3rb 0.1.0

data/lib/3rb/renderers/shader_lib.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Sunrb
+  module ShaderLib
+    SHADERS_PATH = File.expand_path("../../../shaders", __dir__)
+
+    class << self
+      def load_shader(name)
+        {
+          vertex_shader: load_file("#{name}.vert"),
+          fragment_shader: load_file("#{name}.frag")
+        }
+      end
+
+      def basic
+        @basic ||= load_shader("basic").merge(
+          uniforms: basic_uniforms
+        )
+      end
+
+      def lambert
+        @lambert ||= load_shader("lambert").merge(
+          uniforms: lambert_uniforms
+        )
+      end
+
+      def phong
+        @phong ||= load_shader("phong").merge(
+          uniforms: phong_uniforms
+        )
+      end
+
+      def standard
+        @standard ||= load_shader("standard").merge(
+          uniforms: standard_uniforms
+        )
+      end
+
+      private
+
+      def load_file(filename)
+        path = File.join(SHADERS_PATH, filename)
+        return nil unless File.exist?(path)
+
+        File.read(path)
+      end
+
+      def common_uniforms
+        {
+          model_matrix: { type: :mat4, value: nil },
+          model_view_matrix: { type: :mat4, value: nil },
+          projection_matrix: { type: :mat4, value: nil },
+          view_matrix: { type: :mat4, value: nil },
+          normal_matrix: { type: :mat3, value: nil },
+          camera_position: { type: :vec3, value: Vector3.new }
+        }
+      end
+
+      def basic_uniforms
+        common_uniforms.merge(
+          diffuse: { type: :vec3, value: Color.new(0xffffff) },
+          opacity: { type: :float, value: 1.0 },
+          map: { type: :texture, value: nil },
+          use_map: { type: :bool, value: false }
+        )
+      end
+
+      def lambert_uniforms
+        basic_uniforms.merge(
+          emissive: { type: :vec3, value: Color.new(0x000000) },
+          ambient_light_color: { type: :vec3, value: Color.new(0x000000) },
+          directional_light_direction: { type: :vec3, value: Vector3.new(0, 1, 0) },
+          directional_light_color: { type: :vec3, value: Color.new(0xffffff) }
+        )
+      end
+
+      def phong_uniforms
+        lambert_uniforms.merge(
+          specular: { type: :vec3, value: Color.new(0x111111) },
+          shininess: { type: :float, value: 30.0 }
+        )
+      end
+
+      def standard_uniforms
+        common_uniforms.merge(
+          diffuse: { type: :vec3, value: Color.new(0xffffff) },
+          emissive: { type: :vec3, value: Color.new(0x000000) },
+          roughness: { type: :float, value: 1.0 },
+          metalness: { type: :float, value: 0.0 },
+          opacity: { type: :float, value: 1.0 },
+          map: { type: :texture, value: nil },
+          use_map: { type: :bool, value: false },
+          ambient_light_color: { type: :vec3, value: Color.new(0x000000) },
+          directional_light_direction: { type: :vec3, value: Vector3.new(0, 1, 0) },
+          directional_light_color: { type: :vec3, value: Color.new(0xffffff) }
+        )
+      end
+    end
+  end
+end

data/lib/3rb/textures/cube_texture.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class CubeTexture < Texture
+    attr_accessor :images
+
+    def initialize(
+      images: Array.new(6),
+      mapping: :cube_reflection,
+      **options
+    )
+      super(mapping: mapping, **options)
+
+      @images = images
+      @flip_y = false
+    end
+
+    def image
+      @images
+    end
+
+    def image=(value)
+      @images = value
+    end
+  end
+end

data/lib/3rb/textures/data_texture.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class DataTexture < Texture
+    attr_accessor :data, :width, :height
+
+    def initialize(
+      data: nil,
+      width: 1,
+      height: 1,
+      format: :rgba,
+      type: :unsigned_byte,
+      **options
+    )
+      super(format: format, type: type, **options)
+
+      @data = data
+      @width = width
+      @height = height
+
+      @mag_filter = :nearest
+      @min_filter = :nearest
+
+      @generate_mipmaps = false
+      @flip_y = false
+      @unpack_alignment = 1
+
+      @needs_update = true
+    end
+
+    def image
+      { data: @data, width: @width, height: @height }
+    end
+  end
+end

data/lib/3rb/textures/render_target.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class RenderTarget
+    attr_accessor :uuid, :width, :height, :depth
+    attr_accessor :scissor, :scissor_test
+    attr_accessor :viewport
+    attr_accessor :texture, :depth_buffer, :stencil_buffer
+    attr_accessor :depth_texture
+
+    def initialize(
+      width: 1,
+      height: 1,
+      depth: 1,
+      min_filter: :linear,
+      mag_filter: :linear,
+      wrap_s: :clamp_to_edge,
+      wrap_t: :clamp_to_edge,
+      generate_mipmaps: false,
+      format: :rgba,
+      type: :unsigned_byte,
+      anisotropy: 1,
+      encoding: :linear,
+      depth_buffer: true,
+      stencil_buffer: false,
+      depth_texture: nil
+    )
+      @uuid = SecureRandom.uuid
+      @width = width
+      @height = height
+      @depth = depth
+
+      @scissor = Vector4.new(0, 0, width, height)
+      @scissor_test = false
+
+      @viewport = Vector4.new(0, 0, width, height)
+
+      @texture = Texture.new(
+        mag_filter: mag_filter,
+        min_filter: min_filter,
+        wrap_s: wrap_s,
+        wrap_t: wrap_t,
+        format: format,
+        type: type,
+        anisotropy: anisotropy
+      )
+      @texture.generate_mipmaps = generate_mipmaps
+      @texture.encoding = encoding
+
+      @depth_buffer = depth_buffer
+      @stencil_buffer = stencil_buffer
+      @depth_texture = depth_texture
+    end
+
+    def set_size(width, height, depth = 1)
+      return if @width == width && @height == height && @depth == depth
+
+      @width = width
+      @height = height
+      @depth = depth
+
+      @texture.needs_update = true
+
+      dispose
+    end
+
+    def clone
+      self.class.new.copy(self)
+    end
+
+    def copy(source)
+      @width = source.width
+      @height = source.height
+      @depth = source.depth
+
+      @viewport.copy(source.viewport)
+
+      @texture = source.texture.clone
+
+      @depth_buffer = source.depth_buffer
+      @stencil_buffer = source.stencil_buffer
+      @depth_texture = source.depth_texture&.clone
+
+      self
+    end
+
+    def dispose
+      @texture.version += 1
+    end
+  end
+
+  class WebGLRenderTarget < RenderTarget
+  end
+
+  class WebGLMultipleRenderTargets < RenderTarget
+    attr_accessor :textures
+
+    def initialize(width: 1, height: 1, count: 1, **options)
+      super(width: width, height: height, **options)
+
+      @textures = Array.new(count) do
+        Texture.new(
+          mag_filter: options[:mag_filter] || :linear,
+          min_filter: options[:min_filter] || :linear,
+          wrap_s: options[:wrap_s] || :clamp_to_edge,
+          wrap_t: options[:wrap_t] || :clamp_to_edge,
+          format: options[:format] || :rgba,
+          type: options[:type] || :unsigned_byte
+        )
+      end
+    end
+
+    def set_size(width, height, depth = 1)
+      return if @width == width && @height == height && @depth == depth
+
+      @width = width
+      @height = height
+      @depth = depth
+
+      @textures.each { |t| t.needs_update = true }
+
+      dispose
+    end
+  end
+end

