@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/scripting/exporters/HaxeExporter.d.ts

@@ -0,0 +1,49 @@
+import { ImperativeLanguageExporter, TypeMapping, CodeBuilder, ExportConfig } from '../LanguageExporter';
+import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum } from '../ScriptAST';
+export type HaxeTarget = 'openfl' | 'heaps' | 'haxeflixel' | 'kha' | 'generic';
+export declare class HaxeExporter extends ImperativeLanguageExporter {
+    readonly languageName = "haxe";
+    readonly fileExtension = "hx";
+    readonly typeMapping: TypeMapping;
+    protected readonly statementTerminator = ";";
+    protected readonly breakKeyword = "break";
+    protected readonly continueKeyword = "continue";
+    private target;
+    constructor(config?: Partial<ExportConfig>);
+    protected generateScript(script: ASTScript): string;
+    private generateImports;
+    protected generateClass(cls: ASTClass, builder: CodeBuilder): void;
+    private getBaseClass;
+    protected generateEnum(en: ASTEnum, builder: CodeBuilder): void;
+    private generateConstructor;
+    private generateClassMethod;
+    protected generateMethod(method: ASTFunction, builder: CodeBuilder): void;
+    protected generateField(field: ASTField, builder: CodeBuilder): void;
+    private convertMethodName;
+    private generateParams;
+    private getDefaultValue;
+    protected generateVarDecl(decl: ASTVarDecl, builder: CodeBuilder): void;
+    protected generateAssignment(assign: ASTAssignment, builder: CodeBuilder): void;
+    protected generateIf(stmt: ASTIf, builder: CodeBuilder): void;
+    protected generateWhile(stmt: ASTWhile, builder: CodeBuilder): void;
+    protected generateFor(stmt: ASTFor, builder: CodeBuilder): void;
+    protected generateForEach(stmt: ASTForEach, builder: CodeBuilder): void;
+    protected generateReturn(stmt: ASTReturn, builder: CodeBuilder): void;
+    protected generateSwitch(stmt: ASTSwitch, builder: CodeBuilder): void;
+    protected generateTry(stmt: ASTTry, builder: CodeBuilder): void;
+    protected generateLiteral(lit: ASTLiteral): string;
+    protected generateBinaryOp(op: ASTBinaryOp): string;
+    protected generateUnaryOp(op: ASTUnaryOp): string;
+    protected generateCall(call: ASTCall): string;
+    protected generateMethodCall(call: ASTMethodCall): string;
+    protected generatePropertyAccess(access: ASTPropertyAccess): string;
+    protected generateIndexAccess(access: ASTIndexAccess): string;
+    protected generateConditional(cond: ASTConditional): string;
+    protected generateArrayLiteral(arr: ASTArrayLiteral): string;
+    protected generateDictionaryLiteral(dict: ASTDictionaryLiteral): string;
+    protected generateCast(cast: ASTCast): string;
+    protected generateLambda(lambda: ASTLambda): string;
+    protected generateNew(newExpr: ASTNew): string;
+    private convertFunctionName;
+}
+export default HaxeExporter;

package/dist/types/scripting/exporters/KotlinExporter.d.ts

