mxsPlugin.h File Reference

#include "../kernel/value.h"
#include "../maxwrapper/mxsobjects.h"
#include "../../ref.h"
#include "../../iparamm2.h"
#include "../../iparamb2.h"
#include "../../iparamb2Typedefs.h"
#include "../../IMtlRender_Compatibility.h"
#include "../../genlight.h"
#include "../../gencam.h"
#include "../../simpobj.h"
#include "../../simpspl.h"
#include "../../manipulator.h"
#include "../../simpmod.h"
#include "../../tvutil.h"
#include "../../control.h"
#include "../../ILockedTracks.h"
#include "../../ILockedContainerUpdate.h"
#include "../macros/define_implementations.h"

Classes
class	ParamRef
class	MSPluginClass
class	MSPluginDesc
class	MSPluginPBAccessor
class	MSPlugin
class	MSPluginValueMigrator
class	MSPluginValueMigratorEx
class	MSPluginObject< TYPE >
class	MSObjectXtnd< TYPE, MS_SUPER >
class	MSPluginGeomObject
class	MSGeomObjectXtnd
class	MSPluginHelper
class	MSHelperXtnd
class	MSPluginLight
class	MSLightXtnd
class	MSPluginCamera
class	MSCameraXtnd
class	MSPluginShape
class	MSShapeXtnd
class	MSPluginSimpleObject
class	MSSimpleObjectXtnd
class	MSPluginSimpleSpline
class	MSPluginSimpleManipulator
class	MSSimpleManipulatorXtnd
class	MSPluginModifier
class	MSModifierXtnd
class	MSPluginSimpleMeshMod
class	MSPluginSimpleMod
class	MSSimpleModXtnd
class	MSPluginTexmap
class	MSTexmapXtnd
class	MSPluginMtl
class	MSMtlXtnd
class	MSAutoMParamDlg
class	MSPluginSpecialFX< TYPE >
class	MSSpecialFXXtnd< TYPE, MS_SUPER >
class	MSPluginEffect
class	MSEffectXtnd
class	MSAutoEParamDlg
class	MSPluginAtmos
class	MSAtmosXtnd
class	MSPluginTrackViewUtility
class	PluginClassDefPLCB1
class	PluginClassDefPLCB2

Macros
#define	is_msplugin_class(v)
#define	def_generic(fn, name)
#define	def_visible_generic(fn, name)
#define	def_struct_generic(fn, name)
#define	def_node_generic(fn, name)
#define	def_mapped_generic(fn, name)
#define	use_generic(fn, name)
#define	def_generic_debug_ok(fn, name)
#define	def_visible_generic_debug_ok(fn, name)
#define	def_struct_generic_debug_ok(fn, name)
#define	def_node_generic_debug_ok(fn, name)
#define	def_mapped_generic_debug_ok(fn, name)
#define	def_primitive(fn, name)
#define	def_lazy_primitive(fn, name)
#define	def_visible_lazy_primitive(fn, name)
#define	def_visible_primitive(fn, name)
#define	def_mapped_primitive(fn, name)
#define	def_struct_primitive(fn, _struct, name)
#define	def_primitive_debug_ok(fn, name)
#define	def_visible_primitive_debug_ok(fn, name)
#define	def_mapped_primitive_debug_ok(fn, name)
#define	def_lazy_primitive_debug_ok(fn, name)
#define	def_visible_lazy_primitive_debug_ok(fn, name)
#define	def_struct_primitive_debug_ok(fn, _struct, name)
#define	def_property(p)
#define	def_prop_getter(p)
#define	def_prop_setter(p)
#define	def_property_alias(p, real_p)
#define	def_2_prop_path(p1, p2)
#define	def_2_prop_path_alias(p1, p2, real_p1, real_p2)
#define	def_nested_prop(p1)
#define	def_backpatched_setter(_prop, _superclass)
#define	def_local_prop_alias(p, real_p)
#define	def_time_fn(_fn)
#define	def_name(name)
#define	def_marker(var, str)
#define	_def_num_bin_op(_class, _conv, _op_fn, _op, _member)
#define	_def_bin_op(_class, _conv, _op_fn, _op, _member)
#define	_def_rel_op(_class, _conv, _op_fn, _rel_op, _member)
#define	def_eq_op(_class, comparison_method, _member)
#define	def_ne_op(_class, comparison_method, _member)
#define	_def_num_un_op(_class, _op_fn, _op, _member)
#define	_def_un_op(_class, _op_fn, _op, _member)
#define	def_bin_op(_class, _conv, _op_fn, _op)
#define	def_rel_op(_class, _conv, _op_fn, _rel_op)
#define	def_un_op(_class, _op_fn, _op)
#define	PI_double   (3.14159265358979323846)
#define	TWOPI_double   (6.28318530717958647652)
#define	HALFPI_double   (1.57079632679489661973)
#define	DEG_TO_RAD_double   (PI_double/180.0)
#define	RAD_TO_DEG_double   (180.0/PI_double)
#define	DegToRad_double(deg)
#define	RadToDeg_double(rad)
#define	DegToRad_float(deg)
#define	RadToDeg_float(rad)
#define	def_math_fn(_class, _outclass, _type, _conv, _fn)
#define	def_angle_trig_fn(_class, _outclass, _type, _conv, _fn)
#define	def_float_trig_fn(_class, _outclass, _type, _conv, _fn)
#define	def_math_bin_fn(_class, _outclass, _type, _conv, _fn)
#define	def_angle_trig_bin_fn(_class, _outclass, _type, _conv, _fn)
#define	def_num_prop_accessors(_class, _prop, _member, _type, _conv)
#define	def_prop_accessors(_class, _prop, _member, _type, _conv)
#define	def_fn_prop_accessors(_class, _prop, _getter, _setter)
#define	def_fn_prop_getter(_class, _prop, _getter)
#define	def_fn_prop_setter(_class, _prop, _setter)
#define	def_float_prop_accessors(_class, _prop, _member)
#define	def_int_prop_accessors(_class, _prop, _member)
#define	def_point3_prop_accessors(_class, _prop, _member)
#define	def_angle_prop_accessors(_class, _prop, _member)
#define	def_time_bin_op(_op_fn, _op)
#define	def_time_rel_op(_op_fn, _rel_op)
#define	def_time_un_op(_op_fn, _op)
#define	def_quat_bin_op(_class, _conv, _op_fn, _op)
#define	def_quat_rel_op(_class, _conv, _op_fn, _rel_op)
#define	def_quat_un_op(_class, _op_fn, _op)
#define	def_new_quat_fn(_fn, _arg_count, _call)
#define	def_mut_quat_fn(_fn, _arg_count, _call)
#define	def_new_mat_fn(_fn, _arg_count, _call)
#define	def_mut_mat_fn(_fn, _arg_count, _call)
#define	def_mat_primitive(_fn, _arg_count, _call)
#define	def_mat_bin_op(_class, _conv, _op_fn, _op)
#define	def_mat_rel_op(_class, _conv, _op_fn, _rel_op)
#define	def_mat_un_op(_class, _op_fn, _op)
#define	def_bool_node_fns(name, getter, setter)
#define	def_bool_node_getter(name, getter)
#define	def_ulong_node_fns(name, getter, setter)
#define	def_color_node_fns(name, getter, setter)
#define	def_bool_node_noredraw_fns(name, getter, setter)
#define	def_ulong_node_noredraw_fns(name, getter, setter)
#define	def_color_node_noredraw_fns(name, getter, setter)
#define	MPC_TEMPORARY   (1<<0)
#define	MPC_REDEFINITION   (1<<1)
#define	MPC_MS_CREATING   (1<<2)
#define	MPC_MS_WAS_CREATING   (1<<3)
#define	MPC_EDITING_IN_CP   (1<<4)
#define	MPC_EDITING_IN_MTLEDT   (1<<5)
#define	MPC_EDITING_IN_EFX   (1<<6)
#define	MPC_REPLACE_UI   (1<<7)
#define	MPC_INVISIBLE   (1<<8)
#define	MPC_SILENTERRORS   (1<<9)
#define	MPC_MAX_CREATING   (1<<10)
#define	MPC_ABORT_CREATE   (1<<11)
#define	MPC_LEVEL_6   (1<<12)
#define	MPC_IS_MANIP   (1<<13)
#define	MPC_ALTERNATE   (1<<14)
#define	MPC_CAD_FILESAVE   (1<<15)
#define	MPC_PROMOTE_DEL_PROPS   (1<<16)
#define	MPC_USE_PB_VALIDITY   (1<<17)
#define	MPC_CAD_FILELOAD_LOADDEFDATA   (1<<18)
#define	MPC_CAD_NO_ATTRIBID   (1<<19)
#define	MPC_UNIQUE   (1<<20)
#define	key_parm(_key)
#define	bool_key_parm(_key, var, def)
#define	MSP_LOADING   0x0001
#define	MSP_DISABLED   0x0002
#define	MSP_DELETED   0x0004
#define	MSPLUGIN_CHUNK   0x0010

Typedefs
using	creator_fn = RefTargetHandle (*)(MSPluginClass* pic, BOOL loading)

Enumerations
enum	{ pl_this , pl_version , pl_loading , pl_delegate }
enum	{ pl_extent = pl_delegate + 1 , pl_min , pl_max , pl_center }
enum	{   pl_mesh2 = pl_center + 1 , pl_transform , pl_inverseTransform , pl_bbox ,   pl_owningNode }
enum	{ pl_mesh = pl_delegate + 1 }
enum	{ pl_beziershape = pl_delegate + 1 }
enum	{   pl_target = pl_delegate + 1 , pl_node , pl_gizmoDontDisplay , pl_gizmoDontHitTest ,   pl_gizmoScaleToViewport , pl_gizmoUseScreenSpace , pl_gizmoActiveViewportOnly , pl_gizmoUseRelativeScreenSpace ,   pl_gizmoApplyUIScaling }
enum	{   pl_isLeaf = pl_delegate + 1 , pl_isKeyable , pl_method , pl_parentTransform ,   pl_usesParentTransform }

Functions
Value *	_get_key_param (Array *keys, Value *key_name)

Variables
PluginClassDefPLCB1	thePluginClassDefPLCB1
PluginClassDefPLCB2	thePluginClassDefPLCB2

Macro Definition Documentation

is_msplugin_class

#define is_msplugin_class

(

v

)

Value:

((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(MSPluginClass))

def_generic

#define def_generic	(		fn,
			name )

Value:

    Value* fn##_vf(Value** arglist, int arg_count)

def_visible_generic

#define def_visible_generic	(		fn,
			name )

Value:

def_generic(fn, name)

def_struct_generic

#define def_struct_generic	(		fn,
			name )

Value:

def_generic(fn, name)

def_node_generic

#define def_node_generic	(		fn,
			name )

Value:

def_generic(fn, name)

def_mapped_generic

#define def_mapped_generic	(		fn,
			name )

Value:

def_generic(fn, name)

use_generic

#define use_generic	(		fn,
			name )

Value:

def_generic(fn, name)

def_generic_debug_ok

#define def_generic_debug_ok	(		fn,
			name )

Value:

def_generic(fn, name)

def_visible_generic_debug_ok

#define def_visible_generic_debug_ok	(		fn,
			name )

Value:

def_generic(fn, name)

def_struct_generic_debug_ok

#define def_struct_generic_debug_ok	(		fn,
			name )

Value:

def_generic(fn, name)

def_node_generic_debug_ok

#define def_node_generic_debug_ok	(		fn,
			name )

Value:

def_generic(fn, name)

def_mapped_generic_debug_ok

#define def_mapped_generic_debug_ok	(		fn,
			name )

Value:

def_generic(fn, name)

def_primitive

#define def_primitive	(		fn,
			name )

def_lazy_primitive

#define def_lazy_primitive	(		fn,
			name )

Value:

def_primitive(fn, name)

def_visible_lazy_primitive

#define def_visible_lazy_primitive	(		fn,
			name )

Value:

def_primitive(fn, name)

def_visible_primitive

#define def_visible_primitive	(		fn,
			name )

Value:

def_primitive(fn, name)

def_mapped_primitive

#define def_mapped_primitive	(		fn,
			name )

Value:

def_primitive(fn, name)

def_struct_primitive

#define def_struct_primitive	(		fn,
			_struct,
			name )

Value:

def_primitive(fn, name)

def_primitive_debug_ok

#define def_primitive_debug_ok	(		fn,
			name )

def_visible_primitive_debug_ok

#define def_visible_primitive_debug_ok	(		fn,
			name )

def_mapped_primitive_debug_ok

#define def_mapped_primitive_debug_ok	(		fn,
			name )

def_lazy_primitive_debug_ok

#define def_lazy_primitive_debug_ok	(		fn,
			name )

def_visible_lazy_primitive_debug_ok

#define def_visible_lazy_primitive_debug_ok	(		fn,
			name )

def_struct_primitive_debug_ok

#define def_struct_primitive_debug_ok	(		fn,
			_struct,
			name )

def_property

#define def_property

(

p

)

Value:

            Value* get_##p(Value** arg_list, int count);  \
            Value* set_##p(Value** arg_list, int count)

def_prop_getter

#define def_prop_getter

(

p

)

Value:

            Value* get_##p(Value** arg_list, int count)

def_prop_setter

#define def_prop_setter

(

p

)

Value:

            Value* set_##p(Value** arg_list, int count)

def_property_alias

#define def_property_alias	(		p,
			real_p )

def_2_prop_path

#define def_2_prop_path	(		p1,
			p2 )

Value:

            Value* get_##p1##_##p2(Value** arg_list, int count);  \
            Value* set_##p1##_##p2(Value** arg_list, int count)

def_2_prop_path_alias

#define def_2_prop_path_alias	(		p1,
			p2,
			real_p1,
			real_p2 )

def_nested_prop

#define def_nested_prop

(

p1

)

Value:

            Value* get_nested_##p1(Value** arg_list, int count);  \
            Value* set_nested_##p1(Value** arg_list, int count)

def_backpatched_setter

#define def_backpatched_setter	(		_prop,
			_superclass )

Value:

            Value*                                                 \
            set_##_prop(Value** arg_list, int count)               \
            {                                                       \
                _superclass::set_##_prop(arg_list, count);          \
                back_patch();                                       \
                return arg_list[0];                                 \
            };

def_local_prop_alias

