@multiplekex/shallot 0.2.3 → 0.2.5

package/src/standard/render/forward/raster.ts

@@ -1,228 +0,0 @@
-import type { SurfaceData } from "../surface";
-import { SCENE_STRUCT_WGSL, WGSL_STRUCTS } from "../surface/structs";
-import { compileVertexBody, WGSL_LIGHTING_CALC, SKY_WGSL, SKY_DIR_WGSL } from "../surface/wgsl";
-
-function compileSurfaceVariant(id: number, data: SurfaceData): string {
-    const vertexBody = compileVertexBody(data.vertex);
-    const fragmentBody = data.fragment ?? "";
-    const lit = data.lit !== false;
-
-    return `
-fn userVertexTransform_${id}(worldPos: vec3<f32>, normal: vec3<f32>, eid: u32) -> vec3<f32> {
-    ${vertexBody}
-}
-
-fn userFragment_${id}(surface: ptr<function, SurfaceData>, position: vec4<f32>) {
-    ${fragmentBody}
-}
-
-fn applyLighting_${id}(surface: SurfaceData) -> vec3<f32> {
-    ${
-        lit
-            ? `${WGSL_LIGHTING_CALC}
-    return surface.baseColor * lighting + surface.emission;`
-            : "return surface.baseColor;"
-    }
-}
-`;
-}
-
-function compileDispatchFunctions(surfaceCount: number): string {
-    const vertexCases = Array.from(
-        { length: surfaceCount },
-        (_, i) => `        case ${i}u: { return userVertexTransform_${i}(worldPos, normal, eid); }`
-    ).join("\n");
-
-    const fragmentCases = Array.from(
-        { length: surfaceCount },
-        (_, i) => `        case ${i}u: { userFragment_${i}(surface, position); }`
-    ).join("\n");
-
-    const lightingCases = Array.from(
-        { length: surfaceCount },
-        (_, i) => `        case ${i}u: { return applyLighting_${i}(surface); }`
-    ).join("\n");
-
-    return `
-fn dispatchVertexTransform(surfaceId: u32, worldPos: vec3<f32>, normal: vec3<f32>, eid: u32) -> vec3<f32> {
-    switch surfaceId {
-${vertexCases}
-        default: { return userVertexTransform_0(worldPos, normal, eid); }
-    }
-}
-
-fn dispatchFragment(surfaceId: u32, surface: ptr<function, SurfaceData>, position: vec4<f32>) {
-    switch surfaceId {
-${fragmentCases}
-        default: { userFragment_0(surface, position); }
-    }
-}
-
-fn dispatchLighting(surfaceId: u32, surface: SurfaceData) -> vec3<f32> {
-    switch surfaceId {
-${lightingCases}
-        default: { return applyLighting_0(surface); }
-    }
-}
-`;
-}
-
-export function compileRasterShader(surfaces: SurfaceData[]): string {
-    const surfaceVariants = surfaces.map((s, i) => compileSurfaceVariant(i, s)).join("\n");
-    const dispatchFunctions = compileDispatchFunctions(surfaces.length);
-
-    return /* wgsl */ `
-${WGSL_STRUCTS}
-
-@group(0) @binding(8) var<storage, read> surfaceIds: array<u32>;
-
-${surfaceVariants}
-${dispatchFunctions}
-
-@vertex
-fn vs(input: VertexInput) -> VertexOutput {
-    let eid = entityIds[input.instance];
-    let world = matrices[eid];
-    let scaledPos = input.position * sizes[eid].xyz;
-    let baseWorldPos = (world * vec4<f32>(scaledPos, 1.0)).xyz;
-    let worldNormal = normalize((world * vec4<f32>(input.normal, 0.0)).xyz);
-    let surfaceId = surfaceIds[eid] & 0xFFu;
-    let finalWorldPos = dispatchVertexTransform(surfaceId, baseWorldPos, worldNormal, eid);
-    _ = shapes[eid];
-
-    var output: VertexOutput;
-    output.position = scene.viewProj * vec4<f32>(finalWorldPos, 1.0);
-    output.color = colors[eid];
-    output.worldNormal = worldNormal;
-    output.entityId = eid;
-    output.worldPos = finalWorldPos;
-    return output;
-}
-
-@fragment
-fn fs(input: VertexOutput) -> FragmentOutput {
-    let eid = input.entityId;
-    let pbrData = pbr[eid];
-    let emissionData = emission[eid];
-    let surfaceId = surfaceIds[eid] & 0xFFu;
-
-    var surface: SurfaceData;
-    surface.baseColor = input.color.rgb;
-    surface.roughness = pbrData.x;
-    surface.metallic = pbrData.y;
-    surface.emission = emissionData.rgb * emissionData.a;
-    surface.normal = normalize(input.worldNormal);
-    surface.worldPos = input.worldPos;
-
-    dispatchFragment(surfaceId, &surface, input.position);
-
-    let litColor = dispatchLighting(surfaceId, surface);
-
-    var output: FragmentOutput;
-    output.color = vec4<f32>(litColor, input.color.a);
-    output.entityId = input.entityId;
-    return output;
-}
-`;
-}
-
-export async function createRasterPipeline(
-    device: GPUDevice,
-    surfaces: SurfaceData[],
-    colorFormat: GPUTextureFormat
-): Promise<GPURenderPipeline> {
-    const code = compileRasterShader(surfaces);
-    const module = device.createShaderModule({ code });
-
-    return device.createRenderPipelineAsync({
-        layout: "auto",
-        vertex: {
-            module,
-            entryPoint: "vs",
-            buffers: [
-                {
-                    arrayStride: 24,
-                    attributes: [
-                        { shaderLocation: 0, offset: 0, format: "float32x3" },
-                        { shaderLocation: 1, offset: 12, format: "float32x3" },
-                    ],
-                },
-            ],
-        },
-        fragment: {
-            module,
-            entryPoint: "fs",
-            targets: [{ format: colorFormat }, { format: "r32uint" }],
-        },
-        depthStencil: {
-            format: "depth24plus",
-            depthWriteEnabled: true,
-            depthCompare: "less",
-        },
-        primitive: {
-            topology: "triangle-list",
-            cullMode: "back",
-        },
-    });
-}
-
-export function compileSkyShader(): string {
-    return /* wgsl */ `
-${SCENE_STRUCT_WGSL}
-
-@group(0) @binding(0) var<uniform> scene: Scene;
-
-${SKY_DIR_WGSL}
-${SKY_WGSL}
-
-struct VertexOutput {
-    @builtin(position) position: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-}
-
-@vertex
-fn vs(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
-    var positions = array<vec2<f32>, 3>(
-        vec2(-1.0, -1.0),
-        vec2(3.0, -1.0),
-        vec2(-1.0, 3.0)
-    );
-    var output: VertexOutput;
-    output.position = vec4(positions[vertexIndex], 0.0, 1.0);
-    output.uv = (positions[vertexIndex] + 1.0) * 0.5;
-    output.uv.y = 1.0 - output.uv.y;
-    return output;
-}
-
-@fragment
-fn fs(input: VertexOutput) -> @location(0) vec4<f32> {
-    let dir = computeSkyDir(input.uv.x, input.uv.y);
-    let color = sampleSky(dir);
-    return vec4(color, 1.0);
-}
-`;
-}
-
-export async function createSkyPipeline(
-    device: GPUDevice,
-    colorFormat: GPUTextureFormat
-): Promise<GPURenderPipeline> {
-    const code = compileSkyShader();
-    const module = device.createShaderModule({ code });
-
-    return device.createRenderPipelineAsync({
-        layout: "auto",
-        vertex: { module, entryPoint: "vs" },
-        fragment: {
-            module,
-            entryPoint: "fs",
-            targets: [{ format: colorFormat }],
-        },
-        depthStencil: {
-            format: "depth24plus",
-            depthWriteEnabled: false,
-            depthCompare: "always",
-        },
-        primitive: { topology: "triangle-list" },
-    });
-}

