drawinglayer/source/primitive3d/sdrextrudelathetools3d.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: sdrextrudelathetools3d.cxx,v $
   6  *
   7  *  $Revision: 1.11 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-06-24 15:31:08 $
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 // MARKER(update_precomp.py): autogen include statement, do not remove
  37 #include "precompiled_drawinglayer.hxx"
  38
  39 #include <drawinglayer/primitive3d/sdrextrudelathetools3d.hxx>
  40 #include <basegfx/polygon/b2dpolypolygon.hxx>
  41 #include <basegfx/range/b2drange.hxx>
  42 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  43 #include <basegfx/matrix/b2dhommatrix.hxx>
  44 #include <basegfx/point/b3dpoint.hxx>
  45 #include <basegfx/polygon/b3dpolygon.hxx>
  46 #include <basegfx/polygon/b3dpolygontools.hxx>
  47 #include <basegfx/polygon/b3dpolypolygontools.hxx>
  48 #include <basegfx/range/b3drange.hxx>
  49 #include <basegfx/matrix/b3dhommatrix.hxx>
  50 #include <basegfx/polygon/b2dpolygontools.hxx>
  51 #include <drawinglayer/geometry/viewinformation3d.hxx>
  52 #include <numeric>
  53
  54 //////////////////////////////////////////////////////////////////////////////
  55 // decompositon helpers for extrude/lathe (rotation) objects
  56
  57 namespace
  58 {
  59     //////////////////////////////////////////////////////////////////////////////
  60     // common helpers
  61
  62     basegfx::B2DPolyPolygon impScalePolyPolygonOnCenter(
  63         const basegfx::B2DPolyPolygon& rSource,
  64         double fScale)
  65     {
  66         basegfx::B2DPolyPolygon aRetval(rSource);
  67
  68         if(!basegfx::fTools::equalZero(fScale))
  69         {
  70             const basegfx::B2DRange aRange(basegfx::tools::getRange(rSource));
  71             const basegfx::B2DPoint aCenter(aRange.getCenter());
  72             basegfx::B2DHomMatrix aTrans;
  73
  74             aTrans.translate(-aCenter.getX(), -aCenter.getY());
  75             aTrans.scale(fScale, fScale);
  76             aTrans.translate(aCenter.getX(), aCenter.getY());
  77             aRetval.transform(aTrans);
  78         }
  79
  80         return aRetval;
  81     }
  82
  83     void impGetOuterPolyPolygon(
  84         basegfx::B2DPolyPolygon& rPolygon,
  85         basegfx::B2DPolyPolygon& rOuterPolyPolygon,
  86         double fOffset,
  87         bool bCharacterMode)
  88     {
  89         rOuterPolyPolygon = rPolygon;
  90
  91         if(basegfx::fTools::more(fOffset, 0.0))
  92         {
  93             if(bCharacterMode)
  94             {
  95                 // grow the outside polygon and scale all polygons to original size. This is done
  96                 // to avoid a shrink which potentially would lead to self-intersections, but changes
  97                 // the original polygon -> not a precision step, so e.g. not usable for charts
  98                 const basegfx::B2DRange aRange(basegfx::tools::getRange(rPolygon));
  99                 rPolygon = basegfx::tools::growInNormalDirection(rPolygon, fOffset);
 100                 const basegfx::B2DRange aGrownRange(basegfx::tools::getRange(rPolygon));
 101                 const double fScaleX(basegfx::fTools::equalZero(aGrownRange.getWidth()) ? 1.0 : aRange.getWidth() / aGrownRange.getWidth());
 102                 const double fScaleY(basegfx::fTools::equalZero(aGrownRange.getHeight())? 1.0 : aRange.getHeight() / aGrownRange.getHeight());
 103                 basegfx::B2DHomMatrix aScaleTrans;
 104
 105                 aScaleTrans.translate(-aGrownRange.getMinX(), -aGrownRange.getMinY());
 106                 aScaleTrans.scale(fScaleX, fScaleY);
 107                 aScaleTrans.translate(aRange.getMinX(), aRange.getMinY());
 108                 rPolygon.transform(aScaleTrans);
 109                 rOuterPolyPolygon.transform(aScaleTrans);
 110             }
 111             else
 112             {
 113                 // use more precision, shrink the outer polygons. Since this may lead to self-intersections,
 114                 // some kind of correction should be applied here after that step
 115                 rOuterPolyPolygon = basegfx::tools::growInNormalDirection(rPolygon, -fOffset);
 116                 basegfx::tools::correctGrowShrinkPolygonPair(rPolygon, rOuterPolyPolygon);
 117             }
 118         }
 119     }
 120
 121     void impAddInBetweenFill(
 122         basegfx::B3DPolyPolygon& rTarget,
 123         const basegfx::B3DPolyPolygon& rPolA,
 124         const basegfx::B3DPolyPolygon& rPolB,
 125         double fTexVerStart,
 126         double fTexVerStop,
 127         bool bCreateNormals,
 128         bool bCreateTextureCoordinates)
 129     {
 130         OSL_ENSURE(rPolA.count() == rPolB.count(), "impAddInBetweenFill: unequally sized polygons (!)");
 131         const sal_uInt32 nPolygonCount(rPolA.count());
 132
 133         for(sal_uInt32 a(0L); a < nPolygonCount; a++)
 134         {
 135             const basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
 136             const basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
 137             OSL_ENSURE(aSubA.count() == aSubB.count(), "impAddInBetweenFill: unequally sized polygons (!)");
 138             const sal_uInt32 nPointCount(aSubA.count());
 139
 140             if(nPointCount)
 141             {
 142                 const sal_uInt32 nEdgeCount(aSubA.isClosed() ? nPointCount : nPointCount - 1L);
 143                 double fTexHorMultiplicatorA(0.0), fTexHorMultiplicatorB(0.0);
 144                 double fPolygonPosA(0.0), fPolygonPosB(0.0);
 145
 146                 if(bCreateTextureCoordinates)
 147                 {
 148                     const double fPolygonLengthA(basegfx::tools::getLength(aSubA));
 149                     fTexHorMultiplicatorA = basegfx::fTools::equalZero(fPolygonLengthA) ? 1.0 : 1.0 / fPolygonLengthA;
 150
 151                     const double fPolygonLengthB(basegfx::tools::getLength(aSubB));
 152                     fTexHorMultiplicatorB = basegfx::fTools::equalZero(fPolygonLengthB) ? 1.0 : 1.0 / fPolygonLengthB;
 153                 }
 154
 155                 for(sal_uInt32 b(0L); b < nEdgeCount; b++)
 156                 {
 157                     const sal_uInt32 nIndexA(b);
 158                     const sal_uInt32 nIndexB((b + 1L) % nPointCount);
 159
 160                     const basegfx::B3DPoint aStartA(aSubA.getB3DPoint(nIndexA));
 161                     const basegfx::B3DPoint aEndA(aSubA.getB3DPoint(nIndexB));
 162                     const basegfx::B3DPoint aStartB(aSubB.getB3DPoint(nIndexA));
 163                     const basegfx::B3DPoint aEndB(aSubB.getB3DPoint(nIndexB));
 164
 165                     basegfx::B3DPolygon aNew;
 166                     aNew.setClosed(true);
 167
 168                     aNew.append(aStartA);
 169                     aNew.append(aStartB);
 170                     aNew.append(aEndB);
 171                     aNew.append(aEndA);
 172
 173                     if(bCreateNormals)
 174                     {
 175                         aNew.setNormal(0L, aSubA.getNormal(nIndexA));
 176                         aNew.setNormal(1L, aSubB.getNormal(nIndexA));
 177                         aNew.setNormal(2L, aSubB.getNormal(nIndexB));
 178                         aNew.setNormal(3L, aSubA.getNormal(nIndexB));
 179                     }
 180
 181                     if(bCreateTextureCoordinates)
 182                     {
 183                         const double fRelTexAL(fPolygonPosA * fTexHorMultiplicatorA);
 184                         const double fEdgeLengthA(basegfx::B3DVector(aEndA - aStartA).getLength());
 185                         fPolygonPosA += fEdgeLengthA;
 186                         const double fRelTexAR(fPolygonPosA * fTexHorMultiplicatorA);
 187
 188                         const double fRelTexBL(fPolygonPosB * fTexHorMultiplicatorB);
 189                         const double fEdgeLengthB(basegfx::B3DVector(aEndB - aStartB).getLength());
 190                         fPolygonPosB += fEdgeLengthB;
 191                         const double fRelTexBR(fPolygonPosB * fTexHorMultiplicatorB);
 192
 193                         aNew.setTextureCoordinate(0L, basegfx::B2DPoint(fRelTexAL, fTexVerStart));
 194                         aNew.setTextureCoordinate(1L, basegfx::B2DPoint(fRelTexBL, fTexVerStop));
 195                         aNew.setTextureCoordinate(2L, basegfx::B2DPoint(fRelTexBR, fTexVerStop));
 196                         aNew.setTextureCoordinate(3L, basegfx::B2DPoint(fRelTexAR, fTexVerStart));
 197                     }
 198
 199                     rTarget.append(aNew);
 200                 }
 201             }
 202         }
 203     }
 204
 205     void impSetNormal(
 206         basegfx::B3DPolyPolygon& rCandidate,
 207         const basegfx::B3DVector& rNormal)
 208     {
 209         for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
 210         {
 211             basegfx::B3DPolygon aSub(rCandidate.getB3DPolygon(a));
 212
 213             for(sal_uInt32 b(0L); b < aSub.count(); b++)
 214             {
 215                 aSub.setNormal(b, rNormal);
 216             }
 217
 218             rCandidate.setB3DPolygon(a, aSub);
 219         }
 220     }
 221
 222     void impCreateInBetweenNormals(
 223         basegfx::B3DPolyPolygon& rPolA,
 224         basegfx::B3DPolyPolygon& rPolB,
 225         bool bSmoothHorizontalNormals)
 226     {
 227         OSL_ENSURE(rPolA.count() == rPolB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
 228
 229         for(sal_uInt32 a(0L); a < rPolA.count(); a++)
 230         {
 231             basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
 232             basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
 233             OSL_ENSURE(aSubA.count() == aSubB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
 234             const sal_uInt32 nPointCount(aSubA.count());
 235
 236             if(nPointCount)
 237             {
 238                 basegfx::B3DPoint aPrevA(aSubA.getB3DPoint(nPointCount - 1L));
 239                 basegfx::B3DPoint aCurrA(aSubA.getB3DPoint(0L));
 240                 const bool bClosed(aSubA.isClosed());
 241
 242                 for(sal_uInt32 b(0L); b < nPointCount; b++)
 243                 {
 244                     const sal_uInt32 nIndNext((b + 1L) % nPointCount);
 245                     const basegfx::B3DPoint aNextA(aSubA.getB3DPoint(nIndNext));
 246                     const basegfx::B3DPoint aCurrB(aSubB.getB3DPoint(b));
 247
 248                     // vector to back
 249                     basegfx::B3DVector aDepth(aCurrB - aCurrA);
 250                     aDepth.normalize();
 251
 252                     if(aDepth.equalZero())
 253                     {
 254                         // no difference, try to get depth from next point
 255                         const basegfx::B3DPoint aNextB(aSubB.getB3DPoint(nIndNext));
 256                         aDepth = aNextB - aNextA;
 257                         aDepth.normalize();
 258                     }
 259
 260                     // vector to left (correct for non-closed lines)
 261                     const bool bFirstAndNotClosed(!bClosed && 0L == b);
 262                     basegfx::B3DVector aLeft(bFirstAndNotClosed ? aCurrA - aNextA : aPrevA - aCurrA);
 263                     aLeft.normalize();
 264
 265                     // create left normal
 266                     const basegfx::B3DVector aNormalLeft(aDepth.getPerpendicular(aLeft));
 267
 268                     if(bSmoothHorizontalNormals)
 269                     {
 270                         // vector to right (correct for non-closed lines)
 271                         const bool bLastAndNotClosed(!bClosed && b + 1L == nPointCount);
 272                         basegfx::B3DVector aRight(bLastAndNotClosed ? aCurrA - aPrevA : aNextA - aCurrA);
 273                         aRight.normalize();
 274
 275                         // create right normal
 276                         const basegfx::B3DVector aNormalRight(aRight.getPerpendicular(aDepth));
 277
 278                         // create smoothed in-between normal
 279                         basegfx::B3DVector aNewNormal(aNormalLeft + aNormalRight);
 280                         aNewNormal.normalize();
 281
 282                         // set as new normal at polygons
 283                         aSubA.setNormal(b, aNewNormal);
 284                         aSubB.setNormal(b, aNewNormal);
 285                     }
 286                     else
 287                     {
 288                         // set aNormalLeft as new normal at polygons
 289                         aSubA.setNormal(b, aNormalLeft);
 290                         aSubB.setNormal(b, aNormalLeft);
 291                     }
 292
 293                     // prepare next step
 294                     aPrevA = aCurrA;
 295                     aCurrA = aNextA;
 296                 }
 297
 298                 rPolA.setB3DPolygon(a, aSubA);
 299                 rPolB.setB3DPolygon(a, aSubB);
 300             }
 301         }
 302     }
 303
 304     void impMixNormals(
 305         basegfx::B3DPolyPolygon& rPolA,
 306         const basegfx::B3DPolyPolygon& rPolB,
 307         double fWeightA)
 308     {
 309         const double fWeightB(1.0 - fWeightA);
 310         OSL_ENSURE(rPolA.count() == rPolB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
 311
 312         for(sal_uInt32 a(0L); a < rPolA.count(); a++)
 313         {
 314             basegfx::B3DPolygon aSubA(rPolA.getB3DPolygon(a));
 315             const basegfx::B3DPolygon aSubB(rPolB.getB3DPolygon(a));
 316             OSL_ENSURE(aSubA.count() == aSubB.count(), "sdrExtrudePrimitive3D: unequally sized polygons (!)");
 317             const sal_uInt32 nPointCount(aSubA.count());
 318
 319             for(sal_uInt32 b(0L); b < nPointCount; b++)
 320             {
 321                 const basegfx::B3DVector aVA(aSubA.getNormal(b) * fWeightA);
 322                 const basegfx::B3DVector aVB(aSubB.getNormal(b) * fWeightB);
 323                 basegfx::B3DVector aVNew(aVA + aVB);
 324                 aVNew.normalize();
 325                 aSubA.setNormal(b, aVNew);
 326             }
 327
 328             rPolA.setB3DPolygon(a, aSubA);
 329         }
 330     }
 331
 332     bool impHasCutWith(const basegfx::B2DPolygon& rPoly, const basegfx::B2DPoint& rStart, const basegfx::B2DPoint& rEnd)
 333     {
 334         // polygon is closed, one of the points is a member
 335         const sal_uInt32 nPointCount(rPoly.count());
 336
 337         if(nPointCount)
 338         {
 339             basegfx::B2DPoint aCurrent(rPoly.getB2DPoint(0));
 340             const basegfx::B2DVector aVector(rEnd - rStart);
 341
 342             for(sal_uInt32 a(0); a < nPointCount; a++)
 343             {
 344                 const sal_uInt32 nNextIndex((a + 1) % nPointCount);
 345                 const basegfx::B2DPoint aNext(rPoly.getB2DPoint(nNextIndex));
 346                 const basegfx::B2DVector aEdgeVector(aNext - aCurrent);
 347
 348                 if(basegfx::tools::findCut(
 349                     rStart, aVector,
 350                     aCurrent, aEdgeVector))
 351                 {
 352                     return true;
 353                 }
 354
 355                 aCurrent = aNext;
 356             }
 357         }
 358
 359         return false;
 360     }
 361 } // end of anonymous namespace
 362
 363 //////////////////////////////////////////////////////////////////////////////
 364
 365 namespace drawinglayer
 366 {
 367     namespace primitive3d
 368     {
 369         void createLatheSlices(
 370             Slice3DVector& rSliceVector,
 371             const basegfx::B2DPolyPolygon& rSource,
 372             double fBackScale,
 373             double fDiagonal,
 374             double fRotation,
 375             sal_uInt32 nSteps,
 376             bool bCharacterMode,
 377             bool bCloseFront,
 378             bool bCloseBack)
 379         {
 380             if(basegfx::fTools::equalZero(fRotation) || 0L == nSteps)
 381             {
 382                 // no rotation or no steps, just one plane
 383                 rSliceVector.push_back(Slice3D(rSource, basegfx::B3DHomMatrix()));
 384             }
 385             else
 386             {
 387                 const bool bBackScale(!basegfx::fTools::equal(fBackScale, 1.0));
 388                 const bool bClosedRotation(!bBackScale && basegfx::fTools::equal(fRotation, F_2PI));
 389                 basegfx::B2DPolyPolygon aFront(rSource);
 390                 basegfx::B2DPolyPolygon aBack(rSource);
 391                 basegfx::B3DHomMatrix aTransformBack;
 392                 basegfx::B2DPolyPolygon aOuterBack;
 393
 394                 if(bClosedRotation)
 395                 {
 396                     bCloseFront = bCloseBack = false;
 397                 }
 398
 399                 if(bBackScale)
 400                 {
 401                     // avoid null zoom
 402                     if(basegfx::fTools::equalZero(fBackScale))
 403                     {
 404                         fBackScale = 0.000001;
 405                     }
 406
 407                     // back is scaled compared to front, create scaled version
 408                     aBack = impScalePolyPolygonOnCenter(aBack, fBackScale);
 409                 }
 410
 411                 if(bCloseFront || bCloseBack)
 412                 {
 413                     const basegfx::B2DRange aBaseRange(basegfx::tools::getRange(aFront));
 414                     const double fOuterLength(aBaseRange.getMaxX() * fRotation);
 415                     const double fInnerLength(aBaseRange.getMinX() * fRotation);
 416                     const double fAverageLength((fOuterLength + fInnerLength) * 0.5);
 417
 418                     if(bCloseFront)
 419                     {
 420                         const double fOffsetLen((fAverageLength / 12.0) * fDiagonal);
 421                         basegfx::B2DPolyPolygon aOuterFront;
 422                         impGetOuterPolyPolygon(aFront, aOuterFront, fOffsetLen, bCharacterMode);
 423                         basegfx::B3DHomMatrix aTransform;
 424                         aTransform.translate(0.0, 0.0, fOffsetLen);
 425                         rSliceVector.push_back(Slice3D(aOuterFront, aTransform, SLICETYPE3D_FRONTCAP));
 426                     }
 427
 428                     if(bCloseBack)
 429                     {
 430                         const double fOffsetLen((fAverageLength / 12.0) * fDiagonal);
 431                         impGetOuterPolyPolygon(aBack, aOuterBack, fOffsetLen, bCharacterMode);
 432                         aTransformBack.translate(0.0, 0.0, -fOffsetLen);
 433                         aTransformBack.rotate(0.0, fRotation, 0.0);
 434                     }
 435                 }
 436
 437                 // add start polygon (a = 0L)
 438                 if(!bClosedRotation)
 439                 {
 440                     rSliceVector.push_back(Slice3D(aFront, basegfx::B3DHomMatrix()));
 441                 }
 442
 443                 // create segments (a + 1 .. nSteps)
 444                 const double fStepSize(1.0 / (double)nSteps);
 445
 446                 for(sal_uInt32 a(0L); a < nSteps; a++)
 447                 {
 448                     const double fStep((double)(a + 1L) * fStepSize);
 449                     basegfx::B2DPolyPolygon aNewPoly(bBackScale ? basegfx::tools::interpolate(aFront, aBack, fStep) : aFront);
 450                     basegfx::B3DHomMatrix aNewMat;
 451                     aNewMat.rotate(0.0, fRotation * fStep, 0.0);
 452                     rSliceVector.push_back(Slice3D(aNewPoly, aNewMat));
 453                 }
 454
 455                 if(bCloseBack)
 456                 {
 457                     rSliceVector.push_back(Slice3D(aOuterBack, aTransformBack, SLICETYPE3D_BACKCAP));
 458                 }
 459             }
 460         }
 461
 462         void createExtrudeSlices(
 463             Slice3DVector& rSliceVector,
 464             const basegfx::B2DPolyPolygon& rSource,
 465             double fBackScale,
 466             double fDiagonal,
 467             double fDepth,
 468             bool bCharacterMode,
 469             bool bCloseFront,
 470             bool bCloseBack)
 471         {
 472             if(basegfx::fTools::equalZero(fDepth))
 473             {
 474                 // no depth, just one plane
 475                 rSliceVector.push_back(Slice3D(rSource, basegfx::B3DHomMatrix()));
 476             }
 477             else
 478             {
 479                 // there is depth, create Polygons for front,back and their default depth positions
 480                 basegfx::B2DPolyPolygon aFront(rSource);
 481                 basegfx::B2DPolyPolygon aBack(rSource);
 482                 const bool bBackScale(!basegfx::fTools::equal(fBackScale, 1.0));
 483                 double fZFront(fDepth); // default depth for aFront
 484                 double fZBack(0.0); // default depth for aBack
 485                 basegfx::B2DPolyPolygon aOuterBack;
 486
 487                 if(bBackScale)
 488                 {
 489                     // avoid null zoom
 490                     if(basegfx::fTools::equalZero(fBackScale))
 491                     {
 492                         fBackScale = 0.000001;
 493                     }
 494
 495                     // aFront is scaled compared to aBack, create scaled version
 496                     aFront = impScalePolyPolygonOnCenter(aFront, fBackScale);
 497                 }
 498
 499                 if(bCloseFront)
 500                 {
 501                     const double fOffset(fDepth * fDiagonal * 0.5);
 502                     fZFront = fDepth - fOffset;
 503                     basegfx::B2DPolyPolygon aOuterFront;
 504                     impGetOuterPolyPolygon(aFront, aOuterFront, fOffset, bCharacterMode);
 505                     basegfx::B3DHomMatrix aTransformFront;
 506                     aTransformFront.translate(0.0, 0.0, fDepth);
 507                     rSliceVector.push_back(Slice3D(aOuterFront, aTransformFront, SLICETYPE3D_FRONTCAP));
 508                 }
 509
 510                 if(bCloseBack)
 511                 {
 512                     const double fOffset(fDepth * fDiagonal * 0.5);
 513                     fZBack = fOffset;
 514                     impGetOuterPolyPolygon(aBack, aOuterBack, fOffset, bCharacterMode);
 515                 }
 516
 517                 // add front and back polygons at evtl. changed depths
 518                 {
 519                     basegfx::B3DHomMatrix aTransformA, aTransformB;
 520
 521                     aTransformA.translate(0.0, 0.0, fZFront);
 522                     rSliceVector.push_back(Slice3D(aFront, aTransformA));
 523
 524                     aTransformB.translate(0.0, 0.0, fZBack);
 525                     rSliceVector.push_back(Slice3D(aBack, aTransformB));
 526                 }
 527
 528                 if(bCloseBack)
 529                 {
 530                     rSliceVector.push_back(Slice3D(aOuterBack, basegfx::B3DHomMatrix(), SLICETYPE3D_BACKCAP));
 531                 }
 532             }
 533         }
 534
 535         basegfx::B3DPolyPolygon extractHorizontalLinesFromSlice(const Slice3DVector& rSliceVector, bool bCloseHorLines)
 536         {
 537             basegfx::B3DPolyPolygon aRetval;
 538             const sal_uInt32 nNumSlices(rSliceVector.size());
 539
 540             if(nNumSlices)
 541             {
 542                 const sal_uInt32 nSlideSubPolygonCount(rSliceVector[0].getB3DPolyPolygon().count());
 543
 544                 for(sal_uInt32 b(0); b < nSlideSubPolygonCount; b++)
 545                 {
 546                     const sal_uInt32 nSubPolygonPointCount(rSliceVector[0].getB3DPolyPolygon().getB3DPolygon(b).count());
 547
 548                     for(sal_uInt32 c(0); c < nSubPolygonPointCount; c++)
 549                     {
 550                         basegfx::B3DPolygon aNew;
 551
 552                         for(sal_uInt32 d(0); d < nNumSlices; d++)
 553                         {
 554                             OSL_ENSURE(nSlideSubPolygonCount == rSliceVector[d].getB3DPolyPolygon().count(),
 555                                 "Slice PolyPolygon with different Polygon count (!)");
 556                             OSL_ENSURE(nSubPolygonPointCount == rSliceVector[d].getB3DPolyPolygon().getB3DPolygon(b).count(),
 557                                 "Slice Polygon with different point count (!)");
 558                             aNew.append(rSliceVector[d].getB3DPolyPolygon().getB3DPolygon(b).getB3DPoint(c));
 559                         }
 560
 561                         aNew.setClosed(bCloseHorLines);
 562                         aRetval.append(aNew);
 563                     }
 564                 }
 565             }
 566
 567             return aRetval;
 568         }
 569
 570         basegfx::B3DPolyPolygon  extractVerticalLinesFromSlice(const Slice3DVector& rSliceVector)
 571         {
 572             basegfx::B3DPolyPolygon aRetval;
 573             const sal_uInt32 nNumSlices(rSliceVector.size());
 574
 575             for(sal_uInt32 a(0L); a < nNumSlices; a++)
 576             {
 577                 aRetval.append(rSliceVector[a].getB3DPolyPolygon());
 578             }
 579
 580             return aRetval;
 581         }
 582
 583         void extractPlanesFromSlice(
 584             ::std::vector< basegfx::B3DPolyPolygon >& rFill,
 585             const Slice3DVector& rSliceVector,
 586             bool bCreateNormals,
 587             bool bSmoothHorizontalNormals,
 588             bool bSmoothNormals,
 589             bool bSmoothLids,
 590             bool bClosed,
 591             double fSmoothNormalsMix,
 592             double fSmoothLidsMix,
 593             bool bCreateTextureCoordinates,
 594             const basegfx::B2DHomMatrix& rTexTransform)
 595         {
 596             const sal_uInt32 nNumSlices(rSliceVector.size());
 597
 598             if(nNumSlices)
 599             {
 600                 // common parameters
 601                 const sal_uInt32 nLoopCount(bClosed ? nNumSlices : nNumSlices - 1L);
 602                 basegfx::B3DPolyPolygon aEdgeRounding;
 603                 sal_uInt32 a;
 604
 605                 // tetxture parameters
 606                 double fInvTexHeight(1.0);
 607                 double fTexHeightPos(0.0);
 608                 double fTexStart(0.0);
 609                 double fTexStop(1.0);
 610                 ::std::vector<double> aTexHeightArray;
 611                 basegfx::B3DRange aTexRangeFront;
 612                 basegfx::B3DRange aTexRangeBack;
 613
 614                 if(bCreateTextureCoordinates)
 615                 {
 616                     aTexRangeFront = basegfx::tools::getRange(rSliceVector[0L].getB3DPolyPolygon());
 617                     aTexRangeBack = basegfx::tools::getRange(rSliceVector[nNumSlices - 1L].getB3DPolyPolygon());
 618
 619                     if(aTexRangeBack.getDepth() > aTexRangeBack.getWidth())
 620                     {
 621                         // last polygon is rotated so that depth is bigger than width, exchange X and Z
 622                         // for making applyDefaultTextureCoordinatesParallel use Z instead of X for
 623                         // horizontal texture coordinate
 624                         aTexRangeBack = basegfx::B3DRange(
 625                             aTexRangeBack.getMinZ(), aTexRangeBack.getMinY(), aTexRangeBack.getMinX(),
 626                             aTexRangeBack.getMaxZ(), aTexRangeBack.getMaxY(), aTexRangeBack.getMaxX());
 627                     }
 628
 629                     basegfx::B3DPoint aCenter(basegfx::tools::getRange(rSliceVector[0L].getB3DPolyPolygon()).getCenter());
 630
 631                     for(a = 0L; a < nLoopCount; a++)
 632                     {
 633                         const basegfx::B3DPoint aNextCenter(basegfx::tools::getRange(rSliceVector[(a + 1L) % nNumSlices].getB3DPolyPolygon()).getCenter());
 634                         const double fLength(basegfx::B3DVector(aNextCenter - aCenter).getLength());
 635                         aTexHeightArray.push_back(fLength);
 636                         aCenter = aNextCenter;
 637                     }
 638
 639                     const double fTexHeight(::std::accumulate(aTexHeightArray.begin(), aTexHeightArray.end(), 0.0));
 640
 641                     if(!basegfx::fTools::equalZero(fTexHeight))
 642                     {
 643                         fInvTexHeight = 1.0 / fTexHeight;
 644                     }
 645                 }
 646
 647                 if(nLoopCount)
 648                 {
 649                     for(a = 0L; a < nLoopCount; a++)
 650                     {
 651                         const Slice3D& rSliceA(rSliceVector[a]);
 652                         const Slice3D& rSliceB(rSliceVector[(a + 1L) % nNumSlices]);
 653                         const bool bAcceptPair(SLICETYPE3D_REGULAR == rSliceA.getSliceType() && SLICETYPE3D_REGULAR == rSliceB.getSliceType());
 654                         basegfx::B3DPolyPolygon aPolA(rSliceA.getB3DPolyPolygon());
 655                         basegfx::B3DPolyPolygon aPolB(rSliceB.getB3DPolyPolygon());
 656
 657                         if(bAcceptPair)
 658                         {
 659                             if(bCreateNormals)
 660                             {
 661                                 impCreateInBetweenNormals(aPolB, aPolA, bSmoothHorizontalNormals);
 662                             }
 663
 664                             {
 665                                 const sal_uInt32 nIndPrev((a + nNumSlices - 1L) % nNumSlices);
 666                                 const Slice3D& rSlicePrev(rSliceVector[nIndPrev]);
 667                                 basegfx::B3DPolyPolygon aPrev(rSlicePrev.getB3DPolyPolygon());
 668                                 basegfx::B3DPolyPolygon aPolAA(rSliceA.getB3DPolyPolygon());
 669
 670                                 if(SLICETYPE3D_FRONTCAP == rSlicePrev.getSliceType())
 671                                 {
 672                                     basegfx::B3DPolyPolygon aFront(rSlicePrev.getB3DPolyPolygon());
 673                                     const bool bHasSlant(aPolAA != aPrev);
 674
 675                                     if(bCreateTextureCoordinates)
 676                                     {
 677                                         aFront = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFront, aTexRangeFront);
 678                                     }
 679
 680                                     if(bCreateNormals)
 681                                     {
 682                                         basegfx::B3DVector aNormal(0.0, 0.0, -1.0);
 683
 684                                         if(aFront.count())
 685                                         {
 686                                             aNormal = -aFront.getB3DPolygon(0L).getNormal();
 687                                         }
 688
 689                                         impSetNormal(aFront, aNormal);
 690
 691                                         if(bHasSlant)
 692                                         {
 693                                             impCreateInBetweenNormals(aPolAA, aPrev, bSmoothHorizontalNormals);
 694
 695                                             if(bSmoothNormals)
 696                                             {
 697                                                 // smooth and copy
 698                                                 impMixNormals(aPolA, aPolAA, fSmoothNormalsMix);
 699                                                 aPolAA = aPolA;
 700                                             }
 701                                             else
 702                                             {
 703                                                 // take over from surface
 704                                                 aPolAA = aPolA;
 705                                             }
 706
 707                                             if(bSmoothLids)
 708                                             {
 709                                                 // smooth and copy
 710                                                 impMixNormals(aFront, aPrev, fSmoothLidsMix);
 711                                                 aPrev = aFront;
 712                                             }
 713                                             else
 714                                             {
 715                                                 // take over from front
 716                                                 aPrev = aFront;
 717                                             }
 718                                         }
 719                                         else
 720                                         {
 721                                             if(bSmoothNormals)
 722                                             {
 723                                                 // smooth
 724                                                 impMixNormals(aPolA, aFront, fSmoothNormalsMix);
 725                                             }
 726
 727                                             if(bSmoothLids)
 728                                             {
 729                                                 // smooth and copy
 730                                                 impMixNormals(aFront, aPolA, fSmoothLidsMix);
 731                                                 aPolA = aFront;
 732                                             }
 733                                         }
 734                                     }
 735
 736                                     if(bHasSlant)
 737                                     {
 738                                         if(bCreateTextureCoordinates)
 739                                         {
 740                                             fTexStart = fTexHeightPos * fInvTexHeight;
 741                                             fTexStop = (fTexHeightPos - aTexHeightArray[(a + nLoopCount - 1L) % nLoopCount]) * fInvTexHeight;
 742                                         }
 743
 744                                         impAddInBetweenFill(aEdgeRounding, aPolAA, aPrev, fTexStart, fTexStop, bCreateNormals, bCreateTextureCoordinates);
 745                                     }
 746
 747                                     aFront.flip();
 748                                     rFill.push_back(aFront);
 749                                 }
 750                                 else
 751                                 {
 752                                     if(bCreateNormals && bSmoothNormals && (nIndPrev != a + 1L))
 753                                     {
 754                                         impCreateInBetweenNormals(aPolAA, aPrev, bSmoothHorizontalNormals);
 755                                         impMixNormals(aPolA, aPolAA, 0.5);
 756                                     }
 757                                 }
 758                             }
 759
 760                             {
 761                                 const sal_uInt32 nIndNext((a + 2L) % nNumSlices);
 762                                 const Slice3D& rSliceNext(rSliceVector[nIndNext]);
 763                                 basegfx::B3DPolyPolygon aNext(rSliceNext.getB3DPolyPolygon());
 764                                 basegfx::B3DPolyPolygon aPolBB(rSliceB.getB3DPolyPolygon());
 765
 766                                 if(SLICETYPE3D_BACKCAP == rSliceNext.getSliceType())
 767                                 {
 768                                     basegfx::B3DPolyPolygon aBack(rSliceNext.getB3DPolyPolygon());
 769                                     const bool bHasSlant(aPolBB != aNext);
 770
 771                                     if(bCreateTextureCoordinates)
 772                                     {
 773                                         aBack = basegfx::tools::applyDefaultTextureCoordinatesParallel(aBack, aTexRangeBack);
 774                                     }
 775
 776                                     if(bCreateNormals)
 777                                     {
 778                                         const basegfx::B3DVector aNormal(aBack.count() ? aBack.getB3DPolygon(0L).getNormal() : basegfx::B3DVector(0.0, 0.0, 1.0));
 779                                         impSetNormal(aBack, aNormal);
 780
 781                                         if(bHasSlant)
 782                                         {
 783                                             impCreateInBetweenNormals(aNext, aPolBB, bSmoothHorizontalNormals);
 784
 785                                             if(bSmoothNormals)
 786                                             {
 787                                                 // smooth and copy
 788                                                 impMixNormals(aPolB, aPolBB, fSmoothNormalsMix);
 789                                                 aPolBB = aPolB;
 790                                             }
 791                                             else
 792                                             {
 793                                                 // take over from surface
 794                                                 aPolBB = aPolB;
 795                                             }
 796
 797                                             if(bSmoothLids)
 798                                             {
 799                                                 // smooth and copy
 800                                                 impMixNormals(aBack, aNext, fSmoothLidsMix);
 801                                                 aNext = aBack;
 802                                             }
 803                                             else
 804                                             {
 805                                                 // take over from back
 806                                                 aNext = aBack;
 807                                             }
 808                                         }
 809                                         else
 810                                         {
 811                                             if(bSmoothNormals)
 812                                             {
 813                                                 // smooth
 814                                                 impMixNormals(aPolB, aBack, fSmoothNormalsMix);
 815                                             }
 816
 817                                             if(bSmoothLids)
 818                                             {
 819                                                 // smooth and copy
 820                                                 impMixNormals(aBack, aPolB, fSmoothLidsMix);
 821                                                 aPolB = aBack;
 822                                             }
 823                                         }
 824                                     }
 825
 826                                     if(bHasSlant)
 827                                     {
 828                                         if(bCreateTextureCoordinates)
 829                                         {
 830                                             fTexStart = (fTexHeightPos + aTexHeightArray[a] + aTexHeightArray[(a + 1L) % nLoopCount]) * fInvTexHeight;
 831                                             fTexStop = (fTexHeightPos + aTexHeightArray[a]) * fInvTexHeight;
 832                                         }
 833
 834                                         impAddInBetweenFill(aEdgeRounding, aNext, aPolBB, fTexStart, fTexStop, bCreateNormals, bCreateTextureCoordinates);
 835                                     }
 836
 837                                     rFill.push_back(aBack);
 838                                 }
 839                                 else
 840                                 {
 841                                     if(bCreateNormals && bSmoothNormals && (nIndNext != a))
 842                                     {
 843                                         impCreateInBetweenNormals(aNext, aPolBB, bSmoothHorizontalNormals);
 844                                         impMixNormals(aPolB, aPolBB, 0.5);
 845                                     }
 846                                 }
 847                             }
 848
 849                             if(bCreateTextureCoordinates)
 850                             {
 851                                 fTexStart = (fTexHeightPos + aTexHeightArray[a]) * fInvTexHeight;
 852                                 fTexStop = fTexHeightPos * fInvTexHeight;
 853                             }
 854
 855                             impAddInBetweenFill(aEdgeRounding, aPolB, aPolA, fTexStart, fTexStop, bCreateNormals, bCreateTextureCoordinates);
 856                         }
 857
 858                         if(bCreateTextureCoordinates)
 859                         {
 860                             fTexHeightPos += aTexHeightArray[a];
 861                         }
 862                     }
 863                 }
 864                 else
 865                 {
 866                     // no loop, but a single slice (1 == nNumSlices), create a filling from the single
 867                     // front plane
 868                     const Slice3D& rSlice(rSliceVector[0]);
 869                     basegfx::B3DPolyPolygon aFront(rSlice.getB3DPolyPolygon());
 870
 871                     if(bCreateTextureCoordinates)
 872                     {
 873                         aFront = basegfx::tools::applyDefaultTextureCoordinatesParallel(aFront, aTexRangeFront);
 874                     }
 875
 876                     if(bCreateNormals)
 877                     {
 878                         basegfx::B3DVector aNormal(0.0, 0.0, -1.0);
 879
 880                         if(aFront.count())
 881                         {
 882                             aNormal = -aFront.getB3DPolygon(0L).getNormal();
 883                         }
 884
 885                         impSetNormal(aFront, aNormal);
 886                     }
 887
 888                     aFront.flip();
 889                     rFill.push_back(aFront);
 890                 }
 891
 892                 if(bCreateTextureCoordinates)
 893                 {
 894                     aEdgeRounding.transformTextureCoordiantes(rTexTransform);
 895                 }
 896
 897                 for(a = 0L; a < aEdgeRounding.count(); a++)
 898                 {
 899                     rFill.push_back(basegfx::B3DPolyPolygon(aEdgeRounding.getB3DPolygon(a)));
 900                 }
 901             }
 902         }
 903
 904         void createReducedOutlines(
 905             const geometry::ViewInformation3D& rViewInformation,
 906             const basegfx::B3DHomMatrix& rObjectTransform,
 907             const basegfx::B3DPolygon& rLoopA,
 908             const basegfx::B3DPolygon& rLoopB,
 909             basegfx::B3DPolyPolygon& rTarget)
 910         {
 911             const sal_uInt32 nPointCount(rLoopA.count());
 912
 913             // with idetic polygons there are no outlines
 914             if(rLoopA != rLoopB)
 915             {
 916                 if(nPointCount && nPointCount == rLoopB.count())
 917                 {
 918                     const basegfx::B3DHomMatrix aObjectTransform(rViewInformation.getObjectToView() * rObjectTransform);
 919                     const basegfx::B2DPolygon a2DLoopA(basegfx::tools::createB2DPolygonFromB3DPolygon(rLoopA, aObjectTransform));
 920                     const basegfx::B2DPolygon a2DLoopB(basegfx::tools::createB2DPolygonFromB3DPolygon(rLoopB, aObjectTransform));
 921                     const basegfx::B2DPoint a2DCenterA(a2DLoopA.getB2DRange().getCenter());
 922                     const basegfx::B2DPoint a2DCenterB(a2DLoopB.getB2DRange().getCenter());
 923
 924                     // without detectable Y-Axis there are no outlines
 925                     if(!a2DCenterA.equal(a2DCenterB))
 926                     {
 927                         // search for outmost left and right inter-loop-edges which do not cut the loops
 928                         const basegfx::B2DPoint aCommonCenter(basegfx::average(a2DCenterA, a2DCenterB));
 929                         const basegfx::B2DVector aAxisVector(a2DCenterA - a2DCenterB);
 930                         double fMaxLeft(0.0);
 931                         double fMaxRight(0.0);
 932                         sal_uInt32 nIndexLeft(0);
 933                         sal_uInt32 nIndexRight(0);
 934
 935                         for(sal_uInt32 a(0); a < nPointCount; a++)
 936                         {
 937                             const basegfx::B2DPoint aStart(a2DLoopA.getB2DPoint(a));
 938                             const basegfx::B2DPoint aEnd(a2DLoopB.getB2DPoint(a));
 939                             const basegfx::B2DPoint aMiddle(basegfx::average(aStart, aEnd));
 940
 941                             if(!basegfx::tools::isInside(a2DLoopA, aMiddle))
 942                             {
 943                                 if(!basegfx::tools::isInside(a2DLoopB, aMiddle))
 944                                 {
 945                                     if(!impHasCutWith(a2DLoopA, aStart, aEnd))
 946                                     {
 947                                         if(!impHasCutWith(a2DLoopB, aStart, aEnd))
 948                                         {
 949                                             const basegfx::B2DVector aCandidateVector(aMiddle - aCommonCenter);
 950                                             const double fCross(aCandidateVector.cross(aAxisVector));
 951                                             const double fDistance(aCandidateVector.getLength());
 952
 953                                             if(fCross > 0.0)
 954                                             {
 955                                                 if(fDistance > fMaxLeft)
 956                                                 {
 957                                                     fMaxLeft = fDistance;
 958                                                     nIndexLeft = a;
 959                                                 }
 960                                             }
 961                                             else if(fCross < 0.0)
 962                                             {
 963                                                 if(fDistance > fMaxRight)
 964                                                 {
 965                                                     fMaxRight = fDistance;
 966                                                     nIndexRight = a;
 967                                                 }
 968                                             }
 969                                         }
 970                                     }
 971                                 }
 972                             }
 973                         }
 974
 975                         if(fMaxLeft != 0.0)
 976                         {
 977                             basegfx::B3DPolygon aToBeAdded;
 978                             aToBeAdded.append(rLoopA.getB3DPoint(nIndexLeft));
 979                             aToBeAdded.append(rLoopB.getB3DPoint(nIndexLeft));
 980                             rTarget.append(aToBeAdded);
 981                         }
 982
 983                         if(fMaxRight != 0.0)
 984                         {
 985                             basegfx::B3DPolygon aToBeAdded;
 986                             aToBeAdded.append(rLoopA.getB3DPoint(nIndexRight));
 987                             aToBeAdded.append(rLoopB.getB3DPoint(nIndexRight));
 988                             rTarget.append(aToBeAdded);
 989                         }
 990                     }
 991                 }
 992             }
 993         }
 994
 995     } // end of namespace primitive3d
 996 } // end of namespace drawinglayer
 997
 998 //////////////////////////////////////////////////////////////////////////////
 999 // eof