mittsu 0.1.1 → 0.1.2

data/lib/mittsu/renderers/opengl/opengl_state.rb

@@ -1,8 +1,6 @@
 module Mittsu
   class OpenGLState
-    def initialize(param_mittsu_to_gl)
-      @param_mittsu_to_gl = param_mittsu_to_gl
-
+    def initialize
       @new_attributes = Array.new(16) # Uint8Array
       @enabled_attributes = Array.new(16) # Uint8Array
 
@@ -90,14 +88,14 @@ module Mittsu
         blend_dst_alpha ||= blend_dst
 
         if blend_equation != @current_blend_equation || blend_equation_alpha != @current_blend_equation_alpha
-          glBlendEquationSeparate(@param_mittsu_to_gl[blend_equation], @param_mittsu_to_gl[blend_equation_alpha])
+          glBlendEquationSeparate(GL_MITTSU_PARAMS[blend_equation], GL_MITTSU_PARAMS[blend_equation_alpha])
 
           @current_blend_equation = blend_equation
           @current_blend_equation_alpha = blend_equation_alpha
         end
 
         if blend_src != @current_blend_src || blend_dst != @current_blend_dst || blend_src_alpha != @current_blend_src_alpha || blend_dst_alpha != @current_blend_dst_alpha
-          glBlendFuncSeparate(@param_mittsu_to_gl[blend_src], @param_mittsu_to_gl[blend_dst], @param_mittsu_to_gl[blend_src_alpha], @param_mittsu_to_gl[blend_dst_alpha])
+          glBlendFuncSeparate(GL_MITTSU_PARAMS[blend_src], GL_MITTSU_PARAMS[blend_dst], GL_MITTSU_PARAMS[blend_src_alpha], GL_MITTSU_PARAMS[blend_dst_alpha])
 
           @current_blend_src = nil
           @current_blend_dst = nil

data/lib/mittsu/renderers/opengl/plugins/shadow_map_plugin.rb

@@ -49,10 +49,10 @@ module Mittsu
         skinning: true
       )
 
-      @depth_material[:_shadow_pass] = true
-      @depth_material_morph[:_shadow_pass] = true
-      @depth_material_skin[:_shadow_pass] = true
-      @depth_material_morph_skin[:_shadow_pass] = true
+      @depth_material.implementation(renderer).shadow_pass = true
+      @depth_material_morph.implementation(renderer).shadow_pass = true
+      @depth_material_skin.implementation(renderer).shadow_pass = true
+      @depth_material_morph_skin.implementation(renderer).shadow_pass = true
     end
 
     def render(scene, camera)
@@ -142,9 +142,10 @@ module Mittsu
           scene.update_matrix_world if scene.auto_update
         end
 
-        if light.shadow_camera_visible && !light[:camera_helper]
-          light[:camera_helper] = CameraHelper.new(light.shadow_camera)
-          scene.add(light[:camera_helper])
+        light_impl = light.implementation(@renderer)
+        if light.shadow_camera_visible && !light_impl.camera_helper
+          light_impl.camera_helper = CameraHelper.new(light.shadow_camera)
+          scene.add(light_impl.camera_helper)
         end
 
         if light.virtual? && virtual_light.original_camera == camera
@@ -167,8 +168,8 @@ module Mittsu
         #
 
 
-        light[:camera_helper].visible = light.shadow_camera_visible if light[:camera_helper]
-        light[:camera_helper].update if light.shadow_camera_visible
+        light_impl.camera_helper.visible = light.shadow_camera_visible if light_impl.camera_helper
+        light_impl.camera_helper.update if light.shadow_camera_visible
 
         # compute shadow matrix
 
@@ -273,7 +274,8 @@ module Mittsu
 
         if opengl_objects && object.cast_shadow && (object.frustum_culled == false || @frustum.intersects_object?(object) == true)
           opengl_objects.each do |opengl_object|
-            object[:_model_view_matrix].multiply_matrices(shadow_camera.matrix_world_inverse, object.matrix_world)
+            object_impl = object.implementation(@renderer)
+            object_impl.model_view_matrix.multiply_matrices(shadow_camera.matrix_world_inverse, object.matrix_world)
             @render_list << opengl_object
           end
         end

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

@@ -0,0 +1,8 @@
+module Mittsu
+  class OpenGLScene < OpenGLObject3D
+    def project
+      return unless @object.visible
+      project_children
+    end
+  end
+end

data/lib/mittsu/renderers/opengl/textures/opengl_compressed_texture.rb

@@ -0,0 +1,21 @@
+module Mittsu
+  class OpenGLCompressedTexture < OpenGLTexture
+    def update_specific
+      gl_format = GL_MITTSU_PARAMS[@texture.format]
+      gl_type = GL_MITTSU_PARAMS[@texture.type]
+      mipmaps = @texture.mipmaps
+
+      mipmaps.each_with_index do |mipmap, i|
+        if @texture.format != RGBAFormat && @texture.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'
+          end
+        else
+          glTexImage2D(GL_TEXTURE_2D, i, gl_format, mipmap.width, mipmap.height, 0, gl_format, gl_type, mipmap.data)
+        end
+      end
+    end
+  end
+end

data/lib/mittsu/renderers/opengl/textures/opengl_cube_texture.rb

@@ -0,0 +1,75 @@
+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
+            @renderer.info[:memory][:textures] += 1
+          end
+
+          glActiveTexture(GL_TEXTURE0 + slot)
+          glBindTexture(GL_TEXTURE_CUBE_MAP, @texture.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)
+
+          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)
+            else
+              cube_image[i] = is_data_texture ? @texture.image[i].image : @texture.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]
+
+          set_parameters(GL_TEXTURE_CUBE_MAP, is_image_power_of_two)
+
+          6.times do |i|
+            if !is_compressed
+              if is_data_texture
+                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, gl_format, cube_image[i].width, cube_image[i].height, 0, gl_format, gl_type, cube_image[i].data)
+              else
+                glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, gl_format, cube_image[i].width, cube_image[i].height, 0, gl_format, gl_type, cube_image[i].data)
+              end
+            else
+              mipmaps = cube_image[i].mipmaps
+
+              mipmaps.each_with_index do |mipmap, j|
+                if @texture.format != RGBAFormat && @texture.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
+                    puts "WARNING: Mittsu::OpenGLCubeTexture: Attempt to load unsupported compressed texture format in #set"
+                  end
+                else
+                  glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, j, gl_format, mipmap.width, mipmap.height, 0, gl_format, gl_type, mipmap.data)
+                end
+              end
+            end
+          end
+
+          if @texture.generate_mipmaps && is_image_power_of_two
+            glGenerateMipmap(GL_TEXTURE_CUBE_MAP)
+          end
+
+          @texture.needs_update = false
+
+          @texture.on_update.call if @texture.on_update
+        else
+          glActiveTexture(GL_TEXTURE0 + slot)
+          glBindTexture(GL_TEXTURE_CUBE_MAP, @texture.image[:_opengl_texture_cube])
+        end
+      end
+    end
+  end
+end

data/lib/mittsu/renderers/opengl/textures/opengl_data_texture.rb

@@ -0,0 +1,23 @@
+module Mittsu
+  class OpenGLDataTexture < OpenGLTexture
+    def update_specific
+      gl_format = GL_MITTSU_PARAMS[@texture.format]
+      gl_type = GL_MITTSU_PARAMS[@texture.type]
+      mipmaps = @texture.mipmaps
+      image = @texture.image
+      is_image_power_of_two = Math.power_of_two?(image.width) && Math.power_of_two?(image.height)
+
+      # use manually created mipmaps if available
+      # if there are no manual mipmaps
+      # set 0 level mipmap and then use GL to generate other mipmap levels
+
+      if !mipmaps.empty? && is_image_power_of_two
+        mipmaps.each_with_index do |mipmap, i|
+          glTexImage2D(GL_TEXTURE_2D, i, gl_format, mipmap.width, mipmap.height, 0, gl_format, gl_type, mipmap.data)
+        end
+      else
+        glTexImage2D(GL_TEXTURE_2D, 0, gl_format, image.width, image.height, 0, gl_format, gl_type, image.data)
+      end
+    end
+  end
+end

