@nice2dev/game-engine 0.1.0 → 1.0.3

package/dist/types/rendering/WebGPURenderPipeline.d.ts

@@ -0,0 +1,255 @@
+export type GPUTextureFormatType = 'bgra8unorm' | 'rgba8unorm' | 'rgba16float' | 'rgba32float' | 'depth24plus' | 'depth32float' | 'depth24plus-stencil8';
+export type GPUBlendModeType = 'opaque' | 'alpha-blend' | 'additive' | 'multiply' | 'premultiplied';
+export type ToneMappingMode = 'none' | 'reinhard' | 'aces' | 'filmic' | 'uncharted2';
+export type MaterialType = 'pbr' | 'unlit' | 'sprite' | 'particle' | 'custom';
+export type RenderPassType = 'depth-prepass' | 'shadow' | 'color' | 'transparent' | 'post-process' | 'ui-overlay';
+export type LightCategory = 'directional' | 'point' | 'spot' | 'area';
+export type PostEffectType = 'bloom' | 'fxaa' | 'taa' | 'ssao' | 'motion-blur' | 'chromatic-aberration' | 'vignette' | 'color-grading' | 'dof' | 'film-grain';
+export interface VertexAttribute {
+    name: string;
+    format: string;
+    offset: number;
+    shaderLocation: number;
+}
+export interface VertexBufferLayout {
+    arrayStride: number;
+    stepMode: 'vertex' | 'instance';
+    attributes: VertexAttribute[];
+}
+/** Standard vertex layout: position(3) + normal(3) + uv(2) + tangent(4) */
+export declare const STANDARD_VERTEX_LAYOUT: VertexBufferLayout;
+/** Instance data layout: model matrix (4x4) + color (4) */
+export declare const INSTANCE_LAYOUT: VertexBufferLayout;
+export interface GPUTextureRef {
+    id: string;
+    uri?: string;
+    width: number;
+    height: number;
+    format: GPUTextureFormatType;
+    mipLevels: number;
+}
+export interface PBRMaterial {
+    type: 'pbr';
+    albedo: [number, number, number, number];
+    albedoTexture?: GPUTextureRef;
+    metallic: number;
+    roughness: number;
+    metallicRoughnessTexture?: GPUTextureRef;
+    normalTexture?: GPUTextureRef;
+    normalScale: number;
+    occlusionTexture?: GPUTextureRef;
+    occlusionStrength: number;
+    emissive: [number, number, number];
+    emissiveTexture?: GPUTextureRef;
+    emissiveIntensity: number;
+    alphaMode: 'opaque' | 'mask' | 'blend';
+    alphaCutoff: number;
+    doubleSided: boolean;
+}
+export interface UnlitMaterial {
+    type: 'unlit';
+    color: [number, number, number, number];
+    texture?: GPUTextureRef;
+    alphaMode: 'opaque' | 'mask' | 'blend';
+    alphaCutoff: number;
+}
+export interface SpriteMaterial {
+    type: 'sprite';
+    texture: GPUTextureRef;
+    tint: [number, number, number, number];
+    uvRect: [number, number, number, number];
+    pixelPerfect: boolean;
+}
+export interface CustomMaterial {
+    type: 'custom';
+    shaderCode: string;
+    uniforms: Record<string, number | number[] | GPUTextureRef>;
+    blendMode: GPUBlendModeType;
+}
+export type RenderMaterial = PBRMaterial | UnlitMaterial | SpriteMaterial | CustomMaterial;
+export declare const DEFAULT_PBR: PBRMaterial;
+export interface GPULight {
+    category: LightCategory;
+    color: [number, number, number];
+    intensity: number;
+    /** World-space position (point/spot/area) */
+    position?: [number, number, number];
+    /** Direction (directional/spot) */
+    direction?: [number, number, number];
+    /** Range for point/spot (0 = infinite) */
+    range?: number;
+    /** Inner/outer cone angle in radians (spot only) */
+    innerConeAngle?: number;
+    outerConeAngle?: number;
+    /** Cast shadows */
+    castShadow: boolean;
+    shadowMapSize?: number;
+    shadowBias?: number;
+}
+export interface RenderBatch {
+    id: string;
+    vertexData: Float32Array;
+    indexData: Uint32Array;
+    instanceCount: number;
+    instanceData?: Float32Array;
+    material: RenderMaterial;
+    layer: number;
+    castShadow: boolean;
+    receiveShadow: boolean;
+}
+export interface ClusteredLightConfig {
+    tileCountX: number;
+    tileCountY: number;
+    sliceCount: number;
+    maxLightsPerCluster: number;
+}
+export interface ShadowConfig {
+    enabled: boolean;
+    mapSize: number;
+    cascadeCount: number;
+    cascadeSplitLambda: number;
+    bias: number;
+    normalBias: number;
+    pcfRadius: number;
+}
+export interface PostProcessConfig {
+    enabled: boolean;
+    effects: PostEffectSettings[];
+    hdrEnabled: boolean;
+    toneMapping: ToneMappingMode;
+    exposure: number;
+    gamma: number;
+}
+export interface PostEffectSettings {
+    type: PostEffectType;
+    enabled: boolean;
+    intensity: number;
+    params: Record<string, number>;
+}
+export interface WebGPURenderConfig {
+    canvasFormat: GPUTextureFormatType;
+    sampleCount: number;
+    maxLights: number;
+    clusteredLighting: ClusteredLightConfig;
+    shadows: ShadowConfig;
+    postProcess: PostProcessConfig;
+    maxInstances: number;
+    depthPrepassEnabled: boolean;
+    frustumCulling: boolean;
+    occlusionCulling: boolean;
+    sortTransparents: boolean;
+}
+export declare const DEFAULT_RENDER_CONFIG: WebGPURenderConfig;
+export interface GPUResourceHandle {
+    id: string;
+    type: 'buffer' | 'texture' | 'sampler' | 'pipeline' | 'bind-group';
+}
+export interface GPUStats {
+    drawCalls: number;
+    triangles: number;
+    instances: number;
+    textureMegabytes: number;
+    bufferMegabytes: number;
+    pipelineSwitches: number;
+    frameTimeMs: number;
+    gpuTimeMs: number;
+}
+/** Track GPU resource allocations */
+export declare class GPUResourceTracker {
+    private resources;
+    private totalBytes;
+    register(id: string, type: string, sizeBytes: number, label?: string): void;
+    release(id: string): void;
+    getStats(): {
+        count: number;
+        totalMB: number;
+        byType: Record<string, number>;
+    };
+    clear(): void;
+}
+export interface RenderPassDescriptor {
+    type: RenderPassType;
+    label: string;
+    enabled: boolean;
+    order: number;
+}
+/** Collects batches, sorts, and generates draw calls per pass */
+export declare class RenderPipelineManager {
+    private config;
+    private passes;
+    private batches;
+    private lights;
+    private stats;
+    private resourceTracker;
+    constructor(config?: Partial<WebGPURenderConfig>);
+    private initDefaultPasses;
+    getConfig(): Readonly<WebGPURenderConfig>;
+    updateConfig(patch: Partial<WebGPURenderConfig>): void;
+    submitBatch(batch: RenderBatch): void;
+    submitLight(light: GPULight): void;
+    clearFrame(): void;
+    /** Sort and organize batches for rendering */
+    preparePasses(): Map<RenderPassType, RenderBatch[]>;
+    private isOpaque;
+    /** Generate draw statistics */
+    computeStats(): GPUStats;
+    getLights(): readonly GPULight[];
+    getPasses(): readonly RenderPassDescriptor[];
+    getResourceTracker(): GPUResourceTracker;
+}
+export interface WebGPURendererState {
+    initialized: boolean;
+    supported: boolean;
+    adapterInfo: string;
+    deviceLimits: Record<string, number>;
+}
+/** High-level WebGPU renderer that manages device, pipelines, and frame submission */
+export declare class WebGPURenderer {
+    private pipeline;
+    private state;
+    private frameCallback;
+    constructor(config?: Partial<WebGPURenderConfig>);
+    /** Check WebGPU support */
+    isSupported(): boolean;
+    /** Initialize the WebGPU device */
+    initialize(): Promise<boolean>;
+    /** Submit a renderable batch */
+    submit(batch: RenderBatch): void;
+    /** Submit a light */
+    addLight(light: GPULight): void;
+    /** Execute full render frame */
+    renderFrame(): GPUStats;
+    /** Register frame callback */
+    onFrame(cb: (stats: GPUStats) => void): void;
+    getState(): Readonly<WebGPURendererState>;
+    getPipeline(): RenderPipelineManager;
+    /** Get available shader sources for debug/customization */
+    getShaderSources(): Record<string, string>;
+    destroy(): void;
+}
+export interface PostProcessPass {
+    type: PostEffectType;
+    enabled: boolean;
+    intensity: number;
+    params: Record<string, number>;
+}
+export declare const BLOOM_DEFAULTS: PostProcessPass;
+export declare const FXAA_DEFAULTS: PostProcessPass;
+export declare const SSAO_DEFAULTS: PostProcessPass;
+export declare const DOF_DEFAULTS: PostProcessPass;
+export declare const COLOR_GRADING_DEFAULTS: PostProcessPass;
+/** Manage ordered post-process stack */
+export declare class PostProcessStack {
+    private passes;
+    add(pass: PostProcessPass): void;
+    remove(type: PostEffectType): void;
+    setEnabled(type: PostEffectType, enabled: boolean): void;
+    setIntensity(type: PostEffectType, intensity: number): void;
+    getActive(): PostProcessPass[];
+    getAll(): readonly PostProcessPass[];
+    reorder(order: PostEffectType[]): void;
+    clear(): void;
+}
+export type QualityPreset = 'low' | 'medium' | 'high' | 'ultra';
+export declare const QUALITY_PRESET_CONFIGS: Record<QualityPreset, Partial<WebGPURenderConfig>>;
+export declare function applyQualityPreset(preset: QualityPreset): WebGPURenderConfig;

package/dist/types/scripting/GraphToAST.d.ts

@@ -0,0 +1,55 @@
+import type { ScriptGraph } from './NodeGraph';
+import { NodeLibrary } from './NodeGraph';
+import type { ASTScript } from './ScriptAST';
+export interface ConvertOptions {
+    /** Name for the generated class */
+    className?: string;
+    /** Base class to extend */
+    baseClass?: string;
+    /** Whether to generate async methods for delay/wait nodes */
+    useAsync?: boolean;
+    /** Whether to generate comments showing node IDs */
+    includeNodeIds?: boolean;
+    /** Prefix for generated variable names */
+    varPrefix?: string;
+}
+export declare class GraphToAST {
+    private library;
+    constructor(library?: NodeLibrary);
+    /**
+     * Convert a visual script graph to AST representation.
+     */
+    convert(graph: ScriptGraph, options?: ConvertOptions): ASTScript;
+    /**
+     * Convert multiple graphs into a single script module.
+     */
+    convertMultiple(graphs: ScriptGraph[], moduleName: string, options?: ConvertOptions): ASTScript;
+    private findEntryNodes;
+    private entryTypeToMethodName;
+    private convertVariables;
+    private valueToASTType;
+    private convertEntryPointsToMethod;
+    private getEntryParams;
+    private createEmptyMethod;
+    private processNode;
+    private generateNodeCode;
+    private generateFlowNode;
+    private generateIfElse;
+    private generateDelay;
+    private generateForLoop;
+    private generateWhileLoop;
+    private generateMathNode;
+    private generateLogicNode;
+    private generateVariableNode;
+    private generateEntityNode;
+    private generateInputNode;
+    private generateAudioNode;
+    private generateGenericNode;
+    private resolveInputExpression;
+    private valueToExpression;
+    private getOrCreateNodeVar;
+    private getFlowTargetNodes;
+    private followFlowConnections;
+}
+export declare function convertGraphToAST(graph: ScriptGraph, library: NodeLibrary, options?: ConvertOptions): ASTScript;
+export default GraphToAST;

package/dist/types/scripting/LanguageExporter.d.ts

@@ -0,0 +1,136 @@
+import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTProperty, ASTStatement, ASTExpression, ASTTypeInfo, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTImport, ASTEnum, ASTSignalDef } from './ScriptAST';
+export interface ExportConfig {
+    /** Target game engine/platform */
+    targetEngine?: 'unity' | 'godot' | 'bevy' | 'pygame' | 'love2d' | 'defold' | 'generic';
+    /** Engine version (e.g., '4.2' for Godot) */
+    engineVersion?: string;
+    /** Indentation string */
+    indent: string;
+    /** Line ending */
+    lineEnding: '\n' | '\r\n';
+    /** Whether to include debug comments */
+    includeDebugComments: boolean;
+    /** Include source node IDs in comments */
+    includeSourceMappings: boolean;
+    /** Base class name for generated scripts */
+    baseClassName?: string;
+    /** Namespace/package for generated code */
+    namespace?: string;
+    /** Additional custom options */
+    custom?: Record<string, unknown>;
+}
+export declare const defaultConfig: ExportConfig;
+export interface ExportedFile {
+    filename: string;
+    content: string;
+    /** Language/file type */
+    language: string;
+    /** Optional file path for export consumption */
+    path?: string;
+}
+export interface ExportResult {
+    files: ExportedFile[];
+    errors: ExportError[];
+    warnings: ExportWarning[];
+    stats: {
+        classCount: number;
+        methodCount: number;
+        lineCount: number;
+        exportDuration: number;
+    };
+}
+export interface ExportError {
+    message: string;
+    nodeId?: string;
+    line?: number;
+    column?: number;
+}
+export interface ExportWarning {
+    message: string;
+    nodeId?: string;
+    suggestion?: string;
+}
+export interface TypeMapping {
+    [key: string]: string;
+}
+export declare class CodeBuilder {
+    private lines;
+    private currentIndent;
+    private indentStr;
+    private lineEnding;
+    constructor(config: ExportConfig);
+    indent(): this;
+    dedent(): this;
+    line(text?: string): this;
+    rawLine(text: string): this;
+    emptyLine(): this;
+    comment(text: string, style?: 'line' | 'block'): this;
+    docComment(text: string, style?: 'csharp' | 'jsdoc' | 'python' | 'lua'): this;
+    block(open: string, close: string, body: () => void): this;
+    toString(): string;
+    get lineCount(): number;
+}
+export declare abstract class LanguageExporter {
+    protected config: ExportConfig;
+    protected errors: ExportError[];
+    protected warnings: ExportWarning[];
+    /** Language name for identification */
+    abstract readonly languageName: string;
+    /** File extension without dot */
+    abstract readonly fileExtension: string;
+    /** Type mapping from AST types to target language */
+    abstract readonly typeMapping: TypeMapping;
+    constructor(config?: Partial<ExportConfig>);
+    export(script: ASTScript, config?: Partial<ExportConfig>): ExportResult;
+    protected addError(message: string, nodeId?: string): void;
+    protected addWarning(message: string, nodeId?: string, suggestion?: string): void;
+    protected mapType(typeInfo: ASTTypeInfo): string;
+    protected createBuilder(): CodeBuilder;
+    protected abstract generateScript(script: ASTScript): string;
+    protected abstract generateClass(cls: ASTClass, builder: CodeBuilder): void;
+    protected abstract generateMethod(method: ASTFunction, builder: CodeBuilder): void;
+    protected abstract generateField(field: ASTField, builder: CodeBuilder): void;
+    protected abstract generateStatement(stmt: ASTStatement, builder: CodeBuilder): void;
+    protected abstract generateExpression(expr: ASTExpression): string;
+    protected formatArrayType(elementType: string): string;
+    protected formatDictType(keyType: string, valueType: string): string;
+    protected formatNullableType(baseType: string): string;
+    protected generateImport(_imp: ASTImport, _builder: CodeBuilder): void;
+    protected generateEnum(_en: ASTEnum, _builder: CodeBuilder): void;
+    protected generateProperty(_prop: ASTProperty, _builder: CodeBuilder): void;
+    protected generateSignal(_signal: ASTSignalDef, _builder: CodeBuilder): void;
+}
+export declare abstract class ImperativeLanguageExporter extends LanguageExporter {
+    protected generateStatement(stmt: ASTStatement, builder: CodeBuilder): void;
+    protected generateExpression(expr: ASTExpression): string;
+    protected abstract readonly statementTerminator: string;
+    protected abstract readonly breakKeyword: string;
+    protected abstract readonly continueKeyword: string;
+    protected abstract generateVarDecl(decl: ASTVarDecl, builder: CodeBuilder): void;
+    protected abstract generateAssignment(assign: ASTAssignment, builder: CodeBuilder): void;
+    protected abstract generateIf(stmt: ASTIf, builder: CodeBuilder): void;
+    protected abstract generateWhile(stmt: ASTWhile, builder: CodeBuilder): void;
+    protected abstract generateFor(stmt: ASTFor, builder: CodeBuilder): void;
+    protected abstract generateForEach(stmt: ASTForEach, builder: CodeBuilder): void;
+    protected abstract generateReturn(stmt: ASTReturn, builder: CodeBuilder): void;
+    protected abstract generateSwitch(stmt: ASTSwitch, builder: CodeBuilder): void;
+    protected abstract generateTry(stmt: ASTTry, builder: CodeBuilder): void;
+    protected abstract generateLiteral(lit: ASTLiteral): string;
+    protected abstract generateBinaryOp(op: ASTBinaryOp): string;
+    protected abstract generateUnaryOp(op: ASTUnaryOp): string;
+    protected abstract generateCall(call: ASTCall): string;
+    protected abstract generateMethodCall(call: ASTMethodCall): string;
+    protected abstract generatePropertyAccess(access: ASTPropertyAccess): string;
+    protected abstract generateIndexAccess(access: ASTIndexAccess): string;
+    protected abstract generateConditional(cond: ASTConditional): string;
+    protected abstract generateArrayLiteral(arr: ASTArrayLiteral): string;
+    protected abstract generateDictionaryLiteral(dict: ASTDictionaryLiteral): string;
+    protected abstract generateCast(cast: ASTCast): string;
+    protected abstract generateLambda(lambda: ASTLambda): string;
+    protected abstract generateNew(n: ASTNew): string;
+}
+export declare function escapeString(str: string, quote?: '"' | "'"): string;
+export declare function toUpperCamelCase(str: string): string;
+export declare function toLowerCamelCase(str: string): string;
+export declare function toSnakeCase(str: string): string;
+export declare function toScreamingSnakeCase(str: string): string;