case, laboratori e luoghi di culto per le Creature di Silicio; le nere costole e gli archi scolpiti di questi labirinti rivelano l'oscurità delle menti dei loro creatori. I Labirinti di Silicio contengono corridoi bio-ingegnerizzati appiccicosi, macchinari organici e porte che assomigliano a reti o orifizi pieni di denti. Basta dire, che nessuno, a parte le Creature di Silicio, si avventura deliberatamente in uno di questi Labirinti, e gli R-Human che ne vengono catturati all'interno raramente riescono a tornare indietro. I Guerrieri di Silicio hanno maggiore protezione contro gli attacchi di hacking da parte degli intrusi e hanno a disposizione nanoparticelle ambientali rigeneranti progettate per ripristinare rapidamente le loro ferite. Questi covi sono generalmente ben nascosti dall'esterno e sono pieni di Folletti di Silicio e Biocritter.

#ifdef GL_ES
precision mediump float;
#endif

void mainImage(out vec4 fragColor, in vec2 fragCoord) {

 
    vec2 uv=(fragCoord.xy*2.-iResolution.xy)/min(iResolution.x,iResolution.y); 
     
    vec2 huv=uv;
    float lines=197.0;
    uv.x=floor(uv.x*lines)/lines;
    uv.y=floor(uv.y*lines)/lines;   //192 lines vec3 finalColor=vec3(1);
    vec3 finalColor=vec3(0);

    float y=uv.y;

    float x=uv.x+floor(iTime*lines/9.)/lines;
    
    
    float w1=smoothstep(0.81,0.85,cos(x*20.)*1.2+cos(x*2.)*1.0+cos(y*2.+.1));
    w1+=smoothstep(0.81,0.85,cos(x*20.+3.)*1.2+cos(x*2.+3.)*1.0+cos(y*2.-1.)-1.);
  
    x=uv.x+floor(iTime*lines/8.)/lines;
    
    float w2=smoothstep(0.81,0.85,cos(x*20.)*1.1+cos(x*20.)*0.7+cos(y*5.+.1)*1.1);
    w2+=smoothstep(0.81,0.85,cos(x*20.+3.)*0.7+cos(x*20.+3.)*1.0+cos(y*4.-1.)*1.0-1.);
  
    x=uv.x+floor(iTime*lines/10.)/lines;
    
    
    float w3=smoothstep(0.81,0.85,cos(x*20.)*1.1+cos(x*32.)*0.7+cos(y*6.+.1)*1.1);
    w3+=smoothstep(0.81,0.85,cos(x*20.+3.)*0.7+cos(x*32.+3.)*1.0+cos(y*5.-1.)*1.0-1.);


    
    float g1=0.9;  // erbacce
    float l1=0.9;  // fronde degli alberi
    
   
    float g2=0.9;  // erbacce medio
    float l2=0.9;  //fronde medio
    

    float g3=0.9;  // erbacce sfondo
    float l3=0.9;  //fronde sfondo
    
    vec2 pos=vec2(cos(iTime*0.41),sin(iTime*0.51)*.3);
    pos=floor(pos*lines)/lines;
    float s1=smoothstep(0.04,0.0,length(pos+uv));
    pos=vec2(cos(1.+iTime*0.31),sin(iTime*0.52)*.3);
    pos=floor(pos*lines)/lines;
    float s2=smoothstep(0.04,0.0,length(pos-uv));
    
    float c;
    
    
    // elimina tutto
    c=w3*g3*l3;finalColor=clamp(vec3(0.7,0.8,1.0)+c,0.0,1.);
    
    
    // alberi intermedi
    c=w2*g2*l2;finalColor=min(clamp(vec3(0.4,0.5,0.7)+c,0.0,1.0),finalColor);
    
    
    // Lucciole
    c=s1;finalColor+=c*vec3(0.0,0.,1.0);
    c=s2;finalColor+=c*vec3(0.0,0.,0.);
    c=s1;finalColor+=2.*c*c*vec3(1)*abs(sin(iTime*50.));
    c=s2;finalColor+=c*c*vec3(1)*abs(cos(iTime*50.));
    
    c=w1*g1*l1;finalColor*=vec3(0.7,0.0,0.0)*c;

    fragColor = vec4(finalColor.gbr,1);

}






// rework of this https://glslsandbox.com/e#80649.0
#ifdef GL_ES
precision mediump float;
#endif

//uniform float iTime;
//uniform vec2 iResolution;
#define PI 3.14159265358979

vec3 color = 0.3*vec3(1.0,0.7,0.3);
float d2y(float d){return 1./(0.5+d)*sin(iTime/7.);}
float radius = 0.95;

float rad(float radius) {

     return radius*sin(iTime);
}

float fct(vec2 p, float r){
    float a = 0.2*mod((p.y, p.x)+sin(0.)*2.+sin(1.)*2., 2.*PI);    
    float scan = 0.*9.;
    return (d2y(a)+scan)+(1.-step((radius*+0.5),r));
}

    
float circle(vec2 p, float r){
    float d=distance(r, radius*+0.5);
    return d2y(35.*d);
}


void mainImage( out vec4 fragColor, in vec2 fragCoord ) {
    
    vec2 position = (( fragCoord.xy )-0.5*iResolution.xy)/ iResolution.y;
    position/=cos(.0*length(position));
    float y  = 0.0;
    
    float dc = length(position);
    
    y+=fct(position, dc);
    y+=circle(position, dc);
    y=pow(y,4.90);
    fragColor = vec4( sqrt(y)*color,1. );
}




HackNoise - KodeLife + Angus Young;
da una rielaborazione di questo GLSL Shader : https://glslsandbox.com/e#79369.0

// rework of this GLSL Shader : https://glslsandbox.com/e#79369.0

#ifdef GL_ES
precision lowp float;
#endif

const float n = 5.1;
const float s = 7.3;

float Hack( vec2 p, in float s)
{
    vec3 p2 = vec3(p.xy,17.3 * abs(sin(s)));
    return fract(sin(dot(p2,vec3(17.3,61.7, 12.4)))*173713.1);
}


float HackNoise(in vec2 p, in float s)
{
    vec2 i = floor(p);
    vec2 f = fract(p);
    f *= f * (3.0-2.0*f);
  
    return mix(mix(Hack(i + vec2(0.,0.), s), Hack(i + vec2(1.,0.), s),f.x),
               mix(Hack(i + vec2(0.,1.), s), Hack(i + vec2(1.,1.), s),f.x),
               f.y) * s;
}


float Thunder(vec2 p, vec3 spec)
{  
    float v = - HackNoise(p * 02., 0.25);
    v += HackNoise(p * 01.1, 0.5) - HackNoise(p * 01.1, 0.25);
    v += HackNoise(p * 02.1, 0.25) - HackNoise(p * 02.1, 0.125);
    v += HackNoise(p * 04.1, 0.125)*spec.x*1. - HackNoise(p * 08.1, 0.0625);
    v += HackNoise(p * 08.1, 0.0625) - HackNoise(p * 16., 0.03125)*spec.y*1.;
    v += HackNoise(p * 16.1, 0.03125);
    return v*1.2;
}


void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    float WhoMadeWho = (iTime * s) + 1000.0;
    vec2 p = fragCoord.xy / iResolution.yy;
    vec2 q = fragCoord.xy / iResolution.yy;
    
    int tx = int(p.x*128.0);
    
    float wave = texelFetch( iChannel0, ivec2(tx,1), 0 ).x;
    vec3 spec = vec3(wave/1.0);

    vec2 uv = ( gl_FragCoord.xy / iResolution.xy ) * 2.0 - 1.0;
    uv.y *= iResolution.y/iResolution.x;
  
    vec3 finalColor = vec3( 0.0, 0.0, 0.0 );
    for( float i = 1.0; i < n; i++ )
    {
        float t = abs(4.0 / ((uv.y + Thunder( uv + WhoMadeWho / i , spec)) * (i * 100.0)));
        finalColor +=  t * vec3( i * 0.1*spec.x*2., 0.2, 1.30 );
    }
    
    fragColor = vec4( finalColor, 1.0 );   
}

 





ShaderToy

Image

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
vec2 p = fragCoord / iResolution.x;
vec4 col = texture(iChannel0, p);
fragColor = vec4(col.rgb, 1.);
}

