mittsu 0.1.2 → 0.1.3

data/lib/mittsu/renderers/opengl/lights/{opengl_point_light.rb → point_light.rb}

@@ -1,5 +1,5 @@
 module Mittsu
-  class OpenGLPointLight < OpenGLLight
+  class PointLight
     TYPE = :point
 
     class Cache < Struct.new(:length, :count, :colors, :distances, :positions, :decays)
@@ -15,9 +15,9 @@ module Mittsu
     def setup_specific(index)
       offset = index * 3;
 
-      OpenGLHelper.set_color_linear(@cache.colors, offset, @light.color, @light.intensity)
+      OpenGLHelper.set_color_linear(@cache.colors, offset, color, intensity)
 
-      @_vector3.set_from_matrix_position(@light.matrix_world)
+      @_vector3.set_from_matrix_position(matrix_world)
 
       positions = @cache.positions
       positions[offset]     = @_vector3.x
@@ -25,8 +25,8 @@ module Mittsu
       positions[offset + 2] = @_vector3.z
 
       # distance is 0 if decay is 0, because there is no attenuation at all.
-      @cache.distances[index] = @light.distance
-      @cache.decays[index] = @light.distance.zero? ? 0.0 : @light.decay
+      @cache.distances[index] = distance
+      @cache.decays[index] = distance.zero? ? 0.0 : decay
     end
 
     def to_sym

data/lib/mittsu/renderers/opengl/lights/{opengl_spot_light.rb → spot_light.rb}

@@ -1,5 +1,5 @@
 module Mittsu
-  class OpenGLSpotLight < OpenGLLight
+  class SpotLight
     TYPE = :spot
 
     class Cache < Struct.new(:length, :count, :colors, :directions, :distances, :positions, :exponents, :angles_cos, :decays)
@@ -15,18 +15,18 @@ module Mittsu
     def setup_specific(index)
       offset = index * 3
 
-      OpenGLHelper.set_color_linear(@cache.colors, offset, @light.color, @light.intensity)
+      OpenGLHelper.set_color_linear(@cache.colors, offset, color, intensity)
 
-      @_direction.set_from_matrix_position(@light.matrix_world)
+      @_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] = @light.distance
+      @cache.distances[index] = distance
 
-      @_vector3.set_from_matrix_position(@light.target.matrix_world)
+      @_vector3.set_from_matrix_position(target.matrix_world)
       @_direction.sub(@_vector3)
       @_direction.normalize
 
@@ -35,9 +35,9 @@ module Mittsu
       directions[offset + 1] = @_direction.y
       directions[offset + 2] = @_direction.z
 
-      @cache.angles_cos[index] = Math.cos(@light.angle)
-      @cache.exponents[index] = @light.exponent;
-      @cache.decays[index] = @light.distance.zero? ? 0.0 : @light.decay
+      @cache.angles_cos[index] = Math.cos(angle)
+      @cache.exponents[index] = exponent;
+      @cache.decays[index] = distance.zero? ? 0.0 : decay
     end
 
     def to_sym

data/lib/mittsu/renderers/opengl/materials/{opengl_line_basic_material.rb → line_basic_material.rb}

@@ -1,8 +1,8 @@
 module Mittsu
-  class OpenGLLineBasicMaterial < OpenGLMaterial
+  class LineBasicMaterial
     def refresh_uniforms(uniforms)
-      uniforms['diffuse'].value = @material.color
-      uniforms['opacity'].value = @material.opacity
+      uniforms['diffuse'].value = color
+      uniforms['opacity'].value = opacity
     end
 
     def init_shader

data/lib/mittsu/renderers/opengl/materials/{opengl_material.rb → material.rb}

@@ -1,5 +1,5 @@
 module Mittsu
-  class OpenGLMaterial
+  class Material
     # TODO: init_shader for these material-types
     # MeshDepthMaterial => :depth, # TODO...
     # MeshNormalMaterial => :normal, # TODO...
@@ -9,48 +9,47 @@ module Mittsu
     attr_accessor :shadow_pass
     attr_reader :shader, :uniforms_list
 
-    def initialize(material, renderer)
-      @material = material
+    def init(lights, fog, object, renderer)
       @renderer = renderer
-    end
 
-    def init(lights, fog, object)
-      @material.add_event_listener(:dispose, @renderer.method(:on_material_dispose))
+      add_event_listener(:dispose, @renderer.method(:on_material_dispose))
 
       init_shader
 
-      @material.program = find_or_create_program(lights, fog, object)
+      self.program = find_or_create_program(lights, fog, object)
 
-      count_supported_morph_attributes(@material.program.attributes)
+      count_supported_morph_attributes(program.attributes)
 
       @uniforms_list = get_uniforms_list
     end
 
-    def set
-      if @material.transparent
-        @renderer.state.set_blending(@material.blending, @material.blend_equation, @material.blend_src, @material.blend_dst, @material.blend_equation_alpha, @material.blend_src_alpha, @material.blend_dst_alpha)
+    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(@material.depth_test)
-      @renderer.state.set_depth_write(@material.depth_write)
-      @renderer.state.set_color_write(@material.color_write)
-      @renderer.state.set_polygon_offset(@material.polygon_offset, @material.polygon_offset_factor, @material.polygon_offset_units)
+      @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?
-      @material.shading == FlatShading
+      shading == FlatShading
     end
 
     def clear_custom_attributes
-      @material.attributes.each do |attribute|
+      attributes.each do |attribute|
         attribute.needs_update = false
       end
     end
 
     def custom_attributes_dirty?
-      @material.attributes.each do |attribute|
+      attributes.each do |attribute|
         return true if attribute.needs_update
       end
       false
@@ -61,24 +60,24 @@ module Mittsu
     end
 
     def needs_camera_position_uniform?
-      @material.env_map
+      env_map
     end
 
     def needs_view_matrix_uniform?
-      @material.skinning
+      skinning
     end
 
     def needs_lights?
-      @material.lights
+      lights
     end
 
     protected
 
     def init_shader
       @shader = {
-        uniforms: @material.uniforms,
-        vertex_shader: @material.vertex_shader,
-        fragment_shader: @material.fragment_shader
+        uniforms: uniforms,
+        vertex_shader: vertex_shader,
+        fragment_shader: fragment_shader
       }
     end
 
@@ -94,7 +93,7 @@ module Mittsu
       }.each_with_object({
         directional: 0, point: 0, spot: 0, hemi: 0, other: 0
       }) { |light, counts|
-        counts[light.implementation(@renderer).to_sym] += 1
+        counts[light.to_sym] += 1
       }
     end
 
@@ -142,11 +141,11 @@ module Mittsu
     end
 
     def count_supported_morph_attributes(attributes)
-      if @material.morph_targets
-        @material.num_supported_morph_normals = count_supported_morph_attribute(attributes, 'morphTarget', @renderer.max_morph_normals)
+      if morph_targets
+        self.num_supported_morph_normals = count_supported_morph_attribute(attributes, 'morphTarget', @renderer.max_morph_normals)
       end
-      if @material.morph_normals
-        @material.num_supported_morph_normals = count_supported_morph_attribute(attributes, 'morphNormal', @renderer.max_morph_normals)
+      if morph_normals
+        self.num_supported_morph_normals = count_supported_morph_attribute(attributes, 'morphNormal', @renderer.max_morph_normals)
       end
     end
 
