Real time visualization (GLSL + Processing).

Real time visualization (GLSL + Processing). from Armando Rodriguez on Vimeo.

Visual by José Armando Rodríguez

/// PROCESSING CODE

import punktiert.math.Vec;
import punktiert.physics.*;

PShader Shrtoy;
float t= 0;
int m = 0;
// world object
VPhysics physics;
ArrayList<VParticleString> strings = new ArrayList<VParticleString>();
int numStrings=150;
int radio = 250;
float pastx, pasty, pastz, count = 0;

public void setup() {
smooth();
size(1920, 1080, P3D);
// create world object with bouncing behavior
physics = new VPhysics();
physics.setfriction(.01f);

Shrtoy = loadShader(“warping2.glsl”);
Shrtoy.set(“iResolution”, float(1), float(1));

 

for (int i=0; i<numStrings; i++) {
float anguloA = random(0, 2*PI);
float anguloB = random(0, PI*2);
VParticle particleA = new VParticle((cos(anguloB)*cos(anguloA)*(radio/3)), (sin(anguloB)*sin(anguloA)*(radio/3)), (radio/3)*sin(anguloB));
particleA.isLocked();
particleA.lock();
VParticle particleB = new VParticle(((cos(anguloB)*cos(anguloA))*radio), (sin(anguloB)*sin(anguloA)*radio), radio*sin(anguloB));
// particleB.isLocked();
// particleB.lock();
//create a ParticleString: input: VPhysics, particleA, particleB, resolution, strength
strings.add(new VParticleString(physics, particleB, particleA, .1f, .001f));
physics.addGroup(strings.get(i));
}

//for(int i=0; i<numStrings; i++){
// float anguloA1 = random(0,2*PI);
// float anguloA2 = random(0,2*PI);
// float anguloB1 = random(0,2*PI);
// float anguloB2 = random(0,2*PI);
// float radioR = random(radio/2,radio);
// VParticle particleA = new VParticle((cos(anguloB1)*sin(anguloA1*2)*radioR), (sin(anguloB1*3)*sin(anguloA1)*radioR), radioR*sin(anguloB1));
//// particleA.isLocked();
// VParticle particleB = new VParticle(((-cos(anguloB2)*sin(anguloA2*2))*radioR), (-sin(anguloB2*3)*sin(anguloA2)*radioR), -radioR*sin(anguloB2));
// particleB.isLocked();
// //create a ParticleString: input: VPhysics, particleA, particleB, resolution, strength
// strings.add(new VParticleString(physics, particleB, particleA, .1f, .02f));
// physics.addGroup(strings.get(i));
// }

//BAttractionLocal(float radius, float strength)
physics.addBehavior(new BAttractionLocal(600, 300));
physics.addBehavior(new BCollision());
// physics.addBehavior(new BSeparate(600));
physics.addBehavior(new BCohesion() );
}

public void draw() {

Shrtoy.set(“iGlobalTime”, t / 1000.0);
float dato = map(mouseX, width, height, 0, 3);
float dato2 = map(mouseY, width, height, 0, 1);
Shrtoy.set(“mouseX”, dato);
Shrtoy.set(“mouseY”, dato2);
filter(Shrtoy);
t=frameCount*40*dato;
if (key == ‘s’ || key == ‘S’) {
saveFrame(“shader-######.png”);
}
noStroke();
fill(190);
//rect(0,0,width,height);
// background(#75BECB);
float sp = 0.02 * frameCount;
camera( 500 *cos(sp), 500, 500*sin(sp), 0, 0, 0, 0, 0, -1);
stroke(30);
strokeWeight(0.3);
physics.update();
sphereDetail(20);
for (VSpring s : physics.springs) {
m += 0.01;
//line(s.a.x, s.a.y, s.a.z, s.b.x, s.b.y, s.b.z);
pushMatrix();
translate(s.a.x, s.a.y, s.a.z);
sphere(int(20 * (sin(m)+1)));
//sphere(20);
popMatrix();
}
// saveFrame(“screen-####.jpg”);
if (key == ‘s’ || key == ‘S’) {
saveFrame(“shader-######.png”);
}
}

 

//GLSL CODE (save as warping2.glsl in your sketch’s data folder). SHADER REFERENCE http://www.iquilezles.org/www/index.htm

uniform vec2 iResolution;
uniform float iGlobalTime;
uniform float mouseX;
uniform float mouseY;
const mat2 m = mat2( 0.90, 0.70, -0.70, 0.90 );

float noise( in vec2 x )
{
return sin(1.3*x.x)*cos(1.3*x.y)*cos(1.5*x.y)*sin(sin(1.6*x.x));
}

float fbm4( vec2 p )
{
float f = 0.0;
f += 0.5000*noise( p ); p = m*p*mouseX;
f += 0.2500*noise( p ); p = m*p*mouseX;
f += 0.1250*noise( p ); p = m*p*mouseX;
f += 0.0625*noise( p );
return f/0.9375;
}

float fbm6( vec2 p )
{
float f = 0.0;
f += 0.500000*(0.5+0.5*noise( p )); p = m*p*2.32;
f += 0.250000*(0.5+0.5*noise( p )); p = m*p*2.33;
f += 0.125000*(0.5+0.5*noise( p )); p = m*p*2.31;
f += 0.062500*(0.5+0.5*noise( p )); p = m*p*2.34;
f += 0.031250*(0.5+0.5*noise( p )); p = m*p*2.31;
f += 0.015625*(0.5+0.5*noise( p ));
return f/0.96875;
}

float fbm8( vec2 p )
{
float f = 0.0;
f += 0.700000*(0.5+0.5*noise( p )); p = m*p*1.32;
f += 0.556540*(0.5+0.5*noise( p )); p = m*p*1.33;
f += 0.434000*(0.5+0.5*noise( p )); p = m*p*1.31;
f += 0.252500*(0.5+0.5*noise( p )); p = m*p*1.34;
f += 0.134500*(0.5+0.5*noise( p )); p = m*p*1.30;
f += 0.062450*(0.5+0.5*noise( p )); p = m*p*1.33;
f += 0.027550*(0.5+0.5*noise( p )); p = m*p*1.31;
f += 0.016565*(0.5+0.5*noise( p ));
return f/0.98853;
}

float fbm16( vec2 p )
{
float f = 0.0;
f += 0.800000*(0.5+0.5*noise( p )); p = m*p*1.42;
f += 0.756540*(0.5+0.5*noise( p )); p = m*p*1.43;
f += 0.634000*(0.5+0.5*noise( p )); p = m*p*1.41;
f += 0.552500*(0.5+0.5*noise( p )); p = m*p*1.44;
f += 0.434500*(0.5+0.5*noise( p )); p = m*p*1.40;
f += 0.162450*(0.5+0.5*noise( p )); p = m*p*1.43;
f += 0.127550*(0.5+0.5*noise( p )); p = m*p*1.41;
f += 0.10565*(0.5+0.5*noise( p ));
return f/0.98853;
}

 

float func( vec2 q, out vec4 ron )
{
float ql = length( q );
q.x += 0.05*sin(sin(0.27*iGlobalTime+ql*4.1));
q.y += 0.05*cos(0.23*iGlobalTime+ql*4.3)*sin(sin(0.27*iGlobalTime+ql*4.1));
q *= 0.5;

vec2 o = vec2(0.0);
o.x = 0.5 + 0.5*fbm4( vec2(15.0*q +vec2(3.2) ) );
o.y = 0.5 + 0.5*fbm4( vec2(15*q+vec2(5.2)) );

float ol = length( o );
o.x += 0.4*sin((0.12*iGlobalTime+ol))/ol;
o.y += 0.4*cos((0.14*iGlobalTime*2+ol))/ol;

vec2 n;
n.x = fbm6( vec2(4.0*o+vec2(9.2)) );
n.y = fbm6( vec2(4.0*o+vec2(5.7)) );
/////NEW/////////////////////////////////////////////////
float oli = length( n );
n.x += 0.4*sin((0.12*iGlobalTime+oli))/oli;
n.y += 0.4*cos((0.14*iGlobalTime*2+oli))/oli;

vec2 m;
m.x = fbm6( vec2(4.0*n+vec2(3.2)) );
m.y = fbm6( vec2(4.0*n+vec2(6.7)) );

 

/////NEW/////////////////////////////////////////////////
float oli2 = length( m );
m.x += 0.4*sin((0.12*iGlobalTime+oli2))/oli2;
m.y += 0.4*cos((0.14*iGlobalTime*2+oli2))/oli2;

vec2 l;
l.x = fbm16( vec2(0.10*m+vec2(3.2)) );
l.y = fbm16( vec2(0.10*m+vec2(6.7)) );

 

//illuminacion
vec2 p = 8.0*q + 8.0*m + 8.0*n + 0.8*l ;

float f = 0.5 + 0.5*fbm4( p );

f = mix( f, f*f*f*1.5, f*abs(n.y) );

float g = 0.5 + 0.5*sin(sin(4.0*p.x))*sin(cos(4.0*p.y));
f *= 1.0-0.5*pow( g, 28.0 );

ron = vec4( o, n );

return f;
}

 

vec3 doMagic(vec2 p)
{
vec2 q = p*0.0005;

vec4 on = vec4(0.0);
float f = func(q, on);

vec3 col = vec3(0.0);
col = mix( vec3(mouseY,0.4,0.6), vec3(0.9,0.9,0.3), f );
col = mix( col, vec3(0.2,0.4,0.1), dot(on.zy,on.zx) );
col = mix( col, vec3(0.2,0.3,0.9), 0.2*on.y*on.y );
//fondo
col = mix( col, vec3(0.2,0.1,0.5), 0.9*smoothstep(1.2,1.3,abs(on.z)+abs(on.w)) );
col = clamp( col*f*2.0, 0.0, 1.0 );

vec3 nor = normalize( vec3( dFdx(f)*iResolution.x, 6.0, dFdy(f)*iResolution.y ) );
vec3 lig = normalize( vec3( 0.9, -0.2, -0.4 ) );
float dif = clamp( 0.5+0.7*dot( nor, lig ), 0.0, 1.0 );
vec3 bdrf;
bdrf = vec3(0.70,0.7,0.95)*(nor.y*0.9+0.5);
bdrf += vec3(0.85,0.10,0.5)*dif;
col *= 1.0*bdrf;
col = 1.0-col;
//1.3 brillo
return 1.3*col*col;
}

 

 

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

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

fragColor = vec4( doMagic( p ), 0.3 );
}
void main() {
mainImage(gl_FragColor,gl_FragCoord.xy);
}

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión /  Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión /  Cambiar )

Conectando a %s