@plasius/gpu-lighting 0.1.6 → 0.1.7

package/dist/index.js

@@ -115,6 +115,649 @@ var lightingProfiles = Object.freeze(
 );
 var lightingProfileNames = Object.freeze(Object.keys(lightingProfiles));
 var defaultLightingProfile = "realtime";
+var lightingWorkerQueueClass = "lighting";
+var lightingDebugOwner = "lighting";
+function buildWorkerBudgetLevels(jobType, queueClass, presets) {
+  return Object.freeze([
+    Object.freeze({
+      id: "low",
+      estimatedCostMs: presets.low.estimatedCostMs,
+      config: Object.freeze({
+        maxDispatchesPerFrame: presets.low.maxDispatchesPerFrame,
+        maxJobsPerDispatch: presets.low.maxJobsPerDispatch,
+        cadenceDivisor: presets.low.cadenceDivisor,
+        workgroupScale: presets.low.workgroupScale,
+        maxQueueDepth: presets.low.maxQueueDepth,
+        metadata: Object.freeze({
+          owner: lightingDebugOwner,
+          queueClass,
+          jobType,
+          quality: "low"
+        })
+      })
+    }),
+    Object.freeze({
+      id: "medium",
+      estimatedCostMs: presets.medium.estimatedCostMs,
+      config: Object.freeze({
+        maxDispatchesPerFrame: presets.medium.maxDispatchesPerFrame,
+        maxJobsPerDispatch: presets.medium.maxJobsPerDispatch,
+        cadenceDivisor: presets.medium.cadenceDivisor,
+        workgroupScale: presets.medium.workgroupScale,
+        maxQueueDepth: presets.medium.maxQueueDepth,
+        metadata: Object.freeze({
+          owner: lightingDebugOwner,
+          queueClass,
+          jobType,
+          quality: "medium"
+        })
+      })
+    }),
+    Object.freeze({
+      id: "high",
+      estimatedCostMs: presets.high.estimatedCostMs,
+      config: Object.freeze({
+        maxDispatchesPerFrame: presets.high.maxDispatchesPerFrame,
+        maxJobsPerDispatch: presets.high.maxJobsPerDispatch,
+        cadenceDivisor: presets.high.cadenceDivisor,
+        workgroupScale: presets.high.workgroupScale,
+        maxQueueDepth: presets.high.maxQueueDepth,
+        metadata: Object.freeze({
+          owner: lightingDebugOwner,
+          queueClass,
+          jobType,
+          quality: "high"
+        })
+      })
+    })
+  ]);
+}
+var lightingWorkerSpecPresets = {
+  hybrid: {
+    suggestedAllocationIds: [
+      "lighting.hybrid.radiance-cache",
+      "lighting.hybrid.reflection-history",
+      "lighting.hybrid.shadow-atlas"
+    ],
+    jobs: {
+      directLighting: {
+        domain: "lighting",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hybrid.directLighting",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.5,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 128
+            },
+            medium: {
+              estimatedCostMs: 0.9,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 128,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 256
+            },
+            high: {
+              estimatedCostMs: 1.2,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 256,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 512
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hybrid.shadow-atlas"]
+      },
+      screenTrace: {
+        domain: "reflections",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hybrid.screenTrace",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.8,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 3,
+              workgroupScale: 0.4,
+              maxQueueDepth: 96
+            },
+            medium: {
+              estimatedCostMs: 1.5,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 96,
+              cadenceDivisor: 2,
+              workgroupScale: 0.7,
+              maxQueueDepth: 192
+            },
+            high: {
+              estimatedCostMs: 2.2,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 192,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 384
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hybrid.reflection-history"]
+      },
+      radianceCache: {
+        domain: "lighting",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hybrid.radianceCache",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.7,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 96
+            },
+            medium: {
+              estimatedCostMs: 1.2,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 192
+            },
+            high: {
+              estimatedCostMs: 1.8,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 128,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 256
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hybrid.radiance-cache"]
+      },
+      finalGather: {
+        domain: "lighting",
+        importance: "critical",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hybrid.finalGather",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 1,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 48,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 128
+            },
+            medium: {
+              estimatedCostMs: 1.8,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 96,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 256
+            },
+            high: {
+              estimatedCostMs: 2.6,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 192,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 384
+            }
+          }
+        ),
+        suggestedAllocationIds: [
+          "lighting.hybrid.radiance-cache",
+          "lighting.hybrid.reflection-history"
+        ]
+      },
+      reflectionResolve: {
+        domain: "reflections",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hybrid.reflectionResolve",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 96
+            },
+            medium: {
+              estimatedCostMs: 0.8,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 192
+            },
+            high: {
+              estimatedCostMs: 1.2,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 128,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 256
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hybrid.reflection-history"]
+      }
+    }
+  },
+  pathtracer: {
+    suggestedAllocationIds: [
+      "lighting.pathtracer.path-state",
+      "lighting.pathtracer.accumulation",
+      "lighting.pathtracer.denoise-history"
+    ],
+    jobs: {
+      pathTrace: {
+        domain: "lighting",
+        importance: "critical",
+        levels: buildWorkerBudgetLevels(
+          "lighting.pathtracer.pathTrace",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 1.2,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 3,
+              workgroupScale: 0.45,
+              maxQueueDepth: 48
+            },
+            medium: {
+              estimatedCostMs: 2.3,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 2,
+              workgroupScale: 0.7,
+              maxQueueDepth: 96
+            },
+            high: {
+              estimatedCostMs: 3.8,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 128
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.pathtracer.path-state"]
+      },
+      accumulate: {
+        domain: "lighting",
+        importance: "medium",
+        levels: buildWorkerBudgetLevels(
+          "lighting.pathtracer.accumulate",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 32
+            },
+            medium: {
+              estimatedCostMs: 0.8,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 64
+            },
+            high: {
+              estimatedCostMs: 1.1,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 96
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.pathtracer.accumulation"]
+      },
+      denoise: {
+        domain: "post-processing",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.pathtracer.denoise",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 32
+            },
+            medium: {
+              estimatedCostMs: 0.9,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 64
+            },
+            high: {
+              estimatedCostMs: 1.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 96
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.pathtracer.denoise-history"]
+      }
+    }
+  },
+  volumetrics: {
+    suggestedAllocationIds: [
+      "lighting.volumetrics.froxel-grid",
+      "lighting.volumetrics.shadow-history"
+    ],
+    jobs: {
+      froxelIntegrate: {
+        domain: "volumetrics",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.volumetrics.froxelIntegrate",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.6,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 96
+            },
+            medium: {
+              estimatedCostMs: 1.1,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 64,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 192
+            },
+            high: {
+              estimatedCostMs: 1.7,
+              maxDispatchesPerFrame: 2,
+              maxJobsPerDispatch: 128,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 256
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.volumetrics.froxel-grid"]
+      },
+      volumetricShadow: {
+        domain: "volumetrics",
+        importance: "high",
+        levels: buildWorkerBudgetLevels(
+          "lighting.volumetrics.volumetricShadow",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.5,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 24,
+              cadenceDivisor: 2,
+              workgroupScale: 0.5,
+              maxQueueDepth: 64
+            },
+            medium: {
+              estimatedCostMs: 0.9,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 48,
+              cadenceDivisor: 1,
+              workgroupScale: 0.75,
+              maxQueueDepth: 128
+            },
+            high: {
+              estimatedCostMs: 1.3,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 96,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 192
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.volumetrics.shadow-history"]
+      }
+    }
+  },
+  hdri: {
+    suggestedAllocationIds: [
+      "lighting.hdri.cubemap",
+      "lighting.hdri.prefilter",
+      "lighting.hdri.brdf-lut"
+    ],
+    jobs: {
+      irradianceConvolution: {
+        domain: "lighting",
+        importance: "medium",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hdri.irradianceConvolution",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.3,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 8,
+              cadenceDivisor: 3,
+              workgroupScale: 0.5,
+              maxQueueDepth: 16
+            },
+            medium: {
+              estimatedCostMs: 0.5,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 2,
+              workgroupScale: 0.75,
+              maxQueueDepth: 32
+            },
+            high: {
+              estimatedCostMs: 0.8,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 48
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hdri.cubemap"]
+      },
+      specularPrefilter: {
+        domain: "lighting",
+        importance: "medium",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hdri.specularPrefilter",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 8,
+              cadenceDivisor: 3,
+              workgroupScale: 0.5,
+              maxQueueDepth: 16
+            },
+            medium: {
+              estimatedCostMs: 0.7,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 2,
+              workgroupScale: 0.75,
+              maxQueueDepth: 32
+            },
+            high: {
+              estimatedCostMs: 1,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 32,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 48
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hdri.prefilter"]
+      },
+      brdfLut: {
+        domain: "lighting",
+        importance: "low",
+        levels: buildWorkerBudgetLevels(
+          "lighting.hdri.brdfLut",
+          lightingWorkerQueueClass,
+          {
+            low: {
+              estimatedCostMs: 0.2,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 4,
+              cadenceDivisor: 3,
+              workgroupScale: 0.5,
+              maxQueueDepth: 8
+            },
+            medium: {
+              estimatedCostMs: 0.4,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 8,
+              cadenceDivisor: 2,
+              workgroupScale: 0.75,
+              maxQueueDepth: 16
+            },
+            high: {
+              estimatedCostMs: 0.6,
+              maxDispatchesPerFrame: 1,
+              maxJobsPerDispatch: 16,
+              cadenceDivisor: 1,
+              workgroupScale: 1,
+              maxQueueDepth: 24
+            }
+          }
+        ),
+        suggestedAllocationIds: ["lighting.hdri.brdf-lut"]
+      }
+    }
+  }
+};
+var lightingWorkerDagSpecs = {
+  hybrid: {
+    directLighting: { priority: 4, dependencies: [] },
+    screenTrace: { priority: 3, dependencies: [] },
+    radianceCache: { priority: 4, dependencies: ["directLighting"] },
+    finalGather: { priority: 2, dependencies: ["radianceCache", "screenTrace"] },
+    reflectionResolve: {
+      priority: 1,
+      dependencies: ["screenTrace", "finalGather"]
+    }
+  },
+  pathtracer: {
+    pathTrace: { priority: 4, dependencies: [] },
+    accumulate: { priority: 3, dependencies: ["pathTrace"] },
+    denoise: { priority: 2, dependencies: ["accumulate"] }
+  },
+  volumetrics: {
+    volumetricShadow: { priority: 3, dependencies: [] },
+    froxelIntegrate: { priority: 2, dependencies: ["volumetricShadow"] }
+  },
+  hdri: {
+    irradianceConvolution: { priority: 3, dependencies: [] },
+    specularPrefilter: { priority: 3, dependencies: [] },
+    brdfLut: {
+      priority: 2,
+      dependencies: ["irradianceConvolution", "specularPrefilter"]
+    }
+  }
+};
+function buildWorkerManifestJob(techniqueName, job) {
+  const spec = lightingWorkerSpecPresets[techniqueName].jobs[job.key];
+  const dag = lightingWorkerDagSpecs[techniqueName][job.key];
+  const dependencies = dag.dependencies.map(
+    (dependency) => `lighting.${techniqueName}.${dependency}`
+  );
+  return Object.freeze({
+    key: job.key,
+    label: job.label,
+    worker: Object.freeze({
+      jobType: job.label,
+      queueClass: lightingWorkerQueueClass,
+      priority: dag.priority,
+      dependencies: Object.freeze(dependencies),
+      schedulerMode: "dag"
+    }),
+    performance: Object.freeze({
+      id: job.label,
+      jobType: job.label,
+      queueClass: lightingWorkerQueueClass,
+      domain: spec.domain,
+      authority: "visual",
+      importance: spec.importance,
+      levels: spec.levels
+    }),
+    debug: Object.freeze({
+      owner: lightingDebugOwner,
+      queueClass: lightingWorkerQueueClass,
+      jobType: job.label,
+      tags: Object.freeze([
+        "lighting",
+        techniqueName,
+        job.key,
+        spec.domain
+      ]),
+      suggestedAllocationIds: Object.freeze([...spec.suggestedAllocationIds])
+    })
+  });
+}
+function buildLightingWorkerManifest(name, technique) {
+  const spec = lightingWorkerSpecPresets[name];
+  return Object.freeze({
+    schemaVersion: 1,
+    owner: lightingDebugOwner,
+    technique: name,
+    description: technique.description,
+    queueClass: lightingWorkerQueueClass,
+    schedulerMode: "dag",
+    suggestedAllocationIds: Object.freeze([...spec.suggestedAllocationIds]),
+    jobs: Object.freeze(
+      technique.jobs.map((job) => buildWorkerManifestJob(name, job))
+    )
+  });
+}
+var lightingWorkerManifests = Object.freeze(
+  Object.fromEntries(
+    Object.entries(lightingTechniques).map(([name, technique]) => [
+      name,
+      buildLightingWorkerManifest(name, technique)
+    ])
+  )
+);
 function getTechniqueJob(technique, key) {
   const job = technique.jobs.find((entry) => entry.key === key);
   if (!job) {
@@ -141,6 +784,31 @@ function getLightingProfile(name = defaultLightingProfile) {
   }
   return profile;
 }
+function getLightingTechniqueWorkerManifest(name = defaultLightingTechnique) {
+  const manifest = lightingWorkerManifests[name];
+  if (!manifest) {
+    const available = lightingTechniqueNames.join(", ");
+    throw new Error(
+      `Unknown lighting technique "${name}". Available: ${available}.`
+    );
+  }
+  return manifest;
+}
+function getLightingProfileWorkerManifest(name = defaultLightingProfile) {
+  const profile = getLightingProfile(name);
+  const techniques = profile.techniques.map(
+    (techniqueName) => getLightingTechniqueWorkerManifest(techniqueName)
+  );
+  return Object.freeze({
+    schemaVersion: 1,
+    owner: lightingDebugOwner,
+    profile: profile.name,
+    description: profile.description,
+    schedulerMode: "dag",
+    techniques: Object.freeze(techniques),
+    jobs: Object.freeze(techniques.flatMap((technique) => technique.jobs))
+  });
+}
 var defaultTechnique = getLightingTechnique(defaultLightingTechnique);
 var lightingPreludeWgslUrl = defaultTechnique.preludeUrl;
 var lightingJobLabels = Object.freeze(
@@ -229,6 +897,19 @@ async function loadLightingTechniqueJobs(techniqueName, options = {}) {
   }));
   return { preludeWgsl, jobs };
 }
+async function loadLightingTechniqueWorkerBundle(techniqueName = defaultLightingTechnique, options = {}) {
+  const technique = getLightingTechnique(techniqueName);
+  const { preludeWgsl, jobs } = await loadLightingTechniqueJobs(
+    technique.name,
+    options
+  );
+  return {
+    technique: technique.name,
+    preludeWgsl,
+    jobs,
+    workerManifest: getLightingTechniqueWorkerManifest(technique.name)
+  };
+}
 async function loadLightingPreludeWgsl(options = {}) {
   const { fetcher } = options ?? {};
   return loadTechniquePrelude(defaultTechnique, fetcher);
@@ -253,11 +934,27 @@ async function loadLightingProfile(profileName, options = {}) {
   );
   return { profile, techniques };
 }
+async function loadLightingProfileWorkerPlan(profileName = defaultLightingProfile, options = {}) {
+  const profile = getLightingProfile(profileName);
+  const techniques = await Promise.all(
+    profile.techniques.map(
+      (techniqueName) => loadLightingTechniqueWorkerBundle(techniqueName, options)
+    )
+  );
+  return {
+    profile,
+    techniques,
+    workerManifest: getLightingProfileWorkerManifest(profile.name)
+  };
+}
 export {
   defaultLightingProfile,
   defaultLightingTechnique,
   getLightingProfile,
+  getLightingProfileWorkerManifest,
   getLightingTechnique,
+  getLightingTechniqueWorkerManifest,
+  lightingDebugOwner,
   lightingJobLabels,
   lightingJobs,
   lightingPreludeWgslUrl,
@@ -265,11 +962,15 @@ export {
   lightingProfiles,
   lightingTechniqueNames,
   lightingTechniques,
+  lightingWorkerManifests,
+  lightingWorkerQueueClass,
   loadLightingJobs,
   loadLightingPreludeWgsl,
   loadLightingProfile,
+  loadLightingProfileWorkerPlan,
   loadLightingTechniqueJobWgsl,
   loadLightingTechniqueJobs,
-  loadLightingTechniquePreludeWgsl
+  loadLightingTechniquePreludeWgsl,
+  loadLightingTechniqueWorkerBundle
 };
 //# sourceMappingURL=index.js.map