mittsu 0.4.1 → 0.5.0

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

@@ -1,166 +0,0 @@
-module Mittsu
-  module RBSLLoader
-    UNIFORM_RGX = /uniform\s+(\S+)\s+(\w+)(|\s+\=\s+(.+));/
-    COLOR_RGX = /color\(([^\)]*)\)/
-
-    class << self
-      def load_shader(shader, chunks)
-        shader.lines.flat_map(&:chomp).map{ |line|
-          if line =~ /(\s*)#include\s+(\w+)/
-            indentation = $1
-            chunk_name = $2.to_sym
-
-            chunks[chunk_name].lines.map(&:chomp).map{ |l|
-              "#{indentation}#{l}"
-            }
-          else
-            line
-          end
-        }.join("\n") + "\n"
-      end
-
-      def extract_array_contents(str)
-        /\[([^\]]+)\]/.match(str)[1]
-      end
-
-      def parse_int(str)
-        str.to_i
-      end
-
-      (2..4).each do |n|
-        define_method("parse_ivec#{n}") do |str|
-          str =~ /ivec#{n}\(([^\)]+)\)/
-          $1.split(',').map(&:strip).map(&:to_i).take(n)
-        end
-      end
-
-      def parse_float(str)
-        str.to_f
-      end
-
-      def parse_single_color(values)
-        if values.length == 1
-          values = values.map(&:to_i)
-        else
-          values = values.map(&:to_f)
-        end
-        Color.new(*values)
-      end
-
-      def parse_color(str)
-        str =~ COLOR_RGX
-        values = $1.split(',').map(&:strip)
-        parse_single_color(values)
-      end
-
-      def parse_color_array(str)
-        str = extract_array_contents(str)
-        str.scan(COLOR_RGX).map{ |m|
-          values = m.first.split(',').map(&:strip)
-          parse_single_color(values)
-        }
-      end
-
-      def parse_int_array(str)
-        str = extract_array_contents(str)
-        str.split(',').map(&:strip).map(&:to_i)
-      end
-
-      def parse_float_array(str)
-        str = extract_array_contents(str)
-        str.split(',').map(&:strip).map(&:to_f)
-      end
-
-      [Vector2, Vector3, Vector4].each do |vectorClass|
-        define_method("parse_vec#{vectorClass::DIMENSIONS}") do |str|
-          str =~ /vec#{vectorClass::DIMENSIONS}\(([^\)]+)\)/
-          values = $1.split(',').map(&:strip).map(&:to_f).take(vectorClass::DIMENSIONS)
-          vectorClass.new(*values)
-        end
-      end
-
-      (2..4).each do |n|
-        define_method("parse_ivec#{n}_array") do |str|
-          str = extract_array_contents(str)
-          str.scan(/ivec#{n}\(([^\)]+)\)/).map{ |m| m.first.split(',').map(&:strip).map(&:to_i).take(n) }
-        end
-      end
-
-      [Vector2, Vector3, Vector4].each do |vectorClass|
-        define_method("parse_vec#{vectorClass::DIMENSIONS}_array") do |str|
-          str = extract_array_contents(str)
-          str.scan(/vec#{vectorClass::DIMENSIONS}\(([^\)]+)\)/).map{ |m|
-            values = m.first.split(',').map(&:strip).map(&:to_f).take(vectorClass::DIMENSIONS)
-            vectorClass.new(*values)
-          }
-        end
-      end
-
-      [Matrix3, Matrix4].each do |matrixClass|
-        define_method("parse_mat#{matrixClass::DIMENSIONS}") do |str|
-          str =~ /mat#{matrixClass::DIMENSIONS}\(([^\)]+)\)/
-          values = $1.split(',').map(&:strip).map(&:to_f).take(matrixClass::DIMENSIONS * matrixClass::DIMENSIONS)
-          matrixClass.new().tap { |mat| mat.set(*values) }
-        end
-      end
-
-      [Matrix3, Matrix4].each do |matrixClass|
-        define_method("parse_mat#{matrixClass::DIMENSIONS}_array") do |str|
-          str = extract_array_contents(str)
-          str.scan(/mat#{matrixClass::DIMENSIONS}\(([^\)]+)\)/).map{ |m|
-            values = m.first.split(',').map(&:strip).map(&:to_f).take(matrixClass::DIMENSIONS * matrixClass::DIMENSIONS)
-            matrixClass.new().tap { |mat| mat.set(*values) }
-          }
-        end
-      end
-
-      def parse_texture(_str)
-        nil
-      end
-
-      def parse_texture_array(_str)
-        []
-      end
-
-      def parse_uniform(uniform)
-        uniform =~ UNIFORM_RGX
-        type_str = $1
-        type = type_str.to_sym
-        is_array = type_str.end_with?('[]')
-        name = $2
-        value_str = $4
-        value = is_array ? [] : nil
-        if value_str && !value_str.empty?
-          value = send("parse_#{type.to_s.gsub(/\[\]/, '_array')}".to_s, value_str)
-        end
-        [name, Uniform.new(type, value)]
-      end
-
-      def load_uniforms(uniforms, uniforms_lib)
-        uniform_strings = nil;
-        in_uniform = false
-
-        uniforms.lines.map(&:strip).each_with_object({}) { |line, hash|
-          if in_uniform
-            uniform_strings << line
-            if line.end_with?(';')
-              in_uniform = false
-              name, value = parse_uniform(uniform_strings.join(' '))
-              hash[name] = value
-            end
-          elsif line =~ /#include\s+(\w+)/
-            uniforms_lib[$1.to_sym].map { |(k, v)| hash[k] = v.clone }
-          elsif line.start_with?('uniform')
-            if line.end_with?(';')
-              name, value = parse_uniform(line)
-              hash[name] = value
-            else
-              in_uniform = true
-              uniform_strings = [line]
-            end
-          end
-        }
-      end
-    end
-  end
-end

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

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

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

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

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

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

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

@@ -1,40 +0,0 @@
-#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

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

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

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

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

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

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

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

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

@@ -1,60 +0,0 @@
-#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

@@ -1,15 +0,0 @@
-#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

@@ -1,21 +0,0 @@
-#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

@@ -1,62 +0,0 @@
-#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

@@ -1,21 +0,0 @@
-#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

@@ -1,7 +0,0 @@
-#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

@@ -1,17 +0,0 @@
-#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

@@ -1,26 +0,0 @@
-#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

@@ -1,15 +0,0 @@
-#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

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

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

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

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

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

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

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

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

@@ -1,43 +0,0 @@
-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