mittsu-opengl 0.5.0

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

@@ -0,0 +1,25 @@
+uniform float size;
+// uniform float scale; // TODO
+
+#include common
+#include color_pars_vertex
+#include shadowmap_pars_vertex
+#include logdepthbuf_pars_vertex
+
+void main() {
+  #include color_vertex
+
+  vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+
+  // #ifdef USE_SIZEATTENUATION
+    // gl_PointSize = size * (scale / length(mvPosition.xyz));
+  // #else
+    gl_PointSize = size;
+  // #endif
+
+  gl_Position = projectionMatrix * mvPosition;
+
+  #include logdepthbuf_vertex
+  #include worldpos_vertex
+  #include shadowmap_vertex
+}

data/lib/mittsu/opengl/shader/lib/phong/phong_fragment.rbsl

@@ -0,0 +1,45 @@
+#define PHONG
+
+uniform vec3 diffuse;
+uniform vec3 emissive;
+uniform vec3 specular;
+uniform float shininess;
+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 lights_phong_pars_fragment
+#include shadowmap_pars_fragment
+#include bumpmap_pars_fragment
+#include normalmap_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
+
+  #include lights_phong_fragment
+
+  #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
+}

data/lib/mittsu/opengl/shader/lib/phong/phong_uniforms.rbslu

@@ -0,0 +1,11 @@
+#include common
+#include bump
+#include normal_map
+#include fog
+#include lights
+#include shadow_map
+
+uniform color emissive = color(0.0, 0.0, 0.0);
+uniform color specular = color(0.667, 0.667, 0.667);
+uniform float shininess = 30.0;
+uniform vec3 wrapRGB = vec3(1.0, 1.0, 1.0);

data/lib/mittsu/opengl/shader/lib/phong/phong_vertex.rbsl

@@ -0,0 +1,43 @@
+#define PHONG
+  out vec3 vViewPosition;
+#ifndef FLAT_SHADED
+  out vec3 vNormal;
+#endif
+
+#include common
+#include map_pars_vertex
+#include lightmap_pars_vertex
+#include envmap_pars_vertex
+#include lights_phong_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
+
+  #ifndef FLAT_SHADED // Normal computed with derivatives when FLAT_SHADED
+    vNormal = normalize( transformedNormal );
+  #endif
+
+  #include morphtarget_vertex
+  #include skinning_vertex
+  #include default_vertex
+  #include logdepthbuf_vertex
+
+  vViewPosition = -mvPosition.xyz;
+
+  #include worldpos_vertex
+  #include envmap_vertex
+  #include lights_phong_vertex
+  #include shadowmap_vertex
+}

data/lib/mittsu/opengl/shader/lib.rb

@@ -0,0 +1,45 @@
+require 'mittsu/opengl/shader/uniforms_utils'
+require 'mittsu/opengl/shader/uniforms_lib'
+require 'mittsu/opengl/shader/chunk'
+require 'mittsu/opengl/shader/rbsl_loader'
+
+module Mittsu
+  class OpenGL::Shader
+    module Lib
+      class Instance
+        attr_accessor :uniforms, :vertex_shader, :fragment_shader
+        def initialize(options = {})
+          @uniforms = options.fetch(:uniforms)
+          @vertex_shader = options.fetch(:vertex_shader)
+          @fragment_shader = options.fetch(:fragment_shader)
+        end
+    
+        def self.load_from_file(name)
+          Instance.new(
+            uniforms: RBSLLoader.load_uniforms(File.read(File.join(__dir__, 'lib', name, "#{name}_uniforms.rbslu")), UniformsLib),
+            vertex_shader: RBSLLoader.load_shader(File.read(File.join(__dir__, 'lib', name, "#{name}_vertex.rbsl")), Chunk),
+            fragment_shader: RBSLLoader.load_shader(File.read(File.join(__dir__, 'lib', name, "#{name}_fragment.rbsl")), Chunk)
+          )
+        end
+      end
+      private_constant :Instance
+  
+      SHADER_LIB_HASH = Hash.new { |h, k|
+        h[k] = Instance.load_from_file(k.to_s)
+      }
+  
+      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
+  
+      def self.[](id)
+        SHADER_LIB_HASH[id]
+      end
+    end
+  end
+end

data/lib/mittsu/opengl/shader/rbsl_loader.rb

@@ -0,0 +1,168 @@
+module Mittsu
+  class OpenGL::Shader
+    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
+end

data/lib/mittsu/opengl/shader/templates/fragment.glsl.erb

@@ -0,0 +1,105 @@
+#version 330
+
+// (parameters[:bump_map] || parameters[:normal_map] || parameters[:flat_shading]) ? '#extension GL_OES_standard_derivatives : enable' : '', # TODO: does extension exist in OpenGL?
+
+<%= custom_defines %>
+
+#define MAX_DIR_LIGHTS <%= parameters[:max_dir_lights] %>
+#define MAX_POINT_LIGHTS <%= parameters[:max_point_lights] %>
+#define MAX_SPOT_LIGHTS <%= parameters[:max_spot_lights] %>
+#define MAX_HEMI_LIGHTS <%= parameters[:max_hemi_lights] %>
+
+#define MAX_SHADOWS <%= parameters[:max_shadows] %>
+
+<% if parameters[:alpha_test] %>
+  #define ALPHATEST <%= parameters[:alpha_test].to_f %>
+<% end %>
+
+<% if @renderer.gamma_input %>
+  #define GAMMA_INPUT
+<% end %>
+<% if @renderer.gamma_output %>
+  #define GAMMA_OUTPUT
+<% end %>
+#define GAMMA_FACTOR <%= gamma_factor_define %>
+
+<% if parameters[:use_fog] && parameters[:fog] %>
+  #define USE_FOG
+<% end %>
+<% if parameters[:use_fog] && parameters[:fog_exp] %>
+  #define FOG_EXP2
+<% end %>
+
+<% if parameters[:map] %>
+  #define USE_MAP
+<% end %>
+<% if parameters[:env_map] %>
+  #define USE_ENVMAP
+<% end %>
+<% if parameters[:env_map] %>
+  #define <%= env_map_type_define %>
+<% end %>
+<% if parameters[:env_map] %>
+  #define <%= env_map_mode_define %>
+<% end %>
+<% if parameters[:env_map] %>
+  #define <%= env_map_blending_define %>
+<% end %>
+<% if parameters[:light_map] %>
+  #define USE_LIGHTMAP
+<% end %>
+<% if parameters[:bump_map] %>
+  #define USE_BUMPMAP
+<% end %>
+<% if parameters[:normal_map] %>
+  #define USE_NORMALMAP
+<% end %>
+<% if parameters[:specular_map] %>
+  #define USE_SPECULARMAP
+<% end %>
+<% if parameters[:alpha_map] %>
+  #define USE_ALPHAMAP
+<% end %>
+<% if parameters[:vertex_colors] %>
+  #define USE_COLOR
+<% end %>
+
+<% if parameters[:flat_shading] %>
+  #define FLAT_SHADED
+<% end %>
+
+<% if parameters[:metal] %>
+  #define METAL
+<% end %>
+<% if parameters[:wrap_around] %>
+  #define WRAP_AROUND
+<% end %>
+<% if parameters[:double_sided] %>
+  #define DOUBLE_SIDED
+<% end %>
+<% if parameters[:flip_sided] %>
+  #define FLIP_SIDED
+<% end %>
+
+<% if parameters[:shadow_map_enabled] %>
+  #define USE_SHADOWMAP
+<% end %>
+<% if parameters[:shadow_map_enabled] %>
+  #define <%= shadow_map_type_define %>
+<% end %>
+<% if parameters[:shadow_map_debug] %>
+  #define SHADOWMAP_DEBUG
+<% end %>
+<% if parameters[:'shadow_map_cascade'] %>
+  #define SHADOWMAP_CASCADE
+<% end %>
+
+<% if parameters[:logarithmic_depth_buffer] %>
+  #define USE_LOGDEPTHBUF
+<% end %>
+// @renderer._GL.ExtensionFragDepth ? '#define USE_LOGDEPTHBUF_EXT' : '',
+
+uniform mat4 viewMatrix;
+uniform vec3 cameraPosition;
+
+layout(location = 0) out vec4 fragColor;

data/lib/mittsu/opengl/shader/templates/vertex.glsl.erb

