3DMaterial.h

Go to the documentation of this file.

//! @file 3DMaterial.h
//! @brief The files handles materials definition
//! 
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_3DMaterial_H__CA6BC29F_FAC2_11D1_A0DE_000000000000__INCLUDED_)
#define AFX_3DMaterial_H__CA6BC29F_FAC2_11D1_A0DE_000000000000__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "3DAnimatable.h"
#include "RGBColor.h"
 
#include "DependentChannels.h"
#include "MaterialMap.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
#define MATERIAL_GUID_CLASS MAKE_CUSTOM_ID('M', 'A', 'T', 'R')
 
//! @enum MATERIAL_COPY_FLAGS
//! These flags give a way to control material copy
typedef enum MATERIAL_COPY_FLAGS
{
    MATERIAL_COPY_DEFAULT = 0x00,
    MATERIAL_COPY_KEEP_ID = 0x01, // Keep the material id when copying. If id already exist, then it is not replaced.
    MATERIAL_COPY_REMOVE_ALL = 0x02, // Remove all existings materials before copying
    MATERIAL_COPY_USE_HASH = 0x04, // Copy only materials find in the provided hash
} MATERIAL_COPY_FLAGS;
 
//! @enum MATERIAL_FLAGS
//! Flags defining different material properties
typedef enum MATERIAL_FLAGS XEnumType(unsigned int)
{
    MATERIAL_NONE = 0x00,
    MATERIAL_FLAGS_MASK = 0x000FFFFF,
    MATERIAL_IS_HIDDEN = 0x01,
    MATERIAL_DISABLE_DIFFUSE_MODULATION = 0x02, //!< This means that the diffuse color has no effect on texturing (does not modulate texture)
    MATERIAL_USE_FRONT_CHANNEL_WHEN_BACK_MISSING = 0x1000, //!< For the material maps, use the front UV on the back side (the flag is not active if front & back materials are defined or if back channel exists). The flag requires the object context and is taken into account in GetChannelID(CGeomInfo *info... for example
    MATERIAL_INVALIDATION_MASK  = 0xFFF00000,
    MATERIAL_NAME_CHANGED       = 0x00100000,
    MATERIAL_MAPS_CHANGED       = 0x00200000,
    MATERIAL_COLORS_CHANGED     = 0x00400000,
    MATERIAL_OTHERS_CHANGED     = 0x00800000,
    MATERIAL_MAPS_DOWNLOADED    = 0x01000000, // A material map has been downloaded. If the file was missing, this give a chance to the CMaterialMap to load again the bitmap
} MATERIAL_FLAGS;
 
//! @enum MATERIAL_CLASS
//! C3DMaterial is the base material. C3DMaterial::GetClass allows to cast to the appropriate derived class
typedef enum MATERIAL_CLASS XEnumType(unsigned char)
{
    MATERIAL_CLASS_UNDEFINED = 0,
    MATERIAL_CLASS_STANDARD = 1, //!< The material is a C3DStandardMaterial
    MATERIAL_CLASS_PBR, //!< The material is a C3DPbrMaterial
} MATERIAL_CLASS;
 
class CMaterials;
class C3DStandardMaterial;
 
template <> class CHashMethods<MapType> : public CHashMethods<unsigned int> {};
 
//! @class C3DMaterial
//! @brief C3DMaterial is the base class for materials. There is currently two kinds of materials: C3DPbrMaterial or C3DStandardMaterial.
//! Any kind of materials can be converted to C3DStandardMaterial, because many 3D exports only handle this kind of material.
//! Cf. #MATERIALS to know more about materials.
class DLL_3DFUNCTION C3DMaterial : public CXObject, public C3DKeyframable
{
    friend CMaterials;
 
public:
    typedef enum  _faceModeEnum XEnumType(unsigned int)
    {
        FACE_DEFAULT_MODE = 0,
        SINGLE_SIDE,
        DOUBLE_SIDE,
    } faceModeEnum;
 
