#include "maxheap.h"
#include "baseInterface.h"
#include "iparamb2Typedefs.h"
#include "coreexp.h"
#include "strclass.h"
#include "containers/Array.h"
#include "paramtype.h"

Classes
class	FPInterface

class	FPInterfaceDesc

class	FPStaticInterface

class	FPMixinInterface

class	FPFunctionDef

class	FPPropDef

class	FPActionDef

class	FPParamDef

class	FPParams
	This parameters class contains a MaxSDK::Array FPValue's. More...

class	FPEnum

struct	FPEnum::enum_code

class	FPValue

class	FPParamOptions

class	FPValidator

class	FPMacroEmitter

class	IObject

class	MAXException

class	MAXSecurityException
	3ds Max security exception class for function published exceptions. More...

Macros
#define	FP_NO_FUNCTION ((FunctionID)-1)
	Special ID indicating no function bound. More...

#define	FP_NO_ENUM ((EnumID)-1)

#define	NULLINTERFACE_ID Interface_ID(0, 0)

#define	FPINTERFACE_ID Interface_ID(0, 2)

#define	FPMIXININTERFACE_ID Interface_ID(0, 3)

#define	FPINTERFACEDESC_ID Interface_ID(0, 4)

#define	FPS_FAIL 0
	Indicates a failure. More...

#define	FPS_NO_SUCH_FUNCTION -1
	The function called does not exist. More...

#define	FPS_ACTION_DISABLED -2
	The action is disabled. More...

#define	FPS_OK 1
	Indicates a success. More...

#define	FP_ACTIONS 0x0001

#define	FP_MIXIN 0x0002

#define	FP_CORE 0x0004

#define	FP_STATIC_METHODS 0x0008

#define	FP_TEST_INTERFACE 0x0010

#define	FP_SCRIPTED_CLASS 0x1000

#define	FP_TEMPORARY 0x2000

#define	FP_NO_REDRAW 0x0001

#define	FP_VAR_ARGS 0x0002

#define	FP_CLIENT_OWNS_RESULT 0x0004

#define	FP_EMBEDDEDSCRIPTSECURITYFEATURE 0x0008

#define	FP_ACTION 0x0100

#define	FP_HAS_UI 0x0200

#define	FP_ICONRES 0x0400

#define	FP_ICONFILE 0x0800

#define	FP_HAS_SHORTCUT 0x1000

#define	FP_HAS_KEYARGS 0x2000

#define	FPP_HAS_RANGE 0x0001

#define	FPP_HAS_VALIDATOR 0x0002

#define	FPP_IN_PARAM 0x0004

#define	FPP_OUT_PARAM 0x0008

#define	FPP_IN_OUT_PARAM 0x000C

#define	FPP_KEYARG 0x0010

#define	FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_R 0x0040

#define	FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_W 0x0080

#define	FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_RW 0x00C0

#define	DECLARE_DESCRIPTOR(_interface)

#define	DECLARE_DESCRIPTOR_INIT(_interface)

#define	DECLARE_DESCRIPTOR_NDC(_interface)

#define	DECLARE_DESCRIPTOR_INIT_NDC(_interface)

#define	BEGIN_FUNCTION_MAP

#define	BEGIN_FUNCTION_MAP_PARENT(Parent)

#define	END_FUNCTION_MAP

#define	NO_FUNCTION_MAP

#define	FP_FIELD(_type, _v) (_type##_FIELD(_v))

#define	FN_ACTION(_fid, _fn)

#define	FN_PRED(_fid, _fn)

#define	FN_PREDS(_fid1, _fn1, _fid2, _fn2, _fid3, _fn3)

#define	TYPE_FLOAT_FP_FIELD f

#define	TYPE_INT_FP_FIELD i

#define	TYPE_RGBA_FP_FIELD p

#define	TYPE_POINT3_FP_FIELD p

#define	TYPE_FRGBA_FP_FIELD p4

#define	TYPE_POINT4_FP_FIELD p4

#define	TYPE_BOOL_FP_FIELD i

#define	TYPE_ANGLE_FP_FIELD f

#define	TYPE_PCNT_FRAC_FP_FIELD f

#define	TYPE_WORLD_FP_FIELD f

#define	TYPE_STRING_FP_FIELD s

#define	TYPE_FILENAME_FP_FIELD s

#define	TYPE_HSV_FP_FIELD p

#define	TYPE_COLOR_CHANNEL_FP_FIELD f

#define	TYPE_TIMEVALUE_FP_FIELD i

#define	TYPE_RADIOBTN_INDEX_FP_FIELD i

#define	TYPE_MTL_FP_FIELD mtl

#define	TYPE_TEXMAP_FP_FIELD tex

#define	TYPE_BITMAP_FP_FIELD bm

#define	TYPE_INODE_FP_FIELD n

#define	TYPE_REFTARG_FP_FIELD r

#define	TYPE_INDEX_FP_FIELD i

#define	TYPE_MATRIX3_FP_FIELD m

#define	TYPE_VOID_FP_FIELD void_paramtype_bad

#define	TYPE_ENUM_FP_FIELD i

#define	TYPE_INTERVAL_FP_FIELD intvl

#define	TYPE_ANGAXIS_FP_FIELD aa

#define	TYPE_QUAT_FP_FIELD q

#define	TYPE_RAY_FP_FIELD ray

#define	TYPE_POINT2_FP_FIELD p2

#define	TYPE_BITARRAY_FP_FIELD bits

#define	TYPE_CLASS_FP_FIELD cd

#define	TYPE_MESH_FP_FIELD msh

#define	TYPE_OBJECT_FP_FIELD obj

#define	TYPE_CONTROL_FP_FIELD ctrl

#define	TYPE_POINT_FP_FIELD pt

#define	TYPE_TSTR_FP_FIELD tstr

#define	TYPE_IOBJECT_FP_FIELD iobj

#define	TYPE_INTERFACE_FP_FIELD fpi

#define	TYPE_HWND_FP_FIELD hwnd

#define	TYPE_NAME_FP_FIELD s

#define	TYPE_COLOR_FP_FIELD clr

#define	TYPE_ACOLOR_FP_FIELD aclr

#define	TYPE_FPVALUE_FP_FIELD fpv

#define	TYPE_VALUE_FP_FIELD v

#define	TYPE_DWORD_FP_FIELD d

#define	TYPE_bool_FP_FIELD b

#define	TYPE_INTPTR_FP_FIELD intptr

#define	TYPE_INT64_FP_FIELD i64

#define	TYPE_DOUBLE_FP_FIELD dbl

#define	TYPE_BOX3_FP_FIELD b3

#define	TYPE_FLOAT_TAB_FP_FIELD f_tab

#define	TYPE_INT_TAB_FP_FIELD i_tab

#define	TYPE_RGBA_TAB_FP_FIELD p_tab

#define	TYPE_POINT3_TAB_FP_FIELD p_tab

#define	TYPE_FRGBA_TAB_FP_FIELD p4_tab

#define	TYPE_POINT4_TAB_FP_FIELD p4_tab

#define	TYPE_BOOL_TAB_FP_FIELD i_tab

#define	TYPE_ANGLE_TAB_FP_FIELD f_tab

#define	TYPE_PCNT_FRAC_TAB_FP_FIELD f_tab

#define	TYPE_WORLD_TAB_FP_FIELD f_tab

#define	TYPE_STRING_TAB_FP_FIELD s_tab

#define	TYPE_FILENAME_TAB_FP_FIELD s_tab

#define	TYPE_HSV_TAB_FP_FIELD p_tab

#define	TYPE_COLOR_CHANNEL_TAB_FP_FIELD f_tab

#define	TYPE_TIMEVALUE_TAB_FP_FIELD i_tab

#define	TYPE_RADIOBTN_INDEX_TAB_FP_FIELD i_tab

#define	TYPE_MTL_TAB_FP_FIELD mtl_tab

#define	TYPE_TEXMAP_TAB_FP_FIELD tex_tab

#define	TYPE_BITMAP_TAB_FP_FIELD bm_tab

#define	TYPE_INODE_TAB_FP_FIELD n_tab

#define	TYPE_REFTARG_TAB_FP_FIELD r_tab

#define	TYPE_INDEX_TAB_FP_FIELD i_tab

#define	TYPE_MATRIX3_TAB_FP_FIELD m3_tab

#define	TYPE_ENUM_TAB_FP_FIELD i_tab

#define	TYPE_INTERVAL_TAB_FP_FIELD intvl_tab

#define	TYPE_ANGAXIS_TAB_FP_FIELD aa_tab

#define	TYPE_QUAT_TAB_FP_FIELD q_tab

#define	TYPE_RAY_TAB_FP_FIELD ray_tab

#define	TYPE_POINT2_TAB_FP_FIELD p2_tab

#define	TYPE_BITARRAY_TAB_FP_FIELD bits_tab

#define	TYPE_CLASS_TAB_FP_FIELD cd_tab

#define	TYPE_MESH_TAB_FP_FIELD msh_tab

#define	TYPE_OBJECT_TAB_FP_FIELD obj_tab

#define	TYPE_CONTROL_TAB_FP_FIELD ctrl_tab

#define	TYPE_POINT_TAB_FP_FIELD pt_tab

#define	TYPE_TSTR_TAB_FP_FIELD tstr_tab

#define	TYPE_IOBJECT_TAB_FP_FIELD iobj_tab

#define	TYPE_INTERFACE_TAB_FP_FIELD fpi_tab

#define	TYPE_HWND_TAB_FP_FIELD hwnd_tab

#define	TYPE_NAME_TAB_FP_FIELD s_tab

#define	TYPE_COLOR_TAB_FP_FIELD clr_tab

#define	TYPE_ACOLOR_TAB_FP_FIELD aclr_tab

#define	TYPE_FPVALUE_TAB_FP_FIELD fpv_tab

#define	TYPE_VALUE_TAB_FP_FIELD v_tab

#define	TYPE_DWORD_TAB_FP_FIELD d_tab

#define	TYPE_bool_TAB_FP_FIELD b_tab

#define	TYPE_INTPTR_TAB_FP_FIELD intptr_tab

#define	TYPE_INT64_TAB_FP_FIELD i64_tab

#define	TYPE_DOUBLE_TAB_FP_FIELD dbl_tab

#define	TYPE_BOX3_TAB_FP_FIELD b3_tab

#define	TYPE_FLOAT_BP_FP_FIELD fptr

#define	TYPE_INT_BP_FP_FIELD iptr

#define	TYPE_BOOL_BP_FP_FIELD iptr

#define	TYPE_ANGLE_BP_FP_FIELD fptr

#define	TYPE_PCNT_FRAC_BP_FP_FIELD fptr

#define	TYPE_WORLD_BP_FP_FIELD fptr

#define	TYPE_COLOR_CHANNEL_BP_FP_FIELD fptr

#define	TYPE_TIMEVALUE_BP_FP_FIELD iptr

#define	TYPE_RADIOBTN_INDEX_BP_FP_FIELD iptr

#define	TYPE_INDEX_BP_FP_FIELD iptr

#define	TYPE_ENUM_BP_FP_FIELD iptr

#define	TYPE_DWORD_BP_FP_FIELD dptr

#define	TYPE_bool_BP_FP_FIELD bptr

#define	TYPE_INTPTR_BP_FP_FIELD intptrptr

#define	TYPE_INT64_BP_FP_FIELD i64ptr

#define	TYPE_DOUBLE_BP_FP_FIELD dblptr

#define	TYPE_FLOAT_BR_FP_FIELD fptr

#define	TYPE_INT_BR_FP_FIELD iptr

#define	TYPE_RGBA_BR_FP_FIELD p

#define	TYPE_POINT3_BR_FP_FIELD p

#define	TYPE_FRGBA_BR_FP_FIELD p4

#define	TYPE_POINT4_BR_FP_FIELD p4

#define	TYPE_BOOL_BR_FP_FIELD iptr

#define	TYPE_ANGLE_BR_FP_FIELD fptr

#define	TYPE_PCNT_FRAC_BR_FP_FIELD fptr

#define	TYPE_WORLD_BR_FP_FIELD fptr

#define	TYPE_HSV_BR_FP_FIELD p

#define	TYPE_COLOR_CHANNEL_BR_FP_FIELD f

#define	TYPE_TIMEVALUE_BR_FP_FIELD iptr

#define	TYPE_RADIOBTN_INDEX_BR_FP_FIELD iptr

#define	TYPE_BITMAP_BR_FP_FIELD bm

#define	TYPE_INDEX_BR_FP_FIELD iptr

#define	TYPE_ENUM_BR_FP_FIELD iptr

#define	TYPE_REFTARG_BR_FP_FIELD r

#define	TYPE_MATRIX3_BR_FP_FIELD m

#define	TYPE_ANGAXIS_BR_FP_FIELD aa

#define	TYPE_QUAT_BR_FP_FIELD q

#define	TYPE_BITARRAY_BR_FP_FIELD bits

#define	TYPE_RAY_BR_FP_FIELD ray

#define	TYPE_POINT2_BR_FP_FIELD p2

#define	TYPE_MESH_BR_FP_FIELD msh

#define	TYPE_INTERVAL_BR_FP_FIELD intvl

#define	TYPE_POINT_BR_FP_FIELD pt

#define	TYPE_TSTR_BR_FP_FIELD tstr

#define	TYPE_COLOR_BR_FP_FIELD clr

#define	TYPE_ACOLOR_BR_FP_FIELD aclr

#define	TYPE_FPVALUE_BR_FP_FIELD fpv

#define	TYPE_DWORD_BR_FP_FIELD dptr

#define	TYPE_bool_BR_FP_FIELD bptr

#define	TYPE_INTPTR_BR_FP_FIELD intptrptr

#define	TYPE_INT64_BR_FP_FIELD i64ptr

#define	TYPE_DOUBLE_BR_FP_FIELD dblptr

#define	TYPE_BOX3_BR_FP_FIELD b3

#define	TYPE_FLOAT_TAB_BR_FP_FIELD f_tab

#define	TYPE_INT_TAB_BR_FP_FIELD i_tab

#define	TYPE_RGBA_TAB_BR_FP_FIELD p_tab

#define	TYPE_POINT3_TAB_BR_FP_FIELD p_tab

#define	TYPE_FRGBA_TAB_BR_FP_FIELD p4_tab

#define	TYPE_POINT4_TAB_BR_FP_FIELD p4_tab

#define	TYPE_BOOL_TAB_BR_FP_FIELD i_tab

#define	TYPE_ANGLE_TAB_BR_FP_FIELD f_tab

#define	TYPE_PCNT_FRAC_TAB_BR_FP_FIELD f_tab

#define	TYPE_WORLD_TAB_BR_FP_FIELD f_tab

#define	TYPE_STRING_TAB_BR_FP_FIELD s_tab

#define	TYPE_FILENAME_TAB_BR_FP_FIELD s_tab

#define	TYPE_HSV_TAB_BR_FP_FIELD p_tab

#define	TYPE_COLOR_CHANNEL_TAB_BR_FP_FIELD f_tab

#define	TYPE_TIMEVALUE_TAB_BR_FP_FIELD i_tab

#define	TYPE_RADIOBTN_INDEX_TAB_BR_FP_FIELD i_tab

#define	TYPE_MTL_TAB_BR_FP_FIELD mtl_tab

#define	TYPE_TEXMAP_TAB_BR_FP_FIELD tex_tab

#define	TYPE_BITMAP_TAB_BR_FP_FIELD bm_tab

#define	TYPE_INODE_TAB_BR_FP_FIELD n_tab

#define	TYPE_REFTARG_TAB_BR_FP_FIELD r_tab

#define	TYPE_INDEX_TAB_BR_FP_FIELD i_tab

#define	TYPE_ENUM_TAB_BR_FP_FIELD i_tab

#define	TYPE_MATRIX3_TAB_BR_FP_FIELD m3_tab

#define	TYPE_ANGAXIS_TAB_BR_FP_FIELD aa_tab

#define	TYPE_QUAT_TAB_BR_FP_FIELD q_tab

#define	TYPE_BITARRAY_TAB_BR_FP_FIELD bits_tab

#define	TYPE_CLASS_TAB_BR_FP_FIELD cd_tab

#define	TYPE_RAY_TAB_BR_FP_FIELD ray_tab

#define	TYPE_POINT2_TAB_BR_FP_FIELD p2_tab

#define	TYPE_MESH_TAB_BR_FP_FIELD msh_tab

#define	TYPE_OBJECT_TAB_BR_FP_FIELD obj_tab

#define	TYPE_CONTROL_TAB_BR_FP_FIELD ctrl_tab

#define	TYPE_INTERVAL_TAB_BR_FP_FIELD intvl_tab

#define	TYPE_POINT_TAB_BR_FP_FIELD pt_tab

#define	TYPE_HWND_TAB_BR_FP_FIELD hwnd_tab

#define	TYPE_TSTR_TAB_BR_FP_FIELD tstr_tab

#define	TYPE_IOBJECT_TAB_BR_FP_FIELD iobj_tab

#define	TYPE_INTERFACE_TAB_BR_FP_FIELD fpi_tab

#define	TYPE_NAME_TAB_BR_FP_FIELD s_tab

#define	TYPE_COLOR_TAB_BR_FP_FIELD clr_tab

#define	TYPE_ACOLOR_TAB_BR_FP_FIELD aclr_tab

#define	TYPE_FPVALUE_TAB_BR_FP_FIELD fpv_tab

#define	TYPE_VALUE_TAB_BR_FP_FIELD v_tab

#define	TYPE_DWORD_TAB_BR_FP_FIELD d_tab

#define	TYPE_bool_TAB_BR_FP_FIELD b_tab

#define	TYPE_INTPTR_TAB_BR_FP_FIELD intptr_tab

#define	TYPE_INT64_TAB_BR_FP_FIELD i64_tab

#define	TYPE_DOUBLE_TAB_BR_FP_FIELD dbl_tab

#define	TYPE_BOX3_TAB_BR_FP_FIELD b3_tab

#define	TYPE_RGBA_BV_FP_FIELD p

#define	TYPE_POINT3_BV_FP_FIELD p

#define	TYPE_FRGBA_BV_FP_FIELD p4

#define	TYPE_POINT4_BV_FP_FIELD p4

#define	TYPE_HSV_BV_FP_FIELD p

#define	TYPE_BITMAP_BV_FP_FIELD bm

#define	TYPE_MATRIX3_BV_FP_FIELD m

#define	TYPE_ANGAXIS_BV_FP_FIELD aa

#define	TYPE_QUAT_BV_FP_FIELD q

#define	TYPE_BITARRAY_BV_FP_FIELD bits

#define	TYPE_RAY_BV_FP_FIELD ray

#define	TYPE_POINT2_BV_FP_FIELD p2

#define	TYPE_MESH_BV_FP_FIELD msh

#define	TYPE_INTERVAL_BV_FP_FIELD intvl

#define	TYPE_POINT_BV_FP_FIELD pt

#define	TYPE_TSTR_BV_FP_FIELD tstr

#define	TYPE_COLOR_BV_FP_FIELD clr

#define	TYPE_ACOLOR_BV_FP_FIELD aclr

#define	TYPE_FPVALUE_BV_FP_FIELD fpv

#define	TYPE_CLASS_BV_FP_FIELD cd

#define	TYPE_BOX3_BV_FP_FIELD b3

#define	TYPE_FLOAT_TAB_BV_FP_FIELD f_tab

#define	TYPE_INT_TAB_BV_FP_FIELD i_tab

#define	TYPE_RGBA_TAB_BV_FP_FIELD p_tab

#define	TYPE_POINT3_TAB_BV_FP_FIELD p_tab

#define	TYPE_FRGBA_TAB_BV_FP_FIELD p4_tab

#define	TYPE_POINT4_TAB_BV_FP_FIELD p4_tab

#define	TYPE_BOOL_TAB_BV_FP_FIELD i_tab

#define	TYPE_ANGLE_TAB_BV_FP_FIELD f_tab

#define	TYPE_PCNT_FRAC_TAB_BV_FP_FIELD f_tab

#define	TYPE_WORLD_TAB_BV_FP_FIELD f_tab

#define	TYPE_STRING_TAB_BV_FP_FIELD s_tab

#define	TYPE_FILENAME_TAB_BV_FP_FIELD s_tab

#define	TYPE_HSV_TAB_BV_FP_FIELD p_tab

#define	TYPE_COLOR_CHANNEL_TAB_BV_FP_FIELD f_tab

#define	TYPE_TIMEVALUE_TAB_BV_FP_FIELD i_tab

#define	TYPE_RADIOBTN_INDEX_TAB_BV_FP_FIELD i_tab

#define	TYPE_MTL_TAB_BV_FP_FIELD mtl_tab

#define	TYPE_TEXMAP_TAB_BV_FP_FIELD tex_tab

#define	TYPE_BITMAP_TAB_BV_FP_FIELD bm_tab

#define	TYPE_INODE_TAB_BV_FP_FIELD n_tab

#define	TYPE_REFTARG_TAB_BV_FP_FIELD r_tab

#define	TYPE_INDEX_TAB_BV_FP_FIELD i_tab

#define	TYPE_ENUM_TAB_BV_FP_FIELD i_tab

#define	TYPE_MATRIX3_TAB_BV_FP_FIELD m3_tab

#define	TYPE_ANGAXIS_TAB_BV_FP_FIELD aa_tab

#define	TYPE_QUAT_TAB_BV_FP_FIELD q_tab

#define	TYPE_BITARRAY_TAB_BV_FP_FIELD bits_tab

#define	TYPE_CLASS_TAB_BV_FP_FIELD cd_tab

#define	TYPE_RAY_TAB_BV_FP_FIELD ray_tab

#define	TYPE_POINT2_TAB_BV_FP_FIELD p2_tab

#define	TYPE_MESH_TAB_BV_FP_FIELD msh_tab

#define	TYPE_OBJECT_TAB_BV_FP_FIELD obj_tab

#define	TYPE_CONTROL_TAB_BV_FP_FIELD ctrl_tab

#define	TYPE_INTERVAL_TAB_BV_FP_FIELD intvl_tab

#define	TYPE_POINT_TAB_BV_FP_FIELD pt_tab

#define	TYPE_HWND_TAB_BV_FP_FIELD hwnd_tab

#define	TYPE_TSTR_TAB_BV_FP_FIELD tstr_tab

#define	TYPE_IOBJECT_TAB_BV_FP_FIELD iobj_tab

#define	TYPE_INTERFACE_TAB_BV_FP_FIELD fpi_tab

#define	TYPE_NAME_TAB_BV_FP_FIELD s_tab

#define	TYPE_COLOR_TAB_BV_FP_FIELD clr_tab

#define	TYPE_ACOLOR_TAB_BV_FP_FIELD aclr_tab

#define	TYPE_FPVALUE_TAB_BV_FP_FIELD fpv_tab

#define	TYPE_VALUE_TAB_BV_FP_FIELD v_tab

#define	TYPE_DWORD_TAB_BV_FP_FIELD d_tab

#define	TYPE_bool_TAB_BV_FP_FIELD b_tab

#define	TYPE_INTPTR_TAB_BV_FP_FIELD intptr_tab

#define	TYPE_INT64_TAB_BV_FP_FIELD i64_tab

#define	TYPE_DOUBLE_TAB_BV_FP_FIELD dbl_tab

#define	TYPE_BOX3_TAB_BV_FP_FIELD b3_tab

#define	TYPE_FLOAT_FIELD(_v) (((_v).f))

#define	TYPE_INT_FIELD(_v) (((_v).i))

#define	TYPE_RGBA_FIELD(_v) (*((_v).p))

#define	TYPE_POINT3_FIELD(_v) (*((_v).p))

#define	TYPE_FRGBA_FIELD(_v) (*((_v).p4))

#define	TYPE_POINT4_FIELD(_v) (*((_v).p4))

#define	TYPE_BOOL_FIELD(_v) (((_v).i))

#define	TYPE_ANGLE_FIELD(_v) (((_v).f))

#define	TYPE_PCNT_FRAC_FIELD(_v) (((_v).f))

#define	TYPE_WORLD_FIELD(_v) (((_v).f))

#define	TYPE_STRING_FIELD(_v) (((_v).s))

#define	TYPE_FILENAME_FIELD(_v) (((_v).s))

#define	TYPE_HSV_FIELD(_v) (*((_v).p))

#define	TYPE_COLOR_CHANNEL_FIELD(_v) (((_v).f))

#define	TYPE_TIMEVALUE_FIELD(_v) (((_v).i))

#define	TYPE_RADIOBTN_INDEX_FIELD(_v) (((_v).i))

#define	TYPE_MTL_FIELD(_v) (((_v).mtl))

#define	TYPE_TEXMAP_FIELD(_v) (((_v).tex))

#define	TYPE_BITMAP_FIELD(_v) (((_v).bm))

#define	TYPE_INODE_FIELD(_v) (((_v).n))

#define	TYPE_REFTARG_FIELD(_v) (((_v).r))

#define	TYPE_INDEX_FIELD(_v) (((_v).i))

#define	TYPE_ENUM_FIELD(_v) (((_v).i))

#define	TYPE_MATRIX3_FIELD(_v) (*((_v).m))

#define	TYPE_ANGAXIS_FIELD(_v) (*((_v).aa))

#define	TYPE_QUAT_FIELD(_v) (*((_v).q))

#define	TYPE_BITARRAY_FIELD(_v) (((_v).bits))

#define	TYPE_CLASS_FIELD(_v) (((_v).cd))

#define	TYPE_RAY_FIELD(_v) (*((_v).ray))

#define	TYPE_POINT2_FIELD(_v) (*((_v).p2))

#define	TYPE_MESH_FIELD(_v) (((_v).msh))

#define	TYPE_OBJECT_FIELD(_v) (((_v).obj))

#define	TYPE_CONTROL_FIELD(_v) (((_v).ctrl))

#define	TYPE_INTERVAL_FIELD(_v) (*((_v).intvl))

#define	TYPE_POINT_FIELD(_v) (*((_v).pt))

#define	TYPE_TSTR_FIELD(_v) (*((_v).tstr))

#define	TYPE_IOBJECT_FIELD(_v) (((_v).iobj))

#define	TYPE_INTERFACE_FIELD(_v) (((_v).fpi))

#define	TYPE_HWND_FIELD(_v) (((_v).hwnd))

#define	TYPE_NAME_FIELD(_v) (((_v).s))

#define	TYPE_COLOR_FIELD(_v) (((_v).clr))

#define	TYPE_ACOLOR_FIELD(_v) (((_v).aclr))

#define	TYPE_FPVALUE_FIELD(_v) (((_v).fpv))

#define	TYPE_VALUE_FIELD(_v) (((_v).v))

#define	TYPE_DWORD_FIELD(_v) (((_v).d))

#define	TYPE_bool_FIELD(_v) (((_v).b))

#define	TYPE_INTPTR_FIELD(_v) (((_v).intptr))

#define	TYPE_INT64_FIELD(_v) (((_v).i64))

#define	TYPE_DOUBLE_FIELD(_v) (((_v).dbl))

#define	TYPE_BOX3_FIELD(_v) (*((_v).b3))

#define	TYPE_FLOAT_TAB_FIELD(_v) (((_v).f_tab))

#define	TYPE_INT_TAB_FIELD(_v) (((_v).i_tab))

#define	TYPE_RGBA_TAB_FIELD(_v) (((_v).p_tab))

#define	TYPE_POINT3_TAB_FIELD(_v) (((_v).p_tab))

#define	TYPE_FRGBA_TAB_FIELD(_v) (((_v).p4_tab))

#define	TYPE_POINT4_TAB_FIELD(_v) (((_v).p4_tab))

#define	TYPE_BOOL_TAB_FIELD(_v) (((_v).i_tab))

#define	TYPE_ANGLE_TAB_FIELD(_v) (((_v).f_tab))

#define	TYPE_PCNT_FRAC_TAB_FIELD(_v) (((_v).f_tab))

#define	TYPE_WORLD_TAB_FIELD(_v) (((_v).f_tab))

#define	TYPE_STRING_TAB_FIELD(_v) (((_v).s_tab))

#define	TYPE_FILENAME_TAB_FIELD(_v) (((_v).s_tab))

#define	TYPE_HSV_TAB_FIELD(_v) (((_v).p_tab))

#define	TYPE_COLOR_CHANNEL_TAB_FIELD(_v) (((_v).f_tab))

#define	TYPE_TIMEVALUE_TAB_FIELD(_v) (((_v).i_tab))

#define	TYPE_RADIOBTN_INDEX_TAB_FIELD(_v) (((_v).i_tab))

#define	TYPE_MTL_TAB_FIELD(_v) (((_v).mtl_tab))

#define	TYPE_TEXMAP_TAB_FIELD(_v) (((_v).tex_tab))

#define	TYPE_BITMAP_TAB_FIELD(_v) (((_v).bm_tab))

#define	TYPE_INODE_TAB_FIELD(_v) (((_v).n_tab))

#define	TYPE_REFTARG_TAB_FIELD(_v) (((_v).r_tab))

#define	TYPE_INDEX_TAB_FIELD(_v) (((_v).i_tab))

#define	TYPE_ENUM_TAB_FIELD(_v) (((_v).i_tab))

#define	TYPE_MATRIX3_TAB_FIELD(_v) (((_v).m3_tab))

#define	TYPE_ANGAXIS_TAB_FIELD(_v) (((_v).aa_tab))

#define	TYPE_QUAT_TAB_FIELD(_v) (((_v).q_tab))

#define	TYPE_BITARRAY_TAB_FIELD(_v) (((_v).bits_tab))

#define	TYPE_CLASS_TAB_FIELD(_v) (((_v).cd_tab))

#define	TYPE_RAY_TAB_FIELD(_v) (((_v).ray_tab))

#define	TYPE_POINT2_TAB_FIELD(_v) (((_v).p2_tab))

#define	TYPE_MESH_TAB_FIELD(_v) (((_v).msh_tab))

#define	TYPE_OBJECT_TAB_FIELD(_v) (((_v).obj_tab))

#define	TYPE_CONTROL_TAB_FIELD(_v) (((_v).ctrl_tab))

#define	TYPE_INTERVAL_TAB_FIELD(_v) (((_v).intvl_tab))

#define	TYPE_POINT_TAB_FIELD(_v) (((_v).pt_tab))

#define	TYPE_TSTRT_TAB_FIELD(_v) (((_v).tstr_tab))

#define	TYPE_IOBJECT_TAB_FIELD(_v) (((_v).iobj_tab))

#define	TYPE_INTERFACE_TAB_FIELD(_v) (((_v).fpi_tab))

#define	TYPE_HWND_TAB_FIELD(_v) (((_v).hwnd_tab))

#define	TYPE_NAME_TAB_FIELD(_v) (((_v).s_tab))

#define	TYPE_COLOR_TAB_FIELD(_v) (((_v).clr_tab))

#define	TYPE_ACOLOR_TAB_FIELD(_v) (((_v).aclr_tab))

#define	TYPE_FPVALUE_TAB_FIELD(_v) (((_v).fpv_tab))

#define	TYPE_VALUE_TAB_FIELD(_v) (((_v).v_tab))

#define	TYPE_DWORD_TAB_FIELD(_v) (((_v).d_tab))

#define	TYPE_bool_TAB_FIELD(_v) (((_v).b_tab))

#define	TYPE_INTPTR_TAB_FIELD(_v) (((_v).intptr_tab))

#define	TYPE_INT64_TAB_FIELD(_v) (((_v).i64_tab))

#define	TYPE_DOUBLE_TAB_FIELD(_v) (((_v).dbl_tab))

#define	TYPE_BOX3_TAB_FIELD(_v) (((_v).b3_tab))

#define	TYPE_FLOAT_BP_FIELD(_v) (((_v).fptr))

#define	TYPE_INT_BP_FIELD(_v) (((_v).iptr))

#define	TYPE_BOOL_BP_FIELD(_v) (((_v).iptr))

#define	TYPE_ANGLE_BP_FIELD(_v) (((_v).fptr))

#define	TYPE_PCNT_FRAC_BP_FIELD(_v) (((_v).fptr))

#define	TYPE_WORLD_BP_FIELD(_v) (((_v).fptr))

#define	TYPE_COLOR_CHANNEL_BP_FIELD(_v) (((_v).fptr))

#define	TYPE_TIMEVALUE_BP_FIELD(_v) (((_v).iptr))

#define	TYPE_RADIOBTN_INDEX_BP_FIELD(_v) (((_v).iptr))

#define	TYPE_INDEX_BP_FIELD(_v) (((_v).iptr))

#define	TYPE_ENUM_BP_FIELD(_v) (((_v).iptr))

#define	TYPE_DWORD_BP_FIELD(_v) (((_v).dptr))

#define	TYPE_bool_BP_FIELD(_v) (((_v).bptr))

#define	TYPE_INTPTR_BP_FIELD(_v) (((_v).intptrptr))

#define	TYPE_INT64_BP_FIELD(_v) (((_v).i64ptr))

#define	TYPE_DOUBLE_BP_FIELD(_v) (((_v).dblptr))

#define	TYPE_FLOAT_BR_FIELD(_v) (*((_v).fptr))

#define	TYPE_INT_BR_FIELD(_v) (*((_v).iptr))

#define	TYPE_RGBA_BR_FIELD(_v) (*((_v).p))

#define	TYPE_POINT3_BR_FIELD(_v) (*((_v).p))

#define	TYPE_FRGBA_BR_FIELD(_v) (*((_v).p4))

#define	TYPE_POINT4_BR_FIELD(_v) (*((_v).p4))

#define	TYPE_BOOL_BR_FIELD(_v) (*((_v).iptr))

#define	TYPE_ANGLE_BR_FIELD(_v) (*((_v).fptr))

#define	TYPE_PCNT_FRAC_BR_FIELD(_v) (*((_v).fptr))

#define	TYPE_WORLD_BR_FIELD(_v) (*((_v).fptr))

