mittsu 0.1.1 → 0.1.2

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

@@ -0,0 +1,166 @@
+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.rb

@@ -1,12 +1,9 @@
 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
+  ShaderChunk = Hash.new do |chunks, key|
+    file_name = "#{key.to_s}.glsl"
+    file_path = File.join(__dir__, 'shader_chunk', file_name)
+    chunk = File.read(file_path)
+    # chunk = "// #{chunk_name}\n#{chunk}"
+    chunks[key] = chunk
   end
 end

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

@@ -18,9 +18,8 @@
 	float fDepth;
 	vec3 shadowColor = vec3( 1.0 );
 
-	for( int i = 0; i < MAX_SHADOWS; i ++ ) {
-
-		vec3 shadowCoord = vShadowCoord[ i ].xyz / vShadowCoord[ i ].w;
+	<% 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
@@ -47,7 +46,7 @@
 
 		if ( frustumTest ) {
 
-			shadowCoord.z += shadowBias[ i ];
+			shadowCoord.z += shadowBias[ <%= i %> ];
 
 			#if defined( SHADOWMAP_TYPE_PCF )
 
@@ -64,10 +63,10 @@
 				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 );
+						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 ) );
+								//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 );
 
@@ -82,42 +81,42 @@
 
 				const float shadowDelta = 1.0 / 9.0;
 
-				float xPixelOffset = 1.0 / shadowMapSize[ i ].x;
-				float yPixelOffset = 1.0 / shadowMapSize[ i ].y;
+				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 ) ) );
+				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 ) ) );
+				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 ) ) );
+				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 ) ) );
+				fDepth = unpackDepth( texture( shadowMap[ <%= i %> ], shadowCoord.xy + vec2( dx0, 0.0 ) ) );
 				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
 
-				fDepth = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy ) );
+				fDepth = unpackDepth( texture( shadowMap[ <%= i %> ], shadowCoord.xy ) );
 				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
 
-				fDepth = unpackDepth( texture( shadowMap[ i ], shadowCoord.xy + vec2( dx1, 0.0 ) ) );
+				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 ) ) );
+				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 ) ) );
+				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 ) ) );
+				fDepth = unpackDepth( texture( shadowMap[ <%= i %> ], shadowCoord.xy + vec2( dx1, dy1 ) ) );
 				if ( fDepth < shadowCoord.z ) shadow += shadowDelta;
 
-				shadowColor = shadowColor * vec3( ( 1.0 - shadowDarkness[ i ] * shadow ) );
+				shadowColor = shadowColor * vec3( ( 1.0 - shadowDarkness[ <%= i %> ] * shadow ) );
 
 			#elif defined( SHADOWMAP_TYPE_PCF_SOFT )
 
@@ -127,8 +126,8 @@
 
 				float shadow = 0.0;
 
-				float xPixelOffset = 1.0 / shadowMapSize[ i ].x;
-				float yPixelOffset = 1.0 / shadowMapSize[ i ].y;
+				float xPixelOffset = 1.0 / shadowMapSize[ <%= i %> ].x;
+				float yPixelOffset = 1.0 / shadowMapSize[ <%= i %> ].y;
 
 				float dx0 = -1.0 * xPixelOffset;
 				float dy0 = -1.0 * yPixelOffset;
@@ -138,15 +137,15 @@
 				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 ) ) );
+				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 ));
@@ -158,7 +157,7 @@
 				shadowKernel[2] = vec3(lessThan(depthKernel[2], shadowZ ));
 				shadowKernel[2] *= vec3(0.25);
 
-				vec2 fractionalCoord = 1.0 - fract( shadowCoord.xy * shadowMapSize[i].xy );
+				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 );
@@ -171,22 +170,22 @@
 
 				shadow = dot( shadowValues, vec4( 1.0 ) );
 
-				shadowColor = shadowColor * vec3( ( 1.0 - shadowDarkness[ i ] * shadow ) );
+				shadowColor = shadowColor * vec3( ( 1.0 - shadowDarkness[ <%= i %> ] * shadow ) );
 
 			#else
 
-				vec4 rgbaDepth = texture( shadowMap[ i ], shadowCoord.xy );
+				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 ] );
+					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 ] ) );
+		// 					shadowColor = min( shadowColor, vec3( shadowDarkness[ <%= i %> ] ) );
 
 			#endif
 
@@ -197,17 +196,17 @@
 
 			#ifdef SHADOWMAP_CASCADE
 
-				if ( inFrustum && inFrustumCount == 1 ) outgoingLight *= frustumColors[ i ];
+				if ( inFrustum && inFrustumCount == 1 ) outgoingLight *= frustumColors[ <%= i %> ];
 
 			#else
 
-				if ( inFrustum ) outgoingLight *= frustumColors[ i ];
+				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 );

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

@@ -1,6 +1,7 @@
 require 'mittsu/renderers/shaders/uniforms_utils'
 require 'mittsu/renderers/shaders/uniforms_lib'
 require 'mittsu/renderers/shaders/shader_chunk'
+require 'mittsu/renderers/shaders/rbsl_loader'
 
 module Mittsu
   class ShaderLib_Instance
@@ -10,411 +11,33 @@ module Mittsu
       @vertex_shader = options.fetch(:vertex_shader)
       @fragment_shader = options.fetch(: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',
+    def self.load_from_file(name)
+      ShaderLib_Instance.new(
+        uniforms: RBSLLoader.load_uniforms(File.read(File.join(__dir__, 'shader_lib', name, "#{name}_uniforms.rbslu")), UniformsLib),
+        vertex_shader: RBSLLoader.load_shader(File.read(File.join(__dir__, 'shader_lib', name, "#{name}_vertex.rbsl")), ShaderChunk),
+        fragment_shader: RBSLLoader.load_shader(File.read(File.join(__dir__, 'shader_lib', name, "#{name}_fragment.rbsl")), ShaderChunk)
+      )
+    end
+  end
+  private_constant :ShaderLib_Instance
 
-        '    fragColor = pack_depth( gl_FragCoord.z );',
+  SHADER_LIB_HASH = Hash.new { |h, k|
+    h[k] = ShaderLib_Instance.load_from_file(k.to_s)
+  }
 
-        '  #endif',
+  class ShaderLib
+    def self.create_shader(id, options={})
+      shader = self[id]
+      {
+        uniforms: UniformsUtils.clone(shader.uniforms),
+        vertex_shader: shader.vertex_shader,
+        fragment_shader: shader.fragment_shader
+      }.merge(options)
+    end
 
-          #'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")
-    )
-  }
+    def self.[](id)
+      SHADER_LIB_HASH[id]
+    end
+  end
 end