drawinglayer/source/processor3d/defaultprocessor3d.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: defaultprocessor3d.cxx,v $
   6  *
   7  *  $Revision: 1.13 $
   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/defaultprocessor3d.hxx>
  40 #include <drawinglayer/primitive3d/textureprimitive3d.hxx>
  41 #include <drawinglayer/texture/texture.hxx>
  42 #include <drawinglayer/texture/texture3d.hxx>
  43 #include <drawinglayer/primitive3d/hatchtextureprimitive3d.hxx>
  44 #include <drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx>
  45 #include <drawinglayer/primitive3d/polygonprimitive3d.hxx>
  46 #include <basegfx/polygon/b3dpolygontools.hxx>
  47 #include <drawinglayer/attribute/materialattribute3d.hxx>
  48 #include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
  49 #include <basegfx/polygon/b3dpolypolygontools.hxx>
  50 #include <com/sun/star/drawing/ShadeMode.hpp>
  51 #include <drawinglayer/attribute/sdrattribute3d.hxx>
  52 #include <drawinglayer/primitive3d/transformprimitive3d.hxx>
  53 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
  54
  55 //////////////////////////////////////////////////////////////////////////////
  56
  57 using namespace com::sun::star;
  58
  59 //////////////////////////////////////////////////////////////////////////////
  60
  61 namespace drawinglayer
  62 {
  63     namespace processor3d
  64     {
  65         void DefaultProcessor3D::impRenderGradientTexturePrimitive3D(const primitive3d::GradientTexturePrimitive3D& rPrimitive, bool bTransparence)
  66         {
  67             const primitive3d::Primitive3DSequence& rSubSequence = rPrimitive.getChildren();
  68
  69             if(rSubSequence.hasElements())
  70             {
  71                 // rescue values
  72                 const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate();
  73                 const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter();
  74                 const bool bOldSimpleTextureActive(mbSimpleTextureActive);
  75                 texture::GeoTexSvx* pOldTex = (bTransparence) ? mpTransparenceGeoTexSvx : mpGeoTexSvx;
  76
  77                 // create texture
  78                 const attribute::FillGradientAttribute& rFillGradient = rPrimitive.getGradient();
  79                 const basegfx::B2DRange aOutlineRange(0.0, 0.0, rPrimitive.getTextureSize().getX(), rPrimitive.getTextureSize().getY());
  80                 const attribute::GradientStyle aGradientStyle(rFillGradient.getStyle());
  81                 sal_uInt32 nSteps(rFillGradient.getSteps());
  82                 const basegfx::BColor aStart(rFillGradient.getStartColor());
  83                 const basegfx::BColor aEnd(rFillGradient.getEndColor());
  84                 const sal_uInt32 nMaxSteps(sal_uInt32((aStart.getMaximumDistance(aEnd) * 127.5) + 0.5));
  85                 texture::GeoTexSvx* pNewTex = 0L;
  86
  87                 if(nMaxSteps)
  88                 {
  89                     // there IS a color distance
  90                     if(nSteps == 0L)
  91                     {
  92                         nSteps = nMaxSteps;
  93                     }
  94
  95                     if(nSteps < 2L)
  96                     {
  97                         nSteps = 2L;
  98                     }
  99
 100                     if(nSteps > nMaxSteps)
 101                     {
 102                         nSteps = nMaxSteps;
 103                     }
 104
 105                     switch(aGradientStyle)
 106                     {
 107                         case attribute::GRADIENTSTYLE_LINEAR:
 108                         {
 109                             pNewTex = new texture::GeoTexSvxGradientLinear(aOutlineRange, aStart, aEnd, nSteps, rFillGradient.getBorder(), -rFillGradient.getAngle());
 110                             break;
 111                         }
 112                         case attribute::GRADIENTSTYLE_AXIAL:
 113                         {
 114                             pNewTex = new texture::GeoTexSvxGradientAxial(aOutlineRange, aStart, aEnd, nSteps, rFillGradient.getBorder(), -rFillGradient.getAngle());
 115                             break;
 116                         }
 117                         case attribute::GRADIENTSTYLE_RADIAL:
 118                         {
 119                             pNewTex = new texture::GeoTexSvxGradientRadial(aOutlineRange, aStart, aEnd, nSteps, rFillGradient.getBorder(), rFillGradient.getOffsetX(), rFillGradient.getOffsetY());
 120                             break;
 121                         }
 122                         case attribute::GRADIENTSTYLE_ELLIPTICAL:
 123                         {
 124                             pNewTex = new texture::GeoTexSvxGradientElliptical(aOutlineRange, aStart, aEnd, nSteps, rFillGradient.getBorder(), rFillGradient.getOffsetX(), rFillGradient.getOffsetY(), -rFillGradient.getAngle());
 125                             break;
 126                         }
 127                         case attribute::GRADIENTSTYLE_SQUARE:
 128                         {
 129                             pNewTex = new texture::GeoTexSvxGradientSquare(aOutlineRange, aStart, aEnd, nSteps, rFillGradient.getBorder(), rFillGradient.getOffsetX(), rFillGradient.getOffsetY(), -rFillGradient.getAngle());
 130                             break;
 131                         }
 132                         case attribute::GRADIENTSTYLE_RECT:
 133                         {
 134                             pNewTex = new texture::GeoTexSvxGradientRect(aOutlineRange, aStart, aEnd, nSteps, rFillGradient.getBorder(), rFillGradient.getOffsetX(), rFillGradient.getOffsetY(), -rFillGradient.getAngle());
 135                             break;
 136                         }
 137                     }
 138
 139                     mbSimpleTextureActive = false;
 140                 }
 141                 else
 142                 {
 143                     // no color distance -> same color, use simple texture
 144                     pNewTex = new texture::GeoTexSvxMono(aStart, 1.0 - aStart.luminance());
 145                     mbSimpleTextureActive = true;
 146                 }
 147
 148                 // set created texture
 149                 if(bTransparence)
 150                 {
 151                     mpTransparenceGeoTexSvx = pNewTex;
 152                 }
 153                 else
 154                 {
 155                     mpGeoTexSvx = pNewTex;
 156                 }
 157
 158                 // process sub-list
 159                 process(rSubSequence);
 160
 161                 // delete texture
 162                 delete pNewTex;
 163
 164                 // restore values
 165                 mbModulate = bOldModulate;
 166                 mbFilter = bOldFilter;
 167                 mbSimpleTextureActive = bOldSimpleTextureActive;
 168
 169                 if(bTransparence)
 170                 {
 171                     mpTransparenceGeoTexSvx = pOldTex;
 172                 }
 173                 else
 174                 {
 175                     mpGeoTexSvx = pOldTex;
 176                 }
 177             }
 178         }
 179
 180         void DefaultProcessor3D::impRenderHatchTexturePrimitive3D(const primitive3d::HatchTexturePrimitive3D& rPrimitive)
 181         {
 182             const primitive3d::Primitive3DSequence& rSubSequence = rPrimitive.getChildren();
 183
 184             if(rSubSequence.hasElements())
 185             {
 186                 // rescue values
 187                 const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate();
 188                 const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter();
 189                 texture::GeoTexSvx* pOldTex = mpGeoTexSvx;
 190
 191                 // calculate logic pixel size in object coordinates. Create transformation view
 192                 // to object by inverting ObjectToView
 193                 basegfx::B3DHomMatrix aInvObjectToView(getViewInformation3D().getObjectToView());
 194                 aInvObjectToView.invert();
 195
 196                 // back-project discrete coordinates to object coordinates and extract
 197                 // maximum distance
 198                 const basegfx::B3DPoint aZero(aInvObjectToView * basegfx::B3DPoint(0.0, 0.0, 0.0));
 199                 const basegfx::B3DPoint aOne(aInvObjectToView * basegfx::B3DPoint(1.0, 1.0, 1.0));
 200                 const basegfx::B3DVector aLogicPixel(aOne - aZero);
 201                 double fLogicPixelSizeWorld(::std::max(::std::max(fabs(aLogicPixel.getX()), fabs(aLogicPixel.getY())), fabs(aLogicPixel.getZ())));
 202
 203                 // calculate logic pixel size in texture coordinates
 204                 const double fLogicTexSizeX(fLogicPixelSizeWorld / rPrimitive.getTextureSize().getX());
 205                 const double fLogicTexSizeY(fLogicPixelSizeWorld / rPrimitive.getTextureSize().getY());
 206                 const double fLogicTexSize(fLogicTexSizeX > fLogicTexSizeY ? fLogicTexSizeX : fLogicTexSizeY);
 207
 208                 // create texture and set
 209                 texture::GeoTexSvxMultiHatch* pNewTex = new texture::GeoTexSvxMultiHatch(rPrimitive, fLogicTexSize);
 210                 mpGeoTexSvx = pNewTex;
 211
 212                 // process sub-list
 213                 process(rSubSequence);
 214
 215                 // delete texture
 216                 delete mpGeoTexSvx;
 217
 218                 // restore values
 219                 mbModulate = bOldModulate;
 220                 mbFilter = bOldFilter;
 221                 mpGeoTexSvx = pOldTex;
 222             }
 223         }
 224
 225         void DefaultProcessor3D::impRenderBitmapTexturePrimitive3D(const primitive3d::BitmapTexturePrimitive3D& rPrimitive)
 226         {
 227             const primitive3d::Primitive3DSequence& rSubSequence = rPrimitive.getChildren();
 228
 229             if(rSubSequence.hasElements())
 230             {
 231                 // rescue values
 232                 const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate();
 233                 const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter();
 234                 texture::GeoTexSvx* pOldTex = mpGeoTexSvx;
 235
 236                 // create texture
 237                 const attribute::FillBitmapAttribute& rFillBitmapAttribute = rPrimitive.getBitmap();
 238
 239                 if(rFillBitmapAttribute.getTiling())
 240                 {
 241                     mpGeoTexSvx = new texture::GeoTexSvxBitmapTiled(
 242                         rFillBitmapAttribute.getBitmap(),
 243                         rFillBitmapAttribute.getTopLeft() * rPrimitive.getTextureSize(),
 244                         rFillBitmapAttribute.getSize() * rPrimitive.getTextureSize());
 245                 }
 246                 else
 247                 {
 248                     mpGeoTexSvx = new texture::GeoTexSvxBitmap(
 249                         rFillBitmapAttribute.getBitmap(),
 250                         rFillBitmapAttribute.getTopLeft() * rPrimitive.getTextureSize(),
 251                         rFillBitmapAttribute.getSize() * rPrimitive.getTextureSize());
 252                 }
 253
 254                 // process sub-list
 255                 process(rSubSequence);
 256
 257                 // delete texture
 258                 delete mpGeoTexSvx;
 259
 260                 // restore values
 261                 mbModulate = bOldModulate;
 262                 mbFilter = bOldFilter;
 263                 mpGeoTexSvx = pOldTex;
 264             }
 265         }
 266
 267         void DefaultProcessor3D::impRenderModifiedColorPrimitive3D(const primitive3d::ModifiedColorPrimitive3D& rModifiedCandidate)
 268         {
 269             const primitive3d::Primitive3DSequence& rSubSequence = rModifiedCandidate.getChildren();
 270
 271             if(rSubSequence.hasElements())
 272             {
 273                 // put modifier on stack
 274                 maBColorModifierStack.push(rModifiedCandidate.getColorModifier());
 275
 276                 // process sub-list
 277                 process(rModifiedCandidate.getChildren());
 278
 279                 // remove modifier from stack
 280                 maBColorModifierStack.pop();
 281             }
 282         }
 283
 284         void DefaultProcessor3D::impRenderPolygonHairlinePrimitive3D(const primitive3d::PolygonHairlinePrimitive3D& rPrimitive)
 285         {
 286             basegfx::B3DPolygon aHairline(rPrimitive.getB3DPolygon());
 287
 288             if(aHairline.count())
 289             {
 290                 // hairlines need no extra data, clear it
 291                 aHairline.clearTextureCoordinates();
 292                 aHairline.clearNormals();
 293                 aHairline.clearBColors();
 294
 295                 // transform to device coordinates (-1.0 .. 1.0) and check for visibility
 296                 aHairline.transform(getViewInformation3D().getObjectToView());
 297                 const basegfx::B3DRange a3DRange(basegfx::tools::getRange(aHairline));
 298                 const basegfx::B2DRange a2DRange(a3DRange.getMinX(), a3DRange.getMinY(), a3DRange.getMaxX(), a3DRange.getMaxY());
 299
 300                 if(a2DRange.overlaps(maRasterRange))
 301                 {
 302                     const attribute::MaterialAttribute3D aMaterial(maBColorModifierStack.getModifiedColor(rPrimitive.getBColor()));
 303
 304                     rasterconvertB3DPolygon(aMaterial, aHairline);
 305                 }
 306             }
 307         }
 308
 309         void DefaultProcessor3D::impRenderPolyPolygonMaterialPrimitive3D(const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive)
 310         {
 311             basegfx::B3DPolyPolygon aFill(rPrimitive.getB3DPolyPolygon());
 312             basegfx::BColor aObjectColor(rPrimitive.getMaterial().getColor());
 313             bool bPaintIt(aFill.count());
 314
 315             // #i98295# get ShadeMode. Correct early when only flat is possible due to missing normals
 316             const ::com::sun::star::drawing::ShadeMode aShadeMode(
 317                 aFill.areNormalsUsed() ?
 318                     getSdrSceneAttribute().getShadeMode() : ::com::sun::star::drawing::ShadeMode_FLAT);
 319
 320             if(bPaintIt)
 321             {
 322                 // get rid of texture coordinates if there is no texture
 323                 if(aFill.areTextureCoordinatesUsed() && !getGeoTexSvx() && !getTransparenceGeoTexSvx())
 324                 {
 325                     aFill.clearTextureCoordinates();
 326                 }
 327
 328                 // #i98295# get rid of normals and color early when not needed
 329                 if(::com::sun::star::drawing::ShadeMode_FLAT == aShadeMode)
 330                 {
 331                     aFill.clearNormals();
 332                     aFill.clearBColors();
 333                 }
 334
 335                 // transform to device coordinates (-1.0 .. 1.0) and check for visibility
 336                 aFill.transform(getViewInformation3D().getObjectToView());
 337                 const basegfx::B3DRange a3DRange(basegfx::tools::getRange(aFill));
 338                 const basegfx::B2DRange a2DRange(a3DRange.getMinX(), a3DRange.getMinY(), a3DRange.getMaxX(), a3DRange.getMaxY());
 339
 340                 bPaintIt = a2DRange.overlaps(maRasterRange);
 341             }
 342
 343             // check if it shall be painted regarding hiding of normals (backface culling)
 344             if(bPaintIt && !rPrimitive.getDoubleSided())
 345             {
 346                 // get plane normal of polygon in view coordinates (with ZBuffer values),
 347                 // left-handed coordinate system
 348                 const basegfx::B3DVector aPlaneNormal(aFill.getB3DPolygon(0L).getNormal());
 349
 350                 if(aPlaneNormal.getZ() > 0.0)
 351                 {
 352                     bPaintIt = false;
 353                 }
 354             }
 355
 356             if(bPaintIt)
 357             {
 358                 // prepare ObjectToEye in NormalTransform
 359                 basegfx::B3DHomMatrix aNormalTransform(getViewInformation3D().getOrientation() * getViewInformation3D().getObjectTransformation());
 360
 361                 if(getSdrSceneAttribute().getTwoSidedLighting())
 362                 {
 363                     // get plane normal of polygon in view coordinates (with ZBuffer values),
 364                     // left-handed coordinate system
 365                     const basegfx::B3DVector aPlaneNormal(aFill.getB3DPolygon(0L).getNormal());
 366
 367                     if(aPlaneNormal.getZ() > 0.0)
 368                     {
 369                         // mirror normals
 370                         aNormalTransform.scale(-1.0, -1.0, -1.0);
 371                     }
 372                 }
 373
 374                 switch(aShadeMode)
 375                 {
 376                     case ::com::sun::star::drawing::ShadeMode_PHONG:
 377                     {
 378                         // phong shading. Transform normals to eye coor
 379                         aFill.transformNormals(aNormalTransform);
 380                         break;
 381                     }
 382                     case ::com::sun::star::drawing::ShadeMode_SMOOTH:
 383                     {
 384                         // gouraud shading. Transform normals to eye coor
 385                         aFill.transformNormals(aNormalTransform);
 386
 387                         // prepare color model parameters, evtl. use blend color
 388                         const basegfx::BColor aColor(getModulate() ? basegfx::BColor(1.0, 1.0, 1.0) : rPrimitive.getMaterial().getColor());
 389                         const basegfx::BColor& rSpecular(rPrimitive.getMaterial().getSpecular());
 390                         const basegfx::BColor& rEmission(rPrimitive.getMaterial().getEmission());
 391                         const sal_uInt16 nSpecularIntensity(rPrimitive.getMaterial().getSpecularIntensity());
 392
 393                         // solve color model for each normal vector, set colors at points. Clear normals.
 394                         for(sal_uInt32 a(0L); a < aFill.count(); a++)
 395                         {
 396                             basegfx::B3DPolygon aPartFill(aFill.getB3DPolygon(a));
 397
 398                             for(sal_uInt32 b(0L); b < aPartFill.count(); b++)
 399                             {
 400                                 // solve color model. Transform normal to eye coor
 401                                 const basegfx::B3DVector aNormal(aPartFill.getNormal(b));
 402                                 const basegfx::BColor aSolvedColor(getSdrLightingAttribute().solveColorModel(aNormal, aColor, rSpecular, rEmission, nSpecularIntensity));
 403                                 aPartFill.setBColor(b, aSolvedColor);
 404                             }
 405
 406                             // clear normals on this part polygon and write it back
 407                             aPartFill.clearNormals();
 408                             aFill.setB3DPolygon(a, aPartFill);
 409                         }
 410                         break;
 411                     }
 412                     case ::com::sun::star::drawing::ShadeMode_FLAT:
 413                     {
 414                         // flat shading. Get plane vector in eye coordinates
 415                         const basegfx::B3DVector aPlaneEyeNormal(aNormalTransform * rPrimitive.getB3DPolyPolygon().getB3DPolygon(0L).getNormal());
 416
 417                         // prepare color model parameters, evtl. use blend color
 418                         const basegfx::BColor aColor(getModulate() ? basegfx::BColor(1.0, 1.0, 1.0) : rPrimitive.getMaterial().getColor());
 419                         const basegfx::BColor& rSpecular(rPrimitive.getMaterial().getSpecular());
 420                         const basegfx::BColor& rEmission(rPrimitive.getMaterial().getEmission());
 421                         const sal_uInt16 nSpecularIntensity(rPrimitive.getMaterial().getSpecularIntensity());
 422
 423                         // solve color model for plane vector and use that color for whole plane
 424                         aObjectColor = getSdrLightingAttribute().solveColorModel(aPlaneEyeNormal, aColor, rSpecular, rEmission, nSpecularIntensity);
 425                         break;
 426                     }
 427                     default: // case ::com::sun::star::drawing::ShadeMode_DRAFT:
 428                     {
 429                         // draft, just use object color which is already set. Delete all other infos
 430                         aFill.clearNormals();
 431                         aFill.clearBColors();
 432                         break;
 433                     }
 434                 }
 435
 436                 // draw it to ZBuffer
 437                 const attribute::MaterialAttribute3D aMaterial(
 438                     maBColorModifierStack.getModifiedColor(aObjectColor),
 439                     rPrimitive.getMaterial().getSpecular(),
 440                     rPrimitive.getMaterial().getEmission(),
 441                     rPrimitive.getMaterial().getSpecularIntensity());
 442
 443                 rasterconvertB3DPolyPolygon(aMaterial, aFill);
 444             }
 445         }
 446
 447         void DefaultProcessor3D::impRenderTransformPrimitive3D(const primitive3d::TransformPrimitive3D& rTransformCandidate)
 448         {
 449             // transform group. Remember current transformations
 450             const geometry::ViewInformation3D aLastViewInformation3D(getViewInformation3D());
 451
 452             // create new transformation; add new object transform from right side
 453             const geometry::ViewInformation3D aNewViewInformation3D(
 454                 aLastViewInformation3D.getObjectTransformation() * rTransformCandidate.getTransformation(),
 455                 aLastViewInformation3D.getOrientation(),
 456                 aLastViewInformation3D.getProjection(),
 457                 aLastViewInformation3D.getDeviceToView(),
 458                 aLastViewInformation3D.getViewTime(),
 459                 aLastViewInformation3D.getExtendedInformationSequence());
 460             updateViewInformation(aNewViewInformation3D);
 461
 462             // let break down recursively
 463             process(rTransformCandidate.getChildren());
 464
 465             // restore transformations
 466             updateViewInformation(aLastViewInformation3D);
 467         }
 468
 469         void DefaultProcessor3D::processBasePrimitive3D(const primitive3d::BasePrimitive3D& rBasePrimitive)
 470         {
 471             // it is a BasePrimitive3D implementation, use getPrimitiveID() call for switch
 472             switch(rBasePrimitive.getPrimitiveID())
 473             {
 474                 case PRIMITIVE3D_ID_GRADIENTTEXTUREPRIMITIVE3D :
 475                 {
 476                     // GradientTexturePrimitive3D
 477                     const primitive3d::GradientTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::GradientTexturePrimitive3D& >(rBasePrimitive);
 478                     impRenderGradientTexturePrimitive3D(rPrimitive, false);
 479                     break;
 480                 }
 481                 case PRIMITIVE3D_ID_HATCHTEXTUREPRIMITIVE3D :
 482                 {
 483                     // HatchTexturePrimitive3D
 484                     static bool bDoHatchDecomposition(false);
 485
 486                     if(bDoHatchDecomposition)
 487                     {
 488                         // let break down
 489                         process(rBasePrimitive.get3DDecomposition(getViewInformation3D()));
 490                     }
 491                     else
 492                     {
 493                         // hatchTexturePrimitive3D
 494                         const primitive3d::HatchTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::HatchTexturePrimitive3D& >(rBasePrimitive);
 495                         impRenderHatchTexturePrimitive3D(rPrimitive);
 496                     }
 497                     break;
 498                 }
 499                 case PRIMITIVE3D_ID_BITMAPTEXTUREPRIMITIVE3D :
 500                 {
 501                     // BitmapTexturePrimitive3D
 502                     const primitive3d::BitmapTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::BitmapTexturePrimitive3D& >(rBasePrimitive);
 503                     impRenderBitmapTexturePrimitive3D(rPrimitive);
 504                     break;
 505                 }
 506                 case PRIMITIVE3D_ID_ALPHATEXTUREPRIMITIVE3D :
 507                 {
 508                     // AlphaTexturePrimitive3D
 509                     const primitive3d::AlphaTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::AlphaTexturePrimitive3D& >(rBasePrimitive);
 510                     impRenderGradientTexturePrimitive3D(rPrimitive, true);
 511                     break;
 512                 }
 513                 case PRIMITIVE3D_ID_MODIFIEDCOLORPRIMITIVE3D :
 514                 {
 515                     // ModifiedColorPrimitive3D
 516                     // Force output to unified color.
 517                     const primitive3d::ModifiedColorPrimitive3D& rPrimitive = static_cast< const primitive3d::ModifiedColorPrimitive3D& >(rBasePrimitive);
 518                     impRenderModifiedColorPrimitive3D(rPrimitive);
 519                     break;
 520                 }
 521                 case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D :
 522                 {
 523                     // directdraw of PolygonHairlinePrimitive3D
 524                     const primitive3d::PolygonHairlinePrimitive3D& rPrimitive = static_cast< const primitive3d::PolygonHairlinePrimitive3D& >(rBasePrimitive);
 525                     impRenderPolygonHairlinePrimitive3D(rPrimitive);
 526                     break;
 527                 }
 528                 case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D :
 529                 {
 530                     // directdraw of PolyPolygonMaterialPrimitive3D
 531                     const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const primitive3d::PolyPolygonMaterialPrimitive3D& >(rBasePrimitive);
 532                     impRenderPolyPolygonMaterialPrimitive3D(rPrimitive);
 533                     break;
 534                 }
 535                 case PRIMITIVE3D_ID_TRANSFORMPRIMITIVE3D :
 536                 {
 537                     // transform group (TransformPrimitive3D)
 538                     impRenderTransformPrimitive3D(static_cast< const primitive3d::TransformPrimitive3D& >(rBasePrimitive));
 539                     break;
 540                 }
 541                 default:
 542                 {
 543                     // process recursively
 544                     process(rBasePrimitive.get3DDecomposition(getViewInformation3D()));
 545                     break;
 546                 }
 547             }
 548         }
 549
 550         DefaultProcessor3D::DefaultProcessor3D(
 551             const geometry::ViewInformation3D& rViewInformation,
 552             const attribute::SdrSceneAttribute& rSdrSceneAttribute,
 553             const attribute::SdrLightingAttribute& rSdrLightingAttribute)
 554         :       BaseProcessor3D(rViewInformation),
 555             mrSdrSceneAttribute(rSdrSceneAttribute),
 556             mrSdrLightingAttribute(rSdrLightingAttribute),
 557             maRasterRange(),
 558             maBColorModifierStack(),
 559             mpGeoTexSvx(0),
 560             mpTransparenceGeoTexSvx(0),
 561             mbModulate(false),
 562             mbFilter(false),
 563             mbSimpleTextureActive(false)
 564         {
 565             // a derivation has to set maRasterRange which is used in the basic render methods.
 566             // Setting to default here ([0.0 .. 1.0] in X,Y) to avoid problems
 567             maRasterRange.expand(basegfx::B2DTuple(0.0, 0.0));
 568             maRasterRange.expand(basegfx::B2DTuple(1.0, 1.0));
 569         }
 570
 571         DefaultProcessor3D::~DefaultProcessor3D()
 572         {
 573         }
 574     } // end of namespace processor3d
 575 } // end of namespace drawinglayer
 576
 577 //////////////////////////////////////////////////////////////////////////////
 578 // eof