@plasius/gpu-lighting 0.2.5 → 0.2.7

package/src/techniques/wavefront/accumulate-terminal-radiance.job.wgsl

@@ -0,0 +1,61 @@
+@group(0) @binding(0) var<uniform> wavefrontLightingParams: WavefrontLightingParams;
+@group(0) @binding(1) var<storage, read> activeQueue: array<RayRecord>;
+@group(0) @binding(2) var<storage, read> hitBuffer: array<HitRecord>;
+@group(0) @binding(3) var<storage, read> surfaceBuffer: array<SurfaceRecord>;
+@group(0) @binding(4) var<storage, read> materialRefBuffer: array<MaterialReferenceRecord>;
+@group(0) @binding(5) var<storage, read> mediumRefBuffer: array<MediumReferenceRecord>;
+@group(0) @binding(6) var<storage, read_write> accumulationBuffer: array<AccumulationRecord>;
+
+fn resolve_emissive_radiance(
+  material: MaterialReferenceRecord,
+  surface: SurfaceRecord
+) -> vec3<f32> {
+  let uv_weight = saturate_scalar(surface.uv.x + surface.uv.y);
+  let emissive_hint = select(0.0, 1.0, (material.flags & 0x1u) != 0u);
+  let base = material_base_albedo(material);
+  return base * (0.5 + uv_weight * 0.5 + emissive_hint * 2.0);
+}
+
+fn accumulate_terminal_sample(
+  ray: RayRecord,
+  hit: HitRecord,
+  surface: SurfaceRecord,
+  material: MaterialReferenceRecord,
+  accumulation_index: u32
+) {
+  let emissive_radiance = resolve_emissive_radiance(material, surface);
+  let terminal_radiance = terminal_radiance_for_hit(hit, ray, emissive_radiance);
+  if (luminance(terminal_radiance) <= LIGHTING_EPSILON) {
+    return;
+  }
+
+  accumulationBuffer[accumulation_index].sourcePixelId = ray.sourcePixelId;
+  accumulationBuffer[accumulation_index].sampleCount =
+    accumulationBuffer[accumulation_index].sampleCount + 1u;
+  accumulationBuffer[accumulation_index].resetEpoch =
+    wavefrontLightingParams.accumulation_reset_epoch;
+  accumulationBuffer[accumulation_index].radiance =
+    accumulationBuffer[accumulation_index].radiance + terminal_radiance;
+  accumulationBuffer[accumulation_index].throughput = ray.throughput;
+}
+
+@compute @workgroup_size(64, 1, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let index = global_id.x;
+  if (index >= wavefrontLightingParams.active_count) {
+    return;
+  }
+
+  let ray = activeQueue[index];
+  let hit = hitBuffer[index];
+  if (!is_terminal_hit_type(hit.hitType)) {
+    return;
+  }
+
+  let surface = surfaceBuffer[index];
+  let material = materialRefBuffer[surface.materialRefId];
+  let _medium = mediumRefBuffer[surface.mediumRefId];
+  let accumulation_index = min(ray.sourcePixelId, wavefrontLightingParams.active_count - 1u);
+
+  accumulate_terminal_sample(ray, hit, surface, material, accumulation_index);
+}

package/src/techniques/wavefront/prelude.wgsl

@@ -0,0 +1,237 @@
+const LIGHTING_WAVEFRONT_SCHEMA_VERSION: u32 = 1u;
+const LIGHTING_WAVEFRONT_QUEUE_PAIR_STRATEGY: u32 = 1u;
+
+const HIT_TYPE_SURFACE: u32 = 0u;
+const HIT_TYPE_EMISSIVE: u32 = 1u;
+const HIT_TYPE_ENVIRONMENT: u32 = 2u;
+const HIT_TYPE_TRANSPARENT: u32 = 3u;
+const HIT_TYPE_MISS: u32 = 4u;
+
+const EVENT_KIND_DIFFUSE: u32 = 0u;
+const EVENT_KIND_REFLECTION: u32 = 1u;
+const EVENT_KIND_REFRACTION: u32 = 2u;
+const EVENT_KIND_TRANSPARENCY: u32 = 3u;
+const EVENT_KIND_TERMINATE: u32 = 4u;
+
+const RAY_KIND_PATH: u32 = 0u;
+const RAY_KIND_VISIBILITY_PROBE: u32 = 1u;
+const RAY_KIND_MASK: u32 = 0x3u;
+
+const LIGHTING_EPSILON: f32 = 0.0001;
+const LIGHTING_INV_PI: f32 = 0.3183098861837907;
+
+struct WavefrontLightingParams {
+  active_count: u32,
+  next_queue_capacity: u32,
+  bounce_index: u32,
+  max_depth: u32,
+  enable_explicit_light_sampling: u32,
+  accumulation_reset_epoch: u32,
+  environment_mode: u32,
+  environment_intensity: f32,
+  sunlit_baseline: f32,
+  _padding0: vec3<f32>,
+  environment_color: vec4<f32>,
+  ambient_color: vec4<f32>,
+  environment_miss_radiance: vec4<f32>,
+};
+
+struct RayRecord {
+  rayId: u32,
+  parentRayId: u32,
+  sourcePixelId: u32,
+  sampleId: u32,
+  bounce: u32,
+  origin: vec3<f32>,
+  _padding0: f32,
+  direction: vec3<f32>,
+  _padding1: f32,
+  throughput: vec3<f32>,
+  mediumRefId: u32,
+  flags: u32,
+};
+
+struct HitRecord {
+  rayId: u32,
+  sourcePixelId: u32,
+  hitType: u32,
+  _padding0: u32,
+  distance: f32,
+  entityId: u32,
+  instanceId: u32,
+  primitiveId: u32,
+  materialId: u32,
+  _padding1: vec3<u32>,
+  barycentrics: vec3<f32>,
+  _padding2: f32,
+  uv: vec2<f32>,
+  _padding3: vec2<f32>,
+  geometricNormal: vec3<f32>,
+  _padding4: f32,
+  shadingNormal: vec3<f32>,
+  frontFace: u32,
+};
+
+struct SurfaceRecord {
+  rayId: u32,
+  entityId: u32,
+  materialRefId: u32,
+  mediumRefId: u32,
+  geometricNormal: vec3<f32>,
+  _padding0: f32,
+  shadingNormal: vec3<f32>,
+  _padding1: f32,
+  uv: vec2<f32>,
+  _padding2: vec2<f32>,
+  tangentFrame0: vec3<f32>,
+  _padding3: f32,
+  tangentFrame1: vec3<f32>,
+  _padding4: f32,
+  tangentFrame2: vec3<f32>,
+  _padding5: f32,
+};
+
+struct MaterialReferenceRecord {
+  materialRefId: u32,
+  materialId: u32,
+  shadingModel: u32,
+  textureSetId: u32,
+  flags: u32,
+  _padding0: vec3<u32>,
+};
+
+struct MediumReferenceRecord {
+  mediumRefId: u32,
+  mediumId: u32,
+  phaseModel: u32,
+  _padding0: u32,
+  absorption: vec3<f32>,
+  _padding1: f32,
+  scattering: vec3<f32>,
+  _padding2: f32,
+};
+
+struct AccumulationRecord {
+  sourcePixelId: u32,
+  sampleCount: u32,
+  resetEpoch: u32,
+  _padding0: u32,
+  radiance: vec3<f32>,
+  _padding1: f32,
+  throughput: vec3<f32>,
+  _padding2: f32,
+};
+
+fn luminance(value: vec3<f32>) -> f32 {
+  return dot(value, vec3<f32>(0.2126, 0.7152, 0.0722));
+}
+
+fn saturate_scalar(value: f32) -> f32 {
+  return clamp(value, 0.0, 1.0);
+}
+
+fn saturate_vec3(value: vec3<f32>) -> vec3<f32> {
+  return max(value, vec3<f32>(0.0));
+}
+
+fn safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  if (dot(value, value) <= LIGHTING_EPSILON) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+  return normalize(value);
+}
+
+fn faceforward_normal(normal: vec3<f32>, direction: vec3<f32>) -> vec3<f32> {
+  return select(normal, -normal, dot(normal, direction) > 0.0);
+}
+
+fn is_terminal_hit_type(hit_type: u32) -> bool {
+  return hit_type == HIT_TYPE_EMISSIVE ||
+    hit_type == HIT_TYPE_ENVIRONMENT ||
+    hit_type == HIT_TYPE_MISS;
+}
+
+fn ray_kind(flags: u32) -> u32 {
+  return flags & RAY_KIND_MASK;
+}
+
+fn environment_radiance(direction: vec3<f32>) -> vec3<f32> {
+  let upward = saturate_scalar(direction.y * 0.5 + 0.5);
+  let directional = mix(
+    wavefrontLightingParams.environment_color.xyz * 0.45,
+    wavefrontLightingParams.environment_color.xyz,
+    upward
+  );
+  let ambient = wavefrontLightingParams.ambient_color.xyz * 0.18;
+  let miss = wavefrontLightingParams.environment_miss_radiance.xyz;
+  return saturate_vec3(max(directional + ambient, miss));
+}
+
+fn terminal_radiance_for_hit(
+  hit: HitRecord,
+  ray: RayRecord,
+  emissive_radiance: vec3<f32>
+) -> vec3<f32> {
+  if (hit.hitType == HIT_TYPE_EMISSIVE) {
+    return ray.throughput * saturate_vec3(emissive_radiance);
+  }
+  if (hit.hitType == HIT_TYPE_ENVIRONMENT) {
+    return ray.throughput * environment_radiance(ray.direction);
+  }
+  if (hit.hitType == HIT_TYPE_MISS) {
+    let miss_radiance = max(
+      environment_radiance(ray.direction),
+      wavefrontLightingParams.environment_miss_radiance.xyz
+    );
+    return ray.throughput * saturate_vec3(miss_radiance);
+  }
+  return vec3<f32>(0.0);
+}
+
+fn reflect_direction(direction: vec3<f32>, normal: vec3<f32>) -> vec3<f32> {
+  return safe_normalize(reflect(direction, normal));
+}
+
+fn refract_direction(direction: vec3<f32>, normal: vec3<f32>, eta_ratio: f32) -> vec3<f32> {
+  let refracted = refract(direction, normal, eta_ratio);
+  if (dot(refracted, refracted) <= LIGHTING_EPSILON) {
+    return reflect_direction(direction, normal);
+  }
+  return safe_normalize(refracted);
+}
+
+fn choose_continuation_event_kind(hit: HitRecord, material: MaterialReferenceRecord) -> u32 {
+  if (hit.hitType == HIT_TYPE_TRANSPARENT || (material.flags & 0x4u) != 0u) {
+    return EVENT_KIND_TRANSPARENCY;
+  }
+  if ((material.flags & 0x8u) != 0u) {
+    return EVENT_KIND_REFRACTION;
+  }
+  if ((material.flags & 0x2u) != 0u) {
+    return EVENT_KIND_REFLECTION;
+  }
+  return EVENT_KIND_DIFFUSE;
+}
+
+fn material_base_albedo(material: MaterialReferenceRecord) -> vec3<f32> {
+  let tint = vec3<f32>(
+    f32((material.materialId & 0xffu)) / 255.0,
+    f32((material.textureSetId & 0xffu)) / 255.0,
+    f32(((material.materialId ^ material.textureSetId) & 0xffu)) / 255.0
+  );
+  return max(tint, vec3<f32>(0.12, 0.12, 0.12));
+}
+
+fn continuation_attenuation(event_kind: u32, material: MaterialReferenceRecord) -> vec3<f32> {
+  let base_albedo = material_base_albedo(material);
+  if (event_kind == EVENT_KIND_REFLECTION) {
+    return mix(vec3<f32>(0.04), base_albedo, 0.7);
+  }
+  if (event_kind == EVENT_KIND_REFRACTION) {
+    return vec3<f32>(0.92, 0.94, 0.98);
+  }
+  if (event_kind == EVENT_KIND_TRANSPARENCY) {
+    return vec3<f32>(0.75, 0.82, 0.9);
+  }
+  return base_albedo * LIGHTING_INV_PI;
+}

