558 lines
19 KiB
C
558 lines
19 KiB
C
/*
|
|
---------------------------------------------------------------------------
|
|
Free Asset Import Library (ASSIMP)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2008, ASSIMP Development 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 Development 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.
|
|
---------------------------------------------------------------------------
|
|
*/
|
|
|
|
/** @file Defines the material system of the library
|
|
*
|
|
*/
|
|
|
|
#ifndef AI_MATERIAL_H_INC
|
|
#define AI_MATERIAL_H_INC
|
|
|
|
#include "aiTypes.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Defines type identifiers for use within the material system.
|
|
*
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
enum aiPropertyTypeInfo
|
|
{
|
|
/** Array of single-precision floats
|
|
*/
|
|
aiPTI_Float = 0x1,
|
|
|
|
/** aiString data structure
|
|
*/
|
|
aiPTI_String = 0x3,
|
|
|
|
/** Array of Integers
|
|
*/
|
|
aiPTI_Integer = 0x4,
|
|
|
|
/** Simple binary buffer
|
|
*/
|
|
aiPTI_Buffer = 0x5,
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Defines texture operations like add, mul ...
|
|
*
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
enum aiTextureOp
|
|
{
|
|
/** T = T1 * T2
|
|
*/
|
|
aiTextureOp_Multiply = 0x0,
|
|
|
|
/** T = T1 + T2
|
|
*/
|
|
aiTextureOp_Add = 0x1,
|
|
|
|
/** T = T1 - T2
|
|
*/
|
|
aiTextureOp_Subtract = 0x2,
|
|
|
|
/** T = T1 / T2
|
|
*/
|
|
aiTextureOp_Divide = 0x3,
|
|
|
|
/** T = (T1 + T2) - (T1 * T2)
|
|
*/
|
|
aiTextureOp_SmoothAdd = 0x4,
|
|
|
|
/** T = T1 + (T2-0.5)
|
|
*/
|
|
aiTextureOp_SignedAdd = 0x5
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Defines all shading models supported by the library
|
|
*
|
|
* @note The list of shading modes has been taken from Blender3D.
|
|
* See Blender3D documentation for more information. The API does
|
|
* not distinguish between "specular" and "diffuse" shaders (thus the
|
|
* specular term for diffuse shading models like Oren-Nayar remains
|
|
* undefined)
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
enum aiShadingMode
|
|
{
|
|
/** Flat shading. Shading is done on per-face base,
|
|
* diffuse only.
|
|
*/
|
|
aiShadingMode_Flat = 0x1,
|
|
|
|
/** Diffuse gouraud shading. Shading on per-vertex base
|
|
*/
|
|
aiShadingMode_Gouraud = 0x2,
|
|
|
|
/** Diffuse/Specular Phong-Shading
|
|
*
|
|
* Shading is applied on per-pixel base. This is the
|
|
* slowest algorithm, but generates the best results.
|
|
*/
|
|
aiShadingMode_Phong = 0x3,
|
|
|
|
/** Diffuse/Specular Phong-Blinn-Shading
|
|
*
|
|
* Shading is applied on per-pixel base. This is a little
|
|
* bit faster than phong and in some cases even
|
|
* more realistic
|
|
*/
|
|
aiShadingMode_Blinn = 0x4,
|
|
|
|
/** Toon-Shading per pixel
|
|
*
|
|
* Shading is applied on per-pixel base. The output looks
|
|
* like a comic. Often combined with edge detection.
|
|
*/
|
|
aiShadingMode_Toon = 0x5,
|
|
|
|
/** OrenNayar-Shading per pixel
|
|
*
|
|
* Extension to standard lambertian shading, taking the
|
|
* roughness of the material into account
|
|
*
|
|
*/
|
|
aiShadingMode_OrenNayar = 0x6,
|
|
|
|
/** Minnaert-Shading per pixel
|
|
*
|
|
* Extension to standard lambertian shading, taking the
|
|
* "darkness" of the material into account
|
|
*/
|
|
aiShadingMode_Minnaert = 0x7,
|
|
|
|
/** CookTorrance-Shading per pixel
|
|
*/
|
|
aiShadingMode_CookTorrance = 0x8,
|
|
|
|
/** No shading at all
|
|
*/
|
|
aiShadingMode_NoShading = 0x8
|
|
};
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Data structure for a single property inside a material
|
|
*
|
|
* @see aiMaterial
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
struct aiMaterialProperty
|
|
{
|
|
/** Specifies the name of the property (key)
|
|
*
|
|
* Keys are case insensitive.
|
|
*/
|
|
C_STRUCT aiString* mKey;
|
|
|
|
/** Size of the buffer mData is pointing to, in bytes
|
|
*/
|
|
unsigned int mDataLength;
|
|
|
|
/** Type information for the property.
|
|
*
|
|
* Defines the data layout inside the
|
|
* data buffer. This is used by the library
|
|
* internally to perform debug checks.
|
|
*/
|
|
aiPropertyTypeInfo mType;
|
|
|
|
/** Binary buffer to hold the property's value
|
|
*
|
|
* The buffer has no terminal character. However,
|
|
* if a string is stored inside it may use 0 as terminal,
|
|
* but it would be contained in mDataLength.
|
|
*/
|
|
char* mData;
|
|
};
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Data structure for a material
|
|
*
|
|
* Material data is stored using a key-value structure, called property
|
|
* (to guarant that the system is maximally flexible).
|
|
* The library defines a set of standard keys, which should be enough
|
|
* for nearly all purposes.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
struct aiMaterial
|
|
{
|
|
#ifdef __cplusplus
|
|
protected:
|
|
aiMaterial() {}
|
|
public:
|
|
#endif // __cplusplus
|
|
|
|
/** List of all material properties loaded.
|
|
*/
|
|
C_STRUCT aiMaterialProperty** mProperties;
|
|
|
|
/** Number of properties loaded
|
|
*/
|
|
unsigned int mNumProperties;
|
|
unsigned int mNumAllocated;
|
|
};
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_NAME
|
|
* Defines the name of the material (aiString)
|
|
*/
|
|
#define AI_MATKEY_NAME "$mat.name"
|
|
|
|
/** @def AI_MATKEY_SHADING_MODE
|
|
* Defines the shading model to use (aiShadingMode)
|
|
*/
|
|
#define AI_MATKEY_SHADING_MODEL "$mat.shadingm"
|
|
|
|
/** @def AI_MATKEY_ENABLE_WIREFRAM
|
|
* Integer property. 1 to enable wireframe for rendering
|
|
*/
|
|
#define AI_MATKEY_ENABLE_WIREFRAME "$mat.wireframe"
|
|
|
|
/** @def AI_MATKEY_OPACITY
|
|
* Defines the base opacity of the material
|
|
*/
|
|
#define AI_MATKEY_OPACITY "$mat.opacity"
|
|
|
|
/** @def AI_MATKEY_BUMPSCALING
|
|
* Defines the height scaling of a bump map (for stuff like Parallax
|
|
* Occlusion Mapping)
|
|
*/
|
|
#define AI_MATKEY_BUMPSCALING "$mat.bumpscaling"
|
|
|
|
/** @def AI_MATKEY_SHININESS
|
|
* Defines the base shininess of the material
|
|
*/
|
|
#define AI_MATKEY_SHININESS "$mat.shininess"
|
|
|
|
/** @def AI_MATKEY_COLOR_DIFFUSE
|
|
* Defines the diffuse base color of the material
|
|
*/
|
|
#define AI_MATKEY_COLOR_DIFFUSE "$clr.diffuse"
|
|
|
|
/** @def AI_MATKEY_COLOR_AMBIENT
|
|
* Defines the ambient base color of the material
|
|
*/
|
|
#define AI_MATKEY_COLOR_AMBIENT "$clr.ambient"
|
|
|
|
/** @def AI_MATKEY_COLOR_SPECULAR
|
|
* Defines the specular base color of the material
|
|
*/
|
|
#define AI_MATKEY_COLOR_SPECULAR "$clr.specular"
|
|
|
|
/** @def AI_MATKEY_COLOR_EMISSIVE
|
|
* Defines the emissive base color of the material
|
|
*/
|
|
#define AI_MATKEY_COLOR_EMISSIVE "$clr.emissive"
|
|
|
|
/** @def AI_MATKEY_TEXTURE_DIFFUSE
|
|
* Defines a specified diffuse texture channel of the material
|
|
*/
|
|
#define AI_MATKEY_TEXTURE_DIFFUSE(N) "$tex.file.diffuse["#N"]"
|
|
#define AI_MATKEY_TEXTURE_DIFFUSE_ "$tex.file.diffuse"
|
|
|
|
/** @def AI_MATKEY_TEXTURE_AMBIENT
|
|
* Defines a specified ambient texture channel of the material
|
|
*/
|
|
#define AI_MATKEY_TEXTURE_AMBIENT(N) "$tex.file.ambient["#N"]"
|
|
#define AI_MATKEY_TEXTURE_AMBIENT_ "$tex.file.ambient"
|
|
|
|
/** @def AI_MATKEY_TEXTURE_SPECULAR
|
|
* Defines a specified specular texture channel of the material
|
|
*/
|
|
#define AI_MATKEY_TEXTURE_SPECULAR(N) "$tex.file.specular["#N"]"
|
|
#define AI_MATKEY_TEXTURE_SPECULAR_ "$tex.file.specular"
|
|
|
|
/** @def AI_MATKEY_TEXTURE_EMISSIVE
|
|
* Defines a specified emissive texture channel of the material
|
|
*/
|
|
#define AI_MATKEY_TEXTURE_EMISSIVE(N) "$tex.file.emissive["#N"]"
|
|
#define AI_MATKEY_TEXTURE_EMISSIVE_ "$tex.file.emissive"
|
|
|
|
/** @def AI_MATKEY_TEXTURE_NORMALS
|
|
* Defines a specified normal texture channel of the material
|
|
*/
|
|
#define AI_MATKEY_TEXTURE_NORMALS(N) "$tex.file.normals["#N"]"
|
|
#define AI_MATKEY_TEXTURE_NORMALS_ "$tex.file.normals"
|
|
|
|
/** @def AI_MATKEY_TEXTURE_HEIGHT
|
|
* Defines a specified bumpmap texture (=heightmap) channel of the material
|
|
* This is very similar to #AI_MATKEY_TEXTURE_NORMALS. It is provided
|
|
* to allow applications to determine whether the input data for
|
|
* normal mapping is already a normal map or needs to be converted from
|
|
* a heightmap to a normal map.
|
|
*/
|
|
#define AI_MATKEY_TEXTURE_HEIGHT(N) "$tex.file.bump["#N"]"
|
|
#define AI_MATKEY_TEXTURE_HEIGHT_ "$tex.file.bump"
|
|
|
|
/** @def AI_MATKEY_TEXTURE_SHININESS
|
|
* Defines a specified shininess texture channel of the material
|
|
*/
|
|
#define AI_MATKEY_TEXTURE_SHININESS(N) "$tex.file.shininess["#N"]"
|
|
#define AI_MATKEY_TEXTURE_SHININESS_ "$tex.file.shininess"
|
|
|
|
/** @def AI_MATKEY_TEXTURE_OPACITY
|
|
* Defines a specified opacity texture channel of the material
|
|
*/
|
|
#define AI_MATKEY_TEXTURE_OPACITY(N) "$tex.file.opacity["#N"]"
|
|
#define AI_MATKEY_TEXTURE_OPACITY_ "$tex.file.opacity"
|
|
|
|
|
|
#define AI_MATKEY_TEXOP_DIFFUSE(N) "$tex.op.diffuse["#N"]"
|
|
#define AI_MATKEY_TEXOP_AMBIENT(N) "$tex.op.ambient["#N"]"
|
|
#define AI_MATKEY_TEXOP_SPECULAR(N) "$tex.op.specular["#N"]"
|
|
#define AI_MATKEY_TEXOP_EMISSIVE(N) "$tex.op.emissive["#N"]"
|
|
#define AI_MATKEY_TEXOP_NORMALS(N) "$tex.op.normals["#N"]"
|
|
#define AI_MATKEY_TEXOP_HEIGHT(N) "$tex.op.bump["#N"]"
|
|
#define AI_MATKEY_TEXOP_SHININESS(N) "$tex.op.shininess["#N"]"
|
|
#define AI_MATKEY_TEXOP_OPACITY(N) "$tex.op.opacity["#N"]"
|
|
|
|
#define AI_MATKEY_TEXOP_DIFFUSE_ "$tex.op.diffuse"
|
|
#define AI_MATKEY_TEXOP_AMBIENT_ "$tex.op.ambient"
|
|
#define AI_MATKEY_TEXOP_SPECULAR_ "$tex.op.specular"
|
|
#define AI_MATKEY_TEXOP_EMISSIVE_ "$tex.op.emissive"
|
|
#define AI_MATKEY_TEXOP_NORMALS_ "$tex.op.normals"
|
|
#define AI_MATKEY_TEXOP_HEIGHT_ "$tex.op.bump"
|
|
#define AI_MATKEY_TEXOP_SHININESS_ "$tex.op.shininess"
|
|
#define AI_MATKEY_TEXOP_OPACITY_ "$tex.op.opacity"
|
|
|
|
#define AI_MATKEY_UVWSRC_DIFFUSE(N) "$tex.uvw.diffuse["#N"]"
|
|
#define AI_MATKEY_UVWSRC_AMBIENT(N) "$tex.uvw.ambient["#N"]"
|
|
#define AI_MATKEY_UVWSRC_SPECULAR(N) "$tex.uvw.specular["#N"]"
|
|
#define AI_MATKEY_UVWSRC_EMISSIVE(N) "$tex.uvw.emissive["#N"]"
|
|
#define AI_MATKEY_UVWSRC_NORMALS(N) "$tex.uvw.normals["#N"]"
|
|
#define AI_MATKEY_UVWSRC_HEIGHT(N) "$tex.uvw.bump["#N"]"
|
|
#define AI_MATKEY_UVWSRC_SHININESS(N) "$tex.uvw.shininess["#N"]"
|
|
#define AI_MATKEY_UVWSRC_OPACITY(N) "$tex.uvw.opacity["#N"]"
|
|
|
|
#define AI_MATKEY_UVWSRC_DIFFUSE_ "$tex.uvw.diffuse"
|
|
#define AI_MATKEY_UVWSRC_AMBIENT_ "$tex.uvw.ambient"
|
|
#define AI_MATKEY_UVWSRC_SPECULAR_ "$tex.uvw.specular"
|
|
#define AI_MATKEY_UVWSRC_EMISSIVE_ "$tex.uvw.emissive"
|
|
#define AI_MATKEY_UVWSRC_NORMALS_ "$tex.uvw.normals"
|
|
#define AI_MATKEY_UVWSRC_HEIGHT_ "$tex.uvw.bump"
|
|
#define AI_MATKEY_UVWSRC_SHININESS_ "$tex.uvw.shininess"
|
|
#define AI_MATKEY_UVWSRC_OPACITY_ "$tex.uvw.opacity"
|
|
|
|
#define AI_MATKEY_TEXBLEND_DIFFUSE(N) "$tex.blend.diffuse["#N"]"
|
|
#define AI_MATKEY_TEXBLEND_AMBIENT(N) "$tex.blend.ambient["#N"]"
|
|
#define AI_MATKEY_TEXBLEND_SPECULAR(N) "$tex.blend.specular["#N"]"
|
|
#define AI_MATKEY_TEXBLEND_EMISSIVE(N) "$tex.blend.emissive["#N"]"
|
|
#define AI_MATKEY_TEXBLEND_NORMALS(N) "$tex.blend.normals["#N"]"
|
|
#define AI_MATKEY_TEXBLEND_HEIGHT(N) "$tex.blend.bump["#N"]"
|
|
#define AI_MATKEY_TEXBLEND_SHININESS(N) "$tex.blend.shininess["#N"]"
|
|
#define AI_MATKEY_TEXBLEND_OPACITY(N) "$tex.blend.opacity["#N"]"
|
|
|
|
#define AI_MATKEY_TEXBLEND_DIFFUSE_ "$tex.blend.diffuse"
|
|
#define AI_MATKEY_TEXBLEND_AMBIENT_ "$tex.blend.ambient"
|
|
#define AI_MATKEY_TEXBLEND_SPECULAR_ "$tex.blend.specular"
|
|
#define AI_MATKEY_TEXBLEND_EMISSIVE_ "$tex.blend.emissive"
|
|
#define AI_MATKEY_TEXBLEND_NORMALS_ "$tex.blend.normals"
|
|
#define AI_MATKEY_TEXBLEND_HEIGHT_ "$tex.blend.bump"
|
|
#define AI_MATKEY_TEXBLEND_SHININESS_ "$tex.blend.shininess"
|
|
#define AI_MATKEY_TEXBLEND_OPACITY_ "$tex.blend.opacity"
|
|
|
|
|
|
#define AI_MATKEY_ORENNAYAR_ROUGHNESS "$shading.orennayar.roughness"
|
|
#define AI_MATKEY_MINNAERT_DARKNESS "$shading.minnaert.darkness"
|
|
#define AI_MATKEY_COOK_TORRANCE_REFRACTI "$shading.cookt.refracti"
|
|
#define AI_MATKEY_COOK_TORRANCE_PARAM "$shading.cookt.param"
|
|
|
|
|
|
/** @def AI_MATKEY_GLOBAL_BACKGROUND_IMAGE
|
|
* Global property defined by some loaders. Contains the path to
|
|
* the image file to be used as background image.
|
|
*/
|
|
#define AI_MATKEY_GLOBAL_BACKGROUND_IMAGE "$global.bg.image2d"
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Retrieve a material property with a specific key from the material
|
|
*
|
|
* @param pMat Pointer to the input material. May not be NULL
|
|
* @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
|
|
* @param pPropOut Pointer to receive a pointer to a valid aiMaterialProperty
|
|
* structure or NULL if the key has not been found.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
aiReturn aiGetMaterialProperty(const C_STRUCT aiMaterial* pMat,
|
|
const char* pKey,
|
|
const C_STRUCT aiMaterialProperty** pPropOut);
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Retrieve an array of float values with a specific key
|
|
* from the material
|
|
*
|
|
* @param pMat Pointer to the input material. May not be NULL
|
|
* @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
|
|
* @param pOut Pointer to a buffer to receive the result.
|
|
* @param pMax Specifies the size of the given buffer, in float's.
|
|
* Receives the number of values (not bytes!) read.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
aiReturn aiGetMaterialFloatArray(const C_STRUCT aiMaterial* pMat,
|
|
const char* pKey,
|
|
float* pOut,
|
|
unsigned int* pMax);
|
|
|
|
#ifdef __cplusplus
|
|
// inline it
|
|
inline aiReturn aiGetMaterialFloat(const C_STRUCT aiMaterial* pMat,
|
|
const char* pKey,
|
|
float* pOut)
|
|
{return aiGetMaterialFloatArray(pMat,pKey,pOut,(unsigned int*)0x0);}
|
|
#else
|
|
// use our friend, the C preprocessor
|
|
#define aiGetMaterialFloat (pMat, pKey, pOut) \
|
|
aiGetMaterialFloatArray(pMat, pKey, pOut, NULL)
|
|
#endif //!__cplusplus
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Retrieve an array of integer values with a specific key
|
|
* from the material
|
|
*
|
|
* @param pMat Pointer to the input material. May not be NULL
|
|
* @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
|
|
* @param pOut Pointer to a buffer to receive the result.
|
|
* @param pMax Specifies the size of the given buffer, in int's.
|
|
* Receives the number of values (not bytes!) read.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
aiReturn aiGetMaterialIntegerArray(const C_STRUCT aiMaterial* pMat,
|
|
const char* pKey,
|
|
int* pOut,
|
|
unsigned int* pMax);
|
|
|
|
#ifdef __cplusplus
|
|
// inline it
|
|
inline aiReturn aiGetMaterialInteger(const C_STRUCT aiMaterial* pMat,
|
|
const char* pKey,
|
|
int* pOut)
|
|
{return aiGetMaterialIntegerArray(pMat,pKey,pOut,(unsigned int*)0x0);}
|
|
#else
|
|
// use our friend, the C preprocessor
|
|
#define aiGetMaterialInteger (pMat, pKey, pOut) \
|
|
aiGetMaterialIntegerArray(pMat, pKey, pOut, NULL)
|
|
#endif //!__cplusplus
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Retrieve a color value from the material property table
|
|
*
|
|
* @param pMat Pointer to the input material. May not be NULL
|
|
* @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
|
|
* @param pOut Pointer to a buffer to receive the result.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
aiReturn aiGetMaterialColor(const C_STRUCT aiMaterial* pMat,
|
|
const char* pKey,
|
|
aiColor4D* pOut);
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Retrieve a string from the material property table
|
|
*
|
|
* @param pMat Pointer to the input material. May not be NULL
|
|
* @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
|
|
* @param pOut Pointer to a buffer to receive the result.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
aiReturn aiGetMaterialString(const C_STRUCT aiMaterial* pMat,
|
|
const char* pKey,
|
|
aiString* pOut);
|
|
|
|
|
|
#define AI_TEXTYPE_OPACITY 0x0
|
|
#define AI_TEXTYPE_SPECULAR 0x1
|
|
#define AI_TEXTYPE_AMBIENT 0x2
|
|
#define AI_TEXTYPE_EMISSIVE 0x3
|
|
#define AI_TEXTYPE_HEIGHT 0x4
|
|
#define AI_TEXTYPE_NORMALS 0x5
|
|
#define AI_TEXTYPE_SHININESS 0x6
|
|
#define AI_TEXTYPE_DIFFUSE 0x7
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Helper function to get a diffuse texture from a material
|
|
*
|
|
* This function is provided just for convinience.
|
|
* @param pMat Pointer to the input material. May not be NULL
|
|
* @param iIndex Index of the texture to retrieve. If the index is too
|
|
* large the function fails.
|
|
* @param iTexType One of the AI_TEXTYPE constants. Specifies the type of
|
|
* the texture to retrieve (e.g. diffuse, specular, height map ...)
|
|
* @param szPath Receives the output path
|
|
* NULL is no allowed as value
|
|
* @param piUVIndex Receives the UV index of the texture.
|
|
* NULL is allowed as value.
|
|
* @param pfBlendFactor Receives the blend factor for the texture
|
|
* NULL is allowed as value.
|
|
* @param peTextureOp Receives the texture operation to perform between
|
|
* this texture and the previous texture.
|
|
* NULL is allowed as value.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* pMat,
|
|
unsigned int iIndex,
|
|
unsigned int iTexType,
|
|
C_STRUCT aiString* szPath,
|
|
unsigned int* piUVIndex,
|
|
float* pfBlendFactor,
|
|
aiTextureOp* peTextureOp);
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif //!__cplusplus
|
|
|
|
#endif //!!AI_MATERIAL_H_INC
|