tiny.rig.articulated

1pub const CoordinateKind = enum(u8) {2    revolute = 0,3    prismatic = 1,4};

1pub const Handle = struct {2    name_buf: [64]u8 = @as([64]u8, @splat(0)),3    name_len: u8 = 0,4    parent: ?u32 = null,5    rest_translation: Vec3 = .{},6    rest_rotation: Quat = .{},7    coordinate_offset: u32 = 0,8    coordinate_count: u8 = 0,9    coordinate_kinds: [max_handle_coordinates]CoordinateKind = @as([max_handle_coordinates]CoordinateKind, @splat(.revolute)),10    coordinate_axes: [max_handle_coordinates]Vec3 = @as([max_handle_coordinates]Vec3, @splat(Vec3.zero)),11    coordinate_mins: [max_handle_coordinates]f32 = @as([max_handle_coordinates]f32, @splat(0.0)),12    coordinate_maxs: [max_handle_coordinates]f32 = @as([max_handle_coordinates]f32, @splat(0.0)),13};

1pub const HandleSpec = struct {2    name: []const u8 = "",3    parent: ?u32 = null,4    rest_translation: Vec3 = .{},5    rest_rotation: Quat = .{},6    coordinate_kinds: []const CoordinateKind = &.{},7    coordinate_axes: []const Vec3 = &.{},8    coordinate_mins: []const f32 = &.{},9    coordinate_maxs: []const f32 = &.{},10    initial_coordinates: []const f32 = &.{},11};

1pub const MotionType = enum(u8) {2    dynamic = 0,3    kinematic = 1,4    static_ = 2,5};

1pub const ProxyBinding = struct {2    handle_index: u32,3    local_translation: Vec3 = .{},4    local_rotation: Quat = .{},5    shape: ProxyShape = .point,6    mass: f32 = 1.0,7    friction: f32 = 0.0,8    restitution: f32 = 0.0,9    motion_type: MotionType = .kinematic,10};

1pub const ProxyShape = union(enum(u8)) {2    point: void,3    sphere: struct { radius: f32 },4    box: struct { half_extents: [3]f32 },5    capsule: struct { half_height: f32, radius: f32 },6};

1pub const max_handle_coordinates: usize = 3;

1//! An articulated rig: handles joined by revolute and prismatic2//! coordinates, with a point Jacobian and collision proxies on top.3//!4//! Each handle's coordinates turn its rest transform into a local5//! transform, rest first and then each coordinate's motion in order. The6//! skeleton's forward kinematics composes the local transforms down the7//! hierarchy; there is no second composition of the chain. Storage grows8//! only when a handle or proxy is added, so posing and querying never9//! allocate.1011const std = @import("std");12const linear = @import("linear");13const skeleton = @import("../skeleton.zig");14const transform = @import("../transform.zig");15const handle = @import("handle.zig");16const jacobian = @import("jacobian.zig");17const pose = @import("pose.zig");18const proxy = @import("proxy.zig");1920const Allocator = std.mem.Allocator;21const Joint = skeleton.Joint;22const Transform = transform.Transform;23const Vec3 = linear.Vec3;2425pub const CoordinateKind = handle.CoordinateKind;26pub const HandleSpec = handle.HandleSpec;27pub const Handle = handle.Handle;28pub const max_handle_coordinates = handle.max_handle_coordinates;29pub const MotionType = proxy.MotionType;30pub const ProxyBinding = proxy.ProxyBinding;31pub const ProxyShape = proxy.ProxyShape;3233pub const ArticulatedRig = struct {34    handles: std.ArrayListUnmanaged(Handle) = .empty,35    /// Each handle's parent, in the skeleton's form.36    parents: std.ArrayListUnmanaged(Joint) = .empty,37    coordinates: std.ArrayListUnmanaged(f32) = .empty,38    coordinate_to_handle: std.ArrayListUnmanaged(u32) = .empty,39    local_transforms: std.ArrayListUnmanaged(Transform) = .empty,40    world_transforms: std.ArrayListUnmanaged(Transform) = .empty,41    /// Each coordinate's axis and origin in world space, in the frame its42    /// motion applies in.43    coordinate_world_axes: std.ArrayListUnmanaged(Vec3) = .empty,44    coordinate_world_origins: std.ArrayListUnmanaged(Vec3) = .empty,45    proxies: std.ArrayListUnmanaged(ProxyBinding) = .empty,46    pose_dirty: bool = true,4748    pub fn init() ArticulatedRig {49        return .{};50    }5152    pub fn deinit(rig: *ArticulatedRig, allocator: Allocator) void {53        rig.handles.deinit(allocator);54        rig.parents.deinit(allocator);55        rig.coordinates.deinit(allocator);56        rig.coordinate_to_handle.deinit(allocator);57        rig.local_transforms.deinit(allocator);58        rig.world_transforms.deinit(allocator);59        rig.coordinate_world_axes.deinit(allocator);60        rig.coordinate_world_origins.deinit(allocator);61        rig.proxies.deinit(allocator);62        rig.* = .{};63    }6465    pub const addHandle = handle.add;66    pub const coordinateCount = handle.coordinateCount;67    pub const setCoordinate = handle.setCoordinate;68    pub const getCoordinate = handle.getCoordinate;69    pub const clampCoordinateValue = handle.clampCoordinateValue;70    pub const handleByIndex = handle.byIndex;71    pub const coordinateValue = handle.coordinateValue;72    pub const refresh = pose.refresh;73    pub const worldTransform = pose.worldTransform;74    pub const worldPoint = pose.worldPoint;75    pub const pointJacobian = jacobian.point;76    pub const addProxy = proxy.add;77    pub const proxyCount = proxy.count;78    pub const proxyBinding = proxy.binding;79    pub const proxyWorldTransform = proxy.worldTransform;80};

1pub const articulated = @import("articulated/root.zig");