mittsu-opengl 0.5.0

data/lib/mittsu/opengl/renderer.rb

@@ -0,0 +1,1028 @@
+require 'opengl'
+require 'glfw'
+require 'fiddle'
+
+require 'mittsu/opengl/version'
+require 'mittsu/opengl/lib'
+opengl_lib = Mittsu::OpenGL::Lib.discover
+GL.load_lib(ENV["MITTSU_LIBGL_PATH"] || opengl_lib.path, Mittsu.debug?)
+
+require 'mittsu/glfw/window'
+require 'mittsu/opengl/gl_debug' if ENV['DEBUG']
+require 'mittsu/opengl/implementation'
+require 'mittsu/opengl/gl_extensions'
+require 'mittsu/opengl/helper'
+require 'mittsu/opengl/program'
+require 'mittsu/opengl/state'
+require 'mittsu/opengl/geometry_group'
+require 'mittsu/opengl/light_renderer'
+require 'mittsu/opengl/default_target'
+require 'mittsu/opengl/buffer'
+require 'mittsu/opengl/plugins/shadow_map_plugin'
+require 'mittsu/opengl/plugins/sprite_plugin'
+require 'mittsu/opengl/shader/lib'
+require 'mittsu/opengl/shader/uniforms_utils'
+include Mittsu::OpenGL::Helper
+
+require 'mittsu/opengl/gl_mittsu_params'
+
+module Mittsu
+  class OpenGL::Renderer
+    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 = OpenGL::LightRenderer.new(self)
+
+      create_window
+
+      @state = OpenGL::State.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)
+      GL.Scissor(
+        x * pixel_ratio,
+        y * pixel_ratio,
+        width * pixel_ratio,
+        height * pixel_ratio
+      )
+    end
+
+    def enable_scissor_test(enable)
+      enable ? GL.Enable(GL::SCISSOR_TEST) : GL.Disable(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
+
+      GL.Clear(bits)
+    end
+
+    def clear_depth
+      GL.Clear(GL::DEPTH_BUFFER_BIT)
+    end
+
+    def clear_stencil
+      GL.Clear(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::OpenGL::Renderer#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::OpenGL::Renderer: 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
+
+      GL.ClearColor(r, g, b, a)
+    end
+
+    def set_default_gl_state
+      GL.ClearColor(0.0, 0.0, 0.0, 1.0)
+      GL.ClearDepth(1)
+      GL.ClearStencil(0)
+
+      GL.Enable(GL::DEPTH_TEST)
+      GL.DepthFunc(GL::LEQUAL)
+
+      GL.FrontFace(GL::CCW)
+      GL.CullFace(GL::BACK)
+      GL.Enable(GL::CULL_FACE)
+
+      GL.Enable(GL::BLEND)
+      GL.BlendEquation(GL::FUNC_ADD)
+      GL.BlendFunc(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] ||= []) << OpenGL::Buffer.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 ?????
+        # GL.BindVertexArray 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 = GL.CreateBuffer
+            GL.BindBuffer(buffer_type, attribute.buffer)
+            GL.BufferData_easy(buffer_type, attribute.array, (attribute.is_a? DynamicBufferAttribute) ? GL::DYNAMIC_DRAW : GL::STATIC_DRAW)
+
+            attribute.needs_update = false
+          elsif attribute.needs_update
+            GL.BindBuffer(buffer_type, attribute.buffer)
+            if attribute.update_range.nil? || attribute.update_range.count == -1 # Not using update ranged
+              GL.BufferSubData(buffer_type, 0, attribute.array)
+            elsif attribute.udpate_range.count.zero?
+              puts 'ERROR: Mittsu::OpenGL::Renderer#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 GL.BufferSubData_easy method
+              GL.BufferSubData(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
+        GL.UseProgram(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?
+        #   GL.UniformMatrix4fv(program_uniforms['bindMatrix'], GL::FALSE, object.bind_matrix.elements)
+        # end
+        #
+        # if object.bind_matrix_inverse && !program_uniforms['bindMatrixInverse'].nil?
+        #   GL.UniformMatrix4fv(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
+        #
+        #     GL.Uniform1i(program_uniforms['boneTexture'], texture_unit)
+        #     object.skeleton.bone_texture.set(texture_unit, self)
+        #   end
+        #
+        #   if !program_uniforms['boneTextureWidth'].nil?
+        #     GL.Uniform1i(program_uniforms['boneTextureWidth'], object.skeleton.bone_texture_width)
+        #   end
+        #
+        #   if !program_uniforms['boneTextureHeight'].nil?
+        #     GL.Uniform1i(program_uniforms['boneTextureHeight'], object.skeleton.bone_texture_height)
+        #   end
+        # elsif object.skeleton && object.skeleton.bone_matrices
+        #   if !program_uniforms['boneGlobalMatrices'].nil?
+        #     GL.UniformMatrix4fv(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
+            OpenGL::Helper.refresh_uniforms_lights(material_uniforms, @light_renderer.cache)
+          end
+
+          OpenGL::Helper.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
+          OpenGL::Helper.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?
+        GL.UniformMatrix4fv(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
+          GL.Uniform1i(location, value)
+        when :ivec2
+          GL.Uniform2i(location, value[0], value[1])
+        when :ivec3
+          GL.Uniform3i(location, value[0], value[1], value[2])
+        when :ivec4
+          GL.Uniform4i(location, value[0], value[1], value[2], value[3])
+        when :float
+          GL.Uniform1f(location, value)
+        when :vec2
+          GL.Uniform2f(location, value[0], value[1])
+        when :vec3, :color
+          GL.Uniform3f(location, value[0], value[1], value[2])
+        when :vec4
+          GL.Uniform4f(location, value[0], value[1], value[2], value[3])
+        when :'int[]'
+          GL.Uniform1iv(location, value.length, array_to_ptr_easy(value))
+        when :'ivec2[]'
+          GL.Uniform2iv(location, value.length / 2, array_to_ptr_easy(value))
+        when :'ivec3[]'
+          GL.Uniform3iv(location, value.length / 3, array_to_ptr_easy(value))
+        when :'ivec4[]'
+          GL.Uniform4iv(location, value.length / 4, array_to_ptr_easy(value))
+        when :'float[]'
+          GL.Uniform1fv(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
+            GL.Uniform2fv(location, value.length, array_to_ptr_easy(uniform.array))
+          else
+            GL.Uniform2fv(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
+            GL.Uniform3fv(location, value.length, array_to_ptr_easy(uniform.array))
+          else
+            GL.Uniform3fv(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
+            GL.Uniform4fv(location, value.length, array_to_ptr_easy(uniform.array))
+          else
+            GL.Uniform4fv(location, value.length / 4, array_to_ptr_easy(value))
+          end
+        when :mat3
+          GL.UniformMatrix3fv(location, 1, GL::FALSE, array_to_ptr_easy(value.to_a))
+        when :mat4
+          GL.UniformMatrix4fv(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
+
+            GL.UniformMatrix3fv(location, value.length, GL::FALSE, array_to_ptr_easy(uniform.array))
+          else
+            GL.UniformMatrix3fv(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
+
+            GL.UniformMatrix4fv(location, value.length, GL::FALSE, array_to_ptr_easy(uniform.array))
+          else
+            GL.UniformMatrix4fv(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
+
+          GL.Uniform1i(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
+
+          GL.Uniform1iv(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::OpenGL::Renderer: Unknown uniform type: #{type}"
+        end
+      end
+    end
+
+    def get_texture_unit
+      texture_unit = @_used_texture_units
+
+      if texture_unit >= @_max_textures
+        puts "WARNING: OpenGL::Renderer: 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| OpenGL::Helper.painter_sort_stable(a,b) }
+      @transparent_objects.sort! { |a,b| OpenGL::Helper.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 = GL.GetParameter(GL::MAX_TEXTURE_IMAGE_UNITS)
+      @_max_vertex_textures = GL.GetParameter(GL::MAX_VERTEX_TEXTURE_IMAGE_UNITS)
+      @_max_texture_size = GL.GetParameter(GL::MAX_TEXTURE_SIZE)
+      @_max_cubemap_size = GL.GetParameter(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 ||= OpenGL::DefaultTarget.new(self)
+    end
+
+    def update_camera_uniforms(uniforms, camera, material)
+      GL.UniformMatrix4fv(uniforms['projectionMatrix'], 1, GL::FALSE, array_to_ptr_easy(camera.projection_matrix.elements))
+
+      if @logarithmic_depth_buffer
+        GL.Uniform1f(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)
+        GL.Uniform3f(uniforms['cameraPosition'], @_vector3.x, @_vector3.y, @_vector3.z)
+      end
+
+      if material.needs_view_matrix_uniform? && !uniforms['viewMatrix'].nil?
+        GL.UniformMatrix4fv(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( _webGL.ObjectsImmediate, object );
+      end
+
+      object.deinit
+    end
+  end
+end