dama 0.1.0-x86_64-linux

data/lib/dama/game.rb

@@ -0,0 +1,88 @@
+module Dama
+  # Top-level orchestrator for a Dama game.
+  #
+  # Example:
+  #   game = Dama::Game.new do
+  #     settings resolution: [1280, 720], title: "My Game"
+  #     start_scene MenuScene
+  #   end
+  #   game.start
+  class Game
+    attr_reader :registry, :configuration, :backend, :asset_cache
+
+    def initialize(&)
+      @registry = Registry.new
+      @builder = Game::Builder.new(registry:)
+      builder.instance_eval(&)
+      @configuration = builder.configuration
+      @start_scene_class = builder.start_scene_class
+      @backend = Backend.for
+      @asset_cache = AssetCache.new(backend:)
+    end
+
+    def start
+      run_game(frame_controller: Debug::FrameController.new)
+    end
+
+    # Run exactly N frames, then stop. For debugging and testing.
+    def run_frames(count)
+      run_game(frame_controller: Debug::FrameController.new(frame_limit: count))
+    end
+
+    def screenshot(output_path)
+      screenshot_tool.capture(output_path:)
+    end
+
+    private
+
+    attr_reader :builder, :start_scene_class, :current_scene, :pending_scene_class
+
+    def run_game(frame_controller:)
+      backend.initialize_engine(configuration:)
+      load_initial_scene
+      game_loop(frame_controller:).run
+    ensure
+      asset_cache.release_all
+      backend.shutdown
+    end
+
+    def load_initial_scene
+      @current_scene = build_scene(start_scene_class)
+    end
+
+    def build_scene(scene_class)
+      scene = scene_class.new(
+        registry:, asset_cache:, backend:,
+        scene_switcher: method(:request_scene_switch)
+      )
+      scene.perform_compose
+      scene.perform_enter
+      scene
+    end
+
+    def request_scene_switch(scene_class)
+      @pending_scene_class = scene_class
+    end
+
+    def apply_pending_scene_switch
+      return unless pending_scene_class
+
+      @current_scene = build_scene(pending_scene_class)
+      @pending_scene_class = nil
+    end
+
+    def game_loop(frame_controller:)
+      @game_loop ||= Game::Loop.new(
+        backend:,
+        scene_provider: -> { current_scene },
+        frame_controller:,
+        input: Input.new(backend:),
+        scene_transition: method(:apply_pending_scene_switch),
+      )
+    end
+
+    def screenshot_tool
+      @screenshot_tool ||= Debug::ScreenshotTool.new(backend:)
+    end
+  end
+end

data/lib/dama/geometry/circle.rb

@@ -0,0 +1,28 @@
+module Dama
+  module Geometry
+    # Decomposes a circle into a triangle fan (segments × 3 vertices).
+    # Each vertex is [x, y, r, g, b, a, u, v] — 8 floats in pixel coordinates.
+    class Circle
+      def self.vertices(cx:, cy:, radius:, r:, g:, b:, a:, segments: 32)
+        result = []
+        angle_step = (2.0 * Math::PI) / segments
+
+        segments.times do |i|
+          angle1 = angle_step * i
+          angle2 = angle_step * (i + 1)
+
+          x1 = cx + (radius * Math.cos(angle1))
+          y1 = cy + (radius * Math.sin(angle1))
+          x2 = cx + (radius * Math.cos(angle2))
+          y2 = cy + (radius * Math.sin(angle2))
+
+          result.push(cx, cy, r, g, b, a, 0.0, 0.0,
+                      x1, y1, r, g, b, a, 0.0, 0.0,
+                      x2, y2, r, g, b, a, 0.0, 0.0)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/dama/geometry/rect.rb

@@ -0,0 +1,16 @@
+module Dama
+  module Geometry
+    # Decomposes a rectangle into 2 triangles (6 vertices).
+    # Each vertex is [x, y, r, g, b, a, u, v] — 8 floats in pixel coordinates.
+    class Rect
+      def self.vertices(x:, y:, w:, h:, r:, g:, b:, a:)
+        [x,     y,     r, g, b, a, 0.0, 0.0,
+         x + w, y,     r, g, b, a, 0.0, 0.0,
+         x,     y + h, r, g, b, a, 0.0, 0.0,
+         x + w, y,     r, g, b, a, 0.0, 0.0,
+         x + w, y + h, r, g, b, a, 0.0, 0.0,
+         x,     y + h, r, g, b, a, 0.0, 0.0]
+      end
+    end
+  end
+end

data/lib/dama/geometry/sprite.rb

