/************************************************************** * * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include ////////////////////////////////////////////////////////////////////////////// using namespace com::sun::star; ////////////////////////////////////////////////////////////////////////////// namespace { BitmapEx BPixelRasterToBitmapEx(const basegfx::BPixelRaster& rRaster, sal_uInt16 mnAntiAlialize) { BitmapEx aRetval; const sal_uInt32 nWidth(mnAntiAlialize ? rRaster.getWidth()/mnAntiAlialize : rRaster.getWidth()); const sal_uInt32 nHeight(mnAntiAlialize ? rRaster.getHeight()/mnAntiAlialize : rRaster.getHeight()); if(nWidth && nHeight) { const Size aDestSize(nWidth, nHeight); sal_uInt8 nInitAlpha(255); Bitmap aContent(aDestSize, 24); AlphaMask aAlpha(aDestSize, &nInitAlpha); BitmapWriteAccess* pContent = aContent.AcquireWriteAccess(); BitmapWriteAccess* pAlpha = aAlpha.AcquireWriteAccess(); if(pContent && pAlpha) { if(mnAntiAlialize) { const sal_uInt16 nDivisor(mnAntiAlialize * mnAntiAlialize); for(sal_uInt32 y(0L); y < nHeight; y++) { for(sal_uInt32 x(0L); x < nWidth; x++) { sal_uInt16 nRed(0); sal_uInt16 nGreen(0); sal_uInt16 nBlue(0); sal_uInt16 nOpacity(0); sal_uInt32 nIndex(rRaster.getIndexFromXY(x * mnAntiAlialize, y * mnAntiAlialize)); for(sal_uInt32 c(0); c < mnAntiAlialize; c++) { for(sal_uInt32 d(0); d < mnAntiAlialize; d++) { const basegfx::BPixel& rPixel(rRaster.getBPixel(nIndex++)); nRed = nRed + rPixel.getRed(); nGreen = nGreen + rPixel.getGreen(); nBlue = nBlue + rPixel.getBlue(); nOpacity = nOpacity + rPixel.getOpacity(); } nIndex += rRaster.getWidth() - mnAntiAlialize; } nOpacity = nOpacity / nDivisor; if(nOpacity) { pContent->SetPixel(y, x, BitmapColor( (sal_uInt8)(nRed / nDivisor), (sal_uInt8)(nGreen / nDivisor), (sal_uInt8)(nBlue / nDivisor))); pAlpha->SetPixel(y, x, BitmapColor(255 - (sal_uInt8)nOpacity)); } } } } else { sal_uInt32 nIndex(0L); for(sal_uInt32 y(0L); y < nHeight; y++) { for(sal_uInt32 x(0L); x < nWidth; x++) { const basegfx::BPixel& rPixel(rRaster.getBPixel(nIndex++)); if(rPixel.getOpacity()) { pContent->SetPixel(y, x, BitmapColor(rPixel.getRed(), rPixel.getGreen(), rPixel.getBlue())); pAlpha->SetPixel(y, x, BitmapColor(255 - rPixel.getOpacity())); } } } } } delete pContent; delete pAlpha; aRetval = BitmapEx(aContent, aAlpha); // #i101811# set PrefMapMode and PrefSize at newly created Bitmap aRetval.SetPrefMapMode(MAP_PIXEL); aRetval.SetPrefSize(Size(nWidth, nHeight)); } return aRetval; } } // end of anonymous namespace ////////////////////////////////////////////////////////////////////////////// class ZBufferRasterConverter3D : public basegfx::RasterConverter3D { private: const drawinglayer::processor3d::DefaultProcessor3D& mrProcessor; basegfx::BZPixelRaster& mrBuffer; // interpolators for a single line span basegfx::ip_single maIntZ; basegfx::ip_triple maIntColor; basegfx::ip_triple maIntNormal; basegfx::ip_double maIntTexture; basegfx::ip_triple maIntInvTexture; // current material to use for ratsreconversion const drawinglayer::attribute::MaterialAttribute3D* mpCurrentMaterial; // bitfield // some boolean flags for line span interpolator usages unsigned mbModifyColor : 1; unsigned mbUseTex : 1; unsigned mbHasTexCoor : 1; unsigned mbHasInvTexCoor : 1; unsigned mbUseNrm : 1; unsigned mbUseCol : 1; void getTextureCoor(basegfx::B2DPoint& rTarget) const { if(mbHasTexCoor) { rTarget.setX(maIntTexture.getX().getVal()); rTarget.setY(maIntTexture.getY().getVal()); } else if(mbHasInvTexCoor) { const double fZFactor(maIntInvTexture.getZ().getVal()); const double fInvZFactor(basegfx::fTools::equalZero(fZFactor) ? 1.0 : 1.0 / fZFactor); rTarget.setX(maIntInvTexture.getX().getVal() * fInvZFactor); rTarget.setY(maIntInvTexture.getY().getVal() * fInvZFactor); } } void incrementLineSpanInterpolators(double fStep) { maIntZ.increment(fStep); if(mbUseTex) { if(mbHasTexCoor) { maIntTexture.increment(fStep); } else if(mbHasInvTexCoor) { maIntInvTexture.increment(fStep); } } if(mbUseNrm) { maIntNormal.increment(fStep); } if(mbUseCol) { maIntColor.increment(fStep); } } double decideColorAndOpacity(basegfx::BColor& rColor) { // init values with full opacity and material color OSL_ENSURE(0 != mpCurrentMaterial, "CurrentMaterial not set (!)"); double fOpacity(1.0); rColor = mpCurrentMaterial->getColor(); if(mbUseTex) { basegfx::B2DPoint aTexCoor(0.0, 0.0); getTextureCoor(aTexCoor); if(mrProcessor.getGeoTexSvx().get()) { // calc color in spot. This may also set to invisible already when // e.g. bitmap textures have transparent parts mrProcessor.getGeoTexSvx()->modifyBColor(aTexCoor, rColor, fOpacity); } if(basegfx::fTools::more(fOpacity, 0.0) && mrProcessor.getTransparenceGeoTexSvx().get()) { // calc opacity. Object has a 2nd texture, a transparence texture mrProcessor.getTransparenceGeoTexSvx()->modifyOpacity(aTexCoor, fOpacity); } } if(basegfx::fTools::more(fOpacity, 0.0)) { if(mrProcessor.getGeoTexSvx().get()) { if(mbUseNrm) { // blend texture with phong rColor = mrProcessor.getSdrLightingAttribute().solveColorModel( basegfx::B3DVector(maIntNormal.getX().getVal(), maIntNormal.getY().getVal(), maIntNormal.getZ().getVal()), rColor, mpCurrentMaterial->getSpecular(), mpCurrentMaterial->getEmission(), mpCurrentMaterial->getSpecularIntensity()); } else if(mbUseCol) { // blend texture with gouraud basegfx::BColor aBlendColor(maIntColor.getX().getVal(), maIntColor.getY().getVal(), maIntColor.getZ().getVal()); rColor *= aBlendColor; } else if(mrProcessor.getModulate()) { // blend texture with single material color rColor *= mpCurrentMaterial->getColor(); } } else { if(mbUseNrm) { // modify color with phong rColor = mrProcessor.getSdrLightingAttribute().solveColorModel( basegfx::B3DVector(maIntNormal.getX().getVal(), maIntNormal.getY().getVal(), maIntNormal.getZ().getVal()), rColor, mpCurrentMaterial->getSpecular(), mpCurrentMaterial->getEmission(), mpCurrentMaterial->getSpecularIntensity()); } else if(mbUseCol) { // modify color with gouraud rColor.setRed(maIntColor.getX().getVal()); rColor.setGreen(maIntColor.getY().getVal()); rColor.setBlue(maIntColor.getZ().getVal()); } } if(mbModifyColor) { rColor = mrProcessor.getBColorModifierStack().getModifiedColor(rColor); } } return fOpacity; } void setupLineSpanInterpolators(const basegfx::RasterConversionLineEntry3D& rA, const basegfx::RasterConversionLineEntry3D& rB) { // get inverse XDelta const double xInvDelta(1.0 / (rB.getX().getVal() - rA.getX().getVal())); // prepare Z-interpolator const double fZA(rA.getZ().getVal()); const double fZB(rB.getZ().getVal()); maIntZ = basegfx::ip_single(fZA, (fZB - fZA) * xInvDelta); // get bools and init other interpolators on demand accordingly mbModifyColor = mrProcessor.getBColorModifierStack().count(); mbHasTexCoor = SCANLINE_EMPTY_INDEX != rA.getTextureIndex() && SCANLINE_EMPTY_INDEX != rB.getTextureIndex(); mbHasInvTexCoor = SCANLINE_EMPTY_INDEX != rA.getInverseTextureIndex() && SCANLINE_EMPTY_INDEX != rB.getInverseTextureIndex(); const bool bTextureActive(mrProcessor.getGeoTexSvx().get() || mrProcessor.getTransparenceGeoTexSvx().get()); mbUseTex = bTextureActive && (mbHasTexCoor || mbHasInvTexCoor || mrProcessor.getSimpleTextureActive()); const bool bUseColorTex(mbUseTex && mrProcessor.getGeoTexSvx().get()); const bool bNeedNrmOrCol(!bUseColorTex || (bUseColorTex && mrProcessor.getModulate())); mbUseNrm = bNeedNrmOrCol && SCANLINE_EMPTY_INDEX != rA.getNormalIndex() && SCANLINE_EMPTY_INDEX != rB.getNormalIndex(); mbUseCol = !mbUseNrm && bNeedNrmOrCol && SCANLINE_EMPTY_INDEX != rA.getColorIndex() && SCANLINE_EMPTY_INDEX != rB.getColorIndex(); if(mbUseTex) { if(mbHasTexCoor) { const basegfx::ip_double& rTA(getTextureInterpolators()[rA.getTextureIndex()]); const basegfx::ip_double& rTB(getTextureInterpolators()[rB.getTextureIndex()]); maIntTexture = basegfx::ip_double( rTA.getX().getVal(), (rTB.getX().getVal() - rTA.getX().getVal()) * xInvDelta, rTA.getY().getVal(), (rTB.getY().getVal() - rTA.getY().getVal()) * xInvDelta); } else if(mbHasInvTexCoor) { const basegfx::ip_triple& rITA(getInverseTextureInterpolators()[rA.getInverseTextureIndex()]); const basegfx::ip_triple& rITB(getInverseTextureInterpolators()[rB.getInverseTextureIndex()]); maIntInvTexture = basegfx::ip_triple( rITA.getX().getVal(), (rITB.getX().getVal() - rITA.getX().getVal()) * xInvDelta, rITA.getY().getVal(), (rITB.getY().getVal() - rITA.getY().getVal()) * xInvDelta, rITA.getZ().getVal(), (rITB.getZ().getVal() - rITA.getZ().getVal()) * xInvDelta); } } if(mbUseNrm) { const basegfx::ip_triple& rNA(getNormalInterpolators()[rA.getNormalIndex()]); const basegfx::ip_triple& rNB(getNormalInterpolators()[rB.getNormalIndex()]); maIntNormal = basegfx::ip_triple( rNA.getX().getVal(), (rNB.getX().getVal() - rNA.getX().getVal()) * xInvDelta, rNA.getY().getVal(), (rNB.getY().getVal() - rNA.getY().getVal()) * xInvDelta, rNA.getZ().getVal(), (rNB.getZ().getVal() - rNA.getZ().getVal()) * xInvDelta); } if(mbUseCol) { const basegfx::ip_triple& rCA(getColorInterpolators()[rA.getColorIndex()]); const basegfx::ip_triple& rCB(getColorInterpolators()[rB.getColorIndex()]); maIntColor = basegfx::ip_triple( rCA.getX().getVal(), (rCB.getX().getVal() - rCA.getX().getVal()) * xInvDelta, rCA.getY().getVal(), (rCB.getY().getVal() - rCA.getY().getVal()) * xInvDelta, rCA.getZ().getVal(), (rCB.getZ().getVal() - rCA.getZ().getVal()) * xInvDelta); } } virtual void processLineSpan(const basegfx::RasterConversionLineEntry3D& rA, const basegfx::RasterConversionLineEntry3D& rB, sal_Int32 nLine, sal_uInt32 nSpanCount); public: ZBufferRasterConverter3D(basegfx::BZPixelRaster& rBuffer, const drawinglayer::processor3d::ZBufferProcessor3D& rProcessor) : basegfx::RasterConverter3D(), mrProcessor(rProcessor), mrBuffer(rBuffer), maIntZ(), maIntColor(), maIntNormal(), maIntTexture(), maIntInvTexture(), mpCurrentMaterial(0), mbModifyColor(false), mbUseTex(false), mbHasTexCoor(false), mbUseNrm(false), mbUseCol(false) {} void setCurrentMaterial(const drawinglayer::attribute::MaterialAttribute3D& rMaterial) { mpCurrentMaterial = &rMaterial; } }; void ZBufferRasterConverter3D::processLineSpan(const basegfx::RasterConversionLineEntry3D& rA, const basegfx::RasterConversionLineEntry3D& rB, sal_Int32 nLine, sal_uInt32 nSpanCount) { if(!(nSpanCount & 0x0001)) { if(nLine >= 0 && nLine < (sal_Int32)mrBuffer.getHeight()) { sal_uInt32 nXA(::std::min(mrBuffer.getWidth(), (sal_uInt32)::std::max((sal_Int32)0, basegfx::fround(rA.getX().getVal())))); const sal_uInt32 nXB(::std::min(mrBuffer.getWidth(), (sal_uInt32)::std::max((sal_Int32)0, basegfx::fround(rB.getX().getVal())))); if(nXA < nXB) { // prepare the span interpolators setupLineSpanInterpolators(rA, rB); // bring span interpolators to start condition by incrementing with the possible difference of // clamped and non-clamped XStart. Interpolators are setup relying on double precision // X-values, so that difference is the correct value to compensate for possible clampings incrementLineSpanInterpolators(static_cast(nXA) - rA.getX().getVal()); // prepare scanline index sal_uInt32 nScanlineIndex(mrBuffer.getIndexFromXY(nXA, static_cast(nLine))); basegfx::BColor aNewColor; while(nXA < nXB) { // early-test Z values if we need to do anything at all const double fNewZ(::std::max(0.0, ::std::min((double)0xffff, maIntZ.getVal()))); const sal_uInt16 nNewZ(static_cast< sal_uInt16 >(fNewZ)); sal_uInt16& rOldZ(mrBuffer.getZ(nScanlineIndex)); if(nNewZ > rOldZ) { // detect color and opacity for this pixel const sal_uInt16 nOpacity(::std::max((sal_Int16)0, static_cast< sal_Int16 >(decideColorAndOpacity(aNewColor) * 255.0))); if(nOpacity > 0) { // avoid color overrun aNewColor.clamp(); if(nOpacity >= 0x00ff) { // full opacity (not transparent), set z and color rOldZ = nNewZ; mrBuffer.getBPixel(nScanlineIndex) = basegfx::BPixel(aNewColor, 0xff); } else { basegfx::BPixel& rDest = mrBuffer.getBPixel(nScanlineIndex); if(rDest.getOpacity()) { // mix new color by using // color' = color * (1 - opacity) + newcolor * opacity const sal_uInt16 nTransparence(0x0100 - nOpacity); rDest.setRed((sal_uInt8)(((rDest.getRed() * nTransparence) + ((sal_uInt16)(255.0 * aNewColor.getRed()) * nOpacity)) >> 8)); rDest.setGreen((sal_uInt8)(((rDest.getGreen() * nTransparence) + ((sal_uInt16)(255.0 * aNewColor.getGreen()) * nOpacity)) >> 8)); rDest.setBlue((sal_uInt8)(((rDest.getBlue() * nTransparence) + ((sal_uInt16)(255.0 * aNewColor.getBlue()) * nOpacity)) >> 8)); if(0xff != rDest.getOpacity()) { // both are transparent, mix new opacity by using // opacity = newopacity * (1 - oldopacity) + oldopacity rDest.setOpacity(((sal_uInt8)((nOpacity * (0x0100 - rDest.getOpacity())) >> 8)) + rDest.getOpacity()); } } else { // dest is unused, set color rDest = basegfx::BPixel(aNewColor, (sal_uInt8)nOpacity); } } } } // increments nScanlineIndex++; nXA++; incrementLineSpanInterpolators(1.0); } } } } } ////////////////////////////////////////////////////////////////////////////// // helper class to buffer output for transparent rasterprimitives (filled areas // and lines) until the end of processing. To ensure correct transparent // visualisation, ZBuffers require to not set Z and to mix with the transparent // color. If transparent rasterprimitives overlap, it gets necessary to // paint transparent rasterprimitives from back to front to ensure that the // mixing happens from back to front. For that purpose, transparent // rasterprimitives are held in this class during the processing run, remember // all data and will be rendered class RasterPrimitive3D { private: boost::shared_ptr< drawinglayer::texture::GeoTexSvx > mpGeoTexSvx; boost::shared_ptr< drawinglayer::texture::GeoTexSvx > mpTransparenceGeoTexSvx; drawinglayer::attribute::MaterialAttribute3D maMaterial; basegfx::B3DPolyPolygon maPolyPolygon; double mfCenterZ; // bitfield bool mbModulate : 1; bool mbFilter : 1; bool mbSimpleTextureActive : 1; bool mbIsLine : 1; public: RasterPrimitive3D( const boost::shared_ptr< drawinglayer::texture::GeoTexSvx >& pGeoTexSvx, const boost::shared_ptr< drawinglayer::texture::GeoTexSvx >& pTransparenceGeoTexSvx, const drawinglayer::attribute::MaterialAttribute3D& rMaterial, const basegfx::B3DPolyPolygon& rPolyPolygon, bool bModulate, bool bFilter, bool bSimpleTextureActive, bool bIsLine) : mpGeoTexSvx(pGeoTexSvx), mpTransparenceGeoTexSvx(pTransparenceGeoTexSvx), maMaterial(rMaterial), maPolyPolygon(rPolyPolygon), mfCenterZ(basegfx::tools::getRange(rPolyPolygon).getCenter().getZ()), mbModulate(bModulate), mbFilter(bFilter), mbSimpleTextureActive(bSimpleTextureActive), mbIsLine(bIsLine) { } RasterPrimitive3D& operator=(const RasterPrimitive3D& rComp) { mpGeoTexSvx = rComp.mpGeoTexSvx; mpTransparenceGeoTexSvx = rComp.mpTransparenceGeoTexSvx; maMaterial = rComp.maMaterial; maPolyPolygon = rComp.maPolyPolygon; mfCenterZ = rComp.mfCenterZ; mbModulate = rComp.mbModulate; mbFilter = rComp.mbFilter; mbSimpleTextureActive = rComp.mbSimpleTextureActive; mbIsLine = rComp.mbIsLine; return *this; } bool operator<(const RasterPrimitive3D& rComp) const { return mfCenterZ < rComp.mfCenterZ; } const boost::shared_ptr< drawinglayer::texture::GeoTexSvx >& getGeoTexSvx() const { return mpGeoTexSvx; } const boost::shared_ptr< drawinglayer::texture::GeoTexSvx >& getTransparenceGeoTexSvx() const { return mpTransparenceGeoTexSvx; } const drawinglayer::attribute::MaterialAttribute3D& getMaterial() const { return maMaterial; } const basegfx::B3DPolyPolygon& getPolyPolygon() const { return maPolyPolygon; } bool getModulate() const { return mbModulate; } bool getFilter() const { return mbFilter; } bool getSimpleTextureActive() const { return mbSimpleTextureActive; } bool getIsLine() const { return mbIsLine; } }; ////////////////////////////////////////////////////////////////////////////// namespace drawinglayer { namespace processor3d { void ZBufferProcessor3D::rasterconvertB3DPolygon(const attribute::MaterialAttribute3D& rMaterial, const basegfx::B3DPolygon& rHairline) const { if(mpBZPixelRaster) { if(getTransparenceCounter()) { // transparent output; record for later sorting and painting from // back to front if(!mpRasterPrimitive3Ds) { const_cast< ZBufferProcessor3D* >(this)->mpRasterPrimitive3Ds = new std::vector< RasterPrimitive3D >; } mpRasterPrimitive3Ds->push_back(RasterPrimitive3D( getGeoTexSvx(), getTransparenceGeoTexSvx(), rMaterial, basegfx::B3DPolyPolygon(rHairline), getModulate(), getFilter(), getSimpleTextureActive(), true)); } else { // do rasterconversion mpZBufferRasterConverter3D->setCurrentMaterial(rMaterial); if(mnAntiAlialize > 1) { const bool bForceLineSnap(getOptionsDrawinglayer().IsAntiAliasing() && getOptionsDrawinglayer().IsSnapHorVerLinesToDiscrete()); if(bForceLineSnap) { basegfx::B3DHomMatrix aTransform; basegfx::B3DPolygon aSnappedHairline(rHairline); const double fScaleDown(1.0 / mnAntiAlialize); const double fScaleUp(mnAntiAlialize); // take oversampling out aTransform.scale(fScaleDown, fScaleDown, 1.0); aSnappedHairline.transform(aTransform); // snap to integer aSnappedHairline = basegfx::tools::snapPointsOfHorizontalOrVerticalEdges(aSnappedHairline); // add oversampling again aTransform.identity(); aTransform.scale(fScaleUp, fScaleUp, 1.0); if(false) { // when really want to go to single pixel lines, move to center. // Without this translation, all hor/ver hairlines will be centered exactly // between two pixel lines (which looks best) const double fTranslateToCenter(mnAntiAlialize * 0.5); aTransform.translate(fTranslateToCenter, fTranslateToCenter, 0.0); } aSnappedHairline.transform(aTransform); mpZBufferRasterConverter3D->rasterconvertB3DPolygon(aSnappedHairline, 0, mpBZPixelRaster->getHeight(), mnAntiAlialize); } else { mpZBufferRasterConverter3D->rasterconvertB3DPolygon(rHairline, 0, mpBZPixelRaster->getHeight(), mnAntiAlialize); } } else { mpZBufferRasterConverter3D->rasterconvertB3DPolygon(rHairline, 0, mpBZPixelRaster->getHeight(), 1); } } } } void ZBufferProcessor3D::rasterconvertB3DPolyPolygon(const attribute::MaterialAttribute3D& rMaterial, const basegfx::B3DPolyPolygon& rFill) const { if(mpBZPixelRaster) { if(getTransparenceCounter()) { // transparent output; record for later sorting and painting from // back to front if(!mpRasterPrimitive3Ds) { const_cast< ZBufferProcessor3D* >(this)->mpRasterPrimitive3Ds = new std::vector< RasterPrimitive3D >; } mpRasterPrimitive3Ds->push_back(RasterPrimitive3D( getGeoTexSvx(), getTransparenceGeoTexSvx(), rMaterial, rFill, getModulate(), getFilter(), getSimpleTextureActive(), false)); } else { mpZBufferRasterConverter3D->setCurrentMaterial(rMaterial); mpZBufferRasterConverter3D->rasterconvertB3DPolyPolygon(rFill, &maInvEyeToView, 0, mpBZPixelRaster->getHeight()); } } } ZBufferProcessor3D::ZBufferProcessor3D( const geometry::ViewInformation3D& rViewInformation3D, const geometry::ViewInformation2D& rViewInformation2D, const attribute::SdrSceneAttribute& rSdrSceneAttribute, const attribute::SdrLightingAttribute& rSdrLightingAttribute, double fSizeX, double fSizeY, const basegfx::B2DRange& rVisiblePart, sal_uInt16 nAntiAlialize) : DefaultProcessor3D(rViewInformation3D, rSdrSceneAttribute, rSdrLightingAttribute), mpBZPixelRaster(0), maInvEyeToView(), mpZBufferRasterConverter3D(0), mnAntiAlialize(nAntiAlialize), mpRasterPrimitive3Ds(0) { // generate ViewSizes const double fFullViewSizeX((rViewInformation2D.getObjectToViewTransformation() * basegfx::B2DVector(fSizeX, 0.0)).getLength()); const double fFullViewSizeY((rViewInformation2D.getObjectToViewTransformation() * basegfx::B2DVector(0.0, fSizeY)).getLength()); const double fViewSizeX(fFullViewSizeX * rVisiblePart.getWidth()); const double fViewSizeY(fFullViewSizeY * rVisiblePart.getHeight()); // generate RasterWidth and RasterHeight const sal_uInt32 nRasterWidth((sal_uInt32)basegfx::fround(fViewSizeX) + 1); const sal_uInt32 nRasterHeight((sal_uInt32)basegfx::fround(fViewSizeY) + 1); if(nRasterWidth && nRasterHeight) { // create view unit buffer mpBZPixelRaster = new basegfx::BZPixelRaster( mnAntiAlialize ? nRasterWidth * mnAntiAlialize : nRasterWidth, mnAntiAlialize ? nRasterHeight * mnAntiAlialize : nRasterHeight); OSL_ENSURE(mpBZPixelRaster, "ZBufferProcessor3D: Could not allocate basegfx::BZPixelRaster (!)"); // create DeviceToView for Z-Buffer renderer since Z is handled // different from standard 3D transformations (Z is mirrored). Also // the transformation includes the step from unit device coordinates // to discrete units ([-1.0 .. 1.0] -> [minDiscrete .. maxDiscrete] basegfx::B3DHomMatrix aDeviceToView; { // step one: // // bring from [-1.0 .. 1.0] in X,Y and Z to [0.0 .. 1.0]. Also // necessary to // - flip Y due to screen orientation // - flip Z due to Z-Buffer orientation from back to front aDeviceToView.scale(0.5, -0.5, -0.5); aDeviceToView.translate(0.5, 0.5, 0.5); } { // step two: // // bring from [0.0 .. 1.0] in X,Y and Z to view cordinates // // #i102611# // also: scale Z to [1.5 .. 65534.5]. Normally, a range of [0.0 .. 65535.0] // could be used, but a 'unused' value is needed, so '0' is used what reduces // the range to [1.0 .. 65535.0]. It has also shown that small numerical errors // (smaller as basegfx::fTools::mfSmallValue, which is 0.000000001) happen. // Instead of checking those by basegfx::fTools methods which would cost // runtime, just add another 0.5 tolerance to the start and end of the Z-Buffer // range, thus resulting in [1.5 .. 65534.5] const double fMaxZDepth(65533.0); aDeviceToView.translate(-rVisiblePart.getMinX(), -rVisiblePart.getMinY(), 0.0); if(mnAntiAlialize) aDeviceToView.scale(fFullViewSizeX * mnAntiAlialize, fFullViewSizeY * mnAntiAlialize, fMaxZDepth); else aDeviceToView.scale(fFullViewSizeX, fFullViewSizeY, fMaxZDepth); aDeviceToView.translate(0.0, 0.0, 1.5); } // update local ViewInformation3D with own DeviceToView const geometry::ViewInformation3D aNewViewInformation3D( getViewInformation3D().getObjectTransformation(), getViewInformation3D().getOrientation(), getViewInformation3D().getProjection(), aDeviceToView, getViewInformation3D().getViewTime(), getViewInformation3D().getExtendedInformationSequence()); updateViewInformation(aNewViewInformation3D); // prepare inverse EyeToView transformation. This can be done in constructor // since changes in object transformations when processing TransformPrimitive3Ds // do not influence this prepared partial transformation maInvEyeToView = getViewInformation3D().getDeviceToView() * getViewInformation3D().getProjection(); maInvEyeToView.invert(); // prepare maRasterRange maRasterRange.reset(); maRasterRange.expand(basegfx::B2DPoint(0.0, 0.0)); maRasterRange.expand(basegfx::B2DPoint(mpBZPixelRaster->getWidth(), mpBZPixelRaster->getHeight())); // create the raster converter mpZBufferRasterConverter3D = new ZBufferRasterConverter3D(*mpBZPixelRaster, *this); } } ZBufferProcessor3D::~ZBufferProcessor3D() { if(mpBZPixelRaster) { delete mpZBufferRasterConverter3D; delete mpBZPixelRaster; } if(mpRasterPrimitive3Ds) { OSL_ASSERT("ZBufferProcessor3D: destructed, but there are unrendered transparent geometries. Use ZBufferProcessor3D::finish() to render these (!)"); delete mpRasterPrimitive3Ds; } } void ZBufferProcessor3D::finish() { if(mpRasterPrimitive3Ds) { // there are transparent rasterprimitives const sal_uInt32 nSize(mpRasterPrimitive3Ds->size()); if(nSize > 1) { // sort them from back to front std::sort(mpRasterPrimitive3Ds->begin(), mpRasterPrimitive3Ds->end()); } for(sal_uInt32 a(0); a < nSize; a++) { // paint each one by setting the remembered data and calling // the render method const RasterPrimitive3D& rCandidate = (*mpRasterPrimitive3Ds)[a]; mpGeoTexSvx = rCandidate.getGeoTexSvx(); mpTransparenceGeoTexSvx = rCandidate.getTransparenceGeoTexSvx(); mbModulate = rCandidate.getModulate(); mbFilter = rCandidate.getFilter(); mbSimpleTextureActive = rCandidate.getSimpleTextureActive(); if(rCandidate.getIsLine()) { rasterconvertB3DPolygon( rCandidate.getMaterial(), rCandidate.getPolyPolygon().getB3DPolygon(0)); } else { rasterconvertB3DPolyPolygon( rCandidate.getMaterial(), rCandidate.getPolyPolygon()); } } // delete them to signal the destructor that all is done and // to allow asserting there delete mpRasterPrimitive3Ds; mpRasterPrimitive3Ds = 0; } } BitmapEx ZBufferProcessor3D::getBitmapEx() const { if(mpBZPixelRaster) { return BPixelRasterToBitmapEx(*mpBZPixelRaster, mnAntiAlialize); } return BitmapEx(); } } // end of namespace processor3d } // end of namespace drawinglayer ////////////////////////////////////////////////////////////////////////////// // eof