@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-I3XGTIHM.cjs

@@ -1,1505 +0,0 @@
-'use strict';
-
-// src/traits/LightingTrait.ts
-var LightingTrait = class {
-  constructor(config) {
-    this.lights = /* @__PURE__ */ new Map();
-    this.lightIdCounter = 0;
-    this.globalIllumination = {
-      enabled: true,
-      intensity: 1,
-      skyColor: { r: 0.5, g: 0.7, b: 1 },
-      skyIntensity: 1,
-      groundColor: { r: 0.4, g: 0.4, b: 0.4 },
-      groundIntensity: 0.5,
-      probes: true,
-      indirectDiffuse: 1,
-      indirectSpecular: 1,
-      aoIntensity: 1,
-      screenSpaceAO: true,
-      ...config
-    };
-  }
-  /**
-   * Add a light to the scene
-   */
-  addLight(light) {
-    const id = light.name || `light_${this.lightIdCounter++}`;
-    this.lights.set(id, light);
-    return id;
-  }
-  /**
-   * Get light by ID
-   */
-  getLight(id) {
-    return this.lights.get(id);
-  }
-  /**
-   * Get all lights
-   */
-  getLights() {
-    return Array.from(this.lights.values());
-  }
-  /**
-   * Get lights by type
-   */
-  getLightsByType(type) {
-    return Array.from(this.lights.values()).filter((l) => l.type === type);
-  }
-  /**
-   * Update light properties
-   */
-  updateLight(id, updates) {
-    const light = this.lights.get(id);
-    if (!light) return false;
-    this.lights.set(id, { ...light, ...updates });
-    return true;
-  }
-  /**
-   * Remove light
-   */
-  removeLight(id) {
-    return this.lights.delete(id);
-  }
-  /**
-   * Clear all lights
-   */
-  clearLights() {
-    this.lights.clear();
-  }
-  /**
-   * Get global illumination config
-   */
-  getGlobalIllumination() {
-    return { ...this.globalIllumination };
-  }
-  /**
-   * Update global illumination
-   */
-  updateGlobalIllumination(updates) {
-    this.globalIllumination = {
-      ...this.globalIllumination,
-      ...updates
-    };
-  }
-  /**
-   * Enable/disable GI
-   */
-  setGIEnabled(enabled) {
-    this.globalIllumination.enabled = enabled;
-  }
-  /**
-   * Set ambient light colors (skybox mode)
-   */
-  setAmbientLight(skyColor, groundColor, intensity = 1) {
-    this.globalIllumination.skyColor = skyColor;
-    this.globalIllumination.groundColor = groundColor;
-    this.globalIllumination.skyIntensity = intensity;
-    this.globalIllumination.groundIntensity = intensity * 0.5;
-  }
-  /**
-   * Enable/disable screen-space ambient occlusion
-   */
-  setScreenSpaceAO(enabled, intensity = 1) {
-    this.globalIllumination.screenSpaceAO = enabled;
-    this.globalIllumination.aoIntensity = intensity;
-  }
-  /**
-   * Create directional light (sun)
-   */
-  createDirectionalLight(direction, color, intensity = 1, castShadows = true) {
-    const light = {
-      type: "directional",
-      name: `sun_${this.lightIdCounter}`,
-      direction,
-      color,
-      intensity,
-      shadow: castShadows ? {
-        type: "soft",
-        resolution: 2048,
-        cascades: 4,
-        softness: 1
-      } : void 0,
-      volumetric: true,
-      priority: 100
-    };
-    return this.addLight(light);
-  }
-  /**
-   * Create point light
-   */
-  createPointLight(position, color, intensity, range, castShadows = false) {
-    const light = {
-      type: "point",
-      name: `point_${this.lightIdCounter}`,
-      position,
-      color,
-      intensity,
-      range,
-      shadow: castShadows ? {
-        type: "soft",
-        resolution: 512,
-        softness: 0.5
-      } : void 0,
-      priority: 50
-    };
-    return this.addLight(light);
-  }
-  /**
-   * Create spot light
-   */
-  createSpotLight(position, direction, color, intensity, range, spotAngle = 45, castShadows = true) {
-    const light = {
-      type: "spot",
-      name: `spot_${this.lightIdCounter}`,
-      position,
-      direction,
-      color,
-      intensity,
-      range,
-      spotAngle,
-      innerSpotAngle: spotAngle * 0.5,
-      shadow: castShadows ? {
-        type: "soft",
-        resolution: 1024,
-        softness: 0.8
-      } : void 0,
-      priority: 75
-    };
-    return this.addLight(light);
-  }
-  /**
-   * Create area light for soft lighting
-   */
-  createAreaLight(position, color, intensity, width, height) {
-    const light = {
-      type: "area",
-      name: `area_${this.lightIdCounter}`,
-      position,
-      color,
-      intensity,
-      range: Math.max(width, height) * 2,
-      priority: 25
-    };
-    return this.addLight(light);
-  }
-  /**
-   * Get shadow-casting lights
-   */
-  getShadowCastingLights() {
-    return Array.from(this.lights.values()).filter((l) => l.shadow && l.shadow.type !== "none");
-  }
-  /**
-   * Get light count by type
-   */
-  getLightCount() {
-    const counts = {
-      directional: 0,
-      point: 0,
-      spot: 0,
-      area: 0,
-      probe: 0
-    };
-    for (const light of Array.from(this.lights.values())) {
-      counts[light.type]++;
-    }
-    return counts;
-  }
-  /**
-   * Estimate light impact for performance optimization
-   */
-  getPerformanceImpact() {
-    const totalLights = this.lights.size;
-    const shadowCasters = this.getShadowCastingLights().length;
-    let estimatedGPUCost = "low";
-    if (totalLights > 16 || shadowCasters > 4) {
-      estimatedGPUCost = "high";
-    } else if (totalLights > 8 || shadowCasters > 2) {
-      estimatedGPUCost = "medium";
-    }
-    return {
-      totalLights,
-      shadowCasters,
-      estimatedGPUCost
-    };
-  }
-  /**
-   * Get scene complexity info
-   */
-  getSceneInfo() {
-    const counts = this.getLightCount();
-    const impact = this.getPerformanceImpact();
-    return `Lighting: ${counts.directional} dir, ${counts.point} point, ${counts.spot} spot | Shadows: ${impact.shadowCasters} | GPU: ${impact.estimatedGPUCost}`;
-  }
-  /**
-   * Dispose and cleanup
-   */
-  dispose() {
-    this.lights.clear();
-  }
-};
-function createLightingTrait(config) {
-  return new LightingTrait(config);
-}
-var LIGHTING_PRESETS = {
-  /** Neutral studio lighting */
-  studio: () => ({
-    enabled: true,
-    intensity: 1,
-    skyColor: { r: 0.5, g: 0.5, b: 0.5 },
-    skyIntensity: 0.5,
-    groundColor: { r: 0.3, g: 0.3, b: 0.3 },
-    groundIntensity: 0.3
-  }),
-  /** Bright outdoor lighting */
-  outdoor: () => ({
-    enabled: true,
-    intensity: 1.2,
-    skyColor: { r: 0.7, g: 0.85, b: 1 },
-    skyIntensity: 1,
-    groundColor: { r: 0.4, g: 0.4, b: 0.35 },
-    groundIntensity: 0.6,
-    indirectDiffuse: 1.2
-  }),
-  /** Dim interior lighting */
-  interior: () => ({
-    enabled: true,
-    intensity: 0.6,
-    skyColor: { r: 0.3, g: 0.3, b: 0.35 },
-    skyIntensity: 0.4,
-    groundColor: { r: 0.2, g: 0.2, b: 0.2 },
-    groundIntensity: 0.2
-  }),
-  /** Night scene */
-  night: () => ({
-    enabled: true,
-    intensity: 0.3,
-    skyColor: { r: 0.01, g: 0.01, b: 0.02 },
-    skyIntensity: 0.1,
-    groundColor: { r: 0.02, g: 0.02, b: 0.02 },
-    groundIntensity: 0.05,
-    screenSpaceAO: false
-  }),
-  /** Sunset/golden hour */
-  sunset: () => ({
-    enabled: true,
-    intensity: 1.1,
-    skyColor: { r: 1, g: 0.7, b: 0.3 },
-    skyIntensity: 1,
-    groundColor: { r: 0.6, g: 0.4, b: 0.2 },
-    groundIntensity: 0.8
-  })
-};
-var lightingHandler = {
-  name: "lighting",
-  defaultConfig: {},
-  onAttach(node, config, ctx) {
-    const instance = new LightingTrait(config);
-    node.__lighting_instance = instance;
-    ctx.emit("lighting_attached", { node, config });
-  },
-  onDetach(node, _config, ctx) {
-    const instance = node.__lighting_instance;
-    if (instance) {
-      if (typeof instance.onDetach === "function") instance.onDetach(node, ctx);
-      else if (typeof instance.dispose === "function") instance.dispose();
-      else if (typeof instance.cleanup === "function") instance.cleanup();
-    }
-    ctx.emit("lighting_detached", { node });
-    delete node.__lighting_instance;
-  },
-  onEvent(node, _config, ctx, event) {
-    const instance = node.__lighting_instance;
-    if (!instance) return;
-    if (typeof instance.onEvent === "function") instance.onEvent(event);
-    else if (typeof instance.emit === "function" && event.type) instance.emit(event);
-    if (event.type === "lighting_configure" && event.payload) {
-      Object.assign(instance, event.payload);
-      ctx.emit("lighting_configured", { node });
-    }
-  },
-  onUpdate(node, _config, ctx, dt) {
-    const instance = node.__lighting_instance;
-    if (!instance) return;
-    if (typeof instance.onUpdate === "function") instance.onUpdate(node, ctx, dt);
-  }
-};
-
-// src/traits/MaterialTrait.ts
-var MaterialTrait = class {
-  constructor(config) {
-    this.textureCache = /* @__PURE__ */ new Map();
-    this.material = {
-      ...{ type: "pbr" },
-      ...config
-    };
-  }
-  /**
-   * Get material properties
-   */
-  getMaterial() {
-    return { ...this.material };
-  }
-  /**
-   * Update material property
-   */
-  setProperty(key, value) {
-    this.material[key] = value;
-  }
-  /**
-   * Get PBR properties
-   */
-  getPBRProperties() {
-    return this.material.pbr;
-  }
-  /**
-   * Update PBR material
-   */
-  updatePBR(pbr) {
-    if (!this.material.pbr) {
-      this.material.pbr = {
-        baseColor: { r: 1, g: 1, b: 1 },
-        metallic: 0,
-        roughness: 0.5
-      };
-    }
-    this.material.pbr = { ...this.material.pbr, ...pbr };
-  }
-  /**
-   * Add texture map
-   */
-  addTexture(texture) {
-    if (!this.material.textures) {
-      this.material.textures = [];
-    }
-    this.material.textures.push(texture);
-  }
-  /**
-   * Get all textures
-   */
-  getTextures() {
-    return [...this.material.textures || []];
-  }
-  /**
-   * Clear texture cache (for memory optimization)
-   */
-  clearTextureCache() {
-    this.textureCache.clear();
-  }
-  /**
-   * Get shader code if custom
-   */
-  getCustomShader() {
-    return this.material.customShader;
-  }
-  /**
-   * Set custom shader
-   */
-  setCustomShader(shader) {
-    this.material.customShader = shader;
-  }
-  /**
-   * Get optimization hints
-   */
-  getOptimization() {
-    return this.material.optimization;
-  }
-  /**
-   * Enable/disable texture streaming
-   */
-  setTextureStreaming(enabled) {
-    if (!this.material.optimization) {
-      this.material.optimization = {};
-    }
-    this.material.optimization.streamTextures = enabled;
-  }
-  /**
-   * Set texture compression
-   */
-  setCompression(compression) {
-    if (!this.material.optimization) {
-      this.material.optimization = {};
-    }
-    this.material.optimization.compression = compression;
-  }
-  /**
-   * Enable material instancing for performance
-   */
-  setInstanced(instanced) {
-    if (!this.material.optimization) {
-      this.material.optimization = {};
-    }
-    this.material.optimization.instanced = instanced;
-  }
-  /**
-   * Dispose and cleanup
-   */
-  dispose() {
-    this.textureCache.clear();
-  }
-};
-function createMaterialTrait(config) {
-  return new MaterialTrait(config);
-}
-var MATERIAL_PRESETS = {
-  /** Shiny metal */
-  chrome: () => ({
-    type: "pbr",
-    pbr: {
-      baseColor: { r: 0.77, g: 0.77, b: 0.77 },
-      metallic: 1,
-      roughness: 0.1
-    }
-  }),
-  /** Rough plastic */
-  plastic: () => ({
-    type: "pbr",
-    pbr: {
-      baseColor: { r: 1, g: 1, b: 1 },
-      metallic: 0,
-      roughness: 0.8
-    }
-  }),
-  /** Wood texture */
-  wood: () => ({
-    type: "pbr",
-    pbr: {
-      baseColor: { r: 0.6, g: 0.4, b: 0.2 },
-      metallic: 0,
-      roughness: 0.4
-    }
-  }),
-  /** Glass */
-  glass: () => ({
-    type: "transparent",
-    blendMode: "blend",
-    pbr: {
-      baseColor: { r: 1, g: 1, b: 1, a: 0.3 },
-      metallic: 0,
-      roughness: 0,
-      ior: 1.5,
-      transmission: 0.9
-    }
-  }),
-  /** Emissive (glowing) */
-  emissive: () => ({
-    type: "pbr",
-    pbr: {
-      baseColor: { r: 0, g: 1, b: 0 },
-      metallic: 0,
-      roughness: 1,
-      emission: {
-        color: { r: 0, g: 1, b: 0 },
-        intensity: 2
-      }
-    }
-  }),
-  /** Skin material */
-  skin: () => ({
-    type: "pbr",
-    pbr: {
-      baseColor: { r: 1, g: 0.8, b: 0.7 },
-      metallic: 0,
-      roughness: 0.5,
-      ambientOcclusion: 0.8
-    }
-  })
-};
-var materialHandler = {
-  name: "material",
-  defaultConfig: {},
-  onAttach(node, config, ctx) {
-    const instance = new MaterialTrait(config);
-    node.__material_instance = instance;
-    ctx.emit("material_attached", { node, config });
-  },
-  onDetach(node, _config, ctx) {
-    const instance = node.__material_instance;
-    if (instance) {
-      if (typeof instance.onDetach === "function") instance.onDetach(node, ctx);
-      else if (typeof instance.dispose === "function") instance.dispose();
-      else if (typeof instance.cleanup === "function") instance.cleanup();
-    }
-    ctx.emit("material_detached", { node });
-    delete node.__material_instance;
-  },
-  onEvent(node, _config, ctx, event) {
-    const instance = node.__material_instance;
-    if (!instance) return;
-    if (typeof instance.onEvent === "function") instance.onEvent(event);
-    else if (typeof instance.emit === "function" && event.type) instance.emit(event);
-    if (event.type === "material_configure" && event.payload) {
-      Object.assign(instance, event.payload);
-      ctx.emit("material_configured", { node });
-    }
-  },
-  onUpdate(node, _config, ctx, dt) {
-    const instance = node.__material_instance;
-    if (!instance) return;
-    if (typeof instance.onUpdate === "function") instance.onUpdate(node, ctx, dt);
-  }
-};
-
-// src/traits/RenderingTrait.ts
-var RenderingTrait = class {
-  constructor(config) {
-    this.optimization = {
-      lodStrategy: "automatic",
-      culling: {
-        mode: "back",
-        frustum: true,
-        occlusion: true
-      },
-      batching: {
-        static: true,
-        dynamic: true,
-        instancing: true,
-        maxInstanceCount: 1e3
-      },
-      textures: {
-        streaming: true,
-        compression: "auto",
-        mipmaps: true,
-        maxResolution: 2048
-      },
-      shaders: {
-        simplifiedShaders: true,
-        lodBias: 0
-      },
-      targetGPUTier: "high",
-      adaptiveQuality: true,
-      targetFrameRate: 60,
-      ...config
-    };
-  }
-  /**
-   * Get rendering optimization config
-   */
-  getOptimization() {
-    return JSON.parse(JSON.stringify(this.optimization));
-  }
-  /**
-   * Update rendering configuration
-   */
-  updateOptimization(updates) {
-    this.optimization = { ...this.optimization, ...updates };
-  }
-  /**
-   * Setup LOD levels (3 levels is typical)
-   */
-  setupLODLevels(strategy = "automatic") {
-    const levels = [
-      {
-        level: 0,
-        screenRelativeSize: 0.5,
-        polygonReduction: 1,
-        textureScale: 1
-      },
-      {
-        level: 1,
-        screenRelativeSize: 0.25,
-        polygonReduction: 0.6,
-        disabledFeatures: ["specular"],
-        textureScale: 0.5
-      },
-      {
-        level: 2,
-        screenRelativeSize: 0.1,
-        polygonReduction: 0.3,
-        disabledFeatures: ["specular", "normals"],
-        textureScale: 0.25
-      }
-    ];
-    this.optimization.lodStrategy = strategy;
-    this.optimization.lodLevels = levels;
-  }
-  /**
-   * Get LOD levels
-   */
-  getLODLevels() {
-    return [...this.optimization.lodLevels || []];
-  }
-  /**
-   * Configure culling
-   */
-  setCulling(config) {
-    const defaultCulling = { mode: "back" };
-    this.optimization.culling = {
-      ...defaultCulling,
-      ...this.optimization.culling,
-      ...config
-    };
-  }
-  /**
-   * Enable frustum culling
-   */
-  setFrustumCulling(enabled) {
-    if (!this.optimization.culling) {
-      this.optimization.culling = { mode: "back" };
-    }
-    this.optimization.culling.frustum = enabled;
-  }
-  /**
-   * Enable occlusion culling
-   */
-  setOcclusionCulling(enabled, distance) {
-    if (!this.optimization.culling) {
-      this.optimization.culling = { mode: "back" };
-    }
-    this.optimization.culling.occlusion = enabled;
-    if (distance) {
-      this.optimization.culling.occlusionDistance = distance;
-    }
-  }
-  /**
-   * Configure batching
-   */
-  setBatching(config) {
-    this.optimization.batching = {
-      ...this.optimization.batching,
-      ...config
-    };
-  }
-  /**
-   * Enable GPU instancing
-   */
-  setInstancing(enabled, maxInstances) {
-    if (!this.optimization.batching) {
-      this.optimization.batching = {};
-    }
-    this.optimization.batching.instancing = enabled;
-    if (maxInstances) {
-      this.optimization.batching.maxInstanceCount = maxInstances;
-    }
-  }
-  /**
-   * Configure texture optimization
-   */
-  setTextureOptimization(config) {
-    this.optimization.textures = {
-      ...this.optimization.textures,
-      ...config
-    };
-  }
-  /**
-   * Enable texture streaming
-   */
-  setTextureStreaming(enabled, budgetMB) {
-    if (!this.optimization.textures) {
-      this.optimization.textures = {};
-    }
-    this.optimization.textures.streaming = enabled;
-    if (budgetMB) {
-      this.optimization.textures.streamingBudget = budgetMB;
-    }
-  }
-  /**
-   * Set texture compression
-   */
-  setTextureCompression(compression) {
-    if (!this.optimization.textures) {
-      this.optimization.textures = {};
-    }
-    this.optimization.textures.compression = compression;
-  }
-  /**
-   * Set max texture resolution
-   */
-  setMaxTextureResolution(resolution) {
-    if (!this.optimization.textures) {
-      this.optimization.textures = {};
-    }
-    this.optimization.textures.maxResolution = resolution;
-  }
-  /**
-   * Configure shader optimization
-   */
-  setShaderOptimization(config) {
-    this.optimization.shaders = {
-      ...this.optimization.shaders,
-      ...config
-    };
-  }
-  /**
-   * Set target GPU tier
-   */
-  setTargetGPUTier(tier) {
-    this.optimization.targetGPUTier = tier;
-  }
-  /**
-   * Enable adaptive quality (adjust based on frame rate)
-   */
-  setAdaptiveQuality(enabled, targetFrameRate) {
-    this.optimization.adaptiveQuality = enabled;
-    if (targetFrameRate) {
-      this.optimization.targetFrameRate = targetFrameRate;
-    }
-  }
-  /**
-   * Set fixed timestep for VR/AR
-   */
-  setFixedTimestep(timestep) {
-    this.optimization.fixedTimestep = timestep;
-  }
-  /**
-   * Get rendering preset for quality level
-   */
-  getPresetForQuality(quality) {
-    const presets = {
-      low: {
-        targetGPUTier: "low",
-        lodStrategy: "automatic",
-        culling: { mode: "back", frustum: true, occlusion: false },
-        batching: { instancing: true, maxInstanceCount: 500 },
-        textures: {
-          compression: "astc",
-          maxResolution: 512,
-          streaming: true,
-          streamingBudget: 128
-        },
-        adaptiveQuality: true,
-        targetFrameRate: 30
-      },
-      medium: {
-        targetGPUTier: "medium",
-        lodStrategy: "automatic",
-        culling: { mode: "back", frustum: true, occlusion: true },
-        batching: { instancing: true, maxInstanceCount: 1e3 },
-        textures: {
-          compression: "basis",
-          maxResolution: 1024,
-          streaming: true,
-          streamingBudget: 256
-        },
-        adaptiveQuality: true,
-        targetFrameRate: 60
-      },
-      high: {
-        targetGPUTier: "high",
-        lodStrategy: "automatic",
-        culling: { mode: "back", frustum: true, occlusion: true },
-        batching: { instancing: true, maxInstanceCount: 2e3 },
-        textures: {
-          compression: "dxt",
-          maxResolution: 2048,
-          streaming: true,
-          streamingBudget: 512
-        },
-        adaptiveQuality: false,
-        targetFrameRate: 60
-      },
-      ultra: {
-        targetGPUTier: "ultra",
-        lodStrategy: "manual",
-        culling: {
-          mode: "back",
-          frustum: true,
-          occlusion: true,
-          hierarchicalZ: true
-        },
-        batching: { instancing: true, maxInstanceCount: 5e3 },
-        textures: {
-          compression: "none",
-          maxResolution: 4096,
-          virtualTexturing: true,
-          streaming: true,
-          streamingBudget: 1024
-        },
-        adaptiveQuality: false,
-        targetFrameRate: 120
-      }
-    };
-    return { ...this.optimization, ...presets[quality] };
-  }
-  /**
-   * Apply quality preset
-   */
-  applyQualityPreset(quality) {
-    const preset = this.getPresetForQuality(quality);
-    this.optimization = preset;
-  }
-  /**
-   * Estimate GPU memory usage
-   */
-  estimateGPUMemory() {
-    let textureMemory = 0;
-    let vertexBuffers = 0;
-    const maxRes = this.optimization.textures?.maxResolution || 2048;
-    textureMemory = maxRes * maxRes * 4 / (1024 * 1024);
-    const instanceCount = this.optimization.batching?.maxInstanceCount || 1e3;
-    const verticesPerMesh = 1e4;
-    vertexBuffers = verticesPerMesh * 36 * instanceCount / (1024 * 1024) * 0.1;
-    return {
-      textureMemory: Math.round(textureMemory),
-      vertexBuffers: Math.max(1, Math.round(vertexBuffers)),
-      // At least 1MB
-      estimatedTotal: Math.round(textureMemory + Math.max(1, vertexBuffers))
-    };
-  }
-  /**
-   * Get rendering statistics/info
-   */
-  getInfo() {
-    const tier = this.optimization.targetGPUTier;
-    const lod = this.optimization.lodStrategy;
-    const culling = this.optimization.culling?.mode;
-    const instancing = this.optimization.batching?.instancing ? "yes" : "no";
-    const memory = this.estimateGPUMemory();
-    return `Rendering: tier=${tier} | LOD=${lod} | culling=${culling} | instancing=${instancing} | memory=${memory.estimatedTotal}MB`;
-  }
-  /**
-   * Optimize for VR/AR (fixed timestep, fast culling)
-   */
-  optimizeForVRAR(targetFPS = 90) {
-    this.optimization.fixedTimestep = 1 / targetFPS;
-    this.optimization.targetFrameRate = targetFPS;
-    this.setOcclusionCulling(true, 50);
-    this.setInstancing(true, 5e3);
-    this.setAdaptiveQuality(true, targetFPS);
-  }
-  /**
-   * Optimize for mobile (lower resources)
-   */
-  optimizeForMobile() {
-    this.applyQualityPreset("low");
-    this.setTextureCompression("astc");
-    this.setInstancing(true, 256);
-  }
-  /**
-   * Optimize for desktop (higher resources)
-   */
-  optimizeForDesktop() {
-    this.applyQualityPreset("ultra");
-    this.setTextureCompression("none");
-    this.setInstancing(true, 5e3);
-  }
-  /**
-   * Dispose and cleanup
-   */
-  dispose() {
-  }
-};
-function createRenderingTrait(config) {
-  return new RenderingTrait(config);
-}
-var renderingHandler = {
-  name: "rendering",
-  defaultConfig: {},
-  onAttach(node, config, ctx) {
-    const instance = new RenderingTrait(config);
-    node.__rendering_instance = instance;
-    ctx.emit("rendering_attached", { node, config });
-  },
-  onDetach(node, _config, ctx) {
-    const instance = node.__rendering_instance;
-    if (instance) {
-      if (typeof instance.onDetach === "function") instance.onDetach(node, ctx);
-      else if (typeof instance.dispose === "function") instance.dispose();
-      else if (typeof instance.cleanup === "function") instance.cleanup();
-    }
-    ctx.emit("rendering_detached", { node });
-    delete node.__rendering_instance;
-  },
-  onEvent(node, _config, ctx, event) {
-    const instance = node.__rendering_instance;
-    if (!instance) return;
-    if (typeof instance.onEvent === "function") instance.onEvent(event);
-    else if (typeof instance.emit === "function" && event.type) instance.emit(event);
-    if (event.type === "rendering_configure" && event.payload) {
-      Object.assign(instance, event.payload);
-      ctx.emit("rendering_configured", { node });
-    }
-  },
-  onUpdate(node, _config, ctx, dt) {
-    const instance = node.__rendering_instance;
-    if (!instance) return;
-    if (typeof instance.onUpdate === "function") instance.onUpdate(node, ctx, dt);
-  }
-};
-
-// src/traits/ShaderTrait.ts
-var SHADER_CHUNKS = {
-  /** Common noise functions */
-  noise: `
-// Simplex 2D noise
-vec3 mod289(vec3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
-vec2 mod289(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
-vec3 permute(vec3 x) { return mod289(((x*34.0)+1.0)*x); }
-
-float snoise(vec2 v) {
-  const vec4 C = vec4(0.211324865405187, 0.366025403784439,
-                      -0.577350269189626, 0.024390243902439);
-  vec2 i  = floor(v + dot(v, C.yy));
-  vec2 x0 = v -   i + dot(i, C.xx);
-  vec2 i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
-  vec4 x12 = x0.xyxy + C.xxzz;
-  x12.xy -= i1;
-  i = mod289(i);
-  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));
-  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
-  m = m*m;
-  m = m*m;
-  vec3 x = 2.0 * fract(p * C.www) - 1.0;
-  vec3 h = abs(x) - 0.5;
-  vec3 ox = floor(x + 0.5);
-  vec3 a0 = x - ox;
-  m *= 1.79284291400159 - 0.85373472095314 * (a0*a0 + h*h);
-  vec3 g;
-  g.x  = a0.x  * x0.x  + h.x  * x0.y;
-  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
-  return 130.0 * dot(m, g);
-}
-`,
-  /** Hologram effect */
-  hologram: `
-// Hologram scanline effect
-float hologramScanline(vec2 uv, float time, float density) {
-  return sin(uv.y * density + time * 2.0) * 0.5 + 0.5;
-}
-
-// Hologram flicker
-float hologramFlicker(float time) {
-  return 0.9 + 0.1 * sin(time * 20.0) * sin(time * 13.0);
-}
-
-// Hologram edge glow
-float hologramEdge(vec3 normal, vec3 viewDir) {
-  return pow(1.0 - abs(dot(normal, viewDir)), 2.0);
-}
-`,
-  /** Fresnel effect */
-  fresnel: `
-// Basic Fresnel
-float fresnel(vec3 normal, vec3 viewDir, float power) {
-  return pow(1.0 - abs(dot(normal, viewDir)), power);
-}
-
-// Schlick's approximation
-float fresnelSchlick(float cosTheta, float F0) {
-  return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
-}
-`,
-  /** PBR lighting */
-  pbr: `
-// Distribution function (GGX/Trowbridge-Reitz)
-float distributionGGX(vec3 N, vec3 H, float roughness) {
-  float a = roughness * roughness;
-  float a2 = a * a;
-  float NdotH = max(dot(N, H), 0.0);
-  float NdotH2 = NdotH * NdotH;
-  float num = a2;
-  float denom = (NdotH2 * (a2 - 1.0) + 1.0);
-  denom = 3.14159265 * denom * denom;
-  return num / denom;
-}
-
-// Geometry function (Schlick-GGX)
-float geometrySchlickGGX(float NdotV, float roughness) {
-  float r = (roughness + 1.0);
-  float k = (r * r) / 8.0;
-  float num = NdotV;
-  float denom = NdotV * (1.0 - k) + k;
-  return num / denom;
-}
-
-// Smith's geometry function
-float geometrySmith(vec3 N, vec3 V, vec3 L, float roughness) {
-  float NdotV = max(dot(N, V), 0.0);
-  float NdotL = max(dot(N, L), 0.0);
-  float ggx2 = geometrySchlickGGX(NdotV, roughness);
-  float ggx1 = geometrySchlickGGX(NdotL, roughness);
-  return ggx1 * ggx2;
-}
-`,
-  /** UV utilities */
-  uv: `
-// Rotate UV
-vec2 rotateUV(vec2 uv, float angle) {
-  float c = cos(angle);
-  float s = sin(angle);
-  return vec2(c * uv.x - s * uv.y, s * uv.x + c * uv.y);
-}
-
-// Tile UV
-vec2 tileUV(vec2 uv, vec2 scale) {
-  return fract(uv * scale);
-}
-
-// Parallax mapping
-vec2 parallaxUV(vec2 uv, vec3 viewDir, sampler2D heightMap, float scale) {
-  float height = texture2D(heightMap, uv).r;
-  vec2 p = viewDir.xy / viewDir.z * (height * scale);
-  return uv - p;
-}
-`
-};
-var ShaderTrait = class {
-  constructor(config) {
-    this.uniformValues = /* @__PURE__ */ new Map();
-    this.config = {
-      ...config,
-      source: {
-        language: config.source?.language || "glsl",
-        vertex: config.source?.vertex || "",
-        fragment: config.source?.fragment || "",
-        geometry: config.source?.geometry,
-        tessellationControl: config.source?.tessellationControl,
-        tessellationEvaluation: config.source?.tessellationEvaluation,
-        compute: config.source?.compute
-      }
-    };
-    if (config.uniforms) {
-      for (const [name, uniform] of Object.entries(config.uniforms)) {
-        this.uniformValues.set(name, uniform.value);
-      }
-    }
-  }
-  /**
-   * Get shader configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  /**
-   * Get vertex shader source with includes
-   */
-  getVertexSource() {
-    return this.assembleShaderSource("vertex");
-  }
-  /**
-   * Get fragment shader source with includes
-   */
-  getFragmentSource() {
-    return this.assembleShaderSource("fragment");
-  }
-  /**
-   * Assemble shader source with includes and uniforms
-   */
-  assembleShaderSource(stage) {
-    const source = this.config.source ? this.config.source[stage] : void 0;
-    if (!source) return "";
-    let assembled = "";
-    if (this.config.source?.language === "glsl") {
-      assembled += "precision highp float;\n\n";
-    }
-    if (this.config.uniforms) {
-      for (const [name, uniform] of Object.entries(this.config.uniforms)) {
-        assembled += `uniform ${this.getGLSLType(uniform.type)} ${name};
-`;
-      }
-      assembled += "\n";
-    }
-    if (this.config.includes) {
-      for (const include of this.config.includes) {
-        const chunk = SHADER_CHUNKS[include.path];
-        if (chunk) {
-          assembled += `// Include: ${include.path}
-${chunk}
-`;
-        }
-      }
-    }
-    assembled += source;
-    return assembled;
-  }
-  /**
-   * Convert uniform type to GLSL type
-   */
-  getGLSLType(type) {
-    const typeMap = {
-      float: "float",
-      int: "int",
-      bool: "bool",
-      vec2: "vec2",
-      vec3: "vec3",
-      vec4: "vec4",
-      mat2: "mat2",
-      mat3: "mat3",
-      mat4: "mat4",
-      sampler2D: "sampler2D",
-      samplerCube: "samplerCube"
-    };
-    return typeMap[type] || "float";
-  }
-  /**
-   * Set uniform value
-   */
-  setUniform(name, value) {
-    this.uniformValues.set(name, value);
-  }
-  /**
-   * Get uniform value
-   */
-  getUniform(name) {
-    return this.uniformValues.get(name);
-  }
-  /**
-   * Get all uniform values
-   */
-  getUniforms() {
-    return new Map(this.uniformValues);
-  }
-  /**
-   * Validate shader syntax
-   */
-  validate() {
-    const errors = [];
-    const warnings = [];
-    if (this.config.source?.vertex) {
-      const vertexErrors = this.validateShaderSyntax(this.config.source.vertex, "vertex");
-      errors.push(...vertexErrors);
-    }
-    if (this.config.source?.fragment) {
-      const fragmentErrors = this.validateShaderSyntax(this.config.source.fragment, "fragment");
-      errors.push(...fragmentErrors);
-    }
-    if (this.config.source?.vertex && !this.config.source.vertex.includes("void main")) {
-      errors.push({
-        stage: "vertex",
-        line: 1,
-        message: "Vertex shader must contain a main() function",
-        code: "E001"
-      });
-    }
-    if (this.config.source?.fragment && !this.config.source.fragment.includes("void main")) {
-      errors.push({
-        stage: "fragment",
-        line: 1,
-        message: "Fragment shader must contain a main() function",
-        code: "E002"
-      });
-    }
-    this.compilationResult = {
-      success: errors.length === 0,
-      errors,
-      warnings
-    };
-    return this.compilationResult;
-  }
-  /**
-   * Basic shader syntax validation
-   */
-  validateShaderSyntax(source, stage) {
-    const errors = [];
-    const lines = source.split("\n");
-    let braceCount = 0;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      braceCount += (line.match(/{/g) || []).length;
-      braceCount -= (line.match(/}/g) || []).length;
-    }
-    if (braceCount !== 0) {
-      errors.push({
-        stage,
-        line: lines.length,
-        message: `Unbalanced braces in ${stage} shader`,
-        code: "E003"
-      });
-    }
-    let parenCount = 0;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      parenCount += (line.match(/\(/g) || []).length;
-      parenCount -= (line.match(/\)/g) || []).length;
-    }
-    if (parenCount !== 0) {
-      errors.push({
-        stage,
-        line: lines.length,
-        message: `Unbalanced parentheses in ${stage} shader`,
-        code: "E004"
-      });
-    }
-    return errors;
-  }
-  /**
-   * Compile shader to target platform
-   */
-  compile(options) {
-    const validation = this.validate();
-    if (!validation.success) {
-      return validation;
-    }
-    let vertexSource = this.getVertexSource();
-    let fragmentSource = this.getFragmentSource();
-    if (options?.defines) {
-      for (const [key, value] of Object.entries(options.defines)) {
-        const define = `#define ${key} ${value}
-`;
-        vertexSource = define + vertexSource;
-        fragmentSource = define + fragmentSource;
-      }
-    }
-    return {
-      success: true,
-      errors: [],
-      warnings: [],
-      compiledCode: {
-        vertex: vertexSource,
-        fragment: fragmentSource
-      }
-    };
-  }
-  /**
-   * Create Three.js ShaderMaterial config
-   */
-  toThreeJSConfig() {
-    const uniformsObj = {};
-    for (const [name, value] of this.uniformValues) {
-      uniformsObj[name] = { value };
-    }
-    return {
-      vertexShader: this.getVertexSource(),
-      fragmentShader: this.getFragmentSource(),
-      uniforms: uniformsObj,
-      transparent: this.config.blendMode !== "opaque",
-      depthTest: this.config.depthTest ?? true,
-      depthWrite: this.config.depthWrite ?? true,
-      side: this.getCullSide()
-    };
-  }
-  getCullSide() {
-    const THREE_FrontSide = 0;
-    const THREE_BackSide = 1;
-    const THREE_DoubleSide = 2;
-    switch (this.config.cullFace) {
-      case "front":
-        return THREE_BackSide;
-      case "back":
-        return THREE_FrontSide;
-      case "none":
-        return THREE_DoubleSide;
-      default:
-        return THREE_FrontSide;
-    }
-  }
-};
-var SHADER_PRESETS = {
-  /** Hologram effect shader */
-  hologram: {
-    name: "hologram",
-    source: {
-      language: "glsl",
-      vertex: `
-varying vec2 vUv;
-varying vec3 vNormal;
-varying vec3 vViewPosition;
-
-void main() {
-  vUv = uv;
-  vNormal = normalize(normalMatrix * normal);
-  vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
-  vViewPosition = -mvPosition.xyz;
-  gl_Position = projectionMatrix * mvPosition;
-}
-`,
-      fragment: `
-uniform float time;
-uniform vec3 color;
-uniform float opacity;
-uniform float scanlineIntensity;
-uniform float flickerIntensity;
-
-varying vec2 vUv;
-varying vec3 vNormal;
-varying vec3 vViewPosition;
-
-void main() {
-  // Fresnel edge glow
-  vec3 viewDir = normalize(vViewPosition);
-  float fresnel = pow(1.0 - abs(dot(vNormal, viewDir)), 2.0);
-  
-  // Scanlines
-  float scanline = sin(vUv.y * 100.0 + time * 2.0) * scanlineIntensity;
-  
-  // Flicker
-  float flicker = 0.9 + flickerIntensity * sin(time * 20.0) * sin(time * 13.0);
-  
-  // Combine
-  float alpha = (opacity + fresnel * 0.3 + scanline) * flicker;
-  vec3 finalColor = color + fresnel * 0.5;
-  
-  gl_FragColor = vec4(finalColor, alpha);
-}
-`
-    },
-    uniforms: {
-      time: { type: "float", value: 0 },
-      color: { type: "vec3", value: [0, 1, 1] },
-      opacity: { type: "float", value: 0.5, min: 0, max: 1 },
-      scanlineIntensity: { type: "float", value: 0.1, min: 0, max: 0.5 },
-      flickerIntensity: { type: "float", value: 0.1, min: 0, max: 0.3 }
-    },
-    blendMode: "blend",
-    depthWrite: false,
-    cullFace: "none"
-  },
-  /** Force field shader */
-  forceField: {
-    name: "forceField",
-    source: {
-      language: "glsl",
-      vertex: `
-varying vec2 vUv;
-varying vec3 vNormal;
-varying vec3 vWorldPosition;
-
-void main() {
-  vUv = uv;
-  vNormal = normalize(normalMatrix * normal);
-  vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;
-  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-}
-`,
-      fragment: `
-uniform float time;
-uniform vec3 color;
-uniform float pulseSpeed;
-uniform float hexScale;
-
-varying vec2 vUv;
-varying vec3 vNormal;
-varying vec3 vWorldPosition;
-
-float hexPattern(vec2 p) {
-  vec2 q = vec2(p.x * 2.0 * 0.5773503, p.y + p.x * 0.5773503);
-  vec2 pi = floor(q);
-  vec2 pf = fract(q);
-  float v = mod(pi.x + pi.y, 3.0);
-  float ca = step(1.0, v);
-  float cb = step(2.0, v);
-  vec2 ma = step(pf.xy, pf.yx);
-  float e = dot(ma, 1.0 - pf.yx + ca * (pf.x + pf.y - 1.0) + cb * (pf.yx - 2.0 * pf.xy));
-  return e;
-}
-
-void main() {
-  float hex = hexPattern(vUv * hexScale);
-  float pulse = sin(time * pulseSpeed) * 0.5 + 0.5;
-  float alpha = hex * (0.3 + pulse * 0.2);
-  gl_FragColor = vec4(color, alpha);
-}
-`
-    },
-    uniforms: {
-      time: { type: "float", value: 0 },
-      color: { type: "vec3", value: [0.2, 0.5, 1] },
-      pulseSpeed: { type: "float", value: 2, min: 0.5, max: 5 },
-      hexScale: { type: "float", value: 10, min: 5, max: 50 }
-    },
-    blendMode: "additive",
-    depthWrite: false,
-    cullFace: "none"
-  },
-  /** Dissolve effect shader */
-  dissolve: {
-    name: "dissolve",
-    source: {
-      language: "glsl",
-      vertex: `
-varying vec2 vUv;
-varying vec3 vPosition;
-
-void main() {
-  vUv = uv;
-  vPosition = position;
-  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-}
-`,
-      fragment: `
-uniform float progress;
-uniform vec3 edgeColor;
-uniform float edgeWidth;
-uniform sampler2D noiseTexture;
-
-varying vec2 vUv;
-varying vec3 vPosition;
-
-void main() {
-  float noise = texture2D(noiseTexture, vUv).r;
-  float diff = noise - progress;
-  
-  if (diff < 0.0) discard;
-  
-  float edge = smoothstep(0.0, edgeWidth, diff);
-  vec3 color = mix(edgeColor, vec3(1.0), edge);
-  
-  gl_FragColor = vec4(color, 1.0);
-}
-`
-    },
-    uniforms: {
-      progress: { type: "float", value: 0, min: 0, max: 1 },
-      edgeColor: { type: "vec3", value: [1, 0.5, 0] },
-      edgeWidth: { type: "float", value: 0.1, min: 0.01, max: 0.5 },
-      noiseTexture: { type: "sampler2D", value: "" }
-    },
-    blendMode: "opaque"
-  }
-};
-function createShaderTrait(config) {
-  return new ShaderTrait({
-    name: "custom",
-    source: {
-      language: "glsl",
-      vertex: "",
-      fragment: ""
-    },
-    uniforms: {},
-    blendMode: "opaque",
-    ...config
-  });
-}
-var shaderHandler = {
-  name: "shader",
-  defaultConfig: {},
-  onAttach(node, config, ctx) {
-    const instance = new ShaderTrait(config);
-    node.__shader_instance = instance;
-    ctx.emit("shader_attached", { node, config });
-  },
-  onDetach(node, _config, ctx) {
-    const instance = node.__shader_instance;
-    if (instance) {
-      if (typeof instance.onDetach === "function") instance.onDetach(node, ctx);
-      else if (typeof instance.dispose === "function") instance.dispose();
-      else if (typeof instance.cleanup === "function") instance.cleanup();
-    }
-    ctx.emit("shader_detached", { node });
-    delete node.__shader_instance;
-  },
-  onEvent(node, _config, ctx, event) {
-    const instance = node.__shader_instance;
-    if (!instance) return;
-    if (typeof instance.onEvent === "function") instance.onEvent(event);
-    else if (typeof instance.emit === "function" && event.type) instance.emit(event);
-    if (event.type === "shader_configure" && event.payload) {
-      Object.assign(instance, event.payload);
-      ctx.emit("shader_configured", { node });
-    }
-  },
-  onUpdate(node, _config, ctx, dt) {
-    const instance = node.__shader_instance;
-    if (!instance) return;
-    if (typeof instance.onUpdate === "function") instance.onUpdate(node, ctx, dt);
-  }
-};
-
-exports.LIGHTING_PRESETS = LIGHTING_PRESETS;
-exports.LightingTrait = LightingTrait;
-exports.MATERIAL_PRESETS = MATERIAL_PRESETS;
-exports.MaterialTrait = MaterialTrait;
-exports.RenderingTrait = RenderingTrait;
-exports.SHADER_CHUNKS = SHADER_CHUNKS;
-exports.SHADER_PRESETS = SHADER_PRESETS;
-exports.ShaderTrait = ShaderTrait;
-exports.createLightingTrait = createLightingTrait;
-exports.createMaterialTrait = createMaterialTrait;
-exports.createRenderingTrait = createRenderingTrait;
-exports.createShaderTrait = createShaderTrait;
-exports.lightingHandler = lightingHandler;
-exports.materialHandler = materialHandler;
-exports.renderingHandler = renderingHandler;
-exports.shaderHandler = shaderHandler;
-//# sourceMappingURL=chunk-I3XGTIHM.cjs.map
-//# sourceMappingURL=chunk-I3XGTIHM.cjs.map