@solidrt/2d 0.0.55 → 0.0.57

package/src/index.ts

@@ -1,29 +1,70 @@
 // @solidrt/2d - an instanced sprite layer above @solidrt/core/gpu.
-// One atlas, N quads in one draw. The live layer (createSpriteLayer/
-// addSprite) backs every sprite with a SPATIAL ARENA node whose Pose2D
-// record sink writes the pose instance buffer at the core flush, so core
-// producers reach sprites and picking walks the core BVH; style stays a
-// JS-written second instance buffer. The records layer (createRecordLayer)
+// One atlas, N quads in one draw per VIEW: a layer holds the sprites and
+// shows only through its views (layer.createView / <View2d>, each a target
+// with a camera of its own - a Unity scene renders only through Cameras,
+// a Godot World2D only through Viewports). The live layer
+// (createSpriteLayer/addSprite) backs every sprite with a SPATIAL ARENA
+// node whose Pose2D record sink writes the pose instance buffer at the
+// core flush, so core producers reach sprites and picking walks the core
+// BVH; style stays a JS-written second instance buffer. The records layer (createRecordLayer)
 // is the raw escape hatch for motion only JS can compute: 13 JS-owned
 // floats per sprite published through the zero-copy write lease. The baked
 // tile layer (createTileLayer/TileLayer) is the static sibling: a tile
 // world rendered once into textures and composited as a few quads,
 // re-baked on change. Two faces throughout: the imperative core (usable
 // without Solid components) and the components (SpriteLayer/Sprite/Group/
-// TileLayer) on top. See AGENTS.md for the model and the traps.
+// View2d/TileLayer) on top. See AGENTS.md for the model and the traps.
 
-export { addGroup, addSprite, createSpriteLayer, getSprite, removeGroup, removeSprite, setGroup, setGroupTransition, setSprite, setSpriteParent, setSpriteTransition, POSE_FLOATS, STYLE_FLOATS } from "./layer.ts"
+export { addGroup, addSprite, createSpriteLayer, getSprite, removeGroup, removeSprite, setGroup, setGroupTransition, setSprite, setSpriteParent, setSpriteTransition, worldPosition, POSE_FLOATS, STYLE_FLOATS } from "./layer.ts"
 export { createRecordLayer, FLOATS_PER_SPRITE } from "./records.ts"
-export type { RecordLayer as RecordLayerHandle } from "./records.ts"
+export type { RecordLayer as RecordLayerHandle, RecordLayerOptions } from "./records.ts"
 export { pointInSprite } from "./pick.ts"
-export type { AddSpriteOptions, CameraUpdate, GroupOptions, Sprite as SpriteHandle, SpriteGroup, SpriteHandlers, SpriteLayer as SpriteLayerHandle, SpriteLayerOptions, SpriteOptions, SpritePointerEvent, TransitionEndEvent } from "./layer.ts"
+export { projectCamera, unprojectCamera } from "./camera.ts"
+export type { CameraState, CameraUpdate } from "./camera.ts"
+export { createCamera2d } from "./camera2d.ts"
+export type { Camera2d as Camera2dHandle, Camera2dAxes, Camera2dOptions, Camera2dPose, Camera2dTarget, Rect2d } from "./camera2d.ts"
+export { camera2dActions, camera2dBindings } from "./input.ts"
+export type { CameraDevices } from "./input.ts"
+export type {
+  AddSpriteOptions,
+  Capsule,
+  Circle,
+  GroupOptions,
+  Impact,
+  MoveOptions,
+  MoveResult,
+  Overlap,
+  QueryOptions,
+  RayHit,
+  Rect,
+  LayerPointerEvent,
+  LayerPointerListener,
+  LayerTapEvent,
+  LayerWheelEvent,
+  Sprite as SpriteHandle,
+  SpriteGroup,
+  SpriteHandlers,
+  SpriteLayer as SpriteLayerHandle,
+  SpriteLayerOptions,
+  SpriteOptions,
+  SpritePointerEvent,
+  SpriteTapEvent,
+  SpriteWheelEvent,
+  TransitionEndEvent,
+  Volume,
+} from "./layer.ts"
+export { feedPointer } from "./views.ts"
+export type { ViewHandle, ViewOptions } from "./views.ts"
 export { createTileLayer } from "./tiles.ts"
 export type { TileChunk, TileLayer as TileLayerHandle, TileLayerOptions } from "./tiles.ts"
 
 export type { NodeTransition, NodeTransitionSpec } from "flux:spatial"
 export { grid, namedFrames, FULL_FRAME } from "./frames.ts"
-export type { Frame, GridOptions } from "./frames.ts"
+export type { AtlasSize, Frame, GridOptions, NamedFramesOptions } from "./frames.ts"
+export { createAnimation } from "./animation.ts"
+export type { AnimationOptions, SpriteAnimation } from "./animation.ts"
+export { fitOversample } from "./oversample.ts"
 export { createAtlas } from "./atlas.ts"
 export type { Atlas, AtlasOptions } from "./atlas.ts"
-export { Group, Sprite, SpriteLayer, TileLayer, useSpriteLayer } from "./components.tsx"
-export type { GroupProps, SpriteLayerProps, SpritePointerProps, SpriteProps, TileCamera, TileLayerProps } from "./components.tsx"
+export { Camera2d, Group, Sprite, SpriteLayer, TileLayer, View2d, useSpriteLayer } from "./components/index.ts"
+export type { Camera2dProps, GroupProps, LayerPointerProps, SpriteLayerProps, SpritePointerProps, SpriteProps, TileCamera, TileLayerProps, View2dProps } from "./components/index.ts"

package/src/input.ts

@@ -0,0 +1,50 @@
+// The standard input wiring for the 2d camera: the action declarations it
+// consumes (its axes, by the shared vocabulary) and a preset that binds
+// the devices an app hands in - plain data the app could write by hand,
+// applied with `input.bind(camera2dBindings({ pointer, gamepad }))` and
+// adjusted afterwards with unbind; nothing binds unless the app says so
+// (ARCHITECTURE.md). `pointer` is the feed of the view showing the layer
+// (`createPointerFeed()`, handed to `<SpriteLayer pointer>` or
+// `<View2d pointer>`, or bridged with feedPointer for an imperative view),
+// `gamepad` a core gamepad device, `keyboard` the core keyboard device.
+//
+// Keys and sticks move the CAMERA where a drag moves the content (the
+// arrow right scrolls the view right, as every map does), so those
+// bindings go through invert() and `pan` keeps its one meaning.
+
+import { invert } from "@solidrt/core/input"
+import type { Binding, GamepadDevice, KeyboardDevice, PointerFeed } from "@solidrt/core"
+
+export type CameraDevices = {
+  pointer?: PointerFeed
+  gamepad?: GamepadDevice
+  keyboard?: KeyboardDevice
+}
+
+/** The 2d camera's actions: `pan`, `zoom`, `roll`. */
+export let camera2dActions = { pan: "vec2", zoom: "axis", roll: "axis" } as const
+
+/**
+ * The 2d camera's standard bindings: one finger or a mouse drag pans and
+ * so do two fingers, a pinch and the wheel zoom about the pointer, a twist
+ * rolls; the left stick scrolls, the triggers zoom, the right stick's x
+ * rolls; the arrow keys scroll and minus/equals zoom.
+ */
+export function camera2dBindings(devices: CameraDevices): Binding[] {
+  let out: Binding[] = []
+  let { pointer, gamepad, keyboard } = devices
+  if (pointer) {
+    out.push(
+      { action: "pan", source: pointer.drag },
+      { action: "pan", source: pointer.pan },
+      { action: "zoom", source: pointer.pinch },
+      { action: "zoom", source: pointer.wheel },
+      { action: "roll", source: pointer.twist },
+    )
+  }
+  if (gamepad) {
+    out.push({ action: "pan", source: invert(gamepad.leftStick) }, { action: "zoom", source: gamepad.triggers }, { action: "roll", source: invert(gamepad.axis("rightX")) })
+  }
+  if (keyboard) out.push({ action: "pan", source: invert(keyboard.arrows) }, { action: "zoom", source: keyboard.axis("Minus", "Equal") })
+  return out
+}