Crafter.Graphics/interfaces/Crafter.Graphics-Mesh.cppm

/*
Crafter®.Graphics
Copyright (C) 2026 Catcrafts®
catcrafts.net

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License version 3.0 as published by the Free Software Foundation;

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
*/

module;

#ifndef CRAFTER_GRAPHICS_WINDOW_DOM
#include "vulkan/vulkan.h"

#endif // !CRAFTER_GRAPHICS_WINDOW_DOM
export module Crafter.Graphics:Mesh;
#ifndef CRAFTER_GRAPHICS_WINDOW_DOM
import std;
import Crafter.Math;
import Crafter.Asset;
import :VulkanBuffer;

export namespace Crafter {
    class Mesh {
        public:
        VulkanBuffer<char, false> scratchBuffer;
        VulkanBuffer<char, false> blasBuffer;
        VulkanBuffer<Vector<float, 3, 3>, true> vertexBuffer;
        VulkanBuffer<std::uint32_t, true> indexBuffer;
        // Lives until the cmd buffer issued by the compressed Build path
        // completes execution. Kept as a member so the recorded
        // vkCmdDecompressMemoryEXT references valid memory until the queue
        // submit signals — caller must not re-Build or destroy the Mesh
        // before that submit's fence is signaled (same contract as the
        // existing uncompressed path).
        VulkanBuffer<std::byte, true> compressedStaging;
        VkAccelerationStructureGeometryTrianglesDataKHR blasData;
        VkAccelerationStructureGeometryKHR blas;
        VkAccelerationStructureKHR accelerationStructure;
        VkDeviceAddress blasAddr;
        bool opaque;
        void Build(std::span<Vector<float, 3, 3>> verticies, std::span<std::uint32_t> indicies, VkCommandBuffer cmd);
        // GPU path: decompresses vertex (region 0) and index (region 1) streams
        // from asset.blob into vertexBuffer / indexBuffer using
        // VK_EXT_memory_decompression. Falls back to CPU decode + the
        // uncompressed Build if Device::memoryDecompressionSupported is false.
        // Region 2 (data) is not consumed here — the caller decompresses it
        // into their own buffer if needed (or uses Compression::DecompressCPU).
        void Build(const ::Crafter::CompressedMeshAsset& asset, VkCommandBuffer cmd);
    };
}
#endif // !CRAFTER_GRAPHICS_WINDOW_DOM

#ifdef CRAFTER_GRAPHICS_WINDOW_DOM
import std;
import Crafter.Math;
import Crafter.Asset;
import :WebGPU;

export namespace Crafter {
    // Software-RT BLAS node, packed to 32 bytes. Matches the WGSL
    // `BVHNode` struct in the RT WGSL prelude (additional/dom-webgpu.js,
    // rtWgslPrelude) byte-for-byte.
    //
    //   primCount == 0          → inner node, children at indices
    //                             firstChildOrPrim and firstChildOrPrim+1.
    //   primCount  > 0          → leaf, `primCount` primitives starting at
    //                             primIndex `firstChildOrPrim` in the
    //                             global primRemap heap.
    //
    // SAH-built BVH2; constructed CPU-side at Build() time, never refit.
    struct BVHNode {
        float         aabbMin[3];
        std::uint32_t firstChildOrPrim;
        float         aabbMax[3];
        std::uint32_t primCount;
    };
    static_assert(sizeof(BVHNode) == 32);

    // One procedural primitive's axis-aligned bounding box, in object
    // space. The analog of VkAabbPositionsKHR — the BLAS stores these
    // instead of triangles and an intersection shader (registered in the
    // hit group as a ProceduralHitGroup) reports the actual surface hit
    // for each AABB the ray enters.
    struct RTAabb {
        float min[3];
        float max[3];
    };
    static_assert(sizeof(RTAabb) == 24);

    class Mesh {
        public:
        // BLAS "handle": opaque identity that goes into
        // RTInstance::accelerationStructureReference. Set by Build() to a
        // stable u32 (widened to u64 for Vulkan-struct layout parity), used
        // by the WebGPU TLAS-build compute shader to look up the BLAS root
        // AABB and per-mesh heap offsets. Handle 0 is the unassigned
        // sentinel; never returned by Build().
        std::uint64_t blasAddr = 0;
        std::uint32_t triangleCount = 0;
        std::uint32_t vertexCount   = 0;

        bool opaque = true;

        // Build BLAS from raw triangle data. Runs the CPU SAH BVH2 builder
        // and forwards vertex/index/BVH/remap arrays to the JS-side mesh
        // heap (additional/dom-webgpu.js), which queue.writeBuffers them
        // into the global heaps and records the per-mesh offsets keyed by
        // the returned handle. The `cmd` parameter is unused on WebGPU —
        // kept for API symmetry with the Vulkan signature.
        void Build(std::span<Crafter::Vector<float, 3, 3>> vertices,
                   std::span<std::uint32_t>                indices,
                   WebGPUCommandEncoderRef                  cmd = 0);

        // CPU-decompress the .cmesh blob (no VK_EXT_memory_decompression
        // equivalent in WebGPU) and forward to the positions+indices path,
        // plus push the optional `data` region into the per-vertex attribs
        // heap so closest-hit shaders can sample UVs / normals / tangents.
        // The data layout is example-defined — the heap is exposed in WGSL
        // as `vertexAttribs : array<u32>` with a per-mesh u32-word offset.
        void Build(const ::Crafter::CompressedMeshAsset& asset,
                   WebGPUCommandEncoderRef                cmd = 0);

        // Build an AABB (procedural) BLAS from a list of object-space boxes
        // — the WebGPU analog of a VK_GEOMETRY_TYPE_AABBS_KHR geometry. The
        // hit group bound to instances of this mesh must be a
        // ProceduralHitGroup carrying an intersection shader; that shader is
        // invoked for each box the ray enters and reports the surface hit.
        // `opaque` is the geometry's opaque bit: pass false to let any-hit
        // shaders run (the default for procedural geometry, which is usually
        // transparent / volumetric). The `cmd` parameter is unused on
        // WebGPU — kept for API symmetry with the triangle path.
        void BuildProcedural(std::span<const RTAabb> aabbs,
                             bool                    opaque = false,
                             WebGPUCommandEncoderRef cmd    = 0);
    };
}
#endif // CRAFTER_GRAPHICS_WINDOW_DOM