3rb 0.1.0

data/lib/3rb/core/object3d.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Object3D
+    attr_accessor :position, :rotation, :scale
+    attr_accessor :matrix, :matrix_world
+    attr_accessor :parent, :visible, :name
+    attr_accessor :cast_shadow, :receive_shadow
+    attr_accessor :frustum_culled, :render_order
+    attr_accessor :user_data
+    attr_reader :uuid, :children, :up, :quaternion
+
+    def initialize
+      @uuid = MathUtils.generate_uuid
+      @name = ""
+
+      @position = Vector3.new(0, 0, 0)
+      @rotation = Euler.new(0, 0, 0)
+      @quaternion = Quaternion.new
+      @scale = Vector3.new(1, 1, 1)
+
+      @up = Vector3.new(0, 1, 0)
+
+      @matrix = Matrix4.new
+      @matrix_world = Matrix4.new
+      @matrix_auto_update = true
+      @matrix_world_needs_update = false
+
+      @parent = nil
+      @children = []
+
+      @visible = true
+      @cast_shadow = false
+      @receive_shadow = false
+      @frustum_culled = true
+      @render_order = 0
+
+      @user_data = {}
+
+      sync_rotation_and_quaternion
+    end
+
+    def rotation=(value)
+      @rotation = value
+      @quaternion.set_from_euler(@rotation)
+    end
+
+    def quaternion=(value)
+      @quaternion = value
+      @rotation.set_from_quaternion(@quaternion)
+    end
+
+    def add(*objects)
+      objects.each do |object|
+        next if object == self
+
+        object.remove_from_parent if object.parent
+        object.parent = self
+        @children << object
+      end
+      self
+    end
+
+    def remove(*objects)
+      objects.each do |object|
+        index = @children.index(object)
+        next unless index
+
+        object.parent = nil
+        @children.delete_at(index)
+      end
+      self
+    end
+
+    def remove_from_parent
+      @parent&.remove(self)
+      self
+    end
+
+    def clear
+      @children.each do |child|
+        child.parent = nil
+      end
+      @children.clear
+      self
+    end
+
+    def get_object_by_id(id)
+      return self if @uuid == id
+
+      @children.each do |child|
+        found = child.get_object_by_id(id)
+        return found if found
+      end
+
+      nil
+    end
+
+    def get_object_by_name(name)
+      return self if @name == name
+
+      @children.each do |child|
+        found = child.get_object_by_name(name)
+        return found if found
+      end
+
+      nil
+    end
+
+    def get_object_by_property(name, value)
+      return self if respond_to?(name) && send(name) == value
+
+      @children.each do |child|
+        found = child.get_object_by_property(name, value)
+        return found if found
+      end
+
+      nil
+    end
+
+    def get_world_position(target = Vector3.new)
+      update_world_matrix(true, false)
+      target.set(@matrix_world.elements[12], @matrix_world.elements[13], @matrix_world.elements[14])
+    end
+
+    def get_world_quaternion(target = Quaternion.new)
+      update_world_matrix(true, false)
+      @matrix_world.decompose[1].tap { |q| target.copy(q) }
+      target
+    end
+
+    def get_world_scale(target = Vector3.new)
+      update_world_matrix(true, false)
+      @matrix_world.decompose[2].tap { |s| target.copy(s) }
+      target
+    end
+
+    def get_world_direction(target = Vector3.new)
+      update_world_matrix(true, false)
+      e = @matrix_world.elements
+      target.set(e[8], e[9], e[10]).normalize
+    end
+
+    def look_at(x, y = nil, z = nil)
+      target = if x.is_a?(Vector3)
+                 x
+               else
+                 Vector3.new(x, y, z)
+               end
+
+      update_world_matrix(true, false)
+      position = get_world_position
+
+      m1 = Matrix4.new
+      m1.make_look_at(position, target, @up)
+
+      @quaternion.set_from_rotation_matrix(m1)
+
+      if @parent
+        m1.set_from_rotation_matrix(@parent.matrix_world)
+        parent_quaternion = Quaternion.new.set_from_rotation_matrix(m1)
+        @quaternion.premultiply!(parent_quaternion.invert!)
+      end
+
+      sync_rotation_from_quaternion
+    end
+
+    def traverse(&block)
+      block.call(self)
+      @children.each { |child| child.traverse(&block) }
+    end
+
+    def traverse_visible(&block)
+      return unless @visible
+
+      block.call(self)
+      @children.each { |child| child.traverse_visible(&block) }
+    end
+
+    def traverse_ancestors(&block)
+      @parent&.tap do |parent|
+        block.call(parent)
+        parent.traverse_ancestors(&block)
+      end
+    end
+
+    def update_matrix
+      @quaternion.set_from_euler(@rotation)
+      @matrix.compose(@position, @quaternion, @scale)
+      @matrix_world_needs_update = true
+    end
+
+    def update_matrix_world(force = false)
+      update_matrix if @matrix_auto_update
+
+      if @matrix_world_needs_update || force
+        if @parent.nil?
+          @matrix_world.copy(@matrix)
+        else
+          @matrix_world.copy(@parent.matrix_world).multiply!(@matrix)
+        end
+        @matrix_world_needs_update = false
+        force = true
+      end
+
+      @children.each { |child| child.update_matrix_world(force) }
+    end
+
+    def update_world_matrix(update_parents, update_children)
+      if update_parents && @parent
+        @parent.update_world_matrix(true, false)
+      end
+
+      update_matrix if @matrix_auto_update
+
+      if @parent.nil?
+        @matrix_world.copy(@matrix)
+      else
+        @matrix_world.copy(@parent.matrix_world).multiply!(@matrix)
+      end
+
+      if update_children
+        @children.each { |child| child.update_world_matrix(false, true) }
+      end
+    end
+
+    def clone(recursive = true)
+      new_object = self.class.new
+      new_object.name = @name
+      new_object.up.copy(@up)
+      new_object.position.copy(@position)
+      new_object.rotation.copy(@rotation)
+      new_object.scale.copy(@scale)
+      new_object.matrix.copy(@matrix)
+      new_object.matrix_world.copy(@matrix_world)
+      new_object.visible = @visible
+      new_object.cast_shadow = @cast_shadow
+      new_object.receive_shadow = @receive_shadow
+      new_object.frustum_culled = @frustum_culled
+      new_object.render_order = @render_order
+
+      if recursive
+        @children.each do |child|
+          new_object.add(child.clone)
+        end
+      end
+
+      new_object
+    end
+
+    def copy(source, recursive = true)
+      @name = source.name
+      @up.copy(source.up)
+      @position.copy(source.position)
+      @rotation.copy(source.rotation)
+      @quaternion.copy(source.quaternion)
+      @scale.copy(source.scale)
+      @matrix.copy(source.matrix)
+      @matrix_world.copy(source.matrix_world)
+      @visible = source.visible
+      @cast_shadow = source.cast_shadow
+      @receive_shadow = source.receive_shadow
+      @frustum_culled = source.frustum_culled
+      @render_order = source.render_order
+
+      if recursive
+        source.children.each do |child|
+          add(child.clone)
+        end
+      end
+
+      self
+    end
+
+    def to_h
+      {
+        uuid: @uuid,
+        type: self.class.name,
+        name: @name,
+        position: @position.to_a,
+        rotation: @rotation.to_a,
+        scale: @scale.to_a,
+        visible: @visible,
+        children: @children.map(&:to_h)
+      }
+    end
+
+    private
+
+    def sync_rotation_and_quaternion
+      @quaternion.set_from_euler(@rotation)
+    end
+
+    def sync_rotation_from_quaternion
+      @rotation.set_from_quaternion(@quaternion)
+    end
+  end
+end

