mittsu 0.1.2 → 0.1.3

data/lib/mittsu/renderers/opengl/scenes/scene.rb

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

data/lib/mittsu/renderers/opengl/textures/{opengl_compressed_texture.rb → compressed_texture.rb}

@@ -1,16 +1,15 @@
 module Mittsu
-  class OpenGLCompressedTexture < OpenGLTexture
+  class CompressedTexture
     def update_specific
-      gl_format = GL_MITTSU_PARAMS[@texture.format]
-      gl_type = GL_MITTSU_PARAMS[@texture.type]
-      mipmaps = @texture.mipmaps
+      gl_format = GL_MITTSU_PARAMS[format]
+      gl_type = GL_MITTSU_PARAMS[type]
 
       mipmaps.each_with_index do |mipmap, i|
-        if @texture.format != RGBAFormat && @texture.format != RGBFormat
+        if format != RGBAFormat && format != RGBFormat
           if @renderer.compressed_texture_formats.include?(gl_format)
             glCompressedTexImage2D(GL_TEXTURE_2D, i, gl_format, mipmap.width, mipmap.height, 0, mipmap.data)
           else
-            puts 'WARNING: Mittsu::OpenGLTexture: Attempt to load unsupported compressed texture format in #update_texture'
+            puts 'WARNING: Mittsu::Texture: Attempt to load unsupported compressed texture format in #update_texture'
           end
         else
           glTexImage2D(GL_TEXTURE_2D, i, gl_format, mipmap.width, mipmap.height, 0, gl_format, gl_type, mipmap.data)

data/lib/mittsu/renderers/opengl/textures/{opengl_cube_texture.rb → cube_texture.rb}

@@ -1,36 +1,38 @@
 module Mittsu
-  class OpenGLCubeTexture < OpenGLTexture
-    def set(slot)
-      if @texture.image.length == 6
-        if @texture.needs_update?
-          if !@texture.image[:_opengl_texture_cube]
-            @texture.add_event_listener(:dispose, @renderer.method(:on_texture_dispose))
-            @texture.image[:_opengl_texture_cube] = glCreateTexture
+  class CubeTexture
+    def set(slot, renderer)
+      @renderer = renderer
+
+      if image.length == 6
+        if needs_update?
+          if !image[:_opengl_texture_cube]
+            add_event_listener(:dispose, @renderer.method(:on_texture_dispose))
+            image[:_opengl_texture_cube] = glCreateTexture
             @renderer.info[:memory][:textures] += 1
           end
 
           glActiveTexture(GL_TEXTURE0 + slot)
-          glBindTexture(GL_TEXTURE_CUBE_MAP, @texture.image[:_opengl_texture_cube])
+          glBindTexture(GL_TEXTURE_CUBE_MAP, image[:_opengl_texture_cube])
 
           # glPixelStorei(GL_UNPACK_FLIP_Y_WEBGL, texture.flip_y)
 
-          is_compressed = @texture.is_a?(CompressedTexture)
-          is_data_texture = @texture.image[0].is_a?(DataTexture)
+          is_compressed = is_a?(CompressedTexture)
+          is_data_texture = image[0].is_a?(DataTexture)
 
           cube_image = [];
 
           6.times do |i|
             if @auto_scale_cubemaps && !is_compressed && !is_data_texture
-              cube_image[i] = clamp_to_max_size(@texture.image[i], @_max_cubemap_size)
+              cube_image[i] = clamp_to_max_size(image[i], @_max_cubemap_size)
             else
-              cube_image[i] = is_data_texture ? @texture.image[i].image : @texture.image[i];
+              cube_image[i] = is_data_texture ? image[i].image : image[i];
             end
           end
 
-          image = cube_image[0]
-          is_image_power_of_two = Math.power_of_two?(image.width) && Math.power_of_two?(image.height)
-          gl_format = GL_MITTSU_PARAMS[@texture.format]
-          gl_type = GL_MITTSU_PARAMS[@texture.type]
+          img = cube_image[0]
+          is_image_power_of_two = Math.power_of_two?(img.width) && Math.power_of_two?(img.height)
+          gl_format = GL_MITTSU_PARAMS[format]
+          gl_type = GL_MITTSU_PARAMS[type]
 
           set_parameters(GL_TEXTURE_CUBE_MAP, is_image_power_of_two)
 
