From f9158592e1478b2013afc7041d9ed041cf2d2f4a Mon Sep 17 00:00:00 2001 From: David Walter Seikel Date: Mon, 13 Jan 2014 19:47:58 +1000 Subject: Update Irrlicht to 1.8.1. Include actual change markers this time. lol --- .../doc/html/_s_material_8h_source.html | 648 +++++++++++++++++++++ 1 file changed, 648 insertions(+) create mode 100644 libraries/irrlicht-1.8.1/doc/html/_s_material_8h_source.html (limited to 'libraries/irrlicht-1.8.1/doc/html/_s_material_8h_source.html') diff --git a/libraries/irrlicht-1.8.1/doc/html/_s_material_8h_source.html b/libraries/irrlicht-1.8.1/doc/html/_s_material_8h_source.html new file mode 100644 index 0000000..fad581a --- /dev/null +++ b/libraries/irrlicht-1.8.1/doc/html/_s_material_8h_source.html @@ -0,0 +1,648 @@ + + +
+ +00001 // Copyright (C) 2002-2012 Nikolaus Gebhardt +00002 // This file is part of the "Irrlicht Engine". +00003 // For conditions of distribution and use, see copyright notice in irrlicht.h +00004 +00005 #ifndef __S_MATERIAL_H_INCLUDED__ +00006 #define __S_MATERIAL_H_INCLUDED__ +00007 +00008 #include "SColor.h" +00009 #include "matrix4.h" +00010 #include "irrArray.h" +00011 #include "irrMath.h" +00012 #include "EMaterialTypes.h" +00013 #include "EMaterialFlags.h" +00014 #include "SMaterialLayer.h" +00015 +00016 namespace irr +00017 { +00018 namespace video +00019 { +00020 class ITexture; +00021 +00023 enum E_BLEND_FACTOR +00024 { +00025 EBF_ZERO = 0, +00026 EBF_ONE, +00027 EBF_DST_COLOR, +00028 EBF_ONE_MINUS_DST_COLOR, +00029 EBF_SRC_COLOR, +00030 EBF_ONE_MINUS_SRC_COLOR, +00031 EBF_SRC_ALPHA, +00032 EBF_ONE_MINUS_SRC_ALPHA, +00033 EBF_DST_ALPHA, +00034 EBF_ONE_MINUS_DST_ALPHA, +00035 EBF_SRC_ALPHA_SATURATE +00036 }; +00037 +00039 enum E_BLEND_OPERATION +00040 { +00041 EBO_NONE = 0, +00042 EBO_ADD, +00043 EBO_SUBTRACT, +00044 EBO_REVSUBTRACT, +00045 EBO_MIN, +00046 EBO_MAX, +00047 EBO_MIN_FACTOR, +00048 EBO_MAX_FACTOR, +00049 EBO_MIN_ALPHA, +00050 EBO_MAX_ALPHA +00051 }; +00052 +00054 enum E_MODULATE_FUNC +00055 { +00056 EMFN_MODULATE_1X = 1, +00057 EMFN_MODULATE_2X = 2, +00058 EMFN_MODULATE_4X = 4 +00059 }; +00060 +00062 enum E_COMPARISON_FUNC +00063 { +00065 ECFN_NEVER=0, +00067 ECFN_LESSEQUAL=1, +00069 ECFN_EQUAL=2, +00071 ECFN_LESS, +00073 ECFN_NOTEQUAL, +00075 ECFN_GREATEREQUAL, +00077 ECFN_GREATER, +00079 ECFN_ALWAYS +00080 }; +00081 +00083 enum E_COLOR_PLANE +00084 { +00086 ECP_NONE=0, +00088 ECP_ALPHA=1, +00090 ECP_RED=2, +00092 ECP_GREEN=4, +00094 ECP_BLUE=8, +00096 ECP_RGB=14, +00098 ECP_ALL=15 +00099 }; +00100 +00102 +00104 enum E_ALPHA_SOURCE +00105 { +00107 EAS_NONE=0, +00109 EAS_VERTEX_COLOR, +00111 EAS_TEXTURE +00112 }; +00113 +00115 +00116 inline f32 pack_textureBlendFunc ( const E_BLEND_FACTOR srcFact, const E_BLEND_FACTOR dstFact, const E_MODULATE_FUNC modulate=EMFN_MODULATE_1X, const u32 alphaSource=EAS_TEXTURE ) +00117 { +00118 const u32 tmp = (alphaSource << 12) | (modulate << 8) | (srcFact << 4) | dstFact; +00119 return FR(tmp); +00120 } +00121 +00123 +00124 inline void unpack_textureBlendFunc ( E_BLEND_FACTOR &srcFact, E_BLEND_FACTOR &dstFact, +00125 E_MODULATE_FUNC &modulo, u32& alphaSource, const f32 param ) +00126 { +00127 const u32 state = IR(param); +00128 alphaSource = (state & 0x0000F000) >> 12; +00129 modulo = E_MODULATE_FUNC( ( state & 0x00000F00 ) >> 8 ); +00130 srcFact = E_BLEND_FACTOR ( ( state & 0x000000F0 ) >> 4 ); +00131 dstFact = E_BLEND_FACTOR ( ( state & 0x0000000F ) ); +00132 } +00133 +00135 inline bool textureBlendFunc_hasAlpha ( const E_BLEND_FACTOR factor ) +00136 { +00137 switch ( factor ) +00138 { +00139 case EBF_SRC_ALPHA: +00140 case EBF_ONE_MINUS_SRC_ALPHA: +00141 case EBF_DST_ALPHA: +00142 case EBF_ONE_MINUS_DST_ALPHA: +00143 case EBF_SRC_ALPHA_SATURATE: +00144 return true; +00145 default: +00146 return false; +00147 } +00148 } +00149 +00150 +00152 +00158 enum E_ANTI_ALIASING_MODE +00159 { +00161 EAAM_OFF=0, +00163 EAAM_SIMPLE=1, +00165 EAAM_QUALITY=3, +00167 EAAM_LINE_SMOOTH=4, +00169 EAAM_POINT_SMOOTH=8, +00171 EAAM_FULL_BASIC=15, +00173 +00174 EAAM_ALPHA_TO_COVERAGE=16 +00175 }; +00176 +00178 +00184 enum E_COLOR_MATERIAL +00185 { +00187 ECM_NONE=0, +00189 ECM_DIFFUSE, +00191 ECM_AMBIENT, +00193 ECM_EMISSIVE, +00195 ECM_SPECULAR, +00197 ECM_DIFFUSE_AND_AMBIENT +00198 }; +00199 +00201 +00202 enum E_POLYGON_OFFSET +00203 { +00205 +00206 EPO_BACK=0, +00208 +00210 EPO_FRONT=1 +00211 }; +00212 +00214 const c8* const PolygonOffsetDirectionNames[] = +00215 { +00216 "Back", +00217 "Front", +00218 0 +00219 }; +00220 +00221 +00223 const u32 MATERIAL_MAX_TEXTURES = _IRR_MATERIAL_MAX_TEXTURES_; +00224 +00226 class SMaterial +00227 { +00228 public: +00230 SMaterial() +00231 : MaterialType(EMT_SOLID), AmbientColor(255,255,255,255), DiffuseColor(255,255,255,255), +00232 EmissiveColor(0,0,0,0), SpecularColor(255,255,255,255), +00233 Shininess(0.0f), MaterialTypeParam(0.0f), MaterialTypeParam2(0.0f), Thickness(1.0f), +00234 ZBuffer(ECFN_LESSEQUAL), AntiAliasing(EAAM_SIMPLE), ColorMask(ECP_ALL), +00235 ColorMaterial(ECM_DIFFUSE), BlendOperation(EBO_NONE), +00236 PolygonOffsetFactor(0), PolygonOffsetDirection(EPO_FRONT), +00237 Wireframe(false), PointCloud(false), GouraudShading(true), +00238 Lighting(true), ZWriteEnable(true), BackfaceCulling(true), FrontfaceCulling(false), +00239 FogEnable(false), NormalizeNormals(false), UseMipMaps(true) +00240 { } +00241 +00243 +00244 SMaterial(const SMaterial& other) +00245 { +00246 // These pointers are checked during assignment +00247 for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i) +00248 TextureLayer[i].TextureMatrix = 0; +00249 *this = other; +00250 } +00251 +00253 +00254 SMaterial& operator=(const SMaterial& other) +00255 { +00256 // Check for self-assignment! +00257 if (this == &other) +00258 return *this; +00259 +00260 MaterialType = other.MaterialType; +00261 +00262 AmbientColor = other.AmbientColor; +00263 DiffuseColor = other.DiffuseColor; +00264 EmissiveColor = other.EmissiveColor; +00265 SpecularColor = other.SpecularColor; +00266 Shininess = other.Shininess; +00267 MaterialTypeParam = other.MaterialTypeParam; +00268 MaterialTypeParam2 = other.MaterialTypeParam2; +00269 Thickness = other.Thickness; +00270 for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i) +00271 { +00272 TextureLayer[i] = other.TextureLayer[i]; +00273 } +00274 +00275 Wireframe = other.Wireframe; +00276 PointCloud = other.PointCloud; +00277 GouraudShading = other.GouraudShading; +00278 Lighting = other.Lighting; +00279 ZWriteEnable = other.ZWriteEnable; +00280 BackfaceCulling = other.BackfaceCulling; +00281 FrontfaceCulling = other.FrontfaceCulling; +00282 FogEnable = other.FogEnable; +00283 NormalizeNormals = other.NormalizeNormals; +00284 ZBuffer = other.ZBuffer; +00285 AntiAliasing = other.AntiAliasing; +00286 ColorMask = other.ColorMask; +00287 ColorMaterial = other.ColorMaterial; +00288 BlendOperation = other.BlendOperation; +00289 PolygonOffsetFactor = other.PolygonOffsetFactor; +00290 PolygonOffsetDirection = other.PolygonOffsetDirection; +00291 UseMipMaps = other.UseMipMaps; +00292 +00293 return *this; +00294 } +00295 +00297 SMaterialLayer TextureLayer[MATERIAL_MAX_TEXTURES]; +00298 +00300 E_MATERIAL_TYPE MaterialType; +00301 +00303 +00306 SColor AmbientColor; +00307 +00309 +00310 SColor DiffuseColor; +00311 +00313 SColor EmissiveColor; +00314 +00316 +00318 SColor SpecularColor; +00319 +00321 +00350 f32 Shininess; +00351 +00353 +00355 f32 MaterialTypeParam; +00356 +00358 +00359 f32 MaterialTypeParam2; +00360 +00362 f32 Thickness; +00363 +00365 +00366 u8 ZBuffer; +00367 +00369 +00372 u8 AntiAliasing; +00373 +00375 +00379 u8 ColorMask:4; +00380 +00382 +00387 u8 ColorMaterial:3; +00388 +00390 +00392 E_BLEND_OPERATION BlendOperation:4; +00393 +00395 +00397 u8 PolygonOffsetFactor:3; +00398 +00400 +00401 E_POLYGON_OFFSET PolygonOffsetDirection:1; +00402 +00404 +00407 bool Wireframe:1; +00408 +00410 bool PointCloud:1; +00411 +00413 bool GouraudShading:1; +00414 +00416 bool Lighting:1; +00417 +00419 +00422 bool ZWriteEnable:1; +00423 +00425 bool BackfaceCulling:1; +00426 +00428 bool FrontfaceCulling:1; +00429 +00431 bool FogEnable:1; +00432 +00434 +00435 bool NormalizeNormals:1; +00436 +00438 +00439 bool UseMipMaps:1; +00440 +00442 +00444 core::matrix4& getTextureMatrix(u32 i) +00445 { +00446 return TextureLayer[i].getTextureMatrix(); +00447 } +00448 +00450 +00452 const core::matrix4& getTextureMatrix(u32 i) const +00453 { +00454 if (i<MATERIAL_MAX_TEXTURES) +00455 return TextureLayer[i].getTextureMatrix(); +00456 else +00457 return core::IdentityMatrix; +00458 } +00459 +00461 +00463 void setTextureMatrix(u32 i, const core::matrix4& mat) +00464 { +00465 if (i>=MATERIAL_MAX_TEXTURES) +00466 return; +00467 TextureLayer[i].setTextureMatrix(mat); +00468 } +00469 +00471 +00473 ITexture* getTexture(u32 i) const +00474 { +00475 return i < MATERIAL_MAX_TEXTURES ? TextureLayer[i].Texture : 0; +00476 } +00477 +00479 +00482 void setTexture(u32 i, ITexture* tex) +00483 { +00484 if (i>=MATERIAL_MAX_TEXTURES) +00485 return; +00486 TextureLayer[i].Texture = tex; +00487 } +00488 +00490 +00492 void setFlag(E_MATERIAL_FLAG flag, bool value) +00493 { +00494 switch (flag) +00495 { +00496 case EMF_WIREFRAME: +00497 Wireframe = value; break; +00498 case EMF_POINTCLOUD: +00499 PointCloud = value; break; +00500 case EMF_GOURAUD_SHADING: +00501 GouraudShading = value; break; +00502 case EMF_LIGHTING: +00503 Lighting = value; break; +00504 case EMF_ZBUFFER: +00505 ZBuffer = value; break; +00506 case EMF_ZWRITE_ENABLE: +00507 ZWriteEnable = value; break; +00508 case EMF_BACK_FACE_CULLING: +00509 BackfaceCulling = value; break; +00510 case EMF_FRONT_FACE_CULLING: +00511 FrontfaceCulling = value; break; +00512 case EMF_BILINEAR_FILTER: +00513 { +00514 for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i) +00515 TextureLayer[i].BilinearFilter = value; +00516 } +00517 break; +00518 case EMF_TRILINEAR_FILTER: +00519 { +00520 for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i) +00521 TextureLayer[i].TrilinearFilter = value; +00522 } +00523 break; +00524 case EMF_ANISOTROPIC_FILTER: +00525 { +00526 if (value) +00527 for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i) +00528 TextureLayer[i].AnisotropicFilter = 0xFF; +00529 else +00530 for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i) +00531 TextureLayer[i].AnisotropicFilter = 0; +00532 } +00533 break; +00534 case EMF_FOG_ENABLE: +00535 FogEnable = value; break; +00536 case EMF_NORMALIZE_NORMALS: +00537 NormalizeNormals = value; break; +00538 case EMF_TEXTURE_WRAP: +00539 { +00540 for (u32 i=0; i<MATERIAL_MAX_TEXTURES; ++i) +00541 { +00542 TextureLayer[i].TextureWrapU = (E_TEXTURE_CLAMP)value; +00543 TextureLayer[i].TextureWrapV = (E_TEXTURE_CLAMP)value; +00544 } +00545 } +00546 break; +00547 case EMF_ANTI_ALIASING: +00548 AntiAliasing = value?EAAM_SIMPLE:EAAM_OFF; break; +00549 case EMF_COLOR_MASK: +00550 ColorMask = value?ECP_ALL:ECP_NONE; break; +00551 case EMF_COLOR_MATERIAL: +00552 ColorMaterial = value?ECM_DIFFUSE:ECM_NONE; break; +00553 case EMF_USE_MIP_MAPS: +00554 UseMipMaps = value; break; +00555 case EMF_BLEND_OPERATION: +00556 BlendOperation = value?EBO_ADD:EBO_NONE; break; +00557 case EMF_POLYGON_OFFSET: +00558 PolygonOffsetFactor = value?1:0; +00559 PolygonOffsetDirection = EPO_BACK; +00560 break; +00561 default: +00562 break; +00563 } +00564 } +00565 +00567 +00569 bool getFlag(E_MATERIAL_FLAG flag) const +00570 { +00571 switch (flag) +00572 { +00573 case EMF_WIREFRAME: +00574 return Wireframe; +00575 case EMF_POINTCLOUD: +00576 return PointCloud; +00577 case EMF_GOURAUD_SHADING: +00578 return GouraudShading; +00579 case EMF_LIGHTING: +00580 return Lighting; +00581 case EMF_ZBUFFER: +00582 return ZBuffer!=ECFN_NEVER; +00583 case EMF_ZWRITE_ENABLE: +00584 return ZWriteEnable; +00585 case EMF_BACK_FACE_CULLING: +00586 return BackfaceCulling; +00587 case EMF_FRONT_FACE_CULLING: +00588 return FrontfaceCulling; +00589 case EMF_BILINEAR_FILTER: +00590 return TextureLayer[0].BilinearFilter; +00591 case EMF_TRILINEAR_FILTER: +00592 return TextureLayer[0].TrilinearFilter; +00593 case EMF_ANISOTROPIC_FILTER: +00594 return TextureLayer[0].AnisotropicFilter!=0; +00595 case EMF_FOG_ENABLE: +00596 return FogEnable; +00597 case EMF_NORMALIZE_NORMALS: +00598 return NormalizeNormals; +00599 case EMF_TEXTURE_WRAP: +00600 return !(TextureLayer[0].TextureWrapU || +00601 TextureLayer[0].TextureWrapV || +00602 TextureLayer[1].TextureWrapU || +00603 TextureLayer[1].TextureWrapV || +00604 TextureLayer[2].TextureWrapU || +00605 TextureLayer[2].TextureWrapV || +00606 TextureLayer[3].TextureWrapU || +00607 TextureLayer[3].TextureWrapV); +00608 case EMF_ANTI_ALIASING: +00609 return (AntiAliasing==1); +00610 case EMF_COLOR_MASK: +00611 return (ColorMask!=ECP_NONE); +00612 case EMF_COLOR_MATERIAL: +00613 return (ColorMaterial != ECM_NONE); +00614 case EMF_USE_MIP_MAPS: +00615 return UseMipMaps; +00616 case EMF_BLEND_OPERATION: +00617 return BlendOperation != EBO_NONE; +00618 case EMF_POLYGON_OFFSET: +00619 return PolygonOffsetFactor != 0; +00620 } +00621 +00622 return false; +00623 } +00624 +00626 +00628 inline bool operator!=(const SMaterial& b) const +00629 { +00630 bool different = +00631 MaterialType != b.MaterialType || +00632 AmbientColor != b.AmbientColor || +00633 DiffuseColor != b.DiffuseColor || +00634 EmissiveColor != b.EmissiveColor || +00635 SpecularColor != b.SpecularColor || +00636 Shininess != b.Shininess || +00637 MaterialTypeParam != b.MaterialTypeParam || +00638 MaterialTypeParam2 != b.MaterialTypeParam2 || +00639 Thickness != b.Thickness || +00640 Wireframe != b.Wireframe || +00641 PointCloud != b.PointCloud || +00642 GouraudShading != b.GouraudShading || +00643 Lighting != b.Lighting || +00644 ZBuffer != b.ZBuffer || +00645 ZWriteEnable != b.ZWriteEnable || +00646 BackfaceCulling != b.BackfaceCulling || +00647 FrontfaceCulling != b.FrontfaceCulling || +00648 FogEnable != b.FogEnable || +00649 NormalizeNormals != b.NormalizeNormals || +00650 AntiAliasing != b.AntiAliasing || +00651 ColorMask != b.ColorMask || +00652 ColorMaterial != b.ColorMaterial || +00653 BlendOperation != b.BlendOperation || +00654 PolygonOffsetFactor != b.PolygonOffsetFactor || +00655 PolygonOffsetDirection != b.PolygonOffsetDirection || +00656 UseMipMaps != b.UseMipMaps; +00657 for (u32 i=0; (i<MATERIAL_MAX_TEXTURES) && !different; ++i) +00658 { +00659 different |= (TextureLayer[i] != b.TextureLayer[i]); +00660 } +00661 return different; +00662 } +00663 +00665 +00667 inline bool operator==(const SMaterial& b) const +00668 { return !(b!=*this); } +00669 +00670 bool isTransparent() const +00671 { +00672 return MaterialType==EMT_TRANSPARENT_ADD_COLOR || +00673 MaterialType==EMT_TRANSPARENT_ALPHA_CHANNEL || +00674 MaterialType==EMT_TRANSPARENT_VERTEX_ALPHA || +00675 MaterialType==EMT_TRANSPARENT_REFLECTION_2_LAYER; +00676 } +00677 }; +00678 +00680 IRRLICHT_API extern SMaterial IdentityMaterial; +00681 +00682 } // end namespace video +00683 } // end namespace irr +00684 +00685 #endif +