A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
feat: implement tilemap editor v2 with complete editing system
esengine1c858f023def
diff --git a/editor/src/DockLayoutManager.ts b/editor/src/DockLayoutManager.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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: BuiltdefaultVisible: 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: Builtorder: 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: BuiltdefaultVisible: 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.cssindex 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.tsindex 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.tsindex 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.tsindex 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);}