mittsu 0.1.1 → 0.1.2

data/lib/mittsu/renderers/glfw_window.rb

@@ -2,21 +2,23 @@ require 'opengl'
 require 'glfw'
 
 GLFW_LIB_EXT = OpenGL.get_platform == :OPENGL_PLATFORM_MACOSX ? 'dylib' : 'so'
-GLFW_LIB = begin
-  "lib#{`pkg-config --libs-only-l glfw3`.gsub(/^-l/, '').chomp.strip}.#{GLFW_LIB_EXT}"
-rescue
-  "libglfw.#{GLFW_LIB_EXT}"
-end
-GLFW_LIB_PATH = begin
-  s = `pkg-config glfw3 --libs-only-L`.gsub(/^-L/, '').chomp.strip
-  s.empty? ? nil : s
-rescue
-  nil
-end
+if OpenGL.get_platform != :OPENGL_PLATFORM_TEST
+  GLFW_LIB = begin
+    "lib#{`pkg-config --libs-only-l glfw3`.gsub(/^-l/, '').chomp.strip}.#{GLFW_LIB_EXT}"
+  rescue
+    "libglfw.#{GLFW_LIB_EXT}"
+  end
+  GLFW_LIB_PATH = begin
+    s = `pkg-config glfw3 --libs-only-L`.gsub(/^-L/, '').chomp.strip
+    s.empty? ? nil : s
+  rescue
+    nil
+  end
 
-GLFW.load_lib GLFW_LIB, GLFW_LIB_PATH
+  GLFW.load_lib GLFW_LIB, GLFW_LIB_PATH
 
-include GLFW
+  include GLFW
+end
 
 module Mittsu
   module GLFW

data/lib/mittsu/renderers/opengl/core/opengl_geometry.rb

