interface.h

#pragma once

#include <cstddef>
#include <cstdint>

extern "C" {

/**
 * @brief Opaque AABB structure (treat as pointer).
 */
struct Aabb64;

/**
 * @brief Column-major 4x4 affine transformation matrix.
 */
using Matrix4x4 = double[4][4];

/**
 * @brief Status codes for AABB operations.
 */
enum class Status : uint32_t {
    Success = 0,                ///< Operation completed successfully.
    NullPointer,                ///< Provided pointer was null.
    InvalidPointerAlignment,    ///< Pointer was not properly aligned.
    InsufficientBufferSize,     ///< Buffer size is incorrect (too small).
    InvalidByteStride           ///< Byte stride does not have required alignment.
};

/**
 * @brief Return the byte size and alignment of the AABB state buffer.
 * @param[out] out_buffer_size Pointer to store buffer size.
 * @param[out] out_buffer_alignment Pointer to store buffer alignment.
 * @return Status::Success or error code.
 */
Status aabb_buffer_info(std::size_t* out_buffer_size, std::size_t* out_buffer_alignment);

/**
 * @brief Initialize the AABB structure.
 * @param[in,out] aabb Pointer to AABB structure.
 * @param[in] aabb_size Size of AABB structure (must be at least value from aabb_buffer_info).
 * @return Status::Success or error code.
 */
Status aabb_init(Aabb64* aabb, std::size_t aabb_size);

/**
 * @brief Incrementally compute the AABB for a set of points transformed by a given affine transformation.
 *        This function is cumulative and can be called multiple times.
 * @param[in,out] aabb Pointer to AABB structure.
 * @param[in] aabb_size Size of AABB structure (must be at least value from aabb_buffer_info).
 * @param[in] transform Pointer to 4x4 column-major affine transformation matrix.
 * @param[in] first_point Pointer to first point in array.
 * @param[in] point_count Number of points in array.
 * @param[in] point_byte_stride Byte stride between points (must be 4-byte aligned).
 * @return Status::Success or error code.
 */
Status aabb_compute_incremental(
    Aabb64* aabb,
    std::size_t aabb_size,
    const Matrix4x4* transform,
    const void* first_point,
    std::size_t point_count,
    std::size_t point_byte_stride
);

/**
 * @brief Get the current min and max values of the AABB.
 *        Can be called after any number of incremental computations.
 * @param[in] aabb Pointer to AABB structure.
 * @param[in] aabb_size Size of AABB structure (must be at least value from aabb_buffer_info).
 * @param[out] out_min Pointer to store min vector.
 * @param[out] out_max Pointer to store max vector.
 * @param[in] out_buffer_size Size of output buffers (must be at least 24 bytes).
 * @return Status::Success or error code.
 */
Status aabb_result(
    const Aabb64* aabb,
    std::size_t aabb_size,
    void* out_min,
    void* out_max,
    std::size_t out_buffer_size
);

} // extern "C"