mittsu-opengl 0.5.0

data/lib/mittsu/opengl/geometry_like.rb

@@ -0,0 +1,132 @@
+module Mittsu
+  module OpenGL::GeometryLike
+    CONST_BUFFER_NAMES = [
+      :vertex,
+      :color,
+      :normal,
+      :tangent,
+      :uv,
+      :uv2,
+      :skin_indices,
+      :skin_weight,
+      :line_distance,
+      :face,
+      :line
+    ]
+    attr_accessor(*CONST_BUFFER_NAMES.map(&:to_s).map { |name| "#{name}_buffer" }.map(&:to_sym))
+    attr_accessor(*CONST_BUFFER_NAMES.map(&:to_s).map { |name| "#{name}_array" }.map(&:to_sym))
+
+    attr_accessor :vertex_array_object,
+                  :num_morph_targets,
+                  :num_morph_normals,
+                  :morph_targets_buffers,
+                  :morph_normals_buffers,
+                  :morph_targets_arrays,
+                  :morph_normals_arrays,
+                  :faces3,
+                  :type_array,
+                  :face_count,
+                  :line_count,
+                  :particle_count,
+                  :initted_arrays,
+                  :custom_attributes_list,
+                  :num_vertices,
+                  :renderer
+
+    def bind_vertex_array_object
+      GL.BindVertexArray(@vertex_array_object) if @vertex_array_object
+    end
+
+    def update_vertex_buffer(attribute)
+      GL.BindBuffer(GL::ARRAY_BUFFER, @vertex_buffer)
+      @renderer.state.enable_attribute(attribute)
+      GL.VertexAttribPointer(attribute, 3, GL::FLOAT, GL::FALSE, 0, 0)
+    end
+
+    def update_other_buffers(object, material, attributes)
+      update_custom_attributes(attributes)
+
+      update_color_buffer(attributes['color'], object, material)
+      update_normal_buffer(attributes['normal'])
+      update_tangent_buffer(attributes['tangent'])
+      update_uv_buffers(attributes['uv'], attributes['uv2'], object, material)
+
+      if material.skinning
+        update_skin_buffers(attributes['skin_index'], attributes['skin_weight'])
+      end
+
+      update_line_distances_buffer(attributes['line_distances'])
+    end
+
+    private
+
+    def attribute_exists?(attribute)
+      attribute && attribute >= 0
+    end
+
+    def update_color_buffer(attribute, object, material)
+      return unless attribute_exists?(attribute)
+      if object.geometry.colors.length > 0 || object.geometry.faces.length > 0
+        update_attribute(attribute, @color_buffer, 3)
+      elsif material.default_attribute_values
+        GL.VertexAttrib3fv(attribute, material.default_attribute_values.color)
+      end
+    end
+
+    def update_normal_buffer(attribute)
+      return unless attribute_exists?(attribute)
+      update_attribute(attribute, @normal_buffer, 3)
+    end
+
+    def update_tangent_buffer(attribute)
+      return unless attribute_exists?(attribute)
+      update_attribute(attribute, @tangent_buffer, 4)
+    end
+
+    def update_uv_buffers(uv_attribute, uv2_attribute, object, material)
+      update_uv_buffer(uv_attribute, @uv_buffer, object, 0)
+      update_uv_buffer(uv2_attribute, @uv2_buffer, object, 1)
+    end
+
+    def update_uv_buffer(attribute, buffer, object, index)
+      return unless attribute_exists?(attribute)
+      if object.geometry.face_vertex_uvs[index]
+        update_attribute(attribute, buffer, 2)
+      else
+        # TODO default_attribute_value ???
+        # GL.VertexAttrib2fv(attribute, default_attribute_value)
+      end
+    end
+
+    def update_skin_buffers(index_attribute, weight_attribute)
+      return unless attribute_exists?(index_attribute) && attribute_exists?(weight_attribute)
+      update_attribute(attribute, @skin_indices_buffer, 4)
+      update_attribute(attribute, @skin_weight_buffer, 4)
+    end
+
+    def update_line_distances_buffer(attribute)
+      return unless attribute_exists?(attribute)
+      update_attribute(attribute, @line_distance_buffer, 1)
+    end
+
+    def update_custom_attributes(attributes)
+      if @custom_attributes_list
+        @custom_attributes_list.each do |custom_attribute|
+          belongs_to_attribute = attributes[custom_attribute.buffer.belongs_to_attribute]
+          update_custom_attribute(custom_attribute, belongs_to_attribute)
+        end
+      end
+    end
+
+    def update_custom_attribute(custom_attribute, belongs_to_attribute)
+      return unless attribute_exists?(belongs_to_attribute)
+      update_attribute(attribute, custom_attribute.buffer, custom_attribute.size)
+    end
+
+    def update_attribute(attribute, buffer, size)
+      GL.BindBuffer(GL::ARRAY_BUFFER, buffer)
+      @renderer.state.enable_attribute(attribute)
+      GL.VertexAttribPointer(attribute, size, GL::FLOAT, GL::FALSE, 0, 0)
+    end
+  end
+end

data/lib/mittsu/opengl/gl_debug.rb

@@ -0,0 +1,85 @@
+require 'opengl'
+
+ERROR_STRINGS = {
+  GL::NO_ERROR => 'NO_ERROR',
+  GL::INVALID_ENUM => 'INVALID_ENUM',
+  GL::INVALID_VALUE => 'INVALID_VALUE',
+  GL::INVALID_OPERATION => 'INVALID_OPERATION',
+  GL::STACK_OVERFLOW => 'STACK_OVERFLOW',
+  GL::STACK_UNDERFLOW => 'STACK_UNDERFLOW',
+  GL::OUT_OF_MEMORY => 'OUT_OF_MEMORY',
+  # GL::TABLE_TOO_LARGE => 'TABLE_TOO_LARGE'
+}
+
+OriginalGL = GL
+
+module OpenGLDebug
+  class DebugShader
+    def initialize(handle)
+      @handle = handle
+      @uniforms = {}
+    end
+
+    def set_uniform(handle, name)
+      @uniforms[handle] = name
+    end
+
+    def get_uniform_name(handle)
+      @uniforms[handle]
+    end
+  end
+
+  def self.load_lib(*args)
+    OriginalGL.load_lib(*args)
+  end
+
+  OriginalGL.constants.each do |c|
+    const_set c, OriginalGL.const_get(c)
+  end
+
+  class << self
+    OriginalGL::GL_FUNCTION_SYMBOLS
+      .map { |m| m.to_s.gsub(/^gl/, '').to_sym }
+      .each do |m|
+        define_method(m) do |*args|
+          call_debug_method(m, caller[0], *args)
+        end
+      end
+
+    def call_debug_method m, called_from = caller[0], *args
+      if m.to_s.start_with?('Uniform')
+        uniform_name = @@current_shader.get_uniform_name(args.first)
+        call = "#{m}('#{uniform_name}',#{args[1..-1].map { |s| s.to_s[0..20] }.join(', ')})"
+      else
+        call = "#{m}(#{args.map { |s| s.to_s[0..20] }.join(', ')})"
+      end
+      print call
+      r = OriginalGL.send(m, *args)
+      ret = r.nil? ? '' : " => #{r}"
+      puts "#{ret} (#{called_from})"
+      e = OriginalGL.GetError
+      raise "ERROR: #{m} => #{ERROR_STRINGS[e]}" unless e == GL::NO_ERROR
+      r
+    end
+
+    def CreateProgram
+      call_debug_method(:CreateProgram, caller[0]).tap do |handle|
+        @@shaders ||= {}
+        @@shaders[handle] = DebugShader.new(handle)
+      end
+    end
+
+    def UseProgram(handle)
+      @@current_shader = @@shaders[handle]
+      call_debug_method(:UseProgram, caller[0], handle)
+    end
+
+    def GetUniformLocation(program, name)
+      call_debug_method(:GetUniformLocation, caller[0], program, name).tap do |handle|
+        @@shaders[program].set_uniform(handle, name)
+      end
+    end
+  end
+end
+
+GL = OpenGLDebug

