3rb 0.1.0

data/lib/3rb/objects/points.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class PointsMaterial < Material
+    attr_accessor :color, :map
+    attr_accessor :size, :size_attenuation
+    attr_accessor :alpha_map
+
+    def initialize(color: 0xffffff, size: 1, size_attenuation: true)
+      super()
+      @color = color.is_a?(Color) ? color : Color.new(color)
+      @map = nil
+      @size = size.to_f
+      @size_attenuation = size_attenuation
+      @alpha_map = nil
+      @lights = false
+    end
+
+    def copy(source)
+      super
+      @color = source.color.clone
+      @map = source.map
+      @size = source.size
+      @size_attenuation = source.size_attenuation
+      @alpha_map = source.alpha_map
+      self
+    end
+
+    def to_h
+      super.merge(
+        color: @color.get_hex,
+        size: @size,
+        size_attenuation: @size_attenuation
+      )
+    end
+  end
+
+  class Points < Object3D
+    attr_accessor :geometry, :material
+
+    def initialize(geometry = nil, material = nil)
+      super()
+      @geometry = geometry || BufferGeometry.new
+      @material = material || PointsMaterial.new
+    end
+
+    def copy(source, recursive = true)
+      super
+      @material = source.material.clone
+      @geometry = source.geometry.clone
+      self
+    end
+
+    def clone(recursive = true)
+      new_points = super
+      new_points.geometry = @geometry.clone
+      new_points.material = @material.clone
+      new_points
+    end
+
+    def raycast(_raycaster, _intersects)
+    end
+
+    def to_h
+      super.merge(
+        geometry: @geometry.uuid,
+        material: @material.uuid
+      )
+    end
+  end
+end

data/lib/3rb/renderers/opengl_renderer.rb

