| /************************************************************** |
| * |
| * 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_svx.hxx" |
| |
| #include <svx/helperhittest3d.hxx> |
| #include <basegfx/point/b2dpoint.hxx> |
| #include <svx/svdpage.hxx> |
| #include <svx/scene3d.hxx> |
| #include <svx/svditer.hxx> |
| #include <drawinglayer/processor3d/cutfindprocessor3d.hxx> |
| #include <svx/sdr/contact/viewcontactofe3d.hxx> |
| #include <svx/sdr/contact/viewcontactofe3dscene.hxx> |
| #include <com/sun/star/uno/Sequence.h> |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| using namespace com::sun::star; |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| class ImplPairDephAndObject |
| { |
| private: |
| const E3dCompoundObject* mpObject; |
| double mfDepth; |
| |
| public: |
| ImplPairDephAndObject(const E3dCompoundObject* pObject, double fDepth) |
| : mpObject(pObject), |
| mfDepth(fDepth) |
| {} |
| |
| // for ::std::sort |
| bool operator<(const ImplPairDephAndObject& rComp) const |
| { |
| return (mfDepth < rComp.mfDepth); |
| } |
| |
| // data read access |
| const E3dCompoundObject* getObject() const { return mpObject; } |
| double getDepth() const { return mfDepth; } |
| }; |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| void getAllHit3DObjectWithRelativePoint( |
| const basegfx::B3DPoint& rFront, |
| const basegfx::B3DPoint& rBack, |
| const E3dCompoundObject& rObject, |
| const drawinglayer::geometry::ViewInformation3D& rObjectViewInformation3D, |
| ::std::vector< basegfx::B3DPoint >& o_rResult, |
| bool bAnyHit) |
| { |
| o_rResult.clear(); |
| |
| if(!rFront.equal(rBack)) |
| { |
| // rObject is a E3dCompoundObject, so it cannot be a scene (which is a E3dObject) |
| const sdr::contact::ViewContactOfE3d& rVCObject = static_cast< sdr::contact::ViewContactOfE3d& >(rObject.GetViewContact()); |
| const drawinglayer::primitive3d::Primitive3DSequence aPrimitives(rVCObject.getViewIndependentPrimitive3DSequence()); |
| |
| if(aPrimitives.hasElements()) |
| { |
| // make BoundVolume empty and overlapping test for speedup |
| const basegfx::B3DRange aObjectRange(drawinglayer::primitive3d::getB3DRangeFromPrimitive3DSequence(aPrimitives, rObjectViewInformation3D)); |
| |
| if(!aObjectRange.isEmpty()) |
| { |
| const basegfx::B3DRange aFrontBackRange(rFront, rBack); |
| |
| if(aObjectRange.overlaps(aFrontBackRange)) |
| { |
| // bound volumes hit, geometric cut tests needed |
| drawinglayer::processor3d::CutFindProcessor aCutFindProcessor(rObjectViewInformation3D, rFront, rBack, bAnyHit); |
| aCutFindProcessor.process(aPrimitives); |
| o_rResult = aCutFindProcessor.getCutPoints(); |
| } |
| } |
| } |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| E3dScene* fillViewInformation3DForCompoundObject(drawinglayer::geometry::ViewInformation3D& o_rViewInformation3D, const E3dCompoundObject& rCandidate) |
| { |
| // Search for root scene (outmost scene) of the 3d object since e.g. in chart, multiple scenes may |
| // be placed between object and outmost scene. On that search, remember the in-between scene's |
| // transformation for the correct complete ObjectTransformation. For historical reasons, the |
| // root scene's own object transformation is part of the scene's ViewTransformation, o do not |
| // add it. For more details, see ViewContactOfE3dScene::createViewInformation3D. |
| E3dScene* pParentScene = dynamic_cast< E3dScene* >(rCandidate.GetParentObj()); |
| E3dScene* pRootScene = 0; |
| basegfx::B3DHomMatrix aInBetweenSceneMatrix; |
| |
| while(pParentScene) |
| { |
| E3dScene* pParentParentScene = dynamic_cast< E3dScene* >(pParentScene->GetParentObj()); |
| |
| if(pParentParentScene) |
| { |
| // pParentScene is a in-between scene |
| aInBetweenSceneMatrix = pParentScene->GetTransform() * aInBetweenSceneMatrix; |
| } |
| else |
| { |
| // pParentScene is the root scene |
| pRootScene = pParentScene; |
| } |
| |
| pParentScene = pParentParentScene; |
| } |
| |
| if(pRootScene) |
| { |
| const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pRootScene->GetViewContact()); |
| |
| if(aInBetweenSceneMatrix.isIdentity()) |
| { |
| o_rViewInformation3D = rVCScene.getViewInformation3D(); |
| } |
| else |
| { |
| // build new ViewInformation containing all transforms for the candidate |
| const drawinglayer::geometry::ViewInformation3D aViewInfo3D(rVCScene.getViewInformation3D()); |
| |
| o_rViewInformation3D = drawinglayer::geometry::ViewInformation3D( |
| aViewInfo3D.getObjectTransformation() * aInBetweenSceneMatrix, |
| aViewInfo3D.getOrientation(), |
| aViewInfo3D.getProjection(), |
| aViewInfo3D.getDeviceToView(), |
| aViewInfo3D.getViewTime(), |
| aViewInfo3D.getExtendedInformationSequence()); |
| } |
| } |
| else |
| { |
| const uno::Sequence< beans::PropertyValue > aEmptyParameters; |
| o_rViewInformation3D = drawinglayer::geometry::ViewInformation3D(aEmptyParameters); |
| } |
| |
| return pRootScene; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| SVX_DLLPUBLIC void getAllHit3DObjectsSortedFrontToBack( |
| const basegfx::B2DPoint& rPoint, |
| const E3dScene& rScene, |
| ::std::vector< const E3dCompoundObject* >& o_rResult) |
| { |
| o_rResult.clear(); |
| SdrObjList* pList = rScene.GetSubList(); |
| |
| if(pList && pList->GetObjCount()) |
| { |
| // prepare relative HitPoint. To do so, get the VC of the 3DScene and from there |
| // the Scene's 2D transformation. Multiplying with the inverse transformation |
| // will create a point relative to the 3D scene as unit-2d-object |
| const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(rScene.GetViewContact()); |
| basegfx::B2DHomMatrix aInverseSceneTransform(rVCScene.getObjectTransformation()); |
| aInverseSceneTransform.invert(); |
| const basegfx::B2DPoint aRelativePoint(aInverseSceneTransform * rPoint); |
| |
| // check if test point is inside scene's area at all |
| if(aRelativePoint.getX() >= 0.0 && aRelativePoint.getX() <= 1.0 && aRelativePoint.getY() >= 0.0 && aRelativePoint.getY() <= 1.0) |
| { |
| SdrObjListIter aIterator(*pList, IM_DEEPNOGROUPS); |
| ::std::vector< ImplPairDephAndObject > aDepthAndObjectResults; |
| const uno::Sequence< beans::PropertyValue > aEmptyParameters; |
| drawinglayer::geometry::ViewInformation3D aViewInfo3D(aEmptyParameters); |
| |
| while(aIterator.IsMore()) |
| { |
| const E3dCompoundObject* pCandidate = dynamic_cast< const E3dCompoundObject* >(aIterator.Next()); |
| |
| if(pCandidate) |
| { |
| fillViewInformation3DForCompoundObject(aViewInfo3D, *pCandidate); |
| |
| // create HitPoint Front and Back, transform to object coordinates |
| basegfx::B3DHomMatrix aViewToObject(aViewInfo3D.getObjectToView()); |
| aViewToObject.invert(); |
| const basegfx::B3DPoint aFront(aViewToObject * basegfx::B3DPoint(aRelativePoint.getX(), aRelativePoint.getY(), 0.0)); |
| const basegfx::B3DPoint aBack(aViewToObject * basegfx::B3DPoint(aRelativePoint.getX(), aRelativePoint.getY(), 1.0)); |
| |
| if(!aFront.equal(aBack)) |
| { |
| // get all hit points with object |
| ::std::vector< basegfx::B3DPoint > aHitsWithObject; |
| getAllHit3DObjectWithRelativePoint(aFront, aBack, *pCandidate, aViewInfo3D, aHitsWithObject, false); |
| |
| for(sal_uInt32 a(0); a < aHitsWithObject.size(); a++) |
| { |
| const basegfx::B3DPoint aPointInViewCoordinates(aViewInfo3D.getObjectToView() * aHitsWithObject[a]); |
| aDepthAndObjectResults.push_back(ImplPairDephAndObject(pCandidate, aPointInViewCoordinates.getZ())); |
| } |
| } |
| } |
| } |
| |
| // fill nRetval |
| const sal_uInt32 nCount(aDepthAndObjectResults.size()); |
| |
| if(nCount) |
| { |
| // sort aDepthAndObjectResults by depth |
| ::std::sort(aDepthAndObjectResults.begin(), aDepthAndObjectResults.end()); |
| |
| // copy SdrObject pointers to return result set |
| ::std::vector< ImplPairDephAndObject >::iterator aIterator2(aDepthAndObjectResults.begin()); |
| |
| for(;aIterator2 != aDepthAndObjectResults.end(); aIterator2++) |
| { |
| o_rResult.push_back(aIterator2->getObject()); |
| } |
| } |
| } |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| bool checkHitSingle3DObject( |
| const basegfx::B2DPoint& rPoint, |
| const E3dCompoundObject& rCandidate) |
| { |
| const uno::Sequence< beans::PropertyValue > aEmptyParameters; |
| drawinglayer::geometry::ViewInformation3D aViewInfo3D(aEmptyParameters); |
| E3dScene* pRootScene = fillViewInformation3DForCompoundObject(aViewInfo3D, rCandidate); |
| |
| if(pRootScene) |
| { |
| // prepare relative HitPoint. To do so, get the VC of the 3DScene and from there |
| // the Scene's 2D transformation. Multiplying with the inverse transformation |
| // will create a point relative to the 3D scene as unit-2d-object |
| const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pRootScene->GetViewContact()); |
| basegfx::B2DHomMatrix aInverseSceneTransform(rVCScene.getObjectTransformation()); |
| aInverseSceneTransform.invert(); |
| const basegfx::B2DPoint aRelativePoint(aInverseSceneTransform * rPoint); |
| |
| // check if test point is inside scene's area at all |
| if(aRelativePoint.getX() >= 0.0 && aRelativePoint.getX() <= 1.0 && aRelativePoint.getY() >= 0.0 && aRelativePoint.getY() <= 1.0) |
| { |
| // create HitPoint Front and Back, transform to object coordinates |
| basegfx::B3DHomMatrix aViewToObject(aViewInfo3D.getObjectToView()); |
| aViewToObject.invert(); |
| const basegfx::B3DPoint aFront(aViewToObject * basegfx::B3DPoint(aRelativePoint.getX(), aRelativePoint.getY(), 0.0)); |
| const basegfx::B3DPoint aBack(aViewToObject * basegfx::B3DPoint(aRelativePoint.getX(), aRelativePoint.getY(), 1.0)); |
| |
| if(!aFront.equal(aBack)) |
| { |
| // get all hit points with object |
| ::std::vector< basegfx::B3DPoint > aHitsWithObject; |
| getAllHit3DObjectWithRelativePoint(aFront, aBack, rCandidate, aViewInfo3D, aHitsWithObject, true); |
| |
| if(aHitsWithObject.size()) |
| { |
| return true; |
| } |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // eof |
