3rb 0.1.0

data/lib/3rb/geometries/cone_geometry.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class ConeGeometry < CylinderGeometry
+    def initialize(radius: 1, height: 1, radial_segments: 32, height_segments: 1,
+                   open_ended: false, theta_start: 0, theta_length: Math::PI * 2)
+      super(
+        radius_top: 0,
+        radius_bottom: radius,
+        height: height,
+        radial_segments: radial_segments,
+        height_segments: height_segments,
+        open_ended: open_ended,
+        theta_start: theta_start,
+        theta_length: theta_length
+      )
+
+      @parameters = {
+        radius: radius,
+        height: height,
+        radial_segments: radial_segments,
+        height_segments: height_segments,
+        open_ended: open_ended,
+        theta_start: theta_start,
+        theta_length: theta_length
+      }
+    end
+  end
+end

data/lib/3rb/geometries/cylinder_geometry.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class CylinderGeometry < BufferGeometry
+    attr_reader :parameters
+
+    def initialize(radius_top: 1, radius_bottom: 1, height: 1,
+                   radial_segments: 32, height_segments: 1,
+                   open_ended: false, theta_start: 0, theta_length: Math::PI * 2)
+      super()
+
+      @parameters = {
+        radius_top: radius_top,
+        radius_bottom: radius_bottom,
+        height: height,
+        radial_segments: radial_segments,
+        height_segments: height_segments,
+        open_ended: open_ended,
+        theta_start: theta_start,
+        theta_length: theta_length
+      }
+
+      @indices = []
+      @vertices = []
+      @normals = []
+      @uvs = []
+      @index = 0
+
+      build_geometry
+    end
+
+    private
+
+    def build_geometry
+      radial_segments = [3, @parameters[:radial_segments].to_i].max
+      height_segments = [1, @parameters[:height_segments].to_i].max
+
+      generate_torso(radial_segments, height_segments)
+
+      unless @parameters[:open_ended]
+        generate_cap(true, radial_segments) if @parameters[:radius_top] > 0
+        generate_cap(false, radial_segments) if @parameters[:radius_bottom] > 0
+      end
+
+      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
+
+    def generate_torso(radial_segments, height_segments)
+      radius_top = @parameters[:radius_top]
+      radius_bottom = @parameters[:radius_bottom]
+      height = @parameters[:height]
+      theta_start = @parameters[:theta_start]
+      theta_length = @parameters[:theta_length]
+
+      half_height = height / 2.0
+      slope = (radius_bottom - radius_top) / height
+
+      index_array = []
+
+      (0..height_segments).each do |y|
+        index_row = []
+        v = y.to_f / height_segments
+        radius = v * (radius_bottom - radius_top) + radius_top
+
+        (0..radial_segments).each do |x|
+          u = x.to_f / radial_segments
+          theta = u * theta_length + theta_start
+
+          sin_theta = Math.sin(theta)
+          cos_theta = Math.cos(theta)
+
+          @vertices.push(radius * sin_theta, -v * height + half_height, radius * cos_theta)
+
+          normal = Vector3.new(sin_theta, slope, cos_theta).normalize!
+          @normals.push(normal.x, normal.y, normal.z)
+
+          @uvs.push(u, 1 - v)
+
+          index_row.push(@index)
+          @index += 1
+        end
+
+        index_array.push(index_row)
+      end
+
+      (0...height_segments).each do |y|
+        (0...radial_segments).each do |x|
+          a = index_array[y][x]
+          b = index_array[y + 1][x]
+          c = index_array[y + 1][x + 1]
+          d = index_array[y][x + 1]
+
+          @indices.push(a, b, d)
+          @indices.push(b, c, d)
+        end
+      end
+    end
+
+    def generate_cap(top, radial_segments)
+      radius_top = @parameters[:radius_top]
+      radius_bottom = @parameters[:radius_bottom]
+      height = @parameters[:height]
+      theta_start = @parameters[:theta_start]
+      theta_length = @parameters[:theta_length]
+
+      half_height = height / 2.0
+      radius = top ? radius_top : radius_bottom
+      sign = top ? 1 : -1
+
+      center_index_start = @index
+
+      (0..radial_segments).each do |x|
+        @vertices.push(0, half_height * sign, 0)
+        @normals.push(0, sign, 0)
+        @uvs.push(0.5, 0.5)
+        @index += 1
+      end
+
+      center_index_end = @index
+
+      (0..radial_segments).each do |x|
+        u = x.to_f / radial_segments
+        theta = u * theta_length + theta_start
+
+        cos_theta = Math.cos(theta)
+        sin_theta = Math.sin(theta)
+
+        @vertices.push(radius * sin_theta, half_height * sign, radius * cos_theta)
+        @normals.push(0, sign, 0)
+        @uvs.push((cos_theta * 0.5) + 0.5, (sin_theta * 0.5 * sign) + 0.5)
+        @index += 1
+      end
+
+      (0...radial_segments).each do |x|
+        c = center_index_start + x
+        i = center_index_end + x
+
+        if top
+          @indices.push(i, i + 1, c)
+        else
+          @indices.push(i + 1, i, c)
+        end
+      end
+    end
+  end
+end

data/lib/3rb/geometries/plane_geometry.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class PlaneGeometry < BufferGeometry
+    attr_reader :parameters
+
+    def initialize(width: 1, height: 1, width_segments: 1, height_segments: 1)
+      super()
+
+      @parameters = {
+        width: width,
+        height: height,
+        width_segments: width_segments,
+        height_segments: height_segments
+      }
+
+      build_geometry
+    end
+
+    private
+
+    def build_geometry
+      width = @parameters[:width]
+      height = @parameters[:height]
+      width_segments = @parameters[:width_segments].to_i
+      height_segments = @parameters[:height_segments].to_i
+
+      width_half = width / 2.0
+      height_half = height / 2.0
+
+      grid_x = width_segments
+      grid_y = height_segments
+
+      grid_x1 = grid_x + 1
+      grid_y1 = grid_y + 1
+
+      segment_width = width / grid_x
+      segment_height = height / grid_y
+
+      indices = []
+      vertices = []
+      normals = []
+      uvs = []
+
+      (0...grid_y1).each do |iy|
+        y = iy * segment_height - height_half
+
+        (0...grid_x1).each do |ix|
+          x = ix * segment_width - width_half
+
+          vertices.push(x, -y, 0)
+          normals.push(0, 0, 1)
+          uvs.push(ix.to_f / grid_x, 1 - (iy.to_f / grid_y))
+        end
+      end
+
+      (0...grid_y).each do |iy|
+        (0...grid_x).each do |ix|
+          a = ix + grid_x1 * iy
+          b = ix + grid_x1 * (iy + 1)
+          c = (ix + 1) + grid_x1 * (iy + 1)
+          d = (ix + 1) + grid_x1 * iy
+
+          indices.push(a, b, d)
+          indices.push(b, c, d)
+        end
+      end
+
+      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/sphere_geometry.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class SphereGeometry < BufferGeometry
+    attr_reader :parameters
+
+    def initialize(radius: 1, width_segments: 32, height_segments: 16,
+                   phi_start: 0, phi_length: Math::PI * 2,
+                   theta_start: 0, theta_length: Math::PI)
+      super()
+
+      @parameters = {
+        radius: radius,
+        width_segments: width_segments,
+        height_segments: height_segments,
+        phi_start: phi_start,
+        phi_length: phi_length,
+        theta_start: theta_start,
+        theta_length: theta_length
+      }
+
+      build_geometry
+    end
+
+    private
+
+    def build_geometry
+      radius = @parameters[:radius]
+      width_segments = [3, @parameters[:width_segments].to_i].max
+      height_segments = [2, @parameters[:height_segments].to_i].max
+      phi_start = @parameters[:phi_start]
+      phi_length = @parameters[:phi_length]
+      theta_start = @parameters[:theta_start]
+      theta_length = @parameters[:theta_length]
+
+      theta_end = [theta_start + theta_length, Math::PI].min
+
+      indices = []
+      vertices = []
+      normals = []
+      uvs = []
+
+      index = 0
+      grid = []
+
+      (0..height_segments).each do |iy|
+        vertices_row = []
+        v = iy.to_f / height_segments
+
+        u_offset = 0
+        u_offset = 0.5 / width_segments if iy.zero? && theta_start.zero?
+        u_offset = -0.5 / width_segments if iy == height_segments && theta_end >= Math::PI
+
+        (0..width_segments).each do |ix|
+          u = ix.to_f / width_segments
+
+          x = -radius * Math.cos(phi_start + u * phi_length) * Math.sin(theta_start + v * theta_length)
+          y = radius * Math.cos(theta_start + v * theta_length)
+          z = radius * Math.sin(phi_start + u * phi_length) * Math.sin(theta_start + v * theta_length)
+
+          vertices.push(x, y, z)
+
+          normal = Vector3.new(x, y, z).normalize!
+          normals.push(normal.x, normal.y, normal.z)
+
+          uvs.push(u + u_offset, 1 - v)
+
+          vertices_row.push(index)
+          index += 1
+        end
+
+        grid.push(vertices_row)
+      end
+
+      (0...height_segments).each do |iy|
+        (0...width_segments).each do |ix|
+          a = grid[iy][ix + 1]
+          b = grid[iy][ix]
+          c = grid[iy + 1][ix]
+          d = grid[iy + 1][ix + 1]
+
+          indices.push(a, b, d) if iy != 0 || theta_start > 0
+          indices.push(b, c, d) if iy != height_segments - 1 || theta_end < Math::PI
+        end
+      end
+
+      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/torus_geometry.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class TorusGeometry < BufferGeometry
+    attr_reader :parameters
+
+    def initialize(radius: 1, tube: 0.4, radial_segments: 12, tubular_segments: 48, arc: Math::PI * 2)
+      super()
+
+      @parameters = {
+        radius: radius,
+        tube: tube,
+        radial_segments: radial_segments,
+        tubular_segments: tubular_segments,
+        arc: arc
+      }
+
+      build_geometry
+    end
+
+    private
+
+    def build_geometry
+      radius = @parameters[:radius]
+      tube = @parameters[:tube]
+      radial_segments = [3, @parameters[:radial_segments].to_i].max
+      tubular_segments = [3, @parameters[:tubular_segments].to_i].max
+      arc = @parameters[:arc]
+
+      indices = []
+      vertices = []
+      normals = []
+      uvs = []
+
+      center = Vector3.new
+
+      (0..radial_segments).each do |j|
+        (0..tubular_segments).each do |i|
+          u = i.to_f / tubular_segments * arc
+          v = j.to_f / radial_segments * Math::PI * 2
+
+          x = (radius + tube * Math.cos(v)) * Math.cos(u)
+          y = (radius + tube * Math.cos(v)) * Math.sin(u)
+          z = tube * Math.sin(v)
+
+          vertices.push(x, y, z)
+
+          center.x = radius * Math.cos(u)
+          center.y = radius * Math.sin(u)
+
+          normal = Vector3.new(x - center.x, y - center.y, z).normalize!
+          normals.push(normal.x, normal.y, normal.z)
+
+          uvs.push(i.to_f / tubular_segments)
+          uvs.push(j.to_f / radial_segments)
+        end
+      end
+
+      (1..radial_segments).each do |j|
+        (1..tubular_segments).each do |i|
+          a = (tubular_segments + 1) * j + i - 1
+          b = (tubular_segments + 1) * (j - 1) + i - 1
+          c = (tubular_segments + 1) * (j - 1) + i
+          d = (tubular_segments + 1) * j + i
+
+          indices.push(a, b, d)
+          indices.push(b, c, d)
+        end
+      end
+
+      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/lights/ambient_light.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class AmbientLight < Light
+    def initialize(color: 0xffffff, intensity: 1.0)
+      super(color: color, intensity: intensity)
+    end
+  end
+end

data/lib/3rb/lights/directional_light.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class DirectionalLight < Light
+    attr_accessor :target
+    attr_accessor :shadow
+
+    def initialize(color: 0xffffff, intensity: 1.0)
+      super(color: color, intensity: intensity)
+      @target = Object3D.new
+      @shadow = DirectionalLightShadow.new
+    end
+
+    def copy(source, recursive = true)
+      super
+      @target = source.target.clone
+      @shadow = source.shadow.clone
+      self
+    end
+
+    def dispose
+      @shadow&.dispose
+    end
+
+    def to_h
+      super.merge(
+        target: @target.position.to_a
+      )
+    end
+  end
+
+  class DirectionalLightShadow
+    attr_accessor :camera, :bias, :normal_bias, :radius
+    attr_accessor :map_size
+
+    def initialize
+      @camera = OrthographicCamera.new(left: -5, right: 5, top: 5, bottom: -5, near: 0.5, far: 500)
+      @bias = 0
+      @normal_bias = 0
+      @radius = 1
+      @map_size = Vector2.new(512, 512)
+    end
+
+    def clone
+      shadow = DirectionalLightShadow.new
+      shadow.camera = @camera.clone
+      shadow.bias = @bias
+      shadow.normal_bias = @normal_bias
+      shadow.radius = @radius
+      shadow.map_size = @map_size.clone
+      shadow
+    end
+
+    def dispose
+    end
+  end
+end

