/**************************************************************
 * 
 * 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.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_basegfx.hxx"

#include <basegfx/raster/rasterconvert3d.hxx>
#include <basegfx/polygon/b3dpolygon.hxx>
#include <basegfx/polygon/b3dpolypolygon.hxx>
#include <basegfx/point/b3dpoint.hxx>

//////////////////////////////////////////////////////////////////////////////
// implementations of the 3D raster converter

namespace basegfx
{
    void RasterConverter3D::addArea(const B3DPolygon& rFill, const B3DHomMatrix* pViewToEye)
    {
	    const sal_uInt32 nPointCount(rFill.count());

	    for(sal_uInt32 a(0); a < nPointCount; a++)
	    {
		    addEdge(rFill, a, (a + 1) % nPointCount, pViewToEye);
	    }
    }

    void RasterConverter3D::addArea(const B3DPolyPolygon& rFill, const B3DHomMatrix* pViewToEye)
    {
	    const sal_uInt32 nPolyCount(rFill.count());

	    for(sal_uInt32 a(0); a < nPolyCount; a++)
	    {
		    addArea(rFill.getB3DPolygon(a), pViewToEye);
	    }
    }

    RasterConverter3D::RasterConverter3D()
    :	InterpolatorProvider3D(),
	    maLineEntries()
    {}

    RasterConverter3D::~RasterConverter3D()
    {}

    void RasterConverter3D::rasterconvertB3DArea(sal_Int32 nStartLine, sal_Int32 nStopLine)
    {
	    if(maLineEntries.size())
	    {
		    OSL_ENSURE(nStopLine >= nStartLine, "nStopLine is bigger than nStartLine (!)");

            // sort global entries by Y, X once. After this, the vector
		    // is seen as frozen. Pointers to it's entries will be used in the following code.
		    ::std::sort(maLineEntries.begin(), maLineEntries.end());

		    // local parameters
		    ::std::vector< RasterConversionLineEntry3D >::iterator aCurrentEntry(maLineEntries.begin());
		    ::std::vector< RasterConversionLineEntry3D* > aCurrentLine;
		    ::std::vector< RasterConversionLineEntry3D* > aNextLine;
		    ::std::vector< RasterConversionLineEntry3D* >::iterator aRasterConversionLineEntry3D;
		    sal_uInt32 nPairCount(0);

		    // get scanlines first LineNumber as start
		    sal_Int32 nLineNumber(::std::max(aCurrentEntry->getY(), nStartLine));

		    while((aCurrentLine.size() || aCurrentEntry != maLineEntries.end()) && (nLineNumber < nStopLine))
		    {
			    // add all entries which start at current line to current scanline
			    while(aCurrentEntry != maLineEntries.end())
			    {
				    const sal_Int32 nCurrentLineNumber(aCurrentEntry->getY());

				    if(nCurrentLineNumber > nLineNumber)
				    {
					    // line is below current one, done (since array is sorted)
					    break;
				    }
				    else
				    {
					    // less or equal. Line is above or at current one. Advance it exactly to
					    // current line
					    const sal_uInt32 nStep(nLineNumber - nCurrentLineNumber);

					    if(!nStep || aCurrentEntry->decrementRasterConversionLineEntry3D(nStep))
					    {
						    // add when exactly on current line or when incremet to it did not 
						    // completely consume it
						    if(nStep)
						    {
							    aCurrentEntry->incrementRasterConversionLineEntry3D(nStep, *this);
						    }

						    aCurrentLine.push_back(&(*(aCurrentEntry)));
					    }
				    }

				    aCurrentEntry++;
			    }

			    // sort current scanline using comparator. Only X is used there
			    // since all entries are already in one processed line. This needs to be done
			    // everytime since not only new spans may have benn added or old removed,
			    // but incrementing may also have changed the order
			    ::std::sort(aCurrentLine.begin(), aCurrentLine.end(), lineComparator());

			    // process current scanline
			    aRasterConversionLineEntry3D = aCurrentLine.begin();
			    aNextLine.clear();
			    nPairCount = 0;

			    while(aRasterConversionLineEntry3D != aCurrentLine.end())
			    {
				    RasterConversionLineEntry3D& rPrevScanRasterConversionLineEntry3D(**aRasterConversionLineEntry3D++);

				    // look for 2nd span
				    if(aRasterConversionLineEntry3D != aCurrentLine.end())
				    {
					    // work on span from rPrevScanRasterConversionLineEntry3D to aRasterConversionLineEntry3D, fLineNumber is valid
					    processLineSpan(rPrevScanRasterConversionLineEntry3D, **aRasterConversionLineEntry3D, nLineNumber, nPairCount++);
				    }

				    // increment to next line
				    if(rPrevScanRasterConversionLineEntry3D.decrementRasterConversionLineEntry3D(1))
				    {
					    rPrevScanRasterConversionLineEntry3D.incrementRasterConversionLineEntry3D(1, *this);
					    aNextLine.push_back(&rPrevScanRasterConversionLineEntry3D);
				    }
			    }

			    // copy back next scanline if count has changed
			    if(aNextLine.size() != aCurrentLine.size())
			    {
				    aCurrentLine = aNextLine;
			    }

			    // increment fLineNumber
			    nLineNumber++;
		    }
	    }
    }

    void RasterConverter3D::addEdge(const B3DPolygon& rFill, sal_uInt32 a, sal_uInt32 b, const B3DHomMatrix* pViewToEye)
    {
	    B3DPoint aStart(rFill.getB3DPoint(a));
	    B3DPoint aEnd(rFill.getB3DPoint(b));
	    sal_Int32 nYStart(fround(aStart.getY()));
	    sal_Int32 nYEnd(fround(aEnd.getY()));

	    if(nYStart != nYEnd)
	    {
		    if(nYStart > nYEnd)
		    {
			    ::std::swap(aStart, aEnd);
			    ::std::swap(nYStart, nYEnd);
			    ::std::swap(a, b);
		    }

		    const sal_uInt32 nYDelta(nYEnd - nYStart);
		    const double fInvYDelta(1.0 / nYDelta);
		    maLineEntries.push_back(RasterConversionLineEntry3D(
			    aStart.getX(), (aEnd.getX() - aStart.getX()) * fInvYDelta,
			    aStart.getZ(), (aEnd.getZ() - aStart.getZ()) * fInvYDelta,
			    nYStart, nYDelta));

		    // if extra interpolation data is used, add it to the last created entry
		    RasterConversionLineEntry3D& rEntry = maLineEntries[maLineEntries.size() - 1];

		    if(rFill.areBColorsUsed())
		    {
			    rEntry.setColorIndex(addColorInterpolator(rFill.getBColor(a), rFill.getBColor(b), fInvYDelta));
		    }

		    if(rFill.areNormalsUsed())
		    {
			    rEntry.setNormalIndex(addNormalInterpolator(rFill.getNormal(a), rFill.getNormal(b), fInvYDelta));
		    }

		    if(rFill.areTextureCoordinatesUsed())
		    {
			    if(pViewToEye)
			    {
				    const double fEyeA(((*pViewToEye) * aStart).getZ());
				    const double fEyeB(((*pViewToEye) * aEnd).getZ());

				    rEntry.setInverseTextureIndex(addInverseTextureInterpolator(
					    rFill.getTextureCoordinate(a), 
					    rFill.getTextureCoordinate(b), 
					    fEyeA, fEyeB, fInvYDelta));
			    }
			    else
			    {
				    rEntry.setTextureIndex(addTextureInterpolator(
					    rFill.getTextureCoordinate(a), 
					    rFill.getTextureCoordinate(b), 
					    fInvYDelta));
			    }
		    }
	    }
    }

    void RasterConverter3D::rasterconvertB3DEdge(const B3DPolygon& rLine, sal_uInt32 nA, sal_uInt32 nB, sal_Int32 nStartLine, sal_Int32 nStopLine, sal_uInt16 nLineWidth)
    {
        B3DPoint aStart(rLine.getB3DPoint(nA));
        B3DPoint aEnd(rLine.getB3DPoint(nB));
        const double fZBufferLineAdd(0x00ff);
		static bool bForceToPolygon(false);

        if(nLineWidth > 1 || bForceToPolygon)
        {
            // this is not a hairline anymore, in most cases since it's an oversampled
            // hairline to get e.g. AA for Z-Buffering. Create fill geometry.
            if(!aStart.equal(aEnd))
            {
		        reset();
		        maLineEntries.clear();
                
                B2DVector aVector(aEnd.getX() - aStart.getX(), aEnd.getY() - aStart.getY());
                aVector.normalize();
            	const B2DVector aPerpend(getPerpendicular(aVector) * ((static_cast<double>(nLineWidth) + 0.5) * 0.5));
                const double fZStartWithAdd(aStart.getZ() + fZBufferLineAdd);
                const double fZEndWithAdd(aEnd.getZ() + fZBufferLineAdd);

                B3DPolygon aPolygon;
                aPolygon.append(B3DPoint(aStart.getX() + aPerpend.getX(), aStart.getY() + aPerpend.getY(), fZStartWithAdd));
                aPolygon.append(B3DPoint(aEnd.getX() + aPerpend.getX(), aEnd.getY() + aPerpend.getY(), fZEndWithAdd));
                aPolygon.append(B3DPoint(aEnd.getX() - aPerpend.getX(), aEnd.getY() - aPerpend.getY(), fZEndWithAdd));
                aPolygon.append(B3DPoint(aStart.getX() - aPerpend.getX(), aStart.getY() - aPerpend.getY(), fZStartWithAdd));
                aPolygon.setClosed(true);

                addArea(aPolygon, 0);
            }
        }
        else
        {
            // it's a hairline. Use direct RasterConversionLineEntry creation to
            // rasterconvert lines as similar to areas as possible to avoid Z-Fighting
	        sal_Int32 nYStart(fround(aStart.getY()));
	        sal_Int32 nYEnd(fround(aEnd.getY()));

	        if(nYStart == nYEnd)
	        {
		        // horizontal line, check X
		        const sal_Int32 nXStart(static_cast<sal_Int32>(aStart.getX()));
		        const sal_Int32 nXEnd(static_cast<sal_Int32>(aEnd.getX()));

		        if(nXStart != nXEnd)
		        {
			        reset();
			        maLineEntries.clear();
    				
			        // horizontal line, create vertical entries. These will be sorted by
			        // X anyways, so no need to distinguish the case here
			        maLineEntries.push_back(RasterConversionLineEntry3D(
				        aStart.getX(), 0.0,
				        aStart.getZ() + fZBufferLineAdd, 0.0,
				        nYStart, 1));
			        maLineEntries.push_back(RasterConversionLineEntry3D(
				        aEnd.getX(), 0.0,
				        aEnd.getZ() + fZBufferLineAdd, 0.0,
				        nYStart, 1));
		        }
	        }
	        else
	        {
		        reset();
		        maLineEntries.clear();

		        if(nYStart > nYEnd)
		        {
			        ::std::swap(aStart, aEnd);
			        ::std::swap(nYStart, nYEnd);
		        }

		        const sal_uInt32 nYDelta(static_cast<sal_uInt32>(nYEnd - nYStart));
		        const double fInvYDelta(1.0 / nYDelta);

		        // non-horizontal line, create two parallell entries. These will be sorted by
		        // X anyways, so no need to distinguish the case here
		        maLineEntries.push_back(RasterConversionLineEntry3D(
			        aStart.getX(), (aEnd.getX() - aStart.getX()) * fInvYDelta,
			        aStart.getZ() + fZBufferLineAdd, (aEnd.getZ() - aStart.getZ()) * fInvYDelta,
			        nYStart, nYDelta));

		        RasterConversionLineEntry3D& rEntry = maLineEntries[maLineEntries.size() - 1];

		        // need to choose a X-Distance for the 2nd edge which guarantees all pixels 
		        // of the line to be set. This is exactly the X-Increment for one Y-Step.
		        // Same is true for Z, so in both cases, add one increment to them. To also
		        // guarantee one pixel per line, add a minimum of one for X.
		        const double fDistanceX(fabs(rEntry.getX().getInc()) >= 1.0 ? rEntry.getX().getInc() : 1.0);

		        maLineEntries.push_back(RasterConversionLineEntry3D(
			        rEntry.getX().getVal() + fDistanceX, rEntry.getX().getInc(),
			        rEntry.getZ().getVal() + rEntry.getZ().getInc(), rEntry.getZ().getInc(),
			        nYStart, nYDelta));
	        }
        }

        if(maLineEntries.size())
        {
	        rasterconvertB3DArea(nStartLine, nStopLine);
        }
    }

    void RasterConverter3D::rasterconvertB3DPolyPolygon(const B3DPolyPolygon& rFill, const B3DHomMatrix* pViewToEye, sal_Int32 nStartLine, sal_Int32 nStopLine)
    {
	    reset();
	    maLineEntries.clear();
	    addArea(rFill, pViewToEye);
	    rasterconvertB3DArea(nStartLine, nStopLine);
    }

    void RasterConverter3D::rasterconvertB3DPolygon(const B3DPolygon& rLine, sal_Int32 nStartLine, sal_Int32 nStopLine, sal_uInt16 nLineWidth)
    {
	    const sal_uInt32 nPointCount(rLine.count());

	    if(nPointCount)
	    {
		    const sal_uInt32 nEdgeCount(rLine.isClosed() ? nPointCount : nPointCount - 1);

		    for(sal_uInt32 a(0); a < nEdgeCount; a++)
		    {
			    rasterconvertB3DEdge(rLine, a, (a + 1) % nPointCount, nStartLine, nStopLine, nLineWidth);
		    }
	    }
    }
} // end of namespace basegfx

//////////////////////////////////////////////////////////////////////////////
// eof