@plasius/gpu-lighting 0.1.16 → 0.1.18

package/dist/techniques/techniques/pathtracer/prelude.wgsl

@@ -1,8 +1,20 @@
+const PATH_TRACER_PI: f32 = 3.141592653589793;
+const PATH_TRACER_INV_PI: f32 = 0.3183098861837907;
+const PATH_TRACER_EPSILON: f32 = 0.0005;
+
 struct PathTracerParams {
   frame_index: u32,
   max_bounces: u32,
   samples_per_pixel: u32,
   enable_next_event_estimation: u32,
+  image_width: u32,
+  image_height: u32,
+  accumulation_reset: u32,
+  environment_mode: u32,
+  environment_intensity: f32,
+  exposure: f32,
+  history_blend: f32,
+  denoise_strength: f32,
 };
 
 struct PathSample {
@@ -10,6 +22,254 @@ struct PathSample {
   throughput: vec3<f32>,
 };
 
+struct PathTracerCamera {
+  origin: vec3<f32>,
+  aspect_ratio: f32,
+  forward: vec3<f32>,
+  vertical_fov_radians: f32,
+  right: vec3<f32>,
+  focus_distance: f32,
+  up: vec3<f32>,
+  aperture_radius: f32,
+};
+
+struct PathTracerSceneMetadata {
+  sphere_count: u32,
+  triangle_count: u32,
+  material_count: u32,
+  max_trace_distance: f32,
+};
+
+struct PathTracerGroundPlane {
+  normal: vec3<f32>,
+  height: f32,
+  material_index: u32,
+  enabled: u32,
+  _padding0: vec2<u32>,
+};
+
+struct PathTracerMaterial {
+  albedo_roughness: vec4<f32>,
+  emission_metalness: vec4<f32>,
+  transmittance_ior: vec4<f32>,
+};
+
+struct PathTracerSphere {
+  center_radius: vec4<f32>,
+  material_index: u32,
+  flags: u32,
+  _padding0: vec2<u32>,
+};
+
+struct PathTracerTriangle {
+  position0: vec4<f32>,
+  position1: vec4<f32>,
+  position2: vec4<f32>,
+  normal0: vec4<f32>,
+  normal1: vec4<f32>,
+  normal2: vec4<f32>,
+  material_index: u32,
+  flags: u32,
+  _padding0: vec2<u32>,
+};
+
+struct Ray {
+  origin: vec3<f32>,
+  t_min: f32,
+  direction: vec3<f32>,
+  t_max: f32,
+};
+
+struct PathHit {
+  hit: u32,
+  distance: f32,
+  position: vec3<f32>,
+  material_index: u32,
+  normal: vec3<f32>,
+  primitive_kind: u32,
+  barycentric: vec3<f32>,
+  _padding1: u32,
+};
+
+struct MaterialSample {
+  albedo: vec3<f32>,
+  roughness: f32,
+  emission: vec3<f32>,
+  metalness: f32,
+  transmittance: vec3<f32>,
+  refractive_index: f32,
+};
+
+struct PathScatter {
+  direction: vec3<f32>,
+  pdf: f32,
+  attenuation: vec3<f32>,
+  event_kind: f32,
+};
+
+struct PathState {
+  throughput_bounce: vec4<f32>,
+  origin_active: vec4<f32>,
+  direction_pdf: vec4<f32>,
+  random_state: u32,
+  last_hit_kind: u32,
+  _padding0: vec2<u32>,
+};
+
+struct PathSamplePixel {
+  radiance_opacity: vec4<f32>,
+  direction_distance: vec4<f32>,
+  normal_roughness: vec4<f32>,
+  albedo_sample_count: vec4<f32>,
+};
+
+struct PathAccumulationPixel {
+  integrated_radiance: vec4<f32>,
+  moments: vec4<f32>,
+};
+
+struct PathDenoisePixel {
+  filtered_radiance: vec4<f32>,
+  normal_depth: vec4<f32>,
+  albedo_history: vec4<f32>,
+};
+
 fn luminance(value: vec3<f32>) -> f32 {
   return dot(value, vec3<f32>(0.2126, 0.7152, 0.0722));
 }
+
+fn saturate(value: f32) -> f32 {
+  return clamp(value, 0.0, 1.0);
+}
+
+fn safe_rcp(value: f32) -> f32 {
+  if (abs(value) <= PATH_TRACER_EPSILON) {
+    return 0.0;
+  }
+
+  return 1.0 / value;
+}
+
+fn safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  if (dot(value, value) <= PATH_TRACER_EPSILON) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+
+  return normalize(value);
+}
+
+fn make_default_material() -> PathTracerMaterial {
+  return PathTracerMaterial(
+    vec4<f32>(0.72, 0.74, 0.76, 0.5),
+    vec4<f32>(0.0, 0.0, 0.0, 0.0),
+    vec4<f32>(0.0, 0.0, 0.0, 1.45)
+  );
+}
+
+fn unpack_material(material: PathTracerMaterial) -> MaterialSample {
+  return MaterialSample(
+    material.albedo_roughness.xyz,
+    clamp(material.albedo_roughness.w, 0.02, 1.0),
+    material.emission_metalness.xyz,
+    saturate(material.emission_metalness.w),
+    material.transmittance_ior.xyz,
+    max(material.transmittance_ior.w, 1.0)
+  );
+}
+
+fn hash_u32(value: u32) -> u32 {
+  var x = value + 0x9e3779b9u;
+  x = (x ^ (x >> 16u)) * 0x85ebca6bu;
+  x = (x ^ (x >> 13u)) * 0xc2b2ae35u;
+  return x ^ (x >> 16u);
+}
+
+fn random_f32(state: ptr<function, u32>) -> f32 {
+  let next = hash_u32((*state) ^ 0x68bc21ebu);
+  *state = next;
+  return f32(next) * 2.3283064365386963e-10;
+}
+
+fn sample_unit_disk(state: ptr<function, u32>) -> vec2<f32> {
+  let radius = sqrt(random_f32(state));
+  let angle = 2.0 * PATH_TRACER_PI * random_f32(state);
+  return vec2<f32>(cos(angle), sin(angle)) * radius;
+}
+
+fn sample_unit_sphere(state: ptr<function, u32>) -> vec3<f32> {
+  let z = random_f32(state) * 2.0 - 1.0;
+  let angle = 2.0 * PATH_TRACER_PI * random_f32(state);
+  let radius = sqrt(max(1.0 - z * z, 0.0));
+  return vec3<f32>(radius * cos(angle), radius * sin(angle), z);
+}
+
+fn build_tangent(normal: vec3<f32>) -> vec3<f32> {
+  let basis = select(
+    vec3<f32>(0.0, 1.0, 0.0),
+    vec3<f32>(1.0, 0.0, 0.0),
+    abs(normal.y) > 0.999
+  );
+  return safe_normalize(cross(basis, normal));
+}
+
+fn build_bitangent(normal: vec3<f32>, tangent: vec3<f32>) -> vec3<f32> {
+  return safe_normalize(cross(normal, tangent));
+}
+
+fn sample_cosine_hemisphere(normal: vec3<f32>, state: ptr<function, u32>) -> vec3<f32> {
+  let disk = sample_unit_disk(state);
+  let z = sqrt(max(1.0 - dot(disk, disk), 0.0));
+  let tangent = build_tangent(normal);
+  let bitangent = build_bitangent(normal, tangent);
+  return safe_normalize(tangent * disk.x + bitangent * disk.y + normal * z);
+}
+
+fn fresnel_schlick(cos_theta: f32, f0: vec3<f32>) -> vec3<f32> {
+  let factor = pow(1.0 - saturate(cos_theta), 5.0);
+  return f0 + (vec3<f32>(1.0) - f0) * factor;
+}
+
+fn environment_radiance(
+  direction: vec3<f32>,
+  intensity: f32,
+  mode: u32
+) -> vec3<f32> {
+  let up_factor = saturate(direction.y * 0.5 + 0.5);
+  let horizon_color = vec3<f32>(0.65, 0.74, 0.86);
+  let zenith_color = select(
+    vec3<f32>(0.05, 0.12, 0.24),
+    vec3<f32>(0.11, 0.08, 0.18),
+    mode == 1u
+  );
+  let sunset_color = vec3<f32>(1.1, 0.64, 0.32);
+  let sun_direction = safe_normalize(vec3<f32>(0.35, 0.92, 0.18));
+  let moon_direction = safe_normalize(vec3<f32>(-0.2, 0.98, -0.1));
+  let sun_glow = pow(saturate(dot(direction, sun_direction)), 256.0);
+  let moon_glow = pow(saturate(dot(direction, moon_direction)), 512.0);
+  var sky = horizon_color * (1.0 - up_factor) + zenith_color * up_factor;
+  if (mode == 1u) {
+    sky = sky * (1.0 - up_factor * 0.4) + sunset_color * sun_glow * 0.25;
+  }
+  return (
+    sky +
+    vec3<f32>(8.0, 7.6, 6.8) * sun_glow +
+    vec3<f32>(0.7, 0.76, 0.9) * moon_glow * 0.3
+  ) * max(intensity, 0.0001);
+}
+
+fn miss_hit(ray: Ray) -> PathHit {
+  return PathHit(
+    0u,
+    ray.t_max,
+    ray.origin + ray.direction * ray.t_max,
+    0u,
+    vec3<f32>(0.0, 1.0, 0.0),
+    0u,
+    vec3<f32>(0.0),
+    0u
+  );
+}
+
+fn faceforward_normal(normal: vec3<f32>, direction: vec3<f32>) -> vec3<f32> {
+  return select(normal, -normal, dot(normal, direction) > 0.0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasius/gpu-lighting",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Advanced lighting WGSL modules and planning profiles for @plasius/gpu-worker.",
   "type": "module",
   "sideEffects": false,

package/src/index.js

@@ -131,6 +131,16 @@ export const lightingProfiles = Object.freeze(
 export const lightingProfileNames = Object.freeze(Object.keys(lightingProfiles));
 
 export const defaultLightingProfile = "realtime";
+export const lightingProfileModeOrder = Object.freeze([
+  "realtime",
+  "hybrid",
+  "reference",
+]);
+export const defaultAdaptiveLightingProfilePolicy = Object.freeze({
+  preferredProfile: "reference",
+  minimumFrameRate: 30,
+  sampleWindowSize: 4,
+});
 export const lightingDistanceBands = Object.freeze([
   "near",
   "mid",
@@ -199,6 +209,23 @@ function assertLightingImportance(name, value) {
   return value;
 }
 
+function readPositiveIntegerOption(name, value, fallback) {
+  if (value === undefined) {
+    return fallback;
+  }
+
+  if (
+    typeof value !== "number" ||
+    !Number.isFinite(value) ||
+    value <= 0 ||
+    Math.round(value) !== value
+  ) {
+    throw new Error(`${name} must be a positive integer.`);
+  }
+
+  return value;
+}
+
 function resolveBandParticipation(profileName, band, importance) {
   const referenceProfile = profileName === "reference";
   const premiumImportance =
@@ -276,6 +303,93 @@ export function createLightingBandPlan(options = {}) {
   });
 }
 
+const lightingProfileModeEstimatedCostMs = Object.freeze({
+  realtime: 4.5,
+  hybrid: 7.5,
+  reference: 12.5,
+});
+
+export function createLightingProfileModeLadder(options = {}) {
+  const moduleId =
+    typeof options.id === "string" && options.id.trim().length > 0
+      ? options.id.trim()
+      : "lighting-profile-mode";
+  const preferredProfile = getLightingProfile(
+    options.preferredProfile ?? defaultAdaptiveLightingProfilePolicy.preferredProfile
+  ).name;
+  const initialProfile = getLightingProfile(
+    options.initialProfile ?? preferredProfile
+  ).name;
+  const minimumFrameRate = readPositiveIntegerOption(
+    "minimumFrameRate",
+    options.minimumFrameRate,
+    defaultAdaptiveLightingProfilePolicy.minimumFrameRate
+  );
+  const sampleWindowSize = readPositiveIntegerOption(
+    "sampleWindowSize",
+    options.sampleWindowSize,
+    defaultAdaptiveLightingProfilePolicy.sampleWindowSize
+  );
+  const importance = assertLightingImportance(
+    "importance",
+    options.importance ?? "high"
+  );
+  const moduleImportance = assertLightingImportance(
+    "moduleImportance",
+    options.moduleImportance ?? "critical"
+  );
+
+  const levels = Object.freeze(
+    lightingProfileModeOrder.map((profileName) => {
+      const profile = getLightingProfile(profileName);
+      return Object.freeze({
+        id: profile.name,
+        estimatedCostMs: lightingProfileModeEstimatedCostMs[profile.name],
+        config: Object.freeze({
+          profile: profile.name,
+          description: profile.description,
+          techniques: Object.freeze([...profile.techniques]),
+          lightingBandPlan: createLightingBandPlan({
+            profile: profile.name,
+            importance,
+          }),
+          policy: Object.freeze({
+            preferredProfile,
+            minimumFrameRate,
+            sampleWindowSize,
+          }),
+        }),
+      });
+    })
+  );
+
+  return Object.freeze({
+    id: moduleId,
+    domain: "lighting",
+    authority: "visual",
+    importance: moduleImportance,
+    initialLevel: initialProfile,
+    levels,
+    target: Object.freeze({
+      minimumFrameRate,
+      maximumFrameRate: minimumFrameRate,
+      preferredFrameRates: Object.freeze([minimumFrameRate]),
+    }),
+    adaptation: Object.freeze({
+      sampleWindowSize,
+      minimumSamplesBeforeAdjustment: sampleWindowSize,
+      degradeCooldownFrames: 1,
+      upgradeCooldownFrames: sampleWindowSize,
+      minStableFramesForRecovery: sampleWindowSize,
+    }),
+    policy: Object.freeze({
+      preferredProfile,
+      minimumFrameRate,
+      sampleWindowSize,
+    }),
+  });
+}
+
 function buildWorkerBudgetLevels(jobType, queueClass, presets) {
   return Object.freeze([
     Object.freeze({

package/src/techniques/hybrid/direct-lighting.job.wgsl

@@ -1,3 +1,70 @@
-fn process_job() {
-  // Placeholder direct lighting resolve for the hybrid technique.
+@group(0) @binding(0) var<uniform> hybridFrameParams: HybridFrameParams;
+@group(0) @binding(1) var<uniform> hybridReflectionCamera: HybridReflectionCamera;
+@group(0) @binding(2) var<storage, read> hybridReflectionSurfaces: array<HybridReflectionSurface>;
+@group(0) @binding(3) var<storage, read_write> hybridDirectLightingOutput: array<HybridLightingPixel>;
+
+fn direct_lighting_index(pixel: vec2<u32>) -> u32 {
+  return pixel.y * max(hybridFrameParams.image_width, 1u) + pixel.x;
+}
+
+fn evaluate_direct_sun(
+  normal: vec3<f32>,
+  view_direction: vec3<f32>,
+  albedo: vec3<f32>,
+  roughness: f32,
+  metalness: f32
+) -> vec3<f32> {
+  let sun_direction = hybrid_safe_normalize(vec3<f32>(0.31, 0.92, 0.22));
+  let ndotl = hybrid_saturate(dot(normal, sun_direction));
+  if (ndotl <= 0.0) {
+    return vec3<f32>(0.0);
+  }
+
+  let halfway = hybrid_safe_normalize(sun_direction + view_direction);
+  let f0 = hybrid_surface_f0(albedo, metalness);
+  let fresnel = hybrid_fresnel_schlick(
+    hybrid_saturate(dot(normal, view_direction)),
+    f0
+  );
+  let diffuse = albedo * ndotl * 0.3183098861837907 * (1.0 - metalness);
+  let specular_power = 10.0 + (1.0 - roughness) * 112.0;
+  let specular = fresnel * pow(hybrid_saturate(dot(normal, halfway)), specular_power) * ndotl;
+  let sun_color = vec3<f32>(6.2, 5.8, 5.1) * max(hybridFrameParams.sky_intensity, 0.0001);
+  return (diffuse + specular) * sun_color;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  if (
+    global_id.x >= hybridFrameParams.image_width ||
+    global_id.y >= hybridFrameParams.image_height
+  ) {
+    return;
+  }
+
+  let index = direct_lighting_index(global_id.xy);
+  let surface = hybridReflectionSurfaces[index];
+  let position = surface.position.xyz;
+  let normal = hybrid_safe_normalize(surface.normal_roughness.xyz);
+  let roughness = clamp(surface.normal_roughness.w + hybridFrameParams.roughness_bias, 0.02, 1.0);
+  let albedo = surface.albedo_metalness.xyz;
+  let metalness = hybrid_saturate(surface.albedo_metalness.w);
+  let emission = surface.emission_occlusion.xyz;
+  let occlusion = hybrid_saturate(surface.emission_occlusion.w);
+  let view_direction = hybrid_safe_normalize(hybridReflectionCamera.position - position);
+  let direct_sun = evaluate_direct_sun(normal, view_direction, albedo, roughness, metalness);
+  let sky_fill = hybrid_environment(normal, hybridFrameParams.sky_intensity, hybridFrameParams.sky_mode);
+  let grazing = pow(1.0 - hybrid_saturate(dot(normal, view_direction)), 4.0);
+  let ambient = sky_fill * (0.08 + grazing * 0.06) * occlusion;
+  let radiance = emission + direct_sun * occlusion + ambient;
+  let confidence = clamp(
+    hybrid_luminance(radiance) * 0.045 + occlusion * 0.35 + (1.0 - roughness) * 0.15,
+    0.0,
+    1.0
+  );
+
+  hybridDirectLightingOutput[index] = HybridLightingPixel(
+    vec4<f32>(radiance * hybridFrameParams.exposure, confidence),
+    vec4<f32>(normal, occlusion)
+  );
 }

package/src/techniques/hybrid/final-gather.job.wgsl

@@ -1,3 +1,63 @@
-fn process_job() {
-  // Placeholder final gather stage that combines cache data and traces.
+@group(0) @binding(0) var<uniform> hybridFrameParams: HybridFrameParams;
+@group(0) @binding(1) var<storage, read> hybridReflectionSurfaces: array<HybridReflectionSurface>;
+@group(0) @binding(2) var<storage, read> hybridDirectLightingInput: array<HybridLightingPixel>;
+@group(0) @binding(3) var<storage, read> hybridScreenTraceInput: array<HybridScreenTracePixel>;
+@group(0) @binding(4) var<storage, read> hybridRadianceCacheInput: array<HybridRadianceCacheEntry>;
+@group(0) @binding(5) var<storage, read_write> hybridFinalGatherOutput: array<HybridLightingPixel>;
+
+fn final_gather_index(pixel: vec2<u32>) -> u32 {
+  return pixel.y * max(hybridFrameParams.image_width, 1u) + pixel.x;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn process_job(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  if (
+    global_id.x >= hybridFrameParams.image_width ||
+    global_id.y >= hybridFrameParams.image_height
+  ) {
+    return;
+  }
+
+  let index = final_gather_index(global_id.xy);
+  let surface = hybridReflectionSurfaces[index];
+  let direct = hybridDirectLightingInput[index];
+  let trace = hybridScreenTraceInput[index];
+  let cache = hybridRadianceCacheInput[index];
+  let previous = hybridFinalGatherOutput[index];
+  let normal = hybrid_safe_normalize(surface.normal_roughness.xyz);
+  let roughness = clamp(surface.normal_roughness.w + hybridFrameParams.roughness_bias, 0.02, 1.0);
+  let metalness = hybrid_saturate(surface.albedo_metalness.w);
+  let emission = surface.emission_occlusion.xyz;
+  let occlusion = hybrid_saturate(surface.emission_occlusion.w);
+  let direct_radiance = direct.radiance_confidence.xyz;
+  let trace_radiance = trace.radiance_confidence.xyz;
+  let cache_irradiance = cache.irradiance_validity.xyz;
+  let indirect_gi =
+    cache_irradiance * occlusion * (0.32 + (1.0 - roughness) * 0.28);
+  let reflection_term =
+    trace_radiance *
+    trace.radiance_confidence.w *
+    (0.18 + (1.0 - roughness) * 0.42 + metalness * 0.25);
+  let ambient = hybrid_environment(normal, hybridFrameParams.sky_intensity, hybridFrameParams.sky_mode) * 0.05 * occlusion;
+  let current_radiance = direct_radiance + indirect_gi + reflection_term + emission + ambient;
+  let history_weight = select(
+    0.0,
+    encode_history_weight(hybridFrameParams.history_weight),
+    hybridFrameParams.reflection_reset == 0u && previous.radiance_confidence.w > 0.0
+  );
+  let resolved_radiance =
+    previous.radiance_confidence.xyz * history_weight +
+    current_radiance * (1.0 - history_weight);
+  let confidence = clamp(
+    direct.radiance_confidence.w * 0.4 +
+    cache.irradiance_validity.w * 0.3 +
+    trace.radiance_confidence.w * 0.3,
+    0.0,
+    1.0
+  );
+
+  hybridFinalGatherOutput[index] = HybridLightingPixel(
+    vec4<f32>(resolved_radiance, confidence),
+    vec4<f32>(normal, occlusion)
+  );
 }

package/src/techniques/hybrid/prelude.wgsl

@@ -3,6 +3,14 @@ struct HybridFrameParams {
   max_trace_steps: u32,
   history_weight: f32,
   exposure: f32,
+  image_width: u32,
+  image_height: u32,
+  reflection_reset: u32,
+  sky_mode: u32,
+  sky_intensity: f32,
+  max_reflection_distance: f32,
+  roughness_bias: f32,
+  thickness: f32,
 };
 
 struct HybridHit {
@@ -10,6 +18,138 @@ struct HybridHit {
   hit_distance: f32,
 };
 
+struct HybridReflectionCamera {
+  position: vec3<f32>,
+  _padding0: f32,
+};
+
+struct HybridReflectionSurface {
+  position: vec4<f32>,
+  normal_roughness: vec4<f32>,
+  albedo_metalness: vec4<f32>,
+  emission_occlusion: vec4<f32>,
+};
+
+struct HybridGroundPlane {
+  normal: vec3<f32>,
+  height: f32,
+  material_index: u32,
+  enabled: u32,
+  _padding0: vec2<u32>,
+};
+
+struct HybridReflectionSceneMetadata {
+  sphere_count: u32,
+  material_count: u32,
+  _padding0: vec2<u32>,
+  max_trace_distance: f32,
+};
+
+struct HybridReflectionMaterial {
+  albedo_roughness: vec4<f32>,
+  emission_metalness: vec4<f32>,
+};
+
+struct HybridReflectionSphere {
+  center_radius: vec4<f32>,
+  material_index: u32,
+  flags: u32,
+  _padding0: vec2<u32>,
+};
+
+struct HybridReflectionTrace {
+  hit_mask: u32,
+  distance: f32,
+  position: vec3<f32>,
+  material_index: u32,
+  normal: vec3<f32>,
+  _padding1: u32,
+};
+
+struct HybridReflectionPixel {
+  reflection_confidence: vec4<f32>,
+  hit_normal_distance: vec4<f32>,
+};
+
+struct HybridLightingPixel {
+  radiance_confidence: vec4<f32>,
+  normal_occlusion: vec4<f32>,
+};
+
+struct HybridScreenTracePixel {
+  radiance_confidence: vec4<f32>,
+  hit_normal_distance: vec4<f32>,
+};
+
+struct HybridRadianceCacheEntry {
+  irradiance_validity: vec4<f32>,
+  bent_normal_depth: vec4<f32>,
+};
+
 fn encode_history_weight(value: f32) -> f32 {
   return clamp(value, 0.0, 1.0);
 }
+
+fn hybrid_saturate(value: f32) -> f32 {
+  return clamp(value, 0.0, 1.0);
+}
+
+fn hybrid_safe_normalize(value: vec3<f32>) -> vec3<f32> {
+  if (dot(value, value) <= 0.000001) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+
+  return normalize(value);
+}
+
+fn hybrid_fresnel_schlick(cos_theta: f32, f0: vec3<f32>) -> vec3<f32> {
+  let factor = pow(1.0 - hybrid_saturate(cos_theta), 5.0);
+  return f0 + (vec3<f32>(1.0) - f0) * factor;
+}
+
+fn hybrid_surface_f0(albedo: vec3<f32>, metalness: f32) -> vec3<f32> {
+  return vec3<f32>(0.04) * (1.0 - metalness) + albedo * metalness;
+}
+
+fn hybrid_luminance(color: vec3<f32>) -> f32 {
+  return dot(color, vec3<f32>(0.2126, 0.7152, 0.0722));
+}
+
+fn hybrid_hash_u32(value: u32) -> u32 {
+  var x = value + 0x9e3779b9u;
+  x = (x ^ (x >> 16u)) * 0x85ebca6bu;
+  x = (x ^ (x >> 13u)) * 0xc2b2ae35u;
+  return x ^ (x >> 16u);
+}
+
+fn hybrid_random_f32(state: ptr<function, u32>) -> f32 {
+  let next = hybrid_hash_u32((*state) ^ 0x7f4a7c15u);
+  *state = next;
+  return f32(next) * 2.3283064365386963e-10;
+}
+
+fn hybrid_sample_unit_sphere(state: ptr<function, u32>) -> vec3<f32> {
+  let z = hybrid_random_f32(state) * 2.0 - 1.0;
+  let angle = 6.283185307179586 * hybrid_random_f32(state);
+  let radius = sqrt(max(1.0 - z * z, 0.0));
+  return vec3<f32>(radius * cos(angle), radius * sin(angle), z);
+}
+
+fn hybrid_environment(direction: vec3<f32>, intensity: f32, mode: u32) -> vec3<f32> {
+  let up_factor = hybrid_saturate(direction.y * 0.5 + 0.5);
+  let horizon_color = vec3<f32>(0.54, 0.64, 0.77);
+  let zenith_color = select(
+    vec3<f32>(0.04, 0.09, 0.18),
+    vec3<f32>(0.09, 0.07, 0.16),
+    mode == 1u
+  );
+  let sun_direction = hybrid_safe_normalize(vec3<f32>(0.31, 0.92, 0.22));
+  let sun_glow = pow(hybrid_saturate(dot(direction, sun_direction)), 192.0);
+  let sunset_bias = select(vec3<f32>(0.0), vec3<f32>(0.55, 0.24, 0.08) * (1.0 - up_factor), mode == 1u);
+  return (
+    horizon_color * (1.0 - up_factor) +
+    zenith_color * up_factor +
+    sunset_bias +
+    vec3<f32>(5.8, 5.5, 5.0) * sun_glow
+  ) * max(intensity, 0.0001);
+}