#define def_local_prop_alias	(		p,
			real_p )

Value:

            Value* get_##p(Value** arg_list, int count) { return get_##real_p(arg_list, count); }   \
            Value* set_##p(Value** arg_list, int count) { return set_##real_p(arg_list, count); }   \

def_time_fn

#define def_time_fn

(

_fn

)

Value:

    Value* _fn##_vf(Value** arglist, int arg_count)

def_name

#define def_name

(

name

)

Value:

n_##name = Name::intern(_M(#name));

def_marker

#define def_marker	(		var,
			str )

_def_num_bin_op

#define _def_num_bin_op	(		_class,
			_conv,
			_op_fn,
			_op,
			_member )

Value:

    Value*                                                     \
    _class::_op_fn##_vf(Value** arg_list, int count)           \
    {                                                           \
        check_arg_count(_fn, 2, count+1);                       \
        one_value_local(widened);                               \
        Value *arg, *result;                                   \
        arg = arg_list[0];                                      \
        if (tag != arg->tag && ((vl.widened = widen_to(arg, arg_list)) != NULL)) \
            result = vl.widened->_op_fn##_vf(arg_list, 1);      \
        else                                                    \
            result = _class::intern(_member _op (arg_list[0])->_conv()); \
        return_value(result);                                   \
    }

_def_bin_op

#define _def_bin_op	(		_class,
			_conv,
			_op_fn,
			_op,
			_member )

Value:

    Value*                                                     \
    _class::_op_fn##_vf(Value** arg_list, int count)           \
    {                                                           \
        check_arg_count(_op_fn, 2, count + 1);                  \
        one_value_local(widened);                               \
        Value *arg, *result;                                   \
        arg = arg_list[0];                                      \
        if (tag != arg->tag && ((vl.widened = widen_to(arg, arg_list)) != NULL)) \
            result = vl.widened->_op_fn##_vf(arg_list, 1);      \
        else                                                    \
            result = new _class (_member _op (arg_list[0])->_conv()); \
        return_value(result);                                   \
    }

_def_rel_op

#define _def_rel_op	(		_class,
			_conv,
			_op_fn,
			_rel_op,
			_member )

Value:

    Value*                                                     \
    _class::_op_fn##_vf(Value** arg_list, int count)           \
    {                                                           \
        check_arg_count(_op_fn, 2, count + 1);                  \
        one_value_local(widened);                               \
        Value *arg, *result;                                   \
        arg = arg_list[0];                                      \
        if (tag != arg->tag && ((vl.widened = widen_to(arg, arg_list)) != NULL)) \
            result = vl.widened->_op_fn##_vf(arg_list, 1);      \
        else                                                    \
        {                                                       \
            if (comparable(arg))                                \
                result = (_member _rel_op arg->_conv()) ?       \
                            &true_value : &false_value;            \
            else                                                \
                throw IncompatibleTypes(this, arg);                \
        }                                                       \
        return_value(result);                                   \
    }

def_eq_op

#define def_eq_op	(		_class,
			comparison_method,
			_member )

Value:

    Value*                                                     \
    _class::eq_vf(Value** arg_list, int count)                 \
    {                                                           \
        check_arg_count(eq, 2, count + 1);                      \
        Value* cmpnd = arg_list[0];                                \
        Value* result;                                         \
        bool specialCaseCompareResult = false;              \
        if (special_case_compare(cmpnd,specialCaseCompareResult))   \
        {                                                                           \
            result = specialCaseCompareResult ? &true_value : &false_value;    \
        }                                                                       \
        else if (comparable(cmpnd))                                 \
            result = (_member == cmpnd->comparison_method()) ?  \
                &true_value : &false_value;                        \
        else                                                    \
            result = &false_value;                               \
        return result;                                          \
    }

def_ne_op

#define def_ne_op	(		_class,
			comparison_method,
			_member )

Value:

    Value*                                                     \
    _class::ne_vf(Value** arg_list, int count)                 \
    {                                                           \
        check_arg_count(ne, 2, count + 1);                      \
        Value* cmpnd = arg_list[0];                                \
        Value* result;                                         \
        bool specialCaseCompareResult = false;              \
        if (special_case_compare(cmpnd,specialCaseCompareResult))   \
        {                                                                           \
            result = specialCaseCompareResult ? &false_value : &true_value;    \
        }                                                                       \
        else if (comparable(cmpnd))                                 \
            result = (_member == cmpnd->comparison_method()) ?  \
                        &false_value : &true_value;                \
        else                                                    \
            result = &true_value;                             \
        return result;                                          \
    }

_def_num_un_op

#define _def_num_un_op	(		_class,
			_op_fn,
			_op,
			_member )

Value:

    Value*                                                     \
    _class::_op_fn##_vf(Value** arg_list, int count)           \
    {                                                           \
        check_arg_count(_op_fn, 1, count + 1);                  \
        return_value (_class::intern(_op _member));             \
    }

