shim.cpp

#include <ai.h>
#include <cstddef>
#include <ai_output_iterator.h>
#include <ai_nodes.h>

extern "C" {
    int         rst_ai_node_driver(void)      { return AI_NODE_DRIVER; }
    int         rst_ai_type_none(void)        { return AI_TYPE_NONE; }
    const char* rst_ai_version(void)          { return AI_VERSION; }
    int         rst_ai_maxsize_version(void)  { return AI_MAXSIZE_VERSION; }

    size_t rst_nl_size(void)                 { return sizeof(AtNodeLib); }
    size_t rst_nl_off_node_type(void)        { return offsetof(AtNodeLib, node_type); }
    size_t rst_nl_off_output_type(void)      { return offsetof(AtNodeLib, output_type); }
    size_t rst_nl_off_name(void)             { return offsetof(AtNodeLib, name); }
    size_t rst_nl_off_methods(void)          { return offsetof(AtNodeLib, methods); }
    size_t rst_nl_off_version(void)          { return offsetof(AtNodeLib, version); }

    // Logging wrappers (avoid C variadics in Rust)
    void rst_msg_info(const char* msg)       { AiMsgInfo("%s", msg); }
    void rst_msg_debug(const char* msg)      { AiMsgDebug("%s", msg); }
    void rst_msg_warning(const char* msg)    { AiMsgWarning("%s", msg); }
    void rst_msg_error(const char* msg)      { AiMsgError("%s", msg); }

    // Output iterator wrappers
    bool rst_outiter_next(AtOutputIterator* it, const char** out_name, int* out_pixel_type, const void** out_data) {
        AtString name;
        int pixel_type = 0;
        const void* data = nullptr;
        const bool ok = AiOutputIteratorGetNext(it, &name, &pixel_type, &data);
        if (!ok) return false;
        if (out_name) *out_name = name; // implicit conversion to const char*
        if (out_pixel_type) *out_pixel_type = pixel_type;
        if (out_data) *out_data = data;
        return true;
    }
    void rst_outiter_reset(AtOutputIterator* it) { AiOutputIteratorReset(it); }
    bool rst_outiter_is_half(AtOutputIterator* it) { return AiOutputIteratorIsHalf(it); }
    const char* rst_outiter_layer_name(AtOutputIterator* it) { return AiOutputIteratorGetLayerName(it); }

    // Driver initialize wrapper
    void rst_driver_initialize(AtNode* node, bool supports_multiple_outputs) {
        AiDriverInitialize(node, supports_multiple_outputs);
    }

    // Node parameter getters (common types)
    int         rst_node_get_int(AtNode* node, const char* name) { return AiNodeGetInt(node, AtString(name)); }
    float       rst_node_get_flt(AtNode* node, const char* name) { return AiNodeGetFlt(node, AtString(name)); }
    bool        rst_node_get_bool(AtNode* node, const char* name){ return AiNodeGetBool(node, AtString(name)); }
    const char* rst_node_get_str(AtNode* node, const char* name) { AtString s = AiNodeGetStr(node, AtString(name)); return s; }

    // Parameter declaration helpers (to be called within Parameters callback)
    void rst_params_add_str(AtList* params, const char* name, const char* defval) {
        AiNodeParamStr(params, -1, name, defval);
    }
    void rst_params_add_int(AtList* params, const char* name, int defval) {
        AiNodeParamInt(params, -1, name, defval);
    }
    void rst_params_add_flt(AtList* params, const char* name, float defval) {
        AiNodeParamFlt(params, -1, name, defval);
    }
    void rst_params_add_bool(AtList* params, const char* name, bool defval) {
        AiNodeParamBool(params, -1, name, defval);
    }
}