| 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__