mirror_js/condition
1
0
Fork 0
mirror of https://github.com/FMS-Cat/condition.git synced 2025-08-20 04:11:41 +02:00
Code Issues Projects Releases Wiki Activity

feature: even more flickies

Browse Source
This commit is contained in:
FMS-Cat
2021-03-14 05:17:43 +09:00
parent e0a08c3a93
commit 654d864f47
2 changed files with 105 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
src/shaders/flicky-particles-render.frag
View File

@@ -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 ) {
vec2 size = vec2( 0.5 );
size.y *= 1.0 - exp( -10.0 * ( 1.0 - vLife ) );
int mode = int( vMode + 0.5 );
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;
size *= 1.0 - exp( -10.0 * ( 1.0 - vLife ) );
vec2 folded = mod( 8.0 * uv, 1.0 );
vec2 uv = vUv;
vec2 folded = mod( 4.0 * uv, 1.0 );
float shape = step( length( folded - 0.5 ), size );
float shape = step( length( folded - 0.5 ), 0.1 );
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 );
shape *= step( size, r + length( deltaUv ) );
float shape = step( r, 0.5 );
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;

34
src/shaders/flicky-particles-render.vert
View File

@@ -1,13 +1,18 @@
#version 300 es
const float MODE_RECT = 0.0;
const float MODE_GRID = 1.0;
const float MODE_CIRCLE = 2.0;
const float MODES = 3.0;
const int MODE_RECT = 0;
const int MODE_GRID = 1;
const int MODE_CIRCLE = 2;
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 );
vMode = floor( float( MODES ) * dice.w );
vDice = fs( random( computeUV.xy * 88.92 + 0.42 ) ); // precision matters,,,?
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 ) {
size = vec2( 0.25 + 0.25 * dice.x );
} else if ( mode == MODE_GRID ) {
size = vec2( 0.25 );
} else if ( vMode == MODE_CIRCLE ) {
size = vec2( 1.0 * dice.x );
} else if ( mode == MODE_CIRCLE ) {
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 );
}