basegfx/source/polygon/b3dpolygon.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 <osl/diagnose.h>
  21 #include <basegfx/polygon/b3dpolygon.hxx>
  22 #include <basegfx/point/b3dpoint.hxx>
  23 #include <basegfx/matrix/b3dhommatrix.hxx>
  24 #include <basegfx/point/b2dpoint.hxx>
  25 #include <basegfx/color/bcolor.hxx>
  26 #include <basegfx/matrix/b2dhommatrix.hxx>
  27 #include <cassert>
  28 #include <memory>
  29 #include <utility>
  30 #include <vector>
  31 #include <algorithm>
  32
  33 namespace {
  34
  35 class CoordinateData3D
  36 {
  37     basegfx::B3DPoint                               maPoint;
  38
  39 public:
  40     CoordinateData3D()
  41     {
  42     }
  43
  44     explicit CoordinateData3D(const basegfx::B3DPoint& rData)
  45     :   maPoint(rData)
  46     {
  47     }
  48
  49     const basegfx::B3DPoint& getCoordinate() const
  50     {
  51         return maPoint;
  52     }
  53
  54     void setCoordinate(const basegfx::B3DPoint& rValue)
  55     {
  56         if(rValue != maPoint)
  57             maPoint = rValue;
  58     }
  59
  60     bool operator==(const CoordinateData3D& rData) const
  61     {
  62         return (maPoint == rData.getCoordinate());
  63     }
  64
  65     void transform(const basegfx::B3DHomMatrix& rMatrix)
  66     {
  67         maPoint *= rMatrix;
  68     }
  69 };
  70
  71 class CoordinateDataArray3D
  72 {
  73     typedef std::vector< CoordinateData3D > CoordinateData3DVector;
  74
  75     CoordinateData3DVector                          maVector;
  76
  77 public:
  78     explicit CoordinateDataArray3D(sal_uInt32 nCount)
  79     :   maVector(nCount)
  80     {
  81     }
  82
  83     CoordinateDataArray3D(const CoordinateDataArray3D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
  84     :   maVector(rOriginal.maVector.begin() + nIndex, rOriginal.maVector.begin() + (nIndex + nCount))
  85     {
  86     }
  87
  88     ::basegfx::B3DVector getNormal() const
  89     {
  90         ::basegfx::B3DVector aRetval;
  91         const sal_uInt32 nPointCount(maVector.size());
  92
  93         if(nPointCount > 2)
  94         {
  95             sal_uInt32 nISmallest(0);
  96             sal_uInt32 a(0);
  97             const basegfx::B3DPoint* pSmallest(&maVector[0].getCoordinate());
  98             const basegfx::B3DPoint* pNext(nullptr);
  99             const basegfx::B3DPoint* pPrev(nullptr);
 100
 101             // To guarantee a correctly oriented point, choose an outmost one
 102             // which then cannot be concave
 103             for(a = 1; a < nPointCount; a++)
 104             {
 105                 const basegfx::B3DPoint& rCandidate = maVector[a].getCoordinate();
 106
 107                 if((rCandidate.getX() < pSmallest->getX())
 108                     || (rCandidate.getX() == pSmallest->getX() && rCandidate.getY() < pSmallest->getY())
 109                     || (rCandidate.getX() == pSmallest->getX() && rCandidate.getY() == pSmallest->getY() && rCandidate.getZ() < pSmallest->getZ()))
 110                 {
 111                     nISmallest = a;
 112                     pSmallest = &rCandidate;
 113                 }
 114             }
 115
 116             // look for a next point different from minimal one
 117             for(a = (nISmallest + 1) % nPointCount; a != nISmallest; a = (a + 1) % nPointCount)
 118             {
 119                 const basegfx::B3DPoint& rCandidate = maVector[a].getCoordinate();
 120
 121                 if(!rCandidate.equal(*pSmallest))
 122                 {
 123                     pNext = &rCandidate;
 124                     break;
 125                 }
 126             }
 127
 128             // look for a previous point different from minimal one
 129             for(a = (nISmallest + nPointCount - 1) % nPointCount; a != nISmallest; a = (a + nPointCount - 1) % nPointCount)
 130             {
 131                 const basegfx::B3DPoint& rCandidate = maVector[a].getCoordinate();
 132
 133                 if(!rCandidate.equal(*pSmallest))
 134                 {
 135                     pPrev = &rCandidate;
 136                     break;
 137                 }
 138             }
 139
 140             // we always have a minimal point. If we also have a different next and previous,
 141             // we can calculate the normal
 142             if(pNext && pPrev)
 143             {
 144                 const basegfx::B3DVector aPrev(*pPrev - *pSmallest);
 145                 const basegfx::B3DVector aNext(*pNext - *pSmallest);
 146
 147                 aRetval = cross(aPrev, aNext);
 148                 aRetval.normalize();
 149             }
 150         }
 151
 152         return aRetval;
 153     }
 154
 155     sal_uInt32 count() const
 156     {
 157         return maVector.size();
 158     }
 159
 160     bool operator==(const CoordinateDataArray3D& rCandidate) const
 161     {
 162         return (maVector == rCandidate.maVector);
 163     }
 164
 165     const basegfx::B3DPoint& getCoordinate(sal_uInt32 nIndex) const
 166     {
 167         return maVector[nIndex].getCoordinate();
 168     }
 169
 170     void setCoordinate(sal_uInt32 nIndex, const basegfx::B3DPoint& rValue)
 171     {
 172         maVector[nIndex].setCoordinate(rValue);
 173     }
 174
 175     void insert(sal_uInt32 nIndex, const CoordinateData3D& rValue, sal_uInt32 nCount)
 176     {
 177         if(nCount)
 178         {
 179             // add nCount copies of rValue
 180             CoordinateData3DVector::iterator aIndex(maVector.begin());
 181             aIndex += nIndex;
 182             maVector.insert(aIndex, nCount, rValue);
 183         }
 184     }
 185
 186     void insert(sal_uInt32 nIndex, const CoordinateDataArray3D& rSource)
 187     {
 188         const sal_uInt32 nCount(rSource.maVector.size());
 189
 190         if(nCount)
 191         {
 192             // insert data
 193             CoordinateData3DVector::iterator aIndex(maVector.begin());
 194             aIndex += nIndex;
 195             CoordinateData3DVector::const_iterator aStart(rSource.maVector.begin());
 196             CoordinateData3DVector::const_iterator aEnd(rSource.maVector.end());
 197             maVector.insert(aIndex, aStart, aEnd);
 198         }
 199     }
 200
 201     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 202     {
 203         if(nCount)
 204         {
 205             // remove point data
 206             CoordinateData3DVector::iterator aStart(maVector.begin());
 207             aStart += nIndex;
 208             const CoordinateData3DVector::iterator aEnd(aStart + nCount);
 209             maVector.erase(aStart, aEnd);
 210         }
 211     }
 212
 213     void flip()
 214     {
 215         if(maVector.size() <= 1)
 216             return;
 217
 218         const sal_uInt32 nHalfSize(maVector.size() >> 1);
 219         CoordinateData3DVector::iterator aStart(maVector.begin());
 220         CoordinateData3DVector::iterator aEnd(maVector.end() - 1);
 221
 222         for(sal_uInt32 a(0); a < nHalfSize; a++)
 223         {
 224             std::swap(*aStart, *aEnd);
 225             ++aStart;
 226             --aEnd;
 227         }
 228     }
 229
 230     void transform(const ::basegfx::B3DHomMatrix& rMatrix)
 231     {
 232         for (auto & elem : maVector)
 233         {
 234             elem.transform(rMatrix);
 235         }
 236     }
 237 };
 238
 239 class BColorArray
 240 {
 241     typedef std::vector< ::basegfx::BColor > BColorDataVector;
 242
 243     BColorDataVector                                    maVector;
 244     sal_uInt32                                          mnUsedEntries;
 245
 246 public:
 247     explicit BColorArray(sal_uInt32 nCount)
 248     :   maVector(nCount),
 249         mnUsedEntries(0)
 250     {
 251     }
 252
 253     BColorArray(const BColorArray& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
 254     :   mnUsedEntries(0)
 255     {
 256         BColorDataVector::const_iterator aStart(rOriginal.maVector.begin());
 257         aStart += nIndex;
 258         BColorDataVector::const_iterator aEnd(aStart);
 259         assert(nCount <= rOriginal.maVector.size());
 260         aEnd += nCount;
 261         maVector.reserve(nCount);
 262
 263         for(; aStart != aEnd; ++aStart)
 264         {
 265             if(!aStart->equalZero())
 266                 mnUsedEntries++;
 267
 268             maVector.push_back(*aStart);
 269         }
 270     }
 271
 272     bool operator==(const BColorArray& rCandidate) const
 273     {
 274         return (maVector == rCandidate.maVector);
 275     }
 276
 277     bool isUsed() const
 278     {
 279         return (mnUsedEntries != 0);
 280     }
 281
 282     const ::basegfx::BColor& getBColor(sal_uInt32 nIndex) const
 283     {
 284         return maVector[nIndex];
 285     }
 286
 287     void setBColor(sal_uInt32 nIndex, const ::basegfx::BColor& rValue)
 288     {
 289         bool bWasUsed(mnUsedEntries && !maVector[nIndex].equalZero());
 290         bool bIsUsed(!rValue.equalZero());
 291
 292         if(bWasUsed)
 293         {
 294             if(bIsUsed)
 295             {
 296                 maVector[nIndex] = rValue;
 297             }
 298             else
 299             {
 300                 maVector[nIndex] = ::basegfx::BColor::getEmptyBColor();
 301                 mnUsedEntries--;
 302             }
 303         }
 304         else
 305         {
 306             if(bIsUsed)
 307             {
 308                 maVector[nIndex] = rValue;
 309                 mnUsedEntries++;
 310             }
 311         }
 312     }
 313
 314     void insert(sal_uInt32 nIndex, const ::basegfx::BColor& rValue, sal_uInt32 nCount)
 315     {
 316         if(nCount)
 317         {
 318             // add nCount copies of rValue
 319             BColorDataVector::iterator aIndex(maVector.begin());
 320             aIndex += nIndex;
 321             maVector.insert(aIndex, nCount, rValue);
 322
 323             if(!rValue.equalZero())
 324                 mnUsedEntries += nCount;
 325         }
 326     }
 327
 328     void insert(sal_uInt32 nIndex, const BColorArray& rSource)
 329     {
 330         const sal_uInt32 nCount(rSource.maVector.size());
 331
 332         if(nCount)
 333         {
 334             // insert data
 335             BColorDataVector::iterator aIndex(maVector.begin());
 336             aIndex += nIndex;
 337             BColorDataVector::const_iterator aStart(rSource.maVector.begin());
 338             BColorDataVector::const_iterator aEnd(rSource.maVector.end());
 339             maVector.insert(aIndex, aStart, aEnd);
 340
 341             mnUsedEntries += std::count_if(aStart, aEnd,
 342                 [](BColorDataVector::const_reference rData) { return !rData.equalZero(); });
 343         }
 344     }
 345
 346     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 347     {
 348         if(nCount)
 349         {
 350             const BColorDataVector::iterator aDeleteStart(maVector.begin() + nIndex);
 351             const BColorDataVector::iterator aDeleteEnd(aDeleteStart + nCount);
 352
 353             auto nDeleteUsed = std::count_if(aDeleteStart, aDeleteEnd,
 354                 [](BColorDataVector::const_reference rData) { return !rData.equalZero(); });
 355             mnUsedEntries -= std::min(mnUsedEntries, static_cast<sal_uInt32>(nDeleteUsed));
 356
 357             // remove point data
 358             maVector.erase(aDeleteStart, aDeleteEnd);
 359         }
 360     }
 361
 362     void flip()
 363     {
 364         if(maVector.size() <= 1)
 365             return;
 366
 367         const sal_uInt32 nHalfSize(maVector.size() >> 1);
 368         BColorDataVector::iterator aStart(maVector.begin());
 369         BColorDataVector::iterator aEnd(maVector.end() - 1);
 370
 371         for(sal_uInt32 a(0); a < nHalfSize; a++)
 372         {
 373             std::swap(*aStart, *aEnd);
 374             ++aStart;
 375             --aEnd;
 376         }
 377     }
 378 };
 379
 380 class NormalsArray3D
 381 {
 382     typedef std::vector< ::basegfx::B3DVector > NormalsData3DVector;
 383
 384     NormalsData3DVector                                 maVector;
 385     sal_uInt32                                          mnUsedEntries;
 386
 387 public:
 388     explicit NormalsArray3D(sal_uInt32 nCount)
 389     :   maVector(nCount),
 390         mnUsedEntries(0)
 391     {
 392     }
 393
 394     NormalsArray3D(const NormalsArray3D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
 395     :   mnUsedEntries(0)
 396     {
 397         NormalsData3DVector::const_iterator aStart(rOriginal.maVector.begin());
 398         aStart += nIndex;
 399         NormalsData3DVector::const_iterator aEnd(aStart);
 400         aEnd += nCount;
 401         maVector.reserve(nCount);
 402
 403         for(; aStart != aEnd; ++aStart)
 404         {
 405             if(!aStart->equalZero())
 406                 mnUsedEntries++;
 407
 408             maVector.push_back(*aStart);
 409         }
 410     }
 411
 412     bool operator==(const NormalsArray3D& rCandidate) const
 413     {
 414         return (maVector == rCandidate.maVector);
 415     }
 416
 417     bool isUsed() const
 418     {
 419         return (mnUsedEntries != 0);
 420     }
 421
 422     const ::basegfx::B3DVector& getNormal(sal_uInt32 nIndex) const
 423     {
 424         return maVector[nIndex];
 425     }
 426
 427     void setNormal(sal_uInt32 nIndex, const ::basegfx::B3DVector& rValue)
 428     {
 429         bool bWasUsed(mnUsedEntries && !maVector[nIndex].equalZero());
 430         bool bIsUsed(!rValue.equalZero());
 431
 432         if(bWasUsed)
 433         {
 434             if(bIsUsed)
 435             {
 436                 maVector[nIndex] = rValue;
 437             }
 438             else
 439             {
 440                 maVector[nIndex] = ::basegfx::B3DVector::getEmptyVector();
 441                 mnUsedEntries--;
 442             }
 443         }
 444         else
 445         {
 446             if(bIsUsed)
 447             {
 448                 maVector[nIndex] = rValue;
 449                 mnUsedEntries++;
 450             }
 451         }
 452     }
 453
 454     void insert(sal_uInt32 nIndex, const ::basegfx::B3DVector& rValue, sal_uInt32 nCount)
 455     {
 456         if(nCount)
 457         {
 458             // add nCount copies of rValue
 459             NormalsData3DVector::iterator aIndex(maVector.begin());
 460             aIndex += nIndex;
 461             maVector.insert(aIndex, nCount, rValue);
 462
 463             if(!rValue.equalZero())
 464                 mnUsedEntries += nCount;
 465         }
 466     }
 467
 468     void insert(sal_uInt32 nIndex, const NormalsArray3D& rSource)
 469     {
 470         const sal_uInt32 nCount(rSource.maVector.size());
 471
 472         if(nCount)
 473         {
 474             // insert data
 475             NormalsData3DVector::iterator aIndex(maVector.begin());
 476             aIndex += nIndex;
 477             NormalsData3DVector::const_iterator aStart(rSource.maVector.begin());
 478             NormalsData3DVector::const_iterator aEnd(rSource.maVector.end());
 479             maVector.insert(aIndex, aStart, aEnd);
 480
 481             mnUsedEntries += std::count_if(aStart, aEnd,
 482                 [](NormalsData3DVector::const_reference rData) { return !rData.equalZero(); });
 483         }
 484     }
 485
 486     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 487     {
 488         if(nCount)
 489         {
 490             const NormalsData3DVector::iterator aDeleteStart(maVector.begin() + nIndex);
 491             const NormalsData3DVector::iterator aDeleteEnd(aDeleteStart + nCount);
 492
 493             auto nDeleteUsed = std::count_if(aDeleteStart, aDeleteEnd,
 494                 [](NormalsData3DVector::const_reference rData) { return !rData.equalZero(); });
 495             mnUsedEntries -= std::min(mnUsedEntries, static_cast<sal_uInt32>(nDeleteUsed));
 496
 497             // remove point data
 498             maVector.erase(aDeleteStart, aDeleteEnd);
 499         }
 500     }
 501
 502     void flip()
 503     {
 504         if(maVector.size() <= 1)
 505             return;
 506
 507         const sal_uInt32 nHalfSize(maVector.size() >> 1);
 508         NormalsData3DVector::iterator aStart(maVector.begin());
 509         NormalsData3DVector::iterator aEnd(maVector.end() - 1);
 510
 511         for(sal_uInt32 a(0); a < nHalfSize; a++)
 512         {
 513             std::swap(*aStart, *aEnd);
 514             ++aStart;
 515             --aEnd;
 516         }
 517     }
 518
 519     void transform(const basegfx::B3DHomMatrix& rMatrix)
 520     {
 521         for (auto & elem : maVector)
 522         {
 523             elem *= rMatrix;
 524         }
 525     }
 526 };
 527
 528 class TextureCoordinate2D
 529 {
 530     typedef std::vector< ::basegfx::B2DPoint > TextureData2DVector;
 531
 532     TextureData2DVector                                 maVector;
 533     sal_uInt32                                          mnUsedEntries;
 534
 535 public:
 536     explicit TextureCoordinate2D(sal_uInt32 nCount)
 537     :   maVector(nCount),
 538         mnUsedEntries(0)
 539     {
 540     }
 541
 542     TextureCoordinate2D(const TextureCoordinate2D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
 543     :   mnUsedEntries(0)
 544     {
 545         TextureData2DVector::const_iterator aStart(rOriginal.maVector.begin());
 546         aStart += nIndex;
 547         TextureData2DVector::const_iterator aEnd(aStart);
 548         aEnd += nCount;
 549         maVector.reserve(nCount);
 550
 551         for(; aStart != aEnd; ++aStart)
 552         {
 553             if(!aStart->equalZero())
 554                 mnUsedEntries++;
 555
 556             maVector.push_back(*aStart);
 557         }
 558     }
 559
 560     bool operator==(const TextureCoordinate2D& rCandidate) const
 561     {
 562         return (maVector == rCandidate.maVector);
 563     }
 564
 565     bool isUsed() const
 566     {
 567         return (mnUsedEntries != 0);
 568     }
 569
 570     const ::basegfx::B2DPoint& getTextureCoordinate(sal_uInt32 nIndex) const
 571     {
 572         return maVector[nIndex];
 573     }
 574
 575     void setTextureCoordinate(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue)
 576     {
 577         bool bWasUsed(mnUsedEntries && !maVector[nIndex].equalZero());
 578         bool bIsUsed(!rValue.equalZero());
 579
 580         if(bWasUsed)
 581         {
 582             if(bIsUsed)
 583             {
 584                 maVector[nIndex] = rValue;
 585             }
 586             else
 587             {
 588                 maVector[nIndex] = ::basegfx::B2DPoint::getEmptyPoint();
 589                 mnUsedEntries--;
 590             }
 591         }
 592         else
 593         {
 594             if(bIsUsed)
 595             {
 596                 maVector[nIndex] = rValue;
 597                 mnUsedEntries++;
 598             }
 599         }
 600     }
 601
 602     void insert(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue, sal_uInt32 nCount)
 603     {
 604         if(nCount)
 605         {
 606             // add nCount copies of rValue
 607             TextureData2DVector::iterator aIndex(maVector.begin());
 608             aIndex += nIndex;
 609             maVector.insert(aIndex, nCount, rValue);
 610
 611             if(!rValue.equalZero())
 612                 mnUsedEntries += nCount;
 613         }
 614     }
 615
 616     void insert(sal_uInt32 nIndex, const TextureCoordinate2D& rSource)
 617     {
 618         const sal_uInt32 nCount(rSource.maVector.size());
 619
 620         if(nCount)
 621         {
 622             // insert data
 623             TextureData2DVector::iterator aIndex(maVector.begin());
 624             aIndex += nIndex;
 625             TextureData2DVector::const_iterator aStart(rSource.maVector.begin());
 626             TextureData2DVector::const_iterator aEnd(rSource.maVector.end());
 627             maVector.insert(aIndex, aStart, aEnd);
 628
 629             mnUsedEntries += std::count_if(aStart, aEnd,
 630                 [](TextureData2DVector::const_reference rData) { return !rData.equalZero(); });
 631         }
 632     }
 633
 634     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 635     {
 636         if(nCount)
 637         {
 638             const TextureData2DVector::iterator aDeleteStart(maVector.begin() + nIndex);
 639             const TextureData2DVector::iterator aDeleteEnd(aDeleteStart + nCount);
 640
 641             auto nDeleteUsed = std::count_if(aDeleteStart, aDeleteEnd,
 642                 [](TextureData2DVector::const_reference rData) { return !rData.equalZero(); });
 643             mnUsedEntries -= std::min(mnUsedEntries, static_cast<sal_uInt32>(nDeleteUsed));
 644
 645             // remove point data
 646             maVector.erase(aDeleteStart, aDeleteEnd);
 647         }
 648     }
 649
 650     void flip()
 651     {
 652         if(maVector.size() <= 1)
 653             return;
 654
 655         const sal_uInt32 nHalfSize(maVector.size() >> 1);
 656         TextureData2DVector::iterator aStart(maVector.begin());
 657         TextureData2DVector::iterator aEnd(maVector.end() - 1);
 658
 659         for(sal_uInt32 a(0); a < nHalfSize; a++)
 660         {
 661             std::swap(*aStart, *aEnd);
 662             ++aStart;
 663             --aEnd;
 664         }
 665     }
 666
 667     void transform(const ::basegfx::B2DHomMatrix& rMatrix)
 668     {
 669         for (auto & elem : maVector)
 670         {
 671             elem *= rMatrix;
 672         }
 673     }
 674 };
 675
 676 }
 677
 678 class ImplB3DPolygon
 679 {
 680     // The point vector. This vector exists always and defines the
 681     // count of members.
 682     CoordinateDataArray3D                           maPoints;
 683
 684     // The BColor vector. This vectors are created on demand
 685     // and may be zero.
 686     std::unique_ptr<BColorArray>                    mpBColors;
 687
 688     // The Normals vector. This vectors are created on demand
 689     // and may be zero.
 690     std::unique_ptr<NormalsArray3D>                 mpNormals;
 691
 692     // The TextureCoordinates vector. This vectors are created on demand
 693     // and may be zero.
 694     std::unique_ptr<TextureCoordinate2D>            mpTextureCoordinates;
 695
 696     // flag which decides if this polygon is opened or closed
 697     bool                                            mbIsClosed : 1;
 698
 699 public:
 700     // This constructor is only used from the static identity polygon, thus
 701     // the RefCount is set to 1 to never 'delete' this static incarnation.
 702     ImplB3DPolygon()
 703     :   maPoints(0),
 704         mbIsClosed(false)
 705     {
 706         // complete initialization with defaults
 707     }
 708
 709     ImplB3DPolygon(const ImplB3DPolygon& rToBeCopied)
 710     :   maPoints(rToBeCopied.maPoints),
 711         mbIsClosed(rToBeCopied.mbIsClosed)
 712     {
 713         // complete initialization using copy
 714         if(rToBeCopied.mpBColors && rToBeCopied.mpBColors->isUsed())
 715         {
 716             mpBColors.reset( new BColorArray(*rToBeCopied.mpBColors) );
 717         }
 718
 719         if(rToBeCopied.mpNormals && rToBeCopied.mpNormals->isUsed())
 720         {
 721             mpNormals.reset( new NormalsArray3D(*rToBeCopied.mpNormals) );
 722         }
 723
 724         if(rToBeCopied.mpTextureCoordinates && rToBeCopied.mpTextureCoordinates->isUsed())
 725         {
 726             mpTextureCoordinates.reset( new TextureCoordinate2D(*rToBeCopied.mpTextureCoordinates) );
 727         }
 728     }
 729
 730     ImplB3DPolygon(const ImplB3DPolygon& rToBeCopied, sal_uInt32 nIndex, sal_uInt32 nCount)
 731     :   maPoints(rToBeCopied.maPoints, nIndex, nCount),
 732         mbIsClosed(rToBeCopied.mbIsClosed)
 733     {
 734         // complete initialization using partly copy
 735         if(rToBeCopied.mpBColors && rToBeCopied.mpBColors->isUsed())
 736         {
 737             mpBColors.reset( new BColorArray(*rToBeCopied.mpBColors, nIndex, nCount) );
 738
 739             if(!mpBColors->isUsed())
 740             {
 741                 mpBColors.reset();
 742             }
 743         }
 744
 745         if(rToBeCopied.mpNormals && rToBeCopied.mpNormals->isUsed())
 746         {
 747             mpNormals.reset( new NormalsArray3D(*rToBeCopied.mpNormals, nIndex, nCount) );
 748
 749             if(!mpNormals->isUsed())
 750             {
 751                 mpNormals.reset();
 752             }
 753         }
 754
 755         if(rToBeCopied.mpTextureCoordinates && rToBeCopied.mpTextureCoordinates->isUsed())
 756         {
 757             mpTextureCoordinates.reset( new TextureCoordinate2D(*rToBeCopied.mpTextureCoordinates, nIndex, nCount) );
 758
 759             if(!mpTextureCoordinates->isUsed())
 760             {
 761                 mpTextureCoordinates.reset();
 762             }
 763         }
 764     }
 765
 766     sal_uInt32 count() const
 767     {
 768         return maPoints.count();
 769     }
 770
 771     bool isClosed() const
 772     {
 773         return mbIsClosed;
 774     }
 775
 776     void setClosed(bool bNew)
 777     {
 778         if(bNew != mbIsClosed)
 779         {
 780             mbIsClosed = bNew;
 781         }
 782     }
 783
 784     bool impBColorsAreEqual(const ImplB3DPolygon& rCandidate) const
 785     {
 786         bool bBColorsAreEqual(true);
 787
 788         if(mpBColors)
 789         {
 790             if(rCandidate.mpBColors)
 791             {
 792                 bBColorsAreEqual = (*mpBColors == *rCandidate.mpBColors);
 793             }
 794             else
 795             {
 796                 // candidate has no BColors, so it's assumed all unused.
 797                 bBColorsAreEqual = !mpBColors->isUsed();
 798             }
 799         }
 800         else
 801         {
 802             if(rCandidate.mpBColors)
 803             {
 804                 // we have no TextureCoordinates, so it's assumed all unused.
 805                 bBColorsAreEqual = !rCandidate.mpBColors->isUsed();
 806             }
 807         }
 808
 809         return bBColorsAreEqual;
 810     }
 811
 812     bool impNormalsAreEqual(const ImplB3DPolygon& rCandidate) const
 813     {
 814         bool bNormalsAreEqual(true);
 815
 816         if(mpNormals)
 817         {
 818             if(rCandidate.mpNormals)
 819             {
 820                 bNormalsAreEqual = (*mpNormals == *rCandidate.mpNormals);
 821             }
 822             else
 823             {
 824                 // candidate has no normals, so it's assumed all unused.
 825                 bNormalsAreEqual = !mpNormals->isUsed();
 826             }
 827         }
 828         else
 829         {
 830             if(rCandidate.mpNormals)
 831             {
 832                 // we have no normals, so it's assumed all unused.
 833                 bNormalsAreEqual = !rCandidate.mpNormals->isUsed();
 834             }
 835         }
 836
 837         return bNormalsAreEqual;
 838     }
 839
 840     bool impTextureCoordinatesAreEqual(const ImplB3DPolygon& rCandidate) const
 841     {
 842         bool bTextureCoordinatesAreEqual(true);
 843
 844         if(mpTextureCoordinates)
 845         {
 846             if(rCandidate.mpTextureCoordinates)
 847             {
 848                 bTextureCoordinatesAreEqual = (*mpTextureCoordinates == *rCandidate.mpTextureCoordinates);
 849             }
 850             else
 851             {
 852                 // candidate has no TextureCoordinates, so it's assumed all unused.
 853                 bTextureCoordinatesAreEqual = !mpTextureCoordinates->isUsed();
 854             }
 855         }
 856         else
 857         {
 858             if(rCandidate.mpTextureCoordinates)
 859             {
 860                 // we have no TextureCoordinates, so it's assumed all unused.
 861                 bTextureCoordinatesAreEqual = !rCandidate.mpTextureCoordinates->isUsed();
 862             }
 863         }
 864
 865         return bTextureCoordinatesAreEqual;
 866     }
 867
 868     bool operator==(const ImplB3DPolygon& rCandidate) const
 869     {
 870         if(mbIsClosed == rCandidate.mbIsClosed)
 871         {
 872             if(maPoints == rCandidate.maPoints)
 873             {
 874                 if(impBColorsAreEqual(rCandidate))
 875                 {
 876                     if(impNormalsAreEqual(rCandidate))
 877                     {
 878                         if(impTextureCoordinatesAreEqual(rCandidate))
 879                         {
 880                             return true;
 881                         }
 882                     }
 883                 }
 884             }
 885         }
 886
 887         return false;
 888     }
 889
 890     const ::basegfx::B3DPoint& getPoint(sal_uInt32 nIndex) const
 891     {
 892         return maPoints.getCoordinate(nIndex);
 893     }
 894
 895     void setPoint(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rValue)
 896     {
 897         maPoints.setCoordinate(nIndex, rValue);
 898     }
 899
 900     void insert(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rPoint, sal_uInt32 nCount)
 901     {
 902         if(!nCount)
 903             return;
 904
 905         CoordinateData3D aCoordinate(rPoint);
 906         maPoints.insert(nIndex, aCoordinate, nCount);
 907
 908         if(mpBColors)
 909         {
 910             mpBColors->insert(nIndex, ::basegfx::BColor::getEmptyBColor(), nCount);
 911         }
 912
 913         if(mpNormals)
 914         {
 915             mpNormals->insert(nIndex, ::basegfx::B3DVector::getEmptyVector(), nCount);
 916         }
 917
 918         if(mpTextureCoordinates)
 919         {
 920             mpTextureCoordinates->insert(nIndex, ::basegfx::B2DPoint::getEmptyPoint(), nCount);
 921         }
 922     }
 923
 924     const ::basegfx::BColor& getBColor(sal_uInt32 nIndex) const
 925     {
 926         if(mpBColors)
 927         {
 928             return mpBColors->getBColor(nIndex);
 929         }
 930         else
 931         {
 932             return ::basegfx::BColor::getEmptyBColor();
 933         }
 934     }
 935
 936     void setBColor(sal_uInt32 nIndex, const ::basegfx::BColor& rValue)
 937     {
 938         if(!mpBColors)
 939         {
 940             if(!rValue.equalZero())
 941             {
 942                 mpBColors.reset( new BColorArray(maPoints.count()) );
 943                 mpBColors->setBColor(nIndex, rValue);
 944             }
 945         }
 946         else
 947         {
 948             mpBColors->setBColor(nIndex, rValue);
 949
 950             if(!mpBColors->isUsed())
 951             {
 952                 mpBColors.reset();
 953             }
 954         }
 955     }
 956
 957     bool areBColorsUsed() const
 958     {
 959         return (mpBColors && mpBColors->isUsed());
 960     }
 961
 962     void clearBColors()
 963     {
 964         mpBColors.reset();
 965     }
 966
 967     ::basegfx::B3DVector getNormal() const
 968     {
 969         return maPoints.getNormal();
 970     }
 971
 972     const ::basegfx::B3DVector& getNormal(sal_uInt32 nIndex) const
 973     {
 974         if(mpNormals)
 975         {
 976             return mpNormals->getNormal(nIndex);
 977         }
 978         else
 979         {
 980             return ::basegfx::B3DVector::getEmptyVector();
 981         }
 982     }
 983
 984     void setNormal(sal_uInt32 nIndex, const ::basegfx::B3DVector& rValue)
 985     {
 986         if(!mpNormals)
 987         {
 988             if(!rValue.equalZero())
 989             {
 990                 mpNormals.reset( new NormalsArray3D(maPoints.count()) );
 991                 mpNormals->setNormal(nIndex, rValue);
 992             }
 993         }
 994         else
 995         {
 996             mpNormals->setNormal(nIndex, rValue);
 997
 998             if(!mpNormals->isUsed())
 999             {
1000                 mpNormals.reset();
1001             }
1002         }
1003     }
1004
1005     void transformNormals(const ::basegfx::B3DHomMatrix& rMatrix)
1006     {
1007         if(mpNormals)
1008         {
1009             mpNormals->transform(rMatrix);
1010         }
1011     }
1012
1013     bool areNormalsUsed() const
1014     {
1015         return (mpNormals && mpNormals->isUsed());
1016     }
1017
1018     void clearNormals()
1019     {
1020         mpNormals.reset();
1021     }
1022
1023     const ::basegfx::B2DPoint& getTextureCoordinate(sal_uInt32 nIndex) const
1024     {
1025         if(mpTextureCoordinates)
1026         {
1027             return mpTextureCoordinates->getTextureCoordinate(nIndex);
1028         }
1029         else
1030         {
1031             return ::basegfx::B2DPoint::getEmptyPoint();
1032         }
1033     }
1034
1035     void setTextureCoordinate(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue)
1036     {
1037         if(!mpTextureCoordinates)
1038         {
1039             if(!rValue.equalZero())
1040             {
1041                 mpTextureCoordinates.reset( new TextureCoordinate2D(maPoints.count()) );
1042                 mpTextureCoordinates->setTextureCoordinate(nIndex, rValue);
1043             }
1044         }
1045         else
1046         {
1047             mpTextureCoordinates->setTextureCoordinate(nIndex, rValue);
1048
1049             if(!mpTextureCoordinates->isUsed())
1050             {
1051                 mpTextureCoordinates.reset();
1052             }
1053         }
1054     }
1055
1056     bool areTextureCoordinatesUsed() const
1057     {
1058         return (mpTextureCoordinates && mpTextureCoordinates->isUsed());
1059     }
1060
1061     void clearTextureCoordinates()
1062     {
1063         mpTextureCoordinates.reset();
1064     }
1065
1066     void transformTextureCoordinates(const ::basegfx::B2DHomMatrix& rMatrix)
1067     {
1068         if(mpTextureCoordinates)
1069         {
1070             mpTextureCoordinates->transform(rMatrix);
1071         }
1072     }
1073
1074     void insert(sal_uInt32 nIndex, const ImplB3DPolygon& rSource)
1075     {
1076         const sal_uInt32 nCount(rSource.maPoints.count());
1077
1078         if(!nCount)
1079             return;
1080
1081         maPoints.insert(nIndex, rSource.maPoints);
1082
1083         if(rSource.mpBColors && rSource.mpBColors->isUsed())
1084         {
1085             if(!mpBColors)
1086             {
1087                 mpBColors.reset( new BColorArray(maPoints.count()) );
1088             }
1089
1090             mpBColors->insert(nIndex, *rSource.mpBColors);
1091         }
1092         else
1093         {
1094             if(mpBColors)
1095             {
1096                 mpBColors->insert(nIndex, ::basegfx::BColor::getEmptyBColor(), nCount);
1097             }
1098         }
1099
1100         if(rSource.mpNormals && rSource.mpNormals->isUsed())
1101         {
1102             if(!mpNormals)
1103             {
1104                 mpNormals.reset( new NormalsArray3D(maPoints.count()) );
1105             }
1106
1107             mpNormals->insert(nIndex, *rSource.mpNormals);
1108         }
1109         else
1110         {
1111             if(mpNormals)
1112             {
1113                 mpNormals->insert(nIndex, ::basegfx::B3DVector::getEmptyVector(), nCount);
1114             }
1115         }
1116
1117         if(rSource.mpTextureCoordinates && rSource.mpTextureCoordinates->isUsed())
1118         {
1119             if(!mpTextureCoordinates)
1120             {
1121                 mpTextureCoordinates.reset( new TextureCoordinate2D(maPoints.count()) );
1122             }
1123
1124             mpTextureCoordinates->insert(nIndex, *rSource.mpTextureCoordinates);
1125         }
1126         else
1127         {
1128             if(mpTextureCoordinates)
1129             {
1130                 mpTextureCoordinates->insert(nIndex, ::basegfx::B2DPoint::getEmptyPoint(), nCount);
1131             }
1132         }
1133     }
1134
1135     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
1136     {
1137         if(!nCount)
1138             return;
1139
1140         maPoints.remove(nIndex, nCount);
1141
1142         if(mpBColors)
1143         {
1144             mpBColors->remove(nIndex, nCount);
1145
1146             if(!mpBColors->isUsed())
1147             {
1148                 mpBColors.reset();
1149             }
1150         }
1151
1152         if(mpNormals)
1153         {
1154             mpNormals->remove(nIndex, nCount);
1155
1156             if(!mpNormals->isUsed())
1157             {
1158                 mpNormals.reset();
1159             }
1160         }
1161
1162         if(mpTextureCoordinates)
1163         {
1164             mpTextureCoordinates->remove(nIndex, nCount);
1165
1166             if(!mpTextureCoordinates->isUsed())
1167             {
1168                 mpTextureCoordinates.reset();
1169             }
1170         }
1171     }
1172
1173     void flip()
1174     {
1175         if(maPoints.count() <= 1)
1176             return;
1177
1178         maPoints.flip();
1179
1180         if(mpBColors)
1181         {
1182             mpBColors->flip();
1183         }
1184
1185         if(mpNormals)
1186         {
1187             mpNormals->flip();
1188         }
1189
1190         if(mpTextureCoordinates)
1191         {
1192             mpTextureCoordinates->flip();
1193         }
1194     }
1195
1196     bool hasDoublePoints() const
1197     {
1198         if(mbIsClosed)
1199         {
1200             // check for same start and end point
1201             const sal_uInt32 nIndex(maPoints.count() - 1);
1202
1203             if(maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex))
1204             {
1205                 const bool bBColorEqual(!mpBColors || (mpBColors->getBColor(0) == mpBColors->getBColor(nIndex)));
1206
1207                 if(bBColorEqual)
1208                 {
1209                     const bool bNormalsEqual(!mpNormals || (mpNormals->getNormal(0) == mpNormals->getNormal(nIndex)));
1210
1211                     if(bNormalsEqual)
1212                     {
1213                         const bool bTextureCoordinatesEqual(!mpTextureCoordinates || (mpTextureCoordinates->getTextureCoordinate(0) == mpTextureCoordinates->getTextureCoordinate(nIndex)));
1214
1215                         if(bTextureCoordinatesEqual)
1216                         {
1217                             return true;
1218                         }
1219                     }
1220                 }
1221             }
1222         }
1223
1224         // test for range
1225         for(sal_uInt32 a(0); a < maPoints.count() - 1; a++)
1226         {
1227             if(maPoints.getCoordinate(a) == maPoints.getCoordinate(a + 1))
1228             {
1229                 const bool bBColorEqual(!mpBColors || (mpBColors->getBColor(a) == mpBColors->getBColor(a + 1)));
1230
1231                 if(bBColorEqual)
1232                 {
1233                     const bool bNormalsEqual(!mpNormals || (mpNormals->getNormal(a) == mpNormals->getNormal(a + 1)));
1234
1235                     if(bNormalsEqual)
1236                     {
1237                         const bool bTextureCoordinatesEqual(!mpTextureCoordinates || (mpTextureCoordinates->getTextureCoordinate(a) == mpTextureCoordinates->getTextureCoordinate(a + 1)));
1238
1239                         if(bTextureCoordinatesEqual)
1240                         {
1241                             return true;
1242                         }
1243                     }
1244                 }
1245             }
1246         }
1247
1248         return false;
1249     }
1250
1251     void removeDoublePointsAtBeginEnd()
1252     {
1253         // Only remove DoublePoints at Begin and End when poly is closed
1254         if(!mbIsClosed)
1255             return;
1256
1257         bool bRemove;
1258
1259         do
1260         {
1261             bRemove = false;
1262
1263             if(maPoints.count() > 1)
1264             {
1265                 const sal_uInt32 nIndex(maPoints.count() - 1);
1266                 bRemove = (maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex));
1267
1268                 if(bRemove && mpBColors && mpBColors->getBColor(0) != mpBColors->getBColor(nIndex))
1269                 {
1270                     bRemove = false;
1271                 }
1272
1273                 if(bRemove && mpNormals && mpNormals->getNormal(0) != mpNormals->getNormal(nIndex))
1274                 {
1275                     bRemove = false;
1276                 }
1277
1278                 if(bRemove && mpTextureCoordinates && mpTextureCoordinates->getTextureCoordinate(0) != mpTextureCoordinates->getTextureCoordinate(nIndex))
1279                 {
1280                     bRemove = false;
1281                 }
1282             }
1283
1284             if(bRemove)
1285             {
1286                 const sal_uInt32 nIndex(maPoints.count() - 1);
1287                 remove(nIndex, 1);
1288             }
1289         } while(bRemove);
1290     }
1291
1292     void removeDoublePointsWholeTrack()
1293     {
1294         sal_uInt32 nIndex(0);
1295
1296         // test as long as there are at least two points and as long as the index
1297         // is smaller or equal second last point
1298         while((maPoints.count() > 1) && (nIndex <= maPoints.count() - 2))
1299         {
1300             const sal_uInt32 nNextIndex(nIndex + 1);
1301             bool bRemove(maPoints.getCoordinate(nIndex) == maPoints.getCoordinate(nNextIndex));
1302
1303             if(bRemove && mpBColors && mpBColors->getBColor(nIndex) != mpBColors->getBColor(nNextIndex))
1304             {
1305                 bRemove = false;
1306             }
1307
1308             if(bRemove && mpNormals && mpNormals->getNormal(nIndex) != mpNormals->getNormal(nNextIndex))
1309             {
1310                 bRemove = false;
1311             }
1312
1313             if(bRemove && mpTextureCoordinates && mpTextureCoordinates->getTextureCoordinate(nIndex) != mpTextureCoordinates->getTextureCoordinate(nNextIndex))
1314             {
1315                 bRemove = false;
1316             }
1317
1318             if(bRemove)
1319             {
1320                 // if next is same as index and the control vectors are unused, delete index
1321                 remove(nIndex, 1);
1322             }
1323             else
1324             {
1325                 // if different, step forward
1326                 nIndex++;
1327             }
1328         }
1329     }
1330
1331     void transform(const ::basegfx::B3DHomMatrix& rMatrix)
1332     {
1333         maPoints.transform(rMatrix);
1334     }
1335 };
1336
1337 namespace basegfx
1338 {
1339     namespace {
1340
1341     B3DPolygon::ImplType const & getDefaultPolygon() {
1342         static B3DPolygon::ImplType const singleton;
1343         return singleton;
1344     }
1345
1346     }
1347
1348     B3DPolygon::B3DPolygon() :
1349         mpPolygon(getDefaultPolygon())
1350     {
1351     }
1352
1353     B3DPolygon::B3DPolygon(const B3DPolygon&) = default;
1354
1355     B3DPolygon::B3DPolygon(B3DPolygon&&) = default;
1356
1357     B3DPolygon::~B3DPolygon() = default;
1358
1359     B3DPolygon& B3DPolygon::operator=(const B3DPolygon&) = default;
1360
1361     B3DPolygon& B3DPolygon::operator=(B3DPolygon&&) = default;
1362
1363     bool B3DPolygon::operator==(const B3DPolygon& rPolygon) const
1364     {
1365         if(mpPolygon.same_object(rPolygon.mpPolygon))
1366             return true;
1367
1368         return (*mpPolygon == *rPolygon.mpPolygon);
1369     }
1370
1371     sal_uInt32 B3DPolygon::count() const
1372     {
1373         return mpPolygon->count();
1374     }
1375
1376     basegfx::B3DPoint const & B3DPolygon::getB3DPoint(sal_uInt32 nIndex) const
1377     {
1378         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1379
1380         return mpPolygon->getPoint(nIndex);
1381     }
1382
1383     void B3DPolygon::setB3DPoint(sal_uInt32 nIndex, const basegfx::B3DPoint& rValue)
1384     {
1385         OSL_ENSURE(nIndex < std::as_const(mpPolygon)->count(), "B3DPolygon access outside range (!)");
1386
1387         if(getB3DPoint(nIndex) != rValue)
1388             mpPolygon->setPoint(nIndex, rValue);
1389     }
1390
1391     BColor const & B3DPolygon::getBColor(sal_uInt32 nIndex) const
1392     {
1393         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1394
1395         return mpPolygon->getBColor(nIndex);
1396     }
1397
1398     void B3DPolygon::setBColor(sal_uInt32 nIndex, const BColor& rValue)
1399     {
1400         OSL_ENSURE(nIndex < std::as_const(mpPolygon)->count(), "B3DPolygon access outside range (!)");
1401
1402         if(std::as_const(mpPolygon)->getBColor(nIndex) != rValue)
1403             mpPolygon->setBColor(nIndex, rValue);
1404     }
1405
1406     bool B3DPolygon::areBColorsUsed() const
1407     {
1408         return mpPolygon->areBColorsUsed();
1409     }
1410
1411     void B3DPolygon::clearBColors()
1412     {
1413         if(std::as_const(mpPolygon)->areBColorsUsed())
1414             mpPolygon->clearBColors();
1415     }
1416
1417     B3DVector B3DPolygon::getNormal() const
1418     {
1419         return mpPolygon->getNormal();
1420     }
1421
1422     B3DVector const & B3DPolygon::getNormal(sal_uInt32 nIndex) const
1423     {
1424         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1425
1426         return mpPolygon->getNormal(nIndex);
1427     }
1428
1429     void B3DPolygon::setNormal(sal_uInt32 nIndex, const B3DVector& rValue)
1430     {
1431         OSL_ENSURE(nIndex < std::as_const(mpPolygon)->count(), "B3DPolygon access outside range (!)");
1432
1433         if(std::as_const(mpPolygon)->getNormal(nIndex) != rValue)
1434             mpPolygon->setNormal(nIndex, rValue);
1435     }
1436
1437     void B3DPolygon::transformNormals(const B3DHomMatrix& rMatrix)
1438     {
1439         if(std::as_const(mpPolygon)->areNormalsUsed() && !rMatrix.isIdentity())
1440             mpPolygon->transformNormals(rMatrix);
1441     }
1442
1443     bool B3DPolygon::areNormalsUsed() const
1444     {
1445         return mpPolygon->areNormalsUsed();
1446     }
1447
1448     void B3DPolygon::clearNormals()
1449     {
1450         if(std::as_const(mpPolygon)->areNormalsUsed())
1451             mpPolygon->clearNormals();
1452     }
1453
1454     B2DPoint const & B3DPolygon::getTextureCoordinate(sal_uInt32 nIndex) const
1455     {
1456         OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
1457
1458         return mpPolygon->getTextureCoordinate(nIndex);
1459     }
1460
1461     void B3DPolygon::setTextureCoordinate(sal_uInt32 nIndex, const B2DPoint& rValue)
1462     {
1463         OSL_ENSURE(nIndex < std::as_const(mpPolygon)->count(), "B3DPolygon access outside range (!)");
1464
1465         if(std::as_const(mpPolygon)->getTextureCoordinate(nIndex) != rValue)
1466             mpPolygon->setTextureCoordinate(nIndex, rValue);
1467     }
1468
1469     void B3DPolygon::transformTextureCoordinates(const B2DHomMatrix& rMatrix)
1470     {
1471         if(std::as_const(mpPolygon)->areTextureCoordinatesUsed() && !rMatrix.isIdentity())
1472             mpPolygon->transformTextureCoordinates(rMatrix);
1473     }
1474
1475     bool B3DPolygon::areTextureCoordinatesUsed() const
1476     {
1477         return mpPolygon->areTextureCoordinatesUsed();
1478     }
1479
1480     void B3DPolygon::clearTextureCoordinates()
1481     {
1482         if(std::as_const(mpPolygon)->areTextureCoordinatesUsed())
1483             mpPolygon->clearTextureCoordinates();
1484     }
1485
1486     void B3DPolygon::append(const basegfx::B3DPoint& rPoint, sal_uInt32 nCount)
1487     {
1488         if(nCount)
1489             mpPolygon->insert(std::as_const(mpPolygon)->count(), rPoint, nCount);
1490     }
1491
1492     void B3DPolygon::append(const B3DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
1493     {
1494         if(!rPoly.count())
1495             return;
1496
1497         if(!nCount)
1498         {
1499             nCount = rPoly.count();
1500         }
1501
1502         if(nIndex == 0 && nCount == rPoly.count())
1503         {
1504             mpPolygon->insert(std::as_const(mpPolygon)->count(), *rPoly.mpPolygon);
1505         }
1506         else
1507         {
1508             OSL_ENSURE(nIndex + nCount <= rPoly.mpPolygon->count(), "B3DPolygon Append outside range (!)");
1509             ImplB3DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
1510             mpPolygon->insert(std::as_const(mpPolygon)->count(), aTempPoly);
1511         }
1512     }
1513
1514     void B3DPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
1515     {
1516         OSL_ENSURE(nIndex + nCount <= std::as_const(mpPolygon)->count(), "B3DPolygon Remove outside range (!)");
1517
1518         if(nCount)
1519             mpPolygon->remove(nIndex, nCount);
1520     }
1521
1522     void B3DPolygon::clear()
1523     {
1524         mpPolygon = getDefaultPolygon();
1525     }
1526
1527     bool B3DPolygon::isClosed() const
1528     {
1529         return mpPolygon->isClosed();
1530     }
1531
1532     void B3DPolygon::setClosed(bool bNew)
1533     {
1534         if(isClosed() != bNew)
1535             mpPolygon->setClosed(bNew);
1536     }
1537
1538     void B3DPolygon::flip()
1539     {
1540         if(count() > 1)
1541             mpPolygon->flip();
1542     }
1543
1544     bool B3DPolygon::hasDoublePoints() const
1545     {
1546         return (mpPolygon->count() > 1 && mpPolygon->hasDoublePoints());
1547     }
1548
1549     void B3DPolygon::removeDoublePoints()
1550     {
1551         if(hasDoublePoints())
1552         {
1553             mpPolygon->removeDoublePointsAtBeginEnd();
1554             mpPolygon->removeDoublePointsWholeTrack();
1555         }
1556     }
1557
1558     void B3DPolygon::transform(const basegfx::B3DHomMatrix& rMatrix)
1559     {
1560         if(std::as_const(mpPolygon)->count() && !rMatrix.isIdentity())
1561         {
1562             mpPolygon->transform(rMatrix);
1563         }
1564     }
1565 } // end of namespace basegfx
1566
1567 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */