/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



#ifndef _BGFX_RASTER_RASTERCONVERT3D_HXX
#define _BGFX_RASTER_RASTERCONVERT3D_HXX

#include <sal/types.h>
#include <vector>
#include <basegfx/color/bcolor.hxx>
#include <basegfx/vector/b3dvector.hxx>
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/vector/b2dvector.hxx>
#include <basegfx/basegfxdllapi.h>

//////////////////////////////////////////////////////////////////////////////
// predeclarations

namespace basegfx
{
    class B3DPolygon;
    class B3DPolyPolygon;
}

//////////////////////////////////////////////////////////////////////////////
// interpolators for double precision

namespace basegfx
{
    class BASEGFX_DLLPUBLIC ip_single
    {
    private:
	    double										mfVal;
	    double										mfInc;

    public:
	    ip_single() 
	    :	mfVal(0.0), 
		    mfInc(0.0) 
	    {}

	    ip_single(double fVal, double fInc) 
	    :	mfVal(fVal), 
		    mfInc(fInc) 
	    {}

	    double getVal() const { return mfVal; }
	    double getInc() const { return mfInc; }

	    void increment(double fStep) { mfVal += fStep * mfInc; }
    };
} // end of namespace basegfx

namespace basegfx
{
    class BASEGFX_DLLPUBLIC ip_double
    {
    private:
	    ip_single									maX;
	    ip_single									maY;

    public:
	    ip_double() 
	    :	maX(),
		    maY()
	    {}

	    ip_double(double fXVal, double fXInc, double fYVal, double fYInc) 
	    :	maX(fXVal, fXInc),
		    maY(fYVal, fYInc)
	    {}

	    const ip_single& getX() const { return maX; }
	    const ip_single& getY() const { return maY; }

	    void increment(double fStep) { maX.increment(fStep); maY.increment(fStep); }
    };
} // end of namespace basegfx

namespace basegfx
{
    class BASEGFX_DLLPUBLIC ip_triple
    {
    private:
	    ip_single									maX;
	    ip_single									maY;
	    ip_single									maZ;

    public:
	    ip_triple() 
	    :	maX(),
		    maY(),
		    maZ()
	    {}

	    ip_triple(double fXVal, double fXInc, double fYVal, double fYInc, double fZVal, double fZInc) 
	    :	maX(fXVal, fXInc),
		    maY(fYVal, fYInc),
		    maZ(fZVal, fZInc)
	    {}

	    const ip_single& getX() const { return maX; }
	    const ip_single& getY() const { return maY; }
	    const ip_single& getZ() const { return maZ; }

	    void increment(double fStep) { maX.increment(fStep); maY.increment(fStep); maZ.increment(fStep); }
    };
} // end of namespace basegfx

//////////////////////////////////////////////////////////////////////////////
// InterpolatorProvider3D to have a common source for allocating interpolators
// which may then be addressed using the index to the vectors

namespace basegfx
{
    #define	SCANLINE_EMPTY_INDEX (0xffffffff)

    class BASEGFX_DLLPUBLIC InterpolatorProvider3D
    {
    private:
	    ::std::vector< ip_triple >					maColorInterpolators;
	    ::std::vector< ip_triple >					maNormalInterpolators;
	    ::std::vector< ip_double >					maTextureInterpolators;
	    ::std::vector< ip_triple >					maInverseTextureInterpolators;

    protected:
	    sal_uInt32 addColorInterpolator(const BColor& rA, const BColor& rB, double fInvYDelta)
	    {
            double aDeltaRed(rB.getRed() - rA.getRed());

            if(fTools::equalZero(aDeltaRed))
            {
                aDeltaRed = 0.0;
            }
            else
            {
                aDeltaRed *= fInvYDelta;
            }

            double aDeltaGreen(rB.getGreen() - rA.getGreen());

            if(fTools::equalZero(aDeltaGreen))
            {
                aDeltaGreen = 0.0;
            }
            else
            {
                aDeltaGreen *= fInvYDelta;
            }

            double aDeltaBlue(rB.getBlue() - rA.getBlue());

            if(fTools::equalZero(aDeltaBlue))
            {
                aDeltaBlue = 0.0;
            }
            else
            {
                aDeltaBlue *= fInvYDelta;
            }

		    maColorInterpolators.push_back(
                ip_triple(
                    rA.getRed(), aDeltaRed, 
                    rA.getGreen(), aDeltaGreen, 
                    rA.getBlue(), aDeltaBlue));

		    return (maColorInterpolators.size() - 1);
	    }

	    sal_uInt32 addNormalInterpolator(const B3DVector& rA, const B3DVector& rB, double fInvYDelta)
	    {
            double aDeltaX(rB.getX() - rA.getX());

            if(fTools::equalZero(aDeltaX))
            {
                aDeltaX = 0.0;
            }
            else
            {
                aDeltaX *= fInvYDelta;
            }

            double aDeltaY(rB.getY() - rA.getY());

            if(fTools::equalZero(aDeltaY))
            {
                aDeltaY = 0.0;
            }
            else
            {
                aDeltaY *= fInvYDelta;
            }

            double aDeltaZ(rB.getZ() - rA.getZ());

            if(fTools::equalZero(aDeltaZ))
            {
                aDeltaZ = 0.0;
            }
            else
            {
                aDeltaZ *= fInvYDelta;
            }

		    maNormalInterpolators.push_back(
                ip_triple(
                    rA.getX(), aDeltaX, 
                    rA.getY(), aDeltaY, 
                    rA.getZ(), aDeltaZ));

		    return (maNormalInterpolators.size() - 1);
	    }

	    sal_uInt32 addTextureInterpolator(const B2DPoint& rA, const B2DPoint& rB, double fInvYDelta)
	    {
            double aDeltaX(rB.getX() - rA.getX());

            if(fTools::equalZero(aDeltaX))
            {
                aDeltaX = 0.0;
            }
            else
            {
                aDeltaX *= fInvYDelta;
            }

            double aDeltaY(rB.getY() - rA.getY());

            if(fTools::equalZero(aDeltaY))
            {
                aDeltaY = 0.0;
            }
            else
            {
                aDeltaY *= fInvYDelta;
            }

		    maTextureInterpolators.push_back(
                ip_double(
                    rA.getX(), aDeltaX, 
                    rA.getY(), aDeltaY));

		    return (maTextureInterpolators.size() - 1);
	    }

	    sal_uInt32 addInverseTextureInterpolator(const B2DPoint& rA, const B2DPoint& rB, double fZEyeA, double fZEyeB, double fInvYDelta)
	    {
            double fZDelta(fZEyeB - fZEyeA);
            const double fInvZEyeA(fTools::equalZero(fZEyeA) ? fZEyeA : 1.0 / fZEyeA);
            double fInvZEyeB(fInvZEyeA);

            if(fTools::equalZero(fZDelta))
            {
                fZDelta = 0.0;
            }
            else
            {
                fInvZEyeB = fTools::equalZero(fZEyeB) ? fZEyeB : 1.0 / fZEyeB;
                fZDelta = (fInvZEyeB - fInvZEyeA) * fInvYDelta;
            }

            const B2DPoint aInvA(rA * fInvZEyeA);
            const B2DPoint aInvB(rB * fInvZEyeB);
            const double aDeltaX((aInvB.getX() - aInvA.getX()) * fInvYDelta);
            const double aDeltaY((aInvB.getY() - aInvA.getY()) * fInvYDelta);

		    maInverseTextureInterpolators.push_back(
                ip_triple(
                    aInvA.getX(), aDeltaX, 
                    aInvA.getY(), aDeltaY, 
                    fInvZEyeA, fZDelta));

		    return (maInverseTextureInterpolators.size() - 1);
	    }

	    void reset()
	    {
		    maColorInterpolators.clear();
		    maNormalInterpolators.clear();
		    maTextureInterpolators.clear();
		    maInverseTextureInterpolators.clear();
	    }

    public:
	    InterpolatorProvider3D() {}

	    ::std::vector< ip_triple >& getColorInterpolators() { return maColorInterpolators; }
	    ::std::vector< ip_triple >& getNormalInterpolators() { return maNormalInterpolators; }
	    ::std::vector< ip_double >& getTextureInterpolators() { return maTextureInterpolators; }
	    ::std::vector< ip_triple >& getInverseTextureInterpolators() { return maInverseTextureInterpolators; }
    };
} // end of namespace basegfx

//////////////////////////////////////////////////////////////////////////////
// RasterConversionLineEntry3D for Raterconversion of 3D PolyPolygons

namespace basegfx
{
    class BASEGFX_DLLPUBLIC RasterConversionLineEntry3D
    {
    private:
	    ip_single									maX;
	    ip_single									maZ;
	    sal_Int32									mnY;
	    sal_uInt32									mnCount;

	    sal_uInt32									mnColorIndex;
	    sal_uInt32									mnNormalIndex;
	    sal_uInt32									mnTextureIndex;
	    sal_uInt32									mnInverseTextureIndex;

    public:
	    RasterConversionLineEntry3D(const double& rfX, const double& rfDeltaX, const double& rfZ, const double& rfDeltaZ, sal_Int32 nY, sal_uInt32 nCount)
	    :	maX(rfX, rfDeltaX),
		    maZ(rfZ, rfDeltaZ),
		    mnY(nY),
		    mnCount(nCount),
		    mnColorIndex(SCANLINE_EMPTY_INDEX),
		    mnNormalIndex(SCANLINE_EMPTY_INDEX),
		    mnTextureIndex(SCANLINE_EMPTY_INDEX),
		    mnInverseTextureIndex(SCANLINE_EMPTY_INDEX)
	    {}

