drawinglayer/source/primitive2d/sceneprimitive2d.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: sceneprimitive2d.cxx,v $
   6  *
   7  *  $Revision: 1.16 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-06-24 15:31:08 $
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 // MARKER(update_precomp.py): autogen include statement, do not remove
  37 #include "precompiled_drawinglayer.hxx"
  38
  39 #include <drawinglayer/primitive2d/sceneprimitive2d.hxx>
  40 #include <basegfx/tools/canvastools.hxx>
  41 #include <basegfx/polygon/b2dpolygontools.hxx>
  42 #include <basegfx/polygon/b2dpolygon.hxx>
  43 #include <basegfx/polygon/b2dpolygonclipper.hxx>
  44 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  45 #include <basegfx/matrix/b2dhommatrix.hxx>
  46 #include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
  47 #include <drawinglayer/processor3d/zbufferprocessor3d.hxx>
  48 #include <drawinglayer/processor3d/shadow3dextractor.hxx>
  49 #include <drawinglayer/geometry/viewinformation2d.hxx>
  50 #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
  51 #include <svtools/optionsdrawinglayer.hxx>
  52 #include <drawinglayer/processor3d/geometry2dextractor.hxx>
  53 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
  54
  55 //////////////////////////////////////////////////////////////////////////////
  56
  57 using namespace com::sun::star;
  58
  59 //////////////////////////////////////////////////////////////////////////////
  60
  61 namespace drawinglayer
  62 {
  63     namespace primitive2d
  64     {
  65         bool ScenePrimitive2D::impGetShadow3D(const geometry::ViewInformation2D& /*rViewInformation*/) const
  66         {
  67             ::osl::MutexGuard aGuard( m_aMutex );
  68
  69             // create on demand
  70             if(!mbShadow3DChecked && getChildren3D().hasElements())
  71             {
  72                 basegfx::B3DVector aLightNormal;
  73                 const double fShadowSlant(getSdrSceneAttribute().getShadowSlant());
  74                 const basegfx::B3DRange aScene3DRange(primitive3d::getB3DRangeFromPrimitive3DSequence(getChildren3D(), getViewInformation3D()));
  75
  76                 if(maSdrLightingAttribute.getLightVector().size())
  77                 {
  78                     // get light normal from first light and normalize
  79                     aLightNormal = maSdrLightingAttribute.getLightVector()[0].getDirection();
  80                     aLightNormal.normalize();
  81                 }
  82
  83                 // create shadow extraction processor
  84                 processor3d::Shadow3DExtractingProcessor aShadowProcessor(
  85                     getViewInformation3D(),
  86                     getObjectTransformation(),
  87                     aLightNormal,
  88                     fShadowSlant,
  89                     aScene3DRange);
  90
  91                 // process local primitives
  92                 aShadowProcessor.process(getChildren3D());
  93
  94                 // fetch result and set checked flag
  95                 const_cast< ScenePrimitive2D* >(this)->maShadowPrimitives = aShadowProcessor.getPrimitive2DSequence();
  96                 const_cast< ScenePrimitive2D* >(this)->mbShadow3DChecked = true;
  97             }
  98
  99             // return if there are shadow primitives
 100             return maShadowPrimitives.hasElements();
 101         }
 102
 103         void ScenePrimitive2D::calculateDsicreteSizes(
 104             const geometry::ViewInformation2D& rViewInformation,
 105             basegfx::B2DRange& rDiscreteRange,
 106             basegfx::B2DRange& rVisibleDiscreteRange,
 107             basegfx::B2DRange& rUnitVisibleRange) const
 108         {
 109             // use unit range and transform to discrete coordinates
 110             rDiscreteRange = basegfx::B2DRange(0.0, 0.0, 1.0, 1.0);
 111             rDiscreteRange.transform(rViewInformation.getObjectToViewTransformation() * getObjectTransformation());
 112
 113             // force to discrete expanded bounds (it grows, so expanding works perfectly well)
 114             rDiscreteRange.expand(basegfx::B2DTuple(floor(rDiscreteRange.getMinX()), floor(rDiscreteRange.getMinY())));
 115             rDiscreteRange.expand(basegfx::B2DTuple(ceil(rDiscreteRange.getMaxX()), ceil(rDiscreteRange.getMaxY())));
 116
 117             // clip it against discrete Viewport (if set)
 118             rVisibleDiscreteRange = rDiscreteRange;
 119
 120             if(!rViewInformation.getViewport().isEmpty())
 121             {
 122                 rVisibleDiscreteRange.intersect(rViewInformation.getDiscreteViewport());
 123
 124                 if(!rVisibleDiscreteRange.isEmpty())
 125                 {
 126                     // force to discrete expanded bounds, too
 127                     rVisibleDiscreteRange.expand(basegfx::B2DTuple(floor(rVisibleDiscreteRange.getMinX()), floor(rVisibleDiscreteRange.getMinY())));
 128                     rVisibleDiscreteRange.expand(basegfx::B2DTuple(ceil(rVisibleDiscreteRange.getMaxX()), ceil(rVisibleDiscreteRange.getMaxY())));
 129                 }
 130             }
 131
 132             if(rVisibleDiscreteRange.isEmpty())
 133             {
 134                 rUnitVisibleRange = rVisibleDiscreteRange;
 135             }
 136             else
 137             {
 138                 // create UnitVisibleRange containing unit range values [0.0 .. 1.0] describing
 139                 // the relative position of rVisibleDiscreteRange inside rDiscreteRange
 140                 const double fDiscreteScaleFactorX(basegfx::fTools::equalZero(rDiscreteRange.getWidth()) ? 1.0 : 1.0 / rDiscreteRange.getWidth());
 141                 const double fDiscreteScaleFactorY(basegfx::fTools::equalZero(rDiscreteRange.getHeight()) ? 1.0 : 1.0 / rDiscreteRange.getHeight());
 142
 143                 const double fMinX(basegfx::fTools::equal(rVisibleDiscreteRange.getMinX(), rDiscreteRange.getMinX())
 144                     ? 0.0
 145                     : (rVisibleDiscreteRange.getMinX() - rDiscreteRange.getMinX()) * fDiscreteScaleFactorX);
 146                 const double fMinY(basegfx::fTools::equal(rVisibleDiscreteRange.getMinY(), rDiscreteRange.getMinY())
 147                     ? 0.0
 148                     : (rVisibleDiscreteRange.getMinY() - rDiscreteRange.getMinY()) * fDiscreteScaleFactorY);
 149
 150                 const double fMaxX(basegfx::fTools::equal(rVisibleDiscreteRange.getMaxX(), rDiscreteRange.getMaxX())
 151                     ? 1.0
 152                     : (rVisibleDiscreteRange.getMaxX() - rDiscreteRange.getMinX()) * fDiscreteScaleFactorX);
 153                 const double fMaxY(basegfx::fTools::equal(rVisibleDiscreteRange.getMaxY(), rDiscreteRange.getMaxY())
 154                     ? 1.0
 155                     : (rVisibleDiscreteRange.getMaxY() - rDiscreteRange.getMinY()) * fDiscreteScaleFactorY);
 156
 157                 rUnitVisibleRange = basegfx::B2DRange(fMinX, fMinY, fMaxX, fMaxY);
 158             }
 159         }
 160
 161         Primitive2DSequence ScenePrimitive2D::createLocalDecomposition(const geometry::ViewInformation2D& rViewInformation) const
 162         {
 163             Primitive2DSequence aRetval;
 164
 165             // create 2D shadows from contained 3D primitives. This creates the shadow primitives on demand and tells if
 166             // there are some or not. Do this at start, the shadow might still be visible even when the scene is not
 167             if(impGetShadow3D(rViewInformation))
 168             {
 169                 // test visibility
 170                 const basegfx::B2DRange aShadow2DRange(getB2DRangeFromPrimitive2DSequence(maShadowPrimitives, rViewInformation));
 171                 const basegfx::B2DRange aViewRange(rViewInformation.getViewport());
 172
 173                 if(aViewRange.isEmpty() || aShadow2DRange.overlaps(aViewRange))
 174                 {
 175                     // add extracted 2d shadows (before 3d scene creations itself)
 176                     aRetval = maShadowPrimitives;
 177                 }
 178             }
 179
 180             // get the involved ranges (see helper method calculateDsicreteSizes for details)
 181             basegfx::B2DRange aDiscreteRange;
 182             basegfx::B2DRange aVisibleDiscreteRange;
 183             basegfx::B2DRange aUnitVisibleRange;
 184             calculateDsicreteSizes(rViewInformation, aDiscreteRange, aVisibleDiscreteRange, aUnitVisibleRange);
 185
 186             if(!aVisibleDiscreteRange.isEmpty())
 187             {
 188                 // test if discrete view size (pixel) maybe too big and limit it
 189                 double fViewSizeX(aVisibleDiscreteRange.getWidth());
 190                 double fViewSizeY(aVisibleDiscreteRange.getHeight());
 191                 const double fViewVisibleArea(fViewSizeX * fViewSizeY);
 192                 const SvtOptionsDrawinglayer aDrawinglayerOpt;
 193                 const double fMaximumVisibleArea(aDrawinglayerOpt.GetQuadratic3DRenderLimit());
 194                 double fReduceFactor(1.0);
 195
 196                 if(fViewVisibleArea > fMaximumVisibleArea)
 197                 {
 198                     fReduceFactor = sqrt(fMaximumVisibleArea / fViewVisibleArea);
 199                     fViewSizeX *= fReduceFactor;
 200                     fViewSizeY *= fReduceFactor;
 201                 }
 202
 203                 // calculate logic render size in world coordinates for usage in renderer
 204                 basegfx::B2DVector aLogicRenderSize(
 205                     aDiscreteRange.getWidth() * fReduceFactor,
 206                     aDiscreteRange.getHeight() * fReduceFactor);
 207                 aLogicRenderSize *= rViewInformation.getInverseObjectToViewTransformation();
 208
 209                 // determine the oversample value
 210                 static bool bDoOversample(false);
 211                 static sal_uInt16 nDefaultOversampleValue(3);
 212                 const sal_uInt16 nOversampleValue((bDoOversample || aDrawinglayerOpt.IsAntiAliasing()) ? nDefaultOversampleValue : 0);
 213
 214                 // use default 3D primitive processor to create BitmapEx for aUnitVisiblePart and process
 215                 processor3d::ZBufferProcessor3D aZBufferProcessor3D(
 216                     getViewInformation3D(),
 217                     rViewInformation,
 218                     getSdrSceneAttribute(),
 219                     getSdrLightingAttribute(),
 220                     aLogicRenderSize.getX(),
 221                     aLogicRenderSize.getY(),
 222                     aUnitVisibleRange,
 223                     nOversampleValue);
 224
 225                 aZBufferProcessor3D.processNonTransparent(getChildren3D());
 226                 aZBufferProcessor3D.processTransparent(getChildren3D());
 227                 const BitmapEx aNewBitmap(aZBufferProcessor3D.getBitmapEx());
 228                 const Size aBitmapSizePixel(aNewBitmap.GetSizePixel());
 229
 230                 if(aBitmapSizePixel.getWidth() && aBitmapSizePixel.getHeight())
 231                 {
 232                     // create transform for the created bitmap in discrete coordinates first.
 233                     // #i97772# Do not forget to apply evtl. render size reduction to scaling
 234                     basegfx::B2DHomMatrix aNew2DTransform;
 235                     const double fSizeReductionFactor(1.0 / fReduceFactor);
 236
 237                     aNew2DTransform.set(0, 0, (double)(aBitmapSizePixel.getWidth() - 1) * fSizeReductionFactor);
 238                     aNew2DTransform.set(1, 1, (double)(aBitmapSizePixel.getHeight() - 1) * fSizeReductionFactor);
 239                     aNew2DTransform.set(0, 2, aVisibleDiscreteRange.getMinX());
 240                     aNew2DTransform.set(1, 2, aVisibleDiscreteRange.getMinY());
 241
 242                     // transform back to world coordinates for usage in primitive creation
 243                     aNew2DTransform *= rViewInformation.getInverseObjectToViewTransformation();
 244
 245                     // create bitmap primitive and add
 246                     const Primitive2DReference xRef(new BitmapPrimitive2D(aNewBitmap, aNew2DTransform));
 247                     appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, xRef);
 248
 249                     // test: Allow to add an outline in the debugger when tests are needed
 250                     static bool bAddOutlineToCreated3DSceneRepresentation(false);
 251
 252                     if(bAddOutlineToCreated3DSceneRepresentation)
 253                     {
 254                         basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(basegfx::B2DRange(0.0, 0.0, 1.0, 1.0)));
 255                         aOutline.transform(aNew2DTransform);
 256                         const Primitive2DReference xRef2(new PolygonHairlinePrimitive2D(aOutline, basegfx::BColor(1.0, 0.0, 0.0)));
 257                         appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, xRef2);
 258                     }
 259                 }
 260             }
 261
 262             return aRetval;
 263         }
 264
 265         Primitive2DSequence ScenePrimitive2D::getGeometry2D(const geometry::ViewInformation2D& rViewInformation) const
 266         {
 267             Primitive2DSequence aRetval;
 268
 269             // create 2D shadows from contained 3D primitives
 270             if(impGetShadow3D(rViewInformation))
 271             {
 272                 // add extracted 2d shadows (before 3d scene creations itself)
 273                 aRetval = maShadowPrimitives;
 274             }
 275
 276             // create 2D projected geometry from 3D geometry
 277             if(getChildren3D().hasElements())
 278             {
 279                 // create 2D geometry extraction processor
 280                 processor3d::Geometry2DExtractingProcessor aGeometryProcessor(
 281                     getViewInformation3D(),
 282                     getObjectTransformation());
 283
 284                 // process local primitives
 285                 aGeometryProcessor.process(getChildren3D());
 286
 287                 // fetch result and append
 288                 Primitive2DSequence a2DExtractedPrimitives(aGeometryProcessor.getPrimitive2DSequence());
 289                 appendPrimitive2DSequenceToPrimitive2DSequence(aRetval, a2DExtractedPrimitives);
 290             }
 291
 292             return aRetval;
 293         }
 294
 295         ScenePrimitive2D::ScenePrimitive2D(
 296             const primitive3d::Primitive3DSequence& rxChildren3D,
 297             const attribute::SdrSceneAttribute& rSdrSceneAttribute,
 298             const attribute::SdrLightingAttribute& rSdrLightingAttribute,
 299             const basegfx::B2DHomMatrix& rObjectTransformation,
 300             const geometry::ViewInformation3D& rViewInformation3D)
 301         :       BasePrimitive2D(),
 302             mxChildren3D(rxChildren3D),
 303             maSdrSceneAttribute(rSdrSceneAttribute),
 304             maSdrLightingAttribute(rSdrLightingAttribute),
 305             maObjectTransformation(rObjectTransformation),
 306             maViewInformation3D(rViewInformation3D),
 307             maShadowPrimitives(),
 308             mbShadow3DChecked(false),
 309             mfOldDiscreteSizeX(0.0),
 310             mfOldDiscreteSizeY(0.0),
 311             maOldUnitVisiblePart()
 312         {
 313         }
 314
 315         bool ScenePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 316         {
 317             if(BasePrimitive2D::operator==(rPrimitive))
 318             {
 319                 const ScenePrimitive2D& rCompare = (ScenePrimitive2D&)rPrimitive;
 320
 321                 return (primitive3d::arePrimitive3DSequencesEqual(getChildren3D(), rCompare.getChildren3D())
 322                     && getSdrSceneAttribute() == rCompare.getSdrSceneAttribute()
 323                     && getSdrLightingAttribute() == rCompare.getSdrLightingAttribute()
 324                     && getObjectTransformation() == rCompare.getObjectTransformation()
 325                     && getViewInformation3D() == rCompare.getViewInformation3D());
 326             }
 327
 328             return false;
 329         }
 330
 331         basegfx::B2DRange ScenePrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
 332         {
 333             // transform unit range to discrete coordinate range
 334             basegfx::B2DRange aRetval(0.0, 0.0, 1.0, 1.0);
 335             aRetval.transform(rViewInformation.getObjectToViewTransformation() * getObjectTransformation());
 336
 337             // force to discrete expanded bounds (it grows, so expanding works perfectly well)
 338             aRetval.expand(basegfx::B2DTuple(floor(aRetval.getMinX()), floor(aRetval.getMinY())));
 339             aRetval.expand(basegfx::B2DTuple(ceil(aRetval.getMaxX()), ceil(aRetval.getMaxY())));
 340
 341             // transform back from discrete (view) to world coordinates
 342             aRetval.transform(rViewInformation.getInverseObjectToViewTransformation());
 343
 344             // expand by evtl. existing shadow primitives
 345             if(impGetShadow3D(rViewInformation))
 346             {
 347                 const basegfx::B2DRange aShadow2DRange(getB2DRangeFromPrimitive2DSequence(maShadowPrimitives, rViewInformation));
 348
 349                 if(!aShadow2DRange.isEmpty())
 350                 {
 351                     aRetval.expand(aShadow2DRange);
 352                 }
 353             }
 354
 355             return aRetval;
 356         }
 357
 358         Primitive2DSequence ScenePrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
 359         {
 360             ::osl::MutexGuard aGuard( m_aMutex );
 361
 362             // get the involved ranges (see helper method calculateDsicreteSizes for details)
 363             basegfx::B2DRange aDiscreteRange;
 364             basegfx::B2DRange aUnitVisibleRange;
 365             bool bNeedNewDecomposition(false);
 366             bool bDiscreteSizesAreCalculated(false);
 367
 368             if(getLocalDecomposition().hasElements())
 369             {
 370                 basegfx::B2DRange aVisibleDiscreteRange;
 371                 calculateDsicreteSizes(rViewInformation, aDiscreteRange, aVisibleDiscreteRange, aUnitVisibleRange);
 372                 bDiscreteSizesAreCalculated = true;
 373
 374                 // display has changed and cannot be reused when resolution did change
 375                 if(!basegfx::fTools::equal(aDiscreteRange.getWidth(), mfOldDiscreteSizeX) ||
 376                     !basegfx::fTools::equal(aDiscreteRange.getHeight(), mfOldDiscreteSizeY))
 377                 {
 378                     bNeedNewDecomposition = true;
 379                 }
 380
 381                 if(!bNeedNewDecomposition)
 382                 {
 383                     // needs to be painted when the new part is not part of the last
 384                     // decomposition
 385                     if(!maOldUnitVisiblePart.isInside(aUnitVisibleRange))
 386                     {
 387                         bNeedNewDecomposition = true;
 388                     }
 389                 }
 390             }
 391
 392             if(bNeedNewDecomposition)
 393             {
 394                 // conditions of last local decomposition have changed, delete
 395                 const_cast< ScenePrimitive2D* >(this)->setLocalDecomposition(Primitive2DSequence());
 396             }
 397
 398             if(!getLocalDecomposition().hasElements())
 399             {
 400                 if(!bDiscreteSizesAreCalculated)
 401                 {
 402                     basegfx::B2DRange aVisibleDiscreteRange;
 403                     calculateDsicreteSizes(rViewInformation, aDiscreteRange, aVisibleDiscreteRange, aUnitVisibleRange);
 404                 }
 405
 406                 // remember last used NewDiscreteSize and NewUnitVisiblePart
 407                 ScenePrimitive2D* pThat = const_cast< ScenePrimitive2D* >(this);
 408                 pThat->mfOldDiscreteSizeX = aDiscreteRange.getWidth();
 409                 pThat->mfOldDiscreteSizeY = aDiscreteRange.getHeight();
 410                 pThat->maOldUnitVisiblePart = aUnitVisibleRange;
 411             }
 412
 413             // use parent implementation
 414             return BasePrimitive2D::get2DDecomposition(rViewInformation);
 415         }
 416
 417         // provide unique ID
 418         ImplPrimitrive2DIDBlock(ScenePrimitive2D, PRIMITIVE2D_ID_SCENEPRIMITIVE2D)
 419
 420     } // end of namespace primitive2d
 421 } // end of namespace drawinglayer
 422
 423 //////////////////////////////////////////////////////////////////////////////
 424 // eof