@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/renderer/geometry/bvh/shader_blas_refit_batch_seed.js

@@ -1,75 +0,0 @@
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { BVH_NODE_LAYOUT_DEFINITION } from "../../gpu_primitive/bvh/BVH_NODE_LAYOUT_DEFINITION.js";
-import { BVH_REFIT_DEFERRED_DEFINITION } from "../../gpu_primitive/bvh/BVH_REFIT_DEFERRED_DEFINITION.js";
-import { BLAS_REFIT_TARGET_STRUCT } from "./BLAS_REFIT_TARGET_STRUCT.js";
-import { BLAS_REFIT_BATCH_WORKGROUP_SIZE } from "./shader_blas_refit_batch.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-// see shader_blas_refit_batch: workgroups covered by earlier pages of the same batch
-resources.setImmediate("dispatch_offset", u32);
-
-resources.createGroup()
-    .addStorageBuffer("targets", WebGPUArray.from(BLAS_REFIT_TARGET_STRUCT), false)
-    // `(target_index, slot_base)` per workgroup, flat: runs of node slots rather than of leaves
-    .addStorageBuffer("lookup", WebGPUArray.from(u32), false)
-    .addStorageBuffer("nodes", WebGPUArray.from(u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${BLAS_REFIT_BATCH_WORKGROUP_SIZE}, 1, 1)
-fn main(
-    @builtin(workgroup_id) wg: vec3<u32>,
-    @builtin(local_invocation_id) lid: vec3<u32>,
-) {
-    let pair = (wg.x + dispatch_offset) * 2u;
-
-    // ("target" is a reserved word in WGSL)
-    let tree = targets[lookup[pair]];
-
-    let slot = lookup[pair + 1u] + lid.x;
-
-    if (slot >= tree.node_count) {
-        // the tail of a tree's last run; the next workgroup is another tree's
-        return;
-    }
-
-    let bounds_word = tree.node_word_offset + slot * BVH_NODE_STRIDE + BVH_NODE_BOUNDS;
-
-    for (var w = 0u; w < 6u; w += 1u) {
-        nodes[bounds_word + w] = BVH_UNFITTED;
-    }
-}
-`, [
-    BVH_NODE_LAYOUT_DEFINITION,
-    BVH_REFIT_DEFERRED_DEFINITION,
-]);
-
-/**
- * Seed every bound word of every tree in a batch with {@link BVH_UNFITTED}, a dispatch ahead of
- * {@link shader_blas_refit_batch}.
- *
- * The batch refit hands boxes between invocations through relaxed atomics — leaf boxes included,
- * since it writes them in the same dispatch — and a store need not reach the reader before the
- * dispatch ends. What this leaves behind is what such a read returns, so the climb can see a box
- * that has not arrived instead of taking last frame's for it. For a skinned mesh last frame's box
- * is close to this frame's, so taking it would go unnoticed.
- *
- * One lane per node slot, holes included: the arena's trees keep the slots their builder allocated,
- * and seeding a hole costs six stores where telling it apart would cost a walk. The bounds words are
- * all it touches; children and payloads are the tree's topology and stay as they are.
- *
- * Recorded by {@link GPUBLASRefitBatch}, paginated as the refit is.
- *
- * @type {ComputeShader}
- */
-export const shader_blas_refit_batch_seed = ComputeShader.from({
-    label: "BLAS/RefitBatchSeed",
-    resources,
-    body,
-});

package/src/shade/renderer/geometry/meshlet_batch_to_bvh.d.ts

@@ -1,17 +0,0 @@
-/**
- *
- * @param {Object} options
- * @param {BVH} options.bvh
- * @param {MeshletBatch} options.meshlets
- * @param {Float32Array} options.bounding_box
- * @param {number} options.primitive_count
- * @param {number} [options.optimization]
- */
-export function meshlet_batch_to_bvh({ bvh, meshlets, bounding_box, primitive_count, optimization }: {
-    bvh: BVH;
-    meshlets: MeshletBatch;
-    bounding_box: Float32Array;
-    primitive_count: number;
-    optimization?: number;
-}): void;
-//# sourceMappingURL=meshlet_batch_to_bvh.d.ts.map

package/src/shade/renderer/geometry/meshlet_batch_to_bvh.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"meshlet_batch_to_bvh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/meshlet_batch_to_bvh.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH;IANwB,GAAG;IACM,QAAQ;IACR,YAAY,EAAlC,YAAY;IACI,eAAe,EAA/B,MAAM;IACW,YAAY,GAA7B,MAAM;SAqOhB"}

package/src/shade/renderer/geometry/meshlet_batch_to_bvh.js

@@ -1,247 +0,0 @@
-import { assert } from "../../../core/assert.js";
-import { NULL_NODE } from "../../../core/bvh2/bvh3/BVH.js";
-import { ebvh_optimize_treelet } from "../../../core/bvh2/bvh3/ebvh_optimize_treelet.js";
-import { v3_morton_encode_bounded } from "../../../core/geom/3d/morton/v3_morton_encode_bounded.js";
-import {
-    aabb3_compute_from_triangle
-} from "../../../core/geom/3d/triangle/aabb3_compute_from_triangle.js";
-import { max2 } from "../../../core/math/max2.js";
-import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "./meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
-
-/**
- *
- * @param {Object} options
- * @param {BVH} options.bvh
- * @param {MeshletBatch} options.meshlets
- * @param {Float32Array} options.bounding_box
- * @param {number} options.primitive_count
- * @param {number} [options.optimization]
- */
-export function meshlet_batch_to_bvh({
-                                         bvh,
-                                         meshlets,
-                                         bounding_box,
-                                         primitive_count,
-                                         optimization = 1
-                                     }) {
-
-    assert.defined(bvh, 'bvh');
-    assert.defined(meshlets, 'meshlets');
-    assert.defined(bounding_box, 'bounding_box');
-    assert.isNonNegativeInteger(primitive_count, 'primitive_count');
-
-    const meshlet_count = meshlets.count;
-
-    bvh.release_all();
-
-    if (meshlet_count === 0) {
-        bvh.root = NULL_NODE;
-        bvh.trim();
-        return;
-    }
-
-    // order meshlet indices by morton codes and count actual triangles in the batch
-    const meshlet_morton_codes = new Uint32Array(meshlet_count);
-    let node_leaf_count = 0;
-
-    for (let i = 0; i < meshlet_count; i++) {
-
-        const header = meshlets.read_header(i);
-
-        node_leaf_count += header.primitive_count;
-
-        const bb = header.bounds_box;
-
-        const center_x = (bb[0] + bb[3]) * 0.5;
-        const center_y = (bb[1] + bb[4]) * 0.5;
-        const center_z = (bb[2] + bb[5]) * 0.5;
-
-        meshlet_morton_codes[i] = v3_morton_encode_bounded(
-            center_x, center_y, center_z,
-            bounding_box,
-        );
-    }
-
-    if (node_leaf_count === 0) {
-        bvh.root = NULL_NODE;
-        bvh.trim();
-        return;
-    }
-
-    const node_bin_count = max2(0, node_leaf_count - 1);
-
-    const node_total_count = node_leaf_count + node_bin_count;
-
-    bvh.allocate_linear(node_total_count);
-
-    const partial_tree_nodes = new Uint32Array(meshlet_count);
-
-    // how many nodes do we need for meshlet subtree assembly?
-    const meshlet_node_leaf_count = meshlet_count;
-    const meshlet_node_bin_count = max2(0, meshlet_node_leaf_count - 1);
-
-    {
-        // we want to use the beginning of the memory space for the meshlet tree
-        // the root of the tree must be node 0 (convention)
-
-        // note that we include bottom tree roots here
-        const bottom_tree_node_count = node_total_count - meshlet_node_bin_count;
-        const bottom_tree_node_pool = new Uint32Array(bottom_tree_node_count);
-        let bottom_tree_node_cursor = 0;
-        const bottom_tree_node_scratch = new Uint32Array(GEOMETRY_MESHLET_TRIANGLE_LIMIT);
-
-        // fill nodes
-        for (let i = 0; i < bottom_tree_node_count; i++) {
-            const node = (node_total_count - 1) - i;
-            bottom_tree_node_pool[i] = node;
-        }
-
-        const sorted_indices = new Uint32Array(meshlet_count);
-        for (let i = 0; i < meshlet_count; i++) {
-            sorted_indices[i] = i;
-        }
-
-        sorted_indices.sort((a, b) => meshlet_morton_codes[a] - meshlet_morton_codes[b]);
-
-        const triangle_aabb = new Float32Array(6);
-
-        for (let i = 0; i < meshlet_count; i++) {
-            const meshlet_index = sorted_indices[i];
-
-            const meshlet = meshlets.read_meshlet(meshlet_index);
-
-            const meshlet_header = meshlet.header;
-
-            // NOTE: indices and vertices are per-meshlet, there are no global attributes
-            const meshlet_indices = meshlet.attribute_index;
-            const meshlet_positions = meshlet.attribute_position;
-
-            const meshlet_triangle_count = meshlet_header.primitive_count;
-
-            assert.greaterThan(meshlet_triangle_count, 0, 'meshlet_triangle_count');
-
-            for (let triangle_index = 0; triangle_index < meshlet_triangle_count; triangle_index++) {
-
-                const index3 = triangle_index * 3;
-
-                const i0 = meshlet_indices[index3 + 0];
-                const i1 = meshlet_indices[index3 + 1];
-                const i2 = meshlet_indices[index3 + 2];
-
-                aabb3_compute_from_triangle(
-                    triangle_aabb, 0,
-                    meshlet_positions,
-                    i0, i1, i2
-                );
-
-                // NOTE: we already limit the number of triangles per meshlet to 256, so this is safe.
-                const encoded_triangle_id = ((meshlet_index & 0x00FFFFFF) << 8)
-                    | (triangle_index & 0xFF);
-
-                const node = bottom_tree_node_pool[bottom_tree_node_cursor++];
-
-                bvh.node_set_aabb(node, triangle_aabb);
-                bvh.node_set_user_data(node, encoded_triangle_id)
-                bvh.node_set_child1(node, NULL_NODE); // mark as leaf node
-
-                bottom_tree_node_scratch[triangle_index] = node;
-            }
-
-            // assemble meshlet tree
-            let unprocessed_node_count = meshlet_triangle_count;
-
-            while (unprocessed_node_count > 1) {
-
-                let added_nodes = 0;
-                let cursor = 0;
-
-                while (cursor + 1 < unprocessed_node_count) {
-                    const child_2 = bottom_tree_node_scratch[cursor++];
-                    const child_1 = bottom_tree_node_scratch[cursor++];
-
-                    const parent = bottom_tree_node_pool[bottom_tree_node_cursor++];
-
-                    bvh.node_assign_children(parent, child_1, child_2);
-
-                    bottom_tree_node_scratch[added_nodes++] = parent;
-                }
-
-                while (cursor < unprocessed_node_count) {
-                    // dangling nodes, push them onto the next level
-                    bottom_tree_node_scratch[added_nodes++] = bottom_tree_node_scratch[cursor++];
-                }
-
-                unprocessed_node_count = added_nodes;
-
-            }
-
-            // the first node is now the root
-            partial_tree_nodes[i] = bottom_tree_node_scratch[0];
-        }
-
-        assert.equal(bottom_tree_node_cursor, bottom_tree_node_count, 'bottom_tree_node_cursor !== bottom_tree_node_count');
-    }
-
-    // ===========
-    // Second phase - assemble meshlet trees into the final structure
-    // ===========
-    {
-        // assemble meshlet tree
-        let unprocessed_node_count = meshlet_count;
-        let top_tree_node_cursor = 0;
-        const top_tree_node_count = meshlet_node_bin_count;
-        const top_tree_node_pool = new Uint32Array(top_tree_node_count);
-
-        // fill nodes
-        for (let i = 0; i < top_tree_node_count; i++) {
-            const node = (top_tree_node_count - 1) - i;
-            top_tree_node_pool[i] = node;
-        }
-
-        while (unprocessed_node_count > 1) {
-
-            let added_nodes = 0;
-            let cursor = 0;
-
-            while (cursor + 1 < unprocessed_node_count) {
-                const child_2 = partial_tree_nodes[cursor++];
-                const child_1 = partial_tree_nodes[cursor++];
-
-                const parent = top_tree_node_pool[top_tree_node_cursor++];
-
-                bvh.node_assign_children(parent, child_1, child_2);
-
-                partial_tree_nodes[added_nodes++] = parent;
-            }
-
-            while (cursor < unprocessed_node_count) {
-                // dangling nodes, push them onto the next level
-                partial_tree_nodes[added_nodes++] = partial_tree_nodes[cursor++];
-            }
-
-            unprocessed_node_count = added_nodes;
-
-        }
-
-        assert.equal(top_tree_node_cursor, top_tree_node_count, 'top_tree_node_cursor !== top_tree_node_count');
-
-        const root = partial_tree_nodes[0];
-
-        assert.equal(root, 0, 'root must be node 0');
-
-        bvh.node_set_parent(root, NULL_NODE);
-        bvh.root = root;
-    }
-
-
-    // The BVH we built so far is good, but not optimal
-    // Optimize BVH for better traversal performance
-
-    for (let i = 0; i < optimization; i++) {
-        ebvh_optimize_treelet(bvh);
-    }
-
-    assert.equal(bvh.root, 0, 'root must be node 0');
-
-    bvh.trim();
-}

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_ray_query_blas_occlusion.d.ts

@@ -1,7 +0,0 @@
-/**
- * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH8.h#L277
- * @type {CodeChunk}
- */
-export const chunk_bvh8_ray_query_blas_occlusion: CodeChunk;
-import { CodeChunk } from "../../../../compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_bvh8_ray_query_blas_occlusion.d.ts.map

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_ray_query_blas_occlusion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_bvh8_ray_query_blas_occlusion.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_ray_query_blas_occlusion.js"],"names":[],"mappings":"AAoGA;;;GAGG;AACH,kDAFU,SAAS,CA2HjB;0BAjOwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/bvh/bvh8/webgpu/chunk_bvh8_ray_query_blas_occlusion.js

@@ -1,226 +0,0 @@
-import { CodeChunk } from "../../../../compiler/CodeChunk.js";
-import { chunk_extract_byte } from "../../../binary/chunk_extract_byte.js";
-import { chunk_first_bit_high } from "../../../binary/chunk_first_bit_high.js";
-import {
-    chunk_geometry_read_triangle_vertices
-} from "../../../geometry/format/chunk_geometry_read_triangle_vertices.js";
-import { chunk_ray_intersects_sphere } from "../../../geometry/ray/chunk_ray_intersects_sphere.js";
-import { chunk_ray_triangle_intersect } from "../../../geometry/ray/chunk_ray_triangle_intersect.js";
-import { RAY_STRUCT } from "../../../geometry/ray/RAY_STRUCT.js";
-import { BVH8_INODE_STRUCT } from "./BVH8_INODE_STRUCT.js";
-import { chunk_bvh8_node_intersect } from "./chunk_bvh8_node_intersect.js";
-import { chunk_ray_get_octant_inv4 } from "./chunk_ray_get_octant_inv4.js";
-
-const BVH_STACK_SIZE = 32;
-/**
- * Portion of the Stack that resides in Shared Memory
- * Original paper "Efficient Incoherent Ray Traversal on GPUs Through Compressed Wide BVHs" recommends 12 to be the sweet spot, with 8 being close second
- * The effect of shared stack becomes more pronounced for larger bounce counts
- * @type {number}
- */
-const SHARED_STACK_SIZE = 8;
-
-const LOCAL_STACK_SIZE = (BVH_STACK_SIZE - SHARED_STACK_SIZE);
-
-/**
- * On shared memory:
- *   - it seems to be allocated separately, so it's a "use it or lose it" case. Although recent NVIDIA articles suggest otherwise
- *   - According to original paper, using shared stack improved memory access patterns, see "Efficient Incoherent Ray Traversal on GPUs Through Compressed Wide BVHs" Appendix A.3 table 9
- * @type {CodeChunk}
- */
-const chunk_bvh8_query_context = CodeChunk.from(
-    //language=WGSL
-    `
-var<private> thread_idx : i32;
-    `
-);
-
-const chunk_bvh8_initialize_context = CodeChunk.from(
-    //language=WGSL
-    `
-fn bvh8_initialize_context(invocation: vec3<u32>){
-    thread_idx = invocation.x;
-}
-    `, [
-        chunk_bvh8_query_context
-    ]
-);
-
-/**
- * TODO consider transposing the layout, might result in better performance
- * @see https://github.com/fynv/webpbf/blob/430c5832bd2199b8fe7e3c1a2d430392b1b991f5/client/raycast_depth.js#L177
- * @type {CodeChunk}
- */
-const chunk_bvh8_compute_shared_stack_index = CodeChunk.from(
-    //language=WGSL
-    `
-fn bvh8_compute_shared_stack_index(offset: i32) -> i32 {
-    return thread_idx * ${SHARED_STACK_SIZE} + offset;
-}
-    `
-);
-
-/**
- * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH.h#L25
- * @type {CodeChunk}
- */
-const chunk_bvh8_stack_push = CodeChunk.from(
-//language=WGSL
-    `
-fn bvh8_stack_push(local_stack:ptr<function,array<vec2u,${LOCAL_STACK_SIZE}>>, stack_size: ptr<function,i32>, item: vec2u) {
-
-        local_stack[*stack_size] = item;
-                
-    *stack_size++;
-}
-    `, [
-        chunk_bvh8_query_context,
-        chunk_bvh8_compute_shared_stack_index,
-    ]
-);
-/**
- * https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH.h#L38
- * @type {CodeChunk}
- */
-const chunk_bvh8_stack_pop = CodeChunk.from(
-//language=WGSL
-    `
-fn bvh8_stack_pop(local_stack:ptr<function,array<vec2u,${LOCAL_STACK_SIZE}>>, stack_size: ptr<function,i32> ) -> vec2u{
-
-    *stack_size--;
-    
-        return local_stack[*stack_size];
-                
-}
-    `, [
-        chunk_bvh8_query_context,
-        chunk_bvh8_compute_shared_stack_index,
-    ]
-);
-
-/**
- * @see https://github.com/jan-van-bergen/GPU-Raytracer/blob/6559ae2241c8fdea0ddaec959fe1a47ec9b3ab0d/Src/CUDA/Raytracing/BVH8.h#L277
- * @type {CodeChunk}
- */
-export const chunk_bvh8_ray_query_blas_occlusion = CodeChunk.from(
-    //language=WGSL
-    `
-fn bvh8_ray_query_blas_occlusion(
-    ray: ${RAY_STRUCT.wgsl_ref},
-    geometry_index: u32, 
-) -> bool {
-
-    let geometry = geometries[geometry_index];
-    
-    let bounding_sphere = geometry.bounding_sphere;
-    
-    if(!ray_intersects_sphere(ray, bounding_sphere.xyz, bounding_sphere.w)){
-        // typically this lets us get misses much quicker
-        return false;
-    }
-        
-    let blas_address = blas_lookup[geometry_index];
-  
-    var stack: array<vec2u, ${LOCAL_STACK_SIZE}>;
-    var stack_size = 0;
-
-    let oct_inv4 = ray_get_octant_inv4(ray.direction);
-    
-    // initialize 'current group' with the BLAS root
-    // Root is always traversed, first hits bit set to 1 all the rest 0s
-    // Current group |child node base index  | hits     | pad     | imask  |
-    //               |       32 bits         | 8 bits   | 16 bits | 8 bits |
-    var current_group = vec2(0u, 0x80000000u);
-    
-    loop {
-        // Triangle group |triangle base index  | pad     | triangle hits |
-        //                |       32 bits       | 8 bits  | 24 bits       |
-        var triangle_group : vec2u;
-        
-        let hits_imask = current_group.y;
-        
-        // Get first node hit
-        let child_index_offset = first_bit_high(hits_imask);
-        let child_index_base = current_group.x;
-
-        // Remove node from current_group
-        current_group.y &= ~(1u << child_index_offset);
-
-        // If the node group is not yet empty, push it on the stack
-        if ( (current_group.y & 0xff000000u) != 0 ) {
-            stack[stack_size] = current_group;
-            stack_size++;
-        }
-        
-        // reversing the traversal priority computation
-        let slot_index = (child_index_offset - 24u) ^ (oct_inv4 & 0xffu);
-        
-        // Relative index of the node is obtained by computing the number of neighboring nodes
-        // stored in the lower child slots:
-        let relative_index = countOneBits(hits_imask & ~(0xffffffffu << slot_index));
-        let child_node_index = blas_address + child_index_base + relative_index;
-        
-        let node: ${BVH8_INODE_STRUCT.wgsl_ref} = blas_data[child_node_index];
-    
-        let hitmask = bvh8_node_intersect(ray, oct_inv4, node);
-
-        let imask = extract_byte( bitcast<u32>(node.data[0].w), 3);	
-
-        current_group.x = bitcast<u32>(node.data[1].x); // Child    base offset
-        triangle_group.x = bitcast<u32>(node.data[1].y); // Triangle base offset
-
-        current_group.y = (hitmask & 0xff000000u) | imask;
-        triangle_group.y = (hitmask & 0x00ffffffu);
-			
-		
-        // While the triangle group is not empty
-        // Intersect all triangles in the current node
-        while (triangle_group.y != 0u) {
-                
-            // Get next triangle index and remove it from the list
-			let triangle_index = first_bit_high(triangle_group.y);
-			triangle_group.y &= ~(1u << triangle_index);
-
-			let tri_idx = triangle_group.x + triangle_index;
-						
-            let triangle = geometry_read_triangle_vertices(geometry, tri_idx);
-            
-			let intersection = ray_triangle_intersect(ray,triangle);
-			
-			if (intersection) {				
-				return true;	
-			}
-			
-		}			
-
-		if ((current_group.y & 0xff000000u) == 0) {
-			if (stack_size == 0)  {
-			    // we didn't hit anything, stack is empty, bail
-                break;
-            }
-            
-            // get next element on the stack
-            stack_size--;
-		    current_group = stack[stack_size];
-		    
-		}
-    }
-    
-    // no hit
-    return false;
-}
-    `, [
-        BVH8_INODE_STRUCT.declaration_chunk,
-        RAY_STRUCT.declaration_chunk,
-        chunk_bvh8_stack_push,
-        chunk_bvh8_stack_pop,
-        chunk_bvh8_compute_shared_stack_index,
-        chunk_extract_byte,
-        chunk_ray_get_octant_inv4,
-        chunk_bvh8_node_intersect,
-        chunk_ray_triangle_intersect,
-        chunk_ray_intersects_sphere,
-        chunk_geometry_read_triangle_vertices,
-        chunk_first_bit_high,
-    ]
-);

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mask_visibility_via_rays.d.ts

@@ -1,8 +0,0 @@
-/**
- * Perform visibility checks for probes using Raytracing
- * see {@link chunk_lpv_sample_irradiance}
- * @type {CodeChunk}
- */
-export const chunk_lpv_mask_visibility_via_rays: CodeChunk;
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_lpv_mask_visibility_via_rays.d.ts.map

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mask_visibility_via_rays.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_lpv_mask_visibility_via_rays.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mask_visibility_via_rays.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,iDAFU,SAAS,CAmCb;0BA5CoB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mask_visibility_via_rays.js

@@ -1,45 +0,0 @@
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_offset_ray } from "../../geometry/ray/chunk_offset_ray.js";
-import { chunk_ray_query_occluded } from "../../geometry/ray/chunk_ray_query_occluded.js";
-import { RAY_STRUCT } from "../../geometry/ray/RAY_STRUCT.js";
-import { chunk_f32_array_as_vec3 } from "../../geometry/vec3/chunk_f32_array_as_vec3.js";
-
-/**
- * Perform visibility checks for probes using Raytracing
- * see {@link chunk_lpv_sample_irradiance}
- * @type {CodeChunk}
- */
-export const chunk_lpv_mask_visibility_via_rays = CodeChunk.from(
-    //language=WGSL
-    `
-fn lpv_mask_visibility_via_rays(vertices:array<u32, 4>, position_ws: vec3<f32>, shading_normal: vec3<f32>) -> vec4<f32> {
-    var weights: vec4<f32> = vec4(1.0);
-
-    // do shadow rays towards tet corners
-    for(var i=0u; i < 4; i++){
-        let i_probe_index = vertices[i];
-        
-        let i_probe = lpv_probes[i_probe_index];
-        let i_probe_position = f32_array_as_vec3(i_probe.position);
-        
-        let to_probe = (i_probe_position - position_ws);
-        
-        var shadow_ray:${RAY_STRUCT.wgsl_ref};
-        
-        shadow_ray.direction = normalize(to_probe);
-        shadow_ray.origin = offset_ray(position_ws, shading_normal) + shadow_ray.direction * 1e-6;
-        shadow_ray.tmax = length(to_probe);
-        
-        if(ray_query_occluded(shadow_ray)){
-            weights[i] = 0;
-        }
-    }
-    
-    return weights;
-}
-`, [
-        RAY_STRUCT.declaration_chunk,
-        chunk_f32_array_as_vec3,
-        chunk_offset_ray,
-        chunk_ray_query_occluded,
-    ])

package/src/shade/renderer/shader/chunk/light/sample/chunk_ray_sample_light.d.ts

@@ -1,3 +0,0 @@
-export const chunk_ray_sample_light: CodeChunk;
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_ray_sample_light.d.ts.map

package/src/shade/renderer/shader/chunk/light/sample/chunk_ray_sample_light.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_ray_sample_light.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/sample/chunk_ray_sample_light.js"],"names":[],"mappings":"AAgBA,+CAwFO;0BAxGmB,gCAAgC"}