/**************************************************************
 * 
 * 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_drawinglayer.hxx"

#include <drawinglayer/primitive3d/sdrextrudelathetools3d.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <basegfx/range/b2drange.hxx>
#include <basegfx/polygon/b2dpolypolygontools.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/point/b3dpoint.hxx>
#include <basegfx/polygon/b3dpolygon.hxx>
#include <basegfx/polygon/b3dpolygontools.hxx>
#include <basegfx/polygon/b3dpolypolygontools.hxx>
#include <basegfx/range/b3drange.hxx>
#include <basegfx/matrix/b3dhommatrix.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <drawinglayer/geometry/viewinformation3d.hxx>
#include <numeric>

//////////////////////////////////////////////////////////////////////////////
// decompositon helpers for extrude/lathe (rotation) objects

namespace
{
	//////////////////////////////////////////////////////////////////////////////
	// common helpers

	basegfx::B2DPolyPolygon impScalePolyPolygonOnCenter(
		const basegfx::B2DPolyPolygon& rSource, 
		double fScale)
	{
		basegfx::B2DPolyPolygon aRetval(rSource);
		
		if(!basegfx::fTools::equalZero(fScale))
		{
			const basegfx::B2DRange aRange(basegfx::tools::getRange(rSource));
			const basegfx::B2DPoint aCenter(aRange.getCenter());
			basegfx::B2DHomMatrix aTrans;

			aTrans.translate(-aCenter.getX(), -aCenter.getY());
			aTrans.scale(fScale, fScale);
			aTrans.translate(aCenter.getX(), aCenter.getY());
			aRetval.transform(aTrans);
		}

		return aRetval;
	}

	void impGetOuterPolyPolygon(
		basegfx::B2DPolyPolygon& rPolygon, 
		basegfx::B2DPolyPolygon& rOuterPolyPolygon, 
		double fOffset, 
		bool bCharacterMode)
	{
		rOuterPolyPolygon = rPolygon;

		if(basegfx::fTools::more(fOffset, 0.0))
		{
			if(bCharacterMode)
			{
				// grow the outside polygon and scale all polygons to original size. This is done
				// to avoid a shrink which potentially would lead to self-intersections, but changes
				// the original polygon -> not a precision step, so e.g. not usable for charts
				const basegfx::B2DRange aRange(basegfx::tools::getRange(rPolygon));
				rPolygon = basegfx::tools::growInNormalDirection(rPolygon, fOffset);
				const basegfx::B2DRange aGrownRange(basegfx::tools::getRange(rPolygon));
				const double fScaleX(basegfx::fTools::equalZero(aGrownRange.getWidth()) ? 1.0 : aRange.getWidth() / aGrownRange.getWidth());
				const double fScaleY(basegfx::fTools::equalZero(aGrownRange.getHeight())? 1.0 : aRange.getHeight() / aGrownRange.getHeight());
				basegfx::B2DHomMatrix aScaleTrans;

				aScaleTrans.translate(-aGrownRange.getMinX(), -aGrownRange.getMinY());
				aScaleTrans.scale(fScaleX, fScaleY);
				aScaleTrans.translate(aRange.getMinX(), aRange.getMinY());
				rPolygon.transform(aScaleTrans);
				rOuterPolyPolygon.transform(aScaleTrans);
			}
			else
			{
				// use more precision, shrink the outer polygons. Since this may lead to self-intersections,
				// some kind of correction should be applied here after that step
				rOuterPolyPolygon = basegfx::tools::growInNormalDirection(rPolygon, -fOffset);
				basegfx::tools::correctGrowShrinkPolygonPair(rPolygon, rOuterPolyPolygon);
			}
		}
	}

	void impAddInBetweenFill(
		basegfx::B3DPolyPolygon& rTarget, 
		const basegfx::B3DPolyPolygon& rPolA, 
		const basegfx::B3DPolyPolygon& rPolB,
		double fTexVerStart, 
		double fTexVerStop, 
		bool bCreateNormals, 
		bool bCreateTextureCoordinates)
	{
		OSL_ENSURE(rPolA.count() == rPolB.count(), "impAddInBetweenFill: unequally sized polygons (!)");
		const sal_uInt32 nPolygonCount(::std::min(rPolA.count(), rPolB.count()));

		for(sal_uInt32 a(0L); a < nPolygonCount; a++)
		{
			const basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
			const basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
			OSL_ENSURE(aSubA.count() == aSubB.count(), "impAddInBetweenFill: unequally sized polygons (!)");
			const sal_uInt32 nPointCount(::std::min(aSubA.count(), aSubB.count()));

			if(nPointCount)
			{
				const sal_uInt32 nEdgeCount(aSubA.isClosed() ? nPointCount : nPointCount - 1L);
				double fTexHorMultiplicatorA(0.0), fTexHorMultiplicatorB(0.0);
				double fPolygonPosA(0.0), fPolygonPosB(0.0);

				if(bCreateTextureCoordinates)
				{
					const double fPolygonLengthA(basegfx::tools::getLength(aSubA));
					fTexHorMultiplicatorA = basegfx::fTools::equalZero(fPolygonLengthA) ? 1.0 : 1.0 / fPolygonLengthA;

					const double fPolygonLengthB(basegfx::tools::getLength(aSubB));
					fTexHorMultiplicatorB = basegfx::fTools::equalZero(fPolygonLengthB) ? 1.0 : 1.0 / fPolygonLengthB;
				}

				for(sal_uInt32 b(0L); b < nEdgeCount; b++)
				{
					const sal_uInt32 nIndexA(b);
					const sal_uInt32 nIndexB((b + 1L) % nPointCount);
					
					const basegfx::B3DPoint aStartA(aSubA.getB3DPoint(nIndexA));
					const basegfx::B3DPoint aEndA(aSubA.getB3DPoint(nIndexB));
					const basegfx::B3DPoint aStartB(aSubB.getB3DPoint(nIndexA));
					const basegfx::B3DPoint aEndB(aSubB.getB3DPoint(nIndexB));

					basegfx::B3DPolygon aNew;
					aNew.setClosed(true);

					aNew.append(aStartA);
					aNew.append(aStartB);
					aNew.append(aEndB);
					aNew.append(aEndA);

					if(bCreateNormals)
					{
						aNew.setNormal(0L, aSubA.getNormal(nIndexA));
						aNew.setNormal(1L, aSubB.getNormal(nIndexA));
						aNew.setNormal(2L, aSubB.getNormal(nIndexB));
						aNew.setNormal(3L, aSubA.getNormal(nIndexB));
					}

					if(bCreateTextureCoordinates)
					{
						const double fRelTexAL(fPolygonPosA * fTexHorMultiplicatorA);
						const double fEdgeLengthA(basegfx::B3DVector(aEndA - aStartA).getLength());
						fPolygonPosA += fEdgeLengthA;
						const double fRelTexAR(fPolygonPosA * fTexHorMultiplicatorA);
						
						const double fRelTexBL(fPolygonPosB * fTexHorMultiplicatorB);
						const double fEdgeLengthB(basegfx::B3DVector(aEndB - aStartB).getLength());
						fPolygonPosB += fEdgeLengthB;
						const double fRelTexBR(fPolygonPosB * fTexHorMultiplicatorB);

						aNew.setTextureCoordinate(0L, basegfx::B2DPoint(fRelTexAL, fTexVerStart));
						aNew.setTextureCoordinate(1L, basegfx::B2DPoint(fRelTexBL, fTexVerStop));
						aNew.setTextureCoordinate(2L, basegfx::B2DPoint(fRelTexBR, fTexVerStop));
						aNew.setTextureCoordinate(3L, basegfx::B2DPoint(fRelTexAR, fTexVerStart));
					}

					rTarget.append(aNew);
				}
			}
		}
	}

	void impSetNormal(
		basegfx::B3DPolyPolygon& rCandidate, 
		const basegfx::B3DVector& rNormal)
	{
		for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
		{
			basegfx::B3DPolygon aSub(rCandidate.getB3DPolygon(a));

			for(sal_uInt32 b(0L); b < aSub.count(); b++)
			{
				aSub.setNormal(b, rNormal);
			}

			rCandidate.setB3DPolygon(a, aSub);
		}
	}

	void impCreateInBetweenNormals(
		basegfx::B3DPolyPolygon& rPolA, 
		basegfx::B3DPolyPolygon& rPolB, 
		bool bSmoothHorizontalNormals)
	{
		OSL_ENSURE(rPolA.count() == rPolB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
		const sal_uInt32 nPolygonCount(::std::min(rPolA.count(), rPolB.count()));

		for(sal_uInt32 a(0L); a < nPolygonCount; a++)
		{
			basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
			basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
			OSL_ENSURE(aSubA.count() == aSubB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
			const sal_uInt32 nPointCount(::std::min(aSubA.count(), aSubB.count()));

			if(nPointCount)
			{
				basegfx::B3DPoint aPrevA(aSubA.getB3DPoint(nPointCount - 1L));
				basegfx::B3DPoint aCurrA(aSubA.getB3DPoint(0L));
				const bool bClosed(aSubA.isClosed());

				for(sal_uInt32 b(0L); b < nPointCount; b++)
				{
					const sal_uInt32 nIndNext((b + 1L) % nPointCount);
					const basegfx::B3DPoint aNextA(aSubA.getB3DPoint(nIndNext));
					const basegfx::B3DPoint aCurrB(aSubB.getB3DPoint(b));

					// vector to back
					basegfx::B3DVector aDepth(aCurrB - aCurrA);
					aDepth.normalize();

					if(aDepth.equalZero())
					{
						// no difference, try to get depth from next point
						const basegfx::B3DPoint aNextB(aSubB.getB3DPoint(nIndNext));
						aDepth = aNextB - aNextA;
						aDepth.normalize();
					}

					// vector to left (correct for non-closed lines)
					const bool bFirstAndNotClosed(!bClosed && 0L == b);
					basegfx::B3DVector aLeft(bFirstAndNotClosed ? aCurrA - aNextA : aPrevA - aCurrA);
					aLeft.normalize();

					// create left normal
					const basegfx::B3DVector aNormalLeft(aDepth.getPerpendicular(aLeft));

					if(bSmoothHorizontalNormals)
					{
						// vector to right (correct for non-closed lines)
						const bool bLastAndNotClosed(!bClosed && b + 1L == nPointCount);
						basegfx::B3DVector aRight(bLastAndNotClosed ? aCurrA - aPrevA : aNextA - aCurrA);
						aRight.normalize();

						// create right normal
						const basegfx::B3DVector aNormalRight(aRight.getPerpendicular(aDepth));

						// create smoothed in-between normal
						basegfx::B3DVector aNewNormal(aNormalLeft + aNormalRight);
						aNewNormal.normalize();

						// set as new normal at polygons
						aSubA.setNormal(b, aNewNormal);
						aSubB.setNormal(b, aNewNormal);
					}
					else
					{
						// set aNormalLeft as new normal at polygons
						aSubA.setNormal(b, aNormalLeft);
						aSubB.setNormal(b, aNormalLeft);
					}

					// prepare next step
					aPrevA = aCurrA;
					aCurrA = aNextA;
				}

				rPolA.setB3DPolygon(a, aSubA);
				rPolB.setB3DPolygon(a, aSubB);
			}
		}
	}

	void impMixNormals(
		basegfx::B3DPolyPolygon& rPolA, 
		const basegfx::B3DPolyPolygon& rPolB, 
		double fWeightA)
	{
		const double fWeightB(1.0 - fWeightA);
		OSL_ENSURE(rPolA.count() == rPolB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
		const sal_uInt32 nPolygonCount(::std::min(rPolA.count(), rPolB.count()));

		for(sal_uInt32 a(0L); a < nPolygonCount; a++)
		{
			basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
			const basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
			OSL_ENSURE(aSubA.count() == aSubB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
			const sal_uInt32 nPointCount(::std::min(aSubA.count(), aSubB.count()));

			for(sal_uInt32 b(0L); b < nPointCount; b++)
			{
				const basegfx::B3DVector aVA(aSubA.getNormal(b) * fWeightA);
				const basegfx::B3DVector aVB(aSubB.getNormal(b) * fWeightB);
				basegfx::B3DVector aVNew(aVA + aVB);
				aVNew.normalize();
				aSubA.setNormal(b, aVNew);
			}

			rPolA.setB3DPolygon(a, aSubA);
		}
	}

	bool impHasCutWith(const basegfx::B2DPolygon& rPoly, const basegfx::B2DPoint& rStart, const basegfx::B2DPoint& rEnd)
    {
        // polygon is closed, one of the points is a member
        const sal_uInt32 nPointCount(rPoly.count());

        if(nPointCount)
        {
            basegfx::B2DPoint aCurrent(rPoly.getB2DPoint(0));
            const basegfx::B2DVector aVector(rEnd - rStart);

            for(sal_uInt32 a(0); a < nPointCount; a++)
            {
                const sal_uInt32 nNextIndex((a + 1) % nPointCount);
                const basegfx::B2DPoint aNext(rPoly.getB2DPoint(nNextIndex));
                const basegfx::B2DVector aEdgeVector(aNext - aCurrent);

                if(basegfx::tools::findCut(
                    rStart, aVector,
                    aCurrent, aEdgeVector))
                {
                    return true;
                }

                aCurrent = aNext;
            }
        }

        return false;
    }
} // end of anonymous namespace

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

namespace drawinglayer
{
	namespace primitive3d
	{
		void createLatheSlices(
			Slice3DVector& rSliceVector, 
			const basegfx::B2DPolyPolygon& rSource, 
			double fBackScale, 
			double fDiagonal, 
			double fRotation, 
			sal_uInt32 nSteps, 
			bool bCharacterMode, 
			bool bCloseFront, 
			bool bCloseBack)
		{
			if(basegfx::fTools::equalZero(fRotation) || 0L == nSteps)
			{
				// no rotation or no steps, just one plane
				rSliceVector.push_back(Slice3D(rSource, basegfx::B3DHomMatrix()));
			}
			else
			{
				const bool bBackScale(!basegfx::fTools::equal(fBackScale, 1.0));
				const bool bClosedRotation(!bBackScale && basegfx::fTools::equal(fRotation, F_2PI));
				basegfx::B2DPolyPolygon aFront(rSource);
				basegfx::B2DPolyPolygon aBack(rSource);
				basegfx::B3DHomMatrix aTransformBack;
				basegfx::B2DPolyPolygon aOuterBack;

				if(bClosedRotation)
				{
					bCloseFront = bCloseBack = false;
				}

				if(bBackScale)
				{
					// avoid null zoom
					if(basegfx::fTools::equalZero(fBackScale))
					{
						fBackScale = 0.000001;
					}

					// back is scaled compared to front, create scaled version
					aBack = impScalePolyPolygonOnCenter(aBack, fBackScale);
				}

				if(bCloseFront || bCloseBack)
				{
					const basegfx::B2DRange aBaseRange(basegfx::tools::getRange(aFront));
					const double fOuterLength(aBaseRange.getMaxX() * fRotation);
					const double fInnerLength(aBaseRange.getMinX() * fRotation);
					const double fAverageLength((fOuterLength + fInnerLength) * 0.5);

					if(bCloseFront)
					{
						const double fOffsetLen((fAverageLength / 12.0) * fDiagonal);
						basegfx::B2DPolyPolygon aOuterFront;
						impGetOuterPolyPolygon(aFront, aOuterFront, fOffsetLen, bCharacterMode);
						basegfx::B3DHomMatrix aTransform;
						aTransform.translate(0.0, 0.0, fOffsetLen);
						rSliceVector.push_back(Slice3D(aOuterFront, aTransform, SLICETYPE3D_FRONTCAP));
					}

					if(bCloseBack)
					{
						const double fOffsetLen((fAverageLength / 12.0) * fDiagonal);
						impGetOuterPolyPolygon(aBack, aOuterBack, fOffsetLen, bCharacterMode);
						aTransformBack.translate(0.0, 0.0, -fOffsetLen);
						aTransformBack.rotate(0.0, fRotation, 0.0);
					}
				}

				// add start polygon (a = 0L)
				if(!bClosedRotation)
				{
					rSliceVector.push_back(Slice3D(aFront, basegfx::B3DHomMatrix()));
				}

				// create segments (a + 1 .. nSteps)
				const double fStepSize(1.0 / (double)nSteps);

				for(sal_uInt32 a(0L); a < nSteps; a++)
				{
					const double fStep((double)(a + 1L) * fStepSize);
					basegfx::B2DPolyPolygon aNewPoly(bBackScale ? basegfx::tools::interpolate(aFront, aBack, fStep) : aFront);
					basegfx::B3DHomMatrix aNewMat;
					aNewMat.rotate(0.0, fRotation * fStep, 0.0);
					rSliceVector.push_back(Slice3D(aNewPoly, aNewMat));
				}

				if(bCloseBack)
				{
					rSliceVector.push_back(Slice3D(aOuterBack, aTransformBack, SLICETYPE3D_BACKCAP));
				}
			}
		}

		void createExtrudeSlices(
			Slice3DVector& rSliceVector, 
			const basegfx::B2DPolyPolygon& rSource, 
			double fBackScale, 
			double fDiagonal, 
			double fDepth, 
			bool bCharacterMode, 
			bool bCloseFront, 
			bool bCloseBack)
		{
			if(basegfx::fTools::equalZero(fDepth))
			{
				// no depth, just one plane
				rSliceVector.push_back(Slice3D(rSource, basegfx::B3DHomMatrix()));
			}
			else
			{
				// there is depth, create Polygons for front,back and their default depth positions
				basegfx::B2DPolyPolygon aFront(rSource);
				basegfx::B2DPolyPolygon aBack(rSource);
				const bool bBackScale(!basegfx::fTools::equal(fBackScale, 1.0));
				double fZFront(fDepth); // default depth for aFront
				double fZBack(0.0); // default depth for aBack
				basegfx::B2DPolyPolygon aOuterBack;

				if(bBackScale)
				{
					// avoid null zoom
					if(basegfx::fTools::equalZero(fBackScale))
					{
						fBackScale = 0.000001;
					}

					// aFront is scaled compared to aBack, create scaled version
					aFront = impScalePolyPolygonOnCenter(aFront, fBackScale);
				}

				if(bCloseFront)
				{
					const double fOffset(fDepth * fDiagonal * 0.5);
					fZFront = fDepth - fOffset;
					basegfx::B2DPolyPolygon aOuterFront;
					impGetOuterPolyPolygon(aFront, aOuterFront, fOffset, bCharacterMode);
					basegfx::B3DHomMatrix aTransformFront;
					aTransformFront.translate(0.0, 0.0, fDepth);
					rSliceVector.push_back(Slice3D(aOuterFront, aTransformFront, SLICETYPE3D_FRONTCAP));
				}
				
				if(bCloseBack)
				{
					const double fOffset(fDepth * fDiagonal * 0.5);
					fZBack = fOffset;
					impGetOuterPolyPolygon(aBack, aOuterBack, fOffset, bCharacterMode);
				}

				// add front and back polygons at evtl. changed depths
				{
					basegfx::B3DHomMatrix aTransformA, aTransformB;

					aTransformA.translate(0.0, 0.0, fZFront);
					rSliceVector.push_back(Slice3D(aFront, aTransformA));

					aTransformB.translate(0.0, 0.0, fZBack);
					rSliceVector.push_back(Slice3D(aBack, aTransformB));
				}

				if(bCloseBack)
				{
					rSliceVector.push_back(Slice3D(aOuterBack, basegfx::B3DHomMatrix(), SLICETYPE3D_BACKCAP));
				}
			}
		}

		basegfx::B3DPolyPolygon extractHorizontalLinesFromSlice(const Slice3DVector& rSliceVector, bool bCloseHorLines)
		{
			basegfx::B3DPolyPolygon aRetval;
			const sal_uInt32 nNumSlices(rSliceVector.size());
			
			if(nNumSlices)
			{
				const sal_uInt32 nSlideSubPolygonCount(rSliceVector[0].getB3DPolyPolygon().count());

				for(sal_uInt32 b(0); b < nSlideSubPolygonCount; b++)
				{
					const sal_uInt32 nSubPolygonPointCount(rSliceVector[0].getB3DPolyPolygon().getB3DPolygon(b).count());

					for(sal_uInt32 c(0); c < nSubPolygonPointCount; c++)
					{
						basegfx::B3DPolygon aNew;
						
						for(sal_uInt32 d(0); d < nNumSlices; d++)
						{
                            const bool bSamePolygonCount(nSlideSubPolygonCount == rSliceVector[d].getB3DPolyPolygon().count());
                            const bool bSamePointCount(nSubPolygonPointCount == rSliceVector[d].getB3DPolyPolygon().getB3DPolygon(b).count());

                            if(bSamePolygonCount && bSamePointCount)
                            {
                                aNew.append(rSliceVector[d].getB3DPolyPolygon().getB3DPolygon(b).getB3DPoint(c));
                            }
                            else
                            {
                                OSL_ENSURE(bSamePolygonCount, "Slice PolyPolygon with different Polygon count (!)");
                                OSL_ENSURE(bSamePointCount, "Slice Polygon with different point count (!)");
                            }
                        }

						aNew.setClosed(bCloseHorLines);
						aRetval.append(aNew);
					}
				}
			}

			return aRetval;
		}

		basegfx::B3DPolyPolygon  extractVerticalLinesFromSlice(const Slice3DVector& rSliceVector)
		{
			basegfx::B3DPolyPolygon aRetval;
			const sal_uInt32 nNumSlices(rSliceVector.size());
			
		    for(sal_uInt32 a(0L); a < nNumSlices; a++)
		    {
			    aRetval.append(rSliceVector[a].getB3DPolyPolygon());
		    }

			return aRetval;
		}

		void extractPlanesFromSlice(
			::std::vector< basegfx::B3DPolyPolygon >& rFill, 
			const Slice3DVector& rSliceVector,
			bool bCreateNormals, 
			bool bSmoothHorizontalNormals, 
			bool bSmoothNormals, 
			bool bSmoothLids, 
			bool bClosed,
			double fSmoothNormalsMix, 
			double fSmoothLidsMix, 
			bool bCreateTextureCoordinates, 
			const basegfx::B2DHomMatrix& rTexTransform)
		{
			const sal_uInt32 nNumSlices(rSliceVector.size());
			
			if(nNumSlices)
			{
				// common parameters
				const sal_uInt32 nLoopCount(bClosed ? nNumSlices : nNumSlices - 1L);
				basegfx::B3DPolyPolygon aEdgeRounding;
				sal_uInt32 a;

				// tetxture parameters
				double fInvTexHeight(1.0);
				double fTexHeightPos(0.0);
				double fTexStart(0.0);
				double fTexStop(1.0);
				::std::vector<double> aTexHeightArray;
				basegfx::B3DRange aTexRangeFront;
				basegfx::B3DRange aTexRangeBack;

				if(bCreateTextureCoordinates)
				{
					aTexRangeFront = basegfx::tools::getRange(rSliceVector[0L].getB3DPolyPolygon());
					aTexRangeBack = basegfx::tools::getRange(rSliceVector[nNumSlices - 1L].getB3DPolyPolygon());

					if(aTexRangeBack.getDepth() > aTexRangeBack.getWidth())
					{
						// last polygon is rotated so that depth is bigger than width, exchange X and Z
						// for making applyDefaultTextureCoordinatesParallel use Z instead of X for
						// horizontal texture coordinate
						aTexRangeBack = basegfx::B3DRange(
							aTexRangeBack.getMinZ(), aTexRangeBack.getMinY(), aTexRangeBack.getMinX(),
							aTexRangeBack.getMaxZ(), aTexRangeBack.getMaxY(), aTexRangeBack.getMaxX());
					}

					basegfx::B3DPoint aCenter(basegfx::tools::getRange(rSliceVector[0L].getB3DPolyPolygon()).getCenter());

					for(a = 0L; a < nLoopCount; a++)
					{
						const basegfx::B3DPoint aNextCenter(basegfx::tools::getRange(rSliceVector[(a + 1L) % nNumSlices].getB3DPolyPolygon()).getCenter());
						const double fLength(basegfx::B3DVector(aNextCenter - aCenter).getLength());
						aTexHeightArray.push_back(fLength);
						aCenter = aNextCenter;
					}

					const double fTexHeight(::std::accumulate(aTexHeightArray.begin(), aTexHeightArray.end(), 0.0));

					if(!basegfx::fTools::equalZero(fTexHeight))
					{
						fInvTexHeight = 1.0 / fTexHeight;
					}
				}

                if(nLoopCount)
                {
				    for(a = 0L; a < nLoopCount; a++)
				    {
					    const Slice3D& rSliceA(rSliceVector[a]);
					    const Slice3D& rSliceB(rSliceVector[(a + 1L) % nNumSlices]);
					    const bool bAcceptPair(SLICETYPE3D_REGULAR == rSliceA.getSliceType() && SLICETYPE3D_REGULAR == rSliceB.getSliceType());
					    basegfx::B3DPolyPolygon aPolA(rSliceA.getB3DPolyPolygon());
					    basegfx::B3DPolyPolygon aPolB(rSliceB.getB3DPolyPolygon());

					    if(bAcceptPair)
					    {
						    if(bCreateNormals)
						    {
							    impCreateInBetweenNormals(aPolB, aPolA, bSmoothHorizontalNormals);
						    }
    						
						    {
							    const sal_uInt32 nIndPrev((a + nNumSlices - 1L) % nNumSlices);
							    const Slice3D& rSlicePrev(rSliceVector[nIndPrev]);
							    basegfx::B3DPolyPolygon aPrev(rSlicePrev.getB3DPolyPolygon());
							    basegfx::B3DPolyPolygon aPolAA(rSliceA.getB3DPolyPolygon());

							    if(SLICETYPE3D_FRONTCAP == rSlicePrev.getSliceType())
							    {
								    basegfx::B3DPolyPolygon aFront(rSlicePrev.getB3DPolyPolygon());
								    const bool bHasSlant(aPolAA != aPrev);

								    if(bCreateTextureCoordinates)
								    {
									    aFront = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFront, aTexRangeFront);
								    }

								    if(bCreateNormals)
								    {
									    basegfx::B3DVector aNormal(0.0, 0.0, -1.0);

									    if(aFront.count())
									    {
										    aNormal = -aFront.getB3DPolygon(0L).getNormal();
									    }

									    impSetNormal(aFront, aNormal);

									    if(bHasSlant)
									    {
										    impCreateInBetweenNormals(aPolAA, aPrev, bSmoothHorizontalNormals);

										    if(bSmoothNormals)
										    {
											    // smooth and copy
											    impMixNormals(aPolA, aPolAA, fSmoothNormalsMix);
											    aPolAA = aPolA;
										    }
										    else
										    {
											    // take over from surface
											    aPolAA = aPolA;
										    }

										    if(bSmoothLids)
										    {
											    // smooth and copy
											    impMixNormals(aFront, aPrev, fSmoothLidsMix);
											    aPrev = aFront;
										    }
										    else
										    {
											    // take over from front
											    aPrev = aFront;
										    }
									    }
									    else
									    {
										    if(bSmoothNormals)
										    {
											    // smooth
											    impMixNormals(aPolA, aFront, fSmoothNormalsMix);
										    }

										    if(bSmoothLids)
										    {
											    // smooth and copy
											    impMixNormals(aFront, aPolA, fSmoothLidsMix);
											    aPolA = aFront;
										    }
									    }
								    }
    	
								    if(bHasSlant)
								    {
									    if(bCreateTextureCoordinates)
									    {
										    fTexStart = fTexHeightPos * fInvTexHeight;
										    fTexStop = (fTexHeightPos - aTexHeightArray[(a + nLoopCount - 1L) % nLoopCount]) * fInvTexHeight;
									    }

									    impAddInBetweenFill(aEdgeRounding, aPolAA, aPrev, fTexStart, fTexStop, bCreateNormals, bCreateTextureCoordinates);
								    }

								    aFront.flip();
								    rFill.push_back(aFront);
							    }
							    else
							    {
								    if(bCreateNormals && bSmoothNormals && (nIndPrev != a + 1L))
								    {
									    impCreateInBetweenNormals(aPolAA, aPrev, bSmoothHorizontalNormals);
									    impMixNormals(aPolA, aPolAA, 0.5);
								    }
							    }
						    }

						    {
							    const sal_uInt32 nIndNext((a + 2L) % nNumSlices);
							    const Slice3D& rSliceNext(rSliceVector[nIndNext]);
							    basegfx::B3DPolyPolygon aNext(rSliceNext.getB3DPolyPolygon());
							    basegfx::B3DPolyPolygon aPolBB(rSliceB.getB3DPolyPolygon());

							    if(SLICETYPE3D_BACKCAP == rSliceNext.getSliceType())
							    {
								    basegfx::B3DPolyPolygon aBack(rSliceNext.getB3DPolyPolygon());
								    const bool bHasSlant(aPolBB != aNext);

								    if(bCreateTextureCoordinates)
								    {
									    aBack = basegfx::tools::applyDefaultTextureCoordinatesParallel(aBack, aTexRangeBack);
								    }

								    if(bCreateNormals)
								    {
									    const basegfx::B3DVector aNormal(aBack.count() ? aBack.getB3DPolygon(0L).getNormal() : basegfx::B3DVector(0.0, 0.0, 1.0));
									    impSetNormal(aBack, aNormal);

									    if(bHasSlant)
									    {
										    impCreateInBetweenNormals(aNext, aPolBB, bSmoothHorizontalNormals);

										    if(bSmoothNormals)
										    {
											    // smooth and copy
											    impMixNormals(aPolB, aPolBB, fSmoothNormalsMix);
											    aPolBB = aPolB;
										    }
										    else
										    {
											    // take over from surface
											    aPolBB = aPolB;
										    }

										    if(bSmoothLids)
										    {
											    // smooth and copy
											    impMixNormals(aBack, aNext, fSmoothLidsMix);
											    aNext = aBack;
										    }
										    else
										    {
											    // take over from back
											    aNext = aBack;
										    }
									    }
									    else
									    {
										    if(bSmoothNormals)
										    {
											    // smooth
											    impMixNormals(aPolB, aBack, fSmoothNormalsMix);
										    }

										    if(bSmoothLids)
										    {
											    // smooth and copy
											    impMixNormals(aBack, aPolB, fSmoothLidsMix);
											    aPolB = aBack;
										    }
									    }
								    }

								    if(bHasSlant)
								    {
									    if(bCreateTextureCoordinates)
									    {
										    fTexStart = (fTexHeightPos + aTexHeightArray[a] + aTexHeightArray[(a + 1L) % nLoopCount]) * fInvTexHeight;
										    fTexStop = (fTexHeightPos + aTexHeightArray[a]) * fInvTexHeight;
									    }

									    impAddInBetweenFill(aEdgeRounding, aNext, aPolBB, fTexStart, fTexStop, bCreateNormals, bCreateTextureCoordinates);
								    }

								    rFill.push_back(aBack);
							    }
							    else
							    {
								    if(bCreateNormals && bSmoothNormals && (nIndNext != a))
								    {
									    impCreateInBetweenNormals(aNext, aPolBB, bSmoothHorizontalNormals);
									    impMixNormals(aPolB, aPolBB, 0.5);
								    }
							    }
						    }

						    if(bCreateTextureCoordinates)
						    {
							    fTexStart = (fTexHeightPos + aTexHeightArray[a]) * fInvTexHeight;
							    fTexStop = fTexHeightPos * fInvTexHeight;
						    }

						    impAddInBetweenFill(aEdgeRounding, aPolB, aPolA, fTexStart, fTexStop, bCreateNormals, bCreateTextureCoordinates);
					    }

					    if(bCreateTextureCoordinates)
					    {
						    fTexHeightPos += aTexHeightArray[a];
					    }
				    }
                }
                else
                {
                    // no loop, but a single slice (1 == nNumSlices), create a filling from the single
                    // front plane
				    const Slice3D& rSlice(rSliceVector[0]);
                    basegfx::B3DPolyPolygon aFront(rSlice.getB3DPolyPolygon());

				    if(bCreateTextureCoordinates)
				    {
					    aFront = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFront, aTexRangeFront);
				    }

				    if(bCreateNormals)
				    {
					    basegfx::B3DVector aNormal(0.0, 0.0, -1.0);

					    if(aFront.count())
					    {
						    aNormal = -aFront.getB3DPolygon(0L).getNormal();
					    }

					    impSetNormal(aFront, aNormal);
				    }

				    aFront.flip();
				    rFill.push_back(aFront);
                }

				if(bCreateTextureCoordinates)
				{
					aEdgeRounding.transformTextureCoordiantes(rTexTransform);
				}

				for(a = 0L; a < aEdgeRounding.count(); a++)
				{
					rFill.push_back(basegfx::B3DPolyPolygon(aEdgeRounding.getB3DPolygon(a)));
				}
			}
		}

		void createReducedOutlines(
			const geometry::ViewInformation3D& rViewInformation, 
			const basegfx::B3DHomMatrix& rObjectTransform,
			const basegfx::B3DPolygon& rLoopA, 
			const basegfx::B3DPolygon& rLoopB, 
			basegfx::B3DPolyPolygon& rTarget)
		{
			const sal_uInt32 nPointCount(rLoopA.count());
	
			// with idetic polygons there are no outlines
			if(rLoopA != rLoopB)
			{
				if(nPointCount && nPointCount == rLoopB.count())
				{
					const basegfx::B3DHomMatrix aObjectTransform(rViewInformation.getObjectToView() * rObjectTransform);
					const basegfx::B2DPolygon a2DLoopA(basegfx::tools::createB2DPolygonFromB3DPolygon(rLoopA, aObjectTransform));
					const basegfx::B2DPolygon a2DLoopB(basegfx::tools::createB2DPolygonFromB3DPolygon(rLoopB, aObjectTransform));
					const basegfx::B2DPoint a2DCenterA(a2DLoopA.getB2DRange().getCenter());
					const basegfx::B2DPoint a2DCenterB(a2DLoopB.getB2DRange().getCenter());

					// without detectable Y-Axis there are no outlines
					if(!a2DCenterA.equal(a2DCenterB))
					{
						// search for outmost left and right inter-loop-edges which do not cut the loops
						const basegfx::B2DPoint aCommonCenter(basegfx::average(a2DCenterA, a2DCenterB));
						const basegfx::B2DVector aAxisVector(a2DCenterA - a2DCenterB);
						double fMaxLeft(0.0);
						double fMaxRight(0.0);
						sal_uInt32 nIndexLeft(0);
						sal_uInt32 nIndexRight(0);

						for(sal_uInt32 a(0); a < nPointCount; a++)
						{
							const basegfx::B2DPoint aStart(a2DLoopA.getB2DPoint(a));
							const basegfx::B2DPoint aEnd(a2DLoopB.getB2DPoint(a));
							const basegfx::B2DPoint aMiddle(basegfx::average(aStart, aEnd));

							if(!basegfx::tools::isInside(a2DLoopA, aMiddle))
							{
								if(!basegfx::tools::isInside(a2DLoopB, aMiddle))
								{
									if(!impHasCutWith(a2DLoopA, aStart, aEnd))
									{
										if(!impHasCutWith(a2DLoopB, aStart, aEnd))
										{
											const basegfx::B2DVector aCandidateVector(aMiddle - aCommonCenter);
											const double fCross(aCandidateVector.cross(aAxisVector));
											const double fDistance(aCandidateVector.getLength());

											if(fCross > 0.0)
											{
												if(fDistance > fMaxLeft)
												{
													fMaxLeft = fDistance;
													nIndexLeft = a;
												}
											}
											else if(fCross < 0.0)
											{
												if(fDistance > fMaxRight)
												{
													fMaxRight = fDistance;
													nIndexRight = a;
												}
											}
										}
									}
								}
							}
						}

						if(fMaxLeft != 0.0)
						{
							basegfx::B3DPolygon aToBeAdded;
							aToBeAdded.append(rLoopA.getB3DPoint(nIndexLeft));
							aToBeAdded.append(rLoopB.getB3DPoint(nIndexLeft));
							rTarget.append(aToBeAdded);
						}
						
						if(fMaxRight != 0.0)
						{
							basegfx::B3DPolygon aToBeAdded;
							aToBeAdded.append(rLoopA.getB3DPoint(nIndexRight));
							aToBeAdded.append(rLoopB.getB3DPoint(nIndexRight));
							rTarget.append(aToBeAdded);
						}
					}
				}
			}
		}

	} // end of namespace primitive3d
} // end of namespace drawinglayer

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