A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
fix(tilemap): align rotated layers and collision normals
yhh91936bb0c6f8
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex f85b962a0..14c2b3782 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -14,6 +14,10 @@ published separately; it ships inside the editor.## [Unreleased]+### Fixed++- **Rotated tile layers share one frame for drawing, picking and collision previews.** World Z rotation, including parent rotation, applies to tile vertices, visible chunk selection, editor grids, brush ghosts and world-to-tile queries. Collision previews rotate cached local geometry and keep large shapes visible when their bounds overlap the viewport. Generated tile one-way platforms rotate their solid side with the physics body; ordinary one-way platforms retain world-space normals unless `localSpace` is enabled. Static-parent rotation needs no repeated normal submissions, and rebuilt shapes restore their pre-solve behavior.+## [0.88.0] - 2026-10-15### Addeddiff --git a/desktop b/desktopindex 56085d2c8..ecff22bba 160000--- a/desktop+++ b/desktop@@ -1 +1 @@-Subproject commit 56085d2c89a614a4c99503794d87654716b70715+Subproject commit ecff22bbabdda331dd603724b3c37524e0d197dadiff --git a/docs/astro/src/data/components.generated.json b/docs/astro/src/data/components.generated.jsonindex cf512df3b..603ca2e87 100644--- a/docs/astro/src/data/components.generated.json+++ b/docs/astro/src/data/components.generated.json@@ -2775,6 +2775,11 @@"type": "Vec2","default": "(0, 1)"},+ {+ "key": "localSpace",+ "type": "boolean",+ "default": "false"+ },{"key": "enabled","type": "boolean",diff --git a/sdk/etc/index.api.md b/sdk/etc/index.api.mdindex e0b60760d..b643fb7a0 100644--- a/sdk/etc/index.api.md+++ b/sdk/etc/index.api.md@@ -5929,6 +5929,7 @@ _physics_setMotorJointMaxVelocityForce: (entityId: number, force: number) => voi_physics_setMotorJointMaxVelocityTorque: (entityId: number, torque: number) => void_physics_setMouseTarget: (targetX: number, targetY: number) => void_physics_setOneWayPlatform: (entityId: number, nx: number, ny: number, enable: number) => void+_physics_setOneWayPlatformLocal: (entityId: number, nx: number, ny: number, enable: number) => void_physics_setPrismaticJointLimits: (entityId: number, lower: number, upper: number) => void_physics_setPrismaticJointMaxMotorForce: (entityId: number, force: number) => void_physics_setPrismaticJointMotorSpeed: (entityId: number, speed: number) => voiddiff --git a/sdk/etc/index.native.api.md b/sdk/etc/index.native.api.mdindex 8843c34c0..de48a80ed 100644--- a/sdk/etc/index.native.api.md+++ b/sdk/etc/index.native.api.md@@ -6132,6 +6132,7 @@ _physics_setMotorJointMaxVelocityForce: (entityId: number, force: number) => voi_physics_setMotorJointMaxVelocityTorque: (entityId: number, torque: number) => void_physics_setMouseTarget: (targetX: number, targetY: number) => void_physics_setOneWayPlatform: (entityId: number, nx: number, ny: number, enable: number) => void+_physics_setOneWayPlatformLocal: (entityId: number, nx: number, ny: number, enable: number) => void_physics_setPrismaticJointLimits: (entityId: number, lower: number, upper: number) => void_physics_setPrismaticJointMaxMotorForce: (entityId: number, force: number) => void_physics_setPrismaticJointMotorSpeed: (entityId: number, speed: number) => voiddiff --git a/sdk/etc/index.node.api.md b/sdk/etc/index.node.api.mdindex 5bed73613..d11efadbc 100644--- a/sdk/etc/index.node.api.md+++ b/sdk/etc/index.node.api.md@@ -5924,6 +5924,7 @@ _physics_setMotorJointMaxVelocityForce: (entityId: number, force: number) => voi_physics_setMotorJointMaxVelocityTorque: (entityId: number, torque: number) => void_physics_setMouseTarget: (targetX: number, targetY: number) => void_physics_setOneWayPlatform: (entityId: number, nx: number, ny: number, enable: number) => void+_physics_setOneWayPlatformLocal: (entityId: number, nx: number, ny: number, enable: number) => void_physics_setPrismaticJointLimits: (entityId: number, lower: number, upper: number) => void_physics_setPrismaticJointMaxMotorForce: (entityId: number, force: number) => void_physics_setPrismaticJointMotorSpeed: (entityId: number, speed: number) => voiddiff --git a/sdk/etc/minigame.api.md b/sdk/etc/minigame.api.mdindex 1362e7b6b..dc788226d 100644--- a/sdk/etc/minigame.api.md+++ b/sdk/etc/minigame.api.md@@ -6217,6 +6217,7 @@ _physics_setMotorJointMaxVelocityForce: (entityId: number, force: number) => voi_physics_setMotorJointMaxVelocityTorque: (entityId: number, torque: number) => void_physics_setMouseTarget: (targetX: number, targetY: number) => void_physics_setOneWayPlatform: (entityId: number, nx: number, ny: number, enable: number) => void+_physics_setOneWayPlatformLocal: (entityId: number, nx: number, ny: number, enable: number) => void_physics_setPrismaticJointLimits: (entityId: number, lower: number, upper: number) => void_physics_setPrismaticJointMaxMotorForce: (entityId: number, force: number) => void_physics_setPrismaticJointMotorSpeed: (entityId: number, speed: number) => voiddiff --git a/sdk/etc/physics.api.md b/sdk/etc/physics.api.mdindex 3fd0420b2..97182bb84 100644--- a/sdk/etc/physics.api.md+++ b/sdk/etc/physics.api.md@@ -299,6 +299,7 @@ ComponentDef<OneWayPlatform2DData>## OneWayPlatform2DData — interface @experimental```enabled: boolean+localSpace: boolean | undefinednormal: Vec2```@@ -557,6 +558,7 @@ _physics_setMotorJointMaxVelocityForce: (entityId: number, force: number) => voi_physics_setMotorJointMaxVelocityTorque: (entityId: number, torque: number) => void_physics_setMouseTarget: (targetX: number, targetY: number) => void_physics_setOneWayPlatform: (entityId: number, nx: number, ny: number, enable: number) => void+_physics_setOneWayPlatformLocal: (entityId: number, nx: number, ny: number, enable: number) => void_physics_setPrismaticJointLimits: (entityId: number, lower: number, upper: number) => void_physics_setPrismaticJointMaxMotorForce: (entityId: number, force: number) => void_physics_setPrismaticJointMotorSpeed: (entityId: number, speed: number) => voiddiff --git a/sdk/etc/tilemap.api.md b/sdk/etc/tilemap.api.mdindex 6729f5e84..ff0ddf476 100644--- a/sdk/etc/tilemap.api.md+++ b/sdk/etc/tilemap.api.md@@ -372,7 +372,7 @@ ComponentDef<TilemapData>## TilemapAPI — const @experimental```-{ initLayer(entity: number, width: number, height: number, tileWidth: number, tileHeight: number): void; destroyLayer(entity: number): void; setTile(entity: number, x: number, y: number, tileId: number): void; getTile(entity: number, x: number, y: number): number; fillRect(entity: number, x: number, y: number, w: number, h: number, tileId: number): void; setTiles(entity: number, tiles: Uint16Array): void; setTilesets(entity: number, slots: { firstId: number; textureHandle: number; columns: number; margin?: number; spacing?: number; extrude?: number; }[]): void; hasLayer(entity: number): boolean; setRenderProps(entity: number, textureHandle: number, tilesetColumns: number, uvTileW: number, uvTileH: number, sortLayer: number, depth: number, parallaxX: number, parallaxY: number): void; setTint(entity: number, r: number, g: number, b: number, a: number, opacity: number): void; setVisible(entity: number, visible: boolean): void; setOriginEntity(layerKey: number, originEntity: number): void; setTileAnimation(entity: number, tileId: number, frames: { tileId: number; duration: number; }[]): void; clearTileAnimations(entity: number): void; advanceAnimations(entity: number, dtMs: number): void; setTileProperty(entity: number, tileId: number, key: string, value: string): void; getTileProperty(entity: number, x: number, y: number, key: string): string; flipTile(entity: number, x: number, y: number, flipH: boolean, flipV: boolean, flipD: boolean): void; rotateTile(entity: number, x: number, y: number, degrees: number): void; initInfiniteLayer(entity: number, tileWidth: number, tileHeight: number): void; setChunkTiles(entity: number, chunkX: number, chunkY: number, tiles: Uint16Array, width: number, height: number): void; setGridType(entity: number, type: number): void; setHexParams(entity: number, sideLength: number, staggerAxisX: boolean, staggerIndexEven: boolean): void; tileToWorld(entity: number, tx: number, ty: number, originX: number, originY: number): { x: number; y: number; }; worldToTile(entity: number, wx: number, wy: number, originX: number, originY: number): { x: number; y: number; }; exportChunks(entity: number): string; importChunks(entity: number, encoded: string): boolean; }+{ initLayer(entity: number, width: number, height: number, tileWidth: number, tileHeight: number): void; destroyLayer(entity: number): void; setTile(entity: number, x: number, y: number, tileId: number): void; getTile(entity: number, x: number, y: number): number; fillRect(entity: number, x: number, y: number, w: number, h: number, tileId: number): void; setTiles(entity: number, tiles: Uint16Array): void; setTilesets(entity: number, slots: { firstId: number; textureHandle: number; columns: number; margin?: number; spacing?: number; extrude?: number; }[]): void; hasLayer(entity: number): boolean; setRenderProps(entity: number, textureHandle: number, tilesetColumns: number, uvTileW: number, uvTileH: number, sortLayer: number, depth: number, parallaxX: number, parallaxY: number): void; setTint(entity: number, r: number, g: number, b: number, a: number, opacity: number): void; setVisible(entity: number, visible: boolean): void; setOriginEntity(layerKey: number, originEntity: number): void; setTileAnimation(entity: number, tileId: number, frames: { tileId: number; duration: number; }[]): void; clearTileAnimations(entity: number): void; advanceAnimations(entity: number, dtMs: number): void; setTileProperty(entity: number, tileId: number, key: string, value: string): void; getTileProperty(entity: number, x: number, y: number, key: string): string; flipTile(entity: number, x: number, y: number, flipH: boolean, flipV: boolean, flipD: boolean): void; rotateTile(entity: number, x: number, y: number, degrees: number): void; initInfiniteLayer(entity: number, tileWidth: number, tileHeight: number): void; setChunkTiles(entity: number, chunkX: number, chunkY: number, tiles: Uint16Array, width: number, height: number): void; setGridType(entity: number, type: number): void; setHexParams(entity: number, sideLength: number, staggerAxisX: boolean, staggerIndexEven: boolean): void; tileToWorld(entity: number, tx: number, ty: number, originX: number, originY: number, rotation?: number): { x: number; y: number; }; worldToTile(entity: number, wx: number, wy: number, originX: number, originY: number, rotation?: number): { x: number; y: number; }; exportChunks(entity: number): string; importChunks(entity: number, encoded: string): boolean; }```## TilemapData — interface @experimental@@ -454,7 +454,7 @@ Odd = 0## Tilemaps — const @experimental```-ResourceDef<{ initLayer(entity: number, width: number, height: number, tileWidth: number, tileHeight: number): void; destroyLayer(entity: number): void; setTile(entity: number, x: number, y: number, tileId: number): void; getTile(entity: number, x: number, y: number): number; fillRect(entity: number, x: number, y: number, w: number, h: number, tileId: number): void; setTiles(entity: number, tiles: Uint16Array): void; setTilesets(entity: number, slots: { firstId: number; textureHandle: number; columns: number; margin?: number; spacing?: number; extrude?: number; }[]): void; hasLayer(entity: number): boolean; setRenderProps(entity: number, textureHandle: number, tilesetColumns: number, uvTileW: number, uvTileH: number, sortLayer: number, depth: number, parallaxX: number, parallaxY: number): void; setTint(entity: number, r: number, g: number, b: number, a: number, opacity: number): void; setVisible(entity: number, visible: boolean): void; setOriginEntity(layerKey: number, originEntity: number): void; setTileAnimation(entity: number, tileId: number, frames: { tileId: number; duration: number; }[]): void; clearTileAnimations(entity: number): void; advanceAnimations(entity: number, dtMs: number): void; setTileProperty(entity: number, tileId: number, key: string, value: string): void; getTileProperty(entity: number, x: number, y: number, key: string): string; flipTile(entity: number, x: number, y: number, flipH: boolean, flipV: boolean, flipD: boolean): void; rotateTile(entity: number, x: number, y: number, degrees: number): void; initInfiniteLayer(entity: number, tileWidth: number, tileHeight: number): void; setChunkTiles(entity: number, chunkX: number, chunkY: number, tiles: Uint16Array, width: number, height: number): void; setGridType(entity: number, type: number): void; setHexParams(entity: number, sideLength: number, staggerAxisX: boolean, staggerIndexEven: boolean): void; tileToWorld(entity: number, tx: number, ty: number, originX: number, originY: number): { x: number; y: number; }; worldToTile(entity: number, wx: number, wy: number, originX: number, originY: number): { x: number; y: number; }; exportChunks(entity: number): string; importChunks(entity: number, encoded: string): boolean; }>+ResourceDef<{ initLayer(entity: number, width: number, height: number, tileWidth: number, tileHeight: number): void; destroyLayer(entity: number): void; setTile(entity: number, x: number, y: number, tileId: number): void; getTile(entity: number, x: number, y: number): number; fillRect(entity: number, x: number, y: number, w: number, h: number, tileId: number): void; setTiles(entity: number, tiles: Uint16Array): void; setTilesets(entity: number, slots: { firstId: number; textureHandle: number; columns: number; margin?: number; spacing?: number; extrude?: number; }[]): void; hasLayer(entity: number): boolean; setRenderProps(entity: number, textureHandle: number, tilesetColumns: number, uvTileW: number, uvTileH: number, sortLayer: number, depth: number, parallaxX: number, parallaxY: number): void; setTint(entity: number, r: number, g: number, b: number, a: number, opacity: number): void; setVisible(entity: number, visible: boolean): void; setOriginEntity(layerKey: number, originEntity: number): void; setTileAnimation(entity: number, tileId: number, frames: { tileId: number; duration: number; }[]): void; clearTileAnimations(entity: number): void; advanceAnimations(entity: number, dtMs: number): void; setTileProperty(entity: number, tileId: number, key: string, value: string): void; getTileProperty(entity: number, x: number, y: number, key: string): string; flipTile(entity: number, x: number, y: number, flipH: boolean, flipV: boolean, flipD: boolean): void; rotateTile(entity: number, x: number, y: number, degrees: number): void; initInfiniteLayer(entity: number, tileWidth: number, tileHeight: number): void; setChunkTiles(entity: number, chunkX: number, chunkY: number, tiles: Uint16Array, width: number, height: number): void; setGridType(entity: number, type: number): void; setHexParams(entity: number, sideLength: number, staggerAxisX: boolean, staggerIndexEven: boolean): void; tileToWorld(entity: number, tx: number, ty: number, originX: number, originY: number, rotation?: number): { x: number; y: number; }; worldToTile(entity: number, wx: number, wy: number, originX: number, originY: number, rotation?: number): { x: number; y: number; }; exportChunks(entity: number): string; importChunks(entity: number, encoded: string): boolean; }>```## TilesetAnimFrame — interface @experimental@@ -848,7 +848,7 @@ tileTerrain: Map<number, number>## tileCollisionAtWorld — function @experimental```-(layer: Entity | number, worldX: number, worldY: number, originX?: number, originY?: number): ResolvedTileCollision | null+(layer: Entity | number, worldX: number, worldY: number, originX?: number, originY?: number, rotation?: number): ResolvedTileCollision | null```## tileCollisionOutlines — function @experimentaldiff --git a/sdk/etc/wechat.api.md b/sdk/etc/wechat.api.mdindex f9293d4d0..c1eb5852e 100644--- a/sdk/etc/wechat.api.md+++ b/sdk/etc/wechat.api.md@@ -5931,6 +5931,7 @@ _physics_setMotorJointMaxVelocityForce: (entityId: number, force: number) => voi_physics_setMotorJointMaxVelocityTorque: (entityId: number, torque: number) => void_physics_setMouseTarget: (targetX: number, targetY: number) => void_physics_setOneWayPlatform: (entityId: number, nx: number, ny: number, enable: number) => void+_physics_setOneWayPlatformLocal: (entityId: number, nx: number, ny: number, enable: number) => void_physics_setPrismaticJointLimits: (entityId: number, lower: number, upper: number) => void_physics_setPrismaticJointMaxMotorForce: (entityId: number, force: number) => void_physics_setPrismaticJointMotorSpeed: (entityId: number, speed: number) => voiddiff --git a/sdk/src/physics/Physics2DPlugin.ts b/sdk/src/physics/Physics2DPlugin.tsindex fc2a43295..ffa60708e 100644--- a/sdk/src/physics/Physics2DPlugin.ts+++ b/sdk/src/physics/Physics2DPlugin.ts@@ -93,6 +93,7 @@ const REQUIRED_EXPORTS = ['_physics_capturePoses', '_physics_getInterpolatedCount', '_physics_getInterpolatedTransforms','_physics_collectEvents', '_physics_getDynamicBodyCount', '_physics_getDynamicBodyTransforms','_physics_setBodyTransform',+ '_physics_setOneWayPlatformLocal',] as const;function assertModuleContract(module: PhysicsWasmModule): void {diff --git a/sdk/src/physics/PhysicsComponents.ts b/sdk/src/physics/PhysicsComponents.tsindex 8cdb651dd..59bbc797f 100644--- a/sdk/src/physics/PhysicsComponents.ts+++ b/sdk/src/physics/PhysicsComponents.ts@@ -239,10 +239,11 @@ export function activeCollider<C extends AnyComponentDef>(// =============================================================================export interface OneWayPlatform2DData {- // Solid-side normal in world/physics space. Contacts are cancelled unless the- // other body approaches from this side. Default {0,1} = solid top (land on top,- // jump up through it).+ // Contacts survive only on this solid side; {0,1} is solid-top, pass-through below.+ // World/physics coordinates by default, body coordinates when localSpace is true.normal: Vec2;+ /** Rotate the normal with the physics body, including its parent's world rotation. */+ localSpace?: boolean;enabled: boolean;}@@ -251,6 +252,7 @@ export interface OneWayPlatform2DData {// shapes and feeds the normal to the one-way pre-solve callback.export const OneWayPlatform2D = defineComponent<OneWayPlatform2DData>('OneWayPlatform2D', {normal: { x: 0, y: 1 },+ localSpace: false,enabled: true,});diff --git a/sdk/src/physics/PhysicsModuleLoader.ts b/sdk/src/physics/PhysicsModuleLoader.tsindex b6c57205f..3e59a58ad 100644--- a/sdk/src/physics/PhysicsModuleLoader.ts+++ b/sdk/src/physics/PhysicsModuleLoader.ts@@ -98,6 +98,7 @@ export interface PhysicsWasmModule {fixedRotation: number, bullet: number): void;_physics_setOneWayPlatform(entityId: number, nx: number, ny: number, enable: number): void;+ _physics_setOneWayPlatformLocal(entityId: number, nx: number, ny: number, enable: number): void;_physics_createRevoluteJoint(entityIdA: number, entityIdB: number,anchorAx: number, anchorAy: number, anchorBx: number, anchorBy: number,diff --git a/sdk/src/physics/PhysicsSystem.ts b/sdk/src/physics/PhysicsSystem.tsindex 6055a3d9f..fa0fd79ba 100644--- a/sdk/src/physics/PhysicsSystem.ts+++ b/sdk/src/physics/PhysicsSystem.ts@@ -339,7 +339,11 @@ function syncOneWayPlatforms(for (const entity of world.getEntitiesWithComponents([OneWayPlatform2D, RigidBody2D])) {if (!trackedEntities.has(entity)) continue;const ow = world.get(entity, OneWayPlatform2D) as OneWayPlatform2DData;- module._physics_setOneWayPlatform(entity, ow.normal.x, ow.normal.y, ow.enabled ? 1 : 0);+ if (ow.localSpace) {+ module._physics_setOneWayPlatformLocal(entity, ow.normal.x, ow.normal.y, ow.enabled ? 1 : 0);+ } else {+ module._physics_setOneWayPlatform(entity, ow.normal.x, ow.normal.y, ow.enabled ? 1 : 0);+ }trackedOneWay.add(entity);seen.add(entity);}diff --git a/sdk/src/tilemap/tileGeometry.ts b/sdk/src/tilemap/tileGeometry.tsindex 80ae19ddc..92cbc2476 100644--- a/sdk/src/tilemap/tileGeometry.ts+++ b/sdk/src/tilemap/tileGeometry.ts@@ -5,10 +5,10 @@* @brief Orientation-aware tile-cell geometry — the single TS mirror of the C++* placement math in TilemapRenderPlugin / TilemapSystem.*- * The renderer always draws a tile as an axis-aligned tileWidth×tileHeight quad;+ * The renderer draws each tile as a layer-local axis-aligned tileWidth×tileHeight quad;* only its CENTER moves per orientation (orthogonal / isometric / staggered /* hexagonal). {@link tileCellCenter} reproduces that center (layer-local, y-up —- * the caller adds the layer's world origin), so the editor brush ghost lands+ * the caller applies the layer's world Z rotation and origin), so the editor brush ghost lands* exactly where the runtime will draw the tile.** The CELL itself is a rect (orthogonal), a diamond (isometric / staggered), or adiff --git a/sdk/src/tilemap/tileQuery.ts b/sdk/src/tilemap/tileQuery.tsindex 7ba844ef7..ac5baceb7 100644--- a/sdk/src/tilemap/tileQuery.ts+++ b/sdk/src/tilemap/tileQuery.ts@@ -109,7 +109,7 @@ export function isTileSolid(layer: Entity | number, x: number, y: number): boole/*** {@link tileCollisionAt} addressed in WORLD pixels — converts through the* layer's own grid (`worldToTile`, honoring the layer origin at (originX,- * originY), typically its Transform position).+ * originY), typically its Transform position, and optional world Z rotation in radians).*/export function tileCollisionAtWorld(layer: Entity | number,@@ -117,7 +117,8 @@ export function tileCollisionAtWorld(worldY: number,originX = 0,originY = 0,+ rotation = 0,): ResolvedTileCollision | null {- const t = TilemapAPI.worldToTile(layer as Entity, worldX, worldY, originX, originY);+ const t = TilemapAPI.worldToTile(layer as Entity, worldX, worldY, originX, originY, rotation);return tileCollisionAt(layer, Math.floor(t.x), Math.floor(t.y));}diff --git a/sdk/src/tilemap/tiledLoader.ts b/sdk/src/tilemap/tiledLoader.tsindex 092aacf0f..0aef77a53 100644--- a/sdk/src/tilemap/tiledLoader.ts+++ b/sdk/src/tilemap/tiledLoader.ts@@ -1054,7 +1054,7 @@ export function generateChunkPolygonCollision(return entities;}-/** A one-way solid-side normal (world y-up; {0,1} = solid-top), reoriented by cell flips+/** A one-way solid-side normal (layer y-up; {0,1} = solid-top), reoriented by cell flips* so a flipped platform's solid side follows the render. Shared with the editor overlay,* so a flipped one-way tile's arrow matches the side a body actually lands on at Play. */export function oneWayNormalWorld(nx: number, ny: number, fH: boolean, fV: boolean, fD: boolean): { x: number; y: number } {@@ -1122,6 +1122,7 @@ function spawnTileShape(if (rc.oneWay) {world.insert(entity, OneWayPlatform2D, {normal: oneWayNormalWorld(rc.oneWay.nx, rc.oneWay.ny, f.flipH, f.flipV, f.flipD),+ localSpace: true,});}return entity;diff --git a/sdk/src/tilemap/tilemapAPI.ts b/sdk/src/tilemap/tilemapAPI.tsindex afac66541..f0bd60200 100644--- a/sdk/src/tilemap/tilemapAPI.ts+++ b/sdk/src/tilemap/tilemapAPI.ts@@ -292,20 +292,27 @@ function tilemapAPI(moduleOf: () => TilemapModule | null) {moduleOf()?.tilemap_setHexParams(entity, sideLength, staggerAxisX ? 1 : 0, staggerIndexEven ? 1 : 0);},+ /** Grid anchor in world pixels; rotation is the layer's world Z angle in radians. */tileToWorld(entity: number, tx: number, ty: number,- originX: number, originY: number): { x: number; y: number } {+ originX: number, originY: number, rotation = 0): { x: number; y: number } {if (!moduleOf()) return { x: 0, y: 0 };const m0 = moduleOf()!;- const ptr = m0.tilemap_tileToWorld(entity, tx, ty, originX, originY);+ const ptr = m0.tilemap_tileToWorld(entity, tx, ty, rotation === 0 ? originX : 0, rotation === 0 ? originY : 0);const floats = new Float32Array(m0.HEAPU8.buffer, ptr, 2);- return { x: floats[0], y: floats[1] };+ if (rotation === 0) return { x: floats[0], y: floats[1] };+ const c = Math.cos(rotation), s = Math.sin(rotation);+ return { x: originX + c * floats[0] - s * floats[1], y: originY + s * floats[0] + c * floats[1] };},+ /** Invert the layer origin and world Z rotation before reading its grid. */worldToTile(entity: number, wx: number, wy: number,- originX: number, originY: number): { x: number; y: number } {+ originX: number, originY: number, rotation = 0): { x: number; y: number } {if (!moduleOf()) return { x: 0, y: 0 };const m0 = moduleOf()!;- const ptr = m0.tilemap_worldToTile(entity, wx, wy, originX, originY);+ const dx = wx - originX, dy = wy - originY, c = Math.cos(rotation), s = Math.sin(rotation);+ const ptr = rotation === 0+ ? m0.tilemap_worldToTile(entity, wx, wy, originX, originY)+ : m0.tilemap_worldToTile(entity, dx * c + dy * s, -dx * s + dy * c, 0, 0);const floats = new Float32Array(m0.HEAPU8.buffer, ptr, 2);return { x: floats[0], y: floats[1] };},diff --git a/sdk/src/tilemap/tilesetAsset.ts b/sdk/src/tilemap/tilesetAsset.tsindex 998bd49d1..98bdc1100 100644--- a/sdk/src/tilemap/tilesetAsset.ts+++ b/sdk/src/tilemap/tilesetAsset.ts@@ -29,11 +29,9 @@ export type TileCollisionShape =| { type: 'circle'; cx: number; cy: number; r: number };/**- * A tile's collision = a {@link TileCollisionShape} plus optional cross-cutting modifiers.- * Every modifier is optional and omitted when at its engine default, so existing- * `.estileset` files (plain `{type:'box'}` / `{type:'polygon'}`) round-trip byte-for-byte.- * `oneWay` is the solid-side normal in physics/world convention (y-up; `{0,1}` = solid-top,- * jump-through floor); flip flags reorient it at placement. Absence of `collision` = none.+ * Modifiers at their defaults are omitted, preserving existing `.estileset` round-trips.+ * `oneWay` uses the layer's y-up frame (`{0,1}` = solid-top, pass-through below);+ * cell flips and layer rotation reorient it. Absent `collision` means no collider.*/export type TilesetCollision = TileCollisionShape & {/** One-way (jump-through) platform: contacts from behind this normal pass through. */diff --git a/sdk/src/tilemap/tilesetResolve.ts b/sdk/src/tilemap/tilesetResolve.tsindex 4ece28e1a..101412d68 100644--- a/sdk/src/tilemap/tilesetResolve.ts+++ b/sdk/src/tilemap/tilesetResolve.ts@@ -51,7 +51,7 @@ export interface ResolvedTileCollision {| { type: 'box' }| { type: 'polygon'; points: [number, number][] }| { type: 'circle'; cx: number; cy: number; r: number };- /** Solid-side normal (world y-up; {0,1} = solid-top) of a one-way platform, if any. */+ /** Solid-side normal in the layer's y-up frame; {0,1} = solid-top before layer rotation. */oneWay?: { nx: number; ny: number };sensor?: boolean;density?: number;diff --git a/sdk/tests/physics-features-smoke.mjs b/sdk/tests/physics-features-smoke.mjsindex 9b703d472..868c1accc 100644--- a/sdk/tests/physics-features-smoke.mjs+++ b/sdk/tests/physics-features-smoke.mjs@@ -60,6 +60,38 @@ check('above body does not sink through', aPos && aPos.y > 0.2, `y=${aPos?.y.toFcheck('below body passes up through', belowMaxY > 1.5, `maxY=${belowMaxY.toFixed(3)} (want >1.5)`);check('below body lands on top after passing', bPos && Math.abs(bPos.y - 0.4) < 0.2, `y=${bPos?.y.toFixed(3)} (want ≈0.4)`);+// The normal is bound before rotating the body, without another normal write.+for (const angle of [Math.PI / 2, -Math.PI / 2, Math.PI, 0.37]) {+ for (const approach of [1, -1]) {+ m._physics_shutdown();+ m._physics_init(0, 0, 1 / 60, 4, 30, 10, 3);+ const nx = -Math.sin(angle), ny = Math.cos(angle);+ body(1, STATIC, 0, 0); box(1, 2, 0.2);+ m._physics_setOneWayPlatformLocal(1, 0, 1, 1);+ m._physics_setBodyTransform(1, 0, 0, angle);+ body(2, DYNAMIC, nx * 3 * approach, ny * 3 * approach);+ box(2, 0.2, 0.2);+ m._physics_setLinearVelocity(2, -nx * 3 * approach, -ny * 3 * approach);+ step(120);+ const p = bodyPos(2);+ const distance = p ? p.x * nx + p.y * ny : NaN;+ check(`rotated local one-way ${angle.toFixed(2)} side ${approach}`,+ approach === 1 ? distance > 0.2 && distance < 0.7 : distance > 2,+ `solid-side distance=${distance.toFixed(3)}`);+ }+}+// The existing setter still binds a world-space normal on a rotated body.+m._physics_shutdown();+m._physics_init(0, 0, 1 / 60, 4, 30, 10, 3);+body(1, STATIC, 0, 0); box(1, 2, 0.2);+m._physics_setOneWayPlatformLocal(1, 0, 1, 1);+m._physics_setOneWayPlatform(1, 0, 1, 1);+m._physics_setBodyTransform(1, 0, 0, Math.PI / 2);+body(2, DYNAMIC, -3, 0); box(2, 0.2, 0.2);+m._physics_setLinearVelocity(2, 3, 0);+step(120);+check('world normal replaces local mode and keeps world orientation', bodyPos(2)?.x > 2);+// ── 2) Motor joint (conveyor / driven motion) ───────────────────────────────m._physics_shutdown();m._physics_init(0, 0, 1 / 60, 4, 30, 10, 3); // no gravity isolates the motordiff --git a/sdk/tests/physics-features.test.ts b/sdk/tests/physics-features.test.tsindex 734bb9732..6432c38f2 100644--- a/sdk/tests/physics-features.test.ts+++ b/sdk/tests/physics-features.test.ts@@ -27,6 +27,7 @@ describe('OneWayPlatform2D component', () => {const d = OneWayPlatform2D._default as OneWayPlatform2DData;expect(d.normal).toEqual({ x: 0, y: 1 });expect(d.enabled).toBe(true);+ expect(d.localSpace).toBe(false);});});diff --git a/sdk/tests/physics-module-contract.test.ts b/sdk/tests/physics-module-contract.test.tsindex f0c98e13b..a18198c4a 100644--- a/sdk/tests/physics-module-contract.test.ts+++ b/sdk/tests/physics-module-contract.test.ts@@ -35,6 +35,7 @@ const EVERY_EXPORT = ['_physics_capturePoses', '_physics_getInterpolatedCount', '_physics_getInterpolatedTransforms','_physics_collectEvents', '_physics_getDynamicBodyCount', '_physics_getDynamicBodyTransforms','_physics_setBodyTransform',+ '_physics_setOneWayPlatformLocal',];const moduleWith = (names: readonly string[]): Record<string, unknown> =>@@ -44,6 +45,15 @@ const moduleWith = (names: readonly string[]): Record<string, unknown> =>const settle = () => new Promise((r) => { setTimeout(r, 0); });describe('the physics plugin against a stale wasm', () => {+ it('refuses a module that cannot keep generated tile normals in the body frame', async () => {+ const stale = moduleWith(EVERY_EXPORT.filter(n => n !== '_physics_setOneWayPlatformLocal'));+ const app = fakeApp();+ new Physics2DPlugin('', {}, async () => stale as never).build(app);+ await settle();+ expect(app.errors).toHaveLength(1);+ expect(app.errors[0]).toContain('_physics_setOneWayPlatformLocal');+ expect(stale._physics_init).not.toHaveBeenCalled();+ });it('refuses a module missing the frame loop it will call, and names what is missing', async () => {const stale = moduleWith(EVERY_EXPORT.filter((n) => !n.includes('Interpolated') && n !== '_physics_capturePoses'));const app = fakeApp();diff --git a/sdk/tests/physics-static-transform-wasm.test.ts b/sdk/tests/physics-static-transform-wasm.test.tsindex d27d8b668..83bd93aaf 100644--- a/sdk/tests/physics-static-transform-wasm.test.ts+++ b/sdk/tests/physics-static-transform-wasm.test.ts@@ -6,16 +6,61 @@ import { Transform } from '../src/ecs/component';import { Physics2DPlugin } from '../src/physics/Physics2DPlugin';import { Physics2DRuntime } from '../src/physics/Physics2DRuntime';import { Physics2D } from '../src/physics/Physics2D';-import { RigidBody2D, BoxCollider2D, BodyType } from '../src/physics/PhysicsComponents';+import { RigidBody2D, BoxCollider2D, BodyType, OneWayPlatform2D } from '../src/physics/PhysicsComponents';import type { PhysicsWasmModule } from '../src/physics/PhysicsModuleLoader';import type { ESEngineModule } from '../src/wasm';import { HAS_WASM, hasSideModule, loadSideModule, loadWasmModule } from './helpers/loadWasm';+import { generateChunkTileShapes } from '../src/tilemap/tiledLoader';+import { buildCollisionPaletteModel } from '../src/tilemap/collisionPalette';+import { CHUNK_SIZE } from '../src/tilemap/chunkCodec';let engine: ESEngineModule;const apps: App[] = [];afterEach(() => { for (const app of apps.splice(0)) app.quit(); vi.restoreAllMocks(); });describe.skipIf(!HAS_WASM || !hasSideModule('physics'))('static Box2D transform projection', () => {beforeAll(async () => { engine = await loadWasmModule(); });+ it('rotates local one-way normals with a static parent without normal resubmission', async () => {+ const app = App.new(); apps.push(app);+ app.connectCpp(new engine.Registry(), engine, { ownedRegistry: true });+ const module = await loadSideModule<PhysicsWasmModule>('physics');+ app.addPlugin(new Physics2DPlugin('', { gravity: { x: 0, y: 0 } }, async () => module));+ await app.getResource(Physics2DRuntime).initPromise;+ const world = app.world, parent = world.spawn();+ world.insert(parent, Transform);+ const tiles = new Uint16Array(CHUNK_SIZE * CHUNK_SIZE); tiles[0] = 8;+ const [platform] = generateChunkTileShapes(world, [{ x: 0, y: 0, tiles }],+ buildCollisionPaletteModel().tileShapes, 400, 40, 0, 0, 100);+ expect(world.get(platform, OneWayPlatform2D).localSpace).toBe(true);+ world.setParent(platform, parent);+ const local = vi.spyOn(module, '_physics_setOneWayPlatformLocal');+ await app.stepFrames(3, 1 / 60);+ expect(local).toHaveBeenCalledTimes(1);+ world.update(parent, Transform, value => {+ value.rotation = { x: 0, y: 0, z: Math.SQRT1_2, w: Math.SQRT1_2 };+ value.position = { x: -20, y: -200, z: 0 };+ });+ await app.stepFrames(3, 1 / 60);+ expect(local).toHaveBeenCalledTimes(1);+ const actor = world.spawn();+ world.insert(actor, Transform, { position: { x: -300, y: 0, z: 0 } });+ world.insert(actor, RigidBody2D, { bodyType: BodyType.Dynamic });+ world.insert(actor, BoxCollider2D, { halfExtents: { x: .2, y: .2 } });+ await app.stepFrames(3, 1 / 60);+ module._physics_setLinearVelocity(actor, 3, 0);+ const writes = local.mock.calls.length;+ await app.stepFrames(120, 1 / 60);+ const x = world.get(actor, Transform).worldPosition.x;+ expect(x).toBeGreaterThan(-70);+ expect(x).toBeLessThan(-20);+ expect(local).toHaveBeenCalledTimes(writes);+ world.update(platform, BoxCollider2D, value => { value.halfExtents.y = .3; });+ await app.stepFrames(3, 1 / 60);+ expect(local.mock.calls.length).toBeGreaterThan(writes);+ const clear = vi.spyOn(module, '_physics_setOneWayPlatform');+ world.remove(platform, OneWayPlatform2D);+ await app.stepFrames(3, 1 / 60);+ expect(clear).toHaveBeenCalledWith(platform, 0, 0, 0);+ });it.each([false, true])('moves a static body in place without repeated writes (parented=%s)', async parented => {const app = App.new(); apps.push(app);app.connectCpp(new engine.Registry(), engine, { ownedRegistry: true });diff --git a/sdk/tests/tilemap-rotation-wasm.test.ts b/sdk/tests/tilemap-rotation-wasm.test.tsnew file mode 100644index 000000000..4b2c49cfe--- /dev/null+++ b/sdk/tests/tilemap-rotation-wasm.test.ts@@ -0,0 +1,35 @@+// SPDX-License-Identifier: Apache-2.0+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team+import { beforeAll, describe, expect, it } from 'vitest';+import type { ESEngineModule } from '../src/wasm';+import { createTilemapAPI } from '../src/tilemap/tilemapAPI';+import type { EngineApi } from '../src/ecs/bridge/engineApi';+import { tileCellCenter } from '../src/tilemap/tileGeometry';+import { HAS_WASM, loadWasmModule } from './helpers/loadWasm';++describe.skipIf(!HAS_WASM)('rotated tile grid coordinate conversion', () => {+ let core: ESEngineModule;+ beforeAll(async () => { core = await loadWasmModule(); });+ it.each([0, 1, 2, 3])('preserves layout %s anchors and inverse coordinates under world rotation', orientation => {+ core.setActiveContext(null);+ const tiles = createTilemapAPI(core as EngineApi);+ tiles.initInfiniteLayer(10, 16, 24); tiles.setGridType(10, orientation); tiles.setHexParams(10, 6, true, false);+ try {+ for (const rotation of [0, Math.PI / 2, -Math.PI / 2, Math.PI, 0.37]) {+ for (const [x, y] of [[0, 0], [64, 2], [-33, -17]]) {+ const local = tileCellCenter({ orientation, tileWidth: 16, tileHeight: 24,+ hexSideLength: 6, staggerAxisX: true, staggerIndexEven: false }, x, y);+ const anchor = orientation === 1 ? local : { x: local.x - 8, y: local.y + 12 };+ const expected = { x: 20 + Math.cos(rotation) * anchor.x - Math.sin(rotation) * anchor.y,+ y: 30 + Math.sin(rotation) * anchor.x + Math.cos(rotation) * anchor.y };+ const point = tiles.tileToWorld(10, x, y, 20, 30, rotation);+ expect(point.x).toBeCloseTo(expected.x, 3); expect(point.y).toBeCloseTo(expected.y, 3);+ const center = { x: 20 + Math.cos(rotation) * local.x - Math.sin(rotation) * local.y,+ y: 30 + Math.sin(rotation) * local.x + Math.cos(rotation) * local.y };+ expect(tiles.worldToTile(10, center.x, center.y, 20, 30, rotation))+ .toEqual(tiles.worldToTile(10, 20 + local.x, 30 + local.y, 20, 30));+ }+ }+ } finally { core.tilemap_destroyLayer!(10); }+ });+});diff --git a/src/esengine/bindings/modules/physics/PhysicsBindings.hpp b/src/esengine/bindings/modules/physics/PhysicsBindings.hppindex 63b6da1fe..3fe975bb7 100644--- a/src/esengine/bindings/modules/physics/PhysicsBindings.hpp+++ b/src/esengine/bindings/modules/physics/PhysicsBindings.hpp@@ -41,6 +41,7 @@ void physics_init(float gx, float gy, float timestep, int substeps, float contacvoid physics_setWorldConfig(int enableSleep, int enableContinuous, float restitutionThreshold, float maxLinearSpeed);void physics_shutdown();void physics_setOneWayPlatform(uint32_t entityId, float nx, float ny, int enable);+void physics_setOneWayPlatformLocal(uint32_t entityId, float nx, float ny, int enable);void physics_createBody(uint32_t entityId, int bodyType, float x, float y, float angle, float gravityScale, float linearDamping, float angularDamping, int fixedRotation, int bullet);void physics_destroyBody(uint32_t entityId);int physics_hasBody(uint32_t entityId);diff --git a/src/esengine/bindings/modules/physics/PhysicsContext.hpp b/src/esengine/bindings/modules/physics/PhysicsContext.hppindex e627bbeec..be40b0e02 100644--- a/src/esengine/bindings/modules/physics/PhysicsContext.hpp+++ b/src/esengine/bindings/modules/physics/PhysicsContext.hpp@@ -42,10 +42,14 @@ struct PhysicsContext {};std::unordered_map<uint32_t, PausedMotion> pausedMotion;- // One-way (one-sided) platforms: entity -> solid-side normal in physics space- // (normalized). Read by the pre-solve callback to cancel contacts that approach+ // One-way platforms: entity -> normalized solid-side normal and coordinate frame.+ // Read by the pre-solve callback to cancel contacts that approach// from the pass-through side. Empty map = zero pre-solve overhead.- std::unordered_map<uint32_t, b2Vec2> oneWayNormals;+ struct OneWayNormal {+ b2Vec2 normal;+ bool localSpace = false;+ };+ std::unordered_map<uint32_t, OneWayNormal> oneWayNormals;// Interactive drag: a single kinematic "mouse body" + motor joint pulling one// target body toward the cursor (Box2D v3 has no dedicated mouse joint).diff --git a/src/esengine/bindings/modules/physics/PhysicsModuleEntry.cpp b/src/esengine/bindings/modules/physics/PhysicsModuleEntry.cppindex 5fcd11893..5771d4e7a 100644--- a/src/esengine/bindings/modules/physics/PhysicsModuleEntry.cpp+++ b/src/esengine/bindings/modules/physics/PhysicsModuleEntry.cpp@@ -35,13 +35,19 @@ static bool preSolveOneWayPlatform(b2ShapeId shapeIdA, b2ShapeId shapeIdB,auto itA = g_ctx.oneWayNormals.find(entityFromShape(shapeIdA));if (itA != g_ctx.oneWayNormals.end()) {// Platform = A; direction toward the other shape (B) is +normal.- float d = normal.x * itA->second.x + normal.y * itA->second.y;+ const b2Vec2 solid = itA->second.localSpace+ ? b2RotateVector(b2Body_GetRotation(b2Shape_GetBody(shapeIdA)), itA->second.normal)+ : itA->second.normal;+ float d = normal.x * solid.x + normal.y * solid.y;if (d <= ONE_WAY_ALIGN_THRESHOLD) return false;}auto itB = g_ctx.oneWayNormals.find(entityFromShape(shapeIdB));if (itB != g_ctx.oneWayNormals.end()) {// Platform = B; direction toward the other shape (A) is -normal.- float d = normal.x * itB->second.x + normal.y * itB->second.y;+ const b2Vec2 solid = itB->second.localSpace+ ? b2RotateVector(b2Body_GetRotation(b2Shape_GetBody(shapeIdB)), itB->second.normal)+ : itB->second.normal;+ float d = normal.x * solid.x + normal.y * solid.y;if (d >= -ONE_WAY_ALIGN_THRESHOLD) return false;}return true;@@ -104,9 +110,10 @@ EMSCRIPTEN_KEEPALIVEvoid physics_setOneWayPlatform(uint32_t entityId, float nx, float ny, int enable) {if (enable != 0) {float len = sqrtf(nx * nx + ny * ny);- g_ctx.oneWayNormals[entityId] = (len > 0.0f)+ const b2Vec2 normal = (len > 0.0f)? b2Vec2{nx / len, ny / len}: b2Vec2{0.0f, 1.0f};+ g_ctx.oneWayNormals[entityId] = {normal, false};} else {g_ctx.oneWayNormals.erase(entityId);}@@ -121,6 +128,12 @@ void physics_setOneWayPlatform(uint32_t entityId, float nx, float ny, int enable}}+EMSCRIPTEN_KEEPALIVE+void physics_setOneWayPlatformLocal(uint32_t entityId, float nx, float ny, int enable) {+ physics_setOneWayPlatform(entityId, nx, ny, enable);+ if (enable != 0) g_ctx.oneWayNormals.at(entityId).localSpace = true;+}+// Body ManagementEMSCRIPTEN_KEEPALIVEdiff --git a/src/esengine/renderer/plugins/TilemapRenderPlugin.cpp b/src/esengine/renderer/plugins/TilemapRenderPlugin.cppindex fa3fcf2e1..415c5fc6e 100644--- a/src/esengine/renderer/plugins/TilemapRenderPlugin.cpp+++ b/src/esengine/renderer/plugins/TilemapRenderPlugin.cpp@@ -253,14 +253,18 @@ void TilemapRenderPlugin::collect(RenderCollectContext& collect_ctx) {}if (!anySlotValid) continue;- f32 originX = 0, originY = 0;+ f32 originX = 0, originY = 0, angle = 0;Entity transformEntity = (layer.origin_entity != INVALID_ENTITY)? layer.origin_entity : entity;if (auto* transform = registry.tryGet<ecs::Transform>(transformEntity)) {transform->ensureDecomposed(); // lazily derived; see Transform.hpporiginX = transform->worldPosition.x;originY = transform->worldPosition.y;+ const auto& q = transform->worldRotation;+ angle = std::atan2(2.0f * (q.w * q.z + q.x * q.y),+ 1.0f - 2.0f * (q.y * q.y + q.z * q.z));}+ const f32 cosAngle = std::cos(angle), sinAngle = std::sin(angle);glm::vec4 finalColor(tint.r, tint.g, tint.b, tint.a * opacity);u32 packedColor = packColor(finalColor);@@ -285,10 +289,19 @@ void TilemapRenderPlugin::collect(RenderCollectContext& collect_ctx) {// tile whose center is off-screen while its body still overlaps.i32 chunkSize = static_cast<i32>(tilemap::CHUNK_SIZE);i32 cornerTx[4], cornerTy[4];- tilemap_system_->worldToTile(entity, cam.left, cam.top, adjOriginX, adjOriginY, cornerTx[0], cornerTy[0]);- tilemap_system_->worldToTile(entity, cam.right, cam.top, adjOriginX, adjOriginY, cornerTx[1], cornerTy[1]);- tilemap_system_->worldToTile(entity, cam.left, cam.bottom, adjOriginX, adjOriginY, cornerTx[2], cornerTy[2]);- tilemap_system_->worldToTile(entity, cam.right, cam.bottom, adjOriginX, adjOriginY, cornerTx[3], cornerTy[3]);+ const auto cornerToTile = [&](f32 x, f32 y, i32& tx, i32& ty) {+ if (angle == 0) {+ tilemap_system_->worldToTile(entity, x, y, adjOriginX, adjOriginY, tx, ty);+ } else {+ const f32 dx = x - originX - parallaxOffsetX, dy = y - originY - parallaxOffsetY;+ tilemap_system_->worldToTile(entity, dx * cosAngle + dy * sinAngle,+ -dx * sinAngle + dy * cosAngle, originOffset.x, originOffset.y, tx, ty);+ }+ };+ cornerToTile(cam.left, cam.top, cornerTx[0], cornerTy[0]);+ cornerToTile(cam.right, cam.top, cornerTx[1], cornerTy[1]);+ cornerToTile(cam.left, cam.bottom, cornerTx[2], cornerTy[2]);+ cornerToTile(cam.right, cam.bottom, cornerTx[3], cornerTy[3]);i32 minTx = cornerTx[0], maxTx = cornerTx[0];i32 minTy = cornerTy[0], maxTy = cornerTy[0];for (int i = 1; i < 4; ++i) {@@ -362,8 +375,12 @@ void TilemapRenderPlugin::collect(RenderCollectContext& collect_ctx) {if (mesh.indices.empty()) continue;u32 baseVertex = static_cast<u32>(slotVertices[si].size());for (const BatchVertex& v : mesh.vertices) {+ const f32 lx = v.position.x + originOffset.x, ly = v.position.y + originOffset.y;slotVertices[si].push_back({- { v.position.x + adjOriginX, v.position.y + adjOriginY, depth },+ angle == 0+ ? glm::vec3{v.position.x + adjOriginX, v.position.y + adjOriginY, depth}+ : glm::vec3{originX + parallaxOffsetX + lx * cosAngle - ly * sinAngle,+ originY + parallaxOffsetY + lx * sinAngle + ly * cosAngle, depth},packedColor, v.texCoord });}for (u32 idx : mesh.indices) {diff --git a/src/esengine/renderer/plugins/TilemapRenderPlugin.hpp b/src/esengine/renderer/plugins/TilemapRenderPlugin.hppindex 11fef5140..aa1cf80f7 100644--- a/src/esengine/renderer/plugins/TilemapRenderPlugin.hpp+++ b/src/esengine/renderer/plugins/TilemapRenderPlugin.hpp@@ -25,11 +25,8 @@ public:const char* collectScope() const override { return "render.collect.tilemap"; }private:- // Per-tileset-slot geometry for one chunk. A multi-tileset layer splits a- // chunk's tiles across slots (one texture each) so each becomes its own batch.- // Vertices are layer-local and untinted: origin, parallax offset and tint are- // applied when merging into the frame's batch, so moving, tinting or- // parallax-scrolling a layer never invalidates the cache.+ // One batch per tileset slot. Vertices stay layer-local and untinted;+ // rotation, origin, parallax and tint apply at frame merge without cache rebuilds.struct SlotMesh {std::vector<BatchVertex> vertices;std::vector<u32> indices;diff --git a/tests/renderer/test_batch_builder.cpp b/tests/renderer/test_batch_builder.cppindex 9e10951d8..ab2598803 100644--- a/tests/renderer/test_batch_builder.cpp+++ b/tests/renderer/test_batch_builder.cpp@@ -21,6 +21,8 @@#include "esengine/renderer/plugins/UIElementPlugin.hpp"#include "esengine/renderer/plugins/TextPlugin.hpp"#include "esengine/renderer/plugins/SpritePlugin.hpp"+#include "esengine/renderer/plugins/TilemapRenderPlugin.hpp"+#include "esengine/ecs/components/TilemapLayer.hpp"#include "esengine/ecs/components/Sprite.hpp"#include "esengine/ecs/components/BitmapText.hpp"#include "esengine/ecs/components/UINode.hpp"@@ -146,6 +148,62 @@ TEST_CASE("pool reports each stream's vertex stride (single source for baseVerteCHECK(h.pool.vertexStride(LayoutId::ParticleInstance) == sizeof(TestParticleInstance));}+TEST_CASE("tilemaps: rotation places cached quads and inverts distant chunk culling") {+ for (auto grid : {tilemap::GridType::Orthogonal, tilemap::GridType::Isometric,+ tilemap::GridType::StaggeredIsometric, tilemap::GridType::Hexagonal}) {+ for (bool infinite : {false, true}) for (bool lazy : {false, true}) {+ Harness h;+ RenderContext context(h.device);+ resource::ResourceManager resources;+ resources.init(h.device);+ const u8 pixels[16 * 24 * 4] = {};+ const auto texture = resources.createTexture(resource::ResourceContent::Retained,+ 16, 24, pixels, TextureFormat::RGBA8);+ ecs::Registry registry;+ const auto entity = registry.create();+ auto& transform = registry.emplace<ecs::Transform>(entity);+ auto& component = registry.emplace<ecs::TilemapLayer>(entity);+ component.tileset = texture; component.tilesetColumns = 1;+ component.cellSize = {16, 24}; component.originOffset = {3, -2};+ tilemap::TilemapSystem system;+ if (infinite) system.initInfiniteLayer(entity, 16, 24);+ else system.initLayer(entity, 96, 16, 16, 24);+ system.setGridType(entity, grid); system.setHexParams(entity, 6, true, false);+ const i32 tx = infinite ? -33 : 64, ty = 2;+ system.setTile(entity, tx, ty, 1);+ f32 lx = 0, ly = 0;+ system.tileToWorld(entity, tx, ty, 0, 0, lx, ly);+ if (grid != tilemap::GridType::Isometric) { lx += 8; ly -= 12; }+ const glm::vec3 localCenter{lx + 3, ly - 2, 0}, origin{20, 30, 0};+ Frustum frustum;+ RenderFrameContext frameContext{context, resources};+ RenderCollectContext collect{registry, frustum, h.clips, h.pool, h.list, frameContext, {}};+ TilemapRenderPlugin plugin; plugin.setTilemapSystem(&system); plugin.init(frameContext);+ const auto revision = system.getLayerData(entity)->edit_revision;+ for (f32 angle : {0.0f, .37f, glm::half_pi<f32>(), glm::pi<f32>(), -glm::half_pi<f32>()}) {+ const auto rotation = glm::angleAxis(angle, glm::vec3{0, 0, 1});+ transform.worldPosition = origin; transform.worldRotation = rotation;+ transform.cachedMatrix_ = glm::translate(glm::mat4{1}, origin) * glm::mat4_cast(rotation);+ transform.decomposed_ = !lazy;+ const auto center = origin + rotation * localCenter;+ const auto projection = glm::ortho(center.x - 4, center.x + 4, center.y - 4, center.y + 4);+ frustum.extractFromMatrix(projection); collect.camera = computeCameraView(projection);+ h.pool.beginFrame(); h.list.clear(); plugin.collect(collect);+ REQUIRE(h.pool.vertexBytesUsed(LayoutId::Batch) == 4 * sizeof(BatchVertex));+ const auto* vertices = reinterpret_cast<const BatchVertex*>(h.pool.vertexData(LayoutId::Batch));+ const glm::vec3 offsets[] = {{-8, -12, 0}, {8, -12, 0}, {8, 12, 0}, {-8, 12, 0}};+ for (u32 i = 0; i < 4; ++i) {+ const auto expected = origin + rotation * (localCenter + offsets[i]);+ CHECK(std::abs(vertices[i].position.x - expected.x) < .002f);+ CHECK(std::abs(vertices[i].position.y - expected.y) < .002f);+ }+ CHECK(system.getLayerData(entity)->edit_revision == revision);+ }+ resources.shutdown();+ }+ }+}+TEST_CASE("appendQuad: Batch command with baseVertex-offset indices and one texture slot") {Harness h;BatchVertex quad[4] = {diff --git a/tools/releaseNotes.mjs b/tools/releaseNotes.mjsindex 258b82c08..8c9e11071 100644--- a/tools/releaseNotes.mjs+++ b/tools/releaseNotes.mjs@@ -28,6 +28,10 @@ export const NOTES_FLOOR = 'v0.65.0';* the reader recognises anyway.*/export const NOTED = {+ 'fix(tilemap): align rotated layers and collision normals':+ { note: 'Rotated tile layers share one frame for drawing, picking and collision previews.' },+ 'fix(editor): align rotated tile tools and collision previews':+ { note: 'Rotated tile layers share one frame for drawing, picking and collision previews.' },'chore(release): classify 0.88.0 feature coverage':{ internal: 'Registers the new release features in the certification census and records the missing packaged-pixel coverage for volume color overrides without claiming acceptance.' },'chore(release): prepare 0.88.0':