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