1/****************************************************************************
2**
3** Copyright (C) 2014 Klaralvdalens Datakonsult AB (KDAB).
4** Contact: https://www.qt.io/licensing/
5**
6** This file is part of the Qt3D module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and The Qt Company. For licensing terms
14** and conditions see https://www.qt.io/terms-conditions. For further
15** information use the contact form at https://www.qt.io/contact-us.
16**
17** GNU Lesser General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU Lesser
19** General Public License version 3 as published by the Free Software
20** Foundation and appearing in the file LICENSE.LGPL3 included in the
21** packaging of this file. Please review the following information to
22** ensure the GNU Lesser General Public License version 3 requirements
23** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24**
25** GNU General Public License Usage
26** Alternatively, this file may be used under the terms of the GNU
27** General Public License version 2.0 or (at your option) the GNU General
28** Public license version 3 or any later version approved by the KDE Free
29** Qt Foundation. The licenses are as published by the Free Software
30** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31** included in the packaging of this file. Please review the following
32** information to ensure the GNU General Public License requirements will
33** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34** https://www.gnu.org/licenses/gpl-3.0.html.
35**
36** $QT_END_LICENSE$
37**
38****************************************************************************/
39
40#ifndef QT3DRENDER_RENDER_OPENGL_SHADERPARAMETERPACK_P_H
41#define QT3DRENDER_RENDER_OPENGL_SHADERPARAMETERPACK_P_H
42
43//
44// W A R N I N G
45// -------------
46//
47// This file is not part of the Qt API. It exists for the convenience
48// of other Qt classes. This header file may change from version to
49// version without notice, or even be removed.
50//
51// We mean it.
52//
53
54#include <QVariant>
55#include <QByteArray>
56#include <QVector>
57#include <QOpenGLShaderProgram>
58#include <Qt3DCore/qnodeid.h>
59#include <Qt3DRender/private/renderlogging_p.h>
60#include <Qt3DRender/private/uniform_p.h>
61#include <shadervariables_p.h>
62
63QT_BEGIN_NAMESPACE
64
65class QOpenGLShaderProgram;
66
67namespace Qt3DCore {
68class QFrameAllocator;
69}
70
71namespace Qt3DRender {
72namespace Render {
73namespace OpenGL {
74
75class GraphicsContext;
76
77struct BlockToUBO {
78 int m_blockIndex;
79 Qt3DCore::QNodeId m_bufferID;
80 bool m_needsUpdate;
81 QHash<QString, QVariant> m_updatedProperties;
82};
83QT3D_DECLARE_TYPEINFO_3(Qt3DRender, Render, OpenGL, BlockToUBO, Q_MOVABLE_TYPE)
84
85struct BlockToSSBO {
86 int m_blockIndex;
87 int m_bindingIndex;
88 Qt3DCore::QNodeId m_bufferID;
89};
90QT3D_DECLARE_TYPEINFO_3(Qt3DRender, Render, OpenGL, BlockToSSBO, Q_PRIMITIVE_TYPE)
91
92
93struct PackUniformHash
94{
95 std::vector<int> keys;
96 std::vector<UniformValue> values;
97
98 PackUniformHash()
99 {
100 }
101
102 void reserve(int count)
103 {
104 keys.reserve(n: count);
105 values.reserve(n: count);
106 }
107
108 size_t size() const
109 {
110 return keys.size();
111 }
112
113 inline int indexForKey(int key) const
114 {
115 const auto b = keys.cbegin();
116 const auto e = keys.cend();
117 const auto it = std::find(first: b, last: e, val: key);
118 if (it == e)
119 return -1;
120 return std::distance(first: b, last: it);
121 }
122
123 void insert(int key, const UniformValue &value)
124 {
125 const int idx = indexForKey(key);
126 if (idx != -1) {
127 values[idx] = value;
128 } else {
129 keys.push_back(x: key);
130 values.push_back(x: value);
131 }
132 }
133
134 void insert(int key, UniformValue &&value)
135 {
136 const int idx = indexForKey(key);
137 if (idx != -1) {
138 values[idx] = std::move(value);
139 } else {
140 keys.push_back(x: key);
141 values.push_back(x: std::move(value));
142 }
143 }
144
145 UniformValue value(int key) const noexcept
146 {
147 const int idx = indexForKey(key);
148 if (idx != -1)
149 return values.at(n: idx);
150 return UniformValue();
151 }
152
153 UniformValue& value(int key)
154 {
155 const int idx = indexForKey(key);
156 if (idx != -1)
157 return values[idx];
158 insert(key, value: UniformValue());
159 return value(key);
160 }
161
162 template<typename F>
163 void apply(int key, F func) const noexcept
164 {
165 const int idx = indexForKey(key);
166 if (idx != -1)
167 func(values[idx]);
168 }
169
170 void erase(int idx)
171 {
172 keys.erase(position: keys.begin() + idx);
173 values.erase(position: values.begin() + idx);
174 }
175
176 bool contains(int key) const noexcept
177 {
178 const auto b = keys.cbegin();
179 const auto e = keys.cend();
180 return std::find(first: b, last: e, val: key) != e;
181 }
182};
183
184class Q_AUTOTEST_EXPORT ShaderParameterPack
185{
186public:
187 ~ShaderParameterPack();
188
189 void reserve(int uniformCount);
190 void setUniform(const int glslNameId, const UniformValue &val);
191 void setTexture(const int glslNameId, int uniformArrayIndex, Qt3DCore::QNodeId id);
192 void setImage(const int glslNameId, int uniformArrayIndex, Qt3DCore::QNodeId id);
193
194 void setUniformBuffer(BlockToUBO blockToUBO);
195 void setShaderStorageBuffer(BlockToSSBO blockToSSBO);
196 void setSubmissionUniformIndex(const int shaderUniformIndex);
197
198 inline PackUniformHash &uniforms() { return m_uniforms; }
199 inline const PackUniformHash &uniforms() const { return m_uniforms; }
200 UniformValue uniform(const int glslNameId) const { return m_uniforms.value(key: glslNameId); }
201
202
203 struct NamedResource
204 {
205 enum Type {
206 Texture = 0,
207 Image
208 };
209
210 NamedResource() {}
211 NamedResource(const int glslNameId, Qt3DCore::QNodeId texId,
212 int uniformArrayIndex, Type type)
213 : glslNameId(glslNameId)
214 , nodeId(texId)
215 , uniformArrayIndex(uniformArrayIndex)
216 , type(type)
217 { }
218
219 int glslNameId;
220 Qt3DCore::QNodeId nodeId;
221 int uniformArrayIndex;
222 Type type;
223
224 bool operator==(const NamedResource &other) const
225 {
226 return glslNameId == other.glslNameId &&
227 nodeId == other.nodeId &&
228 uniformArrayIndex == other.uniformArrayIndex &&
229 type == other.type;
230 }
231
232 bool operator!=(const NamedResource &other) const
233 {
234 return !(*this == other);
235 }
236 };
237
238 inline const std::vector<NamedResource> &textures() const { return m_textures; }
239 inline const std::vector<NamedResource> &images() const { return m_images; }
240 inline const std::vector<BlockToUBO> &uniformBuffers() const { return m_uniformBuffers; }
241 inline const std::vector<BlockToSSBO> &shaderStorageBuffers() const { return m_shaderStorageBuffers; }
242 inline const std::vector<int> &submissionUniformIndices() const { return m_submissionUniformIndices; }
243private:
244 PackUniformHash m_uniforms;
245
246 std::vector<NamedResource> m_textures;
247 std::vector<NamedResource> m_images;
248 std::vector<BlockToUBO> m_uniformBuffers;
249 std::vector<BlockToSSBO> m_shaderStorageBuffers;
250 std::vector<int> m_submissionUniformIndices;
251
252 friend class RenderView;
253};
254QT3D_DECLARE_TYPEINFO_3(Qt3DRender, Render, OpenGL, ShaderParameterPack::NamedResource, Q_PRIMITIVE_TYPE)
255
256} // namespace OpenGL
257} // namespace Render
258} // namespace Qt3DRender
259
260QT_END_NAMESPACE
261
262Q_DECLARE_METATYPE(Qt3DRender::Render::OpenGL::ShaderParameterPack)
263
264#endif // QT3DRENDER_RENDER_OPENGL_SHADERPARAMETERPACK_P_H
265

source code of qt3d/src/plugins/renderers/opengl/renderer/shaderparameterpack_p.h