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

Macros

#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)

Macro Definition Documentation

◆ def_generic

#define def_generic ( fn,
name )
Value:
Value* fn##_vf(Value** arglist, int arg_count)
Value
Definition value.h:107
53#define def_generic(fn, name) \
54 Value* fn##_vf(Value** arglist, int arg_count)

◆ def_visible_generic

#define def_visible_generic ( fn,
name )
Value:
def_generic(fn, name)
def_generic
#define def_generic(fn, name)
Definition functions.h:15

◆ 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_primitive
#define def_primitive(fn, name)
Definition define_abstract_functions.h:87

◆ 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)
81#define def_property(p) \
82 Value* get_##p(Value** arg_list, int count); \
83 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)
84#define def_prop_getter(p) \
85 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)
86#define def_prop_setter(p) \
87 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)
89#define def_2_prop_path(p1, p2) \
90 Value* get_##p1##_##p2(Value** arg_list, int count); \
91 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)
93#define def_nested_prop(p1) \
94 Value* get_nested_##p1(Value** arg_list, int count); \
95 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]; \
};
97#define def_backpatched_setter(_prop, _superclass) \
98 Value* \
99 set_##_prop(Value** arg_list, int count) \
100 { \
101 _superclass::set_##_prop(arg_list, count); \
102 back_patch(); \
103 return arg_list[0]; \
104 };

◆ 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); } \
106#define def_local_prop_alias(p, real_p) \
107 Value* get_##p(Value** arg_list, int count) { return get_##real_p(arg_list, count); } \
108 Value* set_##p(Value** arg_list, int count) { return set_##real_p(arg_list, count); } \
109

◆ def_time_fn

#define def_time_fn ( _fn)
Value:
Value* _fn##_vf(Value** arglist, int arg_count)
113#define def_time_fn(_fn) \
114 Value* _fn##_vf(Value** arglist, int arg_count)

◆ def_name

#define def_name ( name)
Value:
n_##name = Name::intern(_M(#name));
Name::intern
static ScripterExport Value * intern(const MCHAR *str)
_M
#define _M(x)
Used to wrap string literals.
Definition strbasic.h:67

◆ 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
124#define _def_num_bin_op(_class, _conv, _op_fn, _op, _member) \
125 Value* \
126 _class::_op_fn##_vf(Value** arg_list, int count) \
127 { \
128 check_arg_count(_fn, 2, count+1); \
129 one_value_local(widened); \
130 Value *arg, *result; \
131 arg = arg_list[0]; \
132 if (tag != arg->tag && ((vl.widened = widen_to(arg, arg_list)) != NULL)) \
133 result = vl.widened->_op_fn##_vf(arg_list, 1); \
134 else \
135 result = _class::intern(_member _op (arg_list[0])->_conv()); \
136 return_value(result); \
137 }

◆ _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); \
}
139#define _def_bin_op(_class, _conv, _op_fn, _op, _member) \
140 Value* \
141 _class::_op_fn##_vf(Value** arg_list, int count) \
142 { \
143 check_arg_count(_op_fn, 2, count + 1); \
144 one_value_local(widened); \
145 Value *arg, *result; \
146 arg = arg_list[0]; \
147 if (tag != arg->tag && ((vl.widened = widen_to(arg, arg_list)) != NULL)) \
148 result = vl.widened->_op_fn##_vf(arg_list, 1); \
149 else \
150 result = new _class (_member _op (arg_list[0])->_conv()); \
151 return_value(result); \
152 }

◆ _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:301
false_value
ScripterExport Boolean false_value
true_value
ScripterExport Boolean true_value
154#define _def_rel_op(_class, _conv, _op_fn, _rel_op, _member) \
155 Value* \
156 _class::_op_fn##_vf(Value** arg_list, int count) \
157 { \
158 check_arg_count(_op_fn, 2, count + 1); \
159 one_value_local(widened); \
160 Value *arg, *result; \
161 arg = arg_list[0]; \
162 if (tag != arg->tag && ((vl.widened = widen_to(arg, arg_list)) != NULL)) \
163 result = vl.widened->_op_fn##_vf(arg_list, 1); \
164 else \
165 { \
166 if (comparable(arg)) \
167 result = (_member _rel_op arg->_conv()) ? \
168 &true_value : &false_value; \
169 else \
170 throw IncompatibleTypes(this, arg); \
171 } \
172 return_value(result); \
173 }

◆ 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; \
}
176#define def_eq_op(_class, comparison_method, _member) \
177 Value* \
178 _class::eq_vf(Value** arg_list, int count) \
179 { \
180 check_arg_count(eq, 2, count + 1); \
181 Value* cmpnd = arg_list[0]; \
182 Value* result; \
183 bool specialCaseCompareResult = false; \
184 if (special_case_compare(cmpnd,specialCaseCompareResult)) \
185 { \
186 result = specialCaseCompareResult ? &true_value : &false_value; \
187 } \
188 else if (comparable(cmpnd)) \
189 result = (_member == cmpnd->comparison_method()) ? \
190 &true_value : &false_value; \
191 else \
192 result = &false_value; \
193 return result; \
194 }

◆ 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; \
}
196#define def_ne_op(_class, comparison_method, _member) \
197 Value* \
198 _class::ne_vf(Value** arg_list, int count) \
199 { \
200 check_arg_count(ne, 2, count + 1); \
201 Value* cmpnd = arg_list[0]; \
202 Value* result; \
203 bool specialCaseCompareResult = false; \
204 if (special_case_compare(cmpnd,specialCaseCompareResult)) \
205 { \
206 result = specialCaseCompareResult ? &false_value : &true_value; \
207 } \
208 else if (comparable(cmpnd)) \
209 result = (_member == cmpnd->comparison_method()) ? \
210 &false_value : &true_value; \
211 else \
212 result = &true_value; \
213 return result; \
214 }

◆ _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)); \
}
217#define _def_num_un_op(_class, _op_fn, _op, _member) \
218 Value* \
219 _class::_op_fn##_vf(Value** arg_list, int count) \
220 { \
221 check_arg_count(_op_fn, 1, count + 1); \
222 return_value (_class::intern(_op _member)); \
223 }

◆ _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); \
}
225#define _def_un_op(_class, _op_fn, _op, _member) \
226 Value* \
227 _class::_op_fn##_vf(Value** arg_list, int count) \
228 { \
229 check_arg_count(_op_fn, 1, count + 1); \
230 return new _class (_op _member); \
231 }

◆ def_bin_op

#define def_bin_op ( _class,
_conv,
_op_fn,
_op )
Value:
_def_num_bin_op(_class, _conv, _op_fn, _op, value)
_def_num_bin_op
#define _def_num_bin_op(_class, _conv, _op_fn, _op, _member)
Definition define_implementations.h:124
233#define def_bin_op(_class, _conv, _op_fn, _op) \
234 _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_rel_op
#define _def_rel_op(_class, _conv, _op_fn, _rel_op, _member)
Definition define_implementations.h:154
235#define def_rel_op(_class, _conv, _op_fn, _rel_op) \
236 _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)
_def_num_un_op
#define _def_num_un_op(_class, _op_fn, _op, _member)
Definition define_implementations.h:217
237#define def_un_op(_class, _op_fn, _op) \
238 _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)
DEG_TO_RAD_double
#define DEG_TO_RAD_double
Definition define_implementations.h:244

◆ RadToDeg_double

#define RadToDeg_double ( rad)
Value:
(((double)rad)*RAD_TO_DEG_double)
RAD_TO_DEG_double
#define RAD_TO_DEG_double
Definition define_implementations.h:245

◆ 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()))); \
}
252#define def_math_fn(_class, _outclass, _type, _conv, _fn) \
253 Value* \
254 _class::_fn##_vf(Value** arg_list, int count) \
255 { \
256 check_arg_count(_fn, 1, count+1); \
257 return_value (_outclass::intern((_type)_fn(_conv()))); \
258 }

◆ 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())))); \
}
260#define def_angle_trig_fn(_class, _outclass, _type, _conv, _fn) \
261 Value* \
262 _class::_fn##_vf(Value** arg_list, int count) \
263 { \
264 check_arg_count(_fn, 1, count+1); \
265 return_value (_outclass::intern(RadToDeg_##_type((_type)_fn(_conv())))); \
266 }

◆ 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())))); \
}
268#define def_float_trig_fn(_class, _outclass, _type, _conv, _fn) \
269 Value* \
270 _class::_fn##_vf(Value** arg_list, int count) \
271 { \
272 check_arg_count(_fn, 1, count+1); \
273 return_value (_outclass::intern((_type)_fn(DegToRad_##_type(_conv())))); \
274 }

◆ 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); \
}
276#define def_math_bin_fn(_class, _outclass, _type, _conv, _fn) \
277 Value* \
278 _class::_fn##_vf(Value** arg_list, int count) \
279 { \
280 check_arg_count(_fn, 2, count+1); \
281 one_value_local(widened); \
282 Value *arg, *result; \
283 arg = arg_list[0]; \
284 if (tag != arg->tag && ((vl.widened = widen_to(arg, arg_list)) != NULL)) \
285 result = vl.widened->_fn##_vf(arg_list, 1); \
286 else \
287 result = _outclass::intern((_type)_fn(_conv(), arg_list[0]->_conv())); \
288 return_value(result); \
289 }

◆ 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())))); \
}
291#define def_angle_trig_bin_fn(_class, _outclass, _type, _conv, _fn) \
292 Value* \
293 _class::_fn##_vf(Value** arg_list, int count) \
294 { \
295 check_arg_count(_fn, 2, count+1); \
296 return_value (_outclass::intern(RadToDeg_##_type((_type)_fn(_conv(), \
297 arg_list[0]->_conv())))); \
298 }

