material.h

Go to the documentation of this file.

/*
---------------------------------------------------------------------------
Open Asset Import Library (assimp)
---------------------------------------------------------------------------

Copyright (c) 2006-2012, assimp team

All rights reserved.

Redistribution and use of this software in source and binary forms, 
with or without modification, are permitted provided that the following 
conditions are met:

* Redistributions of source code must retain the above
  copyright notice, this list of conditions and the
  following disclaimer.

* Redistributions in binary form must reproduce the above
  copyright notice, this list of conditions and the
  following disclaimer in the documentation and/or other
  materials provided with the distribution.

* Neither the name of the assimp team, nor the names of its
  contributors may be used to endorse or promote products
  derived from this software without specific prior
  written permission of the assimp team.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/

#ifndef AI_MATERIAL_H_INC
#define AI_MATERIAL_H_INC

#include "types.h"

#ifdef __cplusplus
extern "C" {
#endif

// Name for default materials (2nd is used if meshes have UV coords)
#define AI_DEFAULT_MATERIAL_NAME          "DefaultMaterial"

// ---------------------------------------------------------------------------
enum aiTextureOp
{
    aiTextureOp_Multiply = 0x0,

    aiTextureOp_Add = 0x1,

    aiTextureOp_Subtract = 0x2,

    aiTextureOp_Divide = 0x3,

    aiTextureOp_SmoothAdd = 0x4,

    aiTextureOp_SignedAdd = 0x5,


#ifndef SWIG
    _aiTextureOp_Force32Bit = INT_MAX
#endif
};

// ---------------------------------------------------------------------------
enum aiTextureMapMode
{
    aiTextureMapMode_Wrap = 0x0,

    aiTextureMapMode_Clamp = 0x1,

    aiTextureMapMode_Decal = 0x3,

    aiTextureMapMode_Mirror = 0x2,

#ifndef SWIG
    _aiTextureMapMode_Force32Bit = INT_MAX
#endif
};

// ---------------------------------------------------------------------------
enum aiTextureMapping
{
    aiTextureMapping_UV = 0x0,

    aiTextureMapping_SPHERE = 0x1,

    aiTextureMapping_CYLINDER = 0x2,

    aiTextureMapping_BOX = 0x3,

    aiTextureMapping_PLANE = 0x4,

    aiTextureMapping_OTHER = 0x5,


#ifndef SWIG
    _aiTextureMapping_Force32Bit = INT_MAX
#endif
};

// ---------------------------------------------------------------------------
enum aiTextureType
{
    aiTextureType_NONE = 0x0,



    aiTextureType_DIFFUSE = 0x1,

    aiTextureType_SPECULAR = 0x2,

    aiTextureType_AMBIENT = 0x3,

    aiTextureType_EMISSIVE = 0x4,

    aiTextureType_HEIGHT = 0x5,

    aiTextureType_NORMALS = 0x6,

    aiTextureType_SHININESS = 0x7,

    aiTextureType_OPACITY = 0x8,

    aiTextureType_DISPLACEMENT = 0x9,

    aiTextureType_LIGHTMAP = 0xA,

    aiTextureType_REFLECTION = 0xB,

    aiTextureType_UNKNOWN = 0xC,


#ifndef SWIG
    _aiTextureType_Force32Bit = INT_MAX
#endif
};

#define AI_TEXTURE_TYPE_MAX  aiTextureType_UNKNOWN

// ---------------------------------------------------------------------------
enum aiShadingMode
{
    aiShadingMode_Flat = 0x1,

    aiShadingMode_Gouraud = 0x2,

    aiShadingMode_Phong = 0x3,

    aiShadingMode_Blinn = 0x4,

    aiShadingMode_Toon = 0x5,

    aiShadingMode_OrenNayar = 0x6,

    aiShadingMode_Minnaert = 0x7,

    aiShadingMode_CookTorrance = 0x8,

    aiShadingMode_NoShading = 0x9,

    aiShadingMode_Fresnel = 0xa,


#ifndef SWIG
    _aiShadingMode_Force32Bit = INT_MAX
#endif
};


// ---------------------------------------------------------------------------
enum aiTextureFlags
{
    aiTextureFlags_Invert = 0x1,

    aiTextureFlags_UseAlpha = 0x2,

    aiTextureFlags_IgnoreAlpha = 0x4,
    
#ifndef SWIG
      _aiTextureFlags_Force32Bit = INT_MAX
#endif
};


// ---------------------------------------------------------------------------
enum aiBlendMode
{
    aiBlendMode_Default = 0x0,

    aiBlendMode_Additive = 0x1,

    // we don't need more for the moment, but we might need them
    // in future versions ...

#ifndef SWIG
    _aiBlendMode_Force32Bit = INT_MAX
#endif
};


#include "./Compiler/pushpack1.h"

// ---------------------------------------------------------------------------
struct aiUVTransform
{
    C_STRUCT aiVector2D mTranslation;

    C_STRUCT aiVector2D mScaling;

    float mRotation;


#ifdef __cplusplus
    aiUVTransform()
        :   mScaling    (1.f,1.f)
        ,   mRotation   (0.f)
    {
        // nothing to be done here ...
    }
#endif

} PACK_STRUCT;

#include "./Compiler/poppack1.h"

// ---------------------------------------------------------------------------
enum aiPropertyTypeInfo
{
    aiPTI_Float   = 0x1,

    aiPTI_String  = 0x3,

    aiPTI_Integer = 0x4,


    aiPTI_Buffer  = 0x5,


#ifndef SWIG
     _aiPTI_Force32Bit = INT_MAX
#endif
};

// ---------------------------------------------------------------------------
struct aiMaterialProperty
{
    C_STRUCT aiString mKey;

    unsigned int mSemantic;

    unsigned int mIndex;

    unsigned int mDataLength;

    C_ENUM aiPropertyTypeInfo mType;

    char* mData;

#ifdef __cplusplus

    aiMaterialProperty()
        : mSemantic( 0 )
        , mIndex( 0 )
        , mDataLength( 0 )
        , mType( aiPTI_Float )
        , mData( NULL )
    {
    }

    ~aiMaterialProperty()   {
        delete[] mData;
    }

#endif
};

#ifdef __cplusplus
} // We need to leave the "C" block here to allow template member functions
#endif

// ---------------------------------------------------------------------------
#ifdef __cplusplus
struct ASSIMP_API aiMaterial
#else
struct aiMaterial
#endif
{

#ifdef __cplusplus

public:

    aiMaterial();
    ~aiMaterial();

    // -------------------------------------------------------------------
    template <typename Type>
    aiReturn Get(const char* pKey,unsigned int type,
        unsigned int idx, Type* pOut, unsigned int* pMax) const;

    aiReturn Get(const char* pKey,unsigned int type,
        unsigned int idx, int* pOut, unsigned int* pMax) const;

    aiReturn Get(const char* pKey,unsigned int type,
        unsigned int idx, float* pOut, unsigned int* pMax) const;

    // -------------------------------------------------------------------
    template <typename Type>
    aiReturn Get(const char* pKey,unsigned int type,
        unsigned int idx,Type& pOut) const;


    aiReturn Get(const char* pKey,unsigned int type,
        unsigned int idx, int& pOut) const;

    aiReturn Get(const char* pKey,unsigned int type,
        unsigned int idx, float& pOut) const;

    aiReturn Get(const char* pKey,unsigned int type,
        unsigned int idx, aiString& pOut) const;

    aiReturn Get(const char* pKey,unsigned int type,
        unsigned int idx, aiColor3D& pOut) const;

    aiReturn Get(const char* pKey,unsigned int type,
        unsigned int idx, aiColor4D& pOut) const;

    aiReturn Get(const char* pKey,unsigned int type,
        unsigned int idx, aiUVTransform& pOut) const;

    // -------------------------------------------------------------------
    unsigned int GetTextureCount(aiTextureType type) const;

    // -------------------------------------------------------------------
    // -------------------------------------------------------------------
    aiReturn GetTexture(aiTextureType type,
        unsigned int  index,
        C_STRUCT aiString* path,
        aiTextureMapping* mapping   = NULL,
        unsigned int* uvindex       = NULL,
        float* blend                   = NULL,
        aiTextureOp* op             = NULL,
        aiTextureMapMode* mapmode   = NULL) const; 


    // Setters


    // ------------------------------------------------------------------------------
    aiReturn AddBinaryProperty (const void* pInput,
        unsigned int pSizeInBytes,
        const char* pKey,
        unsigned int type ,
        unsigned int index ,
        aiPropertyTypeInfo pType);

    // ------------------------------------------------------------------------------
    aiReturn AddProperty (const aiString* pInput,
        const char* pKey,
        unsigned int type  = 0,
        unsigned int index = 0);

    // ------------------------------------------------------------------------------
    template<class TYPE>
    aiReturn AddProperty (const TYPE* pInput,
        unsigned int pNumValues,
        const char* pKey,
        unsigned int type  = 0,
        unsigned int index = 0);

    aiReturn AddProperty (const aiVector3D* pInput,
        unsigned int pNumValues,
        const char* pKey,
        unsigned int type  = 0,
        unsigned int index = 0);

    aiReturn AddProperty (const aiColor3D* pInput,
        unsigned int pNumValues,
        const char* pKey,
        unsigned int type  = 0,
        unsigned int index = 0);

    aiReturn AddProperty (const aiColor4D* pInput,
        unsigned int pNumValues,
        const char* pKey,
        unsigned int type  = 0,
        unsigned int index = 0);

    aiReturn AddProperty (const int* pInput,
        unsigned int pNumValues,
        const char* pKey,
        unsigned int type  = 0,
        unsigned int index = 0);

    aiReturn AddProperty (const float* pInput,
        unsigned int pNumValues,
        const char* pKey,
        unsigned int type  = 0,
        unsigned int index = 0);

    aiReturn AddProperty (const aiUVTransform* pInput,
        unsigned int pNumValues,
        const char* pKey,
        unsigned int type  = 0,
        unsigned int index = 0);

    // ------------------------------------------------------------------------------
    aiReturn RemoveProperty (const char* pKey,
        unsigned int type  = 0,
        unsigned int index = 0);

    // ------------------------------------------------------------------------------
    void Clear();

    // ------------------------------------------------------------------------------
    static void CopyPropertyList(aiMaterial* pcDest, 
        const aiMaterial* pcSrc);


#endif

    C_STRUCT aiMaterialProperty** mProperties;

    unsigned int mNumProperties;

    unsigned int mNumAllocated;
};

// Go back to extern "C" again
#ifdef __cplusplus
extern "C" {
#endif

// ---------------------------------------------------------------------------
#define AI_MATKEY_NAME "?mat.name",0,0
#define AI_MATKEY_TWOSIDED "$mat.twosided",0,0
#define AI_MATKEY_SHADING_MODEL "$mat.shadingm",0,0
#define AI_MATKEY_ENABLE_WIREFRAME "$mat.wireframe",0,0
#define AI_MATKEY_BLEND_FUNC "$mat.blend",0,0
#define AI_MATKEY_OPACITY "$mat.opacity",0,0
#define AI_MATKEY_BUMPSCALING "$mat.bumpscaling",0,0
#define AI_MATKEY_SHININESS "$mat.shininess",0,0
#define AI_MATKEY_REFLECTIVITY "$mat.reflectivity",0,0
#define AI_MATKEY_SHININESS_STRENGTH "$mat.shinpercent",0,0
#define AI_MATKEY_REFRACTI "$mat.refracti",0,0
#define AI_MATKEY_COLOR_DIFFUSE "$clr.diffuse",0,0
#define AI_MATKEY_COLOR_AMBIENT "$clr.ambient",0,0
#define AI_MATKEY_COLOR_SPECULAR "$clr.specular",0,0
#define AI_MATKEY_COLOR_EMISSIVE "$clr.emissive",0,0
#define AI_MATKEY_COLOR_TRANSPARENT "$clr.transparent",0,0
#define AI_MATKEY_COLOR_REFLECTIVE "$clr.reflective",0,0
#define AI_MATKEY_GLOBAL_BACKGROUND_IMAGE "?bg.global",0,0

// ---------------------------------------------------------------------------
// Pure key names for all texture-related properties
#define _AI_MATKEY_TEXTURE_BASE         "$tex.file"
#define _AI_MATKEY_UVWSRC_BASE          "$tex.uvwsrc"
#define _AI_MATKEY_TEXOP_BASE           "$tex.op"
#define _AI_MATKEY_MAPPING_BASE         "$tex.mapping"
#define _AI_MATKEY_TEXBLEND_BASE        "$tex.blend"
#define _AI_MATKEY_MAPPINGMODE_U_BASE   "$tex.mapmodeu"
#define _AI_MATKEY_MAPPINGMODE_V_BASE   "$tex.mapmodev"
#define _AI_MATKEY_TEXMAP_AXIS_BASE     "$tex.mapaxis"
#define _AI_MATKEY_UVTRANSFORM_BASE     "$tex.uvtrafo"
#define _AI_MATKEY_TEXFLAGS_BASE        "$tex.flags"

// ---------------------------------------------------------------------------
#define AI_MATKEY_TEXTURE(type, N) _AI_MATKEY_TEXTURE_BASE,type,N

// For backward compatibility and simplicity
#define AI_MATKEY_TEXTURE_DIFFUSE(N)    \
    AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE,N)

#define AI_MATKEY_TEXTURE_SPECULAR(N)   \
    AI_MATKEY_TEXTURE(aiTextureType_SPECULAR,N)

#define AI_MATKEY_TEXTURE_AMBIENT(N)    \
    AI_MATKEY_TEXTURE(aiTextureType_AMBIENT,N)

#define AI_MATKEY_TEXTURE_EMISSIVE(N)   \
    AI_MATKEY_TEXTURE(aiTextureType_EMISSIVE,N)

#define AI_MATKEY_TEXTURE_NORMALS(N)    \
    AI_MATKEY_TEXTURE(aiTextureType_NORMALS,N)

#define AI_MATKEY_TEXTURE_HEIGHT(N) \
    AI_MATKEY_TEXTURE(aiTextureType_HEIGHT,N)

#define AI_MATKEY_TEXTURE_SHININESS(N)  \
    AI_MATKEY_TEXTURE(aiTextureType_SHININESS,N)

#define AI_MATKEY_TEXTURE_OPACITY(N)    \
    AI_MATKEY_TEXTURE(aiTextureType_OPACITY,N)

#define AI_MATKEY_TEXTURE_DISPLACEMENT(N)   \
    AI_MATKEY_TEXTURE(aiTextureType_DISPLACEMENT,N)

#define AI_MATKEY_TEXTURE_LIGHTMAP(N)   \
    AI_MATKEY_TEXTURE(aiTextureType_LIGHTMAP,N)

#define AI_MATKEY_TEXTURE_REFLECTION(N) \
    AI_MATKEY_TEXTURE(aiTextureType_REFLECTION,N)


// ---------------------------------------------------------------------------
#define AI_MATKEY_UVWSRC(type, N) _AI_MATKEY_UVWSRC_BASE,type,N

// For backward compatibility and simplicity
#define AI_MATKEY_UVWSRC_DIFFUSE(N) \
    AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE,N)

#define AI_MATKEY_UVWSRC_SPECULAR(N)    \
    AI_MATKEY_UVWSRC(aiTextureType_SPECULAR,N)

#define AI_MATKEY_UVWSRC_AMBIENT(N) \
    AI_MATKEY_UVWSRC(aiTextureType_AMBIENT,N)

#define AI_MATKEY_UVWSRC_EMISSIVE(N)    \
    AI_MATKEY_UVWSRC(aiTextureType_EMISSIVE,N)

#define AI_MATKEY_UVWSRC_NORMALS(N) \
    AI_MATKEY_UVWSRC(aiTextureType_NORMALS,N)

#define AI_MATKEY_UVWSRC_HEIGHT(N)  \
    AI_MATKEY_UVWSRC(aiTextureType_HEIGHT,N)

#define AI_MATKEY_UVWSRC_SHININESS(N)   \
    AI_MATKEY_UVWSRC(aiTextureType_SHININESS,N)

#define AI_MATKEY_UVWSRC_OPACITY(N) \
    AI_MATKEY_UVWSRC(aiTextureType_OPACITY,N)

#define AI_MATKEY_UVWSRC_DISPLACEMENT(N)    \
    AI_MATKEY_UVWSRC(aiTextureType_DISPLACEMENT,N)

#define AI_MATKEY_UVWSRC_LIGHTMAP(N)    \
    AI_MATKEY_UVWSRC(aiTextureType_LIGHTMAP,N)

#define AI_MATKEY_UVWSRC_REFLECTION(N)  \
    AI_MATKEY_UVWSRC(aiTextureType_REFLECTION,N)

// ---------------------------------------------------------------------------
#define AI_MATKEY_TEXOP(type, N) _AI_MATKEY_TEXOP_BASE,type,N

// For backward compatibility and simplicity
#define AI_MATKEY_TEXOP_DIFFUSE(N)  \
    AI_MATKEY_TEXOP(aiTextureType_DIFFUSE,N)

#define AI_MATKEY_TEXOP_SPECULAR(N) \
    AI_MATKEY_TEXOP(aiTextureType_SPECULAR,N)

#define AI_MATKEY_TEXOP_AMBIENT(N)  \
    AI_MATKEY_TEXOP(aiTextureType_AMBIENT,N)

#define AI_MATKEY_TEXOP_EMISSIVE(N) \
    AI_MATKEY_TEXOP(aiTextureType_EMISSIVE,N)

#define AI_MATKEY_TEXOP_NORMALS(N)  \
    AI_MATKEY_TEXOP(aiTextureType_NORMALS,N)

#define AI_MATKEY_TEXOP_HEIGHT(N)   \
    AI_MATKEY_TEXOP(aiTextureType_HEIGHT,N)

#define AI_MATKEY_TEXOP_SHININESS(N)    \
    AI_MATKEY_TEXOP(aiTextureType_SHININESS,N)

#define AI_MATKEY_TEXOP_OPACITY(N)  \
    AI_MATKEY_TEXOP(aiTextureType_OPACITY,N)

#define AI_MATKEY_TEXOP_DISPLACEMENT(N) \
    AI_MATKEY_TEXOP(aiTextureType_DISPLACEMENT,N)

#define AI_MATKEY_TEXOP_LIGHTMAP(N) \
    AI_MATKEY_TEXOP(aiTextureType_LIGHTMAP,N)

#define AI_MATKEY_TEXOP_REFLECTION(N)   \
    AI_MATKEY_TEXOP(aiTextureType_REFLECTION,N)

// ---------------------------------------------------------------------------
#define AI_MATKEY_MAPPING(type, N) _AI_MATKEY_MAPPING_BASE,type,N

// For backward compatibility and simplicity
#define AI_MATKEY_MAPPING_DIFFUSE(N)    \
    AI_MATKEY_MAPPING(aiTextureType_DIFFUSE,N)

#define AI_MATKEY_MAPPING_SPECULAR(N)   \
    AI_MATKEY_MAPPING(aiTextureType_SPECULAR,N)

#define AI_MATKEY_MAPPING_AMBIENT(N)    \
    AI_MATKEY_MAPPING(aiTextureType_AMBIENT,N)

#define AI_MATKEY_MAPPING_EMISSIVE(N)   \
    AI_MATKEY_MAPPING(aiTextureType_EMISSIVE,N)

#define AI_MATKEY_MAPPING_NORMALS(N)    \
    AI_MATKEY_MAPPING(aiTextureType_NORMALS,N)

#define AI_MATKEY_MAPPING_HEIGHT(N) \
    AI_MATKEY_MAPPING(aiTextureType_HEIGHT,N)

#define AI_MATKEY_MAPPING_SHININESS(N)  \
    AI_MATKEY_MAPPING(aiTextureType_SHININESS,N)

#define AI_MATKEY_MAPPING_OPACITY(N)    \
    AI_MATKEY_MAPPING(aiTextureType_OPACITY,N)

#define AI_MATKEY_MAPPING_DISPLACEMENT(N)   \
    AI_MATKEY_MAPPING(aiTextureType_DISPLACEMENT,N)

#define AI_MATKEY_MAPPING_LIGHTMAP(N)   \
    AI_MATKEY_MAPPING(aiTextureType_LIGHTMAP,N)

#define AI_MATKEY_MAPPING_REFLECTION(N) \
    AI_MATKEY_MAPPING(aiTextureType_REFLECTION,N)

// ---------------------------------------------------------------------------
#define AI_MATKEY_TEXBLEND(type, N) _AI_MATKEY_TEXBLEND_BASE,type,N

// For backward compatibility and simplicity
#define AI_MATKEY_TEXBLEND_DIFFUSE(N)   \
    AI_MATKEY_TEXBLEND(aiTextureType_DIFFUSE,N)

#define AI_MATKEY_TEXBLEND_SPECULAR(N)  \
    AI_MATKEY_TEXBLEND(aiTextureType_SPECULAR,N)

#define AI_MATKEY_TEXBLEND_AMBIENT(N)   \
    AI_MATKEY_TEXBLEND(aiTextureType_AMBIENT,N)

#define AI_MATKEY_TEXBLEND_EMISSIVE(N)  \
    AI_MATKEY_TEXBLEND(aiTextureType_EMISSIVE,N)

#define AI_MATKEY_TEXBLEND_NORMALS(N)   \
    AI_MATKEY_TEXBLEND(aiTextureType_NORMALS,N)

#define AI_MATKEY_TEXBLEND_HEIGHT(N)    \
    AI_MATKEY_TEXBLEND(aiTextureType_HEIGHT,N)

#define AI_MATKEY_TEXBLEND_SHININESS(N) \
    AI_MATKEY_TEXBLEND(aiTextureType_SHININESS,N)

#define AI_MATKEY_TEXBLEND_OPACITY(N)   \
    AI_MATKEY_TEXBLEND(aiTextureType_OPACITY,N)

#define AI_MATKEY_TEXBLEND_DISPLACEMENT(N)  \
    AI_MATKEY_TEXBLEND(aiTextureType_DISPLACEMENT,N)

#define AI_MATKEY_TEXBLEND_LIGHTMAP(N)  \
    AI_MATKEY_TEXBLEND(aiTextureType_LIGHTMAP,N)

#define AI_MATKEY_TEXBLEND_REFLECTION(N)    \
    AI_MATKEY_TEXBLEND(aiTextureType_REFLECTION,N)

// ---------------------------------------------------------------------------
#define AI_MATKEY_MAPPINGMODE_U(type, N) _AI_MATKEY_MAPPINGMODE_U_BASE,type,N

// For backward compatibility and simplicity
#define AI_MATKEY_MAPPINGMODE_U_DIFFUSE(N)  \
    AI_MATKEY_MAPPINGMODE_U(aiTextureType_DIFFUSE,N)

#define AI_MATKEY_MAPPINGMODE_U_SPECULAR(N) \
    AI_MATKEY_MAPPINGMODE_U(aiTextureType_SPECULAR,N)

#define AI_MATKEY_MAPPINGMODE_U_AMBIENT(N)  \
    AI_MATKEY_MAPPINGMODE_U(aiTextureType_AMBIENT,N)

#define AI_MATKEY_MAPPINGMODE_U_EMISSIVE(N) \
    AI_MATKEY_MAPPINGMODE_U(aiTextureType_EMISSIVE,N)

#define AI_MATKEY_MAPPINGMODE_U_NORMALS(N)  \
    AI_MATKEY_MAPPINGMODE_U(aiTextureType_NORMALS,N)

#define AI_MATKEY_MAPPINGMODE_U_HEIGHT(N)   \
    AI_MATKEY_MAPPINGMODE_U(aiTextureType_HEIGHT,N)

#define AI_MATKEY_MAPPINGMODE_U_SHININESS(N)    \
    AI_MATKEY_MAPPINGMODE_U(aiTextureType_SHININESS,N)

#define AI_MATKEY_MAPPINGMODE_U_OPACITY(N)  \
    AI_MATKEY_MAPPINGMODE_U(aiTextureType_OPACITY,N)

#define AI_MATKEY_MAPPINGMODE_U_DISPLACEMENT(N) \
    AI_MATKEY_MAPPINGMODE_U(aiTextureType_DISPLACEMENT,N)

#define AI_MATKEY_MAPPINGMODE_U_LIGHTMAP(N) \
    AI_MATKEY_MAPPINGMODE_U(aiTextureType_LIGHTMAP,N)

#define AI_MATKEY_MAPPINGMODE_U_REFLECTION(N)   \
    AI_MATKEY_MAPPINGMODE_U(aiTextureType_REFLECTION,N)

// ---------------------------------------------------------------------------
#define AI_MATKEY_MAPPINGMODE_V(type, N) _AI_MATKEY_MAPPINGMODE_V_BASE,type,N

// For backward compatibility and simplicity
#define AI_MATKEY_MAPPINGMODE_V_DIFFUSE(N)  \
    AI_MATKEY_MAPPINGMODE_V(aiTextureType_DIFFUSE,N)

#define AI_MATKEY_MAPPINGMODE_V_SPECULAR(N) \
    AI_MATKEY_MAPPINGMODE_V(aiTextureType_SPECULAR,N)

#define AI_MATKEY_MAPPINGMODE_V_AMBIENT(N)  \
    AI_MATKEY_MAPPINGMODE_V(aiTextureType_AMBIENT,N)

#define AI_MATKEY_MAPPINGMODE_V_EMISSIVE(N) \
    AI_MATKEY_MAPPINGMODE_V(aiTextureType_EMISSIVE,N)

#define AI_MATKEY_MAPPINGMODE_V_NORMALS(N)  \
    AI_MATKEY_MAPPINGMODE_V(aiTextureType_NORMALS,N)

#define AI_MATKEY_MAPPINGMODE_V_HEIGHT(N)   \
    AI_MATKEY_MAPPINGMODE_V(aiTextureType_HEIGHT,N)

#define AI_MATKEY_MAPPINGMODE_V_SHININESS(N)    \
    AI_MATKEY_MAPPINGMODE_V(aiTextureType_SHININESS,N)

#define AI_MATKEY_MAPPINGMODE_V_OPACITY(N)  \
    AI_MATKEY_MAPPINGMODE_V(aiTextureType_OPACITY,N)

#define AI_MATKEY_MAPPINGMODE_V_DISPLACEMENT(N) \
    AI_MATKEY_MAPPINGMODE_V(aiTextureType_DISPLACEMENT,N)

#define AI_MATKEY_MAPPINGMODE_V_LIGHTMAP(N) \
    AI_MATKEY_MAPPINGMODE_V(aiTextureType_LIGHTMAP,N)

#define AI_MATKEY_MAPPINGMODE_V_REFLECTION(N)   \
    AI_MATKEY_MAPPINGMODE_V(aiTextureType_REFLECTION,N)

// ---------------------------------------------------------------------------
#define AI_MATKEY_TEXMAP_AXIS(type, N) _AI_MATKEY_TEXMAP_AXIS_BASE,type,N

// For backward compatibility and simplicity
#define AI_MATKEY_TEXMAP_AXIS_DIFFUSE(N)    \
    AI_MATKEY_TEXMAP_AXIS(aiTextureType_DIFFUSE,N)

#define AI_MATKEY_TEXMAP_AXIS_SPECULAR(N)   \
    AI_MATKEY_TEXMAP_AXIS(aiTextureType_SPECULAR,N)

#define AI_MATKEY_TEXMAP_AXIS_AMBIENT(N)    \
    AI_MATKEY_TEXMAP_AXIS(aiTextureType_AMBIENT,N)

#define AI_MATKEY_TEXMAP_AXIS_EMISSIVE(N)   \
    AI_MATKEY_TEXMAP_AXIS(aiTextureType_EMISSIVE,N)

#define AI_MATKEY_TEXMAP_AXIS_NORMALS(N)    \
    AI_MATKEY_TEXMAP_AXIS(aiTextureType_NORMALS,N)

#define AI_MATKEY_TEXMAP_AXIS_HEIGHT(N) \
    AI_MATKEY_TEXMAP_AXIS(aiTextureType_HEIGHT,N)

#define AI_MATKEY_TEXMAP_AXIS_SHININESS(N)  \
    AI_MATKEY_TEXMAP_AXIS(aiTextureType_SHININESS,N)

#define AI_MATKEY_TEXMAP_AXIS_OPACITY(N)    \
    AI_MATKEY_TEXMAP_AXIS(aiTextureType_OPACITY,N)

#define AI_MATKEY_TEXMAP_AXIS_DISPLACEMENT(N)   \
    AI_MATKEY_TEXMAP_AXIS(aiTextureType_DISPLACEMENT,N)

#define AI_MATKEY_TEXMAP_AXIS_LIGHTMAP(N)   \
    AI_MATKEY_TEXMAP_AXIS(aiTextureType_LIGHTMAP,N)

#define AI_MATKEY_TEXMAP_AXIS_REFLECTION(N) \
    AI_MATKEY_TEXMAP_AXIS(aiTextureType_REFLECTION,N)

// ---------------------------------------------------------------------------
#define AI_MATKEY_UVTRANSFORM(type, N) _AI_MATKEY_UVTRANSFORM_BASE,type,N

// For backward compatibility and simplicity
#define AI_MATKEY_UVTRANSFORM_DIFFUSE(N)    \
    AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE,N)

#define AI_MATKEY_UVTRANSFORM_SPECULAR(N)   \
    AI_MATKEY_UVTRANSFORM(aiTextureType_SPECULAR,N)

#define AI_MATKEY_UVTRANSFORM_AMBIENT(N)    \
    AI_MATKEY_UVTRANSFORM(aiTextureType_AMBIENT,N)

#define AI_MATKEY_UVTRANSFORM_EMISSIVE(N)   \
    AI_MATKEY_UVTRANSFORM(aiTextureType_EMISSIVE,N)

#define AI_MATKEY_UVTRANSFORM_NORMALS(N)    \
    AI_MATKEY_UVTRANSFORM(aiTextureType_NORMALS,N)

#define AI_MATKEY_UVTRANSFORM_HEIGHT(N) \
    AI_MATKEY_UVTRANSFORM(aiTextureType_HEIGHT,N)

#define AI_MATKEY_UVTRANSFORM_SHININESS(N)  \
    AI_MATKEY_UVTRANSFORM(aiTextureType_SHININESS,N)

#define AI_MATKEY_UVTRANSFORM_OPACITY(N)    \
    AI_MATKEY_UVTRANSFORM(aiTextureType_OPACITY,N)

#define AI_MATKEY_UVTRANSFORM_DISPLACEMENT(N)   \
    AI_MATKEY_UVTRANSFORM(aiTextureType_DISPLACEMENT,N)

#define AI_MATKEY_UVTRANSFORM_LIGHTMAP(N)   \
    AI_MATKEY_UVTRANSFORM(aiTextureType_LIGHTMAP,N)

#define AI_MATKEY_UVTRANSFORM_REFLECTION(N) \
    AI_MATKEY_UVTRANSFORM(aiTextureType_REFLECTION,N)

#define AI_MATKEY_UVTRANSFORM_UNKNOWN(N)    \
    AI_MATKEY_UVTRANSFORM(aiTextureType_UNKNOWN,N)

// ---------------------------------------------------------------------------
#define AI_MATKEY_TEXFLAGS(type, N) _AI_MATKEY_TEXFLAGS_BASE,type,N

// For backward compatibility and simplicity
#define AI_MATKEY_TEXFLAGS_DIFFUSE(N)   \
    AI_MATKEY_TEXFLAGS(aiTextureType_DIFFUSE,N)

#define AI_MATKEY_TEXFLAGS_SPECULAR(N)  \
    AI_MATKEY_TEXFLAGS(aiTextureType_SPECULAR,N)

#define AI_MATKEY_TEXFLAGS_AMBIENT(N)   \
    AI_MATKEY_TEXFLAGS(aiTextureType_AMBIENT,N)

#define AI_MATKEY_TEXFLAGS_EMISSIVE(N)  \
    AI_MATKEY_TEXFLAGS(aiTextureType_EMISSIVE,N)

#define AI_MATKEY_TEXFLAGS_NORMALS(N)   \
    AI_MATKEY_TEXFLAGS(aiTextureType_NORMALS,N)

#define AI_MATKEY_TEXFLAGS_HEIGHT(N)    \
    AI_MATKEY_TEXFLAGS(aiTextureType_HEIGHT,N)

#define AI_MATKEY_TEXFLAGS_SHININESS(N) \
    AI_MATKEY_TEXFLAGS(aiTextureType_SHININESS,N)

#define AI_MATKEY_TEXFLAGS_OPACITY(N)   \
    AI_MATKEY_TEXFLAGS(aiTextureType_OPACITY,N)

#define AI_MATKEY_TEXFLAGS_DISPLACEMENT(N)  \
    AI_MATKEY_TEXFLAGS(aiTextureType_DISPLACEMENT,N)

#define AI_MATKEY_TEXFLAGS_LIGHTMAP(N)  \
    AI_MATKEY_TEXFLAGS(aiTextureType_LIGHTMAP,N)

#define AI_MATKEY_TEXFLAGS_REFLECTION(N)    \
    AI_MATKEY_TEXFLAGS(aiTextureType_REFLECTION,N)

#define AI_MATKEY_TEXFLAGS_UNKNOWN(N)   \
    AI_MATKEY_TEXFLAGS(aiTextureType_UNKNOWN,N)

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
ASSIMP_API C_ENUM aiReturn aiGetMaterialProperty(
     const C_STRUCT aiMaterial* pMat, 
    const char* pKey,
     unsigned int type,
    unsigned int  index,
    const C_STRUCT aiMaterialProperty** pPropOut);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
ASSIMP_API C_ENUM aiReturn aiGetMaterialFloatArray(
     const C_STRUCT aiMaterial* pMat, 
    const char* pKey,
     unsigned int type,
    unsigned int index,
    float* pOut,
    unsigned int* pMax);


#ifdef __cplusplus

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
inline aiReturn aiGetMaterialFloat(const aiMaterial* pMat, 
    const char* pKey,
    unsigned int type,
   unsigned int index,
    float* pOut)
{
    return aiGetMaterialFloatArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0);
}

#else 

// Use our friend, the C preprocessor
#define aiGetMaterialFloat (pMat, type, index, pKey, pOut) \
    aiGetMaterialFloatArray(pMat, type, index, pKey, pOut, NULL)

#endif 


// ---------------------------------------------------------------------------
ASSIMP_API C_ENUM aiReturn aiGetMaterialIntegerArray(const C_STRUCT aiMaterial* pMat, 
    const char* pKey,
     unsigned int  type,
     unsigned int  index,
    int* pOut,
    unsigned int* pMax);


#ifdef __cplusplus

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
inline aiReturn aiGetMaterialInteger(const C_STRUCT aiMaterial* pMat, 
    const char* pKey,
    unsigned int type,
   unsigned int index,
    int* pOut)
{
    return aiGetMaterialIntegerArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0);
}

#else 

// use our friend, the C preprocessor
#define aiGetMaterialInteger (pMat, type, index, pKey, pOut) \
    aiGetMaterialIntegerArray(pMat, type, index, pKey, pOut, NULL)

#endif 



// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
ASSIMP_API C_ENUM aiReturn aiGetMaterialColor(const C_STRUCT aiMaterial* pMat, 
    const char* pKey,
     unsigned int type,
    unsigned int index,
     C_STRUCT aiColor4D* pOut);


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
ASSIMP_API C_ENUM aiReturn aiGetMaterialUVTransform(const C_STRUCT aiMaterial* pMat, 
    const char* pKey,
     unsigned int type,
    unsigned int index,
     C_STRUCT aiUVTransform* pOut);


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
ASSIMP_API C_ENUM aiReturn aiGetMaterialString(const C_STRUCT aiMaterial* pMat, 
    const char* pKey,
     unsigned int type,
    unsigned int index,
    C_STRUCT aiString* pOut);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
ASSIMP_API unsigned int aiGetMaterialTextureCount(const C_STRUCT aiMaterial* pMat,  
    C_ENUM aiTextureType type);

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
#ifdef __cplusplus
ASSIMP_API aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
    aiTextureType type,
    unsigned int  index,
    aiString* path,
    aiTextureMapping* mapping   = NULL,
    unsigned int* uvindex       = NULL,
    float* blend                = NULL,
    aiTextureOp* op             = NULL,
    aiTextureMapMode* mapmode   = NULL,
    unsigned int* flags         = NULL); 
#else
C_ENUM aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
    C_ENUM aiTextureType type,
    unsigned int  index,
    C_STRUCT aiString* path,
    C_ENUM aiTextureMapping* mapping    /*= NULL*/,
    unsigned int* uvindex               /*= NULL*/,
    float* blend                        /*= NULL*/,
    C_ENUM aiTextureOp* op              /*= NULL*/,
    C_ENUM aiTextureMapMode* mapmode    /*= NULL*/,
    unsigned int* flags                 /*= NULL*/); 
#endif // !#ifdef __cplusplus

#ifdef __cplusplus
}

#include "material.inl"

#endif 
#endif