Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

107 KB
Raw Blame
/**
 * @file    ptrAccessors.generated.ts
 * @brief   Auto-generated type-safe WASM pointer accessors
 * @details Generated by EHT - DO NOT EDIT
 */

interface Vec2 { x: number; y: number; }
interface Vec3 { x: number; y: number; z: number; }
interface Vec4 { x: number; y: number; z: number; w: number; }
interface Color { r: number; g: number; b: number; a: number; }

export interface BillboardPtrData {
    mode: number;
    enabled: boolean;
}

export function fillBillboard(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: BillboardPtrData,
): void {
    out.mode = u32[ptr >> 2] | 0;
    out.enabled = u8[ptr + 4] !== 0;
}

export function writeBillboard(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: BillboardPtrData,
): void {
    u32[ptr >> 2] = data.mode | 0;
    u8[ptr + 4] = data.enabled ? 1 : 0;
}

export function createBillboardData(): BillboardPtrData {
    return {
        mode: 0,
        enabled: false,
    };
}

export interface BitmapTextPtrData {
    color: Color;
    fontSize: number;
    align: number;
    spacing: number;
    parallax: Vec2;
    layer: number;
    font: number;
    enabled: boolean;
}

export function fillBitmapText(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: BitmapTextPtrData,
): void {
    const color_ = out.color; color_.r = f32[(ptr + 12) >> 2]; color_.g = f32[((ptr + 12) >> 2) + 1]; color_.b = f32[((ptr + 12) >> 2) + 2]; color_.a = f32[((ptr + 12) >> 2) + 3];
    out.fontSize = f32[(ptr + 28) >> 2];
    out.align = u8[ptr + 32];
    out.spacing = f32[(ptr + 36) >> 2];
    const parallax_ = out.parallax; parallax_.x = f32[(ptr + 40) >> 2]; parallax_.y = f32[((ptr + 40) >> 2) + 1];
    out.layer = u32[(ptr + 48) >> 2] | 0;
    out.font = u32[(ptr + 52) >> 2];
    out.enabled = u8[ptr + 56] !== 0;
}

export function writeBitmapText(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: BitmapTextPtrData,
): void {
    f32[(ptr + 12) >> 2] = data.color.r; f32[((ptr + 12) >> 2) + 1] = data.color.g; f32[((ptr + 12) >> 2) + 2] = data.color.b; f32[((ptr + 12) >> 2) + 3] = data.color.a;
    f32[(ptr + 28) >> 2] = data.fontSize;
    u8[ptr + 32] = data.align;
    f32[(ptr + 36) >> 2] = data.spacing;
    f32[(ptr + 40) >> 2] = data.parallax.x; f32[((ptr + 40) >> 2) + 1] = data.parallax.y;
    u32[(ptr + 48) >> 2] = data.layer | 0;
    u32[(ptr + 52) >> 2] = data.font;
    u8[ptr + 56] = data.enabled ? 1 : 0;
}

export function createBitmapTextData(): BitmapTextPtrData {
    return {
        color: { r: 0, g: 0, b: 0, a: 0 },
        fontSize: 0,
        align: 0,
        spacing: 0,
        parallax: { x: 0, y: 0 },
        layer: 0,
        font: 0,
        enabled: false,
    };
}

export interface BoxCollider2DPtrData {
    halfExtents: Vec2;
    offset: Vec2;
    density: number;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
    categoryBits: number;
    maskBits: number;
}

export function fillBoxCollider2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: BoxCollider2DPtrData,
): void {
    const halfExtents_ = out.halfExtents; halfExtents_.x = f32[ptr >> 2]; halfExtents_.y = f32[(ptr >> 2) + 1];
    const offset_ = out.offset; offset_.x = f32[(ptr + 8) >> 2]; offset_.y = f32[((ptr + 8) >> 2) + 1];
    out.density = f32[(ptr + 16) >> 2];
    out.friction = f32[(ptr + 20) >> 2];
    out.restitution = f32[(ptr + 24) >> 2];
    out.isSensor = u8[ptr + 28] !== 0;
    out.enabled = u8[ptr + 29] !== 0;
    out.categoryBits = u32[(ptr + 32) >> 2];
    out.maskBits = u32[(ptr + 36) >> 2];
}

export function writeBoxCollider2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: BoxCollider2DPtrData,
): void {
    f32[ptr >> 2] = data.halfExtents.x; f32[(ptr >> 2) + 1] = data.halfExtents.y;
    f32[(ptr + 8) >> 2] = data.offset.x; f32[((ptr + 8) >> 2) + 1] = data.offset.y;
    f32[(ptr + 16) >> 2] = data.density;
    f32[(ptr + 20) >> 2] = data.friction;
    f32[(ptr + 24) >> 2] = data.restitution;
    u8[ptr + 28] = data.isSensor ? 1 : 0;
    u8[ptr + 29] = data.enabled ? 1 : 0;
    u32[(ptr + 32) >> 2] = data.categoryBits;
    u32[(ptr + 36) >> 2] = data.maskBits;
}

export function createBoxCollider2DData(): BoxCollider2DPtrData {
    return {
        halfExtents: { x: 0, y: 0 },
        offset: { x: 0, y: 0 },
        density: 0,
        friction: 0,
        restitution: 0,
        isSensor: false,
        enabled: false,
        categoryBits: 0,
        maskBits: 0,
    };
}

export interface BoxCollider3DPtrData {
    halfExtents: Vec3;
    center: Vec3;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
}

export function fillBoxCollider3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: BoxCollider3DPtrData,
): void {
    const halfExtents_ = out.halfExtents; halfExtents_.x = f32[ptr >> 2]; halfExtents_.y = f32[(ptr >> 2) + 1]; halfExtents_.z = f32[(ptr >> 2) + 2];
    const center_ = out.center; center_.x = f32[(ptr + 12) >> 2]; center_.y = f32[((ptr + 12) >> 2) + 1]; center_.z = f32[((ptr + 12) >> 2) + 2];
    out.friction = f32[(ptr + 24) >> 2];
    out.restitution = f32[(ptr + 28) >> 2];
    out.isSensor = u8[ptr + 32] !== 0;
    out.enabled = u8[ptr + 33] !== 0;
}

export function writeBoxCollider3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: BoxCollider3DPtrData,
): void {
    f32[ptr >> 2] = data.halfExtents.x; f32[(ptr >> 2) + 1] = data.halfExtents.y; f32[(ptr >> 2) + 2] = data.halfExtents.z;
    f32[(ptr + 12) >> 2] = data.center.x; f32[((ptr + 12) >> 2) + 1] = data.center.y; f32[((ptr + 12) >> 2) + 2] = data.center.z;
    f32[(ptr + 24) >> 2] = data.friction;
    f32[(ptr + 28) >> 2] = data.restitution;
    u8[ptr + 32] = data.isSensor ? 1 : 0;
    u8[ptr + 33] = data.enabled ? 1 : 0;
}

export function createBoxCollider3DData(): BoxCollider3DPtrData {
    return {
        halfExtents: { x: 0, y: 0, z: 0 },
        center: { x: 0, y: 0, z: 0 },
        friction: 0,
        restitution: 0,
        isSensor: false,
        enabled: false,
    };
}

export interface CameraPtrData {
    projectionType: number;
    fov: number;
    orthoSize: number;
    nearPlane: number;
    farPlane: number;
    aspectRatio: number;
    isActive: boolean;
    priority: number;
    viewport: Vec4;
    clearFlags: number;
    pixelPerfect: boolean;
    cullingMask: number;
    renderTarget: number;
}

export function fillCamera(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: CameraPtrData,
): void {
    out.projectionType = u8[ptr];
    out.fov = f32[(ptr + 4) >> 2];
    out.orthoSize = f32[(ptr + 8) >> 2];
    out.nearPlane = f32[(ptr + 12) >> 2];
    out.farPlane = f32[(ptr + 16) >> 2];
    out.aspectRatio = f32[(ptr + 20) >> 2];
    out.isActive = u8[ptr + 24] !== 0;
    out.priority = u32[(ptr + 28) >> 2] | 0;
    const viewport_ = out.viewport; viewport_.x = f32[(ptr + 32) >> 2]; viewport_.y = f32[((ptr + 32) >> 2) + 1]; viewport_.z = f32[((ptr + 32) >> 2) + 2]; viewport_.w = f32[((ptr + 32) >> 2) + 3];
    out.clearFlags = u8[ptr + 48];
    out.pixelPerfect = u8[ptr + 49] !== 0;
    out.cullingMask = u32[(ptr + 52) >> 2];
    out.renderTarget = u32[(ptr + 56) >> 2];
}

export function writeCamera(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: CameraPtrData,
): void {
    u8[ptr] = data.projectionType;
    f32[(ptr + 4) >> 2] = data.fov;
    f32[(ptr + 8) >> 2] = data.orthoSize;
    f32[(ptr + 12) >> 2] = data.nearPlane;
    f32[(ptr + 16) >> 2] = data.farPlane;
    f32[(ptr + 20) >> 2] = data.aspectRatio;
    u8[ptr + 24] = data.isActive ? 1 : 0;
    u32[(ptr + 28) >> 2] = data.priority | 0;
    f32[(ptr + 32) >> 2] = data.viewport.x; f32[((ptr + 32) >> 2) + 1] = data.viewport.y; f32[((ptr + 32) >> 2) + 2] = data.viewport.z; f32[((ptr + 32) >> 2) + 3] = data.viewport.w;
    u8[ptr + 48] = data.clearFlags;
    u8[ptr + 49] = data.pixelPerfect ? 1 : 0;
    u32[(ptr + 52) >> 2] = data.cullingMask;
    u32[(ptr + 56) >> 2] = data.renderTarget;
}

export function createCameraData(): CameraPtrData {
    return {
        projectionType: 0,
        fov: 0,
        orthoSize: 0,
        nearPlane: 0,
        farPlane: 0,
        aspectRatio: 0,
        isActive: false,
        priority: 0,
        viewport: { x: 0, y: 0, z: 0, w: 0 },
        clearFlags: 0,
        pixelPerfect: false,
        cullingMask: 0,
        renderTarget: 0,
    };
}

export interface CanvasPtrData {
    designResolution: Vec2;
    pixelsPerUnit: number;
    scaleMode: number;
    matchWidthOrHeight: number;
    backgroundColor: Color;
    layer: number;
}

export function fillCanvas(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: CanvasPtrData,
): void {
    const designResolution_ = out.designResolution; designResolution_.x = f32[ptr >> 2]; designResolution_.y = f32[(ptr >> 2) + 1];
    out.pixelsPerUnit = f32[(ptr + 8) >> 2];
    out.scaleMode = u8[ptr + 12];
    out.matchWidthOrHeight = f32[(ptr + 16) >> 2];
    const backgroundColor_ = out.backgroundColor; backgroundColor_.r = f32[(ptr + 20) >> 2]; backgroundColor_.g = f32[((ptr + 20) >> 2) + 1]; backgroundColor_.b = f32[((ptr + 20) >> 2) + 2]; backgroundColor_.a = f32[((ptr + 20) >> 2) + 3];
    out.layer = u32[(ptr + 36) >> 2] | 0;
}

export function writeCanvas(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: CanvasPtrData,
): void {
    f32[ptr >> 2] = data.designResolution.x; f32[(ptr >> 2) + 1] = data.designResolution.y;
    f32[(ptr + 8) >> 2] = data.pixelsPerUnit;
    u8[ptr + 12] = data.scaleMode;
    f32[(ptr + 16) >> 2] = data.matchWidthOrHeight;
    f32[(ptr + 20) >> 2] = data.backgroundColor.r; f32[((ptr + 20) >> 2) + 1] = data.backgroundColor.g; f32[((ptr + 20) >> 2) + 2] = data.backgroundColor.b; f32[((ptr + 20) >> 2) + 3] = data.backgroundColor.a;
    u32[(ptr + 36) >> 2] = data.layer | 0;
}

export function createCanvasData(): CanvasPtrData {
    return {
        designResolution: { x: 0, y: 0 },
        pixelsPerUnit: 0,
        scaleMode: 0,
        matchWidthOrHeight: 0,
        backgroundColor: { r: 0, g: 0, b: 0, a: 0 },
        layer: 0,
    };
}

export interface CapsuleCollider2DPtrData {
    radius: number;
    halfHeight: number;
    offset: Vec2;
    density: number;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
    categoryBits: number;
    maskBits: number;
}

export function fillCapsuleCollider2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: CapsuleCollider2DPtrData,
): void {
    out.radius = f32[ptr >> 2];
    out.halfHeight = f32[(ptr + 4) >> 2];
    const offset_ = out.offset; offset_.x = f32[(ptr + 8) >> 2]; offset_.y = f32[((ptr + 8) >> 2) + 1];
    out.density = f32[(ptr + 16) >> 2];
    out.friction = f32[(ptr + 20) >> 2];
    out.restitution = f32[(ptr + 24) >> 2];
    out.isSensor = u8[ptr + 28] !== 0;
    out.enabled = u8[ptr + 29] !== 0;
    out.categoryBits = u32[(ptr + 32) >> 2];
    out.maskBits = u32[(ptr + 36) >> 2];
}

export function writeCapsuleCollider2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: CapsuleCollider2DPtrData,
): void {
    f32[ptr >> 2] = data.radius;
    f32[(ptr + 4) >> 2] = data.halfHeight;
    f32[(ptr + 8) >> 2] = data.offset.x; f32[((ptr + 8) >> 2) + 1] = data.offset.y;
    f32[(ptr + 16) >> 2] = data.density;
    f32[(ptr + 20) >> 2] = data.friction;
    f32[(ptr + 24) >> 2] = data.restitution;
    u8[ptr + 28] = data.isSensor ? 1 : 0;
    u8[ptr + 29] = data.enabled ? 1 : 0;
    u32[(ptr + 32) >> 2] = data.categoryBits;
    u32[(ptr + 36) >> 2] = data.maskBits;
}

export function createCapsuleCollider2DData(): CapsuleCollider2DPtrData {
    return {
        radius: 0,
        halfHeight: 0,
        offset: { x: 0, y: 0 },
        density: 0,
        friction: 0,
        restitution: 0,
        isSensor: false,
        enabled: false,
        categoryBits: 0,
        maskBits: 0,
    };
}

export interface CapsuleCollider3DPtrData {
    radius: number;
    halfHeight: number;
    center: Vec3;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
}

export function fillCapsuleCollider3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: CapsuleCollider3DPtrData,
): void {
    out.radius = f32[ptr >> 2];
    out.halfHeight = f32[(ptr + 4) >> 2];
    const center_ = out.center; center_.x = f32[(ptr + 8) >> 2]; center_.y = f32[((ptr + 8) >> 2) + 1]; center_.z = f32[((ptr + 8) >> 2) + 2];
    out.friction = f32[(ptr + 20) >> 2];
    out.restitution = f32[(ptr + 24) >> 2];
    out.isSensor = u8[ptr + 28] !== 0;
    out.enabled = u8[ptr + 29] !== 0;
}

export function writeCapsuleCollider3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: CapsuleCollider3DPtrData,
): void {
    f32[ptr >> 2] = data.radius;
    f32[(ptr + 4) >> 2] = data.halfHeight;
    f32[(ptr + 8) >> 2] = data.center.x; f32[((ptr + 8) >> 2) + 1] = data.center.y; f32[((ptr + 8) >> 2) + 2] = data.center.z;
    f32[(ptr + 20) >> 2] = data.friction;
    f32[(ptr + 24) >> 2] = data.restitution;
    u8[ptr + 28] = data.isSensor ? 1 : 0;
    u8[ptr + 29] = data.enabled ? 1 : 0;
}

export function createCapsuleCollider3DData(): CapsuleCollider3DPtrData {
    return {
        radius: 0,
        halfHeight: 0,
        center: { x: 0, y: 0, z: 0 },
        friction: 0,
        restitution: 0,
        isSensor: false,
        enabled: false,
    };
}

export interface CharacterController3DPtrData {
    velocity: Vec3;
    radius: number;
    halfHeight: number;
    maxSlope: number;
    stepHeight: number;
    snapDown: number;
    mass: number;
    pushForce: number;
    enabled: boolean;
    layer: number;
    isOnFloor: boolean;
    floorNormal: Vec3;
    realVelocity: Vec3;
}

