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