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