package/src/techniques/wavefront/scatter-continuations.job.wgsl

@@ -0,0 +1,136 @@
+@group(0) @binding(0) var<uniform> wavefrontLightingParams: WavefrontLightingParams;
+@group(0) @binding(1) var<storage, read> activeQueue: array<RayRecord>;
+@group(0) @binding(2) var<storage, read> hitBuffer: array<HitRecord>;
+@group(0) @binding(3) var<storage, read> surfaceBuffer: array<SurfaceRecord>;
+@group(0) @binding(4) var<storage, read> materialRefBuffer: array<MaterialReferenceRecord>;
+@group(0) @binding(5) var<storage, read> mediumRefBuffer: array<MediumReferenceRecord>;
+@group(0) @binding(6) var<storage, read_write> nextQueue: array<RayRecord>;
+@group(0) @binding(7) var<storage, read_write> nextQueueCounter: atomic<u32>;
+
+fn queue_continuation_ray(
+  ray: RayRecord,
+  hit: HitRecord,
+  surface: SurfaceRecord,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>
+) {
+  let slot = atomicAdd(&nextQueueCounter, 1u);
+  if (slot >= wavefrontLightingParams.next_queue_capacity) {
+    return;
+  }
+
+  let offset_origin =
+    ray.origin +
+    ray.direction * hit.distance +
+    faceforward_normal(surface.geometricNormal, ray.direction) * 0.001;
+  nextQueue[slot] = RayRecord(
+    ray.rayId ^ ((wavefrontLightingParams.bounce_index + 1u) * 0x9e3779b9u),
+    ray.rayId,
+    ray.sourcePixelId,
+    ray.sampleId,
+    wavefrontLightingParams.bounce_index + 1u,
+    offset_origin,
+    0.0,
+    direction,
+    0.0,
+    ray.throughput * attenuation,
+    surface.mediumRefId,
+    ray.flags
+  );
+}
+
+fn queue_reflection_continuation(
+  ray: RayRecord,
+  hit: HitRecord,
+  surface: SurfaceRecord,
+  material: MaterialReferenceRecord
+) {
+  let facing_normal = faceforward_normal(surface.shadingNormal, ray.direction);
+  let direction = reflect_direction(ray.direction, facing_normal);
+  let attenuation = continuation_attenuation(EVENT_KIND_REFLECTION, material);
+  queue_continuation_ray(ray, hit, surface, direction, attenuation);
+}
+
+fn queue_refraction_continuation(
+  ray: RayRecord,
+  hit: HitRecord,
+  surface: SurfaceRecord,
+  material: MaterialReferenceRecord
+) {
+  let front_face = hit.frontFace != 0u;
+  let facing_normal = faceforward_normal(surface.shadingNormal, ray.direction);
+  let eta_ratio = select(1.45, 1.0 / 1.45, front_face);
+  let direction = refract_direction(ray.direction, facing_normal, eta_ratio);
+  let attenuation = continuation_attenuation(EVENT_KIND_REFRACTION, material);
+  queue_continuation_ray(ray, hit, surface, direction, attenuation);
+}
+
+fn queue_transparency_continuation(
+  ray: RayRecord,
+  hit: HitRecord,
+  surface: SurfaceRecord,
+  material: MaterialReferenceRecord
+) {
+  let attenuation = continuation_attenuation(EVENT_KIND_TRANSPARENCY, material);
+  queue_continuation_ray(ray, hit, surface, ray.direction, attenuation);
+}
+
+fn queue_diffuse_continuation(
+  ray: RayRecord,
+  hit: HitRecord,
+  surface: SurfaceRecord,
+  material: MaterialReferenceRecord
+) {
+  let facing_normal = faceforward_normal(surface.shadingNormal, ray.direction);
+  let attenuation = continuation_attenuation(EVENT_KIND_DIFFUSE, material);
+  let bias =
+    surface.tangentFrame0 * (surface.uv.x - 0.5) +
+    surface.tangentFrame1 * (surface.uv.y - 0.5) +
+    facing_normal;
+  let direction = safe_normalize(bias);
+  queue_continuation_ray(ray, hit, surface, direction, attenuation);
+}
+
+@compute @workgroup_size(64, 1, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let index = global_id.x;
+  if (index >= wavefrontLightingParams.active_count) {
+    return;
+  }
+  if (wavefrontLightingParams.bounce_index + 1u >= wavefrontLightingParams.max_depth) {
+    return;
+  }
+
+  let ray = activeQueue[index];
+  let hit = hitBuffer[index];
+  if (is_terminal_hit_type(hit.hitType) || hit.hitType == HIT_TYPE_MISS) {
+    return;
+  }
+
+  let surface = surfaceBuffer[index];
+  let material = materialRefBuffer[surface.materialRefId];
+  let _medium = mediumRefBuffer[surface.mediumRefId];
+  let event_kind = choose_continuation_event_kind(hit, material);
+  let explicit_light_sampling_enabled = wavefrontLightingParams.enable_explicit_light_sampling != 0u;
+
+  if (event_kind == EVENT_KIND_REFLECTION) {
+    queue_reflection_continuation(ray, hit, surface, material);
+    return;
+  }
+  if (event_kind == EVENT_KIND_REFRACTION) {
+    queue_refraction_continuation(ray, hit, surface, material);
+    return;
+  }
+  if (event_kind == EVENT_KIND_TRANSPARENCY) {
+    queue_transparency_continuation(ray, hit, surface, material);
+    return;
+  }
+
+  if (explicit_light_sampling_enabled) {
+    // Explicit light sampling remains optional for correctness in this first slice.
+    queue_diffuse_continuation(ray, hit, surface, material);
+    return;
+  }
+
+  queue_diffuse_continuation(ray, hit, surface, material);
+}