3ds Max C++ API Reference
Loading...
Searching...
No Matches
Macros
define_implementations.h File Reference

Macros

#define def_generic(fn, name)    Value* fn##_vf(Value** arglist, int arg_count)
 
#define def_visible_generic(fn, name)   def_generic(fn, name)
 
#define def_struct_generic(fn, name)   def_generic(fn, name)
 
#define def_node_generic(fn, name)   def_generic(fn, name)
 
#define def_mapped_generic(fn, name)   def_generic(fn, name)
 
#define use_generic(fn, name)   def_generic(fn, name)
 
#define def_generic_debug_ok(fn, name)   def_generic(fn, name)
 
#define def_visible_generic_debug_ok(fn, name)   def_generic(fn, name)
 
#define def_struct_generic_debug_ok(fn, name)   def_generic(fn, name)
 
#define def_node_generic_debug_ok(fn, name)   def_generic(fn, name)
 
#define def_mapped_generic_debug_ok(fn, name)   def_generic(fn, name)
 
#define def_primitive(fn, name)
 
#define def_lazy_primitive(fn, name)   def_primitive(fn, name)
 
#define def_visible_lazy_primitive(fn, name)   def_primitive(fn, name)
 
#define def_visible_primitive(fn, name)   def_primitive(fn, name)
 
#define def_mapped_primitive(fn, name)   def_primitive(fn, name)
 
#define def_struct_primitive(fn, _struct, name)   def_primitive(fn, 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)    Value* get_##p(Value** arg_list, int count)
 
#define def_prop_setter(p)    Value* set_##p(Value** arg_list, int count)
 
#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)    Value* _fn##_vf(Value** arglist, int arg_count)
 
#define def_name(name)   n_##name = Name::intern(_M(#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)    _def_num_bin_op(_class, _conv, _op_fn, _op, value)
 
#define def_rel_op(_class, _conv, _op_fn, _rel_op)    _def_rel_op(_class, _conv, _op_fn, _rel_op, value)
 
#define def_un_op(_class, _op_fn, _op)    _def_num_un_op(_class, _op_fn, _op, value)
 
#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)   (((double)deg)*DEG_TO_RAD_double)
 
#define RadToDeg_double(rad)   (((double)rad)*RAD_TO_DEG_double)
 
#define DegToRad_float(deg)   DegToRad(deg)
 
#define RadToDeg_float(rad)   RadToDeg(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)    def_num_prop_accessors(_class, _prop, _member, Float, to_float)
 
#define def_int_prop_accessors(_class, _prop, _member)    def_num_prop_accessors(_class, _prop, _member, Integer, to_int)
 
#define def_point3_prop_accessors(_class, _prop, _member)    def_fn_prop_accessors(_class, _prop, new Point3Value (_member), _member = val->to_point3())
 
#define def_angle_prop_accessors(_class, _prop, _member)    def_fn_prop_accessors(_class, _prop, Float::intern(RadToDeg(_member)), _member = DegToRad(val->to_float()))
 
#define def_time_bin_op(_op_fn, _op)    _def_bin_op(MSTime, to_timevalue, _op_fn, _op, time)
 
#define def_time_rel_op(_op_fn, _rel_op)    _def_rel_op(MSTime, to_timevalue, _op_fn, _rel_op, time)
 
#define def_time_un_op(_op_fn, _op)    _def_un_op(MSTime, _op_fn, _op, time)
 
#define def_quat_bin_op(_class, _conv, _op_fn, _op)    _def_bin_op(_class, _conv, _op_fn, _op, q)
 
#define def_quat_rel_op(_class, _conv, _op_fn, _rel_op)    _def_rel_op(_class, _conv, _op_fn, _rel_op, q)
 
#define def_quat_un_op(_class, _op_fn, _op)    _def_un_op(_class, _op_fn, _op, q)
 
#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)    _def_bin_op(_class, _conv, _op_fn, _op, m)
 
#define def_mat_rel_op(_class, _conv, _op_fn, _rel_op)    _def_rel_op(_class, _conv, _op_fn, _rel_op, m)
 
#define def_mat_un_op(_class, _op_fn, _op)    _def_un_op(_class, _op_fn, _op, m)
 
#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)
 

Macro Definition Documentation

◆ def_generic

#define def_generic (   fn,
  name 
)     Value* fn##_vf(Value** arglist, int arg_count)

◆ def_visible_generic

#define def_visible_generic (   fn,
  name 
)    def_generic(fn, name)

◆ def_struct_generic

#define def_struct_generic (   fn,
  name 
)    def_generic(fn, name)

◆ def_node_generic

#define def_node_generic (   fn,
  name 
)    def_generic(fn, name)

◆ def_mapped_generic

#define def_mapped_generic (   fn,
  name 
)    def_generic(fn, name)

◆ use_generic