data/lib/3rb/textures/texture.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Sunrb
+  class Texture
+    MAPPING = {
+      uv: 300,
+      cube_reflection: 301,
+      cube_refraction: 302,
+      equirectangular_reflection: 303,
+      equirectangular_refraction: 304,
+      spherical_reflection: 305
+    }.freeze
+
+    WRAPPING = {
+      repeat: 1000,
+      clamp_to_edge: 1001,
+      mirrored_repeat: 1002
+    }.freeze
+
+    FILTER = {
+      nearest: 1003,
+      nearest_mipmap_nearest: 1004,
+      nearest_mipmap_linear: 1005,
+      linear: 1006,
+      linear_mipmap_nearest: 1007,
+      linear_mipmap_linear: 1008
+    }.freeze
+
+    FORMAT = {
+      alpha: 1021,
+      rgb: 1022,
+      rgba: 1023,
+      luminance: 1024,
+      luminance_alpha: 1025,
+      depth: 1026,
+      depth_stencil: 1027
+    }.freeze
+
+    TYPE = {
+      unsigned_byte: 1009,
+      byte: 1010,
+      short: 1011,
+      unsigned_short: 1012,
+      int: 1013,
+      unsigned_int: 1014,
+      float: 1015,
+      half_float: 1016
+    }.freeze
+
+    attr_accessor :uuid, :name, :image, :mipmaps
+    attr_accessor :mapping, :wrap_s, :wrap_t
+    attr_accessor :mag_filter, :min_filter
+    attr_accessor :anisotropy
+    attr_accessor :format, :internal_format, :type
+    attr_accessor :offset, :repeat, :center, :rotation
+    attr_accessor :matrix_auto_update, :matrix
+    attr_accessor :generate_mipmaps, :premultiply_alpha, :flip_y
+    attr_accessor :unpack_alignment, :encoding
+    attr_accessor :version, :needs_update
+    attr_accessor :user_data
+
+    def initialize(
+      image: nil,
+      mapping: :uv,
+      wrap_s: :clamp_to_edge,
+      wrap_t: :clamp_to_edge,
+      mag_filter: :linear,
+      min_filter: :linear_mipmap_linear,
+      format: :rgba,
+      type: :unsigned_byte,
+      anisotropy: 1
+    )
+      @uuid = SecureRandom.uuid
+      @name = ""
+      @image = image
+      @mipmaps = []
+
+      @mapping = mapping
+      @wrap_s = wrap_s
+      @wrap_t = wrap_t
+
+      @mag_filter = mag_filter
+      @min_filter = min_filter
+
+      @anisotropy = anisotropy
+
+      @format = format
+      @internal_format = nil
+      @type = type
+
+      @offset = Vector2.new(0, 0)
+      @repeat = Vector2.new(1, 1)
+      @center = Vector2.new(0, 0)
+      @rotation = 0
+
+      @matrix_auto_update = true
+      @matrix = Matrix3.new
+
+      @generate_mipmaps = true
+      @premultiply_alpha = false
+      @flip_y = true
+      @unpack_alignment = 4
+
+      @encoding = :linear
+      @version = 0
+      @needs_update = false
+      @user_data = {}
+    end
+
+    def needs_update=(value)
+      @version += 1 if value
+      @needs_update = value
+    end
+
+    def update_matrix
+      @matrix.set_uv_transform(
+        @offset.x, @offset.y,
+        @repeat.x, @repeat.y,
+        @rotation,
+        @center.x, @center.y
+      )
+    end
+
+    def clone
+      self.class.new.copy(self)
+    end
+
+    def copy(source)
+      @name = source.name
+      @image = source.image
+      @mipmaps = source.mipmaps.dup
+
+      @mapping = source.mapping
+      @wrap_s = source.wrap_s
+      @wrap_t = source.wrap_t
+
+      @mag_filter = source.mag_filter
+      @min_filter = source.min_filter
+
+      @anisotropy = source.anisotropy
+
+      @format = source.format
+      @internal_format = source.internal_format
+      @type = source.type
+
+      @offset.copy(source.offset)
+      @repeat.copy(source.repeat)
+      @center.copy(source.center)
+      @rotation = source.rotation
+
+      @matrix_auto_update = source.matrix_auto_update
+      @matrix.copy(source.matrix)
+
+      @generate_mipmaps = source.generate_mipmaps
+      @premultiply_alpha = source.premultiply_alpha
+      @flip_y = source.flip_y
+      @unpack_alignment = source.unpack_alignment
+
+      @encoding = source.encoding
+      @user_data = source.user_data.dup
+
+      self
+    end
+
+    def dispose
+      @version += 1
+    end
+
+    def to_h
+      {
+        uuid: @uuid,
+        name: @name,
+        mapping: @mapping,
+        wrap_s: @wrap_s,
+        wrap_t: @wrap_t,
+        mag_filter: @mag_filter,
+        min_filter: @min_filter,
+        anisotropy: @anisotropy,
+        format: @format,
+        type: @type,
+        offset: @offset.to_a,
+        repeat: @repeat.to_a,
+        center: @center.to_a,
+        rotation: @rotation,
+        flip_y: @flip_y,
+        encoding: @encoding
+      }
+    end
+  end
+end

data/lib/3rb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Sunrb
+  VERSION = "0.1.0"
+end

data/lib/3rb.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "3rb/version"
+
+module Sunrb
+  class Error < StandardError; end
+  class GLError < Error; end
+  class ShaderCompileError < Error; end
+  class TextureLoadError < Error; end
+  class ModelLoadError < Error; end
+  class InvalidArgumentError < Error; end
+end
+
+require_relative "3rb/math/math_utils"
+require_relative "3rb/math/vector2"
+require_relative "3rb/math/vector3"
+require_relative "3rb/math/vector4"
+require_relative "3rb/math/matrix3"
+require_relative "3rb/math/matrix4"
+require_relative "3rb/math/quaternion"
+require_relative "3rb/math/euler"
+require_relative "3rb/math/color"
+
+require_relative "3rb/core/buffer_attribute"
+require_relative "3rb/core/object3d"
+require_relative "3rb/core/scene"
+require_relative "3rb/core/group"
+
+require_relative "3rb/geometries/buffer_geometry"
+require_relative "3rb/geometries/box_geometry"
+require_relative "3rb/geometries/sphere_geometry"
+require_relative "3rb/geometries/plane_geometry"
+require_relative "3rb/geometries/cylinder_geometry"
+require_relative "3rb/geometries/cone_geometry"
+require_relative "3rb/geometries/torus_geometry"
+
+require_relative "3rb/materials/material"
+require_relative "3rb/materials/basic_material"
+require_relative "3rb/materials/lambert_material"
+require_relative "3rb/materials/phong_material"
+require_relative "3rb/materials/standard_material"
+require_relative "3rb/materials/shader_material"
+
+require_relative "3rb/objects/mesh"
+require_relative "3rb/objects/line"
+require_relative "3rb/objects/points"
+
+require_relative "3rb/cameras/camera"
+require_relative "3rb/cameras/perspective_camera"
+require_relative "3rb/cameras/orthographic_camera"
+
+require_relative "3rb/lights/light"
+require_relative "3rb/lights/ambient_light"
+require_relative "3rb/lights/directional_light"
+require_relative "3rb/lights/point_light"
+require_relative "3rb/lights/spot_light"
+require_relative "3rb/lights/hemisphere_light"
+require_relative "3rb/lights/rect_area_light"
+
+require_relative "3rb/renderers/renderer"
+require_relative "3rb/renderers/opengl_renderer"
+require_relative "3rb/renderers/shader_lib"
+
+require_relative "3rb/dsl/helpers"
+require_relative "3rb/dsl/scene_builder"
+
+require_relative "3rb/textures/texture"
+require_relative "3rb/textures/data_texture"
+require_relative "3rb/textures/cube_texture"
+require_relative "3rb/textures/render_target"
+
+require_relative "3rb/loaders/loader"
+require_relative "3rb/loaders/texture_loader"
+require_relative "3rb/loaders/obj_loader"
+require_relative "3rb/loaders/gltf_loader"
+
+require_relative "3rb/controls/orbit_controls"
+
+require_relative "3rb/animation/animation_clip"
+require_relative "3rb/animation/animation_mixer"
+
+begin
+  require_relative "3rb/native"
+rescue LoadError => e
+  warn "Failed to load native FFI bindings: #{e.message}"
+end

data/shaders/basic.frag

@@ -0,0 +1,19 @@
+#version 330 core
+
+in vec2 vUv;
+out vec4 FragColor;
+
+uniform vec3 diffuse;
+uniform float opacity;
+uniform bool useMap;
+uniform sampler2D map;
+
+void main() {
+    vec4 diffuseColor = vec4(diffuse, opacity);
+
+    if (useMap) {
+        diffuseColor *= texture(map, vUv);
+    }
+
+    FragColor = diffuseColor;
+}

data/shaders/basic.vert

@@ -0,0 +1,15 @@
+#version 330 core
+
+layout (location = 0) in vec3 position;
+layout (location = 1) in vec3 normal;
+layout (location = 2) in vec2 uv;
+
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+
+out vec2 vUv;
+
+void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}

data/shaders/common/lights.glsl

@@ -0,0 +1,53 @@
+// Light structures and uniforms
+
+struct AmbientLight {
+    vec3 color;
+};
+
+struct DirectionalLight {
+    vec3 direction;
+    vec3 color;
+};
+
+struct PointLight {
+    vec3 position;
+    vec3 color;
+    float distance;
+    float decay;
+};
+
+struct SpotLight {
+    vec3 position;
+    vec3 direction;
+    vec3 color;
+    float distance;
+    float decay;
+    float coneCos;
+    float penumbraCos;
+};
+
+#define MAX_LIGHTS 4
+
+uniform AmbientLight ambientLights[MAX_LIGHTS];
+uniform int numAmbientLights;
+
+uniform DirectionalLight directionalLights[MAX_LIGHTS];
+uniform int numDirectionalLights;
+
+uniform PointLight pointLights[MAX_LIGHTS];
+uniform int numPointLights;
+
+uniform SpotLight spotLights[MAX_LIGHTS];
+uniform int numSpotLights;
+
+// Light calculation functions
+float getDistanceAttenuation(float lightDistance, float cutoffDistance, float decayExponent) {
+    if (cutoffDistance > 0.0 && decayExponent > 0.0) {
+        return pow(clamp(1.0 - pow(lightDistance / cutoffDistance, 4.0), 0.0, 1.0), decayExponent);
+    }
+    return 1.0;
+}
+
+float getSpotAttenuation(float coneCosine, float penumbraCosine, float angleCosine) {
+    return smoothstep(coneCosine, penumbraCosine, angleCosine);
+}

data/shaders/common/uniforms.glsl

@@ -0,0 +1,9 @@
+// Common uniforms for all shaders
+uniform mat4 modelMatrix;
+uniform mat4 modelViewMatrix;
+uniform mat4 projectionMatrix;
+uniform mat4 viewMatrix;
+uniform mat3 normalMatrix;
+uniform vec3 cameraPosition;
+
+uniform float time;

data/shaders/lambert.frag

@@ -0,0 +1,37 @@
+#version 330 core
+
+in vec3 vNormal;
+in vec3 vWorldPosition;
+in vec2 vUv;
+
+out vec4 FragColor;
+
+uniform vec3 diffuse;
+uniform vec3 emissive;
+uniform float opacity;
+uniform bool useMap;
+uniform sampler2D map;
+
+uniform vec3 ambientLightColor;
+uniform vec3 directionalLightDirection;
+uniform vec3 directionalLightColor;
+
+void main() {
+    vec3 normal = normalize(vNormal);
+
+    vec4 diffuseColor = vec4(diffuse, opacity);
+    if (useMap) {
+        diffuseColor *= texture(map, vUv);
+    }
+
+    // Ambient
+    vec3 lighting = ambientLightColor;
+
+    // Directional light (Lambertian)
+    float dotNL = max(dot(normal, directionalLightDirection), 0.0);
+    lighting += directionalLightColor * dotNL;
+
+    vec3 outgoingLight = diffuseColor.rgb * lighting + emissive;
+
+    FragColor = vec4(outgoingLight, diffuseColor.a);
+}