xref: /aoo41x/main/drawinglayer/source/primitive2d/sceneprimitive2d.cxx (revision 78d93489)

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



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

#include <drawinglayer/primitive2d/sceneprimitive2d.hxx>
#include <basegfx/tools/canvastools.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/polygon/b2dpolygonclipper.hxx>
#include <basegfx/polygon/b2dpolypolygontools.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
#include <drawinglayer/processor3d/zbufferprocessor3d.hxx>
#include <drawinglayer/processor3d/shadow3dextractor.hxx>
#include <drawinglayer/geometry/viewinformation2d.hxx>
#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
#include <svtools/optionsdrawinglayer.hxx>
#include <drawinglayer/processor3d/geometry2dextractor.hxx>
#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>

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

using namespace com::sun::star;

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

namespace drawinglayer
{
	namespace primitive2d
	{
		bool ScenePrimitive2D::impGetShadow3D(const geometry::ViewInformation2D& /*rViewInformation*/) const
		{
            ::osl::MutexGuard aGuard( m_aMutex );

			// create on demand
			if(!mbShadow3DChecked && getChildren3D().hasElements())
			{
				basegfx::B3DVector aLightNormal;
                const double fShadowSlant(getSdrSceneAttribute().getShadowSlant());
				const basegfx::B3DRange aScene3DRange(primitive3d::getB3DRangeFromPrimitive3DSequence(getChildren3D(), getViewInformation3D()));

				if(maSdrLightingAttribute.getLightVector().size())
				{
					// get light normal from first light and normalize
					aLightNormal = maSdrLightingAttribute.getLightVector()[0].getDirection();
					aLightNormal.normalize();
				}

				// create shadow extraction processor
				processor3d::Shadow3DExtractingProcessor aShadowProcessor(
					getViewInformation3D(),
					getObjectTransformation(),
					aLightNormal,
					fShadowSlant,
                    aScene3DRange);

				// process local primitives
				aShadowProcessor.process(getChildren3D());

				// fetch result and set checked flag
				const_cast< ScenePrimitive2D* >(this)->maShadowPrimitives = aShadowProcessor.getPrimitive2DSequence();
				const_cast< ScenePrimitive2D* >(this)->mbShadow3DChecked = true;
			}

			// return if there are shadow primitives
			return maShadowPrimitives.hasElements();
		}

        void ScenePrimitive2D::calculateDiscreteSizes(
			const geometry::ViewInformation2D& rViewInformation,
			basegfx::B2DRange& rDiscreteRange,
			basegfx::B2DRange& rVisibleDiscreteRange,
			basegfx::B2DRange& rUnitVisibleRange) const
		{
			// use unit range and transform to discrete coordinates
			rDiscreteRange = basegfx::B2DRange(0.0, 0.0, 1.0, 1.0);
			rDiscreteRange.transform(rViewInformation.getObjectToViewTransformation() * getObjectTransformation());

			// clip it against discrete Viewport (if set)
			rVisibleDiscreteRange = rDiscreteRange;

			if(!rViewInformation.getViewport().isEmpty())
			{
				rVisibleDiscreteRange.intersect(rViewInformation.getDiscreteViewport());
			}

			if(rVisibleDiscreteRange.isEmpty())
			{
				rUnitVisibleRange = rVisibleDiscreteRange;
			}
			else
			{
				// create UnitVisibleRange containing unit range values [0.0 .. 1.0] describing
				// the relative position of rVisibleDiscreteRange inside rDiscreteRange
				const double fDiscreteScaleFactorX(basegfx::fTools::equalZero(rDiscreteRange.getWidth()) ? 1.0 : 1.0 / rDiscreteRange.getWidth());
				const double fDiscreteScaleFactorY(basegfx::fTools::equalZero(rDiscreteRange.getHeight()) ? 1.0 : 1.0 / rDiscreteRange.getHeight());

				const double fMinX(basegfx::fTools::equal(rVisibleDiscreteRange.getMinX(), rDiscreteRange.getMinX())
					? 0.0
					: (rVisibleDiscreteRange.getMinX() - rDiscreteRange.getMinX()) * fDiscreteScaleFactorX);
				const double fMinY(basegfx::fTools::equal(rVisibleDiscreteRange.getMinY(), rDiscreteRange.getMinY())
					? 0.0
					: (rVisibleDiscreteRange.getMinY() - rDiscreteRange.getMinY()) * fDiscreteScaleFactorY);

				const double fMaxX(basegfx::fTools::equal(rVisibleDiscreteRange.getMaxX(), rDiscreteRange.getMaxX())
					? 1.0
					: (rVisibleDiscreteRange.getMaxX() - rDiscreteRange.getMinX()) * fDiscreteScaleFactorX);
				const double fMaxY(basegfx::fTools::equal(rVisibleDiscreteRange.getMaxY(), rDiscreteRange.getMaxY())
					? 1.0
					: (rVisibleDiscreteRange.getMaxY() - rDiscreteRange.getMinY()) * fDiscreteScaleFactorY);

				rUnitVisibleRange = basegfx::B2DRange(fMinX, fMinY, fMaxX, fMaxY);
			}
		}

