mittsu-opengl 0.5.0

data/lib/mittsu/opengl/shader/uniforms_utils.rb

@@ -0,0 +1,31 @@
+module Mittsu
+  module OpenGL::Shader::UniformsUtils
+    def self.merge(uniforms)
+      merged = {}
+
+      uniforms.each do |uniform|
+        tmp = UniformsUtils.clone(uniform)
+
+        next if tmp.nil?
+
+        tmp.each do |(p, tmp_p)|
+          merged[p] = tmp_p
+        end
+      end
+
+      merged
+    end
+
+    def self.clone(uniforms_src)
+      return if uniforms_src.nil?
+
+      uniforms_dst = {}
+
+      uniforms_src.each do |(u, uniform_src)|
+        uniforms_dst[u] = uniform_src.clone
+      end
+
+      uniforms_dst
+    end
+  end
+end

data/lib/mittsu/opengl/shader.rb

@@ -0,0 +1,56 @@
+module Mittsu
+  class OpenGL::Shader
+    attr_reader :shader
+
+    def initialize(type, string)
+      @shader = GL.CreateShader(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]
+
+      GL.ShaderSource(@shader, 1, string_pointer.ref, string_length.ref)
+      GL.CompileShader(@shader)
+
+      if !compile_status
+        puts "ERROR: Mittsu::OpenGL::Shader: Shader couldn't compile"
+      end
+
+      log_info = shader_info_log
+      if !log_info.empty?
+        puts "WARNING: Mittsu::OpenGL::Shader: GL.GetShaderInfoLog, #{log_info}"
+        puts add_line_numbers(string)
+      end
+    end
+
+    private
+
+    def compile_status
+      ptr = ' '*8
+      GL.GetShaderiv @shader, GL::COMPILE_STATUS, ptr
+      ptr.unpack('L')[0]
+    end
+
+    def shader_info_log
+      ptr = ' '*8
+      GL.GetShaderiv @shader, GL::INFO_LOG_LENGTH, ptr
+      length = ptr.unpack('L')[0]
+
+      if length > 0
+        log = ' '*length
+        GL.GetShaderInfoLog @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

data/lib/mittsu/opengl/state.rb

