Home | Namespaces | Hierarchy | Alphabetical List | Class list | Files | Namespace Members | Class members | File members | Tutorials

SVertexManipulator.h

Go to the documentation of this file.
00001 // Copyright (C) 2009 Christian Stehno
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_VERTEX_MANIPULATOR_H_INCLUDED__
00006 #define __S_VERTEX_MANIPULATOR_H_INCLUDED__
00007 
00008 #include "S3DVertex.h"
00009 #include "SColor.h"
00010 
00011 namespace irr
00012 {
00013 namespace scene
00014 {
00015 
00016         class IMesh;
00017         class IMeshBuffer;
00018         struct SMesh;
00019 
00021 
00023         struct IVertexManipulator
00024         {
00025         };
00027         class SVertexColorSetManipulator : public IVertexManipulator
00028         {
00029         public:
00030                 SVertexColorSetManipulator(video::SColor color) : Color(color) {}
00031                 void operator()(video::S3DVertex& vertex) const
00032                 {
00033                         vertex.Color=Color;
00034                 }
00035         private:
00036                 video::SColor Color;
00037         };
00039         class SVertexColorSetAlphaManipulator : public IVertexManipulator
00040         {
00041         public:
00042                 SVertexColorSetAlphaManipulator(u32 alpha) : Alpha(alpha) {}
00043                 void operator()(video::S3DVertex& vertex) const
00044                 {
00045                         vertex.Color.setAlpha(Alpha);
00046                 }
00047         private:
00048                 u32 Alpha;
00049         };
00051         class SVertexColorInvertManipulator : public IVertexManipulator
00052         {
00053         public:
00054                 void operator()(video::S3DVertex& vertex) const
00055                 {
00056                         vertex.Color.setRed(255-vertex.Color.getRed());
00057                         vertex.Color.setGreen(255-vertex.Color.getGreen());
00058                         vertex.Color.setBlue(255-vertex.Color.getBlue());
00059                 }
00060         };
00062 
00063         class SVertexColorThresholdManipulator : public IVertexManipulator
00064         {
00065         public:
00066                 SVertexColorThresholdManipulator(u8 threshold, video::SColor low,
00067                         video::SColor high) : Threshold(threshold), Low(low), High(high) {}
00068                 void operator()(video::S3DVertex& vertex) const
00069                 {
00070                         vertex.Color = ((u8)vertex.Color.getAverage()>Threshold)?High:Low;
00071                 }
00072         private:
00073                 u8 Threshold;
00074                 video::SColor Low;
00075                 video::SColor High;
00076         };
00078 
00079         class SVertexColorBrightnessManipulator : public IVertexManipulator
00080         {
00081         public:
00082                 SVertexColorBrightnessManipulator(s32 amount) : Amount(amount) {}
00083                 void operator()(video::S3DVertex& vertex) const
00084                 {
00085                         vertex.Color.setRed(core::clamp(vertex.Color.getRed()+Amount, 0u, 255u));
00086                         vertex.Color.setGreen(core::clamp(vertex.Color.getGreen()+Amount, 0u, 255u));
00087                         vertex.Color.setBlue(core::clamp(vertex.Color.getBlue()+Amount, 0u, 255u));
00088                 }
00089         private:
00090                 s32 Amount;
00091         };
00093 
00094         class SVertexColorContrastManipulator : public IVertexManipulator
00095         {
00096         public:
00097                 SVertexColorContrastManipulator(f32 factor) : Factor(factor) {}
00098                 void operator()(video::S3DVertex& vertex) const
00099                 {
00100                         vertex.Color.setRed(core::clamp(core::round32((vertex.Color.getRed()-128)*Factor)+128, 0, 255));
00101                         vertex.Color.setGreen(core::clamp(core::round32((vertex.Color.getGreen()-128)*Factor)+128, 0, 255));
00102                         vertex.Color.setBlue(core::clamp(core::round32((vertex.Color.getBlue()-128)*Factor)+128, 0, 255));
00103                 }
00104         private:
00105                 f32 Factor;
00106         };
00108 
00110         class SVertexColorContrastBrightnessManipulator : public IVertexManipulator
00111         {
00112         public:
00113                 SVertexColorContrastBrightnessManipulator(f32 factor, s32 amount) : Factor(factor), Amount(amount+128) {}
00114                 void operator()(video::S3DVertex& vertex) const
00115                 {
00116                         vertex.Color.setRed(core::clamp(core::round32((vertex.Color.getRed()-128)*Factor)+Amount, 0, 255));
00117                         vertex.Color.setGreen(core::clamp(core::round32((vertex.Color.getGreen()-128)*Factor)+Amount, 0, 255));
00118                         vertex.Color.setBlue(core::clamp(core::round32((vertex.Color.getBlue()-128)*Factor)+Amount, 0, 255));
00119                 }
00120         private:
00121                 f32 Factor;
00122                 s32 Amount;
00123         };
00125 
00126         class SVertexColorGammaManipulator : public IVertexManipulator
00127         {
00128         public:
00129                 SVertexColorGammaManipulator(f32 gamma) : Gamma(1.f)
00130                 {
00131                         if (gamma != 0.f)
00132                                 Gamma = 1.f/gamma;
00133                 }
00134                 void operator()(video::S3DVertex& vertex) const
00135                 {
00136                         vertex.Color.setRed(core::clamp(core::round32(powf((f32)(vertex.Color.getRed()),Gamma)), 0, 255));
00137                         vertex.Color.setGreen(core::clamp(core::round32(powf((f32)(vertex.Color.getGreen()),Gamma)), 0, 255));
00138                         vertex.Color.setBlue(core::clamp(core::round32(powf((f32)(vertex.Color.getBlue()),Gamma)), 0, 255));
00139                 }
00140         private:
00141                 f32 Gamma;
00142         };
00144 
00145         class SVertexColorScaleManipulator : public IVertexManipulator
00146         {
00147         public:
00148                 SVertexColorScaleManipulator(f32 factor) : Factor(factor) {}
00149                 void operator()(video::S3DVertex& vertex) const
00150                 {
00151                         vertex.Color.setRed(core::clamp(core::round32(vertex.Color.getRed()*Factor), 0, 255));
00152                         vertex.Color.setGreen(core::clamp(core::round32(vertex.Color.getGreen()*Factor), 0, 255));
00153                         vertex.Color.setBlue(core::clamp(core::round32(vertex.Color.getBlue()*Factor), 0, 255));
00154                 }
00155         private:
00156                 f32 Factor;
00157         };
00159 
00160         class SVertexColorDesaturateToLightnessManipulator : public IVertexManipulator
00161         {
00162         public:
00163                 void operator()(video::S3DVertex& vertex) const
00164                 {
00165                         vertex.Color=core::round32(vertex.Color.getLightness());
00166                 }
00167         };
00169 
00170         class SVertexColorDesaturateToAverageManipulator : public IVertexManipulator
00171         {
00172         public:
00173                 void operator()(video::S3DVertex& vertex) const
00174                 {
00175                         vertex.Color=vertex.Color.getAverage();
00176                 }
00177         };
00179 
00180         class SVertexColorDesaturateToLuminanceManipulator : public IVertexManipulator
00181         {
00182         public:
00183                 void operator()(video::S3DVertex& vertex) const
00184                 {
00185                         vertex.Color=core::round32(vertex.Color.getLuminance());
00186                 }
00187         };
00189 
00190         class SVertexColorInterpolateLinearManipulator : public IVertexManipulator
00191         {
00192         public:
00193                 SVertexColorInterpolateLinearManipulator(video::SColor color, f32 factor) :
00194                   Color(color), Factor(factor) {}
00195                 void operator()(video::S3DVertex& vertex) const
00196                 {
00197                         vertex.Color=vertex.Color.getInterpolated(Color, Factor);
00198                 }
00199         private:
00200                 video::SColor Color;
00201                 f32 Factor;
00202         };
00204 
00205         class SVertexColorInterpolateQuadraticManipulator : public IVertexManipulator
00206         {
00207         public:
00208                 SVertexColorInterpolateQuadraticManipulator(video::SColor color1, video::SColor color2, f32 factor) :
00209                   Color1(color1), Color2(color2), Factor(factor) {}
00210                 void operator()(video::S3DVertex& vertex) const
00211                 {
00212                         vertex.Color=vertex.Color.getInterpolated_quadratic(Color1, Color2, Factor);
00213                 }
00214         private:
00215                 video::SColor Color1;
00216                 video::SColor Color2;
00217                 f32 Factor;
00218         };
00219 
00221         class SVertexPositionScaleManipulator : public IVertexManipulator
00222         {
00223         public:
00224                 SVertexPositionScaleManipulator(const core::vector3df& factor) : Factor(factor) {}
00225                 template <typename VType>
00226                 void operator()(VType& vertex) const
00227                 {
00228                         vertex.Pos *= Factor;
00229                 }
00230         private:
00231                 core::vector3df Factor;
00232         };
00233 
00235 
00238         class SVertexPositionScaleAlongNormalsManipulator : public IVertexManipulator
00239         {
00240         public:
00241                 SVertexPositionScaleAlongNormalsManipulator(const core::vector3df& factor) : Factor(factor) {}
00242                 template <typename VType>
00243                 void operator()(VType& vertex) const
00244                 {
00245                         vertex.Pos += vertex.Normal*Factor;
00246                 }
00247         private:
00248                 core::vector3df Factor;
00249         };
00250 
00252         class SVertexPositionTransformManipulator : public IVertexManipulator
00253         {
00254         public:
00255                 SVertexPositionTransformManipulator(const core::matrix4& m) : Transformation(m) {}
00256                 template <typename VType>
00257                 void operator()(VType& vertex) const
00258                 {
00259                         Transformation.transformVect(vertex.Pos);
00260                 }
00261         private:
00262                 core::matrix4 Transformation;
00263         };
00264 
00266         class SVertexTCoordsScaleManipulator : public IVertexManipulator
00267         {
00268         public:
00269                 SVertexTCoordsScaleManipulator(const core::vector2df& factor, u32 uvSet=1) : Factor(factor), UVSet(uvSet) {}
00270                 void operator()(video::S3DVertex2TCoords& vertex) const
00271                 {
00272                         if (1==UVSet)
00273                                 vertex.TCoords *= Factor;
00274                         else if (2==UVSet)
00275                                 vertex.TCoords2 *= Factor;
00276                 }
00277                 template <typename VType>
00278                 void operator()(VType& vertex) const
00279                 {
00280                         if (1==UVSet)
00281                                 vertex.TCoords *= Factor;
00282                 }
00283         private:
00284                 core::vector2df Factor;
00285                 u32 UVSet;
00286         };
00287 
00288 } // end namespace scene
00289 } // end namespace irr
00290 
00291 
00292 #endif

The Irrlicht Engine
The Irrlicht Engine Documentation © 2003-2010 by Nikolaus Gebhardt. Generated on Sun Oct 24 12:41:58 2010 by Doxygen (1.6.2)