@@ -0,0 +1,18 @@
+module Dama
+  module Geometry
+    # Decomposes a textured sprite quad into 2 triangles (6 vertices).
+    # Each vertex is [x, y, r, g, b, a, u, v] — 8 floats in pixel coordinates.
+    # UV maps the full texture (0,0)→(1,1) by default; override for atlas sub-regions.
+    class Sprite
+      def self.vertices(x:, y:, w:, h:, r: 1.0, g: 1.0, b: 1.0, a: 1.0,
+                        u_min: 0.0, v_min: 0.0, u_max: 1.0, v_max: 1.0)
+        [x,     y,     r, g, b, a, u_min, v_min,
+         x + w, y,     r, g, b, a, u_max, v_min,
+         x,     y + h, r, g, b, a, u_min, v_max,
+         x + w, y,     r, g, b, a, u_max, v_min,
+         x + w, y + h, r, g, b, a, u_max, v_max,
+         x,     y + h, r, g, b, a, u_min, v_max]
+      end
+    end
+  end
+end

data/lib/dama/geometry/triangle.rb

@@ -0,0 +1,13 @@
+module Dama
+  module Geometry
+    # Decomposes a triangle into 3 vertices.
+    # Each vertex is [x, y, r, g, b, a, u, v] — 8 floats in pixel coordinates.
+    class Triangle
+      def self.vertices(x1:, y1:, x2:, y2:, x3:, y3:, r:, g:, b:, a:)
+        [x1, y1, r, g, b, a, 0.0, 0.0,
+         x2, y2, r, g, b, a, 0.0, 0.0,
+         x3, y3, r, g, b, a, 0.0, 0.0]
+      end
+    end
+  end
+end

data/lib/dama/geometry.rb

@@ -0,0 +1,4 @@
+module Dama
+  module Geometry
+  end
+end

data/lib/dama/input/keyboard_state.rb

@@ -0,0 +1,44 @@
+module Dama
+  class Input
+    # Maps symbolic key names to winit KeyCode values and queries
+    # the backend for current key state.
+    class KeyboardState
+      # Maps symbolic key names to Dama::Keys constants.
+      KEY_CODES = {
+        left: Keys::ARROW_LEFT,
+        right: Keys::ARROW_RIGHT,
+        up: Keys::ARROW_UP,
+        down: Keys::ARROW_DOWN,
+        space: Keys::SPACE,
+        enter: Keys::ENTER,
+        escape: Keys::ESCAPE,
+        a: Keys::KEY_A,
+        b: Keys::KEY_B,
+        c: Keys::KEY_C,
+        d: Keys::KEY_D,
+        w: Keys::KEY_W,
+        s: Keys::KEY_S,
+        equal: Keys::EQUAL,
+        minus: Keys::MINUS,
+      }.freeze
+
+      def initialize(backend:)
+        @backend = backend
+      end
+
+      def pressed?(key:)
+        code = KEY_CODES.fetch(key)
+        backend.key_pressed?(key_code: code)
+      end
+
+      def just_pressed?(key:)
+        code = KEY_CODES.fetch(key)
+        backend.key_just_pressed?(key_code: code)
+      end
+
+      private
+
+      attr_reader :backend
+    end
+  end
+end

data/lib/dama/input/mouse_state.rb

@@ -0,0 +1,45 @@
+module Dama
+  class Input
+    # Tracks mouse position and button state with edge detection.
+    # Call #update once per frame before querying.
+    class MouseState
+      BUTTON_CODES = {
+        left: 0,
+        right: 1,
+        middle: 2,
+      }.freeze
+
+      def initialize(backend:)
+        @backend = backend
+        @previous_pressed = Hash.new(false)
+        @current_pressed = Hash.new(false)
+      end
+
+      def x = backend.mouse_x
+      def y = backend.mouse_y
+
+      def pressed?(button:)
+        code = BUTTON_CODES.fetch(button)
+        backend.mouse_button_pressed?(button: code)
+      end
+
+      # Returns true only on the frame the button transitions
+      # from released to pressed (edge detection).
+      def just_pressed?(button:)
+        current_pressed.fetch(button, false) && !previous_pressed.fetch(button, false)
+      end
+
+      # Must be called once per frame to track state transitions.
+      def update
+        BUTTON_CODES.each_key do |button|
+          previous_pressed[button] = current_pressed[button]
+          current_pressed[button] = pressed?(button:)
+        end
+      end
+
+      private
+
+      attr_reader :backend, :previous_pressed, :current_pressed
+    end
+  end
+end

data/lib/dama/input.rb

@@ -0,0 +1,38 @@
+module Dama
+  # Snapshot of input state for a single frame.
+  # Provides convenience methods for common input queries.
+  class Input
+    def initialize(backend:)
+      @keyboard = Input::KeyboardState.new(backend:)
+      @mouse = Input::MouseState.new(backend:)
+    end
+
+    # Generic key queries — works for any named key.
+    def key_pressed?(key) = keyboard.pressed?(key:)
+    def key_just_pressed?(key) = keyboard.just_pressed?(key:)
+
+    # Keyboard convenience methods.
+    def left?  = keyboard.pressed?(key: :left)
+    def right? = keyboard.pressed?(key: :right)
+    def up?    = keyboard.pressed?(key: :up)
+    def down?  = keyboard.pressed?(key: :down)
+    def space? = keyboard.pressed?(key: :space)
+    def escape? = keyboard.pressed?(key: :escape)
+
+    # Mouse convenience methods.
+    def mouse_x = mouse.x
+    def mouse_y = mouse.y
+    def mouse_pressed?(button) = mouse.pressed?(button:)
+    def mouse_just_pressed?(button) = mouse.just_pressed?(button:)
+    def mouse_clicked? = mouse.just_pressed?(button: :left)
+
+    # Must be called once per frame to track mouse button transitions.
+    def update
+      mouse.update
+    end
+
+    private
+
+    attr_reader :keyboard, :mouse
+  end
+end

data/lib/dama/keys.rb

@@ -0,0 +1,67 @@
+module Dama
+  # Named constants for keyboard key codes matching winit's KeyCode enum.
+  # Use these instead of raw numeric values when querying input state.
+  #
+  # Values are the Rust enum discriminant indices for winit::keyboard::KeyCode.
+  module Keys
+    ARROW_LEFT  = 80
+    ARROW_RIGHT = 81
+    ARROW_UP    = 82
+    ARROW_DOWN  = 79
+
+    SPACE  = 62
+    ENTER  = 57
+    ESCAPE = 114
+
+    BACKSPACE = 52
+    TAB       = 63
+
+    LEFT_SHIFT  = 60
+    LEFT_CTRL   = 55
+    LEFT_ALT    = 50
+    RIGHT_SHIFT = 61
+    RIGHT_CTRL  = 56
+    RIGHT_ALT   = 51
+
+    KEY_A = 19
+    KEY_B = 20
+    KEY_C = 21
+    KEY_D = 22
+    KEY_E = 23
+    KEY_F = 24
+    KEY_G = 25
+    KEY_H = 26
+    KEY_I = 27
+    KEY_J = 28
+    KEY_K = 29
+    KEY_L = 30
+    KEY_M = 31
+    KEY_N = 32
+    KEY_O = 33
+    KEY_P = 34
+    KEY_Q = 35
+    KEY_R = 36
+    KEY_S = 37
+    KEY_T = 38
+    KEY_U = 39
+    KEY_V = 40
+    KEY_W = 41
+    KEY_X = 42
+    KEY_Y = 43
+    KEY_Z = 44
+
+    EQUAL = 15
+    MINUS = 45
+
+    DIGIT_0 = 5
+    DIGIT_1 = 6
+    DIGIT_2 = 7
+    DIGIT_3 = 8
+    DIGIT_4 = 9
+    DIGIT_5 = 10
+    DIGIT_6 = 11
+    DIGIT_7 = 12
+    DIGIT_8 = 13
+    DIGIT_9 = 14
+  end
+end

data/lib/dama/node/component_slot.rb

@@ -0,0 +1,18 @@
+module Dama
+  class Node
+    # Binds a Component class to its default attribute values.
+    # When a Node is instantiated, each slot builds a component instance.
+    class ComponentSlot
+      attr_reader :component_class, :defaults
+
+      def initialize(component_class:, defaults:)
+        @component_class = component_class
+        @defaults = defaults
+      end
+
+      def build(**overrides)
+        component_class.new(**defaults, **overrides)
+      end
+    end
+  end
+end

data/lib/dama/node/draw_context.rb

@@ -0,0 +1,96 @@
+module Dama
+  class Node
+    # Evaluation context for a Node's draw block. Provides drawing
+    # primitives (rect, triangle, circle) and exposes all node
+    # attributes and component accessors as direct methods.
+    #
+    # When a camera is present, all coordinates are automatically
+    # transformed from world space to screen space.
+    #
+    # Custom shaders can be applied to any shape via the `shader:` keyword:
+    #   rect(x, y, w, h, color: Dama::Colors::RED, shader: glow)
+    class DrawContext
+      def initialize(node:, backend:, camera: nil)
+        @node = node
+        @backend = backend
+        @camera = camera
+      end
+
+      def rect(x, y, w, h, color: Dama::Colors::WHITE, r: color.r, g: color.g, b: color.b, a: color.a, shader: nil)
+        sx, sy = apply_camera(x, y)
+        sw = w * zoom_factor
+        sh = h * zoom_factor
+        with_shader(shader) { backend.draw_rect(x: sx, y: sy, w: sw, h: sh, r:, g:, b:, a:) }
+      end
+
+      def triangle(x1, y1, x2, y2, x3, y3, color: Dama::Colors::WHITE,
+                   r: color.r, g: color.g, b: color.b, a: color.a, shader: nil)
+        sx1, sy1 = apply_camera(x1, y1)
+        sx2, sy2 = apply_camera(x2, y2)
+        sx3, sy3 = apply_camera(x3, y3)
+        with_shader(shader) do
+          backend.draw_triangle(x1: sx1, y1: sy1, x2: sx2, y2: sy2, x3: sx3, y3: sy3, r:, g:, b:, a:)
+        end
+      end
+
+      def circle(cx, cy, radius, color: Dama::Colors::WHITE,
+                 r: color.r, g: color.g, b: color.b, a: color.a, segments: 32, shader: nil)
+        sx, sy = apply_camera(cx, cy)
+        with_shader(shader) do
+          backend.draw_circle(cx: sx, cy: sy, radius: radius * zoom_factor, r:, g:, b:, a:, segments:)
+        end
+      end
+
+      def text(content, x, y, size: 24.0, color: Dama::Colors::WHITE,
+               r: color.r, g: color.g, b: color.b, a: color.a, font: nil)
+        sx, sy = apply_camera(x, y)
+        backend.draw_text(text: content.to_s, x: sx, y: sy, size: size * zoom_factor, r:, g:, b:, a:, font:)
+      end
+
+      def sprite(texture_handle, x, y, w, h, color: Dama::Colors::WHITE,
+                 r: color.r, g: color.g, b: color.b, a: color.a, shader: nil)
+        sx, sy = apply_camera(x, y)
+        sw = w * zoom_factor
+        sh = h * zoom_factor
+        with_shader(shader) do
+          backend.draw_sprite(texture_handle:, x: sx, y: sy, w: sw, h: sh, r:, g:, b:, a:)
+        end
+      end
+
+      def method_missing(method_name, ...)
+        return super unless node.respond_to?(method_name)
+
+        node.public_send(method_name, ...)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        node.respond_to?(method_name, include_private) || super
+      end
+
+      private
+
+      attr_reader :node, :backend, :camera
+
+      def apply_camera(world_x, world_y)
+        return [world_x, world_y] unless camera
+
+        result = camera.world_to_screen(world_x:, world_y:)
+        [result.fetch(:screen_x), result.fetch(:screen_y)]
+      end
+
+      def zoom_factor
+        camera ? camera.zoom : 1.0
+      end
+
+      # Wraps a draw call with shader activation/deactivation.
+      # If no shader is specified, the block executes unchanged.
+      def with_shader(shader_handle)
+        return yield unless shader_handle
+
+        backend.set_shader(handle: shader_handle)
+        yield
+        backend.set_shader(handle: 0)
+      end
+    end
+  end
+end

data/lib/dama/node.rb

