miniassimp

annotate include/miniassimp/material.h @ 0:879c81d94345

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