include/basegfx/raster/rasterconvert3d.hxx

   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 #ifndef INCLUDED_BASEGFX_RASTER_RASTERCONVERT3D_HXX
  21 #define INCLUDED_BASEGFX_RASTER_RASTERCONVERT3D_HXX
  22
  23 #include <sal/types.h>
  24 #include <vector>
  25
  26 #include <osl/diagnose.h>
  27
  28 #include <basegfx/color/bcolor.hxx>
  29 #include <basegfx/vector/b3dvector.hxx>
  30 #include <basegfx/point/b2dpoint.hxx>
  31 #include <basegfx/vector/b2dvector.hxx>
  32 #include <basegfx/basegfxdllapi.h>
  33
  34 namespace basegfx
  35 {
  36     class B3DPolygon;
  37     class B3DPolyPolygon;
  38 }
  39
  40 // interpolators for double precision
  41
  42 namespace basegfx
  43 {
  44     class ip_single
  45     {
  46     private:
  47         double                                      mfVal;
  48         double                                      mfInc;
  49
  50     public:
  51         ip_single()
  52         :   mfVal(0.0),
  53             mfInc(0.0)
  54         {}
  55
  56         ip_single(double fVal, double fInc)
  57         :   mfVal(fVal),
  58             mfInc(fInc)
  59         {}
  60
  61         double getVal() const { return mfVal; }
  62         double getInc() const { return mfInc; }
  63
  64         void increment(double fStep) { mfVal += fStep * mfInc; }
  65     };
  66 } // end of namespace basegfx
  67
  68 namespace basegfx
  69 {
  70     class ip_double
  71     {
  72     private:
  73         ip_single                                   maX;
  74         ip_single                                   maY;
  75
  76     public:
  77         ip_double()
  78         :   maX(),
  79             maY()
  80         {}
  81
  82         ip_double(double fXVal, double fXInc, double fYVal, double fYInc)
  83         :   maX(fXVal, fXInc),
  84             maY(fYVal, fYInc)
  85         {}
  86
  87         const ip_single& getX() const { return maX; }
  88         const ip_single& getY() const { return maY; }
  89
  90         void increment(double fStep) { maX.increment(fStep); maY.increment(fStep); }
  91     };
  92 } // end of namespace basegfx
  93
  94 namespace basegfx
  95 {
  96     class ip_triple
  97     {
  98     private:
  99         ip_single                                   maX;
 100         ip_single                                   maY;
 101         ip_single                                   maZ;
 102
 103     public:
 104         ip_triple()
 105         :   maX(),
 106             maY(),
 107             maZ()
 108         {}
 109
 110         ip_triple(double fXVal, double fXInc, double fYVal, double fYInc, double fZVal, double fZInc)
 111         :   maX(fXVal, fXInc),
 112             maY(fYVal, fYInc),
 113             maZ(fZVal, fZInc)
 114         {}
 115
 116         const ip_single& getX() const { return maX; }
 117         const ip_single& getY() const { return maY; }
 118         const ip_single& getZ() const { return maZ; }
 119
 120         void increment(double fStep) { maX.increment(fStep); maY.increment(fStep); maZ.increment(fStep); }
 121     };
 122 } // end of namespace basegfx
 123
 124
 125 // InterpolatorProvider3D to have a common source for allocating interpolators
 126 // which may then be addressed using the index to the vectors
 127
 128 namespace basegfx
 129 {
 130     #define SCANLINE_EMPTY_INDEX (0xffffffff)
 131
 132     class InterpolatorProvider3D
 133     {
 134     private:
 135         ::std::vector< ip_triple >                  maColorInterpolators;
 136         ::std::vector< ip_triple >                  maNormalInterpolators;
 137         ::std::vector< ip_double >                  maTextureInterpolators;
 138         ::std::vector< ip_triple >                  maInverseTextureInterpolators;
 139
 140     protected:
 141         sal_uInt32 addColorInterpolator(const BColor& rA, const BColor& rB, double fInvYDelta)
 142         {
 143             double aDeltaRed(rB.getRed() - rA.getRed());
 144
 145             if(fTools::equalZero(aDeltaRed))
 146             {
 147                 aDeltaRed = 0.0;
 148             }
 149             else
 150             {
 151                 aDeltaRed *= fInvYDelta;
 152             }
 153
 154             double aDeltaGreen(rB.getGreen() - rA.getGreen());
 155
 156             if(fTools::equalZero(aDeltaGreen))
 157             {
 158                 aDeltaGreen = 0.0;
 159             }
 160             else
 161             {
 162                 aDeltaGreen *= fInvYDelta;
 163             }
 164
 165             double aDeltaBlue(rB.getBlue() - rA.getBlue());
 166
 167             if(fTools::equalZero(aDeltaBlue))
 168             {
 169                 aDeltaBlue = 0.0;
 170             }
 171             else
 172             {
 173                 aDeltaBlue *= fInvYDelta;
 174             }
 175
 176             maColorInterpolators.push_back(
 177                 ip_triple(
 178                     rA.getRed(), aDeltaRed,
 179                     rA.getGreen(), aDeltaGreen,
 180                     rA.getBlue(), aDeltaBlue));
 181
 182             return (maColorInterpolators.size() - 1);
 183         }
 184
 185         sal_uInt32 addNormalInterpolator(const B3DVector& rA, const B3DVector& rB, double fInvYDelta)
 186         {
 187             double aDeltaX(rB.getX() - rA.getX());
 188
 189             if(fTools::equalZero(aDeltaX))
 190             {
 191                 aDeltaX = 0.0;
 192             }
 193             else
 194             {
 195                 aDeltaX *= fInvYDelta;
 196             }
 197
 198             double aDeltaY(rB.getY() - rA.getY());
 199
 200             if(fTools::equalZero(aDeltaY))
 201             {
 202                 aDeltaY = 0.0;
 203             }
 204             else
 205             {
 206                 aDeltaY *= fInvYDelta;
 207             }
 208
 209             double aDeltaZ(rB.getZ() - rA.getZ());
 210
 211             if(fTools::equalZero(aDeltaZ))
 212             {
 213                 aDeltaZ = 0.0;
 214             }
 215             else
 216             {
 217                 aDeltaZ *= fInvYDelta;
 218             }
 219
 220             maNormalInterpolators.push_back(
 221                 ip_triple(
 222                     rA.getX(), aDeltaX,
 223                     rA.getY(), aDeltaY,
 224                     rA.getZ(), aDeltaZ));
 225
 226             return (maNormalInterpolators.size() - 1);
 227         }
 228
 229         sal_uInt32 addTextureInterpolator(const B2DPoint& rA, const B2DPoint& rB, double fInvYDelta)
 230         {
 231             double aDeltaX(rB.getX() - rA.getX());
 232
 233             if(fTools::equalZero(aDeltaX))
 234             {
 235                 aDeltaX = 0.0;
 236             }
 237             else
 238             {
 239                 aDeltaX *= fInvYDelta;
 240             }
 241
 242             double aDeltaY(rB.getY() - rA.getY());
 243
 244             if(fTools::equalZero(aDeltaY))
 245             {
 246                 aDeltaY = 0.0;
 247             }
 248             else
 249             {
 250                 aDeltaY *= fInvYDelta;
 251             }
 252
 253             maTextureInterpolators.push_back(
 254                 ip_double(
 255                     rA.getX(), aDeltaX,
 256                     rA.getY(), aDeltaY));
 257
 258             return (maTextureInterpolators.size() - 1);
 259         }
 260
 261         sal_uInt32 addInverseTextureInterpolator(const B2DPoint& rA, const B2DPoint& rB, double fZEyeA, double fZEyeB, double fInvYDelta)
 262         {
 263             double fZDelta(fZEyeB - fZEyeA);
 264             const double fInvZEyeA(fTools::equalZero(fZEyeA) ? fZEyeA : 1.0 / fZEyeA);
 265             double fInvZEyeB(fInvZEyeA);
 266
 267             if(fTools::equalZero(fZDelta))
 268             {
 269                 fZDelta = 0.0;
 270             }
 271             else
 272             {
 273                 fInvZEyeB = fTools::equalZero(fZEyeB) ? fZEyeB : 1.0 / fZEyeB;
 274                 fZDelta = (fInvZEyeB - fInvZEyeA) * fInvYDelta;
 275             }
 276
 277             const B2DPoint aInvA(rA * fInvZEyeA);
 278             const B2DPoint aInvB(rB * fInvZEyeB);
 279             const double aDeltaX((aInvB.getX() - aInvA.getX()) * fInvYDelta);
 280             const double aDeltaY((aInvB.getY() - aInvA.getY()) * fInvYDelta);
 281
 282             maInverseTextureInterpolators.push_back(
 283                 ip_triple(
 284                     aInvA.getX(), aDeltaX,
 285                     aInvA.getY(), aDeltaY,
 286                     fInvZEyeA, fZDelta));
 287
 288             return (maInverseTextureInterpolators.size() - 1);
 289         }
 290
 291         void reset()
 292         {
 293             maColorInterpolators.clear();
 294             maNormalInterpolators.clear();
 295             maTextureInterpolators.clear();
 296             maInverseTextureInterpolators.clear();
 297         }
 298
 299     public:
 300         InterpolatorProvider3D() {}
 301
 302         ::std::vector< ip_triple >& getColorInterpolators() { return maColorInterpolators; }
 303         ::std::vector< ip_triple >& getNormalInterpolators() { return maNormalInterpolators; }
 304         ::std::vector< ip_double >& getTextureInterpolators() { return maTextureInterpolators; }
 305         ::std::vector< ip_triple >& getInverseTextureInterpolators() { return maInverseTextureInterpolators; }
 306     };
 307 } // end of namespace basegfx
 308
 309
 310 // RasterConversionLineEntry3D for Rasterconversion of 3D PolyPolygons
 311
 312 namespace basegfx
 313 {
 314     class RasterConversionLineEntry3D
 315     {
 316     private:
 317         ip_single                                   maX;
 318         ip_single                                   maZ;
 319         sal_Int32                                   mnY;
 320         sal_uInt32                                  mnCount;
 321
 322         sal_uInt32                                  mnColorIndex;
 323         sal_uInt32                                  mnNormalIndex;
 324         sal_uInt32                                  mnTextureIndex;
 325         sal_uInt32                                  mnInverseTextureIndex;
 326
 327     public:
 328         RasterConversionLineEntry3D(const double& rfX, const double& rfDeltaX, const double& rfZ, const double& rfDeltaZ, sal_Int32 nY, sal_uInt32 nCount)
 329         :   maX(rfX, rfDeltaX),
 330             maZ(rfZ, rfDeltaZ),
 331             mnY(nY),
 332             mnCount(nCount),
 333             mnColorIndex(SCANLINE_EMPTY_INDEX),
 334             mnNormalIndex(SCANLINE_EMPTY_INDEX),
 335             mnTextureIndex(SCANLINE_EMPTY_INDEX),
 336             mnInverseTextureIndex(SCANLINE_EMPTY_INDEX)
 337         {}
 338
 339         void setColorIndex(sal_uInt32 nIndex) { mnColorIndex = nIndex; }
 340         void setNormalIndex(sal_uInt32 nIndex) { mnNormalIndex = nIndex; }
 341         void setTextureIndex(sal_uInt32 nIndex) { mnTextureIndex = nIndex; }
 342         void setInverseTextureIndex(sal_uInt32 nIndex) { mnInverseTextureIndex = nIndex; }
 343
 344         bool operator<(const RasterConversionLineEntry3D& rComp) const
 345         {
 346             if(mnY == rComp.mnY)
 347             {
 348                 return maX.getVal() < rComp.maX.getVal();
 349             }
 350
 351             return mnY < rComp.mnY;
 352         }
 353
 354         bool decrementRasterConversionLineEntry3D(sal_uInt32 nStep)
 355         {
 356             if(nStep >= mnCount)
 357             {
 358                 return false;
 359             }
 360             else
 361             {
 362                 mnCount -= nStep;
 363                 return true;
 364             }
 365         }
 366
 367         void incrementRasterConversionLineEntry3D(sal_uInt32 nStep, InterpolatorProvider3D& rProvider)
 368         {
 369             const double fStep((double)nStep);
 370             maX.increment(fStep);
 371             maZ.increment(fStep);
 372             mnY += nStep;
 373
 374             if(SCANLINE_EMPTY_INDEX != mnColorIndex)
 375             {
 376                 rProvider.getColorInterpolators()[mnColorIndex].increment(fStep);
 377             }
 378
 379             if(SCANLINE_EMPTY_INDEX != mnNormalIndex)
 380             {
 381                 rProvider.getNormalInterpolators()[mnNormalIndex].increment(fStep);
 382             }
 383
 384             if(SCANLINE_EMPTY_INDEX != mnTextureIndex)
 385             {
 386                 rProvider.getTextureInterpolators()[mnTextureIndex].increment(fStep);
 387             }
 388
 389             if(SCANLINE_EMPTY_INDEX != mnInverseTextureIndex)
 390             {
 391                 rProvider.getInverseTextureInterpolators()[mnInverseTextureIndex].increment(fStep);
 392             }
 393         }
 394
 395         // data read access
 396         const ip_single& getX() const { return maX; }
 397         sal_Int32 getY() const { return mnY; }
 398         const ip_single& getZ() const { return maZ; }
 399         sal_uInt32 getColorIndex() const { return mnColorIndex; }
 400         sal_uInt32 getNormalIndex() const { return mnNormalIndex; }
 401         sal_uInt32 getTextureIndex() const { return mnTextureIndex; }
 402         sal_uInt32 getInverseTextureIndex() const { return mnInverseTextureIndex; }
 403     };
 404 } // end of namespace basegfx
 405
 406
 407 // the basic RasterConverter itself. Only one method needs to be overridden. The
 408 // class itself is pure virtual
 409
 410 namespace basegfx
 411 {
 412     class BASEGFX_DLLPUBLIC RasterConverter3D : public InterpolatorProvider3D
 413     {
 414     private:
 415         // the line entries for an area conversion run
 416         ::std::vector< RasterConversionLineEntry3D >            maLineEntries;
 417
 418         struct lineComparator
 419         {
 420             bool operator()(const RasterConversionLineEntry3D* pA, const RasterConversionLineEntry3D* pB)
 421             {
 422                 OSL_ENSURE(pA && pB, "lineComparator: empty pointer (!)");
 423                 return pA->getX().getVal() < pB->getX().getVal();
 424             }
 425         };
 426
 427         void addArea(const B3DPolygon& rFill, const B3DHomMatrix* pViewToEye);
 428         void addArea(const B3DPolyPolygon& rFill, const B3DHomMatrix* pViewToEye);
 429         void addEdge(const B3DPolygon& rFill, sal_uInt32 a, sal_uInt32 b, const B3DHomMatrix* pViewToEye);
 430
 431         void rasterconvertB3DArea(sal_Int32 nStartLine, sal_Int32 nStopLine);
 432         void rasterconvertB3DEdge(const B3DPolygon& rLine, sal_uInt32 nA, sal_uInt32 nB, sal_Int32 nStartLine, sal_Int32 nStopLine, sal_uInt16 nLineWidth);
 433
 434         virtual void processLineSpan(const RasterConversionLineEntry3D& rA, const RasterConversionLineEntry3D& rB, sal_Int32 nLine, sal_uInt32 nSpanCount) = 0;
 435
 436     public:
 437         RasterConverter3D();
 438         virtual ~RasterConverter3D();
 439
 440         void rasterconvertB3DPolyPolygon(const B3DPolyPolygon& rFill, const B3DHomMatrix* pViewToEye, sal_Int32 nStartLine, sal_Int32 nStopLine);
 441         void rasterconvertB3DPolygon(const B3DPolygon& rLine, sal_Int32 nStartLine, sal_Int32 nStopLine, sal_uInt16 nLineWidth);
 442     };
 443 } // end of namespace basegfx
 444
 445 #endif // INCLUDED_BASEGFX_RASTER_RASTERCONVERT3D_HXX
 446
 447 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */