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/box3.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:434
DbgVerify
#define DbgVerify(expr)
Definition assert1.h:85
value_metaclass
ScripterExport MetaClassClass value_metaclass
is_sourcepositionwrapper
#define is_sourcepositionwrapper(v)
Definition value.h:647

◆ CHECK_ARG_COUNT

#define CHECK_ARG_COUNT ( fn,
w,
g )
Value:
if ((w) != (g)) throw ArgCountError (_M(#fn), w, g)
ArgCountError
Definition exceptions.h:274
_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:108
true_value
ScripterExport Boolean true_value
466#define classof_methods(_cls, _super) \
467 Value* classOf_vf(Value** arg_list, int count) override \
468 { \
469 UNUSED_PARAM(arg_list); \
470 CHECK_ARG_COUNT(classOf, 1, count + 1); \
471 return &_cls##_class; \
472 } \
473 Value* superClassOf_vf(Value** arg_list, int count) override \
474 { \
475 UNUSED_PARAM(arg_list); \
476 CHECK_ARG_COUNT(superClassOf, 1, count + 1); \
477 return &_super##_class; \
478 } \
479 Value* isKindOf_vf(Value** arg_list, int count) override \
480 { \
481 CHECK_ARG_COUNT(isKindOf, 2, count + 1); \
482 return (arg_list[0] == &_cls##_class) ? \
483 &true_value : \
484 _super::isKindOf_vf(arg_list, count); \
485 } \
486 BOOL is_kind_of(ValueMetaClass* c) override \
487 { \
488 return (c == &_cls##_class) ? 1 \
489 : _super::is_kind_of(c); \
490 }

◆ 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:438
MCHAR
#define MCHAR
MBCS/Unicode helper defines std::wofstream doesn't mix well with Unicode.
Definition strbasic.h:42
492#define visible_class(_cls) \
493 class _cls##Class : public ValueMetaClass \
494 { \
495 public: \
496 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { } \
497 void collect() override { delete this; } \
498 }; \
499 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
501#define visible_class_debug_ok(_cls) \
502 class _cls##Class : public ValueMetaClass \
503 { \
504 public: \
505 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { flags3 |= VALUE_FLAGBIT_0; } \
506 void collect() override { delete this; } \
507 }; \
508 extern ScripterExport _cls##Class _cls##_class;

◆ visible_class_s

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

◆ 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;
545#define applyable_class(_cls) \
546 class _cls##Class : public ValueMetaClass \
547 { \
548 public: \
549 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { }\
550 void collect() override { delete this; } \
551 ScripterExport Value* apply(Value** arglist, int count, CallContext* cc = nullptr) override; \
552 }; \
553 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;
555#define applyable_class_debug_ok(_cls) \
556 class _cls##Class : public ValueMetaClass \
557 { \
558 public: \
559 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { flags3 |= VALUE_FLAGBIT_0; }\
560 void collect() override { delete this; } \
561 ScripterExport Value* apply(Value** arglist, int count, CallContext* cc = nullptr) override; \
562 }; \
563 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;
565#define applyable_class_s(_cls, _super) \
566 class _cls##Class : public ValueMetaClass \
567 { \
568 public: \
569 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { }\
570 Value* classOf_vf(Value** arg_list, int count) override \
571 { \
572 UNUSED_PARAM(arg_list); \
573 CHECK_ARG_COUNT(classOf, 1, count + 1); \
574 return &_super##_class; \
575 } \
576 Value* superClassOf_vf(Value** arg_list, int count) override \
577 { \
578 UNUSED_PARAM(arg_list); \
579 UNUSED_PARAM(count); \
580 return _super##_class.classOf_vf(nullptr, 0); \
581 } \
582 void collect() override { delete this; } \
583 ScripterExport Value* apply(Value** arglist, int count, CallContext* cc = nullptr) override; \
584 }; \
585 extern ScripterExport _cls##Class _cls##_class;

◆ visible_class_instance

#define visible_class_instance ( _cls,
_name )
Value:
ScripterExport _cls##Class _cls##_class (_M(_name));
587#define visible_class_instance(_cls, _name) \
588 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;
590#define invisible_class(_cls) \
591 class _cls##Class : public ValueMetaClass \
592 { \
593 public: \
594 _cls##Class(const MCHAR* name) : ValueMetaClass (name) { } \
595 void collect() override { delete this; } \
596 void export_to_scripter() override { } \
597 }; \
598 extern ScripterExport _cls##Class _cls##_class;

◆ invisible_class_instance

#define invisible_class_instance ( _cls,
_name )
Value:
ScripterExport _cls##Class _cls##_class (_M(_name));
600#define invisible_class_instance(_cls, _name) \
601 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:636

◆ is_pywrapperbase

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

◆ pywrapperbase_equal

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

◆ 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
425{ 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:371

◆ live_ptr()

Value * live_ptr ( Value * v)
inline
426{ 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:374

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