data/lib/mittsu/opengl/gl_extensions.rb

@@ -0,0 +1,42 @@
+module GL
+  def self.CreateBuffer
+    @_b ||= ' '*8
+    ::GL.GenBuffers(1, @_b)
+    @_b.unpack('L')[0]
+  end
+
+  def self.CreateTexture
+    @_b ||= ' '*8
+    ::GL.GenTextures(1, @_b)
+    @_b.unpack('L')[0]
+  end
+
+  def self.CreateVertexArray
+    @_b ||= ' '*8
+    ::GL.GenVertexArrays(1, @_b)
+    @_b.unpack('L')[0]
+  end
+
+  def self.CreateFramebuffer
+    @_b ||= ' '*8
+    ::GL.GenFramebuffers(1, @_b)
+    @_b.unpack('L')[0]
+  end
+
+  def self.CreateRenderbuffer
+    @_b ||= ' '*8
+    ::GL.GenRenderbuffers(1, @_b)
+    @_b.unpack('L')[0]
+  end
+
+  def self.BufferData_easy(target, data, usage)
+    ptr = array_to_ptr_easy(data)
+    ::GL.BufferData(target, ptr.size, ptr, usage)
+  end
+
+  def self.GetParameter(pname)
+    @_b ||= ' '*8
+    ::GL.GetIntegerv(pname, @_b)
+    @_b.unpack('L')[0]
+  end
+end

data/lib/mittsu/opengl/gl_mittsu_params.rb

@@ -0,0 +1,53 @@
+module Mittsu
+  GL::MITTSU_PARAMS = {
+    RepeatWrapping => GL::REPEAT,
+    ClampToEdgeWrapping => GL::CLAMP_TO_EDGE,
+    MirroredRepeatWrapping => GL::MIRRORED_REPEAT,
+
+    NearestFilter => GL::NEAREST,
+    NearestMipMapNearestFilter => GL::NEAREST_MIPMAP_NEAREST,
+    NearestMipMapLinearFilter => GL::NEAREST_MIPMAP_LINEAR,
+
+    LinearFilter => GL::LINEAR,
+    LinearMipMapNearestFilter => GL::LINEAR_MIPMAP_NEAREST,
+    LinearMipMapLinearFilter => GL::LINEAR_MIPMAP_LINEAR,
+
+    UnsignedByteType => GL::UNSIGNED_BYTE,
+    UnsignedShort4444Type => GL::UNSIGNED_SHORT_4_4_4_4,
+    UnsignedShort5551Type => GL::UNSIGNED_SHORT_5_5_5_1,
+    UnsignedShort565Type => GL::UNSIGNED_SHORT_5_6_5,
+
+    ByteType => GL::BYTE,
+    ShortType => GL::SHORT,
+    UnsignedShortType => GL::UNSIGNED_SHORT,
+    IntType => GL::INT,
+    UnsignedIntType => GL::UNSIGNED_INT,
+    FloatType => GL::FLOAT,
+
+    AlphaFormat => GL::ALPHA,
+    RGBFormat => GL::RGB,
+    RGBAFormat => GL::RGBA,
+    LuminanceFormat => GL::LUMINANCE,
+    LuminanceAlphaFormat => GL::LUMINANCE_ALPHA,
+
+    AddEquation => GL::FUNC_ADD,
+    SubtractEquation => GL::FUNC_SUBTRACT,
+    ReverseSubtractEquation => GL::FUNC_REVERSE_SUBTRACT,
+
+    ZeroFactor => GL::ZERO,
+    OneFactor => GL::ONE,
+    SrcColorFactor => GL::SRC_COLOR,
+    OneMinusSrcColorFactor => GL::ONE_MINUS_SRC_COLOR,
+    SrcAlphaFactor => GL::SRC_ALPHA,
+    OneMinusSrcAlphaFactor => GL::ONE_MINUS_SRC_ALPHA,
+    DstAlphaFactor => GL::DST_ALPHA,
+    OneMinusDstAlphaFactor => GL::ONE_MINUS_DST_ALPHA,
+
+    DstColorFactor => GL::DST_COLOR,
+    OneMinusDstColorFactor => GL::ONE_MINUS_DST_COLOR,
+    SrcAlphaSaturateFactor => GL::SRC_ALPHA_SATURATE
+
+    # TODO: populate with extension parameters?
+  }
+  GL::MITTSU_PARAMS.default = 0
+end

