mittsu-opengl 0.5.0

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

@@ -0,0 +1,243 @@
+#ifndef FLAT_SHADED
+
+	vec3 normal = normalize( vNormal );
+
+	#ifdef DOUBLE_SIDED
+
+		normal = normal * ( -1.0 + 2.0 * float( gl_FrontFacing ) );
+
+	#endif
+
+#else
+
+	vec3 fdx = dFdx( vViewPosition );
+	vec3 fdy = dFdy( vViewPosition );
+	vec3 normal = normalize( cross( fdx, fdy ) );
+
+#endif
+
+vec3 viewPosition = normalize( vViewPosition );
+
+#ifdef USE_NORMALMAP
+
+	normal = perturbNormal2Arb( -vViewPosition, normal );
+
+#elif defined( USE_BUMPMAP )
+
+	normal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );
+
+#endif
+
+vec3 totalDiffuseLight = vec3( 0.0 );
+vec3 totalSpecularLight = vec3( 0.0 );
+
+#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 + vViewPosition.xyz;
+
+		float attenuation = calcLightAttenuation( length( lVector ), pointLightDistance[ i ], pointLightDecay[ i ] );
+
+		lVector = normalize( lVector );
+
+		// diffuse
+
+		float dotProduct = dot( normal, lVector );
+
+		#ifdef WRAP_AROUND
+
+			float pointDiffuseWeightFull = max( dotProduct, 0.0 );
+			float pointDiffuseWeightHalf = max( 0.5 * dotProduct + 0.5, 0.0 );
+
+			vec3 pointDiffuseWeight = mix( vec3( pointDiffuseWeightFull ), vec3( pointDiffuseWeightHalf ), wrapRGB );
+
+		#else
+
+			float pointDiffuseWeight = max( dotProduct, 0.0 );
+
+		#endif
+
+		totalDiffuseLight += pointLightColor[ i ] * pointDiffuseWeight * attenuation;
+
+				// specular
+
+		vec3 pointHalfVector = normalize( lVector + viewPosition );
+		float pointDotNormalHalf = max( dot( normal, pointHalfVector ), 0.0 );
+		float pointSpecularWeight = specularStrength * max( pow( pointDotNormalHalf, shininess ), 0.0 );
+
+		float specularNormalization = ( shininess + 2.0 ) / 8.0;
+
+		vec3 schlick = specular + vec3( 1.0 - specular ) * pow( max( 1.0 - dot( lVector, pointHalfVector ), 0.0 ), 5.0 );
+		totalSpecularLight += schlick * pointLightColor[ i ] * pointSpecularWeight * pointDiffuseWeight * attenuation * specularNormalization;
+
+	}
+
+#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 + vViewPosition.xyz;
+
+		float attenuation = calcLightAttenuation( length( lVector ), spotLightDistance[ i ], spotLightDecay[ i ] );
+
+		lVector = normalize( lVector );
+
+		float spotEffect = dot( spotLightDirection[ i ], normalize( spotLightPosition[ i ] - vWorldPosition ) );
+
+		if ( spotEffect > spotLightAngleCos[ i ] ) {
+
+			spotEffect = max( pow( max( spotEffect, 0.0 ), spotLightExponent[ i ] ), 0.0 );
+
+			// diffuse
+
+			float dotProduct = dot( normal, lVector );
+
+			#ifdef WRAP_AROUND
+
+				float spotDiffuseWeightFull = max( dotProduct, 0.0 );
+				float spotDiffuseWeightHalf = max( 0.5 * dotProduct + 0.5, 0.0 );
+
+				vec3 spotDiffuseWeight = mix( vec3( spotDiffuseWeightFull ), vec3( spotDiffuseWeightHalf ), wrapRGB );
+
+			#else
+
+				float spotDiffuseWeight = max( dotProduct, 0.0 );
+
+			#endif
+
+			totalDiffuseLight += spotLightColor[ i ] * spotDiffuseWeight * attenuation * spotEffect;
+
+			// specular
+
+			vec3 spotHalfVector = normalize( lVector + viewPosition );
+			float spotDotNormalHalf = max( dot( normal, spotHalfVector ), 0.0 );
+			float spotSpecularWeight = specularStrength * max( pow( spotDotNormalHalf, shininess ), 0.0 );
+
+			float specularNormalization = ( shininess + 2.0 ) / 8.0;
+
+			vec3 schlick = specular + vec3( 1.0 - specular ) * pow( max( 1.0 - dot( lVector, spotHalfVector ), 0.0 ), 5.0 );
+			totalSpecularLight += schlick * spotLightColor[ i ] * spotSpecularWeight * spotDiffuseWeight * attenuation * specularNormalization * spotEffect;
+
+		}
+
+	}
+
+#endif
+
+#if MAX_DIR_LIGHTS > 0
+
+	for( int i = 0; i < MAX_DIR_LIGHTS; i ++ ) {
+
+		vec3 dirVector = transformDirection( directionalLightDirection[ i ], viewMatrix );
+
+		// diffuse
+
+		float dotProduct = dot( normal, dirVector );
+
+		#ifdef WRAP_AROUND
+
+			float dirDiffuseWeightFull = max( dotProduct, 0.0 );
+			float dirDiffuseWeightHalf = max( 0.5 * dotProduct + 0.5, 0.0 );
+
+			vec3 dirDiffuseWeight = mix( vec3( dirDiffuseWeightFull ), vec3( dirDiffuseWeightHalf ), wrapRGB );
+
+		#else
+
+			float dirDiffuseWeight = max( dotProduct, 0.0 );
+
+		#endif
+
+		totalDiffuseLight += directionalLightColor[ i ] * dirDiffuseWeight;
+
+		// specular
+
+		vec3 dirHalfVector = normalize( dirVector + viewPosition );
+		float dirDotNormalHalf = max( dot( normal, dirHalfVector ), 0.0 );
+		float dirSpecularWeight = specularStrength * max( pow( dirDotNormalHalf, shininess ), 0.0 );
+
+		/*
+		// fresnel term from skin shader
+		const float F0 = 0.128;
+
+		float base = 1.0 - dot( viewPosition, dirHalfVector );
+		float exponential = pow( base, 5.0 );
+
+		float fresnel = exponential + F0 * ( 1.0 - exponential );
+		*/
+
+		/*
+		// fresnel term from fresnel shader
+		const float mFresnelBias = 0.08;
+		const float mFresnelScale = 0.3;
+		const float mFresnelPower = 5.0;
+
+		float fresnel = mFresnelBias + mFresnelScale * pow( 1.0 + dot( normalize( -viewPosition ), normal ), mFresnelPower );
+		*/
+
+		float specularNormalization = ( shininess + 2.0 ) / 8.0;
+
+		// 		dirSpecular += specular * directionalLightColor[ i ] * dirSpecularWeight * dirDiffuseWeight * specularNormalization * fresnel;
+
+		vec3 schlick = specular + vec3( 1.0 - specular ) * pow( max( 1.0 - dot( dirVector, dirHalfVector ), 0.0 ), 5.0 );
+		totalSpecularLight += schlick * directionalLightColor[ i ] * dirSpecularWeight * dirDiffuseWeight * specularNormalization;
+
+
+	}
+
+#endif
+
+#if MAX_HEMI_LIGHTS > 0
+
+	for( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {
+
+		vec3 lVector = transformDirection( hemisphereLightDirection[ i ], viewMatrix );
+
+		// diffuse
+
+		float dotProduct = dot( normal, lVector );
+		float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;
+
+		vec3 hemiColor = mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeight );
+
+		totalDiffuseLight += hemiColor;
+
+		// specular (sky light)
+
+		vec3 hemiHalfVectorSky = normalize( lVector + viewPosition );
+		float hemiDotNormalHalfSky = 0.5 * dot( normal, hemiHalfVectorSky ) + 0.5;
+		float hemiSpecularWeightSky = specularStrength * max( pow( max( hemiDotNormalHalfSky, 0.0 ), shininess ), 0.0 );
+
+		// specular (ground light)
+
+		vec3 lVectorGround = -lVector;
+
+		vec3 hemiHalfVectorGround = normalize( lVectorGround + viewPosition );
+		float hemiDotNormalHalfGround = 0.5 * dot( normal, hemiHalfVectorGround ) + 0.5;
+		float hemiSpecularWeightGround = specularStrength * max( pow( max( hemiDotNormalHalfGround, 0.0 ), shininess ), 0.0 );
+
+		float dotProductGround = dot( normal, lVectorGround );
+
+		float specularNormalization = ( shininess + 2.0 ) / 8.0;
+
+		vec3 schlickSky = specular + vec3( 1.0 - specular ) * pow( max( 1.0 - dot( lVector, hemiHalfVectorSky ), 0.0 ), 5.0 );
+		vec3 schlickGround = specular + vec3( 1.0 - specular ) * pow( max( 1.0 - dot( lVectorGround, hemiHalfVectorGround ), 0.0 ), 5.0 );
+		totalSpecularLight += hemiColor * specularNormalization * ( schlickSky * hemiSpecularWeightSky * max( dotProduct, 0.0 ) + schlickGround * hemiSpecularWeightGround * max( dotProductGround, 0.0 ) );
+
+	}
+
+#endif
+
+#ifdef METAL
+
+	outgoingLight += diffuseColor.rgb * ( totalDiffuseLight + ambientLightColor ) * specular + totalSpecularLight + emissive;
+
+#else
+
+	outgoingLight += diffuseColor.rgb * ( totalDiffuseLight + ambientLightColor ) + totalSpecularLight + emissive;
+
+#endif

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

