mittsu-opengl 0.5.0

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

@@ -0,0 +1,416 @@
+require 'mittsu/math'
+
+module Mittsu
+  class ShadowMapPlugin
+    def initialize(renderer, lights, opengl_objects, opengl_objects_immediate)
+      @renderer, @lights = renderer, lights
+      @opengl_objects = opengl_objects
+      @opengl_objects_immediate = opengl_objects_immediate
+
+      @frustum = Frustum.new
+      @proj_screen_matrix = Matrix4.new
+
+      @min = Vector3.new
+      @max = Vector3.new
+
+      @matrix_position = Vector3.new
+
+      @render_list = []
+
+      depth_shader = OpenGL::Shader::Lib[:depth_rgba]
+      depth_uniforms = OpenGL::Shader::UniformsUtils.clone(depth_shader.uniforms)
+
+      @depth_material = ShaderMaterial.new(
+        uniforms: depth_uniforms,
+        vertex_shader: depth_shader.vertex_shader,
+        fragment_shader: depth_shader.fragment_shader
+      )
+
+      @depth_material_morph = ShaderMaterial.new(
+        uniforms: depth_uniforms,
+        vertex_shader: depth_shader.vertex_shader,
+        fragment_shader: depth_shader.fragment_shader,
+        morph_targets: true
+      )
+
+      @depth_material_skin = ShaderMaterial.new(
+        uniforms: depth_uniforms,
+        vertex_shader: depth_shader.vertex_shader,
+        fragment_shader: depth_shader.fragment_shader,
+        skinning: true
+      )
+
+      @depth_material_morph_skin = ShaderMaterial.new(
+        uniforms: depth_uniforms,
+        vertex_shader: depth_shader.vertex_shader,
+        fragment_shader: depth_shader.fragment_shader,
+        morph_targets: true,
+        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
+    end
+
+    def render(scene, camera)
+      return unless @renderer.shadow_map_enabled
+
+      lights = []
+      fog = nil
+
+      # set GL state for depth map
+
+      GL.ClearColor(1.0, 1.0, 1.0, 1.0)
+      GL.Disable(GL::BLEND)
+
+      GL.Enable(GL::CULL_FACE)
+      GL.FrontFace(GL::CCW)
+
+      if @renderer.shadow_map_cull_face = CullFaceFront
+        GL.CullFace(GL::FRONT)
+      else
+        GL.CullFace(GL::BACK)
+      end
+
+      @renderer.state.set_depth_test(true)
+
+      # process lights
+      #  - skip lights that are not casting shadows
+      #  - create virtual lights for cascaded shadow maps
+
+      @lights.select(&:cast_shadow).each do |light|
+        if light.is_a?(DirectionalLight) && light.shadow_cascade
+          light.shadow_cascade_count.times do |n|
+            if !light.shadow_cascade_array[n]
+              virtual_light = create_virtual_light(light, n)
+              virtual_light.original_camera = camera
+
+              gyro = Gyroscope.new
+              gyro.position.copy(light.shadow_cascade_offset)
+
+              gyro.add(virtual_light)
+              gyro.add(virtual_light.target)
+
+              camera.add(gyro)
+
+              light.shadow_cascade_array[n] = virtual_light
+            else
+              virtual_light = light.shadow_cascade_array[n]
+            end
+
+            update_virtual_light(light, n)
+
+            lights << virtual_light
+          end
+        else
+          lights << light
+        end
+      end
+
+      # render depth map
+
+      lights.each do |light|
+        if !light.shadow_map
+          shadow_filter = LinearFilter
+          if @renderer.shadow_map_type == PCFSoftShadowMap
+            shadow_filter = NearestFilter
+          end
+
+          pars = { min_filter: shadow_filter, mag_filter: shadow_filter, format: RGBAFormat }
+
+          light.shadow_map = RenderTarget.new(light.shadow_map_width, light.shadow_map_height, pars)
+          light.shadow_map.renderer = @renderer
+          light.shadow_map_size = Vector2.new(light.shadow_map_width, light.shadow_map_height)
+
+          light.shadow_matrix = Matrix4.new
+        end
+
+        if !light.shadow_camera
+          case light
+          when SpotLight
+            light.shadow_camera = PerspectiveCamera.new(light.shadow_camera_fov, light.shadow_map_width / light.shadow_map_height, light.shadow_camera_near, light.shadow_camera_far)
+          when DirectionalLight
+            light.shadow_camera = OrthographicCamera.new(light.shadow_camera_left, light.shadow_camera_right, light.shadow_camera_top, light.shadow_camera_bottom, light.shadow_camera_near, light.shadow_camera_far)
+          else
+            puts "ERROR: Mittsu::ShadowMapPlugin: Unsupported light type for shadow #{light.inspect}"
+            next
+          end
+
+          scene.add(light.shadow_camera)
+          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)
+        end
+
+        if light.virtual? && virtual_light.original_camera == camera
+          update_shadow_camera(camera, light)
+        end
+
+        shadow_map = light.shadow_map
+        shadow_matrix = light.shadow_matrix
+        shadow_camera = light.shadow_camera
+
+        #
+
+        shadow_camera.position.set_from_matrix_position(light.matrix_world)
+        @matrix_position.set_from_matrix_position(light.target.matrix_world)
+        shadow_camera.look_at(@matrix_position)
+        shadow_camera.update_matrix_world
+
+        shadow_camera.matrix_world_inverse.inverse(shadow_camera.matrix_world)
+
+        #
+
+
+        light.camera_helper.visible = light.shadow_camera_visible if light.camera_helper
+        light.camera_helper.update_points if light.shadow_camera_visible
+
+        # compute shadow matrix
+
+        shadow_matrix.set(
+          0.5, 0.0, 0.0, 0.5,
+          0.0, 0.5, 0.0, 0.5,
+          0.0, 0.0, 0.5, 0.5,
+          0.0, 0.0, 0.0, 1.0
+        )
+
+        shadow_matrix.multiply(shadow_camera.projection_matrix)
+        shadow_matrix.multiply(shadow_camera.matrix_world_inverse)
+
+        # update camera matrices and frustum
+
+        @proj_screen_matrix.multiply_matrices(shadow_camera.projection_matrix, shadow_camera.matrix_world_inverse)
+        @frustum.set_from_matrix(@proj_screen_matrix)
+
+        # render shadow map
+
+        @renderer.set_render_target(shadow_map)
+        @renderer.clear
+
+        # set object matrices & frustum culling
+
+        @render_list.clear
+
+        project_object(scene, scene, shadow_camera)
+
+        # render regular obejcts
+
+        @render_list.each do |opengl_object|
+          object = opengl_object[:object]
+          buffer = opengl_object[:buffer]
+
+          # culling is overridden globally for all objects
+          # while rendering depth map
+
+          # need to deal with MeshFaceMaterial somehow
+          # in that case just use the first of material.materials for now
+          # (proper solution would require to break objects by materials
+          #  similarly to regular rendering and then set corresponding
+          #  depth materials per each chunk instead of just once per object)
+
+          object_material = get_object_material(object)
+
+          # TODO: SkinnedMesh/morph_targets
+          # use_morphing = !object.geometry.morph_targets.nil? && !object.geometry.morph_targets.empty?
+          # use_skinning = object.is_a?(SkinnedMesh) && object_material.skinning
+
+          # TODO: SkinnedMesh/morph_targets
+          # if object.custom_depth_material
+          #   material = object.custom_depth_material
+          # elsif use_skinning
+          #   material = use_morphing ? @depth_material_morph_skin : @depth_material_skin
+          # elsif use_morphing
+          #   material = @deptth_material_morph
+          # else
+            material = @depth_material
+          # end
+
+          @renderer.set_material_faces(object_material)
+
+          if buffer.is_a?(BufferGeometry)
+            @renderer.render_buffer_direct(shadow_camera, @lights, fog, material, buffer, object)
+          else
+            @renderer.render_buffer(shadow_camera, @lights, fog, material, buffer, object)
+          end
+        end
+
+        # set materices and rendr immeidate objects
+
+        @opengl_objects_immediate.each do |opengl_object_immediate|
+          opengl_object = opengl_object_immediate
+          object = opengl_object[:object]
+
+          if object.visible && object.cast_shadow
+            object[:_model_view_matrix].multiply_matrices(shadow_camera.matrix_womatrix_world_inverse, object.matrix_world)
+            @renderer.render_immediate_object(shadow_camera, @lights, fog, @depth_material, object)
+          end
+        end
+      end
+
+      # restore GL state
+
+      clear_color = @renderer.get_clear_color
+      clear_alpha = @renderer.get_clear_alpha
+
+      GL.ClearColor(clear_color.r, clear_color.g, clear_color.b, clear_alpha)
+      GL.Enable(GL::BLEND)
+
+      if @renderer.shadow_map_cull_face == CullFaceFront
+        GL.CullFace(GL::BACK)
+      end
+
+      @renderer.reset_gl_state
+    end
+
+    def project_object(scene, object, shadow_camera)
+      if object.visible
+        opengl_objects = @opengl_objects[object.id]
+
+        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)
+            @render_list << opengl_object
+          end
+        end
+
+        object.children.each do |child|
+          project_object(scene, child, shadow_camera)
+        end
+      end
+    end
+
+    def create_virtual_light(light, cascade)
+      DirectionalLight.new.tap do |virtual_light|
+        virtual_light.is_virtual = true
+
+        virtual_light.only_shadow = true
+        virtual_light.cast_shadow = true
+
+        virtual_light.shadow_camera_near = light.shadow_camera_near
+        virtual_light.shadow_camera_far = light.shadow_camera_far
+
+        virtual_light.shadow_camera_left = light.shadow_camera_left
+        virtual_light.shadow_camera_right = light.shadow_camera_right
+        virtual_light.shadow_camera_bottom = light.shadow_camera_bottom
+        virtual_light.shadow_camera_top = light.shadow_camera_top
+
+        virtual_light.shadow_camera_visible = light.shadow_camera_visible
+
+        virtual_light.shadow_darkness = light.shadow_darkness
+
+        virtual_light.shadow_darkness = light.shadow_darkness
+
+        virtual_light.shadow_bias = light.shadow_cascade_bias[cascade]
+        virtual_light.shadow_map_width = light.shadow_cascade_width[cascade]
+        virtual_light.shadow_map_height = light.shadow_cascade_height[cascade]
+
+        points_world = virtual_light.points_world = []
+        points_frustum = virtual_light.points_frustum = []
+
+        8.times do
+          points_world << Vector3.new
+          points_frustum << Vector3.new
+        end
+
+        near_z = light.shadow_cascade_near_z[cascade]
+        far_z = light.shadow_cascade_far_z[cascade]
+
+        points_frustum[0].set(-1.0, -1.0, near_z)
+        points_frustum[1].set( 1.0, -1.0, near_z)
+        points_frustum[2].set(-1.0,  1.0, near_z)
+        points_frustum[3].set( 1.0,  1.0, near_z)
+
+        points_frustum[4].set(-1.0, -1.0, far_z)
+        points_frustum[5].set( 1.0, -1.0, far_z)
+        points_frustum[6].set(-1.0,  1.0, far_z)
+        points_frustum[7].set( 1.0,  1.0, far_z)
+      end
+    end
+
+    # synchronize virtual light with the original light
+
+    def update_virtual_light(light, cascade)
+      virtual_light = light.shadow_cascade_array[cascade]
+
+      virtual_light.position.copy(light.position)
+      virtual_light.target.position.copy(light.target.position)
+      virtual_light.look_at(virtual_light.target)
+
+      virtual_light.shadow_camera_visible = light.shadow_camera_visible
+      virtual_light.shadow_darkness = light.shadow_darkness
+
+      virtual_light.shadow_bias = light.shadow_cascade_bias[cascade]
+
+      near_z = light.shadow_cascade_near_z[cascade]
+      far_z = light.shadow_cascade_far_z[cascade]
+
+      points_frustum = virtual_light.points_frustum
+
+      points_frustum[0].z = near_z
+      points_frustum[1].z = near_z
+      points_frustum[2].z = near_z
+      points_frustum[3].z = near_z
+
+      points_frustum[4].z = far_z
+      points_frustum[5].z = far_z
+      points_frustum[6].z = far_z
+      points_frustum[7].z = far_z
+    end
+
+    # fit shadow camera's ortho frustum to camera frustum
+
+    def update_shadow_camera(camera, light)
+      shadow_camera = light.shadow_camera
+      points_frustum = light.pointa_frustum
+      points_world = light.points_world
+
+      @min.set(Float::INFINITY, Float::INFINITY, Float::INFINITY)
+      @max.set(-Float::INFINITY, -Float::INFINITY, -Float::INFINITY)
+
+      8.times do |i|
+        p = points_world[i]
+
+        p.copy(points_frustum[i])
+        p.unproject(camera)
+
+        p.apply_matrix4(shadow_camera.matrix_world_inverse)
+
+        @min.x = p.x if (p.x < @min.x)
+        @max.x = p.x if (p.x > @max.x)
+
+        @min.y = p.y if (p.y < @min.y)
+        @max.y = p.y if (p.y > @max.y)
+
+        @min.z = p.z if (p.z < @min.z)
+        @max.z = p.z if (p.z > @max.z)
+      end
+
+      shadow_camera.left = @min.x
+      shadow_camera.right = @max.x
+      shadow_camera.top = @max.y
+      shadow_camera.bottom = @min.y
+
+      # can't really fit near/far
+      # shadow_camera.near = @min.x
+      # shadow_camera.far = @max.z
+
+      shadow_camera.update_projection_matrix
+    end
+
+    # For the moment just ignore objects that have multiple materials with different animation methods
+    # Only the frst material will be taken into account for deciding which depth material to use for shadow maps
+
+    def get_object_material(object)
+      if object.material.is_a?(MeshFaceMaterial)
+        object.material.materials[0]
+      else
+        object.material
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+#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/opengl/plugins/sprite_plugin.rb

@@ -0,0 +1,250 @@
+module Mittsu
+  class SpritePlugin
+    include OpenGL::Helper
+
+    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)
+
+      GL.Enable(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 = GL.CreateVertexArray
+      GL.BindVertexArray(@vertex_array_object)
+
+      @vertex_buffer = GL.CreateBuffer
+      @element_buffer = GL.CreateBuffer
+
+      GL.BindBuffer(GL::ARRAY_BUFFER, @vertex_buffer)
+      GL.BufferData_easy(GL::ARRAY_BUFFER, VERTICES, GL::STATIC_DRAW)
+
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @element_buffer)
+      GL.BufferData_easy(GL::ELEMENT_ARRAY_BUFFER, FACES, GL::STATIC_DRAW)
+    end
+
+    def create_program
+      @program = GL.CreateProgram
+
+      vertex_shader = OpenGL::Shader.new(GL::VERTEX_SHADER, File.read(File.join(__dir__, 'sprite_vertex.glsl')))
+      fragment_shader = OpenGL::Shader.new(GL::FRAGMENT_SHADER, File.read(File.join(__dir__, 'sprite_fragment.glsl')))
+
+      GL.AttachShader(@program, vertex_shader.shader)
+      GL.AttachShader(@program, fragment_shader.shader)
+
+      GL.LinkProgram(@program)
+    end
+
+    def init_attributes
+      @attributes = {
+        position: GL.GetAttribLocation(@program, 'position'),
+        uv: GL.GetAttribLocation(@program, 'uv')
+      }
+    end
+
+    def init_uniforms
+      @uniforms = {
+        uvOffset: GL.GetUniformLocation(@program, 'uvOffset'),
+        uvScale: GL.GetUniformLocation(@program, 'uvScale'),
+
+        rotation: GL.GetUniformLocation(@program, 'rotation'),
+        scale: GL.GetUniformLocation(@program, 'scale'),
+
+        color: GL.GetUniformLocation(@program, 'color'),
+        map: GL.GetUniformLocation(@program, 'map'),
+        opacity: GL.GetUniformLocation(@program, 'opacity'),
+
+        modelViewMatrix: GL.GetUniformLocation(@program, 'modelViewMatrix'),
+        projectionMatrix: GL.GetUniformLocation(@program, 'projectionMatrix'),
+
+        fogType: GL.GetUniformLocation(@program, 'fogType'),
+        fogDensity: GL.GetUniformLocation(@program, 'fogDensity'),
+        fogNear: GL.GetUniformLocation(@program, 'fogNear'),
+        fogFar: GL.GetUniformLocation(@program, 'fogFar'),
+        fogColor: GL.GetUniformLocation(@program, 'fogColor'),
+
+        alphaTest: GL.GetUniformLocation(@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)
+      GL.UseProgram(@program)
+
+      GL.Disable(GL::CULL_FACE)
+      GL.Enable(GL::BLEND)
+
+      GL.BindVertexArray(@vertex_array_object)
+
+      GL.EnableVertexAttribArray(@attributes[:position])
+      GL.EnableVertexAttribArray(@attributes[:uv])
+
+      GL.BindBuffer(GL::ARRAY_BUFFER, @vertex_buffer)
+
+      GL.VertexAttribPointer(@attributes[:position], 2, GL::FLOAT, GL::FALSE, 2 * 8, 0)
+      GL.VertexAttribPointer(@attributes[:uv], 2, GL::FLOAT, GL::FALSE, 2 * 8, 8)
+
+      GL.BindBuffer(GL::ELEMENT_ARRAY_BUFFER, @element_buffer)
+
+      GL.UniformMatrix4fv(@uniforms[:projectionMatrix], 1, GL::FALSE, array_to_ptr_easy(camera.projection_matrix.elements))
+
+      GL.ActiveTexture(GL::TEXTURE0)
+      GL.Uniform1i(@uniforms[:map], 0)
+    end
+
+    def setup_fog(scene)
+      @old_fog_type = 0
+      @scene_fog_type = 0
+      fog = scene.fog
+
+      if fog
+        GL.Uniform3f(@uniforms[:fogColor], fog.color.r, fog.color.g, fog.color.b)
+
+        if fog.is_a?(Fog)
+          GL.Uniform1f(@uniforms[:fogNear], fog.near)
+          GL.Uniform1f(@uniforms[:fogFar], fog.far)
+
+          GL.Uniform1i(@uniforms[:fogType], 1)
+          @old_fog_type = 1
+          @scene_fog_type = 1
+        elsif fog.is_a?(FogExp2)
+          GL.Uniform1f(@uniforms[:fogDensity], fog.density)
+
+          GL.Uniform1i(@uniforms[:fogType], 2)
+          @old_fog_type = 2
+          @scene_fog_type = 2
+        end
+      else
+        GL.Uniform1i(@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
+        GL.DrawElements(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
+        GL.Uniform1(@uniforms[:fogType], fog_type)
+        @old_fog_type = fog_type
+      end
+    end
+
+    def set_uv_uniforms(material)
+      if !material.map.nil?
+        GL.Uniform2f(@uniforms[:uvOffset], material.map.offset.x, material.map.offset.y)
+        GL.Uniform2f(@uniforms[:uvScale], material.map.repeat.x, material.map.repeat.y)
+      else
+        GL.Uniform2f(@uniforms[:uvOffset], 0.0, 0.0)
+        GL.Uniform2f(@uniforms[:uvScale], 1.0, 1.0)
+      end
+    end
+
+    def set_color_uniforms(material)
+      GL.Uniform1f(@uniforms[:opacity], material.opacity)
+      GL.Uniform3f(@uniforms[:color], material.color.r, material.color.g, material.color.b)
+      GL.Uniform1f(@uniforms[:alphaTest], material.alpha_test)
+    end
+
+    def set_transform_uniforms(sprite)
+      GL.UniformMatrix4fv(@uniforms[:modelViewMatrix], 1, GL::FALSE, array_to_ptr_easy(sprite.model_view_matrix.elements))
+
+      sprite.matrix_world.decompose(@sprite_position, @sprite_rotation, @sprite_scale)
+
+      GL.Uniform1f(@uniforms[:rotation], sprite.material.rotation)
+      GL.Uniform2fv(@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