mittsu 0.4.0 → 0.5.0

data/lib/mittsu/renderers/opengl/opengl_shader.rb

@@ -1,58 +0,0 @@
-require 'fiddle'
-
-module Mittsu
-  class OpenGLShader
-    attr_reader :shader
-
-    def initialize(type, string)
-      @shader = glCreateShader(type)
-      # filename = type == GL_VERTEX_SHADER ? 'vertex.glsl' : 'fragment.glsl'
-      # File.write filename, string
-
-      string_pointer = Fiddle::Pointer[string]
-      string_length = Fiddle::Pointer[string.length]
-
-      glShaderSource(@shader, 1, string_pointer.ref, string_length.ref)
-      glCompileShader(@shader)
-
-      if !compile_status
-        puts "ERROR: Mittsu::OpenGLShader: Shader couldn't compile"
-      end
-
-      log_info = shader_info_log
-      if !log_info.empty?
-        puts "WARNING: Mittsu::OpenGLShader: glGetShaderInfoLog, #{log_info}"
-        puts add_line_numbers(string)
-      end
-    end
-
-    private
-
-    def compile_status
-      ptr = ' '*8
-      glGetShaderiv @shader, GL_COMPILE_STATUS, ptr
-      ptr.unpack('L')[0]
-    end
-
-    def shader_info_log
-      ptr = ' '*8
-      glGetShaderiv @shader, GL_INFO_LOG_LENGTH, ptr
-      length = ptr.unpack('L')[0]
-
-      if length > 0
-        log = ' '*length
-        glGetShaderInfoLog @shader, length, ptr, log
-        log.unpack("A#{length}")[0]
-      else
-        ''
-      end
-    end
-
-    def add_line_numbers(string)
-      string.split("\n").each_with_index.map { |line, i|
-        line_number = "#{i + 1}".rjust(4, ' ')
-        "#{line_number}: #{line}"
-      }.join("\n")
-    end
-  end
-end

data/lib/mittsu/renderers/opengl/opengl_state.rb

