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(engine): Phase 1 foundational fixes

esengineadd6921cb606
diff --git a/sdk/src/wasm.generated.ts b/sdk/src/wasm.generated.ts
index c7a0ab0b3..dd73cc60d 100644
--- a/sdk/src/wasm.generated.ts
+++ b/sdk/src/wasm.generated.ts
@@ -22,53 +22,30 @@ export interface VectorEntity {
// Enums
-export enum AlignSelf {
- Auto = 0,
- Start = 1,
- Center = 2,
- End = 3,
- Stretch = 4,
-}
-
-export enum EmitterShape {
- Point = 0,
- Circle = 1,
- Rectangle = 2,
- Cone = 3,
-}
-
-export enum SimulationSpace {
- World = 0,
- Local = 1,
-}
-
-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 ProjectionType {
+ Perspective = 0,
+ Orthographic = 1,
+}
+
+export enum ClearFlags {
+ Nothing = 0,
+ Color = 1,
+ Depth = 2,
+ ColorAndDepth = 3,
+}
+
+export enum CanvasScaleMode {
+ FixedWidth = 0,
+ FixedHeight = 1,
+ Expand = 2,
+ Shrink = 3,
+ Match = 4,
}
export enum FlexDirection {
@@ -108,50 +85,81 @@ export enum AlignContent {
SpaceAround = 5,
}
-export enum CanvasScaleMode {
- FixedWidth = 0,
- FixedHeight = 1,
- Expand = 2,
- Shrink = 3,
- Match = 4,
+export enum AlignSelf {
+ Auto = 0,
+ Start = 1,
+ Center = 2,
+ End = 3,
+ Stretch = 4,
}
-export enum ProjectionType {
- Perspective = 0,
- Orthographic = 1,
+export enum GridDirection {
+ Vertical = 0,
+ Horizontal = 1,
}
-export enum ClearFlags {
- Nothing = 0,
- Color = 1,
- Depth = 2,
- ColorAndDepth = 3,
+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 MaskMode {
+ Scissor = 0,
+ Stencil = 1,
+}
+
+export enum UIVisualType {
+ None = 0,
+ SolidColor = 1,
+ Image = 2,
+ NineSlice = 3,
}
// Components
-export interface UIRect {
- anchorMin: Vec2;
- anchorMax: Vec2;
- offsetMin: Vec2;
- offsetMax: Vec2;
- size: Vec2;
- pivot: Vec2;
+export interface BitmapText {
+ text: string;
+ color: Vec4;
+ fontSize: number;
+ align: number;
+ spacing: number;
+ layer: number;
+ font: number;
+ enabled: boolean;
}
-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 Camera {
+ projectionType: number;
+ fov: number;
+ orthoSize: number;
+ nearPlane: number;
+ farPlane: number;
+ aspectRatio: number;
+ isActive: boolean;
+ priority: number;
+ viewport: Vec4;
+ clearFlags: number;
+}
+
+export interface Canvas {
+ designResolution: UVec2;
+ pixelsPerUnit: number;
+ scaleMode: number;
+ matchWidthOrHeight: number;
+ backgroundColor: Vec4;
}
export interface BoxCollider {
@@ -203,6 +211,52 @@ 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;
@@ -247,38 +301,25 @@ export interface ParticleEmitter {
enabled: boolean;
}
-export interface Transform {
- position: Vec3;
- rotation: Quat;
- scale: Vec3;
- worldPosition: Vec3;
- worldRotation: Quat;
- worldScale: Vec3;
+export interface RigidBody {
+ bodyType: number;
+ gravityScale: number;
+ linearDamping: number;
+ angularDamping: number;
+ fixedRotation: boolean;
+ bullet: boolean;
+ enabled: boolean;
}
-export interface UIRenderer {
- visualType: number;
- texture: number;
+export interface ShapeRenderer {
+ shapeType: number;
color: Vec4;
- uvOffset: Vec2;
- uvScale: Vec2;
- sliceBorder: Vec4;
- material: number;
+ size: Vec2;
+ cornerRadius: number;
+ layer: 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;
@@ -296,40 +337,6 @@ export interface SpineAnimation {
enabled: boolean;
}
-export interface Interactable {
- enabled: boolean;
- blockRaycast: boolean;
- raycastTarget: boolean;
-}
-
-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;
@@ -346,19 +353,9 @@ export interface Sprite {
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 StateMachine {
+ current: string;
+ previous: string;
}
export interface StateVisuals {
@@ -399,47 +396,50 @@ export interface StateVisuals {
slot7Scale: number;
}
-export interface Parent {
- entity: number;
+export interface Transform {
+ position: Vec3;
+ rotation: Quat;
+ scale: Vec3;
+ worldPosition: Vec3;
+ worldRotation: Quat;
+ worldScale: Vec3;
}
-export interface Children {
- entities: VectorEntity;
+export interface UIInteraction {
+ hovered: boolean;
+ pressed: boolean;
+ justPressed: boolean;
+ justReleased: boolean;
}
-export interface ShapeRenderer {
- shapeType: number;
- color: Vec4;
- size: Vec2;
- cornerRadius: number;
- layer: number;
+export interface UIMask {
enabled: boolean;
+ mode: number;
}
-export interface StateMachine {
- current: string;
- previous: string;
+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 UIRenderer {
+ visualType: number;
+ texture: number;
+ color: Vec4;
+ uvOffset: Vec2;
+ uvScale: Vec2;
+ sliceBorder: Vec4;
+ material: 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 Velocity {
+ linear: Vec3;
+ angular: Vec3;
}
// Registry
@@ -449,14 +449,18 @@ export interface Registry {
valid(entity: Entity): boolean;
entityCount(): number;
- 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;
+ 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;
hasBoxCollider(entity: Entity): boolean;
getBoxCollider(entity: Entity): BoxCollider;
addBoxCollider(entity: Entity, component: BoxCollider): void;
@@ -473,62 +477,18 @@ export interface Registry {
getSegmentCollider(entity: Entity): SegmentCollider;
addSegmentCollider(entity: Entity, component: SegmentCollider): void;
removeSegmentCollider(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;
- 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;
- 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;
- 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;
- hasUIMask(entity: Entity): boolean;
- getUIMask(entity: Entity): UIMask;
- addUIMask(entity: Entity, component: UIMask): void;
- removeUIMask(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;
+ hasFlexItem(entity: Entity): boolean;
+ getFlexItem(entity: Entity): FlexItem;
+ addFlexItem(entity: Entity, component: FlexItem): void;
+ removeFlexItem(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;
@@ -537,22 +497,62 @@ export interface Registry {
getChildren(entity: Entity): Children;
addChildren(entity: Entity, component: Children): void;
removeChildren(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;
+ 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;
+ 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;
- 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;
+ 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;
// Hierarchy Utilities
setParent(child: Entity, parent: Entity): void;
@@ -567,30 +567,30 @@ export interface ESEngineModule {
* the shipped SDK and the actual WASM module.
*/
getBuiltinComponentNames(): string[];
- UIRect: new () => UIRect;
- FlexItem: new () => FlexItem;
+ BitmapText: new () => BitmapText;
+ Camera: new () => Camera;
+ Canvas: new () => Canvas;
BoxCollider: new () => BoxCollider;
CircleCollider: new () => CircleCollider;
CapsuleCollider: new () => CapsuleCollider;
SegmentCollider: new () => SegmentCollider;
- ParticleEmitter: new () => ParticleEmitter;
- Transform: new () => Transform;
- UIRenderer: new () => UIRenderer;
- GridLayout: new () => GridLayout;
- Velocity: new () => Velocity;
- SpineAnimation: new () => SpineAnimation;
- Interactable: new () => Interactable;
- UIInteraction: new () => UIInteraction;
- RigidBody: new () => RigidBody;
- BitmapText: new () => BitmapText;
- Sprite: new () => Sprite;
- UIMask: new () => UIMask;
FlexContainer: new () => FlexContainer;
- StateVisuals: new () => StateVisuals;
+ FlexItem: new () => FlexItem;
+ GridLayout: new () => GridLayout;
Parent: new () => Parent;
Children: new () => Children;
+ Interactable: new () => Interactable;
+ ParticleEmitter: new () => ParticleEmitter;
+ RigidBody: new () => RigidBody;
ShapeRenderer: new () => ShapeRenderer;
+ SpineAnimation: new () => SpineAnimation;
+ Sprite: new () => Sprite;
StateMachine: new () => StateMachine;
- Canvas: new () => Canvas;
- Camera: new () => Camera;
+ StateVisuals: new () => StateVisuals;
+ Transform: new () => Transform;
+ UIInteraction: new () => UIInteraction;
+ UIMask: new () => UIMask;
+ UIRect: new () => UIRect;
+ UIRenderer: new () => UIRenderer;
+ Velocity: new () => Velocity;
}
diff --git a/sdk/wasm.generated.ts b/sdk/wasm.generated.ts
index eb232d7fc..dd73cc60d 100644
--- a/sdk/wasm.generated.ts
+++ b/sdk/wasm.generated.ts
@@ -561,6 +561,12 @@ export interface Registry {
// 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[];
BitmapText: new () => BitmapText;
Camera: new () => Camera;
Canvas: new () => Canvas;
diff --git a/src/esengine/animation/animTargets.generated.hpp b/src/esengine/animation/animTargets.generated.hpp
index 6ad014b3c..8fd2fb363 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/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/Sprite.hpp"
+#include "../ecs/components/Transform.hpp"
+#include "../ecs/components/UIRect.hpp"
+#include "../ecs/components/UIRenderer.hpp"
#include "../ecs/components/UIRect.hpp"
#include <glm/glm.hpp>
@@ -16,49 +16,49 @@
namespace esengine::animation {
enum class AnimTargetComponent : u8 {
- UIRect = 0,
- Transform = 1,
- UIRenderer = 2,
- BitmapText = 3,
- Sprite = 4,
- Camera = 5,
+ BitmapText = 0,
+ Camera = 1,
+ Sprite = 2,
+ Transform = 3,
+ UIRect = 4,
+ UIRenderer = 5,
Custom = 6,
COUNT
};
enum class AnimTargetField : u8 {
- 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,
+ 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,
CustomField = 32,
COUNT
};
@@ -68,54 +68,59 @@ inline void applyAnimatedValue(
AnimTargetField field, f32 value)
{
switch (field) {
- case AnimTargetField::UIRectAnchorMinX:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->anchorMin.x = value;
+ case AnimTargetField::BitmapTextColorR:
+ if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
+ c->color.r = value;
}
break;
- case AnimTargetField::UIRectAnchorMinY:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->anchorMin.y = value;
+ case AnimTargetField::BitmapTextColorG:
+ if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
+ c->color.g = value;
}
break;
- case AnimTargetField::UIRectAnchorMaxX:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->anchorMax.x = value;
+ case AnimTargetField::BitmapTextColorB:
+ if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
+ c->color.b = value;
}
break;
- case AnimTargetField::UIRectAnchorMaxY:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->anchorMax.y = value;
+ case AnimTargetField::BitmapTextColorA:
+ if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
+ c->color.a = value;
}
break;
- case AnimTargetField::UIRectOffsetMinX:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->offsetMin.x = value;
+ case AnimTargetField::CameraOrthoSize:
+ if (auto* c = registry.tryGet<ecs::Camera>(entity)) {
+ c->orthoSize = value;
}
break;
- case AnimTargetField::UIRectOffsetMinY:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->offsetMin.y = value;
+ case AnimTargetField::SpriteColorR:
+ if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
+ c->color.r = value;
}
break;
- case AnimTargetField::UIRectOffsetMaxX:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->offsetMax.x = value;
+ case AnimTargetField::SpriteColorG:
+ if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
+ c->color.g = value;
}
break;
- case AnimTargetField::UIRectOffsetMaxY:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->offsetMax.y = value;
+ case AnimTargetField::SpriteColorB:
+ if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
+ c->color.b = value;
}
break;
- case AnimTargetField::UIRectPivotX:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->pivot.x = value;
+ case AnimTargetField::SpriteColorA:
+ if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
+ c->color.a = value;
}
break;
- case AnimTargetField::UIRectPivotY:
- if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
- c->pivot.y = value;
+ 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::TransformPositionX:
@@ -159,79 +164,74 @@ inline void applyAnimatedValue(
c->scale.z = value;
}
break;
- case AnimTargetField::UIRendererColorR:
- if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
- c->color.r = value;
- }
- break;
- case AnimTargetField::UIRendererColorG:
- if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
- c->color.g = value;
+ case AnimTargetField::UIRectAnchorMinX:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->anchorMin.x = value;
}
break;
- case AnimTargetField::UIRendererColorB:
- if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
- c->color.b = value;
+ case AnimTargetField::UIRectAnchorMinY:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->anchorMin.y = value;
}
break;
- case AnimTargetField::UIRendererColorA:
- if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
- c->color.a = value;
+ case AnimTargetField::UIRectAnchorMaxX:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->anchorMax.x = value;
}
break;
- case AnimTargetField::BitmapTextColorR:
- if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
- c->color.r = value;
+ case AnimTargetField::UIRectAnchorMaxY:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->anchorMax.y = value;
}
break;
- case AnimTargetField::BitmapTextColorG:
- if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
- c->color.g = value;
+ case AnimTargetField::UIRectOffsetMinX:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->offsetMin.x = value;
}
break;
- case AnimTargetField::BitmapTextColorB:
- if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
- c->color.b = value;
+ case AnimTargetField::UIRectOffsetMinY:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->offsetMin.y = value;
}
break;
- case AnimTargetField::BitmapTextColorA:
- if (auto* c = registry.tryGet<ecs::BitmapText>(entity)) {
- c->color.a = value;
+ case AnimTargetField::UIRectOffsetMaxX:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->offsetMax.x = value;
}
break;
- case AnimTargetField::SpriteColorR:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->color.r = value;
+ case AnimTargetField::UIRectOffsetMaxY:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->offsetMax.y = value;
}
break;
- case AnimTargetField::SpriteColorG:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->color.g = value;
+ case AnimTargetField::UIRectPivotX:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->pivot.x = value;
}
break;
- case AnimTargetField::SpriteColorB:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->color.b = value;
+ case AnimTargetField::UIRectPivotY:
+ if (auto* c = registry.tryGet<ecs::UIRect>(entity)) {
+ c->pivot.y = value;
}
break;
- case AnimTargetField::SpriteColorA:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->color.a = value;
+ case AnimTargetField::UIRendererColorR:
+ if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ c->color.r = value;
}
break;
- case AnimTargetField::SpriteSizeX:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->size.x = value;
+ case AnimTargetField::UIRendererColorG:
+ if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ c->color.g = value;
}
break;
- case AnimTargetField::SpriteSizeY:
- if (auto* c = registry.tryGet<ecs::Sprite>(entity)) {
- c->size.y = value;
+ case AnimTargetField::UIRendererColorB:
+ if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ c->color.b = value;
}
break;
- case AnimTargetField::CameraOrthoSize:
- if (auto* c = registry.tryGet<ecs::Camera>(entity)) {
- c->orthoSize = value;
+ case AnimTargetField::UIRendererColorA:
+ if (auto* c = registry.tryGet<ecs::UIRenderer>(entity)) {
+ c->color.a = value;
}
break;
case AnimTargetField::CustomField:
diff --git a/src/esengine/bindings/EditorAPI.generated.cpp b/src/esengine/bindings/EditorAPI.generated.cpp
index c5007cd1d..045ab2889 100644
--- a/src/esengine/bindings/EditorAPI.generated.cpp
+++ b/src/esengine/bindings/EditorAPI.generated.cpp
@@ -2,8 +2,11 @@
* @file EditorAPI.generated.cpp
* @brief Auto-generated editor API with string-dispatched component access
* @details Generated by EHT - DO NOT EDIT
+ * @schema_hash 3aac921bfb4e31df
*/
+#define ES_EDITOR_API_SCHEMA_HASH "3aac921bfb4e31df"
+
#ifdef ES_PLATFORM_WEB
#include <emscripten/bind.h>
@@ -51,70 +54,79 @@ inline glm::quat eulerDegToQuat(const glm::vec3& deg) {
std::vector<std::string> editor_getComponentNames() {
return {
- "UIRect",
- "FlexItem",
+ "BitmapText",
+ "Camera",
+ "Canvas",
"BoxCollider",
"CircleCollider",
"CapsuleCollider",
"SegmentCollider",
- "ParticleEmitter",
- "Transform",
- "UIRenderer",
- "GridLayout",
- "Velocity",
- "SpineAnimation",
- "Interactable",
- "UIInteraction",
- "RigidBody",
- "BitmapText",
- "Sprite",
- "UIMask",
"FlexContainer",
- "StateVisuals",
+ "FlexItem",
+ "GridLayout",
"Parent",
"Children",
+ "Interactable",
+ "ParticleEmitter",
+ "RigidBody",
"ShapeRenderer",
+ "SpineAnimation",
+ "Sprite",
"StateMachine",
- "Canvas",
- "Camera",
+ "StateVisuals",
+ "Transform",
+ "UIInteraction",
+ "UIMask",
+ "UIRect",
+ "UIRenderer",
+ "Velocity",
};
}
// ── Component Schema (JSON) ──
std::string editor_getComponentSchema(const std::string& name) {
- if (name == "UIRect") {
+ if (name == "BitmapText") {
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":"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 == "FlexItem") {
+ } else if (name == "Camera") {
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"}
+ {"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";
+ } else if (name == "Canvas") {
+ 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"}
])JSON";
} else if (name == "BoxCollider") {
return R"JSON([
@@ -171,6 +183,61 @@ 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"},
@@ -223,54 +290,28 @@ std::string editor_getComponentSchema(const std::string& name) {
{"key":"simulationSpace","type":"int","group":"ParticleEmitter"},
{"key":"enabled","type":"bool","group":"ParticleEmitter"}
])JSON";
- } else if (name == "Transform") {
- 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"}
- ])JSON";
- } else if (name == "UIRenderer") {
- 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"}
- ])JSON";
- } else if (name == "GridLayout") {
+ } else if (name == "RigidBody") {
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"}
+ {"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 == "Velocity") {
+ } else if (name == "ShapeRenderer") {
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":"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 == "SpineAnimation") {
return R"JSON([
@@ -292,43 +333,6 @@ 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"},
@@ -354,24 +358,10 @@ std::string editor_getComponentSchema(const std::string& name) {
{"key":"material","type":"asset","group":"Sprite"},
{"key":"enabled","type":"bool","group":"Sprite"}
])JSON";
- } else if (name == "UIMask") {
- return R"JSON([
- {"key":"enabled","type":"bool","group":"UIMask"},
- {"key":"mode","type":"enum","group":"UIMask","values":["Scissor","Stencil"]}
- ])JSON";
- } else if (name == "FlexContainer") {
+ } else if (name == "StateMachine") {
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"}
+ {"key":"current","type":"string","group":"StateMachine"},
+ {"key":"previous","type":"string","group":"StateMachine"}
])JSON";
} else if (name == "StateVisuals") {
return R"JSON([
@@ -435,59 +425,72 @@ std::string editor_getComponentSchema(const std::string& name) {
{"key":"slot7Sprite","type":"asset","group":"StateVisuals"},
{"key":"slot7Scale","type":"float","group":"StateVisuals"}
])JSON";
- } else if (name == "Parent") {
+ } else if (name == "Transform") {
return R"JSON([
- {"key":"entity","type":"entity","group":"Parent"}
+ {"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 == "Children") {
+ } else if (name == "UIInteraction") {
return R"JSON([
- {"key":"entities","type":"entity","group":"Children"}
+ {"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 == "ShapeRenderer") {
+ } else if (name == "UIMask") {
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":"enabled","type":"bool","group":"UIMask"},
+ {"key":"mode","type":"enum","group":"UIMask","values":["Scissor","Stencil"]}
])JSON";
- } else if (name == "StateMachine") {
+ } else if (name == "UIRect") {
return R"JSON([
- {"key":"current","type":"string","group":"StateMachine"},
- {"key":"previous","type":"string","group":"StateMachine"}
+ {"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 == "UIRenderer") {
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":"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 == "Camera") {
+ } else if (name == "Velocity") {
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":"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";
}
return "[]";
@@ -498,11 +501,14 @@ 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 == "UIRect") {
- if (!reg.has<esengine::ecs::UIRect>(entity)) reg.emplace<esengine::ecs::UIRect>(entity);
+ if (name == "BitmapText") {
+ if (!reg.has<esengine::ecs::BitmapText>(entity)) reg.emplace<esengine::ecs::BitmapText>(entity);
return true;
- } else if (name == "FlexItem") {
- if (!reg.has<esengine::ecs::FlexItem>(entity)) reg.emplace<esengine::ecs::FlexItem>(entity);
+ } else if (name == "Camera") {
+ if (!reg.has<esengine::ecs::Camera>(entity)) reg.emplace<esengine::ecs::Camera>(entity);
+ return true;
+ } else if (name == "Canvas") {
+ if (!reg.has<esengine::ecs::Canvas>(entity)) reg.emplace<esengine::ecs::Canvas>(entity);
return true;
} else if (name == "BoxCollider") {
if (!reg.has<esengine::ecs::BoxCollider>(entity)) reg.emplace<esengine::ecs::BoxCollider>(entity);
@@ -516,65 +522,62 @@ 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 == "ParticleEmitter") {
- if (!reg.has<esengine::ecs::ParticleEmitter>(entity)) reg.emplace<esengine::ecs::ParticleEmitter>(entity);
- return true;
- } else if (name == "Transform") {
- if (!reg.has<esengine::ecs::Transform>(entity)) reg.emplace<esengine::ecs::Transform>(entity);
+ } else if (name == "FlexContainer") {
+ if (!reg.has<esengine::ecs::FlexContainer>(entity)) reg.emplace<esengine::ecs::FlexContainer>(entity);
return true;
- } else if (name == "UIRenderer") {
- if (!reg.has<esengine::ecs::UIRenderer>(entity)) reg.emplace<esengine::ecs::UIRenderer>(entity);
+ } else if (name == "FlexItem") {
+ if (!reg.has<esengine::ecs::FlexItem>(entity)) reg.emplace<esengine::ecs::FlexItem>(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 == "Velocity") {
- if (!reg.has<esengine::ecs::Velocity>(entity)) reg.emplace<esengine::ecs::Velocity>(entity);
+ } else if (name == "Parent") {
+ if (!reg.has<esengine::ecs::Parent>(entity)) reg.emplace<esengine::ecs::Parent>(entity);
return true;
- } else if (name == "SpineAnimation") {
- if (!reg.has<esengine::ecs::SpineAnimation>(entity)) reg.emplace<esengine::ecs::SpineAnimation>(entity);
+ } else if (name == "Children") {
+ if (!reg.has<esengine::ecs::Children>(entity)) reg.emplace<esengine::ecs::Children>(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 == "UIInteraction") {
- if (!reg.has<esengine::ecs::UIInteraction>(entity)) reg.emplace<esengine::ecs::UIInteraction>(entity);
+ } else if (name == "ParticleEmitter") {
+ if (!reg.has<esengine::ecs::ParticleEmitter>(entity)) reg.emplace<esengine::ecs::ParticleEmitter>(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 == "BitmapText") {
- if (!reg.has<esengine::ecs::BitmapText>(entity)) reg.emplace<esengine::ecs::BitmapText>(entity);
+ } 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);
return true;
} else if (name == "Sprite") {
if (!reg.has<esengine::ecs::Sprite>(entity)) reg.emplace<esengine::ecs::Sprite>(entity);
return true;
- } 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);
+ } else if (name == "StateMachine") {
+ if (!reg.has<esengine::ecs::StateMachine>(entity)) reg.emplace<esengine::ecs::StateMachine>(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 == "Parent") {
- if (!reg.has<esengine::ecs::Parent>(entity)) reg.emplace<esengine::ecs::Parent>(entity);
+ } else if (name == "Transform") {
+ if (!reg.has<esengine::ecs::Transform>(entity)) reg.emplace<esengine::ecs::Transform>(entity);
return true;
- } else if (name == "Children") {
- if (!reg.has<esengine::ecs::Children>(entity)) reg.emplace<esengine::ecs::Children>(entity);
+ } else if (name == "UIInteraction") {
+ if (!reg.has<esengine::ecs::UIInteraction>(entity)) reg.emplace<esengine::ecs::UIInteraction>(entity);
return true;
- } else if (name == "ShapeRenderer") {
- if (!reg.has<esengine::ecs::ShapeRenderer>(entity)) reg.emplace<esengine::ecs::ShapeRenderer>(entity);
+ } else if (name == "UIMask") {
+ if (!reg.has<esengine::ecs::UIMask>(entity)) reg.emplace<esengine::ecs::UIMask>(entity);
return true;
- } else if (name == "StateMachine") {
- if (!reg.has<esengine::ecs::StateMachine>(entity)) reg.emplace<esengine::ecs::StateMachine>(entity);
+ } else 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 == "UIRenderer") {
+ if (!reg.has<esengine::ecs::UIRenderer>(entity)) reg.emplace<esengine::ecs::UIRenderer>(entity);
return true;
- } else if (name == "Camera") {
- if (!reg.has<esengine::ecs::Camera>(entity)) reg.emplace<esengine::ecs::Camera>(entity);
+ } else if (name == "Velocity") {
+ if (!reg.has<esengine::ecs::Velocity>(entity)) reg.emplace<esengine::ecs::Velocity>(entity);
return true;
}
return false;
@@ -583,10 +586,12 @@ 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 == "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; }
+ 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; }
} else if (name == "BoxCollider") {
if (reg.has<esengine::ecs::BoxCollider>(entity)) { reg.remove<esengine::ecs::BoxCollider>(entity); return true; }
} else if (name == "CircleCollider") {
@@ -595,46 +600,44 @@ 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 == "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 == "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 == "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 == "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 == "UIMask") {
- if (reg.has<esengine::ecs::UIMask>(entity)) { reg.remove<esengine::ecs::UIMask>(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 == "FlexItem") {
+ if (reg.has<esengine::ecs::FlexItem>(entity)) { reg.remove<esengine::ecs::FlexItem>(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 == "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 == "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 == "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 == "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; }
+ } 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; }
}
return false;
}
@@ -642,32 +645,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 == "UIRect") return reg.has<esengine::ecs::UIRect>(entity);
- if (name == "FlexItem") return reg.has<esengine::ecs::FlexItem>(entity);
+ 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 == "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 == "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 == "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 == "UIInteraction") return reg.has<esengine::ecs::UIInteraction>(entity);
- if (name == "RigidBody") return reg.has<esengine::ecs::RigidBody>(entity);
- if (name == "BitmapText") return reg.has<esengine::ecs::BitmapText>(entity);
- if (name == "Sprite") return reg.has<esengine::ecs::Sprite>(entity);
- if (name == "UIMask") return reg.has<esengine::ecs::UIMask>(entity);
if (name == "FlexContainer") return reg.has<esengine::ecs::FlexContainer>(entity);
- if (name == "StateVisuals") return reg.has<esengine::ecs::StateVisuals>(entity);
+ if (name == "FlexItem") return reg.has<esengine::ecs::FlexItem>(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 == "Interactable") return reg.has<esengine::ecs::Interactable>(entity);
+ if (name == "ParticleEmitter") return reg.has<esengine::ecs::ParticleEmitter>(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 == "Sprite") return reg.has<esengine::ecs::Sprite>(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);
+ 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);
return false;
}
@@ -677,32 +680,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::UIRect>(entity)) result.push_back("UIRect");
- if (reg.has<esengine::ecs::FlexItem>(entity)) result.push_back("FlexItem");
+ 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::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::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::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::UIInteraction>(entity)) result.push_back("UIInteraction");
- if (reg.has<esengine::ecs::RigidBody>(entity)) result.push_back("RigidBody");
- 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::UIMask>(entity)) result.push_back("UIMask");
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::FlexItem>(entity)) result.push_back("FlexItem");
+ 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::Interactable>(entity)) result.push_back("Interactable");
+ if (reg.has<esengine::ecs::ParticleEmitter>(entity)) result.push_back("ParticleEmitter");
+ 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::Sprite>(entity)) result.push_back("Sprite");
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");
+ 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");
return result;
}
@@ -711,39 +714,40 @@ 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 == "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; }
+ 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 == "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 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;
+ } 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 == "BoxCollider") {
@@ -793,6 +797,44 @@ 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);
@@ -831,67 +873,24 @@ 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 == "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 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 == "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 { 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 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 == "SpineAnimation") {
@@ -902,26 +901,7 @@ bool editor_setFloat(Registry& reg, u32 e, const std::string& comp, const std::s
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 == "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 if (field == "skeletonScale") { c.skeletonScale = value; }
else { return false; }
return true;
} else if (comp == "Sprite") {
@@ -945,17 +925,6 @@ 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);
@@ -1002,41 +971,75 @@ 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 == "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 (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 == "cornerRadius") { c.cornerRadius = 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 == "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 == "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 == "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 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;
}
@@ -1048,37 +1051,36 @@ 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 == "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; }
+ 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; }
} else if (comp == "BoxCollider") {
if (!reg.has<esengine::ecs::BoxCollider>(entity)) return 0.0f;
const auto& c = reg.get<esengine::ecs::BoxCollider>(entity);
@@ -1118,6 +1120,38 @@ 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);
@@ -1154,73 +1188,31 @@ 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 == "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 == "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);
- if (field == "timeScale") { return c.timeScale; }
- else 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 == "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);
+ } 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 == "fontSize") { return c.fontSize; }
- else if (field == "spacing") { return c.spacing; }
+ 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 == "SpineAnimation") {
+ if (!reg.has<esengine::ecs::SpineAnimation>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::SpineAnimation>(entity);
+ if (field == "timeScale") { return c.timeScale; }
+ else 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 == "skeletonScale") { return c.skeletonScale; }
} else if (comp == "Sprite") {
if (!reg.has<esengine::ecs::Sprite>(entity)) return 0.0f;
const auto& c = reg.get<esengine::ecs::Sprite>(entity);
@@ -1240,15 +1232,6 @@ 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);
@@ -1293,37 +1276,57 @@ 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 == "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 == "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);
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 (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; }
+ 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; }
}
return 0.0f;
}
@@ -1333,11 +1336,26 @@ 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 == "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); }
+ 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 if (field == "font") { c.font = resource::BitmapFontHandle(static_cast<u32>(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); }
else { return false; }
return true;
} else if (comp == "BoxCollider") {
@@ -1368,6 +1386,36 @@ 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);
@@ -1385,19 +1433,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 == "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 (field == "texture") { c.texture = resource::TextureHandle(static_cast<u32>(value)); }
- else if (field == "material") { c.material = static_cast<u32>(value); }
+ } 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 == "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 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 == "SpineAnimation") {
@@ -1407,20 +1453,6 @@ bool editor_setInt(Registry& reg, u32 e, const std::string& comp, const std::str
else if (field == "material") { c.material = static_cast<u32>(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 if (field == "font") { c.font = resource::BitmapFontHandle(static_cast<u32>(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);
@@ -1429,22 +1461,6 @@ bool editor_setInt(Registry& reg, u32 e, const std::string& comp, const std::str
else if (field == "material") { c.material = 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 { 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);
@@ -1460,31 +1476,18 @@ bool editor_setInt(Registry& reg, u32 e, const std::string& comp, const std::str
else if (field == "slot7Sprite") { c.slot7Sprite = resource::TextureHandle(static_cast<u32>(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 == "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 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 == "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 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 (field == "texture") { c.texture = resource::TextureHandle(static_cast<u32>(value)); }
+ else if (field == "material") { c.material = static_cast<u32>(value); }
else { return false; }
return true;
}
@@ -1496,11 +1499,22 @@ 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 == "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); }
+ 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 (field == "font") { return static_cast<i32>(c.font.id()); }
+ } 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); }
} else if (comp == "BoxCollider") {
if (!reg.has<esengine::ecs::BoxCollider>(entity)) return 0;
const auto& c = reg.get<esengine::ecs::BoxCollider>(entity);
@@ -1521,6 +1535,28 @@ 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);
@@ -1536,50 +1572,26 @@ i32 editor_getInt(Registry& reg, u32 e, const std::string& comp, const std::stri
else if (field == "layer") { return static_cast<i32>(c.layer); }
else if (field == "material") { return static_cast<i32>(c.material); }
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 (field == "texture") { return static_cast<i32>(c.texture.id()); }
- else if (field == "material") { return static_cast<i32>(c.material); }
- } 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 (field == "material") { return static_cast<i32>(c.material); }
} 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 == "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 (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 (field == "font") { return static_cast<i32>(c.font.id()); }
+ } 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 (field == "material") { return static_cast<i32>(c.material); }
} else if (comp == "Sprite") {
if (!reg.has<esengine::ecs::Sprite>(entity)) return 0;
const auto& c = reg.get<esengine::ecs::Sprite>(entity);
if (field == "texture") { return static_cast<i32>(c.texture.id()); }
else if (field == "layer") { return static_cast<i32>(c.layer); }
else if (field == "material") { return static_cast<i32>(c.material); }
- } 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);
@@ -1593,25 +1605,16 @@ i32 editor_getInt(Registry& reg, u32 e, const std::string& comp, const std::stri
else if (field == "slot5Sprite") { return static_cast<i32>(c.slot5Sprite.id()); }
else if (field == "slot6Sprite") { return static_cast<i32>(c.slot6Sprite.id()); }
else if (field == "slot7Sprite") { return static_cast<i32>(c.slot7Sprite.id()); }
- } 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); }
+ } 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 (field == "texture") { return static_cast<i32>(c.texture.id()); }
+ else if (field == "material") { return static_cast<i32>(c.material); }
}
return 0;
}
@@ -1621,7 +1624,19 @@ 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 == "BoxCollider") {
+ 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 (!reg.has<esengine::ecs::BoxCollider>(entity)) return false;
auto& c = reg.get<esengine::ecs::BoxCollider>(entity);
if (field == "isSensor") { c.isSensor = value; }
@@ -1649,6 +1664,14 @@ 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);
@@ -1658,9 +1681,17 @@ 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 == "UIRenderer") {
- if (!reg.has<esengine::ecs::UIRenderer>(entity)) return false;
- auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
+ } 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);
if (field == "enabled") { c.enabled = value; }
else { return false; }
return true;
@@ -1674,12 +1705,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 == "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 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 == "UIInteraction") {
@@ -1691,46 +1722,18 @@ 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 == "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;
- } 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;
}
@@ -1740,7 +1743,15 @@ 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 == "BoxCollider") {
+ 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 (!reg.has<esengine::ecs::BoxCollider>(entity)) return false;
const auto& c = reg.get<esengine::ecs::BoxCollider>(entity);
if (field == "isSensor") { return c.isSensor; }
@@ -1760,6 +1771,12 @@ 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);
@@ -1767,9 +1784,15 @@ 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 == "UIRenderer") {
- if (!reg.has<esengine::ecs::UIRenderer>(entity)) return false;
- const auto& c = reg.get<esengine::ecs::UIRenderer>(entity);
+ } 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);
if (field == "enabled") { return c.enabled; }
} else if (comp == "SpineAnimation") {
if (!reg.has<esengine::ecs::SpineAnimation>(entity)) return false;
@@ -1779,12 +1802,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 == "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 == "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 == "UIInteraction") {
if (!reg.has<esengine::ecs::UIInteraction>(entity)) return false;
const auto& c = reg.get<esengine::ecs::UIInteraction>(entity);
@@ -1792,38 +1815,98 @@ 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 == "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 == "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;
}
+// ── Set String Property ──
+
+bool editor_setString(Registry& reg, u32 e, const std::string& comp, const std::string& field, const std::string& 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 == "text") { c.text = value; }
+ else { return false; }
+ return true;
+ } else if (comp == "SpineAnimation") {
+ if (!reg.has<esengine::ecs::SpineAnimation>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::SpineAnimation>(entity);
+ if (field == "skeletonPath") { c.skeletonPath = value; }
+ else if (field == "atlasPath") { c.atlasPath = value; }
+ else if (field == "skin") { c.skin = value; }
+ else if (field == "animation") { c.animation = value; }
+ else { return false; }
+ return true;
+ } else if (comp == "StateMachine") {
+ if (!reg.has<esengine::ecs::StateMachine>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::StateMachine>(entity);
+ if (field == "current") { c.current = value; }
+ else if (field == "previous") { c.previous = 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);
+ if (field == "slot0Name") { c.slot0Name = value; }
+ else if (field == "slot1Name") { c.slot1Name = value; }
+ else if (field == "slot2Name") { c.slot2Name = value; }
+ else if (field == "slot3Name") { c.slot3Name = value; }
+ else if (field == "slot4Name") { c.slot4Name = value; }
+ else if (field == "slot5Name") { c.slot5Name = value; }
+ else if (field == "slot6Name") { c.slot6Name = value; }
+ else if (field == "slot7Name") { c.slot7Name = value; }
+ else { return false; }
+ return true;
+ }
+ return false;
+}
+
+// ── Get String Property ──
+
+std::string editor_getString(Registry& reg, u32 e, const std::string& comp, const std::string& field) {
+ auto entity = static_cast<Entity>(e);
+ if (!reg.valid(entity)) return std::string{};
+ if (comp == "BitmapText") {
+ if (!reg.has<esengine::ecs::BitmapText>(entity)) return std::string{};
+ const auto& c = reg.get<esengine::ecs::BitmapText>(entity);
+ if (field == "text") { return c.text; }
+ } else if (comp == "SpineAnimation") {
+ if (!reg.has<esengine::ecs::SpineAnimation>(entity)) return std::string{};
+ const auto& c = reg.get<esengine::ecs::SpineAnimation>(entity);
+ if (field == "skeletonPath") { return c.skeletonPath; }
+ else if (field == "atlasPath") { return c.atlasPath; }
+ else if (field == "skin") { return c.skin; }
+ else if (field == "animation") { return c.animation; }
+ } else if (comp == "StateMachine") {
+ if (!reg.has<esengine::ecs::StateMachine>(entity)) return std::string{};
+ const auto& c = reg.get<esengine::ecs::StateMachine>(entity);
+ if (field == "current") { return c.current; }
+ else if (field == "previous") { return c.previous; }
+ } else if (comp == "StateVisuals") {
+ if (!reg.has<esengine::ecs::StateVisuals>(entity)) return std::string{};
+ const auto& c = reg.get<esengine::ecs::StateVisuals>(entity);
+ if (field == "slot0Name") { return c.slot0Name; }
+ else if (field == "slot1Name") { return c.slot1Name; }
+ else if (field == "slot2Name") { return c.slot2Name; }
+ else if (field == "slot3Name") { return c.slot3Name; }
+ else if (field == "slot4Name") { return c.slot4Name; }
+ else if (field == "slot5Name") { return c.slot5Name; }
+ else if (field == "slot6Name") { return c.slot6Name; }
+ else if (field == "slot7Name") { return c.slot7Name; }
+ }
+ return std::string{};
+}
+
} // anonymous namespace
// ── Embind Registration ──
@@ -1843,6 +1926,8 @@ EMSCRIPTEN_BINDINGS(esengine_editor_api) {
emscripten::function("editor_getInt", &editor_getInt);
emscripten::function("editor_setBool", &editor_setBool);
emscripten::function("editor_getBool", &editor_getBool);
+ emscripten::function("editor_setString", &editor_setString);
+ emscripten::function("editor_getString", &editor_getString);
emscripten::register_vector<std::string>("VectorString");
}
diff --git a/src/esengine/bindings/TilemapBindings.cpp b/src/esengine/bindings/TilemapBindings.cpp
index ba9b70657..123486540 100644
--- a/src/esengine/bindings/TilemapBindings.cpp
+++ b/src/esengine/bindings/TilemapBindings.cpp
@@ -535,8 +535,7 @@ std::string tilemap_getTileProperty(u32 entity, i32 x, i32 y,
u16 raw = getTilemapSystem().getTile(e, x, y);
u16 tileId = raw & tilemap::TILE_ID_MASK;
if (tileId == tilemap::EMPTY_TILE) return "";
- const char* val = getTilemapSystem().getTileProperty(e, tileId, key);
- return val ? std::string(val) : "";
+ return getTilemapSystem().getTileProperty(e, tileId, key);
}
void tilemap_flipTile(u32 entity, i32 x, i32 y,
diff --git a/src/esengine/bindings/WebBindings.generated.cpp b/src/esengine/bindings/WebBindings.generated.cpp
index 43f9db58c..81fa04b1a 100644
--- a/src/esengine/bindings/WebBindings.generated.cpp
+++ b/src/esengine/bindings/WebBindings.generated.cpp
@@ -80,46 +80,27 @@ 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::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::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::FlexDirection>("FlexDirection")
.value("Row", esengine::ecs::FlexDirection::Row)
@@ -153,22 +134,41 @@ EMSCRIPTEN_BINDINGS(esengine_enums) {
.value("SpaceBetween", esengine::ecs::AlignContent::SpaceBetween)
.value("SpaceAround", esengine::ecs::AlignContent::SpaceAround);
- 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::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::ProjectionType>("ProjectionType")
- .value("Perspective", esengine::ecs::ProjectionType::Perspective)
- .value("Orthographic", esengine::ecs::ProjectionType::Orthographic);
+ enum_<esengine::ecs::GridDirection>("GridDirection")
+ .value("Vertical", esengine::ecs::GridDirection::Vertical)
+ .value("Horizontal", esengine::ecs::GridDirection::Horizontal);
- 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::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::MaskMode>("MaskMode")
+ .value("Scissor", esengine::ecs::MaskMode::Scissor)
+ .value("Stencil", esengine::ecs::MaskMode::Stencil);
+
+ 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);
}
@@ -176,6 +176,148 @@ 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;
@@ -225,6 +367,65 @@ 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;
@@ -361,68 +562,6 @@ 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;
@@ -457,43 +596,6 @@ 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;
@@ -546,59 +648,6 @@ 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;
@@ -717,135 +766,93 @@ StateVisualsJS statevisualsToJS(const esengine::ecs::StateVisuals& c) {
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 CanvasJS {
- glm::uvec2 designResolution;
- f32 pixelsPerUnit;
- i32 scaleMode;
- f32 matchWidthOrHeight;
- glm::vec4 backgroundColor;
+struct UIMaskJS {
+ bool enabled;
+ i32 mode;
};
-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;
+esengine::ecs::UIMask uimaskFromJS(const UIMaskJS& js) {
+ esengine::ecs::UIMask c;
+ c.enabled = js.enabled;
+ c.mode = static_cast<MaskMode>(js.mode);
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;
+UIMaskJS uimaskToJS(const esengine::ecs::UIMask& c) {
+ UIMaskJS js;
+ js.enabled = c.enabled;
+ js.mode = static_cast<i32>(c.mode);
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);
+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;
}
-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);
+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;
}
EMSCRIPTEN_BINDINGS(esengine_components) {
register_vector<u32>("VectorEntity");
- 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<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<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<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<CanvasJS>("Canvas")
+ .field("designResolution", &CanvasJS::designResolution)
+ .field("pixelsPerUnit", &CanvasJS::pixelsPerUnit)
+ .field("scaleMode", &CanvasJS::scaleMode)
+ .field("matchWidthOrHeight", &CanvasJS::matchWidthOrHeight)
+ .field("backgroundColor", &CanvasJS::backgroundColor);
value_object<esengine::ecs::BoxCollider>("BoxCollider")
.field("halfExtents", &esengine::ecs::BoxCollider::halfExtents)
@@ -892,6 +899,46 @@ 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)
@@ -935,33 +982,22 @@ EMSCRIPTEN_BINDINGS(esengine_components) {
.field("simulationSpace", &ParticleEmitterJS::simulationSpace)
.field("enabled", &ParticleEmitterJS::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<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<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::Velocity>("Velocity")
- .field("linear", &esengine::ecs::Velocity::linear)
- .field("angular", &esengine::ecs::Velocity::angular);
+ 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<esengine::ecs::SpineAnimation>("SpineAnimation")
.field("skeletonPath", &esengine::ecs::SpineAnimation::skeletonPath)
@@ -979,36 +1015,6 @@ 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)
@@ -1024,18 +1030,9 @@ EMSCRIPTEN_BINDINGS(esengine_components) {
.field("material", &SpriteJS::material)
.field("enabled", &SpriteJS::enabled);
- 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<esengine::ecs::StateMachine>("StateMachine")
+ .field("current", &esengine::ecs::StateMachine::current)
+ .field("previous", &esengine::ecs::StateMachine::previous);
value_object<StateVisualsJS>("StateVisuals")
.field("targetGraphic", &StateVisualsJS::targetGraphic)
@@ -1074,42 +1071,45 @@ EMSCRIPTEN_BINDINGS(esengine_components) {
.field("slot7Sprite", &StateVisualsJS::slot7Sprite)
.field("slot7Scale", &StateVisualsJS::slot7Scale);
- value_object<ParentJS>("Parent")
- .field("entity", &ParentJS::entity);
-
- value_object<ChildrenJS>("Children")
- .field("entities", &ChildrenJS::entities);
+ 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<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<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<CanvasJS>("Canvas")
- .field("designResolution", &CanvasJS::designResolution)
- .field("pixelsPerUnit", &CanvasJS::pixelsPerUnit)
- .field("scaleMode", &CanvasJS::scaleMode)
- .field("matchWidthOrHeight", &CanvasJS::matchWidthOrHeight)
- .field("backgroundColor", &CanvasJS::backgroundColor);
+ 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<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<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::Velocity>("Velocity")
+ .field("linear", &esengine::ecs::Velocity::linear)
+ .field("angular", &esengine::ecs::Velocity::angular);
}
@@ -1131,45 +1131,64 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
}))
.function("entityCount", &Registry::entityCount)
- // UIRect
- .function("hasUIRect", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::UIRect>(static_cast<Entity>(e));
+ // BitmapText
+ .function("hasBitmapText", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::BitmapText>(static_cast<Entity>(e));
}))
- .function("getUIRect", optional_override([](Registry& r, u32 e) -> esengine::ecs::UIRect& {
+ .function("getBitmapText", optional_override([](Registry& r, u32 e) {
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);
- }), allow_raw_pointers())
- .function("addUIRect", optional_override([](Registry& r, u32 e, const esengine::ecs::UIRect& c) {
+ 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::UIRect>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::BitmapText>(entity, bitmaptextFromJS(js));
}))
- .function("removeUIRect", 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::UIRect>(entity)) return;
- r.remove<esengine::ecs::UIRect>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::BitmapText>(entity)) return;
+ r.remove<esengine::ecs::BitmapText>(entity);
}))
- // FlexItem
- .function("hasFlexItem", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::FlexItem>(static_cast<Entity>(e));
+ // Camera
+ .function("hasCamera", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Camera>(static_cast<Entity>(e));
}))
- .function("getFlexItem", optional_override([](Registry& r, u32 e) {
+ .function("getCamera", optional_override([](Registry& r, u32 e) {
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));
+ if (!r.valid(entity) || !r.has<esengine::ecs::Camera>(entity)) return CameraJS{};
+ return cameraToJS(r.get<esengine::ecs::Camera>(entity));
}))
- .function("addFlexItem", optional_override([](Registry& r, u32 e, const FlexItemJS& js) {
+ .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::FlexItem>(entity, flexitemFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::Camera>(entity, cameraFromJS(js));
}))
- .function("removeFlexItem", 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::FlexItem>(entity)) return;
- r.remove<esengine::ecs::FlexItem>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::Camera>(entity)) return;
+ r.remove<esengine::ecs::Camera>(entity);
+ }))
+
+ // Canvas
+ .function("hasCanvas", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Canvas>(static_cast<Entity>(e));
+ }))
+ .function("getCanvas", 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));
+ }))
+ .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::Canvas>(entity, canvasFromJS(js));
+ }))
+ .function("removeCanvas", 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);
}))
// BoxCollider
@@ -1256,67 +1275,44 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::SegmentCollider>(entity);
}))
- // ParticleEmitter
- .function("hasParticleEmitter", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::ParticleEmitter>(static_cast<Entity>(e));
- }))
- .function("getParticleEmitter", optional_override([](Registry& r, u32 e) {
- 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) {
- auto entity = static_cast<Entity>(e);
- if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::ParticleEmitter>(entity, particleemitterFromJS(js));
+ // FlexContainer
+ .function("hasFlexContainer", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::FlexContainer>(static_cast<Entity>(e));
}))
- .function("removeParticleEmitter", optional_override([](Registry& r, u32 e) {
+ .function("getFlexContainer", 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);
- }))
-
- // Transform
- .function("hasTransform", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::Transform>(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("getTransform", optional_override([](Registry& r, u32 e) -> esengine::ecs::Transform& {
- 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) {
+ .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::Transform>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::FlexContainer>(entity, flexcontainerFromJS(js));
}))
- .function("removeTransform", optional_override([](Registry& r, u32 e) {
+ .function("removeFlexContainer", 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::FlexContainer>(entity)) return;
+ r.remove<esengine::ecs::FlexContainer>(entity);
}))
- // UIRenderer
- .function("hasUIRenderer", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::UIRenderer>(static_cast<Entity>(e));
+ // FlexItem
+ .function("hasFlexItem", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::FlexItem>(static_cast<Entity>(e));
}))
- .function("getUIRenderer", 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::UIRenderer>(entity)) return UIRendererJS{};
- return uirendererToJS(r.get<esengine::ecs::UIRenderer>(entity));
+ if (!r.valid(entity) || !r.has<esengine::ecs::FlexItem>(entity)) return FlexItemJS{};
+ return flexitemToJS(r.get<esengine::ecs::FlexItem>(entity));
}))
- .function("addUIRenderer", optional_override([](Registry& r, u32 e, const UIRendererJS& 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::UIRenderer>(entity, uirendererFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::FlexItem>(entity, flexitemFromJS(js));
}))
- .function("removeUIRenderer", 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::UIRenderer>(entity)) return;
- r.remove<esengine::ecs::UIRenderer>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::FlexItem>(entity)) return;
+ r.remove<esengine::ecs::FlexItem>(entity);
}))
// GridLayout
@@ -1339,46 +1335,44 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::GridLayout>(entity);
}))
- // Velocity
- .function("hasVelocity", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::Velocity>(static_cast<Entity>(e));
+ // Parent
+ .function("hasParent", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Parent>(static_cast<Entity>(e));
}))
- .function("getVelocity", optional_override([](Registry& r, u32 e) -> esengine::ecs::Velocity& {
+ .function("getParent", 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::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::Velocity>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::Parent>(entity, parentFromJS(js));
}))
- .function("removeVelocity", 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::Velocity>(entity)) return;
- r.remove<esengine::ecs::Velocity>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::Parent>(entity)) return;
+ r.remove<esengine::ecs::Parent>(entity);
}))
- // SpineAnimation
- .function("hasSpineAnimation", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::SpineAnimation>(static_cast<Entity>(e));
+ // Children
+ .function("hasChildren", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Children>(static_cast<Entity>(e));
}))
- .function("getSpineAnimation", optional_override([](Registry& r, u32 e) -> esengine::ecs::SpineAnimation& {
+ .function("getChildren", optional_override([](Registry& r, u32 e) {
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) {
+ 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::SpineAnimation>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::Children>(entity, childrenFromJS(js));
}))
- .function("removeSpineAnimation", 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::SpineAnimation>(entity)) return;
- r.remove<esengine::ecs::SpineAnimation>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::Children>(entity)) return;
+ r.remove<esengine::ecs::Children>(entity);
}))
// Interactable
@@ -1402,25 +1396,24 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::Interactable>(entity);
}))
- // UIInteraction
- .function("hasUIInteraction", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::UIInteraction>(static_cast<Entity>(e));
+ // ParticleEmitter
+ .function("hasParticleEmitter", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::ParticleEmitter>(static_cast<Entity>(e));
}))
- .function("getUIInteraction", optional_override([](Registry& r, u32 e) -> esengine::ecs::UIInteraction& {
+ .function("getParticleEmitter", 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::ParticleEmitter>(entity)) return ParticleEmitterJS{};
+ return particleemitterToJS(r.get<esengine::ecs::ParticleEmitter>(entity));
+ }))
+ .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::UIInteraction>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::ParticleEmitter>(entity, particleemitterFromJS(js));
}))
- .function("removeUIInteraction", 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::UIInteraction>(entity)) return;
- r.remove<esengine::ecs::UIInteraction>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::ParticleEmitter>(entity)) return;
+ r.remove<esengine::ecs::ParticleEmitter>(entity);
}))
// RigidBody
@@ -1439,28 +1432,50 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
}))
.function("removeRigidBody", optional_override([](Registry& r, u32 e) {
auto entity = static_cast<Entity>(e);
- if (!r.valid(entity) || !r.has<esengine::ecs::RigidBody>(entity)) return;
- r.remove<esengine::ecs::RigidBody>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::RigidBody>(entity)) return;
+ 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);
+ }))
+ .function("removeShapeRenderer", 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);
}))
- // BitmapText
- .function("hasBitmapText", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::BitmapText>(static_cast<Entity>(e));
+ // SpineAnimation
+ .function("hasSpineAnimation", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::SpineAnimation>(static_cast<Entity>(e));
}))
- .function("getBitmapText", 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::BitmapText>(entity)) return BitmapTextJS{};
- return bitmaptextToJS(r.get<esengine::ecs::BitmapText>(entity));
- }))
- .function("addBitmapText", optional_override([](Registry& r, u32 e, const BitmapTextJS& 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::BitmapText>(entity, bitmaptextFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::SpineAnimation>(entity, c);
}))
- .function("removeBitmapText", 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::BitmapText>(entity)) return;
- r.remove<esengine::ecs::BitmapText>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::SpineAnimation>(entity)) return;
+ r.remove<esengine::ecs::SpineAnimation>(entity);
}))
// Sprite
@@ -1483,44 +1498,25 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::Sprite>(entity);
}))
- // UIMask
- .function("hasUIMask", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::UIMask>(static_cast<Entity>(e));
- }))
- .function("getUIMask", optional_override([](Registry& r, u32 e) {
- 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) {
- auto entity = static_cast<Entity>(e);
- if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::UIMask>(entity, uimaskFromJS(js));
- }))
- .function("removeUIMask", 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);
- }))
-
- // FlexContainer
- .function("hasFlexContainer", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::FlexContainer>(static_cast<Entity>(e));
+ // StateMachine
+ .function("hasStateMachine", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::StateMachine>(static_cast<Entity>(e));
}))
- .function("getFlexContainer", optional_override([](Registry& r, u32 e) {
+ .function("getStateMachine", optional_override([](Registry& r, u32 e) -> esengine::ecs::StateMachine& {
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) {
+ 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) {
auto entity = static_cast<Entity>(e);
if (!r.valid(entity)) return;
- r.emplaceOrReplace<esengine::ecs::FlexContainer>(entity, flexcontainerFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::StateMachine>(entity, c);
}))
- .function("removeFlexContainer", 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::FlexContainer>(entity)) return;
- r.remove<esengine::ecs::FlexContainer>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::StateMachine>(entity)) return;
+ r.remove<esengine::ecs::StateMachine>(entity);
}))
// StateVisuals
@@ -1543,126 +1539,130 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::StateVisuals>(entity);
}))
- // Parent
- .function("hasParent", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::Parent>(static_cast<Entity>(e));
+ // Transform
+ .function("hasTransform", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Transform>(static_cast<Entity>(e));
}))
- .function("getParent", 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::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::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::Parent>(entity, parentFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::Transform>(entity, c);
}))
- .function("removeParent", optional_override([](Registry& r, u32 e) {
+ .function("removeTransform", 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::Transform>(entity)) return;
+ r.remove<esengine::ecs::Transform>(entity);
}))
- // Children
- .function("hasChildren", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::Children>(static_cast<Entity>(e));
+ // UIInteraction
+ .function("hasUIInteraction", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::UIInteraction>(static_cast<Entity>(e));
}))
- .function("getChildren", 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::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::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::Children>(entity, childrenFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::UIInteraction>(entity, c);
}))
- .function("removeChildren", 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::Children>(entity)) return;
- r.remove<esengine::ecs::Children>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::UIInteraction>(entity)) return;
+ r.remove<esengine::ecs::UIInteraction>(entity);
}))
- // ShapeRenderer
- .function("hasShapeRenderer", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::ShapeRenderer>(static_cast<Entity>(e));
+ // UIMask
+ .function("hasUIMask", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::UIMask>(static_cast<Entity>(e));
}))
- .function("getShapeRenderer", optional_override([](Registry& r, u32 e) -> esengine::ecs::ShapeRenderer& {
+ .function("getUIMask", optional_override([](Registry& r, u32 e) {
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) {
+ 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::ShapeRenderer>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::UIMask>(entity, uimaskFromJS(js));
}))
- .function("removeShapeRenderer", 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::ShapeRenderer>(entity)) return;
- r.remove<esengine::ecs::ShapeRenderer>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::UIMask>(entity)) return;
+ r.remove<esengine::ecs::UIMask>(entity);
}))
- // StateMachine
- .function("hasStateMachine", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::StateMachine>(static_cast<Entity>(e));
+ // UIRect
+ .function("hasUIRect", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::UIRect>(static_cast<Entity>(e));
}))
- .function("getStateMachine", optional_override([](Registry& r, u32 e) -> esengine::ecs::StateMachine& {
+ .function("getUIRect", optional_override([](Registry& r, u32 e) -> esengine::ecs::UIRect& {
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);
+ 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("addStateMachine", optional_override([](Registry& r, u32 e, const esengine::ecs::StateMachine& c) {
+ .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::StateMachine>(entity, c);
+ r.emplaceOrReplace<esengine::ecs::UIRect>(entity, c);
}))
- .function("removeStateMachine", 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::StateMachine>(entity)) return;
- r.remove<esengine::ecs::StateMachine>(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));
+ // UIRenderer
+ .function("hasUIRenderer", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::UIRenderer>(static_cast<Entity>(e));
}))
- .function("getCanvas", optional_override([](Registry& r, u32 e) {
+ .function("getUIRenderer", 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::UIRenderer>(entity)) return UIRendererJS{};
+ return uirendererToJS(r.get<esengine::ecs::UIRenderer>(entity));
}))
- .function("addCanvas", optional_override([](Registry& r, u32 e, const CanvasJS& js) {
+ .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::Canvas>(entity, canvasFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::UIRenderer>(entity, uirendererFromJS(js));
}))
- .function("removeCanvas", 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::Canvas>(entity)) return;
- r.remove<esengine::ecs::Canvas>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::UIRenderer>(entity)) return;
+ r.remove<esengine::ecs::UIRenderer>(entity);
}))
- // Camera
- .function("hasCamera", optional_override([](Registry& r, u32 e) {
- return r.has<esengine::ecs::Camera>(static_cast<Entity>(e));
+ // Velocity
+ .function("hasVelocity", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::Velocity>(static_cast<Entity>(e));
}))
- .function("getCamera", 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::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::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::Camera>(entity, cameraFromJS(js));
+ r.emplaceOrReplace<esengine::ecs::Velocity>(entity, c);
}))
- .function("removeCamera", 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::Camera>(entity)) return;
- r.remove<esengine::ecs::Camera>(entity);
+ if (!r.valid(entity) || !r.has<esengine::ecs::Velocity>(entity)) return;
+ r.remove<esengine::ecs::Velocity>(entity);
}))
// Hierarchy Utilities
@@ -1681,32 +1681,32 @@ 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("BitmapText")));
+ arr.set(i++, val(std::string("Camera")));
+ arr.set(i++, val(std::string("Canvas")));
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("FlexItem")));
+ arr.set(i++, val(std::string("GridLayout")));
arr.set(i++, val(std::string("Parent")));
arr.set(i++, val(std::string("Children")));
+ arr.set(i++, val(std::string("Interactable")));
+ arr.set(i++, val(std::string("ParticleEmitter")));
+ arr.set(i++, val(std::string("RigidBody")));
arr.set(i++, val(std::string("ShapeRenderer")));
+ arr.set(i++, val(std::string("SpineAnimation")));
+ arr.set(i++, val(std::string("Sprite")));
arr.set(i++, val(std::string("StateMachine")));
- arr.set(i++, val(std::string("Canvas")));
- arr.set(i++, val(std::string("Camera")));
+ arr.set(i++, val(std::string("StateVisuals")));
+ arr.set(i++, val(std::string("Transform")));
+ arr.set(i++, val(std::string("UIInteraction")));
+ arr.set(i++, val(std::string("UIMask")));
+ arr.set(i++, val(std::string("UIRect")));
+ arr.set(i++, val(std::string("UIRenderer")));
+ arr.set(i++, val(std::string("Velocity")));
return arr;
}
diff --git a/src/esengine/ecs/DynamicComponent.hpp b/src/esengine/ecs/DynamicComponent.hpp
index ac2b1cc15..d068ef571 100644
--- a/src/esengine/ecs/DynamicComponent.hpp
+++ b/src/esengine/ecs/DynamicComponent.hpp
@@ -129,7 +129,15 @@ public:
dense_[denseIdx] = last;
std::swap(values_[denseIdx], values_.back());
- sparse_[last.index()] = denseIdx;
+ // Defensive: an in-dense entity implies its index was
+ // covered by sparse_ on emplace. Guard against the case
+ // where some future refactor shrinks sparse_ without
+ // dense_, instead of trusting the invariant silently.
+ ES_ASSERT(last.index() < sparse_.size(),
+ "DynamicComponentPool sparse/dense out of sync");
+ if (last.index() < sparse_.size()) {
+ sparse_[last.index()] = denseIdx;
+ }
dense_.pop_back();
values_.pop_back();
diff --git a/src/esengine/ecs/TransformSystem.hpp b/src/esengine/ecs/TransformSystem.hpp
index 7dc11f27b..e4df020e0 100644
--- a/src/esengine/ecs/TransformSystem.hpp
+++ b/src/esengine/ecs/TransformSystem.hpp
@@ -190,7 +190,16 @@ inline void setParent(Registry& registry, Entity child, Entity newParent) {
if (!registry.has<Children>(newParent)) {
registry.emplace<Children>(newParent);
}
- registry.get<Children>(newParent).entities.push_back(child);
+ // Defensive dedupe: the normal path already removed child from
+ // its old parent's list above, but if Parent/Children got out
+ // of sync externally (user code touching components directly,
+ // partial loads, or a double-insert via ordering bugs), a
+ // naked push_back here would compound the corruption into an
+ // infinite-traversal hierarchy.
+ auto& newChildren = registry.get<Children>(newParent).entities;
+ if (std::find(newChildren.begin(), newChildren.end(), child) == newChildren.end()) {
+ newChildren.push_back(child);
+ }
u32 parentDepth = 0;
if (registry.has<HierarchyDepth>(newParent)) {
diff --git a/src/esengine/ecs/View.hpp b/src/esengine/ecs/View.hpp
index c184f1354..49f0984f0 100644
--- a/src/esengine/ecs/View.hpp
+++ b/src/esengine/ecs/View.hpp
@@ -270,17 +270,27 @@ public:
void each(Func&& func) {
if (!smallest_) return;
- const auto& entities = smallest_->entities();
- const usize n = entities.size();
-
- for (usize i = 0; i < n; ++i) {
- Entity entity = entities[i];
+ // Snapshot the entity list so the callback can safely
+ // emplace/remove components mid-iteration — the snapshot is
+ // O(n) up front, but any pool realloc inside the callback
+ // would otherwise invalidate a live reference and silently
+ // corrupt the iteration.
+ //
+ // After the snapshot, each step re-checks that the entity
+ // still has the smallest component (it may have been removed
+ // by the callback). The smallest pool's dense index is no
+ // longer used for the fast read, since mutations can reorder
+ // it — look the component up by entity instead.
+ std::vector<Entity> entities = smallest_->entities();
+
+ for (Entity entity : entities) {
+ if (!smallestStillHas(entity)) continue;
if (!allHaveExceptSmallest(entity)) continue;
if constexpr (std::is_invocable_v<Func, Entity, Components&...>) {
- func(entity, getFromPool<Components>(entity, i)...);
+ func(entity, getByEntity<Components>(entity)...);
} else if constexpr (std::is_invocable_v<Func, Components&...>) {
- func(getFromPool<Components>(entity, i)...);
+ func(getByEntity<Components>(entity)...);
} else {
func(entity);
}
@@ -289,12 +299,12 @@ public:
private:
template<typename T>
- T& getFromPool(Entity entity, usize smallestDenseIndex) {
- auto* pool = std::get<SparseSet<T>*>(pools_);
- if (static_cast<SparseSetBase*>(pool) == smallest_) {
- return pool->components()[smallestDenseIndex];
- }
- return pool->getUnchecked(entity);
+ T& getByEntity(Entity entity) {
+ return std::get<SparseSet<T>*>(pools_)->getUnchecked(entity);
+ }
+
+ bool smallestStillHas(Entity entity) const {
+ return smallest_->contains(entity);
}
bool allHaveExceptSmallest(Entity entity) const {
diff --git a/src/esengine/tilemap/TilemapSystem.cpp b/src/esengine/tilemap/TilemapSystem.cpp
index 97efaf698..311d53361 100644
--- a/src/esengine/tilemap/TilemapSystem.cpp
+++ b/src/esengine/tilemap/TilemapSystem.cpp
@@ -269,21 +269,18 @@ void TilemapSystem::setTileProperty(Entity entity, u16 tileId,
layer->tile_properties[tileId][key] = value;
}
-static std::string s_propertyResult;
-
-const char* TilemapSystem::getTileProperty(Entity entity, u16 tileId,
+std::string TilemapSystem::getTileProperty(Entity entity, u16 tileId,
const std::string& key) const {
const auto* layer = getLayerData(entity);
- if (!layer) return "";
+ if (!layer) return {};
auto tileIt = layer->tile_properties.find(tileId);
- if (tileIt == layer->tile_properties.end()) return "";
+ if (tileIt == layer->tile_properties.end()) return {};
auto propIt = tileIt->second.find(key);
- if (propIt == tileIt->second.end()) return "";
+ if (propIt == tileIt->second.end()) return {};
- s_propertyResult = propIt->second;
- return s_propertyResult.c_str();
+ return propIt->second;
}
void TilemapSystem::flipTile(Entity entity, i32 x, i32 y,
diff --git a/src/esengine/tilemap/TilemapSystem.hpp b/src/esengine/tilemap/TilemapSystem.hpp
index 7cb607755..1e9df371d 100644
--- a/src/esengine/tilemap/TilemapSystem.hpp
+++ b/src/esengine/tilemap/TilemapSystem.hpp
@@ -86,7 +86,13 @@ public:
void setTileProperty(Entity entity, u16 tileId,
const std::string& key, const std::string& value);
- const char* getTileProperty(Entity entity, u16 tileId,
+ /**
+ * Return the property value copied by value — do NOT return a
+ * pointer into internal storage. Previous iterations used a
+ * file-scope static buffer which corrupted on back-to-back calls
+ * and was unsafe across threads.
+ */
+ std::string getTileProperty(Entity entity, u16 tileId,
const std::string& key) const;
void flipTile(Entity entity, i32 x, i32 y, bool flipH, bool flipV, bool flipD);
diff --git a/tests/ecs/test_registry.cpp b/tests/ecs/test_registry.cpp
index a92b05b61..314f4da79 100644
--- a/tests/ecs/test_registry.cpp
+++ b/tests/ecs/test_registry.cpp
@@ -431,3 +431,64 @@ TEST_CASE("uuid_component") {
esengine::ecs::UUID other(0x12345678ABCDEF00ULL);
CHECK(uuid == other);
}
+
+TEST_CASE("view_each tolerates mid-iteration emplace on the same pool") {
+ esengine::ecs::Registry registry;
+ std::vector<esengine::Entity> seeds;
+ for (int i = 0; i < 8; ++i) {
+ esengine::Entity e = registry.create();
+ registry.emplace<test::Position>(e, float(i), 0.0f);
+ seeds.push_back(e);
+ }
+
+ int visited = 0;
+ auto view = registry.view<test::Position>();
+ view.each([&](esengine::Entity e, test::Position&) {
+ (void)e;
+ ++visited;
+ // Trigger a pool realloc on the smallest pool while iterating.
+ // A naked reference to the dense array would dangle here; the
+ // snapshot path keeps iteration valid.
+ if (visited == 1) {
+ for (int j = 0; j < 32; ++j) {
+ esengine::Entity extra = registry.create();
+ registry.emplace<test::Position>(extra, 99.0f, 99.0f);
+ }
+ }
+ });
+
+ CHECK_EQ(visited, 8);
+}
+
+TEST_CASE("view_each tolerates mid-iteration remove of the current entity") {
+ esengine::ecs::Registry registry;
+ std::vector<esengine::Entity> entities;
+ for (int i = 0; i < 5; ++i) {
+ esengine::Entity e = registry.create();
+ registry.emplace<test::Position>(e, float(i), 0.0f);
+ entities.push_back(e);
+ }
+
+ int visited = 0;
+ auto view = registry.view<test::Position>();
+ view.each([&](esengine::Entity e, test::Position&) {
+ ++visited;
+ registry.remove<test::Position>(e);
+ });
+
+ CHECK_EQ(visited, 5);
+ CHECK_EQ(registry.view<test::Position>().sizeHint(), 0u);
+}
+
+TEST_CASE("setParent is idempotent on duplicate reparent") {
+ esengine::ecs::Registry registry;
+ esengine::Entity parent = registry.create();
+ esengine::Entity child = registry.create();
+
+ esengine::ecs::setParent(registry, child, parent);
+ esengine::ecs::setParent(registry, child, parent); // second call
+
+ const auto& children = registry.get<esengine::ecs::Children>(parent).entities;
+ CHECK_EQ(children.size(), 1u);
+ CHECK_EQ(children[0], child);
+}
diff --git a/tools/eht/generators/editor_api.py b/tools/eht/generators/editor_api.py
index 390d18c6c..506abcf52 100644
--- a/tools/eht/generators/editor_api.py
+++ b/tools/eht/generators/editor_api.py
@@ -6,12 +6,30 @@ Generates EditorAPI.generated.cpp with:
- String-dispatched property get/set by component+field path
"""
+import hashlib
from typing import List, Set
from ..data import Component, Enum
from ..type_system import TypeSystem
from ..field_utils import get_sub_components, get_editor_type, is_color_field
+def compute_schema_hash(components: List[Component]) -> str:
+ """Deterministic hash of the component schema.
+
+ Stable across runs on the same input, invalidated by any added /
+ removed / renamed / retyped field. Emitted into generated files so
+ build-time drift detection can compare against the source schema.
+ """
+ h = hashlib.sha256()
+ for comp in sorted(components, key=lambda c: (c.namespace or '', c.name)):
+ h.update(f'{comp.namespace or ""}::{comp.name}|'.encode('utf-8'))
+ for prop in comp.properties:
+ annotations = ','.join(sorted(prop.annotations.keys())) if prop.annotations else ''
+ h.update(f'{prop.name}:{prop.cpp_type}:{annotations};'.encode('utf-8'))
+ h.update(b'\n')
+ return h.hexdigest()[:16]
+
+
class EditorAPIGenerator:
def __init__(self, components: List[Component], enums: List[Enum]):
self.components = components
@@ -30,6 +48,8 @@ class EditorAPIGenerator:
lines.extend(self._gen_get_int())
lines.extend(self._gen_set_bool())
lines.extend(self._gen_get_bool())
+ lines.extend(self._gen_set_string())
+ lines.extend(self._gen_get_string())
lines.extend(self._gen_embind())
lines.append('')
lines.append('#endif // ES_PLATFORM_WEB')
@@ -37,13 +57,17 @@ class EditorAPIGenerator:
return '\n'.join(lines)
def _gen_header(self) -> List[str]:
+ schema_hash = compute_schema_hash(self.components)
lines = [
'/**',
' * @file EditorAPI.generated.cpp',
' * @brief Auto-generated editor API with string-dispatched component access',
' * @details Generated by EHT - DO NOT EDIT',
+ f' * @schema_hash {schema_hash}',
' */',
'',
+ f'#define ES_EDITOR_API_SCHEMA_HASH "{schema_hash}"',
+ '',
'#ifdef ES_PLATFORM_WEB',
'',
'#include <emscripten/bind.h>',
@@ -597,6 +621,102 @@ class EditorAPIGenerator:
])
return lines
+ def _collect_string_fields(self, comp: Component) -> list:
+ """Collect (key, cpp_path) for all std::string-backed editable fields.
+
+ Includes both plain string fields and asset-annotated string fields
+ (e.g. spine skeleton paths) — the latter can't go through setInt
+ because their storage isn't integer-convertible.
+ """
+ string_fields = []
+ for prop in comp.properties:
+ if self._is_readonly(prop):
+ continue
+ editor_type = get_editor_type(prop, self.types)
+ if editor_type == 'skip':
+ continue
+ t = self.types.clean_type(prop.cpp_type)
+ if t == 'std::string':
+ string_fields.append((prop.name, prop.name))
+ return string_fields
+
+ def _gen_set_string(self) -> List[str]:
+ lines = [
+ '// ── Set String Property ──',
+ '',
+ 'bool editor_setString(Registry& reg, u32 e, const std::string& comp, const std::string& field, const std::string& value) {',
+ ' auto entity = static_cast<Entity>(e);',
+ ' if (!reg.valid(entity)) return false;',
+ ]
+
+ first_comp = True
+ for comp in self.components:
+ if not comp.properties:
+ continue
+ full = f'{comp.namespace}::{comp.name}' if comp.namespace else comp.name
+ string_fields = self._collect_string_fields(comp)
+ if not string_fields:
+ continue
+
+ cond = 'if' if first_comp else '} else if'
+ first_comp = False
+ lines.append(f' {cond} (comp == "{comp.name}") {{')
+ lines.append(f' if (!reg.has<{full}>(entity)) return false;')
+ lines.append(f' auto& c = reg.get<{full}>(entity);')
+
+ for i, (key, cpp_path) in enumerate(string_fields):
+ prefix = 'if' if i == 0 else 'else if'
+ lines.append(f' {prefix} (field == "{key}") {{ c.{cpp_path} = value; }}')
+
+ lines.append(' else { return false; }')
+ lines.append(' return true;')
+
+ if not first_comp:
+ lines.append(' }')
+ lines.extend([
+ ' return false;',
+ '}',
+ '',
+ ])
+ return lines
+
+ def _gen_get_string(self) -> List[str]:
+ lines = [
+ '// ── Get String Property ──',
+ '',
+ 'std::string editor_getString(Registry& reg, u32 e, const std::string& comp, const std::string& field) {',
+ ' auto entity = static_cast<Entity>(e);',
+ ' if (!reg.valid(entity)) return std::string{};',
+ ]
+
+ first_comp = True
+ for comp in self.components:
+ if not comp.properties:
+ continue
+ full = f'{comp.namespace}::{comp.name}' if comp.namespace else comp.name
+ string_fields = self._collect_string_fields(comp)
+ if not string_fields:
+ continue
+
+ cond = 'if' if first_comp else '} else if'
+ first_comp = False
+ lines.append(f' {cond} (comp == "{comp.name}") {{')
+ lines.append(f' if (!reg.has<{full}>(entity)) return std::string{{}};')
+ lines.append(f' const auto& c = reg.get<{full}>(entity);')
+
+ for i, (key, cpp_path) in enumerate(string_fields):
+ prefix = 'if' if i == 0 else 'else if'
+ lines.append(f' {prefix} (field == "{key}") {{ return c.{cpp_path}; }}')
+
+ if not first_comp:
+ lines.append(' }')
+ lines.extend([
+ ' return std::string{};',
+ '}',
+ '',
+ ])
+ return lines
+
def _gen_embind(self) -> List[str]:
return [
'} // anonymous namespace',
@@ -618,6 +738,8 @@ class EditorAPIGenerator:
' emscripten::function("editor_getInt", &editor_getInt);',
' emscripten::function("editor_setBool", &editor_setBool);',
' emscripten::function("editor_getBool", &editor_getBool);',
+ ' emscripten::function("editor_setString", &editor_setString);',
+ ' emscripten::function("editor_getString", &editor_getString);',
'',
' emscripten::register_vector<std::string>("VectorString");',
'}',