Skip to content

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

feat(wasm): export authoritative component list via reflection

esengine8ea0e2ce59f1
diff --git a/sdk/src/ecs/BuiltinBridge.ts b/sdk/src/ecs/BuiltinBridge.ts
index 9e45f0917..ff131b03b 100644
--- a/sdk/src/ecs/BuiltinBridge.ts
+++ b/sdk/src/ecs/BuiltinBridge.ts
@@ -176,6 +176,19 @@ export interface BridgeVerification {
readonly ok: boolean;
/** List of components with missing bindings (empty when ok). */
readonly missing: readonly { readonly name: string; readonly methods: readonly string[] }[];
+ /**
+ * Components reported by the WASM module's reflection table
+ * (`getBuiltinComponentNames`) that are not present in the shipped
+ * COMPONENT_META — the WASM was built from a newer schema than the SDK
+ * bundle. Only populated when the module exposes the reflection call.
+ */
+ readonly wasmOnly: readonly string[];
+ /**
+ * Components declared in COMPONENT_META that the WASM module's reflection
+ * table does not list — the SDK was built from a newer schema than the
+ * WASM. Only populated when the module exposes the reflection call.
+ */
+ readonly sdkOnly: readonly string[];
}
/** Options for {@link BuiltinBridge.connect}. */
@@ -193,13 +206,23 @@ export interface BridgeConnectOptions {
const METHOD_PREFIXES = ['add', 'get', 'has', 'remove'] as const;
-function formatMissingBindings(missing: readonly { name: string; methods: readonly string[] }[]): string {
- const detail = missing.map(m => ` - ${m.name}: missing ${m.methods.join(', ')}`).join('\n');
- return (
- `C++ Registry is missing ${String(missing.length)} builtin component binding(s):\n${detail}\n\n` +
- `Likely cause: WebBindings.generated.cpp is out of sync with component.generated.ts. ` +
- `Rerun the EHT generator and rebuild the WASM target.`
+function formatBridgeDiagnostic(v: BridgeVerification): string {
+ const parts: string[] = [];
+ if (v.missing.length > 0) {
+ const detail = v.missing.map(m => ` - ${m.name}: missing ${m.methods.join(', ')}`).join('\n');
+ parts.push(`C++ Registry is missing ${String(v.missing.length)} builtin component binding(s):\n${detail}`);
+ }
+ if (v.wasmOnly.length > 0) {
+ parts.push(`WASM exposes components not in the SDK's COMPONENT_META:\n ${v.wasmOnly.join(', ')}`);
+ }
+ if (v.sdkOnly.length > 0) {
+ parts.push(`SDK's COMPONENT_META lists components the WASM does not export:\n ${v.sdkOnly.join(', ')}`);
+ }
+ parts.push(
+ 'Likely cause: WebBindings.generated.cpp is out of sync with component.generated.ts. ' +
+ 'Rerun the EHT generator and rebuild the WASM target.',
);
+ return parts.join('\n\n');
}
// =============================================================================
@@ -235,12 +258,12 @@ export class BuiltinBridge {
this.builtinMethodCache_.clear();
this.builtinEntitySets_.clear();
- const verification = this.verifyAgainst_(cppRegistry);
+ const verification = this.verifyAgainst_(cppRegistry, module);
if (options.strict && !verification.ok) {
this.cppRegistry_ = null;
this.module_ = null;
this.builtinMethodCache_.clear();
- throw new Error(formatMissingBindings(verification.missing));
+ throw new Error(formatBridgeDiagnostic(verification));
}
}
@@ -268,11 +291,18 @@ export class BuiltinBridge {
* diagnostics and tests that want to inspect coverage.
*/
verify(): BridgeVerification {
- if (!this.cppRegistry_) return { ok: false, missing: [{ name: '<registry>', methods: ['connect() not called'] }] };
- return this.verifyAgainst_(this.cppRegistry_);
+ if (!this.cppRegistry_) {
+ return {
+ ok: false,
+ missing: [{ name: '<registry>', methods: ['connect() not called'] }],
+ wasmOnly: [],
+ sdkOnly: [],
+ };
+ }
+ return this.verifyAgainst_(this.cppRegistry_, this.module_ ?? undefined);
}
- private verifyAgainst_(reg: CppRegistry): BridgeVerification {
+ private verifyAgainst_(reg: CppRegistry, module?: ESEngineModule): BridgeVerification {
const missing: { name: string; methods: string[] }[] = [];
for (const cppName of Object.keys(COMPONENT_META)) {
const missingMethods: string[] = [];
@@ -286,7 +316,29 @@ export class BuiltinBridge {
}
this.resolveAndCache_(reg, cppName);
}
- return { ok: missing.length === 0, missing };
+
+ // Cross-check against the WASM module's self-reported component list
+ // (added in the EHT generator as `getBuiltinComponentNames`). Older
+ // WASM builds may not expose it — those skip this check.
+ let wasmOnly: string[] = [];
+ let sdkOnly: string[] = [];
+ const listFn = (module as unknown as { getBuiltinComponentNames?: () => string[] } | undefined)
+ ?.getBuiltinComponentNames;
+ if (typeof listFn === 'function') {
+ let wasmList: string[];
+ try {
+ wasmList = listFn();
+ } catch {
+ wasmList = [];
+ }
+ const sdkSet = new Set(Object.keys(COMPONENT_META));
+ const wasmSet = new Set(wasmList);
+ wasmOnly = wasmList.filter(n => !sdkSet.has(n));
+ sdkOnly = Object.keys(COMPONENT_META).filter(n => !wasmSet.has(n));
+ }
+
+ const ok = missing.length === 0 && wasmOnly.length === 0 && sdkOnly.length === 0;
+ return { ok, missing, wasmOnly, sdkOnly };
}
getBuiltinMethods(cppName: string): BuiltinMethods {
diff --git a/sdk/src/wasm.generated.ts b/sdk/src/wasm.generated.ts
index eb232d7fc..c7a0ab0b3 100644
--- a/sdk/src/wasm.generated.ts
+++ b/sdk/src/wasm.generated.ts
@@ -22,30 +22,53 @@ export interface VectorEntity {
// Enums
-export enum TextAlign {
- Left = 0,
- Center = 1,
- Right = 2,
+export enum AlignSelf {
+ Auto = 0,
+ Start = 1,
+ Center = 2,
+ End = 3,
+ Stretch = 4,
}
-export enum ProjectionType {
- Perspective = 0,
- Orthographic = 1,
+export enum EmitterShape {
+ Point = 0,
+ Circle = 1,
+ Rectangle = 2,
+ Cone = 3,
}
-export enum ClearFlags {
- Nothing = 0,
- Color = 1,
- Depth = 2,
- ColorAndDepth = 3,
+export enum SimulationSpace {
+ World = 0,
+ Local = 1,
}
-export enum CanvasScaleMode {
- FixedWidth = 0,
- FixedHeight = 1,
- Expand = 2,
- Shrink = 3,
- Match = 4,
+export enum UIVisualType {
+ None = 0,
+ SolidColor = 1,
+ Image = 2,
+ NineSlice = 3,
+}
+
+export enum GridDirection {
+ Vertical = 0,
+ Horizontal = 1,
+}
+
+export enum BodyType {
+ Static = 0,
+ Kinematic = 1,
+ Dynamic = 2,
+}
+
+export enum TextAlign {
+ Left = 0,
+ Center = 1,
+ Right = 2,
+}
+
+export enum MaskMode {
+ Scissor = 0,
+ Stencil = 1,
}
export enum FlexDirection {
@@ -85,81 +108,50 @@ export enum AlignContent {
SpaceAround = 5,
}
-export enum AlignSelf {
- Auto = 0,
- Start = 1,
- Center = 2,
- End = 3,
- Stretch = 4,
-}
-
-export enum GridDirection {
- Vertical = 0,
- Horizontal = 1,
-}
-
-export enum EmitterShape {
- Point = 0,
- Circle = 1,
- Rectangle = 2,
- Cone = 3,
-}
-
-export enum SimulationSpace {
- World = 0,
- Local = 1,
-}
-
-export enum BodyType {
- Static = 0,
- Kinematic = 1,
- Dynamic = 2,
+export enum CanvasScaleMode {
+ FixedWidth = 0,
+ FixedHeight = 1,
+ Expand = 2,
+ Shrink = 3,
+ Match = 4,
}
-export enum MaskMode {
- Scissor = 0,
- Stencil = 1,
+export enum ProjectionType {
+ Perspective = 0,
+ Orthographic = 1,
}
-export enum UIVisualType {
- None = 0,
- SolidColor = 1,
- Image = 2,
- NineSlice = 3,
+export enum ClearFlags {
+ Nothing = 0,
+ Color = 1,
+ Depth = 2,
+ ColorAndDepth = 3,
}
// Components
-export interface BitmapText {
- text: string;
- color: Vec4;
- fontSize: number;
- align: number;
- spacing: number;
- layer: number;
- font: number;
- enabled: boolean;
-}
-
-export interface Camera {
- projectionType: number;
- fov: number;
- orthoSize: number;
- nearPlane: number;
- farPlane: number;
- aspectRatio: number;
- isActive: boolean;
- priority: number;
- viewport: Vec4;
- clearFlags: number;
+export interface UIRect {
+ anchorMin: Vec2;
+ anchorMax: Vec2;
+ offsetMin: Vec2;
+ offsetMax: Vec2;
+ size: Vec2;
+ pivot: Vec2;
}
-export interface Canvas {
- designResolution: UVec2;
- pixelsPerUnit: number;
- scaleMode: number;
- matchWidthOrHeight: number;
- backgroundColor: Vec4;
+export interface FlexItem {
+ flexGrow: number;
+ flexShrink: number;
+ flexBasis: number;
+ order: number;
+ alignSelf: number;
+ margin: Padding;
+ minWidth: number;
+ minHeight: number;
+ maxWidth: number;
+ maxHeight: number;
+ widthPercent: number;
+ heightPercent: number;
}
export interface BoxCollider {
@@ -211,52 +203,6 @@ export interface SegmentCollider {
maskBits: number;
}
-export interface FlexContainer {
- direction: number;
- wrap: number;
- justifyContent: number;
- alignItems: number;
- alignContent: number;
- gap: Vec2;
- padding: Padding;
-}
-
-export interface FlexItem {
- flexGrow: number;
- flexShrink: number;
- flexBasis: number;
- order: number;
- alignSelf: number;
- margin: Padding;
- minWidth: number;
- minHeight: number;
- maxWidth: number;
- maxHeight: number;
- widthPercent: number;
- heightPercent: number;
-}
-
-export interface GridLayout {
- direction: number;
- crossAxisCount: number;
- itemSize: Vec2;
- spacing: Vec2;
-}
-
-export interface Parent {
- entity: number;
-}
-
-export interface Children {
- entities: VectorEntity;
-}
-
-export interface Interactable {
- enabled: boolean;
- blockRaycast: boolean;
- raycastTarget: boolean;
-}
-
export interface ParticleEmitter {
rate: number;
burstCount: number;
@@ -301,25 +247,38 @@ export interface ParticleEmitter {
enabled: boolean;
}
-export interface RigidBody {
- bodyType: number;
- gravityScale: number;
- linearDamping: number;
- angularDamping: number;
- fixedRotation: boolean;
- bullet: boolean;
- enabled: boolean;
+export interface Transform {
+ position: Vec3;
+ rotation: Quat;
+ scale: Vec3;
+ worldPosition: Vec3;
+ worldRotation: Quat;
+ worldScale: Vec3;
}
-export interface ShapeRenderer {
- shapeType: number;
+export interface UIRenderer {
+ visualType: number;
+ texture: number;
color: Vec4;
- size: Vec2;
- cornerRadius: number;
- layer: number;
+ uvOffset: Vec2;
+ uvScale: Vec2;
+ sliceBorder: Vec4;
+ material: number;
enabled: boolean;
}
+export interface GridLayout {
+ direction: number;
+ crossAxisCount: number;
+ itemSize: Vec2;
+ spacing: Vec2;
+}
+
+export interface Velocity {
+ linear: Vec3;
+ angular: Vec3;
+}
+
export interface SpineAnimation {
skeletonPath: string;
atlasPath: string;
@@ -337,25 +296,69 @@ export interface SpineAnimation {
enabled: boolean;
}
-export interface Sprite {
- texture: number;
- color: Vec4;
- size: Vec2;
- pivot: Vec2;
- uvOffset: Vec2;
- uvScale: Vec2;
- layer: number;
- flipX: boolean;
- flipY: boolean;
- tileSize: Vec2;
- tileSpacing: Vec2;
- material: number;
+export interface Interactable {
enabled: boolean;
+ blockRaycast: boolean;
+ raycastTarget: boolean;
}
-export interface StateMachine {
- current: string;
- previous: string;
+export interface UIInteraction {
+ hovered: boolean;
+ pressed: boolean;
+ justPressed: boolean;
+ justReleased: boolean;
+}
+
+export interface RigidBody {
+ bodyType: number;
+ gravityScale: number;
+ linearDamping: number;
+ angularDamping: number;
+ fixedRotation: boolean;
+ bullet: boolean;
+ enabled: boolean;
+}
+
+export interface BitmapText {
+ text: string;
+ color: Vec4;
+ fontSize: number;
+ align: number;
+ spacing: number;
+ layer: number;
+ font: number;
+ enabled: boolean;
+}
+
+export interface Sprite {
+ texture: number;
+ color: Vec4;
+ size: Vec2;
+ pivot: Vec2;
+ uvOffset: Vec2;
+ uvScale: Vec2;
+ layer: number;
+ flipX: boolean;
+ flipY: boolean;
+ tileSize: Vec2;
+ tileSpacing: Vec2;
+ material: number;
+ enabled: boolean;
+}
+
+export interface UIMask {
+ enabled: boolean;
+ mode: number;
+}
+
+export interface FlexContainer {
+ direction: number;
+ wrap: number;
+ justifyContent: number;
+ alignItems: number;
+ alignContent: number;
+ gap: Vec2;
+ padding: Padding;
}
export interface StateVisuals {
@@ -396,50 +399,47 @@ export interface StateVisuals {
slot7Scale: number;
}
-export interface Transform {
- position: Vec3;
- rotation: Quat;
- scale: Vec3;
- worldPosition: Vec3;
- worldRotation: Quat;
- worldScale: Vec3;
+export interface Parent {
+ entity: number;
}
-export interface UIInteraction {
- hovered: boolean;
- pressed: boolean;
- justPressed: boolean;
- justReleased: boolean;
+export interface Children {
+ entities: VectorEntity;
}
-export interface UIMask {
+export interface ShapeRenderer {
+ shapeType: number;
+ color: Vec4;
+ size: Vec2;
+ cornerRadius: number;
+ layer: number;
enabled: boolean;
- mode: number;
}
-export interface UIRect {
- anchorMin: Vec2;
- anchorMax: Vec2;
- offsetMin: Vec2;
- offsetMax: Vec2;
- size: Vec2;
- pivot: Vec2;
+export interface StateMachine {
+ current: string;
+ previous: string;
}
-export interface UIRenderer {
- visualType: number;
- texture: number;
- color: Vec4;
- uvOffset: Vec2;
- uvScale: Vec2;
- sliceBorder: Vec4;
- material: number;
- enabled: boolean;
+export interface Canvas {
+ designResolution: UVec2;
+ pixelsPerUnit: number;
+ scaleMode: number;
+ matchWidthOrHeight: number;
+ backgroundColor: Vec4;
}
-export interface Velocity {
- linear: Vec3;
- angular: Vec3;
+export interface Camera {
+ projectionType: number;
+ fov: number;
+ orthoSize: number;
+ nearPlane: number;
+ farPlane: number;
+ aspectRatio: number;
+ isActive: boolean;
+ priority: number;
+ viewport: Vec4;
+ clearFlags: number;
}
// Registry
@@ -449,18 +449,14 @@ export interface Registry {
valid(entity: Entity): boolean;
entityCount(): number;
- hasBitmapText(entity: Entity): boolean;
- getBitmapText(entity: Entity): BitmapText;
- addBitmapText(entity: Entity, component: BitmapText): void;
- removeBitmapText(entity: Entity): void;
- hasCamera(entity: Entity): boolean;
- getCamera(entity: Entity): Camera;
- addCamera(entity: Entity, component: Camera): void;
- removeCamera(entity: Entity): void;
- hasCanvas(entity: Entity): boolean;
- getCanvas(entity: Entity): Canvas;
- addCanvas(entity: Entity, component: Canvas): void;
- removeCanvas(entity: Entity): void;
+ hasUIRect(entity: Entity): boolean;
+ getUIRect(entity: Entity): UIRect;
+ addUIRect(entity: Entity, component: UIRect): void;
+ removeUIRect(entity: Entity): void;
+ hasFlexItem(entity: Entity): boolean;
+ getFlexItem(entity: Entity): FlexItem;
+ addFlexItem(entity: Entity, component: FlexItem): void;
+ removeFlexItem(entity: Entity): void;
hasBoxCollider(entity: Entity): boolean;
getBoxCollider(entity: Entity): BoxCollider;
addBoxCollider(entity: Entity, component: BoxCollider): void;
@@ -477,82 +473,86 @@ export interface Registry {
getSegmentCollider(entity: Entity): SegmentCollider;
addSegmentCollider(entity: Entity, component: SegmentCollider): void;
removeSegmentCollider(entity: Entity): void;
- hasFlexContainer(entity: Entity): boolean;
- getFlexContainer(entity: Entity): FlexContainer;
- addFlexContainer(entity: Entity, component: FlexContainer): void;
- removeFlexContainer(entity: Entity): void;
- hasFlexItem(entity: Entity): boolean;
- getFlexItem(entity: Entity): FlexItem;
- addFlexItem(entity: Entity, component: FlexItem): void;
- removeFlexItem(entity: Entity): void;
+ hasParticleEmitter(entity: Entity): boolean;
+ getParticleEmitter(entity: Entity): ParticleEmitter;
+ addParticleEmitter(entity: Entity, component: ParticleEmitter): void;
+ removeParticleEmitter(entity: Entity): void;
+ hasTransform(entity: Entity): boolean;
+ getTransform(entity: Entity): Transform;
+ addTransform(entity: Entity, component: Transform): void;
+ removeTransform(entity: Entity): void;
+ hasUIRenderer(entity: Entity): boolean;
+ getUIRenderer(entity: Entity): UIRenderer;
+ addUIRenderer(entity: Entity, component: UIRenderer): void;
+ removeUIRenderer(entity: Entity): void;
hasGridLayout(entity: Entity): boolean;
getGridLayout(entity: Entity): GridLayout;
addGridLayout(entity: Entity, component: GridLayout): void;
removeGridLayout(entity: Entity): void;
- hasParent(entity: Entity): boolean;
- getParent(entity: Entity): Parent;
- addParent(entity: Entity, component: Parent): void;
- removeParent(entity: Entity): void;
- hasChildren(entity: Entity): boolean;
- getChildren(entity: Entity): Children;
- addChildren(entity: Entity, component: Children): void;
- removeChildren(entity: Entity): void;
+ hasVelocity(entity: Entity): boolean;
+ getVelocity(entity: Entity): Velocity;
+ addVelocity(entity: Entity, component: Velocity): void;
+ removeVelocity(entity: Entity): void;
+ hasSpineAnimation(entity: Entity): boolean;
+ getSpineAnimation(entity: Entity): SpineAnimation;
+ addSpineAnimation(entity: Entity, component: SpineAnimation): void;
+ removeSpineAnimation(entity: Entity): void;
hasInteractable(entity: Entity): boolean;
getInteractable(entity: Entity): Interactable;
addInteractable(entity: Entity, component: Interactable): void;
removeInteractable(entity: Entity): void;
- hasParticleEmitter(entity: Entity): boolean;
- getParticleEmitter(entity: Entity): ParticleEmitter;
- addParticleEmitter(entity: Entity, component: ParticleEmitter): void;
- removeParticleEmitter(entity: Entity): void;
+ hasUIInteraction(entity: Entity): boolean;
+ getUIInteraction(entity: Entity): UIInteraction;
+ addUIInteraction(entity: Entity, component: UIInteraction): void;
+ removeUIInteraction(entity: Entity): void;
hasRigidBody(entity: Entity): boolean;
getRigidBody(entity: Entity): RigidBody;
addRigidBody(entity: Entity, component: RigidBody): void;
removeRigidBody(entity: Entity): void;
- hasShapeRenderer(entity: Entity): boolean;
- getShapeRenderer(entity: Entity): ShapeRenderer;
- addShapeRenderer(entity: Entity, component: ShapeRenderer): void;
- removeShapeRenderer(entity: Entity): void;
- hasSpineAnimation(entity: Entity): boolean;
- getSpineAnimation(entity: Entity): SpineAnimation;
- addSpineAnimation(entity: Entity, component: SpineAnimation): void;
- removeSpineAnimation(entity: Entity): void;
+ hasBitmapText(entity: Entity): boolean;
+ getBitmapText(entity: Entity): BitmapText;
+ addBitmapText(entity: Entity, component: BitmapText): void;
+ removeBitmapText(entity: Entity): void;
hasSprite(entity: Entity): boolean;
getSprite(entity: Entity): Sprite;
addSprite(entity: Entity, component: Sprite): void;
removeSprite(entity: Entity): void;
- hasStateMachine(entity: Entity): boolean;
- getStateMachine(entity: Entity): StateMachine;
- addStateMachine(entity: Entity, component: StateMachine): void;
- removeStateMachine(entity: Entity): void;
- hasStateVisuals(entity: Entity): boolean;
- getStateVisuals(entity: Entity): StateVisuals;
- addStateVisuals(entity: Entity, component: StateVisuals): void;
- removeStateVisuals(entity: Entity): void;
- hasTransform(entity: Entity): boolean;
- getTransform(entity: Entity): Transform;
- addTransform(entity: Entity, component: Transform): void;
- removeTransform(entity: Entity): void;
- hasUIInteraction(entity: Entity): boolean;
- getUIInteraction(entity: Entity): UIInteraction;
- addUIInteraction(entity: Entity, component: UIInteraction): void;
- removeUIInteraction(entity: Entity): void;
hasUIMask(entity: Entity): boolean;
getUIMask(entity: Entity): UIMask;
addUIMask(entity: Entity, component: UIMask): void;
removeUIMask(entity: Entity): void;
- hasUIRect(entity: Entity): boolean;
- getUIRect(entity: Entity): UIRect;
- addUIRect(entity: Entity, component: UIRect): void;
- removeUIRect(entity: Entity): void;
- hasUIRenderer(entity: Entity): boolean;
- getUIRenderer(entity: Entity): UIRenderer;
- addUIRenderer(entity: Entity, component: UIRenderer): void;
- removeUIRenderer(entity: Entity): void;
- hasVelocity(entity: Entity): boolean;
- getVelocity(entity: Entity): Velocity;
- addVelocity(entity: Entity, component: Velocity): void;
- removeVelocity(entity: Entity): void;
+ hasFlexContainer(entity: Entity): boolean;
+ getFlexContainer(entity: Entity): FlexContainer;
+ addFlexContainer(entity: Entity, component: FlexContainer): void;
+ removeFlexContainer(entity: Entity): void;
+ hasStateVisuals(entity: Entity): boolean;
+ getStateVisuals(entity: Entity): StateVisuals;
+ addStateVisuals(entity: Entity, component: StateVisuals): void;
+ removeStateVisuals(entity: Entity): void;
+ hasParent(entity: Entity): boolean;
+ getParent(entity: Entity): Parent;
+ addParent(entity: Entity, component: Parent): void;
+ removeParent(entity: Entity): void;
+ hasChildren(entity: Entity): boolean;
+ getChildren(entity: Entity): Children;
+ addChildren(entity: Entity, component: Children): void;
+ removeChildren(entity: Entity): void;
+ hasShapeRenderer(entity: Entity): boolean;
+ getShapeRenderer(entity: Entity): ShapeRenderer;
+ addShapeRenderer(entity: Entity, component: ShapeRenderer): void;
+ removeShapeRenderer(entity: Entity): void;
+ hasStateMachine(entity: Entity): boolean;
+ getStateMachine(entity: Entity): StateMachine;
+ addStateMachine(entity: Entity, component: StateMachine): void;
+ removeStateMachine(entity: Entity): void;
+ hasCanvas(entity: Entity): boolean;
+ getCanvas(entity: Entity): Canvas;
+ addCanvas(entity: Entity, component: Canvas): void;
+ removeCanvas(entity: Entity): void;
+ hasCamera(entity: Entity): boolean;
+ getCamera(entity: Entity): Camera;
+ addCamera(entity: Entity, component: Camera): void;
+ removeCamera(entity: Entity): void;
// Hierarchy Utilities
setParent(child: Entity, parent: Entity): void;
@@ -561,30 +561,36 @@ export interface Registry {
// Module
export interface ESEngineModule {
Registry: new () => Registry;
- BitmapText: new () => BitmapText;
- Camera: new () => Camera;
- Canvas: new () => Canvas;
+ /**
+ * Authoritative list of component names this WASM build exposes
+ * on the Registry. Used by BuiltinBridge to detect drift between
+ * the shipped SDK and the actual WASM module.
+ */
+ getBuiltinComponentNames(): string[];
+ UIRect: new () => UIRect;
+ FlexItem: new () => FlexItem;
BoxCollider: new () => BoxCollider;
CircleCollider: new () => CircleCollider;
CapsuleCollider: new () => CapsuleCollider;
SegmentCollider: new () => SegmentCollider;
- FlexContainer: new () => FlexContainer;
- FlexItem: new () => FlexItem;
+ ParticleEmitter: new () => ParticleEmitter;
+ Transform: new () => Transform;
+ UIRenderer: new () => UIRenderer;
GridLayout: new () => GridLayout;
- Parent: new () => Parent;
- Children: new () => Children;
+ Velocity: new () => Velocity;
+ SpineAnimation: new () => SpineAnimation;
Interactable: new () => Interactable;
- ParticleEmitter: new () => ParticleEmitter;
+ UIInteraction: new () => UIInteraction;
RigidBody: new () => RigidBody;
- ShapeRenderer: new () => ShapeRenderer;
- SpineAnimation: new () => SpineAnimation;
+ BitmapText: new () => BitmapText;
Sprite: new () => Sprite;
- StateMachine: new () => StateMachine;
- StateVisuals: new () => StateVisuals;
- Transform: new () => Transform;
- UIInteraction: new () => UIInteraction;
UIMask: new () => UIMask;
- UIRect: new () => UIRect;
- UIRenderer: new () => UIRenderer;
- Velocity: new () => Velocity;
+ FlexContainer: new () => FlexContainer;
+ StateVisuals: new () => StateVisuals;
+ Parent: new () => Parent;
+ Children: new () => Children;
+ ShapeRenderer: new () => ShapeRenderer;
+ StateMachine: new () => StateMachine;
+ Canvas: new () => Canvas;
+ Camera: new () => Camera;
}
diff --git a/sdk/tests/builtin-bridge.test.ts b/sdk/tests/builtin-bridge.test.ts
index ed2f90093..5bf12bd10 100644
--- a/sdk/tests/builtin-bridge.test.ts
+++ b/sdk/tests/builtin-bridge.test.ts
@@ -7,7 +7,7 @@
import { describe, expect, it } from 'vitest';
import { BuiltinBridge } from '../src/ecs/BuiltinBridge';
import { COMPONENT_META } from '../src/component.generated';
-import type { CppRegistry } from '../src/wasm';
+import type { CppRegistry, ESEngineModule } from '../src/wasm';
function stubMethod() { return undefined; }
@@ -114,4 +114,85 @@ describe('BuiltinBridge', () => {
const bridge = new BuiltinBridge();
expect(() => bridge.getBuiltinMethods('Transform')).toThrow(/before connect/);
});
+
+ // -------------------------------------------------------------------------
+ // Reflection-table drift detection (requires the WASM module to expose
+ // getBuiltinComponentNames() — absent on older builds; present on all
+ // builds produced by the current EHT generator).
+ // -------------------------------------------------------------------------
+
+ it('verify().ok is true when WASM reflection matches COMPONENT_META', () => {
+ const bridge = new BuiltinBridge();
+ const reg = makeCompleteRegistry() as unknown as CppRegistry;
+ const module = {
+ getBuiltinComponentNames: () => Object.keys(COMPONENT_META),
+ } as unknown as ESEngineModule;
+
+ bridge.connect(reg, module, { strict: true });
+ const v = bridge.verify();
+ expect(v.ok).toBe(true);
+ expect(v.wasmOnly).toEqual([]);
+ expect(v.sdkOnly).toEqual([]);
+ });
+
+ it('reports wasmOnly components when WASM exposes one the SDK does not know', () => {
+ const bridge = new BuiltinBridge();
+ const reg = makeCompleteRegistry();
+ // Add a hypothetical component the SDK hasn't heard of. The registry must
+ // expose its four methods too or strict verification of SDK components
+ // wouldn't be the source of the drift report.
+ for (const p of ['add', 'get', 'has', 'remove']) {
+ reg[`${p}FutureThing`] = stubMethod;
+ }
+ const module = {
+ getBuiltinComponentNames: () => [...Object.keys(COMPONENT_META), 'FutureThing'],
+ } as unknown as ESEngineModule;
+
+ const caught = (() => {
+ try {
+ bridge.connect(reg as unknown as CppRegistry, module, { strict: true });
+ return null;
+ } catch (e) { return e as Error; }
+ })();
+
+ expect(caught).not.toBeNull();
+ expect(caught!.message).toContain('WASM exposes components not in');
+ expect(caught!.message).toContain('FutureThing');
+ });
+
+ it('reports sdkOnly components when COMPONENT_META has one the WASM does not', () => {
+ const bridge = new BuiltinBridge();
+ const reg = makeCompleteRegistry() as unknown as CppRegistry;
+ const firstName = Object.keys(COMPONENT_META)[0];
+ if (!firstName) throw new Error('COMPONENT_META fixture is empty');
+ const module = {
+ // WASM reports everything except the first name.
+ getBuiltinComponentNames: () => Object.keys(COMPONENT_META).slice(1),
+ } as unknown as ESEngineModule;
+
+ const caught = (() => {
+ try {
+ bridge.connect(reg, module, { strict: true });
+ return null;
+ } catch (e) { return e as Error; }
+ })();
+
+ expect(caught).not.toBeNull();
+ expect(caught!.message).toContain('SDK\'s COMPONENT_META lists components the WASM does not');
+ expect(caught!.message).toContain(firstName);
+ });
+
+ it('skips reflection cross-check when the module lacks getBuiltinComponentNames', () => {
+ // Older WASM builds won't have the reflection export. The bridge must
+ // still connect successfully as long as method-level verification passes.
+ const bridge = new BuiltinBridge();
+ const reg = makeCompleteRegistry() as unknown as CppRegistry;
+ const module = {} as unknown as ESEngineModule;
+
+ expect(() => { bridge.connect(reg, module, { strict: true }); }).not.toThrow();
+ const v = bridge.verify();
+ expect(v.ok).toBe(true);
+ expect(v.wasmOnly).toEqual([]);
+ expect(v.sdkOnly).toEqual([]);
+ });
});
diff --git a/src/esengine/animation/animTargets.generated.hpp b/src/esengine/animation/animTargets.generated.hpp
index 8fd2fb363..6ad014b3c 100644
--- a/src/esengine/animation/animTargets.generated.hpp
+++ b/src/esengine/animation/animTargets.generated.hpp
@@ -2,12 +2,12 @@
#include "../core/Types.hpp"
#include "../ecs/Registry.hpp"
-#include "../ecs/components/BitmapText.hpp"
-#include "../ecs/components/Camera.hpp"
-#include "../ecs/components/Sprite.hpp"
-#include "../ecs/components/Transform.hpp"
#include "../ecs/components/UIRect.hpp"
+#include "../ecs/components/Transform.hpp"
#include "../ecs/components/UIRenderer.hpp"
+#include "../ecs/components/BitmapText.hpp"
+#include "../ecs/components/Sprite.hpp"
+#include "../ecs/components/Camera.hpp"
#include "../ecs/components/UIRect.hpp"
#include <glm/glm.hpp>
@@ -16,49 +16,49 @@
namespace esengine::animation {
enum class AnimTargetComponent : u8 {
- BitmapText = 0,
- Camera = 1,
- Sprite = 2,
- Transform = 3,
- UIRect = 4,
- UIRenderer = 5,
+ UIRect = 0,
+ Transform = 1,
+ UIRenderer = 2,
+ BitmapText = 3,
+ Sprite = 4,
+ Camera = 5,
Custom = 6,
COUNT
};
enum class AnimTargetField : u8 {
- BitmapTextColorR = 0,
- BitmapTextColorG = 1,
- BitmapTextColorB = 2,
- BitmapTextColorA = 3,
- CameraOrthoSize = 4,
- SpriteColorR = 5,
- SpriteColorG = 6,
- SpriteColorB = 7,
- SpriteColorA = 8,
- SpriteSizeX = 9,
- SpriteSizeY = 10,
- TransformPositionX = 11,
- TransformPositionY = 12,
- TransformPositionZ = 13,
- TransformRotationZ = 14,
- TransformScaleX = 15,
- TransformScaleY = 16,
- TransformScaleZ = 17,
- UIRectAnchorMinX = 18,
- UIRectAnchorMinY = 19,
- UIRectAnchorMaxX = 20,
- UIRectAnchorMaxY = 21,
- UIRectOffsetMinX = 22,
- UIRectOffsetMinY = 23,
- UIRectOffsetMaxX = 24,
- UIRectOffsetMaxY = 25,
- UIRectPivotX = 26,
- UIRectPivotY = 27,
- UIRendererColorR = 28,
- UIRendererColorG = 29,
- UIRendererColorB = 30,
- UIRendererColorA = 31,
+ UIRectAnchorMinX = 0,
+ UIRectAnchorMinY = 1,
+ UIRectAnchorMaxX = 2,
+ UIRectAnchorMaxY = 3,
+ UIRectOffsetMinX = 4,
+ UIRectOffsetMinY = 5,
+ UIRectOffsetMaxX = 6,
+ UIRectOffsetMaxY = 7,
+ UIRectPivotX = 8,
+ UIRectPivotY = 9,
+ TransformPositionX = 10,
+ TransformPositionY = 11,
+ TransformPositionZ = 12,
+ TransformRotationZ = 13,
+ TransformScaleX = 14,
+ TransformScaleY = 15,
+ TransformScaleZ = 16,
+ UIRendererColorR = 17,
+ UIRendererColorG = 18,
+ UIRendererColorB = 19,
+ UIRendererColorA = 20,
+ BitmapTextColorR = 21,
+ BitmapTextColorG = 22,
+ BitmapTextColorB = 23,
+ BitmapTextColorA = 24,
+ SpriteColorR = 25,
+ SpriteColorG = 26,
+ SpriteColorB = 27,
+ SpriteColorA = 28,
+ SpriteSizeX = 29,
+ SpriteSizeY = 30,
+ CameraOrthoSize = 31,
CustomField = 32,
COUNT
};
@@ -68,59 +68,54 @@ inline void applyAnimatedValue(
AnimTargetField field, f32 value)
{
switch (field) {
- case AnimTargetField::BitmapTextColorR:
- if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
- c->color.r = value;
- }
- break;
- case AnimTargetField::BitmapTextColorG:
- if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
- c->color.g = value;
+ case AnimTargetField::UIRectAnchorMinX:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->anchorMin.x = value;
}
break;
- case AnimTargetField::BitmapTextColorB:
- if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
- c->color.b = value;
+ case AnimTargetField::UIRectAnchorMinY:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->anchorMin.y = value;
}
break;
- case AnimTargetField::BitmapTextColorA:
- if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
- c->color.a = value;
+ case AnimTargetField::UIRectAnchorMaxX:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->anchorMax.x = value;
}
break;
- case AnimTargetField::CameraOrthoSize:
- if (auto* c = registry.tryGet<ecs::Camera>(entity)) {
- c->orthoSize = value;
+ case AnimTargetField::UIRectAnchorMaxY:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->anchorMax.y = value;
}
break;
- case AnimTargetField::SpriteColorR:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->color.r = value;
+ case AnimTargetField::UIRectOffsetMinX:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->offsetMin.x = value;
}
break;
- case AnimTargetField::SpriteColorG:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->color.g = value;
+ case AnimTargetField::UIRectOffsetMinY:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->offsetMin.y = value;
}
break;
- case AnimTargetField::SpriteColorB:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->color.b = value;
+ case AnimTargetField::UIRectOffsetMaxX:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->offsetMax.x = value;
}
break;
- case AnimTargetField::SpriteColorA:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->color.a = value;
+ case AnimTargetField::UIRectOffsetMaxY:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->offsetMax.y = value;
}
break;
- case AnimTargetField::SpriteSizeX:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->size.x = value;
+ case AnimTargetField::UIRectPivotX:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->pivot.x = value;
}
break;
- case AnimTargetField::SpriteSizeY:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->size.y = value;
+ case AnimTargetField::UIRectPivotY:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->pivot.y = value;
}
break;
case AnimTargetField::TransformPositionX:
@@ -164,76 +159,81 @@ inline void applyAnimatedValue(
c->scale.z = value;
}
break;
- case AnimTargetField::UIRectAnchorMinX:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->anchorMin.x = value;
- }
- break;
- case AnimTargetField::UIRectAnchorMinY:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->anchorMin.y = value;
- }
- break;
- case AnimTargetField::UIRectAnchorMaxX:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->anchorMax.x = value;
+ case AnimTargetField::UIRendererColorR:
+ if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ c->color.r = value;
}
break;
- case AnimTargetField::UIRectAnchorMaxY:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->anchorMax.y = value;
+ case AnimTargetField::UIRendererColorG:
+ if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ c->color.g = value;
}
break;
- case AnimTargetField::UIRectOffsetMinX:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->offsetMin.x = value;
+ case AnimTargetField::UIRendererColorB:
+ if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ c->color.b = value;
}
break;
- case AnimTargetField::UIRectOffsetMinY:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->offsetMin.y = value;
+ case AnimTargetField::UIRendererColorA:
+ if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ c->color.a = value;
}
break;
- case AnimTargetField::UIRectOffsetMaxX:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->offsetMax.x = value;
+ case AnimTargetField::BitmapTextColorR:
+ if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
+ c->color.r = value;
}
break;
- case AnimTargetField::UIRectOffsetMaxY:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->offsetMax.y = value;
+ case AnimTargetField::BitmapTextColorG:
+ if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
+ c->color.g = value;
}
break;
- case AnimTargetField::UIRectPivotX:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->pivot.x = value;
+ case AnimTargetField::BitmapTextColorB:
+ if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
+ c->color.b = value;
}
break;
- case AnimTargetField::UIRectPivotY:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->pivot.y = value;
+ case AnimTargetField::BitmapTextColorA:
+ if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
+ c->color.a = value;
}
break;
- case AnimTargetField::UIRendererColorR:
- if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ case AnimTargetField::SpriteColorR:
+ if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
c->color.r = value;
}
break;
- case AnimTargetField::UIRendererColorG:
- if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ case AnimTargetField::SpriteColorG:
+ if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
c->color.g = value;
}
break;
- case AnimTargetField::UIRendererColorB:
- if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ case AnimTargetField::SpriteColorB:
+ if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
c->color.b = value;
}
break;
- case AnimTargetField::UIRendererColorA:
- if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ case AnimTargetField::SpriteColorA:
+ if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
c->color.a = value;
}
break;
+ case AnimTargetField::SpriteSizeX:
+ if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
+ c->size.x = value;
+ }
+ break;
+ case AnimTargetField::SpriteSizeY:
+ if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
+ c->size.y = value;
+ }
+ break;
+ case AnimTargetField::CameraOrthoSize:
+ if (auto* c = registry.tryGet<ecs::Camera>(entity)) {
+ c->orthoSize = value;
+ }
+ break;
case AnimTargetField::CustomField:
default:
break;
diff --git a/src/esengine/bindings/EditorAPI.generated.cpp b/src/esengine/bindings/EditorAPI.generated.cpp
index 8fa4bbd81..6ea5dbfa7 100644
--- a/src/esengine/bindings/EditorAPI.generated.cpp
+++ b/src/esengine/bindings/EditorAPI.generated.cpp
@@ -51,79 +51,70 @@ inline glm::quat eulerDegToQuat(const glm::vec3& deg) {
std::vector<std::string> editor_getComponentNames() {
return {
- "BitmapText",
- "Camera",
- "Canvas",
+ "UIRect",
+ "FlexItem",
"BoxCollider",
"CircleCollider",
"CapsuleCollider",
"SegmentCollider",
- "FlexContainer",
- "FlexItem",
+ "ParticleEmitter",
+ "Transform",
+ "UIRenderer",
"GridLayout",
- "Parent",
- "Children",
+ "Velocity",
+ "SpineAnimation",
"Interactable",
- "ParticleEmitter",
+ "UIInteraction",
"RigidBody",
- "ShapeRenderer",
- "SpineAnimation",
+ "BitmapText",
"Sprite",
- "StateMachine",
- "StateVisuals",
- "Transform",
- "UIInteraction",
"UIMask",
- "UIRect",
- "UIRenderer",
- "Velocity",
+ "FlexContainer",
+ "StateVisuals",
+ "Parent",
+ "Children",
+ "ShapeRenderer",
+ "StateMachine",
+ "Canvas",
+ "Camera",
};
}
// ── Component Schema (JSON) ──
std::string editor_getComponentSchema(const std::string& name) {
- if (name == "BitmapText") {
- return R"JSON([
- {"key":"text","type":"string","group":"BitmapText"},
- {"key":"color.r","type":"color","group":"BitmapText"},
- {"key":"color.g","type":"color","group":"BitmapText"},
- {"key":"color.b","type":"color","group":"BitmapText"},
- {"key":"color.a","type":"color","group":"BitmapText"},
- {"key":"fontSize","type":"float","group":"BitmapText"},
- {"key":"align","type":"enum","group":"BitmapText","values":["Left","Center","Right"]},
- {"key":"spacing","type":"float","group":"BitmapText"},
- {"key":"layer","type":"int","group":"BitmapText"},
- {"key":"font","type":"asset","group":"BitmapText"},
- {"key":"enabled","type":"bool","group":"BitmapText"}
- ])JSON";
- } else if (name == "Camera") {
+ if (name == "UIRect") {
return R"JSON([
- {"key":"projectionType","type":"enum","group":"Camera","values":["Perspective","Orthographic"]},
- {"key":"fov","type":"float","group":"Camera"},
- {"key":"orthoSize","type":"float","group":"Camera"},
- {"key":"nearPlane","type":"float","group":"Camera"},
- {"key":"farPlane","type":"float","group":"Camera"},
- {"key":"aspectRatio","type":"float","group":"Camera"},
- {"key":"isActive","type":"bool","group":"Camera"},
- {"key":"priority","type":"int","group":"Camera"},
- {"key":"viewport.x","type":"float","group":"Camera"},
- {"key":"viewport.y","type":"float","group":"Camera"},
- {"key":"viewport.z","type":"float","group":"Camera"},
- {"key":"viewport.w","type":"float","group":"Camera"},
- {"key":"clearFlags","type":"enum","group":"Camera","values":["Nothing","Color","Depth","ColorAndDepth"]}
+ {"key":"anchorMin.x","type":"float","group":"UIRect"},
+ {"key":"anchorMin.y","type":"float","group":"UIRect"},
+ {"key":"anchorMax.x","type":"float","group":"UIRect"},
+ {"key":"anchorMax.y","type":"float","group":"UIRect"},
+ {"key":"offsetMin.x","type":"float","group":"UIRect"},
+ {"key":"offsetMin.y","type":"float","group":"UIRect"},
+ {"key":"offsetMax.x","type":"float","group":"UIRect"},
+ {"key":"offsetMax.y","type":"float","group":"UIRect"},
+ {"key":"size.x","type":"float","group":"UIRect"},
+ {"key":"size.y","type":"float","group":"UIRect"},
+ {"key":"pivot.x","type":"float","group":"UIRect"},
+ {"key":"pivot.y","type":"float","group":"UIRect"}
])JSON";
- } else if (name == "Canvas") {
+ } else if (name == "FlexItem") {
return R"JSON([
- {"key":"designResolution.x","type":"int","group":"Canvas"},
- {"key":"designResolution.y","type":"int","group":"Canvas"},
- {"key":"pixelsPerUnit","type":"float","group":"Canvas"},
- {"key":"scaleMode","type":"enum","group":"Canvas","values":["FixedWidth","FixedHeight","Expand","Shrink","Match"]},
- {"key":"matchWidthOrHeight","type":"float","group":"Canvas"},
- {"key":"backgroundColor.r","type":"color","group":"Canvas"},
- {"key":"backgroundColor.g","type":"color","group":"Canvas"},
- {"key":"backgroundColor.b","type":"color","group":"Canvas"},
- {"key":"backgroundColor.a","type":"color","group":"Canvas"}
+ {"key":"flexGrow","type":"float","group":"FlexItem"},
+ {"key":"flexShrink","type":"float","group":"FlexItem"},
+ {"key":"flexBasis","type":"float","group":"FlexItem"},
+ {"key":"order","type":"int","group":"FlexItem"},
+ {"key":"alignSelf","type":"enum","group":"FlexItem","values":["Auto","Start","Center","End","Stretch"]},
+ {"key":"margin.left","type":"float","group":"FlexItem"},
+ {"key":"margin.top","type":"float","group":"FlexItem"},
+ {"key":"margin.right","type":"float","group":"FlexItem"},
+ {"key":"margin.bottom","type":"float","group":"FlexItem"},
+ {"key":"minWidth","type":"float","group":"FlexItem"},
+ {"key":"minHeight","type":"float","group":"FlexItem"},
+ {"key":"maxWidth","type":"float","group":"FlexItem"},
+ {"key":"maxHeight","type":"float","group":"FlexItem"},
+ {"key":"widthPercent","type":"float","group":"FlexItem"},
+ {"key":"heightPercent","type":"float","group":"FlexItem"}
])JSON";
} else if (name == "BoxCollider") {
return R"JSON([
@@ -180,61 +171,6 @@ std::string editor_getComponentSchema(const std::string& name) {
{"key":"categoryBits","type":"int","group":"SegmentCollider"},
{"key":"maskBits","type":"int","group":"SegmentCollider"}
])JSON";
- } else if (name == "FlexContainer") {
- return R"JSON([
- {"key":"direction","type":"enum","group":"FlexContainer","values":["Row","Column","RowReverse","ColumnReverse"]},
- {"key":"wrap","type":"enum","group":"FlexContainer","values":["NoWrap","Wrap"]},
- {"key":"justifyContent","type":"enum","group":"FlexContainer","values":["Start","Center","End","SpaceBetween","SpaceAround","SpaceEvenly"]},
- {"key":"alignItems","type":"enum","group":"FlexContainer","values":["Start","Center","End","Stretch"]},
- {"key":"alignContent","type":"enum","group":"FlexContainer","values":["Start","Center","End","Stretch","SpaceBetween","SpaceAround"]},
- {"key":"gap.x","type":"float","group":"FlexContainer"},
- {"key":"gap.y","type":"float","group":"FlexContainer"},
- {"key":"padding.left","type":"float","group":"FlexContainer"},
- {"key":"padding.top","type":"float","group":"FlexContainer"},
- {"key":"padding.right","type":"float","group":"FlexContainer"},
- {"key":"padding.bottom","type":"float","group":"FlexContainer"}
- ])JSON";
- } else if (name == "FlexItem") {
- return R"JSON([
- {"key":"flexGrow","type":"float","group":"FlexItem"},
- {"key":"flexShrink","type":"float","group":"FlexItem"},
- {"key":"flexBasis","type":"float","group":"FlexItem"},
- {"key":"order","type":"int","group":"FlexItem"},
- {"key":"alignSelf","type":"enum","group":"FlexItem","values":["Auto","Start","Center","End","Stretch"]},
- {"key":"margin.left","type":"float","group":"FlexItem"},
- {"key":"margin.top","type":"float","group":"FlexItem"},
- {"key":"margin.right","type":"float","group":"FlexItem"},
- {"key":"margin.bottom","type":"float","group":"FlexItem"},
- {"key":"minWidth","type":"float","group":"FlexItem"},
- {"key":"minHeight","type":"float","group":"FlexItem"},
- {"key":"maxWidth","type":"float","group":"FlexItem"},
- {"key":"maxHeight","type":"float","group":"FlexItem"},
- {"key":"widthPercent","type":"float","group":"FlexItem"},
- {"key":"heightPercent","type":"float","group":"FlexItem"}
- ])JSON";
- } else if (name == "GridLayout") {
- return R"JSON([
- {"key":"direction","type":"enum","group":"GridLayout","values":["Vertical","Horizontal"]},
- {"key":"crossAxisCount","type":"int","group":"GridLayout"},
- {"key":"itemSize.x","type":"float","group":"GridLayout"},
- {"key":"itemSize.y","type":"float","group":"GridLayout"},
- {"key":"spacing.x","type":"float","group":"GridLayout"},
- {"key":"spacing.y","type":"float","group":"GridLayout"}
- ])JSON";
- } else if (name == "Parent") {
- return R"JSON([
- {"key":"entity","type":"entity","group":"Parent"}
- ])JSON";
- } else if (name == "Children") {
- return R"JSON([
- {"key":"entities","type":"entity","group":"Children"}
- ])JSON";
- } else if (name == "Interactable") {
- return R"JSON([
- {"key":"enabled","type":"bool","group":"Interactable"},
- {"key":"blockRaycast","type":"bool","group":"Interactable"},
- {"key":"raycastTarget","type":"bool","group":"Interactable"}
- ])JSON";
} else if (name == "ParticleEmitter") {
return R"JSON([
{"key":"rate","type":"float","group":"ParticleEmitter"},
@@ -287,28 +223,54 @@ std::string editor_getComponentSchema(const std::string& name) {
{"key":"simulationSpace","type":"int","group":"ParticleEmitter"},
{"key":"enabled","type":"bool","group":"ParticleEmitter"}
])JSON";
- } else if (name == "RigidBody") {
+ } else if (name == "Transform") {
return R"JSON([
- {"key":"bodyType","type":"enum","group":"RigidBody","values":["Static","Kinematic","Dynamic"]},
- {"key":"gravityScale","type":"float","group":"RigidBody"},
- {"key":"linearDamping","type":"float","group":"RigidBody"},
- {"key":"angularDamping","type":"float","group":"RigidBody"},
- {"key":"fixedRotation","type":"bool","group":"RigidBody"},
- {"key":"bullet","type":"bool","group":"RigidBody"},
- {"key":"enabled","type":"bool","group":"RigidBody"}
+ {"key":"position.x","type":"float","group":"Transform"},
+ {"key":"position.y","type":"float","group":"Transform"},
+ {"key":"position.z","type":"float","group":"Transform"},
+ {"key":"rotation.x","type":"float","group":"Transform"},
+ {"key":"rotation.y","type":"float","group":"Transform"},
+ {"key":"rotation.z","type":"float","group":"Transform"},
+ {"key":"scale.x","type":"float","group":"Transform"},
+ {"key":"scale.y","type":"float","group":"Transform"},
+ {"key":"scale.z","type":"float","group":"Transform"}
])JSON";
- } else if (name == "ShapeRenderer") {
+ } else if (name == "UIRenderer") {
return R"JSON([
- {"key":"shapeType","type":"int","group":"ShapeRenderer"},
- {"key":"color.r","type":"color","group":"ShapeRenderer"},
- {"key":"color.g","type":"color","group":"ShapeRenderer"},
- {"key":"color.b","type":"color","group":"ShapeRenderer"},
- {"key":"color.a","type":"color","group":"ShapeRenderer"},
- {"key":"size.x","type":"float","group":"ShapeRenderer"},
- {"key":"size.y","type":"float","group":"ShapeRenderer"},
- {"key":"cornerRadius","type":"float","group":"ShapeRenderer"},
- {"key":"layer","type":"int","group":"ShapeRenderer"},
- {"key":"enabled","type":"bool","group":"ShapeRenderer"}
+ {"key":"visualType","type":"enum","group":"UIRenderer","values":["None","SolidColor","Image","NineSlice"]},
+ {"key":"texture","type":"asset","group":"UIRenderer"},
+ {"key":"color.r","type":"color","group":"UIRenderer"},
+ {"key":"color.g","type":"color","group":"UIRenderer"},
+ {"key":"color.b","type":"color","group":"UIRenderer"},
+ {"key":"color.a","type":"color","group":"UIRenderer"},
+ {"key":"uvOffset.x","type":"float","group":"UIRenderer"},
+ {"key":"uvOffset.y","type":"float","group":"UIRenderer"},
+ {"key":"uvScale.x","type":"float","group":"UIRenderer"},
+ {"key":"uvScale.y","type":"float","group":"UIRenderer"},
+ {"key":"sliceBorder.x","type":"float","group":"UIRenderer"},
+ {"key":"sliceBorder.y","type":"float","group":"UIRenderer"},
+ {"key":"sliceBorder.z","type":"float","group":"UIRenderer"},
+ {"key":"sliceBorder.w","type":"float","group":"UIRenderer"},
+ {"key":"material","type":"asset","group":"UIRenderer"},
+ {"key":"enabled","type":"bool","group":"UIRenderer"}
+ ])JSON";
+ } else if (name == "GridLayout") {
+ return R"JSON([
+ {"key":"direction","type":"enum","group":"GridLayout","values":["Vertical","Horizontal"]},
+ {"key":"crossAxisCount","type":"int","group":"GridLayout"},
+ {"key":"itemSize.x","type":"float","group":"GridLayout"},
+ {"key":"itemSize.y","type":"float","group":"GridLayout"},
+ {"key":"spacing.x","type":"float","group":"GridLayout"},
+ {"key":"spacing.y","type":"float","group":"GridLayout"}
+ ])JSON";
+ } else if (name == "Velocity") {
+ return R"JSON([
+ {"key":"linear.x","type":"float","group":"Velocity"},
+ {"key":"linear.y","type":"float","group":"Velocity"},
+ {"key":"linear.z","type":"float","group":"Velocity"},
+ {"key":"angular.x","type":"float","group":"Velocity"},
+ {"key":"angular.y","type":"float","group":"Velocity"},
+ {"key":"angular.z","type":"float","group":"Velocity"}
])JSON";
} else if (name == "SpineAnimation") {
return R"JSON([
@@ -330,6 +292,43 @@ std::string editor_getComponentSchema(const std::string& name) {
{"key":"material","type":"asset","group":"SpineAnimation"},
{"key":"enabled","type":"bool","group":"SpineAnimation"}
])JSON";
+ } else if (name == "Interactable") {
+ return R"JSON([
+ {"key":"enabled","type":"bool","group":"Interactable"},
+ {"key":"blockRaycast","type":"bool","group":"Interactable"},
+ {"key":"raycastTarget","type":"bool","group":"Interactable"}
+ ])JSON";
+ } else if (name == "UIInteraction") {
+ return R"JSON([
+ {"key":"hovered","type":"bool","group":"UIInteraction"},
+ {"key":"pressed","type":"bool","group":"UIInteraction"},
+ {"key":"justPressed","type":"bool","group":"UIInteraction"},
+ {"key":"justReleased","type":"bool","group":"UIInteraction"}
+ ])JSON";
+ } else if (name == "RigidBody") {
+ return R"JSON([
+ {"key":"bodyType","type":"enum","group":"RigidBody","values":["Static","Kinematic","Dynamic"]},
+ {"key":"gravityScale","type":"float","group":"RigidBody"},
+ {"key":"linearDamping","type":"float","group":"RigidBody"},
+ {"key":"angularDamping","type":"float","group":"RigidBody"},
+ {"key":"fixedRotation","type":"bool","group":"RigidBody"},
+ {"key":"bullet","type":"bool","group":"RigidBody"},
+ {"key":"enabled","type":"bool","group":"RigidBody"}
+ ])JSON";
+ } else if (name == "BitmapText") {
+ return R"JSON([
+ {"key":"text","type":"string","group":"BitmapText"},
+ {"key":"color.r","type":"color","group":"BitmapText"},
+ {"key":"color.g","type":"color","group":"BitmapText"},
+ {"key":"color.b","type":"color","group":"BitmapText"},
+ {"key":"color.a","type":"color","group":"BitmapText"},
+ {"key":"fontSize","type":"float","group":"BitmapText"},
+ {"key":"align","type":"enum","group":"BitmapText","values":["Left","Center","Right"]},
+ {"key":"spacing","type":"float","group":"BitmapText"},
+ {"key":"layer","type":"int","group":"BitmapText"},
+ {"key":"font","type":"asset","group":"BitmapText"},
+ {"key":"enabled","type":"bool","group":"BitmapText"}
+ ])JSON";
} else if (name == "Sprite") {
return R"JSON([
{"key":"texture","type":"asset","group":"Sprite"},
@@ -355,10 +354,24 @@ std::string editor_getComponentSchema(const std::string& name) {
{"key":"material","type":"asset","group":"Sprite"},
{"key":"enabled","type":"bool","group":"Sprite"}
])JSON";
- } else if (name == "StateMachine") {
+ } else if (name == "UIMask") {
return R"JSON([
- {"key":"current","type":"string","group":"StateMachine"},
- {"key":"previous","type":"string","group":"StateMachine"}
+ {"key":"enabled","type":"bool","group":"UIMask"},
+ {"key":"mode","type":"enum","group":"UIMask","values":["Scissor","Stencil"]}
+ ])JSON";
+ } else if (name == "FlexContainer") {
+ return R"JSON([
+ {"key":"direction","type":"enum","group":"FlexContainer","values":["Row","Column","RowReverse","ColumnReverse"]},
+ {"key":"wrap","type":"enum","group":"FlexContainer","values":["NoWrap","Wrap"]},
+ {"key":"justifyContent","type":"enum","group":"FlexContainer","values":["Start","Center","End","SpaceBetween","SpaceAround","SpaceEvenly"]},
+ {"key":"alignItems","type":"enum","group":"FlexContainer","values":["Start","Center","End","Stretch"]},
+ {"key":"alignContent","type":"enum","group":"FlexContainer","values":["Start","Center","End","Stretch","SpaceBetween","SpaceAround"]},
+ {"key":"gap.x","type":"float","group":"FlexContainer"},
+ {"key":"gap.y","type":"float","group":"FlexContainer"},
+ {"key":"padding.left","type":"float","group":"FlexContainer"},
+ {"key":"padding.top","type":"float","group":"FlexContainer"},
+ {"key":"padding.right","type":"float","group":"FlexContainer"},
+ {"key":"padding.bottom","type":"float","group":"FlexContainer"}
])JSON";
} else if (name == "StateVisuals") {
return R"JSON([
@@ -422,72 +435,59 @@ std::string editor_getComponentSchema(const std::string& name) {
{"key":"slot7Sprite","type":"asset","group":"StateVisuals"},
{"key":"slot7Scale","type":"float","group":"StateVisuals"}
])JSON";
- } else if (name == "Transform") {
+ } else if (name == "Parent") {
return R"JSON([
- {"key":"position.x","type":"float","group":"Transform"},
- {"key":"position.y","type":"float","group":"Transform"},
- {"key":"position.z","type":"float","group":"Transform"},
- {"key":"rotation.x","type":"float","group":"Transform"},
- {"key":"rotation.y","type":"float","group":"Transform"},
- {"key":"rotation.z","type":"float","group":"Transform"},
- {"key":"scale.x","type":"float","group":"Transform"},
- {"key":"scale.y","type":"float","group":"Transform"},
- {"key":"scale.z","type":"float","group":"Transform"}
+ {"key":"entity","type":"entity","group":"Parent"}
])JSON";
- } else if (name == "UIInteraction") {
+ } else if (name == "Children") {
return R"JSON([
- {"key":"hovered","type":"bool","group":"UIInteraction"},
- {"key":"pressed","type":"bool","group":"UIInteraction"},
- {"key":"justPressed","type":"bool","group":"UIInteraction"},
- {"key":"justReleased","type":"bool","group":"UIInteraction"}
+ {"key":"entities","type":"entity","group":"Children"}
])JSON";
- } else if (name == "UIMask") {
+ } else if (name == "ShapeRenderer") {
return R"JSON([
- {"key":"enabled","type":"bool","group":"UIMask"},
- {"key":"mode","type":"enum","group":"UIMask","values":["Scissor","Stencil"]}
+ {"key":"shapeType","type":"int","group":"ShapeRenderer"},
+ {"key":"color.r","type":"color","group":"ShapeRenderer"},
+ {"key":"color.g","type":"color","group":"ShapeRenderer"},
+ {"key":"color.b","type":"color","group":"ShapeRenderer"},
+ {"key":"color.a","type":"color","group":"ShapeRenderer"},
+ {"key":"size.x","type":"float","group":"ShapeRenderer"},
+ {"key":"size.y","type":"float","group":"ShapeRenderer"},
+ {"key":"cornerRadius","type":"float","group":"ShapeRenderer"},
+ {"key":"layer","type":"int","group":"ShapeRenderer"},
+ {"key":"enabled","type":"bool","group":"ShapeRenderer"}
])JSON";
- } else if (name == "UIRect") {
+ } else if (name == "StateMachine") {
return R"JSON([
- {"key":"anchorMin.x","type":"float","group":"UIRect"},
- {"key":"anchorMin.y","type":"float","group":"UIRect"},
- {"key":"anchorMax.x","type":"float","group":"UIRect"},
- {"key":"anchorMax.y","type":"float","group":"UIRect"},
- {"key":"offsetMin.x","type":"float","group":"UIRect"},
- {"key":"offsetMin.y","type":"float","group":"UIRect"},
- {"key":"offsetMax.x","type":"float","group":"UIRect"},
- {"key":"offsetMax.y","type":"float","group":"UIRect"},
- {"key":"size.x","type":"float","group":"UIRect"},
- {"key":"size.y","type":"float","group":"UIRect"},
- {"key":"pivot.x","type":"float","group":"UIRect"},
- {"key":"pivot.y","type":"float","group":"UIRect"}
+ {"key":"current","type":"string","group":"StateMachine"},
+ {"key":"previous","type":"string","group":"StateMachine"}
])JSON";
- } else if (name == "UIRenderer") {
+ } else if (name == "Canvas") {
return R"JSON([
- {"key":"visualType","type":"enum","group":"UIRenderer","values":["None","SolidColor","Image","NineSlice"]},
- {"key":"texture","type":"asset","group":"UIRenderer"},
- {"key":"color.r","type":"color","group":"UIRenderer"},
- {"key":"color.g","type":"color","group":"UIRenderer"},
- {"key":"color.b","type":"color","group":"UIRenderer"},
- {"key":"color.a","type":"color","group":"UIRenderer"},
- {"key":"uvOffset.x","type":"float","group":"UIRenderer"},
- {"key":"uvOffset.y","type":"float","group":"UIRenderer"},
- {"key":"uvScale.x","type":"float","group":"UIRenderer"},
- {"key":"uvScale.y","type":"float","group":"UIRenderer"},
- {"key":"sliceBorder.x","type":"float","group":"UIRenderer"},
- {"key":"sliceBorder.y","type":"float","group":"UIRenderer"},
- {"key":"sliceBorder.z","type":"float","group":"UIRenderer"},
- {"key":"sliceBorder.w","type":"float","group":"UIRenderer"},
- {"key":"material","type":"asset","group":"UIRenderer"},
- {"key":"enabled","type":"bool","group":"UIRenderer"}
+ {"key":"designResolution.x","type":"int","group":"Canvas"},
+ {"key":"designResolution.y","type":"int","group":"Canvas"},
+ {"key":"pixelsPerUnit","type":"float","group":"Canvas"},
+ {"key":"scaleMode","type":"enum","group":"Canvas","values":["FixedWidth","FixedHeight","Expand","Shrink","Match"]},
+ {"key":"matchWidthOrHeight","type":"float","group":"Canvas"},
+ {"key":"backgroundColor.r","type":"color","group":"Canvas"},
+ {"key":"backgroundColor.g","type":"color","group":"Canvas"},
+ {"key":"backgroundColor.b","type":"color","group":"Canvas"},
+ {"key":"backgroundColor.a","type":"color","group":"Canvas"}
])JSON";
- } else if (name == "Velocity") {
+ } else if (name == "Camera") {
return R"JSON([
- {"key":"linear.x","type":"float","group":"Velocity"},
- {"key":"linear.y","type":"float","group":"Velocity"},
- {"key":"linear.z","type":"float","group":"Velocity"},
- {"key":"angular.x","type":"float","group":"Velocity"},
- {"key":"angular.y","type":"float","group":"Velocity"},
- {"key":"angular.z","type":"float","group":"Velocity"}
+ {"key":"projectionType","type":"enum","group":"Camera","values":["Perspective","Orthographic"]},
+ {"key":"fov","type":"float","group":"Camera"},
+ {"key":"orthoSize","type":"float","group":"Camera"},
+ {"key":"nearPlane","type":"float","group":"Camera"},
+ {"key":"farPlane","type":"float","group":"Camera"},
+ {"key":"aspectRatio","type":"float","group":"Camera"},
+ {"key":"isActive","type":"bool","group":"Camera"},
+ {"key":"priority","type":"int","group":"Camera"},
+ {"key":"viewport.x","type":"float","group":"Camera"},
+ {"key":"viewport.y","type":"float","group":"Camera"},
+ {"key":"viewport.z","type":"float","group":"Camera"},
+ {"key":"viewport.w","type":"float","group":"Camera"},
+ {"key":"clearFlags","type":"enum","group":"Camera","values":["Nothing","Color","Depth","ColorAndDepth"]}
])JSON";
}
return "[]";
@@ -498,14 +498,11 @@ std::string editor_getComponentSchema(const std::string& name) {
bool editor_addComponent(Registry& reg, u32 e, const std::string& name) {
auto entity = static_cast<Entity>(e);
if (!reg.valid(entity)) return false;
- if (name == "BitmapText") {
- if (!reg.has<esengine::ecs::BitmapText>(entity)) reg.emplace<esengine::ecs::BitmapText>(entity);
- return true;
- } else if (name == "Camera") {
- if (!reg.has<esengine::ecs::Camera>(entity)) reg.emplace<esengine::ecs::Camera>(entity);
+ if (name == "UIRect") {
+ if (!reg.has<esengine::ecs::UIRect>(entity)) reg.emplace<esengine::ecs::UIRect>(entity);
return true;
- } else if (name == "Canvas") {
- if (!reg.has<esengine::ecs::Canvas>(entity)) reg.emplace<esengine::ecs::Canvas>(entity);
+ } else if (name == "FlexItem") {
+ if (!reg.has<esengine::ecs::FlexItem>(entity)) reg.emplace<esengine::ecs::FlexItem>(entity);
return true;
} else if (name == "BoxCollider") {
if (!reg.has<esengine::ecs::BoxCollider>(entity)) reg.emplace<esengine::ecs::BoxCollider>(entity);
@@ -519,62 +516,65 @@ bool editor_addComponent(Registry& reg, u32 e, const std::string& name) {
} else if (name == "SegmentCollider") {
if (!reg.has<esengine::ecs::SegmentCollider>(entity)) reg.emplace<esengine::ecs::SegmentCollider>(entity);
return true;
- } else if (name == "FlexContainer") {
- if (!reg.has<esengine::ecs::FlexContainer>(entity)) reg.emplace<esengine::ecs::FlexContainer>(entity);
+ } else if (name == "ParticleEmitter") {
+ if (!reg.has<esengine::ecs::ParticleEmitter>(entity)) reg.emplace<esengine::ecs::ParticleEmitter>(entity);
return true;
- } else if (name == "FlexItem") {
- if (!reg.has<esengine::ecs::FlexItem>(entity)) reg.emplace<esengine::ecs::FlexItem>(entity);
+ } else if (name == "Transform") {
+ if (!reg.has<esengine::ecs::Transform>(entity)) reg.emplace<esengine::ecs::Transform>(entity);
+ return true;
+ } else if (name == "UIRenderer") {
+ if (!reg.has<esengine::ecs::UIRenderer>(entity)) reg.emplace<esengine::ecs::UIRenderer>(entity);
return true;
} else if (name == "GridLayout") {
if (!reg.has<esengine::ecs::GridLayout>(entity)) reg.emplace<esengine::ecs::GridLayout>(entity);
return true;
- } else if (name == "Parent") {
- if (!reg.has<esengine::ecs::Parent>(entity)) reg.emplace<esengine::ecs::Parent>(entity);
+ } else if (name == "Velocity") {
+ if (!reg.has<esengine::ecs::Velocity>(entity)) reg.emplace<esengine::ecs::Velocity>(entity);
return true;
- } else if (name == "Children") {
- if (!reg.has<esengine::ecs::Children>(entity)) reg.emplace<esengine::ecs::Children>(entity);
+ } else if (name == "SpineAnimation") {
+ if (!reg.has<esengine::ecs::SpineAnimation>(entity)) reg.emplace<esengine::ecs::SpineAnimation>(entity);
return true;
} else if (name == "Interactable") {
if (!reg.has<esengine::ecs::Interactable>(entity)) reg.emplace<esengine::ecs::Interactable>(entity);
return true;
- } else if (name == "ParticleEmitter") {
- if (!reg.has<esengine::ecs::ParticleEmitter>(entity)) reg.emplace<esengine::ecs::ParticleEmitter>(entity);
+ } else if (name == "UIInteraction") {
+ if (!reg.has<esengine::ecs::UIInteraction>(entity)) reg.emplace<esengine::ecs::UIInteraction>(entity);
return true;
} else if (name == "RigidBody") {
if (!reg.has<esengine::ecs::RigidBody>(entity)) reg.emplace<esengine::ecs::RigidBody>(entity);
return true;
- } else if (name == "ShapeRenderer") {
- if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) reg.emplace<esengine::ecs::ShapeRenderer>(entity);
- return true;
- } else if (name == "SpineAnimation") {
- if (!reg.has<esengine::ecs::SpineAnimation>(entity)) reg.emplace<esengine::ecs::SpineAnimation>(entity);
+ } else if (name == "BitmapText") {
+ if (!reg.has<esengine::ecs::BitmapText>(entity)) reg.emplace<esengine::ecs::BitmapText>(entity);
return true;
} else if (name == "Sprite") {
if (!reg.has<esengine::ecs::Sprite>(entity)) reg.emplace<esengine::ecs::Sprite>(entity);
return true;
- } else if (name == "StateMachine") {
- if (!reg.has<esengine::ecs::StateMachine>(entity)) reg.emplace<esengine::ecs::StateMachine>(entity);
+ } else if (name == "UIMask") {
+ if (!reg.has<esengine::ecs::UIMask>(entity)) reg.emplace<esengine::ecs::UIMask>(entity);
+ return true;
+ } else if (name == "FlexContainer") {
+ if (!reg.has<esengine::ecs::FlexContainer>(entity)) reg.emplace<esengine::ecs::FlexContainer>(entity);
return true;
} else if (name == "StateVisuals") {
if (!reg.has<esengine::ecs::StateVisuals>(entity)) reg.emplace<esengine::ecs::StateVisuals>(entity);
return true;
- } else if (name == "Transform") {
- if (!reg.has<esengine::ecs::Transform>(entity)) reg.emplace<esengine::ecs::Transform>(entity);
+ } else if (name == "Parent") {
+ if (!reg.has<esengine::ecs::Parent>(entity)) reg.emplace<esengine::ecs::Parent>(entity);
return true;
- } else if (name == "UIInteraction") {
- if (!reg.has<esengine::ecs::UIInteraction>(entity)) reg.emplace<esengine::ecs::UIInteraction>(entity);
+ } else if (name == "Children") {
+ if (!reg.has<esengine::ecs::Children>(entity)) reg.emplace<esengine::ecs::Children>(entity);
return true;
- } else if (name == "UIMask") {
- if (!reg.has<esengine::ecs::UIMask>(entity)) reg.emplace<esengine::ecs::UIMask>(entity);
+ } else if (name == "ShapeRenderer") {
+ if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) reg.emplace<esengine::ecs::ShapeRenderer>(entity);
return true;
- } else if (name == "UIRect") {
- if (!reg.has<esengine::ecs::UIRect>(entity)) reg.emplace<esengine::ecs::UIRect>(entity);
+ } else if (name == "StateMachine") {
+ if (!reg.has<esengine::ecs::StateMachine>(entity)) reg.emplace<esengine::ecs::StateMachine>(entity);
return true;
- } else if (name == "UIRenderer") {
- if (!reg.has<esengine::ecs::UIRenderer>(entity)) reg.emplace<esengine::ecs::UIRenderer>(entity);
+ } else if (name == "Canvas") {
+ if (!reg.has<esengine::ecs::Canvas>(entity)) reg.emplace<esengine::ecs::Canvas>(entity);
return true;
- } else if (name == "Velocity") {
- if (!reg.has<esengine::ecs::Velocity>(entity)) reg.emplace<esengine::ecs::Velocity>(entity);
+ } else if (name == "Camera") {
+ if (!reg.has<esengine::ecs::Camera>(entity)) reg.emplace<esengine::ecs::Camera>(entity);
return true;
}
return false;
@@ -583,12 +583,10 @@ bool editor_addComponent(Registry& reg, u32 e, const std::string& name) {
bool editor_removeComponent(Registry& reg, u32 e, const std::string& name) {
auto entity = static_cast<Entity>(e);
if (!reg.valid(entity)) return false;
- if (name == "BitmapText") {
- if (reg.has<esengine::ecs::BitmapText>(entity)) { reg.remove<esengine::ecs::BitmapText>(entity); return true; }
- } else if (name == "Camera") {
- if (reg.has<esengine::ecs::Camera>(entity)) { reg.remove<esengine::ecs::Camera>(entity); return true; }
- } else if (name == "Canvas") {
- if (reg.has<esengine::ecs::Canvas>(entity)) { reg.remove<esengine::ecs::Canvas>(entity); return true; }
+ if (name == "UIRect") {
+ if (reg.has<esengine::ecs::UIRect>(entity)) { reg.remove<esengine::ecs::UIRect>(entity); return true; }
+ } else if (name == "FlexItem") {
+ if (reg.has<esengine::ecs::FlexItem>(entity)) { reg.remove<esengine::ecs::FlexItem>(entity); return true; }
} else if (name == "BoxCollider") {
if (reg.has<esengine::ecs::BoxCollider>(entity)) { reg.remove<esengine::ecs::BoxCollider>(entity); return true; }
} else if (name == "CircleCollider") {
@@ -597,44 +595,46 @@ bool editor_removeComponent(Registry& reg, u32 e, const std::string& name) {
if (reg.has<esengine::ecs::CapsuleCollider>(entity)) { reg.remove<esengine::ecs::CapsuleCollider>(entity); return true; }
} else if (name == "SegmentCollider") {
if (reg.has<esengine::ecs::SegmentCollider>(entity)) { reg.remove<esengine::ecs::SegmentCollider>(entity); return true; }
- } else if (name == "FlexContainer") {
- if (reg.has<esengine::ecs::FlexContainer>(entity)) { reg.remove<esengine::ecs::FlexContainer>(entity); return true; }
- } else if (name == "FlexItem") {
- if (reg.has<esengine::ecs::FlexItem>(entity)) { reg.remove<esengine::ecs::FlexItem>(entity); return true; }
+ } else if (name == "ParticleEmitter") {
+ if (reg.has<esengine::ecs::ParticleEmitter>(entity)) { reg.remove<esengine::ecs::ParticleEmitter>(entity); return true; }
+ } else if (name == "Transform") {
+ if (reg.has<esengine::ecs::Transform>(entity)) { reg.remove<esengine::ecs::Transform>(entity); return true; }
+ } else if (name == "UIRenderer") {
+ if (reg.has<esengine::ecs::UIRenderer>(entity)) { reg.remove<esengine::ecs::UIRenderer>(entity); return true; }
} else if (name == "GridLayout") {
if (reg.has<esengine::ecs::GridLayout>(entity)) { reg.remove<esengine::ecs::GridLayout>(entity); return true; }
- } else if (name == "Parent") {
- if (reg.has<esengine::ecs::Parent>(entity)) { reg.remove<esengine::ecs::Parent>(entity); return true; }
- } else if (name == "Children") {
- if (reg.has<esengine::ecs::Children>(entity)) { reg.remove<esengine::ecs::Children>(entity); return true; }
+ } else if (name == "Velocity") {
+ if (reg.has<esengine::ecs::Velocity>(entity)) { reg.remove<esengine::ecs::Velocity>(entity); return true; }
+ } else if (name == "SpineAnimation") {
+ if (reg.has<esengine::ecs::SpineAnimation>(entity)) { reg.remove<esengine::ecs::SpineAnimation>(entity); return true; }
} else if (name == "Interactable") {
if (reg.has<esengine::ecs::Interactable>(entity)) { reg.remove<esengine::ecs::Interactable>(entity); return true; }
- } else if (name == "ParticleEmitter") {
- if (reg.has<esengine::ecs::ParticleEmitter>(entity)) { reg.remove<esengine::ecs::ParticleEmitter>(entity); return true; }
+ } else if (name == "UIInteraction") {
+ if (reg.has<esengine::ecs::UIInteraction>(entity)) { reg.remove<esengine::ecs::UIInteraction>(entity); return true; }
} else if (name == "RigidBody") {
if (reg.has<esengine::ecs::RigidBody>(entity)) { reg.remove<esengine::ecs::RigidBody>(entity); return true; }
- } else if (name == "ShapeRenderer") {
- if (reg.has<esengine::ecs::ShapeRenderer>(entity)) { reg.remove<esengine::ecs::ShapeRenderer>(entity); return true; }
- } else if (name == "SpineAnimation") {
- if (reg.has<esengine::ecs::SpineAnimation>(entity)) { reg.remove<esengine::ecs::SpineAnimation>(entity); return true; }
+ } else if (name == "BitmapText") {
+ if (reg.has<esengine::ecs::BitmapText>(entity)) { reg.remove<esengine::ecs::BitmapText>(entity); return true; }
} else if (name == "Sprite") {
if (reg.has<esengine::ecs::Sprite>(entity)) { reg.remove<esengine::ecs::Sprite>(entity); return true; }
- } else if (name == "StateMachine") {
- if (reg.has<esengine::ecs::StateMachine>(entity)) { reg.remove<esengine::ecs::StateMachine>(entity); return true; }
- } else if (name == "StateVisuals") {
- if (reg.has<esengine::ecs::StateVisuals>(entity)) { reg.remove<esengine::ecs::StateVisuals>(entity); return true; }
- } else if (name == "Transform") {
- if (reg.has<esengine::ecs::Transform>(entity)) { reg.remove<esengine::ecs::Transform>(entity); return true; }
- } else if (name == "UIInteraction") {
- if (reg.has<esengine::ecs::UIInteraction>(entity)) { reg.remove<esengine::ecs::UIInteraction>(entity); return true; }
} else if (name == "UIMask") {
if (reg.has<esengine::ecs::UIMask>(entity)) { reg.remove<esengine::ecs::UIMask>(entity); return true; }
- } else if (name == "UIRect") {
- if (reg.has<esengine::ecs::UIRect>(entity)) { reg.remove<esengine::ecs::UIRect>(entity); return true; }
- } else if (name == "UIRenderer") {
- if (reg.has<esengine::ecs::UIRenderer>(entity)) { reg.remove<esengine::ecs::UIRenderer>(entity); return true; }
- } else if (name == "Velocity") {
- if (reg.has<esengine::ecs::Velocity>(entity)) { reg.remove<esengine::ecs::Velocity>(entity); return true; }
+ } else if (name == "FlexContainer") {
+ if (reg.has<esengine::ecs::FlexContainer>(entity)) { reg.remove<esengine::ecs::FlexContainer>(entity); return true; }
+ } else if (name == "StateVisuals") {
+ if (reg.has<esengine::ecs::StateVisuals>(entity)) { reg.remove<esengine::ecs::StateVisuals>(entity); return true; }
+ } else if (name == "Parent") {
+ if (reg.has<esengine::ecs::Parent>(entity)) { reg.remove<esengine::ecs::Parent>(entity); return true; }
+ } else if (name == "Children") {
+ if (reg.has<esengine::ecs::Children>(entity)) { reg.remove<esengine::ecs::Children>(entity); return true; }
+ } else if (name == "ShapeRenderer") {
+ if (reg.has<esengine::ecs::ShapeRenderer>(entity)) { reg.remove<esengine::ecs::ShapeRenderer>(entity); return true; }
+ } else if (name == "StateMachine") {
+ if (reg.has<esengine::ecs::StateMachine>(entity)) { reg.remove<esengine::ecs::StateMachine>(entity); return true; }
+ } else if (name == "Canvas") {
+ if (reg.has<esengine::ecs::Canvas>(entity)) { reg.remove<esengine::ecs::Canvas>(entity); return true; }
+ } else if (name == "Camera") {
+ if (reg.has<esengine::ecs::Camera>(entity)) { reg.remove<esengine::ecs::Camera>(entity); return true; }
}
return false;
}
@@ -642,32 +642,32 @@ bool editor_removeComponent(Registry& reg, u32 e, const std::string& name) {
bool editor_hasComponent(Registry& reg, u32 e, const std::string& name) {
auto entity = static_cast<Entity>(e);
if (!reg.valid(entity)) return false;
- if (name == "BitmapText") return reg.has<esengine::ecs::BitmapText>(entity);
- if (name == "Camera") return reg.has<esengine::ecs::Camera>(entity);
- if (name == "Canvas") return reg.has<esengine::ecs::Canvas>(entity);
+ if (name == "UIRect") return reg.has<esengine::ecs::UIRect>(entity);
+ if (name == "FlexItem") return reg.has<esengine::ecs::FlexItem>(entity);
if (name == "BoxCollider") return reg.has<esengine::ecs::BoxCollider>(entity);
if (name == "CircleCollider") return reg.has<esengine::ecs::CircleCollider>(entity);
if (name == "CapsuleCollider") return reg.has<esengine::ecs::CapsuleCollider>(entity);
if (name == "SegmentCollider") return reg.has<esengine::ecs::SegmentCollider>(entity);
- if (name == "FlexContainer") return reg.has<esengine::ecs::FlexContainer>(entity);
- if (name == "FlexItem") return reg.has<esengine::ecs::FlexItem>(entity);
+ if (name == "ParticleEmitter") return reg.has<esengine::ecs::ParticleEmitter>(entity);
+ if (name == "Transform") return reg.has<esengine::ecs::Transform>(entity);
+ if (name == "UIRenderer") return reg.has<esengine::ecs::UIRenderer>(entity);
if (name == "GridLayout") return reg.has<esengine::ecs::GridLayout>(entity);
- if (name == "Parent") return reg.has<esengine::ecs::Parent>(entity);
- if (name == "Children") return reg.has<esengine::ecs::Children>(entity);
+ if (name == "Velocity") return reg.has<esengine::ecs::Velocity>(entity);
+ if (name == "SpineAnimation") return reg.has<esengine::ecs::SpineAnimation>(entity);
if (name == "Interactable") return reg.has<esengine::ecs::Interactable>(entity);
- if (name == "ParticleEmitter") return reg.has<esengine::ecs::ParticleEmitter>(entity);
+ if (name == "UIInteraction") return reg.has<esengine::ecs::UIInteraction>(entity);
if (name == "RigidBody") return reg.has<esengine::ecs::RigidBody>(entity);
- if (name == "ShapeRenderer") return reg.has<esengine::ecs::ShapeRenderer>(entity);
- if (name == "SpineAnimation") return reg.has<esengine::ecs::SpineAnimation>(entity);
+ if (name == "BitmapText") return reg.has<esengine::ecs::BitmapText>(entity);
if (name == "Sprite") return reg.has<esengine::ecs::Sprite>(entity);
- if (name == "StateMachine") return reg.has<esengine::ecs::StateMachine>(entity);
- if (name == "StateVisuals") return reg.has<esengine::ecs::StateVisuals>(entity);
- if (name == "Transform") return reg.has<esengine::ecs::Transform>(entity);
- if (name == "UIInteraction") return reg.has<esengine::ecs::UIInteraction>(entity);
if (name == "UIMask") return reg.has<esengine::ecs::UIMask>(entity);
- if (name == "UIRect") return reg.has<esengine::ecs::UIRect>(entity);
- if (name == "UIRenderer") return reg.has<esengine::ecs::UIRenderer>(entity);
- if (name == "Velocity") return reg.has<esengine::ecs::Velocity>(entity);
+ if (name == "FlexContainer") return reg.has<esengine::ecs::FlexContainer>(entity);
+ if (name == "StateVisuals") return reg.has<esengine::ecs::StateVisuals>(entity);
+ if (name == "Parent") return reg.has<esengine::ecs::Parent>(entity);
+ if (name == "Children") return reg.has<esengine::ecs::Children>(entity);
+ if (name == "ShapeRenderer") return reg.has<esengine::ecs::ShapeRenderer>(entity);
+ if (name == "StateMachine") return reg.has<esengine::ecs::StateMachine>(entity);
+ if (name == "Canvas") return reg.has<esengine::ecs::Canvas>(entity);
+ if (name == "Camera") return reg.has<esengine::ecs::Camera>(entity);
return false;
}
@@ -677,32 +677,32 @@ std::vector<std::string> editor_getComponents(Registry& reg, u32 e) {
auto entity = static_cast<Entity>(e);
std::vector<std::string> result;
if (!reg.valid(entity)) return result;
- if (reg.has<esengine::ecs::BitmapText>(entity)) result.push_back("BitmapText");
- if (reg.has<esengine::ecs::Camera>(entity)) result.push_back("Camera");
- if (reg.has<esengine::ecs::Canvas>(entity)) result.push_back("Canvas");
+ if (reg.has<esengine::ecs::UIRect>(entity)) result.push_back("UIRect");
+ if (reg.has<esengine::ecs::FlexItem>(entity)) result.push_back("FlexItem");
if (reg.has<esengine::ecs::BoxCollider>(entity)) result.push_back("BoxCollider");
if (reg.has<esengine::ecs::CircleCollider>(entity)) result.push_back("CircleCollider");
if (reg.has<esengine::ecs::CapsuleCollider>(entity)) result.push_back("CapsuleCollider");
if (reg.has<esengine::ecs::SegmentCollider>(entity)) result.push_back("SegmentCollider");
- if (reg.has<esengine::ecs::FlexContainer>(entity)) result.push_back("FlexContainer");
- if (reg.has<esengine::ecs::FlexItem>(entity)) result.push_back("FlexItem");
+ if (reg.has<esengine::ecs::ParticleEmitter>(entity)) result.push_back("ParticleEmitter");
+ if (reg.has<esengine::ecs::Transform>(entity)) result.push_back("Transform");
+ if (reg.has<esengine::ecs::UIRenderer>(entity)) result.push_back("UIRenderer");
if (reg.has<esengine::ecs::GridLayout>(entity)) result.push_back("GridLayout");
- if (reg.has<esengine::ecs::Parent>(entity)) result.push_back("Parent");
- if (reg.has<esengine::ecs::Children>(entity)) result.push_back("Children");
+ if (reg.has<esengine::ecs::Velocity>(entity)) result.push_back("Velocity");
+ if (reg.has<esengine::ecs::SpineAnimation>(entity)) result.push_back("SpineAnimation");
if (reg.has<esengine::ecs::Interactable>(entity)) result.push_back("Interactable");
- if (reg.has<esengine::ecs::ParticleEmitter>(entity)) result.push_back("ParticleEmitter");
+ if (reg.has<esengine::ecs::UIInteraction>(entity)) result.push_back("UIInteraction");
if (reg.has<esengine::ecs::RigidBody>(entity)) result.push_back("RigidBody");
- if (reg.has<esengine::ecs::ShapeRenderer>(entity)) result.push_back("ShapeRenderer");
- if (reg.has<esengine::ecs::SpineAnimation>(entity)) result.push_back("SpineAnimation");
+ if (reg.has<esengine::ecs::BitmapText>(entity)) result.push_back("BitmapText");
if (reg.has<esengine::ecs::Sprite>(entity)) result.push_back("Sprite");
- if (reg.has<esengine::ecs::StateMachine>(entity)) result.push_back("StateMachine");
- if (reg.has<esengine::ecs::StateVisuals>(entity)) result.push_back("StateVisuals");
- if (reg.has<esengine::ecs::Transform>(entity)) result.push_back("Transform");
- if (reg.has<esengine::ecs::UIInteraction>(entity)) result.push_back("UIInteraction");
if (reg.has<esengine::ecs::UIMask>(entity)) result.push_back("UIMask");
- if (reg.has<esengine::ecs::UIRect>(entity)) result.push_back("UIRect");
- if (reg.has<esengine::ecs::UIRenderer>(entity)) result.push_back("UIRenderer");
- if (reg.has<esengine::ecs::Velocity>(entity)) result.push_back("Velocity");
+ if (reg.has<esengine::ecs::FlexContainer>(entity)) result.push_back("FlexContainer");
+ if (reg.has<esengine::ecs::StateVisuals>(entity)) result.push_back("StateVisuals");
+ if (reg.has<esengine::ecs::Parent>(entity)) result.push_back("Parent");
+ if (reg.has<esengine::ecs::Children>(entity)) result.push_back("Children");
+ if (reg.has<esengine::ecs::ShapeRenderer>(entity)) result.push_back("ShapeRenderer");
+ if (reg.has<esengine::ecs::StateMachine>(entity)) result.push_back("StateMachine");
+ if (reg.has<esengine::ecs::Canvas>(entity)) result.push_back("Canvas");
+ if (reg.has<esengine::ecs::Camera>(entity)) result.push_back("Camera");
return result;
}
@@ -711,40 +711,39 @@ std::vector<std::string> editor_getComponents(Registry& reg, u32 e) {
bool editor_setFloat(Registry& reg, u32 e, const std::string& comp, const std::string& field, f32 value) {
auto entity = static_cast<Entity>(e);
if (!reg.valid(entity)) return false;
- if (comp == "BitmapText") {
- if (!reg.has<esengine::ecs::BitmapText>(entity)) return false;
- auto& c = reg.get<esengine::ecs::BitmapText>(entity);
- if (field == "color.r") { c.color.r = value; }
- else if (field == "color.g") { c.color.g = value; }
- else if (field == "color.b") { c.color.b = value; }
- else if (field == "color.a") { c.color.a = value; }
- else if (field == "fontSize") { c.fontSize = value; }
- else if (field == "spacing") { c.spacing = value; }
- else { return false; }
- return true;
- } else if (comp == "Camera") {
- if (!reg.has<esengine::ecs::Camera>(entity)) return false;
- auto& c = reg.get<esengine::ecs::Camera>(entity);
- if (field == "fov") { c.fov = value; }
- else if (field == "orthoSize") { c.orthoSize = value; }
- else if (field == "nearPlane") { c.nearPlane = value; }
- else if (field == "farPlane") { c.farPlane = value; }
- else if (field == "aspectRatio") { c.aspectRatio = value; }
- else if (field == "viewport.x") { c.viewport.x = value; }
- else if (field == "viewport.y") { c.viewport.y = value; }
- else if (field == "viewport.z") { c.viewport.z = value; }
- else if (field == "viewport.w") { c.viewport.w = value; }
+ if (comp == "UIRect") {
+ if (!reg.has<esengine::ecs::UIRect>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::UIRect>(entity);
+ if (field == "anchorMin.x") { c.anchorMin.x = value; }
+ else if (field == "anchorMin.y") { c.anchorMin.y = value; }
+ else if (field == "anchorMax.x") { c.anchorMax.x = value; }
+ else if (field == "anchorMax.y") { c.anchorMax.y = value; }
+ else if (field == "offsetMin.x") { c.offsetMin.x = value; }
+ else if (field == "offsetMin.y") { c.offsetMin.y = value; }
+ else if (field == "offsetMax.x") { c.offsetMax.x = value; }
+ else if (field == "offsetMax.y") { c.offsetMax.y = value; }
+ else if (field == "size.x") { c.size.x = value; }
+ else if (field == "size.y") { c.size.y = value; }
+ else if (field == "pivot.x") { c.pivot.x = value; }
+ else if (field == "pivot.y") { c.pivot.y = value; }
else { return false; }
return true;
- } else if (comp == "Canvas") {
- if (!reg.has<esengine::ecs::Canvas>(entity)) return false;
- auto& c = reg.get<esengine::ecs::Canvas>(entity);
- if (field == "pixelsPerUnit") { c.pixelsPerUnit = value; }
- else if (field == "matchWidthOrHeight") { c.matchWidthOrHeight = value; }
- else if (field == "backgroundColor.r") { c.backgroundColor.r = value; }
- else if (field == "backgroundColor.g") { c.backgroundColor.g = value; }
- else if (field == "backgroundColor.b") { c.backgroundColor.b = value; }
- else if (field == "backgroundColor.a") { c.backgroundColor.a = value; }
+ } else if (comp == "FlexItem") {
+ if (!reg.has<esengine::ecs::FlexItem>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::FlexItem>(entity);
+ if (field == "flexGrow") { c.flexGrow = value; }
+ else if (field == "flexShrink") { c.flexShrink = value; }
+ else if (field == "flexBasis") { c.flexBasis = value; }
+ else if (field == "margin.left") { c.margin.left = value; }
+ else if (field == "margin.top") { c.margin.top = value; }
+ else if (field == "margin.right") { c.margin.right = value; }
+ else if (field == "margin.bottom") { c.margin.bottom = value; }
+ else if (field == "minWidth") { c.minWidth = value; }
+ else if (field == "minHeight") { c.minHeight = value; }
+ else if (field == "maxWidth") { c.maxWidth = value; }
+ else if (field == "maxHeight") { c.maxHeight = value; }
+ else if (field == "widthPercent") { c.widthPercent = value; }
+ else if (field == "heightPercent") { c.heightPercent = value; }
else { return false; }
return true;
} else if (comp == "BoxCollider") {
@@ -794,44 +793,6 @@ bool editor_setFloat(Registry& reg, u32 e, const std::string& comp, const std::s
else if (field == "restitution") { c.restitution = value; }
else { return false; }
return true;
- } else if (comp == "FlexContainer") {
- if (!reg.has<esengine::ecs::FlexContainer>(entity)) return false;
- auto& c = reg.get<esengine::ecs::FlexContainer>(entity);
- if (field == "gap.x") { c.gap.x = value; }
- else if (field == "gap.y") { c.gap.y = value; }
- else if (field == "padding.left") { c.padding.left = value; }
- else if (field == "padding.top") { c.padding.top = value; }
- else if (field == "padding.right") { c.padding.right = value; }
- else if (field == "padding.bottom") { c.padding.bottom = value; }
- else { return false; }
- return true;
- } else if (comp == "FlexItem") {
- if (!reg.has<esengine::ecs::FlexItem>(entity)) return false;
- auto& c = reg.get<esengine::ecs::FlexItem>(entity);
- if (field == "flexGrow") { c.flexGrow = value; }
- else if (field == "flexShrink") { c.flexShrink = value; }
- else if (field == "flexBasis") { c.flexBasis = value; }
- else if (field == "margin.left") { c.margin.left = value; }
- else if (field == "margin.top") { c.margin.top = value; }
- else if (field == "margin.right") { c.margin.right = value; }
- else if (field == "margin.bottom") { c.margin.bottom = value; }
- else if (field == "minWidth") { c.minWidth = value; }
- else if (field == "minHeight") { c.minHeight = value; }
- else if (field == "maxWidth") { c.maxWidth = value; }
- else if (field == "maxHeight") { c.maxHeight = value; }
- else if (field == "widthPercent") { c.widthPercent = value; }
- else if (field == "heightPercent") { c.heightPercent = value; }
- else { return false; }
- return true;
- } else if (comp == "GridLayout") {
- if (!reg.has<esengine::ecs::GridLayout>(entity)) return false;
- auto& c = reg.get<esengine::ecs::GridLayout>(entity);
- if (field == "itemSize.x") { c.itemSize.x = value; }
- else if (field == "itemSize.y") { c.itemSize.y = value; }
- else if (field == "spacing.x") { c.spacing.x = value; }
- else if (field == "spacing.y") { c.spacing.y = value; }
- else { return false; }
- return true;
} else if (comp == "ParticleEmitter") {
if (!reg.has<esengine::ecs::ParticleEmitter>(entity)) return false;
auto& c = reg.get<esengine::ecs::ParticleEmitter>(entity);
@@ -870,24 +831,67 @@ bool editor_setFloat(Registry& reg, u32 e, const std::string& comp, const std::s
else if (field == "spriteFPS") { c.spriteFPS = value; }
else { return false; }
return true;
- } else if (comp == "RigidBody") {
- if (!reg.has<esengine::ecs::RigidBody>(entity)) return false;
- auto& c = reg.get<esengine::ecs::RigidBody>(entity);
- if (field == "gravityScale") { c.gravityScale = value; }
- else if (field == "linearDamping") { c.linearDamping = value; }
- else if (field == "angularDamping") { c.angularDamping = value; }
+ } else if (comp == "Transform") {
+ if (!reg.has<esengine::ecs::Transform>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::Transform>(entity);
+ if (field == "position.x") { c.position.x = value; }
+ else if (field == "position.y") { c.position.y = value; }
+ else if (field == "position.z") { c.position.z = value; }
+ else if (field == "scale.x") { c.scale.x = value; }
+ else if (field == "scale.y") { c.scale.y = value; }
+ else if (field == "scale.z") { c.scale.z = value; }
+ else if (field == "rotation.x") {
+ auto euler = quatToEulerDeg(c.rotation);
+ euler.x = value;
+ c.rotation = eulerDegToQuat(euler);
+ }
+ else if (field == "rotation.y") {
+ auto euler = quatToEulerDeg(c.rotation);
+ euler.y = value;
+ c.rotation = eulerDegToQuat(euler);
+ }
+ else if (field == "rotation.z") {
+ auto euler = quatToEulerDeg(c.rotation);
+ euler.z = value;
+ c.rotation = eulerDegToQuat(euler);
+ }
else { return false; }
return true;
- } else if (comp == "ShapeRenderer") {
- if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return false;
- auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
+ } else if (comp == "UIRenderer") {
+ if (!reg.has<esengine::ecs::UIRenderer>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
if (field == "color.r") { c.color.r = value; }
else if (field == "color.g") { c.color.g = value; }
else if (field == "color.b") { c.color.b = value; }
else if (field == "color.a") { c.color.a = value; }
- else if (field == "size.x") { c.size.x = value; }
- else if (field == "size.y") { c.size.y = value; }
- else if (field == "cornerRadius") { c.cornerRadius = value; }
+ else if (field == "uvOffset.x") { c.uvOffset.x = value; }
+ else if (field == "uvOffset.y") { c.uvOffset.y = value; }
+ else if (field == "uvScale.x") { c.uvScale.x = value; }
+ else if (field == "uvScale.y") { c.uvScale.y = value; }
+ else if (field == "sliceBorder.x") { c.sliceBorder.x = value; }
+ else if (field == "sliceBorder.y") { c.sliceBorder.y = value; }
+ else if (field == "sliceBorder.z") { c.sliceBorder.z = value; }
+ else if (field == "sliceBorder.w") { c.sliceBorder.w = value; }
+ else { return false; }
+ return true;
+ } else if (comp == "GridLayout") {
+ if (!reg.has<esengine::ecs::GridLayout>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::GridLayout>(entity);
+ if (field == "itemSize.x") { c.itemSize.x = value; }
+ else if (field == "itemSize.y") { c.itemSize.y = value; }
+ else if (field == "spacing.x") { c.spacing.x = value; }
+ else if (field == "spacing.y") { c.spacing.y = value; }
+ else { return false; }
+ return true;
+ } else if (comp == "Velocity") {
+ if (!reg.has<esengine::ecs::Velocity>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::Velocity>(entity);
+ if (field == "linear.x") { c.linear.x = value; }
+ else if (field == "linear.y") { c.linear.y = value; }
+ else if (field == "linear.z") { c.linear.z = value; }
+ else if (field == "angular.x") { c.angular.x = value; }
+ else if (field == "angular.y") { c.angular.y = value; }
+ else if (field == "angular.z") { c.angular.z = value; }
else { return false; }
return true;
} else if (comp == "SpineAnimation") {
@@ -901,6 +905,25 @@ bool editor_setFloat(Registry& reg, u32 e, const std::string& comp, const std::s
else if (field == "skeletonScale") { c.skeletonScale = value; }
else { return false; }
return true;
+ } else if (comp == "RigidBody") {
+ if (!reg.has<esengine::ecs::RigidBody>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::RigidBody>(entity);
+ if (field == "gravityScale") { c.gravityScale = value; }
+ else if (field == "linearDamping") { c.linearDamping = value; }
+ else if (field == "angularDamping") { c.angularDamping = value; }
+ else { return false; }
+ return true;
+ } else if (comp == "BitmapText") {
+ if (!reg.has<esengine::ecs::BitmapText>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::BitmapText>(entity);
+ if (field == "color.r") { c.color.r = value; }
+ else if (field == "color.g") { c.color.g = value; }
+ else if (field == "color.b") { c.color.b = value; }
+ else if (field == "color.a") { c.color.a = value; }
+ else if (field == "fontSize") { c.fontSize = value; }
+ else if (field == "spacing") { c.spacing = value; }
+ else { return false; }
+ return true;
} else if (comp == "Sprite") {
if (!reg.has<esengine::ecs::Sprite>(entity)) return false;
auto& c = reg.get<esengine::ecs::Sprite>(entity);
@@ -922,6 +945,17 @@ bool editor_setFloat(Registry& reg, u32 e, const std::string& comp, const std::s
else if (field == "tileSpacing.y") { c.tileSpacing.y = value; }
else { return false; }
return true;
+ } else if (comp == "FlexContainer") {
+ if (!reg.has<esengine::ecs::FlexContainer>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::FlexContainer>(entity);
+ if (field == "gap.x") { c.gap.x = value; }
+ else if (field == "gap.y") { c.gap.y = value; }
+ else if (field == "padding.left") { c.padding.left = value; }
+ else if (field == "padding.top") { c.padding.top = value; }
+ else if (field == "padding.right") { c.padding.right = value; }
+ else if (field == "padding.bottom") { c.padding.bottom = value; }
+ else { return false; }
+ return true;
} else if (comp == "StateVisuals") {
if (!reg.has<esengine::ecs::StateVisuals>(entity)) return false;
auto& c = reg.get<esengine::ecs::StateVisuals>(entity);
@@ -968,75 +1002,41 @@ bool editor_setFloat(Registry& reg, u32 e, const std::string& comp, const std::s
else if (field == "slot7Scale") { c.slot7Scale = value; }
else { return false; }
return true;
- } else if (comp == "Transform") {
- if (!reg.has<esengine::ecs::Transform>(entity)) return false;
- auto& c = reg.get<esengine::ecs::Transform>(entity);
- if (field == "position.x") { c.position.x = value; }
- else if (field == "position.y") { c.position.y = value; }
- else if (field == "position.z") { c.position.z = value; }
- else if (field == "scale.x") { c.scale.x = value; }
- else if (field == "scale.y") { c.scale.y = value; }
- else if (field == "scale.z") { c.scale.z = value; }
- else if (field == "rotation.x") {
- auto euler = quatToEulerDeg(c.rotation);
- euler.x = value;
- c.rotation = eulerDegToQuat(euler);
- }
- else if (field == "rotation.y") {
- auto euler = quatToEulerDeg(c.rotation);
- euler.y = value;
- c.rotation = eulerDegToQuat(euler);
- }
- else if (field == "rotation.z") {
- auto euler = quatToEulerDeg(c.rotation);
- euler.z = value;
- c.rotation = eulerDegToQuat(euler);
- }
- else { return false; }
- return true;
- } else if (comp == "UIRect") {
- if (!reg.has<esengine::ecs::UIRect>(entity)) return false;
- auto& c = reg.get<esengine::ecs::UIRect>(entity);
- if (field == "anchorMin.x") { c.anchorMin.x = value; }
- else if (field == "anchorMin.y") { c.anchorMin.y = value; }
- else if (field == "anchorMax.x") { c.anchorMax.x = value; }
- else if (field == "anchorMax.y") { c.anchorMax.y = value; }
- else if (field == "offsetMin.x") { c.offsetMin.x = value; }
- else if (field == "offsetMin.y") { c.offsetMin.y = value; }
- else if (field == "offsetMax.x") { c.offsetMax.x = value; }
- else if (field == "offsetMax.y") { c.offsetMax.y = value; }
- else if (field == "size.x") { c.size.x = value; }
- else if (field == "size.y") { c.size.y = value; }
- else if (field == "pivot.x") { c.pivot.x = value; }
- else if (field == "pivot.y") { c.pivot.y = value; }
- else { return false; }
- return true;
- } else if (comp == "UIRenderer") {
- if (!reg.has<esengine::ecs::UIRenderer>(entity)) return false;
- auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
+ } else if (comp == "ShapeRenderer") {
+ if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
if (field == "color.r") { c.color.r = value; }
else if (field == "color.g") { c.color.g = value; }
else if (field == "color.b") { c.color.b = value; }
else if (field == "color.a") { c.color.a = value; }
- else if (field == "uvOffset.x") { c.uvOffset.x = value; }
- else if (field == "uvOffset.y") { c.uvOffset.y = value; }
- else if (field == "uvScale.x") { c.uvScale.x = value; }
- else if (field == "uvScale.y") { c.uvScale.y = value; }
- else if (field == "sliceBorder.x") { c.sliceBorder.x = value; }
- else if (field == "sliceBorder.y") { c.sliceBorder.y = value; }
- else if (field == "sliceBorder.z") { c.sliceBorder.z = value; }
- else if (field == "sliceBorder.w") { c.sliceBorder.w = value; }
+ else if (field == "size.x") { c.size.x = value; }
+ else if (field == "size.y") { c.size.y = value; }
+ else if (field == "cornerRadius") { c.cornerRadius = value; }
else { return false; }
return true;
- } else if (comp == "Velocity") {
- if (!reg.has<esengine::ecs::Velocity>(entity)) return false;
- auto& c = reg.get<esengine::ecs::Velocity>(entity);
- if (field == "linear.x") { c.linear.x = value; }
- else if (field == "linear.y") { c.linear.y = value; }
- else if (field == "linear.z") { c.linear.z = value; }
- else if (field == "angular.x") { c.angular.x = value; }
- else if (field == "angular.y") { c.angular.y = value; }
- else if (field == "angular.z") { c.angular.z = value; }
+ } else if (comp == "Canvas") {
+ if (!reg.has<esengine::ecs::Canvas>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::Canvas>(entity);
+ if (field == "pixelsPerUnit") { c.pixelsPerUnit = value; }
+ else if (field == "matchWidthOrHeight") { c.matchWidthOrHeight = value; }
+ else if (field == "backgroundColor.r") { c.backgroundColor.r = value; }
+ else if (field == "backgroundColor.g") { c.backgroundColor.g = value; }
+ else if (field == "backgroundColor.b") { c.backgroundColor.b = value; }
+ else if (field == "backgroundColor.a") { c.backgroundColor.a = value; }
+ else { return false; }
+ return true;
+ } else if (comp == "Camera") {
+ if (!reg.has<esengine::ecs::Camera>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::Camera>(entity);
+ if (field == "fov") { c.fov = value; }
+ else if (field == "orthoSize") { c.orthoSize = value; }
+ else if (field == "nearPlane") { c.nearPlane = value; }
+ else if (field == "farPlane") { c.farPlane = value; }
+ else if (field == "aspectRatio") { c.aspectRatio = value; }
+ else if (field == "viewport.x") { c.viewport.x = value; }
+ else if (field == "viewport.y") { c.viewport.y = value; }
+ else if (field == "viewport.z") { c.viewport.z = value; }
+ else if (field == "viewport.w") { c.viewport.w = value; }
else { return false; }
return true;
}
@@ -1048,36 +1048,37 @@ bool editor_setFloat(Registry& reg, u32 e, const std::string& comp, const std::s
f32 editor_getFloat(Registry& reg, u32 e, const std::string& comp, const std::string& field) {
auto entity = static_cast<Entity>(e);
if (!reg.valid(entity)) return 0.0f;
- if (comp == "BitmapText") {
- if (!reg.has<esengine::ecs::BitmapText>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::BitmapText>(entity);
- if (field == "color.r") { return c.color.r; }
- else if (field == "color.g") { return c.color.g; }
- else if (field == "color.b") { return c.color.b; }
- else if (field == "color.a") { return c.color.a; }
- else if (field == "fontSize") { return c.fontSize; }
- else if (field == "spacing") { return c.spacing; }
- } else if (comp == "Camera") {
- if (!reg.has<esengine::ecs::Camera>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::Camera>(entity);
- if (field == "fov") { return c.fov; }
- else if (field == "orthoSize") { return c.orthoSize; }
- else if (field == "nearPlane") { return c.nearPlane; }
- else if (field == "farPlane") { return c.farPlane; }
- else if (field == "aspectRatio") { return c.aspectRatio; }
- else if (field == "viewport.x") { return c.viewport.x; }
- else if (field == "viewport.y") { return c.viewport.y; }
- else if (field == "viewport.z") { return c.viewport.z; }
- else if (field == "viewport.w") { return c.viewport.w; }
- } else if (comp == "Canvas") {
- if (!reg.has<esengine::ecs::Canvas>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::Canvas>(entity);
- if (field == "pixelsPerUnit") { return c.pixelsPerUnit; }
- else if (field == "matchWidthOrHeight") { return c.matchWidthOrHeight; }
- else if (field == "backgroundColor.r") { return c.backgroundColor.r; }
- else if (field == "backgroundColor.g") { return c.backgroundColor.g; }
- else if (field == "backgroundColor.b") { return c.backgroundColor.b; }
- else if (field == "backgroundColor.a") { return c.backgroundColor.a; }
+ if (comp == "UIRect") {
+ if (!reg.has<esengine::ecs::UIRect>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::UIRect>(entity);
+ if (field == "anchorMin.x") { return c.anchorMin.x; }
+ else if (field == "anchorMin.y") { return c.anchorMin.y; }
+ else if (field == "anchorMax.x") { return c.anchorMax.x; }
+ else if (field == "anchorMax.y") { return c.anchorMax.y; }
+ else if (field == "offsetMin.x") { return c.offsetMin.x; }
+ else if (field == "offsetMin.y") { return c.offsetMin.y; }
+ else if (field == "offsetMax.x") { return c.offsetMax.x; }
+ else if (field == "offsetMax.y") { return c.offsetMax.y; }
+ else if (field == "size.x") { return c.size.x; }
+ else if (field == "size.y") { return c.size.y; }
+ else if (field == "pivot.x") { return c.pivot.x; }
+ else if (field == "pivot.y") { return c.pivot.y; }
+ } else if (comp == "FlexItem") {
+ if (!reg.has<esengine::ecs::FlexItem>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::FlexItem>(entity);
+ if (field == "flexGrow") { return c.flexGrow; }
+ else if (field == "flexShrink") { return c.flexShrink; }
+ else if (field == "flexBasis") { return c.flexBasis; }
+ else if (field == "margin.left") { return c.margin.left; }
+ else if (field == "margin.top") { return c.margin.top; }
+ else if (field == "margin.right") { return c.margin.right; }
+ else if (field == "margin.bottom") { return c.margin.bottom; }
+ else if (field == "minWidth") { return c.minWidth; }
+ else if (field == "minHeight") { return c.minHeight; }
+ else if (field == "maxWidth") { return c.maxWidth; }
+ else if (field == "maxHeight") { return c.maxHeight; }
+ else if (field == "widthPercent") { return c.widthPercent; }
+ else if (field == "heightPercent") { return c.heightPercent; }
} else if (comp == "BoxCollider") {
if (!reg.has<esengine::ecs::BoxCollider>(entity)) return 0.0f;
const auto& c = reg.get<esengine::ecs::BoxCollider>(entity);
@@ -1117,38 +1118,6 @@ f32 editor_getFloat(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "density") { return c.density; }
else if (field == "friction") { return c.friction; }
else if (field == "restitution") { return c.restitution; }
- } else if (comp == "FlexContainer") {
- if (!reg.has<esengine::ecs::FlexContainer>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::FlexContainer>(entity);
- if (field == "gap.x") { return c.gap.x; }
- else if (field == "gap.y") { return c.gap.y; }
- else if (field == "padding.left") { return c.padding.left; }
- else if (field == "padding.top") { return c.padding.top; }
- else if (field == "padding.right") { return c.padding.right; }
- else if (field == "padding.bottom") { return c.padding.bottom; }
- } else if (comp == "FlexItem") {
- if (!reg.has<esengine::ecs::FlexItem>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::FlexItem>(entity);
- if (field == "flexGrow") { return c.flexGrow; }
- else if (field == "flexShrink") { return c.flexShrink; }
- else if (field == "flexBasis") { return c.flexBasis; }
- else if (field == "margin.left") { return c.margin.left; }
- else if (field == "margin.top") { return c.margin.top; }
- else if (field == "margin.right") { return c.margin.right; }
- else if (field == "margin.bottom") { return c.margin.bottom; }
- else if (field == "minWidth") { return c.minWidth; }
- else if (field == "minHeight") { return c.minHeight; }
- else if (field == "maxWidth") { return c.maxWidth; }
- else if (field == "maxHeight") { return c.maxHeight; }
- else if (field == "widthPercent") { return c.widthPercent; }
- else if (field == "heightPercent") { return c.heightPercent; }
- } else if (comp == "GridLayout") {
- if (!reg.has<esengine::ecs::GridLayout>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::GridLayout>(entity);
- if (field == "itemSize.x") { return c.itemSize.x; }
- else if (field == "itemSize.y") { return c.itemSize.y; }
- else if (field == "spacing.x") { return c.spacing.x; }
- else if (field == "spacing.y") { return c.spacing.y; }
} else if (comp == "ParticleEmitter") {
if (!reg.has<esengine::ecs::ParticleEmitter>(entity)) return 0.0f;
const auto& c = reg.get<esengine::ecs::ParticleEmitter>(entity);
@@ -1185,22 +1154,49 @@ f32 editor_getFloat(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "gravity.y") { return c.gravity.y; }
else if (field == "damping") { return c.damping; }
else if (field == "spriteFPS") { return c.spriteFPS; }
- } else if (comp == "RigidBody") {
- if (!reg.has<esengine::ecs::RigidBody>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::RigidBody>(entity);
- if (field == "gravityScale") { return c.gravityScale; }
- else if (field == "linearDamping") { return c.linearDamping; }
- else if (field == "angularDamping") { return c.angularDamping; }
- } else if (comp == "ShapeRenderer") {
- if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
+ } else if (comp == "Transform") {
+ if (!reg.has<esengine::ecs::Transform>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::Transform>(entity);
+ if (field == "position.x") { return c.position.x; }
+ else if (field == "position.y") { return c.position.y; }
+ else if (field == "position.z") { return c.position.z; }
+ else if (field == "scale.x") { return c.scale.x; }
+ else if (field == "scale.y") { return c.scale.y; }
+ else if (field == "scale.z") { return c.scale.z; }
+ else if (field == "rotation.x") { return quatToEulerDeg(c.rotation).x; }
+ else if (field == "rotation.y") { return quatToEulerDeg(c.rotation).y; }
+ else if (field == "rotation.z") { return quatToEulerDeg(c.rotation).z; }
+ } else if (comp == "UIRenderer") {
+ if (!reg.has<esengine::ecs::UIRenderer>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
if (field == "color.r") { return c.color.r; }
else if (field == "color.g") { return c.color.g; }
else if (field == "color.b") { return c.color.b; }
else if (field == "color.a") { return c.color.a; }
- else if (field == "size.x") { return c.size.x; }
- else if (field == "size.y") { return c.size.y; }
- else if (field == "cornerRadius") { return c.cornerRadius; }
+ else if (field == "uvOffset.x") { return c.uvOffset.x; }
+ else if (field == "uvOffset.y") { return c.uvOffset.y; }
+ else if (field == "uvScale.x") { return c.uvScale.x; }
+ else if (field == "uvScale.y") { return c.uvScale.y; }
+ else if (field == "sliceBorder.x") { return c.sliceBorder.x; }
+ else if (field == "sliceBorder.y") { return c.sliceBorder.y; }
+ else if (field == "sliceBorder.z") { return c.sliceBorder.z; }
+ else if (field == "sliceBorder.w") { return c.sliceBorder.w; }
+ } else if (comp == "GridLayout") {
+ if (!reg.has<esengine::ecs::GridLayout>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::GridLayout>(entity);
+ if (field == "itemSize.x") { return c.itemSize.x; }
+ else if (field == "itemSize.y") { return c.itemSize.y; }
+ else if (field == "spacing.x") { return c.spacing.x; }
+ else if (field == "spacing.y") { return c.spacing.y; }
+ } else if (comp == "Velocity") {
+ if (!reg.has<esengine::ecs::Velocity>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::Velocity>(entity);
+ if (field == "linear.x") { return c.linear.x; }
+ else if (field == "linear.y") { return c.linear.y; }
+ else if (field == "linear.z") { return c.linear.z; }
+ else if (field == "angular.x") { return c.angular.x; }
+ else if (field == "angular.y") { return c.angular.y; }
+ else if (field == "angular.z") { return c.angular.z; }
} else if (comp == "SpineAnimation") {
if (!reg.has<esengine::ecs::SpineAnimation>(entity)) return 0.0f;
const auto& c = reg.get<esengine::ecs::SpineAnimation>(entity);
@@ -1210,6 +1206,21 @@ f32 editor_getFloat(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "color.b") { return c.color.b; }
else if (field == "color.a") { return c.color.a; }
else if (field == "skeletonScale") { return c.skeletonScale; }
+ } else if (comp == "RigidBody") {
+ if (!reg.has<esengine::ecs::RigidBody>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::RigidBody>(entity);
+ if (field == "gravityScale") { return c.gravityScale; }
+ else if (field == "linearDamping") { return c.linearDamping; }
+ else if (field == "angularDamping") { return c.angularDamping; }
+ } else if (comp == "BitmapText") {
+ if (!reg.has<esengine::ecs::BitmapText>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::BitmapText>(entity);
+ if (field == "color.r") { return c.color.r; }
+ else if (field == "color.g") { return c.color.g; }
+ else if (field == "color.b") { return c.color.b; }
+ else if (field == "color.a") { return c.color.a; }
+ else if (field == "fontSize") { return c.fontSize; }
+ else if (field == "spacing") { return c.spacing; }
} else if (comp == "Sprite") {
if (!reg.has<esengine::ecs::Sprite>(entity)) return 0.0f;
const auto& c = reg.get<esengine::ecs::Sprite>(entity);
@@ -1229,6 +1240,15 @@ f32 editor_getFloat(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "tileSize.y") { return c.tileSize.y; }
else if (field == "tileSpacing.x") { return c.tileSpacing.x; }
else if (field == "tileSpacing.y") { return c.tileSpacing.y; }
+ } else if (comp == "FlexContainer") {
+ if (!reg.has<esengine::ecs::FlexContainer>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::FlexContainer>(entity);
+ if (field == "gap.x") { return c.gap.x; }
+ else if (field == "gap.y") { return c.gap.y; }
+ else if (field == "padding.left") { return c.padding.left; }
+ else if (field == "padding.top") { return c.padding.top; }
+ else if (field == "padding.right") { return c.padding.right; }
+ else if (field == "padding.bottom") { return c.padding.bottom; }
} else if (comp == "StateVisuals") {
if (!reg.has<esengine::ecs::StateVisuals>(entity)) return 0.0f;
const auto& c = reg.get<esengine::ecs::StateVisuals>(entity);
@@ -1273,57 +1293,37 @@ f32 editor_getFloat(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "slot7Color.b") { return c.slot7Color.b; }
else if (field == "slot7Color.a") { return c.slot7Color.a; }
else if (field == "slot7Scale") { return c.slot7Scale; }
- } else if (comp == "Transform") {
- if (!reg.has<esengine::ecs::Transform>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::Transform>(entity);
- if (field == "position.x") { return c.position.x; }
- else if (field == "position.y") { return c.position.y; }
- else if (field == "position.z") { return c.position.z; }
- else if (field == "scale.x") { return c.scale.x; }
- else if (field == "scale.y") { return c.scale.y; }
- else if (field == "scale.z") { return c.scale.z; }
- else if (field == "rotation.x") { return quatToEulerDeg(c.rotation).x; }
- else if (field == "rotation.y") { return quatToEulerDeg(c.rotation).y; }
- else if (field == "rotation.z") { return quatToEulerDeg(c.rotation).z; }
- } else if (comp == "UIRect") {
- if (!reg.has<esengine::ecs::UIRect>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::UIRect>(entity);
- if (field == "anchorMin.x") { return c.anchorMin.x; }
- else if (field == "anchorMin.y") { return c.anchorMin.y; }
- else if (field == "anchorMax.x") { return c.anchorMax.x; }
- else if (field == "anchorMax.y") { return c.anchorMax.y; }
- else if (field == "offsetMin.x") { return c.offsetMin.x; }
- else if (field == "offsetMin.y") { return c.offsetMin.y; }
- else if (field == "offsetMax.x") { return c.offsetMax.x; }
- else if (field == "offsetMax.y") { return c.offsetMax.y; }
- else if (field == "size.x") { return c.size.x; }
- else if (field == "size.y") { return c.size.y; }
- else if (field == "pivot.x") { return c.pivot.x; }
- else if (field == "pivot.y") { return c.pivot.y; }
- } else if (comp == "UIRenderer") {
- if (!reg.has<esengine::ecs::UIRenderer>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
+ } else if (comp == "ShapeRenderer") {
+ if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
if (field == "color.r") { return c.color.r; }
else if (field == "color.g") { return c.color.g; }
else if (field == "color.b") { return c.color.b; }
else if (field == "color.a") { return c.color.a; }
- else if (field == "uvOffset.x") { return c.uvOffset.x; }
- else if (field == "uvOffset.y") { return c.uvOffset.y; }
- else if (field == "uvScale.x") { return c.uvScale.x; }
- else if (field == "uvScale.y") { return c.uvScale.y; }
- else if (field == "sliceBorder.x") { return c.sliceBorder.x; }
- else if (field == "sliceBorder.y") { return c.sliceBorder.y; }
- else if (field == "sliceBorder.z") { return c.sliceBorder.z; }
- else if (field == "sliceBorder.w") { return c.sliceBorder.w; }
- } else if (comp == "Velocity") {
- if (!reg.has<esengine::ecs::Velocity>(entity)) return 0.0f;
- const auto& c = reg.get<esengine::ecs::Velocity>(entity);
- if (field == "linear.x") { return c.linear.x; }
- else if (field == "linear.y") { return c.linear.y; }
- else if (field == "linear.z") { return c.linear.z; }
- else if (field == "angular.x") { return c.angular.x; }
- else if (field == "angular.y") { return c.angular.y; }
- else if (field == "angular.z") { return c.angular.z; }
+ else if (field == "size.x") { return c.size.x; }
+ else if (field == "size.y") { return c.size.y; }
+ else if (field == "cornerRadius") { return c.cornerRadius; }
+ } else if (comp == "Canvas") {
+ if (!reg.has<esengine::ecs::Canvas>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::Canvas>(entity);
+ if (field == "pixelsPerUnit") { return c.pixelsPerUnit; }
+ else if (field == "matchWidthOrHeight") { return c.matchWidthOrHeight; }
+ else if (field == "backgroundColor.r") { return c.backgroundColor.r; }
+ else if (field == "backgroundColor.g") { return c.backgroundColor.g; }
+ else if (field == "backgroundColor.b") { return c.backgroundColor.b; }
+ else if (field == "backgroundColor.a") { return c.backgroundColor.a; }
+ } else if (comp == "Camera") {
+ if (!reg.has<esengine::ecs::Camera>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::Camera>(entity);
+ if (field == "fov") { return c.fov; }
+ else if (field == "orthoSize") { return c.orthoSize; }
+ else if (field == "nearPlane") { return c.nearPlane; }
+ else if (field == "farPlane") { return c.farPlane; }
+ else if (field == "aspectRatio") { return c.aspectRatio; }
+ else if (field == "viewport.x") { return c.viewport.x; }
+ else if (field == "viewport.y") { return c.viewport.y; }
+ else if (field == "viewport.z") { return c.viewport.z; }
+ else if (field == "viewport.w") { return c.viewport.w; }
}
return 0.0f;
}
@@ -1333,25 +1333,11 @@ f32 editor_getFloat(Registry& reg, u32 e, const std::string& comp, const std::st
bool editor_setInt(Registry& reg, u32 e, const std::string& comp, const std::string& field, i32 value) {
auto entity = static_cast<Entity>(e);
if (!reg.valid(entity)) return false;
- if (comp == "BitmapText") {
- if (!reg.has<esengine::ecs::BitmapText>(entity)) return false;
- auto& c = reg.get<esengine::ecs::BitmapText>(entity);
- if (field == "align") { c.align = static_cast<TextAlign>(value); }
- else if (field == "layer") { c.layer = static_cast<i32>(value); }
- else { return false; }
- return true;
- } else if (comp == "Camera") {
- if (!reg.has<esengine::ecs::Camera>(entity)) return false;
- auto& c = reg.get<esengine::ecs::Camera>(entity);
- if (field == "projectionType") { c.projectionType = static_cast<ProjectionType>(value); }
- else if (field == "priority") { c.priority = static_cast<i32>(value); }
- else if (field == "clearFlags") { c.clearFlags = static_cast<ClearFlags>(value); }
- else { return false; }
- return true;
- } else if (comp == "Canvas") {
- if (!reg.has<esengine::ecs::Canvas>(entity)) return false;
- auto& c = reg.get<esengine::ecs::Canvas>(entity);
- if (field == "scaleMode") { c.scaleMode = static_cast<CanvasScaleMode>(value); }
+ if (comp == "FlexItem") {
+ if (!reg.has<esengine::ecs::FlexItem>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::FlexItem>(entity);
+ if (field == "order") { c.order = static_cast<i32>(value); }
+ else if (field == "alignSelf") { c.alignSelf = static_cast<AlignSelf>(value); }
else { return false; }
return true;
} else if (comp == "BoxCollider") {
@@ -1382,36 +1368,6 @@ bool editor_setInt(Registry& reg, u32 e, const std::string& comp, const std::str
else if (field == "maskBits") { c.maskBits = static_cast<u32>(value); }
else { return false; }
return true;
- } else if (comp == "FlexContainer") {
- if (!reg.has<esengine::ecs::FlexContainer>(entity)) return false;
- auto& c = reg.get<esengine::ecs::FlexContainer>(entity);
- if (field == "direction") { c.direction = static_cast<FlexDirection>(value); }
- else if (field == "wrap") { c.wrap = static_cast<FlexWrap>(value); }
- else if (field == "justifyContent") { c.justifyContent = static_cast<JustifyContent>(value); }
- else if (field == "alignItems") { c.alignItems = static_cast<AlignItems>(value); }
- else if (field == "alignContent") { c.alignContent = static_cast<AlignContent>(value); }
- else { return false; }
- return true;
- } else if (comp == "FlexItem") {
- if (!reg.has<esengine::ecs::FlexItem>(entity)) return false;
- auto& c = reg.get<esengine::ecs::FlexItem>(entity);
- if (field == "order") { c.order = static_cast<i32>(value); }
- else if (field == "alignSelf") { c.alignSelf = static_cast<AlignSelf>(value); }
- else { return false; }
- return true;
- } else if (comp == "GridLayout") {
- if (!reg.has<esengine::ecs::GridLayout>(entity)) return false;
- auto& c = reg.get<esengine::ecs::GridLayout>(entity);
- if (field == "direction") { c.direction = static_cast<GridDirection>(value); }
- else if (field == "crossAxisCount") { c.crossAxisCount = static_cast<i32>(value); }
- else { return false; }
- return true;
- } else if (comp == "Parent") {
- if (!reg.has<esengine::ecs::Parent>(entity)) return false;
- auto& c = reg.get<esengine::ecs::Parent>(entity);
- if (field == "entity") { c.entity = static_cast<Entity>(value); }
- else { return false; }
- return true;
} else if (comp == "ParticleEmitter") {
if (!reg.has<esengine::ecs::ParticleEmitter>(entity)) return false;
auto& c = reg.get<esengine::ecs::ParticleEmitter>(entity);
@@ -1427,17 +1383,17 @@ bool editor_setInt(Registry& reg, u32 e, const std::string& comp, const std::str
else if (field == "simulationSpace") { c.simulationSpace = static_cast<i32>(value); }
else { return false; }
return true;
- } else if (comp == "RigidBody") {
- if (!reg.has<esengine::ecs::RigidBody>(entity)) return false;
- auto& c = reg.get<esengine::ecs::RigidBody>(entity);
- if (field == "bodyType") { c.bodyType = static_cast<BodyType>(value); }
+ } else if (comp == "UIRenderer") {
+ if (!reg.has<esengine::ecs::UIRenderer>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
+ if (field == "visualType") { c.visualType = static_cast<UIVisualType>(value); }
else { return false; }
return true;
- } else if (comp == "ShapeRenderer") {
- if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return false;
- auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
- if (field == "shapeType") { c.shapeType = static_cast<u8>(value); }
- else if (field == "layer") { c.layer = static_cast<i32>(value); }
+ } else if (comp == "GridLayout") {
+ if (!reg.has<esengine::ecs::GridLayout>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::GridLayout>(entity);
+ if (field == "direction") { c.direction = static_cast<GridDirection>(value); }
+ else if (field == "crossAxisCount") { c.crossAxisCount = static_cast<i32>(value); }
else { return false; }
return true;
} else if (comp == "SpineAnimation") {
@@ -1446,12 +1402,41 @@ bool editor_setInt(Registry& reg, u32 e, const std::string& comp, const std::str
if (field == "layer") { c.layer = static_cast<i32>(value); }
else { return false; }
return true;
+ } else if (comp == "RigidBody") {
+ if (!reg.has<esengine::ecs::RigidBody>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::RigidBody>(entity);
+ if (field == "bodyType") { c.bodyType = static_cast<BodyType>(value); }
+ else { return false; }
+ return true;
+ } else if (comp == "BitmapText") {
+ if (!reg.has<esengine::ecs::BitmapText>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::BitmapText>(entity);
+ if (field == "align") { c.align = static_cast<TextAlign>(value); }
+ else if (field == "layer") { c.layer = static_cast<i32>(value); }
+ else { return false; }
+ return true;
} else if (comp == "Sprite") {
if (!reg.has<esengine::ecs::Sprite>(entity)) return false;
auto& c = reg.get<esengine::ecs::Sprite>(entity);
if (field == "layer") { c.layer = static_cast<i32>(value); }
else { return false; }
return true;
+ } else if (comp == "UIMask") {
+ if (!reg.has<esengine::ecs::UIMask>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::UIMask>(entity);
+ if (field == "mode") { c.mode = static_cast<MaskMode>(value); }
+ else { return false; }
+ return true;
+ } else if (comp == "FlexContainer") {
+ if (!reg.has<esengine::ecs::FlexContainer>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::FlexContainer>(entity);
+ if (field == "direction") { c.direction = static_cast<FlexDirection>(value); }
+ else if (field == "wrap") { c.wrap = static_cast<FlexWrap>(value); }
+ else if (field == "justifyContent") { c.justifyContent = static_cast<JustifyContent>(value); }
+ else if (field == "alignItems") { c.alignItems = static_cast<AlignItems>(value); }
+ else if (field == "alignContent") { c.alignContent = static_cast<AlignContent>(value); }
+ else { return false; }
+ return true;
} else if (comp == "StateVisuals") {
if (!reg.has<esengine::ecs::StateVisuals>(entity)) return false;
auto& c = reg.get<esengine::ecs::StateVisuals>(entity);
@@ -1459,16 +1444,31 @@ bool editor_setInt(Registry& reg, u32 e, const std::string& comp, const std::str
else if (field == "transitionFlags") { c.transitionFlags = static_cast<u32>(value); }
else { return false; }
return true;
- } else if (comp == "UIMask") {
- if (!reg.has<esengine::ecs::UIMask>(entity)) return false;
- auto& c = reg.get<esengine::ecs::UIMask>(entity);
- if (field == "mode") { c.mode = static_cast<MaskMode>(value); }
+ } else if (comp == "Parent") {
+ if (!reg.has<esengine::ecs::Parent>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::Parent>(entity);
+ if (field == "entity") { c.entity = static_cast<Entity>(value); }
+ else { return false; }
+ return true;
+ } else if (comp == "ShapeRenderer") {
+ if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
+ if (field == "shapeType") { c.shapeType = static_cast<u8>(value); }
+ else if (field == "layer") { c.layer = static_cast<i32>(value); }
+ else { return false; }
+ return true;
+ } else if (comp == "Canvas") {
+ if (!reg.has<esengine::ecs::Canvas>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::Canvas>(entity);
+ if (field == "scaleMode") { c.scaleMode = static_cast<CanvasScaleMode>(value); }
else { return false; }
return true;
- } else if (comp == "UIRenderer") {
- if (!reg.has<esengine::ecs::UIRenderer>(entity)) return false;
- auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
- if (field == "visualType") { c.visualType = static_cast<UIVisualType>(value); }
+ } else if (comp == "Camera") {
+ if (!reg.has<esengine::ecs::Camera>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::Camera>(entity);
+ if (field == "projectionType") { c.projectionType = static_cast<ProjectionType>(value); }
+ else if (field == "priority") { c.priority = static_cast<i32>(value); }
+ else if (field == "clearFlags") { c.clearFlags = static_cast<ClearFlags>(value); }
else { return false; }
return true;
}
@@ -1480,21 +1480,11 @@ bool editor_setInt(Registry& reg, u32 e, const std::string& comp, const std::str
i32 editor_getInt(Registry& reg, u32 e, const std::string& comp, const std::string& field) {
auto entity = static_cast<Entity>(e);
if (!reg.valid(entity)) return 0;
- if (comp == "BitmapText") {
- if (!reg.has<esengine::ecs::BitmapText>(entity)) return 0;
- const auto& c = reg.get<esengine::ecs::BitmapText>(entity);
- if (field == "align") { return static_cast<i32>(c.align); }
- else if (field == "layer") { return static_cast<i32>(c.layer); }
- } else if (comp == "Camera") {
- if (!reg.has<esengine::ecs::Camera>(entity)) return 0;
- const auto& c = reg.get<esengine::ecs::Camera>(entity);
- if (field == "projectionType") { return static_cast<i32>(c.projectionType); }
- else if (field == "priority") { return static_cast<i32>(c.priority); }
- else if (field == "clearFlags") { return static_cast<i32>(c.clearFlags); }
- } else if (comp == "Canvas") {
- if (!reg.has<esengine::ecs::Canvas>(entity)) return 0;
- const auto& c = reg.get<esengine::ecs::Canvas>(entity);
- if (field == "scaleMode") { return static_cast<i32>(c.scaleMode); }
+ if (comp == "FlexItem") {
+ if (!reg.has<esengine::ecs::FlexItem>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::FlexItem>(entity);
+ if (field == "order") { return static_cast<i32>(c.order); }
+ else if (field == "alignSelf") { return static_cast<i32>(c.alignSelf); }
} else if (comp == "BoxCollider") {
if (!reg.has<esengine::ecs::BoxCollider>(entity)) return 0;
const auto& c = reg.get<esengine::ecs::BoxCollider>(entity);
@@ -1515,28 +1505,6 @@ i32 editor_getInt(Registry& reg, u32 e, const std::string& comp, const std::stri
const auto& c = reg.get<esengine::ecs::SegmentCollider>(entity);
if (field == "categoryBits") { return static_cast<i32>(c.categoryBits); }
else if (field == "maskBits") { return static_cast<i32>(c.maskBits); }
- } else if (comp == "FlexContainer") {
- if (!reg.has<esengine::ecs::FlexContainer>(entity)) return 0;
- const auto& c = reg.get<esengine::ecs::FlexContainer>(entity);
- if (field == "direction") { return static_cast<i32>(c.direction); }
- else if (field == "wrap") { return static_cast<i32>(c.wrap); }
- else if (field == "justifyContent") { return static_cast<i32>(c.justifyContent); }
- else if (field == "alignItems") { return static_cast<i32>(c.alignItems); }
- else if (field == "alignContent") { return static_cast<i32>(c.alignContent); }
- } else if (comp == "FlexItem") {
- if (!reg.has<esengine::ecs::FlexItem>(entity)) return 0;
- const auto& c = reg.get<esengine::ecs::FlexItem>(entity);
- if (field == "order") { return static_cast<i32>(c.order); }
- else if (field == "alignSelf") { return static_cast<i32>(c.alignSelf); }
- } else if (comp == "GridLayout") {
- if (!reg.has<esengine::ecs::GridLayout>(entity)) return 0;
- const auto& c = reg.get<esengine::ecs::GridLayout>(entity);
- if (field == "direction") { return static_cast<i32>(c.direction); }
- else if (field == "crossAxisCount") { return static_cast<i32>(c.crossAxisCount); }
- } else if (comp == "Parent") {
- if (!reg.has<esengine::ecs::Parent>(entity)) return 0;
- const auto& c = reg.get<esengine::ecs::Parent>(entity);
- if (field == "entity") { return static_cast<i32>(static_cast<u32>(c.entity)); }
} else if (comp == "ParticleEmitter") {
if (!reg.has<esengine::ecs::ParticleEmitter>(entity)) return 0;
const auto& c = reg.get<esengine::ecs::ParticleEmitter>(entity);
@@ -1550,36 +1518,68 @@ i32 editor_getInt(Registry& reg, u32 e, const std::string& comp, const std::stri
else if (field == "blendMode") { return static_cast<i32>(c.blendMode); }
else if (field == "layer") { return static_cast<i32>(c.layer); }
else if (field == "simulationSpace") { return static_cast<i32>(c.simulationSpace); }
+ } else if (comp == "UIRenderer") {
+ if (!reg.has<esengine::ecs::UIRenderer>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
+ if (field == "visualType") { return static_cast<i32>(c.visualType); }
+ } else if (comp == "GridLayout") {
+ if (!reg.has<esengine::ecs::GridLayout>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::GridLayout>(entity);
+ if (field == "direction") { return static_cast<i32>(c.direction); }
+ else if (field == "crossAxisCount") { return static_cast<i32>(c.crossAxisCount); }
+ } else if (comp == "SpineAnimation") {
+ if (!reg.has<esengine::ecs::SpineAnimation>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::SpineAnimation>(entity);
+ if (field == "layer") { return static_cast<i32>(c.layer); }
} else if (comp == "RigidBody") {
if (!reg.has<esengine::ecs::RigidBody>(entity)) return 0;
const auto& c = reg.get<esengine::ecs::RigidBody>(entity);
if (field == "bodyType") { return static_cast<i32>(c.bodyType); }
- } else if (comp == "ShapeRenderer") {
- if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return 0;
- const auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
- if (field == "shapeType") { return static_cast<i32>(c.shapeType); }
+ } else if (comp == "BitmapText") {
+ if (!reg.has<esengine::ecs::BitmapText>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::BitmapText>(entity);
+ if (field == "align") { return static_cast<i32>(c.align); }
else if (field == "layer") { return static_cast<i32>(c.layer); }
- } else if (comp == "SpineAnimation") {
- if (!reg.has<esengine::ecs::SpineAnimation>(entity)) return 0;
- const auto& c = reg.get<esengine::ecs::SpineAnimation>(entity);
- if (field == "layer") { return static_cast<i32>(c.layer); }
} else if (comp == "Sprite") {
if (!reg.has<esengine::ecs::Sprite>(entity)) return 0;
const auto& c = reg.get<esengine::ecs::Sprite>(entity);
if (field == "layer") { return static_cast<i32>(c.layer); }
+ } else if (comp == "UIMask") {
+ if (!reg.has<esengine::ecs::UIMask>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::UIMask>(entity);
+ if (field == "mode") { return static_cast<i32>(c.mode); }
+ } else if (comp == "FlexContainer") {
+ if (!reg.has<esengine::ecs::FlexContainer>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::FlexContainer>(entity);
+ if (field == "direction") { return static_cast<i32>(c.direction); }
+ else if (field == "wrap") { return static_cast<i32>(c.wrap); }
+ else if (field == "justifyContent") { return static_cast<i32>(c.justifyContent); }
+ else if (field == "alignItems") { return static_cast<i32>(c.alignItems); }
+ else if (field == "alignContent") { return static_cast<i32>(c.alignContent); }
} else if (comp == "StateVisuals") {
if (!reg.has<esengine::ecs::StateVisuals>(entity)) return 0;
const auto& c = reg.get<esengine::ecs::StateVisuals>(entity);
if (field == "targetGraphic") { return static_cast<i32>(static_cast<u32>(c.targetGraphic)); }
else if (field == "transitionFlags") { return static_cast<i32>(c.transitionFlags); }
- } else if (comp == "UIMask") {
- if (!reg.has<esengine::ecs::UIMask>(entity)) return 0;
- const auto& c = reg.get<esengine::ecs::UIMask>(entity);
- if (field == "mode") { return static_cast<i32>(c.mode); }
- } else if (comp == "UIRenderer") {
- if (!reg.has<esengine::ecs::UIRenderer>(entity)) return 0;
- const auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
- if (field == "visualType") { return static_cast<i32>(c.visualType); }
+ } else if (comp == "Parent") {
+ if (!reg.has<esengine::ecs::Parent>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::Parent>(entity);
+ if (field == "entity") { return static_cast<i32>(static_cast<u32>(c.entity)); }
+ } else if (comp == "ShapeRenderer") {
+ if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
+ if (field == "shapeType") { return static_cast<i32>(c.shapeType); }
+ else if (field == "layer") { return static_cast<i32>(c.layer); }
+ } else if (comp == "Canvas") {
+ if (!reg.has<esengine::ecs::Canvas>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::Canvas>(entity);
+ if (field == "scaleMode") { return static_cast<i32>(c.scaleMode); }
+ } else if (comp == "Camera") {
+ if (!reg.has<esengine::ecs::Camera>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::Camera>(entity);
+ if (field == "projectionType") { return static_cast<i32>(c.projectionType); }
+ else if (field == "priority") { return static_cast<i32>(c.priority); }
+ else if (field == "clearFlags") { return static_cast<i32>(c.clearFlags); }
}
return 0;
}
@@ -1589,19 +1589,7 @@ i32 editor_getInt(Registry& reg, u32 e, const std::string& comp, const std::stri
bool editor_setBool(Registry& reg, u32 e, const std::string& comp, const std::string& field, bool value) {
auto entity = static_cast<Entity>(e);
if (!reg.valid(entity)) return false;
- if (comp == "BitmapText") {
- if (!reg.has<esengine::ecs::BitmapText>(entity)) return false;
- auto& c = reg.get<esengine::ecs::BitmapText>(entity);
- if (field == "enabled") { c.enabled = value; }
- else { return false; }
- return true;
- } else if (comp == "Camera") {
- if (!reg.has<esengine::ecs::Camera>(entity)) return false;
- auto& c = reg.get<esengine::ecs::Camera>(entity);
- if (field == "isActive") { c.isActive = value; }
- else { return false; }
- return true;
- } else if (comp == "BoxCollider") {
+ if (comp == "BoxCollider") {
if (!reg.has<esengine::ecs::BoxCollider>(entity)) return false;
auto& c = reg.get<esengine::ecs::BoxCollider>(entity);
if (field == "isSensor") { c.isSensor = value; }
@@ -1629,14 +1617,6 @@ bool editor_setBool(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "enabled") { c.enabled = value; }
else { return false; }
return true;
- } else if (comp == "Interactable") {
- if (!reg.has<esengine::ecs::Interactable>(entity)) return false;
- auto& c = reg.get<esengine::ecs::Interactable>(entity);
- if (field == "enabled") { c.enabled = value; }
- else if (field == "blockRaycast") { c.blockRaycast = value; }
- else if (field == "raycastTarget") { c.raycastTarget = value; }
- else { return false; }
- return true;
} else if (comp == "ParticleEmitter") {
if (!reg.has<esengine::ecs::ParticleEmitter>(entity)) return false;
auto& c = reg.get<esengine::ecs::ParticleEmitter>(entity);
@@ -1646,17 +1626,9 @@ bool editor_setBool(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "enabled") { c.enabled = value; }
else { return false; }
return true;
- } else if (comp == "RigidBody") {
- if (!reg.has<esengine::ecs::RigidBody>(entity)) return false;
- auto& c = reg.get<esengine::ecs::RigidBody>(entity);
- if (field == "fixedRotation") { c.fixedRotation = value; }
- else if (field == "bullet") { c.bullet = value; }
- else if (field == "enabled") { c.enabled = value; }
- else { return false; }
- return true;
- } else if (comp == "ShapeRenderer") {
- if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return false;
- auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
+ } else if (comp == "UIRenderer") {
+ if (!reg.has<esengine::ecs::UIRenderer>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
if (field == "enabled") { c.enabled = value; }
else { return false; }
return true;
@@ -1670,12 +1642,12 @@ bool editor_setBool(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "enabled") { c.enabled = value; }
else { return false; }
return true;
- } else if (comp == "Sprite") {
- if (!reg.has<esengine::ecs::Sprite>(entity)) return false;
- auto& c = reg.get<esengine::ecs::Sprite>(entity);
- if (field == "flipX") { c.flipX = value; }
- else if (field == "flipY") { c.flipY = value; }
- else if (field == "enabled") { c.enabled = value; }
+ } else if (comp == "Interactable") {
+ if (!reg.has<esengine::ecs::Interactable>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::Interactable>(entity);
+ if (field == "enabled") { c.enabled = value; }
+ else if (field == "blockRaycast") { c.blockRaycast = value; }
+ else if (field == "raycastTarget") { c.raycastTarget = value; }
else { return false; }
return true;
} else if (comp == "UIInteraction") {
@@ -1687,18 +1659,46 @@ bool editor_setBool(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "justReleased") { c.justReleased = value; }
else { return false; }
return true;
+ } else if (comp == "RigidBody") {
+ if (!reg.has<esengine::ecs::RigidBody>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::RigidBody>(entity);
+ if (field == "fixedRotation") { c.fixedRotation = value; }
+ else if (field == "bullet") { c.bullet = value; }
+ else if (field == "enabled") { c.enabled = value; }
+ else { return false; }
+ return true;
+ } else if (comp == "BitmapText") {
+ if (!reg.has<esengine::ecs::BitmapText>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::BitmapText>(entity);
+ if (field == "enabled") { c.enabled = value; }
+ else { return false; }
+ return true;
+ } else if (comp == "Sprite") {
+ if (!reg.has<esengine::ecs::Sprite>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::Sprite>(entity);
+ if (field == "flipX") { c.flipX = value; }
+ else if (field == "flipY") { c.flipY = value; }
+ else if (field == "enabled") { c.enabled = value; }
+ else { return false; }
+ return true;
} else if (comp == "UIMask") {
if (!reg.has<esengine::ecs::UIMask>(entity)) return false;
auto& c = reg.get<esengine::ecs::UIMask>(entity);
if (field == "enabled") { c.enabled = value; }
else { return false; }
return true;
- } else if (comp == "UIRenderer") {
- if (!reg.has<esengine::ecs::UIRenderer>(entity)) return false;
- auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
+ } else if (comp == "ShapeRenderer") {
+ if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
if (field == "enabled") { c.enabled = value; }
else { return false; }
return true;
+ } else if (comp == "Camera") {
+ if (!reg.has<esengine::ecs::Camera>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::Camera>(entity);
+ if (field == "isActive") { c.isActive = value; }
+ else { return false; }
+ return true;
}
return false;
}
@@ -1708,15 +1708,7 @@ bool editor_setBool(Registry& reg, u32 e, const std::string& comp, const std::st
bool editor_getBool(Registry& reg, u32 e, const std::string& comp, const std::string& field) {
auto entity = static_cast<Entity>(e);
if (!reg.valid(entity)) return false;
- if (comp == "BitmapText") {
- if (!reg.has<esengine::ecs::BitmapText>(entity)) return false;
- const auto& c = reg.get<esengine::ecs::BitmapText>(entity);
- if (field == "enabled") { return c.enabled; }
- } else if (comp == "Camera") {
- if (!reg.has<esengine::ecs::Camera>(entity)) return false;
- const auto& c = reg.get<esengine::ecs::Camera>(entity);
- if (field == "isActive") { return c.isActive; }
- } else if (comp == "BoxCollider") {
+ if (comp == "BoxCollider") {
if (!reg.has<esengine::ecs::BoxCollider>(entity)) return false;
const auto& c = reg.get<esengine::ecs::BoxCollider>(entity);
if (field == "isSensor") { return c.isSensor; }
@@ -1736,12 +1728,6 @@ bool editor_getBool(Registry& reg, u32 e, const std::string& comp, const std::st
const auto& c = reg.get<esengine::ecs::SegmentCollider>(entity);
if (field == "isSensor") { return c.isSensor; }
else if (field == "enabled") { return c.enabled; }
- } else if (comp == "Interactable") {
- if (!reg.has<esengine::ecs::Interactable>(entity)) return false;
- const auto& c = reg.get<esengine::ecs::Interactable>(entity);
- if (field == "enabled") { return c.enabled; }
- else if (field == "blockRaycast") { return c.blockRaycast; }
- else if (field == "raycastTarget") { return c.raycastTarget; }
} else if (comp == "ParticleEmitter") {
if (!reg.has<esengine::ecs::ParticleEmitter>(entity)) return false;
const auto& c = reg.get<esengine::ecs::ParticleEmitter>(entity);
@@ -1749,15 +1735,9 @@ bool editor_getBool(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "playOnStart") { return c.playOnStart; }
else if (field == "spriteLoop") { return c.spriteLoop; }
else if (field == "enabled") { return c.enabled; }
- } else if (comp == "RigidBody") {
- if (!reg.has<esengine::ecs::RigidBody>(entity)) return false;
- const auto& c = reg.get<esengine::ecs::RigidBody>(entity);
- if (field == "fixedRotation") { return c.fixedRotation; }
- else if (field == "bullet") { return c.bullet; }
- else if (field == "enabled") { return c.enabled; }
- } else if (comp == "ShapeRenderer") {
- if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return false;
- const auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
+ } else if (comp == "UIRenderer") {
+ if (!reg.has<esengine::ecs::UIRenderer>(entity)) return false;
+ const auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
if (field == "enabled") { return c.enabled; }
} else if (comp == "SpineAnimation") {
if (!reg.has<esengine::ecs::SpineAnimation>(entity)) return false;
@@ -1767,12 +1747,12 @@ bool editor_getBool(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "flipX") { return c.flipX; }
else if (field == "flipY") { return c.flipY; }
else if (field == "enabled") { return c.enabled; }
- } else if (comp == "Sprite") {
- if (!reg.has<esengine::ecs::Sprite>(entity)) return false;
- const auto& c = reg.get<esengine::ecs::Sprite>(entity);
- if (field == "flipX") { return c.flipX; }
- else if (field == "flipY") { return c.flipY; }
- else if (field == "enabled") { return c.enabled; }
+ } else if (comp == "Interactable") {
+ if (!reg.has<esengine::ecs::Interactable>(entity)) return false;
+ const auto& c = reg.get<esengine::ecs::Interactable>(entity);
+ if (field == "enabled") { return c.enabled; }
+ else if (field == "blockRaycast") { return c.blockRaycast; }
+ else if (field == "raycastTarget") { return c.raycastTarget; }
} else if (comp == "UIInteraction") {
if (!reg.has<esengine::ecs::UIInteraction>(entity)) return false;
const auto& c = reg.get<esengine::ecs::UIInteraction>(entity);
@@ -1780,14 +1760,34 @@ bool editor_getBool(Registry& reg, u32 e, const std::string& comp, const std::st
else if (field == "pressed") { return c.pressed; }
else if (field == "justPressed") { return c.justPressed; }
else if (field == "justReleased") { return c.justReleased; }
+ } else if (comp == "RigidBody") {
+ if (!reg.has<esengine::ecs::RigidBody>(entity)) return false;
+ const auto& c = reg.get<esengine::ecs::RigidBody>(entity);
+ if (field == "fixedRotation") { return c.fixedRotation; }
+ else if (field == "bullet") { return c.bullet; }
+ else if (field == "enabled") { return c.enabled; }
+ } else if (comp == "BitmapText") {
+ if (!reg.has<esengine::ecs::BitmapText>(entity)) return false;
+ const auto& c = reg.get<esengine::ecs::BitmapText>(entity);
+ if (field == "enabled") { return c.enabled; }
+ } else if (comp == "Sprite") {
+ if (!reg.has<esengine::ecs::Sprite>(entity)) return false;
+ const auto& c = reg.get<esengine::ecs::Sprite>(entity);
+ if (field == "flipX") { return c.flipX; }
+ else if (field == "flipY") { return c.flipY; }
+ else if (field == "enabled") { return c.enabled; }
} else if (comp == "UIMask") {
if (!reg.has<esengine::ecs::UIMask>(entity)) return false;
const auto& c = reg.get<esengine::ecs::UIMask>(entity);
if (field == "enabled") { return c.enabled; }
- } else if (comp == "UIRenderer") {
- if (!reg.has<esengine::ecs::UIRenderer>(entity)) return false;
- const auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
+ } else if (comp == "ShapeRenderer") {
+ if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) return false;
+ const auto& c = reg.get<esengine::ecs::ShapeRenderer>(entity);
if (field == "enabled") { return c.enabled; }
+ } else if (comp == "Camera") {
+ if (!reg.has<esengine::ecs::Camera>(entity)) return false;
+ const auto& c = reg.get<esengine::ecs::Camera>(entity);
+ if (field == "isActive") { return c.isActive; }
}
return false;
}
diff --git a/src/esengine/bindings/WebBindings.generated.cpp b/src/esengine/bindings/WebBindings.generated.cpp
index da06ef600..43f9db58c 100644
--- a/src/esengine/bindings/WebBindings.generated.cpp
+++ b/src/esengine/bindings/WebBindings.generated.cpp
@@ -80,27 +80,46 @@ EMSCRIPTEN_BINDINGS(esengine_math) {
// =============================================================================
EMSCRIPTEN_BINDINGS(esengine_enums) {
+ enum_<esengine::ecs::AlignSelf>("AlignSelf")
+ .value("Auto", esengine::ecs::AlignSelf::Auto)
+ .value("Start", esengine::ecs::AlignSelf::Start)
+ .value("Center", esengine::ecs::AlignSelf::Center)
+ .value("End", esengine::ecs::AlignSelf::End)
+ .value("Stretch", esengine::ecs::AlignSelf::Stretch);
+
+ enum_<esengine::ecs::EmitterShape>("EmitterShape")
+ .value("Point", esengine::ecs::EmitterShape::Point)
+ .value("Circle", esengine::ecs::EmitterShape::Circle)
+ .value("Rectangle", esengine::ecs::EmitterShape::Rectangle)
+ .value("Cone", esengine::ecs::EmitterShape::Cone);
+
+ enum_<esengine::ecs::SimulationSpace>("SimulationSpace")
+ .value("World", esengine::ecs::SimulationSpace::World)
+ .value("Local", esengine::ecs::SimulationSpace::Local);
+
+ enum_<esengine::ecs::UIVisualType>("UIVisualType")
+ .value("None", esengine::ecs::UIVisualType::None)
+ .value("SolidColor", esengine::ecs::UIVisualType::SolidColor)
+ .value("Image", esengine::ecs::UIVisualType::Image)
+ .value("NineSlice", esengine::ecs::UIVisualType::NineSlice);
+
+ enum_<esengine::ecs::GridDirection>("GridDirection")
+ .value("Vertical", esengine::ecs::GridDirection::Vertical)
+ .value("Horizontal", esengine::ecs::GridDirection::Horizontal);
+
+ enum_<esengine::ecs::BodyType>("BodyType")
+ .value("Static", esengine::ecs::BodyType::Static)
+ .value("Kinematic", esengine::ecs::BodyType::Kinematic)
+ .value("Dynamic", esengine::ecs::BodyType::Dynamic);
+
enum_<esengine::ecs::TextAlign>("TextAlign")
.value("Left", esengine::ecs::TextAlign::Left)
.value("Center", esengine::ecs::TextAlign::Center)
.value("Right", esengine::ecs::TextAlign::Right);
- enum_<esengine::ecs::ProjectionType>("ProjectionType")
- .value("Perspective", esengine::ecs::ProjectionType::Perspective)
- .value("Orthographic", esengine::ecs::ProjectionType::Orthographic);
-
- enum_<esengine::ecs::ClearFlags>("ClearFlags")
- .value("Nothing", esengine::ecs::ClearFlags::Nothing)
- .value("Color", esengine::ecs::ClearFlags::Color)
- .value("Depth", esengine::ecs::ClearFlags::Depth)
- .value("ColorAndDepth", esengine::ecs::ClearFlags::ColorAndDepth);
-
- enum_<esengine::ecs::CanvasScaleMode>("CanvasScaleMode")
- .value("FixedWidth", esengine::ecs::CanvasScaleMode::FixedWidth)
- .value("FixedHeight", esengine::ecs::CanvasScaleMode::FixedHeight)
- .value("Expand", esengine::ecs::CanvasScaleMode::Expand)
- .value("Shrink", esengine::ecs::CanvasScaleMode::Shrink)
- .value("Match", esengine::ecs::CanvasScaleMode::Match);
+ enum_<esengine::ecs::MaskMode>("MaskMode")
+ .value("Scissor", esengine::ecs::MaskMode::Scissor)
+ .value("Stencil", esengine::ecs::MaskMode::Stencil);
enum_<esengine::ecs::FlexDirection>("FlexDirection")
.value("Row", esengine::ecs::FlexDirection::Row)
@@ -134,41 +153,22 @@ EMSCRIPTEN_BINDINGS(esengine_enums) {
.value("SpaceBetween", esengine::ecs::AlignContent::SpaceBetween)
.value("SpaceAround", esengine::ecs::AlignContent::SpaceAround);
- enum_<esengine::ecs::AlignSelf>("AlignSelf")
- .value("Auto", esengine::ecs::AlignSelf::Auto)
- .value("Start", esengine::ecs::AlignSelf::Start)
- .value("Center", esengine::ecs::AlignSelf::Center)
- .value("End", esengine::ecs::AlignSelf::End)
- .value("Stretch", esengine::ecs::AlignSelf::Stretch);
-
- enum_<esengine::ecs::GridDirection>("GridDirection")
- .value("Vertical", esengine::ecs::GridDirection::Vertical)
- .value("Horizontal", esengine::ecs::GridDirection::Horizontal);
-
- enum_<esengine::ecs::EmitterShape>("EmitterShape")
- .value("Point", esengine::ecs::EmitterShape::Point)
- .value("Circle", esengine::ecs::EmitterShape::Circle)
- .value("Rectangle", esengine::ecs::EmitterShape::Rectangle)
- .value("Cone", esengine::ecs::EmitterShape::Cone);
-
- enum_<esengine::ecs::SimulationSpace>("SimulationSpace")
- .value("World", esengine::ecs::SimulationSpace::World)
- .value("Local", esengine::ecs::SimulationSpace::Local);
-
- enum_<esengine::ecs::BodyType>("BodyType")
- .value("Static", esengine::ecs::BodyType::Static)
- .value("Kinematic", esengine::ecs::BodyType::Kinematic)
- .value("Dynamic", esengine::ecs::BodyType::Dynamic);
+ enum_<esengine::ecs::CanvasScaleMode>("CanvasScaleMode")
+ .value("FixedWidth", esengine::ecs::CanvasScaleMode::FixedWidth)
+ .value("FixedHeight", esengine::ecs::CanvasScaleMode::FixedHeight)
+ .value("Expand", esengine::ecs::CanvasScaleMode::Expand)
+ .value("Shrink", esengine::ecs::CanvasScaleMode::Shrink)
+ .value("Match", esengine::ecs::CanvasScaleMode::Match);
- enum_<esengine::ecs::MaskMode>("MaskMode")
- .value("Scissor", esengine::ecs::MaskMode::Scissor)
- .value("Stencil", esengine::ecs::MaskMode::Stencil);
+ enum_<esengine::ecs::ProjectionType>("ProjectionType")
+ .value("Perspective", esengine::ecs::ProjectionType::Perspective)
+ .value("Orthographic", esengine::ecs::ProjectionType::Orthographic);
- enum_<esengine::ecs::UIVisualType>("UIVisualType")
- .value("None", esengine::ecs::UIVisualType::None)
- .value("SolidColor", esengine::ecs::UIVisualType::SolidColor)
- .value("Image", esengine::ecs::UIVisualType::Image)
- .value("NineSlice", esengine::ecs::UIVisualType::NineSlice);
+ enum_<esengine::ecs::ClearFlags>("ClearFlags")
+ .value("Nothing", esengine::ecs::ClearFlags::Nothing)
+ .value("Color", esengine::ecs::ClearFlags::Color)
+ .value("Depth", esengine::ecs::ClearFlags::Depth)
+ .value("ColorAndDepth", esengine::ecs::ClearFlags::ColorAndDepth);
}
@@ -176,148 +176,6 @@ EMSCRIPTEN_BINDINGS(esengine_enums) {
// Components
// =============================================================================
-struct BitmapTextJS {
- std::string text;
- glm::vec4 color;
- f32 fontSize;
- i32 align;
- f32 spacing;
- i32 layer;
- u32 font;
- bool enabled;
-};
-
-esengine::ecs::BitmapText bitmaptextFromJS(const BitmapTextJS& js) {
- esengine::ecs::BitmapText c;
- c.text = js.text;
- c.color = js.color;
- c.fontSize = js.fontSize;
- c.align = static_cast<TextAlign>(js.align);
- c.spacing = js.spacing;
- c.layer = js.layer;
- c.font = resource::BitmapFontHandle(js.font);
- c.enabled = js.enabled;
- return c;
-}
-
-BitmapTextJS bitmaptextToJS(const esengine::ecs::BitmapText& c) {
- BitmapTextJS js;
- js.text = c.text;
- js.color = c.color;
- js.fontSize = c.fontSize;
- js.align = static_cast<i32>(c.align);
- js.spacing = c.spacing;
- js.layer = c.layer;
- js.font = c.font.id();
- js.enabled = c.enabled;
- return js;
-}
-
-struct CameraJS {
- i32 projectionType;
- f32 fov;
- f32 orthoSize;
- f32 nearPlane;
- f32 farPlane;
- f32 aspectRatio;
- bool isActive;
- i32 priority;
- glm::vec4 viewport;
- i32 clearFlags;
-};
-
-esengine::ecs::Camera cameraFromJS(const CameraJS& js) {
- esengine::ecs::Camera c;
- c.projectionType = static_cast<ProjectionType>(js.projectionType);
- c.fov = js.fov;
- c.orthoSize = js.orthoSize;
- c.nearPlane = js.nearPlane;
- c.farPlane = js.farPlane;
- c.aspectRatio = js.aspectRatio;
- c.isActive = js.isActive;
- c.priority = js.priority;
- c.viewport = js.viewport;
- c.clearFlags = static_cast<ClearFlags>(js.clearFlags);
- return c;
-}
-
-CameraJS cameraToJS(const esengine::ecs::Camera& c) {
- CameraJS js;
- js.projectionType = static_cast<i32>(c.projectionType);
- js.fov = c.fov;
- js.orthoSize = c.orthoSize;
- js.nearPlane = c.nearPlane;
- js.farPlane = c.farPlane;
- js.aspectRatio = c.aspectRatio;
- js.isActive = c.isActive;
- js.priority = c.priority;
- js.viewport = c.viewport;
- js.clearFlags = static_cast<i32>(c.clearFlags);
- return js;
-}
-
-struct CanvasJS {
- glm::uvec2 designResolution;
- f32 pixelsPerUnit;
- i32 scaleMode;
- f32 matchWidthOrHeight;
- glm::vec4 backgroundColor;
-};
-
-esengine::ecs::Canvas canvasFromJS(const CanvasJS& js) {
- esengine::ecs::Canvas c;
- c.designResolution = js.designResolution;
- c.pixelsPerUnit = js.pixelsPerUnit;
- c.scaleMode = static_cast<CanvasScaleMode>(js.scaleMode);
- c.matchWidthOrHeight = js.matchWidthOrHeight;
- c.backgroundColor = js.backgroundColor;
- return c;
-}
-
-CanvasJS canvasToJS(const esengine::ecs::Canvas& c) {
- CanvasJS js;
- js.designResolution = c.designResolution;
- js.pixelsPerUnit = c.pixelsPerUnit;
- js.scaleMode = static_cast<i32>(c.scaleMode);
- js.matchWidthOrHeight = c.matchWidthOrHeight;
- js.backgroundColor = c.backgroundColor;
- return js;
-}
-
-struct FlexContainerJS {
- i32 direction;
- i32 wrap;
- i32 justifyContent;
- i32 alignItems;
- i32 alignContent;
- glm::vec2 gap;
- Padding padding;
-};
-
-esengine::ecs::FlexContainer flexcontainerFromJS(const FlexContainerJS& js) {
- esengine::ecs::FlexContainer c;
- c.direction = static_cast<FlexDirection>(js.direction);
- c.wrap = static_cast<FlexWrap>(js.wrap);
- c.justifyContent = static_cast<JustifyContent>(js.justifyContent);
- c.alignItems = static_cast<AlignItems>(js.alignItems);
- c.alignContent = static_cast<AlignContent>(js.alignContent);
- c.gap = js.gap;
- c.padding = js.padding;
- return c;
-}
-
-FlexContainerJS flexcontainerToJS(const esengine::ecs::FlexContainer& c) {
- FlexContainerJS js;
- js.direction = static_cast<i32>(c.direction);
- js.wrap = static_cast<i32>(c.wrap);
- js.justifyContent = static_cast<i32>(c.justifyContent);
- js.alignItems = static_cast<i32>(c.alignItems);
- js.alignContent = static_cast<i32>(c.alignContent);
- js.gap = c.gap;
- js.padding = c.padding;
- return js;
-}
-
struct FlexItemJS {
f32 flexGrow;
f32 flexShrink;
@@ -367,65 +225,6 @@ FlexItemJS flexitemToJS(const esengine::ecs::FlexItem& c) {
return js;
}
-struct GridLayoutJS {
- i32 direction;
- i32 crossAxisCount;
- glm::vec2 itemSize;
- glm::vec2 spacing;
-};
-
-esengine::ecs::GridLayout gridlayoutFromJS(const GridLayoutJS& js) {
- esengine::ecs::GridLayout c;
- c.direction = static_cast<GridDirection>(js.direction);
- c.crossAxisCount = js.crossAxisCount;
- c.itemSize = js.itemSize;
- c.spacing = js.spacing;
- return c;
-}
-
-GridLayoutJS gridlayoutToJS(const esengine::ecs::GridLayout& c) {
- GridLayoutJS js;
- js.direction = static_cast<i32>(c.direction);
- js.crossAxisCount = c.crossAxisCount;
- js.itemSize = c.itemSize;
- js.spacing = c.spacing;
- return js;
-}
-
-struct ParentJS {
- u32 entity;
-};
-
-esengine::ecs::Parent parentFromJS(const ParentJS& js) {
- esengine::ecs::Parent c;
- c.entity = Entity(js.entity);
- return c;
-}
-
-ParentJS parentToJS(const esengine::ecs::Parent& c) {
- ParentJS js;
- js.entity = static_cast<u32>(c.entity);
- return js;
-}
-
-struct ChildrenJS {
- std::vector<u32> entities;
-};
-
-esengine::ecs::Children childrenFromJS(const ChildrenJS& js) {
- esengine::ecs::Children c;
- c.entities.reserve(js.entities.size());
- for (auto v : js.entities) c.entities.push_back(Entity(v));
- return c;
-}
-
-ChildrenJS childrenToJS(const esengine::ecs::Children& c) {
- ChildrenJS js;
- js.entities.reserve(c.entities.size());
- for (auto e : c.entities) js.entities.push_back(static_cast<u32>(e));
- return js;
-}
-
struct ParticleEmitterJS {
f32 rate;
i32 burstCount;
@@ -562,6 +361,68 @@ ParticleEmitterJS particleemitterToJS(const esengine::ecs::ParticleEmitter& c) {
return js;
}
+struct UIRendererJS {
+ i32 visualType;
+ u32 texture;
+ glm::vec4 color;
+ glm::vec2 uvOffset;
+ glm::vec2 uvScale;
+ glm::vec4 sliceBorder;
+ u32 material;
+ bool enabled;
+};
+
+esengine::ecs::UIRenderer uirendererFromJS(const UIRendererJS& js) {
+ esengine::ecs::UIRenderer c;
+ c.visualType = static_cast<UIVisualType>(js.visualType);
+ c.texture = resource::TextureHandle(js.texture);
+ c.color = js.color;
+ c.uvOffset = js.uvOffset;
+ c.uvScale = js.uvScale;
+ c.sliceBorder = js.sliceBorder;
+ c.material = js.material;
+ c.enabled = js.enabled;
+ return c;
+}
+
+UIRendererJS uirendererToJS(const esengine::ecs::UIRenderer& c) {
+ UIRendererJS js;
+ js.visualType = static_cast<i32>(c.visualType);
+ js.texture = c.texture.id();
+ js.color = c.color;
+ js.uvOffset = c.uvOffset;
+ js.uvScale = c.uvScale;
+ js.sliceBorder = c.sliceBorder;
+ js.material = c.material;
+ js.enabled = c.enabled;
+ return js;
+}
+
+struct GridLayoutJS {
+ i32 direction;
+ i32 crossAxisCount;
+ glm::vec2 itemSize;
+ glm::vec2 spacing;
+};
+
+esengine::ecs::GridLayout gridlayoutFromJS(const GridLayoutJS& js) {
+ esengine::ecs::GridLayout c;
+ c.direction = static_cast<GridDirection>(js.direction);
+ c.crossAxisCount = js.crossAxisCount;
+ c.itemSize = js.itemSize;
+ c.spacing = js.spacing;
+ return c;
+}
+
+GridLayoutJS gridlayoutToJS(const esengine::ecs::GridLayout& c) {
+ GridLayoutJS js;
+ js.direction = static_cast<i32>(c.direction);
+ js.crossAxisCount = c.crossAxisCount;
+ js.itemSize = c.itemSize;
+ js.spacing = c.spacing;
+ return js;
+}
+
struct RigidBodyJS {
i32 bodyType;
f32 gravityScale;
@@ -596,6 +457,43 @@ RigidBodyJS rigidbodyToJS(const esengine::ecs::RigidBody& c) {
return js;
}
+struct BitmapTextJS {
+ std::string text;
+ glm::vec4 color;
+ f32 fontSize;
+ i32 align;
+ f32 spacing;
+ i32 layer;
+ u32 font;
+ bool enabled;
+};
+
+esengine::ecs::BitmapText bitmaptextFromJS(const BitmapTextJS& js) {
+ esengine::ecs::BitmapText c;
+ c.text = js.text;
+ c.color = js.color;
+ c.fontSize = js.fontSize;
+ c.align = static_cast<TextAlign>(js.align);
+ c.spacing = js.spacing;
+ c.layer = js.layer;
+ c.font = resource::BitmapFontHandle(js.font);
+ c.enabled = js.enabled;
+ return c;
+}
+
+BitmapTextJS bitmaptextToJS(const esengine::ecs::BitmapText& c) {
+ BitmapTextJS js;
+ js.text = c.text;
+ js.color = c.color;
+ js.fontSize = c.fontSize;
+ js.align = static_cast<i32>(c.align);
+ js.spacing = c.spacing;
+ js.layer = c.layer;
+ js.font = c.font.id();
+ js.enabled = c.enabled;
+ return js;
+}
+
struct SpriteJS {
u32 texture;
glm::vec4 color;
@@ -648,6 +546,59 @@ SpriteJS spriteToJS(const esengine::ecs::Sprite& c) {
return js;
}
+struct UIMaskJS {
+ bool enabled;
+ i32 mode;
+};
+
+esengine::ecs::UIMask uimaskFromJS(const UIMaskJS& js) {
+ esengine::ecs::UIMask c;
+ c.enabled = js.enabled;
+ c.mode = static_cast<MaskMode>(js.mode);
+ return c;
+}
+
+UIMaskJS uimaskToJS(const esengine::ecs::UIMask& c) {
+ UIMaskJS js;
+ js.enabled = c.enabled;
+ js.mode = static_cast<i32>(c.mode);
+ return js;
+}
+
+struct FlexContainerJS {
+ i32 direction;
+ i32 wrap;
+ i32 justifyContent;
+ i32 alignItems;
+ i32 alignContent;
+ glm::vec2 gap;
+ Padding padding;
+};
+
+esengine::ecs::FlexContainer flexcontainerFromJS(const FlexContainerJS& js) {
+ esengine::ecs::FlexContainer c;
+ c.direction = static_cast<FlexDirection>(js.direction);
+ c.wrap = static_cast<FlexWrap>(js.wrap);
+ c.justifyContent = static_cast<JustifyContent>(js.justifyContent);
+ c.alignItems = static_cast<AlignItems>(js.alignItems);
+ c.alignContent = static_cast<AlignContent>(js.alignContent);
+ c.gap = js.gap;
+ c.padding = js.padding;
+ return c;
+}
+
+FlexContainerJS flexcontainerToJS(const esengine::ecs::FlexContainer& c) {
+ FlexContainerJS js;
+ js.direction = static_cast<i32>(c.direction);
+ js.wrap = static_cast<i32>(c.wrap);
+ js.justifyContent = static_cast<i32>(c.justifyContent);
+ js.alignItems = static_cast<i32>(c.alignItems);
+ js.alignContent = static_cast<i32>(c.alignContent);
+ js.gap = c.gap;
+ js.padding = c.padding;
+ return js;
+}
+
struct StateVisualsJS {
u32 targetGraphic;
u32 transitionFlags;
@@ -766,93 +717,135 @@ StateVisualsJS statevisualsToJS(const esengine::ecs::StateVisuals& c) {
return js;
}
-struct UIMaskJS {
- bool enabled;
- i32 mode;
+struct ParentJS {
+ u32 entity;
};
-esengine::ecs::UIMask uimaskFromJS(const UIMaskJS& js) {
- esengine::ecs::UIMask c;
- c.enabled = js.enabled;
- c.mode = static_cast<MaskMode>(js.mode);
+esengine::ecs::Parent parentFromJS(const ParentJS& js) {
+ esengine::ecs::Parent c;
+ c.entity = Entity(js.entity);
+ return c;
+}
+
+ParentJS parentToJS(const esengine::ecs::Parent& c) {
+ ParentJS js;
+ js.entity = static_cast<u32>(c.entity);
+ return js;
+}
+
+struct ChildrenJS {
+ std::vector<u32> entities;
+};
+
+esengine::ecs::Children childrenFromJS(const ChildrenJS& js) {
+ esengine::ecs::Children c;
+ c.entities.reserve(js.entities.size());
+ for (auto v : js.entities) c.entities.push_back(Entity(v));
+ return c;
+}
+
+ChildrenJS childrenToJS(const esengine::ecs::Children& c) {
+ ChildrenJS js;
+ js.entities.reserve(c.entities.size());
+ for (auto e : c.entities) js.entities.push_back(static_cast<u32>(e));
+ return js;
+}
+
+struct CanvasJS {
+ glm::uvec2 designResolution;
+ f32 pixelsPerUnit;
+ i32 scaleMode;
+ f32 matchWidthOrHeight;
+ glm::vec4 backgroundColor;
+};
+
+esengine::ecs::Canvas canvasFromJS(const CanvasJS& js) {
+ esengine::ecs::Canvas c;
+ c.designResolution = js.designResolution;
+ c.pixelsPerUnit = js.pixelsPerUnit;
+ c.scaleMode = static_cast<CanvasScaleMode>(js.scaleMode);
+ c.matchWidthOrHeight = js.matchWidthOrHeight;
+ c.backgroundColor = js.backgroundColor;
return c;
}
-UIMaskJS uimaskToJS(const esengine::ecs::UIMask& c) {
- UIMaskJS js;
- js.enabled = c.enabled;
- js.mode = static_cast<i32>(c.mode);
+CanvasJS canvasToJS(const esengine::ecs::Canvas& c) {
+ CanvasJS js;
+ js.designResolution = c.designResolution;
+ js.pixelsPerUnit = c.pixelsPerUnit;
+ js.scaleMode = static_cast<i32>(c.scaleMode);
+ js.matchWidthOrHeight = c.matchWidthOrHeight;
+ js.backgroundColor = c.backgroundColor;
return js;
}
-struct UIRendererJS {
- i32 visualType;
- u32 texture;
- glm::vec4 color;
- glm::vec2 uvOffset;
- glm::vec2 uvScale;
- glm::vec4 sliceBorder;
- u32 material;
- bool enabled;
+struct CameraJS {
+ i32 projectionType;
+ f32 fov;
+ f32 orthoSize;
+ f32 nearPlane;
+ f32 farPlane;
+ f32 aspectRatio;
+ bool isActive;
+ i32 priority;
+ glm::vec4 viewport;
+ i32 clearFlags;
};
-esengine::ecs::UIRenderer uirendererFromJS(const UIRendererJS& js) {
- esengine::ecs::UIRenderer c;
- c.visualType = static_cast<UIVisualType>(js.visualType);
- c.texture = resource::TextureHandle(js.texture);
- c.color = js.color;
- c.uvOffset = js.uvOffset;
- c.uvScale = js.uvScale;
- c.sliceBorder = js.sliceBorder;
- c.material = js.material;
- c.enabled = js.enabled;
+esengine::ecs::Camera cameraFromJS(const CameraJS& js) {
+ esengine::ecs::Camera c;
+ c.projectionType = static_cast<ProjectionType>(js.projectionType);
+ c.fov = js.fov;
+ c.orthoSize = js.orthoSize;
+ c.nearPlane = js.nearPlane;
+ c.farPlane = js.farPlane;
+ c.aspectRatio = js.aspectRatio;
+ c.isActive = js.isActive;
+ c.priority = js.priority;
+ c.viewport = js.viewport;
+ c.clearFlags = static_cast<ClearFlags>(js.clearFlags);
return c;
}
-UIRendererJS uirendererToJS(const esengine::ecs::UIRenderer& c) {
- UIRendererJS js;
- js.visualType = static_cast<i32>(c.visualType);
- js.texture = c.texture.id();
- js.color = c.color;
- js.uvOffset = c.uvOffset;
- js.uvScale = c.uvScale;
- js.sliceBorder = c.sliceBorder;
- js.material = c.material;
- js.enabled = c.enabled;
+CameraJS cameraToJS(const esengine::ecs::Camera& c) {
+ CameraJS js;
+ js.projectionType = static_cast<i32>(c.projectionType);
+ js.fov = c.fov;
+ js.orthoSize = c.orthoSize;
+ js.nearPlane = c.nearPlane;
+ js.farPlane = c.farPlane;
+ js.aspectRatio = c.aspectRatio;
+ js.isActive = c.isActive;
+ js.priority = c.priority;
+ js.viewport = c.viewport;
+ js.clearFlags = static_cast<i32>(c.clearFlags);
return js;
}
EMSCRIPTEN_BINDINGS(esengine_components) {
register_vector<u32>("VectorEntity");
- value_object<BitmapTextJS>("BitmapText")
- .field("text", &BitmapTextJS::text)
- .field("color", &BitmapTextJS::color)
- .field("fontSize", &BitmapTextJS::fontSize)
- .field("align", &BitmapTextJS::align)
- .field("spacing", &BitmapTextJS::spacing)
- .field("layer", &BitmapTextJS::layer)
- .field("font", &BitmapTextJS::font)
- .field("enabled", &BitmapTextJS::enabled);
-
- value_object<CameraJS>("Camera")
- .field("projectionType", &CameraJS::projectionType)
- .field("fov", &CameraJS::fov)
- .field("orthoSize", &CameraJS::orthoSize)
- .field("nearPlane", &CameraJS::nearPlane)
- .field("farPlane", &CameraJS::farPlane)
- .field("aspectRatio", &CameraJS::aspectRatio)
- .field("isActive", &CameraJS::isActive)
- .field("priority", &CameraJS::priority)
- .field("viewport", &CameraJS::viewport)
- .field("clearFlags", &CameraJS::clearFlags);
+ value_object<esengine::ecs::UIRect>("UIRect")
+ .field("anchorMin", &esengine::ecs::UIRect::anchorMin)
+ .field("anchorMax", &esengine::ecs::UIRect::anchorMax)
+ .field("offsetMin", &esengine::ecs::UIRect::offsetMin)
+ .field("offsetMax", &esengine::ecs::UIRect::offsetMax)
+ .field("size", &esengine::ecs::UIRect::size)
+ .field("pivot", &esengine::ecs::UIRect::pivot);
- value_object<CanvasJS>("Canvas")
- .field("designResolution", &CanvasJS::designResolution)
- .field("pixelsPerUnit", &CanvasJS::pixelsPerUnit)
- .field("scaleMode", &CanvasJS::scaleMode)
- .field("matchWidthOrHeight", &CanvasJS::matchWidthOrHeight)
- .field("backgroundColor", &CanvasJS::backgroundColor);
+ value_object<FlexItemJS>("FlexItem")
+ .field("flexGrow", &FlexItemJS::flexGrow)
+ .field("flexShrink", &FlexItemJS::flexShrink)
+ .field("flexBasis", &FlexItemJS::flexBasis)
+ .field("order", &FlexItemJS::order)
+ .field("alignSelf", &FlexItemJS::alignSelf)
+ .field("margin", &FlexItemJS::margin)
+ .field("minWidth", &FlexItemJS::minWidth)
+ .field("minHeight", &FlexItemJS::minHeight)
+ .field("maxWidth", &FlexItemJS::maxWidth)
+ .field("maxHeight", &FlexItemJS::maxHeight)
+ .field("widthPercent", &FlexItemJS::widthPercent)
+ .field("heightPercent", &FlexItemJS::heightPercent);
value_object<esengine::ecs::BoxCollider>("BoxCollider")
.field("halfExtents", &esengine::ecs::BoxCollider::halfExtents)
@@ -899,46 +892,6 @@ EMSCRIPTEN_BINDINGS(esengine_components) {
.field("categoryBits", &esengine::ecs::SegmentCollider::categoryBits)
.field("maskBits", &esengine::ecs::SegmentCollider::maskBits);
- value_object<FlexContainerJS>("FlexContainer")
- .field("direction", &FlexContainerJS::direction)
- .field("wrap", &FlexContainerJS::wrap)
- .field("justifyContent", &FlexContainerJS::justifyContent)
- .field("alignItems", &FlexContainerJS::alignItems)
- .field("alignContent", &FlexContainerJS::alignContent)
- .field("gap", &FlexContainerJS::gap)
- .field("padding", &FlexContainerJS::padding);
-
- value_object<FlexItemJS>("FlexItem")
- .field("flexGrow", &FlexItemJS::flexGrow)
- .field("flexShrink", &FlexItemJS::flexShrink)
- .field("flexBasis", &FlexItemJS::flexBasis)
- .field("order", &FlexItemJS::order)
- .field("alignSelf", &FlexItemJS::alignSelf)
- .field("margin", &FlexItemJS::margin)
- .field("minWidth", &FlexItemJS::minWidth)
- .field("minHeight", &FlexItemJS::minHeight)
- .field("maxWidth", &FlexItemJS::maxWidth)
- .field("maxHeight", &FlexItemJS::maxHeight)
- .field("widthPercent", &FlexItemJS::widthPercent)
- .field("heightPercent", &FlexItemJS::heightPercent);
-
- value_object<GridLayoutJS>("GridLayout")
- .field("direction", &GridLayoutJS::direction)
- .field("crossAxisCount", &GridLayoutJS::crossAxisCount)
- .field("itemSize", &GridLayoutJS::itemSize)
- .field("spacing", &GridLayoutJS::spacing);
-
- value_object<ParentJS>("Parent")
- .field("entity", &ParentJS::entity);
-
- value_object<ChildrenJS>("Children")
- .field("entities", &ChildrenJS::entities);
-
- value_object<esengine::ecs::Interactable>("Interactable")
- .field("enabled", &esengine::ecs::Interactable::enabled)
- .field("blockRaycast", &esengine::ecs::Interactable::blockRaycast)
- .field("raycastTarget", &esengine::ecs::Interactable::raycastTarget);
-
value_object<ParticleEmitterJS>("ParticleEmitter")
.field("rate", &ParticleEmitterJS::rate)
.field("burstCount", &ParticleEmitterJS::burstCount)
@@ -982,22 +935,33 @@ EMSCRIPTEN_BINDINGS(esengine_components) {
.field("simulationSpace", &ParticleEmitterJS::simulationSpace)
.field("enabled", &ParticleEmitterJS::enabled);
- value_object<RigidBodyJS>("RigidBody")
- .field("bodyType", &RigidBodyJS::bodyType)
- .field("gravityScale", &RigidBodyJS::gravityScale)
- .field("linearDamping", &RigidBodyJS::linearDamping)
- .field("angularDamping", &RigidBodyJS::angularDamping)
- .field("fixedRotation", &RigidBodyJS::fixedRotation)
- .field("bullet", &RigidBodyJS::bullet)
- .field("enabled", &RigidBodyJS::enabled);
+ value_object<esengine::ecs::Transform>("Transform")
+ .field("position", &esengine::ecs::Transform::position)
+ .field("rotation", &esengine::ecs::Transform::rotation)
+ .field("scale", &esengine::ecs::Transform::scale)
+ .field("worldPosition", &esengine::ecs::Transform::worldPosition)
+ .field("worldRotation", &esengine::ecs::Transform::worldRotation)
+ .field("worldScale", &esengine::ecs::Transform::worldScale);
- value_object<esengine::ecs::ShapeRenderer>("ShapeRenderer")
- .field("shapeType", &esengine::ecs::ShapeRenderer::shapeType)
- .field("color", &esengine::ecs::ShapeRenderer::color)
- .field("size", &esengine::ecs::ShapeRenderer::size)
- .field("cornerRadius", &esengine::ecs::ShapeRenderer::cornerRadius)
- .field("layer", &esengine::ecs::ShapeRenderer::layer)
- .field("enabled", &esengine::ecs::ShapeRenderer::enabled);
+ value_object<UIRendererJS>("UIRenderer")
+ .field("visualType", &UIRendererJS::visualType)
+ .field("texture", &UIRendererJS::texture)
+ .field("color", &UIRendererJS::color)
+ .field("uvOffset", &UIRendererJS::uvOffset)
+ .field("uvScale", &UIRendererJS::uvScale)
+ .field("sliceBorder", &UIRendererJS::sliceBorder)
+ .field("material", &UIRendererJS::material)
+ .field("enabled", &UIRendererJS::enabled);
+
+ value_object<GridLayoutJS>("GridLayout")
+ .field("direction", &GridLayoutJS::direction)
+ .field("crossAxisCount", &GridLayoutJS::crossAxisCount)
+ .field("itemSize", &GridLayoutJS::itemSize)
+ .field("spacing", &GridLayoutJS::spacing);
+
+ value_object<esengine::ecs::Velocity>("Velocity")
+ .field("linear", &esengine::ecs::Velocity::linear)
+ .field("angular", &esengine::ecs::Velocity::angular);
value_object<esengine::ecs::SpineAnimation>("SpineAnimation")
.field("skeletonPath", &esengine::ecs::SpineAnimation::skeletonPath)
@@ -1015,6 +979,36 @@ EMSCRIPTEN_BINDINGS(esengine_components) {
.field("material", &esengine::ecs::SpineAnimation::material)
.field("enabled", &esengine::ecs::SpineAnimation::enabled);
+ value_object<esengine::ecs::Interactable>("Interactable")
+ .field("enabled", &esengine::ecs::Interactable::enabled)
+ .field("blockRaycast", &esengine::ecs::Interactable::blockRaycast)
+ .field("raycastTarget", &esengine::ecs::Interactable::raycastTarget);
+
+ value_object<esengine::ecs::UIInteraction>("UIInteraction")
+ .field("hovered", &esengine::ecs::UIInteraction::hovered)
+ .field("pressed", &esengine::ecs::UIInteraction::pressed)
+ .field("justPressed", &esengine::ecs::UIInteraction::justPressed)
+ .field("justReleased", &esengine::ecs::UIInteraction::justReleased);
+
+ value_object<RigidBodyJS>("RigidBody")
+ .field("bodyType", &RigidBodyJS::bodyType)
+ .field("gravityScale", &RigidBodyJS::gravityScale)
+ .field("linearDamping", &RigidBodyJS::linearDamping)
+ .field("angularDamping", &RigidBodyJS::angularDamping)
+ .field("fixedRotation", &RigidBodyJS::fixedRotation)
+ .field("bullet", &RigidBodyJS::bullet)
+ .field("enabled", &RigidBodyJS::enabled);
+
+ value_object<BitmapTextJS>("BitmapText")
+ .field("text", &BitmapTextJS::text)
+ .field("color", &BitmapTextJS::color)
+ .field("fontSize", &BitmapTextJS::fontSize)
+ .field("align", &BitmapTextJS::align)
+ .field("spacing", &BitmapTextJS::spacing)
+ .field("layer", &BitmapTextJS::layer)
+ .field("font", &BitmapTextJS::font)
+ .field("enabled", &BitmapTextJS::enabled);
+
value_object<SpriteJS>("Sprite")
.field("texture", &SpriteJS::texture)
.field("color", &SpriteJS::color)
@@ -1030,9 +1024,18 @@ EMSCRIPTEN_BINDINGS(esengine_components) {
.field("material", &SpriteJS::material)
.field("enabled", &SpriteJS::enabled);
- value_object<esengine::ecs::StateMachine>("StateMachine")
- .field("current", &esengine::ecs::StateMachine::current)
- .field("previous", &esengine::ecs::StateMachine::previous);
+ value_object<UIMaskJS>("UIMask")
+ .field("enabled", &UIMaskJS::enabled)
+ .field("mode", &UIMaskJS::mode);
+
+ value_object<FlexContainerJS>("FlexContainer")
+ .field("direction", &FlexContainerJS::direction)
+ .field("wrap", &FlexContainerJS::wrap)
+ .field("justifyContent", &FlexContainerJS::justifyContent)
+ .field("alignItems", &FlexContainerJS::alignItems)
+ .field("alignContent", &FlexContainerJS::alignContent)
+ .field("gap", &FlexContainerJS::gap)
+ .field("padding", &FlexContainerJS::padding);
value_object<StateVisualsJS>("StateVisuals")
.field("targetGraphic", &StateVisualsJS::targetGraphic)
@@ -1071,45 +1074,42 @@ EMSCRIPTEN_BINDINGS(esengine_components) {
.field("slot7Sprite", &StateVisualsJS::slot7Sprite)
.field("slot7Scale", &StateVisualsJS::slot7Scale);
- value_object<esengine::ecs::Transform>("Transform")
- .field("position", &esengine::ecs::Transform::position)
- .field("rotation", &esengine::ecs::Transform::rotation)
- .field("scale", &esengine::ecs::Transform::scale)
- .field("worldPosition", &esengine::ecs::Transform::worldPosition)
- .field("worldRotation", &esengine::ecs::Transform::worldRotation)
- .field("worldScale", &esengine::ecs::Transform::worldScale);
-
- value_object<esengine::ecs::UIInteraction>("UIInteraction")
- .field("hovered", &esengine::ecs::UIInteraction::hovered)
- .field("pressed", &esengine::ecs::UIInteraction::pressed)
- .field("justPressed", &esengine::ecs::UIInteraction::justPressed)
- .field("justReleased", &esengine::ecs::UIInteraction::justReleased);
+ value_object<ParentJS>("Parent")
+ .field("entity", &ParentJS::entity);
- value_object<UIMaskJS>("UIMask")
- .field("enabled", &UIMaskJS::enabled)
- .field("mode", &UIMaskJS::mode);
+ value_object<ChildrenJS>("Children")
+ .field("entities", &ChildrenJS::entities);
- value_object<esengine::ecs::UIRect>("UIRect")
- .field("anchorMin", &esengine::ecs::UIRect::anchorMin)
- .field("anchorMax", &esengine::ecs::UIRect::anchorMax)
- .field("offsetMin", &esengine::ecs::UIRect::offsetMin)
- .field("offsetMax", &esengine::ecs::UIRect::offsetMax)
- .field("size", &esengine::ecs::UIRect::size)
- .field("pivot", &esengine::ecs::UIRect::pivot);
+ value_object<esengine::ecs::ShapeRenderer>("ShapeRenderer")
+ .field("shapeType", &esengine::ecs::ShapeRenderer::shapeType)
+ .field("color", &esengine::ecs::ShapeRenderer::color)
+ .field("size", &esengine::ecs::ShapeRenderer::size)
+ .field("cornerRadius", &esengine::ecs::ShapeRenderer::cornerRadius)
+ .field("layer", &esengine::ecs::ShapeRenderer::layer)
+ .field("enabled", &esengine::ecs::ShapeRenderer::enabled);
- value_object<UIRendererJS>("UIRenderer")
- .field("visualType", &UIRendererJS::visualType)
- .field("texture", &UIRendererJS::texture)
- .field("color", &UIRendererJS::color)
- .field("uvOffset", &UIRendererJS::uvOffset)
- .field("uvScale", &UIRendererJS::uvScale)
- .field("sliceBorder", &UIRendererJS::sliceBorder)
- .field("material", &UIRendererJS::material)
- .field("enabled", &UIRendererJS::enabled);
+ value_object<esengine::ecs::StateMachine>("StateMachine")
+ .field("current", &esengine::ecs::StateMachine::current)
+ .field("previous", &esengine::ecs::StateMachine::previous);
- value_object<esengine::ecs::Velocity>("Velocity")
- .field("linear", &esengine::ecs::Velocity::linear)
- .field("angular", &esengine::ecs::Velocity::angular);
+ value_object<CanvasJS>("Canvas")
+ .field("designResolution", &CanvasJS::designResolution)
+ .field("pixelsPerUnit", &CanvasJS::pixelsPerUnit)
+ .field("scaleMode", &CanvasJS::scaleMode)
+ .field("matchWidthOrHeight", &CanvasJS::matchWidthOrHeight)
+ .field("backgroundColor", &CanvasJS::backgroundColor);
+
+ value_object<CameraJS>("Camera")
+ .field("projectionType", &CameraJS::projectionType)
+ .field("fov", &CameraJS::fov)
+ .field("orthoSize", &CameraJS::orthoSize)
+ .field("nearPlane", &CameraJS::nearPlane)
+ .field("farPlane", &CameraJS::farPlane)
+ .field("aspectRatio", &CameraJS::aspectRatio)
+ .field("isActive", &CameraJS::isActive)
+ .field("priority", &CameraJS::priority)
+ .field("viewport", &CameraJS::viewport)
+ .field("clearFlags", &CameraJS::clearFlags);
}
@@ -1131,64 +1131,45 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
}))
.function("entityCount", &Registry::entityCount)
- // BitmapText
- .function("hasBitmapText", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::BitmapText>(static_cast<Entity>(e));
- }))
- .function("getBitmapText", optional_override([](Registry& r, u32 e) {
- auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::BitmapText>(entity)) return BitmapTextJS{};
- return bitmaptextToJS(r.get<esengine::ecs::BitmapText>(entity));
- }))
- .function("addBitmapText", optional_override([](Registry& r, u32 e, const BitmapTextJS& js) {
- auto entity = static_cast<Entity>(e);
- if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::BitmapText>(entity, bitmaptextFromJS(js));
- }))
- .function("removeBitmapText", optional_override([](Registry& r, u32 e) {
- auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::BitmapText>(entity)) return;
- r.remove<esengine::ecs::BitmapText>(entity);
- }))
-
- // Camera
- .function("hasCamera", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::Camera>(static_cast<Entity>(e));
+ // UIRect
+ .function("hasUIRect", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::UIRect>(static_cast<Entity>(e));
}))
- .function("getCamera", optional_override([](Registry& r, u32 e) {
+ .function("getUIRect", optional_override([](Registry& r, u32 e) -> esengine::ecs::UIRect& {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::Camera>(entity)) return CameraJS{};
- return cameraToJS(r.get<esengine::ecs::Camera>(entity));
- }))
- .function("addCamera", optional_override([](Registry& r, u32 e, const CameraJS& js) {
+ static esengine::ecs::UIRect s_dummy{};
+ if (!r.valid(entity) || !r.has<esengine::ecs::UIRect>(entity)) return s_dummy;
+ return r.get<esengine::ecs::UIRect>(entity);
+ }), allow_raw_pointers())
+ .function("addUIRect", optional_override([](Registry& r, u32 e, const esengine::ecs::UIRect& c) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::Camera>(entity, cameraFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::UIRect>(entity, c);
}))
- .function("removeCamera", optional_override([](Registry& r, u32 e) {
+ .function("removeUIRect", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::Camera>(entity)) return;
- r.remove<esengine::ecs::Camera>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::UIRect>(entity)) return;
+ r.remove<esengine::ecs::UIRect>(entity);
}))
- // Canvas
- .function("hasCanvas", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::Canvas>(static_cast<Entity>(e));
+ // FlexItem
+ .function("hasFlexItem", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::FlexItem>(static_cast<Entity>(e));
}))
- .function("getCanvas", optional_override([](Registry& r, u32 e) {
+ .function("getFlexItem", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::Canvas>(entity)) return CanvasJS{};
- return canvasToJS(r.get<esengine::ecs::Canvas>(entity));
+ if (!r.valid(entity) || !r.has<esengine::ecs::FlexItem>(entity)) return FlexItemJS{};
+ return flexitemToJS(r.get<esengine::ecs::FlexItem>(entity));
}))
- .function("addCanvas", optional_override([](Registry& r, u32 e, const CanvasJS& js) {
+ .function("addFlexItem", optional_override([](Registry& r, u32 e, const FlexItemJS& js) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::Canvas>(entity, canvasFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::FlexItem>(entity, flexitemFromJS(js));
}))
- .function("removeCanvas", optional_override([](Registry& r, u32 e) {
+ .function("removeFlexItem", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::Canvas>(entity)) return;
- r.remove<esengine::ecs::Canvas>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::FlexItem>(entity)) return;
+ r.remove<esengine::ecs::FlexItem>(entity);
}))
// BoxCollider
@@ -1275,44 +1256,67 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::SegmentCollider>(entity);
}))
- // FlexContainer
- .function("hasFlexContainer", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::FlexContainer>(static_cast<Entity>(e));
+ // ParticleEmitter
+ .function("hasParticleEmitter", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::ParticleEmitter>(static_cast<Entity>(e));
}))
- .function("getFlexContainer", optional_override([](Registry& r, u32 e) {
+ .function("getParticleEmitter", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::FlexContainer>(entity)) return FlexContainerJS{};
- return flexcontainerToJS(r.get<esengine::ecs::FlexContainer>(entity));
+ if (!r.valid(entity) || !r.has<esengine::ecs::ParticleEmitter>(entity)) return ParticleEmitterJS{};
+ return particleemitterToJS(r.get<esengine::ecs::ParticleEmitter>(entity));
}))
- .function("addFlexContainer", optional_override([](Registry& r, u32 e, const FlexContainerJS& js) {
+ .function("addParticleEmitter", optional_override([](Registry& r, u32 e, const ParticleEmitterJS& js) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::FlexContainer>(entity, flexcontainerFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::ParticleEmitter>(entity, particleemitterFromJS(js));
}))
- .function("removeFlexContainer", optional_override([](Registry& r, u32 e) {
+ .function("removeParticleEmitter", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::FlexContainer>(entity)) return;
- r.remove<esengine::ecs::FlexContainer>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::ParticleEmitter>(entity)) return;
+ r.remove<esengine::ecs::ParticleEmitter>(entity);
}))
- // FlexItem
- .function("hasFlexItem", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::FlexItem>(static_cast<Entity>(e));
+ // Transform
+ .function("hasTransform", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Transform>(static_cast<Entity>(e));
}))
- .function("getFlexItem", optional_override([](Registry& r, u32 e) {
+ .function("getTransform", optional_override([](Registry& r, u32 e) -> esengine::ecs::Transform& {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::FlexItem>(entity)) return FlexItemJS{};
- return flexitemToJS(r.get<esengine::ecs::FlexItem>(entity));
+ static esengine::ecs::Transform s_dummy{};
+ if (!r.valid(entity) || !r.has<esengine::ecs::Transform>(entity)) return s_dummy;
+ auto& t = r.get<esengine::ecs::Transform>(entity);
+ t.ensureDecomposed();
+ return t;
+ }), allow_raw_pointers())
+ .function("addTransform", optional_override([](Registry& r, u32 e, const esengine::ecs::Transform& c) {
+ auto entity = static_cast<Entity>(e);
+ if (!r.valid(entity)) return;
+ r.emplaceOrReplace<esengine::ecs::Transform>(entity, c);
}))
- .function("addFlexItem", optional_override([](Registry& r, u32 e, const FlexItemJS& js) {
+ .function("removeTransform", optional_override([](Registry& r, u32 e) {
+ auto entity = static_cast<Entity>(e);
+ if (!r.valid(entity) || !r.has<esengine::ecs::Transform>(entity)) return;
+ r.remove<esengine::ecs::Transform>(entity);
+ }))
+
+ // UIRenderer
+ .function("hasUIRenderer", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::UIRenderer>(static_cast<Entity>(e));
+ }))
+ .function("getUIRenderer", optional_override([](Registry& r, u32 e) {
+ auto entity = static_cast<Entity>(e);
+ if (!r.valid(entity) || !r.has<esengine::ecs::UIRenderer>(entity)) return UIRendererJS{};
+ return uirendererToJS(r.get<esengine::ecs::UIRenderer>(entity));
+ }))
+ .function("addUIRenderer", optional_override([](Registry& r, u32 e, const UIRendererJS& js) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::FlexItem>(entity, flexitemFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::UIRenderer>(entity, uirendererFromJS(js));
}))
- .function("removeFlexItem", optional_override([](Registry& r, u32 e) {
+ .function("removeUIRenderer", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::FlexItem>(entity)) return;
- r.remove<esengine::ecs::FlexItem>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::UIRenderer>(entity)) return;
+ r.remove<esengine::ecs::UIRenderer>(entity);
}))
// GridLayout
@@ -1335,44 +1339,46 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::GridLayout>(entity);
}))
- // Parent
- .function("hasParent", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::Parent>(static_cast<Entity>(e));
+ // Velocity
+ .function("hasVelocity", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Velocity>(static_cast<Entity>(e));
}))
- .function("getParent", optional_override([](Registry& r, u32 e) {
+ .function("getVelocity", optional_override([](Registry& r, u32 e) -> esengine::ecs::Velocity& {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::Parent>(entity)) return ParentJS{};
- return parentToJS(r.get<esengine::ecs::Parent>(entity));
- }))
- .function("addParent", optional_override([](Registry& r, u32 e, const ParentJS& js) {
+ static esengine::ecs::Velocity s_dummy{};
+ if (!r.valid(entity) || !r.has<esengine::ecs::Velocity>(entity)) return s_dummy;
+ return r.get<esengine::ecs::Velocity>(entity);
+ }), allow_raw_pointers())
+ .function("addVelocity", optional_override([](Registry& r, u32 e, const esengine::ecs::Velocity& c) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::Parent>(entity, parentFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::Velocity>(entity, c);
}))
- .function("removeParent", optional_override([](Registry& r, u32 e) {
+ .function("removeVelocity", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::Parent>(entity)) return;
- r.remove<esengine::ecs::Parent>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::Velocity>(entity)) return;
+ r.remove<esengine::ecs::Velocity>(entity);
}))
- // Children
- .function("hasChildren", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::Children>(static_cast<Entity>(e));
+ // SpineAnimation
+ .function("hasSpineAnimation", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::SpineAnimation>(static_cast<Entity>(e));
}))
- .function("getChildren", optional_override([](Registry& r, u32 e) {
+ .function("getSpineAnimation", optional_override([](Registry& r, u32 e) -> esengine::ecs::SpineAnimation& {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::Children>(entity)) return ChildrenJS{};
- return childrenToJS(r.get<esengine::ecs::Children>(entity));
- }))
- .function("addChildren", optional_override([](Registry& r, u32 e, const ChildrenJS& js) {
+ static esengine::ecs::SpineAnimation s_dummy{};
+ if (!r.valid(entity) || !r.has<esengine::ecs::SpineAnimation>(entity)) return s_dummy;
+ return r.get<esengine::ecs::SpineAnimation>(entity);
+ }), allow_raw_pointers())
+ .function("addSpineAnimation", optional_override([](Registry& r, u32 e, const esengine::ecs::SpineAnimation& c) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::Children>(entity, childrenFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::SpineAnimation>(entity, c);
}))
- .function("removeChildren", optional_override([](Registry& r, u32 e) {
+ .function("removeSpineAnimation", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::Children>(entity)) return;
- r.remove<esengine::ecs::Children>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::SpineAnimation>(entity)) return;
+ r.remove<esengine::ecs::SpineAnimation>(entity);
}))
// Interactable
@@ -1396,24 +1402,25 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::Interactable>(entity);
}))
- // ParticleEmitter
- .function("hasParticleEmitter", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::ParticleEmitter>(static_cast<Entity>(e));
+ // UIInteraction
+ .function("hasUIInteraction", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::UIInteraction>(static_cast<Entity>(e));
}))
- .function("getParticleEmitter", optional_override([](Registry& r, u32 e) {
+ .function("getUIInteraction", optional_override([](Registry& r, u32 e) -> esengine::ecs::UIInteraction& {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::ParticleEmitter>(entity)) return ParticleEmitterJS{};
- return particleemitterToJS(r.get<esengine::ecs::ParticleEmitter>(entity));
- }))
- .function("addParticleEmitter", optional_override([](Registry& r, u32 e, const ParticleEmitterJS& js) {
+ static esengine::ecs::UIInteraction s_dummy{};
+ if (!r.valid(entity) || !r.has<esengine::ecs::UIInteraction>(entity)) return s_dummy;
+ return r.get<esengine::ecs::UIInteraction>(entity);
+ }), allow_raw_pointers())
+ .function("addUIInteraction", optional_override([](Registry& r, u32 e, const esengine::ecs::UIInteraction& c) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::ParticleEmitter>(entity, particleemitterFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::UIInteraction>(entity, c);
}))
- .function("removeParticleEmitter", optional_override([](Registry& r, u32 e) {
+ .function("removeUIInteraction", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::ParticleEmitter>(entity)) return;
- r.remove<esengine::ecs::ParticleEmitter>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::UIInteraction>(entity)) return;
+ r.remove<esengine::ecs::UIInteraction>(entity);
}))
// RigidBody
@@ -1436,46 +1443,24 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::RigidBody>(entity);
}))
- // ShapeRenderer
- .function("hasShapeRenderer", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::ShapeRenderer>(static_cast<Entity>(e));
- }))
- .function("getShapeRenderer", optional_override([](Registry& r, u32 e) -> esengine::ecs::ShapeRenderer& {
- auto entity = static_cast<Entity>(e);
- static esengine::ecs::ShapeRenderer s_dummy{};
- if (!r.valid(entity) || !r.has<esengine::ecs::ShapeRenderer>(entity)) return s_dummy;
- return r.get<esengine::ecs::ShapeRenderer>(entity);
- }), allow_raw_pointers())
- .function("addShapeRenderer", optional_override([](Registry& r, u32 e, const esengine::ecs::ShapeRenderer& c) {
- auto entity = static_cast<Entity>(e);
- if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::ShapeRenderer>(entity, c);
+ // BitmapText
+ .function("hasBitmapText", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::BitmapText>(static_cast<Entity>(e));
}))
- .function("removeShapeRenderer", optional_override([](Registry& r, u32 e) {
+ .function("getBitmapText", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::ShapeRenderer>(entity)) return;
- r.remove<esengine::ecs::ShapeRenderer>(entity);
- }))
-
- // SpineAnimation
- .function("hasSpineAnimation", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::SpineAnimation>(static_cast<Entity>(e));
+ if (!r.valid(entity) || !r.has<esengine::ecs::BitmapText>(entity)) return BitmapTextJS{};
+ return bitmaptextToJS(r.get<esengine::ecs::BitmapText>(entity));
}))
- .function("getSpineAnimation", optional_override([](Registry& r, u32 e) -> esengine::ecs::SpineAnimation& {
- auto entity = static_cast<Entity>(e);
- static esengine::ecs::SpineAnimation s_dummy{};
- if (!r.valid(entity) || !r.has<esengine::ecs::SpineAnimation>(entity)) return s_dummy;
- return r.get<esengine::ecs::SpineAnimation>(entity);
- }), allow_raw_pointers())
- .function("addSpineAnimation", optional_override([](Registry& r, u32 e, const esengine::ecs::SpineAnimation& c) {
+ .function("addBitmapText", optional_override([](Registry& r, u32 e, const BitmapTextJS& js) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::SpineAnimation>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::BitmapText>(entity, bitmaptextFromJS(js));
}))
- .function("removeSpineAnimation", optional_override([](Registry& r, u32 e) {
+ .function("removeBitmapText", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::SpineAnimation>(entity)) return;
- r.remove<esengine::ecs::SpineAnimation>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::BitmapText>(entity)) return;
+ r.remove<esengine::ecs::BitmapText>(entity);
}))
// Sprite
@@ -1498,25 +1483,44 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::Sprite>(entity);
}))
- // StateMachine
- .function("hasStateMachine", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::StateMachine>(static_cast<Entity>(e));
+ // UIMask
+ .function("hasUIMask", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::UIMask>(static_cast<Entity>(e));
}))
- .function("getStateMachine", optional_override([](Registry& r, u32 e) -> esengine::ecs::StateMachine& {
+ .function("getUIMask", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- static esengine::ecs::StateMachine s_dummy{};
- if (!r.valid(entity) || !r.has<esengine::ecs::StateMachine>(entity)) return s_dummy;
- return r.get<esengine::ecs::StateMachine>(entity);
- }), allow_raw_pointers())
- .function("addStateMachine", optional_override([](Registry& r, u32 e, const esengine::ecs::StateMachine& c) {
+ if (!r.valid(entity) || !r.has<esengine::ecs::UIMask>(entity)) return UIMaskJS{};
+ return uimaskToJS(r.get<esengine::ecs::UIMask>(entity));
+ }))
+ .function("addUIMask", optional_override([](Registry& r, u32 e, const UIMaskJS& js) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::StateMachine>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::UIMask>(entity, uimaskFromJS(js));
}))
- .function("removeStateMachine", optional_override([](Registry& r, u32 e) {
+ .function("removeUIMask", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::StateMachine>(entity)) return;
- r.remove<esengine::ecs::StateMachine>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::UIMask>(entity)) return;
+ r.remove<esengine::ecs::UIMask>(entity);
+ }))
+
+ // FlexContainer
+ .function("hasFlexContainer", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::FlexContainer>(static_cast<Entity>(e));
+ }))
+ .function("getFlexContainer", optional_override([](Registry& r, u32 e) {
+ auto entity = static_cast<Entity>(e);
+ if (!r.valid(entity) || !r.has<esengine::ecs::FlexContainer>(entity)) return FlexContainerJS{};
+ return flexcontainerToJS(r.get<esengine::ecs::FlexContainer>(entity));
+ }))
+ .function("addFlexContainer", optional_override([](Registry& r, u32 e, const FlexContainerJS& js) {
+ auto entity = static_cast<Entity>(e);
+ if (!r.valid(entity)) return;
+ r.emplaceOrReplace<esengine::ecs::FlexContainer>(entity, flexcontainerFromJS(js));
+ }))
+ .function("removeFlexContainer", optional_override([](Registry& r, u32 e) {
+ auto entity = static_cast<Entity>(e);
+ if (!r.valid(entity) || !r.has<esengine::ecs::FlexContainer>(entity)) return;
+ r.remove<esengine::ecs::FlexContainer>(entity);
}))
// StateVisuals
@@ -1539,130 +1543,126 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::StateVisuals>(entity);
}))
- // Transform
- .function("hasTransform", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::Transform>(static_cast<Entity>(e));
+ // Parent
+ .function("hasParent", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Parent>(static_cast<Entity>(e));
}))
- .function("getTransform", optional_override([](Registry& r, u32 e) -> esengine::ecs::Transform& {
+ .function("getParent", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- static esengine::ecs::Transform s_dummy{};
- if (!r.valid(entity) || !r.has<esengine::ecs::Transform>(entity)) return s_dummy;
- auto& t = r.get<esengine::ecs::Transform>(entity);
- t.ensureDecomposed();
- return t;
- }), allow_raw_pointers())
- .function("addTransform", optional_override([](Registry& r, u32 e, const esengine::ecs::Transform& c) {
+ if (!r.valid(entity) || !r.has<esengine::ecs::Parent>(entity)) return ParentJS{};
+ return parentToJS(r.get<esengine::ecs::Parent>(entity));
+ }))
+ .function("addParent", optional_override([](Registry& r, u32 e, const ParentJS& js) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::Transform>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::Parent>(entity, parentFromJS(js));
}))
- .function("removeTransform", optional_override([](Registry& r, u32 e) {
+ .function("removeParent", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::Transform>(entity)) return;
- r.remove<esengine::ecs::Transform>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::Parent>(entity)) return;
+ r.remove<esengine::ecs::Parent>(entity);
}))
- // UIInteraction
- .function("hasUIInteraction", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::UIInteraction>(static_cast<Entity>(e));
+ // Children
+ .function("hasChildren", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Children>(static_cast<Entity>(e));
}))
- .function("getUIInteraction", optional_override([](Registry& r, u32 e) -> esengine::ecs::UIInteraction& {
+ .function("getChildren", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- static esengine::ecs::UIInteraction s_dummy{};
- if (!r.valid(entity) || !r.has<esengine::ecs::UIInteraction>(entity)) return s_dummy;
- return r.get<esengine::ecs::UIInteraction>(entity);
- }), allow_raw_pointers())
- .function("addUIInteraction", optional_override([](Registry& r, u32 e, const esengine::ecs::UIInteraction& c) {
+ if (!r.valid(entity) || !r.has<esengine::ecs::Children>(entity)) return ChildrenJS{};
+ return childrenToJS(r.get<esengine::ecs::Children>(entity));
+ }))
+ .function("addChildren", optional_override([](Registry& r, u32 e, const ChildrenJS& js) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::UIInteraction>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::Children>(entity, childrenFromJS(js));
}))
- .function("removeUIInteraction", optional_override([](Registry& r, u32 e) {
+ .function("removeChildren", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::UIInteraction>(entity)) return;
- r.remove<esengine::ecs::UIInteraction>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::Children>(entity)) return;
+ r.remove<esengine::ecs::Children>(entity);
}))
- // UIMask
- .function("hasUIMask", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::UIMask>(static_cast<Entity>(e));
+ // ShapeRenderer
+ .function("hasShapeRenderer", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::ShapeRenderer>(static_cast<Entity>(e));
}))
- .function("getUIMask", optional_override([](Registry& r, u32 e) {
+ .function("getShapeRenderer", optional_override([](Registry& r, u32 e) -> esengine::ecs::ShapeRenderer& {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::UIMask>(entity)) return UIMaskJS{};
- return uimaskToJS(r.get<esengine::ecs::UIMask>(entity));
- }))
- .function("addUIMask", optional_override([](Registry& r, u32 e, const UIMaskJS& js) {
+ static esengine::ecs::ShapeRenderer s_dummy{};
+ if (!r.valid(entity) || !r.has<esengine::ecs::ShapeRenderer>(entity)) return s_dummy;
+ return r.get<esengine::ecs::ShapeRenderer>(entity);
+ }), allow_raw_pointers())
+ .function("addShapeRenderer", optional_override([](Registry& r, u32 e, const esengine::ecs::ShapeRenderer& c) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::UIMask>(entity, uimaskFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::ShapeRenderer>(entity, c);
}))
- .function("removeUIMask", optional_override([](Registry& r, u32 e) {
+ .function("removeShapeRenderer", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::UIMask>(entity)) return;
- r.remove<esengine::ecs::UIMask>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::ShapeRenderer>(entity)) return;
+ r.remove<esengine::ecs::ShapeRenderer>(entity);
}))
- // UIRect
- .function("hasUIRect", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::UIRect>(static_cast<Entity>(e));
+ // StateMachine
+ .function("hasStateMachine", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::StateMachine>(static_cast<Entity>(e));
}))
- .function("getUIRect", optional_override([](Registry& r, u32 e) -> esengine::ecs::UIRect& {
+ .function("getStateMachine", optional_override([](Registry& r, u32 e) -> esengine::ecs::StateMachine& {
auto entity = static_cast<Entity>(e);
- static esengine::ecs::UIRect s_dummy{};
- if (!r.valid(entity) || !r.has<esengine::ecs::UIRect>(entity)) return s_dummy;
- return r.get<esengine::ecs::UIRect>(entity);
+ static esengine::ecs::StateMachine s_dummy{};
+ if (!r.valid(entity) || !r.has<esengine::ecs::StateMachine>(entity)) return s_dummy;
+ return r.get<esengine::ecs::StateMachine>(entity);
}), allow_raw_pointers())
- .function("addUIRect", optional_override([](Registry& r, u32 e, const esengine::ecs::UIRect& c) {
+ .function("addStateMachine", optional_override([](Registry& r, u32 e, const esengine::ecs::StateMachine& c) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::UIRect>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::StateMachine>(entity, c);
}))
- .function("removeUIRect", optional_override([](Registry& r, u32 e) {
+ .function("removeStateMachine", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::UIRect>(entity)) return;
- r.remove<esengine::ecs::UIRect>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::StateMachine>(entity)) return;
+ r.remove<esengine::ecs::StateMachine>(entity);
}))
- // UIRenderer
- .function("hasUIRenderer", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::UIRenderer>(static_cast<Entity>(e));
+ // Canvas
+ .function("hasCanvas", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Canvas>(static_cast<Entity>(e));
}))
- .function("getUIRenderer", optional_override([](Registry& r, u32 e) {
+ .function("getCanvas", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::UIRenderer>(entity)) return UIRendererJS{};
- return uirendererToJS(r.get<esengine::ecs::UIRenderer>(entity));
+ if (!r.valid(entity) || !r.has<esengine::ecs::Canvas>(entity)) return CanvasJS{};
+ return canvasToJS(r.get<esengine::ecs::Canvas>(entity));
}))
- .function("addUIRenderer", optional_override([](Registry& r, u32 e, const UIRendererJS& js) {
+ .function("addCanvas", optional_override([](Registry& r, u32 e, const CanvasJS& js) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::UIRenderer>(entity, uirendererFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::Canvas>(entity, canvasFromJS(js));
}))
- .function("removeUIRenderer", optional_override([](Registry& r, u32 e) {
+ .function("removeCanvas", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::UIRenderer>(entity)) return;
- r.remove<esengine::ecs::UIRenderer>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::Canvas>(entity)) return;
+ r.remove<esengine::ecs::Canvas>(entity);
}))
- // Velocity
- .function("hasVelocity", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::Velocity>(static_cast<Entity>(e));
+ // Camera
+ .function("hasCamera", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Camera>(static_cast<Entity>(e));
}))
- .function("getVelocity", optional_override([](Registry& r, u32 e) -> esengine::ecs::Velocity& {
+ .function("getCamera", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- static esengine::ecs::Velocity s_dummy{};
- if (!r.valid(entity) || !r.has<esengine::ecs::Velocity>(entity)) return s_dummy;
- return r.get<esengine::ecs::Velocity>(entity);
- }), allow_raw_pointers())
- .function("addVelocity", optional_override([](Registry& r, u32 e, const esengine::ecs::Velocity& c) {
+ if (!r.valid(entity) || !r.has<esengine::ecs::Camera>(entity)) return CameraJS{};
+ return cameraToJS(r.get<esengine::ecs::Camera>(entity));
+ }))
+ .function("addCamera", optional_override([](Registry& r, u32 e, const CameraJS& js) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::Velocity>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::Camera>(entity, cameraFromJS(js));
}))
- .function("removeVelocity", optional_override([](Registry& r, u32 e) {
+ .function("removeCamera", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::Velocity>(entity)) return;
- r.remove<esengine::ecs::Velocity>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::Camera>(entity)) return;
+ r.remove<esengine::ecs::Camera>(entity);
}))
// Hierarchy Utilities
@@ -1673,4 +1673,45 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
;
}
+// =============================================================================
+// Reflection — authoritative binding manifest for JS
+// =============================================================================
+
+emscripten::val esengineGetBuiltinComponentNames() {
+ using namespace emscripten;
+ auto arr = val::array();
+ size_t i = 0;
+ arr.set(i++, val(std::string("UIRect")));
+ arr.set(i++, val(std::string("FlexItem")));
+ arr.set(i++, val(std::string("BoxCollider")));
+ arr.set(i++, val(std::string("CircleCollider")));
+ arr.set(i++, val(std::string("CapsuleCollider")));
+ arr.set(i++, val(std::string("SegmentCollider")));
+ arr.set(i++, val(std::string("ParticleEmitter")));
+ arr.set(i++, val(std::string("Transform")));
+ arr.set(i++, val(std::string("UIRenderer")));
+ arr.set(i++, val(std::string("GridLayout")));
+ arr.set(i++, val(std::string("Velocity")));
+ arr.set(i++, val(std::string("SpineAnimation")));
+ arr.set(i++, val(std::string("Interactable")));
+ arr.set(i++, val(std::string("UIInteraction")));
+ arr.set(i++, val(std::string("RigidBody")));
+ arr.set(i++, val(std::string("BitmapText")));
+ arr.set(i++, val(std::string("Sprite")));
+ arr.set(i++, val(std::string("UIMask")));
+ arr.set(i++, val(std::string("FlexContainer")));
+ arr.set(i++, val(std::string("StateVisuals")));
+ arr.set(i++, val(std::string("Parent")));
+ arr.set(i++, val(std::string("Children")));
+ arr.set(i++, val(std::string("ShapeRenderer")));
+ arr.set(i++, val(std::string("StateMachine")));
+ arr.set(i++, val(std::string("Canvas")));
+ arr.set(i++, val(std::string("Camera")));
+ return arr;
+}
+
+EMSCRIPTEN_BINDINGS(esengine_reflection) {
+ emscripten::function("getBuiltinComponentNames", &esengineGetBuiltinComponentNames);
+}
+
#endif // ES_PLATFORM_WEB
diff --git a/tools/eht/generators/embind.py b/tools/eht/generators/embind.py
index 90934b117..712246d42 100644
--- a/tools/eht/generators/embind.py
+++ b/tools/eht/generators/embind.py
@@ -18,6 +18,7 @@ class EmbindGenerator:
lines.extend(self._gen_enums())
lines.extend(self._gen_components())
lines.extend(self._gen_registry())
+ lines.extend(self._gen_reflection())
lines.append('')
lines.append('#endif // ES_PLATFORM_WEB')
lines.append('')
@@ -213,6 +214,33 @@ class EmbindGenerator:
lines.append('')
return lines
+ def _gen_reflection(self) -> List[str]:
+ """Emit a module-level function returning the authoritative list of
+ component names bound in this WASM build. JS uses this to detect drift
+ between the shipped SDK's COMPONENT_META and the actual WASM module."""
+ lines = [
+ '',
+ '// =============================================================================',
+ '// Reflection — authoritative binding manifest for JS',
+ '// =============================================================================',
+ '',
+ 'emscripten::val esengineGetBuiltinComponentNames() {',
+ ' using namespace emscripten;',
+ ' auto arr = val::array();',
+ ' size_t i = 0;',
+ ]
+ for comp in self.components:
+ lines.append(f' arr.set(i++, val(std::string("{comp.name}")));')
+ lines.extend([
+ ' return arr;',
+ '}',
+ '',
+ 'EMSCRIPTEN_BINDINGS(esengine_reflection) {',
+ ' emscripten::function("getBuiltinComponentNames", &esengineGetBuiltinComponentNames);',
+ '}',
+ ])
+ return lines
+
def _gen_registry(self) -> List[str]:
lines = [
'// =============================================================================',
diff --git a/tools/eht/generators/typescript.py b/tools/eht/generators/typescript.py
index eca039776..2a784d80a 100644
--- a/tools/eht/generators/typescript.py
+++ b/tools/eht/generators/typescript.py
@@ -102,6 +102,12 @@ class TypeScriptGenerator:
'// Module',
'export interface ESEngineModule {',
' Registry: new () => Registry;',
+ ' /**',
+ ' * Authoritative list of component names this WASM build exposes',
+ ' * on the Registry. Used by BuiltinBridge to detect drift between',
+ ' * the shipped SDK and the actual WASM module.',
+ ' */',
+ ' getBuiltinComponentNames(): string[];',
]
for comp in self.components:
lines.append(f' {comp.name}: new () => {comp.name};')