data/lib/mittsu/opengl/helper.rb

@@ -0,0 +1,120 @@
+module Mittsu
+  module OpenGL::Helper
+    def array_to_ptr_easy(data)
+      if data.first.is_a?(Float)
+        size_of_element = Fiddle::SIZEOF_FLOAT
+        format_of_element = 'F'
+        # data.map!{ |d| d.nil? ? 0.0 : d }
+      else
+        size_of_element = Fiddle::SIZEOF_INT
+        format_of_element = 'L'
+        # data.map!{ |d| d.nil? ? 0 : d }
+      end
+      size = data.length * size_of_element
+      array_to_ptr(data, size, format_of_element)
+    end
+
+    def array_to_ptr(data, size, format)
+      ptr = Fiddle::Pointer.malloc(size)
+      ptr[0,size] = data.pack(format * data.length)
+      ptr
+    end
+
+    class << self
+      def mark_uniforms_lights_needs_update(uniforms, value)
+        uniforms['ambientLightColor'].needs_update = value
+
+        uniforms['directionalLightColor'].needs_update = value
+        uniforms['directionalLightDirection'].needs_update = value
+
+        uniforms['pointLightColor'].needs_update = value
+        uniforms['pointLightPosition'].needs_update = value
+        uniforms['pointLightDistance'].needs_update = value
+        uniforms['pointLightDecay'].needs_update = value
+
+        uniforms['spotLightColor'].needs_update = value
+        uniforms['spotLightPosition'].needs_update = value
+        uniforms['spotLightDistance'].needs_update = value
+        uniforms['spotLightDirection'].needs_update = value
+        uniforms['spotLightAngleCos'].needs_update = value
+        uniforms['spotLightExponent'].needs_update = value
+        uniforms['spotLightDecay'].needs_update = value
+
+        uniforms['hemisphereLightSkyColor'].needs_update = value
+        uniforms['hemisphereLightGroundColor'].needs_update = value
+        uniforms['hemisphereLightDirection'].needs_update = value
+      end
+
+      def refresh_uniforms_shadow(uniforms, lights)
+        if uniforms['shadowMatrix']
+          lights.select(&:cast_shadow).select { |light|
+            light.is_a?(SpotLight) || (light.is_a?(DirectionalLight) && !light.shadow_cascade)
+          }.each_with_index { |light, i|
+            uniforms['shadowMap'].value[i] = light.shadow_map
+            uniforms['shadowMapSize'].value[i] = light.shadow_map_size
+
+            uniforms['shadowMatrix'].value[i] = light.shadow_matrix
+
+            uniforms['shadowDarkness'].value[i] = light.shadow_darkness
+            uniforms['shadowBias'].value[i] = light.shadow_bias
+          }
+        end
+      end
+
+      def refresh_uniforms_lights(uniforms, lights)
+        uniforms['ambientLightColor'].value = lights[:ambient].value
+
+        uniforms['directionalLightColor'].value = lights[:directional].colors
+        uniforms['directionalLightDirection'].value = lights[:directional].positions
+
+        uniforms['pointLightColor'].value = lights[:point].colors
+        uniforms['pointLightPosition'].value = lights[:point].positions
+        uniforms['pointLightDistance'].value = lights[:point].distances
+        uniforms['pointLightDecay'].value = lights[:point].decays
+
+        uniforms['spotLightColor'].value = lights[:spot].colors
+        uniforms['spotLightPosition'].value = lights[:spot].positions
+        uniforms['spotLightDistance'].value = lights[:spot].distances
+        uniforms['spotLightDirection'].value = lights[:spot].directions
+        uniforms['spotLightAngleCos'].value = lights[:spot].angles_cos
+        uniforms['spotLightExponent'].value = lights[:spot].exponents
+        uniforms['spotLightDecay'].value = lights[:spot].decays
+
+        uniforms['hemisphereLightSkyColor'].value = lights[:hemi].sky_colors
+        uniforms['hemisphereLightGroundColor'].value = lights[:hemi].ground_colors
+        uniforms['hemisphereLightDirection'].value = lights[:hemi].positions
+      end
+
+      def refresh_uniforms_lambert(uniforms, material)
+      end
+
+      def set_color_linear(array, offset, color, intensity)
+        array[offset]     = color.r * intensity
+        array[offset + 1] = color.g * intensity
+        array[offset + 2] = color.b * intensity
+      end
+
+      def painter_sort_stable(a, b)
+        if a.object.render_order != b.object.render_order
+          a.object.render_order <=> b.object.render_order
+        elsif a.material.id != b.material.id
+          a.material.id <=> b.material.id
+        elsif a.z != b.z
+          a.z <=> b.z
+        else
+          a.object.id <=> b.object.id
+        end
+      end
+
+      def reverse_painter_sort_stable(a, b)
+        if a.object.render_order != b.object.render_order
+          a.object.render_order <=> b.object.render_order
+        elsif a.z != b.z
+          b.z <=> a.z
+        else
+          b.id <=> a.id
+        end
+      end
+    end
+  end
+end

data/lib/mittsu/opengl/implementation.rb

@@ -0,0 +1,31 @@
+require 'mittsu/opengl_implementation/core/geometry'
+require 'mittsu/opengl_implementation/core/object_3d'
+require 'mittsu/opengl_implementation/core/buffer_geometry'
+require 'mittsu/opengl_implementation/objects/mesh'
+require 'mittsu/opengl_implementation/objects/line'
+require 'mittsu/opengl_implementation/objects/group'
+require 'mittsu/opengl_implementation/objects/sprite'
+require 'mittsu/opengl_implementation/objects/point_cloud'
+require 'mittsu/opengl_implementation/scenes/scene'
+
+require 'mittsu/opengl_implementation/lights/light'
+require 'mittsu/opengl_implementation/lights/spot_light'
+require 'mittsu/opengl_implementation/lights/point_light'
+require 'mittsu/opengl_implementation/lights/hemisphere_light'
+require 'mittsu/opengl_implementation/lights/ambient_light'
+require 'mittsu/opengl_implementation/lights/directional_light'
+
+require 'mittsu/opengl_implementation/materials/material'
+require 'mittsu/opengl_implementation/materials/mesh_basic_material'
+require 'mittsu/opengl_implementation/materials/mesh_lambert_material'
+require 'mittsu/opengl_implementation/materials/mesh_phong_material'
+require 'mittsu/opengl_implementation/materials/line_basic_material'
+require 'mittsu/opengl_implementation/materials/shader_material'
+require 'mittsu/opengl_implementation/materials/point_cloud_material'
+
+require 'mittsu/opengl_implementation/textures/texture'
+require 'mittsu/opengl_implementation/textures/cube_texture'
+require 'mittsu/opengl_implementation/textures/data_texture'
+require 'mittsu/opengl_implementation/textures/compressed_texture'
+require 'mittsu/opengl_implementation/textures/render_target'
+# require 'mittsu/opengl_implementation/textures/render_target_cube' # TODO

data/lib/mittsu/opengl/lib.rb

@@ -0,0 +1,19 @@
+require 'mittsu/generic_lib'
+
+module Mittsu
+  module OpenGL::Lib
+    extend GenericLib
+
+    class Linux < GenericLib::Linux
+      def initialize(loader = Linux)
+        @loader = loader
+      end
+    end
+
+    class Windows < GenericLib::Base
+    end
+
+    class MacOS < GenericLib::Base
+    end
+  end
+end

data/lib/mittsu/opengl/light_renderer.rb

@@ -0,0 +1,43 @@
+module Mittsu
+  class OpenGL::LightRenderer
+    attr_accessor :lights_need_update, :cache
+
+    LIGHT_CLASSES = [
+      AmbientLight,
+      DirectionalLight,
+      PointLight,
+      SpotLight,
+      HemisphereLight
+    ]
+    LIGHT_TYPES = LIGHT_CLASSES.map { |klass| klass::TYPE }
+
+    def initialize(renderer)
+      @renderer = renderer
+      @lights_need_update = true
+      @cache = {}
+      LIGHT_CLASSES.each { |klass|
+        @cache[klass::TYPE] = klass::Cache.new
+      }
+    end
+
+    def setup(lights)
+      @cache.values.each(&:reset)
+
+      lights.each do |light|
+        next if light.only_shadow
+        light.setup(self)
+      end
+
+      LIGHT_CLASSES.each do |klass|
+        cache = @cache[klass::TYPE]
+        klass.null_remaining_lights(cache)
+      end
+
+      @lights_need_update = false
+    end
+
+    def reset
+      @lights_need_update = true
+    end
+  end
+end

data/lib/mittsu/opengl/material_basics.rb

@@ -0,0 +1,57 @@
+module Mittsu
+  module OpenGL::MaterialBasics
+    def refresh_uniforms_basic(uniforms)
+      refresh_map_uniforms(uniforms)
+      refresh_env_map_uniforms(uniforms)
+      refresh_other_uniforms(uniforms)
+    end
+
+    def refresh_map_uniforms(uniforms)
+      uniforms['map'].value = map
+      uniforms['lightMap'].value = light_map
+      uniforms['specularMap'].value = specular_map
+      uniforms['alphaMap'].value = alpha_map
+
+      if bump_map
+        uniforms['bumpMap'].value = bump_map
+        uniforms['bumpScale'].value = bump_scale
+      end
+
+      if normal_map
+        uniforms['normalMap'].value = normal_map
+        uniforms['normalScale'].value.copy(normal_scale)
+      end
+    end
+
+    def refresh_env_map_uniforms(uniforms)
+      uv_scale_map = get_uv_scale_map
+
+      if uv_scale_map
+        offset = uv_scale_map.offset
+        repeat = uv_scale_map.repeat
+
+        uniforms['offsetRepeat'].value.set(offset.x, offset.y, repeat.x, repeat.y)
+      end
+
+      uniforms['envMap'].value = env_map
+      # TODO: when OpenGLRenderTargetCube exists
+      # uniforms['flipEnvMap'].value = envMap.is_a?(OpenGLRenderTargetCube) ? 1 : - 1
+    end
+
+    def refresh_other_uniforms(uniforms)
+      uniforms['opacity'].value = opacity
+      uniforms['diffuse'].value = color
+
+      uniforms['reflectivity'].value = reflectivity
+      uniforms['refractionRatio'].value = refraction_ratio
+    end
+
+    def get_uv_scale_map
+      map ||
+      specular_map ||
+      normal_map ||
+      bump_map ||
+      alpha_map
+    end
+  end
+end