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.

refactor(tilemap): renderer reads painted-layer metadata from the component (RC2a)

yhh5b4fa9bd9881
diff --git a/sdk/src/tilemap/tilemapPlugin.ts b/sdk/src/tilemap/tilemapPlugin.ts
index 8de1d5960..4a95e0bb9 100644
--- a/sdk/src/tilemap/tilemapPlugin.ts
+++ b/sdk/src/tilemap/tilemapPlugin.ts
@@ -31,15 +31,6 @@ export class TilemapPlugin implements Plugin {
private initializedLayers_ = new Set<number>();
private animatedLayers_ = new Set<number>();
private sourceEntityKeys_ = new Map<number, number[]>();
- private layerState_ = new Map<number, {
- texture: number;
- tilesetColumns: number;
- renderLayer: number;
- tintR: number; tintG: number; tintB: number; tintA: number;
- opacity: number;
- parallaxX: number; parallaxY: number;
- visible: boolean;
- }>();
/** tilemap entity → the static collider entities derived from its collidable tiles (play-mode only). */
private collisionEntities_ = new Map<number, Entity[]>();
/** TilemapLayer entity → its baked collidable tile ids (out-of-band scene data; drives native collision). */
@@ -81,7 +72,6 @@ export class TilemapPlugin implements Plugin {
const initializedLayers = this.initializedLayers_;
const animatedLayers = this.animatedLayers_;
const sourceEntityKeys = this.sourceEntityKeys_;
- const layerState = this.layerState_;
const collisionEntities = this.collisionEntities_;
const tilemapSyncSystem: SystemDef = {
@@ -110,7 +100,6 @@ export class TilemapPlugin implements Plugin {
if (!currentLayerSet.has(entity)) {
TilemapAPI.destroyLayer(entity);
initializedLayers.delete(entity);
- layerState.delete(entity);
nativeCollisionIds.delete(entity);
const colliders = collisionEntities.get(entity);
if (colliders) {
@@ -127,9 +116,11 @@ export class TilemapPlugin implements Plugin {
const textureHandle = layerData.tileset;
if (!textureHandle) continue;
- const dims = getTextureDimensions(textureHandle);
- if (!dims) continue;
-
+ // RC2a: the TilemapLayer component is the single source of visual
+ // metadata; the C++ renderer reads tint/opacity/tileset/columns/
+ // renderLayer/parallax/visible straight off the component each frame.
+ // No per-frame push into LayerData anymore — we only init the layer's
+ // chunk store (the heavy data) and let the renderer pull the rest.
if (!initializedLayers.has(entity)) {
TilemapAPI.initInfiniteLayer(
entity, layerData.cellSize.x, layerData.cellSize.y,
@@ -138,43 +129,6 @@ export class TilemapPlugin implements Plugin {
initializedLayers.add(entity);
}
- const uvTileWidth = layerData.cellSize.x / dims.width;
- const uvTileHeight = layerData.cellSize.y / dims.height;
- const tint = layerData.tintColor;
- const pf = layerData.parallaxFactor;
-
- const prev = layerState.get(entity);
- const needsUpdate = !prev
- || prev.texture !== textureHandle
- || prev.tilesetColumns !== layerData.tilesetColumns
- || prev.renderLayer !== layerData.renderLayer
- || prev.parallaxX !== pf.x || prev.parallaxY !== pf.y
- || prev.tintR !== tint.r || prev.tintG !== tint.g
- || prev.tintB !== tint.b || prev.tintA !== tint.a
- || prev.opacity !== layerData.opacity
- || prev.visible !== layerData.visible;
-
- if (needsUpdate) {
- TilemapAPI.setRenderProps(
- entity, textureHandle, layerData.tilesetColumns,
- uvTileWidth, uvTileHeight,
- layerData.renderLayer, 0,
- pf.x, pf.y,
- );
- TilemapAPI.setTint(entity, tint.r, tint.g, tint.b, tint.a, layerData.opacity ?? 1);
- TilemapAPI.setVisible(entity, layerData.visible ?? true);
-
- layerState.set(entity, {
- texture: textureHandle,
- tilesetColumns: layerData.tilesetColumns,
- renderLayer: layerData.renderLayer,
- tintR: tint.r, tintG: tint.g, tintB: tint.b, tintA: tint.a,
- opacity: layerData.opacity,
- parallaxX: pf.x, parallaxY: pf.y,
- visible: layerData.visible,
- });
- }
-
// Native path: a painted TilemapLayer with collidable tiles (baked from
// its .estileset) spawns merged static colliders once in play mode.
const collIds = nativeCollisionIds.get(entity);
@@ -302,7 +256,6 @@ export class TilemapPlugin implements Plugin {
TilemapAPI.destroyLayer(key);
initializedLayers.delete(key);
animatedLayers.delete(key);
- layerState.delete(key);
}
sourceEntityKeys.delete(entity);
@@ -333,7 +286,6 @@ export class TilemapPlugin implements Plugin {
this.initializedLayers_.clear();
this.animatedLayers_.clear();
this.sourceEntityKeys_.clear();
- this.layerState_.clear();
// Collider entities die with the world on reset/teardown; just drop our bookkeeping.
this.collisionEntities_.clear();
this.nativeCollisionIds_.clear();
diff --git a/src/esengine/renderer/plugins/TilemapRenderPlugin.cpp b/src/esengine/renderer/plugins/TilemapRenderPlugin.cpp
index 6af4d9286..f3d9b100b 100644
--- a/src/esengine/renderer/plugins/TilemapRenderPlugin.cpp
+++ b/src/esengine/renderer/plugins/TilemapRenderPlugin.cpp
@@ -5,6 +5,7 @@
#include "../../tilemap/TilemapSystem.hpp"
#include "../../ecs/components/Transform.hpp"
+#include "../../ecs/components/TilemapLayer.hpp"
#include "../RenderFrame.hpp"
#include <cmath>
@@ -19,6 +20,7 @@ void TilemapRenderPlugin::rebuildChunk(
const tilemap::TilemapSystem::LayerData& layer,
const tilemap::ChunkData& chunk, tilemap::ChunkCoord coord,
f32 originX, f32 originY, u32 packedColor,
+ u32 tilesetColumns, f32 uvTileW, f32 uvTileH,
Entity entity, ChunkCache& cache
) {
cache.vertices.clear();
@@ -54,8 +56,8 @@ void TilemapRenderPlugin::rebuildChunk(
bool flipV = (rawTile & tilemap::TILE_FLIP_V) != 0;
u32 tileIndex = tileId - 1;
- u32 tileCol = tileIndex % layer.tileset_columns;
- u32 tileRow = tileIndex / layer.tileset_columns;
+ u32 tileCol = tileIndex % tilesetColumns;
+ u32 tileRow = tileIndex / tilesetColumns;
f32 worldX, worldY;
if (layer.grid_type == tilemap::GridType::Isometric) {
@@ -70,13 +72,13 @@ void TilemapRenderPlugin::rebuildChunk(
worldY = originY - static_cast<f32>(ty) * layer.tile_height - hh;
}
- f32 u0 = static_cast<f32>(tileCol) * layer.uv_tile_width;
- f32 v0 = 1.0f - static_cast<f32>(tileRow + 1) * layer.uv_tile_height;
- f32 su = layer.uv_tile_width;
- f32 sv = layer.uv_tile_height;
+ f32 u0 = static_cast<f32>(tileCol) * uvTileW;
+ f32 v0 = 1.0f - static_cast<f32>(tileRow + 1) * uvTileH;
+ f32 su = uvTileW;
+ f32 sv = uvTileH;
- if (flipH) { u0 += layer.uv_tile_width; su = -su; }
- if (flipV) { v0 += layer.uv_tile_height; sv = -sv; }
+ if (flipH) { u0 += uvTileW; su = -su; }
+ if (flipV) { v0 += uvTileH; sv = -sv; }
u32 baseVertex = static_cast<u32>(cache.vertices.size());
cache.vertices.push_back({ {worldX - hw, worldY - hh}, packedColor, {u0, v0} });
@@ -111,12 +113,54 @@ void TilemapRenderPlugin::collect(RenderCollectContext& collect_ctx) {
f32 camTop = tr.y / tr.w;
for (const auto& [entity, layer] : layers) {
- if (!layer.visible || layer.texture_handle == 0 || layer.tileset_columns == 0) continue;
+ // RC2a: the TilemapLayer component is the single source of a painted
+ // layer's visual metadata — the renderer reads it live each frame (so
+ // animated tint/opacity need no sync). Tiled-imported synthetic layers
+ // have no component and still carry their metadata in LayerData.
+ const ecs::TilemapLayer* comp = registry.tryGet<ecs::TilemapLayer>(entity);
+
+ bool visible;
+ resource::TextureHandle tilesetHandle;
+ u32 tilesetColumns;
+ i32 sortLayer;
+ f32 depth;
+ glm::vec4 tint;
+ f32 opacity;
+ glm::vec2 parallax;
+ if (comp) {
+ visible = comp->visible;
+ tilesetHandle = comp->tileset;
+ tilesetColumns = static_cast<u32>(comp->tilesetColumns);
+ sortLayer = comp->renderLayer;
+ depth = 0.0f;
+ tint = comp->tintColor;
+ opacity = comp->opacity;
+ parallax = comp->parallaxFactor;
+ } else {
+ visible = layer.visible;
+ tilesetHandle = resource::TextureHandle(layer.texture_handle);
+ tilesetColumns = layer.tileset_columns;
+ sortLayer = layer.sort_layer;
+ depth = layer.depth;
+ tint = layer.tint;
+ opacity = layer.opacity;
+ parallax = layer.parallax_factor;
+ }
- auto* texRes = ctx.resources.getTexture(resource::TextureHandle(layer.texture_handle));
+ if (!visible || !tilesetHandle.isValid() || tilesetColumns == 0) continue;
+
+ auto* texRes = ctx.resources.getTexture(tilesetHandle);
if (!texRes) continue;
u32 glTextureId = texRes->getId();
+ // UVs derive from tile size / texture size — the single source is the
+ // tile dimensions + the texture, so there is no synced uv copy to drift.
+ f32 texW = static_cast<f32>(texRes->getWidth());
+ f32 texH = static_cast<f32>(texRes->getHeight());
+ if (texW <= 0.0f || texH <= 0.0f) continue;
+ f32 uvTileW = layer.tile_width / texW;
+ f32 uvTileH = layer.tile_height / texH;
+
f32 originX = 0, originY = 0;
Entity transformEntity = (layer.origin_entity != INVALID_ENTITY)
? layer.origin_entity : entity;
@@ -125,15 +169,13 @@ void TilemapRenderPlugin::collect(RenderCollectContext& collect_ctx) {
originY = transform->worldPosition.y;
}
- glm::vec4 finalColor(
- layer.tint.r, layer.tint.g, layer.tint.b,
- layer.tint.a * layer.opacity);
+ glm::vec4 finalColor(tint.r, tint.g, tint.b, tint.a * opacity);
u32 packedColor = packColor(finalColor);
f32 camCenterX = (camLeft + camRight) * 0.5f;
f32 camCenterY = (camBottom + camTop) * 0.5f;
- f32 parallaxOffsetX = camCenterX * (1.0f - layer.parallax_factor.x);
- f32 parallaxOffsetY = camCenterY * (1.0f - layer.parallax_factor.y);
+ f32 parallaxOffsetX = camCenterX * (1.0f - parallax.x);
+ f32 parallaxOffsetY = camCenterY * (1.0f - parallax.y);
f32 adjOriginX = originX + parallaxOffsetX;
f32 adjOriginY = originY + parallaxOffsetY;
@@ -174,6 +216,7 @@ void TilemapRenderPlugin::collect(RenderCollectContext& collect_ctx) {
if (chunkData.revision != cache.built_revision || cache.has_animated_tiles) {
rebuildChunk(layer, chunkData, coord,
adjOriginX, adjOriginY, packedColor,
+ tilesetColumns, uvTileW, uvTileH,
entity, cache);
cache.built_revision = chunkData.revision;
}
@@ -197,11 +240,11 @@ void TilemapRenderPlugin::collect(RenderCollectContext& collect_ctx) {
indices_.data(), static_cast<u32>(indices_.size()),
BatchDrawKey{
.stage = ctx.current_stage,
- .layer = layer.sort_layer,
+ .layer = sortLayer,
.shaderId = batch_shader_id_,
.blend = BlendMode::Normal,
.textureId = glTextureId,
- .depth = layer.depth,
+ .depth = depth,
.entity = entity,
.type = RenderType::Sprite,
});
diff --git a/src/esengine/renderer/plugins/TilemapRenderPlugin.hpp b/src/esengine/renderer/plugins/TilemapRenderPlugin.hpp
index a22d51d38..2255533f6 100644
--- a/src/esengine/renderer/plugins/TilemapRenderPlugin.hpp
+++ b/src/esengine/renderer/plugins/TilemapRenderPlugin.hpp
@@ -40,6 +40,7 @@ private:
void rebuildChunk(const tilemap::TilemapSystem::LayerData& layer,
const tilemap::ChunkData& chunk, tilemap::ChunkCoord coord,
f32 originX, f32 originY, u32 packedColor,
+ u32 tilesetColumns, f32 uvTileW, f32 uvTileH,
Entity entity, ChunkCache& cache);
tilemap::TilemapSystem* tilemap_system_ = nullptr;