    typedef enum  _alphaModeEnum XEnumType(unsigned int)
    {
        ALPHA_BLEND = 0x01, //!< Default mode, the cutoff value define the alpha cutoff threshold (0 by default).
        ALPHA_OPAQUE = 0x02, //!< Alpha is disabled, the map is entirely visible
    } alphaModeEnum;
 
protected:
    //! @enum DataID
    //! @brief This enum is used in the serialization process to load/save specific material properties
    typedef enum DataID
    {
        MATERIAL_ALPHA_MODE = MAKE_CUSTOM_ID('A', 'P', 'M', 'D'), // UInt
        MATERIAL_FACE_CULLMODE = MAKE_CUSTOM_ID('F', 'C', 'C', 'M'), // UInt
        MAT_VC_CHANNEL_ID = MAKE_CUSTOM_ID('V', 'C', 'I', 'D'),
        MAT_VC_CHANNEL_FLAGS = MAKE_CUSTOM_ID('V', 'C', 'F', 'G'),
    } DataID;
 
    //! @enum KeyframableID
    //! @brief This enum define the animatable material information
    typedef enum KeyframableID XEnumType(longuint)
    {
        KEYFRAME_MAT_SMOOTH_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'S', 'M')), //!< CFloatKey
        KEYFRAME_MAT_DIFFUSE_COLOR = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_COLOR, MAKE_CUSTOM_ID('M', 'T', 'D', 'R')), //!< CColorKey
        KEYFRAME_MAT_DIFFUSE_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'D', 'F')), //!< CFloatKey
        KEYFRAME_MAT_VC_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'V', 'C')), //!< CFloatKey
        KEYFRAME_MAT_ALPHA_CUTOFF_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'C', 'O')), //!< CFloatKey, Alpha cutoff coef
        KEYFRAME_MAT_TRANSPARENCY_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'T', 'Y')), //!< CFloatKey
    } KeyframableID;
 
protected:
    MATERIAL_CLASS materialClass;
    unsigned int materialFlags;
    CXString name;
    CCustomData data; // Not serialized at the moment
 
    // The materials list to which material belong, needed for fast material access, initialized when using C3DMaterials::CreateNewMaterial
    // NULL when material is constructed on the heap.
    CMaterials *materials;
    CHashMap<MapType, MapType, CMaterialMap *> maps;
 
    MaterialID materialID;
    faceModeEnum faceMode;
    ChannelID vertexColorID;
    unsigned int vertexColorFlags;
 
    void DeleteMaps();
 
    virtual unsigned int GetHashValue() const; // Return a value that will help for retrieving quickly a material by its property or name using CMaterials::Find
    void HashInsert();
    void HashRemove();
 