_def_un_op

#define _def_un_op	(		_class,
			_op_fn,
			_op,
			_member )

Value:

    Value*                                                     \
    _class::_op_fn##_vf(Value** arg_list, int count)           \
    {                                                           \
        check_arg_count(_op_fn, 1, count + 1);                  \
        return new _class (_op _member);                        \
    }

def_bin_op

#define def_bin_op	(		_class,
			_conv,
			_op_fn,
			_op )

Value:

            _def_num_bin_op(_class, _conv, _op_fn, _op, value)

def_rel_op

#define def_rel_op	(		_class,
			_conv,
			_op_fn,
			_rel_op )

Value:

            _def_rel_op(_class, _conv, _op_fn, _rel_op, value)

def_un_op

#define def_un_op	(		_class,
			_op_fn,
			_op )

Value:

            _def_num_un_op(_class, _op_fn, _op, value)

PI_double

#define PI_double   (3.14159265358979323846)

TWOPI_double

#define TWOPI_double   (6.28318530717958647652)

HALFPI_double

#define HALFPI_double   (1.57079632679489661973)

DEG_TO_RAD_double

#define DEG_TO_RAD_double   (PI_double/180.0)

RAD_TO_DEG_double

#define RAD_TO_DEG_double   (180.0/PI_double)

DegToRad_double

#define DegToRad_double

(

deg

)

Value:

(((double)deg)*DEG_TO_RAD_double)

RadToDeg_double

#define RadToDeg_double

(

rad

)

Value:

(((double)rad)*RAD_TO_DEG_double)

DegToRad_float

#define DegToRad_float

(

deg

)

Value:

DegToRad(deg)

RadToDeg_float

#define RadToDeg_float

(

rad

)

Value:

RadToDeg(rad)

def_math_fn

#define def_math_fn	(		_class,
			_outclass,
			_type,
			_conv,
			_fn )

Value:

    Value*                                             \
    _class::_fn##_vf(Value** arg_list, int count)      \
    {                                                   \
        check_arg_count(_fn, 1, count+1);               \
        return_value (_outclass::intern((_type)_fn(_conv())));      \
    }

def_angle_trig_fn

#define def_angle_trig_fn	(		_class,
			_outclass,
			_type,
			_conv,
			_fn )

Value:

    Value*                                                         \
    _class::_fn##_vf(Value** arg_list, int count)                  \
    {                                                               \
        check_arg_count(_fn, 1, count+1);                           \
        return_value (_outclass::intern(RadToDeg_##_type((_type)_fn(_conv())))); \
    }

def_float_trig_fn

#define def_float_trig_fn	(		_class,
			_outclass,
			_type,
			_conv,
			_fn )

Value:

    Value*                                                         \
    _class::_fn##_vf(Value** arg_list, int count)                  \
    {                                                               \
        check_arg_count(_fn, 1, count+1);                           \
        return_value (_outclass::intern((_type)_fn(DegToRad_##_type(_conv())))); \
    }

def_math_bin_fn

#define def_math_bin_fn	(		_class,
			_outclass,
			_type,
			_conv,
			_fn )

Value:

    Value*                                                     \
    _class::_fn##_vf(Value** arg_list, int count)              \
    {                                                           \
        check_arg_count(_fn, 2, count+1);                       \
        one_value_local(widened);                               \
        Value *arg, *result;                                   \
        arg = arg_list[0];                                      \
        if (tag != arg->tag && ((vl.widened = widen_to(arg, arg_list)) != NULL)) \
            result = vl.widened->_fn##_vf(arg_list, 1);     \
        else                                                    \
            result = _outclass::intern((_type)_fn(_conv(), arg_list[0]->_conv())); \
        return_value(result);                                   \
    }

def_angle_trig_bin_fn

#define def_angle_trig_bin_fn	(		_class,
			_outclass,
			_type,
			_conv,
			_fn )

Value:

    Value*                                                         \
    _class::_fn##_vf(Value** arg_list, int count)                  \
    {                                                               \
        check_arg_count(_fn, 2, count+1);                           \
        return_value (_outclass::intern(RadToDeg_##_type((_type)_fn(_conv(),    \
                              arg_list[0]->_conv()))));             \
    }

def_num_prop_accessors

#define def_num_prop_accessors	(		_class,
			_prop,
			_member,
			_type,
			_conv )

Value:

    Value*                                                         \
    _class::get_##_prop(Value** arg_list, int count)               \
    {                                                               \
        return_value (_type::intern(_member));                              \
    }                                                               \
    Value*                                                         \
    _class::set_##_prop(Value** arg_list, int count)               \
    {                                                               \
        Value*  val = arg_list[0];                                 \
        _member = val->_conv();                                     \
        return val;                                                 \
    }

def_prop_accessors

#define def_prop_accessors	(		_class,
			_prop,
			_member,
			_type,
			_conv )

Value:

    Value*                                                         \
    _class::get_##_prop(Value** arg_list, int count)               \
    {                                                               \
        return new _type (_member);                                 \
    }                                                               \
    Value*                                                         \
    _class::set_##_prop(Value** arg_list, int count)               \
    {                                                               \
        Value*  val = arg_list[0];                                 \
        _member = val->_conv();                                     \
        return val;                                                 \
    }

def_fn_prop_accessors

#define def_fn_prop_accessors	(		_class,
			_prop,
			_getter,
			_setter )

Value:

    Value*                                                         \
    _class::get_##_prop(Value** arg_list, int count)               \
    {                                                               \
        return _getter;                                             \
    }                                                               \
    Value*                                                         \
    _class::set_##_prop(Value** arg_list, int count)               \
    {                                                               \
        Value*  val = arg_list[0];                                 \
        _setter;                                                    \
        return val;                                                 \
    }

def_fn_prop_getter

#define def_fn_prop_getter	(		_class,
			_prop,
			_getter )

Value:

    Value*                                                         \
    _class::get_##_prop(Value** arg_list, int count)               \
    {                                                               \
        return _getter;                                             \
    }

def_fn_prop_setter

#define def_fn_prop_setter	(		_class,
			_prop,
			_setter )

Value:

    Value*                                                         \
    _class::set_##_prop(Value** arg_list, int count)               \
    {                                                               \
        Value*  val = arg_list[0];                                 \
        _setter;                                                    \
        return val;                                                 \
    }

def_float_prop_accessors

#define def_float_prop_accessors	(		_class,
			_prop,
			_member )

Value:

            def_num_prop_accessors(_class, _prop, _member, Float, to_float)

def_int_prop_accessors

#define def_int_prop_accessors	(		_class,
			_prop,
			_member )

Value:

            def_num_prop_accessors(_class, _prop, _member, Integer, to_int)

def_point3_prop_accessors

#define def_point3_prop_accessors	(		_class,
			_prop,
			_member )

Value:

            def_fn_prop_accessors(_class, _prop, new Point3Value (_member), _member = val->to_point3())

def_angle_prop_accessors

#define def_angle_prop_accessors	(		_class,
			_prop,
			_member )

Value:

            def_fn_prop_accessors(_class, _prop, Float::intern(RadToDeg(_member)), _member = DegToRad(val->to_float()))

def_time_bin_op

#define def_time_bin_op	(		_op_fn,
			_op )

Value:

            _def_bin_op(MSTime, to_timevalue, _op_fn, _op, time)

def_time_rel_op

#define def_time_rel_op	(		_op_fn,
			_rel_op )

Value:

            _def_rel_op(MSTime, to_timevalue, _op_fn, _rel_op, time)

def_time_un_op

#define def_time_un_op	(		_op_fn,
			_op )

Value:

            _def_un_op(MSTime, _op_fn, _op, time)

def_quat_bin_op

#define def_quat_bin_op	(		_class,
			_conv,
			_op_fn,
			_op )

Value:

            _def_bin_op(_class, _conv, _op_fn, _op, q)

def_quat_rel_op

#define def_quat_rel_op	(		_class,
			_conv,
			_op_fn,
			_rel_op )

Value:

            _def_rel_op(_class, _conv, _op_fn, _rel_op, q)

def_quat_un_op

#define def_quat_un_op	(		_class,
			_op_fn,
			_op )

Value:

            _def_un_op(_class, _op_fn, _op, q)

def_new_quat_fn

#define def_new_quat_fn	(		_fn,
			_arg_count,
			_call )

Value:

    Value*                                                 \
    QuatValue::_fn##_vf(Value** arg_list, int count)       \
    {                                                       \
        check_arg_count(_fn, _arg_count, count + 1);        \
        return new QuatValue (_call);                      \
    }

def_mut_quat_fn

#define def_mut_quat_fn	(		_fn,
			_arg_count,
			_call )

Value:

    Value*                                                 \
    QuatValue::_fn##_vf(Value** arg_list, int count)       \
    {                                                       \
        check_arg_count(_fn, _arg_count, count + 1);        \
        _call;                                              \
        return this;                                        \
    }

def_new_mat_fn

#define def_new_mat_fn	(		_fn,
			_arg_count,
			_call )

Value:

    Value*                                                 \
    Matrix3Value::_fn##_vf(Value** arg_list, int count)        \
    {                                                       \
        check_arg_count(_fn, _arg_count, count + 1);        \
        return new Matrix3Value (_call);                        \
    }

def_mut_mat_fn

#define def_mut_mat_fn	(		_fn,
			_arg_count,
			_call )

Value:

    Value*                                                 \
    Matrix3Value::_fn##_vf(Value** arg_list, int count)        \
    {                                                       \
        check_arg_count(_fn, _arg_count, count + 1);        \
        _call;                                              \
        return this;                                        \
    }

def_mat_primitive

#define def_mat_primitive	(		_fn,
			_arg_count,
			_call )

Value:

    Value*                                                 \
    _fn##_cf(Value** arg_list, int count)                  \
    {                                                       \
        check_arg_count(_fn, _arg_count, count);            \
        return new Matrix3Value (_call);                    \
    }

def_mat_bin_op

#define def_mat_bin_op	(		_class,
			_conv,
			_op_fn,
			_op )

Value:

            _def_bin_op(_class, _conv, _op_fn, _op, m)

def_mat_rel_op

#define def_mat_rel_op	(		_class,
			_conv,
			_op_fn,
			_rel_op )

Value:

            _def_rel_op(_class, _conv, _op_fn, _rel_op, m)

def_mat_un_op

#define def_mat_un_op	(		_class,
			_op_fn,
			_op )

Value:

            _def_un_op(_class, _op_fn, _op, m)

def_bool_node_fns

#define def_bool_node_fns	(		name,
			getter,
			setter )

Value:

    Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid)       \
    {                                                                                           \
        return ((INode*)obj)->getter() ? &true_value : &false_value;                          \
    }                                                                                           \
    void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val)          \
    {                                                                                           \
        ((INode*)obj)->setter(val->to_bool());                                                 \
        InvalidateNodeRect((INode*)obj,t);                                                     \
    }

def_bool_node_getter

#define def_bool_node_getter	(		name,
			getter )

Value:

    Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid)       \
    {                                                                                           \
        return ((INode*)obj)->getter() ? &true_value : &false_value;                          \
    }                                                                                           \
    void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val)          \
    {                                                                                           \
        throw RuntimeError (_M("Property not settable: "), _M(#name));                              \
    }

def_ulong_node_fns

#define def_ulong_node_fns	(		name,
			getter,
			setter )

Value:

    Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid)       \
    {                                                                                           \
        return_value (Integer::intern((int)((INode*)obj)->getter()));                                   \
    }                                                                                           \
    void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val)          \
    {                                                                                           \
        ((INode*)obj)->setter((ULONG)val->to_int());                                           \
        InvalidateNodeRect((INode*)obj,t);                                                     \
    }

def_color_node_fns

#define def_color_node_fns	(		name,
			getter,
			setter )

Value:

    Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid)       \
    {                                                                                           \
        DWORD rgb = ((INode*)obj)->getter();                                                   \
        return_value (ColorValue::intern(GetRValue(rgb) / 255.0f, GetGValue(rgb) / 255.0f, GetBValue(rgb) / 255.0f)); \
    }                                                                                           \
    void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val)          \
    {                                                                                           \
        AColor c;                                                                               \
        c = val->to_acolor();                                                                   \
        ((INode*)obj)->setter(RGB((BYTE)(c.r * 255), (BYTE)(c.g * 255), (BYTE)(c.b * 255)));   \
        InvalidateNodeRect((INode*)obj,t);                                                     \
    }

def_bool_node_noredraw_fns

#define def_bool_node_noredraw_fns	(		name,
			getter,
			setter )

Value:

    Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid)       \
    {                                                                                           \
        return ((INode*)obj)->getter() ? &true_value : &false_value;                          \
    }                                                                                           \
    void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val)          \
    {                                                                                           \
        ((INode*)obj)->setter(val->to_bool());                                                 \
    }

def_ulong_node_noredraw_fns

#define def_ulong_node_noredraw_fns	(		name,
			getter,
			setter )

Value:

    Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid)       \
    {                                                                                           \
        return_value (Integer::intern((int)((INode*)obj)->getter()));                                   \
    }                                                                                           \
    void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val)          \
    {                                                                                           \
        ((INode*)obj)->setter((ULONG)val->to_int());                                           \
    }

def_color_node_noredraw_fns

#define def_color_node_noredraw_fns	(		name,
			getter,
			setter )

Value:

    Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid)       \
    {                                                                                           \
        DWORD rgb = ((INode*)obj)->getter();                                                   \
        return_value (ColorValue::intern(GetRValue(rgb) / 255.0f, GetGValue(rgb) / 255.0f, GetBValue(rgb) / 255.0f)); \
    }                                                                                           \
    void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val)          \
    {                                                                                           \
        AColor c;                                                                               \
        c = val->to_acolor();                                                                   \
        ((INode*)obj)->setter(RGB((BYTE)(c.r * 255), (BYTE)(c.g * 255), (BYTE)(c.b * 255)));   \
    }

MPC_TEMPORARY

#define MPC_TEMPORARY   (1<<0)

MPC_REDEFINITION

#define MPC_REDEFINITION   (1<<1)

MPC_MS_CREATING

#define MPC_MS_CREATING   (1<<2)

MPC_MS_WAS_CREATING

#define MPC_MS_WAS_CREATING   (1<<3)

MPC_EDITING_IN_CP

#define MPC_EDITING_IN_CP   (1<<4)

MPC_EDITING_IN_MTLEDT

#define MPC_EDITING_IN_MTLEDT   (1<<5)

MPC_EDITING_IN_EFX

#define MPC_EDITING_IN_EFX   (1<<6)

MPC_REPLACE_UI

#define MPC_REPLACE_UI   (1<<7)

MPC_INVISIBLE

#define MPC_INVISIBLE   (1<<8)

MPC_SILENTERRORS

#define MPC_SILENTERRORS   (1<<9)

MPC_MAX_CREATING

#define MPC_MAX_CREATING   (1<<10)

MPC_ABORT_CREATE

#define MPC_ABORT_CREATE   (1<<11)

MPC_LEVEL_6

#define MPC_LEVEL_6   (1<<12)

MPC_IS_MANIP

#define MPC_IS_MANIP   (1<<13)

MPC_ALTERNATE

#define MPC_ALTERNATE   (1<<14)

MPC_CAD_FILESAVE

#define MPC_CAD_FILESAVE   (1<<15)

MPC_PROMOTE_DEL_PROPS

#define MPC_PROMOTE_DEL_PROPS   (1<<16)

MPC_USE_PB_VALIDITY

#define MPC_USE_PB_VALIDITY   (1<<17)

MPC_CAD_FILELOAD_LOADDEFDATA

#define MPC_CAD_FILELOAD_LOADDEFDATA   (1<<18)

MPC_CAD_NO_ATTRIBID

#define MPC_CAD_NO_ATTRIBID   (1<<19)

MPC_UNIQUE

#define MPC_UNIQUE   (1<<20)

key_parm

#define key_parm

(

_key

)

Value:

_get_key_param(keys, n_##_key)

bool_key_parm

#define bool_key_parm	(		_key,
			var,
			def )

Value:

((var = _get_key_param(keys, n_##_key)) == &unsupplied ? def : var->to_bool())

MSP_LOADING

#define MSP_LOADING   0x0001

MSP_DISABLED

#define MSP_DISABLED   0x0002

MSP_DELETED

#define MSP_DELETED   0x0004

MSPLUGIN_CHUNK

#define MSPLUGIN_CHUNK   0x0010

Typedef Documentation

creator_fn

using creator_fn = RefTargetHandle (*)(MSPluginClass* pic, BOOL loading)

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
pl_this
pl_version
pl_loading
pl_delegate

     { 
    pl_this, pl_version, pl_loading, pl_delegate          // common
};

anonymous enum

anonymous enum

Enumerator
pl_extent
pl_min
pl_max
pl_center

     { 
    pl_extent = pl_delegate + 1, pl_min, pl_max, pl_center   // for SimpleMods
};

anonymous enum

anonymous enum

Enumerator
pl_mesh2
pl_transform
pl_inverseTransform
pl_bbox
pl_owningNode

     { 
    pl_mesh2 = pl_center + 1, pl_transform, pl_inverseTransform, pl_bbox, pl_owningNode,    // for SimpleMeshMods
};

anonymous enum

anonymous enum

Enumerator
pl_mesh

     { 
    pl_mesh = pl_delegate + 1                             // for SimpleObjects 
};

anonymous enum

anonymous enum

Enumerator
pl_beziershape

     { 
    pl_beziershape = pl_delegate + 1                           // for SimpleSplines 
};

anonymous enum

anonymous enum

Enumerator
pl_target
pl_node
pl_gizmoDontDisplay
pl_gizmoDontHitTest
pl_gizmoScaleToViewport
pl_gizmoUseScreenSpace
pl_gizmoActiveViewportOnly
pl_gizmoUseRelativeScreenSpace
pl_gizmoApplyUIScaling

     { 
    pl_target = pl_delegate + 1, pl_node,                // for SimpleManipulators 
    pl_gizmoDontDisplay, pl_gizmoDontHitTest, pl_gizmoScaleToViewport,
    pl_gizmoUseScreenSpace, pl_gizmoActiveViewportOnly, pl_gizmoUseRelativeScreenSpace, pl_gizmoApplyUIScaling,
};

anonymous enum

anonymous enum

Enumerator
pl_isLeaf
pl_isKeyable
pl_method
pl_parentTransform
pl_usesParentTransform

     { 
    pl_isLeaf = pl_delegate + 1,                            // for scripted controller plugins 
    pl_isKeyable,
    pl_method,
    pl_parentTransform,                                       // these 2 are actively used only for P/R/S/Transform controllers
    pl_usesParentTransform
};

Function Documentation

_get_key_param()

Value * _get_key_param ( Array * keys, Value * key_name )

extern

Variable Documentation

thePluginClassDefPLCB1

PluginClassDefPLCB1 thePluginClassDefPLCB1

extern

thePluginClassDefPLCB2

PluginClassDefPLCB2 thePluginClassDefPLCB2

extern