🔍

The baby swing

Illustrations of possible realizations of the swinging device – left: plain screwed core material / right: furry surface

The diffuse bed

The visualization shows the reactive state of the ai reacting to video feed in, therefore motion and training pulse.https://glslsandbox.com/e#101349.1


PShader s;
PGraphics cnv;
int w,h;

void setup(){

  size(600,400,P2D);
  s = loadShader("field.glsl");
  s.set("resolution", float(width), float(height) );
 
  cnv = createGraphics(600,400,P2D);
  noStroke();
  w = width;
  h= height;
}

void draw(){
  
  s.set("time", millis() / 1000.0);
  cnv.beginDraw();
  cnv.noStroke();
  cnv.rect(0,0,w,h);
  //cnv.background(222);
  cnv.shader(s);
  cnv.endDraw();

  image(cnv,0,0);
 
}




#extension GL_OES_standard_derivatives : enable

precision mediump float;

uniform float time;
uniform vec2 mouse;
uniform vec2 resolution;




mat2 rotate2D(float r) {
    return mat2(cos(r), sin(r), -sin(r), cos(r));
}

 
void main()
{
 
	 float t = time*.1;
	float brightness = (sin(t*12.) +1.) *.1;
	float fluffi = (sin(t*2.) +1.) *.1 + 1.1; // change slowly!
	float detail = 9.;
	
	float metaloid = 1.03; // .3 = smooth // 1.03 liquid // metaloid  only change hard - no slide
	
	
	// Normalized pixel coordinates (from 0 to 1)
    vec2 uv = (gl_FragCoord.xy-.5*resolution.xy)/resolution.y;
    vec3 col = vec3(2);
   
    
    vec2 n = vec2(1);
    vec2 q = vec2(1);
    vec2 p = uv;
    float d = dot(p,p);
    float S = detail;
    float a = 0.05;
    mat2 m = rotate2D(2.2);

    for (float j = 0.; j < 11.; j++) {
        p *= m;
        n *= m;
        q = p * S + t * 4. + sin(t * 4. - d * 3.) * 2.09 + j + n; // wtf???
        a += dot(cos(q*metaloid)/S, vec2(.2));
        n -= sin(q);
        S *= fluffi;
    }

       col = vec3(7, 2, 4) * (a  + brightness) + a + a ;
	 
	
	
	//col -=d; // vignette
    
    
    // Output to screen
    gl_FragColor = vec4(col,1.0);
}

The main setup


import gohai.glvideo.*;
GLCapture video;
PShader edge_shader;
PGraphics video_direct_buffer; // video buffer graphcis
PGraphics video_p_buffer;
PGraphics diffBuffA; // video buffer graphcis
PGraphics canvas; // buffer graphcis

PGraphics ebuff;

int sw = 640;
int sh = 480;

int cw = 320;
int ch = 240;

int bw = 80;
int bh = 60;

float p_brisum = 0;
float sbs = 0;

float smdiff = 0;

void setup() {
  size(640, 480, P2D);

  initCam();
  initShaders();
  noCursor();
  edge_shader = loadShader("shader_one.glsl");
  edge_shader.set("iResolution", float(cw), float(ch) ); 
  

  
  frameRate(25);
}

void draw(){

  //background(122);
  
  if (video.available()) {
    video.read();
    video.updatePixels();
    video_direct_buffer.beginDraw();
    video_direct_buffer.image(video,0,0);
    video_direct_buffer.endDraw();
    
    
    
  }
   
   edge_shader.set("iChannel0", video_direct_buffer);
   edge_shader.set("iChannel1", video_p_buffer);
   
   canvas.beginDraw();
   canvas.rect(0,0,22,22);
   canvas.filter(edge_shader);
   canvas.endDraw();
    
   
video_p_buffer.beginDraw();
video_p_buffer.background(222);
video_p_buffer.image(video_direct_buffer,0,0 );
video_p_buffer.endDraw();

   ebuff.beginDraw();
   ebuff.rect(0,0,22,22);
   ebuff.image(canvas,0,0,bw,bh);
   ebuff.endDraw();
   
   ebuff.loadPixels();
   float brisum = 0;
   for(int i = 0;i< ebuff.pixels.length;i++){
     
     color cc = ebuff.pixels[i];
     float r = red(cc);
        float g = green(cc);
        float b = blue(cc);
        
        brisum += .2126*r + 0.7152 * g + 0.0722 * b;
     
       
     
   }
   //ebuff.Pixels();
   brisum /= float(ebuff.pixels.length);
   smdiff = lerp(smdiff,brisum, 0.15);
 
//image(video_p_buffer,80,0,sw/2,sh/2);

  image(canvas,0,0,sw,sh);
   
   image(video_direct_buffer,0,0,sw/4,sh/4);
   
   //image(ebuff,0,160);
   
   fill(smdiff*10);
   rect(80,80,44,44);

}