data/lib/mittsu/renderers/opengl/textures/opengl_texture.rb

@@ -0,0 +1,111 @@
+module Mittsu
+  class OpenGLTexture
+    attr_reader :opengl_texture
+
+    def initialize(texture, renderer)
+      @texture = texture
+      @renderer = renderer
+      @initted = false
+    end
+
+    def set(slot)
+      glActiveTexture(GL_TEXTURE0 + slot)
+
+      if @texture.needs_update?
+        update
+      else
+        glBindTexture(GL_TEXTURE_2D, @opengl_texture)
+      end
+    end
+
+    def update
+      if !@initted
+        @initted = true
+        @texture.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)
+
+      image = @texture.image = @renderer.clamp_to_max_size(@texture.image)
+
+      is_image_power_of_two = Math.power_of_two?(image.width) && Math.power_of_two?(image.height)
+
+      set_parameters(GL_TEXTURE_2D, is_image_power_of_two)
+
+      update_specific
+
+      if @texture.generate_mipmaps && is_image_power_of_two
+        glGenerateMipmap(GL_TEXTURE_2D)
+      end
+
+      @texture.needs_update = false
+
+      @texture.on_update.call if @texture.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_MAG_FILTER, GL_MITTSU_PARAMS[@texture.mag_filter])
+        glTexParameteri(texture_type, GL_TEXTURE_MIN_FILTER, GL_MITTSU_PARAMS[@texture.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})"
+        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))
+
+        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})"
+        end
+
+        # TODO: anisotropic extension ???
+      end
+    end
+
+  	# Fallback filters for non-power-of-2 textures
+  	def filter_fallback(filter)
+  		if filter == NearestFilter || filter == NearestMipMapNearestFilter || f == NearestMipMapLinearFilter
+  			GL_NEAREST
+  		end
+
+      GL_LINEAR
+  	end
+
+    def update_specific
+      gl_format = GL_MITTSU_PARAMS[@texture.format]
+      gl_type = GL_MITTSU_PARAMS[@texture.type]
+      mipmaps = @texture.mipmaps
+      image = @texture.image
+      is_image_power_of_two = Math.power_of_two?(image.width) && Math.power_of_two?(image.height)
+
+      # use manually created mipmaps if available
+      # if there are no manual mipmaps
+      # set 0 level mipmap and then use GL to generate other mipmap levels
+
+      if !mipmaps.empty? && is_image_power_of_two
+        mipmaps.each_with_index do |mipmap, i|
+          glTexImage2D(GL_TEXTURE_2D, i, gl_format, mipmap.width, mipmap.height, 0, gl_format, gl_type, mipmap.data)
+        end
+
+        @texture.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)
+      end
+    end
+  end
+end

data/lib/mittsu/renderers/opengl_render_target.rb

@@ -1,5 +1,5 @@
 module Mittsu
-  class OpenGLRenderTarget < HashObject
+  class OpenGLRenderTarget < OpenGLTexture
     include EventDispatcher
 
     attr_accessor :width,
@@ -18,8 +18,10 @@ module Mittsu
                   :generate_mipmaps,
                   :share_depth_from
 
+    attr_reader :framebuffer
+
     def initialize(width, height, options = {})
-      super()
+      super(self, nil)
 
       @width = width
       @height = height
@@ -80,8 +82,121 @@ module Mittsu
       end
     end
 
+    def setup_buffers
+      return unless @framebuffer.nil?
+
+      # TODO: when OpenGLRenderTargetCube exists
+      is_cube = false # render_target.is_a? OpenGLRenderTargetCube
+
+      @depth_buffer = true if @depth_buffer.nil?
+      @stencil_buffer = true if @stencil_buffer.nil?
+
+      add_event_listener(:dispose, @renderer.method(:on_render_target_dispose))
+
+      @opengl_texture = glCreateTexture
+
+      @renderer.info[:memory][:textures] += 1
+
+      # Setup texture, create render and frame buffers
+
+      is_target_power_of_two = Math.power_of_two?(@width) && Math.power_of_two?(@height)
+      gl_format = GL_MITTSU_PARAMS[@format]
+      gl_type = GL_MITTSU_PARAMS[@type]
+
+      if is_cube
+        # TODO
+      else
+        @framebuffer = glCreateFramebuffer
+
+        if @share_depth_from
+          @renderbuffer = share_depth_from.renderbuffer
+        else
+          @renderbuffer = glCreateRenderbuffer
+        end
+
+        glBindTexture(GL_TEXTURE_2D, @opengl_texture)
+        set_parameters(GL_TEXTURE_2D, is_target_power_of_two)
+
+        glTexImage2D(GL_TEXTURE_2D, 0, gl_format, @width, @height, 0, gl_format, gl_type, nil)
+
+        setup_framebuffer(GL_TEXTURE_2D)
+
+        if @share_depth_from
+          if @depth_buffer && !@stencil_buffer
+            glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, @renderbuffer)
+          elsif @depth_buffer && @stencil_buffer
+            glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, @renderbuffer)
+          end
+        else
+          setup_renderbuffer
+        end
+
+        glGenerateMipmap(GL_TEXTURE_2D) if is_target_power_of_two
+      end
+
+      # Release everything
+
+      if is_cube
+        # TODO
+      else
+        glBindTexture(GL_TEXTURE_2D, 0)
+      end
+
+      glBindRenderbuffer(GL_RENDERBUFFER, 0)
+      glBindFramebuffer(GL_FRAMEBUFFER, 0)
+    end
+
+    def use
+      glBindFramebuffer(GL_FRAMEBUFFER, @framebuffer)
+      glViewport(0, 0, @width, @height)
+    end
+
     def dispose
       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
+  		# 	glBindTexture(GL_TEXTURE_CUBE_MAP, @opengl_texture)
+  		# 	glGenerateMipmap(GL_TEXTURE_CUBE_MAP)
+  		# 	glBindTexture(GL_TEXTURE_CUBE_MAP, nil)
+			glBindTexture(GL_TEXTURE_2D, @opengl_texture)
+			glGenerateMipmap(GL_TEXTURE_2D)
+			glBindTexture(GL_TEXTURE_2D, nil)
+    end
+
+    private
+
+    def setup_framebuffer(texture_target)
+      glBindFramebuffer(GL_FRAMEBUFFER, @framebuffer)
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture_target, @opengl_texture, 0)
+    end
+
+    def setup_renderbuffer
+      glBindRenderbuffer(GL_RENDERBUFFER, @renderbuffer)
+
+      if @depth_buffer && !@stencil_buffer
+        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, @width, @height)
+        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, @renderbuffer)
+
+        # TODO: investigate this (?):
+    		# THREE.js - For some reason this is not working. Defaulting to RGBA4.
+    		# } else if ( ! renderTarget.depthBuffer && renderTarget.stencilBuffer ) {
+        #
+    		# 	_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.STENCIL_INDEX8, renderTarget.width, renderTarget.height );
+    		# 	_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.STENCIL_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );
+      elsif @depth_buffer && @stencil_buffer
+        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, @width, @height)
+        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, @renderbuffer)
+      else
+        glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, @width, @height)
+      end
+    end
   end
 end