3ds Max C++ API Reference
Loading...
Searching...
No Matches
value.h File Reference
#include "../ScripterExport.h"
#include "collectable.h"
#include "interupts.h"
#include "MAXScript_TLS.h"
#include "../macros/value_locals.h"
#include "MaxscriptTypedefs.h"
#include <Geom/matrix3.h>
#include <Geom/box2.h>
#include <Geom/acolor.h>
#include <Geom/quat.h>
#include "../../interval.h"
#include "../../ifnpub.h"

Classes

class  Value
class  ValueMetaClass
class  Boolean
class  Undefined
class  Ok
class  Empty
class  Unsupplied
class  NoValue

Macros

#define is_valueclass(v)
#define CHECK_ARG_COUNT(fn, w, g)
#define classof_methods(_cls, _super)
#define visible_class(_cls)
#define visible_class_debug_ok(_cls)
#define visible_class_s(_cls, _super)
#define applyable_class(_cls)
#define applyable_class_debug_ok(_cls)
#define applyable_class_s(_cls, _super)
#define visible_class_instance(_cls, _name)
#define invisible_class(_cls)
#define invisible_class_instance(_cls, _name)
#define class_tag(_cls)
#define INTERNAL_CLASS_TAG   ((ValueMetaClass*)0L)
#define INTERNAL_INDEX_THUNK_TAG   ((ValueMetaClass*)1L)
#define INTERNAL_PROP_THUNK_TAG   ((ValueMetaClass*)2L)
#define INTERNAL_LOCAL_THUNK_TAG   ((ValueMetaClass*)3L)
#define INTERNAL_FREE_THUNK_TAG   ((ValueMetaClass*)4L)
#define INTERNAL_RO_LOCAL_THUNK_TAG   ((ValueMetaClass*)5L)
#define INTERNAL_CODE_TAG   ((ValueMetaClass*)6L)
#define INTERNAL_SOURCEFILEWRAPPER_TAG   ((ValueMetaClass*)7L)
#define INTERNAL_PIPE_TAG   ((ValueMetaClass*)8L)
#define INTERNAL_TOOL_LOCAL_THUNK_TAG   ((ValueMetaClass*)9L)
#define INTERNAL_GLOBAL_THUNK_TAG   ((ValueMetaClass*)10L)
#define INTERNAL_CONST_GLOBAL_THUNK_TAG   ((ValueMetaClass*)11L)
#define INTERNAL_SYS_GLOBAL_THUNK_TAG   ((ValueMetaClass*)12L)
#define INTERNAL_PLUGIN_LOCAL_THUNK_TAG   ((ValueMetaClass*)13L)
#define INTERNAL_PLUGIN_PARAM_THUNK_TAG   ((ValueMetaClass*)14L)
#define INTERNAL_RCMENU_LOCAL_THUNK_TAG   ((ValueMetaClass*)15L)
#define INTERNAL_STRUCT_MEM_THUNK_TAG   ((ValueMetaClass*)16L)
#define INTERNAL_MSPLUGIN_TAG   ((ValueMetaClass*)17L)
#define INTERNAL_STRUCT_TAG   ((ValueMetaClass*)18L)
#define INTERNAL_MAKER_TAG   ((ValueMetaClass*)19L)
#define INTERNAL_CODEBLOCK_LOCAL_TAG   ((ValueMetaClass*)20L)
#define INTERNAL_CODEBLOCK_TAG   ((ValueMetaClass*)21L)
#define INTERNAL_THUNK_REF_TAG   ((ValueMetaClass*)22L)
#define INTERNAL_THUNK_DEREF_TAG   ((ValueMetaClass*)23L)
#define INTERNAL_STRUCT_METHOD_TAG   ((ValueMetaClass*)24L)
#define INTERNAL_MSPLUGIN_METHOD_TAG   ((ValueMetaClass*)25L)
#define INTERNAL_CONTEXT_THUNK_TAG   ((ValueMetaClass*)26L)
#define INTERNAL_OWNER_THUNK_TAG   ((ValueMetaClass*)27L)
#define INTERNAL_RCMENU_ITEM_THUNK_TAG   ((ValueMetaClass*)28L)
#define INTERNAL_STANDINMSPLUGINCLASS_TAG   ((ValueMetaClass*)29L)
#define INTERNAL_SOURCEPOSWRAPPER_TAG   ((ValueMetaClass*)30L)
#define INTERNAL_PYWRAPPERBASE_TAG   ((ValueMetaClass*)31L)
#define INTERNAL_PROP_EX_THUNK_TAG   ((ValueMetaClass*)32L)
#define INTERNAL_READONLY_THUNK_TAG   ((ValueMetaClass*)33L)
#define INTERNAL_TAGS   ((ValueMetaClass*)100L)
#define is_sourcepositionwrapper(v)
#define is_pywrapperbase(v)
#define pywrapperbase_equal(va, vb)
#define is_bool(v)

Functions

ScripterExport Value * _get_key_arg_or_default (Value **arg_list, int count, Value *key_name, Value *def)
Value * heap_ptr (Value *v)
Value * live_ptr (Value *v)

Variables

ScripterExport Undefined undefined
ScripterExport bool dontThrowAccessorError
ScripterExport MetaClassClass value_metaclass
ScripterExport Boolean true_value
ScripterExport Boolean false_value
ScripterExport Undefined dontCollect
ScripterExport Undefined loopExit
ScripterExport Ok ok
ScripterExport Empty empty
ScripterExport Unsupplied unsupplied
ScripterExport NoValue noValue

Macro Definition Documentation

◆ is_valueclass

#define is_valueclass ( v)
Value:
((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == (ValueMetaClass*)&value_metaclass)
ValueMetaClass
Definition value.h:433
DbgVerify
#define DbgVerify(expr)
Definition assert1.h:85
value_metaclass
ScripterExport MetaClassClass value_metaclass
is_sourcepositionwrapper
#define is_sourcepositionwrapper(v)
Definition value.h:645

◆ CHECK_ARG_COUNT

#define CHECK_ARG_COUNT ( fn,
w,
g )
Value:
if ((w) != (g)) throw ArgCountError (_M(#fn), w, g)
ArgCountError
Definition exceptions.h:241
_M
#define _M(x)
Used to wrap string literals.
Definition strbasic.h:67

◆ classof_methods

#define classof_methods ( _cls,
_super )
Value:
Value* classOf_vf(Value** arg_list, int count) override \
{ \
UNUSED_PARAM(arg_list); \
CHECK_ARG_COUNT(classOf, 1, count + 1); \
return &_cls##_class; \
} \
Value* superClassOf_vf(Value** arg_list, int count) override \
{ \
UNUSED_PARAM(arg_list); \
CHECK_ARG_COUNT(superClassOf, 1, count + 1); \
return &_super##_class; \
} \
Value* isKindOf_vf(Value** arg_list, int count) override \
{ \
CHECK_ARG_COUNT(isKindOf, 2, count + 1); \
return (arg_list[0] == &_cls##_class) ? \
&true_value : \
_super::isKindOf_vf(arg_list, count); \
} \
BOOL is_kind_of(ValueMetaClass* c) override \
{ \
return (c == &_cls##_class) ? 1 \
: _super::is_kind_of(c); \
}
Value
Definition value.h:107
true_value
ScripterExport Boolean true_value
464#define classof_methods(_cls, _super) \
465 Value* classOf_vf(Value** arg_list, int count) override \
466 { \
467 UNUSED_PARAM(arg_list); \
468 CHECK_ARG_COUNT(classOf, 1, count + 1); \
469 return &_cls##_class; \
470 } \
471 Value* superClassOf_vf(Value** arg_list, int count) override \
472 { \
473 UNUSED_PARAM(arg_list); \
474 CHECK_ARG_COUNT(superClassOf, 1, count + 1); \
475 return &_super##_class; \
476 } \
477 Value* isKindOf_vf(Value** arg_list, int count) override \
478 { \
479 CHECK_ARG_COUNT(isKindOf, 2, count + 1); \
480 return (arg_list[0] == &_cls##_class) ? \
481 &true_value : \
482 _super::isKindOf_vf(arg_list, count); \
483 } \
484 BOOL is_kind_of(ValueMetaClass* c) override \
485 { \
486 return (c == &_cls##_class) ? 1 \
487 : _super::is_kind_of(c); \
488 }

◆ visible_class

#define visible_class ( _cls)
Value:
class _cls##Class : public ValueMetaClass \
{ \
public: \
_cls##Class(const MCHAR* name) : ValueMetaClass (name) { } \
void collect() override { delete this; } \
}; \
extern ScripterExport _cls##Class _cls##_class;
ScripterExport
#define ScripterExport
Definition ScripterExport.h:7
ValueMetaClass::name
const MCHAR * name
Definition value.h:437
MCHAR
#define MCHAR
MBCS/Unicode helper defines std::wofstream doesn't mix well with Unicode.
Definition strbasic.h:42
490#define visible_class(_cls) \
491 class _cls##Class : public ValueMetaClass \
492 { \
493 public: \
494 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { } \
495 void collect() override { delete this; } \
496 }; \
497 extern ScripterExport _cls##Class _cls##_class;

◆ visible_class_debug_ok

#define visible_class_debug_ok ( _cls)
Value:
class _cls##Class : public ValueMetaClass \
{ \
public: \
_cls##Class(const MCHAR* name) : ValueMetaClass (name) { flags3 |= VALUE_FLAGBIT_0; } \
void collect() override { delete this; } \
}; \
extern ScripterExport _cls##Class _cls##_class;
VALUE_FLAGBIT_0
@ VALUE_FLAGBIT_0
Definition collectable.h:65
499#define visible_class_debug_ok(_cls) \
500 class _cls##Class : public ValueMetaClass \
501 { \
502 public: \
503 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { flags3 |= VALUE_FLAGBIT_0; } \
504 void collect() override { delete this; } \
505 }; \
506 extern ScripterExport _cls##Class _cls##_class;

◆ visible_class_s

#define visible_class_s ( _cls,
_super )
508#define visible_class_s(_cls, _super) \
509 class _cls##Class; \
510 extern ScripterExport _cls##Class _cls##_class; \
511 class _cls##Class : public ValueMetaClass \
512 { \
513 public: \
514 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { } \
515 void collect() override { delete this; } \
516 Value* classOf_vf(Value** arg_list, int count) override \
517 { \
518 UNUSED_PARAM(arg_list); \
519 CHECK_ARG_COUNT(classOf, 1, count + 1); \
520 return &_super##_class; \
521 } \
522 Value* superClassOf_vf(Value** arg_list, int count) override \
523 { \
524 UNUSED_PARAM(arg_list); \
525 UNUSED_PARAM(count); \
526 return _super##_class.classOf_vf(nullptr, 0); \
527 } \
528 Value* isKindOf_vf(Value** arg_list, int count) override \
529 { \
530 CHECK_ARG_COUNT(isKindOf, 2, count + 1); \
531 Value* arg0 = arg_list[0]; \
532 return (arg0 == &_cls##_class || arg0 == &_super##_class) ? \
533 &true_value : \
534 _super##_class.isKindOf_vf(arg_list, count); \
535 } \
536 BOOL is_kind_of(ValueMetaClass* c) override \
537 { \
538 return (c == &_cls##_class) ? 1 \
539 : _super##_class.is_kind_of(c); \
540 } \
541 };

◆ applyable_class

#define applyable_class ( _cls)
Value:
class _cls##Class : public ValueMetaClass \
{ \
public: \
_cls##Class(const MCHAR* name) : ValueMetaClass (name) { }\
void collect() override { delete this; } \
ScripterExport Value* apply(Value** arglist, int count, CallContext* cc = nullptr) override; \
}; \
extern ScripterExport _cls##Class _cls##_class;
543#define applyable_class(_cls) \
544 class _cls##Class : public ValueMetaClass \
545 { \
546 public: \
547 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { }\
548 void collect() override { delete this; } \
549 ScripterExport Value* apply(Value** arglist, int count, CallContext* cc = nullptr) override; \
550 }; \
551 extern ScripterExport _cls##Class _cls##_class;

◆ applyable_class_debug_ok

#define applyable_class_debug_ok ( _cls)
Value:
class _cls##Class : public ValueMetaClass \
{ \
public: \
_cls##Class(const MCHAR* name) : ValueMetaClass (name) { flags3 |= VALUE_FLAGBIT_0; }\
void collect() override { delete this; } \
ScripterExport Value* apply(Value** arglist, int count, CallContext* cc = nullptr) override; \
}; \
extern ScripterExport _cls##Class _cls##_class;
553#define applyable_class_debug_ok(_cls) \
554 class _cls##Class : public ValueMetaClass \
555 { \
556 public: \
557 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { flags3 |= VALUE_FLAGBIT_0; }\
558 void collect() override { delete this; } \
559 ScripterExport Value* apply(Value** arglist, int count, CallContext* cc = nullptr) override; \
560 }; \
561 extern ScripterExport _cls##Class _cls##_class;

◆ applyable_class_s

#define applyable_class_s ( _cls,
_super )
Value:
class _cls##Class : public ValueMetaClass \
{ \
public: \
_cls##Class(const MCHAR* name) : ValueMetaClass (name) { }\
Value* classOf_vf(Value** arg_list, int count) override \
{ \
UNUSED_PARAM(arg_list); \
CHECK_ARG_COUNT(classOf, 1, count + 1); \
return &_super##_class; \
} \
Value* superClassOf_vf(Value** arg_list, int count) override \
{ \
UNUSED_PARAM(arg_list); \
UNUSED_PARAM(count); \
return _super##_class.classOf_vf(nullptr, 0); \
} \
void collect() override { delete this; } \
ScripterExport Value* apply(Value** arglist, int count, CallContext* cc = nullptr) override; \
}; \
extern ScripterExport _cls##Class _cls##_class;
563#define applyable_class_s(_cls, _super) \
564 class _cls##Class : public ValueMetaClass \
565 { \
566 public: \
567 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { }\
568 Value* classOf_vf(Value** arg_list, int count) override \
569 { \
570 UNUSED_PARAM(arg_list); \
571 CHECK_ARG_COUNT(classOf, 1, count + 1); \
572 return &_super##_class; \
573 } \
574 Value* superClassOf_vf(Value** arg_list, int count) override \
575 { \
576 UNUSED_PARAM(arg_list); \
577 UNUSED_PARAM(count); \
578 return _super##_class.classOf_vf(nullptr, 0); \
579 } \
580 void collect() override { delete this; } \
581 ScripterExport Value* apply(Value** arglist, int count, CallContext* cc = nullptr) override; \
582 }; \
583 extern ScripterExport _cls##Class _cls##_class;

◆ visible_class_instance

#define visible_class_instance ( _cls,
_name )
Value:
ScripterExport _cls##Class _cls##_class (_M(_name));
585#define visible_class_instance(_cls, _name) \
586 ScripterExport _cls##Class _cls##_class (_M(_name));

◆ invisible_class

#define invisible_class ( _cls)
Value:
class _cls##Class : public ValueMetaClass \
{ \
public: \
_cls##Class(const MCHAR* name) : ValueMetaClass (name) { } \
void collect() override { delete this; } \
void export_to_scripter() override { } \
}; \
extern ScripterExport _cls##Class _cls##_class;
588#define invisible_class(_cls) \
589 class _cls##Class : public ValueMetaClass \
590 { \
591 public: \
592 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { } \
593 void collect() override { delete this; } \
594 void export_to_scripter() override { } \
595 }; \
596 extern ScripterExport _cls##Class _cls##_class;

◆ invisible_class_instance

#define invisible_class_instance ( _cls,
_name )
Value:
ScripterExport _cls##Class _cls##_class (_M(_name));
598#define invisible_class_instance(_cls, _name) \
599 ScripterExport _cls##Class _cls##_class (_M(_name));

◆ class_tag

#define class_tag ( _cls)
Value:
&_cls##_class

◆ INTERNAL_CLASS_TAG

#define INTERNAL_CLASS_TAG   ((ValueMetaClass*)0L)

◆ INTERNAL_INDEX_THUNK_TAG

#define INTERNAL_INDEX_THUNK_TAG   ((ValueMetaClass*)1L)

◆ INTERNAL_PROP_THUNK_TAG

#define INTERNAL_PROP_THUNK_TAG   ((ValueMetaClass*)2L)

◆ INTERNAL_LOCAL_THUNK_TAG

#define INTERNAL_LOCAL_THUNK_TAG   ((ValueMetaClass*)3L)

◆ INTERNAL_FREE_THUNK_TAG

#define INTERNAL_FREE_THUNK_TAG   ((ValueMetaClass*)4L)

◆ INTERNAL_RO_LOCAL_THUNK_TAG

#define INTERNAL_RO_LOCAL_THUNK_TAG   ((ValueMetaClass*)5L)

◆ INTERNAL_CODE_TAG

#define INTERNAL_CODE_TAG   ((ValueMetaClass*)6L)

◆ INTERNAL_SOURCEFILEWRAPPER_TAG

#define INTERNAL_SOURCEFILEWRAPPER_TAG   ((ValueMetaClass*)7L)

◆ INTERNAL_PIPE_TAG

#define INTERNAL_PIPE_TAG   ((ValueMetaClass*)8L)

◆ INTERNAL_TOOL_LOCAL_THUNK_TAG

#define INTERNAL_TOOL_LOCAL_THUNK_TAG   ((ValueMetaClass*)9L)

◆ INTERNAL_GLOBAL_THUNK_TAG

#define INTERNAL_GLOBAL_THUNK_TAG   ((ValueMetaClass*)10L)

◆ INTERNAL_CONST_GLOBAL_THUNK_TAG

#define INTERNAL_CONST_GLOBAL_THUNK_TAG   ((ValueMetaClass*)11L)

◆ INTERNAL_SYS_GLOBAL_THUNK_TAG

#define INTERNAL_SYS_GLOBAL_THUNK_TAG   ((ValueMetaClass*)12L)

◆ INTERNAL_PLUGIN_LOCAL_THUNK_TAG

#define INTERNAL_PLUGIN_LOCAL_THUNK_TAG   ((ValueMetaClass*)13L)

◆ INTERNAL_PLUGIN_PARAM_THUNK_TAG

#define INTERNAL_PLUGIN_PARAM_THUNK_TAG   ((ValueMetaClass*)14L)

◆ INTERNAL_RCMENU_LOCAL_THUNK_TAG

#define INTERNAL_RCMENU_LOCAL_THUNK_TAG   ((ValueMetaClass*)15L)

◆ INTERNAL_STRUCT_MEM_THUNK_TAG

#define INTERNAL_STRUCT_MEM_THUNK_TAG   ((ValueMetaClass*)16L)

◆ INTERNAL_MSPLUGIN_TAG

#define INTERNAL_MSPLUGIN_TAG   ((ValueMetaClass*)17L)

◆ INTERNAL_STRUCT_TAG

#define INTERNAL_STRUCT_TAG   ((ValueMetaClass*)18L)

◆ INTERNAL_MAKER_TAG

#define INTERNAL_MAKER_TAG   ((ValueMetaClass*)19L)

◆ INTERNAL_CODEBLOCK_LOCAL_TAG

#define INTERNAL_CODEBLOCK_LOCAL_TAG   ((ValueMetaClass*)20L)

◆ INTERNAL_CODEBLOCK_TAG

#define INTERNAL_CODEBLOCK_TAG   ((ValueMetaClass*)21L)

◆ INTERNAL_THUNK_REF_TAG

#define INTERNAL_THUNK_REF_TAG   ((ValueMetaClass*)22L)

◆ INTERNAL_THUNK_DEREF_TAG

#define INTERNAL_THUNK_DEREF_TAG   ((ValueMetaClass*)23L)

◆ INTERNAL_STRUCT_METHOD_TAG

#define INTERNAL_STRUCT_METHOD_TAG   ((ValueMetaClass*)24L)

◆ INTERNAL_MSPLUGIN_METHOD_TAG

#define INTERNAL_MSPLUGIN_METHOD_TAG   ((ValueMetaClass*)25L)

◆ INTERNAL_CONTEXT_THUNK_TAG

#define INTERNAL_CONTEXT_THUNK_TAG   ((ValueMetaClass*)26L)

◆ INTERNAL_OWNER_THUNK_TAG

#define INTERNAL_OWNER_THUNK_TAG   ((ValueMetaClass*)27L)

◆ INTERNAL_RCMENU_ITEM_THUNK_TAG

#define INTERNAL_RCMENU_ITEM_THUNK_TAG   ((ValueMetaClass*)28L)

◆ INTERNAL_STANDINMSPLUGINCLASS_TAG

#define INTERNAL_STANDINMSPLUGINCLASS_TAG   ((ValueMetaClass*)29L)

◆ INTERNAL_SOURCEPOSWRAPPER_TAG

#define INTERNAL_SOURCEPOSWRAPPER_TAG   ((ValueMetaClass*)30L)

◆ INTERNAL_PYWRAPPERBASE_TAG

#define INTERNAL_PYWRAPPERBASE_TAG   ((ValueMetaClass*)31L)

◆ INTERNAL_PROP_EX_THUNK_TAG

#define INTERNAL_PROP_EX_THUNK_TAG   ((ValueMetaClass*)32L)

◆ INTERNAL_READONLY_THUNK_TAG

#define INTERNAL_READONLY_THUNK_TAG   ((ValueMetaClass*)33L)

◆ INTERNAL_TAGS

#define INTERNAL_TAGS   ((ValueMetaClass*)100L)

◆ is_sourcepositionwrapper

#define is_sourcepositionwrapper ( v)
Value:
((v)->tag == INTERNAL_SOURCEPOSWRAPPER_TAG)
INTERNAL_SOURCEPOSWRAPPER_TAG
#define INTERNAL_SOURCEPOSWRAPPER_TAG
Definition value.h:634

◆ is_pywrapperbase

#define is_pywrapperbase ( v)
Value:
((v)->tag == INTERNAL_PYWRAPPERBASE_TAG)
INTERNAL_PYWRAPPERBASE_TAG
#define INTERNAL_PYWRAPPERBASE_TAG
Definition value.h:635

◆ pywrapperbase_equal

#define pywrapperbase_equal ( va,
vb )
Value:
( \
is_pywrapperbase(va) && \
is_pywrapperbase(vb) && \
(va)->eq_vf(&(vb), 1) \
)
649#define pywrapperbase_equal(va, vb) \
650( \
651 is_pywrapperbase(va) && \
652 is_pywrapperbase(vb) && \
653 (va)->eq_vf(&(vb), 1) \
654)

◆ is_bool

#define is_bool ( v)
Value:
((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == &Boolean_class)

Function Documentation

◆ _get_key_arg_or_default()

ScripterExport Value * _get_key_arg_or_default ( Value ** arg_list,
int count,
Value * key_name,
Value * def )

◆ heap_ptr()

Value * heap_ptr ( Value * v)
inline
424{ return v ? v->get_heap_ptr() : nullptr; } // ensure v is in heap, migrate if not, return heap pointer
Value::get_heap_ptr
ScripterExport Value * get_heap_ptr()
Definition value.h:370

◆ live_ptr()

Value * live_ptr ( Value * v)
inline
425{ return v->get_live_ptr(); } // get live pointer, if on stack & migrated, heap copy is live
Value::get_live_ptr
ScripterExport Value * get_live_ptr()
Definition value.h:373

Variable Documentation

◆ undefined

ScripterExport Undefined undefined
extern

◆ dontThrowAccessorError

ScripterExport bool dontThrowAccessorError
extern

◆ value_metaclass

ScripterExport MetaClassClass value_metaclass
extern

◆ true_value

ScripterExport Boolean true_value
extern

◆ false_value

ScripterExport Boolean false_value
extern

◆ dontCollect

ScripterExport Undefined dontCollect
extern

◆ loopExit

ScripterExport Undefined loopExit
extern

◆ ok

ScripterExport Ok ok
extern

◆ empty

ScripterExport Empty empty
extern

◆ unsupplied

ScripterExport Unsupplied unsupplied
extern

◆ noValue

ScripterExport NoValue noValue
extern