void initShaders(){


    video_direct_buffer = createGraphics(cw,ch,P2D);
    video_direct_buffer.beginDraw();
    video_direct_buffer.background(122);
    video_direct_buffer.endDraw();
    
    video_p_buffer = createGraphics(cw,ch,P2D);
    video_p_buffer.beginDraw();
    video_p_buffer.background(122);
    video_p_buffer.endDraw();
    
    canvas = createGraphics(cw,ch,P2D);
    canvas.beginDraw();
    canvas.background(122);
    canvas.endDraw();

      ebuff = createGraphics(bw,bh,P2D);
  ebuff.beginDraw();
   ebuff.background(122);
   ebuff.endDraw();


    

}


void initCam(){
/*
  String[] devices = GLCapture.list();
  println("Devices:");
  //
  if (0 < devices.length) {
    String[] configs = GLCapture.configs(devices[0]);
   // println("Configs:");
    //printArray(configs);
  }
  
   
   printArray(devices);
  GLCapture.configs(devices[0]);
  */

  String[] devices = GLCapture.list();
  //video = new GLCapture(this);
  video = new GLCapture(this, devices[0], cw, ch, 25);
  video.start();

}


#ifdef GL_ES
precision mediump float;
#endif

#define PROCESSING_TEXTURE_SHADER

uniform float iTime;
uniform vec2 iMouse;
uniform vec2 iResolution;
uniform sampler2D iChannel0; // direct cam feed
uniform sampler2D iChannel1; // buffer


uniform sampler2D texture;
uniform vec2 texOffset;

varying vec4 vertColor;
varying vec4 vertTexCoord;


void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
	
	 vec2 res = iResolution.xy;
    vec2 uv = fragCoord / res;

   vec4 cam_direct = texture2D(iChannel0,uv);
   
   
	
	  vec2 tc0 = vertTexCoord.st + vec2(-texOffset.s, -texOffset.t);
  vec2 tc1 = vertTexCoord.st + vec2(         0.0, -texOffset.t);
  vec2 tc2 = vertTexCoord.st + vec2(+texOffset.s, -texOffset.t);
  vec2 tc3 = vertTexCoord.st + vec2(-texOffset.s,          0.0);
  vec2 tc4 = vertTexCoord.st + vec2(         0.0,          0.0);
  vec2 tc5 = vertTexCoord.st + vec2(+texOffset.s,          0.0);
  vec2 tc6 = vertTexCoord.st + vec2(-texOffset.s, +texOffset.t);
  vec2 tc7 = vertTexCoord.st + vec2(         0.0, +texOffset.t);
  vec2 tc8 = vertTexCoord.st + vec2(+texOffset.s, +texOffset.t);


	//texture = iChannel0;
	
  vec4 col0 = texture2D(iChannel0, tc0);
  vec4 col1 = texture2D(iChannel0, tc1);
  vec4 col2 = texture2D(iChannel0, tc2);
  vec4 col3 = texture2D(iChannel0, tc3);
  vec4 col4 = texture2D(iChannel0, tc4);
  vec4 col5 = texture2D(iChannel0, tc5);
  vec4 col6 = texture2D(iChannel0, tc6);
  vec4 col7 = texture2D(iChannel0, tc7);
  vec4 col8 = texture2D(iChannel0, tc8);
  
  
	
	// dir_edge is the direct feed converted to edges!
	vec4 dir_edge = 8.0 * col4 - (col0 + col1 + col2 + col3 + col5 + col6 + col7 + col8);
  
	
	vec4 camdirin = texture2D(iChannel0,uv);
	
	vec4 buffer = texture2D(iChannel1,uv);
	
	 	
	float cam_edge_bri = dot(camdirin.xyz,vec3(0.2126,0.7152,0.0722));
	
	float buff_bri = dot(buffer.xyz,vec3(0.2126,0.7152,0.0722));
	
	//float eggi =   buff_bri - cam_edge_bri;
	
	float eggi =  abs(camdirin.r - buffer.r);
	
	 

     fragColor = vec4(vec3(eggi*.6), 1.0);
    
     //fragColor = vec4(coldiff, 1.0);
    
	
}



void main(void)
{
     mainImage(gl_FragColor, gl_FragCoord.xy);
   
   
}