SVertexManipulator.hpp

// Copyright (C) 2009-2012 Christian Stehno
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in duckcpp/duckcpp.hpp
 
#ifndef S_VERTEX_MANIPULATOR_HPP_INCLUDED
#define S_VERTEX_MANIPULATOR_HPP_INCLUDED
 
#include <duckcpp/core/engine/matrix4.hpp>
#include <duckcpp/core/engine/S3DVertex.hpp>
#include <duckcpp/core/engine/SColor.hpp>
 
namespace dcpp
{
namespace scene
{
 
    class IMesh;
    class IMeshBuffer;
    class SMesh;
 
 
    class IVertexManipulator
    {
    };
    class SVertexColorSetManipulator : public IVertexManipulator
    {
    public:
        SVertexColorSetManipulator(dcpp::video::SColor color) : Color(color) {}
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color=Color;
        }
    private:
        dcpp::video::SColor Color;
    };
    class SVertexColorSetAlphaManipulator : public IVertexManipulator
    {
    public:
        SVertexColorSetAlphaManipulator(dcpp::uint32_kt alpha) : Alpha(alpha) {}
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color.setAlpha(Alpha);
        }
    private:
        dcpp::uint32_kt Alpha;
    };
    class SVertexColorInvertManipulator : public IVertexManipulator
    {
    public:
        void operator()(dcpp::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());
        }
    };
 
    class SVertexColorThresholdManipulator : public IVertexManipulator
    {
    public:
        SVertexColorThresholdManipulator(dcpp::uint8_kt threshold, dcpp::video::SColor low,
            dcpp::video::SColor high) : Threshold(threshold), Low(low), High(high) {}
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color = ((dcpp::uint8_kt)vertex.Color.getAverage()>Threshold)?High:Low;
        }
    private:
        dcpp::uint8_kt Threshold;
        dcpp::video::SColor Low;
        dcpp::video::SColor High;
    };
 
    class SVertexColorBrightnessManipulator : public IVertexManipulator
    {
    public:
        SVertexColorBrightnessManipulator(dcpp::int32_kt amount) : Amount(amount) {}
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color.setRed(dcpp::nub::clamp(vertex.Color.getRed()+Amount, 0u, 255u));
            vertex.Color.setGreen(dcpp::nub::clamp(vertex.Color.getGreen()+Amount, 0u, 255u));
            vertex.Color.setBlue(dcpp::nub::clamp(vertex.Color.getBlue()+Amount, 0u, 255u));
        }
    private:
        dcpp::int32_kt Amount;
    };
 
    class SVertexColorContrastManipulator : public IVertexManipulator
    {
    public:
        SVertexColorContrastManipulator(dcpp::float32_kt factor) : Factor(factor) {}
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color.setRed(dcpp::nub::clamp(dcpp::nub::round32((vertex.Color.getRed()-128)*Factor)+128, 0, 255));
            vertex.Color.setGreen(dcpp::nub::clamp(dcpp::nub::round32((vertex.Color.getGreen()-128)*Factor)+128, 0, 255));
            vertex.Color.setBlue(dcpp::nub::clamp(dcpp::nub::round32((vertex.Color.getBlue()-128)*Factor)+128, 0, 255));
        }
    private:
        dcpp::float32_kt Factor;
    };
 
    class SVertexColorContrastBrightnessManipulator : public IVertexManipulator
    {
    public:
        SVertexColorContrastBrightnessManipulator(dcpp::float32_kt factor, dcpp::int32_kt amount) : Factor(factor), Amount(amount+128) {}
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color.setRed(dcpp::nub::clamp(dcpp::nub::round32((vertex.Color.getRed()-128)*Factor)+Amount, 0, 255));
            vertex.Color.setGreen(dcpp::nub::clamp(dcpp::nub::round32((vertex.Color.getGreen()-128)*Factor)+Amount, 0, 255));
            vertex.Color.setBlue(dcpp::nub::clamp(dcpp::nub::round32((vertex.Color.getBlue()-128)*Factor)+Amount, 0, 255));
        }
    private:
        dcpp::float32_kt Factor;
        dcpp::int32_kt Amount;
    };
 
    class SVertexColorGammaManipulator : public IVertexManipulator
    {
    public:
        SVertexColorGammaManipulator(dcpp::float32_kt gamma) : Gamma(1.f)
        {
            if (gamma != 0.f)
                Gamma = 1.f/gamma;
        }
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color.setRed(dcpp::nub::clamp(dcpp::nub::round32(powf((dcpp::float32_kt)(vertex.Color.getRed()),Gamma)), 0, 255));
            vertex.Color.setGreen(dcpp::nub::clamp(dcpp::nub::round32(powf((dcpp::float32_kt)(vertex.Color.getGreen()),Gamma)), 0, 255));
            vertex.Color.setBlue(dcpp::nub::clamp(dcpp::nub::round32(powf((dcpp::float32_kt)(vertex.Color.getBlue()),Gamma)), 0, 255));
        }
    private:
        dcpp::float32_kt Gamma;
    };
 
    class SVertexColorScaleManipulator : public IVertexManipulator
    {
    public:
        SVertexColorScaleManipulator(dcpp::float32_kt factor) : Factor(factor) {}
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color.setRed(dcpp::nub::clamp(dcpp::nub::round32(vertex.Color.getRed()*Factor), 0, 255));
            vertex.Color.setGreen(dcpp::nub::clamp(dcpp::nub::round32(vertex.Color.getGreen()*Factor), 0, 255));
            vertex.Color.setBlue(dcpp::nub::clamp(dcpp::nub::round32(vertex.Color.getBlue()*Factor), 0, 255));
        }
    private:
        dcpp::float32_kt Factor;
    };
 
    class SVertexColorDesaturateToLightnessManipulator : public IVertexManipulator
    {
    public:
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color=dcpp::nub::round32(vertex.Color.getLightness());
        }
    };
 
    class SVertexColorDesaturateToAverageManipulator : public IVertexManipulator
    {
    public:
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color=vertex.Color.getAverage();
        }
    };
 
    class SVertexColorDesaturateToLuminanceManipulator : public IVertexManipulator
    {
    public:
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color=dcpp::nub::round32(vertex.Color.getLuminance());
        }
    };
 
    class SVertexColorInterpolateLinearManipulator : public IVertexManipulator
    {
    public:
        SVertexColorInterpolateLinearManipulator(dcpp::video::SColor color, dcpp::float32_kt factor) :
          Color(color), Factor(factor) {}
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color=vertex.Color.getInterpolated(Color, Factor);
        }
    private:
        dcpp::video::SColor Color;
        dcpp::float32_kt Factor;
    };
 
    class SVertexColorInterpolateQuadraticManipulator : public IVertexManipulator
    {
    public:
        SVertexColorInterpolateQuadraticManipulator(dcpp::video::SColor color1, dcpp::video::SColor color2, dcpp::float32_kt factor) :
          Color1(color1), Color2(color2), Factor(factor) {}
        void operator()(dcpp::video::S3DVertex& vertex) const
        {
            vertex.Color=vertex.Color.getInterpolated_quadratic(Color1, Color2, Factor);
        }
    private:
        dcpp::video::SColor Color1;
        dcpp::video::SColor Color2;
        dcpp::float32_kt Factor;
    };
 
    class SVertexPositionScaleManipulator : public IVertexManipulator
    {
    public:
        SVertexPositionScaleManipulator(const dcpp::nub::vector3df& factor) : Factor(factor) {}
        template <typename VType>
        void operator()(VType& vertex) const
        {
            vertex.Pos *= Factor;
        }
    private:
        dcpp::nub::vector3df Factor;
    };
 
 
    class SVertexPositionScaleAlongNormalsManipulator : public IVertexManipulator
    {
    public:
        SVertexPositionScaleAlongNormalsManipulator(const dcpp::nub::vector3df& factor) : Factor(factor) {}
        template <typename VType>
        void operator()(VType& vertex) const
        {
            vertex.Pos += vertex.Normal*Factor;
        }
    private:
        dcpp::nub::vector3df Factor;
    };
 
    class SVertexPositionTransformManipulator : public IVertexManipulator
    {
    public:
        SVertexPositionTransformManipulator(const dcpp::nub::matrix4& m) : Transformation(m) {}
        template <typename VType>
        void operator()(VType& vertex) const
        {
            Transformation.transformVect(vertex.Pos);
        }
    private:
        dcpp::nub::matrix4 Transformation;
    };
 
    class SVertexNormalTransformManipulator : public IVertexManipulator
    {
    public:
        SVertexNormalTransformManipulator(const dcpp::nub::matrix4& m) : Transformation(m) {}
        template <typename VType>
        void operator()(VType& vertex) const
        {
            Transformation.transformVect(vertex.Normal);
        }
    private:
        dcpp::nub::matrix4 Transformation;
    };
 
    class SVertexNormalRotateScaleManipulator : public IVertexManipulator
    {
    public:
        SVertexNormalRotateScaleManipulator(const dcpp::nub::matrix4& m) : Transformation(m) {}
        template <typename VType>
        void operator()(VType& vertex) const
        {
            Transformation.rotateVect(vertex.Normal);
        }
    private:
        dcpp::nub::matrix4 Transformation;
    };
 
    class SVertexNormalizeNormalManipulator : public IVertexManipulator
    {
    public:
        SVertexNormalizeNormalManipulator() {}
        template <typename VType>
        void operator()(VType& vertex) const
        {
            vertex.Normal.normalize();
        }
    };
 
    class SVertexTCoordsScaleManipulator : public IVertexManipulator
    {
    public:
        SVertexTCoordsScaleManipulator(const dcpp::nub::vector2df& factor, dcpp::uint32_kt uvSet=1) : Factor(factor), UVSet(uvSet) {}
        void operator()(dcpp::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:
        dcpp::nub::vector2df Factor;
        dcpp::uint32_kt UVSet;
    };
 
} // end namespace scene
} // end namespace dcpp
 
#endif