Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

feat: implement tilemap editor v2 with complete editing system

esengine1c858f023def
diff --git a/editor/src/DockLayoutManager.ts b/editor/src/DockLayoutManager.ts
index 6a2f7a0a6..19f138bee 100644
--- a/editor/src/DockLayoutManager.ts
+++ b/editor/src/DockLayoutManager.ts
@@ -33,6 +33,7 @@ export class DockLayoutManager {
private lastActivePanelId_: string | null = null;
private detachContext_: DetachContext | null = null;
private panelClosedUnlisten_: (() => void) | null = null;
+ private pinnedPanels_ = new Set<string>();
constructor(panelManager: PanelManager, store: EditorStore) {
this.panelManager_ = panelManager;
@@ -190,7 +191,20 @@ export class DockLayoutManager {
this.addPanelToRegion_(desc, areaId);
}
+ isPanelPinned(panelId: string): boolean {
+ return this.pinnedPanels_.has(panelId);
+ }
+
+ setPanelPinned(panelId: string, pinned: boolean): void {
+ if (pinned) {
+ this.pinnedPanels_.add(panelId);
+ } else {
+ this.pinnedPanels_.delete(panelId);
+ }
+ }
+
resetLayout(): void {
+ this.pinnedPanels_.clear();
this.dock_?.resetLayout();
}
diff --git a/editor/src/Editor.ts b/editor/src/Editor.ts
index cd3306ee2..dc50367e7 100644
--- a/editor/src/Editor.ts
+++ b/editor/src/Editor.ts
@@ -280,6 +280,7 @@ export class Editor {
this.dockLayout_.initialize(dockContainer);
this.navigationService_.setDockLayout(this.dockLayout_);
+ this.navigationService_.initContextPanels(this.store_);
this.extensionService_.setDockLayout(this.dockLayout_);
diff --git a/editor/src/commands/TilePaintCommand.ts b/editor/src/commands/TilePaintCommand.ts
index e4626ab18..9787128df 100644
--- a/editor/src/commands/TilePaintCommand.ts
+++ b/editor/src/commands/TilePaintCommand.ts
@@ -1,9 +1,11 @@
import type { Entity } from 'esengine';
import type { SceneData, EntityData } from '../types/SceneTypes';
import { BaseCommand, CommandRegistry, type ChangeEmitter, type SerializedCommand } from './Command';
+import { CHUNK_SIZE, tileToChunk } from '../gizmos/TileChunkUtils';
export interface TileChange {
- index: number;
+ x: number;
+ y: number;
oldTile: number;
newTile: number;
}
@@ -71,11 +73,45 @@ export class TilePaintCommand extends BaseCommand {
const component = entityData.components.find(c => c.type === 'TilemapLayer');
if (!component) return;
- const tiles = component.data.tiles as number[];
+ const data = component.data as Record<string, unknown>;
+ const infinite = data.infinite as boolean ?? false;
+
+ if (infinite) {
+ this.applyChunkTiles_(data, forward);
+ } else {
+ this.applyFlatTiles_(data, forward);
+ }
+ }
+
+ private applyFlatTiles_(data: Record<string, unknown>, forward: boolean): void {
+ const tiles = data.tiles as number[];
if (!tiles) return;
+ const width = data.width as number ?? 0;
+
+ for (const change of this.changes_) {
+ const index = change.y * width + change.x;
+ tiles[index] = forward ? change.newTile : change.oldTile;
+ }
+ }
+
+ private applyChunkTiles_(data: Record<string, unknown>, forward: boolean): void {
+ let chunks = data.chunks as Record<string, number[]>;
+ if (!chunks) {
+ chunks = {};
+ data.chunks = chunks;
+ }
for (const change of this.changes_) {
- tiles[change.index] = forward ? change.newTile : change.oldTile;
+ const { cx, cy, lx, ly } = tileToChunk(change.x, change.y);
+ const key = `${cx},${cy}`;
+
+ let chunk = chunks[key];
+ if (!chunk) {
+ chunk = new Array(CHUNK_SIZE * CHUNK_SIZE).fill(0);
+ chunks[key] = chunk;
+ }
+
+ chunk[ly * CHUNK_SIZE + lx] = forward ? change.newTile : change.oldTile;
}
}
}
diff --git a/editor/src/gizmos/GizmoManager.ts b/editor/src/gizmos/GizmoManager.ts
index 6655e7fd1..40d5c7680 100644
--- a/editor/src/gizmos/GizmoManager.ts
+++ b/editor/src/gizmos/GizmoManager.ts
@@ -43,7 +43,7 @@ export class GizmoManager {
gizmo.draw(this.context_);
}
- onMouseDown(worldX: number, worldY: number): boolean {
+ onMouseDown(worldX: number, worldY: number, event?: MouseEvent): boolean {
const gizmo = this.getActive();
if (!gizmo || !this.context_) return false;
@@ -57,7 +57,7 @@ export class GizmoManager {
startWorldY: worldY,
};
- gizmo.onDragStart?.(worldX, worldY, result.data, this.context_);
+ gizmo.onDragStart?.(worldX, worldY, result.data, this.context_, event);
return true;
}
@@ -95,6 +95,12 @@ export class GizmoManager {
return gizmo.getCursor(this.dragState_?.data ?? this.hoveredData_);
}
+ onKeyDown(key: string): boolean {
+ const gizmo = this.getActive();
+ if (!gizmo?.onKeyDown || !this.context_) return false;
+ return gizmo.onKeyDown(key, this.context_);
+ }
+
resetHover(): void {
this.hoveredData_ = null;
}
diff --git a/editor/src/gizmos/GizmoRegistry.ts b/editor/src/gizmos/GizmoRegistry.ts
index 9c800a4fa..aba95d18a 100644
--- a/editor/src/gizmos/GizmoRegistry.ts
+++ b/editor/src/gizmos/GizmoRegistry.ts
@@ -24,12 +24,13 @@ export interface GizmoDescriptor {
hitTest(worldX: number, worldY: number, ctx: GizmoContext): { hit: boolean; data?: unknown };
draw(ctx: GizmoContext): void;
- onDragStart?(worldX: number, worldY: number, hitData: unknown, ctx: GizmoContext): void;
+ onDragStart?(worldX: number, worldY: number, hitData: unknown, ctx: GizmoContext, event?: MouseEvent): void;
onDrag?(worldX: number, worldY: number, hitData: unknown, ctx: GizmoContext, event?: MouseEvent): void;
onDragEnd?(worldX: number, worldY: number, hitData: unknown, ctx: GizmoContext): void;
onHover?(worldX: number, worldY: number, hitData: unknown, ctx: GizmoContext): void;
getCursor?(hitData: unknown): string;
isApplicable?(ctx: GizmoContext): boolean;
+ onKeyDown?(key: string, ctx: GizmoContext): boolean;
}
export function registerGizmo(descriptor: GizmoDescriptor): void {
diff --git a/editor/src/gizmos/TileBrushGizmo.ts b/editor/src/gizmos/TileBrushGizmo.ts
index 67e7239f8..0f5b0777b 100644
--- a/editor/src/gizmos/TileBrushGizmo.ts
+++ b/editor/src/gizmos/TileBrushGizmo.ts
@@ -1,6 +1,8 @@
import type { GizmoContext, GizmoDescriptor } from './GizmoRegistry';
import { getTilesetForSource, getTilesetForImage, findParentTilemapSource } from './TilesetLoader';
import { TilePaintCommand, type TileChange } from '../commands/TilePaintCommand';
+import { floodFill } from './TileFill';
+import { readChunkTile, writeChunkTile } from './TileChunkUtils';
import { icons } from '../utils/icons';
interface TileBrushDragState {
@@ -11,8 +13,19 @@ interface TileBrushDragState {
tileHeight: number;
originX: number;
originY: number;
+ infinite: boolean;
tiles: number[];
- changes: Map<number, TileChange>;
+ chunks: Record<string, number[]>;
+ changes: Map<string, TileChange>;
+ rightClickErase: boolean;
+}
+
+interface RectDragState {
+ entityId: number;
+ startTx: number;
+ startTy: number;
+ endTx: number;
+ endTy: number;
}
function findTilemapLayerData(gctx: GizmoContext): {
@@ -50,27 +63,33 @@ function worldToTile(
};
}
+type LayerInfo = {
+ entityId: number;
+ width: number;
+ height: number;
+ tileWidth: number;
+ tileHeight: number;
+ infinite: boolean;
+ tiles: number[];
+ chunks: Record<string, number[]>;
+ originX: number;
+ originY: number;
+};
+
export function createTileBrushGizmo(): GizmoDescriptor {
let hoverTile: { tx: number; ty: number } | null = null;
let dragState: TileBrushDragState | null = null;
+ let rectDrag: RectDragState | null = null;
- function getLayerInfo(gctx: GizmoContext): {
- entityId: number;
- width: number;
- height: number;
- tileWidth: number;
- tileHeight: number;
- tiles: number[];
- originX: number;
- originY: number;
- } | null {
+ function getLayerInfo(gctx: GizmoContext): LayerInfo | null {
const layer = findTilemapLayerData(gctx);
if (!layer) return null;
const d = layer.data;
+ const infinite = d.infinite as boolean ?? false;
const width = d.width as number ?? 0;
const height = d.height as number ?? 0;
- if (width === 0 || height === 0) return null;
+ if (!infinite && (width === 0 || height === 0)) return null;
const worldTransform = gctx.store.getWorldTransform(layer.entityId);
return {
@@ -79,73 +98,139 @@ export function createTileBrushGizmo(): GizmoDescriptor {
height,
tileWidth: d.tileWidth as number ?? 32,
tileHeight: d.tileHeight as number ?? 32,
+ infinite,
tiles: d.tiles as number[] ?? [],
+ chunks: d.chunks as Record<string, number[]> ?? {},
originX: worldTransform.position.x,
originY: worldTransform.position.y,
};
}
- function getTilesetImage(gctx: GizmoContext): {
- image: HTMLImageElement;
- columns: number;
- tileWidth: number;
- tileHeight: number;
- } | null {
- const source = findTilemapSource(gctx);
- if (source) {
- const info = getTilesetForSource(source);
- if (info?.tilesetImage) {
- return {
- image: info.tilesetImage,
- columns: info.tilesetColumns,
- tileWidth: info.tileWidth,
- tileHeight: info.tileHeight,
- };
- }
+ function readTile(state: TileBrushDragState, tx: number, ty: number): number {
+ if (state.infinite) {
+ return readChunkTile(state.chunks, tx, ty);
}
+ return state.tiles[ty * state.mapWidth + tx] ?? 0;
+ }
- const layer = findTilemapLayerData(gctx);
- if (layer) {
- const d = layer.data;
- const textureUuid = d.texture as string ?? '';
- if (textureUuid && typeof textureUuid === 'string') {
- const tw = d.tileWidth as number ?? 32;
- const th = d.tileHeight as number ?? 32;
- const cols = d.tilesetColumns as number ?? 1;
- const info = getTilesetForImage(textureUuid, tw, th, cols);
- if (info?.tilesetImage) {
- return {
- image: info.tilesetImage,
- columns: info.tilesetColumns,
- tileWidth: info.tileWidth,
- tileHeight: info.tileHeight,
- };
- }
- }
+ function writeTile(state: TileBrushDragState, tx: number, ty: number, tileId: number): void {
+ if (state.infinite) {
+ writeChunkTile(state.chunks, tx, ty, tileId);
+ } else {
+ state.tiles[ty * state.mapWidth + tx] = tileId;
}
-
- return null;
}
function paintTile(state: TileBrushDragState, tx: number, ty: number, tileId: number): void {
- if (tx < 0 || tx >= state.mapWidth || ty < 0 || ty >= state.mapHeight) return;
- const expectedLen = state.mapWidth * state.mapHeight;
- if (state.tiles.length < expectedLen) {
- const oldLen = state.tiles.length;
- state.tiles.length = expectedLen;
- state.tiles.fill(0, oldLen, expectedLen);
+ if (!state.infinite) {
+ if (tx < 0 || tx >= state.mapWidth || ty < 0 || ty >= state.mapHeight) return;
+ const expectedLen = state.mapWidth * state.mapHeight;
+ if (state.tiles.length < expectedLen) {
+ const oldLen = state.tiles.length;
+ state.tiles.length = expectedLen;
+ state.tiles.fill(0, oldLen, expectedLen);
+ }
}
- const index = ty * state.mapWidth + tx;
- if (!state.changes.has(index)) {
- state.changes.set(index, {
- index,
- oldTile: state.tiles[index] ?? 0,
+ const changeKey = `${tx},${ty}`;
+ if (!state.changes.has(changeKey)) {
+ state.changes.set(changeKey, {
+ x: tx,
+ y: ty,
+ oldTile: readTile(state, tx, ty),
newTile: tileId,
});
} else {
- state.changes.get(index)!.newTile = tileId;
+ state.changes.get(changeKey)!.newTile = tileId;
+ }
+ writeTile(state, tx, ty, tileId);
+ }
+
+ function paintStamp(state: TileBrushDragState, tx: number, ty: number, stamp: Readonly<{ width: number; height: number; tiles: number[] }>): void {
+ for (let sy = 0; sy < stamp.height; sy++) {
+ for (let sx = 0; sx < stamp.width; sx++) {
+ const tileId = stamp.tiles[sy * stamp.width + sx] ?? 0;
+ if (tileId > 0) {
+ paintTile(state, tx + sx, ty + sy, tileId);
+ }
+ }
+ }
+ }
+
+ function createDragState(info: LayerInfo, rightClickErase: boolean): TileBrushDragState {
+ return {
+ entityId: info.entityId,
+ mapWidth: info.width,
+ mapHeight: info.height,
+ tileWidth: info.tileWidth,
+ tileHeight: info.tileHeight,
+ originX: info.originX,
+ originY: info.originY,
+ infinite: info.infinite,
+ tiles: info.tiles,
+ chunks: info.chunks,
+ changes: new Map(),
+ rightClickErase,
+ };
+ }
+
+ function commitChanges(state: TileBrushDragState, gctx: GizmoContext): void {
+ if (state.changes.size === 0) return;
+ const changes = Array.from(state.changes.values());
+ const store = gctx.store;
+ const cmd = new TilePaintCommand(
+ store.scene,
+ store.entityMap_,
+ state.entityId,
+ changes,
+ );
+ store.executeCommand(cmd);
+ }
+
+ function readTileFromInfo(info: LayerInfo, tx: number, ty: number): number {
+ if (info.infinite) {
+ return readChunkTile(info.chunks, tx, ty);
}
- state.tiles[index] = tileId;
+ if (tx < 0 || tx >= info.width || ty < 0 || ty >= info.height) return 0;
+ return info.tiles[ty * info.width + tx] ?? 0;
+ }
+
+ function doBucketFill(gctx: GizmoContext, tx: number, ty: number): void {
+ const info = getLayerInfo(gctx);
+ if (!info) return;
+
+ const fillTileId = gctx.store.tileBrushStamp.tiles[0] ?? 1;
+ const result = floodFill({
+ infinite: info.infinite,
+ width: info.width,
+ height: info.height,
+ tiles: info.tiles,
+ chunks: info.chunks,
+ }, tx, ty);
+
+ if (result.positions.length === 0) return;
+
+ const state = createDragState(info, false);
+ for (const pos of result.positions) {
+ paintTile(state, pos.x, pos.y, fillTileId);
+ }
+ commitChanges(state, gctx);
+ }
+
+ function doPicker(gctx: GizmoContext, tx: number, ty: number): void {
+ const info = getLayerInfo(gctx);
+ if (!info) return;
+
+ const tileId = readTileFromInfo(info, tx, ty);
+ if (tileId > 0) {
+ gctx.store.tileBrushStamp = { width: 1, height: 1, tiles: [tileId] };
+ gctx.store.tileBrushTool = 'paint';
+ }
+ }
+
+ function isErasing(gctx: GizmoContext, rightClickErase: boolean, event?: MouseEvent | null): boolean {
+ return rightClickErase
+ || gctx.store.tileBrushTool === 'eraser'
+ || (event?.shiftKey ?? false);
}
return {
@@ -163,6 +248,21 @@ export function createTileBrushGizmo(): GizmoDescriptor {
);
},
+ onKeyDown(key: string, gctx: GizmoContext): boolean {
+ const toolMap: Record<string, 'paint' | 'rect-fill' | 'bucket-fill' | 'eraser' | 'picker'> = {
+ u: 'rect-fill',
+ g: 'bucket-fill',
+ d: 'eraser',
+ i: 'picker',
+ };
+ const tool = toolMap[key.toLowerCase()];
+ if (tool) {
+ gctx.store.tileBrushTool = tool;
+ return true;
+ }
+ return false;
+ },
+
hitTest(worldX, worldY, gctx) {
const info = getLayerInfo(gctx);
if (!info) return { hit: false };
@@ -170,6 +270,10 @@ export function createTileBrushGizmo(): GizmoDescriptor {
const tile = worldToTile(worldX, worldY,
info.originX, info.originY, info.tileWidth, info.tileHeight);
+ if (info.infinite) {
+ return { hit: true, data: tile };
+ }
+
if (tile.tx >= 0 && tile.tx < info.width &&
tile.ty >= 0 && tile.ty < info.height) {
return { hit: true, data: tile };
@@ -185,14 +289,15 @@ export function createTileBrushGizmo(): GizmoDescriptor {
const { ctx, zoom } = gctx;
const store = gctx.store;
- const isErase = store.tileBrushMode === 'erase';
+ const tool = store.tileBrushTool;
+ const stamp = store.tileBrushStamp;
- const screenX = info.originX + hoverTile.tx * info.tileWidth;
- const screenY = -info.originY + hoverTile.ty * info.tileHeight;
+ const drawEraseCursor = tool === 'eraser' || (dragState?.rightClickErase ?? false);
- ctx.save();
-
- if (isErase) {
+ if (drawEraseCursor) {
+ const screenX = info.originX + hoverTile.tx * info.tileWidth;
+ const screenY = -info.originY + hoverTile.ty * info.tileHeight;
+ ctx.save();
ctx.fillStyle = 'rgba(255, 60, 60, 0.3)';
ctx.fillRect(screenX, screenY, info.tileWidth, info.tileHeight);
ctx.strokeStyle = 'rgba(255, 60, 60, 0.8)';
@@ -203,18 +308,43 @@ export function createTileBrushGizmo(): GizmoDescriptor {
ctx.moveTo(screenX + info.tileWidth, screenY);
ctx.lineTo(screenX, screenY + info.tileHeight);
ctx.stroke();
- } else {
- ctx.fillStyle = 'rgba(100, 200, 255, 0.3)';
- ctx.fillRect(screenX, screenY, info.tileWidth, info.tileHeight);
+ ctx.restore();
+ return;
+ }
+
+ if (rectDrag) {
+ const minTx = Math.min(rectDrag.startTx, rectDrag.endTx);
+ const minTy = Math.min(rectDrag.startTy, rectDrag.endTy);
+ const maxTx = Math.max(rectDrag.startTx, rectDrag.endTx);
+ const maxTy = Math.max(rectDrag.startTy, rectDrag.endTy);
+ const sx = info.originX + minTx * info.tileWidth;
+ const sy = -info.originY + minTy * info.tileHeight;
+ const w = (maxTx - minTx + 1) * info.tileWidth;
+ const h = (maxTy - minTy + 1) * info.tileHeight;
+ ctx.save();
+ ctx.fillStyle = 'rgba(100, 200, 255, 0.2)';
+ ctx.fillRect(sx, sy, w, h);
ctx.strokeStyle = 'rgba(100, 200, 255, 0.8)';
ctx.lineWidth = 2 / zoom;
- ctx.strokeRect(screenX, screenY, info.tileWidth, info.tileHeight);
+ ctx.strokeRect(sx, sy, w, h);
+ ctx.restore();
+ return;
}
+ ctx.save();
+ const screenX = info.originX + hoverTile.tx * info.tileWidth;
+ const screenY = -info.originY + hoverTile.ty * info.tileHeight;
+ const sw = stamp.width * info.tileWidth;
+ const sh = stamp.height * info.tileHeight;
+ ctx.fillStyle = 'rgba(100, 200, 255, 0.3)';
+ ctx.fillRect(screenX, screenY, sw, sh);
+ ctx.strokeStyle = 'rgba(100, 200, 255, 0.8)';
+ ctx.lineWidth = 2 / zoom;
+ ctx.strokeRect(screenX, screenY, sw, sh);
ctx.restore();
},
- onDragStart(worldX, worldY, _hitData, gctx) {
+ onDragStart(worldX, worldY, _hitData, gctx, event) {
gctx.setGizmoActive(true);
const info = getLayerInfo(gctx);
if (!info) return;
@@ -222,38 +352,72 @@ export function createTileBrushGizmo(): GizmoDescriptor {
const tile = worldToTile(worldX, worldY,
info.originX, info.originY, info.tileWidth, info.tileHeight);
- const isErase = gctx.store.tileBrushMode === 'erase';
- const tileId = isErase ? 0 : gctx.store.tileBrushSelectedTileId;
-
- dragState = {
- entityId: info.entityId,
- mapWidth: info.width,
- mapHeight: info.height,
- tileWidth: info.tileWidth,
- tileHeight: info.tileHeight,
- originX: info.originX,
- originY: info.originY,
- tiles: info.tiles,
- changes: new Map(),
- };
+ const tool = gctx.store.tileBrushTool;
+ const rightClick = event?.button === 2;
+
+ if (!rightClick && tool === 'bucket-fill') {
+ doBucketFill(gctx, tile.tx, tile.ty);
+ gctx.setGizmoActive(false);
+ gctx.requestRender();
+ return;
+ }
- paintTile(dragState, tile.tx, tile.ty, tileId);
+ if (!rightClick && tool === 'picker') {
+ doPicker(gctx, tile.tx, tile.ty);
+ gctx.setGizmoActive(false);
+ gctx.requestRender();
+ return;
+ }
+
+ if (!rightClick && tool === 'rect-fill') {
+ rectDrag = {
+ entityId: info.entityId,
+ startTx: tile.tx,
+ startTy: tile.ty,
+ endTx: tile.tx,
+ endTy: tile.ty,
+ };
+ gctx.requestRender();
+ return;
+ }
+
+ const erase = isErasing(gctx, rightClick);
+ dragState = createDragState(info, rightClick);
+
+ if (erase) {
+ paintTile(dragState, tile.tx, tile.ty, 0);
+ } else {
+ paintStamp(dragState, tile.tx, tile.ty, gctx.store.tileBrushStamp);
+ }
gctx.requestRender();
},
onDrag(worldX, worldY, _hitData, gctx, event) {
+ if (rectDrag) {
+ const info = getLayerInfo(gctx);
+ if (!info) return;
+ const tile = worldToTile(worldX, worldY,
+ info.originX, info.originY, info.tileWidth, info.tileHeight);
+ rectDrag.endTx = tile.tx;
+ rectDrag.endTy = tile.ty;
+ hoverTile = tile;
+ gctx.requestRender();
+ return;
+ }
+
if (!dragState) return;
- const isShiftErase = event?.shiftKey ?? false;
- const storeErase = gctx.store.tileBrushMode === 'erase';
- const isErase = isShiftErase || storeErase;
- const tileId = isErase ? 0 : gctx.store.tileBrushSelectedTileId;
+ const erase = isErasing(gctx, dragState.rightClickErase, event);
const tile = worldToTile(worldX, worldY,
dragState.originX, dragState.originY,
dragState.tileWidth, dragState.tileHeight);
- paintTile(dragState, tile.tx, tile.ty, tileId);
+ if (erase) {
+ paintTile(dragState, tile.tx, tile.ty, 0);
+ } else {
+ paintStamp(dragState, tile.tx, tile.ty, gctx.store.tileBrushStamp);
+ }
hoverTile = tile;
gctx.requestRender();
@@ -261,34 +425,51 @@ export function createTileBrushGizmo(): GizmoDescriptor {
onDragEnd(_worldX, _worldY, _hitData, gctx) {
gctx.setGizmoActive(false);
+
+ if (rectDrag) {
+ const info = getLayerInfo(gctx);
+ if (info) {
+ const minTx = Math.min(rectDrag.startTx, rectDrag.endTx);
+ const minTy = Math.min(rectDrag.startTy, rectDrag.endTy);
+ const maxTx = Math.max(rectDrag.startTx, rectDrag.endTx);
+ const maxTy = Math.max(rectDrag.startTy, rectDrag.endTy);
+
+ const state = createDragState(info, false);
+ const stamp = gctx.store.tileBrushStamp;
+
+ for (let ty = minTy; ty <= maxTy; ty++) {
+ for (let tx = minTx; tx <= maxTx; tx++) {
+ const sx = (tx - minTx) % stamp.width;
+ const sy = (ty - minTy) % stamp.height;
+ const tileId = stamp.tiles[sy * stamp.width + sx] ?? 0;
+ if (tileId > 0) {
+ paintTile(state, tx, ty, tileId);
+ }
+ }
+ }
+ commitChanges(state, gctx);
+ }
+ rectDrag = null;
+ gctx.requestRender();
+ return;
+ }
+
if (!dragState || dragState.changes.size === 0) {
dragState = null;
return;
}
- const changes = Array.from(dragState.changes.values());
- const entityId = dragState.entityId;
+ commitChanges(dragState, gctx);
dragState = null;
-
- const store = gctx.store;
- const cmd = new TilePaintCommand(
- store.scene,
- store.entityMap_,
- entityId,
- changes,
- );
- store.executeCommand(cmd);
gctx.requestRender();
},
onHover(worldX, worldY, hitData, gctx) {
let newTile: { tx: number; ty: number } | null = null;
- if (hitData) {
- const info = getLayerInfo(gctx);
- if (info) {
- newTile = worldToTile(worldX, worldY,
- info.originX, info.originY, info.tileWidth, info.tileHeight);
- }
+ const info = getLayerInfo(gctx);
+ if (info && (hitData || info.infinite)) {
+ newTile = worldToTile(worldX, worldY,
+ info.originX, info.originY, info.tileWidth, info.tileHeight);
}
if (newTile?.tx === hoverTile?.tx && newTile?.ty === hoverTile?.ty) return;
hoverTile = newTile;
diff --git a/editor/src/gizmos/TileChunkUtils.ts b/editor/src/gizmos/TileChunkUtils.ts
new file mode 100644
index 000000000..fa0af05de
--- /dev/null
+++ b/editor/src/gizmos/TileChunkUtils.ts
@@ -0,0 +1,27 @@
+export const CHUNK_SIZE = 16;
+
+export function tileToChunk(tx: number, ty: number): { cx: number; cy: number; lx: number; ly: number } {
+ return {
+ cx: Math.floor(tx / CHUNK_SIZE),
+ cy: Math.floor(ty / CHUNK_SIZE),
+ lx: ((tx % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE,
+ ly: ((ty % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE,
+ };
+}
+
+export function readChunkTile(chunks: Record<string, number[]>, tx: number, ty: number): number {
+ const { cx, cy, lx, ly } = tileToChunk(tx, ty);
+ const chunk = chunks[`${cx},${cy}`];
+ return chunk ? (chunk[ly * CHUNK_SIZE + lx] ?? 0) : 0;
+}
+
+export function writeChunkTile(chunks: Record<string, number[]>, tx: number, ty: number, tileId: number): void {
+ const { cx, cy, lx, ly } = tileToChunk(tx, ty);
+ const key = `${cx},${cy}`;
+ let chunk = chunks[key];
+ if (!chunk) {
+ chunk = new Array(CHUNK_SIZE * CHUNK_SIZE).fill(0);
+ chunks[key] = chunk;
+ }
+ chunk[ly * CHUNK_SIZE + lx] = tileId;
+}
diff --git a/editor/src/gizmos/TileFill.ts b/editor/src/gizmos/TileFill.ts
new file mode 100644
index 000000000..be934b384
--- /dev/null
+++ b/editor/src/gizmos/TileFill.ts
@@ -0,0 +1,64 @@
+import { readChunkTile } from './TileChunkUtils';
+
+const FLOOD_FILL_LIMIT = 10000;
+
+interface TileGrid {
+ infinite: boolean;
+ width: number;
+ height: number;
+ tiles: number[];
+ chunks: Record<string, number[]>;
+}
+
+function readTile(grid: TileGrid, x: number, y: number): number {
+ if (grid.infinite) {
+ return readChunkTile(grid.chunks, x, y);
+ }
+ if (x < 0 || x >= grid.width || y < 0 || y >= grid.height) return -1;
+ return grid.tiles[y * grid.width + x] ?? 0;
+}
+
+export interface FillResult {
+ positions: { x: number; y: number }[];
+}
+
+export function floodFill(
+ grid: TileGrid,
+ startX: number, startY: number,
+): FillResult {
+ const targetTile = readTile(grid, startX, startY);
+ if (targetTile < 0) return { positions: [] };
+
+ const visited = new Set<string>();
+ const queue: { x: number; y: number }[] = [{ x: startX, y: startY }];
+ const positions: { x: number; y: number }[] = [];
+ let head = 0;
+
+ const startKey = `${startX},${startY}`;
+ visited.add(startKey);
+
+ while (head < queue.length && positions.length < FLOOD_FILL_LIMIT) {
+ const { x, y } = queue[head++];
+ positions.push({ x, y });
+
+ const neighbors = [
+ { x: x - 1, y },
+ { x: x + 1, y },
+ { x, y: y - 1 },
+ { x, y: y + 1 },
+ ];
+
+ for (const n of neighbors) {
+ const key = `${n.x},${n.y}`;
+ if (visited.has(key)) continue;
+ visited.add(key);
+
+ const tile = readTile(grid, n.x, n.y);
+ if (tile === targetTile) {
+ queue.push(n);
+ }
+ }
+ }
+
+ return { positions };
+}
diff --git a/editor/src/gizmos/TilemapOverlay.ts b/editor/src/gizmos/TilemapOverlay.ts
index 23d28a38d..5013db186 100644
--- a/editor/src/gizmos/TilemapOverlay.ts
+++ b/editor/src/gizmos/TilemapOverlay.ts
@@ -1,6 +1,7 @@
import type { OverlayContext } from './ColliderOverlay';
import type { EntityData } from '../types/SceneTypes';
-import { getTilesetForSource, addTilesetLoadListener } from './TilesetLoader';
+import { getTilesetForSource, getTilesetForImage, findParentTilemapSource, addTilesetLoadListener } from './TilesetLoader';
+import { CHUNK_SIZE } from './TileChunkUtils';
const GRID_COLOR = 'rgba(100, 200, 255, 0.5)';
const FALLBACK_TILE_COLOR = 'rgba(100, 200, 255, 0.15)';
@@ -63,14 +64,14 @@ export class TilemapOverlay {
if (!layerComp) return;
const data = layerComp.data as Record<string, unknown>;
+ const infinite = data.infinite as boolean ?? false;
const width = data.width as number ?? 0;
const height = data.height as number ?? 0;
const tileWidth = data.tileWidth as number ?? 32;
const tileHeight = data.tileHeight as number ?? 32;
- const tiles = data.tiles as number[] ?? [];
const tilesetColumns = data.tilesetColumns as number ?? 1;
- if (width === 0 || height === 0) return;
+ if (!infinite && (width === 0 || height === 0)) return;
const { ctx, zoom, store } = octx;
const worldTransform = store.getWorldTransform(entity.id);
@@ -79,17 +80,82 @@ export class TilemapOverlay {
ctx.save();
- this.drawGrid_(ctx, width, height, tileWidth, tileHeight, ox, oy, zoom);
+ const image = this.resolveTilesetImage_(octx, entity, data, tileWidth, tileHeight, tilesetColumns);
- if (tiles.length > 0) {
- this.drawTiles_(ctx, tiles, width, height, tileWidth, tileHeight,
- tilesetColumns, null, ox, oy);
+ if (infinite) {
+ const chunks = data.chunks as Record<string, number[]> ?? {};
+ this.drawChunks_(ctx, chunks, tileWidth, tileHeight, tilesetColumns, image, ox, oy);
+ } else {
+ this.drawGrid_(ctx, width, height, tileWidth, tileHeight, ox, oy, zoom);
+ const tiles = data.tiles as number[] ?? [];
+ if (tiles.length > 0) {
+ this.drawTiles_(ctx, tiles, width, height, tileWidth, tileHeight,
+ tilesetColumns, image, ox, oy);
+ }
}
this.drawOriginMarker_(ctx, ox, oy, zoom);
ctx.restore();
}
+ private resolveTilesetImage_(
+ octx: OverlayContext, entity: EntityData, data: Record<string, unknown>,
+ tileWidth: number, tileHeight: number, tilesetColumns: number,
+ ): HTMLImageElement | null {
+ const parentSource = findParentTilemapSource(octx.store.scene.entities, entity.id);
+ if (parentSource) {
+ const info = getTilesetForSource(parentSource);
+ if (info?.tilesetImage) return info.tilesetImage;
+ }
+
+ const textureUuid = data.texture as string ?? '';
+ if (textureUuid && typeof textureUuid === 'string') {
+ const info = getTilesetForImage(textureUuid, tileWidth, tileHeight, tilesetColumns);
+ if (info?.tilesetImage) return info.tilesetImage;
+ }
+
+ return null;
+ }
+
+
+ private drawChunks_(
+ ctx: CanvasRenderingContext2D,
+ chunks: Record<string, number[]>,
+ tileWidth: number, tileHeight: number,
+ tilesetColumns: number,
+ image: HTMLImageElement | null,
+ ox: number, oy: number,
+ ): void {
+ const hasImage = image && image.complete && image.naturalWidth > 0;
+
+ for (const [key, tiles] of Object.entries(chunks)) {
+ const [cxStr, cyStr] = key.split(',');
+ const cx = parseInt(cxStr, 10);
+ const cy = parseInt(cyStr, 10);
+ const baseX = ox + cx * CHUNK_SIZE * tileWidth;
+ const baseY = oy + cy * CHUNK_SIZE * tileHeight;
+
+ for (let ly = 0; ly < CHUNK_SIZE; ly++) {
+ for (let lx = 0; lx < CHUNK_SIZE; lx++) {
+ const tileId = tiles[ly * CHUNK_SIZE + lx] ?? 0;
+ if (tileId === 0) continue;
+
+ const dx = baseX + lx * tileWidth;
+ const dy = baseY + ly * tileHeight;
+
+ if (hasImage) {
+ const tileIndex = tileId - 1;
+ const sx = (tileIndex % tilesetColumns) * tileWidth;
+ const sy = Math.floor(tileIndex / tilesetColumns) * tileHeight;
+ ctx.drawImage(image!, sx, sy, tileWidth, tileHeight, dx, dy, tileWidth, tileHeight);
+ } else {
+ ctx.fillStyle = FALLBACK_TILE_COLOR;
+ ctx.fillRect(dx + 1, dy + 1, tileWidth - 2, tileHeight - 2);
+ }
+ }
+ }
+ }
+ }
private drawTiles_(
ctx: CanvasRenderingContext2D,
diff --git a/editor/src/panels/PanelRegistry.ts b/editor/src/panels/PanelRegistry.ts
index e6e3ce069..5ecacbae9 100644
--- a/editor/src/panels/PanelRegistry.ts
+++ b/editor/src/panels/PanelRegistry.ts
@@ -1,5 +1,6 @@
import { getEditorContainer } from '../container';
import { PANEL } from '../container/tokens';
+import type { EditorStore } from '../store/EditorStore';
export type PanelPosition = 'left' | 'right' | 'center' | 'bottom';
@@ -11,6 +12,7 @@ export interface PanelDescriptor {
defaultVisible?: boolean;
order?: number;
factory: PanelFactory;
+ contextMatch?: (store: EditorStore) => boolean;
}
export interface PanelFactoryResult {
diff --git a/editor/src/panels/builtinPanels.ts b/editor/src/panels/builtinPanels.ts
index 8630e5d89..a4726c887 100644
--- a/editor/src/panels/builtinPanels.ts
+++ b/editor/src/panels/builtinPanels.ts
@@ -97,6 +97,10 @@ export function registerBuiltinPanels(registrar: PluginRegistrar, options: Built
defaultVisible: false,
order: 2,
factory: (c) => ({ instance: new TimelinePanel(c, getEditorStore()) }),
+ contextMatch: (store) => {
+ const data = store.getSelectedEntityData();
+ return !!data?.components.some(c => c.type === 'TimelinePlayer');
+ },
});
registerPanel({
@@ -127,6 +131,10 @@ export function registerBuiltinPanels(registrar: PluginRegistrar, options: Built
order: 5,
defaultVisible: false,
factory: (c) => ({ instance: new StateMachineGraphPanel(c, getEditorStore()) }),
+ contextMatch: (store) => {
+ const data = store.getSelectedEntityData();
+ return !!data?.components.some(c => c.type === 'StateMachine');
+ },
});
registerPanel({
@@ -137,6 +145,10 @@ export function registerBuiltinPanels(registrar: PluginRegistrar, options: Built
defaultVisible: false,
order: 6,
factory: (c) => ({ instance: new TilePalettePanel(c, getEditorStore()) }),
+ contextMatch: (store) => {
+ const data = store.getSelectedEntityData();
+ return !!data?.components.some(c => c.type === 'TilemapLayer' || c.type === 'Tilemap');
+ },
});
registerPanel({
diff --git a/editor/src/panels/hierarchy/CreateTilemapDialog.ts b/editor/src/panels/hierarchy/CreateTilemapDialog.ts
index edd7a8d7f..3354fac66 100644
--- a/editor/src/panels/hierarchy/CreateTilemapDialog.ts
+++ b/editor/src/panels/hierarchy/CreateTilemapDialog.ts
@@ -18,6 +18,7 @@ interface TilemapConfig {
tilesetColumns: number;
mapWidth: number;
mapHeight: number;
+ infinite: boolean;
}
export async function showCreateTilemapDialog(
@@ -31,6 +32,7 @@ export async function showCreateTilemapDialog(
tilesetColumns: 1,
mapWidth: DEFAULT_MAP_WIDTH,
mapHeight: DEFAULT_MAP_HEIGHT,
+ infinite: false,
};
let loadedImage: HTMLImageElement | null = null;
@@ -62,7 +64,14 @@ export async function showCreateTilemapDialog(
<input type="number" class="es-dialog-input es-tilemap-cols" value="1" min="1" max="256" step="1">
</div>
</div>
- <div class="es-dialog-field" style="display:flex;gap:12px;">
+ <div class="es-dialog-field">
+ <label class="es-dialog-label">Map Type</label>
+ <select class="es-dialog-input es-tilemap-map-type" style="width:100%;">
+ <option value="fixed" selected>Fixed Size</option>
+ <option value="infinite">Infinite</option>
+ </select>
+ </div>
+ <div class="es-dialog-field es-tilemap-size-row" style="display:flex;gap:12px;">
<div style="flex:1;">
<label class="es-dialog-label">Map Width (tiles)</label>
<input type="number" class="es-dialog-input es-tilemap-mw" value="${DEFAULT_MAP_WIDTH}" min="1" max="1000" step="1">
@@ -170,6 +179,13 @@ export async function showCreateTilemapDialog(
config.mapHeight = Math.max(1, parseInt(mhInput.value) || DEFAULT_MAP_HEIGHT);
});
+ const mapTypeSelect = content.querySelector('.es-tilemap-map-type') as HTMLSelectElement;
+ const sizeRow = content.querySelector('.es-tilemap-size-row') as HTMLElement;
+ mapTypeSelect.addEventListener('change', () => {
+ config.infinite = mapTypeSelect.value === 'infinite';
+ sizeRow.style.display = config.infinite ? 'none' : 'flex';
+ });
+
const dialog = new Dialog({
title: 'New Tilemap Layer',
content,
@@ -188,17 +204,32 @@ export async function showCreateTilemapDialog(
state.store.addComponent(entity, 'Transform', transformData);
const layerData = getInitialComponentData('TilemapLayer');
- const tiles = new Array(config.mapWidth * config.mapHeight).fill(0);
- state.store.addComponent(entity, 'TilemapLayer', {
- ...layerData,
- texture: config.textureUuid,
- tileWidth: config.tileWidth,
- tileHeight: config.tileHeight,
- tilesetColumns: config.tilesetColumns,
- width: config.mapWidth,
- height: config.mapHeight,
- tiles,
- });
+ if (config.infinite) {
+ state.store.addComponent(entity, 'TilemapLayer', {
+ ...layerData,
+ texture: config.textureUuid,
+ tileWidth: config.tileWidth,
+ tileHeight: config.tileHeight,
+ tilesetColumns: config.tilesetColumns,
+ infinite: true,
+ width: 0,
+ height: 0,
+ tiles: [],
+ chunks: {},
+ });
+ } else {
+ const tiles = new Array(config.mapWidth * config.mapHeight).fill(0);
+ state.store.addComponent(entity, 'TilemapLayer', {
+ ...layerData,
+ texture: config.textureUuid,
+ tileWidth: config.tileWidth,
+ tileHeight: config.tileHeight,
+ tilesetColumns: config.tilesetColumns,
+ width: config.mapWidth,
+ height: config.mapHeight,
+ tiles,
+ });
+ }
state.store.selectEntity(entity);
state.store.requestGizmo('tile-brush');
diff --git a/editor/src/panels/scene-view/SceneViewInput.ts b/editor/src/panels/scene-view/SceneViewInput.ts
index 3e18c48ef..79497cf4e 100644
--- a/editor/src/panels/scene-view/SceneViewInput.ts
+++ b/editor/src/panels/scene-view/SceneViewInput.ts
@@ -81,6 +81,7 @@ export class SceneViewInput {
return;
}
+ if (this.deps_.gizmoManager.onKeyDown(e.key)) return;
if (toolbar.handleKeyShortcut(e.key)) return;
if (e.key === 'f' || e.key === 'F') {
@@ -201,6 +202,15 @@ export class SceneViewInput {
return;
}
+ if (e.button === 2 && gizmoManager.getActiveId() === 'tile-brush') {
+ const { worldX, worldY } = camera.screenToWorld(e.clientX, e.clientY);
+ this.updateGizmoContext();
+ if (gizmoManager.onMouseDown(worldX, worldY, e)) {
+ this.startDocumentDrag();
+ }
+ return;
+ }
+
if (e.button !== 0) return;
this.mouseDownX_ = e.clientX;
@@ -211,7 +221,7 @@ export class SceneViewInput {
if (gizmoManager.getActiveId() !== 'select' && hasSelection) {
this.updateGizmoContext();
- if (gizmoManager.onMouseDown(worldX, worldY)) {
+ if (gizmoManager.onMouseDown(worldX, worldY, e)) {
this.startDocumentDrag();
return;
}
@@ -443,6 +453,10 @@ export class SceneViewInput {
}
private onContextMenu(e: MouseEvent): void {
+ if (this.deps_.gizmoManager.getActiveId() === 'tile-brush') {
+ e.preventDefault();
+ return;
+ }
if (!getSettingsValue<boolean>('scene.showColliders')) return;
const { camera, colliderOverlay } = this.deps_;
diff --git a/editor/src/panels/tile-palette/TilePalettePanel.ts b/editor/src/panels/tile-palette/TilePalettePanel.ts
index 4d5ddae4e..a0c1e3321 100644
--- a/editor/src/panels/tile-palette/TilePalettePanel.ts
+++ b/editor/src/panels/tile-palette/TilePalettePanel.ts
@@ -1,5 +1,6 @@
import type { PanelInstance } from '../PanelRegistry';
import type { EditorStore } from '../../store/EditorStore';
+import type { EntityData } from '../../types/SceneTypes';
import { DisposableStore } from '../../utils/Disposable';
import { getTilesetForSource, getTilesetForImage, findParentTilemapSource, addTilesetLoadListener, type TilesetInfo } from '../../gizmos/TilesetLoader';
import { icons } from '../../utils/icons';
@@ -10,6 +11,16 @@ const HOVER_COLOR = 'rgba(255, 255, 255, 0.3)';
const GRID_COLOR = 'rgba(80, 80, 80, 0.5)';
const BG_COLOR = '#1e1e1e';
+type TileBrushTool = 'paint' | 'rect-fill' | 'bucket-fill' | 'eraser' | 'picker';
+
+const TOOL_DEFS: { tool: TileBrushTool; cls: string; label: string; shortcut: string; icon: (s: number) => string }[] = [
+ { tool: 'paint', cls: 'es-tile-tool-paint', label: 'Paint', shortcut: 'B', icon: icons.pencil },
+ { tool: 'rect-fill', cls: 'es-tile-tool-rect', label: 'Rect Fill', shortcut: 'U', icon: icons.rectFill },
+ { tool: 'bucket-fill', cls: 'es-tile-tool-bucket', label: 'Bucket Fill', shortcut: 'G', icon: icons.paintBucket },
+ { tool: 'eraser', cls: 'es-tile-tool-eraser', label: 'Eraser', shortcut: 'D', icon: icons.eraser },
+ { tool: 'picker', cls: 'es-tile-tool-picker', label: 'Picker', shortcut: 'I', icon: icons.pipette },
+];
+
export class TilePalettePanel implements PanelInstance {
private container_: HTMLElement;
private store_: EditorStore;
@@ -17,22 +28,35 @@ export class TilePalettePanel implements PanelInstance {
private canvas_: HTMLCanvasElement | null = null;
private ctx_: CanvasRenderingContext2D | null = null;
private statusEl_: HTMLElement | null = null;
+ private layerSelect_: HTMLSelectElement | null = null;
private hoveredTile_ = -1;
private cachedInfo_: TilesetInfo | null = null;
private cachedSource_: string | null = null;
private isReadOnly_ = false;
private lastSelectedEntityId_ = -1;
+ private dragStartTile_ = -1;
+ private dragEndTile_ = -1;
+ private isDragging_ = false;
+
constructor(container: HTMLElement, store: EditorStore) {
this.container_ = container;
this.store_ = store;
this.container_.innerHTML = `
<div class="es-tile-palette" style="display:flex;flex-direction:column;height:100%;overflow:hidden;">
- <div class="es-tile-palette-toolbar" style="display:flex;gap:4px;padding:4px;border-bottom:1px solid var(--border-color, #333);align-items:center;">
- <button class="es-btn es-btn-icon es-tile-tool-paint es-active" data-tooltip="Paint (B)" style="min-width:24px;height:24px;">${icons.pencil(12)}</button>
- <button class="es-btn es-btn-icon es-tile-tool-erase" data-tooltip="Erase (Shift)" style="min-width:24px;height:24px;">${icons.trash(12)}</button>
- <span class="es-tile-palette-status" style="margin-left:auto;font-size:11px;color:#888;"></span>
+ <div class="es-tile-palette-toolbar" style="display:flex;gap:2px;padding:4px;border-bottom:1px solid var(--border-color, #333);align-items:center;flex-wrap:wrap;">
+ ${TOOL_DEFS.map(d =>
+ `<button class="es-btn es-btn-icon ${d.cls}" data-tooltip="${d.label} (${d.shortcut})" style="min-width:24px;height:24px;">${d.icon(12)}</button>`
+ ).join('')}
+ <span style="width:1px;height:16px;background:var(--border-color,#444);margin:0 4px;"></span>
+ <button class="es-btn es-btn-icon es-tile-flip-h" data-tooltip="Flip Horizontal" style="min-width:24px;height:24px;">${icons.flipHorizontal(12)}</button>
+ <button class="es-btn es-btn-icon es-tile-flip-v" data-tooltip="Flip Vertical" style="min-width:24px;height:24px;">${icons.flipVertical(12)}</button>
+ </div>
+ <div class="es-tile-palette-info" style="display:flex;gap:8px;padding:4px 8px;border-bottom:1px solid var(--border-color, #333);align-items:center;font-size:11px;">
+ <label style="color:#aaa;">Layer:</label>
+ <select class="es-tile-layer-select es-select" style="flex:1;max-width:160px;height:20px;font-size:11px;"></select>
+ <span class="es-tile-palette-status" style="margin-left:auto;color:#888;"></span>
</div>
<div class="es-tile-palette-canvas-wrap" style="flex:1;overflow-y:auto;position:relative;">
<canvas class="es-tile-palette-canvas" style="display:block;"></canvas>
@@ -42,12 +66,17 @@ export class TilePalettePanel implements PanelInstance {
this.canvas_ = this.container_.querySelector('.es-tile-palette-canvas');
this.ctx_ = this.canvas_?.getContext('2d') ?? null;
this.statusEl_ = this.container_.querySelector('.es-tile-palette-status');
+ this.layerSelect_ = this.container_.querySelector('.es-tile-layer-select');
this.setupToolbarEvents_();
this.setupCanvasEvents_();
+ this.setupLayerSelect_();
this.disposables_.add(store.subscribe(() => this.onStoreChange_()));
- this.disposables_.add(addTilesetLoadListener(() => this.render_()));
+ this.disposables_.add(addTilesetLoadListener(() => {
+ this.lastSelectedEntityId_ = -1;
+ this.onStoreChange_();
+ }));
this.onStoreChange_();
}
@@ -61,69 +90,185 @@ export class TilePalettePanel implements PanelInstance {
}
private setupToolbarEvents_(): void {
- const paintBtn = this.container_.querySelector('.es-tile-tool-paint');
- const eraseBtn = this.container_.querySelector('.es-tile-tool-erase');
+ for (const def of TOOL_DEFS) {
+ const btn = this.container_.querySelector(`.${def.cls}`);
+ if (!btn) continue;
+ const handler = () => {
+ this.store_.tileBrushTool = def.tool;
+ this.updateToolbarActive_();
+ };
+ btn.addEventListener('click', handler);
+ this.disposables_.add(() => btn.removeEventListener('click', handler));
+ }
+
+ const flipH = this.container_.querySelector('.es-tile-flip-h');
+ const flipV = this.container_.querySelector('.es-tile-flip-v');
- const onPaint = () => {
- this.store_.tileBrushMode = 'paint';
+ const onFlipH = () => {
+ this.store_.tileBrushFlipH = !this.store_.tileBrushFlipH;
this.updateToolbarActive_();
};
- const onErase = () => {
- this.store_.tileBrushMode = 'erase';
+ const onFlipV = () => {
+ this.store_.tileBrushFlipV = !this.store_.tileBrushFlipV;
this.updateToolbarActive_();
};
- paintBtn?.addEventListener('click', onPaint);
- eraseBtn?.addEventListener('click', onErase);
+ flipH?.addEventListener('click', onFlipH);
+ flipV?.addEventListener('click', onFlipV);
this.disposables_.add(() => {
- paintBtn?.removeEventListener('click', onPaint);
- eraseBtn?.removeEventListener('click', onErase);
+ flipH?.removeEventListener('click', onFlipH);
+ flipV?.removeEventListener('click', onFlipV);
});
}
private updateToolbarActive_(): void {
- const mode = this.store_.tileBrushMode;
- this.container_.querySelector('.es-tile-tool-paint')
- ?.classList.toggle('es-active', mode === 'paint');
- this.container_.querySelector('.es-tile-tool-erase')
- ?.classList.toggle('es-active', mode === 'erase');
+ const tool = this.store_.tileBrushTool;
+ for (const def of TOOL_DEFS) {
+ this.container_.querySelector(`.${def.cls}`)
+ ?.classList.toggle('es-active', tool === def.tool);
+ }
+ this.container_.querySelector('.es-tile-flip-h')
+ ?.classList.toggle('es-active', this.store_.tileBrushFlipH);
+ this.container_.querySelector('.es-tile-flip-v')
+ ?.classList.toggle('es-active', this.store_.tileBrushFlipV);
+ }
+
+ private setupLayerSelect_(): void {
+ if (!this.layerSelect_) return;
+ const onChange = () => {
+ const id = parseInt(this.layerSelect_!.value, 10);
+ if (!isNaN(id)) {
+ this.store_.selectEntity(id);
+ }
+ };
+ this.layerSelect_.addEventListener('change', onChange);
+ this.disposables_.add(() => this.layerSelect_?.removeEventListener('change', onChange));
+ }
+
+ private updateLayerDropdown_(): void {
+ if (!this.layerSelect_) return;
+
+ const entityData = this.store_.getSelectedEntityData();
+ if (!entityData) {
+ this.layerSelect_.innerHTML = '';
+ return;
+ }
+
+ const parentId = entityData.parent;
+ const siblings = this.store_.scene.entities.filter(e => {
+ if (e.parent !== parentId) return false;
+ return e.components.some(c => c.type === 'TilemapLayer');
+ });
+
+ if (siblings.length === 0 && entityData.components.some(c => c.type === 'TilemapLayer')) {
+ siblings.push(entityData);
+ }
+
+ const currentValue = this.layerSelect_.value;
+ this.layerSelect_.innerHTML = siblings.map(e =>
+ `<option value="${e.id}"${e.id === entityData.id ? ' selected' : ''}>${e.name || `Entity ${e.id}`}</option>`
+ ).join('');
+
+ if (this.layerSelect_.value !== currentValue) {
+ this.layerSelect_.value = String(entityData.id);
+ }
}
private setupCanvasEvents_(): void {
if (!this.canvas_) return;
- const onClick = (e: MouseEvent) => {
- if (this.isReadOnly_) return;
+ const onMouseDown = (e: MouseEvent) => {
+ if (this.isReadOnly_ || e.button !== 0) return;
const tileId = this.getTileAtMouse_(e);
- if (tileId > 0) {
- this.store_.tileBrushSelectedTileId = tileId;
- this.render_();
- }
+ if (tileId <= 0) return;
+
+ this.isDragging_ = true;
+ this.dragStartTile_ = tileId;
+ this.dragEndTile_ = tileId;
+
+ this.store_.tileBrushStamp = { width: 1, height: 1, tiles: [tileId] };
+ this.render_();
};
- const onMove = (e: MouseEvent) => {
+
+ const onMouseMove = (e: MouseEvent) => {
const tileId = this.getTileAtMouse_(e);
+
+ if (this.isDragging_) {
+ if (tileId > 0 && tileId !== this.dragEndTile_) {
+ this.dragEndTile_ = tileId;
+ this.updateStampFromDrag_();
+ this.render_();
+ }
+ return;
+ }
+
if (tileId !== this.hoveredTile_) {
this.hoveredTile_ = tileId;
this.render_();
}
};
+
+ const onMouseUp = () => {
+ if (this.isDragging_) {
+ this.isDragging_ = false;
+ this.updateStampFromDrag_();
+ this.render_();
+ }
+ };
+
const onLeave = () => {
+ if (this.isDragging_) {
+ this.isDragging_ = false;
+ this.updateStampFromDrag_();
+ }
if (this.hoveredTile_ !== -1) {
this.hoveredTile_ = -1;
this.render_();
}
};
- this.canvas_.addEventListener('click', onClick);
- this.canvas_.addEventListener('mousemove', onMove);
+ this.canvas_.addEventListener('mousedown', onMouseDown);
+ this.canvas_.addEventListener('mousemove', onMouseMove);
+ window.addEventListener('mouseup', onMouseUp);
this.canvas_.addEventListener('mouseleave', onLeave);
this.disposables_.add(() => {
- this.canvas_?.removeEventListener('click', onClick);
- this.canvas_?.removeEventListener('mousemove', onMove);
+ this.canvas_?.removeEventListener('mousedown', onMouseDown);
+ this.canvas_?.removeEventListener('mousemove', onMouseMove);
+ window.removeEventListener('mouseup', onMouseUp);
this.canvas_?.removeEventListener('mouseleave', onLeave);
});
}
+ private updateStampFromDrag_(): void {
+ if (!this.cachedInfo_) return;
+ const cols = this.cachedInfo_.tilesetColumns;
+
+ const startIdx = this.dragStartTile_ - 1;
+ const endIdx = this.dragEndTile_ - 1;
+
+ const startCol = startIdx % cols;
+ const startRow = Math.floor(startIdx / cols);
+ const endCol = endIdx % cols;
+ const endRow = Math.floor(endIdx / cols);
+
+ const minCol = Math.min(startCol, endCol);
+ const maxCol = Math.max(startCol, endCol);
+ const minRow = Math.min(startRow, endRow);
+ const maxRow = Math.max(startRow, endRow);
+
+ const w = maxCol - minCol + 1;
+ const h = maxRow - minRow + 1;
+ const tiles: number[] = [];
+
+ for (let r = minRow; r <= maxRow; r++) {
+ for (let c = minCol; c <= maxCol; c++) {
+ tiles.push(r * cols + c + 1);
+ }
+ }
+
+ this.store_.tileBrushStamp = { width: w, height: h, tiles };
+ }
+
private getTileAtMouse_(e: MouseEvent): number {
if (!this.canvas_ || !this.cachedInfo_) return -1;
@@ -159,9 +304,13 @@ export class TilePalettePanel implements PanelInstance {
const entityData = this.store_.getSelectedEntityData();
const entityId = entityData?.id ?? -1;
- const newSource = this.resolveSource_(entityData);
+ const newSource = this.resolveSource_(entityData ?? null);
- if (entityId === this.lastSelectedEntityId_ && newSource === this.cachedSource_) return;
+ if (entityId === this.lastSelectedEntityId_ && newSource === this.cachedSource_) {
+ this.updateToolbarActive_();
+ this.updateStatusText_();
+ return;
+ }
this.lastSelectedEntityId_ = entityId;
this.isReadOnly_ = false;
@@ -196,10 +345,12 @@ export class TilePalettePanel implements PanelInstance {
}
}
+ this.updateLayerDropdown_();
+ this.updateToolbarActive_();
this.render_();
}
- private resolveSource_(entityData: { id: number; components: { type: string; data: unknown }[] } | null): string | null {
+ private resolveSource_(entityData: EntityData | null): string | null {
if (!entityData) return null;
const tilemapComp = entityData.components.find(c => c.type === 'Tilemap');
@@ -226,19 +377,27 @@ export class TilePalettePanel implements PanelInstance {
return null;
}
+ private updateStatusText_(): void {
+ if (!this.statusEl_) return;
+ if (this.isReadOnly_) {
+ this.statusEl_.textContent = 'Read-only';
+ } else if (this.cachedInfo_) {
+ const stamp = this.store_.tileBrushStamp;
+ if (stamp.width === 1 && stamp.height === 1) {
+ this.statusEl_.textContent = `Tile: ${stamp.tiles[0] ?? 0}`;
+ } else {
+ this.statusEl_.textContent = `${stamp.width}\u00D7${stamp.height} stamp`;
+ }
+ } else {
+ this.statusEl_.textContent = '';
+ }
+ }
+
private render_(): void {
const ctx = this.ctx_;
if (!this.canvas_ || !ctx) return;
- if (this.statusEl_) {
- if (this.isReadOnly_) {
- this.statusEl_.textContent = 'Read-only (external source)';
- } else if (this.cachedInfo_) {
- this.statusEl_.textContent = `Tile: ${this.store_.tileBrushSelectedTileId}`;
- } else {
- this.statusEl_.textContent = 'No tilemap selected';
- }
- }
+ this.updateStatusText_();
if (!this.cachedInfo_?.tilesetImage) {
this.canvas_.width = this.canvas_.parentElement?.clientWidth ?? 200;
@@ -305,23 +464,9 @@ export class TilePalettePanel implements PanelInstance {
ctx.stroke();
}
- const selectedId = this.store_.tileBrushSelectedTileId;
- if (selectedId > 0 && selectedId <= totalTiles) {
- const si = selectedId - 1;
- const sc = si % cols;
- const sr = Math.floor(si / cols);
- ctx.strokeStyle = SELECTED_COLOR;
- ctx.lineWidth = 2;
- ctx.strokeRect(
- sc * TILE_RENDER_SIZE + 1,
- sr * TILE_RENDER_SIZE + 1,
- TILE_RENDER_SIZE - 2,
- TILE_RENDER_SIZE - 2,
- );
- }
+ this.drawSelection_(ctx, cols, totalTiles);
- if (this.hoveredTile_ > 0 && this.hoveredTile_ <= totalTiles &&
- this.hoveredTile_ !== selectedId) {
+ if (this.hoveredTile_ > 0 && this.hoveredTile_ <= totalTiles) {
const hi = this.hoveredTile_ - 1;
const hc = hi % cols;
const hr = Math.floor(hi / cols);
@@ -334,4 +479,61 @@ export class TilePalettePanel implements PanelInstance {
);
}
}
+
+ private drawSelection_(ctx: CanvasRenderingContext2D, cols: number, totalTiles: number): void {
+ const stamp = this.store_.tileBrushStamp;
+
+ if (this.isDragging_ && this.dragStartTile_ > 0 && this.dragEndTile_ > 0) {
+ const startIdx = this.dragStartTile_ - 1;
+ const endIdx = this.dragEndTile_ - 1;
+ const minCol = Math.min(startIdx % cols, endIdx % cols);
+ const maxCol = Math.max(startIdx % cols, endIdx % cols);
+ const minRow = Math.min(Math.floor(startIdx / cols), Math.floor(endIdx / cols));
+ const maxRow = Math.max(Math.floor(startIdx / cols), Math.floor(endIdx / cols));
+
+ ctx.strokeStyle = SELECTED_COLOR;
+ ctx.lineWidth = 2;
+ ctx.strokeRect(
+ minCol * TILE_RENDER_SIZE + 1,
+ minRow * TILE_RENDER_SIZE + 1,
+ (maxCol - minCol + 1) * TILE_RENDER_SIZE - 2,
+ (maxRow - minRow + 1) * TILE_RENDER_SIZE - 2,
+ );
+ return;
+ }
+
+ if (stamp.tiles.length === 0) return;
+
+ if (stamp.width === 1 && stamp.height === 1) {
+ const selectedId = stamp.tiles[0];
+ if (selectedId > 0 && selectedId <= totalTiles) {
+ const si = selectedId - 1;
+ const sc = si % cols;
+ const sr = Math.floor(si / cols);
+ ctx.strokeStyle = SELECTED_COLOR;
+ ctx.lineWidth = 2;
+ ctx.strokeRect(
+ sc * TILE_RENDER_SIZE + 1,
+ sr * TILE_RENDER_SIZE + 1,
+ TILE_RENDER_SIZE - 2,
+ TILE_RENDER_SIZE - 2,
+ );
+ }
+ } else {
+ const firstId = stamp.tiles[0];
+ if (firstId <= 0) return;
+ const fi = firstId - 1;
+ const startCol = fi % cols;
+ const startRow = Math.floor(fi / cols);
+
+ ctx.strokeStyle = SELECTED_COLOR;
+ ctx.lineWidth = 2;
+ ctx.strokeRect(
+ startCol * TILE_RENDER_SIZE + 1,
+ startRow * TILE_RENDER_SIZE + 1,
+ stamp.width * TILE_RENDER_SIZE - 2,
+ stamp.height * TILE_RENDER_SIZE - 2,
+ );
+ }
+ }
}
diff --git a/editor/src/plugins/tilemap.ts b/editor/src/plugins/tilemap.ts
index 52d8fa61a..31d026385 100644
--- a/editor/src/plugins/tilemap.ts
+++ b/editor/src/plugins/tilemap.ts
@@ -15,6 +15,7 @@ const TilemapLayerSchema: ComponentSchema = {
name: 'TilemapLayer',
category: 'builtin',
properties: [
+ { name: 'infinite', type: 'boolean' },
{ name: 'width', type: 'number', min: 1, max: 1000 },
{ name: 'height', type: 'number', min: 1, max: 1000 },
{ name: 'tileWidth', type: 'number', min: 1, max: 512 },
diff --git a/editor/src/services/NavigationService.ts b/editor/src/services/NavigationService.ts
index 95281bfd4..fb314de9e 100644
--- a/editor/src/services/NavigationService.ts
+++ b/editor/src/services/NavigationService.ts
@@ -1,7 +1,8 @@
import type { PanelManager } from '../PanelManager';
import type { DockLayoutManager } from '../DockLayoutManager';
import type { EditorAssetServer } from '../asset/EditorAssetServer';
-import { getPanel, getPanelsByPosition, type PanelPosition } from '../panels/PanelRegistry';
+import type { EditorStore } from '../store/EditorStore';
+import { getPanel, getAllPanels, getPanelsByPosition, type PanelPosition } from '../panels/PanelRegistry';
import type { RegionId } from '../dock/DockRegion';
export type NavigateToAssetHandler = (path: string) => Promise<void>;
@@ -26,6 +27,9 @@ export class NavigationService {
private lastActiveBottom_: string | null = null;
private panelToggleListeners_: Array<() => void> = [];
+ private contextDebounceTimer_: ReturnType<typeof setTimeout> | null = null;
+ private storeUnsubscribe_: (() => void) | null = null;
+ private activeContextPanels_ = new Set<string>();
constructor(panelManager: PanelManager) {
this.panelManager_ = panelManager;
@@ -46,7 +50,47 @@ export class NavigationService {
}
// =========================================================================
- // Panel visibility (Godot-style toggle)
+ // Context-sensitive panels
+ // =========================================================================
+
+ initContextPanels(store: EditorStore): void {
+ this.storeUnsubscribe_?.();
+ this.storeUnsubscribe_ = store.subscribe(() => {
+ if (this.contextDebounceTimer_) clearTimeout(this.contextDebounceTimer_);
+ this.contextDebounceTimer_ = setTimeout(() => {
+ this.updateContextPanels_(store);
+ }, 100);
+ });
+ }
+
+ private updateContextPanels_(store: EditorStore): void {
+ if (!this.dockLayout_) return;
+
+ for (const desc of getAllPanels()) {
+ if (!desc.contextMatch) continue;
+
+ const matches = desc.contextMatch(store);
+ const isInDock = !!this.dockLayout_.findPanelRegion(desc.id);
+ const isPinned = this.dockLayout_.isPanelPinned(desc.id);
+
+ if (matches && !isInDock) {
+ this.dockLayout_.showPanel(desc.id);
+ this.activeContextPanels_.add(desc.id);
+ if (!this.dockLayout_.isRegionCollapsed('bottom')) {
+ this.dockLayout_.dock?.activatePanel(desc.id);
+ } else {
+ this.expandBottomRegion_(desc.id);
+ }
+ } else if (!matches && isInDock && !isPinned && this.activeContextPanels_.has(desc.id)) {
+ this.dockLayout_.removePanel(desc.id);
+ this.activeContextPanels_.delete(desc.id);
+ this.notifyToggleListeners_();
+ }
+ }
+ }
+
+ // =========================================================================
+ // Panel visibility
// =========================================================================
showPanel(id: string): void {
@@ -75,6 +119,17 @@ export class NavigationService {
return;
}
+ const desc = getPanel(id);
+ if (desc?.contextMatch) {
+ const isInDock = !!this.dockLayout_?.findPanelRegion(id);
+ if (!isInDock) {
+ this.dockLayout_?.setPanelPinned(id, true);
+ } else {
+ this.dockLayout_?.setPanelPinned(id, false);
+ this.activeContextPanels_.delete(id);
+ }
+ }
+
if (region === 'bottom') {
this.toggleBottomPanel_(id);
} else {
diff --git a/editor/src/store/EditorStore.ts b/editor/src/store/EditorStore.ts
index 59c3180c7..0660cad2e 100644
--- a/editor/src/store/EditorStore.ts
+++ b/editor/src/store/EditorStore.ts
@@ -107,8 +107,10 @@ export class EditorStore {
private autoSaveTimer_: ReturnType<typeof setInterval> | null = null;
- private tileBrushSelectedTileId_ = 1;
- private tileBrushMode_: 'paint' | 'erase' = 'paint';
+ private tileBrushTool_: 'paint' | 'rect-fill' | 'bucket-fill' | 'eraser' | 'picker' = 'paint';
+ private tileBrushStamp_: { width: number; height: number; tiles: number[] } = { width: 1, height: 1, tiles: [1] };
+ private tileBrushFlipH_ = false;
+ private tileBrushFlipV_ = false;
private requestedGizmoId_: string | null = null;
private readonly selection_: SelectionService;
@@ -193,20 +195,43 @@ export class EditorStore {
return this.prefabEdit_.isEditingPrefab;
}
- get tileBrushSelectedTileId(): number {
- return this.tileBrushSelectedTileId_;
+ get tileBrushTool(): 'paint' | 'rect-fill' | 'bucket-fill' | 'eraser' | 'picker' {
+ return this.tileBrushTool_;
}
- set tileBrushSelectedTileId(id: number) {
- this.tileBrushSelectedTileId_ = id;
+ set tileBrushTool(tool: 'paint' | 'rect-fill' | 'bucket-fill' | 'eraser' | 'picker') {
+ if (this.tileBrushTool_ === tool) return;
+ this.tileBrushTool_ = tool;
+ this.notify();
}
- get tileBrushMode(): 'paint' | 'erase' {
- return this.tileBrushMode_;
+ get tileBrushStamp(): Readonly<{ width: number; height: number; tiles: number[] }> {
+ return this.tileBrushStamp_;
}
- set tileBrushMode(mode: 'paint' | 'erase') {
- this.tileBrushMode_ = mode;
+ set tileBrushStamp(stamp: { width: number; height: number; tiles: number[] }) {
+ this.tileBrushStamp_ = stamp;
+ this.notify();
+ }
+
+ get tileBrushFlipH(): boolean {
+ return this.tileBrushFlipH_;
+ }
+
+ set tileBrushFlipH(v: boolean) {
+ if (this.tileBrushFlipH_ === v) return;
+ this.tileBrushFlipH_ = v;
+ this.notify();
+ }
+
+ get tileBrushFlipV(): boolean {
+ return this.tileBrushFlipV_;
+ }
+
+ set tileBrushFlipV(v: boolean) {
+ if (this.tileBrushFlipV_ === v) return;
+ this.tileBrushFlipV_ = v;
+ this.notify();
}
consumeRequestedGizmoId(): string | null {
diff --git a/editor/src/styles/base.css b/editor/src/styles/base.css
index a0b626331..32a7605ec 100644
--- a/editor/src/styles/base.css
+++ b/editor/src/styles/base.css
@@ -25,7 +25,7 @@
--es-text-muted: hsl(220, 5%, 42%);
--es-text-disabled: hsl(220, 4%, 32%);
- /* Accent (Unity-style blue) */
+ /* Accent */
--es-accent: hsl(215, 80%, 56%);
--es-accent-hover: hsl(215, 80%, 64%);
--es-accent-pressed: hsl(215, 80%, 48%);
diff --git a/editor/src/utils/icons.ts b/editor/src/utils/icons.ts
index 9541b46ac..dbc6f3dc1 100644
--- a/editor/src/utils/icons.ts
+++ b/editor/src/utils/icons.ts
@@ -82,6 +82,12 @@ import {
Info,
TriangleAlert,
PanelLeft,
+ FlipHorizontal2,
+ FlipVertical2,
+ Pipette,
+ PaintBucket,
+ Eraser,
+ RectangleHorizontal,
} from 'lucide';
// =============================================================================
@@ -220,6 +226,12 @@ export const icons = {
grip: (size?: number) => renderIcon(GripVertical as IconNode, size),
info: (size?: number) => renderIcon(Info as IconNode, size),
alertTriangle: (size?: number) => renderIcon(TriangleAlert as IconNode, size),
+ flipHorizontal: (size?: number) => renderIcon(FlipHorizontal2 as IconNode, size),
+ flipVertical: (size?: number) => renderIcon(FlipVertical2 as IconNode, size),
+ pipette: (size?: number) => renderIcon(Pipette as IconNode, size),
+ paintBucket: (size?: number) => renderIcon(PaintBucket as IconNode, size),
+ eraser: (size?: number) => renderIcon(Eraser as IconNode, size),
+ rectFill: (size?: number) => renderIcon(RectangleHorizontal as IconNode, size),
};
export type IconName = keyof typeof icons;
diff --git a/sdk/src/tilemap/components.ts b/sdk/src/tilemap/components.ts
index 3dcd0c416..98264adfc 100644
--- a/sdk/src/tilemap/components.ts
+++ b/sdk/src/tilemap/components.ts
@@ -13,6 +13,8 @@ export interface TilemapLayerData {
tilesetColumns: number;
layer: number;
tiles: number[];
+ infinite: boolean;
+ chunks: Record<string, number[]>;
tint: { r: number; g: number; b: number; a: number };
opacity: number;
visible: boolean;
@@ -32,6 +34,8 @@ export const TilemapLayer = defineComponent<TilemapLayerData>('TilemapLayer', {
tilesetColumns: 1,
layer: 0,
tiles: [],
+ infinite: false,
+ chunks: {},
tint: { r: 1, g: 1, b: 1, a: 1 },
opacity: 1,
visible: true,
diff --git a/sdk/src/tilemap/tilemapPlugin.ts b/sdk/src/tilemap/tilemapPlugin.ts
index d016a048a..13553f1e5 100644
--- a/sdk/src/tilemap/tilemapPlugin.ts
+++ b/sdk/src/tilemap/tilemapPlugin.ts
@@ -73,18 +73,34 @@ export class TilemapPlugin implements Plugin {
if (!dims) continue;
if (!initializedLayers.has(entity)) {
- TilemapAPI.initLayer(
- entity, layerData.width, layerData.height,
- layerData.tileWidth, layerData.tileHeight,
- );
- TilemapAPI.setOriginEntity(entity, entity);
- if (layerData.tiles.length > 0) {
- const u16 = new Uint16Array(layerData.tiles.length);
- for (let i = 0; i < layerData.tiles.length; i++) {
- u16[i] = layerData.tiles[i];
+ if (layerData.infinite) {
+ TilemapAPI.initInfiniteLayer(
+ entity, layerData.tileWidth, layerData.tileHeight,
+ );
+ if (layerData.chunks) {
+ for (const [key, tiles] of Object.entries(layerData.chunks)) {
+ const [cxStr, cyStr] = key.split(',');
+ const cx = parseInt(cxStr, 10);
+ const cy = parseInt(cyStr, 10);
+ const u16 = new Uint16Array(tiles.length);
+ for (let i = 0; i < tiles.length; i++) u16[i] = tiles[i];
+ TilemapAPI.setChunkTiles(entity, cx, cy, u16, 16, 16);
+ }
+ }
+ } else {
+ TilemapAPI.initLayer(
+ entity, layerData.width, layerData.height,
+ layerData.tileWidth, layerData.tileHeight,
+ );
+ if (layerData.tiles.length > 0) {
+ const u16 = new Uint16Array(layerData.tiles.length);
+ for (let i = 0; i < layerData.tiles.length; i++) {
+ u16[i] = layerData.tiles[i];
+ }
+ TilemapAPI.setTiles(entity, u16);
}
- TilemapAPI.setTiles(entity, u16);
}
+ TilemapAPI.setOriginEntity(entity, entity);
initializedLayers.add(entity);
}