mittsu 0.1.0

data/lib/mittsu/renderers/opengl/opengl_debug.rb

@@ -0,0 +1,38 @@
+require 'opengl'
+
+ERROR_STRINGS = {
+  OpenGL::GL_NO_ERROR => 'NO_ERROR',
+  OpenGL::GL_INVALID_ENUM => 'INVALID_ENUM',
+  OpenGL::GL_INVALID_VALUE => 'INVALID_VALUE',
+  OpenGL::GL_INVALID_OPERATION => 'INVALID_OPERATION',
+  OpenGL::GL_STACK_OVERFLOW => 'STACK_OVERFLOW',
+  OpenGL::GL_STACK_UNDERFLOW => 'STACK_UNDERFLOW',
+  OpenGL::GL_OUT_OF_MEMORY => 'OUT_OF_MEMORY',
+  # OpenGL::GL_TABLE_TOO_LARGE => 'TABLE_TOO_LARGE'
+}
+
+module OpenGLDebug
+  module OpenGLProxy
+    extend OpenGL
+  end
+
+  def self.load_lib
+    OpenGL.load_lib
+  end
+
+  OpenGL.constants.each do |c|
+    const_set c, OpenGL.const_get(c)
+  end
+
+  OpenGL.instance_methods.each do |m|
+    define_method m do |*args|
+      r = OpenGLProxy.send(m, *args)
+      call = "#{m}(#{args.map { |s| s.to_s[0..20] }.join(', ')})"
+      ret = r.nil? ? '' : " => #{r}"
+      puts "#{call}#{ret}"
+      e = OpenGLProxy.glGetError
+      raise "ERROR: #{m} => #{ERROR_STRINGS[e]}" unless e == OpenGL::GL_NO_ERROR
+      r
+    end
+  end
+end

data/lib/mittsu/renderers/opengl/opengl_program.rb

@@ -0,0 +1,402 @@
+require 'mittsu/renderers/opengl/opengl_shader'
+
+module Mittsu
+  class OpenGLProgram
+    attr_reader :id, :program, :uniforms, :attributes
+    attr_accessor :code, :used_times, :attributes, :vertex_shader, :fragment_shader
+
+    def initialize(renderer, code, material, parameters)
+      defines = material.defines || {} # TODO: setting to default object... ?
+      uniforms = material[:_opengl_shader][:uniforms]
+      attributes = material.attributes || [] # TODO: setting to default array... ?
+
+      vertex_shader = material[:_opengl_shader][:vertex_shader]
+      fragment_shader = material[:_opengl_shader][:fragment_shader]
+
+      # 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
+
+      shadow_map_type_define = 'SHADOWMAP_TYPE_BASIC'
+
+      if parameters[:shadow_map_type] == PCFShadowMap
+        shadow_map_type_define = 'SHADOWMAP_TYPE_PCF_SOFT'
+      elsif parameters[:shadow_map_type] == PCFSoftShadowMap
+        shadow_map_type_define = 'SHADOWMAP_TYPE_PCF_SOFT'
+      end
+
+      env_map_type_define = 'ENVMAP_TYPE_CUBE'
+      env_map_mode_define = 'ENVMAP_MODE_REFLECTION'
+      env_map_blending_define = 'ENVMAP_BLENDING_MULTIPLY'
+
+      if parameters[:env_map]
+        case material.env_map.mapping
+        when CubeReflectionMapping, CubeRefractionMapping
+          env_map_type_define = 'ENVMAP_TYPE_CUBE'
+        when EquirectangularReflectionMapping, EquirectangularRefractionMapping
+          env_map_type_define = 'ENVMAP_TYPE_EQUIREC'
+        when SphericalReflectionMapping
+          env_map_type_define = 'ENVMAP_TYPE_SPHERE'
+        end
+
+        case material.env_map.mapping
+        when CubeRefractionMapping, EquirectangularRefractionMapping
+          env_map_mode_define 'ENVMAP_MODE_REFRACTION'
+        end
+
+        case material.combine
+        when MultiplyOperation
+          env_map_blending_define = 'ENVMAP_BLENDING_MULTIPLY'
+        when MixOperation
+          env_map_blending_define = 'ENVMAP_BLENDING_MIX'
+        when AddOperation
+          env_map_blending_define = 'ENVMAP_BLENDING_ADD'
+        end
+      end
+
+      gamma_factor_define = (renderer.gamma_factor > 0) ? renderer.gamma_factor : 1.0
+
+      # puts 'building new program'
+
+      #
+
+      custom_defines = generate_defines(defines)
+
+      #
+
+      @program = glCreateProgram
+
+      if false # material.is_a?(RawShaderMaterial) # TODO: when RawShaderMaterial exists
+        prefix_vertex = ''
+        prefix_fragment = ''
+      else
+        prefix_vertex = [
+          '#version 330',
+          # TODO: do we need precision for an OpenGL program?
+          # "precision #{parameters[:precision]} float;",
+          # "precision #{parameters[:precision]} int;",
+
+          custom_defines,
+
+          parameters[:supports_vertex_textures] ? '#define VERTEX_TEXTURES' : '',
+
+          renderer.gamma_input ? '#define GAMMA_INPUT' : '',
+          renderer.gamma_output ? '#define GAMMA_OUTPUT' : '',
+          "#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]}",
+
+          parameters[:map] ? '#define USE_MAP' : '',
+          parameters[:env_map] ? '#define USE_ENVMAP' : '',
+          parameters[:env_map] ? "#define #{env_map_mode_define}" : '',
+          parameters[:light_map] ? '#define USE_LIGHTMAP' : '',
+          parameters[:bump_map] ? '#define USE_BUMPMAP' : '',
+          parameters[:normal_map] ? '#define USE_NORMALMAP' : '',
+          parameters[:specular_map] ? '#define USE_SPECULARMAP' : '',
+          parameters[:alpha_map] ? '#define USE_ALPHAMAP' : '',
+          parameters[:vertex_colors] ? '#define USE_COLOR' : '',
+
+          parameters[:flat_shading] ? '#define FLAT_SHADED': '',
+
+          parameters[:skinning] ? '#define USE_SKINNING' : '',
+          parameters[:use_vertex_texture] ? '#define BONE_TEXTURE' : '',
+
+          parameters[:morph_targets] ? '#define USE_MORPHTARGETS' : '',
+          parameters[:morph_normals] ? '#define USE_MORPHNORMALS' : '',
+          parameters[:wrap_around] ? '#define WRAP_AROUND' : '',
+          parameters[:double_sided] ? '#define DOUBLE_SIDED' : '',
+          parameters[:flip_sided] ? '#define FLIP_SIDED' : '',
+
+          parameters[:shadow_map_enabled] ? '#define USE_SHADOWMAP' : '',
+          parameters[:shadow_map_enabled] ? "#define #{shadow_map_type_define}" : '',
+          parameters[:shadow_map_debug] ? '#define SHADOWMAP_DEBUG' : '',
+          parameters[:shadow_map_cascade] ? '#define SHADOWMAP_CASCADE' : '',
+
+          parameters[:size_attenuation] ? '#define USE_SIZEATTENUATION' : '',
+
+          parameters[:logarithmic_depth_buffer] ? '#define USE_LOGDEPTHBUF' : '',
+          #renderer._glExtensionFragDepth ? '#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',
+        ].reject(&:empty?).join("\n") + "\n"
+
+        prefix_fragment = [
+          '#version 330',
+          # TODO: do we need precision for an OpenGL program?
+          # "precison #{parameters[:precision]} float;",
+          # "precison #{parameters[:precision]} int;",
+
+          # (parameters[:bump_map] || parameters[:normal_map] || parameters[:flat_shading]) ? '#extension GL_OES_standard_derivatives : enable' : '', # TODO: oes extension 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]}",
+
+          parameters[:alpha_test] ? "#define ALPHATEST #{parameters[:alpha_test].to_f}" : '',
+
+          renderer.gamma_input ? '#define GAMMA_INPUT' : '',
+          renderer.gamma_output ? '#define GAMMA_OUTPUT' : '',
+          "#define GAMMA_FACTOR #{gamma_factor_define}",
+
+          (parameters[:use_fog] && parameters[:fog]) ? '#define USE_FOG' : '',
+          (parameters[:use_fog] && parameters[:fog_exp]) ? '#define FOG_EXP2' : '',
+
+          parameters[:map] ? '#define USE_MAP' : '',
+          parameters[:env_map] ? '#define USE_ENVMAP' : '',
+          parameters[:env_map] ? "#define #{env_map_type_define}" : '',
+          parameters[:env_map] ? "#define #{env_map_mode_define}" : '',
+          parameters[:env_map] ? "#define #{env_map_blending_define}" : '',
+          parameters[:light_map] ? '#define USE_LIGHTMAP' : '',
+          parameters[:bump_map] ? '#define USE_BUMPMAP' : '',
+          parameters[:normal_map] ? '#define USE_NORMALMAP' : '',
+          parameters[:specular_map] ? '#define USE_SPECULARMAP' : '',
+          parameters[:alpha_map] ? '#define USE_ALPHAMAP' : '',
+          parameters[:vertex_colors] ? '#define USE_COLOR' : '',
+
+          parameters[:flat_shading] ? '#define FLAT_SHADED' : '',
+
+          parameters[:metal] ? '#define METAL' : '',
+          parameters[:wrap_around] ? '#define WRAP_AROUND' : '',
+          parameters[:double_sided] ? '#define DOUBLE_SIDED' : '',
+          parameters[:flip_sided] ? '#define FLIP_SIDED' : '',
+
+
+          parameters[:shadow_map_enabled] ? '#define USE_SHADOWMAP' : '',
+          parameters[:shadow_map_enabled] ? "#define #{shadow_map_type_define}" : '',
+          parameters[:shadow_map_debug] ? '#define SHADOWMAP_DEBUG' : '',
+          parameters[:'shadow_map_cascade'] ? '#define SHADOWMAP_CASCADE' : '',
+
+          parameters[:logarithmic_depth_buffer] ? '#define USE_LOGDEPTHBUF' : '',
+          #renderer._glExtensionFragDepth ? '#define USE_LOGDEPTHBUF_EXT' : '',
+
+          'uniform mat4 viewMatrix;',
+          'uniform vec3 cameraPosition;',
+
+          'layout(location = 0) out vec4 fragColor;'
+        ].reject(&:empty?).join("\n") + "\n"
+      end
+
+      gl_vertex_shader = OpenGLShader.new(GL_VERTEX_SHADER, prefix_vertex + vertex_shader)
+      gl_fragment_shader = OpenGLShader.new(GL_FRAGMENT_SHADER, prefix_fragment + fragment_shader)
+
+      glAttachShader(@program, gl_vertex_shader.shader)
+      glAttachShader(@program, gl_fragment_shader.shader)
+
+      # 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
+
+      #   glBindAttributeLocation(program, 0, index0_attribute_name)
+      # end
+
+      glLinkProgram(@program)
+
+      log_info = program_info_log
+
+      if !link_status
+        puts "ERROR: Mittsu::OpenGLProgram: shader error: #{glGetError}, GL_INVALID_STATUS, #{glGetProgramParameter(program, GL_VALIDATE_STATUS)}, glGetProgramParameterInfoLog, #{program_log_info}"
+      end
+
+      if !log_info.empty?
+        puts "WARNING: Mittsu::OpenGLProgram: glGetProgramInfoLog, #{log_info}"
+        # TODO: useless in OpenGL ???
+        # puts "WARNING: #{glGetExtension( 'OPENGL_debug_shaders' ).getTranslatedShaderSource( glVertexShader )}"
+        # puts "WARNING: #{glGetExtension( 'OPENGL_debug_shaders' ).getTranslatedShaderSource( glFragmentShader )}"
+      end
+
+      # clean up
+
+      glDeleteShader(gl_vertex_shader.shader)
+      glDeleteShader(gl_fragment_shader.shader)
+
+      # cache uniform locations
+
+      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 = cache_uniform_locations(program, identifiers)
+
+      # cache attributes locations
+
+      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 = cache_attribute_locations(program, identifiers)
+
+      @id = (@@id ||= 1).tap { @@id += 1 }
+      @code = code
+      @used_times = 2
+      @vertex_shader = gl_vertex_shader
+      @fragment_shader = gl_fragment_shader
+    end
+
+    private
+
+    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 cache_uniform_locations(program, identifiers)
+      uniforms = {}
+
+      identifiers.each do |id|
+        uniforms[id] = glGetUniformLocation(program, id)
+      end
+
+      uniforms
+    end
+
+    def cache_attribute_locations(program, identifiers)
+      attributes = {}
+
+      identifiers.each do |id|
+        attributes[id] = glGetAttribLocation(program, id)
+      end
+
+      attributes
+    end
+
+    def link_status
+      ptr = ' '*8
+      glGetProgramiv @program, GL_LINK_STATUS, ptr
+      ptr.unpack('L')[0]
+    end
+
+    def program_info_log
+      ptr = ' '*8
+      glGetProgramiv @program, GL_INFO_LOG_LENGTH, ptr
+      length = ptr.unpack('L')[0]
+
+      if length > 0
+        log = ' '*length
+        glGetProgramInfoLog @program, length, ptr, log
+        log.unpack("A#{length}")[0]
+      else
+        ''
+      end
+    end
+  end
+end

data/lib/mittsu/renderers/opengl/opengl_shader.rb

@@ -0,0 +1,58 @@
+require 'fiddle'
+
+module Mittsu
+  class OpenGLShader
+    attr_reader :shader
+
+    def initialize(type, string)
+      @shader = glCreateShader(type)
+      # filename = type == GL_VERTEX_SHADER ? 'vertex.glsl' : 'fragment.glsl'
+      # File.write filename, string
+
+      string_pointer = Fiddle::Pointer[string]
+      string_length = Fiddle::Pointer[string.length]
+
+      glShaderSource(@shader, 1, string_pointer.ref, string_length.ref)
+      glCompileShader(@shader)
+
+      if !compile_status
+        puts "ERROR: Mittsu::OpenGLShader: Shader couldn't compile"
+      end
+
+      log_info = shader_info_log
+      if !log_info.empty?
+        puts "WARNING: Mittsu::OpenGLShader: glGetShaderInfoLog, #{log_info}"
+        puts add_line_numbers(string)
+      end
+    end
+
+    private
+
+    def compile_status
+      ptr = ' '*8
+      glGetShaderiv @shader, GL_COMPILE_STATUS, ptr
+      ptr.unpack('L')[0]
+    end
+
+    def shader_info_log
+      ptr = ' '*8
+      glGetShaderiv @shader, GL_INFO_LOG_LENGTH, ptr
+      length = ptr.unpack('L')[0]
+
+      if length > 0
+        log = ' '*length
+        glGetShaderInfoLog @shader, length, ptr, log
+        log.unpack("A#{length}")[0]
+      else
+        ''
+      end
+    end
+
+    def add_line_numbers(string)
+      string.split("\n").each_with_index.map { |line, i|
+        line_number = "#{i + 1}".rjust(4, ' ')
+        "#{line_number}: #{line}"
+      }.join("\n")
+    end
+  end
+end