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 : #ifndef INCLUDED_BASEGFX_RASTER_RASTERCONVERT3D_HXX
21 : #define INCLUDED_BASEGFX_RASTER_RASTERCONVERT3D_HXX
22 :
23 : #include <sal/types.h>
24 : #include <vector>
25 : #include <basegfx/color/bcolor.hxx>
26 : #include <basegfx/vector/b3dvector.hxx>
27 : #include <basegfx/point/b2dpoint.hxx>
28 : #include <basegfx/vector/b2dvector.hxx>
29 : #include <basegfx/basegfxdllapi.h>
30 :
31 :
32 : // predeclarations
33 :
34 : namespace basegfx
35 : {
36 : class B3DPolygon;
37 : class B3DPolyPolygon;
38 : }
39 :
40 :
41 : // interpolators for double precision
42 :
43 : namespace basegfx
44 : {
45 : class ip_single
46 : {
47 : private:
48 : double mfVal;
49 : double mfInc;
50 :
51 : public:
52 252 : ip_single()
53 : : mfVal(0.0),
54 252 : mfInc(0.0)
55 252 : {}
56 :
57 371062 : ip_single(double fVal, double fInc)
58 : : mfVal(fVal),
59 371062 : mfInc(fInc)
60 371062 : {}
61 :
62 7993595 : double getVal() const { return mfVal; }
63 3129 : double getInc() const { return mfInc; }
64 :
65 6087167 : void increment(double fStep) { mfVal += fStep * mfInc; }
66 : };
67 : } // end of namespace basegfx
68 :
69 : namespace basegfx
70 : {
71 : class ip_double
72 : {
73 : private:
74 : ip_single maX;
75 : ip_single maY;
76 :
77 : public:
78 21 : ip_double()
79 : : maX(),
80 21 : maY()
81 21 : {}
82 :
83 0 : ip_double(double fXVal, double fXInc, double fYVal, double fYInc)
84 : : maX(fXVal, fXInc),
85 0 : maY(fYVal, fYInc)
86 0 : {}
87 :
88 0 : const ip_single& getX() const { return maX; }
89 0 : const ip_single& getY() const { return maY; }
90 :
91 0 : void increment(double fStep) { maX.increment(fStep); maY.increment(fStep); }
92 : };
93 : } // end of namespace basegfx
94 :
95 : namespace basegfx
96 : {
97 : class ip_triple
98 : {
99 : private:
100 : ip_single maX;
101 : ip_single maY;
102 : ip_single maZ;
103 :
104 : public:
105 63 : ip_triple()
106 : : maX(),
107 : maY(),
108 63 : maZ()
109 63 : {}
110 :
111 6750 : ip_triple(double fXVal, double fXInc, double fYVal, double fYInc, double fZVal, double fZInc)
112 : : maX(fXVal, fXInc),
113 : maY(fYVal, fYInc),
114 6750 : maZ(fZVal, fZInc)
115 6750 : {}
116 :
117 205330 : const ip_single& getX() const { return maX; }
118 205330 : const ip_single& getY() const { return maY; }
119 205330 : const ip_single& getZ() const { return maZ; }
120 :
121 205608 : void increment(double fStep) { maX.increment(fStep); maY.increment(fStep); maZ.increment(fStep); }
122 : };
123 : } // end of namespace basegfx
124 :
125 :
126 : // InterpolatorProvider3D to have a common source for allocating interpolators
127 : // which may then be addressed using the index to the vectors
128 :
129 : namespace basegfx
130 : {
131 : #define SCANLINE_EMPTY_INDEX (0xffffffff)
132 :
133 21 : class InterpolatorProvider3D
134 : {
135 : private:
136 : ::std::vector< ip_triple > maColorInterpolators;
137 : ::std::vector< ip_triple > maNormalInterpolators;
138 : ::std::vector< ip_double > maTextureInterpolators;
139 : ::std::vector< ip_triple > maInverseTextureInterpolators;
140 :
141 : protected:
142 132 : sal_uInt32 addColorInterpolator(const BColor& rA, const BColor& rB, double fInvYDelta)
143 : {
144 132 : double aDeltaRed(rB.getRed() - rA.getRed());
145 :
146 132 : if(fTools::equalZero(aDeltaRed))
147 : {
148 83 : aDeltaRed = 0.0;
149 : }
150 : else
151 : {
152 49 : aDeltaRed *= fInvYDelta;
153 : }
154 :
155 132 : double aDeltaGreen(rB.getGreen() - rA.getGreen());
156 :
157 132 : if(fTools::equalZero(aDeltaGreen))
158 : {
159 83 : aDeltaGreen = 0.0;
160 : }
161 : else
162 : {
163 49 : aDeltaGreen *= fInvYDelta;
164 : }
165 :
166 132 : double aDeltaBlue(rB.getBlue() - rA.getBlue());
167 :
168 132 : if(fTools::equalZero(aDeltaBlue))
169 : {
170 55 : aDeltaBlue = 0.0;
171 : }
172 : else
173 : {
174 77 : aDeltaBlue *= fInvYDelta;
175 : }
176 :
177 : maColorInterpolators.push_back(
178 : ip_triple(
179 : rA.getRed(), aDeltaRed,
180 : rA.getGreen(), aDeltaGreen,
181 132 : rA.getBlue(), aDeltaBlue));
182 :
183 132 : return (maColorInterpolators.size() - 1);
184 : }
185 :
186 0 : sal_uInt32 addNormalInterpolator(const B3DVector& rA, const B3DVector& rB, double fInvYDelta)
187 : {
188 0 : double aDeltaX(rB.getX() - rA.getX());
189 :
190 0 : if(fTools::equalZero(aDeltaX))
191 : {
192 0 : aDeltaX = 0.0;
193 : }
194 : else
195 : {
196 0 : aDeltaX *= fInvYDelta;
197 : }
198 :
199 0 : double aDeltaY(rB.getY() - rA.getY());
200 :
201 0 : if(fTools::equalZero(aDeltaY))
202 : {
203 0 : aDeltaY = 0.0;
204 : }
205 : else
206 : {
207 0 : aDeltaY *= fInvYDelta;
208 : }
209 :
210 0 : double aDeltaZ(rB.getZ() - rA.getZ());
211 :
212 0 : if(fTools::equalZero(aDeltaZ))
213 : {
214 0 : aDeltaZ = 0.0;
215 : }
216 : else
217 : {
218 0 : aDeltaZ *= fInvYDelta;
219 : }
220 :
221 : maNormalInterpolators.push_back(
222 : ip_triple(
223 : rA.getX(), aDeltaX,
224 : rA.getY(), aDeltaY,
225 0 : rA.getZ(), aDeltaZ));
226 :
227 0 : return (maNormalInterpolators.size() - 1);
228 : }
229 :
230 0 : sal_uInt32 addTextureInterpolator(const B2DPoint& rA, const B2DPoint& rB, double fInvYDelta)
231 : {
232 0 : double aDeltaX(rB.getX() - rA.getX());
233 :
234 0 : if(fTools::equalZero(aDeltaX))
235 : {
236 0 : aDeltaX = 0.0;
237 : }
238 : else
239 : {
240 0 : aDeltaX *= fInvYDelta;
241 : }
242 :
243 0 : double aDeltaY(rB.getY() - rA.getY());
244 :
245 0 : if(fTools::equalZero(aDeltaY))
246 : {
247 0 : aDeltaY = 0.0;
248 : }
249 : else
250 : {
251 0 : aDeltaY *= fInvYDelta;
252 : }
253 :
254 : maTextureInterpolators.push_back(
255 : ip_double(
256 : rA.getX(), aDeltaX,
257 0 : rA.getY(), aDeltaY));
258 :
259 0 : return (maTextureInterpolators.size() - 1);
260 : }
261 :
262 132 : sal_uInt32 addInverseTextureInterpolator(const B2DPoint& rA, const B2DPoint& rB, double fZEyeA, double fZEyeB, double fInvYDelta)
263 : {
264 132 : double fZDelta(fZEyeB - fZEyeA);
265 132 : const double fInvZEyeA(fTools::equalZero(fZEyeA) ? fZEyeA : 1.0 / fZEyeA);
266 132 : double fInvZEyeB(fInvZEyeA);
267 :
268 132 : if(fTools::equalZero(fZDelta))
269 : {
270 0 : fZDelta = 0.0;
271 : }
272 : else
273 : {
274 132 : fInvZEyeB = fTools::equalZero(fZEyeB) ? fZEyeB : 1.0 / fZEyeB;
275 132 : fZDelta = (fInvZEyeB - fInvZEyeA) * fInvYDelta;
276 : }
277 :
278 132 : const B2DPoint aInvA(rA * fInvZEyeA);
279 264 : const B2DPoint aInvB(rB * fInvZEyeB);
280 132 : const double aDeltaX((aInvB.getX() - aInvA.getX()) * fInvYDelta);
281 132 : const double aDeltaY((aInvB.getY() - aInvA.getY()) * fInvYDelta);
282 :
283 : maInverseTextureInterpolators.push_back(
284 : ip_triple(
285 : aInvA.getX(), aDeltaX,
286 : aInvA.getY(), aDeltaY,
287 132 : fInvZEyeA, fZDelta));
288 :
289 264 : return (maInverseTextureInterpolators.size() - 1);
290 : }
291 :
292 38095 : void reset()
293 : {
294 38095 : maColorInterpolators.clear();
295 38095 : maNormalInterpolators.clear();
296 38095 : maTextureInterpolators.clear();
297 38095 : maInverseTextureInterpolators.clear();
298 38095 : }
299 :
300 : public:
301 21 : InterpolatorProvider3D() {}
302 :
303 12972 : ::std::vector< ip_triple >& getColorInterpolators() { return maColorInterpolators; }
304 0 : ::std::vector< ip_triple >& getNormalInterpolators() { return maNormalInterpolators; }
305 0 : ::std::vector< ip_double >& getTextureInterpolators() { return maTextureInterpolators; }
306 12972 : ::std::vector< ip_triple >& getInverseTextureInterpolators() { return maInverseTextureInterpolators; }
307 : };
308 : } // end of namespace basegfx
309 :
310 :
311 : // RasterConversionLineEntry3D for Raterconversion of 3D PolyPolygons
312 :
313 : namespace basegfx
314 : {
315 : class RasterConversionLineEntry3D
316 : {
317 : private:
318 : ip_single maX;
319 : ip_single maZ;
320 : sal_Int32 mnY;
321 : sal_uInt32 mnCount;
322 :
323 : sal_uInt32 mnColorIndex;
324 : sal_uInt32 mnNormalIndex;
325 : sal_uInt32 mnTextureIndex;
326 : sal_uInt32 mnInverseTextureIndex;
327 :
328 : public:
329 61558 : RasterConversionLineEntry3D(const double& rfX, const double& rfDeltaX, const double& rfZ, const double& rfDeltaZ, sal_Int32 nY, sal_uInt32 nCount)
330 : : maX(rfX, rfDeltaX),
331 : maZ(rfZ, rfDeltaZ),
332 : mnY(nY),
333 : mnCount(nCount),
334 : mnColorIndex(SCANLINE_EMPTY_INDEX),
335 : mnNormalIndex(SCANLINE_EMPTY_INDEX),
336 : mnTextureIndex(SCANLINE_EMPTY_INDEX),
337 61558 : mnInverseTextureIndex(SCANLINE_EMPTY_INDEX)
338 61558 : {}
339 :
340 132 : void setColorIndex(sal_uInt32 nIndex) { mnColorIndex = nIndex; }
341 0 : void setNormalIndex(sal_uInt32 nIndex) { mnNormalIndex = nIndex; }
342 0 : void setTextureIndex(sal_uInt32 nIndex) { mnTextureIndex = nIndex; }
343 132 : void setInverseTextureIndex(sal_uInt32 nIndex) { mnInverseTextureIndex = nIndex; }
344 :
345 65164 : bool operator<(const RasterConversionLineEntry3D& rComp) const
346 : {
347 65164 : if(mnY == rComp.mnY)
348 : {
349 43132 : return maX.getVal() < rComp.maX.getVal();
350 : }
351 :
352 22032 : return mnY < rComp.mnY;
353 : }
354 :
355 796058 : bool decrementRasterConversionLineEntry3D(sal_uInt32 nStep)
356 : {
357 796058 : if(nStep >= mnCount)
358 : {
359 61404 : return false;
360 : }
361 : else
362 : {
363 734654 : mnCount -= nStep;
364 734654 : return true;
365 : }
366 : }
367 :
368 734654 : void incrementRasterConversionLineEntry3D(sal_uInt32 nStep, InterpolatorProvider3D& rProvider)
369 : {
370 734654 : const double fStep((double)nStep);
371 734654 : maX.increment(fStep);
372 734654 : maZ.increment(fStep);
373 734654 : mnY += nStep;
374 :
375 734654 : if(SCANLINE_EMPTY_INDEX != mnColorIndex)
376 : {
377 6486 : rProvider.getColorInterpolators()[mnColorIndex].increment(fStep);
378 : }
379 :
380 734654 : if(SCANLINE_EMPTY_INDEX != mnNormalIndex)
381 : {
382 0 : rProvider.getNormalInterpolators()[mnNormalIndex].increment(fStep);
383 : }
384 :
385 734654 : if(SCANLINE_EMPTY_INDEX != mnTextureIndex)
386 : {
387 0 : rProvider.getTextureInterpolators()[mnTextureIndex].increment(fStep);
388 : }
389 :
390 734654 : if(SCANLINE_EMPTY_INDEX != mnInverseTextureIndex)
391 : {
392 6486 : rProvider.getInverseTextureInterpolators()[mnInverseTextureIndex].increment(fStep);
393 : }
394 734654 : }
395 :
396 : // data read access
397 3063795 : const ip_single& getX() const { return maX; }
398 200329 : sal_Int32 getY() const { return mnY; }
399 457336 : const ip_single& getZ() const { return maZ; }
400 237425 : sal_uInt32 getColorIndex() const { return mnColorIndex; }
401 227696 : sal_uInt32 getNormalIndex() const { return mnNormalIndex; }
402 227696 : sal_uInt32 getTextureIndex() const { return mnTextureIndex; }
403 237425 : sal_uInt32 getInverseTextureIndex() const { return mnInverseTextureIndex; }
404 : };
405 : } // end of namespace basegfx
406 :
407 :
408 : // the basic RaterConverter itself. Only one method needs to be overloaded. The
409 : // class itself is strictly virtual
410 :
411 : namespace basegfx
412 : {
413 : class BASEGFX_DLLPUBLIC RasterConverter3D : public InterpolatorProvider3D
414 : {
415 : private:
416 : // the line entries for an area conversion run
417 : ::std::vector< RasterConversionLineEntry3D > maLineEntries;
418 :
419 : struct lineComparator
420 : {
421 791084 : bool operator()(const RasterConversionLineEntry3D* pA, const RasterConversionLineEntry3D* pB)
422 : {
423 : OSL_ENSURE(pA && pB, "lineComparator: empty pointer (!)");
424 791084 : return pA->getX().getVal() < pB->getX().getVal();
425 : }
426 : };
427 :
428 : void addArea(const B3DPolygon& rFill, const B3DHomMatrix* pViewToEye);
429 : void addArea(const B3DPolyPolygon& rFill, const B3DHomMatrix* pViewToEye);
430 : void addEdge(const B3DPolygon& rFill, sal_uInt32 a, sal_uInt32 b, const B3DHomMatrix* pViewToEye);
431 :
432 : void rasterconvertB3DArea(sal_Int32 nStartLine, sal_Int32 nStopLine);
433 : void rasterconvertB3DEdge(const B3DPolygon& rLine, sal_uInt32 nA, sal_uInt32 nB, sal_Int32 nStartLine, sal_Int32 nStopLine, sal_uInt16 nLineWidth);
434 :
435 : virtual void processLineSpan(const RasterConversionLineEntry3D& rA, const RasterConversionLineEntry3D& rB, sal_Int32 nLine, sal_uInt32 nSpanCount) = 0;
436 :
437 : public:
438 : RasterConverter3D();
439 : virtual ~RasterConverter3D();
440 :
441 : void rasterconvertB3DPolyPolygon(const B3DPolyPolygon& rFill, const B3DHomMatrix* pViewToEye, sal_Int32 nStartLine, sal_Int32 nStopLine);
442 : void rasterconvertB3DPolygon(const B3DPolygon& rLine, sal_Int32 nStartLine, sal_Int32 nStopLine, sal_uInt16 nLineWidth);
443 : };
444 : } // end of namespace basegfx
445 :
446 :
447 :
448 : #endif // INCLUDED_BASEGFX_RASTER_RASTERCONVERT3D_HXX
449 :
450 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
