3rb 0.1.0

data/lib/3rb/ffi/glfw.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Sunrb
+  module FFI
+    module GLFW
+      extend ::FFI::Library
+
+      ffi_lib Platform.glfw_lib
+
+      CONTEXT_VERSION_MAJOR = 0x00022002
+      CONTEXT_VERSION_MINOR = 0x00022003
+      OPENGL_PROFILE = 0x00022008
+      OPENGL_CORE_PROFILE = 0x00032001
+      OPENGL_FORWARD_COMPAT = 0x00022006
+      SAMPLES = 0x0002100D
+      COCOA_RETINA_FRAMEBUFFER = 0x00023001
+
+      PRESS = 1
+      RELEASE = 0
+      REPEAT = 2
+
+      KEY_ESCAPE = 256
+      KEY_SPACE = 32
+      KEY_W = 87
+      KEY_A = 65
+      KEY_S = 83
+      KEY_D = 68
+      KEY_UP = 265
+      KEY_DOWN = 264
+      KEY_LEFT = 263
+      KEY_RIGHT = 262
+
+      MOUSE_BUTTON_LEFT = 0
+      MOUSE_BUTTON_RIGHT = 1
+      MOUSE_BUTTON_MIDDLE = 2
+
+      callback :error_callback, [:int, :string], :void
+
+      attach_function :glfwInit, [], :int
+      attach_function :glfwTerminate, [], :void
+      attach_function :glfwSetErrorCallback, [:error_callback], :pointer
+      attach_function :glfwWindowHint, [:int, :int], :void
+      attach_function :glfwCreateWindow, [:int, :int, :string, :pointer, :pointer], :pointer
+      attach_function :glfwDestroyWindow, [:pointer], :void
+      attach_function :glfwWindowShouldClose, [:pointer], :int
+      attach_function :glfwSetWindowShouldClose, [:pointer, :int], :void
+      attach_function :glfwSetWindowTitle, [:pointer, :string], :void
+      attach_function :glfwMakeContextCurrent, [:pointer], :void
+      attach_function :glfwSwapInterval, [:int], :void
+      attach_function :glfwSwapBuffers, [:pointer], :void
+      attach_function :glfwPollEvents, [], :void
+      attach_function :glfwGetKey, [:pointer, :int], :int
+      attach_function :glfwGetMouseButton, [:pointer, :int], :int
+      attach_function :glfwGetCursorPos, [:pointer, :pointer, :pointer], :void
+      attach_function :glfwGetFramebufferSize, [:pointer, :pointer, :pointer], :void
+      attach_function :glfwGetTime, [], :double
+    end
+  end
+end

