1 /*
2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public License
4 * as published by the Free Software Foundation; either version 2
5 * of the License, or (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software Foundation,
14 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15 *
16 * The Original Code is Copyright (C) 2020 Blender Foundation.
17 * All rights reserved.
18 */
19
20 /** \file
21 * \ingroup gpu
22 */
23
24 #include "BKE_global.h"
25
26 #include "BLI_string.h"
27 #include "BLI_vector.hh"
28
29 #include "GPU_platform.h"
30
31 #include "gl_backend.hh"
32 #include "gl_debug.hh"
33 #include "gl_vertex_buffer.hh"
34
35 #include "gl_shader.hh"
36 #include "gl_shader_interface.hh"
37
38 using namespace blender;
39 using namespace blender::gpu;
40
41 /* -------------------------------------------------------------------- */
42 /** \name Creation / Destruction
43 * \{ */
44
GLShader(const char * name)45 GLShader::GLShader(const char *name) : Shader(name)
46 {
47 #if 0 /* Would be nice to have, but for now the Deferred compilation \
48 * does not have a GPUContext. */
49 BLI_assert(GLContext::get() != NULL);
50 #endif
51 shader_program_ = glCreateProgram();
52
53 debug::object_label(GL_PROGRAM, shader_program_, name);
54 }
55
~GLShader(void)56 GLShader::~GLShader(void)
57 {
58 #if 0 /* Would be nice to have, but for now the Deferred compilation \
59 * does not have a GPUContext. */
60 BLI_assert(GLContext::get() != NULL);
61 #endif
62 /* Invalid handles are silently ignored. */
63 glDeleteShader(vert_shader_);
64 glDeleteShader(geom_shader_);
65 glDeleteShader(frag_shader_);
66 glDeleteProgram(shader_program_);
67 }
68
69 /** \} */
70
71 /* -------------------------------------------------------------------- */
72 /** \name Shader stage creation
73 * \{ */
74
glsl_patch_get(void)75 char *GLShader::glsl_patch_get(void)
76 {
77 /** Used for shader patching. Init once. */
78 static char patch[512] = "\0";
79 if (patch[0] != '\0') {
80 return patch;
81 }
82
83 size_t slen = 0;
84 /* Version need to go first. */
85 STR_CONCAT(patch, slen, "#version 330\n");
86
87 /* Enable extensions for features that are not part of our base GLSL version
88 * don't use an extension for something already available! */
89 if (GLContext::texture_gather_support) {
90 STR_CONCAT(patch, slen, "#extension GL_ARB_texture_gather: enable\n");
91 /* Some drivers don't agree on GLEW_ARB_texture_gather and the actual support in the
92 * shader so double check the preprocessor define (see T56544). */
93 STR_CONCAT(patch, slen, "#ifdef GL_ARB_texture_gather\n");
94 STR_CONCAT(patch, slen, "# define GPU_ARB_texture_gather\n");
95 STR_CONCAT(patch, slen, "#endif\n");
96 }
97 if (GLContext::shader_draw_parameters_support) {
98 STR_CONCAT(patch, slen, "#extension GL_ARB_shader_draw_parameters : enable\n");
99 STR_CONCAT(patch, slen, "#define GPU_ARB_shader_draw_parameters\n");
100 }
101 if (GLContext::texture_cube_map_array_support) {
102 STR_CONCAT(patch, slen, "#extension GL_ARB_texture_cube_map_array : enable\n");
103 STR_CONCAT(patch, slen, "#define GPU_ARB_texture_cube_map_array\n");
104 }
105
106 /* Derivative sign can change depending on implementation. */
107 STR_CONCATF(patch, slen, "#define DFDX_SIGN %1.1f\n", GLContext::derivative_signs[0]);
108 STR_CONCATF(patch, slen, "#define DFDY_SIGN %1.1f\n", GLContext::derivative_signs[1]);
109
110 BLI_assert(slen < sizeof(patch));
111 return patch;
112 }
113
114 /* Create, compile and attach the shader stage to the shader program. */
create_shader_stage(GLenum gl_stage,MutableSpan<const char * > sources)115 GLuint GLShader::create_shader_stage(GLenum gl_stage, MutableSpan<const char *> sources)
116 {
117 GLuint shader = glCreateShader(gl_stage);
118 if (shader == 0) {
119 fprintf(stderr, "GLShader: Error: Could not create shader object.");
120 return 0;
121 }
122
123 /* Patch the shader code using the first source slot. */
124 sources[0] = glsl_patch_get();
125
126 glShaderSource(shader, sources.size(), sources.data(), NULL);
127 glCompileShader(shader);
128
129 GLint status;
130 glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
131 if (!status || (G.debug & G_DEBUG_GPU)) {
132 char log[5000] = "";
133 glGetShaderInfoLog(shader, sizeof(log), NULL, log);
134 if (log[0] != '\0') {
135 switch (gl_stage) {
136 case GL_VERTEX_SHADER:
137 this->print_log(sources, log, "VertShader", !status);
138 break;
139 case GL_GEOMETRY_SHADER:
140 this->print_log(sources, log, "GeomShader", !status);
141 break;
142 case GL_FRAGMENT_SHADER:
143 this->print_log(sources, log, "FragShader", !status);
144 break;
145 }
146 }
147 }
148 if (!status) {
149 glDeleteShader(shader);
150 compilation_failed_ = true;
151 return 0;
152 }
153
154 debug::object_label(gl_stage, shader, name);
155
156 glAttachShader(shader_program_, shader);
157 return shader;
158 }
159
vertex_shader_from_glsl(MutableSpan<const char * > sources)160 void GLShader::vertex_shader_from_glsl(MutableSpan<const char *> sources)
161 {
162 vert_shader_ = this->create_shader_stage(GL_VERTEX_SHADER, sources);
163 }
164
geometry_shader_from_glsl(MutableSpan<const char * > sources)165 void GLShader::geometry_shader_from_glsl(MutableSpan<const char *> sources)
166 {
167 geom_shader_ = this->create_shader_stage(GL_GEOMETRY_SHADER, sources);
168 }
169
fragment_shader_from_glsl(MutableSpan<const char * > sources)170 void GLShader::fragment_shader_from_glsl(MutableSpan<const char *> sources)
171 {
172 frag_shader_ = this->create_shader_stage(GL_FRAGMENT_SHADER, sources);
173 }
174
finalize(void)175 bool GLShader::finalize(void)
176 {
177 if (compilation_failed_) {
178 return false;
179 }
180
181 glLinkProgram(shader_program_);
182
183 GLint status;
184 glGetProgramiv(shader_program_, GL_LINK_STATUS, &status);
185 if (!status) {
186 char log[5000];
187 glGetProgramInfoLog(shader_program_, sizeof(log), NULL, log);
188 Span<const char *> sources;
189 this->print_log(sources, log, "Linking", true);
190 return false;
191 }
192
193 interface = new GLShaderInterface(shader_program_);
194
195 return true;
196 }
197
198 /** \} */
199
200 /* -------------------------------------------------------------------- */
201 /** \name Binding
202 * \{ */
203
bind(void)204 void GLShader::bind(void)
205 {
206 BLI_assert(shader_program_ != 0);
207 glUseProgram(shader_program_);
208 }
209
unbind(void)210 void GLShader::unbind(void)
211 {
212 #ifndef NDEBUG
213 glUseProgram(0);
214 #endif
215 }
216
217 /** \} */
218
219 /* -------------------------------------------------------------------- */
220 /** \name Transform feedback
221 *
222 * TODO(fclem): Should be replaced by compute shaders.
223 * \{ */
224
225 /* Should be called before linking. */
transform_feedback_names_set(Span<const char * > name_list,const eGPUShaderTFBType geom_type)226 void GLShader::transform_feedback_names_set(Span<const char *> name_list,
227 const eGPUShaderTFBType geom_type)
228 {
229 glTransformFeedbackVaryings(
230 shader_program_, name_list.size(), name_list.data(), GL_INTERLEAVED_ATTRIBS);
231 transform_feedback_type_ = geom_type;
232 }
233
transform_feedback_enable(GPUVertBuf * buf_)234 bool GLShader::transform_feedback_enable(GPUVertBuf *buf_)
235 {
236 if (transform_feedback_type_ == GPU_SHADER_TFB_NONE) {
237 return false;
238 }
239
240 GLVertBuf *buf = static_cast<GLVertBuf *>(unwrap(buf_));
241
242 BLI_assert(buf->vbo_id_ != 0);
243
244 glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf->vbo_id_);
245
246 switch (transform_feedback_type_) {
247 case GPU_SHADER_TFB_POINTS:
248 glBeginTransformFeedback(GL_POINTS);
249 break;
250 case GPU_SHADER_TFB_LINES:
251 glBeginTransformFeedback(GL_LINES);
252 break;
253 case GPU_SHADER_TFB_TRIANGLES:
254 glBeginTransformFeedback(GL_TRIANGLES);
255 break;
256 default:
257 return false;
258 }
259 return true;
260 }
261
transform_feedback_disable(void)262 void GLShader::transform_feedback_disable(void)
263 {
264 glEndTransformFeedback();
265 }
266
267 /** \} */
268
269 /* -------------------------------------------------------------------- */
270 /** \name Uniforms setters
271 * \{ */
272
uniform_float(int location,int comp_len,int array_size,const float * data)273 void GLShader::uniform_float(int location, int comp_len, int array_size, const float *data)
274 {
275 switch (comp_len) {
276 case 1:
277 glUniform1fv(location, array_size, data);
278 break;
279 case 2:
280 glUniform2fv(location, array_size, data);
281 break;
282 case 3:
283 glUniform3fv(location, array_size, data);
284 break;
285 case 4:
286 glUniform4fv(location, array_size, data);
287 break;
288 case 9:
289 glUniformMatrix3fv(location, array_size, 0, data);
290 break;
291 case 16:
292 glUniformMatrix4fv(location, array_size, 0, data);
293 break;
294 default:
295 BLI_assert(0);
296 break;
297 }
298 }
299
uniform_int(int location,int comp_len,int array_size,const int * data)300 void GLShader::uniform_int(int location, int comp_len, int array_size, const int *data)
301 {
302 switch (comp_len) {
303 case 1:
304 glUniform1iv(location, array_size, data);
305 break;
306 case 2:
307 glUniform2iv(location, array_size, data);
308 break;
309 case 3:
310 glUniform3iv(location, array_size, data);
311 break;
312 case 4:
313 glUniform4iv(location, array_size, data);
314 break;
315 default:
316 BLI_assert(0);
317 break;
318 }
319 }
320
321 /** \} */
322
323 /* -------------------------------------------------------------------- */
324 /** \name GPUVertFormat from Shader
325 * \{ */
326
calc_component_size(const GLenum gl_type)327 static uint calc_component_size(const GLenum gl_type)
328 {
329 switch (gl_type) {
330 case GL_FLOAT_VEC2:
331 case GL_INT_VEC2:
332 case GL_UNSIGNED_INT_VEC2:
333 return 2;
334 case GL_FLOAT_VEC3:
335 case GL_INT_VEC3:
336 case GL_UNSIGNED_INT_VEC3:
337 return 3;
338 case GL_FLOAT_VEC4:
339 case GL_FLOAT_MAT2:
340 case GL_INT_VEC4:
341 case GL_UNSIGNED_INT_VEC4:
342 return 4;
343 case GL_FLOAT_MAT3:
344 return 9;
345 case GL_FLOAT_MAT4:
346 return 16;
347 case GL_FLOAT_MAT2x3:
348 case GL_FLOAT_MAT3x2:
349 return 6;
350 case GL_FLOAT_MAT2x4:
351 case GL_FLOAT_MAT4x2:
352 return 8;
353 case GL_FLOAT_MAT3x4:
354 case GL_FLOAT_MAT4x3:
355 return 12;
356 default:
357 return 1;
358 }
359 }
360
get_fetch_mode_and_comp_type(int gl_type,GPUVertCompType * r_comp_type,GPUVertFetchMode * r_fetch_mode)361 static void get_fetch_mode_and_comp_type(int gl_type,
362 GPUVertCompType *r_comp_type,
363 GPUVertFetchMode *r_fetch_mode)
364 {
365 switch (gl_type) {
366 case GL_FLOAT:
367 case GL_FLOAT_VEC2:
368 case GL_FLOAT_VEC3:
369 case GL_FLOAT_VEC4:
370 case GL_FLOAT_MAT2:
371 case GL_FLOAT_MAT3:
372 case GL_FLOAT_MAT4:
373 case GL_FLOAT_MAT2x3:
374 case GL_FLOAT_MAT2x4:
375 case GL_FLOAT_MAT3x2:
376 case GL_FLOAT_MAT3x4:
377 case GL_FLOAT_MAT4x2:
378 case GL_FLOAT_MAT4x3:
379 *r_comp_type = GPU_COMP_F32;
380 *r_fetch_mode = GPU_FETCH_FLOAT;
381 break;
382 case GL_INT:
383 case GL_INT_VEC2:
384 case GL_INT_VEC3:
385 case GL_INT_VEC4:
386 *r_comp_type = GPU_COMP_I32;
387 *r_fetch_mode = GPU_FETCH_INT;
388 break;
389 case GL_UNSIGNED_INT:
390 case GL_UNSIGNED_INT_VEC2:
391 case GL_UNSIGNED_INT_VEC3:
392 case GL_UNSIGNED_INT_VEC4:
393 *r_comp_type = GPU_COMP_U32;
394 *r_fetch_mode = GPU_FETCH_INT;
395 break;
396 default:
397 BLI_assert(0);
398 }
399 }
400
vertformat_from_shader(GPUVertFormat * format) const401 void GLShader::vertformat_from_shader(GPUVertFormat *format) const
402 {
403 GPU_vertformat_clear(format);
404
405 GLint attr_len;
406 glGetProgramiv(shader_program_, GL_ACTIVE_ATTRIBUTES, &attr_len);
407
408 for (int i = 0; i < attr_len; i++) {
409 char name[256];
410 GLenum gl_type;
411 GLint size;
412 glGetActiveAttrib(shader_program_, i, sizeof(name), NULL, &size, &gl_type, name);
413
414 /* Ignore OpenGL names like `gl_BaseInstanceARB`, `gl_InstanceID` and `gl_VertexID`. */
415 if (glGetAttribLocation(shader_program_, name) == -1) {
416 continue;
417 }
418
419 GPUVertCompType comp_type;
420 GPUVertFetchMode fetch_mode;
421 get_fetch_mode_and_comp_type(gl_type, &comp_type, &fetch_mode);
422
423 int comp_len = calc_component_size(gl_type) * size;
424
425 GPU_vertformat_attr_add(format, name, comp_type, comp_len, fetch_mode);
426 }
427 }
428
429 /** \} */
430