@multiplekex/shallot 0.1.12 → 0.2.0

package/src/standard/render/shaders.ts

@@ -0,0 +1,484 @@
+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]);
+}

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

@@ -1,12 +1,9 @@
 import { WGSL_STRUCTS } from "./structs";
 import type { SurfaceData } from "./index";
+import { compileVertexBody, WGSL_LIGHTING_CALC } from "./wgsl";
 
 export function compileSurface(data: SurfaceData): string {
-    const vertexTransform = data.vertex
-        ? `var pos = worldPos;
-    ${data.vertex}
-    return pos;`
-        : "return worldPos;";
+    const vertexTransform = compileVertexBody(data.vertex);
 
     const fragmentBody = data.fragment ?? "";
 
@@ -60,11 +57,7 @@ fn fs(input: VertexOutput) -> FragmentOutput {
 ${
     data.lit === false
         ? `    output.color = vec4<f32>(surface.baseColor, input.color.a);`
-        : `    let NdotL = max(dot(surface.normal, -scene.sunDirection.xyz), 0.0);
-    let ambient = scene.ambientColor.rgb * scene.ambientColor.a;
-    let diffuse = scene.sunColor.rgb * NdotL;
-    let diffuseFactor = 1.0 - surface.metallic * 0.9;
-    let lighting = ambient + diffuse * diffuseFactor;
+        : `    ${WGSL_LIGHTING_CALC}
     output.color = vec4<f32>(surface.baseColor * lighting + surface.emission, input.color.a);`
 }
     output.entityId = input.entityId;

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

@@ -11,31 +11,35 @@ interface ComposedSurface extends SurfaceData {
     composed: number[];
 }
 
-const surfaces: (SurfaceData | ComposedSurface)[] = [];
+export interface SurfaceRegistry {
+    surfaces: (SurfaceData | ComposedSurface)[];
+}
+
+export function createSurfaceRegistry(): SurfaceRegistry {
+    const registry: SurfaceRegistry = { surfaces: [] };
+    initBuiltIns(registry);
+    return registry;
+}
 
-function initBuiltIns(): void {
-    if (surfaces.length === 0) {
-        surfaces.push({ lit: true });
+function initBuiltIns(registry: SurfaceRegistry): void {
+    registry.surfaces.push({ lit: true });
 
-        surfaces.push({
-            lit: false,
-            fragment: `(*surface).baseColor = (*surface).normal * 0.5 + 0.5;`,
-        });
+    registry.surfaces.push({
+        lit: false,
+        fragment: `(*surface).baseColor = (*surface).normal * 0.5 + 0.5;`,
+    });
 
-        surfaces.push({
-            lit: false,
-            fragment: `
+    registry.surfaces.push({
+        lit: false,
+        fragment: `
     let depth = position.z;
     let remapped = pow(1.0 - depth, 0.1);
     (*surface).baseColor = vec3(remapped);`,
-        });
+    });
 
-        surfaces.push({ lit: false });
-    }
+    registry.surfaces.push({ lit: false });
 }
 
-initBuiltIns();
-
 export const SurfaceType = {
     Default: 0,
     Normals: 1,
@@ -43,23 +47,27 @@ export const SurfaceType = {
     Albedo: 3,
 } as const;
 
-export function surface(data: SurfaceData): number {
-    const id = surfaces.length;
-    surfaces.push(data);
+export function registerSurface(registry: SurfaceRegistry, data: SurfaceData): number {
+    const id = registry.surfaces.length;
+    registry.surfaces.push(data);
     return id;
 }
 
-export function getSurface(id: number): SurfaceData | undefined {
-    return surfaces[id];
+export function getSurface(registry: SurfaceRegistry, id: number): SurfaceData | undefined {
+    return registry.surfaces[id];
 }
 
-export function clearSurfaces(): void {
-    surfaces.length = 0;
-    initBuiltIns();
+export function getAllSurfaces(registry: SurfaceRegistry): SurfaceData[] {
+    return [...registry.surfaces];
 }
 
-export function compose(...ids: number[]): number {
-    const validIds = ids.filter((id) => id > 0 && id < surfaces.length);
+export function clearSurfaces(registry: SurfaceRegistry): void {
+    registry.surfaces.length = 0;
+    initBuiltIns(registry);
+}
+
+export function composeSurfaces(registry: SurfaceRegistry, ...ids: number[]): number {
+    const validIds = ids.filter((id) => id > 0 && id < registry.surfaces.length);
     if (validIds.length === 0) return SurfaceType.Default;
     if (validIds.length === 1) return validIds[0];
 
@@ -68,14 +76,14 @@ export function compose(...ids: number[]): number {
     let lit = true;
 
     for (const id of validIds) {
-        const s = surfaces[id];
+        const s = registry.surfaces[id];
         if (!s) continue;
 
         if (s.lit === false) lit = false;
 
         if ("composed" in s) {
             for (const composedId of s.composed) {
-                const inner = surfaces[composedId];
+                const inner = registry.surfaces[composedId];
                 if (inner?.vertex) vertexParts.push(inner.vertex);
                 if (inner?.fragment) fragmentParts.push(inner.fragment);
             }
@@ -92,11 +100,33 @@ export function compose(...ids: number[]): number {
         composed: validIds,
     };
 
-    const id = surfaces.length;
-    surfaces.push(composedData);
+    const id = registry.surfaces.length;
+    registry.surfaces.push(composedData);
     return id;
 }
 
+const defaultRegistry = createSurfaceRegistry();
+
+export function surface(data: SurfaceData): number {
+    return registerSurface(defaultRegistry, data);
+}
+
+export function getDefaultSurface(id: number): SurfaceData | undefined {
+    return getSurface(defaultRegistry, id);
+}
+
+export function getDefaultAllSurfaces(): SurfaceData[] {
+    return getAllSurfaces(defaultRegistry);
+}
+
+export function clearDefaultSurfaces(): void {
+    clearSurfaces(defaultRegistry);
+}
+
+export function compose(...ids: number[]): number {
+    return composeSurfaces(defaultRegistry, ...ids);
+}
+
 export const SurfaceIds = {
     data: new Uint32Array(MAX_ENTITIES),
 };

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

@@ -0,0 +1,45 @@
+export const NOISE_WGSL = /* wgsl */ `
+fn hash2(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 simplex2(p: vec2<f32>) -> f32 {
+    let K1 = 0.366025404;
+    let K2 = 0.211324865;
+
+    let i = floor(p + (p.x + p.y) * K1);
+    let a = p - i + (i.x + i.y) * K2;
+
+    let o = select(vec2(0.0, 1.0), vec2(1.0, 0.0), a.x > a.y);
+    let b = a - o + K2;
+    let c = a - 1.0 + 2.0 * K2;
+
+    let h = max(0.5 - vec3(dot(a, a), dot(b, b), dot(c, c)), vec3(0.0));
+    let h4 = h * h * h * h;
+
+    let n = vec3(
+        dot(a, vec2(hash2(i) * 2.0 - 1.0, hash2(i + vec2(0.0, 1.0)) * 2.0 - 1.0)),
+        dot(b, vec2(hash2(i + o) * 2.0 - 1.0, hash2(i + o + vec2(0.0, 1.0)) * 2.0 - 1.0)),
+        dot(c, vec2(hash2(i + 1.0) * 2.0 - 1.0, hash2(i + vec2(1.0, 2.0)) * 2.0 - 1.0))
+    );
+
+    return dot(h4, n) * 70.0;
+}
+
+fn fbm2(p: vec2<f32>, octaves: i32) -> f32 {
+    var value = 0.0;
+    var amplitude = 0.5;
+    var frequency = 1.0;
+    var pos = p;
+
+    for (var i = 0; i < octaves; i++) {
+        value += amplitude * simplex2(pos * frequency);
+        amplitude *= 0.5;
+        frequency *= 2.0;
+    }
+
+    return value;
+}
+`;