public:
    DECLARE_SERIAL_XOBJECT(C3DMaterial); // Cf. implement note
 
    C3DMaterial(); //!< Use CMaterials::CreateNewMaterial if the material is intended to belong to a material scene list.
    virtual ~C3DMaterial();
 
    static C3DMaterial* Create(MATERIAL_CLASS materialClass); //!< Create a C3DMaterial. Equivalent to xNew(C3DMaterial)
 
    CMaterials* GetMaterials() const { return materials; }; //!< The materials to which the material is attached. NULL if material not already attached to anything
    C3DScene* GetScene() const; //!< The scene to which the materials belonh. NULL if material not already attached to anything
 
    inline MATERIAL_CLASS GetClass() const {
        return materialClass;
    }
 
    MaterialID SetMaterialID(MaterialID refID = MATERIAL_UNDEFINED); //!< Create a new material with the given MaterialID. If material is not attached to a material list, then provided id is always used. If the material is already attached to a material list, provided id might be modified if it is already used by the materials list. Note: if you intend to change a materialID which is already in the material list, you should remove it from the list before.
    MaterialID GetMaterialID() const;
 
    unsigned int GetFlags() { return materialFlags; }
    void SetFlags(unsigned int flags, bool set);
    void SetFlag(MATERIAL_FLAGS flag, bool set);
    bool IsOneFlagSet(unsigned int flags) const;
    bool IsFlagSet(MATERIAL_FLAGS flag) const;
 
    CCustomData& GetCustomData();
    const CCustomData& GetCustomData() const;
 
    void Inherit(const C3DMaterial* refmat); //!< Inherit basic information from refmat (mainly C3DMaterial information such name, materialID, flags, KeyframableID, DataID,...). The material should not be attached to any material list (materialid 
 
    // Virtuals
    virtual void Serialize(CXArchive& ar);
    virtual C3DMaterial& operator=(const C3DMaterial& refmat);
    virtual bool HasSameParameters(const C3DMaterial& refmat) const; //!< Compare only settings
    virtual void ChangeChannelID(CHashMap<CChannelInfo, const CChannelInfo&, CChannelInfo>& channelMap); //!< Remap the materialmap channel ID to the new channelID provided by the map. Used mainly internally when concatenating different mesh for example
    virtual C3DStandardMaterial* ConvertToStandardMaterial(bool replaceCurrentByStandardMaterial) { XASSERT(0);  return NULL; } //!< Must be overidden Return a standard material from the given material. If deleteCurrentAndReplaceByNewOne = false, the returned materials must be attached to CMaterials list, or deleted when no more need. If deleteCurrentAndReplaceByNewOne = true, the current material is destroyed (if not already a standard material) and the new standard is added to materials list to which the material is attached.
 
    CXString GetName(void) const; //!< Get material name
    void SetName(const CXString&); //!< Set material name
 
    void SetAlphaMode(unsigned int time, alphaModeEnum mode, float cutOffCoef = 0.0f);  //!< Set alpha cut and cutoff coef
    float GetAlphaModeCutoffCoef(unsigned int time) const;  //!< Get cutoff coef
    alphaModeEnum GetAlphaMode() const; //!< Get alpha mode
 
    void SetTransparencyFactor(unsigned int time, float value);
    float GetTransparencyFactor(unsigned int time) const;
 
    //! Check if material has some transparency. The material is considered to be opaque, unless something allows us to know that it is transparent.
    //! If checkDiffuseAlpha = true and ALPHA_OPAQUE not set, the diffuse map is loaded and it's alpha channel checked. If checkDiffuseAlpha = false, the map is assumed to be opaque
    virtual bool IsTransparent(unsigned int time, bool checkDiffuseAlpha = false) const;
 
    void SetFaceMode(faceModeEnum mode); //!< Set single / double face material mode
    faceModeEnum GetFaceMode(void) const; //!< Get single / double face material mode
 
    void SetSmoothAngle(unsigned int time, float value); //!< Set normal break angle
    float GetSmoothAngle(unsigned int time) const; //!< Get normal break angle
 
    //! @name Set a color that represent diffuse or base color
    //! @{
    void SetDiffuseColor(unsigned int time, const CRGBColor& color);
    virtual CRGBColor GetDiffuseColor(unsigned int time, bool modulateByDiffuseFactor = false) const; //!< This can be overidden as derived class might have a different computation for this
    void FloatGetDiffuseColor(unsigned int time, float color[4], bool modulateByDiffuseFactor = false) const;
 
    void SetDiffuseFactor(unsigned int time, float value);
    float GetDiffuseFactor(unsigned int time) const;
 
    //! @}
 
    //! @name Set vertex color channel ID and modulation
    //! @{
    void SetVertexColor(unsigned int time, ChannelID channel, float modulationCoef = 1.0f, unsigned int channelFlags = CMaterialMap::MAPCHANNEL_UNSPECIFIED);
    ChannelID GetVertexColor(unsigned int time, float& modulationCoef, unsigned int *channelFlags = NULL) const; // Return the material vertex color information if any, If channelFlags not NULL it is filled with the MapChannelFlags 
    bool RemoveVertexColor(); // Return true if some information exists
 
    //! @}
 
    bool operator==(const C3DMaterial& refmat) const; //!< Compare 2 materials (name and settings)
 
    //! @enum AdjustMaterialFlags
    //! Flags used in AdjustMaterial to modify materials in order to tweak them depending on the export capabilities
    typedef enum AdjustMaterialFlags
    {
        ADJUST_NONE = 0,
        ADJUST_DIFFUSE_IF_NO_MODULATION = 0x01, //!< MATERIAL_DISABLE_DIFFUSE_MODULATION not supported by all I/O. If set, this replace the diffuse by a grey color with the luminance of original diffuse color
    } AdjustMaterialFlags;
 
    bool AdjustMaterial(unsigned int flags); //!< flags is one or more AdjustMaterialFlags. return true if the material changed
 
    //! @name Retrieve the UVW or vertex color channelID
    //! These methods are helper to retrieve the final channelID to use for a given geom object. It checks if there is a global channel, and specific flag that might modify the channel ID used by the material for a specific object
    //! For example the final channel for UV depend of
    //! 1) object global uv channel
    //! 2) for each face, material map of the face
    //! 3) wether the front or back of the face is to be displayed
    //! 4) wether MATERIAL_USE_FRONT_CHANNEL_WHEN_BACK_MISSING is set or not for material (the flag have effect only if the object has only front face specified. It allows to have the same front & back UV)
    //! 5) wether the map use MAPCHANNEL_FIRST_CHANNEL_FOUND
    //! @{
    ChannelID GetUVWChannelID(const CGeomInfo *info, MapType maptype, bool front = true) const; // Return vertex color to use depending on the provided CGeomInfo. It can be the object GetGlobalVCChannel if defined, or the material vertex color channel otherwise
    int GetRequiredUVWChannelID(const CGeomInfo *info, CHashTable<ChannelID>& channels, MapType maptype = MAPTYPE_UNDEFINED, bool clearMap = true) const; // Return the channel ID list required for a given object and a given material
 
    ChannelID GetVCChannelID(const CGeomInfo* info, unsigned int time, float& value) const; // Return vertex color to use depending on the provided CGeomInfo. It can be the object GetGlobalVCChannel if defined, or the material vertex color channel otherwise
    int GetRequiredVCChannelID(const CGeomInfo* info, CHashTable<ChannelID>& channels, MapType maptype = MAPTYPE_UNDEFINED, bool clearMap = true) const; // Return the channel ID list required for a given object and a given material
 
    //! @}
 
    //! @name Managing texture material map associated to the material
    //! @{
    CMaterialMap* AddMaterialMap(MapType type);
    CMaterialMap *AddMaterialMap(const CXString& filename, ChannelID id, MapType type, MapProjection projection, unsigned int channelFlags = CMaterialMap::MAPCHANNEL_NONE);
    HashPos GetFirstMap();
    CMaterialMap * GetNextMap(HashPos& pos, MapType & type);
 
    bool RemoveMaterialMap(MapType type);
    CMaterialMap *GetMaterialMap(MapType type);
    const CMaterialMap *GetMaterialMap(MapType type) const;
 
    //! @}
 
    bool CopyTextures(const CXString& dstfolder, bool overwriteIfExists = false); //!< Copy all material maps to the given path and update pathss
 
    bool IsGenerateUVWNeeded(MapType type = MAPTYPE_UNDEFINED) const; //!< Return true if one of the map has a projection mode that require UVW to be generated, for all the map type (type == MAPTYPE_UNDEFINED) or for the specific MapType (type = MAPTYPE_DIFFUSE for example)
    unsigned int CreateMissingUVWBackChannels(const CGeomInfo* info, MapType type = MAPTYPE_UNDEFINED, CHANNEL_PROPERTIES channelTagFlag = CHANNEL_NONE) const; //!< Copy front UVW channels to back channels if back are missing. If type = MAPTYPE_UNDEFINED, then all maps are checked, otherwise only the provided map.
 
    void AdjustPaths(const CXString& targetPath, bool relativePathAllowed); //!< Make internal filenames used by materials relative to provided path
};
 
