@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-QPOQ7VPI.js

@@ -0,0 +1,1491 @@
+import { init_safeJsonParse, jsonClone } from './chunk-VVKVQZI6.js';
+
+// 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
+init_safeJsonParse();
+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 jsonClone(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[0] > x0[1]) ? 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[1] + vec3(0.0, i1[1], 1.0)) + i[0] + vec3(0.0, i1[0], 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[0]  = a0[0]  * x0[0]  + h[0]  * x0[1];
+  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[1] * 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[0] - s * uv[1], s * uv[0] + c * uv[1]);
+}
+
+// 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[2] * (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[1] * 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[0] * 2.0 * 0.5773503, p[1] + p[0] * 0.5773503);
+  vec2 pi = floor(q);
+  vec2 pf = fract(q);
+  float v = mod(pi[0] + pi[1], 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[0] + pf[1] - 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);
+  }
+};
+
+export { LIGHTING_PRESETS, LightingTrait, MATERIAL_PRESETS, MaterialTrait, RenderingTrait, SHADER_CHUNKS, SHADER_PRESETS, ShaderTrait, createLightingTrait, createMaterialTrait, createRenderingTrait, createShaderTrait, lightingHandler, materialHandler, renderingHandler, shaderHandler };
+//# sourceMappingURL=chunk-QPOQ7VPI.js.map
+//# sourceMappingURL=chunk-QPOQ7VPI.js.map