@multiplekex/shallot 0.2.3 → 0.2.5

package/src/standard/render/surface/wgsl.ts

@@ -1,573 +0,0 @@
-export function compileVertexBody(vertex?: string): string {
-    return vertex
-        ? `var pos = worldPos;
-    ${vertex}
-    return pos;`
-        : "return worldPos;";
-}
-
-export const STARS_WGSL = /* wgsl */ `
-fn hashStar(p: vec2<f32>) -> f32 {
-    var p3 = fract(vec3(p.x, p.y, p.x) * 0.1031);
-    p3 += dot(p3, p3.yzx + 33.33);
-    return fract((p3.x + p3.y) * p3.z);
-}
-
-fn hash2Star(p: vec2<f32>) -> vec2<f32> {
-    var p3 = fract(vec3(p.x, p.y, p.x) * vec3(0.1031, 0.1030, 0.0973));
-    p3 += dot(p3, p3.yzx + 33.33);
-    return fract((p3.xx + p3.yz) * p3.zy);
-}
-
-fn sampleStars(dir: vec3<f32>) -> vec3<f32> {
-    if (scene.starParams.z <= 0.0 || dir.y < 0.0) {
-        return vec3(0.0);
-    }
-
-    let theta = atan2(dir.z, dir.x);
-    let phi = asin(clamp(dir.y, -1.0, 1.0));
-
-    let gridSize = mix(20.0, 100.0, scene.starParams.y);
-    let cell = vec2(theta * gridSize / 3.14159, phi * gridSize / 1.5708);
-    let cellId = floor(cell);
-    let cellFract = fract(cell);
-
-    var starColor = vec3(0.0);
-
-    for (var dy = -1; dy <= 1; dy++) {
-        for (var dx = -1; dx <= 1; dx++) {
-            let neighbor = cellId + vec2(f32(dx), f32(dy));
-            let starHash = hashStar(neighbor);
-
-            if (starHash > scene.starParams.y * 0.7) {
-                continue;
-            }
-
-            let starPos = hash2Star(neighbor);
-            let starCenter = neighbor + starPos;
-            let dist = length(cell - starCenter);
-
-            let brightness = hashStar(neighbor + vec2(100.0, 100.0));
-            let radius = 0.02 + brightness * 0.03;
-
-            if (dist < radius) {
-                let twinkle = 0.8 + 0.2 * sin(brightness * 100.0);
-                let intensity = scene.starParams.x * brightness * twinkle;
-                let falloff = 1.0 - smoothstep(0.0, radius, dist);
-
-                let temp = hashStar(neighbor + vec2(200.0, 200.0));
-                let tint = mix(vec3(1.0, 0.9, 0.8), vec3(0.8, 0.9, 1.0), temp);
-
-                starColor = max(starColor, tint * intensity * falloff);
-            }
-        }
-    }
-
-    return starColor;
-}
-`;
-
-import { NOISE_WGSL } from "./noise";
-
-export const MOON_WGSL = /* wgsl */ `
-fn sampleMoon(dir: vec3<f32>) -> vec3<f32> {
-    if (scene.moonParams.z <= 0.0) {
-        return vec3(0.0);
-    }
-
-    let moonDir = scene.moonDirection.xyz;
-    let moonDot = dot(dir, moonDir);
-
-    let moonSize = 0.9995;
-    let moonColor = vec3(0.9, 0.9, 0.85);
-
-    if (moonDot > moonSize) {
-        let toCenter = dir - moonDir * moonDot;
-        let diskRight = normalize(cross(moonDir, vec3(0.0, 1.0, 0.0)));
-        let diskUp = cross(diskRight, moonDir);
-
-        let diskRadius = sqrt(1.0 - moonSize * moonSize);
-        let u = dot(toCenter, diskRight) / diskRadius;
-        let v = dot(toCenter, diskUp) / diskRadius;
-
-        let r2 = u * u + v * v;
-        let z = sqrt(max(0.0, 1.0 - r2));
-
-        let phase = scene.moonParams.x;
-        let sunAngle = phase * 6.28318;
-        let sunLocalX = sin(sunAngle);
-        let sunLocalZ = -cos(sunAngle);
-
-        let illumination = u * sunLocalX + z * sunLocalZ;
-        let lit = select(0.15, 1.0, illumination > 0.0);
-
-        return moonColor * lit;
-    } else {
-        let glowFalloff = max(0.0, moonDot - 0.99) / (moonSize - 0.99);
-        let glow = pow(glowFalloff, 2.0) * scene.moonParams.y;
-        return moonColor * glow * 0.3;
-    }
-}
-`;
-
-export const CLOUDS_WGSL = /* wgsl */ `
-${NOISE_WGSL}
-
-fn sampleClouds(dir: vec3<f32>) -> vec4<f32> {
-    if (scene.cloudParams.w <= 0.0 || dir.y < 0.01) {
-        return vec4(0.0);
-    }
-
-    let t = scene.cloudParams.z / max(dir.y, 0.001);
-    let uv = dir.xz * t;
-
-    var n = fbm2(uv, 5);
-
-    let coverage = scene.cloudParams.x;
-    let density = scene.cloudParams.y;
-    n = smoothstep(1.0 - coverage, 1.0, n * 0.5 + 0.5) * density;
-
-    n *= smoothstep(0.0, 0.15, dir.y);
-
-    return vec4(scene.cloudColor.rgb, n);
-}
-`;
-
-const DEG_TO_RAD = Math.PI / 180;
-
-export const SKY_DIR_WGSL = /* wgsl */ `
-const DEG_TO_RAD: f32 = ${DEG_TO_RAD};
-
-fn computeSkyDir(screenX: f32, screenY: f32) -> vec3<f32> {
-    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 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 skyFov = select(scene.fov, 60.0, scene.cameraMode > 0.5);
-    let tanHalfFov = tan((skyFov * DEG_TO_RAD) / 2.0);
-    let camDirX = ndcX * aspect * tanHalfFov;
-    let camDirY = ndcY * tanHalfFov;
-    let camDirZ = -1.0;
-    var dirX = r00 * camDirX + r01 * camDirY + r02 * camDirZ;
-    var dirY = r10 * camDirX + r11 * camDirY + r12 * camDirZ;
-    var dirZ = r20 * camDirX + r21 * camDirY + r22 * camDirZ;
-    let len = sqrt(dirX * dirX + dirY * dirY + dirZ * dirZ);
-    dirX /= len; dirY /= len; dirZ /= len;
-    return vec3(dirX, dirY, dirZ);
-}
-`;
-
-export const SKY_WGSL = /* wgsl */ `
-${STARS_WGSL}
-${MOON_WGSL}
-${CLOUDS_WGSL}
-
-fn sampleSky(dir: vec3<f32>) -> vec3<f32> {
-    if (scene.skyZenith.a <= 0.0) {
-        return scene.clearColor.rgb;
-    }
-
-    let t = pow(clamp(dir.y, 0.0, 1.0), 0.25);
-    var color = mix(scene.skyHorizon.rgb, scene.skyZenith.rgb, t);
-
-    let horizonBand = 1.0 - abs(dir.y);
-    let horizonBlend = pow(horizonBand, 32.0);
-    color = mix(color, vec3(1.09), horizonBlend);
-
-    color += sampleStars(dir);
-
-    let clouds = sampleClouds(dir);
-    color = mix(color, clouds.rgb, clouds.a);
-
-    let moonContrib = sampleMoon(dir);
-    color += moonContrib * (1.0 - clouds.a * 0.7);
-
-    let sunDir = -scene.sunDirection.xyz;
-    let sunDot = dot(dir, sunDir);
-
-    let sunVisualColor = select(scene.sunColor.rgb, scene.sunVisualColor.rgb, scene.sunParams.z > 0.5);
-
-    let baseSunSize = 0.9995;
-    let sunSizeParam = scene.sunParams.x;
-    let sunThreshold = 1.0 - (1.0 - baseSunSize) * sunSizeParam;
-
-    if (sunDot > sunThreshold) {
-        color = sunVisualColor;
-    } else {
-        let glow = max(0.0, sunDot);
-        let glowParam = scene.sunParams.y;
-        let glowIntensity = pow(glow, 8.0) * glowParam;
-        color += sunVisualColor * glowIntensity;
-    }
-
-    if (scene.hazeDensity > 0.0) {
-        let horizonFactor = 1.0 - clamp(dir.y, 0.0, 1.0);
-        let hazeAmount = pow(horizonFactor, 2.0) * saturate(scene.hazeDensity * 5.0);
-        color = mix(color, scene.hazeColor.rgb, hazeAmount);
-    }
-
-    return color;
-}
-`;
-
-export const HAZE_WGSL = /* wgsl */ `
-fn applyHaze(color: vec3<f32>, dist: f32) -> vec3<f32> {
-    if (scene.hazeDensity <= 0.0) {
-        return color;
-    }
-    let haze = 1.0 - exp(-scene.hazeDensity * dist);
-    return mix(color, scene.hazeColor.rgb, haze);
-}
-`;
-
-export const SPECULAR_WGSL = /* wgsl */ `
-const DIELECTRIC_F0: f32 = 0.04;
-
-fn blinnPhongSpecular(N: vec3<f32>, L: vec3<f32>, V: vec3<f32>, roughness: f32) -> f32 {
-    let H = normalize(L + V);
-    let NdotH = max(dot(N, H), 0.0);
-    let shininess = pow(2.0, (1.0 - roughness) * 10.0);
-    let intensity = (1.0 - roughness) * (1.0 - roughness);
-    return pow(NdotH, shininess) * intensity;
-}
-
-fn schlickFresnel(cosTheta: f32, F0: vec3<f32>) -> vec3<f32> {
-    return F0 + (vec3(1.0) - F0) * pow(1.0 - cosTheta, 5.0);
-}
-
-fn computeF0Vec(baseColor: vec3<f32>, metallic: f32) -> vec3<f32> {
-    return mix(vec3(DIELECTRIC_F0), baseColor, metallic);
-}
-`;
-
-export const REFRACTION_WGSL = /* wgsl */ `
-fn refractRay(I: vec3<f32>, N: vec3<f32>, eta: f32) -> vec4<f32> {
-    let cosI = -dot(I, N);
-    let sinT2 = eta * eta * (1.0 - cosI * cosI);
-    if (sinT2 > 1.0) {
-        return vec4(reflect(I, N), 1.0);
-    }
-    let cosT = sqrt(1.0 - sinT2);
-    return vec4(normalize(eta * I + (eta * cosI - cosT) * N), 0.0);
-}
-
-fn fresnelSchlickIOR(cosTheta: f32, n1: f32, n2: f32) -> f32 {
-    let r0 = pow((n1 - n2) / (n1 + n2), 2.0);
-    return r0 + (1.0 - r0) * pow(1.0 - cosTheta, 5.0);
-}
-`;
-
-export function reflectionWgsl(shadows: boolean): string {
-    const shadowCheck = shadows
-        ? `var hitShadow = 1.0;
-        if (hitNdotL > 0.0) {
-            var shadowRay: Ray;
-            shadowRay.origin = hit.worldPos + hit.normal * REFLECTION_EPSILON;
-            shadowRay.direction = hitL;
-            if (traceAnyHit(shadowRay, 1000.0)) { hitShadow = 0.0; }
-        }`
-        : "let hitShadow = 1.0;";
-
-    return /* wgsl */ `
-const REFLECTION_EPSILON: f32 = 0.001;
-const MIN_CONTRIBUTION: f32 = 0.02;
-
-fn traceReflections(
-    startPos: vec3<f32>,
-    startNormal: vec3<f32>,
-    startDir: vec3<f32>,
-    diffuseColor: vec3<f32>,
-    startBaseColor: vec3<f32>,
-    startRoughness: f32,
-    startMetallic: f32,
-    maxBounces: u32
-) -> vec3<f32> {
-    let V = -startDir;
-    let NdotV = max(dot(startNormal, V), 0.0);
-
-    let F0 = computeF0Vec(startBaseColor, startMetallic);
-    var F = schlickFresnel(NdotV, F0);
-
-    let smoothness = 1.0 - startRoughness;
-    let roughnessAtten = smoothness * smoothness;
-    F *= roughnessAtten;
-
-    let avgF = (F.x + F.y + F.z) / 3.0;
-    if (avgF < MIN_CONTRIBUTION) {
-        return diffuseColor;
-    }
-
-    var currentPos = startPos;
-    var currentNormal = startNormal;
-    var currentDir = startDir;
-    var reflectionColor = vec3(0.0);
-    var throughput = F;
-
-    for (var bounce = 0u; bounce < maxBounces; bounce++) {
-        let avgThroughput = (throughput.x + throughput.y + throughput.z) / 3.0;
-        if (avgThroughput < MIN_CONTRIBUTION) {
-            break;
-        }
-
-        let reflectDir = reflect(currentDir, currentNormal);
-        var reflectRay: Ray;
-        reflectRay.origin = currentPos + currentNormal * REFLECTION_EPSILON;
-        reflectRay.direction = reflectDir;
-
-        var reflectColor = vec3(0.0);
-        var reflectRemaining = 1.0;
-        var opaqueHit: HitResult;
-        var foundOpaque = false;
-
-        for (var t = 0u; t < 2u; t++) {
-            let hit = trace(reflectRay);
-            if (!hit.hit) {
-                reflectColor += sampleSky(reflectDir) * reflectRemaining;
-                break;
-            }
-
-            let eid = hit.entityId;
-            let hitData = getData(eid);
-            let hitOpacity = hitData.baseColor.a;
-            let hitBaseColor = hitData.baseColor.rgb;
-            let hitRoughness = hitData.pbr.x;
-            let hitMetallic = hitData.pbr.y;
-            let hitEmission = hitData.emission.rgb * hitData.emission.a;
-
-            let hitV = -reflectDir;
-            let hitL = -scene.sunDirection.xyz;
-            let hitNdotL = max(dot(hit.normal, hitL), 0.0);
-            let hitNdotV = max(dot(hit.normal, hitV), 0.0);
-${shadowCheck}
-
-            let hitF0 = computeF0Vec(hitBaseColor, hitMetallic);
-            let hitF = schlickFresnel(hitNdotV, hitF0);
-            let hitiffuseWeight = (1.0 - hitMetallic) * (vec3(1.0) - hitF);
-            let hitAmbient = scene.ambientColor.rgb * scene.ambientColor.a;
-            let hitSun = scene.sunColor.rgb * hitNdotL * hitShadow;
-            let hitiffuse = hitBaseColor * (hitAmbient + hitSun) * hitiffuseWeight;
-            let hitSpec = blinnPhongSpecular(hit.normal, hitL, hitV, hitRoughness);
-            let hitSpecular = scene.sunColor.rgb * hitSpec * hitF * hitNdotL * hitShadow;
-            let hitLit = hitiffuse + hitSpecular + hitEmission;
-
-            reflectColor += applyHaze(hitLit, hit.t) * hitOpacity * reflectRemaining;
-
-            if (hitOpacity >= 1.0) {
-                opaqueHit = hit;
-                foundOpaque = true;
-                break;
-            }
-
-            reflectRemaining *= (1.0 - hitOpacity);
-            if (reflectRemaining < 0.02) { break; }
-            reflectRay.origin = hit.worldPos + reflectDir * REFLECTION_EPSILON;
-        }
-
-        reflectionColor += throughput * reflectColor;
-
-        if (!foundOpaque) { break; }
-
-        let opaqueEid = opaqueHit.entityId;
-        let opaque = getData(opaqueEid);
-        let hitSmoothness = 1.0 - opaque.pbr.x;
-        let hitRoughnessAtten = hitSmoothness * hitSmoothness;
-        let opaqueF0 = computeF0Vec(opaque.baseColor.rgb, opaque.pbr.y);
-        let opaqueNdotV = max(dot(opaqueHit.normal, -reflectDir), 0.0);
-        let opaqueF = schlickFresnel(opaqueNdotV, opaqueF0);
-        throughput *= opaqueF * hitRoughnessAtten;
-        currentPos = opaqueHit.worldPos;
-        currentNormal = opaqueHit.normal;
-        currentDir = reflectDir;
-    }
-
-    return diffuseColor * (vec3(1.0) - F) + reflectionColor;
-}
-`;
-}
-
-export const WGSL_LIGHTING_CALC = /* wgsl */ `
-let NdotL = max(dot(surface.normal, -scene.sunDirection.xyz), 0.0);
-let ambient = scene.ambientColor.rgb * scene.ambientColor.a;
-let sunDiffuse = scene.sunColor.rgb * NdotL;
-let diffuseWeight = 1.0 - surface.metallic;
-let lighting = (ambient + sunDiffuse) * diffuseWeight;
-`;
-
-export const SHADOW_WGSL = /* wgsl */ `
-const GOLDEN_ANGLE: f32 = 2.39996323;
-const SHADOW_TRANSPARENCY_EPSILON: f32 = 0.001;
-const MAX_SHADOW_TRANSPARENT_DEPTH: u32 = 2u;
-
-fn buildTangentBasis(dir: vec3<f32>) -> mat3x3<f32> {
-    let up = select(vec3(0.0, 1.0, 0.0), vec3(1.0, 0.0, 0.0), abs(dir.y) > 0.99);
-    let tangent = normalize(cross(dir, up));
-    let bitangent = cross(dir, tangent);
-    return mat3x3(tangent, bitangent, dir);
-}
-
-fn traceShadowWithTransparency(origin: vec3<f32>, sunDir: vec3<f32>, tMax: f32) -> f32 {
-    var shadowFactor = 1.0;
-    var currentPos = origin;
-
-    for (var i = 0u; i < MAX_SHADOW_TRANSPARENT_DEPTH; i++) {
-        var shadowRay: Ray;
-        shadowRay.origin = currentPos;
-        shadowRay.direction = sunDir;
-
-        let hit = trace(shadowRay);
-        if (!hit.hit || hit.t > tMax) {
-            break;
-        }
-
-        let shadow = getData(hit.entityId);
-        let opacity = shadow.baseColor.a;
-        shadowFactor *= (1.0 - opacity);
-
-        if (opacity >= 1.0 || shadowFactor < 0.02) {
-            break;
-        }
-
-        currentPos = hit.worldPos + sunDir * SHADOW_TRANSPARENCY_EPSILON;
-    }
-
-    return shadowFactor;
-}
-
-fn sampleSoftShadow(origin: vec3<f32>, sunDir: vec3<f32>, softness: f32, samples: u32) -> f32 {
-    if (samples == 0u) {
-        return 1.0;
-    }
-    if (samples == 1u || softness <= 0.0) {
-        return traceShadowWithTransparency(origin, sunDir, 1000.0);
-    }
-
-    let basis = buildTangentBasis(sunDir);
-    var totalShadow = 0.0;
-
-    let noise = fract(sin(dot(origin.xy, vec2(12.9898, 78.233))) * 43758.5453);
-    let rotationOffset = noise * 6.28318530718;
-
-    for (var i = 0u; i < samples; i++) {
-        let angle = f32(i) * GOLDEN_ANGLE + rotationOffset;
-        let z = (f32(i) + 0.5) / f32(samples);
-        let r = sqrt(1.0 - z * z) * softness * 0.1;
-
-        let localOffset = vec3(cos(angle) * r, sin(angle) * r, 0.0);
-        let sampleDir = normalize(sunDir + basis * localOffset);
-
-        totalShadow += traceShadowWithTransparency(origin, sampleDir, 1000.0);
-    }
-
-    return totalShadow / f32(samples);
-}
-`;
-
-export function compileApplyLighting(
-    lit?: boolean,
-    shadows?: boolean,
-    reflections?: boolean
-): string {
-    if (lit === false) {
-        return "return surface.baseColor;";
-    }
-
-    if (shadows && reflections) {
-        return `
-    let V = -rayDir;
-    let L = -scene.sunDirection.xyz;
-    let NdotL = max(dot(surface.normal, L), 0.0);
-    let NdotV = max(dot(surface.normal, V), 0.0);
-
-    var shadowFactor = 1.0;
-    if (NdotL > 0.0) {
-        let shadowOrigin = surface.worldPos + surface.normal * 0.001;
-        shadowFactor = sampleSoftShadow(shadowOrigin, L, scene.shadowSoftness, scene.shadowSamples);
-    }
-
-    let F0 = computeF0Vec(surface.baseColor, surface.metallic);
-    let F = schlickFresnel(NdotV, F0);
-
-    let ambient = scene.ambientColor.rgb * scene.ambientColor.a;
-    let sunDiffuse = scene.sunColor.rgb * NdotL * shadowFactor;
-    let diffuseWeight = 1.0 - surface.metallic;
-    let diffuseColor = surface.baseColor * (ambient + sunDiffuse) * diffuseWeight + surface.emission;
-
-    let specTerm = blinnPhongSpecular(surface.normal, L, V, surface.roughness);
-    let specular = scene.sunColor.rgb * specTerm * F * NdotL * shadowFactor;
-
-    var finalColor = diffuseColor * (vec3(1.0) - F) + specular;
-
-    if (scene.reflectionDepth > 0u) {
-        finalColor = traceReflections(
-            surface.worldPos, surface.normal, rayDir,
-            diffuseColor + specular, surface.baseColor,
-            surface.roughness, surface.metallic,
-            scene.reflectionDepth
-        );
-    }
-    return finalColor;`;
-    }
-
-    if (shadows) {
-        return `
-    let NdotL = max(dot(surface.normal, -scene.sunDirection.xyz), 0.0);
-    let ambient = scene.ambientColor.rgb * scene.ambientColor.a;
-
-    var shadowFactor = 1.0;
-    if (NdotL > 0.0) {
-        let shadowOrigin = surface.worldPos + surface.normal * 0.001;
-        shadowFactor = sampleSoftShadow(
-            shadowOrigin, -scene.sunDirection.xyz,
-            scene.shadowSoftness, scene.shadowSamples
-        );
-    }
-
-    let sunDiffuse = scene.sunColor.rgb * NdotL * shadowFactor;
-    let diffuseWeight = 1.0 - surface.metallic;
-    let lighting = (ambient + sunDiffuse) * diffuseWeight;
-    return surface.baseColor * lighting + surface.emission;`;
-    }
-
-    if (reflections) {
-        return `
-    let V = -rayDir;
-    let L = -scene.sunDirection.xyz;
-    let NdotL = max(dot(surface.normal, L), 0.0);
-    let NdotV = max(dot(surface.normal, V), 0.0);
-
-    let F0 = computeF0Vec(surface.baseColor, surface.metallic);
-    let F = schlickFresnel(NdotV, F0);
-
-    let ambient = scene.ambientColor.rgb * scene.ambientColor.a;
-    let sunDiffuse = scene.sunColor.rgb * NdotL;
-    let diffuseWeight = 1.0 - surface.metallic;
-    let diffuseColor = surface.baseColor * (ambient + sunDiffuse) * diffuseWeight + surface.emission;
-
-    let specTerm = blinnPhongSpecular(surface.normal, L, V, surface.roughness);
-    let specular = scene.sunColor.rgb * specTerm * F * NdotL;
-
-    var finalColor = diffuseColor * (vec3(1.0) - F) + specular;
-
-    if (scene.reflectionDepth > 0u) {
-        finalColor = traceReflections(
-            surface.worldPos, surface.normal, rayDir,
-            diffuseColor + specular, surface.baseColor,
-            surface.roughness, surface.metallic,
-            scene.reflectionDepth
-        );
-    }
-    return finalColor;`;
-    }
-
-    return `${WGSL_LIGHTING_CALC}
-    return surface.baseColor * lighting + surface.emission;`;
-}