@@ -0,0 +1,205 @@
+module Mittsu
+  class OpenGL::State
+    def initialize
+      @new_attributes = Array.new(16) # Uint8Array
+      @enabled_attributes = Array.new(16) # Uint8Array
+
+      @current_blending = nil
+      @current_blend_equation = nil
+      @current_blend_src = nil
+      @current_blend_dst = nil
+      @current_blend_equation_alpha = nil
+      @current_blend_src_alpha = nil
+      @current_blend_dst_alpha = nil
+
+      @current_depth_test = nil
+      @current_depth_write = nil
+
+      @current_color_write = nil
+
+      @current_double_sided = nil
+      @current_flip_sided = nil
+
+      @current_line_width = nil
+
+      @current_polygon_offset = nil
+      @current_polygon_offset_factor = nil
+      @current_polygon_offset_units = nil
+    end
+
+    def init_attributes
+      @new_attributes.length.times do |i|
+        @new_attributes[i] = false
+      end
+    end
+
+    def enable_attribute(attribute)
+      GL.EnableVertexAttribArray(attribute)
+      @new_attributes[attribute] = true
+
+      if !@enabled_attributes[attribute]
+        # GL.EnableVertexAttribArray(attribute)
+        @enabled_attributes[attribute] = true
+      end
+    end
+
+    def disable_unused_attributes
+      @enabled_attributes.length.times do |i|
+        if @enabled_attributes[i] && !@new_attributes[i]
+          GL.DisableVertexAttribArray(i)
+          @enabled_attributes[i] = false
+        end
+      end
+    end
+
+    def set_blending(blending, blend_equation = nil, blend_src = nil, blend_dst = nil, blend_equation_alpha = nil, blend_src_alpha = nil, blend_dst_alpha = nil)
+      if blending != @current_blending
+        case blending
+        when NoBlending
+          GL.Disable(GL::BLEND)
+        when AdditiveBlending
+          GL.Enable(GL::BLEND)
+          GL.BlendEquation(GL::FUNC_ADD)
+          GL.BlendFunc(GL::SRC_ALPHA, GL::ONE)
+        when SubtractiveBlending
+          # TODO: Find blendFuncSeparate() combination ???
+          GL.Enable(GL::BLEND)
+          GL.BlendEquation(GL::FUNC_ADD)
+          GL.BlendFunc(GL::ZERO, GL::ONE_MINUS_SRC_COLOR)
+        when MultiplyBlending
+          # TODO: Find blendFuncSeparate() combination ???
+          GL.Enable(GL::BLEND)
+          GL.BlendEquation(GL::FUNC_ADD)
+          GL.BlendFunc(GL::ZERO, GL::ONE_MINUS_SRC_COLOR)
+        when CustomBlending
+          GL.Enable(GL::BLEND)
+        else
+          GL.Enable(GL::BLEND)
+          GL.BlendEquationSeparate(GL::FUNC_ADD, GL::FUNC_ADD)
+          GL.BlendFuncSeparate(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA, GL::ONE, GL::ONE_MINUS_SRC_ALPHA)
+        end
+
+        @current_blending = blending
+      end
+
+      if blending == CustomBlending
+        blend_equation_alpha ||= blend_equation
+        blend_src_alpha ||= blend_src
+        blend_dst_alpha ||= blend_dst
+
+        if blend_equation != @current_blend_equation || blend_equation_alpha != @current_blend_equation_alpha
+          GL.BlendEquationSeparate(GL::MITTSU_PARAMS[blend_equation], GL::MITTSU_PARAMS[blend_equation_alpha])
+
+          @current_blend_equation = blend_equation
+          @current_blend_equation_alpha = blend_equation_alpha
+        end
+
+        if blend_src != @current_blend_src || blend_dst != @current_blend_dst || blend_src_alpha != @current_blend_src_alpha || blend_dst_alpha != @current_blend_dst_alpha
+          GL.BlendFuncSeparate(GL::MITTSU_PARAMS[blend_src], GL::MITTSU_PARAMS[blend_dst], GL::MITTSU_PARAMS[blend_src_alpha], GL::MITTSU_PARAMS[blend_dst_alpha])
+
+          @current_blend_src = nil
+          @current_blend_dst = nil
+          @current_blend_src_alpha = nil
+          @current_blend_dst_alpha = nil
+        end
+      else
+        @current_blend_equation = nil
+        @current_blend_src = nil
+        @current_blend_dst = nil
+        @current_blend_equation_alpha = nil
+        @current_blend_src_alpha = nil
+        @current_blend_dst_alpha = nil
+      end
+    end
+
+    def set_depth_test(depth_test)
+      if @current_depth_test != depth_test
+        if depth_test
+          GL.Enable(GL::DEPTH_TEST)
+        else
+          GL.Disable(GL::DEPTH_TEST)
+        end
+
+        @current_depth_test = depth_test
+      end
+    end
+
+    def set_depth_write(depth_write)
+      if @current_depth_write != depth_write
+        GL.DepthMask(depth_write ? GL::TRUE : GL::FALSE)
+        @current_depth_write = depth_write
+      end
+    end
+
+    def set_color_write(color_write)
+      if @current_color_write != color_write
+        gl_color_write = color_write ? GL::TRUE : GL::FALSE
+        GL.ColorMask(gl_color_write, gl_color_write, gl_color_write, gl_color_write)
+        @current_color_write = color_write
+      end
+    end
+
+    def set_double_sided(double_sided)
+      if @current_double_sided != double_sided
+        if double_sided
+          GL.Disable(GL::CULL_FACE)
+        else
+          GL.Enable(GL::CULL_FACE)
+        end
+
+        @current_double_sided = double_sided
+      end
+    end
+
+    def set_flip_sided(flip_sided)
+      if @current_flip_sided != flip_sided
+        if flip_sided
+          GL.FrontFace(GL::CW)
+        else
+          GL.FrontFace(GL::CCW)
+        end
+
+        @current_flip_sided = flip_sided
+      end
+    end
+
+    def set_line_width(width)
+      if width != @current_line_width
+        GL.LineWidth(width)
+        @current_line_width = width
+      end
+    end
+
+    def set_polygon_offset(polygon_offset, factor, units)
+      if @current_polygon_offset != polygon_offset
+        if polygon_offset
+          GL.Enable(GL::POLYGON_OFFSET_FILL)
+        else
+          GL.Disable(GL::POLYGON_OFFSET_FILL)
+        end
+
+        @current_polygon_offset = polygon_offset
+      end
+
+      if polygon_offset && (@current_polygon_offset_factor != factor || @current_polygon_offset_units != units)
+        GL.PolygonOffset(factor, units)
+
+        @current_polygon_offset_factor = factor
+        @current_polygon_offset_units = units
+      end
+    end
+
+    def reset
+      @enabled_attributes.length.times do |i|
+        @enabled_attributes[i] = false
+      end
+
+      @current_blending = nil
+      @current_depth_test = nil
+      @current_depth_write = nil
+      @current_color_write = nil
+      @current_double_sided = nil
+      @current_flip_sided = nil
+    end
+  end
+end

