ai_operator.h

Go to the documentation of this file.

// Copyright 2023 Autodesk, Inc.  All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
 
#pragma once
 
#include "ai_nodes.h"
#include "ai_version.h"
#include "ai_matrix.h"
#include "ai_api.h"
 
// Forward declarations
struct AtNode;
struct AtCookContext;
 
typedef bool (*AtOpCleanupChildData)(void* child_data);
 
AI_API bool     AiOpSetTarget(AtUniverse* universe, AtNode* node);
AI_API AtNode*  AiOpGetTarget(const AtUniverse* universe);
 
AI_API AtArray* AiOpGetInputs(AtNode* op);
AI_API bool     AiOpLink(AtNode* from, AtNode* to, int index = -1);
AI_API bool     AiOpUnlinkInputByIndex(AtNode* to, unsigned int index);
AI_API bool     AiOpUnlink(AtNode* from, AtNode* to);
 
AI_API void     AiOpSetChildData(AtNode* op, void* child_data = NULL, AtOpCleanupChildData cleanup = NULL);
 
AI_API bool     AiOpMatchNodeSelection(AtNode* node, AtString selection, bool relative = true, AtNode* target = NULL);
 
AI_API AtNode*  AiOpCookContextGetCookScope(AtCookContext* cook_context);
 
typedef bool (*AtOpInit)(AtNode* op, void** user_data);
 
typedef bool (*AtOpCleanup)(AtNode* op, void* user_data);
 
typedef bool (*AtOpCook)(AtNode* node, AtNode* op, void* child_data, void* user_data, const AtArray* matching_params, AtCookContext* cook_context);
 
typedef bool (*AtOpPostCook)(AtNode* op, void* user_data);
 
struct AtOperatorNodeMethods
{
   AtOpInit       Init;
   AtOpCleanup    Cleanup;
   AtOpCook       Cook;
   AtOpPostCook   PostCook;
};
 
typedef int (*AtOpFuncPtr)(AtOperatorNodeMethods* methods);
 
#define AI_OPERATOR_COMMON_NODE_METHODS         \
node_parameters;                                \
static AtCommonMethods ai_common_mtds = {       \
   NULL,                                        \
   NULL,                                        \
   Parameters,                                  \
   NULL,                                        \
   NULL,                                        \
   NULL                                         \
};
 
#define AI_OPERATOR_NODE_EXPORT_METHODS(tag)    \
AI_OPERATOR_COMMON_NODE_METHODS                 \
operator_init;                                  \
operator_cleanup;                               \
operator_cook;                                  \
operator_post_cook;                             \
static AtOperatorNodeMethods ai_op_mtds = {     \
   OperatorInit,                                \
   OperatorCleanup,                             \
   OperatorCook,                                \
   OperatorPostCook                             \
};                                              \
static AtNodeMethods ai_node_mtds = {           \
   &ai_common_mtds,                             \
   &ai_op_mtds                                  \
};                                              \
const AtNodeMethods* tag = &ai_node_mtds;
 
#define AI_OPERATOR_NODE_INTERNAL_METHODS(tag)  \
AI_INSTANCE_COMMON_METHODS                      \
static AtNodeMethods ai_node_internal_mtds = {  \
   &ai_common_mtds,                             \
   NULL                                         \
};                                              \
const AtNodeMethods* tag = &ai_node_internal_mtds;
 
#define operator_init \
static bool OperatorInit(AtNode* op, void** user_data)
 
#define operator_cleanup \
static bool OperatorCleanup(AtNode* op, void* user_data)
 
#define operator_cook \
static bool OperatorCook(AtNode* node, AtNode* op, void* child_data, void* user_data, const AtArray* matching_params, AtCookContext* cook_context)
 
#define operator_post_cook \
static bool OperatorPostCook(AtNode* op, void* user_data)
 
/*\}*/