| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_drawinglayer.hxx" |
| |
| #include <drawinglayer/processor3d/defaultprocessor3d.hxx> |
| #include <drawinglayer/primitive3d/textureprimitive3d.hxx> |
| #include <drawinglayer/texture/texture.hxx> |
| #include <drawinglayer/texture/texture3d.hxx> |
| #include <drawinglayer/primitive3d/hatchtextureprimitive3d.hxx> |
| #include <drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx> |
| #include <drawinglayer/primitive3d/polygonprimitive3d.hxx> |
| #include <basegfx/polygon/b3dpolygontools.hxx> |
| #include <drawinglayer/attribute/materialattribute3d.hxx> |
| #include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx> |
| #include <basegfx/polygon/b3dpolypolygontools.hxx> |
| #include <com/sun/star/drawing/ShadeMode.hpp> |
| #include <drawinglayer/primitive3d/transformprimitive3d.hxx> |
| #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx> |
| #include <vcl/bitmapex.hxx> |
| #include <drawinglayer/attribute/sdrsceneattribute3d.hxx> |
| #include <drawinglayer/attribute/sdrlightingattribute3d.hxx> |
| #include <vcl/graph.hxx> |
| #include <basegfx/matrix/b2dhommatrixtools.hxx> |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| using namespace com::sun::star; |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| namespace drawinglayer |
| { |
| namespace processor3d |
| { |
| void DefaultProcessor3D::impRenderGradientTexturePrimitive3D(const primitive3d::GradientTexturePrimitive3D& rPrimitive, bool bTransparence) |
| { |
| const primitive3d::Primitive3DSequence& rSubSequence = rPrimitive.getChildren(); |
| |
| if(rSubSequence.hasElements()) |
| { |
| // rescue values |
| const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate(); |
| const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter(); |
| const bool bOldSimpleTextureActive(getSimpleTextureActive()); |
| boost::shared_ptr< texture::GeoTexSvx > pOldTex = (bTransparence) ? mpTransparenceGeoTexSvx : mpGeoTexSvx; |
| |
| // create texture |
| const attribute::FillGradientAttribute& rFillGradient = rPrimitive.getGradient(); |
| const basegfx::B2DRange aOutlineRange(0.0, 0.0, rPrimitive.getTextureSize().getX(), rPrimitive.getTextureSize().getY()); |
| const attribute::GradientStyle aGradientStyle(rFillGradient.getStyle()); |
| sal_uInt32 nSteps(rFillGradient.getSteps()); |
| const basegfx::BColor aStart(rFillGradient.getStartColor()); |
| const basegfx::BColor aEnd(rFillGradient.getEndColor()); |
| const sal_uInt32 nMaxSteps(sal_uInt32((aStart.getMaximumDistance(aEnd) * 127.5) + 0.5)); |
| boost::shared_ptr< texture::GeoTexSvx > pNewTex; |
| |
| if(nMaxSteps) |
| { |
| // there IS a color distance |
| if(nSteps == 0L) |
| { |
| nSteps = nMaxSteps; |
| } |
| |
| if(nSteps < 2L) |
| { |
| nSteps = 2L; |
| } |
| |
| if(nSteps > nMaxSteps) |
| { |
| nSteps = nMaxSteps; |
| } |
| |
| switch(aGradientStyle) |
| { |
| case attribute::GRADIENTSTYLE_LINEAR: |
| { |
| pNewTex.reset( |
| new texture::GeoTexSvxGradientLinear( |
| aOutlineRange, |
| aOutlineRange, |
| aStart, |
| aEnd, |
| nSteps, |
| rFillGradient.getBorder(), |
| rFillGradient.getAngle())); |
| break; |
| } |
| case attribute::GRADIENTSTYLE_AXIAL: |
| { |
| pNewTex.reset( |
| new texture::GeoTexSvxGradientAxial( |
| aOutlineRange, |
| aOutlineRange, |
| aStart, |
| aEnd, |
| nSteps, |
| rFillGradient.getBorder(), |
| rFillGradient.getAngle())); |
| break; |
| } |
| case attribute::GRADIENTSTYLE_RADIAL: |
| { |
| pNewTex.reset( |
| new texture::GeoTexSvxGradientRadial( |
| aOutlineRange, |
| aStart, |
| aEnd, |
| nSteps, |
| rFillGradient.getBorder(), |
| rFillGradient.getOffsetX(), |
| rFillGradient.getOffsetY())); |
| break; |
| } |
| case attribute::GRADIENTSTYLE_ELLIPTICAL: |
| { |
| pNewTex.reset( |
| new texture::GeoTexSvxGradientElliptical( |
| aOutlineRange, |
| aStart, |
| aEnd, |
| nSteps, |
| rFillGradient.getBorder(), |
| rFillGradient.getOffsetX(), |
| rFillGradient.getOffsetY(), |
| rFillGradient.getAngle())); |
| break; |
| } |
| case attribute::GRADIENTSTYLE_SQUARE: |
| { |
| pNewTex.reset( |
| new texture::GeoTexSvxGradientSquare( |
| aOutlineRange, |
| aStart, |
| aEnd, |
| nSteps, |
| rFillGradient.getBorder(), |
| rFillGradient.getOffsetX(), |
| rFillGradient.getOffsetY(), |
| rFillGradient.getAngle())); |
| break; |
| } |
| case attribute::GRADIENTSTYLE_RECT: |
| { |
| pNewTex.reset( |
| new texture::GeoTexSvxGradientRect( |
| aOutlineRange, |
| aStart, |
| aEnd, |
| nSteps, |
| rFillGradient.getBorder(), |
| rFillGradient.getOffsetX(), |
| rFillGradient.getOffsetY(), |
| rFillGradient.getAngle())); |
| break; |
| } |
| } |
| |
| mbSimpleTextureActive = false; |
| } |
| else |
| { |
| // no color distance -> same color, use simple texture |
| pNewTex.reset(new texture::GeoTexSvxMono(aStart, 1.0 - aStart.luminance())); |
| mbSimpleTextureActive = true; |
| } |
| |
| // set created texture |
| if(bTransparence) |
| { |
| mpTransparenceGeoTexSvx = pNewTex; |
| } |
| else |
| { |
| mpGeoTexSvx = pNewTex; |
| } |
| |
| // process sub-list |
| process(rSubSequence); |
| |
| // restore values |
| mbModulate = bOldModulate; |
| mbFilter = bOldFilter; |
| mbSimpleTextureActive = bOldSimpleTextureActive; |
| |
| if(bTransparence) |
| { |
| mpTransparenceGeoTexSvx = pOldTex; |
| } |
| else |
| { |
| mpGeoTexSvx = pOldTex; |
| } |
| } |
| } |
| |
| void DefaultProcessor3D::impRenderHatchTexturePrimitive3D(const primitive3d::HatchTexturePrimitive3D& rPrimitive) |
| { |
| const primitive3d::Primitive3DSequence& rSubSequence = rPrimitive.getChildren(); |
| |
| if(rSubSequence.hasElements()) |
| { |
| // rescue values |
| const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate(); |
| const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter(); |
| boost::shared_ptr< texture::GeoTexSvx > pOldTex = mpGeoTexSvx; |
| |
| // calculate logic pixel size in object coordinates. Create transformation view |
| // to object by inverting ObjectToView |
| basegfx::B3DHomMatrix aInvObjectToView(getViewInformation3D().getObjectToView()); |
| aInvObjectToView.invert(); |
| |
| // back-project discrete coordinates to object coordinates and extract |
| // maximum distance |
| const basegfx::B3DPoint aZero(aInvObjectToView * basegfx::B3DPoint(0.0, 0.0, 0.0)); |
| const basegfx::B3DPoint aOne(aInvObjectToView * basegfx::B3DPoint(1.0, 1.0, 1.0)); |
| const basegfx::B3DVector aLogicPixel(aOne - aZero); |
| double fLogicPixelSizeWorld(::std::max(::std::max(fabs(aLogicPixel.getX()), fabs(aLogicPixel.getY())), fabs(aLogicPixel.getZ()))); |
| |
| // calculate logic pixel size in texture coordinates |
| const double fLogicTexSizeX(fLogicPixelSizeWorld / rPrimitive.getTextureSize().getX()); |
| const double fLogicTexSizeY(fLogicPixelSizeWorld / rPrimitive.getTextureSize().getY()); |
| const double fLogicTexSize(fLogicTexSizeX > fLogicTexSizeY ? fLogicTexSizeX : fLogicTexSizeY); |
| |
| // create texture and set |
| mpGeoTexSvx.reset(new texture::GeoTexSvxMultiHatch(rPrimitive, fLogicTexSize)); |
| |
| // process sub-list |
| process(rSubSequence); |
| |
| // restore values |
| mbModulate = bOldModulate; |
| mbFilter = bOldFilter; |
| mpGeoTexSvx = pOldTex; |
| } |
| } |
| |
| void DefaultProcessor3D::impRenderBitmapTexturePrimitive3D(const primitive3d::BitmapTexturePrimitive3D& rPrimitive) |
| { |
| const primitive3d::Primitive3DSequence& rSubSequence = rPrimitive.getChildren(); |
| |
| if(rSubSequence.hasElements()) |
| { |
| // rescue values |
| const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate(); |
| const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter(); |
| boost::shared_ptr< texture::GeoTexSvx > pOldTex = mpGeoTexSvx; |
| |
| // create texture |
| const attribute::FillGraphicAttribute& rFillGraphicAttribute = rPrimitive.getFillGraphicAttribute(); |
| |
| // #121194# For 3D texture we will use the BitmapRex representation |
| const BitmapEx aBitmapEx(rFillGraphicAttribute.getGraphic().GetBitmapEx()); |
| |
| // create range scaled by texture size |
| basegfx::B2DRange aGraphicRange(rFillGraphicAttribute.getGraphicRange()); |
| |
| aGraphicRange.transform( |
| basegfx::tools::createScaleB2DHomMatrix( |
| rPrimitive.getTextureSize())); |
| |
| if(rFillGraphicAttribute.getTiling()) |
| { |
| mpGeoTexSvx.reset( |
| new texture::GeoTexSvxBitmapExTiled( |
| aBitmapEx, |
| aGraphicRange, |
| rFillGraphicAttribute.getOffsetX(), |
| rFillGraphicAttribute.getOffsetY())); |
| } |
| else |
| { |
| mpGeoTexSvx.reset( |
| new texture::GeoTexSvxBitmapEx( |
| aBitmapEx, |
| aGraphicRange)); |
| } |
| |
| // process sub-list |
| process(rSubSequence); |
| |
| // restore values |
| mbModulate = bOldModulate; |
| mbFilter = bOldFilter; |
| mpGeoTexSvx = pOldTex; |
| } |
| } |
| |
| void DefaultProcessor3D::impRenderModifiedColorPrimitive3D(const primitive3d::ModifiedColorPrimitive3D& rModifiedCandidate) |
| { |
| const primitive3d::Primitive3DSequence& rSubSequence = rModifiedCandidate.getChildren(); |
| |
| if(rSubSequence.hasElements()) |
| { |
| // put modifier on stack |
| maBColorModifierStack.push(rModifiedCandidate.getColorModifier()); |
| |
| // process sub-list |
| process(rModifiedCandidate.getChildren()); |
| |
| // remove modifier from stack |
| maBColorModifierStack.pop(); |
| } |
| } |
| |
| void DefaultProcessor3D::impRenderPolygonHairlinePrimitive3D(const primitive3d::PolygonHairlinePrimitive3D& rPrimitive) |
| { |
| basegfx::B3DPolygon aHairline(rPrimitive.getB3DPolygon()); |
| |
| if(aHairline.count()) |
| { |
| // hairlines need no extra data, clear it |
| aHairline.clearTextureCoordinates(); |
| aHairline.clearNormals(); |
| aHairline.clearBColors(); |
| |
| // transform to device coordinates (-1.0 .. 1.0) and check for visibility |
| aHairline.transform(getViewInformation3D().getObjectToView()); |
| const basegfx::B3DRange a3DRange(basegfx::tools::getRange(aHairline)); |
| const basegfx::B2DRange a2DRange(a3DRange.getMinX(), a3DRange.getMinY(), a3DRange.getMaxX(), a3DRange.getMaxY()); |
| |
| if(a2DRange.overlaps(maRasterRange)) |
| { |
| const attribute::MaterialAttribute3D aMaterial(maBColorModifierStack.getModifiedColor(rPrimitive.getBColor())); |
| |
| rasterconvertB3DPolygon(aMaterial, aHairline); |
| } |
| } |
| } |
| |
| void DefaultProcessor3D::impRenderPolyPolygonMaterialPrimitive3D(const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive) |
| { |
| basegfx::B3DPolyPolygon aFill(rPrimitive.getB3DPolyPolygon()); |
| basegfx::BColor aObjectColor(rPrimitive.getMaterial().getColor()); |
| bool bPaintIt(aFill.count()); |
| |
| // #i98295# get ShadeMode. Correct early when only flat is possible due to missing normals |
| const ::com::sun::star::drawing::ShadeMode aShadeMode( |
| aFill.areNormalsUsed() ? |
| getSdrSceneAttribute().getShadeMode() : ::com::sun::star::drawing::ShadeMode_FLAT); |
| |
| if(bPaintIt) |
| { |
| // get rid of texture coordinates if there is no texture |
| if(aFill.areTextureCoordinatesUsed() && !getGeoTexSvx().get() && !getTransparenceGeoTexSvx().get()) |
| { |
| aFill.clearTextureCoordinates(); |
| } |
| |
| // #i98295# get rid of normals and color early when not needed |
| if(::com::sun::star::drawing::ShadeMode_FLAT == aShadeMode) |
| { |
| aFill.clearNormals(); |
| aFill.clearBColors(); |
| } |
| |
| // transform to device coordinates (-1.0 .. 1.0) and check for visibility |
| aFill.transform(getViewInformation3D().getObjectToView()); |
| const basegfx::B3DRange a3DRange(basegfx::tools::getRange(aFill)); |
| const basegfx::B2DRange a2DRange(a3DRange.getMinX(), a3DRange.getMinY(), a3DRange.getMaxX(), a3DRange.getMaxY()); |
| |
| bPaintIt = a2DRange.overlaps(maRasterRange); |
| } |
| |
| // check if it shall be painted regarding hiding of normals (backface culling) |
| if(bPaintIt && !rPrimitive.getDoubleSided()) |
| { |
| // get plane normal of polygon in view coordinates (with ZBuffer values), |
| // left-handed coordinate system |
| const basegfx::B3DVector aPlaneNormal(aFill.getB3DPolygon(0L).getNormal()); |
| |
| if(aPlaneNormal.getZ() > 0.0) |
| { |
| bPaintIt = false; |
| } |
| } |
| |
| if(bPaintIt) |
| { |
| // prepare ObjectToEye in NormalTransform |
| basegfx::B3DHomMatrix aNormalTransform(getViewInformation3D().getOrientation() * getViewInformation3D().getObjectTransformation()); |
| |
| if(getSdrSceneAttribute().getTwoSidedLighting()) |
| { |
| // get plane normal of polygon in view coordinates (with ZBuffer values), |
| // left-handed coordinate system |
| const basegfx::B3DVector aPlaneNormal(aFill.getB3DPolygon(0L).getNormal()); |
| |
| if(aPlaneNormal.getZ() > 0.0) |
| { |
| // mirror normals |
| aNormalTransform.scale(-1.0, -1.0, -1.0); |
| } |
| } |
| |
| switch(aShadeMode) |
| { |
| case ::com::sun::star::drawing::ShadeMode_PHONG: |
| { |
| // phong shading. Transform normals to eye coor |
| aFill.transformNormals(aNormalTransform); |
| break; |
| } |
| case ::com::sun::star::drawing::ShadeMode_SMOOTH: |
| { |
| // gouraud shading. Transform normals to eye coor |
| aFill.transformNormals(aNormalTransform); |
| |
| // prepare color model parameters, evtl. use blend color |
| const basegfx::BColor aColor(getModulate() ? basegfx::BColor(1.0, 1.0, 1.0) : rPrimitive.getMaterial().getColor()); |
| const basegfx::BColor& rSpecular(rPrimitive.getMaterial().getSpecular()); |
| const basegfx::BColor& rEmission(rPrimitive.getMaterial().getEmission()); |
| const sal_uInt16 nSpecularIntensity(rPrimitive.getMaterial().getSpecularIntensity()); |
| |
| // solve color model for each normal vector, set colors at points. Clear normals. |
| for(sal_uInt32 a(0L); a < aFill.count(); a++) |
| { |
| basegfx::B3DPolygon aPartFill(aFill.getB3DPolygon(a)); |
| |
| for(sal_uInt32 b(0L); b < aPartFill.count(); b++) |
| { |
| // solve color model. Transform normal to eye coor |
| const basegfx::B3DVector aNormal(aPartFill.getNormal(b)); |
| const basegfx::BColor aSolvedColor(getSdrLightingAttribute().solveColorModel(aNormal, aColor, rSpecular, rEmission, nSpecularIntensity)); |
| aPartFill.setBColor(b, aSolvedColor); |
| } |
| |
| // clear normals on this part polygon and write it back |
| aPartFill.clearNormals(); |
| aFill.setB3DPolygon(a, aPartFill); |
| } |
| break; |
| } |
| case ::com::sun::star::drawing::ShadeMode_FLAT: |
| { |
| // flat shading. Get plane vector in eye coordinates |
| const basegfx::B3DVector aPlaneEyeNormal(aNormalTransform * rPrimitive.getB3DPolyPolygon().getB3DPolygon(0L).getNormal()); |
| |
| // prepare color model parameters, evtl. use blend color |
| const basegfx::BColor aColor(getModulate() ? basegfx::BColor(1.0, 1.0, 1.0) : rPrimitive.getMaterial().getColor()); |
| const basegfx::BColor& rSpecular(rPrimitive.getMaterial().getSpecular()); |
| const basegfx::BColor& rEmission(rPrimitive.getMaterial().getEmission()); |
| const sal_uInt16 nSpecularIntensity(rPrimitive.getMaterial().getSpecularIntensity()); |
| |
| // solve color model for plane vector and use that color for whole plane |
| aObjectColor = getSdrLightingAttribute().solveColorModel(aPlaneEyeNormal, aColor, rSpecular, rEmission, nSpecularIntensity); |
| break; |
| } |
| default: // case ::com::sun::star::drawing::ShadeMode_DRAFT: |
| { |
| // draft, just use object color which is already set. Delete all other infos |
| aFill.clearNormals(); |
| aFill.clearBColors(); |
| break; |
| } |
| } |
| |
| // draw it to ZBuffer |
| const attribute::MaterialAttribute3D aMaterial( |
| maBColorModifierStack.getModifiedColor(aObjectColor), |
| rPrimitive.getMaterial().getSpecular(), |
| rPrimitive.getMaterial().getEmission(), |
| rPrimitive.getMaterial().getSpecularIntensity()); |
| |
| rasterconvertB3DPolyPolygon(aMaterial, aFill); |
| } |
| } |
| |
| void DefaultProcessor3D::impRenderTransformPrimitive3D(const primitive3d::TransformPrimitive3D& rTransformCandidate) |
| { |
| // transform group. Remember current transformations |
| const geometry::ViewInformation3D aLastViewInformation3D(getViewInformation3D()); |
| |
| // create new transformation; add new object transform from right side |
| const geometry::ViewInformation3D aNewViewInformation3D( |
| aLastViewInformation3D.getObjectTransformation() * rTransformCandidate.getTransformation(), |
| aLastViewInformation3D.getOrientation(), |
| aLastViewInformation3D.getProjection(), |
| aLastViewInformation3D.getDeviceToView(), |
| aLastViewInformation3D.getViewTime(), |
| aLastViewInformation3D.getExtendedInformationSequence()); |
| updateViewInformation(aNewViewInformation3D); |
| |
| // let break down recursively |
| process(rTransformCandidate.getChildren()); |
| |
| // restore transformations |
| updateViewInformation(aLastViewInformation3D); |
| } |
| |
| void DefaultProcessor3D::processBasePrimitive3D(const primitive3d::BasePrimitive3D& rBasePrimitive) |
| { |
| // it is a BasePrimitive3D implementation, use getPrimitive3DID() call for switch |
| switch(rBasePrimitive.getPrimitive3DID()) |
| { |
| case PRIMITIVE3D_ID_GRADIENTTEXTUREPRIMITIVE3D : |
| { |
| // GradientTexturePrimitive3D |
| const primitive3d::GradientTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::GradientTexturePrimitive3D& >(rBasePrimitive); |
| impRenderGradientTexturePrimitive3D(rPrimitive, false); |
| break; |
| } |
| case PRIMITIVE3D_ID_HATCHTEXTUREPRIMITIVE3D : |
| { |
| // HatchTexturePrimitive3D |
| static bool bDoHatchDecomposition(false); |
| |
| if(bDoHatchDecomposition) |
| { |
| // let break down |
| process(rBasePrimitive.get3DDecomposition(getViewInformation3D())); |
| } |
| else |
| { |
| // hatchTexturePrimitive3D |
| const primitive3d::HatchTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::HatchTexturePrimitive3D& >(rBasePrimitive); |
| impRenderHatchTexturePrimitive3D(rPrimitive); |
| } |
| break; |
| } |
| case PRIMITIVE3D_ID_BITMAPTEXTUREPRIMITIVE3D : |
| { |
| // BitmapTexturePrimitive3D |
| const primitive3d::BitmapTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::BitmapTexturePrimitive3D& >(rBasePrimitive); |
| impRenderBitmapTexturePrimitive3D(rPrimitive); |
| break; |
| } |
| case PRIMITIVE3D_ID_TRANSPARENCETEXTUREPRIMITIVE3D : |
| { |
| // TransparenceTexturePrimitive3D |
| const primitive3d::TransparenceTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::TransparenceTexturePrimitive3D& >(rBasePrimitive); |
| mnTransparenceCounter++; |
| impRenderGradientTexturePrimitive3D(rPrimitive, true); |
| mnTransparenceCounter--; |
| break; |
| } |
| case PRIMITIVE3D_ID_MODIFIEDCOLORPRIMITIVE3D : |
| { |
| // ModifiedColorPrimitive3D |
| // Force output to unified color. |
| const primitive3d::ModifiedColorPrimitive3D& rPrimitive = static_cast< const primitive3d::ModifiedColorPrimitive3D& >(rBasePrimitive); |
| impRenderModifiedColorPrimitive3D(rPrimitive); |
| break; |
| } |
| case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D : |
| { |
| // directdraw of PolygonHairlinePrimitive3D |
| const primitive3d::PolygonHairlinePrimitive3D& rPrimitive = static_cast< const primitive3d::PolygonHairlinePrimitive3D& >(rBasePrimitive); |
| impRenderPolygonHairlinePrimitive3D(rPrimitive); |
| break; |
| } |
| case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D : |
| { |
| // directdraw of PolyPolygonMaterialPrimitive3D |
| const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const primitive3d::PolyPolygonMaterialPrimitive3D& >(rBasePrimitive); |
| impRenderPolyPolygonMaterialPrimitive3D(rPrimitive); |
| break; |
| } |
| case PRIMITIVE3D_ID_TRANSFORMPRIMITIVE3D : |
| { |
| // transform group (TransformPrimitive3D) |
| impRenderTransformPrimitive3D(static_cast< const primitive3d::TransformPrimitive3D& >(rBasePrimitive)); |
| break; |
| } |
| default: |
| { |
| // process recursively |
| process(rBasePrimitive.get3DDecomposition(getViewInformation3D())); |
| break; |
| } |
| } |
| } |
| |
| DefaultProcessor3D::DefaultProcessor3D( |
| const geometry::ViewInformation3D& rViewInformation, |
| const attribute::SdrSceneAttribute& rSdrSceneAttribute, |
| const attribute::SdrLightingAttribute& rSdrLightingAttribute) |
| : BaseProcessor3D(rViewInformation), |
| mrSdrSceneAttribute(rSdrSceneAttribute), |
| mrSdrLightingAttribute(rSdrLightingAttribute), |
| maRasterRange(), |
| maBColorModifierStack(), |
| mpGeoTexSvx(), |
| mpTransparenceGeoTexSvx(), |
| maDrawinglayerOpt(), |
| mnTransparenceCounter(0), |
| mbModulate(false), |
| mbFilter(false), |
| mbSimpleTextureActive(false) |
| { |
| // a derivation has to set maRasterRange which is used in the basic render methods. |
| // Setting to default here ([0.0 .. 1.0] in X,Y) to avoid problems |
| maRasterRange.expand(basegfx::B2DTuple(0.0, 0.0)); |
| maRasterRange.expand(basegfx::B2DTuple(1.0, 1.0)); |
| } |
| |
| DefaultProcessor3D::~DefaultProcessor3D() |
| { |
| } |
| } // end of namespace processor3d |
| } // end of namespace drawinglayer |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // eof |