data/lib/mittsu/opengl/version.rb

@@ -0,0 +1,5 @@
+module Mittsu
+  module OpenGL
+    VERSION = '0.5.0'
+  end
+end

data/lib/mittsu/opengl.rb

@@ -0,0 +1,2 @@
+require 'mittsu'
+require 'mittsu/opengl/renderer'

data/lib/mittsu/opengl_implementation/core/buffer_geometry.rb

@@ -0,0 +1,11 @@
+module Mittsu
+  class BufferGeometry
+    include OpenGL::GeometryLike
+
+    attr_accessor :initted
+
+    def init
+      @initted = true
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/core/geometry.rb

@@ -0,0 +1,346 @@
+require 'mittsu/opengl/geometry_like'
+
+module Mittsu
+  class Geometry
+    include OpenGL::GeometryLike
+
+    attr_accessor :groups, :initted
+
+    def init_geometry_groups(object)
+      material = object.material
+      add_buffers = false
+
+      if @groups.nil? || @groups_need_update
+        @renderer.remove_opengl_object(object)
+
+        @groups = make_groups(material.is_a?(MeshFaceMaterial))
+
+        @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)
+
+          @vertices_need_update = true
+          @morph_targets_need_update = true
+          @elements_need_update = true
+          @uvs_need_update = true
+          @normals_need_update = true
+          @tangents_need_update = true
+          @colors_need_update = true
+
+          add_buffers = true
+        else
+          add_buffers = false
+        end
+
+        if add_buffers || !object.active?
+          @renderer.add_opengl_object(geometry_group, object)
+        end
+      end
+
+      object.active = true
+    end
+
+    def init_line_buffers(object)
+      nvertices = @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 init_particle_buffers(object)
+      nvertices = @vertices.length
+
+      @vertex_array = Array.new(nvertices * 3, 0.0) # Float32Array
+      @color_array = Array.new(nvertices * 3, 0.0) # Float32Array
+
+      @particle_count = nvertices
+
+      init_custom_attributes(object)
+    end
+
+    def create_line_buffers
+      @vertex_array_object = GL.CreateVertexArray
+
+      @vertex_buffer = GL.CreateBuffer
+      @color_buffer = GL.CreateBuffer
+      @line_distance_buffer = GL.CreateBuffer
+
+      @renderer.info[:memory][:geometries] += 1
+    end
+
+    def create_particle_buffers
+      @vertex_array_object = GL.CreateVertexArray
+
+      @vertex_buffer = GL.CreateBuffer
+      @color_buffer = GL.CreateBuffer
+
+      @renderer.info[:memory][:geometries] += 1
+    end
+
+    def set_line_buffers(hint)
+      if @vertices_need_update
+        @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
+
+        GL.BindBuffer(GL::ARRAY_BUFFER, @vertex_buffer)
+        GL.BufferData_easy(GL::ARRAY_BUFFER, @vertex_array, hint)
+      end
+
+      if @colors_need_update
+        @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
+
+        GL.BindBuffer(GL::ARRAY_BUFFER, @color_buffer)
+        GL.BufferData_easy(GL::ARRAY_BUFFER, @color_array, hint)
+      end
+
+      if @line_distances_need_update
+        @line_distances.each_with_index do |l, d|
+          @line_distance_array[d] = l
+        end
+
+        GL.BindBuffer(GL::ARRAY_BUFFER, @line_distance_buffer)
+        GL.BufferData_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 do |value|
+              custom_attribute.array[offset    ] = value.x
+              custom_attribute.array[offset + 1] = value.y
+
+              offset += 2
+            end
+          when 3
+            if custom_attribute.type === :c
+              values.each do |value|
+                custom_attribute.array[offset    ] = value.r
+                custom_attribute.array[offset + 1] = value.g
+                custom_attribute.array[offset + 2] = value.b
+
+                offset += 3
+              end
+            else
+              values.each do |value|
+                custom_attribute.array[offset    ] = value.x
+                custom_attribute.array[offset + 1] = value.y
+                custom_attribute.array[offset + 2] = value.z
+
+                offset += 3
+              end
+            end
+          when 4
+            values.each do |value|
+              custom_attribute.array[offset    ] = value.x
+              custom_attribute.array[offset + 1] = value.y
+              custom_attribute.array[offset + 2] = value.z
+              custom_attribute.array[offset + 3] = value.w
+
+              offset += 4
+            end
+          end
+
+          GL.BindBuffer(GL::ARRAY_BUFFER, custom_attribute.buffer)
+          GL.BufferData_easy(GL::ARRAY_BUFFER, custom_attribute.array, hint)
+
+          custom_attribute.needs_update = false
+        end
+      end
+    end
+
+    def set_particle_buffers(hint)
+      if @vertices_need_update
+        @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
+
+
+        GL.BindBuffer(GL::ARRAY_BUFFER, @vertex_buffer)
+        GL.BufferData_easy(GL::ARRAY_BUFFER, @vertex_array, hint)
+      end
+
+      if @colors_need_update
+        @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
+
+        GL.BindBuffer(GL::ARRAY_BUFFER, @color_buffer)
+        GL.BufferData_easy(GL::ARRAY_BUFFER, @color_array, hint)
+      end
+
+      if @custom_attribute
+        @custom_attributes.each do |custom_attribute|
+          if custom_attribute.needs_update? && (custom_attribute.bount_to.nil? || custom_attribute.bount_to == 'vertices')
+            offset = 0
+
+            if custom_attribute.size == 1
+              custom_attribute.value.each_with_index do |value, ca|
+                custom_attribute.array[ca] = value
+              end
+            elsif custom_attribute.size == 2
+              custom_attribute.value.each do |value|
+                custom_attribute.array[offset]     = value.x
+                custom_attribute.array[offset + 1] = value.y
+
+                offset += 2
+              end
+            elsif custom_attribute.size == 3
+              if custom_attribute.type == :c
+                custom_attribute.value.each do |value|
+                  custom_attribute.array[offset]     = value.r
+                  custom_attribute.array[offset + 1] = value.g
+                  custom_attribute.array[offset + 2] = value.b
+
+                  offset += 3
+                end
+              else
+                custom_attribute.value.each do |value|
+                  custom_attribute.array[offset]     = value.x
+                  custom_attribute.array[offset + 1] = value.y
+                  custom_attribute.array[offset + 2] = value.z
+
+                  offset += 3
+                end
+              end
+            elsif custom_attribute.size == 4
+              custom_attribute.value.each do |value|
+                custom_attribute.array[offset]     = value.x
+                custom_attribute.array[offset + 1] = value.y
+                custom_attribute.array[offset + 2] = value.z
+                custom_attribute.array[offset + 3] = value.w
+
+                offset += 3
+              end
+            end
+          end
+
+          GL.BindBuffer(GL::ARRAY_BUFFER, customAttribute.buffer)
+          GL.BufferData(GL::ARRAY_BUFFER, customAttribute.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 = @morph_targets.length
+      num_morph_normals = @morph_normals.length
+
+      groups = {}
+      groups_list = []
+
+      @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 = OpenGL::GeometryGroup.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 = @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 = GL.CreateBuffer
+            attribute.buffer.belongs_to_attribute = name
+
+            attribute.needs_update = true
+          end
+
+          @custom_attributes_list << attribute
+        end
+      end
+    end
+  end
+end