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