@@ -0,0 +1,52 @@
+import { ImperativeLanguageExporter, TypeMapping, CodeBuilder, ExportConfig } from '../LanguageExporter';
+import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum } from '../ScriptAST';
+export type KotlinTarget = 'libgdx' | 'korge' | 'compose' | 'generic';
+export declare class KotlinExporter extends ImperativeLanguageExporter {
+    readonly languageName = "kotlin";
+    readonly fileExtension = "kt";
+    readonly typeMapping: TypeMapping;
+    protected readonly statementTerminator = "";
+    protected readonly breakKeyword = "break";
+    protected readonly continueKeyword = "continue";
+    private target;
+    constructor(config?: Partial<ExportConfig>);
+    protected generateScript(script: ASTScript): string;
+    private generateImports;
+    protected generateClass(cls: ASTClass, builder: CodeBuilder): void;
+    private getBaseClass;
+    protected generateEnum(en: ASTEnum, builder: CodeBuilder): void;
+    private generateInitBlock;
+    private generateClassMethod;
+    protected generateMethod(method: ASTFunction, builder: CodeBuilder): void;
+    protected generateField(field: ASTField, builder: CodeBuilder): void;
+    private isReferenceType;
+    private isOverrideMethod;
+    private convertMethodName;
+    private mapReturnType;
+    private generateParams;
+    private getDefaultValue;
+    protected generateVarDecl(decl: ASTVarDecl, builder: CodeBuilder): void;
+    protected generateAssignment(assign: ASTAssignment, builder: CodeBuilder): void;
+    protected generateIf(stmt: ASTIf, builder: CodeBuilder): void;
+    protected generateWhile(stmt: ASTWhile, builder: CodeBuilder): void;
+    protected generateFor(stmt: ASTFor, builder: CodeBuilder): void;
+    protected generateForEach(stmt: ASTForEach, builder: CodeBuilder): void;
+    protected generateReturn(stmt: ASTReturn, builder: CodeBuilder): void;
+    protected generateSwitch(stmt: ASTSwitch, builder: CodeBuilder): void;
+    protected generateTry(stmt: ASTTry, builder: CodeBuilder): void;
+    protected generateLiteral(lit: ASTLiteral): string;
+    protected generateBinaryOp(op: ASTBinaryOp): string;
+    protected generateUnaryOp(op: ASTUnaryOp): string;
+    protected generateCall(call: ASTCall): string;
+    protected generateMethodCall(call: ASTMethodCall): string;
+    protected generatePropertyAccess(access: ASTPropertyAccess): string;
+    protected generateIndexAccess(access: ASTIndexAccess): string;
+    protected generateConditional(cond: ASTConditional): string;
+    protected generateArrayLiteral(arr: ASTArrayLiteral): string;
+    protected generateDictionaryLiteral(dict: ASTDictionaryLiteral): string;
+    protected generateCast(cast: ASTCast): string;
+    protected generateLambda(lambda: ASTLambda): string;
+    protected generateNew(newExpr: ASTNew): string;
+    private convertFunctionName;
+}
+export default KotlinExporter;

package/dist/types/scripting/exporters/LuaExporter.d.ts

@@ -1,5 +1,5 @@
-import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum } from '../ScriptAST';
 import { ImperativeLanguageExporter, TypeMapping, CodeBuilder, ExportConfig } from '../LanguageExporter';
+import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum } from '../ScriptAST';
 export type LuaTarget = 'love2d' | 'defold' | 'generic';
 export declare class LuaExporter extends ImperativeLanguageExporter {
     readonly languageName = "lua";

package/dist/types/scripting/exporters/PythonExporter.d.ts

@@ -1,5 +1,5 @@
-import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum, ASTImport } from '../ScriptAST';
 import { ImperativeLanguageExporter, TypeMapping, CodeBuilder, ExportConfig } from '../LanguageExporter';
+import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum, ASTImport } from '../ScriptAST';
 export type PythonTarget = 'pygame' | 'arcade' | 'generic';
 export declare class PythonExporter extends ImperativeLanguageExporter {
     readonly languageName = "python";

package/dist/types/scripting/exporters/RustExporter.d.ts

@@ -1,5 +1,5 @@
-import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum, ASTImport } from '../ScriptAST';
 import { ImperativeLanguageExporter, TypeMapping, CodeBuilder, ExportConfig } from '../LanguageExporter';
