mittsu 0.4.0 → 0.5.0

data/lib/mittsu/renderers/opengl_renderer.rb

@@ -1,1028 +0,0 @@
-require 'opengl'
-require 'glfw'
-require 'fiddle'
-
-require 'mittsu/renderers/opengl/opengl_lib'
-opengl_lib = Mittsu::OpenGLLib.discover
-OpenGL.load_lib(ENV["MITTSU_LIBGL_FILE"] || opengl_lib.file, ENV["MITTSU_LIBGL_PATH"] || opengl_lib.path)
-
-require 'mittsu/renderers/glfw_window'
-require 'mittsu/renderers/opengl/opengl_implementations'
-require 'mittsu/renderers/opengl/opengl_debug'
-require 'mittsu/renderers/opengl/opengl_helper'
-require 'mittsu/renderers/opengl/opengl_program'
-require 'mittsu/renderers/opengl/opengl_state'
-require 'mittsu/renderers/opengl/opengl_geometry_group'
-require 'mittsu/renderers/opengl/opengl_light_renderer'
-require 'mittsu/renderers/opengl/opengl_default_target'
-require 'mittsu/renderers/opengl/opengl_buffer'
-require 'mittsu/renderers/opengl/plugins/shadow_map_plugin'
-require 'mittsu/renderers/opengl/plugins/sprite_plugin'
-require 'mittsu/renderers/shaders/shader_lib'
-require 'mittsu/renderers/shaders/uniforms_utils'
-
-include ENV['DEBUG'] ? OpenGLDebug : OpenGL
-include Mittsu::OpenGLHelper
-
-require 'mittsu/renderers/opengl/opengl_mittsu_params'
-
-module Mittsu
-  class OpenGLRenderer
-    attr_accessor :auto_clear, :auto_clear_color, :auto_clear_depth, :auto_clear_stencil, :sort_objects, :gamma_factor, :gamma_input,
-      :gamma_output, :shadow_map_enabled, :shadow_map_type, :shadow_map_cull_face, :shadow_map_debug, :shadow_map_cascade,
-      :max_morph_targets, :max_morph_normals, :info, :pixel_ratio, :window, :width, :height, :state
-
-    attr_reader :logarithmic_depth_buffer, :programs, :light_renderer, :proj_screen_matrix
-
-    def initialize(parameters = {})
-      puts "Mittsu OpenGL Renderer #{VERSION}"
-
-      fetch_parameters(parameters)
-
-      @pixel_ratio = 1.0
-      @sort_objects = true
-
-      init_collections
-      init_clearing
-      init_gamma
-      init_shadow_properties
-      init_morphs
-      init_info
-      init_state_cache
-      init_camera_matrix_cache
-
-      @light_renderer = OpenGLLightRenderer.new(self)
-
-      create_window
-
-      @state = OpenGLState.new
-
-      # TODO: load extensions??
-
-      reset_gl_state
-      set_default_gl_state
-
-      get_gpu_capabilities
-
-      init_plugins
-    end
-
-    def supports_bone_textures?
-      @_supports_bone_textures
-    end
-
-    def supports_vertex_textures?
-      @_supports_vertex_textures
-    end
-
-    def shadow_map_enabled?
-      @shadow_map_enabled
-    end
-
-    # TODO: get_context ???
-    # TODO: force_context_loss ???
-    # TODO: supports_float_textures? ???
-    # TODO: supports[half|standard|compressed|blend min max] ... ???
-
-    def max_anisotropy
-      @_max_anisotropy ||= nil
-      # TODO: get max anisotropy ????
-    end
-
-    def set_size(width, height)
-      @width, @height = width, height
-      self.set_viewport(0, 0, width, height)
-    end
-
-    def set_viewport(x, y, width, height)
-      default_target.set_and_use_viewport(
-        x * pixel_ratio,
-        y * pixel_ratio,
-        width * pixel_ratio,
-        height * pixel_ratio
-      )
-    end
-
-    def set_scissor(x, y, width, height)
-      glScissor(
-        x * pixel_ratio,
-        y * pixel_ratio,
-        width * pixel_ratio,
-        height * pixel_ratio
-      )
-    end
-
-    def enable_scissor_test(enable)
-      enable ? glEnable(GL_SCISSOR_TEST) : glDisable(GL_SCISSOR_TEST)
-    end
-
-    def object_in_frustum?(object)
-      @_frustum.intersects_object?(object)
-    end
-
-    def sort_objects?
-      @sort_objects
-    end
-
-    # clearing
-
-    def get_clear_color
-      @_clear_color
-    end
-
-    def set_clear_color(color, alpha = 1.0)
-      @_clear_color.set(color)
-      @_clear_alpha = alpha
-      clear_color(@_clear_color.r, @_clear_color.g, @_clear_color.b, @_clear_alpha)
-    end
-
-    def get_clear_alpha
-      @_clear_alpha
-    end
-
-    def set_clear_alpha(alpha)
-      @_clear_alpha = alpha
-      clear_color(@_clear_color.r, @_clear_color.g, @_clear_color.b, @_clear_alpha)
-    end
-
-    def clear(color = true, depth = true, stencil = true)
-      bits = 0
-
-      bits |= GL_COLOR_BUFFER_BIT if color
-      bits |= GL_DEPTH_BUFFER_BIT if depth
-      bits |= GL_STENCIL_BUFFER_BIT if stencil
-
-      glClear(bits)
-    end
-
-    def clear_depth
-      glClear(GL_DEPTH_BUFFER_BIT)
-    end
-
-    def clear_stencil
-      glClear(GL_STENCIL_BUFFER_BIT)
-    end
-
-    def clear_target(render_target, color, depth, stencil)
-      set_render_target(render_target)
-      clear(color, depth, stencil)
-    end
-
-    def reset_gl_state
-      @_current_program = nil
-      @_current_camera = nil
-
-      @_current_geometry_program = ''
-      @_current_material_id = -1
-
-      @light_renderer.reset
-
-      @state.reset
-    end
-
-    def set_render_target(render_target = default_target)
-      # TODO: when OpenGLRenderTargetCube exists
-      # is_cube = render_target.is_a? OpenGLRenderTargetCube
-
-      # TODO framebuffer logic for render target cube
-      render_target.setup_buffers
-
-      if render_target != @_current_render_target
-        render_target.use
-        @_current_render_target = render_target
-      end
-    end
-
-    def render(scene, camera, render_target = default_target, force_clear = false)
-      raise "ERROR: Mittsu::OpenGLRenderer#render: camera is not an instance of Mittsu::Camera" unless camera.is_a?(Camera)
-
-      reset_cache_for_this_frame
-
-      scene.update_matrix_world if scene.auto_update
-      camera.update_matrix_world if camera.parent.nil?
-
-      update_skeleton_objects(scene)
-
-      update_screen_projection(camera)
-      scene.project(self)
-      sort_objects_for_render if @sort_objects
-
-      render_custom_plugins_pre_pass(scene, camera)
-
-      set_matrices_for_immediate_objects(camera)
-
-      set_render_target(render_target)
-      perform_auto_clear if @auto_clear || force_clear
-      render_main_pass(scene, camera)
-
-      render_custom_plugins_post_pass(scene, camera)
-
-      render_target.update_mipmap
-
-      ensure_depth_buffer_writing
-    end
-
-    def set_material_faces(material)
-      @state.set_double_sided(material.side == DoubleSide)
-      @state.set_flip_sided(material.side == BackSide)
-    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)
-
-      program = set_program(camera, lights, fog, material, object)
-      attributes = program.attributes
-      buffers_need_update = switch_geometry_program(program, material, geometry_group)
-
-      @state.init_attributes if buffers_need_update
-
-      if !material.morph_targets && attributes['position'] && attributes['position'] >= 0
-        geometry_group.update_vertex_buffer(attributes['position']) if buffers_need_update
-      elsif object.morph_target_base
-        # TODO: when morphing is implemented
-        # setup_morph_targets(material, geometry_group, object)
-      end
-
-      if buffers_need_update
-        geometry_group.update_other_buffers(object, material, attributes)
-      end
-
-      @state.disable_unused_attributes
-
-      object.render_buffer(camera, lights, fog, material, geometry_group, buffers_need_update)
-    end
-
-    def compressed_texture_formats
-      # TODO: needs extensions.get ...
-
-      @_compressed_texture_formats ||= []
-    end
-
-    # Events
-
-    def on_object_removed(event)
-      object = event.target
-      object.traverse do |child|
-        child.remove_event_listener(:remove, method(:on_object_removed))
-        remove_child(child)
-      end
-    end
-
-    def on_geometry_dispose(event)
-      geometry = event.target
-      geometry.remove_event_listener(:dispose, method(:on_geometry_dispose))
-      deallocate_geometry(geometry)
-    end
-
-    def on_texture_dispose(event)
-      texture = event.target
-      texture.remove_event_listener(:dispose, method(:on_texture_dispose))
-      deallocate_texture(texture)
-      @info[:memory][:textures] -= 1
-    end
-
-    def on_render_target_dispose(event)
-      render_target = event.target
-      render_target.remove_event_listener(:dispose, method(:on_render_target_dispose))
-      deallocate_render_target(render_target)
-      @info[:memory][:textures] -= 1
-    end
-
-    def on_material_dispose(event)
-      material = event.target
-      material.remove_event_listener(:dispose, method(:on_material_dispose))
-      deallocate_material(material)
-    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
-        # TODO: scale the image ...
-
-        puts "WARNING: Mittsu::OpenGLRenderer: image is too big (#{width} x #{height}). Resized to #{@_max_texture_size} x #{@_max_texture_size}"
-      end
-      image
-    end
-
-    def add_opengl_object(buffer, object)
-      add_buffer(@_opengl_objects, buffer, object)
-    end
-
-    def remove_opengl_object(object)
-      @_opengl_objects.delete(object.id)
-    end
-
-    private
-
-    def clear_color(r, g, b, a)
-      if (@_premultiplied_alpha)
-        r *= a; g *= a; b *= a
-      end
-
-      glClearColor(r, g, b, a)
-    end
-
-    def set_default_gl_state
-      glClearColor(0.0, 0.0, 0.0, 1.0)
-      glClearDepth(1)
-      glClearStencil(0)
-
-      glEnable(GL_DEPTH_TEST)
-      glDepthFunc(GL_LEQUAL)
-
-      glFrontFace(GL_CCW)
-      glCullFace(GL_BACK)
-      glEnable(GL_CULL_FACE)
-
-      glEnable(GL_BLEND)
-      glBlendEquation(GL_FUNC_ADD)
-      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
-
-      default_target.use_viewport
-
-      clear_color(@_clear_color.r, @_clear_color.g, @_clear_color.b, @_clear_alpha)
-    end
-
-    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.setup_matrices(camera)
-
-        if override_material
-          material = override_material
-        else
-          material = opengl_object.material
-          next unless material
-          material.set(self)
-        end
-
-        set_material_faces(material)
-        if buffer.is_a? BufferGeometry
-          # TODO
-          # render_buffer_direct(camera, lights, fog, material, buffer, object)
-        else
-          puts "-- RENDER COLOR #{material.color}" if DEBUG
-          render_buffer(camera, lights, fog, material, buffer, object)
-        end
-      end
-    end
-
-    def render_objects_immediate(render_list, material_type, camera, lights, fog, override_material)
-      material = nil
-      render_list.each do |opengl_object|
-        object = opengl_object.object
-        if object.visible
-          if override_material
-            material = override_material
-          else
-            material = case material_type
-            when :transparent then opengl_object.transparent
-            when :opaque then opengl_object.opaque
-            else nil
-            end
-            next unless material
-            material.set(self)
-          end
-          render_immediate_object(camera, lights, fog, material, object)
-        end
-      end
-    end
-
-    def add_buffer(objlist, buffer, object)
-      id = object.id
-      (objlist[id] ||= []) << OpenGLBuffer.new(
-        buffer, object, nil, 0
-      )
-    end
-
-    def unroll_immediate_buffer_material(opengl_object)
-  		object = opengl_object.object
-  		material = object.material
-
-  		if material.transparent
-  			opengl_object.transparent
-  			opengl_object.opaque = nil
-  		else
-  			opengl_object.opaque = material
-  			opengl_object.transparent = nil
-  		end
-    end
-
-    def unroll_buffer_material(opengl_object)
-      object = opengl_object.object
-      buffer = opengl_object.buffer
-
-      geometry = object.geometry
-      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]
-        end
-
-        opengl_object.material = material
-
-        if material.transparent
-          @transparent_objects << opengl_object
-        else
-          @opaque_objects << opengl_object
-        end
-      end
-    end
-
-    # FIXME: refactor
-    def update_object(object)
-      geometry = object.geometry
-
-      if geometry.is_a? BufferGeometry
-        # TODO: geometry vertex array ?????
-        # glBindVertexArray geometry.vertex_array
-
-        geometry.attributes.each do |(key, attribute)|
-          buffer_type = (key == 'index') ? GL_ELEMENT_ARRAY_BUFFER : GL_ARRAY_BUFFER
-
-          if attribute.buffer.nil?
-            attribute.buffer = glCreateBuffer
-            glBindBuffer(buffer_type, attribute.buffer)
-            glBufferData_easy(buffer_type, attribute.array, (attribute.is_a? DynamicBufferAttribute) ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW)
-
-            attribute.needs_update = false
-          elsif attribute.needs_update
-            glBindBuffer(buffer_type, attribute.buffer)
-            if attribute.update_range.nil? || attribute.update_range.count == -1 # Not using update ranged
-              glBufferSubData(buffer_type, 0, attribute.array)
-            elsif attribute.udpate_range.count.zero?
-              puts 'ERROR: Mittsu::OpenGLRenderer#update_object: using update_range for Mittsu::DynamicBufferAttribute and marked as needs_update but count is 0, ensure you are using set methods or updating manually.'
-            else
-              # TODO: make a glBufferSubData_easy method
-              glBufferSubData(buffer_type, attribute.update_range.offset * attribute.array.BYTES_PER_ELEMENT, attribute.array.subarray(attribute.update_range.offset, attribute.update_range.offset + attribute.update_range.count))
-              attribute.update_range.count = 0 # reset range
-            end
-
-            attribute.needs_update = false
-          end
-        end
-      else
-        object.update
-      end
-    end
-
-    # FIXME: refactor
-    def set_program(camera, lights, fog, material, object)
-      @_used_texture_units = 0
-      if material.needs_update?
-        deallocate_material(material) if material.program
-
-        material.init(lights, fog, object, self)
-        material.needs_update = false
-      end
-
-      if material.morph_targets
-        if !object.morph_target_influences
-          object.morph_target_influences = Array.new(@max_morph_targets) # Float32Array
-        end
-      end
-
-      refresh_program = false
-      refresh_material = false
-      refresh_lights = false
-
-      program = material.program
-      program_uniforms = program.uniforms
-      material_uniforms = material.shader[:uniforms]
-
-      if program.id != @_current_program
-        glUseProgram(program.program)
-        @_current_program = program.id
-
-        refresh_program = true
-        refresh_material = true
-        refresh_lights = true
-      end
-
-      if material.id != @_current_material_id
-        refresh_lights = true if @_current_material_id == -1
-        @_current_material_id = material.id
-
-        refresh_material = true
-      end
-
-      if refresh_program || camera != @_current_camera
-        @_current_camera = camera
-        update_camera_uniforms(program_uniforms, camera, material)
-      end
-
-      if material.skinning
-        # TODO: when skinning is implemented. Then also refactor
-        # if object.bind_matrix && !program_uniforms['bindMatrix'].nil?
-        #   glUniformMatrix4fv(program_uniforms['bindMatrix'], GL_FALSE, object.bind_matrix.elements)
-        # end
-        #
-        # if object.bind_matrix_inverse && !program_uniforms['bindMatrixInverse'].nil?
-        #   glUniformMatrix4fv(program_uniforms['bindMatrixInverse'], GL_FALSE, object.bind_matrix_inverse.elements)
-        # end
-        #
-        # if @_supports_bone_textures && object.skeleton && object.skeleton.use_vertex_texture
-        #   if !program_uniforms['boneTexture'].nil?
-        #     texture_unit = get_texture_unit
-        #
-        #     glUniform1i(program_uniforms['boneTexture'], texture_unit)
-        #     object.skeleton.bone_texture.set(texture_unit, self)
-        #   end
-        #
-        #   if !program_uniforms['boneTextureWidth'].nil?
-        #     glUniform1i(program_uniforms['boneTextureWidth'], object.skeleton.bone_texture_width)
-        #   end
-        #
-        #   if !program_uniforms['boneTextureHeight'].nil?
-        #     glUniform1i(program_uniforms['boneTextureHeight'], object.skeleton.bone_texture_height)
-        #   end
-        # elsif object.skeleton && object.skeleton.bone_matrices
-        #   if !program_uniforms['boneGlobalMatrices'].nil?
-        #     glUniformMatrix4fv(program_uniforms['boneGlobalMatrices'], GL_FALSE, object.skeleton.bone_matrices)
-        #   end
-        # end
-      end
-
-      if refresh_material
-        # TODO: when fog is implemented
-        # refresh_uniforms_fog(material_uniforms, fog) if fog && material.fog
-
-        if material.needs_lights?
-          if @light_renderer.lights_need_update
-            refresh_lights = true
-            @light_renderer.setup(lights)
-          end
-
-          if refresh_lights
-            OpenGLHelper.refresh_uniforms_lights(material_uniforms, @light_renderer.cache)
-          end
-
-          OpenGLHelper.mark_uniforms_lights_needs_update(material_uniforms, refresh_lights)
-        end
-
-        material.refresh_uniforms(material_uniforms)
-
-        # TODO: when all of these things exist
-        # when LineDashedMaterial
-        #   refresh_uniforms_line(material_uniforms, material)
-        #   refresh_uniforms_dash(material_uniforms, material)
-        # when MeshDepthMaterial
-        #   material_uniforms.m_near.value = camera.near
-        #   material_uniforms.m_far.value = camera.far
-        #   material_uniforms.opacity.value = material.opacity
-        # when MeshNormalMaterial
-        #   material_uniforms.opactity.value = material.opacity
-
-        if object.receive_shadow && !material.shadow_pass
-          OpenGLHelper.refresh_uniforms_shadow(material_uniforms, lights)
-        end
-
-        load_uniforms_generic(material.uniforms_list)
-      end
-
-      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))
-      end
-
-      program
-    end
-
-    # FIXME: REFACTOR!?!?!?!?!???
-    # MASSIVE CASE STATEMENT OMG!!!
-    def load_uniforms_generic(uniforms)
-      uniforms.each do |(uniform, location)|
-        # needs_update property is not added to all uniforms.
-        next if uniform.needs_update == false || location == -1
-
-        type = uniform.type
-        value = uniform.value
-
-        # AAAAAHHHHH!!!!! \o/ *flips table*
-        case type
-        when :int
-          glUniform1i(location, value)
-        when :ivec2
-          glUniform2i(location, value[0], value[1])
-        when :ivec3
-          glUniform3i(location, value[0], value[1], value[2])
-        when :ivec4
-          glUniform4i(location, value[0], value[1], value[2], value[3])
-        when :float
-          glUniform1f(location, value)
-        when :vec2
-          glUniform2f(location, value[0], value[1])
-        when :vec3, :color
-          glUniform3f(location, value[0], value[1], value[2])
-        when :vec4
-          glUniform4f(location, value[0], value[1], value[2], value[3])
-        when :'int[]'
-          glUniform1iv(location, value.length, array_to_ptr_easy(value))
-        when :'ivec2[]'
-          glUniform2iv(location, value.length / 2, array_to_ptr_easy(value))
-        when :'ivec3[]'
-          glUniform3iv(location, value.length / 3, array_to_ptr_easy(value))
-        when :'ivec4[]'
-          glUniform4iv(location, value.length / 4, array_to_ptr_easy(value))
-        when :'float[]'
-          glUniform1fv(location, value.length, array_to_ptr_easy(value))
-        when :'vec2[]'
-          if value[0].is_a? Vector2
-            uniform.array ||= value.flat_map(&:to_a) # TODO: Float32Array
-            glUniform2fv(location, value.length, array_to_ptr_easy(uniform.array))
-          else
-            glUniform2fv(location, value.length / 2, array_to_ptr_easy(value))
-          end
-        when :'vec3[]', :'color[]'
-          if value.first.is_a?(Vector3) || value.first.is_a?(Color)
-            uniform.array ||= value.flat_map(&:to_a) # TODO: Float32Array
-            glUniform3fv(location, value.length, array_to_ptr_easy(uniform.array))
-          else
-            glUniform3fv(location, value.length / 3, array_to_ptr_easy(value))
-          end
-        when :'vec4[]'
-          if value.first.is_a? Vector4
-            uniform.array ||= value.flat_map(&:to_a) # TODO: Float32Array
-            glUniform4fv(location, value.length, array_to_ptr_easy(uniform.array))
-          else
-            glUniform4fv(location, value.length / 4, array_to_ptr_easy(value))
-          end
-        when :mat3
-          glUniformMatrix3fv(location, 1, GL_FALSE, array_to_ptr_easy(value.to_a))
-        when :mat4
-          glUniformMatrix4fv(location, 1, GL_FALSE, array_to_ptr_easy(value.to_a))
-        when :'mat3[]'
-          if value.first.is_a? Matrix3
-            uniform.array ||= Array.new(9 * value.length) # Float32Array
-
-            value.each_with_index do |v, i|
-              value[i].flatten_to_array_offset(uniform.array, i * 9)
-            end
-
-            glUniformMatrix3fv(location, value.length, GL_FALSE, array_to_ptr_easy(uniform.array))
-          else
-            glUniformMatrix3fv(location, value.length / 9, GL_FALSE, array_to_ptr_easy(value))
-          end
-        when :'mat4[]'
-          if value.first.is_a? Matrix4
-            uniform.array ||= Array.new(16 * value.length) # Float32Array
-
-            value.each_with_index do |v, i|
-              value[i].flatten_to_array_offset(uniform.array, i * 16)
-            end
-
-            glUniformMatrix4fv(location, value.length, GL_FALSE, array_to_ptr_easy(uniform.array))
-          else
-            glUniformMatrix4fv(location, value.length / 16, GL_FALSE, array_to_ptr_easy(value))
-          end
-        when :texture
-          # single Mittsu::Texture (2d or cube)
-          texture = value
-          texture_unit = get_texture_unit
-
-          glUniform1i(location, texture_unit)
-
-          next unless texture
-
-          texture.set(texture_unit, self)
-          # TODO: when OpenGLRenderTargetCube is defined
-          # elsif texture.is_a?(OpenGLRenderTargetCube)
-            # set_cube_texture_dynamic(texture, texture_unit)
-        when :'texture[]'
-          # array of Mittsu::Texture (2d)
-          uniform.array ||= []
-
-          uniform.value.each_index do |i|
-            uniform.array[i] = get_texture_unit
-          end
-
-          glUniform1iv(location, uniform.array.length, array_to_ptr_easy(uniform.array))
-
-          uniform.value.each_with_index do |tex, i|
-            tex_unit = uniform.array[i]
-
-            next unless tex
-
-            tex.set(tex_unit, self)
-          end
-        else
-          puts "WARNING: Mittsu::OpenGLRenderer: Unknown uniform type: #{type}"
-        end
-      end
-    end
-
-    def get_texture_unit
-      texture_unit = @_used_texture_units
-
-      if texture_unit >= @_max_textures
-        puts "WARNING: OpenGLRenderer: trying to use #{texture_unit} texture units while this GPU supports only #{@_max_textures}"
-      end
-
-      @_used_texture_units += 1
-      texture_unit
-    end
-
-    def ensure_depth_buffer_writing
-      @state.set_depth_test(true)
-      @state.set_depth_write(true)
-      @state.set_color_write(true)
-    end
-
-    def reset_cache
-      @_current_geometry_program = ''
-      @_current_material_id = -1
-      @_current_camera = nil
-      @light_renderer.reset
-    end
-
-    def reset_objects_cache
-      @lights.clear
-      @opaque_objects.clear
-      @transparent_objects.clear
-      @sprites.clear
-      @lens_flares.clear
-    end
-
-    def reset_info
-      @info[:render][:calls] = 0
-      @info[:render][:vertices] = 0
-      @info[:render][:faces] = 0
-      @info[:render][:points] = 0
-    end
-
-    def reset_cache_for_this_frame
-      reset_cache
-      reset_objects_cache
-      reset_info
-    end
-
-    def update_screen_projection(camera)
-      camera.matrix_world_inverse.inverse(camera.matrix_world)
-
-      @proj_screen_matrix.multiply_matrices(camera.projection_matrix, camera.matrix_world_inverse)
-      @_frustum.set_from_matrix(@proj_screen_matrix)
-    end
-
-    def sort_objects_for_render
-      @opaque_objects.sort! { |a,b| OpenGLHelper.painter_sort_stable(a,b) }
-      @transparent_objects.sort! { |a,b| OpenGLHelper.reverse_painter_sort_stable(a,b) }
-    end
-
-    def set_matrices_for_immediate_objects(camera)
-      @_opengl_objects_immediate.each do |opengl_object|
-        object = opengl_object.object
-
-        if object.visible
-          object.setup_matrices(camera)
-          unroll_immediate_buffer_material(opengl_object)
-        end
-      end
-    end
-
-    def render_main_pass(scene, camera)
-      if scene.override_material
-        render_with_override_material(scene, camera)
-      else
-        render_with_default_materials(scene, camera)
-      end
-    end
-
-    def render_with_override_material(scene, camera)
-      override_material = scene.override_material
-
-      override_material.set(self)
-
-      render_objects(@opaque_objects, camera, @lights, scene.fog, override_material)
-      render_objects(@transparent_objects, camera, @lights, scene.fog, override_material)
-      render_objects_immediate(@_opengl_objects_immediate, nil, camera, @lights, scene.fog, override_material)
-    end
-
-    def render_with_default_materials(scene, camera)
-      render_opaque_pass(scene, camera)
-      render_transparent_pass(scene, camera)
-    end
-
-    def render_opaque_pass(scene, camera)
-      # front-to-back order
-      @state.set_blending(NoBlending)
-
-      render_objects(@opaque_objects, camera, @lights, scene.fog, nil)
-      render_objects_immediate(@_opengl_objects_immediate, :opaque, camera, @lights, scene.fog, nil)
-    end
-
-    def render_transparent_pass(scene, camera)
-      # back-to-front-order
-      render_objects(@transparent_objects, camera, @lights, scene.fog, nil)
-      render_objects_immediate(@_opengl_objects_immediate, :transparent, camera, @lights, scene.fog, nil)
-    end
-
-    def render_custom_plugins_pre_pass(scene, camera)
-      @shadow_map_plugin.render(scene, camera)
-    end
-
-    def render_custom_plugins_post_pass(scene, camera)
-      @sprite_plugin.render(scene, camera)
-
-      # TODO: when these custom plugins are implemented
-      # lens_flare_plugin.render(scene, camera, @_current_render_target.width, @_current_render_target.height)
-    end
-
-    def update_skeleton_objects(scene)
-      # TODO: when SkinnedMesh is defined
-      # scene.traverse do |object|
-      #   if object.is_a? SkinnedMesh
-      #     object.skeleton.update
-      #   end
-      # end
-    end
-
-    def perform_auto_clear
-      clear(@auto_clear_color, @auto_clear_depth, @auto_clear_stencil)
-    end
-
-    def init_clearing
-      @_clear_color = Color.new(0x000000)
-      @_clear_alpha = 0.0
-
-      @auto_clear = true
-      @auto_clear_color = true
-      @auto_clear_depth = true
-      @auto_clear_stencil = true
-    end
-
-    def init_gamma
-      @gamma_factor = 2.0 # backwards compat???
-      @gamma_input = false
-      @gamma_output = false
-    end
-
-    def init_shadow_properties
-      @shadow_map_enabled = false
-      @shadow_map_type = PCFShadowMap
-      @shadow_map_cull_face = CullFaceFront
-      @shadow_map_debug = false
-      @shadow_map_cascade = false
-    end
-
-    def init_morphs
-      @max_morph_targets = 8
-      @max_morph_normals = 4
-    end
-
-    def init_collections
-      @lights = []
-      @sprites = []
-
-      @_opengl_objects = {}
-      @_opengl_objects_immediate = []
-
-      @opaque_objects = []
-      @transparent_objects = []
-
-      @sprites = []
-      @lens_flares = []
-
-      @programs = []
-    end
-
-    def init_info
-      @info = {
-        memory: {
-          programs: 0,
-          geometries: 0,
-          textures: 0
-        },
-        render: {
-          calls: 0,
-          vertices: 0,
-          faces: 0,
-          points: 0
-        }
-      }
-    end
-
-    def init_state_cache
-      @_current_program = nil
-      @_current_render_target = default_target
-      @_current_material_id = -1
-      @_current_geometry_program = ''
-      @_current_camera = nil
-
-      @_used_texture_units = 0
-    end
-
-    def init_camera_matrix_cache
-      @_frustum = Frustum.new
-      @proj_screen_matrix = Matrix4.new
-      @_vector3 = Vector3.new
-    end
-
-    def fetch_parameters(parameters)
-      @_alpha = parameters.fetch(:alpha, false)
-      @_depth = parameters.fetch(:depth, true)
-      @_stencil = parameters.fetch(:stencil, true)
-      @_premultiplied_alpha = parameters.fetch(:premultiplied_alpha, true)
-      @_preserve_drawing_buffer = parameters.fetch(:preserve_drawing_buffer, false)
-      @logarithmic_depth_buffer = parameters.fetch(:logarithmic_depth_buffer, false)
-
-      @width = parameters.fetch(:width, 800)
-      @height = parameters.fetch(:height, 600)
-      @title = parameters.fetch(:title, "Mittsu #{VERSION}")
-      @antialias = parameters.fetch(:antialias, 0)
-    end
-
-    def get_gpu_capabilities
-      @_max_textures = glGetParameter(GL_MAX_TEXTURE_IMAGE_UNITS)
-      @_max_vertex_textures = glGetParameter(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS)
-      @_max_texture_size = glGetParameter(GL_MAX_TEXTURE_SIZE)
-      @_max_cubemap_size = glGetParameter(GL_MAX_CUBE_MAP_TEXTURE_SIZE)
-
-      @_supports_vertex_textures = @_max_vertex_textures > 0
-      @_supports_bone_textures = @_supports_vertex_textures && false # TODO: extensions.get('OES_texture_float') ????
-    end
-
-    def init_plugins
-      @shadow_map_plugin = ShadowMapPlugin.new(self, @lights, @_opengl_objects, @_opengl_objects_immediate)
-
-      @sprite_plugin = SpritePlugin.new(self, @sprites)
-
-      # TODO: when these custom plugins are implemented
-      # @lens_flare_plugin = LensFlarePlugin.new(self, @lens_flares)
-    end
-
-    def create_window
-      # attributes = {
-      #   alpha: _alpha,
-      #   depth: _depth,
-      #   stencil: _stencil,
-      #   antialias: _antialias,
-      #   premultiplied_alpha: _premultiplied_alpha,
-      #   preserve_drawing_buffer: _preserve_drawing_buffer
-      # }
-
-      @window = GLFW::Window.new(@width, @height, @title, antialias: @antialias)
-
-      default_target.set_viewport_size(*(@window.framebuffer_size))
-
-      # TODO: handle losing opengl context??
-    end
-
-    def switch_geometry_program(program, material, geometry_group)
-      wireframe_bit = material.wireframe ? 1 : 0
-      geometry_program = "#{geometry_group.id}_#{program.id}_#{wireframe_bit}"
-
-      if geometry_program != @_current_geometry_program
-        @_current_geometry_program = geometry_program
-        true
-      else
-        false
-      end
-    end
-
-    def default_target
-      @_defualt_target ||= OpenGLDefaultTarget.new(self)
-    end
-
-    def update_camera_uniforms(uniforms, camera, material)
-      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.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.needs_view_matrix_uniform? && !uniforms['viewMatrix'].nil?
-        glUniformMatrix4fv(uniforms['viewMatrix'], 1, GL_FALSE, array_to_ptr_easy(camera.matrix_world_inverse.elements))
-      end
-    end
-
-    def remove_child(object)
-      if object.is_a?(Mesh) || object.is_a?(PointCloud) || object.is_a?(Line)
-        @_opengl_objects.delete(object.id)
-
-      # elsif object.is_a?(ImmediateRenderObject) || object.immediate_render_callback
-      #   removeInstances( _webglObjectsImmediate, object );
-      end
-
-      object.deinit
-    end
-  end
-end