#define use_generic (   fn,
  name 
)    def_generic(fn, name)

◆ def_generic_debug_ok

#define def_generic_debug_ok (   fn,
  name 
)    def_generic(fn, name)

◆ def_visible_generic_debug_ok

#define def_visible_generic_debug_ok (   fn,
  name 
)    def_generic(fn, name)

◆ def_struct_generic_debug_ok

#define def_struct_generic_debug_ok (   fn,
  name 
)    def_generic(fn, name)

◆ def_node_generic_debug_ok

#define def_node_generic_debug_ok (   fn,
  name 
)    def_generic(fn, name)

◆ def_mapped_generic_debug_ok

#define def_mapped_generic_debug_ok (   fn,
  name 
)    def_generic(fn, name)

◆ def_primitive

#define def_primitive (   fn,
  name 
)

◆ def_lazy_primitive

#define def_lazy_primitive (   fn,
  name 
)    def_primitive(fn, name)

◆ def_visible_lazy_primitive

#define def_visible_lazy_primitive (   fn,
  name 
)    def_primitive(fn, name)

◆ def_visible_primitive

#define def_visible_primitive (   fn,
  name 
)    def_primitive(fn, name)

◆ def_mapped_primitive

#define def_mapped_primitive (   fn,
  name 
)    def_primitive(fn, name)

◆ def_struct_primitive

#define def_struct_primitive (   fn,
  _struct,
  name 
)    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)
Value
Definition: value.h:107

◆ def_prop_getter

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

◆ def_prop_setter

#define def_prop_setter (   p)     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* _fn##_vf(Value** arglist, int arg_count)

◆ def_name

#define def_name (   name)    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); \
}
NULL
#define NULL
Definition: autoptr.h:18
Value::tag
ValueMetaClass * tag
Definition: value.h:114

◆ _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); \
}
IncompatibleTypes
Definition: exceptions.h:304
false_value
ScripterExport Boolean false_value
true_value
ScripterExport Boolean true_value

◆ 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 
)     _def_num_bin_op(_class, _conv, _op_fn, _op, value)

◆ def_rel_op

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

◆ def_un_op

#define def_un_op (   _class,
  _op_fn,
  _op 
)     _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)    (((double)deg)*DEG_TO_RAD_double)

◆ RadToDeg_double

#define RadToDeg_double (   rad)    (((double)rad)*RAD_TO_DEG_double)

◆ DegToRad_float

#define DegToRad_float (   deg)    DegToRad(deg)

◆ RadToDeg_float

#define RadToDeg_float (   rad)    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 
)     def_num_prop_accessors(_class, _prop, _member, Float, to_float)

◆ def_int_prop_accessors

#define def_int_prop_accessors (   _class,
  _prop,
  _member 
)     def_num_prop_accessors(_class, _prop, _member, Integer, to_int)

◆ def_point3_prop_accessors

#define def_point3_prop_accessors (   _class,
  _prop,
  _member 
)     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 
)     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 
)     _def_bin_op(MSTime, to_timevalue, _op_fn, _op, time)

◆ def_time_rel_op

#define def_time_rel_op (   _op_fn,
  _rel_op 
)     _def_rel_op(MSTime, to_timevalue, _op_fn, _rel_op, time)

◆ def_time_un_op

#define def_time_un_op (   _op_fn,
  _op 
)     _def_un_op(MSTime, _op_fn, _op, time)

◆ def_quat_bin_op

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

◆ def_quat_rel_op

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

◆ def_quat_un_op

#define def_quat_un_op (   _class,
  _op_fn,
  _op 
)     _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); \
}
QuatValue
Definition: 3dmath.h:143

◆ 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); \
}
Matrix3Value
Definition: 3dmath.h:300

◆ 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 
)     _def_bin_op(_class, _conv, _op_fn, _op, m)

◆ def_mat_rel_op

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

◆ def_mat_un_op

#define def_mat_un_op (   _class,
  _op_fn,
  _op 
)     _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); \
}
INode
Definition: inode.h:55
Interval
Definition: interval.h:36
ReferenceTarget
A scene entity that is being owned and listened to by other scene entities.
Definition: ref.h:1849
TimeValue
int TimeValue
Definition: maxtypes.h:31

◆ 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)); \
}
RuntimeError
Definition: exceptions.h:256
_M
#define _M(x)
Used to wrap string literals.
Definition: strbasic.h:67

◆ 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); \
}
Integer::intern
static ScripterExport Value * intern(int init_val)

◆ 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); \
}
AColor
Definition: acolor.h:31
AColor::r
float r
These values are in the range 0.0 to 1.0.
Definition: acolor.h:36
AColor::b
float b
Definition: acolor.h:38
AColor::g
float g
Definition: acolor.h:37
ColorValue::intern
static ScripterExport Value * intern(AColor col)

◆ 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))); \
}