New fullscreen effect for stuns/dazes

game/modules/tome/class/Player.lua

@@ -424,6 +424,12 @@ function _M:updateMainShader()
 		if game.level and game.level.data and game.level.data.underwater then game.fbo_shader:setUniform("underwater", 1)
 		else game.fbo_shader:setUniform("underwater", 0) -- Disable
 		end
+
+		-- Wobbling shader
+		if self:attr("stunned") and self.stunned >= 1 then game.fbo_shader:setUniform("wobbling", 1)
+		elseif self:attr("dazed") and self.dazed >= 1 then game.fbo_shader:setUniform("wobbling", 0.7)
+		else game.fbo_shader:setUniform("wobbling", 0) -- Disable
+		end
 	end
 end
 

game/modules/tome/data/gfx/shaders/main_fbo.frag

@@ -2,6 +2,7 @@ uniform float hp_warning;
 uniform float air_warning;
 uniform float death_warning;
 uniform float solipsism_warning;
+uniform float wobbling;
 uniform float motionblur;
 uniform float underwater;
 uniform float blur;
@@ -67,11 +68,129 @@ float col(vec2 coord)
 	return cos(col);
 }
 
+vec4 permute( vec4 x ) {
+
+	return mod( ( ( x * 34.0 ) + 1.0 ) * x, 289.0 );
+
+} 
+
+vec4 taylorInvSqrt( vec4 r ) {
+
+	return 1.79284291400159 - 0.85373472095314 * r;
+
+}
+
+float snoise( vec3 v ) {
+
+	const vec2 C = vec2( 1.0 / 6.0, 1.0 / 3.0 );
+	const vec4 D = vec4( 0.0, 0.5, 1.0, 2.0 );
+
+	// First corner
+
+	vec3 i  = floor( v + dot( v, C.yyy ) );
+	vec3 x0 = v - i + dot( i, C.xxx );
+
+	// Other corners
+
+	vec3 g = step( x0.yzx, x0.xyz );
+	vec3 l = 1.0 - g;
+	vec3 i1 = min( g.xyz, l.zxy );
+	vec3 i2 = max( g.xyz, l.zxy );
+
+	vec3 x1 = x0 - i1 + 1.0 * C.xxx;
+	vec3 x2 = x0 - i2 + 2.0 * C.xxx;
+	vec3 x3 = x0 - 1. + 3.0 * C.xxx;
+
+	// Permutations
+
+	i = mod( i, 289.0 );
+	vec4 p = permute( permute( permute(
+		i.z + vec4( 0.0, i1.z, i2.z, 1.0 ) )
+		+ i.y + vec4( 0.0, i1.y, i2.y, 1.0 ) )
+		+ i.x + vec4( 0.0, i1.x, i2.x, 1.0 ) );
+
+	// Gradients
+	// ( N*N points uniformly over a square, mapped onto an octahedron.)
+
+	float n_ = 1.0 / 7.0; // N=7
+
+	vec3 ns = n_ * D.wyz - D.xzx;
+
+	vec4 j = p - 49.0 * floor( p * ns.z *ns.z );  //  mod(p,N*N)
+
+	vec4 x_ = floor( j * ns.z );
+	vec4 y_ = floor( j - 7.0 * x_ );    // mod(j,N)
+
+	vec4 x = x_ *ns.x + ns.yyyy;
+	vec4 y = y_ *ns.x + ns.yyyy;
+	vec4 h = 1.0 - abs( x ) - abs( y );
+
+	vec4 b0 = vec4( x.xy, y.xy );
+	vec4 b1 = vec4( x.zw, y.zw );
+
+
+	vec4 s0 = floor( b0 ) * 2.0 + 1.0;
+	vec4 s1 = floor( b1 ) * 2.0 + 1.0;
+	vec4 sh = -step( h, vec4( 0.0 ) );
+
+	vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
+	vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
+
+	vec3 p0 = vec3( a0.xy, h.x );
+	vec3 p1 = vec3( a0.zw, h.y );
+	vec3 p2 = vec3( a1.xy, h.z );
+	vec3 p3 = vec3( a1.zw, h.w );
+
+	// Normalise gradients
+
+	vec4 norm = taylorInvSqrt( vec4( dot( p0, p0 ), dot( p1, p1 ), dot( p2, p2 ), dot( p3, p3 ) ) );
+	p0 *= norm.x;
+	p1 *= norm.y;
+	p2 *= norm.z;
+	p3 *= norm.w;
+
+	// Mix final noise value
+
+	vec4 m = max( 0.6 - vec4( dot( x0, x0 ), dot( x1, x1 ), dot( x2, x2 ), dot( x3, x3 ) ), 0.0 );
+	m = m * m;
+	return 42.0 * dot( m*m, vec4( dot( p0, x0 ), dot( p1, x1 ),
+		dot( p2, x2 ), dot( p3, x3 ) ) );
+
+}  
+
+
+vec2 snoise2(vec3 pos)
+{
+	return vec2(snoise(pos), snoise(pos + vec3(0.0, 0.0, 1.0)));
+}
+
 void main(void)
 {
 	gl_FragColor = texture2D(tex, gl_TexCoord[0].xy);
 
-	if (motionblur > 0.0)
+	/*vec2 offset = 
+	vec4 offsetColor = texture2D(tex, gl_TexCoord[0].xy);*/
+
+	if (wobbling > 0.0)
+	{
+		float scaledTime = tick / 5000.0;
+		vec2 coord = gl_TexCoord[0].xy;
+		coord.x *= texSize.x / texSize.y;
+		vec2 offset =
+			snoise2(vec3(coord / 2.0,  scaledTime / 0.25)) * 0.33 * 3.0 + 
+			snoise2(vec3(coord / 2.0, scaledTime / 2.0)) * 0.0 + 
+			snoise2(vec3(coord / 4.0, scaledTime / 4.0)) * 0.0;
+
+		offset.x *= texSize.x / texSize.y;
+
+		float ratio = clamp(1.5 * pow(length(vec2(0.5, 0.5) - gl_TexCoord[0].xy) / (0.7071), 2.0), 0.0, 1.0); //sqrt(2) / 2 = 0.7071
+		ratio *= (1.0 + snoise2(vec3(coord / 2.0, scaledTime / 0.25 + 10.0))) * 0.5;
+
+		gl_FragColor = 
+			texture2D(tex, gl_TexCoord[0].xy) * (1.0 - ratio) + 
+			texture2D(tex, gl_TexCoord[0].xy + offset * 0.01 * wobbling) * ratio;
+	}
+	else if (motionblur > 0.0)
 	{
 		int blursize = int(motionblur);
 		vec2 offset = 0.8/texSize;