@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/editor/NiceNodeGraph.d.ts

@@ -0,0 +1,87 @@
+import React from 'react';
+import { VisualScriptGraph } from '../visual-scripting/VisualScriptGraph';
+export interface NodePosition {
+    x: number;
+    y: number;
+}
+export interface NodeGraphTheme {
+    background: string;
+    gridColor: string;
+    gridMajorColor: string;
+    nodeBackground: string;
+    nodeBorder: string;
+    nodeSelectedBorder: string;
+    nodeHeaderBackground: string;
+    pinExecution: string;
+    pinBoolean: string;
+    pinNumber: string;
+    pinString: string;
+    pinVector: string;
+    pinObject: string;
+    pinArray: string;
+    pinAny: string;
+    connectionLine: string;
+    connectionLineExecution: string;
+    textPrimary: string;
+    textSecondary: string;
+    groupBackground: string;
+    groupBorder: string;
+    breakpointColor: string;
+    executionHighlight: string;
+}
+export interface NodeCategory {
+    id: string;
+    name: string;
+    icon: string;
+    color: string;
+}
+export interface NodeGraphState {
+    zoom: number;
+    panOffset: NodePosition;
+    selectedNodes: string[];
+    hoveredNode: string | null;
+    hoveredPin: {
+        nodeId: string;
+        pinId: string;
+        isOutput: boolean;
+    } | null;
+    draggingNode: string | null;
+    connecting: {
+        sourceNodeId: string;
+        sourcePinId: string;
+        isOutput: boolean;
+        mousePos: NodePosition;
+    } | null;
+    selectionBox: {
+        start: NodePosition;
+        end: NodePosition;
+    } | null;
+    contextMenu: {
+        x: number;
+        y: number;
+        type: 'canvas' | 'node' | 'connection';
+        targetId?: string;
+    } | null;
+    searchQuery: string;
+    showLibrary: boolean;
+    showVariables: boolean;
+    showCodePreview: boolean;
+    activeBreakpoints: Set<string>;
+    executingNode: string | null;
+}
+export interface NiceNodeGraphProps {
+    graph?: VisualScriptGraph;
+    theme?: Partial<NodeGraphTheme>;
+    readOnly?: boolean;
+    onGraphChange?: (graph: VisualScriptGraph) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface NiceNodeGraphRef {
+    getGraph: () => VisualScriptGraph;
+    addNode: (typeId: string, position: NodePosition) => void;
+    zoomToFit: () => void;
+    clearSelection: () => void;
+}
+export declare const NiceNodeGraph: React.ForwardRefExoticComponent<NiceNodeGraphProps & React.RefAttributes<NiceNodeGraphRef>>;
+export default NiceNodeGraph;

package/dist/types/editor/NiceParticleEditor.d.ts

@@ -0,0 +1,127 @@
+import { type NiceComponentTutorial } from '@nice2dev/ui';
+import React from 'react';
+export interface ParticleCurve {
+    type: 'constant' | 'linear' | 'curve' | 'randomBetweenCurves';
+    value?: number;
+    min?: number;
+    max?: number;
+    keys?: Array<{
+        time: number;
+        value: number;
+        inTangent?: number;
+        outTangent?: number;
+    }>;
+    keys2?: Array<{
+        time: number;
+        value: number;
+        inTangent?: number;
+        outTangent?: number;
+    }>;
+}
+export interface ParticleGradient {
+    type: 'constant' | 'gradient' | 'randomBetweenGradients';
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    keys?: Array<{
+        time: number;
+        color: {
+            r: number;
+            g: number;
+            b: number;
+            a: number;
+        };
+    }>;
+    keys2?: Array<{
+        time: number;
+        color: {
+            r: number;
+            g: number;
+            b: number;
+            a: number;
+        };
+    }>;
+}
+export interface EmitterShape {
+    type: 'sphere' | 'hemisphere' | 'cone' | 'box' | 'circle' | 'edge' | 'mesh';
+    radius?: number;
+    angle?: number;
+    arc?: number;
+    length?: number;
+    boxSize?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    emitFromShell?: boolean;
+    randomDirection?: boolean;
+}
+export interface ParticleModule {
+    id: string;
+    type: ParticleModuleType;
+    enabled: boolean;
+    properties: Record<string, unknown>;
+}
+export type ParticleModuleType = 'emission' | 'shape' | 'velocity' | 'lifetime' | 'speed' | 'size' | 'rotation' | 'color' | 'gravity' | 'noise' | 'collision' | 'subEmitters' | 'textureSheet' | 'trails' | 'lights' | 'customData';
+export interface ParticleSystemData {
+    id: string;
+    name: string;
+    duration: number;
+    looping: boolean;
+    prewarm: boolean;
+    startDelay: ParticleCurve;
+    startLifetime: ParticleCurve;
+    startSpeed: ParticleCurve;
+    startSize: ParticleCurve;
+    startRotation: ParticleCurve;
+    startColor: ParticleGradient;
+    gravityModifier: ParticleCurve;
+    simulationSpace: 'local' | 'world';
+    simulationSpeed: number;
+    maxParticles: number;
+    playOnAwake: boolean;
+    modules: ParticleModule[];
+    renderMode: 'billboard' | 'stretchedBillboard' | 'horizontalBillboard' | 'verticalBillboard' | 'mesh';
+    material?: string;
+    mesh?: string;
+    sortMode: 'none' | 'distance' | 'oldestFirst' | 'youngestFirst';
+    blendMode: 'additive' | 'alpha' | 'multiply' | 'premultiply';
+}
+export interface ParticleEditorTheme {
+    background: string;
+    panelBackground: string;
+    headerBackground: string;
+    moduleBackground: string;
+    moduleBackgroundAlt: string;
+    moduleHeader: string;
+    previewBackground: string;
+    gridColor: string;
+    curveColor: string;
+    curveHandle: string;
+    gradientTrack: string;
+    textPrimary: string;
+    textSecondary: string;
+    accent: string;
+    danger: string;
+}
+export interface NiceParticleEditorProps {
+    system?: ParticleSystemData;
+    theme?: Partial<ParticleEditorTheme>;
+    readOnly?: boolean;
+    onSystemChange?: (system: ParticleSystemData) => void;
+    className?: string;
+    style?: React.CSSProperties;
+    /** Optional "?" guided tour. Off by default; `true` uses the built-in tour. */
+    tutorial?: NiceComponentTutorial;
+}
+export interface NiceParticleEditorRef {
+    getSystem: () => ParticleSystemData;
+    play: () => void;
+    pause: () => void;
+    restart: () => void;
+}
+export declare const NiceParticleEditor: React.ForwardRefExoticComponent<NiceParticleEditorProps & React.RefAttributes<NiceParticleEditorRef>>;
+export default NiceParticleEditor;

package/dist/types/editor/PrefabSystem.d.ts

@@ -0,0 +1,168 @@
+/**
+ * @file PrefabSystem.ts
+ * @description Advanced Prefab System with nested prefabs, variants, override tracking
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Prefab definition and instantiation
+ * - Nested prefabs (prefabs containing other prefabs)
+ * - Prefab variants (inherited modifications)
+ * - Override tracking (property-level changes)
+ * - Apply/revert overrides
+ * - Prefab linking (maintain connection to source)
+ * - Unpack prefab (break connection)
+ * - Auto-update instances when prefab changes
+ * - Serialization/deserialization
+ * - Prefab comparison (diff)
+ */
+export type PropertyPath = string;
+export interface PropertyOverride {
+    path: PropertyPath;
+    originalValue: unknown;
+    overridenValue: unknown;
+    overrideType: 'modify' | 'add' | 'remove';
+    timestamp: number;
+}
+export interface ComponentData {
+    type: string;
+    properties: Record<string, unknown>;
+    enabled: boolean;
+    id: string;
+}
+export interface PrefabEntity {
+    id: string;
+    name: string;
+    parentId: string | null;
+    transform: TransformData;
+    components: ComponentData[];
+    children: string[];
+    tags: string[];
+    layer: string;
+    active: boolean;
+}
+export interface TransformData {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export interface PrefabData {
+    id: string;
+    name: string;
+    description: string;
+    version: number;
+    createdAt: number;
+    modifiedAt: number;
+    author: string;
+    rootEntity: PrefabEntity;
+    entities: Map<string, PrefabEntity>;
+    nestedPrefabs: NestedPrefabReference[];
+    variantOf?: string;
+    inheritedOverrides?: PropertyOverride[];
+    tags: string[];
+    category: string;
+    thumbnail?: string;
+}
+export interface NestedPrefabReference {
+    instanceId: string;
+    prefabId: string;
+    parentEntityId: string;
+    overrides: PropertyOverride[];
+    transform: TransformData;
+}
+export interface PrefabInstance {
+    id: string;
+    prefabId: string;
+    name: string;
+    overrides: PropertyOverride[];
+    worldTransform: TransformData;
+    nestedInstances: Map<string, PrefabInstance>;
+    isLinked: boolean;
+    unpackedAt?: number;
+    createdAt: number;
+    lastSyncedAt: number;
+}
+export interface PrefabDiff {
+    added: PropertyPath[];
+    removed: PropertyPath[];
+    modified: {
+        path: PropertyPath;
+        oldValue: unknown;
+        newValue: unknown;
+    }[];
+    componentAdded: string[];
+    componentRemoved: string[];
+    entityAdded: string[];
+    entityRemoved: string[];
+}
+export declare const DEFAULT_TRANSFORM: TransformData;
+export declare class PrefabManager {
+    private prefabs;
+    private instances;
+    private prefabVersions;
+    private onPrefabChanged?;
+    private onInstanceChanged?;
+    createPrefab(name: string, rootEntity?: Partial<PrefabEntity>): PrefabData;
+    createPrefabFromEntities(name: string, entities: PrefabEntity[]): PrefabData;
+    createVariant(basePrefabId: string, name: string): PrefabData | null;
+    getBasePrefab(variantId: string): PrefabData | null;
+    applyVariantOverrides(variantId: string): void;
+    addNestedPrefab(parentPrefabId: string, nestedPrefabId: string, parentEntityId: string, transform?: Partial<TransformData>): NestedPrefabReference | null;
+    removeNestedPrefab(parentPrefabId: string, instanceId: string): boolean;
+    private hasCircularReference;
+    instantiate(prefabId: string, worldTransform?: Partial<TransformData>): PrefabInstance | null;
+    destroyInstance(instanceId: string): boolean;
+    setOverride(instanceId: string, path: PropertyPath, value: unknown): void;
+    removeOverride(instanceId: string, path: PropertyPath): void;
+    revertAllOverrides(instanceId: string): void;
+    applyOverridesToPrefab(instanceId: string): void;
+    hasOverrides(instanceId: string): boolean;
+    getOverrides(instanceId: string): PropertyOverride[];
+    private getOriginalValue;
+    private findEntityByPathRoot;
+    private getRelativePropertyPath;
+    unlinkInstance(instanceId: string): void;
+    relinkInstance(instanceId: string): boolean;
+    syncInstance(instanceId: string): void;
+    syncAllInstances(prefabId: string): void;
+    private updatePrefabVersion;
+    addEntity(prefabId: string, entity: Partial<PrefabEntity>, parentId?: string): PrefabEntity | null;
+    removeEntity(prefabId: string, entityId: string): boolean;
+    addComponent(prefabId: string, entityId: string, component: Partial<ComponentData>): ComponentData | null;
+    removeComponent(prefabId: string, entityId: string, componentId: string): boolean;
+    comparePrefabs(prefabIdA: string, prefabIdB: string): PrefabDiff | null;
+    compareInstanceToPrefab(instanceId: string): PrefabDiff | null;
+    private compareEntities;
+    private compareProperty;
+    serializePrefab(prefabId: string): string | null;
+    deserializePrefab(json: string): PrefabData | null;
+    serializeInstance(instanceId: string): string | null;
+    deserializeInstance(json: string): PrefabInstance | null;
+    getPrefab(prefabId: string): PrefabData | undefined;
+    getInstance(instanceId: string): PrefabInstance | undefined;
+    getAllPrefabs(): PrefabData[];
+    getAllInstances(): PrefabInstance[];
+    getInstancesOfPrefab(prefabId: string): PrefabInstance[];
+    searchPrefabs(query: string): PrefabData[];
+    getPrefabsByCategory(category: string): PrefabData[];
+    getCategories(): string[];
+    setOnPrefabChanged(callback: (prefabId: string) => void): void;
+    setOnInstanceChanged(callback: (instanceId: string) => void): void;
+    deletePrefab(prefabId: string): boolean;
+    clear(): void;
+}
+export declare function createPrefabManager(): PrefabManager;
+export declare function createDefaultEntity(name?: string): PrefabEntity;
+export declare function createComponent(type: string, properties?: Record<string, unknown>): ComponentData;

package/dist/types/editor/ProfilerPanel.d.ts

@@ -0,0 +1,192 @@
+/**
+ * @file ProfilerPanel.ts
+ * @description Advanced Profiler Panel System for Editor
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - CPU profiling with hierarchical flame graph
+ * - GPU timing (WebGL/WebGPU)
+ * - Memory tracking (JS heap, textures, buffers)
+ * - Frame timeline visualization
+ * - System breakdown
+ * - Custom markers/regions
+ * - Export/import profiler data
+ * - Real-time graphs
+ */
+export type ProfilerCategory = 'scripts' | 'physics' | 'rendering' | 'animation' | 'audio' | 'ai' | 'networking' | 'loading' | 'gc' | 'vsync' | 'other';
+export interface ProfilerMarker {
+    id: string;
+    name: string;
+    category: ProfilerCategory;
+    color: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    depth: number;
+    children: ProfilerMarker[];
+    metadata?: Record<string, unknown>;
+}
+export interface GPUTimerQuery {
+    id: string;
+    name: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+}
+export interface MemorySnapshot {
+    timestamp: number;
+    jsHeapUsed: number;
+    jsHeapTotal: number;
+    jsHeapLimit: number;
+    externalMemory: number;
+    arrayBuffers: number;
+    gpuTextures: number;
+    gpuBuffers: number;
+    gpuShaders: number;
+    gpuRenderTargets: number;
+    allocations: number;
+    deallocations: number;
+    gcCollections: number;
+}
+export interface ProfilerFrame {
+    frameNumber: number;
+    timestamp: number;
+    deltaTime: number;
+    cpuTime: number;
+    gpuTime: number;
+    waitTime: number;
+    markers: ProfilerMarker[];
+    gpuQueries: GPUTimerQuery[];
+    memory: MemorySnapshot;
+    systemTimes: Map<string, number>;
+    drawCalls: number;
+    triangles: number;
+    vertices: number;
+    setPassCalls: number;
+    batchCount: number;
+    shadowCasters: number;
+    visibleObjects: number;
+}
+export interface ProfilerStats {
+    avgFrameTime: number;
+    avgCPUTime: number;
+    avgGPUTime: number;
+    avgFPS: number;
+    minFPS: number;
+    maxFPS: number;
+    frame1Percent: number;
+    frame01Percent: number;
+    avgMemory: number;
+    peakMemory: number;
+    memoryGrowthRate: number;
+    avgDrawCalls: number;
+    avgBatches: number;
+    avgTriangles: number;
+    avgSetPassCalls: number;
+}
+export declare const CATEGORY_COLORS: Record<ProfilerCategory, string>;
+export interface ProfilerConfig {
+    enabled: boolean;
+    deepProfiling: boolean;
+    gpuProfiling: boolean;
+    memoryProfiling: boolean;
+    maxFrames: number;
+    sampleInterval: number;
+    recordAllocations: boolean;
+    categorize: boolean;
+    autoCapture: boolean;
+    captureThreshold: number;
+}
+export declare const DEFAULT_PROFILER_CONFIG: ProfilerConfig;
+export interface GraphPoint {
+    x: number;
+    y: number;
+    label?: string;
+}
+export interface GraphSeries {
+    name: string;
+    color: string;
+    data: GraphPoint[];
+    minValue: number;
+    maxValue: number;
+    avgValue: number;
+}
+export interface ProfilerGraph {
+    title: string;
+    yAxisLabel: string;
+    yAxisUnit: string;
+    series: GraphSeries[];
+    targetLine?: number;
+    warningLine?: number;
+}
+export declare class ProfilerPanel {
+    private config;
+    private frames;
+    private currentFrame;
+    private markerStack;
+    private pendingGPUQueries;
+    private frameNumber;
+    private lastFrameTimestamp;
+    private isRecording;
+    private capturedFrames;
+    private lastMemory;
+    private allocationCounter;
+    private deallocationCounter;
+    private gcCounter;
+    private gl;
+    private gpuTimerExtension;
+    private activeGPUQueries;
+    private renderStats;
+    private onFrameComplete?;
+    private onSlowFrame?;
+    constructor(config?: Partial<ProfilerConfig>);
+    setConfig(config: Partial<ProfilerConfig>): void;
+    getConfig(): ProfilerConfig;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    initializeGPU(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    beginFrame(): void;
+    endFrame(): void;
+    beginMarker(name: string, category?: ProfilerCategory): void;
+    endMarker(): void;
+    /** Convenience method to wrap a function with profiling */
+    profile<T>(name: string, category: ProfilerCategory, fn: () => T): T;
+    /** Async version of profile */
+    profileAsync<T>(name: string, category: ProfilerCategory, fn: () => Promise<T>): Promise<T>;
+    recordSystemTime(systemName: string, time: number): void;
+    addDrawCall(triangles: number, vertices: number): void;
+    addBatch(): void;
+    addSetPassCall(): void;
+    setVisibleObjects(count: number): void;
+    setShadowCasters(count: number): void;
+    beginGPUQuery(name: string): void;
+    endGPUQuery(name: string): void;
+    private collectGPUQueries;
+    private captureMemory;
+    trackAllocation(bytes: number): void;
+    trackDeallocation(bytes: number): void;
+    setGPUMemory(textures: number, buffers: number, shaders: number, renderTargets: number): void;
+    startRecording(): void;
+    stopRecording(): ProfilerFrame[];
+    clearRecording(): void;
+    isRecordingActive(): boolean;
+    getFrames(): ReadonlyArray<ProfilerFrame>;
+    getLastFrame(): ProfilerFrame | null;
+    getFrame(index: number): ProfilerFrame | null;
+    getFrameRange(start: number, end: number): ProfilerFrame[];
+    getCapturedFrames(): ReadonlyArray<ProfilerFrame>;
+    getStats(frameCount?: number): ProfilerStats;
+    getFrameTimeGraph(frameCount?: number): ProfilerGraph;
+    getMemoryGraph(frameCount?: number): ProfilerGraph;
+    getRenderingGraph(frameCount?: number): ProfilerGraph;
+    getFlameGraph(frame: ProfilerFrame): ProfilerMarker[];
+    getSystemBreakdown(frameCount?: number): Map<string, number>;
+    exportData(): string;
+    importData(json: string): void;
+    setOnFrameComplete(callback: (frame: ProfilerFrame) => void): void;
+    setOnSlowFrame(callback: (frame: ProfilerFrame) => void): void;
+    clear(): void;
+}
+export declare function createProfilerPanel(config?: Partial<ProfilerConfig>): ProfilerPanel;
+export declare function generateStatsOverlay(panel: ProfilerPanel): string[];