Welcome to Fractal Forums

vec3 normal(vec3 pos, float normalDistance) {
	normalDistance = max(normalDistance*0.5, 1.0e-7);
	vec3 e = vec3(0.0,normalDistance,0.0);
	vec3 n = vec3(DE(pos+e.yxx)-DE(pos-e.yxx),
		DE(pos+e.xyx)-DE(pos-e.xyx),
		DE(pos+e.xxy)-DE(pos-e.xxy));
	n = normalize(n);
	return n==n ? n : vec3(0.0);
}

		c+=BloomIntensity*pow(b.xyz,vec3(BloomPow));

//Pseudo Knightyan by eiffie 
//Original shader: https://www.shadertoy.com/view/lls3Wf

#include "Progressive2D.frag"
uniform float time;
vec3 iResolution = vec3(1.0/pixelSize.x, 1.0/pixelSize.y, 1.0);

vec3 mcol=vec3(-1.0);
mat2 rmx;
int rotater=-1;
float DE(vec3 p){//knighty's pseudo kleinian
	const vec3 CSize = vec3(0.63248,0.78632,0.875);
	float DEfactor=1.;
	for(int i=0;i<5;i++){
		if(i==rotater)p.xy=p.xy*rmx;
		p=2.*clamp(p, -CSize, CSize)-p;
		float k=max(0.70968/dot(p,p),1.);
		p*=k;DEfactor*=k;
	}
	if(mcol.r>=0.0)mcol+=abs(p);
	float rxy=length(p.xy);
	return max(rxy-0.92784, abs(rxy*p.z) / length(p))/DEfactor;
}
vec3 Normal(in vec3 p, in float px){
	vec2 v=vec2(px*0.1,0.0);
	vec3 n=normalize(vec3(DE(p+v.xyy)-DE(p-v.xyy),DE(p+v.yxy)-DE(p-v.yxy),DE(p+v.yyx)-DE(p-v.yyx)));
	return (n==n)?n:vec3(0.0);
}
float randSeed;
void randomize(vec2 c){randSeed=fract(sin(dot(c,vec2(113.421,17.329)))*3134.1234);}
float rand(){return fract(sin(randSeed++)*3143.45345);}
vec3 path(float tyme){return vec3(cos(tyme),sin(tyme),-0.65+abs(sin(tyme*0.7))*0.25)*(2.0+sin(tyme*1.7)*0.5)+vec3(0.0,0.0,1.0);}
vec4 scene(vec3 ro, vec3 rd, float pathSlider, float tyme, float pxl) {
	randomize(coord.xy+tyme);
	vec3 LP=path(tyme+1.0),p;
	LP.z+=pathSlider;
	ro.z-=pathSlider;
	float d=DE(ro)*0.8,t=d*rand(),nt=d,od=1.0,ft=0.0;//t=totalDist,nt=nextDistForRealDECheck,od=lastDist,ft=fogStepDist
	vec4 col=vec4(0.0,0.0,0.0,1.0);
	vec4 am,tm=vec4(-1.0);//stacks for hit alphas and dists
	for(int i=0;i<99;i++){
		//t+=d=DE(ro+rd*t);if(t>20.0 || d<0.001)break;
		if(nt>t+ft){//prepare for fog step
			p=ro+rd*(t+ft);
			p+=(LP-p)*(-p.z)/(LP.z-p.z);//sample the point on the plane z=0
		}else{//regular march 
			p=ro+rd*t;
		}
		d=DE(p);
		if(nt>t+ft){//step thru the fog and light it up
			float dL=0.05*length(ro+rd*(t+ft)-LP);//how far we step is based on distance to light
			col.rgb+=col.a*vec3(1.0,1.0,0.7)*exp(-dL*40.0)*smoothstep(0.0,0.01,d);
			if(t+ft+dL>nt){
				ft=0.0;
				t=nt;
				if(t>20.0)break;
			}else ft+=dL;
		}else{//save edge samples and march
			if(d<od && tm.w<0.0){
				float alpha=clamp(d/(pxl*t),0.0,1.0); 
				if(alpha<0.95){
					am=vec4(alpha,am.xyz);tm=vec4(t,tm.xyz);
					col.a*=alpha;
				}
			}
			od=d;
			nt=t+d*(0.6+0.2*rand());
		}
	}
	vec3 tcol=vec3(0.0);
	for(int i=0;i<4;i++){//now surface lighting from the saved stack of hits
		if(tm.x<0.0)continue;
		mcol=vec3(0.0);
		p=ro+rd*tm.x;
		vec3 N=Normal(p,pxl*tm.x),L=LP-p,scol;
		mcol=sin(mcol)*0.3+vec3(0.8,0.6,0.4);
		float ls=exp(-dot(L,L)*0.2);
		p+=L*(-p.z)/L.z;
		L=normalize(L);
		scol=ls*mcol*max(0.0,dot(N,L));
		float v=max(0.0,dot(N,-rd));
		scol+=exp(-t)*mcol*v;
		d=smoothstep(0.0,0.005,DE(p));
		scol+=ls*vec3(2.0,2.0,1.7)*max(0.0,dot(N,L))*d;
		if(rd.z<0.0 && d>0.0)scol+=ls*vec3(4.0,3.0,1.4)*pow(max(0.0,dot(reflect(rd,N),L)),5.0)*(1.0-0.25*v)*d;
		tcol=mix(scol,tcol,am.x);
		am=am.yzwx;tm=tm.yzwx;
	}
	col.rgb=clamp(col.rgb+tcol,0.0,1.0);
	return vec4(col.rgb,t);
}
mat3 lookat(vec3 fw){
	fw=normalize(fw);vec3 rt=normalize(cross(fw,vec3(0.0,0.0,1.0)));return mat3(rt,cross(rt,fw),fw);
}

