mittsu 0.1.1 → 0.1.2

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

@@ -0,0 +1,130 @@
+module Mittsu
+  module OpenGLGeometryLike
+    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,
+                  :initted_arrays,
+                  :custom_attributes_list,
+                  :num_vertices
+
+    def bind_vertex_array_object
+      glBindVertexArray(@vertex_array_object) if @vertex_array_object
+    end
+
+    def update_vertex_buffer(attribute)
+      glBindBuffer(GL_ARRAY_BUFFER, @vertex_buffer)
+      @renderer.state.enable_attribute(attribute)
+      glVertexAttribPointer(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
+        glVertexAttrib3fv(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 ???
+        # glVertexAttrib2fv(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)
+      glBindBuffer(GL_ARRAY_BUFFER, buffer)
+      @renderer.state.enable_attribute(attribute)
+      glVertexAttribPointer(attribute, size, GL_FLOAT, GL_FALSE, 0, 0)
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+module Mittsu
+  module OpenGLHelper
+    def glCreateBuffer
+      @_b ||= ' '*8
+      glGenBuffers(1, @_b)
+      @_b.unpack('L')[0]
+    end
+
+    def glCreateTexture
+      @_b ||= ' '*8
+      glGenTextures(1, @_b)
+      @_b.unpack('L')[0]
+    end
+
+    def glCreateVertexArray
+      @_b ||= ' '*8
+      glGenVertexArrays(1, @_b)
+      @_b.unpack('L')[0]
+    end
+
+    def glCreateFramebuffer
+      @_b ||= ' '*8
+      glGenFramebuffers(1, @_b)
+      @_b.unpack('L')[0]
+    end
+
+    def glCreateRenderbuffer
+      @_b ||= ' '*8
+      glGenRenderbuffers(1, @_b)
+      @_b.unpack('L')[0]
+    end
+
+    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
+
+    def glBufferData_easy(target, data, usage)
+      ptr = array_to_ptr_easy(data)
+      glBufferData(target, ptr.size, ptr, usage)
+    end
+
+    def glGetParameter(pname)
+      @_b ||= ' '*8
+      glGetIntegerv(pname, @_b)
+      @_b.unpack('L')[0]
+    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
+          a.id - b.id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'mittsu/core/geometry'
+require 'mittsu/core/object_3d'
+require 'mittsu/objects'
+require 'mittsu/materials'
+require 'mittsu/textures'
+require 'mittsu/scenes'
+
+require 'mittsu/renderers/opengl/core/opengl_geometry'
+require 'mittsu/renderers/opengl/core/opengl_object_3d'
+require 'mittsu/renderers/opengl/objects/opengl_mesh'
+require 'mittsu/renderers/opengl/objects/opengl_line'
+require 'mittsu/renderers/opengl/objects/opengl_group'
+require 'mittsu/renderers/opengl/scenes/opengl_scene'
+require 'mittsu/renderers/opengl/materials/opengl_material'
+require 'mittsu/renderers/opengl/materials/opengl_mesh_basic_material'
+require 'mittsu/renderers/opengl/materials/opengl_mesh_lambert_material'
+require 'mittsu/renderers/opengl/materials/opengl_mesh_phong_material'
+require 'mittsu/renderers/opengl/materials/opengl_line_basic_material'
+require 'mittsu/renderers/opengl/materials/opengl_shader_material'
+require 'mittsu/renderers/opengl/textures/opengl_texture'
+require 'mittsu/renderers/opengl/textures/opengl_cube_texture'
+require 'mittsu/renderers/opengl/textures/opengl_data_texture'
+require 'mittsu/renderers/opengl/textures/opengl_compressed_texture'
+require 'mittsu/renderers/opengl/lights/opengl_light'
+require 'mittsu/renderers/opengl/lights/opengl_light'
+require 'mittsu/renderers/opengl/lights/opengl_spot_light'
+require 'mittsu/renderers/opengl/lights/opengl_point_light'
+require 'mittsu/renderers/opengl/lights/opengl_hemisphere_light'
+require 'mittsu/renderers/opengl/lights/opengl_ambient_light'
+require 'mittsu/renderers/opengl/lights/opengl_directional_light'
+
+module Mittsu
+  OPENGL_IMPLEMENTATIONS = {
+    Object3D => OpenGLObject3D,
+    Geometry => OpenGLGeometry,
+    Material => OpenGLMaterial,
+    Texture => OpenGLTexture,
+    Light => OpenGLLight,
+    CubeTexture => OpenGLCubeTexture,
+    Mesh => OpenGLMesh,
+    Line => OpenGLLine,
+    SpotLight => OpenGLSpotLight,
+    PointLight => OpenGLPointLight,
+    HemisphereLight => OpenGLHemisphereLight,
+    AmbientLight => OpenGLAmbientLight,
+    DirectionalLight => OpenGLDirectionalLight,
+    DataTexture => OpenGLDataTexture,
+    CompressedTexture => OpenGLCompressedTexture,
+    Scene => OpenGLScene,
+    Group => OpenGLGroup,
+    MeshBasicMaterial => OpenGLMeshBasicMaterial,
+    MeshLambertMaterial => OpenGLMeshLambertMaterial,
+    MeshPhongMaterial => OpenGLMeshPhongMaterial,
+    LineBasicMaterial => OpenGLLineBasicMaterial,
+    ShaderMaterial => OpenGLShaderMaterial
+  }
+  OPENGL_IMPLEMENTATIONS.default_proc = -> (hash, key) {
+    super_klass = key.ancestors.find { |a| hash.has_key?(a) }
+    super_klass ? (hash[key] = hash[super_klass]) : nil
+  }
+end

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

@@ -0,0 +1,43 @@
+module Mittsu
+  class OpenGLLightRenderer
+    attr_accessor :lights_need_update, :cache
+
+    LIGHT_CLASSES = [
+      OpenGLAmbientLight,
+      OpenGLDirectionalLight,
+      OpenGLPointLight,
+      OpenGLSpotLight,
+      OpenGLHemisphereLight
+    ]
+    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.implementation(self).setup
+      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/renderers/opengl/opengl_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