/************************************************************** * * 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 ////////////////////////////////////////////////////////////////////////////// using namespace com::sun::star; ////////////////////////////////////////////////////////////////////////////// namespace drawinglayer { namespace primitive3d { Primitive3DSequence HatchTexturePrimitive3D::impCreate3DDecomposition() const { Primitive3DSequence aRetval; if(getChildren().hasElements()) { const Primitive3DSequence aSource(getChildren()); const sal_uInt32 nSourceCount(aSource.getLength()); std::vector< Primitive3DReference > aDestination; for(sal_uInt32 a(0); a < nSourceCount; a++) { // get reference const Primitive3DReference xReference(aSource[a]); if(xReference.is()) { // try to cast to BasePrimitive2D implementation const BasePrimitive3D* pBasePrimitive = dynamic_cast< const BasePrimitive3D* >(xReference.get()); if(pBasePrimitive) { // it is a BasePrimitive3D implementation, use getPrimitive3DID() call for switch // not all content is needed, remove transparencies and ModifiedColorPrimitives switch(pBasePrimitive->getPrimitive3DID()) { case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D : { // polyPolygonMaterialPrimitive3D, check texturing and hatching const PolyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const PolyPolygonMaterialPrimitive3D& >(*pBasePrimitive); const basegfx::B3DPolyPolygon aFillPolyPolygon(rPrimitive.getB3DPolyPolygon()); if(maHatch.isFillBackground()) { // add original primitive for background aDestination.push_back(xReference); } if(aFillPolyPolygon.areTextureCoordinatesUsed()) { const sal_uInt32 nPolyCount(aFillPolyPolygon.count()); basegfx::B2DPolyPolygon aTexPolyPolygon; basegfx::B2DPoint a2N; basegfx::B2DVector a2X, a2Y; basegfx::B3DPoint a3N; basegfx::B3DVector a3X, a3Y; bool b2N(false), b2X(false), b2Y(false); for(sal_uInt32 b(0); b < nPolyCount; b++) { const basegfx::B3DPolygon aPartPoly(aFillPolyPolygon.getB3DPolygon(b)); const sal_uInt32 nPointCount(aPartPoly.count()); basegfx::B2DPolygon aTexPolygon; for(sal_uInt32 c(0); c < nPointCount; c++) { const basegfx::B2DPoint a2Candidate(aPartPoly.getTextureCoordinate(c)); if(!b2N) { a2N = a2Candidate; a3N = aPartPoly.getB3DPoint(c); b2N = true; } else if(!b2X && !a2N.equal(a2Candidate)) { a2X = a2Candidate - a2N; a3X = aPartPoly.getB3DPoint(c) - a3N; b2X = true; } else if(!b2Y && !a2N.equal(a2Candidate) && !a2X.equal(a2Candidate)) { a2Y = a2Candidate - a2N; const double fCross(a2X.cross(a2Y)); if(!basegfx::fTools::equalZero(fCross)) { a3Y = aPartPoly.getB3DPoint(c) - a3N; b2Y = true; } } aTexPolygon.append(a2Candidate); } aTexPolygon.setClosed(true); aTexPolyPolygon.append(aTexPolygon); } if(b2N && b2X && b2Y) { // found two linearly independent 2D vectors // get 2d range of texture coordinates const basegfx::B2DRange aOutlineRange(basegfx::tools::getRange(aTexPolyPolygon)); const basegfx::BColor aHatchColor(getHatch().getColor()); const double fAngle(getHatch().getAngle()); ::std::vector< basegfx::B2DHomMatrix > aMatrices; // get hatch transformations switch(getHatch().getStyle()) { case attribute::HATCHSTYLE_TRIPLE: { // rotated 45 degrees texture::GeoTexSvxHatch aHatch( aOutlineRange, aOutlineRange, getHatch().getDistance(), fAngle - F_PI4); aHatch.appendTransformations(aMatrices); } case attribute::HATCHSTYLE_DOUBLE: { // rotated 90 degrees texture::GeoTexSvxHatch aHatch( aOutlineRange, aOutlineRange, getHatch().getDistance(), fAngle - F_PI2); aHatch.appendTransformations(aMatrices); } case attribute::HATCHSTYLE_SINGLE: { // angle as given texture::GeoTexSvxHatch aHatch( aOutlineRange, aOutlineRange, getHatch().getDistance(), fAngle); aHatch.appendTransformations(aMatrices); } } // create geometry from unit line basegfx::B2DPolyPolygon a2DHatchLines; basegfx::B2DPolygon a2DUnitLine; a2DUnitLine.append(basegfx::B2DPoint(0.0, 0.0)); a2DUnitLine.append(basegfx::B2DPoint(1.0, 0.0)); for(sal_uInt32 c(0); c < aMatrices.size(); c++) { const basegfx::B2DHomMatrix& rMatrix = aMatrices[c]; basegfx::B2DPolygon aNewLine(a2DUnitLine); aNewLine.transform(rMatrix); a2DHatchLines.append(aNewLine); } if(a2DHatchLines.count()) { // clip against texture polygon a2DHatchLines = basegfx::tools::clipPolyPolygonOnPolyPolygon(a2DHatchLines, aTexPolyPolygon, true, true); } if(a2DHatchLines.count()) { // create 2d matrix with 2d vectors as column vectors and 2d point as offset, this represents // a coordinate system transformation from unit coordinates to the new coordinate system basegfx::B2DHomMatrix a2D; a2D.set(0, 0, a2X.getX()); a2D.set(1, 0, a2X.getY()); a2D.set(0, 1, a2Y.getX()); a2D.set(1, 1, a2Y.getY()); a2D.set(0, 2, a2N.getX()); a2D.set(1, 2, a2N.getY()); // invert that transformation, so we have a back-transformation from texture coordinates // to unit coordinates a2D.invert(); a2DHatchLines.transform(a2D); // expand back-transformated geometry tpo 3D basegfx::B3DPolyPolygon a3DHatchLines(basegfx::tools::createB3DPolyPolygonFromB2DPolyPolygon(a2DHatchLines, 0.0)); // create 3d matrix with 3d vectors as column vectors (0,0,1 as Z) and 3d point as offset, this represents // a coordinate system transformation from unit coordinates to the object's 3d coordinate system basegfx::B3DHomMatrix a3D; a3D.set(0, 0, a3X.getX()); a3D.set(1, 0, a3X.getY()); a3D.set(2, 0, a3X.getZ()); a3D.set(0, 1, a3Y.getX()); a3D.set(1, 1, a3Y.getY()); a3D.set(2, 1, a3Y.getZ()); a3D.set(0, 3, a3N.getX()); a3D.set(1, 3, a3N.getY()); a3D.set(2, 3, a3N.getZ()); // transform hatch lines to 3D object coordinates a3DHatchLines.transform(a3D); // build primitives from this geometry const sal_uInt32 nHatchLines(a3DHatchLines.count()); for(sal_uInt32 d(0); d < nHatchLines; d++) { const Primitive3DReference xRef(new PolygonHairlinePrimitive3D(a3DHatchLines.getB3DPolygon(d), aHatchColor)); aDestination.push_back(xRef); } } } } break; } default : { // add reference to result aDestination.push_back(xReference); break; } } } else { // unknown implementation, add to result aDestination.push_back(xReference); } } } // prepare return value const sal_uInt32 nDestSize(aDestination.size()); aRetval.realloc(nDestSize); for(sal_uInt32 b(0); b < nDestSize; b++) { aRetval[b] = aDestination[b]; } } return aRetval; } HatchTexturePrimitive3D::HatchTexturePrimitive3D( const attribute::FillHatchAttribute& rHatch, const Primitive3DSequence& rChildren, const basegfx::B2DVector& rTextureSize, bool bModulate, bool bFilter) : TexturePrimitive3D(rChildren, rTextureSize, bModulate, bFilter), maHatch(rHatch), maBuffered3DDecomposition() { } bool HatchTexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const { if(TexturePrimitive3D::operator==(rPrimitive)) { const HatchTexturePrimitive3D& rCompare = (HatchTexturePrimitive3D&)rPrimitive; return (getHatch() == rCompare.getHatch()); } return false; } Primitive3DSequence HatchTexturePrimitive3D::get3DDecomposition(const geometry::ViewInformation3D& /*rViewInformation*/) const { ::osl::MutexGuard aGuard( m_aMutex ); if(!getBuffered3DDecomposition().hasElements()) { const Primitive3DSequence aNewSequence(impCreate3DDecomposition()); const_cast< HatchTexturePrimitive3D* >(this)->setBuffered3DDecomposition(aNewSequence); } return getBuffered3DDecomposition(); } // provide unique ID ImplPrimitrive3DIDBlock(HatchTexturePrimitive3D, PRIMITIVE3D_ID_HATCHTEXTUREPRIMITIVE3D) } // end of namespace primitive3d } // end of namespace drawinglayer ////////////////////////////////////////////////////////////////////////////// // eof