mittsu 0.4.1 → 0.5.0

data/lib/mittsu/renderers/opengl/plugins/sprite_fragment.glsl

@@ -1,38 +0,0 @@
-#version 330
-
-uniform vec3 color;
-uniform sampler2D map;
-uniform float opacity;
-
-uniform int fogType;
-uniform vec3 fogColor;
-uniform float fogDensity;
-uniform float fogNear;
-uniform float fogFar;
-uniform float alphaTest;
-
-in vec2 vUV;
-layout(location = 0) out vec4 fragColor;
-
-void main() {
-	vec4 texture = texture( map, vUV );
-
-	if ( texture.a < alphaTest ) discard;
-
-	fragColor = vec4( color * texture.xyz, texture.a * opacity );
-
-	if ( fogType > 0 ) {
-		float depth = gl_FragCoord.z / gl_FragCoord.w;
-		float fogFactor = 0.0;
-
-		if ( fogType == 1 ) {
-			fogFactor = smoothstep( fogNear, fogFar, depth );
-		} else {
-			const float LOG2 = 1.442695;
-			float fogFactor = exp2( - fogDensity * fogDensity * depth * depth * LOG2 );
-			fogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 );
-		}
-
-		fragColor = mix( fragColor, vec4( fogColor, fragColor.w ), fogFactor );
-	}
-}

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

@@ -1,250 +0,0 @@
-module Mittsu
-  class SpritePlugin
-    include OpenGLHelper
-
-    VERTICES = [
-      -0.5, -0.5, 0.0, 0.0,
-       0.5, -0.5, 1.0, 0.0,
-       0.5,  0.5, 1.0, 1.0,
-      -0.5,  0.5, 0.0, 1.0
-    ] # Float32Array
-
-    FACES = [
-      0, 1, 2,
-      0, 2, 3
-    ] # Uint16Array
-
-    def initialize(renderer, sprites)
-      @renderer = renderer
-      @sprites = sprites
-      @program = nil
-
-      # for decomposing matrixWorld
-      @sprite_position = Vector3.new
-      @sprite_rotation = Quaternion.new
-      @sprite_scale = Vector3.new
-    end
-
-    def render(scene, camera)
-      return if @sprites.empty?
-
-      init if @program.nil?
-      setup_gl_for_render(camera)
-      setup_fog(scene)
-
-      update_positions_and_sort(camera)
-
-      render_all_sprites(scene)
-
-      glEnable(GL_CULL_FACE)
-      @renderer.reset_gl_state
-    end
-
-    private
-
-    def init
-      create_vertex_array_object
-      create_program
-
-      init_attributes
-      init_uniforms
-
-      # TODO: canvas texture??
-    end
-
-    def create_vertex_array_object
-      @vertex_array_object = glCreateVertexArray
-      glBindVertexArray(@vertex_array_object)
-
-      @vertex_buffer = glCreateBuffer
-      @element_buffer = glCreateBuffer
-
-      glBindBuffer(GL_ARRAY_BUFFER, @vertex_buffer)
-      glBufferData_easy(GL_ARRAY_BUFFER, VERTICES, GL_STATIC_DRAW)
-
-      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, @element_buffer)
-      glBufferData_easy(GL_ELEMENT_ARRAY_BUFFER, FACES, GL_STATIC_DRAW)
-    end
-
-    def create_program
-      @program = glCreateProgram
-
-      vertex_shader = OpenGLShader.new(GL_VERTEX_SHADER, File.read(File.join(__dir__, 'sprite_vertex.glsl')))
-      fragment_shader = OpenGLShader.new(GL_FRAGMENT_SHADER, File.read(File.join(__dir__, 'sprite_fragment.glsl')))
-
-      glAttachShader(@program, vertex_shader.shader)
-      glAttachShader(@program, fragment_shader.shader)
-
-      glLinkProgram(@program)
-    end
-
-    def init_attributes
-      @attributes = {
-        position: glGetAttribLocation(@program, 'position'),
-        uv: glGetAttribLocation(@program, 'uv')
-      }
-    end
-
-    def init_uniforms
-      @uniforms = {
-        uvOffset: glGetUniformLocation(@program, 'uvOffset'),
-        uvScale: glGetUniformLocation(@program, 'uvScale'),
-
-        rotation: glGetUniformLocation(@program, 'rotation'),
-        scale: glGetUniformLocation(@program, 'scale'),
-
-        color: glGetUniformLocation(@program, 'color'),
-        map: glGetUniformLocation(@program, 'map'),
-        opacity: glGetUniformLocation(@program, 'opacity'),
-
-        modelViewMatrix: glGetUniformLocation(@program, 'modelViewMatrix'),
-        projectionMatrix: glGetUniformLocation(@program, 'projectionMatrix'),
-
-        fogType: glGetUniformLocation(@program, 'fogType'),
-        fogDensity: glGetUniformLocation(@program, 'fogDensity'),
-        fogNear: glGetUniformLocation(@program, 'fogNear'),
-        fogFar: glGetUniformLocation(@program, 'fogFar'),
-        fogColor: glGetUniformLocation(@program, 'fogColor'),
-
-        alphaTest: glGetUniformLocation(@program, 'alphaTest')
-      }
-    end
-
-    def painter_sort_stable(a, b)
-      if a.z != b.z
-        b.z - a.z
-      else
-        b.id - a.id
-      end
-    end
-
-    def setup_gl_for_render(camera)
-      glUseProgram(@program)
-
-      glDisable(GL_CULL_FACE)
-      glEnable(GL_BLEND)
-
-      glBindVertexArray(@vertex_array_object)
-
-      glEnableVertexAttribArray(@attributes[:position])
-      glEnableVertexAttribArray(@attributes[:uv])
-
-      glBindBuffer(GL_ARRAY_BUFFER, @vertex_buffer)
-
-      glVertexAttribPointer(@attributes[:position], 2, GL_FLOAT, GL_FALSE, 2 * 8, 0)
-      glVertexAttribPointer(@attributes[:uv], 2, GL_FLOAT, GL_FALSE, 2 * 8, 8)
-
-      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, @element_buffer)
-
-      glUniformMatrix4fv(@uniforms[:projectionMatrix], 1, GL_FALSE, array_to_ptr_easy(camera.projection_matrix.elements))
-
-      glActiveTexture(GL_TEXTURE0)
-      glUniform1i(@uniforms[:map], 0)
-    end
-
-    def setup_fog(scene)
-      @old_fog_type = 0
-      @scene_fog_type = 0
-      fog = scene.fog
-
-      if fog
-        glUniform3f(@uniforms[:fogColor], fog.color.r, fog.color.g, fog.color.b)
-
-        if fog.is_a?(Fog)
-          glUniform1f(@uniforms[:fogNear], fog.near)
-          glUniform1f(@uniforms[:fogFar], fog.far)
-
-          glUniform1i(@uniforms[:fogType], 1)
-          @old_fog_type = 1
-          @scene_fog_type = 1
-        elsif fog.is_a?(FogExp2)
-          glUniform1f(@uniforms[:fogDensity], fog.density)
-
-          glUniform1i(@uniforms[:fogType], 2)
-          @old_fog_type = 2
-          @scene_fog_type = 2
-        end
-      else
-        glUniform1i(@uniforms[:fogType], 0)
-        @old_fog_type = 0
-        @scene_fog_type = 0
-      end
-    end
-
-    def update_positions_and_sort(camera)
-      @sprites.each do |sprite|
-        sprite.model_view_matrix.multiply_matrices(camera.matrix_world_inverse, sprite.matrix_world)
-        sprite.z = -sprite.model_view_matrix.elements[14]
-      end
-
-      @sprites.sort!(&self.method(:painter_sort_stable))
-    end
-
-    def render_all_sprites(scene)
-      @sprites.each do |sprite|
-        material = sprite.material
-
-        set_fog_uniforms(material, scene)
-        set_uv_uniforms(material)
-        set_color_uniforms(material)
-        set_transform_uniforms(sprite)
-        set_blend_mode(material)
-
-        # set texture
-        if material.map && material.map.image && material.map.image.width
-          material.map.set(0, @renderer)
-        else
-          # TODO: canvas texture?
-          # texture.set(0, @renderer)
-        end
-
-        # draw elements
-        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0) # GL_UNSIGNED_SHORT
-      end
-    end
-
-    def set_fog_uniforms(material, scene)
-      fog_type = 0
-
-      if scene.fog && material.fog
-        fog_type = @scene_fog_type
-      end
-
-      if @old_fog_type != fog_type
-        glUniform1(@uniforms[:fogType], fog_type)
-        @old_fog_type = fog_type
-      end
-    end
-
-    def set_uv_uniforms(material)
-      if !material.map.nil?
-        glUniform2f(@uniforms[:uvOffset], material.map.offset.x, material.map.offset.y)
-        glUniform2f(@uniforms[:uvScale], material.map.repeat.x, material.map.repeat.y)
-      else
-        glUniform2f(@uniforms[:uvOffset], 0.0, 0.0)
-        glUniform2f(@uniforms[:uvScale], 1.0, 1.0)
-      end
-    end
-
-    def set_color_uniforms(material)
-      glUniform1f(@uniforms[:opacity], material.opacity)
-      glUniform3f(@uniforms[:color], material.color.r, material.color.g, material.color.b)
-      glUniform1f(@uniforms[:alphaTest], material.alpha_test)
-    end
-
-    def set_transform_uniforms(sprite)
-      glUniformMatrix4fv(@uniforms[:modelViewMatrix], 1, GL_FALSE, array_to_ptr_easy(sprite.model_view_matrix.elements))
-
-      sprite.matrix_world.decompose(@sprite_position, @sprite_rotation, @sprite_scale)
-
-      glUniform1f(@uniforms[:rotation], sprite.material.rotation)
-      glUniform2fv(@uniforms[:scale], 1, array_to_ptr_easy([@sprite_scale.x, @sprite_scale.y]))
-    end
-
-    def set_blend_mode(material)
-      @renderer.state.set_blending(material.blending, material.blend_equation, material.blend_src, material.blend_dst)
-      @renderer.state.set_depth_test(material.depth_test)
-      @renderer.state.set_depth_write(material.depth_write)
-    end
-  end
-end