@@ -0,0 +1,253 @@
+require 'mittsu/renderers/opengl/opengl_geometry_like'
+
+module Mittsu
+  class OpenGLGeometry
+    include OpenGLGeometryLike
+
+    attr_accessor :groups, :initted
+    attr_reader :id
+
+    def initialize(geometry, renderer)
+      @id = (@@id ||= 1).tap { @@id += 1 }
+
+      @geometry = geometry
+      @renderer = renderer
+    end
+
+    def init_geometry_groups(object)
+      object_impl = object.implementation(@renderer)
+      material = object.material
+      add_buffers = false
+
+      if @groups.nil? || @geometry.groups_need_update
+        @renderer.remove_opengl_object(object)
+
+        @groups = make_groups(material.is_a?(MeshFaceMaterial))
+
+        @geometry.groups_need_update = false
+      end
+
+      # create separate VBOs per geometry chunk
+
+      @groups.each do |geometry_group|
+        # initialize VBO on the first access
+        if geometry_group.vertex_buffer.nil?
+          geometry_group.create_mesh_buffers
+          geometry_group.init_mesh_buffers(object)
+
+          @geometry.vertices_need_update = true
+          @geometry.morph_targets_need_update = true
+          @geometry.elements_need_update = true
+          @geometry.uvs_need_update = true
+          @geometry.normals_need_update = true
+          @geometry.tangents_need_update = true
+          @geometry.colors_need_update = true
+
+  				add_buffers = true
+        else
+          add_buffers = false
+        end
+
+        if add_buffers || !object_impl.active?
+          @renderer.add_opengl_object(geometry_group, object)
+        end
+      end
+
+      object_impl.active = true
+    end
+
+    def init_line_buffers(object)
+      nvertices = @geometry.vertices.length
+
+      @vertex_array = Array.new(nvertices * 3, 0.0) # Float32Array
+      @color_array = Array.new(nvertices * 3, 0.0) # Float32Array
+      @line_distance_array = Array.new(nvertices, 0.0) # Float32Array
+
+      @line_count = nvertices
+
+      init_custom_attributes(object)
+    end
+
+    def create_line_buffers
+      @vertex_array_object = glCreateVertexArray
+
+      @vertex_buffer = glCreateBuffer
+      @color_buffer = glCreateBuffer
+      @line_distance_buffer = glCreateBuffer
+
+      @renderer.info[:memory][:geometries] += 1
+    end
+
+    def set_line_buffers(hint)
+      if @geometry.vertices_need_update
+        @geometry.vertices.each_with_index do |vertex, v|
+          offset = v * 3
+
+          @vertex_array[offset]     = vertex.x
+          @vertex_array[offset + 1] = vertex.y
+          @vertex_array[offset + 2] = vertex.z
+        end
+
+        glBindBuffer(GL_ARRAY_BUFFER, @vertex_buffer)
+        glBufferData_easy(GL_ARRAY_BUFFER, @vertex_array, hint)
+      end
+
+      if @geometry.colors_need_update
+        @geometry.colors.each_with_index do |color, c|
+          offset = c * 3
+
+          @color_array[offset]     = color.r
+          @color_array[offset + 1] = color.g
+          @color_array[offset + 2] = color.b
+        end
+
+        glBindBuffer(GL_ARRAY_BUFFER, @color_buffer)
+        glBufferData_easy(GL_ARRAY_BUFFER, @color_array, hint)
+      end
+
+      if @geometry.line_distances_need_update
+        @geometry.line_distances.each_with_index do |l, d|
+          @line_distance_array[d] = l
+        end
+
+        glBindBuffer(GL_ARRAY_BUFFER, @line_distance_buffer)
+        glBufferData_easy(GL_ARRAY_BUFFER, @line_distance_array, hint)
+      end
+
+      if @custom_attributes
+        @custom_attributes.each do |custom_attribute|
+          offset = 0
+
+          values = custom_attribute.value
+
+          case custom_attribute.size
+          when 1
+            value.each_with_index do |value, ca|
+              custom_attribute.array[ca] = value
+            end
+          when 2
+            values.each_with_index do |value, ca|
+              custom_attribute[offset    ] = value.x
+              custom_attribute[offset + 1] = value.y
+
+              offset += 2
+            end
+          when 3
+            if custom_attribute.type === :c
+              values.each_with_index do |value, ca|
+                custom_attribute[offset    ] = value.r
+                custom_attribute[offset + 1] = value.g
+                custom_attribute[offset + 2] = value.b
+
+                offset += 3
+              end
+            else
+              values.each_with_index do |value, ca|
+                custom_attribute[offset    ] = value.x
+                custom_attribute[offset + 1] = value.y
+                custom_attribute[offset + 2] = value.z
+
+                offset += 3
+              end
+            end
+          when 4
+            values.each_with_index do |value, ca|
+              custom_attribute[offset    ] = value.x
+              custom_attribute[offset + 1] = value.y
+              custom_attribute[offset + 2] = value.z
+              custom_attribute[offset + 3] = value.w
+
+              offset += 4
+            end
+          end
+
+          glBindBuffer(GL_ARRAY_BUFFER, custom_attribute.buffer)
+          glBufferData_easy(GL_ARRAY_BUFFER, custom_attribute.array, hint)
+
+          custom_attribute.needs_update = false
+        end
+      end
+    end
+
+    private
+
+    def make_groups(uses_face_material = false)
+      max_vertices_in_group = 65535 # TODO: OES_element_index_uint ???
+
+      hash_map = {}
+
+      num_morph_targets = @geometry.morph_targets.length
+      num_morph_normals = @geometry.morph_normals.length
+
+      groups = {}
+      groups_list = []
+
+      @geometry.faces.each_with_index do |face, f|
+        material_index = uses_face_material ? face.material_index : 0
+
+        if !hash_map.include? material_index
+          hash_map[material_index] = { hash: material_index, counter: 0 }
+        end
+
+        group_hash = "#{hash_map[material_index][:hash]}_#{hash_map[material_index][:counter]}"
+
+        if !groups.include? group_hash
+          group = OpenGLGeometryGroup.new(material_index, num_morph_targets, num_morph_normals, @renderer)
+
+          groups[group_hash] = group
+          groups_list << group
+        end
+
+        if groups[group_hash].num_vertices + 3 > max_vertices_in_group
+          hash_map[material_index][:counter] += 1
+          group_hash = "#{hash_map[material_index][:hash]}_#{hash_map[material_index][:counter]}"
+
+          if !groups.include? group_hash
+            group = OpenGLGeometryGroup.new(material_index, num_morph_targets, num_morph_normals, @renderer)
+
+            groups[group_hash] = group
+            groups_list << group
+          end
+        end
+        groups[group_hash].faces3 << f
+        groups[group_hash].num_vertices += 3
+      end
+      groups_list
+    end
+
+    def init_custom_attributes(object)
+      material = object.material
+
+      nvertices = @geometry.vertices.length
+
+      if material.attributes
+        @custom_attributes_list ||= []
+
+        material.attributes.each do |(name, attribute)|
+          if !attribute[:_opengl_initialized] || attribute.create_unique_buffers
+            attribute[:_opengl_initialized] = true
+
+            size = case attribute.type
+            when :v2 then 2
+            when :v3 then 3
+            when :v4 then 4
+            when :c then 3
+            else 1
+            end
+
+            attribute.size = size
+
+            attribute.array = Array.new(nvertices * size) # Float32Array
+
+            attribute.buffer = glCreateBuffer
+            attribute.buffer.belongs_to_attribute = name
+
+            attribute.needs_update = true
+          end
+
+          @custom_attributes_list << attribute
+        end
+      end
+    end
+  end
+end

data/lib/mittsu/renderers/opengl/core/opengl_object_3d.rb

@@ -0,0 +1,131 @@
+module Mittsu
+  class OpenGLObject3D
+    attr_accessor :morph_target_influences
+    attr_reader :model_view_matrix
+    attr_writer :active
+
+    def initialize(object, renderer)
+      @object = object
+      @renderer = renderer
+      @_vector3 = Vector3.new
+    end
+
+    def active?
+      @active
+    end
+
+    def init
+      if !@initted
+        @initted = true
+        @model_view_matrix = Matrix4.new
+        @normal_matrix = Matrix3.new
+
+        @object.add_event_listener(:removed, @renderer.method(:on_object_removed))
+      end
+
+      geometry = @object.geometry
+
+      if geometry.nil?
+        # ImmediateRenderObject
+      else
+        geometry_impl = geometry.implementation(@renderer)
+        if !geometry_impl.initted
+          geometry_impl.initted = true
+          geometry.add_event_listener(:dispose, @renderer.method(:on_geometry_dispose))
+          if geometry.is_a?(BufferGeometry)
+            @renderer.info[:memory][:geometries] += 1
+          else
+            init_geometry
+          end
+          # TODO: when PointCloud exists
+          # when PointCloud
+          #   if geometry[:_opengl_vertex_buffer].nil?
+          #     create_particle_buffers(geometry)
+          #     init_particle_buffers(geometry, object)
+          #
+          #     geometry.vertices_need_update = true
+          #     geometry.colors_need_update = true
+          #   end
+        end
+      end
+
+      if !@active
+        @active = true
+
+        add_opengl_object
+        # TODO: when ImmediateRenderObject exists
+        # if object.is_a? ImmediateRenderObject || object.immediate_render_callback
+        #   add_buffer_immediate(@renderer.instance_variable_get(:@_opengl_objects_immediate), @object)
+        # end
+      end
+    end
+
+    def project
+      return unless @object.visible
+      init
+
+      # TODO!!! FIXME!!!
+      opengl_objects = @renderer.instance_variable_get(:@_opengl_objects)[@object.id]
+
+      if opengl_objects && (!@object.frustum_culled || @renderer.object_in_frustum?(@object))
+        opengl_objects.each do |opengl_object|
+          # TODO!!! FIXME!!!
+          @renderer.send(:unroll_buffer_material, opengl_object)
+
+          opengl_object.render = true
+          if @renderer.sort_objects?
+            @_vector3.set_from_matrix_position(@object.matrix_world)
+            @_vector3.apply_projection(@renderer.proj_screen_matrix)
+
+            opengl_object[:z] = @_vector3.z
+          end
+        end
+      end
+
+      project_children
+    end
+
+    def setup_matrices(camera)
+      @model_view_matrix.multiply_matrices(camera.matrix_world_inverse, @object.matrix_world)
+      @normal_matrix.normal_matrix(@model_view_matrix)
+      @model_view_matrix
+    end
+
+    def load_uniforms_matrices(uniforms)
+      glUniformMatrix4fv(uniforms['modelViewMatrix'],
+                         1, GL_FALSE,
+                         array_to_ptr_easy(@model_view_matrix.elements))
+
+      if uniforms['normalMatrix']
+        glUniformMatrix3fv(uniforms['normalMatrix'],
+                           1, GL_FALSE,
+                           array_to_ptr_easy(@normal_matrix.elements))
+      end
+    end
+
+    def buffer_material(geometry_group)
+      material = @object.material
+      if material.is_a?(MeshFaceMaterial)
+        material.materials[geometry_group.material_index]
+      else
+        material
+      end
+    end
+
+    def init_geometry
+      # NOOP
+    end
+
+    def add_opengl_object
+      # NOOP
+    end
+
+    protected
+
+    def project_children
+      @object.children.each do |child|
+        child.implementation(@renderer).project
+      end
+    end
+  end
+end

data/lib/mittsu/renderers/opengl/lights/opengl_ambient_light.rb

@@ -0,0 +1,26 @@
+module Mittsu
+  class OpenGLAmbientLight < OpenGLLight
+    TYPE = :ambient
+
+    class Cache < Struct.new(:length, :count, :value)
+      def initialize
+        super(0, 0, [0.0, 0.0, 0.0])
+      end
+
+      def reset
+        self.length = 0
+        self.value[0] = 0.0
+        self.value[1] = 0.0
+        self.value[2] = 0.0
+      end
+    end
+
+    def setup_specific(_)
+      @cache.value[0] += @light.color.r
+      @cache.value[1] += @light.color.g
+      @cache.value[2] += @light.color.b
+    end
+
+    def self.null_remaining_lights(_); end
+  end
+end

data/lib/mittsu/renderers/opengl/lights/opengl_directional_light.rb

@@ -0,0 +1,35 @@
+module Mittsu
+  class OpenGLDirectionalLight < OpenGLLight
+    TYPE = :directional
+
+    class Cache < Struct.new(:length, :count, :colors, :positions)
+      def initialize
+        super(0, 0, [], [])
+      end
+
+      def reset
+        self.length = 0
+      end
+    end
+
+    def setup_specific(index)
+      offset = index * 3
+
+      @_direction.set_from_matrix_position(@light.matrix_world)
+      @_vector3.set_from_matrix_position(@light.target.matrix_world)
+      @_direction.sub(@_vector3)
+      @_direction.normalize
+
+      positions = @cache.positions
+      positions[offset]     = @_direction.x
+      positions[offset + 1] = @_direction.y
+      positions[offset + 2] = @_direction.z
+
+      OpenGLHelper.set_color_linear(@cache.colors, offset, @light.color, @light.intensity)
+    end
+
+    def to_sym
+      :directional
+    end
+  end
+end