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