pixo 0.1.0

data/ext/pixo/ext/tinyobjloader/tinyobjloader-config.cmake.in

@@ -0,0 +1,9 @@
+@PACKAGE_INIT@
+
+set(TINYOBJLOADER_VERSION "@TINYOBJLOADER_VERSION@")
+
+set_and_check(TINYOBJLOADER_INCLUDE_DIRS "@PACKAGE_TINYOBJLOADER_INCLUDE_DIR@")
+set_and_check(TINYOBJLOADER_LIBRARY_DIRS "@PACKAGE_TINYOBJLOADER_LIBRARY_DIR@")
+set(TINYOBJLOADER_LIBRARIES @LIBRARY_NAME@)
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake")

data/ext/pixo/ext/tinyobjloader/tinyobjloader.pc.in

@@ -0,0 +1,15 @@
+# Generated by CMake @CMAKE_VERSION@ for @PROJECT_NAME@. Any changes to this
+# file will be overwritten by the next CMake run. The input file was
+# tinyobjloader.pc.in.
+
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+libdir=${prefix}/@TINYOBJLOADER_LIBRARY_DIR@
+includedir=${prefix}/@TINYOBJLOADER_INCLUDE_DIR@
+
+Name: @PROJECT_NAME@
+Description: Tiny but powerful single file wavefront obj loader
+URL: https://syoyo.github.io/tinyobjloader/
+Version: @TINYOBJLOADER_VERSION@
+Libs: -L${libdir} -l@LIBRARY_NAME@
+Cflags: -I${includedir}

data/ext/pixo/ext/tinyobjloader/tools/travis_postbuild.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+DATEVAL=`date +%Y-%m-%d`
+VERSIONVAL=master
+
+# Use tag as version
+if [ $TRAVIS_TAG ]; then
+  VERSIONVAL=$TRAVIS_TAG
+fi
+
+sed -e s%@DATE@%${DATEVAL}% .bintray.in > .bintray.tmp
+sed -e s%@VERSION@%${VERSIONVAL}% .bintray.tmp > .bintray.json

data/ext/pixo/ext/tinyobjloader/vcsetup.bat

@@ -0,0 +1 @@
+.\\tools\\windows\\premake5.exe vs2013

data/ext/pixo/ext/tinyobjloader/wercker.yml

@@ -0,0 +1,10 @@
+box: rioki/gcc-cpp@0.0.1
+build:
+    steps:
+        # Execute a custom script step.
+        - script:
+            name: build
+            code: |
+                  git clone https://github.com/syoyo/orebuildenv.git
+                  cd tests
+                  make check

data/ext/pixo/fadecandy_configs/4x4x4.json

@@ -0,0 +1,21 @@
+{
+    "listen": ["127.0.0.1", 7890],
+    "verbose": true,
+
+    "color": {
+        "gamma": 2.5,
+        "whitepoint": [0.50, 0.50, 0.50]
+    },
+
+    "devices": [
+        {
+            "type": "fadecandy",
+            "map": [
+                [ 0, 0,  0, 16, "grb" ],
+                [ 0, 16, 64, 16, "grb" ],
+                [ 0, 32, 128, 16, "grb" ],
+                [ 0, 48, 192, 16, "grb" ]
+            ]
+        }
+    ]
+}

data/ext/pixo/fadecandy_configs/8x8x8.json

@@ -0,0 +1,18 @@
+{
+    "listen": ["0.0.0.0", 7890],
+    "verbose": true,
+
+    "color": {
+        "gamma": 2.5,
+        "whitepoint": [0.50, 0.50, 0.50]
+    },
+
+    "devices": [
+        {
+            "type": "fadecandy",
+            "map": [
+                [ 0, 0,  0, 512, "grb" ]
+            ]
+        }
+    ]
+}

data/ext/pixo/patterns/basic.glsl

@@ -0,0 +1,20 @@
+#version 330 core
+out vec4 color_out;
+
+// From http://mrdoob.com/lab/javascript/webgl/glsl/03/
+uniform float time;
+uniform vec2 resolution;
+
+void main( void ) {
+
+    vec2 position = gl_FragCoord.xy / resolution.xy;
+
+    float color = 0.0;
+    color += sin( position.x * cos( time / 15.0 ) * 80.0 ) + cos( position.y * cos( time / 15.0 ) * 10.0 );
+    color += sin( position.y * sin( time / 10.0 ) * 40.0 ) + cos( position.x * sin( time / 25.0 ) * 40.0 );
+    color += sin( position.x * sin( time / 5.0 ) * 10.0 ) + sin( position.y * sin( time / 35.0 ) * 80.0 );
+    color *= sin( time / 10.0 ) * 0.5;
+
+    color_out = vec4( vec3( color, color * 0.9, sin( color + time / 3.0 ) * 0.75 ), 1.0 );
+
+}