void SetCamera(inout vec3 ro, inout vec3 rd, inout float pathSlider,float tyme, vec2 uv){
	ro=path(tyme);
	vec3 ta=path(tyme+0.2);ta.z+=0.1;
	rd=lookat(ta-ro)*normalize(vec3(uv,1.0));
	tyme=mod(tyme,18.85);
	rmx=mat2(cos(tyme),sin(tyme),-sin(tyme),cos(tyme));
	rotater=5-int(tyme/3.1416);
	pathSlider=1.0;
	if(rotater==0)pathSlider=cos((tyme-15.707)*2.0);
}


vec3 color(vec2 J) 
{
	vec2 uv=(J.xy-iResolution.xy)/iResolution.y;
	vec3 ro,rd;
	float pathSlider;
	SetCamera(ro,rd,pathSlider,time*0.125,uv);
	vec4 scn=scene(ro,rd,pathSlider,time*0.125,3.0/iResolution.y);
	return scn;
}

#preset default
Gamma = 2.08335
Brightness = 1
Contrast = 1
Saturation = 1
Center = 485.794,592.973
Zoom = 0.00228831
ToneMapping = 1
Exposure = 1
AARange = 2
AAExp = 1
GaussianAA = true
#endpreset

//wind direction
uniform vec3 WindDir; slider[(-1.0,-1.0,-1.0),(0.0,0.0,1.0),(1.0,1.0,1.0)]
//wind speed
uniform float WindSpeed; slider[0.0,1.0,2.0]

vec3 ro=p0,rd=normalize(p1-p0),cloudDir=normalize(HF_Dir);

vec3 ro=p0 + (WindSpeed*(WindDir*time)),rd=normalize(p1-p0),cloudDir=normalize(HF_Dir);

#define USE_IQ_CLOUDS
uniform float time;

#include "DE-Kn2.frag"

float rand(vec3 co){// implementation found at: lumina.sourceforge.net/Tutorials/Noise.html
	return fract(sin(dot(co*0.123,vec3(12.9898,78.233,112.166))) * 43758.5453);
}

return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);

	return fract(sin(dot(co*0.123,vec3(12.9898,78.233,112.166))) * 43758.5453);

	return fract(sin(dot(co,vec3(12.9898,78.233,112.166))) * 43758.5453);

float stepFactor = clamp((fSteps)/float(GlowMax),0.0,1.0);

float ao = AO.w*stepFactor ;

		if (DetailAO<0.0) ao = ambientOcclusion(hit, hitNormal);

float ao = AO.w*stepFactor ;

	if (DetailAO<0.0) ao = ambientOcclusion(hit, hitNormal);

	ao = ambientOcclusion(hit, hitNormal);

      ao = min( ambientOcclusion(hit, hitNormal), AO.w*stepFactor);

return (FG*SpotLight.xyz*SpotLight.w*falloff*(diffuse+ specular)*(1.0+ao)+CamLight.xyz*CamLight.w*(ambient)*(1.-ao))*color;

