1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_basegfx.hxx" 30 31 #include <basegfx/raster/rasterconvert3d.hxx> 32 #include <basegfx/polygon/b3dpolygon.hxx> 33 #include <basegfx/polygon/b3dpolypolygon.hxx> 34 #include <basegfx/point/b3dpoint.hxx> 35 36 ////////////////////////////////////////////////////////////////////////////// 37 // implementations of the 3D raster converter 38 39 namespace basegfx 40 { 41 void RasterConverter3D::addArea(const B3DPolygon& rFill, const B3DHomMatrix* pViewToEye) 42 { 43 const sal_uInt32 nPointCount(rFill.count()); 44 45 for(sal_uInt32 a(0); a < nPointCount; a++) 46 { 47 addEdge(rFill, a, (a + 1) % nPointCount, pViewToEye); 48 } 49 } 50 51 void RasterConverter3D::addArea(const B3DPolyPolygon& rFill, const B3DHomMatrix* pViewToEye) 52 { 53 const sal_uInt32 nPolyCount(rFill.count()); 54 55 for(sal_uInt32 a(0); a < nPolyCount; a++) 56 { 57 addArea(rFill.getB3DPolygon(a), pViewToEye); 58 } 59 } 60 61 RasterConverter3D::RasterConverter3D() 62 : InterpolatorProvider3D(), 63 maLineEntries() 64 {} 65 66 RasterConverter3D::~RasterConverter3D() 67 {} 68 69 void RasterConverter3D::rasterconvertB3DArea(sal_Int32 nStartLine, sal_Int32 nStopLine) 70 { 71 if(maLineEntries.size()) 72 { 73 OSL_ENSURE(nStopLine >= nStartLine, "nStopLine is bigger than nStartLine (!)"); 74 75 // sort global entries by Y, X once. After this, the vector 76 // is seen as frozen. Pointers to it's entries will be used in the following code. 77 ::std::sort(maLineEntries.begin(), maLineEntries.end()); 78 79 // local parameters 80 ::std::vector< RasterConversionLineEntry3D >::iterator aCurrentEntry(maLineEntries.begin()); 81 ::std::vector< RasterConversionLineEntry3D* > aCurrentLine; 82 ::std::vector< RasterConversionLineEntry3D* > aNextLine; 83 ::std::vector< RasterConversionLineEntry3D* >::iterator aRasterConversionLineEntry3D; 84 sal_uInt32 nPairCount(0); 85 86 // get scanlines first LineNumber as start 87 sal_Int32 nLineNumber(::std::max(aCurrentEntry->getY(), nStartLine)); 88 89 while((aCurrentLine.size() || aCurrentEntry != maLineEntries.end()) && (nLineNumber < nStopLine)) 90 { 91 // add all entries which start at current line to current scanline 92 while(aCurrentEntry != maLineEntries.end()) 93 { 94 const sal_Int32 nCurrentLineNumber(aCurrentEntry->getY()); 95 96 if(nCurrentLineNumber > nLineNumber) 97 { 98 // line is below current one, done (since array is sorted) 99 break; 100 } 101 else 102 { 103 // less or equal. Line is above or at current one. Advance it exactly to 104 // current line 105 const sal_uInt32 nStep(nLineNumber - nCurrentLineNumber); 106 107 if(!nStep || aCurrentEntry->decrementRasterConversionLineEntry3D(nStep)) 108 { 109 // add when exactly on current line or when incremet to it did not 110 // completely consume it 111 if(nStep) 112 { 113 aCurrentEntry->incrementRasterConversionLineEntry3D(nStep, *this); 114 } 115 116 aCurrentLine.push_back(&(*(aCurrentEntry))); 117 } 118 } 119 120 aCurrentEntry++; 121 } 122 123 // sort current scanline using comparator. Only X is used there 124 // since all entries are already in one processed line. This needs to be done 125 // everytime since not only new spans may have benn added or old removed, 126 // but incrementing may also have changed the order 127 ::std::sort(aCurrentLine.begin(), aCurrentLine.end(), lineComparator()); 128 129 // process current scanline 130 aRasterConversionLineEntry3D = aCurrentLine.begin(); 131 aNextLine.clear(); 132 nPairCount = 0; 133 134 while(aRasterConversionLineEntry3D != aCurrentLine.end()) 135 { 136 RasterConversionLineEntry3D& rPrevScanRasterConversionLineEntry3D(**aRasterConversionLineEntry3D++); 137 138 // look for 2nd span 139 if(aRasterConversionLineEntry3D != aCurrentLine.end()) 140 { 141 // work on span from rPrevScanRasterConversionLineEntry3D to aRasterConversionLineEntry3D, fLineNumber is valid 142 processLineSpan(rPrevScanRasterConversionLineEntry3D, **aRasterConversionLineEntry3D, nLineNumber, nPairCount++); 143 } 144 145 // increment to next line 146 if(rPrevScanRasterConversionLineEntry3D.decrementRasterConversionLineEntry3D(1)) 147 { 148 rPrevScanRasterConversionLineEntry3D.incrementRasterConversionLineEntry3D(1, *this); 149 aNextLine.push_back(&rPrevScanRasterConversionLineEntry3D); 150 } 151 } 152 153 // copy back next scanline if count has changed 154 if(aNextLine.size() != aCurrentLine.size()) 155 { 156 aCurrentLine = aNextLine; 157 } 158 159 // increment fLineNumber 160 nLineNumber++; 161 } 162 } 163 } 164 165 void RasterConverter3D::addEdge(const B3DPolygon& rFill, sal_uInt32 a, sal_uInt32 b, const B3DHomMatrix* pViewToEye) 166 { 167 B3DPoint aStart(rFill.getB3DPoint(a)); 168 B3DPoint aEnd(rFill.getB3DPoint(b)); 169 sal_Int32 nYStart(fround(aStart.getY())); 170 sal_Int32 nYEnd(fround(aEnd.getY())); 171 172 if(nYStart != nYEnd) 173 { 174 if(nYStart > nYEnd) 175 { 176 ::std::swap(aStart, aEnd); 177 ::std::swap(nYStart, nYEnd); 178 ::std::swap(a, b); 179 } 180 181 const sal_uInt32 nYDelta(nYEnd - nYStart); 182 const double fInvYDelta(1.0 / nYDelta); 183 maLineEntries.push_back(RasterConversionLineEntry3D( 184 aStart.getX(), (aEnd.getX() - aStart.getX()) * fInvYDelta, 185 aStart.getZ(), (aEnd.getZ() - aStart.getZ()) * fInvYDelta, 186 nYStart, nYDelta)); 187 188 // if extra interpolation data is used, add it to the last created entry 189 RasterConversionLineEntry3D& rEntry = maLineEntries[maLineEntries.size() - 1]; 190 191 if(rFill.areBColorsUsed()) 192 { 193 rEntry.setColorIndex(addColorInterpolator(rFill.getBColor(a), rFill.getBColor(b), fInvYDelta)); 194 } 195 196 if(rFill.areNormalsUsed()) 197 { 198 rEntry.setNormalIndex(addNormalInterpolator(rFill.getNormal(a), rFill.getNormal(b), fInvYDelta)); 199 } 200 201 if(rFill.areTextureCoordinatesUsed()) 202 { 203 if(pViewToEye) 204 { 205 const double fEyeA(((*pViewToEye) * aStart).getZ()); 206 const double fEyeB(((*pViewToEye) * aEnd).getZ()); 207 208 rEntry.setInverseTextureIndex(addInverseTextureInterpolator( 209 rFill.getTextureCoordinate(a), 210 rFill.getTextureCoordinate(b), 211 fEyeA, fEyeB, fInvYDelta)); 212 } 213 else 214 { 215 rEntry.setTextureIndex(addTextureInterpolator( 216 rFill.getTextureCoordinate(a), 217 rFill.getTextureCoordinate(b), 218 fInvYDelta)); 219 } 220 } 221 } 222 } 223 224 void RasterConverter3D::rasterconvertB3DEdge(const B3DPolygon& rLine, sal_uInt32 nA, sal_uInt32 nB, sal_Int32 nStartLine, sal_Int32 nStopLine, sal_uInt16 nLineWidth) 225 { 226 B3DPoint aStart(rLine.getB3DPoint(nA)); 227 B3DPoint aEnd(rLine.getB3DPoint(nB)); 228 const double fZBufferLineAdd(0x00ff); 229 static bool bForceToPolygon(false); 230 231 if(nLineWidth > 1 || bForceToPolygon) 232 { 233 // this is not a hairline anymore, in most cases since it's an oversampled 234 // hairline to get e.g. AA for Z-Buffering. Create fill geometry. 235 if(!aStart.equal(aEnd)) 236 { 237 reset(); 238 maLineEntries.clear(); 239 240 B2DVector aVector(aEnd.getX() - aStart.getX(), aEnd.getY() - aStart.getY()); 241 aVector.normalize(); 242 const B2DVector aPerpend(getPerpendicular(aVector) * ((static_cast<double>(nLineWidth) + 0.5) * 0.5)); 243 const double fZStartWithAdd(aStart.getZ() + fZBufferLineAdd); 244 const double fZEndWithAdd(aEnd.getZ() + fZBufferLineAdd); 245 246 B3DPolygon aPolygon; 247 aPolygon.append(B3DPoint(aStart.getX() + aPerpend.getX(), aStart.getY() + aPerpend.getY(), fZStartWithAdd)); 248 aPolygon.append(B3DPoint(aEnd.getX() + aPerpend.getX(), aEnd.getY() + aPerpend.getY(), fZEndWithAdd)); 249 aPolygon.append(B3DPoint(aEnd.getX() - aPerpend.getX(), aEnd.getY() - aPerpend.getY(), fZEndWithAdd)); 250 aPolygon.append(B3DPoint(aStart.getX() - aPerpend.getX(), aStart.getY() - aPerpend.getY(), fZStartWithAdd)); 251 aPolygon.setClosed(true); 252 253 addArea(aPolygon, 0); 254 } 255 } 256 else 257 { 258 // it's a hairline. Use direct RasterConversionLineEntry creation to 259 // rasterconvert lines as similar to areas as possible to avoid Z-Fighting 260 sal_Int32 nYStart(fround(aStart.getY())); 261 sal_Int32 nYEnd(fround(aEnd.getY())); 262 263 if(nYStart == nYEnd) 264 { 265 // horizontal line, check X 266 const sal_Int32 nXStart(static_cast<sal_Int32>(aStart.getX())); 267 const sal_Int32 nXEnd(static_cast<sal_Int32>(aEnd.getX())); 268 269 if(nXStart != nXEnd) 270 { 271 reset(); 272 maLineEntries.clear(); 273 274 // horizontal line, create vertical entries. These will be sorted by 275 // X anyways, so no need to distinguish the case here 276 maLineEntries.push_back(RasterConversionLineEntry3D( 277 aStart.getX(), 0.0, 278 aStart.getZ() + fZBufferLineAdd, 0.0, 279 nYStart, 1)); 280 maLineEntries.push_back(RasterConversionLineEntry3D( 281 aEnd.getX(), 0.0, 282 aEnd.getZ() + fZBufferLineAdd, 0.0, 283 nYStart, 1)); 284 } 285 } 286 else 287 { 288 reset(); 289 maLineEntries.clear(); 290 291 if(nYStart > nYEnd) 292 { 293 ::std::swap(aStart, aEnd); 294 ::std::swap(nYStart, nYEnd); 295 } 296 297 const sal_uInt32 nYDelta(static_cast<sal_uInt32>(nYEnd - nYStart)); 298 const double fInvYDelta(1.0 / nYDelta); 299 300 // non-horizontal line, create two parallell entries. These will be sorted by 301 // X anyways, so no need to distinguish the case here 302 maLineEntries.push_back(RasterConversionLineEntry3D( 303 aStart.getX(), (aEnd.getX() - aStart.getX()) * fInvYDelta, 304 aStart.getZ() + fZBufferLineAdd, (aEnd.getZ() - aStart.getZ()) * fInvYDelta, 305 nYStart, nYDelta)); 306 307 RasterConversionLineEntry3D& rEntry = maLineEntries[maLineEntries.size() - 1]; 308 309 // need to choose a X-Distance for the 2nd edge which guarantees all pixels 310 // of the line to be set. This is exactly the X-Increment for one Y-Step. 311 // Same is true for Z, so in both cases, add one increment to them. To also 312 // guarantee one pixel per line, add a minimum of one for X. 313 const double fDistanceX(fabs(rEntry.getX().getInc()) >= 1.0 ? rEntry.getX().getInc() : 1.0); 314 315 maLineEntries.push_back(RasterConversionLineEntry3D( 316 rEntry.getX().getVal() + fDistanceX, rEntry.getX().getInc(), 317 rEntry.getZ().getVal() + rEntry.getZ().getInc(), rEntry.getZ().getInc(), 318 nYStart, nYDelta)); 319 } 320 } 321 322 if(maLineEntries.size()) 323 { 324 rasterconvertB3DArea(nStartLine, nStopLine); 325 } 326 } 327 328 void RasterConverter3D::rasterconvertB3DPolyPolygon(const B3DPolyPolygon& rFill, const B3DHomMatrix* pViewToEye, sal_Int32 nStartLine, sal_Int32 nStopLine) 329 { 330 reset(); 331 maLineEntries.clear(); 332 addArea(rFill, pViewToEye); 333 rasterconvertB3DArea(nStartLine, nStopLine); 334 } 335 336 void RasterConverter3D::rasterconvertB3DPolygon(const B3DPolygon& rLine, sal_Int32 nStartLine, sal_Int32 nStopLine, sal_uInt16 nLineWidth) 337 { 338 const sal_uInt32 nPointCount(rLine.count()); 339 340 if(nPointCount) 341 { 342 const sal_uInt32 nEdgeCount(rLine.isClosed() ? nPointCount : nPointCount - 1); 343 344 for(sal_uInt32 a(0); a < nEdgeCount; a++) 345 { 346 rasterconvertB3DEdge(rLine, a, (a + 1) % nPointCount, nStartLine, nStopLine, nLineWidth); 347 } 348 } 349 } 350 } // end of namespace basegfx 351 352 ////////////////////////////////////////////////////////////////////////////// 353 // eof 354