@@ -0,0 +1,139 @@
+module Dama
+  # Base class for game entities. Nodes compose Components via named
+  # accessors, declare attributes, textures, and define draw behavior.
+  #
+  # Example:
+  #   class Player < Dama::Node
+  #     component Transform, as: :transform, x: 50.0, y: 50.0
+  #     texture :sprite, path: "assets/player.png"
+  #     attribute :name, default: "Player"
+  #
+  #     draw do
+  #       sprite(sprite, transform.x, transform.y, 32, 32)
+  #     end
+  #   end
+  class Node
+    class << self
+      def component(component_class, as:, **defaults)
+        component_slots[as] = ComponentSlot.new(component_class:, defaults:)
+        define_method(as) { components.fetch(as) }
+      end
+
+      def attribute(name, default: nil)
+        attribute_definitions[name] = default
+        attr_accessor name
+      end
+
+      # Declare a texture asset with a named accessor.
+      # The texture is loaded via AssetCache during scene composition
+      # and the GPU handle is accessible as a method on the node.
+      def texture(name, path:)
+        texture_declarations[name] = path
+        define_method(name) { texture_handles.fetch(name) }
+      end
+
+      # Declare a custom WGSL fragment shader with a named accessor.
+      # The shader is loaded via the backend during scene composition
+      # and the handle is accessible as a method on the node.
+      #
+      # Example:
+      #   shader :glow, path: "assets/shaders/glow.wgsl"
+      #   shader :invert, source: "@fragment\nfn fs_main(...) { ... }"
+      def shader(name, path: nil, source: nil)
+        shader_declarations[name] = { path:, source: }
+        define_method(name) { shader_handles.fetch(name) }
+      end
+
+      def draw(&block)
+        @draw_block = block
+      end
+
+      def component_slots
+        @component_slots ||= {}
+      end
+
+      def attribute_definitions
+        @attribute_definitions ||= {}
+      end
+
+      def texture_declarations
+        @texture_declarations ||= {}
+      end
+
+      def shader_declarations
+        @shader_declarations ||= {}
+      end
+
+      # Declare a physics body for this node.
+      # The body is created during scene composition if the scene has physics enabled.
+      def physics_body(**options)
+        @physics_body_options = options
+      end
+
+      attr_reader :physics_body_options, :draw_block
+    end
+
+    attr_accessor :physics
+
+    def initialize(**values)
+      @components = {}
+      @texture_handles = {}
+      @shader_handles = {}
+      @physics = nil
+      initialize_components(values)
+      initialize_attributes(values)
+    end
+
+    # Load all declared textures via the AssetCache.
+    def load_textures(asset_cache:)
+      self.class.texture_declarations.each do |name, path|
+        texture_handles[name] = asset_cache.acquire(path:)
+      end
+    end
+
+    # Release all declared textures from the AssetCache.
+    def unload_textures(asset_cache:)
+      self.class.texture_declarations.each_value do |path|
+        asset_cache.release(path:)
+      end
+      texture_handles.clear
+    end
+
+    # Load all declared shaders via the backend.
+    def load_shaders(backend:)
+      self.class.shader_declarations.each do |name, declaration|
+        source = declaration[:source] || File.read(declaration.fetch(:path))
+        shader_handles[name] = backend.load_shader(source:)
+      end
+    end
+
+    # Unload all declared shaders via the backend.
+    def unload_shaders(backend:)
+      shader_handles.each_value do |handle|
+        backend.unload_shader(handle:)
+      end
+      shader_handles.clear
+    end
+
+    private
+
+    attr_reader :components, :texture_handles, :shader_handles
+
+    def initialize_components(values)
+      self.class.component_slots.each do |name, slot|
+        # Allow constructor values to override component defaults.
+        # e.g., PieceNode.new(x: 100.0) overrides Transform's default x.
+        component_attrs = slot.component_class.attribute_set.map(&:name)
+        overrides = values.slice(*component_attrs)
+        components[name] = slot.build(**overrides)
+      end
+    end
+
+    def initialize_attributes(values)
+      self.class.attribute_definitions.each do |name, default|
+        value = values.fetch(name, default)
+        public_send(:"#{name}=", value)
+      end
+    end
+  end
+end

data/lib/dama/physics/body.rb

@@ -0,0 +1,57 @@
+module Dama
+  module Physics
+    # A physics body attached to a node. Tracks velocity, acceleration,
+    # and collider shape. Updated by Physics::World each frame.
+    class Body
+      BODY_TYPES = %i[dynamic static kinematic].freeze
+
+      attr_reader :type, :mass, :collider, :node
+      attr_accessor :velocity_x, :velocity_y, :acceleration_x, :acceleration_y,
+                    :restitution
+
+      def initialize(type:, collider:, mass: 1.0, node: nil, restitution: 0.0)
+        @type = type
+        @mass = mass.to_f
+        @collider = collider
+        @node = node
+        @velocity_x = 0.0
+        @velocity_y = 0.0
+        @acceleration_x = 0.0
+        @acceleration_y = 0.0
+        @restitution = restitution.to_f
+      end
+
+      def dynamic? = type == :dynamic
+      def static? = type == :static
+      def kinematic? = type == :kinematic
+
+      # Current position from the node's transform component.
+      def x
+        node.transform.x
+      end
+
+      def y
+        node.transform.y
+      end
+
+      def x=(value)
+        node.transform.x = value
+      end
+
+      def y=(value)
+        node.transform.y = value
+      end
+
+      # Integrate velocity and acceleration over delta_time.
+      def integrate(delta_time:, gravity_x: 0.0, gravity_y: 0.0)
+        return unless dynamic?
+
+        self.velocity_x += (acceleration_x + gravity_x) * delta_time
+        self.velocity_y += (acceleration_y + gravity_y) * delta_time
+
+        self.x = x + (velocity_x * delta_time)
+        self.y = y + (velocity_y * delta_time)
+      end
+    end
+  end
+end