mittsu-opengl 0.5.0

data/lib/mittsu/opengl/plugins/sprite_vertex.glsl

@@ -0,0 +1,31 @@
+#version 330
+
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform float rotation;
+uniform vec2 scale;
+uniform vec2 uvOffset;
+uniform vec2 uvScale;
+
+in vec2 position;
+in vec2 uv;
+
+out vec2 vUV;
+
+void main() {
+  vUV = uvOffset + uv * uvScale;
+
+  vec2 alignedPosition = position * scale;
+
+  vec2 rotatedPosition;
+  rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
+  rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
+
+  vec4 finalPosition;
+
+  finalPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
+  finalPosition.xy += rotatedPosition;
+  finalPosition = projectionMatrix * finalPosition;
+
+  gl_Position = finalPosition;
+}

data/lib/mittsu/opengl/program.rb

@@ -0,0 +1,250 @@
+require 'erb'
+require 'mittsu/opengl/shader'
+
+module Mittsu
+  class OpenGL::Program
+    attr_reader :id, :program, :uniforms
+    attr_accessor :code, :used_times, :attributes, :vertex_shader, :fragment_shader
+
+    def initialize(renderer, code, material, parameters)
+      @id = (@@id ||= 1).tap { @@id += 1 }
+      @renderer = renderer
+
+      compile_and_link_program(material, parameters)
+
+      cache_uniform_locations(material.shader[:uniforms] || {}, parameters)
+      cache_attribute_locations(material.attributes || {}, parameters)
+
+      @code = code
+      @used_times = 2
+    end
+
+    private
+
+    def compile_and_link_program(material, parameters)
+      @program = GL.CreateProgram
+
+      # TODO: necessary for OpenGL?
+      # index0_attribute_name = material.index0_attribute_name
+      #
+      # if index0_attribute_name.nil? && parameters[:morph_targets]
+      #   # programs with morph_targets displace position of attribute 0
+      #
+      #   index0_attribute_name = 'position'
+      # end
+
+      compile_shaders(material, parameters)
+
+      # if !index0_attribute_name.nil?
+        # TODO: is this necessary in OpenGL ???
+        # Force a particular attribute to index 0.
+        # because potentially expensive emulation is done by __browser__ if attribute 0 is disabled. (no browser here!)
+        # And, color, for example is often automatically bound to index 0 so disabling it
+
+      #   GL.BindAttributeLocation(program, 0, index0_attribute_name)
+      # end
+
+      GL.LinkProgram(@program)
+      check_for_link_errors
+      post_link_clean_up
+    end
+
+    def generate_defines(defines)
+      chunks = []
+
+      defines.each do |d, value|
+        next if value == false
+
+        chunk = "#define #{d} #{value}"
+        chunks << chunk
+      end
+
+      chunks.join("\n")
+    end
+
+    def link_status
+      ptr = ' '*8
+      GL.GetProgramiv @program, GL::LINK_STATUS, ptr
+      ptr.unpack('L')[0]
+    end
+
+    def program_info_log
+      ptr = ' '*8
+      GL.GetProgramiv @program, GL::INFO_LOG_LENGTH, ptr
+      length = ptr.unpack('L')[0]
+
+      if length > 0
+        log = ' '*length
+        GL.GetProgramInfoLog @program, length, ptr, log
+        log.unpack("A#{length}")[0]
+      else
+        ''
+      end
+    end
+
+    def check_for_link_errors
+      log_info = program_info_log
+
+      if !link_status
+        puts "ERROR: Mittsu::OpenGL::Program: shader error: #{GL.GetError}, GL::INVALID_STATUS, #{GL.GetProgramParameter(program, GL::VALIDATE_STATUS)}, GL.GetProgramParameterInfoLog, #{log_info}"
+      end
+
+      if !log_info.empty?
+        puts "WARNING: Mittsu::OpenGL::Program: GL.GetProgramInfoLog, #{log_info}"
+        # TODO: useless in OpenGL ???
+        # puts "WARNING: #{GL.GetExtension( 'OPENGL_debug_shaders' ).getTranslatedShaderSource( GL.VertexShader )}"
+        # puts "WARNING: #{GL.GetExtension( 'OPENGL_debug_shaders' ).getTranslatedShaderSource( GL.FragmentShader )}"
+      end
+    end
+
+    def get_shadow_map_define(shadow_map_param)
+      case shadow_map_param
+      when PCFShadowMap
+        'SHADOWMAP_TYPE_PCF'
+      when PCFSoftShadowMap
+        'SHADOWMAP_TYPE_PCF_SOFT'
+      else
+        'SHADOWMAP_TYPE_BASIC'
+      end
+    end
+
+    def get_env_map_type_define(env_map_param, material)
+      return 'ENVMAP_TYPE_CUBE' unless env_map_param
+      case material.env_map.mapping
+      when CubeReflectionMapping, CubeRefractionMapping
+        'ENVMAP_TYPE_CUBE'
+      when EquirectangularReflectionMapping, EquirectangularRefractionMapping
+        'ENVMAP_TYPE_EQUIREC'
+      when SphericalReflectionMapping
+        'ENVMAP_TYPE_SPHERE'
+      else
+        'ENVMAP_TYPE_CUBE'
+      end
+    end
+
+    def get_env_map_mode_define(env_map_param, material)
+      return 'ENVMAP_MODE_REFLECTION' unless env_map_param
+      case material.env_map.mapping
+      when CubeRefractionMapping, EquirectangularRefractionMapping
+        'ENVMAP_MODE_REFRACTION'
+      else
+        'ENVMAP_MODE_REFLECTION'
+      end
+    end
+
+    def get_env_map_blending_define(env_map_param, material)
+      return 'ENVMAP_BLENDING_MULTIPLY' unless env_map_param
+      case material.combine
+      when MultiplyOperation
+        'ENVMAP_BLENDING_MULTIPLY'
+      when MixOperation
+        'ENVMAP_BLENDING_MIX'
+      when AddOperation
+        'ENVMAP_BLENDING_ADD'
+      else
+        'ENVMAP_BLENDING_MULTIPLY'
+      end
+    end
+
+    def compile_shaders(material, parameters)
+      shadow_map_type_define = get_shadow_map_define(parameters[:shadow_map_type])
+
+      env_map_type_define = get_env_map_type_define(parameters[:env_map], material)
+      env_map_mode_define = get_env_map_mode_define(parameters[:env_map], material)
+      env_map_blending_define = get_env_map_blending_define(parameters[:env_map], material)
+
+      gamma_factor_define = (@renderer.gamma_factor > 0) ? @renderer.gamma_factor : 1.0
+
+      custom_defines = generate_defines(material.defines || {})
+
+      if false # material.is_a?(RawShaderMaterial) # TODO: when RawShaderMaterial exists
+        prefix_vertex = ''
+        prefix_fragment = ''
+      else
+        prefix_vertex = File.read(File.expand_path('../shader/templates/vertex.glsl.erb', __FILE__))
+        prefix_fragment = File.read(File.expand_path('../shader/templates/fragment.glsl.erb', __FILE__))
+      end
+
+      @vertex_shader = OpenGL::Shader.new(GL::VERTEX_SHADER, compile_shader_template(prefix_vertex + material.shader[:vertex_shader], binding))
+      @fragment_shader = OpenGL::Shader.new(GL::FRAGMENT_SHADER, compile_shader_template(prefix_fragment + material.shader[:fragment_shader], binding))
+
+      GL.AttachShader(@program, @vertex_shader.shader)
+      GL.AttachShader(@program, @fragment_shader.shader)
+    end
+
+    def compile_shader_template(template, b)
+      ERB.new(template).result(b)
+    end
+
+    def post_link_clean_up
+      GL.DeleteShader(@vertex_shader.shader)
+      GL.DeleteShader(@fragment_shader.shader)
+    end
+
+    def cache_uniform_locations(uniforms, parameters)
+      identifiers = [
+        'viewMatrix',
+        'modelViewMatrix',
+        'projectionMatrix',
+        'normalMatrix',
+        'modelMatrix',
+        'cameraPosition',
+        'morphTargetInfluences',
+        'bindMatrix',
+        'bindMatrixInverse'
+      ]
+
+      if parameters[:use_vertex_texture]
+        identifiers << 'boneTexture'
+        identifiers << 'boneTextureWidth'
+        identifiers << 'boneTextureHeight'
+      else
+        identifiers << 'boneGlobalMatrices'
+      end
+
+      if parameters[:logarithmic_depth_buffer]
+        identifiers << 'logDepthBufFC'
+      end
+
+      uniforms.each do |k, v|
+        identifiers << k.to_s
+      end
+
+      @uniforms = {}
+      identifiers.each do |id|
+        @uniforms[id] = GL.GetUniformLocation(program, id)
+      end
+    end
+
+    def cache_attribute_locations(attributes, parameters)
+      identifiers = [
+        'position',
+        'normal',
+        'uv',
+        'uv2',
+        'tangent',
+        'color',
+        'skinIndex',
+        'skinWeight',
+        'lineDistance'
+      ]
+
+      parameters[:max_morph_targets].times do |i|
+        identifiers << "morphTarget#{i}"
+      end
+
+      parameters[:max_morph_normals].times do |i|
+        identifiers << "morphNormal#{i}"
+      end
+
+      attributes.each do |k, v|
+        identifiers << k
+      end
+
+      @attributes = {}
+      identifiers.each do |id|
+        @attributes[id] = GL.GetAttribLocation(program, id)
+      end
+    end
+  end
+end