//! @class C3DStandardMaterial
//! @brief C3DStandardMaterial is a basic material that defines ambient, specular, bump and other coefficients
class DLL_3DFUNCTION C3DStandardMaterial : public C3DMaterial
{
protected:
    typedef enum DataID XEnumType(longuint)
    {
    } DataID;
 
    //! @enum KeyframableID
    //! @brief This enum define the animatable C3DStandardMaterial information
    typedef enum KeyframableID XEnumType(longuint)
    {
        KEYFRAME_MAT_AMBIENT_COLOR = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_COLOR, MAKE_CUSTOM_ID('M', 'T', 'A', 'R')), //!< CColorKey
        KEYFRAME_MAT_AMBIENT_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'A', 'F')), //!< CFloatKey
        KEYFRAME_MAT_SPECULAR_COLOR = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_COLOR, MAKE_CUSTOM_ID('M', 'T', 'S', 'R')), //!< CColorKey
        KEYFRAME_MAT_SPECULAR_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'S', 'F')), //!< CFloatKey
        KEYFRAME_MAT_BUMP_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'B', 'M')), //!< CFloatKey
        KEYFRAME_MAT_REFLECTION_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'R', 'F')), //!< CFloatKey
        KEYFRAME_MAT_REFRACTION_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'R', 'R')), //!< CFloatKey
    } KeyframableID;
 
    void ReadPreviousVersion(CXArchive& ar, unsigned int version);
 
public:
    DECLARE_SERIAL_XOBJECT(C3DStandardMaterial);
 
    C3DStandardMaterial();
    
    void SetAmbientColor(unsigned int time, const CRGBColor& color);
    CRGBColor GetAmbientColor(unsigned int time, bool modulateByAmbient = false) const;
    void FloatGetAmbientColor(unsigned int time, float color[4]);
    
    CMaterialMap* GetAmbientMaps(); //!< @deprecated use GetMaterialMap(MAPTYPE_AMBIANT)
    CMaterialMap* GetDiffuseMaps(); //!< @deprecated use GetMaterialMap(MAPTYPE_DIFFUSE)
    CMaterialMap* GetNormalMaps(); //!< @deprecated use GetMaterialMap(MAPTYPE_NORMALMAP)
 
    void SetSpecularColor(unsigned int time, const CRGBColor& color);
    CRGBColor GetSpecularColor(unsigned int time) const;
    void FloatGetSpecularColor(unsigned int time, float color[4]) const;
    CMaterialMap* GetSpecularMaps();
 
    void SetBumpFactor(unsigned int time, float value);
    float GetBumpFactor(unsigned int time) const;
    CMaterialMap* GetBumpMaps();
 
    void SetAmbientFactor(unsigned int time, float value);
    float GetAmbientFactor(unsigned int time) const;
 
    void SetSpecularFactor(unsigned int time, float value);
    float GetSpecularFactor(unsigned int time) const;
 
    CMaterialMap* GetTransparencyMaps();
 
    void SetReflectionFactor(unsigned int time, float value); //!< Reflection coef between 0.0 and 1.0f (default 0.0)
    float GetReflectionFactor(unsigned int time) const;
 
    void SetRefractionFactor(unsigned int time, float value); //!< IOR refraction indice >= 1.0 (default 1.0)
    float GetRefractionFactor(unsigned int time) const;
 
    virtual C3DStandardMaterial* ConvertToStandardMaterial(bool replaceCurrentByStandardMaterial) {
        return this; // This is already a standard material
    }
 
    void Serialize(CXArchive& ar);
 
};
 
//! @class C3DPbrMaterial
//! @brief C3DPbrMaterial defines a PBR material which is used by different file formats such GLTF or FBX.
class DLL_3DFUNCTION C3DPbrMaterial : public C3DMaterial
{
public:
    typedef enum PbrInputFormat
    {
        UNDEFINED_INPUT_FORMAT = -1,
        FROM_3DSMAX = 0,
        FROM_MAYA,
    } PbrInputFormat;
 
    //! @enum DataID
    //! @brief This enum is used in the serialization process to load/save specific C3DPbrMaterial properties
    typedef enum DataID
    {
        PBR_INPUT_FORMAT = MAKE_CUSTOM_ID('P', 'B', 'F', 'M'), // PBR input format source: 0 - 3ds Max, 1- Maya, 
        OCCLUSION_STRENGTH = MAKE_CUSTOM_ID('S', 'T', 'R', 'N'),
        EMISSIVE_COLOR = MAKE_CUSTOM_ID('E', 'M', 'C', 'R'),
    } DataID;
 
protected:
    typedef enum KeyframableID XEnumType(longuint)
    {
        KEYFRAME_MAT_EMISSIVE_COLOR = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_COLOR, MAKE_CUSTOM_ID('M', 'T', 'E', 'C')),
        KEYFRAME_MAT_EMISSIVE_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'E', 'F')),
        KEYFRAME_MAT_OCCLUSION_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'O', 'C')),
        KEYFRAME_MAT_METALLIC_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'M', 'E')),
        KEYFRAME_MAT_ROUGHNESS_COEF = KEYFRAMEID(C3DKeyframe::KEYFRAME_TYPE_FLOAT, MAKE_CUSTOM_ID('M', 'T', 'R', 'O')),
    
    } KeyframableID;
 
public:
    DECLARE_SERIAL_XOBJECT(C3DPbrMaterial);
 
    C3DPbrMaterial();
 
    virtual C3DStandardMaterial* ConvertToStandardMaterial(bool replaceCurrentByStandardMaterial); //!< Return a standard material from the given material. If deleteCurrentAndReplaceByNewOne = false, the returned materials must be attached to CMaterials list, or deleted when no more need. If deleteCurrentAndReplaceByNewOne = true, the current material is destroyed (if not already a standard material) and the new standard is added to materials list to which the material is attached.
    virtual void Serialize(CXArchive& ar);
    virtual C3DMaterial& operator=(const C3DMaterial& refmat);
    virtual bool HasSameParameters(const C3DMaterial& refmat) const; //!< Compare only the settings (not the name)
 
    void SetMetallicFactor(unsigned int time, float value);
    float GetMetallicFactor(unsigned int time) const;
    void SetRoughnessFactor(unsigned int time, float value);
    float GetRoughnessFactor(unsigned int time) const;
 
    void SetEmissiveColor(unsigned int time, const CRGBColor& color);
    void SetEmissiveFactor(unsigned int time, float value);
 
    CRGBColor GetEmissiveColor(unsigned int time) const;
    float GetEmissiveFactor(unsigned int time) const;
 
    void SetOcclusionStrengthFactor(unsigned int time, float value);
    float GetOcclusionStrengthFactor(unsigned int time) const;
};
 
class CMaterialNameMap;
//! @class CMaterials
//! @brief CMaterials stores scene materials. CMaterials::CreateNewMaterial allows to create a material and insert it in the list.
//! @note
//! The data is internally stored in a hash table
class DLL_3DFUNCTION CMaterials : public CXObject
{
    friend void C3DMaterial::HashRemove();
    friend void C3DMaterial::HashInsert();
 
public:
    DECLARE_SERIAL_XOBJECT(CMaterials);
 
    CMaterials();
    virtual ~CMaterials();
 
    void SetScene(C3DScene *scene);
    C3DScene* GetScene() const { return scene; }; //!< The scene that own the materials
    CGuidMgr* GetGuidMgr() const { return guidMgr; }; //!< If scene is defined then guidMgr is the scene guidMgr. The material list handles scene materials. Otherwise it can be a private material list, related to something else (renderer...)
 
    virtual void Serialize( CXArchive& ar );
 
    HashPos GetFirst() const { return hashMaterials.GetFirst(); } //!< if matclass = MATERIAL_CLASS_UNDEFINED, return all type of materials, otherwise return materials of the given class
    void GetNext(HashPos& pos, MaterialID& id, C3DMaterial*& mat) const { hashMaterials.GetNext(pos, id, mat); }; //!< if defined matclass should be the same than the one use in GetFirstMaterial
    unsigned int GetMaterials(C3DMaterialArray& mats, bool resetArray = true, MATERIAL_CLASS matclass = MATERIAL_CLASS_UNDEFINED) const;
    unsigned int GetMaterials(C3DMaterialArray& mats, MapType maptype, bool checkIfBitmapExist, bool resetArray = true) const;
    unsigned int GetCount(MATERIAL_CLASS matclass = MATERIAL_CLASS_UNDEFINED) const;
 
    C3DMaterial* CreateNewMaterial(MATERIAL_CLASS materialClass); //!< Create and add a new material of the specified material class
    C3DMaterial *CreateNewMaterial(MaterialID& refid, MATERIAL_CLASS materialClass); //!< Create and add a new material of the specified material class with the provided refid. If refid is alreaday used, a new material id is assigned which is returned in refid
    MaterialID AddNewMaterial(C3DMaterial* mat); //!< Add the new material which has not been assigned to any materials. Return its MaterialId definitive which will be the same as the one defined if possible.
    C3DMaterial *SetDefaultMaterial(C3DStandardMaterial *defaultMat = NULL); //!< Return the default material. defaultMat is optional and can define specific color properties.
    bool RemoveMaterial(MaterialID refID, bool deleteIt = true);
    bool ReplaceMaterial(C3DMaterial *newMat, bool deletePrevious = true); //!< Replace an existing material with newMat->GetMaterialID() by the newMat provided material. If this  MaterialID does not exist, then newMat is simply added to the materials. When deletePrevious = false, the old material is removed from the materials list and it is not deleted. NewMat is supposed to not be attached to any existing materials list
    void CopyMaterials(const CMaterials& refmaterials, unsigned int flags = MATERIAL_COPY_KEEP_ID|MATERIAL_COPY_REMOVE_ALL, const C3DScene *dstScene = NULL, const CMaterialHashMap *hash = NULL);
 
    C3DMaterial *Find(const C3DMaterial& material, bool sameName) const; //!< Find a material that have similar properties and optionally the same name
    C3DMaterial *FindByID(MaterialID refID, bool createIfMissing = false) const; //!< Find the material that have the given MaterialID. Return NULL if none is found. (no material is created, even with DEFAULT_MATERIAL)
    C3DMaterial *FindByName(const CXString& name) const; //!< Find the first material with the given name (beware: there can be several different materials with the same name).
 
    unsigned int IsGenerateUVWNeeded(MaterialID matid = MATERIAL_UNDEFINED, MapType type = MAPTYPE_UNDEFINED) const; //!< If matid == MATERIAL_UNDEFINED, it returns the number of materials that have a projection that requires UVW generation. If matid != MATERIAL_UNDEFINED it returns 1 if the specified material requires UVW generationrequired
    unsigned int CreateMissingUVWBackChannels(const CGeomInfo* info, MaterialID matid = MATERIAL_UNDEFINED, MapType type = MAPTYPE_UNDEFINED, CHANNEL_PROPERTIES channelTagFlag = CHANNEL_NONE) const;
 
    unsigned int FilterByText(const CXString& filter, bool matchCase, C3DMaterialIDArray& matids, bool resetHash); //!< Advanced search: find all materials that match the given text. Return the number of element in matids
 
    void AdjustPaths(const CXString& targetPath, bool relativePathAllowed); //!< Make internal filenames used by materials relative to provided path
 
    void RemoveAll();
 
protected:
    typedef CHashMap<MaterialID, MaterialID, C3DMaterial *> CMaterialIDMap;
    typedef CHashAssocMap<CRGBColor, const CRGBColor&, MaterialID> CMaterialPropertiesMap;
    typedef CHashAssocMap<CXString, const CXString&, MaterialID> CMaterialNameMap;
 
    mutable CXCriticalSection threadLock;
 
    C3DScene *scene;
    CGuidMgr *guidMgr;
    CMaterialIDMap hashMaterials; // The materials themselfs
    CMaterialPropertiesMap hashByProperties; // Use to retrieve quickly a material giving its properties
    CMaterialNameMap hashByNames; // Use to retrieve quickly a material giving its name
 
    void HashInsert(C3DMaterial *material);
    void HashRemove(C3DMaterial *const material);
    void HashFree();
 
#ifdef _DEBUG
    void CheckHash() const;
#endif
};
 
END_MOOTOOLS_NAMESPACE
 
#ifdef MOOTOOLS_MFC_PRODUCT_BUILD
#ifdef MOOTOOLS_NO_BITMAP
#pragma message("Build Warning: MOOTOOLS_NO_BITMAP defined in a product build. CMaterialMap might differ between dll resulting in impredicable behavior\n")
#endif
#endif
 
#endif // !defined(AFX_3DMaterial_H__CA6BC29F_FAC2_11D1_A0DE_000000000000__INCLUDED_)