stagecraft 1.0.0

data/lib/stagecraft/textures/sampler_state.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  module Textures
+    SamplerState = Data.define(
+      :wrap_u, :wrap_v, :wrap_w, :mag_filter, :min_filter, :mipmap_filter,
+      :lod_min, :lod_max, :compare, :max_anisotropy
+    ) do
+      FILTERS = %i[nearest linear].freeze
+
+      def initialize(wrap_u: :repeat, wrap_v: :repeat, wrap_w: :repeat,
+                     mag_filter: :linear, min_filter: :linear, mipmap_filter: :linear,
+                     lod_min: 0.0, lod_max: 32.0, compare: nil, max_anisotropy: 1)
+        super(
+          wrap_u: normalize_wrap(wrap_u),
+          wrap_v: normalize_wrap(wrap_v),
+          wrap_w: normalize_wrap(wrap_w),
+          mag_filter: mag_filter.to_sym,
+          min_filter: min_filter.to_sym,
+          mipmap_filter: mipmap_filter.to_sym,
+          lod_min: Float(lod_min),
+          lod_max: Float(lod_max),
+          compare: compare&.to_sym,
+          max_anisotropy: Integer(max_anisotropy)
+        )
+        validate!
+      end
+
+      private
+
+      def normalize_wrap(value)
+        {
+          repeat: :repeat,
+          mirrored_repeat: :mirror_repeat,
+          mirror_repeat: :mirror_repeat,
+          clamp_to_edge: :clamp_to_edge
+        }.fetch(value.to_sym)
+      end
+
+      def validate!
+        raise ArgumentError, "mag_filter must be :nearest or :linear" unless FILTERS.include?(mag_filter)
+        raise ArgumentError, "min_filter must be :nearest or :linear" unless FILTERS.include?(min_filter)
+        unless FILTERS.include?(mipmap_filter)
+          raise ArgumentError, "mipmap_filter must be :nearest or :linear"
+        end
+        raise ArgumentError, "lod_min must be non-negative" if lod_min.negative?
+        raise ArgumentError, "lod_max must be at least lod_min" if lod_max < lod_min
+        unless max_anisotropy.between?(1, 16)
+          raise ArgumentError, "max_anisotropy must be between 1 and 16"
+        end
+        return if max_anisotropy == 1 ||
+                  [mag_filter, min_filter, mipmap_filter].all? { |filter| filter == :linear }
+
+        raise ArgumentError, "anisotropic filtering requires linear filters"
+      end
+    end
+  end
+end

data/lib/stagecraft/textures/texture.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  module Textures
+    class Texture
+      attr_reader :image, :sampler, :color_space, :version
+
+      def initialize(image = nil, sampler: SamplerState.new, color_space: nil)
+        @version = 0
+        @disposed = false
+        @dispose_callbacks = []
+        self.image = image
+        self.sampler = sampler
+        self.color_space = color_space
+      end
+
+      def self.load(source, **options)
+        require "texel"
+        color_space = options.delete(:color_space)
+        channels = options.delete(:channels)
+        image = Texel.load(source, channels:, color_space:)
+        new(image, color_space:, **options)
+      end
+
+      def image=(value)
+        assign(:@image, value)
+      end
+
+      def sampler=(value)
+        raise ArgumentError, "expected a SamplerState" unless value.is_a?(SamplerState)
+
+        assign(:@sampler, value)
+      end
+
+      def color_space=(value)
+        assign(:@color_space, value&.to_sym)
+      end
+
+      def on_dispose(&block)
+        @dispose_callbacks << block
+        self
+      end
+
+      def dispose
+        return self if @disposed
+
+        @disposed = true
+        @version += 1
+        @dispose_callbacks.each { |callback| callback.call(self) }
+        @dispose_callbacks.clear
+        self
+      end
+
+      def disposed?
+        @disposed
+      end
+
+      private
+
+      def assign(variable, value)
+        return value if instance_variable_defined?(variable) && instance_variable_get(variable) == value
+
+        instance_variable_set(variable, value)
+        @version += 1
+        value
+      end
+    end
+  end
+
+  Texture = Textures::Texture
+end

