mittsu 0.1.0

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

@@ -0,0 +1,12 @@
+module Mittsu
+  ShaderChunk = {}.tap do |chunks|
+    Dir.new(File.join(__dir__, 'shader_chunk')).each do |file_name|
+      next unless file_name.end_with? '.glsl'
+      file_path = File.join(__dir__, 'shader_chunk', file_name)
+      chunk_name = File.basename(file_name, '.glsl')
+      chunk = File.read(file_path)
+      # chunk = "// #{chunk_name}\n#{chunk}"
+      chunks[chunk_name.to_sym] = chunk
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+#ifdef USE_ALPHAMAP
+
+	diffuseColor.a *= texture( alphaMap, vUv ).g;
+
+#endif

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

@@ -0,0 +1,5 @@
+#ifdef USE_ALPHAMAP
+
+	uniform sampler2D alphaMap;
+
+#endif

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

@@ -0,0 +1,5 @@
+#ifdef ALPHATEST
+
+	if ( diffuseColor.a < ALPHATEST ) discard;
+
+#endif

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

@@ -0,0 +1,40 @@
+#ifdef USE_BUMPMAP
+
+	uniform sampler2D bumpMap;
+	uniform float bumpScale;
+
+	// Derivative maps - bump mapping unparametrized surfaces by Morten Mikkelsen
+	// http://mmikkelsen3d.blogspot.sk/2011/07/derivative-maps.html
+
+	// Evaluate the derivative of the height w.r.t. screen-space using forward differencing (listing 2)
+
+	vec2 dHdxy_fwd() {
+
+		vec2 dSTdx = dFdx( vUv );
+		vec2 dSTdy = dFdy( vUv );
+
+		float Hll = bumpScale * texture( bumpMap, vUv ).x;
+		float dBx = bumpScale * texture( bumpMap, vUv + dSTdx ).x - Hll;
+		float dBy = bumpScale * texture( bumpMap, vUv + dSTdy ).x - Hll;
+
+		return vec2( dBx, dBy );
+
+	}
+
+	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {
+
+		vec3 vSigmaX = dFdx( surf_pos );
+		vec3 vSigmaY = dFdy( surf_pos );
+		vec3 vN = surf_norm;		// normalized
+
+		vec3 R1 = cross( vSigmaY, vN );
+		vec3 R2 = cross( vN, vSigmaX );
+
+		float fDet = dot( vSigmaX, R1 );
+
+		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );
+		return normalize( abs( fDet ) * surf_norm - vGrad );
+
+	}
+
+#endif

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

@@ -0,0 +1,5 @@
+#ifdef USE_COLOR
+
+	diffuseColor.rgb *= vColor;
+
+#endif

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

@@ -0,0 +1,5 @@
+#ifdef USE_COLOR
+
+	in vec3 vColor;
+
+#endif

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

@@ -0,0 +1,5 @@
+#ifdef USE_COLOR
+
+	out vec3 vColor;
+
+#endif

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

@@ -0,0 +1,5 @@
+#ifdef USE_COLOR
+
+	vColor.xyz = inputToLinear( color.xyz );
+
+#endif

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