+import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum, ASTImport } from '../ScriptAST';
 export declare class RustExporter extends ImperativeLanguageExporter {
     readonly languageName = "rust";
     readonly fileExtension = "rs";

package/dist/types/scripting/exporters/SwiftExporter.d.ts

@@ -0,0 +1,52 @@
+import { ImperativeLanguageExporter, TypeMapping, CodeBuilder, ExportConfig } from '../LanguageExporter';
+import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum } from '../ScriptAST';
+export type SwiftTarget = 'spritekit' | 'scenekit' | 'metal' | 'generic';
+export declare class SwiftExporter extends ImperativeLanguageExporter {
+    readonly languageName = "swift";
+    readonly fileExtension = "swift";
+    readonly typeMapping: TypeMapping;
+    protected readonly statementTerminator = "";
+    protected readonly breakKeyword = "break";
+    protected readonly continueKeyword = "continue";
+    private target;
+    constructor(config?: Partial<ExportConfig>);
+    protected generateScript(script: ASTScript): string;
+    private generateImports;
+    protected generateClass(cls: ASTClass, builder: CodeBuilder): void;
+    private getBaseClass;
+    protected generateEnum(en: ASTEnum, builder: CodeBuilder): void;
+    private generateInit;
+    private generateRequiredInit;
+    private generateClassMethod;
+    protected generateMethod(method: ASTFunction, builder: CodeBuilder): void;
+    protected generateField(field: ASTField, builder: CodeBuilder): void;
+    private isOverrideMethod;
+    private convertMethodName;
+    private mapReturnType;
+    private generateParams;
+    private getDefaultValue;
+    protected generateVarDecl(decl: ASTVarDecl, builder: CodeBuilder): void;
+    protected generateAssignment(assign: ASTAssignment, builder: CodeBuilder): void;
+    protected generateIf(stmt: ASTIf, builder: CodeBuilder): void;
+    protected generateWhile(stmt: ASTWhile, builder: CodeBuilder): void;
+    protected generateFor(stmt: ASTFor, builder: CodeBuilder): void;
+    protected generateForEach(stmt: ASTForEach, builder: CodeBuilder): void;
+    protected generateReturn(stmt: ASTReturn, builder: CodeBuilder): void;
+    protected generateSwitch(stmt: ASTSwitch, builder: CodeBuilder): void;
+    protected generateTry(stmt: ASTTry, builder: CodeBuilder): void;
+    protected generateLiteral(lit: ASTLiteral): string;
+    protected generateBinaryOp(op: ASTBinaryOp): string;
+    protected generateUnaryOp(op: ASTUnaryOp): string;
+    protected generateCall(call: ASTCall): string;
+    protected generateMethodCall(call: ASTMethodCall): string;
+    protected generatePropertyAccess(access: ASTPropertyAccess): string;
+    protected generateIndexAccess(access: ASTIndexAccess): string;
+    protected generateConditional(cond: ASTConditional): string;
+    protected generateArrayLiteral(arr: ASTArrayLiteral): string;
+    protected generateDictionaryLiteral(dict: ASTDictionaryLiteral): string;
+    protected generateCast(cast: ASTCast): string;
+    protected generateLambda(lambda: ASTLambda): string;
+    protected generateNew(newExpr: ASTNew): string;
+    private convertFunctionName;
+}
+export default SwiftExporter;

package/dist/types/scripting/exporters/TypeScriptExporter.d.ts

@@ -1,5 +1,5 @@
-import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTProperty, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum, ASTImport } from '../ScriptAST';
 import { ImperativeLanguageExporter, TypeMapping, CodeBuilder, ExportConfig } from '../LanguageExporter';
+import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTProperty, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum, ASTImport } from '../ScriptAST';
 export type TypeScriptTarget = 'nice2dev' | 'browser' | 'node';
 export declare class TypeScriptExporter extends ImperativeLanguageExporter {
     readonly languageName = "typescript";

package/dist/types/scripting/exporters/index.d.ts

@@ -1,8 +1,12 @@
+export { CppExporter } from './CppExporter';
 export { CSharpExporter } from './CSharpExporter';
 export { GDScriptExporter } from './GDScriptExporter';
+export { HaxeExporter } from './HaxeExporter';
+export { KotlinExporter } from './KotlinExporter';
 export { LuaExporter } from './LuaExporter';
 export { PythonExporter } from './PythonExporter';
 export { RustExporter } from './RustExporter';
+export { SwiftExporter } from './SwiftExporter';
 export { TypeScriptExporter } from './TypeScriptExporter';
 export type { ExportConfig, ExportResult, ExportedFile, ExportError, ExportWarning, TypeMapping, } from '../LanguageExporter';
 export { LanguageExporter, ImperativeLanguageExporter, CodeBuilder, defaultConfig, escapeString, toUpperCamelCase, toLowerCamelCase, toSnakeCase, toScreamingSnakeCase, } from '../LanguageExporter';

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

@@ -3,11 +3,17 @@ export type { PortDataType, PortDirection, PortDef, NodeCategory, NodeDef, NodeE
 export * from './ScriptAST';
 export { LanguageExporter, ImperativeLanguageExporter, CodeBuilder, defaultConfig, escapeString, toUpperCamelCase, toLowerCamelCase, toSnakeCase, toScreamingSnakeCase, } from './LanguageExporter';
 export type { ExportConfig, ExportResult, ExportedFile, ExportError, ExportWarning, TypeMapping, } from './LanguageExporter';
+export { CppExporter } from './exporters/CppExporter';
 export { CSharpExporter } from './exporters/CSharpExporter';
 export { GDScriptExporter } from './exporters/GDScriptExporter';
+export { HaxeExporter } from './exporters/HaxeExporter';
+export { KotlinExporter } from './exporters/KotlinExporter';
 export { LuaExporter } from './exporters/LuaExporter';
 export { PythonExporter } from './exporters/PythonExporter';
 export { RustExporter } from './exporters/RustExporter';
+export { SwiftExporter } from './exporters/SwiftExporter';
 export { TypeScriptExporter } from './exporters/TypeScriptExporter';
+export { WasmCompiler, compileToWasm, generateWasmRuntime, STANDARD_HOST_IMPORTS, defaultWasmConfig, } from './WasmCompiler';
+export type { WasmValueType, WasmFuncType, WasmFunc, WasmGlobal, WasmModule, WasmCompileConfig, WasmCompileResult, WasmHostImport, } from './WasmCompiler';
 export { GraphToAST, convertGraphToAST } from './GraphToAST';
 export type { ConvertOptions } from './GraphToAST';

package/dist/types/systems/LightingSystem.d.ts

@@ -0,0 +1,276 @@
+/**
+ * @file LightingSystem.ts
+ * @description Advanced Lighting System with Lightmap Baking and GI
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Light types (Directional, Point, Spot, Area)
+ * - Light probes for indirect lighting
+ * - Reflection probes
+ * - Lightmap baking (progressive, GPU-accelerated)
+ * - Global Illumination preview
+ * - Shadow configuration
+ * - Light cookies
+ * - IES profiles
+ */
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface Bounds {
+    min: Vec3;
+    max: Vec3;
+}
+export type LightType = 'directional' | 'point' | 'spot' | 'area' | 'disc';
+export type ShadowType = 'none' | 'hard' | 'soft';
+export type ShadowResolution = 256 | 512 | 1024 | 2048 | 4096;
+export type LightMode = 'realtime' | 'mixed' | 'baked';
+export type LightRenderMode = 'auto' | 'forcePixel' | 'forceVertex';
+export type AreaLightType = 'rectangle' | 'disc' | 'line';
+export interface LightComponent {
+    id: string;
+    name: string;
+    type: LightType;
+    enabled: boolean;
+    position: Vec3;
+    rotation: Vec3;
+    scale: Vec3;
+    color: Color;
+    intensity: number;
+    indirectMultiplier: number;
+    range: number;
+    mode: LightMode;
+    renderMode: LightRenderMode;
+    spotAngle: number;
+    outerSpotAngle: number;
+    areaSize: {
+        width: number;
+        height: number;
+    };
+    areaLightType: AreaLightType;
+    shadows: ShadowType;
+    shadowStrength: number;
+    shadowResolution: ShadowResolution;
+    shadowBias: number;
+    shadowNormalBias: number;
+    shadowNearPlane: number;
+    shadowSoftness: number;
+    shadowSoftnessFalloff: number;
+    cullingMask: number;
+    renderingLayerMask: number;
+    cookieTextureId?: string;
+    cookieSize: number;
+    iesProfileId?: string;
+    lightmapBakeType: 'baked' | 'realtime' | 'mixed';
+    affectsLightmaps: boolean;
+    affectsSpecular: boolean;
+}
+export declare function createDirectionalLight(name: string): LightComponent;
+export declare function createPointLight(name: string, position: Vec3): LightComponent;
+export declare function createSpotLight(name: string, position: Vec3): LightComponent;
+export declare function createAreaLight(name: string, position: Vec3): LightComponent;
+export interface SphericalHarmonics {
+    /** 9 RGB coefficients for L0, L1, L2 bands */
+    coefficients: Float32Array;
+}
+export interface LightProbe {
+    id: string;
+    position: Vec3;
+    /** Baked spherical harmonics */
+    sh: SphericalHarmonics;
+    /** Is this probe valid/baked */
+    isValid: boolean;
+}
+export interface LightProbeGroup {
+    id: string;
+    name: string;
+    probes: LightProbe[];
+    /** Interpolation mode */
+    interpolationMode: 'linear' | 'spherical';
+    /** Density for auto-placement */
+    density: number;
+    /** Bounds for auto-placement */
+    bounds: Bounds;
+}
+export declare function createLightProbeGroup(name: string): LightProbeGroup;
+export declare function createLightProbe(position: Vec3): LightProbe;
+export type ReflectionProbeType = 'baked' | 'realtime' | 'custom';
+export type ReflectionProbeRefresh = 'onAwake' | 'everyFrame' | 'viaScripting';
+export interface ReflectionProbe {
+    id: string;
+    name: string;
+    position: Vec3;
+    rotation: Vec3;
+    type: ReflectionProbeType;
+    refreshMode: ReflectionProbeRefresh;
+    timeSlicing: 'allFacesAtOnce' | 'individualFaces' | 'noTimeSlicing';
+    size: Vec3;
+    center: Vec3;
+    blendDistance: number;
+    boxProjection: boolean;
+    resolution: 16 | 32 | 64 | 128 | 256 | 512 | 1024 | 2048;
+    hdr: boolean;
+    shadowDistance: number;
+    clearFlags: 'skybox' | 'solidColor';
+    backgroundColor: Color;
+    cullingMask: number;
+    nearClip: number;
+    farClip: number;
+    intensity: number;
+    importance: number;
+    bakedCubemapId?: string;
+    isValid: boolean;
+}
+export declare function createReflectionProbe(name: string, position: Vec3): ReflectionProbe;
+export type LightmapMode = 'nonDirectional' | 'directional' | 'shadowmask';
+export type LightmapMixedMode = 'bakedIndirect' | 'shadowmask' | 'subtractive';
+export type LightmapDenoiser = 'none' | 'optix' | 'openImageDenoise' | 'radeonProImage';
+export type GIMode = 'none' | 'baked' | 'enlighten';
+export interface LightmapSettings {
+    mode: LightmapMode;
+    mixedMode: LightmapMixedMode;
+    lightmapper: 'progressive' | 'progressiveGPU' | 'enlighten';
+    prioritizeView: boolean;
+    multipleImportanceSampling: boolean;
+    lightmapResolution: number;
+    lightmapPadding: number;
+    maxLightmapSize: 1024 | 2048 | 4096;
+    compressLightmaps: boolean;
+    directSamples: number;
+    indirectSamples: number;
+    bounces: number;
+    denoiser: LightmapDenoiser;
+    filteringMode: 'none' | 'auto' | 'advanced';
+    directFilter: number;
+    indirectFilter: number;
+    ambientOcclusionFilter: number;
+    ambientOcclusion: boolean;
+    aoMaxDistance: number;
+    aoIndirectContribution: number;
+    aoDirectContribution: number;
+    environmentLighting: 'skybox' | 'gradient' | 'color';
+    skyColor: Color;
+    equatorColor: Color;
+    groundColor: Color;
+    environmentIntensity: number;
+    albedoBoost: number;
+    indirectIntensity: number;
+    extractAO: boolean;
+}
+export declare const DEFAULT_LIGHTMAP_SETTINGS: LightmapSettings;
+export interface Lightmap {
+    id: string;
+    /** Lightmap texture pixels (RGBA for color + direction) */
+    colorData: Uint8Array;
+    /** Direction map (for directional mode) */
+    directionData?: Uint8Array;
+    /** Shadowmask (for mixed lighting) */
+    shadowmaskData?: Uint8Array;
+    /** Resolution */
+    width: number;
+    height: number;
+    /** HDR format */
+    isHDR: boolean;
+}
+export interface LightmapUV {
+    entityId: string;
+    /** Lightmap index */
+    lightmapIndex: number;
+    /** UV offset and scale */
+    uvOffset: {
+        x: number;
+        y: number;
+    };
+    uvScale: {
+        x: number;
+        y: number;
+    };
+}
+export type BakePhase = 'idle' | 'preparing' | 'directLighting' | 'indirectLighting' | 'denoising' | 'compositing' | 'probes' | 'reflections' | 'finished' | 'cancelled' | 'error';
+export interface BakeProgress {
+    phase: BakePhase;
+    progress: number;
+    totalProgress: number;
+    currentBounce: number;
+    totalBounces: number;
+    samplesRendered: number;
+    totalSamples: number;
+    lightmapsCompleted: number;
+    totalLightmaps: number;
+    probesCompleted: number;
+    totalProbes: number;
+    reflectionProbesCompleted: number;
+    totalReflectionProbes: number;
+    elapsedTime: number;
+    estimatedRemainingTime: number;
+    message: string;
+}
+export declare class LightingSystem {
+    private lights;
+    private lightProbeGroups;
+    private reflectionProbes;
+    private lightmaps;
+    private lightmapUVs;
+    private settings;
+    private bakeProgress;
+    private bakeAbort;
+    private bakeCallbacks;
+    addLight(light: LightComponent): void;
+    removeLight(lightId: string): void;
+    getLight(lightId: string): LightComponent | undefined;
+    getAllLights(): LightComponent[];
+    getRealtimeLights(): LightComponent[];
+    getBakedLights(): LightComponent[];
+    addLightProbeGroup(group: LightProbeGroup): void;
+    removeLightProbeGroup(groupId: string): void;
+    getLightProbeGroup(groupId: string): LightProbeGroup | undefined;
+    getAllLightProbeGroups(): LightProbeGroup[];
+    /** Auto-generate probes within bounds */
+    autoGenerateProbes(groupId: string): void;
+    /** Get interpolated spherical harmonics at a position */
+    sampleLightProbes(position: Vec3): SphericalHarmonics | null;
+    addReflectionProbe(probe: ReflectionProbe): void;
+    removeReflectionProbe(probeId: string): void;
+    getReflectionProbe(probeId: string): ReflectionProbe | undefined;
+    getAllReflectionProbes(): ReflectionProbe[];
+    /** Get blended reflection at a position */
+    sampleReflection(position: Vec3): string | null;
+    getSettings(): LightmapSettings;
+    setSettings(settings: Partial<LightmapSettings>): void;
+    onBakeProgress(callback: (progress: BakeProgress) => void): () => void;
+    private emitProgress;
+    startBake(entityBounds: Map<string, Bounds>): Promise<void>;
+    cancelBake(): void;
+    getBakeProgress(): BakeProgress;
+    private countTotalProbes;
+    private prepareForBake;
+    private calculateTotalLightmapArea;
+    private packLightmapUVs;
+    private bakeDirectLighting;
+    private calculateDirectLighting;
+    private bakeIndirectBounce;
+    private sampleIndirectLighting;
+    private denoiseLightmaps;
+    private applyBoxBlur;
+    private compositeLightmaps;
+    private bakeLightProbes;
+    private computeSphericalHarmonics;
+    private sampleEnvironmentLighting;
+    private bakeReflectionProbes;
+    private renderCubemap;
+    private sleep;
+    enableGIPreview(_enable: boolean): void;
+    getLightmaps(): Lightmap[];
+    getLightmapUVs(): LightmapUV[];
+    serialize(): string;
+    static deserialize(json: string): LightingSystem;
+}
+export declare function createLightingSystem(): LightingSystem;
+export declare function createDefaultLightingSetup(): LightingSystem;