◆ 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; \
}
300#define def_num_prop_accessors(_class, _prop, _member, _type, _conv ) \
301 Value* \
302 _class::get_##_prop(Value** arg_list, int count) \
303 { \
304 return_value (_type::intern(_member)); \
305 } \
306 Value* \
307 _class::set_##_prop(Value** arg_list, int count) \
308 { \
309 Value* val = arg_list[0]; \
310 _member = val->_conv(); \
311 return val; \
312 }

◆ 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; \
}
314#define def_prop_accessors(_class, _prop, _member, _type, _conv ) \
315 Value* \
316 _class::get_##_prop(Value** arg_list, int count) \
317 { \
318 return new _type (_member); \
319 } \
320 Value* \
321 _class::set_##_prop(Value** arg_list, int count) \
322 { \
323 Value* val = arg_list[0]; \
324 _member = val->_conv(); \
325 return val; \
326 }

◆ 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; \
}
328#define def_fn_prop_accessors(_class, _prop, _getter, _setter) \
329 Value* \
330 _class::get_##_prop(Value** arg_list, int count) \
331 { \
332 return _getter; \
333 } \
334 Value* \
335 _class::set_##_prop(Value** arg_list, int count) \
336 { \
337 Value* val = arg_list[0]; \
338 _setter; \
339 return val; \
340 }

◆ def_fn_prop_getter

#define def_fn_prop_getter ( _class,
_prop,
_getter )
Value:
Value* \
_class::get_##_prop(Value** arg_list, int count) \
{ \
return _getter; \
}
342#define def_fn_prop_getter(_class, _prop, _getter) \
343 Value* \
344 _class::get_##_prop(Value** arg_list, int count) \
345 { \
346 return _getter; \
347 }

◆ 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; \
}
349#define def_fn_prop_setter(_class, _prop, _setter) \
350 Value* \
351 _class::set_##_prop(Value** arg_list, int count) \
352 { \
353 Value* val = arg_list[0]; \
354 _setter; \
355 return val; \
356 }

◆ def_float_prop_accessors

#define def_float_prop_accessors ( _class,
_prop,
_member )
Value:
def_num_prop_accessors(_class, _prop, _member, Float, to_float)
Float
Definition numbers.h:77
def_num_prop_accessors
#define def_num_prop_accessors(_class, _prop, _member, _type, _conv)
Definition define_implementations.h:300
358#define def_float_prop_accessors(_class, _prop, _member) \
359 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)
Integer
Definition numbers.h:176
361#define def_int_prop_accessors(_class, _prop, _member) \
362 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())
Point3Value
Definition 3dmath.h:26
Point3Value::to_point3
Point3 to_point3() override
Definition 3dmath.h:62
def_fn_prop_accessors
#define def_fn_prop_accessors(_class, _prop, _getter, _setter)
Definition define_implementations.h:328
364#define def_point3_prop_accessors(_class, _prop, _member) \
365 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()))
Float::intern
static ScripterExport Value * intern(float init_val)
367#define def_angle_prop_accessors(_class, _prop, _member) \
368 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)
MSTime
Definition mxstime.h:20
_def_bin_op
#define _def_bin_op(_class, _conv, _op_fn, _op, _member)
Definition define_implementations.h:139
370#define def_time_bin_op(_op_fn, _op) \
371 _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)
372#define def_time_rel_op(_op_fn, _rel_op) \
373 _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_un_op
#define _def_un_op(_class, _op_fn, _op, _member)
Definition define_implementations.h:225
374#define def_time_un_op(_op_fn, _op) \
375 _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)
377#define def_quat_bin_op(_class, _conv, _op_fn, _op) \
378 _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)
379#define def_quat_rel_op(_class, _conv, _op_fn, _rel_op) \
380 _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)
381#define def_quat_un_op(_class, _op_fn, _op) \
382 _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
384#define def_new_quat_fn(_fn, _arg_count, _call) \
385 Value* \
386 QuatValue::_fn##_vf(Value** arg_list, int count) \
387 { \
388 check_arg_count(_fn, _arg_count, count + 1); \
389 return new QuatValue (_call); \
390 }

◆ 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; \
}
392#define def_mut_quat_fn(_fn, _arg_count, _call) \
393 Value* \
394 QuatValue::_fn##_vf(Value** arg_list, int count) \
395 { \
396 check_arg_count(_fn, _arg_count, count + 1); \
397 _call; \
398 return this; \
399 }

◆ 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
401#define def_new_mat_fn(_fn, _arg_count, _call) \
402 Value* \
403 Matrix3Value::_fn##_vf(Value** arg_list, int count) \
404 { \
405 check_arg_count(_fn, _arg_count, count + 1); \
406 return new Matrix3Value (_call); \
407 }

◆ 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; \
}
409#define def_mut_mat_fn(_fn, _arg_count, _call) \
410 Value* \
411 Matrix3Value::_fn##_vf(Value** arg_list, int count) \
412 { \
413 check_arg_count(_fn, _arg_count, count + 1); \
414 _call; \
415 return this; \
416 }

◆ 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); \
}
418#define def_mat_primitive(_fn, _arg_count, _call) \
419 Value* \
420 _fn##_cf(Value** arg_list, int count) \
421 { \
422 check_arg_count(_fn, _arg_count, count); \
423 return new Matrix3Value (_call); \
424 }

◆ def_mat_bin_op

#define def_mat_bin_op ( _class,
_conv,
_op_fn,
_op )
Value:
_def_bin_op(_class, _conv, _op_fn, _op, m)
426#define def_mat_bin_op(_class, _conv, _op_fn, _op) \
427 _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)
428#define def_mat_rel_op(_class, _conv, _op_fn, _rel_op) \
429 _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)
430#define def_mat_un_op(_class, _op_fn, _op) \
431 _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:1869
TimeValue
int TimeValue
Definition maxtypes.h:31
436#define def_bool_node_fns(name, getter, setter) \
437 Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid) \
438 { \
439 return ((INode*)obj)->getter() ? &true_value : &false_value; \
440 } \
441 void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val) \
442 { \
443 ((INode*)obj)->setter(val->to_bool()); \
444 InvalidateNodeRect((INode*)obj,t); \
445 }

◆ 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:253
447#define def_bool_node_getter(name, getter) \
448 Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid) \
449 { \
450 return ((INode*)obj)->getter() ? &true_value : &false_value; \
451 } \
452 void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val) \
453 { \
454 throw RuntimeError (_M("Property not settable: "), _M(#name)); \
455 }

◆ 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)
457#define def_ulong_node_fns(name, getter, setter) \
458 Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid) \
459 { \
460 return_value (Integer::intern((int)((INode*)obj)->getter())); \
461 } \
462 void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val) \
463 { \
464 ((INode*)obj)->setter((ULONG)val->to_int()); \
465 InvalidateNodeRect((INode*)obj,t); \
466 }

◆ 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); \
}
ColorValue::intern
static ScripterExport Value * intern(AColor col)
468#define def_color_node_fns(name, getter, setter) \
469 Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid) \
470 { \
471 DWORD rgb = ((INode*)obj)->getter(); \
472 return_value (ColorValue::intern(GetRValue(rgb) / 255.0f, GetGValue(rgb) / 255.0f, GetBValue(rgb) / 255.0f)); \
473 } \
474 void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val) \
475 { \
476 AColor c; \
477 c = val->to_acolor(); \
478 ((INode*)obj)->setter(RGB((BYTE)(c.r * 255), (BYTE)(c.g * 255), (BYTE)(c.b * 255))); \
479 InvalidateNodeRect((INode*)obj,t); \
480 }

◆ 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()); \
}
489#define def_bool_node_noredraw_fns(name, getter, setter) \
490 Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid) \
491 { \
492 return ((INode*)obj)->getter() ? &true_value : &false_value; \
493 } \
494 void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val) \
495 { \
496 ((INode*)obj)->setter(val->to_bool()); \
497 }

◆ 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()); \
}
499#define def_ulong_node_noredraw_fns(name, getter, setter) \
500 Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid) \
501 { \
502 return_value (Integer::intern((int)((INode*)obj)->getter())); \
503 } \
504 void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val) \
505 { \
506 ((INode*)obj)->setter((ULONG)val->to_int()); \
507 }

◆ 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))); \
}
509#define def_color_node_noredraw_fns(name, getter, setter) \
510 Value* node_get_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Interval& valid) \
511 { \
512 DWORD rgb = ((INode*)obj)->getter(); \
513 return_value (ColorValue::intern(GetRValue(rgb) / 255.0f, GetGValue(rgb) / 255.0f, GetBValue(rgb) / 255.0f)); \
514 } \
515 void node_set_##name(ReferenceTarget* obj, Value* prop, TimeValue t, Value* val) \
516 { \
517 AColor c; \
518 c = val->to_acolor(); \
519 ((INode*)obj)->setter(RGB((BYTE)(c.r * 255), (BYTE)(c.g * 255), (BYTE)(c.b * 255))); \
520 }