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
|
/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* Copyright 2020, Blender Foundation.
*/
/** \file
* \ingroup gpu
*/
#pragma once
#include "BLI_sys_types.h"
#include <optional>
#include "GPU_shader.h"
#include "GPU_uniform_buffer_types.h"
#include <array>
struct GPUUniformBuf;
namespace blender {
namespace gpu {
class ShaderInterface;
#ifdef DEBUG
# define DEBUG_NAME_LEN 64
#else
# define DEBUG_NAME_LEN 8
#endif
/**
* Implementation of Uniform Buffers.
* Base class which is then specialized for each implementation (GL, VK, ...).
*/
class UniformBuf {
protected:
/** Data size in bytes. */
size_t size_in_bytes_;
/** Continuous memory block to copy to GPU. This data is owned by the UniformBuf. */
void *data_ = NULL;
/** Debugging name */
char name_[DEBUG_NAME_LEN];
public:
UniformBuf(size_t size, const char *name);
virtual ~UniformBuf();
virtual void update(const void *data) = 0;
virtual void bind(int slot) = 0;
virtual void unbind(void) = 0;
/** Used to defer data upload at drawing time.
* This is useful if the thread has no context bound.
* This transfers ownership to this UniformBuf. */
void attach_data(void *data)
{
data_ = data;
}
};
/* Syntactic sugar. */
static inline GPUUniformBuf *wrap(UniformBuf *vert)
{
return reinterpret_cast<GPUUniformBuf *>(vert);
}
static inline UniformBuf *unwrap(GPUUniformBuf *vert)
{
return reinterpret_cast<UniformBuf *>(vert);
}
static inline const UniformBuf *unwrap(const GPUUniformBuf *vert)
{
return reinterpret_cast<const UniformBuf *>(vert);
}
class UniformBuiltinStructType {
public:
constexpr UniformBuiltinStructType(const GPUUniformBuiltinStructType type);
static const UniformBuiltinStructType &get(const GPUUniformBuiltinStructType type);
bool has_all_builtin_uniforms(const ShaderInterface &interface) const;
GPUUniformBuiltinStructType type;
struct AttributeBinding {
int binding = -1;
size_t offset = -1;
bool has_binding() const;
};
const AttributeBinding &attribute_binding(const GPUUniformBuiltin builtin_uniform) const
{
return m_attribute_bindings[builtin_uniform];
}
const size_t data_size() const
{
return m_data_size;
}
private:
const std::array<const AttributeBinding, GPU_NUM_UNIFORMS> &m_attribute_bindings;
const size_t m_data_size;
};
class UniformBuiltinStruct {
public:
struct Flags {
bool is_dirty : 1;
};
UniformBuiltinStruct(const GPUUniformBuiltinStructType type);
~UniformBuiltinStruct();
void *data() const
{
return m_data;
};
bool uniform_int(int location, int comp_len, int array_size, const int *data);
bool uniform_float(int location, int comp_len, int array_size, const float *data);
private:
Flags m_flags;
const UniformBuiltinStructType &m_type_info;
void *m_data;
};
std::optional<const GPUUniformBuiltinStructType> find_smallest_uniform_builtin_struct(
const ShaderInterface &interface);
#undef DEBUG_NAME_LEN
} // namespace gpu
} // namespace blender
|
