vrshoot

annotate libs/assimp/assimp/material.h @ 0:b2f14e535253

find changesets by author, revision, files, or words in the commit message
initial commit
author John Tsiombikas <nuclear@member.fsf.org>
date Sat, 01 Feb 2014 19:58:19 +0200
parents
children
rev   line source
nuclear@0 1 /*
nuclear@0 2 ---------------------------------------------------------------------------
nuclear@0 3 Open Asset Import Library (assimp)
nuclear@0 4 ---------------------------------------------------------------------------
nuclear@0 5
nuclear@0 6 Copyright (c) 2006-2012, assimp team
nuclear@0 7
nuclear@0 8 All rights reserved.
nuclear@0 9
nuclear@0 10 Redistribution and use of this software in source and binary forms,
nuclear@0 11 with or without modification, are permitted provided that the following
nuclear@0 12 conditions are met:
nuclear@0 13
nuclear@0 14 * Redistributions of source code must retain the above
nuclear@0 15 copyright notice, this list of conditions and the
nuclear@0 16 following disclaimer.
nuclear@0 17
nuclear@0 18 * Redistributions in binary form must reproduce the above
nuclear@0 19 copyright notice, this list of conditions and the
nuclear@0 20 following disclaimer in the documentation and/or other
nuclear@0 21 materials provided with the distribution.
nuclear@0 22
nuclear@0 23 * Neither the name of the assimp team, nor the names of its
nuclear@0 24 contributors may be used to endorse or promote products
nuclear@0 25 derived from this software without specific prior
nuclear@0 26 written permission of the assimp team.
nuclear@0 27
nuclear@0 28 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
nuclear@0 29 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
nuclear@0 30 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
nuclear@0 31 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
nuclear@0 32 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
nuclear@0 33 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
nuclear@0 34 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
nuclear@0 35 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
nuclear@0 36 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
nuclear@0 37 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
nuclear@0 38 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
nuclear@0 39 ---------------------------------------------------------------------------
nuclear@0 40 */
nuclear@0 41
nuclear@0 42 /** @file material.h
nuclear@0 43 * @brief Defines the material system of the library
nuclear@0 44 */
nuclear@0 45
nuclear@0 46 #ifndef AI_MATERIAL_H_INC
nuclear@0 47 #define AI_MATERIAL_H_INC
nuclear@0 48
nuclear@0 49 #include "types.h"
nuclear@0 50
nuclear@0 51 #ifdef __cplusplus
nuclear@0 52 extern "C" {
nuclear@0 53 #endif
nuclear@0 54
nuclear@0 55 // Name for default materials (2nd is used if meshes have UV coords)
nuclear@0 56 #define AI_DEFAULT_MATERIAL_NAME "DefaultMaterial"
nuclear@0 57
nuclear@0 58 // ---------------------------------------------------------------------------
nuclear@0 59 /** @brief Defines how the Nth texture of a specific type is combined with
nuclear@0 60 * the result of all previous layers.
nuclear@0 61 *
nuclear@0 62 * Example (left: key, right: value): <br>
nuclear@0 63 * @code
nuclear@0 64 * DiffColor0 - gray
nuclear@0 65 * DiffTextureOp0 - aiTextureOpMultiply
nuclear@0 66 * DiffTexture0 - tex1.png
nuclear@0 67 * DiffTextureOp0 - aiTextureOpAdd
nuclear@0 68 * DiffTexture1 - tex2.png
nuclear@0 69 * @endcode
nuclear@0 70 * Written as equation, the final diffuse term for a specific pixel would be:
nuclear@0 71 * @code
nuclear@0 72 * diffFinal = DiffColor0 * sampleTex(DiffTexture0,UV0) +
nuclear@0 73 * sampleTex(DiffTexture1,UV0) * diffContrib;
nuclear@0 74 * @endcode
nuclear@0 75 * where 'diffContrib' is the intensity of the incoming light for that pixel.
nuclear@0 76 */
nuclear@0 77 enum aiTextureOp
nuclear@0 78 {
nuclear@0 79 /** T = T1 * T2 */
nuclear@0 80 aiTextureOp_Multiply = 0x0,
nuclear@0 81
nuclear@0 82 /** T = T1 + T2 */
nuclear@0 83 aiTextureOp_Add = 0x1,
nuclear@0 84
nuclear@0 85 /** T = T1 - T2 */
nuclear@0 86 aiTextureOp_Subtract = 0x2,
nuclear@0 87
nuclear@0 88 /** T = T1 / T2 */
nuclear@0 89 aiTextureOp_Divide = 0x3,
nuclear@0 90
nuclear@0 91 /** T = (T1 + T2) - (T1 * T2) */
nuclear@0 92 aiTextureOp_SmoothAdd = 0x4,
nuclear@0 93
nuclear@0 94 /** T = T1 + (T2-0.5) */
nuclear@0 95 aiTextureOp_SignedAdd = 0x5,
nuclear@0 96
nuclear@0 97
nuclear@0 98 /** @cond never
nuclear@0 99 * This value is not used. It forces the compiler to use at least
nuclear@0 100 * 32 Bit integers to represent this enum.
nuclear@0 101 */
nuclear@0 102 #ifndef SWIG
nuclear@0 103 _aiTextureOp_Force32Bit = INT_MAX
nuclear@0 104 #endif
nuclear@0 105 //! @endcond
nuclear@0 106 };
nuclear@0 107
nuclear@0 108 // ---------------------------------------------------------------------------
nuclear@0 109 /** @brief Defines how UV coordinates outside the [0...1] range are handled.
nuclear@0 110 *
nuclear@0 111 * Commonly refered to as 'wrapping mode'.
nuclear@0 112 */
nuclear@0 113 enum aiTextureMapMode
nuclear@0 114 {
nuclear@0 115 /** A texture coordinate u|v is translated to u%1|v%1
nuclear@0 116 */
nuclear@0 117 aiTextureMapMode_Wrap = 0x0,
nuclear@0 118
nuclear@0 119 /** Texture coordinates outside [0...1]
nuclear@0 120 * are clamped to the nearest valid value.
nuclear@0 121 */
nuclear@0 122 aiTextureMapMode_Clamp = 0x1,
nuclear@0 123
nuclear@0 124 /** If the texture coordinates for a pixel are outside [0...1]
nuclear@0 125 * the texture is not applied to that pixel
nuclear@0 126 */
nuclear@0 127 aiTextureMapMode_Decal = 0x3,
nuclear@0 128
nuclear@0 129 /** A texture coordinate u|v becomes u%1|v%1 if (u-(u%1))%2 is zero and
nuclear@0 130 * 1-(u%1)|1-(v%1) otherwise
nuclear@0 131 */
nuclear@0 132 aiTextureMapMode_Mirror = 0x2,
nuclear@0 133
nuclear@0 134 /** @cond never
nuclear@0 135 * This value is not used. It forces the compiler to use at least
nuclear@0 136 * 32 Bit integers to represent this enum.
nuclear@0 137 */
nuclear@0 138 #ifndef SWIG
nuclear@0 139 _aiTextureMapMode_Force32Bit = INT_MAX
nuclear@0 140 #endif
nuclear@0 141 //! @endcond
nuclear@0 142 };
nuclear@0 143
nuclear@0 144 // ---------------------------------------------------------------------------
nuclear@0 145 /** @brief Defines how the mapping coords for a texture are generated.
nuclear@0 146 *
nuclear@0 147 * Real-time applications typically require full UV coordinates, so the use of
nuclear@0 148 * the aiProcess_GenUVCoords step is highly recommended. It generates proper
nuclear@0 149 * UV channels for non-UV mapped objects, as long as an accurate description
nuclear@0 150 * how the mapping should look like (e.g spherical) is given.
nuclear@0 151 * See the #AI_MATKEY_MAPPING property for more details.
nuclear@0 152 */
nuclear@0 153 enum aiTextureMapping
nuclear@0 154 {
nuclear@0 155 /** The mapping coordinates are taken from an UV channel.
nuclear@0 156 *
nuclear@0 157 * The #AI_MATKEY_UVWSRC key specifies from which UV channel
nuclear@0 158 * the texture coordinates are to be taken from (remember,
nuclear@0 159 * meshes can have more than one UV channel).
nuclear@0 160 */
nuclear@0 161 aiTextureMapping_UV = 0x0,
nuclear@0 162
nuclear@0 163 /** Spherical mapping */
nuclear@0 164 aiTextureMapping_SPHERE = 0x1,
nuclear@0 165
nuclear@0 166 /** Cylindrical mapping */
nuclear@0 167 aiTextureMapping_CYLINDER = 0x2,
nuclear@0 168
nuclear@0 169 /** Cubic mapping */
nuclear@0 170 aiTextureMapping_BOX = 0x3,
nuclear@0 171
nuclear@0 172 /** Planar mapping */
nuclear@0 173 aiTextureMapping_PLANE = 0x4,
nuclear@0 174
nuclear@0 175 /** Undefined mapping. Have fun. */
nuclear@0 176 aiTextureMapping_OTHER = 0x5,
nuclear@0 177
nuclear@0 178
nuclear@0 179 /** @cond never
nuclear@0 180 * This value is not used. It forces the compiler to use at least
nuclear@0 181 * 32 Bit integers to represent this enum.
nuclear@0 182 */
nuclear@0 183 #ifndef SWIG
nuclear@0 184 _aiTextureMapping_Force32Bit = INT_MAX
nuclear@0 185 #endif
nuclear@0 186 //! @endcond
nuclear@0 187 };
nuclear@0 188
nuclear@0 189 // ---------------------------------------------------------------------------
nuclear@0 190 /** @brief Defines the purpose of a texture
nuclear@0 191 *
nuclear@0 192 * This is a very difficult topic. Different 3D packages support different
nuclear@0 193 * kinds of textures. For very common texture types, such as bumpmaps, the
nuclear@0 194 * rendering results depend on implementation details in the rendering
nuclear@0 195 * pipelines of these applications. Assimp loads all texture references from
nuclear@0 196 * the model file and tries to determine which of the predefined texture
nuclear@0 197 * types below is the best choice to match the original use of the texture
nuclear@0 198 * as closely as possible.<br>
nuclear@0 199 *
nuclear@0 200 * In content pipelines you'll usually define how textures have to be handled,
nuclear@0 201 * and the artists working on models have to conform to this specification,
nuclear@0 202 * regardless which 3D tool they're using.
nuclear@0 203 */
nuclear@0 204 enum aiTextureType
nuclear@0 205 {
nuclear@0 206 /** Dummy value.
nuclear@0 207 *
nuclear@0 208 * No texture, but the value to be used as 'texture semantic'
nuclear@0 209 * (#aiMaterialProperty::mSemantic) for all material properties
nuclear@0 210 * *not* related to textures.
nuclear@0 211 */
nuclear@0 212 aiTextureType_NONE = 0x0,
nuclear@0 213
nuclear@0 214
nuclear@0 215
nuclear@0 216 /** The texture is combined with the result of the diffuse
nuclear@0 217 * lighting equation.
nuclear@0 218 */
nuclear@0 219 aiTextureType_DIFFUSE = 0x1,
nuclear@0 220
nuclear@0 221 /** The texture is combined with the result of the specular
nuclear@0 222 * lighting equation.
nuclear@0 223 */
nuclear@0 224 aiTextureType_SPECULAR = 0x2,
nuclear@0 225
nuclear@0 226 /** The texture is combined with the result of the ambient
nuclear@0 227 * lighting equation.
nuclear@0 228 */
nuclear@0 229 aiTextureType_AMBIENT = 0x3,
nuclear@0 230
nuclear@0 231 /** The texture is added to the result of the lighting
nuclear@0 232 * calculation. It isn't influenced by incoming light.
nuclear@0 233 */
nuclear@0 234 aiTextureType_EMISSIVE = 0x4,
nuclear@0 235
nuclear@0 236 /** The texture is a height map.
nuclear@0 237 *
nuclear@0 238 * By convention, higher gray-scale values stand for
nuclear@0 239 * higher elevations from the base height.
nuclear@0 240 */
nuclear@0 241 aiTextureType_HEIGHT = 0x5,
nuclear@0 242
nuclear@0 243 /** The texture is a (tangent space) normal-map.
nuclear@0 244 *
nuclear@0 245 * Again, there are several conventions for tangent-space
nuclear@0 246 * normal maps. Assimp does (intentionally) not
nuclear@0 247 * distinguish here.
nuclear@0 248 */
nuclear@0 249 aiTextureType_NORMALS = 0x6,
nuclear@0 250
nuclear@0 251 /** The texture defines the glossiness of the material.
nuclear@0 252 *
nuclear@0 253 * The glossiness is in fact the exponent of the specular
nuclear@0 254 * (phong) lighting equation. Usually there is a conversion
nuclear@0 255 * function defined to map the linear color values in the
nuclear@0 256 * texture to a suitable exponent. Have fun.
nuclear@0 257 */
nuclear@0 258 aiTextureType_SHININESS = 0x7,
nuclear@0 259
nuclear@0 260 /** The texture defines per-pixel opacity.
nuclear@0 261 *
nuclear@0 262 * Usually 'white' means opaque and 'black' means
nuclear@0 263 * 'transparency'. Or quite the opposite. Have fun.
nuclear@0 264 */
nuclear@0 265 aiTextureType_OPACITY = 0x8,
nuclear@0 266
nuclear@0 267 /** Displacement texture
nuclear@0 268 *
nuclear@0 269 * The exact purpose and format is application-dependent.
nuclear@0 270 * Higher color values stand for higher vertex displacements.
nuclear@0 271 */
nuclear@0 272 aiTextureType_DISPLACEMENT = 0x9,
nuclear@0 273
nuclear@0 274 /** Lightmap texture (aka Ambient Occlusion)
nuclear@0 275 *
nuclear@0 276 * Both 'Lightmaps' and dedicated 'ambient occlusion maps' are
nuclear@0 277 * covered by this material property. The texture contains a
nuclear@0 278 * scaling value for the final color value of a pixel. Its
nuclear@0 279 * intensity is not affected by incoming light.
nuclear@0 280 */
nuclear@0 281 aiTextureType_LIGHTMAP = 0xA,
nuclear@0 282
nuclear@0 283 /** Reflection texture
nuclear@0 284 *
nuclear@0 285 * Contains the color of a perfect mirror reflection.
nuclear@0 286 * Rarely used, almost never for real-time applications.
nuclear@0 287 */
nuclear@0 288 aiTextureType_REFLECTION = 0xB,
nuclear@0 289
nuclear@0 290 /** Unknown texture
nuclear@0 291 *
nuclear@0 292 * A texture reference that does not match any of the definitions
nuclear@0 293 * above is considered to be 'unknown'. It is still imported,
nuclear@0 294 * but is excluded from any further postprocessing.
nuclear@0 295 */
nuclear@0 296 aiTextureType_UNKNOWN = 0xC,
nuclear@0 297
nuclear@0 298
nuclear@0 299 /** @cond never
nuclear@0 300 * This value is not used. It forces the compiler to use at least
nuclear@0 301 * 32 Bit integers to represent this enum.
nuclear@0 302 */
nuclear@0 303 #ifndef SWIG
nuclear@0 304 _aiTextureType_Force32Bit = INT_MAX
nuclear@0 305 #endif
nuclear@0 306 //! @endcond
nuclear@0 307 };
nuclear@0 308
nuclear@0 309 #define AI_TEXTURE_TYPE_MAX aiTextureType_UNKNOWN
nuclear@0 310
nuclear@0 311 // ---------------------------------------------------------------------------
nuclear@0 312 /** @brief Defines all shading models supported by the library
nuclear@0 313 *
nuclear@0 314 * The list of shading modes has been taken from Blender.
nuclear@0 315 * See Blender documentation for more information. The API does
nuclear@0 316 * not distinguish between "specular" and "diffuse" shaders (thus the
nuclear@0 317 * specular term for diffuse shading models like Oren-Nayar remains
nuclear@0 318 * undefined). <br>
nuclear@0 319 * Again, this value is just a hint. Assimp tries to select the shader whose
nuclear@0 320 * most common implementation matches the original rendering results of the
nuclear@0 321 * 3D modeller which wrote a particular model as closely as possible.
nuclear@0 322 */
nuclear@0 323 enum aiShadingMode
nuclear@0 324 {
nuclear@0 325 /** Flat shading. Shading is done on per-face base,
nuclear@0 326 * diffuse only. Also known as 'faceted shading'.
nuclear@0 327 */
nuclear@0 328 aiShadingMode_Flat = 0x1,
nuclear@0 329
nuclear@0 330 /** Simple Gouraud shading.
nuclear@0 331 */
nuclear@0 332 aiShadingMode_Gouraud = 0x2,
nuclear@0 333
nuclear@0 334 /** Phong-Shading -
nuclear@0 335 */
nuclear@0 336 aiShadingMode_Phong = 0x3,
nuclear@0 337
nuclear@0 338 /** Phong-Blinn-Shading
nuclear@0 339 */
nuclear@0 340 aiShadingMode_Blinn = 0x4,
nuclear@0 341
nuclear@0 342 /** Toon-Shading per pixel
nuclear@0 343 *
nuclear@0 344 * Also known as 'comic' shader.
nuclear@0 345 */
nuclear@0 346 aiShadingMode_Toon = 0x5,
nuclear@0 347
nuclear@0 348 /** OrenNayar-Shading per pixel
nuclear@0 349 *
nuclear@0 350 * Extension to standard Lambertian shading, taking the
nuclear@0 351 * roughness of the material into account
nuclear@0 352 */
nuclear@0 353 aiShadingMode_OrenNayar = 0x6,
nuclear@0 354
nuclear@0 355 /** Minnaert-Shading per pixel
nuclear@0 356 *
nuclear@0 357 * Extension to standard Lambertian shading, taking the
nuclear@0 358 * "darkness" of the material into account
nuclear@0 359 */
nuclear@0 360 aiShadingMode_Minnaert = 0x7,
nuclear@0 361
nuclear@0 362 /** CookTorrance-Shading per pixel
nuclear@0 363 *
nuclear@0 364 * Special shader for metallic surfaces.
nuclear@0 365 */
nuclear@0 366 aiShadingMode_CookTorrance = 0x8,
nuclear@0 367
nuclear@0 368 /** No shading at all. Constant light influence of 1.0.
nuclear@0 369 */
nuclear@0 370 aiShadingMode_NoShading = 0x9,
nuclear@0 371
nuclear@0 372 /** Fresnel shading
nuclear@0 373 */
nuclear@0 374 aiShadingMode_Fresnel = 0xa,
nuclear@0 375
nuclear@0 376
nuclear@0 377 /** @cond never
nuclear@0 378 * This value is not used. It forces the compiler to use at least
nuclear@0 379 * 32 Bit integers to represent this enum.
nuclear@0 380 */
nuclear@0 381 #ifndef SWIG
nuclear@0 382 _aiShadingMode_Force32Bit = INT_MAX
nuclear@0 383 #endif
nuclear@0 384 //! @endcond
nuclear@0 385 };
nuclear@0 386
nuclear@0 387
nuclear@0 388 // ---------------------------------------------------------------------------
nuclear@0 389 /** @brief Defines some mixed flags for a particular texture.
nuclear@0 390 *
nuclear@0 391 * Usually you'll instruct your cg artists how textures have to look like ...
nuclear@0 392 * and how they will be processed in your application. However, if you use
nuclear@0 393 * Assimp for completely generic loading purposes you might also need to
nuclear@0 394 * process these flags in order to display as many 'unknown' 3D models as
nuclear@0 395 * possible correctly.
nuclear@0 396 *
nuclear@0 397 * This corresponds to the #AI_MATKEY_TEXFLAGS property.
nuclear@0 398 */
nuclear@0 399 enum aiTextureFlags
nuclear@0 400 {
nuclear@0 401 /** The texture's color values have to be inverted (componentwise 1-n)
nuclear@0 402 */
nuclear@0 403 aiTextureFlags_Invert = 0x1,
nuclear@0 404
nuclear@0 405 /** Explicit request to the application to process the alpha channel
nuclear@0 406 * of the texture.
nuclear@0 407 *
nuclear@0 408 * Mutually exclusive with #aiTextureFlags_IgnoreAlpha. These
nuclear@0 409 * flags are set if the library can say for sure that the alpha
nuclear@0 410 * channel is used/is not used. If the model format does not
nuclear@0 411 * define this, it is left to the application to decide whether
nuclear@0 412 * the texture alpha channel - if any - is evaluated or not.
nuclear@0 413 */
nuclear@0 414 aiTextureFlags_UseAlpha = 0x2,
nuclear@0 415
nuclear@0 416 /** Explicit request to the application to ignore the alpha channel
nuclear@0 417 * of the texture.
nuclear@0 418 *
nuclear@0 419 * Mutually exclusive with #aiTextureFlags_UseAlpha.
nuclear@0 420 */
nuclear@0 421 aiTextureFlags_IgnoreAlpha = 0x4,
nuclear@0 422
nuclear@0 423 /** @cond never
nuclear@0 424 * This value is not used. It forces the compiler to use at least
nuclear@0 425 * 32 Bit integers to represent this enum.
nuclear@0 426 */
nuclear@0 427 #ifndef SWIG
nuclear@0 428 _aiTextureFlags_Force32Bit = INT_MAX
nuclear@0 429 #endif
nuclear@0 430 //! @endcond
nuclear@0 431 };
nuclear@0 432
nuclear@0 433
nuclear@0 434 // ---------------------------------------------------------------------------
nuclear@0 435 /** @brief Defines alpha-blend flags.
nuclear@0 436 *
nuclear@0 437 * If you're familiar with OpenGL or D3D, these flags aren't new to you.
nuclear@0 438 * They define *how* the final color value of a pixel is computed, basing
nuclear@0 439 * on the previous color at that pixel and the new color value from the
nuclear@0 440 * material.
nuclear@0 441 * The blend formula is:
nuclear@0 442 * @code
nuclear@0 443 * SourceColor * SourceBlend + DestColor * DestBlend
nuclear@0 444 * @endcode
nuclear@0 445 * where <DestColor> is the previous color in the framebuffer at this
nuclear@0 446 * position and <SourceColor> is the material colro before the transparency
nuclear@0 447 * calculation.<br>
nuclear@0 448 * This corresponds to the #AI_MATKEY_BLEND_FUNC property.
nuclear@0 449 */
nuclear@0 450 enum aiBlendMode
nuclear@0 451 {
nuclear@0 452 /**
nuclear@0 453 * Formula:
nuclear@0 454 * @code
nuclear@0 455 * SourceColor*SourceAlpha + DestColor*(1-SourceAlpha)
nuclear@0 456 * @endcode
nuclear@0 457 */
nuclear@0 458 aiBlendMode_Default = 0x0,
nuclear@0 459
nuclear@0 460 /** Additive blending
nuclear@0 461 *
nuclear@0 462 * Formula:
nuclear@0 463 * @code
nuclear@0 464 * SourceColor*1 + DestColor*1
nuclear@0 465 * @endcode
nuclear@0 466 */
nuclear@0 467 aiBlendMode_Additive = 0x1,
nuclear@0 468
nuclear@0 469 // we don't need more for the moment, but we might need them
nuclear@0 470 // in future versions ...
nuclear@0 471
nuclear@0 472 /** @cond never
nuclear@0 473 * This value is not used. It forces the compiler to use at least
nuclear@0 474 * 32 Bit integers to represent this enum.
nuclear@0 475 */
nuclear@0 476 #ifndef SWIG
nuclear@0 477 _aiBlendMode_Force32Bit = INT_MAX
nuclear@0 478 #endif
nuclear@0 479 //! @endcond
nuclear@0 480 };
nuclear@0 481
nuclear@0 482
nuclear@0 483 #include "./Compiler/pushpack1.h"
nuclear@0 484
nuclear@0 485 // ---------------------------------------------------------------------------
nuclear@0 486 /** @brief Defines how an UV channel is transformed.
nuclear@0 487 *
nuclear@0 488 * This is just a helper structure for the #AI_MATKEY_UVTRANSFORM key.
nuclear@0 489 * See its documentation for more details.
nuclear@0 490 *
nuclear@0 491 * Typically you'll want to build a matrix of this information. However,
nuclear@0 492 * we keep separate scaling/translation/rotation values to make it
nuclear@0 493 * easier to process and optimize UV transformations internally.
nuclear@0 494 */
nuclear@0 495 struct aiUVTransform
nuclear@0 496 {
nuclear@0 497 /** Translation on the u and v axes.
nuclear@0 498 *
nuclear@0 499 * The default value is (0|0).
nuclear@0 500 */
nuclear@0 501 C_STRUCT aiVector2D mTranslation;
nuclear@0 502
nuclear@0 503 /** Scaling on the u and v axes.
nuclear@0 504 *
nuclear@0 505 * The default value is (1|1).
nuclear@0 506 */
nuclear@0 507 C_STRUCT aiVector2D mScaling;
nuclear@0 508
nuclear@0 509 /** Rotation - in counter-clockwise direction.
nuclear@0 510 *
nuclear@0 511 * The rotation angle is specified in radians. The
nuclear@0 512 * rotation center is 0.5f|0.5f. The default value
nuclear@0 513 * 0.f.
nuclear@0 514 */
nuclear@0 515 float mRotation;
nuclear@0 516
nuclear@0 517
nuclear@0 518 #ifdef __cplusplus
nuclear@0 519 aiUVTransform()
nuclear@0 520 : mScaling (1.f,1.f)
nuclear@0 521 , mRotation (0.f)
nuclear@0 522 {
nuclear@0 523 // nothing to be done here ...
nuclear@0 524 }
nuclear@0 525 #endif
nuclear@0 526
nuclear@0 527 } PACK_STRUCT;
nuclear@0 528
nuclear@0 529 #include "./Compiler/poppack1.h"
nuclear@0 530
nuclear@0 531 //! @cond AI_DOX_INCLUDE_INTERNAL
nuclear@0 532 // ---------------------------------------------------------------------------
nuclear@0 533 /** @brief A very primitive RTTI system for the contents of material
nuclear@0 534 * properties.
nuclear@0 535 */
nuclear@0 536 enum aiPropertyTypeInfo
nuclear@0 537 {
nuclear@0 538 /** Array of single-precision (32 Bit) floats
nuclear@0 539 *
nuclear@0 540 * It is possible to use aiGetMaterialInteger[Array]() (or the C++-API
nuclear@0 541 * aiMaterial::Get()) to query properties stored in floating-point format.
nuclear@0 542 * The material system performs the type conversion automatically.
nuclear@0 543 */
nuclear@0 544 aiPTI_Float = 0x1,
nuclear@0 545
nuclear@0 546 /** The material property is an aiString.
nuclear@0 547 *
nuclear@0 548 * Arrays of strings aren't possible, aiGetMaterialString() (or the
nuclear@0 549 * C++-API aiMaterial::Get()) *must* be used to query a string property.
nuclear@0 550 */
nuclear@0 551 aiPTI_String = 0x3,
nuclear@0 552
nuclear@0 553 /** Array of (32 Bit) integers
nuclear@0 554 *
nuclear@0 555 * It is possible to use aiGetMaterialFloat[Array]() (or the C++-API
nuclear@0 556 * aiMaterial::Get()) to query properties stored in integer format.
nuclear@0 557 * The material system performs the type conversion automatically.
nuclear@0 558 */
nuclear@0 559 aiPTI_Integer = 0x4,
nuclear@0 560
nuclear@0 561
nuclear@0 562 /** Simple binary buffer, content undefined. Not convertible to anything.
nuclear@0 563 */
nuclear@0 564 aiPTI_Buffer = 0x5,
nuclear@0 565
nuclear@0 566
nuclear@0 567 /** This value is not used. It is just there to force the
nuclear@0 568 * compiler to map this enum to a 32 Bit integer.
nuclear@0 569 */
nuclear@0 570 #ifndef SWIG
nuclear@0 571 _aiPTI_Force32Bit = INT_MAX
nuclear@0 572 #endif
nuclear@0 573 };
nuclear@0 574
nuclear@0 575 // ---------------------------------------------------------------------------
nuclear@0 576 /** @brief Data structure for a single material property
nuclear@0 577 *
nuclear@0 578 * As an user, you'll probably never need to deal with this data structure.
nuclear@0 579 * Just use the provided aiGetMaterialXXX() or aiMaterial::Get() family
nuclear@0 580 * of functions to query material properties easily. Processing them
nuclear@0 581 * manually is faster, but it is not the recommended way. It isn't worth
nuclear@0 582 * the effort. <br>
nuclear@0 583 * Material property names follow a simple scheme:
nuclear@0 584 * @code
nuclear@0 585 * $<name>
nuclear@0 586 * ?<name>
nuclear@0 587 * A public property, there must be corresponding AI_MATKEY_XXX define
nuclear@0 588 * 2nd: Public, but ignored by the #aiProcess_RemoveRedundantMaterials
nuclear@0 589 * post-processing step.
nuclear@0 590 * ~<name>
nuclear@0 591 * A temporary property for internal use.
nuclear@0 592 * @endcode
nuclear@0 593 * @see aiMaterial
nuclear@0 594 */
nuclear@0 595 struct aiMaterialProperty
nuclear@0 596 {
nuclear@0 597 /** Specifies the name of the property (key)
nuclear@0 598 * Keys are generally case insensitive.
nuclear@0 599 */
nuclear@0 600 C_STRUCT aiString mKey;
nuclear@0 601
nuclear@0 602 /** Textures: Specifies their exact usage semantic.
nuclear@0 603 * For non-texture properties, this member is always 0
nuclear@0 604 * (or, better-said, #aiTextureType_NONE).
nuclear@0 605 */
nuclear@0 606 unsigned int mSemantic;
nuclear@0 607
nuclear@0 608 /** Textures: Specifies the index of the texture.
nuclear@0 609 * For non-texture properties, this member is always 0.
nuclear@0 610 */
nuclear@0 611 unsigned int mIndex;
nuclear@0 612
nuclear@0 613 /** Size of the buffer mData is pointing to, in bytes.
nuclear@0 614 * This value may not be 0.
nuclear@0 615 */
nuclear@0 616 unsigned int mDataLength;
nuclear@0 617
nuclear@0 618 /** Type information for the property.
nuclear@0 619 *
nuclear@0 620 * Defines the data layout inside the data buffer. This is used
nuclear@0 621 * by the library internally to perform debug checks and to
nuclear@0 622 * utilize proper type conversions.
nuclear@0 623 * (It's probably a hacky solution, but it works.)
nuclear@0 624 */
nuclear@0 625 C_ENUM aiPropertyTypeInfo mType;
nuclear@0 626
nuclear@0 627 /** Binary buffer to hold the property's value.
nuclear@0 628 * The size of the buffer is always mDataLength.
nuclear@0 629 */
nuclear@0 630 char* mData;
nuclear@0 631
nuclear@0 632 #ifdef __cplusplus
nuclear@0 633
nuclear@0 634 aiMaterialProperty()
nuclear@0 635 : mSemantic( 0 )
nuclear@0 636 , mIndex( 0 )
nuclear@0 637 , mDataLength( 0 )
nuclear@0 638 , mType( aiPTI_Float )
nuclear@0 639 , mData( NULL )
nuclear@0 640 {
nuclear@0 641 }
nuclear@0 642
nuclear@0 643 ~aiMaterialProperty() {
nuclear@0 644 delete[] mData;
nuclear@0 645 }
nuclear@0 646
nuclear@0 647 #endif
nuclear@0 648 };
nuclear@0 649 //! @endcond
nuclear@0 650
nuclear@0 651 #ifdef __cplusplus
nuclear@0 652 } // We need to leave the "C" block here to allow template member functions
nuclear@0 653 #endif
nuclear@0 654
nuclear@0 655 // ---------------------------------------------------------------------------
nuclear@0 656 /** @brief Data structure for a material
nuclear@0 657 *
nuclear@0 658 * Material data is stored using a key-value structure. A single key-value
nuclear@0 659 * pair is called a 'material property'. C++ users should use the provided
nuclear@0 660 * member functions of aiMaterial to process material properties, C users
nuclear@0 661 * have to stick with the aiMaterialGetXXX family of unbound functions.
nuclear@0 662 * The library defines a set of standard keys (AI_MATKEY_XXX).
nuclear@0 663 */
nuclear@0 664 #ifdef __cplusplus
nuclear@0 665 struct ASSIMP_API aiMaterial
nuclear@0 666 #else
nuclear@0 667 struct aiMaterial
nuclear@0 668 #endif
nuclear@0 669 {
nuclear@0 670
nuclear@0 671 #ifdef __cplusplus
nuclear@0 672
nuclear@0 673 public:
nuclear@0 674
nuclear@0 675 aiMaterial();
nuclear@0 676 ~aiMaterial();
nuclear@0 677
nuclear@0 678 // -------------------------------------------------------------------
nuclear@0 679 /** @brief Retrieve an array of Type values with a specific key
nuclear@0 680 * from the material
nuclear@0 681 *
nuclear@0 682 * @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
nuclear@0 683 * @param type .. set by AI_MATKEY_XXX
nuclear@0 684 * @param idx .. set by AI_MATKEY_XXX
nuclear@0 685 * @param pOut Pointer to a buffer to receive the result.
nuclear@0 686 * @param pMax Specifies the size of the given buffer, in Type's.
nuclear@0 687 * Receives the number of values (not bytes!) read.
nuclear@0 688 * NULL is a valid value for this parameter.
nuclear@0 689 */
nuclear@0 690 template <typename Type>
nuclear@0 691 aiReturn Get(const char* pKey,unsigned int type,
nuclear@0 692 unsigned int idx, Type* pOut, unsigned int* pMax) const;
nuclear@0 693
nuclear@0 694 // -------------------------------------------------------------------
nuclear@0 695 /** @brief Retrieve a Type value with a specific key
nuclear@0 696 * from the material
nuclear@0 697 *
nuclear@0 698 * @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
nuclear@0 699 * @param type Specifies the type of the texture to be retrieved (
nuclear@0 700 * e.g. diffuse, specular, height map ...)
nuclear@0 701 * @param idx Index of the texture to be retrieved.
nuclear@0 702 * @param pOut Reference to receive the output value
nuclear@0 703 */
nuclear@0 704 template <typename Type>
nuclear@0 705 aiReturn Get(const char* pKey,unsigned int type,
nuclear@0 706 unsigned int idx,Type& pOut) const;
nuclear@0 707
nuclear@0 708 // -------------------------------------------------------------------
nuclear@0 709 /** Get the number of textures for a particular texture type.
nuclear@0 710 * @param type Texture type to check for
nuclear@0 711 * @return Number of textures for this type.
nuclear@0 712 * @note A texture can be easily queried using #GetTexture() */
nuclear@0 713 unsigned int GetTextureCount(aiTextureType type) const;
nuclear@0 714
nuclear@0 715 // -------------------------------------------------------------------
nuclear@0 716 /** Helper function to get all parameters pertaining to a
nuclear@0 717 * particular texture slot from a material.
nuclear@0 718 *
nuclear@0 719 * This function is provided just for convenience, you could also
nuclear@0 720 * read the single material properties manually.
nuclear@0 721 * @param type Specifies the type of the texture to be retrieved (
nuclear@0 722 * e.g. diffuse, specular, height map ...)
nuclear@0 723 * @param index Index of the texture to be retrieved. The function fails
nuclear@0 724 * if there is no texture of that type with this index.
nuclear@0 725 * #GetTextureCount() can be used to determine the number of textures
nuclear@0 726 * per texture type.
nuclear@0 727 * @param path Receives the path to the texture.
nuclear@0 728 * NULL is a valid value.
nuclear@0 729 * @param mapping The texture mapping.
nuclear@0 730 * NULL is allowed as value.
nuclear@0 731 * @param uvindex Receives the UV index of the texture.
nuclear@0 732 * NULL is a valid value.
nuclear@0 733 * @param blend Receives the blend factor for the texture
nuclear@0 734 * NULL is a valid value.
nuclear@0 735 * @param op Receives the texture operation to be performed between
nuclear@0 736 * this texture and the previous texture. NULL is allowed as value.
nuclear@0 737 * @param mapmode Receives the mapping modes to be used for the texture.
nuclear@0 738 * The parameter may be NULL but if it is a valid pointer it MUST
nuclear@0 739 * point to an array of 3 aiTextureMapMode's (one for each
nuclear@0 740 * axis: UVW order (=XYZ)).
nuclear@0 741 */
nuclear@0 742 // -------------------------------------------------------------------
nuclear@0 743 aiReturn GetTexture(aiTextureType type,
nuclear@0 744 unsigned int index,
nuclear@0 745 C_STRUCT aiString* path,
nuclear@0 746 aiTextureMapping* mapping = NULL,
nuclear@0 747 unsigned int* uvindex = NULL,
nuclear@0 748 float* blend = NULL,
nuclear@0 749 aiTextureOp* op = NULL,
nuclear@0 750 aiTextureMapMode* mapmode = NULL) const;
nuclear@0 751
nuclear@0 752
nuclear@0 753 // Setters
nuclear@0 754
nuclear@0 755
nuclear@0 756 // ------------------------------------------------------------------------------
nuclear@0 757 /** @brief Add a property with a given key and type info to the material
nuclear@0 758 * structure
nuclear@0 759 *
nuclear@0 760 * @param pInput Pointer to input data
nuclear@0 761 * @param pSizeInBytes Size of input data
nuclear@0 762 * @param pKey Key/Usage of the property (AI_MATKEY_XXX)
nuclear@0 763 * @param type Set by the AI_MATKEY_XXX macro
nuclear@0 764 * @param index Set by the AI_MATKEY_XXX macro
nuclear@0 765 * @param pType Type information hint */
nuclear@0 766 aiReturn AddBinaryProperty (const void* pInput,
nuclear@0 767 unsigned int pSizeInBytes,
nuclear@0 768 const char* pKey,
nuclear@0 769 unsigned int type ,
nuclear@0 770 unsigned int index ,
nuclear@0 771 aiPropertyTypeInfo pType);
nuclear@0 772
nuclear@0 773 // ------------------------------------------------------------------------------
nuclear@0 774 /** @brief Add a string property with a given key and type info to the
nuclear@0 775 * material structure
nuclear@0 776 *
nuclear@0 777 * @param pInput Input string
nuclear@0 778 * @param pKey Key/Usage of the property (AI_MATKEY_XXX)
nuclear@0 779 * @param type Set by the AI_MATKEY_XXX macro
nuclear@0 780 * @param index Set by the AI_MATKEY_XXX macro */
nuclear@0 781 aiReturn AddProperty (const aiString* pInput,
nuclear@0 782 const char* pKey,
nuclear@0 783 unsigned int type = 0,
nuclear@0 784 unsigned int index = 0);
nuclear@0 785
nuclear@0 786 // ------------------------------------------------------------------------------
nuclear@0 787 /** @brief Add a property with a given key to the material structure
nuclear@0 788 * @param pInput Pointer to the input data
nuclear@0 789 * @param pNumValues Number of values in the array
nuclear@0 790 * @param pKey Key/Usage of the property (AI_MATKEY_XXX)
nuclear@0 791 * @param type Set by the AI_MATKEY_XXX macro
nuclear@0 792 * @param index Set by the AI_MATKEY_XXX macro */
nuclear@0 793 template<class TYPE>
nuclear@0 794 aiReturn AddProperty (const TYPE* pInput,
nuclear@0 795 unsigned int pNumValues,
nuclear@0 796 const char* pKey,
nuclear@0 797 unsigned int type = 0,
nuclear@0 798 unsigned int index = 0);
nuclear@0 799
nuclear@0 800 // ------------------------------------------------------------------------------
nuclear@0 801 /** @brief Remove a given key from the list.
nuclear@0 802 *
nuclear@0 803 * The function fails if the key isn't found
nuclear@0 804 * @param pKey Key to be deleted */
nuclear@0 805 aiReturn RemoveProperty (const char* pKey,
nuclear@0 806 unsigned int type = 0,
nuclear@0 807 unsigned int index = 0);
nuclear@0 808
nuclear@0 809 // ------------------------------------------------------------------------------
nuclear@0 810 /** @brief Removes all properties from the material.
nuclear@0 811 *
nuclear@0 812 * The data array remains allocated so adding new properties is quite fast. */
nuclear@0 813 void Clear();
nuclear@0 814
nuclear@0 815 // ------------------------------------------------------------------------------
nuclear@0 816 /** Copy the property list of a material
nuclear@0 817 * @param pcDest Destination material
nuclear@0 818 * @param pcSrc Source material
nuclear@0 819 */
nuclear@0 820 static void CopyPropertyList(aiMaterial* pcDest,
nuclear@0 821 const aiMaterial* pcSrc);
nuclear@0 822
nuclear@0 823
nuclear@0 824 #endif
nuclear@0 825
nuclear@0 826 /** List of all material properties loaded. */
nuclear@0 827 C_STRUCT aiMaterialProperty** mProperties;
nuclear@0 828
nuclear@0 829 /** Number of properties in the data base */
nuclear@0 830 unsigned int mNumProperties;
nuclear@0 831
nuclear@0 832 /** Storage allocated */
nuclear@0 833 unsigned int mNumAllocated;
nuclear@0 834 };
nuclear@0 835
nuclear@0 836 // Go back to extern "C" again
nuclear@0 837 #ifdef __cplusplus
nuclear@0 838 extern "C" {
nuclear@0 839 #endif
nuclear@0 840
nuclear@0 841 // ---------------------------------------------------------------------------
nuclear@0 842 #define AI_MATKEY_NAME "?mat.name",0,0
nuclear@0 843 #define AI_MATKEY_TWOSIDED "$mat.twosided",0,0
nuclear@0 844 #define AI_MATKEY_SHADING_MODEL "$mat.shadingm",0,0
nuclear@0 845 #define AI_MATKEY_ENABLE_WIREFRAME "$mat.wireframe",0,0
nuclear@0 846 #define AI_MATKEY_BLEND_FUNC "$mat.blend",0,0
nuclear@0 847 #define AI_MATKEY_OPACITY "$mat.opacity",0,0
nuclear@0 848 #define AI_MATKEY_BUMPSCALING "$mat.bumpscaling",0,0
nuclear@0 849 #define AI_MATKEY_SHININESS "$mat.shininess",0,0
nuclear@0 850 #define AI_MATKEY_REFLECTIVITY "$mat.reflectivity",0,0
nuclear@0 851 #define AI_MATKEY_SHININESS_STRENGTH "$mat.shinpercent",0,0
nuclear@0 852 #define AI_MATKEY_REFRACTI "$mat.refracti",0,0
nuclear@0 853 #define AI_MATKEY_COLOR_DIFFUSE "$clr.diffuse",0,0
nuclear@0 854 #define AI_MATKEY_COLOR_AMBIENT "$clr.ambient",0,0
nuclear@0 855 #define AI_MATKEY_COLOR_SPECULAR "$clr.specular",0,0
nuclear@0 856 #define AI_MATKEY_COLOR_EMISSIVE "$clr.emissive",0,0
nuclear@0 857 #define AI_MATKEY_COLOR_TRANSPARENT "$clr.transparent",0,0
nuclear@0 858 #define AI_MATKEY_COLOR_REFLECTIVE "$clr.reflective",0,0
nuclear@0 859 #define AI_MATKEY_GLOBAL_BACKGROUND_IMAGE "?bg.global",0,0
nuclear@0 860
nuclear@0 861 // ---------------------------------------------------------------------------
nuclear@0 862 // Pure key names for all texture-related properties
nuclear@0 863 //! @cond MATS_DOC_FULL
nuclear@0 864 #define _AI_MATKEY_TEXTURE_BASE "$tex.file"
nuclear@0 865 #define _AI_MATKEY_UVWSRC_BASE "$tex.uvwsrc"
nuclear@0 866 #define _AI_MATKEY_TEXOP_BASE "$tex.op"
nuclear@0 867 #define _AI_MATKEY_MAPPING_BASE "$tex.mapping"
nuclear@0 868 #define _AI_MATKEY_TEXBLEND_BASE "$tex.blend"
nuclear@0 869 #define _AI_MATKEY_MAPPINGMODE_U_BASE "$tex.mapmodeu"
nuclear@0 870 #define _AI_MATKEY_MAPPINGMODE_V_BASE "$tex.mapmodev"
nuclear@0 871 #define _AI_MATKEY_TEXMAP_AXIS_BASE "$tex.mapaxis"
nuclear@0 872 #define _AI_MATKEY_UVTRANSFORM_BASE "$tex.uvtrafo"
nuclear@0 873 #define _AI_MATKEY_TEXFLAGS_BASE "$tex.flags"
nuclear@0 874 //! @endcond
nuclear@0 875
nuclear@0 876 // ---------------------------------------------------------------------------
nuclear@0 877 #define AI_MATKEY_TEXTURE(type, N) _AI_MATKEY_TEXTURE_BASE,type,N
nuclear@0 878
nuclear@0 879 // For backward compatibility and simplicity
nuclear@0 880 //! @cond MATS_DOC_FULL
nuclear@0 881 #define AI_MATKEY_TEXTURE_DIFFUSE(N) \
nuclear@0 882 AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE,N)
nuclear@0 883
nuclear@0 884 #define AI_MATKEY_TEXTURE_SPECULAR(N) \
nuclear@0 885 AI_MATKEY_TEXTURE(aiTextureType_SPECULAR,N)
nuclear@0 886
nuclear@0 887 #define AI_MATKEY_TEXTURE_AMBIENT(N) \
nuclear@0 888 AI_MATKEY_TEXTURE(aiTextureType_AMBIENT,N)
nuclear@0 889
nuclear@0 890 #define AI_MATKEY_TEXTURE_EMISSIVE(N) \
nuclear@0 891 AI_MATKEY_TEXTURE(aiTextureType_EMISSIVE,N)
nuclear@0 892
nuclear@0 893 #define AI_MATKEY_TEXTURE_NORMALS(N) \
nuclear@0 894 AI_MATKEY_TEXTURE(aiTextureType_NORMALS,N)
nuclear@0 895
nuclear@0 896 #define AI_MATKEY_TEXTURE_HEIGHT(N) \
nuclear@0 897 AI_MATKEY_TEXTURE(aiTextureType_HEIGHT,N)
nuclear@0 898
nuclear@0 899 #define AI_MATKEY_TEXTURE_SHININESS(N) \
nuclear@0 900 AI_MATKEY_TEXTURE(aiTextureType_SHININESS,N)
nuclear@0 901
nuclear@0 902 #define AI_MATKEY_TEXTURE_OPACITY(N) \
nuclear@0 903 AI_MATKEY_TEXTURE(aiTextureType_OPACITY,N)
nuclear@0 904
nuclear@0 905 #define AI_MATKEY_TEXTURE_DISPLACEMENT(N) \
nuclear@0 906 AI_MATKEY_TEXTURE(aiTextureType_DISPLACEMENT,N)
nuclear@0 907
nuclear@0 908 #define AI_MATKEY_TEXTURE_LIGHTMAP(N) \
nuclear@0 909 AI_MATKEY_TEXTURE(aiTextureType_LIGHTMAP,N)
nuclear@0 910
nuclear@0 911 #define AI_MATKEY_TEXTURE_REFLECTION(N) \
nuclear@0 912 AI_MATKEY_TEXTURE(aiTextureType_REFLECTION,N)
nuclear@0 913
nuclear@0 914 //! @endcond
nuclear@0 915
nuclear@0 916 // ---------------------------------------------------------------------------
nuclear@0 917 #define AI_MATKEY_UVWSRC(type, N) _AI_MATKEY_UVWSRC_BASE,type,N
nuclear@0 918
nuclear@0 919 // For backward compatibility and simplicity
nuclear@0 920 //! @cond MATS_DOC_FULL
nuclear@0 921 #define AI_MATKEY_UVWSRC_DIFFUSE(N) \
nuclear@0 922 AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE,N)
nuclear@0 923
nuclear@0 924 #define AI_MATKEY_UVWSRC_SPECULAR(N) \
nuclear@0 925 AI_MATKEY_UVWSRC(aiTextureType_SPECULAR,N)
nuclear@0 926
nuclear@0 927 #define AI_MATKEY_UVWSRC_AMBIENT(N) \
nuclear@0 928 AI_MATKEY_UVWSRC(aiTextureType_AMBIENT,N)
nuclear@0 929
nuclear@0 930 #define AI_MATKEY_UVWSRC_EMISSIVE(N) \
nuclear@0 931 AI_MATKEY_UVWSRC(aiTextureType_EMISSIVE,N)
nuclear@0 932
nuclear@0 933 #define AI_MATKEY_UVWSRC_NORMALS(N) \
nuclear@0 934 AI_MATKEY_UVWSRC(aiTextureType_NORMALS,N)
nuclear@0 935
nuclear@0 936 #define AI_MATKEY_UVWSRC_HEIGHT(N) \
nuclear@0 937 AI_MATKEY_UVWSRC(aiTextureType_HEIGHT,N)
nuclear@0 938
nuclear@0 939 #define AI_MATKEY_UVWSRC_SHININESS(N) \
nuclear@0 940 AI_MATKEY_UVWSRC(aiTextureType_SHININESS,N)
nuclear@0 941
nuclear@0 942 #define AI_MATKEY_UVWSRC_OPACITY(N) \
nuclear@0 943 AI_MATKEY_UVWSRC(aiTextureType_OPACITY,N)
nuclear@0 944
nuclear@0 945 #define AI_MATKEY_UVWSRC_DISPLACEMENT(N) \
nuclear@0 946 AI_MATKEY_UVWSRC(aiTextureType_DISPLACEMENT,N)
nuclear@0 947
nuclear@0 948 #define AI_MATKEY_UVWSRC_LIGHTMAP(N) \
nuclear@0 949 AI_MATKEY_UVWSRC(aiTextureType_LIGHTMAP,N)
nuclear@0 950
nuclear@0 951 #define AI_MATKEY_UVWSRC_REFLECTION(N) \
nuclear@0 952 AI_MATKEY_UVWSRC(aiTextureType_REFLECTION,N)
nuclear@0 953
nuclear@0 954 //! @endcond
nuclear@0 955 // ---------------------------------------------------------------------------
nuclear@0 956 #define AI_MATKEY_TEXOP(type, N) _AI_MATKEY_TEXOP_BASE,type,N
nuclear@0 957
nuclear@0 958 // For backward compatibility and simplicity
nuclear@0 959 //! @cond MATS_DOC_FULL
nuclear@0 960 #define AI_MATKEY_TEXOP_DIFFUSE(N) \
nuclear@0 961 AI_MATKEY_TEXOP(aiTextureType_DIFFUSE,N)
nuclear@0 962
nuclear@0 963 #define AI_MATKEY_TEXOP_SPECULAR(N) \
nuclear@0 964 AI_MATKEY_TEXOP(aiTextureType_SPECULAR,N)
nuclear@0 965
nuclear@0 966 #define AI_MATKEY_TEXOP_AMBIENT(N) \
nuclear@0 967 AI_MATKEY_TEXOP(aiTextureType_AMBIENT,N)
nuclear@0 968
nuclear@0 969 #define AI_MATKEY_TEXOP_EMISSIVE(N) \
nuclear@0 970 AI_MATKEY_TEXOP(aiTextureType_EMISSIVE,N)
nuclear@0 971
nuclear@0 972 #define AI_MATKEY_TEXOP_NORMALS(N) \
nuclear@0 973 AI_MATKEY_TEXOP(aiTextureType_NORMALS,N)
nuclear@0 974
nuclear@0 975 #define AI_MATKEY_TEXOP_HEIGHT(N) \
nuclear@0 976 AI_MATKEY_TEXOP(aiTextureType_HEIGHT,N)
nuclear@0 977
nuclear@0 978 #define AI_MATKEY_TEXOP_SHININESS(N) \
nuclear@0 979 AI_MATKEY_TEXOP(aiTextureType_SHININESS,N)
nuclear@0 980
nuclear@0 981 #define AI_MATKEY_TEXOP_OPACITY(N) \
nuclear@0 982 AI_MATKEY_TEXOP(aiTextureType_OPACITY,N)
nuclear@0 983
nuclear@0 984 #define AI_MATKEY_TEXOP_DISPLACEMENT(N) \
nuclear@0 985 AI_MATKEY_TEXOP(aiTextureType_DISPLACEMENT,N)
nuclear@0 986
nuclear@0 987 #define AI_MATKEY_TEXOP_LIGHTMAP(N) \
nuclear@0 988 AI_MATKEY_TEXOP(aiTextureType_LIGHTMAP,N)
nuclear@0 989
nuclear@0 990 #define AI_MATKEY_TEXOP_REFLECTION(N) \
nuclear@0 991 AI_MATKEY_TEXOP(aiTextureType_REFLECTION,N)
nuclear@0 992
nuclear@0 993 //! @endcond
nuclear@0 994 // ---------------------------------------------------------------------------
nuclear@0 995 #define AI_MATKEY_MAPPING(type, N) _AI_MATKEY_MAPPING_BASE,type,N
nuclear@0 996
nuclear@0 997 // For backward compatibility and simplicity
nuclear@0 998 //! @cond MATS_DOC_FULL
nuclear@0 999 #define AI_MATKEY_MAPPING_DIFFUSE(N) \
nuclear@0 1000 AI_MATKEY_MAPPING(aiTextureType_DIFFUSE,N)
nuclear@0 1001
nuclear@0 1002 #define AI_MATKEY_MAPPING_SPECULAR(N) \
nuclear@0 1003 AI_MATKEY_MAPPING(aiTextureType_SPECULAR,N)
nuclear@0 1004
nuclear@0 1005 #define AI_MATKEY_MAPPING_AMBIENT(N) \
nuclear@0 1006 AI_MATKEY_MAPPING(aiTextureType_AMBIENT,N)
nuclear@0 1007
nuclear@0 1008 #define AI_MATKEY_MAPPING_EMISSIVE(N) \
nuclear@0 1009 AI_MATKEY_MAPPING(aiTextureType_EMISSIVE,N)
nuclear@0 1010
nuclear@0 1011 #define AI_MATKEY_MAPPING_NORMALS(N) \
nuclear@0 1012 AI_MATKEY_MAPPING(aiTextureType_NORMALS,N)
nuclear@0 1013
nuclear@0 1014 #define AI_MATKEY_MAPPING_HEIGHT(N) \
nuclear@0 1015 AI_MATKEY_MAPPING(aiTextureType_HEIGHT,N)
nuclear@0 1016
nuclear@0 1017 #define AI_MATKEY_MAPPING_SHININESS(N) \
nuclear@0 1018 AI_MATKEY_MAPPING(aiTextureType_SHININESS,N)
nuclear@0 1019
nuclear@0 1020 #define AI_MATKEY_MAPPING_OPACITY(N) \
nuclear@0 1021 AI_MATKEY_MAPPING(aiTextureType_OPACITY,N)
nuclear@0 1022
nuclear@0 1023 #define AI_MATKEY_MAPPING_DISPLACEMENT(N) \
nuclear@0 1024 AI_MATKEY_MAPPING(aiTextureType_DISPLACEMENT,N)
nuclear@0 1025
nuclear@0 1026 #define AI_MATKEY_MAPPING_LIGHTMAP(N) \
nuclear@0 1027 AI_MATKEY_MAPPING(aiTextureType_LIGHTMAP,N)
nuclear@0 1028
nuclear@0 1029 #define AI_MATKEY_MAPPING_REFLECTION(N) \
nuclear@0 1030 AI_MATKEY_MAPPING(aiTextureType_REFLECTION,N)
nuclear@0 1031
nuclear@0 1032 //! @endcond
nuclear@0 1033 // ---------------------------------------------------------------------------
nuclear@0 1034 #define AI_MATKEY_TEXBLEND(type, N) _AI_MATKEY_TEXBLEND_BASE,type,N
nuclear@0 1035
nuclear@0 1036 // For backward compatibility and simplicity
nuclear@0 1037 //! @cond MATS_DOC_FULL
nuclear@0 1038 #define AI_MATKEY_TEXBLEND_DIFFUSE(N) \
nuclear@0 1039 AI_MATKEY_TEXBLEND(aiTextureType_DIFFUSE,N)
nuclear@0 1040
nuclear@0 1041 #define AI_MATKEY_TEXBLEND_SPECULAR(N) \
nuclear@0 1042 AI_MATKEY_TEXBLEND(aiTextureType_SPECULAR,N)
nuclear@0 1043
nuclear@0 1044 #define AI_MATKEY_TEXBLEND_AMBIENT(N) \
nuclear@0 1045 AI_MATKEY_TEXBLEND(aiTextureType_AMBIENT,N)
nuclear@0 1046
nuclear@0 1047 #define AI_MATKEY_TEXBLEND_EMISSIVE(N) \
nuclear@0 1048 AI_MATKEY_TEXBLEND(aiTextureType_EMISSIVE,N)
nuclear@0 1049
nuclear@0 1050 #define AI_MATKEY_TEXBLEND_NORMALS(N) \
nuclear@0 1051 AI_MATKEY_TEXBLEND(aiTextureType_NORMALS,N)
nuclear@0 1052
nuclear@0 1053 #define AI_MATKEY_TEXBLEND_HEIGHT(N) \
nuclear@0 1054 AI_MATKEY_TEXBLEND(aiTextureType_HEIGHT,N)
nuclear@0 1055
nuclear@0 1056 #define AI_MATKEY_TEXBLEND_SHININESS(N) \
nuclear@0 1057 AI_MATKEY_TEXBLEND(aiTextureType_SHININESS,N)
nuclear@0 1058
nuclear@0 1059 #define AI_MATKEY_TEXBLEND_OPACITY(N) \
nuclear@0 1060 AI_MATKEY_TEXBLEND(aiTextureType_OPACITY,N)
nuclear@0 1061
nuclear@0 1062 #define AI_MATKEY_TEXBLEND_DISPLACEMENT(N) \
nuclear@0 1063 AI_MATKEY_TEXBLEND(aiTextureType_DISPLACEMENT,N)
nuclear@0 1064
nuclear@0 1065 #define AI_MATKEY_TEXBLEND_LIGHTMAP(N) \
nuclear@0 1066 AI_MATKEY_TEXBLEND(aiTextureType_LIGHTMAP,N)
nuclear@0 1067
nuclear@0 1068 #define AI_MATKEY_TEXBLEND_REFLECTION(N) \
nuclear@0 1069 AI_MATKEY_TEXBLEND(aiTextureType_REFLECTION,N)
nuclear@0 1070
nuclear@0 1071 //! @endcond
nuclear@0 1072 // ---------------------------------------------------------------------------
nuclear@0 1073 #define AI_MATKEY_MAPPINGMODE_U(type, N) _AI_MATKEY_MAPPINGMODE_U_BASE,type,N
nuclear@0 1074
nuclear@0 1075 // For backward compatibility and simplicity
nuclear@0 1076 //! @cond MATS_DOC_FULL
nuclear@0 1077 #define AI_MATKEY_MAPPINGMODE_U_DIFFUSE(N) \
nuclear@0 1078 AI_MATKEY_MAPPINGMODE_U(aiTextureType_DIFFUSE,N)
nuclear@0 1079
nuclear@0 1080 #define AI_MATKEY_MAPPINGMODE_U_SPECULAR(N) \
nuclear@0 1081 AI_MATKEY_MAPPINGMODE_U(aiTextureType_SPECULAR,N)
nuclear@0 1082
nuclear@0 1083 #define AI_MATKEY_MAPPINGMODE_U_AMBIENT(N) \
nuclear@0 1084 AI_MATKEY_MAPPINGMODE_U(aiTextureType_AMBIENT,N)
nuclear@0 1085
nuclear@0 1086 #define AI_MATKEY_MAPPINGMODE_U_EMISSIVE(N) \
nuclear@0 1087 AI_MATKEY_MAPPINGMODE_U(aiTextureType_EMISSIVE,N)
nuclear@0 1088
nuclear@0 1089 #define AI_MATKEY_MAPPINGMODE_U_NORMALS(N) \
nuclear@0 1090 AI_MATKEY_MAPPINGMODE_U(aiTextureType_NORMALS,N)
nuclear@0 1091
nuclear@0 1092 #define AI_MATKEY_MAPPINGMODE_U_HEIGHT(N) \
nuclear@0 1093 AI_MATKEY_MAPPINGMODE_U(aiTextureType_HEIGHT,N)
nuclear@0 1094
nuclear@0 1095 #define AI_MATKEY_MAPPINGMODE_U_SHININESS(N) \
nuclear@0 1096 AI_MATKEY_MAPPINGMODE_U(aiTextureType_SHININESS,N)
nuclear@0 1097
nuclear@0 1098 #define AI_MATKEY_MAPPINGMODE_U_OPACITY(N) \
nuclear@0 1099 AI_MATKEY_MAPPINGMODE_U(aiTextureType_OPACITY,N)
nuclear@0 1100
nuclear@0 1101 #define AI_MATKEY_MAPPINGMODE_U_DISPLACEMENT(N) \
nuclear@0 1102 AI_MATKEY_MAPPINGMODE_U(aiTextureType_DISPLACEMENT,N)
nuclear@0 1103
nuclear@0 1104 #define AI_MATKEY_MAPPINGMODE_U_LIGHTMAP(N) \
nuclear@0 1105 AI_MATKEY_MAPPINGMODE_U(aiTextureType_LIGHTMAP,N)
nuclear@0 1106
nuclear@0 1107 #define AI_MATKEY_MAPPINGMODE_U_REFLECTION(N) \
nuclear@0 1108 AI_MATKEY_MAPPINGMODE_U(aiTextureType_REFLECTION,N)
nuclear@0 1109
nuclear@0 1110 //! @endcond
nuclear@0 1111 // ---------------------------------------------------------------------------
nuclear@0 1112 #define AI_MATKEY_MAPPINGMODE_V(type, N) _AI_MATKEY_MAPPINGMODE_V_BASE,type,N
nuclear@0 1113
nuclear@0 1114 // For backward compatibility and simplicity
nuclear@0 1115 //! @cond MATS_DOC_FULL
nuclear@0 1116 #define AI_MATKEY_MAPPINGMODE_V_DIFFUSE(N) \
nuclear@0 1117 AI_MATKEY_MAPPINGMODE_V(aiTextureType_DIFFUSE,N)
nuclear@0 1118
nuclear@0 1119 #define AI_MATKEY_MAPPINGMODE_V_SPECULAR(N) \
nuclear@0 1120 AI_MATKEY_MAPPINGMODE_V(aiTextureType_SPECULAR,N)
nuclear@0 1121
nuclear@0 1122 #define AI_MATKEY_MAPPINGMODE_V_AMBIENT(N) \
nuclear@0 1123 AI_MATKEY_MAPPINGMODE_V(aiTextureType_AMBIENT,N)
nuclear@0 1124
nuclear@0 1125 #define AI_MATKEY_MAPPINGMODE_V_EMISSIVE(N) \
nuclear@0 1126 AI_MATKEY_MAPPINGMODE_V(aiTextureType_EMISSIVE,N)
nuclear@0 1127
nuclear@0 1128 #define AI_MATKEY_MAPPINGMODE_V_NORMALS(N) \
nuclear@0 1129 AI_MATKEY_MAPPINGMODE_V(aiTextureType_NORMALS,N)
nuclear@0 1130
nuclear@0 1131 #define AI_MATKEY_MAPPINGMODE_V_HEIGHT(N) \
nuclear@0 1132 AI_MATKEY_MAPPINGMODE_V(aiTextureType_HEIGHT,N)
nuclear@0 1133
nuclear@0 1134 #define AI_MATKEY_MAPPINGMODE_V_SHININESS(N) \
nuclear@0 1135 AI_MATKEY_MAPPINGMODE_V(aiTextureType_SHININESS,N)
nuclear@0 1136
nuclear@0 1137 #define AI_MATKEY_MAPPINGMODE_V_OPACITY(N) \
nuclear@0 1138 AI_MATKEY_MAPPINGMODE_V(aiTextureType_OPACITY,N)
nuclear@0 1139
nuclear@0 1140 #define AI_MATKEY_MAPPINGMODE_V_DISPLACEMENT(N) \
nuclear@0 1141 AI_MATKEY_MAPPINGMODE_V(aiTextureType_DISPLACEMENT,N)
nuclear@0 1142
nuclear@0 1143 #define AI_MATKEY_MAPPINGMODE_V_LIGHTMAP(N) \
nuclear@0 1144 AI_MATKEY_MAPPINGMODE_V(aiTextureType_LIGHTMAP,N)
nuclear@0 1145
nuclear@0 1146 #define AI_MATKEY_MAPPINGMODE_V_REFLECTION(N) \
nuclear@0 1147 AI_MATKEY_MAPPINGMODE_V(aiTextureType_REFLECTION,N)
nuclear@0 1148
nuclear@0 1149 //! @endcond
nuclear@0 1150 // ---------------------------------------------------------------------------
nuclear@0 1151 #define AI_MATKEY_TEXMAP_AXIS(type, N) _AI_MATKEY_TEXMAP_AXIS_BASE,type,N
nuclear@0 1152
nuclear@0 1153 // For backward compatibility and simplicity
nuclear@0 1154 //! @cond MATS_DOC_FULL
nuclear@0 1155 #define AI_MATKEY_TEXMAP_AXIS_DIFFUSE(N) \
nuclear@0 1156 AI_MATKEY_TEXMAP_AXIS(aiTextureType_DIFFUSE,N)
nuclear@0 1157
nuclear@0 1158 #define AI_MATKEY_TEXMAP_AXIS_SPECULAR(N) \
nuclear@0 1159 AI_MATKEY_TEXMAP_AXIS(aiTextureType_SPECULAR,N)
nuclear@0 1160
nuclear@0 1161 #define AI_MATKEY_TEXMAP_AXIS_AMBIENT(N) \
nuclear@0 1162 AI_MATKEY_TEXMAP_AXIS(aiTextureType_AMBIENT,N)
nuclear@0 1163
nuclear@0 1164 #define AI_MATKEY_TEXMAP_AXIS_EMISSIVE(N) \
nuclear@0 1165 AI_MATKEY_TEXMAP_AXIS(aiTextureType_EMISSIVE,N)
nuclear@0 1166
nuclear@0 1167 #define AI_MATKEY_TEXMAP_AXIS_NORMALS(N) \
nuclear@0 1168 AI_MATKEY_TEXMAP_AXIS(aiTextureType_NORMALS,N)
nuclear@0 1169
nuclear@0 1170 #define AI_MATKEY_TEXMAP_AXIS_HEIGHT(N) \
nuclear@0 1171 AI_MATKEY_TEXMAP_AXIS(aiTextureType_HEIGHT,N)
nuclear@0 1172
nuclear@0 1173 #define AI_MATKEY_TEXMAP_AXIS_SHININESS(N) \
nuclear@0 1174 AI_MATKEY_TEXMAP_AXIS(aiTextureType_SHININESS,N)
nuclear@0 1175
nuclear@0 1176 #define AI_MATKEY_TEXMAP_AXIS_OPACITY(N) \
nuclear@0 1177 AI_MATKEY_TEXMAP_AXIS(aiTextureType_OPACITY,N)
nuclear@0 1178
nuclear@0 1179 #define AI_MATKEY_TEXMAP_AXIS_DISPLACEMENT(N) \
nuclear@0 1180 AI_MATKEY_TEXMAP_AXIS(aiTextureType_DISPLACEMENT,N)
nuclear@0 1181
nuclear@0 1182 #define AI_MATKEY_TEXMAP_AXIS_LIGHTMAP(N) \
nuclear@0 1183 AI_MATKEY_TEXMAP_AXIS(aiTextureType_LIGHTMAP,N)
nuclear@0 1184
nuclear@0 1185 #define AI_MATKEY_TEXMAP_AXIS_REFLECTION(N) \
nuclear@0 1186 AI_MATKEY_TEXMAP_AXIS(aiTextureType_REFLECTION,N)
nuclear@0 1187
nuclear@0 1188 //! @endcond
nuclear@0 1189 // ---------------------------------------------------------------------------
nuclear@0 1190 #define AI_MATKEY_UVTRANSFORM(type, N) _AI_MATKEY_UVTRANSFORM_BASE,type,N
nuclear@0 1191
nuclear@0 1192 // For backward compatibility and simplicity
nuclear@0 1193 //! @cond MATS_DOC_FULL
nuclear@0 1194 #define AI_MATKEY_UVTRANSFORM_DIFFUSE(N) \
nuclear@0 1195 AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE,N)
nuclear@0 1196
nuclear@0 1197 #define AI_MATKEY_UVTRANSFORM_SPECULAR(N) \
nuclear@0 1198 AI_MATKEY_UVTRANSFORM(aiTextureType_SPECULAR,N)
nuclear@0 1199
nuclear@0 1200 #define AI_MATKEY_UVTRANSFORM_AMBIENT(N) \
nuclear@0 1201 AI_MATKEY_UVTRANSFORM(aiTextureType_AMBIENT,N)
nuclear@0 1202
nuclear@0 1203 #define AI_MATKEY_UVTRANSFORM_EMISSIVE(N) \
nuclear@0 1204 AI_MATKEY_UVTRANSFORM(aiTextureType_EMISSIVE,N)
nuclear@0 1205
nuclear@0 1206 #define AI_MATKEY_UVTRANSFORM_NORMALS(N) \
nuclear@0 1207 AI_MATKEY_UVTRANSFORM(aiTextureType_NORMALS,N)
nuclear@0 1208
nuclear@0 1209 #define AI_MATKEY_UVTRANSFORM_HEIGHT(N) \
nuclear@0 1210 AI_MATKEY_UVTRANSFORM(aiTextureType_HEIGHT,N)
nuclear@0 1211
nuclear@0 1212 #define AI_MATKEY_UVTRANSFORM_SHININESS(N) \
nuclear@0 1213 AI_MATKEY_UVTRANSFORM(aiTextureType_SHININESS,N)
nuclear@0 1214
nuclear@0 1215 #define AI_MATKEY_UVTRANSFORM_OPACITY(N) \
nuclear@0 1216 AI_MATKEY_UVTRANSFORM(aiTextureType_OPACITY,N)
nuclear@0 1217
nuclear@0 1218 #define AI_MATKEY_UVTRANSFORM_DISPLACEMENT(N) \
nuclear@0 1219 AI_MATKEY_UVTRANSFORM(aiTextureType_DISPLACEMENT,N)
nuclear@0 1220
nuclear@0 1221 #define AI_MATKEY_UVTRANSFORM_LIGHTMAP(N) \
nuclear@0 1222 AI_MATKEY_UVTRANSFORM(aiTextureType_LIGHTMAP,N)
nuclear@0 1223
nuclear@0 1224 #define AI_MATKEY_UVTRANSFORM_REFLECTION(N) \
nuclear@0 1225 AI_MATKEY_UVTRANSFORM(aiTextureType_REFLECTION,N)
nuclear@0 1226
nuclear@0 1227 #define AI_MATKEY_UVTRANSFORM_UNKNOWN(N) \
nuclear@0 1228 AI_MATKEY_UVTRANSFORM(aiTextureType_UNKNOWN,N)
nuclear@0 1229
nuclear@0 1230 //! @endcond
nuclear@0 1231 // ---------------------------------------------------------------------------
nuclear@0 1232 #define AI_MATKEY_TEXFLAGS(type, N) _AI_MATKEY_TEXFLAGS_BASE,type,N
nuclear@0 1233
nuclear@0 1234 // For backward compatibility and simplicity
nuclear@0 1235 //! @cond MATS_DOC_FULL
nuclear@0 1236 #define AI_MATKEY_TEXFLAGS_DIFFUSE(N) \
nuclear@0 1237 AI_MATKEY_TEXFLAGS(aiTextureType_DIFFUSE,N)
nuclear@0 1238
nuclear@0 1239 #define AI_MATKEY_TEXFLAGS_SPECULAR(N) \
nuclear@0 1240 AI_MATKEY_TEXFLAGS(aiTextureType_SPECULAR,N)
nuclear@0 1241
nuclear@0 1242 #define AI_MATKEY_TEXFLAGS_AMBIENT(N) \
nuclear@0 1243 AI_MATKEY_TEXFLAGS(aiTextureType_AMBIENT,N)
nuclear@0 1244
nuclear@0 1245 #define AI_MATKEY_TEXFLAGS_EMISSIVE(N) \
nuclear@0 1246 AI_MATKEY_TEXFLAGS(aiTextureType_EMISSIVE,N)
nuclear@0 1247
nuclear@0 1248 #define AI_MATKEY_TEXFLAGS_NORMALS(N) \
nuclear@0 1249 AI_MATKEY_TEXFLAGS(aiTextureType_NORMALS,N)
nuclear@0 1250
nuclear@0 1251 #define AI_MATKEY_TEXFLAGS_HEIGHT(N) \
nuclear@0 1252 AI_MATKEY_TEXFLAGS(aiTextureType_HEIGHT,N)
nuclear@0 1253
nuclear@0 1254 #define AI_MATKEY_TEXFLAGS_SHININESS(N) \
nuclear@0 1255 AI_MATKEY_TEXFLAGS(aiTextureType_SHININESS,N)
nuclear@0 1256
nuclear@0 1257 #define AI_MATKEY_TEXFLAGS_OPACITY(N) \
nuclear@0 1258 AI_MATKEY_TEXFLAGS(aiTextureType_OPACITY,N)
nuclear@0 1259
nuclear@0 1260 #define AI_MATKEY_TEXFLAGS_DISPLACEMENT(N) \
nuclear@0 1261 AI_MATKEY_TEXFLAGS(aiTextureType_DISPLACEMENT,N)
nuclear@0 1262
nuclear@0 1263 #define AI_MATKEY_TEXFLAGS_LIGHTMAP(N) \
nuclear@0 1264 AI_MATKEY_TEXFLAGS(aiTextureType_LIGHTMAP,N)
nuclear@0 1265
nuclear@0 1266 #define AI_MATKEY_TEXFLAGS_REFLECTION(N) \
nuclear@0 1267 AI_MATKEY_TEXFLAGS(aiTextureType_REFLECTION,N)
nuclear@0 1268
nuclear@0 1269 #define AI_MATKEY_TEXFLAGS_UNKNOWN(N) \
nuclear@0 1270 AI_MATKEY_TEXFLAGS(aiTextureType_UNKNOWN,N)
nuclear@0 1271
nuclear@0 1272 // ---------------------------------------------------------------------------
nuclear@0 1273 /** @brief Retrieve a material property with a specific key from the material
nuclear@0 1274 *
nuclear@0 1275 * @param pMat Pointer to the input material. May not be NULL
nuclear@0 1276 * @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
nuclear@0 1277 * @param type Specifies the type of the texture to be retrieved (
nuclear@0 1278 * e.g. diffuse, specular, height map ...)
nuclear@0 1279 * @param index Index of the texture to be retrieved.
nuclear@0 1280 * @param pPropOut Pointer to receive a pointer to a valid aiMaterialProperty
nuclear@0 1281 * structure or NULL if the key has not been found. */
nuclear@0 1282 // ---------------------------------------------------------------------------
nuclear@0 1283 ASSIMP_API C_ENUM aiReturn aiGetMaterialProperty(
nuclear@0 1284 const C_STRUCT aiMaterial* pMat,
nuclear@0 1285 const char* pKey,
nuclear@0 1286 unsigned int type,
nuclear@0 1287 unsigned int index,
nuclear@0 1288 const C_STRUCT aiMaterialProperty** pPropOut);
nuclear@0 1289
nuclear@0 1290 // ---------------------------------------------------------------------------
nuclear@0 1291 /** @brief Retrieve an array of float values with a specific key
nuclear@0 1292 * from the material
nuclear@0 1293 *
nuclear@0 1294 * Pass one of the AI_MATKEY_XXX constants for the last three parameters (the
nuclear@0 1295 * example reads the #AI_MATKEY_UVTRANSFORM property of the first diffuse texture)
nuclear@0 1296 * @code
nuclear@0 1297 * aiUVTransform trafo;
nuclear@0 1298 * unsigned int max = sizeof(aiUVTransform);
nuclear@0 1299 * if (AI_SUCCESS != aiGetMaterialFloatArray(mat, AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE,0),
nuclear@0 1300 * (float*)&trafo, &max) || sizeof(aiUVTransform) != max)
nuclear@0 1301 * {
nuclear@0 1302 * // error handling
nuclear@0 1303 * }
nuclear@0 1304 * @endcode
nuclear@0 1305 *
nuclear@0 1306 * @param pMat Pointer to the input material. May not be NULL
nuclear@0 1307 * @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
nuclear@0 1308 * @param pOut Pointer to a buffer to receive the result.
nuclear@0 1309 * @param pMax Specifies the size of the given buffer, in float's.
nuclear@0 1310 * Receives the number of values (not bytes!) read.
nuclear@0 1311 * @param type (see the code sample above)
nuclear@0 1312 * @param index (see the code sample above)
nuclear@0 1313 * @return Specifies whether the key has been found. If not, the output
nuclear@0 1314 * arrays remains unmodified and pMax is set to 0.*/
nuclear@0 1315 // ---------------------------------------------------------------------------
nuclear@0 1316 ASSIMP_API C_ENUM aiReturn aiGetMaterialFloatArray(
nuclear@0 1317 const C_STRUCT aiMaterial* pMat,
nuclear@0 1318 const char* pKey,
nuclear@0 1319 unsigned int type,
nuclear@0 1320 unsigned int index,
nuclear@0 1321 float* pOut,
nuclear@0 1322 unsigned int* pMax);
nuclear@0 1323
nuclear@0 1324
nuclear@0 1325 #ifdef __cplusplus
nuclear@0 1326
nuclear@0 1327 // ---------------------------------------------------------------------------
nuclear@0 1328 /** @brief Retrieve a single float property with a specific key from the material.
nuclear@0 1329 *
nuclear@0 1330 * Pass one of the AI_MATKEY_XXX constants for the last three parameters (the
nuclear@0 1331 * example reads the #AI_MATKEY_SHININESS_STRENGTH property of the first diffuse texture)
nuclear@0 1332 * @code
nuclear@0 1333 * float specStrength = 1.f; // default value, remains unmodified if we fail.
nuclear@0 1334 * aiGetMaterialFloat(mat, AI_MATKEY_SHININESS_STRENGTH,
nuclear@0 1335 * (float*)&specStrength);
nuclear@0 1336 * @endcode
nuclear@0 1337 *
nuclear@0 1338 * @param pMat Pointer to the input material. May not be NULL
nuclear@0 1339 * @param pKey Key to search for. One of the AI_MATKEY_XXX constants.
nuclear@0 1340 * @param pOut Receives the output float.
nuclear@0 1341 * @param type (see the code sample above)
nuclear@0 1342 * @param index (see the code sample above)
nuclear@0 1343 * @return Specifies whether the key has been found. If not, the output
nuclear@0 1344 * float remains unmodified.*/
nuclear@0 1345 // ---------------------------------------------------------------------------
nuclear@0 1346 inline aiReturn aiGetMaterialFloat(const aiMaterial* pMat,
nuclear@0 1347 const char* pKey,
nuclear@0 1348 unsigned int type,
nuclear@0 1349 unsigned int index,
nuclear@0 1350 float* pOut)
nuclear@0 1351 {
nuclear@0 1352 return aiGetMaterialFloatArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0);
nuclear@0 1353 }
nuclear@0 1354
nuclear@0 1355 #else
nuclear@0 1356
nuclear@0 1357 // Use our friend, the C preprocessor
nuclear@0 1358 #define aiGetMaterialFloat (pMat, type, index, pKey, pOut) \
nuclear@0 1359 aiGetMaterialFloatArray(pMat, type, index, pKey, pOut, NULL)
nuclear@0 1360
nuclear@0 1361 #endif //!__cplusplus
nuclear@0 1362
nuclear@0 1363
nuclear@0 1364 // ---------------------------------------------------------------------------
nuclear@0 1365 /** @brief Retrieve an array of integer values with a specific key
nuclear@0 1366 * from a material
nuclear@0 1367 *
nuclear@0 1368 * See the sample for aiGetMaterialFloatArray for more information.*/
nuclear@0 1369 ASSIMP_API C_ENUM aiReturn aiGetMaterialIntegerArray(const C_STRUCT aiMaterial* pMat,
nuclear@0 1370 const char* pKey,
nuclear@0 1371 unsigned int type,
nuclear@0 1372 unsigned int index,
nuclear@0 1373 int* pOut,
nuclear@0 1374 unsigned int* pMax);
nuclear@0 1375
nuclear@0 1376
nuclear@0 1377 #ifdef __cplusplus
nuclear@0 1378
nuclear@0 1379 // ---------------------------------------------------------------------------
nuclear@0 1380 /** @brief Retrieve an integer property with a specific key from a material
nuclear@0 1381 *
nuclear@0 1382 * See the sample for aiGetMaterialFloat for more information.*/
nuclear@0 1383 // ---------------------------------------------------------------------------
nuclear@0 1384 inline aiReturn aiGetMaterialInteger(const C_STRUCT aiMaterial* pMat,
nuclear@0 1385 const char* pKey,
nuclear@0 1386 unsigned int type,
nuclear@0 1387 unsigned int index,
nuclear@0 1388 int* pOut)
nuclear@0 1389 {
nuclear@0 1390 return aiGetMaterialIntegerArray(pMat,pKey,type,index,pOut,(unsigned int*)0x0);
nuclear@0 1391 }
nuclear@0 1392
nuclear@0 1393 #else
nuclear@0 1394
nuclear@0 1395 // use our friend, the C preprocessor
nuclear@0 1396 #define aiGetMaterialInteger (pMat, type, index, pKey, pOut) \
nuclear@0 1397 aiGetMaterialIntegerArray(pMat, type, index, pKey, pOut, NULL)
nuclear@0 1398
nuclear@0 1399 #endif //!__cplusplus
nuclear@0 1400
nuclear@0 1401
nuclear@0 1402
nuclear@0 1403 // ---------------------------------------------------------------------------
nuclear@0 1404 /** @brief Retrieve a color value from the material property table
nuclear@0 1405 *
nuclear@0 1406 * See the sample for aiGetMaterialFloat for more information*/
nuclear@0 1407 // ---------------------------------------------------------------------------
nuclear@0 1408 ASSIMP_API C_ENUM aiReturn aiGetMaterialColor(const C_STRUCT aiMaterial* pMat,
nuclear@0 1409 const char* pKey,
nuclear@0 1410 unsigned int type,
nuclear@0 1411 unsigned int index,
nuclear@0 1412 C_STRUCT aiColor4D* pOut);
nuclear@0 1413
nuclear@0 1414
nuclear@0 1415 // ---------------------------------------------------------------------------
nuclear@0 1416 /** @brief Retrieve a string from the material property table
nuclear@0 1417 *
nuclear@0 1418 * See the sample for aiGetMaterialFloat for more information.*/
nuclear@0 1419 // ---------------------------------------------------------------------------
nuclear@0 1420 ASSIMP_API C_ENUM aiReturn aiGetMaterialString(const C_STRUCT aiMaterial* pMat,
nuclear@0 1421 const char* pKey,
nuclear@0 1422 unsigned int type,
nuclear@0 1423 unsigned int index,
nuclear@0 1424 C_STRUCT aiString* pOut);
nuclear@0 1425
nuclear@0 1426 // ---------------------------------------------------------------------------
nuclear@0 1427 /** Get the number of textures for a particular texture type.
nuclear@0 1428 * @param[in] pMat Pointer to the input material. May not be NULL
nuclear@0 1429 * @param type Texture type to check for
nuclear@0 1430 * @return Number of textures for this type.
nuclear@0 1431 * @note A texture can be easily queried using #aiGetMaterialTexture() */
nuclear@0 1432 // ---------------------------------------------------------------------------
nuclear@0 1433 ASSIMP_API unsigned int aiGetMaterialTextureCount(const C_STRUCT aiMaterial* pMat,
nuclear@0 1434 C_ENUM aiTextureType type);
nuclear@0 1435
nuclear@0 1436 // ---------------------------------------------------------------------------
nuclear@0 1437 /** @brief Helper function to get all values pertaining to a particular
nuclear@0 1438 * texture slot from a material structure.
nuclear@0 1439 *
nuclear@0 1440 * This function is provided just for convenience. You could also read the
nuclear@0 1441 * texture by parsing all of its properties manually. This function bundles
nuclear@0 1442 * all of them in a huge function monster.
nuclear@0 1443 *
nuclear@0 1444 * @param[in] mat Pointer to the input material. May not be NULL
nuclear@0 1445 * @param[in] type Specifies the texture stack to read from (e.g. diffuse,
nuclear@0 1446 * specular, height map ...).
nuclear@0 1447 * @param[in] index Index of the texture. The function fails if the
nuclear@0 1448 * requested index is not available for this texture type.
nuclear@0 1449 * #aiGetMaterialTextureCount() can be used to determine the number of
nuclear@0 1450 * textures in a particular texture stack.
nuclear@0 1451 * @param[out] path Receives the output path
nuclear@0 1452 * This parameter must be non-null.
nuclear@0 1453 * @param mapping The texture mapping mode to be used.
nuclear@0 1454 * Pass NULL if you're not interested in this information.
nuclear@0 1455 * @param[out] uvindex For UV-mapped textures: receives the index of the UV
nuclear@0 1456 * source channel. Unmodified otherwise.
nuclear@0 1457 * Pass NULL if you're not interested in this information.
nuclear@0 1458 * @param[out] blend Receives the blend factor for the texture
nuclear@0 1459 * Pass NULL if you're not interested in this information.
nuclear@0 1460 * @param[out] op Receives the texture blend operation to be perform between
nuclear@0 1461 * this texture and the previous texture.
nuclear@0 1462 * Pass NULL if you're not interested in this information.
nuclear@0 1463 * @param[out] mapmode Receives the mapping modes to be used for the texture.
nuclear@0 1464 * Pass NULL if you're not interested in this information. Otherwise,
nuclear@0 1465 * pass a pointer to an array of two aiTextureMapMode's (one for each
nuclear@0 1466 * axis, UV order).
nuclear@0 1467 * @return AI_SUCCESS on success, otherwise something else. Have fun.*/
nuclear@0 1468 // ---------------------------------------------------------------------------
nuclear@0 1469 #ifdef __cplusplus
nuclear@0 1470 ASSIMP_API aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
nuclear@0 1471 aiTextureType type,
nuclear@0 1472 unsigned int index,
nuclear@0 1473 aiString* path,
nuclear@0 1474 aiTextureMapping* mapping = NULL,
nuclear@0 1475 unsigned int* uvindex = NULL,
nuclear@0 1476 float* blend = NULL,
nuclear@0 1477 aiTextureOp* op = NULL,
nuclear@0 1478 aiTextureMapMode* mapmode = NULL,
nuclear@0 1479 unsigned int* flags = NULL);
nuclear@0 1480 #else
nuclear@0 1481 C_ENUM aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
nuclear@0 1482 C_ENUM aiTextureType type,
nuclear@0 1483 unsigned int index,
nuclear@0 1484 C_STRUCT aiString* path,
nuclear@0 1485 C_ENUM aiTextureMapping* mapping /*= NULL*/,
nuclear@0 1486 unsigned int* uvindex /*= NULL*/,
nuclear@0 1487 float* blend /*= NULL*/,
nuclear@0 1488 C_ENUM aiTextureOp* op /*= NULL*/,
nuclear@0 1489 C_ENUM aiTextureMapMode* mapmode /*= NULL*/,
nuclear@0 1490 unsigned int* flags /*= NULL*/);
nuclear@0 1491 #endif // !#ifdef __cplusplus
nuclear@0 1492
nuclear@0 1493 #ifdef __cplusplus
nuclear@0 1494 }
nuclear@0 1495
nuclear@0 1496 #include "material.inl"
nuclear@0 1497
nuclear@0 1498 #endif //!__cplusplus
nuclear@0 1499 #endif //!!AI_MATERIAL_H_INC