mittsu 0.4.1 → 0.5.0

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

@@ -1,134 +0,0 @@
-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)
-      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)
-      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/renderers/opengl/lights/ambient_light.rb

@@ -1,26 +0,0 @@
-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/renderers/opengl/lights/directional_light.rb

@@ -1,35 +0,0 @@
-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
-
-      OpenGLHelper.set_color_linear(@cache.colors, offset, color, intensity)
-    end
-
-    def to_sym
-      :directional
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-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
-
-      OpenGLHelper.set_color_linear(@cache.sky_colors, offset, color, intensity)
-      OpenGLHelper.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/renderers/opengl/lights/light.rb

@@ -1,55 +0,0 @@
-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/renderers/opengl/lights/point_light.rb

@@ -1,36 +0,0 @@
-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;
-
-      OpenGLHelper.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/renderers/opengl/lights/spot_light.rb

@@ -1,47 +0,0 @@
-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
-
-      OpenGLHelper.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/renderers/opengl/materials/line_basic_material.rb

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

data/lib/mittsu/renderers/opengl/materials/material.rb

@@ -1,274 +0,0 @@
-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 = (glGetParameter(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: OpenGLRenderer: 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 = OpenGLProgram.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/renderers/opengl/materials/mesh_basic_material.rb

@@ -1,21 +0,0 @@
-require 'mittsu/renderers/opengl/materials/opengl_material_basics'
-
-module Mittsu
-  class MeshBasicMaterial
-    include OpenGLMaterialBasics
-
-    def refresh_uniforms(uniforms)
-      refresh_uniforms_basic(uniforms)
-    end
-
-    protected
-
-    def init_shader
-      @shader = ShaderLib.create_shader(shader_id)
-    end
-
-    def shader_id
-      :basic
-    end
-  end
-end