data/lib/3rb/core/scene.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Scene < Object3D
+    attr_accessor :background, :environment, :fog
+    attr_accessor :override_material
+
+    def initialize
+      super
+      @background = nil
+      @environment = nil
+      @fog = nil
+      @override_material = nil
+    end
+
+    def clone(recursive = true)
+      new_scene = super(recursive)
+      new_scene.background = @background&.respond_to?(:clone) ? @background.clone : @background
+      new_scene.environment = @environment
+      new_scene.fog = @fog&.clone
+      new_scene.override_material = @override_material
+      new_scene
+    end
+
+    def copy(source, recursive = true)
+      super(source, recursive)
+      @background = source.background&.respond_to?(:clone) ? source.background.clone : source.background
+      @environment = source.environment
+      @fog = source.fog&.clone
+      @override_material = source.override_material
+      self
+    end
+
+    def to_h
+      super.merge(
+        background: @background.respond_to?(:to_h) ? @background.to_h : @background,
+        fog: @fog&.to_h
+      )
+    end
+  end
+
+  class Fog
+    attr_accessor :name, :color, :near, :far
+
+    def initialize(color, near = 1, far = 1000)
+      @name = ""
+      @color = color.is_a?(Color) ? color : Color.new(color)
+      @near = near.to_f
+      @far = far.to_f
+    end
+
+    def clone
+      Fog.new(@color.clone, @near, @far)
+    end
+
+    def to_h
+      { color: @color.get_hex, near: @near, far: @far }
+    end
+  end
+
+  class FogExp2
+    attr_accessor :name, :color, :density
+
+    def initialize(color, density = 0.00025)
+      @name = ""
+      @color = color.is_a?(Color) ? color : Color.new(color)
+      @density = density.to_f
+    end
+
+    def clone
+      FogExp2.new(@color.clone, @density)
+    end
+
+    def to_h
+      { color: @color.get_hex, density: @density }
+    end
+  end
+end

