LCOV - code coverage report
Current view: top level - drawinglayer/source/primitive3d - polygontubeprimitive3d.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 244 330 73.9 %
Date: 2015-06-13 12:38:46 Functions: 14 19 73.7 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <boost/noncopyable.hpp>
      21             : #include <drawinglayer/primitive3d/polygontubeprimitive3d.hxx>
      22             : #include <drawinglayer/attribute/materialattribute3d.hxx>
      23             : #include <basegfx/matrix/b3dhommatrix.hxx>
      24             : #include <basegfx/polygon/b3dpolypolygon.hxx>
      25             : #include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
      26             : #include <basegfx/polygon/b3dpolypolygontools.hxx>
      27             : #include <drawinglayer/primitive3d/transformprimitive3d.hxx>
      28             : #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
      29             : #include <rtl/instance.hxx>
      30             : 
      31             : 
      32             : 
      33             : namespace drawinglayer
      34             : {
      35             :     namespace primitive3d
      36             :     {
      37             :         namespace // anonymous namespace
      38             :         {
      39           2 :             class TubeBuffer : boost::noncopyable
      40             :             {
      41             :             private:
      42             :                 // data for buffered tube primitives
      43             :                 Primitive3DSequence m_aLineTubeList;
      44             :                 sal_uInt32 m_nLineTubeSegments;
      45             :                 attribute::MaterialAttribute3D m_aLineMaterial;
      46             :                 ::osl::Mutex m_aMutex;
      47             :             public:
      48           2 :                 TubeBuffer()
      49           2 :                     : m_nLineTubeSegments(0L)
      50             :                 {
      51           2 :                 }
      52             : 
      53        4951 :                 Primitive3DSequence getLineTubeSegments(
      54             :                     sal_uInt32 nSegments,
      55             :                     const attribute::MaterialAttribute3D& rMaterial)
      56             :                 {
      57             :                     // may exclusively change cached data, use mutex
      58        4951 :                     ::osl::MutexGuard aGuard(m_aMutex);
      59             : 
      60        4951 :                     if (nSegments != m_nLineTubeSegments || !(rMaterial == m_aLineMaterial))
      61             :                     {
      62          10 :                         m_nLineTubeSegments = nSegments;
      63          10 :                         m_aLineMaterial = rMaterial;
      64          10 :                         m_aLineTubeList = Primitive3DSequence();
      65             :                     }
      66             : 
      67        4951 :                     if (!m_aLineTubeList.hasElements() && m_nLineTubeSegments != 0)
      68             :                     {
      69          10 :                         const basegfx::B3DPoint aLeft(0.0, 0.0, 0.0);
      70          20 :                         const basegfx::B3DPoint aRight(1.0, 0.0, 0.0);
      71          20 :                         basegfx::B3DPoint aLastLeft(0.0, 1.0, 0.0);
      72          20 :                         basegfx::B3DPoint aLastRight(1.0, 1.0, 0.0);
      73          20 :                         basegfx::B3DHomMatrix aRot;
      74          10 :                         aRot.rotate(F_2PI / (double)m_nLineTubeSegments, 0.0, 0.0);
      75          10 :                         m_aLineTubeList.realloc(m_nLineTubeSegments);
      76             : 
      77          90 :                         for(sal_uInt32 a = 0; a < m_nLineTubeSegments; ++a)
      78             :                         {
      79          80 :                             const basegfx::B3DPoint aNextLeft(aRot * aLastLeft);
      80         160 :                             const basegfx::B3DPoint aNextRight(aRot * aLastRight);
      81         160 :                             basegfx::B3DPolygon aNewPolygon;
      82             : 
      83          80 :                             aNewPolygon.append(aNextLeft);
      84          80 :                             aNewPolygon.setNormal(0L, basegfx::B3DVector(aNextLeft - aLeft));
      85             : 
      86          80 :                             aNewPolygon.append(aLastLeft);
      87          80 :                             aNewPolygon.setNormal(1L, basegfx::B3DVector(aLastLeft - aLeft));
      88             : 
      89          80 :                             aNewPolygon.append(aLastRight);
      90          80 :                             aNewPolygon.setNormal(2L, basegfx::B3DVector(aLastRight - aRight));
      91             : 
      92          80 :                             aNewPolygon.append(aNextRight);
      93          80 :                             aNewPolygon.setNormal(3L, basegfx::B3DVector(aNextRight - aRight));
      94             : 
      95          80 :                             aNewPolygon.setClosed(true);
      96             : 
      97         160 :                             const basegfx::B3DPolyPolygon aNewPolyPolygon(aNewPolygon);
      98         160 :                             const Primitive3DReference xRef(new PolyPolygonMaterialPrimitive3D(aNewPolyPolygon, m_aLineMaterial, false));
      99          80 :                             m_aLineTubeList[a] = xRef;
     100             : 
     101          80 :                             aLastLeft = aNextLeft;
     102          80 :                             aLastRight = aNextRight;
     103          90 :                         }
     104             :                     }
     105        4951 :                     return m_aLineTubeList;
     106             :                 }
     107             :             };
     108             : 
     109             :             struct theTubeBuffer :
     110             :                 public rtl::Static< TubeBuffer, theTubeBuffer > {};
     111             : 
     112        4951 :             Primitive3DSequence getLineTubeSegments(
     113             :                 sal_uInt32 nSegments,
     114             :                 const attribute::MaterialAttribute3D& rMaterial)
     115             :             {
     116             :                 // static data for buffered tube primitives
     117        4951 :                 TubeBuffer &rTheBuffer = theTubeBuffer::get();
     118        4951 :                 return rTheBuffer.getLineTubeSegments(nSegments, rMaterial);
     119             :             }
     120             : 
     121           2 :             class CapBuffer : boost::noncopyable
     122             :             {
     123             :             private:
     124             :                 // data for buffered cap primitives
     125             :                 Primitive3DSequence m_aLineCapList;
     126             :                 sal_uInt32 m_nLineCapSegments;
     127             :                 attribute::MaterialAttribute3D m_aLineMaterial;
     128             :                 ::osl::Mutex m_aMutex;
     129             :             public:
     130           2 :                 CapBuffer()
     131           2 :                     : m_nLineCapSegments(0)
     132             :                 {
     133           2 :                 }
     134         418 :                 Primitive3DSequence getLineCapSegments(
     135             :                     sal_uInt32 nSegments,
     136             :                     const attribute::MaterialAttribute3D& rMaterial)
     137             :                 {
     138             :                     // may exclusively change cached data, use mutex
     139         418 :                     ::osl::MutexGuard aGuard(m_aMutex);
     140             : 
     141         418 :                     if (nSegments != m_nLineCapSegments || !(rMaterial == m_aLineMaterial))
     142             :                     {
     143          10 :                         m_nLineCapSegments = nSegments;
     144          10 :                         m_aLineMaterial = rMaterial;
     145          10 :                         m_aLineCapList = Primitive3DSequence();
     146             :                     }
     147             : 
     148         418 :                     if (!m_aLineCapList.hasElements() && m_nLineCapSegments != 0)
     149             :                     {
     150          10 :                         const basegfx::B3DPoint aNull(0.0, 0.0, 0.0);
     151          20 :                         basegfx::B3DPoint aLast(0.0, 1.0, 0.0);
     152          20 :                         basegfx::B3DHomMatrix aRot;
     153          10 :                         aRot.rotate(F_2PI / (double)m_nLineCapSegments, 0.0, 0.0);
     154          10 :                         m_aLineCapList.realloc(m_nLineCapSegments);
     155             : 
     156          90 :                         for(sal_uInt32 a = 0; a < m_nLineCapSegments; ++a)
     157             :                         {
     158          80 :                             const basegfx::B3DPoint aNext(aRot * aLast);
     159         160 :                             basegfx::B3DPolygon aNewPolygon;
     160             : 
     161          80 :                             aNewPolygon.append(aLast);
     162          80 :                             aNewPolygon.setNormal(0L, basegfx::B3DVector(aLast - aNull));
     163             : 
     164          80 :                             aNewPolygon.append(aNext);
     165          80 :                             aNewPolygon.setNormal(1L, basegfx::B3DVector(aNext - aNull));
     166             : 
     167          80 :                             aNewPolygon.append(aNull);
     168          80 :                             aNewPolygon.setNormal(2L, basegfx::B3DVector(-1.0, 0.0, 0.0));
     169             : 
     170          80 :                             aNewPolygon.setClosed(true);
     171             : 
     172         160 :                             const basegfx::B3DPolyPolygon aNewPolyPolygon(aNewPolygon);
     173         160 :                             const Primitive3DReference xRef(new PolyPolygonMaterialPrimitive3D(aNewPolyPolygon, m_aLineMaterial, false));
     174          80 :                             m_aLineCapList[a] = xRef;
     175             : 
     176          80 :                             aLast = aNext;
     177          90 :                         }
     178             :                     }
     179             : 
     180         418 :                     return m_aLineCapList;
     181             :                 }
     182             :             };
     183             : 
     184             :             struct theCapBuffer :
     185             :                 public rtl::Static< CapBuffer, theCapBuffer > {};
     186             : 
     187         418 :             Primitive3DSequence getLineCapSegments(
     188             :                 sal_uInt32 nSegments,
     189             :                 const attribute::MaterialAttribute3D& rMaterial)
     190             :             {
     191             :                 // static data for buffered cap primitives
     192         418 :                 CapBuffer &rTheBuffer = theCapBuffer::get();
     193         418 :                 return rTheBuffer.getLineCapSegments(nSegments, rMaterial);
     194             :             }
     195             : 
     196           0 :             class CapRoundBuffer : boost::noncopyable
     197             :             {
     198             :             private:
     199             :                 // data for buffered capround primitives
     200             :                 Primitive3DSequence m_aLineCapRoundList;
     201             :                 sal_uInt32 m_nLineCapRoundSegments;
     202             :                 attribute::MaterialAttribute3D m_aLineMaterial;
     203             :                 ::osl::Mutex m_aMutex;
     204             :             public:
     205           0 :                 CapRoundBuffer()
     206           0 :                     : m_nLineCapRoundSegments(0)
     207             :                 {
     208           0 :                 }
     209           0 :                 Primitive3DSequence getLineCapRoundSegments(
     210             :                     sal_uInt32 nSegments,
     211             :                     const attribute::MaterialAttribute3D& rMaterial)
     212             :                 {
     213             :                     // may exclusively change cached data, use mutex
     214           0 :                     ::osl::MutexGuard aGuard(m_aMutex);
     215             : 
     216           0 :                     if (nSegments != m_nLineCapRoundSegments || !(rMaterial == m_aLineMaterial))
     217             :                     {
     218           0 :                         m_nLineCapRoundSegments = nSegments;
     219           0 :                         m_aLineMaterial = rMaterial;
     220           0 :                         m_aLineCapRoundList = Primitive3DSequence();
     221             :                     }
     222             : 
     223           0 :                     if (!m_aLineCapRoundList.hasElements() && m_nLineCapRoundSegments)
     224             :                     {
     225             :                         // calculate new horizontal segments
     226           0 :                         sal_uInt32 nVerSeg(nSegments / 2);
     227             : 
     228           0 :                         if (nVerSeg < 1)
     229             :                         {
     230           0 :                             nVerSeg = 1;
     231             :                         }
     232             : 
     233             :                         // create half-sphere; upper half of unit sphere
     234             :                         basegfx::B3DPolyPolygon aSphere(
     235             :                             basegfx::tools::createUnitSphereFillPolyPolygon(
     236             :                                 nSegments,
     237             :                                 nVerSeg,
     238             :                                 true,
     239             :                                 F_PI2, 0.0,
     240           0 :                                 0.0, F_2PI));
     241           0 :                         const sal_uInt32 nCount(aSphere.count());
     242             : 
     243           0 :                         if (nCount)
     244             :                         {
     245             :                             // rotate to have sphere cap orientned to negative X-Axis; do not
     246             :                             // forget to transform normals, too
     247           0 :                             basegfx::B3DHomMatrix aSphereTrans;
     248             : 
     249           0 :                             aSphereTrans.rotate(0.0, 0.0, F_PI2);
     250           0 :                             aSphere.transform(aSphereTrans);
     251           0 :                             aSphere.transformNormals(aSphereTrans);
     252             : 
     253             :                             // realloc for primitives and create based on polygon snippets
     254           0 :                             m_aLineCapRoundList.realloc(nCount);
     255             : 
     256           0 :                             for (sal_uInt32 a = 0; a < nCount; ++a)
     257             :                             {
     258           0 :                                 const basegfx::B3DPolygon aPartPolygon(aSphere.getB3DPolygon(a));
     259           0 :                                 const basegfx::B3DPolyPolygon aPartPolyPolygon(aPartPolygon);
     260             : 
     261             :                                 // need to create one primitive per Polygon since the primitive
     262             :                                 // is for planar PolyPolygons which is definitely not the case here
     263           0 :                                 m_aLineCapRoundList[a] = new PolyPolygonMaterialPrimitive3D(
     264             :                                     aPartPolyPolygon,
     265             :                                     rMaterial,
     266           0 :                                     false);
     267           0 :                             }
     268           0 :                         }
     269             :                     }
     270             : 
     271           0 :                     return m_aLineCapRoundList;
     272             :                 }
     273             : 
     274             :             };
     275             : 
     276             :             struct theCapRoundBuffer :
     277             :                 public rtl::Static< CapRoundBuffer, theCapRoundBuffer > {};
     278             : 
     279             : 
     280           0 :             Primitive3DSequence getLineCapRoundSegments(
     281             :                 sal_uInt32 nSegments,
     282             :                 const attribute::MaterialAttribute3D& rMaterial)
     283             :             {
     284             :                 // static data for buffered cap primitives
     285           0 :                 CapRoundBuffer &rTheBuffer = theCapRoundBuffer::get();
     286           0 :                 return rTheBuffer.getLineCapRoundSegments(nSegments, rMaterial);
     287             :             }
     288             : 
     289        4742 :             Primitive3DSequence getLineJoinSegments(
     290             :                 sal_uInt32 nSegments,
     291             :                 const attribute::MaterialAttribute3D& rMaterial,
     292             :                 double fAngle,
     293             :                 double /*fDegreeStepWidth*/,
     294             :                 double fMiterMinimumAngle,
     295             :                 basegfx::B2DLineJoin aLineJoin)
     296             :             {
     297             :                 // nSegments is for whole circle, adapt to half circle
     298        4742 :                 const sal_uInt32 nVerSeg(nSegments >> 1L);
     299        4742 :                 std::vector< BasePrimitive3D* > aResultVector;
     300             : 
     301        4742 :                 if(nVerSeg)
     302             :                 {
     303        4742 :                     if(basegfx::B2DLineJoin::Round == aLineJoin)
     304             :                     {
     305             :                         // calculate new horizontal segments
     306        4742 :                         const sal_uInt32 nHorSeg(basegfx::fround((fAngle / F_2PI) * (double)nSegments));
     307             : 
     308        4742 :                         if(nHorSeg)
     309             :                         {
     310             :                             // create half-sphere
     311         134 :                             const basegfx::B3DPolyPolygon aSphere(basegfx::tools::createUnitSphereFillPolyPolygon(nHorSeg, nVerSeg, true, F_PI2, -F_PI2, 0.0, fAngle));
     312             : 
     313        1206 :                             for(sal_uInt32 a(0L); a < aSphere.count(); a++)
     314             :                             {
     315        1072 :                                 const basegfx::B3DPolygon aPartPolygon(aSphere.getB3DPolygon(a));
     316        2144 :                                 const basegfx::B3DPolyPolygon aPartPolyPolygon(aPartPolygon);
     317        1072 :                                 BasePrimitive3D* pNew = new PolyPolygonMaterialPrimitive3D(aPartPolyPolygon, rMaterial, false);
     318        1072 :                                 aResultVector.push_back(pNew);
     319        1206 :                             }
     320             :                         }
     321             :                         else
     322             :                         {
     323             :                             // fallback to bevel when there is not at least one segment hor and ver
     324        4608 :                             aLineJoin = basegfx::B2DLineJoin::Bevel;
     325             :                         }
     326             :                     }
     327             : 
     328        4742 :                     if(basegfx::B2DLineJoin::Middle == aLineJoin
     329        4742 :                         || basegfx::B2DLineJoin::Bevel == aLineJoin
     330         134 :                         || basegfx::B2DLineJoin::Miter == aLineJoin)
     331             :                     {
     332        4608 :                         if(basegfx::B2DLineJoin::Miter == aLineJoin)
     333             :                         {
     334           0 :                             const double fMiterAngle(fAngle/2.0);
     335             : 
     336           0 :                             if(fMiterAngle < fMiterMinimumAngle)
     337             :                             {
     338             :                                 // fallback to bevel when miter's angle is too small
     339           0 :                                 aLineJoin = basegfx::B2DLineJoin::Bevel;
     340             :                             }
     341             :                         }
     342             : 
     343        4608 :                         const double fInc(F_PI / (double)nVerSeg);
     344        4608 :                         const double fSin(sin(-fAngle));
     345        4608 :                         const double fCos(cos(-fAngle));
     346        4608 :                         const bool bMiter(basegfx::B2DLineJoin::Miter == aLineJoin);
     347        4608 :                         const double fMiterSin(bMiter ? sin(-(fAngle/2.0)) : 0.0);
     348        4608 :                         const double fMiterCos(bMiter ? cos(-(fAngle/2.0)) : 0.0);
     349        4608 :                         double fPos(-F_PI2);
     350        9216 :                         basegfx::B3DPoint aPointOnXY, aPointRotY, aNextPointOnXY, aNextPointRotY;
     351        9216 :                         basegfx::B3DPoint aCurrMiter, aNextMiter;
     352        9216 :                         basegfx::B3DPolygon aNewPolygon, aMiterPolygon;
     353             : 
     354             :                         // close polygon
     355        4608 :                         aNewPolygon.setClosed(true);
     356        4608 :                         aMiterPolygon.setClosed(true);
     357             : 
     358       23040 :                         for(sal_uInt32 a(0L); a < nVerSeg; a++)
     359             :                         {
     360       18432 :                             const bool bFirst(0L == a);
     361       18432 :                             const bool bLast(a + 1L == nVerSeg);
     362             : 
     363       18432 :                             if(bFirst || !bLast)
     364             :                             {
     365       13824 :                                 fPos += fInc;
     366             : 
     367       27648 :                                 aNextPointOnXY = basegfx::B3DPoint(
     368             :                                     cos(fPos),
     369             :                                     sin(fPos),
     370       13824 :                                     0.0);
     371             : 
     372       41472 :                                 aNextPointRotY = basegfx::B3DPoint(
     373       13824 :                                     aNextPointOnXY.getX() * fCos,
     374             :                                     aNextPointOnXY.getY(),
     375       27648 :                                     aNextPointOnXY.getX() * fSin);
     376             : 
     377       13824 :                                 if(bMiter)
     378             :                                 {
     379           0 :                                     aNextMiter = basegfx::B3DPoint(
     380             :                                         aNextPointOnXY.getX(),
     381             :                                         aNextPointOnXY.getY(),
     382           0 :                                         fMiterSin * (aNextPointOnXY.getX() / fMiterCos));
     383             :                                 }
     384             :                             }
     385             : 
     386       18432 :                             if(bFirst)
     387             :                             {
     388        4608 :                                 aNewPolygon.clear();
     389             : 
     390        4608 :                                 if(bMiter)
     391             :                                 {
     392           0 :                                     aNewPolygon.append(basegfx::B3DPoint(0.0, -1.0, 0.0));
     393           0 :                                     aNewPolygon.append(aNextPointOnXY);
     394           0 :                                     aNewPolygon.append(aNextMiter);
     395             : 
     396           0 :                                     aMiterPolygon.clear();
     397           0 :                                     aMiterPolygon.append(basegfx::B3DPoint(0.0, -1.0, 0.0));
     398           0 :                                     aMiterPolygon.append(aNextMiter);
     399           0 :                                     aMiterPolygon.append(aNextPointRotY);
     400             :                                 }
     401             :                                 else
     402             :                                 {
     403        4608 :                                     aNewPolygon.append(basegfx::B3DPoint(0.0, -1.0, 0.0));
     404        4608 :                                     aNewPolygon.append(aNextPointOnXY);
     405        4608 :                                     aNewPolygon.append(aNextPointRotY);
     406             :                                 }
     407             :                             }
     408       13824 :                             else if(bLast)
     409             :                             {
     410        4608 :                                 aNewPolygon.clear();
     411             : 
     412        4608 :                                 if(bMiter)
     413             :                                 {
     414           0 :                                     aNewPolygon.append(basegfx::B3DPoint(0.0, 1.0, 0.0));
     415           0 :                                     aNewPolygon.append(aCurrMiter);
     416           0 :                                     aNewPolygon.append(aPointOnXY);
     417             : 
     418           0 :                                     aMiterPolygon.clear();
     419           0 :                                     aMiterPolygon.append(basegfx::B3DPoint(0.0, 1.0, 0.0));
     420           0 :                                     aMiterPolygon.append(aPointRotY);
     421           0 :                                     aMiterPolygon.append(aCurrMiter);
     422             :                                 }
     423             :                                 else
     424             :                                 {
     425        4608 :                                     aNewPolygon.append(basegfx::B3DPoint(0.0, 1.0, 0.0));
     426        4608 :                                     aNewPolygon.append(aPointRotY);
     427        4608 :                                     aNewPolygon.append(aPointOnXY);
     428             :                                 }
     429             :                             }
     430             :                             else
     431             :                             {
     432        9216 :                                 aNewPolygon.clear();
     433             : 
     434        9216 :                                 if(bMiter)
     435             :                                 {
     436           0 :                                     aNewPolygon.append(aPointOnXY);
     437           0 :                                     aNewPolygon.append(aNextPointOnXY);
     438           0 :                                     aNewPolygon.append(aNextMiter);
     439           0 :                                     aNewPolygon.append(aCurrMiter);
     440             : 
     441           0 :                                     aMiterPolygon.clear();
     442           0 :                                     aMiterPolygon.append(aCurrMiter);
     443           0 :                                     aMiterPolygon.append(aNextMiter);
     444           0 :                                     aMiterPolygon.append(aNextPointRotY);
     445           0 :                                     aMiterPolygon.append(aPointRotY);
     446             :                                 }
     447             :                                 else
     448             :                                 {
     449        9216 :                                     aNewPolygon.append(aPointRotY);
     450        9216 :                                     aNewPolygon.append(aPointOnXY);
     451        9216 :                                     aNewPolygon.append(aNextPointOnXY);
     452        9216 :                                     aNewPolygon.append(aNextPointRotY);
     453             :                                 }
     454             :                             }
     455             : 
     456             :                             // set normals
     457       82944 :                             for(sal_uInt32 b(0L); b < aNewPolygon.count(); b++)
     458             :                             {
     459       64512 :                                 aNewPolygon.setNormal(b, basegfx::B3DVector(aNewPolygon.getB3DPoint(b)));
     460             :                             }
     461             : 
     462             :                             // create primitive
     463       18432 :                             if(aNewPolygon.count())
     464             :                             {
     465       18432 :                                 const basegfx::B3DPolyPolygon aNewPolyPolygon(aNewPolygon);
     466       18432 :                                 BasePrimitive3D* pNew = new PolyPolygonMaterialPrimitive3D(aNewPolyPolygon, rMaterial, false);
     467       18432 :                                 aResultVector.push_back(pNew);
     468             :                             }
     469             : 
     470       18432 :                             if(bMiter && aMiterPolygon.count())
     471             :                             {
     472             :                                 // set normals
     473           0 :                                 for(sal_uInt32 c(0L); c < aMiterPolygon.count(); c++)
     474             :                                 {
     475           0 :                                     aMiterPolygon.setNormal(c, basegfx::B3DVector(aMiterPolygon.getB3DPoint(c)));
     476             :                                 }
     477             : 
     478             :                                 // create primitive
     479           0 :                                 const basegfx::B3DPolyPolygon aMiterPolyPolygon(aMiterPolygon);
     480           0 :                                 BasePrimitive3D* pNew = new PolyPolygonMaterialPrimitive3D(aMiterPolyPolygon, rMaterial, false);
     481           0 :                                 aResultVector.push_back(pNew);
     482             :                             }
     483             : 
     484             :                             // prepare next step
     485       18432 :                             if(bFirst || !bLast)
     486             :                             {
     487       13824 :                                 aPointOnXY = aNextPointOnXY;
     488       13824 :                                 aPointRotY = aNextPointRotY;
     489             : 
     490       13824 :                                 if(bMiter)
     491             :                                 {
     492           0 :                                     aCurrMiter = aNextMiter;
     493             :                                 }
     494             :                             }
     495        4608 :                         }
     496             :                     }
     497             :                 }
     498             : 
     499        4742 :                 Primitive3DSequence aRetval(aResultVector.size());
     500             : 
     501       24246 :                 for(size_t a(0); a < aResultVector.size(); a++)
     502             :                 {
     503       19504 :                     aRetval[a] = Primitive3DReference(aResultVector[a]);
     504             :                 }
     505             : 
     506        4742 :                 return aRetval;
     507             :             }
     508             : 
     509        4951 :             basegfx::B3DHomMatrix getRotationFromVector(const basegfx::B3DVector& rVector)
     510             :             {
     511             :                 // build transformation from unit vector to vector
     512        4951 :                 basegfx::B3DHomMatrix aRetval;
     513             : 
     514             :                 // get applied rotations from angles in XY and in XZ (cartesian)
     515        4951 :                 const double fRotInXY(atan2(rVector.getY(), rVector.getXZLength()));
     516        4951 :                 const double fRotInXZ(atan2(-rVector.getZ(), rVector.getX()));
     517             : 
     518             :                 // apply rotations. Rot around Z needs to be done first, so apply in two steps
     519        4951 :                 aRetval.rotate(0.0, 0.0, fRotInXY);
     520        4951 :                 aRetval.rotate(0.0, fRotInXZ, 0.0);
     521             : 
     522        4951 :                 return aRetval;
     523             :             }
     524             :         } // end of anonymous namespace
     525             :     } // end of namespace primitive3d
     526             : } // end of namespace drawinglayer
     527             : 
     528             : 
     529             : 
     530             : using namespace com::sun::star;
     531             : 
     532             : 
     533             : 
     534             : namespace drawinglayer
     535             : {
     536             :     namespace primitive3d
     537             :     {
     538         449 :         Primitive3DSequence PolygonTubePrimitive3D::impCreate3DDecomposition(const geometry::ViewInformation3D& /*rViewInformation*/) const
     539             :         {
     540         449 :             const sal_uInt32 nPointCount(getB3DPolygon().count());
     541         449 :             std::vector< BasePrimitive3D* > aResultVector;
     542             : 
     543         449 :             if(nPointCount)
     544             :             {
     545         449 :                 if(basegfx::fTools::more(getRadius(), 0.0))
     546             :                 {
     547         449 :                     const attribute::MaterialAttribute3D aMaterial(getBColor());
     548             :                     static sal_uInt32 nSegments(8); // default for 3d line segments, for more quality just raise this value (in even steps)
     549         449 :                     const bool bClosed(getB3DPolygon().isClosed());
     550         449 :                     const bool bNoLineJoin(basegfx::B2DLineJoin::NONE == getLineJoin());
     551         449 :                     const sal_uInt32 nLoopCount(bClosed ? nPointCount : nPointCount - 1);
     552         898 :                     basegfx::B3DPoint aLast(getB3DPolygon().getB3DPoint(nPointCount - 1));
     553         898 :                     basegfx::B3DPoint aCurr(getB3DPolygon().getB3DPoint(0));
     554             : 
     555        5496 :                     for(sal_uInt32 a(0); a < nLoopCount; a++)
     556             :                     {
     557             :                         // get next data
     558        5047 :                         const basegfx::B3DPoint aNext(getB3DPolygon().getB3DPoint((a + 1) % nPointCount));
     559       10094 :                         const basegfx::B3DVector aForw(aNext - aCurr);
     560        5047 :                         const double fForwLen(aForw.getLength());
     561             : 
     562        5047 :                         if(basegfx::fTools::more(fForwLen, 0.0))
     563             :                         {
     564             :                             // find out if linecap is active
     565        4951 :                             const bool bFirst(!a);
     566        4951 :                             const bool bLast(a + 1 == nLoopCount);
     567        4951 :                             const bool bLineCapPossible(!bClosed && (bFirst || bLast));
     568        4951 :                             const bool bLineCapRound(bLineCapPossible && com::sun::star::drawing::LineCap_ROUND == getLineCap());
     569        4951 :                             const bool bLineCapSquare(bLineCapPossible && com::sun::star::drawing::LineCap_SQUARE == getLineCap());
     570             : 
     571             :                             // get rotation from vector, this describes rotation from (1, 0, 0) to aForw
     572        4951 :                             basegfx::B3DHomMatrix aRotVector(getRotationFromVector(aForw));
     573             : 
     574             :                             // prepare transformations for tube and cap
     575        9902 :                             basegfx::B3DHomMatrix aTubeTrans;
     576        9902 :                             basegfx::B3DHomMatrix aCapTrans;
     577             : 
     578             :                             // cap gets radius size
     579        4951 :                             aCapTrans.scale(getRadius(), getRadius(), getRadius());
     580             : 
     581        4951 :                             if(bLineCapSquare)
     582             :                             {
     583             :                                 // when square line cap just prolong line segment in X, maybe 2 x radius when
     584             :                                 // first and last (simple line segment)
     585           0 :                                 const double fExtraLength(bFirst && bLast ? getRadius() * 2.0 : getRadius());
     586             : 
     587           0 :                                 aTubeTrans.scale(fForwLen + fExtraLength, getRadius(), getRadius());
     588             : 
     589           0 :                                 if(bFirst)
     590             :                                 {
     591             :                                     // correct start positions for tube and cap when first and square prolonged
     592           0 :                                     aTubeTrans.translate(-getRadius(), 0.0, 0.0);
     593           0 :                                     aCapTrans.translate(-getRadius(), 0.0, 0.0);
     594             :                                 }
     595             :                             }
     596             :                             else
     597             :                             {
     598             :                                 // normal tube size
     599        4951 :                                 aTubeTrans.scale(fForwLen, getRadius(), getRadius());
     600             :                             }
     601             : 
     602             :                             // rotate and translate tube and cap
     603        4951 :                             aTubeTrans *= aRotVector;
     604        4951 :                             aTubeTrans.translate(aCurr.getX(), aCurr.getY(), aCurr.getZ());
     605        4951 :                             aCapTrans *= aRotVector;
     606        4951 :                             aCapTrans.translate(aCurr.getX(), aCurr.getY(), aCurr.getZ());
     607             : 
     608        4951 :                             if(bNoLineJoin || (!bClosed && bFirst))
     609             :                             {
     610             :                                 // line start edge, build transformed primitiveVector3D
     611         209 :                                 Primitive3DSequence aSequence;
     612             : 
     613         209 :                                 if(bLineCapRound && bFirst)
     614             :                                 {
     615             :                                     // LineCapRound used
     616           0 :                                     aSequence = getLineCapRoundSegments(nSegments, aMaterial);
     617             :                                 }
     618             :                                 else
     619             :                                 {
     620             :                                     // simple closing cap
     621         209 :                                     aSequence = getLineCapSegments(nSegments, aMaterial);
     622             :                                 }
     623             : 
     624         209 :                                 TransformPrimitive3D* pNewTransformedA = new TransformPrimitive3D(aCapTrans, aSequence);
     625         209 :                                 aResultVector.push_back(pNewTransformedA);
     626             :                             }
     627             :                             else
     628             :                             {
     629        4742 :                                 const basegfx::B3DVector aBack(aCurr - aLast);
     630        4742 :                                 const double fCross(basegfx::cross(aBack, aForw).getLength());
     631             : 
     632        4742 :                                 if(!basegfx::fTools::equalZero(fCross))
     633             :                                 {
     634             :                                     // line connect non-parallel, aBack, aForw, use getLineJoin()
     635        4742 :                                     const double fAngle(acos(aBack.scalar(aForw) / (fForwLen * aBack.getLength()))); // 0.0 .. F_PI2
     636             :                                     Primitive3DSequence aNewList(
     637             :                                         getLineJoinSegments(
     638             :                                             nSegments,
     639             :                                             aMaterial,
     640             :                                             fAngle,
     641             :                                             getDegreeStepWidth(),
     642             :                                             getMiterMinimumAngle(),
     643        4742 :                                             getLineJoin()));
     644             : 
     645             :                                     // calculate transformation. First, get angle in YZ between nForw projected on (1, 0, 0) and nBack
     646        9484 :                                     basegfx::B3DHomMatrix aInvRotVector(aRotVector);
     647        4742 :                                     aInvRotVector.invert();
     648        9484 :                                     basegfx::B3DVector aTransBack(aInvRotVector * aBack);
     649        4742 :                                     const double fRotInYZ(atan2(aTransBack.getY(), aTransBack.getZ()));
     650             : 
     651             :                                     // create trans by rotating unit sphere with angle 90 degrees around Y, then 180-fRot in X.
     652             :                                     // Also apply usual scaling and translation
     653        9484 :                                     basegfx::B3DHomMatrix aSphereTrans;
     654        4742 :                                     aSphereTrans.rotate(0.0, F_PI2, 0.0);
     655        4742 :                                     aSphereTrans.rotate(F_PI - fRotInYZ, 0.0, 0.0);
     656        4742 :                                     aSphereTrans *= aRotVector;
     657        4742 :                                     aSphereTrans.scale(getRadius(), getRadius(), getRadius());
     658        4742 :                                     aSphereTrans.translate(aCurr.getX(), aCurr.getY(), aCurr.getZ());
     659             : 
     660             :                                     // line start edge, build transformed primitiveVector3D
     661             :                                     aResultVector.push_back(
     662             :                                         new TransformPrimitive3D(
     663             :                                             aSphereTrans,
     664        9484 :                                             aNewList));
     665        4742 :                                 }
     666             :                             }
     667             : 
     668             :                             // create line segments, build transformed primitiveVector3D
     669             :                             aResultVector.push_back(
     670             :                                 new TransformPrimitive3D(
     671             :                                     aTubeTrans,
     672        4951 :                                     getLineTubeSegments(nSegments, aMaterial)));
     673             : 
     674        4951 :                             if(bNoLineJoin || (!bClosed && bLast))
     675             :                             {
     676             :                                 // line end edge
     677         209 :                                 basegfx::B3DHomMatrix aBackCapTrans;
     678             : 
     679             :                                 // Mirror (line end) and radius scale
     680         209 :                                 aBackCapTrans.rotate(0.0, F_PI, 0.0);
     681         209 :                                 aBackCapTrans.scale(getRadius(), getRadius(), getRadius());
     682             : 
     683         209 :                                 if(bLineCapSquare && bLast)
     684             :                                 {
     685             :                                     // correct position when square and prolonged
     686           0 :                                     aBackCapTrans.translate(fForwLen + getRadius(), 0.0, 0.0);
     687             :                                 }
     688             :                                 else
     689             :                                 {
     690             :                                     // standard position
     691         209 :                                     aBackCapTrans.translate(fForwLen, 0.0, 0.0);
     692             :                                 }
     693             : 
     694             :                                 // rotate and translate to destination
     695         209 :                                 aBackCapTrans *= aRotVector;
     696         209 :                                 aBackCapTrans.translate(aCurr.getX(), aCurr.getY(), aCurr.getZ());
     697             : 
     698             :                                 // get primitiveVector3D
     699         418 :                                 Primitive3DSequence aSequence;
     700             : 
     701         209 :                                 if(bLineCapRound && bLast)
     702             :                                 {
     703             :                                     // LineCapRound used
     704           0 :                                     aSequence = getLineCapRoundSegments(nSegments, aMaterial);
     705             :                                 }
     706             :                                 else
     707             :                                 {
     708             :                                     // simple closing cap
     709         209 :                                     aSequence = getLineCapSegments(nSegments, aMaterial);
     710             :                                 }
     711             : 
     712             :                                 aResultVector.push_back(
     713             :                                     new TransformPrimitive3D(
     714             :                                         aBackCapTrans,
     715         418 :                                         aSequence));
     716        4951 :                             }
     717             :                         }
     718             : 
     719             :                         // prepare next loop step
     720        5047 :                         aLast = aCurr;
     721        5047 :                         aCurr = aNext;
     722        5496 :                     }
     723             :                 }
     724             :                 else
     725             :                 {
     726             :                     // create hairline
     727           0 :                     PolygonHairlinePrimitive3D* pNew = new PolygonHairlinePrimitive3D(getB3DPolygon(), getBColor());
     728           0 :                     aResultVector.push_back(pNew);
     729             :                 }
     730             :             }
     731             : 
     732             :             // prepare return value
     733         449 :             Primitive3DSequence aRetval(aResultVector.size());
     734             : 
     735       10560 :             for(size_t a(0); a < aResultVector.size(); a++)
     736             :             {
     737       10111 :                 aRetval[a] = Primitive3DReference(aResultVector[a]);
     738             :             }
     739             : 
     740         449 :             return aRetval;
     741             :         }
     742             : 
     743         449 :         PolygonTubePrimitive3D::PolygonTubePrimitive3D(
     744             :             const basegfx::B3DPolygon& rPolygon,
     745             :             const basegfx::BColor& rBColor,
     746             :             double fRadius, basegfx::B2DLineJoin aLineJoin,
     747             :             com::sun::star::drawing::LineCap aLineCap,
     748             :             double fDegreeStepWidth,
     749             :             double fMiterMinimumAngle)
     750             :         :   PolygonHairlinePrimitive3D(rPolygon, rBColor),
     751             :             maLast3DDecomposition(),
     752             :             mfRadius(fRadius),
     753             :             mfDegreeStepWidth(fDegreeStepWidth),
     754             :             mfMiterMinimumAngle(fMiterMinimumAngle),
     755             :             maLineJoin(aLineJoin),
     756         449 :             maLineCap(aLineCap)
     757             :         {
     758         449 :         }
     759             : 
     760           0 :         bool PolygonTubePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
     761             :         {
     762           0 :             if(PolygonHairlinePrimitive3D::operator==(rPrimitive))
     763             :             {
     764           0 :                 const PolygonTubePrimitive3D& rCompare = static_cast<const PolygonTubePrimitive3D&>(rPrimitive);
     765             : 
     766           0 :                 return (getRadius() == rCompare.getRadius()
     767           0 :                     && getDegreeStepWidth() == rCompare.getDegreeStepWidth()
     768           0 :                     && getMiterMinimumAngle() == rCompare.getMiterMinimumAngle()
     769           0 :                     && getLineJoin() == rCompare.getLineJoin()
     770           0 :                     && getLineCap() == rCompare.getLineCap());
     771             :             }
     772             : 
     773           0 :             return false;
     774             :         }
     775             : 
     776         535 :         Primitive3DSequence PolygonTubePrimitive3D::get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const
     777             :         {
     778         535 :             ::osl::MutexGuard aGuard( m_aMutex );
     779             : 
     780         535 :             if(!getLast3DDecomposition().hasElements())
     781             :             {
     782         449 :                 const Primitive3DSequence aNewSequence(impCreate3DDecomposition(rViewInformation));
     783         449 :                 const_cast< PolygonTubePrimitive3D* >(this)->setLast3DDecomposition(aNewSequence);
     784             :             }
     785             : 
     786         535 :             return getLast3DDecomposition();
     787             :         }
     788             : 
     789             :         // provide unique ID
     790         535 :         ImplPrimitive3DIDBlock(PolygonTubePrimitive3D, PRIMITIVE3D_ID_POLYGONTUBEPRIMITIVE3D)
     791             : 
     792             :     } // end of namespace primitive3d
     793             : } // end of namespace drawinglayer
     794             : 
     795             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11