lib/mittsu/opengl/renderer.rb
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