@@ -159,7 +158,7 @@ module Mittsu
 
     def get_uniforms_list
       @shader[:uniforms].map { |(key, uniform)|
-        location = @material.program.uniforms[key]
+        location = program.uniforms[key]
         if location
           [uniform, location]
         end
@@ -177,34 +176,34 @@ module Mittsu
       {
         supports_vertex_textures: @renderer.supports_vertex_textures?,
 
-        map: !!@material.map,
-        env_map: !!@material.env_map,
-        env_map_mode: @material.env_map && @material.env_map.mapping,
-        light_map: !!@material.light_map,
-        bump_map: !!@material.light_map,
-        normal_map: !!@material.normal_map,
-        specular_map: !!@material.specular_map,
-        alpha_map: !!@material.alpha_map,
+        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: @material.combine,
+        combine: combine,
 
-        vertex_colors: @material.vertex_colors,
+        vertex_colors: vertex_colors,
 
         fog: fog,
-        use_fog: @material.fog,
+        use_fog: fog,
         # fog_exp: fog.is_a?(FogExp2), # TODO: when FogExp2 exists
 
-        flat_shading: @material.shading == FlatShading,
+        flat_shading: shading == FlatShading,
 
-        size_attenuation: @material.size_attenuation,
+        size_attenuation: size_attenuation,
         logarithmic_depth_buffer: @renderer.logarithmic_depth_buffer,
 
-        skinning: @material.skinning,
+        skinning: skinning,
         max_bones: max_bones,
         use_vertex_texture: @renderer.supports_bone_textures?,
 
-        morph_targets: @material.morph_targets,
-        morph_normals: @material.morph_normals,
+        morph_targets: morph_targets,
+        morph_normals: morph_normals,
         max_morph_targets: @renderer.max_morph_targets,
         max_morph_normals: @renderer.max_morph_normals,
 
@@ -219,11 +218,11 @@ module Mittsu
         shadow_map_debug: @renderer.shadow_map_debug,
         shadow_map_cascade: @renderer.shadow_map_cascade,
 
-        alpha_test: @material.alpha_test,
-        metal: @material.metal,
-        wrap_around: @material.wrap_around,
-        double_sided: @material.side == DoubleSide,
-        flip_sided: @material.side == BackSide
+        alpha_test: alpha_test,
+        metal: metal,
+        wrap_around: wrap_around,
+        double_sided: side == DoubleSide,
+        flip_sided: side == BackSide
       }
     end
 
@@ -233,12 +232,12 @@ module Mittsu
       if shader_id
         chunks << shader_id
       else
-        chunks << @material.fragment_shader
-        chunks << @material.vertex_shader
+        chunks << fragment_shader
+        chunks << vertex_shader
       end
 
-      if !@material.defines.nil?
-        @material.defines.each do |(name, define)|
+      if !defines.nil?
+        defines.each do |(name, define)|
           chunks << name
           chunks << define
         end
@@ -261,7 +260,7 @@ module Mittsu
       end
 
       if program.nil?
-        program = OpenGLProgram.new(@renderer, code, @material, parameters)
+        program = OpenGLProgram.new(@renderer, code, self, parameters)
         @renderer.programs.push(program)
 
         @renderer.info[:memory][:programs] = @renderer.programs.length

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

@@ -0,0 +1,21 @@
+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/{opengl_mesh_lambert_material.rb → mesh_lambert_material.rb}

@@ -1,12 +1,16 @@
+require 'mittsu/renderers/opengl/materials/opengl_material_basics'
+
 module Mittsu
-  class OpenGLMeshLambertMaterial < OpenGLMeshBasicMaterial
+  class MeshLambertMaterial
+    include OpenGLMaterialBasics
+
     def refresh_uniforms(uniforms)
-      super
+      refresh_uniforms_basic(uniforms)
 
-      uniforms['emissive'].value = @material.emissive
+      uniforms['emissive'].value = emissive
 
-      if @material.wrap_around
-        uniforms['wrapRGB'].value.copy(@material.wrap_rgb)
+      if wrap_around
+        uniforms['wrapRGB'].value.copy(wrap_rgb)
       end
     end
 

data/lib/mittsu/renderers/opengl/materials/{opengl_mesh_phong_material.rb → mesh_phong_material.rb}

@@ -1,19 +1,23 @@
+require 'mittsu/renderers/opengl/materials/opengl_material_basics'
+
 module Mittsu
-  class OpenGLMeshPhongMaterial < OpenGLMeshBasicMaterial
+  class MeshPhongMaterial
+    include OpenGLMaterialBasics
+
     def needs_face_normals?
       false
     end
 
     def refresh_uniforms(uniforms)
-      super
+      refresh_uniforms_basic(uniforms)
 
-      uniforms['shininess'].value = @material.shininess
+      uniforms['shininess'].value = shininess
 
-      uniforms['emissive'].value = @material.emissive
-      uniforms['specular'].value = @material.specular
+      uniforms['emissive'].value = emissive
+      uniforms['specular'].value = specular
 
-      if @material.wrap_around
-        uniforms['wrapRGB'].value.copy(@material.wrap_rgb)
+      if wrap_around
+        uniforms['wrapRGB'].value.copy(wrap_rgb)
       end
     end
 

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

@@ -0,0 +1,57 @@
+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