feature: even more flickies

src/shaders/flicky-particles-render.frag

@@ -7,19 +7,25 @@ const int MTL_UNLIT = 1;
 const int MODE_RECT = 0;
 const int MODE_GRID = 1;
 const int MODE_CIRCLE = 2;
-const int MODES = 3;
+const int MODE_TAMBO = 3;
+const int MODE_C = 4;
+const int MODE_THEREFORE = 5;
+const int MODE_SPEEN = 6;
+const int MODES = 7;
 const float PI = 3.14159265;
 const float TAU = 6.28318531;
 
 #define saturate(i) clamp(i,0.,1.)
 #define linearstep(a,b,x) saturate(((x)-(a))/((b)-(a)))
+#define lofi(i,m) (floor((i)/(m))*(m))
 
 // == varings / uniforms ===========================================================================
-in vec4 vPosition;
-in vec3 vNormal;
 in float vLife;
-in vec2 vUv;
 in float vMode;
+in vec2 vUv;
+in vec3 vNormal;
+in vec4 vPosition;
+in vec4 vDice;
 
 layout (location = 0) out vec4 fragPosition;
 layout (location = 1) out vec4 fragNormal;
@@ -27,28 +33,36 @@ layout (location = 2) out vec4 fragColor;
 layout (location = 3) out vec4 fragWTF;
 
 uniform float time;
+uniform sampler2D samplerRandomStatic;
 
 // == utils ========================================================================================
+mat2 rotate2D( float t ) {
+  return mat2( cos( t ), sin( t ), -sin( t ), cos( t ) );
+}
+
+vec4 random( vec2 uv ) {
+  return texture( samplerRandomStatic, uv );
+}
+
 vec2 yflip( vec2 uv ) {
   return vec2( 0.0, 1.0 ) + vec2( 1.0, -1.0 ) * uv;
 }
 
 // == main procedure ===============================================================================
 void main() {
-  int mode = int( vMode + 0.5 );
-
-  vec3 color = vec3( 0.0 );
-
   if ( vLife < 0.0 ) { discard; }
   if ( vLife < 0.1 && 0.5 < fract( 30.0 * vLife ) ) { discard; }
 
-  if ( mode == MODE_RECT ) {
+  int mode = int( vMode + 0.5 );
-    vec2 size = vec2( 0.5 );
-    size.y *= 1.0 - exp( -10.0 * ( 1.0 - vLife ) );
 
-    vec2 uv = vUv;
+  vec2 uv = vUv;
+  vec2 deltaUv = abs( vec2( dFdx( uv.x ), dFdy( uv.y ) ) );
+
+  vec3 color = vec3( 0.0 );
+
+  if ( mode == MODE_RECT ) {
     vec2 deltaUv = abs( vec2( dFdx( uv.x ), dFdy( uv.y ) ) );
-    vec2 folded = ( size - abs( uv - 0.5 ) ) / deltaUv;
+    vec2 folded = ( vec2( 0.5 ) - abs( uv - 0.5 ) ) / deltaUv;
     bool isVert = false;
 
     if ( folded.x < folded.y ) {
@@ -69,34 +83,74 @@ void main() {
     color = vec3( 1.0 );
 
   } else if ( mode == MODE_GRID ) {
-    float size = 0.2;
+    vec2 folded = mod( 8.0 * uv, 1.0 );
-    size *= 1.0 - exp( -10.0 * ( 1.0 - vLife ) );
 
-    vec2 uv = vUv;
+    float shape = step( length( folded - 0.5 ), 0.1 );
-
-    vec2 folded = mod( 4.0 * uv, 1.0 );
-
-    float shape = step( length( folded - 0.5 ), size );
 
     if ( shape < 0.5 ) { discard; }
 
     color = vec3( 1.0 );
 
   } else if ( mode == MODE_CIRCLE ) {
-    float size = 0.5;
-    size *= 1.0 - exp( -10.0 * ( 1.0 - vLife ) );
-
-    vec2 uv = vUv;
-    vec2 deltaUv = abs( vec2( dFdx( uv.x ), dFdy( uv.y ) ) );
-
     float r = length( uv - 0.5 );
-    float shape = step( r, size );
+    float shape = step( r, 0.5 );
-    shape *= step( size, r + length( deltaUv ) );
+    shape *= step( 0.5, r + length( deltaUv ) );
 
     if ( shape < 0.5 ) { discard; }
 
     color = vec3( 1.0 );
 
+  } else if ( mode == MODE_TAMBO ) { // 田
+    if ( vLife < 0.7 ) { discard; }
+
+    if ( any( lessThan( abs( uv - 0.5 ), vec2( 0.1 ) ) ) ) { discard; }
+
+    float ptn = mod( floor( 4.0 * vDice.x + 30.0 * time ), 4.0 );
+    float pos = floor( 2.0 * uv.x ) + 2.0 * floor( 2.0 * uv.y );
+    if ( ptn != pos ) { discard; }
+
+    color = vec3( 1.0 );
+
+  } else if ( mode == MODE_C ) { // c
+    if ( vLife < 0.7 ) { discard; }
+
+    vec2 p = 2.0 * vUv - 1.0;
+    if ( 0.2 < abs( length( p ) - 0.8 ) ) { discard; }
+
+    float ptn = floor( mod( 8.0 * vDice.x - 30.0 * time, 8.0 ) );
+    vec2 pp = rotate2D( ptn * TAU / 8.0 ) * p;
+    float th = atan( pp.y, pp.x );
+    if ( th < 0.0 ) { discard; }
+
+    color = vec3( 1.0 );
+
+  } else if ( mode == MODE_THEREFORE ) { // ∴
+    if ( vLife < 0.7 ) { discard; }
+
+    vec2 p = uv * 2.0 - 1.0;
+    float ptn = floor( mod( 3.0 * vDice.x + 30.0 * time, 3.0 ) );
+    p = rotate2D( -PI / 2.0 + ptn * TAU / 3.0 ) * p;
+
+    float d = lofi( atan( p.y, p.x ) + TAU / 6.0, TAU / 3.0 );
+    p = rotate2D( -d ) * p;
+    p -= vec2( 0.5, 0.0 );
+
+    if ( 0.5 < length( p ) ) { discard; }
+    if ( d != 0.0 && length( p ) < 0.32 ) { discard; }
+
+    color = vec3( 1.0 );
+
+  } else if ( mode == MODE_SPEEN ) { // |
+    if ( vLife < 0.7 ) { discard; }
+
+    vec2 p = uv * 2.0 - 1.0;
+    float ptn = floor( mod( 4.0 * vDice.x + 30.0 * time, 4.0 ) );
+    vec2 pp = rotate2D( ptn * TAU / 8.0 ) * p;
+
+    if ( 0.2 < abs( pp.x ) || 0.9 < abs( pp.y ) ) { discard; }
+
+    color = vec3( 1.0 );
+
   }
 
   fragPosition = vPosition;

src/shaders/flicky-particles-render.vert

@@ -1,13 +1,18 @@
 #version 300 es
 
-const float MODE_RECT = 0.0;
+const int MODE_RECT = 0;
-const float MODE_GRID = 1.0;
+const int MODE_GRID = 1;
-const float MODE_CIRCLE = 2.0;
+const int MODE_CIRCLE = 2;
-const float MODES = 3.0;
+const int MODE_TAMBO = 3;
+const int MODE_C = 4;
+const int MODE_THEREFORE = 5;
+const int MODE_SPEEN = 6;
+const int MODES = 7;
 const float HUGE = 9E16;
 const float PI = 3.14159265;
 const float TAU = 6.283185307;
 
+#define fs(i) (fract(sin((i)*114.514)*1919.810))
 #define saturate(i) clamp(i,0.,1.)
 #define lofi(i,m) (floor((i)/(m))*(m))
 #define lofir(i,m) (floor((i+0.5)/(m))*(m))
@@ -22,6 +27,7 @@ out float vMode;
 out vec2 vUv;
 out vec3 vNormal;
 out vec4 vPosition;
+out vec4 vDice;
 
 uniform vec2 resolution;
 uniform vec2 resolutionCompute;
@@ -46,8 +52,11 @@ void main() {
   vec4 tex0 = texture( samplerCompute0, computeUV );
 
   // == assign varying variables ===================================================================
-  vec4 dice = random( computeUV.xy * 182.92 );
+  vDice = fs( random( computeUV.xy * 88.92 + 0.42 ) ); // precision matters,,,?
-  vMode = floor( float( MODES ) * dice.w );
+
+  vec4 dice = fs( random( computeUV.xy * 182.92 ) );
+  int mode = int( float( MODES ) * dice.w );
+  vMode = float( mode );
 
   vUv = 0.5 + 0.5 * position;
 
@@ -60,14 +69,17 @@ void main() {
 
   vec2 size;
 
-  if ( vMode == MODE_RECT ) {
+  if ( mode == MODE_RECT ) {
     size = 1.0 * dice.xy;
 
-  } else if ( vMode == MODE_GRID ) {
+  } else if ( mode == MODE_GRID ) {
-    size = vec2( 0.25 + 0.25 * dice.x );
+    size = vec2( 0.25 );
 
-  } else if ( vMode == MODE_CIRCLE ) {
+  } else if ( mode == MODE_CIRCLE ) {
-    size = vec2( 1.0 * dice.x );
+    size = vec2( 3.0 * dice.x * dice.x );
+
+  } else if ( mode == MODE_TAMBO || mode == MODE_C || mode == MODE_THEREFORE || mode == MODE_SPEEN ) {
+    size = vec2( 0.2 * dice.x );
 
   }