@@ -0,0 +1,58 @@
+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 spotLightAngleCos[ MAX_SPOT_LIGHTS ];
+	uniform float spotLightExponent[ MAX_SPOT_LIGHTS ];
+	uniform float spotLightDistance[ MAX_SPOT_LIGHTS ];
+	uniform float spotLightDecay[ MAX_SPOT_LIGHTS ];
+
+#endif
+
+#if MAX_SPOT_LIGHTS > 0 || defined( USE_BUMPMAP ) || defined( USE_ENVMAP )
+
+	in vec3 vWorldPosition;
+
+#endif
+
+#ifdef WRAP_AROUND
+
+	uniform vec3 wrapRGB;
+
+#endif
+
+in vec3 vViewPosition;
+
+#ifndef FLAT_SHADED
+
+	in vec3 vNormal;
+
+#endif

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

@@ -0,0 +1,5 @@
+#if MAX_SPOT_LIGHTS > 0 || defined( USE_BUMPMAP ) || defined( USE_ENVMAP )
+
+	out vec3 vWorldPosition;
+
+#endif

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

@@ -0,0 +1,5 @@
+#if MAX_SPOT_LIGHTS > 0 || defined( USE_BUMPMAP ) || defined( USE_ENVMAP )
+
+	vWorldPosition = worldPosition.xyz;
+
+#endif

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