data/ext/pixo/patterns/bendy_pipes.glsl

@@ -0,0 +1,116 @@
+#version 330 core
+out vec4 color_out;
+
+
+float rand(vec3 r) { return fract(sin(dot(r.xy,vec2(1.38984*sin(r.z),1.13233*cos(r.z))))*653758.5453); }
+
+#define Iterations 64
+#define Thickness 0.1
+#define SuperQuadPower 8.0
+#define Fisheye 0.5
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+
+float truchetarc(vec3 pos)
+{
+	float r=length(pos.xy);
+//	return max(abs(r-0.5),abs(pos.z-0.5))-Thickness;
+//	return length(vec2(r-0.5,pos.z-0.5))-Thickness;
+	return pow(pow(abs(r-0.5),SuperQuadPower)+pow(abs(pos.z-0.5),SuperQuadPower),1.0/SuperQuadPower)-Thickness;
+}
+
+float truchetcell(vec3 pos)
+{
+	return min(min(
+	truchetarc(pos),
+	truchetarc(vec3(pos.z,1.0-pos.x,pos.y))),
+	truchetarc(vec3(1.0-pos.y,1.0-pos.z,pos.x)));
+}
+
+float distfunc(vec3 pos)
+{
+	vec3 cellpos=fract(pos);
+	vec3 gridpos=floor(pos);
+
+	float rnd=rand(gridpos);
+
+	if(rnd<1.0/8.0) return truchetcell(vec3(cellpos.x,cellpos.y,cellpos.z));
+	else if(rnd<2.0/8.0) return truchetcell(vec3(cellpos.x,1.0-cellpos.y,cellpos.z));
+	else if(rnd<3.0/8.0) return truchetcell(vec3(1.0-cellpos.x,cellpos.y,cellpos.z));
+	else if(rnd<4.0/8.0) return truchetcell(vec3(1.0-cellpos.x,1.0-cellpos.y,cellpos.z));
+	else if(rnd<5.0/8.0) return truchetcell(vec3(cellpos.y,cellpos.x,cellpos.z));
+	else if(rnd<6.0/8.0) return truchetcell(vec3(cellpos.y,1.0-cellpos.x,cellpos.z));
+	else if(rnd<7.0/8.0) return truchetcell(vec3(1.0-cellpos.y,cellpos.x,cellpos.z));
+	else  return truchetcell(vec3(1.0-cellpos.y,1.0-cellpos.x,cellpos.z));
+}
+
+vec3 gradient(vec3 pos)
+{
+	const float eps=0.0001;
+	float mid=distfunc(pos);
+	return vec3(
+	distfunc(pos+vec3(eps,0.0,0.0))-mid,
+	distfunc(pos+vec3(0.0,eps,0.0))-mid,
+	distfunc(pos+vec3(0.0,0.0,eps))-mid);
+}
+
+void mainVR( out vec4 fragColor, in vec2 fragCoord, in vec3 fragRayOri, in vec3 fragRayDir )
+{
+    vec3 ray_dir=fragRayDir;
+	vec3 ray_pos=fragRayOri;
+
+	float i=float(Iterations);
+	for(int j=0;j<Iterations;j++)
+	{
+		float dist=distfunc(ray_pos);
+		ray_pos+=dist*ray_dir;
+
+		if(abs(dist)<0.001) { i=float(j); break; }
+	}
+
+	vec3 normal=normalize(gradient(ray_pos));
+
+	float ao=1.0-i/float(Iterations);
+	float what=pow(max(0.0,dot(normal,-ray_dir)),2.0);
+	float light=ao*what*1.4;
+
+	float z=ray_pos.z/2.0;
+//	vec3 col=(sin(vec3(z,z+pi/3.0,z+pi*2.0/3.0))+2.0)/3.0;
+	vec3 col=(cos(ray_pos/2.0)+2.0)/3.0;
+
+	vec3 reflected=reflect(ray_dir,normal);
+	//vec3 env=textureCube(iChannel0,reflected*reflected*reflected).xyz;
+
+	fragColor=vec4(col*light,1.0);
+}
+
+void mainImage( out vec4 fragColor, in vec2 fragCoord )
+{
+	const float pi=3.141592;
+
+	vec2 coords=(2.0*fragCoord.xy-resolution.xy)/length(resolution.xy);
+
+	float a=time/3.0;
+	mat3 m=mat3(
+	0.0,1.0,0.0,
+	-sin(a),0.0,cos(a),
+	cos(a),0.0,sin(a));
+	m*=m;
+	m*=m;
+
+	vec3 ray_dir=m*normalize(vec3(1.4*coords,-1.0+Fisheye*(coords.x*coords.x+coords.y*coords.y)));
+
+	float t=time/3.0;
+	vec3 ray_pos=vec3(
+    2.0*(sin(t+sin(2.0*t)/2.0)/2.0+0.5),
+    2.0*(sin(t-sin(2.0*t)/2.0-pi/2.0)/2.0+0.5),
+    2.0*((-2.0*(t-sin(4.0*t)/4.0)/pi)+0.5+0.5));
+
+    mainVR(fragColor,fragCoord,ray_pos,ray_dir);
+
+   	float vignette=pow(1.0-length(coords),0.3);
+	fragColor.xyz*=vec3(vignette);
+}
+void main(){mainImage(color_out,gl_FragCoord.xy);}  