data/lib/3rb/ffi/opengl.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Sunrb
+  module FFI
+    module OpenGL
+      extend ::FFI::Library
+
+      ffi_lib Platform.opengl_lib
+
+      GL_TRUE = 1
+      GL_FALSE = 0
+
+      GL_COLOR_BUFFER_BIT = 0x00004000
+      GL_DEPTH_BUFFER_BIT = 0x00000100
+      GL_STENCIL_BUFFER_BIT = 0x00000400
+
+      GL_DEPTH_TEST = 0x0B71
+      GL_BLEND = 0x0BE2
+      GL_CULL_FACE = 0x0B44
+
+      GL_LESS = 0x0201
+      GL_LEQUAL = 0x0203
+      GL_GREATER = 0x0204
+
+      GL_SRC_ALPHA = 0x0302
+      GL_ONE_MINUS_SRC_ALPHA = 0x0303
+
+      GL_FRONT = 0x0404
+      GL_BACK = 0x0405
+      GL_FRONT_AND_BACK = 0x0408
+      GL_LINE = 0x1B01
+      GL_FILL = 0x1B02
+
+      GL_CW = 0x0900
+      GL_CCW = 0x0901
+
+      GL_VERTEX_SHADER = 0x8B31
+      GL_FRAGMENT_SHADER = 0x8B30
+      GL_COMPILE_STATUS = 0x8B81
+      GL_LINK_STATUS = 0x8B82
+      GL_INFO_LOG_LENGTH = 0x8B84
+
+      GL_ARRAY_BUFFER = 0x8892
+      GL_ELEMENT_ARRAY_BUFFER = 0x8893
+      GL_STATIC_DRAW = 0x88E4
+      GL_DYNAMIC_DRAW = 0x88E8
+
+      GL_FLOAT = 0x1406
+      GL_UNSIGNED_INT = 0x1405
+      GL_UNSIGNED_BYTE = 0x1401
+
+      GL_TRIANGLES = 0x0004
+      GL_LINES = 0x0001
+      GL_POINTS = 0x0000
+
+      GL_TEXTURE_2D = 0x0DE1
+      GL_TEXTURE0 = 0x84C0
+      GL_TEXTURE_MIN_FILTER = 0x2801
+      GL_TEXTURE_MAG_FILTER = 0x2800
+      GL_TEXTURE_WRAP_S = 0x2802
+      GL_TEXTURE_WRAP_T = 0x2803
+      GL_LINEAR = 0x2601
+      GL_NEAREST = 0x2600
+      GL_REPEAT = 0x2901
+      GL_CLAMP_TO_EDGE = 0x812F
+      GL_RGBA = 0x1908
+      GL_RGB = 0x1907
+
+      GL_VENDOR = 0x1F00
+      GL_RENDERER = 0x1F01
+      GL_VERSION = 0x1F02
+
+      attach_function :glClearColor, [:float, :float, :float, :float], :void
+      attach_function :glClear, [:uint], :void
+      attach_function :glViewport, [:int, :int, :int, :int], :void
+      attach_function :glEnable, [:uint], :void
+      attach_function :glDisable, [:uint], :void
+      attach_function :glDepthFunc, [:uint], :void
+      attach_function :glBlendFunc, [:uint, :uint], :void
+      attach_function :glCullFace, [:uint], :void
+      attach_function :glFrontFace, [:uint], :void
+      attach_function :glGetError, [], :uint
+      attach_function :glGetString, [:uint], :pointer
+      attach_function :glPolygonMode, [:uint, :uint], :void
+      attach_function :glLineWidth, [:float], :void
+
+      attach_function :glCreateShader, [:uint], :uint
+      attach_function :glShaderSource, [:uint, :int, :pointer, :pointer], :void
+      attach_function :glCompileShader, [:uint], :void
+      attach_function :glGetShaderiv, [:uint, :uint, :pointer], :void
+      attach_function :glGetShaderInfoLog, [:uint, :int, :pointer, :pointer], :void
+      attach_function :glDeleteShader, [:uint], :void
+
+      attach_function :glCreateProgram, [], :uint
+      attach_function :glAttachShader, [:uint, :uint], :void
+      attach_function :glLinkProgram, [:uint], :void
+      attach_function :glGetProgramiv, [:uint, :uint, :pointer], :void
+      attach_function :glGetProgramInfoLog, [:uint, :int, :pointer, :pointer], :void
+      attach_function :glUseProgram, [:uint], :void
+      attach_function :glDeleteProgram, [:uint], :void
+
+      attach_function :glGetUniformLocation, [:uint, :string], :int
+      attach_function :glUniform1f, [:int, :float], :void
+      attach_function :glUniform2f, [:int, :float, :float], :void
+      attach_function :glUniform3f, [:int, :float, :float, :float], :void
+      attach_function :glUniform4f, [:int, :float, :float, :float, :float], :void
+      attach_function :glUniform1i, [:int, :int], :void
+      attach_function :glUniformMatrix4fv, [:int, :int, :uchar, :pointer], :void
+      attach_function :glUniformMatrix3fv, [:int, :int, :uchar, :pointer], :void
+
+      attach_function :glGenVertexArrays, [:int, :pointer], :void
+      attach_function :glBindVertexArray, [:uint], :void
+      attach_function :glDeleteVertexArrays, [:int, :pointer], :void
+
+      attach_function :glGenBuffers, [:int, :pointer], :void
+      attach_function :glBindBuffer, [:uint, :uint], :void
+      attach_function :glBufferData, [:uint, :long, :pointer, :uint], :void
+      attach_function :glDeleteBuffers, [:int, :pointer], :void
+
+      attach_function :glVertexAttribPointer, [:uint, :int, :uint, :uchar, :int, :pointer], :void
+      attach_function :glEnableVertexAttribArray, [:uint], :void
+      attach_function :glDisableVertexAttribArray, [:uint], :void
+
+      attach_function :glDrawArrays, [:uint, :int, :int], :void
+      attach_function :glDrawElements, [:uint, :int, :uint, :pointer], :void
+
+      attach_function :glGenTextures, [:int, :pointer], :void
+      attach_function :glBindTexture, [:uint, :uint], :void
+      attach_function :glTexParameteri, [:uint, :uint, :int], :void
+      attach_function :glActiveTexture, [:uint], :void
+      attach_function :glDeleteTextures, [:int, :pointer], :void
+      attach_function :glTexImage2D, [:uint, :int, :int, :int, :int, :int, :uint, :uint, :pointer], :void
+    end
+  end
+end

data/lib/3rb/ffi/platform.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Sunrb
+  module FFI
+    module Platform
+      class << self
+        def os
+          @os ||= case RbConfig::CONFIG["host_os"]
+          when /darwin/i then :macos
+          when /linux/i then :linux
+          when /mswin|mingw|cygwin/i then :windows
+          else :unknown
+          end
+        end
+
+        def glfw_lib
+          case os
+          when :macos
+            find_macos_library("libglfw.3.dylib", "libglfw.dylib")
+          when :linux
+            "libglfw.so.3"
+          when :windows
+            "glfw3.dll"
+          else
+            "libglfw.so.3"
+          end
+        end
+
+        def opengl_lib
+          case os
+          when :macos
+            "/System/Library/Frameworks/OpenGL.framework/OpenGL"
+          when :linux
+            "libGL.so.1"
+          when :windows
+            "opengl32.dll"
+          else
+            "libGL.so.1"
+          end
+        end
+
+        private
+
+        def find_macos_library(*names)
+          brew_paths = [
+            "/opt/homebrew/lib",
+            "/usr/local/lib",
+            "/opt/local/lib"
+          ]
+
+          names.each do |name|
+            brew_paths.each do |path|
+              full_path = File.join(path, name)
+              return full_path if File.exist?(full_path)
+            end
+          end
+
+          names.first
+        end
+      end
+    end
+  end
+end

data/lib/3rb/geometries/box_geometry.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class BoxGeometry < BufferGeometry
+    attr_reader :parameters
+
+    def initialize(width: 1, height: 1, depth: 1, width_segments: 1, height_segments: 1, depth_segments: 1)
+      super()
+
+      @parameters = {
+        width: width,
+        height: height,
+        depth: depth,
+        width_segments: width_segments,
+        height_segments: height_segments,
+        depth_segments: depth_segments
+      }
+
+      build_geometry
+    end
+
+    private
+
+    def build_geometry
+      width = @parameters[:width]
+      height = @parameters[:height]
+      depth = @parameters[:depth]
+      width_segments = @parameters[:width_segments].to_i
+      height_segments = @parameters[:height_segments].to_i
+      depth_segments = @parameters[:depth_segments].to_i
+
+      indices = []
+      vertices = []
+      normals = []
+      uvs = []
+
+      number_of_vertices = 0
+
+      build_plane = lambda do |u, v, w, udir, vdir, width, height, depth, grid_x, grid_y|
+        segment_width = width / grid_x
+        segment_height = height / grid_y
+
+        width_half = width / 2.0
+        height_half = height / 2.0
+        depth_half = depth / 2.0
+
+        grid_x1 = grid_x + 1
+        grid_y1 = grid_y + 1
+
+        vertex = Vector3.new
+        (0...grid_y1).each do |iy|
+          y = iy * segment_height - height_half
+          (0...grid_x1).each do |ix|
+            x = ix * segment_width - width_half
+
+            vertex.send("#{u}=", x * udir)
+            vertex.send("#{v}=", y * vdir)
+            vertex.send("#{w}=", depth_half)
+
+            vertices.push(vertex.x, vertex.y, vertex.z)
+
+            vertex.send("#{u}=", 0)
+            vertex.send("#{v}=", 0)
+            vertex.send("#{w}=", depth > 0 ? 1 : -1)
+
+            normals.push(vertex.x, vertex.y, vertex.z)
+
+            uvs.push(ix.to_f / grid_x)
+            uvs.push(1 - (iy.to_f / grid_y))
+          end
+        end
+
+        (0...grid_y).each do |iy|
+          (0...grid_x).each do |ix|
+            a = number_of_vertices + ix + grid_x1 * iy
+            b = number_of_vertices + ix + grid_x1 * (iy + 1)
+            c = number_of_vertices + (ix + 1) + grid_x1 * (iy + 1)
+            d = number_of_vertices + (ix + 1) + grid_x1 * iy
+
+            indices.push(a, b, d)
+            indices.push(b, c, d)
+          end
+        end
+
+        number_of_vertices += grid_x1 * grid_y1
+      end
+
+      build_plane.call(:z, :y, :x, -1, -1, depth, height, width, depth_segments, height_segments)
+      build_plane.call(:z, :y, :x, 1, -1, depth, height, -width, depth_segments, height_segments)
+      build_plane.call(:x, :z, :y, 1, 1, width, depth, height, width_segments, depth_segments)
+      build_plane.call(:x, :z, :y, 1, -1, width, depth, -height, width_segments, depth_segments)
+      build_plane.call(:x, :y, :z, 1, -1, width, height, depth, width_segments, height_segments)
+      build_plane.call(:x, :y, :z, -1, -1, width, height, -depth, width_segments, height_segments)
+
+      set_index(indices)
+      set_attribute(:position, Float32BufferAttribute.new(vertices, 3))
+      set_attribute(:normal, Float32BufferAttribute.new(normals, 3))
+      set_attribute(:uv, Float32BufferAttribute.new(uvs, 2))
+    end
+  end
+end