@@ -0,0 +1,60 @@
+#define PI 3.14159
+#define PI2 6.28318
+#define RECIPROCAL_PI2 0.15915494
+#define LOG2 1.442695
+#define EPSILON 1e-6
+
+float square( in float a ) { return a*a; }
+vec2  square( in vec2 a )  { return vec2( a.x*a.x, a.y*a.y ); }
+vec3  square( in vec3 a )  { return vec3( a.x*a.x, a.y*a.y, a.z*a.z ); }
+vec4  square( in vec4 a )  { return vec4( a.x*a.x, a.y*a.y, a.z*a.z, a.w*a.w ); }
+float saturate( in float a ) { return clamp( a, 0.0, 1.0 ); }
+vec2  saturate( in vec2 a )  { return clamp( a, 0.0, 1.0 ); }
+vec3  saturate( in vec3 a )  { return clamp( a, 0.0, 1.0 ); }
+vec4  saturate( in vec4 a )  { return clamp( a, 0.0, 1.0 ); }
+float average( in float a ) { return a; }
+float average( in vec2 a )  { return ( a.x + a.y) * 0.5; }
+float average( in vec3 a )  { return ( a.x + a.y + a.z) / 3.0; }
+float average( in vec4 a )  { return ( a.x + a.y + a.z + a.w) * 0.25; }
+float whiteCompliment( in float a ) { return saturate( 1.0 - a ); }
+vec2  whiteCompliment( in vec2 a )  { return saturate( vec2(1.0) - a ); }
+vec3  whiteCompliment( in vec3 a )  { return saturate( vec3(1.0) - a ); }
+vec4  whiteCompliment( in vec4 a )  { return saturate( vec4(1.0) - a ); }
+vec3 transformDirection( in vec3 normal, in mat4 matrix ) {
+	return normalize( ( matrix * vec4( normal, 0.0 ) ).xyz );
+}
+// http://en.wikibooks.org/wiki/GLSL_Programming/Applying_Matrix_Transformations
+vec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {
+	return normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );
+}
+vec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal) {
+	float distance = dot( planeNormal, point-pointOnPlane );
+	return point - distance * planeNormal;
+}
+float sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
+	return sign( dot( point - pointOnPlane, planeNormal ) );
+}
+vec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {
+	return pointOnLine + lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) );
+}
+float calcLightAttenuation( float lightDistance, float cutoffDistance, float decayExponent ) {
+	if ( decayExponent > 0.0 ) {
+	  return pow( saturate( 1.0 - lightDistance / cutoffDistance ), decayExponent );
+	}
+	return 1.0;
+}
+
+vec3 inputToLinear( in vec3 a ) {
+#ifdef GAMMA_INPUT
+	return pow( a, vec3( float( GAMMA_FACTOR ) ) );
+#else
+	return a;
+#endif
+}
+vec3 linearToOutput( in vec3 a ) {
+#ifdef GAMMA_OUTPUT
+	return pow( a, vec3( 1.0 / float( GAMMA_FACTOR ) ) );
+#else
+	return a;
+#endif
+}

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

@@ -0,0 +1,15 @@
+#ifdef USE_SKINNING
+
+	vec4 mvPosition = modelViewMatrix * skinned;
+
+#elif defined( USE_MORPHTARGETS )
+
+	vec4 mvPosition = modelViewMatrix * vec4( morphed, 1.0 );
+
+#else
+
+	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
+
+#endif
+
+gl_Position = projectionMatrix * mvPosition;

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

@@ -0,0 +1,21 @@
+#ifdef USE_SKINNING
+
+	vec3 objectNormal = skinnedNormal.xyz;
+
+#elif defined( USE_MORPHNORMALS )
+
+	vec3 objectNormal = morphedNormal;
+
+#else
+
+	vec3 objectNormal = normal;
+
+#endif
+
+#ifdef FLIP_SIDED
+
+	objectNormal = -objectNormal;
+
+#endif
+
+vec3 transformedNormal = normalMatrix * objectNormal;

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

@@ -0,0 +1,62 @@
+#ifdef USE_ENVMAP
+
+	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
+
+		vec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );
+
+		// Transforming Normal Vectors with the Inverse Transformation
+		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );
+
+		#ifdef ENVMAP_MODE_REFLECTION
+
+			vec3 reflectVec = reflect( cameraToVertex, worldNormal );
+
+		#else
+
+			vec3 reflectVec = refract( cameraToVertex, worldNormal, refractionRatio );
+
+		#endif
+
+	#else
+
+		vec3 reflectVec = vReflect;
+
+	#endif
+
+	#ifdef DOUBLE_SIDED
+		float flipNormal = ( -1.0 + 2.0 * float( gl_FrontFacing ) );
+	#else
+		float flipNormal = 1.0;
+	#endif
+
+	#ifdef ENVMAP_TYPE_CUBE
+		vec4 envColor = texture( envMap, flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
+
+	#elif defined( ENVMAP_TYPE_EQUIREC )
+		vec2 sampleUV;
+		sampleUV.y = saturate( flipNormal * reflectVec.y * 0.5 + 0.5 );
+		sampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;
+		vec4 envColor = texture( envMap, sampleUV );
+
+	#elif defined( ENVMAP_TYPE_SPHERE )
+		vec3 reflectView = flipNormal * normalize((viewMatrix * vec4( reflectVec, 0.0 )).xyz + vec3(0.0,0.0,1.0));
+		vec4 envColor = texture( envMap, reflectView.xy * 0.5 + 0.5 );
+	#endif
+
+	envColor.xyz = inputToLinear( envColor.xyz );
+
+	#ifdef ENVMAP_BLENDING_MULTIPLY
+
+		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );
+
+	#elif defined( ENVMAP_BLENDING_MIX )
+
+		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );
+
+	#elif defined( ENVMAP_BLENDING_ADD )
+
+		outgoingLight += envColor.xyz * specularStrength * reflectivity;
+
+	#endif
+
+#endif

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

