mittsu 0.1.0

data/lib/mittsu/renderers/shaders/shader_chunk/morphtarget_vertex.glsl

@@ -0,0 +1,20 @@
+#ifdef USE_MORPHTARGETS
+
+	vec3 morphed = vec3( 0.0 );
+	morphed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];
+	morphed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];
+	morphed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];
+	morphed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];
+
+	#ifndef USE_MORPHNORMALS
+
+	morphed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];
+	morphed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];
+	morphed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];
+	morphed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];
+
+	#endif
+
+	morphed += position;
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/normalmap_pars_fragment.glsl

@@ -0,0 +1,27 @@
+#ifdef USE_NORMALMAP
+
+	uniform sampler2D normalMap;
+	uniform vec2 normalScale;
+
+	// Per-Pixel Tangent Space Normal Mapping
+	// http://hacksoflife.blogspot.ch/2009/11/per-pixel-tangent-space-normal-mapping.html
+
+	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm ) {
+
+		vec3 q0 = dFdx( eye_pos.xyz );
+		vec3 q1 = dFdy( eye_pos.xyz );
+		vec2 st0 = dFdx( vUv.st );
+		vec2 st1 = dFdy( vUv.st );
+
+		vec3 S = normalize( q0 * st1.t - q1 * st0.t );
+		vec3 T = normalize( -q0 * st1.s + q1 * st0.s );
+		vec3 N = normalize( surf_norm );
+
+		vec3 mapN = texture( normalMap, vUv ).xyz * 2.0 - 1.0;
+		mapN.xy = normalScale * mapN.xy;
+		mat3 tsn = mat3( S, T, N );
+		return normalize( tsn * mapN );
+
+	}
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/shadowmap_fragment.glsl

