3rb 0.1.0

data/lib/3rb/native/gl.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+module Sunrb
+  module Native
+    module GL
+      class << self
+        def clear_color(r, g, b, a)
+          FFI::OpenGL.glClearColor(r, g, b, a)
+          nil
+        end
+
+        def clear(mask)
+          FFI::OpenGL.glClear(mask)
+          nil
+        end
+
+        def viewport(x, y, width, height)
+          FFI::OpenGL.glViewport(x, y, width, height)
+          nil
+        end
+
+        def enable(cap)
+          FFI::OpenGL.glEnable(cap)
+          nil
+        end
+
+        def disable(cap)
+          FFI::OpenGL.glDisable(cap)
+          nil
+        end
+
+        def depth_func(func)
+          FFI::OpenGL.glDepthFunc(func)
+          nil
+        end
+
+        def blend_func(sfactor, dfactor)
+          FFI::OpenGL.glBlendFunc(sfactor, dfactor)
+          nil
+        end
+
+        def cull_face(mode)
+          FFI::OpenGL.glCullFace(mode)
+          nil
+        end
+
+        def front_face(mode)
+          FFI::OpenGL.glFrontFace(mode)
+          nil
+        end
+
+        def get_error
+          FFI::OpenGL.glGetError
+        end
+
+        def get_string(name)
+          ptr = FFI::OpenGL.glGetString(name)
+          return nil if ptr.nil? || ptr.null?
+
+          ptr.read_string
+        end
+
+        def polygon_mode(face, mode)
+          FFI::OpenGL.glPolygonMode(face, mode)
+          nil
+        end
+
+        def line_width(width)
+          FFI::OpenGL.glLineWidth(width)
+          nil
+        end
+
+        def create_shader(type)
+          FFI::OpenGL.glCreateShader(type)
+        end
+
+        def shader_source(shader, source)
+          src_ptr = ::FFI::MemoryPointer.from_string(source)
+          src_ptr_ptr = ::FFI::MemoryPointer.new(:pointer)
+          src_ptr_ptr.write_pointer(src_ptr)
+
+          len_ptr = ::FFI::MemoryPointer.new(:int)
+          len_ptr.write_int(source.bytesize)
+
+          FFI::OpenGL.glShaderSource(shader, 1, src_ptr_ptr, len_ptr)
+          nil
+        end
+
+        def compile_shader(shader)
+          FFI::OpenGL.glCompileShader(shader)
+          nil
+        end
+
+        def get_shader_iv(shader, pname)
+          result_ptr = ::FFI::MemoryPointer.new(:int)
+          FFI::OpenGL.glGetShaderiv(shader, pname, result_ptr)
+          result_ptr.read_int
+        end
+
+        def get_shader_info_log(shader)
+          length = get_shader_iv(shader, FFI::OpenGL::GL_INFO_LOG_LENGTH)
+          return "" if length <= 0
+
+          log_ptr = ::FFI::MemoryPointer.new(:char, length)
+          FFI::OpenGL.glGetShaderInfoLog(shader, length, nil, log_ptr)
+          log_ptr.read_string
+        end
+
+        def delete_shader(shader)
+          FFI::OpenGL.glDeleteShader(shader)
+          nil
+        end
+
+        def create_program
+          FFI::OpenGL.glCreateProgram
+        end
+
+        def attach_shader(program, shader)
+          FFI::OpenGL.glAttachShader(program, shader)
+          nil
+        end
+
+        def link_program(program)
+          FFI::OpenGL.glLinkProgram(program)
+          nil
+        end
+
+        def get_program_iv(program, pname)
+          result_ptr = ::FFI::MemoryPointer.new(:int)
+          FFI::OpenGL.glGetProgramiv(program, pname, result_ptr)
+          result_ptr.read_int
+        end
+
+        def get_program_info_log(program)
+          length = get_program_iv(program, FFI::OpenGL::GL_INFO_LOG_LENGTH)
+          return "" if length <= 0
+
+          log_ptr = ::FFI::MemoryPointer.new(:char, length)
+          FFI::OpenGL.glGetProgramInfoLog(program, length, nil, log_ptr)
+          log_ptr.read_string
+        end
+
+        def use_program(program)
+          FFI::OpenGL.glUseProgram(program)
+          nil
+        end
+
+        def delete_program(program)
+          FFI::OpenGL.glDeleteProgram(program)
+          nil
+        end
+
+        def get_uniform_location(program, name)
+          FFI::OpenGL.glGetUniformLocation(program, name)
+        end
+
+        def uniform_1f(location, v0)
+          FFI::OpenGL.glUniform1f(location, v0)
+          nil
+        end
+
+        def uniform_2f(location, v0, v1)
+          FFI::OpenGL.glUniform2f(location, v0, v1)
+          nil
+        end
+
+        def uniform_3f(location, v0, v1, v2)
+          FFI::OpenGL.glUniform3f(location, v0, v1, v2)
+          nil
+        end
+
+        def uniform_4f(location, v0, v1, v2, v3)
+          FFI::OpenGL.glUniform4f(location, v0, v1, v2, v3)
+          nil
+        end
+
+        def uniform_1i(location, v0)
+          FFI::OpenGL.glUniform1i(location, v0)
+          nil
+        end
+
+        def uniform_matrix4fv(location, transpose, value)
+          buffer = ::FFI::MemoryPointer.new(:float, 16)
+          buffer.write_array_of_float(value.map(&:to_f))
+          FFI::OpenGL.glUniformMatrix4fv(location, 1, transpose ? 1 : 0, buffer)
+          nil
+        end
+
+        def uniform_matrix3fv(location, transpose, value)
+          buffer = ::FFI::MemoryPointer.new(:float, 9)
+          buffer.write_array_of_float(value.map(&:to_f))
+          FFI::OpenGL.glUniformMatrix3fv(location, 1, transpose ? 1 : 0, buffer)
+          nil
+        end
+
+        def gen_vertex_arrays(n)
+          buffer = ::FFI::MemoryPointer.new(:uint, n)
+          FFI::OpenGL.glGenVertexArrays(n, buffer)
+          buffer.read_array_of_uint(n)
+        end
+
+        def bind_vertex_array(array)
+          FFI::OpenGL.glBindVertexArray(array)
+          nil
+        end
+
+        def delete_vertex_arrays(arrays)
+          arrays = Array(arrays)
+          buffer = ::FFI::MemoryPointer.new(:uint, arrays.length)
+          buffer.write_array_of_uint(arrays)
+          FFI::OpenGL.glDeleteVertexArrays(arrays.length, buffer)
+          nil
+        end
+
+        def gen_buffers(n)
+          buffer = ::FFI::MemoryPointer.new(:uint, n)
+          FFI::OpenGL.glGenBuffers(n, buffer)
+          buffer.read_array_of_uint(n)
+        end
+
+        def bind_buffer(target, buffer)
+          FFI::OpenGL.glBindBuffer(target, buffer)
+          nil
+        end
+
+        def buffer_data(target, data, usage)
+          data = data.map(&:to_f)
+          buffer = ::FFI::MemoryPointer.new(:float, data.length)
+          buffer.write_array_of_float(data)
+          FFI::OpenGL.glBufferData(target, data.length * 4, buffer, usage)
+          nil
+        end
+
+        def buffer_data_uint(target, data, usage)
+          data = data.map(&:to_i)
+          buffer = ::FFI::MemoryPointer.new(:uint, data.length)
+          buffer.write_array_of_uint(data)
+          FFI::OpenGL.glBufferData(target, data.length * 4, buffer, usage)
+          nil
+        end
+
+        def delete_buffers(buffers)
+          buffers = Array(buffers)
+          buffer = ::FFI::MemoryPointer.new(:uint, buffers.length)
+          buffer.write_array_of_uint(buffers)
+          FFI::OpenGL.glDeleteBuffers(buffers.length, buffer)
+          nil
+        end
+
+        def vertex_attrib_pointer(index, size, type, normalized, stride, offset)
+          offset_ptr = ::FFI::Pointer.new(:void, offset)
+          FFI::OpenGL.glVertexAttribPointer(index, size, type, normalized ? 1 : 0, stride, offset_ptr)
+          nil
+        end
+
+        def enable_vertex_attrib_array(index)
+          FFI::OpenGL.glEnableVertexAttribArray(index)
+          nil
+        end
+
+        def disable_vertex_attrib_array(index)
+          FFI::OpenGL.glDisableVertexAttribArray(index)
+          nil
+        end
+
+        def draw_arrays(mode, first, count)
+          FFI::OpenGL.glDrawArrays(mode, first, count)
+          nil
+        end
+
+        def draw_elements(mode, count, type, offset)
+          offset_ptr = ::FFI::Pointer.new(:void, offset)
+          FFI::OpenGL.glDrawElements(mode, count, type, offset_ptr)
+          nil
+        end
+
+        def gen_textures(n)
+          buffer = ::FFI::MemoryPointer.new(:uint, n)
+          FFI::OpenGL.glGenTextures(n, buffer)
+          buffer.read_array_of_uint(n)
+        end
+
+        def bind_texture(target, texture)
+          FFI::OpenGL.glBindTexture(target, texture)
+          nil
+        end
+
+        def tex_parameter_i(target, pname, param)
+          FFI::OpenGL.glTexParameteri(target, pname, param)
+          nil
+        end
+
+        def active_texture(texture)
+          FFI::OpenGL.glActiveTexture(texture)
+          nil
+        end
+
+        def delete_textures(textures)
+          textures = Array(textures)
+          buffer = ::FFI::MemoryPointer.new(:uint, textures.length)
+          buffer.write_array_of_uint(textures)
+          FFI::OpenGL.glDeleteTextures(textures.length, buffer)
+          nil
+        end
+
+        def tex_image_2d(target, level, internal_format, width, height, border, format, type, data)
+          if data.nil?
+            FFI::OpenGL.glTexImage2D(target, level, internal_format, width, height, border, format, type, nil)
+          else
+            data = data.map(&:to_i)
+            buffer = ::FFI::MemoryPointer.new(:uchar, data.length)
+            buffer.write_array_of_uchar(data)
+            FFI::OpenGL.glTexImage2D(target, level, internal_format, width, height, border, format, type, buffer)
+          end
+          nil
+        end
+      end
+
+      COLOR_BUFFER_BIT = FFI::OpenGL::GL_COLOR_BUFFER_BIT
+      DEPTH_BUFFER_BIT = FFI::OpenGL::GL_DEPTH_BUFFER_BIT
+      STENCIL_BUFFER_BIT = FFI::OpenGL::GL_STENCIL_BUFFER_BIT
+
+      DEPTH_TEST = FFI::OpenGL::GL_DEPTH_TEST
+      BLEND = FFI::OpenGL::GL_BLEND
+      CULL_FACE = FFI::OpenGL::GL_CULL_FACE
+
+      LESS = FFI::OpenGL::GL_LESS
+      LEQUAL = FFI::OpenGL::GL_LEQUAL
+      GREATER = FFI::OpenGL::GL_GREATER
+
+      SRC_ALPHA = FFI::OpenGL::GL_SRC_ALPHA
+      ONE_MINUS_SRC_ALPHA = FFI::OpenGL::GL_ONE_MINUS_SRC_ALPHA
+
+      FRONT = FFI::OpenGL::GL_FRONT
+      BACK = FFI::OpenGL::GL_BACK
+      FRONT_AND_BACK = FFI::OpenGL::GL_FRONT_AND_BACK
+      LINE = FFI::OpenGL::GL_LINE
+      FILL = FFI::OpenGL::GL_FILL
+
+      CW = FFI::OpenGL::GL_CW
+      CCW = FFI::OpenGL::GL_CCW
+
+      VERTEX_SHADER = FFI::OpenGL::GL_VERTEX_SHADER
+      FRAGMENT_SHADER = FFI::OpenGL::GL_FRAGMENT_SHADER
+      COMPILE_STATUS = FFI::OpenGL::GL_COMPILE_STATUS
+      LINK_STATUS = FFI::OpenGL::GL_LINK_STATUS
+
+      ARRAY_BUFFER = FFI::OpenGL::GL_ARRAY_BUFFER
+      ELEMENT_ARRAY_BUFFER = FFI::OpenGL::GL_ELEMENT_ARRAY_BUFFER
+      STATIC_DRAW = FFI::OpenGL::GL_STATIC_DRAW
+      DYNAMIC_DRAW = FFI::OpenGL::GL_DYNAMIC_DRAW
+
+      FLOAT = FFI::OpenGL::GL_FLOAT
+      UNSIGNED_INT = FFI::OpenGL::GL_UNSIGNED_INT
+      UNSIGNED_BYTE = FFI::OpenGL::GL_UNSIGNED_BYTE
+
+      TRIANGLES = FFI::OpenGL::GL_TRIANGLES
+      LINES = FFI::OpenGL::GL_LINES
+      POINTS = FFI::OpenGL::GL_POINTS
+
+      TEXTURE_2D = FFI::OpenGL::GL_TEXTURE_2D
+      TEXTURE0 = FFI::OpenGL::GL_TEXTURE0
+      TEXTURE_MIN_FILTER = FFI::OpenGL::GL_TEXTURE_MIN_FILTER
+      TEXTURE_MAG_FILTER = FFI::OpenGL::GL_TEXTURE_MAG_FILTER
+      TEXTURE_WRAP_S = FFI::OpenGL::GL_TEXTURE_WRAP_S
+      TEXTURE_WRAP_T = FFI::OpenGL::GL_TEXTURE_WRAP_T
+      LINEAR = FFI::OpenGL::GL_LINEAR
+      NEAREST = FFI::OpenGL::GL_NEAREST
+      REPEAT = FFI::OpenGL::GL_REPEAT
+      CLAMP_TO_EDGE = FFI::OpenGL::GL_CLAMP_TO_EDGE
+      RGBA = FFI::OpenGL::GL_RGBA
+      RGB = FFI::OpenGL::GL_RGB
+
+      VENDOR = FFI::OpenGL::GL_VENDOR
+      RENDERER = FFI::OpenGL::GL_RENDERER
+      VERSION = FFI::OpenGL::GL_VERSION
+
+      TRUE = FFI::OpenGL::GL_TRUE
+      FALSE = FFI::OpenGL::GL_FALSE
+    end
+  end
+end

data/lib/3rb/native/native.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Sunrb
+  module Native
+    @glfw_initialized = false
+
+    class << self
+      def init_glfw
+        return true if @glfw_initialized
+
+        result = FFI::GLFW.glfwInit
+        raise RuntimeError, "Failed to initialize GLFW" if result == 0
+
+        @glfw_initialized = true
+        true
+      end
+
+      def terminate_glfw
+        return unless @glfw_initialized
+
+        FFI::GLFW.glfwTerminate
+        @glfw_initialized = false
+        nil
+      end
+
+      def poll_events
+        FFI::GLFW.glfwPollEvents
+        nil
+      end
+
+      def get_time
+        FFI::GLFW.glfwGetTime
+      end
+    end
+
+    KEY_ESCAPE = FFI::GLFW::KEY_ESCAPE
+    KEY_SPACE = FFI::GLFW::KEY_SPACE
+    KEY_W = FFI::GLFW::KEY_W
+    KEY_A = FFI::GLFW::KEY_A
+    KEY_S = FFI::GLFW::KEY_S
+    KEY_D = FFI::GLFW::KEY_D
+    KEY_UP = FFI::GLFW::KEY_UP
+    KEY_DOWN = FFI::GLFW::KEY_DOWN
+    KEY_LEFT = FFI::GLFW::KEY_LEFT
+    KEY_RIGHT = FFI::GLFW::KEY_RIGHT
+
+    MOUSE_BUTTON_LEFT = FFI::GLFW::MOUSE_BUTTON_LEFT
+    MOUSE_BUTTON_RIGHT = FFI::GLFW::MOUSE_BUTTON_RIGHT
+    MOUSE_BUTTON_MIDDLE = FFI::GLFW::MOUSE_BUTTON_MIDDLE
+
+    PRESS = FFI::GLFW::PRESS
+    RELEASE = FFI::GLFW::RELEASE
+    REPEAT = FFI::GLFW::REPEAT
+  end
+end

data/lib/3rb/native/window.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Sunrb
+  module Native
+    class Window
+      def initialize(width, height, title)
+        FFI::GLFW.glfwWindowHint(FFI::GLFW::CONTEXT_VERSION_MAJOR, 3)
+        FFI::GLFW.glfwWindowHint(FFI::GLFW::CONTEXT_VERSION_MINOR, 3)
+        FFI::GLFW.glfwWindowHint(FFI::GLFW::OPENGL_PROFILE, FFI::GLFW::OPENGL_CORE_PROFILE)
+
+        if FFI::Platform.os == :macos
+          FFI::GLFW.glfwWindowHint(FFI::GLFW::OPENGL_FORWARD_COMPAT, 1)
+        end
+
+        @handle = FFI::GLFW.glfwCreateWindow(width, height, title, nil, nil)
+        raise RuntimeError, "Failed to create GLFW window" if @handle.nil? || @handle.null?
+
+        FFI::GLFW.glfwMakeContextCurrent(@handle)
+        FFI::GLFW.glfwSwapInterval(1)
+
+        @width = width
+        @height = height
+      end
+
+      def should_close?
+        return true if @handle.nil? || @handle.null?
+
+        FFI::GLFW.glfwWindowShouldClose(@handle) != 0
+      end
+
+      def should_close=(value)
+        return if @handle.nil? || @handle.null?
+
+        FFI::GLFW.glfwSetWindowShouldClose(@handle, value ? 1 : 0)
+      end
+
+      def swap_buffers
+        return if @handle.nil? || @handle.null?
+
+        FFI::GLFW.glfwSwapBuffers(@handle)
+      end
+
+      def make_current
+        return if @handle.nil? || @handle.null?
+
+        FFI::GLFW.glfwMakeContextCurrent(@handle)
+      end
+
+      def width
+        update_framebuffer_size
+        @fb_width || 0
+      end
+
+      def height
+        update_framebuffer_size
+        @fb_height || 0
+      end
+
+      def size
+        update_framebuffer_size
+        [@fb_width || 0, @fb_height || 0]
+      end
+
+      def title=(title)
+        return if @handle.nil? || @handle.null?
+
+        FFI::GLFW.glfwSetWindowTitle(@handle, title)
+      end
+
+      def get_key(key)
+        return FFI::GLFW::RELEASE if @handle.nil? || @handle.null?
+
+        FFI::GLFW.glfwGetKey(@handle, key)
+      end
+
+      def get_mouse_button(button)
+        return FFI::GLFW::RELEASE if @handle.nil? || @handle.null?
+
+        FFI::GLFW.glfwGetMouseButton(@handle, button)
+      end
+
+      def cursor_pos
+        return [0.0, 0.0] if @handle.nil? || @handle.null?
+
+        x_ptr = ::FFI::MemoryPointer.new(:double)
+        y_ptr = ::FFI::MemoryPointer.new(:double)
+        FFI::GLFW.glfwGetCursorPos(@handle, x_ptr, y_ptr)
+        [x_ptr.read_double, y_ptr.read_double]
+      end
+
+      def destroy
+        if @handle && !@handle.null?
+          FFI::GLFW.glfwDestroyWindow(@handle)
+          @handle = nil
+        end
+      end
+
+      private
+
+      def update_framebuffer_size
+        return unless @handle && !@handle.null?
+
+        w_ptr = ::FFI::MemoryPointer.new(:int)
+        h_ptr = ::FFI::MemoryPointer.new(:int)
+        FFI::GLFW.glfwGetFramebufferSize(@handle, w_ptr, h_ptr)
+        @fb_width = w_ptr.read_int
+        @fb_height = h_ptr.read_int
+      end
+    end
+  end
+end