	    void setColorIndex(sal_uInt32 nIndex) { mnColorIndex = nIndex; }
	    void setNormalIndex(sal_uInt32 nIndex) { mnNormalIndex = nIndex; }
	    void setTextureIndex(sal_uInt32 nIndex) { mnTextureIndex = nIndex; }
	    void setInverseTextureIndex(sal_uInt32 nIndex) { mnInverseTextureIndex = nIndex; }

	    bool operator<(const RasterConversionLineEntry3D& rComp) const
	    {
		    if(mnY == rComp.mnY)
		    {
			    return maX.getVal() < rComp.maX.getVal();
		    }

		    return mnY < rComp.mnY;
	    }

	    bool decrementRasterConversionLineEntry3D(sal_uInt32 nStep)
	    {
		    if(nStep >= mnCount)
		    {
			    return false;
		    }
		    else
		    {
			    mnCount -= nStep;
			    return true;
		    }
	    }

	    void incrementRasterConversionLineEntry3D(sal_uInt32 nStep, InterpolatorProvider3D& rProvider)
	    {
		    const double fStep((double)nStep);
		    maX.increment(fStep);
		    maZ.increment(fStep);
		    mnY += nStep;

		    if(SCANLINE_EMPTY_INDEX != mnColorIndex)
		    {
			    rProvider.getColorInterpolators()[mnColorIndex].increment(fStep);
		    }

		    if(SCANLINE_EMPTY_INDEX != mnNormalIndex)
		    {
			    rProvider.getNormalInterpolators()[mnNormalIndex].increment(fStep);
		    }

		    if(SCANLINE_EMPTY_INDEX != mnTextureIndex)
		    {
			    rProvider.getTextureInterpolators()[mnTextureIndex].increment(fStep);
		    }

		    if(SCANLINE_EMPTY_INDEX != mnInverseTextureIndex)
		    {
			    rProvider.getInverseTextureInterpolators()[mnInverseTextureIndex].increment(fStep);
		    }
	    }

	    // data read access
	    const ip_single& getX() const { return maX; }
	    sal_Int32 getY() const { return mnY; }
	    const ip_single& getZ() const { return maZ; }
	    sal_uInt32 getColorIndex() const { return mnColorIndex; }
	    sal_uInt32 getNormalIndex() const { return mnNormalIndex; }
	    sal_uInt32 getTextureIndex() const { return mnTextureIndex; }
	    sal_uInt32 getInverseTextureIndex() const { return mnInverseTextureIndex; }
    };
} // end of namespace basegfx

//////////////////////////////////////////////////////////////////////////////
// the basic RaterConverter itself. Only one method needs to be overloaded. The
// class itself is strictly virtual

namespace basegfx
{
    class BASEGFX_DLLPUBLIC RasterConverter3D : public InterpolatorProvider3D
    {
    private:
        // the line entries for an area conversion run
	    ::std::vector< RasterConversionLineEntry3D >			maLineEntries;

	    struct lineComparator
	    {
		    bool operator()(const RasterConversionLineEntry3D* pA, const RasterConversionLineEntry3D* pB)
		    {
			    OSL_ENSURE(pA && pB, "lineComparator: empty pointer (!)");
			    return pA->getX().getVal() < pB->getX().getVal();
		    }
	    };

	    void addArea(const B3DPolygon& rFill, const B3DHomMatrix* pViewToEye);
	    void addArea(const B3DPolyPolygon& rFill, const B3DHomMatrix* pViewToEye);
	    void addEdge(const B3DPolygon& rFill, sal_uInt32 a, sal_uInt32 b, const B3DHomMatrix* pViewToEye);

        void rasterconvertB3DArea(sal_Int32 nStartLine, sal_Int32 nStopLine);
	    void rasterconvertB3DEdge(const B3DPolygon& rLine, sal_uInt32 nA, sal_uInt32 nB, sal_Int32 nStartLine, sal_Int32 nStopLine, sal_uInt16 nLineWidth);

        virtual void processLineSpan(const RasterConversionLineEntry3D& rA, const RasterConversionLineEntry3D& rB, sal_Int32 nLine, sal_uInt32 nSpanCount) = 0;

    public:
	    RasterConverter3D();
        virtual ~RasterConverter3D();

	    void rasterconvertB3DPolyPolygon(const B3DPolyPolygon& rFill, const B3DHomMatrix* pViewToEye, sal_Int32 nStartLine, sal_Int32 nStopLine);
	    void rasterconvertB3DPolygon(const B3DPolygon& rLine, sal_Int32 nStartLine, sal_Int32 nStopLine, sal_uInt16 nLineWidth);
    };
} // end of namespace basegfx

//////////////////////////////////////////////////////////////////////////////

#endif /* _BGFX_RASTER_RASTERCONVERT3D_HXX */