BufferA

float distanceToSegment( vec2 a, vec2 b, vec2 p )

{
vec2 pa = p - a, ba = b - a;
float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );
return length( pa - ba*h );
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )

{

vec2 p = fragCoord / iResolution.xy;
vec2 cen = 0.5*iResolution.xy/iResolution.x;
vec4 m = iMouse / iResolution.x;
float i;
vec3 col;

col=vec3(0.0,0.0,0.0);

vec3 rgb_previous = vec3(texture( iChannel0 , p ).xy,0.0);

if (iFrame!=0) {
col = rgb_previous*0.5;
};

float d = distanceToSegment( m.xy, abs(m.zw), p );
col += mix( col, vec3(1.0,0.0,0.0), 1.0-smoothstep(.003,0.035, d) );
fragColor = vec4( col, 1.0 );

}




Abbiamo condannato il lupo non per quello che è, ma per quello che abbiamo deliberatamente ed erroneamente percepito che fosse - l'immagine mitizzata di uno spietato assassino selvaggio - Che, in realtà, non è altro che l’immagine riflessa di noi stessi.




"In your light I learn how to love. In your beauty, how to make poems. You dance inside my chest where no-one sees you, but sometimes I do, and that sight becomes this art." Rumi

precision mediump float;

vec2 rotate(vec2 v, float a) {
float s = sin(a);
float c = cos(a);
mat2 m = mat2(c, -s, s, c);
return m * v;
}

#define MAX 10.0
#define NUM_LAYERS 4.

mat2 rot(float angle){
float s=sin(angle),c=cos(angle);
return mat2(c,-s,s,c);
}

float hash21(vec2 p){
p=fract(p*vec2(52.34,5.21));
p+=dot(p,p+45.32);
return fract(p.x*p.y);
}

float star(vec2 uv,float flare){
float d=length(uv);
float m=.04/d;
float rays=max(0.,1.-abs(uv.x*uv.y*1000.));
m+=rays*flare;
uv*=rot(3.1415/4.);
rays=max(0.,1.-abs(uv.x*uv.y*1000.));
m+=rays*.3*flare;
m*=smoothstep(1.,.2,d);
return m;
}

vec3 universe(vec2 uv){
vec3 col=vec3(0);
vec2 gv=fract(uv)-.5;
vec2 id=floor(uv);
for(int y=-1;y<=1;y++){
for(int x=-1;x<=1;x++){
vec2 offs=vec2(x,y);
float n=hash21(id+offs);// random [0,1]
float size=fract(n*354.32);
float st=star(gv-offs-vec2(n,fract(n*34.))+.5,smoothstep(.9,1.,size)*.6);
vec3 color=sin(vec3(1.3392,.2882,.0988))*.8+.5;
st*=sin(iTime*3.+n*6.2831)*.5+1.;
col+=st*size*color;
}
}
return col;
}

void mainImage( out vec4 fragColor, in vec2 fragCoord ){

int j = 0;

//vec2 p = (fragColor.xy * 2.0 - iResolution) / min(iResolution.x, iResolution.y);
vec2 p = (fragCoord.xy*2.0 - iResolution.xy) / min(iResolution.x, iResolution.y);

//p = p*0.1. ;
p = rotate (p, 1.6);

vec2 x = p + vec2(-0.3, -0.1);
float y = 1.5;
vec2 z = vec2(0.0, 0.0);

for(int i = 0; i < 360; i++){
j++;
if(length(z) > 1.0) {break;}
z = vec2(z.x * z.x - z.y * z.y, 2.0 * (sin(iTime*6.7)*0.3+1.) * z.x * z.y) + x * 0.4* y;
}

vec3 rgb = vec3(0.2,0.0,0.0);

for(float i=0.;i<1.;i+=1./NUM_LAYERS){
float depth=fract(i+iTime);
float scale=mix(20.,.5,depth);
float fade=depth*smoothstep(1.,0.9*abs(sin(iTime)),depth);
rgb+=universe(p*rot(iTime*sin(i*30.))*scale+i*453.2)*fade;
}

float t = float(j) / 130.0 ;

fragColor = vec4(rgb * t , 1.0);

}




link ShaderToy : https://www.shadertoy.com/view/WddGWN

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{

 
    float x = fragCoord.x;
    float y2 = fragCoord.y;
 
    vec2 p = fragCoord.xy / iResolution.yy;
    vec2 q = fragCoord.xy / iResolution.yy;
 
    vec2 translate = vec2(cos(iTime),sin(iTime));
    vec2 translate2 = vec2(sin(iTime),cos(iTime));
 
 
    if (sin(iTime)>0.)
    p += translate*1.35*fract(sin(iTime)*1.0);
    else
    p += translate2*1.35*fract(sin(iTime)*1.0);
 
    vec2 pix = fragCoord.xy*p;
    vec3 col = texture(iChannel0,floor(pix/17.0)*8.0/iResolution.xy).rgb;
    vec3 col2 = texture(iChannel2, floor(pix/8.0)*8.0/iResolution.xy).rgb;
    vec3 col3 = texture(iChannel1, floor(pix/8.0)*8.0/iResolution.xy).rgb;

    fragColor = vec4(0.1+col3.x+col.x*tan(iTime)+col2.x*1.8,0.3+col3.y+col2.y+col.y*cos(iTime),0.3+col3.z+col.z*sin(iTime)+col2.z,1);
 
}




#define PERIOD 2.
#define REPETITIONS 2

const float PI = 3.1415926535;


float box(in vec2 _st, in vec2 _size){
    _size = vec2(0.5) - _size*0.5;
    vec2 uv = smoothstep(_size,
                        _size+vec2(0.001),
                        _st);
    uv *= smoothstep(_size,
                    _size+vec2(0.001),
                    vec2(1.0)-_st);
    return uv.x*uv.y;
}

float cross2(in vec2 _st, float _size){
    return  box(_st, vec2(_size,_size/4.)) +
            box(_st, vec2(_size/4.,_size));
}

vec3 shadeBlob(vec2 p, float index, float value, float scale)
{
    float screenRatio = iResolution.x / iResolution.y;
    vec2 pc = vec2(0.1 + (screenRatio - 0.2) * value, index);
   
    float d = length(pc - p) / 0.015*scale/0.3;
   
    return vec3(3. * vec3(0.2, 0.5, 0.7) / (max(d * d, 1.)));
}

float step_interp(float x) {
    return step(0.5, x);
}

float linear_interp(float x) {
    float c = clamp(x, 0., 1.);
   
    return c;
}

float cosine_interp(float x) {
    float c = clamp(x, 0., 1.);
   
    return 0.5 * (1. - cos(PI * c));
}

float smoothstep_interp(float x) {
//    return smoothstep(0., 1., x);

    float c = clamp(x, 0., 1.);
   
    return c * c * (3. - 2. * c);
}

float quintic_interp(float x) {
    float c = clamp(x, 0., 1.);
   
    return c * c * c * ((6. * c - 15.) * c + 10.);
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    vec2 p = fragCoord.xy / iResolution.yy;
    vec2 q = fragCoord.xy / iResolution.yy;
   
    int tx = int(p.x*128.0);
   
    // per lo Spectrum Audio
    float wave = texelFetch( iChannel0, ivec2(tx,1), 0 ).x;
    vec3 spec = vec3(wave);
   
    vec2 translate = vec2(cos(iTime),sin(iTime));
    vec2 translate2 = vec2(sin(iTime),cos(iTime));
    p += translate*0.35*sin(iTime);
    q += translate2*1.35*sin(iTime);
   
    float t = abs(2. * fract(iTime / PERIOD) - 1.);
    //int sel = int(6. * fract(time / (float(REPETITIONS) * PERIOD) / 6.));
    int sel = 5;
   
    // Background pattern
   
    vec3 col = vec3(0.0 + 0.000 * mod(floor(p.x * 10.0) + floor(p.y * 10.0), 2.0));
    vec3 col2 = vec3(0.0 + 0.000 * mod(floor(q.y * 5.0) + floor(q.x * 5.0), 2.0));
    //vec3 col = vec3(0.0,0.0,0.0,0.0));
   
   
    col += shadeBlob(p, 0.1, smoothstep_interp(t)*spec.x+0.5, wave/3.0);
    col2 += shadeBlob(q, 0.3+spec.z, linear_interp(t)*spec.y+0.5, wave/3.0);
    col += shadeBlob(p, 0.5+spec.x, cosine_interp(t)*spec.z+0.7, wave/3.0);
    col2 += shadeBlob(q, 0.7, smoothstep_interp(t)*spec.z+0.1, wave/3.0);
    col += shadeBlob(p, 0.9-spec.y, quintic_interp(t)*spec.z+0.3, wave/3.0);
   
   
    col = pow(col, vec3(0.45));
    col2 = pow(col2, vec3(0.45));
   
    fragColor = vec4(col+col2, 1.0);
}