float DEF2(vec3 p) {
	if (EnableFloor) {
		floorDist = abs(dot(floorNormal,p)-FloorHeight);
		return min(floorDist, DE(p));
	} else {
		return DE(p);
	}
}

Could not create fragment shader: 0(197) : error C7011: implicit cast from "float" to "vec2"
0(197) : error C7011: implicit cast from "float" to "vec2"
0(197) : error C7011: implicit cast from "float" to "vec2"
0(197) : error C7011: implicit cast from "float" to "vec2"
0(788) : error C7623: implicit narrowing of type from "vec3" to "float"

Could not create fragment shader: 0(133) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(134) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(135) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(136) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(137) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(138) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(147) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(148) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(149) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(150) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(151) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(197) : error C7011: implicit cast from "float" to "vec2"
0(197) : error C7011: implicit cast from "float" to "vec2"
0(197) : error C7011: implicit cast from "float" to "vec2"
0(197) : error C7011: implicit cast from "float" to "vec2"
0(256) : warning C7555: 'varying' is deprecated, use 'in/out' instead
0(351) : warning C7533: global variable gl_FragColor is deprecated after version 120
0(788) : error C7623: implicit narrowing of type from "vec3" to "float"

#group KalisetLight
uniform float VolumetricRayStep;slider[0.01,0.1,1.];
uniform float VolumetricDither;slider[0,.01,.2];
uniform int MinDistance;  slider[0,5,50]

uniform float LightRad; slider[0.0,0.0,5.0]
uniform float LightExp; slider[0.0,1.0,5.0]
uniform float LightGlowIntensity; slider[0.0,0.0,1.0]
uniform float LightGlowClear; slider[0.0,0.0,10.0]
uniform float VolumetricShadow; slider[0,0,5] 
uniform float MinLight; slider[0.0,0.0,1.0]

vec3 ptLightGlowK(vec3 from, vec3 pos){
	SRay Ray;
	from+=((rand(dir.xy+vec2(subframe,subframe*1.12358))-.5)*VolumetricDither);
	float kglow=0;	
	int c=0;
	float lf=0;
	float sh=0;
	vec3 col = vec3(0.0);
	if (!lighthit && LightGlowIntensity>0.) {
		for (float r=MinDistance; r<MaxDistance; r+=VolumetricRayStep) {
			vec3 p=from+r*dir;
			//vec3 p = SRCurrentPt(Ray);
			vec3 spotDir1 = normalize(LightPos-Ray.Pos);
			//vec3 lightdir=-lightnormal(p,.01);
			vec3 lightdir=spotDir1;
			float ep=exp(-(LightGlowClear*.01)*r*r);
			float k=max(MinLight,Kaliset(p)*KFinalScale);
			sh=shadow(p,lightdir,minDist*10);
			lf+=k*ep*clamp((1-sh),VolumetricShadow,1.);
			c++;
		}
	}
	lf=max(0,lf);
	lf*=VolumetricRayStep;
	lf*=LightGlowIntensity*5;	
	float glow1=exp(-pow(1/LightRad,4)*pow(kglow,LightExp));
	float glow2=exp(-10*pow(kglow,1));
	col=SpotLight.xyz*glow1*SpotLight.w*lf+SpotLight.xyz*glow2*SpotLight.w*2;
	return col;
}

col0+=ptLightGlowK(prevPos,curPos);

if (floorHit) {
			hitColor = FloorColor;
			if(EnableFloorPic) {			
				vec3 p = SRCurrentPt(Ray);
				p=rotFloor*p;
				p+=MovTer;
				hitColor += FloorColor+FPicBright*texture2D(tex, p*htexturespeed+htextoff);			
			}
		}

#include "Classic-Noise.frag"
uniform int FloorIter1;  slider[0,3,50]
uniform float FreqMul1; slider[1,2,10]
uniform float AmpMul1; slider[0,0.3,1]
uniform float Offset1; slider[0,0.4,1]

uniform int FloorIter2;  slider[0,3,50]
uniform float FreqMul2; slider[1,2,10]
uniform float AmpMul2; slider[0,0.3,1]
uniform float Offset2; slider[0,0.4,1]

uniform vec2 Period; slider[(0,0),(1,1),(1,1)]
uniform vec3 off1; slider[(-10,-10,-10),(1,1,1),(10,10,10)]

float water(vec3 pos) {
	float A = 1.0;
	float B = 1.0;
	float C = 1.0;
	float D = 1.0;
	float r = 0.0;
	for (int i = 0; i < FloorIter1; i++) {
		r+= B*cnoise(A*(pos.xy)+Offset1);
		A*=FreqMul1;
		B*=AmpMul1;
	}
	for (int j = 0; j < FloorIter2; j++) {
		r+= D*pnoise(C*(pos.xy)+Offset2, Period);
		C*=FreqMul2;
		D*=AmpMul2;
	}
	return r;
}

float height(vec3 pos) {
pos*=off1;
return water(pos);
}

vec3 BlendLinearLightf(vec3 base, vec3 blend) {
	return (blend < vec3(.5))?BlendSubstractf(base,(2.0*blend)):BlendAddf(base,(2.0*(blend - 0.5)));
}

ERROR: 2:317: '<' :  wrong operand types  no operation '<' exists that takes a left-hand operand of type 'in 3-component vector of float' and a right operand of type 'const 3-component vector of float' (or there is no acceptable conversion)

vec4 clouds(vec3 p0, vec3 p1){

       ....

// add fog anisotropy to clouds 3Dickulus 05/14/16
#ifdef KN_VOLUMETRIC
for(int j=0;j<HF_FogIter;j++) sum.xyz+=(ptLightGlow3(ro, p1)*(1./float(HF_FogIter)));
#endif

        return clamp(sum,0.0,1.0);
}

uniform sampler2D BG; file[tex.jpg]
//............
vec3 p=SRCurrentPt(Ray);
backColor += equirectangularMap(BG, Ray.Origin-p);

vec3 TerrainColour(vec3 pos, vec3 normal) {
	vec4 tm1=vec4(0.0); 
	vec4 tm2=vec4(0.0);
	if (normal.z < tex_normal) {
	tm1 = texture2D(tex1, pos.xy);
	}
	if (normal.z > tex_normal) {
	tm2 = texture2D(tex2, pos.xy);
	}
return tm1.rgb + tm2.rgb;
}

vec3 TerrainColour(vec3 pos, vec3 normal)
{
	vec3 mat=vec3(0.0);
	vec4 tm1=vec4(0.0);
	vec4 tm2=vec4(0.0);
	vec4 tm3=vec4(0.0);

// 	if (normal.z < tex_normal) {
	tm1 = texture2D(tex1, pos.xy*tex1size);
// 	}
// 	if (normal.z > tex_normal) {
	tm2 = texture2D(tex2, pos.xy*tex2size);
//        }

	return mix(tm1.rgb,tm2.rgb,normal.z*tex_normal).rgb; // + tm3;
}

float smin(float a, float b, float k) {
    float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
    return mix(b, a, h) - k * h * (1.0 - h);
}

vec3 smin( vec3 a, vec3 b, vec3 k)
{
vec3 h = clamp( 0.5 + 0.5*(b-a)/k, 0.0, 1.0 );
return mix( b, a, h ) - k*h*(1.0-h);
}

		if (hitNormal == vec3(0.0) || dot(RWeight,RWeight)<0.0001 || lighthit || Ray.Pos>=MaxDistance) {//nothing hit or light hit or reflected light is too small
			break; 
		}

... dot(RWeight,RWeight)<0.0001 ...

colfogglow+=ptLightGlow1(prevPos, curPos);

#ifdef KN_VOLUMETRIC
		if(HF_Scatter*(HF_Intensity+HF_Const)>0.){ 
			vec3 colfogglow=vec3(0.);
			for(int j=0;j<HF_FogIter;j++) {
				colfogglow+=ptLightGlow1(prevPos, curPos);
				colfogglow+=ptLightGlow3(prevPos, curPos);
			}
			col0+=colfogglow*1./float(HF_FogIter);//ptLightGlow1(prevPos, curPos);
		}
#endif

				colfogglow+=ptLightGlow1(prevPos, curPos);
				colfogglow+=ptLightGlow1(prevPos, curPos);
				colfogglow+=ptLightGlow3(prevPos, curPos);

#ifdef KN_VOLUMETRIC
		if(HF_Scatter*(HF_Intensity+HF_Const)>0.){ 
			fogstrata=0;// <<<---- ADD THIS
			vec3 colfogglow=vec3(0.);
			for(int j=0;j<HF_FogIter;j++) colfogglow+=ptLightGlow3(prevPos, curPos);
			col0+=colfogglow*1./float(HF_FogIter);//ptLightGlow1(prevPos, curPos);
		}
#endif