mittsu-opengl 0.5.0

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

@@ -0,0 +1,134 @@
+module Mittsu
+  class Object3D
+    attr_accessor :morph_target_influences, :renderer, :initted
+    attr_reader :model_view_matrix
+    attr_writer :active
+
+    def active?
+      @active
+    end
+
+    def init
+      if !@initted
+        puts " --- INIT #{self.name}" if DEBUG
+
+        @initted = true
+        @model_view_matrix = Matrix4.new
+        @normal_matrix = Matrix3.new
+
+        add_event_listener(:removed, @renderer.method(:on_object_removed))
+      end
+
+      if geometry.nil?
+        # ImmediateRenderObject
+      else
+        if !geometry.initted
+          geometry.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), self)
+        # end
+      end
+    end
+
+    def project(renderer)
+      puts " --- PROJECT #{self.name}" if DEBUG
+      @renderer = renderer
+      return unless visible
+      init
+
+      # TODO!!! FIXME!!!
+      opengl_objects = @renderer.instance_variable_get(:@_opengl_objects)[id]
+
+      if opengl_objects && (!frustum_culled || @renderer.object_in_frustum?(self))
+        opengl_objects.each do |opengl_object|
+          # TODO!!! FIXME!!!
+          @renderer.send(:unroll_buffer_material, opengl_object)
+
+          opengl_object.render = true
+          if @renderer.sort_objects?
+            @_vector3 ||= Vector3.new
+
+            @_vector3.set_from_matrix_position(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, matrix_world)
+      @normal_matrix.normal_matrix(@model_view_matrix)
+      @model_view_matrix
+    end
+
+    def load_uniforms_matrices(uniforms)
+      GL.UniformMatrix4fv(uniforms['modelViewMatrix'],
+                         1, GL::FALSE,
+                         array_to_ptr_easy(@model_view_matrix.elements))
+
+      if uniforms['normalMatrix']
+        GL.UniformMatrix3fv(uniforms['normalMatrix'],
+                           1, GL::FALSE,
+                           array_to_ptr_easy(@normal_matrix.elements))
+      end
+    end
+
+    def buffer_material(geometry_group)
+      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
+
+    def deinit
+      @initted = nil
+      @model_view_matrix = nil
+      @normal_matrix = nil
+      @active = nil
+    end
+
+    protected
+
+    def project_children
+      children.each do |child|
+        child.project(@renderer)
+      end
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/lights/ambient_light.rb

@@ -0,0 +1,26 @@
+module Mittsu
+  class AmbientLight
+    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] += color.r
+      @cache.value[1] += color.g
+      @cache.value[2] += color.b
+    end
+
+    def self.null_remaining_lights(_); end
+  end
+end

data/lib/mittsu/opengl_implementation/lights/directional_light.rb

@@ -0,0 +1,35 @@
+module Mittsu
+  class DirectionalLight
+    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(matrix_world)
+      @_vector3.set_from_matrix_position(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
+
+      OpenGL::Helper.set_color_linear(@cache.colors, offset, color, intensity)
+    end
+
+    def to_sym
+      :directional
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/lights/hemisphere_light.rb

@@ -0,0 +1,39 @@
+module Mittsu
+  class HemisphereLight
+    TYPE = :hemi
+
+    class Cache < Struct.new(:length, :count, :sky_colors, :ground_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(matrix_world)
+      @_direction.normalize
+
+      positions = @cache.positions
+      positions[offset]     = @_direction.x
+      positions[offset + 1] = @_direction.y
+      positions[offset + 2] = @_direction.z
+
+      OpenGL::Helper.set_color_linear(@cache.sky_colors, offset, color, intensity)
+      OpenGL::Helper.set_color_linear(@cache.ground_colors, offset, ground_color, intensity)
+    end
+
+    def self.null_remaining_lights(cache)
+      super(cache, cache.ground_colors)
+      super(cache, cache.sky_colors)
+    end
+
+    def to_sym
+      :hemi
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/lights/light.rb

@@ -0,0 +1,55 @@
+module Mittsu
+  class Light
+    attr_accessor :camera_helper
+
+    # def initialize(light, renderer)
+    #   super
+    #   @light = light
+    #   @light_renderer = renderer.light_renderer
+    #
+    #
+    #   @_direction = Vector3.new
+    #   @_vector3 = Vector3.new
+    # end
+
+    def type
+      self.class::TYPE
+    end
+
+    def setup(light_renderer)
+      @light_renderer = light_renderer
+      @cache ||= @light_renderer.cache[type]
+      @cache.count += 1
+
+      return unless visible
+
+      @_direction ||= Vector3.new
+      @_vector3 ||= Vector3.new
+
+      setup_specific(@cache.length)
+
+      @cache.length += 1
+    end
+
+    def project(renderer)
+      @renderer = renderer
+      return unless visible
+      init
+      # TODO!!! FIXME!!!
+      @renderer.instance_variable_get(:@lights) << self
+      project_children
+    end
+
+    def self.null_remaining_lights(cache, colors = nil)
+      colors ||= cache.colors
+      count = [colors.length, cache.count * 3].max
+      (cache.length * 3).upto(count - 1).each { |i|
+        colors[i] = 0.0
+      }
+    end
+
+    def to_sym
+      :other
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/lights/point_light.rb

@@ -0,0 +1,36 @@
+module Mittsu
+  class PointLight
+    TYPE = :point
+
+    class Cache < Struct.new(:length, :count, :colors, :distances, :positions, :decays)
+      def initialize
+        super(0, 0, [], [], [], [])
+      end
+
+      def reset
+        self.length = 0
+      end
+    end
+
+    def setup_specific(index)
+      offset = index * 3;
+
+      OpenGL::Helper.set_color_linear(@cache.colors, offset, color, intensity)
+
+      @_vector3.set_from_matrix_position(matrix_world)
+
+      positions = @cache.positions
+      positions[offset]     = @_vector3.x
+      positions[offset + 1] = @_vector3.y
+      positions[offset + 2] = @_vector3.z
+
+      # distance is 0 if decay is 0, because there is no attenuation at all.
+      @cache.distances[index] = distance
+      @cache.decays[index] = distance.zero? ? 0.0 : decay
+    end
+
+    def to_sym
+      :point
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/lights/spot_light.rb

@@ -0,0 +1,47 @@
+module Mittsu
+  class SpotLight
+    TYPE = :spot
+
+    class Cache < Struct.new(:length, :count, :colors, :directions, :distances, :positions, :exponents, :angles_cos, :decays)
+      def initialize
+        super(0, 0, [], [], [], [], [], [], [])
+      end
+
+      def reset
+        self.length = 0
+      end
+    end
+
+    def setup_specific(index)
+      offset = index * 3
+
+      OpenGL::Helper.set_color_linear(@cache.colors, offset, color, intensity)
+
+      @_direction.set_from_matrix_position(matrix_world)
+
+      positions = @cache.positions
+      positions[offset]     = @_direction.x
+      positions[offset + 1] = @_direction.y
+      positions[offset + 2] = @_direction.z
+
+      @cache.distances[index] = distance
+
+      @_vector3.set_from_matrix_position(target.matrix_world)
+      @_direction.sub(@_vector3)
+      @_direction.normalize
+
+      directions = @cache.directions
+      directions[offset]     = @_direction.x
+      directions[offset + 1] = @_direction.y
+      directions[offset + 2] = @_direction.z
+
+      @cache.angles_cos[index] = ::Math.cos(angle)
+      @cache.exponents[index] = exponent;
+      @cache.decays[index] = distance.zero? ? 0.0 : decay
+    end
+
+    def to_sym
+      :spot
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/materials/line_basic_material.rb

@@ -0,0 +1,16 @@
+module Mittsu
+  class LineBasicMaterial
+    def refresh_uniforms(uniforms)
+      uniforms['diffuse'].value = color
+      uniforms['opacity'].value = opacity
+    end
+
+    def init_shader
+      @shader = OpenGL::Shader::Lib.create_shader(shader_id)
+    end
+
+    def shader_id
+      :basic
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/materials/material.rb

@@ -0,0 +1,274 @@
+module Mittsu
+  class Material
+    # TODO: init_shader for these material-types
+    # MeshDepthMaterial => :depth, # TODO...
+    # MeshNormalMaterial => :normal, # TODO...
+    # LineDashedMaterial => :dashed, # TODO...
+    # PointCloudMaterial => :particle_basic # TODO...
+
+    attr_accessor :shadow_pass
+    attr_reader :shader, :uniforms_list
+
+    def init(lights, fog, object, renderer)
+      @renderer = renderer
+
+      add_event_listener(:dispose, @renderer.method(:on_material_dispose))
+
+      init_shader
+
+      self.program = find_or_create_program(lights, fog, object)
+
+      count_supported_morph_attributes(program.attributes)
+
+      @uniforms_list = get_uniforms_list
+    end
+
+    def set(renderer)
+      @renderer = renderer
+
+      if transparent
+        @renderer.state.set_blending(blending, blend_equation, blend_src, blend_dst, blend_equation_alpha, blend_src_alpha, blend_dst_alpha)
+      else
+        @renderer.state.set_blending(NoBlending)
+      end
+
+      @renderer.state.set_depth_test(depth_test)
+      @renderer.state.set_depth_write(depth_write)
+      @renderer.state.set_color_write(color_write)
+      @renderer.state.set_polygon_offset(polygon_offset, polygon_offset_factor, polygon_offset_units)
+    end
+
+    def needs_face_normals?
+      shading == FlatShading
+    end
+
+    def clear_custom_attributes
+      attributes.each do |attribute|
+        attribute.needs_update = false
+      end
+    end
+
+    def custom_attributes_dirty?
+      attributes.each do |attribute|
+        return true if attribute.needs_update
+      end
+      false
+    end
+
+    def refresh_uniforms(_)
+      # NOOP
+    end
+
+    def needs_camera_position_uniform?
+      env_map
+    end
+
+    def needs_view_matrix_uniform?
+      skinning
+    end
+
+    def needs_lights?
+      lights
+    end
+
+    protected
+
+    def init_shader
+      @shader = {
+        uniforms: uniforms,
+        vertex_shader: vertex_shader,
+        fragment_shader: fragment_shader
+      }
+    end
+
+    def shader_id
+      nil
+    end
+
+    private
+
+    def allocate_lights(lights)
+      lights.reject { |light|
+        light.only_shadow || !light.visible
+      }.each_with_object({
+        directional: 0, point: 0, spot: 0, hemi: 0, other: 0
+      }) { |light, counts|
+        counts[light.to_sym] += 1
+      }
+    end
+
+    def allocate_shadows(lights)
+      max_shadows = 0
+
+      lights.each do |light|
+        next unless light.cast_shadow
+
+        max_shadows += 1 if light.is_a?(SpotLight)
+        max_shadows += 1 if light.is_a?(DirectionalLight) && !light.shadow_cascade
+      end
+
+      max_shadows
+    end
+
+    def allocate_bones(object = nil)
+      if @renderer.supports_bone_textures? && object && object.skeleton && object.skeleton.use_vertex_texture
+        return 1024
+      end
+
+      # default for when object is not specified
+      # ( for example when prebuilding shader
+      #   to be used with multiple objects )
+      #
+      #  - leave some extra space for other uniforms
+      #  - limit here is ANGLE's 254 max uniform vectors
+      #    (up to 54 should be safe)
+
+      n_vertex_uniforms = (GL.GetParameter(GL::MAX_VERTEX_UNIFORM_COMPONENTS) / 4.0).floor
+      n_vertex_matrices = ((n_vertex_uniforms - 20) / 4.0).floor
+
+      max_bones = n_vertex_matrices
+
+      # TODO: when SkinnedMesh exists
+      # if !object.nil? && object.is_a?(SkinnedMesh)
+      #   max_bones = [object.skeleton.bones.length, max_bones].min
+      #
+      #   if max_bones < object.skeleton.bones.length
+      #     puts "WARNING: OpenGL::Renderer: too many bones - #{object.skeleton.bones.length}, this GPU supports just #{max_bones}"
+      #   end
+      # end
+
+      max_bones
+    end
+
+    def count_supported_morph_attributes(attributes)
+      if morph_targets
+        self.num_supported_morph_normals = count_supported_morph_attribute(attributes, 'morphTarget', @renderer.max_morph_normals)
+      end
+      if morph_normals
+        self.num_supported_morph_normals = count_supported_morph_attribute(attributes, 'morphNormal', @renderer.max_morph_normals)
+      end
+    end
+
+    def count_supported_morph_attribute(attributes, base, max)
+      max.times.reduce do |num, i|
+        attribute = attributes["#{base}#{i}"]
+        attribute && attribute >= 0 ? num + 1 : num
+      end
+    end
+
+    def get_uniforms_list
+      @shader[:uniforms].map { |(key, uniform)|
+        location = program.uniforms[key]
+        if location
+          [uniform, location]
+        end
+      }.compact
+    end
+
+    def program_parameters(lights, fog, object)
+      # heuristics to create shader paramaters according to lights in the scene
+      # (not to blow over max_lights budget)
+
+      max_light_count = allocate_lights(lights)
+      max_shadows = allocate_shadows(lights)
+      max_bones = allocate_bones(object)
+
+      {
+        supports_vertex_textures: @renderer.supports_vertex_textures?,
+
+        map: !!map,
+        env_map: !!env_map,
+        env_map_mode: env_map && env_map.mapping,
+        light_map: !!light_map,
+        bump_map: !!light_map,
+        normal_map: !!normal_map,
+        specular_map: !!specular_map,
+        alpha_map: !!alpha_map,
+
+        combine: combine,
+
+        vertex_colors: vertex_colors,
+
+        fog: fog,
+        use_fog: fog,
+        # fog_exp: fog.is_a?(FogExp2), # TODO: when FogExp2 exists
+
+        flat_shading: shading == FlatShading,
+
+        size_attenuation: size_attenuation,
+        logarithmic_depth_buffer: @renderer.logarithmic_depth_buffer,
+
+        skinning: skinning,
+        max_bones: max_bones,
+        use_vertex_texture: @renderer.supports_bone_textures?,
+
+        morph_targets: morph_targets,
+        morph_normals: morph_normals,
+        max_morph_targets: @renderer.max_morph_targets,
+        max_morph_normals: @renderer.max_morph_normals,
+
+        max_dir_lights: max_light_count[:directional],
+        max_point_lights: max_light_count[:point],
+        max_spot_lights: max_light_count[:spot],
+        max_hemi_lights: max_light_count[:hemi],
+
+        max_shadows: max_shadows,
+        shadow_map_enabled: @renderer.shadow_map_enabled? && object.receive_shadow && max_shadows > 0,
+        shadow_map_type: @renderer.shadow_map_type,
+        shadow_map_debug: @renderer.shadow_map_debug,
+        shadow_map_cascade: @renderer.shadow_map_cascade,
+
+        alpha_test: alpha_test,
+        metal: metal,
+        wrap_around: wrap_around,
+        double_sided: side == DoubleSide,
+        flip_sided: side == BackSide
+      }
+    end
+
+    def program_slug(parameters)
+      chunks = []
+
+      if shader_id
+        chunks << shader_id
+      else
+        chunks << fragment_shader
+        chunks << vertex_shader
+      end
+
+      if !defines.nil?
+        defines.each do |(name, define)|
+          chunks << name
+          chunks << define
+        end
+      end
+
+      parameters.each do |(name, parameter)|
+        chunks << name
+        chunks << parameter
+      end
+
+      chunks.join
+    end
+
+    def find_or_create_program(lights, fog, object)
+      parameters = program_parameters(lights, fog, object)
+      code = program_slug(parameters)
+
+      program = @renderer.programs.find do |program_info|
+        program_info.code == code
+      end
+
+      if program.nil?
+        program = OpenGL::Program.new(@renderer, code, self, parameters)
+        @renderer.programs.push(program)
+
+        @renderer.info[:memory][:programs] = @renderer.programs.length
+      else
+        program.used_times += 1
+      end
+
+      program
+    end
+  end
+end

data/lib/mittsu/opengl_implementation/materials/mesh_basic_material.rb

@@ -0,0 +1,21 @@
+require 'mittsu/opengl/material_basics'
+
+module Mittsu
+  class MeshBasicMaterial
+    include OpenGL::MaterialBasics
+
+    def refresh_uniforms(uniforms)
+      refresh_uniforms_basic(uniforms)
+    end
+
+    protected
+
+    def init_shader
+      @shader = OpenGL::Shader::Lib.create_shader(shader_id)
+    end
+
+    def shader_id
+      :basic
+    end
+  end
+end