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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
#include "DrawableNode.h"
#include "RenderQueue.h"
#include "RenderResources.h"
#include "Viewport.h"
#include "../Application.h"
#include "RenderStatistics.h"
#include "../tracy.h"
namespace nCine
{
namespace
{
GLenum toGlBlendingFactor(DrawableNode::BlendingFactor blendingFactor)
{
switch (blendingFactor) {
case DrawableNode::BlendingFactor::ZERO: return GL_ZERO;
case DrawableNode::BlendingFactor::ONE: return GL_ONE;
case DrawableNode::BlendingFactor::SRC_COLOR: return GL_SRC_COLOR;
case DrawableNode::BlendingFactor::ONE_MINUS_SRC_COLOR: return GL_ONE_MINUS_SRC_COLOR;
case DrawableNode::BlendingFactor::DST_COLOR: return GL_DST_COLOR;
case DrawableNode::BlendingFactor::ONE_MINUS_DST_COLOR: return GL_ONE_MINUS_DST_COLOR;
case DrawableNode::BlendingFactor::SRC_ALPHA: return GL_SRC_ALPHA;
case DrawableNode::BlendingFactor::ONE_MINUS_SRC_ALPHA: return GL_ONE_MINUS_SRC_ALPHA;
case DrawableNode::BlendingFactor::DST_ALPHA: return GL_DST_ALPHA;
case DrawableNode::BlendingFactor::ONE_MINUS_DST_ALPHA: return GL_ONE_MINUS_DST_ALPHA;
case DrawableNode::BlendingFactor::CONSTANT_COLOR: return GL_CONSTANT_COLOR;
case DrawableNode::BlendingFactor::ONE_MINUS_CONSTANT_COLOR: return GL_ONE_MINUS_CONSTANT_COLOR;
case DrawableNode::BlendingFactor::CONSTANT_ALPHA: return GL_CONSTANT_ALPHA;
case DrawableNode::BlendingFactor::ONE_MINUS_CONSTANT_ALPHA: return GL_ONE_MINUS_CONSTANT_ALPHA;
case DrawableNode::BlendingFactor::SRC_ALPHA_SATURATE: return GL_SRC_ALPHA_SATURATE;
}
return GL_ZERO;
}
DrawableNode::BlendingFactor fromGlBlendingFactor(GLenum blendingFactor)
{
switch (blendingFactor) {
case GL_ZERO: return DrawableNode::BlendingFactor::ZERO;
case GL_ONE: return DrawableNode::BlendingFactor::ONE;
case GL_SRC_COLOR: return DrawableNode::BlendingFactor::SRC_COLOR;
case GL_ONE_MINUS_SRC_COLOR: return DrawableNode::BlendingFactor::ONE_MINUS_SRC_COLOR;
case GL_DST_COLOR: return DrawableNode::BlendingFactor::DST_COLOR;
case GL_ONE_MINUS_DST_COLOR: return DrawableNode::BlendingFactor::ONE_MINUS_DST_COLOR;
case GL_SRC_ALPHA: return DrawableNode::BlendingFactor::SRC_ALPHA;
case GL_ONE_MINUS_SRC_ALPHA: return DrawableNode::BlendingFactor::ONE_MINUS_SRC_ALPHA;
case GL_DST_ALPHA: return DrawableNode::BlendingFactor::DST_ALPHA;
case GL_ONE_MINUS_DST_ALPHA: return DrawableNode::BlendingFactor::ONE_MINUS_DST_ALPHA;
case GL_CONSTANT_COLOR: return DrawableNode::BlendingFactor::CONSTANT_COLOR;
case GL_ONE_MINUS_CONSTANT_COLOR: return DrawableNode::BlendingFactor::ONE_MINUS_CONSTANT_COLOR;
case GL_CONSTANT_ALPHA: return DrawableNode::BlendingFactor::CONSTANT_ALPHA;
case GL_ONE_MINUS_CONSTANT_ALPHA: return DrawableNode::BlendingFactor::ONE_MINUS_CONSTANT_ALPHA;
case GL_SRC_ALPHA_SATURATE: return DrawableNode::BlendingFactor::SRC_ALPHA_SATURATE;
}
return DrawableNode::BlendingFactor::ZERO;
}
}
const Vector2f DrawableNode::AnchorCenter(0.5f, 0.5f);
const Vector2f DrawableNode::AnchorBottomLeft(0.0f, 0.0f);
const Vector2f DrawableNode::AnchorTopLeft(0.0f, 1.0f);
const Vector2f DrawableNode::AnchorBottomRight(1.0f, 0.0f);
const Vector2f DrawableNode::AnchorTopRight(1.0f, 1.0f);
DrawableNode::DrawableNode(SceneNode* parent, float xx, float yy)
: SceneNode(parent, xx, yy), width_(0.0f), height_(0.0f),
renderCommand_(),
lastFrameRendered_(0)
{
renderCommand_.SetIdSortKey(id());
}
DrawableNode::DrawableNode(SceneNode* parent, Vector2f position)
: DrawableNode(parent, position.X, position.Y)
{
}
DrawableNode::DrawableNode(SceneNode* parent)
: DrawableNode(parent, 0.0f, 0.0f)
{
}
DrawableNode::DrawableNode()
: DrawableNode(nullptr, 0.0f, 0.0f)
{
}
DrawableNode::~DrawableNode() = default;
//DrawableNode::DrawableNode(DrawableNode&&) = default;
//DrawableNode& DrawableNode::operator=(DrawableNode&&) = default;
bool DrawableNode::OnDraw(RenderQueue& renderQueue)
{
// Skip rendering a zero area drawable node
if (width_ == 0.0f || height_ == 0.0f)
return false;
const bool cullingEnabled = theApplication().GetRenderingSettings().cullingEnabled;
bool overlaps = false;
if (cullingEnabled && lastFrameRendered_ == theApplication().GetFrameCount()) {
// This frame one of the viewports in the chain might overlap this node
const Viewport* viewport = RenderResources::GetCurrentViewport();
overlaps = aabb_.Overlaps(viewport->GetCullingRect());
}
if (!cullingEnabled || overlaps) {
renderCommand_.SetLayer(absLayer_);
renderCommand_.SetVisitOrder(withVisitOrder_ ? visitOrderIndex_ : 0);
updateRenderCommand();
dirtyBits_.reset(DirtyBitPositions::TransformationUploadBit);
dirtyBits_.reset(DirtyBitPositions::ColorUploadBit);
renderQueue.AddCommand(&renderCommand_);
} else {
#if defined(NCINE_PROFILING)
RenderStatistics::AddCulledNode();
#endif
return false;
}
return true;
}
/*! \note This method sets the anchor point relative to the node width and height.
* To set the anchor point in pixels use `setAbsAnchorPoint()` instead. */
void DrawableNode::setAnchorPoint(float xx, float yy)
{
const float clampedX = std::clamp(xx, 0.0f, 1.0f);
const float clampedY = std::clamp(yy, 0.0f, 1.0f);
anchorPoint_.Set((clampedX - 0.5f) * width(), (clampedY - 0.5f) * height());
}
bool DrawableNode::isBlendingEnabled() const
{
return renderCommand_.GetMaterial().IsBlendingEnabled();
}
void DrawableNode::setBlendingEnabled(bool blendingEnabled)
{
renderCommand_.GetMaterial().SetBlendingEnabled(blendingEnabled);
}
DrawableNode::BlendingFactor DrawableNode::srcBlendingFactor() const
{
return fromGlBlendingFactor(renderCommand_.GetMaterial().GetSrcBlendingFactor());
}
DrawableNode::BlendingFactor DrawableNode::destBlendingFactor() const
{
return fromGlBlendingFactor(renderCommand_.GetMaterial().GetDestBlendingFactor());
}
void DrawableNode::setBlendingPreset(BlendingPreset blendingPreset)
{
switch (blendingPreset) {
case BlendingPreset::DISABLED:
renderCommand_.GetMaterial().SetBlendingFactors(toGlBlendingFactor(BlendingFactor::ONE), toGlBlendingFactor(BlendingFactor::ZERO));
break;
case BlendingPreset::ALPHA:
renderCommand_.GetMaterial().SetBlendingFactors(toGlBlendingFactor(BlendingFactor::SRC_ALPHA), toGlBlendingFactor(BlendingFactor::ONE_MINUS_SRC_ALPHA));
break;
case BlendingPreset::PREMULTIPLIED_ALPHA:
renderCommand_.GetMaterial().SetBlendingFactors(toGlBlendingFactor(BlendingFactor::ONE), toGlBlendingFactor(BlendingFactor::ONE_MINUS_SRC_ALPHA));
break;
case BlendingPreset::ADDITIVE:
renderCommand_.GetMaterial().SetBlendingFactors(toGlBlendingFactor(BlendingFactor::SRC_ALPHA), toGlBlendingFactor(BlendingFactor::ONE));
break;
case BlendingPreset::MULTIPLY:
renderCommand_.GetMaterial().SetBlendingFactors(toGlBlendingFactor(BlendingFactor::DST_COLOR), toGlBlendingFactor(BlendingFactor::ZERO));
break;
}
}
void DrawableNode::setBlendingFactors(BlendingFactor srcBlendingFactor, BlendingFactor destBlendingFactor)
{
renderCommand_.GetMaterial().SetBlendingFactors(toGlBlendingFactor(srcBlendingFactor), toGlBlendingFactor(destBlendingFactor));
}
void DrawableNode::updateAabb()
{
//ZoneScopedC(0x81A861);
const float width = absWidth();
const float height = absHeight();
if (absRotation_ > MinRotation || absRotation_ < -MinRotation) {
// Calculate max size for any rotation angle, this will create larger bounding boxes but avoids using sin/cos
const float maxSize = width + height;
aabb_ = Rectf(absPosition_.X - maxSize, absPosition_.Y - maxSize, maxSize * 2, maxSize * 2);
} else {
aabb_ = Rectf(absPosition_.X, absPosition_.Y, width, height);
}
}
void DrawableNode::updateCulling()
{
const bool cullingEnabled = theApplication().GetRenderingSettings().cullingEnabled;
if (drawEnabled_ && cullingEnabled && width_ > 0 && height_ > 0) {
if (dirtyBits_.test(DirtyBitPositions::AabbBit)) {
updateAabb();
dirtyBits_.reset(DirtyBitPositions::AabbBit);
}
// Check if at least one viewport in the chain overlaps with this node
if (lastFrameRendered_ < theApplication().GetFrameCount()) {
const Viewport* viewport = RenderResources::GetCurrentViewport();
const bool overlaps = aabb_.Overlaps(viewport->GetCullingRect());
if (overlaps)
lastFrameRendered_ = theApplication().GetFrameCount();
}
}
}
DrawableNode::DrawableNode(const DrawableNode& other)
: SceneNode(other), width_(other.width_), height_(other.height_), renderCommand_(), lastFrameRendered_(0)
{
renderCommand_.SetIdSortKey(id());
setBlendingEnabled(other.isBlendingEnabled());
setBlendingFactors(other.srcBlendingFactor(), other.destBlendingFactor());
setLayer(other.layer());
}
}
|