@@ -0,0 +1,21 @@
+#ifdef USE_ENVMAP
+
+	uniform float reflectivity;
+	#ifdef ENVMAP_TYPE_CUBE
+		uniform samplerCube envMap;
+	#else
+		uniform sampler2D envMap;
+	#endif
+	uniform float flipEnvMap;
+
+	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
+
+		uniform float refractionRatio;
+
+	#else
+
+		in vec3 vReflect;
+
+	#endif
+
+#endif

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

@@ -0,0 +1,7 @@
+#if defined( USE_ENVMAP ) && ! defined( USE_BUMPMAP ) && ! defined( USE_NORMALMAP ) && ! defined( PHONG )
+
+	out vec3 vReflect;
+
+	uniform float refractionRatio;
+
+#endif

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

@@ -0,0 +1,17 @@
+#if defined( USE_ENVMAP ) && ! defined( USE_BUMPMAP ) && ! defined( USE_NORMALMAP ) && ! defined( PHONG )
+
+	vec3 worldNormal = transformDirection( objectNormal, modelMatrix );
+
+	vec3 cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
+
+	#ifdef ENVMAP_MODE_REFLECTION
+
+		vReflect = reflect( cameraToVertex, worldNormal );
+
+	#else
+
+		vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
+
+	#endif
+
+#endif

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

@@ -0,0 +1,26 @@
+#ifdef USE_FOG
+
+	#ifdef USE_LOGDEPTHBUF_EXT
+
+		float depth = gl_FragDepthEXT / gl_FragCoord.w;
+
+	#else
+
+		float depth = gl_FragCoord.z / gl_FragCoord.w;
+
+	#endif
+
+	#ifdef FOG_EXP2
+
+		float fogFactor = exp2( - square( fogDensity ) * square( depth ) * LOG2 );
+		fogFactor = whiteCompliment( fogFactor );
+
+	#else
+
+		float fogFactor = smoothstep( fogNear, fogFar, depth );
+
+	#endif
+	
+	outgoingLight = mix( outgoingLight, fogColor, fogFactor );
+
+#endif

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

@@ -0,0 +1,15 @@
+#ifdef USE_FOG
+
+	uniform vec3 fogColor;
+
+	#ifdef FOG_EXP2
+
+		uniform float fogDensity;
+
+	#else
+
+		uniform float fogNear;
+		uniform float fogFar;
+	#endif
+
+#endif

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

@@ -0,0 +1,5 @@
+#ifdef USE_LIGHTMAP
+
+	outgoingLight *= diffuseColor.xyz * texture( lightMap, vUv2 ).xyz;
+
+#endif

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

@@ -0,0 +1,6 @@
+#ifdef USE_LIGHTMAP
+
+	in vec2 vUv2;
+	uniform sampler2D lightMap;
+
+#endif

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

@@ -0,0 +1,5 @@
+#ifdef USE_LIGHTMAP
+
+	out vec2 vUv2;
+
+#endif

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

@@ -0,0 +1,5 @@
+#ifdef USE_LIGHTMAP
+
+	vUv2 = uv2;
+
+#endif

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

@@ -0,0 +1,43 @@
+uniform vec3 ambientLightColor;
+
+#if MAX_DIR_LIGHTS > 0
+
+	uniform vec3 directionalLightColor[ MAX_DIR_LIGHTS ];
+	uniform vec3 directionalLightDirection[ MAX_DIR_LIGHTS ];
+
+#endif
+
+#if MAX_HEMI_LIGHTS > 0
+
+	uniform vec3 hemisphereLightSkyColor[ MAX_HEMI_LIGHTS ];
+	uniform vec3 hemisphereLightGroundColor[ MAX_HEMI_LIGHTS ];
+	uniform vec3 hemisphereLightDirection[ MAX_HEMI_LIGHTS ];
+
+#endif
+
+#if MAX_POINT_LIGHTS > 0
+
+	uniform vec3 pointLightColor[ MAX_POINT_LIGHTS ];
+	uniform vec3 pointLightPosition[ MAX_POINT_LIGHTS ];
+	uniform float pointLightDistance[ MAX_POINT_LIGHTS ];
+	uniform float pointLightDecay[ MAX_POINT_LIGHTS ];
+
+#endif
+
+#if MAX_SPOT_LIGHTS > 0
+
+	uniform vec3 spotLightColor[ MAX_SPOT_LIGHTS ];
+	uniform vec3 spotLightPosition[ MAX_SPOT_LIGHTS ];
+	uniform vec3 spotLightDirection[ MAX_SPOT_LIGHTS ];
+	uniform float spotLightDistance[ MAX_SPOT_LIGHTS ];
+	uniform float spotLightAngleCos[ MAX_SPOT_LIGHTS ];
+	uniform float spotLightExponent[ MAX_SPOT_LIGHTS ];
+	uniform float spotLightDecay[ MAX_SPOT_LIGHTS ];
+
+#endif
+
+#ifdef WRAP_AROUND
+
+	uniform vec3 wrapRGB;
+
+#endif

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

@@ -0,0 +1,196 @@
+vLightFront = vec3( 0.0 );
+
+#ifdef DOUBLE_SIDED
+
+	vLightBack = vec3( 0.0 );
+
+#endif
+
+transformedNormal = normalize( transformedNormal );
+
+#if MAX_DIR_LIGHTS > 0
+
+for( int i = 0; i < MAX_DIR_LIGHTS; i ++ ) {
+
+	vec3 dirVector = transformDirection( directionalLightDirection[ i ], viewMatrix );
+
+	float dotProduct = dot( transformedNormal, dirVector );
+	vec3 directionalLightWeighting = vec3( max( dotProduct, 0.0 ) );
+
+	#ifdef DOUBLE_SIDED
+
+		vec3 directionalLightWeightingBack = vec3( max( -dotProduct, 0.0 ) );
+
+		#ifdef WRAP_AROUND
+
+			vec3 directionalLightWeightingHalfBack = vec3( max( -0.5 * dotProduct + 0.5, 0.0 ) );
+
+		#endif
+
+	#endif
+
+	#ifdef WRAP_AROUND
+
+		vec3 directionalLightWeightingHalf = vec3( max( 0.5 * dotProduct + 0.5, 0.0 ) );
+		directionalLightWeighting = mix( directionalLightWeighting, directionalLightWeightingHalf, wrapRGB );
+
+		#ifdef DOUBLE_SIDED
+
+			directionalLightWeightingBack = mix( directionalLightWeightingBack, directionalLightWeightingHalfBack, wrapRGB );
+
+		#endif
+
+	#endif
+
+	vLightFront += directionalLightColor[ i ] * directionalLightWeighting;
+
+	#ifdef DOUBLE_SIDED
+
+		vLightBack += directionalLightColor[ i ] * directionalLightWeightingBack;
+
+	#endif
+
+}
+
+#endif
+
+#if MAX_POINT_LIGHTS > 0
+
+	for( int i = 0; i < MAX_POINT_LIGHTS; i ++ ) {
+
+		vec4 lPosition = viewMatrix * vec4( pointLightPosition[ i ], 1.0 );
+		vec3 lVector = lPosition.xyz - mvPosition.xyz;
+
+		float attenuation = calcLightAttenuation( length( lVector ), pointLightDistance[ i ], pointLightDecay[ i ] );
+
+		lVector = normalize( lVector );
+		float dotProduct = dot( transformedNormal, lVector );
+
+		vec3 pointLightWeighting = vec3( max( dotProduct, 0.0 ) );
+
+		#ifdef DOUBLE_SIDED
+
+			vec3 pointLightWeightingBack = vec3( max( -dotProduct, 0.0 ) );
+
+			#ifdef WRAP_AROUND
+
+				vec3 pointLightWeightingHalfBack = vec3( max( -0.5 * dotProduct + 0.5, 0.0 ) );
+
+			#endif
+
+		#endif
+
+		#ifdef WRAP_AROUND
+
+			vec3 pointLightWeightingHalf = vec3( max( 0.5 * dotProduct + 0.5, 0.0 ) );
+			pointLightWeighting = mix( pointLightWeighting, pointLightWeightingHalf, wrapRGB );
+
+			#ifdef DOUBLE_SIDED
+
+				pointLightWeightingBack = mix( pointLightWeightingBack, pointLightWeightingHalfBack, wrapRGB );
+
+			#endif
+
+		#endif
+
+		vLightFront += pointLightColor[ i ] * pointLightWeighting * attenuation;
+
+		#ifdef DOUBLE_SIDED
+
+			vLightBack += pointLightColor[ i ] * pointLightWeightingBack * attenuation;
+
+		#endif
+
+	}
+
+#endif
+
+#if MAX_SPOT_LIGHTS > 0
+
+	for( int i = 0; i < MAX_SPOT_LIGHTS; i ++ ) {
+
+		vec4 lPosition = viewMatrix * vec4( spotLightPosition[ i ], 1.0 );
+		vec3 lVector = lPosition.xyz - mvPosition.xyz;
+
+		float spotEffect = dot( spotLightDirection[ i ], normalize( spotLightPosition[ i ] - worldPosition.xyz ) );
+
+		if ( spotEffect > spotLightAngleCos[ i ] ) {
+
+			spotEffect = max( pow( max( spotEffect, 0.0 ), spotLightExponent[ i ] ), 0.0 );
+
+			float attenuation = calcLightAttenuation( length( lVector ), spotLightDistance[ i ], spotLightDecay[ i ] );
+
+			lVector = normalize( lVector );
+
+			float dotProduct = dot( transformedNormal, lVector );
+			vec3 spotLightWeighting = vec3( max( dotProduct, 0.0 ) );
+
+			#ifdef DOUBLE_SIDED
+
+				vec3 spotLightWeightingBack = vec3( max( -dotProduct, 0.0 ) );
+
+				#ifdef WRAP_AROUND
+
+					vec3 spotLightWeightingHalfBack = vec3( max( -0.5 * dotProduct + 0.5, 0.0 ) );
+
+				#endif
+
+			#endif
+
+			#ifdef WRAP_AROUND
+
+				vec3 spotLightWeightingHalf = vec3( max( 0.5 * dotProduct + 0.5, 0.0 ) );
+				spotLightWeighting = mix( spotLightWeighting, spotLightWeightingHalf, wrapRGB );
+
+				#ifdef DOUBLE_SIDED
+
+					spotLightWeightingBack = mix( spotLightWeightingBack, spotLightWeightingHalfBack, wrapRGB );
+
+				#endif
+
+			#endif
+
+			vLightFront += spotLightColor[ i ] * spotLightWeighting * attenuation * spotEffect;
+
+			#ifdef DOUBLE_SIDED
+
+				vLightBack += spotLightColor[ i ] * spotLightWeightingBack * attenuation * spotEffect;
+
+			#endif
+
+		}
+
+	}
+
+#endif
+
+#if MAX_HEMI_LIGHTS > 0
+
+	for( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {
+
+		vec3 lVector = transformDirection( hemisphereLightDirection[ i ], viewMatrix );
+
+		float dotProduct = dot( transformedNormal, lVector );
+
+		float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;
+		float hemiDiffuseWeightBack = -0.5 * dotProduct + 0.5;
+
+		vLightFront += mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeight );
+
+		#ifdef DOUBLE_SIDED
+
+			vLightBack += mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeightBack );
+
+		#endif
+
+	}
+
+#endif
+
+vLightFront += ambientLightColor;
+
+#ifdef DOUBLE_SIDED
+
+	vLightBack += ambientLightColor;
+
+#endif