maxscript/maxwrapper/mxsmaterial.h File Reference
 
 
 
maxscript/maxwrapper/mxsmaterial.h File Reference
#include "mxsobjects.h"
#include "../macros/define_implementations.h"
#include "..\protocols\arrays.inl"
#include "..\protocols\textures.inl"

Defines

#define  is_materiallibrary(v)   ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(MAXMaterialLibrary))

Functions

  visible_class (MAXMaterial) class MAXMaterial
  visible_class (MAXMultiMaterial) class MAXMultiMaterial
  applyable_class (MAXMaterialLibrary) class MAXMaterialLibrary
  visible_class (MAXTexture) class MAXTexture
  visible_class (MAXMtlBase) class MAXMtlBase
  visible_class (MAXMeditMaterials) class MAXMeditMaterials

Variables

ScripterExport MAXMeditMaterials  medit_materials

Define Documentation

#define is_materiallibrary (   v )    ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(MAXMaterialLibrary))

Function Documentation

visible_class ( MAXMaterial  )

Define an equal operator (i.e. '==') for maxscript visible values.

Define a NOT equal operator (i.e. '!=') for maxscript visible values.

                  : public MAXWrapper
{
public:
        Mtl*            mat;                            /* the MAX-side material        */

                                MAXMaterial() {};
                                MAXMaterial(Mtl* imat);
        static ScripterExport Value* intern(Mtl* imat);

        static Value* make(MAXClass* cls, Value** arg_list, int count);

        BOOL            is_kind_of(ValueMetaClass* c) { return (c == class_tag(MAXMaterial)) ? 1 : MAXWrapper::is_kind_of(c); }
        void            collect();
        ScripterExport void sprin1(CharStream* s);
        const MCHAR*            class_name();

#include "../macros/define_implementations.h"
        Value*          copy_vf(Value** arg_list, int count) { return MAXWrapper::copy_no_undo(arg_list, count); }

        def_property   ( name );
        def_property   ( effectsChannel );
        def_property   ( showInViewport );
        Value*          get_property(Value** arg_list, int count);
        Value*          set_property(Value** arg_list, int count);

        Mtl*            to_mtl() { check_for_deletion(); return mat; }
        MtlBase*        to_mtlbase() { check_for_deletion(); return mat; }
        void            to_fpvalue(FPValue& v) { v.mtl = mat; v.type = TYPE_MTL; }
};
visible_class ( MAXMultiMaterial  )
                       : public MAXMaterial
{
public:

                                MAXMultiMaterial() {};
                                MAXMultiMaterial(MultiMtl* imat);
        static ScripterExport Value* intern(MultiMtl* imat);

        static Value* make(MAXClass* cls, Value** arg_list, int count);

        BOOL            is_kind_of(ValueMetaClass* c) { return (c == class_tag(MAXMultiMaterial)) ? 1 : MAXMaterial::is_kind_of(c); }
        void            collect();
        ScripterExport void sprin1(CharStream* s);
        const MCHAR*            class_name();

        def_generic (get, "get");
        def_generic (put, "put");
        Value*          copy_vf(Value** arg_list, int count) { return MAXWrapper::copy_no_undo(arg_list, count); }

        ScripterExport Value* map(node_map& m);

        def_property( numsubs );
        def_property( count );

        Mtl*            to_mtl() { return mat; }
        MtlBase*        to_mtlbase() { check_for_deletion(); return mat; }
        void            to_fpvalue(FPValue& v) { v.mtl = mat; v.type = TYPE_MTL; }
};
applyable_class ( MAXMaterialLibrary  )

Define an equal operator (i.e. '==') for maxscript visible values.

Define a NOT equal operator (i.e. '!=') for maxscript visible values.

                         : public MAXWrapper
{
public:
        MtlBaseLib      new_lib;
        MtlBaseLib&     lib;

                                MAXMaterialLibrary(MtlBaseLib& ilib);
                                MAXMaterialLibrary(MtlBaseLib* ilib);
                                MAXMaterialLibrary();
        static ScripterExport Value* intern(MtlBaseLib& ilib);
        static ScripterExport Value* intern(MtlBaseLib* ilib);
#       define          is_materiallibrary(v) ((DbgVerify(!is_sourcepositionwrapper(v)), (v))->tag == class_tag(MAXMaterialLibrary))

                                classof_methods (MAXMaterialLibrary, MAXWrapper);
        void            collect();
        ScripterExport void sprin1(CharStream* s);
        MtlBase*        get_mtlbase(int index);
        MtlBase*        find_mtlbase(const MCHAR* name);
        const MCHAR*            class_name();

        /* operations */
        
        ScripterExport Value* map(node_map& m);

#include "../macros/define_implementations.h"
#       include "..\protocols\arrays.inl"
        Value*          copy_vf(Value** arg_list, int count) { return MAXWrapper::copy_no_undo(arg_list, count); }

        /* built-in property accessors */

        def_property ( count );
};
visible_class ( MAXTexture  )

Define an equal operator (i.e. '==') for maxscript visible values.

Define a NOT equal operator (i.e. '!=') for maxscript visible values.

                 : public MAXWrapper
{
public:
        Texmap* map;                            /* the MAX-side map     */

                                MAXTexture(Texmap* imap);
        static ScripterExport Value* intern(Texmap* imap);

        static Value* make(MAXClass* cls, Value** arg_list, int count);

        BOOL            is_kind_of(ValueMetaClass* c) { return (c == class_tag(MAXTexture)) ? 1 : MAXWrapper::is_kind_of(c); }
        void            collect();
        ScripterExport void sprin1(CharStream* s);
        const MCHAR*            class_name();

#include "../macros/define_implementations.h"
#       include "..\protocols\textures.inl"
        Value*          copy_vf(Value** arg_list, int count) { return MAXWrapper::copy_no_undo(arg_list, count); }

        def_property( name );

        Texmap*         to_texmap() { check_for_deletion(); return map; }
        MtlBase*        to_mtlbase() { check_for_deletion(); return map; }
        void            to_fpvalue(FPValue& v) { v.tex = map; v.type = TYPE_TEXMAP; }
};
visible_class ( MAXMtlBase  )
                 : public MAXWrapper
{
public:
        MtlBase*        mtl;                            /* the MAX-side mtlbase */

                                MAXMtlBase(MtlBase* imtl);
        static ScripterExport Value* intern(MtlBase* imtl);

        static Value* make(MAXClass* cls, Value** arg_list, int count);

        BOOL            is_kind_of(ValueMetaClass* c) { return (c == class_tag(MAXMtlBase)) ? 1 : MAXWrapper::is_kind_of(c); }
        void            collect();
        ScripterExport void sprin1(CharStream* s);
        const MCHAR*            class_name() { return _M("MapSupportClass"); }
        Value*          copy_vf(Value** arg_list, int count) { return MAXWrapper::copy_no_undo(arg_list, count); }

        MtlBase*        to_mtlbase() { check_for_deletion(); return mtl; }
};
visible_class ( MAXMeditMaterials  )

Define an equal operator (i.e. '==') for maxscript visible values.

Define a NOT equal operator (i.e. '!=') for maxscript visible values.

                        : public MAXWrapper
{
public:
                                MAXMeditMaterials();

                                classof_methods (MAXMeditMaterials, MAXWrapper);
        void            collect();
        ScripterExport void sprin1(CharStream* s);
        MtlBase*        get_mtl(int index);
        MtlBase*        find_mtl(const MCHAR* name);
        static void setup();
        const MCHAR*            class_name();

        // operations
        ScripterExport Value* map(node_map& m);

#include "../macros/define_implementations.h"
#       include "..\protocols\arrays.inl"

        // built-in property accessors
        def_property ( count );
};

Variable Documentation

ScripterExport MAXMeditMaterials medit_materials