@@ -0,0 +1,217 @@
+#ifdef USE_SHADOWMAP
+
+	#ifdef SHADOWMAP_DEBUG
+
+		vec3 frustumColors[3];
+		frustumColors[0] = vec3( 1.0, 0.5, 0.0 );
+		frustumColors[1] = vec3( 0.0, 1.0, 0.8 );
+		frustumColors[2] = vec3( 0.0, 0.5, 1.0 );
+
+	#endif
+
+	#ifdef SHADOWMAP_CASCADE
+
+		int inFrustumCount = 0;
+
+	#endif
+
+	float fDepth;
+	vec3 shadowColor = vec3( 1.0 );
+
+	for( int i = 0; i < MAX_SHADOWS; i ++ ) {
+
+		vec3 shadowCoord = vShadowCoord[ i ].xyz / vShadowCoord[ i ].w;
+
+				// if ( something && something ) breaks ATI OpenGL shader compiler
+				// if ( all( something, something ) ) using this instead
+
+		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );
+		bool inFrustum = all( inFrustumVec );
+
+				// don't shadow pixels outside of light frustum
+				// use just first frustum (for cascades)
+				// don't shadow pixels behind far plane of light frustum
+
+		#ifdef SHADOWMAP_CASCADE
+
+			inFrustumCount += int( inFrustum );
+			bvec3 frustumTestVec = bvec3( inFrustum, inFrustumCount == 1, shadowCoord.z <= 1.0 );
+
+		#else
+
+			bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );
+
+		#endif
+
+		bool frustumTest = all( frustumTestVec );
+
+		if ( frustumTest ) {
+
+			shadowCoord.z += shadowBias[ i ];
+
+			#if defined( SHADOWMAP_TYPE_PCF )
+
+						// Percentage-close filtering
+						// (9 pixel kernel)
+						// http://fabiensanglard.net/shadowmappingPCF/
+
+				float shadow = 0.0;
+
+		/*
+						// nested loops breaks shader compiler / validator on some ATI cards when using OpenGL
+						// must enroll loop manually
+
+				for ( float y = -1.25; y <= 1.25; y += 1.25 )
+					for ( float x = -1.25; x <= 1.25; x += 1.25 ) {
+
+						vec4 rgbaDepth = texture( shadowMap[ i ], vec2( x * xPixelOffset, y * yPixelOffset ) + shadowCoord.xy );
+
+								// doesn't seem to produce any noticeable visual difference compared to simple texture lookup
+								//vec4 rgbaDepth = textureProj( shadowMap[ i ], vec4( vShadowCoord[ i ].w * ( vec2( x * xPixelOffset, y * yPixelOffset ) + shadowCoord.xy ), 0.05, vShadowCoord[ i ].w ) );
+
+						float fDepth = unpackDepth( rgbaDepth );
+
+						if ( fDepth < shadowCoord.z )
+							shadow += 1.0;
+
+				}
+
+				shadow /= 9.0;
+
+		*/
+
+				const float shadowDelta = 1.0 / 9.0;
+
+				float xPixelOffset = 1.0 / shadowMapSize[ i ].x;
+				float yPixelOffset = 1.0 / shadowMapSize[ i ].y;
+
+				float dx0 = -1.25 * xPixelOffset;
+				float dy0 = -1.25 * yPixelOffset;
+				float dx1 = 1.25 * xPixelOffset;
+				float dy1 = 1.25 * yPixelOffset;
+
+				fDepth = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx0, dy0 ) ) );
+				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
+
+				fDepth = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( 0.0, dy0 ) ) );
+				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
+
+				fDepth = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx1, dy0 ) ) );
+				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
+
+				fDepth = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx0, 0.0 ) ) );
+				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
+
+				fDepth = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy ) );
+				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
+
+				fDepth = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx1, 0.0 ) ) );
+				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
+
+				fDepth = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx0, dy1 ) ) );
+				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
+
+				fDepth = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( 0.0, dy1 ) ) );
+				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
+
+				fDepth = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx1, dy1 ) ) );
+				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
+
+				shadowColor = shadowColor * vec3( ( 1.0 - shadowDarkness[ i ] * shadow ) );
+
+			#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
+
+						// Percentage-close filtering
+						// (9 pixel kernel)
+						// http://fabiensanglard.net/shadowmappingPCF/
+
+				float shadow = 0.0;
+
+				float xPixelOffset = 1.0 / shadowMapSize[ i ].x;
+				float yPixelOffset = 1.0 / shadowMapSize[ i ].y;
+
+				float dx0 = -1.0 * xPixelOffset;
+				float dy0 = -1.0 * yPixelOffset;
+				float dx1 = 1.0 * xPixelOffset;
+				float dy1 = 1.0 * yPixelOffset;
+
+				mat3 shadowKernel;
+				mat3 depthKernel;
+
+				depthKernel[0][0] = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx0, dy0 ) ) );
+				depthKernel[0][1] = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx0, 0.0 ) ) );
+				depthKernel[0][2] = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx0, dy1 ) ) );
+				depthKernel[1][0] = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( 0.0, dy0 ) ) );
+				depthKernel[1][1] = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy ) );
+				depthKernel[1][2] = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( 0.0, dy1 ) ) );
+				depthKernel[2][0] = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx1, dy0 ) ) );
+				depthKernel[2][1] = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx1, 0.0 ) ) );
+				depthKernel[2][2] = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx1, dy1 ) ) );
+
+				vec3 shadowZ = vec3( shadowCoord.z );
+				shadowKernel[0] = vec3(lessThan(depthKernel[0], shadowZ ));
+				shadowKernel[0] *= vec3(0.25);
+
+				shadowKernel[1] = vec3(lessThan(depthKernel[1], shadowZ ));
+				shadowKernel[1] *= vec3(0.25);
+
+				shadowKernel[2] = vec3(lessThan(depthKernel[2], shadowZ ));
+				shadowKernel[2] *= vec3(0.25);
+
+				vec2 fractionalCoord = 1.0 - fract( shadowCoord.xy * shadowMapSize[i].xy );
+
+				shadowKernel[0] = mix( shadowKernel[1], shadowKernel[0], fractionalCoord.x );
+				shadowKernel[1] = mix( shadowKernel[2], shadowKernel[1], fractionalCoord.x );
+
+				vec4 shadowValues;
+				shadowValues.x = mix( shadowKernel[0][1], shadowKernel[0][0], fractionalCoord.y );
+				shadowValues.y = mix( shadowKernel[0][2], shadowKernel[0][1], fractionalCoord.y );
+				shadowValues.z = mix( shadowKernel[1][1], shadowKernel[1][0], fractionalCoord.y );
+				shadowValues.w = mix( shadowKernel[1][2], shadowKernel[1][1], fractionalCoord.y );
+
+				shadow = dot( shadowValues, vec4( 1.0 ) );
+
+				shadowColor = shadowColor * vec3( ( 1.0 - shadowDarkness[ i ] * shadow ) );
+
+			#else
+
+				vec4 rgbaDepth = texture( shadowMap[ i ], shadowCoord.xy );
+				float fDepth = unpackDepth( rgbaDepth );
+
+				if ( fDepth < shadowCoord.z )
+
+		// spot with multiple shadows is darker
+
+					shadowColor = shadowColor * vec3( 1.0 - shadowDarkness[ i ] );
+
+		// spot with multiple shadows has the same color as single shadow spot
+
+		// 					shadowColor = min( shadowColor, vec3( shadowDarkness[ i ] ) );
+
+			#endif
+
+		}
+
+
+		#ifdef SHADOWMAP_DEBUG
+
+			#ifdef SHADOWMAP_CASCADE
+
+				if ( inFrustum && inFrustumCount == 1 ) outgoingLight *= frustumColors[ i ];
+
+			#else
+
+				if ( inFrustum ) outgoingLight *= frustumColors[ i ];
+
+			#endif
+
+		#endif
+
+	}
+
+	// NOTE: I am unsure if this is correct in linear space.  -bhouston, Dec 29, 2014
+	shadowColor = inputToLinear( shadowColor );
+
+	outgoingLight = outgoingLight * shadowColor;
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/shadowmap_pars_fragment.glsl

@@ -0,0 +1,19 @@
+#ifdef USE_SHADOWMAP
+
+	uniform sampler2D shadowMap[ MAX_SHADOWS ];
+	uniform vec2 shadowMapSize[ MAX_SHADOWS ];
+
+	uniform float shadowDarkness[ MAX_SHADOWS ];
+	uniform float shadowBias[ MAX_SHADOWS ];
+
+	in vec4 vShadowCoord[ MAX_SHADOWS ];
+
+	float unpackDepth( const in vec4 rgba_depth ) {
+
+		const vec4 bit_shift = vec4( 1.0 / ( 256.0 * 256.0 * 256.0 ), 1.0 / ( 256.0 * 256.0 ), 1.0 / 256.0, 1.0 );
+		float depth = dot( rgba_depth, bit_shift );
+		return depth;
+
+	}
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/shadowmap_pars_vertex.glsl

@@ -0,0 +1,6 @@
+#ifdef USE_SHADOWMAP
+
+	out vec4 vShadowCoord[ MAX_SHADOWS ];
+	uniform mat4 shadowMatrix[ MAX_SHADOWS ];
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/shadowmap_vertex.glsl

@@ -0,0 +1,9 @@
+#ifdef USE_SHADOWMAP
+
+	for( int i = 0; i < MAX_SHADOWS; i ++ ) {
+
+		vShadowCoord[ i ] = shadowMatrix[ i ] * worldPosition;
+
+	}
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/skinbase_vertex.glsl

@@ -0,0 +1,8 @@
+#ifdef USE_SKINNING
+
+	mat4 boneMatX = getBoneMatrix( skinIndex.x );
+	mat4 boneMatY = getBoneMatrix( skinIndex.y );
+	mat4 boneMatZ = getBoneMatrix( skinIndex.z );
+	mat4 boneMatW = getBoneMatrix( skinIndex.w );
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/skinning_pars_vertex.glsl

@@ -0,0 +1,47 @@
+#ifdef USE_SKINNING
+
+	uniform mat4 bindMatrix;
+	uniform mat4 bindMatrixInverse;
+
+	#ifdef BONE_TEXTURE
+
+		uniform sampler2D boneTexture;
+		uniform int boneTextureWidth;
+		uniform int boneTextureHeight;
+
+		mat4 getBoneMatrix( const in float i ) {
+
+			float j = i * 4.0;
+			float x = mod( j, float( boneTextureWidth ) );
+			float y = floor( j / float( boneTextureWidth ) );
+
+			float dx = 1.0 / float( boneTextureWidth );
+			float dy = 1.0 / float( boneTextureHeight );
+
+			y = dy * ( y + 0.5 );
+
+			vec4 v1 = texture( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
+			vec4 v2 = texture( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
+			vec4 v3 = texture( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
+			vec4 v4 = texture( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
+
+			mat4 bone = mat4( v1, v2, v3, v4 );
+
+			return bone;
+
+		}
+
+	#else
+
+		uniform mat4 boneGlobalMatrices[ MAX_BONES ];
+
+		mat4 getBoneMatrix( const in float i ) {
+
+			mat4 bone = boneGlobalMatrices[ int(i) ];
+			return bone;
+
+		}
+
+	#endif
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/skinning_vertex.glsl

@@ -0,0 +1,20 @@
+#ifdef USE_SKINNING
+
+	#ifdef USE_MORPHTARGETS
+
+	vec4 skinVertex = bindMatrix * vec4( morphed, 1.0 );
+
+	#else
+
+	vec4 skinVertex = bindMatrix * vec4( position, 1.0 );
+
+	#endif
+
+	vec4 skinned = vec4( 0.0 );
+	skinned += boneMatX * skinVertex * skinWeight.x;
+	skinned += boneMatY * skinVertex * skinWeight.y;
+	skinned += boneMatZ * skinVertex * skinWeight.z;
+	skinned += boneMatW * skinVertex * skinWeight.w;
+	skinned  = bindMatrixInverse * skinned;
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/skinnormal_vertex.glsl

@@ -0,0 +1,20 @@
+#ifdef USE_SKINNING
+
+	mat4 skinMatrix = mat4( 0.0 );
+	skinMatrix += skinWeight.x * boneMatX;
+	skinMatrix += skinWeight.y * boneMatY;
+	skinMatrix += skinWeight.z * boneMatZ;
+	skinMatrix += skinWeight.w * boneMatW;
+	skinMatrix  = bindMatrixInverse * skinMatrix * bindMatrix;
+
+	#ifdef USE_MORPHNORMALS
+
+	vec4 skinnedNormal = skinMatrix * vec4( morphedNormal, 0.0 );
+
+	#else
+
+	vec4 skinnedNormal = skinMatrix * vec4( normal, 0.0 );
+
+	#endif
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/specularmap_fragment.glsl

@@ -0,0 +1,12 @@
+float specularStrength;
+
+#ifdef USE_SPECULARMAP
+
+	vec4 texelSpecular = texture( specularMap, vUv );
+	specularStrength = texelSpecular.r;
+
+#else
+
+	specularStrength = 1.0;
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/specularmap_pars_fragment.glsl

@@ -0,0 +1,5 @@
+#ifdef USE_SPECULARMAP
+
+	uniform sampler2D specularMap;
+
+#endif

data/lib/mittsu/renderers/shaders/shader_chunk/worldpos_vertex.glsl

@@ -0,0 +1,17 @@
+#if defined( USE_ENVMAP ) || defined( PHONG ) || defined( LAMBERT ) || defined ( USE_SHADOWMAP )
+
+	#ifdef USE_SKINNING
+
+		vec4 worldPosition = modelMatrix * skinned;
+
+	#elif defined( USE_MORPHTARGETS )
+
+		vec4 worldPosition = modelMatrix * vec4( morphed, 1.0 );
+
+	#else
+
+		vec4 worldPosition = modelMatrix * vec4( position, 1.0 );
+
+	#endif
+
+#endif

data/lib/mittsu/renderers/shaders/shader_lib.rb

@@ -0,0 +1,420 @@
+require 'mittsu/renderers/shaders/uniforms_utils'
+require 'mittsu/renderers/shaders/uniforms_lib'
+require 'mittsu/renderers/shaders/shader_chunk'
+
+module Mittsu
+  class ShaderLib_Instance
+    attr_accessor :uniforms, :vertex_shader, :fragment_shader
+    def initialize(uniforms:, vertex_shader:, fragment_shader:)
+      @uniforms = uniforms
+      @vertex_shader = vertex_shader
+      @fragment_shader = fragment_shader
+    end
+  end
+
+  ShaderLib = {
+    basic: ShaderLib_Instance.new(
+      uniforms: UniformsUtils.merge([
+        UniformsLib[:common],
+        UniformsLib[:fog],
+        UniformsLib[:shadowmap]
+      ]),
+
+      vertex_shader: [
+        ShaderChunk[:common],
+        ShaderChunk[:map_pars_vertex],
+        ShaderChunk[:lightmap_pars_vertex],
+        ShaderChunk[:envmap_pars_vertex],
+        ShaderChunk[:color_pars_vertex],
+        ShaderChunk[:morphtarget_pars_vertex],
+        ShaderChunk[:skinning_pars_vertex],
+        ShaderChunk[:shadowmap_pars_vertex],
+        ShaderChunk[:logdepthbuf_pars_vertex],
+
+        "void main() {",
+
+          ShaderChunk[:map_vertex],
+          ShaderChunk[:lightmap_vertex],
+          ShaderChunk[:color_vertex],
+          ShaderChunk[:skinbase_vertex],
+
+        "  #ifdef USE_ENVMAP",
+
+          ShaderChunk[:morphnormal_vertex],
+          ShaderChunk[:skinnormal_vertex],
+          ShaderChunk[:defaultnormal_vertex],
+
+        "  #endif",
+
+          ShaderChunk[:morphtarget_vertex],
+          ShaderChunk[:skin_vertex],
+          ShaderChunk[:default_vertex],
+          ShaderChunk[:logdepthbuf_vertex],
+
+          ShaderChunk[:worldpos_vertex],
+          ShaderChunk[:envmap_vertex],
+          ShaderChunk[:shadowmap_vertex],
+
+        "}"
+
+      ].join("\n"),
+
+      fragment_shader: [
+
+        "uniform vec3 diffuse;",
+        "uniform float opacity;",
+
+        ShaderChunk[:common],
+        ShaderChunk[:color_pars_fragment],
+        ShaderChunk[:map_pars_fragment],
+        ShaderChunk[:alphamap_pars_fragment],
+        ShaderChunk[:lightmap_pars_fragment],
+        ShaderChunk[:envmap_pars_fragment],
+        ShaderChunk[:fog_pars_fragment],
+        ShaderChunk[:shadowmap_pars_fragment],
+        ShaderChunk[:specularmap_pars_fragment],
+        ShaderChunk[:logdepthbuf_pars_fragment],
+
+        "void main() {",
+
+        "  vec3 outgoingLight = vec3( 0.0 );",  # outgoing light does not have an alpha, the surface does
+        "  vec4 diffuseColor = vec4( diffuse, opacity );",
+
+          ShaderChunk[:logdepthbuf_fragment],
+          ShaderChunk[:map_fragment],
+          ShaderChunk[:color_fragment],
+          ShaderChunk[:alphamap_fragment],
+          ShaderChunk[:alphatest_fragment],
+          ShaderChunk[:specularmap_fragment],
+
+        "  outgoingLight = diffuseColor.rgb;", # simple shader
+
+          ShaderChunk[:lightmap_fragment],    # TODO: Light map on an otherwise unlit surface doesn't make sense.
+          ShaderChunk[:envmap_fragment],
+          ShaderChunk[:shadowmap_fragment],    # TODO: Shadows on an otherwise unlit surface doesn't make sense.
+
+          ShaderChunk[:linear_to_gamma_fragment],
+
+          ShaderChunk[:fog_fragment],
+
+        "  fragColor = vec4( outgoingLight, diffuseColor.a );",  # TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
+
+        "}"
+
+      ].join("\n")
+    ),
+    lambert: ShaderLib_Instance.new(
+      uniforms: UniformsUtils.merge([
+        UniformsLib[:common],
+        UniformsLib[:fog],
+        UniformsLib[:lights],
+        UniformsLib[:shadow_map],
+        {
+          'emissive' => Uniform.new(:c, Color.new(0x000000)),
+          'wrapRGB' => Uniform.new(:v3, Vector3.new(1.0, 1.0, 1.0))
+        }
+      ]),
+      vertex_shader: [
+        '#define LAMBERT',
+        'out vec3 vLightFront;',
+        '#ifdef DOUBLE_SIDED',
+        '  out vec3 vLightBack;',
+        '#endif',
+        ShaderChunk[:common],
+        ShaderChunk[:map_pars_vertex],
+        ShaderChunk[:lightmap_pars_vertex],
+        ShaderChunk[:envmap_pars_vertex],
+        ShaderChunk[:lights_lambert_pars_vertex],
+        ShaderChunk[:color_pars_vertex],
+        ShaderChunk[:morphtarget_pars_vertex],
+        ShaderChunk[:skinning_pars_vertex],
+        ShaderChunk[:shadowmap_pars_vertex],
+        ShaderChunk[:logdepthbuf_pars_vertex],
+        'void main() {',
+
+          ShaderChunk[:map_vertex],
+          ShaderChunk[:lightmap_vertex],
+          ShaderChunk[:color_vertex],
+
+          ShaderChunk[:morphnormal_vertex],
+          ShaderChunk[:skinbase_vertex],
+          ShaderChunk[:skinnormal_vertex],
+          ShaderChunk[:defaultnormal_vertex],
+
+          ShaderChunk[:morphtarget_vertex],
+          ShaderChunk[:skinning_vertex],
+          ShaderChunk[:default_vertex],
+          ShaderChunk[:logdepthbuf_vertex],
+
+          ShaderChunk[:worldpos_vertex],
+          ShaderChunk[:envmap_vertex],
+          ShaderChunk[:lights_lambert_vertex],
+          ShaderChunk[:shadowmap_vertex],
+
+        '}',
+      ].join("\n"),
+      fragment_shader: [
+        'uniform vec3 diffuse;',
+        'uniform vec3 emissive;',
+        'uniform float opacity;',
+
+        'in vec3 vLightFront;',
+
+        '#ifdef DOUBLE_SIDED',
+        '  in vec3 vLightBack;',
+        '#endif',
+
+        ShaderChunk[:common],
+        ShaderChunk[:color_pars_fragment],
+        ShaderChunk[:map_pars_fragment],
+        ShaderChunk[:alphamap_pars_fragment],
+        ShaderChunk[:lightmap_pars_fragment],
+        ShaderChunk[:envmap_pars_fragment],
+        ShaderChunk[:fog_pars_fragment],
+        ShaderChunk[:shadowmap_pars_fragment],
+        ShaderChunk[:specularmap_pars_fragment],
+        ShaderChunk[:logdepthbuf_pars_fragment],
+
+        'void main() {',
+
+        '  vec3 outgoingLight = vec3( 0.0 );',  # outgoing light does not have an alpha, the surface does
+        '  vec4 diffuseColor = vec4( diffuse, opacity );',
+
+          ShaderChunk[:logdepthbuf_fragment],
+          ShaderChunk[:map_fragment],
+          ShaderChunk[:color_fragment],
+          ShaderChunk[:alphamap_fragment],
+          ShaderChunk[:alphatest_fragment],
+          ShaderChunk[:specularmap_fragment],
+
+        '  #ifdef DOUBLE_SIDED',
+
+            #'float isFront = float( gl_FrontFacing );',
+            #'fragColor.xyz *= isFront * vLightFront + ( 1.0 - isFront ) * vLightBack;',
+
+        '    if ( gl_FrontFacing )',
+        '      outgoingLight += diffuseColor.rgb * vLightFront + emissive;',
+        '    else',
+        '      outgoingLight += diffuseColor.rgb * vLightBack + emissive;',
+
+        '  #else',
+
+        '    outgoingLight += diffuseColor.rgb * vLightFront + emissive;',
+
+        '  #endif',
+
+          ShaderChunk[:lightmap_fragment],
+          ShaderChunk[:envmap_fragment],
+          ShaderChunk[:shadowmap_fragment],
+
+          ShaderChunk[:linear_to_gamma_fragment],
+
+          ShaderChunk[:fog_fragment],
+
+        # '  fragColor = vec4( outgoingLight, diffuseColor.a );',  # TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
+
+        '  fragColor = vec4(outgoingLight, diffuseColor.a);',
+        '}'
+      ].join("\n")
+    ),
+    phong: ShaderLib_Instance.new(
+      uniforms: UniformsUtils.merge([
+        UniformsLib[:common],
+        UniformsLib[:bump],
+        UniformsLib[:normal_map],
+        UniformsLib[:fog],
+        UniformsLib[:lights],
+        UniformsLib[:shadow_map],
+        {
+          'emissive'  => Uniform.new(:c, Color.new(0x000000)),
+          'specular'  => Uniform.new(:c, Color.new(0x111111)),
+          'shininess' => Uniform.new(:f, 30.0),
+          'wrapRGB'   => Uniform.new(:v3, Vector3.new(1.0, 1.0, 1.0))
+        }
+      ]),
+      vertex_shader: [
+        '#define PHONG',
+        'out vec3 vViewPosition;',
+        '#ifndef FLAT_SHADED',
+        '  out vec3 vNormal;',
+        '#endif',
+
+        ShaderChunk[:common],
+        ShaderChunk[:map_pars_vertex],
+        ShaderChunk[:lightmap_pars_vertex],
+        ShaderChunk[:envmap_pars_vertex],
+        ShaderChunk[:lights_phong_pars_vertex],
+        ShaderChunk[:color_pars_vertex],
+        ShaderChunk[:morphtarget_pars_vertex],
+        ShaderChunk[:skinning_pars_vertex],
+        ShaderChunk[:shadowmap_pars_vertex],
+        ShaderChunk[:logdepthbuf_pars_vertex],
+
+        'void main() {',
+
+          ShaderChunk[:map_vertex],
+          ShaderChunk[:lightmap_vertex],
+          ShaderChunk[:color_vertex],
+
+          ShaderChunk[:morphnormal_vertex],
+          ShaderChunk[:skinbase_vertex],
+          ShaderChunk[:skinnormal_vertex],
+          ShaderChunk[:defaultnormal_vertex],
+
+        '#ifndef FLAT_SHADED', # Normal computed with derivatives when FLAT_SHADED
+        '  vNormal = normalize( transformedNormal );',
+        '#endif',
+
+          ShaderChunk[:morphtarget_vertex],
+          ShaderChunk[:skinning_vertex],
+          ShaderChunk[:default_vertex],
+          ShaderChunk[:logdepthbuf_vertex],
+
+        '  vViewPosition = -mvPosition.xyz;',
+
+          ShaderChunk[:worldpos_vertex],
+          ShaderChunk[:envmap_vertex],
+          ShaderChunk[:lights_phong_vertex],
+          ShaderChunk[:shadowmap_vertex],
+        '}'
+      ].join("\n"),
+      fragment_shader: [
+        '#define PHONG',
+
+        'uniform vec3 diffuse;',
+        'uniform vec3 emissive;',
+        'uniform vec3 specular;',
+        'uniform float shininess;',
+        'uniform float opacity;',
+
+        ShaderChunk[:common],
+        ShaderChunk[:color_pars_fragment],
+        ShaderChunk[:map_pars_fragment],
+        ShaderChunk[:alphamap_pars_fragment],
+        ShaderChunk[:lightmap_pars_fragment],
+        ShaderChunk[:envmap_pars_fragment],
+        ShaderChunk[:fog_pars_fragment],
+        ShaderChunk[:lights_phong_pars_fragment],
+        ShaderChunk[:shadowmap_pars_fragment],
+        ShaderChunk[:bumpmap_pars_fragment],
+        ShaderChunk[:normalmap_pars_fragment],
+        ShaderChunk[:specularmap_pars_fragment],
+        ShaderChunk[:logdepthbuf_pars_fragment],
+
+        'void main() {',
+
+        '  vec3 outgoingLight = vec3( 0.0 );',  # outgoing light does not have an alpha, the surface does
+        '  vec4 diffuseColor = vec4( diffuse, opacity );',
+
+          ShaderChunk[:logdepthbuf_fragment],
+          ShaderChunk[:map_fragment],
+          ShaderChunk[:color_fragment],
+          ShaderChunk[:alphamap_fragment],
+          ShaderChunk[:alphatest_fragment],
+          ShaderChunk[:specularmap_fragment],
+
+          ShaderChunk[:lights_phong_fragment],
+
+          ShaderChunk[:lightmap_fragment],
+          ShaderChunk[:envmap_fragment],
+          ShaderChunk[:shadowmap_fragment],
+
+          ShaderChunk[:linear_to_gamma_fragment],
+
+          ShaderChunk[:fog_fragment],
+
+        '  fragColor = vec4( outgoingLight, diffuseColor.a );',  # TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
+
+        '}'
+      ].join("\n")
+    ),
+    # TODO:
+    # particle_basic
+    # dashed
+    # depth
+    # normal
+    cube: ShaderLib_Instance.new(
+      uniforms: {
+        'tCube' => Uniform.new(:t, nil),
+        'tFlip' => Uniform.new(:f, -1.0)
+      },
+      vertex_shader: [
+        'out vec3 vWorldPosition;',
+
+        ShaderChunk[:common],
+        ShaderChunk[:logdepthbuf_pars_vertex],
+
+        'void main() {',
+        '  vWorldPosition = transformDirection( position, modelMatrix );',
+        '  gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+          ShaderChunk[:logdepthbuf_vertex],
+        '}'
+      ].join("\n"),
+      fragment_shader: [
+        'uniform samplerCube tCube;',
+        'uniform float tFlip;',
+
+        'in vec3 vWorldPosition;',
+
+        ShaderChunk[:common],
+        ShaderChunk[:logdepthbuf_pars_fragment],
+
+        'void main() {',
+        '  fragColor = texture( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );',
+          ShaderChunk[:logdepthbuf_fragment],
+        '}'
+      ].join("\n")
+    ),
+    # equirect
+    depth_rgba: ShaderLib_Instance.new(
+      uniforms: {},
+      vertex_shader: [
+        ShaderChunk[:common],
+        ShaderChunk[:morphtarget_pars_vertex],
+        ShaderChunk[:skinning_pars_vertex],
+        ShaderChunk[:logdepthbuf_pars_vertex],
+
+        'void main() {',
+          ShaderChunk[:skinbase_vertex],
+          ShaderChunk[:morphtarget_vertex],
+          ShaderChunk[:skinning_vertex],
+          ShaderChunk[:default_vertex],
+          ShaderChunk[:logdepthbuf_vertex],
+        '}'
+      ].join("\n"),
+      fragment_shader: [
+        ShaderChunk[:common],
+        ShaderChunk[:logdepthbuf_pars_fragment],
+
+        'vec4 pack_depth( const in float depth ) {',
+
+        '  const vec4 bit_shift = vec4( 256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0 );',
+        '  const vec4 bit_mask = vec4( 0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0 );',
+        '  vec4 res = mod( depth * bit_shift * vec4( 255 ), vec4( 256 ) ) / vec4( 255 );', # '  vec4 res = fract( depth * bit_shift );',
+        '  res -= res.xxyz * bit_mask;',
+        '  return res;',
+
+        '}',
+
+        'void main() {',
+          ShaderChunk[:logdepthbuf_fragment],
+
+        '  #ifdef USE_LOGDEPTHBUF_EXT',
+
+        '    fragColor   = pack_depth( gl_FragDepthEXT );',
+
+        '  #else',
+
+        '    fragColor = pack_depth( gl_FragCoord.z );',
+
+        '  #endif',
+
+          #'fragColor = pack_depth( gl_FragCoord.z / gl_FragCoord.w );',
+          #'float z = ( ( gl_FragCoord.z / gl_FragCoord.w ) - 3.0 ) / ( 4000.0 - 3.0 );',
+          #'fragColor = pack_depth( z );',
+          #'fragColor = vec4( z, z, z, 1.0 );',
+        '}'
+      ].join("\n")
+    )
+  }
+end