ComputeMeshBuffer.hpp

Go to the documentation of this file.

#pragma once
 
#include "MayaFlux/Buffers/VKBuffer.hpp"
#include "MayaFlux/Kakshya/NDData/VertexFormats.hpp"
#include "MayaFlux/Kinesis/Tendency/DualField.hpp"
#include "MayaFlux/Kinesis/Tendency/Tendency.hpp"
 
namespace MayaFlux::Buffers {
 
class RenderProcessor;
class SDFPrepProcessor;
class SDFFieldProcessor;
class SDFMeshProcessor;
 
/**
 * @class ComputeMeshBuffer
 * @brief VKBuffer that evaluates a SpatialField isosurface via marching cubes
 *        on the GPU and renders directly without CPU readback.
 *
 * SDFMeshProcessor dispatches mc_emit.comp into this buffer each dirty frame.
 * RenderProcessor draws from the same VKBuffer. No CPU-GPU round-trip occurs
 * after the initial lookup table upload.
 *
 * Config::source picks where the field is evaluated. A SpatialField is
 * evaluated on the CPU into the grid whenever the buffer is dirty. A path
 * names a field compute shader, and an MF_FIELD, MF_FIELD_T or MF_FIELD_P
 * field is lowered to one; both fill the grid on the GPU and are driven
 * through get_field_processor(). The surface is re-extracted only when dirty.
 *
 * One MF_FIELD serves both evaluators: pass the field itself for the GPU, or
 * its cpu member for the CPU. A temporal field reads the processor's time,
 * and a parametric field also reads its parameter block, set with set_params.
 *
 * Usage:
 * @code
 * auto buf = std::make_shared<ComputeMeshBuffer>(ComputeMeshBuffer::Config {
 *     .source = make_field(),
 *     .bounds_min = glm::vec3(-1.6F),
 *     .bounds_max = glm::vec3(1.6F),
 *     .resolution_x = 40,
 *     .resolution_y = 40,
 *     .resolution_z = 40,
 * }) | Graphics;
 * buf->setup_rendering({ .target_window = window });
 *
 * schedule_metro(1.0 / 60.0, [buf, make_field]() {
 *     buf->set_field(make_field());
 *     buf->set_dirty();
 * }, "sdf_anim", Vruta::ProcessingToken::FRAME_ACCURATE);
 * @endcode
 */
class MAYAFLUX_API ComputeMeshBuffer : public VKBuffer {
public:
    using FieldSource = std::variant<
        Kinesis::SpatialField,
        std::filesystem::path,
        Kinesis::DualSpatialField,
        Kinesis::TemporalSpatialField,
        Kinesis::ParametricSpatialField>;
 
    struct Config {
        FieldSource source;
        glm::vec3 bounds_min { -1.0F };
        glm::vec3 bounds_max { 1.0F };
        uint32_t resolution_x { 32 };
        uint32_t resolution_y { 32 };
        uint32_t resolution_z { 32 };
        float iso_level { 0.0F };
    };
 
    explicit ComputeMeshBuffer(Config config);
 
    /** @brief Access the field processor to drive time or bounds from a metro. */
    [[nodiscard]] std::shared_ptr<SDFFieldProcessor> get_field_processor() const
    {
        return m_field_processor;
    }
 
    /**
     * @brief The marching-cubes stage, valid after setup_processors().
     *
     * Holds the atomic vertex counter buffer (SDFMeshProcessor::counter_buf())
     * a readback needs to size itself correctly, since this buffer's own
     * get_size_bytes() reflects worst-case allocated capacity, not the live
     * count from the most recent dispatch.
     */
    [[nodiscard]] std::shared_ptr<SDFMeshProcessor> get_mesh_processor() const
    {
        return m_sdf_processor;
    }
 
    /**
     * @brief The live vertex count from the most recent dispatch.
     *
     * get_size_bytes() and the vertex layout describe worst-case capacity; this
     * is the count a readback must be sized to.
     *
     * @return The count, or nullopt before setup_processors() or when the counter is not mapped.
     */
    [[nodiscard]] std::optional<uint32_t> get_live_vertex_count() const;
 
    ~ComputeMeshBuffer() override = default;
 
    void setup_processors(ProcessingToken token) override;
 
    /**
     * @brief Create the RenderProcessor and attach it to the processing chain.
     * @param config  At minimum, supply target_window. Shader paths default to
     *                triangle.vert.spv / triangle.frag.spv (or mesh_textured.frag.spv
     *                when a texture has been set).
     */
    void setup_rendering(const RenderConfig& config);
 
    // -------------------------------------------------------------------------
    // Field and geometry control
    // -------------------------------------------------------------------------
 
    /** @brief Replace the scalar field and mark dirty. */
    void set_field(Kinesis::SpatialField field);
 
    /** @brief Replace the evaluation volume and mark dirty. */
    void set_bounds(const glm::vec3& bounds_min, const glm::vec3& bounds_max);
 
    /**
     * @brief Replace the grid resolution.
     *
     * Resizes the internal grid and counter buffers. Marks dirty.
     */
    void set_resolution(uint32_t res_x, uint32_t res_y, uint32_t res_z);
 
    /** @brief Replace the iso_level threshold and mark dirty. */
    void set_iso_level(float iso_level);
 
    /** @brief Request a re-dispatch on the next graphics frame. */
    void set_dirty();
 
    // -------------------------------------------------------------------------
    // Texture
    // -------------------------------------------------------------------------
 
    /**
     * @brief Bind a diffuse texture sampled in the fragment shader.
     * @param image   GPU image (nullptr clears the binding).
     * @param binding Descriptor name (default: "diffuseTex").
     *
     * Selects mesh_textured.frag.spv when setup_rendering is called after this.
     * Calling after setup_rendering forwards the binding to RenderProcessor directly.
     */
    void set_texture(
        std::shared_ptr<Core::VKImage> image,
        std::string binding = "diffuseTex");
 
    /** @brief Check if a diffuse texture is bound. */
    [[nodiscard]] bool has_diffuse_texture() const noexcept { return m_diffuse_texture != nullptr; }
 
    /** @brief Diffuse texture is optional, so may return nullptr. */
    [[nodiscard]] std::shared_ptr<Core::VKImage> get_diffuse_texture() const noexcept { return m_diffuse_texture; }
 
private:
    uint32_t m_res_x;
    uint32_t m_res_y;
    uint32_t m_res_z;
 
    std::shared_ptr<SDFMeshProcessor> m_sdf_processor;
 
    std::shared_ptr<Core::VKImage> m_diffuse_texture;
    std::string m_diffuse_binding { "diffuseTex" };
 
    bool m_gpu_field {};
    std::shared_ptr<SDFPrepProcessor> m_prep_processor;
    std::shared_ptr<SDFFieldProcessor> m_field_processor;
 
    std::string m_field_shader;
    std::optional<Kinesis::FieldSource> m_field_expression;
 
    // Field parameters held until m_sdf_processor is constructed.
    Kinesis::SpatialField m_field;
    glm::vec3 m_bounds_min;
    glm::vec3 m_bounds_max;
    float m_iso_level;
 
    [[nodiscard]] static size_t worst_case_bytes(
        uint32_t res_x, uint32_t res_y, uint32_t res_z) noexcept
    {
        return static_cast<size_t>(res_x) * res_y * res_z * 15U * sizeof(Kakshya::MeshVertex);
    }
};
 
} // namespace MayaFlux::Buffers