GPUTexture: Add debug print for cubemap textures
[blender.git] / source / blender / gpu / intern / gpu_texture.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2005 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Brecht Van Lommel.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #include "MEM_guardedalloc.h"
29
30 #include "DNA_image_types.h"
31
32 #include "BLI_blenlib.h"
33 #include "BLI_utildefines.h"
34 #include "BLI_math_base.h"
35 #include "BLI_listbase.h"
36 #include "BLI_threads.h"
37
38 #include "BKE_global.h"
39
40 #include "GPU_batch.h"
41 #include "GPU_context.h"
42 #include "GPU_debug.h"
43 #include "GPU_draw.h"
44 #include "GPU_extensions.h"
45 #include "GPU_glew.h"
46 #include "GPU_framebuffer.h"
47 #include "GPU_texture.h"
48
49 #include "gpu_context_private.h"
50
51 static struct GPUTextureGlobal {
52         GPUTexture *invalid_tex_1D; /* texture used in place of invalid textures (not loaded correctly, missing) */
53         GPUTexture *invalid_tex_2D;
54         GPUTexture *invalid_tex_3D;
55 } GG = {NULL, NULL, NULL};
56
57 /* Maximum number of FBOs a texture can be attached to. */
58 #define GPU_TEX_MAX_FBO_ATTACHED 10
59
60 typedef enum GPUTextureFormatFlag {
61         GPU_FORMAT_DEPTH     = (1 << 0),
62         GPU_FORMAT_STENCIL   = (1 << 1),
63         GPU_FORMAT_INTEGER   = (1 << 2),
64         GPU_FORMAT_FLOAT     = (1 << 3),
65
66         GPU_FORMAT_1D        = (1 << 10),
67         GPU_FORMAT_2D        = (1 << 11),
68         GPU_FORMAT_3D        = (1 << 12),
69         GPU_FORMAT_CUBE      = (1 << 13),
70         GPU_FORMAT_ARRAY     = (1 << 14),
71 } GPUTextureFormatFlag;
72
73 /* GPUTexture */
74 struct GPUTexture {
75         int w, h, d;        /* width/height/depth */
76         int number;         /* number for multitexture binding */
77         int refcount;       /* reference count */
78         GLenum target;      /* GL_TEXTURE_* */
79         GLenum target_base; /* same as target, (but no multisample)
80                              * use it for unbinding */
81         GLuint bindcode;    /* opengl identifier for texture */
82
83         GPUTextureFormat format;
84         GPUTextureFormatFlag format_flag;
85
86         uint bytesize;      /* number of byte for one pixel */
87         int components;     /* number of color/alpha channels */
88         int samples;        /* number of samples for multisamples textures. 0 if not multisample target */
89
90         int fb_attachment[GPU_TEX_MAX_FBO_ATTACHED];
91         GPUFrameBuffer *fb[GPU_TEX_MAX_FBO_ATTACHED];
92 };
93
94 /* ------ Memory Management ------- */
95 /* Records every texture allocation / free
96  * to estimate the Texture Pool Memory consumption */
97 static uint memory_usage;
98
99 static uint gpu_texture_memory_footprint_compute(GPUTexture *tex)
100 {
101         int samp = max_ii(tex->samples, 1);
102         switch (tex->target_base) {
103                 case GL_TEXTURE_1D:
104                         return tex->bytesize * tex->w * samp;
105                 case GL_TEXTURE_1D_ARRAY:
106                 case GL_TEXTURE_2D:
107                         return tex->bytesize * tex->w * tex->h * samp;
108                 case GL_TEXTURE_2D_ARRAY:
109                 case GL_TEXTURE_3D:
110                         return tex->bytesize * tex->w * tex->h * tex->d * samp;
111                 case GL_TEXTURE_CUBE_MAP:
112                         return tex->bytesize * 6 * tex->w * tex->h * samp;
113                 case GL_TEXTURE_CUBE_MAP_ARRAY:
114                         return tex->bytesize * 6 * tex->w * tex->h * tex->d * samp;
115                 default:
116                         return 0;
117         }
118 }
119
120 static void gpu_texture_memory_footprint_add(GPUTexture *tex)
121 {
122         memory_usage += gpu_texture_memory_footprint_compute(tex);
123 }
124
125 static void gpu_texture_memory_footprint_remove(GPUTexture *tex)
126 {
127         memory_usage -= gpu_texture_memory_footprint_compute(tex);
128 }
129
130 uint GPU_texture_memory_usage_get(void)
131 {
132         return memory_usage;
133 }
134
135 /* -------------------------------- */
136
137 static const char *gl_enum_to_str(GLenum e)
138 {
139 #define ENUM_TO_STRING(e) [GL_##e] = STRINGIFY_ARG(e)
140         static const char *enum_strings[] = {
141                 ENUM_TO_STRING(TEXTURE_CUBE_MAP),
142                 ENUM_TO_STRING(TEXTURE_2D),
143                 ENUM_TO_STRING(TEXTURE_2D_ARRAY),
144                 ENUM_TO_STRING(TEXTURE_1D),
145                 ENUM_TO_STRING(TEXTURE_1D_ARRAY),
146                 ENUM_TO_STRING(TEXTURE_3D),
147                 ENUM_TO_STRING(TEXTURE_2D_MULTISAMPLE),
148                 ENUM_TO_STRING(RGBA32F),
149                 ENUM_TO_STRING(RGBA16F),
150                 ENUM_TO_STRING(RGBA16),
151                 ENUM_TO_STRING(RG32F),
152                 ENUM_TO_STRING(RGB16F),
153                 ENUM_TO_STRING(RG16F),
154                 ENUM_TO_STRING(RG16I),
155                 ENUM_TO_STRING(RG16),
156                 ENUM_TO_STRING(RGBA8),
157                 ENUM_TO_STRING(RGBA8UI),
158                 ENUM_TO_STRING(R32F),
159                 ENUM_TO_STRING(R32UI),
160                 ENUM_TO_STRING(R32I),
161                 ENUM_TO_STRING(R16F),
162                 ENUM_TO_STRING(R16I),
163                 ENUM_TO_STRING(R16UI),
164                 ENUM_TO_STRING(RG8),
165                 ENUM_TO_STRING(RG16UI),
166                 ENUM_TO_STRING(R16),
167                 ENUM_TO_STRING(R8),
168                 ENUM_TO_STRING(R8UI),
169                 ENUM_TO_STRING(R11F_G11F_B10F),
170                 ENUM_TO_STRING(DEPTH24_STENCIL8),
171                 ENUM_TO_STRING(DEPTH32F_STENCIL8),
172                 ENUM_TO_STRING(DEPTH_COMPONENT32F),
173                 ENUM_TO_STRING(DEPTH_COMPONENT24),
174                 ENUM_TO_STRING(DEPTH_COMPONENT16),
175         };
176 #undef ENUM_TO_STRING
177
178         return enum_strings[e];
179 }
180
181 static int gpu_get_component_count(GPUTextureFormat format)
182 {
183         switch (format) {
184                 case GPU_RGBA8:
185                 case GPU_RGBA8UI:
186                 case GPU_RGBA16F:
187                 case GPU_RGBA16:
188                 case GPU_RGBA32F:
189                         return 4;
190                 case GPU_RGB16F:
191                 case GPU_R11F_G11F_B10F:
192                         return 3;
193                 case GPU_RG8:
194                 case GPU_RG16:
195                 case GPU_RG16F:
196                 case GPU_RG16I:
197                 case GPU_RG16UI:
198                 case GPU_RG32F:
199                         return 2;
200                 default:
201                         return 1;
202         }
203 }
204
205 /* Definitely not complete, edit according to the gl specification. */
206 static void gpu_validate_data_format(GPUTextureFormat tex_format, GPUDataFormat data_format)
207 {
208         (void)data_format;
209
210         if (ELEM(tex_format,
211                  GPU_DEPTH_COMPONENT24,
212                  GPU_DEPTH_COMPONENT16,
213                  GPU_DEPTH_COMPONENT32F))
214         {
215                 BLI_assert(data_format == GPU_DATA_FLOAT);
216         }
217         else if (ELEM(tex_format,
218                       GPU_DEPTH24_STENCIL8,
219                       GPU_DEPTH32F_STENCIL8))
220         {
221                 BLI_assert(data_format == GPU_DATA_UNSIGNED_INT_24_8);
222         }
223         else {
224                 /* Integer formats */
225                 if (ELEM(tex_format, GPU_RG16I, GPU_R16I, GPU_RG16UI, GPU_R16UI, GPU_R8UI, GPU_R32UI)) {
226                         if (ELEM(tex_format, GPU_R8UI, GPU_R16UI, GPU_RG16UI, GPU_R32UI)) {
227                                 BLI_assert(data_format == GPU_DATA_UNSIGNED_INT);
228                         }
229                         else {
230                                 BLI_assert(data_format == GPU_DATA_INT);
231                         }
232                 }
233                 /* Byte formats */
234                 else if (ELEM(tex_format, GPU_R8, GPU_RG8, GPU_RGBA8, GPU_RGBA8UI)) {
235                         BLI_assert(ELEM(data_format, GPU_DATA_UNSIGNED_BYTE, GPU_DATA_FLOAT));
236                 }
237                 /* Special case */
238                 else if (ELEM(tex_format, GPU_R11F_G11F_B10F)) {
239                         BLI_assert(ELEM(data_format, GPU_DATA_10_11_11_REV, GPU_DATA_FLOAT));
240                 }
241                 /* Float formats */
242                 else {
243                         BLI_assert(ELEM(data_format, GPU_DATA_FLOAT));
244                 }
245         }
246 }
247
248 static GPUDataFormat gpu_get_data_format_from_tex_format(GPUTextureFormat tex_format)
249 {
250         if (ELEM(tex_format,
251                  GPU_DEPTH_COMPONENT24,
252                  GPU_DEPTH_COMPONENT16,
253                  GPU_DEPTH_COMPONENT32F))
254         {
255                 return GPU_DATA_FLOAT;
256         }
257         else if (ELEM(tex_format,
258                       GPU_DEPTH24_STENCIL8,
259                       GPU_DEPTH32F_STENCIL8))
260         {
261                 return GPU_DATA_UNSIGNED_INT_24_8;
262         }
263         else {
264                 /* Integer formats */
265                 if (ELEM(tex_format, GPU_RG16I, GPU_R16I, GPU_RG16UI, GPU_R8UI, GPU_R16UI, GPU_R32UI)) {
266                         if (ELEM(tex_format, GPU_R8UI, GPU_R16UI, GPU_RG16UI, GPU_R32UI)) {
267                                 return GPU_DATA_UNSIGNED_INT;
268                         }
269                         else {
270                                 return GPU_DATA_INT;
271                         }
272                 }
273                 /* Byte formats */
274                 else if (ELEM(tex_format, GPU_R8)) {
275                         return GPU_DATA_UNSIGNED_BYTE;
276                 }
277                 /* Special case */
278                 else if (ELEM(tex_format, GPU_R11F_G11F_B10F)) {
279                         return GPU_DATA_10_11_11_REV;
280                 }
281                 else {
282                         return GPU_DATA_FLOAT;
283                 }
284         }
285 }
286
287 /* Definitely not complete, edit according to the gl specification. */
288 static GLenum gpu_get_gl_dataformat(GPUTextureFormat data_type, GPUTextureFormatFlag *format_flag)
289 {
290         if (ELEM(data_type,
291                  GPU_DEPTH_COMPONENT24,
292                  GPU_DEPTH_COMPONENT16,
293                  GPU_DEPTH_COMPONENT32F))
294         {
295                 *format_flag |= GPU_FORMAT_DEPTH;
296                 return GL_DEPTH_COMPONENT;
297         }
298         else if (ELEM(data_type,
299                       GPU_DEPTH24_STENCIL8,
300                       GPU_DEPTH32F_STENCIL8))
301         {
302                 *format_flag |= GPU_FORMAT_DEPTH | GPU_FORMAT_STENCIL;
303                 return GL_DEPTH_STENCIL;
304         }
305         else {
306                 /* Integer formats */
307                 if (ELEM(data_type, GPU_R8UI, GPU_RG16I, GPU_R16I, GPU_RG16UI, GPU_R16UI, GPU_R32UI)) {
308                         *format_flag |= GPU_FORMAT_INTEGER;
309
310                         switch (gpu_get_component_count(data_type)) {
311                                 case 1: return GL_RED_INTEGER; break;
312                                 case 2: return GL_RG_INTEGER; break;
313                                 case 3: return GL_RGB_INTEGER; break;
314                                 case 4: return GL_RGBA_INTEGER; break;
315                         }
316                 }
317                 else if (ELEM(data_type, GPU_R8)) {
318                         *format_flag |= GPU_FORMAT_FLOAT;
319                         return GL_RED;
320                 }
321                 else {
322                         *format_flag |= GPU_FORMAT_FLOAT;
323
324                         switch (gpu_get_component_count(data_type)) {
325                                 case 1: return GL_RED; break;
326                                 case 2: return GL_RG; break;
327                                 case 3: return GL_RGB; break;
328                                 case 4: return GL_RGBA; break;
329                         }
330                 }
331         }
332
333         BLI_assert(0);
334         *format_flag |= GPU_FORMAT_FLOAT;
335         return GL_RGBA;
336 }
337
338 static uint gpu_get_bytesize(GPUTextureFormat data_type)
339 {
340         switch (data_type) {
341                 case GPU_RGBA32F:
342                         return 32;
343                 case GPU_RG32F:
344                 case GPU_RGBA16F:
345                 case GPU_RGBA16:
346                         return 16;
347                 case GPU_RGB16F:
348                         return 12;
349                 case GPU_DEPTH32F_STENCIL8:
350                         return 8;
351                 case GPU_RG16F:
352                 case GPU_RG16I:
353                 case GPU_RG16UI:
354                 case GPU_RG16:
355                 case GPU_DEPTH24_STENCIL8:
356                 case GPU_DEPTH_COMPONENT32F:
357                 case GPU_RGBA8UI:
358                 case GPU_RGBA8:
359                 case GPU_R11F_G11F_B10F:
360                 case GPU_R32F:
361                 case GPU_R32UI:
362                 case GPU_R32I:
363                         return 4;
364                 case GPU_DEPTH_COMPONENT24:
365                         return 3;
366                 case GPU_DEPTH_COMPONENT16:
367                 case GPU_R16F:
368                 case GPU_R16UI:
369                 case GPU_R16I:
370                 case GPU_RG8:
371                 case GPU_R16:
372                         return 2;
373                 case GPU_R8:
374                 case GPU_R8UI:
375                         return 1;
376                 default:
377                         BLI_assert(!"Texture format incorrect or unsupported\n");
378                         return 0;
379         }
380 }
381
382 static GLenum gpu_get_gl_internalformat(GPUTextureFormat format)
383 {
384         /* You can add any of the available type to this list
385          * For available types see GPU_texture.h */
386         switch (format) {
387                 /* Formats texture & renderbuffer */
388                 case GPU_RGBA32F: return GL_RGBA32F;
389                 case GPU_RGBA16F: return GL_RGBA16F;
390                 case GPU_RGBA16: return GL_RGBA16;
391                 case GPU_RG32F: return GL_RG32F;
392                 case GPU_RGB16F: return GL_RGB16F;
393                 case GPU_RG16F: return GL_RG16F;
394                 case GPU_RG16I: return GL_RG16I;
395                 case GPU_RG16: return GL_RG16;
396                 case GPU_RGBA8: return GL_RGBA8;
397                 case GPU_RGBA8UI: return GL_RGBA8UI;
398                 case GPU_R32F: return GL_R32F;
399                 case GPU_R32UI: return GL_R32UI;
400                 case GPU_R32I: return GL_R32I;
401                 case GPU_R16F: return GL_R16F;
402                 case GPU_R16I: return GL_R16I;
403                 case GPU_R16UI: return GL_R16UI;
404                 case GPU_RG8: return GL_RG8;
405                 case GPU_RG16UI: return GL_RG16UI;
406                 case GPU_R16: return GL_R16;
407                 case GPU_R8: return GL_R8;
408                 case GPU_R8UI: return GL_R8UI;
409                 /* Special formats texture & renderbuffer */
410                 case GPU_R11F_G11F_B10F: return GL_R11F_G11F_B10F;
411                 case GPU_DEPTH24_STENCIL8: return GL_DEPTH24_STENCIL8;
412                 case GPU_DEPTH32F_STENCIL8: return GL_DEPTH32F_STENCIL8;
413                 /* Texture only format */
414                 /* ** Add Format here **/
415                 /* Special formats texture only */
416                 /* ** Add Format here **/
417                 /* Depth Formats */
418                 case GPU_DEPTH_COMPONENT32F: return GL_DEPTH_COMPONENT32F;
419                 case GPU_DEPTH_COMPONENT24: return GL_DEPTH_COMPONENT24;
420                 case GPU_DEPTH_COMPONENT16: return GL_DEPTH_COMPONENT16;
421                 default:
422                         BLI_assert(!"Texture format incorrect or unsupported\n");
423                         return 0;
424         }
425 }
426
427 static GLenum gpu_get_gl_datatype(GPUDataFormat format)
428 {
429         switch (format) {
430                 case GPU_DATA_FLOAT:
431                         return GL_FLOAT;
432                 case GPU_DATA_INT:
433                         return GL_INT;
434                 case GPU_DATA_UNSIGNED_INT:
435                         return GL_UNSIGNED_INT;
436                 case GPU_DATA_UNSIGNED_BYTE:
437                         return GL_UNSIGNED_BYTE;
438                 case GPU_DATA_UNSIGNED_INT_24_8:
439                         return GL_UNSIGNED_INT_24_8;
440                 case GPU_DATA_10_11_11_REV:
441                         return GL_UNSIGNED_INT_10F_11F_11F_REV;
442                 default:
443                         BLI_assert(!"Unhandled data format");
444                         return GL_FLOAT;
445         }
446 }
447
448 static float *GPU_texture_3D_rescale(GPUTexture *tex, int w, int h, int d, int channels, const float *fpixels)
449 {
450         const uint xf = w / tex->w, yf = h / tex->h, zf = d / tex->d;
451         float *nfpixels = MEM_mallocN(channels * sizeof(float) * tex->w * tex->h * tex->d, "GPUTexture Rescaled 3Dtex");
452
453         if (nfpixels) {
454                 GPU_print_error_debug("You need to scale a 3D texture, feel the pain!");
455
456                 for (uint k = 0; k < tex->d; k++) {
457                         for (uint j = 0; j < tex->h; j++) {
458                                 for (uint i = 0; i < tex->w; i++) {
459                                         /* obviously doing nearest filtering here,
460                                          * it's going to be slow in any case, let's not make it worse */
461                                         float xb = i * xf;
462                                         float yb = j * yf;
463                                         float zb = k * zf;
464                                         uint offset = k * (tex->w * tex->h) + i * tex->h + j;
465                                         uint offset_orig = (zb) * (w * h) + (xb) * h + (yb);
466
467                                         if (channels == 4) {
468                                                 nfpixels[offset * 4] = fpixels[offset_orig * 4];
469                                                 nfpixels[offset * 4 + 1] = fpixels[offset_orig * 4 + 1];
470                                                 nfpixels[offset * 4 + 2] = fpixels[offset_orig * 4 + 2];
471                                                 nfpixels[offset * 4 + 3] = fpixels[offset_orig * 4 + 3];
472                                         }
473                                         else
474                                                 nfpixels[offset] = fpixels[offset_orig];
475                                 }
476                         }
477                 }
478         }
479
480         return nfpixels;
481 }
482
483 /* This tries to allocate video memory for a given texture
484  * If alloc fails, lower the resolution until it fits. */
485 static bool gpu_texture_try_alloc(
486         GPUTexture *tex, GLenum proxy, GLenum internalformat, GLenum data_format, GLenum data_type,
487         int channels, bool try_rescale, const float *fpixels, float **rescaled_fpixels)
488 {
489         int r_width;
490
491         switch (proxy) {
492                 case GL_PROXY_TEXTURE_1D:
493                         glTexImage1D(proxy, 0, internalformat, tex->w, 0, data_format, data_type, NULL);
494                         break;
495                 case GL_PROXY_TEXTURE_1D_ARRAY:
496                 case GL_PROXY_TEXTURE_2D:
497                         glTexImage2D(proxy, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, NULL);
498                         break;
499                 case GL_PROXY_TEXTURE_2D_ARRAY:
500                         /* HACK: Some driver wrongly check GL_PROXY_TEXTURE_2D_ARRAY as a GL_PROXY_TEXTURE_3D
501                          * checking all dimensions against GPU_max_texture_layers (see T55888). */
502                         return (tex->w > 0) && (tex->w <= GPU_max_texture_size()) &&
503                                (tex->h > 0) && (tex->h <= GPU_max_texture_size()) &&
504                                (tex->d > 0) && (tex->d <= GPU_max_texture_layers());
505                 case GL_PROXY_TEXTURE_3D:
506                         glTexImage3D(proxy, 0, internalformat, tex->w, tex->h, tex->d, 0, data_format, data_type, NULL);
507                         break;
508         }
509
510         glGetTexLevelParameteriv(proxy, 0, GL_TEXTURE_WIDTH, &r_width);
511
512         if (r_width == 0 && try_rescale) {
513                 const int w = tex->w, h = tex->h, d = tex->d;
514
515                 /* Find largest texture possible */
516                 while (r_width == 0) {
517                         tex->w /= 2;
518                         tex->h /= 2;
519                         tex->d /= 2;
520
521                         /* really unlikely to happen but keep this just in case */
522                         if (tex->w == 0) break;
523                         if (tex->h == 0 && proxy != GL_PROXY_TEXTURE_1D) break;
524                         if (tex->d == 0 && proxy == GL_PROXY_TEXTURE_3D) break;
525
526                         if (proxy == GL_PROXY_TEXTURE_1D)
527                                 glTexImage1D(proxy, 0, internalformat, tex->w, 0, data_format, data_type, NULL);
528                         else if (proxy == GL_PROXY_TEXTURE_2D)
529                                 glTexImage2D(proxy, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, NULL);
530                         else if (proxy == GL_PROXY_TEXTURE_3D)
531                                 glTexImage3D(proxy, 0, internalformat, tex->w, tex->h, tex->d, 0, data_format, data_type, NULL);
532
533                         glGetTexLevelParameteriv(GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_WIDTH, &r_width);
534                 }
535
536                 /* Rescale */
537                 if (r_width > 0) {
538                         switch (proxy) {
539                                 case GL_PROXY_TEXTURE_1D:
540                                 case GL_PROXY_TEXTURE_2D:
541                                         /* Do nothing for now */
542                                         return false;
543                                 case GL_PROXY_TEXTURE_3D:
544                                         BLI_assert(data_type == GL_FLOAT);
545                                         *rescaled_fpixels = GPU_texture_3D_rescale(tex, w, h, d, channels, fpixels);
546                                         return (bool)*rescaled_fpixels;
547                         }
548                 }
549         }
550
551         return (r_width > 0);
552 }
553
554 GPUTexture *GPU_texture_create_nD(
555         int w, int h, int d, int n, const void *pixels,
556         GPUTextureFormat tex_format, GPUDataFormat gpu_data_format, int samples,
557         const bool can_rescale, char err_out[256])
558 {
559         if (samples) {
560                 CLAMP_MAX(samples, GPU_max_color_texture_samples());
561         }
562
563         if ((tex_format == GPU_DEPTH24_STENCIL8) && GPU_depth_blitting_workaround()) {
564                 /* MacOS + Radeon Pro fails to blit depth on GPU_DEPTH24_STENCIL8
565                  * but works on GPU_DEPTH32F_STENCIL8. */
566                 tex_format = GPU_DEPTH32F_STENCIL8;
567         }
568
569         GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
570         tex->w = w;
571         tex->h = h;
572         tex->d = d;
573         tex->samples = samples;
574         tex->number = -1;
575         tex->refcount = 1;
576         tex->format = tex_format;
577         tex->components = gpu_get_component_count(tex_format);
578         tex->bytesize = gpu_get_bytesize(tex_format);
579         tex->format_flag = 0;
580
581         if (n == 2) {
582                 if (d == 0)
583                         tex->target_base = tex->target = GL_TEXTURE_2D;
584                 else
585                         tex->target_base = tex->target = GL_TEXTURE_2D_ARRAY;
586         }
587         else if (n == 1) {
588                 if (h == 0)
589                         tex->target_base = tex->target = GL_TEXTURE_1D;
590                 else
591                         tex->target_base = tex->target = GL_TEXTURE_1D_ARRAY;
592         }
593         else if (n == 3) {
594                 tex->target_base = tex->target = GL_TEXTURE_3D;
595         }
596         else {
597                 /* should never happen */
598                 MEM_freeN(tex);
599                 return NULL;
600         }
601
602         gpu_validate_data_format(tex_format, gpu_data_format);
603
604         if (samples && n == 2 && d == 0)
605                 tex->target = GL_TEXTURE_2D_MULTISAMPLE;
606
607         GLenum internalformat = gpu_get_gl_internalformat(tex_format);
608         GLenum data_format = gpu_get_gl_dataformat(tex_format, &tex->format_flag);
609         GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
610
611         /* Generate Texture object */
612         tex->bindcode = GPU_tex_alloc();
613
614         if (!tex->bindcode) {
615                 if (err_out)
616                         BLI_snprintf(err_out, 256, "GPUTexture: texture create failed\n");
617                 else
618                         fprintf(stderr, "GPUTexture: texture create failed\n");
619                 GPU_texture_free(tex);
620                 return NULL;
621         }
622
623         glBindTexture(tex->target, tex->bindcode);
624
625         /* Check if texture fit in VRAM */
626         GLenum proxy = GL_PROXY_TEXTURE_2D;
627
628         if (n == 2) {
629                 if (d > 0)
630                         proxy = GL_PROXY_TEXTURE_2D_ARRAY;
631         }
632         else if (n == 1) {
633                 if (h == 0)
634                         proxy = GL_PROXY_TEXTURE_1D;
635                 else
636                         proxy = GL_PROXY_TEXTURE_1D_ARRAY;
637         }
638         else if (n == 3) {
639                 proxy = GL_PROXY_TEXTURE_3D;
640         }
641
642         float *rescaled_pixels = NULL;
643         bool valid = gpu_texture_try_alloc(tex, proxy, internalformat, data_format, data_type, tex->components, can_rescale,
644                                            pixels, &rescaled_pixels);
645
646         if (G.debug & G_DEBUG_GPU || !valid) {
647                 printf("GPUTexture: create : %s, %s, w : %d, h : %d, d : %d, comp : %d, size : %.2f MiB\n",
648                        gl_enum_to_str(tex->target), gl_enum_to_str(internalformat),
649                        w, h, d, tex->components,
650                        gpu_texture_memory_footprint_compute(tex) / 1048576.0f);
651         }
652
653         if (!valid) {
654                 if (err_out) {
655                         BLI_snprintf(err_out, 256, "GPUTexture: texture alloc failed\n");
656                 }
657                 else {
658                         fprintf(stderr, "GPUTexture: texture alloc failed. Likely not enough Video Memory.\n");
659                         fprintf(stderr, "Current texture memory usage : %.2f MiB.\n",
660                                         gpu_texture_memory_footprint_compute(tex) / 1048576.0f);
661                 }
662                 GPU_texture_free(tex);
663                 return NULL;
664         }
665
666         gpu_texture_memory_footprint_add(tex);
667
668         /* Upload Texture */
669         const float *pix = (rescaled_pixels) ? rescaled_pixels : pixels;
670
671         if (tex->target == GL_TEXTURE_2D ||
672             tex->target == GL_TEXTURE_2D_MULTISAMPLE ||
673             tex->target == GL_TEXTURE_1D_ARRAY)
674         {
675                 if (samples) {
676                         glTexImage2DMultisample(tex->target, samples, internalformat, tex->w, tex->h, true);
677                         if (pix)
678                                 glTexSubImage2D(tex->target, 0, 0, 0, tex->w, tex->h, data_format, data_type, pix);
679                 }
680                 else {
681                         glTexImage2D(tex->target, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, pix);
682                 }
683         }
684         else if (tex->target == GL_TEXTURE_1D) {
685                 glTexImage1D(tex->target, 0, internalformat, tex->w, 0, data_format, data_type, pix);
686         }
687         else {
688                 glTexImage3D(tex->target, 0, internalformat, tex->w, tex->h, tex->d, 0, data_format, data_type, pix);
689         }
690
691         if (rescaled_pixels)
692                 MEM_freeN(rescaled_pixels);
693
694         /* Texture Parameters */
695         if (GPU_texture_stencil(tex) || /* Does not support filtering */
696             GPU_texture_integer(tex) || /* Does not support filtering */
697             GPU_texture_depth(tex))
698         {
699                 glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
700                 glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
701         }
702         else {
703                 glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
704                 glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
705         }
706
707         if (GPU_texture_depth(tex)) {
708                 glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_MODE, GL_NONE);
709                 glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
710         }
711
712         glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
713         if (n > 1) {
714                 glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
715         }
716         if (n > 2) {
717                 glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
718         }
719
720         glBindTexture(tex->target, 0);
721
722         return tex;
723 }
724
725 static GPUTexture *GPU_texture_cube_create(
726         int w, int d,
727         const float *fpixels_px, const float *fpixels_py, const float *fpixels_pz,
728         const float *fpixels_nx, const float *fpixels_ny, const float *fpixels_nz,
729         GPUTextureFormat tex_format, GPUDataFormat gpu_data_format,
730         char err_out[256])
731 {
732         GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
733         tex->w = w;
734         tex->h = w;
735         tex->d = d;
736         tex->samples = 0;
737         tex->number = -1;
738         tex->refcount = 1;
739         tex->format = tex_format;
740         tex->components = gpu_get_component_count(tex_format);
741         tex->bytesize = gpu_get_bytesize(tex_format);
742         tex->format_flag = GPU_FORMAT_CUBE;
743
744         if (d == 0) {
745                 tex->target_base = tex->target = GL_TEXTURE_CUBE_MAP;
746         }
747         else {
748                 BLI_assert(false && "Cubemap array Not implemented yet");
749                 // tex->target_base = tex->target = GL_TEXTURE_CUBE_MAP_ARRAY;
750         }
751
752         GLenum internalformat = gpu_get_gl_internalformat(tex_format);
753         GLenum data_format = gpu_get_gl_dataformat(tex_format, &tex->format_flag);
754         GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
755
756         /* Generate Texture object */
757         tex->bindcode = GPU_tex_alloc();
758
759         if (!tex->bindcode) {
760                 if (err_out)
761                         BLI_snprintf(err_out, 256, "GPUTexture: texture create failed\n");
762                 else
763                         fprintf(stderr, "GPUTexture: texture create failed\n");
764                 GPU_texture_free(tex);
765                 return NULL;
766         }
767
768         if (G.debug & G_DEBUG_GPU) {
769                 printf("GPUTexture: create : %s, %s, w : %d, h : %d, d : %d, comp : %d, size : %.2f MiB\n",
770                        gl_enum_to_str(tex->target), gl_enum_to_str(internalformat),
771                        w, w, d, tex->components,
772                        gpu_texture_memory_footprint_compute(tex) / 1048576.0f);
773         }
774
775         gpu_texture_memory_footprint_add(tex);
776
777         glBindTexture(tex->target, tex->bindcode);
778
779         /* Upload Texture */
780         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_px);
781         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_py);
782         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_pz);
783         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_nx);
784         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_ny);
785         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_nz);
786
787         /* Texture Parameters */
788         if (GPU_texture_stencil(tex) || /* Does not support filtering */
789             GPU_texture_integer(tex) || /* Does not support filtering */
790             GPU_texture_depth(tex))
791         {
792                 glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
793                 glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
794         }
795         else {
796                 glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
797                 glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
798         }
799
800         if (GPU_texture_depth(tex)) {
801                 glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_MODE, GL_NONE);
802                 glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
803         }
804
805         glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
806         glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
807         glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
808
809         glBindTexture(tex->target, 0);
810
811         return tex;
812 }
813
814 /* Special buffer textures. tex_format must be compatible with the buffer content. */
815 GPUTexture *GPU_texture_create_buffer(GPUTextureFormat tex_format, const GLuint buffer)
816 {
817         GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
818         tex->number = -1;
819         tex->refcount = 1;
820         tex->format = tex_format;
821         tex->components = gpu_get_component_count(tex_format);
822         tex->format_flag = 0;
823         tex->target_base = tex->target = GL_TEXTURE_BUFFER;
824         tex->bytesize = gpu_get_bytesize(tex_format);
825
826         GLenum internalformat = gpu_get_gl_internalformat(tex_format);
827
828         gpu_get_gl_dataformat(tex_format, &tex->format_flag);
829
830         if (!(ELEM(tex_format, GPU_R8, GPU_R16) ||
831               ELEM(tex_format, GPU_R16F, GPU_R32F) ||
832               ELEM(tex_format, GPU_R8I, GPU_R16I, GPU_R32I) ||
833               ELEM(tex_format, GPU_R8UI, GPU_R16UI, GPU_R32UI) ||
834               ELEM(tex_format, GPU_RG8, GPU_RG16) ||
835               ELEM(tex_format, GPU_RG16F, GPU_RG32F) ||
836               ELEM(tex_format, GPU_RG8I, GPU_RG16I, GPU_RG32I) ||
837               ELEM(tex_format, GPU_RG8UI, GPU_RG16UI, GPU_RG32UI) ||
838               //ELEM(tex_format, GPU_RGB32F, GPU_RGB32I, GPU_RGB32UI) || /* Not available until gl 4.0 */
839               ELEM(tex_format, GPU_RGBA8, GPU_RGBA16) ||
840               ELEM(tex_format, GPU_RGBA16F, GPU_RGBA32F) ||
841               ELEM(tex_format, GPU_RGBA8I, GPU_RGBA16I, GPU_RGBA32I) ||
842               ELEM(tex_format, GPU_RGBA8UI, GPU_RGBA16UI, GPU_RGBA32UI)))
843         {
844                 fprintf(stderr, "GPUTexture: invalid format for texture buffer\n");
845                 GPU_texture_free(tex);
846                 return NULL;
847         }
848
849         /* Generate Texture object */
850         tex->bindcode = GPU_tex_alloc();
851
852         if (!tex->bindcode) {
853                 fprintf(stderr, "GPUTexture: texture create failed\n");
854                 GPU_texture_free(tex);
855                 BLI_assert(0 && "glGenTextures failed: Are you sure a valid OGL context is active on this thread?\n");
856                 return NULL;
857         }
858
859         glBindTexture(tex->target, tex->bindcode);
860         glTexBuffer(tex->target, internalformat, buffer);
861         glBindTexture(tex->target, 0);
862
863         return tex;
864 }
865
866 GPUTexture *GPU_texture_from_bindcode(int textarget, int bindcode)
867 {
868         /* see GPUInput::textarget: it can take two values - GL_TEXTURE_2D and GL_TEXTURE_CUBE_MAP
869          * these values are correct for glDisable, so textarget can be safely used in
870          * GPU_texture_bind/GPU_texture_unbind through tex->target_base */
871         /* (is any of this obsolete now that we don't glEnable/Disable textures?) */
872         GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
873         tex->bindcode = bindcode;
874         tex->number = -1;
875         tex->refcount = 1;
876         tex->target = textarget;
877         tex->target_base = textarget;
878         tex->format = -1;
879         tex->components = -1;
880         tex->samples = 0;
881
882         if (!glIsTexture(tex->bindcode)) {
883                 GPU_print_error_debug("Blender Texture Not Loaded");
884         }
885         else {
886                 GLint w, h;
887
888                 GLenum gettarget;
889
890                 if (textarget == GL_TEXTURE_2D)
891                         gettarget = GL_TEXTURE_2D;
892                 else
893                         gettarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
894
895                 glBindTexture(textarget, tex->bindcode);
896                 glGetTexLevelParameteriv(gettarget, 0, GL_TEXTURE_WIDTH, &w);
897                 glGetTexLevelParameteriv(gettarget, 0, GL_TEXTURE_HEIGHT, &h);
898                 tex->w = w;
899                 tex->h = h;
900                 glBindTexture(textarget, 0);
901         }
902
903         return tex;
904 }
905
906 GPUTexture *GPU_texture_from_preview(PreviewImage *prv, int mipmap)
907 {
908         GPUTexture *tex = prv->gputexture[0];
909         GLuint bindcode = 0;
910
911         if (tex)
912                 bindcode = tex->bindcode;
913
914         /* this binds a texture, so that's why we restore it to 0 */
915         if (bindcode == 0) {
916                 GPU_create_gl_tex(&bindcode, prv->rect[0], NULL, prv->w[0], prv->h[0], GL_TEXTURE_2D, mipmap, 0, NULL);
917         }
918         if (tex) {
919                 tex->bindcode = bindcode;
920                 glBindTexture(GL_TEXTURE_2D, 0);
921                 return tex;
922         }
923
924         tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
925         tex->bindcode = bindcode;
926         tex->number = -1;
927         tex->refcount = 1;
928         tex->target = GL_TEXTURE_2D;
929         tex->target_base = GL_TEXTURE_2D;
930         tex->format = -1;
931         tex->components = -1;
932
933         prv->gputexture[0] = tex;
934
935         if (!glIsTexture(tex->bindcode)) {
936                 GPU_print_error_debug("Blender Texture Not Loaded");
937         }
938         else {
939                 GLint w, h;
940
941                 glBindTexture(GL_TEXTURE_2D, tex->bindcode);
942                 glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
943                 glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h);
944
945                 tex->w = w;
946                 tex->h = h;
947         }
948
949         glBindTexture(GL_TEXTURE_2D, 0);
950
951         return tex;
952
953 }
954
955 GPUTexture *GPU_texture_create_1D(
956         int w, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
957 {
958         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
959         return GPU_texture_create_nD(w, 0, 0, 1, pixels, tex_format, data_format, 0, false, err_out);
960 }
961
962 GPUTexture *GPU_texture_create_1D_array(
963         int w, int h, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
964 {
965         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
966         return GPU_texture_create_nD(w, h, 0, 1, pixels, tex_format, data_format, 0, false, err_out);
967 }
968
969 GPUTexture *GPU_texture_create_2D(
970         int w, int h, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
971 {
972         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
973         return GPU_texture_create_nD(w, h, 0, 2, pixels, tex_format, data_format, 0, false, err_out);
974 }
975
976 GPUTexture *GPU_texture_create_2D_multisample(
977         int w, int h, GPUTextureFormat tex_format, const float *pixels, int samples, char err_out[256])
978 {
979         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
980         return GPU_texture_create_nD(w, h, 0, 2, pixels, tex_format, data_format, samples, false, err_out);
981 }
982
983 GPUTexture *GPU_texture_create_2D_array(
984         int w, int h, int d, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
985 {
986         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
987         return GPU_texture_create_nD(w, h, d, 2, pixels, tex_format, data_format, 0, false, err_out);
988 }
989
990 GPUTexture *GPU_texture_create_3D(
991         int w, int h, int d, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
992 {
993         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
994         return GPU_texture_create_nD(w, h, d, 3, pixels, tex_format, data_format, 0, true, err_out);
995 }
996
997 GPUTexture *GPU_texture_create_cube(
998         int w, GPUTextureFormat tex_format, const float *fpixels, char err_out[256])
999 {
1000         const float *fpixels_px, *fpixels_py, *fpixels_pz, *fpixels_nx, *fpixels_ny, *fpixels_nz;
1001         const int channels = gpu_get_component_count(tex_format);
1002
1003         if (fpixels) {
1004                 int face_ofs = w * w * channels;
1005                 fpixels_px = fpixels + 0 * face_ofs;
1006                 fpixels_nx = fpixels + 1 * face_ofs;
1007                 fpixels_py = fpixels + 2 * face_ofs;
1008                 fpixels_ny = fpixels + 3 * face_ofs;
1009                 fpixels_pz = fpixels + 4 * face_ofs;
1010                 fpixels_nz = fpixels + 5 * face_ofs;
1011         }
1012         else {
1013                 fpixels_px = fpixels_py = fpixels_pz = fpixels_nx = fpixels_ny = fpixels_nz = NULL;
1014         }
1015
1016         return GPU_texture_cube_create(w, 0, fpixels_px, fpixels_py, fpixels_pz, fpixels_nx, fpixels_ny, fpixels_nz,
1017                                        tex_format, GPU_DATA_FLOAT, err_out);
1018 }
1019
1020 GPUTexture *GPU_texture_create_from_vertbuf(GPUVertBuf *vert)
1021 {
1022         GPUVertFormat *format = &vert->format;
1023         GPUVertAttr *attr = &format->attribs[0];
1024
1025         /* Detect incompatible cases (not supported by texture buffers) */
1026         BLI_assert(format->attr_len == 1 && vert->vbo_id != 0);
1027         BLI_assert(attr->comp_len != 3); /* Not until OGL 4.0 */
1028         BLI_assert(attr->comp_type != GPU_COMP_I10);
1029         BLI_assert(attr->fetch_mode != GPU_FETCH_INT_TO_FLOAT);
1030
1031         uint byte_per_comp = attr->sz / attr->comp_len;
1032         bool is_uint = ELEM(attr->comp_type, GPU_COMP_U8, GPU_COMP_U16, GPU_COMP_U32);
1033
1034         /* Cannot fetch signed int or 32bit ints as normalized float. */
1035         if (attr->fetch_mode == GPU_FETCH_INT_TO_FLOAT_UNIT) {
1036                 BLI_assert(is_uint || byte_per_comp <= 2);
1037         }
1038
1039         GPUTextureFormat data_type;
1040         switch (attr->fetch_mode) {
1041                 case GPU_FETCH_FLOAT:
1042                         switch (attr->comp_len) {
1043                                 case 1: data_type = GPU_R32F; break;
1044                                 case 2: data_type = GPU_RG32F; break;
1045                                 // case 3: data_type = GPU_RGB32F; break; /* Not supported */
1046                                 default: data_type = GPU_RGBA32F; break;
1047                         }
1048                         break;
1049                 case GPU_FETCH_INT:
1050                         switch (attr->comp_len) {
1051                                 case 1:
1052                                         switch (byte_per_comp) {
1053                                                 case 1: data_type = (is_uint) ? GPU_R8UI : GPU_R8I; break;
1054                                                 case 2: data_type = (is_uint) ? GPU_R16UI : GPU_R16I; break;
1055                                                 default: data_type = (is_uint) ? GPU_R32UI : GPU_R32I; break;
1056                                         }
1057                                         break;
1058                                 case 2:
1059                                         switch (byte_per_comp) {
1060                                                 case 1: data_type = (is_uint) ? GPU_RG8UI : GPU_RG8I; break;
1061                                                 case 2: data_type = (is_uint) ? GPU_RG16UI : GPU_RG16I; break;
1062                                                 default: data_type = (is_uint) ? GPU_RG32UI : GPU_RG32I; break;
1063                                         }
1064                                         break;
1065                                 default:
1066                                         switch (byte_per_comp) {
1067                                                 case 1: data_type = (is_uint) ? GPU_RGBA8UI : GPU_RGBA8I; break;
1068                                                 case 2: data_type = (is_uint) ? GPU_RGBA16UI : GPU_RGBA16I; break;
1069                                                 default: data_type = (is_uint) ? GPU_RGBA32UI : GPU_RGBA32I; break;
1070                                         }
1071                                         break;
1072                         }
1073                         break;
1074                 case GPU_FETCH_INT_TO_FLOAT_UNIT:
1075                         switch (attr->comp_len) {
1076                                 case 1: data_type = (byte_per_comp == 1) ? GPU_R8 : GPU_R16; break;
1077                                 case 2: data_type = (byte_per_comp == 1) ? GPU_RG8 : GPU_RG16; break;
1078                                 default: data_type = (byte_per_comp == 1) ? GPU_RGBA8 : GPU_RGBA16; break;
1079                         }
1080                         break;
1081                 default:
1082                         BLI_assert(0);
1083                         return NULL;
1084         }
1085
1086         return GPU_texture_create_buffer(data_type, vert->vbo_id);
1087 }
1088
1089 void GPU_texture_add_mipmap(
1090         GPUTexture *tex, GPUDataFormat gpu_data_format, int miplvl, const void *pixels)
1091 {
1092         BLI_assert((int)tex->format > -1);
1093         BLI_assert(tex->components > -1);
1094
1095         gpu_validate_data_format(tex->format, gpu_data_format);
1096
1097         GLenum internalformat = gpu_get_gl_internalformat(tex->format);
1098         GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);
1099         GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
1100
1101         glBindTexture(tex->target, tex->bindcode);
1102
1103         int size[3];
1104         GPU_texture_get_mipmap_size(tex, miplvl, size);
1105
1106         switch (tex->target) {
1107                 case GL_TEXTURE_1D:
1108                         glTexImage1D(tex->target, miplvl, internalformat, size[0], 0, data_format, data_type, pixels);
1109                         break;
1110                 case GL_TEXTURE_2D:
1111                 case GL_TEXTURE_1D_ARRAY:
1112                         glTexImage2D(tex->target, miplvl, internalformat, size[0], size[1], 0, data_format, data_type, pixels);
1113                         break;
1114                 case GL_TEXTURE_3D:
1115                 case GL_TEXTURE_2D_ARRAY:
1116                         glTexImage3D(tex->target, miplvl, internalformat, size[0], size[1], size[2], 0, data_format, data_type, pixels);
1117                         break;
1118                 case GL_TEXTURE_2D_MULTISAMPLE:
1119                         /* Multisample textures cannot have mipmaps. */
1120                 default:
1121                         BLI_assert(!"tex->target mode not supported");
1122         }
1123
1124         glTexParameteri(GPU_texture_target(tex), GL_TEXTURE_MAX_LEVEL, miplvl);
1125
1126         glBindTexture(tex->target, 0);
1127 }
1128
1129 void GPU_texture_update_sub(
1130         GPUTexture *tex, GPUDataFormat gpu_data_format, const void *pixels,
1131         int offset_x, int offset_y, int offset_z, int width, int height, int depth)
1132 {
1133         BLI_assert((int)tex->format > -1);
1134         BLI_assert(tex->components > -1);
1135
1136         GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);
1137         GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
1138         GLint alignment;
1139
1140         /* The default pack size for textures is 4, which won't work for byte based textures */
1141         if (tex->bytesize == 1) {
1142                 glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
1143                 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1144         }
1145
1146         glBindTexture(tex->target, tex->bindcode);
1147         switch (tex->target) {
1148                 case GL_TEXTURE_1D:
1149                         glTexSubImage1D(tex->target, 0, offset_x, width, data_format, data_type, pixels);
1150                         break;
1151                 case GL_TEXTURE_2D:
1152                 case GL_TEXTURE_2D_MULTISAMPLE:
1153                 case GL_TEXTURE_1D_ARRAY:
1154                         glTexSubImage2D(
1155                                 tex->target, 0, offset_x, offset_y,
1156                                 width, height, data_format, data_type, pixels);
1157                         break;
1158                 case GL_TEXTURE_3D:
1159                 case GL_TEXTURE_2D_ARRAY:
1160                         glTexSubImage3D(
1161                                 tex->target, 0, offset_x, offset_y, offset_z,
1162                                 width, height, depth, data_format, data_type, pixels);
1163                         break;
1164                 default:
1165                         BLI_assert(!"tex->target mode not supported");
1166         }
1167
1168         if (tex->bytesize == 1) {
1169                 glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
1170         }
1171
1172         glBindTexture(tex->target, 0);
1173 }
1174
1175 void *GPU_texture_read(GPUTexture *tex, GPUDataFormat gpu_data_format, int miplvl)
1176 {
1177         int size[3] = {0, 0, 0};
1178         GPU_texture_get_mipmap_size(tex, miplvl, size);
1179
1180         gpu_validate_data_format(tex->format, gpu_data_format);
1181
1182         size_t buf_size = gpu_texture_memory_footprint_compute(tex);
1183         size_t samples_count = max_ii(1, tex->samples);
1184
1185         samples_count *= size[0];
1186         samples_count *= max_ii(1, size[1]);
1187         samples_count *= max_ii(1, size[2]);
1188         samples_count *= (GPU_texture_cube(tex)) ? 6 : 1;
1189
1190         switch (gpu_data_format) {
1191                 case GPU_DATA_FLOAT:
1192                         buf_size = sizeof(float) * samples_count * tex->components;
1193                         break;
1194                 case GPU_DATA_INT:
1195                 case GPU_DATA_UNSIGNED_INT:
1196                         buf_size = sizeof(int) * samples_count * tex->components;
1197                         break;
1198                 case GPU_DATA_UNSIGNED_INT_24_8:
1199                 case GPU_DATA_10_11_11_REV:
1200                         buf_size = sizeof(int) * samples_count;
1201                         break;
1202                 case GPU_DATA_UNSIGNED_BYTE:
1203                         break;
1204         }
1205
1206         void *buf = MEM_mallocN(buf_size, "GPU_texture_read");
1207
1208         GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);
1209         GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
1210
1211         glBindTexture(tex->target, tex->bindcode);
1212
1213         if (GPU_texture_cube(tex)) {
1214                 int cube_face_size = buf_size / 6;
1215                 for (int i = 0; i < 6; ++i) {
1216                         glGetTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, miplvl, data_format, data_type,
1217                                       ((char *)buf) + cube_face_size * i);
1218                 }
1219         }
1220         else {
1221                 glGetTexImage(tex->target, miplvl, data_format, data_type, buf);
1222         }
1223
1224         glBindTexture(tex->target, 0);
1225
1226         return buf;
1227 }
1228
1229 void GPU_texture_update(GPUTexture *tex, GPUDataFormat data_format, const void *pixels)
1230 {
1231         GPU_texture_update_sub(tex, data_format, pixels, 0, 0, 0, tex->w, tex->h, tex->d);
1232 }
1233
1234 void GPU_invalid_tex_init(void)
1235 {
1236         memory_usage = 0;
1237         const float color[4] = {1.0f, 0.0f, 1.0f, 1.0f};
1238         GG.invalid_tex_1D = GPU_texture_create_1D(1, GPU_RGBA8, color, NULL);
1239         GG.invalid_tex_2D = GPU_texture_create_2D(1, 1, GPU_RGBA8, color, NULL);
1240         GG.invalid_tex_3D = GPU_texture_create_3D(1, 1, 1, GPU_RGBA8, color, NULL);
1241 }
1242
1243 void GPU_invalid_tex_bind(int mode)
1244 {
1245         switch (mode) {
1246                 case GL_TEXTURE_1D:
1247                         glBindTexture(GL_TEXTURE_1D, GG.invalid_tex_1D->bindcode);
1248                         break;
1249                 case GL_TEXTURE_2D:
1250                         glBindTexture(GL_TEXTURE_2D, GG.invalid_tex_2D->bindcode);
1251                         break;
1252                 case GL_TEXTURE_3D:
1253                         glBindTexture(GL_TEXTURE_3D, GG.invalid_tex_3D->bindcode);
1254                         break;
1255         }
1256 }
1257
1258 void GPU_invalid_tex_free(void)
1259 {
1260         if (GG.invalid_tex_1D)
1261                 GPU_texture_free(GG.invalid_tex_1D);
1262         if (GG.invalid_tex_2D)
1263                 GPU_texture_free(GG.invalid_tex_2D);
1264         if (GG.invalid_tex_3D)
1265                 GPU_texture_free(GG.invalid_tex_3D);
1266 }
1267
1268 void GPU_texture_bind(GPUTexture *tex, int number)
1269 {
1270         BLI_assert(number >= 0);
1271
1272         if (number >= GPU_max_textures()) {
1273                 fprintf(stderr, "Not enough texture slots.\n");
1274                 return;
1275         }
1276
1277         if ((G.debug & G_DEBUG)) {
1278                 for (int i = 0; i < GPU_TEX_MAX_FBO_ATTACHED; ++i) {
1279                         if (tex->fb[i] && GPU_framebuffer_bound(tex->fb[i])) {
1280                                 fprintf(stderr,
1281                                         "Feedback loop warning!: Attempting to bind "
1282                                         "texture attached to current framebuffer!\n");
1283                                 BLI_assert(0); /* Should never happen! */
1284                                 break;
1285                         }
1286                 }
1287         }
1288
1289         glActiveTexture(GL_TEXTURE0 + number);
1290
1291         if (tex->bindcode != 0)
1292                 glBindTexture(tex->target, tex->bindcode);
1293         else
1294                 GPU_invalid_tex_bind(tex->target_base);
1295
1296         tex->number = number;
1297 }
1298
1299 void GPU_texture_unbind(GPUTexture *tex)
1300 {
1301         if (tex->number == -1)
1302                 return;
1303
1304         glActiveTexture(GL_TEXTURE0 + tex->number);
1305         glBindTexture(tex->target, 0);
1306
1307         tex->number = -1;
1308 }
1309
1310 int GPU_texture_bound_number(GPUTexture *tex)
1311 {
1312         return tex->number;
1313 }
1314
1315 #define WARN_NOT_BOUND(_tex) do { \
1316         if (_tex->number == -1) { \
1317                 fprintf(stderr, "Warning : Trying to set parameter on a texture not bound.\n"); \
1318                 BLI_assert(0); \
1319                 return; \
1320         } \
1321 } while (0);
1322
1323 void GPU_texture_generate_mipmap(GPUTexture *tex)
1324 {
1325         WARN_NOT_BOUND(tex);
1326
1327         glActiveTexture(GL_TEXTURE0 + tex->number);
1328
1329         if (GPU_texture_depth(tex)) {
1330                 /* Some drivers have bugs when using glGenerateMipmap with depth textures (see T56789).
1331                  * In this case we just create a complete texture with mipmaps manually without downsampling.
1332                  * You must initialize the texture levels using other methods like GPU_framebuffer_recursive_downsample(). */
1333                 int levels = 1 + floor(log2(max_ii(tex->w, tex->h)));
1334                 GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex->format);
1335                 for (int i = 1; i < levels; ++i) {
1336                         GPU_texture_add_mipmap(tex, data_format, i, NULL);
1337                 }
1338                 glBindTexture(tex->target, tex->bindcode);
1339         }
1340         else {
1341                 glGenerateMipmap(tex->target_base);
1342         }
1343 }
1344
1345 void GPU_texture_compare_mode(GPUTexture *tex, bool use_compare)
1346 {
1347         WARN_NOT_BOUND(tex);
1348
1349         /* Could become an assertion ? (fclem) */
1350         if (!GPU_texture_depth(tex))
1351                 return;
1352
1353         GLenum mode = (use_compare) ? GL_COMPARE_REF_TO_TEXTURE : GL_NONE;
1354
1355         glActiveTexture(GL_TEXTURE0 + tex->number);
1356         glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_MODE, mode);
1357 }
1358
1359 void GPU_texture_filter_mode(GPUTexture *tex, bool use_filter)
1360 {
1361         WARN_NOT_BOUND(tex);
1362
1363         /* Stencil and integer format does not support filtering. */
1364         BLI_assert(!use_filter || !(GPU_texture_stencil(tex) || GPU_texture_integer(tex)));
1365
1366         GLenum filter = (use_filter) ? GL_LINEAR : GL_NEAREST;
1367
1368         glActiveTexture(GL_TEXTURE0 + tex->number);
1369         glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, filter);
1370         glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, filter);
1371 }
1372
1373 void GPU_texture_mipmap_mode(GPUTexture *tex, bool use_mipmap, bool use_filter)
1374 {
1375         WARN_NOT_BOUND(tex);
1376
1377         /* Stencil and integer format does not support filtering. */
1378         BLI_assert((!use_filter && !use_mipmap) || !(GPU_texture_stencil(tex) || GPU_texture_integer(tex)));
1379
1380         GLenum filter = (use_filter) ? GL_LINEAR : GL_NEAREST;
1381         GLenum mipmap = (
1382                 (use_filter) ?
1383                 (use_mipmap) ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR :
1384                 (use_mipmap) ? GL_NEAREST_MIPMAP_LINEAR : GL_NEAREST);
1385
1386         glActiveTexture(GL_TEXTURE0 + tex->number);
1387         glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, mipmap);
1388         glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, filter);
1389 }
1390
1391 void GPU_texture_wrap_mode(GPUTexture *tex, bool use_repeat)
1392 {
1393         WARN_NOT_BOUND(tex);
1394
1395         GLenum repeat = (use_repeat) ? GL_REPEAT : GL_CLAMP_TO_EDGE;
1396
1397         glActiveTexture(GL_TEXTURE0 + tex->number);
1398         glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_S, repeat);
1399         if (tex->target_base != GL_TEXTURE_1D)
1400                 glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_T, repeat);
1401         if (tex->target_base == GL_TEXTURE_3D)
1402                 glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_R, repeat);
1403 }
1404
1405 static GLenum gpu_get_gl_filterfunction(GPUFilterFunction filter)
1406 {
1407         switch (filter) {
1408                 case GPU_NEAREST:
1409                         return GL_NEAREST;
1410                 case GPU_LINEAR:
1411                         return GL_LINEAR;
1412                 default:
1413                         BLI_assert(!"Unhandled filter mode");
1414                         return GL_NEAREST;
1415         }
1416 }
1417
1418 void GPU_texture_filters(GPUTexture *tex, GPUFilterFunction min_filter, GPUFilterFunction mag_filter)
1419 {
1420         WARN_NOT_BOUND(tex);
1421
1422         /* Stencil and integer format does not support filtering. */
1423         BLI_assert(!(GPU_texture_stencil(tex) || GPU_texture_integer(tex)));
1424         BLI_assert(mag_filter == GPU_NEAREST || mag_filter == GPU_LINEAR);
1425
1426         glActiveTexture(GL_TEXTURE0 + tex->number);
1427         glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, gpu_get_gl_filterfunction(min_filter));
1428         glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, gpu_get_gl_filterfunction(mag_filter));
1429 }
1430
1431 void GPU_texture_free(GPUTexture *tex)
1432 {
1433         tex->refcount--;
1434
1435         if (tex->refcount < 0)
1436                 fprintf(stderr, "GPUTexture: negative refcount\n");
1437
1438         if (tex->refcount == 0) {
1439                 for (int i = 0; i < GPU_TEX_MAX_FBO_ATTACHED; ++i) {
1440                         if (tex->fb[i] != NULL) {
1441                                 GPU_framebuffer_texture_detach_slot(tex->fb[i], tex, tex->fb_attachment[i]);
1442                         }
1443                 }
1444
1445                 if (tex->bindcode)
1446                         GPU_tex_free(tex->bindcode);
1447
1448                 gpu_texture_memory_footprint_remove(tex);
1449
1450                 MEM_freeN(tex);
1451         }
1452 }
1453
1454 void GPU_texture_ref(GPUTexture *tex)
1455 {
1456         tex->refcount++;
1457 }
1458
1459 int GPU_texture_target(const GPUTexture *tex)
1460 {
1461         return tex->target;
1462 }
1463
1464 int GPU_texture_width(const GPUTexture *tex)
1465 {
1466         return tex->w;
1467 }
1468
1469 int GPU_texture_height(const GPUTexture *tex)
1470 {
1471         return tex->h;
1472 }
1473
1474 int GPU_texture_layers(const GPUTexture *tex)
1475 {
1476         return tex->d;
1477 }
1478
1479 GPUTextureFormat GPU_texture_format(const GPUTexture *tex)
1480 {
1481         return tex->format;
1482 }
1483
1484 int GPU_texture_samples(const GPUTexture *tex)
1485 {
1486         return tex->samples;
1487 }
1488
1489 bool GPU_texture_depth(const GPUTexture *tex)
1490 {
1491         return (tex->format_flag & GPU_FORMAT_DEPTH) != 0;
1492 }
1493
1494 bool GPU_texture_stencil(const GPUTexture *tex)
1495 {
1496         return (tex->format_flag & GPU_FORMAT_STENCIL) != 0;
1497 }
1498
1499 bool GPU_texture_integer(const GPUTexture *tex)
1500 {
1501         return (tex->format_flag & GPU_FORMAT_INTEGER) != 0;
1502 }
1503
1504 bool GPU_texture_cube(const GPUTexture *tex)
1505 {
1506         return (tex->format_flag & GPU_FORMAT_CUBE) != 0;
1507 }
1508
1509 int GPU_texture_opengl_bindcode(const GPUTexture *tex)
1510 {
1511         return tex->bindcode;
1512 }
1513
1514 void GPU_texture_attach_framebuffer(GPUTexture *tex, GPUFrameBuffer *fb, int attachment)
1515 {
1516         for (int i = 0; i < GPU_TEX_MAX_FBO_ATTACHED; ++i) {
1517                 if (tex->fb[i] == NULL) {
1518                         tex->fb[i] = fb;
1519                         tex->fb_attachment[i] = attachment;
1520                         return;
1521                 }
1522         }
1523
1524         BLI_assert(!"Error: Texture: Not enough Framebuffer slots");
1525 }
1526
1527 /* Return previous attachment point */
1528 int GPU_texture_detach_framebuffer(GPUTexture *tex, GPUFrameBuffer *fb)
1529 {
1530         for (int i = 0; i < GPU_TEX_MAX_FBO_ATTACHED; ++i) {
1531                 if (tex->fb[i] == fb) {
1532                         tex->fb[i] = NULL;
1533                         return tex->fb_attachment[i];
1534                 }
1535         }
1536
1537         BLI_assert(!"Error: Texture: Framebuffer is not attached");
1538         return 0;
1539 }
1540
1541 void GPU_texture_get_mipmap_size(GPUTexture *tex, int lvl, int *size)
1542 {
1543         /* TODO assert if lvl is below the limit of 1px in each dimension. */
1544         int div = 1 << lvl;
1545         size[0] = max_ii(1, tex->w / div);
1546
1547         if (tex->target == GL_TEXTURE_1D_ARRAY) {
1548                 size[1] = tex->h;
1549         }
1550         else if (tex->h > 0) {
1551                 size[1] = max_ii(1, tex->h / div);
1552         }
1553
1554         if (tex->target == GL_TEXTURE_2D_ARRAY) {
1555                 size[2] = tex->d;
1556         }
1557         else if (tex->d > 0) {
1558                 size[2] = max_ii(1, tex->d / div);
1559         }
1560 }