export function fillCharacterController3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: CharacterController3DPtrData,
): void {
    const velocity_ = out.velocity; velocity_.x = f32[ptr >> 2]; velocity_.y = f32[(ptr >> 2) + 1]; velocity_.z = f32[(ptr >> 2) + 2];
    out.radius = f32[(ptr + 12) >> 2];
    out.halfHeight = f32[(ptr + 16) >> 2];
    out.maxSlope = f32[(ptr + 20) >> 2];
    out.stepHeight = f32[(ptr + 24) >> 2];
    out.snapDown = f32[(ptr + 28) >> 2];
    out.mass = f32[(ptr + 32) >> 2];
    out.pushForce = f32[(ptr + 36) >> 2];
    out.enabled = u8[ptr + 40] !== 0;
    out.layer = u32[(ptr + 44) >> 2];
    out.isOnFloor = u8[ptr + 48] !== 0;
    const floorNormal_ = out.floorNormal; floorNormal_.x = f32[(ptr + 52) >> 2]; floorNormal_.y = f32[((ptr + 52) >> 2) + 1]; floorNormal_.z = f32[((ptr + 52) >> 2) + 2];
    const realVelocity_ = out.realVelocity; realVelocity_.x = f32[(ptr + 64) >> 2]; realVelocity_.y = f32[((ptr + 64) >> 2) + 1]; realVelocity_.z = f32[((ptr + 64) >> 2) + 2];
}

export function writeCharacterController3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: CharacterController3DPtrData,
): void {
    f32[ptr >> 2] = data.velocity.x; f32[(ptr >> 2) + 1] = data.velocity.y; f32[(ptr >> 2) + 2] = data.velocity.z;
    f32[(ptr + 12) >> 2] = data.radius;
    f32[(ptr + 16) >> 2] = data.halfHeight;
    f32[(ptr + 20) >> 2] = data.maxSlope;
    f32[(ptr + 24) >> 2] = data.stepHeight;
    f32[(ptr + 28) >> 2] = data.snapDown;
    f32[(ptr + 32) >> 2] = data.mass;
    f32[(ptr + 36) >> 2] = data.pushForce;
    u8[ptr + 40] = data.enabled ? 1 : 0;
    u32[(ptr + 44) >> 2] = data.layer;
    u8[ptr + 48] = data.isOnFloor ? 1 : 0;
    f32[(ptr + 52) >> 2] = data.floorNormal.x; f32[((ptr + 52) >> 2) + 1] = data.floorNormal.y; f32[((ptr + 52) >> 2) + 2] = data.floorNormal.z;
    f32[(ptr + 64) >> 2] = data.realVelocity.x; f32[((ptr + 64) >> 2) + 1] = data.realVelocity.y; f32[((ptr + 64) >> 2) + 2] = data.realVelocity.z;
}

export function createCharacterController3DData(): CharacterController3DPtrData {
    return {
        velocity: { x: 0, y: 0, z: 0 },
        radius: 0,
        halfHeight: 0,
        maxSlope: 0,
        stepHeight: 0,
        snapDown: 0,
        mass: 0,
        pushForce: 0,
        enabled: false,
        layer: 0,
        isOnFloor: false,
        floorNormal: { x: 0, y: 0, z: 0 },
        realVelocity: { x: 0, y: 0, z: 0 },
    };
}

export interface CircleCollider2DPtrData {
    radius: number;
    offset: Vec2;
    density: number;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
    categoryBits: number;
    maskBits: number;
}

export function fillCircleCollider2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: CircleCollider2DPtrData,
): void {
    out.radius = f32[ptr >> 2];
    const offset_ = out.offset; offset_.x = f32[(ptr + 4) >> 2]; offset_.y = f32[((ptr + 4) >> 2) + 1];
    out.density = f32[(ptr + 12) >> 2];
    out.friction = f32[(ptr + 16) >> 2];
    out.restitution = f32[(ptr + 20) >> 2];
    out.isSensor = u8[ptr + 24] !== 0;
    out.enabled = u8[ptr + 25] !== 0;
    out.categoryBits = u32[(ptr + 28) >> 2];
    out.maskBits = u32[(ptr + 32) >> 2];
}

export function writeCircleCollider2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: CircleCollider2DPtrData,
): void {
    f32[ptr >> 2] = data.radius;
    f32[(ptr + 4) >> 2] = data.offset.x; f32[((ptr + 4) >> 2) + 1] = data.offset.y;
    f32[(ptr + 12) >> 2] = data.density;
    f32[(ptr + 16) >> 2] = data.friction;
    f32[(ptr + 20) >> 2] = data.restitution;
    u8[ptr + 24] = data.isSensor ? 1 : 0;
    u8[ptr + 25] = data.enabled ? 1 : 0;
    u32[(ptr + 28) >> 2] = data.categoryBits;
    u32[(ptr + 32) >> 2] = data.maskBits;
}

export function createCircleCollider2DData(): CircleCollider2DPtrData {
    return {
        radius: 0,
        offset: { x: 0, y: 0 },
        density: 0,
        friction: 0,
        restitution: 0,
        isSensor: false,
        enabled: false,
        categoryBits: 0,
        maskBits: 0,
    };
}

export interface ContentRectPtrData {
    size: Vec2;
    pivot: Vec2;
}

export function fillContentRect(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: ContentRectPtrData,
): void {
    const size_ = out.size; size_.x = f32[ptr >> 2]; size_.y = f32[(ptr >> 2) + 1];
    const pivot_ = out.pivot; pivot_.x = f32[(ptr + 8) >> 2]; pivot_.y = f32[((ptr + 8) >> 2) + 1];
}

export function writeContentRect(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: ContentRectPtrData,
): void {
    f32[ptr >> 2] = data.size.x; f32[(ptr >> 2) + 1] = data.size.y;
    f32[(ptr + 8) >> 2] = data.pivot.x; f32[((ptr + 8) >> 2) + 1] = data.pivot.y;
}

export function createContentRectData(): ContentRectPtrData {
    return {
        size: { x: 0, y: 0 },
        pivot: { x: 0, y: 0 },
    };
}

export interface ConvexCollider3DPtrData {
    mesh: number;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
}

export function fillConvexCollider3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: ConvexCollider3DPtrData,
): void {
    out.mesh = u32[ptr >> 2];
    out.friction = f32[(ptr + 4) >> 2];
    out.restitution = f32[(ptr + 8) >> 2];
    out.isSensor = u8[ptr + 12] !== 0;
    out.enabled = u8[ptr + 13] !== 0;
}

export function writeConvexCollider3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: ConvexCollider3DPtrData,
): void {
    u32[ptr >> 2] = data.mesh;
    f32[(ptr + 4) >> 2] = data.friction;
    f32[(ptr + 8) >> 2] = data.restitution;
    u8[ptr + 12] = data.isSensor ? 1 : 0;
    u8[ptr + 13] = data.enabled ? 1 : 0;
}

export function createConvexCollider3DData(): ConvexCollider3DPtrData {
    return {
        mesh: 0,
        friction: 0,
        restitution: 0,
        isSensor: false,
        enabled: false,
    };
}

export interface DraggablePtrData {
    enabled: boolean;
    dragThreshold: number;
    lockX: boolean;
    lockY: boolean;
    constrainMin: boolean;
    constraintMin: Vec2;
    constrainMax: boolean;
    constraintMax: Vec2;
}

export function fillDraggable(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: DraggablePtrData,
): void {
    out.enabled = u8[ptr] !== 0;
    out.dragThreshold = f32[(ptr + 4) >> 2];
    out.lockX = u8[ptr + 8] !== 0;
    out.lockY = u8[ptr + 9] !== 0;
    out.constrainMin = u8[ptr + 10] !== 0;
    const constraintMin_ = out.constraintMin; constraintMin_.x = f32[(ptr + 12) >> 2]; constraintMin_.y = f32[((ptr + 12) >> 2) + 1];
    out.constrainMax = u8[ptr + 20] !== 0;
    const constraintMax_ = out.constraintMax; constraintMax_.x = f32[(ptr + 24) >> 2]; constraintMax_.y = f32[((ptr + 24) >> 2) + 1];
}

export function writeDraggable(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: DraggablePtrData,
): void {
    u8[ptr] = data.enabled ? 1 : 0;
    f32[(ptr + 4) >> 2] = data.dragThreshold;
    u8[ptr + 8] = data.lockX ? 1 : 0;
    u8[ptr + 9] = data.lockY ? 1 : 0;
    u8[ptr + 10] = data.constrainMin ? 1 : 0;
    f32[(ptr + 12) >> 2] = data.constraintMin.x; f32[((ptr + 12) >> 2) + 1] = data.constraintMin.y;
    u8[ptr + 20] = data.constrainMax ? 1 : 0;
    f32[(ptr + 24) >> 2] = data.constraintMax.x; f32[((ptr + 24) >> 2) + 1] = data.constraintMax.y;
}

export function createDraggableData(): DraggablePtrData {
    return {
        enabled: false,
        dragThreshold: 0,
        lockX: false,
        lockY: false,
        constrainMin: false,
        constraintMin: { x: 0, y: 0 },
        constrainMax: false,
        constraintMax: { x: 0, y: 0 },
    };
}

export interface DragonBonesAnimationPtrData {
    timeScale: number;
    loop: boolean;
    playing: boolean;
    fadeInTime: number;
    flipX: boolean;
    flipY: boolean;
    color: Color;
    layer: number;
    skeletonScale: number;
    material: number;
    enabled: boolean;
}

export function fillDragonBonesAnimation(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: DragonBonesAnimationPtrData,
): void {
    out.timeScale = f32[(ptr + 48) >> 2];
    out.loop = u8[ptr + 52] !== 0;
    out.playing = u8[ptr + 53] !== 0;
    out.fadeInTime = f32[(ptr + 56) >> 2];
    out.flipX = u8[ptr + 60] !== 0;
    out.flipY = u8[ptr + 61] !== 0;
    const color_ = out.color; color_.r = f32[(ptr + 64) >> 2]; color_.g = f32[((ptr + 64) >> 2) + 1]; color_.b = f32[((ptr + 64) >> 2) + 2]; color_.a = f32[((ptr + 64) >> 2) + 3];
    out.layer = u32[(ptr + 80) >> 2] | 0;
    out.skeletonScale = f32[(ptr + 84) >> 2];
    out.material = u32[(ptr + 88) >> 2];
    out.enabled = u8[ptr + 92] !== 0;
}

export function writeDragonBonesAnimation(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: DragonBonesAnimationPtrData,
): void {
    f32[(ptr + 48) >> 2] = data.timeScale;
    u8[ptr + 52] = data.loop ? 1 : 0;
    u8[ptr + 53] = data.playing ? 1 : 0;
    f32[(ptr + 56) >> 2] = data.fadeInTime;
    u8[ptr + 60] = data.flipX ? 1 : 0;
    u8[ptr + 61] = data.flipY ? 1 : 0;
    f32[(ptr + 64) >> 2] = data.color.r; f32[((ptr + 64) >> 2) + 1] = data.color.g; f32[((ptr + 64) >> 2) + 2] = data.color.b; f32[((ptr + 64) >> 2) + 3] = data.color.a;
    u32[(ptr + 80) >> 2] = data.layer | 0;
    f32[(ptr + 84) >> 2] = data.skeletonScale;
    u32[(ptr + 88) >> 2] = data.material;
    u8[ptr + 92] = data.enabled ? 1 : 0;
}

export function createDragonBonesAnimationData(): DragonBonesAnimationPtrData {
    return {
        timeScale: 0,
        loop: false,
        playing: false,
        fadeInTime: 0,
        flipX: false,
        flipY: false,
        color: { r: 0, g: 0, b: 0, a: 0 },
        layer: 0,
        skeletonScale: 0,
        material: 0,
        enabled: false,
    };
}

export interface FlexContainerPtrData {
    direction: number;
    wrap: number;
    justifyContent: number;
    alignItems: number;
    alignContent: number;
    gap: Vec2;
    padding: { left: number; top: number; right: number; bottom: number; };
}

export function fillFlexContainer(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: FlexContainerPtrData,
): void {
    out.direction = u8[ptr];
    out.wrap = u8[ptr + 1];
    out.justifyContent = u8[ptr + 2];
    out.alignItems = u8[ptr + 3];
    out.alignContent = u8[ptr + 4];
    const gap_ = out.gap; gap_.x = f32[(ptr + 8) >> 2]; gap_.y = f32[((ptr + 8) >> 2) + 1];
    const padding_ = out.padding; padding_.left = f32[(ptr + 16) >> 2]; padding_.top = f32[(ptr + 20) >> 2]; padding_.right = f32[(ptr + 24) >> 2]; padding_.bottom = f32[(ptr + 28) >> 2];
}

export function writeFlexContainer(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: FlexContainerPtrData,
): void {
    u8[ptr] = data.direction;
    u8[ptr + 1] = data.wrap;
    u8[ptr + 2] = data.justifyContent;
    u8[ptr + 3] = data.alignItems;
    u8[ptr + 4] = data.alignContent;
    f32[(ptr + 8) >> 2] = data.gap.x; f32[((ptr + 8) >> 2) + 1] = data.gap.y;
    f32[(ptr + 16) >> 2] = data.padding.left; f32[(ptr + 20) >> 2] = data.padding.top; f32[(ptr + 24) >> 2] = data.padding.right; f32[(ptr + 28) >> 2] = data.padding.bottom;
}

export function createFlexContainerData(): FlexContainerPtrData {
    return {
        direction: 0,
        wrap: 0,
        justifyContent: 0,
        alignItems: 0,
        alignContent: 0,
        gap: { x: 0, y: 0 },
        padding: { left: 0, top: 0, right: 0, bottom: 0 },
    };
}

export interface GroupOpacityPtrData {
    opacity: number;
    enabled: boolean;
}

export function fillGroupOpacity(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: GroupOpacityPtrData,
): void {
    out.opacity = f32[ptr >> 2];
    out.enabled = u8[ptr + 4] !== 0;
}

export function writeGroupOpacity(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: GroupOpacityPtrData,
): void {
    f32[ptr >> 2] = data.opacity;
    u8[ptr + 4] = data.enabled ? 1 : 0;
}

export function createGroupOpacityData(): GroupOpacityPtrData {
    return {
        opacity: 0,
        enabled: false,
    };
}

export interface ImpostorPtrData {
    screenSize: number;
    frames: number;
    resolution: number;
    enabled: boolean;
}

export function fillImpostor(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: ImpostorPtrData,
): void {
    out.screenSize = f32[ptr >> 2];
    out.frames = u32[(ptr + 4) >> 2] | 0;
    out.resolution = u32[(ptr + 8) >> 2] | 0;
    out.enabled = u8[ptr + 12] !== 0;
}

export function writeImpostor(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: ImpostorPtrData,
): void {
    f32[ptr >> 2] = data.screenSize;
    u32[(ptr + 4) >> 2] = data.frames | 0;
    u32[(ptr + 8) >> 2] = data.resolution | 0;
    u8[ptr + 12] = data.enabled ? 1 : 0;
}

export function createImpostorData(): ImpostorPtrData {
    return {
        screenSize: 0,
        frames: 0,
        resolution: 0,
        enabled: false,
    };
}

export interface InteractablePtrData {
    enabled: boolean;
    blockRaycast: boolean;
    raycastTarget: boolean;
}

export function fillInteractable(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: InteractablePtrData,
): void {
    out.enabled = u8[ptr] !== 0;
    out.blockRaycast = u8[ptr + 1] !== 0;
    out.raycastTarget = u8[ptr + 2] !== 0;
}

export function writeInteractable(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: InteractablePtrData,
): void {
    u8[ptr] = data.enabled ? 1 : 0;
    u8[ptr + 1] = data.blockRaycast ? 1 : 0;
    u8[ptr + 2] = data.raycastTarget ? 1 : 0;
}

export function createInteractableData(): InteractablePtrData {
    return {
        enabled: false,
        blockRaycast: false,
        raycastTarget: false,
    };
}

export interface LODGroupPtrData {
    lod1: number;
    lod2: number;
    lod3: number;
    lod1Size: number;
    lod2Size: number;
    lod3Size: number;
    cullSize: number;
    hysteresis: number;
    enabled: boolean;
}

export function fillLODGroup(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: LODGroupPtrData,
): void {
    out.lod1 = u32[ptr >> 2];
    out.lod2 = u32[(ptr + 4) >> 2];
    out.lod3 = u32[(ptr + 8) >> 2];
    out.lod1Size = f32[(ptr + 12) >> 2];
    out.lod2Size = f32[(ptr + 16) >> 2];
    out.lod3Size = f32[(ptr + 20) >> 2];
    out.cullSize = f32[(ptr + 24) >> 2];
    out.hysteresis = f32[(ptr + 28) >> 2];
    out.enabled = u8[ptr + 32] !== 0;
}

export function writeLODGroup(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: LODGroupPtrData,
): void {
    u32[ptr >> 2] = data.lod1;
    u32[(ptr + 4) >> 2] = data.lod2;
    u32[(ptr + 8) >> 2] = data.lod3;
    f32[(ptr + 12) >> 2] = data.lod1Size;
    f32[(ptr + 16) >> 2] = data.lod2Size;
    f32[(ptr + 20) >> 2] = data.lod3Size;
    f32[(ptr + 24) >> 2] = data.cullSize;
    f32[(ptr + 28) >> 2] = data.hysteresis;
    u8[ptr + 32] = data.enabled ? 1 : 0;
}

export function createLODGroupData(): LODGroupPtrData {
    return {
        lod1: 0,
        lod2: 0,
        lod3: 0,
        lod1Size: 0,
        lod2Size: 0,
        lod3Size: 0,
        cullSize: 0,
        hysteresis: 0,
        enabled: false,
    };
}

export interface LightPtrData {
    type: number;
    color: Color;
    intensity: number;
    radius: number;
    innerRadius: number;
    falloff: number;
    inverseSquare: boolean;
    shadowStrength: number;
    layerMin: number;
    layerMax: number;
    cookie: number;
    cookieSize: Vec2;
    innerAngle: number;
    outerAngle: number;
    shadowSoftness: number;
    sourceAngle: number;
    shadowDistance: number;
    meshShadows: boolean;
    shadowExtent: number;
    followEnvironmentSun: boolean;
    aimFollowedSun: boolean;
    environment: number;
    environmentRotation: number;
    drawEnvironment: boolean;
    reflectionScale: number;
    diffuseScale: number;
    diffuseTint: Color;
    reflectionSaturation: number;
    bakedTint: Color;
    hemisphere: boolean;
    groundColor: Color;
    enabled: boolean;
}

export function fillLight(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: LightPtrData,
): void {
    out.type = u32[ptr >> 2] | 0;
    const color_ = out.color; color_.r = f32[(ptr + 4) >> 2]; color_.g = f32[((ptr + 4) >> 2) + 1]; color_.b = f32[((ptr + 4) >> 2) + 2]; color_.a = f32[((ptr + 4) >> 2) + 3];
    out.intensity = f32[(ptr + 20) >> 2];
    out.radius = f32[(ptr + 24) >> 2];
    out.innerRadius = f32[(ptr + 28) >> 2];
    out.falloff = f32[(ptr + 32) >> 2];
    out.inverseSquare = u8[ptr + 36] !== 0;
    out.shadowStrength = f32[(ptr + 40) >> 2];
    out.layerMin = u32[(ptr + 44) >> 2] | 0;
    out.layerMax = u32[(ptr + 48) >> 2] | 0;
    out.cookie = u32[(ptr + 52) >> 2];
    const cookieSize_ = out.cookieSize; cookieSize_.x = f32[(ptr + 56) >> 2]; cookieSize_.y = f32[((ptr + 56) >> 2) + 1];
    out.innerAngle = f32[(ptr + 64) >> 2];
    out.outerAngle = f32[(ptr + 68) >> 2];
    out.shadowSoftness = f32[(ptr + 72) >> 2];
    out.sourceAngle = f32[(ptr + 76) >> 2];
    out.shadowDistance = f32[(ptr + 80) >> 2];
    out.meshShadows = u8[ptr + 84] !== 0;
    out.shadowExtent = f32[(ptr + 88) >> 2];
    out.followEnvironmentSun = u8[ptr + 92] !== 0;
    out.aimFollowedSun = u8[ptr + 93] !== 0;
    out.environment = u32[(ptr + 96) >> 2];
    out.environmentRotation = f32[(ptr + 100) >> 2];
    out.drawEnvironment = u8[ptr + 104] !== 0;
    out.reflectionScale = f32[(ptr + 108) >> 2];
    out.diffuseScale = f32[(ptr + 112) >> 2];
    const diffuseTint_ = out.diffuseTint; diffuseTint_.r = f32[(ptr + 116) >> 2]; diffuseTint_.g = f32[((ptr + 116) >> 2) + 1]; diffuseTint_.b = f32[((ptr + 116) >> 2) + 2]; diffuseTint_.a = f32[((ptr + 116) >> 2) + 3];
    out.reflectionSaturation = f32[(ptr + 132) >> 2];
    const bakedTint_ = out.bakedTint; bakedTint_.r = f32[(ptr + 136) >> 2]; bakedTint_.g = f32[((ptr + 136) >> 2) + 1]; bakedTint_.b = f32[((ptr + 136) >> 2) + 2]; bakedTint_.a = f32[((ptr + 136) >> 2) + 3];
    out.hemisphere = u8[ptr + 152] !== 0;
    const groundColor_ = out.groundColor; groundColor_.r = f32[(ptr + 156) >> 2]; groundColor_.g = f32[((ptr + 156) >> 2) + 1]; groundColor_.b = f32[((ptr + 156) >> 2) + 2]; groundColor_.a = f32[((ptr + 156) >> 2) + 3];
    out.enabled = u8[ptr + 172] !== 0;
}

export function writeLight(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: LightPtrData,
): void {
    u32[ptr >> 2] = data.type | 0;
    f32[(ptr + 4) >> 2] = data.color.r; f32[((ptr + 4) >> 2) + 1] = data.color.g; f32[((ptr + 4) >> 2) + 2] = data.color.b; f32[((ptr + 4) >> 2) + 3] = data.color.a;
    f32[(ptr + 20) >> 2] = data.intensity;
    f32[(ptr + 24) >> 2] = data.radius;
    f32[(ptr + 28) >> 2] = data.innerRadius;
    f32[(ptr + 32) >> 2] = data.falloff;
    u8[ptr + 36] = data.inverseSquare ? 1 : 0;
    f32[(ptr + 40) >> 2] = data.shadowStrength;
    u32[(ptr + 44) >> 2] = data.layerMin | 0;
    u32[(ptr + 48) >> 2] = data.layerMax | 0;
    u32[(ptr + 52) >> 2] = data.cookie;
    f32[(ptr + 56) >> 2] = data.cookieSize.x; f32[((ptr + 56) >> 2) + 1] = data.cookieSize.y;
    f32[(ptr + 64) >> 2] = data.innerAngle;
    f32[(ptr + 68) >> 2] = data.outerAngle;
    f32[(ptr + 72) >> 2] = data.shadowSoftness;
    f32[(ptr + 76) >> 2] = data.sourceAngle;
    f32[(ptr + 80) >> 2] = data.shadowDistance;
    u8[ptr + 84] = data.meshShadows ? 1 : 0;
    f32[(ptr + 88) >> 2] = data.shadowExtent;
    u8[ptr + 92] = data.followEnvironmentSun ? 1 : 0;
    u8[ptr + 93] = data.aimFollowedSun ? 1 : 0;
    u32[(ptr + 96) >> 2] = data.environment;
    f32[(ptr + 100) >> 2] = data.environmentRotation;
    u8[ptr + 104] = data.drawEnvironment ? 1 : 0;
    f32[(ptr + 108) >> 2] = data.reflectionScale;
    f32[(ptr + 112) >> 2] = data.diffuseScale;
    f32[(ptr + 116) >> 2] = data.diffuseTint.r; f32[((ptr + 116) >> 2) + 1] = data.diffuseTint.g; f32[((ptr + 116) >> 2) + 2] = data.diffuseTint.b; f32[((ptr + 116) >> 2) + 3] = data.diffuseTint.a;
    f32[(ptr + 132) >> 2] = data.reflectionSaturation;
    f32[(ptr + 136) >> 2] = data.bakedTint.r; f32[((ptr + 136) >> 2) + 1] = data.bakedTint.g; f32[((ptr + 136) >> 2) + 2] = data.bakedTint.b; f32[((ptr + 136) >> 2) + 3] = data.bakedTint.a;
    u8[ptr + 152] = data.hemisphere ? 1 : 0;
    f32[(ptr + 156) >> 2] = data.groundColor.r; f32[((ptr + 156) >> 2) + 1] = data.groundColor.g; f32[((ptr + 156) >> 2) + 2] = data.groundColor.b; f32[((ptr + 156) >> 2) + 3] = data.groundColor.a;
    u8[ptr + 172] = data.enabled ? 1 : 0;
}

export function createLightData(): LightPtrData {
    return {
        type: 0,
        color: { r: 0, g: 0, b: 0, a: 0 },
        intensity: 0,
        radius: 0,
        innerRadius: 0,
        falloff: 0,
        inverseSquare: false,
        shadowStrength: 0,
        layerMin: 0,
        layerMax: 0,
        cookie: 0,
        cookieSize: { x: 0, y: 0 },
        innerAngle: 0,
        outerAngle: 0,
        shadowSoftness: 0,
        sourceAngle: 0,
        shadowDistance: 0,
        meshShadows: false,
        shadowExtent: 0,
        followEnvironmentSun: false,
        aimFollowedSun: false,
        environment: 0,
        environmentRotation: 0,
        drawEnvironment: false,
        reflectionScale: 0,
        diffuseScale: 0,
        diffuseTint: { r: 0, g: 0, b: 0, a: 0 },
        reflectionSaturation: 0,
        bakedTint: { r: 0, g: 0, b: 0, a: 0 },
        hemisphere: false,
        groundColor: { r: 0, g: 0, b: 0, a: 0 },
        enabled: false,
    };
}

export interface LightProbeVolumePtrData {
    probes: number;
    capture: boolean;
    captureInterval: number;
    halfExtents: Vec3;
    spacing: number;
    enabled: boolean;
}

export function fillLightProbeVolume(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: LightProbeVolumePtrData,
): void {
    out.probes = u32[ptr >> 2];
    out.capture = u8[ptr + 4] !== 0;
    out.captureInterval = f32[(ptr + 8) >> 2];
    const halfExtents_ = out.halfExtents; halfExtents_.x = f32[(ptr + 12) >> 2]; halfExtents_.y = f32[((ptr + 12) >> 2) + 1]; halfExtents_.z = f32[((ptr + 12) >> 2) + 2];
    out.spacing = f32[(ptr + 24) >> 2];
    out.enabled = u8[ptr + 28] !== 0;
}

export function writeLightProbeVolume(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: LightProbeVolumePtrData,
): void {
    u32[ptr >> 2] = data.probes;
    u8[ptr + 4] = data.capture ? 1 : 0;
    f32[(ptr + 8) >> 2] = data.captureInterval;
    f32[(ptr + 12) >> 2] = data.halfExtents.x; f32[((ptr + 12) >> 2) + 1] = data.halfExtents.y; f32[((ptr + 12) >> 2) + 2] = data.halfExtents.z;
    f32[(ptr + 24) >> 2] = data.spacing;
    u8[ptr + 28] = data.enabled ? 1 : 0;
}

export function createLightProbeVolumeData(): LightProbeVolumePtrData {
    return {
        probes: 0,
        capture: false,
        captureInterval: 0,
        halfExtents: { x: 0, y: 0, z: 0 },
        spacing: 0,
        enabled: false,
    };
}

export interface MeshCollider3DPtrData {
    mesh: number;
    friction: number;
    restitution: number;
    layer: number;
    enabled: boolean;
}

export function fillMeshCollider3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: MeshCollider3DPtrData,
): void {
    out.mesh = u32[ptr >> 2];
    out.friction = f32[(ptr + 4) >> 2];
    out.restitution = f32[(ptr + 8) >> 2];
    out.layer = u32[(ptr + 12) >> 2];
    out.enabled = u8[ptr + 16] !== 0;
}

export function writeMeshCollider3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: MeshCollider3DPtrData,
): void {
    u32[ptr >> 2] = data.mesh;
    f32[(ptr + 4) >> 2] = data.friction;
    f32[(ptr + 8) >> 2] = data.restitution;
    u32[(ptr + 12) >> 2] = data.layer;
    u8[ptr + 16] = data.enabled ? 1 : 0;
}

export function createMeshCollider3DData(): MeshCollider3DPtrData {
    return {
        mesh: 0,
        friction: 0,
        restitution: 0,
        layer: 0,
        enabled: false,
    };
}

export interface MeshInstancesPtrData {
    lod1Mesh: number;
    lodDistance: number;
    minDistance: number;
    drawDistance: number;
    shadowDistance: number;
}

export function fillMeshInstances(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: MeshInstancesPtrData,
): void {
    out.lod1Mesh = u32[ptr >> 2];
    out.lodDistance = f32[(ptr + 4) >> 2];
    out.minDistance = f32[(ptr + 8) >> 2];
    out.drawDistance = f32[(ptr + 12) >> 2];
    out.shadowDistance = f32[(ptr + 16) >> 2];
}

export function writeMeshInstances(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: MeshInstancesPtrData,
): void {
    u32[ptr >> 2] = data.lod1Mesh;
    f32[(ptr + 4) >> 2] = data.lodDistance;
    f32[(ptr + 8) >> 2] = data.minDistance;
    f32[(ptr + 12) >> 2] = data.drawDistance;
    f32[(ptr + 16) >> 2] = data.shadowDistance;
}

export function createMeshInstancesData(): MeshInstancesPtrData {
    return {
        lod1Mesh: 0,
        lodDistance: 0,
        minDistance: 0,
        drawDistance: 0,
        shadowDistance: 0,
    };
}

export interface MeshLightmapPtrData {
    lightmap: number;
    scaleOffset: Vec4;
}

export function fillMeshLightmap(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: MeshLightmapPtrData,
): void {
    out.lightmap = u32[ptr >> 2];
    const scaleOffset_ = out.scaleOffset; scaleOffset_.x = f32[(ptr + 4) >> 2]; scaleOffset_.y = f32[((ptr + 4) >> 2) + 1]; scaleOffset_.z = f32[((ptr + 4) >> 2) + 2]; scaleOffset_.w = f32[((ptr + 4) >> 2) + 3];
}

export function writeMeshLightmap(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: MeshLightmapPtrData,
): void {
    u32[ptr >> 2] = data.lightmap;
    f32[(ptr + 4) >> 2] = data.scaleOffset.x; f32[((ptr + 4) >> 2) + 1] = data.scaleOffset.y; f32[((ptr + 4) >> 2) + 2] = data.scaleOffset.z; f32[((ptr + 4) >> 2) + 3] = data.scaleOffset.w;
}

export function createMeshLightmapData(): MeshLightmapPtrData {
    return {
        lightmap: 0,
        scaleOffset: { x: 0, y: 0, z: 0, w: 0 },
    };
}

export interface MeshRendererPtrData {
    texture: number;
    normalMap: number;
    color: Color;
    layer: number;
    opaque: boolean;
    cullBackfaces: boolean;
    lit: boolean;
    castShadows: boolean;
    parallax: Vec2;
    material: number;
    enabled: boolean;
    mesh: number;
}

export function fillMeshRenderer(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: MeshRendererPtrData,
): void {
    out.texture = u32[ptr >> 2];
    out.normalMap = u32[(ptr + 4) >> 2];
    const color_ = out.color; color_.r = f32[(ptr + 8) >> 2]; color_.g = f32[((ptr + 8) >> 2) + 1]; color_.b = f32[((ptr + 8) >> 2) + 2]; color_.a = f32[((ptr + 8) >> 2) + 3];
    out.layer = u32[(ptr + 24) >> 2] | 0;
    out.opaque = u8[ptr + 28] !== 0;
    out.cullBackfaces = u8[ptr + 29] !== 0;
    out.lit = u8[ptr + 30] !== 0;
    out.castShadows = u8[ptr + 31] !== 0;
    const parallax_ = out.parallax; parallax_.x = f32[(ptr + 32) >> 2]; parallax_.y = f32[((ptr + 32) >> 2) + 1];
    out.material = u32[(ptr + 40) >> 2];
    out.enabled = u8[ptr + 44] !== 0;
    out.mesh = u32[(ptr + 48) >> 2];
}

export function writeMeshRenderer(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: MeshRendererPtrData,
): void {
    u32[ptr >> 2] = data.texture;
    u32[(ptr + 4) >> 2] = data.normalMap;
    f32[(ptr + 8) >> 2] = data.color.r; f32[((ptr + 8) >> 2) + 1] = data.color.g; f32[((ptr + 8) >> 2) + 2] = data.color.b; f32[((ptr + 8) >> 2) + 3] = data.color.a;
    u32[(ptr + 24) >> 2] = data.layer | 0;
    u8[ptr + 28] = data.opaque ? 1 : 0;
    u8[ptr + 29] = data.cullBackfaces ? 1 : 0;
    u8[ptr + 30] = data.lit ? 1 : 0;
    u8[ptr + 31] = data.castShadows ? 1 : 0;
    f32[(ptr + 32) >> 2] = data.parallax.x; f32[((ptr + 32) >> 2) + 1] = data.parallax.y;
    u32[(ptr + 40) >> 2] = data.material;
    u8[ptr + 44] = data.enabled ? 1 : 0;
    u32[(ptr + 48) >> 2] = data.mesh;
}

export function createMeshRendererData(): MeshRendererPtrData {
    return {
        texture: 0,
        normalMap: 0,
        color: { r: 0, g: 0, b: 0, a: 0 },
        layer: 0,
        opaque: false,
        cullBackfaces: false,
        lit: false,
        castShadows: false,
        parallax: { x: 0, y: 0 },
        material: 0,
        enabled: false,
        mesh: 0,
    };
}

export interface OccluderPtrData {
    halfExtents: Vec3;
    enabled: boolean;
}

export function fillOccluder(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: OccluderPtrData,
): void {
    const halfExtents_ = out.halfExtents; halfExtents_.x = f32[ptr >> 2]; halfExtents_.y = f32[(ptr >> 2) + 1]; halfExtents_.z = f32[(ptr >> 2) + 2];
    out.enabled = u8[ptr + 12] !== 0;
}

export function writeOccluder(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: OccluderPtrData,
): void {
    f32[ptr >> 2] = data.halfExtents.x; f32[(ptr >> 2) + 1] = data.halfExtents.y; f32[(ptr >> 2) + 2] = data.halfExtents.z;
    u8[ptr + 12] = data.enabled ? 1 : 0;
}

export function createOccluderData(): OccluderPtrData {
    return {
        halfExtents: { x: 0, y: 0, z: 0 },
        enabled: false,
    };
}

export interface ParticleColliderPtrData {
    shape: number;
    radius: number;
    halfHeight: number;
    halfExtents: Vec3;
    inverted: boolean;
    mask: number;
    enabled: boolean;
}

export function fillParticleCollider(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: ParticleColliderPtrData,
): void {
    out.shape = u32[ptr >> 2] | 0;
    out.radius = f32[(ptr + 4) >> 2];
    out.halfHeight = f32[(ptr + 8) >> 2];
    const halfExtents_ = out.halfExtents; halfExtents_.x = f32[(ptr + 12) >> 2]; halfExtents_.y = f32[((ptr + 12) >> 2) + 1]; halfExtents_.z = f32[((ptr + 12) >> 2) + 2];
    out.inverted = u8[ptr + 24] !== 0;
    out.mask = u32[(ptr + 28) >> 2];
    out.enabled = u8[ptr + 32] !== 0;
}

export function writeParticleCollider(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: ParticleColliderPtrData,
): void {
    u32[ptr >> 2] = data.shape | 0;
    f32[(ptr + 4) >> 2] = data.radius;
    f32[(ptr + 8) >> 2] = data.halfHeight;
    f32[(ptr + 12) >> 2] = data.halfExtents.x; f32[((ptr + 12) >> 2) + 1] = data.halfExtents.y; f32[((ptr + 12) >> 2) + 2] = data.halfExtents.z;
    u8[ptr + 24] = data.inverted ? 1 : 0;
    u32[(ptr + 28) >> 2] = data.mask;
    u8[ptr + 32] = data.enabled ? 1 : 0;
}

export function createParticleColliderData(): ParticleColliderPtrData {
    return {
        shape: 0,
        radius: 0,
        halfHeight: 0,
        halfExtents: { x: 0, y: 0, z: 0 },
        inverted: false,
        mask: 0,
        enabled: false,
    };
}

export interface ParticleEmitterPtrData {
    rate: number;
    burstCount: number;
    burstInterval: number;
    duration: number;
    simulationSpeed: number;
    startDelay: number;
    looping: boolean;
    playOnStart: boolean;
    maxParticles: number;
    gpuSimulation: boolean;
    lifetimeMin: number;
    lifetimeMax: number;
    shape: number;
    shapeRadius: number;
    shapeSize: Vec3;
    shapeAngle: number;
    speedMin: number;
    speedMax: number;
    angleSpreadMin: number;
    angleSpreadMax: number;
    startSizeMin: number;
    startSizeMax: number;
    endSizeMin: number;
    endSizeMax: number;
    sizeEasing: number;
    startColor: Color;
    endColor: Color;
    colorEasing: number;
    rotationMin: number;
    rotationMax: number;
    angularVelocityMin: number;
    angularVelocityMax: number;
    gravity: Vec3;
    damping: number;
    addedVelocityMin: Vec3;
    addedVelocityMax: Vec3;
    speedLimit: number;
    limitDampen: number;
    noiseStrength: number;
    noiseFrequency: number;
    noiseScrollSpeed: number;
    noiseOctaves: number;
    texture: number;
    spriteColumns: number;
    spriteRows: number;
    spriteFPS: number;
    spriteLoop: boolean;
    blendMode: number;
    layer: number;
    material: number;
    simulationSpace: number;
    renderMode: number;
    velocityScale: number;
    lengthScale: number;
    enabled: boolean;
    subEmitterTrigger: number;
    subEmitterChance: number;
    subEmitterInheritVelocity: number;
    subEmitter: number;
    trailEnabled: boolean;
    trailWidth: number;
    trailPoints: number;
    trailMinDistance: number;
    collisionEnabled: boolean;
    collisionFloor: number;
    collisionMode: number;
    collisionMask: number;
    collisionQueryBudget: number;
    collisionMaxDistance: number;
    collisionFallback: number;
    collisionEvents: boolean;
    collisionEventBudget: number;
    collisionThickness: number;
    collisionBounce: number;
    collisionFriction: number;
    collisionLifetimeLoss: number;
}

export function fillParticleEmitter(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: ParticleEmitterPtrData,
): void {
    out.rate = f32[ptr >> 2];
    out.burstCount = u32[(ptr + 4) >> 2] | 0;
    out.burstInterval = f32[(ptr + 8) >> 2];
    out.duration = f32[(ptr + 12) >> 2];
    out.simulationSpeed = f32[(ptr + 16) >> 2];
    out.startDelay = f32[(ptr + 20) >> 2];
    out.looping = u8[ptr + 24] !== 0;
    out.playOnStart = u8[ptr + 25] !== 0;
    out.maxParticles = u32[(ptr + 28) >> 2] | 0;
    out.gpuSimulation = u8[ptr + 32] !== 0;
    out.lifetimeMin = f32[(ptr + 36) >> 2];
    out.lifetimeMax = f32[(ptr + 40) >> 2];
    out.shape = u32[(ptr + 44) >> 2] | 0;
    out.shapeRadius = f32[(ptr + 48) >> 2];
    const shapeSize_ = out.shapeSize; shapeSize_.x = f32[(ptr + 52) >> 2]; shapeSize_.y = f32[((ptr + 52) >> 2) + 1]; shapeSize_.z = f32[((ptr + 52) >> 2) + 2];
    out.shapeAngle = f32[(ptr + 64) >> 2];
    out.speedMin = f32[(ptr + 68) >> 2];
    out.speedMax = f32[(ptr + 72) >> 2];
    out.angleSpreadMin = f32[(ptr + 76) >> 2];
    out.angleSpreadMax = f32[(ptr + 80) >> 2];
    out.startSizeMin = f32[(ptr + 84) >> 2];
    out.startSizeMax = f32[(ptr + 88) >> 2];
    out.endSizeMin = f32[(ptr + 92) >> 2];
    out.endSizeMax = f32[(ptr + 96) >> 2];
    out.sizeEasing = u32[(ptr + 100) >> 2] | 0;
    const startColor_ = out.startColor; startColor_.r = f32[(ptr + 104) >> 2]; startColor_.g = f32[((ptr + 104) >> 2) + 1]; startColor_.b = f32[((ptr + 104) >> 2) + 2]; startColor_.a = f32[((ptr + 104) >> 2) + 3];
    const endColor_ = out.endColor; endColor_.r = f32[(ptr + 120) >> 2]; endColor_.g = f32[((ptr + 120) >> 2) + 1]; endColor_.b = f32[((ptr + 120) >> 2) + 2]; endColor_.a = f32[((ptr + 120) >> 2) + 3];
    out.colorEasing = u32[(ptr + 136) >> 2] | 0;
    out.rotationMin = f32[(ptr + 140) >> 2];
    out.rotationMax = f32[(ptr + 144) >> 2];
    out.angularVelocityMin = f32[(ptr + 148) >> 2];
    out.angularVelocityMax = f32[(ptr + 152) >> 2];
    const gravity_ = out.gravity; gravity_.x = f32[(ptr + 156) >> 2]; gravity_.y = f32[((ptr + 156) >> 2) + 1]; gravity_.z = f32[((ptr + 156) >> 2) + 2];
    out.damping = f32[(ptr + 168) >> 2];
    const addedVelocityMin_ = out.addedVelocityMin; addedVelocityMin_.x = f32[(ptr + 172) >> 2]; addedVelocityMin_.y = f32[((ptr + 172) >> 2) + 1]; addedVelocityMin_.z = f32[((ptr + 172) >> 2) + 2];
    const addedVelocityMax_ = out.addedVelocityMax; addedVelocityMax_.x = f32[(ptr + 184) >> 2]; addedVelocityMax_.y = f32[((ptr + 184) >> 2) + 1]; addedVelocityMax_.z = f32[((ptr + 184) >> 2) + 2];
    out.speedLimit = f32[(ptr + 196) >> 2];
    out.limitDampen = f32[(ptr + 200) >> 2];
    out.noiseStrength = f32[(ptr + 204) >> 2];
    out.noiseFrequency = f32[(ptr + 208) >> 2];
    out.noiseScrollSpeed = f32[(ptr + 212) >> 2];
    out.noiseOctaves = u32[(ptr + 216) >> 2] | 0;
    out.texture = u32[(ptr + 220) >> 2];
    out.spriteColumns = u32[(ptr + 224) >> 2] | 0;
    out.spriteRows = u32[(ptr + 228) >> 2] | 0;
    out.spriteFPS = f32[(ptr + 232) >> 2];
    out.spriteLoop = u8[ptr + 236] !== 0;
    out.blendMode = u32[(ptr + 240) >> 2] | 0;
    out.layer = u32[(ptr + 244) >> 2] | 0;
    out.material = u32[(ptr + 248) >> 2];
    out.simulationSpace = u32[(ptr + 252) >> 2] | 0;
    out.renderMode = u32[(ptr + 256) >> 2] | 0;
    out.velocityScale = f32[(ptr + 260) >> 2];
    out.lengthScale = f32[(ptr + 264) >> 2];
    out.enabled = u8[ptr + 268] !== 0;
    out.subEmitterTrigger = u32[(ptr + 272) >> 2] | 0;
    out.subEmitterChance = f32[(ptr + 276) >> 2];
    out.subEmitterInheritVelocity = f32[(ptr + 280) >> 2];
    out.subEmitter = u32[(ptr + 284) >> 2];
    out.trailEnabled = u8[ptr + 288] !== 0;
    out.trailWidth = f32[(ptr + 292) >> 2];
    out.trailPoints = u32[(ptr + 296) >> 2] | 0;
    out.trailMinDistance = f32[(ptr + 300) >> 2];
    out.collisionEnabled = u8[ptr + 304] !== 0;
    out.collisionFloor = f32[(ptr + 308) >> 2];
    out.collisionMode = u32[(ptr + 312) >> 2] | 0;
    out.collisionMask = u32[(ptr + 316) >> 2];
    out.collisionQueryBudget = u32[(ptr + 320) >> 2] | 0;
    out.collisionMaxDistance = f32[(ptr + 324) >> 2];
    out.collisionFallback = u32[(ptr + 328) >> 2] | 0;
    out.collisionEvents = u8[ptr + 332] !== 0;
    out.collisionEventBudget = u32[(ptr + 336) >> 2] | 0;
    out.collisionThickness = f32[(ptr + 340) >> 2];
    out.collisionBounce = f32[(ptr + 344) >> 2];
    out.collisionFriction = f32[(ptr + 348) >> 2];
    out.collisionLifetimeLoss = f32[(ptr + 352) >> 2];
}

export function writeParticleEmitter(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: ParticleEmitterPtrData,
): void {
    f32[ptr >> 2] = data.rate;
    u32[(ptr + 4) >> 2] = data.burstCount | 0;
    f32[(ptr + 8) >> 2] = data.burstInterval;
    f32[(ptr + 12) >> 2] = data.duration;
    f32[(ptr + 16) >> 2] = data.simulationSpeed;
    f32[(ptr + 20) >> 2] = data.startDelay;
    u8[ptr + 24] = data.looping ? 1 : 0;
    u8[ptr + 25] = data.playOnStart ? 1 : 0;
    u32[(ptr + 28) >> 2] = data.maxParticles | 0;
    u8[ptr + 32] = data.gpuSimulation ? 1 : 0;
    f32[(ptr + 36) >> 2] = data.lifetimeMin;
    f32[(ptr + 40) >> 2] = data.lifetimeMax;
    u32[(ptr + 44) >> 2] = data.shape | 0;
    f32[(ptr + 48) >> 2] = data.shapeRadius;
    f32[(ptr + 52) >> 2] = data.shapeSize.x; f32[((ptr + 52) >> 2) + 1] = data.shapeSize.y; f32[((ptr + 52) >> 2) + 2] = data.shapeSize.z;
    f32[(ptr + 64) >> 2] = data.shapeAngle;
    f32[(ptr + 68) >> 2] = data.speedMin;
    f32[(ptr + 72) >> 2] = data.speedMax;
    f32[(ptr + 76) >> 2] = data.angleSpreadMin;
    f32[(ptr + 80) >> 2] = data.angleSpreadMax;
    f32[(ptr + 84) >> 2] = data.startSizeMin;
    f32[(ptr + 88) >> 2] = data.startSizeMax;
    f32[(ptr + 92) >> 2] = data.endSizeMin;
    f32[(ptr + 96) >> 2] = data.endSizeMax;
    u32[(ptr + 100) >> 2] = data.sizeEasing | 0;
    f32[(ptr + 104) >> 2] = data.startColor.r; f32[((ptr + 104) >> 2) + 1] = data.startColor.g; f32[((ptr + 104) >> 2) + 2] = data.startColor.b; f32[((ptr + 104) >> 2) + 3] = data.startColor.a;
    f32[(ptr + 120) >> 2] = data.endColor.r; f32[((ptr + 120) >> 2) + 1] = data.endColor.g; f32[((ptr + 120) >> 2) + 2] = data.endColor.b; f32[((ptr + 120) >> 2) + 3] = data.endColor.a;
    u32[(ptr + 136) >> 2] = data.colorEasing | 0;
    f32[(ptr + 140) >> 2] = data.rotationMin;
    f32[(ptr + 144) >> 2] = data.rotationMax;
    f32[(ptr + 148) >> 2] = data.angularVelocityMin;
    f32[(ptr + 152) >> 2] = data.angularVelocityMax;
    f32[(ptr + 156) >> 2] = data.gravity.x; f32[((ptr + 156) >> 2) + 1] = data.gravity.y; f32[((ptr + 156) >> 2) + 2] = data.gravity.z;
    f32[(ptr + 168) >> 2] = data.damping;
    f32[(ptr + 172) >> 2] = data.addedVelocityMin.x; f32[((ptr + 172) >> 2) + 1] = data.addedVelocityMin.y; f32[((ptr + 172) >> 2) + 2] = data.addedVelocityMin.z;
    f32[(ptr + 184) >> 2] = data.addedVelocityMax.x; f32[((ptr + 184) >> 2) + 1] = data.addedVelocityMax.y; f32[((ptr + 184) >> 2) + 2] = data.addedVelocityMax.z;
    f32[(ptr + 196) >> 2] = data.speedLimit;
    f32[(ptr + 200) >> 2] = data.limitDampen;
    f32[(ptr + 204) >> 2] = data.noiseStrength;
    f32[(ptr + 208) >> 2] = data.noiseFrequency;
    f32[(ptr + 212) >> 2] = data.noiseScrollSpeed;
    u32[(ptr + 216) >> 2] = data.noiseOctaves | 0;
    u32[(ptr + 220) >> 2] = data.texture;
    u32[(ptr + 224) >> 2] = data.spriteColumns | 0;
    u32[(ptr + 228) >> 2] = data.spriteRows | 0;
    f32[(ptr + 232) >> 2] = data.spriteFPS;
    u8[ptr + 236] = data.spriteLoop ? 1 : 0;
    u32[(ptr + 240) >> 2] = data.blendMode | 0;
    u32[(ptr + 244) >> 2] = data.layer | 0;
    u32[(ptr + 248) >> 2] = data.material;
    u32[(ptr + 252) >> 2] = data.simulationSpace | 0;
    u32[(ptr + 256) >> 2] = data.renderMode | 0;
    f32[(ptr + 260) >> 2] = data.velocityScale;
    f32[(ptr + 264) >> 2] = data.lengthScale;
    u8[ptr + 268] = data.enabled ? 1 : 0;
    u32[(ptr + 272) >> 2] = data.subEmitterTrigger | 0;
    f32[(ptr + 276) >> 2] = data.subEmitterChance;
    f32[(ptr + 280) >> 2] = data.subEmitterInheritVelocity;
    u32[(ptr + 284) >> 2] = data.subEmitter;
    u8[ptr + 288] = data.trailEnabled ? 1 : 0;
    f32[(ptr + 292) >> 2] = data.trailWidth;
    u32[(ptr + 296) >> 2] = data.trailPoints | 0;
    f32[(ptr + 300) >> 2] = data.trailMinDistance;
    u8[ptr + 304] = data.collisionEnabled ? 1 : 0;
    f32[(ptr + 308) >> 2] = data.collisionFloor;
    u32[(ptr + 312) >> 2] = data.collisionMode | 0;
    u32[(ptr + 316) >> 2] = data.collisionMask;
    u32[(ptr + 320) >> 2] = data.collisionQueryBudget | 0;
    f32[(ptr + 324) >> 2] = data.collisionMaxDistance;
    u32[(ptr + 328) >> 2] = data.collisionFallback | 0;
    u8[ptr + 332] = data.collisionEvents ? 1 : 0;
    u32[(ptr + 336) >> 2] = data.collisionEventBudget | 0;
    f32[(ptr + 340) >> 2] = data.collisionThickness;
    f32[(ptr + 344) >> 2] = data.collisionBounce;
    f32[(ptr + 348) >> 2] = data.collisionFriction;
    f32[(ptr + 352) >> 2] = data.collisionLifetimeLoss;
}

export function createParticleEmitterData(): ParticleEmitterPtrData {
    return {
        rate: 0,
        burstCount: 0,
        burstInterval: 0,
        duration: 0,
        simulationSpeed: 0,
        startDelay: 0,
        looping: false,
        playOnStart: false,
        maxParticles: 0,
        gpuSimulation: false,
        lifetimeMin: 0,
        lifetimeMax: 0,
        shape: 0,
        shapeRadius: 0,
        shapeSize: { x: 0, y: 0, z: 0 },
        shapeAngle: 0,
        speedMin: 0,
        speedMax: 0,
        angleSpreadMin: 0,
        angleSpreadMax: 0,
        startSizeMin: 0,
        startSizeMax: 0,
        endSizeMin: 0,
        endSizeMax: 0,
        sizeEasing: 0,
        startColor: { r: 0, g: 0, b: 0, a: 0 },
        endColor: { r: 0, g: 0, b: 0, a: 0 },
        colorEasing: 0,
        rotationMin: 0,
        rotationMax: 0,
        angularVelocityMin: 0,
        angularVelocityMax: 0,
        gravity: { x: 0, y: 0, z: 0 },
        damping: 0,
        addedVelocityMin: { x: 0, y: 0, z: 0 },
        addedVelocityMax: { x: 0, y: 0, z: 0 },
        speedLimit: 0,
        limitDampen: 0,
        noiseStrength: 0,
        noiseFrequency: 0,
        noiseScrollSpeed: 0,
        noiseOctaves: 0,
        texture: 0,
        spriteColumns: 0,
        spriteRows: 0,
        spriteFPS: 0,
        spriteLoop: false,
        blendMode: 0,
        layer: 0,
        material: 0,
        simulationSpace: 0,
        renderMode: 0,
        velocityScale: 0,
        lengthScale: 0,
        enabled: false,
        subEmitterTrigger: 0,
        subEmitterChance: 0,
        subEmitterInheritVelocity: 0,
        subEmitter: 0,
        trailEnabled: false,
        trailWidth: 0,
        trailPoints: 0,
        trailMinDistance: 0,
        collisionEnabled: false,
        collisionFloor: 0,
        collisionMode: 0,
        collisionMask: 0,
        collisionQueryBudget: 0,
        collisionMaxDistance: 0,
        collisionFallback: 0,
        collisionEvents: false,
        collisionEventBudget: 0,
        collisionThickness: 0,
        collisionBounce: 0,
        collisionFriction: 0,
        collisionLifetimeLoss: 0,
    };
}

export interface ParticleForceFieldPtrData {
    type: number;
    strength: number;
    radius: number;
    direction: Vec3;
    falloff: boolean;
    enabled: boolean;
}

export function fillParticleForceField(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: ParticleForceFieldPtrData,
): void {
    out.type = u32[ptr >> 2] | 0;
    out.strength = f32[(ptr + 4) >> 2];
    out.radius = f32[(ptr + 8) >> 2];
    const direction_ = out.direction; direction_.x = f32[(ptr + 12) >> 2]; direction_.y = f32[((ptr + 12) >> 2) + 1]; direction_.z = f32[((ptr + 12) >> 2) + 2];
    out.falloff = u8[ptr + 24] !== 0;
    out.enabled = u8[ptr + 25] !== 0;
}

export function writeParticleForceField(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: ParticleForceFieldPtrData,
): void {
    u32[ptr >> 2] = data.type | 0;
    f32[(ptr + 4) >> 2] = data.strength;
    f32[(ptr + 8) >> 2] = data.radius;
    f32[(ptr + 12) >> 2] = data.direction.x; f32[((ptr + 12) >> 2) + 1] = data.direction.y; f32[((ptr + 12) >> 2) + 2] = data.direction.z;
    u8[ptr + 24] = data.falloff ? 1 : 0;
    u8[ptr + 25] = data.enabled ? 1 : 0;
}

export function createParticleForceFieldData(): ParticleForceFieldPtrData {
    return {
        type: 0,
        strength: 0,
        radius: 0,
        direction: { x: 0, y: 0, z: 0 },
        falloff: false,
        enabled: false,
    };
}

export interface PlanarReflectionPtrData {
    axis: number;
    clipOffset: number;
    cullingMask: number;
    quality: number;
    resolutionScale: number;
    maxSize: number;
    update: number;
    updatesPerSecond: number;
    revision: number;
    enabled: boolean;
}

export function fillPlanarReflection(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: PlanarReflectionPtrData,
): void {
    out.axis = u8[ptr];
    out.clipOffset = f32[(ptr + 4) >> 2];
    out.cullingMask = u32[(ptr + 8) >> 2];
    out.quality = u8[ptr + 12];
    out.resolutionScale = f32[(ptr + 16) >> 2];
    out.maxSize = u32[(ptr + 20) >> 2];
    out.update = u8[ptr + 24];
    out.updatesPerSecond = f32[(ptr + 28) >> 2];
    out.revision = u32[(ptr + 32) >> 2];
    out.enabled = u8[ptr + 36] !== 0;
}

export function writePlanarReflection(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: PlanarReflectionPtrData,
): void {
    u8[ptr] = data.axis;
    f32[(ptr + 4) >> 2] = data.clipOffset;
    u32[(ptr + 8) >> 2] = data.cullingMask;
    u8[ptr + 12] = data.quality;
    f32[(ptr + 16) >> 2] = data.resolutionScale;
    u32[(ptr + 20) >> 2] = data.maxSize;
    u8[ptr + 24] = data.update;
    f32[(ptr + 28) >> 2] = data.updatesPerSecond;
    u32[(ptr + 32) >> 2] = data.revision;
    u8[ptr + 36] = data.enabled ? 1 : 0;
}

export function createPlanarReflectionData(): PlanarReflectionPtrData {
    return {
        axis: 0,
        clipOffset: 0,
        cullingMask: 0,
        quality: 0,
        resolutionScale: 0,
        maxSize: 0,
        update: 0,
        updatesPerSecond: 0,
        revision: 0,
        enabled: false,
    };
}

export interface ReflectionProbePtrData {
    reflection: number;
    halfExtents: Vec3;
    slot: number;
    enabled: boolean;
}

export function fillReflectionProbe(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: ReflectionProbePtrData,
): void {
    out.reflection = u32[ptr >> 2];
    const halfExtents_ = out.halfExtents; halfExtents_.x = f32[(ptr + 4) >> 2]; halfExtents_.y = f32[((ptr + 4) >> 2) + 1]; halfExtents_.z = f32[((ptr + 4) >> 2) + 2];
    out.slot = u32[(ptr + 16) >> 2];
    out.enabled = u8[ptr + 20] !== 0;
}

export function writeReflectionProbe(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: ReflectionProbePtrData,
): void {
    u32[ptr >> 2] = data.reflection;
    f32[(ptr + 4) >> 2] = data.halfExtents.x; f32[((ptr + 4) >> 2) + 1] = data.halfExtents.y; f32[((ptr + 4) >> 2) + 2] = data.halfExtents.z;
    u32[(ptr + 16) >> 2] = data.slot;
    u8[ptr + 20] = data.enabled ? 1 : 0;
}

export function createReflectionProbeData(): ReflectionProbePtrData {
    return {
        reflection: 0,
        halfExtents: { x: 0, y: 0, z: 0 },
        slot: 0,
        enabled: false,
    };
}

export interface RigidBody2DPtrData {
    bodyType: number;
    gravityScale: number;
    linearDamping: number;
    angularDamping: number;
    fixedRotation: boolean;
    bullet: boolean;
    enabled: boolean;
}

export function fillRigidBody2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: RigidBody2DPtrData,
): void {
    out.bodyType = u8[ptr];
    out.gravityScale = f32[(ptr + 4) >> 2];
    out.linearDamping = f32[(ptr + 8) >> 2];
    out.angularDamping = f32[(ptr + 12) >> 2];
    out.fixedRotation = u8[ptr + 16] !== 0;
    out.bullet = u8[ptr + 17] !== 0;
    out.enabled = u8[ptr + 18] !== 0;
}

export function writeRigidBody2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: RigidBody2DPtrData,
): void {
    u8[ptr] = data.bodyType;
    f32[(ptr + 4) >> 2] = data.gravityScale;
    f32[(ptr + 8) >> 2] = data.linearDamping;
    f32[(ptr + 12) >> 2] = data.angularDamping;
    u8[ptr + 16] = data.fixedRotation ? 1 : 0;
    u8[ptr + 17] = data.bullet ? 1 : 0;
    u8[ptr + 18] = data.enabled ? 1 : 0;
}

export function createRigidBody2DData(): RigidBody2DPtrData {
    return {
        bodyType: 0,
        gravityScale: 0,
        linearDamping: 0,
        angularDamping: 0,
        fixedRotation: false,
        bullet: false,
        enabled: false,
    };
}

export interface RigidBody3DPtrData {
    bodyType: number;
    gravityScale: number;
    linearDamping: number;
    angularDamping: number;
    mass: number;
    fixedRotation: boolean;
    layer: number;
    continuousCollision: boolean;
    enabled: boolean;
}

export function fillRigidBody3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: RigidBody3DPtrData,
): void {
    out.bodyType = u8[ptr];
    out.gravityScale = f32[(ptr + 4) >> 2];
    out.linearDamping = f32[(ptr + 8) >> 2];
    out.angularDamping = f32[(ptr + 12) >> 2];
    out.mass = f32[(ptr + 16) >> 2];
    out.fixedRotation = u8[ptr + 20] !== 0;
    out.layer = u32[(ptr + 24) >> 2];
    out.continuousCollision = u8[ptr + 28] !== 0;
    out.enabled = u8[ptr + 29] !== 0;
}

export function writeRigidBody3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: RigidBody3DPtrData,
): void {
    u8[ptr] = data.bodyType;
    f32[(ptr + 4) >> 2] = data.gravityScale;
    f32[(ptr + 8) >> 2] = data.linearDamping;
    f32[(ptr + 12) >> 2] = data.angularDamping;
    f32[(ptr + 16) >> 2] = data.mass;
    u8[ptr + 20] = data.fixedRotation ? 1 : 0;
    u32[(ptr + 24) >> 2] = data.layer;
    u8[ptr + 28] = data.continuousCollision ? 1 : 0;
    u8[ptr + 29] = data.enabled ? 1 : 0;
}

export function createRigidBody3DData(): RigidBody3DPtrData {
    return {
        bodyType: 0,
        gravityScale: 0,
        linearDamping: 0,
        angularDamping: 0,
        mass: 0,
        fixedRotation: false,
        layer: 0,
        continuousCollision: false,
        enabled: false,
    };
}

export interface SegmentCollider2DPtrData {
    point1: Vec2;
    point2: Vec2;
    density: number;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
    categoryBits: number;
    maskBits: number;
}

export function fillSegmentCollider2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: SegmentCollider2DPtrData,
): void {
    const point1_ = out.point1; point1_.x = f32[ptr >> 2]; point1_.y = f32[(ptr >> 2) + 1];
    const point2_ = out.point2; point2_.x = f32[(ptr + 8) >> 2]; point2_.y = f32[((ptr + 8) >> 2) + 1];
    out.density = f32[(ptr + 16) >> 2];
    out.friction = f32[(ptr + 20) >> 2];
    out.restitution = f32[(ptr + 24) >> 2];
    out.isSensor = u8[ptr + 28] !== 0;
    out.enabled = u8[ptr + 29] !== 0;
    out.categoryBits = u32[(ptr + 32) >> 2];
    out.maskBits = u32[(ptr + 36) >> 2];
}

export function writeSegmentCollider2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: SegmentCollider2DPtrData,
): void {
    f32[ptr >> 2] = data.point1.x; f32[(ptr >> 2) + 1] = data.point1.y;
    f32[(ptr + 8) >> 2] = data.point2.x; f32[((ptr + 8) >> 2) + 1] = data.point2.y;
    f32[(ptr + 16) >> 2] = data.density;
    f32[(ptr + 20) >> 2] = data.friction;
    f32[(ptr + 24) >> 2] = data.restitution;
    u8[ptr + 28] = data.isSensor ? 1 : 0;
    u8[ptr + 29] = data.enabled ? 1 : 0;
    u32[(ptr + 32) >> 2] = data.categoryBits;
    u32[(ptr + 36) >> 2] = data.maskBits;
}

export function createSegmentCollider2DData(): SegmentCollider2DPtrData {
    return {
        point1: { x: 0, y: 0 },
        point2: { x: 0, y: 0 },
        density: 0,
        friction: 0,
        restitution: 0,
        isSensor: false,
        enabled: false,
        categoryBits: 0,
        maskBits: 0,
    };
}

export interface ShadowCaster2DPtrData {
    size: Vec2;
    enabled: boolean;
}

export function fillShadowCaster2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: ShadowCaster2DPtrData,
): void {
    const size_ = out.size; size_.x = f32[ptr >> 2]; size_.y = f32[(ptr >> 2) + 1];
    out.enabled = u8[ptr + 20] !== 0;
}

export function writeShadowCaster2D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: ShadowCaster2DPtrData,
): void {
    f32[ptr >> 2] = data.size.x; f32[(ptr >> 2) + 1] = data.size.y;
    u8[ptr + 20] = data.enabled ? 1 : 0;
}

export function createShadowCaster2DData(): ShadowCaster2DPtrData {
    return {
        size: { x: 0, y: 0 },
        enabled: false,
    };
}

export interface ShapeRendererPtrData {
    shapeType: number;
    color: Color;
    size: Vec2;
    cornerRadius: number;
    layer: number;
    parallax: Vec2;
    enabled: boolean;
}

export function fillShapeRenderer(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: ShapeRendererPtrData,
): void {
    out.shapeType = u8[ptr];
    const color_ = out.color; color_.r = f32[(ptr + 4) >> 2]; color_.g = f32[((ptr + 4) >> 2) + 1]; color_.b = f32[((ptr + 4) >> 2) + 2]; color_.a = f32[((ptr + 4) >> 2) + 3];
    const size_ = out.size; size_.x = f32[(ptr + 20) >> 2]; size_.y = f32[((ptr + 20) >> 2) + 1];
    out.cornerRadius = f32[(ptr + 28) >> 2];
    out.layer = u32[(ptr + 32) >> 2] | 0;
    const parallax_ = out.parallax; parallax_.x = f32[(ptr + 36) >> 2]; parallax_.y = f32[((ptr + 36) >> 2) + 1];
    out.enabled = u8[ptr + 44] !== 0;
}

export function writeShapeRenderer(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: ShapeRendererPtrData,
): void {
    u8[ptr] = data.shapeType;
    f32[(ptr + 4) >> 2] = data.color.r; f32[((ptr + 4) >> 2) + 1] = data.color.g; f32[((ptr + 4) >> 2) + 2] = data.color.b; f32[((ptr + 4) >> 2) + 3] = data.color.a;
    f32[(ptr + 20) >> 2] = data.size.x; f32[((ptr + 20) >> 2) + 1] = data.size.y;
    f32[(ptr + 28) >> 2] = data.cornerRadius;
    u32[(ptr + 32) >> 2] = data.layer | 0;
    f32[(ptr + 36) >> 2] = data.parallax.x; f32[((ptr + 36) >> 2) + 1] = data.parallax.y;
    u8[ptr + 44] = data.enabled ? 1 : 0;
}

export function createShapeRendererData(): ShapeRendererPtrData {
    return {
        shapeType: 0,
        color: { r: 0, g: 0, b: 0, a: 0 },
        size: { x: 0, y: 0 },
        cornerRadius: 0,
        layer: 0,
        parallax: { x: 0, y: 0 },
        enabled: false,
    };
}

export interface SortingGroupPtrData {
    layer: number;
    order: number;
    enabled: boolean;
}

export function fillSortingGroup(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: SortingGroupPtrData,
): void {
    out.layer = u32[ptr >> 2] | 0;
    out.order = u32[(ptr + 4) >> 2] | 0;
    out.enabled = u8[ptr + 8] !== 0;
}

export function writeSortingGroup(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: SortingGroupPtrData,
): void {
    u32[ptr >> 2] = data.layer | 0;
    u32[(ptr + 4) >> 2] = data.order | 0;
    u8[ptr + 8] = data.enabled ? 1 : 0;
}

export function createSortingGroupData(): SortingGroupPtrData {
    return {
        layer: 0,
        order: 0,
        enabled: false,
    };
}

export interface SphereCollider3DPtrData {
    radius: number;
    center: Vec3;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
}

export function fillSphereCollider3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: SphereCollider3DPtrData,
): void {
    out.radius = f32[ptr >> 2];
    const center_ = out.center; center_.x = f32[(ptr + 4) >> 2]; center_.y = f32[((ptr + 4) >> 2) + 1]; center_.z = f32[((ptr + 4) >> 2) + 2];
    out.friction = f32[(ptr + 16) >> 2];
    out.restitution = f32[(ptr + 20) >> 2];
    out.isSensor = u8[ptr + 24] !== 0;
    out.enabled = u8[ptr + 25] !== 0;
}

export function writeSphereCollider3D(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: SphereCollider3DPtrData,
): void {
    f32[ptr >> 2] = data.radius;
    f32[(ptr + 4) >> 2] = data.center.x; f32[((ptr + 4) >> 2) + 1] = data.center.y; f32[((ptr + 4) >> 2) + 2] = data.center.z;
    f32[(ptr + 16) >> 2] = data.friction;
    f32[(ptr + 20) >> 2] = data.restitution;
    u8[ptr + 24] = data.isSensor ? 1 : 0;
    u8[ptr + 25] = data.enabled ? 1 : 0;
}

export function createSphereCollider3DData(): SphereCollider3DPtrData {
    return {
        radius: 0,
        center: { x: 0, y: 0, z: 0 },
        friction: 0,
        restitution: 0,
        isSensor: false,
        enabled: false,
    };
}

export interface SpineAnimationPtrData {
    timeScale: number;
    loop: boolean;
    playing: boolean;
    flipX: boolean;
    flipY: boolean;
    color: Color;
    layer: number;
    skeletonScale: number;
    material: number;
    enabled: boolean;
}

export function fillSpineAnimation(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: SpineAnimationPtrData,
): void {
    out.timeScale = f32[(ptr + 48) >> 2];
    out.loop = u8[ptr + 52] !== 0;
    out.playing = u8[ptr + 53] !== 0;
    out.flipX = u8[ptr + 54] !== 0;
    out.flipY = u8[ptr + 55] !== 0;
    const color_ = out.color; color_.r = f32[(ptr + 56) >> 2]; color_.g = f32[((ptr + 56) >> 2) + 1]; color_.b = f32[((ptr + 56) >> 2) + 2]; color_.a = f32[((ptr + 56) >> 2) + 3];
    out.layer = u32[(ptr + 72) >> 2] | 0;
    out.skeletonScale = f32[(ptr + 76) >> 2];
    out.material = u32[(ptr + 80) >> 2];
    out.enabled = u8[ptr + 84] !== 0;
}

export function writeSpineAnimation(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: SpineAnimationPtrData,
): void {
    f32[(ptr + 48) >> 2] = data.timeScale;
    u8[ptr + 52] = data.loop ? 1 : 0;
    u8[ptr + 53] = data.playing ? 1 : 0;
    u8[ptr + 54] = data.flipX ? 1 : 0;
    u8[ptr + 55] = data.flipY ? 1 : 0;
    f32[(ptr + 56) >> 2] = data.color.r; f32[((ptr + 56) >> 2) + 1] = data.color.g; f32[((ptr + 56) >> 2) + 2] = data.color.b; f32[((ptr + 56) >> 2) + 3] = data.color.a;
    u32[(ptr + 72) >> 2] = data.layer | 0;
    f32[(ptr + 76) >> 2] = data.skeletonScale;
    u32[(ptr + 80) >> 2] = data.material;
    u8[ptr + 84] = data.enabled ? 1 : 0;
}

export function createSpineAnimationData(): SpineAnimationPtrData {
    return {
        timeScale: 0,
        loop: false,
        playing: false,
        flipX: false,
        flipY: false,
        color: { r: 0, g: 0, b: 0, a: 0 },
        layer: 0,
        skeletonScale: 0,
        material: 0,
        enabled: false,
    };
}

export interface SpringBonePtrData {
    enabled: boolean;
    stiffness: number;
    drag: number;
    gravity: Vec3;
    wind: Vec3;
    windGust: number;
    windFrequency: number;
    endLength: number;
    radius: number;
    weight: number;
}

export function fillSpringBone(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: SpringBonePtrData,
): void {
    out.enabled = u8[ptr] !== 0;
    out.stiffness = f32[(ptr + 4) >> 2];
    out.drag = f32[(ptr + 8) >> 2];
    const gravity_ = out.gravity; gravity_.x = f32[(ptr + 12) >> 2]; gravity_.y = f32[((ptr + 12) >> 2) + 1]; gravity_.z = f32[((ptr + 12) >> 2) + 2];
    const wind_ = out.wind; wind_.x = f32[(ptr + 24) >> 2]; wind_.y = f32[((ptr + 24) >> 2) + 1]; wind_.z = f32[((ptr + 24) >> 2) + 2];
    out.windGust = f32[(ptr + 36) >> 2];
    out.windFrequency = f32[(ptr + 40) >> 2];
    out.endLength = f32[(ptr + 44) >> 2];
    out.radius = f32[(ptr + 48) >> 2];
    out.weight = f32[(ptr + 52) >> 2];
}

export function writeSpringBone(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: SpringBonePtrData,
): void {
    u8[ptr] = data.enabled ? 1 : 0;
    f32[(ptr + 4) >> 2] = data.stiffness;
    f32[(ptr + 8) >> 2] = data.drag;
    f32[(ptr + 12) >> 2] = data.gravity.x; f32[((ptr + 12) >> 2) + 1] = data.gravity.y; f32[((ptr + 12) >> 2) + 2] = data.gravity.z;
    f32[(ptr + 24) >> 2] = data.wind.x; f32[((ptr + 24) >> 2) + 1] = data.wind.y; f32[((ptr + 24) >> 2) + 2] = data.wind.z;
    f32[(ptr + 36) >> 2] = data.windGust;
    f32[(ptr + 40) >> 2] = data.windFrequency;
    f32[(ptr + 44) >> 2] = data.endLength;
    f32[(ptr + 48) >> 2] = data.radius;
    f32[(ptr + 52) >> 2] = data.weight;
}

export function createSpringBoneData(): SpringBonePtrData {
    return {
        enabled: false,
        stiffness: 0,
        drag: 0,
        gravity: { x: 0, y: 0, z: 0 },
        wind: { x: 0, y: 0, z: 0 },
        windGust: 0,
        windFrequency: 0,
        endLength: 0,
        radius: 0,
        weight: 0,
    };
}

export interface SpringBoneColliderPtrData {
    shape: number;
    radius: number;
    height: number;
    offset: Vec3;
}

export function fillSpringBoneCollider(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: SpringBoneColliderPtrData,
): void {
    out.shape = u8[ptr];
    out.radius = f32[(ptr + 4) >> 2];
    out.height = f32[(ptr + 8) >> 2];
    const offset_ = out.offset; offset_.x = f32[(ptr + 12) >> 2]; offset_.y = f32[((ptr + 12) >> 2) + 1]; offset_.z = f32[((ptr + 12) >> 2) + 2];
}

export function writeSpringBoneCollider(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: SpringBoneColliderPtrData,
): void {
    u8[ptr] = data.shape;
    f32[(ptr + 4) >> 2] = data.radius;
    f32[(ptr + 8) >> 2] = data.height;
    f32[(ptr + 12) >> 2] = data.offset.x; f32[((ptr + 12) >> 2) + 1] = data.offset.y; f32[((ptr + 12) >> 2) + 2] = data.offset.z;
}

export function createSpringBoneColliderData(): SpringBoneColliderPtrData {
    return {
        shape: 0,
        radius: 0,
        height: 0,
        offset: { x: 0, y: 0, z: 0 },
    };
}

export interface SpritePtrData {
    texture: number;
    color: Color;
    size: Vec2;
    pivot: Vec2;
    uvOffset: Vec2;
    uvScale: Vec2;
    layer: number;
    order: number;
    maskInteraction: number;
    lit: boolean;
    flipX: boolean;
    flipY: boolean;
    drawMode: number;
    tileSize: Vec2;
    tileSpacing: Vec2;
    parallax: Vec2;
    material: number;
    enabled: boolean;
}

export function fillSprite(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: SpritePtrData,
): void {
    out.texture = u32[ptr >> 2];
    const color_ = out.color; color_.r = f32[(ptr + 4) >> 2]; color_.g = f32[((ptr + 4) >> 2) + 1]; color_.b = f32[((ptr + 4) >> 2) + 2]; color_.a = f32[((ptr + 4) >> 2) + 3];
    const size_ = out.size; size_.x = f32[(ptr + 20) >> 2]; size_.y = f32[((ptr + 20) >> 2) + 1];
    const pivot_ = out.pivot; pivot_.x = f32[(ptr + 28) >> 2]; pivot_.y = f32[((ptr + 28) >> 2) + 1];
    const uvOffset_ = out.uvOffset; uvOffset_.x = f32[(ptr + 36) >> 2]; uvOffset_.y = f32[((ptr + 36) >> 2) + 1];
    const uvScale_ = out.uvScale; uvScale_.x = f32[(ptr + 44) >> 2]; uvScale_.y = f32[((ptr + 44) >> 2) + 1];
    out.layer = u32[(ptr + 52) >> 2] | 0;
    out.order = u32[(ptr + 56) >> 2] | 0;
    out.maskInteraction = u32[(ptr + 60) >> 2] | 0;
    out.lit = u8[ptr + 64] !== 0;
    out.flipX = u8[ptr + 65] !== 0;
    out.flipY = u8[ptr + 66] !== 0;
    out.drawMode = u8[ptr + 67];
    const tileSize_ = out.tileSize; tileSize_.x = f32[(ptr + 68) >> 2]; tileSize_.y = f32[((ptr + 68) >> 2) + 1];
    const tileSpacing_ = out.tileSpacing; tileSpacing_.x = f32[(ptr + 76) >> 2]; tileSpacing_.y = f32[((ptr + 76) >> 2) + 1];
    const parallax_ = out.parallax; parallax_.x = f32[(ptr + 84) >> 2]; parallax_.y = f32[((ptr + 84) >> 2) + 1];
    out.material = u32[(ptr + 92) >> 2];
    out.enabled = u8[ptr + 96] !== 0;
}

export function writeSprite(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: SpritePtrData,
): void {
    u32[ptr >> 2] = data.texture;
    f32[(ptr + 4) >> 2] = data.color.r; f32[((ptr + 4) >> 2) + 1] = data.color.g; f32[((ptr + 4) >> 2) + 2] = data.color.b; f32[((ptr + 4) >> 2) + 3] = data.color.a;
    f32[(ptr + 20) >> 2] = data.size.x; f32[((ptr + 20) >> 2) + 1] = data.size.y;
    f32[(ptr + 28) >> 2] = data.pivot.x; f32[((ptr + 28) >> 2) + 1] = data.pivot.y;
    f32[(ptr + 36) >> 2] = data.uvOffset.x; f32[((ptr + 36) >> 2) + 1] = data.uvOffset.y;
    f32[(ptr + 44) >> 2] = data.uvScale.x; f32[((ptr + 44) >> 2) + 1] = data.uvScale.y;
    u32[(ptr + 52) >> 2] = data.layer | 0;
    u32[(ptr + 56) >> 2] = data.order | 0;
    u32[(ptr + 60) >> 2] = data.maskInteraction | 0;
    u8[ptr + 64] = data.lit ? 1 : 0;
    u8[ptr + 65] = data.flipX ? 1 : 0;
    u8[ptr + 66] = data.flipY ? 1 : 0;
    u8[ptr + 67] = data.drawMode;
    f32[(ptr + 68) >> 2] = data.tileSize.x; f32[((ptr + 68) >> 2) + 1] = data.tileSize.y;
    f32[(ptr + 76) >> 2] = data.tileSpacing.x; f32[((ptr + 76) >> 2) + 1] = data.tileSpacing.y;
    f32[(ptr + 84) >> 2] = data.parallax.x; f32[((ptr + 84) >> 2) + 1] = data.parallax.y;
    u32[(ptr + 92) >> 2] = data.material;
    u8[ptr + 96] = data.enabled ? 1 : 0;
}

export function createSpriteData(): SpritePtrData {
    return {
        texture: 0,
        color: { r: 0, g: 0, b: 0, a: 0 },
        size: { x: 0, y: 0 },
        pivot: { x: 0, y: 0 },
        uvOffset: { x: 0, y: 0 },
        uvScale: { x: 0, y: 0 },
        layer: 0,
        order: 0,
        maskInteraction: 0,
        lit: false,
        flipX: false,
        flipY: false,
        drawMode: 0,
        tileSize: { x: 0, y: 0 },
        tileSpacing: { x: 0, y: 0 },
        parallax: { x: 0, y: 0 },
        material: 0,
        enabled: false,
    };
}

export interface SpriteMaskPtrData {
    alphaCutoff: number;
    limitRange: boolean;
    rangeEndLayer: number;
    rangeEndOrder: number;
    enabled: boolean;
}

export function fillSpriteMask(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: SpriteMaskPtrData,
): void {
    out.alphaCutoff = f32[ptr >> 2];
    out.limitRange = u8[ptr + 4] !== 0;
    out.rangeEndLayer = u32[(ptr + 8) >> 2] | 0;
    out.rangeEndOrder = u32[(ptr + 12) >> 2] | 0;
    out.enabled = u8[ptr + 16] !== 0;
}