data/lib/3rb/dsl/helpers.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Sunrb
+  module DSL
+    module Helpers
+      def self.color(value)
+        Color.new(value)
+      end
+
+      def self.vector2(x, y)
+        Vector2.new(x, y)
+      end
+
+      def self.vector3(x, y, z)
+        Vector3.new(x, y, z)
+      end
+
+      def self.euler(x, y, z, order = "XYZ")
+        Euler.new(x, y, z, order)
+      end
+
+      def self.degrees_to_radians(degrees)
+        degrees * Math::PI / 180
+      end
+
+      def self.radians_to_degrees(radians)
+        radians * 180 / Math::PI
+      end
+    end
+
+    module TopLevelHelpers
+      def color(value)
+        Helpers.color(value)
+      end
+
+      def vec2(x, y)
+        Helpers.vector2(x, y)
+      end
+
+      def vec3(x, y, z)
+        Helpers.vector3(x, y, z)
+      end
+
+      def euler(x, y, z, order = "XYZ")
+        Helpers.euler(x, y, z, order)
+      end
+
+      def deg2rad(degrees)
+        Helpers.degrees_to_radians(degrees)
+      end
+
+      def rad2deg(radians)
+        Helpers.radians_to_degrees(radians)
+      end
+    end
+  end
+end

data/lib/3rb/dsl/scene_builder.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+module Sunrb
+  module DSL
+    class SceneBuilder
+      attr_reader :scene, :camera, :renderer
+      attr_reader :objects, :lights
+
+      def initialize(width: 800, height: 600, title: "Sunrb")
+        @scene = Scene.new
+        @camera = nil
+        @renderer = OpenGLRenderer.new(width: width, height: height, title: title)
+        @objects = {}
+        @lights = {}
+        @frame_callbacks = []
+        @key_callbacks = []
+        @mouse_callbacks = []
+      end
+
+      def background(color)
+        @scene.background = color.is_a?(Color) ? color : Color.new(color)
+      end
+
+      def fog(color, near, far)
+        @scene.fog = Fog.new(color, near, far)
+      end
+
+      def perspective_camera(fov: 50, aspect: nil, near: 0.1, far: 2000, &block)
+        aspect ||= @renderer.width.to_f / @renderer.height
+        @camera = PerspectiveCamera.new(fov: fov, aspect: aspect, near: near, far: far)
+        ObjectConfigurator.new(@camera).instance_eval(&block) if block
+        @camera
+      end
+
+      def orthographic_camera(left: -1, right: 1, top: 1, bottom: -1, near: 0.1, far: 2000, &block)
+        @camera = OrthographicCamera.new(left: left, right: right, top: top, bottom: bottom, near: near, far: far)
+        ObjectConfigurator.new(@camera).instance_eval(&block) if block
+        @camera
+      end
+
+      def ambient_light(color: 0xffffff, intensity: 1.0, &block)
+        light = AmbientLight.new(color: color, intensity: intensity)
+        ObjectConfigurator.new(light).instance_eval(&block) if block
+        @scene.add(light)
+        light
+      end
+
+      def directional_light(color: 0xffffff, intensity: 1.0, &block)
+        light = DirectionalLight.new(color: color, intensity: intensity)
+        ObjectConfigurator.new(light).instance_eval(&block) if block
+        @scene.add(light)
+        light
+      end
+
+      def point_light(color: 0xffffff, intensity: 1.0, distance: 0, decay: 2, &block)
+        light = PointLight.new(color: color, intensity: intensity, distance: distance, decay: decay)
+        ObjectConfigurator.new(light).instance_eval(&block) if block
+        @scene.add(light)
+        light
+      end
+
+      def spot_light(color: 0xffffff, intensity: 1.0, distance: 0, angle: Math::PI / 3, penumbra: 0, decay: 2, &block)
+        light = SpotLight.new(color: color, intensity: intensity, distance: distance, angle: angle, penumbra: penumbra, decay: decay)
+        ObjectConfigurator.new(light).instance_eval(&block) if block
+        @scene.add(light)
+        light
+      end
+
+      def hemisphere_light(sky_color: 0xffffff, ground_color: 0xffffff, intensity: 1.0, &block)
+        light = HemisphereLight.new(sky_color: sky_color, ground_color: ground_color, intensity: intensity)
+        ObjectConfigurator.new(light).instance_eval(&block) if block
+        @scene.add(light)
+        light
+      end
+
+      def mesh(name = nil, &block)
+        builder = MeshBuilder.new
+        builder.instance_eval(&block) if block
+        mesh = builder.build
+        mesh.name = name.to_s if name
+        @objects[name] = mesh if name
+        @scene.add(mesh)
+        mesh
+      end
+
+      def group(name = nil, &block)
+        grp = Group.new
+        grp.name = name.to_s if name
+        GroupConfigurator.new(grp, self).instance_eval(&block) if block
+        @objects[name] = grp if name
+        @scene.add(grp)
+        grp
+      end
+
+      def on_frame(&block)
+        @frame_callbacks << block
+      end
+
+      def on_key(&block)
+        @key_callbacks << block
+      end
+
+      def on_mouse(&block)
+        @mouse_callbacks << block
+      end
+
+      def close
+        @renderer.stop
+      end
+
+      def run
+        @renderer.on_frame do |delta|
+          @frame_callbacks.each { |cb| cb.call(delta) }
+        end
+
+        @renderer.on_key do |key, action|
+          @key_callbacks.each { |cb| cb.call(key, action) }
+        end
+
+        @renderer.on_mouse do |button, action, x, y|
+          @mouse_callbacks.each { |cb| cb.call(button, action, x, y) }
+        end
+
+        @renderer.run do |_delta|
+          @renderer.render(@scene, @camera)
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        return @objects[name] if @objects.key?(name)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @objects.key?(name) || super
+      end
+    end
+
+    class ObjectConfigurator
+      def initialize(object)
+        @object = object
+      end
+
+      def position(x, y, z)
+        @object.position.set(x, y, z)
+      end
+
+      def rotation(x, y, z)
+        @object.rotation.set(x, y, z)
+      end
+
+      def scale(x, y = nil, z = nil)
+        y ||= x
+        z ||= x
+        @object.scale.set(x, y, z)
+      end
+
+      def look_at(x, y = nil, z = nil)
+        if x.is_a?(Vector3)
+          @object.look_at(x)
+        else
+          @object.look_at(x, y, z)
+        end
+      end
+
+      def visible(value)
+        @object.visible = value
+      end
+
+      def cast_shadow(value)
+        @object.cast_shadow = value
+      end
+
+      def receive_shadow(value)
+        @object.receive_shadow = value
+      end
+    end
+
+    class MeshBuilder
+      GEOMETRY_TYPES = {
+        box: BoxGeometry,
+        sphere: SphereGeometry,
+        plane: PlaneGeometry,
+        cylinder: CylinderGeometry,
+        cone: ConeGeometry,
+        torus: TorusGeometry
+      }.freeze
+
+      MATERIAL_TYPES = {
+        basic: MeshBasicMaterial,
+        lambert: MeshLambertMaterial,
+        phong: MeshPhongMaterial,
+        standard: MeshStandardMaterial
+      }.freeze
+
+      def initialize
+        @geometry = nil
+        @material = nil
+        @position = nil
+        @rotation = nil
+        @scale = nil
+        @name = nil
+      end
+
+      def geometry(type, **options)
+        klass = GEOMETRY_TYPES[type]
+        raise ArgumentError, "Unknown geometry type: #{type}" unless klass
+
+        @geometry = klass.new(**options)
+      end
+
+      def material(type, **options)
+        klass = MATERIAL_TYPES[type]
+        raise ArgumentError, "Unknown material type: #{type}" unless klass
+
+        @material = klass.new(**options)
+      end
+
+      def position(x, y, z)
+        @position = [x, y, z]
+      end
+
+      def rotation(x, y, z)
+        @rotation = [x, y, z]
+      end
+
+      def scale(x, y = nil, z = nil)
+        y ||= x
+        z ||= x
+        @scale = [x, y, z]
+      end
+
+      def build
+        @geometry ||= BoxGeometry.new
+        @material ||= MeshBasicMaterial.new
+
+        mesh = Mesh.new(@geometry, @material)
+        mesh.position.set(*@position) if @position
+        mesh.rotation.set(*@rotation) if @rotation
+        mesh.scale.set(*@scale) if @scale
+        mesh.name = @name if @name
+        mesh
+      end
+    end
+
+    class GroupConfigurator < ObjectConfigurator
+      def initialize(group, scene_builder)
+        super(group)
+        @group = group
+        @scene_builder = scene_builder
+      end
+
+      def mesh(name = nil, &block)
+        builder = MeshBuilder.new
+        builder.instance_eval(&block) if block
+        mesh = builder.build
+        mesh.name = name.to_s if name
+        @scene_builder.objects[name] = mesh if name
+        @group.add(mesh)
+        mesh
+      end
+
+      def group(name = nil, &block)
+        grp = Group.new
+        grp.name = name.to_s if name
+        GroupConfigurator.new(grp, @scene_builder).instance_eval(&block) if block
+        @scene_builder.objects[name] = grp if name
+        @group.add(grp)
+        grp
+      end
+    end
+  end
+
+  class << self
+    def app(width: 800, height: 600, title: "Sunrb", &block)
+      builder = DSL::SceneBuilder.new(width: width, height: height, title: title)
+      builder.instance_eval(&block)
+      builder.run
+    end
+
+    def scene(&block)
+      builder = DSL::SceneBuilder.new
+      builder.instance_eval(&block)
+      builder
+    end
+  end
+end