data/ext/pixo/patterns/blades.glsl

@@ -0,0 +1,69 @@
+#version 330 core
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+#extension GL_OES_standard_derivatives : enable
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+out vec4 color_out;
+
+#define PI 3.141592653589793
+#define TWOPI 6.283185307179586
+
+float rand(vec2 co) { 
+  float a = 12.9898; 
+  float b = 78.233; 
+  float c = 43758.5453; 
+  float dt= dot(co.xy ,vec2(a,b)); 
+  float sn= mod(dt,3.14); 
+  return fract(sin(sn) * c);
+}
+
+vec2 rotate(float theta, vec2 v) {
+  float s = sin(theta);
+  float c = cos(theta);
+  mat2 R = mat2(c, s, -s, c);
+  return R * v;
+}
+
+void main(void) {
+  vec2 pos = gl_FragCoord.xy * 2. - resolution;
+  pos /= max(resolution.x, resolution.y);
+
+  pos *= 5.;
+
+  float l = length(pos);
+  pos = rotate(-pow(l, .5), pos);
+
+  pos *= .5;
+
+  vec3 mask = vec3(0.0);
+
+  const int len = 3;
+  for (int i = 0; i < len; i++) {
+    float theta = mod(-time, TWOPI) - PI * 2. * float(i) / float(len);
+    float phi = atan(pos.y, pos.x);
+
+    float delta = phi - theta;
+    delta = mod(delta + PI, TWOPI);
+
+    float r = smoothstep(0., TWOPI / float(len), abs(delta));
+
+    mask += vec3(pos, 1.) * vec3(1. - r);
+  }
+
+  vec4 color = vec4(mask.xy * pos, mask.z, 1.0);
+
+  float c = length(color.xy);
+  color.rg = rotate(1. + pow(c,1.2), color.rg);
+	
+  color.gr = sin(color.rg * 10.);
+	
+	color *= step(vec4(.5), color);
+
+  color_out = color;
+}

data/ext/pixo/patterns/blob_neon.glsl

@@ -0,0 +1,71 @@
+#version 330 core
+
+// BlobNeon   By @paulofalcao - some blobs modifications with symmetries. 
+// Shrunk to fit in a page; paul's orig is nicer!
+// https://github.com/fxlex/ProcessingGLSL/blob/master/ProcessingGLSL/src/data/glslsandbox/blobneon.glsl
+
+// http://glslsandbox.com/e#26491.2
+
+
+#ifdef GL_ES
+precision mediump float; 
+#endif
+#define PI 3.14159265
+uniform float time;
+uniform vec2 resolution;
+
+out vec4 color_out;
+
+
+vec3 sim(vec3 p,float s); //.h
+vec2 rot(vec2 p,float r);
+vec2 rotsim(vec2 p,float s);
+
+vec2 makeSymmetry(vec2 p){ //nice stuff :)
+   vec2 ret=p;
+   ret=rotsim(ret,sin(time*0.3)*2.0+3.0);
+   ret.x=abs(ret.x);
+   return ret;
+}
+
+float makePoint(float x,float y,float fx,float fy,float sx,float sy,float t){
+   float xx=x+tan(t*fx)*sx;
+   float yy=y-tan(t*fy)*sy;
+   return 0.8/sqrt(abs(x*xx+yy*yy));
+}
+
+vec3 sim(vec3 p,float s){
+   vec3 ret=p;
+   ret=p+s/2.0;
+   ret=fract(ret/s)*s-s/2.0;
+   return ret;
+}
+
+vec2 rot(vec2 p,float r){
+   vec2 ret;
+   ret.x=p.x*cos(r)-p.y*sin(r);
+   ret.y=p.x*sin(r)+p.y*cos(r);
+   return ret;
+}
+
+vec2 rotsim(vec2 p,float s){
+   vec2 ret=p;
+   ret=rot(p,-PI/(s*2.0));
+   ret=rot(p,floor(atan(ret.x,ret.y)/PI*s)*(PI/s));
+   return ret;
+}
+
+void main( void ) {
+   vec2 p=(gl_FragCoord.xy/resolution.x)*2.0-vec2(1.0,resolution.y/resolution.x);
+   p=makeSymmetry(p); 
+   float x=p.x;
+   float y=p.y;
+   float t=time*0.2;
+   float a= makePoint(x,y,3.3,2.9,0.3,0.3,t);
+        a=a+makePoint(x,y,1.8,1.7,0.5,0.4,t);      
+   float b=makePoint(x,y,1.2,1.9,0.3,0.3,t);
+       b=b+makePoint(x,y,0.7,2.7,0.4,0.4,t);
+   float c=makePoint(x,y,3.7,0.3,0.3,0.3,t);
+       c=c+makePoint(x,y,0.8,0.9,0.4,0.5,t);   
+  color_out = vec4(a/31.,b/31.,c/31.,1.0);
+}

