1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* 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 .
*/
#pragma once
#include <drawinglayer/processor3d/baseprocessor3d.hxx>
#include <basegfx/range/b2drange.hxx>
#include <basegfx/color/bcolormodifier.hxx>
// predefines
namespace basegfx {
class B3DPolygon;
class B3DPolyPolygon;
}
namespace drawinglayer::attribute {
class SdrSceneAttribute;
class SdrLightingAttribute;
class MaterialAttribute3D;
}
namespace drawinglayer::primitive3d {
class PolygonHairlinePrimitive3D;
class PolyPolygonMaterialPrimitive3D;
class GradientTexturePrimitive3D;
class HatchTexturePrimitive3D;
class BitmapTexturePrimitive3D;
class TransformPrimitive3D;
class ModifiedColorPrimitive3D;
}
namespace drawinglayer::texture {
class GeoTexSvx;
}
namespace drawinglayer::processor3d
{
/** DefaultProcessor3D class
This processor renders all fed primitives to a 2D raster where for all
primitives the two basic methods rasterconvertB3DPolygon for hairlines and
rasterconvertB3DPolyPolygon for filled geometry is called. It is a baseclass to
e.g. base a Z-Buffer supported renderer on the 3D primitive processing.
*/
class DefaultProcessor3D : public BaseProcessor3D
{
protected:
/// read-only scene infos (normal handling, etc...)
const attribute::SdrSceneAttribute& mrSdrSceneAttribute;
/// read-only light infos (lights, etc...)
const attribute::SdrLightingAttribute& mrSdrLightingAttribute;
/// renderer range. Need to be correctly set by the derived implementations
/// normally the (0, 0, W, H) range from mpBZPixelRaster
basegfx::B2DRange maRasterRange;
/// the modifiedColorPrimitive stack
basegfx::BColorModifierStack maBColorModifierStack;
/// the current active texture
std::shared_ptr< texture::GeoTexSvx > mpGeoTexSvx;
/// the current active transparence texture
std::shared_ptr< texture::GeoTexSvx > mpTransparenceGeoTexSvx;
/// counter for entered transparence textures
sal_uInt32 mnTransparenceCounter;
bool mbModulate : 1;
bool mbFilter : 1;
bool mbSimpleTextureActive : 1;
// rendering support
void impRenderGradientTexturePrimitive3D(const primitive3d::GradientTexturePrimitive3D& rPrimitive, bool bTransparence);
void impRenderHatchTexturePrimitive3D(const primitive3d::HatchTexturePrimitive3D& rPrimitive);
void impRenderBitmapTexturePrimitive3D(const primitive3d::BitmapTexturePrimitive3D& rPrimitive);
void impRenderModifiedColorPrimitive3D(const primitive3d::ModifiedColorPrimitive3D& rModifiedCandidate);
void impRenderPolygonHairlinePrimitive3D(const primitive3d::PolygonHairlinePrimitive3D& rPrimitive) const;
void impRenderPolyPolygonMaterialPrimitive3D(const primitive3d::PolyPolygonMaterialPrimitive3D& rPrimitive) const;
void impRenderTransformPrimitive3D(const primitive3d::TransformPrimitive3D& rTransformCandidate);
// rasterconversions for filled and non-filled polygons. These NEED to be
// implemented from derivations
virtual void rasterconvertB3DPolygon(const attribute::MaterialAttribute3D& rMaterial, const basegfx::B3DPolygon& rHairline) const = 0;
virtual void rasterconvertB3DPolyPolygon(const attribute::MaterialAttribute3D& rMaterial, const basegfx::B3DPolyPolygon& rFill) const = 0;
// the processing method for a single, known primitive
virtual void processBasePrimitive3D(const primitive3d::BasePrimitive3D& rBasePrimitive) override;
public:
DefaultProcessor3D(
const geometry::ViewInformation3D& rViewInformation,
const attribute::SdrSceneAttribute& rSdrSceneAttribute,
const attribute::SdrLightingAttribute& rSdrLightingAttribute);
virtual ~DefaultProcessor3D() override;
/// data read access
const attribute::SdrSceneAttribute& getSdrSceneAttribute() const { return mrSdrSceneAttribute; }
const attribute::SdrLightingAttribute& getSdrLightingAttribute() const { return mrSdrLightingAttribute; }
/// data read access renderer stuff
const basegfx::BColorModifierStack& getBColorModifierStack() const { return maBColorModifierStack; }
const std::shared_ptr< texture::GeoTexSvx >& getGeoTexSvx() const { return mpGeoTexSvx; }
const std::shared_ptr< texture::GeoTexSvx >& getTransparenceGeoTexSvx() const { return mpTransparenceGeoTexSvx; }
sal_uInt32 getTransparenceCounter() const { return mnTransparenceCounter; }
bool getModulate() const { return mbModulate; }
bool getFilter() const { return mbFilter; }
bool getSimpleTextureActive() const { return mbSimpleTextureActive; }
};
} // end of namespace drawinglayer::processor3d
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
