rgame 0.1.0 → 0.2.0

data/ext/rgame_core/graphics/clip.c

@@ -1,5 +1,7 @@
 #include "graphics/clip.h"
 
+#include <stdint.h>
+
 /* The canonical empty rect. Every path that produces "nothing" produces this
  * exact value, so two empties compare equal and cannot split a batch. */
 static const rgame_rect RGAME_EMPTY_RECT = { 0, 0, 0, 0 };
@@ -30,20 +32,27 @@ rgame_rect rgame_rect_intersect(rgame_rect a, rgame_rect b) {
     }
 
     /*
-     * Edges are computed in `long` rather than `int`. A caller can legitimately
-     * pass a very large width to mean "as wide as possible", and x + w would
-     * then overflow — which is undefined behaviour, not merely a wrong answer.
-     * The result always fits back in an int because it is bounded by the
-     * smaller of the two inputs.
+     * Edges are computed in `int64_t` rather than `int`. A caller can
+     * legitimately pass a very large width to mean "as wide as possible", and
+     * x + w would then overflow — which is undefined behaviour, not merely a
+     * wrong answer. The result always fits back in an int because it is
+     * bounded by the smaller of the two inputs.
+     *
+     * `int64_t` rather than `long`: `long` is only 32 bits on Windows (LLP64),
+     * the same width as `int` there, so it does not actually buy the extra
+     * headroom this needs — found by UBSan under clang64, which is the only
+     * configuration that caught it (the intermediate overflow this guards
+     * against never occurs in Check's own test values on a 64-bit `long`
+     * platform, so plain Linux/macOS runs never exercise the bug either).
      */
-    long left = a.x > b.x ? a.x : b.x;
-    long top = a.y > b.y ? a.y : b.y;
-    long a_right = (long)a.x + a.w;
-    long b_right = (long)b.x + b.w;
-    long a_bottom = (long)a.y + a.h;
-    long b_bottom = (long)b.y + b.h;
-    long right = a_right < b_right ? a_right : b_right;
-    long bottom = a_bottom < b_bottom ? a_bottom : b_bottom;
+    int64_t left = a.x > b.x ? a.x : b.x;
+    int64_t top = a.y > b.y ? a.y : b.y;
+    int64_t a_right = (int64_t)a.x + a.w;
+    int64_t b_right = (int64_t)b.x + b.w;
+    int64_t a_bottom = (int64_t)a.y + a.h;
+    int64_t b_bottom = (int64_t)b.y + b.h;
+    int64_t right = a_right < b_right ? a_right : b_right;
+    int64_t bottom = a_bottom < b_bottom ? a_bottom : b_bottom;
 
     if (right <= left || bottom <= top) {
         return RGAME_EMPTY_RECT;

data/ext/rgame_core/include/rgame/core.h

@@ -52,16 +52,93 @@ void rgame_app_destroy(rgame_app *app);
 #define RGAME_BUTTON_GAMEPAD_FIRST 0x1000
 #define RGAME_BUTTON_GAMEPAD_LAST 0x10FF
 
-/* Keyboard ids == SDL scancodes. Only the keys the engine actually binds are
- * named; adding one is a #define plus a _Static_assert in app.c. */
+/* Keyboard ids == SDL scancodes, which are physical *positions* rather than
+ * letters: RGAME_KEY_A is the key marked A on a QWERTY board and Q on AZERTY.
+ * The set is what a Western keyboard can be relied on to have. No numpad (most
+ * laptops have none), no GUI/Windows/Command key, no print-screen cluster, and
+ * nothing whose position depends on the layout. Those can be added when
+ * something needs them; each is a #define plus a _Static_assert in app.c. */
+#define RGAME_KEY_A 4
+#define RGAME_KEY_B 5
+#define RGAME_KEY_C 6
+#define RGAME_KEY_D 7
+#define RGAME_KEY_E 8
+#define RGAME_KEY_F 9
+#define RGAME_KEY_G 10
+#define RGAME_KEY_H 11
+#define RGAME_KEY_I 12
+#define RGAME_KEY_J 13
+#define RGAME_KEY_K 14
+#define RGAME_KEY_L 15
+#define RGAME_KEY_M 16
+#define RGAME_KEY_N 17
+#define RGAME_KEY_O 18
+#define RGAME_KEY_P 19
+#define RGAME_KEY_Q 20
+#define RGAME_KEY_R 21
+#define RGAME_KEY_S 22
+#define RGAME_KEY_T 23
+#define RGAME_KEY_U 24
+#define RGAME_KEY_V 25
+#define RGAME_KEY_W 26
+#define RGAME_KEY_X 27
+#define RGAME_KEY_Y 28
+#define RGAME_KEY_Z 29
+#define RGAME_KEY_1 30
+#define RGAME_KEY_2 31
+#define RGAME_KEY_3 32
+#define RGAME_KEY_4 33
+#define RGAME_KEY_5 34
+#define RGAME_KEY_6 35
+#define RGAME_KEY_7 36
+#define RGAME_KEY_8 37
+#define RGAME_KEY_9 38
+#define RGAME_KEY_0 39
 #define RGAME_KEY_RETURN 40
 #define RGAME_KEY_ESCAPE 41
+#define RGAME_KEY_BACKSPACE 42
+#define RGAME_KEY_TAB 43
 #define RGAME_KEY_SPACE 44
+#define RGAME_KEY_MINUS 45
+#define RGAME_KEY_EQUALS 46
+#define RGAME_KEY_LEFTBRACKET 47
+#define RGAME_KEY_RIGHTBRACKET 48
+#define RGAME_KEY_BACKSLASH 49
+#define RGAME_KEY_SEMICOLON 51
+#define RGAME_KEY_APOSTROPHE 52
+#define RGAME_KEY_GRAVE 53
+#define RGAME_KEY_COMMA 54
+#define RGAME_KEY_PERIOD 55
+#define RGAME_KEY_SLASH 56
+#define RGAME_KEY_CAPSLOCK 57
 #define RGAME_KEY_F1 58
+#define RGAME_KEY_F2 59
+#define RGAME_KEY_F3 60
+#define RGAME_KEY_F4 61
+#define RGAME_KEY_F5 62
+#define RGAME_KEY_F6 63
+#define RGAME_KEY_F7 64
+#define RGAME_KEY_F8 65
+#define RGAME_KEY_F9 66
+#define RGAME_KEY_F10 67
+#define RGAME_KEY_F11 68
+#define RGAME_KEY_F12 69
+#define RGAME_KEY_INSERT 73
+#define RGAME_KEY_HOME 74
+#define RGAME_KEY_PAGEUP 75
+#define RGAME_KEY_DELETE 76
+#define RGAME_KEY_END 77
+#define RGAME_KEY_PAGEDOWN 78
 #define RGAME_KEY_RIGHT 79
 #define RGAME_KEY_LEFT 80
 #define RGAME_KEY_DOWN 81
 #define RGAME_KEY_UP 82
+#define RGAME_KEY_LCTRL 224
+#define RGAME_KEY_LSHIFT 225
+#define RGAME_KEY_LALT 226
+#define RGAME_KEY_RCTRL 228
+#define RGAME_KEY_RSHIFT 229
+#define RGAME_KEY_RALT 230
 
 /* Gamepad button ids: the gamepad range plus SDL's controller button number.
  * app.c asserts each against the SDL constant it mirrors, as with the keys. */
@@ -80,6 +157,12 @@ void rgame_app_destroy(rgame_app *app);
 #define RGAME_PAD_DPAD_DOWN (RGAME_BUTTON_GAMEPAD_FIRST + 12)
 #define RGAME_PAD_DPAD_LEFT (RGAME_BUTTON_GAMEPAD_FIRST + 13)
 #define RGAME_PAD_DPAD_RIGHT (RGAME_BUTTON_GAMEPAD_FIRST + 14)
+#define RGAME_PAD_MISC1 (RGAME_BUTTON_GAMEPAD_FIRST + 15)
+#define RGAME_PAD_PADDLE1 (RGAME_BUTTON_GAMEPAD_FIRST + 16)
+#define RGAME_PAD_PADDLE2 (RGAME_BUTTON_GAMEPAD_FIRST + 17)
+#define RGAME_PAD_PADDLE3 (RGAME_BUTTON_GAMEPAD_FIRST + 18)
+#define RGAME_PAD_PADDLE4 (RGAME_BUTTON_GAMEPAD_FIRST + 19)
+#define RGAME_PAD_TOUCHPAD (RGAME_BUTTON_GAMEPAD_FIRST + 20)
 
 /*
  * Analog axes are their own small id space rather than part of the button
@@ -121,6 +204,7 @@ void rgame_app_destroy(rgame_app *app);
 typedef void (*rgame_frame_begin_fn)(void *userdata);
 typedef void (*rgame_update_fn)(void *userdata, double dt_seconds);
 typedef void (*rgame_draw_fn)(void *userdata);
+typedef void (*rgame_frame_end_fn)(void *userdata);
 typedef int (*rgame_needs_redraw_fn)(void *userdata);
 typedef void (*rgame_button_fn)(void *userdata, int button_id);
 typedef void (*rgame_resize_fn)(void *userdata, int width, int height);
@@ -141,6 +225,12 @@ typedef void (*rgame_gamepad_fn)(void *userdata, int slot);
  *  - `needs_redraw` is polled before drawing; returning 0 skips the draw for
  *    that frame (simulation still advances). NULL means always redraw.
  *  - `draw` renders one frame.
+ *  - `frame_end` runs once per rendered frame, after that frame's drawing has
+ *    been submitted to the GPU but *before* the buffer swap — the only point
+ *    at which the frame just drawn can be read back deterministically. Never
+ *    called when `needs_redraw` skipped the draw. Rarely needed: it exists for
+ *    reading pixels back for a test, not for game code, since a real driver is
+ *    free to swap however it likes once `draw` returns.
  *  - `button_down`/`button_up` report discrete key presses and releases. Key
  *    repeats are filtered out, so holding a key reports exactly one press.
  *  - `resize` reports a new window size; the GL viewport is already updated.
@@ -154,6 +244,7 @@ typedef struct {
     rgame_update_fn update;
     rgame_needs_redraw_fn needs_redraw;
     rgame_draw_fn draw;
+    rgame_frame_end_fn frame_end;
     rgame_button_fn button_down;
     rgame_button_fn button_up;
     rgame_resize_fn resize;
@@ -360,7 +451,7 @@ int rgame_app_draw_image_rot(rgame_app *app, const rgame_image *image, float cx,
                              float angle_degrees, float scale, unsigned int color, double z);
 
 /*
- * The transform and clip stacks. Every push is undone by the same
+ * The transform, clip and layer stacks. Every push is undone by the same
  * `rgame_app_pop`, so a caller can never pop the wrong one; a push that cannot
  * be honoured (a full stack) is still counted, so pops stay balanced and the
  * drawing comes out untransformed rather than desynchronised.
@@ -378,6 +469,25 @@ void rgame_app_push_scale(rgame_app *app, float sx, float sy);
  * always succeed as far as the caller is concerned.
  */
 int rgame_app_push_clip(rgame_app *app, int x, int y, int width, int height);
+
+/*
+ * The layer stack: what every subsequent `z` is measured from, until the
+ * matching pop. It *replaces* rather than accumulates, and starts at 0, so a
+ * caller that never pushes one gets exactly the z it passes.
+ *
+ * `rgame_app_next_layer_slot` is the other half: one counter per band, reset at
+ * the start of each frame, handing out increasing indices. It counts and
+ * nothing more — what a band means, and how a slot index becomes a base, is
+ * decided a layer up (RGame::Util::Z). Bands outside 0..7 answer 0.
+ *
+ * Together they are how a scene graph gives each node its own narrow window of
+ * z values: the traversal takes the next slot as it reaches a node, so draw
+ * order is tree order, and a node's `z:` can only reorder its own drawing.
+ */
+void rgame_app_push_layer(rgame_app *app, double base);
+double rgame_app_layer(rgame_app *app);
+unsigned int rgame_app_next_layer_slot(rgame_app *app, int band);
+
 void rgame_app_pop(rgame_app *app);
 
 /*

data/ext/rgame_core/input/gamepad.c

@@ -11,15 +11,69 @@ _Static_assert(RGAME_GAMEPAD_AXIS_COUNT == SDL_CONTROLLER_AXIS_MAX,
 
 /* Gamepad button ids are the gamepad range plus SDL's own button number, so
  * each named id must line up with the SDL constant it mirrors. */
-_Static_assert(RGAME_PAD_A == RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_A,
+_Static_assert(RGAME_PAD_A ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_A,
                "pad id must match SDL controller button");
-_Static_assert(RGAME_PAD_START == RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_START,
+_Static_assert(RGAME_PAD_B ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_B,
                "pad id must match SDL controller button");
-_Static_assert(RGAME_PAD_DPAD_UP == RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_DPAD_UP,
+_Static_assert(RGAME_PAD_X ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_X,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_Y ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_Y,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_BACK ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_BACK,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_GUIDE ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_GUIDE,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_START ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_START,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_LEFT_STICK ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_LEFTSTICK,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_RIGHT_STICK ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_RIGHTSTICK,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_LEFT_SHOULDER ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_LEFTSHOULDER,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_RIGHT_SHOULDER ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_RIGHTSHOULDER,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_DPAD_UP ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_DPAD_UP,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_DPAD_DOWN ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_DPAD_DOWN,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_DPAD_LEFT ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_DPAD_LEFT,
                "pad id must match SDL controller button");
 _Static_assert(RGAME_PAD_DPAD_RIGHT ==
                    RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_DPAD_RIGHT,
                "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_MISC1 ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_MISC1,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_PADDLE1 ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_PADDLE1,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_PADDLE2 ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_PADDLE2,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_PADDLE3 ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_PADDLE3,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_PADDLE4 ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_PADDLE4,
+               "pad id must match SDL controller button");
+_Static_assert(RGAME_PAD_TOUCHPAD ==
+                   RGAME_BUTTON_GAMEPAD_FIRST + SDL_CONTROLLER_BUTTON_TOUCHPAD,
+               "pad id must match SDL controller button");
 _Static_assert(RGAME_AXIS_LEFT_X == SDL_CONTROLLER_AXIS_LEFTX, "axis id must match SDL axis");
 _Static_assert(RGAME_AXIS_TRIGGER_RIGHT == SDL_CONTROLLER_AXIS_TRIGGERRIGHT,
                "axis id must match SDL axis");

data/ext/rgame_core/ruby/core_ext.c

@@ -23,6 +23,9 @@
  *     def button_down(id); end   # discrete key press
  *     def button_up(id); end
  *     def frame_begin; end       # once per frame, before the tick batch
+ *     def frame_end; end         # after draw is submitted, before the swap —
+ *                                 # rarely needed; it exists for reading pixels
+ *                                 # back in a test, not for game code
  *     def resize(w, h); end
  *     def gamepad_connected(slot); end
  *     def gamepad_disconnected(slot); end
@@ -47,6 +50,7 @@
 static ID id_frame_begin;
 static ID id_update;
 static ID id_draw;
+static ID id_frame_end;
 static ID id_needs_redraw;
 static ID id_button_down;
 static ID id_button_up;
@@ -265,6 +269,10 @@ static void tramp_draw(void *userdata) {
     protected_call((run_state *)userdata, id_draw, 0, NULL);
 }
 
+static void tramp_frame_end(void *userdata) {
+    protected_call((run_state *)userdata, id_frame_end, 0, NULL);
+}
+
 static int tramp_needs_redraw(void *userdata) {
     VALUE result = protected_call((run_state *)userdata, id_needs_redraw, 0, NULL);
     return RTEST(result) ? 1 : 0;
@@ -308,6 +316,7 @@ static VALUE app_run(VALUE self) {
         .update = tramp_update,
         .needs_redraw = tramp_needs_redraw,
         .draw = tramp_draw,
+        .frame_end = tramp_frame_end,
         .button_down = tramp_button_down,
         .button_up = tramp_button_up,
         .resize = tramp_resize,
@@ -421,6 +430,11 @@ static VALUE app_default_draw(VALUE self) {
     return Qnil;
 }
 
+static VALUE app_default_frame_end(VALUE self) {
+    (void)self;
+    return Qnil;
+}
+
 /* Default is "always redraw", matching a NULL needs_redraw in the C API. */
 static VALUE app_default_needs_redraw(VALUE self) {
     (void)self;
@@ -457,6 +471,7 @@ void Init_core_ext(void) {
     id_frame_begin = rb_intern("frame_begin");
     id_update = rb_intern("update");
     id_draw = rb_intern("draw");
+    id_frame_end = rb_intern("frame_end");
     id_needs_redraw = rb_intern("needs_redraw?");
     id_button_down = rb_intern("button_down");
     id_button_up = rb_intern("button_up");
@@ -498,6 +513,7 @@ void Init_core_ext(void) {
     rb_define_method(cApp, "frame_begin", app_default_frame_begin, 0);
     rb_define_method(cApp, "update", app_default_update, 1);
     rb_define_method(cApp, "draw", app_default_draw, 0);
+    rb_define_method(cApp, "frame_end", app_default_frame_end, 0);
     rb_define_method(cApp, "needs_redraw?", app_default_needs_redraw, 0);
     rb_define_method(cApp, "button_down", app_default_button, 1);
     rb_define_method(cApp, "button_up", app_default_button, 1);

data/ext/rgame_core/ruby/renderer_ext.c

@@ -297,6 +297,26 @@ static VALUE renderer_push_clip(VALUE self, VALUE x, VALUE y, VALUE width, VALUE
     return self;
 }
 
+/*
+ * #push_layer(base) / #layer — the base every subsequent z is measured from.
+ *
+ * `base` is a whole number well inside a double's exact range (see
+ * RGame::Util::Z), so it crosses as a double and comes back as a Float.
+ */
+static VALUE renderer_push_layer(VALUE self, VALUE base) {
+    rgame_app_push_layer(drawing_app(self), NUM2DBL(base));
+    return self;
+}
+
+static VALUE renderer_layer(VALUE self) {
+    return DBL2NUM(rgame_app_layer(drawing_app(self)));
+}
+
+/* #next_layer_slot(band) -> the next slot index in that band this frame. */
+static VALUE renderer_next_layer_slot(VALUE self, VALUE band) {
+    return UINT2NUM(rgame_app_next_layer_slot(drawing_app(self), NUM2INT(band)));
+}
+
 /* ------------------------------------------------------------------------- *
  * Recording
  *
@@ -368,6 +388,9 @@ void rgame_init_renderer(VALUE mCore) {
     rb_define_method(cRenderer, "push_rotate", renderer_push_rotate, 3);
     rb_define_method(cRenderer, "push_scale", renderer_push_scale, 2);
     rb_define_method(cRenderer, "push_clip", renderer_push_clip, 4);
+    rb_define_method(cRenderer, "push_layer", renderer_push_layer, 1);
+    rb_define_method(cRenderer, "layer", renderer_layer, 0);
+    rb_define_method(cRenderer, "next_layer_slot", renderer_next_layer_slot, 1);
     rb_define_method(cRenderer, "pop", renderer_pop, 0);
 
     rb_define_method(cRenderer, "begin_record", renderer_begin_record, 0);

data/ext/rgame_util/color_ext.c

@@ -63,10 +63,19 @@ static VALUE color_s_new(int argc, VALUE *argv, VALUE klass) {
                                        NIL_P(a) ? 255 : component(a, "alpha")));
 }
 
-/* Color.from_packed(0xRRGGBBAA) */
+/* Color.from_packed(0xRRGGBBAA)
+ *
+ * The bounds check below needs a C type wider than 32 bits so a
+ * one-bit-too-wide value can be caught rather than silently truncated.
+ * `unsigned long` is that on Linux/macOS (LP64: 64 bits) but not on Windows
+ * (LLP64: `long` stays 32 bits even in a 64-bit build), where NUM2ULONG would
+ * itself raise RangeError on the very value this function means to turn into
+ * a clean ArgumentError. NUM2ULL is unsigned long long, 64 bits on every
+ * platform this project builds for, so the check below runs before either
+ * platform's integer width can get in the way. */
 static VALUE color_s_from_packed(VALUE klass, VALUE packed) {
-    unsigned long value = NUM2ULONG(packed);
-    if (value > 0xFFFFFFFFul) {
+    unsigned long long value = NUM2ULL(packed);
+    if (value > 0xFFFFFFFFull) {
         rb_raise(rb_eArgError, "packed colour must fit in 32 bits");
     }
     return color_wrap(klass, (rgame_color)value);

data/lib/rgame/core/app.rb

@@ -16,6 +16,8 @@
 #                              # fixed step, never wall-clock frame time
 #     def needs_redraw?; end   # false skips the draw (simulation still runs)
 #     def draw; end            # render one frame
+#     def frame_end; end       # after draw is submitted, before the swap —
+#                              # rarely needed outside a test that reads pixels
 #     def button_down(id); end # discrete key press (no repeats)
 #     def button_up(id); end
 #     def resize(w, h); end

data/lib/rgame/core/input.rb

@@ -5,72 +5,66 @@ require_relative '../util/controls'
 
 module RGame
   module Core
-    # Translates the game's symbolic actions (:fire, :confirm) into the physical
-    # button ids the engine understands, and asks the app whether they're held.
+    # Asks the engine whether a physical input is active, on a given device.
     #
     #   input = RGame::Core::Input.new(app)
-    #   input.down?(:fire)                 # keyboard, the single-player default
-    #   input.down?(:fire, device: 1)      # the pad in player slot 0
-    #   input.axis(:move_x, device: 1)     # => Float, -1.0..1.0
+    #   input.down?(Controls::KEY_SPACE)                          # keyboard
+    #   input.down?(Controls::PAD_A, device: Controls.gamepad(0))  # player 1's pad
+    #   input.axis(Controls::AXIS_LEFT_X, device: Controls.gamepad(0))
     #
-    # The id vocabulary itself lives in RGame::Util::Controls, not here: ids are
-    # values, and the engine layer must be able to name one without touching
-    # Core. That is also what makes rebinding possible — a game builds its own
-    # table from those constants and passes it in:
+    # **This is the raw query, and deliberately nothing more.** It used to carry
+    # binding tables of its own — `down?(:fire)` resolved `:fire` to a scancode
+    # through one of three tables passed to the constructor. Those are gone, and
+    # binding now lives one layer up in RGame::Engine::InputMap, for two
+    # reasons. A game's rebinding screen has to be able to edit the table, and
+    # the engine layer may not name RGame::Core at all; and with a player per
+    # device, the table is a per-player value rather than a property of the one
+    # object that talks to the hardware.
     #
-    #   controls = RGame::Util::Controls
-    #   input = RGame::Core::Input.new(
-    #     app, bindings: controls::DEFAULT_KEYBOARD.merge(fire: controls::KEY_J)
-    #   )
+    # What is left is an argument-order adapter over the app's own
+    # `input_down?(device, id)` / `input_axis(device, axis_id)`. It stays a named
+    # class rather than collapsing into those, because it is what gets handed to
+    # the engine layer as an input backend — and handing it a whole App, which
+    # can also close the window and rename it, would be a worse seam.
     #
-    # Devices are numbered keyboard-first: Controls::KEYBOARD is 0, and
-    # Controls.gamepad(slot) is the pad in that player slot. Defaulting
-    # `device:` to the keyboard is what lets single-player call sites stay
-    # `input.down?(:fire)` with no ceremony.
+    # Ids come from RGame::Util::Controls. They are values with nothing behind
+    # them, so both layers can name one.
     #
     # **There is no pointer or mouse support, by design.** The layer this
     # replaced had a cursor position and a click button riding the same "is
     # held" path as keys, and none of it was carried over: this engine's input
-    # is keyboard and controllers. A game wanting click-based UI has to build
-    # hit-testing on top rather than find it here, and the intended answer for
-    # menus is keyboard and controller navigation instead.
+    # is keyboard and controllers. The intended answer for menus is keyboard and
+    # controller navigation instead.
     class Input
       Controls = RGame::Util::Controls
 
-      # `bindings` covers the keyboard, `pad_bindings` the controllers, and
-      # `axis_bindings` the analog axes. All default to the standard tables.
-      def initialize(app,
-                     bindings: Controls::DEFAULT_KEYBOARD,
-                     pad_bindings: Controls::DEFAULT_PAD,
-                     axis_bindings: Controls::DEFAULT_AXES)
+      def initialize(app)
         @app = app
-        @bindings = bindings
-        @pad_bindings = pad_bindings
-        @axis_bindings = axis_bindings
       end
 
-      # Is the action's physical button held on `device`?
+      # Is `id` held on `device`?
       #
       # Reads the engine's per-frame input snapshot, so the answer is identical
       # for every simulation tick within one frame — a key held for a single
       # frame behaves the same whether that frame ran one catch-up tick or five.
+      #
+      # A device only answers for its own kind of input: asking a gamepad about
+      # a keyboard scancode is `false`, never the keyboard's answer. That is
+      # what lets one binding table list a key and a pad button for the same
+      # action and still keep player two's pad from echoing player one.
       # hot-path
-      def down?(action, device: Controls::KEYBOARD)
-        @app.input_down?(device, bindings_for(device).fetch(action))
+      def down?(id, device: Controls::KEYBOARD)
+        @app.input_down?(device, id)
       end
 
       # Current value of an analog axis: sticks -1.0..1.0, triggers 0.0..1.0.
       # The keyboard has no axes, so it always reads 0.0.
+      #
+      # No dead zone is applied here — this is the hardware's answer. Ignoring
+      # a resting stick's jitter is RGame::Engine::ActionMapper's job.
       # hot-path
-      def axis(action, device: Controls::KEYBOARD)
-        @app.input_axis(device, @axis_bindings.fetch(action))
-      end
-
-      private
-
-      # hot-path
-      def bindings_for(device)
-        device == Controls::KEYBOARD ? @bindings : @pad_bindings
+      def axis(axis_id, device: Controls::KEYBOARD)
+        @app.input_axis(device, axis_id)
       end
     end
   end

data/lib/rgame/core/recording.rb

@@ -2,6 +2,7 @@
 
 require 'rgame/core_ext'
 require_relative '../util/color'
+require_relative '../util/z'
 
 module RGame
   module Core
@@ -37,6 +38,7 @@ module RGame
     #   renderer.clipped(0, 0, 400, 600) { ground.draw(0, 0) }
     class Recording
       Color = RGame::Util::Color
+      Z = RGame::Util::Z
 
       # Replays everything that was recorded, with the recording's origin at
       # (x, y).
@@ -45,7 +47,7 @@ module RGame
       # so white (the default) draws the recording unchanged and a colour with
       # alpha fades the whole layer out at once.
       def draw(x = 0, y = 0, z: 0, color: nil)
-        draw_at(x, y, z, Color.coerce(color).packed)
+        draw_at(x, y, Z.offset(z), Color.coerce(color).packed)
       end
     end
   end