Login
Username:

Password:

Remember me



Lost Password?

Register now!

Sections

Who's Online
92 user(s) are online (67 user(s) are browsing Forums)

Members: 0
Guests: 92

more...

Support us!

Recent OS4 Files
OS4Depot.net

Report message:*
 

Re: Warp3DNova shader bugs thread

Subject: Re: Warp3DNova shader bugs thread
by kas1e on 2020/5/30 17:38:22

@All
Another rendering issue which i find in some shaders, can be called as "colors swapped or reverted". I think (i hope) it can be roots of one single issue, so maybe worth to check them all at the same time. For all images press open in new tab for fullsize. So:

Shader #1:

https://www.shadertoy.com/view/tdjfRt

#define S(a, b, t) smoothstep(a, b, t)

float createTaperBox(vec2 pointfloat bottomWidthfloat topWidthfloat yBottomfloat yTopfloat blur) {
    
// Bottom edge    
    
float m S(-blurblurpoint.yBottom);
    
// Top edge
    
*= S(blur, -blurpoint.yTop);
    
// Sides, mirrored
    
point.abs(point.x);
    
    
float w mix(bottomWidthtopWidth, (point.yBottom) / (yTop yBottom));
    
*= S(blur, -blurpoint.w);
    
    return 
m;
}

vec4 createTree(vec2 uvvec3 colorfloat blur) {
    
    
// --- Trunk ---
    
float m createTaperBox(uv0.030.03, -0.050.25blur);
    
// --- Canopy 1 ---
    
+= createTaperBox(uv0.20.10.250.5blur);
    
// --- Canopy 2 ---
    
+= createTaperBox(uv0.150.050.50.75blur);
    
// --- Top ---
    
+= createTaperBox(uv0.10.00.751.0blur);
    
    
float shadow createTaperBox(uv vec2(0.20.0), 0.10.50.150.25blur);
    
shadow += createTaperBox(uv vec2(0.250.0), 0.10.50.450.5blur);
    
shadow += createTaperBox(uv vec2(0.20.0), 0.10.50.70.75blur);
    
color -= shadow 0.8;
    
//m = 1.0;
    
    
return vec4(colorm);
}

float GetHeight(float x) {
    return 
sin(0.435) + sin(x) * 0.3;
}

vec4 createLayer(vec2 uvfloat blur) {
    
vec4 color vec4(0.0);
    
    
float id floor(uv.x);
    
float n fract(sin(id 256.12) * 6854.3) * 2.0 1.0;
    
float x 0.3;
    
float y GetHeight(uv.x);
    
    
// Ground
    
float ground S(blur, -bluruv.y);
    
color += ground;
    
    
GetHeight(id 0.5 x);
    
    
uv.fract(uv.x) - 0.5;
    
vec4 tree createTree((uv vec2(x, -y)) * vec2(1.01.0 0.25), vec3(1.0), blur);
    
    
color mix(colortreetree.a);
    
color.max(groundtree.a);
    return 
color;
}

float Hash21(vec2 point) {
    
point fract(point vec2(1462.341026.75));
    
point += dot(pointpoint 864.23);
    
    return 
fract(point.point.y);
}

