mittsu 0.4.0 → 0.5.0

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

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

@@ -1,33 +0,0 @@
-require 'mittsu/renderers/opengl/materials/opengl_material_basics'
-
-module Mittsu
-  class MeshLambertMaterial
-    include OpenGLMaterialBasics
-
-    def refresh_uniforms(uniforms)
-      refresh_uniforms_basic(uniforms)
-
-      uniforms['emissive'].value = emissive
-
-      if wrap_around
-        uniforms['wrapRGB'].value.copy(wrap_rgb)
-      end
-    end
-
-    def needs_view_matrix_uniform?
-      true
-    end
-
-    def needs_lights?
-      true
-    end
-
-    def init_shader
-      @shader = ShaderLib.create_shader(shader_id)
-    end
-
-    def shader_id
-      :lambert
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require 'mittsu/renderers/opengl/materials/opengl_material_basics'
-
-module Mittsu
-  class MeshPhongMaterial
-    include OpenGLMaterialBasics
-
-    def needs_face_normals?
-      false
-    end
-
-    def refresh_uniforms(uniforms)
-      refresh_uniforms_basic(uniforms)
-
-      uniforms['shininess'].value = shininess
-
-      uniforms['emissive'].value = emissive
-      uniforms['specular'].value = specular
-
-      if wrap_around
-        uniforms['wrapRGB'].value.copy(wrap_rgb)
-      end
-    end
-
-    def needs_camera_position_uniform?
-      true
-    end
-
-    def needs_view_matrix_uniform?
-      true
-    end
-
-    def needs_lights?
-      true
-    end
-
-    def init_shader
-      @shader = ShaderLib.create_shader(shader_id)
-    end
-
-    def shader_id
-      :phong
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-module Mittsu
-  module OpenGLMaterialBasics
-    def refresh_uniforms_basic(uniforms)
-      refresh_map_uniforms(uniforms)
-      refresh_env_map_uniforms(uniforms)
-      refresh_other_uniforms(uniforms)
-    end
-
-    def refresh_map_uniforms(uniforms)
-      uniforms['map'].value = map
-      uniforms['lightMap'].value = light_map
-      uniforms['specularMap'].value = specular_map
-      uniforms['alphaMap'].value = alpha_map
-
-      if bump_map
-        uniforms['bumpMap'].value = bump_map
-        uniforms['bumpScale'].value = bump_scale
-      end
-
-      if normal_map
-        uniforms['normalMap'].value = normal_map
-        uniforms['normalScale'].value.copy(normal_scale)
-      end
-    end
-
-    def refresh_env_map_uniforms(uniforms)
-      uv_scale_map = get_uv_scale_map
-
-      if uv_scale_map
-        offset = uv_scale_map.offset
-        repeat = uv_scale_map.repeat
-
-        uniforms['offsetRepeat'].value.set(offset.x, offset.y, repeat.x, repeat.y)
-      end
-
-      uniforms['envMap'].value = env_map
-      # TODO: when OpenGLRenderTargetCube exists
-      # uniforms['flipEnvMap'].value = envMap.is_a?(OpenGLRenderTargetCube) ? 1 : - 1
-    end
-
-    def refresh_other_uniforms(uniforms)
-      uniforms['opacity'].value = opacity
-      uniforms['diffuse'].value = color
-
-      uniforms['reflectivity'].value = reflectivity
-      uniforms['refractionRatio'].value = refraction_ratio
-    end
-
-    def get_uv_scale_map
-      map ||
-      specular_map ||
-      normal_map ||
-      bump_map ||
-      alpha_map
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module Mittsu
-  class PointCloudMaterial
-    def refresh_uniforms(uniforms)
-      uniforms['psColor'].value = color
-      uniforms['opacity'].value = opacity
-      uniforms['size'].value = size
-      # uniforms['scale'].value = _canvas.height / 2.0 # TODO get window height?
-
-      uniforms['map'].value = map
-
-      if !map.nil?
-        offset = material.map.offset
-        repeat = material.map.repeat
-
-        uniforms['offsetRepeat'].value.set(offset.x, offset.y, repeat.x, repeat.y)
-      end
-    end
-
-    def init_shader
-      @shader = ShaderLib.create_shader(shader_id)
-    end
-
-    def shader_id
-      :particle_basic
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-module Mittsu
-  class ShaderMaterial
-    def needs_camera_position_uniform?
-      true
-    end
-
-    def needs_view_matrix_uniform?
-      true
-    end
-  end
-end

data/lib/mittsu/renderers/opengl/objects/group.rb

@@ -1,9 +0,0 @@
-module Mittsu
-  class Group
-    def project(renderer)
-      @renderer = renderer
-      return unless visible
-      project_children
-    end
-  end
-end

data/lib/mittsu/renderers/opengl/objects/line.rb

