delete src/mesh/assimp-master

1 files changed, 0 insertions, 1681 deletions

diff --git a/src/mesh/assimp-master/include/assimp/material.h b/src/mesh/assimp-master/include/assimp/material.h
deleted file mode 100644
index 416dbc4..0000000
--- a/src/mesh/assimp-master/include/assimp/material.h
+++ /dev/null
@@ -1,1681 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2022, 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.
----------------------------------------------------------------------------
-*/
-
-/** @file material.h
- *  @brief Defines the material system of the library
- */
-#pragma once
-#ifndef AI_MATERIAL_H_INC
-#define AI_MATERIAL_H_INC
-
-#ifdef __GNUC__
-#pragma GCC system_header
-#endif
-
-#include <assimp/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"
-
-// ---------------------------------------------------------------------------
-/** @brief Defines how the Nth texture of a specific type is combined with
- *  the result of all previous layers.
- *
- *  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,
-
-#ifndef SWIG
-    _aiTextureOp_Force32Bit = INT_MAX
-#endif
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Defines how UV coordinates outside the [0...1] range are handled.
- *
- *  Commonly referred to as 'wrapping mode'.
- */
-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,
-
-#ifndef SWIG
-    _aiTextureMapMode_Force32Bit = INT_MAX
-#endif
-};
-
-// ---------------------------------------------------------------------------
-/** @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.
-     *
-     *  #AI_MATKEY_UVWSRC property specifies from which UV channel
-     *  the texture coordinates are to be taken from (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,
-
-#ifndef SWIG
-    _aiTextureMapping_Force32Bit = INT_MAX
-#endif
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Defines the purpose of a texture
- *
- *  This is a very difficult topic. Different 3D packages support different
- *  kinds of textures. For very common texture types, such as bumpmaps, the
- *  rendering results depend on implementation details in the rendering
- *  pipelines of these applications. Assimp loads all texture references from
- *  the model file and tries to determine which of the predefined texture
- *  types below is the best choice to match the original use of the texture
- *  as closely as possible.<br>
- *
- *  In content pipelines you'll usually define how textures have to be handled,
- *  and the artists working on models have to conform to this specification,
- *  regardless which 3D tool they're using.
- */
-enum aiTextureType {
-    /** Dummy value.
-     *
-     *  No texture, but the value to be used as 'texture semantic'
-     *  (#aiMaterialProperty::mSemantic) for all material properties
-     *  *not* related to textures.
-     */
-    aiTextureType_NONE = 0,
-
-    /** LEGACY API MATERIALS
-     * Legacy refers to materials which
-     * Were originally implemented in the specifications around 2000.
-     * These must never be removed, as most engines support them.
-     */
-
-    /** The texture is combined with the result of the diffuse
-     *  lighting equation.
-     *  OR
-     *  PBR Specular/Glossiness
-     */
-    aiTextureType_DIFFUSE = 1,
-
-    /** The texture is combined with the result of the specular
-     *  lighting equation.
-     *  OR
-     *  PBR Specular/Glossiness
-     */
-    aiTextureType_SPECULAR = 2,
-
-    /** The texture is combined with the result of the ambient
-     *  lighting equation.
-     */
-    aiTextureType_AMBIENT = 3,
-
-    /** The texture is added to the result of the lighting
-     *  calculation. It isn't influenced by incoming light.
-     */
-    aiTextureType_EMISSIVE = 4,
-
-    /** The texture is a height map.
-     *
-     *  By convention, higher gray-scale values stand for
-     *  higher elevations from the base height.
-     */
-    aiTextureType_HEIGHT = 5,
-
-    /** The texture is a (tangent space) normal-map.
-     *
-     *  Again, there are several conventions for tangent-space
-     *  normal maps. Assimp does (intentionally) not
-     *  distinguish here.
-     */
-    aiTextureType_NORMALS = 6,
-
-    /** The texture defines the glossiness of the material.
-     *
-     *  The glossiness is in fact the exponent of the specular
-     *  (phong) lighting equation. Usually there is a conversion
-     *  function defined to map the linear color values in the
-     *  texture to a suitable exponent. Have fun.
-    */
-    aiTextureType_SHININESS = 7,
-
-    /** The texture defines per-pixel opacity.
-     *
-     *  Usually 'white' means opaque and 'black' means
-     *  'transparency'. Or quite the opposite. Have fun.
-    */
-    aiTextureType_OPACITY = 8,
-
-    /** Displacement texture
-     *
-     *  The exact purpose and format is application-dependent.
-     *  Higher color values stand for higher vertex displacements.
-    */
-    aiTextureType_DISPLACEMENT = 9,
-
-    /** Lightmap texture (aka Ambient Occlusion)
-     *
-     *  Both 'Lightmaps' and dedicated 'ambient occlusion maps' are
-     *  covered by this material property. The texture contains a
-     *  scaling value for the final color value of a pixel. Its
-     *  intensity is not affected by incoming light.
-    */
-    aiTextureType_LIGHTMAP = 10,
-
-    /** Reflection texture
-     *
-     * Contains the color of a perfect mirror reflection.
-     * Rarely used, almost never for real-time applications.
-    */
-    aiTextureType_REFLECTION = 11,
-
-    /** PBR Materials
-     * PBR definitions from maya and other modelling packages now use this standard.
-     * This was originally introduced around 2012.
-     * Support for this is in game engines like Godot, Unreal or Unity3D.
-     * Modelling packages which use this are very common now.
-     */
-
-    aiTextureType_BASE_COLOR = 12,
-    aiTextureType_NORMAL_CAMERA = 13,
-    aiTextureType_EMISSION_COLOR = 14,
-    aiTextureType_METALNESS = 15,
-    aiTextureType_DIFFUSE_ROUGHNESS = 16,
-    aiTextureType_AMBIENT_OCCLUSION = 17,
-
-    /** PBR Material Modifiers
-    * Some modern renderers have further PBR modifiers that may be overlaid
-    * on top of the 'base' PBR materials for additional realism.
-    * These use multiple texture maps, so only the base type is directly defined
-    */
-
-    /** Sheen
-    * Generally used to simulate textiles that are covered in a layer of microfibers
-    * eg velvet
-    * https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_sheen
-    */
-    aiTextureType_SHEEN = 19,
-
-    /** Clearcoat
-    * Simulates a layer of 'polish' or 'laquer' layered on top of a PBR substrate
-    * https://autodesk.github.io/standard-surface/#closures/coating
-    * https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
-    */
-    aiTextureType_CLEARCOAT = 20,
-
-    /** Transmission
-    * Simulates transmission through the surface
-    * May include further information such as wall thickness
-    */
-    aiTextureType_TRANSMISSION = 21,
-
-    /** Unknown texture
-     *
-     *  A texture reference that does not match any of the definitions
-     *  above is considered to be 'unknown'. It is still imported,
-     *  but is excluded from any further post-processing.
-    */
-    aiTextureType_UNKNOWN = 18,
-
-#ifndef SWIG
-    _aiTextureType_Force32Bit = INT_MAX
-#endif
-};
-
-#define AI_TEXTURE_TYPE_MAX aiTextureType_UNKNOWN
-
-// -------------------------------------------------------------------------------
-// Get a string for a given aiTextureType
-ASSIMP_API const char *TextureTypeToString(enum aiTextureType in);
-
-// ---------------------------------------------------------------------------
-/** @brief Defines all shading models supported by the library
- *
- *  Property: #AI_MATKEY_SHADING_MODEL
- *
- *  The list of shading modes has been taken from Blender.
- *  See Blender 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). <br>
- *  Again, this value is just a hint. Assimp tries to select the shader whose
- *  most common implementation matches the original rendering results of the
- *  3D modeler which wrote a particular model as closely as possible.
- *
- */
-enum aiShadingMode {
-    /** Flat shading. Shading is done on per-face base,
-     *  diffuse only. Also known as 'faceted shading'.
-     */
-    aiShadingMode_Flat = 0x1,
-
-    /** Simple Gouraud shading.
-     */
-    aiShadingMode_Gouraud = 0x2,
-
-    /** Phong-Shading -
-     */
-    aiShadingMode_Phong = 0x3,
-
-    /** Phong-Blinn-Shading
-     */
-    aiShadingMode_Blinn = 0x4,
-
-    /** Toon-Shading per pixel
-     *
-     *  Also known as 'comic' shader.
-     */
-    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
-     *
-     *  Special shader for metallic surfaces.
-     */
-    aiShadingMode_CookTorrance = 0x8,
-
-    /** No shading at all. Constant light influence of 1.0.
-    * Also known as "Unlit"
-    */
-    aiShadingMode_NoShading = 0x9,
-    aiShadingMode_Unlit = aiShadingMode_NoShading, // Alias
-
-    /** Fresnel shading
-     */
-    aiShadingMode_Fresnel = 0xa,
-
-    /** Physically-Based Rendering (PBR) shading using
-    * Bidirectional scattering/reflectance distribution function (BSDF/BRDF)
-    * There are multiple methods under this banner, and model files may provide
-    * data for more than one PBR-BRDF method.
-    * Applications should use the set of provided properties to determine which
-    * of their preferred PBR rendering methods are likely to be available
-    * eg:
-    * - If AI_MATKEY_METALLIC_FACTOR is set, then a Metallic/Roughness is available
-    * - If AI_MATKEY_GLOSSINESS_FACTOR is set, then a Specular/Glossiness is available
-    * Note that some PBR methods allow layering of techniques
-    */
-    aiShadingMode_PBR_BRDF = 0xb,
-
-#ifndef SWIG
-    _aiShadingMode_Force32Bit = INT_MAX
-#endif
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Defines some mixed flags for a particular texture.
- *
- *  Usually you'll instruct your cg artists how textures have to look like ...
- *  and how they will be processed in your application. However, if you use
- *  Assimp for completely generic loading purposes you might also need to
- *  process these flags in order to display as many 'unknown' 3D models as
- *  possible correctly.
- *
- *  This corresponds to the #AI_MATKEY_TEXFLAGS property.
-*/
-enum aiTextureFlags {
-    /** The texture's color values have to be inverted (component-wise 1-n)
-     */
-    aiTextureFlags_Invert = 0x1,
-
-    /** Explicit request to the application to process the alpha channel
-     *  of the texture.
-     *
-     *  Mutually exclusive with #aiTextureFlags_IgnoreAlpha. These
-     *  flags are set if the library can say for sure that the alpha
-     *  channel is used/is not used. If the model format does not
-     *  define this, it is left to the application to decide whether
-     *  the texture alpha channel - if any - is evaluated or not.
-     */
-    aiTextureFlags_UseAlpha = 0x2,
-
-    /** Explicit request to the application to ignore the alpha channel
-     *  of the texture.
-     *
-     *  Mutually exclusive with #aiTextureFlags_UseAlpha.
-     */
-    aiTextureFlags_IgnoreAlpha = 0x4,
-
-#ifndef SWIG
-    _aiTextureFlags_Force32Bit = INT_MAX
-#endif
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Defines alpha-blend flags.
- *
- *  If you're familiar with OpenGL or D3D, these flags aren't new to you.
- *  They define *how* the final color value of a pixel is computed, basing
- *  on the previous color at that pixel and the new color value from the
- *  material.
- *  The blend formula is:
- *  @code
- *    SourceColor * SourceBlend + DestColor * DestBlend
- *  @endcode
- *  where DestColor is the previous color in the frame-buffer at this
- *  position and SourceColor is the material color before the transparency
- *  calculation.<br>
- *  This corresponds to the #AI_MATKEY_BLEND_FUNC property.
-*/
-enum aiBlendMode {
-    /**
-     *  Formula:
-     *  @code
-     *  SourceColor*SourceAlpha + DestColor*(1-SourceAlpha)
-     *  @endcode
-     */
-    aiBlendMode_Default = 0x0,
-
-    /** Additive blending
-     *
-     *  Formula:
-     *  @code
-     *  SourceColor*1 + DestColor*1
-     *  @endcode
-     */
-    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"
-
-// ---------------------------------------------------------------------------
-/** @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.
-     *
-     *  The default value is (0|0).
-     */
-    C_STRUCT aiVector2D mTranslation;
-
-    /** Scaling on the u and v axes.
-     *
-     *  The default value is (1|1).
-     */
-    C_STRUCT aiVector2D mScaling;
-
-    /** Rotation - in counter-clockwise direction.
-     *
-     *  The rotation angle is specified in radians. The
-     *  rotation center is 0.5f|0.5f. The default value
-     *  0.f.
-     */
-    ai_real mRotation;
-
-#ifdef __cplusplus
-    aiUVTransform() AI_NO_EXCEPT
-            : mTranslation(0.0, 0.0),
-              mScaling(1.0, 1.0),
-              mRotation(0.0) {
-        // nothing to be done here ...
-    }
-#endif
-};
-
-#include "./Compiler/poppack1.h"
-
-//! @cond AI_DOX_INCLUDE_INTERNAL
-// ---------------------------------------------------------------------------
-/** @brief A very primitive RTTI system for the contents of material
- *  properties.
- */
-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,
-
-    /** Array of double-precision (64 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_Double = 0x2,
-
-    /** 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.
-     */
-#ifndef SWIG
-    _aiPTI_Force32Bit = INT_MAX
-#endif
-};
-
-// ---------------------------------------------------------------------------
-/** @brief Data structure for a single material property
- *
- *  As an user, you'll probably never need to deal with this data structure.
- *  Just use the provided aiGetMaterialXXX() or aiMaterial::Get() family
- *  of functions to query material properties easily. Processing them
- *  manually is faster, but it is not the recommended way. It isn't worth
- *  the effort. <br>
- *  Material property names follow a simple scheme:
- *  @code
- *    $<name>
- *    ?<name>
- *       A public property, there must be corresponding AI_MATKEY_XXX define
- *       2nd: Public, but ignored by the #aiProcess_RemoveRedundantMaterials
- *       post-processing step.
- *    ~<name>
- *       A temporary property for internal use.
- *  @endcode
- *  @see aiMaterial
- */
-struct aiMaterialProperty {
-    /** Specifies the name of the property (key)
-     *  Keys are generally case insensitive.
-     */
-    C_STRUCT aiString mKey;
-
-    /** Textures: Specifies their exact usage semantic.
-     * For non-texture properties, this member is always 0
-     * (or, better-said, #aiTextureType_NONE).
-     */
-    unsigned int mSemantic;
-
-    /** Textures: Specifies the index of the texture.
-     *  For non-texture properties, this member is always 0.
-     */
-    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 and to
-     * utilize proper type conversions.
-     * (It's probably a hacky solution, but it works.)
-     */
-    C_ENUM aiPropertyTypeInfo mType;
-
-    /** Binary buffer to hold the property's value.
-     * The size of the buffer is always mDataLength.
-     */
-    char *mData;
-
-#ifdef __cplusplus
-
-    aiMaterialProperty() AI_NO_EXCEPT
-            : mSemantic(0),
-              mIndex(0),
-              mDataLength(0),
-              mType(aiPTI_Float),
-              mData(nullptr) {
-        // empty
-    }
-
-    ~aiMaterialProperty() {
-        delete[] mData;
-        mData = nullptr;
-    }
-
-#endif
-};
-//! @endcond
-
-#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).
-*/
-#ifdef __cplusplus
-struct ASSIMP_API aiMaterial
-#else
-struct aiMaterial
-#endif
-{
-
-#ifdef __cplusplus
-
-public:
-    aiMaterial();
-    ~aiMaterial();
-
-    // -------------------------------------------------------------------
-    /**
-      * @brief  Returns the name of the material.
-      * @return The name of the material.
-      */
-    // -------------------------------------------------------------------
-    aiString GetName() const;
-
-    // -------------------------------------------------------------------
-    /** @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 .. set by AI_MATKEY_XXX
-     * @param idx .. set by AI_MATKEY_XXX
-     * @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;
-
-    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, ai_real *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;
-
-    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, ai_real &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;
-
-    // -------------------------------------------------------------------
-    /** Get the number of textures for a particular texture type.
-     *  @param type Texture type to check for
-     *  @return Number of textures for this type.
-     *  @note A texture can be easily queried using #GetTexture() */
-    unsigned int GetTextureCount(aiTextureType type) const;
-
-    // -------------------------------------------------------------------
-    /** Helper function to get all parameters pertaining to a
-     *  particular texture slot 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.
-     *    #GetTextureCount() can be used to determine the number of textures
-     *    per texture type.
-     *  @param path Receives the path to the texture.
-     *    Use aiScene::GetEmbeddedTexture() method to determine if returned path
-     *    is an image file to be opened or a string key of embedded texture stored in the corresponding scene
-     *    (could be a '*' followed by the id of the texture in case of no name)
-     *    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,
-            ai_real *blend = NULL,
-            aiTextureOp *op = NULL,
-            aiTextureMapMode *mapmode = NULL) const;
-
-    // Setters
-
-    // ------------------------------------------------------------------------------
-    /** @brief Add a property with a given key and type info to the material
-     *  structure
-     *
-     *  @param pInput Pointer to input data
-     *  @param pSizeInBytes Size of input data
-     *  @param pKey Key/Usage of the property (AI_MATKEY_XXX)
-     *  @param type Set by the AI_MATKEY_XXX macro
-     *  @param index Set by the AI_MATKEY_XXX macro
-     *  @param pType Type information hint */
-    aiReturn AddBinaryProperty(const void *pInput,
-            unsigned int pSizeInBytes,
-            const char *pKey,
-            unsigned int type,
-            unsigned int index,
-            aiPropertyTypeInfo pType);
-
-    // ------------------------------------------------------------------------------
-    /** @brief Add a string property with a given key and type info to the
-     *  material structure
-     *
-     *  @param pInput Input string
-     *  @param pKey Key/Usage of the property (AI_MATKEY_XXX)
-     *  @param type Set by the AI_MATKEY_XXX macro
-     *  @param index Set by the AI_MATKEY_XXX macro */
-    aiReturn AddProperty(const aiString *pInput,
-            const char *pKey,
-            unsigned int type = 0,
-            unsigned int index = 0);
-
-    // ------------------------------------------------------------------------------
-    /** @brief Add a property with a given key to the material structure
-     *  @param pInput Pointer to the input data
-     *  @param pNumValues Number of values in the array
-     *  @param pKey Key/Usage of the property (AI_MATKEY_XXX)
-     *  @param type Set by the AI_MATKEY_XXX macro
-     *  @param index Set by the AI_MATKEY_XXX macro  */
-    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 double *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);
-
-    // ------------------------------------------------------------------------------
-    /** @brief Remove a given key from the list.
-     *
-     *  The function fails if the key isn't found
-     *  @param pKey Key to be deleted
-     *  @param type Set by the AI_MATKEY_XXX macro
-     *  @param index Set by the AI_MATKEY_XXX macro  */
-    aiReturn RemoveProperty(const char *pKey,
-            unsigned int type = 0,
-            unsigned int index = 0);
-
-    // ------------------------------------------------------------------------------
-    /** @brief Removes all properties from the material.
-     *
-     *  The data array remains allocated so adding new properties is quite fast.  */
-    void Clear();
-
-    // ------------------------------------------------------------------------------
-    /** Copy the property list of a material
-     *  @param pcDest Destination material
-     *  @param pcSrc Source material
-     */
-    static void CopyPropertyList(aiMaterial *pcDest,
-            const aiMaterial *pcSrc);
-
-#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
-
-// ---------------------------------------------------------------------------
-#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_TRANSPARENCYFACTOR "$mat.transparencyfactor", 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
-#define AI_MATKEY_GLOBAL_SHADERLANG "?sh.lang", 0, 0
-#define AI_MATKEY_SHADER_VERTEX "?sh.vs", 0, 0
-#define AI_MATKEY_SHADER_FRAGMENT "?sh.fs", 0, 0
-#define AI_MATKEY_SHADER_GEO "?sh.gs", 0, 0
-#define AI_MATKEY_SHADER_TESSELATION "?sh.ts", 0, 0
-#define AI_MATKEY_SHADER_PRIMITIVE "?sh.ps", 0, 0
-#define AI_MATKEY_SHADER_COMPUTE "?sh.cs", 0, 0
-
-// ---------------------------------------------------------------------------
-// PBR material support
-// --------------------
-// Properties defining PBR rendering techniques
-#define AI_MATKEY_USE_COLOR_MAP "$mat.useColorMap", 0, 0
-
-// Metallic/Roughness Workflow
-// ---------------------------
-// Base RGBA color factor. Will be multiplied by final base color texture values if extant
-// Note: Importers may choose to copy this into AI_MATKEY_COLOR_DIFFUSE for compatibility
-// with renderers and formats that do not support Metallic/Roughness PBR
-#define AI_MATKEY_BASE_COLOR "$clr.base", 0, 0
-#define AI_MATKEY_BASE_COLOR_TEXTURE aiTextureType_BASE_COLOR, 0
-#define AI_MATKEY_USE_METALLIC_MAP "$mat.useMetallicMap", 0, 0
-// Metallic factor. 0.0 = Full Dielectric, 1.0 = Full Metal
-#define AI_MATKEY_METALLIC_FACTOR "$mat.metallicFactor", 0, 0
-#define AI_MATKEY_METALLIC_TEXTURE aiTextureType_METALNESS, 0
-#define AI_MATKEY_USE_ROUGHNESS_MAP "$mat.useRoughnessMap", 0, 0
-// Roughness factor. 0.0 = Perfectly Smooth, 1.0 = Completely Rough
-#define AI_MATKEY_ROUGHNESS_FACTOR "$mat.roughnessFactor", 0, 0
-#define AI_MATKEY_ROUGHNESS_TEXTURE aiTextureType_DIFFUSE_ROUGHNESS, 0
-// Anisotropy factor. 0.0 = isotropic, 1.0 = anisotropy along tangent direction,
-// -1.0 = anisotropy along bitangent direction
-#define AI_MATKEY_ANISOTROPY_FACTOR "$mat.anisotropyFactor", 0, 0
-
-// Specular/Glossiness Workflow
-// ---------------------------
-// Diffuse/Albedo Color. Note: Pure Metals have a diffuse of {0,0,0}
-// AI_MATKEY_COLOR_DIFFUSE
-// Specular Color.
-// Note: Metallic/Roughness may also have a Specular Color
-// AI_MATKEY_COLOR_SPECULAR
-#define AI_MATKEY_SPECULAR_FACTOR "$mat.specularFactor", 0, 0
-// Glossiness factor. 0.0 = Completely Rough, 1.0 = Perfectly Smooth
-#define AI_MATKEY_GLOSSINESS_FACTOR "$mat.glossinessFactor", 0, 0
-
-// Sheen
-// -----
-// Sheen base RGB color. Default {0,0,0}
-#define AI_MATKEY_SHEEN_COLOR_FACTOR "$clr.sheen.factor", 0, 0
-// Sheen Roughness Factor.
-#define AI_MATKEY_SHEEN_ROUGHNESS_FACTOR "$mat.sheen.roughnessFactor", 0, 0
-#define AI_MATKEY_SHEEN_COLOR_TEXTURE aiTextureType_SHEEN, 0
-#define AI_MATKEY_SHEEN_ROUGHNESS_TEXTURE aiTextureType_SHEEN, 1
-
-// Clearcoat
-// ---------
-// Clearcoat layer intensity. 0.0 = none (disabled)
-#define AI_MATKEY_CLEARCOAT_FACTOR "$mat.clearcoat.factor", 0, 0
-#define AI_MATKEY_CLEARCOAT_ROUGHNESS_FACTOR "$mat.clearcoat.roughnessFactor", 0, 0
-#define AI_MATKEY_CLEARCOAT_TEXTURE aiTextureType_CLEARCOAT, 0
-#define AI_MATKEY_CLEARCOAT_ROUGHNESS_TEXTURE aiTextureType_CLEARCOAT, 1
-#define AI_MATKEY_CLEARCOAT_NORMAL_TEXTURE aiTextureType_CLEARCOAT, 2
-
-// Transmission
-// ------------
-// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission
-// Base percentage of light transmitted through the surface. 0.0 = Opaque, 1.0 = Fully transparent
-#define AI_MATKEY_TRANSMISSION_FACTOR "$mat.transmission.factor", 0, 0
-// Texture defining percentage of light transmitted through the surface.
-// Multiplied by AI_MATKEY_TRANSMISSION_FACTOR
-#define AI_MATKEY_TRANSMISSION_TEXTURE aiTextureType_TRANSMISSION, 0
-
-// Volume
-// ------------
-// https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_volume
-// The thickness of the volume beneath the surface. If the value is 0 the material is thin-walled. Otherwise the material is a volume boundary.
-#define AI_MATKEY_VOLUME_THICKNESS_FACTOR "$mat.volume.thicknessFactor", 0, 0
-// Texture that defines the thickness.
-// Multiplied by AI_MATKEY_THICKNESS_FACTOR
-#define AI_MATKEY_VOLUME_THICKNESS_TEXTURE aiTextureType_TRANSMISSION, 1
-// Density of the medium given as the average distance that light travels in the medium before interacting with a particle.
-#define AI_MATKEY_VOLUME_ATTENUATION_DISTANCE "$mat.volume.attenuationDistance", 0, 0
-// The color that white light turns into due to absorption when reaching the attenuation distance.
-#define AI_MATKEY_VOLUME_ATTENUATION_COLOR "$mat.volume.attenuationColor", 0, 0
-
-// Emissive
-// --------
-#define AI_MATKEY_USE_EMISSIVE_MAP "$mat.useEmissiveMap", 0, 0
-#define AI_MATKEY_EMISSIVE_INTENSITY "$mat.emissiveIntensity", 0, 0
-#define AI_MATKEY_USE_AO_MAP "$mat.useAOMap", 0, 0
-
-// ---------------------------------------------------------------------------
-// Pure key names for all texture-related properties
-//! @cond MATS_DOC_FULL
-#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"
-//! @endcond
-
-// ---------------------------------------------------------------------------
-#define AI_MATKEY_TEXTURE(type, N) _AI_MATKEY_TEXTURE_BASE, type, N
-
-// For backward compatibility and simplicity
-//! @cond MATS_DOC_FULL
-#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)
-
-//! @endcond
-
-// ---------------------------------------------------------------------------
-#define AI_MATKEY_UVWSRC(type, N) _AI_MATKEY_UVWSRC_BASE, type, N
-
-// For backward compatibility and simplicity
-//! @cond MATS_DOC_FULL
-#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)
-
-//! @endcond
-// ---------------------------------------------------------------------------
-#define AI_MATKEY_TEXOP(type, N) _AI_MATKEY_TEXOP_BASE, type, N
-
-// For backward compatibility and simplicity
-//! @cond MATS_DOC_FULL
-#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)
-
-//! @endcond
-// ---------------------------------------------------------------------------
-#define AI_MATKEY_MAPPING(type, N) _AI_MATKEY_MAPPING_BASE, type, N
-
-// For backward compatibility and simplicity
-//! @cond MATS_DOC_FULL
-#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)
-
-//! @endcond
-// ---------------------------------------------------------------------------
-#define AI_MATKEY_TEXBLEND(type, N) _AI_MATKEY_TEXBLEND_BASE, type, N
-
-// For backward compatibility and simplicity
-//! @cond MATS_DOC_FULL
-#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)
-
-//! @endcond
-// ---------------------------------------------------------------------------
-#define AI_MATKEY_MAPPINGMODE_U(type, N) _AI_MATKEY_MAPPINGMODE_U_BASE, type, N
-
-// For backward compatibility and simplicity
-//! @cond MATS_DOC_FULL
-#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)
-
-//! @endcond
-// ---------------------------------------------------------------------------
-#define AI_MATKEY_MAPPINGMODE_V(type, N) _AI_MATKEY_MAPPINGMODE_V_BASE, type, N
-
-// For backward compatibility and simplicity
-//! @cond MATS_DOC_FULL
-#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)
-
-//! @endcond
-// ---------------------------------------------------------------------------
-#define AI_MATKEY_TEXMAP_AXIS(type, N) _AI_MATKEY_TEXMAP_AXIS_BASE, type, N
-
-// For backward compatibility and simplicity
-//! @cond MATS_DOC_FULL
-#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)
-
-//! @endcond
-// ---------------------------------------------------------------------------
-#define AI_MATKEY_UVTRANSFORM(type, N) _AI_MATKEY_UVTRANSFORM_BASE, type, N
-
-// For backward compatibility and simplicity
-//! @cond MATS_DOC_FULL
-#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)
-
-//! @endcond
-// ---------------------------------------------------------------------------
-#define AI_MATKEY_TEXFLAGS(type, N) _AI_MATKEY_TEXFLAGS_BASE, type, N
-
-// For backward compatibility and simplicity
-//! @cond MATS_DOC_FULL
-#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)
-
-//! @endcond
-//!
-// ---------------------------------------------------------------------------
-/** @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,
-        unsigned int 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,
-        ai_real *pOut,
-        unsigned int *pMax);
-
-// ---------------------------------------------------------------------------
-/** @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 C_STRUCT aiMaterial *pMat,
-        const char *pKey,
-        unsigned int type,
-        unsigned int index,
-        ai_real *pOut) {
-    return aiGetMaterialFloatArray(pMat, pKey, type, index, pOut, (unsigned int *)0x0);
-}
-
-// ---------------------------------------------------------------------------
-/** @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);
-
-// ---------------------------------------------------------------------------
-/** @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);
-}
-
-// ---------------------------------------------------------------------------
-/** @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 aiUVTransform value from the material property table
-*
-* See the sample for aiGetMaterialFloat for more information*/
-// ---------------------------------------------------------------------------
-ASSIMP_API C_ENUM aiReturn aiGetMaterialUVTransform(const C_STRUCT aiMaterial *pMat,
-        const char *pKey,
-        unsigned int type,
-        unsigned int index,
-        C_STRUCT aiUVTransform *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);
-
-// ---------------------------------------------------------------------------
-/** Get the number of textures for a particular texture type.
- *  @param[in] pMat Pointer to the input material. May not be NULL
- *  @param type Texture type to check for
- *  @return Number of textures for this type.
- *  @note A texture can be easily queried using #aiGetMaterialTexture() */
-// ---------------------------------------------------------------------------
-ASSIMP_API unsigned int aiGetMaterialTextureCount(const C_STRUCT aiMaterial *pMat,
-        C_ENUM aiTextureType type);
-
-// ---------------------------------------------------------------------------
-/** @brief Helper function to get all values pertaining to a particular
- *  texture slot from a material structure.
- *
- *  This function is provided just for convenience. You could also read the
- *  texture by parsing all of its properties manually. This function bundles
- *  all of them in a huge function monster.
- *
- *  @param[in] mat Pointer to the input material. May not be NULL
- *  @param[in] type Specifies the texture stack to read from (e.g. diffuse,
- *     specular, height map ...).
- *  @param[in] index Index of the texture. The function fails if the
- *     requested index is not available for this texture type.
- *     #aiGetMaterialTextureCount() can be used to determine the number of
- *     textures in a particular texture stack.
- *  @param[out] path Receives the output path
- *     If the texture is embedded, receives a '*' followed by the id of
- *     the texture (for the textures stored in the corresponding scene) which
- *     can be converted to an int using a function like atoi.
- *     This parameter must be non-null.
- *  @param mapping The texture mapping mode to be used.
- *      Pass NULL if you're not interested in this information.
- *  @param[out] uvindex For UV-mapped textures: receives the index of the UV
- *      source channel. Unmodified otherwise.
- *      Pass NULL if you're not interested in this information.
- *  @param[out] blend Receives the blend factor for the texture
- *      Pass NULL if you're not interested in this information.
- *  @param[out] op Receives the texture blend operation to be perform between
- *      this texture and the previous texture.
- *      Pass NULL if you're not interested in this information.
- *  @param[out] mapmode Receives the mapping modes to be used for the texture.
- *      Pass NULL if you're not interested in this information. Otherwise,
- *      pass a pointer to an array of two aiTextureMapMode's (one for each
- *      axis, UV order).
- *  @param[out] flags Receives the the texture flags.
- *  @return AI_SUCCESS on success, otherwise something else. Have fun.*/
-// ---------------------------------------------------------------------------
-#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,
-        ai_real *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*/,
-        ai_real *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 //!__cplusplus
-
-#endif //!!AI_MATERIAL_H_INC