Dron/Onejsky4U
1
0
Fork 0
Code Pull Requests Releases Activity
Files
master
Onejsky4U/Plugins/Runtime/HoudiniEngine/Source/HoudiniEngineRuntime/Public/HAPI/HAPI_Common.h
T

1809 lines
60 KiB
C
Raw Permalink Blame History

/*
* PROPRIETARY INFORMATION. This software is proprietary to
* Side Effects Software Inc., and is not to be reproduced,
* transmitted, or disclosed in any way without written permission.
*
*/
#ifndef __HAPI_COMMON_h__
#define __HAPI_COMMON_h__
#include "HAPI_API.h"
/////////////////////////////////////////////////////////////////////////////
// Defines
#define HAPI_POSITION_VECTOR_SIZE 3
#define HAPI_SCALE_VECTOR_SIZE 3
#define HAPI_SHEAR_VECTOR_SIZE 3
#define HAPI_NORMAL_VECTOR_SIZE 3
#define HAPI_QUATERNION_VECTOR_SIZE 4
#define HAPI_EULER_VECTOR_SIZE 3
#define HAPI_UV_VECTOR_SIZE 2
#define HAPI_COLOR_VECTOR_SIZE 4
#define HAPI_CV_VECTOR_SIZE 4
#define HAPI_PRIM_MIN_VERTEX_COUNT 1
#define HAPI_PRIM_MAX_VERTEX_COUNT 16
#define HAPI_INVALID_PARM_ID -1
/// Common Default Attributes' Names
/// @{
#define HAPI_ATTRIB_POSITION "P"
#define HAPI_ATTRIB_UV "uv"
#define HAPI_ATTRIB_UV2 "uv2"
#define HAPI_ATTRIB_NORMAL "N"
#define HAPI_ATTRIB_TANGENT "tangentu"
#define HAPI_ATTRIB_TANGENT2 "tangentv"
#define HAPI_ATTRIB_COLOR "Cd"
#define HAPI_ATTRIB_NAME "name"
#define HAPI_ATTRIB_INSTANCE "instance"
/// @}
/// This is the name of the primitive group created from all the primitives
/// that are not in any user-defined group. This way, when you put all the
/// groups together you cover the entire mesh. This is important for some
/// clients where the mesh has to be defined in terms of submeshes that cover
/// the entire original mesh.
#define HAPI_UNGROUPED_GROUP_NAME "__ungrouped_group"
/// Common image file format names (to use with the material extract APIs).
/// Note that you may still want to check if they are supported via
/// HAPI_GetSupportedImageFileFormats() since all formats are loaded
/// dynamically by Houdini on-demand so just because these formats are defined
/// here doesn't mean they are supported in your instance.
/// @{
#define HAPI_RAW_FORMAT_NAME "HAPI_RAW" // HAPI-only Raw Format
#define HAPI_PNG_FORMAT_NAME "PNG"
#define HAPI_JPEG_FORMAT_NAME "JPEG"
#define HAPI_BMP_FORMAT_NAME "Bitmap"
#define HAPI_TIFF_FORMAT_NAME "TIFF"
#define HAPI_TGA_FORMAT_NAME "Targa"
/// @}
/// Default image file format's name - used when the image generated and has
/// no "original" file format and the user does not specify a format to
/// convert to.
#define HAPI_DEFAULT_IMAGE_FORMAT_NAME HAPI_PNG_FORMAT_NAME
/// Name of subnet OBJ node containing the global nodes.
#define HAPI_GLOBAL_NODES_NODE_NAME "GlobalNodes"
/// Environment variables.
#define HAPI_ENV_HIP "HIP"
#define HAPI_ENV_JOB "JOB"
#define HAPI_ENV_CLIENT_NAME "HAPI_CLIENT_NAME"
/// [HAPI_CACHE]
/// Common cache names. You can see these same cache names in the
/// Cache Manager window in Houdini (Windows > Cache Manager).
#define HAPI_CACHE_COP_COOK "COP Cook Cache"
#define HAPI_CACHE_COP_FLIPBOOK "COP Flipbook Cache"
#define HAPI_CACHE_IMAGE "Image Cache"
#define HAPI_CACHE_OBJ "Object Transform Cache"
#define HAPI_CACHE_GL_TEXTURE "OpenGL Texture Cache"
#define HAPI_CACHE_GL_VERTEX "OpenGL Vertex Cache"
#define HAPI_CACHE_SOP "SOP Cache"
#define HAPI_CACHE_VEX "VEX File Cache"
/// [HAPI_CACHE]
// Make sure our enums and structs are usable without those keywords, as-is,
// in C.
#ifdef __cplusplus
#define HAPI_C_ENUM_TYPEDEF( enum_name )
#define HAPI_C_STRUCT_TYPEDEF( struct_name )
#else
#define HAPI_C_ENUM_TYPEDEF( enum_name ) \
typedef enum enum_name enum_name;
#define HAPI_C_STRUCT_TYPEDEF( struct_name ) \
typedef struct struct_name struct_name;
#endif // __cplusplus
/////////////////////////////////////////////////////////////////////////////
// Typedefs
// C has no bool.
#ifdef __cplusplus
typedef bool HAPI_Bool;
#else
typedef char HAPI_Bool;
#endif // __cplusplus
// 64-bit Integers
typedef long long HAPI_Int64;
HAPI_STATIC_ASSERT( sizeof( HAPI_Int64 ) == 8, unsupported_size_of_long );
// The process id has to be uint on Windows and int on any other platform.
#if ( defined _WIN32 || defined WIN32 )
typedef unsigned int HAPI_ProcessId;
#else
typedef int HAPI_ProcessId;
#endif
/// Has to be 64-bit.
typedef HAPI_Int64 HAPI_SessionId;
/// Use this with HAPI_GetString() to get the value.
/// See @ref HAPI_Fundamentals_Strings.
typedef int HAPI_StringHandle;
typedef int HAPI_AssetLibraryId;
/// See @ref HAPI_Nodes_Basics.
typedef int HAPI_NodeId;
/// Either get this from the ::HAPI_ParmInfo or ::HAPI_GetParmIdFromName().
/// See @ref HAPI_Parameters.
typedef int HAPI_ParmId;
/// Use this with ::HAPI_GetPartInfo().
/// See @ref HAPI_Parts.
typedef int HAPI_PartId;
/// Use this with PDG functions
typedef int HAPI_PDG_WorkitemId;
/// Use this with PDG functions
typedef int HAPI_PDG_GraphContextId;
/// When we load a HIP file, we associate a HIP file ID with the created nodes
/// so that they can be looked up later
typedef int HAPI_HIPFileId;
/////////////////////////////////////////////////////////////////////////////
// Enums
enum HAPI_License
{
HAPI_LICENSE_NONE,
HAPI_LICENSE_HOUDINI_ENGINE,
HAPI_LICENSE_HOUDINI,
HAPI_LICENSE_HOUDINI_FX,
HAPI_LICENSE_HOUDINI_ENGINE_INDIE,
HAPI_LICENSE_HOUDINI_INDIE,
HAPI_LICENSE_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_License )
enum HAPI_StatusType
{
HAPI_STATUS_CALL_RESULT,
HAPI_STATUS_COOK_RESULT,
HAPI_STATUS_COOK_STATE,
HAPI_STATUS_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_StatusType )
enum HAPI_StatusVerbosity
{
HAPI_STATUSVERBOSITY_0,
HAPI_STATUSVERBOSITY_1,
HAPI_STATUSVERBOSITY_2,
HAPI_STATUSVERBOSITY_ALL = HAPI_STATUSVERBOSITY_2,
///< Equivalent to ::HAPI_STATUSVERBOSITY_2.
// Used for Results.
HAPI_STATUSVERBOSITY_ERRORS = HAPI_STATUSVERBOSITY_0,
///< Equivalent to ::HAPI_STATUSVERBOSITY_0.
HAPI_STATUSVERBOSITY_WARNINGS = HAPI_STATUSVERBOSITY_1,
///< Equivalent to ::HAPI_STATUSVERBOSITY_1.
HAPI_STATUSVERBOSITY_MESSAGES = HAPI_STATUSVERBOSITY_2,
///< Equivalent to ::HAPI_STATUSVERBOSITY_2.
};
HAPI_C_ENUM_TYPEDEF( HAPI_StatusVerbosity )
enum HAPI_Result
{
HAPI_RESULT_SUCCESS = 0,
HAPI_RESULT_FAILURE = 1,
HAPI_RESULT_ALREADY_INITIALIZED = 2,
HAPI_RESULT_NOT_INITIALIZED = 3,
HAPI_RESULT_CANT_LOADFILE = 4,
HAPI_RESULT_PARM_SET_FAILED = 5,
HAPI_RESULT_INVALID_ARGUMENT = 6,
HAPI_RESULT_CANT_LOAD_GEO = 7,
HAPI_RESULT_CANT_GENERATE_PRESET = 8,
HAPI_RESULT_CANT_LOAD_PRESET = 9,
HAPI_RESULT_ASSET_DEF_ALREADY_LOADED = 10,
HAPI_RESULT_NO_LICENSE_FOUND = 110,
HAPI_RESULT_DISALLOWED_NC_LICENSE_FOUND = 120,
HAPI_RESULT_DISALLOWED_NC_ASSET_WITH_C_LICENSE = 130,
HAPI_RESULT_DISALLOWED_NC_ASSET_WITH_LC_LICENSE = 140,
HAPI_RESULT_DISALLOWED_LC_ASSET_WITH_C_LICENSE = 150,
HAPI_RESULT_DISALLOWED_HENGINEINDIE_W_3PARTY_PLUGIN = 160,
HAPI_RESULT_ASSET_INVALID = 200,
HAPI_RESULT_NODE_INVALID = 210,
HAPI_RESULT_USER_INTERRUPTED = 300,
HAPI_RESULT_INVALID_SESSION = 400
};
HAPI_C_ENUM_TYPEDEF( HAPI_Result )
enum HAPI_ErrorCode
{
HAPI_ERRORCODE_ASSET_DEF_NOT_FOUND = 1 << 0,
HAPI_ERRORCODE_PYTHON_NODE_ERROR = 1 << 1
};
HAPI_C_ENUM_TYPEDEF( HAPI_ErrorCode )
typedef int HAPI_ErrorCodeBits;
enum HAPI_SessionType
{
HAPI_SESSION_INPROCESS,
HAPI_SESSION_THRIFT,
HAPI_SESSION_CUSTOM1,
HAPI_SESSION_CUSTOM2,
HAPI_SESSION_CUSTOM3,
HAPI_SESSION_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_SessionType )
enum HAPI_State
{
HAPI_STATE_READY, ///< Everything cook successfully without errors.
HAPI_STATE_READY_WITH_FATAL_ERRORS, ///< You should abort the cook.
HAPI_STATE_READY_WITH_COOK_ERRORS, ///< Only some objects failed.
HAPI_STATE_STARTING_COOK,
HAPI_STATE_COOKING,
HAPI_STATE_STARTING_LOAD,
HAPI_STATE_LOADING,
HAPI_STATE_MAX,
HAPI_STATE_MAX_READY_STATE = HAPI_STATE_READY_WITH_COOK_ERRORS
};
HAPI_C_ENUM_TYPEDEF( HAPI_State )
enum HAPI_PackedPrimInstancingMode
{
HAPI_PACKEDPRIM_INSTANCING_MODE_INVALID = -1,
HAPI_PACKEDPRIM_INSTANCING_MODE_DISABLED,
HAPI_PACKEDPRIM_INSTANCING_MODE_HIERARCHY,
HAPI_PACKEDPRIM_INSTANCING_MODE_FLAT,
HAPI_PACKEDPRIM_INSTANCING_MODE_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_PackedPrimInstancingMode )
enum HAPI_Permissions
{
HAPI_PERMISSIONS_NON_APPLICABLE,
HAPI_PERMISSIONS_READ_WRITE,
HAPI_PERMISSIONS_READ_ONLY,
HAPI_PERMISSIONS_WRITE_ONLY,
HAPI_PERMISSIONS_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_Permissions )
enum HAPI_RampType
{
HAPI_RAMPTYPE_INVALID = -1,
HAPI_RAMPTYPE_FLOAT,
HAPI_RAMPTYPE_COLOR,
HAPI_RAMPTYPE_MAX,
};
HAPI_C_ENUM_TYPEDEF( HAPI_RampType )
/// As you can see, some of these high level types share the same underlying
/// raw data type. For instance, both string and file parameter types can be
/// represented with strings, yet semantically they are different. We will
/// group high level parameter types that share an underlying raw data type
/// together, so you can always check the raw data type of a parameter based
/// on its high level data type by checking a range of values.
enum HAPI_ParmType
{
HAPI_PARMTYPE_INT = 0,
HAPI_PARMTYPE_MULTIPARMLIST,
HAPI_PARMTYPE_TOGGLE,
HAPI_PARMTYPE_BUTTON,
HAPI_PARMTYPE_FLOAT,
HAPI_PARMTYPE_COLOR,
HAPI_PARMTYPE_STRING,
HAPI_PARMTYPE_PATH_FILE,
HAPI_PARMTYPE_PATH_FILE_GEO,
HAPI_PARMTYPE_PATH_FILE_IMAGE,
HAPI_PARMTYPE_NODE,
HAPI_PARMTYPE_FOLDERLIST,
HAPI_PARMTYPE_FOLDERLIST_RADIO,
HAPI_PARMTYPE_FOLDER,
HAPI_PARMTYPE_LABEL,
HAPI_PARMTYPE_SEPARATOR,
HAPI_PARMTYPE_PATH_FILE_DIR,
// Helpers
HAPI_PARMTYPE_MAX, ///< Total number of supported parameter types.
HAPI_PARMTYPE_INT_START = HAPI_PARMTYPE_INT,
HAPI_PARMTYPE_INT_END = HAPI_PARMTYPE_BUTTON,
HAPI_PARMTYPE_FLOAT_START = HAPI_PARMTYPE_FLOAT,
HAPI_PARMTYPE_FLOAT_END = HAPI_PARMTYPE_COLOR,
HAPI_PARMTYPE_STRING_START = HAPI_PARMTYPE_STRING,
HAPI_PARMTYPE_STRING_END = HAPI_PARMTYPE_NODE,
HAPI_PARMTYPE_PATH_START = HAPI_PARMTYPE_PATH_FILE,
HAPI_PARMTYPE_PATH_END = HAPI_PARMTYPE_PATH_FILE_IMAGE,
HAPI_PARMTYPE_NODE_START = HAPI_PARMTYPE_NODE,
HAPI_PARMTYPE_NODE_END = HAPI_PARMTYPE_NODE,
HAPI_PARMTYPE_CONTAINER_START = HAPI_PARMTYPE_FOLDERLIST,
HAPI_PARMTYPE_CONTAINER_END = HAPI_PARMTYPE_FOLDERLIST_RADIO,
HAPI_PARMTYPE_NONVALUE_START = HAPI_PARMTYPE_FOLDER,
HAPI_PARMTYPE_NONVALUE_END = HAPI_PARMTYPE_SEPARATOR
};
HAPI_C_ENUM_TYPEDEF( HAPI_ParmType )
/// Corresponds to the types as shown in the Houdini Type Properties
/// window and in DialogScript files. Available on HAPI_ParmInfo
/// See: <a href="http://www.sidefx.com/docs/houdini/ref/windows/optype.html#parmtypes">Parameter types</a>
///
enum HAPI_PrmScriptType
{
HAPI_PRM_SCRIPT_TYPE_INT = 0, ///< "int", "integer"
HAPI_PRM_SCRIPT_TYPE_FLOAT,
HAPI_PRM_SCRIPT_TYPE_ANGLE,
HAPI_PRM_SCRIPT_TYPE_STRING,
HAPI_PRM_SCRIPT_TYPE_FILE,
HAPI_PRM_SCRIPT_TYPE_DIRECTORY,
HAPI_PRM_SCRIPT_TYPE_IMAGE,
HAPI_PRM_SCRIPT_TYPE_GEOMETRY,
HAPI_PRM_SCRIPT_TYPE_TOGGLE, ///< "toggle", "embed"
HAPI_PRM_SCRIPT_TYPE_BUTTON,
HAPI_PRM_SCRIPT_TYPE_VECTOR2,
HAPI_PRM_SCRIPT_TYPE_VECTOR3, ///< "vector", "vector3"
HAPI_PRM_SCRIPT_TYPE_VECTOR4,
HAPI_PRM_SCRIPT_TYPE_INTVECTOR2,
HAPI_PRM_SCRIPT_TYPE_INTVECTOR3, ///< "intvector", "intvector3"
HAPI_PRM_SCRIPT_TYPE_INTVECTOR4,
HAPI_PRM_SCRIPT_TYPE_UV,
HAPI_PRM_SCRIPT_TYPE_UVW,
HAPI_PRM_SCRIPT_TYPE_DIR, ///< "dir", "direction"
HAPI_PRM_SCRIPT_TYPE_COLOR, ///< "color", "rgb"
HAPI_PRM_SCRIPT_TYPE_COLOR4, ///< "color4", "rgba"
HAPI_PRM_SCRIPT_TYPE_OPPATH,
HAPI_PRM_SCRIPT_TYPE_OPLIST,
HAPI_PRM_SCRIPT_TYPE_OBJECT,
HAPI_PRM_SCRIPT_TYPE_OBJECTLIST,
HAPI_PRM_SCRIPT_TYPE_RENDER,
HAPI_PRM_SCRIPT_TYPE_SEPARATOR,
HAPI_PRM_SCRIPT_TYPE_GEOMETRY_DATA,
HAPI_PRM_SCRIPT_TYPE_KEY_VALUE_DICT,
HAPI_PRM_SCRIPT_TYPE_LABEL,
HAPI_PRM_SCRIPT_TYPE_RGBAMASK,
HAPI_PRM_SCRIPT_TYPE_ORDINAL,
HAPI_PRM_SCRIPT_TYPE_RAMP_FLT,
HAPI_PRM_SCRIPT_TYPE_RAMP_RGB,
HAPI_PRM_SCRIPT_TYPE_FLOAT_LOG,
HAPI_PRM_SCRIPT_TYPE_INT_LOG,
HAPI_PRM_SCRIPT_TYPE_DATA,
HAPI_PRM_SCRIPT_TYPE_FLOAT_MINMAX,
HAPI_PRM_SCRIPT_TYPE_INT_MINMAX,
HAPI_PRM_SCRIPT_TYPE_INT_STARTEND,
HAPI_PRM_SCRIPT_TYPE_BUTTONSTRIP,
HAPI_PRM_SCRIPT_TYPE_ICONSTRIP,
// The following apply to HAPI_PARMTYPE_FOLDER type parms
HAPI_PRM_SCRIPT_TYPE_GROUPRADIO = 1000, ///< Radio buttons Folder
HAPI_PRM_SCRIPT_TYPE_GROUPCOLLAPSIBLE, ///< Collapsible Folder
HAPI_PRM_SCRIPT_TYPE_GROUPSIMPLE, ///< Simple Folder
HAPI_PRM_SCRIPT_TYPE_GROUP ///< Tabs Folder
};
HAPI_C_ENUM_TYPEDEF( HAPI_PrmScriptType )
enum HAPI_ChoiceListType
{
HAPI_CHOICELISTTYPE_NONE, ///< Parameter is not a menu.
HAPI_CHOICELISTTYPE_NORMAL, ///< Menu Only, Single Selection
HAPI_CHOICELISTTYPE_MINI, ///< Mini Menu Only, Single Selection
HAPI_CHOICELISTTYPE_REPLACE, ///< Field + Single Selection Menu
HAPI_CHOICELISTTYPE_TOGGLE ///< Field + Multiple Selection Menu
};
HAPI_C_ENUM_TYPEDEF( HAPI_ChoiceListType )
enum HAPI_PresetType
{
HAPI_PRESETTYPE_INVALID = -1,
HAPI_PRESETTYPE_BINARY = 0, ///< Just the presets binary blob.
HAPI_PRESETTYPE_IDX, ///< Presets blob within an .idx file format.
HAPI_PRESETTYPE_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_PresetType )
enum HAPI_NodeType
{
HAPI_NODETYPE_ANY = -1,
HAPI_NODETYPE_NONE = 0,
HAPI_NODETYPE_OBJ = 1 << 0,
HAPI_NODETYPE_SOP = 1 << 1,
HAPI_NODETYPE_CHOP = 1 << 2,
HAPI_NODETYPE_ROP = 1 << 3,
HAPI_NODETYPE_SHOP = 1 << 4,
HAPI_NODETYPE_COP = 1 << 5,
HAPI_NODETYPE_VOP = 1 << 6,
HAPI_NODETYPE_DOP = 1 << 7,
HAPI_NODETYPE_TOP = 1 << 8
};
HAPI_C_ENUM_TYPEDEF( HAPI_NodeType )
typedef int HAPI_NodeTypeBits;
/// Flags used to filter compositions of node lists. Flags marked
/// 'Recursive Flag' will exclude children whos parent does not
/// satisfy the flag, even if the children themselves satisfy the flag.
enum HAPI_NodeFlags
{
HAPI_NODEFLAGS_ANY = -1,
HAPI_NODEFLAGS_NONE = 0,
HAPI_NODEFLAGS_DISPLAY = 1 << 0, ///< Recursive Flag
HAPI_NODEFLAGS_RENDER = 1 << 1, ///< Recursive Flag
HAPI_NODEFLAGS_TEMPLATED = 1 << 2,
HAPI_NODEFLAGS_LOCKED = 1 << 3,
HAPI_NODEFLAGS_EDITABLE = 1 << 4,
HAPI_NODEFLAGS_BYPASS = 1 << 5,
HAPI_NODEFLAGS_NETWORK = 1 << 6,
/// OBJ Node Specific Flags
HAPI_NODEFLAGS_OBJ_GEOMETRY = 1 << 7,
HAPI_NODEFLAGS_OBJ_CAMERA = 1 << 8,
HAPI_NODEFLAGS_OBJ_LIGHT = 1 << 9,
HAPI_NODEFLAGS_OBJ_SUBNET = 1 << 10,
/// SOP Node Specific Flags
HAPI_NODEFLAGS_SOP_CURVE = 1 << 11, ///< Looks for "curve".
HAPI_NODEFLAGS_SOP_GUIDE = 1 << 12, ///< Looks for Guide Geometry
/// TOP Node Specific Flags
HAPI_NODEFLAGS_TOP_NONSCHEDULER = 1 << 13 /// All TOP nodes except schedulers
};
HAPI_C_ENUM_TYPEDEF( HAPI_NodeFlags )
typedef int HAPI_NodeFlagsBits;
enum HAPI_GroupType
{
HAPI_GROUPTYPE_INVALID = -1,
HAPI_GROUPTYPE_POINT,
HAPI_GROUPTYPE_PRIM,
HAPI_GROUPTYPE_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_GroupType )
enum HAPI_AttributeOwner
{
HAPI_ATTROWNER_INVALID = -1,
HAPI_ATTROWNER_VERTEX,
HAPI_ATTROWNER_POINT,
HAPI_ATTROWNER_PRIM,
HAPI_ATTROWNER_DETAIL,
HAPI_ATTROWNER_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_AttributeOwner )
enum HAPI_CurveType
{
HAPI_CURVETYPE_INVALID = -1,
HAPI_CURVETYPE_LINEAR,
HAPI_CURVETYPE_NURBS,
HAPI_CURVETYPE_BEZIER,
HAPI_CURVETYPE_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_CurveType )
enum HAPI_VolumeType
{
HAPI_VOLUMETYPE_INVALID = -1,
HAPI_VOLUMETYPE_HOUDINI,
HAPI_VOLUMETYPE_VDB,
HAPI_VOLUMETYPE_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_VolumeType )
enum HAPI_VolumeVisualType
{
HAPI_VOLUMEVISTYPE_INVALID = -1,
HAPI_VOLUMEVISTYPE_SMOKE,
HAPI_VOLUMEVISTYPE_RAINBOW,
HAPI_VOLUMEVISTYPE_ISO,
HAPI_VOLUMEVISTYPE_INVISIBLE,
HAPI_VOLUMEVISTYPE_HEIGHTFIELD,
HAPI_VOLUMEVISTYPE_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_VolumeVisualType )
enum HAPI_StorageType
{
HAPI_STORAGETYPE_INVALID = -1,
HAPI_STORAGETYPE_INT,
HAPI_STORAGETYPE_INT64,
HAPI_STORAGETYPE_FLOAT,
HAPI_STORAGETYPE_FLOAT64,
HAPI_STORAGETYPE_STRING,
HAPI_STORAGETYPE_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_StorageType )
enum HAPI_AttributeTypeInfo
{
HAPI_ATTRIBUTE_TYPE_INVALID = -1,
HAPI_ATTRIBUTE_TYPE_NONE, // Implicit type based on data
HAPI_ATTRIBUTE_TYPE_POINT, // Position
HAPI_ATTRIBUTE_TYPE_HPOINT, // Homogeneous position
HAPI_ATTRIBUTE_TYPE_VECTOR, // Direction vector
HAPI_ATTRIBUTE_TYPE_NORMAL, // Normal
HAPI_ATTRIBUTE_TYPE_COLOR, // Color
HAPI_ATTRIBUTE_TYPE_QUATERNION, // Quaternion
HAPI_ATTRIBUTE_TYPE_MATRIX3, // 3x3 Matrix
HAPI_ATTRIBUTE_TYPE_MATRIX, // Matrix
HAPI_ATTRIBUTE_TYPE_ST, // Parametric interval
HAPI_ATTRIBUTE_TYPE_HIDDEN, // "Private" (hidden)
HAPI_ATTRIBUTE_TYPE_BOX2, // 2x2 Bounding box
HAPI_ATTRIBUTE_TYPE_BOX, // 3x3 Bounding box
HAPI_ATTRIBUTE_TYPE_TEXTURE, // Texture coordinate
HAPI_ATTRIBUTE_TYPE_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_AttributeTypeInfo )
enum HAPI_GeoType
{
HAPI_GEOTYPE_INVALID = -1,
/// Most geos will be of this type which essentially means a geo
/// not of the other types.
HAPI_GEOTYPE_DEFAULT,
/// An exposed edit node.
/// See @ref HAPI_IntermediateAssetsResults.
HAPI_GEOTYPE_INTERMEDIATE,
/// An input geo that can accept geometry from the host.
/// See @ref HAPI_AssetInputs_MarshallingGeometryIntoHoudini.
HAPI_GEOTYPE_INPUT,
/// A curve.
/// See @ref HAPI_Curves.
HAPI_GEOTYPE_CURVE,
HAPI_GEOTYPE_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_GeoType )
enum HAPI_PartType
{
HAPI_PARTTYPE_INVALID = -1,
HAPI_PARTTYPE_MESH,
HAPI_PARTTYPE_CURVE,
HAPI_PARTTYPE_VOLUME,
HAPI_PARTTYPE_INSTANCER,
HAPI_PARTTYPE_BOX,
HAPI_PARTTYPE_SPHERE,
HAPI_PARTTYPE_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_PartType )
enum HAPI_InputType
{
HAPI_INPUT_INVALID = -1,
HAPI_INPUT_TRANSFORM,
HAPI_INPUT_GEOMETRY,
HAPI_INPUT_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_InputType )
enum HAPI_CurveOrders
{
HAPI_CURVE_ORDER_VARYING = 0,
HAPI_CURVE_ORDER_INVALID = 1,
HAPI_CURVE_ORDER_LINEAR = 2,
HAPI_CURVE_ORDER_QUADRATIC = 3,
HAPI_CURVE_ORDER_CUBIC = 4,
};
HAPI_C_ENUM_TYPEDEF( HAPI_CurveOrders )
enum HAPI_TransformComponent
{
HAPI_TRANSFORM_TX = 0,
HAPI_TRANSFORM_TY,
HAPI_TRANSFORM_TZ,
HAPI_TRANSFORM_RX,
HAPI_TRANSFORM_RY,
HAPI_TRANSFORM_RZ,
HAPI_TRANSFORM_QX,
HAPI_TRANSFORM_QY,
HAPI_TRANSFORM_QZ,
HAPI_TRANSFORM_QW,
HAPI_TRANSFORM_SX,
HAPI_TRANSFORM_SY,
HAPI_TRANSFORM_SZ
};
HAPI_C_ENUM_TYPEDEF( HAPI_TransformComponent )
enum HAPI_RSTOrder
{
HAPI_TRS = 0,
HAPI_TSR,
HAPI_RTS,
HAPI_RST,
HAPI_STR,
HAPI_SRT,
HAPI_RSTORDER_DEFAULT = HAPI_SRT
};
HAPI_C_ENUM_TYPEDEF( HAPI_RSTOrder )
enum HAPI_XYZOrder
{
HAPI_XYZ = 0,
HAPI_XZY,
HAPI_YXZ,
HAPI_YZX,
HAPI_ZXY,
HAPI_ZYX,
HAPI_XYZORDER_DEFAULT = HAPI_XYZ
};
HAPI_C_ENUM_TYPEDEF( HAPI_XYZOrder )
enum HAPI_ImageDataFormat
{
HAPI_IMAGE_DATA_UNKNOWN = -1,
HAPI_IMAGE_DATA_INT8,
HAPI_IMAGE_DATA_INT16,
HAPI_IMAGE_DATA_INT32,
HAPI_IMAGE_DATA_FLOAT16,
HAPI_IMAGE_DATA_FLOAT32,
HAPI_IMAGE_DATA_MAX,
HAPI_IMAGE_DATA_DEFAULT = HAPI_IMAGE_DATA_INT8
};
HAPI_C_ENUM_TYPEDEF( HAPI_ImageDataFormat )
enum HAPI_ImagePacking
{
HAPI_IMAGE_PACKING_UNKNOWN = -1,
HAPI_IMAGE_PACKING_SINGLE, ///< Single Channel
HAPI_IMAGE_PACKING_DUAL, ///< Dual Channel
HAPI_IMAGE_PACKING_RGB, ///< RGB
HAPI_IMAGE_PACKING_BGR, ///< RGB Reversed
HAPI_IMAGE_PACKING_RGBA, ///< RGBA
HAPI_IMAGE_PACKING_ABGR, ///< RGBA Reversed
HAPI_IMAGE_PACKING_MAX,
HAPI_IMAGE_PACKING_DEFAULT3 = HAPI_IMAGE_PACKING_RGB,
HAPI_IMAGE_PACKING_DEFAULT4 = HAPI_IMAGE_PACKING_RGBA
};
HAPI_C_ENUM_TYPEDEF( HAPI_ImagePacking )
/// This enum is to be used with ::HAPI_GetEnvInt() to retrieve basic
/// information about the HAPI implementation currently being linked
/// against. Note that as of HAPI version 2.0, these enum values are
/// guaranteed never to change so you can reliably get this information from
/// any post-2.0 version of HAPI. The same goes for the actual
/// ::HAPI_GetEnvInt() API call.
enum HAPI_EnvIntType
{
HAPI_ENVINT_INVALID = -1,
/// The three components of the Houdini version that HAPI is
/// expecting to link against.
/// @{
HAPI_ENVINT_VERSION_HOUDINI_MAJOR = 100,
HAPI_ENVINT_VERSION_HOUDINI_MINOR = 110,
HAPI_ENVINT_VERSION_HOUDINI_BUILD = 120,
HAPI_ENVINT_VERSION_HOUDINI_PATCH = 130,
/// @}
/// The two components of the Houdini Engine (marketed) version.
/// @{
HAPI_ENVINT_VERSION_HOUDINI_ENGINE_MAJOR = 200,
HAPI_ENVINT_VERSION_HOUDINI_ENGINE_MINOR = 210,
/// @}
/// This is a monotonously increasing API version number that can be used
/// to lock against a certain API for compatibility purposes. Basically,
/// when this number changes code compiled against the HAPI.h methods
/// might no longer compile. Semantic changes to the methods will also
/// cause this version to increase. This number will be reset to 0
/// every time the Houdini Engine version is bumped.
HAPI_ENVINT_VERSION_HOUDINI_ENGINE_API = 220,
HAPI_ENVINT_MAX,
};
HAPI_C_ENUM_TYPEDEF( HAPI_EnvIntType )
/// This enum is to be used with ::HAPI_GetSessionEnvInt() to retrieve basic
/// session-specific information.
enum HAPI_SessionEnvIntType
{
HAPI_SESSIONENVINT_INVALID = -1,
/// License Type. See ::HAPI_License.
HAPI_SESSIONENVINT_LICENSE = 100,
HAPI_SESSIONENVINT_MAX
};
HAPI_C_ENUM_TYPEDEF( HAPI_SessionEnvIntType )
/// [HAPI_CacheProperty]
enum HAPI_CacheProperty
{
/// Current memory usage in MB. Setting this to 0 invokes
/// a cache clear.
HAPI_CACHEPROP_CURRENT,
HAPI_CACHEPROP_HAS_MIN, ///< True if it actually has a minimum size.
HAPI_CACHEPROP_MIN, ///< Min cache memory limit in MB.
HAPI_CACHEPROP_HAS_MAX, ///< True if it actually has a maximum size.
HAPI_CACHEPROP_MAX, ///< Max cache memory limit in MB.
/// How aggressive to cull memory. This only works for:
/// - ::HAPI_CACHE_COP_COOK where:
/// 0 -> Never reduce inactive cache.
/// 1 -> Always reduce inactive cache.
/// - ::HAPI_CACHE_OBJ where:
/// 0 -> Never enforce the max memory limit.
/// 1 -> Always enforce the max memory limit.
/// - ::HAPI_CACHE_SOP where:
/// 0 -> When to Unload = Never
/// When to Limit Max Memory = Never
/// 1-2 -> When to Unload = Based on Flag
/// When to Limit Max Memory = Never
/// 3-4 -> When to Unload = Based on Flag
/// When to Limit Max Memory = Always
/// 5 -> When to Unload = Always
/// When to Limit Max Memory = Always
HAPI_CACHEPROP_CULL_LEVEL,
};
HAPI_C_ENUM_TYPEDEF( HAPI_CacheProperty )
/// Type of sampling for heightfield
enum HAPI_HeightFieldSampling
{
HAPI_HEIGHTFIELD_SAMPLING_CENTER,
HAPI_HEIGHTFIELD_SAMPLING_CORNER
};
HAPI_C_ENUM_TYPEDEF( HAPI_HeightFieldSampling )
/// Used with PDG functions
enum HAPI_PDG_State
{
HAPI_PDG_STATE_READY,
HAPI_PDG_STATE_COOKING,
HAPI_PDG_STATE_MAX,
HAPI_PDG_STATE_MAX_READY_STATE = HAPI_PDG_STATE_READY
};
HAPI_C_ENUM_TYPEDEF( HAPI_PDG_State )
/// Used with PDG functions
enum HAPI_PDG_EventType
{
HAPI_PDG_EVENT_NULL,
HAPI_PDG_EVENT_WORKITEM_ADD,
HAPI_PDG_EVENT_WORKITEM_REMOVE,
HAPI_PDG_EVENT_WORKITEM_STATE_CHANGE,
HAPI_PDG_EVENT_WORKITEM_ADD_DEP,
HAPI_PDG_EVENT_WORKITEM_REMOVE_DEP,
HAPI_PDG_EVENT_WORKITEM_ADD_PARENT,
HAPI_PDG_EVENT_WORKITEM_REMOVE_PARENT,
HAPI_PDG_EVENT_NODE_CLEAR,
HAPI_PDG_EVENT_COOK_ERROR,
HAPI_PDG_EVENT_COOK_WARNING,
HAPI_PDG_EVENT_COOK_COMPLETE,
HAPI_PDG_EVENT_DIRTY_START,
HAPI_PDG_EVENT_DIRTY_STOP,
HAPI_PDG_EVENT_DIRTY_ALL,
HAPI_PDG_EVENT_UI_SELECT,
HAPI_PDG_EVENT_NODE_CREATE,
HAPI_PDG_EVENT_NODE_REMOVE,
HAPI_PDG_EVENT_NODE_RENAME,
HAPI_PDG_EVENT_NODE_CONNECT,
HAPI_PDG_EVENT_NODE_DISCONNECT,
HAPI_PDG_EVENT_WORKITEM_SET_INT,
HAPI_PDG_EVENT_WORKITEM_SET_FLOAT,
HAPI_PDG_EVENT_WORKITEM_SET_STRING,
HAPI_PDG_EVENT_WORKITEM_SET_FILE,
HAPI_PDG_EVENT_WORKITEM_SET_PYOBJECT,
HAPI_PDG_EVENT_WORKITEM_SET_GEOMETRY,
HAPI_PDG_EVENT_WORKITEM_MERGE,
HAPI_PDG_EVENT_WORKITEM_RESULT,
HAPI_PDG_EVENT_WORKITEM_PRIORITY,
HAPI_PDG_EVENT_COOK_START,
HAPI_PDG_EVENT_WORKITEM_ADD_STATIC_ANCESTOR,
HAPI_PDG_EVENT_WORKITEM_REMOVE_STATIC_ANCESTOR,
HAPI_PDG_EVENT_NODE_PROGRESS_UPDATE,
HAPI_PDG_EVENT_BATCH_ITEM_INITIALIZED,
HAPI_PDG_EVENT_ALL,
HAPI_PDG_EVENT_LOG,
HAPI_PDG_EVENT_SCHEDULER_ADDED,
HAPI_PDG_EVENT_SCHEDULER_REMOVED,
HAPI_PDG_EVENT_SET_SCHEDULER,
HAPI_PDG_EVENT_SERVICE_MANAGER_ALL,
HAPI_PDG_CONTEXT_EVENTS
};
HAPI_C_ENUM_TYPEDEF( HAPI_PDG_EventType )
/// Used with PDG functions
enum HAPI_PDG_WorkitemState
{
HAPI_PDG_WORKITEM_UNDEFINED,
HAPI_PDG_WORKITEM_UNCOOKED,
HAPI_PDG_WORKITEM_WAITING,
HAPI_PDG_WORKITEM_SCHEDULED,
HAPI_PDG_WORKITEM_COOKING,
HAPI_PDG_WORKITEM_COOKED_SUCCESS,
HAPI_PDG_WORKITEM_COOKED_CACHE,
HAPI_PDG_WORKITEM_COOKED_FAIL,
HAPI_PDG_WORKITEM_COOKED_CANCEL,
HAPI_PDG_WORKITEM_DIRTY
};
HAPI_C_ENUM_TYPEDEF( HAPI_PDG_WorkitemState )
/////////////////////////////////////////////////////////////////////////////
// Main API Structs
// GENERICS -----------------------------------------------------------------
struct HAPI_API HAPI_Transform
{
float position[ HAPI_POSITION_VECTOR_SIZE ];
float rotationQuaternion[ HAPI_QUATERNION_VECTOR_SIZE ];
float scale[ HAPI_SCALE_VECTOR_SIZE ];
float shear[ HAPI_SHEAR_VECTOR_SIZE ];
HAPI_RSTOrder rstOrder;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_Transform )
struct HAPI_API HAPI_TransformEuler
{
float position[ HAPI_POSITION_VECTOR_SIZE ];
float rotationEuler[ HAPI_EULER_VECTOR_SIZE ];
float scale[ HAPI_SCALE_VECTOR_SIZE ];
float shear[ HAPI_SHEAR_VECTOR_SIZE ];
HAPI_XYZOrder rotationOrder;
HAPI_RSTOrder rstOrder;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_TransformEuler )
// SESSIONS -----------------------------------------------------------------
struct HAPI_API HAPI_Session
{
/// The type of session determines the which implementation will be
/// used to communicate with the Houdini Engine library.
HAPI_SessionType type;
/// Some session types support multiple simultaneous sessions. This means
/// that each session needs to have a unique identifier.
HAPI_SessionId id;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_Session )
/// Options to configure a Thrift server being started from HARC.
struct HAPI_API HAPI_ThriftServerOptions
{
/// Close the server automatically when all clients disconnect from it.
HAPI_Bool autoClose;
/// Timeout in milliseconds for waiting on the server to
/// signal that it's ready to serve. If the server fails
/// to signal within this time interval, the start server call fails
/// and the server process is terminated.
float timeoutMs;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_ThriftServerOptions )
// TIME ---------------------------------------------------------------------
struct HAPI_API HAPI_TimelineOptions
{
float fps;
float startTime;
float endTime;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_TimelineOptions )
// ASSETS -------------------------------------------------------------------
struct HAPI_API HAPI_AssetInfo
{
/// Use the node id to get the asset's parameters.
/// See @ref HAPI_Nodes_Basics.
HAPI_NodeId nodeId;
/// The objectNodeId differs from the regular nodeId in that for
/// geometry based assets (SOPs) it will be the node id of the dummy
/// object (OBJ) node instead of the asset node. For object based assets
/// the objectNodeId will equal the nodeId. The reason the distinction
/// exists is because transforms are always stored on the object node
/// but the asset parameters may not be on the asset node if the asset
/// is a geometry asset so we need both.
HAPI_NodeId objectNodeId;
/// It's possible to instantiate an asset without cooking it.
/// See @ref HAPI_Assets_Cooking.
HAPI_Bool hasEverCooked;
HAPI_StringHandle nameSH; ///< Instance name (the label + a number).
HAPI_StringHandle labelSH; ///< This is what any end user should be shown.
HAPI_StringHandle filePathSH; ///< Path to the .otl library file.
HAPI_StringHandle versionSH; ///< User-defined asset version.
HAPI_StringHandle fullOpNameSH; ///< Full asset name and namespace.
HAPI_StringHandle helpTextSH; ///< Asset help marked-up text.
HAPI_StringHandle helpURLSH; ///< Asset help URL.
int objectCount; ///< See @ref HAPI_Objects.
int handleCount; ///< See @ref HAPI_Handles.
/// Transform inputs exposed by the asset. For OBJ assets this is the
/// number of transform inputs on the OBJ node. For SOP assets, this is
/// the singular transform input on the dummy wrapper OBJ node.
/// See @ref HAPI_AssetInputs.
int transformInputCount;
/// Geometry inputs exposed by the asset. For SOP assets this is
/// the number of geometry inputs on the SOP node itself. OBJ assets
/// will always have zero geometry inputs.
/// See @ref HAPI_AssetInputs.
int geoInputCount;
/// Geometry outputs exposed by the asset. For SOP assets this is
/// the number of geometry outputs on the SOP node itself. OBJ assets
/// will always have zero geometry outputs.
/// See @ref HAPI_AssetInputs.
int geoOutputCount;
/// For incremental updates. Indicates whether any of the assets's
/// objects have changed. Refreshed only during an asset cook.
HAPI_Bool haveObjectsChanged;
/// For incremental updates. Indicates whether any of the asset's
/// materials have changed. Refreshed only during an asset cook.
HAPI_Bool haveMaterialsChanged;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_AssetInfo )
struct HAPI_API HAPI_CookOptions
{
/// Normally, geos are split into parts in two different ways. First it
/// is split by group and within each group it is split by primitive type.
///
/// For example, if you have a geo with group1 covering half of the mesh
/// and volume1 and group2 covering the other half of the mesh, all of
/// curve1, and volume2 you will end up with 5 parts. First two parts
/// will be for the half-mesh of group1 and volume1, and the last three
/// will cover group2.
///
/// This toggle lets you disable the splitting by group and just have
/// the geo be split by primitive type alone. By default, this is true
/// and therefore geos will be split by group and primitive type. If
/// set to false, geos will only be split by primitive type.
HAPI_Bool splitGeosByGroup;
/// This toggle lets you enable the splitting by unique values
/// of a specified attribute. By default, this is false and
/// the geo be split as described above.
/// as described above. If this is set to true, and splitGeosByGroup
/// set to false, mesh geos will be split on attribute values
/// The attribute name to split on must be created with HAPI_SetCustomString
/// and then the splitAttrSH handle set on the struct.
HAPI_Bool splitGeosByAttribute;
HAPI_StringHandle splitAttrSH;
/// For meshes only, this is enforced by convexing the mesh. Use -1
/// to avoid convexing at all and get some performance boost.
int maxVerticesPerPrimitive;
/// For curves only.
/// If this is set to true, then all curves will be refined to a linear
/// curve and you can no longer access the original CVs. You can control
/// the refinement detail via ::HAPI_CookOptions::curveRefineLOD.
/// If it's false, the curve type (NURBS, Bezier etc) will be left as is.
HAPI_Bool refineCurveToLinear;
/// Controls the number of divisions per unit distance when refining
/// a curve to linear. The default in Houdini is 8.0.
float curveRefineLOD;
/// If this option is turned on, then we will recursively clear the
/// errors and warnings (and messages) of all nodes before performing
/// the cook.
HAPI_Bool clearErrorsAndWarnings;
/// Decide whether to recursively cook all templated geos or not.
HAPI_Bool cookTemplatedGeos;
/// Decide whether to split points by vertex attributes. This takes
/// all vertex attributes and tries to copy them to their respective
/// points. If two vertices have any difference in their attribute values,
/// the corresponding point is split into two points. This is repeated
/// until all the vertex attributes have been copied to the points.
///
/// With this option enabled, you can reduce the total number of vertices
/// on a game engine side as sharing of attributes (like UVs) is optimized.
/// To make full use of this feature, you have to think of Houdini points
/// as game engine vertices (sharable). With this option OFF (or before
/// this feature existed) you had to map Houdini vertices to game engine
/// vertices, to make sure all attribute values are accounted for.
HAPI_Bool splitPointsByVertexAttributes;
/// Choose how you want the cook to handle packed primitives.
/// The default is: ::HAPI_PACKEDPRIM_INSTANCING_MODE_DISABLED
HAPI_PackedPrimInstancingMode packedPrimInstancingMode;
/// Choose which special part types should be handled. Unhandled special
/// part types will just be refined to ::HAPI_PARTTYPE_MESH.
HAPI_Bool handleBoxPartTypes;
HAPI_Bool handleSpherePartTypes;
/// If enabled, sets the ::HAPI_PartInfo::hasChanged member during the
/// cook. If disabled, the member will always be true. Checking for
/// part changes can be expensive, so there is a potential performance
/// gain when disabled.
HAPI_Bool checkPartChanges;
/// For internal use only. :)
int extraFlags;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_CookOptions )
// NODES --------------------------------------------------------------------
struct HAPI_API HAPI_NodeInfo
{
HAPI_NodeId id;
HAPI_NodeId parentId;
HAPI_StringHandle nameSH;
HAPI_NodeType type;
/// Always true unless the asset's definition has changed due to loading
/// a duplicate asset definition and from another OTL asset library
/// file OR deleting the OTL asset library file used by this node's asset.
HAPI_Bool isValid;
/// Total number of cooks of this node.
int totalCookCount;
/// Use this unique id to grab the OP_Node pointer for this node.
/// If you're linking against the C++ HDK, include the OP_Node.h header
/// and call OP_Node::lookupNode().
int uniqueHoudiniNodeId;
/// This is the internal node path in the Houdini scene graph. This path
/// is meant to be abstracted away for most client purposes but for
/// advanced uses it can come in handy.
HAPI_StringHandle internalNodePathSH;
/// Total number of parameters this asset has exposed. Includes hidden
/// parameters.
/// See @ref HAPI_Parameters.
int parmCount;
/// Number of values. A single parameter may have more than one value so
/// this number is more than or equal to ::HAPI_NodeInfo::parmCount.
/// @{
int parmIntValueCount;
int parmFloatValueCount;
int parmStringValueCount;
/// @}
/// The total number of choices among all the combo box parameters.
/// See @ref HAPI_Parameters_ChoiceLists.
int parmChoiceCount;
/// The number of child nodes. This is 0 for all nodes that are not
/// node networks.
int childNodeCount;
/// The number of inputs this specific node has.
int inputCount;
/// The number of outputs this specific node has.
int outputCount;
/// Nodes created via scripts or via ::HAPI_CreateNode() will be have
/// this set to true. Only such nodes can be deleted using
/// ::HAPI_DeleteNode().
HAPI_Bool createdPostAssetLoad;
/// Indicates if this node will change over time
HAPI_Bool isTimeDependent;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_NodeInfo )
// PARAMETERS ---------------------------------------------------------------
/// @struct HAPI_ParmInfo
///
/// Contains parameter information like name, label, type, and size.
///
struct HAPI_API HAPI_ParmInfo
{
/// The parent id points to the id of the parent parm
/// of this parm. The parent parm is something like a folder.
HAPI_ParmId id;
/// Parameter id of the parent of this parameter.
HAPI_ParmId parentId;
/// Child index within its immediate parent parameter.
int childIndex;
/// The HAPI type of the parm
HAPI_ParmType type;
/// The Houdini script-type of the parm
HAPI_PrmScriptType scriptType;
/// Some parameter types require additional type information.
/// - File path parameters will indicate what file extensions they
/// expect in a space-separated list of wild-cards. This is set
/// in the Operator Type Properties using the File Pattern
/// parameter property.
/// For example, for filtering by PNG and JPG only: "*.png *.jpg"
HAPI_StringHandle typeInfoSH;
/// For the majority of parameter types permission will not be applicable.
/// For file path parameters these permissions will indicate how the
/// asset plans to use the file: whether it will only read it, only write
/// to it, or both. This is set in the Operator Type Properties using
/// the Browse Mode parameter property.
HAPI_Permissions permissions;
/// Number of tags on this paramter.
int tagCount;
/// Tuple size. For scalar parameters this value is 1, but for vector
/// parameters this value can be greater. For example, a 3 vector would
/// have a size of 3. For folders and folder lists, this value is the
/// number of children they own.
int size;
/// Any ::HAPI_ParmType can be a choice list. If this is set to
/// ::HAPI_CHOICELISTTYPE_NONE, than this parameter is NOT a choice list.
/// Otherwise, the parameter is a choice list of the indicated type.
/// See @ref HAPI_Parameters_ChoiceLists.
HAPI_ChoiceListType choiceListType;
/// Any ::HAPI_ParmType can be a choice list. If the parameter is a
/// choice list, this tells you how many choices it currently has.
/// Note that some menu parameters can have a dynamic number of choices
/// so it is important that this count is re-checked after every cook.
/// See @ref HAPI_Parameters_ChoiceLists.
int choiceCount;
/// Note that folders are not real parameters in Houdini so they do not
/// have names. The folder names given here are generated from the name
/// of the folderlist (or switcher) parameter which is a parameter. The
/// folderlist parameter simply defines how many of the "next" parameters
/// belong to the first folder, how many of the parameters after that
/// belong to the next folder, and so on. This means that folder names
/// can change just by reordering the folders around so don't rely on
/// them too much. The only guarantee here is that the folder names will
/// be unique among all other parameter names.
HAPI_StringHandle nameSH;
/// The label string for the parameter
HAPI_StringHandle labelSH;
/// If this parameter is a multiparm instance than the
/// ::HAPI_ParmInfo::templateNameSH will be the hash-templated parm name,
/// containing #'s for the parts of the name that use the instance number.
/// Compared to the ::HAPI_ParmInfo::nameSH, the ::HAPI_ParmInfo::nameSH
/// will be the ::HAPI_ParmInfo::templateNameSH but with the #'s
/// replaced by the instance number. For regular parms, the
/// ::HAPI_ParmInfo::templateNameSH is identical to the
/// ::HAPI_ParmInfo::nameSH.
HAPI_StringHandle templateNameSH;
/// The help string for this parameter
HAPI_StringHandle helpSH;
/// Whether min/max exists for the parameter values.
/// @{
HAPI_Bool hasMin;
HAPI_Bool hasMax;
HAPI_Bool hasUIMin;
HAPI_Bool hasUIMax;
/// @}
/// Parameter value range, shared between int and float parameters.
/// @{
float min;
float max;
float UIMin;
float UIMax;
/// @}
/// Whether this parm should be hidden from the user entirely. This is
/// mostly used to expose parameters as asset meta-data but not allow the
/// user to directly modify them.
HAPI_Bool invisible;
/// Whether this parm should appear enabled or disabled.
HAPI_Bool disabled;
/// If true, it means this parameter doesn't actually exist on the node
/// in Houdini but was added by Houdini Engine as a spare parameter.
/// This is just for your information. The behaviour of this parameter
/// is not any different than a non-spare parameter.
HAPI_Bool spare;
HAPI_Bool joinNext; ///< Whether this parm should be on the same line as
///< the next parm.
HAPI_Bool labelNone; ///< Whether the label should be displayed.
/// The index to use to look into the values array in order to retrieve
/// the actual value(s) of this parameter.
/// @{
int intValuesIndex;
int floatValuesIndex;
int stringValuesIndex;
int choiceIndex;
/// @}
/// If this is a ::HAPI_PARMTYPE_NODE, this tells you what node types
/// this parameter accepts.
HAPI_NodeType inputNodeType;
/// The node input parameter could have another subtype filter specified,
/// like "Object: Geometry Only". In this case, this value will specify
/// that extra filter. If the filter demands a node that HAPI does not
/// support, both this and ::HAPI_ParmInfo::inputNodeType will be set to
/// NONE as such a node is not settable through HAPI.
HAPI_NodeFlags inputNodeFlag;
/// See @ref HAPI_Parameters_MultiParms.
/// @{
HAPI_Bool isChildOfMultiParm;
int instanceNum; ///< The index of the instance in the multiparm.
int instanceLength; ///< The number of parms in a multiparm instance.
int instanceCount; ///< The number of instances in a multiparm.
/// First instance's ::HAPI_ParmInfo::instanceNum. Either 0 or 1.
int instanceStartOffset;
HAPI_RampType rampType;
/// @}
/// Provides the raw condition string which is used to evaluate the
/// the visibility of a parm
HAPI_StringHandle visibilityConditionSH;
/// Provides the raw condition string which is used to evalute whether
/// a parm is enabled or disabled
HAPI_StringHandle disabledConditionSH;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_ParmInfo )
struct HAPI_API HAPI_ParmChoiceInfo
{
HAPI_ParmId parentParmId;
HAPI_StringHandle labelSH;
/// This evaluates to the value of the token associated with the label
/// applies to string menus only.
HAPI_StringHandle valueSH;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_ParmChoiceInfo )
// HANDLES ------------------------------------------------------------------
/// @struct HAPI_HandleInfo
///
/// Contains handle information such as the type of handle
/// (translate, rotate, scale, softxform ...etc) and the number of
/// parameters the current handle is bound to.
///
struct HAPI_API HAPI_HandleInfo
{
HAPI_StringHandle nameSH;
HAPI_StringHandle typeNameSH;
int bindingsCount;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_HandleInfo )
/// @struct HAPI_HandleBindingInfo
///
/// Contains binding information that maps the handle parameter to
/// the asset parameter. The index is only used for int and float vector
/// and colour parms.
///
struct HAPI_API HAPI_HandleBindingInfo
{
HAPI_StringHandle handleParmNameSH;
HAPI_StringHandle assetParmNameSH;
HAPI_ParmId assetParmId;
int assetParmIndex;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_HandleBindingInfo )
// OBJECTS ------------------------------------------------------------------
struct HAPI_API HAPI_ObjectInfo
{
HAPI_StringHandle nameSH;
/// (deprecated)
HAPI_StringHandle objectInstancePathSH;
/// For incremental updates. Indicates whether the object's transform
/// has changed. Refreshed only during an asset cook.
HAPI_Bool hasTransformChanged;
/// For incremental updates. Indicates whether any of the object's
/// geometry nodes have changed. Refreshed only during an asset cook.
HAPI_Bool haveGeosChanged;
/// Whether the object is hidden and should not be shown. Some objects
/// should be hidden but still brought into the host environment, for
/// example those used only for instancing.
/// See @ref HAPI_Instancing.
HAPI_Bool isVisible;
/// See @ref HAPI_Instancing.
HAPI_Bool isInstancer;
/// Determine if this object is being instanced. Normally, this implies
/// that while this object may not be visible, it should still be
/// brought into the host application because it is needed by an instancer.
/// See @ref HAPI_Instancing.
HAPI_Bool isInstanced;
/// (deprecated) The number of geometries under this object. For those familiar
/// with Houdini, this number will always include the one visible SOP and any
/// SOPs that were exposed as "editable" or "templated".
/// See @ref HAPI_Geos.
int geoCount;
/// Use the node id to get the node's parameters.
/// Using the HDK, you can also get the raw node C++ pointer for this
/// object's internal node.
/// See @ref HAPI_Nodes_Basics.
HAPI_NodeId nodeId;
/// If the object is an instancer, this variable gives the object id of
/// the object that should be instanced.
/// See @ref HAPI_Instancing.
HAPI_NodeId objectToInstanceId;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_ObjectInfo )
// GEOMETRY -----------------------------------------------------------------
struct HAPI_API HAPI_GeoInfo
{
HAPI_GeoType type;
HAPI_StringHandle nameSH;
/// Use the node id to get the node's parameters.
/// Using the HDK, you can also get the raw node C++ pointer for this
/// object's internal node.
HAPI_NodeId nodeId;
/// Whether the SOP node has been exposed by dragging it into the
/// editable nodes section of the asset definition.
HAPI_Bool isEditable;
/// Has the templated flag turned on which means "expose as read-only".
HAPI_Bool isTemplated;
/// Final Result (Display SOP).
HAPI_Bool isDisplayGeo;
/// For incremental updates.
HAPI_Bool hasGeoChanged;
/// (deprecated) This variable is deprecated and should no longer be used.
/// Materials are now separate from parts. They are maintained at the
/// asset level so you only need to check if the material itself has
/// changed via ::HAPI_MaterialInfo::hasChanged instead of the material
/// on the part.
HAPI_Bool hasMaterialChanged;
/// Groups.
/// @{
int pointGroupCount;
int primitiveGroupCount;
/// @}
/// Total number of parts this geometry contains.
/// See @ref HAPI_Parts.
int partCount;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_GeoInfo )
struct HAPI_API HAPI_PartInfo
{
HAPI_PartId id;
HAPI_StringHandle nameSH;
HAPI_PartType type;
int faceCount;
int vertexCount;
int pointCount; ///< Number of points. Note that this is NOT the number
///< of "positions" as "points" may imply. If your
///< geometry has 3 points then set this to 3 and not 3*3.
int attributeCounts[ HAPI_ATTROWNER_MAX ];
/// If this is true, don't display this part. Load its data but then
/// instance it where the corresponding instancer part tells you to
/// instance it.
HAPI_Bool isInstanced;
/// The number of parts that this instancer part is instancing.
/// For example, if we're instancing a curve and a box, they would come
/// across as two parts, hence this count would be two.
/// Call ::HAPI_GetInstancedPartIds() to get the list of ::HAPI_PartId's.
int instancedPartCount;
/// The number of instances that this instancer part is instancing.
/// Using the same example as with ::HAPI_PartInfo::instancedPartCount,
/// if I'm instancing the merge of a curve and a box 5 times, this count
/// would be 5. To be clear, all instanced parts are instanced the same
/// number of times and with the same transform for each instance.
/// Call ::HAPI_GetInstancerPartTransforms() to get the transform of
/// each instance.
int instanceCount;
/// If this is false, the underlying attribute data appear to match that of
/// the previous cook. In this case you may be able to re-used marshaled
/// data from the previous cook.
HAPI_Bool hasChanged;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_PartInfo )
/// See @ref HAPI_Attributes.
struct HAPI_API HAPI_AttributeInfo
{
HAPI_Bool exists;
HAPI_AttributeOwner owner;
HAPI_StorageType storage;
/// When converting from the Houdini native GA geometry format to the
/// GT geometry format HAPI uses, some attributes might change owners.
/// For example, in Houdini GA curves can have points shared by
/// vertices but the GT format only supports curve vertices
/// (no points). This means that if you had point attributes on a curve
/// in Houdini, when it comes out of HAPI those point attributes will now
/// be vertex attributes. In this case, the ::HAPI_AttributeInfo::owner
/// will be set to ::HAPI_ATTROWNER_VERTEX but the
/// ::HAPI_AttributeInfo::originalOwner will be ::HAPI_ATTROWNER_POINT.
HAPI_AttributeOwner originalOwner;
/// Number of attributes. This count will match the number of values
/// given the owner. For example, if the owner is ::HAPI_ATTROWNER_VERTEX
/// this count will be the same as the ::HAPI_PartInfo::vertexCount.
/// To be clear, this is not the number of values in the attribute, rather
/// it is the number of attributes. If your geometry has three 3D points
/// then this count will be 3 (not 3*3) while the
/// ::HAPI_AttributeInfo::tupleSize will be 3.
int count;
/// Number of values per attribute.
/// Note that this is NOT the memory size of the attribute. It is the
/// number of values per attributes. Multiplying this by the
/// size of the ::HAPI_AttributeInfo::storage will give you the memory
/// size per attribute.
int tupleSize;
/// Total number of elements for an array attribute.
/// An array attribute can be thought of as a 2 dimensional array where
/// the 2nd dimension can vary in size for each element in the 1st
/// dimension. Therefore this returns the total number of values in
/// the entire array.
/// This should be used to determine the total storage
/// size needed by multiplying with ::HAPI_AttributeInfo::storage.
/// Note that this will be 0 for a non-array attribute.
HAPI_Int64 totalArrayElements;
/// Attribute type info
/// This is used to help identify the type of data stored in an attribute.
/// Using the type is recommended over using just an attribute's name to identify
/// its purpose.
HAPI_AttributeTypeInfo typeInfo;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_AttributeInfo )
// MATERIALS ----------------------------------------------------------------
struct HAPI_API HAPI_MaterialInfo
{
/// This is the HAPI node id for the SHOP node this material is attached
/// to. Use it to get access to the parameters (which contain the
/// texture paths).
/// IMPORTANT: When the ::HAPI_MaterialInfo::hasChanged is true this
/// @p nodeId could have changed. Do not assume ::HAPI_MaterialInfo::nodeId
/// will never change for a specific material.
HAPI_NodeId nodeId;
HAPI_Bool exists;
HAPI_Bool hasChanged;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_MaterialInfo )
struct HAPI_API HAPI_ImageFileFormat
{
HAPI_StringHandle nameSH;
HAPI_StringHandle descriptionSH;
HAPI_StringHandle defaultExtensionSH;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_ImageFileFormat )
struct HAPI_API HAPI_ImageInfo
{
/// Unlike the other members of this struct changing imageFileFormatNameSH
/// and giving this struct back to HAPI_SetImageInfo() nothing will happen.
/// Use this member variable to derive which image file format will be used
/// by the HAPI_ExtractImageTo...() functions if called with
/// image_file_format_name set to NULL. This way, you can decide whether
/// to ask for a file format conversion (slower) or not (faster).
HAPI_StringHandle imageFileFormatNameSH; // Read-only
int xRes;
int yRes;
HAPI_ImageDataFormat dataFormat;
HAPI_Bool interleaved; ///< ex: true = RGBRGBRGB, false = RRRGGGBBB
HAPI_ImagePacking packing;
/// Adjust the gamma of the image. For anything less than
/// ::HAPI_IMAGE_DATA_INT16, you probably want to leave this as 2.2.
double gamma;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_ImageInfo )
// ANIMATION ----------------------------------------------------------------
struct HAPI_API HAPI_Keyframe
{
float time;
float value;
float inTangent;
float outTangent;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_Keyframe )
// VOLUMES ------------------------------------------------------------------
/// @struct HAPI_VolumeInfo
///
/// This represents a volume primitive but does not contain the actual voxel
/// values, which can be retrieved on a per-tile basis.
///
/// See @ref HAPI_Volumes.
///
struct HAPI_API HAPI_VolumeInfo
{
HAPI_StringHandle nameSH;
HAPI_VolumeType type;
/// Each voxel is identified with an index. The indices will range
/// between:
/// [ ( minX, minY, minZ ), ( minX+xLength, minY+yLength, minZ+zLength ) )
/// @{
int xLength;
int yLength;
int zLength;
int minX;
int minY;
int minZ;
/// @}
/// Number of values per voxel.
/// The tuple size field is 1 for scalars and 3 for vector data.
int tupleSize;
/// Can be either ::HAPI_STORAGETYPE_INT or ::HAPI_STORAGETYPE_FLOAT.
HAPI_StorageType storage;
/// The dimensions of each tile.
/// This can be 8 or 16, denoting an 8x8x8 or 16x16x16 tiles.
int tileSize;
/// The transform of the volume with respect to the lengths.
/// The volume may be positioned anywhere in space.
HAPI_Transform transform;
/// Denotes special situations where the volume tiles are not perfect
/// cubes, but are tapered instead.
HAPI_Bool hasTaper;
/// If there is taper involved, denotes the amount of taper involved.
/// @{
float xTaper;
float yTaper;
/// @}
};
HAPI_C_STRUCT_TYPEDEF( HAPI_VolumeInfo )
/// @struct HAPI_VolumeTileInfo
///
/// A HAPI_VolumeTileInfo represents an cube subarray of the volume.
/// The size of each dimension is HAPI_VoluemInfo::tileSize
/// bbox [(minX, minY, minZ), (minX+tileSize, minY+tileSize, minZ+tileSize))
///
struct HAPI_API HAPI_VolumeTileInfo
{
int minX;
int minY;
int minZ;
HAPI_Bool isValid;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_VolumeTileInfo )
/// @struct HAPI_VolumeVisualInfo
///
/// Describes the visual settings of a volume.
///
struct HAPI_API HAPI_VolumeVisualInfo
{
HAPI_VolumeVisualType type;
float iso;
float density;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_VolumeVisualInfo )
// CURVES -------------------------------------------------------------------
/// @struct HAPI_CurveInfo
///
/// This represents the meta-data associated with a curve mesh (a number
/// of curves of the same type).
struct HAPI_API HAPI_CurveInfo
{
HAPI_CurveType curveType;
int curveCount; ///< The number of curves contained in this curve mesh.
int vertexCount; ///< The number of control vertices (CVs) for all curves.
int knotCount; ///< The number of knots for all curves.
HAPI_Bool isPeriodic;
///< Whether the curves in this curve mesh are periodic.
HAPI_Bool isRational;
///< Whether the curves in this curve mesh are rational.
int order; ///< Order of 1 is invalid. 0 means there is a varying order.
HAPI_Bool hasKnots; ///< Whether the curve has knots.
};
HAPI_C_STRUCT_TYPEDEF( HAPI_CurveInfo )
// BASIC PRIMITIVES ---------------------------------------------------------
struct HAPI_API HAPI_BoxInfo
{
float center[ HAPI_POSITION_VECTOR_SIZE ];
float size[ HAPI_SCALE_VECTOR_SIZE ];
float rotation[ HAPI_EULER_VECTOR_SIZE ];
};
HAPI_C_STRUCT_TYPEDEF( HAPI_BoxInfo )
struct HAPI_API HAPI_SphereInfo
{
float center[ HAPI_POSITION_VECTOR_SIZE ];
float radius;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_SphereInfo )
// PDG Structs --------------------------------------------------------------
struct HAPI_API HAPI_PDG_EventInfo
{
HAPI_NodeId nodeId; /// id of related node
HAPI_PDG_WorkitemId workitemId; /// id of related workitem
HAPI_PDG_WorkitemId dependencyId; /// id of related workitem dependency
int currentState; /// (HAPI_PDG_WorkItemState) value of current state for state change
int lastState; /// (HAPI_PDG_WorkItemState) value of last state for state change
int eventType; /// (HAPI_PDG_EventType) event type
HAPI_StringHandle msgSH; /// String handle of the event message (> 0 if there is a message)
};
HAPI_C_STRUCT_TYPEDEF( HAPI_PDG_EventInfo )
struct HAPI_API HAPI_PDG_WorkitemInfo
{
int index; /// index of the workitem
int numResults; /// number of results reported
HAPI_StringHandle nameSH; /// name of the workitem
};
HAPI_C_STRUCT_TYPEDEF( HAPI_PDG_WorkitemInfo )
struct HAPI_API HAPI_PDG_WorkitemResultInfo
{
int resultSH; /// result string data
int resultTagSH; /// result tag
HAPI_Int64 resultHash; /// hash value of result
};
HAPI_C_STRUCT_TYPEDEF( HAPI_PDG_WorkitemResultInfo )
// SESSIONSYNC --------------------------------------------------------------
/// @struct HAPI_Viewport
///
/// Contains the information for synchronizing viewport between Houdini
/// and other applications. When SessionSync is enabled, Houdini will
/// update this struct with its viewport state. It will also update
/// its own viewport if this struct has changed.
/// The data stored is in Houdini's right-handed Y-up coordinate system.
///
struct HAPI_API HAPI_Viewport
{
/// The world position of the viewport camera's pivot.
float position[ HAPI_POSITION_VECTOR_SIZE ];
/// The direction of the viewport camera stored as a quaternion.
float rotationQuaternion[ HAPI_QUATERNION_VECTOR_SIZE ];
/// The offset from the pivot to the viewport camera's
/// actual world position.
float offset;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_Viewport )
/// @struct HAPI_SessionSyncInfo
///
/// Contains the information for synchronizing general SessionSync
/// state between Houdini and other applications. When SessionSync
/// is enabled, Houdini will update this struct with its state.
/// It will also update its internal state if this struct has
/// changed.
///
struct HAPI_API HAPI_SessionSyncInfo
{
/// Specifies whether Houdini's current time is used for Houdini Engine
/// cooks. This is automatically enabled in SessionSync where
/// Houdini's viewport forces cooks to use Houdini's current time.
/// This is disabled in non-SessionSync mode, but can be toggled to
/// override default behaviour.
HAPI_Bool cookUsingHoudiniTime;
/// Specifies whether viewport synchronization is enabled. If enabled,
/// in SessionSync, Houdini will update its own viewport using
/// ::HAPI_Viewport.
HAPI_Bool syncViewport;
};
HAPI_C_STRUCT_TYPEDEF( HAPI_SessionSyncInfo )
#endif // __HAPI_COMMON_h__
View Git Blame Copy Permalink