Irrlicht 3D Engine
SMaterialLayer.h
Go to the documentation of this file.
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_LAYER_H_INCLUDED__
00006 #define __S_MATERIAL_LAYER_H_INCLUDED__
00007 
00008 #include "matrix4.h"
00009 #include "irrAllocator.h"
00010 
00011 namespace irr
00012 {
00013 namespace video
00014 {
00015     class ITexture;
00016 
00018     enum E_TEXTURE_CLAMP
00019     {
00021         ETC_REPEAT = 0,
00023         ETC_CLAMP,
00025         ETC_CLAMP_TO_EDGE,
00027         ETC_CLAMP_TO_BORDER,
00029         ETC_MIRROR,
00031         ETC_MIRROR_CLAMP,
00033         ETC_MIRROR_CLAMP_TO_EDGE,
00035         ETC_MIRROR_CLAMP_TO_BORDER
00036     };
00037     static const char* const aTextureClampNames[] = {
00038             "texture_clamp_repeat",
00039             "texture_clamp_clamp",
00040             "texture_clamp_clamp_to_edge",
00041             "texture_clamp_clamp_to_border",
00042             "texture_clamp_mirror",
00043             "texture_clamp_mirror_clamp",
00044             "texture_clamp_mirror_clamp_to_edge",
00045             "texture_clamp_mirror_clamp_to_border", 0};
00046 
00048     class SMaterialLayer
00049     {
00050     public:
00052         SMaterialLayer()
00053             : Texture(0),
00054                 TextureWrapU(ETC_REPEAT),
00055                 TextureWrapV(ETC_REPEAT),
00056                 BilinearFilter(true),
00057                 TrilinearFilter(false),
00058                 AnisotropicFilter(0),
00059                 LODBias(0),
00060                 TextureMatrix(0)
00061             {}
00062 
00064 
00065         SMaterialLayer(const SMaterialLayer& other)
00066         {
00067             // This pointer is checked during assignment
00068             TextureMatrix = 0;
00069             *this = other;
00070         }
00071 
00073         ~SMaterialLayer()
00074         {
00075             MatrixAllocator.destruct(TextureMatrix);
00076             MatrixAllocator.deallocate(TextureMatrix); 
00077         }
00078 
00080 
00082         SMaterialLayer& operator=(const SMaterialLayer& other)
00083         {
00084             // Check for self-assignment!
00085             if (this == &other)
00086                 return *this;
00087 
00088             Texture = other.Texture;
00089             if (TextureMatrix)
00090             {
00091                 if (other.TextureMatrix)
00092                     *TextureMatrix = *other.TextureMatrix;
00093                 else
00094                 {
00095                     MatrixAllocator.destruct(TextureMatrix);
00096                     MatrixAllocator.deallocate(TextureMatrix); 
00097                     TextureMatrix = 0;
00098                 }
00099             }
00100             else
00101             {
00102                 if (other.TextureMatrix)
00103                 {
00104                     TextureMatrix = MatrixAllocator.allocate(1);
00105                     MatrixAllocator.construct(TextureMatrix,*other.TextureMatrix);
00106                 }
00107                 else
00108                     TextureMatrix = 0;
00109             }
00110             TextureWrapU = other.TextureWrapU;
00111             TextureWrapV = other.TextureWrapV;
00112             BilinearFilter = other.BilinearFilter;
00113             TrilinearFilter = other.TrilinearFilter;
00114             AnisotropicFilter = other.AnisotropicFilter;
00115             LODBias = other.LODBias;
00116 
00117             return *this;
00118         }
00119 
00121 
00122         core::matrix4& getTextureMatrix()
00123         {
00124             if (!TextureMatrix)
00125             {
00126                 TextureMatrix = MatrixAllocator.allocate(1);
00127                 MatrixAllocator.construct(TextureMatrix,core::IdentityMatrix);
00128             }
00129             return *TextureMatrix;
00130         }
00131 
00133 
00134         const core::matrix4& getTextureMatrix() const
00135         {
00136             if (TextureMatrix)
00137                 return *TextureMatrix;
00138             else
00139                 return core::IdentityMatrix;
00140         }
00141 
00143 
00144         void setTextureMatrix(const core::matrix4& mat)
00145         {
00146             if (!TextureMatrix)
00147             {
00148                 TextureMatrix = MatrixAllocator.allocate(1);
00149                 MatrixAllocator.construct(TextureMatrix,mat);
00150             }
00151             else
00152                 *TextureMatrix = mat;
00153         }
00154 
00156 
00158         inline bool operator!=(const SMaterialLayer& b) const
00159         {
00160             bool different =
00161                 Texture != b.Texture ||
00162                 TextureWrapU != b.TextureWrapU ||
00163                 TextureWrapV != b.TextureWrapV ||
00164                 BilinearFilter != b.BilinearFilter ||
00165                 TrilinearFilter != b.TrilinearFilter ||
00166                 AnisotropicFilter != b.AnisotropicFilter ||
00167                 LODBias != b.LODBias;
00168             if (different)
00169                 return true;
00170             else
00171                 different |= (TextureMatrix != b.TextureMatrix) &&
00172                     TextureMatrix && b.TextureMatrix &&
00173                     (*TextureMatrix != *(b.TextureMatrix));
00174             return different;
00175         }
00176 
00178 
00180         inline bool operator==(const SMaterialLayer& b) const
00181         { return !(b!=*this); }
00182 
00184         ITexture* Texture;
00185 
00187 
00188         u8 TextureWrapU:4;
00189         u8 TextureWrapV:4;
00190 
00192         bool BilinearFilter:1;
00193 
00195 
00197         bool TrilinearFilter:1;
00198 
00200 
00206         u8 AnisotropicFilter;
00207 
00209 
00213         s8 LODBias;
00214 
00215     private:
00216         friend class SMaterial;
00217         irr::core::irrAllocator<irr::core::matrix4> MatrixAllocator;
00218 
00220 
00222         core::matrix4* TextureMatrix;
00223     };
00224 
00225 } // end namespace video
00226 } // end namespace irr
00227 
00228 #endif // __S_MATERIAL_LAYER_H_INCLUDED__