@@ -0,0 +1,2 @@
+
+	outgoingLight = linearToOutput( outgoingLight );

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

@@ -0,0 +1,5 @@
+#if defined(USE_LOGDEPTHBUF) && defined(USE_LOGDEPTHBUF_EXT)
+
+	gl_FragDepthEXT = log2(vFragDepth) * logDepthBufFC * 0.5;
+
+#endif

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

@@ -0,0 +1,12 @@
+#ifdef USE_LOGDEPTHBUF
+
+	uniform float logDepthBufFC;
+
+	#ifdef USE_LOGDEPTHBUF_EXT
+
+		#extension GL_EXT_frag_depth : enable
+		in float vFragDepth;
+
+	#endif
+
+#endif

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

@@ -0,0 +1,11 @@
+#ifdef USE_LOGDEPTHBUF
+
+	#ifdef USE_LOGDEPTHBUF_EXT
+
+		out float vFragDepth;
+
+	#endif
+
+	uniform float logDepthBufFC;
+
+#endif

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

@@ -0,0 +1,15 @@
+#ifdef USE_LOGDEPTHBUF
+
+	gl_Position.z = log2(max( EPSILON, gl_Position.w + 1.0 )) * logDepthBufFC;
+
+	#ifdef USE_LOGDEPTHBUF_EXT
+
+		vFragDepth = 1.0 + gl_Position.w;
+
+#else
+
+		gl_Position.z = (gl_Position.z - 1.0) * gl_Position.w;
+
+	#endif
+
+#endif

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

@@ -0,0 +1,9 @@
+#ifdef USE_MAP
+
+	vec4 texelColor = texture( map, vUv );
+
+	texelColor.xyz = inputToLinear( texelColor.xyz );
+
+	diffuseColor *= texelColor;
+
+#endif

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

@@ -0,0 +1,11 @@
+#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP )
+
+	in vec2 vUv;
+
+#endif
+
+#ifdef USE_MAP
+
+	uniform sampler2D map;
+
+#endif

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

@@ -0,0 +1,6 @@
+#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP )
+
+	out vec2 vUv;
+	uniform vec4 offsetRepeat;
+
+#endif

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

@@ -0,0 +1,5 @@
+#ifdef USE_MAP
+
+	diffuseColor *= texture( map, vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y ) * offsetRepeat.zw + offsetRepeat.xy );
+
+#endif

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

@@ -0,0 +1,6 @@
+#ifdef USE_MAP
+
+	uniform vec4 offsetRepeat;
+	uniform sampler2D map;
+
+#endif

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

@@ -0,0 +1,5 @@
+#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP )
+
+	vUv = uv * offsetRepeat.zw + offsetRepeat.xy;
+
+#endif

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

@@ -0,0 +1,12 @@
+#ifdef USE_MORPHNORMALS
+
+	vec3 morphedNormal = vec3( 0.0 );
+
+	morphedNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];
+	morphedNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];
+	morphedNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];
+	morphedNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];
+
+	morphedNormal += normal;
+
+#endif

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

@@ -0,0 +1,13 @@
+#ifdef USE_MORPHTARGETS
+
+	#ifndef USE_MORPHNORMALS
+
+	uniform float morphTargetInfluences[ 8 ];
+
+	#else
+
+	uniform float morphTargetInfluences[ 4 ];
+
+	#endif
+
+#endif

data/lib/mittsu/opengl/shader/chunks/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/opengl/shader/chunks/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