package/src/standard/render/shaders.ts

@@ -1,484 +0,0 @@
-import type { SurfaceData } from "./surface";
-import {
-    compileVertexBody,
-    compileApplyLighting,
-    reflectionWgsl,
-    SHADOW_WGSL,
-    SPECULAR_WGSL,
-    REFRACTION_WGSL,
-    SKY_DIR_WGSL,
-    SKY_WGSL,
-    HAZE_WGSL,
-} from "./surface/wgsl";
-import {
-    BVH_STRUCTS,
-    TLAS_BLAS_STRUCTS,
-    TLAS_BLAS_BINDINGS,
-    TLAS_BLAS_TRAVERSAL,
-    TLAS_BLAS_ANY_HIT,
-} from "./bvh/traverse";
-import { RAY_STRUCT_WGSL, HIT_RESULT_STRUCT_WGSL } from "./bvh/structs";
-import { SURFACE_DATA_STRUCT_WGSL, SCENE_STRUCT_WGSL, DATA_STRUCT_WGSL } from "./surface/structs";
-
-export { SCENE_STRUCT_WGSL };
-
-const EPSILON = 1e-7;
-
-export const RT_STRUCTS = /* wgsl */ `
-${RAY_STRUCT_WGSL}
-${HIT_RESULT_STRUCT_WGSL}
-${SURFACE_DATA_STRUCT_WGSL}
-${SCENE_STRUCT_WGSL}
-${DATA_STRUCT_WGSL}
-`;
-
-export const RT_BINDINGS = /* wgsl */ `
-@group(0) @binding(0) var<uniform> scene: Scene;
-@group(0) @binding(1) var<storage, read> data: array<Data>;
-@group(0) @binding(2) var output_scene: texture_storage_2d<rgba8unorm, write>;
-@group(0) @binding(3) var output_depth: texture_storage_2d<r32float, write>;
-@group(0) @binding(4) var output_entityId: texture_storage_2d<r32uint, write>;
-`;
-
-export const RT_UTILS = /* wgsl */ `
-fn getData(eid: u32) -> Data {
-    return data[eid];
-}
-
-fn getSurfaceType(eid: u32) -> u32 {
-    return data[eid].flags & 0xFFu;
-}
-
-fn getVolume(eid: u32) -> u32 {
-    return (data[eid].flags >> 8u) & 0xFu;
-}
-
-fn getShapeId(eid: u32) -> u32 {
-    return data[eid].flags >> 16u;
-}
-
-fn getInstanceCount() -> u32 {
-    return scene.instanceCount;
-}
-`;
-
-export const RT_RAY_GEN = /* wgsl */ `
-${SKY_DIR_WGSL}
-
-struct PrimaryRay {
-    origin: vec3<f32>,
-    direction: vec3<f32>,
-    skyDir: vec3<f32>,
-}
-
-fn generateRay(screenX: f32, screenY: f32) -> PrimaryRay {
-    var result: PrimaryRay;
-    result.skyDir = computeSkyDir(screenX, screenY);
-
-    let width = scene.viewport.x;
-    let height = scene.viewport.y;
-    let ndcX = screenX * 2.0 - 1.0;
-    let ndcY = 1.0 - screenY * 2.0;
-    let aspect = width / height;
-
-    let cameraWorld = scene.cameraWorld;
-    let camPosX = cameraWorld[3][0];
-    let camPosY = cameraWorld[3][1];
-    let camPosZ = cameraWorld[3][2];
-
-    if (scene.cameraMode > 0.5) {
-        let r00 = cameraWorld[0][0]; let r10 = cameraWorld[0][1]; let r20 = cameraWorld[0][2];
-        let r01 = cameraWorld[1][0]; let r11 = cameraWorld[1][1]; let r21 = cameraWorld[1][2];
-        let r02 = cameraWorld[2][0]; let r12 = cameraWorld[2][1]; let r22 = cameraWorld[2][2];
-
-        let halfHeight = scene.cameraSize;
-        let halfWidth = halfHeight * aspect;
-        let offsetX = ndcX * halfWidth;
-        let offsetY = ndcY * halfHeight;
-        let fwdX = -r02; let fwdY = -r12; let fwdZ = -r22;
-
-        result.origin = vec3(
-            camPosX + r00 * offsetX + r01 * offsetY + fwdX * scene.near,
-            camPosY + r10 * offsetX + r11 * offsetY + fwdY * scene.near,
-            camPosZ + r20 * offsetX + r21 * offsetY + fwdZ * scene.near
-        );
-        result.direction = vec3(fwdX, fwdY, fwdZ);
-    } else {
-        let dir = result.skyDir;
-        result.origin = vec3(camPosX + dir.x * scene.near, camPosY + dir.y * scene.near, camPosZ + dir.z * scene.near);
-        result.direction = dir;
-    }
-
-    return result;
-}
-`;
-
-export const RT_INTERSECTION = /* wgsl */ `
-const EPSILON: f32 = ${EPSILON};
-`;
-
-export function compileRTSurface(data: SurfaceData): string {
-    return compileUberShader([data]);
-}
-
-function compileSurfaceVariant(id: number, data: SurfaceData): string {
-    const vertexBody = compileVertexBody(data.vertex);
-    const fragmentBody = data.fragment ?? "";
-    const lightingCode = compileApplyLighting(data.lit, true, true);
-
-    return `
-fn userVertexTransform_${id}(worldPos: vec3<f32>, normal: vec3<f32>, eid: u32) -> vec3<f32> {
-    ${vertexBody}
-}
-
-fn userFragment_${id}(surface: ptr<function, SurfaceData>, position: vec4<f32>) {
-    ${fragmentBody}
-}
-
-fn applyLighting_${id}(surface: SurfaceData, rayDir: vec3<f32>) -> vec3<f32> {
-    ${lightingCode}
-}
-`;
-}
-
-function compileDispatchFunctions(surfaceCount: number): string {
-    const vertexCases = Array.from(
-        { length: surfaceCount },
-        (_, i) => `        case ${i}u: { return userVertexTransform_${i}(worldPos, normal, eid); }`
-    ).join("\n");
-
-    const fragmentCases = Array.from(
-        { length: surfaceCount },
-        (_, i) => `        case ${i}u: { userFragment_${i}(surface, position); }`
-    ).join("\n");
-
-    const lightingCases = Array.from(
-        { length: surfaceCount },
-        (_, i) => `        case ${i}u: { return applyLighting_${i}(surface, rayDir); }`
-    ).join("\n");
-
-    return `
-fn dispatchVertexTransform(surfaceId: u32, worldPos: vec3<f32>, normal: vec3<f32>, eid: u32) -> vec3<f32> {
-    switch surfaceId {
-${vertexCases}
-        default: { return userVertexTransform_0(worldPos, normal, eid); }
-    }
-}
-
-fn dispatchFragment(surfaceId: u32, surface: ptr<function, SurfaceData>, position: vec4<f32>) {
-    switch surfaceId {
-${fragmentCases}
-        default: { userFragment_0(surface, position); }
-    }
-}
-
-fn dispatchLighting(surfaceId: u32, surface: SurfaceData, rayDir: vec3<f32>) -> vec3<f32> {
-    switch surfaceId {
-${lightingCases}
-        default: { return applyLighting_0(surface, rayDir); }
-    }
-}
-`;
-}
-
-export function compileUberShader(
-    surfaces: SurfaceData[],
-    _shadows: boolean = true,
-    _reflections: boolean = true,
-    _refractions: boolean = true
-): string {
-    const surfaceVariants = surfaces.map((s, i) => compileSurfaceVariant(i, s)).join("\n");
-    const dispatchFunctions = compileDispatchFunctions(surfaces.length);
-
-    return /* wgsl */ `
-${RT_STRUCTS}
-${BVH_STRUCTS}
-${TLAS_BLAS_STRUCTS}
-${RT_BINDINGS}
-${RT_UTILS}
-${TLAS_BLAS_BINDINGS}
-${RT_RAY_GEN}
-${RT_INTERSECTION}
-${TLAS_BLAS_TRAVERSAL}
-${TLAS_BLAS_ANY_HIT}
-${SHADOW_WGSL}
-${SPECULAR_WGSL}
-${REFRACTION_WGSL}
-${SKY_WGSL}
-${HAZE_WGSL}
-${reflectionWgsl(true)}
-
-${surfaceVariants}
-${dispatchFunctions}
-
-const MAX_TRANSPARENT_DEPTH: u32 = 4u;
-const TRANSPARENCY_EPSILON: f32 = 0.001;
-const MAX_REFRACTION_DEPTH: u32 = 2u;
-const REFRACTION_EPSILON: f32 = 0.001;
-
-${compileRefractionTracer(true)}
-
-@compute @workgroup_size(8, 8)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let width = u32(scene.viewport.x);
-    let height = u32(scene.viewport.y);
-
-    if (gid.x >= width || gid.y >= height) {
-        return;
-    }
-
-    let screenX = (f32(gid.x) + 0.5) / f32(width);
-    let screenY = (f32(gid.y) + 0.5) / f32(height);
-
-    let primary = generateRay(screenX, screenY);
-    var ray: Ray;
-    ray.origin = primary.origin;
-    ray.direction = primary.direction;
-
-    var finalColor = vec3(0.0);
-    var remainingOpacity = 1.0;
-    var depth = 1e30;
-    var entityId = 0u;
-    var firstHit = true;
-
-    for (var i = 0u; i < MAX_TRANSPARENT_DEPTH; i++) {
-        let hit = trace(ray);
-
-        if (!hit.hit) {
-            finalColor += sampleSky(primary.skyDir) * remainingOpacity;
-            break;
-        }
-
-        let eid = hit.entityId;
-        let d = getData(eid);
-        let opacity = d.baseColor.a;
-        let surfaceId = getSurfaceType(eid);
-
-        if (firstHit) {
-            depth = hit.t;
-            entityId = eid;
-            firstHit = false;
-        }
-
-        let finalWorldPos = dispatchVertexTransform(surfaceId, hit.worldPos, hit.normal, eid);
-
-        var surface: SurfaceData;
-        surface.baseColor = d.baseColor.rgb;
-        surface.roughness = d.pbr.x;
-        surface.metallic = d.pbr.y;
-        surface.opacity = opacity;
-        surface.emission = d.emission.rgb * d.emission.a;
-        surface.normal = hit.normal;
-        surface.worldPos = finalWorldPos;
-
-        dispatchFragment(surfaceId, &surface, vec4(f32(gid.x), f32(gid.y), hit.t, 1.0));
-
-        ${compileRefractionBranch()}
-        let litColor = dispatchLighting(surfaceId, surface, primary.direction);
-        let hazeColor = applyHaze(litColor, hit.t);
-
-        let contribution = opacity * remainingOpacity;
-        finalColor += hazeColor * contribution;
-
-        if (opacity >= 1.0) {
-            break;
-        }
-
-        remainingOpacity *= (1.0 - opacity);
-        if (remainingOpacity < 0.02) {
-            break;
-        }
-
-        ray.origin = hit.worldPos + ray.direction * TRANSPARENCY_EPSILON;
-    }
-
-    textureStore(output_scene, vec2<i32>(gid.xy), vec4(finalColor, 1.0));
-    textureStore(output_depth, vec2<i32>(gid.xy), vec4(depth, 0.0, 0.0, 0.0));
-    textureStore(output_entityId, vec2<i32>(gid.xy), vec4(entityId, 0u, 0u, 0u));
-}
-`;
-}
-
-function compileRefractionTracer(_shadows: boolean = true): string {
-    const shadowCheck = `var hitShadow = 1.0;
-            if (hitNdotL > 0.0 && scene.shadowSamples > 0u) {
-                var shadowRay: Ray;
-                shadowRay.origin = refHit.worldPos + refHit.normal * REFRACTION_EPSILON;
-                shadowRay.direction = hitL;
-                if (traceAnyHit(shadowRay, 1000.0)) { hitShadow = 0.0; }
-            }`;
-
-    return /* wgsl */ `
-const VOLUME_SOLID: u32 = 0u;
-const VOLUME_HALF_SPACE: u32 = 1u;
-
-fn traceRefraction(
-    startPos: vec3<f32>,
-    startNormal: vec3<f32>,
-    rayDir: vec3<f32>,
-    ior: f32,
-    mediumColor: vec3<f32>,
-    volumeType: u32,
-    maxBounces: u32
-) -> vec3<f32> {
-    var currentPos = startPos;
-    var currentNormal = startNormal;
-    var currentDir = rayDir;
-    var currentIOR = ior;
-    var currentMediumColor = mediumColor;
-    var totalDistance = 0.0;
-    var inMedium = true;
-    let isHalfSpace = volumeType == VOLUME_HALF_SPACE;
-
-    for (var bounce = 0u; bounce < maxBounces; bounce++) {
-        let entering = dot(currentDir, currentNormal) < 0.0;
-        let n = select(-currentNormal, currentNormal, entering);
-        let n1 = select(currentIOR, 1.0, entering);
-        let n2 = select(1.0, currentIOR, entering);
-        let eta = n1 / n2;
-
-        let refractResult = refractRay(currentDir, n, eta);
-        let isTIR = refractResult.w > 0.5;
-
-        var refractRay_: Ray;
-        refractRay_.direction = refractResult.xyz;
-        refractRay_.origin = select(
-            currentPos - n * REFRACTION_EPSILON,
-            currentPos + n * REFRACTION_EPSILON,
-            isTIR
-        );
-
-        let refHit = trace(refractRay_);
-        if (!refHit.hit) {
-            if (isHalfSpace && inMedium) {
-                let depthFade = exp(-totalDistance * 0.1);
-                return currentMediumColor * depthFade * scene.ambientColor.rgb * scene.ambientColor.a;
-            }
-            var skyColor = sampleSky(refractRay_.direction);
-            if (inMedium && totalDistance > 0.0) {
-                let absorption = exp(-totalDistance * 0.5);
-                skyColor = mix(skyColor * currentMediumColor, skyColor, absorption);
-            }
-            return skyColor;
-        }
-
-        if (inMedium) {
-            totalDistance += refHit.t;
-        }
-
-        let refEid = refHit.entityId;
-        let refracted = getData(refEid);
-        let refOpacity = refracted.baseColor.a;
-        let refIOR = refracted.pbr.z;
-
-        if (refIOR <= 1.0) {
-            let hitBaseColor = refracted.baseColor.rgb;
-            let hitMetallic = refracted.pbr.y;
-            let hitEmission = refracted.emission.rgb * refracted.emission.a;
-
-            let hitL = -scene.sunDirection.xyz;
-            let hitNdotL = max(dot(refHit.normal, hitL), 0.0);
-${shadowCheck}
-
-            let hitAmbient = scene.ambientColor.rgb * scene.ambientColor.a;
-            let hitSun = scene.sunColor.rgb * hitNdotL * hitShadow;
-            var hitDiffuse = hitBaseColor * (hitAmbient + hitSun) * (1.0 - hitMetallic);
-
-            if (totalDistance > 0.0) {
-                let absorption = exp(-totalDistance * 0.5);
-                hitDiffuse = mix(hitDiffuse * currentMediumColor, hitDiffuse, absorption);
-            }
-
-            var surfaceColor = applyHaze(hitDiffuse + hitEmission, refHit.t);
-
-            if (refOpacity >= 1.0) {
-                return surfaceColor;
-            }
-
-            var behindRay: Ray;
-            behindRay.origin = refHit.worldPos + refractRay_.direction * REFRACTION_EPSILON;
-            behindRay.direction = refractRay_.direction;
-            let behindHit = trace(behindRay);
-            var behindColor = sampleSky(refractRay_.direction);
-            if (behindHit.hit) {
-                let behind = getData(behindHit.entityId);
-                let behindBaseColor = behind.baseColor.rgb;
-                let behindMetallic = behind.pbr.y;
-                let behindEmission = behind.emission.rgb * behind.emission.a;
-                let behindNdotL = max(dot(behindHit.normal, hitL), 0.0);
-                let behindAmbient = scene.ambientColor.rgb * scene.ambientColor.a;
-                let behindSun = scene.sunColor.rgb * behindNdotL;
-                behindColor = applyHaze(behindBaseColor * (behindAmbient + behindSun) * (1.0 - behindMetallic) + behindEmission, behindHit.t);
-            }
-
-            return surfaceColor * refOpacity + behindColor * (1.0 - refOpacity);
-        }
-
-        if (!entering) {
-            inMedium = false;
-        } else {
-            inMedium = true;
-            currentMediumColor = refracted.baseColor.rgb;
-            totalDistance = 0.0;
-        }
-
-        currentPos = refHit.worldPos;
-        currentNormal = refHit.normal;
-        currentDir = refractRay_.direction;
-        currentIOR = refIOR;
-    }
-
-    if (isHalfSpace && inMedium) {
-        let depthFade = exp(-totalDistance * 0.1);
-        return currentMediumColor * depthFade * scene.ambientColor.rgb * scene.ambientColor.a;
-    }
-    var skyColor = sampleSky(currentDir);
-    if (inMedium && totalDistance > 0.0) {
-        let absorption = exp(-totalDistance * 0.5);
-        skyColor = mix(skyColor * currentMediumColor, skyColor, absorption);
-    }
-    return skyColor;
-}
-`;
-}
-
-function compileRefractionBranch(): string {
-    return /* wgsl */ `
-        let ior = d.pbr.z;
-        if (ior > 1.0 && scene.refractionDepth > 0u) {
-            let entering = dot(ray.direction, surface.normal) < 0.0;
-            let n = select(-surface.normal, surface.normal, entering);
-            let n1 = select(ior, 1.0, entering);
-            let n2 = select(1.0, ior, entering);
-            let cosI = abs(dot(ray.direction, n));
-            let fresnel = fresnelSchlickIOR(cosI, n1, n2);
-
-            let volumeType = getVolume(eid);
-            let refractedColor = traceRefraction(
-                surface.worldPos, surface.normal, ray.direction, ior,
-                surface.baseColor, volumeType, scene.refractionDepth
-            );
-
-            let contribution = opacity * remainingOpacity;
-            let refractContrib = (1.0 - fresnel) * contribution;
-            finalColor += applyHaze(refractedColor, hit.t) * refractContrib;
-
-            let litColor = dispatchLighting(surfaceId, surface, primary.direction);
-            finalColor += applyHaze(litColor, hit.t) * fresnel * contribution;
-
-            if (opacity >= 1.0) {
-                break;
-            }
-            remainingOpacity *= (1.0 - opacity);
-            if (remainingOpacity < 0.02) {
-                break;
-            }
-            ray.origin = hit.worldPos + ray.direction * TRANSPARENCY_EPSILON;
-            continue;
-        }
-`;
-}
-
-export function compileForwardShader(surface: SurfaceData): string {
-    return compileUberShader([surface]);
-}