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.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
/**
* @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 },
};