data/lib/3rb/native.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "ffi"
+require_relative "ffi/platform"
+require_relative "ffi/glfw"
+require_relative "ffi/opengl"
+require_relative "native/native"
+require_relative "native/window"
+require_relative "native/gl"

data/lib/3rb/objects/line.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class LineBasicMaterial < Material
+    attr_accessor :color, :linewidth, :linecap, :linejoin
+
+    def initialize(color: 0xffffff, linewidth: 1)
+      super()
+      @color = color.is_a?(Color) ? color : Color.new(color)
+      @linewidth = linewidth
+      @linecap = "round"
+      @linejoin = "round"
+      @lights = false
+    end
+
+    def copy(source)
+      super
+      @color = source.color.clone
+      @linewidth = source.linewidth
+      @linecap = source.linecap
+      @linejoin = source.linejoin
+      self
+    end
+
+    def to_h
+      super.merge(
+        color: @color.get_hex,
+        linewidth: @linewidth
+      )
+    end
+  end
+
+  class Line < Object3D
+    attr_accessor :geometry, :material
+
+    def initialize(geometry = nil, material = nil)
+      super()
+      @geometry = geometry || BufferGeometry.new
+      @material = material || LineBasicMaterial.new
+    end
+
+    def copy(source, recursive = true)
+      super
+      @material = source.material.clone
+      @geometry = source.geometry.clone
+      self
+    end
+
+    def clone(recursive = true)
+      new_line = super
+      new_line.geometry = @geometry.clone
+      new_line.material = @material.clone
+      new_line
+    end
+
+    def compute_line_distances
+      position = @geometry.get_attribute(:position)
+      return self unless position
+
+      line_distances = [0.0]
+
+      (1...position.count).each do |i|
+        p1 = Vector3.new(
+          position.get_x(i - 1),
+          position.get_y(i - 1),
+          position.get_z(i - 1)
+        )
+        p2 = Vector3.new(
+          position.get_x(i),
+          position.get_y(i),
+          position.get_z(i)
+        )
+        line_distances.push(line_distances.last + p1.distance_to(p2))
+      end
+
+      @geometry.set_attribute(:line_distance, Float32BufferAttribute.new(line_distances, 1))
+      self
+    end
+
+    def to_h
+      super.merge(
+        geometry: @geometry.uuid,
+        material: @material.uuid
+      )
+    end
+  end
+
+  class LineLoop < Line
+  end
+
+  class LineSegments < Line
+    def compute_line_distances
+      position = @geometry.get_attribute(:position)
+      return self unless position
+
+      line_distances = []
+
+      (0...position.count).step(2) do |i|
+        p1 = Vector3.new(
+          position.get_x(i),
+          position.get_y(i),
+          position.get_z(i)
+        )
+        p2 = Vector3.new(
+          position.get_x(i + 1),
+          position.get_y(i + 1),
+          position.get_z(i + 1)
+        )
+        line_distances.push(0, p1.distance_to(p2))
+      end
+
+      @geometry.set_attribute(:line_distance, Float32BufferAttribute.new(line_distances, 1))
+      self
+    end
+  end
+end

data/lib/3rb/objects/mesh.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Mesh < Object3D
+    attr_accessor :geometry, :material
+
+    def initialize(geometry = nil, material = nil)
+      super()
+      @geometry = geometry || BufferGeometry.new
+      @material = material || MeshBasicMaterial.new
+    end
+
+    def copy(source, recursive = true)
+      super
+      @material = source.material.is_a?(Array) ? source.material.map(&:clone) : source.material.clone
+      @geometry = source.geometry.clone
+      self
+    end
+
+    def clone(recursive = true)
+      new_mesh = super
+      new_mesh.geometry = @geometry.clone
+      new_mesh.material = @material.is_a?(Array) ? @material.map(&:clone) : @material.clone
+      new_mesh
+    end
+
+    def raycast(_raycaster, _intersects)
+    end
+
+    def update_morph_targets
+    end
+
+    def to_h
+      super.merge(
+        geometry: @geometry.uuid,
+        material: @material.is_a?(Array) ? @material.map(&:uuid) : @material.uuid
+      )
+    end
+  end
+end