@@ -45,7 +47,7 @@ module Mittsu
               mipmaps = cube_image[i].mipmaps
 
               mipmaps.each_with_index do |mipmap, j|
-                if @texture.format != RGBAFormat && @texture.format != RGBFormat
+                if format != RGBAFormat && format != RGBFormat
                   if @renderer.compressed_texture_formats.include?(gl_format)
                     glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, j, gl_format, mipmap.width, mipmap.height, 0, mipmap.data)
                   else
@@ -58,16 +60,16 @@ module Mittsu
             end
           end
 
-          if @texture.generate_mipmaps && is_image_power_of_two
+          if generate_mipmaps && is_image_power_of_two
             glGenerateMipmap(GL_TEXTURE_CUBE_MAP)
           end
 
-          @texture.needs_update = false
+          self.needs_update = false
 
-          @texture.on_update.call if @texture.on_update
+          on_update.call if on_update
         else
           glActiveTexture(GL_TEXTURE0 + slot)
-          glBindTexture(GL_TEXTURE_CUBE_MAP, @texture.image[:_opengl_texture_cube])
+          glBindTexture(GL_TEXTURE_CUBE_MAP, image[:_opengl_texture_cube])
         end
       end
     end

data/lib/mittsu/renderers/opengl/textures/{opengl_data_texture.rb → data_texture.rb}

@@ -1,10 +1,8 @@
 module Mittsu
-  class OpenGLDataTexture < OpenGLTexture
+  class DataTexture
     def update_specific
-      gl_format = GL_MITTSU_PARAMS[@texture.format]
-      gl_type = GL_MITTSU_PARAMS[@texture.type]
-      mipmaps = @texture.mipmaps
-      image = @texture.image
+      gl_format = GL_MITTSU_PARAMS[format]
+      gl_type = GL_MITTSU_PARAMS[type]
       is_image_power_of_two = Math.power_of_two?(image.width) && Math.power_of_two?(image.height)
 
       # use manually created mipmaps if available

data/lib/mittsu/renderers/opengl/textures/{opengl_texture.rb → texture.rb}

@@ -1,38 +1,36 @@
 module Mittsu
-  class OpenGLTexture
+  class Texture
     attr_reader :opengl_texture
 
-    def initialize(texture, renderer)
-      @texture = texture
+    def set(slot, renderer)
       @renderer = renderer
-      @initted = false
-    end
 
-    def set(slot)
       glActiveTexture(GL_TEXTURE0 + slot)
 
-      if @texture.needs_update?
-        update
+      if needs_update?
+        update_opengl(@renderer)
       else
         glBindTexture(GL_TEXTURE_2D, @opengl_texture)
       end
     end
 
-    def update
+    def update_opengl(renderer)
+      @renderer = renderer
+
       if !@initted
         @initted = true
-        @texture.add_event_listener(:dispose, @renderer.method(:on_texture_dispose))
+        add_event_listener(:dispose, @renderer.method(:on_texture_dispose))
         @opengl_texture = glCreateTexture
         @renderer.info[:memory][:textures] += 1
       end
 
       glBindTexture(GL_TEXTURE_2D, @opengl_texture)
 
-      # glPixelStorei(GL_UNPACK_FLIP_Y_WEBGL, texture.flip_y) ???
-      # glPixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiply_alpha) ???
-      glPixelStorei(GL_UNPACK_ALIGNMENT, @texture.unpack_alignment)
+      # glPixelStorei(GL_UNPACK_FLIP_Y_WEBGL, flip_y) ???
+      # glPixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL, premultiply_alpha) ???
+      glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment)
 
-      image = @texture.image = @renderer.clamp_to_max_size(@texture.image)
+      self.image = @renderer.clamp_to_max_size(image)
 
       is_image_power_of_two = Math.power_of_two?(image.width) && Math.power_of_two?(image.height)
 
@@ -40,37 +38,37 @@ module Mittsu
 
       update_specific
 
-      if @texture.generate_mipmaps && is_image_power_of_two
+      if generate_mipmaps && is_image_power_of_two
         glGenerateMipmap(GL_TEXTURE_2D)
       end
 
-      @texture.needs_update = false
+      self.needs_update = false
 
-      @texture.on_update.call if @texture.on_update
+      on_update.call if on_update
     end
 
     protected
 
     def set_parameters(texture_type, is_image_power_of_two)
       if is_image_power_of_two
-        glTexParameteri(texture_type, GL_TEXTURE_WRAP_S, GL_MITTSU_PARAMS[@texture.wrap_s])
-        glTexParameteri(texture_type, GL_TEXTURE_WRAP_T, GL_MITTSU_PARAMS[@texture.wrap_t])
+        glTexParameteri(texture_type, GL_TEXTURE_WRAP_S, GL_MITTSU_PARAMS[wrap_s])
+        glTexParameteri(texture_type, GL_TEXTURE_WRAP_T, GL_MITTSU_PARAMS[wrap_t])
 
-        glTexParameteri(texture_type, GL_TEXTURE_MAG_FILTER, GL_MITTSU_PARAMS[@texture.mag_filter])
-        glTexParameteri(texture_type, GL_TEXTURE_MIN_FILTER, GL_MITTSU_PARAMS[@texture.min_filter])
+        glTexParameteri(texture_type, GL_TEXTURE_MAG_FILTER, GL_MITTSU_PARAMS[mag_filter])
+        glTexParameteri(texture_type, GL_TEXTURE_MIN_FILTER, GL_MITTSU_PARAMS[min_filter])
       else
         glTexParameteri(texture_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
         glTexParameteri(texture_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
 
-        if @texture.wrap_s != ClampToEdgeWrapping || @texture.wrap_t != ClampToEdgeWrapping
-          puts "WARNING: Mittsu::OpenGLTexture: Texture is not power of two. Texture.wrap_s and Texture.wrap_t should be set to Mittsu::ClampToEdgeWrapping. (#{texture.source_file})"
+        if wrap_s != ClampToEdgeWrapping || wrap_t != ClampToEdgeWrapping
+          puts "WARNING: Mittsu::Texture: Texture is not power of two. Texture.wrap_s and Texture.wrap_t should be set to Mittsu::ClampToEdgeWrapping. (#{texture.source_file})"
         end
 
-        glTexParameteri(texture_type, GL_TEXTURE_MAG_FILTER, filter_fallback(@texture.mag_filter))
-        glTexParameteri(texture_type, GL_TEXTURE_MIN_FILTER, filter_fallback(@texture.min_filter))
+        glTexParameteri(texture_type, GL_TEXTURE_MAG_FILTER, filter_fallback(mag_filter))
+        glTexParameteri(texture_type, GL_TEXTURE_MIN_FILTER, filter_fallback(min_filter))
 
-        if @texture.min_filter != NearestFilter && @texture.min_filter != LinearFilter
-          puts "WARNING: Mittsu::OpenGLTexture: Texture is not a power of two. Texture.min_filter should be set to Mittsu::NearestFilter or Mittsu::LinearFilter. (#{texture.source_file})"
+        if min_filter != NearestFilter && min_filter != LinearFilter
+          puts "WARNING: Mittsu::Texture: Texture is not a power of two. Texture.min_filter should be set to Mittsu::NearestFilter or Mittsu::LinearFilter. (#{texture.source_file})"
         end
 
         # TODO: anisotropic extension ???
@@ -87,10 +85,8 @@ module Mittsu
   	end
 
     def update_specific
-      gl_format = GL_MITTSU_PARAMS[@texture.format]
-      gl_type = GL_MITTSU_PARAMS[@texture.type]
-      mipmaps = @texture.mipmaps
-      image = @texture.image
+      gl_format = GL_MITTSU_PARAMS[format]
+      gl_type = GL_MITTSU_PARAMS[type]
       is_image_power_of_two = Math.power_of_two?(image.width) && Math.power_of_two?(image.height)
 
       # use manually created mipmaps if available
@@ -102,9 +98,9 @@ module Mittsu
           glTexImage2D(GL_TEXTURE_2D, i, gl_format, mipmap.width, mipmap.height, 0, gl_format, gl_type, mipmap.data)
         end
 
-        @texture.generate_mipmaps = false
+        self.generate_mipmaps = false
       else
-        glTexImage2D(GL_TEXTURE_2D, 0, gl_format, @texture.image.width, @texture.image.height, 0, gl_format, gl_type, @texture.image.data)
+        glTexImage2D(GL_TEXTURE_2D, 0, gl_format, image.width, image.height, 0, gl_format, gl_type, image.data)
       end
     end
   end

data/lib/mittsu/renderers/opengl_render_target.rb

@@ -1,5 +1,5 @@
 module Mittsu
-  class OpenGLRenderTarget < OpenGLTexture
+  class OpenGLRenderTarget < Texture
     include EventDispatcher
 
     attr_accessor :width,
@@ -20,6 +20,8 @@ module Mittsu
 
     attr_reader :framebuffer
 
+    attr_writer :renderer
+
     def initialize(width, height, options = {})
       super(self, nil)
 
@@ -59,6 +61,8 @@ module Mittsu
 
     def clone
       OpenGLRenderTarget.new(@width, @height).tap do |tmp|
+        tmp.renderer = @renderer
+
     		tmp.wrap_s = @wrap_s
     		tmp.wrap_t = @wrap_t
 
@@ -155,11 +159,6 @@ module Mittsu
       dispatch_event(type: :dispose)
     end
 
-    def implementation(renderer)
-      @renderer = renderer
-      self
-    end
-
     def update_mipmap
       return if !@generate_mipmaps || @min_filter == NearestFilter || @min_filter == LinearFilter
       # TODO: when OpenGLRenderTargetCube exists

data/lib/mittsu/renderers/opengl_renderer.rb

@@ -2,7 +2,10 @@ require 'opengl'
 require 'glfw'
 require 'fiddle'
 
-OpenGL.load_lib
+
+require 'mittsu/renderers/opengl/opengl_lib'
+opengl_lib = OpenGLLib.discover
+OpenGL.load_lib(opengl_lib.file, opengl_lib.path)
 
 require 'mittsu'
 require 'mittsu/renderers/glfw_window'
@@ -185,10 +188,8 @@ module Mittsu
       # TODO: when OpenGLRenderTargetCube exists
       # is_cube = render_target.is_a? OpenGLRenderTargetCube
 
-      render_target_impl = render_target.implementation(self)
-
       # TODO framebuffer logic for render target cube
-      render_target_impl.setup_buffers
+      render_target.setup_buffers
 
       if render_target != @_current_render_target
         render_target.use
@@ -207,7 +208,7 @@ module Mittsu
       update_skeleton_objects(scene)
 
       update_screen_projection(camera)
-      scene.implementation(self).project
+      scene.project(self)
       sort_objects_for_render if @sort_objects
 
       render_custom_plugins_pre_pass(scene, camera)
@@ -220,7 +221,7 @@ module Mittsu
 
       render_custom_plugins_post_pass(scene, camera)
 
-      render_target.implementation(self).update_mipmap
+      render_target.update_mipmap
 
       ensure_depth_buffer_writing
     end
@@ -231,8 +232,10 @@ module Mittsu
     end
 
     def render_buffer(camera, lights, fog, material, geometry_group, object)
+      puts "--- RENDER #{object.name}" if DEBUG
       return unless material.visible
 
+      geometry_group.renderer = self
       geometry_group.bind_vertex_array_object
 
       update_object(object)
@@ -256,7 +259,7 @@ module Mittsu
 
       @state.disable_unused_attributes
 
-      object.implementation(self).render_buffer(camera, lights, fog, material, geometry_group, buffers_need_update)
+      object.render_buffer(camera, lights, fog, material, geometry_group, buffers_need_update)
 
       # TODO: render particles
       # when PointCloud
@@ -308,10 +311,6 @@ module Mittsu
       deallocate_material(material)
     end
 
-    def create_implementation(thing)
-      OPENGL_IMPLEMENTATIONS[thing.class].new(thing, self)
-    end
-
     def clamp_to_max_size(image, max_size = @_max_texture_size)
       width, height = image.width, image.height
       if width > max_size || height > max_size
@@ -364,19 +363,18 @@ module Mittsu
     def render_objects(render_list, camera, lights, fog, override_material)
       material = nil
       render_list.each do |opengl_object|
+        puts "-- RENDER_OBJECT #{opengl_object.name}" if DEBUG
         object = opengl_object.object
         buffer = opengl_object.buffer
 
-        object.implementation(self).setup_matrices(camera)
+        object.setup_matrices(camera)
 
         if override_material
           material = override_material
-          material_impl = material.implementation(self)
         else
           material = opengl_object.material
           next unless material
-          material_impl = material.implementation(self)
-          material_impl.set
+          material.set(self)
         end
 
         set_material_faces(material)
@@ -384,7 +382,8 @@ module Mittsu
           # TODO
           # render_buffer_direct(camera, lights, fog, material, buffer, object)
         else
-          render_buffer(camera, lights, fog, material, buffer.implementation(self), object)
+          puts "-- RENDER COLOR #{material.color}" if DEBUG
+          render_buffer(camera, lights, fog, material, buffer, object)
         end
       end
     end
@@ -403,8 +402,7 @@ module Mittsu
             else nil
             end
             next unless material
-            material_impl = material.implementation(self)
-            material_impl.set
+            material.set(self)
           end
           render_immediate_object(camera, lights, fog, material, object)
         end
@@ -439,6 +437,7 @@ module Mittsu
       material = object.material
 
       if material
+        puts "--- UNROLL #{opengl_object.name}" if DEBUG
         if material.is_a? MeshFaceMaterial
           material_index = geometry.is_a?(BufferGeometry) ? 0 : buffer.material_index
           material = material.materials[material_index]
@@ -457,7 +456,6 @@ module Mittsu
     # FIXME: refactor
     def update_object(object)
       geometry = object.geometry
-      object_impl = object.implementation(self)
 
       if geometry.is_a? BufferGeometry
         # TODO: geometry vertex array ?????
@@ -488,12 +486,12 @@ module Mittsu
           end
         end
       else
-        object_impl.update
+        object.update
       end
       # TODO: when PointCloud exists
       # elsif object.is_A? PointCloud
       #   # TODO: glBindVertexArray ???
-      #   material = object_impl.buffer_material(geometry)
+      #   material = object.buffer_material(geometry)
       #   custom_attributes_dirty = material.attributes && are_custom_attributes_dirty(material)
       #
       #   if geometry.vertices_need_update || geometry.colors_need_update || custom_attributes_dirty
@@ -510,19 +508,16 @@ module Mittsu
     # FIXME: refactor
     def set_program(camera, lights, fog, material, object)
       @_used_texture_units = 0
-      material_impl = material.implementation(self)
-      object_impl = object.implementation(self)
-
       if material.needs_update?
         deallocate_material(material) if material.program
 
-        material_impl.init(lights, fog, object)
+        material.init(lights, fog, object, self)
         material.needs_update = false
       end
 
       if material.morph_targets
-        if !object_impl.morph_target_influences
-          object_impl.morph_target_influences = Array.new(@max_morph_targets) # Float32Array
+        if !object.morph_target_influences
+          object.morph_target_influences = Array.new(@max_morph_targets) # Float32Array
         end
       end
 
@@ -532,7 +527,7 @@ module Mittsu
 
       program = material.program
       program_uniforms = program.uniforms
-      material_uniforms = material_impl.shader[:uniforms]
+      material_uniforms = material.shader[:uniforms]
 
       if program.id != @_current_program
         glUseProgram(program.program)
@@ -570,7 +565,7 @@ module Mittsu
         #     texture_unit = get_texture_unit
         #
         #     glUniform1i(program_uniforms['boneTexture'], texture_unit)
-        #     object.skeleton.bone_texture.implementation(self).set(texture_unit)
+        #     object.skeleton.bone_texture.set(texture_unit, self)
         #   end
         #
         #   if !program_uniforms['boneTextureWidth'].nil?
@@ -591,7 +586,7 @@ module Mittsu
         # TODO: when fog is implemented
         # refresh_uniforms_fog(material_uniforms, fog) if fog && material.fog
 
-        if material_impl.needs_lights?
+        if material.needs_lights?
           if @light_renderer.lights_need_update
             refresh_lights = true
             @light_renderer.setup(lights)
@@ -604,7 +599,7 @@ module Mittsu
           OpenGLHelper.mark_uniforms_lights_needs_update(material_uniforms, refresh_lights)
         end
 
-        material_impl.refresh_uniforms(material_uniforms)
+        material.refresh_uniforms(material_uniforms)
 
         # TODO: when all of these things exist
         # when LineDashedMaterial
@@ -619,14 +614,14 @@ module Mittsu
         # when MeshNormalMaterial
         #   material_uniforms.opactity.value = material.opacity
 
-        if object.receive_shadow && !material_impl.shadow_pass
+        if object.receive_shadow && !material.shadow_pass
           OpenGLHelper.refresh_uniforms_shadow(material_uniforms, lights)
         end
 
-        load_uniforms_generic(material_impl.uniforms_list)
+        load_uniforms_generic(material.uniforms_list)
       end
 
-      object.implementation(self).load_uniforms_matrices(program_uniforms)
+      object.load_uniforms_matrices(program_uniforms)
 
       if !program_uniforms['modelMatrix'].nil?
         glUniformMatrix4fv(program_uniforms['modelMatrix'], 1, GL_FALSE, array_to_ptr_easy(object.matrix_world.elements))
@@ -731,8 +726,7 @@ module Mittsu
 
           next unless texture
 
-          texture_impl = texture.implementation(self)
-          texture_impl.set(texture_unit)
+          texture.set(texture_unit, self)
           # TODO: when OpenGLRenderTargetCube is defined
           # elsif texture.is_a?(OpenGLRenderTargetCube)
             # set_cube_texture_dynamic(texture, texture_unit)
@@ -751,7 +745,7 @@ module Mittsu
 
             next unless tex
 
-            tex.implementation(self).set(tex_unit)
+            tex.set(tex_unit, self)
           end
         else
           puts "WARNING: Mittsu::OpenGLRenderer: Unknown uniform type: #{type}"
@@ -821,7 +815,7 @@ module Mittsu
         object = opengl_object.object
 
         if object.visible
-          object.implementation(self).setup_matrices(camera)
+          object.setup_matrices(camera)
           unroll_immediate_buffer_material(opengl_object)
         end
       end
@@ -837,9 +831,8 @@ module Mittsu
 
     def render_with_override_material(scene, camera)
       override_material = scene.override_material
-      material_impl = override_material.implementation(self)
 
-      material_impl.set
+      override_material.set(self)
 
       render_objects(@opaque_objects, camera, @lights, scene.fog, override_material)
       render_objects(@transparent_objects, camera, @lights, scene.fog, override_material)
@@ -1030,20 +1023,18 @@ module Mittsu
     end
 
     def update_camera_uniforms(uniforms, camera, material)
-      material_impl = material.implementation(self)
-
       glUniformMatrix4fv(uniforms['projectionMatrix'], 1, GL_FALSE, array_to_ptr_easy(camera.projection_matrix.elements))
 
       if @logarithmic_depth_buffer
         glUniform1f(uniforms['logDepthBuffFC'], 2.0 / Math.log(camera.far + 1.0) / Math::LN2)
       end
 
-      if material_impl.needs_camera_position_uniform? && !uniforms['cameraPosition'].nil?
+      if material.needs_camera_position_uniform? && !uniforms['cameraPosition'].nil?
         @_vector3.set_from_matrix_position(camera.matrix_world)
         glUniform3f(uniforms['cameraPosition'], @_vector3.x, @_vector3.y, @_vector3.z)
       end
 
-      if material_impl.needs_view_matrix_uniform? && !uniforms['viewMatrix'].nil?
+      if material.needs_view_matrix_uniform? && !uniforms['viewMatrix'].nil?
         glUniformMatrix4fv(uniforms['viewMatrix'], 1, GL_FALSE, array_to_ptr_easy(camera.matrix_world_inverse.elements))
       end
     end