diff options
Diffstat (limited to 'include/SVertexManipulator.h')
| -rw-r--r-- | include/SVertexManipulator.h | 292 |
1 files changed, 292 insertions, 0 deletions
diff --git a/include/SVertexManipulator.h b/include/SVertexManipulator.h new file mode 100644 index 0000000..6696ad0 --- /dev/null +++ b/include/SVertexManipulator.h @@ -0,0 +1,292 @@ +// Copyright (C) 2009-2012 Christian Stehno
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#ifndef __S_VERTEX_MANIPULATOR_H_INCLUDED__
+#define __S_VERTEX_MANIPULATOR_H_INCLUDED__
+
+#include "S3DVertex.h"
+#include "SColor.h"
+
+namespace irr
+{
+namespace scene
+{
+
+ class IMesh;
+ class IMeshBuffer;
+ struct SMesh;
+
+ //! Interface for vertex manipulators.
+ /** You should derive your manipulator from this class if it shall be called for every vertex, getting as parameter just the vertex.
+ */
+ struct IVertexManipulator
+ {
+ };
+ //! Vertex manipulator to set color to a fixed color for all vertices
+ class SVertexColorSetManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexColorSetManipulator(video::SColor color) : Color(color) {}
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color=Color;
+ }
+ private:
+ video::SColor Color;
+ };
+ //! Vertex manipulator to set the alpha value of the vertex color to a fixed value
+ class SVertexColorSetAlphaManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexColorSetAlphaManipulator(u32 alpha) : Alpha(alpha) {}
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color.setAlpha(Alpha);
+ }
+ private:
+ u32 Alpha;
+ };
+ //! Vertex manipulator which invertes the RGB values
+ class SVertexColorInvertManipulator : public IVertexManipulator
+ {
+ public:
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color.setRed(255-vertex.Color.getRed());
+ vertex.Color.setGreen(255-vertex.Color.getGreen());
+ vertex.Color.setBlue(255-vertex.Color.getBlue());
+ }
+ };
+ //! Vertex manipulator to set vertex color to one of two values depending on a given threshold
+ /** If average of the color value is >Threshold the High color is chosen, else Low. */
+ class SVertexColorThresholdManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexColorThresholdManipulator(u8 threshold, video::SColor low,
+ video::SColor high) : Threshold(threshold), Low(low), High(high) {}
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color = ((u8)vertex.Color.getAverage()>Threshold)?High:Low;
+ }
+ private:
+ u8 Threshold;
+ video::SColor Low;
+ video::SColor High;
+ };
+ //! Vertex manipulator which adjusts the brightness by the given amount
+ /** A positive value increases brightness, a negative value darkens the colors. */
+ class SVertexColorBrightnessManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexColorBrightnessManipulator(s32 amount) : Amount(amount) {}
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color.setRed(core::clamp(vertex.Color.getRed()+Amount, 0u, 255u));
+ vertex.Color.setGreen(core::clamp(vertex.Color.getGreen()+Amount, 0u, 255u));
+ vertex.Color.setBlue(core::clamp(vertex.Color.getBlue()+Amount, 0u, 255u));
+ }
+ private:
+ s32 Amount;
+ };
+ //! Vertex manipulator which adjusts the contrast by the given factor
+ /** Factors over 1 increase contrast, below 1 reduce it. */
+ class SVertexColorContrastManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexColorContrastManipulator(f32 factor) : Factor(factor) {}
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color.setRed(core::clamp(core::round32((vertex.Color.getRed()-128)*Factor)+128, 0, 255));
+ vertex.Color.setGreen(core::clamp(core::round32((vertex.Color.getGreen()-128)*Factor)+128, 0, 255));
+ vertex.Color.setBlue(core::clamp(core::round32((vertex.Color.getBlue()-128)*Factor)+128, 0, 255));
+ }
+ private:
+ f32 Factor;
+ };
+ //! Vertex manipulator which adjusts the contrast by the given factor and brightness by a signed amount.
+ /** Factors over 1 increase contrast, below 1 reduce it.
+ A positive amount increases brightness, a negative one darkens the colors. */
+ class SVertexColorContrastBrightnessManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexColorContrastBrightnessManipulator(f32 factor, s32 amount) : Factor(factor), Amount(amount+128) {}
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color.setRed(core::clamp(core::round32((vertex.Color.getRed()-128)*Factor)+Amount, 0, 255));
+ vertex.Color.setGreen(core::clamp(core::round32((vertex.Color.getGreen()-128)*Factor)+Amount, 0, 255));
+ vertex.Color.setBlue(core::clamp(core::round32((vertex.Color.getBlue()-128)*Factor)+Amount, 0, 255));
+ }
+ private:
+ f32 Factor;
+ s32 Amount;
+ };
+ //! Vertex manipulator which adjusts the brightness by a gamma operation
+ /** A value over one increases brightness, one below darkens the colors. */
+ class SVertexColorGammaManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexColorGammaManipulator(f32 gamma) : Gamma(1.f)
+ {
+ if (gamma != 0.f)
+ Gamma = 1.f/gamma;
+ }
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color.setRed(core::clamp(core::round32(powf((f32)(vertex.Color.getRed()),Gamma)), 0, 255));
+ vertex.Color.setGreen(core::clamp(core::round32(powf((f32)(vertex.Color.getGreen()),Gamma)), 0, 255));
+ vertex.Color.setBlue(core::clamp(core::round32(powf((f32)(vertex.Color.getBlue()),Gamma)), 0, 255));
+ }
+ private:
+ f32 Gamma;
+ };
+ //! Vertex manipulator which scales the color values
+ /** Can e.g be used for white balance, factor would be 255.f/brightest color. */
+ class SVertexColorScaleManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexColorScaleManipulator(f32 factor) : Factor(factor) {}
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color.setRed(core::clamp(core::round32(vertex.Color.getRed()*Factor), 0, 255));
+ vertex.Color.setGreen(core::clamp(core::round32(vertex.Color.getGreen()*Factor), 0, 255));
+ vertex.Color.setBlue(core::clamp(core::round32(vertex.Color.getBlue()*Factor), 0, 255));
+ }
+ private:
+ f32 Factor;
+ };
+ //! Vertex manipulator which desaturates the color values
+ /** Uses the lightness value of the color. */
+ class SVertexColorDesaturateToLightnessManipulator : public IVertexManipulator
+ {
+ public:
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color=core::round32(vertex.Color.getLightness());
+ }
+ };
+ //! Vertex manipulator which desaturates the color values
+ /** Uses the average value of the color. */
+ class SVertexColorDesaturateToAverageManipulator : public IVertexManipulator
+ {
+ public:
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color=vertex.Color.getAverage();
+ }
+ };
+ //! Vertex manipulator which desaturates the color values
+ /** Uses the luminance value of the color. */
+ class SVertexColorDesaturateToLuminanceManipulator : public IVertexManipulator
+ {
+ public:
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color=core::round32(vertex.Color.getLuminance());
+ }
+ };
+ //! Vertex manipulator which interpolates the color values
+ /** Uses linear interpolation. */
+ class SVertexColorInterpolateLinearManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexColorInterpolateLinearManipulator(video::SColor color, f32 factor) :
+ Color(color), Factor(factor) {}
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color=vertex.Color.getInterpolated(Color, Factor);
+ }
+ private:
+ video::SColor Color;
+ f32 Factor;
+ };
+ //! Vertex manipulator which interpolates the color values
+ /** Uses linear interpolation. */
+ class SVertexColorInterpolateQuadraticManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexColorInterpolateQuadraticManipulator(video::SColor color1, video::SColor color2, f32 factor) :
+ Color1(color1), Color2(color2), Factor(factor) {}
+ void operator()(video::S3DVertex& vertex) const
+ {
+ vertex.Color=vertex.Color.getInterpolated_quadratic(Color1, Color2, Factor);
+ }
+ private:
+ video::SColor Color1;
+ video::SColor Color2;
+ f32 Factor;
+ };
+
+ //! Vertex manipulator which scales the position of the vertex
+ class SVertexPositionScaleManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexPositionScaleManipulator(const core::vector3df& factor) : Factor(factor) {}
+ template <typename VType>
+ void operator()(VType& vertex) const
+ {
+ vertex.Pos *= Factor;
+ }
+ private:
+ core::vector3df Factor;
+ };
+
+ //! Vertex manipulator which scales the position of the vertex along the normals
+ /** This can look more pleasing than the usual Scale operator, but
+ depends on the mesh geometry.
+ */
+ class SVertexPositionScaleAlongNormalsManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexPositionScaleAlongNormalsManipulator(const core::vector3df& factor) : Factor(factor) {}
+ template <typename VType>
+ void operator()(VType& vertex) const
+ {
+ vertex.Pos += vertex.Normal*Factor;
+ }
+ private:
+ core::vector3df Factor;
+ };
+
+ //! Vertex manipulator which transforms the position of the vertex
+ class SVertexPositionTransformManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexPositionTransformManipulator(const core::matrix4& m) : Transformation(m) {}
+ template <typename VType>
+ void operator()(VType& vertex) const
+ {
+ Transformation.transformVect(vertex.Pos);
+ }
+ private:
+ core::matrix4 Transformation;
+ };
+
+ //! Vertex manipulator which scales the TCoords of the vertex
+ class SVertexTCoordsScaleManipulator : public IVertexManipulator
+ {
+ public:
+ SVertexTCoordsScaleManipulator(const core::vector2df& factor, u32 uvSet=1) : Factor(factor), UVSet(uvSet) {}
+ void operator()(video::S3DVertex2TCoords& vertex) const
+ {
+ if (1==UVSet)
+ vertex.TCoords *= Factor;
+ else if (2==UVSet)
+ vertex.TCoords2 *= Factor;
+ }
+ template <typename VType>
+ void operator()(VType& vertex) const
+ {
+ if (1==UVSet)
+ vertex.TCoords *= Factor;
+ }
+ private:
+ core::vector2df Factor;
+ u32 UVSet;
+ };
+
+} // end namespace scene
+} // end namespace irr
+
+
+#endif
|