@@ -0,0 +1,567 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class OpenGLRenderer < Renderer
+    attr_reader :window, :info
+
+    def initialize(width: 800, height: 600, title: "Sunrb", antialias: false)
+      super(width: width, height: height)
+
+      @title = title
+      @antialias = antialias
+      @window = nil
+      @running = false
+      @last_time = 0.0
+
+      @info = {
+        memory: { geometries: 0, textures: 0 },
+        render: { calls: 0, triangles: 0, points: 0, lines: 0 }
+      }
+
+      @frame_callback = nil
+      @key_callback = nil
+      @mouse_callback = nil
+      @mouse_move_callback = nil
+      @mouse_button_callback = nil
+      @resize_callback = nil
+
+      @last_mouse_pos = [0.0, 0.0]
+      @last_mouse_buttons = [false, false, false]
+
+      @programs = {}
+      @shader_cache = {}
+      @default_texture = nil
+
+      init_window if native_available?
+    end
+
+    def native_available?
+      defined?(Sunrb::Native) ? true : false
+    end
+
+    def run(&block)
+      raise GLError, "Native extension not available" unless native_available?
+
+      @running = true
+      @last_time = Native.get_time
+
+      while @running && !@window.should_close?
+        current_time = Native.get_time
+        delta = current_time - @last_time
+        @last_time = current_time
+
+        Native.poll_events
+
+        handle_input
+
+        block&.call(delta)
+
+        @frame_callback&.call(delta)
+
+        @window.swap_buffers
+      end
+
+      dispose
+    end
+
+    def on_frame(&block)
+      @frame_callback = block
+    end
+
+    def on_key(&block)
+      @key_callback = block
+    end
+
+    def on_mouse(&block)
+      @mouse_callback = block
+    end
+
+    def on_mouse_move(&block)
+      @mouse_move_callback = block
+    end
+
+    def on_mouse_button(&block)
+      @mouse_button_callback = block
+    end
+
+    def on_resize(&block)
+      @resize_callback = block
+    end
+
+    def stop
+      @running = false
+    end
+
+    def render(scene, camera)
+      return unless native_available?
+
+      reset_info
+
+      @window.make_current
+
+      if @auto_clear
+        clear(
+          color: @auto_clear_color,
+          depth: @auto_clear_depth,
+          stencil: @auto_clear_stencil
+        )
+      end
+
+      scene.update_matrix_world
+      camera.update_matrix_world
+
+      render_scene(scene, camera)
+    end
+
+    def clear(color: true, depth: true, stencil: true)
+      return unless native_available?
+
+      gl = Native::GL
+
+      if color
+        gl.clear_color(@clear_color.r, @clear_color.g, @clear_color.b, @clear_alpha)
+      end
+
+      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 set_size(width, height)
+      super
+      return unless native_available? && @window
+
+      fb_width, fb_height = @window.size
+      Native::GL.viewport(0, 0, fb_width, fb_height)
+    end
+
+    def dispose
+      return unless native_available?
+
+      @programs.each_value { |p| Native::GL.delete_program(p) }
+      @programs.clear
+
+      Native::GL.delete_textures([@default_texture]) if @default_texture
+      @default_texture = nil
+
+      @window&.destroy
+      @window = nil
+
+      Native.terminate_glfw
+    end
+
+    def get_context
+      return nil unless native_available?
+
+      {
+        vendor: Native::GL.get_string(Native::GL::VENDOR),
+        renderer: Native::GL.get_string(Native::GL::RENDERER),
+        version: Native::GL.get_string(Native::GL::VERSION)
+      }
+    end
+
+    private
+
+    def init_window
+      Native.init_glfw
+      @window = Native::Window.new(@width, @height, @title)
+      setup_gl_state
+    end
+
+    def setup_gl_state
+      gl = Native::GL
+
+      gl.enable(gl::DEPTH_TEST)
+      gl.depth_func(gl::LEQUAL)
+
+      gl.enable(gl::CULL_FACE)
+      gl.cull_face(gl::BACK)
+      gl.front_face(gl::CCW)
+
+      gl.enable(gl::BLEND)
+      gl.blend_func(gl::SRC_ALPHA, gl::ONE_MINUS_SRC_ALPHA)
+
+      fb_width, fb_height = @window.size
+      gl.viewport(0, 0, fb_width, fb_height)
+
+      create_default_texture
+    end
+
+    def create_default_texture
+      gl = Native::GL
+
+      @default_texture = gl.gen_textures(1).first
+      gl.bind_texture(gl::TEXTURE_2D, @default_texture)
+      gl.tex_parameter_i(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::NEAREST)
+      gl.tex_parameter_i(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::NEAREST)
+      gl.tex_image_2d(gl::TEXTURE_2D, 0, gl::RGBA, 1, 1, 0, gl::RGBA, gl::UNSIGNED_BYTE, [255, 255, 255, 255])
+      gl.bind_texture(gl::TEXTURE_2D, 0)
+    end
+
+    def handle_input
+      if @window.get_key(Native::KEY_ESCAPE) == Native::PRESS
+        @key_callback&.call(:escape, :press)
+        stop
+      end
+
+      if @mouse_move_callback
+        current_pos = @window.cursor_pos
+        if current_pos != @last_mouse_pos
+          @mouse_move_callback.call(current_pos[0], current_pos[1])
+          @last_mouse_pos = current_pos
+        end
+      end
+
+      if @mouse_button_callback
+        [0, 1, 2].each do |button|
+          pressed = @window.get_mouse_button(button) == Native::PRESS
+          if pressed != @last_mouse_buttons[button]
+            action = pressed ? 1 : 0
+            @mouse_button_callback.call(button, action, 0)
+            @last_mouse_buttons[button] = pressed
+          end
+        end
+      end
+    end
+
+    def reset_info
+      @info[:render][:calls] = 0
+      @info[:render][:triangles] = 0
+      @info[:render][:points] = 0
+      @info[:render][:lines] = 0
+    end
+
+    def render_scene(scene, camera)
+      view_matrix = camera.matrix_world_inverse
+      projection_matrix = camera.projection_matrix
+
+      render_objects = []
+      scene.traverse do |object|
+        render_objects << object if object.is_a?(Mesh) && object.visible
+      end
+
+      lights = collect_lights(scene)
+
+      render_objects.each do |mesh|
+        render_mesh(mesh, camera, view_matrix, projection_matrix, lights)
+      end
+    end
+
+    def collect_lights(scene)
+      lights = { ambient: Color.new(0), directional: [] }
+
+      scene.traverse do |object|
+        case object
+        when AmbientLight
+          lights[:ambient] = lights[:ambient] + object.color * object.intensity
+        when DirectionalLight
+          dir = Vector3.new(0, 0, -1)
+          dir.apply_quaternion(object.quaternion)
+          lights[:directional] << {
+            direction: dir,
+            color: object.color * object.intensity
+          }
+        end
+      end
+
+      lights
+    end
+
+    def render_mesh(mesh, camera, view_matrix, projection_matrix, lights)
+      geometry = mesh.geometry
+      material = mesh.material
+
+      return unless geometry && material
+
+      program = get_or_create_program(material)
+      return unless program
+
+      gl = Native::GL
+      gl.use_program(program)
+
+      gl.active_texture(gl::TEXTURE0)
+      gl.bind_texture(gl::TEXTURE_2D, @default_texture)
+
+      gpu_geometry = get_or_create_geometry(geometry)
+      return unless gpu_geometry
+
+      gl.bind_vertex_array(gpu_geometry[:vao])
+
+      model_matrix = mesh.matrix_world
+      model_view_matrix = view_matrix * model_matrix
+      normal_matrix = model_view_matrix.clone.invert!.transpose!
+
+      set_uniform_matrix4(program, "modelViewMatrix", model_view_matrix)
+      set_uniform_matrix4(program, "projectionMatrix", projection_matrix)
+      set_uniform_matrix4(program, "modelMatrix", model_matrix)
+      set_uniform_matrix4(program, "viewMatrix", view_matrix)
+      set_uniform_matrix3(program, "normalMatrix", normal_matrix.to_matrix3)
+
+      camera_pos = Vector3.new
+      camera_pos.set_from_matrix_position(camera.matrix_world)
+      set_uniform_vec3(program, "cameraPosition", camera_pos)
+
+      set_material_uniforms(program, material, lights)
+
+      wireframe = material.respond_to?(:wireframe) && material.wireframe
+      if wireframe
+        gl.polygon_mode(gl::FRONT_AND_BACK, gl::LINE)
+        linewidth = material.respond_to?(:wireframe_linewidth) ? material.wireframe_linewidth : 1
+        gl.line_width(linewidth)
+      end
+
+      if geometry.index
+        gl.draw_elements(gl::TRIANGLES, geometry.index.count, gl::UNSIGNED_INT, 0)
+      else
+        position_attr = geometry.get_attribute(:position)
+        vertex_count = position_attr ? position_attr.count : 0
+        gl.draw_arrays(gl::TRIANGLES, 0, vertex_count)
+      end
+
+      gl.polygon_mode(gl::FRONT_AND_BACK, gl::FILL) if wireframe
+
+      gl.bind_vertex_array(0)
+
+      @info[:render][:calls] += 1
+    end
+
+    def get_or_create_program(material)
+      if material.is_a?(ShaderMaterial)
+        key = material.object_id
+        return @programs[key] if @programs[key]
+
+        vertex_source = material.vertex_shader
+        fragment_source = material.fragment_shader
+        return nil unless vertex_source && fragment_source
+
+        program = compile_program(vertex_source, fragment_source)
+        @programs[key] = program if program
+        return program
+      end
+
+      key = material.class.name
+
+      return @programs[key] if @programs[key]
+
+      shader_data = case material
+                    when MeshBasicMaterial then ShaderLib.basic
+                    when MeshLambertMaterial then ShaderLib.lambert
+                    when MeshPhongMaterial then ShaderLib.phong
+                    when MeshStandardMaterial then ShaderLib.standard
+                    else ShaderLib.basic
+                    end
+
+      vertex_source = shader_data[:vertex_shader]
+      fragment_source = shader_data[:fragment_shader]
+
+      return nil unless vertex_source && fragment_source
+
+      program = compile_program(vertex_source, fragment_source)
+      @programs[key] = program if program
+
+      program
+    end
+
+    def compile_program(vertex_source, fragment_source)
+      gl = Native::GL
+
+      vertex_shader = gl.create_shader(gl::VERTEX_SHADER)
+      gl.shader_source(vertex_shader, vertex_source)
+      gl.compile_shader(vertex_shader)
+
+      unless gl.get_shader_iv(vertex_shader, gl::COMPILE_STATUS) == 1
+        log = gl.get_shader_info_log(vertex_shader)
+        warn "Vertex shader compile error: #{log}"
+        gl.delete_shader(vertex_shader)
+        return nil
+      end
+
+      fragment_shader = gl.create_shader(gl::FRAGMENT_SHADER)
+      gl.shader_source(fragment_shader, fragment_source)
+      gl.compile_shader(fragment_shader)
+
+      unless gl.get_shader_iv(fragment_shader, gl::COMPILE_STATUS) == 1
+        log = gl.get_shader_info_log(fragment_shader)
+        warn "Fragment shader compile error: #{log}"
+        gl.delete_shader(vertex_shader)
+        gl.delete_shader(fragment_shader)
+        return nil
+      end
+
+      program = gl.create_program
+      gl.attach_shader(program, vertex_shader)
+      gl.attach_shader(program, fragment_shader)
+      gl.link_program(program)
+
+      unless gl.get_program_iv(program, gl::LINK_STATUS) == 1
+        log = gl.get_program_info_log(program)
+        warn "Program link error: #{log}"
+        gl.delete_shader(vertex_shader)
+        gl.delete_shader(fragment_shader)
+        gl.delete_program(program)
+        return nil
+      end
+
+      gl.delete_shader(vertex_shader)
+      gl.delete_shader(fragment_shader)
+
+      program
+    end
+
+    def get_or_create_geometry(geometry)
+      @gpu_geometries ||= {}
+
+      geo_id = geometry.object_id
+      return @gpu_geometries[geo_id] if @gpu_geometries[geo_id]
+
+      position_attr = geometry.get_attribute(:position)
+      return nil unless position_attr
+
+      gl = Native::GL
+
+      vao = gl.gen_vertex_arrays(1).first
+      gl.bind_vertex_array(vao)
+
+      vbo = gl.gen_buffers(1).first
+      gl.bind_buffer(gl::ARRAY_BUFFER, vbo)
+      gl.buffer_data(gl::ARRAY_BUFFER, position_attr.array, gl::STATIC_DRAW)
+      gl.vertex_attrib_pointer(0, 3, gl::FLOAT, false, 0, 0)
+      gl.enable_vertex_attrib_array(0)
+
+      normal_attr = geometry.get_attribute(:normal)
+      if normal_attr
+        normal_vbo = gl.gen_buffers(1).first
+        gl.bind_buffer(gl::ARRAY_BUFFER, normal_vbo)
+        gl.buffer_data(gl::ARRAY_BUFFER, normal_attr.array, gl::STATIC_DRAW)
+        gl.vertex_attrib_pointer(1, 3, gl::FLOAT, false, 0, 0)
+        gl.enable_vertex_attrib_array(1)
+      end
+
+      uv_attr = geometry.get_attribute(:uv)
+      if uv_attr
+        uv_vbo = gl.gen_buffers(1).first
+        gl.bind_buffer(gl::ARRAY_BUFFER, uv_vbo)
+        gl.buffer_data(gl::ARRAY_BUFFER, uv_attr.array, gl::STATIC_DRAW)
+        gl.vertex_attrib_pointer(2, 2, gl::FLOAT, false, 0, 0)
+        gl.enable_vertex_attrib_array(2)
+      end
+
+      ebo = nil
+      if geometry.index
+        ebo = gl.gen_buffers(1).first
+        gl.bind_buffer(gl::ELEMENT_ARRAY_BUFFER, ebo)
+        gl.buffer_data_uint(gl::ELEMENT_ARRAY_BUFFER, geometry.index.array, gl::STATIC_DRAW)
+      end
+
+      gl.bind_vertex_array(0)
+
+      @gpu_geometries[geo_id] = { vao: vao, vbo: vbo, ebo: ebo }
+    end
+
+    def set_uniform_matrix4(program, name, matrix)
+      gl = Native::GL
+      location = gl.get_uniform_location(program, name)
+      return if location < 0
+
+      gl.uniform_matrix4fv(location, false, matrix.elements)
+    end
+
+    def set_uniform_matrix3(program, name, matrix)
+      gl = Native::GL
+      location = gl.get_uniform_location(program, name)
+      return if location < 0
+
+      gl.uniform_matrix3fv(location, false, matrix.elements)
+    end
+
+    def set_uniform_vec3(program, name, vec)
+      gl = Native::GL
+      location = gl.get_uniform_location(program, name)
+      return if location < 0
+
+      if vec.is_a?(Color)
+        gl.uniform_3f(location, vec.r, vec.g, vec.b)
+      else
+        gl.uniform_3f(location, vec.x, vec.y, vec.z)
+      end
+    end
+
+    def set_uniform_vec2(program, name, vec)
+      gl = Native::GL
+      location = gl.get_uniform_location(program, name)
+      return if location < 0
+
+      gl.uniform_2f(location, vec.x, vec.y)
+    end
+
+    def set_uniform_float(program, name, value)
+      gl = Native::GL
+      location = gl.get_uniform_location(program, name)
+      return if location < 0
+
+      gl.uniform_1f(location, value)
+    end
+
+    def set_uniform_int(program, name, value)
+      gl = Native::GL
+      location = gl.get_uniform_location(program, name)
+      return if location < 0
+
+      gl.uniform_1i(location, value)
+    end
+
+    def set_material_uniforms(program, material, lights)
+      if material.is_a?(ShaderMaterial)
+        set_shader_material_uniforms(program, material)
+        return
+      end
+
+      color = material.color || Color.new(0xffffff)
+      set_uniform_vec3(program, "diffuse", color)
+      set_uniform_float(program, "opacity", material.respond_to?(:opacity) ? material.opacity : 1.0)
+      set_uniform_int(program, "useMap", 0)
+
+      if material.respond_to?(:emissive) && material.emissive
+        set_uniform_vec3(program, "emissive", material.emissive)
+      end
+
+      if material.respond_to?(:roughness)
+        set_uniform_float(program, "roughness", material.roughness)
+      end
+
+      if material.respond_to?(:metalness)
+        set_uniform_float(program, "metalness", material.metalness)
+      end
+
+      set_uniform_vec3(program, "ambientLightColor", lights[:ambient])
+
+      if lights[:directional].any?
+        light = lights[:directional].first
+        set_uniform_vec3(program, "directionalLightDirection", light[:direction])
+        set_uniform_vec3(program, "directionalLightColor", light[:color])
+      end
+    end
+
+    def set_shader_material_uniforms(program, material)
+      return unless material.uniforms
+
+      material.uniforms.each do |name, value|
+        case value
+        when Float, Integer
+          set_uniform_float(program, name.to_s, value.to_f)
+        when Vector2
+          set_uniform_vec2(program, name.to_s, value)
+        when Vector3
+          set_uniform_vec3(program, name.to_s, value)
+        when Color
+          set_uniform_vec3(program, name.to_s, value)
+        when Matrix4
+          set_uniform_matrix4(program, name.to_s, value)
+        end
+      end
+    end
+  end
+end

data/lib/3rb/renderers/renderer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Renderer
+    attr_accessor :auto_clear, :auto_clear_color, :auto_clear_depth, :auto_clear_stencil
+    attr_accessor :sort_objects
+    attr_reader :clear_color, :clear_alpha
+    attr_reader :width, :height, :pixel_ratio
+
+    def initialize(width: 800, height: 600)
+      @width = width
+      @height = height
+      @pixel_ratio = 1.0
+
+      @clear_color = Color.new(0, 0, 0)
+      @clear_alpha = 1.0
+
+      @auto_clear = true
+      @auto_clear_color = true
+      @auto_clear_depth = true
+      @auto_clear_stencil = true
+
+      @sort_objects = true
+    end
+
+    def set_size(width, height)
+      @width = width
+      @height = height
+    end
+
+    def set_pixel_ratio(value)
+      @pixel_ratio = value
+    end
+
+    def set_clear_color(color, alpha = 1.0)
+      @clear_color = color.is_a?(Color) ? color : Color.new(color)
+      @clear_alpha = alpha
+    end
+
+    def get_size
+      [@width, @height]
+    end
+
+    def get_drawing_buffer_size
+      [(@width * @pixel_ratio).to_i, (@height * @pixel_ratio).to_i]
+    end
+
+    def render(_scene, _camera)
+      raise NotImplementedError, "Subclasses must implement render"
+    end
+
+    def clear(_color: true, _depth: true, _stencil: true)
+      raise NotImplementedError, "Subclasses must implement clear"
+    end
+
+    def dispose
+      raise NotImplementedError, "Subclasses must implement dispose"
+    end
+  end
+end