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