basegfx/source/polygon/b3dpolypolygon.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/b3dpolypolygon.hxx>
  22 #include <basegfx/polygon/b3dpolygon.hxx>
  23 #include <rtl/instance.hxx>
  24 #include <basegfx/matrix/b2dhommatrix.hxx>
  25 #include <basegfx/matrix/b3dhommatrix.hxx>
  26 #include <functional>
  27 #include <vector>
  28 #include <algorithm>
  29
  30 class ImplB3DPolyPolygon
  31 {
  32     typedef std::vector< ::basegfx::B3DPolygon >  PolygonVector;
  33
  34     PolygonVector                                   maPolygons;
  35
  36 public:
  37     ImplB3DPolyPolygon() : maPolygons()
  38     {
  39     }
  40
  41     explicit ImplB3DPolyPolygon(const ::basegfx::B3DPolygon& rToBeCopied) :
  42         maPolygons(1,rToBeCopied)
  43     {
  44     }
  45
  46     bool operator==(const ImplB3DPolyPolygon& rPolygonList) const
  47     {
  48         // same polygon count?
  49         if(maPolygons.size() != rPolygonList.maPolygons.size())
  50             return false;
  51
  52         // compare polygon content
  53         if(maPolygons != rPolygonList.maPolygons)
  54             return false;
  55
  56         return true;
  57     }
  58
  59     const ::basegfx::B3DPolygon& getB3DPolygon(sal_uInt32 nIndex) const
  60     {
  61         return maPolygons[nIndex];
  62     }
  63
  64     void setB3DPolygon(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rPolygon)
  65     {
  66         maPolygons[nIndex] = rPolygon;
  67     }
  68
  69     void insert(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rPolygon, sal_uInt32 nCount)
  70     {
  71         if(nCount)
  72         {
  73             // add nCount copies of rPolygon
  74             PolygonVector::iterator aIndex(maPolygons.begin());
  75             if( nIndex )
  76                 aIndex += nIndex;
  77             maPolygons.insert(aIndex, nCount, rPolygon);
  78         }
  79     }
  80
  81     void insert(sal_uInt32 nIndex, const ::basegfx::B3DPolyPolygon& rPolyPolygon)
  82     {
  83         // add all polygons from rPolyPolygon
  84         PolygonVector::iterator aIndex(maPolygons.begin());
  85         if( nIndex )
  86             aIndex += nIndex;
  87         maPolygons.insert(aIndex, rPolyPolygon.begin(), rPolyPolygon.end());
  88     }
  89
  90     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
  91     {
  92         if(nCount)
  93         {
  94             // remove polygon data
  95             PolygonVector::iterator aStart(maPolygons.begin());
  96             aStart += nIndex;
  97             const PolygonVector::iterator aEnd(aStart + nCount);
  98
  99             maPolygons.erase(aStart, aEnd);
 100         }
 101     }
 102
 103     sal_uInt32 count() const
 104     {
 105         return maPolygons.size();
 106     }
 107
 108     void flip()
 109     {
 110         for (auto& aPolygon : maPolygons)
 111             aPolygon.flip();
 112     }
 113
 114     void removeDoublePoints()
 115     {
 116         for (auto& aPolygon : maPolygons)
 117             aPolygon.removeDoublePoints();
 118     }
 119
 120     void transform(const ::basegfx::B3DHomMatrix& rMatrix)
 121     {
 122         for (auto& aPolygon : maPolygons)
 123             aPolygon.transform(rMatrix);
 124     }
 125
 126     void clearBColors()
 127     {
 128         for (auto& aPolygon : maPolygons)
 129             aPolygon.clearBColors();
 130     }
 131
 132     void transformNormals(const ::basegfx::B3DHomMatrix& rMatrix)
 133     {
 134         for (auto& aPolygon : maPolygons)
 135             aPolygon.transformNormals(rMatrix);
 136     }
 137
 138     void clearNormals()
 139     {
 140         for (auto& aPolygon : maPolygons)
 141             aPolygon.clearNormals();
 142     }
 143
 144     void transformTextureCoordinates(const ::basegfx::B2DHomMatrix& rMatrix)
 145     {
 146         for (auto& aPolygon : maPolygons)
 147             aPolygon.transformTextureCoordinates(rMatrix);
 148     }
 149
 150     void clearTextureCoordinates()
 151     {
 152         for (auto& aPolygon : maPolygons)
 153             aPolygon.clearTextureCoordinates();
 154     }
 155
 156     const basegfx::B3DPolygon* begin() const
 157     {
 158         if (maPolygons.empty())
 159             return nullptr;
 160         else
 161             return maPolygons.data();
 162     }
 163
 164     const basegfx::B3DPolygon* end() const
 165     {
 166         if (maPolygons.empty())
 167             return nullptr;
 168         else
 169             return maPolygons.data() + maPolygons.size();
 170     }
 171
 172     basegfx::B3DPolygon* begin()
 173     {
 174         if (maPolygons.empty())
 175             return nullptr;
 176         else
 177             return maPolygons.data();
 178     }
 179
 180     basegfx::B3DPolygon* end()
 181     {
 182         if (maPolygons.empty())
 183             return nullptr;
 184         else
 185             return maPolygons.data() + maPolygons.size();
 186     }
 187 };
 188
 189 namespace basegfx
 190 {
 191     namespace { struct DefaultPolyPolygon : public rtl::Static<B3DPolyPolygon::ImplType,
 192                                                                DefaultPolyPolygon> {}; }
 193
 194     B3DPolyPolygon::B3DPolyPolygon() :
 195         mpPolyPolygon(DefaultPolyPolygon::get())
 196     {
 197     }
 198
 199     B3DPolyPolygon::B3DPolyPolygon(const B3DPolyPolygon&) = default;
 200
 201     B3DPolyPolygon::B3DPolyPolygon(B3DPolyPolygon&&) = default;
 202
 203     B3DPolyPolygon::B3DPolyPolygon(const B3DPolygon& rPolygon) :
 204         mpPolyPolygon( ImplB3DPolyPolygon(rPolygon) )
 205     {
 206     }
 207
 208     B3DPolyPolygon::~B3DPolyPolygon() = default;
 209
 210     B3DPolyPolygon& B3DPolyPolygon::operator=(const B3DPolyPolygon&) = default;
 211
 212     B3DPolyPolygon& B3DPolyPolygon::operator=(B3DPolyPolygon&&) = default;
 213
 214     bool B3DPolyPolygon::operator==(const B3DPolyPolygon& rPolyPolygon) const
 215     {
 216         if(mpPolyPolygon.same_object(rPolyPolygon.mpPolyPolygon))
 217             return true;
 218
 219         return ((*mpPolyPolygon) == (*rPolyPolygon.mpPolyPolygon));
 220     }
 221
 222     bool B3DPolyPolygon::operator!=(const B3DPolyPolygon& rPolyPolygon) const
 223     {
 224         return !(*this == rPolyPolygon);
 225     }
 226
 227     sal_uInt32 B3DPolyPolygon::count() const
 228     {
 229         return mpPolyPolygon->count();
 230     }
 231
 232     B3DPolygon const & B3DPolyPolygon::getB3DPolygon(sal_uInt32 nIndex) const
 233     {
 234         OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B3DPolyPolygon access outside range (!)");
 235
 236         return mpPolyPolygon->getB3DPolygon(nIndex);
 237     }
 238
 239     void B3DPolyPolygon::setB3DPolygon(sal_uInt32 nIndex, const B3DPolygon& rPolygon)
 240     {
 241         OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B3DPolyPolygon access outside range (!)");
 242
 243         if(getB3DPolygon(nIndex) != rPolygon)
 244             mpPolyPolygon->setB3DPolygon(nIndex, rPolygon);
 245     }
 246
 247     bool B3DPolyPolygon::areBColorsUsed() const
 248     {
 249         for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
 250         {
 251             if(mpPolyPolygon->getB3DPolygon(a).areBColorsUsed())
 252             {
 253                 return true;
 254             }
 255         }
 256
 257         return false;
 258     }
 259
 260     void B3DPolyPolygon::clearBColors()
 261     {
 262         if(areBColorsUsed())
 263             mpPolyPolygon->clearBColors();
 264     }
 265
 266     void B3DPolyPolygon::transformNormals(const B3DHomMatrix& rMatrix)
 267     {
 268         if(!rMatrix.isIdentity())
 269             mpPolyPolygon->transformNormals(rMatrix);
 270     }
 271
 272     bool B3DPolyPolygon::areNormalsUsed() const
 273     {
 274         for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
 275         {
 276             if(mpPolyPolygon->getB3DPolygon(a).areNormalsUsed())
 277             {
 278                 return true;
 279             }
 280         }
 281
 282         return false;
 283     }
 284
 285     void B3DPolyPolygon::clearNormals()
 286     {
 287         if(areNormalsUsed())
 288             mpPolyPolygon->clearNormals();
 289     }
 290
 291     void B3DPolyPolygon::transformTextureCoordinates(const B2DHomMatrix& rMatrix)
 292     {
 293         if(!rMatrix.isIdentity())
 294             mpPolyPolygon->transformTextureCoordinates(rMatrix);
 295     }
 296
 297     bool B3DPolyPolygon::areTextureCoordinatesUsed() const
 298     {
 299         for(sal_uInt32 a(0); a < mpPolyPolygon->count(); a++)
 300         {
 301             if(mpPolyPolygon->getB3DPolygon(a).areTextureCoordinatesUsed())
 302             {
 303                 return true;
 304             }
 305         }
 306
 307         return false;
 308     }
 309
 310     void B3DPolyPolygon::clearTextureCoordinates()
 311     {
 312         if(areTextureCoordinatesUsed())
 313             mpPolyPolygon->clearTextureCoordinates();
 314     }
 315
 316     void B3DPolyPolygon::append(const B3DPolygon& rPolygon, sal_uInt32 nCount)
 317     {
 318         if(nCount)
 319             mpPolyPolygon->insert(mpPolyPolygon->count(), rPolygon, nCount);
 320     }
 321
 322     void B3DPolyPolygon::append(const B3DPolyPolygon& rPolyPolygon)
 323     {
 324         if(rPolyPolygon.count())
 325             mpPolyPolygon->insert(mpPolyPolygon->count(), rPolyPolygon);
 326     }
 327
 328     void B3DPolyPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 329     {
 330         OSL_ENSURE(nIndex + nCount <= mpPolyPolygon->count(), "B3DPolyPolygon Remove outside range (!)");
 331
 332         if(nCount)
 333             mpPolyPolygon->remove(nIndex, nCount);
 334     }
 335
 336     void B3DPolyPolygon::clear()
 337     {
 338         mpPolyPolygon = DefaultPolyPolygon::get();
 339     }
 340
 341     void B3DPolyPolygon::flip()
 342     {
 343         mpPolyPolygon->flip();
 344     }
 345
 346     bool B3DPolyPolygon::hasDoublePoints() const
 347     {
 348         bool bRetval(false);
 349
 350         for(sal_uInt32 a(0); !bRetval && a < mpPolyPolygon->count(); a++)
 351         {
 352             if(mpPolyPolygon->getB3DPolygon(a).hasDoublePoints())
 353             {
 354                 bRetval = true;
 355             }
 356         }
 357
 358         return bRetval;
 359     }
 360
 361     void B3DPolyPolygon::removeDoublePoints()
 362     {
 363         if(hasDoublePoints())
 364             mpPolyPolygon->removeDoublePoints();
 365     }
 366
 367     void B3DPolyPolygon::transform(const B3DHomMatrix& rMatrix)
 368     {
 369         if(mpPolyPolygon->count() && !rMatrix.isIdentity())
 370         {
 371             mpPolyPolygon->transform(rMatrix);
 372         }
 373     }
 374
 375     const B3DPolygon* B3DPolyPolygon::begin() const
 376     {
 377         return mpPolyPolygon->begin();
 378     }
 379
 380     const B3DPolygon* B3DPolyPolygon::end() const
 381     {
 382         return mpPolyPolygon->end();
 383     }
 384
 385     B3DPolygon* B3DPolyPolygon::begin()
 386     {
 387         return mpPolyPolygon->begin();
 388     }
 389
 390     B3DPolygon* B3DPolyPolygon::end()
 391     {
 392         return mpPolyPolygon->end();
 393     }
 394 } // end of namespace basegfx
 395
 396 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */