1296 lines
42 KiB
C++
1296 lines
42 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open 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 aiMaterial.h
|
|
* @brief 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
|
|
|
|
// Name for the default material
|
|
#define AI_DEFAULT_MATERIAL_NAME "aiDefaultMat"
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief A very primitive RTTI system to store the data type of a
|
|
* material property.
|
|
*/
|
|
enum aiPropertyTypeInfo
|
|
{
|
|
/** Array of single-precision (32 Bit) floats
|
|
*
|
|
* It is possible to use aiGetMaterialInteger[Array]() (or the C++-API
|
|
* aiMaterial::Get()) to query properties stored in floating-point format.
|
|
* The material system performs the type conversion automatically.
|
|
*/
|
|
aiPTI_Float = 0x1,
|
|
|
|
/** The material property is an aiString.
|
|
*
|
|
* Arrays of strings aren't possible, aiGetMaterialString() (or the
|
|
* C++-API aiMaterial::Get()) *must* be used to query a string property.
|
|
*/
|
|
aiPTI_String = 0x3,
|
|
|
|
/** Array of (32 Bit) integers
|
|
*
|
|
* It is possible to use aiGetMaterialFloat[Array]() (or the C++-API
|
|
* aiMaterial::Get()) to query properties stored in integer format.
|
|
* The material system performs the type conversion automatically.
|
|
*/
|
|
aiPTI_Integer = 0x4,
|
|
|
|
|
|
/** Simple binary buffer, content undefined. Not convertible to anything.
|
|
*/
|
|
aiPTI_Buffer = 0x5,
|
|
|
|
|
|
/** This value is not used. It is just there to force the
|
|
* compiler to map this enum to a 32 Bit integer.
|
|
*/
|
|
_aiPTI_Force32Bit = 0x9fffffff
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Defines how the Nth texture is combined with the N-1th texture.
|
|
*
|
|
* Example (left: key, right: value): <br>
|
|
* @code
|
|
* DiffColor0 - gray
|
|
* DiffTextureOp0 - aiTextureOpMultiply
|
|
* DiffTexture0 - tex1.png
|
|
* DiffTextureOp0 - aiTextureOpAdd
|
|
* DiffTexture1 - tex2.png
|
|
* @endcode
|
|
* Written as equation, the final diffuse term for a specific pixel would be:
|
|
* @code
|
|
* diffFinal = DiffColor0 * sampleTex(DiffTexture0,UV0) +
|
|
* sampleTex(DiffTexture1,UV0) * diffContrib;
|
|
* @endcode
|
|
* where 'diffContrib' is the intensity of the incoming light for that pixel.
|
|
*/
|
|
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,
|
|
|
|
|
|
/** This value is not used. It is just there to force the
|
|
* compiler to map this enum to a 32 Bit integer.
|
|
*/
|
|
_aiTextureOp_Force32Bit = 0x9fffffff
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Defines how UV coordinates outside the [0...1] range are handled.
|
|
*
|
|
*/
|
|
enum aiTextureMapMode
|
|
{
|
|
/** A texture coordinate u|v is translated to u%1|v%1
|
|
*/
|
|
aiTextureMapMode_Wrap = 0x0,
|
|
|
|
/** Texture coordinates outside [0...1]
|
|
* are clamped to the nearest valid value.
|
|
*/
|
|
aiTextureMapMode_Clamp = 0x1,
|
|
|
|
/** If the texture coordinates for a pixel are outside [0...1]
|
|
* the texture is not applied to that pixel
|
|
*/
|
|
aiTextureMapMode_Decal = 0x3,
|
|
|
|
/** A texture coordinate u|v becomes u%1|v%1 if (u-(u%1))%2 is zero and
|
|
* 1-(u%1)|1-(v%1) otherwise
|
|
*/
|
|
aiTextureMapMode_Mirror = 0x2,
|
|
|
|
|
|
/** This value is not used. It is just here to force the
|
|
* compiler to map this enum to a 32 Bit integer.
|
|
*/
|
|
_aiTextureMapMode_Force32Bit = 0x9fffffff
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Defines how the mapping coords for a texture are generated.
|
|
*
|
|
* Real-time applications typically require full UV coordinates, so the use of
|
|
* the aiProcess_GenUVCoords step is highly recommended. It generates proper
|
|
* UV channels for non-UV mapped objects, as long as an accurate description
|
|
* how the mapping should look like (e.g spherical) is given.
|
|
* See the #AI_MATKEY_MAPPING property for more details.
|
|
*/
|
|
enum aiTextureMapping
|
|
{
|
|
/** The mapping coordinates are taken from an UV channel.
|
|
*
|
|
* The #AI_MATKEY_UVWSRC key specifies from which (remember,
|
|
* meshes can have more than one UV channel).
|
|
*/
|
|
aiTextureMapping_UV = 0x0 ,
|
|
|
|
/** Spherical mapping */
|
|
aiTextureMapping_SPHERE = 0x1,
|
|
|
|
/** Cylindrical mapping */
|
|
aiTextureMapping_CYLINDER = 0x2,
|
|
|
|
/** Cubic mapping */
|
|
aiTextureMapping_BOX = 0x3,
|
|
|
|
/** Planar mapping */
|
|
aiTextureMapping_PLANE = 0x4,
|
|
|
|
/** Undefined mapping. Have fun. */
|
|
aiTextureMapping_OTHER = 0x5,
|
|
|
|
|
|
/** This value is not used. It is just here to force the
|
|
* compiler to map this enum to a 32 Bit integer.
|
|
*/
|
|
_aiTextureMapping_Force32Bit = 0x9fffffff
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Defines which mesh axes are used to construct the projection shape
|
|
* for non-UV mappings around the model.
|
|
*
|
|
* This corresponds to the #AI_MATKEY_TEXMAP_AXIS property.
|
|
*/
|
|
enum aiAxis
|
|
{
|
|
aiAxis_X = 0x0,
|
|
aiAxis_Y = 0x1,
|
|
aiAxis_Z = 0x2,
|
|
|
|
|
|
/** This value is not used. It is just here to force the
|
|
* compiler to map this enum to a 32 Bit integer.
|
|
*/
|
|
_aiAxis_Force32Bit = 0x9fffffff
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Defines the purpose of a texture
|
|
*/
|
|
enum aiTextureType
|
|
{
|
|
/** The texture is combined with the result of the diffuse
|
|
* lighting equation.
|
|
*/
|
|
aiTextureType_DIFFUSE = 0x0,
|
|
|
|
/** The texture is combined with the result of the specular
|
|
* lighting equation.
|
|
*/
|
|
aiTextureType_SPECULAR = 0x1,
|
|
|
|
/** The texture is combined with the result of the ambient
|
|
* lighting equation.
|
|
*/
|
|
aiTextureType_AMBIENT = 0x2,
|
|
|
|
/** The texture is added to the result of the lighting
|
|
* calculation. It isn't influenced by any lighting.
|
|
*/
|
|
aiTextureType_EMISSIVE = 0x3,
|
|
|
|
/** The texture is a height map and serves as input for
|
|
* a normal map generator.
|
|
*/
|
|
aiTextureType_HEIGHT = 0x4,
|
|
|
|
/** The texture is a (tangent space) normal-map.
|
|
*
|
|
* If the normal map does also contain a height channel
|
|
* for use with techniques such as Parallax Occlusion Mapping
|
|
* it is registered once as a normalmap.
|
|
*/
|
|
aiTextureType_NORMALS = 0x5,
|
|
|
|
/** The texture defines the glossiness of the material.
|
|
*
|
|
* The glossiness is in fact the exponent of the specular
|
|
* lighting equation. Normally there is a conversion
|
|
* function define to map the linear color values in the
|
|
* texture to a suitable exponent. Have fun.
|
|
*/
|
|
aiTextureType_SHININESS = 0x6,
|
|
|
|
/** The texture defines a per-pixel opacity.
|
|
*
|
|
* Normally 'white' means opaque and 'black' means
|
|
* 'transparency'. Or quite the opposite. Have fun.
|
|
*/
|
|
aiTextureType_OPACITY = 0x7,
|
|
|
|
|
|
/** This value is not used. It is just here to force the
|
|
* compiler to map this enum to a 32 Bit integer.
|
|
*/
|
|
_aiTextureType_Force32Bit = 0x9fffffff
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief 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 = 0x9,
|
|
|
|
/** Fresnel shading
|
|
*/
|
|
aiShadingMode_Fresnel = 0xa,
|
|
|
|
|
|
/** This value is not used. It is just there to force the
|
|
* compiler to map this enum to a 32 Bit integer.
|
|
*/
|
|
_aiShadingMode_Force32Bit = 0x9fffffff
|
|
};
|
|
|
|
#include "./Compiler/pushpack1.h"
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Defines how an UV channel is transformed.
|
|
*
|
|
* This is just a helper structure for the #AI_MATKEY_UVTRANSFORM key.
|
|
* See its documentation for more details.
|
|
*
|
|
* Typically you'll want to build a matrix of this information. However,
|
|
* we keep separate scaling/translation/rotation values to make it
|
|
* easier to process and optimize UV transformations internally.
|
|
*/
|
|
struct aiUVTransform
|
|
{
|
|
/** Translation on the u and v axes. */
|
|
C_STRUCT aiVector2D mTranslation;
|
|
|
|
/** Scaling on the u and v axes. */
|
|
C_STRUCT aiVector2D mScaling;
|
|
|
|
/** Rotation - in counter-clockwise direction.
|
|
*
|
|
* The rotation angle is specified in radians. The
|
|
* rotation center is 0.5f|0.5f.
|
|
*/
|
|
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"
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Data structure for a single material property
|
|
* @see aiMaterial
|
|
*/
|
|
struct aiMaterialProperty
|
|
{
|
|
/** Specifies the name of the property (key)
|
|
*
|
|
* Keys are case insensitive.
|
|
*/
|
|
C_STRUCT aiString mKey;
|
|
|
|
/** Textures: Specifies the exact usage semantic
|
|
*/
|
|
unsigned int mSemantic;
|
|
|
|
/** Textures: Specifies the index of the texture
|
|
*
|
|
* Textures are counted per-type.
|
|
*/
|
|
unsigned int mIndex;
|
|
|
|
/** Size of the buffer mData is pointing to, in bytes
|
|
* This value may not be 0.
|
|
*/
|
|
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.
|
|
*/
|
|
C_ENUM 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. This member
|
|
* is never 0
|
|
*/
|
|
char* mData;
|
|
|
|
#ifdef __cplusplus
|
|
|
|
aiMaterialProperty()
|
|
{
|
|
mData = NULL;
|
|
mIndex = mSemantic = 0;
|
|
}
|
|
|
|
~aiMaterialProperty()
|
|
{
|
|
delete[] mData;
|
|
}
|
|
|
|
#endif
|
|
};
|
|
|
|
#ifdef __cplusplus
|
|
} // We need to leave the "C" block here to allow template member functions
|
|
#endif
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Data structure for a material
|
|
*
|
|
* Material data is stored using a key-value structure. A single key-value
|
|
* pair is called a 'material property'. C++ users should use the provided
|
|
* member functions of aiMaterial to process material properties, C users
|
|
* have to stick with the aiMaterialGetXXX family of unbound functions.
|
|
* The library defines a set of standard keys (AI_MATKEY_XXX).
|
|
*/
|
|
struct ASSIMP_API aiMaterial
|
|
{
|
|
|
|
#ifdef __cplusplus
|
|
|
|
/// NOTE: no initialization, instance Assimp::MaterialHelper instead
|
|
aiMaterial() {}
|
|
|
|
public:
|
|
|
|
~aiMaterial();
|
|
|
|
// -------------------------------------------------------------------
|
|
/** @brief Retrieve an array of Type values with a specific key
|
|
* from the material
|
|
*
|
|
* @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
|
|
* @param type Specifies the type of the texture to be retrieved (
|
|
* e.g. diffuse, specular, height map ...)
|
|
* @param idx Index of the texture to be retrieved.
|
|
* @param pOut Pointer to a buffer to receive the result.
|
|
* @param pMax Specifies the size of the given buffer, in Type's.
|
|
* Receives the number of values (not bytes!) read.
|
|
* NULL is a valid value for this parameter.
|
|
*/
|
|
template <typename Type>
|
|
aiReturn Get(const char* pKey,unsigned int type,
|
|
unsigned int idx, Type* pOut, unsigned int* pMax) const;
|
|
|
|
// -------------------------------------------------------------------
|
|
/** @brief Retrieve a Type value with a specific key
|
|
* from the material
|
|
*
|
|
* @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
|
|
* @param type Specifies the type of the texture to be retrieved (
|
|
* e.g. diffuse, specular, height map ...)
|
|
* @param idx Index of the texture to be retrieved.
|
|
* @param pOut Reference to receive the output value
|
|
*/
|
|
template <typename Type>
|
|
aiReturn Get(const char* pKey,unsigned int type,
|
|
unsigned int idx,Type& pOut) const;
|
|
|
|
// -------------------------------------------------------------------
|
|
/** @brief Helper function to get a texture from a material.
|
|
*
|
|
* This function is provided just for convenience, you could also
|
|
* read the single material properties manually.
|
|
* @param type Specifies the type of the texture to be retrieved (
|
|
* e.g. diffuse, specular, height map ...)
|
|
* @param index Index of the texture to be retrieved. The function fails
|
|
* if there is no texture of that type with this index.
|
|
* @param path Receives the path to the texture.
|
|
* NULL is a valid value.
|
|
* @param mapping The texture mapping.
|
|
* NULL is allowed as value.
|
|
* @param uvindex Receives the UV index of the texture.
|
|
* NULL is a valid value.
|
|
* @param blend Receives the blend factor for the texture
|
|
* NULL is a valid value.
|
|
* @param op Receives the texture operation to be performed between
|
|
* this texture and the previous texture. NULL is allowed as value.
|
|
* @param mapmode Receives the mapping modes to be used for the texture.
|
|
* The parameter may be NULL but if it is a valid pointer it MUST
|
|
* point to an array of 3 aiTextureMapMode's (one for each
|
|
* axis: UVW order (=XYZ)).
|
|
*/
|
|
// -------------------------------------------------------------------
|
|
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;
|
|
|
|
#endif
|
|
|
|
/** List of all material properties loaded. */
|
|
C_STRUCT aiMaterialProperty** mProperties;
|
|
|
|
/** Number of properties in the data base */
|
|
unsigned int mNumProperties;
|
|
|
|
/** Storage allocated */
|
|
unsigned int mNumAllocated;
|
|
};
|
|
|
|
// Go back to extern "C" again
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_NAME
|
|
* Defines the name of the material
|
|
* <br>
|
|
* <b>Type:</b> string (aiString)<br>
|
|
* <b>Default value:</b> none <br>
|
|
*/
|
|
#define AI_MATKEY_NAME "$mat.name",0,0
|
|
|
|
|
|
/** @def AI_MATKEY_TWOSIDED
|
|
* Indicates that the material must be rendered two-sided
|
|
* <br>
|
|
* <b>Type:</b> int <br>
|
|
* <b>Default value:</b> 0 <br>
|
|
*/
|
|
#define AI_MATKEY_TWOSIDED "$mat.twosided",0,0
|
|
|
|
|
|
/** @def AI_MATKEY_SHADING_MODEL
|
|
* Defines the shading model to use (aiShadingMode)
|
|
* <br>
|
|
* <b>Type:</b> int (aiShadingMode)<br>
|
|
* <b>Default value:</b> aiShadingMode_Gouraud <br>
|
|
*/
|
|
#define AI_MATKEY_SHADING_MODEL "$mat.shadingm",0,0
|
|
|
|
|
|
/** @def AI_MATKEY_ENABLE_WIREFRAME
|
|
* Integer property. 1 to enable wireframe for rendering
|
|
* <br>
|
|
* <b>Type:</b> int <br>
|
|
* <b>Default value:</b> 0 <br>
|
|
*/
|
|
#define AI_MATKEY_ENABLE_WIREFRAME "$mat.wireframe",0,0
|
|
|
|
|
|
/** @def AI_MATKEY_OPACITY
|
|
* Defines the base opacity of the material
|
|
* <br>
|
|
* <b>Type:</b> float<br>
|
|
* <b>Default value:</b> 1.0f <br>
|
|
*/
|
|
#define AI_MATKEY_OPACITY "$mat.opacity",0,0
|
|
|
|
|
|
/** @def AI_MATKEY_BUMPSCALING
|
|
* Defines the height scaling of a bump map (for stuff like Parallax
|
|
* Occlusion Mapping)
|
|
* <br>
|
|
* <b>Type:</b> float<br>
|
|
* <b>Default value:</b> 1.0f <br>
|
|
*/
|
|
#define AI_MATKEY_BUMPSCALING "$mat.bumpscaling",0,0
|
|
|
|
|
|
/** @def AI_MATKEY_SHININESS
|
|
* Defines the base shininess of the material
|
|
* This is the exponent of the Phong shading equation.
|
|
* <br>
|
|
* <b>Type:</b> float<br>
|
|
* <b>Default value:</b> 0.0f <br>
|
|
*/
|
|
#define AI_MATKEY_SHININESS "$mat.shininess",0,0
|
|
|
|
|
|
/** @def AI_MATKEY_SHININESS_STRENGTH
|
|
* Defines the strength of the specular highlight.
|
|
* This is simply a multiplier to the specular color of a material
|
|
* <br>
|
|
* <b>Type:</b> float<br>
|
|
* <b>Default value:</b> 1.0f <br>
|
|
*/
|
|
#define AI_MATKEY_SHININESS_STRENGTH "$mat.shinpercent",0,0
|
|
|
|
/** @def AI_MATKEY_REFRACTI
|
|
* Index of refraction of the material. This is used by some shading models,
|
|
* e.g. Cook-Torrance. The value is the ratio of the speed of light in a
|
|
* vacuum to the speed of light in the material (always >= 1.0 in the real world).
|
|
* <br>
|
|
* <b>Type:</b> float<br>
|
|
* <b>Default value:</b> 1.0f <br>
|
|
*/
|
|
#define AI_MATKEY_REFRACTI "$mat.refracti",0,0
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_COLOR_DIFFUSE
|
|
* Defines the diffuse base color of the material
|
|
* <br>
|
|
* <b>Type:</b> color (aiColor4D or aiColor3D)<br>
|
|
* <b>Default value:</b> 0.0f|0.0f|0.0f|1.0f <br>
|
|
*/
|
|
#define AI_MATKEY_COLOR_DIFFUSE "$clr.diffuse",0,0
|
|
|
|
/** @def AI_MATKEY_COLOR_AMBIENT
|
|
* Defines the ambient base color of the material
|
|
* <br>
|
|
* <b>Type:</b> color (aiColor4D or aiColor3D)<br>
|
|
* <b>Default value:</b> 0.0f|0.0f|0.0f|1.0f <br>
|
|
*/
|
|
#define AI_MATKEY_COLOR_AMBIENT "$clr.ambient",0,0
|
|
|
|
/** @def AI_MATKEY_COLOR_SPECULAR
|
|
* Defines the specular base color of the material
|
|
* <br>
|
|
* <b>Type:</b> color (aiColor4D or aiColor3D)<br>
|
|
* <b>Default value:</b> 0.0f|0.0f|0.0f|1.0f <br>
|
|
*/
|
|
#define AI_MATKEY_COLOR_SPECULAR "$clr.specular",0,0
|
|
|
|
/** @def AI_MATKEY_COLOR_EMISSIVE
|
|
* Defines the emissive base color of the material
|
|
* <br>
|
|
* <b>Type:</b> color (aiColor4D or aiColor3D)<br>
|
|
* <b>Default value:</b> 0.0f|0.0f|0.0f|1.0f <br>
|
|
*/
|
|
#define AI_MATKEY_COLOR_EMISSIVE "$clr.emissive",0,0
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_TEXTURE
|
|
* Parameters: type, N<br>
|
|
* Specifies the path to the Nth texture of type "type".
|
|
* This can either be a path to the texture or a string of the form '*<i>'
|
|
* where i is an index into the array of embedded textures that has been
|
|
* imported along with the scene. See aiTexture for more details.
|
|
* <br>
|
|
* <b>Type:</b> String<br>
|
|
* <b>Default value to be assumed if this key isn't there:</b> n/a<br>
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
#define AI_MATKEY_TEXTURE(type, N) "$tex.file",type,N
|
|
|
|
// for backward compatibility
|
|
#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)
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_UVWSRC
|
|
* Parameters: type, N<br>
|
|
* Specifies which UV channel is used as source for the mapping coordinates
|
|
* of the Nth texture of type "type".
|
|
* <br>
|
|
* <b>Type:</b> int<br>
|
|
* <b>Default value to be assumed if this key isn't there:</b> 0<br>
|
|
* <b>Requires:</b> AI_MATKEY_TEXTURE(type,N)
|
|
* and AI_MATKEY_MAPPING(type,N) == UV<br>
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
#define AI_MATKEY_UVWSRC(type, N) "$tex.uvwsrc",type,N
|
|
|
|
// for backward compatibility
|
|
#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)
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_TEXOP
|
|
* Parameters: type, N<br>
|
|
* Specifies how the Nth texture of type "type" is combined with
|
|
* the result of all color values from all previous textures combined.
|
|
* <br>
|
|
* <b>Type:</b> int (aiTextureOp)<br>
|
|
* <b>Default value to be assumed if this key isn't there:</b> multiply<br>
|
|
* <b>Requires:</b> AI_MATKEY_TEXTURE(type,N)<br>
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
#define AI_MATKEY_TEXOP(type, N) "$tex.op",type,N
|
|
|
|
// for backward compatibility
|
|
#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)
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_MAPPING
|
|
* Parameters: type, N<br>
|
|
* Specifies how the Nth texture of type "type" is mapped.
|
|
* <br>
|
|
* <b>Type:</b> int (aiTextureMapping)<br>
|
|
* <b>Default value to be assumed if this key isn't there:</b> UV<br>
|
|
* <b>Requires:</b> AI_MATKEY_TEXTURE(type,N)<br>
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
#define AI_MATKEY_MAPPING(type, N) "$tex.mapping",type,N
|
|
|
|
// for backward compatibility
|
|
#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)
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_TEXBLEND (
|
|
* Parameters: type, N<br>
|
|
* Specifies the strength of the <N>th texture of type <type>. This is just
|
|
* a multiplier for the texture's color values.
|
|
* <br>
|
|
* <b>Type:</b> float<br>
|
|
* <b>Default value to be assumed if this key isn't there:</b> 1.f<br>
|
|
* <b>Requires:</b> AI_MATKEY_TEXTURE(type,N)<br>
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
#define AI_MATKEY_TEXBLEND(type, N) "$tex.blend",type,N
|
|
|
|
// for backward compatibility
|
|
#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)
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_MAPPINGMODE_U
|
|
* Parameters: type, N<br>
|
|
* Specifies the texture mapping mode for the <N>th texture of type <type> in
|
|
* the u (x) direction
|
|
* <br>
|
|
* <b>Type:</b> int (aiTextureMapMode)<br>
|
|
* <b>Default value:</b> aiTextureMapMode_Wrap<br>
|
|
* <b>Requires:</b> AI_MATKEY_TEXTURE(type,N)<br>
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
#define AI_MATKEY_MAPPINGMODE_U(type, N) "$tex.mapmodeu",type,N
|
|
|
|
// for backward compatibility
|
|
#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)
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_MAPPINGMODE_V
|
|
* Parameters: type, N<br>
|
|
* Specifies the texture mapping mode for the <N>th texture of type <type> in
|
|
* the w (z) direction
|
|
* <br>
|
|
* <b>Type:</b> int (aiTextureMapMode)<br>
|
|
* <b>Default value:</b> aiTextureMapMode_Wrap<br>
|
|
* <b>Requires:</b> AI_MATKEY_TEXTURE(type,N)<br>
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
#define AI_MATKEY_MAPPINGMODE_V(type, N) "$tex.mapmodev",type,N
|
|
|
|
// for backward compatibility
|
|
#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)
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_MAPPINGMODE_W
|
|
* Parameters: type, N<br>
|
|
* Specifies the texture mapping mode for the <N>th texture of type <type> in
|
|
* the w (z) direction
|
|
* <br>
|
|
* <b>Type:</b> int (aiTextureMapMode)<br>
|
|
* <b>Default value:</b> aiTextureMapMode_Wrap<br>
|
|
* <b>Requires:</b> AI_MATKEY_TEXTURE(type,N)<br>
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
#define AI_MATKEY_MAPPINGMODE_W(type, N) "$tex.mapmodew",type,N
|
|
|
|
// for backward compatibility
|
|
#define AI_MATKEY_MAPPINGMODE_W_DIFFUSE(N) \
|
|
AI_MATKEY_MAPPINGMODE_W(aiTextureType_DIFFUSE,N)
|
|
|
|
#define AI_MATKEY_MAPPINGMODE_W_SPECULAR(N) \
|
|
AI_MATKEY_MAPPINGMODE_W(aiTextureType_SPECULAR,N)
|
|
|
|
#define AI_MATKEY_MAPPINGMODE_W_AMBIENT(N) \
|
|
AI_MATKEY_MAPPINGMODE_W(aiTextureType_AMBIENT,N)
|
|
|
|
#define AI_MATKEY_MAPPINGMODE_W_EMISSIVE(N) \
|
|
AI_MATKEY_MAPPINGMODE_W(aiTextureType_EMISSIVE,N)
|
|
|
|
#define AI_MATKEY_MAPPINGMODE_W_NORMALS(N) \
|
|
AI_MATKEY_MAPPINGMODE_W(aiTextureType_NORMALS,N)
|
|
|
|
#define AI_MATKEY_MAPPINGMODE_W_HEIGHT(N) \
|
|
AI_MATKEY_MAPPINGMODE_W(aiTextureType_HEIGHT,N)
|
|
|
|
#define AI_MATKEY_MAPPINGMODE_W_SHININESS(N) \
|
|
AI_MATKEY_MAPPINGMODE_W(aiTextureType_SHININESS,N)
|
|
|
|
#define AI_MATKEY_MAPPINGMODE_W_OPACITY(N) \
|
|
AI_MATKEY_MAPPINGMODE_W(aiTextureType_OPACITY,N)
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_TEXMAP_AXIS
|
|
* Parameters: type, N<br>
|
|
* Specifies the main mapping axis of the Nth texture of type "type".
|
|
* This applies to non-UV mapped textures. For spherical, cylindrical and
|
|
* planar this is the main axis of the corresponding geometric shape.
|
|
* <br>
|
|
* <b>Type:</b> int (aiAxis)<br>
|
|
* <b>Default value:</b> aiAxis_Z<br>
|
|
* <b>Requires:</b> AI_MATKEY_TEXTURE(type,N) and
|
|
* AI_MATKEY_MAPPING(type,N) != UV<br>
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
#define AI_MATKEY_TEXMAP_AXIS(type, N) "$tex.mapaxis",type,N
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @def AI_MATKEY_UVTRANSFORM
|
|
* Parameters: type, N<br>
|
|
* Specifies how the UV mapping coordinates for the Nth texture of type
|
|
* "type" are transformed before they're used for mapping. This is an array
|
|
* of five floats - use the aiUVTransform structure for simplicity.
|
|
* <br>
|
|
* <b>Type:</b> Array of 5 floats<br>
|
|
* <b>Default value:</b> 0.f,0.f,1.f,1.f,0.f <br>
|
|
* <b>Requires:</b> AI_MATKEY_TEXTURE(type,N) and
|
|
* AI_MATKEY_MAPPING(type,N) == UV<br>
|
|
* <b>Note:</b>Transformed 3D texture coordinates are not supported
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
#define AI_MATKEY_UVTRANSFORM(type, N) "$tex.uvtrafo",type,N
|
|
|
|
// for backward compatibility
|
|
#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_ORENNAYAR_ROUGHNESS "$shading.orennayar.roughness",0,0
|
|
#define AI_MATKEY_MINNAERT_DARKNESS "$shading.minnaert.darkness",0,0
|
|
#define AI_MATKEY_COOK_TORRANCE_PARAM "$shading.cookt.param",0,0
|
|
|
|
/** @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",0,0
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief 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 type Specifies the type of the texture to be retrieved (
|
|
* e.g. diffuse, specular, height map ...)
|
|
* @param index Index of the texture to be retrieved.
|
|
* @param pPropOut Pointer to receive a pointer to a valid aiMaterialProperty
|
|
* structure or NULL if the key has not been found.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
ASSIMP_API C_ENUM aiReturn aiGetMaterialProperty(
|
|
const C_STRUCT aiMaterial* pMat,
|
|
const char* pKey,
|
|
C_ENUM aiTextureType type,
|
|
unsigned int index,
|
|
const C_STRUCT aiMaterialProperty** pPropOut);
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Retrieve an array of float values with a specific key
|
|
* from the material
|
|
*
|
|
* Pass one of the AI_MATKEY_XXX constants for the last three parameters (the
|
|
* example reads the #AI_MATKEY_UVTRANSFORM property of the first diffuse texture)
|
|
* @code
|
|
* aiUVTransform trafo;
|
|
* unsigned int max = sizeof(aiUVTransform);
|
|
* if (AI_SUCCESS != aiGetMaterialFloatArray(mat, AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE,0),
|
|
* (float*)&trafo, &max) || sizeof(aiUVTransform) != max)
|
|
* {
|
|
* // error handling
|
|
* }
|
|
* @endcode
|
|
*
|
|
* @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.
|
|
* @param type (see the code sample above)
|
|
* @param index (see the code sample above)
|
|
* @return Specifies whether the key has been found. If not, the output
|
|
* arrays remains unmodified and pMax is set to 0.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
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
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Retrieve a single float property with a specific key from the material.
|
|
*
|
|
* Pass one of the AI_MATKEY_XXX constants for the last three parameters (the
|
|
* example reads the #AI_MATKEY_SHININESS_STRENGTH property of the first diffuse texture)
|
|
* @code
|
|
* float specStrength = 1.f; // default value, remains unmodified if we fail.
|
|
* aiGetMaterialFloat(mat, AI_MATKEY_SHININESS_STRENGTH,
|
|
* (float*)&specStrength);
|
|
* @endcode
|
|
*
|
|
* @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 Receives the output float.
|
|
* @param type (see the code sample above)
|
|
* @param index (see the code sample above)
|
|
* @return Specifies whether the key has been found. If not, the output
|
|
* float remains unmodified.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
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 //!__cplusplus
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Retrieve an array of integer values with a specific key
|
|
* from a material
|
|
*
|
|
* See the sample for aiGetMaterialFloatArray for more information.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
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
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Retrieve an integer property with a specific key from a material
|
|
*
|
|
* See the sample for aiGetMaterialFloat for more information.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
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 //!__cplusplus
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Retrieve a color value from the material property table
|
|
*
|
|
* See the sample for aiGetMaterialFloat for more information.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
ASSIMP_API C_ENUM aiReturn aiGetMaterialColor(const C_STRUCT aiMaterial* pMat,
|
|
const char* pKey,
|
|
unsigned int type,
|
|
unsigned int index,
|
|
C_STRUCT aiColor4D* pOut);
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Retrieve a string from the material property table
|
|
*
|
|
* See the sample for aiGetMaterialFloat for more information.
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
ASSIMP_API C_ENUM aiReturn aiGetMaterialString(const C_STRUCT aiMaterial* pMat,
|
|
const char* pKey,
|
|
unsigned int type,
|
|
unsigned int index,
|
|
C_STRUCT aiString* pOut);
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** @brief Helper function to get a texture from a material structure.
|
|
*
|
|
* This function is provided just for convenience.
|
|
* @param mat Pointer to the input material. May not be NULL
|
|
* @param index Index of the texture to retrieve. If the index is too
|
|
* large the function fails.
|
|
* @param type Specifies the type of the texture to retrieve (e.g. diffuse,
|
|
* specular, height map ...)
|
|
* @param path Receives the output path
|
|
* NULL is not allowed as value
|
|
* @param mapping The texture mapping.
|
|
* NULL is allowed as value.
|
|
* @param uvindex Receives the UV index of the texture.
|
|
* NULL is allowed as value.
|
|
* @param blend Receives the blend factor for the texture
|
|
* NULL is allowed as value.
|
|
* @param op Receives the texture operation to perform between
|
|
* this texture and the previous texture. NULL is allowed as value.
|
|
* @param mapmode Receives the mapping modes to be used for the texture.
|
|
* The parameter may be NULL but if it is a valid pointer it MUST
|
|
* point to an array of 3 aiTextureMapMode variables (one for each
|
|
* axis: UVW order (=XYZ)).
|
|
*/
|
|
// ---------------------------------------------------------------------------
|
|
#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);
|
|
#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*/);
|
|
#endif // !#ifdef __cplusplus
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
|
|
#include "aiMaterial.inl"
|
|
|
|
#endif //!__cplusplus
|
|
#endif //!!AI_MATERIAL_H_INC
|