void mainImageout vec4 fragColorin vec2 fragCoord )
{
    
// Normalized pixel coordinates (from 0 to 1)
    // Move origin to the center
    
vec2 uv = (fragCoord 0.5 iResolution.xy) / iResolution.y;
    
vec2 mouse = (iMouse.xy iResolution.xy) * 2.0 1.0;
    
float time iTime 0.3;
    
    
    
//uv.x += iTime * 0.1;
    //uv.y += 0.5;
    //uv *= 5.0;
    
    
float blur 0.005;
    
    
// Initialize color
    
vec4 color vec4(0.0);
    
vec4 layer;
    
    
color *= 0.0;
    
float twinkle dot(length(sin(uv time)), length(cos(uv vec2(22.06.7) - time 3.0)));
    
twinkle sin(twinkle 10.0) * 0.5 0.5 4.5;
    
    
float dawn S(-0.750.4, -uv.y);
    
    
float stars pow(Hash21(uv), 60.0 twinkle);
    
color += stars;
    
color.rgb -= vec3(0.50.90.1);
    
color += dawn;
    
    
//float moon = S(0.01, -0.01, length(uv + vec2(-0.65, -0.275)) - 0.1);
    
float moon S(0.0075, -0.0035length(uv vec2(0.470.29)) - 0.1);
    
moon *= S(-0.0750.005length(uv vec2(0.430.325)) - 0.175);
    
color.rgb += vec3(0.6);
    
color += moon;
    
    for (
float i 0.01.0+= 1.0 7.0) {
        
float scale mix(10.01.0i);
        
blur mix(0.020.005i);
        
layer createLayer(uv scale vec2(time 50.0i) - mouseblur);
        
layer.rgb *= (1.0 i) * vec3(0.30.51.0) * 1.2;
        
color mix(colorlayerlayer.a);
    }
    
    
layer createLayer(uv vec2(time 1.0) - mouseblur 3.0);
    
color mix(colorlayer 0.002layer.a);
    
    
float thickness 1.0 iResolution.y;
    
    
    
    
// See axes
    //if (abs(uv.x) < thickness) { color.g = 1.0; }
    //if (abs(uv.y) < thickness) { color.r = 1.0; }

    // Output to screen
    
fragColor color;
}



WIN version:

Resized Image

AOS4 version:

Resized Image


Shader #2:

https://www.shadertoy.com/view/MsjSW3

// Ether by nimitz 2014 (twitter: @stormoid)
// https://www.shadertoy.com/view/MsjSW3
// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// Contact the author for other licensing options

#define t iTime
mat2 m(float a){float c=cos(a), s=sin(a);return mat2(c,-s,s,c);}
float map(vec3 p){
    
p.xz*= m(t*0.4);p.xy*= m(t*0.3);
    
vec3 q p*2.+t;
    return 
length(p+vec3(sin(t*0.7)))*log(length(p)+1.) + sin(q.x+sin(q.z+sin(q.y)))*0.5 1.;
}

void mainImageout vec4 fragColorin vec2 fragCoord ){    
    
vec2 p fragCoord.xy/iResolution.vec2(.9,.5);
    
vec3 cl vec3(0.);
    
float d 2.5;
    for(
int i=0i<=5i++)    {
        
vec3 p vec3(0,0,5.) + normalize(vec3(p, -1.))*d;
        
float rz map(p);
        
float f =  clamp((rz map(p+.1))*0.5, -.11. );
        
vec3 l vec3(0.1,0.3,.4) + vec3(5.2.53.)*f;
        
cl cl*smoothstep(2.5.0rz)*.7*l;
        
+= min(rz1.);
    }
    
fragColor vec4(cl1.);
}


WIN version:

Resized Image

AOS4 version:

Resized Image

Shader #3:

https://www.shadertoy.com/view/WdSBRG

vec4 rainbowDisk(vec2 o) {
    
// the underlying image
    // source: https://www.shadertoy.com/view/XsSfW1 by Flyguy
    
*= max(iResolution.xiResolution.y);
    
+= .5 iResolution.xy;
    
vec4 c;
    
vec2 r iResolution.xy;
    
vec2(length(-= r/2.) / r..3atan(o.y,o.x));    
    
vec4 s c.yzwx .1*cos(1.6*vec4(0,1,2,3) + iTime o.sin(o.y) * sin(iTime)*2.),
    
min(o.x-sc-o.x);
    return 
dot(40.*(s-c), clamp(f*r.y0.1.)) * (s-.1) - f;
}


void mainImageout vec4 fragColorin vec2 fragCoord) {
    
float t iTime;
    
mod(t30.);
    
float res max(iResolution.xiResolution.y);
    
float maxScale res 9.;
    
// zoom in and out
    
float scale mix(
        
4.,  maxScale,
        
smoothstep(2.15.t) - smoothstep(20.30.t)
    );
    
vec2 off vec2(-.2.1);
    
vec2 uv scale * ((fragCoord .5 iResolution.xy) / res off);
    
float pixel scale res;

    
vec2 pixeluv fract(uv);
    
vec2 imguv = (floor(uv)) / maxScale off;
    
    
vec3 colImg rainbowDisk(imguv).rgb;
    
// make the loop seemless
    
colImg mix(
        
// just something to pseudo random
        
fract(vec3(
            
sin(300.123 imguv.300.123 imguv.y),
            
sin(100.521 imguv.250.2 imguv.x),
            
0.4)),
        
colImgsmoothstep(0..1t) - smoothstep(29.930.t));
    
colImg clamp(colImg.1.9);

    
vec3 col vec3(0.);
    
col.smoothstep(
        
pixel0.,
        
max(
            
pixeluv.colImg.r,
            
pixeluv.0.3333333 pixel
        
)
    );
    
col.smoothstep(
        
pixel0.,
        
max(
            
pixeluv.colImg.g,
            
max(pixeluv.0.666666 pixel,
                
0.333333 pixeluv.pixel)
        )
    );
    
col.smoothstep(
        
pixel0.,
        
max(
            
pixeluv.colImg.b,
            
0.666 pixeluv.pixel
        
)
    );
    
col *= smoothstep(
        
0.4. pixel smoothstep(10.1.scale),
        
min(
            
min(pixeluv.y1. pixeluv.y),
            
min(pixeluv.x1. pixeluv.x)
        )
    );
    
fragColor vec4(col1.0);
}


WIN version:

Resized Image

AOS4 version:

Resized Image

Shader #4:

https://www.shadertoy.com/view/tdjBWm

// Fork of "Menger2D" by EvilRyu. https://shadertoy.com/view/MldXz4
// 2020-05-23 02:26:38

// Created by evilryu
// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.

float s=0.95,a=0.006,scale=3.;
float d_box(vec2 q){float d=max(abs(q.x+sin(iTime)*0.01),abs(q.y));return smoothstep(s,s+a,d)+smoothstep(s-a,s-a-a,d);}
float d_sph(vec2 q,float s){float d=pow(pow(abs(q.x),3.0)+pow(abs(q.y),3.5),1./3.);return smoothstep(s,s+a,d)+smoothstep(s-a,s-a-a,d);}
void mainImageout vec4 fragColorin vec2 fragCoord )
{
    
vec2 q = (-iResolution.xy 2.0*fragCoord)/iResolution.y;
    
vec3 col=vec3(1.0);//*d_box(q);
    
float iter mod(floor(iTime),7.0);
    for(
int i=0;i<4;++i)
    {
        if(
i<int(iter+0.5))
        {
            
q=abs(q);
            if(
q.x>q.y)q.xy=q.yx;
            
s*=1.0/scale;
            
col*=d_sph(q,s*(1.+tan(iTime)));
            
q-=s*(scale-(1.+cos(iTime)));
            if(
q.x<-0.5*s*(scale-1.0))q.x+=s*(scale-(1.+sin(iTime)));
        }
        else
        {
            
col*=d_sph(q,fract(iTime)*s/scale);
        }
    }
    
fragColor.xyz=col;
}


WIN version:

Resized Image

AOS4 version:

Resized Image


Shader #5:

https://www.shadertoy.com/view/4dXGR4

// based on https://www.shadertoy.com/view/lsf3RH by
// trisomie21 (THANKS!)
// My apologies for the ugly code.

float snoise(vec3 uvfloat res)    // by trisomie21
{
    const 
vec3 s vec3(1e01e21e4);
    
    
uv *= res;
    
    
vec3 uv0 floor(mod(uvres))*s;
    
vec3 uv1 floor(mod(uv+vec3(1.), res))*s;
    
    
vec3 f fract(uv); f*f*(3.0-2.0*f);
    
    
vec4 v vec4(uv0.x+uv0.y+uv0.zuv1.x+uv0.y+uv0.z,
                    
uv0.x+uv1.y+uv0.zuv1.x+uv1.y+uv0.z);
    
    
vec4 r fract(sin(v*1e-3)*1e5);
    
float r0 mix(mix(r.xr.yf.x), mix(r.zr.wf.x), f.y);
    
    
fract(sin((uv1.uv0.z)*1e-3)*1e5);
    
float r1 mix(mix(r.xr.yf.x), mix(r.zr.wf.x), f.y);
    
    return 
mix(r0r1f.z)*2.-1.;
}