		Primitive2DSequence ScenePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
		{
			Primitive2DSequence aRetval;

			// create 2D shadows from contained 3D primitives. This creates the shadow primitives on demand and tells if
			// there are some or not. Do this at start, the shadow might still be visible even when the scene is not
			if(impGetShadow3D(rViewInformation))
			{
				// test visibility
				const basegfx::B2DRange aShadow2DRange(
                    getB2DRangeFromPrimitive2DSequence(maShadowPrimitives, rViewInformation));
				const basegfx::B2DRange aViewRange(
                    rViewInformation.getViewport());

				if(aViewRange.isEmpty() || aShadow2DRange.overlaps(aViewRange))
				{
					// add extracted 2d shadows (before 3d scene creations itself)
					aRetval = maShadowPrimitives;
				}
			}

			// get the involved ranges (see helper method calculateDiscreteSizes for details)
			basegfx::B2DRange aDiscreteRange;
			basegfx::B2DRange aVisibleDiscreteRange;
			basegfx::B2DRange aUnitVisibleRange;

            calculateDiscreteSizes(rViewInformation, aDiscreteRange, aVisibleDiscreteRange, aUnitVisibleRange);

			if(!aVisibleDiscreteRange.isEmpty())
			{
				// test if discrete view size (pixel) maybe too big and limit it
				double fViewSizeX(aVisibleDiscreteRange.getWidth());
				double fViewSizeY(aVisibleDiscreteRange.getHeight());
				const double fViewVisibleArea(fViewSizeX * fViewSizeY);
                const SvtOptionsDrawinglayer aDrawinglayerOpt;
				const double fMaximumVisibleArea(aDrawinglayerOpt.GetQuadratic3DRenderLimit());
				double fReduceFactor(1.0);

				if(fViewVisibleArea > fMaximumVisibleArea)
				{
					fReduceFactor = sqrt(fMaximumVisibleArea / fViewVisibleArea);
					fViewSizeX *= fReduceFactor;
					fViewSizeY *= fReduceFactor;
				}

				if(rViewInformation.getReducedDisplayQuality())
				{
					// when reducing the visualisation is allowed (e.g. an OverlayObject
					// only needed for dragging), reduce resolution extra
					// to speed up dragging interactions
					const double fArea(fViewSizeX * fViewSizeY);
					double fReducedVisualisationFactor(1.0 / (sqrt(fArea) * (1.0 / 170.0)));

					if(fReducedVisualisationFactor > 1.0)
					{
						fReducedVisualisationFactor = 1.0;
					}
					else if(fReducedVisualisationFactor < 0.20)
					{
						fReducedVisualisationFactor = 0.20;
					}

					if(fReducedVisualisationFactor != 1.0)
					{
						fReduceFactor *= fReducedVisualisationFactor;
						fViewSizeX *= fReducedVisualisationFactor;
						fViewSizeY *= fReducedVisualisationFactor;
					}
				}

                // determine the oversample value
                static sal_uInt16 nDefaultOversampleValue(3);
                const sal_uInt16 nOversampleValue(aDrawinglayerOpt.IsAntiAliasing() ? nDefaultOversampleValue : 0);

                geometry::ViewInformation3D aViewInformation3D(getViewInformation3D());
                {
                    // calculate a transformation from DiscreteRange to evtl. rotated/sheared content.
                    // Start with full transformation from object to discrete units
                    basegfx::B2DHomMatrix aObjToUnit(rViewInformation.getObjectToViewTransformation() * getObjectTransformation());

                    // bring to unit coordinates by applying inverse DiscreteRange
                    aObjToUnit.translate(-aDiscreteRange.getMinX(), -aDiscreteRange.getMinY());
                    aObjToUnit.scale(1.0 / aDiscreteRange.getWidth(), 1.0 / aDiscreteRange.getHeight());

                    // calculate transformed user coordinate system
                    const basegfx::B2DPoint aStandardNull(0.0, 0.0);
                    const basegfx::B2DPoint aUnitRangeTopLeft(aObjToUnit * aStandardNull);
                    const basegfx::B2DVector aStandardXAxis(1.0, 0.0);
                    const basegfx::B2DVector aUnitRangeXAxis(aObjToUnit * aStandardXAxis);
                    const basegfx::B2DVector aStandardYAxis(0.0, 1.0);
                    const basegfx::B2DVector aUnitRangeYAxis(aObjToUnit * aStandardYAxis);

                    if(!aUnitRangeTopLeft.equal(aStandardNull) || !aUnitRangeXAxis.equal(aStandardXAxis) || !aUnitRangeYAxis.equal(aStandardYAxis))
                    {
                        // build transformation from unit range to user coordinate system; the unit range
                        // X and Y axes are the column vectors, the null point is the offset
                        basegfx::B2DHomMatrix aUnitRangeToUser;

                        aUnitRangeToUser.set3x2(
                            aUnitRangeXAxis.getX(), aUnitRangeYAxis.getX(), aUnitRangeTopLeft.getX(),
                            aUnitRangeXAxis.getY(), aUnitRangeYAxis.getY(), aUnitRangeTopLeft.getY());

                        // decompose to allow to apply this to the 3D transformation
                        basegfx::B2DVector aScale, aTranslate;
                        double fRotate, fShearX;
                        aUnitRangeToUser.decompose(aScale, aTranslate, fRotate, fShearX);

                        // apply before DeviceToView and after Projection, 3D is in range [-1.0 .. 1.0] in X,Y and Z
                        // and not yet flipped in Y
                        basegfx::B3DHomMatrix aExtendedProjection(aViewInformation3D.getProjection());

                        // bring to unit coordiantes, flip Y, leave Z unchanged
                        aExtendedProjection.scale(0.5, -0.5, 1.0);
                        aExtendedProjection.translate(0.5, 0.5, 0.0);

                        // apply extra; Y is flipped now, go with positive shear and rotate values
                        aExtendedProjection.scale(aScale.getX(), aScale.getY(), 1.0);
                        aExtendedProjection.shearXZ(fShearX, 0.0);
                        aExtendedProjection.rotate(0.0, 0.0, fRotate);
                        aExtendedProjection.translate(aTranslate.getX(), aTranslate.getY(), 0.0);

                        // back to state after projection
                        aExtendedProjection.translate(-0.5, -0.5, 0.0);
                        aExtendedProjection.scale(2.0, -2.0, 1.0);

                        aViewInformation3D = geometry::ViewInformation3D(
                            aViewInformation3D.getObjectTransformation(),
                            aViewInformation3D.getOrientation(),
                            aExtendedProjection,
                            aViewInformation3D.getDeviceToView(),
                            aViewInformation3D.getViewTime(),
                            aViewInformation3D.getExtendedInformationSequence());
                    }
                }

                // calculate logic render size in world coordinates for usage in renderer
                const basegfx::B2DHomMatrix aInverseOToV(rViewInformation.getInverseObjectToViewTransformation());
                const double fLogicX((aInverseOToV * basegfx::B2DVector(aDiscreteRange.getWidth() * fReduceFactor, 0.0)).getLength());
                const double fLogicY((aInverseOToV * basegfx::B2DVector(0.0, aDiscreteRange.getHeight() * fReduceFactor)).getLength());

			    // use default 3D primitive processor to create BitmapEx for aUnitVisiblePart and process
			    processor3d::ZBufferProcessor3D aZBufferProcessor3D(
                    aViewInformation3D,
					rViewInformation,
				    getSdrSceneAttribute(),
				    getSdrLightingAttribute(),
                    fLogicX,
                    fLogicY,
				    aUnitVisibleRange,
                    nOversampleValue);

			    aZBufferProcessor3D.process(getChildren3D());
			    aZBufferProcessor3D.finish();

                const_cast< ScenePrimitive2D* >(this)->maOldRenderedBitmap = aZBufferProcessor3D.getBitmapEx();
				const Size aBitmapSizePixel(maOldRenderedBitmap.GetSizePixel());

				if(aBitmapSizePixel.getWidth() && aBitmapSizePixel.getHeight())
				{
					// create transform for the created bitmap in discrete coordinates first.
					basegfx::B2DHomMatrix aNew2DTransform;

                    aNew2DTransform.set(0, 0, aVisibleDiscreteRange.getWidth());
					aNew2DTransform.set(1, 1, aVisibleDiscreteRange.getHeight());
					aNew2DTransform.set(0, 2, aVisibleDiscreteRange.getMinX());
					aNew2DTransform.set(1, 2, aVisibleDiscreteRange.getMinY());

					// transform back to world coordinates for usage in primitive creation
					aNew2DTransform *= aInverseOToV;

					// create bitmap primitive and add
					const Primitive2DReference xRef(new BitmapPrimitive2D(maOldRenderedBitmap, aNew2DTransform));
					appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, xRef);

					// test: Allow to add an outline in the debugger when tests are needed
					static bool bAddOutlineToCreated3DSceneRepresentation(false);

					if(bAddOutlineToCreated3DSceneRepresentation)
					{
						basegfx::B2DPolygon aOutline(basegfx::tools::createUnitPolygon());
						aOutline.transform(aNew2DTransform);
						const Primitive2DReference xRef2(new PolygonHairlinePrimitive2D(aOutline, basegfx::BColor(1.0, 0.0, 0.0)));
						appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, xRef2);
					}
				}
			}

			return aRetval;
		}

		Primitive2DSequence ScenePrimitive2D::getGeometry2D() const
		{
			Primitive2DSequence aRetval;

            // create 2D projected geometry from 3D geometry
			if(getChildren3D().hasElements())
			{
				// create 2D geometry extraction processor
				processor3d::Geometry2DExtractingProcessor aGeometryProcessor(
					getViewInformation3D(),
					getObjectTransformation());

				// process local primitives
				aGeometryProcessor.process(getChildren3D());

				// fetch result
				aRetval = aGeometryProcessor.getPrimitive2DSequence();
			}

			return aRetval;
		}

		Primitive2DSequence ScenePrimitive2D::getShadow2D(const geometry::ViewInformation2D& rViewInformation) const
		{
			Primitive2DSequence aRetval;

			// create 2D shadows from contained 3D primitives
			if(impGetShadow3D(rViewInformation))
			{
				// add extracted 2d shadows (before 3d scene creations itself)
				aRetval = maShadowPrimitives;
			}

			return aRetval;
		}

        bool ScenePrimitive2D::tryToCheckLastVisualisationDirectHit(const basegfx::B2DPoint& rLogicHitPoint, bool& o_rResult) const
        {
            if(!maOldRenderedBitmap.IsEmpty() && !maOldUnitVisiblePart.isEmpty())
            {
                basegfx::B2DHomMatrix aInverseSceneTransform(getObjectTransformation());
                aInverseSceneTransform.invert();
                const basegfx::B2DPoint aRelativePoint(aInverseSceneTransform * rLogicHitPoint);

                if(maOldUnitVisiblePart.isInside(aRelativePoint))
                {
                    // calculate coordinates relative to visualized part
                    double fDivisorX(maOldUnitVisiblePart.getWidth());
                    double fDivisorY(maOldUnitVisiblePart.getHeight());

                    if(basegfx::fTools::equalZero(fDivisorX))
                    {
                        fDivisorX = 1.0;
                    }

                    if(basegfx::fTools::equalZero(fDivisorY))
                    {
                        fDivisorY = 1.0;
                    }

                    const double fRelativeX((aRelativePoint.getX() - maOldUnitVisiblePart.getMinX()) / fDivisorX);
                    const double fRelativeY((aRelativePoint.getY() - maOldUnitVisiblePart.getMinY()) / fDivisorY);

                    // combine with real BitmapSizePixel to get bitmap coordinates
    				const Size aBitmapSizePixel(maOldRenderedBitmap.GetSizePixel());
                    const sal_Int32 nX(basegfx::fround(fRelativeX * aBitmapSizePixel.Width()));
                    const sal_Int32 nY(basegfx::fround(fRelativeY * aBitmapSizePixel.Height()));

                    // try to get a statement about transparency in that pixel
                    o_rResult = (0xff != maOldRenderedBitmap.GetTransparency(nX, nY));
                    return true;
                }
            }

            return false;
        }

		ScenePrimitive2D::ScenePrimitive2D(
			const primitive3d::Primitive3DSequence& rxChildren3D,
			const attribute::SdrSceneAttribute& rSdrSceneAttribute,
			const attribute::SdrLightingAttribute& rSdrLightingAttribute,
			const basegfx::B2DHomMatrix& rObjectTransformation,
			const geometry::ViewInformation3D& rViewInformation3D)
		:	BufferedDecompositionPrimitive2D(),
			mxChildren3D(rxChildren3D),
			maSdrSceneAttribute(rSdrSceneAttribute),
			maSdrLightingAttribute(rSdrLightingAttribute),
			maObjectTransformation(rObjectTransformation),
			maViewInformation3D(rViewInformation3D),
            maShadowPrimitives(),
			mbShadow3DChecked(false),
			mfOldDiscreteSizeX(0.0),
			mfOldDiscreteSizeY(0.0),
			maOldUnitVisiblePart(),
            maOldRenderedBitmap()
		{
		}

		bool ScenePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
		{
			if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
			{
				const ScenePrimitive2D& rCompare = (ScenePrimitive2D&)rPrimitive;

				return (primitive3d::arePrimitive3DSequencesEqual(getChildren3D(), rCompare.getChildren3D())
					&& getSdrSceneAttribute() == rCompare.getSdrSceneAttribute()
					&& getSdrLightingAttribute() == rCompare.getSdrLightingAttribute()
					&& getObjectTransformation() == rCompare.getObjectTransformation()
					&& getViewInformation3D() == rCompare.getViewInformation3D());
			}

			return false;
		}

		basegfx::B2DRange ScenePrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
		{
			// transform unit range to discrete coordinate range
			basegfx::B2DRange aRetval(0.0, 0.0, 1.0, 1.0);
			aRetval.transform(rViewInformation.getObjectToViewTransformation() * getObjectTransformation());

			// force to discrete expanded bounds (it grows, so expanding works perfectly well)
			aRetval.expand(basegfx::B2DTuple(floor(aRetval.getMinX()), floor(aRetval.getMinY())));
			aRetval.expand(basegfx::B2DTuple(ceil(aRetval.getMaxX()), ceil(aRetval.getMaxY())));

			// transform back from discrete (view) to world coordinates
			aRetval.transform(rViewInformation.getInverseObjectToViewTransformation());

			// expand by evtl. existing shadow primitives
			if(impGetShadow3D(rViewInformation))
			{
				const basegfx::B2DRange aShadow2DRange(getB2DRangeFromPrimitive2DSequence(maShadowPrimitives, rViewInformation));

				if(!aShadow2DRange.isEmpty())
				{
					aRetval.expand(aShadow2DRange);
				}
			}

			return aRetval;
		}

		Primitive2DSequence ScenePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
		{
			::osl::MutexGuard aGuard( m_aMutex );

			// get the involved ranges (see helper method calculateDiscreteSizes for details)
		    basegfx::B2DRange aDiscreteRange;
		    basegfx::B2DRange aUnitVisibleRange;
			bool bNeedNewDecomposition(false);
			bool bDiscreteSizesAreCalculated(false);

			if(getBuffered2DDecomposition().hasElements())
			{
			    basegfx::B2DRange aVisibleDiscreteRange;
			    calculateDiscreteSizes(rViewInformation, aDiscreteRange, aVisibleDiscreteRange, aUnitVisibleRange);
				bDiscreteSizesAreCalculated = true;

				// needs to be painted when the new part is not part of the last
                // decomposition
				if(!maOldUnitVisiblePart.isInside(aUnitVisibleRange))
                {
					bNeedNewDecomposition = true;
                }

                // display has changed and cannot be reused when resolution got bigger. It
                // can be reused when resolution got smaller, though.
				if(!bNeedNewDecomposition)
				{
				    if(basegfx::fTools::more(aDiscreteRange.getWidth(), mfOldDiscreteSizeX) ||
					    basegfx::fTools::more(aDiscreteRange.getHeight(), mfOldDiscreteSizeY))
				    {
					    bNeedNewDecomposition = true;
				    }
				}
			}

			if(bNeedNewDecomposition)
			{
				// conditions of last local decomposition have changed, delete
				const_cast< ScenePrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
			}

			if(!getBuffered2DDecomposition().hasElements())
			{
				if(!bDiscreteSizesAreCalculated)
				{
					basegfx::B2DRange aVisibleDiscreteRange;
					calculateDiscreteSizes(rViewInformation, aDiscreteRange, aVisibleDiscreteRange, aUnitVisibleRange);
				}

				// remember last used NewDiscreteSize and NewUnitVisiblePart
				ScenePrimitive2D* pThat = const_cast< ScenePrimitive2D* >(this);
				pThat->mfOldDiscreteSizeX = aDiscreteRange.getWidth();
				pThat->mfOldDiscreteSizeY = aDiscreteRange.getHeight();
				pThat->maOldUnitVisiblePart = aUnitVisibleRange;
			}

			// use parent implementation
			return BufferedDecompositionPrimitive2D::get2DDecomposition(rViewInformation);
		}

		// provide unique ID
		ImplPrimitrive2DIDBlock(ScenePrimitive2D, PRIMITIVE2D_ID_SCENEPRIMITIVE2D)

	} // end of namespace primitive2d
} // end of namespace drawinglayer

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