mittsu-opengl 0.5.0

data/lib/mittsu/opengl/shader/chunks/shadowmap_fragment.glsl

@@ -0,0 +1,216 @@
+#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 );
+
+	<% parameters[:max_shadows].times do |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
+
+	<% end %>
+
+	// 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/opengl/shader/chunks/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/opengl/shader/chunks/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/opengl/shader/chunks/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/opengl/shader/chunks/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/opengl/shader/chunks/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/opengl/shader/chunks/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/opengl/shader/chunks/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/opengl/shader/chunks/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/opengl/shader/chunks/specularmap_pars_fragment.glsl

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

data/lib/mittsu/opengl/shader/chunks/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/opengl/shader/lib/basic/basic_fragment.rbsl

@@ -0,0 +1,37 @@
+uniform vec3 diffuse;
+uniform float opacity;
+
+#include common
+#include color_pars_fragment
+#include map_pars_fragment
+#include alphamap_pars_fragment
+#include lightmap_pars_fragment
+#include envmap_pars_fragment
+#include fog_pars_fragment
+#include shadowmap_pars_fragment
+#include specularmap_pars_fragment
+#include 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 );
+
+  #include logdepthbuf_fragment
+  #include map_fragment
+  #include color_fragment
+  #include alphamap_fragment
+  #include alphatest_fragment
+  #include specularmap_fragment
+
+  outgoingLight = diffuseColor.rgb; // simple shader
+
+  #include lightmap_fragment    // TODO: Light map on an otherwise unlit surface doesn't make sense.
+  #include envmap_fragment
+  #include shadowmap_fragment    // TODO: Shadows on an otherwise unlit surface doesn't make sense.
+
+  #include linear_to_gamma_fragment
+
+  #include fog_fragment
+
+  fragColor = vec4( outgoingLight, diffuseColor.a );  // TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
+}

data/lib/mittsu/opengl/shader/lib/basic/basic_uniforms.rbslu

@@ -0,0 +1,3 @@
+#include common
+#include fog
+#include shadow_map

data/lib/mittsu/opengl/shader/lib/basic/basic_vertex.rbsl

@@ -0,0 +1,33 @@
+#include common
+#include map_pars_vertex
+#include lightmap_pars_vertex
+#include envmap_pars_vertex
+#include color_pars_vertex
+#include morphtarget_pars_vertex
+#include skinning_pars_vertex
+#include shadowmap_pars_vertex
+#include logdepthbuf_pars_vertex
+
+void main() {
+  #include map_vertex
+  #include lightmap_vertex
+  #include color_vertex
+  #include skinbase_vertex
+
+  #ifdef USE_ENVMAP
+
+    #include morphnormal_vertex
+    #include skinnormal_vertex
+    #include defaultnormal_vertex
+
+  #endif
+
+  #include morphtarget_vertex
+  #include skinning_vertex
+  #include default_vertex
+  #include logdepthbuf_vertex
+
+  #include worldpos_vertex
+  #include envmap_vertex
+  #include shadowmap_vertex
+}

data/lib/mittsu/opengl/shader/lib/cube/cube_fragment.rbsl

@@ -0,0 +1,12 @@
+uniform samplerCube tCube;
+uniform float tFlip;
+
+in vec3 vWorldPosition;
+
+#include common
+#include logdepthbuf_pars_fragment
+
+void main() {
+  fragColor = texture( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );
+  #include logdepthbuf_fragment
+}

data/lib/mittsu/opengl/shader/lib/cube/cube_uniforms.rbslu

@@ -0,0 +1,2 @@
+uniform texture tCube;
+uniform float tFlip = -1.0;

data/lib/mittsu/opengl/shader/lib/cube/cube_vertex.rbsl

@@ -0,0 +1,12 @@
+out vec3 vWorldPosition;
+
+#include common
+
+#include logdepthbuf_pars_vertex
+
+void main() {
+  vWorldPosition = transformDirection( position, modelMatrix );
+  gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+  #include logdepthbuf_vertex
+}

data/lib/mittsu/opengl/shader/lib/depth_rgba/depth_rgba_fragment.rbsl

@@ -0,0 +1,26 @@
+#include common
+#include 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() {
+  #include 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 );
+}

data/lib/mittsu/opengl/shader/lib/depth_rgba/depth_rgba_vertex.rbsl

@@ -0,0 +1,12 @@
+#include common
+#include morphtarget_pars_vertex
+#include skinning_pars_vertex
+#include logdepthbuf_pars_vertex
+
+void main() {
+  #include skinbase_vertex
+  #include morphtarget_vertex
+  #include skinning_vertex
+  #include default_vertex
+  #include logdepthbuf_vertex
+}

data/lib/mittsu/opengl/shader/lib/lambert/lambert_fragment.rbsl

@@ -0,0 +1,56 @@
+uniform vec3 diffuse;
+uniform vec3 emissive;
+uniform float opacity;
+
+in vec3 vLightFront;
+
+#ifdef DOUBLE_SIDED
+  in vec3 vLightBack;
+#endif
+
+#include common
+#include color_pars_fragment
+#include map_pars_fragment
+#include alphamap_pars_fragment
+#include lightmap_pars_fragment
+#include envmap_pars_fragment
+#include fog_pars_fragment
+#include shadowmap_pars_fragment
+#include specularmap_pars_fragment
+#include 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 );
+
+  #include logdepthbuf_fragment
+  #include map_fragment
+  #include color_fragment
+  #include alphamap_fragment
+  #include alphatest_fragment
+  #include 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
+
+  #include lightmap_fragment
+  #include envmap_fragment
+  #include shadowmap_fragment
+
+  #include linear_to_gamma_fragment
+
+  #include 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);
+}

data/lib/mittsu/opengl/shader/lib/lambert/lambert_uniforms.rbslu

@@ -0,0 +1,7 @@
+#include common
+#include fog
+#include lights
+#include shadow_map
+
+uniform color emissive = color(0.0, 0.0, 0.0);
+uniform vec3 wrapRGB = vec3(1.0, 1.0, 1.0);

data/lib/mittsu/opengl/shader/lib/lambert/lambert_vertex.rbsl

@@ -0,0 +1,37 @@
+#define LAMBERT
+  out vec3 vLightFront;
+#ifdef DOUBLE_SIDED
+  out vec3 vLightBack;
+#endif
+
+#include common
+#include map_pars_vertex
+#include lightmap_pars_vertex
+#include envmap_pars_vertex
+#include lights_lambert_pars_vertex
+#include color_pars_vertex
+#include morphtarget_pars_vertex
+#include skinning_pars_vertex
+#include shadowmap_pars_vertex
+#include logdepthbuf_pars_vertex
+
+void main() {
+  #include map_vertex
+  #include lightmap_vertex
+  #include color_vertex
+
+  #include morphnormal_vertex
+  #include skinbase_vertex
+  #include skinnormal_vertex
+  #include defaultnormal_vertex
+
+  #include morphtarget_vertex
+  #include skinning_vertex
+  #include default_vertex
+  #include logdepthbuf_vertex
+
+  #include worldpos_vertex
+  #include envmap_vertex
+  #include lights_lambert_vertex
+  #include shadowmap_vertex
+}

data/lib/mittsu/opengl/shader/lib/particle_basic/particle_basic_fragment.rbsl

@@ -0,0 +1,27 @@
+uniform vec3 psColor;
+uniform float opacity;
+
+#include common
+#include color_pars_fragment
+#include map_particle_pars_fragment
+#include fog_pars_fragment
+#include shadowmap_pars_fragment
+#include logdepthbuf_pars_fragment
+
+void main() {
+  vec3 outgoingLight = vec3( 0.0 );  // outgoing light does not have an alpha, the surface does
+  vec4 diffuseColor = vec4( psColor, opacity );
+
+  #include logdepthbuf_fragment
+  #include map_particle_fragment
+  #include color_fragment
+  #include alphatest_fragment
+
+  outgoingLight = diffuseColor.rgb; // simple shader
+
+  #include shadowmap_fragment
+  #include fog_fragment
+
+
+  fragColor = vec4( outgoingLight, diffuseColor.a );  // TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
+}

data/lib/mittsu/opengl/shader/lib/particle_basic/particle_basic_uniforms.rbslu

@@ -0,0 +1,2 @@
+#include particle
+#include shadow_map