#define	TYPE_HSV_BR_FIELD(_v) (*((_v).p))

#define	TYPE_COLOR_CHANNEL_BR_FIELD(_v) (*((_v).fptr))

#define	TYPE_TIMEVALUE_BR_FIELD(_v) (*((_v).iptr))

#define	TYPE_RADIOBTN_INDEX_BR_FIELD(_v) (*((_v).iptr))

#define	TYPE_BITMAP_BR_FIELD(_v) (*((_v).bm))

#define	TYPE_INDEX_BR_FIELD(_v) (*((_v).iptr))

#define	TYPE_ENUM_BR_FIELD(_v) (*((_v).iptr))

#define	TYPE_REFTARG_BR_FIELD(_v) (*((_v).r))

#define	TYPE_MATRIX3_BR_FIELD(_v) (*((_v).m))

#define	TYPE_ANGAXIS_BR_FIELD(_v) (*((_v).aa))

#define	TYPE_QUAT_BR_FIELD(_v) (*((_v).q))

#define	TYPE_BITARRAY_BR_FIELD(_v) (*((_v).bits))

#define	TYPE_RAY_BR_FIELD(_v) (*((_v).ray))

#define	TYPE_POINT2_BR_FIELD(_v) (*((_v).p2))

#define	TYPE_MESH_BR_FIELD(_v) (*((_v).msh))

#define	TYPE_INTERVAL_BR_FIELD(_v) (*((_v).intvl))

#define	TYPE_POINT_BR_FIELD(_v) (*((_v).pt))

#define	TYPE_TSTR_BR_FIELD(_v) (*((_v).tstr))

#define	TYPE_COLOR_BR_FIELD(_v) (*((_v).clr))

#define	TYPE_ACOLOR_BR_FIELD(_v) (*((_v).aclr))

#define	TYPE_FPVALUE_BR_FIELD(_v) (*((_v).fpv))

#define	TYPE_DWORD_BR_FIELD(_v) (*((_v).dptr))

#define	TYPE_bool_BR_FIELD(_v) (*((_v).bptr))

#define	TYPE_INTPTR_BR_FIELD(_v) (*((_v).intptrptr))

#define	TYPE_INT64_BR_FIELD(_v) (*((_v).i64ptr))

#define	TYPE_DOUBLE_BR_FIELD(_v) (*((_v).dblptr))

#define	TYPE_BOX3_BR_FIELD(_v) (*((_v).b3))

#define	TYPE_FLOAT_TAB_BR_FIELD(_v) (*((_v).f_tab))

#define	TYPE_INT_TAB_BR_FIELD(_v) (*((_v).i_tab))

#define	TYPE_RGBA_TAB_BR_FIELD(_v) (*((_v).p_tab))

#define	TYPE_POINT3_TAB_BR_FIELD(_v) (*((_v).p_tab))

#define	TYPE_FRGBA_TAB_BR_FIELD(_v) (*((_v).p4_tab))

#define	TYPE_POINT4_TAB_BR_FIELD(_v) (*((_v).p4_tab))

#define	TYPE_BOOL_TAB_BR_FIELD(_v) (*((_v).i_tab))

#define	TYPE_ANGLE_TAB_BR_FIELD(_v) (*((_v).f_tab))

#define	TYPE_PCNT_FRAC_TAB_BR_FIELD(_v) (*((_v).f_tab))

#define	TYPE_WORLD_TAB_BR_FIELD(_v) (*((_v).f_tab))

#define	TYPE_STRING_TAB_BR_FIELD(_v) (*((_v).s_tab))

#define	TYPE_FILENAME_TAB_BR_FIELD(_v) (*((_v).s_tab))

#define	TYPE_HSV_TAB_BR_FIELD(_v) (*((_v).p_tab))

#define	TYPE_COLOR_CHANNEL_TAB_BR_FIELD(_v) (*((_v).f_tab))

#define	TYPE_TIMEVALUE_TAB_BR_FIELD(_v) (*((_v).i_tab))

#define	TYPE_RADIOBTN_INDEX_TAB_BR_FIELD(_v) (*((_v).i_tab))

#define	TYPE_MTL_TAB_BR_FIELD(_v) (*((_v).mtl_tab))

#define	TYPE_TEXMAP_TAB_BR_FIELD(_v) (*((_v).tex_tab))

#define	TYPE_BITMAP_TAB_BR_FIELD(_v) (*((_v).bm_tab))

#define	TYPE_INODE_TAB_BR_FIELD(_v) (*((_v).n_tab))

#define	TYPE_REFTARG_TAB_BR_FIELD(_v) (*((_v).r_tab))

#define	TYPE_INDEX_TAB_BR_FIELD(_v) (*((_v).i_tab))

#define	TYPE_ENUM_TAB_BR_FIELD(_v) (*((_v).i_tab))

#define	TYPE_MATRIX3_TAB_BR_FIELD(_v) (*((_v).m3_tab))

#define	TYPE_ANGAXIS_TAB_BR_FIELD(_v) (*((_v).aa_tab))

#define	TYPE_QUAT_TAB_BR_FIELD(_v) (*((_v).q_tab))

#define	TYPE_BITARRAY_TAB_BR_FIELD(_v) (*((_v).bits_tab))

#define	TYPE_CLASS_TAB_BR_FIELD(_v) (*((_v).cd_tab))

#define	TYPE_RAY_TAB_BR_FIELD(_v) (*((_v).ray_tab))

#define	TYPE_POINT2_TAB_BR_FIELD(_v) (*((_v).p2_tab))

#define	TYPE_MESH_TAB_BR_FIELD(_v) (*((_v).msh_tab))

#define	TYPE_OBJECT_TAB_BR_FIELD(_v) (*((_v).obj_tab))

#define	TYPE_CONTROL_TAB_BR_FIELD(_v) (*((_v).ctrl_tab))

#define	TYPE_INTERVAL_TAB_BR_FIELD(_v) (*((_v).intvl_tab))

#define	TYPE_POINT_TAB_BR_FIELD(_v) (*((_v).pt_tab))

#define	TYPE_HWND_TAB_BR_FIELD(_v) (*((_v).hwnd_tab))

#define	TYPE_TSTR_TAB_BR_FIELD(_v) (*((_v).tstr_tab))

#define	TYPE_IOBJECT_TAB_BR_FIELD(_v) (*((_v).iobj_tab))

#define	TYPE_INTERFACE_TAB_BR_FIELD(_v) (*((_v).fpi_tab))

#define	TYPE_NAME_TAB_BR_FIELD(_v) (*((_v).s_tab))

#define	TYPE_COLOR_TAB_BR_FIELD(_v) (*((_v).clr_tab))

#define	TYPE_ACOLOR_TAB_BR_FIELD(_v) (*((_v).aclr_tab))

#define	TYPE_FPVALUE_TAB_BR_FIELD(_v) (*((_v).fpv_tab))

#define	TYPE_VALUE_TAB_BR_FIELD(_v) (*((_v).v_tab))

#define	TYPE_DWORD_TAB_BR_FIELD(_v) (*((_v).d_tab))

#define	TYPE_bool_TAB_BR_FIELD(_v) (*((_v).b_tab))

#define	TYPE_INTPTR_TAB_BR_FIELD(_v) (*((_v).intptr_tab))

#define	TYPE_INT64_TAB_BR_FIELD(_v) (*((_v).i64_tab))

#define	TYPE_DOUBLE_TAB_BR_FIELD(_v) (*((_v).dbl_tab))

#define	TYPE_BOX3_TAB_BR_FIELD(_v) (*((_v).b3_tab))

#define	TYPE_RGBA_BV_FIELD(_v) (*((_v).p))

#define	TYPE_POINT3_BV_FIELD(_v) (*((_v).p))

#define	TYPE_HSV_BV_FIELD(_v) (*((_v).p))

#define	TYPE_FRGBA_BV_FIELD(_v) (*((_v).p4))

#define	TYPE_POINT4_BV_FIELD(_v) (*((_v).p4))

#define	TYPE_BITMAP_BV_FIELD(_v) (*((_v).bm))

#define	TYPE_MATRIX3_BV_FIELD(_v) (*((_v).m))

#define	TYPE_ANGAXIS_BV_FIELD(_v) (*((_v).aa))

#define	TYPE_QUAT_BV_FIELD(_v) (*((_v).q))

#define	TYPE_BITARRAY_BV_FIELD(_v) (*((_v).bits))

#define	TYPE_RAY_BV_FIELD(_v) (*((_v).ray))

#define	TYPE_POINT2_BV_FIELD(_v) (*((_v).p2))

#define	TYPE_MESH_BV_FIELD(_v) (*((_v).msh))

#define	TYPE_INTERVAL_BV_FIELD(_v) (*((_v).intvl))

#define	TYPE_POINT_BV_FIELD(_v) (*((_v).pt))

#define	TYPE_TSTR_BV_FIELD(_v) (*((_v).tstr))

#define	TYPE_COLOR_BV_FIELD(_v) (*((_v).clr))

#define	TYPE_ACOLOR_BV_FIELD(_v) (*((_v).aclr))

#define	TYPE_FPVALUE_BV_FIELD(_v) (*((_v).fpv))

#define	TYPE_CLASS_BV_FIELD(_v) (*((_v).cd))

#define	TYPE_BOX3_BV_FIELD(_v) (*((_v).b3))

#define	TYPE_FLOAT_TAB_BV_FIELD(_v) (*((_v).f_tab))

#define	TYPE_INT_TAB_BV_FIELD(_v) (*((_v).i_tab))

#define	TYPE_RGBA_TAB_BV_FIELD(_v) (*((_v).p_tab))

#define	TYPE_POINT3_TAB_BV_FIELD(_v) (*((_v).p_tab))

#define	TYPE_FRGBA_TAB_BV_FIELD(_v) (*((_v).p4_tab))

#define	TYPE_POINT4_TAB_BV_FIELD(_v) (*((_v).p4_tab))

#define	TYPE_BOOL_TAB_BV_FIELD(_v) (*((_v).i_tab))

#define	TYPE_ANGLE_TAB_BV_FIELD(_v) (*((_v).f_tab))

#define	TYPE_PCNT_FRAC_TAB_BV_FIELD(_v) (*((_v).f_tab))

#define	TYPE_WORLD_TAB_BV_FIELD(_v) (*((_v).f_tab))

#define	TYPE_STRING_TAB_BV_FIELD(_v) (*((_v).s_tab))

#define	TYPE_FILENAME_TAB_BV_FIELD(_v) (*((_v).s_tab))

#define	TYPE_HSV_TAB_BV_FIELD(_v) (*((_v).p_tab))

#define	TYPE_COLOR_CHANNEL_TAB_BV_FIELD(_v) (*((_v).f_tab))

#define	TYPE_TIMEVALUE_TAB_BV_FIELD(_v) (*((_v).i_tab))

#define	TYPE_RADIOBTN_INDEX_TAB_BV_FIELD(_v) (*((_v).i_tab))

#define	TYPE_MTL_TAB_BV_FIELD(_v) (*((_v).mtl_tab))

#define	TYPE_TEXMAP_TAB_BV_FIELD(_v) (*((_v).tex_tab))

#define	TYPE_BITMAP_TAB_BV_FIELD(_v) (*((_v).bm_tab))

#define	TYPE_INODE_TAB_BV_FIELD(_v) (*((_v).n_tab))

#define	TYPE_REFTARG_TAB_BV_FIELD(_v) (*((_v).r_tab))

#define	TYPE_INDEX_TAB_BV_FIELD(_v) (*((_v).i_tab))

#define	TYPE_ENUM_TAB_BV_FIELD(_v) (*((_v).i_tab))

#define	TYPE_MATRIX3_TAB_BV_FIELD(_v) (*((_v).m3_tab))

#define	TYPE_ANGAXIS_TAB_BV_FIELD(_v) (*((_v).aa_tab))

#define	TYPE_QUAT_TAB_BV_FIELD(_v) (*((_v).q_tab))

#define	TYPE_BITARRAY_TAB_BV_FIELD(_v) (*((_v).bits_tab))

#define	TYPE_CLASS_TAB_BV_FIELD(_v) (*((_v).cd_tab))

#define	TYPE_RAY_TAB_BV_FIELD(_v) (*((_v).ray_tab))

#define	TYPE_POINT2_TAB_BV_FIELD(_v) (*((_v).p2_tab))

#define	TYPE_MESH_TAB_BV_FIELD(_v) (*((_v).msh_tab))

#define	TYPE_OBJECT_TAB_BV_FIELD(_v) (*((_v).obj_tab))

#define	TYPE_CONTROL_TAB_BV_FIELD(_v) (*((_v).ctrl_tab))

#define	TYPE_INTERVAL_TAB_BV_FIELD(_v) (*((_v).intvl_tab))

#define	TYPE_POINT_TAB_BV_FIELD(_v) (*((_v).pt_tab))

#define	TYPE_HWND_TAB_BV_FIELD(_v) (*((_v).hwnd_tab))

#define	TYPE_TSTR_TAB_BV_FIELD(_v) (*((_v).tstr_tab))

#define	TYPE_IOBJECT_TAB_BV_FIELD(_v) (*((_v).iobj_tab))

#define	TYPE_INTERFACE_TAB_BV_FIELD(_v) (*((_v).fpi_tab))

#define	TYPE_NAME_TAB_BV_FIELD(_v) (*((_v).s_tab))

#define	TYPE_COLOR_TAB_BV_FIELD(_v) (*((_v).clr_tab))

#define	TYPE_ACOLOR_TAB_BV_FIELD(_v) (*((_v).aclr_tab))

#define	TYPE_FPVALUE_TAB_BV_FIELD(_v) (*((_v).fpv_tab))

#define	TYPE_VALUE_TAB_BV_FIELD(_v) (*((_v).v_tab))

#define	TYPE_DWORD_TAB_BV_FIELD(_v) (*((_v).d_tab))

#define	TYPE_bool_TAB_BV_FIELD(_v) (*((_v).b_tab))

#define	TYPE_INTPTR_TAB_BV_FIELD(_v) (*((_v).intptr_tab))

#define	TYPE_INT64_TAB_BV_FIELD(_v) (*((_v).i64_tab))

#define	TYPE_DOUBLE_TAB_BV_FIELD(_v) (*((_v).dbl_tab))

#define	TYPE_BOX3_TAB_BV_FIELD(_v) (*((_v).b3_tab))

#define	TYPE_FLOAT_RSLT

#define	TYPE_INT_RSLT

#define	TYPE_RGBA_RSLT

#define	TYPE_POINT3_RSLT

#define	TYPE_FRGBA_RSLT

#define	TYPE_POINT4_RSLT

#define	TYPE_BOOL_RSLT

#define	TYPE_ANGLE_RSLT

#define	TYPE_PCNT_FRAC_RSLT

#define	TYPE_WORLD_RSLT

#define	TYPE_STRING_RSLT

#define	TYPE_FILENAME_RSLT

#define	TYPE_HSV_RSLT

#define	TYPE_COLOR_CHANNEL_RSLT

#define	TYPE_TIMEVALUE_RSLT

#define	TYPE_RADIOBTN_INDEX_RSLT

#define	TYPE_MTL_RSLT

#define	TYPE_TEXMAP_RSLT

#define	TYPE_BITMAP_RSLT

#define	TYPE_INODE_RSLT

#define	TYPE_REFTARG_RSLT

#define	TYPE_INDEX_RSLT

#define	TYPE_ENUM_RSLT

#define	TYPE_MATRIX3_RSLT

#define	TYPE_VOID_RSLT

#define	TYPE_INTERVAL_RSLT

#define	TYPE_ANGAXIS_RSLT

#define	TYPE_QUAT_RSLT

#define	TYPE_RAY_RSLT

#define	TYPE_POINT2_RSLT

#define	TYPE_BITARRAY_RSLT

#define	TYPE_CLASS_RSLT

#define	TYPE_MESH_RSLT

#define	TYPE_OBJECT_RSLT

#define	TYPE_CONTROL_RSLT

#define	TYPE_POINT_RSLT

#define	TYPE_TSTR_RSLT

#define	TYPE_IOBJECT_RSLT

#define	TYPE_INTERFACE_RSLT

#define	TYPE_HWND_RSLT

#define	TYPE_NAME_RSLT

#define	TYPE_COLOR_RSLT

#define	TYPE_ACOLOR_RSLT

#define	TYPE_FPVALUE_RSLT

#define	TYPE_VALUE_RSLT

#define	TYPE_DWORD_RSLT

#define	TYPE_bool_RSLT

#define	TYPE_INTPTR_RSLT

#define	TYPE_INT64_RSLT

#define	TYPE_DOUBLE_RSLT

#define	TYPE_BOX3_RSLT

#define	TYPE_FLOAT_TAB_RSLT

#define	TYPE_INT_TAB_RSLT

#define	TYPE_RGBA_TAB_RSLT

#define	TYPE_POINT3_TAB_RSLT

#define	TYPE_FRGBA_TAB_RSLT

#define	TYPE_POINT4_TAB_RSLT

#define	TYPE_BOOL_TAB_RSLT

#define	TYPE_ANGLE_TAB_RSLT

#define	TYPE_PCNT_FRAC_TAB_RSLT

#define	TYPE_WORLD_TAB_RSLT

#define	TYPE_STRING_TAB_RSLT

#define	TYPE_FILENAME_TAB_RSLT

#define	TYPE_HSV_TAB_RSLT

#define	TYPE_COLOR_CHANNEL_TAB_RSLT

#define	TYPE_TIMEVALUE_TAB_RSLT

#define	TYPE_RADIOBTN_INDEX_TAB_RSLT

#define	TYPE_MTL_TAB_RSLT

#define	TYPE_TEXMAP_TAB_RSLT

#define	TYPE_BITMAP_TAB_RSLT

#define	TYPE_INODE_TAB_RSLT

#define	TYPE_REFTARG_TAB_RSLT

#define	TYPE_INDEX_TAB_RSLT

#define	TYPE_ENUM_TAB_RSLT

#define	TYPE_MATRIX3_TAB_RSLT

#define	TYPE_INTERVAL_TAB_RSLT

#define	TYPE_ANGAXIS_TAB_RSLT

#define	TYPE_QUAT_TAB_RSLT

#define	TYPE_RAY_TAB_RSLT

#define	TYPE_POINT2_TAB_RSLT

#define	TYPE_BITARRAY_TAB_RSLT

#define	TYPE_CLASS_TAB_RSLT

#define	TYPE_MESH_TAB_RSLT

#define	TYPE_OBJECT_TAB_RSLT

#define	TYPE_CONTROL_TAB_RSLT

#define	TYPE_POINT_TAB_RSLT

#define	TYPE_TSTR_TAB_RSLT

#define	TYPE_IOBJECT_TAB_RSLT

#define	TYPE_INTERFACE_TAB_RSLT

#define	TYPE_HWND_TAB_RSLT

#define	TYPE_NAME_TAB_RSLT

#define	TYPE_COLOR_TAB_RSLT

#define	TYPE_ACOLOR_TAB_RSLT

#define	TYPE_FPVALUE_TAB_RSLT

#define	TYPE_VALUE_TAB_RSLT

#define	TYPE_DWORD_TAB_RSLT

#define	TYPE_bool_TAB_RSLT

#define	TYPE_INTPTR_TAB_RSLT

#define	TYPE_INT64_TAB_RSLT

#define	TYPE_DOUBLE_TAB_RSLT

#define	TYPE_BOX3_TAB_RSLT

#define	TYPE_FLOAT_BP_RSLT

#define	TYPE_INT_BP_RSLT

#define	TYPE_BOOL_BP_RSLT

#define	TYPE_ANGLE_BP_RSLT

#define	TYPE_PCNT_FRAC_BP_RSLT

#define	TYPE_WORLD_BP_RSLT

#define	TYPE_COLOR_CHANNEL_BP_RSLT

#define	TYPE_TIMEVALUE_BP_RSLT

#define	TYPE_RADIOBTN_INDEX_BP_RSLT

#define	TYPE_INDEX_BP_RSLT

#define	TYPE_ENUM_BP_RSLT

#define	TYPE_DWORD_BP_RSLT

#define	TYPE_bool_BP_RSLT

#define	TYPE_INTPTR_BP_RSLT

#define	TYPE_INT64_BP_RSLT

#define	TYPE_DOUBLE_BP_RSLT

#define	TYPE_FLOAT_BR_RSLT &

#define	TYPE_INT_BR_RSLT &

#define	TYPE_RGBA_BR_RSLT &

#define	TYPE_POINT3_BR_RSLT &

#define	TYPE_FRGBA_BR_RSLT &

#define	TYPE_POINT4_BR_RSLT &

#define	TYPE_BOOL_BR_RSLT &

#define	TYPE_ANGLE_BR_RSLT &

#define	TYPE_PCNT_FRAC_BR_RSLT &

#define	TYPE_WORLD_BR_RSLT &

#define	TYPE_HSV_BR_RSLT &

#define	TYPE_COLOR_CHANNEL_BR_RSLT &

#define	TYPE_TIMEVALUE_BR_RSLT &

#define	TYPE_RADIOBTN_INDEX_BR_RSLT &

#define	TYPE_BITMAP_BR_RSLT &

#define	TYPE_INDEX_BR_RSLT &

#define	TYPE_ENUM_BR_RSLT &

#define	TYPE_REFTARG_BR_RSLT &

#define	TYPE_MATRIX3_BR_RSLT &

#define	TYPE_ANGAXIS_BR_RSLT &

#define	TYPE_QUAT_BR_RSLT &

#define	TYPE_BITARRAY_BR_RSLT &

#define	TYPE_RAY_BR_RSLT &

#define	TYPE_POINT2_BR_RSLT &

#define	TYPE_MESH_BR_RSLT &

#define	TYPE_INTERVAL_BR_RSLT &

#define	TYPE_POINT_BR_RSLT &

#define	TYPE_TSTR_BR_RSLT &

#define	TYPE_COLOR_BR_RSLT &

#define	TYPE_ACOLOR_BR_RSLT &

#define	TYPE_FPVALUE_BR_RSLT &

#define	TYPE_DWORD_BR_RSLT &

#define	TYPE_bool_BR_RSLT &

#define	TYPE_INTPTR_BR_RSLT &

#define	TYPE_INT64_BR_RSLT &

#define	TYPE_DOUBLE_BR_RSLT &

#define	TYPE_BOX3_BR_RSLT &

#define	TYPE_FLOAT_TAB_BR_RSLT &

#define	TYPE_INT_TAB_BR_RSLT &

#define	TYPE_RGBA_TAB_BR_RSLT &

#define	TYPE_POINT3_TAB_BR_RSLT &

#define	TYPE_FRGBA_TAB_BR_RSLT &

#define	TYPE_POINT4_TAB_BR_RSLT &

#define	TYPE_BOOL_TAB_BR_RSLT &

#define	TYPE_ANGLE_TAB_BR_RSLT &

#define	TYPE_PCNT_FRAC_TAB_BR_RSLT &

#define	TYPE_WORLD_TAB_BR_RSLT &

#define	TYPE_STRING_TAB_BR_RSLT &

#define	TYPE_FILENAME_TAB_BR_RSLT &

#define	TYPE_HSV_TAB_BR_RSLT &

#define	TYPE_COLOR_CHANNEL_TAB_BR_RSLT &

#define	TYPE_TIMEVALUE_TAB_BR_RSLT &

#define	TYPE_RADIOBTN_INDEX_TAB_BR_RSLT &

#define	TYPE_MTL_TAB_BR_RSLT &

#define	TYPE_TEXMAP_TAB_BR_RSLT &

#define	TYPE_BITMAP_TAB_BR_RSLT &

#define	TYPE_INODE_TAB_BR_RSLT &

#define	TYPE_REFTARG_TAB_BR_RSLT &

#define	TYPE_INDEX_TAB_BR_RSLT &

#define	TYPE_ENUM_TAB_BR_RSLT &

#define	TYPE_MATRIX3_TAB_BR_RSLT &

#define	TYPE_ANGAXIS_TAB_BR_RSLT &

#define	TYPE_QUAT_TAB_BR_RSLT &

#define	TYPE_BITARRAY_TAB_BR_RSLT &

#define	TYPE_CLASS_TAB_BR_RSLT &

#define	TYPE_RAY_TAB_BR_RSLT &

#define	TYPE_POINT2_TAB_BR_RSLT &

#define	TYPE_MESH_TAB_BR_RSLT &

#define	TYPE_OBJECT_TAB_BR_RSLT &

#define	TYPE_CONTROL_TAB_BR_RSLT &

#define	TYPE_INTERVAL_TAB_BR_RSLT &

#define	TYPE_POINT_TAB_BR_RSLT &

#define	TYPE_HWND_TAB_BR_RSLT &

#define	TYPE_TSTR_TAB_BR_RSLT &

#define	TYPE_IOBJECT_TAB_BR_RSLT &

#define	TYPE_INTERFACE_TAB_BR_RSLT &

#define	TYPE_NAME_TAB_BR_RSLT &

#define	TYPE_COLOR_TAB_BR_RSLT &

#define	TYPE_ACOLOR_TAB_BR_RSLT &

#define	TYPE_FPVALUE_TAB_BR_RSLT &

#define	TYPE_VALUE_TAB_BR_RSLT &

#define	TYPE_DWORD_TAB_BR_RSLT &

#define	TYPE_bool_TAB_BR_RSLT &

#define	TYPE_INTPTR_TAB_BR_RSLT &

#define	TYPE_INT64_TAB_BR_RSLT &

#define	TYPE_DOUBLE_TAB_BR_RSLT &

#define	TYPE_BOX3_TAB_BR_RSLT &

#define	TYPE_RGBA_BV_RSLT &

#define	TYPE_POINT3_BV_RSLT &

#define	TYPE_HSV_BV_RSLT &

#define	TYPE_FRGBA_BV_RSLT &

#define	TYPE_POINT4_BV_RSLT &

#define	TYPE_BITMAP_BV_RSLT &

#define	TYPE_MATRIX3_BV_RSLT &

#define	TYPE_ANGAXIS_BV_RSLT &

#define	TYPE_QUAT_BV_RSLT &

#define	TYPE_BITARRAY_BV_RSLT &

#define	TYPE_RAY_BV_RSLT &

#define	TYPE_POINT2_BV_RSLT &

#define	TYPE_MESH_BV_RSLT &

#define	TYPE_INTERVAL_BV_RSLT &

#define	TYPE_POINT_BV_RSLT &

#define	TYPE_TSTR_BV_RSLT &

#define	TYPE_COLOR_BV_RSLT &

#define	TYPE_ACOLOR_BV_RSLT &

#define	TYPE_FPVALUE_BV_RSLT &

#define	TYPE_CLASS_BV_RSLT &

#define	TYPE_BOX3_BV_RSLT &

#define	TYPE_FLOAT_TAB_BV_RSLT &

#define	TYPE_INT_TAB_BV_RSLT &

#define	TYPE_RGBA_TAB_BV_RSLT &

#define	TYPE_POINT3_TAB_BV_RSLT &

#define	TYPE_FRGBA_TAB_BV_RSLT &

#define	TYPE_POINT4_TAB_BV_RSLT &

#define	TYPE_BOOL_TAB_BV_RSLT &

#define	TYPE_ANGLE_TAB_BV_RSLT &

#define	TYPE_PCNT_FRAC_TAB_BV_RSLT &

#define	TYPE_WORLD_TAB_BV_RSLT &

#define	TYPE_STRING_TAB_BV_RSLT &

#define	TYPE_FILENAME_TAB_BV_RSLT &

#define	TYPE_HSV_TAB_BV_RSLT &

#define	TYPE_COLOR_CHANNEL_TAB_BV_RSLT &

#define	TYPE_TIMEVALUE_TAB_BV_RSLT &

#define	TYPE_RADIOBTN_INDEX_TAB_BV_RSLT &

#define	TYPE_MTL_TAB_BV_RSLT &

#define	TYPE_TEXMAP_TAB_BV_RSLT &

#define	TYPE_BITMAP_TAB_BV_RSLT &

#define	TYPE_INODE_TAB_BV_RSLT &

#define	TYPE_REFTARG_TAB_BV_RSLT &

#define	TYPE_INDEX_TAB_BV_RSLT &

#define	TYPE_ENUM_TAB_BV_RSLT &

#define	TYPE_MATRIX3_TAB_BV_RSLT &

#define	TYPE_ANGAXIS_TAB_BV_RSLT &

#define	TYPE_QUAT_TAB_BV_RSLT &

#define	TYPE_BITARRAY_TAB_BV_RSLT &

#define	TYPE_CLASS_TAB_BV_RSLT &

#define	TYPE_RAY_TAB_BV_RSLT &

#define	TYPE_POINT2_TAB_BV_RSLT &

#define	TYPE_MESH_TAB_BV_RSLT &

#define	TYPE_OBJECT_TAB_BV_RSLT &

#define	TYPE_CONTROL_TAB_BV_RSLT &

#define	TYPE_INTERVAL_TAB_BV_RSLT &

#define	TYPE_POINT_TAB_BV_RSLT &

#define	TYPE_HWND_TAB_BV_RSLT &

#define	TYPE_TSTR_TAB_BV_RSLT &

#define	TYPE_IOBJECT_TAB_BV_RSLT &

#define	TYPE_INTERFACE_TAB_BV_RSLT &

#define	TYPE_NAME_TAB_BV_RSLT &

#define	TYPE_COLOR_TAB_BV_RSLT &

#define	TYPE_ACOLOR_TAB_BV_RSLT &

#define	TYPE_FPVALUE_TAB_BV_RSLT &

#define	TYPE_VALUE_TAB_BV_RSLT &

#define	TYPE_DWORD_TAB_BV_RSLT &

#define	TYPE_bool_TAB_BV_RSLT &

#define	TYPE_INTPTR_TAB_BV_RSLT &

#define	TYPE_INT64_TAB_BV_RSLT &

#define	TYPE_DOUBLE_TAB_BV_RSLT &

#define	TYPE_BOX3_TAB_BV_RSLT &

#define	TYPE_FLOAT_TYPE float

#define	TYPE_INT_TYPE int

#define	TYPE_RGBA_TYPE Point3

#define	TYPE_POINT3_TYPE Point3

#define	TYPE_FRGBA_TYPE Point4

#define	TYPE_POINT4_TYPE Point4

#define	TYPE_BOOL_TYPE BOOL

#define	TYPE_ANGLE_TYPE float

#define	TYPE_PCNT_FRAC_TYPE float

#define	TYPE_WORLD_TYPE float

#define	TYPE_STRING_TYPE const MCHAR*

#define	TYPE_FILENAME_TYPE const MCHAR*

#define	TYPE_HSV_TYPE Point3

#define	TYPE_COLOR_CHANNEL_TYPE float

#define	TYPE_TIMEVALUE_TYPE int

#define	TYPE_RADIOBTN_INDEX_TYPE int

#define	TYPE_MTL_TYPE Mtl*

#define	TYPE_TEXMAP_TYPE Texmap*

#define	TYPE_BITMAP_TYPE PBBitmap*

#define	TYPE_INODE_TYPE INode*

#define	TYPE_REFTARG_TYPE ReferenceTarget*

#define	TYPE_INDEX_TYPE int

#define	TYPE_ENUM_TYPE int

#define	TYPE_MATRIX3_TYPE Matrix*

#define	TYPE_VOID_TYPE void

#define	TYPE_INTERVAL_TYPE Interval*

#define	TYPE_ANGAXIS_TYPE AngAxis*

#define	TYPE_QUAT_TYPE Quat*

#define	TYPE_RAY_TYPE Ray*

#define	TYPE_POINT2_TYPE Point2*

#define	TYPE_BITARRAY_TYPE BitArray*

#define	TYPE_CLASS_TYPE ClassID*

#define	TYPE_MESH_TYPE Mesh*

#define	TYPE_OBJECT_TYPE Object*

#define	TYPE_CONTROL_TYPE Control*

#define	TYPE_POINT_TYPE POINT*

#define	TYPE_TSTR_TYPE MSTR*

#define	TYPE_IOBJECT_TYPE IObject*

#define	TYPE_INTERFACE_TYPE FPInterface*

#define	TYPE_HWND_TYPE HWND

#define	TYPE_NAME_TYPE const MCHAR*

#define	TYPE_COLOR_TYPE Color*

#define	TYPE_ACOLOR_TYPE AColor*

#define	TYPE_FPVALUE_TYPE FPValue*

#define	TYPE_VALUE_TYPE Value*

#define	TYPE_DWORD_TYPE DWORD

#define	TYPE_bool_TYPE bool

#define	TYPE_INTPTR_TYPE INT_PTR

#define	TYPE_INT64_TYPE INT64

#define	TYPE_DOUBLE_TYPE double

#define	TYPE_BOX3_TYPE Box3*

#define	TYPE_FLOAT_TAB_TYPE Tab<float>*

#define	TYPE_INT_TAB_TYPE Tab<int>*

#define	TYPE_RGBA_TAB_TYPE Tab<Point3>*

#define	TYPE_POINT3_TAB_TYPE Tab<Point3>*

#define	TYPE_FRGBA_TAB_TYPE Tab<Point4>*

#define	TYPE_POINT4_TAB_TYPE Tab<Point4>*

#define	TYPE_BOOL_TAB_TYPE Tab<BOOL>*

#define	TYPE_ANGLE_TAB_TYPE Tab<float>*

#define	TYPE_PCNT_FRAC_TAB_TYPE Tab<float>*

#define	TYPE_WORLD_TAB_TYPE Tab<float>*

#define	TYPE_STRING_TAB_TYPE Tab<const MCHAR>

#define	TYPE_FILENAME_TAB_TYPE Tab<const MCHAR>

#define	TYPE_HSV_TAB_TYPE Tab<Point3>*

#define	TYPE_COLOR_CHANNEL_TAB_TYPE Tab<float>*

#define	TYPE_TIMEVALUE_TAB_TYPE Tab<int>*