@@ -1,205 +0,0 @@
-module Mittsu
-  class OpenGLState
-    def initialize
-      @new_attributes = Array.new(16) # Uint8Array
-      @enabled_attributes = Array.new(16) # Uint8Array
-
-      @current_blending = nil
-      @current_blend_equation = nil
-      @current_blend_src = nil
-      @current_blend_dst = nil
-      @current_blend_equation_alpha = nil
-      @current_blend_src_alpha = nil
-      @current_blend_dst_alpha = nil
-
-      @current_depth_test = nil
-      @current_depth_write = nil
-
-      @current_color_write = nil
-
-      @current_double_sided = nil
-      @current_flip_sided = nil
-
-      @current_line_width = nil
-
-      @current_polygon_offset = nil
-      @current_polygon_offset_factor = nil
-      @current_polygon_offset_units = nil
-    end
-
-    def init_attributes
-      @new_attributes.length.times do |i|
-        @new_attributes[i] = false
-      end
-    end
-
-    def enable_attribute(attribute)
-      glEnableVertexAttribArray(attribute)
-      @new_attributes[attribute] = true
-
-      if !@enabled_attributes[attribute]
-        # glEnableVertexAttribArray(attribute)
-        @enabled_attributes[attribute] = true
-      end
-    end
-
-    def disable_unused_attributes
-      @enabled_attributes.length.times do |i|
-        if @enabled_attributes[i] && !@new_attributes[i]
-          glDisableVertexAttribArray(i)
-          @enabled_attributes[i] = false
-        end
-      end
-    end
-
-    def set_blending(blending, blend_equation = nil, blend_src = nil, blend_dst = nil, blend_equation_alpha = nil, blend_src_alpha = nil, blend_dst_alpha = nil)
-      if blending != @current_blending
-        case blending
-        when NoBlending
-          glDisable(GL_BLEND)
-        when AdditiveBlending
-          glEnable(GL_BLEND)
-          glBlendEquation(GL_FUNC_ADD)
-          glBlendFunc(GL_SRC_ALPHA, GL_ONE)
-        when SubtractiveBlending
-          # TODO: Find blendFuncSeparate() combination ???
-          glEnable(GL_BLEND)
-          glBlendEquation(GL_FUNC_ADD)
-          glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR)
-        when MultiplyBlending
-          # TODO: Find blendFuncSeparate() combination ???
-          glEnable(GL_BLEND)
-          glBlendEquation(GL_FUNC_ADD)
-          glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR)
-        when CustomBlending
-          glEnable(GL_BLEND)
-        else
-          glEnable(GL_BLEND)
-          glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD)
-          glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA)
-        end
-
-        @current_blending = blending
-      end
-
-      if blending == CustomBlending
-        blend_equation_alpha ||= blend_equation
-        blend_src_alpha ||= blend_src
-        blend_dst_alpha ||= blend_dst
-
-        if blend_equation != @current_blend_equation || blend_equation_alpha != @current_blend_equation_alpha
-          glBlendEquationSeparate(GL_MITTSU_PARAMS[blend_equation], GL_MITTSU_PARAMS[blend_equation_alpha])
-
-          @current_blend_equation = blend_equation
-          @current_blend_equation_alpha = blend_equation_alpha
-        end
-
-        if blend_src != @current_blend_src || blend_dst != @current_blend_dst || blend_src_alpha != @current_blend_src_alpha || blend_dst_alpha != @current_blend_dst_alpha
-          glBlendFuncSeparate(GL_MITTSU_PARAMS[blend_src], GL_MITTSU_PARAMS[blend_dst], GL_MITTSU_PARAMS[blend_src_alpha], GL_MITTSU_PARAMS[blend_dst_alpha])
-
-          @current_blend_src = nil
-          @current_blend_dst = nil
-          @current_blend_src_alpha = nil
-          @current_blend_dst_alpha = nil
-        end
-      else
-        @current_blend_equation = nil
-        @current_blend_src = nil
-        @current_blend_dst = nil
-        @current_blend_equation_alpha = nil
-        @current_blend_src_alpha = nil
-        @current_blend_dst_alpha = nil
-      end
-    end
-
-    def set_depth_test(depth_test)
-      if @current_depth_test != depth_test
-        if depth_test
-          glEnable(GL_DEPTH_TEST)
-        else
-          glDisable(GL_DEPTH_TEST)
-        end
-
-        @current_depth_test = depth_test
-      end
-    end
-
-    def set_depth_write(depth_write)
-      if @current_depth_write != depth_write
-        glDepthMask(depth_write ? GL_TRUE : GL_FALSE)
-        @current_depth_write = depth_write
-      end
-    end
-
-    def set_color_write(color_write)
-      if @current_color_write != color_write
-        gl_color_write = color_write ? GL_TRUE : GL_FALSE
-        glColorMask(gl_color_write, gl_color_write, gl_color_write, gl_color_write)
-        @current_color_write = color_write
-      end
-    end
-
-    def set_double_sided(double_sided)
-      if @current_double_sided != double_sided
-        if double_sided
-          glDisable(GL_CULL_FACE)
-        else
-          glEnable(GL_CULL_FACE)
-        end
-
-        @current_double_sided = double_sided
-      end
-    end
-
-    def set_flip_sided(flip_sided)
-      if @current_flip_sided != flip_sided
-        if flip_sided
-          glFrontFace(GL_CW)
-        else
-          glFrontFace(GL_CCW)
-        end
-
-        @current_flip_sided = flip_sided
-      end
-    end
-
-    def set_line_width(width)
-      if width != @current_line_width
-        glLineWidth(width)
-        @current_line_width = width
-      end
-    end
-
-    def set_polygon_offset(polygon_offset, factor, units)
-      if @current_polygon_offset != polygon_offset
-        if polygon_offset
-          glEnable(GL_POLYGON_OFFSET_FILL)
-        else
-          glDisable(GL_POLYGON_OFFSET_FILL)
-        end
-
-        @current_polygon_offset = polygon_offset
-      end
-
-      if polygon_offset && (@current_polygon_offset_factor != factor || @current_polygon_offset_units != units)
-        glPolygonOffset(factor, units)
-
-        @current_polygon_offset_factor = factor
-        @current_polygon_offset_units = units
-      end
-    end
-
-    def reset
-      @enabled_attributes.length.times do |i|
-        @enabled_attributes[i] = false
-      end
-
-      @current_blending = nil
-      @current_depth_test = nil
-      @current_depth_write = nil
-      @current_color_write = nil
-      @current_double_sided = nil
-      @current_flip_sided = nil
-    end
-  end
-end

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

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