data/lib/3rb/lights/hemisphere_light.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class HemisphereLight < Light
+    attr_accessor :ground_color
+
+    def initialize(sky_color: 0xffffff, ground_color: 0xffffff, intensity: 1.0)
+      super(color: sky_color, intensity: intensity)
+      @ground_color = ground_color.is_a?(Color) ? ground_color : Color.new(ground_color)
+      @position.copy(Object3D.new.up)
+      update_matrix
+    end
+
+    def copy(source, recursive = true)
+      super
+      @ground_color = source.ground_color.clone
+      self
+    end
+
+    def to_h
+      super.merge(
+        ground_color: @ground_color.get_hex
+      )
+    end
+  end
+end

data/lib/3rb/lights/light.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Light < Object3D
+    attr_accessor :color, :intensity
+
+    def initialize(color: 0xffffff, intensity: 1.0)
+      super()
+      @color = color.is_a?(Color) ? color : Color.new(color)
+      @intensity = intensity.to_f
+    end
+
+    def copy(source, recursive = true)
+      super
+      @color = source.color.clone
+      @intensity = source.intensity
+      self
+    end
+
+    def to_h
+      super.merge(
+        color: @color.get_hex,
+        intensity: @intensity
+      )
+    end
+  end
+end

data/lib/3rb/lights/point_light.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class PointLight < Light
+    attr_accessor :distance, :decay
+    attr_accessor :shadow
+
+    def initialize(color: 0xffffff, intensity: 1.0, distance: 0, decay: 2)
+      super(color: color, intensity: intensity)
+      @distance = distance.to_f
+      @decay = decay.to_f
+      @shadow = PointLightShadow.new
+    end
+
+    def power
+      @intensity * 4 * Math::PI
+    end
+
+    def power=(value)
+      @intensity = value / (4 * Math::PI)
+    end
+
+    def copy(source, recursive = true)
+      super
+      @distance = source.distance
+      @decay = source.decay
+      @shadow = source.shadow.clone
+      self
+    end
+
+    def dispose
+      @shadow&.dispose
+    end
+
+    def to_h
+      super.merge(
+        distance: @distance,
+        decay: @decay
+      )
+    end
+  end
+
+  class PointLightShadow
+    attr_accessor :camera, :bias, :normal_bias, :radius
+    attr_accessor :map_size
+
+    def initialize
+      @camera = PerspectiveCamera.new(fov: 90, aspect: 1, near: 0.5, far: 500)
+      @bias = 0
+      @normal_bias = 0
+      @radius = 1
+      @map_size = Vector2.new(512, 512)
+    end
+
+    def clone
+      shadow = PointLightShadow.new
+      shadow.camera = @camera.clone
+      shadow.bias = @bias
+      shadow.normal_bias = @normal_bias
+      shadow.radius = @radius
+      shadow.map_size = @map_size.clone
+      shadow
+    end
+
+    def dispose
+    end
+  end
+end

data/lib/3rb/lights/rect_area_light.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class RectAreaLight < Light
+    attr_accessor :width, :height
+
+    def initialize(color: 0xffffff, intensity: 1.0, width: 10, height: 10)
+      super(color: color, intensity: intensity)
+      @width = width.to_f
+      @height = height.to_f
+    end
+
+    def power
+      @intensity * @width * @height * Math::PI
+    end
+
+    def power=(value)
+      @intensity = value / (@width * @height * Math::PI)
+    end
+
+    def copy(source, recursive = true)
+      super
+      @width = source.width
+      @height = source.height
+      self
+    end
+
+    def to_h
+      super.merge(
+        width: @width,
+        height: @height
+      )
+    end
+  end
+end