svx/source/engine3d/helperminimaldepth3d.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
  21 #include <helperminimaldepth3d.hxx>
  22 #include <drawinglayer/processor3d/baseprocessor3d.hxx>
  23 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
  24 #include <drawinglayer/primitive3d/transformprimitive3d.hxx>
  25 #include <drawinglayer/primitive3d/polygonprimitive3d.hxx>
  26 #include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
  27 #include <svx/sdr/contact/viewcontactofe3d.hxx>
  28 #include <svx/sdr/contact/viewcontactofe3dscene.hxx>
  29 #include <svx/obj3d.hxx>
  30 #include <svx/scene3d.hxx>
  31
  32
  33
  34 namespace drawinglayer
  35 {
  36     namespace processor3d
  37     {
  38         class MinimalDephInViewExtractor : public BaseProcessor3D
  39         {
  40         private:
  41             // the value which will be fetched as result
  42             double                                  mfMinimalDepth;
  43
  44             // as tooling, the process() implementation takes over API handling and calls this
  45             // virtual render method when the primitive implementation is BasePrimitive3D-based.
  46             virtual void processBasePrimitive3D(const primitive3d::BasePrimitive3D& rCandidate) SAL_OVERRIDE;
  47
  48         public:
  49             MinimalDephInViewExtractor(const geometry::ViewInformation3D& rViewInformation)
  50             :   BaseProcessor3D(rViewInformation),
  51                 mfMinimalDepth(DBL_MAX)
  52             {}
  53
  54             // data access
  55             double getMinimalDepth() const { return mfMinimalDepth; }
  56         };
  57
  58         void MinimalDephInViewExtractor::processBasePrimitive3D(const primitive3d::BasePrimitive3D& rCandidate)
  59         {
  60             // it is a BasePrimitive3D implementation, use getPrimitive3DID() call for switch
  61             switch(rCandidate.getPrimitive3DID())
  62             {
  63                 case PRIMITIVE3D_ID_TRANSFORMPRIMITIVE3D :
  64                 {
  65                     // transform group. Remember current transformations
  66                     const primitive3d::TransformPrimitive3D& rPrimitive = static_cast< const primitive3d::TransformPrimitive3D& >(rCandidate);
  67                     const geometry::ViewInformation3D aLastViewInformation3D(getViewInformation3D());
  68
  69                     // create new transformation; add new object transform from right side
  70                     const geometry::ViewInformation3D aNewViewInformation3D(
  71                         aLastViewInformation3D.getObjectTransformation() * rPrimitive.getTransformation(),
  72                         aLastViewInformation3D.getOrientation(),
  73                         aLastViewInformation3D.getProjection(),
  74                         aLastViewInformation3D.getDeviceToView(),
  75                         aLastViewInformation3D.getViewTime(),
  76                         aLastViewInformation3D.getExtendedInformationSequence());
  77                     updateViewInformation(aNewViewInformation3D);
  78
  79                     // let break down
  80                     process(rPrimitive.getChildren());
  81
  82                     // restore transformations
  83                     updateViewInformation(aLastViewInformation3D);
  84                     break;
  85                 }
  86                 case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D :
  87                 {
  88                     // PolygonHairlinePrimitive3D
  89                     const primitive3d::PolygonHairlinePrimitive3D& rPrimitive = static_cast< const primitive3d::PolygonHairlinePrimitive3D& >(rCandidate);
  90                        const basegfx::B3DPolygon& rPolygon = rPrimitive.getB3DPolygon();
  91                     const sal_uInt32 nCount(rPolygon.count());
  92
  93                     for(sal_uInt32 a(0); a < nCount; a++)
  94                     {
  95                         const basegfx::B3DPoint aPointInView(getViewInformation3D().getObjectToView() * rPolygon.getB3DPoint(a));
  96
  97                         if(aPointInView.getZ() < mfMinimalDepth)
  98                         {
  99                             mfMinimalDepth = aPointInView.getZ();
 100                         }
 101                     }
 102
 103                     break;
 104                 }
 105                 case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D :
 106                 {
 107                     // PolyPolygonMaterialPrimitive3D
 108                     const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const primitive3d::PolyPolygonMaterialPrimitive3D& >(rCandidate);
 109                        const basegfx::B3DPolyPolygon& rPolyPolygon = rPrimitive.getB3DPolyPolygon();
 110                     const sal_uInt32 nPolyCount(rPolyPolygon.count());
 111
 112                     for(sal_uInt32 a(0); a < nPolyCount; a++)
 113                     {
 114                            const basegfx::B3DPolygon aPolygon(rPolyPolygon.getB3DPolygon(a));
 115                         const sal_uInt32 nCount(aPolygon.count());
 116
 117                         for(sal_uInt32 b(0); b < nCount; b++)
 118                         {
 119                             const basegfx::B3DPoint aPointInView(getViewInformation3D().getObjectToView() * aPolygon.getB3DPoint(b));
 120
 121                             if(aPointInView.getZ() < mfMinimalDepth)
 122                             {
 123                                 mfMinimalDepth = aPointInView.getZ();
 124                             }
 125                         }
 126                     }
 127
 128                     break;
 129                 }
 130                 default :
 131                 {
 132                     // process recursively
 133                     process(rCandidate.get3DDecomposition(getViewInformation3D()));
 134                     break;
 135                 }
 136             }
 137         }
 138     } // end of namespace processor3d
 139 } // end of namespace drawinglayer
 140
 141
 142 // changed to create values using VCs, Primitive3DSequence and ViewInformation3D to allow
 143 // removal of old 3D bucket geometry. There is one slight difference in the result, it's
 144 // in [0.0 .. 1.0] for Z-Depth since the scaling of the scene as 2D object is no longer
 145 // part of the 3D transformations. This could be added since the ViewContactOfE3dScene is
 146 // given, but is not needed since the permutation of the depth values needs only be correct
 147 // relative to each other
 148
 149 double getMinimalDepthInViewCoordinates(const E3dCompoundObject& rObject)
 150 {
 151     // this is a E3dCompoundObject, so it cannot be a scene (which is a E3dObject).
 152     // Get primitive sequence using VC
 153     const sdr::contact::ViewContactOfE3d& rVCObject = static_cast< sdr::contact::ViewContactOfE3d& >(rObject.GetViewContact());
 154     const drawinglayer::primitive3d::Primitive3DSequence aPrimitives = rVCObject.getViewIndependentPrimitive3DSequence();
 155     double fRetval(DBL_MAX);
 156
 157     if(aPrimitives.hasElements())
 158     {
 159         const E3dScene* pScene = rObject.GetScene();
 160
 161         if(pScene)
 162         {
 163             // get ViewInformation3D from scene using VC
 164             const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pScene->GetViewContact());
 165             const drawinglayer::geometry::ViewInformation3D aViewInfo3D(rVCScene.getViewInformation3D());
 166
 167             // the scene's object transformation is already part of aViewInfo3D.getObjectTransformation()
 168             // for historical reasons (see ViewContactOfE3dScene::createViewInformation3D for more info)
 169             // and the object's transform is part of aPrimitives (and taken into account when decomposing
 170             // to PolygonHairlinePrimitive3D and PolyPolygonMaterialPrimitive3D). The missing part may be
 171             // some Scene SdrObjects lying in-between which may need to be added. This is e.g. used in chart,
 172             // and generally allowed in 3d scenes an their 3d object hierarchy
 173             basegfx::B3DHomMatrix aInBetweenSceneMatrix;
 174             E3dScene* pParentScene = dynamic_cast< E3dScene* >(rObject.GetParentObj());
 175
 176             while(pParentScene && pParentScene != pScene)
 177             {
 178                 aInBetweenSceneMatrix = pParentScene->GetTransform() * aInBetweenSceneMatrix;
 179                 pParentScene = dynamic_cast< E3dScene* >(pParentScene->GetParentObj());
 180             }
 181
 182             // build new ViewInformation containing all transforms
 183             const drawinglayer::geometry::ViewInformation3D aNewViewInformation3D(
 184                 aViewInfo3D.getObjectTransformation() * aInBetweenSceneMatrix,
 185                 aViewInfo3D.getOrientation(),
 186                 aViewInfo3D.getProjection(),
 187                 aViewInfo3D.getDeviceToView(),
 188                 aViewInfo3D.getViewTime(),
 189                 aViewInfo3D.getExtendedInformationSequence());
 190
 191             // create extractor helper, process geometry and get return value
 192             drawinglayer::processor3d::MinimalDephInViewExtractor aExtractor(aNewViewInformation3D);
 193             aExtractor.process(aPrimitives);
 194             fRetval = aExtractor.getMinimalDepth();
 195         }
 196     }
 197
 198     return fRetval;
 199 }
 200
 201 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */