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 : #include <drawinglayer/primitive3d/sdrextrudeprimitive3d.hxx>
21 : #include <basegfx/matrix/b2dhommatrix.hxx>
22 : #include <basegfx/polygon/b2dpolygontools.hxx>
23 : #include <basegfx/polygon/b3dpolypolygontools.hxx>
24 : #include <drawinglayer/primitive3d/sdrdecompositiontools3d.hxx>
25 : #include <basegfx/tools/canvastools.hxx>
26 : #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
27 : #include <drawinglayer/geometry/viewinformation3d.hxx>
28 : #include <drawinglayer/attribute/sdrfillattribute.hxx>
29 : #include <drawinglayer/attribute/sdrlineattribute.hxx>
30 : #include <drawinglayer/attribute/sdrshadowattribute.hxx>
31 :
32 :
33 :
34 : using namespace com::sun::star;
35 :
36 :
37 :
38 : namespace drawinglayer
39 : {
40 : namespace primitive3d
41 : {
42 70 : Primitive3DSequence SdrExtrudePrimitive3D::create3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const
43 : {
44 70 : Primitive3DSequence aRetval;
45 :
46 : // get slices
47 70 : const Slice3DVector& rSliceVector = getSlices();
48 :
49 70 : if(!rSliceVector.empty())
50 : {
51 : sal_uInt32 a;
52 :
53 : // decide what to create
54 70 : const ::com::sun::star::drawing::NormalsKind eNormalsKind(getSdr3DObjectAttribute().getNormalsKind());
55 70 : const bool bCreateNormals(::com::sun::star::drawing::NormalsKind_SPECIFIC == eNormalsKind);
56 70 : const bool bCreateTextureCoordiantesX(::com::sun::star::drawing::TextureProjectionMode_OBJECTSPECIFIC == getSdr3DObjectAttribute().getTextureProjectionX());
57 70 : const bool bCreateTextureCoordiantesY(::com::sun::star::drawing::TextureProjectionMode_OBJECTSPECIFIC == getSdr3DObjectAttribute().getTextureProjectionY());
58 70 : basegfx::B2DHomMatrix aTexTransform;
59 :
60 70 : if(!getSdrLFSAttribute().getFill().isDefault() && (bCreateTextureCoordiantesX || bCreateTextureCoordiantesY))
61 : {
62 16 : const basegfx::B2DPolygon aFirstPolygon(maCorrectedPolyPolygon.getB2DPolygon(0L));
63 16 : const double fFrontLength(basegfx::tools::getLength(aFirstPolygon));
64 16 : const double fFrontArea(basegfx::tools::getArea(aFirstPolygon));
65 16 : const double fSqrtFrontArea(sqrt(fFrontArea));
66 16 : double fRelativeTextureWidth = basegfx::fTools::equalZero(fSqrtFrontArea) ? 1.0 : fFrontLength / fSqrtFrontArea;
67 16 : fRelativeTextureWidth = (double)((sal_uInt32)(fRelativeTextureWidth - 0.5));
68 :
69 16 : if(fRelativeTextureWidth < 1.0)
70 : {
71 0 : fRelativeTextureWidth = 1.0;
72 : }
73 :
74 16 : aTexTransform.translate(-0.5, -0.5);
75 16 : aTexTransform.scale(-1.0, -1.0);
76 16 : aTexTransform.translate(0.5, 0.5);
77 16 : aTexTransform.scale(fRelativeTextureWidth, 1.0);
78 : }
79 :
80 : // create geometry
81 140 : ::std::vector< basegfx::B3DPolyPolygon > aFill;
82 : extractPlanesFromSlice(aFill, rSliceVector,
83 210 : bCreateNormals, getSmoothHorizontalNormals(), getSmoothNormals(), getSmoothLids(), false,
84 280 : 0.5, 0.6, bCreateTextureCoordiantesX || bCreateTextureCoordiantesY, aTexTransform);
85 :
86 : // get full range
87 70 : const basegfx::B3DRange aRange(getRangeFrom3DGeometry(aFill));
88 :
89 : // normal creation
90 70 : if(!getSdrLFSAttribute().getFill().isDefault())
91 : {
92 70 : if(::com::sun::star::drawing::NormalsKind_SPHERE == eNormalsKind)
93 : {
94 0 : applyNormalsKindSphereTo3DGeometry(aFill, aRange);
95 : }
96 70 : else if(::com::sun::star::drawing::NormalsKind_FLAT == eNormalsKind)
97 : {
98 0 : applyNormalsKindFlatTo3DGeometry(aFill);
99 : }
100 :
101 70 : if(getSdr3DObjectAttribute().getNormalsInvert())
102 : {
103 0 : applyNormalsInvertTo3DGeometry(aFill);
104 : }
105 : }
106 :
107 : // texture coordinates
108 70 : if(!getSdrLFSAttribute().getFill().isDefault())
109 : {
110 : applyTextureTo3DGeometry(
111 : getSdr3DObjectAttribute().getTextureProjectionX(),
112 : getSdr3DObjectAttribute().getTextureProjectionY(),
113 : aFill,
114 : aRange,
115 70 : getTextureSize());
116 : }
117 :
118 70 : if(!getSdrLFSAttribute().getFill().isDefault())
119 : {
120 : // add fill
121 210 : aRetval = create3DPolyPolygonFillPrimitives(
122 : aFill,
123 70 : getTransform(),
124 70 : getTextureSize(),
125 : getSdr3DObjectAttribute(),
126 70 : getSdrLFSAttribute().getFill(),
127 140 : getSdrLFSAttribute().getFillFloatTransGradient());
128 : }
129 : else
130 : {
131 : // create simplified 3d hit test geometry
132 0 : aRetval = createHiddenGeometryPrimitives3D(
133 : aFill,
134 0 : getTransform(),
135 0 : getTextureSize(),
136 0 : getSdr3DObjectAttribute());
137 : }
138 :
139 : // add line
140 70 : if(!getSdrLFSAttribute().getLine().isDefault())
141 : {
142 0 : if(getSdr3DObjectAttribute().getReducedLineGeometry())
143 : {
144 : // create geometric outlines with reduced line geometry for chart.
145 0 : const basegfx::B3DPolyPolygon aVerLine(extractVerticalLinesFromSlice(rSliceVector));
146 0 : const sal_uInt32 nCount(aVerLine.count());
147 0 : basegfx::B3DPolyPolygon aReducedLoops;
148 0 : basegfx::B3DPolyPolygon aNewLineGeometry;
149 :
150 : // sort out doubles (front and back planes when no edge rounding is done). Since
151 : // this is a line geometry merged from PolyPolygons, loop over all Polygons
152 0 : for(a = 0; a < nCount; a++)
153 : {
154 0 : const sal_uInt32 nReducedCount(aReducedLoops.count());
155 0 : const basegfx::B3DPolygon aCandidate(aVerLine.getB3DPolygon(a));
156 0 : bool bAdd(true);
157 :
158 0 : if(nReducedCount)
159 : {
160 0 : for(sal_uInt32 b(0); bAdd && b < nReducedCount; b++)
161 : {
162 0 : if(aCandidate == aReducedLoops.getB3DPolygon(b))
163 : {
164 0 : bAdd = false;
165 : }
166 : }
167 : }
168 :
169 0 : if(bAdd)
170 : {
171 0 : aReducedLoops.append(aCandidate);
172 : }
173 0 : }
174 :
175 : // from here work with reduced loops and reduced count without changing them
176 0 : const sal_uInt32 nReducedCount(aReducedLoops.count());
177 :
178 0 : if(nReducedCount > 1)
179 : {
180 0 : for(sal_uInt32 b(1); b < nReducedCount; b++)
181 : {
182 : // get loop pair
183 0 : const basegfx::B3DPolygon aCandA(aReducedLoops.getB3DPolygon(b - 1));
184 0 : const basegfx::B3DPolygon aCandB(aReducedLoops.getB3DPolygon(b));
185 :
186 : // for each loop pair create the connection edges
187 : createReducedOutlines(
188 : rViewInformation,
189 0 : getTransform(),
190 : aCandA,
191 : aCandB,
192 0 : aNewLineGeometry);
193 0 : }
194 : }
195 :
196 : // add reduced loops themselves
197 0 : aNewLineGeometry.append(aReducedLoops);
198 :
199 : // to create vertical edges at non-C1/C2 steady loops, use maCorrectedPolyPolygon
200 : // directly since the 3D Polygons do not support this.
201 : //
202 : // Unfortunately there is no bezier polygon provided by the chart module; one reason is
203 : // that the API for extrude wants a 3D polygon geometry (for historical reasons, i guess)
204 : // and those have no beziers. Another reason is that he chart module uses self-created
205 : // stuff to create the 2D geometry (in ShapeFactory::createPieSegment), but this geometry
206 : // does not contain bezier infos, either. The only way which is possible for now is to 'detect'
207 : // candidates for vertical edges of pie segments by looking for the angles in the polygon.
208 : //
209 : // This is all not very well designed ATM. Ideally, the ReducedLineGeometry is responsible
210 : // for creating the outer geometry edges (createReducedOutlines), but for special edges
211 : // like the vertical ones for pie center and both start/end, the incarnation with the
212 : // knowledge about that it needs to create those and IS a pie segment -> in this case,
213 : // the chart itself.
214 0 : const sal_uInt32 nPolyCount(maCorrectedPolyPolygon.count());
215 :
216 0 : for(sal_uInt32 c(0); c < nPolyCount; c++)
217 : {
218 0 : const basegfx::B2DPolygon aCandidate(maCorrectedPolyPolygon.getB2DPolygon(c));
219 0 : const sal_uInt32 nPointCount(aCandidate.count());
220 :
221 0 : if(nPointCount > 2)
222 : {
223 0 : sal_uInt32 nIndexA(nPointCount);
224 0 : sal_uInt32 nIndexB(nPointCount);
225 0 : sal_uInt32 nIndexC(nPointCount);
226 :
227 0 : for(sal_uInt32 d(0); d < nPointCount; d++)
228 : {
229 0 : const sal_uInt32 nPrevInd((d + nPointCount - 1) % nPointCount);
230 0 : const sal_uInt32 nNextInd((d + 1) % nPointCount);
231 0 : const basegfx::B2DPoint aPoint(aCandidate.getB2DPoint(d));
232 0 : const basegfx::B2DVector aPrev(aCandidate.getB2DPoint(nPrevInd) - aPoint);
233 0 : const basegfx::B2DVector aNext(aCandidate.getB2DPoint(nNextInd) - aPoint);
234 0 : const double fAngle(aPrev.angle(aNext));
235 :
236 : // take each angle which deviates more than 10% from going straight as
237 : // special edge. This will detect the two outer edges of pie segments,
238 : // but not always the center one (think about a near 180 degree pie)
239 0 : if(F_PI - fabs(fAngle) > F_PI * 0.1)
240 : {
241 0 : if(nPointCount == nIndexA)
242 : {
243 0 : nIndexA = d;
244 : }
245 0 : else if(nPointCount == nIndexB)
246 : {
247 0 : nIndexB = d;
248 : }
249 0 : else if(nPointCount == nIndexC)
250 : {
251 0 : nIndexC = d;
252 0 : d = nPointCount;
253 : }
254 : }
255 0 : }
256 :
257 0 : const bool bIndexAUsed(nIndexA != nPointCount);
258 0 : const bool bIndexBUsed(nIndexB != nPointCount);
259 0 : bool bIndexCUsed(nIndexC != nPointCount);
260 :
261 0 : if(bIndexCUsed)
262 : {
263 : // already three special edges found, so the center one was already detected
264 : // and does not need to be searched
265 : }
266 0 : else if(bIndexAUsed && bIndexBUsed)
267 : {
268 : // outer edges detected (they are approx. 90 degrees), but center one not.
269 : // Look with the knowledge that it's in-between the two found ones
270 0 : if(((nIndexA + 2) % nPointCount) == nIndexB)
271 : {
272 0 : nIndexC = (nIndexA + 1) % nPointCount;
273 : }
274 0 : else if(((nIndexA + nPointCount - 2) % nPointCount) == nIndexB)
275 : {
276 0 : nIndexC = (nIndexA + nPointCount - 1) % nPointCount;
277 : }
278 :
279 0 : bIndexCUsed = (nIndexC != nPointCount);
280 : }
281 :
282 0 : if(bIndexAUsed)
283 : {
284 0 : const basegfx::B2DPoint aPoint(aCandidate.getB2DPoint(nIndexA));
285 0 : const basegfx::B3DPoint aStart(aPoint.getX(), aPoint.getY(), 0.0);
286 0 : const basegfx::B3DPoint aEnd(aPoint.getX(), aPoint.getY(), getDepth());
287 0 : basegfx::B3DPolygon aToBeAdded;
288 :
289 0 : aToBeAdded.append(aStart);
290 0 : aToBeAdded.append(aEnd);
291 0 : aNewLineGeometry.append(aToBeAdded);
292 : }
293 :
294 0 : if(bIndexBUsed)
295 : {
296 0 : const basegfx::B2DPoint aPoint(aCandidate.getB2DPoint(nIndexB));
297 0 : const basegfx::B3DPoint aStart(aPoint.getX(), aPoint.getY(), 0.0);
298 0 : const basegfx::B3DPoint aEnd(aPoint.getX(), aPoint.getY(), getDepth());
299 0 : basegfx::B3DPolygon aToBeAdded;
300 :
301 0 : aToBeAdded.append(aStart);
302 0 : aToBeAdded.append(aEnd);
303 0 : aNewLineGeometry.append(aToBeAdded);
304 : }
305 :
306 0 : if(bIndexCUsed)
307 : {
308 0 : const basegfx::B2DPoint aPoint(aCandidate.getB2DPoint(nIndexC));
309 0 : const basegfx::B3DPoint aStart(aPoint.getX(), aPoint.getY(), 0.0);
310 0 : const basegfx::B3DPoint aEnd(aPoint.getX(), aPoint.getY(), getDepth());
311 0 : basegfx::B3DPolygon aToBeAdded;
312 :
313 0 : aToBeAdded.append(aStart);
314 0 : aToBeAdded.append(aEnd);
315 0 : aNewLineGeometry.append(aToBeAdded);
316 : }
317 : }
318 0 : }
319 :
320 : // append loops themselves
321 0 : aNewLineGeometry.append(aReducedLoops);
322 :
323 0 : if(aNewLineGeometry.count())
324 : {
325 : const Primitive3DSequence aLines(create3DPolyPolygonLinePrimitives(
326 0 : aNewLineGeometry, getTransform(), getSdrLFSAttribute().getLine()));
327 0 : appendPrimitive3DSequenceToPrimitive3DSequence(aRetval, aLines);
328 0 : }
329 : }
330 : else
331 : {
332 : // extract line geometry from slices
333 0 : const basegfx::B3DPolyPolygon aHorLine(extractHorizontalLinesFromSlice(rSliceVector, false));
334 0 : const basegfx::B3DPolyPolygon aVerLine(extractVerticalLinesFromSlice(rSliceVector));
335 :
336 : // add horizontal lines
337 : const Primitive3DSequence aHorLines(create3DPolyPolygonLinePrimitives(
338 0 : aHorLine, getTransform(), getSdrLFSAttribute().getLine()));
339 0 : appendPrimitive3DSequenceToPrimitive3DSequence(aRetval, aHorLines);
340 :
341 : // add vertical lines
342 : const Primitive3DSequence aVerLines(create3DPolyPolygonLinePrimitives(
343 0 : aVerLine, getTransform(), getSdrLFSAttribute().getLine()));
344 0 : appendPrimitive3DSequenceToPrimitive3DSequence(aRetval, aVerLines);
345 : }
346 : }
347 :
348 : // add shadow
349 70 : if(!getSdrLFSAttribute().getShadow().isDefault() && aRetval.hasElements())
350 : {
351 : const Primitive3DSequence aShadow(createShadowPrimitive3D(
352 0 : aRetval, getSdrLFSAttribute().getShadow(), getSdr3DObjectAttribute().getShadow3D()));
353 0 : appendPrimitive3DSequenceToPrimitive3DSequence(aRetval, aShadow);
354 70 : }
355 : }
356 :
357 70 : return aRetval;
358 : }
359 :
360 3261 : void SdrExtrudePrimitive3D::impCreateSlices()
361 : {
362 : // prepare the polygon. No double points, correct orientations and a correct
363 : // outmost polygon are needed
364 : // Also important: subdivide here to ensure equal point count for all slices (!)
365 3261 : maCorrectedPolyPolygon = basegfx::tools::adaptiveSubdivideByAngle(getPolyPolygon());
366 3261 : maCorrectedPolyPolygon.removeDoublePoints();
367 3261 : maCorrectedPolyPolygon = basegfx::tools::correctOrientations(maCorrectedPolyPolygon);
368 3261 : maCorrectedPolyPolygon = basegfx::tools::correctOutmostPolygon(maCorrectedPolyPolygon);
369 :
370 : // prepare slices as geometry
371 3261 : createExtrudeSlices(maSlices, maCorrectedPolyPolygon, getBackScale(), getDiagonal(), getDepth(), getCharacterMode(), getCloseFront(), getCloseBack());
372 3261 : }
373 :
374 3652 : const Slice3DVector& SdrExtrudePrimitive3D::getSlices() const
375 : {
376 : // This can be made dependent of getSdrLFSAttribute().getFill() and getSdrLFSAttribute().getLine()
377 : // again when no longer geometry is needed for non-visible 3D objects as it is now for chart
378 3652 : if(getPolyPolygon().count() && !maSlices.size())
379 : {
380 3261 : const_cast< SdrExtrudePrimitive3D& >(*this).impCreateSlices();
381 : }
382 :
383 3652 : return maSlices;
384 : }
385 :
386 3520 : SdrExtrudePrimitive3D::SdrExtrudePrimitive3D(
387 : const basegfx::B3DHomMatrix& rTransform,
388 : const basegfx::B2DVector& rTextureSize,
389 : const attribute::SdrLineFillShadowAttribute3D& rSdrLFSAttribute,
390 : const attribute::Sdr3DObjectAttribute& rSdr3DObjectAttribute,
391 : const basegfx::B2DPolyPolygon& rPolyPolygon,
392 : double fDepth,
393 : double fDiagonal,
394 : double fBackScale,
395 : bool bSmoothNormals,
396 : bool bSmoothHorizontalNormals,
397 : bool bSmoothLids,
398 : bool bCharacterMode,
399 : bool bCloseFront,
400 : bool bCloseBack)
401 : : SdrPrimitive3D(rTransform, rTextureSize, rSdrLFSAttribute, rSdr3DObjectAttribute),
402 : maCorrectedPolyPolygon(),
403 : maSlices(),
404 : maPolyPolygon(rPolyPolygon),
405 : mfDepth(fDepth),
406 : mfDiagonal(fDiagonal),
407 : mfBackScale(fBackScale),
408 : mpLastRLGViewInformation(0),
409 : mbSmoothNormals(bSmoothNormals),
410 : mbSmoothHorizontalNormals(bSmoothHorizontalNormals),
411 : mbSmoothLids(bSmoothLids),
412 : mbCharacterMode(bCharacterMode),
413 : mbCloseFront(bCloseFront),
414 3520 : mbCloseBack(bCloseBack)
415 : {
416 : // make sure depth is positive
417 3520 : if(basegfx::fTools::lessOrEqual(getDepth(), 0.0))
418 : {
419 0 : mfDepth = 0.0;
420 : }
421 :
422 : // make sure the percentage value getDiagonal() is between 0.0 and 1.0
423 3520 : if(basegfx::fTools::lessOrEqual(getDiagonal(), 0.0))
424 : {
425 3402 : mfDiagonal = 0.0;
426 : }
427 118 : else if(basegfx::fTools::moreOrEqual(getDiagonal(), 1.0))
428 : {
429 0 : mfDiagonal = 1.0;
430 : }
431 :
432 : // no close front/back when polygon is not closed
433 3520 : if(getPolyPolygon().count() && !getPolyPolygon().getB2DPolygon(0L).isClosed())
434 : {
435 0 : mbCloseFront = mbCloseBack = false;
436 : }
437 :
438 : // no edge rounding when not closing
439 3520 : if(!getCloseFront() && !getCloseBack())
440 : {
441 0 : mfDiagonal = 0.0;
442 : }
443 3520 : }
444 :
445 10560 : SdrExtrudePrimitive3D::~SdrExtrudePrimitive3D()
446 : {
447 3520 : if(mpLastRLGViewInformation)
448 : {
449 8 : delete mpLastRLGViewInformation;
450 : }
451 7040 : }
452 :
453 296 : bool SdrExtrudePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
454 : {
455 296 : if(SdrPrimitive3D::operator==(rPrimitive))
456 : {
457 271 : const SdrExtrudePrimitive3D& rCompare = static_cast< const SdrExtrudePrimitive3D& >(rPrimitive);
458 :
459 271 : return (getPolyPolygon() == rCompare.getPolyPolygon()
460 271 : && getDepth() == rCompare.getDepth()
461 271 : && getDiagonal() == rCompare.getDiagonal()
462 271 : && getBackScale() == rCompare.getBackScale()
463 271 : && getSmoothNormals() == rCompare.getSmoothNormals()
464 271 : && getSmoothHorizontalNormals() == rCompare.getSmoothHorizontalNormals()
465 271 : && getSmoothLids() == rCompare.getSmoothLids()
466 271 : && getCharacterMode() == rCompare.getCharacterMode()
467 271 : && getCloseFront() == rCompare.getCloseFront()
468 542 : && getCloseBack() == rCompare.getCloseBack());
469 : }
470 :
471 25 : return false;
472 : }
473 :
474 3582 : basegfx::B3DRange SdrExtrudePrimitive3D::getB3DRange(const geometry::ViewInformation3D& /*rViewInformation*/) const
475 : {
476 : // use default from sdrPrimitive3D which uses transformation expanded by line width/2
477 : // The parent implementation which uses the ranges of the decomposition would be more
478 : // correct, but for historical reasons it is necessary to do the old method: To get
479 : // the range of the non-transformed geometry and transform it then. This leads to different
480 : // ranges where the new method is more correct, but the need to keep the old behaviour
481 : // has priority here.
482 3582 : return get3DRangeFromSlices(getSlices());
483 : }
484 :
485 106 : Primitive3DSequence SdrExtrudePrimitive3D::get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const
486 : {
487 106 : if(getSdr3DObjectAttribute().getReducedLineGeometry())
488 : {
489 40 : if(!mpLastRLGViewInformation ||
490 8 : (getBuffered3DDecomposition().hasElements()
491 8 : && *mpLastRLGViewInformation != rViewInformation))
492 : {
493 : // conditions of last local decomposition with reduced lines have changed. Remember
494 : // new one and clear current decompositiopn
495 16 : SdrExtrudePrimitive3D* pThat = const_cast< SdrExtrudePrimitive3D* >(this);
496 16 : pThat->setBuffered3DDecomposition(Primitive3DSequence());
497 16 : delete pThat->mpLastRLGViewInformation;
498 16 : pThat->mpLastRLGViewInformation = new geometry::ViewInformation3D(rViewInformation);
499 : }
500 : }
501 :
502 : // no test for buffering needed, call parent
503 106 : return SdrPrimitive3D::get3DDecomposition(rViewInformation);
504 : }
505 :
506 : // provide unique ID
507 698 : ImplPrimitive3DIDBlock(SdrExtrudePrimitive3D, PRIMITIVE3D_ID_SDREXTRUDEPRIMITIVE3D)
508 :
509 : } // end of namespace primitive3d
510 : } // end of namespace drawinglayer
511 :
512 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
