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