Geometry.h

Go to the documentation of this file.

//
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef GNASH_GEOMETRY_H
#define GNASH_GEOMETRY_H

#include "dsodefs.h"
#include "SWFMatrix.h"
#include "SWFRect.h"
#include "Point2d.h"

#include <vector> // for path composition
#include <cmath> // sqrt


// Forward declarations
namespace gnash {
    class LineStyle;
}

namespace gnash { 

class Edge
{
public:
    
    // Quadratic bezier: point = p0 * t^2 + p1 * 2t(1-t) + p2 * (1-t)^2
    point cp; // control point, TWIPS
    point ap; // anchor    point, TWIPS

    constexpr Edge()
        :
        cp(0, 0),
        ap(0, 0)
    {}
    
    constexpr Edge(std::int32_t cx, std::int32_t cy, std::int32_t ax,
                   std::int32_t ay)
        :
        cp(cx, cy),
        ap(ax, ay)
    {}

    constexpr Edge(const Edge& from)
        : 
        cp(from.cp),
        ap(from.ap)
    {}

    constexpr Edge(const point& ncp, const point& nap)
        :
        cp(ncp),
        ap(nap)
    {}

    bool straight() const
    {
        return cp == ap;
    }
    
    void transform(const SWFMatrix& mat)
    {
        mat.transform(ap);
        mat.transform(cp);
    }

    static double
    squareDistancePtSeg(const point& p, const point& A, const point& B)
    {
        std::int32_t dx = B.x - A.x;
        std::int32_t dy = B.y - A.y;

        if ( dx == 0 && dy == 0 ) 
        {
            return p.squareDistance(A);
        }

        std::int32_t pdx = p.x - A.x;
        std::int32_t pdy = p.y - A.y;

        double u = (static_cast<double>(pdx) * dx + static_cast<double>(pdy) * dy ) /
            (static_cast<double>(dx)*dx + static_cast<double>(dy)*dy );

        if (u <= 0)
        {
            return p.squareDistance(A); 
        }

        if (u >= 1)
        {
            return p.squareDistance(B);
        }

        point px(A, B, u); // FIXME: this interpolation introduce a precision loss (point is int-based)
        return p.squareDistance(px);
    }

    static double
    distancePtSeg(const point& pt, const point& A, const point& B)
    {
        const double square = squareDistancePtSeg(pt, A, B);
        return std::sqrt(square);
    }

    //
    static point
    pointOnCurve(const point& A, const point& C, const point& B, float t)
    {
        point Q1(A, C, t);
        point Q2(C, B, t);
        point R(Q1, Q2, t);

        return R;
    }

    //
    static std::int64_t squareDistancePtCurve(const point& A,
                         const point& C,
                         const point& B,
                         const point& p, float t)
    {
        return p.squareDistance( pointOnCurve(A, C, B, t) );
    }
};


class DSOEXPORT Path
{
public:
    unsigned m_fill0;

    unsigned m_fill1;

    unsigned m_line;

    point ap; 

    std::vector<Edge> m_edges;

    
    //
    Path()
    {
        reset(0, 0, 0, 0, 0);
    }

    Path(const Path& from)
        : 
        m_fill0(from.m_fill0),
        m_fill1(from.m_fill1),
        m_line(from.m_line),
        ap(from.ap),
        m_edges(from.m_edges)
    {
    }
    
    //
    Path(std::int32_t ax, std::int32_t ay,
            unsigned fill0, unsigned fill1, unsigned line)
    {
        reset(ax, ay, fill0, fill1, line);
    }

    //
    //
    void reset(std::int32_t ax, std::int32_t ay,
            unsigned fill0, unsigned fill1, unsigned line)
    // Reset all our members to the given values, and clear our edge list.
    {
        ap.x = ax;
        ap.y = ay;
        m_fill0 = fill0;
        m_fill1 = fill1;
        m_line = line;

        m_edges.resize(0);
        assert(empty());
    }

    //
    void
    expandBounds(SWFRect& r, unsigned int thickness, int swfVersion) const
    {
        const Path&    p = *this;
        size_t nedges = m_edges.size();
        
        if ( ! nedges ) return; // this path adds nothing

        if (thickness)
        {
            // NOTE: Half of thickness would be enough (and correct) for
            // radius, but that would not match how Flash calculates the
            // bounds using the drawing API.                                                
            unsigned int radius = swfVersion < 8 ? thickness : thickness/2;

            r.expand_to_circle(ap.x, ap.y, radius);
            for (unsigned int j = 0; j<nedges; j++)
            {
                r.expand_to_circle(m_edges[j].ap.x, m_edges[j].ap.y, radius);
                r.expand_to_circle(m_edges[j].cp.x, m_edges[j].cp.y, radius);
            }
        }
        else
        {
            r.expand_to_point(ap.x, ap.y);
            for (unsigned int j = 0; j<nedges; j++)
            {
                r.expand_to_point(m_edges[j].ap.x, p.m_edges[j].ap.y);
                r.expand_to_point(m_edges[j].cp.x, p.m_edges[j].cp.y);
            }
        }
    }


    //
    void 
    drawLineTo(std::int32_t dx, std::int32_t dy)
    {
        m_edges.emplace_back(dx, dy, dx, dy);
    }

    //
    void 
    drawCurveTo(std::int32_t cdx, std::int32_t cdy, std::int32_t adx, std::int32_t ady)
    {
        m_edges.emplace_back(cdx, cdy, adx, ady);
    }

    void clear()
    {
        m_edges.resize(0);
        m_fill0 = m_fill1 = m_line = 0;
    }



    bool isClosed() const 
    {
        if (m_edges.empty()) return true;
        return m_edges.back().ap == ap; 
    }

    void close()
    {
        if ( m_edges.empty() ) return;

        // Close it with a straight edge if needed
        const Edge& lastedge = m_edges.back();
        if ( lastedge.ap != ap )
        {
            m_edges.emplace_back(ap, ap);
        }
    }

    //
    bool
    withinSquareDistance(const point& p, double dist) const
    {
        size_t nedges = m_edges.size();

        if ( ! nedges ) return false;

        point px(ap);
        for (size_t i=0; i<nedges; ++i)
        {
            const Edge& e = m_edges[i];
            point np(e.ap);

            if (e.straight())
            {
                double d = Edge::squareDistancePtSeg(p, px, np);
                if ( d <= dist ) return true;
            }
            else
            {

                const point& A = px;
                const point& C = e.cp;
                const point& B = e.ap;

                // Approximate the curve to segCount segments
                // and compute distance of query point from each
                // segment.
                //
                // TODO: find an apprpriate value for segCount based
                //             on rendering scale ?
                //
                int segCount = 10; 
                point p0(A.x, A.y);
                for (int i=1; i<=segCount; ++i)
                {
                    float t1 = static_cast<float>(i) / segCount;
                    point p1 = Edge::pointOnCurve(A, C, B, t1);

                    // distance from point and segment being an approximation 
                    // of the curve 
                    double d = Edge::squareDistancePtSeg(p, p0, p1);
                    if ( d <= dist ) return true;

                    p0.setTo(p1.x, p1.y);
                }
            }
            px = np;
        }

        return false;
    }

    void transform(const SWFMatrix& mat)
    {
        mat.transform(ap);
        std::vector<Edge>::iterator it = m_edges.begin(), ie = m_edges.end();
        for(; it != ie; ++it)
        {
            (*it).transform(mat);
        }
    }

    bool empty() const
    {
        return m_edges.empty();
    }

    //
    void setLeftFill(unsigned f)
    {
        m_fill0 = f;
    }

    unsigned getLeftFill() const
    {
        return m_fill0;
    }

    //
    void setRightFill(unsigned f)
    {
        m_fill1 = f;
    }

    unsigned getRightFill() const
    {
        return m_fill1;
    }

    //
    void setLineStyle(unsigned i)
    {
        m_line = i;
    }

    unsigned getLineStyle() const
    {
        return m_line;
    }

    size_t size() const
    {
        return m_edges.size();
    }

    Edge& operator[] (size_t n)
    {
        return m_edges[n];
    }

    const Edge& operator[] (size_t n) const
    {
        return m_edges[n];
    }
}; // end of class Path

namespace geometry
{

bool pointTest(const std::vector<Path>& paths,
    const std::vector<LineStyle>& lineStyles, std::int32_t x,
    std::int32_t y, const SWFMatrix& wm);

} // namespace geometry


} // namespace gnash

#endif // GNASH_GEOMETRY_H


// Local Variables:
// mode: C++
// c-basic-offset: 8 
// tab-width: 8
// indent-tabs-mode: t
// End: