xref: /aoo42x/main/drawinglayer/source/processor3d/zbufferprocessor3d.cxx (revision 464702f4)

/**************************************************************
 *
 * 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/processor3d/zbufferprocessor3d.hxx>
#include <basegfx/raster/bpixelraster.hxx>
#include <vcl/bmpacc.hxx>
#include <basegfx/raster/rasterconvert3d.hxx>
#include <basegfx/raster/bzpixelraster.hxx>
#include <drawinglayer/attribute/materialattribute3d.hxx>
#include <drawinglayer/texture/texture.hxx>
#include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
#include <drawinglayer/primitive3d/textureprimitive3d.hxx>
#include <drawinglayer/primitive3d/polygonprimitive3d.hxx>
#include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
#include <drawinglayer/geometry/viewinformation2d.hxx>
#include <basegfx/polygon/b3dpolygontools.hxx>
#include <basegfx/polygon/b3dpolypolygontools.hxx>
#include <drawinglayer/attribute/sdrlightingattribute3d.hxx>

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

using namespace com::sun::star;

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

namespace
{
	BitmapEx BPixelRasterToBitmapEx(const basegfx::BPixelRaster& rRaster, sal_uInt16 mnAntiAlialize)
	{
		BitmapEx aRetval;
		const sal_uInt32 nWidth(mnAntiAlialize ? rRaster.getWidth()/mnAntiAlialize : rRaster.getWidth());
		const sal_uInt32 nHeight(mnAntiAlialize ? rRaster.getHeight()/mnAntiAlialize : rRaster.getHeight());

		if(nWidth && nHeight)
		{
			const Size aDestSize(nWidth, nHeight);
			sal_uInt8 nInitAlpha(255);
			Bitmap aContent(aDestSize, 24);
			AlphaMask aAlpha(aDestSize, &nInitAlpha);
			BitmapWriteAccess* pContent = aContent.AcquireWriteAccess();
			BitmapWriteAccess* pAlpha = aAlpha.AcquireWriteAccess();

			if(pContent && pAlpha)
			{
				if(mnAntiAlialize)
				{
					const sal_uInt16 nDivisor(mnAntiAlialize * mnAntiAlialize);

					for(sal_uInt32 y(0L); y < nHeight; y++)
					{
						for(sal_uInt32 x(0L); x < nWidth; x++)
						{
							sal_uInt16 nRed(0);
							sal_uInt16 nGreen(0);
							sal_uInt16 nBlue(0);
							sal_uInt16 nOpacity(0);
							sal_uInt32 nIndex(rRaster.getIndexFromXY(x * mnAntiAlialize, y * mnAntiAlialize));

							for(sal_uInt32 c(0); c < mnAntiAlialize; c++)
							{
								for(sal_uInt32 d(0); d < mnAntiAlialize; d++)
								{
									const basegfx::BPixel& rPixel(rRaster.getBPixel(nIndex++));
									nRed = nRed + rPixel.getRed();
									nGreen = nGreen + rPixel.getGreen();
									nBlue = nBlue + rPixel.getBlue();
									nOpacity = nOpacity + rPixel.getOpacity();
								}

								nIndex += rRaster.getWidth() - mnAntiAlialize;
							}

							nOpacity = nOpacity / nDivisor;

							if(nOpacity)
							{
								pContent->SetPixel(y, x, BitmapColor(
									(sal_uInt8)(nRed / nDivisor),
									(sal_uInt8)(nGreen / nDivisor),
									(sal_uInt8)(nBlue / nDivisor)));
								pAlpha->SetPixel(y, x, BitmapColor(255 - (sal_uInt8)nOpacity));
							}
						}
					}
				}
				else
				{
					sal_uInt32 nIndex(0L);

					for(sal_uInt32 y(0L); y < nHeight; y++)
					{
						for(sal_uInt32 x(0L); x < nWidth; x++)
						{
							const basegfx::BPixel& rPixel(rRaster.getBPixel(nIndex++));

							if(rPixel.getOpacity())
							{
								pContent->SetPixel(y, x, BitmapColor(rPixel.getRed(), rPixel.getGreen(), rPixel.getBlue()));
								pAlpha->SetPixel(y, x, BitmapColor(255 - rPixel.getOpacity()));
							}
						}
					}
				}

				delete pContent;
				delete pAlpha;
			}

			aRetval = BitmapEx(aContent, aAlpha);

			// #i101811# set PrefMapMode and PrefSize at newly created Bitmap
			aRetval.SetPrefMapMode(MAP_100TH_MM);
			aRetval.SetPrefSize(Size(nWidth, nHeight));
		}

		return aRetval;
	}
} // end of anonymous namespace

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

class ZBufferRasterConverter3D : public basegfx::RasterConverter3D
{
private:
    const drawinglayer::processor3d::DefaultProcessor3D&	mrProcessor;
    basegfx::BZPixelRaster&								    mrBuffer;

    // interpolators for a single line span
    basegfx::ip_single										maIntZ;
    basegfx::ip_triple										maIntColor;
    basegfx::ip_triple										maIntNormal;
    basegfx::ip_double										maIntTexture;
    basegfx::ip_triple										maIntInvTexture;

    // current material to use for ratsreconversion
    const drawinglayer::attribute::MaterialAttribute3D*     mpCurrentMaterial;

    // bitfield
    // some boolean flags for line span interpolator usages
    unsigned												mbModifyColor : 1;
    unsigned												mbUseTex : 1;
    unsigned												mbHasTexCoor : 1;
    unsigned												mbHasInvTexCoor : 1;
    unsigned												mbUseNrm : 1;
    unsigned												mbUseCol : 1;

    void getTextureCoor(basegfx::B2DPoint& rTarget) const
    {
	    if(mbHasTexCoor)
	    {
		    rTarget.setX(maIntTexture.getX().getVal());
		    rTarget.setY(maIntTexture.getY().getVal());
	    }
	    else if(mbHasInvTexCoor)
	    {
		    const double fZFactor(maIntInvTexture.getZ().getVal());
            const double fInvZFactor(basegfx::fTools::equalZero(fZFactor) ? 1.0 : 1.0 / fZFactor);
		    rTarget.setX(maIntInvTexture.getX().getVal() * fInvZFactor);
		    rTarget.setY(maIntInvTexture.getY().getVal() * fInvZFactor);
	    }
    }

    void incrementLineSpanInterpolators(double fStep)
    {
	    maIntZ.increment(fStep);

	    if(mbUseTex)
	    {
		    if(mbHasTexCoor)
		    {
			    maIntTexture.increment(fStep);
		    }
		    else if(mbHasInvTexCoor)
		    {
			    maIntInvTexture.increment(fStep);
		    }
	    }

	    if(mbUseNrm)
	    {
		    maIntNormal.increment(fStep);
	    }

	    if(mbUseCol)
	    {
		    maIntColor.increment(fStep);
	    }
    }

    double decideColorAndOpacity(basegfx::BColor& rColor)
    {
        // init values with full opacity and material color
        OSL_ENSURE(0 != mpCurrentMaterial, "CurrentMaterial not set (!)");
        double fOpacity(1.0);
        rColor = mpCurrentMaterial->getColor();

        if(mbUseTex)
        {
            basegfx::B2DPoint aTexCoor(0.0, 0.0);
	        getTextureCoor(aTexCoor);

	        if(mrProcessor.getGeoTexSvx().get())
	        {
		        // calc color in spot. This may also set to invisible already when
		        // e.g. bitmap textures have transparent parts
		        mrProcessor.getGeoTexSvx()->modifyBColor(aTexCoor, rColor, fOpacity);
	        }

	        if(basegfx::fTools::more(fOpacity, 0.0) && mrProcessor.getTransparenceGeoTexSvx().get())
	        {
		        // calc opacity. Object has a 2nd texture, a transparence texture
		        mrProcessor.getTransparenceGeoTexSvx()->modifyOpacity(aTexCoor, fOpacity);
	        }
        }

        if(basegfx::fTools::more(fOpacity, 0.0))
        {
	        if(mrProcessor.getGeoTexSvx().get())
	        {
		        if(mbUseNrm)
		        {
			        // blend texture with phong
			        rColor = mrProcessor.getSdrLightingAttribute().solveColorModel(
				        basegfx::B3DVector(maIntNormal.getX().getVal(), maIntNormal.getY().getVal(), maIntNormal.getZ().getVal()),
				        rColor,
				        mpCurrentMaterial->getSpecular(),
				        mpCurrentMaterial->getEmission(),
				        mpCurrentMaterial->getSpecularIntensity());
		        }
		        else if(mbUseCol)
		        {
			        // blend texture with gouraud
			        basegfx::BColor aBlendColor(maIntColor.getX().getVal(), maIntColor.getY().getVal(), maIntColor.getZ().getVal());
			        rColor *= aBlendColor;
		        }
		        else if(mrProcessor.getModulate())
		        {
			        // blend texture with single material color
			        rColor *= mpCurrentMaterial->getColor();
		        }
	        }
	        else
	        {
		        if(mbUseNrm)
		        {
			        // modify color with phong
			        rColor = mrProcessor.getSdrLightingAttribute().solveColorModel(
				        basegfx::B3DVector(maIntNormal.getX().getVal(), maIntNormal.getY().getVal(), maIntNormal.getZ().getVal()),
				        rColor,
				        mpCurrentMaterial->getSpecular(),
				        mpCurrentMaterial->getEmission(),
				        mpCurrentMaterial->getSpecularIntensity());
		        }
		        else if(mbUseCol)
		        {
			        // modify color with gouraud
			        rColor.setRed(maIntColor.getX().getVal());
			        rColor.setGreen(maIntColor.getY().getVal());
			        rColor.setBlue(maIntColor.getZ().getVal());
		        }
	        }

	        if(mbModifyColor)
	        {
		        rColor = mrProcessor.getBColorModifierStack().getModifiedColor(rColor);
	        }
        }

        return fOpacity;
    }

    void setupLineSpanInterpolators(const basegfx::RasterConversionLineEntry3D& rA, const basegfx::RasterConversionLineEntry3D& rB)
    {
        // get inverse XDelta
        const double xInvDelta(1.0 / (rB.getX().getVal() - rA.getX().getVal()));

        // prepare Z-interpolator
        const double fZA(rA.getZ().getVal());
        const double fZB(rB.getZ().getVal());
        maIntZ = basegfx::ip_single(fZA, (fZB - fZA) * xInvDelta);

        // get bools and init other interpolators on demand accordingly
        mbModifyColor = mrProcessor.getBColorModifierStack().count();
        mbHasTexCoor = SCANLINE_EMPTY_INDEX != rA.getTextureIndex() && SCANLINE_EMPTY_INDEX != rB.getTextureIndex();
        mbHasInvTexCoor = SCANLINE_EMPTY_INDEX != rA.getInverseTextureIndex() && SCANLINE_EMPTY_INDEX != rB.getInverseTextureIndex();
        const bool bTextureActive(mrProcessor.getGeoTexSvx().get() || mrProcessor.getTransparenceGeoTexSvx().get());
        mbUseTex = bTextureActive && (mbHasTexCoor || mbHasInvTexCoor || mrProcessor.getSimpleTextureActive());
        const bool bUseColorTex(mbUseTex && mrProcessor.getGeoTexSvx().get());
        const bool bNeedNrmOrCol(!bUseColorTex || (bUseColorTex && mrProcessor.getModulate()));
        mbUseNrm = bNeedNrmOrCol && SCANLINE_EMPTY_INDEX != rA.getNormalIndex() && SCANLINE_EMPTY_INDEX != rB.getNormalIndex();
        mbUseCol = !mbUseNrm && bNeedNrmOrCol && SCANLINE_EMPTY_INDEX != rA.getColorIndex() && SCANLINE_EMPTY_INDEX != rB.getColorIndex();

        if(mbUseTex)
        {
	        if(mbHasTexCoor)
	        {
                const basegfx::ip_double& rTA(getTextureInterpolators()[rA.getTextureIndex()]);
		        const basegfx::ip_double& rTB(getTextureInterpolators()[rB.getTextureIndex()]);
		        maIntTexture = basegfx::ip_double(
			        rTA.getX().getVal(), (rTB.getX().getVal() - rTA.getX().getVal()) * xInvDelta,
			        rTA.getY().getVal(), (rTB.getY().getVal() - rTA.getY().getVal()) * xInvDelta);
	        }
	        else if(mbHasInvTexCoor)
	        {
		        const basegfx::ip_triple& rITA(getInverseTextureInterpolators()[rA.getInverseTextureIndex()]);
		        const basegfx::ip_triple& rITB(getInverseTextureInterpolators()[rB.getInverseTextureIndex()]);
		        maIntInvTexture = basegfx::ip_triple(
			        rITA.getX().getVal(), (rITB.getX().getVal() - rITA.getX().getVal()) * xInvDelta,
			        rITA.getY().getVal(), (rITB.getY().getVal() - rITA.getY().getVal()) * xInvDelta,
			        rITA.getZ().getVal(), (rITB.getZ().getVal() - rITA.getZ().getVal()) * xInvDelta);
	        }
        }

        if(mbUseNrm)
        {
	        const basegfx::ip_triple& rNA(getNormalInterpolators()[rA.getNormalIndex()]);
	        const basegfx::ip_triple& rNB(getNormalInterpolators()[rB.getNormalIndex()]);
	        maIntNormal = basegfx::ip_triple(
		        rNA.getX().getVal(), (rNB.getX().getVal() - rNA.getX().getVal()) * xInvDelta,
		        rNA.getY().getVal(), (rNB.getY().getVal() - rNA.getY().getVal()) * xInvDelta,
		        rNA.getZ().getVal(), (rNB.getZ().getVal() - rNA.getZ().getVal()) * xInvDelta);
        }

        if(mbUseCol)
        {
	        const basegfx::ip_triple& rCA(getColorInterpolators()[rA.getColorIndex()]);
	        const basegfx::ip_triple& rCB(getColorInterpolators()[rB.getColorIndex()]);
	        maIntColor = basegfx::ip_triple(
		        rCA.getX().getVal(), (rCB.getX().getVal() - rCA.getX().getVal()) * xInvDelta,
		        rCA.getY().getVal(), (rCB.getY().getVal() - rCA.getY().getVal()) * xInvDelta,
		        rCA.getZ().getVal(), (rCB.getZ().getVal() - rCA.getZ().getVal()) * xInvDelta);
        }
    }

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

public:
    ZBufferRasterConverter3D(basegfx::BZPixelRaster& rBuffer, const drawinglayer::processor3d::ZBufferProcessor3D& rProcessor)
    :   basegfx::RasterConverter3D(),
        mrProcessor(rProcessor),
        mrBuffer(rBuffer),
	    maIntZ(),
	    maIntColor(),
	    maIntNormal(),
	    maIntTexture(),
	    maIntInvTexture(),
        mpCurrentMaterial(0),
	    mbModifyColor(false),
	    mbUseTex(false),
	    mbHasTexCoor(false),
	    mbUseNrm(false),
	    mbUseCol(false)
    {}

    void setCurrentMaterial(const drawinglayer::attribute::MaterialAttribute3D& rMaterial)
	{
        mpCurrentMaterial = &rMaterial;
    }
};

void ZBufferRasterConverter3D::processLineSpan(const basegfx::RasterConversionLineEntry3D& rA, const basegfx::RasterConversionLineEntry3D& rB, sal_Int32 nLine, sal_uInt32 nSpanCount)
{
    if(!(nSpanCount & 0x0001))
    {
	    if(nLine >= 0 && nLine < (sal_Int32)mrBuffer.getHeight())
	    {
			sal_uInt32 nXA(::std::min(mrBuffer.getWidth(), (sal_uInt32)::std::max((sal_Int32)0, basegfx::fround(rA.getX().getVal()))));
			const sal_uInt32 nXB(::std::min(mrBuffer.getWidth(), (sal_uInt32)::std::max((sal_Int32)0, basegfx::fround(rB.getX().getVal()))));

	        if(nXA < nXB)
	        {
		        // prepare the span interpolators
		        setupLineSpanInterpolators(rA, rB);

		        // bring span interpolators to start condition by incrementing with the possible difference of
		        // clamped and non-clamped XStart. Interpolators are setup relying on double precision
		        // X-values, so that difference is the correct value to compensate for possible clampings
		        incrementLineSpanInterpolators(static_cast<double>(nXA) - rA.getX().getVal());

		        // prepare scanline index
		        sal_uInt32 nScanlineIndex(mrBuffer.getIndexFromXY(nXA, static_cast<sal_uInt32>(nLine)));
                basegfx::BColor aNewColor;

		        while(nXA < nXB)
		        {
			        // early-test Z values if we need to do anything at all
					const double fNewZ(::std::max(0.0, ::std::min((double)0xffff, maIntZ.getVal())));
			        const sal_uInt16 nNewZ(static_cast< sal_uInt16 >(fNewZ));
					sal_uInt16& rOldZ(mrBuffer.getZ(nScanlineIndex));

			        if(nNewZ > rOldZ)
			        {
				        // detect color and opacity for this pixel
						const sal_uInt16 nOpacity(::std::max((sal_Int16)0, static_cast< sal_Int16 >(decideColorAndOpacity(aNewColor) * 255.0)));

						if(nOpacity > 0)
						{
							// avoid color overrun
							aNewColor.clamp();

							if(nOpacity >= 0x00ff)
							{
								// full opacity (not transparent), set z and color
								rOldZ = nNewZ;
								mrBuffer.getBPixel(nScanlineIndex) = basegfx::BPixel(aNewColor, 0xff);
							}
							else
							{
                                basegfx::BPixel& rDest = mrBuffer.getBPixel(nScanlineIndex);

                                if(rDest.getOpacity())
                                {
                                    // mix new color by using
                                    // color' = color * (1 - opacity) + newcolor * opacity
									const sal_uInt16 nTransparence(0x0100 - nOpacity);
									rDest.setRed((sal_uInt8)(((rDest.getRed() * nTransparence) + ((sal_uInt16)(255.0 * aNewColor.getRed()) * nOpacity)) >> 8));
									rDest.setGreen((sal_uInt8)(((rDest.getGreen() * nTransparence) + ((sal_uInt16)(255.0 * aNewColor.getGreen()) * nOpacity)) >> 8));
									rDest.setBlue((sal_uInt8)(((rDest.getBlue() * nTransparence) + ((sal_uInt16)(255.0 * aNewColor.getBlue()) * nOpacity)) >> 8));

                                    if(0xff != rDest.getOpacity())
                                    {
                                        // both are transparent, mix new opacity by using
                                        // opacity = newopacity * (1 - oldopacity) + oldopacity
                                        rDest.setOpacity(((sal_uInt8)((nOpacity * (0x0100 - rDest.getOpacity())) >> 8)) + rDest.getOpacity());
                                    }
                                }
                                else
                                {
									// dest is unused, set color
									rDest = basegfx::BPixel(aNewColor, (sal_uInt8)nOpacity);
                                }
							}
						}
			        }

			        // increments
			        nScanlineIndex++;
			        nXA++;
			        incrementLineSpanInterpolators(1.0);
		        }
	        }
        }
    }
}

//////////////////////////////////////////////////////////////////////////////
// helper class to buffer output for transparent rasterprimitives (filled areas
// and lines) until the end of processing. To ensure correct transparent
// visualisation, ZBuffers require to not set Z and to mix with the transparent
// color. If transparent rasterprimitives overlap, it gets necessary to
// paint transparent rasterprimitives from back to front to ensure that the
// mixing happens from back to front. For that purpose, transparent
// rasterprimitives are held in this class during the processing run, remember
// all data and will be rendered

class RasterPrimitive3D
{
private:
    boost::shared_ptr< drawinglayer::texture::GeoTexSvx >     mpGeoTexSvx;
    boost::shared_ptr< drawinglayer::texture::GeoTexSvx >     mpTransparenceGeoTexSvx;
    drawinglayer::attribute::MaterialAttribute3D              maMaterial;
    basegfx::B3DPolyPolygon                                   maPolyPolygon;
    double                                                    mfCenterZ;

    // bitfield
    bool                                                      mbModulate : 1;
    bool                                                      mbFilter : 1;
    bool                                                      mbSimpleTextureActive : 1;
    bool                                                      mbIsLine : 1;

public:
    RasterPrimitive3D(
        const boost::shared_ptr< drawinglayer::texture::GeoTexSvx >& pGeoTexSvx,
        const boost::shared_ptr< drawinglayer::texture::GeoTexSvx >& pTransparenceGeoTexSvx,
        const drawinglayer::attribute::MaterialAttribute3D& rMaterial,
        const basegfx::B3DPolyPolygon& rPolyPolygon,
        bool bModulate,
        bool bFilter,
        bool bSimpleTextureActive,
        bool bIsLine)
    :   mpGeoTexSvx(pGeoTexSvx),
        mpTransparenceGeoTexSvx(pTransparenceGeoTexSvx),
        maMaterial(rMaterial),
        maPolyPolygon(rPolyPolygon),
        mfCenterZ(basegfx::tools::getRange(rPolyPolygon).getCenter().getZ()),
        mbModulate(bModulate),
        mbFilter(bFilter),
        mbSimpleTextureActive(bSimpleTextureActive),
        mbIsLine(bIsLine)
    {
    }

	RasterPrimitive3D& operator=(const RasterPrimitive3D& rComp)
	{
        mpGeoTexSvx = rComp.mpGeoTexSvx;
        mpTransparenceGeoTexSvx = rComp.mpTransparenceGeoTexSvx;
        maMaterial = rComp.maMaterial;
        maPolyPolygon = rComp.maPolyPolygon;
        mfCenterZ = rComp.mfCenterZ;
        mbModulate = rComp.mbModulate;
        mbFilter = rComp.mbFilter;
        mbSimpleTextureActive = rComp.mbSimpleTextureActive;
        mbIsLine = rComp.mbIsLine;

        return *this;
    }

	bool operator<(const RasterPrimitive3D& rComp) const
	{
        return mfCenterZ < rComp.mfCenterZ;
	}

    const boost::shared_ptr< drawinglayer::texture::GeoTexSvx >& getGeoTexSvx() const { return mpGeoTexSvx; }
    const boost::shared_ptr< drawinglayer::texture::GeoTexSvx >& getTransparenceGeoTexSvx() const { return mpTransparenceGeoTexSvx; }
    const drawinglayer::attribute::MaterialAttribute3D& getMaterial() const { return maMaterial; }
    const basegfx::B3DPolyPolygon& getPolyPolygon() const { return maPolyPolygon; }
    bool getModulate() const { return mbModulate; }
    bool getFilter() const { return mbFilter; }
    bool getSimpleTextureActive() const { return mbSimpleTextureActive; }
    bool getIsLine() const { return mbIsLine; }
};

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

namespace drawinglayer
{
	namespace processor3d
	{
		void ZBufferProcessor3D::rasterconvertB3DPolygon(const attribute::MaterialAttribute3D& rMaterial, const basegfx::B3DPolygon& rHairline) const
		{
			if(mpBZPixelRaster)
			{
                if(getTransparenceCounter())
                {
                    // transparent output; record for later sorting and painting from
                    // back to front
                    if(!mpRasterPrimitive3Ds)
                    {
                        const_cast< ZBufferProcessor3D* >(this)->mpRasterPrimitive3Ds = new std::vector< RasterPrimitive3D >;
                    }

                    mpRasterPrimitive3Ds->push_back(RasterPrimitive3D(
                        getGeoTexSvx(),
                        getTransparenceGeoTexSvx(),
                        rMaterial,
                        basegfx::B3DPolyPolygon(rHairline),
                        getModulate(),
                        getFilter(),
                        getSimpleTextureActive(),
                        true));
                }
                else
                {
                    // do rasterconversion
                    mpZBufferRasterConverter3D->setCurrentMaterial(rMaterial);

				    if(mnAntiAlialize > 1)
				    {
                        const bool bForceLineSnap(getOptionsDrawinglayer().IsAntiAliasing() && getOptionsDrawinglayer().IsSnapHorVerLinesToDiscrete());

					    if(bForceLineSnap)
					    {
						    basegfx::B3DHomMatrix aTransform;
						    basegfx::B3DPolygon aSnappedHairline(rHairline);
						    const double fScaleDown(1.0 / mnAntiAlialize);
						    const double fScaleUp(mnAntiAlialize);

						    // take oversampling out
						    aTransform.scale(fScaleDown, fScaleDown, 1.0);
						    aSnappedHairline.transform(aTransform);

						    // snap to integer
						    aSnappedHairline = basegfx::tools::snapPointsOfHorizontalOrVerticalEdges(aSnappedHairline);

						    // add oversampling again
						    aTransform.identity();
						    aTransform.scale(fScaleUp, fScaleUp, 1.0);

						    if(false)
						    {
							    // when really want to go to single pixel lines, move to center.
							    // Without this translation, all hor/ver hairlines will be centered exactly
							    // between two pixel lines (which looks best)
							    const double fTranslateToCenter(mnAntiAlialize * 0.5);
							    aTransform.translate(fTranslateToCenter, fTranslateToCenter, 0.0);
						    }

						    aSnappedHairline.transform(aTransform);

						    mpZBufferRasterConverter3D->rasterconvertB3DPolygon(aSnappedHairline, 0, mpBZPixelRaster->getHeight(), mnAntiAlialize);
					    }
					    else
					    {
						    mpZBufferRasterConverter3D->rasterconvertB3DPolygon(rHairline, 0, mpBZPixelRaster->getHeight(), mnAntiAlialize);
					    }
				    }
				    else
				    {
					    mpZBufferRasterConverter3D->rasterconvertB3DPolygon(rHairline, 0, mpBZPixelRaster->getHeight(), 1);
				    }
                }
			}
		}

		void ZBufferProcessor3D::rasterconvertB3DPolyPolygon(const attribute::MaterialAttribute3D& rMaterial, const basegfx::B3DPolyPolygon& rFill) const
		{
			if(mpBZPixelRaster)
			{
                if(getTransparenceCounter())
                {
                    // transparent output; record for later sorting and painting from
                    // back to front
                    if(!mpRasterPrimitive3Ds)
                    {
                        const_cast< ZBufferProcessor3D* >(this)->mpRasterPrimitive3Ds = new std::vector< RasterPrimitive3D >;
                    }

                    mpRasterPrimitive3Ds->push_back(RasterPrimitive3D(
                        getGeoTexSvx(),
                        getTransparenceGeoTexSvx(),
                        rMaterial,
                        rFill,
                        getModulate(),
                        getFilter(),
                        getSimpleTextureActive(),
                        false));
                }
                else
                {
                    mpZBufferRasterConverter3D->setCurrentMaterial(rMaterial);
				    mpZBufferRasterConverter3D->rasterconvertB3DPolyPolygon(rFill, &maInvEyeToView, 0, mpBZPixelRaster->getHeight());
                }
			}
		}

		ZBufferProcessor3D::ZBufferProcessor3D(
			const geometry::ViewInformation3D& rViewInformation3D,
			const geometry::ViewInformation2D& rViewInformation2D,
			const attribute::SdrSceneAttribute& rSdrSceneAttribute,
			const attribute::SdrLightingAttribute& rSdrLightingAttribute,
			double fSizeX,
			double fSizeY,
			const basegfx::B2DRange& rVisiblePart,
            sal_uInt16 nAntiAlialize)
		:	DefaultProcessor3D(rViewInformation3D, rSdrSceneAttribute, rSdrLightingAttribute),
			mpBZPixelRaster(0),
			maInvEyeToView(),
			mpZBufferRasterConverter3D(0),
			mnAntiAlialize(nAntiAlialize),
            mpRasterPrimitive3Ds(0)
		{
			// generate ViewSizes
			const double fFullViewSizeX((rViewInformation2D.getObjectToViewTransformation() * basegfx::B2DVector(fSizeX, 0.0)).getLength());
			const double fFullViewSizeY((rViewInformation2D.getObjectToViewTransformation() * basegfx::B2DVector(0.0, fSizeY)).getLength());
			const double fViewSizeX(fFullViewSizeX * rVisiblePart.getWidth());
			const double fViewSizeY(fFullViewSizeY * rVisiblePart.getHeight());

            // generate RasterWidth and RasterHeight
            const sal_uInt32 nRasterWidth((sal_uInt32)basegfx::fround(fViewSizeX) + 1);
			const sal_uInt32 nRasterHeight((sal_uInt32)basegfx::fround(fViewSizeY) + 1);

			if(nRasterWidth && nRasterHeight)
			{
				// create view unit buffer
				mpBZPixelRaster = new basegfx::BZPixelRaster(
					mnAntiAlialize ? nRasterWidth * mnAntiAlialize : nRasterWidth,
					mnAntiAlialize ? nRasterHeight * mnAntiAlialize : nRasterHeight);
				OSL_ENSURE(mpBZPixelRaster, "ZBufferProcessor3D: Could not allocate basegfx::BZPixelRaster (!)");

				// create DeviceToView for Z-Buffer renderer since Z is handled
				// different from standard 3D transformations (Z is mirrored). Also
				// the transformation includes the step from unit device coordinates
				// to discrete units ([-1.0 .. 1.0] -> [minDiscrete .. maxDiscrete]

				basegfx::B3DHomMatrix aDeviceToView;

				{
					// step one:
					//
					// bring from [-1.0 .. 1.0] in X,Y and Z to [0.0 .. 1.0]. Also
					// necessary to
					// - flip Y due to screen orientation
					// - flip Z due to Z-Buffer orientation from back to front

					aDeviceToView.scale(0.5, -0.5, -0.5);
					aDeviceToView.translate(0.5, 0.5, 0.5);
				}

				{
					// step two:
					//
					// bring from [0.0 .. 1.0] in X,Y and Z to view cordinates
                    //
					// #i102611#
                    // also: scale Z to [1.5 .. 65534.5]. Normally, a range of [0.0 .. 65535.0]
                    // could be used, but a 'unused' value is needed, so '0' is used what reduces
                    // the range to [1.0 .. 65535.0]. It has also shown that small numerical errors
                    // (smaller as basegfx::fTools::mfSmallValue, which is 0.000000001) happen.
                    // Instead of checking those by basegfx::fTools methods which would cost
                    // runtime, just add another 0.5 tolerance to the start and end of the Z-Buffer
                    // range, thus resulting in [1.5 .. 65534.5]
					const double fMaxZDepth(65533.0);
					aDeviceToView.translate(-rVisiblePart.getMinX(), -rVisiblePart.getMinY(), 0.0);

					if(mnAntiAlialize)
						aDeviceToView.scale(fFullViewSizeX * mnAntiAlialize, fFullViewSizeY * mnAntiAlialize, fMaxZDepth);
					else
						aDeviceToView.scale(fFullViewSizeX, fFullViewSizeY, fMaxZDepth);

                    aDeviceToView.translate(0.0, 0.0, 1.5);
				}

				// update local ViewInformation3D with own DeviceToView
				const geometry::ViewInformation3D aNewViewInformation3D(
					getViewInformation3D().getObjectTransformation(),
					getViewInformation3D().getOrientation(),
					getViewInformation3D().getProjection(),
					aDeviceToView,
					getViewInformation3D().getViewTime(),
					getViewInformation3D().getExtendedInformationSequence());
				updateViewInformation(aNewViewInformation3D);

				// prepare inverse EyeToView transformation. This can be done in constructor
				// since changes in object transformations when processing TransformPrimitive3Ds
				// do not influence this prepared partial transformation
				maInvEyeToView = getViewInformation3D().getDeviceToView() * getViewInformation3D().getProjection();
				maInvEyeToView.invert();

				// prepare maRasterRange
				maRasterRange.reset();
				maRasterRange.expand(basegfx::B2DPoint(0.0, 0.0));
				maRasterRange.expand(basegfx::B2DPoint(mpBZPixelRaster->getWidth(), mpBZPixelRaster->getHeight()));

				// create the raster converter
				mpZBufferRasterConverter3D = new ZBufferRasterConverter3D(*mpBZPixelRaster, *this);
			}
		}

		ZBufferProcessor3D::~ZBufferProcessor3D()
		{
			if(mpBZPixelRaster)
			{
				delete mpZBufferRasterConverter3D;
				delete mpBZPixelRaster;
			}

            if(mpRasterPrimitive3Ds)
            {
                OSL_ASSERT("ZBufferProcessor3D: destructed, but there are unrendered transparent geometries. Use ZBufferProcessor3D::finish() to render these (!)");
                delete mpRasterPrimitive3Ds;
            }
		}

        void ZBufferProcessor3D::finish()
        {
            if(mpRasterPrimitive3Ds)
            {
                // there are transparent rasterprimitives
                const sal_uInt32 nSize(mpRasterPrimitive3Ds->size());

                if(nSize > 1)
                {
                    // sort them from back to front
            		std::sort(mpRasterPrimitive3Ds->begin(), mpRasterPrimitive3Ds->end());
                }

                for(sal_uInt32 a(0); a < nSize; a++)
                {
                    // paint each one by setting the remembered data and calling
                    // the render method
                    const RasterPrimitive3D& rCandidate = (*mpRasterPrimitive3Ds)[a];

                    mpGeoTexSvx = rCandidate.getGeoTexSvx();
                    mpTransparenceGeoTexSvx = rCandidate.getTransparenceGeoTexSvx();
                    mbModulate = rCandidate.getModulate();
                    mbFilter = rCandidate.getFilter();
                    mbSimpleTextureActive = rCandidate.getSimpleTextureActive();

                    if(rCandidate.getIsLine())
                    {
                		rasterconvertB3DPolygon(
                            rCandidate.getMaterial(),
                            rCandidate.getPolyPolygon().getB3DPolygon(0));
                    }
                    else
                    {
                		rasterconvertB3DPolyPolygon(
                            rCandidate.getMaterial(),
                            rCandidate.getPolyPolygon());
                    }
                }

                // delete them to signal the destructor that all is done and
                // to allow asserting there
                delete mpRasterPrimitive3Ds;
                mpRasterPrimitive3Ds = 0;
            }
        }

        BitmapEx ZBufferProcessor3D::getBitmapEx() const
		{
			if(mpBZPixelRaster)
			{
                return BPixelRasterToBitmapEx(*mpBZPixelRaster, mnAntiAlialize);
			}

			return BitmapEx();
		}
	} // end of namespace processor3d
} // end of namespace drawinglayer

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