Agent Zero
1174 lines
41 KiB
TypeScript
1174 lines
41 KiB
TypeScript
import type { CADElement, ElementType, ToolType } from '../types/cad.types';
|
||
import { ZoomPanController } from '../canvas/ZoomPanController';
|
||
import { RenderEngine } from '../canvas/RenderEngine';
|
||
import { SnapEngine } from '../canvas/SnapEngine';
|
||
import { SelectionEngine } from '../canvas/SelectionEngine';
|
||
import { SpatialIndex } from '../canvas/SpatialIndex';
|
||
import { LayerManager } from '../canvas/LayerManager';
|
||
import { GroupManager } from '../tools/modification/GroupTool';
|
||
import { moveElement, rotateElement, scaleElement, mirrorElement, offsetElement, trimElement, extendElement, filletElements, distance, angleBetween } from '../tools/modification/geometry';
|
||
import { SeatingService, SEATING_TEMPLATES } from '../services/seatingService';
|
||
import { DimensionService } from '../services/dimensionService';
|
||
import { formatDistance, type UnitType } from '../utils/format';
|
||
|
||
export type ToolPhase = 'idle' | 'drawing' | 'modifying' | 'panning' | 'selecting';
|
||
|
||
export interface ToolState {
|
||
activeTool: ToolType;
|
||
phase: ToolPhase;
|
||
points: Array<{ x: number; y: number }>; // accumulated world points for current operation
|
||
previewElement: CADElement | null; // temporary element being drawn
|
||
ortho: boolean;
|
||
snapEnabled: boolean;
|
||
}
|
||
|
||
export interface InteractionConfig {
|
||
orthoKey: string; // F8
|
||
snapToggleKey: string; // F3
|
||
escapeKey: string;
|
||
deleteKey: string;
|
||
selectAllKey: string;
|
||
undoKey: string;
|
||
redoKey: string;
|
||
}
|
||
|
||
export class InteractionEngine {
|
||
private canvas: HTMLCanvasElement;
|
||
private zoomPan: ZoomPanController;
|
||
private renderEngine: RenderEngine;
|
||
private snapEngine: SnapEngine;
|
||
private selectionEngine: SelectionEngine;
|
||
private spatialIndex: SpatialIndex;
|
||
private layerManager: LayerManager;
|
||
private state: ToolState;
|
||
private config: InteractionConfig;
|
||
private selectedTemplate: string | null = null;
|
||
private allElements: CADElement[] = [];
|
||
private groupManager: GroupManager | null = null;
|
||
private isMouseDown = false;
|
||
private isRightDown = false;
|
||
private lastMouseScreen = { x: 0, y: 0 };
|
||
private eventListeners: Array<{ type: string; fn: EventListener }> = [];
|
||
private onElementCreated?: (el: CADElement) => void;
|
||
private onElementsDeleted?: (ids: string[]) => void;
|
||
private onElementsModified?: (els: CADElement[]) => void;
|
||
private onToolStateChanged?: (state: ToolState) => void;
|
||
private onCursorMoved?: (worldX: number, worldY: number) => void;
|
||
private onCommandTrigger?: (cmd: string) => void;
|
||
private onTextEdit?: (el: CADElement) => void;
|
||
private onSelectionChange?: (selectedIds: string[]) => void;
|
||
private animationFrame: number | null = null;
|
||
private boundKeyDown: EventListener;
|
||
private boundMouseMove: EventListener;
|
||
private boundMouseUp: EventListener;
|
||
private boundPointerCancel: EventListener;
|
||
private unit: UnitType = 'mm';
|
||
private scaleFactor: number = 1;
|
||
|
||
constructor(
|
||
canvas: HTMLCanvasElement,
|
||
zoomPan: ZoomPanController,
|
||
renderEngine: RenderEngine,
|
||
snapEngine: SnapEngine,
|
||
selectionEngine: SelectionEngine,
|
||
spatialIndex: SpatialIndex,
|
||
layerManager: LayerManager,
|
||
) {
|
||
this.canvas = canvas;
|
||
this.zoomPan = zoomPan;
|
||
this.renderEngine = renderEngine;
|
||
this.snapEngine = snapEngine;
|
||
this.selectionEngine = selectionEngine;
|
||
this.spatialIndex = spatialIndex;
|
||
this.layerManager = layerManager;
|
||
this.state = {
|
||
activeTool: 'select',
|
||
phase: 'idle',
|
||
points: [],
|
||
previewElement: null,
|
||
ortho: false,
|
||
snapEnabled: true,
|
||
};
|
||
this.config = {
|
||
orthoKey: 'F8',
|
||
snapToggleKey: 'F3',
|
||
escapeKey: 'Escape',
|
||
deleteKey: 'Delete',
|
||
selectAllKey: 'a',
|
||
undoKey: 'z',
|
||
redoKey: 'y',
|
||
};
|
||
this.boundKeyDown = this.onKeyDown.bind(this) as EventListener;
|
||
this.boundMouseMove = this.onMouseMove.bind(this) as EventListener;
|
||
this.boundMouseUp = this.onMouseUp.bind(this) as EventListener;
|
||
this.boundPointerCancel = this.onMouseUp.bind(this) as EventListener;
|
||
}
|
||
|
||
setElements(elements: CADElement[]): void {
|
||
this.allElements = elements;
|
||
this.snapEngine.setElements(elements);
|
||
}
|
||
|
||
setGroupManager(gm: GroupManager | null): void {
|
||
this.groupManager = gm;
|
||
}
|
||
|
||
setSnapEnabled(enabled: boolean): void {
|
||
this.state.snapEnabled = enabled;
|
||
}
|
||
|
||
setOrthoEnabled(enabled: boolean): void {
|
||
this.state.ortho = enabled;
|
||
}
|
||
|
||
setUnits(unit: UnitType, scaleFactor: number): void {
|
||
this.unit = unit;
|
||
this.scaleFactor = scaleFactor;
|
||
}
|
||
|
||
setGridSize(gridSize: number): void {
|
||
this.snapEngine.setConfig({ gridSpacing: gridSize });
|
||
}
|
||
|
||
setPolarEnabled(enabled: boolean): void {
|
||
this.snapEngine.setConfig({ polarEnabled: enabled });
|
||
}
|
||
|
||
setSelectedTemplate(templateName: string | null): void {
|
||
this.selectedTemplate = templateName;
|
||
}
|
||
|
||
setTool(tool: ToolType): void {
|
||
this.state.activeTool = tool;
|
||
this.state.phase = 'idle';
|
||
this.state.points = [];
|
||
this.state.previewElement = null;
|
||
const drawingTools: ToolType[] = ['line', 'rect', 'circle', 'arc', 'polyline', 'polygon', 'revcloud', 'text', 'dimension', 'leader', 'chair', 'seating-row', 'seating-block', 'table', 'stage', 'seating-template', 'hatch'];
|
||
if (drawingTools.includes(tool)) {
|
||
this.selectionEngine.clearSelection();
|
||
this.emitSelectionChange();
|
||
}
|
||
this.notifyToolStateChanged();
|
||
this.requestRender();
|
||
}
|
||
|
||
getToolState(): ToolState {
|
||
return { ...this.state, points: [...this.state.points] };
|
||
}
|
||
|
||
setCallbacks(callbacks: {
|
||
onElementCreated?: (el: CADElement) => void;
|
||
onElementsDeleted?: (ids: string[]) => void;
|
||
onElementsModified?: (els: CADElement[]) => void;
|
||
onToolStateChanged?: (state: ToolState) => void;
|
||
onCursorMoved?: (worldX: number, worldY: number) => void;
|
||
onCommandTrigger?: (cmd: string) => void;
|
||
onTextEdit?: (el: CADElement) => void;
|
||
onSelectionChange?: (selectedIds: string[]) => void;
|
||
}): void {
|
||
this.onElementCreated = callbacks.onElementCreated;
|
||
this.onElementsDeleted = callbacks.onElementsDeleted;
|
||
this.onElementsModified = callbacks.onElementsModified;
|
||
this.onToolStateChanged = callbacks.onToolStateChanged;
|
||
this.onCursorMoved = callbacks.onCursorMoved;
|
||
this.onCommandTrigger = callbacks.onCommandTrigger;
|
||
this.onTextEdit = callbacks.onTextEdit;
|
||
this.onSelectionChange = callbacks.onSelectionChange;
|
||
}
|
||
|
||
private emitSelectionChange(): void {
|
||
if (this.onSelectionChange) {
|
||
this.onSelectionChange(Array.from(this.selectionEngine.getSelectedIds()));
|
||
}
|
||
}
|
||
|
||
attach(): void {
|
||
this.addListener('pointerdown', this.onMouseDown.bind(this) as EventListener);
|
||
document.addEventListener('pointermove', this.boundMouseMove);
|
||
document.addEventListener('pointerup', this.boundMouseUp);
|
||
document.addEventListener('pointercancel', this.boundPointerCancel);
|
||
this.addListener('dblclick', this.onDoubleClick.bind(this) as EventListener);
|
||
this.addListener('wheel', this.onWheel.bind(this) as EventListener, { passive: false } as AddEventListenerOptions);
|
||
this.addListener('contextmenu', this.onContextMenu.bind(this) as EventListener);
|
||
document.addEventListener('keydown', this.boundKeyDown);
|
||
}
|
||
|
||
detach(): void {
|
||
for (const { type, fn } of this.eventListeners) {
|
||
this.canvas.removeEventListener(type, fn);
|
||
}
|
||
this.eventListeners = [];
|
||
document.removeEventListener('pointermove', this.boundMouseMove);
|
||
document.removeEventListener('pointerup', this.boundMouseUp);
|
||
document.removeEventListener('pointercancel', this.boundPointerCancel);
|
||
document.removeEventListener('keydown', this.boundKeyDown);
|
||
if (this.animationFrame !== null) {
|
||
cancelAnimationFrame(this.animationFrame);
|
||
this.animationFrame = null;
|
||
}
|
||
}
|
||
|
||
private addListener(type: string, fn: EventListener, options?: AddEventListenerOptions): void {
|
||
this.canvas.addEventListener(type, fn, options);
|
||
this.eventListeners.push({ type, fn });
|
||
}
|
||
|
||
private getWorldCoords(e: MouseEvent): { x: number; y: number } {
|
||
return this.zoomPan.screenToWorld(e.clientX, e.clientY);
|
||
}
|
||
|
||
private applySnap(x: number, y: number): { x: number; y: number } {
|
||
if (!this.state.snapEnabled) return { x, y };
|
||
// Pass last point as reference for polar tracking
|
||
const refPoint = this.state.points.length > 0 ? this.state.points[this.state.points.length - 1] : undefined;
|
||
const result = this.snapEngine.snap(x, y, refPoint);
|
||
if (result.point) {
|
||
this.renderEngine.setSnapPoints(result.preview);
|
||
this.renderEngine.setActiveSnapPoint(result.point);
|
||
return { x: result.point.x, y: result.point.y };
|
||
}
|
||
this.renderEngine.setSnapPoints([]);
|
||
this.renderEngine.setActiveSnapPoint(null);
|
||
return { x, y };
|
||
}
|
||
|
||
private applyOrtho(x: number, y: number): { x: number; y: number } {
|
||
if (!this.state.ortho || this.state.points.length === 0) return { x, y };
|
||
const last = this.state.points[this.state.points.length - 1];
|
||
const dx = x - last.x;
|
||
const dy = y - last.y;
|
||
if (Math.abs(dx) > Math.abs(dy)) {
|
||
return { x, y: last.y };
|
||
} else {
|
||
return { x: last.x, y };
|
||
}
|
||
}
|
||
|
||
private onMouseDown(e: MouseEvent): void {
|
||
try { this.canvas.setPointerCapture((e as any).pointerId); } catch {}
|
||
this.isMouseDown = true;
|
||
this.lastMouseScreen = { x: e.clientX, y: e.clientY };
|
||
|
||
if (e.button === 2) {
|
||
this.isRightDown = true;
|
||
this.state.phase = 'panning';
|
||
return;
|
||
}
|
||
|
||
if (e.button === 1 || this.state.activeTool === 'pan') {
|
||
this.state.phase = 'panning';
|
||
return;
|
||
}
|
||
|
||
const raw = this.getWorldCoords(e);
|
||
const snapped = this.applySnap(raw.x, raw.y);
|
||
const final = this.applyOrtho(snapped.x, snapped.y);
|
||
|
||
switch (this.state.activeTool) {
|
||
case 'select':
|
||
this.handleSelectDown(e, raw);
|
||
break;
|
||
case 'line':
|
||
case 'polyline':
|
||
case 'rect':
|
||
case 'circle':
|
||
case 'arc':
|
||
case 'polygon':
|
||
case 'text':
|
||
case 'dimension':
|
||
case 'leader':
|
||
this.handleDrawDown(final);
|
||
break;
|
||
case 'revcloud':
|
||
this.handleDrawDown(final);
|
||
break;
|
||
case 'chair':
|
||
case 'seating-row':
|
||
case 'seating-block':
|
||
case 'table':
|
||
case 'stage':
|
||
case 'seating-template':
|
||
this.handlePlaceDown(final);
|
||
break;
|
||
case 'hatch':
|
||
this.handleHatchDown(final);
|
||
break;
|
||
case 'measure':
|
||
this.handleMeasureDown(final);
|
||
break;
|
||
case 'move':
|
||
case 'copy':
|
||
case 'rotate':
|
||
case 'scale':
|
||
case 'mirror':
|
||
case 'trim':
|
||
case 'extend':
|
||
case 'fillet':
|
||
case 'offset':
|
||
this.handleModifyDown(final);
|
||
break;
|
||
case 'delete':
|
||
this.handleDeleteDown(raw);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
this.requestRender();
|
||
}
|
||
|
||
private onMouseMove(e: MouseEvent): void {
|
||
if (this.state.phase === 'idle' && !this.isMouseDown) {
|
||
const rect = this.canvas.getBoundingClientRect();
|
||
if (e.clientX < rect.left || e.clientX > rect.right || e.clientY < rect.top || e.clientY > rect.bottom) return;
|
||
}
|
||
this.lastMouseScreen = { x: e.clientX, y: e.clientY };
|
||
const raw = this.getWorldCoords(e);
|
||
this.onCursorMoved?.(raw.x, raw.y);
|
||
|
||
if (this.state.phase === 'panning') {
|
||
const dx = e.movementX;
|
||
const dy = e.movementY;
|
||
this.zoomPan.pan(dx, dy);
|
||
this.requestRender();
|
||
return;
|
||
}
|
||
|
||
const snapped = this.applySnap(raw.x, raw.y);
|
||
const final = this.applyOrtho(snapped.x, snapped.y);
|
||
|
||
// Hover detection for select tool
|
||
if (this.state.activeTool === 'select' && this.state.phase === 'idle') {
|
||
const hit = this.renderEngine.hitTest(raw.x, raw.y, 5);
|
||
this.selectionEngine.setHover(hit?.id ?? null);
|
||
}
|
||
|
||
// Update preview during drawing
|
||
if (this.state.phase === 'drawing' && this.state.points.length > 0) {
|
||
this.updatePreview(final);
|
||
}
|
||
|
||
// Update preview during modification
|
||
if (this.state.phase === 'modifying' && this.state.points.length > 0) {
|
||
this.updateModifyPreview(final);
|
||
}
|
||
|
||
// Update box selection
|
||
if (this.selectionEngine.isBoxSelecting()) {
|
||
this.selectionEngine.updateBoxSelect(raw.x, raw.y, this.allElements);
|
||
}
|
||
|
||
this.requestRender();
|
||
}
|
||
|
||
private onMouseUp(e: MouseEvent): void {
|
||
try { this.canvas.releasePointerCapture((e as any).pointerId); } catch {}
|
||
this.isMouseDown = false;
|
||
|
||
if (e.button === 2 || (e.button === 1 && this.state.phase === 'panning')) {
|
||
this.isRightDown = false;
|
||
this.state.phase = this.state.activeTool === 'pan' ? 'idle' : 'idle';
|
||
this.requestRender();
|
||
return;
|
||
}
|
||
|
||
if (this.state.phase === 'panning') {
|
||
this.state.phase = 'idle';
|
||
this.requestRender();
|
||
return;
|
||
}
|
||
|
||
// Move/Copy/Rotate/Scale: confirm on mouseUp (press-drag-release)
|
||
if (this.state.phase === 'modifying' && this.state.points.length >= 1) {
|
||
const tool = this.state.activeTool;
|
||
if (tool === 'move' || tool === 'copy' || tool === 'rotate' || tool === 'scale') {
|
||
const raw = this.getWorldCoords(e);
|
||
const snapped = this.applySnap(raw.x, raw.y);
|
||
const final = this.applyOrtho(snapped.x, snapped.y);
|
||
this.confirmModify(final);
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (this.state.activeTool === 'select' && this.selectionEngine.isBoxSelecting()) {
|
||
if (this.selectionEngine.hasBoxMoved()) {
|
||
this.selectionEngine.finishBoxSelect(this.allElements);
|
||
this.emitSelectionChange();
|
||
} else {
|
||
// No drag movement — cancel box select (it was just a click, already handled by clickSelect)
|
||
this.selectionEngine.cancelBoxSelect();
|
||
}
|
||
this.requestRender();
|
||
return;
|
||
}
|
||
|
||
// Click-drag: confirm draw on mouseup for 2-point tools
|
||
if (this.state.phase === 'drawing' && this.state.points.length >= 1) {
|
||
const raw = this.getWorldCoords(e);
|
||
const snapped = this.applySnap(raw.x, raw.y);
|
||
const final = this.applyOrtho(snapped.x, snapped.y);
|
||
const tool = this.state.activeTool;
|
||
// For 2-point tools: use mouseup position as second point
|
||
if (tool === 'line' || tool === 'rect' || tool === 'circle' || tool === 'dimension' || tool === 'leader' || tool === 'arc' || tool === 'polygon' || tool === 'revcloud') {
|
||
this.state.points.push(final);
|
||
this.confirmDraw();
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
private onWheel(e: WheelEvent): void {
|
||
e.preventDefault();
|
||
const factor = e.deltaY > 0 ? 0.9 : 1.1;
|
||
const rect = this.canvas.getBoundingClientRect();
|
||
const cx = e.clientX - rect.left;
|
||
const cy = e.clientY - rect.top;
|
||
this.zoomPan.zoomAt(cx, cy, factor);
|
||
this.requestRender();
|
||
}
|
||
|
||
private onContextMenu(e: MouseEvent): void {
|
||
e.preventDefault();
|
||
}
|
||
|
||
private onDoubleClick(e: MouseEvent): void {
|
||
e.preventDefault();
|
||
if (
|
||
(this.state.activeTool === 'polyline' || this.state.activeTool === 'polygon' || this.state.activeTool === 'revcloud') &&
|
||
this.state.phase === 'drawing' &&
|
||
this.state.points.length >= 2
|
||
) {
|
||
this.confirmDraw();
|
||
}
|
||
}
|
||
|
||
private onKeyDown(e: KeyboardEvent): void {
|
||
// Tool-independent keys
|
||
if (e.key === this.config.escapeKey) {
|
||
this.cancelCurrentOperation();
|
||
return;
|
||
}
|
||
if (e.key === this.config.orthoKey) {
|
||
this.state.ortho = !this.state.ortho;
|
||
this.renderEngine.setOptions({ showOrtho: this.state.ortho });
|
||
this.notifyToolStateChanged();
|
||
this.requestRender();
|
||
return;
|
||
}
|
||
if (e.key === this.config.snapToggleKey) {
|
||
this.state.snapEnabled = !this.state.snapEnabled;
|
||
this.renderEngine.setOptions({ showSnapPoints: this.state.snapEnabled });
|
||
this.notifyToolStateChanged();
|
||
this.requestRender();
|
||
return;
|
||
}
|
||
if (e.key === this.config.deleteKey && this.state.activeTool === 'select') {
|
||
const ids = Array.from(this.selectionEngine.getSelectedIds());
|
||
if (ids.length > 0) {
|
||
this.onElementsDeleted?.(ids);
|
||
}
|
||
return;
|
||
}
|
||
|
||
// G = Group selected elements
|
||
if (e.key === 'g' && !e.ctrlKey && !e.metaKey && this.state.activeTool === 'select') {
|
||
const ids = Array.from(this.selectionEngine.getSelectedIds());
|
||
if (ids.length >= 2) {
|
||
this.onCommandTrigger?.('group');
|
||
}
|
||
return;
|
||
}
|
||
|
||
// Ctrl+G = Ungroup
|
||
if ((e.ctrlKey || e.metaKey) && e.key === 'g' && this.state.activeTool === 'select') {
|
||
e.preventDefault();
|
||
this.onCommandTrigger?.('ungroup');
|
||
return;
|
||
}
|
||
|
||
// Ctrl+A = select all
|
||
if ((e.ctrlKey || e.metaKey) && e.key === this.config.selectAllKey) {
|
||
e.preventDefault();
|
||
this.selectionEngine.selectAll(this.allElements);
|
||
this.emitSelectionChange();
|
||
this.requestRender();
|
||
return;
|
||
}
|
||
|
||
// Ctrl+Z = undo (delegated to app)
|
||
if ((e.ctrlKey || e.metaKey) && e.key === this.config.undoKey) {
|
||
e.preventDefault();
|
||
this.onCommandTrigger?.('undo');
|
||
return;
|
||
}
|
||
|
||
// Ctrl+Y = redo
|
||
if ((e.ctrlKey || e.metaKey) && e.key === this.config.redoKey) {
|
||
e.preventDefault();
|
||
this.onCommandTrigger?.('redo');
|
||
return;
|
||
}
|
||
|
||
// Enter = confirm current operation
|
||
if (e.key === 'Enter' && this.state.phase === 'drawing') {
|
||
this.confirmDraw();
|
||
return;
|
||
}
|
||
|
||
// Enter = confirm modification with current cursor position
|
||
if (e.key === 'Enter' && this.state.phase === 'modifying') {
|
||
const world = this.zoomPan.screenToWorld(this.lastMouseScreen.x, this.lastMouseScreen.y);
|
||
this.confirmModify(world);
|
||
return;
|
||
}
|
||
|
||
// Space = pan toggle (hold)
|
||
if (e.key === ' ' && this.state.activeTool !== 'pan') {
|
||
e.preventDefault();
|
||
// Temporary pan — could implement hold-to-pan
|
||
return;
|
||
}
|
||
}
|
||
|
||
// --- Tool handlers ---
|
||
|
||
private handleSelectDown(e: MouseEvent, world: { x: number; y: number }): void {
|
||
const additive = e.shiftKey;
|
||
const subtractive = e.ctrlKey || e.metaKey;
|
||
this.selectionEngine.setOptions({ additive, subtractive });
|
||
|
||
if (!additive && !subtractive) {
|
||
// Hit test first: if an object is clicked, select it directly
|
||
const hit = this.renderEngine.hitTest(world.x, world.y, 5);
|
||
if (hit) {
|
||
// Group-aware click selection: if clicked element is in a group, select all group members
|
||
if (this.groupManager) {
|
||
const groupElements = this.groupManager.getGroupElements(hit.id);
|
||
if (groupElements.length > 1) {
|
||
this.selectionEngine.selectByIds(groupElements, false);
|
||
this.emitSelectionChange();
|
||
return;
|
||
}
|
||
}
|
||
this.selectionEngine.clickSelect(world.x, world.y, this.allElements);
|
||
this.emitSelectionChange();
|
||
} else {
|
||
// No object hit: start potential box select for drag
|
||
this.selectionEngine.startBoxSelect(world.x, world.y);
|
||
}
|
||
} else {
|
||
// Group-aware click selection: if clicked element is in a group, select all group members
|
||
const hit = this.renderEngine.hitTest(world.x, world.y, 5);
|
||
if (hit && this.groupManager) {
|
||
const groupElements = this.groupManager.getGroupElements(hit.id);
|
||
if (groupElements.length > 1) {
|
||
if (subtractive) {
|
||
// Remove all group elements from selection
|
||
const currentIds = Array.from(this.selectionEngine.getSelectedIds());
|
||
const filtered = currentIds.filter(id => !groupElements.includes(id));
|
||
this.selectionEngine.selectByIds(filtered, false);
|
||
} else {
|
||
this.selectionEngine.selectByIds(groupElements, !additive ? false : true);
|
||
}
|
||
this.emitSelectionChange();
|
||
return;
|
||
}
|
||
}
|
||
this.selectionEngine.clickSelect(world.x, world.y, this.allElements);
|
||
this.emitSelectionChange();
|
||
}
|
||
}
|
||
|
||
private handleDrawDown(pt: { x: number; y: number }): void {
|
||
// Clear any previous points when starting a new draw operation
|
||
if (this.state.points.length === 0) {
|
||
this.state.phase = 'drawing';
|
||
}
|
||
this.state.points.push(pt);
|
||
|
||
// Arc: auto-confirm after 3 points (center, start, end)
|
||
if (this.state.activeTool === 'arc' && this.state.points.length >= 3) {
|
||
this.confirmDraw();
|
||
return;
|
||
}
|
||
|
||
// Text: single click placement, then prompt for text content
|
||
if (this.state.activeTool === 'text') {
|
||
this.updatePreview(pt);
|
||
this.confirmDraw();
|
||
return;
|
||
}
|
||
|
||
// Line, rect, circle, dimension, leader: wait for mouseup (click-drag behavior)
|
||
// Points are collected on mousedown, confirmed on mouseup
|
||
|
||
this.updatePreview(pt);
|
||
this.notifyToolStateChanged();
|
||
}
|
||
|
||
private handlePlaceDown(pt: { x: number; y: number }): void {
|
||
const tool = this.state.activeTool;
|
||
const layerId = this.layerManager.getActiveLayerId();
|
||
const seating = new SeatingService();
|
||
|
||
switch (tool) {
|
||
case 'chair': {
|
||
const el = seating.createChair(pt.x, pt.y, layerId);
|
||
this.onElementCreated?.(el);
|
||
break;
|
||
}
|
||
case 'seating-row': {
|
||
const els = seating.createSeatingRow(pt.x, pt.y, layerId);
|
||
for (const el of els) this.onElementCreated?.(el);
|
||
this.onCommandTrigger?.(`Reihe mit ${els.length} Stühlen erstellt`);
|
||
break;
|
||
}
|
||
case 'seating-block': {
|
||
const els = seating.createSeatingBlock(pt.x, pt.y, layerId);
|
||
for (const el of els) this.onElementCreated?.(el);
|
||
this.onCommandTrigger?.(`Block mit ${els.length} Stühlen erstellt`);
|
||
break;
|
||
}
|
||
case 'table': {
|
||
const el = seating.createTable(pt.x, pt.y, layerId);
|
||
this.onElementCreated?.(el);
|
||
break;
|
||
}
|
||
case 'stage': {
|
||
const el = seating.createStage(pt.x, pt.y, layerId);
|
||
this.onElementCreated?.(el);
|
||
break;
|
||
}
|
||
case 'seating-template': {
|
||
if (this.selectedTemplate) {
|
||
const els = seating.createFromTemplate(this.selectedTemplate, pt.x, pt.y, layerId);
|
||
for (const el of els) this.onElementCreated?.(el);
|
||
this.onCommandTrigger?.(`Vorlage "${this.selectedTemplate}" platziert: ${els.length} Elemente`);
|
||
} else {
|
||
this.onCommandTrigger?.('Keine Vorlage ausgewählt – bitte in der Seitenleiste wählen');
|
||
}
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
this.requestRender();
|
||
}
|
||
|
||
private handleHatchDown(pt: { x: number; y: number }): void {
|
||
// Hatch: select a closed boundary element, then apply hatch pattern
|
||
const hit = this.renderEngine.hitTest(pt.x, pt.y, 5);
|
||
if (hit && (hit.type === 'rect' || hit.type === 'circle' || hit.type === 'polygon')) {
|
||
const updated: CADElement = {
|
||
...hit,
|
||
properties: { ...hit.properties, hatch: true, hatchPattern: 'lines', hatchSpacing: 8 },
|
||
};
|
||
this.onElementsModified?.([updated]);
|
||
}
|
||
this.requestRender();
|
||
}
|
||
|
||
private handleMeasureDown(pt: { x: number; y: number }): void {
|
||
// Measure: two clicks, display distance
|
||
if (this.state.points.length === 0) {
|
||
this.state.points.push(pt);
|
||
this.state.phase = 'drawing';
|
||
this.onCommandTrigger?.('measure: click end point');
|
||
} else {
|
||
const first = this.state.points[0];
|
||
const rawDist = Math.sqrt((pt.x - first.x) ** 2 + (pt.y - first.y) ** 2);
|
||
const angle = (Math.atan2(pt.y - first.y, pt.x - first.x) * 180) / Math.PI;
|
||
const distStr = formatDistance(rawDist, this.unit, this.scaleFactor);
|
||
this.onCommandTrigger?.(`distance: ${distStr} angle: ${angle.toFixed(1)}°`);
|
||
this.state.points = [];
|
||
this.state.phase = 'idle';
|
||
this.requestRender();
|
||
}
|
||
}
|
||
|
||
private modifySelected: CADElement[] = [];
|
||
private modifyBoundary: CADElement | null = null;
|
||
private modifyFilletRadius = 10;
|
||
|
||
private handleModifyDown(pt: { x: number; y: number }): void {
|
||
const tool = this.state.activeTool;
|
||
|
||
// Trim/Extend/Fillet: first click selects boundary element, not from selection
|
||
if (tool === 'trim' || tool === 'extend') {
|
||
if (this.state.points.length === 0) {
|
||
// First click: select boundary element
|
||
const hit = this.renderEngine.hitTest(pt.x, pt.y, 5);
|
||
if (hit) {
|
||
this.modifyBoundary = hit;
|
||
this.state.phase = 'modifying';
|
||
this.state.points.push(pt);
|
||
this.onCommandTrigger?.(`${tool}: select element to ${tool === 'trim' ? 'trim' : 'extend'}`);
|
||
}
|
||
return;
|
||
}
|
||
// Second click: select element to trim/extend
|
||
const hit = this.renderEngine.hitTest(pt.x, pt.y, 5);
|
||
if (hit && this.modifyBoundary) {
|
||
const fn = tool === 'trim' ? trimElement : extendElement;
|
||
const result = fn(hit, this.modifyBoundary);
|
||
if (result) {
|
||
this.onElementsModified?.([result]);
|
||
}
|
||
this.resetModify();
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (tool === 'fillet') {
|
||
if (this.state.points.length === 0) {
|
||
// First click: select first element
|
||
const hit = this.renderEngine.hitTest(pt.x, pt.y, 5);
|
||
if (hit) {
|
||
this.modifySelected = [hit];
|
||
this.state.phase = 'modifying';
|
||
this.state.points.push(pt);
|
||
this.onCommandTrigger?.('fillet: select second element');
|
||
}
|
||
return;
|
||
}
|
||
if (this.state.points.length === 1) {
|
||
// Second click: select second element
|
||
const hit = this.renderEngine.hitTest(pt.x, pt.y, 5);
|
||
if (hit && this.modifySelected.length === 1) {
|
||
const result = filletElements(this.modifySelected[0], hit, this.modifyFilletRadius);
|
||
if (result) {
|
||
this.onElementsModified?.(result);
|
||
}
|
||
this.resetModify();
|
||
}
|
||
return;
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (tool === 'offset') {
|
||
if (this.state.points.length === 0) {
|
||
// First click: select element to offset
|
||
const hit = this.renderEngine.hitTest(pt.x, pt.y, 5);
|
||
if (hit) {
|
||
this.modifySelected = [hit];
|
||
this.state.phase = 'modifying';
|
||
this.state.points.push(pt);
|
||
this.onCommandTrigger?.('offset: click to set direction and distance');
|
||
}
|
||
return;
|
||
}
|
||
// Second click: direction + distance
|
||
if (this.modifySelected.length === 1) {
|
||
const first = this.state.points[0];
|
||
const dist = distance(first, pt);
|
||
const base = this.modifySelected[0];
|
||
// Seitigkeit bestimmen: Kreuzprodukt der Linienrichtung mit Klickvektor.
|
||
// cross > 0 → Klick links der Laufrichtung (p1→p2) → side=+1, sonst -1.
|
||
let side: 1 | -1 = 1;
|
||
if (base.type === 'line' && base.properties.x1 !== undefined && base.properties.y1 !== undefined) {
|
||
const p1x = base.properties.x1 as number;
|
||
const p1y = base.properties.y1 as number;
|
||
const p2x = base.properties.x2 as number;
|
||
const p2y = base.properties.y2 as number;
|
||
const cross = (p2x - p1x) * (pt.y - p1y) - (p2y - p1y) * (pt.x - p1x);
|
||
side = cross >= 0 ? 1 : -1;
|
||
} else if ((base.type === 'circle' || base.type === 'arc') && base.properties.radius !== undefined) {
|
||
// Kreis/Bogen: Klick außerhalb → vergrößern (+1), innerhalb → verkleinern (-1)
|
||
const clickDist = Math.hypot(pt.x - base.x, pt.y - base.y);
|
||
side = clickDist >= base.properties.radius ? 1 : -1;
|
||
}
|
||
const offsetted = offsetElement(base, dist, side);
|
||
// Create as new element (copy)
|
||
this.onElementCreated?.({ ...offsetted, id: this.generateId() });
|
||
this.resetModify();
|
||
}
|
||
return;
|
||
}
|
||
|
||
// Move/Copy/Rotate/Scale: press-drag-release (kein click-click)
|
||
if (tool === 'move' || tool === 'copy' || tool === 'rotate' || tool === 'scale') {
|
||
if (this.state.phase === 'modifying' && this.state.points.length >= 1) {
|
||
// Zweiter Klick — sollte nicht passieren bei drag-release, aber falls doch: bestätigen
|
||
this.confirmModify(pt);
|
||
return;
|
||
}
|
||
const selected = this.selectionEngine.getSelectedElements(this.allElements);
|
||
if (selected.length === 0) {
|
||
this.onCommandTrigger?.('select-first');
|
||
return;
|
||
}
|
||
this.modifySelected = selected;
|
||
this.state.phase = 'modifying';
|
||
this.state.points.push(pt); // Start-Punkt für drag
|
||
this.notifyToolStateChanged();
|
||
return;
|
||
}
|
||
|
||
// Mirror: click-click (zwei Punkte für die Spiegelungsachse)
|
||
if (this.state.phase === 'modifying' && this.state.points.length >= 1) {
|
||
this.confirmModify(pt);
|
||
return;
|
||
}
|
||
|
||
const selected = this.selectionEngine.getSelectedElements(this.allElements);
|
||
if (selected.length === 0) {
|
||
this.onCommandTrigger?.('select-first');
|
||
return;
|
||
}
|
||
|
||
this.modifySelected = selected;
|
||
this.state.phase = 'modifying';
|
||
this.state.points.push(pt);
|
||
this.notifyToolStateChanged();
|
||
}
|
||
|
||
private updateModifyPreview(pt: { x: number; y: number }): void {
|
||
if (this.modifySelected.length === 0 || this.state.points.length === 0) return;
|
||
const tool = this.state.activeTool;
|
||
const base = this.state.points[0];
|
||
|
||
if (tool === 'move' || tool === 'copy') {
|
||
const dx = pt.x - base.x;
|
||
const dy = pt.y - base.y;
|
||
// Show preview of first selected element moved
|
||
this.state.previewElement = moveElement(this.modifySelected[0], dx, dy);
|
||
} else if (tool === 'rotate') {
|
||
const objCenter = { x: this.modifySelected[0].x, y: this.modifySelected[0].y };
|
||
const startAngle = angleBetween(objCenter, base);
|
||
const currentAngle = angleBetween(objCenter, pt);
|
||
const rotationDelta = currentAngle - startAngle;
|
||
this.state.previewElement = rotateElement(this.modifySelected[0], objCenter.x, objCenter.y, rotationDelta);
|
||
} else if (tool === 'scale') {
|
||
const objCenter = { x: this.modifySelected[0].x, y: this.modifySelected[0].y };
|
||
const startDist = distance(objCenter, base);
|
||
const currentDist = distance(objCenter, pt);
|
||
const factor = startDist > 0 ? currentDist / startDist : 1;
|
||
this.state.previewElement = scaleElement(this.modifySelected[0], objCenter.x, objCenter.y, factor, factor);
|
||
} else if (tool === 'mirror') {
|
||
// Mirror preview: axis from base point to current mouse position
|
||
this.state.previewElement = mirrorElement(this.modifySelected[0], base.x, base.y, pt.x, pt.y);
|
||
}
|
||
}
|
||
|
||
private confirmModify(pt: { x: number; y: number }): void {
|
||
if (this.modifySelected.length === 0 || this.state.points.length === 0) return;
|
||
const tool = this.state.activeTool;
|
||
const base = this.state.points[0];
|
||
|
||
if (tool === 'move') {
|
||
const dx = pt.x - base.x;
|
||
const dy = pt.y - base.y;
|
||
// Group-aware: expand modifySelected to include group members
|
||
let toMove = [...this.modifySelected];
|
||
if (this.groupManager) {
|
||
const additionalGroupEls: CADElement[] = [];
|
||
for (const el of this.modifySelected) {
|
||
const groupEls = this.groupManager.getGroupElements(el.id);
|
||
for (const gid of groupEls) {
|
||
if (!toMove.some(e => e.id === gid)) {
|
||
const found = this.allElements.find(e => e.id === gid);
|
||
if (found) additionalGroupEls.push(found);
|
||
}
|
||
}
|
||
}
|
||
toMove = [...toMove, ...additionalGroupEls];
|
||
}
|
||
const modified = toMove.map(el => moveElement(el, dx, dy));
|
||
this.onElementsModified?.(modified);
|
||
} else if (tool === 'copy') {
|
||
const dx = pt.x - base.x;
|
||
const dy = pt.y - base.y;
|
||
for (const el of this.modifySelected) {
|
||
const copy = moveElement(el, dx, dy);
|
||
this.onElementCreated?.({ ...copy, id: this.generateId() });
|
||
}
|
||
} else if (tool === 'rotate') {
|
||
const objCenter = { x: this.modifySelected[0].x, y: this.modifySelected[0].y };
|
||
const startAngle = angleBetween(objCenter, base);
|
||
const endAngle = angleBetween(objCenter, pt);
|
||
const rotationDelta = endAngle - startAngle;
|
||
const modified = this.modifySelected.map(el => rotateElement(el, objCenter.x, objCenter.y, rotationDelta));
|
||
this.onElementsModified?.(modified);
|
||
} else if (tool === 'scale') {
|
||
const objCenter = { x: this.modifySelected[0].x, y: this.modifySelected[0].y };
|
||
const startDist = distance(objCenter, base);
|
||
const endDist = distance(objCenter, pt);
|
||
const factor = startDist > 0 ? endDist / startDist : 1;
|
||
const modified = this.modifySelected.map(el => scaleElement(el, objCenter.x, objCenter.y, factor, factor));
|
||
this.onElementsModified?.(modified);
|
||
} else if (tool === 'mirror') {
|
||
// Mirror axis: base point (first click) to current point (second click)
|
||
const modified = this.modifySelected.map(el => mirrorElement(el, base.x, base.y, pt.x, pt.y));
|
||
this.onElementsModified?.(modified);
|
||
}
|
||
|
||
this.resetModify();
|
||
}
|
||
|
||
private resetModify(): void {
|
||
this.modifySelected = [];
|
||
this.modifyBoundary = null;
|
||
this.state.points = [];
|
||
this.state.previewElement = null;
|
||
this.state.phase = 'idle';
|
||
this.notifyToolStateChanged();
|
||
this.requestRender();
|
||
}
|
||
|
||
private handleDeleteDown(world: { x: number; y: number }): void {
|
||
const hit = this.renderEngine.hitTest(world.x, world.y, 5);
|
||
if (hit) {
|
||
this.onElementsDeleted?.([hit.id]);
|
||
}
|
||
}
|
||
|
||
private updatePreview(pt: { x: number; y: number }): void {
|
||
if (this.state.points.length === 0) return;
|
||
const layerId = this.layerManager.getActiveLayerId();
|
||
const first = this.state.points[0];
|
||
const tool = this.state.activeTool;
|
||
|
||
switch (tool) {
|
||
case 'line':
|
||
this.state.previewElement = {
|
||
id: '__preview__',
|
||
type: 'line',
|
||
layerId,
|
||
x: (first.x + pt.x) / 2,
|
||
y: (first.y + pt.y) / 2,
|
||
width: Math.abs(pt.x - first.x),
|
||
height: Math.abs(pt.y - first.y),
|
||
properties: { x1: first.x, y1: first.y, x2: pt.x, y2: pt.y },
|
||
};
|
||
break;
|
||
case 'rect': {
|
||
const minX = Math.min(first.x, pt.x);
|
||
const minY = Math.min(first.y, pt.y);
|
||
const w = Math.abs(pt.x - first.x);
|
||
const h = Math.abs(pt.y - first.y);
|
||
this.state.previewElement = {
|
||
id: '__preview__',
|
||
type: 'rect',
|
||
layerId,
|
||
x: minX + w / 2,
|
||
y: minY + h / 2,
|
||
width: w,
|
||
height: h,
|
||
properties: {},
|
||
};
|
||
break;
|
||
}
|
||
case 'circle': {
|
||
const r = Math.sqrt((pt.x - first.x) ** 2 + (pt.y - first.y) ** 2);
|
||
this.state.previewElement = {
|
||
id: '__preview__',
|
||
type: 'circle',
|
||
layerId,
|
||
x: first.x,
|
||
y: first.y,
|
||
width: r * 2,
|
||
height: r * 2,
|
||
properties: { radius: r },
|
||
};
|
||
break;
|
||
}
|
||
case 'arc': {
|
||
// 3-point arc: click 1 = center, click 2 = start point (radius + startAngle), click 3 = end point (endAngle)
|
||
const pts = this.state.points;
|
||
if (pts.length === 1) {
|
||
// After center placed, show preview circle as radius guide
|
||
const r = Math.sqrt((pt.x - first.x) ** 2 + (pt.y - first.y) ** 2);
|
||
this.state.previewElement = {
|
||
id: '__preview__',
|
||
type: 'arc',
|
||
layerId,
|
||
x: first.x,
|
||
y: first.y,
|
||
width: r * 2,
|
||
height: r * 2,
|
||
properties: { radius: r, startAngle: 0, endAngle: 360 },
|
||
};
|
||
} else if (pts.length >= 2) {
|
||
const center = pts[0];
|
||
const start = pts[1];
|
||
const radius = Math.sqrt((start.x - center.x) ** 2 + (start.y - center.y) ** 2);
|
||
const startAngle = (Math.atan2(start.y - center.y, start.x - center.x) * 180) / Math.PI;
|
||
const endAngle = (Math.atan2(pt.y - center.y, pt.x - center.x) * 180) / Math.PI;
|
||
this.state.previewElement = {
|
||
id: '__preview__',
|
||
type: 'arc',
|
||
layerId,
|
||
x: center.x,
|
||
y: center.y,
|
||
width: radius * 2,
|
||
height: radius * 2,
|
||
properties: { radius, startAngle, endAngle },
|
||
};
|
||
}
|
||
break;
|
||
}
|
||
case 'polyline':
|
||
case 'polygon': {
|
||
const pts = [...this.state.points, pt];
|
||
const xs = pts.map(p => p.x);
|
||
const ys = pts.map(p => p.y);
|
||
this.state.previewElement = {
|
||
id: '__preview__',
|
||
type: tool,
|
||
layerId,
|
||
x: (Math.min(...xs) + Math.max(...xs)) / 2,
|
||
y: (Math.min(...ys) + Math.max(...ys)) / 2,
|
||
width: Math.max(...xs) - Math.min(...xs),
|
||
height: Math.max(...ys) - Math.min(...ys),
|
||
properties: { points: pts },
|
||
};
|
||
break;
|
||
}
|
||
case 'text':
|
||
// Text placement — single point, then user types
|
||
this.state.previewElement = {
|
||
id: '__preview__',
|
||
type: 'text',
|
||
layerId,
|
||
x: pt.x,
|
||
y: pt.y,
|
||
width: 100,
|
||
height: 20,
|
||
properties: { text: '', fontSize: 12 },
|
||
};
|
||
break;
|
||
case 'dimension': {
|
||
const dist = Math.sqrt((pt.x - first.x) ** 2 + (pt.y - first.y) ** 2);
|
||
this.state.previewElement = {
|
||
id: '__preview__',
|
||
type: 'dimension',
|
||
layerId,
|
||
x: (first.x + pt.x) / 2,
|
||
y: (first.y + pt.y) / 2,
|
||
width: dist,
|
||
height: 20,
|
||
properties: { x1: first.x, y1: first.y, x2: pt.x, y2: pt.y },
|
||
};
|
||
break;
|
||
}
|
||
case 'leader': {
|
||
this.state.previewElement = {
|
||
id: '__preview__',
|
||
type: 'leader',
|
||
layerId,
|
||
x: pt.x, y: pt.y,
|
||
width: Math.abs(pt.x - first.x),
|
||
height: Math.abs(pt.y - first.y),
|
||
properties: { x1: first.x, y1: first.y, x2: pt.x, y2: pt.y, text: '', fontSize: 12, stroke: '#e0e0e0', strokeWidth: 1 },
|
||
};
|
||
break;
|
||
}
|
||
case 'revcloud': {
|
||
const pts = [...this.state.points, pt];
|
||
const xs = pts.map(p => p.x);
|
||
const ys = pts.map(p => p.y);
|
||
this.state.previewElement = {
|
||
id: '__preview__',
|
||
type: 'revcloud',
|
||
layerId,
|
||
x: (Math.min(...xs) + Math.max(...xs)) / 2,
|
||
y: (Math.min(...ys) + Math.max(...ys)) / 2,
|
||
width: Math.max(...xs) - Math.min(...xs),
|
||
height: Math.max(...ys) - Math.min(...ys),
|
||
properties: { points: pts, arcHeight: 8, fill: 'none', stroke: '#e0e0e0', strokeWidth: 1.5 },
|
||
};
|
||
break;
|
||
}
|
||
case 'measure': {
|
||
// Show a dashed line preview from first point to cursor
|
||
this.state.previewElement = {
|
||
id: '__preview__',
|
||
type: 'line',
|
||
layerId,
|
||
x: (first.x + pt.x) / 2,
|
||
y: (first.y + pt.y) / 2,
|
||
width: Math.abs(pt.x - first.x),
|
||
height: Math.abs(pt.y - first.y),
|
||
properties: { x1: first.x, y1: first.y, x2: pt.x, y2: pt.y },
|
||
};
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
private confirmDraw(): void {
|
||
if (!this.state.previewElement) return;
|
||
const layerId = this.layerManager.getActiveLayerId();
|
||
const dimService = new DimensionService();
|
||
let el: CADElement;
|
||
|
||
// Use DimensionService for leader and revcloud creation
|
||
if (this.state.activeTool === 'leader' && this.state.points.length >= 2) {
|
||
const p1 = this.state.points[0];
|
||
const p2 = this.state.points[1];
|
||
el = dimService.createLeader(p1.x, p1.y, p2.x, p2.y, layerId, { text: 'Hinweis' });
|
||
} else if (this.state.activeTool === 'revcloud' && this.state.points.length >= 2) {
|
||
el = dimService.createRevCloud(this.state.points, layerId);
|
||
} else {
|
||
el = { ...this.state.previewElement, id: this.generateId(), layerId: layerId };
|
||
}
|
||
|
||
this.onElementCreated?.(el);
|
||
|
||
// Text: trigger edit callback after placement
|
||
if (el.type === 'text') {
|
||
this.onTextEdit?.(el);
|
||
}
|
||
|
||
// Leader: trigger edit callback for text input
|
||
if (el.type === 'leader') {
|
||
this.onTextEdit?.(el);
|
||
}
|
||
|
||
this.state.points = [];
|
||
this.state.previewElement = null;
|
||
this.state.phase = 'idle';
|
||
this.notifyToolStateChanged();
|
||
this.requestRender();
|
||
}
|
||
|
||
private cancelCurrentOperation(): void {
|
||
this.state.points = [];
|
||
this.state.previewElement = null;
|
||
this.state.phase = 'idle';
|
||
this.selectionEngine.cancelBoxSelect();
|
||
this.notifyToolStateChanged();
|
||
this.requestRender();
|
||
}
|
||
|
||
private notifyToolStateChanged(): void {
|
||
this.onToolStateChanged?.(this.getToolState());
|
||
}
|
||
|
||
private requestRender(): void {
|
||
if (this.animationFrame !== null) return;
|
||
this.animationFrame = requestAnimationFrame(() => {
|
||
this.animationFrame = null;
|
||
this.renderEngine.setPreviewElement(this.state.previewElement);
|
||
this.renderEngine.render();
|
||
});
|
||
}
|
||
|
||
private generateId(): string {
|
||
return `el_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
|
||
}
|
||
|
||
// Public method to trigger zoom fit
|
||
zoomFit(): void {
|
||
this.zoomPan.zoomFit(this.allElements);
|
||
this.requestRender();
|
||
}
|
||
|
||
// Get current cursor world position
|
||
getCursorWorld(): { x: number; y: number } {
|
||
return this.zoomPan.screenToWorld(this.lastMouseScreen.x, this.lastMouseScreen.y);
|
||
}
|
||
}
|