Curve.hpp

Go to the documentation of this file.

/*

 sftools - Copyright (c) 2012-2013 Marco Antognini <antognini.marco@gmail.com>

 This software is provided 'as-is', without any express or implied warranty. In
 no event will the authors be held liable for any damages arising from the use
 of this software.

 Permission is granted to anyone to use this software for any purpose, including
 commercial applications, and to alter it and redistribute it freely, subject to
 the following restrictions:

 1. The origin of this software must not be misrepresented; you must not claim
 that you wrote the original software. If you use this software in a product,
 an acknowledgment in the product documentation would be appreciated but is
 not required.

 2. Altered source versions must be plainly marked as such, and must not be
 misrepresented as being the original software.

 3. This notice may not be removed or altered from any source distribution.

 */

#ifndef __SFTOOLS_CURVE_HPP__
#define __SFTOOLS_CURVE_HPP__

#include <SFML/Graphics.hpp>
#include <cmath>

namespace sftools
{
    typedef std::function<sf::Vector2f(float)> CurveFunction;

    struct CurveInfo
    {
    public:
        static CurveInfo elipse(float a, float b, float begin, float end, unsigned int pointCount)
        {
            auto f = [a, b](float t) -> sf::Vector2f {
                return { a * std::cos(t), b * std::sin(t) };
            };

            return { f, begin, end, pointCount };
        }

        static CurveInfo circle(float r, float begin, float end, unsigned int pointCount)
        {
            return elipse(r, r, begin, end, pointCount);
        }

        static CurveInfo sine(float a, float b, float begin, float end, unsigned int pointCount)
        {
            auto f = [a, b](float t) -> sf::Vector2f {
                return { a * t, b * std::sin(t) };
            };

            return { f, begin, end, pointCount };
        }

        static CurveInfo cosine(float a, float b, float begin, float end, unsigned int pointCount)
        {
            auto f = [a, b](float t) -> sf::Vector2f {
                return { a * t, b * std::cos(t) };
            };

            return { f, begin, end, pointCount };
        }

        static CurveInfo astroid(float a, float begin, float end, unsigned int pointCount)
        {
            auto f = [a](float t) -> sf::Vector2f {
                return { a * std::pow(std::cos(t), 3), a * std::pow(std::sin(t), 3) };
            };

            return { f, begin, end, pointCount };
        }
        
    public:
        CurveFunction f; 
        float begin; 
        float end; 
        unsigned int pointCount; 
    };

    class Curve : public sf::Drawable,
                  public sf::Transformable
    {
    public:
        Curve(CurveInfo info, sf::Color color = sf::Color::Black, float thickness = 1.f)
        : m_vertices(sf::PrimitiveType::TrianglesStrip)
        , m_info(info)
        , m_color(color)
        , m_thickness(thickness)
        {
            update();
        }

        virtual ~Curve()
        {
            // Nothing to do here.
        }
        
        sf::FloatRect getLocalBounds() const
        {
            return m_vertices.getBounds();
        }

        sf::FloatRect getGlobalBounds() const
        {
            return getTransform().transformRect(getLocalBounds());
        }

        CurveInfo const& getInfo() const
        {
            return m_info;
        }

        void setInfo(CurveInfo const& info)
        {
            m_info = info;
            update();
        }

        sf::Color getColor() const
        {
            return m_color;
        }

        void setColor(sf::Color color)
        {
            m_color = color;
            updateColorOnly();
        }

        float getThickness() const
        {
            return m_thickness;
        }

        void setThickness(float thickness)
        {
            m_thickness = thickness;
            update();
        }

    protected:
        virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const
        {
            states.transform *= getTransform();
            target.draw(m_vertices, states);
        }

    private:
        void update()
        {
            // Compute the normalised normal of [a, b] segment.
            // Note: we do it here just to reduce a little bit the inter-dependencies.
            auto const normalisedNormal = [](sf::Vector2f const& a, sf::Vector2f const& b) -> sf::Vector2f
            {
                sf::Vector2f const v = a - b;
                sf::Vector2f const n = { v.y, -v.x };
                float const length = std::sqrt(n.x * n.x + n.y * n.y);
                
                return length != 0.0 ? n / length : n;
            };

            m_vertices.clear();
            m_vertices.resize(m_info.pointCount * 2 - 1); // Count points for the curve and (count - 1) points for the outline
            // (that is, one point for the outline between each point of the curve)

            // Compute the points of the curve
            float const step = (m_info.end - m_info.begin) / m_info.pointCount;
            for (unsigned int i = 0; i < m_info.pointCount; ++i) {
                float const t = m_info.begin + step * i;
                m_vertices[i * 2] = { m_info.f(t), m_color }; // one vertex over two because of the outline
            }

            // Compute the points of the outline
            for (unsigned int i = 1; i < m_info.pointCount * 2 - 1; i += 2) {
                // Compute the normal of the two points (p0 and p2) of the curve that are next to this outline point (p1)
                sf::Vector2f const& p0 = m_vertices[i - 1].position;
                sf::Vector2f const& p2 = m_vertices[i + 1].position;
                sf::Vector2f const  n  = normalisedNormal(p0, p2);
                sf::Vector2f const  m  = (p0 + p2) / 2.f;
                sf::Vector2f const  p1 = m + n * m_thickness;
                
                m_vertices[i] = { p1, m_color };
            }
        }

        void updateColorOnly()
        {
            for (unsigned int i = 0; i < m_vertices.getVertexCount(); ++i) {
                m_vertices[i].color = m_color;
            }
        }

    private:
        sf::VertexArray m_vertices; 
        CurveInfo m_info; 
        sf::Color m_color; 
        float m_thickness; 
    };
}

#endif // __SFTOOLS_CURVE_HPP__