SimplygonSDK.h

Go to the documentation of this file.

#ifndef _SIMPLYGONSDK_H_
#define _SIMPLYGONSDK_H_
 
#include <string.h>
 
#include <stdint.h>
 
#define SIMPLYGONSDK_VERSION 0x0803
 
#ifdef SGDEPRECATED
#undef SGDEPRECATED
#endif
#ifdef _WIN32
#pragma warning( push )
#pragma warning( disable : 4996 )
#endif
 
#if defined(SGSDK) || defined(WITH_SIMPLYGON_DLL) || defined(SGDEPRECATED_OFF)
// internal Simplygon, Unreal Engine, or deprecation warning disabled
#define SGDEPRECATED 
#else
#ifdef _WIN32 // Microsoft compiler
#if (_MSC_VER >= 1300) // 7.1
#define SGDEPRECATED __declspec(deprecated)
#else
#define SGDEPRECATED
#endif
#else
#define SGDEPRECATED
#endif
#endif
        
namespace SimplygonSDK
{
 
    template <class T> class CountedPointer
                {
                public:
                        CountedPointer( T *p=NULL ) : ptr(p)
                                {
                                addref_ptr();
                                }
                                
                        CountedPointer( const CountedPointer<T> &p ) : ptr(p.ptr)
                                {
                                addref_ptr();
                                }
                                
                        ~CountedPointer()
                                {
                                release_ptr();
                                }
                
                        bool IsNull() const
                                {
                                return (ptr == NULL);
                                }
                                
                        CountedPointer<T>& operator=( const CountedPointer<T> &p ) 
                                {
                                if( this != &p ) 
                                        {
                                        release_ptr();
                                        ptr = p.ptr;
                                        addref_ptr();
                                        }
                                return *this;
                                }
 
                    T& operator*() const 
                                {
                        return *ptr;
                                }
                                
                    T* operator->() const 
                                {
                        return ptr;
                                }
                                                                
                        operator T* () const
                                {
                                return ptr;
                                }
                                
                        T* GetPointer() const
                                {
                                return ptr;
                                }
                                
                private:
                        void addref_ptr()
                                {
                                if( ptr!=NULL )
                                        {
                                        ptr->AddRef();
                                        }
                                }
                
                        void release_ptr()
                                {
                                if( ptr!=NULL )
                                        {
                                        ptr->Release();
                                        ptr = NULL;
                                        }
                                }
                
                        T *ptr; 
            };
 
        class IObject;
        
        typedef void* rhandle;
        
        typedef int rid;
 
        typedef float real;
                        
        const real REAL_MIN = 1.175494351e-38F;
        const real REAL_MAX = 3.402823466e+38F;
 
        class robserver
                {
                public:
                        virtual void Execute( IObject *subject , rid EventId , void *EventParameterBlock , unsigned int EventParameterBlockSize ) = 0;  
                };
 
        class rerrorhandler
                {
                public:
                        virtual void HandleError( IObject *object , const char *interfacename , const char *methodname , rid errortype , const char *errortext ) = 0;
                };
 
        class IData
                {
                public:
                        virtual void AddRef() = 0;
                        virtual void Release() = 0;
                        virtual void _SetItemCount( unsigned int size ) = 0;
                        virtual unsigned int _GetItemCount() const = 0;
            virtual void *_GetRawPointer() = 0;
                };
 
        template<class I> class rdata 
                {
                public:
                        typedef typename I::value_type value_type;
 
                        rdata( I *p=NULL ) : ptr(p)
                                {
                                addref_ptr();
                                }
                                
                        rdata( const rdata<I> &p ) : ptr(p.ptr)
                                {
                                addref_ptr();
                                }
                                
                        ~rdata()
                                {
                                release_ptr();
                                }
                
                        bool IsNullOrEmpty() const
                                {
                if( ptr == nullptr )
                    return true;
                if( ptr->_GetItemCount() == 0)
                    return true;
                return false;
                }
                                                
                        rdata<I>& operator=( const rdata<I> &p ) 
                                {
                                if( this != &p ) 
                                        {
                                        release_ptr();
                                        ptr = p.ptr;
                                        addref_ptr();
                                        }
                                return *this;
                                }
 
                        const value_type *Data() const
                                {
                if( this->IsNullOrEmpty() )
                    return nullptr;
                                return this->ptr->_GetData();
                                }
 
                        operator const value_type *() const
                                {
                                if( this->IsNullOrEmpty() )
                    return nullptr;
                                return this->ptr->_GetData();
                                }
 
                        unsigned int GetItemCount() const
                                {
                if( this->IsNullOrEmpty() )
                    return 0;
                                return this->ptr->_GetItemCount();
                                }
 
                        const value_type& GetItem( rid index ) const
                                {
                                return this->ptr->_GetItem(index);
                                }
 
                        const value_type& operator [] ( rid index ) const
                                {
                                return this->GetItem( index );
                                }
                                                
                        operator I* () const
                                {
                                return ptr;
                                }
        
                        I* GetPointer() const
                                {
                                return ptr;
                                }
 
                    I* operator->() const 
                                {
                        return ptr;
                                }
 
        private:
                        void addref_ptr()
                                {
                                if( ptr!=NULL )
                                        {
                                        ptr->AddRef();
                                        }
                                }
                
                        void release_ptr()
                                {
                                if( ptr!=NULL )
                                        {
                                        ptr->Release();
                                        ptr = NULL;
                                        }
                                }
                
                        I *ptr; 
                };
 
 
        class IString
                {
                protected:
                        char *Text; // the text of the string (warning: never modify this pointer directly)
 
                public:
            IString() { this->Text = nullptr; }
 
                        virtual void AddRef() = 0;
                        virtual void Release() = 0;
                        virtual const char *_GetText() const = 0;
                        virtual bool _IsEmpty() const = 0;
                };
        
        class rstring 
                {
                public:
                        rstring( IString *p=nullptr ) : ptr(p)
                                {
                                addref_ptr();
                                }
                                
                        rstring( const rstring &p ) : ptr(p.ptr)
                                {
                                addref_ptr();
                                }
                                
                        ~rstring()
                                {
                                release_ptr();
                                }
                                                                
                        rstring& operator=( const rstring &p ) 
                                {
                                if( this != &p ) 
                                        {
                                        release_ptr();
                                        ptr = p.ptr;
                                        addref_ptr();
                                        }
                                return *this;
                                }
 
                        const char *GetText() const
                                {
                if( ptr == nullptr )
                    return nullptr;
                return ptr->_GetText();
                                }
 
                        operator const char *() const
                                {
                                return this->GetText();
                                }
                                
                        bool IsEmpty() const 
                                {
                                if( ptr == nullptr )
                    return true;
                                return ptr->_IsEmpty();
                                }
 
                        bool IsNull() const 
                                {
                                if( ptr == nullptr )
                    return true;
                                return false;
                                }
               
                    IString* operator->() const 
                                {
                        return ptr;
                                }
 
        private:
                        void addref_ptr()
                                {
                                if( ptr!=NULL )
                                        {
                                        ptr->AddRef();
                                        }
                                }
                
                        void release_ptr()
                                {
                                if( ptr!=NULL )
                                        {
                                        ptr->Release();
                                        ptr = NULL;
                                        }
                                }
                
                        IString *ptr;                           
                };
        class IBoolData : public IData
                {
                protected:
                        bool *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef bool value_type;
                        IBoolData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const bool *_GetData() const = 0;
                        virtual const bool & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IBoolData> spBoolData;
 
        class ICharData : public IData
                {
                protected:
                        char *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef char value_type;
                        ICharData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const char *_GetData() const = 0;
                        virtual const char & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<ICharData> spCharData;
 
        class IUnsignedCharData : public IData
                {
                protected:
                        unsigned char *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef unsigned char value_type;
                        IUnsignedCharData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const unsigned char *_GetData() const = 0;
                        virtual const unsigned char & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IUnsignedCharData> spUnsignedCharData;
 
        class IShortData : public IData
                {
                protected:
                        short *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef short value_type;
                        IShortData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const short *_GetData() const = 0;
                        virtual const short & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IShortData> spShortData;
 
        class IUnsignedShortData : public IData
                {
                protected:
                        unsigned short *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef unsigned short value_type;
                        IUnsignedShortData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const unsigned short *_GetData() const = 0;
                        virtual const unsigned short & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IUnsignedShortData> spUnsignedShortData;
 
        class IIntData : public IData
                {
                protected:
                        int *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef int value_type;
                        IIntData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const int *_GetData() const = 0;
                        virtual const int & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IIntData> spIntData;
 
        class IUnsignedIntData : public IData
                {
                protected:
                        unsigned int *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef unsigned int value_type;
                        IUnsignedIntData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const unsigned int *_GetData() const = 0;
                        virtual const unsigned int & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IUnsignedIntData> spUnsignedIntData;
 
        class ILongData : public IData
                {
                protected:
                        long *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef long value_type;
                        ILongData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const long *_GetData() const = 0;
                        virtual const long & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<ILongData> spLongData;
 
        class IUnsignedLongData : public IData
                {
                protected:
                        unsigned long *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef unsigned long value_type;
                        IUnsignedLongData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const unsigned long *_GetData() const = 0;
                        virtual const unsigned long & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IUnsignedLongData> spUnsignedLongData;
 
        class IFloatData : public IData
                {
                protected:
                        float *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef float value_type;
                        IFloatData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const float *_GetData() const = 0;
                        virtual const float & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IFloatData> spFloatData;
 
        class IDoubleData : public IData
                {
                protected:
                        double *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef double value_type;
                        IDoubleData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const double *_GetData() const = 0;
                        virtual const double & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IDoubleData> spDoubleData;
 
        class IRealData : public IData
                {
                protected:
                        real *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef real value_type;
                        IRealData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const real *_GetData() const = 0;
                        virtual const real & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IRealData> spRealData;
 
        class IRidData : public IData
                {
                protected:
                        rid *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef rid value_type;
                        IRidData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const rid *_GetData() const = 0;
                        virtual const rid & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IRidData> spRidData;
 
        class IRhandleData : public IData
                {
                protected:
                        rhandle *Data; // the data pointer. only use the pointer for debugging purposes
                        unsigned int DataCount; // the number of items. only use the pointer for debugging purposes
                        unsigned int DataAllocation; // the number of allocated items. only use the pointer for debugging purposes
                                                                                                                
                        int RefCount; // the reference count. only use for debugging purposes
                
                public:
                        typedef rhandle value_type;
                        IRhandleData()
                        {
                            this->Data = nullptr;
                            this->DataCount = 0;
                            this->DataAllocation = 0;
                            this->RefCount = 0;
                        }
           
                        virtual const rhandle *_GetData() const = 0;
                        virtual const rhandle & _GetItem( rid item_index ) const = 0;
                };
                                                                                                                        
        typedef rdata<IRhandleData> spRhandleData;
 
 
        enum BaseTypes
        {
                TYPES_ID_BOOL = 1,
                TYPES_ID_CHAR = 2,
                TYPES_ID_UCHAR = 3,
                TYPES_ID_SHORT = 4,
                TYPES_ID_USHORT = 5,
                TYPES_ID_INT = 6,
                TYPES_ID_UINT = 7,
                TYPES_ID_LONG = 8,
                TYPES_ID_ULONG = 9,
                TYPES_ID_FLOAT = 10,
                TYPES_ID_DOUBLE = 11,
                TYPES_ID_REAL = 12,
                TYPES_ID_RID = 13,
                TYPES_ID_RCHAR = 14, // note: TYPES_ID_RCHAR is deprecated and not used anymore
                TYPES_ID_RHANDLE = 15,
                TYPES_ID_STRING = 16,
                TYPES_ID_OBJECT = 17
        };
 
        enum EventCodes
        {
                SG_EVENT_PROGRESS = 0x01000001,
 
                SG_EVENT_PROCESS_STARTED = 0x01000002,
 
                SG_EVENT_CUSTOM_NODE_EVALUATE = 0x00000001,
 
                SG_EVENT_CUSTOM_NODE_GENERATE_SHADER_CODE = 0x00000002
        };
 
        enum ErrorCodes
        {
                SG_ERROR_NOERROR = 0,
 
                SG_ERROR_NOLICENSE = -1,
 
                SG_ERROR_NOTINITIALIZED = -2,
 
                SG_ERROR_ALREADYINITIALIZED = -3,
 
                SG_ERROR_FILENOTFOUND = -4,
 
                SG_ERROR_INVALIDPARAM = -5,
 
                SG_ERROR_FAILEDTESTING = -6,
 
                SG_ERROR_WRONGVERSION = -7,
 
                SG_ERROR_LOADFAILED = -8,
 
                SG_ERROR_LICENSE_WRONGAPPLICATION = -9,
 
                SG_ERROR_LICENSE_WRONGPLATFORM = -10,
 
                SG_ERROR_LICENSE_WRONGVERSION = -11,
 
                SG_ERROR_FAILEDLOOKUP = -10001,
 
                SG_ERROR_FAILEDCONTACT = -10002,
 
                SG_ERROR_FAILEDSEND = -10003,
 
                SG_ERROR_FAILEDRCV = -10004,
 
                SG_ERROR_CORRUPTED = -10005,
 
                SG_ERROR_EXPIRED = -10006,
 
                SG_ERROR_INVALIDLICENSE = -10007,
 
                SG_ERROR_WRONGLICENSE = -10008,
 
                SG_ERROR_NONWCARD = -10009,
 
                SG_ERROR_DECODEFAILED = -10010,
 
                SG_ERROR_WRONGMACHINE = -10011,
 
                SG_ERROR_DECODEFAILED2 = -10012,
 
                SG_ERROR_DECODEFAILED3 = -10013,
 
                SG_ERROR_INVALIDLICENSE2 = -10014,
 
                SG_ERROR_EXPIRED2 = -10015,
 
                SG_ERROR_INVALID_LICENSE2 = -10016,
 
                SG_ERROR_WRONG_LICENSE2 = -10017,
 
                SG_ERROR_NO_NWCARD = -10018,
 
                SG_ERROR_DECODE_FAILED = -10019,
 
                SG_ERROR_WRONG_MACHINE2 = -10020,
 
                SG_ERROR_DECODEFAILED4 = -10021,
 
                SG_ERROR_DECODEFAILED5 = -10022,
 
                SG_ERROR_INVALIDLICENSE3 = -10023,
 
                SG_ERROR_INVALIDWINDOWSVERSION = -10024,
 
                SG_ERROR_LICENSE_BADREQUEST = -10400,
 
                SG_ERROR_LICENSE_UNKNOWNLICENSE = -10404,
 
                SG_ERROR_LICENSE_INACTIVE = -10410,
 
                SG_ERROR_LICENSE_NODECONFLICT = -10409,
 
                SG_ERROR_LICENSE_UPGRADEREQUIRED = -10426,
 
                SG_ERROR_LICENSE_BADREQUEST2 = -10501
        };
 
        enum GeometryValidationCodes
        {
                SG_VALIDATIONERROR_NOERROR = 0x00000000,
 
                SG_VALIDATIONERROR_NAN_FLOAT = 0x00000001,
 
                SG_VALIDATIONERROR_ILLEGAL_TRIANGLECOUNT = 0x00000002,
 
                SG_VALIDATIONERROR_ILLEGAL_VERTEXCOUNT = 0x00000004,
 
                SG_VALIDATIONERROR_ILLEGAL_INDICES = 0x00000008,
 
                SG_VALIDATIONERROR_ILLEGAL_TRIANGLE = 0x00000010,
 
                SG_VALIDATIONERROR_ILLEGAL_FIELD_ITEMCOUNT = 0x00000020,
 
                SG_VALIDATIONERROR_ILLEGAL_FIELD_TUPLECOUNT = 0x00000040,
 
                SG_VALIDATIONERROR_ILLEGAL_FIELD_TUPLESIZE = 0x00000080,
 
                SG_VALIDATIONERROR_ILLEGAL_FIELD_ITEMVALUE = 0x00000100,
 
                SG_VALIDATIONERROR_ZEROAREA_TRIANGLE = 0x00000200,
 
                SG_VALIDATIONERROR_ILLEGAL_BONETUPLESIZE = 0x00000400,
 
                SG_VALIDATIONERROR_MISSING_OBJECT = 0x00000800,
 
                SG_VALIDATIONERROR_ILLEGAL_BONE = 0x00001000,
 
                SG_VALIDATIONERROR_ZERO_LENGTH_NORMAL = 0x00002000,
 
                SG_VALIDATIONERROR_LARGE_FLOAT = 0x00004000,
 
                SG_VALIDATIONERROR_DENORMAL_FLOAT = 0x00008000,
 
                SG_VALIDATIONERROR_ILLEGAL_SCENE_NODE_GUID = 0x00010000
        };
 
        enum ReductionTargets
        {
                SG_REDUCTIONTARGET_TRIANGLECOUNT = 0x00000001,
 
                SG_REDUCTIONTARGET_TRIANGLERATIO = 0x00000002,
 
                SG_REDUCTIONTARGET_MAXDEVIATION = 0x00000004,
 
                SG_REDUCTIONTARGET_ONSCREENSIZE = 0x00000008,
 
                SG_REDUCTIONTARGET_ALL = 0x0000000F
        };
 
        enum StopCondition
        {
                SG_STOPCONDITION_ANY = 0x00000000,
 
                SG_STOPCONDITION_ALL = 0x00000001
        };
 
        enum ReductionHeuristics
        {
                SG_REDUCTIONHEURISTICS_FAST = 0x00000000,
 
                SG_REDUCTIONHEURISTICS_CONSISTENT = 0x00000001
        };
 
        enum DataCreationPreferences
        {
                SG_DATACREATIONPREFERENCES_ONLY_USE_ORIGINAL_DATA = 0x00000000,
 
                SG_DATACREATIONPREFERENCES_PREFER_ORIGINAL_DATA = 0x00000001,
 
                SG_DATACREATIONPREFERENCES_PREFER_OPTIMIZED_RESULT = 0x00000002
        };
 
        enum RemeshingSurfaceTransferMode
        {
                SG_SURFACETRANSFER_FAST = 0x00000000,
 
                SG_SURFACETRANSFER_ACCURATE = 0x00000001
        };
 
        enum ProcessingMode
        {
                SG_MODE_FAST = 0x00000000,
 
                SG_MODE_ACCURATE = 0x00000001
        };
 
        enum AtlasFillMode
        {
                SG_ATLASFILLMODE_INTERPOLATE = 0x00000000,
 
                SG_ATLASFILLMODE_NEARESTNEIGHBOR = 0x00000001,
 
                SG_ATLASFILLMODE_NONE = 0x00000002
        };
 
        enum BoneReductionTargets
        {
                SG_BONEREDUCTIONTARGET_BONECOUNT = 0x00000001,
 
                SG_BONEREDUCTIONTARGET_BONERATIO = 0x00000002,
 
                SG_BONEREDUCTIONTARGET_MAXDEVIATION = 0x00000004,
 
                SG_BONEREDUCTIONTARGET_ONSCREENSIZE = 0x00000008,
 
                SG_BONEREDUCTIONTARGET_ALL = 0x0000000F
        };
 
        enum DitherPatterns
        {
                SG_DITHERPATTERNS_NO_DITHER = 0x00000000,
 
                SG_DITHERPATTERNS_FLOYDSTEINBERG = 0x00000001,
 
                SG_DITHERPATTERNS_JARVISJUDICENINKE = 0x00000002,
 
                SG_DITHERPATTERNS_SIERRA = 0x00000003
        };
 
        enum OcclusionModes
        {
                SG_OCCLUSIONMODE_OCCLUDER = 0x00000000,
 
                SG_OCCLUSIONMODE_OCCLUDEE = 0x00000001,
 
                SG_OCCLUSIONMODE_STANDARD = 0x00000002
        };
 
        enum TangentSpaceMethod
        {
                SG_TANGENTSPACEMETHOD_ORTHONORMAL = 0x00000000,
 
                SG_TANGENTSPACEMETHOD_3DSMAX = 0x00000001,
 
                SG_TANGENTSPACEMETHOD_ORTHONORMAL_LEFTHANDED = 0x00000002
        };
 
        enum ValidationFrequency
        {
                SG_VALIDATIONFREQUENCY_NORMAL = 0x00000000,
 
                SG_VALIDATIONFREQUENCY_CORE = 0x00000001,
 
                SG_VALIDATIONFREQUENCY_ULTRA = 0x00000002
        };
 
        enum TextureBlendType
        {
                SG_TEXTUREBLEND_REPLACE = 0x00000000,
 
                SG_TEXTUREBLEND_ADD = 0x00000001,
 
                SG_TEXTUREBLEND_SUBTRACT = 0x00000002,
 
                SG_TEXTUREBLEND_MULTIPLY = 0x00000003,
 
                SG_TEXTUREBLEND_ALPHA = 0x00000004,
 
                SG_TEXTUREBLEND_PRE_MULTIPLIED_ALPHA = 0x00000005,
 
                SG_TEXTUREBLEND_OVER = 0x00000006,
 
                SG_TEXTUREBLEND_IN = 0x00000007,
 
                SG_TEXTUREBLEND_OUT = 0x00000008,
 
                SG_TEXTUREBLEND_ADD_W_ALPHA = 0x00000009,
 
                SG_TEXTUREBLEND_SUBTRACT_W_ALPHA = 0x0000000A,
 
                SG_TEXTUREBLEND_MULTIPLY_W_ALPHA = 0x0000000B
        };
 
        enum TextureWrapMode
        {
                SG_TEXTUREWRAPMODE_WRAP = 0x00000000,
 
                SG_TEXTUREWRAPMODE_CLAMP = 0x00000001,
 
                SG_TEXTUREWRAPMODE_MIRROR = 0x00000002
        };
 
        enum ImageFileType
        {
                SG_IMAGEFILETYPE_UNSUPPORTED = -1,
 
                SG_IMAGEFILETYPE_BMP = 0,
 
                SG_IMAGEFILETYPE_DDS = 1,
 
                SG_IMAGEFILETYPE_GIF = 2,
 
                SG_IMAGEFILETYPE_JPEG = 3,
 
                SG_IMAGEFILETYPE_PNG = 4,
 
                SG_IMAGEFILETYPE_TGA = 5,
 
                SG_IMAGEFILETYPE_TIFF = 6,
 
                SG_IMAGEFILETYPE_PSD = 7
        };
 
        enum TexcoordGeneratorType
        {
                SG_TEXCOORDGENERATORTYPE_PARAMETERIZER = 0x00000000,
 
                SG_TEXCOORDGENERATORTYPE_CHARTAGGREGATOR = 0x00000001,
 
                SG_TEXCOORDGENERATORTYPE_PARAMETERIZER_OLD = 0x00000002,
 
                SG_TEXCOORDGENERATORTYPE_PARAMETERIZER_8_1 = 0x00000000
        };
 
        enum ChartAggregatorMode
        {
                SG_CHARTAGGREGATORMODE_TEXTURESIZEPROPORTIONS = 0x00000000,
 
                SG_CHARTAGGREGATORMODE_SURFACEAREA = 0x00000001,
 
                SG_CHARTAGGREGATORMODE_ORIGINALPIXELDENSITY = 0x00000002,
 
                SG_CHARTAGGREGATORMODE_UVSIZEPROPORTIONS = 0x00000003
        };
 
        enum FlipFacesAndNormals
        {
                SG_FLIPFACESANDNORMALS_NONE = 0x00000000,
 
                SG_FLIPFACESANDNORMALS_AUTOMATIC = 0x00000001,
 
                SG_FLIPFACESANDNORMALS_MAKEDOUBLESIDED = 0x00000002,
 
                SG_FLIPFACESANDNORMALS_INVERTFACES = 0x00000003,
 
                SG_FLIPFACESANDNORMALS_INVERTNORMALS = 0x00000004,
 
                SG_FLIPFACESANDNORMALS_INVERTFACESANDNORMALS = 0x00000005
        };
 
        enum FoliageType
        {
                SG_FOLIAGETYPE_BILLBOARDS = 0x00000000,
 
                SG_FOLIAGETYPE_FLIPBOOK = 0x00000001
        };
 
        enum CameraType
        {
                SG_CAMERATYPE_PERSPECTIVE = 0x00000000,
 
                SG_CAMERATYPE_ORTHOGRAPHIC = 0x00000001,
 
                SG_CAMERATYPE_OMNIDIRECTIONAL = 0x00000002
        };
 
        enum ComputeVisibilityMode
        {
                SG_COMPUTE_VISIBILITY_MODE_DIRECTX = 0x00000000,
 
                SG_COMPUTE_VISIBILITY_MODE_SOFTWARE = 0x00000001
        };
 
        enum MaterialType
        {
                SG_MATERIALTYPE_STANDARD = 0x00000000,
 
                SG_MATERIALTYPE_FLIPBOOK = 0x00000001,
 
                SG_MATERIALTYPE_BILLBOARDCLOUD = 0x00000002
        };
 
        enum SettingValueType
        {
                SG_SETTINGVALUETYPE_INVALID = 0x00000000,
 
                SG_SETTINGVALUETYPE_BOOL = 0x00000001,
 
                SG_SETTINGVALUETYPE_INT = 0x00000002,
 
                SG_SETTINGVALUETYPE_UINT = 0x00000003,
 
                SG_SETTINGVALUETYPE_DOUBLE = 0x00000004,
 
                SG_SETTINGVALUETYPE_STRING = 0x00000005
        };
 
        static const char * SG_MATERIAL_CHANNEL_AMBIENT = "Ambient";
 
        static const char * SG_MATERIAL_CHANNEL_DIFFUSE = "Diffuse";
 
        static const char * SG_MATERIAL_CHANNEL_SPECULAR = "Specular";
 
        static const char * SG_MATERIAL_CHANNEL_SHININESS = "Shininess";
 
        static const char * SG_MATERIAL_CHANNEL_OPACITY = "Opacity";
 
        static const char * SG_MATERIAL_CHANNEL_EMISSIVE = "Emissive";
 
        static const char * SG_MATERIAL_CHANNEL_NORMALS = "Normals";
 
        static const char * SG_MATERIAL_CHANNEL_GROUPIDS = "GroupIds";
 
        static const char * SG_MATERIAL_CHANNEL_DISPLACEMENT = "Displacement";
 
        static const char * SG_MATERIAL_CHANNEL_BASECOLOR = "Basecolor";
 
        static const char * SG_MATERIAL_CHANNEL_ROUGHNESS = "Roughness";
 
        static const char * SG_MATERIAL_CHANNEL_METALNESS = "Metalness";
 
        static const char * SG_MATERIAL_CHANNEL_OCCLUSION = "Occlusion";
 
        static const char * SG_IMAGEDATA_FORMAT_L = "L";
 
        static const char * SG_IMAGEDATA_FORMAT_RGB = "RGB";
 
        static const char * SG_IMAGEDATA_FORMAT_RGBA = "RGBA";
 
        static const unsigned int SG_NUM_SUPPORTED_TEXTURE_CHANNELS = 256;
 
        static const unsigned int SG_NUM_SUPPORTED_COLOR_CHANNELS = 256;
 
        static const unsigned int SG_NUM_SUPPORTED_BONES_PER_VERTEX = 16;
 
        static const unsigned int SG_NUM_SUPPORTED_MAPPING_LAYERS = 32;
 
        static const unsigned int SG_NUM_SUPPORTED_CUSTOM_NODE_INPUTS = 16;
 
        static const unsigned int SG_SUPPORTED_CUSTOM_NODE_SHADER_CODE_SIZE = 2048;
 
        static const float SG_MAXIMUM_IMPORTANCE_VALUE = (float)1000;
 
        static const unsigned int SG_MAXIMUM_MAPPING_IMAGE_INPUT_MATERIAL_COUNT = 1024;
 
        static const unsigned int SG_MAXIMUM_MAPPING_IMAGE_OUTPUT_MATERIAL_COUNT = 1024;
 
        static const unsigned int SG_MAXIMUM_PARAMETERIZER_OUTPUT_MATERIAL_COUNT = 1024;
 
        static const unsigned int SG_MAXIMUM_CHART_AGGREGATOR_OUTPUT_MATERIAL_COUNT = 1024;
 
 
        class IObject
        {
        public:
                virtual const char *GetClass();
                
                virtual bool IsA( const char *type ) const;
                
                static bool IsClassA( const char *type )
                        {
                        if( type && (strcmp("IObject",type)==0) )
                                return true;
                        return false;
                        }
                        
                static IObject *SafeCast( IObject *ptr ) { return ptr; }
 
                virtual void PrintInfo() = 0;
 
                virtual void AddRef() = 0;
 
                virtual void Release() = 0;
                
                virtual void SetName( const char *Name ) = 0;
                
                virtual rstring GetName() = 0;
        
                virtual rid AddObserver( robserver *Observer , rid EventId ) = 0;
                
                virtual void RemoveObserver( rid ObserverId ) = 0;
 
                virtual void *GetUserComponentArea( rid userid ) = 0;
        };
 
        typedef CountedPointer<IObject> spObject;
 
        class IRidArray;
 
        class IArray : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IArray",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IArray") )
                                return static_cast<IArray*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IArray> NewCopy( bool copy_data ) = 0;
 
                virtual CountedPointer<IArray> NewPackedCopy( IRidArray *index_array ) = 0;
 
                virtual void DeepCopy( IArray *source ) = 0;
 
                virtual void IndexedCopy( IArray *source , IRidArray *idtable , rid startId ) = 0;
 
                virtual void SetTupleSize( unsigned int newsize ) = 0;
 
                virtual unsigned int GetTupleSize(  ) = 0;
 
                virtual void SetItemCount( unsigned int count ) = 0;
 
                virtual unsigned int GetItemCount(  ) = 0;
 
                virtual rid GetMaxItemId(  ) = 0;
 
                virtual void Clear(  ) = 0;
 
                virtual bool IsEmpty(  ) = 0;
 
                virtual unsigned int GetTupleCount(  ) = 0;
 
                virtual rid GetMaxTupleId(  ) = 0;
 
                virtual void SetTupleCount( unsigned int tuplecount ) = 0;
 
                virtual rid GetBaseType(  ) = 0;
 
                virtual SGDEPRECATED void AppendTuples( IArray *source ) = 0;
 
                virtual void AppendArray( IArray *source ) = 0;
 
                virtual void ExtractTuples( IArray *dest , rid start , unsigned int count ) = 0;
 
                virtual void CopyTuple( IArray *sourceArray , rid dest_id , rid src_id ) = 0;
 
                virtual int CompareTuples( IArray *otherArray , rid tuple_id , rid other_tuple_id ) = 0;
 
                virtual void CopyRange( IArray *source_array , rid start_dest_id , rid start_src_id , unsigned int count ) = 0;
 
                virtual void SetAlternativeName( const char * value ) = 0;
 
                virtual rstring GetAlternativeName(  ) = 0;
 
        };
 
        typedef CountedPointer<IArray> spArray;
 
        #define InterfaceDefined_SimplygonSDK_IArray 1
 
        class IRidArray;
        class IRealArray;
 
        class IValueArray : public IArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IValueArray",type)==0 )
                                return true;
                        return IArray::IsClassA(type);
                        }
                static IValueArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IValueArray") )
                                return static_cast<IValueArray*>(ptr);
                        return NULL;
                        }
 
                virtual void SetRealItem( rid id , real value ) = 0;
 
                virtual real GetRealItem( rid id ) = 0;
 
                virtual SGDEPRECATED void IndexedCombine( IValueArray *source , IRidArray *idtable , IRealArray *blendtable , rid startId ) = 0;
 
                virtual SGDEPRECATED void IndexedCombine3( IValueArray *source , IRidArray *idtable , IRealArray *blendtable , rid startId ) = 0;
 
                virtual SGDEPRECATED void CopyCombineTuples( IValueArray *sourceArray , rid dest_id , rid src_id_1 , rid src_id_2 , real alpha ) = 0;
 
                virtual SGDEPRECATED void CopyCombine3Tuples( IValueArray *sourceArray , rid dest_id , rid src_id_1 , rid src_id_2 , rid src_id_3 , real alpha_1 , real alpha_2 ) = 0;
 
                virtual SGDEPRECATED void SetInterpolateTuples( bool value ) = 0;
 
                virtual SGDEPRECATED bool GetInterpolateTuples(  ) = 0;
 
        };
 
        typedef CountedPointer<IValueArray> spValueArray;
 
        #define InterfaceDefined_SimplygonSDK_IValueArray 1
 
 
        class IStringArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IStringArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IStringArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IStringArray") )
                                return static_cast<IStringArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( const char * value ) = 0;
 
                virtual void SetItem( rid id , const char * value ) = 0;
 
                virtual rstring GetItem( rid id ) = 0;
 
        };
 
        typedef CountedPointer<IStringArray> spStringArray;
 
        #define InterfaceDefined_SimplygonSDK_IStringArray 1
 
 
        class IBoolArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IBoolArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IBoolArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IBoolArray") )
                                return static_cast<IBoolArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( bool value ) = 0;
 
                virtual void SetItem( rid id , bool value ) = 0;
 
                virtual bool GetItem( rid id ) = 0;
 
                virtual void AddTuple( const bool *tuple_boolInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const bool *tuple_boolInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , IBoolData *dest_param ) = 0;
 
                virtual void GetData( IBoolData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , IBoolData *dest_param ) = 0;
 
                virtual void SetData( const bool *source_items_boolInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const bool *source_items_boolInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<IBoolArray> spBoolArray;
 
        #define InterfaceDefined_SimplygonSDK_IBoolArray 1
 
 
        class ICharArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ICharArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static ICharArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ICharArray") )
                                return static_cast<ICharArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( char value ) = 0;
 
                virtual void SetItem( rid id , char value ) = 0;
 
                virtual char GetItem( rid id ) = 0;
 
                virtual void AddTuple( const char *tuple_charInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const char *tuple_charInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , ICharData *dest_param ) = 0;
 
                virtual void GetData( ICharData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , ICharData *dest_param ) = 0;
 
                virtual void SetData( const char *source_items_charInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const char *source_items_charInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<ICharArray> spCharArray;
 
        #define InterfaceDefined_SimplygonSDK_ICharArray 1
 
 
        class IDoubleArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IDoubleArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IDoubleArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IDoubleArray") )
                                return static_cast<IDoubleArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( double value ) = 0;
 
                virtual void SetItem( rid id , double value ) = 0;
 
                virtual double GetItem( rid id ) = 0;
 
                virtual void AddTuple( const double *tuple_doubleInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const double *tuple_doubleInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , IDoubleData *dest_param ) = 0;
 
                virtual void GetData( IDoubleData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , IDoubleData *dest_param ) = 0;
 
                virtual void SetData( const double *source_items_doubleInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const double *source_items_doubleInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<IDoubleArray> spDoubleArray;
 
        #define InterfaceDefined_SimplygonSDK_IDoubleArray 1
 
 
        class IFloatArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IFloatArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IFloatArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IFloatArray") )
                                return static_cast<IFloatArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( float value ) = 0;
 
                virtual void SetItem( rid id , float value ) = 0;
 
                virtual float GetItem( rid id ) = 0;
 
                virtual void AddTuple( const float *tuple_floatInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const float *tuple_floatInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , IFloatData *dest_param ) = 0;
 
                virtual void GetData( IFloatData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , IFloatData *dest_param ) = 0;
 
                virtual void SetData( const float *source_items_floatInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const float *source_items_floatInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<IFloatArray> spFloatArray;
 
        #define InterfaceDefined_SimplygonSDK_IFloatArray 1
 
 
        class IIntArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IIntArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IIntArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IIntArray") )
                                return static_cast<IIntArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( int value ) = 0;
 
                virtual void SetItem( rid id , int value ) = 0;
 
                virtual int GetItem( rid id ) = 0;
 
                virtual void AddTuple( const int *tuple_intInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const int *tuple_intInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , IIntData *dest_param ) = 0;
 
                virtual void GetData( IIntData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , IIntData *dest_param ) = 0;
 
                virtual void SetData( const int *source_items_intInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const int *source_items_intInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<IIntArray> spIntArray;
 
        #define InterfaceDefined_SimplygonSDK_IIntArray 1
 
 
        class ILongArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ILongArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static ILongArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ILongArray") )
                                return static_cast<ILongArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( long value ) = 0;
 
                virtual void SetItem( rid id , long value ) = 0;
 
                virtual long GetItem( rid id ) = 0;
 
                virtual void AddTuple( const long *tuple_longInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const long *tuple_longInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , ILongData *dest_param ) = 0;
 
                virtual void GetData( ILongData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , ILongData *dest_param ) = 0;
 
                virtual void SetData( const long *source_items_longInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const long *source_items_longInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<ILongArray> spLongArray;
 
        #define InterfaceDefined_SimplygonSDK_ILongArray 1
 
 
        class IRealArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IRealArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IRealArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IRealArray") )
                                return static_cast<IRealArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( real value ) = 0;
 
                virtual void SetItem( rid id , real value ) = 0;
 
                virtual real GetItem( rid id ) = 0;
 
                virtual void AddTuple( const real *tuple_realInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const real *tuple_realInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , IRealData *dest_param ) = 0;
 
                virtual void GetData( IRealData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , IRealData *dest_param ) = 0;
 
                virtual void SetData( const real *source_items_realInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const real *source_items_realInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<IRealArray> spRealArray;
 
        #define InterfaceDefined_SimplygonSDK_IRealArray 1
 
 
        class IRidArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IRidArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IRidArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IRidArray") )
                                return static_cast<IRidArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( rid value ) = 0;
 
                virtual void SetItem( rid id , rid value ) = 0;
 
                virtual rid GetItem( rid id ) = 0;
 
                virtual void AddTuple( const rid *tuple_ridInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const rid *tuple_ridInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , IRidData *dest_param ) = 0;
 
                virtual void GetData( IRidData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , IRidData *dest_param ) = 0;
 
                virtual void SetData( const rid *source_items_ridInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const rid *source_items_ridInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<IRidArray> spRidArray;
 
        #define InterfaceDefined_SimplygonSDK_IRidArray 1
 
 
        class IShortArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShortArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IShortArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShortArray") )
                                return static_cast<IShortArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( short value ) = 0;
 
                virtual void SetItem( rid id , short value ) = 0;
 
                virtual short GetItem( rid id ) = 0;
 
                virtual void AddTuple( const short *tuple_shortInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const short *tuple_shortInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , IShortData *dest_param ) = 0;
 
                virtual void GetData( IShortData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , IShortData *dest_param ) = 0;
 
                virtual void SetData( const short *source_items_shortInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const short *source_items_shortInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<IShortArray> spShortArray;
 
        #define InterfaceDefined_SimplygonSDK_IShortArray 1
 
 
        class IUnsignedCharArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IUnsignedCharArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IUnsignedCharArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IUnsignedCharArray") )
                                return static_cast<IUnsignedCharArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( unsigned char value ) = 0;
 
                virtual void SetItem( rid id , unsigned char value ) = 0;
 
                virtual unsigned char GetItem( rid id ) = 0;
 
                virtual void AddTuple( const unsigned char *tuple_ucharInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const unsigned char *tuple_ucharInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , IUnsignedCharData *dest_param ) = 0;
 
                virtual void GetData( IUnsignedCharData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , IUnsignedCharData *dest_param ) = 0;
 
                virtual void SetData( const unsigned char *source_items_ucharInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const unsigned char *source_items_ucharInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<IUnsignedCharArray> spUnsignedCharArray;
 
        #define InterfaceDefined_SimplygonSDK_IUnsignedCharArray 1
 
 
        class IUnsignedIntArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IUnsignedIntArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IUnsignedIntArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IUnsignedIntArray") )
                                return static_cast<IUnsignedIntArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( unsigned int value ) = 0;
 
                virtual void SetItem( rid id , unsigned int value ) = 0;
 
                virtual unsigned int GetItem( rid id ) = 0;
 
                virtual void AddTuple( const unsigned int *tuple_uintInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const unsigned int *tuple_uintInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , IUnsignedIntData *dest_param ) = 0;
 
                virtual void GetData( IUnsignedIntData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , IUnsignedIntData *dest_param ) = 0;
 
                virtual void SetData( const unsigned int *source_items_uintInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const unsigned int *source_items_uintInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<IUnsignedIntArray> spUnsignedIntArray;
 
        #define InterfaceDefined_SimplygonSDK_IUnsignedIntArray 1
 
 
        class IUnsignedLongArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IUnsignedLongArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IUnsignedLongArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IUnsignedLongArray") )
                                return static_cast<IUnsignedLongArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( unsigned long value ) = 0;
 
                virtual void SetItem( rid id , unsigned long value ) = 0;
 
                virtual unsigned long GetItem( rid id ) = 0;
 
                virtual void AddTuple( const unsigned long *tuple_ulongInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const unsigned long *tuple_ulongInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , IUnsignedLongData *dest_param ) = 0;
 
                virtual void GetData( IUnsignedLongData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , IUnsignedLongData *dest_param ) = 0;
 
                virtual void SetData( const unsigned long *source_items_ulongInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const unsigned long *source_items_ulongInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<IUnsignedLongArray> spUnsignedLongArray;
 
        #define InterfaceDefined_SimplygonSDK_IUnsignedLongArray 1
 
 
        class IUnsignedShortArray : public IValueArray
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IUnsignedShortArray",type)==0 )
                                return true;
                        return IValueArray::IsClassA(type);
                        }
                static IUnsignedShortArray *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IUnsignedShortArray") )
                                return static_cast<IUnsignedShortArray*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( unsigned short value ) = 0;
 
                virtual void SetItem( rid id , unsigned short value ) = 0;
 
                virtual unsigned short GetItem( rid id ) = 0;
 
                virtual void AddTuple( const unsigned short *tuple_ushortInputDataPtr ) = 0;
 
                virtual void SetTuple( rid id , const unsigned short *tuple_ushortInputDataPtr ) = 0;
 
                virtual void GetTuple( rid id , IUnsignedShortData *dest_param ) = 0;
 
                virtual void GetData( IUnsignedShortData *dest_param ) = 0;
 
                virtual void GetDataRange( rid start_tuple_id , unsigned int tuple_count , IUnsignedShortData *dest_param ) = 0;
 
                virtual void SetData( const unsigned short *source_items_ushortInputDataPtr , unsigned int source_item_count ) = 0;
 
                virtual void SetDataRange( rid start_tuple_id , const unsigned short *source_items_ushortInputDataPtr , unsigned int source_item_count ) = 0;
 
        };
 
        typedef CountedPointer<IUnsignedShortArray> spUnsignedShortArray;
 
        #define InterfaceDefined_SimplygonSDK_IUnsignedShortArray 1
 
        class IImageData;
 
        class IChunkedImageData : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IChunkedImageData",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IChunkedImageData *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IChunkedImageData") )
                                return static_cast<IChunkedImageData*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IChunkedImageData> NewCopy( bool copy_data ) = 0;
 
                virtual void DeepCopy( IChunkedImageData *source , bool copy_data ) = 0;
 
                virtual void SetTemplateImage( IImageData *_template ) = 0;
 
                virtual unsigned int GetTemplateXSize(  ) = 0;
 
                virtual unsigned int GetTemplateYSize(  ) = 0;
 
                virtual unsigned int GetTemplateZSize(  ) = 0;
 
                virtual unsigned int GetXSize(  ) = 0;
 
                virtual unsigned int GetYSize(  ) = 0;
 
                virtual unsigned int GetZSize(  ) = 0;
 
                virtual void Set1DSize( unsigned int _xs ) = 0;
 
                virtual void Set2DSize( unsigned int _xs , unsigned int _ys ) = 0;
 
                virtual void Set3DSize( unsigned int _xs , unsigned int _ys , unsigned int _zs ) = 0;
 
                virtual unsigned int GetTotalXSize(  ) = 0;
 
                virtual unsigned int GetTotalYSize(  ) = 0;
 
                virtual unsigned int GetTotalZSize(  ) = 0;
 
                virtual void Reset(  ) = 0;
 
                virtual CountedPointer<IImageData> LockChunk1D( rid x ) = 0;
 
                virtual CountedPointer<IImageData> LockChunk2D( rid x , rid y ) = 0;
 
                virtual CountedPointer<IImageData> LockChunk3D( rid x , rid y , rid z ) = 0;
 
                virtual bool IsChunkLocked1D( rid x ) = 0;
 
                virtual bool IsChunkLocked2D( rid x , rid y ) = 0;
 
                virtual bool IsChunkLocked3D( rid x , rid y , rid z ) = 0;
 
                virtual void UnlockChunk1D( rid x ) = 0;
 
                virtual void UnlockChunk2D( rid x , rid y ) = 0;
 
                virtual void UnlockChunk3D( rid x , rid y , rid z ) = 0;
 
        };
 
        typedef CountedPointer<IChunkedImageData> spChunkedImageData;
 
        #define InterfaceDefined_SimplygonSDK_IChunkedImageData 1
 
        class IGeometryData;
        class IMaterialTable;
        class IScene;
 
        class IDirectXRenderer : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IDirectXRenderer",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IDirectXRenderer *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IDirectXRenderer") )
                                return static_cast<IDirectXRenderer*>(ptr);
                        return NULL;
                        }
 
                virtual bool CreatePreviewer( int _width , int _height ) = 0;
 
                virtual void RenderAlongCameraPathAndStorePics( int cameraSelectionSetID , const char * file_name_base , const char * format ) = 0;
 
                virtual void SetRenderWireFrameMode( bool flag ) = 0;
 
                virtual bool LoadGeometryData( IGeometryData *geom , IMaterialTable *materials ) = 0;
 
                virtual bool LoadGeometryDataWithMaterialShadingNetwork( IScene *_scene ) = 0;
 
        };
 
        typedef CountedPointer<IDirectXRenderer> spDirectXRenderer;
 
        #define InterfaceDefined_SimplygonSDK_IDirectXRenderer 1
 
        class IRidArray;
        class IRealArray;
        class IValueArray;
 
        class IFieldData : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IFieldData",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IFieldData *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IFieldData") )
                                return static_cast<IFieldData*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IFieldData> NewCopy( bool copy_data ) = 0;
 
                virtual CountedPointer<IFieldData> NewPackedCopy( IRidArray *index_array ) = 0;
 
                virtual void DeepCopy( IFieldData *source , bool copy_data ) = 0;
 
                virtual bool IsSetupIdenticalTo( IFieldData *other ) = 0;
 
                virtual void IndexedCopy( IFieldData *source , IRidArray *idtable , rid startId ) = 0;
 
                virtual void IndexedCopy( IFieldData *source , rid *idtable_ridInputDataPtr , unsigned int idtable_cnt , rid startId ) = 0;
 
                virtual void IndexedCombine( IFieldData *source , IRidArray *idtable , IRealArray *blendtable , rid startId ) = 0;
 
                virtual void IndexedCombine( IFieldData *source , rid *idtable_ridInputDataPtr , real *blendtable_realInputDataPtr , unsigned int idtable_cnt , rid startId ) = 0;
 
                virtual void IndexedCombine3( IFieldData *source , IRidArray *idtable , IRealArray *blendtable , rid startId ) = 0;
 
                virtual void IndexedCombine3( IFieldData *source , rid *idtable_ridInputDataPtr , real *blendtable_realInputDataPtr , unsigned int idtable_cnt , rid startId ) = 0;
 
                virtual void Clear(  ) = 0;
 
                virtual void RemoveAllFields(  ) = 0;
 
                virtual int IsEmpty(  ) = 0;
 
                virtual void AppendTuples( IFieldData *other , bool add_missing_fields ) = 0;
 
                virtual void ExtractTuples( IFieldData *dest , rid start , unsigned int count ) = 0;
 
                virtual void AddField( IValueArray *field ) = 0;
 
                virtual CountedPointer<IValueArray> AddBaseTypeField( rid base_type , unsigned int tuple_size , const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> GetField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> GetFieldWithId( rid id ) = 0;
 
                virtual void RemoveField( const char * name ) = 0;
 
                virtual void SafeRemoveField( const char * name ) = 0;
 
                virtual unsigned int GetFieldCount(  ) = 0;
 
                virtual rid GetMaxFieldId(  ) = 0;
 
                virtual rhandle GetFirstFieldHandle(  ) = 0;
 
                virtual rhandle GetNextFieldHandle( rhandle hand ) = 0;
 
                virtual CountedPointer<IValueArray> GetFieldWithHandle( rhandle hand ) = 0;
 
                virtual void SetTupleCount( unsigned int tuplecount ) = 0;
 
                virtual void AddTupleCount( unsigned int tuplecount ) = 0;
 
                virtual unsigned int GetTupleCount(  ) = 0;
 
                virtual rid GetMaxTupleId(  ) = 0;
 
                virtual void CopyTuple( IFieldData *source , rid dest_id , rid src_id ) = 0;
 
                virtual void CopyCombineTuples( IFieldData *source , rid dest_id , rid src_id_1 , rid src_id_2 , real alpha ) = 0;
 
                virtual void CopyCombine3Tuples( IFieldData *source , rid dest_id , rid src_id_1 , rid src_id_2 , rid src_id_3 , real alpha_1 , real alpha_2 ) = 0;
 
                virtual void CopyRange( IFieldData *source , rid start_dest_id , rid start_src_id , unsigned int count ) = 0;
 
        };
 
        typedef CountedPointer<IFieldData> spFieldData;
 
        #define InterfaceDefined_SimplygonSDK_IFieldData 1
 
        class IPackedGeometryData;
        class IRidArray;
        class IRealArray;
        class IBoolArray;
        class IValueArray;
        class IFieldData;
        class IMatrix4x4;
 
        class IGeometryData : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IGeometryData",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IGeometryData *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IGeometryData") )
                                return static_cast<IGeometryData*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IGeometryData> NewCopy( bool copy_data ) = 0;
 
                virtual CountedPointer<IPackedGeometryData> NewPackedCopy(  ) = 0;
 
                virtual void DeepCopy( IGeometryData *source , bool copy_data ) = 0;
 
                virtual void SetVertexCount( unsigned int count ) = 0;
 
                virtual unsigned int GetVertexCount(  ) = 0;
 
                virtual void AddVertices( unsigned int count ) = 0;
 
                virtual void SetTriangleCount( unsigned int count ) = 0;
 
                virtual unsigned int GetTriangleCount(  ) = 0;
 
                virtual void AddTriangles( unsigned int count ) = 0;
 
                virtual void FindEdgeIdsFromVertexPairs( IRidArray *vertex_pairs , IRidArray *edge_ids ) = 0;
 
                virtual CountedPointer<IRealArray> GetCoords(  ) = 0;
 
                virtual void AddVertexLocks(  ) = 0;
 
                virtual void RemoveVertexLocks(  ) = 0;
 
                virtual CountedPointer<IBoolArray> GetVertexLocks(  ) = 0;
 
                virtual void AddBoneWeights( unsigned int tuplesize ) = 0;
 
                virtual void RemoveBoneWeights(  ) = 0;
 
                virtual CountedPointer<IRealArray> GetBoneWeights(  ) = 0;
 
                virtual CountedPointer<IRidArray> GetBoneIds(  ) = 0;
 
                virtual void AddVertexWeighting(  ) = 0;
 
                virtual void RemoveVertexWeighting(  ) = 0;
 
                virtual CountedPointer<IRealArray> GetVertexWeighting(  ) = 0;
 
                virtual void AddUserVertexField( IValueArray *field ) = 0;
 
                virtual void RemoveUserVertexField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> GetUserVertexField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> AddBaseTypeUserVertexField( rid base_type , const char * name , unsigned int tuple_size ) = 0;
 
                virtual void CopyVertex( IGeometryData *source , rid dest_id , rid src_id ) = 0;
 
                virtual void CopyCombineVertices( IGeometryData *source , rid dest_id , rid src_id_1 , rid src_id_2 , real alpha ) = 0;
 
                virtual void CopyCombine3Vertices( IGeometryData *source , rid dest_id , rid src_id_1 , rid src_id_2 , rid src_id_3 , real alpha_1 , real alpha_2 ) = 0;
 
                virtual CountedPointer<IFieldData> GetVertices(  ) = 0;
 
                virtual CountedPointer<IRidArray> GetVertexIds(  ) = 0;
 
                virtual void AddTexCoords( rid level ) = 0;
 
                virtual rid AddNamedTexCoords( const char * alternative_name ) = 0;
 
                virtual void RemoveTexCoords( rid level ) = 0;
 
                virtual bool RemoveNamedTexCoords( const char * alternative_name ) = 0;
 
                virtual CountedPointer<IRealArray> GetTexCoords( rid level ) = 0;
 
                virtual CountedPointer<IRealArray> GetNamedTexCoords( const char * alternative_name ) = 0;
 
                virtual void AddTangents( rid level ) = 0;
 
                virtual void RemoveTangents( rid level ) = 0;
 
                virtual CountedPointer<IRealArray> GetTangents( rid level ) = 0;
 
                virtual CountedPointer<IRealArray> GetBitangents( rid level ) = 0;
 
                virtual void AddNormals(  ) = 0;
 
                virtual void RemoveNormals(  ) = 0;
 
                virtual CountedPointer<IRealArray> GetNormals(  ) = 0;
 
                virtual void AddColors( rid level ) = 0;
 
                virtual rid AddNamedColors( const char * alternative_name ) = 0;
 
                virtual void RemoveColors( rid level ) = 0;
 
                virtual bool RemoveNamedColors( const char * alternative_name ) = 0;
 
                virtual CountedPointer<IRealArray> GetColors( rid level ) = 0;
 
                virtual CountedPointer<IRealArray> GetNamedColors( const char * alternative_name ) = 0;
 
                virtual void AddUserCornerField( IValueArray *field ) = 0;
 
                virtual void RemoveUserCornerField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> GetUserCornerField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> AddBaseTypeUserCornerField( rid base_type , const char * name , unsigned int tuple_size ) = 0;
 
                virtual void CopyCorner( IGeometryData *source , rid dest_id , rid src_id ) = 0;
 
                virtual void CopyCombineCorners( IGeometryData *source , rid dest_id , rid src_id_1 , rid src_id_2 , real alpha ) = 0;
 
                virtual void CopyCombine3Corners( IGeometryData *source , rid dest_id , rid src_id_1 , rid src_id_2 , rid src_id_3 , real alpha_1 , real alpha_2 ) = 0;
 
                virtual CountedPointer<IFieldData> GetCorners(  ) = 0;
 
                virtual void AddMaterialIds(  ) = 0;
 
                virtual void RemoveMaterialIds(  ) = 0;
 
                virtual CountedPointer<IRidArray> GetMaterialIds(  ) = 0;
 
                virtual void AddGroupIds(  ) = 0;
 
                virtual void RemoveGroupIds(  ) = 0;
 
                virtual CountedPointer<IRidArray> GetGroupIds(  ) = 0;
 
                virtual void AddUserTriangleField( IValueArray *field ) = 0;
 
                virtual void RemoveUserTriangleField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> GetUserTriangleField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> AddBaseTypeUserTriangleField( rid base_type , const char * name , unsigned int tuple_size ) = 0;
 
                virtual void CopyTriangle( IGeometryData *source , rid dest_id , rid src_id ) = 0;
 
                virtual void CopyCombineTriangles( IGeometryData *source , rid dest_id , rid src_id_1 , rid src_id_2 , real alpha ) = 0;
 
                virtual void CopyCombine3Triangles( IGeometryData *source , rid dest_id , rid src_id_1 , rid src_id_2 , rid src_id_3 , real alpha_1 , real alpha_2 ) = 0;
 
                virtual CountedPointer<IFieldData> GetTriangles(  ) = 0;
 
                virtual void AddCustomField( IValueArray *field ) = 0;
 
                virtual void RemoveCustomField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> GetCustomField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> AddBaseTypeCustomField( rid base_type , const char * name , unsigned int tuple_size ) = 0;
 
                virtual void CleanupNanValues(  ) = 0;
 
                virtual void CleanupInvalidTriangles(  ) = 0;
 
                virtual rid FindNamedTexCoordsIndex( const char * field_name ) = 0;
 
                virtual rid FindNamedColorsIndex( const char * field_name ) = 0;
 
                virtual void ExpandVertices(  ) = 0;
 
                virtual void ExtractRange( IGeometryData *dest , rid start_tri_id , unsigned int count ) = 0;
 
                virtual void ExtractTriangles( IGeometryData *dest , IRidArray *triangle_ids ) = 0;
 
                virtual void AppendGeometry( IGeometryData *source ) = 0;
 
                virtual void Compact( bool only_compact_triangles ) = 0;
 
                virtual void Compact(  ) = 0;
 
                virtual void Weld( real threshold ) = 0;
 
                virtual void GetInf( real *realReturnDataPtr ) = 0;
 
                virtual void SetInf( const real *vec_realInputDataPtr ) = 0;
 
                virtual void GetSup( real *realReturnDataPtr ) = 0;
 
                virtual void SetSup( const real *vec_realInputDataPtr ) = 0;
 
                virtual void CalculateExtents( bool only_triangles ) = 0;
 
                virtual bool ExtentsContainCoords(  ) = 0;
 
                virtual void Transform( IMatrix4x4 *transformation ) = 0;
 
                virtual void DetectEdgeNeighbours(  ) = 0;
 
                virtual void ConvertHandedness(  ) = 0;
 
                virtual void ChangeWinding(  ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IValueArray> AddBaseTypeUserTriangleVertexField( rid base_type , const char * name , unsigned int tuple_size ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IFieldData> GetTriangleVertices(  ) = 0;
 
                virtual SGDEPRECATED void CopyTriangleVertex( IGeometryData *source , rid dest_id , rid src_id ) = 0;
 
                virtual SGDEPRECATED void CopyCombineTriangleVertices( IGeometryData *source , rid dest_id , rid src_id_1 , rid src_id_2 , real alpha ) = 0;
 
                virtual SGDEPRECATED void CopyCombine3TriangleVertices( IGeometryData *source , rid dest_id , rid src_id_1 , rid src_id_2 , rid src_id_3 , real alpha_1 , real alpha_2 ) = 0;
 
                virtual SGDEPRECATED void AddBoneIds( unsigned int tuplesize ) = 0;
 
                virtual SGDEPRECATED void RemoveBoneIds(  ) = 0;
 
                virtual SGDEPRECATED void AddUserTriangleVertexField( IValueArray *field ) = 0;
 
                virtual SGDEPRECATED void RemoveUserTriangleVertexField( const char * name ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IValueArray> GetUserTriangleVertexField( const char * name ) = 0;
 
                virtual SGDEPRECATED void AddDiffuseColors(  ) = 0;
 
                virtual SGDEPRECATED void RemoveDiffuseColors(  ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IRealArray> GetDiffuseColors(  ) = 0;
 
                virtual SGDEPRECATED void AddSpecularColors(  ) = 0;
 
                virtual SGDEPRECATED void RemoveSpecularColors(  ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IRealArray> GetSpecularColors(  ) = 0;
 
                virtual SGDEPRECATED void AddBitangents( rid level ) = 0;
 
                virtual SGDEPRECATED void RemoveBitangents( rid level ) = 0;
 
        };
 
        typedef CountedPointer<IGeometryData> spGeometryData;
 
        #define InterfaceDefined_SimplygonSDK_IGeometryData 1
 
        class IGeometryData;
        class IRidArray;
        class IRealArray;
        class IBoolArray;
        class IValueArray;
        class IFieldData;
 
        class IPackedGeometryData : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IPackedGeometryData",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IPackedGeometryData *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IPackedGeometryData") )
                                return static_cast<IPackedGeometryData*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IPackedGeometryData> NewCopy( bool copy_data ) = 0;
 
                virtual CountedPointer<IGeometryData> NewUnpackedCopy(  ) = 0;
 
                virtual void DeepCopy( IPackedGeometryData *source , bool copy_data ) = 0;
 
                virtual int AppendPackedGeometry( IGeometryData *source , IRidArray *NewVertexIds , bool collapseToOriginalVertices ) = 0;
 
                virtual void SetVertexCount( unsigned int count ) = 0;
 
                virtual unsigned int GetVertexCount(  ) = 0;
 
                virtual void AddVertices( unsigned int count ) = 0;
 
                virtual void SetTriangleCount( unsigned int count ) = 0;
 
                virtual unsigned int GetTriangleCount(  ) = 0;
 
                virtual void AddTriangles( unsigned int count ) = 0;
 
                virtual CountedPointer<IRealArray> GetCoords(  ) = 0;
 
                virtual void AddVertexLocks(  ) = 0;
 
                virtual void RemoveVertexLocks(  ) = 0;
 
                virtual CountedPointer<IBoolArray> GetVertexLocks(  ) = 0;
 
                virtual void AddBoneWeights( unsigned int tuplesize ) = 0;
 
                virtual void RemoveBoneWeights(  ) = 0;
 
                virtual CountedPointer<IRealArray> GetBoneWeights(  ) = 0;
 
                virtual CountedPointer<IRidArray> GetBoneIds(  ) = 0;
 
                virtual void AddVertexWeighting(  ) = 0;
 
                virtual void RemoveVertexWeighting(  ) = 0;
 
                virtual CountedPointer<IRealArray> GetVertexWeighting(  ) = 0;
 
                virtual void AddTexCoords( rid level ) = 0;
 
                virtual void RemoveTexCoords( rid level ) = 0;
 
                virtual CountedPointer<IRealArray> GetTexCoords( rid level ) = 0;
 
                virtual void AddTangents( rid level ) = 0;
 
                virtual void RemoveTangents( rid level ) = 0;
 
                virtual CountedPointer<IRealArray> GetTangents( rid level ) = 0;
 
                virtual CountedPointer<IRealArray> GetBitangents( rid level ) = 0;
 
                virtual void AddNormals(  ) = 0;
 
                virtual void RemoveNormals(  ) = 0;
 
                virtual CountedPointer<IRealArray> GetNormals(  ) = 0;
 
                virtual void AddColors( rid level ) = 0;
 
                virtual void RemoveColors( rid level ) = 0;
 
                virtual CountedPointer<IRealArray> GetColors( rid level ) = 0;
 
                virtual void AddUserVertexField( IValueArray *field ) = 0;
 
                virtual void RemoveUserVertexField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> GetUserVertexField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> AddBaseTypeUserVertexField( rid base_type , const char * name , unsigned int tuple_size ) = 0;
 
                virtual CountedPointer<IFieldData> GetVertices(  ) = 0;
 
                virtual CountedPointer<IRidArray> GetVertexIds(  ) = 0;
 
                virtual void AddMaterialIds(  ) = 0;
 
                virtual void RemoveMaterialIds(  ) = 0;
 
                virtual CountedPointer<IRidArray> GetMaterialIds(  ) = 0;
 
                virtual void AddGroupIds(  ) = 0;
 
                virtual void RemoveGroupIds(  ) = 0;
 
                virtual CountedPointer<IRidArray> GetGroupIds(  ) = 0;
 
                virtual void AddUserTriangleField( IValueArray *field ) = 0;
 
                virtual void RemoveUserTriangleField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> GetUserTriangleField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> AddBaseTypeUserTriangleField( rid base_type , const char * name , unsigned int tuple_size ) = 0;
 
                virtual CountedPointer<IFieldData> GetTriangles(  ) = 0;
 
                virtual void GetInf( real *realReturnDataPtr ) = 0;
 
                virtual void SetInf( const real *vec_realInputDataPtr ) = 0;
 
                virtual void GetSup( real *realReturnDataPtr ) = 0;
 
                virtual void SetSup( const real *vec_realInputDataPtr ) = 0;
 
                virtual SGDEPRECATED void AddDiffuseColors(  ) = 0;
 
                virtual SGDEPRECATED void RemoveDiffuseColors(  ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IRealArray> GetDiffuseColors(  ) = 0;
 
                virtual SGDEPRECATED void AddSpecularColors(  ) = 0;
 
                virtual SGDEPRECATED void RemoveSpecularColors(  ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IRealArray> GetSpecularColors(  ) = 0;
 
                virtual SGDEPRECATED void AddBitangents( rid level ) = 0;
 
                virtual SGDEPRECATED void RemoveBitangents( rid level ) = 0;
 
        };
 
        typedef CountedPointer<IPackedGeometryData> spPackedGeometryData;
 
        #define InterfaceDefined_SimplygonSDK_IPackedGeometryData 1
 
        class IValueArray;
        class IFieldData;
 
        class IImageData : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IImageData",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IImageData *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IImageData") )
                                return static_cast<IImageData*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IImageData> NewCopy( bool copy_data ) = 0;
 
                virtual void DeepCopy( IImageData *source , bool copy_data ) = 0;
 
                virtual void AddColors( rid valuetype , const char * format ) = 0;
 
                virtual void RemoveColors(  ) = 0;
 
                virtual CountedPointer<IValueArray> GetColors(  ) = 0;
 
                virtual rid GetColorsValueType(  ) = 0;
 
                virtual bool HasColors(  ) = 0;
 
                virtual rstring GetColorsFormat(  ) = 0;
 
                virtual void AddField( const char * name , rid valuetype , unsigned int tuplesize ) = 0;
 
                virtual void RemoveField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> GetField( const char * name ) = 0;
 
                virtual rid GetFieldValueType( const char * name ) = 0;
 
                virtual bool HasField( const char * name ) = 0;
 
                virtual unsigned int GetType(  ) = 0;
 
                virtual unsigned int GetXSize(  ) = 0;
 
                virtual unsigned int GetYSize(  ) = 0;
 
                virtual unsigned int GetZSize(  ) = 0;
 
                virtual void Set1DSize( unsigned int _xs ) = 0;
 
                virtual void Set2DSize( unsigned int _xs , unsigned int _ys ) = 0;
 
                virtual void Set3DSize( unsigned int _xs , unsigned int _ys , unsigned int _zs ) = 0;
 
                virtual void SetCubeSize( unsigned int _xs , unsigned int _ys ) = 0;
 
                virtual void Reset(  ) = 0;
 
                virtual CountedPointer<IFieldData> GetImageFields(  ) = 0;
 
        };
 
        typedef CountedPointer<IImageData> spImageData;
 
        #define InterfaceDefined_SimplygonSDK_IImageData 1
 
        class IObject;
 
        class ITable : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ITable",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static ITable *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ITable") )
                                return static_cast<ITable*>(ptr);
                        return NULL;
                        }
 
                virtual rid AddItem( IObject *item ) = 0;
 
                virtual void SetItem( rid id , IObject *item ) = 0;
 
                virtual CountedPointer<IObject> FindItem( const char * name ) = 0;
 
                virtual rid FindItemId( const char * name ) = 0;
 
                virtual CountedPointer<IObject> GetItem( rid id ) = 0;
 
                virtual void RemoveItem( rid id ) = 0;
 
                virtual void Clear(  ) = 0;
 
                virtual unsigned int GetItemsCount(  ) = 0;
 
                virtual void Copy( ITable *src ) = 0;
 
        };
 
        typedef CountedPointer<ITable> spTable;
 
        #define InterfaceDefined_SimplygonSDK_ITable 1
 
        class IShadingNode;
 
        class IMaterial : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IMaterial",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IMaterial *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IMaterial") )
                                return static_cast<IMaterial*>(ptr);
                        return NULL;
                        }
 
                virtual unsigned int GetChannelCount(  ) = 0;
 
                virtual rstring GetChannelFromIndex( rid index ) = 0;
 
                virtual void AddUserChannel( const char * channel_name ) = 0;
 
                virtual void RemoveUserChannel( const char * channel_name ) = 0;
 
                virtual bool HasUserChannel( const char * channel_name ) = 0;
 
                virtual void SetShadingNetwork( const char * channel_name , IShadingNode *node ) = 0;
 
                virtual CountedPointer<IShadingNode> GetShadingNetwork( const char * channel_name ) = 0;
 
                virtual void LoadShadingNetworkFromXML( const char * channel_name , const char * in_xml ) = 0;
 
                virtual rstring SaveShadingNetworkToXML( const char * channel_name ) = 0;
 
                virtual void SetUseTangentSpaceNormals( bool value ) = 0;
 
                virtual bool GetUseTangentSpaceNormals(  ) = 0;
 
                virtual bool IsIdenticalTo( IMaterial *mat ) = 0;
 
                virtual bool IsTransparent(  ) = 0;
 
                virtual rstring GetMaterialGUID(  ) = 0;
 
                virtual void SetMaterialGUID( const char * value ) = 0;
 
                virtual void SetMaterialType( unsigned int value ) = 0;
 
                virtual unsigned int GetMaterialType(  ) = 0;
 
                virtual void ChangeTexturePrefixPath( const char * current_path_prefix , const char * new_path_prefix ) = 0;
 
                virtual void SetOpacityFromDiffuseAlpha(  ) = 0;
 
                virtual void ConvertHandedness(  ) = 0;
 
        };
 
        typedef CountedPointer<IMaterial> spMaterial;
 
        #define InterfaceDefined_SimplygonSDK_IMaterial 1
 
        class IMaterial;
        class IRidArray;
 
        class IMaterialTable : public ITable
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IMaterialTable",type)==0 )
                                return true;
                        return ITable::IsClassA(type);
                        }
                static IMaterialTable *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IMaterialTable") )
                                return static_cast<IMaterialTable*>(ptr);
                        return NULL;
                        }
 
                virtual rid AddMaterial( IMaterial *material ) = 0;
 
                virtual CountedPointer<IMaterial> FindMaterial( const char * name ) = 0;
 
                virtual CountedPointer<IMaterial> FindIdenticalMaterial( IMaterial *mat ) = 0;
 
                virtual rid FindMaterialId( const char * name ) = 0;
 
                virtual rid FindIdenticalMaterialId( IMaterial *mat ) = 0;
 
                virtual CountedPointer<IRidArray> FindIdenticalMaterialIds( IMaterial *mat ) = 0;
 
                virtual void SetMaterial( rid id , IMaterial *material ) = 0;
 
                virtual CountedPointer<IMaterial> GetMaterial( rid id ) = 0;
 
                virtual void RemoveMaterial( rid id ) = 0;
 
                virtual unsigned int GetMaterialsCount(  ) = 0;
 
                virtual void ChangeTexturePrefixPath( const char * current_path_prefix , const char * new_path_prefix ) = 0;
 
        };
 
        typedef CountedPointer<IMaterialTable> spMaterialTable;
 
        #define InterfaceDefined_SimplygonSDK_IMaterialTable 1
 
        class IRealArray;
 
        class IMatrix4x4 : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IMatrix4x4",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IMatrix4x4 *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IMatrix4x4") )
                                return static_cast<IMatrix4x4*>(ptr);
                        return NULL;
                        }
 
                virtual void DeepCopy( IMatrix4x4 *mtxin ) = 0;
 
                virtual void Zero(  ) = 0;
 
                virtual void Identity(  ) = 0;
 
                virtual real GetElement( unsigned int column , unsigned int row ) = 0;
 
                virtual void SetElement( unsigned int column , unsigned int row , real value ) = 0;
 
                virtual void GetElements( real *realReturnDataPtr ) = 0;
 
                virtual void Transpose( IMatrix4x4 *mtxin ) = 0;
 
                virtual void Transpose(  ) = 0;
 
                virtual void Invert( IMatrix4x4 *mtxin ) = 0;
 
                virtual void Invert(  ) = 0;
 
                virtual real Determinant3x3(  ) = 0;
 
                virtual void Point3ArrayMultiply( IRealArray *vecarray ) = 0;
 
                virtual void Direction3ArrayMultiply( IRealArray *vecarray ) = 0;
 
                virtual void Vector4ArrayMultiply( IRealArray *vecarray ) = 0;
 
                virtual void SetToRotationTransform( real angle , real ax , real ay , real az ) = 0;
 
                virtual void SetToScalingTransform( real sx , real sy , real sz ) = 0;
 
                virtual void SetToTranslationTransform( real tx , real ty , real tz ) = 0;
 
        };
 
        typedef CountedPointer<IMatrix4x4> spMatrix4x4;
 
        #define InterfaceDefined_SimplygonSDK_IMatrix4x4 1
 
        class IMatrix4x4;
        class IRealArray;
 
        class ITransform3 : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ITransform3",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static ITransform3 *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ITransform3") )
                                return static_cast<ITransform3*>(ptr);
                        return NULL;
                        }
 
                virtual void Clear(  ) = 0;
 
                virtual CountedPointer<IMatrix4x4> GetMatrix(  ) = 0;
 
                virtual CountedPointer<IRealArray> GetStack(  ) = 0;
 
                virtual void PostMultiply(  ) = 0;
 
                virtual void PreMultiply(  ) = 0;
 
                virtual bool IsPostMultiply(  ) = 0;
 
                virtual bool IsPreMultiply(  ) = 0;
 
                virtual void AddRotation( real angle , real rx , real ry , real rz ) = 0;
 
                virtual void AddScaling( real sx , real sy , real sz ) = 0;
 
                virtual void AddTranslation( real tx , real ty , real tz ) = 0;
 
                virtual void AddTransformation( IMatrix4x4 *transform ) = 0;
 
                virtual void AddTransformation( ITransform3 *transform ) = 0;
 
                virtual void Push(  ) = 0;
 
                virtual void Pop(  ) = 0;
 
        };
 
        typedef CountedPointer<ITransform3> spTransform3;
 
        #define InterfaceDefined_SimplygonSDK_ITransform3 1
 
        class IChunkedImageData;
        class IMappingImageMeshData;
 
        class IMappingImage : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IMappingImage",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IMappingImage *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IMappingImage") )
                                return static_cast<IMappingImage*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IMappingImage> NewQuartersizeCopy(  ) = 0;
 
                virtual unsigned int GetWidth(  ) = 0;
 
                virtual unsigned int GetHeight(  ) = 0;
 
                virtual unsigned int GetLayerCount(  ) = 0;
 
                virtual unsigned int GetMultisamplingWidth(  ) = 0;
 
                virtual unsigned int GetMultisamplingHeight(  ) = 0;
 
                virtual CountedPointer<IChunkedImageData> GetImageData(  ) = 0;
 
                virtual CountedPointer<IMappingImageMeshData> GetMappingMeshData(  ) = 0;
 
        };
 
        typedef CountedPointer<IMappingImage> spMappingImage;
 
        #define InterfaceDefined_SimplygonSDK_IMappingImage 1
 
 
        class IProcessingObject : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IProcessingObject",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IProcessingObject *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IProcessingObject") )
                                return static_cast<IProcessingObject*>(ptr);
                        return NULL;
                        }
 
                virtual void RunProcessing(  ) = 0;
 
                virtual void Clear(  ) = 0;
 
                virtual real GetPercentDone(  ) = 0;
 
        };
 
        typedef CountedPointer<IProcessingObject> spProcessingObject;
 
        #define InterfaceDefined_SimplygonSDK_IProcessingObject 1
 
        class IGeometryData;
        class IRealArray;
 
        class IParameterizer : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IParameterizer",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IParameterizer *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IParameterizer") )
                                return static_cast<IParameterizer*>(ptr);
                        return NULL;
                        }
 
                virtual bool Parameterize( IGeometryData *geom , IRealArray *arr ) = 0;
 
                virtual void SetMaxStretch( real value ) = 0;
 
                virtual real GetMaxStretch(  ) = 0;
 
                virtual void SetInputMaterialCount( unsigned int value ) = 0;
 
                virtual unsigned int GetInputMaterialCount(  ) = 0;
 
                virtual void SetOutputMaterialCount( unsigned int value ) = 0;
 
                virtual unsigned int GetOutputMaterialCount(  ) = 0;
 
                virtual void SetInputOutputMaterialMapping( unsigned int InMaterialId , int OutMaterialId ) = 0;
 
                virtual int GetInputOutputMaterialMapping( unsigned int InMaterialId ) = 0;
 
                virtual void SetTextureWidth( unsigned int value ) = 0;
 
                virtual void SetTextureWidth( unsigned int id , unsigned int value ) = 0;
 
                virtual unsigned int GetTextureWidth(  ) = 0;
 
                virtual unsigned int GetTextureWidth( unsigned int id ) = 0;
 
                virtual void SetTextureHeight( unsigned int value ) = 0;
 
                virtual void SetTextureHeight( unsigned int id , unsigned int value ) = 0;
 
                virtual unsigned int GetTextureHeight(  ) = 0;
 
                virtual unsigned int GetTextureHeight( unsigned int id ) = 0;
 
                virtual void SetGutterSpace( unsigned int value ) = 0;
 
                virtual void SetGutterSpace( unsigned int id , unsigned int value ) = 0;
 
                virtual unsigned int GetGutterSpace(  ) = 0;
 
                virtual unsigned int GetGutterSpace( unsigned int id ) = 0;
 
                virtual void SetFeatureFlagsMask( unsigned int value ) = 0;
 
                virtual unsigned int GetFeatureFlagsMask(  ) = 0;
 
                virtual void SetPackingEfficency( real value ) = 0;
 
                virtual real GetPackingEfficency(  ) = 0;
 
                virtual void SetUseAutomaticTextureSize( bool value ) = 0;
 
                virtual bool GetUseAutomaticTextureSize(  ) = 0;
 
                virtual void SetAutomaticTextureSizeMultiplier( real value ) = 0;
 
                virtual real GetAutomaticTextureSizeMultiplier(  ) = 0;
 
                virtual void SetForcePower2Texture( bool value ) = 0;
 
                virtual bool GetForcePower2Texture(  ) = 0;
 
                virtual void SetUseVertexWeights( bool value ) = 0;
 
                virtual bool GetUseVertexWeights(  ) = 0;
 
                virtual void SetUseVisibilityWeights( bool value ) = 0;
 
                virtual bool GetUseVisibilityWeights(  ) = 0;
 
        };
 
        typedef CountedPointer<IParameterizer> spParameterizer;
 
        #define InterfaceDefined_SimplygonSDK_IParameterizer 1
 
        class IObject;
 
        class IObjectCollection : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IObjectCollection",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IObjectCollection *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IObjectCollection") )
                                return static_cast<IObjectCollection*>(ptr);
                        return NULL;
                        }
 
                virtual rhandle AddObject( IObject *obj ) = 0;
 
                virtual rhandle AddObjectSorted( IObject *obj , bool ascending ) = 0;
 
                virtual rhandle GetFirstItem(  ) = 0;
 
                virtual rhandle GetNextItem( rhandle objhandle ) = 0;
 
                virtual CountedPointer<IObject> GetItemsObject( rhandle objhandle ) = 0;
 
                virtual rhandle RemoveItem( rhandle objhandle ) = 0;
 
                virtual void RemoveObject( IObject *pobj ) = 0;
 
                virtual void RemoveAllItems(  ) = 0;
 
                virtual unsigned int GetItemCount(  ) = 0;
 
                virtual rhandle GetItem( unsigned int index ) = 0;
 
                virtual CountedPointer<IObject> GetItemAsObject( unsigned int index ) = 0;
 
                virtual bool IsObjectInCollection( IObject *pobj ) = 0;
 
                virtual bool IsItemInCollection( rhandle objhandle ) = 0;
 
                virtual CountedPointer<IObject> FindObject( const char * name ) = 0;
 
        };
 
        typedef CountedPointer<IObjectCollection> spObjectCollection;
 
        #define InterfaceDefined_SimplygonSDK_IObjectCollection 1
 
        class IGeometryData;
 
        class IGeometryDataCollection : public IObjectCollection
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IGeometryDataCollection",type)==0 )
                                return true;
                        return IObjectCollection::IsClassA(type);
                        }
                static IGeometryDataCollection *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IGeometryDataCollection") )
                                return static_cast<IGeometryDataCollection*>(ptr);
                        return NULL;
                        }
 
                virtual rhandle AddGeometryData( IGeometryData *obj ) = 0;
 
                virtual CountedPointer<IGeometryData> GetGeometryData( rhandle objhandle ) = 0;
 
                virtual void RemoveGeometryData( IGeometryData *pobj ) = 0;
 
                virtual CountedPointer<IGeometryData> FindGeometryData( const char * name ) = 0;
 
                virtual CountedPointer<IGeometryData> GetNextItemAsGeometryData( rhandle *phandle_rhandleInputDataPtr ) = 0;
 
                virtual bool IsGeometryDataInCollection( IGeometryData *pobj ) = 0;
 
        };
 
        typedef CountedPointer<IGeometryDataCollection> spGeometryDataCollection;
 
        #define InterfaceDefined_SimplygonSDK_IGeometryDataCollection 1
 
        class IScene;
 
        class IGraphicsImporter : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IGraphicsImporter",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IGraphicsImporter *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IGraphicsImporter") )
                                return static_cast<IGraphicsImporter*>(ptr);
                        return NULL;
                        }
 
                virtual void SetImportFilePath( const char * value ) = 0;
 
                virtual rstring GetImportFilePath(  ) = 0;
 
                virtual bool RunImport(  ) = 0;
 
                virtual void Clear(  ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
        };
 
        typedef CountedPointer<IGraphicsImporter> spGraphicsImporter;
 
        #define InterfaceDefined_SimplygonSDK_IGraphicsImporter 1
 
 
        class IWavefrontImporter : public IGraphicsImporter
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IWavefrontImporter",type)==0 )
                                return true;
                        return IGraphicsImporter::IsClassA(type);
                        }
                static IWavefrontImporter *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IWavefrontImporter") )
                                return static_cast<IWavefrontImporter*>(ptr);
                        return NULL;
                        }
 
                virtual void SetMaterialFilePath( const char * value ) = 0;
 
                virtual rstring GetMaterialFilePath(  ) = 0;
 
                virtual void SetExtractGroups( bool value ) = 0;
 
                virtual bool GetExtractGroups(  ) = 0;
 
                virtual void SetUseAlphaAsOpacity( bool value ) = 0;
 
                virtual bool GetUseAlphaAsOpacity(  ) = 0;
 
        };
 
        typedef CountedPointer<IWavefrontImporter> spWavefrontImporter;
 
        #define InterfaceDefined_SimplygonSDK_IWavefrontImporter 1
 
        class IScene;
 
        class IGraphicsExporter : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IGraphicsExporter",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IGraphicsExporter *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IGraphicsExporter") )
                                return static_cast<IGraphicsExporter*>(ptr);
                        return NULL;
                        }
 
                virtual void SetExportFilePath( const char * value ) = 0;
 
                virtual rstring GetExportFilePath(  ) = 0;
 
                virtual void SetScene( IScene *scene ) = 0;
 
                virtual void SetSelectionSet( int exportSelectionSetID ) = 0;
 
                virtual bool RunExport(  ) = 0;
 
                virtual void SetPrimaryTexCoordLevelName( const char * name ) = 0;
 
                virtual rstring GetPrimaryTexCoordLevelName(  ) = 0;
 
        };
 
        typedef CountedPointer<IGraphicsExporter> spGraphicsExporter;
 
        #define InterfaceDefined_SimplygonSDK_IGraphicsExporter 1
 
 
        class IWavefrontExporter : public IGraphicsExporter
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IWavefrontExporter",type)==0 )
                                return true;
                        return IGraphicsExporter::IsClassA(type);
                        }
                static IWavefrontExporter *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IWavefrontExporter") )
                                return static_cast<IWavefrontExporter*>(ptr);
                        return NULL;
                        }
 
                virtual void SetMaterialFilePath( const char * value ) = 0;
 
                virtual rstring GetMaterialFilePath(  ) = 0;
 
        };
 
        typedef CountedPointer<IWavefrontExporter> spWavefrontExporter;
 
        #define InterfaceDefined_SimplygonSDK_IWavefrontExporter 1
 
 
        class IBinaryImporter : public IGraphicsImporter
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IBinaryImporter",type)==0 )
                                return true;
                        return IGraphicsImporter::IsClassA(type);
                        }
                static IBinaryImporter *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IBinaryImporter") )
                                return static_cast<IBinaryImporter*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IBinaryImporter> spBinaryImporter;
 
        #define InterfaceDefined_SimplygonSDK_IBinaryImporter 1
 
 
        class IBinaryExporter : public IGraphicsExporter
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IBinaryExporter",type)==0 )
                                return true;
                        return IGraphicsExporter::IsClassA(type);
                        }
                static IBinaryExporter *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IBinaryExporter") )
                                return static_cast<IBinaryExporter*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IBinaryExporter> spBinaryExporter;
 
        #define InterfaceDefined_SimplygonSDK_IBinaryExporter 1
 
        class IGeometryData;
 
        class IGeometryValidator : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IGeometryValidator",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IGeometryValidator *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IGeometryValidator") )
                                return static_cast<IGeometryValidator*>(ptr);
                        return NULL;
                        }
 
                virtual bool ValidateGeometry( IGeometryData *geom ) = 0;
 
                virtual unsigned int GetErrorValue(  ) = 0;
 
                virtual rstring GetErrorString(  ) = 0;
 
                virtual void SetCheckDegenerateFaceIndices( bool value ) = 0;
 
                virtual bool GetCheckDegenerateFaceIndices(  ) = 0;
 
                virtual void SetCheckZeroAreaFaces( bool value ) = 0;
 
                virtual bool GetCheckZeroAreaFaces(  ) = 0;
 
                virtual void SetAllowedMaterialCount( unsigned int value ) = 0;
 
                virtual void SetAllowedBoneCount( unsigned int value ) = 0;
 
                virtual void SetAllowedGroupCount( unsigned int value ) = 0;
 
        };
 
        typedef CountedPointer<IGeometryValidator> spGeometryValidator;
 
        #define InterfaceDefined_SimplygonSDK_IGeometryValidator 1
 
 
        class ISettingsObject : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ISettingsObject",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static ISettingsObject *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ISettingsObject") )
                                return static_cast<ISettingsObject*>(ptr);
                        return NULL;
                        }
 
                virtual bool ValidateSettings(  ) = 0;
 
                virtual rstring GetErrorString(  ) = 0;
 
        };
 
        typedef CountedPointer<ISettingsObject> spSettingsObject;
 
        #define InterfaceDefined_SimplygonSDK_ISettingsObject 1
 
        class IMaterialCasterSettings;
        class ITextureTable;
        class IMaterialTable;
        class IMappingImage;
        class IImageData;
 
        class IMaterialCaster : public IProcessingObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IMaterialCaster",type)==0 )
                                return true;
                        return IProcessingObject::IsClassA(type);
                        }
                static IMaterialCaster *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IMaterialCaster") )
                                return static_cast<IMaterialCaster*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IMaterialCasterSettings> GetCasterSettings(  ) = 0;
 
                virtual void SetSourceTextures( ITextureTable *value ) = 0;
 
                virtual CountedPointer<ITextureTable> GetSourceTextures(  ) = 0;
 
                virtual void SetSourceMaterials( IMaterialTable *value ) = 0;
 
                virtual CountedPointer<IMaterialTable> GetSourceMaterials(  ) = 0;
 
                virtual void SetDestMaterialId( rid value ) = 0;
 
                virtual rid GetDestMaterialId(  ) = 0;
 
                virtual void SetMappingImage( IMappingImage *value ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
                virtual void SetDilation( unsigned int Dilation ) = 0;
 
                virtual unsigned int GetDilation(  ) = 0;
 
                virtual void SetOutputChannels( unsigned int OutputChannels ) = 0;
 
                virtual unsigned int GetOutputChannels(  ) = 0;
 
                virtual void SetOutputChannelBitDepth( unsigned int OutputChannelBitDepth ) = 0;
 
                virtual unsigned int GetOutputChannelBitDepth(  ) = 0;
 
                virtual void SetOutputFilePath( const char * value ) = 0;
 
                virtual rstring GetOutputFilePath(  ) = 0;
 
                virtual void SetOutputImage( IImageData *value ) = 0;
 
                virtual CountedPointer<IImageData> GetOutputImage(  ) = 0;
 
                virtual void SetDitherType( unsigned int DitherType ) = 0;
 
                virtual unsigned int GetDitherType(  ) = 0;
 
                virtual void SetFillMode( unsigned int FillMode ) = 0;
 
                virtual unsigned int GetFillMode(  ) = 0;
 
                virtual void SetUseMultisampling( bool UseMultisampling ) = 0;
 
                virtual bool GetUseMultisampling(  ) = 0;
 
                virtual SGDEPRECATED void CastMaterials(  ) = 0;
 
        };
 
        typedef CountedPointer<IMaterialCaster> spMaterialCaster;
 
        #define InterfaceDefined_SimplygonSDK_IMaterialCaster 1
 
 
        class IMaterialCasterSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IMaterialCasterSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IMaterialCasterSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IMaterialCasterSettings") )
                                return static_cast<IMaterialCasterSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetMaterialChannel( const char * value ) = 0;
 
                virtual rstring GetMaterialChannel(  ) = 0;
 
                virtual void SetDilation( unsigned int value ) = 0;
 
                virtual unsigned int GetDilation(  ) = 0;
 
                virtual void SetOutputChannels( unsigned int value ) = 0;
 
                virtual unsigned int GetOutputChannels(  ) = 0;
 
                virtual void SetOutputChannelBitDepth( unsigned int value ) = 0;
 
                virtual unsigned int GetOutputChannelBitDepth(  ) = 0;
 
                virtual void SetDitherType( unsigned int value ) = 0;
 
                virtual unsigned int GetDitherType(  ) = 0;
 
                virtual void SetFillMode( int value ) = 0;
 
                virtual int GetFillMode(  ) = 0;
 
                virtual void SetUseMultisampling( bool value ) = 0;
 
                virtual bool GetUseMultisampling(  ) = 0;
 
        };
 
        typedef CountedPointer<IMaterialCasterSettings> spMaterialCasterSettings;
 
        #define InterfaceDefined_SimplygonSDK_IMaterialCasterSettings 1
 
        class IColorCasterSettings;
 
        class IColorCaster : public IMaterialCaster
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IColorCaster",type)==0 )
                                return true;
                        return IMaterialCaster::IsClassA(type);
                        }
                static IColorCaster *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IColorCaster") )
                                return static_cast<IColorCaster*>(ptr);
                        return NULL;
                        }
 
                virtual void SetColorType( const char * ColorType ) = 0;
 
                virtual rstring GetColorType(  ) = 0;
 
                virtual void SetOutputSRGB( bool OutputSRGB ) = 0;
 
                virtual bool GetOutputSRGB(  ) = 0;
 
                virtual void SetBakeOpacityInAlpha( bool BakeOpacityInAlpha ) = 0;
 
                virtual bool GetBakeOpacityInAlpha(  ) = 0;
 
                virtual void SetSkipCastingIfNoInputChannel( bool SkipCastingIfNoInputChannel ) = 0;
 
                virtual bool GetSkipCastingIfNoInputChannel(  ) = 0;
 
                virtual bool GetLastCastingWasSkipped(  ) = 0;
 
                virtual CountedPointer<IColorCasterSettings> GetColorCasterSettings(  ) = 0;
 
        };
 
        typedef CountedPointer<IColorCaster> spColorCaster;
 
        #define InterfaceDefined_SimplygonSDK_IColorCaster 1
 
 
        class IColorCasterSettings : public IMaterialCasterSettings
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IColorCasterSettings",type)==0 )
                                return true;
                        return IMaterialCasterSettings::IsClassA(type);
                        }
                static IColorCasterSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IColorCasterSettings") )
                                return static_cast<IColorCasterSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetOutputSRGB( bool value ) = 0;
 
                virtual bool GetOutputSRGB(  ) = 0;
 
                virtual void SetBakeOpacityInAlpha( bool value ) = 0;
 
                virtual bool GetBakeOpacityInAlpha(  ) = 0;
 
                virtual void SetSkipCastingIfNoInputChannel( bool value ) = 0;
 
                virtual bool GetSkipCastingIfNoInputChannel(  ) = 0;
 
        };
 
        typedef CountedPointer<IColorCasterSettings> spColorCasterSettings;
 
        #define InterfaceDefined_SimplygonSDK_IColorCasterSettings 1
 
        class IOpacityCasterSettings;
 
        class IOpacityCaster : public IMaterialCaster
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IOpacityCaster",type)==0 )
                                return true;
                        return IMaterialCaster::IsClassA(type);
                        }
                static IOpacityCaster *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IOpacityCaster") )
                                return static_cast<IOpacityCaster*>(ptr);
                        return NULL;
                        }
 
                virtual void SetColorType( const char * ColorType ) = 0;
 
                virtual rstring GetColorType(  ) = 0;
 
                virtual void SetOutputSRGB( bool OutputSRGB ) = 0;
 
                virtual bool GetOutputSRGB(  ) = 0;
 
                virtual CountedPointer<IOpacityCasterSettings> GetOpacityCasterSettings(  ) = 0;
 
        };
 
        typedef CountedPointer<IOpacityCaster> spOpacityCaster;
 
        #define InterfaceDefined_SimplygonSDK_IOpacityCaster 1
 
 
        class IOpacityCasterSettings : public IMaterialCasterSettings
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IOpacityCasterSettings",type)==0 )
                                return true;
                        return IMaterialCasterSettings::IsClassA(type);
                        }
                static IOpacityCasterSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IOpacityCasterSettings") )
                                return static_cast<IOpacityCasterSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetOutputSRGB( bool value ) = 0;
 
                virtual bool GetOutputSRGB(  ) = 0;
 
        };
 
        typedef CountedPointer<IOpacityCasterSettings> spOpacityCasterSettings;
 
        #define InterfaceDefined_SimplygonSDK_IOpacityCasterSettings 1
 
        class INormalCasterSettings;
 
        class INormalCaster : public IMaterialCaster
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("INormalCaster",type)==0 )
                                return true;
                        return IMaterialCaster::IsClassA(type);
                        }
                static INormalCaster *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("INormalCaster") )
                                return static_cast<INormalCaster*>(ptr);
                        return NULL;
                        }
 
                virtual void SetNormalsChannel( const char * NormalsChannel ) = 0;
 
                virtual rstring GetNormalsChannel(  ) = 0;
 
                virtual void SetFlipBackfacingNormals( bool FlipBackfacingNormals ) = 0;
 
                virtual bool GetFlipBackfacingNormals(  ) = 0;
 
                virtual void SetGenerateTangentSpaceNormals( bool GenerateTangentSpaceNormals ) = 0;
 
                virtual bool GetGenerateTangentSpaceNormals(  ) = 0;
 
                virtual void SetFlipGreen( bool FlipGreen ) = 0;
 
                virtual bool GetFlipGreen(  ) = 0;
 
                virtual CountedPointer<INormalCasterSettings> GetNormalCasterSettings(  ) = 0;
 
        };
 
        typedef CountedPointer<INormalCaster> spNormalCaster;
 
        #define InterfaceDefined_SimplygonSDK_INormalCaster 1
 
 
        class INormalCasterSettings : public IMaterialCasterSettings
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("INormalCasterSettings",type)==0 )
                                return true;
                        return IMaterialCasterSettings::IsClassA(type);
                        }
                static INormalCasterSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("INormalCasterSettings") )
                                return static_cast<INormalCasterSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetFlipBackfacingNormals( bool value ) = 0;
 
                virtual bool GetFlipBackfacingNormals(  ) = 0;
 
                virtual void SetGenerateTangentSpaceNormals( bool value ) = 0;
 
                virtual bool GetGenerateTangentSpaceNormals(  ) = 0;
 
                virtual void SetFlipGreen( bool value ) = 0;
 
                virtual bool GetFlipGreen(  ) = 0;
 
        };
 
        typedef CountedPointer<INormalCasterSettings> spNormalCasterSettings;
 
        #define InterfaceDefined_SimplygonSDK_INormalCasterSettings 1
 
        class IScene;
        class IGeometryData;
 
        class INormalRepairer : public IProcessingObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("INormalRepairer",type)==0 )
                                return true;
                        return IProcessingObject::IsClassA(type);
                        }
                static INormalRepairer *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("INormalRepairer") )
                                return static_cast<INormalRepairer*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual void SetSelectionSetID( rid value ) = 0;
 
                virtual rid GetSelectionSetID(  ) = 0;
 
                virtual void SetProcessSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetProcessSelectionSetName(  ) = 0;
 
                virtual bool GetRecalculateNormals(  ) = 0;
 
                virtual void SetRecalculateNormals( bool value ) = 0;
 
                virtual real GetHardEdgeAngleInRadians(  ) = 0;
 
                virtual void SetHardEdgeAngleInRadians( real value ) = 0;
 
                virtual unsigned int GetBorderFlagsMask(  ) = 0;
 
                virtual void SetBorderFlagsMask( unsigned int value ) = 0;
 
                virtual bool GetScaleByArea(  ) = 0;
 
                virtual void SetScaleByArea( bool value ) = 0;
 
                virtual bool GetScaleByAngle(  ) = 0;
 
                virtual void SetScaleByAngle( bool value ) = 0;
 
                virtual bool GetRepairOnlyInvalidNormals(  ) = 0;
 
                virtual void SetRepairOnlyInvalidNormals( bool value ) = 0;
 
                virtual bool GetSnapNormalsToFlatSurfaces(  ) = 0;
 
                virtual void SetSnapNormalsToFlatSurfaces( bool value ) = 0;
 
                virtual SGDEPRECATED bool GetDetectPrimitiveNormals(  ) = 0;
 
                virtual SGDEPRECATED void SetDetectPrimitiveNormals( bool detectPrimitiveNormals ) = 0;
 
                virtual unsigned int GetFlipFacesAndNormals(  ) = 0;
 
                virtual void SetFlipFacesAndNormals( unsigned int value ) = 0;
 
                virtual CountedPointer<IGeometryData> GetGeometry(  ) = 0;
 
                virtual void SetGeometry( IGeometryData *value ) = 0;
 
                virtual void SetAutoCorrectionAllowsDoubleSided( bool value ) = 0;
 
                virtual void SetAutoCorrectionRatioThreshold( real value ) = 0;
 
                virtual void SetAutoCorrectionSingleSidedThreshold( real value ) = 0;
 
        };
 
        typedef CountedPointer<INormalRepairer> spNormalRepairer;
 
        #define InterfaceDefined_SimplygonSDK_INormalRepairer 1
 
        class IDisplacementCasterSettings;
 
        class IDisplacementCaster : public IMaterialCaster
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IDisplacementCaster",type)==0 )
                                return true;
                        return IMaterialCaster::IsClassA(type);
                        }
                static IDisplacementCaster *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IDisplacementCaster") )
                                return static_cast<IDisplacementCaster*>(ptr);
                        return NULL;
                        }
 
                virtual void SetDistanceScaling( real DistanceScaling ) = 0;
 
                virtual real GetDistanceScaling(  ) = 0;
 
                virtual void SetGenerateScalarDisplacement( bool GenerateScalarDisplacement ) = 0;
 
                virtual bool GetGenerateScalarDisplacement(  ) = 0;
 
                virtual void SetGenerateTangentSpaceDisplacement( bool GenerateTangentSpaceDisplacement ) = 0;
 
                virtual bool GetGenerateTangentSpaceDisplacement(  ) = 0;
 
                virtual void SetNormalMapTextureLevel( rid NormalMapTextureLevel ) = 0;
 
                virtual rid GetNormalMapTextureLevel(  ) = 0;
 
                virtual CountedPointer<IDisplacementCasterSettings> GetDisplacementCasterSettings(  ) = 0;
 
        };
 
        typedef CountedPointer<IDisplacementCaster> spDisplacementCaster;
 
        #define InterfaceDefined_SimplygonSDK_IDisplacementCaster 1
 
 
        class IDisplacementCasterSettings : public IMaterialCasterSettings
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IDisplacementCasterSettings",type)==0 )
                                return true;
                        return IMaterialCasterSettings::IsClassA(type);
                        }
                static IDisplacementCasterSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IDisplacementCasterSettings") )
                                return static_cast<IDisplacementCasterSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetDistanceScaling( real value ) = 0;
 
                virtual real GetDistanceScaling(  ) = 0;
 
                virtual void SetGenerateScalarDisplacement( bool value ) = 0;
 
                virtual bool GetGenerateScalarDisplacement(  ) = 0;
 
                virtual void SetGenerateTangentSpaceDisplacement( bool value ) = 0;
 
                virtual bool GetGenerateTangentSpaceDisplacement(  ) = 0;
 
                virtual void SetNormalMapTextureLevel( rid value ) = 0;
 
                virtual rid GetNormalMapTextureLevel(  ) = 0;
 
        };
 
        typedef CountedPointer<IDisplacementCasterSettings> spDisplacementCasterSettings;
 
        #define InterfaceDefined_SimplygonSDK_IDisplacementCasterSettings 1
 
        class IGeometryData;
        class ISceneNode;
 
        class ITangentCalculator : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ITangentCalculator",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static ITangentCalculator *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ITangentCalculator") )
                                return static_cast<ITangentCalculator*>(ptr);
                        return NULL;
                        }
 
                virtual void CalculateTangents( IGeometryData *geom ) = 0;
 
                virtual void CalculateTangents( ISceneNode *node ) = 0;
 
                virtual void SetTexCoordsSetId( rid value ) = 0;
 
                virtual void SetTangentCalculatorType( rid type ) = 0;
 
                virtual rid GetTangentCalculatorType(  ) = 0;
 
        };
 
        typedef CountedPointer<ITangentCalculator> spTangentCalculator;
 
        #define InterfaceDefined_SimplygonSDK_ITangentCalculator 1
 
 
        class IRepairSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IRepairSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IRepairSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IRepairSettings") )
                                return static_cast<IRepairSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetTjuncDist( real value ) = 0;
 
                virtual real GetTjuncDist(  ) = 0;
 
                virtual void SetUseTJunctionRemover( bool value ) = 0;
 
                virtual bool GetUseTJunctionRemover(  ) = 0;
 
                virtual void SetWeldDist( real value ) = 0;
 
                virtual real GetWeldDist(  ) = 0;
 
                virtual void SetWeldOnlyBorderVertices( bool value ) = 0;
 
                virtual bool GetWeldOnlyBorderVertices(  ) = 0;
 
                virtual void SetWeldOnlyWithinMaterial( bool value ) = 0;
 
                virtual bool GetWeldOnlyWithinMaterial(  ) = 0;
 
                virtual void SetWeldOnlyWithinSceneNode( bool value ) = 0;
 
                virtual bool GetWeldOnlyWithinSceneNode(  ) = 0;
 
                virtual SGDEPRECATED bool GetWeldOnlyObjectBoundary(  ) = 0;
 
                virtual SGDEPRECATED void SetWeldOnlyObjectBoundary( bool weldOnlyObjectBoundary ) = 0;
 
                virtual void SetWeldOnlyBetweenSceneNodes( bool value ) = 0;
 
                virtual bool GetWeldOnlyBetweenSceneNodes(  ) = 0;
 
                virtual void SetUseWelding( bool value ) = 0;
 
                virtual bool GetUseWelding(  ) = 0;
 
                virtual void SetProgressivePasses( unsigned int value ) = 0;
 
                virtual unsigned int GetProgressivePasses(  ) = 0;
 
        };
 
        typedef CountedPointer<IRepairSettings> spRepairSettings;
 
        #define InterfaceDefined_SimplygonSDK_IRepairSettings 1
 
 
        class IBoneSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IBoneSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IBoneSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IBoneSettings") )
                                return static_cast<IBoneSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetBoneReductionTargets( unsigned int value ) = 0;
 
                virtual unsigned int GetBoneReductionTargets(  ) = 0;
 
                virtual void SetStopCondition( unsigned int value ) = 0;
 
                virtual unsigned int GetStopCondition(  ) = 0;
 
                virtual void SetBoneRatio( real value ) = 0;
 
                virtual real GetBoneRatio(  ) = 0;
 
                virtual void SetBoneCount( unsigned int value ) = 0;
 
                virtual unsigned int GetBoneCount(  ) = 0;
 
                virtual void SetMaxDeviation( real value ) = 0;
 
                virtual real GetMaxDeviation(  ) = 0;
 
                virtual void SetOnScreenSize( unsigned int value ) = 0;
 
                virtual unsigned int GetOnScreenSize(  ) = 0;
 
                virtual void SetMaxBonePerVertex( unsigned int value ) = 0;
 
                virtual unsigned int GetMaxBonePerVertex(  ) = 0;
 
                virtual void SetRemoveUnusedBones( bool value ) = 0;
 
                virtual bool GetRemoveUnusedBones(  ) = 0;
 
                virtual void SetLimitBonesPerVertex( bool value ) = 0;
 
                virtual bool GetLimitBonesPerVertex(  ) = 0;
 
                virtual void SetUseBoneReducer( bool value ) = 0;
 
                virtual bool GetUseBoneReducer(  ) = 0;
 
                virtual void SetLockBoneSelectionSetID( rid value ) = 0;
 
                virtual rid GetLockBoneSelectionSetID(  ) = 0;
 
                virtual void SetLockBoneSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetLockBoneSelectionSetName(  ) = 0;
 
                virtual void SetRemoveBoneSelectionSetID( rid value ) = 0;
 
                virtual rid GetRemoveBoneSelectionSetID(  ) = 0;
 
                virtual void SetRemoveBoneSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetRemoveBoneSelectionSetName(  ) = 0;
 
        };
 
        typedef CountedPointer<IBoneSettings> spBoneSettings;
 
        #define InterfaceDefined_SimplygonSDK_IBoneSettings 1
 
 
        class IReductionSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IReductionSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IReductionSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IReductionSettings") )
                                return static_cast<IReductionSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetReductionTargets( unsigned int value ) = 0;
 
                virtual unsigned int GetReductionTargets(  ) = 0;
 
                virtual void SetStopCondition( unsigned int value ) = 0;
 
                virtual unsigned int GetStopCondition(  ) = 0;
 
                virtual void SetReductionHeuristics( unsigned int value ) = 0;
 
                virtual unsigned int GetReductionHeuristics(  ) = 0;
 
                virtual void SetTriangleRatio( real value ) = 0;
 
                virtual real GetTriangleRatio(  ) = 0;
 
                virtual void SetTriangleCount( unsigned int value ) = 0;
 
                virtual unsigned int GetTriangleCount(  ) = 0;
 
                virtual void SetMaxDeviation( real value ) = 0;
 
                virtual real GetMaxDeviation(  ) = 0;
 
                virtual void SetOnScreenSize( unsigned int value ) = 0;
 
                virtual unsigned int GetOnScreenSize(  ) = 0;
 
                virtual void SetGeometryImportance( real value ) = 0;
 
                virtual void SetMaterialImportance( real value ) = 0;
 
                virtual void SetTextureImportance( real value ) = 0;
 
                virtual void SetShadingImportance( real value ) = 0;
 
                virtual void SetGroupImportance( real value ) = 0;
 
                virtual void SetVertexColorImportance( real value ) = 0;
 
                virtual void SetEdgeSetImportance( real value ) = 0;
 
                virtual void SetSkinningImportance( real value ) = 0;
 
                virtual void SetCurvatureImportance( real value ) = 0;
 
                virtual real GetGeometryImportance(  ) = 0;
 
                virtual real GetMaterialImportance(  ) = 0;
 
                virtual real GetTextureImportance(  ) = 0;
 
                virtual real GetShadingImportance(  ) = 0;
 
                virtual real GetGroupImportance(  ) = 0;
 
                virtual real GetVertexColorImportance(  ) = 0;
 
                virtual real GetEdgeSetImportance(  ) = 0;
 
                virtual real GetSkinningImportance(  ) = 0;
 
                virtual real GetCurvatureImportance(  ) = 0;
 
                virtual void SetUseVertexWeights( bool value ) = 0;
 
                virtual bool GetUseVertexWeights(  ) = 0;
 
                virtual void SetCreateGeomorphGeometry( bool value ) = 0;
 
                virtual bool GetCreateGeomorphGeometry(  ) = 0;
 
                virtual void SetAllowDegenerateTexCoords( bool value ) = 0;
 
                virtual bool GetAllowDegenerateTexCoords(  ) = 0;
 
                virtual void SetKeepSymmetry( bool value ) = 0;
 
                virtual bool GetKeepSymmetry(  ) = 0;
 
                virtual void SetUseAutomaticSymmetryDetection( bool value ) = 0;
 
                virtual bool GetUseAutomaticSymmetryDetection(  ) = 0;
 
                virtual void SetUseSymmetryQuadRetriangulator( bool value ) = 0;
 
                virtual bool GetUseSymmetryQuadRetriangulator(  ) = 0;
 
                virtual void SetSymmetryAxis( unsigned int value ) = 0;
 
                virtual unsigned int GetSymmetryAxis(  ) = 0;
 
                virtual void SetSymmetryOffset( real value ) = 0;
 
                virtual real GetSymmetryOffset(  ) = 0;
 
                virtual void SetSymmetryDetectionTolerance( real value ) = 0;
 
                virtual real GetSymmetryDetectionTolerance(  ) = 0;
 
                virtual void SetDataCreationPreferences( unsigned int value ) = 0;
 
                virtual unsigned int GetDataCreationPreferences(  ) = 0;
 
                virtual void SetGenerateGeomorphData( bool value ) = 0;
 
                virtual bool GetGenerateGeomorphData(  ) = 0;
 
                virtual void SetOutwardMoveMultiplier( real value ) = 0;
 
                virtual real GetOutwardMoveMultiplier(  ) = 0;
 
                virtual void SetInwardMoveMultiplier( real value ) = 0;
 
                virtual real GetInwardMoveMultiplier(  ) = 0;
 
                virtual void SetMaxEdgeLength( real value ) = 0;
 
                virtual real GetMaxEdgeLength(  ) = 0;
 
                virtual void SetUseHighQualityNormalCalculation( bool value ) = 0;
 
                virtual bool GetUseHighQualityNormalCalculation(  ) = 0;
 
                virtual void SetProcessSelectionSetID( rid value ) = 0;
 
                virtual rid GetProcessSelectionSetID(  ) = 0;
 
                virtual void SetProcessSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetProcessSelectionSetName(  ) = 0;
 
                virtual void SetMergeGeometries( bool value ) = 0;
 
                virtual bool GetMergeGeometries(  ) = 0;
 
                virtual void SetWeightsFromColorChannelName( const char * value ) = 0;
 
                virtual rstring GetWeightsFromColorChannelName(  ) = 0;
 
                virtual void SetWeightsFromColorChannelID( rid value ) = 0;
 
                virtual rid GetWeightsFromColorChannelID(  ) = 0;
 
                virtual void SetLockGeometricBorder( bool value ) = 0;
 
                virtual bool GetLockGeometricBorder(  ) = 0;
 
        };
 
        typedef CountedPointer<IReductionSettings> spReductionSettings;
 
        #define InterfaceDefined_SimplygonSDK_IReductionSettings 1
 
 
        class INormalCalculationSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("INormalCalculationSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static INormalCalculationSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("INormalCalculationSettings") )
                                return static_cast<INormalCalculationSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetReplaceNormals( bool value ) = 0;
 
                virtual bool GetReplaceNormals(  ) = 0;
 
                virtual void SetReplaceTangents( bool value ) = 0;
 
                virtual bool GetReplaceTangents(  ) = 0;
 
                virtual void SetHardEdgeAngleInRadians( real value ) = 0;
 
                virtual real GetHardEdgeAngleInRadians(  ) = 0;
 
                virtual void SetRepairInvalidNormals( bool value ) = 0;
 
                virtual bool GetRepairInvalidNormals(  ) = 0;
 
                virtual bool GetScaleByArea(  ) = 0;
 
                virtual void SetScaleByArea( bool value ) = 0;
 
                virtual bool GetScaleByAngle(  ) = 0;
 
                virtual void SetScaleByAngle( bool value ) = 0;
 
                virtual bool GetSnapNormalsToFlatSurfaces(  ) = 0;
 
                virtual void SetSnapNormalsToFlatSurfaces( bool value ) = 0;
 
                virtual SGDEPRECATED bool GetDetectPrimitiveNormals(  ) = 0;
 
                virtual SGDEPRECATED void SetDetectPrimitiveNormals( bool detectPrimitiveNormals ) = 0;
 
        };
 
        typedef CountedPointer<INormalCalculationSettings> spNormalCalculationSettings;
 
        #define InterfaceDefined_SimplygonSDK_INormalCalculationSettings 1
 
 
        class IMappingImageSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IMappingImageSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IMappingImageSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IMappingImageSettings") )
                                return static_cast<IMappingImageSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetInputMaterialCount( unsigned int value ) = 0;
 
                virtual unsigned int GetInputMaterialCount(  ) = 0;
 
                virtual void SetOutputMaterialCount( unsigned int value ) = 0;
 
                virtual unsigned int GetOutputMaterialCount(  ) = 0;
 
                virtual void SetInputOutputMaterialMapping( unsigned int InMaterialId , unsigned int OutMaterialId ) = 0;
 
                virtual int GetInputOutputMaterialMapping( unsigned int InMaterialId ) = 0;
 
                virtual void SetWidth( unsigned int value ) = 0;
 
                virtual void SetWidth( unsigned int id , unsigned int value ) = 0;
 
                virtual unsigned int GetWidth(  ) = 0;
 
                virtual unsigned int GetWidth( unsigned int id ) = 0;
 
                virtual void SetMappingImageName( const char * name ) = 0;
 
                virtual void SetMappingImageName( unsigned int id , const char * name ) = 0;
 
                virtual rstring GetMappingImageName(  ) = 0;
 
                virtual rstring GetMappingImageName( unsigned int id ) = 0;
 
                virtual void SetReplaceMappingImages( bool value ) = 0;
 
                virtual bool GetReplaceMappingImages(  ) = 0;
 
                virtual void SetHeight( unsigned int value ) = 0;
 
                virtual void SetHeight( unsigned int id , unsigned int value ) = 0;
 
                virtual unsigned int GetHeight(  ) = 0;
 
                virtual unsigned int GetHeight( unsigned int id ) = 0;
 
                virtual void SetMultisamplingLevel( unsigned int value ) = 0;
 
                virtual void SetMultisamplingLevel( unsigned int id , unsigned int value ) = 0;
 
                virtual unsigned int GetMultisamplingLevel(  ) = 0;
 
                virtual unsigned int GetMultisamplingLevel( unsigned int id ) = 0;
 
                virtual void SetGutterSpace( unsigned int value ) = 0;
 
                virtual void SetGutterSpace( unsigned int id , unsigned int value ) = 0;
 
                virtual unsigned int GetGutterSpace(  ) = 0;
 
                virtual unsigned int GetGutterSpace( unsigned int id ) = 0;
 
                virtual void SetMaximumLayers( unsigned int value ) = 0;
 
                virtual unsigned int GetMaximumLayers(  ) = 0;
 
                virtual void SetAllowTransparencyMapping( bool value ) = 0;
 
                virtual bool GetAllowTransparencyMapping(  ) = 0;
 
                virtual void SetGenerateMappingImage( bool value ) = 0;
 
                virtual bool GetGenerateMappingImage(  ) = 0;
 
                virtual void SetGenerateTexCoords( bool value ) = 0;
 
                virtual bool GetGenerateTexCoords(  ) = 0;
 
                virtual void SetGenerateTangents( bool value ) = 0;
 
                virtual bool GetGenerateTangents(  ) = 0;
 
                virtual void SetTexCoordLevel( rid value ) = 0;
 
                virtual rid GetTexCoordLevel(  ) = 0;
 
                virtual void SetTexCoordLevelName( const char * value ) = 0;
 
                virtual rstring GetTexCoordLevelName(  ) = 0;
 
                virtual void SetUseFullRetexturing( bool value ) = 0;
 
                virtual bool GetUseFullRetexturing(  ) = 0;
 
                virtual void SetUseAutomaticTextureSize( bool value ) = 0;
 
                virtual bool GetUseAutomaticTextureSize(  ) = 0;
 
                virtual void SetAutomaticTextureSizeMultiplier( real value ) = 0;
 
                virtual real GetAutomaticTextureSizeMultiplier(  ) = 0;
 
                virtual void SetForcePower2Texture( bool value ) = 0;
 
                virtual bool GetForcePower2Texture(  ) = 0;
 
                virtual void SetTexCoordGeneratorType( unsigned int value ) = 0;
 
                virtual unsigned int GetTexCoordGeneratorType(  ) = 0;
 
                virtual void SetChartAggregatorMode( unsigned int value ) = 0;
 
                virtual unsigned int GetChartAggregatorMode(  ) = 0;
 
                virtual void SetParameterizerMaxStretch( real value ) = 0;
 
                virtual real GetParameterizerMaxStretch(  ) = 0;
 
                virtual void SetUseVertexWeights( bool value ) = 0;
 
                virtual bool GetUseVertexWeights(  ) = 0;
 
                virtual void SetChartAggregatorOriginalTexCoordLevel( rid value ) = 0;
 
                virtual rid GetChartAggregatorOriginalTexCoordLevel(  ) = 0;
 
                virtual void SetChartAggregatorOriginalTexCoordLevelName( const char * value ) = 0;
 
                virtual rstring GetChartAggregatorOriginalTexCoordLevelName(  ) = 0;
 
                virtual void SetChartAggregatorSeparateOverlappingCharts( bool value ) = 0;
 
                virtual bool GetChartAggregatorSeparateOverlappingCharts(  ) = 0;
 
                virtual void SetChartAggregatorOriginalChartProportionsChannel( const char * value ) = 0;
 
                virtual rstring GetChartAggregatorOriginalChartProportionsChannel(  ) = 0;
 
                virtual void SetParameterizerLargeChartsImportance( real value ) = 0;
 
                virtual real GetParameterizerLargeChartsImportance(  ) = 0;
 
                virtual bool GetChartAggregatorLockUVRotation(  ) = 0;
 
                virtual void SetChartAggregatorLockUVRotation( bool value ) = 0;
 
                virtual bool GetOnlyParameterizeInvalidUVs(  ) = 0;
 
                virtual void SetOnlyParameterizeInvalidUVs( bool value ) = 0;
 
        };
 
        typedef CountedPointer<IMappingImageSettings> spMappingImageSettings;
 
        #define InterfaceDefined_SimplygonSDK_IMappingImageSettings 1
 
 
        class IVisibilitySettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IVisibilitySettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IVisibilitySettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IVisibilitySettings") )
                                return static_cast<IVisibilitySettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetUseVisibilityWeightsInReducer( bool value ) = 0;
 
                virtual bool GetUseVisibilityWeightsInReducer(  ) = 0;
 
                virtual void SetUseVisibilityWeightsInTexcoordGenerator( bool value ) = 0;
 
                virtual bool GetUseVisibilityWeightsInTexcoordGenerator(  ) = 0;
 
                virtual void SetVisibilityWeightsPower( real value ) = 0;
 
                virtual real GetVisibilityWeightsPower(  ) = 0;
 
                virtual void SetCullOccludedGeometry( bool value ) = 0;
 
                virtual bool GetCullOccludedGeometry(  ) = 0;
 
                virtual void SetForceVisibilityCalculation( bool value ) = 0;
 
                virtual bool GetForceVisibilityCalculation(  ) = 0;
 
                virtual void SetUseBackfaceCulling( bool value ) = 0;
 
                virtual bool GetUseBackfaceCulling(  ) = 0;
 
                virtual void SetCameraSelectionSetID( int value ) = 0;
 
                virtual int GetCameraSelectionSetID(  ) = 0;
 
                virtual void SetCameraSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetCameraSelectionSetName(  ) = 0;
 
                virtual void SetOccluderSelectionSetID( int value ) = 0;
 
                virtual int GetOccluderSelectionSetID(  ) = 0;
 
                virtual void SetOccluderSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetOccluderSelectionSetName(  ) = 0;
 
                virtual void SetFillNonVisibleAreaThreshold( real value ) = 0;
 
                virtual real GetFillNonVisibleAreaThreshold(  ) = 0;
 
                virtual void SetRemoveTrianglesNotOccludingOtherTriangles( bool value ) = 0;
 
                virtual bool GetRemoveTrianglesNotOccludingOtherTriangles(  ) = 0;
 
                virtual void SetConservativeMode( bool value ) = 0;
 
                virtual bool GetConservativeMode(  ) = 0;
 
                virtual void SetComputeVisibilityMode( unsigned int value ) = 0;
 
                virtual unsigned int GetComputeVisibilityMode(  ) = 0;
 
        };
 
        typedef CountedPointer<IVisibilitySettings> spVisibilitySettings;
 
        #define InterfaceDefined_SimplygonSDK_IVisibilitySettings 1
 
        class IScene;
        class IMappingImage;
        class IRepairSettings;
        class IReductionSettings;
        class IBoneSettings;
        class INormalCalculationSettings;
        class IMappingImageSettings;
        class IVisibilitySettings;
 
        class IReductionProcessor : public IProcessingObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IReductionProcessor",type)==0 )
                                return true;
                        return IProcessingObject::IsClassA(type);
                        }
                static IReductionProcessor *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IReductionProcessor") )
                                return static_cast<IReductionProcessor*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage( rid OutputMaterialId ) = 0;
 
                virtual CountedPointer<IRepairSettings> GetRepairSettings(  ) = 0;
 
                virtual CountedPointer<IReductionSettings> GetReductionSettings(  ) = 0;
 
                virtual CountedPointer<IBoneSettings> GetBoneSettings(  ) = 0;
 
                virtual CountedPointer<INormalCalculationSettings> GetNormalCalculationSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImageSettings> GetMappingImageSettings(  ) = 0;
 
                virtual CountedPointer<IVisibilitySettings> GetVisibilitySettings(  ) = 0;
 
                virtual real GetResultDeviation(  ) = 0;
 
        };
 
        typedef CountedPointer<IReductionProcessor> spReductionProcessor;
 
        #define InterfaceDefined_SimplygonSDK_IReductionProcessor 1
 
 
        class IRemeshingSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IRemeshingSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IRemeshingSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IRemeshingSettings") )
                                return static_cast<IRemeshingSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetOnScreenSize( unsigned int value ) = 0;
 
                virtual unsigned int GetOnScreenSize(  ) = 0;
 
                virtual void SetMergeDistance( unsigned int value ) = 0;
 
                virtual unsigned int GetMergeDistance(  ) = 0;
 
                virtual void SetMergeBoldness( real value ) = 0;
 
                virtual real GetMergeBoldness(  ) = 0;
 
                virtual void SetMaxTriangleSize( unsigned int value ) = 0;
 
                virtual unsigned int GetMaxTriangleSize(  ) = 0;
 
                virtual void SetSurfaceTransferMode( rid value ) = 0;
 
                virtual rid GetSurfaceTransferMode(  ) = 0;
 
                virtual void SetUseCuttingPlanes( bool value ) = 0;
 
                virtual bool GetUseCuttingPlanes(  ) = 0;
 
                virtual void SetHardEdgeAngleInRadians( real value ) = 0;
 
                virtual real GetHardEdgeAngleInRadians(  ) = 0;
 
                virtual void SetTransferNormals( bool value ) = 0;
 
                virtual bool GetTransferNormals(  ) = 0;
 
                virtual void SetTransferColors( bool value ) = 0;
 
                virtual bool GetTransferColors(  ) = 0;
 
                virtual void SetUseClippingGeometry( bool value ) = 0;
 
                virtual bool GetUseClippingGeometry(  ) = 0;
 
                virtual void SetUseEmptySpaceOverride( bool value ) = 0;
 
                virtual bool GetUseEmptySpaceOverride(  ) = 0;
 
                virtual void SetEmptySpaceOverride( const real *value_realInputDataPtr ) = 0;
 
                virtual void GetEmptySpaceOverride( real *realReturnDataPtr ) = 0;
 
                virtual void SetProcessSelectionSetID( rid value ) = 0;
 
                virtual rid GetProcessSelectionSetID(  ) = 0;
 
                virtual void SetProcessSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetProcessSelectionSetName(  ) = 0;
 
                virtual void SetCuttingPlaneSelectionSetID( rid value ) = 0;
 
                virtual rid GetCuttingPlaneSelectionSetID(  ) = 0;
 
                virtual void SetCuttingPlaneSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetCuttingPlaneSelectionSetName(  ) = 0;
 
                virtual void SetClippingGeometrySelectionSetID( rid value ) = 0;
 
                virtual rid GetClippingGeometrySelectionSetID(  ) = 0;
 
                virtual void SetClippingGeometrySelectionSetName( const char * value ) = 0;
 
                virtual rstring GetClippingGeometrySelectionSetName(  ) = 0;
 
                virtual void SetUseClippingGeometryEmptySpaceOverride( bool value ) = 0;
 
                virtual bool GetUseClippingGeometryEmptySpaceOverride(  ) = 0;
 
                virtual void SetUsePreviewMode( bool value ) = 0;
 
                virtual bool GetUsePreviewMode(  ) = 0;
 
                virtual void SetRespectWindingDirection( bool value ) = 0;
 
                virtual bool GetRespectWindingDirection(  ) = 0;
 
                virtual void SetClippingGeometryEmptySpaceOverride( const real *value_realInputDataPtr ) = 0;
 
                virtual void GetClippingGeometryEmptySpaceOverride( real *realReturnDataPtr ) = 0;
 
                virtual void SetOutputSceneNodeName( const char * value ) = 0;
 
                virtual rstring GetOutputSceneNodeName(  ) = 0;
 
        };
 
        typedef CountedPointer<IRemeshingSettings> spRemeshingSettings;
 
        #define InterfaceDefined_SimplygonSDK_IRemeshingSettings 1
 
 
        class IRemeshingSettingsV2 : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IRemeshingSettingsV2",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IRemeshingSettingsV2 *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IRemeshingSettingsV2") )
                                return static_cast<IRemeshingSettingsV2*>(ptr);
                        return NULL;
                        }
 
                virtual void SetOnScreenSize( unsigned int value ) = 0;
 
                virtual unsigned int GetOnScreenSize(  ) = 0;
 
                virtual void SetMergeDistance( unsigned int value ) = 0;
 
                virtual unsigned int GetMergeDistance(  ) = 0;
 
                virtual void SetMergeBoldness( real value ) = 0;
 
                virtual real GetMergeBoldness(  ) = 0;
 
                virtual void SetSurfaceTransferMode( rid value ) = 0;
 
                virtual rid GetSurfaceTransferMode(  ) = 0;
 
                virtual void SetMeshGenerationMode( rid value ) = 0;
 
                virtual rid GetMeshGenerationMode(  ) = 0;
 
                virtual void SetHardEdgeAngleInRadians( real value ) = 0;
 
                virtual real GetHardEdgeAngleInRadians(  ) = 0;
 
                virtual void SetTransferNormals( bool value ) = 0;
 
                virtual bool GetTransferNormals(  ) = 0;
 
                virtual void SetTransferColors( bool value ) = 0;
 
                virtual bool GetTransferColors(  ) = 0;
 
        };
 
        typedef CountedPointer<IRemeshingSettingsV2> spRemeshingSettingsV2;
 
        #define InterfaceDefined_SimplygonSDK_IRemeshingSettingsV2 1
 
        class IScene;
        class IMappingImage;
        class IRemeshingSettings;
        class IMappingImageSettings;
        class IBoneSettings;
        class IVisibilitySettings;
 
        class IRemeshingProcessor : public IProcessingObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IRemeshingProcessor",type)==0 )
                                return true;
                        return IProcessingObject::IsClassA(type);
                        }
                static IRemeshingProcessor *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IRemeshingProcessor") )
                                return static_cast<IRemeshingProcessor*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage( rid value ) = 0;
 
                virtual CountedPointer<IRemeshingSettings> GetRemeshingSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImageSettings> GetMappingImageSettings(  ) = 0;
 
                virtual CountedPointer<IBoneSettings> GetBoneSettings(  ) = 0;
 
                virtual CountedPointer<IVisibilitySettings> GetVisibilitySettings(  ) = 0;
 
                virtual rid GetResultSelectionSetId(  ) = 0;
 
                virtual SGDEPRECATED void RemeshGeometry(  ) = 0;
 
        };
 
        typedef CountedPointer<IRemeshingProcessor> spRemeshingProcessor;
 
        #define InterfaceDefined_SimplygonSDK_IRemeshingProcessor 1
 
        class IScene;
        class IMappingImage;
        class IRemeshingSettingsV2;
        class IMappingImageSettings;
        class IBoneSettings;
 
        class IRemeshingProcessorV2 : public IProcessingObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IRemeshingProcessorV2",type)==0 )
                                return true;
                        return IProcessingObject::IsClassA(type);
                        }
                static IRemeshingProcessorV2 *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IRemeshingProcessorV2") )
                                return static_cast<IRemeshingProcessorV2*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage( rid OutputMaterialId ) = 0;
 
                virtual CountedPointer<IRemeshingSettingsV2> GetRemeshingSettingsV2(  ) = 0;
 
                virtual CountedPointer<IMappingImageSettings> GetMappingImageSettings(  ) = 0;
 
                virtual CountedPointer<IBoneSettings> GetBoneSettings(  ) = 0;
 
        };
 
        typedef CountedPointer<IRemeshingProcessorV2> spRemeshingProcessorV2;
 
        #define InterfaceDefined_SimplygonSDK_IRemeshingProcessorV2 1
 
        class ISceneNode;
        class IMaterialTable;
        class ISceneBoneTable;
        class ISelectionSetTable;
        class ITextureTable;
        class IMappingImage;
        class IMatrix4x4;
        class IValueArray;
        class IGeometryData;
 
        class IScene : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IScene",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IScene *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IScene") )
                                return static_cast<IScene*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<ISceneNode> GetRootNode(  ) = 0;
 
                virtual CountedPointer<IMaterialTable> GetMaterialTable(  ) = 0;
 
                virtual CountedPointer<ISceneBoneTable> GetBoneTable(  ) = 0;
 
                virtual CountedPointer<ISelectionSetTable> GetSelectionSetTable(  ) = 0;
 
                virtual CountedPointer<ITextureTable> GetTextureTable(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
                virtual void RemoveSceneNodes( int selectionSetID ) = 0;
 
                virtual void RemoveSceneNodes(  ) = 0;
 
                virtual void RemoveSceneNodes( const char * nodeType ) = 0;
 
                virtual void Clear(  ) = 0;
 
                virtual bool LoadFromFile( const char * path ) = 0;
 
                virtual bool SaveToFile( const char * path ) = 0;
 
                virtual void EvaluateDefaultGlobalTransformation( ISceneNode *node , IMatrix4x4 *global_transform ) = 0;
 
                virtual void ShowSceneDebugWindow(  ) = 0;
 
                virtual void GetInf( real *realReturnDataPtr ) = 0;
 
                virtual void GetSup( real *realReturnDataPtr ) = 0;
 
                virtual real GetRadius(  ) = 0;
 
                virtual bool CalculateExtents(  ) = 0;
 
                virtual CountedPointer<ISceneNode> GetNodeFromPath( const char * path ) = 0;
 
                virtual CountedPointer<ISceneNode> GetNodeByGUID( const char * node_id ) = 0;
 
                virtual CountedPointer<ISceneNode> GetNodeByGUID( const char * node_id , ISceneNode *node ) = 0;
 
                virtual CountedPointer<IValueArray> AddCustomField( rid base_type , const char * name , unsigned int tuple_size ) = 0;
 
                virtual void RemoveCustomField( const char * name ) = 0;
 
                virtual CountedPointer<IValueArray> GetCustomField( const char * name ) = 0;
 
                virtual bool HasCustomField( const char * name ) = 0;
 
                virtual void RemoveUnlinkedBones(  ) = 0;
 
                virtual void Compact(  ) = 0;
 
                virtual void Append( IScene *otherScene ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IGeometryData> GetCombinedGeometry(  ) = 0;
 
                virtual CountedPointer<IGeometryData> GetCombinedGeometry( int selectionSetID ) = 0;
 
                virtual CountedPointer<IGeometryData> NewCombinedGeometry( int selectionSetID ) = 0;
 
                virtual CountedPointer<IGeometryData> NewCombinedGeometry(  ) = 0;
 
                virtual int SelectNodes( const char * nodeTypeName ) = 0;
 
                virtual void DeepCopy( IScene *src ) = 0;
 
                virtual CountedPointer<IScene> NewCopy(  ) = 0;
 
                virtual unsigned int GetTriangleCount(  ) = 0;
 
        };
 
        typedef CountedPointer<IScene> spScene;
 
        #define InterfaceDefined_SimplygonSDK_IScene 1
 
        class IScene;
        class IMatrix4x4;
        class ISceneMesh;
        class IGeometryData;
        class IScenePlane;
 
        class ISceneNode : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ISceneNode",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static ISceneNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ISceneNode") )
                                return static_cast<ISceneNode*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual CountedPointer<ISceneNode> GetParent(  ) = 0;
 
                virtual CountedPointer<IMatrix4x4> GetRelativeTransform(  ) = 0;
 
                virtual void SetOriginalName( const char * value ) = 0;
 
                virtual rstring GetOriginalName(  ) = 0;
 
                virtual void SetIsVisible( bool value ) = 0;
 
                virtual bool GetIsVisible(  ) = 0;
 
                virtual void SetIsFrozen( bool value ) = 0;
 
                virtual bool GetIsFrozen(  ) = 0;
 
                virtual void SetIsModified( bool value ) = 0;
 
                virtual bool GetIsModified(  ) = 0;
 
                virtual rstring GetNodeGUID(  ) = 0;
 
                virtual void SetNodeGUID( const char * value ) = 0;
 
                virtual void GetInf( real *realReturnDataPtr ) = 0;
 
                virtual void GetSup( real *realReturnDataPtr ) = 0;
 
                virtual unsigned int GetChildCount(  ) = 0;
 
                virtual CountedPointer<ISceneNode> GetChild( rid index ) = 0;
 
                virtual CountedPointer<ISceneNode> FindNamedChild( const char * name ) = 0;
 
                virtual void AddChild( ISceneNode *child ) = 0;
 
                virtual CountedPointer<ISceneMesh> CreateChildMesh( IGeometryData *geom ) = 0;
 
                virtual CountedPointer<IScenePlane> CreateChildPlane( const real *position_realInputDataPtr , const real *normal_realInputDataPtr ) = 0;
 
                virtual void RemoveChild( ISceneNode *child ) = 0;
 
                virtual void RemoveChildren(  ) = 0;
 
                virtual void RemoveFromParent(  ) = 0;
 
                virtual bool HasChild( ISceneNode *child ) = 0;
 
                virtual CountedPointer<ISceneNode> NewCopy(  ) = 0;
 
                virtual CountedPointer<ISceneNode> NewClone(  ) = 0;
 
                virtual void EvaluateDefaultGlobalTransformation( IMatrix4x4 *global_transform ) = 0;
 
                virtual bool CalculateExtents(  ) = 0;
 
                virtual rstring GetPath(  ) = 0;
 
        };
 
        typedef CountedPointer<ISceneNode> spSceneNode;
 
        #define InterfaceDefined_SimplygonSDK_ISceneNode 1
 
        class ISceneNode;
 
        class ISceneNodeCollection : public IObjectCollection
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ISceneNodeCollection",type)==0 )
                                return true;
                        return IObjectCollection::IsClassA(type);
                        }
                static ISceneNodeCollection *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ISceneNodeCollection") )
                                return static_cast<ISceneNodeCollection*>(ptr);
                        return NULL;
                        }
 
                virtual rhandle AddSceneNode( ISceneNode *obj ) = 0;
 
                virtual CountedPointer<ISceneNode> GetSceneNode( rhandle objhandle ) = 0;
 
                virtual void RemoveSceneNode( ISceneNode *pobj ) = 0;
 
                virtual CountedPointer<ISceneNode> FindSceneNode( const char * name ) = 0;
 
                virtual CountedPointer<ISceneNode> GetNextItemAsSceneNode( rhandle *phandle_rhandleInputDataPtr ) = 0;
 
                virtual bool IsSceneNodeInCollection( ISceneNode *pobj ) = 0;
 
        };
 
        typedef CountedPointer<ISceneNodeCollection> spSceneNodeCollection;
 
        #define InterfaceDefined_SimplygonSDK_ISceneNodeCollection 1
 
        class IGeometryData;
 
        class ISceneMesh : public ISceneNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ISceneMesh",type)==0 )
                                return true;
                        return ISceneNode::IsClassA(type);
                        }
                static ISceneMesh *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ISceneMesh") )
                                return static_cast<ISceneMesh*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IGeometryData> GetGeometry(  ) = 0;
 
                virtual void SetGeometry( IGeometryData *value ) = 0;
 
        };
 
        typedef CountedPointer<ISceneMesh> spSceneMesh;
 
        #define InterfaceDefined_SimplygonSDK_ISceneMesh 1
 
        class IRealArray;
        class ISceneNode;
 
        class ISceneLodGroup : public ISceneNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ISceneLodGroup",type)==0 )
                                return true;
                        return ISceneNode::IsClassA(type);
                        }
                static ISceneLodGroup *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ISceneLodGroup") )
                                return static_cast<ISceneLodGroup*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IRealArray> GetThresholds(  ) = 0;
 
                virtual CountedPointer<ISceneNode> GetLodForDistance( real distance ) = 0;
 
        };
 
        typedef CountedPointer<ISceneLodGroup> spSceneLodGroup;
 
        #define InterfaceDefined_SimplygonSDK_ISceneLodGroup 1
 
        class IRidArray;
 
        class ISceneBone : public ISceneNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ISceneBone",type)==0 )
                                return true;
                        return ISceneNode::IsClassA(type);
                        }
                static ISceneBone *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ISceneBone") )
                                return static_cast<ISceneBone*>(ptr);
                        return NULL;
                        }
 
                virtual rid GetParentBone(  ) = 0;
 
                virtual void CollectAllChildBones( IRidArray *child_bones ) = 0;
 
                virtual rid GetBoneId(  ) = 0;
 
        };
 
        typedef CountedPointer<ISceneBone> spSceneBone;
 
        #define InterfaceDefined_SimplygonSDK_ISceneBone 1
 
        class ISceneBone;
 
        class ISceneBoneTable : public ITable
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ISceneBoneTable",type)==0 )
                                return true;
                        return ITable::IsClassA(type);
                        }
                static ISceneBoneTable *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ISceneBoneTable") )
                                return static_cast<ISceneBoneTable*>(ptr);
                        return NULL;
                        }
 
                virtual rid AddBone( ISceneBone *bone ) = 0;
 
                virtual CountedPointer<ISceneBone> FindBone( const char * name ) = 0;
 
                virtual rid FindBoneId( const char * name ) = 0;
 
                virtual CountedPointer<ISceneBone> GetBone( rid id ) = 0;
 
                virtual void RemoveBone( rid id ) = 0;
 
                virtual unsigned int GetBonesCount(  ) = 0;
 
        };
 
        typedef CountedPointer<ISceneBoneTable> spSceneBoneTable;
 
        #define InterfaceDefined_SimplygonSDK_ISceneBoneTable 1
 
 
        class IScenePlane : public ISceneNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IScenePlane",type)==0 )
                                return true;
                        return ISceneNode::IsClassA(type);
                        }
                static IScenePlane *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IScenePlane") )
                                return static_cast<IScenePlane*>(ptr);
                        return NULL;
                        }
 
                virtual void GetPosition( real *realReturnDataPtr ) = 0;
 
                virtual void SetPosition( const real *vec_realInputDataPtr ) = 0;
 
                virtual void GetNormal( real *realReturnDataPtr ) = 0;
 
                virtual void SetNormal( const real *vec_realInputDataPtr ) = 0;
 
        };
 
        typedef CountedPointer<IScenePlane> spScenePlane;
 
        #define InterfaceDefined_SimplygonSDK_IScenePlane 1
 
        class IRealArray;
 
        class ISceneCamera : public ISceneNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ISceneCamera",type)==0 )
                                return true;
                        return ISceneNode::IsClassA(type);
                        }
                static ISceneCamera *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ISceneCamera") )
                                return static_cast<ISceneCamera*>(ptr);
                        return NULL;
                        }
 
                virtual void SetCameraType( unsigned int value ) = 0;
 
                virtual unsigned int GetCameraType(  ) = 0;
 
                virtual CountedPointer<IRealArray> GetCameraPositions(  ) = 0;
 
                virtual CountedPointer<IRealArray> GetTargetPositions(  ) = 0;
 
                virtual bool GetUseNormalizedCoordinates(  ) = 0;
 
                virtual void SetUseNormalizedCoordinates( bool value ) = 0;
 
                virtual real GetOrthographicCameraPixelSize(  ) = 0;
 
                virtual void SetOrthographicCameraPixelSize( real value ) = 0;
 
                virtual real GetFieldOfView(  ) = 0;
 
                virtual void SetFieldOfView( real value ) = 0;
 
                virtual real GetPixelFieldOfView(  ) = 0;
 
                virtual void SetPixelFieldOfView( real value ) = 0;
 
                virtual unsigned int GetNumberOfViews(  ) = 0;
 
                virtual bool ValidateCamera(  ) = 0;
 
                virtual void SetCustomSphereCameraPath( int fidelity , real pitch_angle , real yaw_angle , real coverage_angle ) = 0;
 
        };
 
        typedef CountedPointer<ISceneCamera> spSceneCamera;
 
        #define InterfaceDefined_SimplygonSDK_ISceneCamera 1
 
 
        class ISelectionSet : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ISelectionSet",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static ISelectionSet *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ISelectionSet") )
                                return static_cast<ISelectionSet*>(ptr);
                        return NULL;
                        }
 
                virtual void AddItem( const char * NodeId ) = 0;
 
                virtual void RemoveItem( const char * NodeId ) = 0;
 
                virtual void Clear(  ) = 0;
 
                virtual unsigned int GetItemCount(  ) = 0;
 
                virtual rstring GetItem( unsigned int index ) = 0;
 
        };
 
        typedef CountedPointer<ISelectionSet> spSelectionSet;
 
        #define InterfaceDefined_SimplygonSDK_ISelectionSet 1
 
        class ISelectionSet;
 
        class ISelectionSetTable : public ITable
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ISelectionSetTable",type)==0 )
                                return true;
                        return ITable::IsClassA(type);
                        }
                static ISelectionSetTable *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ISelectionSetTable") )
                                return static_cast<ISelectionSetTable*>(ptr);
                        return NULL;
                        }
 
                virtual rid AddSelectionSet( ISelectionSet *selectionSet ) = 0;
 
                virtual CountedPointer<ISelectionSet> FindSelectionSet( const char * name ) = 0;
 
                virtual rid FindSelectionSetId( const char * name ) = 0;
 
                virtual CountedPointer<ISelectionSet> GetSelectionSet( rid id ) = 0;
 
                virtual void RemoveSelectionSet( rid id ) = 0;
 
                virtual unsigned int GetSelectionSetCount(  ) = 0;
 
        };
 
        typedef CountedPointer<ISelectionSetTable> spSelectionSetTable;
 
        #define InterfaceDefined_SimplygonSDK_ISelectionSetTable 1
 
        class IImageData;
 
        class ITexture : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ITexture",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static ITexture *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ITexture") )
                                return static_cast<ITexture*>(ptr);
                        return NULL;
                        }
 
                virtual void SetFilePath( const char * value ) = 0;
 
                virtual rstring GetFilePath(  ) = 0;
 
                virtual void SetImageData( IImageData *value ) = 0;
 
                virtual CountedPointer<IImageData> GetImageData(  ) = 0;
 
                virtual void ChangeTexturePrefixPath( const char * current_path_prefix , const char * new_path_prefix ) = 0;
 
        };
 
        typedef CountedPointer<ITexture> spTexture;
 
        #define InterfaceDefined_SimplygonSDK_ITexture 1
 
        class ITexture;
 
        class ITextureTable : public ITable
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ITextureTable",type)==0 )
                                return true;
                        return ITable::IsClassA(type);
                        }
                static ITextureTable *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ITextureTable") )
                                return static_cast<ITextureTable*>(ptr);
                        return NULL;
                        }
 
                virtual rid AddTexture( ITexture *texture ) = 0;
 
                virtual CountedPointer<ITexture> FindTexture( const char * name ) = 0;
 
                virtual CountedPointer<ITexture> FindTextureUsingPath( const char * path ) = 0;
 
                virtual rid FindTextureId( const char * name ) = 0;
 
                virtual void SetTexture( rid id , ITexture *texture ) = 0;
 
                virtual CountedPointer<ITexture> GetTexture( rid id ) = 0;
 
                virtual void RemoveTexture( rid id ) = 0;
 
                virtual unsigned int GetTexturesCount(  ) = 0;
 
                virtual void ChangeTexturePrefixPath( const char * current_path_prefix , const char * new_path_prefix ) = 0;
 
        };
 
        typedef CountedPointer<ITextureTable> spTextureTable;
 
        #define InterfaceDefined_SimplygonSDK_ITextureTable 1
 
        class IImageData;
 
        class IImageDataImporter : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IImageDataImporter",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IImageDataImporter *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IImageDataImporter") )
                                return static_cast<IImageDataImporter*>(ptr);
                        return NULL;
                        }
 
                virtual void SetImportFilePath( const char * value ) = 0;
 
                virtual rstring GetImportFilePath(  ) = 0;
 
                virtual void SetExtensionOverride( const char * value ) = 0;
 
                virtual rstring GetExtensionOverride(  ) = 0;
 
                virtual CountedPointer<IImageData> GetImage(  ) = 0;
 
                virtual void SetCapToPowerOfTwo( bool value ) = 0;
 
                virtual bool GetCapToPowerOfTwo(  ) = 0;
 
                virtual unsigned int GetMaxWidth(  ) = 0;
 
                virtual void SetMaxWidth( unsigned int value ) = 0;
 
                virtual unsigned int GetMaxHeight(  ) = 0;
 
                virtual void SetMaxHeight( unsigned int value ) = 0;
 
                virtual bool GetImportOnlyHeader(  ) = 0;
 
                virtual void SetImportOnlyHeader( bool value ) = 0;
 
                virtual unsigned int GetNumberOfChannels(  ) = 0;
 
                virtual unsigned int GetBitsPerPixel(  ) = 0;
 
                virtual rid GetImageType(  ) = 0;
 
                virtual bool RunImport(  ) = 0;
 
                virtual void Clear(  ) = 0;
 
        };
 
        typedef CountedPointer<IImageDataImporter> spImageDataImporter;
 
        #define InterfaceDefined_SimplygonSDK_IImageDataImporter 1
 
 
        class IMappingImageMeshData : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IMappingImageMeshData",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IMappingImageMeshData *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IMappingImageMeshData") )
                                return static_cast<IMappingImageMeshData*>(ptr);
                        return NULL;
                        }
 
                virtual unsigned int GetMappedGeometriesCount(  ) = 0;
 
                virtual rid GetStartTriangleIdOfGeometry( rid GeometryIndex ) = 0;
 
                virtual rstring GetScenePathOfGeometry( rid GeometryIndex ) = 0;
 
                virtual rstring GetNodeGuidOfGeometry( rid GeometryIndex ) = 0;
 
                virtual void Clear(  ) = 0;
 
        };
 
        typedef CountedPointer<IMappingImageMeshData> spMappingImageMeshData;
 
        #define InterfaceDefined_SimplygonSDK_IMappingImageMeshData 1
 
 
        class IShadingNode : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingNode",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IShadingNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingNode") )
                                return static_cast<IShadingNode*>(ptr);
                        return NULL;
                        }
 
                virtual unsigned int GetParameterCount(  ) = 0;
 
                virtual rstring GetParameterName( rid parameter_id ) = 0;
 
                virtual void SetDefaultParameter( rid parameter_id , real r , real g , real b , real a ) = 0;
 
                virtual real GetDefaultParameterRed( rid parameter_id ) = 0;
 
                virtual real GetDefaultParameterGreen( rid parameter_id ) = 0;
 
                virtual real GetDefaultParameterBlue( rid parameter_id ) = 0;
 
                virtual real GetDefaultParameterAlpha( rid parameter_id ) = 0;
 
        };
 
        typedef CountedPointer<IShadingNode> spShadingNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingNode 1
 
        class IShadingNode;
 
        class IShadingFilterNode : public IShadingNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingFilterNode",type)==0 )
                                return true;
                        return IShadingNode::IsClassA(type);
                        }
                static IShadingFilterNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingFilterNode") )
                                return static_cast<IShadingFilterNode*>(ptr);
                        return NULL;
                        }
 
                virtual bool SetInput( rid input_id , IShadingNode *input_node ) = 0;
 
                virtual CountedPointer<IShadingNode> GetInput( rid input_id ) = 0;
 
                virtual bool GetParameterIsInputable( rid param_id ) = 0;
 
        };
 
        typedef CountedPointer<IShadingFilterNode> spShadingFilterNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingFilterNode 1
 
 
        class IShadingTextureNode : public IShadingNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingTextureNode",type)==0 )
                                return true;
                        return IShadingNode::IsClassA(type);
                        }
                static IShadingTextureNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingTextureNode") )
                                return static_cast<IShadingTextureNode*>(ptr);
                        return NULL;
                        }
 
                virtual void SetTextureName( const char * value ) = 0;
 
                virtual rstring GetTextureName(  ) = 0;
 
                virtual void SetTextureLevelName( const char * value ) = 0;
 
                virtual rstring GetTextureLevelName(  ) = 0;
 
                virtual void SetTextureLevel( int value ) = 0;
 
                virtual int GetTextureLevel(  ) = 0;
 
                virtual void SetUseSRGB( bool value ) = 0;
 
                virtual bool GetUseSRGB(  ) = 0;
 
                virtual void SetTileU( real value ) = 0;
 
                virtual real GetTileU(  ) = 0;
 
                virtual void SetTileV( real value ) = 0;
 
                virtual real GetTileV(  ) = 0;
 
                virtual void SetOffsetU( real value ) = 0;
 
                virtual real GetOffsetU(  ) = 0;
 
                virtual void SetOffsetV( real value ) = 0;
 
                virtual real GetOffsetV(  ) = 0;
 
                virtual void SetTextureWrapMode( int value ) = 0;
 
                virtual int GetTextureWrapMode(  ) = 0;
 
        };
 
        typedef CountedPointer<IShadingTextureNode> spShadingTextureNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingTextureNode 1
 
 
        class IShadingSwizzlingNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingSwizzlingNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingSwizzlingNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingSwizzlingNode") )
                                return static_cast<IShadingSwizzlingNode*>(ptr);
                        return NULL;
                        }
 
                virtual void SetRedComponent( unsigned int value ) = 0;
 
                virtual unsigned int GetRedComponent(  ) = 0;
 
                virtual void SetGreenComponent( unsigned int value ) = 0;
 
                virtual unsigned int GetGreenComponent(  ) = 0;
 
                virtual void SetBlueComponent( unsigned int value ) = 0;
 
                virtual unsigned int GetBlueComponent(  ) = 0;
 
                virtual void SetAlphaComponent( unsigned int value ) = 0;
 
                virtual unsigned int GetAlphaComponent(  ) = 0;
 
        };
 
        typedef CountedPointer<IShadingSwizzlingNode> spShadingSwizzlingNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingSwizzlingNode 1
 
 
        class IShadingColorNode : public IShadingNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingColorNode",type)==0 )
                                return true;
                        return IShadingNode::IsClassA(type);
                        }
                static IShadingColorNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingColorNode") )
                                return static_cast<IShadingColorNode*>(ptr);
                        return NULL;
                        }
 
                virtual void SetColor( real r , real g , real b , real a ) = 0;
 
        };
 
        typedef CountedPointer<IShadingColorNode> spShadingColorNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingColorNode 1
 
 
        class IShadingAddNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingAddNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingAddNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingAddNode") )
                                return static_cast<IShadingAddNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingAddNode> spShadingAddNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingAddNode 1
 
 
        class IShadingSubtractNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingSubtractNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingSubtractNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingSubtractNode") )
                                return static_cast<IShadingSubtractNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingSubtractNode> spShadingSubtractNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingSubtractNode 1
 
 
        class IShadingMultiplyNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingMultiplyNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingMultiplyNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingMultiplyNode") )
                                return static_cast<IShadingMultiplyNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingMultiplyNode> spShadingMultiplyNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingMultiplyNode 1
 
 
        class IShadingPowNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingPowNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingPowNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingPowNode") )
                                return static_cast<IShadingPowNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingPowNode> spShadingPowNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingPowNode 1
 
 
        class IShadingDivideNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingDivideNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingDivideNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingDivideNode") )
                                return static_cast<IShadingDivideNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingDivideNode> spShadingDivideNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingDivideNode 1
 
 
        class IShadingClampNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingClampNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingClampNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingClampNode") )
                                return static_cast<IShadingClampNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingClampNode> spShadingClampNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingClampNode 1
 
 
        class IShadingMaxNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingMaxNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingMaxNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingMaxNode") )
                                return static_cast<IShadingMaxNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingMaxNode> spShadingMaxNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingMaxNode 1
 
 
        class IShadingMinNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingMinNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingMinNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingMinNode") )
                                return static_cast<IShadingMinNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingMinNode> spShadingMinNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingMinNode 1
 
 
        class IShadingStepNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingStepNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingStepNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingStepNode") )
                                return static_cast<IShadingStepNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingStepNode> spShadingStepNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingStepNode 1
 
 
        class IShadingEqualNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingEqualNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingEqualNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingEqualNode") )
                                return static_cast<IShadingEqualNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingEqualNode> spShadingEqualNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingEqualNode 1
 
 
        class IShadingNotEqualNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingNotEqualNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingNotEqualNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingNotEqualNode") )
                                return static_cast<IShadingNotEqualNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingNotEqualNode> spShadingNotEqualNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingNotEqualNode 1
 
 
        class IShadingVertexColorNode : public IShadingNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingVertexColorNode",type)==0 )
                                return true;
                        return IShadingNode::IsClassA(type);
                        }
                static IShadingVertexColorNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingVertexColorNode") )
                                return static_cast<IShadingVertexColorNode*>(ptr);
                        return NULL;
                        }
 
                virtual void SetVertexColorIndex( rid value ) = 0;
 
                virtual rid GetVertexColorIndex(  ) = 0;
 
                virtual void SetVertexColorSet( const char * value ) = 0;
 
                virtual rstring GetVertexColorSet(  ) = 0;
 
        };
 
        typedef CountedPointer<IShadingVertexColorNode> spShadingVertexColorNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingVertexColorNode 1
 
 
        class IShadingInterpolateNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingInterpolateNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingInterpolateNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingInterpolateNode") )
                                return static_cast<IShadingInterpolateNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingInterpolateNode> spShadingInterpolateNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingInterpolateNode 1
 
 
        class IShadingCustomNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingCustomNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingCustomNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingCustomNode") )
                                return static_cast<IShadingCustomNode*>(ptr);
                        return NULL;
                        }
 
                virtual unsigned int GetInputCount(  ) = 0;
 
                virtual void SetInputCount( unsigned int value ) = 0;
 
        };
 
        typedef CountedPointer<IShadingCustomNode> spShadingCustomNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingCustomNode 1
 
 
        class IShadingLayeredBlendNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingLayeredBlendNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingLayeredBlendNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingLayeredBlendNode") )
                                return static_cast<IShadingLayeredBlendNode*>(ptr);
                        return NULL;
                        }
 
                virtual unsigned int GetInputCount(  ) = 0;
 
                virtual void SetInputCount( unsigned int value ) = 0;
 
                virtual void SetPerInputBlendType( int _input , int _blendType ) = 0;
 
                virtual int GetPerInputBlendType( int _input ) = 0;
 
        };
 
        typedef CountedPointer<IShadingLayeredBlendNode> spShadingLayeredBlendNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingLayeredBlendNode 1
 
 
        class IShadingNormalize3Node : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingNormalize3Node",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingNormalize3Node *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingNormalize3Node") )
                                return static_cast<IShadingNormalize3Node*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingNormalize3Node> spShadingNormalize3Node;
 
        #define InterfaceDefined_SimplygonSDK_IShadingNormalize3Node 1
 
 
        class IShadingSqrtNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingSqrtNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingSqrtNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingSqrtNode") )
                                return static_cast<IShadingSqrtNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingSqrtNode> spShadingSqrtNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingSqrtNode 1
 
 
        class IShadingDot3Node : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingDot3Node",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingDot3Node *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingDot3Node") )
                                return static_cast<IShadingDot3Node*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingDot3Node> spShadingDot3Node;
 
        #define InterfaceDefined_SimplygonSDK_IShadingDot3Node 1
 
 
        class IShadingCross3Node : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingCross3Node",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingCross3Node *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingCross3Node") )
                                return static_cast<IShadingCross3Node*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingCross3Node> spShadingCross3Node;
 
        #define InterfaceDefined_SimplygonSDK_IShadingCross3Node 1
 
 
        class IShadingCosNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingCosNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingCosNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingCosNode") )
                                return static_cast<IShadingCosNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingCosNode> spShadingCosNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingCosNode 1
 
 
        class IShadingSinNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingSinNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingSinNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingSinNode") )
                                return static_cast<IShadingSinNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingSinNode> spShadingSinNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingSinNode 1
 
 
        class IShadingGreaterThanNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingGreaterThanNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingGreaterThanNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingGreaterThanNode") )
                                return static_cast<IShadingGreaterThanNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingGreaterThanNode> spShadingGreaterThanNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingGreaterThanNode 1
 
 
        class IShadingLessThanNode : public IShadingFilterNode
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadingLessThanNode",type)==0 )
                                return true;
                        return IShadingFilterNode::IsClassA(type);
                        }
                static IShadingLessThanNode *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadingLessThanNode") )
                                return static_cast<IShadingLessThanNode*>(ptr);
                        return NULL;
                        }
 
        };
 
        typedef CountedPointer<IShadingLessThanNode> spShadingLessThanNode;
 
        #define InterfaceDefined_SimplygonSDK_IShadingLessThanNode 1
 
        class IMaterial;
        class IStringArray;
 
        class IShaderGenerator : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShaderGenerator",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IShaderGenerator *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShaderGenerator") )
                                return static_cast<IShaderGenerator*>(ptr);
                        return NULL;
                        }
 
                virtual void SetMaterial( IMaterial *value ) = 0;
 
                virtual CountedPointer<IMaterial> GetMaterial(  ) = 0;
 
                virtual rstring GetIdentifersPrefix(  ) = 0;
 
                virtual void SetIdentifersPrefix( const char * value ) = 0;
 
                virtual void SetGenerateFullShader( bool value ) = 0;
 
                virtual bool GetGenerateFullShader(  ) = 0;
 
                virtual void SetGenerateTextureSamplerData( bool value ) = 0;
 
                virtual bool GetGenerateTextureSamplerData(  ) = 0;
 
                virtual bool GenerateShaderData(  ) = 0;
 
                virtual rstring GetHLSLCode(  ) = 0;
 
                virtual rstring GetGLSLVertexCode(  ) = 0;
 
                virtual rstring GetGLSLFragmentCode(  ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IStringArray> GetShaderInputTexturePaths(  ) = 0;
 
                virtual unsigned int GetShaderInputTexturePathsCount(  ) = 0;
 
                virtual rstring GetShaderInputTexturePath( rid index ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IStringArray> GetShaderInputUVSets(  ) = 0;
 
                virtual unsigned int GetShaderInputUVSetsCount(  ) = 0;
 
                virtual rstring GetShaderInputUVSet( rid index ) = 0;
 
                virtual rid GetShaderInputUVIndex( const char * uvset ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IStringArray> GetShaderInputVertexColors(  ) = 0;
 
                virtual unsigned int GetShaderInputVertexColorsCount(  ) = 0;
 
                virtual rstring GetShaderInputVertexColor( rid index ) = 0;
 
                virtual rid GetShaderInputVertexColorsIndex( const char * colorset ) = 0;
 
                virtual void UnloadData(  ) = 0;
 
        };
 
        typedef CountedPointer<IShaderGenerator> spShaderGenerator;
 
        #define InterfaceDefined_SimplygonSDK_IShaderGenerator 1
 
        class IScene;
        class IMappingImage;
        class IAggregationSettings;
        class IMappingImageSettings;
        class IVisibilitySettings;
 
        class IAggregationProcessor : public IProcessingObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IAggregationProcessor",type)==0 )
                                return true;
                        return IProcessingObject::IsClassA(type);
                        }
                static IAggregationProcessor *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IAggregationProcessor") )
                                return static_cast<IAggregationProcessor*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
                virtual CountedPointer<IAggregationSettings> GetAggregationSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImageSettings> GetMappingImageSettings(  ) = 0;
 
                virtual CountedPointer<IVisibilitySettings> GetVisibilitySettings(  ) = 0;
 
        };
 
        typedef CountedPointer<IAggregationProcessor> spAggregationProcessor;
 
        #define InterfaceDefined_SimplygonSDK_IAggregationProcessor 1
 
 
        class IAggregationSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IAggregationSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IAggregationSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IAggregationSettings") )
                                return static_cast<IAggregationSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetBaseAtlasOnOriginalTexCoords( bool value ) = 0;
 
                virtual bool GetBaseAtlasOnOriginalTexCoords(  ) = 0;
 
                virtual void SetProcessSelectionSetID( rid value ) = 0;
 
                virtual rid GetProcessSelectionSetID(  ) = 0;
 
                virtual void SetProcessSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetProcessSelectionSetName(  ) = 0;
 
                virtual void SetMergeGeometries( bool value ) = 0;
 
                virtual bool GetMergeGeometries(  ) = 0;
 
                virtual void SetMergeMaterials( bool value ) = 0;
 
                virtual bool GetMergeMaterials(  ) = 0;
 
                virtual void SetSubdivideGeometryBasedOnUVTiles( bool value ) = 0;
 
                virtual bool GetSubdivideGeometryBasedOnUVTiles(  ) = 0;
 
                virtual void SetSubdivisionTileSize( unsigned int value ) = 0;
 
                virtual unsigned int GetSubdivisionTileSize(  ) = 0;
 
        };
 
        typedef CountedPointer<IAggregationSettings> spAggregationSettings;
 
        #define InterfaceDefined_SimplygonSDK_IAggregationSettings 1
 
        class IGeometryData;
        class IRealArray;
        class IMaterialTable;
        class ITextureTable;
 
        class IChartAggregator : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IChartAggregator",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IChartAggregator *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IChartAggregator") )
                                return static_cast<IChartAggregator*>(ptr);
                        return NULL;
                        }
 
                virtual bool Parameterize( IGeometryData *geom , IRealArray *arr ) = 0;
 
                virtual void SetInputMaterialCount( unsigned int value ) = 0;
 
                virtual unsigned int GetInputMaterialCount(  ) = 0;
 
                virtual void SetOutputMaterialCount( unsigned int value ) = 0;
 
                virtual unsigned int GetOutputMaterialCount(  ) = 0;
 
                virtual void SetInputOutputMaterialMapping( unsigned int InMaterialId , int OutMaterialId ) = 0;
 
                virtual int GetInputOutputMaterialMapping( unsigned int InMaterialId ) = 0;
 
                virtual void SetTextureWidth( unsigned int value ) = 0;
 
                virtual void SetTextureWidth( unsigned int id , unsigned int value ) = 0;
 
                virtual unsigned int GetTextureWidth(  ) = 0;
 
                virtual unsigned int GetTextureWidth( unsigned int id ) = 0;
 
                virtual void SetTextureHeight( unsigned int value ) = 0;
 
                virtual void SetTextureHeight( unsigned int id , unsigned int value ) = 0;
 
                virtual unsigned int GetTextureHeight(  ) = 0;
 
                virtual unsigned int GetTextureHeight( unsigned int id ) = 0;
 
                virtual void SetGutterSpace( unsigned int value ) = 0;
 
                virtual void SetGutterSpace( unsigned int id , unsigned int value ) = 0;
 
                virtual unsigned int GetGutterSpace(  ) = 0;
 
                virtual unsigned int GetGutterSpace( unsigned int id ) = 0;
 
                virtual void SetUseAutomaticTextureSize( bool value ) = 0;
 
                virtual bool GetUseAutomaticTextureSize(  ) = 0;
 
                virtual void SetAutomaticTextureSizeMultiplier( real value ) = 0;
 
                virtual real GetAutomaticTextureSizeMultiplier(  ) = 0;
 
                virtual void SetForcePower2Texture( bool value ) = 0;
 
                virtual bool GetForcePower2Texture(  ) = 0;
 
                virtual void SetTexCoordLevel( unsigned int value ) = 0;
 
                virtual unsigned int GetTexCoordLevel(  ) = 0;
 
                virtual void SetTexCoordLevelName( const char * value ) = 0;
 
                virtual rstring GetTexCoordLevelName(  ) = 0;
 
                virtual void SetChartAggregatorMode( unsigned int value ) = 0;
 
                virtual unsigned int GetChartAggregatorMode(  ) = 0;
 
                virtual void SetSeparateOverlappingCharts( bool value ) = 0;
 
                virtual void SetMaterialTable( IMaterialTable *value ) = 0;
 
                virtual void SetTextureTable( ITextureTable *value ) = 0;
 
                virtual unsigned int GetKeepOriginalChartSizesTextureWidth(  ) = 0;
 
                virtual unsigned int GetKeepOriginalChartSizesTextureWidth( unsigned int OutputID ) = 0;
 
                virtual unsigned int GetKeepOriginalChartSizesTextureHeight(  ) = 0;
 
                virtual unsigned int GetKeepOriginalChartSizesTextureHeight( unsigned int OutputID ) = 0;
 
                virtual void SetOriginalChartProportionsChannel( const char * value ) = 0;
 
                virtual rstring GetOriginalChartProportionsChannel(  ) = 0;
 
                virtual bool GetUseVertexWeights(  ) = 0;
 
                virtual void SetUseVertexWeights( bool value ) = 0;
 
                virtual bool GetLockUVRotation(  ) = 0;
 
                virtual void SetLockUVRotation( bool value ) = 0;
 
                virtual bool GetExpandZeroAreaUVs(  ) = 0;
 
                virtual void SetExpandZeroAreaUVs( bool value ) = 0;
 
        };
 
        typedef CountedPointer<IChartAggregator> spChartAggregator;
 
        #define InterfaceDefined_SimplygonSDK_IChartAggregator 1
 
        class IScene;
        class ITextureTable;
        class IMaterialTable;
        class IMappingImage;
 
        class IVertexColorBaker : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IVertexColorBaker",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IVertexColorBaker *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IVertexColorBaker") )
                                return static_cast<IVertexColorBaker*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual void SetSourceTextures( ITextureTable *value ) = 0;
 
                virtual CountedPointer<ITextureTable> GetSourceTextures(  ) = 0;
 
                virtual void SetSourceMaterials( IMaterialTable *value ) = 0;
 
                virtual CountedPointer<IMaterialTable> GetSourceMaterials(  ) = 0;
 
                virtual void SetMappingImage( IMappingImage *_MappingImage ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
                virtual void SetChannelName( const char * value ) = 0;
 
                virtual rstring GetInputChannelName(  ) = 0;
 
                virtual void SetOutputColorLevelName( const char * value ) = 0;
 
                virtual rstring GetOutputColorLevelName(  ) = 0;
 
                virtual void SetColorSpaceEdgeThreshold( real value ) = 0;
 
                virtual real GetColorSpaceEdgeThreshold(  ) = 0;
 
                virtual void Clear(  ) = 0;
 
                virtual void Bake(  ) = 0;
 
        };
 
        typedef CountedPointer<IVertexColorBaker> spVertexColorBaker;
 
        #define InterfaceDefined_SimplygonSDK_IVertexColorBaker 1
 
        class IImageData;
 
        class IImageDataExporter : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IImageDataExporter",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IImageDataExporter *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IImageDataExporter") )
                                return static_cast<IImageDataExporter*>(ptr);
                        return NULL;
                        }
 
                virtual void SetExportFilePath( const char * value ) = 0;
 
                virtual rstring GetExportFilePath(  ) = 0;
 
                virtual void SetImage( IImageData *value ) = 0;
 
                virtual bool RunExport(  ) = 0;
 
                virtual void Clear(  ) = 0;
 
        };
 
        typedef CountedPointer<IImageDataExporter> spImageDataExporter;
 
        #define InterfaceDefined_SimplygonSDK_IImageDataExporter 1
 
        class IScene;
        class IAmbientOcclusionCasterSettings;
 
        class IAmbientOcclusionCaster : public IMaterialCaster
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IAmbientOcclusionCaster",type)==0 )
                                return true;
                        return IMaterialCaster::IsClassA(type);
                        }
                static IAmbientOcclusionCaster *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IAmbientOcclusionCaster") )
                                return static_cast<IAmbientOcclusionCaster*>(ptr);
                        return NULL;
                        }
 
                virtual void SetColorType( const char * ColorType ) = 0;
 
                virtual rstring GetColorType(  ) = 0;
 
                virtual void SetRaysPerPixel( unsigned int RaysPerPixel ) = 0;
 
                virtual unsigned int GetRaysPerPixel(  ) = 0;
 
                virtual void SetOcclusionFalloff( real OcclusionFalloff ) = 0;
 
                virtual real GetOcclusionFalloff(  ) = 0;
 
                virtual void SetOcclusionMultiplier( real OcclusionMultiplier ) = 0;
 
                virtual real GetOcclusionMultiplier(  ) = 0;
 
                virtual void SetUseSimpleOcclusionMode( bool UseSimpleOcclusionMode ) = 0;
 
                virtual bool GetUseSimpleOcclusionMode(  ) = 0;
 
                virtual void SetAdditionalSourceScene( IScene *value ) = 0;
 
                virtual CountedPointer<IAmbientOcclusionCasterSettings> GetAmbientOcclusionCasterSettings(  ) = 0;
 
        };
 
        typedef CountedPointer<IAmbientOcclusionCaster> spAmbientOcclusionCaster;
 
        #define InterfaceDefined_SimplygonSDK_IAmbientOcclusionCaster 1
 
 
        class IAmbientOcclusionCasterSettings : public IMaterialCasterSettings
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IAmbientOcclusionCasterSettings",type)==0 )
                                return true;
                        return IMaterialCasterSettings::IsClassA(type);
                        }
                static IAmbientOcclusionCasterSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IAmbientOcclusionCasterSettings") )
                                return static_cast<IAmbientOcclusionCasterSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetRaysPerPixel( unsigned int value ) = 0;
 
                virtual unsigned int GetRaysPerPixel(  ) = 0;
 
                virtual void SetOcclusionFalloff( real value ) = 0;
 
                virtual real GetOcclusionFalloff(  ) = 0;
 
                virtual void SetOcclusionMultiplier( real value ) = 0;
 
                virtual real GetOcclusionMultiplier(  ) = 0;
 
                virtual void SetUseSimpleOcclusionMode( bool value ) = 0;
 
                virtual bool GetUseSimpleOcclusionMode(  ) = 0;
 
        };
 
        typedef CountedPointer<IAmbientOcclusionCasterSettings> spAmbientOcclusionCasterSettings;
 
        #define InterfaceDefined_SimplygonSDK_IAmbientOcclusionCasterSettings 1
 
        class IScene;
        class IGeometryData;
        class IImpostorSettings;
        class IMappingImageSettings;
        class IMappingImage;
 
        class IImpostorProcessor : public IProcessingObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IImpostorProcessor",type)==0 )
                                return true;
                        return IProcessingObject::IsClassA(type);
                        }
                static IImpostorProcessor *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IImpostorProcessor") )
                                return static_cast<IImpostorProcessor*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual void SetGeometry( IGeometryData *value ) = 0;
 
                virtual CountedPointer<IImpostorSettings> GetImpostorSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImageSettings> GetMappingImageSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
                virtual CountedPointer<IGeometryData> GetImpostorGeometry(  ) = 0;
 
                virtual real CalculateImpostorAspectRatio(  ) = 0;
 
        };
 
        typedef CountedPointer<IImpostorProcessor> spImpostorProcessor;
 
        #define InterfaceDefined_SimplygonSDK_IImpostorProcessor 1
 
 
        class IImpostorSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IImpostorSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IImpostorSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IImpostorSettings") )
                                return static_cast<IImpostorSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetUseTightFitting( bool value ) = 0;
 
                virtual bool GetUseTightFitting(  ) = 0;
 
                virtual void SetTightFittingDepthOffset( real value ) = 0;
 
                virtual real GetTightFittingDepthOffset(  ) = 0;
 
                virtual void SetTwoSided( bool value ) = 0;
 
                virtual bool GetTwoSided(  ) = 0;
 
                virtual void SetViewDirection( const real *value_realInputDataPtr ) = 0;
 
                virtual void GetViewDirection( real *realReturnDataPtr ) = 0;
 
                virtual void SetTexCoordPadding( real value ) = 0;
 
                virtual real GetTexCoordPadding(  ) = 0;
 
        };
 
        typedef CountedPointer<IImpostorSettings> spImpostorSettings;
 
        #define InterfaceDefined_SimplygonSDK_IImpostorSettings 1
 
        class IScene;
        class IGeometryData;
        class IMappingImageSettings;
        class IMappingImage;
 
        class ISurfaceMapper : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ISurfaceMapper",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static ISurfaceMapper *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ISurfaceMapper") )
                                return static_cast<ISurfaceMapper*>(ptr);
                        return NULL;
                        }
 
                virtual void SetSourceScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetSourceScene(  ) = 0;
 
                virtual void SetDestinationScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetDestinationScene(  ) = 0;
 
                virtual void SetSourceGeometry( IGeometryData *value ) = 0;
 
                virtual CountedPointer<IGeometryData> GetSourceGeometry(  ) = 0;
 
                virtual void SetDestinationGeometry( IGeometryData *value ) = 0;
 
                virtual CountedPointer<IGeometryData> GetDestinationGeometry(  ) = 0;
 
                virtual CountedPointer<IMappingImageSettings> GetMappingImageSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
                virtual void SetDestinationTexCoordSet( rid value ) = 0;
 
                virtual rid GetDestinationTexCoordSet(  ) = 0;
 
                virtual void SetRecalculateSearchDirection( bool value ) = 0;
 
                virtual bool GetRecalculateSearchDirection(  ) = 0;
 
                virtual void SetSearchDirectionHardEdgeAngleInRadians( real value ) = 0;
 
                virtual real GetSearchDirectionHardEdgeAngleInRadians(  ) = 0;
 
                virtual void SetSearchDistance( real value ) = 0;
 
                virtual real GetSearchDistance(  ) = 0;
 
                virtual void SetSearchOffset( real value ) = 0;
 
                virtual real GetSearchOffset(  ) = 0;
 
                virtual void RunSurfaceMapping(  ) = 0;
 
        };
 
        typedef CountedPointer<ISurfaceMapper> spSurfaceMapper;
 
        #define InterfaceDefined_SimplygonSDK_ISurfaceMapper 1
 
        class IScene;
        class IOcclusionMeshSettings;
 
        class IOcclusionMeshProcessor : public IProcessingObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IOcclusionMeshProcessor",type)==0 )
                                return true;
                        return IProcessingObject::IsClassA(type);
                        }
                static IOcclusionMeshProcessor *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IOcclusionMeshProcessor") )
                                return static_cast<IOcclusionMeshProcessor*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual CountedPointer<IOcclusionMeshSettings> GetOcclusionMeshSettings(  ) = 0;
 
        };
 
        typedef CountedPointer<IOcclusionMeshProcessor> spOcclusionMeshProcessor;
 
        #define InterfaceDefined_SimplygonSDK_IOcclusionMeshProcessor 1
 
 
        class IOcclusionMeshSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IOcclusionMeshSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IOcclusionMeshSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IOcclusionMeshSettings") )
                                return static_cast<IOcclusionMeshSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetOnScreenSize( unsigned int value ) = 0;
 
                virtual unsigned int GetOnScreenSize(  ) = 0;
 
                virtual void SetOnScreenErrorTolerance( unsigned int value ) = 0;
 
                virtual unsigned int GetOnScreenErrorTolerance(  ) = 0;
 
                virtual void SetInvertOutputMesh( bool value ) = 0;
 
                virtual bool GetInvertOutputMesh(  ) = 0;
 
                virtual void SetTransferSkinning( bool value ) = 0;
 
                virtual bool GetTransferSkinning(  ) = 0;
 
                virtual void SetUseCameras( bool value ) = 0;
 
                virtual bool GetUseCameras(  ) = 0;
 
                virtual void SetCameraSelectionSetId( int value ) = 0;
 
                virtual int GetCameraSelectionSetId(  ) = 0;
 
                virtual void SetCameraSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetCameraSelectionSetName(  ) = 0;
 
                virtual void SetOcclusionMode( unsigned int value ) = 0;
 
                virtual unsigned int GetOcclusionMode(  ) = 0;
 
        };
 
        typedef CountedPointer<IOcclusionMeshSettings> spOcclusionMeshSettings;
 
        #define InterfaceDefined_SimplygonSDK_IOcclusionMeshSettings 1
 
        class IScene;
        class IFoliageSettings;
        class IMappingImageSettings;
        class IMappingImage;
 
        class IFoliageProcessor : public IProcessingObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IFoliageProcessor",type)==0 )
                                return true;
                        return IProcessingObject::IsClassA(type);
                        }
                static IFoliageProcessor *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IFoliageProcessor") )
                                return static_cast<IFoliageProcessor*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual CountedPointer<IFoliageSettings> GetFoliageSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImageSettings> GetMappingImageSettings(  ) = 0;
 
                virtual SGDEPRECATED CountedPointer<IMappingImage> GetFoliageMappingImage(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
                virtual int GetFoliageMaterialID(  ) = 0;
 
        };
 
        typedef CountedPointer<IFoliageProcessor> spFoliageProcessor;
 
        #define InterfaceDefined_SimplygonSDK_IFoliageProcessor 1
 
 
        class IFoliageSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IFoliageSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IFoliageSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IFoliageSettings") )
                                return static_cast<IFoliageSettings*>(ptr);
                        return NULL;
                        }
 
                virtual unsigned int GetFoliageType(  ) = 0;
 
                virtual void SetFoliageType( unsigned int value ) = 0;
 
                virtual bool GetBillboardFavorVerticalPlanes(  ) = 0;
 
                virtual void SetBillboardFavorVerticalPlanes( bool value ) = 0;
 
                virtual bool GetBillboardAllowConvexPolygons(  ) = 0;
 
                virtual void SetBillboardAllowConvexPolygons( bool value ) = 0;
 
                virtual bool GetBillboardSubdividePlanes(  ) = 0;
 
                virtual void SetBillboardSubdividePlanes( bool value ) = 0;
 
                virtual unsigned int GetBillboardMaxPlaneCount(  ) = 0;
 
                virtual void SetBillboardMaxPlaneCount( unsigned int value ) = 0;
 
                virtual bool GetBillboardTwoSided(  ) = 0;
 
                virtual void SetBillboardTwoSided( bool value ) = 0;
 
                virtual bool GetBillboardUseVisibilityWeights(  ) = 0;
 
                virtual void SetBillboardUseVisibilityWeights( bool value ) = 0;
 
                virtual unsigned int GetFlipbookNumberOfViews(  ) = 0;
 
                virtual void SetFlipbookNumberOfViews( unsigned int value ) = 0;
 
                virtual float GetFlipbookVerticalAngleInRadians(  ) = 0;
 
                virtual void SetFlipbookVerticalAngleInRadians( float value ) = 0;
 
                virtual float GetSeparateFoliageTriangleRatio(  ) = 0;
 
                virtual void SetSeparateFoliageTriangleRatio( float value ) = 0;
 
                virtual unsigned int GetSeparateFoliageTriangleThreshold(  ) = 0;
 
                virtual void SetSeparateFoliageTriangleThreshold( unsigned int value ) = 0;
 
                virtual real GetSeparateFoliageAreaThreshold(  ) = 0;
 
                virtual void SetSeparateFoliageAreaThreshold( real value ) = 0;
 
                virtual real GetSeparateFoliageSizeThreshold(  ) = 0;
 
                virtual void SetSeparateFoliageSizeThreshold( real value ) = 0;
 
                virtual float GetBillboardDensity(  ) = 0;
 
                virtual void SetBillboardDensity( float value ) = 0;
 
                virtual float GetBillboardTrunkReductionRatio(  ) = 0;
 
                virtual void SetBillboardTrunkReductionRatio( float value ) = 0;
 
        };
 
        typedef CountedPointer<IFoliageSettings> spFoliageSettings;
 
        #define InterfaceDefined_SimplygonSDK_IFoliageSettings 1
 
        class IScene;
        class IShadowMeshSettings;
 
        class IShadowMeshProcessor : public IProcessingObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadowMeshProcessor",type)==0 )
                                return true;
                        return IProcessingObject::IsClassA(type);
                        }
                static IShadowMeshProcessor *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadowMeshProcessor") )
                                return static_cast<IShadowMeshProcessor*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual CountedPointer<IShadowMeshSettings> GetShadowMeshSettings(  ) = 0;
 
        };
 
        typedef CountedPointer<IShadowMeshProcessor> spShadowMeshProcessor;
 
        #define InterfaceDefined_SimplygonSDK_IShadowMeshProcessor 1
 
 
        class IShadowMeshSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IShadowMeshSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IShadowMeshSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IShadowMeshSettings") )
                                return static_cast<IShadowMeshSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetOnScreenSize( unsigned int value ) = 0;
 
                virtual unsigned int GetOnScreenSize(  ) = 0;
 
                virtual void SetOnScreenErrorTolerance( unsigned int value ) = 0;
 
                virtual unsigned int GetOnScreenErrorTolerance(  ) = 0;
 
        };
 
        typedef CountedPointer<IShadowMeshSettings> spShadowMeshSettings;
 
        #define InterfaceDefined_SimplygonSDK_IShadowMeshSettings 1
 
        class IImageData;
        class IBoolArray;
 
        class IImageComparer : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IImageComparer",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IImageComparer *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IImageComparer") )
                                return static_cast<IImageComparer*>(ptr);
                        return NULL;
                        }
 
                virtual void SetImages( IImageData *beforeImg , IImageData *afterImg ) = 0;
 
                virtual void SetImageMasks( IBoolArray *beforeImgMask , IBoolArray *afterImgMask ) = 0;
 
                virtual int CompareImages(  ) = 0;
 
                virtual void SetImagePathBeforeImg( const char * value ) = 0;
 
                virtual void SetImagePathAfterImg( const char * value ) = 0;
 
                virtual void SetImageDiffExportPath( const char * value ) = 0;
 
                virtual void SetDiffHighlightsExportPath( const char * value ) = 0;
 
                virtual CountedPointer<IImageData> GetImageDiff(  ) = 0;
 
                virtual CountedPointer<IImageData> GetDiffHighlights(  ) = 0;
 
                virtual unsigned int GetTotalMaskCoverage(  ) = 0;
 
                virtual float GetMaxPixelError(  ) = 0;
 
                virtual float GetTotalPixelError(  ) = 0;
 
                virtual unsigned int GetHighlightAreaCoverage(  ) = 0;
 
                virtual void SetSilhouetteDifferenceError( float value ) = 0;
 
        };
 
        typedef CountedPointer<IImageComparer> spImageComparer;
 
        #define InterfaceDefined_SimplygonSDK_IImageComparer 1
 
        class IGeometryData;
 
        class IRecommendedTextureSizeCalculator : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IRecommendedTextureSizeCalculator",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IRecommendedTextureSizeCalculator *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IRecommendedTextureSizeCalculator") )
                                return static_cast<IRecommendedTextureSizeCalculator*>(ptr);
                        return NULL;
                        }
 
                virtual void SetForcePower2Texture( bool value ) = 0;
 
                virtual bool GetForcePower2Texture(  ) = 0;
 
                virtual void SetRecommendedTextureSizeMultiplier( real value ) = 0;
 
                virtual real GetRecommendedTextureSizeMultiplier(  ) = 0;
 
                virtual unsigned int GetRecommendedWidth(  ) = 0;
 
                virtual unsigned int GetRecommendedHeight(  ) = 0;
 
                virtual void CalculateBasedOnDeviation( IGeometryData *geom , real deviation ) = 0;
 
                virtual void CalculateBasedOnOnScreenSize( IGeometryData *geom , unsigned int onScreenSize ) = 0;
 
        };
 
        typedef CountedPointer<IRecommendedTextureSizeCalculator> spRecommendedTextureSizeCalculator;
 
        #define InterfaceDefined_SimplygonSDK_IRecommendedTextureSizeCalculator 1
 
        class IGeometryData;
        class IScene;
        class IRealArray;
 
        class IPartRemover : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IPartRemover",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IPartRemover *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IPartRemover") )
                                return static_cast<IPartRemover*>(ptr);
                        return NULL;
                        }
 
                virtual void RunPartRemoval(  ) = 0;
 
                virtual void SetGeometry( IGeometryData *value ) = 0;
 
                virtual CountedPointer<IGeometryData> GetGeometry(  ) = 0;
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual void SetSizeThreshold( real value ) = 0;
 
                virtual real GetSizeThreshold(  ) = 0;
 
                virtual void SetUsePerMaterialSizeThresholds( bool value ) = 0;
 
                virtual bool GetUsePerMaterialSizeThresholds(  ) = 0;
 
                virtual CountedPointer<IRealArray> GetPerMaterialSizeThresholds(  ) = 0;
 
        };
 
        typedef CountedPointer<IPartRemover> spPartRemover;
 
        #define InterfaceDefined_SimplygonSDK_IPartRemover 1
 
        class IScene;
        class IGeometryData;
 
        class IWelder : public IProcessingObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IWelder",type)==0 )
                                return true;
                        return IProcessingObject::IsClassA(type);
                        }
                static IWelder *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IWelder") )
                                return static_cast<IWelder*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual void SetSelectionSetID( rid value ) = 0;
 
                virtual rid GetSelectionSetID(  ) = 0;
 
                virtual void SetProcessSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetProcessSelectionSetName(  ) = 0;
 
                virtual void SetWeldDist( real value ) = 0;
 
                virtual real GetWeldDist(  ) = 0;
 
                virtual void WeldGeometry( IGeometryData *geom ) = 0;
 
                virtual void SetUpdateExtents( bool value ) = 0;
 
                virtual bool GetUpdateExtents(  ) = 0;
 
                virtual void SetProgressivePasses( unsigned int value ) = 0;
 
                virtual unsigned int GetProgressivePasses(  ) = 0;
 
                virtual void SetIgnoreVertexLocks( bool value ) = 0;
 
                virtual bool GetIgnoreVertexLocks(  ) = 0;
 
                virtual void SetCompactMesh( bool value ) = 0;
 
                virtual bool GetCompactMesh(  ) = 0;
 
                virtual void SetOnlyBorders( bool value ) = 0;
 
                virtual bool GetOnlyBorders(  ) = 0;
 
                virtual void SetOnlyWithinMaterial( bool value ) = 0;
 
                virtual bool GetOnlyWithinMaterial(  ) = 0;
 
                virtual void SetOnlyWithinSceneNode( bool value ) = 0;
 
                virtual bool GetOnlyWithinSceneNode(  ) = 0;
 
                virtual void SetOnlyBetweenSceneNodes( bool value ) = 0;
 
                virtual bool GetOnlyBetweenSceneNodes(  ) = 0;
 
                virtual SGDEPRECATED bool GetOnlyObjectBoundaryFlag(  ) = 0;
 
                virtual SGDEPRECATED void SetOnlyObjectBoundaryFlag( bool onlyObjectBoundaryFlag ) = 0;
 
                virtual SGDEPRECATED bool GetOnlyWithinMaterialFlag(  ) = 0;
 
                virtual SGDEPRECATED void SetOnlyWithinMaterialFlag( bool onlyWithinMaterialFlag ) = 0;
 
                virtual SGDEPRECATED bool GetOnlyBordersFlag(  ) = 0;
 
                virtual SGDEPRECATED void SetOnlyBordersFlag( bool onlyBordersFlag ) = 0;
 
                virtual SGDEPRECATED rstring GetSelectionSetName(  ) = 0;
 
                virtual SGDEPRECATED void SetSelectionSetName( const char * selectionSetName ) = 0;
 
                virtual SGDEPRECATED void Weld(  ) = 0;
 
        };
 
        typedef CountedPointer<IWelder> spWelder;
 
        #define InterfaceDefined_SimplygonSDK_IWelder 1
 
        class IScene;
        class IGeometryData;
 
        class ITJunctionEliminator : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("ITJunctionEliminator",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static ITJunctionEliminator *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("ITJunctionEliminator") )
                                return static_cast<ITJunctionEliminator*>(ptr);
                        return NULL;
                        }
 
                virtual void SetScene( IScene *value ) = 0;
 
                virtual CountedPointer<IScene> GetScene(  ) = 0;
 
                virtual void RemoveTJunctions( IGeometryData *geom ) = 0;
 
                virtual void RemoveTJunctions(  ) = 0;
 
                virtual void SetWeldDist( real value ) = 0;
 
                virtual real GetWeldDist(  ) = 0;
 
                virtual void SetOnlyObjectBoundaryFlag( bool value ) = 0;
 
                virtual bool GetOnlyObjectBoundaryFlag(  ) = 0;
 
                virtual void SetSelectionSetID( rid value ) = 0;
 
                virtual rid GetSelectionSetID(  ) = 0;
 
                virtual void SetSelectionSetName( const char * value ) = 0;
 
                virtual rstring GetSelectionSetName(  ) = 0;
 
                virtual void SetOnlyWithinMaterialFlag( bool value ) = 0;
 
                virtual bool GetOnlyWithinMaterialFlag(  ) = 0;
 
        };
 
        typedef CountedPointer<ITJunctionEliminator> spTJunctionEliminator;
 
        #define InterfaceDefined_SimplygonSDK_ITJunctionEliminator 1
 
        class IScene;
        class IMaterialCaster;
        class IObjectCollection;
        class IPipelineSettings;
 
        class IPipeline : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IPipeline",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IPipeline *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IPipeline") )
                                return static_cast<IPipeline*>(ptr);
                        return NULL;
                        }
 
                virtual void RunSceneFromFile( const char * input_scene , const char * output_scene ) = 0;
 
                virtual void RunScene( IScene *scene ) = 0;
 
                virtual void AddMaterialCaster( IMaterialCaster *MaterialCaster , unsigned int MaterialIndex ) = 0;
 
                virtual CountedPointer<IMaterialCaster> AddMaterialCasterByType( const char * CasterType , unsigned int MaterialIndex ) = 0;
 
                virtual CountedPointer<IObjectCollection> GetMaterialCasters(  ) = 0;
 
                virtual CountedPointer<IPipelineSettings> GetPipelineSettings(  ) = 0;
 
                virtual bool SetBoolParameter( const char * name , bool value ) = 0;
 
                virtual bool SetIntParameter( const char * name , int value ) = 0;
 
                virtual bool SetUIntParameter( const char * name , unsigned int value ) = 0;
 
                virtual bool SetDoubleParameter( const char * name , double value ) = 0;
 
                virtual bool SetStringParameter( const char * name , const char * value ) = 0;
 
                virtual bool SetParameterFromString( const char * name , const char * value ) = 0;
 
                virtual bool GetBoolParameter( const char * name ) = 0;
 
                virtual int GetIntParameter( const char * name ) = 0;
 
                virtual unsigned int GetUIntParameter( const char * name ) = 0;
 
                virtual double GetDoubleParameter( const char * name ) = 0;
 
                virtual rstring GetStringParameter( const char * name ) = 0;
 
                virtual unsigned int GetParameterType( const char * name ) = 0;
 
        };
 
        typedef CountedPointer<IPipeline> spPipeline;
 
        #define InterfaceDefined_SimplygonSDK_IPipeline 1
 
        class IPipeline;
 
        class IPipelineSerializer : public IObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IPipelineSerializer",type)==0 )
                                return true;
                        return IObject::IsClassA(type);
                        }
                static IPipelineSerializer *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IPipelineSerializer") )
                                return static_cast<IPipelineSerializer*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IPipeline> LoadPipelineFromFile( const char * path ) = 0;
 
                virtual void SavePipelineToFile( const char * path , IPipeline *pipeline ) = 0;
 
        };
 
        typedef CountedPointer<IPipelineSerializer> spPipelineSerializer;
 
        #define InterfaceDefined_SimplygonSDK_IPipelineSerializer 1
 
        class IReductionSettings;
        class IRepairSettings;
        class INormalCalculationSettings;
        class IMappingImageSettings;
        class IVisibilitySettings;
        class IBoneSettings;
        class IMappingImage;
 
        class IReductionPipeline : public IPipeline
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IReductionPipeline",type)==0 )
                                return true;
                        return IPipeline::IsClassA(type);
                        }
                static IReductionPipeline *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IReductionPipeline") )
                                return static_cast<IReductionPipeline*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IReductionSettings> GetReductionSettings(  ) = 0;
 
                virtual CountedPointer<IRepairSettings> GetRepairSettings(  ) = 0;
 
                virtual CountedPointer<INormalCalculationSettings> GetNormalCalculationSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImageSettings> GetMappingImageSettings(  ) = 0;
 
                virtual CountedPointer<IVisibilitySettings> GetVisibilitySettings(  ) = 0;
 
                virtual CountedPointer<IBoneSettings> GetBoneSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
        };
 
        typedef CountedPointer<IReductionPipeline> spReductionPipeline;
 
        #define InterfaceDefined_SimplygonSDK_IReductionPipeline 1
 
        class IRemeshingSettings;
        class IMappingImageSettings;
        class IVisibilitySettings;
        class IBoneSettings;
        class IMappingImage;
 
        class IRemeshingPipeline : public IPipeline
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IRemeshingPipeline",type)==0 )
                                return true;
                        return IPipeline::IsClassA(type);
                        }
                static IRemeshingPipeline *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IRemeshingPipeline") )
                                return static_cast<IRemeshingPipeline*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IRemeshingSettings> GetRemeshingSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImageSettings> GetMappingImageSettings(  ) = 0;
 
                virtual CountedPointer<IVisibilitySettings> GetVisibilitySettings(  ) = 0;
 
                virtual CountedPointer<IBoneSettings> GetBoneSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
        };
 
        typedef CountedPointer<IRemeshingPipeline> spRemeshingPipeline;
 
        #define InterfaceDefined_SimplygonSDK_IRemeshingPipeline 1
 
        class IAggregationSettings;
        class IMappingImageSettings;
        class IVisibilitySettings;
        class IMappingImage;
 
        class IAggregationPipeline : public IPipeline
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IAggregationPipeline",type)==0 )
                                return true;
                        return IPipeline::IsClassA(type);
                        }
                static IAggregationPipeline *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IAggregationPipeline") )
                                return static_cast<IAggregationPipeline*>(ptr);
                        return NULL;
                        }
 
                virtual CountedPointer<IAggregationSettings> GetAggregationSettings(  ) = 0;
 
                virtual CountedPointer<IMappingImageSettings> GetMappingImageSettings(  ) = 0;
 
                virtual CountedPointer<IVisibilitySettings> GetVisibilitySettings(  ) = 0;
 
                virtual CountedPointer<IMappingImage> GetMappingImage(  ) = 0;
 
        };
 
        typedef CountedPointer<IAggregationPipeline> spAggregationPipeline;
 
        #define InterfaceDefined_SimplygonSDK_IAggregationPipeline 1
 
 
        class IPipelineSettings : public ISettingsObject
        {
        public:
                virtual const char *GetClass();
 
                virtual bool IsA( const char *type ) const;
 
                static bool IsClassA( const char *type )
                        {
                        if( !type )
                                return false;
                        if( strcmp("IPipelineSettings",type)==0 )
                                return true;
                        return ISettingsObject::IsClassA(type);
                        }
                static IPipelineSettings *SafeCast( IObject *ptr )
                        {
                        if( ptr && ptr->IsA("IPipelineSettings") )
                                return static_cast<IPipelineSettings*>(ptr);
                        return NULL;
                        }
 
                virtual void SetTextureOutputPath( const char * value ) = 0;
 
                virtual rstring GetTextureOutputPath(  ) = 0;
 
        };
 
        typedef CountedPointer<IPipelineSettings> spPipelineSettings;
 
        #define InterfaceDefined_SimplygonSDK_IPipelineSettings 1
 
        class ISimplygonSDK
        {
        public:
                SGDEPRECATED virtual CountedPointer<IStringArray> CreateStringArray() = 0;
 
                virtual CountedPointer<IBoolArray> CreateBoolArray() = 0;
 
                virtual CountedPointer<ICharArray> CreateCharArray() = 0;
 
                virtual CountedPointer<IDoubleArray> CreateDoubleArray() = 0;
 
                virtual CountedPointer<IFloatArray> CreateFloatArray() = 0;
 
                virtual CountedPointer<IIntArray> CreateIntArray() = 0;
 
                virtual CountedPointer<ILongArray> CreateLongArray() = 0;
 
                virtual CountedPointer<IRealArray> CreateRealArray() = 0;
 
                virtual CountedPointer<IRidArray> CreateRidArray() = 0;
 
                virtual CountedPointer<IShortArray> CreateShortArray() = 0;
 
                virtual CountedPointer<IUnsignedCharArray> CreateUnsignedCharArray() = 0;
 
                virtual CountedPointer<IUnsignedIntArray> CreateUnsignedIntArray() = 0;
 
                virtual CountedPointer<IUnsignedLongArray> CreateUnsignedLongArray() = 0;
 
                virtual CountedPointer<IUnsignedShortArray> CreateUnsignedShortArray() = 0;
 
                virtual CountedPointer<IDirectXRenderer> CreateDirectXRenderer() = 0;
 
                virtual CountedPointer<IGeometryData> CreateGeometryData() = 0;
 
                virtual CountedPointer<IPackedGeometryData> CreatePackedGeometryData() = 0;
 
                virtual CountedPointer<IImageData> CreateImageData() = 0;
 
                virtual CountedPointer<ITable> CreateTable() = 0;
 
                virtual CountedPointer<IMaterial> CreateMaterial() = 0;
 
                virtual CountedPointer<IMaterialTable> CreateMaterialTable() = 0;
 
                virtual CountedPointer<IMatrix4x4> CreateMatrix4x4() = 0;
 
                virtual CountedPointer<ITransform3> CreateTransform3() = 0;
 
                virtual CountedPointer<IParameterizer> CreateParameterizer() = 0;
 
                virtual CountedPointer<IObjectCollection> CreateObjectCollection() = 0;
 
                virtual CountedPointer<IGeometryDataCollection> CreateGeometryDataCollection() = 0;
 
                virtual CountedPointer<IWavefrontImporter> CreateWavefrontImporter() = 0;
 
                virtual CountedPointer<IWavefrontExporter> CreateWavefrontExporter() = 0;
 
                virtual CountedPointer<IBinaryImporter> CreateBinaryImporter() = 0;
 
                virtual CountedPointer<IBinaryExporter> CreateBinaryExporter() = 0;
 
                virtual CountedPointer<IGeometryValidator> CreateGeometryValidator() = 0;
 
                virtual CountedPointer<IMaterialCasterSettings> CreateMaterialCasterSettings() = 0;
 
                virtual CountedPointer<IColorCaster> CreateColorCaster() = 0;
 
                virtual CountedPointer<IColorCasterSettings> CreateColorCasterSettings() = 0;
 
                virtual CountedPointer<IOpacityCaster> CreateOpacityCaster() = 0;
 
                virtual CountedPointer<IOpacityCasterSettings> CreateOpacityCasterSettings() = 0;
 
                virtual CountedPointer<INormalCaster> CreateNormalCaster() = 0;
 
                virtual CountedPointer<INormalCasterSettings> CreateNormalCasterSettings() = 0;
 
                virtual CountedPointer<INormalRepairer> CreateNormalRepairer() = 0;
 
                virtual CountedPointer<IDisplacementCaster> CreateDisplacementCaster() = 0;
 
                virtual CountedPointer<IDisplacementCasterSettings> CreateDisplacementCasterSettings() = 0;
 
                virtual CountedPointer<ITangentCalculator> CreateTangentCalculator() = 0;
 
                virtual CountedPointer<IReductionSettings> CreateReductionSettings() = 0;
 
                virtual CountedPointer<IReductionProcessor> CreateReductionProcessor() = 0;
 
                virtual CountedPointer<IRemeshingProcessor> CreateRemeshingProcessor() = 0;
 
                virtual CountedPointer<IRemeshingProcessorV2> CreateRemeshingProcessorV2() = 0;
 
                virtual CountedPointer<IScene> CreateScene() = 0;
 
                virtual CountedPointer<ISceneNode> CreateSceneNode() = 0;
 
                virtual CountedPointer<ISceneNodeCollection> CreateSceneNodeCollection() = 0;
 
                virtual CountedPointer<ISceneMesh> CreateSceneMesh() = 0;
 
                virtual CountedPointer<ISceneLodGroup> CreateSceneLodGroup() = 0;
 
                virtual CountedPointer<ISceneBone> CreateSceneBone() = 0;
 
                virtual CountedPointer<ISceneBoneTable> CreateSceneBoneTable() = 0;
 
                virtual CountedPointer<IScenePlane> CreateScenePlane() = 0;
 
                virtual CountedPointer<ISceneCamera> CreateSceneCamera() = 0;
 
                virtual CountedPointer<ISelectionSet> CreateSelectionSet() = 0;
 
                virtual CountedPointer<ISelectionSetTable> CreateSelectionSetTable() = 0;
 
                virtual CountedPointer<ITexture> CreateTexture() = 0;
 
                virtual CountedPointer<ITextureTable> CreateTextureTable() = 0;
 
                virtual CountedPointer<IImageDataImporter> CreateImageDataImporter() = 0;
 
                virtual CountedPointer<IShadingTextureNode> CreateShadingTextureNode() = 0;
 
                virtual CountedPointer<IShadingSwizzlingNode> CreateShadingSwizzlingNode() = 0;
 
                virtual CountedPointer<IShadingColorNode> CreateShadingColorNode() = 0;
 
                virtual CountedPointer<IShadingAddNode> CreateShadingAddNode() = 0;
 
                virtual CountedPointer<IShadingSubtractNode> CreateShadingSubtractNode() = 0;
 
                virtual CountedPointer<IShadingMultiplyNode> CreateShadingMultiplyNode() = 0;
 
                virtual CountedPointer<IShadingPowNode> CreateShadingPowNode() = 0;
 
                virtual CountedPointer<IShadingDivideNode> CreateShadingDivideNode() = 0;
 
                virtual CountedPointer<IShadingClampNode> CreateShadingClampNode() = 0;
 
                virtual CountedPointer<IShadingMaxNode> CreateShadingMaxNode() = 0;
 
                virtual CountedPointer<IShadingMinNode> CreateShadingMinNode() = 0;
 
                virtual CountedPointer<IShadingStepNode> CreateShadingStepNode() = 0;
 
                virtual CountedPointer<IShadingEqualNode> CreateShadingEqualNode() = 0;
 
                virtual CountedPointer<IShadingNotEqualNode> CreateShadingNotEqualNode() = 0;
 
                virtual CountedPointer<IShadingVertexColorNode> CreateShadingVertexColorNode() = 0;
 
                virtual CountedPointer<IShadingInterpolateNode> CreateShadingInterpolateNode() = 0;
 
                virtual CountedPointer<IShadingCustomNode> CreateShadingCustomNode() = 0;
 
                virtual CountedPointer<IShadingLayeredBlendNode> CreateShadingLayeredBlendNode() = 0;
 
                virtual CountedPointer<IShadingNormalize3Node> CreateShadingNormalize3Node() = 0;
 
                virtual CountedPointer<IShadingSqrtNode> CreateShadingSqrtNode() = 0;
 
                virtual CountedPointer<IShadingDot3Node> CreateShadingDot3Node() = 0;
 
                virtual CountedPointer<IShadingCross3Node> CreateShadingCross3Node() = 0;
 
                virtual CountedPointer<IShadingCosNode> CreateShadingCosNode() = 0;
 
                virtual CountedPointer<IShadingSinNode> CreateShadingSinNode() = 0;
 
                virtual CountedPointer<IShadingGreaterThanNode> CreateShadingGreaterThanNode() = 0;
 
                virtual CountedPointer<IShadingLessThanNode> CreateShadingLessThanNode() = 0;
 
                virtual CountedPointer<IShaderGenerator> CreateShaderGenerator() = 0;
 
                virtual CountedPointer<IAggregationProcessor> CreateAggregationProcessor() = 0;
 
                virtual CountedPointer<IAggregationSettings> CreateAggregationSettings() = 0;
 
                virtual CountedPointer<IChartAggregator> CreateChartAggregator() = 0;
 
                virtual CountedPointer<IVertexColorBaker> CreateVertexColorBaker() = 0;
 
                virtual CountedPointer<IImageDataExporter> CreateImageDataExporter() = 0;
 
                virtual CountedPointer<IAmbientOcclusionCaster> CreateAmbientOcclusionCaster() = 0;
 
                virtual CountedPointer<IAmbientOcclusionCasterSettings> CreateAmbientOcclusionCasterSettings() = 0;
 
                virtual CountedPointer<IImpostorProcessor> CreateImpostorProcessor() = 0;
 
                virtual CountedPointer<IImpostorSettings> CreateImpostorSettings() = 0;
 
                virtual CountedPointer<ISurfaceMapper> CreateSurfaceMapper() = 0;
 
                virtual CountedPointer<IOcclusionMeshProcessor> CreateOcclusionMeshProcessor() = 0;
 
                virtual CountedPointer<IFoliageProcessor> CreateFoliageProcessor() = 0;
 
                virtual CountedPointer<IShadowMeshProcessor> CreateShadowMeshProcessor() = 0;
 
                virtual CountedPointer<IImageComparer> CreateImageComparer() = 0;
 
                virtual CountedPointer<IRecommendedTextureSizeCalculator> CreateRecommendedTextureSizeCalculator() = 0;
 
                virtual CountedPointer<IPartRemover> CreatePartRemover() = 0;
 
                virtual CountedPointer<IWelder> CreateWelder() = 0;
 
                virtual CountedPointer<ITJunctionEliminator> CreateTJunctionEliminator() = 0;
 
                virtual CountedPointer<IPipelineSerializer> CreatePipelineSerializer() = 0;
 
                virtual CountedPointer<IReductionPipeline> CreateReductionPipeline() = 0;
 
                virtual CountedPointer<IRemeshingPipeline> CreateRemeshingPipeline() = 0;
 
                virtual CountedPointer<IAggregationPipeline> CreateAggregationPipeline() = 0;
 
                virtual CountedPointer<IPipelineSettings> CreatePipelineSettings() = 0;
 
                virtual rdata<IBoolData> CreateBoolData() = 0;
 
                virtual rdata<ICharData> CreateCharData() = 0;
 
                virtual rdata<IUnsignedCharData> CreateUnsignedCharData() = 0;
 
                virtual rdata<IShortData> CreateShortData() = 0;
 
                virtual rdata<IUnsignedShortData> CreateUnsignedShortData() = 0;
 
                virtual rdata<IIntData> CreateIntData() = 0;
 
                virtual rdata<IUnsignedIntData> CreateUnsignedIntData() = 0;
 
                virtual rdata<ILongData> CreateLongData() = 0;
 
                virtual rdata<IUnsignedLongData> CreateUnsignedLongData() = 0;
 
                virtual rdata<IFloatData> CreateFloatData() = 0;
 
                virtual rdata<IDoubleData> CreateDoubleData() = 0;
 
                virtual rdata<IRealData> CreateRealData() = 0;
 
                virtual rdata<IRidData> CreateRidData() = 0;
 
                virtual rdata<IRhandleData> CreateRhandleData() = 0;
 
                virtual rerrorhandler *SetErrorHandler( rerrorhandler *handler ) = 0;
                virtual const char *GetVersion() const = 0;
                virtual void SetGlobalSetting( const char *setting_name , intptr_t value ) const = 0;
                virtual intptr_t GetGlobalSetting( const char *setting_name ) const = 0;
                virtual void SetThreadLocalSetting( const char *setting_name , intptr_t value ) const = 0;
                virtual intptr_t GetThreadLocalSetting( const char *setting_name ) const = 0;
        };
 
    template<class T> CountedPointer<T> SafeCast( IObject *ptr )
        {
        return CountedPointer<T>(T::SafeCast(ptr));
        }
    
    template<class T> CountedPointer<T> UnsafeCast( IObject *ptr )
        {
        return CountedPointer<T>(static_cast<T*>(ptr));
        }
    
    template<class T> CountedPointer<T> Cast( IObject *ptr )
        {
        return SafeCast<T>(ptr);
        }
 
        inline const char *GetInterfaceVersionHash()
                {
                return "BC34FC7A54A4BE733345BF339D32C8F0E6881FC2A340054CDB5A2262CDDEBFA7";
                }
 
        inline const char *GetHeaderVersion()
                {
                return "8.3.34600";
                }
 
};
 
#ifdef _WIN32
#pragma warning( pop )
#endif
#endif//_SIMPLYGONSDK_H_