Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 1941 insertions, 0 deletions

diff --git a/drawinglayer/source/processor3d/baseprocessor3d.cxx b/drawinglayer/source/processor3d/baseprocessor3d.cxx
new file mode 100644
index 000000000..02d437a1a
--- /dev/null
+++ b/drawinglayer/source/processor3d/baseprocessor3d.cxx
@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <drawinglayer/processor3d/baseprocessor3d.hxx>
+
+
+using namespace com::sun::star;
+
+
+namespace drawinglayer::processor3d
+{
+        void BaseProcessor3D::processBasePrimitive3D(const primitive3d::BasePrimitive3D& /*rCandidate*/)
+        {
+        }
+
+        BaseProcessor3D::BaseProcessor3D(const geometry::ViewInformation3D& rViewInformation)
+        :   maViewInformation3D(rViewInformation)
+        {
+        }
+
+        BaseProcessor3D::~BaseProcessor3D()
+        {
+        }
+
+        void BaseProcessor3D::process(const primitive3d::Primitive3DContainer& rSource)
+        {
+            if(rSource.empty())
+                return;
+
+            const size_t nCount(rSource.size());
+
+            for(size_t a(0); a < nCount; a++)
+            {
+                // get reference
+                const primitive3d::Primitive3DReference xReference(rSource[a]);
+
+                if(xReference.is())
+                {
+                    const primitive3d::BasePrimitive3D* pBasePrimitive = static_cast< const primitive3d::BasePrimitive3D* >(xReference.get());
+                    processBasePrimitive3D(*pBasePrimitive);
+                }
+            }
+        }
+
+} // end of namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/processor3d/cutfindprocessor3d.cxx b/drawinglayer/source/processor3d/cutfindprocessor3d.cxx
new file mode 100644
index 000000000..cb1f737f5
--- /dev/null
+++ b/drawinglayer/source/processor3d/cutfindprocessor3d.cxx
@@ -0,0 +1,192 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <drawinglayer/processor3d/cutfindprocessor3d.hxx>
+#include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
+#include <drawinglayer/primitive3d/transformprimitive3d.hxx>
+#include <primitive3d/hatchtextureprimitive3d.hxx>
+#include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
+#include <basegfx/polygon/b3dpolygon.hxx>
+#include <basegfx/polygon/b3dpolygontools.hxx>
+#include <basegfx/polygon/b3dpolypolygontools.hxx>
+#include <primitive3d/hiddengeometryprimitive3d.hxx>
+
+
+namespace drawinglayer::processor3d
+{
+        CutFindProcessor::CutFindProcessor(const geometry::ViewInformation3D& rViewInformation,
+            const basegfx::B3DPoint& rFront,
+            const basegfx::B3DPoint& rBack,
+            bool bAnyHit)
+        :   BaseProcessor3D(rViewInformation),
+            maFront(rFront),
+            maBack(rBack),
+            mbAnyHit(bAnyHit)
+        {
+        }
+
+        void CutFindProcessor::processBasePrimitive3D(const primitive3d::BasePrimitive3D& rCandidate)
+        {
+            if(mbAnyHit && !maResult.empty())
+            {
+                // stop processing as soon as a hit was recognized
+                return;
+            }
+
+            // it is a BasePrimitive3D implementation, use getPrimitive3DID() call for switch
+            switch(rCandidate.getPrimitive3DID())
+            {
+                case PRIMITIVE3D_ID_TRANSFORMPRIMITIVE3D :
+                {
+                    // transform group.
+                    const primitive3d::TransformPrimitive3D& rPrimitive = static_cast< const primitive3d::TransformPrimitive3D& >(rCandidate);
+
+                    // remember old and transform front, back to object coordinates
+                    const basegfx::B3DPoint aLastFront(maFront);
+                    const basegfx::B3DPoint aLastBack(maBack);
+                    basegfx::B3DHomMatrix aInverseTrans(rPrimitive.getTransformation());
+                    aInverseTrans.invert();
+                    maFront *= aInverseTrans;
+                    maBack *= aInverseTrans;
+
+                    // remember current and create new transformation; add new object transform from right side
+                    const geometry::ViewInformation3D aLastViewInformation3D(getViewInformation3D());
+                    const geometry::ViewInformation3D aNewViewInformation3D(
+                        aLastViewInformation3D.getObjectTransformation() * rPrimitive.getTransformation(),
+                        aLastViewInformation3D.getOrientation(),
+                        aLastViewInformation3D.getProjection(),
+                        aLastViewInformation3D.getDeviceToView(),
+                        aLastViewInformation3D.getViewTime(),
+                        aLastViewInformation3D.getExtendedInformationSequence());
+                    updateViewInformation(aNewViewInformation3D);
+
+                    // #i102956# remember needed back-transform for found cuts (combine from right side)
+                    const basegfx::B3DHomMatrix aLastCombinedTransform(maCombinedTransform);
+                    maCombinedTransform = maCombinedTransform * rPrimitive.getTransformation();
+
+                    // let break down
+                    process(rPrimitive.getChildren());
+
+                    // restore transformations and front, back
+                    maCombinedTransform = aLastCombinedTransform;
+                    updateViewInformation(aLastViewInformation3D);
+                    maFront = aLastFront;
+                    maBack = aLastBack;
+                    break;
+                }
+                case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D :
+                {
+                    // PolygonHairlinePrimitive3D, not used for hit test with planes, ignore. This
+                    // means that also thick line expansion will not be hit-tested as
+                    // PolyPolygonMaterialPrimitive3D
+                    break;
+                }
+                case PRIMITIVE3D_ID_HATCHTEXTUREPRIMITIVE3D :
+                {
+                    // #i97321#
+                    // For HatchTexturePrimitive3D, do not use the decomposition since it will produce
+                    // clipped hatch lines in 3D. It can be used when the hatch also has a filling, but for
+                    // simplicity, just use the children which are the PolyPolygonMaterialPrimitive3D
+                    // which define the hatched areas anyways; for HitTest this is more than adequate
+                    const primitive3d::HatchTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::HatchTexturePrimitive3D& >(rCandidate);
+                    process(rPrimitive.getChildren());
+                    break;
+                }
+                case PRIMITIVE3D_ID_HIDDENGEOMETRYPRIMITIVE3D :
+                {
+                    // HiddenGeometryPrimitive3D; the default decomposition would return an empty sequence,
+                    // so force this primitive to process its children directly if the switch is set
+                    // (which is the default). Else, ignore invisible content
+                    const primitive3d::HiddenGeometryPrimitive3D& rHiddenGeometry(static_cast< const primitive3d::HiddenGeometryPrimitive3D& >(rCandidate));
+                    const primitive3d::Primitive3DContainer& rChildren = rHiddenGeometry.getChildren();
+
+                    if(!rChildren.empty())
+                    {
+                            process(rChildren);
+                    }
+
+                    break;
+                }
+                case PRIMITIVE3D_ID_UNIFIEDTRANSPARENCETEXTUREPRIMITIVE3D :
+                {
+                    const primitive3d::UnifiedTransparenceTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::UnifiedTransparenceTexturePrimitive3D& >(rCandidate);
+                    const primitive3d::Primitive3DContainer& rChildren = rPrimitive.getChildren();
+
+                    if(!rChildren.empty())
+                    {
+                        process(rChildren);
+                    }
+
+                    break;
+                }
+                case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D :
+                {
+                    // PolyPolygonMaterialPrimitive3D
+                    const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const primitive3d::PolyPolygonMaterialPrimitive3D& >(rCandidate);
+
+                    if(!maFront.equal(maBack))
+                    {
+                        const basegfx::B3DPolyPolygon& rPolyPolygon = rPrimitive.getB3DPolyPolygon();
+                        const sal_uInt32 nPolyCount(rPolyPolygon.count());
+
+                        if(nPolyCount)
+                        {
+                            const basegfx::B3DPolygon& aPolygon(rPolyPolygon.getB3DPolygon(0));
+                            const sal_uInt32 nPointCount(aPolygon.count());
+
+                            if(nPointCount > 2)
+                            {
+                                const basegfx::B3DVector aPlaneNormal(aPolygon.getNormal());
+
+                                if(!aPlaneNormal.equalZero())
+                                {
+                                    const basegfx::B3DPoint aPointOnPlane(aPolygon.getB3DPoint(0));
+                                    double fCut(0.0);
+
+                                    if(basegfx::utils::getCutBetweenLineAndPlane(aPlaneNormal, aPointOnPlane, maFront, maBack, fCut))
+                                    {
+                                        const basegfx::B3DPoint aCutPoint(basegfx::interpolate(maFront, maBack, fCut));
+
+                                        if(basegfx::utils::isInside(rPolyPolygon, aCutPoint))
+                                        {
+                                            // #i102956# add result. Do not forget to do this in the coordinate
+                                            // system the processor get started with, so use the collected
+                                            // combined transformation from processed TransformPrimitive3D's
+                                            maResult.push_back(maCombinedTransform * aCutPoint);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    break;
+                }
+                default :
+                {
+                    // process recursively
+                    process(rCandidate.get3DDecomposition(getViewInformation3D()));
+                    break;
+                }
+            }
+        }
+
+} // end of namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/processor3d/defaultprocessor3d.cxx b/drawinglayer/source/processor3d/defaultprocessor3d.cxx
new file mode 100644
index 000000000..b9159c46c
--- /dev/null
+++ b/drawinglayer/source/processor3d/defaultprocessor3d.cxx
@@ -0,0 +1,598 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <processor3d/defaultprocessor3d.hxx>
+#include <primitive3d/textureprimitive3d.hxx>
+#include <texture/texture.hxx>
+#include <texture/texture3d.hxx>
+#include <primitive3d/hatchtextureprimitive3d.hxx>
+#include <drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx>
+#include <drawinglayer/primitive3d/polygonprimitive3d.hxx>
+#include <basegfx/polygon/b3dpolygontools.hxx>
+#include <drawinglayer/attribute/materialattribute3d.hxx>
+#include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
+#include <basegfx/polygon/b3dpolypolygontools.hxx>
+#include <com/sun/star/drawing/ShadeMode.hpp>
+#include <drawinglayer/primitive3d/transformprimitive3d.hxx>
+#include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
+#include <vcl/bitmapex.hxx>
+#include <drawinglayer/attribute/sdrsceneattribute3d.hxx>
+#include <drawinglayer/attribute/sdrlightingattribute3d.hxx>
+#include <vcl/graph.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+
+
+using namespace com::sun::star;
+
+
+namespace drawinglayer::processor3d
+{
+        void DefaultProcessor3D::impRenderGradientTexturePrimitive3D(const primitive3d::GradientTexturePrimitive3D& rPrimitive, bool bTransparence)
+        {
+            const primitive3d::Primitive3DContainer& rSubSequence = rPrimitive.getChildren();
+
+            if(rSubSequence.empty())
+                return;
+
+            // rescue values
+            const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate();
+            const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter();
+            const bool bOldSimpleTextureActive(getSimpleTextureActive());
+            std::shared_ptr< texture::GeoTexSvx > pOldTex = bTransparence ? mpTransparenceGeoTexSvx : mpGeoTexSvx;
+
+            // create texture
+            const attribute::FillGradientAttribute& rFillGradient = rPrimitive.getGradient();
+            const basegfx::B2DRange aOutlineRange(0.0, 0.0, rPrimitive.getTextureSize().getX(), rPrimitive.getTextureSize().getY());
+            const attribute::GradientStyle aGradientStyle(rFillGradient.getStyle());
+            sal_uInt32 nSteps(rFillGradient.getSteps());
+            const basegfx::BColor& aStart(rFillGradient.getStartColor());
+            const basegfx::BColor& aEnd(rFillGradient.getEndColor());
+            const sal_uInt32 nMaxSteps(sal_uInt32((aStart.getMaximumDistance(aEnd) * 127.5) + 0.5));
+            std::shared_ptr< texture::GeoTexSvx > pNewTex;
+
+            if(nMaxSteps)
+            {
+                // there IS a color distance
+                if(nSteps == 0)
+                {
+                    nSteps = nMaxSteps;
+                }
+
+                if(nSteps < 2)
+                {
+                    nSteps = 2;
+                }
+
+                if(nSteps > nMaxSteps)
+                {
+                    nSteps = nMaxSteps;
+                }
+
+                switch(aGradientStyle)
+                {
+                    case attribute::GradientStyle::Linear:
+                    {
+                        pNewTex = std::make_shared<texture::GeoTexSvxGradientLinear>(
+                                aOutlineRange,
+                                aOutlineRange,
+                                aStart,
+                                aEnd,
+                                nSteps,
+                                rFillGradient.getBorder(),
+                                rFillGradient.getAngle());
+                        break;
+                    }
+                    case attribute::GradientStyle::Axial:
+                    {
+                        pNewTex = std::make_shared<texture::GeoTexSvxGradientAxial>(
+                                aOutlineRange,
+                                aOutlineRange,
+                                aStart,
+                                aEnd,
+                                nSteps,
+                                rFillGradient.getBorder(),
+                                rFillGradient.getAngle());
+                        break;
+                    }
+                    case attribute::GradientStyle::Radial:
+                    {
+                        pNewTex =
+                            std::make_shared<texture::GeoTexSvxGradientRadial>(
+                                aOutlineRange,
+                                aStart,
+                                aEnd,
+                                nSteps,
+                                rFillGradient.getBorder(),
+                                rFillGradient.getOffsetX(),
+                                rFillGradient.getOffsetY());
+                        break;
+                    }
+                    case attribute::GradientStyle::Elliptical:
+                    {
+                        pNewTex =
+                            std::make_shared<texture::GeoTexSvxGradientElliptical>(
+                                aOutlineRange,
+                                aStart,
+                                aEnd,
+                                nSteps,
+                                rFillGradient.getBorder(),
+                                rFillGradient.getOffsetX(),
+                                rFillGradient.getOffsetY(),
+                                rFillGradient.getAngle());
+                        break;
+                    }
+                    case attribute::GradientStyle::Square:
+                    {
+                        pNewTex =
+                            std::make_shared<texture::GeoTexSvxGradientSquare>(
+                                aOutlineRange,
+                                aStart,
+                                aEnd,
+                                nSteps,
+                                rFillGradient.getBorder(),
+                                rFillGradient.getOffsetX(),
+                                rFillGradient.getOffsetY(),
+                                rFillGradient.getAngle());
+                        break;
+                    }
+                    case attribute::GradientStyle::Rect:
+                    {
+                        pNewTex =
+                            std::make_shared<texture::GeoTexSvxGradientRect>(
+                                aOutlineRange,
+                                aStart,
+                                aEnd,
+                                nSteps,
+                                rFillGradient.getBorder(),
+                                rFillGradient.getOffsetX(),
+                                rFillGradient.getOffsetY(),
+                                rFillGradient.getAngle());
+                        break;
+                    }
+                }
+
+                mbSimpleTextureActive = false;
+            }
+            else
+            {
+                // no color distance -> same color, use simple texture
+                pNewTex = std::make_shared<texture::GeoTexSvxMono>(aStart, 1.0 - aStart.luminance());
+                mbSimpleTextureActive = true;
+            }
+
+            // set created texture
+            if(bTransparence)
+            {
+                mpTransparenceGeoTexSvx = pNewTex;
+            }
+            else
+            {
+                mpGeoTexSvx = pNewTex;
+            }
+
+            // process sub-list
+            process(rSubSequence);
+
+            // restore values
+            mbModulate = bOldModulate;
+            mbFilter = bOldFilter;
+            mbSimpleTextureActive = bOldSimpleTextureActive;
+
+            if(bTransparence)
+            {
+                mpTransparenceGeoTexSvx = pOldTex;
+            }
+            else
+            {
+                mpGeoTexSvx = pOldTex;
+            }
+        }
+
+        void DefaultProcessor3D::impRenderHatchTexturePrimitive3D(const primitive3d::HatchTexturePrimitive3D& rPrimitive)
+        {
+            const primitive3d::Primitive3DContainer& rSubSequence = rPrimitive.getChildren();
+
+            if(rSubSequence.empty())
+                return;
+
+            // rescue values
+            const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate();
+            const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter();
+            std::shared_ptr< texture::GeoTexSvx > pOldTex = mpGeoTexSvx;
+
+            // calculate logic pixel size in object coordinates. Create transformation view
+            // to object by inverting ObjectToView
+            basegfx::B3DHomMatrix aInvObjectToView(getViewInformation3D().getObjectToView());
+            aInvObjectToView.invert();
+
+            // back-project discrete coordinates to object coordinates and extract
+            // maximum distance
+            const basegfx::B3DPoint aZero(aInvObjectToView * basegfx::B3DPoint(0.0, 0.0, 0.0));
+            const basegfx::B3DPoint aOne(aInvObjectToView * basegfx::B3DPoint(1.0, 1.0, 1.0));
+            const basegfx::B3DVector aLogicPixel(aOne - aZero);
+            double fLogicPixelSizeWorld(std::max(std::max(fabs(aLogicPixel.getX()), fabs(aLogicPixel.getY())), fabs(aLogicPixel.getZ())));
+
+            // calculate logic pixel size in texture coordinates
+            const double fLogicTexSizeX(fLogicPixelSizeWorld / rPrimitive.getTextureSize().getX());
+            const double fLogicTexSizeY(fLogicPixelSizeWorld / rPrimitive.getTextureSize().getY());
+            const double fLogicTexSize(std::max(fLogicTexSizeX, fLogicTexSizeY));
+
+            // create texture and set
+            mpGeoTexSvx = std::make_shared<texture::GeoTexSvxMultiHatch>(rPrimitive, fLogicTexSize);
+
+            // process sub-list
+            process(rSubSequence);
+
+            // restore values
+            mbModulate = bOldModulate;
+            mbFilter = bOldFilter;
+            mpGeoTexSvx = pOldTex;
+        }
+
+        void DefaultProcessor3D::impRenderBitmapTexturePrimitive3D(const primitive3d::BitmapTexturePrimitive3D& rPrimitive)
+        {
+            const primitive3d::Primitive3DContainer& rSubSequence = rPrimitive.getChildren();
+
+            if(rSubSequence.empty())
+                return;
+
+            // rescue values
+            const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate();
+            const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter();
+            std::shared_ptr< texture::GeoTexSvx > pOldTex = mpGeoTexSvx;
+
+            // create texture
+            const attribute::FillGraphicAttribute& rFillGraphicAttribute = rPrimitive.getFillGraphicAttribute();
+
+            // #121194# For 3D texture we will use the BitmapRex representation
+            const BitmapEx aBitmapEx(rFillGraphicAttribute.getGraphic().GetBitmapEx());
+
+            // create range scaled by texture size
+            basegfx::B2DRange aGraphicRange(rFillGraphicAttribute.getGraphicRange());
+
+            aGraphicRange.transform(
+                basegfx::utils::createScaleB2DHomMatrix(
+                    rPrimitive.getTextureSize()));
+
+            if(rFillGraphicAttribute.getTiling())
+            {
+                mpGeoTexSvx =
+                    std::make_shared<texture::GeoTexSvxBitmapExTiled>(
+                        aBitmapEx,
+                        aGraphicRange,
+                        rFillGraphicAttribute.getOffsetX(),
+                        rFillGraphicAttribute.getOffsetY());
+            }
+            else
+            {
+                mpGeoTexSvx =
+                    std::make_shared<texture::GeoTexSvxBitmapEx>(
+                        aBitmapEx,
+                        aGraphicRange);
+            }
+
+            // process sub-list
+            process(rSubSequence);
+
+            // restore values
+            mbModulate = bOldModulate;
+            mbFilter = bOldFilter;
+            mpGeoTexSvx = pOldTex;
+        }
+
+        void DefaultProcessor3D::impRenderModifiedColorPrimitive3D(const primitive3d::ModifiedColorPrimitive3D& rModifiedCandidate)
+        {
+            const primitive3d::Primitive3DContainer& rSubSequence = rModifiedCandidate.getChildren();
+
+            if(!rSubSequence.empty())
+            {
+                // put modifier on stack
+                maBColorModifierStack.push(rModifiedCandidate.getColorModifier());
+
+                // process sub-list
+                process(rModifiedCandidate.getChildren());
+
+                // remove modifier from stack
+                maBColorModifierStack.pop();
+            }
+        }
+
+        void DefaultProcessor3D::impRenderPolygonHairlinePrimitive3D(const primitive3d::PolygonHairlinePrimitive3D& rPrimitive) const
+        {
+            basegfx::B3DPolygon aHairline(rPrimitive.getB3DPolygon());
+
+            if(!aHairline.count())
+                return;
+
+            // hairlines need no extra data, clear it
+            aHairline.clearTextureCoordinates();
+            aHairline.clearNormals();
+            aHairline.clearBColors();
+
+            // transform to device coordinates (-1.0 .. 1.0) and check for visibility
+            aHairline.transform(getViewInformation3D().getObjectToView());
+            const basegfx::B3DRange a3DRange(basegfx::utils::getRange(aHairline));
+            const basegfx::B2DRange a2DRange(a3DRange.getMinX(), a3DRange.getMinY(), a3DRange.getMaxX(), a3DRange.getMaxY());
+
+            if(a2DRange.overlaps(maRasterRange))
+            {
+                const attribute::MaterialAttribute3D aMaterial(maBColorModifierStack.getModifiedColor(rPrimitive.getBColor()));
+
+                rasterconvertB3DPolygon(aMaterial, aHairline);
+            }
+        }
+
+        void DefaultProcessor3D::impRenderPolyPolygonMaterialPrimitive3D(const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive) const
+        {
+            basegfx::B3DPolyPolygon aFill(rPrimitive.getB3DPolyPolygon());
+            basegfx::BColor aObjectColor(rPrimitive.getMaterial().getColor());
+            bool bPaintIt(aFill.count());
+
+            // #i98295# get ShadeMode. Correct early when only flat is possible due to missing normals
+            const css::drawing::ShadeMode aShadeMode(
+                aFill.areNormalsUsed() ?
+                    getSdrSceneAttribute().getShadeMode() : css::drawing::ShadeMode_FLAT);
+
+            if(bPaintIt)
+            {
+                // get rid of texture coordinates if there is no texture
+                if(aFill.areTextureCoordinatesUsed() && !getGeoTexSvx() && !getTransparenceGeoTexSvx())
+                {
+                    aFill.clearTextureCoordinates();
+                }
+
+                // #i98295# get rid of normals and color early when not needed
+                if(css::drawing::ShadeMode_FLAT == aShadeMode)
+                {
+                    aFill.clearNormals();
+                    aFill.clearBColors();
+                }
+
+                // transform to device coordinates (-1.0 .. 1.0) and check for visibility
+                aFill.transform(getViewInformation3D().getObjectToView());
+                const basegfx::B3DRange a3DRange(basegfx::utils::getRange(aFill));
+                const basegfx::B2DRange a2DRange(a3DRange.getMinX(), a3DRange.getMinY(), a3DRange.getMaxX(), a3DRange.getMaxY());
+
+                bPaintIt = a2DRange.overlaps(maRasterRange);
+            }
+
+            // check if it shall be painted regarding hiding of normals (backface culling)
+            if(bPaintIt && !rPrimitive.getDoubleSided())
+            {
+                // get plane normal of polygon in view coordinates (with ZBuffer values),
+                // left-handed coordinate system
+                const basegfx::B3DVector aPlaneNormal(aFill.getB3DPolygon(0).getNormal());
+
+                if(aPlaneNormal.getZ() > 0.0)
+                {
+                    bPaintIt = false;
+                }
+            }
+
+            if(!bPaintIt)
+                return;
+
+            // prepare ObjectToEye in NormalTransform
+            basegfx::B3DHomMatrix aNormalTransform(getViewInformation3D().getOrientation() * getViewInformation3D().getObjectTransformation());
+
+            if(getSdrSceneAttribute().getTwoSidedLighting())
+            {
+                // get plane normal of polygon in view coordinates (with ZBuffer values),
+                // left-handed coordinate system
+                const basegfx::B3DVector aPlaneNormal(aFill.getB3DPolygon(0).getNormal());
+
+                if(aPlaneNormal.getZ() > 0.0)
+                {
+                    // mirror normals
+                    aNormalTransform.scale(-1.0, -1.0, -1.0);
+                }
+            }
+
+            switch(aShadeMode)
+            {
+                case css::drawing::ShadeMode_PHONG:
+                {
+                    // phong shading. Transform normals to eye coor
+                    aFill.transformNormals(aNormalTransform);
+                    break;
+                }
+                case css::drawing::ShadeMode_SMOOTH:
+                {
+                    // gouraud shading. Transform normals to eye coor
+                    aFill.transformNormals(aNormalTransform);
+
+                    // prepare color model parameters, evtl. use blend color
+                    const basegfx::BColor aColor(getModulate() ? basegfx::BColor(1.0, 1.0, 1.0) : rPrimitive.getMaterial().getColor());
+                    const basegfx::BColor& rSpecular(rPrimitive.getMaterial().getSpecular());
+                    const basegfx::BColor& rEmission(rPrimitive.getMaterial().getEmission());
+                    const sal_uInt16 nSpecularIntensity(rPrimitive.getMaterial().getSpecularIntensity());
+
+                    // solve color model for each normal vector, set colors at points. Clear normals.
+                    for(sal_uInt32 a(0); a < aFill.count(); a++)
+                    {
+                        basegfx::B3DPolygon aPartFill(aFill.getB3DPolygon(a));
+
+                        for(sal_uInt32 b(0); b < aPartFill.count(); b++)
+                        {
+                            // solve color model. Transform normal to eye coor
+                            const basegfx::B3DVector aNormal(aPartFill.getNormal(b));
+                            const basegfx::BColor aSolvedColor(getSdrLightingAttribute().solveColorModel(aNormal, aColor, rSpecular, rEmission, nSpecularIntensity));
+                            aPartFill.setBColor(b, aSolvedColor);
+                        }
+
+                        // clear normals on this part polygon and write it back
+                        aPartFill.clearNormals();
+                        aFill.setB3DPolygon(a, aPartFill);
+                    }
+                    break;
+                }
+                case css::drawing::ShadeMode_FLAT:
+                {
+                    // flat shading. Get plane vector in eye coordinates
+                    const basegfx::B3DVector aPlaneEyeNormal(aNormalTransform * rPrimitive.getB3DPolyPolygon().getB3DPolygon(0).getNormal());
+
+                    // prepare color model parameters, evtl. use blend color
+                    const basegfx::BColor aColor(getModulate() ? basegfx::BColor(1.0, 1.0, 1.0) : rPrimitive.getMaterial().getColor());
+                    const basegfx::BColor& rSpecular(rPrimitive.getMaterial().getSpecular());
+                    const basegfx::BColor& rEmission(rPrimitive.getMaterial().getEmission());
+                    const sal_uInt16 nSpecularIntensity(rPrimitive.getMaterial().getSpecularIntensity());
+
+                    // solve color model for plane vector and use that color for whole plane
+                    aObjectColor = getSdrLightingAttribute().solveColorModel(aPlaneEyeNormal, aColor, rSpecular, rEmission, nSpecularIntensity);
+                    break;
+                }
+                default: // case css::drawing::ShadeMode_DRAFT:
+                {
+                    // draft, just use object color which is already set. Delete all other infos
+                    aFill.clearNormals();
+                    aFill.clearBColors();
+                    break;
+                }
+            }
+
+            // draw it to ZBuffer
+            const attribute::MaterialAttribute3D aMaterial(
+                maBColorModifierStack.getModifiedColor(aObjectColor),
+                rPrimitive.getMaterial().getSpecular(),
+                rPrimitive.getMaterial().getEmission(),
+                rPrimitive.getMaterial().getSpecularIntensity());
+
+            rasterconvertB3DPolyPolygon(aMaterial, aFill);
+        }
+
+        void DefaultProcessor3D::impRenderTransformPrimitive3D(const primitive3d::TransformPrimitive3D& rTransformCandidate)
+        {
+            // transform group. Remember current transformations
+            const geometry::ViewInformation3D aLastViewInformation3D(getViewInformation3D());
+
+            // create new transformation; add new object transform from right side
+            const geometry::ViewInformation3D aNewViewInformation3D(
+                aLastViewInformation3D.getObjectTransformation() * rTransformCandidate.getTransformation(),
+                aLastViewInformation3D.getOrientation(),
+                aLastViewInformation3D.getProjection(),
+                aLastViewInformation3D.getDeviceToView(),
+                aLastViewInformation3D.getViewTime(),
+                aLastViewInformation3D.getExtendedInformationSequence());
+            updateViewInformation(aNewViewInformation3D);
+
+            // let break down recursively
+            process(rTransformCandidate.getChildren());
+
+            // restore transformations
+            updateViewInformation(aLastViewInformation3D);
+        }
+
+        void DefaultProcessor3D::processBasePrimitive3D(const primitive3d::BasePrimitive3D& rBasePrimitive)
+        {
+            // it is a BasePrimitive3D implementation, use getPrimitive3DID() call for switch
+            switch(rBasePrimitive.getPrimitive3DID())
+            {
+                case PRIMITIVE3D_ID_GRADIENTTEXTUREPRIMITIVE3D :
+                {
+                    // GradientTexturePrimitive3D
+                    const primitive3d::GradientTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::GradientTexturePrimitive3D& >(rBasePrimitive);
+                    impRenderGradientTexturePrimitive3D(rPrimitive, false);
+                    break;
+                }
+                case PRIMITIVE3D_ID_HATCHTEXTUREPRIMITIVE3D :
+                {
+                    // hatchTexturePrimitive3D
+                    const primitive3d::HatchTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::HatchTexturePrimitive3D& >(rBasePrimitive);
+                    impRenderHatchTexturePrimitive3D(rPrimitive);
+                    break;
+                }
+                case PRIMITIVE3D_ID_BITMAPTEXTUREPRIMITIVE3D :
+                {
+                    // BitmapTexturePrimitive3D
+                    const primitive3d::BitmapTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::BitmapTexturePrimitive3D& >(rBasePrimitive);
+                    impRenderBitmapTexturePrimitive3D(rPrimitive);
+                    break;
+                }
+                case PRIMITIVE3D_ID_TRANSPARENCETEXTUREPRIMITIVE3D :
+                {
+                    // TransparenceTexturePrimitive3D
+                    const primitive3d::TransparenceTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::TransparenceTexturePrimitive3D& >(rBasePrimitive);
+                    mnTransparenceCounter++;
+                    impRenderGradientTexturePrimitive3D(rPrimitive, true);
+                    mnTransparenceCounter--;
+                    break;
+                }
+                case PRIMITIVE3D_ID_MODIFIEDCOLORPRIMITIVE3D :
+                {
+                    // ModifiedColorPrimitive3D
+                    // Force output to unified color.
+                    const primitive3d::ModifiedColorPrimitive3D& rPrimitive = static_cast< const primitive3d::ModifiedColorPrimitive3D& >(rBasePrimitive);
+                    impRenderModifiedColorPrimitive3D(rPrimitive);
+                    break;
+                }
+                case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D :
+                {
+                    // directdraw of PolygonHairlinePrimitive3D
+                    const primitive3d::PolygonHairlinePrimitive3D& rPrimitive = static_cast< const primitive3d::PolygonHairlinePrimitive3D& >(rBasePrimitive);
+                    impRenderPolygonHairlinePrimitive3D(rPrimitive);
+                    break;
+                }
+                case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D :
+                {
+                    // directdraw of PolyPolygonMaterialPrimitive3D
+                    const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const primitive3d::PolyPolygonMaterialPrimitive3D& >(rBasePrimitive);
+                    impRenderPolyPolygonMaterialPrimitive3D(rPrimitive);
+                    break;
+                }
+                case PRIMITIVE3D_ID_TRANSFORMPRIMITIVE3D :
+                {
+                    // transform group (TransformPrimitive3D)
+                    impRenderTransformPrimitive3D(static_cast< const primitive3d::TransformPrimitive3D& >(rBasePrimitive));
+                    break;
+                }
+                default:
+                {
+                    // process recursively
+                    process(rBasePrimitive.get3DDecomposition(getViewInformation3D()));
+                    break;
+                }
+            }
+        }
+
+        DefaultProcessor3D::DefaultProcessor3D(
+            const geometry::ViewInformation3D& rViewInformation,
+            const attribute::SdrSceneAttribute& rSdrSceneAttribute,
+            const attribute::SdrLightingAttribute& rSdrLightingAttribute)
+        :   BaseProcessor3D(rViewInformation),
+            mrSdrSceneAttribute(rSdrSceneAttribute),
+            mrSdrLightingAttribute(rSdrLightingAttribute),
+            maBColorModifierStack(),
+            mnTransparenceCounter(0),
+            mbModulate(false),
+            mbFilter(false),
+            mbSimpleTextureActive(false)
+        {
+            // a derivation has to set maRasterRange which is used in the basic render methods.
+            // Setting to default here ([0.0 .. 1.0] in X,Y) to avoid problems
+            maRasterRange.expand(basegfx::B2DTuple(0.0, 0.0));
+            maRasterRange.expand(basegfx::B2DTuple(1.0, 1.0));
+        }
+
+        DefaultProcessor3D::~DefaultProcessor3D()
+        {
+        }
+
+} // end of namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/processor3d/geometry2dextractor.cxx b/drawinglayer/source/processor3d/geometry2dextractor.cxx
new file mode 100644
index 000000000..568496bb9
--- /dev/null
+++ b/drawinglayer/source/processor3d/geometry2dextractor.cxx
@@ -0,0 +1,153 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <processor3d/geometry2dextractor.hxx>
+#include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
+#include <drawinglayer/primitive3d/transformprimitive3d.hxx>
+#include <drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx>
+#include <drawinglayer/primitive3d/polygonprimitive3d.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <drawinglayer/primitive2d/PolygonHairlinePrimitive2D.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
+#include <primitive3d/textureprimitive3d.hxx>
+
+
+using namespace com::sun::star;
+
+
+namespace drawinglayer::processor3d
+{
+        // as tooling, the process() implementation takes over API handling and calls this
+        // virtual render method when the primitive implementation is BasePrimitive3D-based.
+        void Geometry2DExtractingProcessor::processBasePrimitive3D(const primitive3d::BasePrimitive3D& rCandidate)
+        {
+            // it is a BasePrimitive3D implementation, use getPrimitive3DID() call for switch
+            switch(rCandidate.getPrimitive3DID())
+            {
+                case PRIMITIVE3D_ID_TRANSFORMPRIMITIVE3D :
+                {
+                    // transform group. Remember current transformations
+                    const primitive3d::TransformPrimitive3D& rPrimitive = static_cast< const primitive3d::TransformPrimitive3D& >(rCandidate);
+                    const geometry::ViewInformation3D aLastViewInformation3D(getViewInformation3D());
+
+                    // create new transformation; add new object transform from right side
+                    const geometry::ViewInformation3D aNewViewInformation3D(
+                        aLastViewInformation3D.getObjectTransformation() * rPrimitive.getTransformation(),
+                        aLastViewInformation3D.getOrientation(),
+                        aLastViewInformation3D.getProjection(),
+                        aLastViewInformation3D.getDeviceToView(),
+                        aLastViewInformation3D.getViewTime(),
+                        aLastViewInformation3D.getExtendedInformationSequence());
+                    updateViewInformation(aNewViewInformation3D);
+
+                    // let break down recursively
+                    process(rPrimitive.getChildren());
+
+                    // restore transformations
+                    updateViewInformation(aLastViewInformation3D);
+                    break;
+                }
+                case PRIMITIVE3D_ID_MODIFIEDCOLORPRIMITIVE3D :
+                {
+                    // ModifiedColorPrimitive3D; push, process and pop
+                    const primitive3d::ModifiedColorPrimitive3D& rModifiedCandidate = static_cast< const primitive3d::ModifiedColorPrimitive3D& >(rCandidate);
+                    const primitive3d::Primitive3DContainer& rSubSequence = rModifiedCandidate.getChildren();
+
+                    if(!rSubSequence.empty())
+                    {
+                        maBColorModifierStack.push(rModifiedCandidate.getColorModifier());
+                        process(rModifiedCandidate.getChildren());
+                        maBColorModifierStack.pop();
+                    }
+                    break;
+                }
+                case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D :
+                {
+                    // PolygonHairlinePrimitive3D
+                    const primitive3d::PolygonHairlinePrimitive3D& rPrimitive = static_cast< const primitive3d::PolygonHairlinePrimitive3D& >(rCandidate);
+                    basegfx::B2DPolygon a2DHairline(basegfx::utils::createB2DPolygonFromB3DPolygon(rPrimitive.getB3DPolygon(), getViewInformation3D().getObjectToView()));
+
+                    if(a2DHairline.count())
+                    {
+                        a2DHairline.transform(getObjectTransformation());
+                        const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(rPrimitive.getBColor()));
+                        const primitive2d::Primitive2DReference xRef(new primitive2d::PolygonHairlinePrimitive2D(a2DHairline, aModifiedColor));
+                        maPrimitive2DSequence.push_back(xRef);
+                    }
+                    break;
+                }
+                case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D :
+                {
+                    // PolyPolygonMaterialPrimitive3D
+                    const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const primitive3d::PolyPolygonMaterialPrimitive3D& >(rCandidate);
+                    basegfx::B2DPolyPolygon a2DFill(basegfx::utils::createB2DPolyPolygonFromB3DPolyPolygon(rPrimitive.getB3DPolyPolygon(), getViewInformation3D().getObjectToView()));
+
+                    if(a2DFill.count())
+                    {
+                        a2DFill.transform(getObjectTransformation());
+                        const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(rPrimitive.getMaterial().getColor()));
+                        const primitive2d::Primitive2DReference xRef(new primitive2d::PolyPolygonColorPrimitive2D(a2DFill, aModifiedColor));
+                        maPrimitive2DSequence.push_back(xRef);
+                    }
+                    break;
+                }
+                case PRIMITIVE3D_ID_GRADIENTTEXTUREPRIMITIVE3D :
+                case PRIMITIVE3D_ID_HATCHTEXTUREPRIMITIVE3D :
+                case PRIMITIVE3D_ID_BITMAPTEXTUREPRIMITIVE3D :
+                case PRIMITIVE3D_ID_TRANSPARENCETEXTUREPRIMITIVE3D :
+                case PRIMITIVE3D_ID_UNIFIEDTRANSPARENCETEXTUREPRIMITIVE3D :
+                {
+                    // TexturePrimitive3D: Process children, do not try to decompose
+                    const primitive3d::TexturePrimitive3D& rTexturePrimitive = static_cast< const primitive3d::TexturePrimitive3D& >(rCandidate);
+                    const primitive3d::Primitive3DContainer& aChildren(rTexturePrimitive.getChildren());
+
+                    if(!aChildren.empty())
+                    {
+                        process(aChildren);
+                    }
+                    break;
+                }
+                case PRIMITIVE3D_ID_SHADOWPRIMITIVE3D :
+                {
+                    // accept but ignore labels and shadow; these should be extracted separately
+                    break;
+                }
+                default :
+                {
+                    // process recursively
+                    process(rCandidate.get3DDecomposition(getViewInformation3D()));
+                    break;
+                }
+            }
+        }
+
+        Geometry2DExtractingProcessor::Geometry2DExtractingProcessor(
+            const geometry::ViewInformation3D& rViewInformation,
+            const basegfx::B2DHomMatrix& rObjectTransformation)
+        :   BaseProcessor3D(rViewInformation),
+            maObjectTransformation(rObjectTransformation),
+            maBColorModifierStack()
+        {
+        }
+
+} // end of namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/processor3d/shadow3dextractor.cxx b/drawinglayer/source/processor3d/shadow3dextractor.cxx
new file mode 100644
index 000000000..91fc57aae
--- /dev/null
+++ b/drawinglayer/source/processor3d/shadow3dextractor.cxx
@@ -0,0 +1,297 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <processor3d/shadow3dextractor.hxx>
+#include <primitive3d/shadowprimitive3d.hxx>
+#include <drawinglayer/primitive2d/shadowprimitive2d.hxx>
+#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
+#include <drawinglayer/primitive3d/transformprimitive3d.hxx>
+#include <drawinglayer/primitive3d/polygonprimitive3d.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <drawinglayer/primitive2d/PolygonHairlinePrimitive2D.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
+#include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
+#include <rtl/ref.hxx>
+
+
+using namespace com::sun::star;
+
+
+namespace drawinglayer::processor3d
+{
+        // as tooling, the process() implementation takes over API handling and calls this
+        // virtual render method when the primitive implementation is BasePrimitive3D-based.
+        void Shadow3DExtractingProcessor::processBasePrimitive3D(const primitive3d::BasePrimitive3D& rCandidate)
+        {
+            // it is a BasePrimitive3D implementation, use getPrimitive3DID() call for switch
+            switch(rCandidate.getPrimitive3DID())
+            {
+                case PRIMITIVE3D_ID_SHADOWPRIMITIVE3D :
+                {
+                    // shadow3d object. Call recursive with content and start conversion
+                    const primitive3d::ShadowPrimitive3D& rPrimitive = static_cast< const primitive3d::ShadowPrimitive3D& >(rCandidate);
+
+                    // set new target
+                    primitive2d::Primitive2DContainer aNewSubList;
+                    primitive2d::Primitive2DContainer* pLastTargetSequence = mpPrimitive2DSequence;
+                    mpPrimitive2DSequence = &aNewSubList;
+
+                    // activate convert
+                    const bool bLastConvert(mbConvert);
+                    mbConvert = true;
+
+                    // set projection flag
+                    const bool bLastUseProjection(mbUseProjection);
+                    mbUseProjection = rPrimitive.getShadow3D();
+
+                    // process content
+                    process(rPrimitive.getChildren());
+
+                    // restore values
+                    mbUseProjection = bLastUseProjection;
+                    mbConvert = bLastConvert;
+                    mpPrimitive2DSequence = pLastTargetSequence;
+
+                    // create 2d shadow primitive with result. This also fetches all entries
+                    // from aNewSubList, so there is no need to delete them
+                    rtl::Reference<primitive2d::BasePrimitive2D> pNew = new primitive2d::ShadowPrimitive2D(
+                        rPrimitive.getShadowTransform(),
+                        rPrimitive.getShadowColor(),
+                        0,  // shadow3d doesn't have rPrimitive.getShadowBlur() yet.
+                        std::move(aNewSubList));
+
+                    if(basegfx::fTools::more(rPrimitive.getShadowTransparence(), 0.0))
+                    {
+                        // create simpleTransparencePrimitive, add created primitives
+                        primitive2d::Primitive2DContainer aNewTransPrimitiveVector { pNew };
+
+                        pNew = new primitive2d::UnifiedTransparencePrimitive2D(
+                            std::move(aNewTransPrimitiveVector),
+                            rPrimitive.getShadowTransparence());
+                    }
+
+                    mpPrimitive2DSequence->push_back(pNew);
+
+                    break;
+                }
+                case PRIMITIVE3D_ID_TRANSFORMPRIMITIVE3D :
+                {
+                    // transform group. Remember current transformations
+                    const primitive3d::TransformPrimitive3D& rPrimitive = static_cast< const primitive3d::TransformPrimitive3D& >(rCandidate);
+                    const geometry::ViewInformation3D aLastViewInformation3D(getViewInformation3D());
+
+                    // create new transformation; add new object transform from right side
+                    const geometry::ViewInformation3D aNewViewInformation3D(
+                        aLastViewInformation3D.getObjectTransformation() * rPrimitive.getTransformation(),
+                        aLastViewInformation3D.getOrientation(),
+                        aLastViewInformation3D.getProjection(),
+                        aLastViewInformation3D.getDeviceToView(),
+                        aLastViewInformation3D.getViewTime(),
+                        aLastViewInformation3D.getExtendedInformationSequence());
+                    updateViewInformation(aNewViewInformation3D);
+
+                    if(mbShadowProjectionIsValid)
+                    {
+                        // update buffered WorldToEye and EyeToView
+                        maWorldToEye = getViewInformation3D().getOrientation() * getViewInformation3D().getObjectTransformation();
+                        maEyeToView = getViewInformation3D().getDeviceToView() * getViewInformation3D().getProjection();
+                    }
+
+                    // let break down
+                    process(rPrimitive.getChildren());
+
+                    // restore transformations
+                    updateViewInformation(aLastViewInformation3D);
+
+                    if(mbShadowProjectionIsValid)
+                    {
+                        // update buffered WorldToEye and EyeToView
+                        maWorldToEye = getViewInformation3D().getOrientation() * getViewInformation3D().getObjectTransformation();
+                        maEyeToView = getViewInformation3D().getDeviceToView() * getViewInformation3D().getProjection();
+                    }
+                    break;
+                }
+                case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D :
+                {
+                    // PolygonHairlinePrimitive3D
+                    if(mbConvert)
+                    {
+                        const primitive3d::PolygonHairlinePrimitive3D& rPrimitive = static_cast< const primitive3d::PolygonHairlinePrimitive3D& >(rCandidate);
+                        basegfx::B2DPolygon a2DHairline;
+
+                        if(mbUseProjection)
+                        {
+                            if(mbShadowProjectionIsValid)
+                            {
+                                a2DHairline = impDoShadowProjection(rPrimitive.getB3DPolygon());
+                            }
+                        }
+                        else
+                        {
+                            a2DHairline = basegfx::utils::createB2DPolygonFromB3DPolygon(rPrimitive.getB3DPolygon(), getViewInformation3D().getObjectToView());
+                        }
+
+                        if(a2DHairline.count())
+                        {
+                            a2DHairline.transform(getObjectTransformation());
+                            mpPrimitive2DSequence->push_back(
+                                new primitive2d::PolygonHairlinePrimitive2D(
+                                    a2DHairline,
+                                    basegfx::BColor()));
+                        }
+                    }
+                    break;
+                }
+                case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D :
+                {
+                    // PolyPolygonMaterialPrimitive3D
+                    if(mbConvert)
+                    {
+                        const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const primitive3d::PolyPolygonMaterialPrimitive3D& >(rCandidate);
+                        basegfx::B2DPolyPolygon a2DFill;
+
+                        if(mbUseProjection)
+                        {
+                            if(mbShadowProjectionIsValid)
+                            {
+                                a2DFill = impDoShadowProjection(rPrimitive.getB3DPolyPolygon());
+                            }
+                        }
+                        else
+                        {
+                            a2DFill = basegfx::utils::createB2DPolyPolygonFromB3DPolyPolygon(rPrimitive.getB3DPolyPolygon(), getViewInformation3D().getObjectToView());
+                        }
+
+                        if(a2DFill.count())
+                        {
+                            a2DFill.transform(getObjectTransformation());
+                            mpPrimitive2DSequence->push_back(
+                                new primitive2d::PolyPolygonColorPrimitive2D(
+                                    a2DFill,
+                                    basegfx::BColor()));
+                        }
+                    }
+                    break;
+                }
+                default :
+                {
+                    // process recursively
+                    process(rCandidate.get3DDecomposition(getViewInformation3D()));
+                    break;
+                }
+            }
+        }
+
+        Shadow3DExtractingProcessor::Shadow3DExtractingProcessor(
+            const geometry::ViewInformation3D& rViewInformation,
+            const basegfx::B2DHomMatrix& rObjectTransformation,
+            const basegfx::B3DVector& rLightNormal,
+            double fShadowSlant,
+            const basegfx::B3DRange& rContained3DRange)
+        :   BaseProcessor3D(rViewInformation),
+            mpPrimitive2DSequence(&maPrimitive2DSequence),
+            maObjectTransformation(rObjectTransformation),
+            maLightNormal(rLightNormal),
+            mfLightPlaneScalar(0.0),
+            mbShadowProjectionIsValid(false),
+            mbConvert(false),
+            mbUseProjection(false)
+        {
+            // normalize light normal, get and normalize shadow plane normal and calculate scalar from it
+            maLightNormal.normalize();
+            maShadowPlaneNormal = basegfx::B3DVector(0.0, sin(fShadowSlant), cos(fShadowSlant));
+            maShadowPlaneNormal.normalize();
+            mfLightPlaneScalar = maLightNormal.scalar(maShadowPlaneNormal);
+
+            // use only when scalar is > 0.0, so the light is in front of the object
+            if(!basegfx::fTools::more(mfLightPlaneScalar, 0.0))
+                return;
+
+            // prepare buffered WorldToEye and EyeToView
+            maWorldToEye = getViewInformation3D().getOrientation() * getViewInformation3D().getObjectTransformation();
+            maEyeToView = getViewInformation3D().getDeviceToView() * getViewInformation3D().getProjection();
+
+            // calculate range to get front edge around which to rotate the shadow's projection
+            basegfx::B3DRange aContained3DRange(rContained3DRange);
+            aContained3DRange.transform(getWorldToEye());
+            maPlanePoint.setX(maShadowPlaneNormal.getX() < 0.0 ? aContained3DRange.getMinX() : aContained3DRange.getMaxX());
+            maPlanePoint.setY(maShadowPlaneNormal.getY() > 0.0 ? aContained3DRange.getMinY() : aContained3DRange.getMaxY());
+            maPlanePoint.setZ(aContained3DRange.getMinZ() - (aContained3DRange.getDepth() / 8.0));
+
+            // set flag that shadow projection is prepared and allowed
+            mbShadowProjectionIsValid = true;
+        }
+
+        Shadow3DExtractingProcessor::~Shadow3DExtractingProcessor()
+        {
+            OSL_ENSURE(maPrimitive2DSequence.empty(),
+                "OOps, someone used Shadow3DExtractingProcessor, but did not fetch the results (!)");
+        }
+
+        basegfx::B2DPolygon Shadow3DExtractingProcessor::impDoShadowProjection(const basegfx::B3DPolygon& rSource)
+        {
+            basegfx::B2DPolygon aRetval;
+
+            for(sal_uInt32 a(0); a < rSource.count(); a++)
+            {
+                // get point, transform to eye coordinate system
+                basegfx::B3DPoint aCandidate(rSource.getB3DPoint(a));
+                aCandidate *= getWorldToEye();
+
+                // we are in eye coordinates
+                // ray is (aCandidate + fCut * maLightNormal)
+                // plane is (maPlanePoint, maShadowPlaneNormal)
+                // maLightNormal.scalar(maShadowPlaneNormal) is already in mfLightPlaneScalar and > 0.0
+                // get cut point of ray with shadow plane
+                const double fCut(basegfx::B3DVector(maPlanePoint - aCandidate).scalar(maShadowPlaneNormal) / mfLightPlaneScalar);
+                aCandidate += maLightNormal * fCut;
+
+                // transform to view, use 2d coordinates
+                aCandidate *= maEyeToView;
+                aRetval.append(basegfx::B2DPoint(aCandidate.getX(), aCandidate.getY()));
+            }
+
+            // copy closed flag
+            aRetval.setClosed(rSource.isClosed());
+
+            return aRetval;
+        }
+
+        basegfx::B2DPolyPolygon Shadow3DExtractingProcessor::impDoShadowProjection(const basegfx::B3DPolyPolygon& rSource)
+        {
+            basegfx::B2DPolyPolygon aRetval;
+
+            for(sal_uInt32 a(0); a < rSource.count(); a++)
+            {
+                aRetval.append(impDoShadowProjection(rSource.getB3DPolygon(a)));
+            }
+
+            return aRetval;
+        }
+
+        const primitive2d::Primitive2DContainer& Shadow3DExtractingProcessor::getPrimitive2DSequence() const
+        {
+            return maPrimitive2DSequence;
+        }
+
+} // end of namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/drawinglayer/source/processor3d/zbufferprocessor3d.cxx b/drawinglayer/source/processor3d/zbufferprocessor3d.cxx
new file mode 100644
index 000000000..aa319161b
--- /dev/null
+++ b/drawinglayer/source/processor3d/zbufferprocessor3d.cxx
@@ -0,0 +1,638 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include <processor3d/zbufferprocessor3d.hxx>
+#include <basegfx/raster/bzpixelraster.hxx>
+#include <basegfx/raster/rasterconvert3d.hxx>
+#include <drawinglayer/attribute/materialattribute3d.hxx>
+#include <texture/texture.hxx>
+#include <basegfx/polygon/b3dpolygon.hxx>
+#include <basegfx/polygon/b3dpolypolygon.hxx>
+#include <basegfx/polygon/b3dpolygontools.hxx>
+#include <basegfx/polygon/b3dpolypolygontools.hxx>
+#include <drawinglayer/attribute/sdrlightingattribute3d.hxx>
+#include <o3tl/safeint.hxx>
+#include <svtools/optionsdrawinglayer.hxx>
+
+using namespace com::sun::star;
+
+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 rasterconversion
+    const drawinglayer::attribute::MaterialAttribute3D*     mpCurrentMaterial;
+
+    // some boolean flags for line span interpolator usages
+    bool                                                    mbModifyColor : 1;
+    bool                                                    mbUseTex : 1;
+    bool                                                    mbHasTexCoor : 1;
+    bool                                                    mbHasInvTexCoor : 1;
+    bool                                                    mbUseNrm : 1;
+    bool                                                    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) const
+    {
+        // init values with full opacity and material color
+        OSL_ENSURE(nullptr != 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())
+            {
+                // 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())
+            {
+                // 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())
+            {
+                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() || mrProcessor.getTransparenceGeoTexSvx());
+        mbUseTex = bTextureActive && (mbHasTexCoor || mbHasInvTexCoor || mrProcessor.getSimpleTextureActive());
+        const bool bUseColorTex(mbUseTex && mrProcessor.getGeoTexSvx());
+        const bool bNeedNrmOrCol(!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) override;
+
+public:
+    ZBufferRasterConverter3D(basegfx::BZPixelRaster& rBuffer, const drawinglayer::processor3d::ZBufferProcessor3D& rProcessor)
+    :   mrProcessor(rProcessor),
+        mrBuffer(rBuffer),
+        mpCurrentMaterial(nullptr),
+        mbModifyColor(false),
+        mbUseTex(false),
+        mbHasTexCoor(false),
+        mbHasInvTexCoor(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)
+        return;
+
+    if(nLine < 0 || o3tl::make_unsigned(nLine) >= mrBuffer.getHeight())
+        return;
+
+    sal_uInt32 nXA(std::min(mrBuffer.getWidth(), static_cast<sal_uInt32>(std::max(sal_Int32(0), basegfx::fround(rA.getX().getVal())))));
+    const sal_uInt32 nXB(std::min(mrBuffer.getWidth(), static_cast<sal_uInt32>(std::max(sal_Int32(0), basegfx::fround(rB.getX().getVal())))));
+
+    if(nXA >= nXB)
+        return;
+
+    // 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::clamp(maIntZ.getVal(), 0.0, 65535.0));
+        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.getAlpha())
+                    {
+                        // mix new color by using
+                        // color' = color * (1 - opacity) + newcolor * opacity
+                        const sal_uInt16 nTransparence(255 - nOpacity);
+                        rDest.setRed(static_cast<sal_uInt8>(((rDest.getRed() * nTransparence) + (static_cast<sal_uInt16>(255.0 * aNewColor.getRed()) * nOpacity)) >> 8));
+                        rDest.setGreen(static_cast<sal_uInt8>(((rDest.getGreen() * nTransparence) + (static_cast<sal_uInt16>(255.0 * aNewColor.getGreen()) * nOpacity)) >> 8));
+                        rDest.setBlue(static_cast<sal_uInt8>(((rDest.getBlue() * nTransparence) + (static_cast<sal_uInt16>(255.0 * aNewColor.getBlue()) * nOpacity)) >> 8));
+
+                        if(255 != rDest.getAlpha())
+                        {
+                            // both are transparent, mix new opacity by using
+                            // opacity = newopacity * (1 - oldopacity) + oldopacity
+                            rDest.setAlpha(static_cast<sal_uInt8>((nOpacity * (255 - rDest.getAlpha())) >> 8) + rDest.getAlpha());
+                        }
+                    }
+                    else
+                    {
+                        // dest is unused, set color
+                        rDest = basegfx::BPixel(aNewColor, static_cast<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:
+    std::shared_ptr< drawinglayer::texture::GeoTexSvx >     mpGeoTexSvx;
+    std::shared_ptr< drawinglayer::texture::GeoTexSvx >     mpTransparenceGeoTexSvx;
+    drawinglayer::attribute::MaterialAttribute3D              maMaterial;
+    basegfx::B3DPolyPolygon                                   maPolyPolygon;
+    double                                                    mfCenterZ;
+
+    bool                                                      mbModulate : 1;
+    bool                                                      mbFilter : 1;
+    bool                                                      mbSimpleTextureActive : 1;
+    bool                                                      mbIsLine : 1;
+
+public:
+    RasterPrimitive3D(
+        const std::shared_ptr< drawinglayer::texture::GeoTexSvx >& pGeoTexSvx,
+        const std::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::utils::getRange(rPolyPolygon).getCenter().getZ()),
+        mbModulate(bModulate),
+        mbFilter(bFilter),
+        mbSimpleTextureActive(bSimpleTextureActive),
+        mbIsLine(bIsLine)
+    {
+    }
+
+    bool operator<(const RasterPrimitive3D& rComp) const
+    {
+        return mfCenterZ < rComp.mfCenterZ;
+    }
+
+    const std::shared_ptr< drawinglayer::texture::GeoTexSvx >& getGeoTexSvx() const { return mpGeoTexSvx; }
+    const std::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::processor3d
+{
+        void ZBufferProcessor3D::rasterconvertB3DPolygon(const attribute::MaterialAttribute3D& rMaterial, const basegfx::B3DPolygon& rHairline) const
+        {
+            if(getTransparenceCounter())
+            {
+                // transparent output; record for later sorting and painting from
+                // back to front
+
+                maRasterPrimitive3Ds.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(SvtOptionsDrawinglayer::IsAntiAliasing() && SvtOptionsDrawinglayer::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::utils::snapPointsOfHorizontalOrVerticalEdges(aSnappedHairline);
+
+                        // add oversampling again
+                        aTransform.identity();
+                        aTransform.scale(fScaleUp, fScaleUp, 1.0);
+
+                        aSnappedHairline.transform(aTransform);
+
+                        mpZBufferRasterConverter3D->rasterconvertB3DPolygon(aSnappedHairline, mnStartLine, mnStopLine, mnAntiAlialize);
+                    }
+                    else
+                    {
+                        mpZBufferRasterConverter3D->rasterconvertB3DPolygon(rHairline, mnStartLine, mnStopLine, mnAntiAlialize);
+                    }
+                }
+                else
+                {
+                    mpZBufferRasterConverter3D->rasterconvertB3DPolygon(rHairline, mnStartLine, mnStopLine, 1);
+                }
+            }
+        }
+
+        void ZBufferProcessor3D::rasterconvertB3DPolyPolygon(const attribute::MaterialAttribute3D& rMaterial, const basegfx::B3DPolyPolygon& rFill) const
+        {
+            if(getTransparenceCounter())
+            {
+                // transparent output; record for later sorting and painting from
+                // back to front
+                maRasterPrimitive3Ds.push_back(RasterPrimitive3D(
+                    getGeoTexSvx(),
+                    getTransparenceGeoTexSvx(),
+                    rMaterial,
+                    rFill,
+                    getModulate(),
+                    getFilter(),
+                    getSimpleTextureActive(),
+                    false));
+            }
+            else
+            {
+                mpZBufferRasterConverter3D->setCurrentMaterial(rMaterial);
+                mpZBufferRasterConverter3D->rasterconvertB3DPolyPolygon(rFill, &maInvEyeToView, mnStartLine, mnStopLine);
+            }
+        }
+
+        ZBufferProcessor3D::ZBufferProcessor3D(
+            const geometry::ViewInformation3D& rViewInformation3D,
+            const attribute::SdrSceneAttribute& rSdrSceneAttribute,
+            const attribute::SdrLightingAttribute& rSdrLightingAttribute,
+            const basegfx::B2DRange& rVisiblePart,
+            sal_uInt16 nAntiAlialize,
+            double fFullViewSizeX,
+            double fFullViewSizeY,
+            basegfx::BZPixelRaster& rBZPixelRaster,
+            sal_uInt32 nStartLine,
+            sal_uInt32 nStopLine)
+        :   DefaultProcessor3D(rViewInformation3D, rSdrSceneAttribute, rSdrLightingAttribute),
+            mnAntiAlialize(nAntiAlialize),
+            mnStartLine(nStartLine),
+            mnStopLine(nStopLine)
+        {
+            // 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 coordinates
+                //
+                // #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, nStartLine));
+            maRasterRange.expand(basegfx::B2DPoint(rBZPixelRaster.getWidth(), nStopLine));
+
+            // create the raster converter
+            mpZBufferRasterConverter3D.reset( new ZBufferRasterConverter3D(rBZPixelRaster, *this) );
+        }
+
+        ZBufferProcessor3D::~ZBufferProcessor3D()
+        {
+            mpZBufferRasterConverter3D.reset();
+
+            if(!maRasterPrimitive3Ds.empty())
+            {
+                OSL_FAIL("ZBufferProcessor3D: destructed, but there are unrendered transparent geometries. Use ZBufferProcessor3D::finish() to render these (!)");
+            }
+        }
+
+        void ZBufferProcessor3D::finish()
+        {
+            if(maRasterPrimitive3Ds.empty())
+                return;
+
+            // there are transparent rasterprimitives
+            const sal_uInt32 nSize(maRasterPrimitive3Ds.size());
+
+            if(nSize > 1)
+            {
+                // sort them from back to front
+                std::sort(maRasterPrimitive3Ds.begin(), maRasterPrimitive3Ds.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 = maRasterPrimitive3Ds[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
+            maRasterPrimitive3Ds.clear();
+        }
+
+} // end of namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */