This reference page is linked to from the following overview topics:

#include "../ScripterExport.h"
#include "collectable.h"
#include "interupts.h"
#include "MAXScript_TLS.h"
#include "../macros/value_locals.h"
#include "MaxscriptTypedefs.h"
#include "../../matrix3.h"
#include "../../box2.h"
#include "../../acolor.h"
#include "../../interval.h"
#include "../../quat.h"
#include "../../ifnpub.h"
#include "../macros/define_external_functions.h"
#include "../protocols/corenames.inl"
#include "../macros/define_abstract_functions.h"
#include "../protocols/math.inl"
#include "../protocols/vector.inl"
#include "../protocols/matrix.inl"
#include "../protocols/quat.inl"
#include "../protocols/arrays.inl"
#include "../protocols/streams.inl"
#include "../protocols/strings.inl"
#include "../protocols/time.inl"
#include "../protocols/color.inl"
#include "../protocols/node.inl"
#include "../protocols/controller.inl"
#include "../protocols/primitives.inl"
#include "../protocols/generics.inl"
#include "../protocols/bitmaps.inl"
#include "../protocols/textures.inl"
#include "../protocols/atmospherics.inl"
#include "../protocols/cameratracker.inl"
#include "../protocols/bigmatrix.inl"
#include "../protocols/box.inl"
#include "../protocols/physiqueblend.inl"
#include "../protocols/physiquemod.inl"
#include "../protocols/biped.inl"
#include "../protocols/notekey.inl"
#include "../protocols/xrefs.inl"
#include "../protocols/kernel.inl"

Classes
class	Value

class	ValueMetaClass

class	Boolean

Macros
#define	def_generic(fn, name) ScripterExport virtual Value* fn##_vf(Value** arglist, int arg_count);

#define	is_valueclass(v) ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == (ValueMetaClass*)&value_metaclass)

#define	CHECK_ARG_COUNT(fn, w, g) if ((w) != (g)) throw ArgCountError (_M(#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) ScripterExport _cls##Class _cls##_class (_M(_name));

#define	invisible_class(_cls)

#define	invisible_class_instance(_cls, _name) ScripterExport _cls##Class _cls##_class (_M(_name));

#define	class_tag(_cls) &_cls##_class

#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_TAGS ((ValueMetaClass*)100L)

#define	is_sourcepositionwrapper(v) ((v)->tag == INTERNAL_SOURCEPOSWRAPPER_TAG)

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

Functions
Value *	heap_ptr (Value *v)

Value *	live_ptr (Value *v)

	visible_class_debug_ok (Value) visible_class_debug_ok(Boolean) class Boolean

	visible_class_debug_ok (Undefined) class Undefined

	classof_methods (Undefined, Value)

void	collect ()

ScripterExport void	sprin1 (CharStream *s)

Value *	copy_vf (Value **arg_list, int count)

IOResult	Save (ISave *isave)

static Value *	Load (ILoad iload, USHORT chunkID, ValueLoader vload)

Mtl *	to_mtl ()

void	to_fpvalue (FPValue &v)

	visible_class_debug_ok (Ok) class Ok

	classof_methods (Ok, Value)

	visible_class_debug_ok (Empty) class Empty

	classof_methods (Empty, Value)

	visible_class_debug_ok (Unsupplied) class Unsupplied

	classof_methods (Unsupplied, Value)

	visible_class_debug_ok (NoValue) class NoValue

	classof_methods (NoValue, Value)

virtual ScripterExport void	sprint (CharStream *stream)

Variables
ScripterExport Undefined	undefined

ScripterExport bool	dontThrowAccessorError

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

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

#define is_valueclass ( v ) ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == (ValueMetaClass*)&value_metaclass)

#define CHECK_ARG_COUNT	(	fn,
		w,
		g
	)	if ((w) != (g)) throw ArgCountError (_M(#fn), w, g)

#define classof_methods	(	_cls,
		_super
	)

Value:

Value* classOf_vf(Value** arg_list, int count)      \
    {                                                   \
		UNUSED_PARAM(arg_list);                           \
		CHECK_ARG_COUNT(classOf, 1, count + 1);           \
        return &_cls##_class;                           \
    }                                                   \
    Value* superClassOf_vf(Value** arg_list, int count) \
    {                                                   \
		UNUSED_PARAM(arg_list);                           \
		CHECK_ARG_COUNT(superClassOf, 1, count + 1);  \
        return &_super##_class;                         \
    }                                                   \
    Value* isKindOf_vf(Value** arg_list, int count)     \
    {                                                   \
		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)                  \
    {                                                   \
        return (c == &_cls##_class) ? 1                 \
                    : _super::is_kind_of(c);            \
    }

#define visible_class ( _cls )

Value:

class _cls##Class : public ValueMetaClass                           \
    {                                                                   \
    public:                                                             \
                    _cls##Class(const MCHAR* name) : ValueMetaClass (name) { }  \
		void      collect() { delete this; }                          \
    };                                                                  \
    extern ScripterExport _cls##Class _cls##_class;

#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() { delete this; }                          \
    };                                                                  \
    extern ScripterExport _cls##Class _cls##_class;

#define visible_class_s	(	_cls,
		_super
	)

Value:

class _cls##Class : public ValueMetaClass                           \
    {                                                                   \
    public:                                                             \
                    _cls##Class(const MCHAR* name) : ValueMetaClass (name) { }  \
		void      collect() { delete this; }                          \
        Value*      classOf_vf(Value** arg_list, int count)             \
        {                                                               \
			UNUSED_PARAM(arg_list);                                      \
			CHECK_ARG_COUNT(classOf, 1, count + 1);                      \
            return &_super##_class;                                     \
        }                                                               \
        Value*      superClassOf_vf(Value** arg_list, int count)        \
        {                                                               \
			UNUSED_PARAM(arg_list);                                      \
			UNUSED_PARAM(count);                                     \
            return _super##_class.classOf_vf(NULL, 0);                  \
        }                                                               \
    };                                                                  \
    extern ScripterExport _cls##Class _cls##_class;

#define applyable_class ( _cls )

Value:

class _cls##Class : public ValueMetaClass                           \
    {                                                                   \
    public:                                                             \
                    _cls##Class(const MCHAR* name) : ValueMetaClass (name) { }\
		void      collect() { delete this; }                          \
		ScripterExport Value* apply(Value** arglist, int count, CallContext* cc=NULL); \
    };                                                                  \
    extern ScripterExport _cls##Class _cls##_class;

#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() { delete this; }                          \
		ScripterExport Value* apply(Value** arglist, int count, CallContext* cc=NULL); \
    };                                                                  \
    extern ScripterExport _cls##Class _cls##_class;

#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)             \
        {                                                               \
			UNUSED_PARAM(arg_list);                                      \
			CHECK_ARG_COUNT(classOf, 1, count + 1);                      \
            return &_super##_class;                                     \
        }                                                               \
        Value*      superClassOf_vf(Value** arg_list, int count)        \
        {                                                               \
			UNUSED_PARAM(arg_list);                                      \
			UNUSED_PARAM(count);                                     \
            return _super##_class.classOf_vf(NULL, 0);                  \
        }                                                               \
		void      collect() { delete this; }                          \
		ScripterExport Value* apply(Value** arglist, int count, CallContext* cc=NULL); \
    };                                                                  \
    extern ScripterExport _cls##Class _cls##_class;

#define visible_class_instance	(	_cls,
		_name
	)	ScripterExport _cls##Class _cls##_class (_M(_name));

#define invisible_class ( _cls )

Value:

class _cls##Class : public ValueMetaClass                           \
    {                                                                   \
    public:                                                             \
                    _cls##Class(const MCHAR* name) : ValueMetaClass (name) { }  \
		void      collect() { delete this; }                          \
		void      export_to_scripter() { }                            \
    };                                                                  \
    extern ScripterExport _cls##Class _cls##_class;

#define invisible_class_instance	(	_cls,
		_name
	)	ScripterExport _cls##Class _cls##_class (_M(_name));

#define class_tag ( _cls ) &_cls##_class

#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_TAGS ((ValueMetaClass*)100L)

#define is_sourcepositionwrapper ( v ) ((v)->tag == INTERNAL_SOURCEPOSWRAPPER_TAG)

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

Function Documentation

Value* heap_ptr ( Value * v )

inline

274 { return v ? v->get_heap_ptr() : NULL; } // ensure v is in heap, migrate if not, return heap pointer

NULL

#define NULL

Definition: autoptr.h:20

Value::get_heap_ptr

ScripterExport Value * get_heap_ptr()

Definition: value.h:267

Value* live_ptr ( Value * v )

inline

275 { 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:270

visible_class_debug_ok ( Value )

visible_class_debug_ok ( Undefined )

                 : public Value
 {
 public:
             Undefined() { tag = &Undefined_class; }

classof_methods	(	Undefined	,
		Value
	)

void collect ( )

ScripterExport void sprin1 ( CharStream * s )

351 { s->printf(_M("LabelControl:%s"), name->to_string()); }

name

Value * name

Definition: structs.h:25

_M

#define _M(x)

Used to wrap string literals.

Definition: strbasic.h:122

Value::to_string

virtual const MCHAR * to_string()

Definition: value.h:171

Value * copy_vf	(	Value **	arg_list,
		int	count
	)

525 { return this; }

IOResult Save ( ISave * isave )

static Value * Load	(	ILoad *	iload,
		USHORT	chunkID,
		ValueLoader *	vload
	)

static

Mtl* to_mtl ( )

530 { return NULL; } // undefined is a NULL material

NULL

#define NULL

Definition: autoptr.h:20

void to_fpvalue ( FPValue & v )

467 { v.iobj = iobj; v.type = TYPE_IOBJECT; }

TYPE_IOBJECT

Definition: paramtype.h:95

FPValue::iobj

IObject * iobj

Definition: ifnpub.h:1193

FPValue::type

ParamType2 type

Definition: ifnpub.h:1152

visible_class_debug_ok ( Ok )

          : public Value
 {
 public:
             Ok() { tag = &Ok_class; }

classof_methods	(	Ok	,
		Value
	)

visible_class_debug_ok ( Empty )

             : public Value
 {
 public:
             Empty() { tag = &Empty_class; }

classof_methods	(	Empty	,
		Value
	)

visible_class_debug_ok ( Unsupplied )

                  : public Value
 {
 public:
             Unsupplied() { tag = &Unsupplied_class; }

classof_methods	(	Unsupplied	,
		Value
	)

visible_class_debug_ok ( NoValue )

               : public Value
 {
 public:
     NoValue() { tag = &NoValue_class; }

classof_methods	(	NoValue	,
		Value
	)

virtual ScripterExport void sprint ( CharStream * stream )

virtual

Variable Documentation

ScripterExport Undefined undefined

ScripterExport bool dontThrowAccessorError

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

maxscript/kernel/value.h File Reference

Classes

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation