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.

fix(tilemap): align rotated layers and collision normals

yhh91936bb0c6f8
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 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
### Added
diff --git a/desktop b/desktop
index 56085d2c8..ecff22bba 160000
--- a/desktop
+++ b/desktop
@@ -1 +1 @@
-Subproject commit 56085d2c89a614a4c99503794d87654716b70715
+Subproject commit ecff22bbabdda331dd603724b3c37524e0d197da
diff --git a/docs/astro/src/data/components.generated.json b/docs/astro/src/data/components.generated.json
index 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.md
index 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) => void
diff --git a/sdk/etc/index.native.api.md b/sdk/etc/index.native.api.md
index 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) => void
diff --git a/sdk/etc/index.node.api.md b/sdk/etc/index.node.api.md
index 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) => void
diff --git a/sdk/etc/minigame.api.md b/sdk/etc/minigame.api.md
index 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) => void
diff --git a/sdk/etc/physics.api.md b/sdk/etc/physics.api.md
index 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 | undefined
normal: 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) => void
diff --git a/sdk/etc/tilemap.api.md b/sdk/etc/tilemap.api.md
index 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 @experimental
diff --git a/sdk/etc/wechat.api.md b/sdk/etc/wechat.api.md
index 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) => void
diff --git a/sdk/src/physics/Physics2DPlugin.ts b/sdk/src/physics/Physics2DPlugin.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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 a
diff --git a/sdk/src/tilemap/tileQuery.ts b/sdk/src/tilemap/tileQuery.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.mjs
index 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.toF
check('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 motor
diff --git a/sdk/tests/physics-features.test.ts b/sdk/tests/physics-features.test.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.hpp
index 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 contac
void 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.hpp
index 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.cpp
index 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_KEEPALIVE
void 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 Management
EMSCRIPTEN_KEEPALIVE
diff --git a/src/esengine/renderer/plugins/TilemapRenderPlugin.cpp b/src/esengine/renderer/plugins/TilemapRenderPlugin.cpp
index 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.hpp
originX = 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.hpp
index 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.cpp
index 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 baseVerte
CHECK(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.mjs
index 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':