@@ -0,0 +1,143 @@
+#version 330
+
+<%= custom_defines %>
+
+<% if parameters[:supports_vertex_textures] %>
+  #define VERTEX_TEXTURES
+<% end %>
+
+<% if @renderer.gamma_input %>
+  #define GAMMA_INPUT
+<% end %>
+<% if @renderer.gamma_output %>
+  #define GAMMA_OUTPUT
+<% end %>
+#define GAMMA_FACTOR <%= gamma_factor_define %>
+
+#define MAX_DIR_LIGHTS <%= parameters[:max_dir_lights] %>
+#define MAX_POINT_LIGHTS <%= parameters[:max_point_lights] %>
+#define MAX_SPOT_LIGHTS <%= parameters[:max_spot_lights] %>
+#define MAX_HEMI_LIGHTS <%= parameters[:max_hemi_lights] %>
+
+#define MAX_SHADOWS <%= parameters[:max_shadows] %>
+
+#define MAX_BONES <%= parameters[:max_bones] %>
+
+<% if parameters[:map] %>
+  #define USE_MAP
+<% end %>
+<% if parameters[:env_map] %>
+  #define USE_ENVMAP
+<% end %>
+<% if parameters[:env_map] %>
+  #define <%= env_map_mode_define %>
+<% end %>
+<% if parameters[:light_map] %>
+  #define USE_LIGHTMAP
+<% end %>
+<% if parameters[:bump_map] %>
+  #define USE_BUMPMAP
+<% end %>
+<% if parameters[:normal_map] %>
+  #define USE_NORMALMAP
+<% end %>
+<% if parameters[:specular_map] %>
+  #define USE_SPECULARMAP
+<% end %>
+<% if parameters[:alpha_map] %>
+  #define USE_ALPHAMAP
+<% end %>
+<% if parameters[:vertex_colors] %>
+  #define USE_COLOR
+<% end %>
+
+<% if parameters[:flat_shading] %>
+  #define FLAT_SHADED
+<% end %>
+
+<% if parameters[:skinning] %>
+  #define USE_SKINNING
+<% end %>
+<% if parameters[:use_vertex_texture] %>
+  #define BONE_TEXTURE
+<% end %>
+
+<% if parameters[:morph_targets] %>
+  #define USE_MORPHTARGETS
+<% end %>
+<% if parameters[:morph_normals] %>
+  #define USE_MORPHNORMALS
+<% end %>
+<% if parameters[:wrap_around] %>
+  #define WRAP_AROUND
+<% end %>
+<% if parameters[:double_sided] %>
+  #define DOUBLE_SIDED
+<% end %>
+<% if parameters[:flip_sided] %>
+  #define FLIP_SIDED
+<% end %>
+
+<% if parameters[:shadow_map_enabled] %>
+  #define USE_SHADOWMAP
+<% end %>
+<% if parameters[:shadow_map_enabled] %>
+  #define <%= shadow_map_type_define %>
+<% end %>
+<% if parameters[:shadow_map_debug] %>
+  #define SHADOWMAP_DEBUG
+<% end %>
+<% if parameters[:shadow_map_cascade] %>
+  #define SHADOWMAP_CASCADE
+<% end %>
+
+<% if parameters[:size_attenuation] %>
+  #define USE_SIZEATTENUATION
+<% end %>
+
+<% if parameters[:logarithmic_depth_buffer] %>
+  #define USE_LOGDEPTHBUF
+<% end %>
+// @renderer._GL.ExtensionFragDepth ? '#define USE_LOGDEPTHBUF_EXT' : '',
+
+
+uniform mat4 modelMatrix;
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform mat4 viewMatrix;
+uniform mat3 normalMatrix;
+uniform vec3 cameraPosition;
+
+in vec3 position;
+in vec3 normal;
+in vec2 uv;
+in vec2 uv2;
+
+#ifdef USE_COLOR
+  in vec3 color;
+#endif
+
+#ifdef USE_MORPHTARGETS
+  in vec3 morphTarget0;
+  in vec3 morphTarget1;
+  in vec3 morphTarget2;
+  in vec3 morphTarget3;
+
+  #ifdef USE_MORPHNORMALS
+    in vec3 morphNormal0;
+    in vec3 morphNormal1;
+    in vec3 morphNormal2;
+    in vec3 morphNormal3;
+  #else
+    in vec3 morphTarget4;
+    in vec3 morphTarget5;
+    in vec3 morphTarget6;
+    in vec3 morphTarget7;
+  #endif
+
+#endif
+
+#ifdef USE_SKINNING
+  in vec4 skinIndex;
+  in vec4 skinWeight;
+#endif

