drawinglayer/source/processor3d/zbufferprocessor3d.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: zbufferprocessor3d.cxx,v $
   6  *
   7  *  $Revision: 1.5 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-06-24 15:31:09 $
  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/processor3d/zbufferprocessor3d.hxx>
  40 #include <basegfx/raster/bpixelraster.hxx>
  41 #include <vcl/bmpacc.hxx>
  42 #include <basegfx/raster/rasterconvert3d.hxx>
  43 #include <basegfx/raster/bzpixelraster.hxx>
  44 #include <drawinglayer/attribute/materialattribute3d.hxx>
  45 #include <drawinglayer/texture/texture.hxx>
  46 #include <drawinglayer/attribute/sdrattribute3d.hxx>
  47 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
  48 #include <drawinglayer/primitive3d/textureprimitive3d.hxx>
  49 #include <drawinglayer/primitive3d/polygonprimitive3d.hxx>
  50 #include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
  51 #include <drawinglayer/geometry/viewinformation2d.hxx>
  52 #include <basegfx/polygon/b3dpolygontools.hxx>
  53
  54 //////////////////////////////////////////////////////////////////////////////
  55
  56 using namespace com::sun::star;
  57
  58 //////////////////////////////////////////////////////////////////////////////
  59
  60 namespace
  61 {
  62     BitmapEx BPixelRasterToBitmapEx(const basegfx::BPixelRaster& rRaster, sal_uInt16 mnAntiAlialize)
  63     {
  64         BitmapEx aRetval;
  65         const sal_uInt32 nWidth(mnAntiAlialize ? rRaster.getWidth()/mnAntiAlialize : rRaster.getWidth());
  66         const sal_uInt32 nHeight(mnAntiAlialize ? rRaster.getHeight()/mnAntiAlialize : rRaster.getHeight());
  67
  68         if(nWidth && nHeight)
  69         {
  70             const Size aDestSize(nWidth, nHeight);
  71             sal_uInt8 nInitAlpha(255);
  72             Bitmap aContent(aDestSize, 24);
  73             AlphaMask aAlpha(aDestSize, &nInitAlpha);
  74             BitmapWriteAccess* pContent = aContent.AcquireWriteAccess();
  75             BitmapWriteAccess* pAlpha = aAlpha.AcquireWriteAccess();
  76
  77             if(pContent && pAlpha)
  78             {
  79                 if(mnAntiAlialize)
  80                 {
  81                     const sal_uInt16 nDivisor(mnAntiAlialize * mnAntiAlialize);
  82
  83                     for(sal_uInt32 y(0L); y < nHeight; y++)
  84                     {
  85                         for(sal_uInt32 x(0L); x < nWidth; x++)
  86                         {
  87                             sal_uInt16 nRed(0);
  88                             sal_uInt16 nGreen(0);
  89                             sal_uInt16 nBlue(0);
  90                             sal_uInt16 nOpacity(0);
  91                             sal_uInt32 nIndex(rRaster.getIndexFromXY(x * mnAntiAlialize, y * mnAntiAlialize));
  92
  93                             for(sal_uInt32 c(0); c < mnAntiAlialize; c++)
  94                             {
  95                                 for(sal_uInt32 d(0); d < mnAntiAlialize; d++)
  96                                 {
  97                                     const basegfx::BPixel& rPixel(rRaster.getBPixel(nIndex++));
  98                                     nRed = nRed + rPixel.getRed();
  99                                     nGreen = nGreen + rPixel.getGreen();
 100                                     nBlue = nBlue + rPixel.getBlue();
 101                                     nOpacity = nOpacity + rPixel.getOpacity();
 102                                 }
 103
 104                                 nIndex += rRaster.getWidth() - mnAntiAlialize;
 105                             }
 106
 107                             nOpacity = nOpacity / nDivisor;
 108
 109                             if(nOpacity)
 110                             {
 111                                 pContent->SetPixel(y, x, BitmapColor(
 112                                     (sal_uInt8)(nRed / nDivisor),
 113                                     (sal_uInt8)(nGreen / nDivisor),
 114                                     (sal_uInt8)(nBlue / nDivisor)));
 115                                 pAlpha->SetPixel(y, x, BitmapColor(255 - (sal_uInt8)nOpacity));
 116                             }
 117                         }
 118                     }
 119                 }
 120                 else
 121                 {
 122                     sal_uInt32 nIndex(0L);
 123
 124                     for(sal_uInt32 y(0L); y < nHeight; y++)
 125                     {
 126                         for(sal_uInt32 x(0L); x < nWidth; x++)
 127                         {
 128                             const basegfx::BPixel& rPixel(rRaster.getBPixel(nIndex++));
 129
 130                             if(rPixel.getOpacity())
 131                             {
 132                                 pContent->SetPixel(y, x, BitmapColor(rPixel.getRed(), rPixel.getGreen(), rPixel.getBlue()));
 133                                 pAlpha->SetPixel(y, x, BitmapColor(255 - rPixel.getOpacity()));
 134                             }
 135                         }
 136                     }
 137                 }
 138
 139                 delete pContent;
 140                 delete pAlpha;
 141             }
 142
 143             aRetval = BitmapEx(aContent, aAlpha);
 144
 145             // #i101811# set PrefMapMode and PrefSize at newly created Bitmap
 146             aRetval.SetPrefMapMode(MAP_100TH_MM);
 147             aRetval.SetPrefSize(Size(nWidth, nHeight));
 148         }
 149
 150         return aRetval;
 151     }
 152 } // end of anonymous namespace
 153
 154 //////////////////////////////////////////////////////////////////////////////
 155
 156 class ZBufferRasterConverter3D : public basegfx::RasterConverter3D
 157 {
 158 private:
 159     const drawinglayer::processor3d::DefaultProcessor3D&        mrProcessor;
 160     basegfx::BZPixelRaster&                                                                 mrBuffer;
 161
 162     // interpolators for a single line span
 163     basegfx::ip_single                                                                          maIntZ;
 164     basegfx::ip_triple                                                                          maIntColor;
 165     basegfx::ip_triple                                                                          maIntNormal;
 166     basegfx::ip_double                                                                          maIntTexture;
 167     basegfx::ip_triple                                                                          maIntInvTexture;
 168
 169     // current material to use for ratsreconversion
 170     const drawinglayer::attribute::MaterialAttribute3D*     mpCurrentMaterial;
 171
 172     // bitfield
 173     // some boolean flags for line span interpolator usages
 174     unsigned                                                                                            mbModifyColor : 1;
 175     unsigned                                                                                            mbUseTex : 1;
 176     unsigned                                                                                            mbHasTexCoor : 1;
 177     unsigned                                                                                            mbHasInvTexCoor : 1;
 178     unsigned                                                                                            mbUseNrm : 1;
 179     unsigned                                                                                            mbUseCol : 1;
 180
 181     void getTextureCoor(basegfx::B2DPoint& rTarget) const
 182     {
 183         if(mbHasTexCoor)
 184         {
 185             rTarget.setX(maIntTexture.getX().getVal());
 186             rTarget.setY(maIntTexture.getY().getVal());
 187         }
 188         else if(mbHasInvTexCoor)
 189         {
 190             const double fZFactor(maIntInvTexture.getZ().getVal());
 191             const double fInvZFactor(basegfx::fTools::equalZero(fZFactor) ? 1.0 : 1.0 / fZFactor);
 192             rTarget.setX(maIntInvTexture.getX().getVal() * fInvZFactor);
 193             rTarget.setY(maIntInvTexture.getY().getVal() * fInvZFactor);
 194         }
 195     }
 196
 197     void incrementLineSpanInterpolators(double fStep)
 198     {
 199         maIntZ.increment(fStep);
 200
 201         if(mbUseTex)
 202         {
 203             if(mbHasTexCoor)
 204             {
 205                 maIntTexture.increment(fStep);
 206             }
 207             else if(mbHasInvTexCoor)
 208             {
 209                 maIntInvTexture.increment(fStep);
 210             }
 211         }
 212
 213         if(mbUseNrm)
 214         {
 215             maIntNormal.increment(fStep);
 216         }
 217
 218         if(mbUseCol)
 219         {
 220             maIntColor.increment(fStep);
 221         }
 222     }
 223
 224     double decideColorAndOpacity(basegfx::BColor& rColor)
 225     {
 226         // init values with full opacity and material color
 227         OSL_ENSURE(0 != mpCurrentMaterial, "CurrentMaterial not set (!)");
 228         double fOpacity(1.0);
 229         rColor = mpCurrentMaterial->getColor();
 230
 231         if(mbUseTex)
 232         {
 233             basegfx::B2DPoint aTexCoor(0.0, 0.0);
 234             getTextureCoor(aTexCoor);
 235
 236             if(mrProcessor.getGeoTexSvx())
 237             {
 238                 // calc color in spot. This may also set to invisible already when
 239                 // e.g. bitmap textures have transparent parts
 240                 mrProcessor.getGeoTexSvx()->modifyBColor(aTexCoor, rColor, fOpacity);
 241             }
 242
 243             if(basegfx::fTools::more(fOpacity, 0.0) && mrProcessor.getTransparenceGeoTexSvx())
 244             {
 245                 // calc opacity. Object has a 2nd texture, a transparence texture
 246                 mrProcessor.getTransparenceGeoTexSvx()->modifyOpacity(aTexCoor, fOpacity);
 247             }
 248         }
 249
 250         if(basegfx::fTools::more(fOpacity, 0.0))
 251         {
 252             if(mrProcessor.getGeoTexSvx())
 253             {
 254                 if(mbUseNrm)
 255                 {
 256                     // blend texture with phong
 257                     rColor = mrProcessor.getSdrLightingAttribute().solveColorModel(
 258                         basegfx::B3DVector(maIntNormal.getX().getVal(), maIntNormal.getY().getVal(), maIntNormal.getZ().getVal()),
 259                         rColor,
 260                         mpCurrentMaterial->getSpecular(),
 261                         mpCurrentMaterial->getEmission(),
 262                         mpCurrentMaterial->getSpecularIntensity());
 263                 }
 264                 else if(mbUseCol)
 265                 {
 266                     // blend texture with gouraud
 267                     basegfx::BColor aBlendColor(maIntColor.getX().getVal(), maIntColor.getY().getVal(), maIntColor.getZ().getVal());
 268                     rColor *= aBlendColor;
 269                 }
 270                 else if(mrProcessor.getModulate())
 271                 {
 272                     // blend texture with single material color
 273                     rColor *= mpCurrentMaterial->getColor();
 274                 }
 275             }
 276             else
 277             {
 278                 if(mbUseNrm)
 279                 {
 280                     // modify color with phong
 281                     rColor = mrProcessor.getSdrLightingAttribute().solveColorModel(
 282                         basegfx::B3DVector(maIntNormal.getX().getVal(), maIntNormal.getY().getVal(), maIntNormal.getZ().getVal()),
 283                         rColor,
 284                         mpCurrentMaterial->getSpecular(),
 285                         mpCurrentMaterial->getEmission(),
 286                         mpCurrentMaterial->getSpecularIntensity());
 287                 }
 288                 else if(mbUseCol)
 289                 {
 290                     // modify color with gouraud
 291                     rColor.setRed(maIntColor.getX().getVal());
 292                     rColor.setGreen(maIntColor.getY().getVal());
 293                     rColor.setBlue(maIntColor.getZ().getVal());
 294                 }
 295             }
 296
 297             if(mbModifyColor)
 298             {
 299                 rColor = mrProcessor.getBColorModifierStack().getModifiedColor(rColor);
 300             }
 301         }
 302
 303         return fOpacity;
 304     }
 305
 306     void setupLineSpanInterpolators(const basegfx::RasterConversionLineEntry3D& rA, const basegfx::RasterConversionLineEntry3D& rB)
 307     {
 308         // get inverse XDelta
 309         const double xInvDelta(1.0 / (rB.getX().getVal() - rA.getX().getVal()));
 310
 311         // prepare Z-interpolator
 312         const double fZA(rA.getZ().getVal());
 313         const double fZB(rB.getZ().getVal());
 314         maIntZ = basegfx::ip_single(fZA, (fZB - fZA) * xInvDelta);
 315
 316         // get bools and init other interpolators on demand accordingly
 317         mbModifyColor = mrProcessor.getBColorModifierStack().count();
 318         mbHasTexCoor = SCANLINE_EMPTY_INDEX != rA.getTextureIndex() && SCANLINE_EMPTY_INDEX != rB.getTextureIndex();
 319         mbHasInvTexCoor = SCANLINE_EMPTY_INDEX != rA.getInverseTextureIndex() && SCANLINE_EMPTY_INDEX != rB.getInverseTextureIndex();
 320         const bool bTextureActive(mrProcessor.getGeoTexSvx() || mrProcessor.getTransparenceGeoTexSvx());
 321         mbUseTex = bTextureActive && (mbHasTexCoor || mbHasInvTexCoor || mrProcessor.getSimpleTextureActive());
 322         const bool bUseColorTex(mbUseTex && mrProcessor.getGeoTexSvx());
 323         const bool bNeedNrmOrCol(!bUseColorTex || (bUseColorTex && mrProcessor.getModulate()));
 324         mbUseNrm = bNeedNrmOrCol && SCANLINE_EMPTY_INDEX != rA.getNormalIndex() && SCANLINE_EMPTY_INDEX != rB.getNormalIndex();
 325         mbUseCol = !mbUseNrm && bNeedNrmOrCol && SCANLINE_EMPTY_INDEX != rA.getColorIndex() && SCANLINE_EMPTY_INDEX != rB.getColorIndex();
 326
 327         if(mbUseTex)
 328         {
 329             if(mbHasTexCoor)
 330             {
 331                 const basegfx::ip_double& rTA(getTextureInterpolators()[rA.getTextureIndex()]);
 332                 const basegfx::ip_double& rTB(getTextureInterpolators()[rB.getTextureIndex()]);
 333                 maIntTexture = basegfx::ip_double(
 334                     rTA.getX().getVal(), (rTB.getX().getVal() - rTA.getX().getVal()) * xInvDelta,
 335                     rTA.getY().getVal(), (rTB.getY().getVal() - rTA.getY().getVal()) * xInvDelta);
 336             }
 337             else if(mbHasInvTexCoor)
 338             {
 339                 const basegfx::ip_triple& rITA(getInverseTextureInterpolators()[rA.getInverseTextureIndex()]);
 340                 const basegfx::ip_triple& rITB(getInverseTextureInterpolators()[rB.getInverseTextureIndex()]);
 341                 maIntInvTexture = basegfx::ip_triple(
 342                     rITA.getX().getVal(), (rITB.getX().getVal() - rITA.getX().getVal()) * xInvDelta,
 343                     rITA.getY().getVal(), (rITB.getY().getVal() - rITA.getY().getVal()) * xInvDelta,
 344                     rITA.getZ().getVal(), (rITB.getZ().getVal() - rITA.getZ().getVal()) * xInvDelta);
 345             }
 346         }
 347
 348         if(mbUseNrm)
 349         {
 350             const basegfx::ip_triple& rNA(getNormalInterpolators()[rA.getNormalIndex()]);
 351             const basegfx::ip_triple& rNB(getNormalInterpolators()[rB.getNormalIndex()]);
 352             maIntNormal = basegfx::ip_triple(
 353                 rNA.getX().getVal(), (rNB.getX().getVal() - rNA.getX().getVal()) * xInvDelta,
 354                 rNA.getY().getVal(), (rNB.getY().getVal() - rNA.getY().getVal()) * xInvDelta,
 355                 rNA.getZ().getVal(), (rNB.getZ().getVal() - rNA.getZ().getVal()) * xInvDelta);
 356         }
 357
 358         if(mbUseCol)
 359         {
 360             const basegfx::ip_triple& rCA(getColorInterpolators()[rA.getColorIndex()]);
 361             const basegfx::ip_triple& rCB(getColorInterpolators()[rB.getColorIndex()]);
 362             maIntColor = basegfx::ip_triple(
 363                 rCA.getX().getVal(), (rCB.getX().getVal() - rCA.getX().getVal()) * xInvDelta,
 364                 rCA.getY().getVal(), (rCB.getY().getVal() - rCA.getY().getVal()) * xInvDelta,
 365                 rCA.getZ().getVal(), (rCB.getZ().getVal() - rCA.getZ().getVal()) * xInvDelta);
 366         }
 367     }
 368
 369     virtual void processLineSpan(const basegfx::RasterConversionLineEntry3D& rA, const basegfx::RasterConversionLineEntry3D& rB, sal_Int32 nLine, sal_uInt32 nSpanCount);
 370
 371 public:
 372     ZBufferRasterConverter3D(basegfx::BZPixelRaster& rBuffer, const drawinglayer::processor3d::ZBufferProcessor3D& rProcessor)
 373     :   basegfx::RasterConverter3D(),
 374         mrProcessor(rProcessor),
 375         mrBuffer(rBuffer),
 376         maIntZ(),
 377         maIntColor(),
 378         maIntNormal(),
 379         maIntTexture(),
 380         maIntInvTexture(),
 381         mpCurrentMaterial(0),
 382         mbModifyColor(false),
 383         mbUseTex(false),
 384         mbHasTexCoor(false),
 385         mbUseNrm(false),
 386         mbUseCol(false)
 387     {}
 388
 389     void setCurrentMaterial(const drawinglayer::attribute::MaterialAttribute3D& rMaterial)
 390     {
 391         mpCurrentMaterial = &rMaterial;
 392     }
 393 };
 394
 395 void ZBufferRasterConverter3D::processLineSpan(const basegfx::RasterConversionLineEntry3D& rA, const basegfx::RasterConversionLineEntry3D& rB, sal_Int32 nLine, sal_uInt32 nSpanCount)
 396 {
 397     if(!(nSpanCount & 0x0001))
 398     {
 399         if(nLine >= 0 && nLine < (sal_Int32)mrBuffer.getHeight())
 400         {
 401             sal_uInt32 nXA(::std::min(mrBuffer.getWidth(), (sal_uInt32)::std::max((sal_Int32)0, basegfx::fround(rA.getX().getVal()))));
 402             const sal_uInt32 nXB(::std::min(mrBuffer.getWidth(), (sal_uInt32)::std::max((sal_Int32)0, basegfx::fround(rB.getX().getVal()))));
 403
 404             if(nXA < nXB)
 405             {
 406                 // prepare the span interpolators
 407                 setupLineSpanInterpolators(rA, rB);
 408
 409                 // bring span interpolators to start condition by incrementing with the possible difference of
 410                 // clamped and non-clamped XStart. Interpolators are setup relying on double precision
 411                 // X-values, so that difference is the correct value to compensate for possible clampings
 412                 incrementLineSpanInterpolators(static_cast<double>(nXA) - rA.getX().getVal());
 413
 414                 // prepare scanline index
 415                 sal_uInt32 nScanlineIndex(mrBuffer.getIndexFromXY(nXA, static_cast<sal_uInt32>(nLine)));
 416                 basegfx::BColor aNewColor;
 417
 418                 while(nXA < nXB)
 419                 {
 420                     // early-test Z values if we need to do anything at all
 421                     const double fNewZ(::std::max(0.0, ::std::min((double)0xffff, maIntZ.getVal())));
 422                     const sal_uInt16 nNewZ(static_cast< sal_uInt16 >(fNewZ));
 423                     sal_uInt16& rOldZ(mrBuffer.getZ(nScanlineIndex));
 424
 425                     if(nNewZ > rOldZ)
 426                     {
 427                         // detect color and opacity for this pixel
 428                         const sal_uInt16 nOpacity(::std::max((sal_Int16)0, static_cast< sal_Int16 >(decideColorAndOpacity(aNewColor) * 255.0)));
 429
 430                         if(nOpacity > 0)
 431                         {
 432                             // avoid color overrun
 433                             aNewColor.clamp();
 434
 435                             if(nOpacity >= 0x00ff)
 436                             {
 437                                 // full opacity, set z and color
 438                                 rOldZ = nNewZ;
 439                                 mrBuffer.getBPixel(nScanlineIndex) = basegfx::BPixel(aNewColor, 0xff);
 440                             }
 441                             else
 442                             {
 443                                 basegfx::BPixel& rDest = mrBuffer.getBPixel(nScanlineIndex);
 444
 445                                 if(rDest.getOpacity())
 446                                 {
 447                                     // both transparent, mix color based on front pixel's opacity
 448                                     // (the new one)
 449                                     const sal_uInt16 nTransparence(0x0100 - nOpacity);
 450                                     rDest.setRed((sal_uInt8)(((rDest.getRed() * nTransparence) + ((sal_uInt16)(255.0 * aNewColor.getRed()) * nOpacity)) >> 8));
 451                                     rDest.setGreen((sal_uInt8)(((rDest.getGreen() * nTransparence) + ((sal_uInt16)(255.0 * aNewColor.getGreen()) * nOpacity)) >> 8));
 452                                     rDest.setBlue((sal_uInt8)(((rDest.getBlue() * nTransparence) + ((sal_uInt16)(255.0 * aNewColor.getBlue()) * nOpacity)) >> 8));
 453
 454                                     if(0xff != rDest.getOpacity())
 455                                     {
 456                                         // destination is also transparent, mix opacities by weighting
 457                                         // old opacity with new pixel's transparence and adding new opacity
 458                                         rDest.setOpacity((sal_uInt8)(((rDest.getOpacity() * nTransparence) >> 8) + nOpacity));
 459                                     }
 460                                 }
 461                                 else
 462                                 {
 463                                     // dest is not visible. Set color.
 464                                     rDest = basegfx::BPixel(aNewColor, (sal_uInt8)nOpacity);
 465                                 }
 466                             }
 467                         }
 468                     }
 469
 470                     // increments
 471                     nScanlineIndex++;
 472                     nXA++;
 473                     incrementLineSpanInterpolators(1.0);
 474                 }
 475             }
 476         }
 477     }
 478 }
 479
 480 //////////////////////////////////////////////////////////////////////////////
 481
 482 namespace drawinglayer
 483 {
 484     namespace processor3d
 485     {
 486         // the processing method for a single, known primitive
 487         void ZBufferProcessor3D::processBasePrimitive3D(const primitive3d::BasePrimitive3D& rBasePrimitive)
 488         {
 489             // it is a BasePrimitive3D implementation, use getPrimitiveID() call for switch
 490             switch(rBasePrimitive.getPrimitiveID())
 491             {
 492                 case PRIMITIVE3D_ID_ALPHATEXTUREPRIMITIVE3D :
 493                 {
 494                     // AlphaTexturePrimitive3D
 495                     const primitive3d::AlphaTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::AlphaTexturePrimitive3D& >(rBasePrimitive);
 496
 497                     if(mbProcessTransparent)
 498                     {
 499                         impRenderGradientTexturePrimitive3D(rPrimitive, true);
 500                     }
 501                     else
 502                     {
 503                         mbContainsTransparent = true;
 504                     }
 505                     break;
 506                 }
 507                 case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D :
 508                 {
 509                     // directdraw of PolygonHairlinePrimitive3D
 510                     const primitive3d::PolygonHairlinePrimitive3D& rPrimitive = static_cast< const primitive3d::PolygonHairlinePrimitive3D& >(rBasePrimitive);
 511
 512                     // do something when either not transparent and no transMap, or transparent and a TransMap
 513                     if((bool)mbProcessTransparent == (0 != getTransparenceGeoTexSvx()))
 514                     {
 515                         impRenderPolygonHairlinePrimitive3D(rPrimitive);
 516                     }
 517                     break;
 518                 }
 519                 case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D :
 520                 {
 521                     // directdraw of PolyPolygonMaterialPrimitive3D
 522                     const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const primitive3d::PolyPolygonMaterialPrimitive3D& >(rBasePrimitive);
 523
 524                     // do something when either not transparent and no transMap, or transparent and a TransMap
 525                     if((bool)mbProcessTransparent == (0 != getTransparenceGeoTexSvx()))
 526                     {
 527                         impRenderPolyPolygonMaterialPrimitive3D(rPrimitive);
 528                     }
 529                     break;
 530                 }
 531                 default:
 532                 {
 533                     // use the DefaultProcessor3D::processBasePrimitive3D()
 534                     DefaultProcessor3D::processBasePrimitive3D(rBasePrimitive);
 535                     break;
 536                 }
 537             }
 538         }
 539
 540         void ZBufferProcessor3D::processNonTransparent(const primitive3d::Primitive3DSequence& rSource)
 541         {
 542             if(mpBZPixelRaster)
 543             {
 544                 mbProcessTransparent = false;
 545                 mbContainsTransparent = false;
 546                 process(rSource);
 547             }
 548         }
 549
 550         void ZBufferProcessor3D::processTransparent(const primitive3d::Primitive3DSequence& rSource)
 551         {
 552             if(mpBZPixelRaster && mbContainsTransparent)
 553             {
 554                 mbProcessTransparent = true;
 555                 process(rSource);
 556             }
 557         }
 558
 559         void ZBufferProcessor3D::rasterconvertB3DPolygon(const attribute::MaterialAttribute3D& rMaterial, const basegfx::B3DPolygon& rHairline) const
 560         {
 561             if(mpBZPixelRaster)
 562             {
 563                 mpZBufferRasterConverter3D->setCurrentMaterial(rMaterial);
 564
 565                 if(mnAntiAlialize > 1)
 566                 {
 567                     const bool bForceLineSnap(getOptionsDrawinglayer().IsAntiAliasing() && getOptionsDrawinglayer().IsSnapHorVerLinesToDiscrete());
 568
 569                     if(bForceLineSnap)
 570                     {
 571                         basegfx::B3DHomMatrix aTransform;
 572                         basegfx::B3DPolygon aSnappedHairline(rHairline);
 573                         const double fScaleDown(1.0 / mnAntiAlialize);
 574                         const double fScaleUp(mnAntiAlialize);
 575
 576                         // take oversampling out
 577                         aTransform.scale(fScaleDown, fScaleDown, 1.0);
 578                         aSnappedHairline.transform(aTransform);
 579
 580                         // snap to integer
 581                         aSnappedHairline = basegfx::tools::snapPointsOfHorizontalOrVerticalEdges(aSnappedHairline);
 582
 583                         // add oversampling again
 584                         aTransform.identity();
 585                         aTransform.scale(fScaleUp, fScaleUp, 1.0);
 586
 587                         if(false)
 588                         {
 589                             // when really want to go to single pixel lines, move to center.
 590                             // Without this translation, all hor/ver hairlines will be centered exactly
 591                             // between two pixel lines (which looks best)
 592                             const double fTranslateToCenter(mnAntiAlialize * 0.5);
 593                             aTransform.translate(fTranslateToCenter, fTranslateToCenter, 0.0);
 594                         }
 595
 596                         aSnappedHairline.transform(aTransform);
 597
 598                         mpZBufferRasterConverter3D->rasterconvertB3DPolygon(aSnappedHairline, 0, mpBZPixelRaster->getHeight(), mnAntiAlialize);
 599                     }
 600                     else
 601                     {
 602                         mpZBufferRasterConverter3D->rasterconvertB3DPolygon(rHairline, 0, mpBZPixelRaster->getHeight(), mnAntiAlialize);
 603                     }
 604                 }
 605                 else
 606                 {
 607                     mpZBufferRasterConverter3D->rasterconvertB3DPolygon(rHairline, 0, mpBZPixelRaster->getHeight(), 1);
 608                 }
 609             }
 610         }
 611
 612         void ZBufferProcessor3D::rasterconvertB3DPolyPolygon(const attribute::MaterialAttribute3D& rMaterial, const basegfx::B3DPolyPolygon& rFill) const
 613         {
 614             if(mpBZPixelRaster)
 615             {
 616                 mpZBufferRasterConverter3D->setCurrentMaterial(rMaterial);
 617                 mpZBufferRasterConverter3D->rasterconvertB3DPolyPolygon(rFill, &maInvEyeToView, 0, mpBZPixelRaster->getHeight());
 618             }
 619         }
 620
 621         ZBufferProcessor3D::ZBufferProcessor3D(
 622             const geometry::ViewInformation3D& rViewInformation3D,
 623             const geometry::ViewInformation2D& rViewInformation2D,
 624             const attribute::SdrSceneAttribute& rSdrSceneAttribute,
 625             const attribute::SdrLightingAttribute& rSdrLightingAttribute,
 626             double fSizeX,
 627             double fSizeY,
 628             const basegfx::B2DRange& rVisiblePart,
 629             sal_uInt16 nAntiAlialize)
 630         :       DefaultProcessor3D(rViewInformation3D, rSdrSceneAttribute, rSdrLightingAttribute),
 631             mpBZPixelRaster(0),
 632             maInvEyeToView(),
 633             mpZBufferRasterConverter3D(0),
 634             mnAntiAlialize(nAntiAlialize),
 635             mbProcessTransparent(false),
 636             mbContainsTransparent(false)
 637         {
 638             // generate ViewSizes
 639             const double fFullViewSizeX((rViewInformation2D.getObjectToViewTransformation() * basegfx::B2DVector(fSizeX, 0.0)).getLength());
 640             const double fFullViewSizeY((rViewInformation2D.getObjectToViewTransformation() * basegfx::B2DVector(0.0, fSizeY)).getLength());
 641             const double fViewSizeX(fFullViewSizeX * rVisiblePart.getWidth());
 642             const double fViewSizeY(fFullViewSizeY * rVisiblePart.getHeight());
 643
 644             // generate RasterWidth and RasterHeight
 645             const sal_uInt32 nRasterWidth((sal_uInt32)basegfx::fround(fViewSizeX) + 1);
 646             const sal_uInt32 nRasterHeight((sal_uInt32)basegfx::fround(fViewSizeY) + 1);
 647
 648             if(nRasterWidth && nRasterHeight)
 649             {
 650                 // create view unit buffer
 651                 mpBZPixelRaster = new basegfx::BZPixelRaster(
 652                     mnAntiAlialize ? nRasterWidth * mnAntiAlialize : nRasterWidth,
 653                     mnAntiAlialize ? nRasterHeight * mnAntiAlialize : nRasterHeight);
 654                 OSL_ENSURE(mpBZPixelRaster, "ZBufferProcessor3D: Could not allocate basegfx::BZPixelRaster (!)");
 655
 656                 // create DeviceToView for Z-Buffer renderer since Z is handled
 657                 // different from standard 3D transformations (Z is mirrored). Also
 658                 // the transformation includes the step from unit device coordinates
 659                 // to discrete units ([-1.0 .. 1.0] -> [minDiscrete .. maxDiscrete]
 660
 661                 basegfx::B3DHomMatrix aDeviceToView;
 662
 663                 {
 664                     // step one:
 665                     //
 666                     // bring from [-1.0 .. 1.0] in X,Y and Z to [0.0 .. 1.0]. Also
 667                     // necessary to
 668                     // - flip Y due to screen orientation
 669                     // - flip Z due to Z-Buffer orientation from back to front
 670
 671                     aDeviceToView.scale(0.5, -0.5, -0.5);
 672                     aDeviceToView.translate(0.5, 0.5, 0.5);
 673                 }
 674
 675                 {
 676                     // step two:
 677                     //
 678                     // bring from [0.0 .. 1.0] in X,Y and Z to view cordinates
 679                     //
 680                     // #i102611#
 681                     // also: scale Z to [1.5 .. 65534.5]. Normally, a range of [0.0 .. 65535.0]
 682                     // could be used, but a 'unused' value is needed, so '0' is used what reduces
 683                     // the range to [1.0 .. 65535.0]. It has also shown that small numerical errors
 684                     // (smaller as basegfx::fTools::mfSmallValue, which is 0.000000001) happen.
 685                     // Instead of checking those by basegfx::fTools methods which would cost
 686                     // runtime, just add another 0.5 tolerance to the start and end of the Z-Buffer
 687                     // range, thus resulting in [1.5 .. 65534.5]
 688                     const double fMaxZDepth(65533.0);
 689                     aDeviceToView.translate(-rVisiblePart.getMinX(), -rVisiblePart.getMinY(), 0.0);
 690
 691                     if(mnAntiAlialize)
 692                         aDeviceToView.scale(fFullViewSizeX * mnAntiAlialize, fFullViewSizeY * mnAntiAlialize, fMaxZDepth);
 693                     else
 694                         aDeviceToView.scale(fFullViewSizeX, fFullViewSizeY, fMaxZDepth);
 695
 696                     aDeviceToView.translate(0.0, 0.0, 1.5);
 697                 }
 698
 699                 // update local ViewInformation3D with own DeviceToView
 700                 const geometry::ViewInformation3D aNewViewInformation3D(
 701                     getViewInformation3D().getObjectTransformation(),
 702                     getViewInformation3D().getOrientation(),
 703                     getViewInformation3D().getProjection(),
 704                     aDeviceToView,
 705                     getViewInformation3D().getViewTime(),
 706                     getViewInformation3D().getExtendedInformationSequence());
 707                 updateViewInformation(aNewViewInformation3D);
 708
 709                 // prepare inverse EyeToView transformation. This can be done in constructor
 710                 // since changes in object transformations when processing TransformPrimitive3Ds
 711                 // do not influence this prepared partial transformation
 712                 maInvEyeToView = getViewInformation3D().getDeviceToView() * getViewInformation3D().getProjection();
 713                 maInvEyeToView.invert();
 714
 715                 // prepare maRasterRange
 716                 maRasterRange.reset();
 717                 maRasterRange.expand(basegfx::B2DPoint(0.0, 0.0));
 718                 maRasterRange.expand(basegfx::B2DPoint(mpBZPixelRaster->getWidth(), mpBZPixelRaster->getHeight()));
 719
 720                 // create the raster converter
 721                 mpZBufferRasterConverter3D = new ZBufferRasterConverter3D(*mpBZPixelRaster, *this);
 722             }
 723         }
 724
 725         ZBufferProcessor3D::~ZBufferProcessor3D()
 726         {
 727             if(mpBZPixelRaster)
 728             {
 729                 delete mpZBufferRasterConverter3D;
 730                 delete mpBZPixelRaster;
 731             }
 732         }
 733
 734         BitmapEx ZBufferProcessor3D::getBitmapEx() const
 735         {
 736             if(mpBZPixelRaster)
 737             {
 738                 return BPixelRasterToBitmapEx(*mpBZPixelRaster, mnAntiAlialize);
 739             }
 740
 741             return BitmapEx();
 742         }
 743     } // end of namespace processor3d
 744 } // end of namespace drawinglayer
 745
 746 //////////////////////////////////////////////////////////////////////////////
 747 // eof