export function writeSpriteMask(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: SpriteMaskPtrData,
): void {
    f32[ptr >> 2] = data.alphaCutoff;
    u8[ptr + 4] = data.limitRange ? 1 : 0;
    u32[(ptr + 8) >> 2] = data.rangeEndLayer | 0;
    u32[(ptr + 12) >> 2] = data.rangeEndOrder | 0;
    u8[ptr + 16] = data.enabled ? 1 : 0;
}

export function createSpriteMaskData(): SpriteMaskPtrData {
    return {
        alphaCutoff: 0,
        limitRange: false,
        rangeEndLayer: 0,
        rangeEndOrder: 0,
        enabled: false,
    };
}

export interface TilemapLayerPtrData {
    cellSize: Vec2;
    orientation: number;
    hexSideLength: number;
    staggerAxis: number;
    staggerIndex: number;
    originOffset: Vec2;
    tileset: number;
    tilesetColumns: number;
    renderLayer: number;
    tintColor: Color;
    opacity: number;
    parallaxFactor: Vec2;
    visible: boolean;
    lit: boolean;
}

export function fillTilemapLayer(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: TilemapLayerPtrData,
): void {
    const cellSize_ = out.cellSize; cellSize_.x = f32[ptr >> 2]; cellSize_.y = f32[(ptr >> 2) + 1];
    out.orientation = u8[ptr + 8];
    out.hexSideLength = f32[(ptr + 12) >> 2];
    out.staggerAxis = u8[ptr + 16];
    out.staggerIndex = u8[ptr + 17];
    const originOffset_ = out.originOffset; originOffset_.x = f32[(ptr + 20) >> 2]; originOffset_.y = f32[((ptr + 20) >> 2) + 1];
    out.tileset = u32[(ptr + 28) >> 2];
    out.tilesetColumns = u32[(ptr + 32) >> 2] | 0;
    out.renderLayer = u32[(ptr + 36) >> 2] | 0;
    const tintColor_ = out.tintColor; tintColor_.r = f32[(ptr + 40) >> 2]; tintColor_.g = f32[((ptr + 40) >> 2) + 1]; tintColor_.b = f32[((ptr + 40) >> 2) + 2]; tintColor_.a = f32[((ptr + 40) >> 2) + 3];
    out.opacity = f32[(ptr + 56) >> 2];
    const parallaxFactor_ = out.parallaxFactor; parallaxFactor_.x = f32[(ptr + 60) >> 2]; parallaxFactor_.y = f32[((ptr + 60) >> 2) + 1];
    out.visible = u8[ptr + 68] !== 0;
    out.lit = u8[ptr + 69] !== 0;
}

export function writeTilemapLayer(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: TilemapLayerPtrData,
): void {
    f32[ptr >> 2] = data.cellSize.x; f32[(ptr >> 2) + 1] = data.cellSize.y;
    u8[ptr + 8] = data.orientation;
    f32[(ptr + 12) >> 2] = data.hexSideLength;
    u8[ptr + 16] = data.staggerAxis;
    u8[ptr + 17] = data.staggerIndex;
    f32[(ptr + 20) >> 2] = data.originOffset.x; f32[((ptr + 20) >> 2) + 1] = data.originOffset.y;
    u32[(ptr + 28) >> 2] = data.tileset;
    u32[(ptr + 32) >> 2] = data.tilesetColumns | 0;
    u32[(ptr + 36) >> 2] = data.renderLayer | 0;
    f32[(ptr + 40) >> 2] = data.tintColor.r; f32[((ptr + 40) >> 2) + 1] = data.tintColor.g; f32[((ptr + 40) >> 2) + 2] = data.tintColor.b; f32[((ptr + 40) >> 2) + 3] = data.tintColor.a;
    f32[(ptr + 56) >> 2] = data.opacity;
    f32[(ptr + 60) >> 2] = data.parallaxFactor.x; f32[((ptr + 60) >> 2) + 1] = data.parallaxFactor.y;
    u8[ptr + 68] = data.visible ? 1 : 0;
    u8[ptr + 69] = data.lit ? 1 : 0;
}

export function createTilemapLayerData(): TilemapLayerPtrData {
    return {
        cellSize: { x: 0, y: 0 },
        orientation: 0,
        hexSideLength: 0,
        staggerAxis: 0,
        staggerIndex: 0,
        originOffset: { x: 0, y: 0 },
        tileset: 0,
        tilesetColumns: 0,
        renderLayer: 0,
        tintColor: { r: 0, g: 0, b: 0, a: 0 },
        opacity: 0,
        parallaxFactor: { x: 0, y: 0 },
        visible: false,
        lit: false,
    };
}

export interface TrailRendererPtrData {
    time: number;
    minVertexDistance: number;
    emitting: boolean;
    startWidth: number;
    endWidth: number;
    startColor: Color;
    endColor: Color;
    texture: number;
    blendMode: number;
    layer: number;
    material: number;
    enabled: boolean;
}

export function fillTrailRenderer(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: TrailRendererPtrData,
): void {
    out.time = f32[ptr >> 2];
    out.minVertexDistance = f32[(ptr + 4) >> 2];
    out.emitting = u8[ptr + 8] !== 0;
    out.startWidth = f32[(ptr + 12) >> 2];
    out.endWidth = f32[(ptr + 16) >> 2];
    const startColor_ = out.startColor; startColor_.r = f32[(ptr + 20) >> 2]; startColor_.g = f32[((ptr + 20) >> 2) + 1]; startColor_.b = f32[((ptr + 20) >> 2) + 2]; startColor_.a = f32[((ptr + 20) >> 2) + 3];
    const endColor_ = out.endColor; endColor_.r = f32[(ptr + 36) >> 2]; endColor_.g = f32[((ptr + 36) >> 2) + 1]; endColor_.b = f32[((ptr + 36) >> 2) + 2]; endColor_.a = f32[((ptr + 36) >> 2) + 3];
    out.texture = u32[(ptr + 52) >> 2];
    out.blendMode = u32[(ptr + 56) >> 2] | 0;
    out.layer = u32[(ptr + 60) >> 2] | 0;
    out.material = u32[(ptr + 64) >> 2];
    out.enabled = u8[ptr + 68] !== 0;
}

export function writeTrailRenderer(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: TrailRendererPtrData,
): void {
    f32[ptr >> 2] = data.time;
    f32[(ptr + 4) >> 2] = data.minVertexDistance;
    u8[ptr + 8] = data.emitting ? 1 : 0;
    f32[(ptr + 12) >> 2] = data.startWidth;
    f32[(ptr + 16) >> 2] = data.endWidth;
    f32[(ptr + 20) >> 2] = data.startColor.r; f32[((ptr + 20) >> 2) + 1] = data.startColor.g; f32[((ptr + 20) >> 2) + 2] = data.startColor.b; f32[((ptr + 20) >> 2) + 3] = data.startColor.a;
    f32[(ptr + 36) >> 2] = data.endColor.r; f32[((ptr + 36) >> 2) + 1] = data.endColor.g; f32[((ptr + 36) >> 2) + 2] = data.endColor.b; f32[((ptr + 36) >> 2) + 3] = data.endColor.a;
    u32[(ptr + 52) >> 2] = data.texture;
    u32[(ptr + 56) >> 2] = data.blendMode | 0;
    u32[(ptr + 60) >> 2] = data.layer | 0;
    u32[(ptr + 64) >> 2] = data.material;
    u8[ptr + 68] = data.enabled ? 1 : 0;
}

export function createTrailRendererData(): TrailRendererPtrData {
    return {
        time: 0,
        minVertexDistance: 0,
        emitting: false,
        startWidth: 0,
        endWidth: 0,
        startColor: { r: 0, g: 0, b: 0, a: 0 },
        endColor: { r: 0, g: 0, b: 0, a: 0 },
        texture: 0,
        blendMode: 0,
        layer: 0,
        material: 0,
        enabled: false,
    };
}

export interface TransformPtrData {
    position: Vec3;
    rotation: Vec4;
    scale: Vec3;
    worldPosition: Vec3;
    worldRotation: Vec4;
    worldScale: Vec3;
}

export function fillTransform(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: TransformPtrData,
): void {
    const position_ = out.position; position_.x = f32[ptr >> 2]; position_.y = f32[(ptr >> 2) + 1]; position_.z = f32[(ptr >> 2) + 2];
    const rotation_ = out.rotation; rotation_.x = f32[(ptr + 12) >> 2]; rotation_.y = f32[((ptr + 12) >> 2) + 1]; rotation_.z = f32[((ptr + 12) >> 2) + 2]; rotation_.w = f32[((ptr + 12) >> 2) + 3];
    const scale_ = out.scale; scale_.x = f32[(ptr + 28) >> 2]; scale_.y = f32[((ptr + 28) >> 2) + 1]; scale_.z = f32[((ptr + 28) >> 2) + 2];
    const worldPosition_ = out.worldPosition; worldPosition_.x = f32[(ptr + 40) >> 2]; worldPosition_.y = f32[((ptr + 40) >> 2) + 1]; worldPosition_.z = f32[((ptr + 40) >> 2) + 2];
    const worldRotation_ = out.worldRotation; worldRotation_.x = f32[(ptr + 52) >> 2]; worldRotation_.y = f32[((ptr + 52) >> 2) + 1]; worldRotation_.z = f32[((ptr + 52) >> 2) + 2]; worldRotation_.w = f32[((ptr + 52) >> 2) + 3];
    const worldScale_ = out.worldScale; worldScale_.x = f32[(ptr + 68) >> 2]; worldScale_.y = f32[((ptr + 68) >> 2) + 1]; worldScale_.z = f32[((ptr + 68) >> 2) + 2];
}

export function writeTransform(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: TransformPtrData,
): void {
    f32[ptr >> 2] = data.position.x; f32[(ptr >> 2) + 1] = data.position.y; f32[(ptr >> 2) + 2] = data.position.z;
    f32[(ptr + 12) >> 2] = data.rotation.x; f32[((ptr + 12) >> 2) + 1] = data.rotation.y; f32[((ptr + 12) >> 2) + 2] = data.rotation.z; f32[((ptr + 12) >> 2) + 3] = data.rotation.w;
    f32[(ptr + 28) >> 2] = data.scale.x; f32[((ptr + 28) >> 2) + 1] = data.scale.y; f32[((ptr + 28) >> 2) + 2] = data.scale.z;
    f32[(ptr + 40) >> 2] = data.worldPosition.x; f32[((ptr + 40) >> 2) + 1] = data.worldPosition.y; f32[((ptr + 40) >> 2) + 2] = data.worldPosition.z;
    f32[(ptr + 52) >> 2] = data.worldRotation.x; f32[((ptr + 52) >> 2) + 1] = data.worldRotation.y; f32[((ptr + 52) >> 2) + 2] = data.worldRotation.z; f32[((ptr + 52) >> 2) + 3] = data.worldRotation.w;
    f32[(ptr + 68) >> 2] = data.worldScale.x; f32[((ptr + 68) >> 2) + 1] = data.worldScale.y; f32[((ptr + 68) >> 2) + 2] = data.worldScale.z;
}

export function createTransformData(): TransformPtrData {
    return {
        position: { x: 0, y: 0, z: 0 },
        rotation: { x: 0, y: 0, z: 0, w: 0 },
        scale: { x: 0, y: 0, z: 0 },
        worldPosition: { x: 0, y: 0, z: 0 },
        worldRotation: { x: 0, y: 0, z: 0, w: 0 },
        worldScale: { x: 0, y: 0, z: 0 },
    };
}

export interface UIInteractionPtrData {
    hovered: boolean;
    pressed: boolean;
    justPressed: boolean;
    justReleased: boolean;
}

export function fillUIInteraction(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: UIInteractionPtrData,
): void {
    out.hovered = u8[ptr] !== 0;
    out.pressed = u8[ptr + 1] !== 0;
    out.justPressed = u8[ptr + 2] !== 0;
    out.justReleased = u8[ptr + 3] !== 0;
}

export function writeUIInteraction(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: UIInteractionPtrData,
): void {
    u8[ptr] = data.hovered ? 1 : 0;
    u8[ptr + 1] = data.pressed ? 1 : 0;
    u8[ptr + 2] = data.justPressed ? 1 : 0;
    u8[ptr + 3] = data.justReleased ? 1 : 0;
}

export function createUIInteractionData(): UIInteractionPtrData {
    return {
        hovered: false,
        pressed: false,
        justPressed: false,
        justReleased: false,
    };
}

export interface UIMaskPtrData {
    enabled: boolean;
    mode: number;
    alphaCutoff: number;
}

export function fillUIMask(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: UIMaskPtrData,
): void {
    out.enabled = u8[ptr] !== 0;
    out.mode = u8[ptr + 1];
    out.alphaCutoff = f32[(ptr + 4) >> 2];
}

export function writeUIMask(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: UIMaskPtrData,
): void {
    u8[ptr] = data.enabled ? 1 : 0;
    u8[ptr + 1] = data.mode;
    f32[(ptr + 4) >> 2] = data.alphaCutoff;
}

export function createUIMaskData(): UIMaskPtrData {
    return {
        enabled: false,
        mode: 0,
        alphaCutoff: 0,
    };
}

export interface UINodePtrData {
    position: number;
    display: number;
    opacity: number;
    pointerEvents: number;
    width: { value: number; unit: number; };
    height: { value: number; unit: number; };
    minWidth: { value: number; unit: number; };
    minHeight: { value: number; unit: number; };
    maxWidth: { value: number; unit: number; };
    maxHeight: { value: number; unit: number; };
    flexGrow: number;
    flexShrink: number;
    flexBasis: { value: number; unit: number; };
    alignSelf: number;
    marginLeft: { value: number; unit: number; };
    marginTop: { value: number; unit: number; };
    marginRight: { value: number; unit: number; };
    marginBottom: { value: number; unit: number; };
    insetLeft: { value: number; unit: number; };
    insetTop: { value: number; unit: number; };
    insetRight: { value: number; unit: number; };
    insetBottom: { value: number; unit: number; };
}

export function fillUINode(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: UINodePtrData,
): void {
    out.position = u8[ptr];
    out.display = u8[ptr + 1];
    out.opacity = f32[(ptr + 4) >> 2];
    out.pointerEvents = u8[ptr + 8];
    const width_ = out.width; width_.value = f32[(ptr + 12) >> 2]; width_.unit = u8[ptr + 16];
    const height_ = out.height; height_.value = f32[(ptr + 20) >> 2]; height_.unit = u8[ptr + 24];
    const minWidth_ = out.minWidth; minWidth_.value = f32[(ptr + 28) >> 2]; minWidth_.unit = u8[ptr + 32];
    const minHeight_ = out.minHeight; minHeight_.value = f32[(ptr + 36) >> 2]; minHeight_.unit = u8[ptr + 40];
    const maxWidth_ = out.maxWidth; maxWidth_.value = f32[(ptr + 44) >> 2]; maxWidth_.unit = u8[ptr + 48];
    const maxHeight_ = out.maxHeight; maxHeight_.value = f32[(ptr + 52) >> 2]; maxHeight_.unit = u8[ptr + 56];
    out.flexGrow = f32[(ptr + 60) >> 2];
    out.flexShrink = f32[(ptr + 64) >> 2];
    const flexBasis_ = out.flexBasis; flexBasis_.value = f32[(ptr + 68) >> 2]; flexBasis_.unit = u8[ptr + 72];
    out.alignSelf = u8[ptr + 76];
    const marginLeft_ = out.marginLeft; marginLeft_.value = f32[(ptr + 80) >> 2]; marginLeft_.unit = u8[ptr + 84];
    const marginTop_ = out.marginTop; marginTop_.value = f32[(ptr + 88) >> 2]; marginTop_.unit = u8[ptr + 92];
    const marginRight_ = out.marginRight; marginRight_.value = f32[(ptr + 96) >> 2]; marginRight_.unit = u8[ptr + 100];
    const marginBottom_ = out.marginBottom; marginBottom_.value = f32[(ptr + 104) >> 2]; marginBottom_.unit = u8[ptr + 108];
    const insetLeft_ = out.insetLeft; insetLeft_.value = f32[(ptr + 112) >> 2]; insetLeft_.unit = u8[ptr + 116];
    const insetTop_ = out.insetTop; insetTop_.value = f32[(ptr + 120) >> 2]; insetTop_.unit = u8[ptr + 124];
    const insetRight_ = out.insetRight; insetRight_.value = f32[(ptr + 128) >> 2]; insetRight_.unit = u8[ptr + 132];
    const insetBottom_ = out.insetBottom; insetBottom_.value = f32[(ptr + 136) >> 2]; insetBottom_.unit = u8[ptr + 140];
}

export function writeUINode(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: UINodePtrData,
): void {
    u8[ptr] = data.position;
    u8[ptr + 1] = data.display;
    f32[(ptr + 4) >> 2] = data.opacity;
    u8[ptr + 8] = data.pointerEvents;
    f32[(ptr + 12) >> 2] = data.width.value; u8[ptr + 16] = data.width.unit;
    f32[(ptr + 20) >> 2] = data.height.value; u8[ptr + 24] = data.height.unit;
    f32[(ptr + 28) >> 2] = data.minWidth.value; u8[ptr + 32] = data.minWidth.unit;
    f32[(ptr + 36) >> 2] = data.minHeight.value; u8[ptr + 40] = data.minHeight.unit;
    f32[(ptr + 44) >> 2] = data.maxWidth.value; u8[ptr + 48] = data.maxWidth.unit;
    f32[(ptr + 52) >> 2] = data.maxHeight.value; u8[ptr + 56] = data.maxHeight.unit;
    f32[(ptr + 60) >> 2] = data.flexGrow;
    f32[(ptr + 64) >> 2] = data.flexShrink;
    f32[(ptr + 68) >> 2] = data.flexBasis.value; u8[ptr + 72] = data.flexBasis.unit;
    u8[ptr + 76] = data.alignSelf;
    f32[(ptr + 80) >> 2] = data.marginLeft.value; u8[ptr + 84] = data.marginLeft.unit;
    f32[(ptr + 88) >> 2] = data.marginTop.value; u8[ptr + 92] = data.marginTop.unit;
    f32[(ptr + 96) >> 2] = data.marginRight.value; u8[ptr + 100] = data.marginRight.unit;
    f32[(ptr + 104) >> 2] = data.marginBottom.value; u8[ptr + 108] = data.marginBottom.unit;
    f32[(ptr + 112) >> 2] = data.insetLeft.value; u8[ptr + 116] = data.insetLeft.unit;
    f32[(ptr + 120) >> 2] = data.insetTop.value; u8[ptr + 124] = data.insetTop.unit;
    f32[(ptr + 128) >> 2] = data.insetRight.value; u8[ptr + 132] = data.insetRight.unit;
    f32[(ptr + 136) >> 2] = data.insetBottom.value; u8[ptr + 140] = data.insetBottom.unit;
}

export function createUINodeData(): UINodePtrData {
    return {
        position: 0,
        display: 0,
        opacity: 0,
        pointerEvents: 0,
        width: { value: 0, unit: 0 },
        height: { value: 0, unit: 0 },
        minWidth: { value: 0, unit: 0 },
        minHeight: { value: 0, unit: 0 },
        maxWidth: { value: 0, unit: 0 },
        maxHeight: { value: 0, unit: 0 },
        flexGrow: 0,
        flexShrink: 0,
        flexBasis: { value: 0, unit: 0 },
        alignSelf: 0,
        marginLeft: { value: 0, unit: 0 },
        marginTop: { value: 0, unit: 0 },
        marginRight: { value: 0, unit: 0 },
        marginBottom: { value: 0, unit: 0 },
        insetLeft: { value: 0, unit: 0 },
        insetTop: { value: 0, unit: 0 },
        insetRight: { value: 0, unit: 0 },
        insetBottom: { value: 0, unit: 0 },
    };
}

export interface UIScrollPtrData {
    enabled: boolean;
    content: number;
    horizontal: boolean;
    vertical: boolean;
    movement: number;
    wheelSpeed: number;
    dragScroll: boolean;
    decelerationRate: number;
}

export function fillUIScroll(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: UIScrollPtrData,
): void {
    out.enabled = u8[ptr] !== 0;
    out.content = u32[(ptr + 4) >> 2];
    out.horizontal = u8[ptr + 8] !== 0;
    out.vertical = u8[ptr + 9] !== 0;
    out.movement = u8[ptr + 10];
    out.wheelSpeed = f32[(ptr + 12) >> 2];
    out.dragScroll = u8[ptr + 16] !== 0;
    out.decelerationRate = f32[(ptr + 20) >> 2];
}

export function writeUIScroll(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: UIScrollPtrData,
): void {
    u8[ptr] = data.enabled ? 1 : 0;
    u32[(ptr + 4) >> 2] = data.content;
    u8[ptr + 8] = data.horizontal ? 1 : 0;
    u8[ptr + 9] = data.vertical ? 1 : 0;
    u8[ptr + 10] = data.movement;
    f32[(ptr + 12) >> 2] = data.wheelSpeed;
    u8[ptr + 16] = data.dragScroll ? 1 : 0;
    f32[(ptr + 20) >> 2] = data.decelerationRate;
}

export function createUIScrollData(): UIScrollPtrData {
    return {
        enabled: false,
        content: 0,
        horizontal: false,
        vertical: false,
        movement: 0,
        wheelSpeed: 0,
        dragScroll: false,
        decelerationRate: 0,
    };
}

export interface UIVisualPtrData {
    visualType: number;
    texture: number;
    color: Color;
    fit: number;
    uvOffset: Vec2;
    uvScale: Vec2;
    sliceBorder: Vec4;
    tileSize: Vec2;
    fillMethod: number;
    fillOrigin: number;
    fillAmount: number;
    material: number;
    enabled: boolean;
}

export function fillUIVisual(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: UIVisualPtrData,
): void {
    out.visualType = u8[ptr];
    out.texture = u32[(ptr + 4) >> 2];
    const color_ = out.color; color_.r = f32[(ptr + 8) >> 2]; color_.g = f32[((ptr + 8) >> 2) + 1]; color_.b = f32[((ptr + 8) >> 2) + 2]; color_.a = f32[((ptr + 8) >> 2) + 3];
    out.fit = u8[ptr + 24];
    const uvOffset_ = out.uvOffset; uvOffset_.x = f32[(ptr + 28) >> 2]; uvOffset_.y = f32[((ptr + 28) >> 2) + 1];
    const uvScale_ = out.uvScale; uvScale_.x = f32[(ptr + 36) >> 2]; uvScale_.y = f32[((ptr + 36) >> 2) + 1];
    const sliceBorder_ = out.sliceBorder; sliceBorder_.x = f32[(ptr + 44) >> 2]; sliceBorder_.y = f32[((ptr + 44) >> 2) + 1]; sliceBorder_.z = f32[((ptr + 44) >> 2) + 2]; sliceBorder_.w = f32[((ptr + 44) >> 2) + 3];
    const tileSize_ = out.tileSize; tileSize_.x = f32[(ptr + 60) >> 2]; tileSize_.y = f32[((ptr + 60) >> 2) + 1];
    out.fillMethod = u8[ptr + 68];
    out.fillOrigin = u8[ptr + 69];
    out.fillAmount = f32[(ptr + 72) >> 2];
    out.material = u32[(ptr + 76) >> 2];
    out.enabled = u8[ptr + 80] !== 0;
}

export function writeUIVisual(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: UIVisualPtrData,
): void {
    u8[ptr] = data.visualType;
    u32[(ptr + 4) >> 2] = data.texture;
    f32[(ptr + 8) >> 2] = data.color.r; f32[((ptr + 8) >> 2) + 1] = data.color.g; f32[((ptr + 8) >> 2) + 2] = data.color.b; f32[((ptr + 8) >> 2) + 3] = data.color.a;
    u8[ptr + 24] = data.fit;
    f32[(ptr + 28) >> 2] = data.uvOffset.x; f32[((ptr + 28) >> 2) + 1] = data.uvOffset.y;
    f32[(ptr + 36) >> 2] = data.uvScale.x; f32[((ptr + 36) >> 2) + 1] = data.uvScale.y;
    f32[(ptr + 44) >> 2] = data.sliceBorder.x; f32[((ptr + 44) >> 2) + 1] = data.sliceBorder.y; f32[((ptr + 44) >> 2) + 2] = data.sliceBorder.z; f32[((ptr + 44) >> 2) + 3] = data.sliceBorder.w;
    f32[(ptr + 60) >> 2] = data.tileSize.x; f32[((ptr + 60) >> 2) + 1] = data.tileSize.y;
    u8[ptr + 68] = data.fillMethod;
    u8[ptr + 69] = data.fillOrigin;
    f32[(ptr + 72) >> 2] = data.fillAmount;
    u32[(ptr + 76) >> 2] = data.material;
    u8[ptr + 80] = data.enabled ? 1 : 0;
}

export function createUIVisualData(): UIVisualPtrData {
    return {
        visualType: 0,
        texture: 0,
        color: { r: 0, g: 0, b: 0, a: 0 },
        fit: 0,
        uvOffset: { x: 0, y: 0 },
        uvScale: { x: 0, y: 0 },
        sliceBorder: { x: 0, y: 0, z: 0, w: 0 },
        tileSize: { x: 0, y: 0 },
        fillMethod: 0,
        fillOrigin: 0,
        fillAmount: 0,
        material: 0,
        enabled: false,
    };
}

export interface VelocityPtrData {
    linear: Vec3;
    angular: Vec3;
}

export function fillVelocity(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, out: VelocityPtrData,
): void {
    const linear_ = out.linear; linear_.x = f32[ptr >> 2]; linear_.y = f32[(ptr >> 2) + 1]; linear_.z = f32[(ptr >> 2) + 2];
    const angular_ = out.angular; angular_.x = f32[(ptr + 12) >> 2]; angular_.y = f32[((ptr + 12) >> 2) + 1]; angular_.z = f32[((ptr + 12) >> 2) + 2];
}

export function writeVelocity(
    f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
    ptr: number, data: VelocityPtrData,
): void {
    f32[ptr >> 2] = data.linear.x; f32[(ptr >> 2) + 1] = data.linear.y; f32[(ptr >> 2) + 2] = data.linear.z;
    f32[(ptr + 12) >> 2] = data.angular.x; f32[((ptr + 12) >> 2) + 1] = data.angular.y; f32[((ptr + 12) >> 2) + 2] = data.angular.z;
}

export function createVelocityData(): VelocityPtrData {
    return {
        linear: { x: 0, y: 0, z: 0 },
        angular: { x: 0, y: 0, z: 0 },
    };
}

export interface PtrAccessor<T> {
    fill: (f32: Float32Array, u32: Uint32Array, u8: Uint8Array, ptr: number, out: T) => void;
    write: (f32: Float32Array, u32: Uint32Array, u8: Uint8Array, ptr: number, data: T) => void;
    create: () => T;
}

export const PTR_ACCESSORS: Record<string, PtrAccessor<any>> = {
    Billboard: { fill: fillBillboard, write: writeBillboard, create: createBillboardData },
    BitmapText: { fill: fillBitmapText, write: writeBitmapText, create: createBitmapTextData },
    BoxCollider2D: { fill: fillBoxCollider2D, write: writeBoxCollider2D, create: createBoxCollider2DData },
    BoxCollider3D: { fill: fillBoxCollider3D, write: writeBoxCollider3D, create: createBoxCollider3DData },
    Camera: { fill: fillCamera, write: writeCamera, create: createCameraData },
    Canvas: { fill: fillCanvas, write: writeCanvas, create: createCanvasData },
    CapsuleCollider2D: { fill: fillCapsuleCollider2D, write: writeCapsuleCollider2D, create: createCapsuleCollider2DData },
    CapsuleCollider3D: { fill: fillCapsuleCollider3D, write: writeCapsuleCollider3D, create: createCapsuleCollider3DData },
    CharacterController3D: { fill: fillCharacterController3D, write: writeCharacterController3D, create: createCharacterController3DData },
    CircleCollider2D: { fill: fillCircleCollider2D, write: writeCircleCollider2D, create: createCircleCollider2DData },
    ContentRect: { fill: fillContentRect, write: writeContentRect, create: createContentRectData },
    ConvexCollider3D: { fill: fillConvexCollider3D, write: writeConvexCollider3D, create: createConvexCollider3DData },
    Draggable: { fill: fillDraggable, write: writeDraggable, create: createDraggableData },
    DragonBonesAnimation: { fill: fillDragonBonesAnimation, write: writeDragonBonesAnimation, create: createDragonBonesAnimationData },
    FlexContainer: { fill: fillFlexContainer, write: writeFlexContainer, create: createFlexContainerData },
    GroupOpacity: { fill: fillGroupOpacity, write: writeGroupOpacity, create: createGroupOpacityData },
    Impostor: { fill: fillImpostor, write: writeImpostor, create: createImpostorData },
    Interactable: { fill: fillInteractable, write: writeInteractable, create: createInteractableData },
    LODGroup: { fill: fillLODGroup, write: writeLODGroup, create: createLODGroupData },
    Light: { fill: fillLight, write: writeLight, create: createLightData },
    LightProbeVolume: { fill: fillLightProbeVolume, write: writeLightProbeVolume, create: createLightProbeVolumeData },
    MeshCollider3D: { fill: fillMeshCollider3D, write: writeMeshCollider3D, create: createMeshCollider3DData },
    MeshInstances: { fill: fillMeshInstances, write: writeMeshInstances, create: createMeshInstancesData },
    MeshLightmap: { fill: fillMeshLightmap, write: writeMeshLightmap, create: createMeshLightmapData },
    MeshRenderer: { fill: fillMeshRenderer, write: writeMeshRenderer, create: createMeshRendererData },
    Occluder: { fill: fillOccluder, write: writeOccluder, create: createOccluderData },
    ParticleCollider: { fill: fillParticleCollider, write: writeParticleCollider, create: createParticleColliderData },
    ParticleEmitter: { fill: fillParticleEmitter, write: writeParticleEmitter, create: createParticleEmitterData },
    ParticleForceField: { fill: fillParticleForceField, write: writeParticleForceField, create: createParticleForceFieldData },
    PlanarReflection: { fill: fillPlanarReflection, write: writePlanarReflection, create: createPlanarReflectionData },
    ReflectionProbe: { fill: fillReflectionProbe, write: writeReflectionProbe, create: createReflectionProbeData },
    RigidBody2D: { fill: fillRigidBody2D, write: writeRigidBody2D, create: createRigidBody2DData },
    RigidBody3D: { fill: fillRigidBody3D, write: writeRigidBody3D, create: createRigidBody3DData },
    SegmentCollider2D: { fill: fillSegmentCollider2D, write: writeSegmentCollider2D, create: createSegmentCollider2DData },
    ShadowCaster2D: { fill: fillShadowCaster2D, write: writeShadowCaster2D, create: createShadowCaster2DData },
    ShapeRenderer: { fill: fillShapeRenderer, write: writeShapeRenderer, create: createShapeRendererData },
    SortingGroup: { fill: fillSortingGroup, write: writeSortingGroup, create: createSortingGroupData },
    SphereCollider3D: { fill: fillSphereCollider3D, write: writeSphereCollider3D, create: createSphereCollider3DData },
    SpineAnimation: { fill: fillSpineAnimation, write: writeSpineAnimation, create: createSpineAnimationData },
    SpringBone: { fill: fillSpringBone, write: writeSpringBone, create: createSpringBoneData },
    SpringBoneCollider: { fill: fillSpringBoneCollider, write: writeSpringBoneCollider, create: createSpringBoneColliderData },
    Sprite: { fill: fillSprite, write: writeSprite, create: createSpriteData },
    SpriteMask: { fill: fillSpriteMask, write: writeSpriteMask, create: createSpriteMaskData },
    TilemapLayer: { fill: fillTilemapLayer, write: writeTilemapLayer, create: createTilemapLayerData },
    TrailRenderer: { fill: fillTrailRenderer, write: writeTrailRenderer, create: createTrailRendererData },
    Transform: { fill: fillTransform, write: writeTransform, create: createTransformData },
    UIInteraction: { fill: fillUIInteraction, write: writeUIInteraction, create: createUIInteractionData },
    UIMask: { fill: fillUIMask, write: writeUIMask, create: createUIMaskData },
    UINode: { fill: fillUINode, write: writeUINode, create: createUINodeData },
    UIScroll: { fill: fillUIScroll, write: writeUIScroll, create: createUIScrollData },
    UIVisual: { fill: fillUIVisual, write: writeUIVisual, create: createUIVisualData },
    Velocity: { fill: fillVelocity, write: writeVelocity, create: createVelocityData },
};