data/lib/mittsu/opengl/shader/uniforms_lib.rb

@@ -0,0 +1,86 @@
+require 'mittsu/math'
+
+module Mittsu
+  class OpenGL::Shader
+    UniformsLib = {
+      common: {
+        'diffuse' => Uniform.new(:color, Color.new(0xeeeeee)),
+        'opacity' => Uniform.new(:float, 1.0),
+
+        'map' => Uniform.new(:texture, nil),
+        'offsetRepeat' => Uniform.new(:vec4, Vector4.new(0.0, 0.0, 1.0, 1.0)),
+
+        'lightMap' => Uniform.new(:texture, nil),
+        'specularMap' => Uniform.new(:texture, nil),
+        'alphaMap' => Uniform.new(:texture, nil),
+
+        'envMap' => Uniform.new(:texture, nil),
+        'flipEnvMap' => Uniform.new(:float, -1.0),
+        'reflectivity' => Uniform.new(:float, 1.0),
+        'refractionRatio' => Uniform.new(:float, 0.98),
+
+        'morphTargetInfluences' => Uniform.new(:float, 0.0)
+      },
+
+      bump: {
+        'bumpMap' => Uniform.new(:texture, nil),
+        'bumpScale' => Uniform.new(:float, 1.0)
+      },
+
+     	normal_map: {
+        'normalMap' => Uniform.new(:texture, nil),
+        'normalScale' => Uniform.new(:vec2, Vector2.new(1.0, 1.0))
+     	},
+
+      fog: {
+        'fogDensity' => Uniform.new(:float, 0.00025),
+        'fogNear' => Uniform.new(:float, 1.0),
+        'fogFar' => Uniform.new(:float, 2000.0),
+        'fogColor' => Uniform.new(:color, Color.new(0xffffff))
+      },
+
+      lights: {
+        'ambientLightColor' => Uniform.new(:color, Color.new(0xffffff)),
+
+        'directionalLightDirection' => Uniform.new(:'vec3[]', []),
+        'directionalLightColor' => Uniform.new(:'color[]', []),
+
+        'hemisphereLightDirection' => Uniform.new(:'vec3[]', []),
+        'hemisphereLightSkyColor' => Uniform.new(:'color[]', []),
+        'hemisphereLightGroundColor' => Uniform.new(:'color[]', []),
+
+        'pointLightColor' => Uniform.new(:'color[]', []),
+        'pointLightPosition' => Uniform.new(:'vec3[]', []),
+        'pointLightDistance' => Uniform.new(:'float[]', []),
+        'pointLightDecay' => Uniform.new(:'float[]', []),
+
+        'spotLightColor' => Uniform.new(:'color[]', []),
+        'spotLightPosition' => Uniform.new(:'vec3[]', []),
+        'spotLightDirection' => Uniform.new(:'vec3[]', []),
+        'spotLightDistance' => Uniform.new(:'float[]', []),
+        'spotLightAngleCos' => Uniform.new(:'float[]', []),
+        'spotLightExponent' => Uniform.new(:'float[]', []),
+        'spotLightDecay' => Uniform.new(:'float[]', [])
+      },
+
+      particle: {
+        'psColor' => Uniform.new(:color, Color.new(0xeeeeee)),
+        'opacity' => Uniform.new(:float, 1.0),
+        'size' => Uniform.new(:float, 1.0),
+        'scale' => Uniform.new(:float, 1.0),
+        'map' => Uniform.new(:texture, nil),
+        'offsetRepeat' => Uniform.new(:vec4, Vector4.new(0.0, 0.0, 1.0, 1.0))
+      },
+
+      shadow_map: {
+        'shadowMap' => Uniform.new(:'texture[]', []),
+        'shadowMapSize' => Uniform.new(:'vec2[]', []),
+
+        'shadowBias' => Uniform.new(:'float[]', []),
+        'shadowDarkness' => Uniform.new(:'float[]', []),
+
+        'shadowMatrix' => Uniform.new(:'mat4[]', [])
+      }
+    }
+  end
+end