data/lib/3rb/geometries/buffer_geometry.rb

@@ -0,0 +1,345 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class BufferGeometry
+    attr_reader :uuid, :attributes, :index, :groups
+    attr_accessor :name, :bounding_box, :bounding_sphere
+    attr_accessor :draw_range
+
+    def initialize
+      @uuid = MathUtils.generate_uuid
+      @name = ""
+      @attributes = {}
+      @index = nil
+      @groups = []
+      @bounding_box = nil
+      @bounding_sphere = nil
+      @draw_range = { start: 0, count: Float::INFINITY }
+    end
+
+    def set_index(index)
+      @index = if index.is_a?(Array)
+                 index.max > 65535 ? Uint32BufferAttribute.new(index, 1) : Uint16BufferAttribute.new(index, 1)
+               else
+                 index
+               end
+      self
+    end
+
+    def get_index
+      @index
+    end
+
+    def set_attribute(name, attribute)
+      @attributes[name.to_sym] = attribute
+      self
+    end
+
+    def get_attribute(name)
+      @attributes[name.to_sym]
+    end
+
+    def delete_attribute(name)
+      @attributes.delete(name.to_sym)
+      self
+    end
+
+    def has_attribute?(name)
+      @attributes.key?(name.to_sym)
+    end
+
+    def add_group(start, count, material_index = 0)
+      @groups << { start: start, count: count, material_index: material_index }
+    end
+
+    def clear_groups
+      @groups.clear
+    end
+
+    def set_draw_range(start, count)
+      @draw_range = { start: start, count: count }
+    end
+
+    def apply_matrix4(matrix)
+      position = get_attribute(:position)
+      position&.apply_matrix4(matrix)
+
+      normal = get_attribute(:normal)
+      if normal
+        normal_matrix = Matrix3.new.set_from_matrix4(matrix).invert!.transpose!
+        normal.apply_normal_matrix(normal_matrix)
+      end
+
+      @bounding_box&.apply_matrix4(matrix)
+      @bounding_sphere&.apply_matrix4(matrix)
+
+      self
+    end
+
+    def apply_quaternion(q)
+      m = Matrix4.new.make_rotation_from_quaternion(q)
+      apply_matrix4(m)
+    end
+
+    def rotate_x(angle)
+      m = Matrix4.new.make_rotation_x(angle)
+      apply_matrix4(m)
+    end
+
+    def rotate_y(angle)
+      m = Matrix4.new.make_rotation_y(angle)
+      apply_matrix4(m)
+    end
+
+    def rotate_z(angle)
+      m = Matrix4.new.make_rotation_z(angle)
+      apply_matrix4(m)
+    end
+
+    def translate(x, y, z)
+      m = Matrix4.new.make_translation(x, y, z)
+      apply_matrix4(m)
+    end
+
+    def scale(x, y, z)
+      m = Matrix4.new.make_scale(x, y, z)
+      apply_matrix4(m)
+    end
+
+    def center
+      compute_bounding_box
+      center = @bounding_box.get_center
+      translate(-center.x, -center.y, -center.z)
+      self
+    end
+
+    def compute_bounding_box
+      position = get_attribute(:position)
+      return unless position
+
+      @bounding_box ||= BoundingBox.new
+
+      @bounding_box.set_from_buffer_attribute(position)
+    end
+
+    def compute_bounding_sphere
+      position = get_attribute(:position)
+      return unless position
+
+      compute_bounding_box unless @bounding_box
+
+      center = @bounding_box.get_center
+      max_radius_sq = 0.0
+
+      position.count.times do |i|
+        x = position.get_x(i) - center.x
+        y = position.get_y(i) - center.y
+        z = position.get_z(i) - center.z
+        radius_sq = x * x + y * y + z * z
+        max_radius_sq = radius_sq if radius_sq > max_radius_sq
+      end
+
+      @bounding_sphere = BoundingSphere.new(center, Math.sqrt(max_radius_sq))
+    end
+
+    def compute_vertex_normals
+      position = get_attribute(:position)
+      return unless position
+
+      normal = get_attribute(:normal)
+      if normal.nil?
+        normal = Float32BufferAttribute.new(Array.new(position.count * 3, 0.0), 3)
+        set_attribute(:normal, normal)
+      else
+        normal.count.times do |i|
+          normal.set_xyz(i, 0, 0, 0)
+        end
+      end
+
+      p_a = Vector3.new
+      p_b = Vector3.new
+      p_c = Vector3.new
+      cb = Vector3.new
+      ab = Vector3.new
+
+      if @index
+        @index.count.step(@index.count - 1, 3) do |i|
+          break if i + 2 >= @index.count
+
+          v_a = @index.get_x(i)
+          v_b = @index.get_x(i + 1)
+          v_c = @index.get_x(i + 2)
+
+          p_a.set(position.get_x(v_a), position.get_y(v_a), position.get_z(v_a))
+          p_b.set(position.get_x(v_b), position.get_y(v_b), position.get_z(v_b))
+          p_c.set(position.get_x(v_c), position.get_y(v_c), position.get_z(v_c))
+
+          cb.copy(p_c).sub!(p_b)
+          ab.copy(p_a).sub!(p_b)
+          cb.cross!(ab)
+
+          normal.set_xyz(v_a, normal.get_x(v_a) + cb.x, normal.get_y(v_a) + cb.y, normal.get_z(v_a) + cb.z)
+          normal.set_xyz(v_b, normal.get_x(v_b) + cb.x, normal.get_y(v_b) + cb.y, normal.get_z(v_b) + cb.z)
+          normal.set_xyz(v_c, normal.get_x(v_c) + cb.x, normal.get_y(v_c) + cb.y, normal.get_z(v_c) + cb.z)
+        end
+      else
+        (0...position.count).step(3) do |i|
+          break if i + 2 >= position.count
+
+          p_a.set(position.get_x(i), position.get_y(i), position.get_z(i))
+          p_b.set(position.get_x(i + 1), position.get_y(i + 1), position.get_z(i + 1))
+          p_c.set(position.get_x(i + 2), position.get_y(i + 2), position.get_z(i + 2))
+
+          cb.copy(p_c).sub!(p_b)
+          ab.copy(p_a).sub!(p_b)
+          cb.cross!(ab)
+
+          normal.set_xyz(i, cb.x, cb.y, cb.z)
+          normal.set_xyz(i + 1, cb.x, cb.y, cb.z)
+          normal.set_xyz(i + 2, cb.x, cb.y, cb.z)
+        end
+      end
+
+      normalize_normals
+    end
+
+    def normalize_normals
+      normal = get_attribute(:normal)
+      return unless normal
+
+      v = Vector3.new
+      normal.count.times do |i|
+        v.set(normal.get_x(i), normal.get_y(i), normal.get_z(i))
+        v.normalize!
+        normal.set_xyz(i, v.x, v.y, v.z)
+      end
+    end
+
+    def clone
+      new_geometry = self.class.new
+      new_geometry.name = @name
+
+      @attributes.each do |key, attr|
+        new_geometry.set_attribute(key, attr.clone)
+      end
+
+      new_geometry.set_index(@index.clone) if @index
+
+      @groups.each do |group|
+        new_geometry.add_group(group[:start], group[:count], group[:material_index])
+      end
+
+      new_geometry
+    end
+
+    def dispose
+      @attributes.clear
+      @index = nil
+      @groups.clear
+    end
+
+    def to_h
+      {
+        uuid: @uuid,
+        type: self.class.name,
+        name: @name,
+        attributes: @attributes.transform_values(&:to_a)
+      }
+    end
+  end
+
+  class BoundingBox
+    attr_accessor :min, :max
+
+    def initialize(min = nil, max = nil)
+      @min = min || Vector3.new(Float::INFINITY, Float::INFINITY, Float::INFINITY)
+      @max = max || Vector3.new(-Float::INFINITY, -Float::INFINITY, -Float::INFINITY)
+    end
+
+    def set_from_buffer_attribute(attribute)
+      @min.set(Float::INFINITY, Float::INFINITY, Float::INFINITY)
+      @max.set(-Float::INFINITY, -Float::INFINITY, -Float::INFINITY)
+
+      attribute.count.times do |i|
+        x = attribute.get_x(i)
+        y = attribute.get_y(i)
+        z = attribute.get_z(i)
+
+        @min.x = x if x < @min.x
+        @min.y = y if y < @min.y
+        @min.z = z if z < @min.z
+
+        @max.x = x if x > @max.x
+        @max.y = y if y > @max.y
+        @max.z = z if z > @max.z
+      end
+      self
+    end
+
+    def get_center(target = Vector3.new)
+      target.set(
+        (@min.x + @max.x) / 2,
+        (@min.y + @max.y) / 2,
+        (@min.z + @max.z) / 2
+      )
+    end
+
+    def get_size(target = Vector3.new)
+      target.set(
+        @max.x - @min.x,
+        @max.y - @min.y,
+        @max.z - @min.z
+      )
+    end
+
+    def apply_matrix4(matrix)
+      points = [
+        Vector3.new(@min.x, @min.y, @min.z),
+        Vector3.new(@min.x, @min.y, @max.z),
+        Vector3.new(@min.x, @max.y, @min.z),
+        Vector3.new(@min.x, @max.y, @max.z),
+        Vector3.new(@max.x, @min.y, @min.z),
+        Vector3.new(@max.x, @min.y, @max.z),
+        Vector3.new(@max.x, @max.y, @min.z),
+        Vector3.new(@max.x, @max.y, @max.z)
+      ]
+
+      @min.set(Float::INFINITY, Float::INFINITY, Float::INFINITY)
+      @max.set(-Float::INFINITY, -Float::INFINITY, -Float::INFINITY)
+
+      points.each do |p|
+        p.apply_matrix4(matrix)
+        @min.x = p.x if p.x < @min.x
+        @min.y = p.y if p.y < @min.y
+        @min.z = p.z if p.z < @min.z
+        @max.x = p.x if p.x > @max.x
+        @max.y = p.y if p.y > @max.y
+        @max.z = p.z if p.z > @max.z
+      end
+      self
+    end
+
+    def clone
+      BoundingBox.new(@min.clone, @max.clone)
+    end
+  end
+
+  class BoundingSphere
+    attr_accessor :center, :radius
+
+    def initialize(center = nil, radius = -1)
+      @center = center || Vector3.new
+      @radius = radius
+    end
+
+    def apply_matrix4(matrix)
+      @center.apply_matrix4(matrix)
+      @radius *= matrix.get_max_scale_on_axis
+      self
+    end
+
+    def clone
+      BoundingSphere.new(@center.clone, @radius)
+    end
+  end
+end