// This is a rework of https://www.shadertoy.com/view/lsfGzr,
// created by @paulofalcao, with sound, by Radical Ed
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License


#define time iTime

float makePoint(float x,float y,float fx,float fy,float sx,float sy,float t, float w){
   float xx=x+sin(t*fx)*sx*tan(fx*t)*log(fx*t);
   float yy=y+cos(t*fy)*sy*tan(fy*t)*log(fy*t);
   return 5.0*abs(sin(25.0*t/337.0))/sqrt(xx*xx+yy*yy)+log(w/4.0);
}

void mainImage( out vec4 fragColor, in vec2 fragCoord ) {

   vec2 p=(fragCoord.xy/iResolution.x)*2.0-vec2(1.0,iResolution.y/iResolution.x);


 
   // create pixel coordinates
   vec2 uv = fragCoord.xy / iResolution.xy;

   // the sound texture is 512x2
   int tx = int(uv.x*512.0);
 

   // second row is the sound wave, one texel is one mono sample
   float wave = texelFetch( iChannel0, ivec2(tx,1), 0 ).x;
 
   vec2 translate = vec2(cos(iTime),sin(iTime));
 
 
 
   p=p*7.0*abs(sin(iTime));
   p += translate*1.35*sin(iTime);
 
   float x=p.x;
   float y=p.y;
 
   vec3 col = vec3( 0.0, 0.0, 0.0);

    // add wave form on top
   //col += smoothstep( 0.0, 0.15, abs(wave- uv.x)/2.0 );
 
    //if (wave > 0.4) { wave = 0.4 ;}
 

   float a=
   makePoint(x + col.x,y + col.y,2.0,2.9,0.3,0.3,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.9,2.0,0.4,0.4,time, wave);
   a=a+makePoint(x + col.x,y + col.y,0.8,0.7,0.4,0.5,time, wave);
   a=a+makePoint(x + col.x,y + col.y,2.3,0.1,0.6,0.3,time, wave);
   a=a+makePoint(x + col.x,y + col.y,0.8,1.7,0.5,0.4,time, wave);
   a=a+makePoint(x + col.x,y + col.y,0.3,1.0,0.4,0.4,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.4,1.7,0.4,0.5,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.3,2.1,0.6,0.3,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.8,1.7,0.5,0.4,time, wave);
   
 
   float b=
   makePoint(x + col.x,y + col.y,1.2,1.9,0.3,0.3,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,2.7,0.4,0.4,time, wave);
   b=b+makePoint(x + col.x,y + col.y,1.4,0.6,0.4,0.5,time, wave);
   b=b+makePoint(x + col.x,y + col.y,2.6,0.4,0.6,0.3,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,1.4,0.5,0.4,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,1.7,0.4,0.4,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.8,0.5,0.4,0.5,time, wave);
   b=b+makePoint(x + col.x,y + col.y,1.4,0.9,0.6,0.3,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,1.3,0.5,0.4,time, wave);
 

   float c=
   makePoint(x + col.x,y + col.y,3.7,0.3,0.3,0.3,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.9,1.3,0.4,0.4,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.8,0.9,0.4,0.5,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.2,1.7,0.6,0.3,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.3,0.6,0.5,0.4,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.3,0.3,0.4,0.4,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.4,0.8,0.4,0.5,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.2,0.6,0.6,0.3,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.3,0.5,0.5,0.4,time, wave);
 
 
   vec3 d=vec3(a,b,c)/22.0;
 
 
   fragColor = vec4(d.x*2.0,d.x,d.x,1.0);
}