@@ -1,45 +0,0 @@
-module Mittsu
-  class Line
-    def render_buffer(camera, lights, fog, material, geometry_group, update_buffers)
-      opengl_mode = mode == LineStrip ? GL_LINE_STRIP : GL_LINES
-
-      @renderer.state.set_line_width(material.line_width * @renderer.pixel_ratio)
-
-      glDrawArrays(opengl_mode, 0, geometry_group.line_count)
-
-      @renderer.info[:render][:calls] += 1
-    end
-
-    def update
-      # TODO: glBindVertexArray ???
-      material = buffer_material(geometry)
-      custom_attributes_dirty = material.attributes && material.custom_attributes_dirty?
-
-      if geometry.vertices_need_update || geometry.colors_need_update || geometry.line_distances_need_update || custom_attributes_dirty
-        geometry.set_line_buffers(GL_DYNAMIC_DRAW)
-      end
-
-      geometry.vertices_need_update = false
-      geometry.colors_need_update = false
-      geometry.line_distances_need_update = false
-
-      material.attributes && material.clear_custom_attributes
-    end
-
-    def init_geometry
-      geometry.renderer = @renderer
-      if geometry.vertex_buffer.nil?
-        geometry.create_line_buffers
-        geometry.init_line_buffers(self)
-
-        geometry.vertices_need_update = true
-        geometry.colors_need_update = true
-        geometry.line_distances_need_update = true
-      end
-    end
-
-    def add_opengl_object
-      @renderer.add_opengl_object(geometry, self)
-    end
-  end
-end

data/lib/mittsu/renderers/opengl/objects/mesh.rb

@@ -1,70 +0,0 @@
-module Mittsu
-  class Mesh
-    attr_accessor :renderer
-
-    def render_buffer(camera, lights, fog, material, geometry_group, update_buffers)
-      type = GL_UNSIGNED_INT # geometry_group.type_array == Uint32Array ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT
-
-      # wireframe
-      if material.wireframe
-        @renderer.state.set_line_width(material.wireframe_linewidth * @renderer.pixel_ratio)
-
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, geometry_group.line_buffer) if update_buffers
-        glDrawElements(GL_LINES, geometry_group.line_count, type, 0)
-
-      # triangles
-      else
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, geometry_group.face_buffer) if update_buffers
-        glDrawElements(GL_TRIANGLES, geometry_group.face_count, type, 0)
-      end
-
-      @renderer.info[:render][:calls] += 1
-      @renderer.info[:render][:vertices] += geometry_group.face_count
-      @renderer.info[:render][:faces] += geometry_group.face_count / 3
-    end
-
-    def update
-      # check all geometry groubs
-      mat = nil
-      geometry.groups.each do |geometry_group|
-        # TODO: place to put this???
-        # glBindVertexArray(geometry_group.vertex_array_object)
-        mat = buffer_material(geometry_group)
-
-        custom_attributes_dirty = mat.attributes && mat.custom_attributes_dirty?
-
-        if geometry.vertices_need_update || geometry.morph_targets_need_update || geometry.elements_need_update || geometry.uvs_need_update || geometry.normals_need_update || geometry.colors_need_update || geometry.tangents_need_update || custom_attributes_dirty
-          geometry_group.set_mesh_buffers(self, GL_DYNAMIC_DRAW, !geometry.dynamic, mat)
-        end
-      end
-
-      geometry.vertices_need_update = false
-      geometry.morph_targets_need_update = false
-      geometry.elements_need_update = false
-      geometry.uvs_need_update = false
-      geometry.normals_need_update = false
-      geometry.colors_need_update = false
-      geometry.tangents_need_update = false
-
-      mat.attributes && mat.clear_custom_attributes
-    end
-
-    def init_geometry
-      geometry.renderer = @renderer
-      geometry.init_geometry_groups(self)
-    end
-
-    def add_opengl_object
-      case geometry
-      when BufferGeometry
-        @renderer.add_opengl_object(geometry, self)
-      when Geometry
-        geometry.groups.each do |group|
-          @renderer.add_opengl_object(group, self)
-        end
-      else
-        raise "GEOMETRY IS NULL"
-      end
-    end
-  end
-end

data/lib/mittsu/renderers/opengl/objects/point_cloud.rb

@@ -1,39 +0,0 @@
-module Mittsu
-  class PointCloud
-    def render_buffer(camera, lights, fog, material, geometry_group, update_buffers)
-      glDrawArrays(GL_POINTS, 0, geometry_group.particle_count)
-
-      @renderer.info[:render][:calls] += 1
-      @renderer.info[:render][:points] += geometry_group.particle_count
-    end
-
-    def update
-			material = buffer_material(geometry)
-			custom_attributes_dirty = material.attributes &&  material.custom_attributes_dirty?
-
-			if geometry.vertices_need_update || geometry.colors_need_update || custom_attributes_dirty
-				geometry.set_particle_buffers(GL_DYNAMIC_DRAW)
-			end
-
-			geometry.vertices_need_update = false
-			geometry.colors_need_update = false
-
-      material.attributes && material.clear_custom_attributes
-    end
-
-    def init_geometry
-      geometry.renderer = @renderer
-      if geometry.vertex_buffer.nil?
-        geometry.create_particle_buffers
-        geometry.init_particle_buffers(self)
-
-        geometry.vertices_need_update = true
-        geometry.colors_need_update = true
-      end
-    end
-
-    def add_opengl_object
-      @renderer.add_opengl_object(geometry, self)
-    end
-  end
-end