#define	TYPE_RADIOBTN_INDEX_TAB_TYPE Tab<int>*

#define	TYPE_MTL_TAB_TYPE Tab<Mtl>

#define	TYPE_TEXMAP_TAB_TYPE Tab<Texmap>

#define	TYPE_BITMAP_TAB_TYPE Tab<PBBitmap>

#define	TYPE_INODE_TAB_TYPE Tab<INode>

#define	TYPE_REFTARG_TAB_TYPE Tab<ReferenceTarget>

#define	TYPE_INDEX_TAB_TYPE Tab<int>*

#define	TYPE_ENUM_TAB_TYPE Tab<int>*

#define	TYPE_MATRIX3_TAB_TYPE Tab<Matrix>

#define	TYPE_VOID_TAB_TYPE Tab<void>*

#define	TYPE_INTERVAL_TAB_TYPE Tab<Interval>

#define	TYPE_ANGAXIS_TAB_TYPE Tab<AngAxis>

#define	TYPE_QUAT_TAB_TYPE Tab<Quat>

#define	TYPE_RAY_TAB_TYPE Tab<Ray>

#define	TYPE_POINT2_TAB_TYPE Tab<Point2>

#define	TYPE_BITARRAY_TAB_TYPE Tab<BitArray>

#define	TYPE_CLASS_TAB_TYPE Tab<ClassID>

#define	TYPE_MESH_TAB_TYPE Tab<Mesh>

#define	TYPE_OBJECT_TAB_TYPE Tab<Object>

#define	TYPE_CONTROL_TAB_TYPE Tab<Control>

#define	TYPE_POINT_TAB_TYPE Tab<POINT>

#define	TYPE_TSTR_TAB_TYPE Tab<MSTR>

#define	TYPE_IOBJECT_TAB_TYPE Tab<IObject>

#define	TYPE_INTERFACE_TAB_TYPE Tab<FPInterface>

#define	TYPE_HWND_TAB_TYPE Tab<HWND>*

#define	TYPE_NAME_TAB_TYPE Tab<const MCHAR>

#define	TYPE_COLOR_TAB_TYPE Tab<Color>

#define	TYPE_ACOLOR_TAB_TYPE Tab<AColor>

#define	TYPE_FPVALUE_TAB_TYPE Tab<FPValue>

#define	TYPE_VALUE_TAB_TYPE Tab<Value>

#define	TYPE_DWORD_TAB_TYPE Tab<DWORD>*

#define	TYPE_bool_TAB_TYPE Tab<bool>*

#define	TYPE_INTPTR_TAB_TYPE Tab<INT_PTR>*

#define	TYPE_INT64_TAB_TYPE Tab<INT64>*

#define	TYPE_DOUBLE_TAB_TYPE Tab<double>*

#define	TYPE_BOX3_TAB_TYPE Tab<Box3>

#define	TYPE_FLOAT_BP_TYPE float*

#define	TYPE_INT_BP_TYPE int*

#define	TYPE_BOOL_BP_TYPE int*

#define	TYPE_ANGLE_BP_TYPE float*

#define	TYPE_PCNT_FRAC_BP_TYPE float*

#define	TYPE_WORLD_BP_TYPE float*

#define	TYPE_COLOR_CHANNEL_BP_TYPE float*

#define	TYPE_TIMEVALUE_BP_TYPE int*

#define	TYPE_RADIOBTN_INDEX_BP_TYPE int*

#define	TYPE_INDEX_BP_TYPE int*

#define	TYPE_ENUM_BP_TYPE int*

#define	TYPE_DWORD_BP_TYPE DWORD*

#define	TYPE_bool_BP_TYPE bool*

#define	TYPE_INTPTR_BP_TYPE INT_PTR*

#define	TYPE_INT64_BP_TYPE INT64*

#define	TYPE_DOUBLE_BP_TYPE double*

#define	TYPE_FLOAT_BR_TYPE float&

#define	TYPE_INT_BR_TYPE int&

#define	TYPE_RGBA_BR_TYPE Point3&

#define	TYPE_POINT3_BR_TYPE Point3&

#define	TYPE_FRGBA_BR_TYPE Point4&

#define	TYPE_POINT4_BR_TYPE Point4&

#define	TYPE_BOOL_BR_TYPE int&

#define	TYPE_ANGLE_BR_TYPE float&

#define	TYPE_PCNT_FRAC_BR_TYPE float&

#define	TYPE_WORLD_BR_TYPE float&

#define	TYPE_HSV_BR_TYPE Point3&

#define	TYPE_COLOR_CHANNEL_BR_TYPE float&

#define	TYPE_TIMEVALUE_BR_TYPE int&

#define	TYPE_RADIOBTN_INDEX_BR_TYPE int&

#define	TYPE_BITMAP_BR_TYPE PBBitmap&

#define	TYPE_INDEX_BR_TYPE int&

#define	TYPE_ENUM_BR_TYPE int&

#define	TYPE_REFTARG_BR_TYPE ReferenceTarget&

#define	TYPE_MATRIX3_BR_TYPE Matrix3&

#define	TYPE_ANGAXIS_BR_TYPE AngAxis&

#define	TYPE_QUAT_BR_TYPE Quat&

#define	TYPE_BITARRAY_BR_TYPE BitArray&

#define	TYPE_RAY_BR_TYPE Ray&

#define	TYPE_POINT2_BR_TYPE Point2&

#define	TYPE_MESH_BR_TYPE Mesh&

#define	TYPE_INTERVAL_BR_TYPE Interval&

#define	TYPE_POINT_BR_TYPE POINT&

#define	TYPE_TSTR_BR_TYPE MSTR&

#define	TYPE_COLOR_BR_TYPE Color&

#define	TYPE_ACOLOR_BR_TYPE AColor&

#define	TYPE_FPVALUE_BR_TYPE FPValue&

#define	TYPE_DWORD_BR_TYPE DWORD&

#define	TYPE_bool_BR_TYPE bool&

#define	TYPE_INTPTR_BR_TYPE INT_PTR&

#define	TYPE_INT64_BR_TYPE INT64&

#define	TYPE_DOUBLE_BR_TYPE double&

#define	TYPE_BOX3_BR_TYPE Box3&

#define	TYPE_FLOAT_TAB_BR_TYPE Tab<float>&

#define	TYPE_INT_TAB_BR_TYPE Tab<int>&

#define	TYPE_RGBA_TAB_BR_TYPE Tab<Point3>&

#define	TYPE_POINT3_TAB_BR_TYPE Tab<Point3>&

#define	TYPE_FRGBA_TAB_BR_TYPE Tab<Point4>&

#define	TYPE_POINT4_TAB_BR_TYPE Tab<Point4>&

#define	TYPE_BOOL_TAB_BR_TYPE Tab<BOOL>&

#define	TYPE_ANGLE_TAB_BR_TYPE Tab<float>&

#define	TYPE_PCNT_FRAC_TAB_BR_TYPE Tab<float>&

#define	TYPE_WORLD_TAB_BR_TYPE Tab<float>&

#define	TYPE_STRING_TAB_BR_TYPE Tab<const MCHAR*>&

#define	TYPE_FILENAME_TAB_BR_TYPE Tab<const MCHAR*>&

#define	TYPE_HSV_TAB_BR_TYPE Tab<Point3>&

#define	TYPE_COLOR_CHANNEL_TAB_BR_TYPE Tab<float>&

#define	TYPE_TIMEVALUE_TAB_BR_TYPE Tab<int>&

#define	TYPE_RADIOBTN_INDEX_TAB_BR_TYPE Tab<int>&

#define	TYPE_MTL_TAB_BR_TYPE Tab<Mtl*>&

#define	TYPE_TEXMAP_TAB_BR_TYPE Tab<Texmap*>&

#define	TYPE_BITMAP_TAB_BR_TYPE Tab<PBBitmap*>&

#define	TYPE_INODE_TAB_BR_TYPE Tab<INode*>&

#define	TYPE_REFTARG_TAB_BR_TYPE Tab<ReferenceTarget*>&

#define	TYPE_INDEX_TAB_BR_TYPE Tab<int>&

#define	TYPE_ENUM_TAB_BR_TYPE Tab<int>&

#define	TYPE_MATRIX3_TAB_BR_TYPE Tab<Matrix*>&

#define	TYPE_VOID_TAB_BR_TYPE Tab<void>&

#define	TYPE_INTERVAL_TAB_BR_TYPE Tab<Interval*>&

#define	TYPE_ANGAXIS_TAB_BR_TYPE Tab<AngAxis*>&

#define	TYPE_QUAT_TAB_BR_TYPE Tab<Quat*>&

#define	TYPE_RAY_TAB_BR_TYPE Tab<Ray*>&

#define	TYPE_POINT2_TAB_BR_TYPE Tab<Point2*>&

#define	TYPE_BITARRAY_TAB_BR_TYPE Tab<BitArray*>&

#define	TYPE_CLASS_TAB_BR_TYPE Tab<ClassID*>&

#define	TYPE_MESH_TAB_BR_TYPE Tab<Mesh*>&

#define	TYPE_OBJECT_TAB_BR_TYPE Tab<Object*>&

#define	TYPE_CONTROL_TAB_BR_TYPE Tab<Control*>&

#define	TYPE_POINT_TAB_BR_TYPE Tab<POINT*>&

#define	TYPE_TSTR_TAB_BR_TYPE Tab<MSTR*>&

#define	TYPE_IOBJECT_TAB_BR_TYPE Tab<IObject*>&

#define	TYPE_INTERFACE_TAB_BR_TYPE Tab<FPInterface*>&

#define	TYPE_HWND_TAB_BR_TYPE Tab<HWND>&

#define	TYPE_NAME_TAB_BR_TYPE Tab<const MCHAR*>&

#define	TYPE_COLOR_TAB_BR_TYPE Tab<Color*>&

#define	TYPE_ACOLOR_TAB_BR_TYPE Tab<AColor*>&

#define	TYPE_FPVALUE_TAB_BR_TYPE Tab<FPValue*>&

#define	TYPE_VALUE_TAB_BR_TYPE Tab<Value*>&

#define	TYPE_DWORD_TAB_BR_TYPE Tab<DWORD>&

#define	TYPE_bool_TAB_BR_TYPE Tab<bool>&

#define	TYPE_INTPTR_TAB_BR_TYPE Tab<INT_PTR>&

#define	TYPE_INT64_TAB_BR_TYPE Tab<INT64>&

#define	TYPE_DOUBLE_TAB_BR_TYPE Tab<double>&

#define	TYPE_BOX3_TAB_BR_TYPE Tab<Box3>&

#define	TYPE_RGBA_BV_TYPE Point3

#define	TYPE_POINT3_BV_TYPE Point3

#define	TYPE_HSV_BV_TYPE Point3

#define	TYPE_FRGBA_BV_TYPE Point4

#define	TYPE_POINT4_BV_TYPE Point4

#define	TYPE_BITMAP_BV_TYPE PBBitmap

#define	TYPE_MATRIX3_BV_TYPE Matrix3

#define	TYPE_ANGAXIS_BV_TYPE AngAxis

#define	TYPE_QUAT_BV_TYPE Quat

#define	TYPE_BITARRAY_BV_TYPE BitArray

#define	TYPE_RAY_BV_TYPE Ray

#define	TYPE_POINT2_BV_TYPE Point2

#define	TYPE_MESH_BV_TYPE Mesh

#define	TYPE_INTERVAL_BV_TYPE Interval

#define	TYPE_POINT_BV_TYPE POINT

#define	TYPE_TSTR_BV_TYPE MSTR

#define	TYPE_COLOR_BV_TYPE Color

#define	TYPE_ACOLOR_BV_TYPE AColor

#define	TYPE_FPVALUE_BV_TYPE FPValue

#define	TYPE_CLASS_BV_TYPE ClassID

#define	TYPE_BOX3_BV_TYPE Box3

#define	TYPE_FLOAT_TAB_BV_TYPE Tab<float>

#define	TYPE_INT_TAB_BV_TYPE Tab<int>

#define	TYPE_RGBA_TAB_BV_TYPE Tab<Point3>

#define	TYPE_POINT3_TAB_BV_TYPE Tab<Point3>

#define	TYPE_FRGBA_TAB_BV_TYPE Tab<Point4>

#define	TYPE_POINT4_TAB_BV_TYPE Tab<Point4>

#define	TYPE_BOOL_TAB_BV_TYPE Tab<BOOL>

#define	TYPE_ANGLE_TAB_BV_TYPE Tab<float>

#define	TYPE_PCNT_FRAC_TAB_BV_TYPE Tab<float>

#define	TYPE_WORLD_TAB_BV_TYPE Tab<float>

#define	TYPE_STRING_TAB_BV_TYPE Tab<const MCHAR*>

#define	TYPE_FILENAME_TAB_BV_TYPE Tab<const MCHAR*>

#define	TYPE_HSV_TAB_BV_TYPE Tab<Point3>

#define	TYPE_COLOR_CHANNEL_TAB_BV_TYPE Tab<float>

#define	TYPE_TIMEVALUE_TAB_BV_TYPE Tab<int>

#define	TYPE_RADIOBTN_INDEX_TAB_BV_TYPE Tab<int>

#define	TYPE_MTL_TAB_BV_TYPE Tab<Mtl*>

#define	TYPE_TEXMAP_TAB_BV_TYPE Tab<Texmap*>

#define	TYPE_BITMAP_TAB_BV_TYPE Tab<PBBitmap*>

#define	TYPE_INODE_TAB_BV_TYPE Tab<INode*>

#define	TYPE_REFTARG_TAB_BV_TYPE Tab<ReferenceTarget*>

#define	TYPE_INDEX_TAB_BV_TYPE Tab<int>

#define	TYPE_ENUM_TAB_BV_TYPE Tab<int>

#define	TYPE_MATRIX3_TAB_BV_TYPE Tab<Matrix*>

#define	TYPE_VOID_TAB_BV_TYPE Tab<void>

#define	TYPE_INTERVAL_TAB_BV_TYPE Tab<Interval*>

#define	TYPE_ANGAXIS_TAB_BV_TYPE Tab<AngAxis*>

#define	TYPE_QUAT_TAB_BV_TYPE Tab<Quat*>

#define	TYPE_RAY_TAB_BV_TYPE Tab<Ray*>

#define	TYPE_POINT2_TAB_BV_TYPE Tab<Point2*>

#define	TYPE_BITARRAY_TAB_BV_TYPE Tab<BitArray*>

#define	TYPE_CLASS_TAB_BV_TYPE Tab<ClassID*>

#define	TYPE_MESH_TAB_BV_TYPE Tab<Mesh*>

#define	TYPE_OBJECT_TAB_BV_TYPE Tab<Object*>

#define	TYPE_CONTROL_TAB_BV_TYPE Tab<Control*>

#define	TYPE_POINT_TAB_BV_TYPE Tab<POINT*>

#define	TYPE_TSTR_TAB_BV_TYPE Tab<MSTR*>

#define	TYPE_IOBJECT_TAB_BV_TYPE Tab<IObject*>

#define	TYPE_INTERFACE_TAB_BV_TYPE Tab<FPInterface*>

#define	TYPE_HWND_TAB_BV_TYPE Tab<HWND>

#define	TYPE_NAME_TAB_BV_TYPE Tab<const MCHAR*>

#define	TYPE_COLOR_TAB_BV_TYPE Tab<Color*>

#define	TYPE_ACOLOR_TAB_BV_TYPE Tab<AColor*>

#define	TYPE_FPVALUE_TAB_BV_TYPE Tab<FPValue*>

#define	TYPE_VALUE_TAB_BV_TYPE Tab<Value*>

#define	TYPE_DWORD_TAB_BV_TYPE Tab<DWORD>

#define	TYPE_bool_TAB_BV_TYPE Tab<bool>

#define	TYPE_INTPTR_TAB_BV_TYPE Tab<INT_PTR>

#define	TYPE_INT64_TAB_BV_TYPE Tab<INT64>

#define	TYPE_DOUBLE_TAB_BV_TYPE Tab<double>

#define	TYPE_BOX3_TAB_BV_TYPE Tab<Box3*>

Property Macros
Turns getters and setters into maxscript properties Property Macro
#define	PROP_FNS(_getID, _getFn, _setID, _setFn, _ptype)
	This takes five arguments: More...

#define	RO_PROP_FN(_getID, _getFn, _ptype)
	Read only Property Macro. More...

#define	PROP_TFNS(_getID, _getFn, _setID, _setFn, _ptype)
	Property Macro with Time parameter. More...

#define	RO_PROP_TFN(_getID, _getFn, _ptype)
	Read only Property Macro with Time parameter. More...

Static Method Macros
Property FN_MAP macros for the Static Method Interfaces used in MAXScript.
#define	SM_PROP_FNS(_getID, _getFn, _setID, _setFn, _ptype)

#define	SM_RO_PROP_FN(_getID, _getFn, _ptype)

#define	SM_PROP_TFNS(_getID, _getFn, _setID, _setFn, _ptype)

#define	SM_RO_PROP_TFN(_getID, _getFn, _ptype)

Function Macros with No Time.
Functions with return value, no time
#define	FN_VA(_fid, _rtype, _f)

#define	FN_0(_fid, _rtype, _f)

#define	FN_1(_fid, _rtype, _f, _p1)

#define	FN_2(_fid, _rtype, _f, _p1, _p2)

#define	FN_3(_fid, _rtype, _f, _p1, _p2, _p3)

#define	FN_4(_fid, _rtype, _f, _p1, _p2, _p3, _p4)

#define	FN_5(_fid, _rtype, _f, _p1, _p2, _p3, _p4, _p5)

#define	FN_6(_fid, _rtype, _f, _p1, _p2, _p3, _p4, _p5, _p6)

#define	FN_7(_fid, _rtype, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7)

#define	FN_8(_fid, _rtype, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8)

#define	FN_9(_fid, _rtype, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9)

#define	FN_10(_fid, _rtype, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9, _p10)

#define	FN_11(_fid, _rtype, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9, _p10, _p11)

Void Function Macros with No Time.
Specifies void functions that take no time parameter
#define	VFN_VA(_fid, _f)

#define	VFN_0(_fid, _f)

#define	VFN_1(_fid, _f, _p1)

#define	VFN_2(_fid, _f, _p1, _p2)

#define	VFN_3(_fid, _f, _p1, _p2, _p3)

#define	VFN_4(_fid, _f, _p1, _p2, _p3, _p4)

#define	VFN_5(_fid, _f, _p1, _p2, _p3, _p4, _p5)

#define	VFN_6(_fid, _f, _p1, _p2, _p3, _p4, _p5, _p6)

#define	VFN_7(_fid, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7)

Const Return Function Macros
Specifies Functions with constant return values, with no time parameter.
#define	CFN_VA(_fid, _rtype, _f)

#define	CFN_0(_fid, _rtype, _f)

#define	CFN_1(_fid, _rtype, _f, _p1)

#define	CFN_2(_fid, _rtype, _f, _p1, _p2)

#define	CFN_3(_fid, _rtype, _f, _p1, _p2, _p3)

#define	CFN_4(_fid, _rtype, _f, _p1, _p2, _p3, _p4)

#define	CFN_5(_fid, _rtype, _f, _p1, _p2, _p3, _p4, _p5)

Value Returning Function Macros
Specifies Functions that return values, with time parameter.
#define	FNT_VA(_fid, _rtype, _f)

#define	FNT_0(_fid, _rtype, _f)

#define	FNT_1(_fid, _rtype, _f, _p1)

#define	FNT_2(_fid, _rtype, _f, _p1, _p2)

#define	FNT_3(_fid, _rtype, _f, _p1, _p2, _p3)

#define	FNT_4(_fid, _rtype, _f, _p1, _p2, _p3, _p4)

#define	FNT_5(_fid, _rtype, _f, _p1, _p2, _p3, _p4, _p5)

#define	FNT_6(_fid, _rtype, _f, _p1, _p2, _p3, _p4, _p5, _p6)

#define	FNT_7(_fid, _rtype, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7)

Void Function (with time) Macros
Specifies void Functions, with time parameter.
#define	VFNT_VA(_fid, _f)

#define	VFNT_0(_fid, _f)

#define	VFNT_1(_fid, _f, _p1)

#define	VFNT_2(_fid, _f, _p1, _p2)

#define	VFNT_3(_fid, _f, _p1, _p2, _p3)

#define	VFNT_4(_fid, _f, _p1, _p2, _p3, _p4)

#define	VFNT_5(_fid, _f, _p1, _p2, _p3, _p4, _p5)

#define	VFNT_6(_fid, _f, _p1, _p2, _p3, _p4, _p5, _p6)

#define	VFNT_7(_fid, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7)

#define	VFNT_8(_fid, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8)

#define	VFNT_9(_fid, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9)

#define	VFNT_10(_fid, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9, _p10)

#define	VFNT_11(_fid, _f, _p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9, _p10, _p11)

Typedefs
typedef int	FPStatus

typedef short	FunctionID
	ID for individual functions within an interface (local) More...

typedef short	EnumID

Enumerations
enum	{ f_category = -(1<<30) , f_predicates , f_isEnabled , f_isChecked , f_isVisible , f_iconRes , f_icon , f_buttonText , f_toolTip , f_menuText , f_ui , f_shortCut , f_macroEmitter , f_embeddedScriptSecurityFeature , f_range , f_validator , f_inOut , f_keyArgDefault , f_embeddedScriptSecurityFeature_r , f_embeddedScriptSecurityFeature_w , f_embeddedScriptSecurityFeature_rw }

Functions
FPInterface *	GetFPInterface (BaseInterface *bi)

FPInterfaceDesc *	GetFPInterfaceDesc (BaseInterface *bi)

FPMixinInterface *	GetFPMixinInterface (BaseInterface *bi)

Macro Definition Documentation

◆ FP_NO_FUNCTION

#define FP_NO_FUNCTION ((FunctionID)-1)

Special ID indicating no function bound.

◆ FP_NO_ENUM

#define FP_NO_ENUM ((EnumID)-1)

◆ NULLINTERFACE_ID

#define NULLINTERFACE_ID Interface_ID(0, 0)

◆ FPINTERFACE_ID

#define FPINTERFACE_ID Interface_ID(0, 2)

◆ FPMIXININTERFACE_ID

#define FPMIXININTERFACE_ID Interface_ID(0, 3)

◆ FPINTERFACEDESC_ID

#define FPINTERFACEDESC_ID Interface_ID(0, 4)

◆ FP_ACTIONS

#define FP_ACTIONS 0x0001

◆ FP_MIXIN

#define FP_MIXIN 0x0002

◆ FP_CORE

#define FP_CORE 0x0004

◆ FP_STATIC_METHODS

#define FP_STATIC_METHODS 0x0008

◆ FP_TEST_INTERFACE

#define FP_TEST_INTERFACE 0x0010

◆ FP_SCRIPTED_CLASS

#define FP_SCRIPTED_CLASS 0x1000

◆ FP_TEMPORARY

#define FP_TEMPORARY 0x2000

◆ FP_NO_REDRAW

#define FP_NO_REDRAW 0x0001

◆ FP_VAR_ARGS

#define FP_VAR_ARGS 0x0002

◆ FP_CLIENT_OWNS_RESULT

#define FP_CLIENT_OWNS_RESULT 0x0004

◆ FP_EMBEDDEDSCRIPTSECURITYFEATURE

#define FP_EMBEDDEDSCRIPTSECURITYFEATURE 0x0008

◆ FP_ACTION

#define FP_ACTION 0x0100

◆ FP_HAS_UI

#define FP_HAS_UI 0x0200

◆ FP_ICONRES

#define FP_ICONRES 0x0400

◆ FP_ICONFILE

#define FP_ICONFILE 0x0800

◆ FP_HAS_SHORTCUT

#define FP_HAS_SHORTCUT 0x1000

◆ FP_HAS_KEYARGS

#define FP_HAS_KEYARGS 0x2000

◆ FPP_HAS_RANGE

#define FPP_HAS_RANGE 0x0001

◆ FPP_HAS_VALIDATOR

#define FPP_HAS_VALIDATOR 0x0002

◆ FPP_IN_PARAM

#define FPP_IN_PARAM 0x0004

◆ FPP_OUT_PARAM

#define FPP_OUT_PARAM 0x0008

◆ FPP_IN_OUT_PARAM

#define FPP_IN_OUT_PARAM 0x000C

◆ FPP_KEYARG

#define FPP_KEYARG 0x0010

◆ FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_R

#define FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_R 0x0040

◆ FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_W

#define FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_W 0x0080

◆ FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_RW

#define FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_RW 0x00C0

◆ DECLARE_DESCRIPTOR

#define DECLARE_DESCRIPTOR ( _interface )

Value:

    public:                                                             \
    _interface() { }                                                    \
    _interface(Interface_ID id, const MCHAR* name,          \
               StringResID descr, ClassDesc* cd,                \
               USHORT flags, ...)                                   \
    {                                                                       \
        va_list ap;                                                     \
        va_start(ap, flags);                                            \
        load_descriptor(id, name, descr, cd, flags, ap);    \
        va_end(ap);                                                     \
    }

◆ DECLARE_DESCRIPTOR_INIT

#define DECLARE_DESCRIPTOR_INIT ( _interface )

Value:

    public:                                                             \
    _interface() { init(); }                                        \
    void init();                                                        \
    _interface(Interface_ID id, const MCHAR* name,          \
               StringResID descr, ClassDesc* cd,                \
               USHORT flags, ...)                                   \
    {                                                                       \
        init();                                                         \
        va_list ap;                                                     \
        va_start(ap, flags);                                            \
        load_descriptor(id, name, descr, cd, flags, ap);    \
        va_end(ap);                                                     \
    }

◆ DECLARE_DESCRIPTOR_NDC

#define DECLARE_DESCRIPTOR_NDC ( _interface )

Value:

    public:                                                             \
    _interface(Interface_ID id, const MCHAR* name,          \
               StringResID descr, ClassDesc* cd,                \
               USHORT flags, ...)                                   \
    {                                                                       \
        va_list ap;                                                     \
        va_start(ap, flags);                                            \
        load_descriptor(id, name, descr, cd, flags, ap);    \
        va_end(ap);                                                     \
    }

◆ DECLARE_DESCRIPTOR_INIT_NDC

#define DECLARE_DESCRIPTOR_INIT_NDC ( _interface )

Value:

    public:                                                             \
    void init();                                                        \
    _interface(Interface_ID id, const MCHAR* name,          \
                StringResID descr, ClassDesc* cd,               \
                USHORT flags, ...)                                  \
    {                                                                       \
        init();                                                         \
        va_list ap;                                                     \
        va_start(ap, flags);                                            \
        load_descriptor(id, name, descr, cd, flags, ap);    \
        va_end(ap);                                                     \
    }

◆ BEGIN_FUNCTION_MAP

#define BEGIN_FUNCTION_MAP

Value:

    public:                                                         \
    FPStatus _dispatch_fn(FunctionID fid, TimeValue t,  \
                    FPValue& result, FPParams* p)               \
    {                                                                   \
        UNUSED_PARAM(t);                                            \
        UNUSED_PARAM(result);                                   \
        UNUSED_PARAM(p);                                            \
        FPStatus status = FPS_OK;                               \
        switch (fid)                                                \
        {

◆ BEGIN_FUNCTION_MAP_PARENT

#define BEGIN_FUNCTION_MAP_PARENT ( Parent )

Value:

    public:                                                         \
    FPStatus _dispatch_fn(FunctionID fid, TimeValue t,  \
                    FPValue& result, FPParams* p)               \
    {                                                                   \
        FPStatus status                                         \
            = Parent::_dispatch_fn(fid, t, result, p);  \
        if (status == FPS_OK) return status;                \
        status = FPS_OK;                                            \
        switch (fid)                                                \
        {

◆ END_FUNCTION_MAP

#define END_FUNCTION_MAP

Value:

            default: status = FPS_NO_SUCH_FUNCTION;     \
        }                                                               \
        return status;                                              \
    }

◆ NO_FUNCTION_MAP

#define NO_FUNCTION_MAP

Value:

    public:                                                         \
    FPStatus _dispatch_fn(FunctionID fid, TimeValue t,  \
                    FPValue& result, FPParams* p)               \
    {                                                                   \
        return FPS_NO_SUCH_FUNCTION;                            \
    }

◆ FP_FIELD

#define FP_FIELD	(	_type,
		_v
	)	(_type##_FIELD(_v))

◆ FN_ACTION

#define FN_ACTION	(	_fid,
		_fn
	)

Value:

    case _fid:                                              \
        status = _fn();                                 \
        break;

◆ FN_PRED

#define FN_PRED	(	_fid,
		_fn
	)

Value:

    case _fid: {                                            \
        auto&& tmp = _fn();                                 \
        result.Load(TYPE_BOOL, tmp);                    \
        break;                                              \
    }

◆ FN_PREDS

#define FN_PREDS	(	_fid1,
		_fn1,
		_fid2,
		_fn2,
		_fid3,
		_fn3
	)

Value:

    case _fid1: {                                                       \
        auto&& tmp = _fn1();                                            \
        result.Load(TYPE_BOOL, tmp);                                \
        break;                                                          \
    }                                                                       \
    case _fid2: {                                                       \
        auto&& tmp = _fn2();                                            \
        result.Load(TYPE_BOOL, tmp);                                \
        break;                                                          \
    }                                                                       \
    case _fid3: {                                                       \
        auto&& tmp = _fn3();                                            \
        result.Load(TYPE_BOOL, tmp);                                \
        break;                                                          \
    }

◆ PROP_FNS

#define PROP_FNS	(	_getID,
		_getFn,
		_setID,
		_setFn,
		_ptype
	)

Value:

    case _getID: {                                                      \
        auto&& tmp = _getFn();                                          \
        result.LoadPtr(_ptype,  _ptype##_RSLT(tmp));            \
        break;                                                          \
    }                                                                       \
    case _setID:                                                        \
        _setFn(FP_FIELD(_ptype, p->params[0]));             \
        break;

This takes five arguments:

Parameters

_getID	- The enum associated with the getter function.
_getFn	- The pointer to the getter function.
_setID	- The enum associated with the setter function.
_setFn	- The pointer to the setter function.
_ptype	- An enum (ParamType or ParamType2) specifying the type of property.

◆ RO_PROP_FN

#define RO_PROP_FN	(	_getID,
		_getFn,
		_ptype
	)

Value:

    case _getID: {                                                  \
        auto&& tmp = _getFn();                                      \
        result.LoadPtr(_ptype,  _ptype##_RSLT(tmp));        \
        break;                                                      \
    }

Read only Property Macro.

Same as PROP_FNS, except specifies a property that is read only, and has no associated setter function.

◆ PROP_TFNS

#define PROP_TFNS	(	_getID,
		_getFn,
		_setID,
		_setFn,
		_ptype
	)

Value:

    case _getID: {                                                          \
        auto&& tmp = _getFn(t);                                         \
        result.LoadPtr(_ptype,  _ptype##_RSLT(tmp));                \
        break;                                                              \
    }                                                                           \
    case _setID:                                                            \
        _setFn(FP_FIELD(_ptype, p->params[0]), t);              \
        break;

Property Macro with Time parameter.

Same as PROP_FNS, except specifies an addition TimeValue is passed to the getter and setter functions.

◆ RO_PROP_TFN

#define RO_PROP_TFN	(	_getID,
		_getFn,
		_ptype
	)

Value:

    case _getID: {                                                  \
        auto&& tmp = _getFn(t);                                 \
        result.LoadPtr(_ptype,  _ptype##_RSLT(tmp));        \
        break;                                                      \
    }

Read only Property Macro with Time parameter.

Same as PROP_TFNS, except specifies a property that is read only, and has no associated setter function.

◆ SM_PROP_FNS

#define SM_PROP_FNS	(	_getID,
		_getFn,
		_setID,
		_setFn,
		_ptype
	)

Value:

    case _getID: {                                                                                              \
        auto&& tmp = _getFn(FP_FIELD(TYPE_FPVALUE_BR, p->params[0]));                               \
        result.LoadPtr(_ptype,  _ptype##_RSLT(tmp));                                                \
        break;                                                                                                  \
    }                                                                                                               \
    case _setID:                                                                                                \
        _setFn(FP_FIELD(TYPE_FPVALUE_BR, p->params[0]), FP_FIELD(_ptype, p->params[1]));    \
        break;

◆ SM_RO_PROP_FN

#define SM_RO_PROP_FN	(	_getID,
		_getFn,
		_ptype
	)

Value:

    case _getID: {                                                                  \
        auto&& tmp = _getFn(FP_FIELD(TYPE_FPVALUE_BR, p->params[0]));   \
        result.LoadPtr(_ptype,  _ptype##_RSLT(tmp));                        \
        break;                                                                      \
    }

◆ SM_PROP_TFNS

#define SM_PROP_TFNS	(	_getID,
		_getFn,
		_setID,
		_setFn,
		_ptype
	)

Value:

    case _getID: {                                                                                                  \
        auto&& tmp = _getFn(FP_FIELD(TYPE_FPVALUE_BR, p->params[0]), t);                                \
        result.LoadPtr(_ptype,  _ptype##_RSLT(tmp));                                                        \
        break;                                                                                                      \
    }                                                                                                                   \
    case _setID:                                                                                                    \
        _setFn(FP_FIELD(TYPE_FPVALUE_BR, p->params[0]), FP_FIELD(_ptype, p->params[1]), t); \
        break;

◆ SM_RO_PROP_TFN

#define SM_RO_PROP_TFN	(	_getID,
		_getFn,
		_ptype
	)

Value:

    case _getID: {                                                                      \
        auto&& tmp = _getFn(FP_FIELD(TYPE_FPVALUE_BR, p->params[0]), t);    \
        result.LoadPtr(_ptype,  _ptype##_RSLT(tmp));                            \
        break;                                                                          \
    }

◆ FN_VA

#define FN_VA	(	_fid,
		_rtype,
		_f
	)

Value:

    case _fid: {                                                \
        auto&& tmp = _f(p);                                     \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));    \
        break;                                                  \
    }

◆ FN_0

#define FN_0	(	_fid,
		_rtype,
		_f
	)

Value:

    case _fid: {                                                \
        auto&& tmp = _f();                                      \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));    \
        break;                                                  \
    }

◆ FN_1

#define FN_1	(	_fid,
		_rtype,
		_f,
		_p1
	)

Value:

    case _fid: {                                                \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]));   \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));    \
        break;                                                  \
    }

◆ FN_2

#define FN_2	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2
	)

Value:

    case _fid: {                                                \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),    \
                          FP_FIELD(_p2, p->params[1])); \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));    \
        break;                                                  \
    }

◆ FN_3

#define FN_3	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3
	)

Value:

    case _fid: {                                                \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),    \
                          FP_FIELD(_p2, p->params[1]),  \
                          FP_FIELD(_p3, p->params[2])); \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));    \
        break;                                                  \
    }

◆ FN_4

#define FN_4	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4
	)

Value:

    case _fid: {                                                \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),    \
                          FP_FIELD(_p2, p->params[1]),  \
                          FP_FIELD(_p3, p->params[2]),  \
                          FP_FIELD(_p4, p->params[3])); \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));    \
        break;                                                  \
    }

◆ FN_5

#define FN_5	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5
	)

Value:

    case _fid: {                                                        \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),            \
                          FP_FIELD(_p2, p->params[1]),          \
                          FP_FIELD(_p3, p->params[2]),          \
                          FP_FIELD(_p4, p->params[3]),          \
                          FP_FIELD(_p5, p->params[4]));         \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));            \
        break;                                                          \
    }

◆ FN_6

#define FN_6	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6
	)

Value:

    case _fid: {                                                                \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                    \
                          FP_FIELD(_p2, p->params[1]),                  \
                          FP_FIELD(_p3, p->params[2]),                  \
                          FP_FIELD(_p4, p->params[3]),                  \
                          FP_FIELD(_p5, p->params[4]),                  \
                          FP_FIELD(_p6, p->params[5]));                 \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));                    \
        break;                                                                  \
    }

◆ FN_7

#define FN_7	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7
	)

Value:

    case _fid: {                                                                    \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                        \
                          FP_FIELD(_p2, p->params[1]),                      \
                          FP_FIELD(_p3, p->params[2]),                      \
                          FP_FIELD(_p4, p->params[3]),                      \
                          FP_FIELD(_p5, p->params[4]),                      \
                          FP_FIELD(_p6, p->params[5]),                      \
                          FP_FIELD(_p7, p->params[6]));                     \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));                        \
        break;                                                                      \
    }

◆ FN_8

#define FN_8	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7,
		_p8
	)

Value:

    case _fid: {                                                                            \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                                \
                          FP_FIELD(_p2, p->params[1]),                              \
                          FP_FIELD(_p3, p->params[2]),                              \
                          FP_FIELD(_p4, p->params[3]),                              \
                          FP_FIELD(_p5, p->params[4]),                              \
                          FP_FIELD(_p6, p->params[5]),                              \
                          FP_FIELD(_p7, p->params[6]),                              \
                          FP_FIELD(_p8, p->params[7]));                             \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));                                \
        break;                                                                              \
    }

◆ FN_9

#define FN_9	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7,
		_p8,
		_p9
	)

Value:

    case _fid: {                                                                                    \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                                        \
                          FP_FIELD(_p2, p->params[1]),                                      \
                          FP_FIELD(_p3, p->params[2]),                                      \
                          FP_FIELD(_p4, p->params[3]),                                      \
                          FP_FIELD(_p5, p->params[4]),                                      \
                          FP_FIELD(_p6, p->params[5]),                                      \
                          FP_FIELD(_p7, p->params[6]),                                      \
                          FP_FIELD(_p8, p->params[7]),                                      \
                          FP_FIELD(_p9, p->params[8]));                                     \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));                                        \
        break;                                                                                      \
    }

◆ FN_10

#define FN_10	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7,
		_p8,
		_p9,
		_p10
	)

Value:

    case _fid: {                                                                                            \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                                                \
                          FP_FIELD(_p2, p->params[1]),                                              \
                          FP_FIELD(_p3, p->params[2]),                                              \
                          FP_FIELD(_p4, p->params[3]),                                              \
                          FP_FIELD(_p5, p->params[4]),                                              \
                          FP_FIELD(_p6, p->params[5]),                                              \
                          FP_FIELD(_p7, p->params[6]),                                              \
                          FP_FIELD(_p8, p->params[7]),                                              \
                          FP_FIELD(_p9, p->params[8]),                                              \
                          FP_FIELD(_p10, p->params[9]));                                                \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));                                                \
        break;                                                                                              \
    }

◆ FN_11

#define FN_11	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7,
		_p8,
		_p9,
		_p10,
		_p11
	)

Value:

    case _fid: {                                                                                                    \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                                                        \
                          FP_FIELD(_p2, p->params[1]),                                                      \
                          FP_FIELD(_p3, p->params[2]),                                                      \
                          FP_FIELD(_p4, p->params[3]),                                                      \
                          FP_FIELD(_p5, p->params[4]),                                                      \
                          FP_FIELD(_p6, p->params[5]),                                                      \
                          FP_FIELD(_p7, p->params[6]),                                                      \
                          FP_FIELD(_p8, p->params[7]),                                                      \
                          FP_FIELD(_p9, p->params[8]),                                                      \
                          FP_FIELD(_p10, p->params[9]),                                                     \
                          FP_FIELD(_p11, p->params[10]));                                                   \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));                                                        \
        break;                                                                                                      \
    }

◆ VFN_VA

#define VFN_VA	(	_fid,
		_f
	)

Value:

    case _fid:                                              \
            _f(p);                                          \
        break;

◆ VFN_0

#define VFN_0	(	_fid,
		_f
	)

Value:

    case _fid:                                              \
            _f();                                               \
        break;

◆ VFN_1

#define VFN_1	(	_fid,
		_f,
		_p1
	)

Value:

    case _fid:                                              \
            _f(FP_FIELD(_p1, p->params[0]));            \
        break;

◆ VFN_2

#define VFN_2	(	_fid,
		_f,
		_p1,
		_p2
	)

Value:

    case _fid:                                              \
            _f(FP_FIELD(_p1, p->params[0]),         \
               FP_FIELD(_p2, p->params[1]));            \
        break;

◆ VFN_3

#define VFN_3	(	_fid,
		_f,
		_p1,
		_p2,
		_p3
	)

Value:

    case _fid:                                              \
            _f(FP_FIELD(_p1, p->params[0]),         \
                    FP_FIELD(_p2, p->params[1]),        \
                    FP_FIELD(_p3, p->params[2]));       \
        break;

◆ VFN_4

#define VFN_4	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4
	)

Value:

    case _fid:                                              \
            _f(FP_FIELD(_p1, p->params[0]),         \
                    FP_FIELD(_p2, p->params[1]),        \
                    FP_FIELD(_p3, p->params[2]),        \
                    FP_FIELD(_p4, p->params[3]));       \
        break;

◆ VFN_5

#define VFN_5	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5
	)

Value:

    case _fid:                                                  \
            _f(FP_FIELD(_p1, p->params[0]),             \
                    FP_FIELD(_p2, p->params[1]),            \
                    FP_FIELD(_p3, p->params[2]),            \
                    FP_FIELD(_p4, p->params[3]),            \
                    FP_FIELD(_p5, p->params[4]));           \
        break;

◆ VFN_6

#define VFN_6	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6
	)

Value:

    case _fid:                                                      \
            _f(FP_FIELD(_p1, p->params[0]),                 \
                    FP_FIELD(_p2, p->params[1]),                \
                    FP_FIELD(_p3, p->params[2]),                \
                    FP_FIELD(_p4, p->params[3]),                \
                    FP_FIELD(_p5, p->params[4]),                \
                    FP_FIELD(_p6, p->params[5]));               \
        break;

◆ VFN_7

#define VFN_7	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7
	)

Value:

    case _fid:                                                              \
            _f(FP_FIELD(_p1, p->params[0]),                         \
                    FP_FIELD(_p2, p->params[1]),                        \
                    FP_FIELD(_p3, p->params[2]),                        \
                    FP_FIELD(_p4, p->params[3]),                        \
                    FP_FIELD(_p5, p->params[4]),                        \
                    FP_FIELD(_p6, p->params[5]),                        \
                    FP_FIELD(_p7, p->params[6]));                       \
        break;

◆ CFN_VA

#define CFN_VA	(	_fid,
		_rtype,
		_f
	)

Value:

    case _fid: {                                                                                    \
        auto&& tmp = _f(p);                                                                         \
        result.LoadPtr(_rtype,  _rtype##_RSLT(const_cast<_rtype##_TYPE>(tmp))); \
        break;                                                                                      \
    }

◆ CFN_0

#define CFN_0	(	_fid,
		_rtype,
		_f
	)

Value:

    case _fid: {                                                                                    \
        auto&& tmp = _f();                                                                          \
        result.LoadPtr(_rtype,  _rtype##_RSLT(const_cast<_rtype##_TYPE>(tmp))); \
        break;                                                                                      \
    }

◆ CFN_1

#define CFN_1	(	_fid,
		_rtype,
		_f,
		_p1
	)

Value:

    case _fid: {                                                                                    \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]));                                       \
        result.LoadPtr(_rtype,  _rtype##_RSLT(const_cast<_rtype##_TYPE>(tmp))); \
        break;                                                                                      \
    }

◆ CFN_2

#define CFN_2	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2
	)

Value:

    case _fid: {                                                                                    \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                                        \
                          FP_FIELD(_p2, p->params[1]));                                     \
        result.LoadPtr(_rtype,  _rtype##_RSLT(const_cast<_rtype##_TYPE>(tmp))); \
        break;                                                                                      \
    }

◆ CFN_3

#define CFN_3	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3
	)

Value:

    case _fid: {                                                                                    \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                                        \
                          FP_FIELD(_p2, p->params[1]),                                      \
                          FP_FIELD(_p3, p->params[2]));                                     \
        result.LoadPtr(_rtype,  _rtype##_RSLT(const_cast<_rtype##_TYPE>(tmp))); \
        break;                                                                                      \
    }

◆ CFN_4

#define CFN_4	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4
	)

Value:

    case _fid: {                                                                                    \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                                        \
                          FP_FIELD(_p2, p->params[1]),                                      \
                          FP_FIELD(_p3, p->params[2]),                                      \
                          FP_FIELD(_p4, p->params[3]));                                     \
        result.LoadPtr(_rtype,  _rtype##_RSLT(const_cast<_rtype##_TYPE>(tmp))); \
        break;                                                                                      \
    }

◆ CFN_5

#define CFN_5	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5
	)

Value:

    case _fid: {                                                                                    \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                                        \
                          FP_FIELD(_p2, p->params[1]),                                      \
                          FP_FIELD(_p3, p->params[2]),                                      \
                          FP_FIELD(_p4, p->params[3]),                                      \
                          FP_FIELD(_p5, p->params[4]));                                     \
        result.LoadPtr(_rtype,  _rtype##_RSLT(const_cast<_rtype##_TYPE>(tmp))); \
        break;                                                                                      \
    }

◆ FNT_VA

#define FNT_VA	(	_fid,
		_rtype,
		_f
	)

Value:

    case _fid: {                                                \
        auto&& tmp = _f(p, t);                                  \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));    \
        break;                                                  \
    }

◆ FNT_0

#define FNT_0	(	_fid,
		_rtype,
		_f
	)

Value:

    case _fid: {                                                \
        auto&& tmp = _f(t);                                     \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));    \
        break;                                                  \
    }

◆ FNT_1

#define FNT_1	(	_fid,
		_rtype,
		_f,
		_p1
	)

Value:

    case _fid: {                                                    \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]), t);    \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));        \
        break;                                                      \
    }

◆ FNT_2

#define FNT_2	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2
	)

Value:

    case _fid: {                                                \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),    \
                          FP_FIELD(_p2, p->params[1]),  \
                          t);                                       \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));    \
        break;                                                  \
    }

◆ FNT_3

#define FNT_3	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3
	)

Value:

    case _fid: {                                                \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),    \
                          FP_FIELD(_p2, p->params[1]),  \
                          FP_FIELD(_p3, p->params[2]),  \
                          t);                                       \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));    \
        break;                                                  \
    }

◆ FNT_4

#define FNT_4	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4
	)

Value:

    case _fid: {                                                    \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),        \
                          FP_FIELD(_p2, p->params[1]),      \
                          FP_FIELD(_p3, p->params[2]),      \
                          FP_FIELD(_p4, p->params[3]),      \
                          t);                                           \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));        \
        break;                                                      \
    }

◆ FNT_5

#define FNT_5	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5
	)

Value:

    case _fid: {                                                        \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),            \
                          FP_FIELD(_p2, p->params[1]),          \
                          FP_FIELD(_p3, p->params[2]),          \
                          FP_FIELD(_p4, p->params[3]),          \
                          FP_FIELD(_p5, p->params[4]),          \
                          t);                                               \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));            \
        break;                                                          \
    }

◆ FNT_6

#define FNT_6	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6
	)

Value:

    case _fid: {                                                                \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                    \
                          FP_FIELD(_p2, p->params[1]),                  \
                          FP_FIELD(_p3, p->params[2]),                  \
                          FP_FIELD(_p4, p->params[3]),                  \
                          FP_FIELD(_p5, p->params[4]),                  \
                          FP_FIELD(_p6, p->params[5]),                  \
                          t);                                                       \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));                    \
        break;                                                                  \
    }

◆ FNT_7

#define FNT_7	(	_fid,
		_rtype,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7
	)

Value:

    case _fid: {                                                                        \
        auto&& tmp = _f(FP_FIELD(_p1, p->params[0]),                            \
                          FP_FIELD(_p2, p->params[1]),                          \
                          FP_FIELD(_p3, p->params[2]),                          \
                          FP_FIELD(_p4, p->params[3]),                          \
                          FP_FIELD(_p5, p->params[4]),                          \
                          FP_FIELD(_p6, p->params[5]),                          \
                          FP_FIELD(_p7, p->params[6]),                          \
                          t);                                                               \
        result.LoadPtr(_rtype,  _rtype##_RSLT(tmp));                            \
        break;                                                                          \
    }

◆ VFNT_VA

#define VFNT_VA	(	_fid,
		_f
	)

Value:

    case _fid:                                          \
            _f(p, t);                                   \
        break;

◆ VFNT_0

#define VFNT_0	(	_fid,
		_f
	)

Value:

    case _fid:                                          \
            _f(t);                                      \
        break;

◆ VFNT_1

#define VFNT_1	(	_fid,
		_f,
		_p1
	)

Value:

    case _fid:                                          \
            _f(FP_FIELD(_p1, p->params[0]),     \
                    t);                                 \
        break;

◆ VFNT_2

#define VFNT_2	(	_fid,
		_f,
		_p1,
		_p2
	)

Value:

    case _fid:                                          \
            _f(FP_FIELD(_p1, p->params[0]),     \
               FP_FIELD(_p2, p->params[1]),     \
               t);                                      \
        break;

◆ VFNT_3

#define VFNT_3	(	_fid,
		_f,
		_p1,
		_p2,
		_p3
	)

Value:

    case _fid:                                          \
            _f(FP_FIELD(_p1, p->params[0]),     \
                    FP_FIELD(_p2, p->params[1]),    \
                    FP_FIELD(_p3, p->params[2]),    \
                    t);                                 \
        break;

◆ VFNT_4

#define VFNT_4	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4
	)

Value:

    case _fid:                                          \
            _f(FP_FIELD(_p1, p->params[0]),     \
                    FP_FIELD(_p2, p->params[1]),    \
                    FP_FIELD(_p3, p->params[2]),    \
                    FP_FIELD(_p4, p->params[3]),    \
                    t);                                 \
        break;

◆ VFNT_5

#define VFNT_5	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5
	)

Value:

    case _fid:                                                  \
            _f(FP_FIELD(_p1, p->params[0]),             \
                    FP_FIELD(_p2, p->params[1]),            \
                    FP_FIELD(_p3, p->params[2]),            \
                    FP_FIELD(_p4, p->params[3]),            \
                    FP_FIELD(_p5, p->params[4]),            \
                    t);                                         \
        break;

◆ VFNT_6

#define VFNT_6	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6
	)

Value:

    case _fid:                                                          \
            _f(FP_FIELD(_p1, p->params[0]),                     \
                    FP_FIELD(_p2, p->params[1]),                    \
                    FP_FIELD(_p3, p->params[2]),                    \
                    FP_FIELD(_p4, p->params[3]),                    \
                    FP_FIELD(_p5, p->params[4]),                    \
                    FP_FIELD(_p6, p->params[5]),                    \
                    t);                                                 \
        break;

◆ VFNT_7

#define VFNT_7	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7
	)

Value:

    case _fid:                                                              \
            _f(FP_FIELD(_p1, p->params[0]),                         \
               FP_FIELD(_p2, p->params[1]),                         \
               FP_FIELD(_p3, p->params[2]),                         \
               FP_FIELD(_p4, p->params[3]),                         \
               FP_FIELD(_p5, p->params[4]),                         \
               FP_FIELD(_p6, p->params[5]),                         \
               FP_FIELD(_p7, p->params[6]),                         \
               t);                                                          \
        break;

◆ VFNT_8

#define VFNT_8	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7,
		_p8
	)

Value:

    case _fid:                                                                      \
            _f(FP_FIELD(_p1, p->params[0]),                                 \
               FP_FIELD(_p2, p->params[1]),                                 \
               FP_FIELD(_p3, p->params[2]),                                 \
               FP_FIELD(_p4, p->params[3]),                                 \
               FP_FIELD(_p5, p->params[4]),                                 \
               FP_FIELD(_p6, p->params[5]),                                 \
               FP_FIELD(_p7, p->params[6]),                                 \
               FP_FIELD(_p8, p->params[7]),                                 \
               t);                                                                  \
        break;

◆ VFNT_9

#define VFNT_9	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7,
		_p8,
		_p9
	)

Value:

    case _fid:                                                                              \
            _f(FP_FIELD(_p1, p->params[0]),                                         \
               FP_FIELD(_p2, p->params[1]),                                         \
               FP_FIELD(_p3, p->params[2]),                                         \
               FP_FIELD(_p4, p->params[3]),                                         \
               FP_FIELD(_p5, p->params[4]),                                         \
               FP_FIELD(_p6, p->params[5]),                                         \
               FP_FIELD(_p7, p->params[6]),                                         \
               FP_FIELD(_p8, p->params[7]),                                         \
               FP_FIELD(_p9, p->params[8]),                                         \
               t);                                                                          \
        break;

◆ VFNT_10

#define VFNT_10	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7,
		_p8,
		_p9,
		_p10
	)

Value:

    case _fid:                                                                                      \
            _f(FP_FIELD(_p1, p->params[0]),                                                 \
               FP_FIELD(_p2, p->params[1]),                                                 \
               FP_FIELD(_p3, p->params[2]),                                                 \
               FP_FIELD(_p4, p->params[3]),                                                 \
               FP_FIELD(_p5, p->params[4]),                                                 \
               FP_FIELD(_p6, p->params[5]),                                                 \
               FP_FIELD(_p7, p->params[6]),                                                 \
               FP_FIELD(_p8, p->params[7]),                                                 \
               FP_FIELD(_p9, p->params[8]),                                                 \
               FP_FIELD(_p10, p->params[9]),                                                    \
               t);                                                                                  \
        break;

◆ VFNT_11

#define VFNT_11	(	_fid,
		_f,
		_p1,
		_p2,
		_p3,
		_p4,
		_p5,
		_p6,
		_p7,
		_p8,
		_p9,
		_p10,
		_p11
	)

Value:

    case _fid:                                                                                              \
            _f(FP_FIELD(_p1, p->params[0]),                                                         \
               FP_FIELD(_p2, p->params[1]),                                                         \
               FP_FIELD(_p3, p->params[2]),                                                         \
               FP_FIELD(_p4, p->params[3]),                                                         \
               FP_FIELD(_p5, p->params[4]),                                                         \
               FP_FIELD(_p6, p->params[5]),                                                         \
               FP_FIELD(_p7, p->params[6]),                                                         \
               FP_FIELD(_p8, p->params[7]),                                                         \
               FP_FIELD(_p9, p->params[8]),                                                         \
               FP_FIELD(_p10, p->params[9]),                                                            \
               FP_FIELD(_p11, p->params[10]),                                                       \
               t);                                                                                          \
        break;

◆ TYPE_FLOAT_FP_FIELD

#define TYPE_FLOAT_FP_FIELD f

◆ TYPE_INT_FP_FIELD

#define TYPE_INT_FP_FIELD i

◆ TYPE_RGBA_FP_FIELD

#define TYPE_RGBA_FP_FIELD p

◆ TYPE_POINT3_FP_FIELD

#define TYPE_POINT3_FP_FIELD p

◆ TYPE_FRGBA_FP_FIELD

#define TYPE_FRGBA_FP_FIELD p4

◆ TYPE_POINT4_FP_FIELD

#define TYPE_POINT4_FP_FIELD p4

◆ TYPE_BOOL_FP_FIELD

#define TYPE_BOOL_FP_FIELD i

◆ TYPE_ANGLE_FP_FIELD

#define TYPE_ANGLE_FP_FIELD f

◆ TYPE_PCNT_FRAC_FP_FIELD

#define TYPE_PCNT_FRAC_FP_FIELD f

◆ TYPE_WORLD_FP_FIELD

#define TYPE_WORLD_FP_FIELD f

◆ TYPE_STRING_FP_FIELD

#define TYPE_STRING_FP_FIELD s

◆ TYPE_FILENAME_FP_FIELD

#define TYPE_FILENAME_FP_FIELD s

◆ TYPE_HSV_FP_FIELD

#define TYPE_HSV_FP_FIELD p

◆ TYPE_COLOR_CHANNEL_FP_FIELD

#define TYPE_COLOR_CHANNEL_FP_FIELD f

◆ TYPE_TIMEVALUE_FP_FIELD

#define TYPE_TIMEVALUE_FP_FIELD i

◆ TYPE_RADIOBTN_INDEX_FP_FIELD

#define TYPE_RADIOBTN_INDEX_FP_FIELD i

◆ TYPE_MTL_FP_FIELD

#define TYPE_MTL_FP_FIELD mtl

◆ TYPE_TEXMAP_FP_FIELD

#define TYPE_TEXMAP_FP_FIELD tex

◆ TYPE_BITMAP_FP_FIELD

#define TYPE_BITMAP_FP_FIELD bm

◆ TYPE_INODE_FP_FIELD

#define TYPE_INODE_FP_FIELD n

◆ TYPE_REFTARG_FP_FIELD

#define TYPE_REFTARG_FP_FIELD r

◆ TYPE_INDEX_FP_FIELD

#define TYPE_INDEX_FP_FIELD i

◆ TYPE_MATRIX3_FP_FIELD

#define TYPE_MATRIX3_FP_FIELD m

◆ TYPE_VOID_FP_FIELD

#define TYPE_VOID_FP_FIELD void_paramtype_bad

◆ TYPE_ENUM_FP_FIELD

#define TYPE_ENUM_FP_FIELD i

◆ TYPE_INTERVAL_FP_FIELD

#define TYPE_INTERVAL_FP_FIELD intvl

◆ TYPE_ANGAXIS_FP_FIELD

#define TYPE_ANGAXIS_FP_FIELD aa

◆ TYPE_QUAT_FP_FIELD

#define TYPE_QUAT_FP_FIELD q

◆ TYPE_RAY_FP_FIELD

#define TYPE_RAY_FP_FIELD ray

◆ TYPE_POINT2_FP_FIELD

#define TYPE_POINT2_FP_FIELD p2

◆ TYPE_BITARRAY_FP_FIELD

#define TYPE_BITARRAY_FP_FIELD bits

◆ TYPE_CLASS_FP_FIELD

#define TYPE_CLASS_FP_FIELD cd

◆ TYPE_MESH_FP_FIELD

#define TYPE_MESH_FP_FIELD msh

◆ TYPE_OBJECT_FP_FIELD

#define TYPE_OBJECT_FP_FIELD obj

◆ TYPE_CONTROL_FP_FIELD

#define TYPE_CONTROL_FP_FIELD ctrl

◆ TYPE_POINT_FP_FIELD

#define TYPE_POINT_FP_FIELD pt

◆ TYPE_TSTR_FP_FIELD

#define TYPE_TSTR_FP_FIELD tstr

◆ TYPE_IOBJECT_FP_FIELD

#define TYPE_IOBJECT_FP_FIELD iobj

◆ TYPE_INTERFACE_FP_FIELD

#define TYPE_INTERFACE_FP_FIELD fpi

◆ TYPE_HWND_FP_FIELD

#define TYPE_HWND_FP_FIELD hwnd

◆ TYPE_NAME_FP_FIELD

#define TYPE_NAME_FP_FIELD s

◆ TYPE_COLOR_FP_FIELD

#define TYPE_COLOR_FP_FIELD clr

◆ TYPE_ACOLOR_FP_FIELD

#define TYPE_ACOLOR_FP_FIELD aclr

◆ TYPE_FPVALUE_FP_FIELD

#define TYPE_FPVALUE_FP_FIELD fpv

◆ TYPE_VALUE_FP_FIELD

#define TYPE_VALUE_FP_FIELD v

◆ TYPE_DWORD_FP_FIELD

#define TYPE_DWORD_FP_FIELD d

◆ TYPE_bool_FP_FIELD

#define TYPE_bool_FP_FIELD b

◆ TYPE_INTPTR_FP_FIELD

#define TYPE_INTPTR_FP_FIELD intptr

◆ TYPE_INT64_FP_FIELD

#define TYPE_INT64_FP_FIELD i64

◆ TYPE_DOUBLE_FP_FIELD

#define TYPE_DOUBLE_FP_FIELD dbl

◆ TYPE_BOX3_FP_FIELD

#define TYPE_BOX3_FP_FIELD b3

◆ TYPE_FLOAT_TAB_FP_FIELD

#define TYPE_FLOAT_TAB_FP_FIELD f_tab

◆ TYPE_INT_TAB_FP_FIELD

#define TYPE_INT_TAB_FP_FIELD i_tab

◆ TYPE_RGBA_TAB_FP_FIELD

#define TYPE_RGBA_TAB_FP_FIELD p_tab

◆ TYPE_POINT3_TAB_FP_FIELD

#define TYPE_POINT3_TAB_FP_FIELD p_tab

◆ TYPE_FRGBA_TAB_FP_FIELD

#define TYPE_FRGBA_TAB_FP_FIELD p4_tab

◆ TYPE_POINT4_TAB_FP_FIELD

#define TYPE_POINT4_TAB_FP_FIELD p4_tab

◆ TYPE_BOOL_TAB_FP_FIELD

#define TYPE_BOOL_TAB_FP_FIELD i_tab

◆ TYPE_ANGLE_TAB_FP_FIELD

#define TYPE_ANGLE_TAB_FP_FIELD f_tab

◆ TYPE_PCNT_FRAC_TAB_FP_FIELD

#define TYPE_PCNT_FRAC_TAB_FP_FIELD f_tab

◆ TYPE_WORLD_TAB_FP_FIELD

#define TYPE_WORLD_TAB_FP_FIELD f_tab

◆ TYPE_STRING_TAB_FP_FIELD

#define TYPE_STRING_TAB_FP_FIELD s_tab

◆ TYPE_FILENAME_TAB_FP_FIELD

#define TYPE_FILENAME_TAB_FP_FIELD s_tab

◆ TYPE_HSV_TAB_FP_FIELD

#define TYPE_HSV_TAB_FP_FIELD p_tab

◆ TYPE_COLOR_CHANNEL_TAB_FP_FIELD

#define TYPE_COLOR_CHANNEL_TAB_FP_FIELD f_tab

◆ TYPE_TIMEVALUE_TAB_FP_FIELD

#define TYPE_TIMEVALUE_TAB_FP_FIELD i_tab

◆ TYPE_RADIOBTN_INDEX_TAB_FP_FIELD

#define TYPE_RADIOBTN_INDEX_TAB_FP_FIELD i_tab

◆ TYPE_MTL_TAB_FP_FIELD

#define TYPE_MTL_TAB_FP_FIELD mtl_tab

◆ TYPE_TEXMAP_TAB_FP_FIELD

#define TYPE_TEXMAP_TAB_FP_FIELD tex_tab

◆ TYPE_BITMAP_TAB_FP_FIELD

#define TYPE_BITMAP_TAB_FP_FIELD bm_tab

◆ TYPE_INODE_TAB_FP_FIELD

#define TYPE_INODE_TAB_FP_FIELD n_tab

◆ TYPE_REFTARG_TAB_FP_FIELD

#define TYPE_REFTARG_TAB_FP_FIELD r_tab

◆ TYPE_INDEX_TAB_FP_FIELD

#define TYPE_INDEX_TAB_FP_FIELD i_tab

◆ TYPE_MATRIX3_TAB_FP_FIELD

#define TYPE_MATRIX3_TAB_FP_FIELD m3_tab

◆ TYPE_ENUM_TAB_FP_FIELD

#define TYPE_ENUM_TAB_FP_FIELD i_tab

◆ TYPE_INTERVAL_TAB_FP_FIELD

#define TYPE_INTERVAL_TAB_FP_FIELD intvl_tab

◆ TYPE_ANGAXIS_TAB_FP_FIELD

#define TYPE_ANGAXIS_TAB_FP_FIELD aa_tab

◆ TYPE_QUAT_TAB_FP_FIELD

#define TYPE_QUAT_TAB_FP_FIELD q_tab

◆ TYPE_RAY_TAB_FP_FIELD

#define TYPE_RAY_TAB_FP_FIELD ray_tab

◆ TYPE_POINT2_TAB_FP_FIELD

#define TYPE_POINT2_TAB_FP_FIELD p2_tab

◆ TYPE_BITARRAY_TAB_FP_FIELD

#define TYPE_BITARRAY_TAB_FP_FIELD bits_tab

◆ TYPE_CLASS_TAB_FP_FIELD

#define TYPE_CLASS_TAB_FP_FIELD cd_tab

◆ TYPE_MESH_TAB_FP_FIELD

#define TYPE_MESH_TAB_FP_FIELD msh_tab

◆ TYPE_OBJECT_TAB_FP_FIELD

#define TYPE_OBJECT_TAB_FP_FIELD obj_tab

◆ TYPE_CONTROL_TAB_FP_FIELD

#define TYPE_CONTROL_TAB_FP_FIELD ctrl_tab

◆ TYPE_POINT_TAB_FP_FIELD

#define TYPE_POINT_TAB_FP_FIELD pt_tab

◆ TYPE_TSTR_TAB_FP_FIELD

#define TYPE_TSTR_TAB_FP_FIELD tstr_tab

◆ TYPE_IOBJECT_TAB_FP_FIELD

#define TYPE_IOBJECT_TAB_FP_FIELD iobj_tab

◆ TYPE_INTERFACE_TAB_FP_FIELD

#define TYPE_INTERFACE_TAB_FP_FIELD fpi_tab

◆ TYPE_HWND_TAB_FP_FIELD

#define TYPE_HWND_TAB_FP_FIELD hwnd_tab

◆ TYPE_NAME_TAB_FP_FIELD

#define TYPE_NAME_TAB_FP_FIELD s_tab

◆ TYPE_COLOR_TAB_FP_FIELD

#define TYPE_COLOR_TAB_FP_FIELD clr_tab

◆ TYPE_ACOLOR_TAB_FP_FIELD

#define TYPE_ACOLOR_TAB_FP_FIELD aclr_tab

◆ TYPE_FPVALUE_TAB_FP_FIELD

#define TYPE_FPVALUE_TAB_FP_FIELD fpv_tab

◆ TYPE_VALUE_TAB_FP_FIELD

#define TYPE_VALUE_TAB_FP_FIELD v_tab

◆ TYPE_DWORD_TAB_FP_FIELD

#define TYPE_DWORD_TAB_FP_FIELD d_tab

◆ TYPE_bool_TAB_FP_FIELD

#define TYPE_bool_TAB_FP_FIELD b_tab

◆ TYPE_INTPTR_TAB_FP_FIELD

#define TYPE_INTPTR_TAB_FP_FIELD intptr_tab

◆ TYPE_INT64_TAB_FP_FIELD

#define TYPE_INT64_TAB_FP_FIELD i64_tab

◆ TYPE_DOUBLE_TAB_FP_FIELD

#define TYPE_DOUBLE_TAB_FP_FIELD dbl_tab

◆ TYPE_BOX3_TAB_FP_FIELD

#define TYPE_BOX3_TAB_FP_FIELD b3_tab

◆ TYPE_FLOAT_BP_FP_FIELD

#define TYPE_FLOAT_BP_FP_FIELD fptr

◆ TYPE_INT_BP_FP_FIELD

#define TYPE_INT_BP_FP_FIELD iptr

◆ TYPE_BOOL_BP_FP_FIELD

#define TYPE_BOOL_BP_FP_FIELD iptr

◆ TYPE_ANGLE_BP_FP_FIELD

#define TYPE_ANGLE_BP_FP_FIELD fptr

◆ TYPE_PCNT_FRAC_BP_FP_FIELD

#define TYPE_PCNT_FRAC_BP_FP_FIELD fptr

◆ TYPE_WORLD_BP_FP_FIELD

#define TYPE_WORLD_BP_FP_FIELD fptr

◆ TYPE_COLOR_CHANNEL_BP_FP_FIELD

#define TYPE_COLOR_CHANNEL_BP_FP_FIELD fptr

◆ TYPE_TIMEVALUE_BP_FP_FIELD

#define TYPE_TIMEVALUE_BP_FP_FIELD iptr

◆ TYPE_RADIOBTN_INDEX_BP_FP_FIELD

#define TYPE_RADIOBTN_INDEX_BP_FP_FIELD iptr

◆ TYPE_INDEX_BP_FP_FIELD

#define TYPE_INDEX_BP_FP_FIELD iptr

◆ TYPE_ENUM_BP_FP_FIELD

#define TYPE_ENUM_BP_FP_FIELD iptr

◆ TYPE_DWORD_BP_FP_FIELD

#define TYPE_DWORD_BP_FP_FIELD dptr

◆ TYPE_bool_BP_FP_FIELD

#define TYPE_bool_BP_FP_FIELD bptr

◆ TYPE_INTPTR_BP_FP_FIELD

#define TYPE_INTPTR_BP_FP_FIELD intptrptr

◆ TYPE_INT64_BP_FP_FIELD

#define TYPE_INT64_BP_FP_FIELD i64ptr

◆ TYPE_DOUBLE_BP_FP_FIELD

#define TYPE_DOUBLE_BP_FP_FIELD dblptr

◆ TYPE_FLOAT_BR_FP_FIELD

#define TYPE_FLOAT_BR_FP_FIELD fptr

◆ TYPE_INT_BR_FP_FIELD

#define TYPE_INT_BR_FP_FIELD iptr

◆ TYPE_RGBA_BR_FP_FIELD

#define TYPE_RGBA_BR_FP_FIELD p

◆ TYPE_POINT3_BR_FP_FIELD

#define TYPE_POINT3_BR_FP_FIELD p

◆ TYPE_FRGBA_BR_FP_FIELD

#define TYPE_FRGBA_BR_FP_FIELD p4

◆ TYPE_POINT4_BR_FP_FIELD

#define TYPE_POINT4_BR_FP_FIELD p4

◆ TYPE_BOOL_BR_FP_FIELD

#define TYPE_BOOL_BR_FP_FIELD iptr

◆ TYPE_ANGLE_BR_FP_FIELD

#define TYPE_ANGLE_BR_FP_FIELD fptr

◆ TYPE_PCNT_FRAC_BR_FP_FIELD

#define TYPE_PCNT_FRAC_BR_FP_FIELD fptr

◆ TYPE_WORLD_BR_FP_FIELD

#define TYPE_WORLD_BR_FP_FIELD fptr

◆ TYPE_HSV_BR_FP_FIELD

#define TYPE_HSV_BR_FP_FIELD p

◆ TYPE_COLOR_CHANNEL_BR_FP_FIELD

#define TYPE_COLOR_CHANNEL_BR_FP_FIELD f

◆ TYPE_TIMEVALUE_BR_FP_FIELD

#define TYPE_TIMEVALUE_BR_FP_FIELD iptr

◆ TYPE_RADIOBTN_INDEX_BR_FP_FIELD

#define TYPE_RADIOBTN_INDEX_BR_FP_FIELD iptr

◆ TYPE_BITMAP_BR_FP_FIELD

#define TYPE_BITMAP_BR_FP_FIELD bm

◆ TYPE_INDEX_BR_FP_FIELD

#define TYPE_INDEX_BR_FP_FIELD iptr

◆ TYPE_ENUM_BR_FP_FIELD

#define TYPE_ENUM_BR_FP_FIELD iptr

◆ TYPE_REFTARG_BR_FP_FIELD

#define TYPE_REFTARG_BR_FP_FIELD r

◆ TYPE_MATRIX3_BR_FP_FIELD

#define TYPE_MATRIX3_BR_FP_FIELD m

◆ TYPE_ANGAXIS_BR_FP_FIELD

#define TYPE_ANGAXIS_BR_FP_FIELD aa

◆ TYPE_QUAT_BR_FP_FIELD

#define TYPE_QUAT_BR_FP_FIELD q

◆ TYPE_BITARRAY_BR_FP_FIELD

#define TYPE_BITARRAY_BR_FP_FIELD bits

◆ TYPE_RAY_BR_FP_FIELD

#define TYPE_RAY_BR_FP_FIELD ray

◆ TYPE_POINT2_BR_FP_FIELD

#define TYPE_POINT2_BR_FP_FIELD p2

◆ TYPE_MESH_BR_FP_FIELD

#define TYPE_MESH_BR_FP_FIELD msh

◆ TYPE_INTERVAL_BR_FP_FIELD

#define TYPE_INTERVAL_BR_FP_FIELD intvl

◆ TYPE_POINT_BR_FP_FIELD

#define TYPE_POINT_BR_FP_FIELD pt

◆ TYPE_TSTR_BR_FP_FIELD

#define TYPE_TSTR_BR_FP_FIELD tstr

◆ TYPE_COLOR_BR_FP_FIELD

#define TYPE_COLOR_BR_FP_FIELD clr

◆ TYPE_ACOLOR_BR_FP_FIELD

#define TYPE_ACOLOR_BR_FP_FIELD aclr

◆ TYPE_FPVALUE_BR_FP_FIELD

#define TYPE_FPVALUE_BR_FP_FIELD fpv

◆ TYPE_DWORD_BR_FP_FIELD

#define TYPE_DWORD_BR_FP_FIELD dptr

◆ TYPE_bool_BR_FP_FIELD

#define TYPE_bool_BR_FP_FIELD bptr

◆ TYPE_INTPTR_BR_FP_FIELD

#define TYPE_INTPTR_BR_FP_FIELD intptrptr

◆ TYPE_INT64_BR_FP_FIELD

#define TYPE_INT64_BR_FP_FIELD i64ptr

◆ TYPE_DOUBLE_BR_FP_FIELD

#define TYPE_DOUBLE_BR_FP_FIELD dblptr

◆ TYPE_BOX3_BR_FP_FIELD

#define TYPE_BOX3_BR_FP_FIELD b3

◆ TYPE_FLOAT_TAB_BR_FP_FIELD

#define TYPE_FLOAT_TAB_BR_FP_FIELD f_tab

◆ TYPE_INT_TAB_BR_FP_FIELD

#define TYPE_INT_TAB_BR_FP_FIELD i_tab

◆ TYPE_RGBA_TAB_BR_FP_FIELD

#define TYPE_RGBA_TAB_BR_FP_FIELD p_tab

◆ TYPE_POINT3_TAB_BR_FP_FIELD

#define TYPE_POINT3_TAB_BR_FP_FIELD p_tab

◆ TYPE_FRGBA_TAB_BR_FP_FIELD

#define TYPE_FRGBA_TAB_BR_FP_FIELD p4_tab

◆ TYPE_POINT4_TAB_BR_FP_FIELD

#define TYPE_POINT4_TAB_BR_FP_FIELD p4_tab

◆ TYPE_BOOL_TAB_BR_FP_FIELD

#define TYPE_BOOL_TAB_BR_FP_FIELD i_tab

◆ TYPE_ANGLE_TAB_BR_FP_FIELD

#define TYPE_ANGLE_TAB_BR_FP_FIELD f_tab

◆ TYPE_PCNT_FRAC_TAB_BR_FP_FIELD

#define TYPE_PCNT_FRAC_TAB_BR_FP_FIELD f_tab

◆ TYPE_WORLD_TAB_BR_FP_FIELD

#define TYPE_WORLD_TAB_BR_FP_FIELD f_tab

◆ TYPE_STRING_TAB_BR_FP_FIELD

#define TYPE_STRING_TAB_BR_FP_FIELD s_tab

◆ TYPE_FILENAME_TAB_BR_FP_FIELD

#define TYPE_FILENAME_TAB_BR_FP_FIELD s_tab

◆ TYPE_HSV_TAB_BR_FP_FIELD

#define TYPE_HSV_TAB_BR_FP_FIELD p_tab

◆ TYPE_COLOR_CHANNEL_TAB_BR_FP_FIELD

#define TYPE_COLOR_CHANNEL_TAB_BR_FP_FIELD f_tab

◆ TYPE_TIMEVALUE_TAB_BR_FP_FIELD

#define TYPE_TIMEVALUE_TAB_BR_FP_FIELD i_tab

◆ TYPE_RADIOBTN_INDEX_TAB_BR_FP_FIELD

#define TYPE_RADIOBTN_INDEX_TAB_BR_FP_FIELD i_tab

◆ TYPE_MTL_TAB_BR_FP_FIELD

#define TYPE_MTL_TAB_BR_FP_FIELD mtl_tab

◆ TYPE_TEXMAP_TAB_BR_FP_FIELD

#define TYPE_TEXMAP_TAB_BR_FP_FIELD tex_tab

◆ TYPE_BITMAP_TAB_BR_FP_FIELD

#define TYPE_BITMAP_TAB_BR_FP_FIELD bm_tab

◆ TYPE_INODE_TAB_BR_FP_FIELD

#define TYPE_INODE_TAB_BR_FP_FIELD n_tab

◆ TYPE_REFTARG_TAB_BR_FP_FIELD

#define TYPE_REFTARG_TAB_BR_FP_FIELD r_tab

◆ TYPE_INDEX_TAB_BR_FP_FIELD

#define TYPE_INDEX_TAB_BR_FP_FIELD i_tab

◆ TYPE_ENUM_TAB_BR_FP_FIELD

#define TYPE_ENUM_TAB_BR_FP_FIELD i_tab

◆ TYPE_MATRIX3_TAB_BR_FP_FIELD

#define TYPE_MATRIX3_TAB_BR_FP_FIELD m3_tab

◆ TYPE_ANGAXIS_TAB_BR_FP_FIELD

#define TYPE_ANGAXIS_TAB_BR_FP_FIELD aa_tab

◆ TYPE_QUAT_TAB_BR_FP_FIELD

#define TYPE_QUAT_TAB_BR_FP_FIELD q_tab

◆ TYPE_BITARRAY_TAB_BR_FP_FIELD

#define TYPE_BITARRAY_TAB_BR_FP_FIELD bits_tab

◆ TYPE_CLASS_TAB_BR_FP_FIELD

#define TYPE_CLASS_TAB_BR_FP_FIELD cd_tab

◆ TYPE_RAY_TAB_BR_FP_FIELD

#define TYPE_RAY_TAB_BR_FP_FIELD ray_tab

◆ TYPE_POINT2_TAB_BR_FP_FIELD

#define TYPE_POINT2_TAB_BR_FP_FIELD p2_tab

◆ TYPE_MESH_TAB_BR_FP_FIELD

#define TYPE_MESH_TAB_BR_FP_FIELD msh_tab

◆ TYPE_OBJECT_TAB_BR_FP_FIELD

#define TYPE_OBJECT_TAB_BR_FP_FIELD obj_tab

◆ TYPE_CONTROL_TAB_BR_FP_FIELD

#define TYPE_CONTROL_TAB_BR_FP_FIELD ctrl_tab

◆ TYPE_INTERVAL_TAB_BR_FP_FIELD

#define TYPE_INTERVAL_TAB_BR_FP_FIELD intvl_tab

◆ TYPE_POINT_TAB_BR_FP_FIELD

#define TYPE_POINT_TAB_BR_FP_FIELD pt_tab

◆ TYPE_HWND_TAB_BR_FP_FIELD

#define TYPE_HWND_TAB_BR_FP_FIELD hwnd_tab

◆ TYPE_TSTR_TAB_BR_FP_FIELD

#define TYPE_TSTR_TAB_BR_FP_FIELD tstr_tab

◆ TYPE_IOBJECT_TAB_BR_FP_FIELD

#define TYPE_IOBJECT_TAB_BR_FP_FIELD iobj_tab

◆ TYPE_INTERFACE_TAB_BR_FP_FIELD

#define TYPE_INTERFACE_TAB_BR_FP_FIELD fpi_tab

◆ TYPE_NAME_TAB_BR_FP_FIELD

#define TYPE_NAME_TAB_BR_FP_FIELD s_tab

◆ TYPE_COLOR_TAB_BR_FP_FIELD

#define TYPE_COLOR_TAB_BR_FP_FIELD clr_tab

◆ TYPE_ACOLOR_TAB_BR_FP_FIELD

#define TYPE_ACOLOR_TAB_BR_FP_FIELD aclr_tab

◆ TYPE_FPVALUE_TAB_BR_FP_FIELD

#define TYPE_FPVALUE_TAB_BR_FP_FIELD fpv_tab

◆ TYPE_VALUE_TAB_BR_FP_FIELD

#define TYPE_VALUE_TAB_BR_FP_FIELD v_tab

◆ TYPE_DWORD_TAB_BR_FP_FIELD

#define TYPE_DWORD_TAB_BR_FP_FIELD d_tab

◆ TYPE_bool_TAB_BR_FP_FIELD

#define TYPE_bool_TAB_BR_FP_FIELD b_tab

◆ TYPE_INTPTR_TAB_BR_FP_FIELD

#define TYPE_INTPTR_TAB_BR_FP_FIELD intptr_tab

◆ TYPE_INT64_TAB_BR_FP_FIELD

#define TYPE_INT64_TAB_BR_FP_FIELD i64_tab

◆ TYPE_DOUBLE_TAB_BR_FP_FIELD

#define TYPE_DOUBLE_TAB_BR_FP_FIELD dbl_tab

◆ TYPE_BOX3_TAB_BR_FP_FIELD

#define TYPE_BOX3_TAB_BR_FP_FIELD b3_tab

◆ TYPE_RGBA_BV_FP_FIELD

#define TYPE_RGBA_BV_FP_FIELD p

◆ TYPE_POINT3_BV_FP_FIELD

#define TYPE_POINT3_BV_FP_FIELD p

◆ TYPE_FRGBA_BV_FP_FIELD

#define TYPE_FRGBA_BV_FP_FIELD p4

◆ TYPE_POINT4_BV_FP_FIELD

#define TYPE_POINT4_BV_FP_FIELD p4

◆ TYPE_HSV_BV_FP_FIELD

#define TYPE_HSV_BV_FP_FIELD p

◆ TYPE_BITMAP_BV_FP_FIELD

#define TYPE_BITMAP_BV_FP_FIELD bm

◆ TYPE_MATRIX3_BV_FP_FIELD

#define TYPE_MATRIX3_BV_FP_FIELD m

◆ TYPE_ANGAXIS_BV_FP_FIELD

#define TYPE_ANGAXIS_BV_FP_FIELD aa

◆ TYPE_QUAT_BV_FP_FIELD

#define TYPE_QUAT_BV_FP_FIELD q

◆ TYPE_BITARRAY_BV_FP_FIELD

#define TYPE_BITARRAY_BV_FP_FIELD bits

◆ TYPE_RAY_BV_FP_FIELD

#define TYPE_RAY_BV_FP_FIELD ray

◆ TYPE_POINT2_BV_FP_FIELD

#define TYPE_POINT2_BV_FP_FIELD p2

◆ TYPE_MESH_BV_FP_FIELD

#define TYPE_MESH_BV_FP_FIELD msh

◆ TYPE_INTERVAL_BV_FP_FIELD

#define TYPE_INTERVAL_BV_FP_FIELD intvl

◆ TYPE_POINT_BV_FP_FIELD

#define TYPE_POINT_BV_FP_FIELD pt

◆ TYPE_TSTR_BV_FP_FIELD

#define TYPE_TSTR_BV_FP_FIELD tstr

◆ TYPE_COLOR_BV_FP_FIELD

#define TYPE_COLOR_BV_FP_FIELD clr

◆ TYPE_ACOLOR_BV_FP_FIELD

#define TYPE_ACOLOR_BV_FP_FIELD aclr

◆ TYPE_FPVALUE_BV_FP_FIELD

#define TYPE_FPVALUE_BV_FP_FIELD fpv

◆ TYPE_CLASS_BV_FP_FIELD

#define TYPE_CLASS_BV_FP_FIELD cd

◆ TYPE_BOX3_BV_FP_FIELD

#define TYPE_BOX3_BV_FP_FIELD b3

◆ TYPE_FLOAT_TAB_BV_FP_FIELD

#define TYPE_FLOAT_TAB_BV_FP_FIELD f_tab

◆ TYPE_INT_TAB_BV_FP_FIELD

#define TYPE_INT_TAB_BV_FP_FIELD i_tab

◆ TYPE_RGBA_TAB_BV_FP_FIELD

#define TYPE_RGBA_TAB_BV_FP_FIELD p_tab

◆ TYPE_POINT3_TAB_BV_FP_FIELD

#define TYPE_POINT3_TAB_BV_FP_FIELD p_tab

◆ TYPE_FRGBA_TAB_BV_FP_FIELD

#define TYPE_FRGBA_TAB_BV_FP_FIELD p4_tab

◆ TYPE_POINT4_TAB_BV_FP_FIELD

#define TYPE_POINT4_TAB_BV_FP_FIELD p4_tab

◆ TYPE_BOOL_TAB_BV_FP_FIELD

#define TYPE_BOOL_TAB_BV_FP_FIELD i_tab

◆ TYPE_ANGLE_TAB_BV_FP_FIELD

#define TYPE_ANGLE_TAB_BV_FP_FIELD f_tab

◆ TYPE_PCNT_FRAC_TAB_BV_FP_FIELD

#define TYPE_PCNT_FRAC_TAB_BV_FP_FIELD f_tab

◆ TYPE_WORLD_TAB_BV_FP_FIELD

#define TYPE_WORLD_TAB_BV_FP_FIELD f_tab

◆ TYPE_STRING_TAB_BV_FP_FIELD

#define TYPE_STRING_TAB_BV_FP_FIELD s_tab

◆ TYPE_FILENAME_TAB_BV_FP_FIELD

#define TYPE_FILENAME_TAB_BV_FP_FIELD s_tab

◆ TYPE_HSV_TAB_BV_FP_FIELD

#define TYPE_HSV_TAB_BV_FP_FIELD p_tab

◆ TYPE_COLOR_CHANNEL_TAB_BV_FP_FIELD

#define TYPE_COLOR_CHANNEL_TAB_BV_FP_FIELD f_tab

◆ TYPE_TIMEVALUE_TAB_BV_FP_FIELD

#define TYPE_TIMEVALUE_TAB_BV_FP_FIELD i_tab

◆ TYPE_RADIOBTN_INDEX_TAB_BV_FP_FIELD

#define TYPE_RADIOBTN_INDEX_TAB_BV_FP_FIELD i_tab

◆ TYPE_MTL_TAB_BV_FP_FIELD

#define TYPE_MTL_TAB_BV_FP_FIELD mtl_tab

◆ TYPE_TEXMAP_TAB_BV_FP_FIELD

#define TYPE_TEXMAP_TAB_BV_FP_FIELD tex_tab

◆ TYPE_BITMAP_TAB_BV_FP_FIELD

#define TYPE_BITMAP_TAB_BV_FP_FIELD bm_tab

◆ TYPE_INODE_TAB_BV_FP_FIELD

#define TYPE_INODE_TAB_BV_FP_FIELD n_tab

◆ TYPE_REFTARG_TAB_BV_FP_FIELD

#define TYPE_REFTARG_TAB_BV_FP_FIELD r_tab

◆ TYPE_INDEX_TAB_BV_FP_FIELD

#define TYPE_INDEX_TAB_BV_FP_FIELD i_tab

◆ TYPE_ENUM_TAB_BV_FP_FIELD

#define TYPE_ENUM_TAB_BV_FP_FIELD i_tab

◆ TYPE_MATRIX3_TAB_BV_FP_FIELD

#define TYPE_MATRIX3_TAB_BV_FP_FIELD m3_tab

◆ TYPE_ANGAXIS_TAB_BV_FP_FIELD

#define TYPE_ANGAXIS_TAB_BV_FP_FIELD aa_tab

◆ TYPE_QUAT_TAB_BV_FP_FIELD

#define TYPE_QUAT_TAB_BV_FP_FIELD q_tab

◆ TYPE_BITARRAY_TAB_BV_FP_FIELD

#define TYPE_BITARRAY_TAB_BV_FP_FIELD bits_tab

◆ TYPE_CLASS_TAB_BV_FP_FIELD

#define TYPE_CLASS_TAB_BV_FP_FIELD cd_tab

◆ TYPE_RAY_TAB_BV_FP_FIELD

#define TYPE_RAY_TAB_BV_FP_FIELD ray_tab

◆ TYPE_POINT2_TAB_BV_FP_FIELD

#define TYPE_POINT2_TAB_BV_FP_FIELD p2_tab

◆ TYPE_MESH_TAB_BV_FP_FIELD

#define TYPE_MESH_TAB_BV_FP_FIELD msh_tab

◆ TYPE_OBJECT_TAB_BV_FP_FIELD

#define TYPE_OBJECT_TAB_BV_FP_FIELD obj_tab

◆ TYPE_CONTROL_TAB_BV_FP_FIELD

#define TYPE_CONTROL_TAB_BV_FP_FIELD ctrl_tab

◆ TYPE_INTERVAL_TAB_BV_FP_FIELD

#define TYPE_INTERVAL_TAB_BV_FP_FIELD intvl_tab

◆ TYPE_POINT_TAB_BV_FP_FIELD

#define TYPE_POINT_TAB_BV_FP_FIELD pt_tab

◆ TYPE_HWND_TAB_BV_FP_FIELD

#define TYPE_HWND_TAB_BV_FP_FIELD hwnd_tab

◆ TYPE_TSTR_TAB_BV_FP_FIELD

#define TYPE_TSTR_TAB_BV_FP_FIELD tstr_tab

◆ TYPE_IOBJECT_TAB_BV_FP_FIELD

#define TYPE_IOBJECT_TAB_BV_FP_FIELD iobj_tab

◆ TYPE_INTERFACE_TAB_BV_FP_FIELD

#define TYPE_INTERFACE_TAB_BV_FP_FIELD fpi_tab

◆ TYPE_NAME_TAB_BV_FP_FIELD

#define TYPE_NAME_TAB_BV_FP_FIELD s_tab

◆ TYPE_COLOR_TAB_BV_FP_FIELD

#define TYPE_COLOR_TAB_BV_FP_FIELD clr_tab

◆ TYPE_ACOLOR_TAB_BV_FP_FIELD

#define TYPE_ACOLOR_TAB_BV_FP_FIELD aclr_tab

◆ TYPE_FPVALUE_TAB_BV_FP_FIELD

#define TYPE_FPVALUE_TAB_BV_FP_FIELD fpv_tab

◆ TYPE_VALUE_TAB_BV_FP_FIELD

#define TYPE_VALUE_TAB_BV_FP_FIELD v_tab

◆ TYPE_DWORD_TAB_BV_FP_FIELD

#define TYPE_DWORD_TAB_BV_FP_FIELD d_tab

◆ TYPE_bool_TAB_BV_FP_FIELD

#define TYPE_bool_TAB_BV_FP_FIELD b_tab

◆ TYPE_INTPTR_TAB_BV_FP_FIELD

#define TYPE_INTPTR_TAB_BV_FP_FIELD intptr_tab

◆ TYPE_INT64_TAB_BV_FP_FIELD

#define TYPE_INT64_TAB_BV_FP_FIELD i64_tab

◆ TYPE_DOUBLE_TAB_BV_FP_FIELD

#define TYPE_DOUBLE_TAB_BV_FP_FIELD dbl_tab

◆ TYPE_BOX3_TAB_BV_FP_FIELD

#define TYPE_BOX3_TAB_BV_FP_FIELD b3_tab

◆ TYPE_FLOAT_FIELD

#define TYPE_FLOAT_FIELD ( _v ) (((_v).f))

◆ TYPE_INT_FIELD

#define TYPE_INT_FIELD ( _v ) (((_v).i))

◆ TYPE_RGBA_FIELD

#define TYPE_RGBA_FIELD ( _v ) (*((_v).p))

◆ TYPE_POINT3_FIELD

#define TYPE_POINT3_FIELD ( _v ) (*((_v).p))

◆ TYPE_FRGBA_FIELD

#define TYPE_FRGBA_FIELD ( _v ) (*((_v).p4))

◆ TYPE_POINT4_FIELD

#define TYPE_POINT4_FIELD ( _v ) (*((_v).p4))

◆ TYPE_BOOL_FIELD

#define TYPE_BOOL_FIELD ( _v ) (((_v).i))

◆ TYPE_ANGLE_FIELD

#define TYPE_ANGLE_FIELD ( _v ) (((_v).f))

◆ TYPE_PCNT_FRAC_FIELD

#define TYPE_PCNT_FRAC_FIELD ( _v ) (((_v).f))

◆ TYPE_WORLD_FIELD

#define TYPE_WORLD_FIELD ( _v ) (((_v).f))

◆ TYPE_STRING_FIELD

#define TYPE_STRING_FIELD ( _v ) (((_v).s))

◆ TYPE_FILENAME_FIELD

#define TYPE_FILENAME_FIELD ( _v ) (((_v).s))

◆ TYPE_HSV_FIELD

#define TYPE_HSV_FIELD ( _v ) (*((_v).p))

◆ TYPE_COLOR_CHANNEL_FIELD

#define TYPE_COLOR_CHANNEL_FIELD ( _v ) (((_v).f))

◆ TYPE_TIMEVALUE_FIELD

#define TYPE_TIMEVALUE_FIELD ( _v ) (((_v).i))

◆ TYPE_RADIOBTN_INDEX_FIELD

#define TYPE_RADIOBTN_INDEX_FIELD ( _v ) (((_v).i))

◆ TYPE_MTL_FIELD

#define TYPE_MTL_FIELD ( _v ) (((_v).mtl))

◆ TYPE_TEXMAP_FIELD

#define TYPE_TEXMAP_FIELD ( _v ) (((_v).tex))

◆ TYPE_BITMAP_FIELD

#define TYPE_BITMAP_FIELD ( _v ) (((_v).bm))

◆ TYPE_INODE_FIELD

#define TYPE_INODE_FIELD ( _v ) (((_v).n))

◆ TYPE_REFTARG_FIELD

#define TYPE_REFTARG_FIELD ( _v ) (((_v).r))

◆ TYPE_INDEX_FIELD

#define TYPE_INDEX_FIELD ( _v ) (((_v).i))

◆ TYPE_ENUM_FIELD

#define TYPE_ENUM_FIELD ( _v ) (((_v).i))

◆ TYPE_MATRIX3_FIELD

#define TYPE_MATRIX3_FIELD ( _v ) (*((_v).m))

◆ TYPE_ANGAXIS_FIELD

#define TYPE_ANGAXIS_FIELD ( _v ) (*((_v).aa))

◆ TYPE_QUAT_FIELD

#define TYPE_QUAT_FIELD ( _v ) (*((_v).q))

◆ TYPE_BITARRAY_FIELD

#define TYPE_BITARRAY_FIELD ( _v ) (((_v).bits))

◆ TYPE_CLASS_FIELD

#define TYPE_CLASS_FIELD ( _v ) (((_v).cd))

◆ TYPE_RAY_FIELD

#define TYPE_RAY_FIELD ( _v ) (*((_v).ray))

◆ TYPE_POINT2_FIELD

#define TYPE_POINT2_FIELD ( _v ) (*((_v).p2))

◆ TYPE_MESH_FIELD

#define TYPE_MESH_FIELD ( _v ) (((_v).msh))

◆ TYPE_OBJECT_FIELD

#define TYPE_OBJECT_FIELD ( _v ) (((_v).obj))

◆ TYPE_CONTROL_FIELD

#define TYPE_CONTROL_FIELD ( _v ) (((_v).ctrl))

◆ TYPE_INTERVAL_FIELD

#define TYPE_INTERVAL_FIELD ( _v ) (*((_v).intvl))

◆ TYPE_POINT_FIELD

#define TYPE_POINT_FIELD ( _v ) (*((_v).pt))

◆ TYPE_TSTR_FIELD

#define TYPE_TSTR_FIELD ( _v ) (*((_v).tstr))

◆ TYPE_IOBJECT_FIELD

#define TYPE_IOBJECT_FIELD ( _v ) (((_v).iobj))

◆ TYPE_INTERFACE_FIELD

#define TYPE_INTERFACE_FIELD ( _v ) (((_v).fpi))

◆ TYPE_HWND_FIELD

#define TYPE_HWND_FIELD ( _v ) (((_v).hwnd))

◆ TYPE_NAME_FIELD

#define TYPE_NAME_FIELD ( _v ) (((_v).s))

◆ TYPE_COLOR_FIELD

#define TYPE_COLOR_FIELD ( _v ) (((_v).clr))

◆ TYPE_ACOLOR_FIELD

#define TYPE_ACOLOR_FIELD ( _v ) (((_v).aclr))

◆ TYPE_FPVALUE_FIELD

#define TYPE_FPVALUE_FIELD ( _v ) (((_v).fpv))

◆ TYPE_VALUE_FIELD

#define TYPE_VALUE_FIELD ( _v ) (((_v).v))

◆ TYPE_DWORD_FIELD

#define TYPE_DWORD_FIELD ( _v ) (((_v).d))

◆ TYPE_bool_FIELD

#define TYPE_bool_FIELD ( _v ) (((_v).b))

◆ TYPE_INTPTR_FIELD

#define TYPE_INTPTR_FIELD ( _v ) (((_v).intptr))

◆ TYPE_INT64_FIELD

#define TYPE_INT64_FIELD ( _v ) (((_v).i64))

◆ TYPE_DOUBLE_FIELD

#define TYPE_DOUBLE_FIELD ( _v ) (((_v).dbl))

◆ TYPE_BOX3_FIELD

#define TYPE_BOX3_FIELD ( _v ) (*((_v).b3))

◆ TYPE_FLOAT_TAB_FIELD

#define TYPE_FLOAT_TAB_FIELD ( _v ) (((_v).f_tab))

◆ TYPE_INT_TAB_FIELD

#define TYPE_INT_TAB_FIELD ( _v ) (((_v).i_tab))

◆ TYPE_RGBA_TAB_FIELD

#define TYPE_RGBA_TAB_FIELD ( _v ) (((_v).p_tab))

◆ TYPE_POINT3_TAB_FIELD

#define TYPE_POINT3_TAB_FIELD ( _v ) (((_v).p_tab))

◆ TYPE_FRGBA_TAB_FIELD

#define TYPE_FRGBA_TAB_FIELD ( _v ) (((_v).p4_tab))

◆ TYPE_POINT4_TAB_FIELD

#define TYPE_POINT4_TAB_FIELD ( _v ) (((_v).p4_tab))

◆ TYPE_BOOL_TAB_FIELD

#define TYPE_BOOL_TAB_FIELD ( _v ) (((_v).i_tab))

◆ TYPE_ANGLE_TAB_FIELD

#define TYPE_ANGLE_TAB_FIELD ( _v ) (((_v).f_tab))

◆ TYPE_PCNT_FRAC_TAB_FIELD

#define TYPE_PCNT_FRAC_TAB_FIELD ( _v ) (((_v).f_tab))

◆ TYPE_WORLD_TAB_FIELD

#define TYPE_WORLD_TAB_FIELD ( _v ) (((_v).f_tab))

◆ TYPE_STRING_TAB_FIELD

#define TYPE_STRING_TAB_FIELD ( _v ) (((_v).s_tab))

◆ TYPE_FILENAME_TAB_FIELD

#define TYPE_FILENAME_TAB_FIELD ( _v ) (((_v).s_tab))

◆ TYPE_HSV_TAB_FIELD

#define TYPE_HSV_TAB_FIELD ( _v ) (((_v).p_tab))

◆ TYPE_COLOR_CHANNEL_TAB_FIELD

#define TYPE_COLOR_CHANNEL_TAB_FIELD ( _v ) (((_v).f_tab))

◆ TYPE_TIMEVALUE_TAB_FIELD

#define TYPE_TIMEVALUE_TAB_FIELD ( _v ) (((_v).i_tab))

◆ TYPE_RADIOBTN_INDEX_TAB_FIELD

#define TYPE_RADIOBTN_INDEX_TAB_FIELD ( _v ) (((_v).i_tab))

◆ TYPE_MTL_TAB_FIELD

#define TYPE_MTL_TAB_FIELD ( _v ) (((_v).mtl_tab))

◆ TYPE_TEXMAP_TAB_FIELD

#define TYPE_TEXMAP_TAB_FIELD ( _v ) (((_v).tex_tab))

◆ TYPE_BITMAP_TAB_FIELD

#define TYPE_BITMAP_TAB_FIELD ( _v ) (((_v).bm_tab))

◆ TYPE_INODE_TAB_FIELD

#define TYPE_INODE_TAB_FIELD ( _v ) (((_v).n_tab))

◆ TYPE_REFTARG_TAB_FIELD

#define TYPE_REFTARG_TAB_FIELD ( _v ) (((_v).r_tab))

◆ TYPE_INDEX_TAB_FIELD

#define TYPE_INDEX_TAB_FIELD ( _v ) (((_v).i_tab))

◆ TYPE_ENUM_TAB_FIELD

#define TYPE_ENUM_TAB_FIELD ( _v ) (((_v).i_tab))

◆ TYPE_MATRIX3_TAB_FIELD

#define TYPE_MATRIX3_TAB_FIELD ( _v ) (((_v).m3_tab))

◆ TYPE_ANGAXIS_TAB_FIELD

#define TYPE_ANGAXIS_TAB_FIELD ( _v ) (((_v).aa_tab))

◆ TYPE_QUAT_TAB_FIELD

#define TYPE_QUAT_TAB_FIELD ( _v ) (((_v).q_tab))

◆ TYPE_BITARRAY_TAB_FIELD

#define TYPE_BITARRAY_TAB_FIELD ( _v ) (((_v).bits_tab))

◆ TYPE_CLASS_TAB_FIELD

#define TYPE_CLASS_TAB_FIELD ( _v ) (((_v).cd_tab))

◆ TYPE_RAY_TAB_FIELD

#define TYPE_RAY_TAB_FIELD ( _v ) (((_v).ray_tab))

◆ TYPE_POINT2_TAB_FIELD

#define TYPE_POINT2_TAB_FIELD ( _v ) (((_v).p2_tab))

◆ TYPE_MESH_TAB_FIELD

#define TYPE_MESH_TAB_FIELD ( _v ) (((_v).msh_tab))

◆ TYPE_OBJECT_TAB_FIELD

#define TYPE_OBJECT_TAB_FIELD ( _v ) (((_v).obj_tab))

◆ TYPE_CONTROL_TAB_FIELD

#define TYPE_CONTROL_TAB_FIELD ( _v ) (((_v).ctrl_tab))

◆ TYPE_INTERVAL_TAB_FIELD

#define TYPE_INTERVAL_TAB_FIELD ( _v ) (((_v).intvl_tab))

◆ TYPE_POINT_TAB_FIELD

#define TYPE_POINT_TAB_FIELD ( _v ) (((_v).pt_tab))

◆ TYPE_TSTRT_TAB_FIELD

#define TYPE_TSTRT_TAB_FIELD ( _v ) (((_v).tstr_tab))

◆ TYPE_IOBJECT_TAB_FIELD

#define TYPE_IOBJECT_TAB_FIELD ( _v ) (((_v).iobj_tab))

◆ TYPE_INTERFACE_TAB_FIELD

#define TYPE_INTERFACE_TAB_FIELD ( _v ) (((_v).fpi_tab))

◆ TYPE_HWND_TAB_FIELD

#define TYPE_HWND_TAB_FIELD ( _v ) (((_v).hwnd_tab))

◆ TYPE_NAME_TAB_FIELD

#define TYPE_NAME_TAB_FIELD ( _v ) (((_v).s_tab))

◆ TYPE_COLOR_TAB_FIELD

#define TYPE_COLOR_TAB_FIELD ( _v ) (((_v).clr_tab))

◆ TYPE_ACOLOR_TAB_FIELD

#define TYPE_ACOLOR_TAB_FIELD ( _v ) (((_v).aclr_tab))

◆ TYPE_FPVALUE_TAB_FIELD

#define TYPE_FPVALUE_TAB_FIELD ( _v ) (((_v).fpv_tab))

◆ TYPE_VALUE_TAB_FIELD

#define TYPE_VALUE_TAB_FIELD ( _v ) (((_v).v_tab))

◆ TYPE_DWORD_TAB_FIELD

#define TYPE_DWORD_TAB_FIELD ( _v ) (((_v).d_tab))

◆ TYPE_bool_TAB_FIELD

#define TYPE_bool_TAB_FIELD ( _v ) (((_v).b_tab))

◆ TYPE_INTPTR_TAB_FIELD

#define TYPE_INTPTR_TAB_FIELD ( _v ) (((_v).intptr_tab))

◆ TYPE_INT64_TAB_FIELD

#define TYPE_INT64_TAB_FIELD ( _v ) (((_v).i64_tab))

◆ TYPE_DOUBLE_TAB_FIELD

#define TYPE_DOUBLE_TAB_FIELD ( _v ) (((_v).dbl_tab))

◆ TYPE_BOX3_TAB_FIELD

#define TYPE_BOX3_TAB_FIELD ( _v ) (((_v).b3_tab))

◆ TYPE_FLOAT_BP_FIELD

#define TYPE_FLOAT_BP_FIELD ( _v ) (((_v).fptr))

◆ TYPE_INT_BP_FIELD

#define TYPE_INT_BP_FIELD ( _v ) (((_v).iptr))

◆ TYPE_BOOL_BP_FIELD

#define TYPE_BOOL_BP_FIELD ( _v ) (((_v).iptr))

◆ TYPE_ANGLE_BP_FIELD

#define TYPE_ANGLE_BP_FIELD ( _v ) (((_v).fptr))

◆ TYPE_PCNT_FRAC_BP_FIELD

#define TYPE_PCNT_FRAC_BP_FIELD ( _v ) (((_v).fptr))

◆ TYPE_WORLD_BP_FIELD

#define TYPE_WORLD_BP_FIELD ( _v ) (((_v).fptr))

◆ TYPE_COLOR_CHANNEL_BP_FIELD

#define TYPE_COLOR_CHANNEL_BP_FIELD ( _v ) (((_v).fptr))

◆ TYPE_TIMEVALUE_BP_FIELD

#define TYPE_TIMEVALUE_BP_FIELD ( _v ) (((_v).iptr))

◆ TYPE_RADIOBTN_INDEX_BP_FIELD

#define TYPE_RADIOBTN_INDEX_BP_FIELD ( _v ) (((_v).iptr))

◆ TYPE_INDEX_BP_FIELD

#define TYPE_INDEX_BP_FIELD ( _v ) (((_v).iptr))

◆ TYPE_ENUM_BP_FIELD

#define TYPE_ENUM_BP_FIELD ( _v ) (((_v).iptr))

◆ TYPE_DWORD_BP_FIELD

#define TYPE_DWORD_BP_FIELD ( _v ) (((_v).dptr))

◆ TYPE_bool_BP_FIELD

#define TYPE_bool_BP_FIELD ( _v ) (((_v).bptr))

◆ TYPE_INTPTR_BP_FIELD

#define TYPE_INTPTR_BP_FIELD ( _v ) (((_v).intptrptr))

◆ TYPE_INT64_BP_FIELD

#define TYPE_INT64_BP_FIELD ( _v ) (((_v).i64ptr))

◆ TYPE_DOUBLE_BP_FIELD

#define TYPE_DOUBLE_BP_FIELD ( _v ) (((_v).dblptr))

◆ TYPE_FLOAT_BR_FIELD

#define TYPE_FLOAT_BR_FIELD ( _v ) (*((_v).fptr))

◆ TYPE_INT_BR_FIELD

#define TYPE_INT_BR_FIELD ( _v ) (*((_v).iptr))

◆ TYPE_RGBA_BR_FIELD

#define TYPE_RGBA_BR_FIELD ( _v ) (*((_v).p))

◆ TYPE_POINT3_BR_FIELD

#define TYPE_POINT3_BR_FIELD ( _v ) (*((_v).p))

◆ TYPE_FRGBA_BR_FIELD

#define TYPE_FRGBA_BR_FIELD ( _v ) (*((_v).p4))

◆ TYPE_POINT4_BR_FIELD

#define TYPE_POINT4_BR_FIELD ( _v ) (*((_v).p4))

◆ TYPE_BOOL_BR_FIELD

#define TYPE_BOOL_BR_FIELD ( _v ) (*((_v).iptr))

◆ TYPE_ANGLE_BR_FIELD

#define TYPE_ANGLE_BR_FIELD ( _v ) (*((_v).fptr))

◆ TYPE_PCNT_FRAC_BR_FIELD

#define TYPE_PCNT_FRAC_BR_FIELD ( _v ) (*((_v).fptr))

◆ TYPE_WORLD_BR_FIELD

#define TYPE_WORLD_BR_FIELD ( _v ) (*((_v).fptr))

◆ TYPE_HSV_BR_FIELD

#define TYPE_HSV_BR_FIELD ( _v ) (*((_v).p))

◆ TYPE_COLOR_CHANNEL_BR_FIELD

#define TYPE_COLOR_CHANNEL_BR_FIELD ( _v ) (*((_v).fptr))

◆ TYPE_TIMEVALUE_BR_FIELD

#define TYPE_TIMEVALUE_BR_FIELD ( _v ) (*((_v).iptr))

◆ TYPE_RADIOBTN_INDEX_BR_FIELD

#define TYPE_RADIOBTN_INDEX_BR_FIELD ( _v ) (*((_v).iptr))

◆ TYPE_BITMAP_BR_FIELD

#define TYPE_BITMAP_BR_FIELD ( _v ) (*((_v).bm))

◆ TYPE_INDEX_BR_FIELD

#define TYPE_INDEX_BR_FIELD ( _v ) (*((_v).iptr))

◆ TYPE_ENUM_BR_FIELD

#define TYPE_ENUM_BR_FIELD ( _v ) (*((_v).iptr))

◆ TYPE_REFTARG_BR_FIELD

#define TYPE_REFTARG_BR_FIELD ( _v ) (*((_v).r))

◆ TYPE_MATRIX3_BR_FIELD

#define TYPE_MATRIX3_BR_FIELD ( _v ) (*((_v).m))

◆ TYPE_ANGAXIS_BR_FIELD

#define TYPE_ANGAXIS_BR_FIELD ( _v ) (*((_v).aa))

◆ TYPE_QUAT_BR_FIELD

#define TYPE_QUAT_BR_FIELD ( _v ) (*((_v).q))

◆ TYPE_BITARRAY_BR_FIELD

#define TYPE_BITARRAY_BR_FIELD ( _v ) (*((_v).bits))

◆ TYPE_RAY_BR_FIELD

#define TYPE_RAY_BR_FIELD ( _v ) (*((_v).ray))

◆ TYPE_POINT2_BR_FIELD

#define TYPE_POINT2_BR_FIELD ( _v ) (*((_v).p2))

◆ TYPE_MESH_BR_FIELD

#define TYPE_MESH_BR_FIELD ( _v ) (*((_v).msh))

◆ TYPE_INTERVAL_BR_FIELD

#define TYPE_INTERVAL_BR_FIELD ( _v ) (*((_v).intvl))

◆ TYPE_POINT_BR_FIELD

#define TYPE_POINT_BR_FIELD ( _v ) (*((_v).pt))

◆ TYPE_TSTR_BR_FIELD

#define TYPE_TSTR_BR_FIELD ( _v ) (*((_v).tstr))

◆ TYPE_COLOR_BR_FIELD

#define TYPE_COLOR_BR_FIELD ( _v ) (*((_v).clr))

◆ TYPE_ACOLOR_BR_FIELD

#define TYPE_ACOLOR_BR_FIELD ( _v ) (*((_v).aclr))

◆ TYPE_FPVALUE_BR_FIELD

#define TYPE_FPVALUE_BR_FIELD ( _v ) (*((_v).fpv))

◆ TYPE_DWORD_BR_FIELD

#define TYPE_DWORD_BR_FIELD ( _v ) (*((_v).dptr))

◆ TYPE_bool_BR_FIELD

#define TYPE_bool_BR_FIELD ( _v ) (*((_v).bptr))

◆ TYPE_INTPTR_BR_FIELD

#define TYPE_INTPTR_BR_FIELD ( _v ) (*((_v).intptrptr))

◆ TYPE_INT64_BR_FIELD

#define TYPE_INT64_BR_FIELD ( _v ) (*((_v).i64ptr))

◆ TYPE_DOUBLE_BR_FIELD

#define TYPE_DOUBLE_BR_FIELD ( _v ) (*((_v).dblptr))

◆ TYPE_BOX3_BR_FIELD

#define TYPE_BOX3_BR_FIELD ( _v ) (*((_v).b3))

◆ TYPE_FLOAT_TAB_BR_FIELD

#define TYPE_FLOAT_TAB_BR_FIELD ( _v ) (*((_v).f_tab))

◆ TYPE_INT_TAB_BR_FIELD

#define TYPE_INT_TAB_BR_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_RGBA_TAB_BR_FIELD

#define TYPE_RGBA_TAB_BR_FIELD ( _v ) (*((_v).p_tab))

◆ TYPE_POINT3_TAB_BR_FIELD

#define TYPE_POINT3_TAB_BR_FIELD ( _v ) (*((_v).p_tab))

◆ TYPE_FRGBA_TAB_BR_FIELD

#define TYPE_FRGBA_TAB_BR_FIELD ( _v ) (*((_v).p4_tab))

◆ TYPE_POINT4_TAB_BR_FIELD

#define TYPE_POINT4_TAB_BR_FIELD ( _v ) (*((_v).p4_tab))

◆ TYPE_BOOL_TAB_BR_FIELD

#define TYPE_BOOL_TAB_BR_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_ANGLE_TAB_BR_FIELD

#define TYPE_ANGLE_TAB_BR_FIELD ( _v ) (*((_v).f_tab))

◆ TYPE_PCNT_FRAC_TAB_BR_FIELD

#define TYPE_PCNT_FRAC_TAB_BR_FIELD ( _v ) (*((_v).f_tab))

◆ TYPE_WORLD_TAB_BR_FIELD

#define TYPE_WORLD_TAB_BR_FIELD ( _v ) (*((_v).f_tab))

◆ TYPE_STRING_TAB_BR_FIELD

#define TYPE_STRING_TAB_BR_FIELD ( _v ) (*((_v).s_tab))

◆ TYPE_FILENAME_TAB_BR_FIELD

#define TYPE_FILENAME_TAB_BR_FIELD ( _v ) (*((_v).s_tab))

◆ TYPE_HSV_TAB_BR_FIELD

#define TYPE_HSV_TAB_BR_FIELD ( _v ) (*((_v).p_tab))

◆ TYPE_COLOR_CHANNEL_TAB_BR_FIELD

#define TYPE_COLOR_CHANNEL_TAB_BR_FIELD ( _v ) (*((_v).f_tab))

◆ TYPE_TIMEVALUE_TAB_BR_FIELD

#define TYPE_TIMEVALUE_TAB_BR_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_RADIOBTN_INDEX_TAB_BR_FIELD

#define TYPE_RADIOBTN_INDEX_TAB_BR_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_MTL_TAB_BR_FIELD

#define TYPE_MTL_TAB_BR_FIELD ( _v ) (*((_v).mtl_tab))

◆ TYPE_TEXMAP_TAB_BR_FIELD

#define TYPE_TEXMAP_TAB_BR_FIELD ( _v ) (*((_v).tex_tab))

◆ TYPE_BITMAP_TAB_BR_FIELD

#define TYPE_BITMAP_TAB_BR_FIELD ( _v ) (*((_v).bm_tab))

◆ TYPE_INODE_TAB_BR_FIELD

#define TYPE_INODE_TAB_BR_FIELD ( _v ) (*((_v).n_tab))

◆ TYPE_REFTARG_TAB_BR_FIELD

#define TYPE_REFTARG_TAB_BR_FIELD ( _v ) (*((_v).r_tab))

◆ TYPE_INDEX_TAB_BR_FIELD

#define TYPE_INDEX_TAB_BR_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_ENUM_TAB_BR_FIELD

#define TYPE_ENUM_TAB_BR_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_MATRIX3_TAB_BR_FIELD

#define TYPE_MATRIX3_TAB_BR_FIELD ( _v ) (*((_v).m3_tab))

◆ TYPE_ANGAXIS_TAB_BR_FIELD

#define TYPE_ANGAXIS_TAB_BR_FIELD ( _v ) (*((_v).aa_tab))

◆ TYPE_QUAT_TAB_BR_FIELD

#define TYPE_QUAT_TAB_BR_FIELD ( _v ) (*((_v).q_tab))

◆ TYPE_BITARRAY_TAB_BR_FIELD

#define TYPE_BITARRAY_TAB_BR_FIELD ( _v ) (*((_v).bits_tab))

◆ TYPE_CLASS_TAB_BR_FIELD

#define TYPE_CLASS_TAB_BR_FIELD ( _v ) (*((_v).cd_tab))

◆ TYPE_RAY_TAB_BR_FIELD

#define TYPE_RAY_TAB_BR_FIELD ( _v ) (*((_v).ray_tab))

◆ TYPE_POINT2_TAB_BR_FIELD

#define TYPE_POINT2_TAB_BR_FIELD ( _v ) (*((_v).p2_tab))

◆ TYPE_MESH_TAB_BR_FIELD

#define TYPE_MESH_TAB_BR_FIELD ( _v ) (*((_v).msh_tab))

◆ TYPE_OBJECT_TAB_BR_FIELD

#define TYPE_OBJECT_TAB_BR_FIELD ( _v ) (*((_v).obj_tab))

◆ TYPE_CONTROL_TAB_BR_FIELD

#define TYPE_CONTROL_TAB_BR_FIELD ( _v ) (*((_v).ctrl_tab))

◆ TYPE_INTERVAL_TAB_BR_FIELD

#define TYPE_INTERVAL_TAB_BR_FIELD ( _v ) (*((_v).intvl_tab))

◆ TYPE_POINT_TAB_BR_FIELD

#define TYPE_POINT_TAB_BR_FIELD ( _v ) (*((_v).pt_tab))

◆ TYPE_HWND_TAB_BR_FIELD

#define TYPE_HWND_TAB_BR_FIELD ( _v ) (*((_v).hwnd_tab))

◆ TYPE_TSTR_TAB_BR_FIELD

#define TYPE_TSTR_TAB_BR_FIELD ( _v ) (*((_v).tstr_tab))

◆ TYPE_IOBJECT_TAB_BR_FIELD

#define TYPE_IOBJECT_TAB_BR_FIELD ( _v ) (*((_v).iobj_tab))

◆ TYPE_INTERFACE_TAB_BR_FIELD

#define TYPE_INTERFACE_TAB_BR_FIELD ( _v ) (*((_v).fpi_tab))

◆ TYPE_NAME_TAB_BR_FIELD

#define TYPE_NAME_TAB_BR_FIELD ( _v ) (*((_v).s_tab))

◆ TYPE_COLOR_TAB_BR_FIELD

#define TYPE_COLOR_TAB_BR_FIELD ( _v ) (*((_v).clr_tab))

◆ TYPE_ACOLOR_TAB_BR_FIELD

#define TYPE_ACOLOR_TAB_BR_FIELD ( _v ) (*((_v).aclr_tab))

◆ TYPE_FPVALUE_TAB_BR_FIELD

#define TYPE_FPVALUE_TAB_BR_FIELD ( _v ) (*((_v).fpv_tab))

◆ TYPE_VALUE_TAB_BR_FIELD

#define TYPE_VALUE_TAB_BR_FIELD ( _v ) (*((_v).v_tab))

◆ TYPE_DWORD_TAB_BR_FIELD

#define TYPE_DWORD_TAB_BR_FIELD ( _v ) (*((_v).d_tab))

◆ TYPE_bool_TAB_BR_FIELD

#define TYPE_bool_TAB_BR_FIELD ( _v ) (*((_v).b_tab))

◆ TYPE_INTPTR_TAB_BR_FIELD

#define TYPE_INTPTR_TAB_BR_FIELD ( _v ) (*((_v).intptr_tab))

◆ TYPE_INT64_TAB_BR_FIELD

#define TYPE_INT64_TAB_BR_FIELD ( _v ) (*((_v).i64_tab))

◆ TYPE_DOUBLE_TAB_BR_FIELD

#define TYPE_DOUBLE_TAB_BR_FIELD ( _v ) (*((_v).dbl_tab))

◆ TYPE_BOX3_TAB_BR_FIELD

#define TYPE_BOX3_TAB_BR_FIELD ( _v ) (*((_v).b3_tab))

◆ TYPE_RGBA_BV_FIELD

#define TYPE_RGBA_BV_FIELD ( _v ) (*((_v).p))

◆ TYPE_POINT3_BV_FIELD

#define TYPE_POINT3_BV_FIELD ( _v ) (*((_v).p))

◆ TYPE_HSV_BV_FIELD

#define TYPE_HSV_BV_FIELD ( _v ) (*((_v).p))

◆ TYPE_FRGBA_BV_FIELD

#define TYPE_FRGBA_BV_FIELD ( _v ) (*((_v).p4))

◆ TYPE_POINT4_BV_FIELD

#define TYPE_POINT4_BV_FIELD ( _v ) (*((_v).p4))

◆ TYPE_BITMAP_BV_FIELD

#define TYPE_BITMAP_BV_FIELD ( _v ) (*((_v).bm))

◆ TYPE_MATRIX3_BV_FIELD

#define TYPE_MATRIX3_BV_FIELD ( _v ) (*((_v).m))

◆ TYPE_ANGAXIS_BV_FIELD

#define TYPE_ANGAXIS_BV_FIELD ( _v ) (*((_v).aa))

◆ TYPE_QUAT_BV_FIELD

#define TYPE_QUAT_BV_FIELD ( _v ) (*((_v).q))

◆ TYPE_BITARRAY_BV_FIELD

#define TYPE_BITARRAY_BV_FIELD ( _v ) (*((_v).bits))

◆ TYPE_RAY_BV_FIELD

#define TYPE_RAY_BV_FIELD ( _v ) (*((_v).ray))

◆ TYPE_POINT2_BV_FIELD

#define TYPE_POINT2_BV_FIELD ( _v ) (*((_v).p2))

◆ TYPE_MESH_BV_FIELD

#define TYPE_MESH_BV_FIELD ( _v ) (*((_v).msh))

◆ TYPE_INTERVAL_BV_FIELD

#define TYPE_INTERVAL_BV_FIELD ( _v ) (*((_v).intvl))

◆ TYPE_POINT_BV_FIELD

#define TYPE_POINT_BV_FIELD ( _v ) (*((_v).pt))

◆ TYPE_TSTR_BV_FIELD

#define TYPE_TSTR_BV_FIELD ( _v ) (*((_v).tstr))

◆ TYPE_COLOR_BV_FIELD

#define TYPE_COLOR_BV_FIELD ( _v ) (*((_v).clr))

◆ TYPE_ACOLOR_BV_FIELD

#define TYPE_ACOLOR_BV_FIELD ( _v ) (*((_v).aclr))

◆ TYPE_FPVALUE_BV_FIELD

#define TYPE_FPVALUE_BV_FIELD ( _v ) (*((_v).fpv))

◆ TYPE_CLASS_BV_FIELD

#define TYPE_CLASS_BV_FIELD ( _v ) (*((_v).cd))

◆ TYPE_BOX3_BV_FIELD

#define TYPE_BOX3_BV_FIELD ( _v ) (*((_v).b3))

◆ TYPE_FLOAT_TAB_BV_FIELD

#define TYPE_FLOAT_TAB_BV_FIELD ( _v ) (*((_v).f_tab))

◆ TYPE_INT_TAB_BV_FIELD

#define TYPE_INT_TAB_BV_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_RGBA_TAB_BV_FIELD

#define TYPE_RGBA_TAB_BV_FIELD ( _v ) (*((_v).p_tab))

◆ TYPE_POINT3_TAB_BV_FIELD

#define TYPE_POINT3_TAB_BV_FIELD ( _v ) (*((_v).p_tab))

◆ TYPE_FRGBA_TAB_BV_FIELD

#define TYPE_FRGBA_TAB_BV_FIELD ( _v ) (*((_v).p4_tab))

◆ TYPE_POINT4_TAB_BV_FIELD

#define TYPE_POINT4_TAB_BV_FIELD ( _v ) (*((_v).p4_tab))

◆ TYPE_BOOL_TAB_BV_FIELD

#define TYPE_BOOL_TAB_BV_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_ANGLE_TAB_BV_FIELD

#define TYPE_ANGLE_TAB_BV_FIELD ( _v ) (*((_v).f_tab))

◆ TYPE_PCNT_FRAC_TAB_BV_FIELD

#define TYPE_PCNT_FRAC_TAB_BV_FIELD ( _v ) (*((_v).f_tab))

◆ TYPE_WORLD_TAB_BV_FIELD

#define TYPE_WORLD_TAB_BV_FIELD ( _v ) (*((_v).f_tab))

◆ TYPE_STRING_TAB_BV_FIELD

#define TYPE_STRING_TAB_BV_FIELD ( _v ) (*((_v).s_tab))

◆ TYPE_FILENAME_TAB_BV_FIELD

#define TYPE_FILENAME_TAB_BV_FIELD ( _v ) (*((_v).s_tab))

◆ TYPE_HSV_TAB_BV_FIELD

#define TYPE_HSV_TAB_BV_FIELD ( _v ) (*((_v).p_tab))

◆ TYPE_COLOR_CHANNEL_TAB_BV_FIELD

#define TYPE_COLOR_CHANNEL_TAB_BV_FIELD ( _v ) (*((_v).f_tab))

◆ TYPE_TIMEVALUE_TAB_BV_FIELD

#define TYPE_TIMEVALUE_TAB_BV_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_RADIOBTN_INDEX_TAB_BV_FIELD

#define TYPE_RADIOBTN_INDEX_TAB_BV_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_MTL_TAB_BV_FIELD

#define TYPE_MTL_TAB_BV_FIELD ( _v ) (*((_v).mtl_tab))

◆ TYPE_TEXMAP_TAB_BV_FIELD

#define TYPE_TEXMAP_TAB_BV_FIELD ( _v ) (*((_v).tex_tab))

◆ TYPE_BITMAP_TAB_BV_FIELD

#define TYPE_BITMAP_TAB_BV_FIELD ( _v ) (*((_v).bm_tab))

◆ TYPE_INODE_TAB_BV_FIELD

#define TYPE_INODE_TAB_BV_FIELD ( _v ) (*((_v).n_tab))

◆ TYPE_REFTARG_TAB_BV_FIELD

#define TYPE_REFTARG_TAB_BV_FIELD ( _v ) (*((_v).r_tab))

◆ TYPE_INDEX_TAB_BV_FIELD

#define TYPE_INDEX_TAB_BV_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_ENUM_TAB_BV_FIELD

#define TYPE_ENUM_TAB_BV_FIELD ( _v ) (*((_v).i_tab))

◆ TYPE_MATRIX3_TAB_BV_FIELD

#define TYPE_MATRIX3_TAB_BV_FIELD ( _v ) (*((_v).m3_tab))

◆ TYPE_ANGAXIS_TAB_BV_FIELD

#define TYPE_ANGAXIS_TAB_BV_FIELD ( _v ) (*((_v).aa_tab))

◆ TYPE_QUAT_TAB_BV_FIELD

#define TYPE_QUAT_TAB_BV_FIELD ( _v ) (*((_v).q_tab))

◆ TYPE_BITARRAY_TAB_BV_FIELD

#define TYPE_BITARRAY_TAB_BV_FIELD ( _v ) (*((_v).bits_tab))

◆ TYPE_CLASS_TAB_BV_FIELD

#define TYPE_CLASS_TAB_BV_FIELD ( _v ) (*((_v).cd_tab))

◆ TYPE_RAY_TAB_BV_FIELD

#define TYPE_RAY_TAB_BV_FIELD ( _v ) (*((_v).ray_tab))

◆ TYPE_POINT2_TAB_BV_FIELD

#define TYPE_POINT2_TAB_BV_FIELD ( _v ) (*((_v).p2_tab))

◆ TYPE_MESH_TAB_BV_FIELD

#define TYPE_MESH_TAB_BV_FIELD ( _v ) (*((_v).msh_tab))

◆ TYPE_OBJECT_TAB_BV_FIELD

#define TYPE_OBJECT_TAB_BV_FIELD ( _v ) (*((_v).obj_tab))

◆ TYPE_CONTROL_TAB_BV_FIELD

#define TYPE_CONTROL_TAB_BV_FIELD ( _v ) (*((_v).ctrl_tab))

◆ TYPE_INTERVAL_TAB_BV_FIELD

#define TYPE_INTERVAL_TAB_BV_FIELD ( _v ) (*((_v).intvl_tab))

◆ TYPE_POINT_TAB_BV_FIELD

#define TYPE_POINT_TAB_BV_FIELD ( _v ) (*((_v).pt_tab))

◆ TYPE_HWND_TAB_BV_FIELD

#define TYPE_HWND_TAB_BV_FIELD ( _v ) (*((_v).hwnd_tab))

◆ TYPE_TSTR_TAB_BV_FIELD

#define TYPE_TSTR_TAB_BV_FIELD ( _v ) (*((_v).tstr_tab))

◆ TYPE_IOBJECT_TAB_BV_FIELD

#define TYPE_IOBJECT_TAB_BV_FIELD ( _v ) (*((_v).iobj_tab))

◆ TYPE_INTERFACE_TAB_BV_FIELD

#define TYPE_INTERFACE_TAB_BV_FIELD ( _v ) (*((_v).fpi_tab))

◆ TYPE_NAME_TAB_BV_FIELD

#define TYPE_NAME_TAB_BV_FIELD ( _v ) (*((_v).s_tab))

◆ TYPE_COLOR_TAB_BV_FIELD

#define TYPE_COLOR_TAB_BV_FIELD ( _v ) (*((_v).clr_tab))

◆ TYPE_ACOLOR_TAB_BV_FIELD

#define TYPE_ACOLOR_TAB_BV_FIELD ( _v ) (*((_v).aclr_tab))

◆ TYPE_FPVALUE_TAB_BV_FIELD

#define TYPE_FPVALUE_TAB_BV_FIELD ( _v ) (*((_v).fpv_tab))

◆ TYPE_VALUE_TAB_BV_FIELD

#define TYPE_VALUE_TAB_BV_FIELD ( _v ) (*((_v).v_tab))

◆ TYPE_DWORD_TAB_BV_FIELD

#define TYPE_DWORD_TAB_BV_FIELD ( _v ) (*((_v).d_tab))

◆ TYPE_bool_TAB_BV_FIELD

#define TYPE_bool_TAB_BV_FIELD ( _v ) (*((_v).b_tab))

◆ TYPE_INTPTR_TAB_BV_FIELD

#define TYPE_INTPTR_TAB_BV_FIELD ( _v ) (*((_v).intptr_tab))

◆ TYPE_INT64_TAB_BV_FIELD

#define TYPE_INT64_TAB_BV_FIELD ( _v ) (*((_v).i64_tab))

◆ TYPE_DOUBLE_TAB_BV_FIELD

#define TYPE_DOUBLE_TAB_BV_FIELD ( _v ) (*((_v).dbl_tab))

◆ TYPE_BOX3_TAB_BV_FIELD

#define TYPE_BOX3_TAB_BV_FIELD ( _v ) (*((_v).b3_tab))

◆ TYPE_FLOAT_RSLT

#define TYPE_FLOAT_RSLT

◆ TYPE_INT_RSLT

#define TYPE_INT_RSLT

◆ TYPE_RGBA_RSLT

#define TYPE_RGBA_RSLT

◆ TYPE_POINT3_RSLT

#define TYPE_POINT3_RSLT

◆ TYPE_FRGBA_RSLT

#define TYPE_FRGBA_RSLT

◆ TYPE_POINT4_RSLT

#define TYPE_POINT4_RSLT

◆ TYPE_BOOL_RSLT

#define TYPE_BOOL_RSLT

◆ TYPE_ANGLE_RSLT

#define TYPE_ANGLE_RSLT

◆ TYPE_PCNT_FRAC_RSLT

#define TYPE_PCNT_FRAC_RSLT

◆ TYPE_WORLD_RSLT

#define TYPE_WORLD_RSLT

◆ TYPE_STRING_RSLT

#define TYPE_STRING_RSLT

◆ TYPE_FILENAME_RSLT

#define TYPE_FILENAME_RSLT

◆ TYPE_HSV_RSLT

#define TYPE_HSV_RSLT

◆ TYPE_COLOR_CHANNEL_RSLT

#define TYPE_COLOR_CHANNEL_RSLT

◆ TYPE_TIMEVALUE_RSLT

#define TYPE_TIMEVALUE_RSLT

◆ TYPE_RADIOBTN_INDEX_RSLT

#define TYPE_RADIOBTN_INDEX_RSLT

◆ TYPE_MTL_RSLT

#define TYPE_MTL_RSLT

◆ TYPE_TEXMAP_RSLT

#define TYPE_TEXMAP_RSLT

◆ TYPE_BITMAP_RSLT

#define TYPE_BITMAP_RSLT

◆ TYPE_INODE_RSLT

#define TYPE_INODE_RSLT

◆ TYPE_REFTARG_RSLT

#define TYPE_REFTARG_RSLT

◆ TYPE_INDEX_RSLT

#define TYPE_INDEX_RSLT

◆ TYPE_ENUM_RSLT

#define TYPE_ENUM_RSLT

◆ TYPE_MATRIX3_RSLT

#define TYPE_MATRIX3_RSLT

◆ TYPE_VOID_RSLT

#define TYPE_VOID_RSLT

◆ TYPE_INTERVAL_RSLT

#define TYPE_INTERVAL_RSLT

◆ TYPE_ANGAXIS_RSLT

#define TYPE_ANGAXIS_RSLT

◆ TYPE_QUAT_RSLT

#define TYPE_QUAT_RSLT

◆ TYPE_RAY_RSLT

#define TYPE_RAY_RSLT

◆ TYPE_POINT2_RSLT

#define TYPE_POINT2_RSLT

◆ TYPE_BITARRAY_RSLT

#define TYPE_BITARRAY_RSLT

◆ TYPE_CLASS_RSLT

#define TYPE_CLASS_RSLT

◆ TYPE_MESH_RSLT

#define TYPE_MESH_RSLT

◆ TYPE_OBJECT_RSLT

#define TYPE_OBJECT_RSLT

◆ TYPE_CONTROL_RSLT

#define TYPE_CONTROL_RSLT

◆ TYPE_POINT_RSLT

#define TYPE_POINT_RSLT

◆ TYPE_TSTR_RSLT

#define TYPE_TSTR_RSLT

◆ TYPE_IOBJECT_RSLT

#define TYPE_IOBJECT_RSLT

◆ TYPE_INTERFACE_RSLT

#define TYPE_INTERFACE_RSLT

◆ TYPE_HWND_RSLT

#define TYPE_HWND_RSLT

◆ TYPE_NAME_RSLT

#define TYPE_NAME_RSLT

◆ TYPE_COLOR_RSLT

#define TYPE_COLOR_RSLT

◆ TYPE_ACOLOR_RSLT

#define TYPE_ACOLOR_RSLT

◆ TYPE_FPVALUE_RSLT

#define TYPE_FPVALUE_RSLT

◆ TYPE_VALUE_RSLT

#define TYPE_VALUE_RSLT

◆ TYPE_DWORD_RSLT

#define TYPE_DWORD_RSLT

◆ TYPE_bool_RSLT

#define TYPE_bool_RSLT

◆ TYPE_INTPTR_RSLT

#define TYPE_INTPTR_RSLT

◆ TYPE_INT64_RSLT

#define TYPE_INT64_RSLT

◆ TYPE_DOUBLE_RSLT

#define TYPE_DOUBLE_RSLT

◆ TYPE_BOX3_RSLT

#define TYPE_BOX3_RSLT

◆ TYPE_FLOAT_TAB_RSLT

#define TYPE_FLOAT_TAB_RSLT

◆ TYPE_INT_TAB_RSLT

#define TYPE_INT_TAB_RSLT

◆ TYPE_RGBA_TAB_RSLT

#define TYPE_RGBA_TAB_RSLT

◆ TYPE_POINT3_TAB_RSLT

#define TYPE_POINT3_TAB_RSLT

◆ TYPE_FRGBA_TAB_RSLT

#define TYPE_FRGBA_TAB_RSLT

◆ TYPE_POINT4_TAB_RSLT

#define TYPE_POINT4_TAB_RSLT

◆ TYPE_BOOL_TAB_RSLT

#define TYPE_BOOL_TAB_RSLT

◆ TYPE_ANGLE_TAB_RSLT

#define TYPE_ANGLE_TAB_RSLT

◆ TYPE_PCNT_FRAC_TAB_RSLT

#define TYPE_PCNT_FRAC_TAB_RSLT

◆ TYPE_WORLD_TAB_RSLT

#define TYPE_WORLD_TAB_RSLT

◆ TYPE_STRING_TAB_RSLT

#define TYPE_STRING_TAB_RSLT

◆ TYPE_FILENAME_TAB_RSLT

#define TYPE_FILENAME_TAB_RSLT

◆ TYPE_HSV_TAB_RSLT

#define TYPE_HSV_TAB_RSLT

◆ TYPE_COLOR_CHANNEL_TAB_RSLT

#define TYPE_COLOR_CHANNEL_TAB_RSLT

◆ TYPE_TIMEVALUE_TAB_RSLT

#define TYPE_TIMEVALUE_TAB_RSLT

◆ TYPE_RADIOBTN_INDEX_TAB_RSLT

#define TYPE_RADIOBTN_INDEX_TAB_RSLT

◆ TYPE_MTL_TAB_RSLT

#define TYPE_MTL_TAB_RSLT

◆ TYPE_TEXMAP_TAB_RSLT

#define TYPE_TEXMAP_TAB_RSLT

◆ TYPE_BITMAP_TAB_RSLT

#define TYPE_BITMAP_TAB_RSLT

◆ TYPE_INODE_TAB_RSLT

#define TYPE_INODE_TAB_RSLT

◆ TYPE_REFTARG_TAB_RSLT

#define TYPE_REFTARG_TAB_RSLT

◆ TYPE_INDEX_TAB_RSLT

#define TYPE_INDEX_TAB_RSLT

◆ TYPE_ENUM_TAB_RSLT

#define TYPE_ENUM_TAB_RSLT

◆ TYPE_MATRIX3_TAB_RSLT

#define TYPE_MATRIX3_TAB_RSLT

◆ TYPE_INTERVAL_TAB_RSLT

#define TYPE_INTERVAL_TAB_RSLT

◆ TYPE_ANGAXIS_TAB_RSLT

#define TYPE_ANGAXIS_TAB_RSLT

◆ TYPE_QUAT_TAB_RSLT

#define TYPE_QUAT_TAB_RSLT

◆ TYPE_RAY_TAB_RSLT

#define TYPE_RAY_TAB_RSLT

◆ TYPE_POINT2_TAB_RSLT

#define TYPE_POINT2_TAB_RSLT

◆ TYPE_BITARRAY_TAB_RSLT

#define TYPE_BITARRAY_TAB_RSLT

◆ TYPE_CLASS_TAB_RSLT

#define TYPE_CLASS_TAB_RSLT

◆ TYPE_MESH_TAB_RSLT

#define TYPE_MESH_TAB_RSLT

◆ TYPE_OBJECT_TAB_RSLT

#define TYPE_OBJECT_TAB_RSLT

◆ TYPE_CONTROL_TAB_RSLT

#define TYPE_CONTROL_TAB_RSLT

◆ TYPE_POINT_TAB_RSLT

#define TYPE_POINT_TAB_RSLT

◆ TYPE_TSTR_TAB_RSLT

#define TYPE_TSTR_TAB_RSLT

◆ TYPE_IOBJECT_TAB_RSLT

#define TYPE_IOBJECT_TAB_RSLT

◆ TYPE_INTERFACE_TAB_RSLT

#define TYPE_INTERFACE_TAB_RSLT

◆ TYPE_HWND_TAB_RSLT

#define TYPE_HWND_TAB_RSLT

◆ TYPE_NAME_TAB_RSLT

#define TYPE_NAME_TAB_RSLT

◆ TYPE_COLOR_TAB_RSLT

#define TYPE_COLOR_TAB_RSLT

◆ TYPE_ACOLOR_TAB_RSLT

#define TYPE_ACOLOR_TAB_RSLT

◆ TYPE_FPVALUE_TAB_RSLT

#define TYPE_FPVALUE_TAB_RSLT

◆ TYPE_VALUE_TAB_RSLT

#define TYPE_VALUE_TAB_RSLT

◆ TYPE_DWORD_TAB_RSLT

#define TYPE_DWORD_TAB_RSLT

◆ TYPE_bool_TAB_RSLT

#define TYPE_bool_TAB_RSLT

◆ TYPE_INTPTR_TAB_RSLT

#define TYPE_INTPTR_TAB_RSLT

◆ TYPE_INT64_TAB_RSLT

#define TYPE_INT64_TAB_RSLT

◆ TYPE_DOUBLE_TAB_RSLT

#define TYPE_DOUBLE_TAB_RSLT

◆ TYPE_BOX3_TAB_RSLT

#define TYPE_BOX3_TAB_RSLT

◆ TYPE_FLOAT_BP_RSLT

#define TYPE_FLOAT_BP_RSLT

◆ TYPE_INT_BP_RSLT

#define TYPE_INT_BP_RSLT

◆ TYPE_BOOL_BP_RSLT

#define TYPE_BOOL_BP_RSLT

◆ TYPE_ANGLE_BP_RSLT

#define TYPE_ANGLE_BP_RSLT

◆ TYPE_PCNT_FRAC_BP_RSLT

#define TYPE_PCNT_FRAC_BP_RSLT

◆ TYPE_WORLD_BP_RSLT

#define TYPE_WORLD_BP_RSLT

◆ TYPE_COLOR_CHANNEL_BP_RSLT

#define TYPE_COLOR_CHANNEL_BP_RSLT

◆ TYPE_TIMEVALUE_BP_RSLT

#define TYPE_TIMEVALUE_BP_RSLT

◆ TYPE_RADIOBTN_INDEX_BP_RSLT

#define TYPE_RADIOBTN_INDEX_BP_RSLT

◆ TYPE_INDEX_BP_RSLT

#define TYPE_INDEX_BP_RSLT

◆ TYPE_ENUM_BP_RSLT

#define TYPE_ENUM_BP_RSLT

◆ TYPE_DWORD_BP_RSLT

#define TYPE_DWORD_BP_RSLT

◆ TYPE_bool_BP_RSLT

#define TYPE_bool_BP_RSLT

◆ TYPE_INTPTR_BP_RSLT

#define TYPE_INTPTR_BP_RSLT

◆ TYPE_INT64_BP_RSLT

#define TYPE_INT64_BP_RSLT

◆ TYPE_DOUBLE_BP_RSLT

#define TYPE_DOUBLE_BP_RSLT

◆ TYPE_FLOAT_BR_RSLT

#define TYPE_FLOAT_BR_RSLT &

◆ TYPE_INT_BR_RSLT

#define TYPE_INT_BR_RSLT &

◆ TYPE_RGBA_BR_RSLT

#define TYPE_RGBA_BR_RSLT &

◆ TYPE_POINT3_BR_RSLT

#define TYPE_POINT3_BR_RSLT &

◆ TYPE_FRGBA_BR_RSLT

#define TYPE_FRGBA_BR_RSLT &

◆ TYPE_POINT4_BR_RSLT

#define TYPE_POINT4_BR_RSLT &

◆ TYPE_BOOL_BR_RSLT

#define TYPE_BOOL_BR_RSLT &

◆ TYPE_ANGLE_BR_RSLT

#define TYPE_ANGLE_BR_RSLT &

◆ TYPE_PCNT_FRAC_BR_RSLT

#define TYPE_PCNT_FRAC_BR_RSLT &

◆ TYPE_WORLD_BR_RSLT

#define TYPE_WORLD_BR_RSLT &

◆ TYPE_HSV_BR_RSLT

#define TYPE_HSV_BR_RSLT &

◆ TYPE_COLOR_CHANNEL_BR_RSLT

#define TYPE_COLOR_CHANNEL_BR_RSLT &

◆ TYPE_TIMEVALUE_BR_RSLT

#define TYPE_TIMEVALUE_BR_RSLT &

◆ TYPE_RADIOBTN_INDEX_BR_RSLT

#define TYPE_RADIOBTN_INDEX_BR_RSLT &

◆ TYPE_BITMAP_BR_RSLT

#define TYPE_BITMAP_BR_RSLT &

◆ TYPE_INDEX_BR_RSLT

#define TYPE_INDEX_BR_RSLT &

◆ TYPE_ENUM_BR_RSLT

#define TYPE_ENUM_BR_RSLT &

◆ TYPE_REFTARG_BR_RSLT

#define TYPE_REFTARG_BR_RSLT &

◆ TYPE_MATRIX3_BR_RSLT

#define TYPE_MATRIX3_BR_RSLT &

◆ TYPE_ANGAXIS_BR_RSLT

#define TYPE_ANGAXIS_BR_RSLT &

◆ TYPE_QUAT_BR_RSLT

#define TYPE_QUAT_BR_RSLT &

◆ TYPE_BITARRAY_BR_RSLT

#define TYPE_BITARRAY_BR_RSLT &

◆ TYPE_RAY_BR_RSLT

#define TYPE_RAY_BR_RSLT &

◆ TYPE_POINT2_BR_RSLT

#define TYPE_POINT2_BR_RSLT &

◆ TYPE_MESH_BR_RSLT

#define TYPE_MESH_BR_RSLT &

◆ TYPE_INTERVAL_BR_RSLT

#define TYPE_INTERVAL_BR_RSLT &

◆ TYPE_POINT_BR_RSLT

#define TYPE_POINT_BR_RSLT &

◆ TYPE_TSTR_BR_RSLT

#define TYPE_TSTR_BR_RSLT &

◆ TYPE_COLOR_BR_RSLT

#define TYPE_COLOR_BR_RSLT &

◆ TYPE_ACOLOR_BR_RSLT

#define TYPE_ACOLOR_BR_RSLT &

◆ TYPE_FPVALUE_BR_RSLT

#define TYPE_FPVALUE_BR_RSLT &

◆ TYPE_DWORD_BR_RSLT

#define TYPE_DWORD_BR_RSLT &

◆ TYPE_bool_BR_RSLT

#define TYPE_bool_BR_RSLT &

◆ TYPE_INTPTR_BR_RSLT

#define TYPE_INTPTR_BR_RSLT &

◆ TYPE_INT64_BR_RSLT

#define TYPE_INT64_BR_RSLT &

◆ TYPE_DOUBLE_BR_RSLT

#define TYPE_DOUBLE_BR_RSLT &

◆ TYPE_BOX3_BR_RSLT

#define TYPE_BOX3_BR_RSLT &

◆ TYPE_FLOAT_TAB_BR_RSLT

#define TYPE_FLOAT_TAB_BR_RSLT &

◆ TYPE_INT_TAB_BR_RSLT

#define TYPE_INT_TAB_BR_RSLT &

◆ TYPE_RGBA_TAB_BR_RSLT

#define TYPE_RGBA_TAB_BR_RSLT &

◆ TYPE_POINT3_TAB_BR_RSLT

#define TYPE_POINT3_TAB_BR_RSLT &

◆ TYPE_FRGBA_TAB_BR_RSLT

#define TYPE_FRGBA_TAB_BR_RSLT &

◆ TYPE_POINT4_TAB_BR_RSLT

#define TYPE_POINT4_TAB_BR_RSLT &

◆ TYPE_BOOL_TAB_BR_RSLT

#define TYPE_BOOL_TAB_BR_RSLT &

◆ TYPE_ANGLE_TAB_BR_RSLT

#define TYPE_ANGLE_TAB_BR_RSLT &

◆ TYPE_PCNT_FRAC_TAB_BR_RSLT

#define TYPE_PCNT_FRAC_TAB_BR_RSLT &

◆ TYPE_WORLD_TAB_BR_RSLT

#define TYPE_WORLD_TAB_BR_RSLT &

◆ TYPE_STRING_TAB_BR_RSLT

#define TYPE_STRING_TAB_BR_RSLT &

◆ TYPE_FILENAME_TAB_BR_RSLT

#define TYPE_FILENAME_TAB_BR_RSLT &

◆ TYPE_HSV_TAB_BR_RSLT

#define TYPE_HSV_TAB_BR_RSLT &

◆ TYPE_COLOR_CHANNEL_TAB_BR_RSLT

#define TYPE_COLOR_CHANNEL_TAB_BR_RSLT &

◆ TYPE_TIMEVALUE_TAB_BR_RSLT

#define TYPE_TIMEVALUE_TAB_BR_RSLT &

◆ TYPE_RADIOBTN_INDEX_TAB_BR_RSLT

#define TYPE_RADIOBTN_INDEX_TAB_BR_RSLT &

◆ TYPE_MTL_TAB_BR_RSLT

#define TYPE_MTL_TAB_BR_RSLT &

◆ TYPE_TEXMAP_TAB_BR_RSLT

#define TYPE_TEXMAP_TAB_BR_RSLT &

◆ TYPE_BITMAP_TAB_BR_RSLT

#define TYPE_BITMAP_TAB_BR_RSLT &

◆ TYPE_INODE_TAB_BR_RSLT

#define TYPE_INODE_TAB_BR_RSLT &

◆ TYPE_REFTARG_TAB_BR_RSLT

#define TYPE_REFTARG_TAB_BR_RSLT &

◆ TYPE_INDEX_TAB_BR_RSLT

#define TYPE_INDEX_TAB_BR_RSLT &

◆ TYPE_ENUM_TAB_BR_RSLT

#define TYPE_ENUM_TAB_BR_RSLT &

◆ TYPE_MATRIX3_TAB_BR_RSLT

#define TYPE_MATRIX3_TAB_BR_RSLT &

◆ TYPE_ANGAXIS_TAB_BR_RSLT

#define TYPE_ANGAXIS_TAB_BR_RSLT &

◆ TYPE_QUAT_TAB_BR_RSLT

#define TYPE_QUAT_TAB_BR_RSLT &

◆ TYPE_BITARRAY_TAB_BR_RSLT

#define TYPE_BITARRAY_TAB_BR_RSLT &

◆ TYPE_CLASS_TAB_BR_RSLT

#define TYPE_CLASS_TAB_BR_RSLT &

◆ TYPE_RAY_TAB_BR_RSLT

#define TYPE_RAY_TAB_BR_RSLT &

◆ TYPE_POINT2_TAB_BR_RSLT

#define TYPE_POINT2_TAB_BR_RSLT &

◆ TYPE_MESH_TAB_BR_RSLT

#define TYPE_MESH_TAB_BR_RSLT &

◆ TYPE_OBJECT_TAB_BR_RSLT

#define TYPE_OBJECT_TAB_BR_RSLT &

◆ TYPE_CONTROL_TAB_BR_RSLT

#define TYPE_CONTROL_TAB_BR_RSLT &

◆ TYPE_INTERVAL_TAB_BR_RSLT

#define TYPE_INTERVAL_TAB_BR_RSLT &

◆ TYPE_POINT_TAB_BR_RSLT

#define TYPE_POINT_TAB_BR_RSLT &

◆ TYPE_HWND_TAB_BR_RSLT

#define TYPE_HWND_TAB_BR_RSLT &

◆ TYPE_TSTR_TAB_BR_RSLT

#define TYPE_TSTR_TAB_BR_RSLT &

◆ TYPE_IOBJECT_TAB_BR_RSLT

#define TYPE_IOBJECT_TAB_BR_RSLT &

◆ TYPE_INTERFACE_TAB_BR_RSLT

#define TYPE_INTERFACE_TAB_BR_RSLT &

◆ TYPE_NAME_TAB_BR_RSLT

#define TYPE_NAME_TAB_BR_RSLT &

◆ TYPE_COLOR_TAB_BR_RSLT

#define TYPE_COLOR_TAB_BR_RSLT &

◆ TYPE_ACOLOR_TAB_BR_RSLT

#define TYPE_ACOLOR_TAB_BR_RSLT &

◆ TYPE_FPVALUE_TAB_BR_RSLT

#define TYPE_FPVALUE_TAB_BR_RSLT &

◆ TYPE_VALUE_TAB_BR_RSLT

#define TYPE_VALUE_TAB_BR_RSLT &

◆ TYPE_DWORD_TAB_BR_RSLT

#define TYPE_DWORD_TAB_BR_RSLT &

◆ TYPE_bool_TAB_BR_RSLT

#define TYPE_bool_TAB_BR_RSLT &

◆ TYPE_INTPTR_TAB_BR_RSLT

#define TYPE_INTPTR_TAB_BR_RSLT &

◆ TYPE_INT64_TAB_BR_RSLT

#define TYPE_INT64_TAB_BR_RSLT &

◆ TYPE_DOUBLE_TAB_BR_RSLT

#define TYPE_DOUBLE_TAB_BR_RSLT &

◆ TYPE_BOX3_TAB_BR_RSLT

#define TYPE_BOX3_TAB_BR_RSLT &

◆ TYPE_RGBA_BV_RSLT

#define TYPE_RGBA_BV_RSLT &

◆ TYPE_POINT3_BV_RSLT

#define TYPE_POINT3_BV_RSLT &

◆ TYPE_HSV_BV_RSLT

#define TYPE_HSV_BV_RSLT &

◆ TYPE_FRGBA_BV_RSLT

#define TYPE_FRGBA_BV_RSLT &

◆ TYPE_POINT4_BV_RSLT

#define TYPE_POINT4_BV_RSLT &

◆ TYPE_BITMAP_BV_RSLT

#define TYPE_BITMAP_BV_RSLT &

◆ TYPE_MATRIX3_BV_RSLT

#define TYPE_MATRIX3_BV_RSLT &

◆ TYPE_ANGAXIS_BV_RSLT

#define TYPE_ANGAXIS_BV_RSLT &

◆ TYPE_QUAT_BV_RSLT

#define TYPE_QUAT_BV_RSLT &

◆ TYPE_BITARRAY_BV_RSLT

#define TYPE_BITARRAY_BV_RSLT &

◆ TYPE_RAY_BV_RSLT

#define TYPE_RAY_BV_RSLT &

◆ TYPE_POINT2_BV_RSLT

#define TYPE_POINT2_BV_RSLT &

◆ TYPE_MESH_BV_RSLT

#define TYPE_MESH_BV_RSLT &

◆ TYPE_INTERVAL_BV_RSLT

#define TYPE_INTERVAL_BV_RSLT &

◆ TYPE_POINT_BV_RSLT

#define TYPE_POINT_BV_RSLT &

◆ TYPE_TSTR_BV_RSLT

#define TYPE_TSTR_BV_RSLT &

◆ TYPE_COLOR_BV_RSLT

#define TYPE_COLOR_BV_RSLT &

◆ TYPE_ACOLOR_BV_RSLT

#define TYPE_ACOLOR_BV_RSLT &

◆ TYPE_FPVALUE_BV_RSLT

#define TYPE_FPVALUE_BV_RSLT &

◆ TYPE_CLASS_BV_RSLT

#define TYPE_CLASS_BV_RSLT &

◆ TYPE_BOX3_BV_RSLT

#define TYPE_BOX3_BV_RSLT &

◆ TYPE_FLOAT_TAB_BV_RSLT

#define TYPE_FLOAT_TAB_BV_RSLT &

◆ TYPE_INT_TAB_BV_RSLT

#define TYPE_INT_TAB_BV_RSLT &

◆ TYPE_RGBA_TAB_BV_RSLT

#define TYPE_RGBA_TAB_BV_RSLT &

◆ TYPE_POINT3_TAB_BV_RSLT

#define TYPE_POINT3_TAB_BV_RSLT &

◆ TYPE_FRGBA_TAB_BV_RSLT

#define TYPE_FRGBA_TAB_BV_RSLT &

◆ TYPE_POINT4_TAB_BV_RSLT

#define TYPE_POINT4_TAB_BV_RSLT &

◆ TYPE_BOOL_TAB_BV_RSLT

#define TYPE_BOOL_TAB_BV_RSLT &

◆ TYPE_ANGLE_TAB_BV_RSLT

#define TYPE_ANGLE_TAB_BV_RSLT &

◆ TYPE_PCNT_FRAC_TAB_BV_RSLT

#define TYPE_PCNT_FRAC_TAB_BV_RSLT &

◆ TYPE_WORLD_TAB_BV_RSLT

#define TYPE_WORLD_TAB_BV_RSLT &

◆ TYPE_STRING_TAB_BV_RSLT

#define TYPE_STRING_TAB_BV_RSLT &

◆ TYPE_FILENAME_TAB_BV_RSLT

#define TYPE_FILENAME_TAB_BV_RSLT &

◆ TYPE_HSV_TAB_BV_RSLT

#define TYPE_HSV_TAB_BV_RSLT &

◆ TYPE_COLOR_CHANNEL_TAB_BV_RSLT

#define TYPE_COLOR_CHANNEL_TAB_BV_RSLT &

◆ TYPE_TIMEVALUE_TAB_BV_RSLT

#define TYPE_TIMEVALUE_TAB_BV_RSLT &

◆ TYPE_RADIOBTN_INDEX_TAB_BV_RSLT

#define TYPE_RADIOBTN_INDEX_TAB_BV_RSLT &

◆ TYPE_MTL_TAB_BV_RSLT

#define TYPE_MTL_TAB_BV_RSLT &

◆ TYPE_TEXMAP_TAB_BV_RSLT

#define TYPE_TEXMAP_TAB_BV_RSLT &

◆ TYPE_BITMAP_TAB_BV_RSLT

#define TYPE_BITMAP_TAB_BV_RSLT &

◆ TYPE_INODE_TAB_BV_RSLT

#define TYPE_INODE_TAB_BV_RSLT &

◆ TYPE_REFTARG_TAB_BV_RSLT

#define TYPE_REFTARG_TAB_BV_RSLT &

◆ TYPE_INDEX_TAB_BV_RSLT

#define TYPE_INDEX_TAB_BV_RSLT &

◆ TYPE_ENUM_TAB_BV_RSLT

#define TYPE_ENUM_TAB_BV_RSLT &

◆ TYPE_MATRIX3_TAB_BV_RSLT

#define TYPE_MATRIX3_TAB_BV_RSLT &

◆ TYPE_ANGAXIS_TAB_BV_RSLT

#define TYPE_ANGAXIS_TAB_BV_RSLT &

◆ TYPE_QUAT_TAB_BV_RSLT

#define TYPE_QUAT_TAB_BV_RSLT &

◆ TYPE_BITARRAY_TAB_BV_RSLT

#define TYPE_BITARRAY_TAB_BV_RSLT &

◆ TYPE_CLASS_TAB_BV_RSLT

#define TYPE_CLASS_TAB_BV_RSLT &

◆ TYPE_RAY_TAB_BV_RSLT

#define TYPE_RAY_TAB_BV_RSLT &

◆ TYPE_POINT2_TAB_BV_RSLT

#define TYPE_POINT2_TAB_BV_RSLT &

◆ TYPE_MESH_TAB_BV_RSLT

#define TYPE_MESH_TAB_BV_RSLT &

◆ TYPE_OBJECT_TAB_BV_RSLT

#define TYPE_OBJECT_TAB_BV_RSLT &

◆ TYPE_CONTROL_TAB_BV_RSLT

#define TYPE_CONTROL_TAB_BV_RSLT &

◆ TYPE_INTERVAL_TAB_BV_RSLT

#define TYPE_INTERVAL_TAB_BV_RSLT &

◆ TYPE_POINT_TAB_BV_RSLT

#define TYPE_POINT_TAB_BV_RSLT &

◆ TYPE_HWND_TAB_BV_RSLT

#define TYPE_HWND_TAB_BV_RSLT &

◆ TYPE_TSTR_TAB_BV_RSLT

#define TYPE_TSTR_TAB_BV_RSLT &

◆ TYPE_IOBJECT_TAB_BV_RSLT

#define TYPE_IOBJECT_TAB_BV_RSLT &

◆ TYPE_INTERFACE_TAB_BV_RSLT

#define TYPE_INTERFACE_TAB_BV_RSLT &

◆ TYPE_NAME_TAB_BV_RSLT

#define TYPE_NAME_TAB_BV_RSLT &

◆ TYPE_COLOR_TAB_BV_RSLT

#define TYPE_COLOR_TAB_BV_RSLT &

◆ TYPE_ACOLOR_TAB_BV_RSLT

#define TYPE_ACOLOR_TAB_BV_RSLT &

◆ TYPE_FPVALUE_TAB_BV_RSLT

#define TYPE_FPVALUE_TAB_BV_RSLT &

◆ TYPE_VALUE_TAB_BV_RSLT

#define TYPE_VALUE_TAB_BV_RSLT &

◆ TYPE_DWORD_TAB_BV_RSLT

#define TYPE_DWORD_TAB_BV_RSLT &

◆ TYPE_bool_TAB_BV_RSLT

#define TYPE_bool_TAB_BV_RSLT &

◆ TYPE_INTPTR_TAB_BV_RSLT

#define TYPE_INTPTR_TAB_BV_RSLT &

◆ TYPE_INT64_TAB_BV_RSLT

#define TYPE_INT64_TAB_BV_RSLT &

◆ TYPE_DOUBLE_TAB_BV_RSLT

#define TYPE_DOUBLE_TAB_BV_RSLT &

◆ TYPE_BOX3_TAB_BV_RSLT

#define TYPE_BOX3_TAB_BV_RSLT &

◆ TYPE_FLOAT_TYPE

#define TYPE_FLOAT_TYPE float

◆ TYPE_INT_TYPE

#define TYPE_INT_TYPE int

◆ TYPE_RGBA_TYPE

#define TYPE_RGBA_TYPE Point3

◆ TYPE_POINT3_TYPE

#define TYPE_POINT3_TYPE Point3

◆ TYPE_FRGBA_TYPE

#define TYPE_FRGBA_TYPE Point4

◆ TYPE_POINT4_TYPE

#define TYPE_POINT4_TYPE Point4

◆ TYPE_BOOL_TYPE

#define TYPE_BOOL_TYPE BOOL

◆ TYPE_ANGLE_TYPE

#define TYPE_ANGLE_TYPE float

◆ TYPE_PCNT_FRAC_TYPE

#define TYPE_PCNT_FRAC_TYPE float

◆ TYPE_WORLD_TYPE

#define TYPE_WORLD_TYPE float

◆ TYPE_STRING_TYPE

#define TYPE_STRING_TYPE const MCHAR*

◆ TYPE_FILENAME_TYPE

#define TYPE_FILENAME_TYPE const MCHAR*

◆ TYPE_HSV_TYPE

#define TYPE_HSV_TYPE Point3

◆ TYPE_COLOR_CHANNEL_TYPE

#define TYPE_COLOR_CHANNEL_TYPE float

◆ TYPE_TIMEVALUE_TYPE

#define TYPE_TIMEVALUE_TYPE int

◆ TYPE_RADIOBTN_INDEX_TYPE

#define TYPE_RADIOBTN_INDEX_TYPE int

◆ TYPE_MTL_TYPE

#define TYPE_MTL_TYPE Mtl*

◆ TYPE_TEXMAP_TYPE

#define TYPE_TEXMAP_TYPE Texmap*

◆ TYPE_BITMAP_TYPE

#define TYPE_BITMAP_TYPE PBBitmap*

◆ TYPE_INODE_TYPE

#define TYPE_INODE_TYPE INode*

◆ TYPE_REFTARG_TYPE

#define TYPE_REFTARG_TYPE ReferenceTarget*

◆ TYPE_INDEX_TYPE

#define TYPE_INDEX_TYPE int

◆ TYPE_ENUM_TYPE

#define TYPE_ENUM_TYPE int

◆ TYPE_MATRIX3_TYPE

#define TYPE_MATRIX3_TYPE Matrix*

◆ TYPE_VOID_TYPE

#define TYPE_VOID_TYPE void

◆ TYPE_INTERVAL_TYPE

#define TYPE_INTERVAL_TYPE Interval*

◆ TYPE_ANGAXIS_TYPE

#define TYPE_ANGAXIS_TYPE AngAxis*

◆ TYPE_QUAT_TYPE

#define TYPE_QUAT_TYPE Quat*

◆ TYPE_RAY_TYPE

#define TYPE_RAY_TYPE Ray*

◆ TYPE_POINT2_TYPE

#define TYPE_POINT2_TYPE Point2*

◆ TYPE_BITARRAY_TYPE

#define TYPE_BITARRAY_TYPE BitArray*

◆ TYPE_CLASS_TYPE

#define TYPE_CLASS_TYPE ClassID*

◆ TYPE_MESH_TYPE

#define TYPE_MESH_TYPE Mesh*

◆ TYPE_OBJECT_TYPE

#define TYPE_OBJECT_TYPE Object*

◆ TYPE_CONTROL_TYPE

#define TYPE_CONTROL_TYPE Control*

◆ TYPE_POINT_TYPE

#define TYPE_POINT_TYPE POINT*

◆ TYPE_TSTR_TYPE

#define TYPE_TSTR_TYPE MSTR*

◆ TYPE_IOBJECT_TYPE

#define TYPE_IOBJECT_TYPE IObject*

◆ TYPE_INTERFACE_TYPE

#define TYPE_INTERFACE_TYPE FPInterface*

◆ TYPE_HWND_TYPE

#define TYPE_HWND_TYPE HWND

◆ TYPE_NAME_TYPE

#define TYPE_NAME_TYPE const MCHAR*

◆ TYPE_COLOR_TYPE

#define TYPE_COLOR_TYPE Color*

◆ TYPE_ACOLOR_TYPE

#define TYPE_ACOLOR_TYPE AColor*

◆ TYPE_FPVALUE_TYPE

#define TYPE_FPVALUE_TYPE FPValue*

◆ TYPE_VALUE_TYPE

#define TYPE_VALUE_TYPE Value*

◆ TYPE_DWORD_TYPE

#define TYPE_DWORD_TYPE DWORD

◆ TYPE_bool_TYPE

#define TYPE_bool_TYPE bool

◆ TYPE_INTPTR_TYPE

#define TYPE_INTPTR_TYPE INT_PTR

◆ TYPE_INT64_TYPE

#define TYPE_INT64_TYPE INT64

◆ TYPE_DOUBLE_TYPE

#define TYPE_DOUBLE_TYPE double

◆ TYPE_BOX3_TYPE

#define TYPE_BOX3_TYPE Box3*

◆ TYPE_FLOAT_TAB_TYPE

#define TYPE_FLOAT_TAB_TYPE Tab<float>*

◆ TYPE_INT_TAB_TYPE

#define TYPE_INT_TAB_TYPE Tab<int>*

◆ TYPE_RGBA_TAB_TYPE

#define TYPE_RGBA_TAB_TYPE Tab<Point3>*

◆ TYPE_POINT3_TAB_TYPE

#define TYPE_POINT3_TAB_TYPE Tab<Point3>*

◆ TYPE_FRGBA_TAB_TYPE

#define TYPE_FRGBA_TAB_TYPE Tab<Point4>*

◆ TYPE_POINT4_TAB_TYPE

#define TYPE_POINT4_TAB_TYPE Tab<Point4>*

◆ TYPE_BOOL_TAB_TYPE

#define TYPE_BOOL_TAB_TYPE Tab<BOOL>*

◆ TYPE_ANGLE_TAB_TYPE

#define TYPE_ANGLE_TAB_TYPE Tab<float>*

◆ TYPE_PCNT_FRAC_TAB_TYPE

#define TYPE_PCNT_FRAC_TAB_TYPE Tab<float>*

◆ TYPE_WORLD_TAB_TYPE

#define TYPE_WORLD_TAB_TYPE Tab<float>*

◆ TYPE_STRING_TAB_TYPE

#define TYPE_STRING_TAB_TYPE Tab<const MCHAR*>*

◆ TYPE_FILENAME_TAB_TYPE

#define TYPE_FILENAME_TAB_TYPE Tab<const MCHAR*>*

◆ TYPE_HSV_TAB_TYPE

#define TYPE_HSV_TAB_TYPE Tab<Point3>*

◆ TYPE_COLOR_CHANNEL_TAB_TYPE

#define TYPE_COLOR_CHANNEL_TAB_TYPE Tab<float>*

◆ TYPE_TIMEVALUE_TAB_TYPE

#define TYPE_TIMEVALUE_TAB_TYPE Tab<int>*

◆ TYPE_RADIOBTN_INDEX_TAB_TYPE

#define TYPE_RADIOBTN_INDEX_TAB_TYPE Tab<int>*

◆ TYPE_MTL_TAB_TYPE

#define TYPE_MTL_TAB_TYPE Tab<Mtl*>*

◆ TYPE_TEXMAP_TAB_TYPE

#define TYPE_TEXMAP_TAB_TYPE Tab<Texmap*>*

◆ TYPE_BITMAP_TAB_TYPE

#define TYPE_BITMAP_TAB_TYPE Tab<PBBitmap*>*

◆ TYPE_INODE_TAB_TYPE

#define TYPE_INODE_TAB_TYPE Tab<INode*>*

◆ TYPE_REFTARG_TAB_TYPE

#define TYPE_REFTARG_TAB_TYPE Tab<ReferenceTarget*>*

◆ TYPE_INDEX_TAB_TYPE

#define TYPE_INDEX_TAB_TYPE Tab<int>*

◆ TYPE_ENUM_TAB_TYPE

#define TYPE_ENUM_TAB_TYPE Tab<int>*

◆ TYPE_MATRIX3_TAB_TYPE

#define TYPE_MATRIX3_TAB_TYPE Tab<Matrix*>*

◆ TYPE_VOID_TAB_TYPE

#define TYPE_VOID_TAB_TYPE Tab<void>*

◆ TYPE_INTERVAL_TAB_TYPE

#define TYPE_INTERVAL_TAB_TYPE Tab<Interval*>*

◆ TYPE_ANGAXIS_TAB_TYPE

#define TYPE_ANGAXIS_TAB_TYPE Tab<AngAxis*>*

◆ TYPE_QUAT_TAB_TYPE

#define TYPE_QUAT_TAB_TYPE Tab<Quat*>*

◆ TYPE_RAY_TAB_TYPE

#define TYPE_RAY_TAB_TYPE Tab<Ray*>*

◆ TYPE_POINT2_TAB_TYPE

#define TYPE_POINT2_TAB_TYPE Tab<Point2*>*

◆ TYPE_BITARRAY_TAB_TYPE

#define TYPE_BITARRAY_TAB_TYPE Tab<BitArray*>*

◆ TYPE_CLASS_TAB_TYPE

#define TYPE_CLASS_TAB_TYPE Tab<ClassID*>*

◆ TYPE_MESH_TAB_TYPE

#define TYPE_MESH_TAB_TYPE Tab<Mesh*>*

◆ TYPE_OBJECT_TAB_TYPE

#define TYPE_OBJECT_TAB_TYPE Tab<Object*>*

◆ TYPE_CONTROL_TAB_TYPE

#define TYPE_CONTROL_TAB_TYPE Tab<Control*>*

◆ TYPE_POINT_TAB_TYPE

#define TYPE_POINT_TAB_TYPE Tab<POINT*>*

◆ TYPE_TSTR_TAB_TYPE

#define TYPE_TSTR_TAB_TYPE Tab<MSTR*>*

◆ TYPE_IOBJECT_TAB_TYPE

#define TYPE_IOBJECT_TAB_TYPE Tab<IObject*>*

◆ TYPE_INTERFACE_TAB_TYPE

#define TYPE_INTERFACE_TAB_TYPE Tab<FPInterface*>*

◆ TYPE_HWND_TAB_TYPE

#define TYPE_HWND_TAB_TYPE Tab<HWND>*

◆ TYPE_NAME_TAB_TYPE

#define TYPE_NAME_TAB_TYPE Tab<const MCHAR*>*

◆ TYPE_COLOR_TAB_TYPE

#define TYPE_COLOR_TAB_TYPE Tab<Color*>*

◆ TYPE_ACOLOR_TAB_TYPE

#define TYPE_ACOLOR_TAB_TYPE Tab<AColor*>*

◆ TYPE_FPVALUE_TAB_TYPE

#define TYPE_FPVALUE_TAB_TYPE Tab<FPValue*>*

◆ TYPE_VALUE_TAB_TYPE

#define TYPE_VALUE_TAB_TYPE Tab<Value*>*

◆ TYPE_DWORD_TAB_TYPE

#define TYPE_DWORD_TAB_TYPE Tab<DWORD>*

◆ TYPE_bool_TAB_TYPE

#define TYPE_bool_TAB_TYPE Tab<bool>*

◆ TYPE_INTPTR_TAB_TYPE

#define TYPE_INTPTR_TAB_TYPE Tab<INT_PTR>*

◆ TYPE_INT64_TAB_TYPE

#define TYPE_INT64_TAB_TYPE Tab<INT64>*

◆ TYPE_DOUBLE_TAB_TYPE

#define TYPE_DOUBLE_TAB_TYPE Tab<double>*

◆ TYPE_BOX3_TAB_TYPE

#define TYPE_BOX3_TAB_TYPE Tab<Box3*>*

◆ TYPE_FLOAT_BP_TYPE

#define TYPE_FLOAT_BP_TYPE float*

◆ TYPE_INT_BP_TYPE

#define TYPE_INT_BP_TYPE int*

◆ TYPE_BOOL_BP_TYPE

#define TYPE_BOOL_BP_TYPE int*

◆ TYPE_ANGLE_BP_TYPE

#define TYPE_ANGLE_BP_TYPE float*

◆ TYPE_PCNT_FRAC_BP_TYPE

#define TYPE_PCNT_FRAC_BP_TYPE float*

◆ TYPE_WORLD_BP_TYPE

#define TYPE_WORLD_BP_TYPE float*

◆ TYPE_COLOR_CHANNEL_BP_TYPE

#define TYPE_COLOR_CHANNEL_BP_TYPE float*

◆ TYPE_TIMEVALUE_BP_TYPE

#define TYPE_TIMEVALUE_BP_TYPE int*

◆ TYPE_RADIOBTN_INDEX_BP_TYPE

#define TYPE_RADIOBTN_INDEX_BP_TYPE int*

◆ TYPE_INDEX_BP_TYPE

#define TYPE_INDEX_BP_TYPE int*

◆ TYPE_ENUM_BP_TYPE

#define TYPE_ENUM_BP_TYPE int*

◆ TYPE_DWORD_BP_TYPE

#define TYPE_DWORD_BP_TYPE DWORD*

◆ TYPE_bool_BP_TYPE

#define TYPE_bool_BP_TYPE bool*

◆ TYPE_INTPTR_BP_TYPE

#define TYPE_INTPTR_BP_TYPE INT_PTR*

◆ TYPE_INT64_BP_TYPE

#define TYPE_INT64_BP_TYPE INT64*

◆ TYPE_DOUBLE_BP_TYPE

#define TYPE_DOUBLE_BP_TYPE double*

◆ TYPE_FLOAT_BR_TYPE

#define TYPE_FLOAT_BR_TYPE float&

◆ TYPE_INT_BR_TYPE

#define TYPE_INT_BR_TYPE int&

◆ TYPE_RGBA_BR_TYPE

#define TYPE_RGBA_BR_TYPE Point3&

◆ TYPE_POINT3_BR_TYPE

#define TYPE_POINT3_BR_TYPE Point3&

◆ TYPE_FRGBA_BR_TYPE

#define TYPE_FRGBA_BR_TYPE Point4&

◆ TYPE_POINT4_BR_TYPE

#define TYPE_POINT4_BR_TYPE Point4&

◆ TYPE_BOOL_BR_TYPE

#define TYPE_BOOL_BR_TYPE int&

◆ TYPE_ANGLE_BR_TYPE

#define TYPE_ANGLE_BR_TYPE float&

◆ TYPE_PCNT_FRAC_BR_TYPE

#define TYPE_PCNT_FRAC_BR_TYPE float&

◆ TYPE_WORLD_BR_TYPE

#define TYPE_WORLD_BR_TYPE float&

◆ TYPE_HSV_BR_TYPE

#define TYPE_HSV_BR_TYPE Point3&

◆ TYPE_COLOR_CHANNEL_BR_TYPE

#define TYPE_COLOR_CHANNEL_BR_TYPE float&

◆ TYPE_TIMEVALUE_BR_TYPE

#define TYPE_TIMEVALUE_BR_TYPE int&

◆ TYPE_RADIOBTN_INDEX_BR_TYPE

#define TYPE_RADIOBTN_INDEX_BR_TYPE int&

◆ TYPE_BITMAP_BR_TYPE

#define TYPE_BITMAP_BR_TYPE PBBitmap&

◆ TYPE_INDEX_BR_TYPE

#define TYPE_INDEX_BR_TYPE int&

◆ TYPE_ENUM_BR_TYPE

#define TYPE_ENUM_BR_TYPE int&

◆ TYPE_REFTARG_BR_TYPE

#define TYPE_REFTARG_BR_TYPE ReferenceTarget&

◆ TYPE_MATRIX3_BR_TYPE

#define TYPE_MATRIX3_BR_TYPE Matrix3&

◆ TYPE_ANGAXIS_BR_TYPE

#define TYPE_ANGAXIS_BR_TYPE AngAxis&

◆ TYPE_QUAT_BR_TYPE

#define TYPE_QUAT_BR_TYPE Quat&

◆ TYPE_BITARRAY_BR_TYPE

#define TYPE_BITARRAY_BR_TYPE BitArray&

◆ TYPE_RAY_BR_TYPE

#define TYPE_RAY_BR_TYPE Ray&

◆ TYPE_POINT2_BR_TYPE

#define TYPE_POINT2_BR_TYPE Point2&

◆ TYPE_MESH_BR_TYPE

#define TYPE_MESH_BR_TYPE Mesh&

◆ TYPE_INTERVAL_BR_TYPE

#define TYPE_INTERVAL_BR_TYPE Interval&

◆ TYPE_POINT_BR_TYPE

#define TYPE_POINT_BR_TYPE POINT&

◆ TYPE_TSTR_BR_TYPE

#define TYPE_TSTR_BR_TYPE MSTR&

◆ TYPE_COLOR_BR_TYPE

#define TYPE_COLOR_BR_TYPE Color&

◆ TYPE_ACOLOR_BR_TYPE

#define TYPE_ACOLOR_BR_TYPE AColor&

◆ TYPE_FPVALUE_BR_TYPE

#define TYPE_FPVALUE_BR_TYPE FPValue&

◆ TYPE_DWORD_BR_TYPE

#define TYPE_DWORD_BR_TYPE DWORD&

◆ TYPE_bool_BR_TYPE

#define TYPE_bool_BR_TYPE bool&

◆ TYPE_INTPTR_BR_TYPE

#define TYPE_INTPTR_BR_TYPE INT_PTR&

◆ TYPE_INT64_BR_TYPE

#define TYPE_INT64_BR_TYPE INT64&

◆ TYPE_DOUBLE_BR_TYPE

#define TYPE_DOUBLE_BR_TYPE double&

◆ TYPE_BOX3_BR_TYPE

#define TYPE_BOX3_BR_TYPE Box3&

◆ TYPE_FLOAT_TAB_BR_TYPE

#define TYPE_FLOAT_TAB_BR_TYPE Tab<float>&

◆ TYPE_INT_TAB_BR_TYPE

#define TYPE_INT_TAB_BR_TYPE Tab<int>&

◆ TYPE_RGBA_TAB_BR_TYPE

#define TYPE_RGBA_TAB_BR_TYPE Tab<Point3>&

◆ TYPE_POINT3_TAB_BR_TYPE

#define TYPE_POINT3_TAB_BR_TYPE Tab<Point3>&

◆ TYPE_FRGBA_TAB_BR_TYPE

#define TYPE_FRGBA_TAB_BR_TYPE Tab<Point4>&

◆ TYPE_POINT4_TAB_BR_TYPE

#define TYPE_POINT4_TAB_BR_TYPE Tab<Point4>&

◆ TYPE_BOOL_TAB_BR_TYPE

#define TYPE_BOOL_TAB_BR_TYPE Tab<BOOL>&

◆ TYPE_ANGLE_TAB_BR_TYPE

#define TYPE_ANGLE_TAB_BR_TYPE Tab<float>&

◆ TYPE_PCNT_FRAC_TAB_BR_TYPE

#define TYPE_PCNT_FRAC_TAB_BR_TYPE Tab<float>&

◆ TYPE_WORLD_TAB_BR_TYPE

#define TYPE_WORLD_TAB_BR_TYPE Tab<float>&

◆ TYPE_STRING_TAB_BR_TYPE

#define TYPE_STRING_TAB_BR_TYPE Tab<const MCHAR*>&

◆ TYPE_FILENAME_TAB_BR_TYPE

#define TYPE_FILENAME_TAB_BR_TYPE Tab<const MCHAR*>&

◆ TYPE_HSV_TAB_BR_TYPE

#define TYPE_HSV_TAB_BR_TYPE Tab<Point3>&

◆ TYPE_COLOR_CHANNEL_TAB_BR_TYPE

#define TYPE_COLOR_CHANNEL_TAB_BR_TYPE Tab<float>&

◆ TYPE_TIMEVALUE_TAB_BR_TYPE

#define TYPE_TIMEVALUE_TAB_BR_TYPE Tab<int>&

◆ TYPE_RADIOBTN_INDEX_TAB_BR_TYPE

#define TYPE_RADIOBTN_INDEX_TAB_BR_TYPE Tab<int>&

◆ TYPE_MTL_TAB_BR_TYPE

#define TYPE_MTL_TAB_BR_TYPE Tab<Mtl*>&

◆ TYPE_TEXMAP_TAB_BR_TYPE

#define TYPE_TEXMAP_TAB_BR_TYPE Tab<Texmap*>&

◆ TYPE_BITMAP_TAB_BR_TYPE

#define TYPE_BITMAP_TAB_BR_TYPE Tab<PBBitmap*>&

◆ TYPE_INODE_TAB_BR_TYPE

#define TYPE_INODE_TAB_BR_TYPE Tab<INode*>&

◆ TYPE_REFTARG_TAB_BR_TYPE

#define TYPE_REFTARG_TAB_BR_TYPE Tab<ReferenceTarget*>&

◆ TYPE_INDEX_TAB_BR_TYPE

#define TYPE_INDEX_TAB_BR_TYPE Tab<int>&

◆ TYPE_ENUM_TAB_BR_TYPE

#define TYPE_ENUM_TAB_BR_TYPE Tab<int>&

◆ TYPE_MATRIX3_TAB_BR_TYPE

#define TYPE_MATRIX3_TAB_BR_TYPE Tab<Matrix*>&

◆ TYPE_VOID_TAB_BR_TYPE

#define TYPE_VOID_TAB_BR_TYPE Tab<void>&

◆ TYPE_INTERVAL_TAB_BR_TYPE

#define TYPE_INTERVAL_TAB_BR_TYPE Tab<Interval*>&

◆ TYPE_ANGAXIS_TAB_BR_TYPE

#define TYPE_ANGAXIS_TAB_BR_TYPE Tab<AngAxis*>&

◆ TYPE_QUAT_TAB_BR_TYPE

#define TYPE_QUAT_TAB_BR_TYPE Tab<Quat*>&

◆ TYPE_RAY_TAB_BR_TYPE

#define TYPE_RAY_TAB_BR_TYPE Tab<Ray*>&

◆ TYPE_POINT2_TAB_BR_TYPE

#define TYPE_POINT2_TAB_BR_TYPE Tab<Point2*>&

◆ TYPE_BITARRAY_TAB_BR_TYPE

#define TYPE_BITARRAY_TAB_BR_TYPE Tab<BitArray*>&

◆ TYPE_CLASS_TAB_BR_TYPE

#define TYPE_CLASS_TAB_BR_TYPE Tab<ClassID*>&

◆ TYPE_MESH_TAB_BR_TYPE

#define TYPE_MESH_TAB_BR_TYPE Tab<Mesh*>&

◆ TYPE_OBJECT_TAB_BR_TYPE

#define TYPE_OBJECT_TAB_BR_TYPE Tab<Object*>&

◆ TYPE_CONTROL_TAB_BR_TYPE

#define TYPE_CONTROL_TAB_BR_TYPE Tab<Control*>&

◆ TYPE_POINT_TAB_BR_TYPE

#define TYPE_POINT_TAB_BR_TYPE Tab<POINT*>&

◆ TYPE_TSTR_TAB_BR_TYPE

#define TYPE_TSTR_TAB_BR_TYPE Tab<MSTR*>&

◆ TYPE_IOBJECT_TAB_BR_TYPE

#define TYPE_IOBJECT_TAB_BR_TYPE Tab<IObject*>&

◆ TYPE_INTERFACE_TAB_BR_TYPE

#define TYPE_INTERFACE_TAB_BR_TYPE Tab<FPInterface*>&

◆ TYPE_HWND_TAB_BR_TYPE

#define TYPE_HWND_TAB_BR_TYPE Tab<HWND>&

◆ TYPE_NAME_TAB_BR_TYPE

#define TYPE_NAME_TAB_BR_TYPE Tab<const MCHAR*>&

◆ TYPE_COLOR_TAB_BR_TYPE

#define TYPE_COLOR_TAB_BR_TYPE Tab<Color*>&

◆ TYPE_ACOLOR_TAB_BR_TYPE

#define TYPE_ACOLOR_TAB_BR_TYPE Tab<AColor*>&

◆ TYPE_FPVALUE_TAB_BR_TYPE

#define TYPE_FPVALUE_TAB_BR_TYPE Tab<FPValue*>&

◆ TYPE_VALUE_TAB_BR_TYPE

#define TYPE_VALUE_TAB_BR_TYPE Tab<Value*>&

◆ TYPE_DWORD_TAB_BR_TYPE

#define TYPE_DWORD_TAB_BR_TYPE Tab<DWORD>&

◆ TYPE_bool_TAB_BR_TYPE

#define TYPE_bool_TAB_BR_TYPE Tab<bool>&

◆ TYPE_INTPTR_TAB_BR_TYPE

#define TYPE_INTPTR_TAB_BR_TYPE Tab<INT_PTR>&

◆ TYPE_INT64_TAB_BR_TYPE

#define TYPE_INT64_TAB_BR_TYPE Tab<INT64>&

◆ TYPE_DOUBLE_TAB_BR_TYPE

#define TYPE_DOUBLE_TAB_BR_TYPE Tab<double>&

◆ TYPE_BOX3_TAB_BR_TYPE

#define TYPE_BOX3_TAB_BR_TYPE Tab<Box3>&

◆ TYPE_RGBA_BV_TYPE

#define TYPE_RGBA_BV_TYPE Point3

◆ TYPE_POINT3_BV_TYPE

#define TYPE_POINT3_BV_TYPE Point3

◆ TYPE_HSV_BV_TYPE

#define TYPE_HSV_BV_TYPE Point3

◆ TYPE_FRGBA_BV_TYPE

#define TYPE_FRGBA_BV_TYPE Point4

◆ TYPE_POINT4_BV_TYPE

#define TYPE_POINT4_BV_TYPE Point4

◆ TYPE_BITMAP_BV_TYPE

#define TYPE_BITMAP_BV_TYPE PBBitmap

◆ TYPE_MATRIX3_BV_TYPE

#define TYPE_MATRIX3_BV_TYPE Matrix3

◆ TYPE_ANGAXIS_BV_TYPE

#define TYPE_ANGAXIS_BV_TYPE AngAxis

◆ TYPE_QUAT_BV_TYPE

#define TYPE_QUAT_BV_TYPE Quat

◆ TYPE_BITARRAY_BV_TYPE

#define TYPE_BITARRAY_BV_TYPE BitArray

◆ TYPE_RAY_BV_TYPE

#define TYPE_RAY_BV_TYPE Ray

◆ TYPE_POINT2_BV_TYPE

#define TYPE_POINT2_BV_TYPE Point2

◆ TYPE_MESH_BV_TYPE

#define TYPE_MESH_BV_TYPE Mesh

◆ TYPE_INTERVAL_BV_TYPE

#define TYPE_INTERVAL_BV_TYPE Interval

◆ TYPE_POINT_BV_TYPE

#define TYPE_POINT_BV_TYPE POINT

◆ TYPE_TSTR_BV_TYPE

#define TYPE_TSTR_BV_TYPE MSTR

◆ TYPE_COLOR_BV_TYPE

#define TYPE_COLOR_BV_TYPE Color

◆ TYPE_ACOLOR_BV_TYPE

#define TYPE_ACOLOR_BV_TYPE AColor

◆ TYPE_FPVALUE_BV_TYPE

#define TYPE_FPVALUE_BV_TYPE FPValue

◆ TYPE_CLASS_BV_TYPE

#define TYPE_CLASS_BV_TYPE ClassID

◆ TYPE_BOX3_BV_TYPE

#define TYPE_BOX3_BV_TYPE Box3

◆ TYPE_FLOAT_TAB_BV_TYPE

#define TYPE_FLOAT_TAB_BV_TYPE Tab<float>

◆ TYPE_INT_TAB_BV_TYPE

#define TYPE_INT_TAB_BV_TYPE Tab<int>

◆ TYPE_RGBA_TAB_BV_TYPE

#define TYPE_RGBA_TAB_BV_TYPE Tab<Point3>

◆ TYPE_POINT3_TAB_BV_TYPE

#define TYPE_POINT3_TAB_BV_TYPE Tab<Point3>

◆ TYPE_FRGBA_TAB_BV_TYPE

#define TYPE_FRGBA_TAB_BV_TYPE Tab<Point4>

◆ TYPE_POINT4_TAB_BV_TYPE

#define TYPE_POINT4_TAB_BV_TYPE Tab<Point4>

◆ TYPE_BOOL_TAB_BV_TYPE

#define TYPE_BOOL_TAB_BV_TYPE Tab<BOOL>

◆ TYPE_ANGLE_TAB_BV_TYPE

#define TYPE_ANGLE_TAB_BV_TYPE Tab<float>

◆ TYPE_PCNT_FRAC_TAB_BV_TYPE

#define TYPE_PCNT_FRAC_TAB_BV_TYPE Tab<float>

◆ TYPE_WORLD_TAB_BV_TYPE

#define TYPE_WORLD_TAB_BV_TYPE Tab<float>

◆ TYPE_STRING_TAB_BV_TYPE

#define TYPE_STRING_TAB_BV_TYPE Tab<const MCHAR*>

◆ TYPE_FILENAME_TAB_BV_TYPE

#define TYPE_FILENAME_TAB_BV_TYPE Tab<const MCHAR*>

◆ TYPE_HSV_TAB_BV_TYPE

#define TYPE_HSV_TAB_BV_TYPE Tab<Point3>

◆ TYPE_COLOR_CHANNEL_TAB_BV_TYPE

#define TYPE_COLOR_CHANNEL_TAB_BV_TYPE Tab<float>

◆ TYPE_TIMEVALUE_TAB_BV_TYPE

#define TYPE_TIMEVALUE_TAB_BV_TYPE Tab<int>

◆ TYPE_RADIOBTN_INDEX_TAB_BV_TYPE

#define TYPE_RADIOBTN_INDEX_TAB_BV_TYPE Tab<int>

◆ TYPE_MTL_TAB_BV_TYPE

#define TYPE_MTL_TAB_BV_TYPE Tab<Mtl*>

◆ TYPE_TEXMAP_TAB_BV_TYPE

#define TYPE_TEXMAP_TAB_BV_TYPE Tab<Texmap*>

◆ TYPE_BITMAP_TAB_BV_TYPE

#define TYPE_BITMAP_TAB_BV_TYPE Tab<PBBitmap*>

◆ TYPE_INODE_TAB_BV_TYPE

#define TYPE_INODE_TAB_BV_TYPE Tab<INode*>

◆ TYPE_REFTARG_TAB_BV_TYPE

#define TYPE_REFTARG_TAB_BV_TYPE Tab<ReferenceTarget*>

◆ TYPE_INDEX_TAB_BV_TYPE

#define TYPE_INDEX_TAB_BV_TYPE Tab<int>

◆ TYPE_ENUM_TAB_BV_TYPE

#define TYPE_ENUM_TAB_BV_TYPE Tab<int>

◆ TYPE_MATRIX3_TAB_BV_TYPE

#define TYPE_MATRIX3_TAB_BV_TYPE Tab<Matrix*>

◆ TYPE_VOID_TAB_BV_TYPE

#define TYPE_VOID_TAB_BV_TYPE Tab<void>

◆ TYPE_INTERVAL_TAB_BV_TYPE

#define TYPE_INTERVAL_TAB_BV_TYPE Tab<Interval*>

◆ TYPE_ANGAXIS_TAB_BV_TYPE

#define TYPE_ANGAXIS_TAB_BV_TYPE Tab<AngAxis*>

◆ TYPE_QUAT_TAB_BV_TYPE

#define TYPE_QUAT_TAB_BV_TYPE Tab<Quat*>

◆ TYPE_RAY_TAB_BV_TYPE

#define TYPE_RAY_TAB_BV_TYPE Tab<Ray*>

◆ TYPE_POINT2_TAB_BV_TYPE

#define TYPE_POINT2_TAB_BV_TYPE Tab<Point2*>

◆ TYPE_BITARRAY_TAB_BV_TYPE

#define TYPE_BITARRAY_TAB_BV_TYPE Tab<BitArray*>

◆ TYPE_CLASS_TAB_BV_TYPE

#define TYPE_CLASS_TAB_BV_TYPE Tab<ClassID*>

◆ TYPE_MESH_TAB_BV_TYPE

#define TYPE_MESH_TAB_BV_TYPE Tab<Mesh*>

◆ TYPE_OBJECT_TAB_BV_TYPE

#define TYPE_OBJECT_TAB_BV_TYPE Tab<Object*>

◆ TYPE_CONTROL_TAB_BV_TYPE

#define TYPE_CONTROL_TAB_BV_TYPE Tab<Control*>

◆ TYPE_POINT_TAB_BV_TYPE

#define TYPE_POINT_TAB_BV_TYPE Tab<POINT*>

◆ TYPE_TSTR_TAB_BV_TYPE

#define TYPE_TSTR_TAB_BV_TYPE Tab<MSTR*>

◆ TYPE_IOBJECT_TAB_BV_TYPE

#define TYPE_IOBJECT_TAB_BV_TYPE Tab<IObject*>

◆ TYPE_INTERFACE_TAB_BV_TYPE

#define TYPE_INTERFACE_TAB_BV_TYPE Tab<FPInterface*>

◆ TYPE_HWND_TAB_BV_TYPE

#define TYPE_HWND_TAB_BV_TYPE Tab<HWND>

◆ TYPE_NAME_TAB_BV_TYPE

#define TYPE_NAME_TAB_BV_TYPE Tab<const MCHAR*>

◆ TYPE_COLOR_TAB_BV_TYPE

#define TYPE_COLOR_TAB_BV_TYPE Tab<Color*>

◆ TYPE_ACOLOR_TAB_BV_TYPE

#define TYPE_ACOLOR_TAB_BV_TYPE Tab<AColor*>

◆ TYPE_FPVALUE_TAB_BV_TYPE

#define TYPE_FPVALUE_TAB_BV_TYPE Tab<FPValue*>

◆ TYPE_VALUE_TAB_BV_TYPE

#define TYPE_VALUE_TAB_BV_TYPE Tab<Value*>

◆ TYPE_DWORD_TAB_BV_TYPE

#define TYPE_DWORD_TAB_BV_TYPE Tab<DWORD>

◆ TYPE_bool_TAB_BV_TYPE

#define TYPE_bool_TAB_BV_TYPE Tab<bool>

◆ TYPE_INTPTR_TAB_BV_TYPE

#define TYPE_INTPTR_TAB_BV_TYPE Tab<INT_PTR>

◆ TYPE_INT64_TAB_BV_TYPE

#define TYPE_INT64_TAB_BV_TYPE Tab<INT64>

◆ TYPE_DOUBLE_TAB_BV_TYPE

#define TYPE_DOUBLE_TAB_BV_TYPE Tab<double>

◆ TYPE_BOX3_TAB_BV_TYPE

#define TYPE_BOX3_TAB_BV_TYPE Tab<Box3*>

Typedef Documentation

◆ FPStatus

typedef int FPStatus

◆ FunctionID

typedef short FunctionID

ID for individual functions within an interface (local)

◆ EnumID

typedef short EnumID

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
f_category
f_predicates
f_isEnabled
f_isChecked
f_isVisible
f_iconRes
f_icon
f_buttonText
f_toolTip
f_menuText
f_ui
f_shortCut
f_macroEmitter
f_embeddedScriptSecurityFeature
f_range
f_validator
f_inOut
f_keyArgDefault
f_embeddedScriptSecurityFeature_r
f_embeddedScriptSecurityFeature_w
f_embeddedScriptSecurityFeature_rw

      {
     // Action options
     f_category = -(1<<30),          // category name, as internal MCHAR* and localizable string resID, defaults to interface name
     f_predicates,                   // supply 3 functionIDs for isEnabled, isChecked, isVisible predicates 
     f_isEnabled,                    // isEnabled predicate functionID
     f_isChecked,                    // isChecked predicate functionID
     f_isVisible,                    // isVisible predicate functionID
     f_iconRes,                      // icon as resource ID
     f_icon,                         // icon as UI .bmp filename, index pair, as per CUI icon specifications
     f_buttonText,                   // button text string resID, defaults to function description
     f_toolTip,                      // tooltip string resID, defaults to function description
     f_menuText,                     // menu item text string resID, defaults to buttonText or function description
     f_ui,                           // UI spec if paramMap2-implemented UI (pmap blockID, mapID, control type, button or checkbutton resID, hilight col if chkbtn)
     f_shortCut,                     // default keyboard short cut, as pair: virt ACCEL flags word, keycode  (first two items in Win32 ACCEL struct)
     f_macroEmitter,                 // provide callback object to handle macro emmission
     f_embeddedScriptSecurityFeature, // invoking action is subject to ISceneScriptSecurityManager settings. When this
                                      // is specified, next value is a
                                      // MaxSDK::ISceneScriptSecurityManager::ScriptingFeature value
  
     // param and property options
     f_range,                        // valid range, two type-specific vals
     f_validator,                    // validator object, FPValidator*
     f_inOut,                        // in, out flags FPP_IN_PARM, FPP_OUT_PARAM or both, defaults to both
     f_keyArgDefault,                // marks this as an optional keyArg param and gives default value which must be of type to match param type, If the param type is a _BR type, the default value must be specified as a pointer to the default value.
     f_embeddedScriptSecurityFeature_r, // invoking getter function is subject to ISceneScriptSecurityManager settings.
                                        // Note that this option should only be used in the 'properties' section of the descriptor.
                                        // When this option is specified, the next value is a
                                        // MaxSDK::ISceneScriptSecurityManager::ScriptingFeature value
  
     f_embeddedScriptSecurityFeature_w, // invoking setter function is subject to ISceneScriptSecurityManager settings.
                                        // Note that this option should only be used in the 'properties' section of the descriptor.
                                        // When this option is specified, the next value is a
                                        // MaxSDK::ISceneScriptSecurityManager::ScriptingFeature value
  
     f_embeddedScriptSecurityFeature_rw, // invoking getter and setter functions are subject to ISceneScriptSecurityManager settings.
                                        // Note that this option should only be used in the 'properties' section of the descriptor.
                                         // When this option is specified, the next value is a
                                         // MaxSDK::ISceneScriptSecurityManager::ScriptingFeature value
  
 };

Function Documentation

◆ GetFPInterface()

FPInterface* GetFPInterface ( BaseInterface * bi )

inline

65 { return reinterpret_cast<FPInterface*>( bi->GetInterface(FPINTERFACE_ID)); }

BaseInterface::GetInterface

UtilExport BaseInterface * GetInterface(Interface_ID id) override

FPInterface

Definition: ifnpub.h:132

FPINTERFACE_ID

#define FPINTERFACE_ID

Definition: ifnpub.h:60

◆ GetFPInterfaceDesc()

FPInterfaceDesc* GetFPInterfaceDesc ( BaseInterface * bi )

inline

66 { return reinterpret_cast<FPInterfaceDesc*>( bi->GetInterface(FPINTERFACEDESC_ID)); }

FPInterfaceDesc

Definition: ifnpub.h:325

FPINTERFACEDESC_ID

#define FPINTERFACEDESC_ID

Definition: ifnpub.h:62

◆ GetFPMixinInterface()

FPMixinInterface* GetFPMixinInterface ( BaseInterface * bi )

inline

67 { return reinterpret_cast<FPMixinInterface*>(bi->GetInterface(FPMIXININTERFACE_ID)); }

FPMixinInterface

Definition: ifnpub.h:559

FPMIXININTERFACE_ID

#define FPMIXININTERFACE_ID

Definition: ifnpub.h:61

Classes

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ FP_NO_FUNCTION

◆ FP_NO_ENUM

◆ NULLINTERFACE_ID

◆ FPINTERFACE_ID

◆ FPMIXININTERFACE_ID

◆ FPINTERFACEDESC_ID

◆ FP_ACTIONS

◆ FP_MIXIN

◆ FP_CORE

◆ FP_STATIC_METHODS

◆ FP_TEST_INTERFACE

◆ FP_SCRIPTED_CLASS

◆ FP_TEMPORARY

◆ FP_NO_REDRAW

◆ FP_VAR_ARGS

◆ FP_CLIENT_OWNS_RESULT

◆ FP_EMBEDDEDSCRIPTSECURITYFEATURE

◆ FP_ACTION

◆ FP_HAS_UI

◆ FP_ICONRES

◆ FP_ICONFILE

◆ FP_HAS_SHORTCUT

◆ FP_HAS_KEYARGS

◆ FPP_HAS_RANGE

◆ FPP_HAS_VALIDATOR

◆ FPP_IN_PARAM

◆ FPP_OUT_PARAM

◆ FPP_IN_OUT_PARAM

◆ FPP_KEYARG

◆ FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_R

◆ FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_W

◆ FPP_HAS_EMBEDDEDSCRIPTSECURITYFEATURE_RW

◆ DECLARE_DESCRIPTOR

◆ DECLARE_DESCRIPTOR_INIT

◆ DECLARE_DESCRIPTOR_NDC

◆ DECLARE_DESCRIPTOR_INIT_NDC

◆ BEGIN_FUNCTION_MAP

◆ BEGIN_FUNCTION_MAP_PARENT

◆ END_FUNCTION_MAP

◆ NO_FUNCTION_MAP

◆ FP_FIELD

◆ FN_ACTION

◆ FN_PRED

◆ FN_PREDS

◆ PROP_FNS

◆ RO_PROP_FN

◆ PROP_TFNS

◆ RO_PROP_TFN

◆ SM_PROP_FNS

◆ SM_RO_PROP_FN

◆ SM_PROP_TFNS

◆ SM_RO_PROP_TFN

◆ FN_VA

◆ FN_0

◆ FN_1

◆ FN_2

◆ FN_3

◆ FN_4

◆ FN_5

◆ FN_6

◆ FN_7

◆ FN_8

◆ FN_9

◆ FN_10

◆ FN_11

◆ VFN_VA

◆ VFN_0

◆ VFN_1

◆ VFN_2

◆ VFN_3

◆ VFN_4

◆ VFN_5

◆ VFN_6

◆ VFN_7