data/ext/pixo/patterns/bubbles.glsl

@@ -0,0 +1,58 @@
+#version 330 core
+
+// Colorful Voronoi
+// By: Brandon Fogerty
+// bfogerty at gmail dot com
+// xdpixel.com
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+out vec4 color_out;
+
+vec2 hash(vec2 p)
+{
+    mat2 m = mat2(  13.85, 47.77,
+                    99.41, 88.48
+                );
+
+    return fract(sin(m*p) * 46738.29);
+}
+
+float voronoi(vec2 p)
+{
+    vec2 g = floor(p);
+    vec2 f = fract(p);
+
+    float distanceToClosestFeaturePoint = 1.0;
+    for(int y = -1; y <= 1; y++)
+    {
+        for(int x = -1; x <= 1; x++)
+        {
+            vec2 latticePoint = vec2(x, y);
+            float currentDistance = distance(latticePoint, f);
+            distanceToClosestFeaturePoint = min(distanceToClosestFeaturePoint, currentDistance);
+        }
+    }
+
+    return distanceToClosestFeaturePoint;
+}
+
+void main( void )
+{
+    vec2 uv = ( gl_FragCoord.xy / resolution.xy ) * 2.0 - 1.0;
+    uv.x *= resolution.x / resolution.y;
+
+    float offset = voronoi(uv*10.0 + vec2(time));
+    float t = 1.0/abs(((uv.x + sin(uv.y + time)) + offset) * 30.0);
+
+    float r = voronoi( uv * 1.0 ) * 10.0;
+    if (r < 3.7) { r = 0.0; }
+    vec3 finalColor = vec3(10.0 * uv.y, 2.0, 1.0 * r) * t;
+    
+    color_out = vec4(finalColor, 1.0 );
+}

data/ext/pixo/patterns/chevron.glsl

@@ -0,0 +1,45 @@
+#version 330 core
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+// http://glslsandbox.com/e#32646.0
+
+#define M_PI 3.1415926535897932384626433832795
+
+#extension GL_OES_standard_derivatives : enable
+
+uniform float time;
+uniform vec2 mouse;
+uniform vec2 resolution;
+
+out vec4 color_out;
+
+void main( void ) {
+  vec3 color = vec3(1.0, 1.0, 1.0);
+  float shift = sin(time * 1.0);
+  float width = 50.0;
+  float x = gl_FragCoord.x - resolution.x/2.0;
+  float y = gl_FragCoord.y - resolution.y/2.0;
+  //float angle = atan(mouse.y, mouse.x);
+  //x = x*cos(angle)-y*sin(angle);
+  //y = 
+  /*if ((x > -1.5 && x < 1.5) || (y > -1.5 && y < 1.5)) {
+    color = vec3(0.0, 1.0, 1.0);  
+  }
+  else*/ {
+    float s = y < 0.0 ? 1.0 : -1.0;
+    float angle = M_PI/4.0;
+    
+    float xp = x*cos(angle*s) - y*sin(angle*s) - time*100.0;
+    
+    if (mod(xp, width) - width/2.0 > 0.0) {
+      color = vec3(0.0, 0.0, 0.0);
+    }
+  }
+  
+  
+  color_out = vec4( color, 1.0 );
+
+}