float freqs[4];

void mainImageout vec4 fragColorin vec2 fragCoord )
{
    
freqs[0] = textureiChannel1vec20.010.25 ) ).x;
    
freqs[1] = textureiChannel1vec20.070.25 ) ).x;
    
freqs[2] = textureiChannel1vec20.150.25 ) ).x;
    
freqs[3] = textureiChannel1vec20.300.25 ) ).x;

    
float brightness    freqs[1] * 0.25 freqs[2] * 0.25;
    
float radius        0.24 brightness 0.2;
    
float invRadius     1.0/radius;
    
    
vec3 orange            vec30.80.650.3 );
    
vec3 orangeRed        vec30.80.350.1 );
    
float time        iTime 0.1;
    
float aspect    iResolution.x/iResolution.y;
    
vec2 uv            fragCoord.xy iResolution.xy;
    
vec2 p             = -0.5 uv;
    
p.*= aspect;

    
float fade        powlength2.0 ), 0.5 );
    
float fVal1        1.0 fade;
    
float fVal2        1.0 fade;
    
    
float angle        atanp.xp.)/6.2832;
    
float dist        length(p);
    
vec3 coord        vec3angledisttime 0.1 );
    
    
float newTime1    abssnoisecoord vec30.0, -time * ( 0.35 brightness 0.001 ), time 0.015 ), 15.0 ) );
    
float newTime2    abssnoisecoord vec30.0, -time * ( 0.15 brightness 0.001 ), time 0.015 ), 45.0 ) );    
    for( 
int i=1i<=7i++ ){
        
float power pow2.0float(1) );
        
fVal1 += ( 0.5 power ) * snoisecoord vec30.0, -timetime 0.2 ), ( power * ( 10.0 ) * ( newTime1 1.0 ) ) );
        
fVal2 += ( 0.5 power ) * snoisecoord vec30.0, -timetime 0.2 ), ( power * ( 25.0 ) * ( newTime2 1.0 ) ) );
    }
    
    
float corona        powfVal1 max1.1 fade0.0 ), 2.0 ) * 50.0;
    
corona                += powfVal2 max1.1 fade0.0 ), 2.0 ) * 50.0;
    
corona                *= 1.2 newTime1;
    
vec3 sphereNormal     vec30.00.01.0 );
    
vec3 dir             vec30.0 );
    
vec3 center            vec30.50.51.0 );
    
vec3 starSphere        vec30.0 );
    
    
vec2 sp = -1.0 2.0 uv;
    
sp.*= aspect;
    
sp *= ( 2.0 brightness );
      
float r dot(sp,sp);
    
float f = (1.0-sqrt(abs(1.0-r)))/(r) + brightness 0.5;
    if( 
dist radius ){
        
corona            *= powdist invRadius24.0 );
          
vec2 newUv;
         
newUv.sp.x*f;
          
newUv.sp.y*f;
        
newUv += vec2time0.0 );
        
        
vec3 texSample     textureiChannel0newUv ).rgb;
        
float uOff        = ( texSample.brightness 4.5 time );
        
vec2 starUV        newUv vec2uOff0.0 );
        
starSphere        textureiChannel0starUV ).rgb;
    }
    
    
float starGlow    minmax1.0 dist * ( 1.0 brightness ), 0.0 ), 1.0 );
    
//fragColor.rgb    = vec3( r );
    
fragColor.rgb    vec3* ( 0.75 brightness 0.3 ) * orange ) + starSphere corona orange starGlow orangeRed;
    
fragColor.a        1.0;
}



WIN version:

Resized Image

AOS4 version:

Resized Image


As far as i can see, in all shaders background and color of some objects like swapped. At moment not sure wtf, but probably will be good idea to start from the smallest ones and trying to reduce it, like shader #2 and shader #4

Powered by XOOPS 2.0 © 2001-2016 The XOOPS Project