data/lib/stagecraft/version.rb

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

data/lib/stagecraft/window/adapter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  module Window
+    class Adapter
+      def initialize
+        @callbacks = Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def on_pointer_button(&block)
+        subscribe(:pointer_button, &block)
+      end
+
+      def on_pointer_move(&block)
+        subscribe(:pointer_move, &block)
+      end
+
+      def on_scroll(&block)
+        subscribe(:scroll, &block)
+      end
+
+      def on_resize(&block)
+        subscribe(:resize, &block)
+      end
+
+      private
+
+      def subscribe(event, &block)
+        @callbacks[event] << block
+        self
+      end
+
+      def emit(event, ...)
+        @callbacks[event].each { |callback| callback.call(...) }
+      end
+    end
+  end
+end

data/lib/stagecraft/window/glfw.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  module Window
+    class Glfw < Adapter
+      attr_reader :native
+
+      def initialize(title:, width:, height:, resizable: true, surface_factory: nil)
+        super()
+        require "glfw"
+        ::GLFW.init
+        @native = ::GLFW::Window.new(
+          width, height, title,
+          client_api: ::GLFW::GLFW_NO_API,
+          resizable:
+        )
+        @surface_factory = surface_factory
+        attach_callbacks
+      end
+
+      def create_surface(instance)
+        return @surface_factory.call(instance, native) if @surface_factory
+
+        raise Error, <<~MESSAGE.strip
+          glfw-ruby does not expose a portable WebGPU surface handle; pass surface_factory:
+          or use window: :sdl3, whose native surface bridge is built into wgpu
+        MESSAGE
+      end
+
+      def poll_events
+        ::GLFW.poll_events
+        []
+      end
+
+      def should_close?
+        native.should_close?
+      end
+
+      def drawable_size
+        native.framebuffer_size
+      end
+
+      def close
+        native.destroy
+        ::GLFW.terminate
+      end
+
+      private
+
+      def attach_callbacks
+        native.on_mouse_button do |_window, button, action, _mods|
+          x, y = native.cursor_pos
+          emit(:pointer_button, button, action == :press, x, y)
+        end
+        native.on_cursor_pos do |_window, x, y|
+          previous = @cursor_position || [x, y]
+          @cursor_position = [x, y]
+          emit(:pointer_move, x, y, x - previous[0], y - previous[1])
+        end
+        native.on_scroll { |_window, x, y| emit(:scroll, x, y) }
+        native.on_resize { |_window, width, height| emit(:resize, width, height) }
+      end
+    end
+
+    GLFW = Glfw
+  end
+end

data/lib/stagecraft/window/sdl3.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Stagecraft
+  module Window
+    class Sdl3 < Adapter
+      attr_reader :native
+
+      def initialize(title:, width:, height:, resizable: true)
+        super()
+        require "wgpu"
+        require "wgpu/window"
+        @native = WGPU::Window::SDLWindow.new(title:, width:, height:, resizable:)
+        @close_requested = false
+      end
+
+      def create_surface(instance)
+        native.create_surface(instance)
+      end
+
+      def poll_events
+        events = native.poll_events
+        events.each { |event| dispatch(event) }
+        events
+      end
+
+      def should_close?
+        @close_requested
+      end
+
+      def drawable_size
+        native.drawable_size
+      end
+
+      def close
+        native.close
+      end
+
+      private
+
+      def dispatch(event)
+        @close_requested = true if event.quit? ||
+                                   (event.respond_to?(:close_requested?) && event.close_requested?)
+        if event.mouse_button_down? || event.mouse_button_up?
+          emit(:pointer_button, event.button, event.mouse_button_down?, event.x, event.y)
+        elsif event.mouse_motion?
+          emit(:pointer_move, event.x, event.y, event.xrel, event.yrel)
+        elsif event.is_a?(::SDL3::MouseWheelEvent)
+          emit(:scroll, event.x, event.y)
+        elsif event.respond_to?(:resized?) && event.resized?
+          emit(:resize, event.data1, event.data2)
+        end
+      end
+    end
+
+    SDL3 = Sdl3
+  end
+end

data/lib/stagecraft.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "larb"
+
+require_relative "stagecraft/version"
+require_relative "stagecraft/color"
+require_relative "stagecraft/core/observed_value"
+require_relative "stagecraft/core/bounding"
+require_relative "stagecraft/core/node"
+require_relative "stagecraft/core/scene"
+require_relative "stagecraft/core/mesh"
+require_relative "stagecraft/core/attribute"
+require_relative "stagecraft/core/geometry"
+require_relative "stagecraft/core/raycaster"
+require_relative "stagecraft/core/skin"
+require_relative "stagecraft/cameras/camera"
+require_relative "stagecraft/cameras/perspective_camera"
+require_relative "stagecraft/cameras/orthographic_camera"
+require_relative "stagecraft/lights/light"
+require_relative "stagecraft/lights/ambient_light"
+require_relative "stagecraft/lights/directional_light"
+require_relative "stagecraft/lights/point_light"
+require_relative "stagecraft/lights/spot_light"
+require_relative "stagecraft/materials/material"
+require_relative "stagecraft/materials/unlit_material"
+require_relative "stagecraft/materials/pbr_material"
+require_relative "stagecraft/materials/shader_material"
+require_relative "stagecraft/textures/sampler_state"
+require_relative "stagecraft/textures/texture"
+require_relative "stagecraft/textures/cube_texture"
+require_relative "stagecraft/geometries"
+require_relative "stagecraft/physics_binding"
+require_relative "stagecraft/renderer/stats"
+require_relative "stagecraft/renderer/features"
+require_relative "stagecraft/renderer/render_list"
+require_relative "stagecraft/renderer/pipeline_cache"
+require_relative "stagecraft/renderer/shaders"
+require_relative "stagecraft/renderer/uniform_packer"
+require_relative "stagecraft/renderer/resource_cache"
+require_relative "stagecraft/renderer/frame"
+require_relative "stagecraft/renderer/wgpu_compatibility"
+require_relative "stagecraft/renderer/gpu_context"
+require_relative "stagecraft/renderer/frame_resources"
+require_relative "stagecraft/renderer/pipeline_factory"
+require_relative "stagecraft/renderer/renderer"
+require_relative "stagecraft/window/adapter"
+require_relative "stagecraft/window/sdl3"
+require_relative "stagecraft/window/glfw"
+require_relative "stagecraft/controls/orbit_controls"
+require_relative "stagecraft/animation/track"
+require_relative "stagecraft/animation/clip"
+require_relative "stagecraft/animation/action"
+require_relative "stagecraft/animation/mixer"
+require_relative "stagecraft/loaders/gltf_loader"
+require_relative "stagecraft/app"
+
+module Stagecraft
+  class Error < StandardError; end
+  class DisposedError < Error; end
+end

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: stagecraft
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: larb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rgltf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: texel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: wgpu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: |-
+  Stagecraft combines a hierarchical scene graph, glTF assets, animation,
+  physically based materials, and a WebGPU renderer behind a Ruby-friendly API.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- docs/api.md
+- docs/tutorial.md
+- examples/01_spinning_cube.rb
+- examples/02_primitives.rb
+- examples/03_pbr_materials.rb
+- examples/04_lights.rb
+- examples/05_directional_shadow.rb
+- examples/06_transparency.rb
+- examples/07_texture.rb
+- examples/08_shader_material.rb
+- examples/09_gltf_loader.rb
+- examples/10_animation.rb
+- examples/11_scene_graph.rb
+- examples/12_orbit_controls.rb
+- examples/13_orthographic_camera.rb
+- examples/14_raycaster.rb
+- examples/15_offscreen.rb
+- examples/16_msaa.rb
+- examples/17_physics_binding.rb
+- examples/18_custom_geometry.rb
+- examples/19_imgui_stats.rb
+- examples/20_window_adapters.rb
+- examples/README.md
+- examples/support/demo.rb
+- lib/stagecraft.rb
+- lib/stagecraft/animation/action.rb
+- lib/stagecraft/animation/clip.rb
+- lib/stagecraft/animation/mixer.rb
+- lib/stagecraft/animation/track.rb
+- lib/stagecraft/app.rb
+- lib/stagecraft/cameras/camera.rb
+- lib/stagecraft/cameras/orthographic_camera.rb
+- lib/stagecraft/cameras/perspective_camera.rb
+- lib/stagecraft/color.rb
+- lib/stagecraft/controls/orbit_controls.rb
+- lib/stagecraft/core/attribute.rb
+- lib/stagecraft/core/bounding.rb
+- lib/stagecraft/core/geometry.rb
+- lib/stagecraft/core/mesh.rb
+- lib/stagecraft/core/node.rb
+- lib/stagecraft/core/observed_value.rb
+- lib/stagecraft/core/raycaster.rb
+- lib/stagecraft/core/scene.rb
+- lib/stagecraft/core/skin.rb
+- lib/stagecraft/geometries.rb
+- lib/stagecraft/lights/ambient_light.rb
+- lib/stagecraft/lights/directional_light.rb
+- lib/stagecraft/lights/light.rb
+- lib/stagecraft/lights/point_light.rb
+- lib/stagecraft/lights/spot_light.rb
+- lib/stagecraft/loaders/gltf_loader.rb
+- lib/stagecraft/materials/material.rb
+- lib/stagecraft/materials/pbr_material.rb
+- lib/stagecraft/materials/shader_material.rb
+- lib/stagecraft/materials/unlit_material.rb
+- lib/stagecraft/physics_binding.rb
+- lib/stagecraft/renderer/features.rb
+- lib/stagecraft/renderer/frame.rb
+- lib/stagecraft/renderer/frame_resources.rb
+- lib/stagecraft/renderer/gpu_context.rb
+- lib/stagecraft/renderer/pipeline_cache.rb
+- lib/stagecraft/renderer/pipeline_factory.rb
+- lib/stagecraft/renderer/render_list.rb
+- lib/stagecraft/renderer/renderer.rb
+- lib/stagecraft/renderer/resource_cache.rb
+- lib/stagecraft/renderer/shaders.rb
+- lib/stagecraft/renderer/shaders/common.wgsl
+- lib/stagecraft/renderer/shaders/pbr.wgsl
+- lib/stagecraft/renderer/shaders/shadow.wgsl
+- lib/stagecraft/renderer/shaders/skinning.wgsl
+- lib/stagecraft/renderer/shaders/tonemap.wgsl
+- lib/stagecraft/renderer/shaders/unlit.wgsl
+- lib/stagecraft/renderer/stats.rb
+- lib/stagecraft/renderer/uniform_packer.rb
+- lib/stagecraft/renderer/wgpu_compatibility.rb
+- lib/stagecraft/textures/cube_texture.rb
+- lib/stagecraft/textures/sampler_state.rb
+- lib/stagecraft/textures/texture.rb
+- lib/stagecraft/version.rb
+- lib/stagecraft/window/adapter.rb
+- lib/stagecraft/window/glfw.rb
+- lib/stagecraft/window/sdl3.rb
+homepage: https://github.com/ydah/stagecraft
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ydah/stagecraft
+  source_code_uri: https://github.com/ydah/stagecraft
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: A three.js-like scene graph and WebGPU renderer for Ruby
+test_files: []