svx/source/engine3d/obj3d.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <o3tl/numeric.hxx>
  21
  22 #include <svx/strings.hrc>
  23 #include <svx/dialmgr.hxx>
  24 #include <svx/svdhdl.hxx>
  25 #include <svx/svdmodel.hxx>
  26 #include <svx/svdobjkind.hxx>
  27 #include <svx/scene3d.hxx>
  28 #include <svx/obj3d.hxx>
  29 #include <sdr/properties/e3dproperties.hxx>
  30 #include <sdr/properties/e3dcompoundproperties.hxx>
  31 #include <basegfx/polygon/b3dpolypolygontools.hxx>
  32 #include <basegfx/point/b3dpoint.hxx>
  33 #include <basegfx/matrix/b3dhommatrix.hxx>
  34 #include <basegfx/matrix/b2dhommatrix.hxx>
  35 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  36 #include <svx/helperhittest3d.hxx>
  37 #include <sdr/contact/viewcontactofe3d.hxx>
  38 #include <drawinglayer/geometry/viewinformation3d.hxx>
  39 #include <com/sun/star/uno/Sequence.h>
  40 #include <svx/sdr/contact/viewcontactofe3dscene.hxx>
  41 #include <svx/e3dsceneupdater.hxx>
  42 #include <comphelper/configuration.hxx>
  43
  44 using namespace com::sun::star;
  45
  46 std::unique_ptr<sdr::properties::BaseProperties> E3dObject::CreateObjectSpecificProperties()
  47 {
  48     return std::make_unique<sdr::properties::E3dProperties>(*this);
  49 }
  50
  51 E3dObject::E3dObject(SdrModel& rSdrModel)
  52 :   SdrAttrObj(rSdrModel),
  53     mbTfHasChanged(true),
  54     mbIsSelected(false)
  55 {
  56     m_bIs3DObj = true;
  57     m_bClosedObj = true;
  58 }
  59
  60 E3dObject::E3dObject(SdrModel& rSdrModel, E3dObject const & rSource)
  61 :   SdrAttrObj(rSdrModel, rSource),
  62     mbTfHasChanged(true),
  63     mbIsSelected(false)
  64 {
  65     m_bIs3DObj = true;
  66     m_bClosedObj = true;
  67
  68     // BoundVol can be copied since also the children are copied
  69     maLocalBoundVol  = rSource.maLocalBoundVol;
  70     maTransformation = rSource.maTransformation;
  71
  72     // Because the parent may have changed, definitely redefine the total
  73     // transformation next time
  74     SetTransformChanged();
  75
  76     // Copy selection status
  77     mbIsSelected = rSource.mbIsSelected;
  78 }
  79
  80 E3dObject::~E3dObject()
  81 {
  82 }
  83
  84 void E3dObject::SetSelected(bool bNew)
  85 {
  86     if(mbIsSelected != bNew)
  87     {
  88         mbIsSelected = bNew;
  89     }
  90 }
  91
  92 // Break, default implementations
  93 bool E3dObject::IsBreakObjPossible()
  94 {
  95     return false;
  96 }
  97
  98 rtl::Reference<SdrAttrObj> E3dObject::GetBreakObj()
  99 {
 100     return nullptr;
 101 }
 102
 103 SdrInventor E3dObject::GetObjInventor() const
 104 {
 105     return SdrInventor::E3d;
 106 }
 107
 108 SdrObjKind E3dObject::GetObjIdentifier() const
 109 {
 110     return SdrObjKind::E3D_Object;
 111 }
 112
 113 // Determine the capabilities of the object
 114 void E3dObject::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
 115 {
 116     rInfo.bResizeFreeAllowed    = true;
 117     rInfo.bResizePropAllowed    = true;
 118     rInfo.bRotateFreeAllowed    = true;
 119     rInfo.bRotate90Allowed      = true;
 120     rInfo.bMirrorFreeAllowed    = false;
 121     rInfo.bMirror45Allowed      = false;
 122     rInfo.bMirror90Allowed      = false;
 123     rInfo.bShearAllowed         = false;
 124     rInfo.bEdgeRadiusAllowed    = false;
 125     rInfo.bCanConvToPath        = false;
 126
 127     // no transparence for 3d objects
 128     rInfo.bTransparenceAllowed = false;
 129
 130     // Convert 3D objects in a group of polygons:
 131     // At first not only possible, because the creation of a group of
 132     // 2D polygons would be required which need to be sorted by depth,
 133     // ie at intersections be cut relative to each other. Also the texture
 134     // coordinates were an unsolved problem.
 135     rInfo.bCanConvToPoly = false;
 136     rInfo.bCanConvToContour = false;
 137     rInfo.bCanConvToPathLineToArea = false;
 138     rInfo.bCanConvToPolyLineToArea = false;
 139 }
 140
 141 // resize object, used from old 2d interfaces, e.g. in Move/Scale dialog (F4)
 142 void E3dObject::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
 143 {
 144     // Movement in X, Y in the eye coordinate system
 145     E3dScene* pScene(getRootE3dSceneFromE3dObject());
 146
 147     if(nullptr == pScene)
 148     {
 149         return;
 150     }
 151
 152     // transform pos from 2D world to 3D eye
 153     const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pScene->GetViewContact());
 154     const drawinglayer::geometry::ViewInformation3D& aViewInfo3D(rVCScene.getViewInformation3D());
 155     basegfx::B2DPoint aScaleCenter2D(static_cast<double>(rRef.X()), static_cast<double>(rRef.Y()));
 156     basegfx::B2DHomMatrix aInverseSceneTransform(rVCScene.getObjectTransformation());
 157
 158     aInverseSceneTransform.invert();
 159     aScaleCenter2D = aInverseSceneTransform * aScaleCenter2D;
 160
 161     basegfx::B3DPoint aScaleCenter3D(aScaleCenter2D.getX(), aScaleCenter2D.getY(), 0.5);
 162     basegfx::B3DHomMatrix aInverseViewToEye(aViewInfo3D.getDeviceToView() * aViewInfo3D.getProjection());
 163
 164     aInverseViewToEye.invert();
 165     aScaleCenter3D = aInverseViewToEye * aScaleCenter3D;
 166
 167     // Get scale factors
 168     double fScaleX(xFact);
 169     double fScaleY(yFact);
 170
 171     // build transform
 172     basegfx::B3DHomMatrix aInverseOrientation(aViewInfo3D.getOrientation());
 173     aInverseOrientation.invert();
 174     basegfx::B3DHomMatrix aFullTransform(GetFullTransform());
 175     basegfx::B3DHomMatrix aTrans(aFullTransform);
 176
 177     aTrans *= aViewInfo3D.getOrientation();
 178     aTrans.translate(-aScaleCenter3D.getX(), -aScaleCenter3D.getY(), -aScaleCenter3D.getZ());
 179     aTrans.scale(fScaleX, fScaleY, 1.0);
 180     aTrans.translate(aScaleCenter3D.getX(), aScaleCenter3D.getY(), aScaleCenter3D.getZ());
 181     aTrans *= aInverseOrientation;
 182     aFullTransform.invert();
 183     aTrans *= aFullTransform;
 184
 185     // Apply
 186     basegfx::B3DHomMatrix aObjTrans(GetTransform());
 187     aObjTrans *= aTrans;
 188
 189     E3DModifySceneSnapRectUpdater aUpdater(this);
 190     SetTransform(aObjTrans);
 191 }
 192
 193 // Move object in 2D is needed when using cursor keys
 194 void E3dObject::NbcMove(const Size& rSize)
 195 {
 196     // Movement in X, Y in the eye coordinate system
 197     E3dScene* pScene(getRootE3dSceneFromE3dObject());
 198
 199     if(nullptr == pScene)
 200     {
 201         return;
 202     }
 203
 204     //Dimensions of the scene in 3D and 2D for comparison
 205     tools::Rectangle aRect = pScene->GetSnapRect();
 206     basegfx::B3DHomMatrix aInvDispTransform;
 207     E3dScene* pParent(getParentE3dSceneFromE3dObject());
 208
 209     if(nullptr != pParent)
 210     {
 211         aInvDispTransform = pParent->GetFullTransform();
 212         aInvDispTransform.invert();
 213     }
 214
 215     // BoundVolume from 3d world to 3d eye
 216     const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pScene->GetViewContact());
 217     const drawinglayer::geometry::ViewInformation3D& aViewInfo3D(rVCScene.getViewInformation3D());
 218     basegfx::B3DRange aEyeVol(pScene->GetBoundVolume());
 219     aEyeVol.transform(aViewInfo3D.getOrientation());
 220
 221     if ((aRect.GetWidth() == 0) || (aRect.GetHeight() == 0))
 222         throw o3tl::divide_by_zero();
 223
 224     // build relative movement vector in eye coordinates
 225     basegfx::B3DPoint aMove(
 226         static_cast<double>(rSize.Width()) * aEyeVol.getWidth() / static_cast<double>(aRect.GetWidth()),
 227         static_cast<double>(-rSize.Height()) * aEyeVol.getHeight() / static_cast<double>(aRect.GetHeight()),
 228         0.0);
 229     basegfx::B3DPoint aPos(0.0, 0.0, 0.0);
 230
 231     // movement vector to local coordinates of objects' parent
 232     basegfx::B3DHomMatrix aInverseOrientation(aViewInfo3D.getOrientation());
 233     aInverseOrientation.invert();
 234     basegfx::B3DHomMatrix aCompleteTrans(aInvDispTransform * aInverseOrientation);
 235
 236     aMove = aCompleteTrans * aMove;
 237     aPos = aCompleteTrans * aPos;
 238
 239     // build transformation and apply
 240     basegfx::B3DHomMatrix aTranslate;
 241     aTranslate.translate(aMove.getX() - aPos.getX(), aMove.getY() - aPos.getY(), aMove.getZ() - aPos.getZ());
 242
 243     E3DModifySceneSnapRectUpdater aUpdater(pScene);
 244     SetTransform(aTranslate * GetTransform());
 245 }
 246
 247 void E3dObject::RecalcSnapRect()
 248 {
 249     maSnapRect = tools::Rectangle();
 250 }
 251
 252 // Inform parent of changes in the structure (eg by transformation), in this
 253 // process the object in which the change has occurred is returned.
 254 void E3dObject::StructureChanged()
 255 {
 256     E3dScene* pParent(getParentE3dSceneFromE3dObject());
 257
 258     if(nullptr != pParent)
 259     {
 260         pParent->InvalidateBoundVolume();
 261         pParent->StructureChanged();
 262     }
 263 }
 264
 265 E3dScene* E3dObject::getParentE3dSceneFromE3dObject() const
 266 {
 267     return DynCastE3dScene(getParentSdrObjectFromSdrObject());
 268 }
 269
 270 // Determine the top-level scene object
 271 E3dScene* E3dObject::getRootE3dSceneFromE3dObject() const
 272 {
 273     E3dScene* pParent(getParentE3dSceneFromE3dObject());
 274
 275     if(nullptr != pParent)
 276     {
 277         return pParent->getRootE3dSceneFromE3dObject();
 278     }
 279
 280     return nullptr;
 281 }
 282
 283 // Calculate enclosed volume, including all child objects
 284 basegfx::B3DRange E3dObject::RecalcBoundVolume() const
 285 {
 286     basegfx::B3DRange aRetval;
 287     if (comphelper::IsFuzzing()) // skip slow path for fuzzing
 288         return aRetval;
 289
 290     const sdr::contact::ViewContactOfE3d* pVCOfE3D = dynamic_cast< const sdr::contact::ViewContactOfE3d* >(&GetViewContact());
 291
 292     if(pVCOfE3D)
 293     {
 294         // BoundVolume is without 3D object transformation, use correct sequence
 295         const drawinglayer::primitive3d::Primitive3DContainer& xLocalSequence(pVCOfE3D->getVIP3DSWithoutObjectTransform());
 296
 297         if(!xLocalSequence.empty())
 298         {
 299             const uno::Sequence< beans::PropertyValue > aEmptyParameters;
 300             const drawinglayer::geometry::ViewInformation3D aLocalViewInformation3D(aEmptyParameters);
 301
 302             aRetval = xLocalSequence.getB3DRange(aLocalViewInformation3D);
 303         }
 304     }
 305
 306     return aRetval;
 307 }
 308
 309 // Get enclosed volume and possibly recalculate it
 310 const basegfx::B3DRange& E3dObject::GetBoundVolume() const
 311 {
 312     if(maLocalBoundVol.isEmpty())
 313     {
 314         const_cast< E3dObject* >(this)->maLocalBoundVol = RecalcBoundVolume();
 315     }
 316
 317     return maLocalBoundVol;
 318 }
 319
 320 void E3dObject::InvalidateBoundVolume()
 321 {
 322     maLocalBoundVol.reset();
 323 }
 324
 325 // Pass on the changes in transformation to all child objects
 326 void E3dObject::SetTransformChanged()
 327 {
 328     InvalidateBoundVolume();
 329     mbTfHasChanged = true;
 330 }
 331
 332 // Define the hierarchical transformation over all Parents, store in
 333 // maFullTransform and return them
 334 const basegfx::B3DHomMatrix& E3dObject::GetFullTransform() const
 335 {
 336     if(mbTfHasChanged)
 337     {
 338         basegfx::B3DHomMatrix aNewFullTransformation(maTransformation);
 339         E3dScene* pParent(getParentE3dSceneFromE3dObject());
 340
 341         if(nullptr != pParent)
 342         {
 343             aNewFullTransformation = pParent->GetFullTransform() * aNewFullTransformation;
 344         }
 345
 346         const_cast< E3dObject* >(this)->maFullTransform = std::move(aNewFullTransformation);
 347         const_cast< E3dObject* >(this)->mbTfHasChanged = false;
 348     }
 349
 350     return maFullTransform;
 351 }
 352
 353 void E3dObject::NbcSetTransform(const basegfx::B3DHomMatrix& rMatrix)
 354 {
 355     if(maTransformation != rMatrix)
 356     {
 357         maTransformation = rMatrix;
 358         SetTransformChanged();
 359         StructureChanged();
 360     }
 361 }
 362
 363 // Set transformation matrix with repaint broadcast
 364 void E3dObject::SetTransform(const basegfx::B3DHomMatrix& rMatrix)
 365 {
 366     if(rMatrix != maTransformation)
 367     {
 368         NbcSetTransform(rMatrix);
 369         SetChanged();
 370         BroadcastObjectChange();
 371         if (m_pUserCall != nullptr) m_pUserCall->Changed(*this, SdrUserCallType::Resize, tools::Rectangle());
 372     }
 373 }
 374
 375 basegfx::B3DPolyPolygon E3dObject::CreateWireframe() const
 376 {
 377     const basegfx::B3DRange aBoundVolume(GetBoundVolume());
 378     return basegfx::utils::createCubePolyPolygonFromB3DRange(aBoundVolume);
 379 }
 380
 381 // Get the name of the object (singular)
 382 OUString E3dObject::TakeObjNameSingul() const
 383 {
 384     OUString sName = SvxResId(STR_ObjNameSingulObj3d);
 385
 386     OUString aName(GetName());
 387     if (!aName.isEmpty())
 388     {
 389         sName += " '" + aName + "'";
 390     }
 391     return sName;
 392 }
 393
 394 // Get the name of the object (plural)
 395 OUString E3dObject::TakeObjNamePlural() const
 396 {
 397     return SvxResId(STR_ObjNamePluralObj3d);
 398 }
 399
 400 rtl::Reference<SdrObject> E3dObject::CloneSdrObject(SdrModel& rTargetModel) const
 401 {
 402     return new E3dObject(rTargetModel, *this);
 403 }
 404
 405 std::unique_ptr<SdrObjGeoData> E3dObject::NewGeoData() const
 406 {
 407     return std::make_unique<E3DObjGeoData>();
 408 }
 409
 410 void E3dObject::SaveGeoData(SdrObjGeoData& rGeo) const
 411 {
 412     SdrAttrObj::SaveGeoData (rGeo);
 413
 414     static_cast<E3DObjGeoData &>(rGeo).maLocalBoundVol  = maLocalBoundVol;
 415     static_cast<E3DObjGeoData &>(rGeo).maTransformation = maTransformation;
 416 }
 417
 418 void E3dObject::RestoreGeoData(const SdrObjGeoData& rGeo)
 419 {
 420     maLocalBoundVol = static_cast<const E3DObjGeoData &>(rGeo).maLocalBoundVol;
 421     E3DModifySceneSnapRectUpdater aUpdater(this);
 422     NbcSetTransform(static_cast<const E3DObjGeoData &>(rGeo).maTransformation);
 423     SdrAttrObj::RestoreGeoData (rGeo);
 424 }
 425
 426 // 2D-rotation of a 3D-body, normally this is done by the scene itself.
 427 // This is however a correct implementation, because everything that has
 428 // happened is a rotation around the axis perpendicular to the screen and that
 429 // is regardless of how the scene has been rotated up until now.
 430 void E3dObject::NbcRotate(const Point& rRef, Degree100 nAngle, double sn, double cs)
 431 {
 432     // So currently the gluepoints are defined relative to the scene aOutRect.
 433     // Before turning the gluepoints are defined relative to the page. They
 434     // take no part in the rotation of the scene. To ensure this, there is the
 435     // SetGlueReallyAbsolute(sal_True);
 436     double fAngleInRad = toRadians(nAngle);
 437
 438     basegfx::B3DHomMatrix aRotateZ;
 439     aRotateZ.rotate(0.0, 0.0, fAngleInRad);
 440     NbcSetTransform(aRotateZ * GetTransform());
 441
 442     SetBoundAndSnapRectsDirty();    // This forces a recalculation of all BoundRects
 443     NbcRotateGluePoints(rRef,nAngle,sn,cs);  // Rotate the gluepoints (who still
 444                                             // have coordinates relative to the
 445                                             // original page)
 446     SetGlueReallyAbsolute(false);       // from now they are again relative to BoundRect (that is defined as aOutRect)
 447 }
 448
 449 std::unique_ptr<sdr::properties::BaseProperties> E3dCompoundObject::CreateObjectSpecificProperties()
 450 {
 451     return std::make_unique<sdr::properties::E3dCompoundProperties>(*this);
 452 }
 453
 454 E3dCompoundObject::E3dCompoundObject(SdrModel& rSdrModel)
 455 :   E3dObject(rSdrModel)
 456 {
 457 }
 458
 459 E3dCompoundObject::E3dCompoundObject(SdrModel& rSdrModel, E3dCompoundObject const & rSource)
 460 :   E3dObject(rSdrModel, rSource)
 461 {
 462 }
 463
 464 E3dCompoundObject::~E3dCompoundObject ()
 465 {
 466 }
 467
 468 basegfx::B2DPolyPolygon E3dCompoundObject::TakeXorPoly() const
 469 {
 470     basegfx::B2DPolyPolygon aRetval;
 471     const uno::Sequence< beans::PropertyValue > aEmptyParameters;
 472     drawinglayer::geometry::ViewInformation3D aViewInfo3D(aEmptyParameters);
 473     E3dScene* pRootScene = fillViewInformation3DForCompoundObject(aViewInfo3D, *this);
 474
 475     if(pRootScene)
 476     {
 477         const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pRootScene->GetViewContact());
 478         const basegfx::B3DPolyPolygon aCubePolyPolygon(CreateWireframe());
 479         aRetval = basegfx::utils::createB2DPolyPolygonFromB3DPolyPolygon(aCubePolyPolygon,
 480             aViewInfo3D.getObjectToView() * GetTransform());
 481         aRetval.transform(rVCScene.getObjectTransformation());
 482     }
 483
 484     return aRetval;
 485 }
 486
 487 sal_uInt32 E3dCompoundObject::GetHdlCount() const
 488 {
 489     // 8 corners + 1 E3dVolumeMarker (= Wireframe representation)
 490     return 9;
 491 }
 492
 493 void E3dCompoundObject::AddToHdlList(SdrHdlList& rHdlList) const
 494 {
 495     const uno::Sequence< beans::PropertyValue > aEmptyParameters;
 496     drawinglayer::geometry::ViewInformation3D aViewInfo3D(aEmptyParameters);
 497     E3dScene* pRootScene = fillViewInformation3DForCompoundObject(aViewInfo3D, *this);
 498
 499     if(pRootScene)
 500     {
 501         const basegfx::B3DRange aBoundVolume(GetBoundVolume());
 502
 503         if(!aBoundVolume.isEmpty())
 504         {
 505             const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pRootScene->GetViewContact());
 506
 507             for(sal_uInt32 a(0); a < 8; a++)
 508             {
 509                 basegfx::B3DPoint aPos3D;
 510
 511                 switch(a)
 512                 {
 513                     case 0 : aPos3D.setX(aBoundVolume.getMinX()); aPos3D.setY(aBoundVolume.getMinY()); aPos3D.setZ(aBoundVolume.getMinZ()); break;
 514                     case 1 : aPos3D.setX(aBoundVolume.getMinX()); aPos3D.setY(aBoundVolume.getMinY()); aPos3D.setZ(aBoundVolume.getMaxZ()); break;
 515                     case 2 : aPos3D.setX(aBoundVolume.getMinX()); aPos3D.setY(aBoundVolume.getMaxY()); aPos3D.setZ(aBoundVolume.getMinZ()); break;
 516                     case 3 : aPos3D.setX(aBoundVolume.getMinX()); aPos3D.setY(aBoundVolume.getMaxY()); aPos3D.setZ(aBoundVolume.getMaxZ()); break;
 517                     case 4 : aPos3D.setX(aBoundVolume.getMaxX()); aPos3D.setY(aBoundVolume.getMinY()); aPos3D.setZ(aBoundVolume.getMinZ()); break;
 518                     case 5 : aPos3D.setX(aBoundVolume.getMaxX()); aPos3D.setY(aBoundVolume.getMinY()); aPos3D.setZ(aBoundVolume.getMaxZ()); break;
 519                     case 6 : aPos3D.setX(aBoundVolume.getMaxX()); aPos3D.setY(aBoundVolume.getMaxY()); aPos3D.setZ(aBoundVolume.getMinZ()); break;
 520                     case 7 : aPos3D.setX(aBoundVolume.getMaxX()); aPos3D.setY(aBoundVolume.getMaxY()); aPos3D.setZ(aBoundVolume.getMaxZ()); break;
 521                 }
 522
 523                 // to 3d view coor
 524                 aPos3D *= aViewInfo3D.getObjectToView() * GetTransform();
 525
 526                 // create 2d relative scene
 527                 basegfx::B2DPoint aPos2D(aPos3D.getX(), aPos3D.getY());
 528
 529                 // to 2d world coor
 530                 aPos2D *= rVCScene.getObjectTransformation();
 531
 532                 rHdlList.AddHdl(std::make_unique<SdrHdl>(Point(basegfx::fround<tools::Long>(aPos2D.getX()), basegfx::fround<tools::Long>(aPos2D.getY())), SdrHdlKind::BezierWeight));
 533             }
 534         }
 535     }
 536
 537     const basegfx::B2DPolyPolygon aPolyPolygon(TakeXorPoly());
 538
 539     if(aPolyPolygon.count())
 540     {
 541         rHdlList.AddHdl(std::make_unique<E3dVolumeMarker>(aPolyPolygon));
 542     }
 543 }
 544
 545 SdrObjKind E3dCompoundObject::GetObjIdentifier() const
 546 {
 547     return SdrObjKind::E3D_CompoundObject;
 548 }
 549
 550 void E3dCompoundObject::RecalcSnapRect()
 551 {
 552     if (comphelper::IsFuzzing()) // skip slow path for fuzzing
 553         return;
 554
 555     const uno::Sequence< beans::PropertyValue > aEmptyParameters;
 556     drawinglayer::geometry::ViewInformation3D aViewInfo3D(aEmptyParameters);
 557     E3dScene* pRootScene = fillViewInformation3DForCompoundObject(aViewInfo3D, *this);
 558     maSnapRect = tools::Rectangle();
 559
 560     if(!pRootScene)
 561         return;
 562
 563     // get VC of 3D candidate
 564     const sdr::contact::ViewContactOfE3d* pVCOfE3D = dynamic_cast< const sdr::contact::ViewContactOfE3d* >(&GetViewContact());
 565
 566     if(!pVCOfE3D)
 567         return;
 568
 569     // get 3D primitive sequence
 570     const drawinglayer::primitive3d::Primitive3DContainer xLocalSequence(pVCOfE3D->getViewIndependentPrimitive3DContainer());
 571
 572     if(xLocalSequence.empty())
 573         return;
 574
 575     // get BoundVolume
 576     basegfx::B3DRange aBoundVolume(xLocalSequence.getB3DRange(aViewInfo3D));
 577
 578     // transform bound volume to relative scene coordinates
 579     aBoundVolume.transform(aViewInfo3D.getObjectToView());
 580
 581     // build 2d relative scene range
 582     basegfx::B2DRange aSnapRange(
 583         aBoundVolume.getMinX(), aBoundVolume.getMinY(),
 584         aBoundVolume.getMaxX(), aBoundVolume.getMaxY());
 585
 586     // transform to 2D world coordinates
 587     const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pRootScene->GetViewContact());
 588     aSnapRange.transform(rVCScene.getObjectTransformation());
 589
 590     // snap to integer
 591     maSnapRect = tools::Rectangle(
 592         sal_Int32(floor(aSnapRange.getMinX())), sal_Int32(floor(aSnapRange.getMinY())),
 593         sal_Int32(ceil(aSnapRange.getMaxX())), sal_Int32(ceil(aSnapRange.getMaxY())));
 594 }
 595
 596 rtl::Reference<SdrObject> E3dCompoundObject::CloneSdrObject(SdrModel& rTargetModel) const
 597 {
 598     return new E3dCompoundObject(rTargetModel, *this);
 599 }
 600
 601 // convert given basegfx::B3DPolyPolygon to screen coor
 602 basegfx::B2DPolyPolygon E3dCompoundObject::TransformToScreenCoor(const basegfx::B3DPolyPolygon& rCandidate) const
 603 {
 604     const uno::Sequence< beans::PropertyValue > aEmptyParameters;
 605     drawinglayer::geometry::ViewInformation3D aViewInfo3D(aEmptyParameters);
 606     E3dScene* pRootScene = fillViewInformation3DForCompoundObject(aViewInfo3D, *this);
 607     basegfx::B2DPolyPolygon aRetval;
 608
 609     if(pRootScene)
 610     {
 611         aRetval = basegfx::utils::createB2DPolyPolygonFromB3DPolyPolygon(rCandidate,
 612             aViewInfo3D.getObjectToView() * GetTransform());
 613         const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pRootScene->GetViewContact());
 614         aRetval.transform(rVCScene.getObjectTransformation());
 615     }
 616
 617     return aRetval;
 618 }
 619
 620 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */