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/processor3d/defaultprocessor3d.hxx>
21 : #include <drawinglayer/primitive3d/textureprimitive3d.hxx>
22 : #include <drawinglayer/texture/texture.hxx>
23 : #include <drawinglayer/texture/texture3d.hxx>
24 : #include <drawinglayer/primitive3d/hatchtextureprimitive3d.hxx>
25 : #include <drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx>
26 : #include <drawinglayer/primitive3d/polygonprimitive3d.hxx>
27 : #include <basegfx/polygon/b3dpolygontools.hxx>
28 : #include <drawinglayer/attribute/materialattribute3d.hxx>
29 : #include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
30 : #include <basegfx/polygon/b3dpolypolygontools.hxx>
31 : #include <com/sun/star/drawing/ShadeMode.hpp>
32 : #include <drawinglayer/primitive3d/transformprimitive3d.hxx>
33 : #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
34 : #include <vcl/bitmapex.hxx>
35 : #include <drawinglayer/attribute/sdrsceneattribute3d.hxx>
36 : #include <drawinglayer/attribute/sdrlightingattribute3d.hxx>
37 : #include <vcl/graph.hxx>
38 : #include <basegfx/matrix/b2dhommatrixtools.hxx>
39 :
40 :
41 :
42 : using namespace com::sun::star;
43 :
44 :
45 :
46 : namespace drawinglayer
47 : {
48 : namespace processor3d
49 : {
50 40 : void DefaultProcessor3D::impRenderGradientTexturePrimitive3D(const primitive3d::GradientTexturePrimitive3D& rPrimitive, bool bTransparence)
51 : {
52 40 : const primitive3d::Primitive3DSequence& rSubSequence = rPrimitive.getChildren();
53 :
54 40 : if(rSubSequence.hasElements())
55 : {
56 : // rescue values
57 40 : const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate();
58 40 : const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter();
59 40 : const bool bOldSimpleTextureActive(getSimpleTextureActive());
60 40 : boost::shared_ptr< texture::GeoTexSvx > pOldTex = (bTransparence) ? mpTransparenceGeoTexSvx : mpGeoTexSvx;
61 :
62 : // create texture
63 40 : const attribute::FillGradientAttribute& rFillGradient = rPrimitive.getGradient();
64 40 : const basegfx::B2DRange aOutlineRange(0.0, 0.0, rPrimitive.getTextureSize().getX(), rPrimitive.getTextureSize().getY());
65 40 : const attribute::GradientStyle aGradientStyle(rFillGradient.getStyle());
66 40 : sal_uInt32 nSteps(rFillGradient.getSteps());
67 80 : const basegfx::BColor aStart(rFillGradient.getStartColor());
68 80 : const basegfx::BColor aEnd(rFillGradient.getEndColor());
69 40 : const sal_uInt32 nMaxSteps(sal_uInt32((aStart.getMaximumDistance(aEnd) * 127.5) + 0.5));
70 80 : boost::shared_ptr< texture::GeoTexSvx > pNewTex;
71 :
72 40 : if(nMaxSteps)
73 : {
74 : // there IS a color distance
75 40 : if(nSteps == 0L)
76 : {
77 40 : nSteps = nMaxSteps;
78 : }
79 :
80 40 : if(nSteps < 2L)
81 : {
82 0 : nSteps = 2L;
83 : }
84 :
85 40 : if(nSteps > nMaxSteps)
86 : {
87 0 : nSteps = nMaxSteps;
88 : }
89 :
90 40 : switch(aGradientStyle)
91 : {
92 : case attribute::GRADIENTSTYLE_LINEAR:
93 : {
94 : pNewTex.reset(
95 : new texture::GeoTexSvxGradientLinear(
96 : aOutlineRange,
97 : aOutlineRange,
98 : aStart,
99 : aEnd,
100 : nSteps,
101 : rFillGradient.getBorder(),
102 20 : rFillGradient.getAngle()));
103 20 : break;
104 : }
105 : case attribute::GRADIENTSTYLE_AXIAL:
106 : {
107 : pNewTex.reset(
108 : new texture::GeoTexSvxGradientAxial(
109 : aOutlineRange,
110 : aOutlineRange,
111 : aStart,
112 : aEnd,
113 : nSteps,
114 : rFillGradient.getBorder(),
115 20 : rFillGradient.getAngle()));
116 20 : break;
117 : }
118 : case attribute::GRADIENTSTYLE_RADIAL:
119 : {
120 : pNewTex.reset(
121 : new texture::GeoTexSvxGradientRadial(
122 : aOutlineRange,
123 : aStart,
124 : aEnd,
125 : nSteps,
126 : rFillGradient.getBorder(),
127 : rFillGradient.getOffsetX(),
128 0 : rFillGradient.getOffsetY()));
129 0 : break;
130 : }
131 : case attribute::GRADIENTSTYLE_ELLIPTICAL:
132 : {
133 : pNewTex.reset(
134 : new texture::GeoTexSvxGradientElliptical(
135 : aOutlineRange,
136 : aStart,
137 : aEnd,
138 : nSteps,
139 : rFillGradient.getBorder(),
140 : rFillGradient.getOffsetX(),
141 : rFillGradient.getOffsetY(),
142 0 : rFillGradient.getAngle()));
143 0 : break;
144 : }
145 : case attribute::GRADIENTSTYLE_SQUARE:
146 : {
147 : pNewTex.reset(
148 : new texture::GeoTexSvxGradientSquare(
149 : aOutlineRange,
150 : aStart,
151 : aEnd,
152 : nSteps,
153 : rFillGradient.getBorder(),
154 : rFillGradient.getOffsetX(),
155 : rFillGradient.getOffsetY(),
156 0 : rFillGradient.getAngle()));
157 0 : break;
158 : }
159 : case attribute::GRADIENTSTYLE_RECT:
160 : {
161 : pNewTex.reset(
162 : new texture::GeoTexSvxGradientRect(
163 : aOutlineRange,
164 : aStart,
165 : aEnd,
166 : nSteps,
167 : rFillGradient.getBorder(),
168 : rFillGradient.getOffsetX(),
169 : rFillGradient.getOffsetY(),
170 0 : rFillGradient.getAngle()));
171 0 : break;
172 : }
173 : }
174 :
175 40 : mbSimpleTextureActive = false;
176 : }
177 : else
178 : {
179 : // no color distance -> same color, use simple texture
180 0 : pNewTex.reset(new texture::GeoTexSvxMono(aStart, 1.0 - aStart.luminance()));
181 0 : mbSimpleTextureActive = true;
182 : }
183 :
184 : // set created texture
185 40 : if(bTransparence)
186 : {
187 40 : mpTransparenceGeoTexSvx = pNewTex;
188 : }
189 : else
190 : {
191 0 : mpGeoTexSvx = pNewTex;
192 : }
193 :
194 : // process sub-list
195 40 : process(rSubSequence);
196 :
197 : // restore values
198 40 : mbModulate = bOldModulate;
199 40 : mbFilter = bOldFilter;
200 40 : mbSimpleTextureActive = bOldSimpleTextureActive;
201 :
202 40 : if(bTransparence)
203 : {
204 40 : mpTransparenceGeoTexSvx = pOldTex;
205 : }
206 : else
207 : {
208 0 : mpGeoTexSvx = pOldTex;
209 40 : }
210 40 : }
211 40 : }
212 :
213 20 : void DefaultProcessor3D::impRenderHatchTexturePrimitive3D(const primitive3d::HatchTexturePrimitive3D& rPrimitive)
214 : {
215 20 : const primitive3d::Primitive3DSequence& rSubSequence = rPrimitive.getChildren();
216 :
217 20 : if(rSubSequence.hasElements())
218 : {
219 : // rescue values
220 20 : const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate();
221 20 : const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter();
222 20 : boost::shared_ptr< texture::GeoTexSvx > pOldTex = mpGeoTexSvx;
223 :
224 : // calculate logic pixel size in object coordinates. Create transformation view
225 : // to object by inverting ObjectToView
226 40 : basegfx::B3DHomMatrix aInvObjectToView(getViewInformation3D().getObjectToView());
227 20 : aInvObjectToView.invert();
228 :
229 : // back-project discrete coordinates to object coordinates and extract
230 : // maximum distance
231 40 : const basegfx::B3DPoint aZero(aInvObjectToView * basegfx::B3DPoint(0.0, 0.0, 0.0));
232 40 : const basegfx::B3DPoint aOne(aInvObjectToView * basegfx::B3DPoint(1.0, 1.0, 1.0));
233 40 : const basegfx::B3DVector aLogicPixel(aOne - aZero);
234 20 : double fLogicPixelSizeWorld(::std::max(::std::max(fabs(aLogicPixel.getX()), fabs(aLogicPixel.getY())), fabs(aLogicPixel.getZ())));
235 :
236 : // calculate logic pixel size in texture coordinates
237 20 : const double fLogicTexSizeX(fLogicPixelSizeWorld / rPrimitive.getTextureSize().getX());
238 20 : const double fLogicTexSizeY(fLogicPixelSizeWorld / rPrimitive.getTextureSize().getY());
239 20 : const double fLogicTexSize(fLogicTexSizeX > fLogicTexSizeY ? fLogicTexSizeX : fLogicTexSizeY);
240 :
241 : // create texture and set
242 20 : mpGeoTexSvx.reset(new texture::GeoTexSvxMultiHatch(rPrimitive, fLogicTexSize));
243 :
244 : // process sub-list
245 20 : process(rSubSequence);
246 :
247 : // restore values
248 20 : mbModulate = bOldModulate;
249 20 : mbFilter = bOldFilter;
250 40 : mpGeoTexSvx = pOldTex;
251 20 : }
252 20 : }
253 :
254 0 : void DefaultProcessor3D::impRenderBitmapTexturePrimitive3D(const primitive3d::BitmapTexturePrimitive3D& rPrimitive)
255 : {
256 0 : const primitive3d::Primitive3DSequence& rSubSequence = rPrimitive.getChildren();
257 :
258 0 : if(rSubSequence.hasElements())
259 : {
260 : // rescue values
261 0 : const bool bOldModulate(getModulate()); mbModulate = rPrimitive.getModulate();
262 0 : const bool bOldFilter(getFilter()); mbFilter = rPrimitive.getFilter();
263 0 : boost::shared_ptr< texture::GeoTexSvx > pOldTex = mpGeoTexSvx;
264 :
265 : // create texture
266 0 : const attribute::FillGraphicAttribute& rFillGraphicAttribute = rPrimitive.getFillGraphicAttribute();
267 :
268 : // #121194# For 3D texture we will use the BitmapRex representation
269 0 : const BitmapEx aBitmapEx(rFillGraphicAttribute.getGraphic().GetBitmapEx());
270 :
271 : // create range scaled by texture size
272 0 : basegfx::B2DRange aGraphicRange(rFillGraphicAttribute.getGraphicRange());
273 :
274 : aGraphicRange.transform(
275 : basegfx::tools::createScaleB2DHomMatrix(
276 0 : rPrimitive.getTextureSize()));
277 :
278 0 : if(rFillGraphicAttribute.getTiling())
279 : {
280 : mpGeoTexSvx.reset(
281 : new texture::GeoTexSvxBitmapExTiled(
282 : aBitmapEx,
283 : aGraphicRange,
284 : rFillGraphicAttribute.getOffsetX(),
285 0 : rFillGraphicAttribute.getOffsetY()));
286 : }
287 : else
288 : {
289 : mpGeoTexSvx.reset(
290 : new texture::GeoTexSvxBitmapEx(
291 : aBitmapEx,
292 0 : aGraphicRange));
293 : }
294 :
295 : // process sub-list
296 0 : process(rSubSequence);
297 :
298 : // restore values
299 0 : mbModulate = bOldModulate;
300 0 : mbFilter = bOldFilter;
301 0 : mpGeoTexSvx = pOldTex;
302 0 : }
303 0 : }
304 :
305 0 : void DefaultProcessor3D::impRenderModifiedColorPrimitive3D(const primitive3d::ModifiedColorPrimitive3D& rModifiedCandidate)
306 : {
307 0 : const primitive3d::Primitive3DSequence& rSubSequence = rModifiedCandidate.getChildren();
308 :
309 0 : if(rSubSequence.hasElements())
310 : {
311 : // put modifier on stack
312 0 : maBColorModifierStack.push(rModifiedCandidate.getColorModifier());
313 :
314 : // process sub-list
315 0 : process(rModifiedCandidate.getChildren());
316 :
317 : // remove modifier from stack
318 0 : maBColorModifierStack.pop();
319 0 : }
320 0 : }
321 :
322 118 : void DefaultProcessor3D::impRenderPolygonHairlinePrimitive3D(const primitive3d::PolygonHairlinePrimitive3D& rPrimitive)
323 : {
324 118 : basegfx::B3DPolygon aHairline(rPrimitive.getB3DPolygon());
325 :
326 118 : if(aHairline.count())
327 : {
328 : // hairlines need no extra data, clear it
329 118 : aHairline.clearTextureCoordinates();
330 118 : aHairline.clearNormals();
331 118 : aHairline.clearBColors();
332 :
333 : // transform to device coordinates (-1.0 .. 1.0) and check for visibility
334 118 : aHairline.transform(getViewInformation3D().getObjectToView());
335 118 : const basegfx::B3DRange a3DRange(basegfx::tools::getRange(aHairline));
336 118 : const basegfx::B2DRange a2DRange(a3DRange.getMinX(), a3DRange.getMinY(), a3DRange.getMaxX(), a3DRange.getMaxY());
337 :
338 118 : if(a2DRange.overlaps(maRasterRange))
339 : {
340 115 : const attribute::MaterialAttribute3D aMaterial(maBColorModifierStack.getModifiedColor(rPrimitive.getBColor()));
341 :
342 115 : rasterconvertB3DPolygon(aMaterial, aHairline);
343 : }
344 118 : }
345 118 : }
346 :
347 36815 : void DefaultProcessor3D::impRenderPolyPolygonMaterialPrimitive3D(const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive)
348 : {
349 36815 : basegfx::B3DPolyPolygon aFill(rPrimitive.getB3DPolyPolygon());
350 73630 : basegfx::BColor aObjectColor(rPrimitive.getMaterial().getColor());
351 36815 : bool bPaintIt(aFill.count());
352 :
353 : // #i98295# get ShadeMode. Correct early when only flat is possible due to missing normals
354 : const ::com::sun::star::drawing::ShadeMode aShadeMode(
355 36815 : aFill.areNormalsUsed() ?
356 36815 : getSdrSceneAttribute().getShadeMode() : ::com::sun::star::drawing::ShadeMode_FLAT);
357 :
358 36815 : if(bPaintIt)
359 : {
360 : // get rid of texture coordinates if there is no texture
361 36815 : if(aFill.areTextureCoordinatesUsed() && !getGeoTexSvx().get() && !getTransparenceGeoTexSvx().get())
362 : {
363 3975 : aFill.clearTextureCoordinates();
364 : }
365 :
366 : // #i98295# get rid of normals and color early when not needed
367 36815 : if(::com::sun::star::drawing::ShadeMode_FLAT == aShadeMode)
368 : {
369 36455 : aFill.clearNormals();
370 36455 : aFill.clearBColors();
371 : }
372 :
373 : // transform to device coordinates (-1.0 .. 1.0) and check for visibility
374 36815 : aFill.transform(getViewInformation3D().getObjectToView());
375 36815 : const basegfx::B3DRange a3DRange(basegfx::tools::getRange(aFill));
376 36815 : const basegfx::B2DRange a2DRange(a3DRange.getMinX(), a3DRange.getMinY(), a3DRange.getMaxX(), a3DRange.getMaxY());
377 :
378 36815 : bPaintIt = a2DRange.overlaps(maRasterRange);
379 : }
380 :
381 : // check if it shall be painted regarding hiding of normals (backface culling)
382 36815 : if(bPaintIt && !rPrimitive.getDoubleSided())
383 : {
384 : // get plane normal of polygon in view coordinates (with ZBuffer values),
385 : // left-handed coordinate system
386 36616 : const basegfx::B3DVector aPlaneNormal(aFill.getB3DPolygon(0L).getNormal());
387 :
388 36616 : if(aPlaneNormal.getZ() > 0.0)
389 : {
390 18319 : bPaintIt = false;
391 36616 : }
392 : }
393 :
394 36815 : if(bPaintIt)
395 : {
396 : // prepare ObjectToEye in NormalTransform
397 18402 : basegfx::B3DHomMatrix aNormalTransform(getViewInformation3D().getOrientation() * getViewInformation3D().getObjectTransformation());
398 :
399 18402 : if(getSdrSceneAttribute().getTwoSidedLighting())
400 : {
401 : // get plane normal of polygon in view coordinates (with ZBuffer values),
402 : // left-handed coordinate system
403 18402 : const basegfx::B3DVector aPlaneNormal(aFill.getB3DPolygon(0L).getNormal());
404 :
405 18402 : if(aPlaneNormal.getZ() > 0.0)
406 : {
407 : // mirror normals
408 59 : aNormalTransform.scale(-1.0, -1.0, -1.0);
409 18402 : }
410 : }
411 :
412 18402 : switch(aShadeMode)
413 : {
414 : case ::com::sun::star::drawing::ShadeMode_PHONG:
415 : {
416 : // phong shading. Transform normals to eye coor
417 0 : aFill.transformNormals(aNormalTransform);
418 0 : break;
419 : }
420 : case ::com::sun::star::drawing::ShadeMode_SMOOTH:
421 : {
422 : // gouraud shading. Transform normals to eye coor
423 164 : aFill.transformNormals(aNormalTransform);
424 :
425 : // prepare color model parameters, evtl. use blend color
426 164 : const basegfx::BColor aColor(getModulate() ? basegfx::BColor(1.0, 1.0, 1.0) : rPrimitive.getMaterial().getColor());
427 164 : const basegfx::BColor& rSpecular(rPrimitive.getMaterial().getSpecular());
428 164 : const basegfx::BColor& rEmission(rPrimitive.getMaterial().getEmission());
429 164 : const sal_uInt16 nSpecularIntensity(rPrimitive.getMaterial().getSpecularIntensity());
430 :
431 : // solve color model for each normal vector, set colors at points. Clear normals.
432 328 : for(sal_uInt32 a(0L); a < aFill.count(); a++)
433 : {
434 164 : basegfx::B3DPolygon aPartFill(aFill.getB3DPolygon(a));
435 :
436 820 : for(sal_uInt32 b(0L); b < aPartFill.count(); b++)
437 : {
438 : // solve color model. Transform normal to eye coor
439 656 : const basegfx::B3DVector aNormal(aPartFill.getNormal(b));
440 1312 : const basegfx::BColor aSolvedColor(getSdrLightingAttribute().solveColorModel(aNormal, aColor, rSpecular, rEmission, nSpecularIntensity));
441 656 : aPartFill.setBColor(b, aSolvedColor);
442 656 : }
443 :
444 : // clear normals on this part polygon and write it back
445 164 : aPartFill.clearNormals();
446 164 : aFill.setB3DPolygon(a, aPartFill);
447 164 : }
448 164 : break;
449 : }
450 : case ::com::sun::star::drawing::ShadeMode_FLAT:
451 : {
452 : // flat shading. Get plane vector in eye coordinates
453 18238 : const basegfx::B3DVector aPlaneEyeNormal(aNormalTransform * rPrimitive.getB3DPolyPolygon().getB3DPolygon(0L).getNormal());
454 :
455 : // prepare color model parameters, evtl. use blend color
456 36476 : const basegfx::BColor aColor(getModulate() ? basegfx::BColor(1.0, 1.0, 1.0) : rPrimitive.getMaterial().getColor());
457 18238 : const basegfx::BColor& rSpecular(rPrimitive.getMaterial().getSpecular());
458 18238 : const basegfx::BColor& rEmission(rPrimitive.getMaterial().getEmission());
459 18238 : const sal_uInt16 nSpecularIntensity(rPrimitive.getMaterial().getSpecularIntensity());
460 :
461 : // solve color model for plane vector and use that color for whole plane
462 18238 : aObjectColor = getSdrLightingAttribute().solveColorModel(aPlaneEyeNormal, aColor, rSpecular, rEmission, nSpecularIntensity);
463 36476 : break;
464 : }
465 : default: // case ::com::sun::star::drawing::ShadeMode_DRAFT:
466 : {
467 : // draft, just use object color which is already set. Delete all other infos
468 0 : aFill.clearNormals();
469 0 : aFill.clearBColors();
470 0 : break;
471 : }
472 : }
473 :
474 : // draw it to ZBuffer
475 : const attribute::MaterialAttribute3D aMaterial(
476 : maBColorModifierStack.getModifiedColor(aObjectColor),
477 18402 : rPrimitive.getMaterial().getSpecular(),
478 18402 : rPrimitive.getMaterial().getEmission(),
479 36804 : rPrimitive.getMaterial().getSpecularIntensity());
480 :
481 18402 : rasterconvertB3DPolyPolygon(aMaterial, aFill);
482 36815 : }
483 36815 : }
484 :
485 5451 : void DefaultProcessor3D::impRenderTransformPrimitive3D(const primitive3d::TransformPrimitive3D& rTransformCandidate)
486 : {
487 : // transform group. Remember current transformations
488 5451 : const geometry::ViewInformation3D aLastViewInformation3D(getViewInformation3D());
489 :
490 : // create new transformation; add new object transform from right side
491 : const geometry::ViewInformation3D aNewViewInformation3D(
492 10902 : aLastViewInformation3D.getObjectTransformation() * rTransformCandidate.getTransformation(),
493 5451 : aLastViewInformation3D.getOrientation(),
494 5451 : aLastViewInformation3D.getProjection(),
495 5451 : aLastViewInformation3D.getDeviceToView(),
496 : aLastViewInformation3D.getViewTime(),
497 16353 : aLastViewInformation3D.getExtendedInformationSequence());
498 5451 : updateViewInformation(aNewViewInformation3D);
499 :
500 : // let break down recursively
501 5451 : process(rTransformCandidate.getChildren());
502 :
503 : // restore transformations
504 10902 : updateViewInformation(aLastViewInformation3D);
505 5451 : }
506 :
507 43495 : void DefaultProcessor3D::processBasePrimitive3D(const primitive3d::BasePrimitive3D& rBasePrimitive)
508 : {
509 : // it is a BasePrimitive3D implementation, use getPrimitive3DID() call for switch
510 43495 : switch(rBasePrimitive.getPrimitive3DID())
511 : {
512 : case PRIMITIVE3D_ID_GRADIENTTEXTUREPRIMITIVE3D :
513 : {
514 : // GradientTexturePrimitive3D
515 0 : const primitive3d::GradientTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::GradientTexturePrimitive3D& >(rBasePrimitive);
516 0 : impRenderGradientTexturePrimitive3D(rPrimitive, false);
517 0 : break;
518 : }
519 : case PRIMITIVE3D_ID_HATCHTEXTUREPRIMITIVE3D :
520 : {
521 : // HatchTexturePrimitive3D
522 : static bool bDoHatchDecomposition(false);
523 :
524 20 : if(bDoHatchDecomposition)
525 : {
526 : // let break down
527 0 : process(rBasePrimitive.get3DDecomposition(getViewInformation3D()));
528 : }
529 : else
530 : {
531 : // hatchTexturePrimitive3D
532 20 : const primitive3d::HatchTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::HatchTexturePrimitive3D& >(rBasePrimitive);
533 20 : impRenderHatchTexturePrimitive3D(rPrimitive);
534 : }
535 20 : break;
536 : }
537 : case PRIMITIVE3D_ID_BITMAPTEXTUREPRIMITIVE3D :
538 : {
539 : // BitmapTexturePrimitive3D
540 0 : const primitive3d::BitmapTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::BitmapTexturePrimitive3D& >(rBasePrimitive);
541 0 : impRenderBitmapTexturePrimitive3D(rPrimitive);
542 0 : break;
543 : }
544 : case PRIMITIVE3D_ID_TRANSPARENCETEXTUREPRIMITIVE3D :
545 : {
546 : // TransparenceTexturePrimitive3D
547 40 : const primitive3d::TransparenceTexturePrimitive3D& rPrimitive = static_cast< const primitive3d::TransparenceTexturePrimitive3D& >(rBasePrimitive);
548 40 : mnTransparenceCounter++;
549 40 : impRenderGradientTexturePrimitive3D(rPrimitive, true);
550 40 : mnTransparenceCounter--;
551 40 : break;
552 : }
553 : case PRIMITIVE3D_ID_MODIFIEDCOLORPRIMITIVE3D :
554 : {
555 : // ModifiedColorPrimitive3D
556 : // Force output to unified color.
557 0 : const primitive3d::ModifiedColorPrimitive3D& rPrimitive = static_cast< const primitive3d::ModifiedColorPrimitive3D& >(rBasePrimitive);
558 0 : impRenderModifiedColorPrimitive3D(rPrimitive);
559 0 : break;
560 : }
561 : case PRIMITIVE3D_ID_POLYGONHAIRLINEPRIMITIVE3D :
562 : {
563 : // directdraw of PolygonHairlinePrimitive3D
564 118 : const primitive3d::PolygonHairlinePrimitive3D& rPrimitive = static_cast< const primitive3d::PolygonHairlinePrimitive3D& >(rBasePrimitive);
565 118 : impRenderPolygonHairlinePrimitive3D(rPrimitive);
566 118 : break;
567 : }
568 : case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D :
569 : {
570 : // directdraw of PolyPolygonMaterialPrimitive3D
571 36815 : const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const primitive3d::PolyPolygonMaterialPrimitive3D& >(rBasePrimitive);
572 36815 : impRenderPolyPolygonMaterialPrimitive3D(rPrimitive);
573 36815 : break;
574 : }
575 : case PRIMITIVE3D_ID_TRANSFORMPRIMITIVE3D :
576 : {
577 : // transform group (TransformPrimitive3D)
578 5451 : impRenderTransformPrimitive3D(static_cast< const primitive3d::TransformPrimitive3D& >(rBasePrimitive));
579 5451 : break;
580 : }
581 : default:
582 : {
583 : // process recursively
584 1051 : process(rBasePrimitive.get3DDecomposition(getViewInformation3D()));
585 1051 : break;
586 : }
587 : }
588 43495 : }
589 :
590 13 : DefaultProcessor3D::DefaultProcessor3D(
591 : const geometry::ViewInformation3D& rViewInformation,
592 : const attribute::SdrSceneAttribute& rSdrSceneAttribute,
593 : const attribute::SdrLightingAttribute& rSdrLightingAttribute)
594 : : BaseProcessor3D(rViewInformation),
595 : mrSdrSceneAttribute(rSdrSceneAttribute),
596 : mrSdrLightingAttribute(rSdrLightingAttribute),
597 : maRasterRange(),
598 : maBColorModifierStack(),
599 : mpGeoTexSvx(),
600 : mpTransparenceGeoTexSvx(),
601 : maDrawinglayerOpt(),
602 : mnTransparenceCounter(0),
603 : mbModulate(false),
604 : mbFilter(false),
605 13 : mbSimpleTextureActive(false)
606 : {
607 : // a derivation has to set maRasterRange which is used in the basic render methods.
608 : // Setting to default here ([0.0 .. 1.0] in X,Y) to avoid problems
609 13 : maRasterRange.expand(basegfx::B2DTuple(0.0, 0.0));
610 13 : maRasterRange.expand(basegfx::B2DTuple(1.0, 1.0));
611 13 : }
612 :
613 13 : DefaultProcessor3D::~DefaultProcessor3D()
614 : {
615 13 : }
616 : } // end of namespace processor3d
617 : } // end of namespace drawinglayer
618 :
619 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
