@plasius/gpu-lighting 0.1.4 → 0.1.7

package/src/index.js

@@ -128,6 +128,658 @@ export const lightingProfileNames = Object.freeze(Object.keys(lightingProfiles))
 
 export const defaultLightingProfile = "realtime";
 
+export const lightingWorkerQueueClass = "lighting";
+export const 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",
+        }),
+      }),
+    }),
+  ]);
+}
+
+const 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"],
+      },
+    },
+  },
+};
+
+const 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))
+    ),
+  });
+}
+
+export const 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) {
@@ -158,6 +810,38 @@ export function getLightingProfile(name = defaultLightingProfile) {
   return profile;
 }
 
+export 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;
+}
+
+export 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)),
+  });
+}
+
 const defaultTechnique = getLightingTechnique(defaultLightingTechnique);
 
 export const lightingPreludeWgslUrl = defaultTechnique.preludeUrl;
@@ -268,6 +952,24 @@ export async function loadLightingTechniqueJobs(techniqueName, options = {}) {
   return { preludeWgsl, jobs };
 }
 
+export 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),
+  };
+}
+
 export async function loadLightingPreludeWgsl(options = {}) {
   const { fetcher } = options ?? {};
   return loadTechniquePrelude(defaultTechnique, fetcher);
@@ -294,3 +996,21 @@ export async function loadLightingProfile(profileName, options = {}) {
   );
   return { profile, techniques };
 }
+
+export 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),
+  };
+}