gradienttools.hxx

Go to the documentation of this file.

/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * Copyright 2000, 2010 Oracle and/or its affiliates.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org 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 Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

#ifndef _BGFX_TOOLS_GRADIENTTOOLS_HXX
#define _BGFX_TOOLS_GRADIENTTOOLS_HXX

#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/range/b2drange.hxx>
#include <basegfx/vector/b2dvector.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/numeric/ftools.hxx>

namespace basegfx
{
    struct ODFGradientInfo
    {
        B2DHomMatrix maTextureTransform;

        B2DHomMatrix maBackTextureTransform;

        double       mfAspectRatio;

        sal_uInt32   mnSteps;
    };

    namespace tools
    {
        ODFGradientInfo& createLinearODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
                                                     const B2DRange&  rTargetArea, 
                                                     sal_uInt32       nSteps, 
                                                     double           fBorder, 
                                                     double           fAngle);
        
        inline double getLinearGradientAlpha(const B2DPoint&        rUV,
                                             const ODFGradientInfo& rGradInfo )
        {
            const B2DPoint aCoor(rGradInfo.maBackTextureTransform * rUV);
            const double t(clamp(aCoor.getY(), 0.0, 1.0));
            const sal_uInt32 nSteps(rGradInfo.mnSteps);

            if(nSteps > 2L && nSteps < 128L)
                return floor(t * nSteps) / double(nSteps + 1L);

            return t;
        }

        ODFGradientInfo& createAxialODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
                                                    const B2DRange&  rTargetArea, 
                                                    sal_uInt32       nSteps, 
                                                    double           fBorder, 
                                                    double           fAngle);

        inline double getAxialGradientAlpha(const B2DPoint&        rUV,
                                            const ODFGradientInfo& rGradInfo )
        {
            const B2DPoint   aCoor(rGradInfo.maBackTextureTransform * rUV);
            const double     t(clamp(fabs(aCoor.getY()), 0.0, 1.0));
            const sal_uInt32 nSteps(rGradInfo.mnSteps);
            const double     fInternalSteps((nSteps * 2L) - 1L);

            if(nSteps > 2L && nSteps < 128L)
                return floor(((t * fInternalSteps) + 1.0) / 2.0) / double(nSteps - 1L);

            return t;
        }
        
        ODFGradientInfo& createRadialODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
                                                     const B2DRange&  rTargetArea, 
                                                     const B2DVector& rOffset,
                                                     sal_uInt32       nSteps, 
                                                     double           fBorder);
        
        inline double getRadialGradientAlpha(const B2DPoint&        rUV,
                                             const ODFGradientInfo& rGradInfo )
        {
            const B2DPoint aCoor(rGradInfo.maBackTextureTransform * rUV);
            const double   fDist(
                clamp(aCoor.getX() * aCoor.getX() + aCoor.getY() * aCoor.getY(),
                      0.0,
                      1.0));

            const double t(1.0 - sqrt(fDist));
            const sal_uInt32 nSteps(rGradInfo.mnSteps);

            if(nSteps > 2L && nSteps < 128L)
                return floor(t * nSteps) / double(nSteps - 1L);

            return t;
        }

        ODFGradientInfo& createEllipticalODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
                                                         const B2DRange&  rTargetArea, 
                                                         const B2DVector& rOffset,
                                                         sal_uInt32       nSteps, 
                                                         double           fBorder, 
                                                         double           fAngle);

        inline double getEllipticalGradientAlpha(const B2DPoint&        rUV,
                                                 const ODFGradientInfo& rGradInfo )
        {
            return getRadialGradientAlpha(rUV,rGradInfo); // only matrix setup differs
        }

        ODFGradientInfo& createSquareODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
                                                     const B2DRange&  rTargetArea, 
                                                     const B2DVector& rOffset,
                                                     sal_uInt32       nSteps, 
                                                     double           fBorder, 
                                                     double           fAngle);

        inline double getSquareGradientAlpha(const B2DPoint&        rUV,
                                             const ODFGradientInfo& rGradInfo )
        {
            const B2DPoint aCoor(rGradInfo.maBackTextureTransform * rUV);
            const double   fAbsX(fabs(aCoor.getX()));
            const double   fAbsY(fabs(aCoor.getY()));

            if(fTools::moreOrEqual(fAbsX, 1.0) || fTools::moreOrEqual(fAbsY, 1.0))
                return 0.0;

            const double t(1.0 - (fAbsX > fAbsY ? fAbsX : fAbsY));
            const sal_uInt32 nSteps(rGradInfo.mnSteps);

            if(nSteps > 2L && nSteps < 128L)
                return floor(t * nSteps) / double(nSteps - 1L);

            return t;
        }

        ODFGradientInfo& createRectangularODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
                                                          const B2DRange&  rTargetArea, 
                                                          const B2DVector& rOffset,
                                                          sal_uInt32       nSteps, 
                                                          double           fBorder, 
                                                          double           fAngle);

        inline double getRectangularGradientAlpha(const B2DPoint&        rUV,
                                                  const ODFGradientInfo& rGradInfo )
        {
            return getSquareGradientAlpha(rUV, rGradInfo); // only matrix setup differs
        }

    }
}

#endif

---