LCOV - code coverage report
Current view: top level - drawinglayer/source/processor3d - defaultprocessor3d.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 171 227 75.3 %
Date: 2015-06-13 12:38:46 Functions: 8 11 72.7 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11