Merge branch 'blender2.7'
[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 static bool gpu_texture_check_capacity(
484         GPUTexture *tex, GLenum proxy, GLenum internalformat,
485         GLenum data_format, GLenum data_type)
486 {
487         if (GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_WIN, GPU_DRIVER_ANY)) {
488                 /* Some AMD drivers have a faulty `GL_PROXY_TEXTURE_..` check.
489                  * (see T55888, T56185, T59351).
490                  * Checking with `GL_PROXY_TEXTURE_..` doesn't prevent `Out Of Memory` issue,
491                  * it just states that the OGL implementation can support the texture.
492                  * So manually check the maximum size and maximum number of layers. */
493                 switch (proxy) {
494                         case GL_PROXY_TEXTURE_2D_ARRAY:
495                                 if ((tex->d < 0) || (tex->d > GPU_max_texture_layers()))
496                                         return false;
497                                 break;
498
499                         case GL_PROXY_TEXTURE_1D_ARRAY:
500                                 if ((tex->h < 0) || (tex->h > GPU_max_texture_layers()))
501                                         return false;
502                                 break;
503                 }
504
505                 switch (proxy) {
506                         case GL_PROXY_TEXTURE_3D:
507                                 if ((tex->d < 0) || (tex->d > GPU_max_texture_size()))
508                                         return false;
509                                 ATTR_FALLTHROUGH;
510
511                         case GL_PROXY_TEXTURE_2D:
512                         case GL_PROXY_TEXTURE_2D_ARRAY:
513                                 if ((tex->h < 0) || (tex->h > GPU_max_texture_size()))
514                                         return false;
515                                 ATTR_FALLTHROUGH;
516
517                         case GL_PROXY_TEXTURE_1D:
518                         case GL_PROXY_TEXTURE_1D_ARRAY:
519                                 if ((tex->w < 0) || (tex->w > GPU_max_texture_size()))
520                                         return false;
521                                 ATTR_FALLTHROUGH;
522                 }
523
524                 return true;
525         }
526         else {
527                 switch (proxy) {
528                         case GL_PROXY_TEXTURE_1D:
529                                 glTexImage1D(proxy, 0, internalformat, tex->w, 0, data_format, data_type, NULL);
530                                 break;
531                         case GL_PROXY_TEXTURE_1D_ARRAY:
532                         case GL_PROXY_TEXTURE_2D:
533                                 glTexImage2D(proxy, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, NULL);
534                                 break;
535                         case GL_PROXY_TEXTURE_2D_ARRAY:
536                         case GL_PROXY_TEXTURE_3D:
537                                 glTexImage3D(proxy, 0, internalformat, tex->w, tex->h, tex->d, 0, data_format, data_type, NULL);
538                                 break;
539                 }
540                 int width = 0;
541                 glGetTexLevelParameteriv(proxy, 0, GL_TEXTURE_WIDTH, &width);
542
543                 return (width > 0);
544         }
545 }
546
547 /* This tries to allocate video memory for a given texture
548  * If alloc fails, lower the resolution until it fits. */
549 static bool gpu_texture_try_alloc(
550         GPUTexture *tex, GLenum proxy, GLenum internalformat, GLenum data_format, GLenum data_type,
551         int channels, bool try_rescale, const float *fpixels, float **rescaled_fpixels)
552 {
553         bool ret;
554         ret = gpu_texture_check_capacity(tex, proxy, internalformat, data_format, data_type);
555
556         if (!ret && try_rescale) {
557                 BLI_assert(!ELEM(proxy, GL_PROXY_TEXTURE_1D_ARRAY, GL_PROXY_TEXTURE_2D_ARRAY)); // not implemented
558
559                 const int w = tex->w, h = tex->h, d = tex->d;
560
561                 /* Find largest texture possible */
562                 do {
563                         tex->w /= 2;
564                         tex->h /= 2;
565                         tex->d /= 2;
566
567                         /* really unlikely to happen but keep this just in case */
568                         if (tex->w == 0) break;
569                         if (tex->h == 0 && proxy != GL_PROXY_TEXTURE_1D) break;
570                         if (tex->d == 0 && proxy == GL_PROXY_TEXTURE_3D) break;
571
572                         ret = gpu_texture_check_capacity(tex, proxy, internalformat, data_format, data_type);
573                 } while (ret == false);
574
575                 /* Rescale */
576                 if (ret) {
577                         switch (proxy) {
578                                 case GL_PROXY_TEXTURE_1D:
579                                 case GL_PROXY_TEXTURE_2D:
580                                         /* Do nothing for now */
581                                         return false;
582                                 case GL_PROXY_TEXTURE_3D:
583                                         BLI_assert(data_type == GL_FLOAT);
584                                         *rescaled_fpixels = GPU_texture_3D_rescale(tex, w, h, d, channels, fpixels);
585                                         return (bool)*rescaled_fpixels;
586                         }
587                 }
588         }
589
590         return ret;
591 }
592
593 GPUTexture *GPU_texture_create_nD(
594         int w, int h, int d, int n, const void *pixels,
595         GPUTextureFormat tex_format, GPUDataFormat gpu_data_format, int samples,
596         const bool can_rescale, char err_out[256])
597 {
598         if (samples) {
599                 CLAMP_MAX(samples, GPU_max_color_texture_samples());
600         }
601
602         if ((tex_format == GPU_DEPTH24_STENCIL8) && GPU_depth_blitting_workaround()) {
603                 /* MacOS + Radeon Pro fails to blit depth on GPU_DEPTH24_STENCIL8
604                  * but works on GPU_DEPTH32F_STENCIL8. */
605                 tex_format = GPU_DEPTH32F_STENCIL8;
606         }
607
608         GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
609         tex->w = w;
610         tex->h = h;
611         tex->d = d;
612         tex->samples = samples;
613         tex->number = -1;
614         tex->refcount = 1;
615         tex->format = tex_format;
616         tex->components = gpu_get_component_count(tex_format);
617         tex->bytesize = gpu_get_bytesize(tex_format);
618         tex->format_flag = 0;
619
620         if (n == 2) {
621                 if (d == 0)
622                         tex->target_base = tex->target = GL_TEXTURE_2D;
623                 else
624                         tex->target_base = tex->target = GL_TEXTURE_2D_ARRAY;
625         }
626         else if (n == 1) {
627                 if (h == 0)
628                         tex->target_base = tex->target = GL_TEXTURE_1D;
629                 else
630                         tex->target_base = tex->target = GL_TEXTURE_1D_ARRAY;
631         }
632         else if (n == 3) {
633                 tex->target_base = tex->target = GL_TEXTURE_3D;
634         }
635         else {
636                 /* should never happen */
637                 MEM_freeN(tex);
638                 return NULL;
639         }
640
641         gpu_validate_data_format(tex_format, gpu_data_format);
642
643         if (samples && n == 2 && d == 0)
644                 tex->target = GL_TEXTURE_2D_MULTISAMPLE;
645
646         GLenum internalformat = gpu_get_gl_internalformat(tex_format);
647         GLenum data_format = gpu_get_gl_dataformat(tex_format, &tex->format_flag);
648         GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
649
650         /* Generate Texture object */
651         tex->bindcode = GPU_tex_alloc();
652
653         if (!tex->bindcode) {
654                 if (err_out)
655                         BLI_snprintf(err_out, 256, "GPUTexture: texture create failed\n");
656                 else
657                         fprintf(stderr, "GPUTexture: texture create failed\n");
658                 GPU_texture_free(tex);
659                 return NULL;
660         }
661
662         glBindTexture(tex->target, tex->bindcode);
663
664         /* Check if texture fit in VRAM */
665         GLenum proxy = GL_PROXY_TEXTURE_2D;
666
667         if (n == 2) {
668                 if (d > 0)
669                         proxy = GL_PROXY_TEXTURE_2D_ARRAY;
670         }
671         else if (n == 1) {
672                 if (h == 0)
673                         proxy = GL_PROXY_TEXTURE_1D;
674                 else
675                         proxy = GL_PROXY_TEXTURE_1D_ARRAY;
676         }
677         else if (n == 3) {
678                 proxy = GL_PROXY_TEXTURE_3D;
679         }
680
681         float *rescaled_pixels = NULL;
682         bool valid = gpu_texture_try_alloc(tex, proxy, internalformat, data_format, data_type, tex->components, can_rescale,
683                                            pixels, &rescaled_pixels);
684
685         if (G.debug & G_DEBUG_GPU || !valid) {
686                 printf("GPUTexture: create : %s, %s, w : %d, h : %d, d : %d, comp : %d, size : %.2f MiB\n",
687                        gl_enum_to_str(tex->target), gl_enum_to_str(internalformat),
688                        w, h, d, tex->components,
689                        gpu_texture_memory_footprint_compute(tex) / 1048576.0f);
690         }
691
692         if (!valid) {
693                 if (err_out) {
694                         BLI_snprintf(err_out, 256, "GPUTexture: texture alloc failed\n");
695                 }
696                 else {
697                         fprintf(stderr, "GPUTexture: texture alloc failed. Likely not enough Video Memory.\n");
698                         fprintf(stderr, "Current texture memory usage : %.2f MiB.\n",
699                                         gpu_texture_memory_footprint_compute(tex) / 1048576.0f);
700                 }
701                 GPU_texture_free(tex);
702                 return NULL;
703         }
704
705         gpu_texture_memory_footprint_add(tex);
706
707         /* Upload Texture */
708         const float *pix = (rescaled_pixels) ? rescaled_pixels : pixels;
709
710         if (tex->target == GL_TEXTURE_2D ||
711             tex->target == GL_TEXTURE_2D_MULTISAMPLE ||
712             tex->target == GL_TEXTURE_1D_ARRAY)
713         {
714                 if (samples) {
715                         glTexImage2DMultisample(tex->target, samples, internalformat, tex->w, tex->h, true);
716                         if (pix)
717                                 glTexSubImage2D(tex->target, 0, 0, 0, tex->w, tex->h, data_format, data_type, pix);
718                 }
719                 else {
720                         glTexImage2D(tex->target, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, pix);
721                 }
722         }
723         else if (tex->target == GL_TEXTURE_1D) {
724                 glTexImage1D(tex->target, 0, internalformat, tex->w, 0, data_format, data_type, pix);
725         }
726         else {
727                 glTexImage3D(tex->target, 0, internalformat, tex->w, tex->h, tex->d, 0, data_format, data_type, pix);
728         }
729
730         if (rescaled_pixels)
731                 MEM_freeN(rescaled_pixels);
732
733         /* Texture Parameters */
734         if (GPU_texture_stencil(tex) || /* Does not support filtering */
735             GPU_texture_integer(tex) || /* Does not support filtering */
736             GPU_texture_depth(tex))
737         {
738                 glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
739                 glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
740         }
741         else {
742                 glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
743                 glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
744         }
745
746         if (GPU_texture_depth(tex)) {
747                 glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_MODE, GL_NONE);
748                 glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
749         }
750
751         glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
752         if (n > 1) {
753                 glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
754         }
755         if (n > 2) {
756                 glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
757         }
758
759         glBindTexture(tex->target, 0);
760
761         return tex;
762 }
763
764 static GPUTexture *GPU_texture_cube_create(
765         int w, int d,
766         const float *fpixels_px, const float *fpixels_py, const float *fpixels_pz,
767         const float *fpixels_nx, const float *fpixels_ny, const float *fpixels_nz,
768         GPUTextureFormat tex_format, GPUDataFormat gpu_data_format,
769         char err_out[256])
770 {
771         GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
772         tex->w = w;
773         tex->h = w;
774         tex->d = d;
775         tex->samples = 0;
776         tex->number = -1;
777         tex->refcount = 1;
778         tex->format = tex_format;
779         tex->components = gpu_get_component_count(tex_format);
780         tex->bytesize = gpu_get_bytesize(tex_format);
781         tex->format_flag = GPU_FORMAT_CUBE;
782
783         if (d == 0) {
784                 tex->target_base = tex->target = GL_TEXTURE_CUBE_MAP;
785         }
786         else {
787                 BLI_assert(false && "Cubemap array Not implemented yet");
788                 // tex->target_base = tex->target = GL_TEXTURE_CUBE_MAP_ARRAY;
789         }
790
791         GLenum internalformat = gpu_get_gl_internalformat(tex_format);
792         GLenum data_format = gpu_get_gl_dataformat(tex_format, &tex->format_flag);
793         GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
794
795         /* Generate Texture object */
796         tex->bindcode = GPU_tex_alloc();
797
798         if (!tex->bindcode) {
799                 if (err_out)
800                         BLI_snprintf(err_out, 256, "GPUTexture: texture create failed\n");
801                 else
802                         fprintf(stderr, "GPUTexture: texture create failed\n");
803                 GPU_texture_free(tex);
804                 return NULL;
805         }
806
807         if (G.debug & G_DEBUG_GPU) {
808                 printf("GPUTexture: create : %s, %s, w : %d, h : %d, d : %d, comp : %d, size : %.2f MiB\n",
809                        gl_enum_to_str(tex->target), gl_enum_to_str(internalformat),
810                        w, w, d, tex->components,
811                        gpu_texture_memory_footprint_compute(tex) / 1048576.0f);
812         }
813
814         gpu_texture_memory_footprint_add(tex);
815
816         glBindTexture(tex->target, tex->bindcode);
817
818         /* Upload Texture */
819         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_px);
820         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_py);
821         glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_pz);
822         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_nx);
823         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_ny);
824         glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, internalformat, tex->w, tex->h, 0, data_format, data_type, fpixels_nz);
825
826         /* Texture Parameters */
827         if (GPU_texture_stencil(tex) || /* Does not support filtering */
828             GPU_texture_integer(tex) || /* Does not support filtering */
829             GPU_texture_depth(tex))
830         {
831                 glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
832                 glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
833         }
834         else {
835                 glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
836                 glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
837         }
838
839         if (GPU_texture_depth(tex)) {
840                 glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_MODE, GL_NONE);
841                 glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
842         }
843
844         glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
845         glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
846         glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
847
848         glBindTexture(tex->target, 0);
849
850         return tex;
851 }
852
853 /* Special buffer textures. tex_format must be compatible with the buffer content. */
854 GPUTexture *GPU_texture_create_buffer(GPUTextureFormat tex_format, const GLuint buffer)
855 {
856         GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
857         tex->number = -1;
858         tex->refcount = 1;
859         tex->format = tex_format;
860         tex->components = gpu_get_component_count(tex_format);
861         tex->format_flag = 0;
862         tex->target_base = tex->target = GL_TEXTURE_BUFFER;
863         tex->bytesize = gpu_get_bytesize(tex_format);
864
865         GLenum internalformat = gpu_get_gl_internalformat(tex_format);
866
867         gpu_get_gl_dataformat(tex_format, &tex->format_flag);
868
869         if (!(ELEM(tex_format, GPU_R8, GPU_R16) ||
870               ELEM(tex_format, GPU_R16F, GPU_R32F) ||
871               ELEM(tex_format, GPU_R8I, GPU_R16I, GPU_R32I) ||
872               ELEM(tex_format, GPU_R8UI, GPU_R16UI, GPU_R32UI) ||
873               ELEM(tex_format, GPU_RG8, GPU_RG16) ||
874               ELEM(tex_format, GPU_RG16F, GPU_RG32F) ||
875               ELEM(tex_format, GPU_RG8I, GPU_RG16I, GPU_RG32I) ||
876               ELEM(tex_format, GPU_RG8UI, GPU_RG16UI, GPU_RG32UI) ||
877               //ELEM(tex_format, GPU_RGB32F, GPU_RGB32I, GPU_RGB32UI) || /* Not available until gl 4.0 */
878               ELEM(tex_format, GPU_RGBA8, GPU_RGBA16) ||
879               ELEM(tex_format, GPU_RGBA16F, GPU_RGBA32F) ||
880               ELEM(tex_format, GPU_RGBA8I, GPU_RGBA16I, GPU_RGBA32I) ||
881               ELEM(tex_format, GPU_RGBA8UI, GPU_RGBA16UI, GPU_RGBA32UI)))
882         {
883                 fprintf(stderr, "GPUTexture: invalid format for texture buffer\n");
884                 GPU_texture_free(tex);
885                 return NULL;
886         }
887
888         /* Generate Texture object */
889         tex->bindcode = GPU_tex_alloc();
890
891         if (!tex->bindcode) {
892                 fprintf(stderr, "GPUTexture: texture create failed\n");
893                 GPU_texture_free(tex);
894                 BLI_assert(0 && "glGenTextures failed: Are you sure a valid OGL context is active on this thread?\n");
895                 return NULL;
896         }
897
898         glBindTexture(tex->target, tex->bindcode);
899         glTexBuffer(tex->target, internalformat, buffer);
900         glBindTexture(tex->target, 0);
901
902         return tex;
903 }
904
905 GPUTexture *GPU_texture_from_bindcode(int textarget, int bindcode)
906 {
907         /* see GPUInput::textarget: it can take two values - GL_TEXTURE_2D and GL_TEXTURE_CUBE_MAP
908          * these values are correct for glDisable, so textarget can be safely used in
909          * GPU_texture_bind/GPU_texture_unbind through tex->target_base */
910         /* (is any of this obsolete now that we don't glEnable/Disable textures?) */
911         GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
912         tex->bindcode = bindcode;
913         tex->number = -1;
914         tex->refcount = 1;
915         tex->target = textarget;
916         tex->target_base = textarget;
917         tex->format = -1;
918         tex->components = -1;
919         tex->samples = 0;
920
921         if (!glIsTexture(tex->bindcode)) {
922                 GPU_print_error_debug("Blender Texture Not Loaded");
923         }
924         else {
925                 GLint w, h;
926
927                 GLenum gettarget;
928
929                 if (textarget == GL_TEXTURE_2D)
930                         gettarget = GL_TEXTURE_2D;
931                 else
932                         gettarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
933
934                 glBindTexture(textarget, tex->bindcode);
935                 glGetTexLevelParameteriv(gettarget, 0, GL_TEXTURE_WIDTH, &w);
936                 glGetTexLevelParameteriv(gettarget, 0, GL_TEXTURE_HEIGHT, &h);
937                 tex->w = w;
938                 tex->h = h;
939                 glBindTexture(textarget, 0);
940         }
941
942         return tex;
943 }
944
945 GPUTexture *GPU_texture_from_preview(PreviewImage *prv, int mipmap)
946 {
947         GPUTexture *tex = prv->gputexture[0];
948         GLuint bindcode = 0;
949
950         if (tex)
951                 bindcode = tex->bindcode;
952
953         /* this binds a texture, so that's why we restore it to 0 */
954         if (bindcode == 0) {
955                 GPU_create_gl_tex(&bindcode, prv->rect[0], NULL, prv->w[0], prv->h[0], GL_TEXTURE_2D, mipmap, 0, NULL);
956         }
957         if (tex) {
958                 tex->bindcode = bindcode;
959                 glBindTexture(GL_TEXTURE_2D, 0);
960                 return tex;
961         }
962
963         tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
964         tex->bindcode = bindcode;
965         tex->number = -1;
966         tex->refcount = 1;
967         tex->target = GL_TEXTURE_2D;
968         tex->target_base = GL_TEXTURE_2D;
969         tex->format = -1;
970         tex->components = -1;
971
972         prv->gputexture[0] = tex;
973
974         if (!glIsTexture(tex->bindcode)) {
975                 GPU_print_error_debug("Blender Texture Not Loaded");
976         }
977         else {
978                 GLint w, h;
979
980                 glBindTexture(GL_TEXTURE_2D, tex->bindcode);
981                 glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
982                 glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h);
983
984                 tex->w = w;
985                 tex->h = h;
986         }
987
988         glBindTexture(GL_TEXTURE_2D, 0);
989
990         return tex;
991
992 }
993
994 GPUTexture *GPU_texture_create_1D(
995         int w, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
996 {
997         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
998         return GPU_texture_create_nD(w, 0, 0, 1, pixels, tex_format, data_format, 0, false, err_out);
999 }
1000
1001 GPUTexture *GPU_texture_create_1D_array(
1002         int w, int h, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
1003 {
1004         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
1005         return GPU_texture_create_nD(w, h, 0, 1, pixels, tex_format, data_format, 0, false, err_out);
1006 }
1007
1008 GPUTexture *GPU_texture_create_2D(
1009         int w, int h, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
1010 {
1011         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
1012         return GPU_texture_create_nD(w, h, 0, 2, pixels, tex_format, data_format, 0, false, err_out);
1013 }
1014
1015 GPUTexture *GPU_texture_create_2D_multisample(
1016         int w, int h, GPUTextureFormat tex_format, const float *pixels, int samples, char err_out[256])
1017 {
1018         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
1019         return GPU_texture_create_nD(w, h, 0, 2, pixels, tex_format, data_format, samples, false, err_out);
1020 }
1021
1022 GPUTexture *GPU_texture_create_2D_array(
1023         int w, int h, int d, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
1024 {
1025         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
1026         return GPU_texture_create_nD(w, h, d, 2, pixels, tex_format, data_format, 0, false, err_out);
1027 }
1028
1029 GPUTexture *GPU_texture_create_3D(
1030         int w, int h, int d, GPUTextureFormat tex_format, const float *pixels, char err_out[256])
1031 {
1032         GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex_format);
1033         return GPU_texture_create_nD(w, h, d, 3, pixels, tex_format, data_format, 0, true, err_out);
1034 }
1035
1036 GPUTexture *GPU_texture_create_cube(
1037         int w, GPUTextureFormat tex_format, const float *fpixels, char err_out[256])
1038 {
1039         const float *fpixels_px, *fpixels_py, *fpixels_pz, *fpixels_nx, *fpixels_ny, *fpixels_nz;
1040         const int channels = gpu_get_component_count(tex_format);
1041
1042         if (fpixels) {
1043                 int face_ofs = w * w * channels;
1044                 fpixels_px = fpixels + 0 * face_ofs;
1045                 fpixels_nx = fpixels + 1 * face_ofs;
1046                 fpixels_py = fpixels + 2 * face_ofs;
1047                 fpixels_ny = fpixels + 3 * face_ofs;
1048                 fpixels_pz = fpixels + 4 * face_ofs;
1049                 fpixels_nz = fpixels + 5 * face_ofs;
1050         }
1051         else {
1052                 fpixels_px = fpixels_py = fpixels_pz = fpixels_nx = fpixels_ny = fpixels_nz = NULL;
1053         }
1054
1055         return GPU_texture_cube_create(w, 0, fpixels_px, fpixels_py, fpixels_pz, fpixels_nx, fpixels_ny, fpixels_nz,
1056                                        tex_format, GPU_DATA_FLOAT, err_out);
1057 }
1058
1059 GPUTexture *GPU_texture_create_from_vertbuf(GPUVertBuf *vert)
1060 {
1061         GPUVertFormat *format = &vert->format;
1062         GPUVertAttr *attr = &format->attribs[0];
1063
1064         /* Detect incompatible cases (not supported by texture buffers) */
1065         BLI_assert(format->attr_len == 1 && vert->vbo_id != 0);
1066         BLI_assert(attr->comp_len != 3); /* Not until OGL 4.0 */
1067         BLI_assert(attr->comp_type != GPU_COMP_I10);
1068         BLI_assert(attr->fetch_mode != GPU_FETCH_INT_TO_FLOAT);
1069
1070         uint byte_per_comp = attr->sz / attr->comp_len;
1071         bool is_uint = ELEM(attr->comp_type, GPU_COMP_U8, GPU_COMP_U16, GPU_COMP_U32);
1072
1073         /* Cannot fetch signed int or 32bit ints as normalized float. */
1074         if (attr->fetch_mode == GPU_FETCH_INT_TO_FLOAT_UNIT) {
1075                 BLI_assert(is_uint || byte_per_comp <= 2);
1076         }
1077
1078         GPUTextureFormat data_type;
1079         switch (attr->fetch_mode) {
1080                 case GPU_FETCH_FLOAT:
1081                         switch (attr->comp_len) {
1082                                 case 1: data_type = GPU_R32F; break;
1083                                 case 2: data_type = GPU_RG32F; break;
1084                                 // case 3: data_type = GPU_RGB32F; break; /* Not supported */
1085                                 default: data_type = GPU_RGBA32F; break;
1086                         }
1087                         break;
1088                 case GPU_FETCH_INT:
1089                         switch (attr->comp_len) {
1090                                 case 1:
1091                                         switch (byte_per_comp) {
1092                                                 case 1: data_type = (is_uint) ? GPU_R8UI : GPU_R8I; break;
1093                                                 case 2: data_type = (is_uint) ? GPU_R16UI : GPU_R16I; break;
1094                                                 default: data_type = (is_uint) ? GPU_R32UI : GPU_R32I; break;
1095                                         }
1096                                         break;
1097                                 case 2:
1098                                         switch (byte_per_comp) {
1099                                                 case 1: data_type = (is_uint) ? GPU_RG8UI : GPU_RG8I; break;
1100                                                 case 2: data_type = (is_uint) ? GPU_RG16UI : GPU_RG16I; break;
1101                                                 default: data_type = (is_uint) ? GPU_RG32UI : GPU_RG32I; break;
1102                                         }
1103                                         break;
1104                                 default:
1105                                         switch (byte_per_comp) {
1106                                                 case 1: data_type = (is_uint) ? GPU_RGBA8UI : GPU_RGBA8I; break;
1107                                                 case 2: data_type = (is_uint) ? GPU_RGBA16UI : GPU_RGBA16I; break;
1108                                                 default: data_type = (is_uint) ? GPU_RGBA32UI : GPU_RGBA32I; break;
1109                                         }
1110                                         break;
1111                         }
1112                         break;
1113                 case GPU_FETCH_INT_TO_FLOAT_UNIT:
1114                         switch (attr->comp_len) {
1115                                 case 1: data_type = (byte_per_comp == 1) ? GPU_R8 : GPU_R16; break;
1116                                 case 2: data_type = (byte_per_comp == 1) ? GPU_RG8 : GPU_RG16; break;
1117                                 default: data_type = (byte_per_comp == 1) ? GPU_RGBA8 : GPU_RGBA16; break;
1118                         }
1119                         break;
1120                 default:
1121                         BLI_assert(0);
1122                         return NULL;
1123         }
1124
1125         return GPU_texture_create_buffer(data_type, vert->vbo_id);
1126 }
1127
1128 void GPU_texture_add_mipmap(
1129         GPUTexture *tex, GPUDataFormat gpu_data_format, int miplvl, const void *pixels)
1130 {
1131         BLI_assert((int)tex->format > -1);
1132         BLI_assert(tex->components > -1);
1133
1134         gpu_validate_data_format(tex->format, gpu_data_format);
1135
1136         GLenum internalformat = gpu_get_gl_internalformat(tex->format);
1137         GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);
1138         GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
1139
1140         glBindTexture(tex->target, tex->bindcode);
1141
1142         int size[3];
1143         GPU_texture_get_mipmap_size(tex, miplvl, size);
1144
1145         switch (tex->target) {
1146                 case GL_TEXTURE_1D:
1147                         glTexImage1D(tex->target, miplvl, internalformat, size[0], 0, data_format, data_type, pixels);
1148                         break;
1149                 case GL_TEXTURE_2D:
1150                 case GL_TEXTURE_1D_ARRAY:
1151                         glTexImage2D(tex->target, miplvl, internalformat, size[0], size[1], 0, data_format, data_type, pixels);
1152                         break;
1153                 case GL_TEXTURE_3D:
1154                 case GL_TEXTURE_2D_ARRAY:
1155                         glTexImage3D(tex->target, miplvl, internalformat, size[0], size[1], size[2], 0, data_format, data_type, pixels);
1156                         break;
1157                 case GL_TEXTURE_2D_MULTISAMPLE:
1158                         /* Multisample textures cannot have mipmaps. */
1159                 default:
1160                         BLI_assert(!"tex->target mode not supported");
1161         }
1162
1163         glTexParameteri(GPU_texture_target(tex), GL_TEXTURE_MAX_LEVEL, miplvl);
1164
1165         glBindTexture(tex->target, 0);
1166 }
1167
1168 void GPU_texture_update_sub(
1169         GPUTexture *tex, GPUDataFormat gpu_data_format, const void *pixels,
1170         int offset_x, int offset_y, int offset_z, int width, int height, int depth)
1171 {
1172         BLI_assert((int)tex->format > -1);
1173         BLI_assert(tex->components > -1);
1174
1175         GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);
1176         GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
1177         GLint alignment;
1178
1179         /* The default pack size for textures is 4, which won't work for byte based textures */
1180         if (tex->bytesize == 1) {
1181                 glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
1182                 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
1183         }
1184
1185         glBindTexture(tex->target, tex->bindcode);
1186         switch (tex->target) {
1187                 case GL_TEXTURE_1D:
1188                         glTexSubImage1D(tex->target, 0, offset_x, width, data_format, data_type, pixels);
1189                         break;
1190                 case GL_TEXTURE_2D:
1191                 case GL_TEXTURE_2D_MULTISAMPLE:
1192                 case GL_TEXTURE_1D_ARRAY:
1193                         glTexSubImage2D(
1194                                 tex->target, 0, offset_x, offset_y,
1195                                 width, height, data_format, data_type, pixels);
1196                         break;
1197                 case GL_TEXTURE_3D:
1198                 case GL_TEXTURE_2D_ARRAY:
1199                         glTexSubImage3D(
1200                                 tex->target, 0, offset_x, offset_y, offset_z,
1201                                 width, height, depth, data_format, data_type, pixels);
1202                         break;
1203                 default:
1204                         BLI_assert(!"tex->target mode not supported");
1205         }
1206
1207         if (tex->bytesize == 1) {
1208                 glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
1209         }
1210
1211         glBindTexture(tex->target, 0);
1212 }
1213
1214 void *GPU_texture_read(GPUTexture *tex, GPUDataFormat gpu_data_format, int miplvl)
1215 {
1216         int size[3] = {0, 0, 0};
1217         GPU_texture_get_mipmap_size(tex, miplvl, size);
1218
1219         gpu_validate_data_format(tex->format, gpu_data_format);
1220
1221         size_t buf_size = gpu_texture_memory_footprint_compute(tex);
1222         size_t samples_count = max_ii(1, tex->samples);
1223
1224         samples_count *= size[0];
1225         samples_count *= max_ii(1, size[1]);
1226         samples_count *= max_ii(1, size[2]);
1227         samples_count *= (GPU_texture_cube(tex)) ? 6 : 1;
1228
1229         switch (gpu_data_format) {
1230                 case GPU_DATA_FLOAT:
1231                         buf_size = sizeof(float) * samples_count * tex->components;
1232                         break;
1233                 case GPU_DATA_INT:
1234                 case GPU_DATA_UNSIGNED_INT:
1235                         buf_size = sizeof(int) * samples_count * tex->components;
1236                         break;
1237                 case GPU_DATA_UNSIGNED_INT_24_8:
1238                 case GPU_DATA_10_11_11_REV:
1239                         buf_size = sizeof(int) * samples_count;
1240                         break;
1241                 case GPU_DATA_UNSIGNED_BYTE:
1242                         break;
1243         }
1244
1245         void *buf = MEM_mallocN(buf_size, "GPU_texture_read");
1246
1247         GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);
1248         GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
1249
1250         glBindTexture(tex->target, tex->bindcode);
1251
1252         if (GPU_texture_cube(tex)) {
1253                 int cube_face_size = buf_size / 6;
1254                 for (int i = 0; i < 6; ++i) {
1255                         glGetTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, miplvl, data_format, data_type,
1256                                       ((char *)buf) + cube_face_size * i);
1257                 }
1258         }
1259         else {
1260                 glGetTexImage(tex->target, miplvl, data_format, data_type, buf);
1261         }
1262
1263         glBindTexture(tex->target, 0);
1264
1265         return buf;
1266 }
1267
1268 void GPU_texture_update(GPUTexture *tex, GPUDataFormat data_format, const void *pixels)
1269 {
1270         GPU_texture_update_sub(tex, data_format, pixels, 0, 0, 0, tex->w, tex->h, tex->d);
1271 }
1272
1273 void GPU_invalid_tex_init(void)
1274 {
1275         memory_usage = 0;
1276         const float color[4] = {1.0f, 0.0f, 1.0f, 1.0f};
1277         GG.invalid_tex_1D = GPU_texture_create_1D(1, GPU_RGBA8, color, NULL);
1278         GG.invalid_tex_2D = GPU_texture_create_2D(1, 1, GPU_RGBA8, color, NULL);
1279         GG.invalid_tex_3D = GPU_texture_create_3D(1, 1, 1, GPU_RGBA8, color, NULL);
1280 }
1281
1282 void GPU_invalid_tex_bind(int mode)
1283 {
1284         switch (mode) {
1285                 case GL_TEXTURE_1D:
1286                         glBindTexture(GL_TEXTURE_1D, GG.invalid_tex_1D->bindcode);
1287                         break;
1288                 case GL_TEXTURE_2D:
1289                         glBindTexture(GL_TEXTURE_2D, GG.invalid_tex_2D->bindcode);
1290                         break;
1291                 case GL_TEXTURE_3D:
1292                         glBindTexture(GL_TEXTURE_3D, GG.invalid_tex_3D->bindcode);
1293                         break;
1294         }
1295 }
1296
1297 void GPU_invalid_tex_free(void)
1298 {
1299         if (GG.invalid_tex_1D)
1300                 GPU_texture_free(GG.invalid_tex_1D);
1301         if (GG.invalid_tex_2D)
1302                 GPU_texture_free(GG.invalid_tex_2D);
1303         if (GG.invalid_tex_3D)
1304                 GPU_texture_free(GG.invalid_tex_3D);
1305 }
1306
1307 void GPU_texture_bind(GPUTexture *tex, int number)
1308 {
1309         BLI_assert(number >= 0);
1310
1311         if (number >= GPU_max_textures()) {
1312                 fprintf(stderr, "Not enough texture slots.\n");
1313                 return;
1314         }
1315
1316         if ((G.debug & G_DEBUG)) {
1317                 for (int i = 0; i < GPU_TEX_MAX_FBO_ATTACHED; ++i) {
1318                         if (tex->fb[i] && GPU_framebuffer_bound(tex->fb[i])) {
1319                                 fprintf(stderr,
1320                                         "Feedback loop warning!: Attempting to bind "
1321                                         "texture attached to current framebuffer!\n");
1322                                 BLI_assert(0); /* Should never happen! */
1323                                 break;
1324                         }
1325                 }
1326         }
1327
1328         glActiveTexture(GL_TEXTURE0 + number);
1329
1330         if (tex->bindcode != 0)
1331                 glBindTexture(tex->target, tex->bindcode);
1332         else
1333                 GPU_invalid_tex_bind(tex->target_base);
1334
1335         tex->number = number;
1336 }
1337
1338 void GPU_texture_unbind(GPUTexture *tex)
1339 {
1340         if (tex->number == -1)
1341                 return;
1342
1343         glActiveTexture(GL_TEXTURE0 + tex->number);
1344         glBindTexture(tex->target, 0);
1345
1346         tex->number = -1;
1347 }
1348
1349 int GPU_texture_bound_number(GPUTexture *tex)
1350 {
1351         return tex->number;
1352 }
1353
1354 #define WARN_NOT_BOUND(_tex) do { \
1355         if (_tex->number == -1) { \
1356                 fprintf(stderr, "Warning : Trying to set parameter on a texture not bound.\n"); \
1357                 BLI_assert(0); \
1358                 return; \
1359         } \
1360 } while (0);
1361
1362 void GPU_texture_generate_mipmap(GPUTexture *tex)
1363 {
1364         WARN_NOT_BOUND(tex);
1365
1366         glActiveTexture(GL_TEXTURE0 + tex->number);
1367
1368         if (GPU_texture_depth(tex)) {
1369                 /* Some drivers have bugs when using glGenerateMipmap with depth textures (see T56789).
1370                  * In this case we just create a complete texture with mipmaps manually without downsampling.
1371                  * You must initialize the texture levels using other methods like GPU_framebuffer_recursive_downsample(). */
1372                 int levels = 1 + floor(log2(max_ii(tex->w, tex->h)));
1373                 GPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex->format);
1374                 for (int i = 1; i < levels; ++i) {
1375                         GPU_texture_add_mipmap(tex, data_format, i, NULL);
1376                 }
1377                 glBindTexture(tex->target, tex->bindcode);
1378         }
1379         else {
1380                 glGenerateMipmap(tex->target_base);
1381         }
1382 }
1383
1384 void GPU_texture_compare_mode(GPUTexture *tex, bool use_compare)
1385 {
1386         WARN_NOT_BOUND(tex);
1387
1388         /* Could become an assertion ? (fclem) */
1389         if (!GPU_texture_depth(tex))
1390                 return;
1391
1392         GLenum mode = (use_compare) ? GL_COMPARE_REF_TO_TEXTURE : GL_NONE;
1393
1394         glActiveTexture(GL_TEXTURE0 + tex->number);
1395         glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_MODE, mode);
1396 }
1397
1398 void GPU_texture_filter_mode(GPUTexture *tex, bool use_filter)
1399 {
1400         WARN_NOT_BOUND(tex);
1401
1402         /* Stencil and integer format does not support filtering. */
1403         BLI_assert(!use_filter || !(GPU_texture_stencil(tex) || GPU_texture_integer(tex)));
1404
1405         GLenum filter = (use_filter) ? GL_LINEAR : GL_NEAREST;
1406
1407         glActiveTexture(GL_TEXTURE0 + tex->number);
1408         glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, filter);
1409         glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, filter);
1410 }
1411
1412 void GPU_texture_mipmap_mode(GPUTexture *tex, bool use_mipmap, bool use_filter)
1413 {
1414         WARN_NOT_BOUND(tex);
1415
1416         /* Stencil and integer format does not support filtering. */
1417         BLI_assert((!use_filter && !use_mipmap) || !(GPU_texture_stencil(tex) || GPU_texture_integer(tex)));
1418
1419         GLenum filter = (use_filter) ? GL_LINEAR : GL_NEAREST;
1420         GLenum mipmap = (
1421                 (use_filter) ?
1422                 (use_mipmap) ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR :
1423                 (use_mipmap) ? GL_NEAREST_MIPMAP_LINEAR : GL_NEAREST);
1424
1425         glActiveTexture(GL_TEXTURE0 + tex->number);
1426         glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, mipmap);
1427         glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, filter);
1428 }
1429
1430 void GPU_texture_wrap_mode(GPUTexture *tex, bool use_repeat)
1431 {
1432         WARN_NOT_BOUND(tex);
1433
1434         GLenum repeat = (use_repeat) ? GL_REPEAT : GL_CLAMP_TO_EDGE;
1435
1436         glActiveTexture(GL_TEXTURE0 + tex->number);
1437         glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_S, repeat);
1438         if (tex->target_base != GL_TEXTURE_1D)
1439                 glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_T, repeat);
1440         if (tex->target_base == GL_TEXTURE_3D)
1441                 glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_R, repeat);
1442 }
1443
1444 static GLenum gpu_get_gl_filterfunction(GPUFilterFunction filter)
1445 {
1446         switch (filter) {
1447                 case GPU_NEAREST:
1448                         return GL_NEAREST;
1449                 case GPU_LINEAR:
1450                         return GL_LINEAR;
1451                 default:
1452                         BLI_assert(!"Unhandled filter mode");
1453                         return GL_NEAREST;
1454         }
1455 }
1456
1457 void GPU_texture_filters(GPUTexture *tex, GPUFilterFunction min_filter, GPUFilterFunction mag_filter)
1458 {
1459         WARN_NOT_BOUND(tex);
1460
1461         /* Stencil and integer format does not support filtering. */
1462         BLI_assert(!(GPU_texture_stencil(tex) || GPU_texture_integer(tex)));
1463         BLI_assert(mag_filter == GPU_NEAREST || mag_filter == GPU_LINEAR);
1464
1465         glActiveTexture(GL_TEXTURE0 + tex->number);
1466         glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, gpu_get_gl_filterfunction(min_filter));
1467         glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, gpu_get_gl_filterfunction(mag_filter));
1468 }
1469
1470 void GPU_texture_free(GPUTexture *tex)
1471 {
1472         tex->refcount--;
1473
1474         if (tex->refcount < 0)
1475                 fprintf(stderr, "GPUTexture: negative refcount\n");
1476
1477         if (tex->refcount == 0) {
1478                 for (int i = 0; i < GPU_TEX_MAX_FBO_ATTACHED; ++i) {
1479                         if (tex->fb[i] != NULL) {
1480                                 GPU_framebuffer_texture_detach_slot(tex->fb[i], tex, tex->fb_attachment[i]);
1481                         }
1482                 }
1483
1484                 if (tex->bindcode)
1485                         GPU_tex_free(tex->bindcode);
1486
1487                 gpu_texture_memory_footprint_remove(tex);
1488
1489                 MEM_freeN(tex);
1490         }
1491 }
1492
1493 void GPU_texture_ref(GPUTexture *tex)
1494 {
1495         tex->refcount++;
1496 }
1497
1498 int GPU_texture_target(const GPUTexture *tex)
1499 {
1500         return tex->target;
1501 }
1502
1503 int GPU_texture_width(const GPUTexture *tex)
1504 {
1505         return tex->w;
1506 }
1507
1508 int GPU_texture_height(const GPUTexture *tex)
1509 {
1510         return tex->h;
1511 }
1512
1513 int GPU_texture_layers(const GPUTexture *tex)
1514 {
1515         return tex->d;
1516 }
1517
1518 GPUTextureFormat GPU_texture_format(const GPUTexture *tex)
1519 {
1520         return tex->format;
1521 }
1522
1523 int GPU_texture_samples(const GPUTexture *tex)
1524 {
1525         return tex->samples;
1526 }
1527
1528 bool GPU_texture_depth(const GPUTexture *tex)
1529 {
1530         return (tex->format_flag & GPU_FORMAT_DEPTH) != 0;
1531 }
1532
1533 bool GPU_texture_stencil(const GPUTexture *tex)
1534 {
1535         return (tex->format_flag & GPU_FORMAT_STENCIL) != 0;
1536 }
1537
1538 bool GPU_texture_integer(const GPUTexture *tex)
1539 {
1540         return (tex->format_flag & GPU_FORMAT_INTEGER) != 0;
1541 }
1542
1543 bool GPU_texture_cube(const GPUTexture *tex)
1544 {
1545         return (tex->format_flag & GPU_FORMAT_CUBE) != 0;
1546 }
1547
1548 int GPU_texture_opengl_bindcode(const GPUTexture *tex)
1549 {
1550         return tex->bindcode;
1551 }
1552
1553 void GPU_texture_attach_framebuffer(GPUTexture *tex, GPUFrameBuffer *fb, int attachment)
1554 {
1555         for (int i = 0; i < GPU_TEX_MAX_FBO_ATTACHED; ++i) {
1556                 if (tex->fb[i] == NULL) {
1557                         tex->fb[i] = fb;
1558                         tex->fb_attachment[i] = attachment;
1559                         return;
1560                 }
1561         }
1562
1563         BLI_assert(!"Error: Texture: Not enough Framebuffer slots");
1564 }
1565
1566 /* Return previous attachment point */
1567 int GPU_texture_detach_framebuffer(GPUTexture *tex, GPUFrameBuffer *fb)
1568 {
1569         for (int i = 0; i < GPU_TEX_MAX_FBO_ATTACHED; ++i) {
1570                 if (tex->fb[i] == fb) {
1571                         tex->fb[i] = NULL;
1572                         return tex->fb_attachment[i];
1573                 }
1574         }
1575
1576         BLI_assert(!"Error: Texture: Framebuffer is not attached");
1577         return 0;
1578 }
1579
1580 void GPU_texture_get_mipmap_size(GPUTexture *tex, int lvl, int *size)
1581 {
1582         /* TODO assert if lvl is below the limit of 1px in each dimension. */
1583         int div = 1 << lvl;
1584         size[0] = max_ii(1, tex->w / div);
1585
1586         if (tex->target == GL_TEXTURE_1D_ARRAY) {
1587                 size[1] = tex->h;
1588         }
1589         else if (tex->h > 0) {
1590                 size[1] = max_ii(1, tex->h / div);
1591         }
1592
1593         if (tex->target == GL_TEXTURE_2D_ARRAY) {
1594                 size[2] = tex->d;
1595         }
1596         else if (tex->d > 0) {
1597                 size[2] = max_ii(1, tex->d / div);
1598         }
1599 }