data/lib/mittsu/renderers/opengl/plugins/sprite_vertex.glsl

@@ -1,31 +0,0 @@
-#version 330
-
-uniform mat4 modelViewMatrix;
-uniform mat4 projectionMatrix;
-uniform float rotation;
-uniform vec2 scale;
-uniform vec2 uvOffset;
-uniform vec2 uvScale;
-
-in vec2 position;
-in vec2 uv;
-
-out vec2 vUV;
-
-void main() {
-  vUV = uvOffset + uv * uvScale;
-
-  vec2 alignedPosition = position * scale;
-
-  vec2 rotatedPosition;
-  rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
-  rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
-
-  vec4 finalPosition;
-
-  finalPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
-  finalPosition.xy += rotatedPosition;
-  finalPosition = projectionMatrix * finalPosition;
-
-  gl_Position = finalPosition;
-}

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

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

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

@@ -1,20 +0,0 @@
-module Mittsu
-  class CompressedTexture
-    def update_specific
-      gl_format = GL_MITTSU_PARAMS[format]
-      gl_type = GL_MITTSU_PARAMS[type]
-
-      mipmaps.each_with_index do |mipmap, i|
-        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::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)
-        end
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-module Mittsu
-  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, image[:_opengl_texture_cube])
-
-          # glPixelStorei(GL_UNPACK_FLIP_Y_WEBGL, texture.flip_y)
-
-          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(image[i], @_max_cubemap_size)
-            else
-              cube_image[i] = is_data_texture ? image[i].image : image[i];
-            end
-          end
-
-          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)
-
-          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 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
-                    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 generate_mipmaps && is_image_power_of_two
-            glGenerateMipmap(GL_TEXTURE_CUBE_MAP)
-          end
-
-          self.needs_update = false
-
-          on_update.call if on_update
-        else
-          glActiveTexture(GL_TEXTURE0 + slot)
-          glBindTexture(GL_TEXTURE_CUBE_MAP, image[:_opengl_texture_cube])
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Mittsu
-  class DataTexture
-    def update_specific
-      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
-      # 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/texture.rb

@@ -1,107 +0,0 @@
-module Mittsu
-  class Texture
-    attr_reader :opengl_texture
-
-    def set(slot, renderer)
-      @renderer = renderer
-
-      glActiveTexture(GL_TEXTURE0 + slot)
-
-      if needs_update?
-        update_opengl(@renderer)
-      else
-        glBindTexture(GL_TEXTURE_2D, @opengl_texture)
-      end
-    end
-
-    def update_opengl(renderer)
-      @renderer = renderer
-
-      if !@initted
-        @initted = true
-        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, flip_y) ???
-      # glPixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL, premultiply_alpha) ???
-      glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment)
-
-      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)
-
-      set_parameters(GL_TEXTURE_2D, is_image_power_of_two)
-
-      update_specific
-
-      if generate_mipmaps && is_image_power_of_two
-        glGenerateMipmap(GL_TEXTURE_2D)
-      end
-
-      self.needs_update = false
-
-      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[wrap_s])
-        glTexParameteri(texture_type, GL_TEXTURE_WRAP_T, GL_MITTSU_PARAMS[wrap_t])
-
-        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 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. (#{source_file})"
-        end
-
-        glTexParameteri(texture_type, GL_TEXTURE_MAG_FILTER, filter_fallback(mag_filter))
-        glTexParameteri(texture_type, GL_TEXTURE_MIN_FILTER, filter_fallback(min_filter))
-
-        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. (#{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 || filter == NearestMipMapLinearFilter
-  			GL_NEAREST
-  		end
-
-      GL_LINEAR
-  	end
-
-    def update_specific
-      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
-      # 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
-
-        self.generate_mipmaps = false
-      else
-        glTexImage2D(GL_TEXTURE_2D, 0, gl_format, image.width, image.height, 0, gl_format, gl_type, image.data)
-      end
-    end
-  end
-end