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(tilemap): TilemapLayer ECS component + chunk serialization

esenginecdfe08217b14
diff --git a/sdk/src/component.generated.ts b/sdk/src/component.generated.ts
index 4e8c30427..dc9263f2b 100644
--- a/sdk/src/component.generated.ts
+++ b/sdk/src/component.generated.ts
@@ -393,6 +393,24 @@ export const COMPONENT_META: Record<string, ComponentMetaEntry> = {
colorFields: ['slot0Color', 'slot1Color', 'slot2Color', 'slot3Color', 'slot4Color', 'slot5Color', 'slot6Color', 'slot7Color'],
animatableFields: [],
},
+ TilemapLayer: {
+ defaults: {
+ cellSize: { x: 32, y: 32 },
+ originOffset: { x: 0, y: 0 },
+ tileset: 0,
+ tilesetColumns: 1,
+ tilesetRows: 1,
+ renderLayer: 0,
+ tintColor: { r: 1, g: 1, b: 1, a: 1 },
+ opacity: 1,
+ parallaxFactor: { x: 1, y: 1 },
+ visible: true,
+ },
+ assetFields: [{ field: 'tileset', type: 'texture' as AssetFieldType }],
+ entityFields: [],
+ colorFields: ['tintColor'],
+ animatableFields: ['tintColor.r', 'tintColor.g', 'tintColor.b', 'tintColor.a', 'opacity'],
+ },
Transform: {
defaults: {
position: { x: 0, y: 0, z: 0 },
diff --git a/sdk/src/ecs/ptrAccessors.generated.ts b/sdk/src/ecs/ptrAccessors.generated.ts
index 026cf49cd..09c1654b3 100644
--- a/sdk/src/ecs/ptrAccessors.generated.ts
+++ b/sdk/src/ecs/ptrAccessors.generated.ts
@@ -1093,6 +1093,66 @@ export function createStateVisualsData(): StateVisualsPtrData {
};
}
+export interface TilemapLayerPtrData {
+ cellSize: Vec2;
+ originOffset: Vec2;
+ tileset: number;
+ tilesetColumns: number;
+ tilesetRows: number;
+ renderLayer: number;
+ tintColor: Color;
+ opacity: number;
+ parallaxFactor: Vec2;
+ visible: boolean;
+}
+
+export function fillTilemapLayer(
+ f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
+ ptr: number, out: TilemapLayerPtrData,
+): void {
+ const cellSize_ = out.cellSize; cellSize_.x = f32[ptr >> 2]; cellSize_.y = f32[(ptr >> 2) + 1];
+ const originOffset_ = out.originOffset; originOffset_.x = f32[(ptr + 8) >> 2]; originOffset_.y = f32[((ptr + 8) >> 2) + 1];
+ out.tileset = u32[(ptr + 16) >> 2];
+ out.tilesetColumns = u32[(ptr + 20) >> 2] | 0;
+ out.tilesetRows = u32[(ptr + 24) >> 2] | 0;
+ out.renderLayer = u32[(ptr + 28) >> 2] | 0;
+ const tintColor_ = out.tintColor; tintColor_.r = f32[(ptr + 32) >> 2]; tintColor_.g = f32[((ptr + 32) >> 2) + 1]; tintColor_.b = f32[((ptr + 32) >> 2) + 2]; tintColor_.a = f32[((ptr + 32) >> 2) + 3];
+ out.opacity = f32[(ptr + 48) >> 2];
+ const parallaxFactor_ = out.parallaxFactor; parallaxFactor_.x = f32[(ptr + 52) >> 2]; parallaxFactor_.y = f32[((ptr + 52) >> 2) + 1];
+ out.visible = u8[ptr + 60] !== 0;
+}
+
+export function writeTilemapLayer(
+ f32: Float32Array, u32: Uint32Array, u8: Uint8Array,
+ ptr: number, data: TilemapLayerPtrData,
+): void {
+ f32[ptr >> 2] = data.cellSize.x; f32[(ptr >> 2) + 1] = data.cellSize.y;
+ f32[(ptr + 8) >> 2] = data.originOffset.x; f32[((ptr + 8) >> 2) + 1] = data.originOffset.y;
+ u32[(ptr + 16) >> 2] = data.tileset;
+ u32[(ptr + 20) >> 2] = data.tilesetColumns | 0;
+ u32[(ptr + 24) >> 2] = data.tilesetRows | 0;
+ u32[(ptr + 28) >> 2] = data.renderLayer | 0;
+ f32[(ptr + 32) >> 2] = data.tintColor.r; f32[((ptr + 32) >> 2) + 1] = data.tintColor.g; f32[((ptr + 32) >> 2) + 2] = data.tintColor.b; f32[((ptr + 32) >> 2) + 3] = data.tintColor.a;
+ f32[(ptr + 48) >> 2] = data.opacity;
+ f32[(ptr + 52) >> 2] = data.parallaxFactor.x; f32[((ptr + 52) >> 2) + 1] = data.parallaxFactor.y;
+ u8[ptr + 60] = data.visible ? 1 : 0;
+}
+
+export function createTilemapLayerData(): TilemapLayerPtrData {
+ return {
+ cellSize: { x: 0, y: 0 },
+ originOffset: { x: 0, y: 0 },
+ tileset: 0,
+ tilesetColumns: 0,
+ tilesetRows: 0,
+ renderLayer: 0,
+ tintColor: { r: 0, g: 0, b: 0, a: 0 },
+ opacity: 0,
+ parallaxFactor: { x: 0, y: 0 },
+ visible: false,
+ };
+}
+
export interface TransformPtrData {
position: Vec3;
rotation: Vec4;
@@ -1349,6 +1409,7 @@ export const PTR_ACCESSORS: Record<string, PtrAccessor<any>> = {
SpineAnimation: { fill: fillSpineAnimation, write: writeSpineAnimation, create: createSpineAnimationData },
Sprite: { fill: fillSprite, write: writeSprite, create: createSpriteData },
StateVisuals: { fill: fillStateVisuals, write: writeStateVisuals, create: createStateVisualsData },
+ TilemapLayer: { fill: fillTilemapLayer, write: writeTilemapLayer, create: createTilemapLayerData },
Transform: { fill: fillTransform, write: writeTransform, create: createTransformData },
UIInteraction: { fill: fillUIInteraction, write: writeUIInteraction, create: createUIInteractionData },
UIMask: { fill: fillUIMask, write: writeUIMask, create: createUIMaskData },
diff --git a/sdk/src/ptrLayouts.generated.ts b/sdk/src/ptrLayouts.generated.ts
index 2b56ecba4..d78e4cae8 100644
--- a/sdk/src/ptrLayouts.generated.ts
+++ b/sdk/src/ptrLayouts.generated.ts
@@ -289,6 +289,21 @@ export const PTR_LAYOUTS: Record<string, PtrLayout> = {
{ name: 'slot7Scale', type: 'f32', offset: 196 },
],
},
+ TilemapLayer: {
+ ptrFn: 'getTilemapLayerPtr',
+ fields: [
+ { name: 'cellSize', type: 'vec2', offset: 0 },
+ { name: 'originOffset', type: 'vec2', offset: 8 },
+ { name: 'tileset', type: 'u32', offset: 16 },
+ { name: 'tilesetColumns', type: 'i32', offset: 20 },
+ { name: 'tilesetRows', type: 'i32', offset: 24 },
+ { name: 'renderLayer', type: 'i32', offset: 28 },
+ { name: 'tintColor', type: 'color', offset: 32 },
+ { name: 'opacity', type: 'f32', offset: 48 },
+ { name: 'parallaxFactor', type: 'vec2', offset: 52 },
+ { name: 'visible', type: 'bool', offset: 60 },
+ ],
+ },
Transform: {
ptrFn: 'getTransformPtr',
fields: [
diff --git a/sdk/src/scene.ts b/sdk/src/scene.ts
index 50f596c5d..c05e674ea 100644
--- a/sdk/src/scene.ts
+++ b/sdk/src/scene.ts
@@ -279,6 +279,18 @@ export function loadComponent(world: World, entity: Entity, compData: SceneCompo
if (maskData.mode === 'scissor') maskData.mode = 0;
else if (maskData.mode === 'stencil') maskData.mode = 1;
}
+ // Tilemap chunk blob travels outside the component's ES_PROPERTY fields
+ // (it's binary, not a settable property). Strip it from the data dict so
+ // the component inserter doesn't choke on an unknown key, then hydrate
+ // after the component exists on the entity.
+ let chunkBlob: string | null = null;
+ if (compData.type === 'TilemapLayer') {
+ const data = compData.data as Record<string, unknown>;
+ if (typeof data.chunks === 'string') {
+ chunkBlob = data.chunks as string;
+ delete data.chunks;
+ }
+ }
const comp = getComponent(compData.type);
if (comp) {
const errors = validateComponentData(compData.type, comp._default as Record<string, unknown>, compData.data);
@@ -287,6 +299,18 @@ export function loadComponent(world: World, entity: Entity, compData: SceneCompo
log.warn('scene', formatValidationErrors(compData.type + context, errors));
}
world.insert(entity, comp, compData.data);
+
+ if (compData.type === 'TilemapLayer' && chunkBlob !== null) {
+ const wasm = world.getWasmModule();
+ if (wasm?.tilemap_importChunks) {
+ const ok = wasm.tilemap_importChunks(entity as unknown as number, chunkBlob);
+ if (!ok) {
+ log.warn('scene', `TilemapLayer chunk import failed for entity ${entity}`);
+ }
+ } else {
+ log.warn('scene', 'tilemap_importChunks not available; chunk data lost');
+ }
+ }
} else {
const context = entityName ? ` on entity "${entityName}"` : '';
log.warn('scene', `Unknown component type: ${compData.type}${context}`);
@@ -354,10 +378,23 @@ export function serializeScene(world: World, sceneName = 'scene'): SceneData {
if (!comp) continue;
const data = world.tryGet(entity, comp);
if (data === null) continue;
- components.push({
- type: typeName,
- data: data as Record<string, unknown>,
- });
+ const dataOut = { ...(data as Record<string, unknown>) };
+
+ // Tilemap tile grid lives in TilemapSystem, not in the component
+ // proper. Pull it through the binary export binding and attach
+ // it as a sibling field; loadComponent strips it back off on
+ // the inbound side so the component inserter doesn't see it.
+ if (typeName === 'TilemapLayer') {
+ const wasm = world.getWasmModule();
+ if (wasm?.tilemap_exportChunks) {
+ const blob = wasm.tilemap_exportChunks(entity as unknown as number);
+ if (blob && blob.length > 0) {
+ dataOut.chunks = blob;
+ }
+ }
+ }
+
+ components.push({ type: typeName, data: dataOut });
}
entities.push({
diff --git a/sdk/src/timeline/animTargets.generated.ts b/sdk/src/timeline/animTargets.generated.ts
index 1a90dd803..e344cd515 100644
--- a/sdk/src/timeline/animTargets.generated.ts
+++ b/sdk/src/timeline/animTargets.generated.ts
@@ -16,38 +16,44 @@ export enum AnimTargetField {
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,
+ TilemapLayerTintColorR = 11,
+ TilemapLayerTintColorG = 12,
+ TilemapLayerTintColorB = 13,
+ TilemapLayerTintColorA = 14,
+ TilemapLayerOpacity = 15,
+ TransformPositionX = 16,
+ TransformPositionY = 17,
+ TransformPositionZ = 18,
+ TransformRotationZ = 19,
+ TransformScaleX = 20,
+ TransformScaleY = 21,
+ TransformScaleZ = 22,
+ UIRectAnchorMinX = 23,
+ UIRectAnchorMinY = 24,
+ UIRectAnchorMaxX = 25,
+ UIRectAnchorMaxY = 26,
+ UIRectOffsetMinX = 27,
+ UIRectOffsetMinY = 28,
+ UIRectOffsetMaxX = 29,
+ UIRectOffsetMaxY = 30,
+ UIRectPivotX = 31,
+ UIRectPivotY = 32,
+ UIRendererColorR = 33,
+ UIRendererColorG = 34,
+ UIRendererColorB = 35,
+ UIRendererColorA = 36,
+ CustomField = 37,
}
export enum AnimTargetComponent {
BitmapText = 0,
Camera = 1,
Sprite = 2,
- Transform = 3,
- UIRect = 4,
- UIRenderer = 5,
- Custom = 6,
+ TilemapLayer = 3,
+ Transform = 4,
+ UIRect = 5,
+ UIRenderer = 6,
+ Custom = 7,
}
export const FIELD_MAP: Record<string, Record<string, AnimTargetField>> = {
@@ -68,6 +74,13 @@ export const FIELD_MAP: Record<string, Record<string, AnimTargetField>> = {
'size.x': AnimTargetField.SpriteSizeX,
'size.y': AnimTargetField.SpriteSizeY,
},
+ TilemapLayer: {
+ 'tintColor.r': AnimTargetField.TilemapLayerTintColorR,
+ 'tintColor.g': AnimTargetField.TilemapLayerTintColorG,
+ 'tintColor.b': AnimTargetField.TilemapLayerTintColorB,
+ 'tintColor.a': AnimTargetField.TilemapLayerTintColorA,
+ 'opacity': AnimTargetField.TilemapLayerOpacity,
+ },
Transform: {
'position.x': AnimTargetField.TransformPositionX,
'position.y': AnimTargetField.TransformPositionY,
@@ -101,6 +114,7 @@ export const COMPONENT_MAP: Record<string, AnimTargetComponent> = {
BitmapText: AnimTargetComponent.BitmapText,
Camera: AnimTargetComponent.Camera,
Sprite: AnimTargetComponent.Sprite,
+ TilemapLayer: AnimTargetComponent.TilemapLayer,
Transform: AnimTargetComponent.Transform,
UIRect: AnimTargetComponent.UIRect,
UIRenderer: AnimTargetComponent.UIRenderer,
diff --git a/sdk/src/wasm.generated.ts b/sdk/src/wasm.generated.ts
index dd73cc60d..93f22af1d 100644
--- a/sdk/src/wasm.generated.ts
+++ b/sdk/src/wasm.generated.ts
@@ -396,6 +396,19 @@ export interface StateVisuals {
slot7Scale: number;
}
+export interface TilemapLayer {
+ cellSize: Vec2;
+ originOffset: Vec2;
+ tileset: number;
+ tilesetColumns: number;
+ tilesetRows: number;
+ renderLayer: number;
+ tintColor: Vec4;
+ opacity: number;
+ parallaxFactor: Vec2;
+ visible: boolean;
+}
+
export interface Transform {
position: Vec3;
rotation: Quat;
@@ -529,6 +542,10 @@ export interface Registry {
getStateVisuals(entity: Entity): StateVisuals;
addStateVisuals(entity: Entity, component: StateVisuals): void;
removeStateVisuals(entity: Entity): void;
+ hasTilemapLayer(entity: Entity): boolean;
+ getTilemapLayer(entity: Entity): TilemapLayer;
+ addTilemapLayer(entity: Entity, component: TilemapLayer): void;
+ removeTilemapLayer(entity: Entity): void;
hasTransform(entity: Entity): boolean;
getTransform(entity: Entity): Transform;
addTransform(entity: Entity, component: Transform): void;
@@ -587,6 +604,7 @@ export interface ESEngineModule {
Sprite: new () => Sprite;
StateMachine: new () => StateMachine;
StateVisuals: new () => StateVisuals;
+ TilemapLayer: new () => TilemapLayer;
Transform: new () => Transform;
UIInteraction: new () => UIInteraction;
UIMask: new () => UIMask;
diff --git a/sdk/src/wasm.ts b/sdk/src/wasm.ts
index 0124c6da4..dd6902b88 100644
--- a/sdk/src/wasm.ts
+++ b/sdk/src/wasm.ts
@@ -240,6 +240,7 @@ export interface ESEngineModule {
// Tilemap API
tilemap_initLayer?(entity: number, width: number, height: number,
tileWidth: number, tileHeight: number): void;
+ tilemap_initInfinite?(entity: number, tileWidth: number, tileHeight: number): void;
tilemap_destroyLayer?(entity: number): void;
tilemap_setTile?(entity: number, x: number, y: number, tileId: number): void;
tilemap_getTile?(entity: number, x: number, y: number): number;
@@ -247,6 +248,8 @@ export interface ESEngineModule {
w: number, h: number, tileId: number): void;
tilemap_setTiles?(entity: number, tilesPtr: number, count: number): void;
tilemap_hasLayer?(entity: number): boolean;
+ tilemap_exportChunks?(entity: number): string;
+ tilemap_importChunks?(entity: number, encoded: string): boolean;
tilemap_submitLayer?(entity: number, textureId: number,
sortLayer: number, depth: number,
tilesetColumns: number,
diff --git a/sdk/wasm.generated.ts b/sdk/wasm.generated.ts
index dd73cc60d..93f22af1d 100644
--- a/sdk/wasm.generated.ts
+++ b/sdk/wasm.generated.ts
@@ -396,6 +396,19 @@ export interface StateVisuals {
slot7Scale: number;
}
+export interface TilemapLayer {
+ cellSize: Vec2;
+ originOffset: Vec2;
+ tileset: number;
+ tilesetColumns: number;
+ tilesetRows: number;
+ renderLayer: number;
+ tintColor: Vec4;
+ opacity: number;
+ parallaxFactor: Vec2;
+ visible: boolean;
+}
+
export interface Transform {
position: Vec3;
rotation: Quat;
@@ -529,6 +542,10 @@ export interface Registry {
getStateVisuals(entity: Entity): StateVisuals;
addStateVisuals(entity: Entity, component: StateVisuals): void;
removeStateVisuals(entity: Entity): void;
+ hasTilemapLayer(entity: Entity): boolean;
+ getTilemapLayer(entity: Entity): TilemapLayer;
+ addTilemapLayer(entity: Entity, component: TilemapLayer): void;
+ removeTilemapLayer(entity: Entity): void;
hasTransform(entity: Entity): boolean;
getTransform(entity: Entity): Transform;
addTransform(entity: Entity, component: Transform): void;
@@ -587,6 +604,7 @@ export interface ESEngineModule {
Sprite: new () => Sprite;
StateMachine: new () => StateMachine;
StateVisuals: new () => StateVisuals;
+ TilemapLayer: new () => TilemapLayer;
Transform: new () => Transform;
UIInteraction: new () => UIInteraction;
UIMask: new () => UIMask;
diff --git a/src/esengine/animation/animTargets.generated.hpp b/src/esengine/animation/animTargets.generated.hpp
index 8fd2fb363..5378d720f 100644
--- a/src/esengine/animation/animTargets.generated.hpp
+++ b/src/esengine/animation/animTargets.generated.hpp
@@ -5,6 +5,7 @@
#include "../ecs/components/BitmapText.hpp"
#include "../ecs/components/Camera.hpp"
#include "../ecs/components/Sprite.hpp"
+#include "../ecs/components/TilemapLayer.hpp"
#include "../ecs/components/Transform.hpp"
#include "../ecs/components/UIRect.hpp"
#include "../ecs/components/UIRenderer.hpp"
@@ -19,10 +20,11 @@ enum class AnimTargetComponent : u8 {
BitmapText = 0,
Camera = 1,
Sprite = 2,
- Transform = 3,
- UIRect = 4,
- UIRenderer = 5,
- Custom = 6,
+ TilemapLayer = 3,
+ Transform = 4,
+ UIRect = 5,
+ UIRenderer = 6,
+ Custom = 7,
COUNT
};
@@ -38,28 +40,33 @@ enum class AnimTargetField : u8 {
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,
+ TilemapLayerTintColorR = 11,
+ TilemapLayerTintColorG = 12,
+ TilemapLayerTintColorB = 13,
+ TilemapLayerTintColorA = 14,
+ TilemapLayerOpacity = 15,
+ TransformPositionX = 16,
+ TransformPositionY = 17,
+ TransformPositionZ = 18,
+ TransformRotationZ = 19,
+ TransformScaleX = 20,
+ TransformScaleY = 21,
+ TransformScaleZ = 22,
+ UIRectAnchorMinX = 23,
+ UIRectAnchorMinY = 24,
+ UIRectAnchorMaxX = 25,
+ UIRectAnchorMaxY = 26,
+ UIRectOffsetMinX = 27,
+ UIRectOffsetMinY = 28,
+ UIRectOffsetMaxX = 29,
+ UIRectOffsetMaxY = 30,
+ UIRectPivotX = 31,
+ UIRectPivotY = 32,
+ UIRendererColorR = 33,
+ UIRendererColorG = 34,
+ UIRendererColorB = 35,
+ UIRendererColorA = 36,
+ CustomField = 37,
COUNT
};
@@ -123,6 +130,31 @@ inline void applyAnimatedValue(
c->size.y = value;
}
break;
+ case AnimTargetField::TilemapLayerTintColorR:
+ if (auto* c = registry.tryGet<ecs::TilemapLayer>(entity)) {
+ c->tintColor.r = value;
+ }
+ break;
+ case AnimTargetField::TilemapLayerTintColorG:
+ if (auto* c = registry.tryGet<ecs::TilemapLayer>(entity)) {
+ c->tintColor.g = value;
+ }
+ break;
+ case AnimTargetField::TilemapLayerTintColorB:
+ if (auto* c = registry.tryGet<ecs::TilemapLayer>(entity)) {
+ c->tintColor.b = value;
+ }
+ break;
+ case AnimTargetField::TilemapLayerTintColorA:
+ if (auto* c = registry.tryGet<ecs::TilemapLayer>(entity)) {
+ c->tintColor.a = value;
+ }
+ break;
+ case AnimTargetField::TilemapLayerOpacity:
+ if (auto* c = registry.tryGet<ecs::TilemapLayer>(entity)) {
+ c->opacity = value;
+ }
+ break;
case AnimTargetField::TransformPositionX:
if (auto* c = registry.tryGet<ecs::Transform>(entity)) {
c->position.x = value;
diff --git a/src/esengine/bindings/EditorAPI.generated.cpp b/src/esengine/bindings/EditorAPI.generated.cpp
index 1d5900148..0809f701e 100644
--- a/src/esengine/bindings/EditorAPI.generated.cpp
+++ b/src/esengine/bindings/EditorAPI.generated.cpp
@@ -2,10 +2,10 @@
* @file EditorAPI.generated.cpp
* @brief Auto-generated editor API with string-dispatched component access
* @details Generated by EHT - DO NOT EDIT
- * @schema_hash 3aac921bfb4e31df
+ * @schema_hash ec0e5e49aabdea7f
*/
-#define ES_EDITOR_API_SCHEMA_HASH "3aac921bfb4e31df"
+#define ES_EDITOR_API_SCHEMA_HASH "ec0e5e49aabdea7f"
#ifdef ES_PLATFORM_WEB
@@ -29,6 +29,7 @@
#include "../ecs/components/Sprite.hpp"
#include "../ecs/components/StateMachine.hpp"
#include "../ecs/components/StateVisuals.hpp"
+#include "../ecs/components/TilemapLayer.hpp"
#include "../ecs/components/Transform.hpp"
#include "../ecs/components/UIInteraction.hpp"
#include "../ecs/components/UIMask.hpp"
@@ -74,6 +75,7 @@ std::vector<std::string> editor_getComponentNames() {
"Sprite",
"StateMachine",
"StateVisuals",
+ "TilemapLayer",
"Transform",
"UIInteraction",
"UIMask",
@@ -425,6 +427,25 @@ std::string editor_getComponentSchema(const std::string& name) {
{"key":"slot7Sprite","type":"asset","group":"StateVisuals"},
{"key":"slot7Scale","type":"float","group":"StateVisuals"}
])JSON";
+ } else if (name == "TilemapLayer") {
+ return R"JSON([
+ {"key":"cellSize.x","type":"float","group":"TilemapLayer"},
+ {"key":"cellSize.y","type":"float","group":"TilemapLayer"},
+ {"key":"originOffset.x","type":"float","group":"TilemapLayer"},
+ {"key":"originOffset.y","type":"float","group":"TilemapLayer"},
+ {"key":"tileset","type":"asset","group":"TilemapLayer"},
+ {"key":"tilesetColumns","type":"int","group":"TilemapLayer"},
+ {"key":"tilesetRows","type":"int","group":"TilemapLayer"},
+ {"key":"renderLayer","type":"int","group":"TilemapLayer"},
+ {"key":"tintColor.r","type":"color","group":"TilemapLayer"},
+ {"key":"tintColor.g","type":"color","group":"TilemapLayer"},
+ {"key":"tintColor.b","type":"color","group":"TilemapLayer"},
+ {"key":"tintColor.a","type":"color","group":"TilemapLayer"},
+ {"key":"opacity","type":"float","group":"TilemapLayer"},
+ {"key":"parallaxFactor.x","type":"float","group":"TilemapLayer"},
+ {"key":"parallaxFactor.y","type":"float","group":"TilemapLayer"},
+ {"key":"visible","type":"bool","group":"TilemapLayer"}
+ ])JSON";
} else if (name == "Transform") {
return R"JSON([
{"key":"position.x","type":"float","group":"Transform"},
@@ -561,6 +582,9 @@ bool editor_addComponent(Registry& reg, u32 e, const std::string& name) {
} else if (name == "StateVisuals") {
if (!reg.has<esengine::ecs::StateVisuals>(entity)) reg.emplace<esengine::ecs::StateVisuals>(entity);
return true;
+ } else if (name == "TilemapLayer") {
+ if (!reg.has<esengine::ecs::TilemapLayer>(entity)) reg.emplace<esengine::ecs::TilemapLayer>(entity);
+ return true;
} else if (name == "Transform") {
if (!reg.has<esengine::ecs::Transform>(entity)) reg.emplace<esengine::ecs::Transform>(entity);
return true;
@@ -626,6 +650,8 @@ bool editor_removeComponent(Registry& reg, u32 e, const std::string& name) {
if (reg.has<esengine::ecs::StateMachine>(entity)) { reg.remove<esengine::ecs::StateMachine>(entity); return true; }
} else if (name == "StateVisuals") {
if (reg.has<esengine::ecs::StateVisuals>(entity)) { reg.remove<esengine::ecs::StateVisuals>(entity); return true; }
+ } else if (name == "TilemapLayer") {
+ if (reg.has<esengine::ecs::TilemapLayer>(entity)) { reg.remove<esengine::ecs::TilemapLayer>(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") {
@@ -665,6 +691,7 @@ bool editor_hasComponent(Registry& reg, u32 e, const std::string& name) {
if (name == "Sprite") return reg.has<esengine::ecs::Sprite>(entity);
if (name == "StateMachine") return reg.has<esengine::ecs::StateMachine>(entity);
if (name == "StateVisuals") return reg.has<esengine::ecs::StateVisuals>(entity);
+ if (name == "TilemapLayer") return reg.has<esengine::ecs::TilemapLayer>(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);
@@ -700,6 +727,7 @@ std::vector<std::string> editor_getComponents(Registry& reg, u32 e) {
if (reg.has<esengine::ecs::Sprite>(entity)) result.push_back("Sprite");
if (reg.has<esengine::ecs::StateMachine>(entity)) result.push_back("StateMachine");
if (reg.has<esengine::ecs::StateVisuals>(entity)) result.push_back("StateVisuals");
+ if (reg.has<esengine::ecs::TilemapLayer>(entity)) result.push_back("TilemapLayer");
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");
@@ -971,6 +999,22 @@ 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 == "TilemapLayer") {
+ if (!reg.has<esengine::ecs::TilemapLayer>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::TilemapLayer>(entity);
+ if (field == "cellSize.x") { c.cellSize.x = value; }
+ else if (field == "cellSize.y") { c.cellSize.y = value; }
+ else if (field == "originOffset.x") { c.originOffset.x = value; }
+ else if (field == "originOffset.y") { c.originOffset.y = value; }
+ else if (field == "tintColor.r") { c.tintColor.r = value; }
+ else if (field == "tintColor.g") { c.tintColor.g = value; }
+ else if (field == "tintColor.b") { c.tintColor.b = value; }
+ else if (field == "tintColor.a") { c.tintColor.a = value; }
+ else if (field == "opacity") { c.opacity = value; }
+ else if (field == "parallaxFactor.x") { c.parallaxFactor.x = value; }
+ else if (field == "parallaxFactor.y") { c.parallaxFactor.y = 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);
@@ -1276,6 +1320,20 @@ 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 == "TilemapLayer") {
+ if (!reg.has<esengine::ecs::TilemapLayer>(entity)) return 0.0f;
+ const auto& c = reg.get<esengine::ecs::TilemapLayer>(entity);
+ if (field == "cellSize.x") { return c.cellSize.x; }
+ else if (field == "cellSize.y") { return c.cellSize.y; }
+ else if (field == "originOffset.x") { return c.originOffset.x; }
+ else if (field == "originOffset.y") { return c.originOffset.y; }
+ else if (field == "tintColor.r") { return c.tintColor.r; }
+ else if (field == "tintColor.g") { return c.tintColor.g; }
+ else if (field == "tintColor.b") { return c.tintColor.b; }
+ else if (field == "tintColor.a") { return c.tintColor.a; }
+ else if (field == "opacity") { return c.opacity; }
+ else if (field == "parallaxFactor.x") { return c.parallaxFactor.x; }
+ else if (field == "parallaxFactor.y") { return c.parallaxFactor.y; }
} else if (comp == "Transform") {
if (!reg.has<esengine::ecs::Transform>(entity)) return 0.0f;
const auto& c = reg.get<esengine::ecs::Transform>(entity);
@@ -1476,6 +1534,15 @@ 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 == "TilemapLayer") {
+ if (!reg.has<esengine::ecs::TilemapLayer>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::TilemapLayer>(entity);
+ if (field == "tileset") { c.tileset = resource::TextureHandle(static_cast<u32>(value)); }
+ else if (field == "tilesetColumns") { c.tilesetColumns = static_cast<i32>(value); }
+ else if (field == "tilesetRows") { c.tilesetRows = static_cast<i32>(value); }
+ else if (field == "renderLayer") { c.renderLayer = static_cast<i32>(value); }
+ else { return false; }
+ return true;
} else if (comp == "UIMask") {
if (!reg.has<esengine::ecs::UIMask>(entity)) return false;
auto& c = reg.get<esengine::ecs::UIMask>(entity);
@@ -1605,6 +1672,13 @@ 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 == "TilemapLayer") {
+ if (!reg.has<esengine::ecs::TilemapLayer>(entity)) return 0;
+ const auto& c = reg.get<esengine::ecs::TilemapLayer>(entity);
+ if (field == "tileset") { return static_cast<i32>(c.tileset.id()); }
+ else if (field == "tilesetColumns") { return static_cast<i32>(c.tilesetColumns); }
+ else if (field == "tilesetRows") { return static_cast<i32>(c.tilesetRows); }
+ else if (field == "renderLayer") { return static_cast<i32>(c.renderLayer); }
} else if (comp == "UIMask") {
if (!reg.has<esengine::ecs::UIMask>(entity)) return 0;
const auto& c = reg.get<esengine::ecs::UIMask>(entity);
@@ -1713,6 +1787,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 == "TilemapLayer") {
+ if (!reg.has<esengine::ecs::TilemapLayer>(entity)) return false;
+ auto& c = reg.get<esengine::ecs::TilemapLayer>(entity);
+ if (field == "visible") { c.visible = value; }
+ else { return false; }
+ return true;
} else if (comp == "UIInteraction") {
if (!reg.has<esengine::ecs::UIInteraction>(entity)) return false;
auto& c = reg.get<esengine::ecs::UIInteraction>(entity);
@@ -1808,6 +1888,10 @@ bool editor_getBool(Registry& reg, u32 e, const std::string& comp, const std::st
if (field == "flipX") { return c.flipX; }
else if (field == "flipY") { return c.flipY; }
else if (field == "enabled") { return c.enabled; }
+ } else if (comp == "TilemapLayer") {
+ if (!reg.has<esengine::ecs::TilemapLayer>(entity)) return false;
+ const auto& c = reg.get<esengine::ecs::TilemapLayer>(entity);
+ if (field == "visible") { return c.visible; }
} else if (comp == "UIInteraction") {
if (!reg.has<esengine::ecs::UIInteraction>(entity)) return false;
const auto& c = reg.get<esengine::ecs::UIInteraction>(entity);
diff --git a/src/esengine/bindings/TilemapBindings.cpp b/src/esengine/bindings/TilemapBindings.cpp
index 123486540..a89e5edb1 100644
--- a/src/esengine/bindings/TilemapBindings.cpp
+++ b/src/esengine/bindings/TilemapBindings.cpp
@@ -17,7 +17,9 @@
#endif
#include <emscripten/bind.h>
+#include <cstring>
#include <string>
+#include <utility>
#include <vector>
namespace esengine {
@@ -39,6 +41,13 @@ void tilemap_initLayer(u32 entity, u32 width, u32 height,
getTilemapSystem().initLayer(e, width, height, tileWidth, tileHeight);
}
+void tilemap_initInfinite(u32 entity, f32 tileWidth, f32 tileHeight) {
+ auto e = Entity::fromRaw(entity);
+ if (e == INVALID_ENTITY) return;
+ if (getTilemapSystem().hasLayer(e)) return;
+ getTilemapSystem().initInfiniteLayer(e, tileWidth, tileHeight);
+}
+
void tilemap_destroyLayer(u32 entity) {
auto e = Entity::fromRaw(entity);
if (e == INVALID_ENTITY) return;
@@ -176,6 +185,166 @@ void tilemap_setOriginEntity(u32 layerKey, u32 originEntity) {
Entity::fromRaw(originEntity));
}
+// --- Chunk serialization ---
+
+namespace {
+
+// Base64 encoding uses the URL-safe alphabet (`-` / `_` instead of `+` / `/`)
+// so the output embeds cleanly in JSON scene files without escaping and can
+// also survive a ?query= parameter if anyone ever serves scenes over HTTP.
+constexpr const char* kB64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+void base64Encode(const u8* data, usize len, std::string& out) {
+ out.reserve(out.size() + ((len + 2) / 3) * 4);
+ usize i = 0;
+ while (i + 3 <= len) {
+ const u32 v = (u32(data[i]) << 16) | (u32(data[i + 1]) << 8) | u32(data[i + 2]);
+ out.push_back(kB64[(v >> 18) & 0x3F]);
+ out.push_back(kB64[(v >> 12) & 0x3F]);
+ out.push_back(kB64[(v >> 6) & 0x3F]);
+ out.push_back(kB64[v & 0x3F]);
+ i += 3;
+ }
+ if (i < len) {
+ const u32 v = (u32(data[i]) << 16) | (i + 1 < len ? (u32(data[i + 1]) << 8) : 0);
+ out.push_back(kB64[(v >> 18) & 0x3F]);
+ out.push_back(kB64[(v >> 12) & 0x3F]);
+ if (i + 1 < len) {
+ out.push_back(kB64[(v >> 6) & 0x3F]);
+ } else {
+ out.push_back('=');
+ }
+ out.push_back('=');
+ }
+}
+
+i32 b64Value(char c) {
+ if (c >= 'A' && c <= 'Z') return c - 'A';
+ if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+ if (c >= '0' && c <= '9') return c - '0' + 52;
+ if (c == '-' || c == '+') return 62;
+ if (c == '_' || c == '/') return 63;
+ return -1;
+}
+
+bool base64Decode(const std::string& in, std::vector<u8>& out) {
+ out.clear();
+ out.reserve(in.size() * 3 / 4);
+ i32 buf = 0;
+ i32 bits = 0;
+ for (char c : in) {
+ if (c == '=' || c == '\n' || c == '\r' || c == ' ') continue;
+ const i32 v = b64Value(c);
+ if (v < 0) return false;
+ buf = (buf << 6) | v;
+ bits += 6;
+ if (bits >= 8) {
+ bits -= 8;
+ out.push_back(static_cast<u8>((buf >> bits) & 0xFF));
+ }
+ }
+ return true;
+}
+
+} // namespace
+
+// Exports every non-empty chunk of `entity` as a single base64-encoded
+// blob. Layout (all little-endian):
+// u32 magic = 'ESTM' (header — version-check on import)
+// u32 chunkCount
+// repeated for each chunk:
+// i32 chunkX, i32 chunkY
+// u16 tiles[CHUNK_SIZE * CHUNK_SIZE]
+// Empty chunks are skipped to keep the payload compact for sparse maps.
+std::string tilemap_exportChunks(u32 entity) {
+ auto e = Entity::fromRaw(entity);
+ const auto* layer = getTilemapSystem().getLayerData(e);
+ if (!layer) return {};
+
+ std::vector<std::pair<tilemap::ChunkCoord, const tilemap::ChunkData*>> nonEmpty;
+ nonEmpty.reserve(layer->chunks.size());
+ for (const auto& [coord, chunk] : layer->chunks) {
+ bool anyTile = false;
+ for (u32 i = 0; i < tilemap::CHUNK_SIZE * tilemap::CHUNK_SIZE; ++i) {
+ if (chunk.tiles[i] != tilemap::EMPTY_TILE) { anyTile = true; break; }
+ }
+ if (anyTile) nonEmpty.emplace_back(coord, &chunk);
+ }
+
+ const u32 magic = 0x4D545345u; // 'ESTM'
+ const u32 count = static_cast<u32>(nonEmpty.size());
+ const usize perChunk = sizeof(i32) * 2
+ + tilemap::CHUNK_SIZE * tilemap::CHUNK_SIZE * sizeof(u16);
+ std::vector<u8> raw;
+ raw.reserve(sizeof(u32) * 2 + count * perChunk);
+
+ auto append = [&](const void* p, usize n) {
+ const u8* b = static_cast<const u8*>(p);
+ raw.insert(raw.end(), b, b + n);
+ };
+ append(&magic, sizeof(magic));
+ append(&count, sizeof(count));
+ for (const auto& [coord, chunk] : nonEmpty) {
+ append(&coord.x, sizeof(coord.x));
+ append(&coord.y, sizeof(coord.y));
+ append(chunk->tiles, sizeof(chunk->tiles));
+ }
+
+ std::string out;
+ base64Encode(raw.data(), raw.size(), out);
+ return out;
+}
+
+bool tilemap_importChunks(u32 entity, const std::string& encoded) {
+ auto e = Entity::fromRaw(entity);
+ // Auto-init as infinite if the caller didn't pre-create a layer — the
+ // scene loader path inserts the TilemapLayer component first and then
+ // expects the chunks to land, so we can't require a separate init call.
+ if (!getTilemapSystem().hasLayer(e)) {
+ getTilemapSystem().initInfiniteLayer(e, 32.0f, 32.0f);
+ }
+ auto* layer = getTilemapSystem().getLayerDataMut(e);
+ if (!layer) return false;
+
+ std::vector<u8> raw;
+ if (!base64Decode(encoded, raw)) return false;
+ if (raw.size() < sizeof(u32) * 2) return false;
+
+ auto read = [&raw](usize offset, void* out, usize n) -> bool {
+ if (offset + n > raw.size()) return false;
+ std::memcpy(out, raw.data() + offset, n);
+ return true;
+ };
+
+ u32 magic = 0;
+ u32 count = 0;
+ if (!read(0, &magic, sizeof(magic))) return false;
+ if (magic != 0x4D545345u) return false;
+ if (!read(sizeof(u32), &count, sizeof(count))) return false;
+
+ const usize perChunk = sizeof(i32) * 2
+ + tilemap::CHUNK_SIZE * tilemap::CHUNK_SIZE * sizeof(u16);
+ if (raw.size() < sizeof(u32) * 2 + static_cast<usize>(count) * perChunk) return false;
+
+ layer->chunks.clear();
+ usize cursor = sizeof(u32) * 2;
+ for (u32 i = 0; i < count; ++i) {
+ i32 cx = 0, cy = 0;
+ if (!read(cursor, &cx, sizeof(cx))) return false;
+ cursor += sizeof(cx);
+ if (!read(cursor, &cy, sizeof(cy))) return false;
+ cursor += sizeof(cy);
+
+ tilemap::ChunkData chunk;
+ if (!read(cursor, chunk.tiles, sizeof(chunk.tiles))) return false;
+ cursor += sizeof(chunk.tiles);
+ chunk.dirty = true;
+ layer->chunks[tilemap::ChunkCoord{cx, cy}] = chunk;
+ }
+
+ return true;
+}
+
// --- Tiled map loader bindings ---
u32 tiled_loadMap(uintptr_t dataPtr, u32 dataSize) {
@@ -581,6 +750,7 @@ uintptr_t tilemap_worldToTile(u32 entity, f32 wx, f32 wy,
EMSCRIPTEN_BINDINGS(esengine_tilemap) {
emscripten::function("tilemap_initLayer", &esengine::tilemap_initLayer);
+ emscripten::function("tilemap_initInfinite", &esengine::tilemap_initInfinite);
emscripten::function("tilemap_destroyLayer", &esengine::tilemap_destroyLayer);
emscripten::function("tilemap_setTile", &esengine::tilemap_setTile);
emscripten::function("tilemap_getTile", &esengine::tilemap_getTile);
@@ -592,6 +762,8 @@ EMSCRIPTEN_BINDINGS(esengine_tilemap) {
emscripten::function("tilemap_setTint", &esengine::tilemap_setTint);
emscripten::function("tilemap_setVisible", &esengine::tilemap_setVisible);
emscripten::function("tilemap_setOriginEntity", &esengine::tilemap_setOriginEntity);
+ emscripten::function("tilemap_exportChunks", &esengine::tilemap_exportChunks);
+ emscripten::function("tilemap_importChunks", &esengine::tilemap_importChunks);
emscripten::function("tiled_loadMap", &esengine::tiled_loadMap);
emscripten::function("tiled_freeMap", &esengine::tiled_freeMap);
diff --git a/src/esengine/bindings/WebBindings.generated.cpp b/src/esengine/bindings/WebBindings.generated.cpp
index 81fa04b1a..0d9842e8f 100644
--- a/src/esengine/bindings/WebBindings.generated.cpp
+++ b/src/esengine/bindings/WebBindings.generated.cpp
@@ -27,6 +27,7 @@
#include "../ecs/components/Sprite.hpp"
#include "../ecs/components/StateMachine.hpp"
#include "../ecs/components/StateVisuals.hpp"
+#include "../ecs/components/TilemapLayer.hpp"
#include "../ecs/components/Transform.hpp"
#include "../ecs/components/UIInteraction.hpp"
#include "../ecs/components/UIMask.hpp"
@@ -766,6 +767,49 @@ StateVisualsJS statevisualsToJS(const esengine::ecs::StateVisuals& c) {
return js;
}
+struct TilemapLayerJS {
+ glm::vec2 cellSize;
+ glm::vec2 originOffset;
+ u32 tileset;
+ i32 tilesetColumns;
+ i32 tilesetRows;
+ i32 renderLayer;
+ glm::vec4 tintColor;
+ f32 opacity;
+ glm::vec2 parallaxFactor;
+ bool visible;
+};
+
+esengine::ecs::TilemapLayer tilemaplayerFromJS(const TilemapLayerJS& js) {
+ esengine::ecs::TilemapLayer c;
+ c.cellSize = js.cellSize;
+ c.originOffset = js.originOffset;
+ c.tileset = resource::TextureHandle(js.tileset);
+ c.tilesetColumns = js.tilesetColumns;
+ c.tilesetRows = js.tilesetRows;
+ c.renderLayer = js.renderLayer;
+ c.tintColor = js.tintColor;
+ c.opacity = js.opacity;
+ c.parallaxFactor = js.parallaxFactor;
+ c.visible = js.visible;
+ return c;
+}
+
+TilemapLayerJS tilemaplayerToJS(const esengine::ecs::TilemapLayer& c) {
+ TilemapLayerJS js;
+ js.cellSize = c.cellSize;
+ js.originOffset = c.originOffset;
+ js.tileset = c.tileset.id();
+ js.tilesetColumns = c.tilesetColumns;
+ js.tilesetRows = c.tilesetRows;
+ js.renderLayer = c.renderLayer;
+ js.tintColor = c.tintColor;
+ js.opacity = c.opacity;
+ js.parallaxFactor = c.parallaxFactor;
+ js.visible = c.visible;
+ return js;
+}
+
struct UIMaskJS {
bool enabled;
i32 mode;
@@ -1071,6 +1115,18 @@ EMSCRIPTEN_BINDINGS(esengine_components) {
.field("slot7Sprite", &StateVisualsJS::slot7Sprite)
.field("slot7Scale", &StateVisualsJS::slot7Scale);
+ value_object<TilemapLayerJS>("TilemapLayer")
+ .field("cellSize", &TilemapLayerJS::cellSize)
+ .field("originOffset", &TilemapLayerJS::originOffset)
+ .field("tileset", &TilemapLayerJS::tileset)
+ .field("tilesetColumns", &TilemapLayerJS::tilesetColumns)
+ .field("tilesetRows", &TilemapLayerJS::tilesetRows)
+ .field("renderLayer", &TilemapLayerJS::renderLayer)
+ .field("tintColor", &TilemapLayerJS::tintColor)
+ .field("opacity", &TilemapLayerJS::opacity)
+ .field("parallaxFactor", &TilemapLayerJS::parallaxFactor)
+ .field("visible", &TilemapLayerJS::visible);
+
value_object<esengine::ecs::Transform>("Transform")
.field("position", &esengine::ecs::Transform::position)
.field("rotation", &esengine::ecs::Transform::rotation)
@@ -1539,6 +1595,26 @@ EMSCRIPTEN_BINDINGS(esengine_registry) {
r.remove<esengine::ecs::StateVisuals>(entity);
}))
+ // TilemapLayer
+ .function("hasTilemapLayer", optional_override([](Registry& r, u32 e) {
+ return r.has<esengine::ecs::TilemapLayer>(static_cast<Entity>(e));
+ }))
+ .function("getTilemapLayer", optional_override([](Registry& r, u32 e) {
+ auto entity = static_cast<Entity>(e);
+ if (!r.valid(entity) || !r.has<esengine::ecs::TilemapLayer>(entity)) return TilemapLayerJS{};
+ return tilemaplayerToJS(r.get<esengine::ecs::TilemapLayer>(entity));
+ }))
+ .function("addTilemapLayer", optional_override([](Registry& r, u32 e, const TilemapLayerJS& js) {
+ auto entity = static_cast<Entity>(e);
+ if (!r.valid(entity)) return;
+ r.emplaceOrReplace<esengine::ecs::TilemapLayer>(entity, tilemaplayerFromJS(js));
+ }))
+ .function("removeTilemapLayer", optional_override([](Registry& r, u32 e) {
+ auto entity = static_cast<Entity>(e);
+ if (!r.valid(entity) || !r.has<esengine::ecs::TilemapLayer>(entity)) return;
+ r.remove<esengine::ecs::TilemapLayer>(entity);
+ }))
+
// Transform
.function("hasTransform", optional_override([](Registry& r, u32 e) {
return r.has<esengine::ecs::Transform>(static_cast<Entity>(e));
@@ -1701,6 +1777,7 @@ emscripten::val esengineGetBuiltinComponentNames() {
arr.set(i++, val(std::string("Sprite")));
arr.set(i++, val(std::string("StateMachine")));
arr.set(i++, val(std::string("StateVisuals")));
+ arr.set(i++, val(std::string("TilemapLayer")));
arr.set(i++, val(std::string("Transform")));
arr.set(i++, val(std::string("UIInteraction")));
arr.set(i++, val(std::string("UIMask")));
diff --git a/src/esengine/ecs/components/TilemapLayer.hpp b/src/esengine/ecs/components/TilemapLayer.hpp
new file mode 100644
index 000000000..5b224ea50
--- /dev/null
+++ b/src/esengine/ecs/components/TilemapLayer.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include "../../core/Types.hpp"
+#include "../../core/Reflection.hpp"
+#include "../../math/Math.hpp"
+#include "../../resource/Handle.hpp"
+
+namespace esengine::ecs {
+
+// Visible editor-facing metadata for a tilemap layer entity. The bulk tile
+// data (chunks, animations, per-tile properties) lives in TilemapSystem's
+// LayerData keyed by this entity — see TilemapSystem for why the heavy
+// state is held out-of-component. The split mirrors SpineAnimation, where
+// the component describes "what this layer is" and the system owns the
+// resolved runtime state.
+ES_COMPONENT()
+struct TilemapLayer {
+ // Size in world units of one tile cell.
+ ES_PROPERTY()
+ glm::vec2 cellSize{32.0f, 32.0f};
+
+ // World offset applied before rendering. Per-layer parallax scales this
+ // by the camera position so background layers can drift more slowly.
+ ES_PROPERTY()
+ glm::vec2 originOffset{0.0f, 0.0f};
+
+ // Texture atlas from which tile IDs index quads. Tile 0 is always
+ // treated as empty; IDs 1..N index into the atlas row-major.
+ ES_PROPERTY(asset = texture)
+ resource::TextureHandle tileset;
+
+ // Atlas layout: columns × rows of tiles in the tileset texture. Used
+ // to compute the per-tile UV rect on render.
+ ES_PROPERTY()
+ i32 tilesetColumns{1};
+
+ ES_PROPERTY()
+ i32 tilesetRows{1};
+
+ // Sort order within the 2D renderer. Lower draws first.
+ ES_PROPERTY()
+ i32 renderLayer{0};
+
+ // Multiplied against the tile sample colour before blending.
+ ES_PROPERTY(animatable)
+ glm::vec4 tintColor{1.0f, 1.0f, 1.0f, 1.0f};
+
+ // Multiplied into the alpha channel of tintColor at submit time.
+ ES_PROPERTY(animatable)
+ f32 opacity{1.0f};
+
+ // Per-axis parallax factor (1.0 = locked to camera, 0.0 = static
+ // background). Evaluated against the active camera each frame.
+ ES_PROPERTY()
+ glm::vec2 parallaxFactor{1.0f, 1.0f};
+
+ ES_PROPERTY()
+ bool visible{true};
+
+ // Runtime-only: set by TilemapSystem when it needs to sync author-
+ // settable fields (tint, visible, render layer) from the component
+ // back into LayerData. Not ES_PROPERTY — not author data, not
+ // serialized. Starts true so the first tick after spawn pushes the
+ // component defaults through.
+ bool needsSync{true};
+
+ TilemapLayer() = default;
+};
+
+} // namespace esengine::ecs