metalMarchingCubesPass.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2025-2026 Arnis Lektauers
//
// Metal compute pass for GPU Marching Cubes isosurface extraction.
//
// Two-pass atomic pipeline:
//   Pass 1 (classifyCells): Each thread classifies one cell, computes its cube
//     index from the 3D volume texture, counts vertices via the triangle table,
//     and atomically adds to a global vertex counter.
//   Pass 2 (generateVertices): Each thread reprocesses its cell, atomically
//     allocates space in the output buffer, and writes full 56-byte VertexData
//     (position, normal, UV, tangent) matching the engine's common.metal layout.
//
// Follows the MetalParticleComputePass pattern:
//   - Embedded MSL source as string literal
//   - Lazy resource creation
//   - Friend access to MetalGraphicsDevice for command queue
//
// Custom shader -- no upstream GLSL equivalent exists for GPU
// Marching Cubes isosurface extraction.
//
#pragma once
 
#include <cstdint>
#include <vector>
#include <Metal/Metal.hpp>
 
namespace visutwin::canvas
{
    class MetalGraphicsDevice;
    class Texture;

    struct alignas(16) MCComputeParams
    {
        uint32_t dimsX, dimsY, dimsZ;   
        float    isovalue;                
        float    domainMinX, domainMinY, domainMinZ;
        float    _pad0;
        float    domainMaxX, domainMaxY, domainMaxZ;
        float    _pad1;
        float    texelSizeX, texelSizeY, texelSizeZ; 
        uint32_t maxVertices;             
        uint32_t flipNormals;             
        float    _pad2[3];
    };
    static_assert(sizeof(MCComputeParams) == 80,
        "MCComputeParams must be 80 bytes to match MSL layout");

    struct MCExtractResult
    {
        MTL::Buffer* vertexBuffer = nullptr;  
        uint32_t     vertexCount  = 0;        
        bool         success      = false;
    };

    struct MCBatchResult
    {
        struct Layer {
            MTL::Buffer* vertexBuffer = nullptr;  
            uint32_t     vertexCount  = 0;
        };
        std::vector<Layer> layers;
        bool success = false;
    };

    class MetalMarchingCubesPass
    {
    public:
        explicit MetalMarchingCubesPass(MetalGraphicsDevice* device);
        ~MetalMarchingCubesPass();
 
        // Non-copyable
        MetalMarchingCubesPass(const MetalMarchingCubesPass&) = delete;
        MetalMarchingCubesPass& operator=(const MetalMarchingCubesPass&) = delete;

        MCExtractResult extract(Texture* volumeTexture, const MCComputeParams& params);

        MCBatchResult extractBatch(Texture* volumeTexture,
                                   const MCComputeParams& baseParams,
                                   const std::vector<float>& isovalues,
                                   const std::vector<bool>& flipNormals = {});

        [[nodiscard]] bool isReady() const { return resourcesReady_; }
 
    private:
        void ensureResources();

        MTL::Buffer* allocateVertexBuffer(uint32_t vertexCount);
 
        MetalGraphicsDevice* device_;
 
        // Compute pipelines
        MTL::ComputePipelineState* classifyPipeline_ = nullptr;
        MTL::ComputePipelineState* generatePipeline_ = nullptr;
 
        // Lookup table buffers (constant, created once)
        MTL::Buffer* edgeTableBuffer_ = nullptr;   // 256 x uint16_t = 512 bytes
        MTL::Buffer* triTableBuffer_  = nullptr;    // 256 x 16 x int8_t = 4096 bytes
 
        // Shared buffers (reused across extractions)
        MTL::Buffer* counterBuffer_   = nullptr;    // single atomic_uint (StorageModeShared)
        MTL::Buffer* uniformBuffer_   = nullptr;    // MCComputeParams (80 bytes)
 
        // Sampler for volume texture
        MTL::SamplerState* fieldSampler_ = nullptr;
 
        bool resourcesReady_ = false;
    };
 
} // namespace visutwin::canvas