# Skate 3 physics engine for Zero `skate_physics` integrates a reconstructed Skate 3 physics engine into Zero. Use this package for Skate 3-style skateboard and rider physics, or use its custom rigid-body solver components independently. It exposes a reconstructed Skate 3-derived Rust solver through editable entities, components and assets: physical bodies, collision volumes, joints, constraints, motors, forces and simulation state. It is a reusable simulation system, not just a skateboarding controller or a park scene. ## Why use it? Build and tune connected physical assemblies without first writing the integration between a custom solver and Zero. Inspect velocities and forces, change mass and inertia, configure joint limits, and drive mechanisms with spring/damper or hard motors. Motors apply impulses through the solver rather than teleporting bodies. The general body/joint/drive layer does not require a rider or animation clips. The package connects physics authoring, fixed-step simulation and entity presentation. Use it to experiment with constrained bodies, motor-driven mechanisms and vehicle assemblies; the skateboard and rider are included applications of the system, not its definition. ## What it provides - `World`: authority-gated fixed-step simulation and publication of solved entity state. - `Body` and `CollisionVolume`: editable mass, inertia, forces, velocities, primitive/compound collision geometry and bounded static-mesh collision. - `Joint` and `Drive`: body references, local frames, linear/angular limits and independently configurable motors. - `API`: in-engine authoring helpers and an explicit-state solver interface. - Input and actuator components for device-driven or scripted physical assemblies. - An integrated skateboard/rider system with control maps, rig mapping, visual bindings and animation-slot overrides. - Example scenes, a modular park, an authored skateboard, and the `GettingStarted` guide. ## Where to start Read **GettingStarted** for the distinction between the general physics components and the specialized rider integration. The low-level **Demo** workbench illustrates bodies, joints and a vehicle assembly. **SampleScenes** exposes rider, vehicle-only, self-propelled, scripted-control and physics-tuning examples. The world's default **RiderFidelity** scene demonstrates the coupled rider/board system with Zero's avatar and the authored park. ## Integration boundaries Static mesh collision has documented size limits; see `Body`. The specialized native rider/board integration requires a fixed body layout; that restriction is distinct from authoring assemblies with the general body/joint/drive API. The rider demo retains converted reference animations for testing, replaceable through normal Zero assets and animation bindings. These are not required by the general motor component. The default showcase uses the authored skateboard and Zero avatar; unused reference character and board models are excluded from publication. See the component documentation for supported shapes, units and solver-specific conventions.

# NativeAnimationCatalog Builds the preserved pose evaluator's input from ordinary Zero rig and animation asset references. Clips are decoded through Zero's own `skeleton.clipToTable`. Bindings retain loop transforms, channel weights and bank/reference-pose mapping. The native loader has no animation-bank fallback. This is a content boundary, not a completed playable rider controller or fidelity acceptance.

# Native body visual Add this to an ordinary visual entity under NativeRiderDriver.boardVisualRoot. Set body to a NativeActorPart belonging to that driver's board assembly. The driver supplies its interpolated position and rotation, coherent with the camera. Position/rotation offsets are in body space; visual scale remains authored on the entity. Do not put this component on the physical body itself. Model and Asset bundle content can be exchanged normally. An animated bundle may keep its own Zero animation components: this binding drives only the visual root, never its bones. It does not alter collision shape, mass or simulation. The current full actor exposes the seven board parts through this presenter.

# NativePoseStream Adjacent completed tick interpolation shared by rider and camera.

# Native board assembly binding Place ordinary skate_physics.Joint entities and NativeTruckMotor entities beneath the driver's constraintsRoot. Joints reference the actor's board parts and its physicsRoot. Their order determines native constraint registration. The selected root replaces the six built-in board joints, so an empty joint list intentionally disconnects the board parts. With no constraintsRoot the original definitions remain active. With no motor entities, original truck dynamics remain active. The separate hook and rider constraints are retained. This interface currently addresses the seven board parts; it does not claim arbitrary actor topology.

# Native rig pose Transfers live simulation poses through Zero humanoid role mappings and anatomical frames. Source and target rig assets remain editable in Zero. Bone lengths and local scales come from the target rig; source poses contribute anatomical orientation and pelvis motion. Non-humanoid content uses the direct pose path or its own presenter.

# NativeFootSurface Geometry-based visual foot correction candidates. This module does not alter physics and runs in NativeRiderDriver's interpolated presentation path when a footSurfaceMesh and footSurfaceBody are assigned. `new(parsedTargetRig, skinnedGeometries, surfaceGeometry)` caches foot-weighted vertices and inverse bind points. It indexes the surface triangles in an X/Z grid. Rig foot roles and hips are required. Supply ordinary Zero mesh geometry; no game files or host filesystem access are needed. `targets(freshPoses, toSurface, fromSurface, options)` returns model-space IK targets plus per-foot gap/overlap/correction diagnostics. Point transforms must be inverse affine transforms between rig model units and surface units. Surface Y defines the normal axis. The hips choose which side of the surface to use. Defaults: maxCorrection=.05 and clearance=0 in surface units. Deep penetration beyond the limit and separated feet receive no correction. This avoids turning IK reference-frame flags into planted-foot assumptions. Pass targets to NativeRigPose:solveFootTargets. It preserves shoe orientation, translations and scales while adjusting the leg rotations. Recompute from the fresh base pose; never feed corrected entity transforms back into this step. Live Zero geometry/pose checks: two 480-vertex feet, 712 projected triangles, about 2 ms per query after indexing in the measured session. The standing-pose 15 mm/3 mm penetrations reduced to about 5e-8 m; a 2 m separation produces no correction. The enabled rider preset also passed live standing, push/ollie/landing and inverted darkslide contact checks. Rig/mesh edit invalidation, broader rig variants and rendering performance across target machines remain to be verified.

# NativeAnimationBindings <!-- zero:scaffolded-readme --> <!-- Replace the line below with what this module provides and who consumes it, then delete both comment lines. --> TODO: describe this module.

# NativeAnimationMetadata <!-- zero:scaffolded-readme --> <!-- Replace the line below with what this module provides and who consumes it, then delete both comment lines. --> TODO: describe this module.

# NativeActorPart Entity-owned native physical state exchanged with the full rider loop. Role and index identify the part; state contains its complete rates and inertia. Shape/constraint authoring integration is unfinished.

# Native environment Collects Zero entities into the full rider runtime's collision and grind inputs. Use static mesh Body entities and optional TerrainSurface metadata. GrindPath children supply native grind splines and explicit ledge-query segments. Geometry and poses come from the selected entities; no reference level is loaded.