Qt
Internal/Contributor docs for the Qt SDK. <b>Note:</b> These are NOT official API docs; those are found <a href='https://doc.qt.io/'>here</a>.
Loading...
Searching...
No Matches
qopengltexture.cpp
Go to the documentation of this file.
1// Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB).
2// Copyright (C) 2020 The Qt Company Ltd.
3// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
4
5#include "qopengltexture.h"
6#include "qopengltexture_p.h"
7#include "qopengltexturehelper_p.h"
8#include "qopenglfunctions.h"
9#include <QtGui/qcolor.h>
10#include <QtGui/qopenglcontext.h>
11#include <QtCore/qdebug.h>
12#include <private/qobject_p.h>
13#include <private/qopenglcontext_p.h>
14
15QT_BEGIN_NAMESPACE
16
17//this is to work around GL_TEXTURE_WRAP_R_OES which also has 0x8072 as value
18#if !defined(GL_TEXTURE_WRAP_R)
19 #define GL_TEXTURE_WRAP_R 0x8072
20#endif
21
22QOpenGLTexturePrivate::QOpenGLTexturePrivate(QOpenGLTexture::Target textureTarget,
23 QOpenGLTexture *qq)
24 : q_ptr(qq),
25 context(nullptr),
26 target(textureTarget),
27 textureId(0),
28 format(QOpenGLTexture::NoFormat),
29 formatClass(QOpenGLTexture::NoFormatClass),
30 requestedMipLevels(1),
31 mipLevels(-1),
32 layers(1),
33 faces(1),
34 samples(0),
35 fixedSamplePositions(true),
36 baseLevel(0),
37 maxLevel(1000),
38 depthStencilMode(QOpenGLTexture::DepthMode),
39 comparisonFunction(QOpenGLTexture::CompareLessEqual),
40 comparisonMode(QOpenGLTexture::CompareNone),
41 minFilter(QOpenGLTexture::Nearest),
42 magFilter(QOpenGLTexture::Nearest),
43 maxAnisotropy(1.0f),
44 minLevelOfDetail(-1000.0f),
45 maxLevelOfDetail(1000.0f),
46 levelOfDetailBias(0.0f),
47 textureView(false),
48 autoGenerateMipMaps(true),
49 storageAllocated(false),
50 texFuncs(nullptr),
51 functions(nullptr)
52{
53 dimensions[0] = dimensions[1] = dimensions[2] = 1;
54
55 switch (target) {
56 case QOpenGLTexture::Target1D:
57 bindingTarget = QOpenGLTexture::BindingTarget1D;
58 break;
59 case QOpenGLTexture::Target1DArray:
60 bindingTarget = QOpenGLTexture::BindingTarget1DArray;
61 break;
62 case QOpenGLTexture::Target2D:
63 bindingTarget = QOpenGLTexture::BindingTarget2D;
64 break;
65 case QOpenGLTexture::Target2DArray:
66 bindingTarget = QOpenGLTexture::BindingTarget2DArray;
67 break;
68 case QOpenGLTexture::Target3D:
69 bindingTarget = QOpenGLTexture::BindingTarget3D;
70 break;
71 case QOpenGLTexture::TargetCubeMap:
72 bindingTarget = QOpenGLTexture::BindingTargetCubeMap;
73 faces = 6;
74 break;
75 case QOpenGLTexture::TargetCubeMapArray:
76 bindingTarget = QOpenGLTexture::BindingTargetCubeMapArray;
77 faces = 6;
78 break;
79 case QOpenGLTexture::Target2DMultisample:
80 bindingTarget = QOpenGLTexture::BindingTarget2DMultisample;
81 break;
82 case QOpenGLTexture::Target2DMultisampleArray:
83 bindingTarget = QOpenGLTexture::BindingTarget2DMultisampleArray;
84 break;
85 case QOpenGLTexture::TargetRectangle:
86 bindingTarget = QOpenGLTexture::BindingTargetRectangle;
87 break;
88 case QOpenGLTexture::TargetBuffer:
89 bindingTarget = QOpenGLTexture::BindingTargetBuffer;
90 break;
91 }
92
93 swizzleMask[0] = QOpenGLTexture::RedValue;
94 swizzleMask[1] = QOpenGLTexture::GreenValue;
95 swizzleMask[2] = QOpenGLTexture::BlueValue;
96 swizzleMask[3] = QOpenGLTexture::AlphaValue;
97
98 wrapModes[0] = wrapModes[1] = wrapModes[2] = target == QOpenGLTexture::TargetRectangle
99 ? QOpenGLTexture::ClampToEdge : QOpenGLTexture::Repeat;
100}
101
106
107void QOpenGLTexturePrivate::initializeOpenGLFunctions()
108{
109 // If we already have a functions object, there is nothing to do
110 if (texFuncs)
111 return;
112
113 // See if the context already has a suitable resource we can use.
114 // If not create a functions object and add it to the context in case
115 // others wish to use it too
116 texFuncs = context->textureFunctions();
117 if (!texFuncs) {
118 texFuncs = new QOpenGLTextureHelper(context);
119 auto *funcs = texFuncs; // lets us capture by pointer value below
120 context->setTextureFunctions(funcs, [funcs] { delete funcs; });
121 }
122}
123
124bool QOpenGLTexturePrivate::create()
125{
126 if (textureId != 0)
127 return true;
128
129 QOpenGLContext *ctx = QOpenGLContext::currentContext();
130 if (!ctx) {
131 qWarning("Requires a valid current OpenGL context.\n"
132 "Texture has not been created");
133 return false;
134 }
135 context = ctx;
136 functions = ctx->functions();
137
138 // Resolve any functions we will need based upon context version and create the texture
139 initializeOpenGLFunctions();
140
141 // What features do we have?
142 QOpenGLTexture::Feature feature = QOpenGLTexture::ImmutableStorage;
143 while (feature != QOpenGLTexture::MaxFeatureFlag) {
144 if (QOpenGLTexture::hasFeature(feature))
145 features |= feature;
146 feature = static_cast<QOpenGLTexture::Feature>(feature << 1);
147 }
148
149 functions->glGenTextures(1, &textureId);
150 return textureId != 0;
151}
152
153void QOpenGLTexturePrivate::destroy()
154{
155 if (!textureId) {
156 // not created or already destroyed
157 return;
158 }
159 QOpenGLContext *currentContext = QOpenGLContext::currentContext();
160 if (!currentContext) {
161 qWarning("QOpenGLTexturePrivate::destroy() called without a current context.\n"
162 "Texture has not been destroyed");
163 return;
164 }
165 if (!QOpenGLContext::areSharing(currentContext, context)) {
166
167 qWarning("QOpenGLTexturePrivate::destroy() called but texture context %p"
168 " is not shared with current context %p.\n"
169 "Texture has not been destroyed",
170 static_cast<const void *>(context),
171 static_cast<const void *>(currentContext));
172 return;
173 }
174
175 functions->glDeleteTextures(1, &textureId);
176
177 context = nullptr;
178 functions = nullptr;
179 textureId = 0;
180 format = QOpenGLTexture::NoFormat;
181 formatClass = QOpenGLTexture::NoFormatClass;
182 requestedMipLevels = 1;
183 mipLevels = -1;
184 layers = 1;
185 faces = 1;
186 samples = 0;
187 fixedSamplePositions = true,
188 baseLevel = 0;
189 maxLevel = 1000;
190 depthStencilMode = QOpenGLTexture::DepthMode;
191 minFilter = QOpenGLTexture::Nearest;
192 magFilter = QOpenGLTexture::Nearest;
193 maxAnisotropy = 1.0f;
194 minLevelOfDetail = -1000.0f;
195 maxLevelOfDetail = 1000.0f;
196 levelOfDetailBias = 0.0f;
197 textureView = false;
198 autoGenerateMipMaps = true;
199 storageAllocated = false;
200 texFuncs = nullptr;
201
202 swizzleMask[0] = QOpenGLTexture::RedValue;
203 swizzleMask[1] = QOpenGLTexture::GreenValue;
204 swizzleMask[2] = QOpenGLTexture::BlueValue;
205 swizzleMask[3] = QOpenGLTexture::AlphaValue;
206
207 wrapModes[0] = wrapModes[1] = wrapModes[2] = target == QOpenGLTexture::TargetRectangle
208 ? QOpenGLTexture::ClampToEdge : QOpenGLTexture::Repeat;
209}
210
215
228
233
246
247bool QOpenGLTexturePrivate::isBound() const
248{
249 GLint boundTextureId = 0;
250 functions->glGetIntegerv(bindingTarget, &boundTextureId);
251 return (static_cast<GLuint>(boundTextureId) == textureId);
252}
253
254bool QOpenGLTexturePrivate::isBound(uint unit) const
255{
256 GLint oldTextureUnit = 0;
257 functions->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
258
259 GLint boundTextureId = 0;
260 texFuncs->glActiveTexture(GL_TEXTURE0 + unit);
261 functions->glGetIntegerv(bindingTarget, &boundTextureId);
262 bool result = (static_cast<GLuint>(boundTextureId) == textureId);
263
264 texFuncs->glActiveTexture(GL_TEXTURE0 + oldTextureUnit);
265 return result;
266}
267
288
289static bool isSizedTextureFormat(QOpenGLTexture::TextureFormat internalFormat)
290{
291 switch (internalFormat) {
292 case QOpenGLTexture::NoFormat:
293 return false;
294
295 case QOpenGLTexture::R8_UNorm:
296 case QOpenGLTexture::RG8_UNorm:
297 case QOpenGLTexture::RGB8_UNorm:
298 case QOpenGLTexture::RGBA8_UNorm:
299 case QOpenGLTexture::R16_UNorm:
300 case QOpenGLTexture::RG16_UNorm:
301 case QOpenGLTexture::RGB16_UNorm:
302 case QOpenGLTexture::RGBA16_UNorm:
303 case QOpenGLTexture::R8_SNorm:
304 case QOpenGLTexture::RG8_SNorm:
305 case QOpenGLTexture::RGB8_SNorm:
306 case QOpenGLTexture::RGBA8_SNorm:
307 case QOpenGLTexture::R16_SNorm:
308 case QOpenGLTexture::RG16_SNorm:
309 case QOpenGLTexture::RGB16_SNorm:
310 case QOpenGLTexture::RGBA16_SNorm:
311 case QOpenGLTexture::R8U:
312 case QOpenGLTexture::RG8U:
313 case QOpenGLTexture::RGB8U:
314 case QOpenGLTexture::RGBA8U:
315 case QOpenGLTexture::R16U:
316 case QOpenGLTexture::RG16U:
317 case QOpenGLTexture::RGB16U:
318 case QOpenGLTexture::RGBA16U:
319 case QOpenGLTexture::R32U:
320 case QOpenGLTexture::RG32U:
321 case QOpenGLTexture::RGB32U:
322 case QOpenGLTexture::RGBA32U:
323 case QOpenGLTexture::R8I:
324 case QOpenGLTexture::RG8I:
325 case QOpenGLTexture::RGB8I:
326 case QOpenGLTexture::RGBA8I:
327 case QOpenGLTexture::R16I:
328 case QOpenGLTexture::RG16I:
329 case QOpenGLTexture::RGB16I:
330 case QOpenGLTexture::RGBA16I:
331 case QOpenGLTexture::R32I:
332 case QOpenGLTexture::RG32I:
333 case QOpenGLTexture::RGB32I:
334 case QOpenGLTexture::RGBA32I:
335 case QOpenGLTexture::R16F:
336 case QOpenGLTexture::RG16F:
337 case QOpenGLTexture::RGB16F:
338 case QOpenGLTexture::RGBA16F:
339 case QOpenGLTexture::R32F:
340 case QOpenGLTexture::RG32F:
341 case QOpenGLTexture::RGB32F:
342 case QOpenGLTexture::RGBA32F:
343 case QOpenGLTexture::RGB9E5:
344 case QOpenGLTexture::RG11B10F:
345 case QOpenGLTexture::RG3B2:
346 case QOpenGLTexture::R5G6B5:
347 case QOpenGLTexture::RGB5A1:
348 case QOpenGLTexture::RGBA4:
349 case QOpenGLTexture::RGB10A2:
350
351 case QOpenGLTexture::D16:
352 case QOpenGLTexture::D24:
353 case QOpenGLTexture::D32:
354 case QOpenGLTexture::D32F:
355
356 case QOpenGLTexture::D24S8:
357 case QOpenGLTexture::D32FS8X24:
358
359 case QOpenGLTexture::S8:
360
361 case QOpenGLTexture::RGB_DXT1:
362 case QOpenGLTexture::RGBA_DXT1:
363 case QOpenGLTexture::RGBA_DXT3:
364 case QOpenGLTexture::RGBA_DXT5:
365 case QOpenGLTexture::R_ATI1N_UNorm:
366 case QOpenGLTexture::R_ATI1N_SNorm:
367 case QOpenGLTexture::RG_ATI2N_UNorm:
368 case QOpenGLTexture::RG_ATI2N_SNorm:
369 case QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT:
370 case QOpenGLTexture::RGB_BP_SIGNED_FLOAT:
371 case QOpenGLTexture::RGB_BP_UNorm:
372 case QOpenGLTexture::SRGB8:
373 case QOpenGLTexture::SRGB8_Alpha8:
374 case QOpenGLTexture::SRGB_DXT1:
375 case QOpenGLTexture::SRGB_Alpha_DXT1:
376 case QOpenGLTexture::SRGB_Alpha_DXT3:
377 case QOpenGLTexture::SRGB_Alpha_DXT5:
378 case QOpenGLTexture::SRGB_BP_UNorm:
379 case QOpenGLTexture::R11_EAC_UNorm:
380 case QOpenGLTexture::R11_EAC_SNorm:
381 case QOpenGLTexture::RG11_EAC_UNorm:
382 case QOpenGLTexture::RG11_EAC_SNorm:
383 case QOpenGLTexture::RGB8_ETC2:
384 case QOpenGLTexture::SRGB8_ETC2:
385 case QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC2:
386 case QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC2:
387 case QOpenGLTexture::RGBA8_ETC2_EAC:
388 case QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC:
389 case QOpenGLTexture::RGBA_ASTC_4x4:
390 case QOpenGLTexture::RGBA_ASTC_5x4:
391 case QOpenGLTexture::RGBA_ASTC_5x5:
392 case QOpenGLTexture::RGBA_ASTC_6x5:
393 case QOpenGLTexture::RGBA_ASTC_6x6:
394 case QOpenGLTexture::RGBA_ASTC_8x5:
395 case QOpenGLTexture::RGBA_ASTC_8x6:
396 case QOpenGLTexture::RGBA_ASTC_8x8:
397 case QOpenGLTexture::RGBA_ASTC_10x5:
398 case QOpenGLTexture::RGBA_ASTC_10x6:
399 case QOpenGLTexture::RGBA_ASTC_10x8:
400 case QOpenGLTexture::RGBA_ASTC_10x10:
401 case QOpenGLTexture::RGBA_ASTC_12x10:
402 case QOpenGLTexture::RGBA_ASTC_12x12:
403 case QOpenGLTexture::SRGB8_Alpha8_ASTC_4x4:
404 case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x4:
405 case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x5:
406 case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x5:
407 case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x6:
408 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x5:
409 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x6:
410 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x8:
411 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x5:
412 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x6:
413 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x8:
414 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x10:
415 case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x10:
416 case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x12:
417 return true;
418
419 case QOpenGLTexture::RGB8_ETC1:
420 return false;
421
422 case QOpenGLTexture::DepthFormat:
423 case QOpenGLTexture::AlphaFormat:
424
425 case QOpenGLTexture::RGBFormat:
426 case QOpenGLTexture::RGBAFormat:
427
428 case QOpenGLTexture::LuminanceFormat:
429
430 case QOpenGLTexture::LuminanceAlphaFormat:
431 return false;
432 }
433
434 Q_UNREACHABLE_RETURN(false);
435}
436
437static bool isTextureTargetMultisample(QOpenGLTexture::Target target)
438{
439 switch (target) {
440 case QOpenGLTexture::Target1D:
441 case QOpenGLTexture::Target1DArray:
442 case QOpenGLTexture::Target2D:
443 case QOpenGLTexture::Target2DArray:
444 case QOpenGLTexture::Target3D:
445 case QOpenGLTexture::TargetCubeMap:
446 case QOpenGLTexture::TargetCubeMapArray:
447 return false;
448
449 case QOpenGLTexture::Target2DMultisample:
450 case QOpenGLTexture::Target2DMultisampleArray:
451 return true;
452
453 case QOpenGLTexture::TargetRectangle:
454 case QOpenGLTexture::TargetBuffer:
455 return false;
456 }
457
458 Q_UNREACHABLE_RETURN(false);
459}
460
461bool QOpenGLTexturePrivate::isUsingImmutableStorage() const
462{
463 // Use immutable storage whenever possible, falling back to mutable
464 // Note that if multisample textures are not supported at all, we'll still fail into
465 // the mutable storage allocation
466 return isSizedTextureFormat(format)
467 && (isTextureTargetMultisample(target)
468 ? features.testFlag(QOpenGLTexture::ImmutableMultisampleStorage)
469 : features.testFlag(QOpenGLTexture::ImmutableStorage));
470}
471
472void QOpenGLTexturePrivate::allocateStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType)
473{
474 // Resolve the actual number of mipmap levels we can use
475 mipLevels = evaluateMipLevels();
476
477 if (isUsingImmutableStorage())
478 allocateImmutableStorage();
479 else
480 allocateMutableStorage(pixelFormat, pixelType);
481}
482
483static QOpenGLTexture::PixelFormat pixelFormatCompatibleWithInternalFormat(QOpenGLTexture::TextureFormat internalFormat)
484{
485 switch (internalFormat) {
486 case QOpenGLTexture::NoFormat:
487 return QOpenGLTexture::NoSourceFormat;
488
489 case QOpenGLTexture::R8_UNorm:
490 return QOpenGLTexture::Red;
491
492 case QOpenGLTexture::RG8_UNorm:
493 return QOpenGLTexture::RG;
494
495 case QOpenGLTexture::RGB8_UNorm:
496 return QOpenGLTexture::RGB;
497
498 case QOpenGLTexture::RGBA8_UNorm:
499 return QOpenGLTexture::RGBA;
500
501 case QOpenGLTexture::R16_UNorm:
502 return QOpenGLTexture::Red;
503
504 case QOpenGLTexture::RG16_UNorm:
505 return QOpenGLTexture::RG;
506
507 case QOpenGLTexture::RGB16_UNorm:
508 return QOpenGLTexture::RGB;
509
510 case QOpenGLTexture::RGBA16_UNorm:
511 return QOpenGLTexture::RGBA;
512
513 case QOpenGLTexture::R8_SNorm:
514 return QOpenGLTexture::Red;
515
516 case QOpenGLTexture::RG8_SNorm:
517 return QOpenGLTexture::RG;
518
519 case QOpenGLTexture::RGB8_SNorm:
520 return QOpenGLTexture::RGB;
521
522 case QOpenGLTexture::RGBA8_SNorm:
523 return QOpenGLTexture::RGBA;
524
525 case QOpenGLTexture::R16_SNorm:
526 return QOpenGLTexture::Red;
527
528 case QOpenGLTexture::RG16_SNorm:
529 return QOpenGLTexture::RG;
530
531 case QOpenGLTexture::RGB16_SNorm:
532 return QOpenGLTexture::RGB;
533
534 case QOpenGLTexture::RGBA16_SNorm:
535 return QOpenGLTexture::RGBA;
536
537 case QOpenGLTexture::R8U:
538 return QOpenGLTexture::Red_Integer;
539
540 case QOpenGLTexture::RG8U:
541 return QOpenGLTexture::RG_Integer;
542
543 case QOpenGLTexture::RGB8U:
544 return QOpenGLTexture::RGB_Integer;
545
546 case QOpenGLTexture::RGBA8U:
547 return QOpenGLTexture::RGBA_Integer;
548
549 case QOpenGLTexture::R16U:
550 return QOpenGLTexture::Red_Integer;
551
552 case QOpenGLTexture::RG16U:
553 return QOpenGLTexture::RG_Integer;
554
555 case QOpenGLTexture::RGB16U:
556 return QOpenGLTexture::RGB_Integer;
557
558 case QOpenGLTexture::RGBA16U:
559 return QOpenGLTexture::RGBA_Integer;
560
561 case QOpenGLTexture::R32U:
562 return QOpenGLTexture::Red_Integer;
563
564 case QOpenGLTexture::RG32U:
565 return QOpenGLTexture::RG_Integer;
566
567 case QOpenGLTexture::RGB32U:
568 return QOpenGLTexture::RGB_Integer;
569
570 case QOpenGLTexture::RGBA32U:
571 return QOpenGLTexture::RGBA_Integer;
572
573 case QOpenGLTexture::R8I:
574 return QOpenGLTexture::Red_Integer;
575
576 case QOpenGLTexture::RG8I:
577 return QOpenGLTexture::RG_Integer;
578
579 case QOpenGLTexture::RGB8I:
580 return QOpenGLTexture::RGB_Integer;
581
582 case QOpenGLTexture::RGBA8I:
583 return QOpenGLTexture::RGBA_Integer;
584
585 case QOpenGLTexture::R16I:
586 return QOpenGLTexture::Red_Integer;
587
588 case QOpenGLTexture::RG16I:
589 return QOpenGLTexture::RG_Integer;
590
591 case QOpenGLTexture::RGB16I:
592 return QOpenGLTexture::RGB_Integer;
593
594 case QOpenGLTexture::RGBA16I:
595 return QOpenGLTexture::RGBA_Integer;
596
597 case QOpenGLTexture::R32I:
598 return QOpenGLTexture::Red_Integer;
599
600 case QOpenGLTexture::RG32I:
601 return QOpenGLTexture::RG_Integer;
602
603 case QOpenGLTexture::RGB32I:
604 return QOpenGLTexture::RGB_Integer;
605
606 case QOpenGLTexture::RGBA32I:
607 return QOpenGLTexture::RGBA_Integer;
608
609 case QOpenGLTexture::R16F:
610 return QOpenGLTexture::Red;
611
612 case QOpenGLTexture::RG16F:
613 return QOpenGLTexture::RG;
614
615 case QOpenGLTexture::RGB16F:
616 return QOpenGLTexture::RGB;
617
618 case QOpenGLTexture::RGBA16F:
619 return QOpenGLTexture::RGBA;
620
621 case QOpenGLTexture::R32F:
622 return QOpenGLTexture::Red;
623
624 case QOpenGLTexture::RG32F:
625 return QOpenGLTexture::RG;
626
627 case QOpenGLTexture::RGB32F:
628 return QOpenGLTexture::RGB;
629
630 case QOpenGLTexture::RGBA32F:
631 return QOpenGLTexture::RGBA;
632
633 case QOpenGLTexture::RGB9E5:
634 return QOpenGLTexture::RGB;
635
636 case QOpenGLTexture::RG11B10F:
637 return QOpenGLTexture::RGB;
638
639 case QOpenGLTexture::RG3B2:
640 return QOpenGLTexture::RGB;
641
642 case QOpenGLTexture::R5G6B5:
643 return QOpenGLTexture::RGB;
644
645 case QOpenGLTexture::RGB5A1:
646 return QOpenGLTexture::RGBA;
647
648 case QOpenGLTexture::RGBA4:
649 return QOpenGLTexture::RGBA;
650
651 case QOpenGLTexture::RGB10A2:
652 return QOpenGLTexture::RGBA;
653
654 case QOpenGLTexture::D16:
655 case QOpenGLTexture::D24:
656 case QOpenGLTexture::D32:
657 case QOpenGLTexture::D32F:
658 return QOpenGLTexture::Depth;
659
660 case QOpenGLTexture::D24S8:
661 case QOpenGLTexture::D32FS8X24:
662 return QOpenGLTexture::DepthStencil;
663
664 case QOpenGLTexture::S8:
665 return QOpenGLTexture::Stencil;
666
667 case QOpenGLTexture::RGB_DXT1:
668 case QOpenGLTexture::RGBA_DXT1:
669 case QOpenGLTexture::RGBA_DXT3:
670 case QOpenGLTexture::RGBA_DXT5:
671 case QOpenGLTexture::R_ATI1N_UNorm:
672 case QOpenGLTexture::R_ATI1N_SNorm:
673 case QOpenGLTexture::RG_ATI2N_UNorm:
674 case QOpenGLTexture::RG_ATI2N_SNorm:
675 case QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT:
676 case QOpenGLTexture::RGB_BP_SIGNED_FLOAT:
677 case QOpenGLTexture::RGB_BP_UNorm:
678 case QOpenGLTexture::SRGB8:
679 case QOpenGLTexture::SRGB8_Alpha8:
680 case QOpenGLTexture::SRGB_DXT1:
681 case QOpenGLTexture::SRGB_Alpha_DXT1:
682 case QOpenGLTexture::SRGB_Alpha_DXT3:
683 case QOpenGLTexture::SRGB_Alpha_DXT5:
684 case QOpenGLTexture::SRGB_BP_UNorm:
685 case QOpenGLTexture::RGB8_ETC1:
686 return QOpenGLTexture::RGBA;
687
688 case QOpenGLTexture::R11_EAC_UNorm:
689 case QOpenGLTexture::R11_EAC_SNorm:
690 return QOpenGLTexture::Red;
691
692 case QOpenGLTexture::RG11_EAC_UNorm:
693 case QOpenGLTexture::RG11_EAC_SNorm:
694 return QOpenGLTexture::RG;
695
696 case QOpenGLTexture::RGB8_ETC2:
697 case QOpenGLTexture::SRGB8_ETC2:
698 return QOpenGLTexture::RGB;
699
700 case QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC2:
701 case QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC2:
702 return QOpenGLTexture::RGBA;
703
704 case QOpenGLTexture::RGBA8_ETC2_EAC:
705 case QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC:
706 return QOpenGLTexture::RGBA;
707
708 case QOpenGLTexture::RGBA_ASTC_4x4:
709 case QOpenGLTexture::RGBA_ASTC_5x4:
710 case QOpenGLTexture::RGBA_ASTC_5x5:
711 case QOpenGLTexture::RGBA_ASTC_6x5:
712 case QOpenGLTexture::RGBA_ASTC_6x6:
713 case QOpenGLTexture::RGBA_ASTC_8x5:
714 case QOpenGLTexture::RGBA_ASTC_8x6:
715 case QOpenGLTexture::RGBA_ASTC_8x8:
716 case QOpenGLTexture::RGBA_ASTC_10x5:
717 case QOpenGLTexture::RGBA_ASTC_10x6:
718 case QOpenGLTexture::RGBA_ASTC_10x8:
719 case QOpenGLTexture::RGBA_ASTC_10x10:
720 case QOpenGLTexture::RGBA_ASTC_12x10:
721 case QOpenGLTexture::RGBA_ASTC_12x12:
722 case QOpenGLTexture::SRGB8_Alpha8_ASTC_4x4:
723 case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x4:
724 case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x5:
725 case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x5:
726 case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x6:
727 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x5:
728 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x6:
729 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x8:
730 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x5:
731 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x6:
732 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x8:
733 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x10:
734 case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x10:
735 case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x12:
736 return QOpenGLTexture::RGBA;
737
738 case QOpenGLTexture::DepthFormat:
739 return QOpenGLTexture::Depth;
740
741 case QOpenGLTexture::AlphaFormat:
742 return QOpenGLTexture::Alpha;
743
744 case QOpenGLTexture::RGBFormat:
745 return QOpenGLTexture::RGB;
746
747 case QOpenGLTexture::RGBAFormat:
748 return QOpenGLTexture::RGBA;
749
750 case QOpenGLTexture::LuminanceFormat:
751 return QOpenGLTexture::Luminance;
752
753 case QOpenGLTexture::LuminanceAlphaFormat:
754 return QOpenGLTexture::LuminanceAlpha;
755 }
756
757 Q_UNREACHABLE_RETURN(QOpenGLTexture::NoSourceFormat);
758}
759
760static QOpenGLTexture::PixelType pixelTypeCompatibleWithInternalFormat(QOpenGLTexture::TextureFormat internalFormat)
761{
762 switch (internalFormat) {
763 case QOpenGLTexture::NoFormat:
764 return QOpenGLTexture::NoPixelType;
765
766 case QOpenGLTexture::R8_UNorm:
767 case QOpenGLTexture::RG8_UNorm:
768 case QOpenGLTexture::RGB8_UNorm:
769 case QOpenGLTexture::RGBA8_UNorm:
770 case QOpenGLTexture::R16_UNorm:
771 case QOpenGLTexture::RG16_UNorm:
772 case QOpenGLTexture::RGB16_UNorm:
773 case QOpenGLTexture::RGBA16_UNorm:
774 return QOpenGLTexture::UInt8;
775
776 case QOpenGLTexture::R8_SNorm:
777 case QOpenGLTexture::RG8_SNorm:
778 case QOpenGLTexture::RGB8_SNorm:
779 case QOpenGLTexture::RGBA8_SNorm:
780 case QOpenGLTexture::R16_SNorm:
781 case QOpenGLTexture::RG16_SNorm:
782 case QOpenGLTexture::RGB16_SNorm:
783 case QOpenGLTexture::RGBA16_SNorm:
784 return QOpenGLTexture::Int8;
785
786 case QOpenGLTexture::R8U:
787 case QOpenGLTexture::RG8U:
788 case QOpenGLTexture::RGB8U:
789 case QOpenGLTexture::RGBA8U:
790 case QOpenGLTexture::R16U:
791 case QOpenGLTexture::RG16U:
792 case QOpenGLTexture::RGB16U:
793 case QOpenGLTexture::RGBA16U:
794 case QOpenGLTexture::R32U:
795 case QOpenGLTexture::RG32U:
796 case QOpenGLTexture::RGB32U:
797 case QOpenGLTexture::RGBA32U:
798 return QOpenGLTexture::UInt8;
799
800 case QOpenGLTexture::R8I:
801 case QOpenGLTexture::RG8I:
802 case QOpenGLTexture::RGB8I:
803 case QOpenGLTexture::RGBA8I:
804 case QOpenGLTexture::R16I:
805 case QOpenGLTexture::RG16I:
806 case QOpenGLTexture::RGB16I:
807 case QOpenGLTexture::RGBA16I:
808 case QOpenGLTexture::R32I:
809 case QOpenGLTexture::RG32I:
810 case QOpenGLTexture::RGB32I:
811 case QOpenGLTexture::RGBA32I:
812 return QOpenGLTexture::Int8;
813
814 case QOpenGLTexture::R16F:
815 case QOpenGLTexture::RG16F:
816 case QOpenGLTexture::RGB16F:
817 case QOpenGLTexture::RGBA16F:
818 return QOpenGLTexture::Float16;
819
820 case QOpenGLTexture::R32F:
821 case QOpenGLTexture::RG32F:
822 case QOpenGLTexture::RGB32F:
823 case QOpenGLTexture::RGBA32F:
824 return QOpenGLTexture::Float32;
825
826 case QOpenGLTexture::RGB9E5:
827 return QOpenGLTexture::UInt16_RGB5A1_Rev;
828
829 case QOpenGLTexture::RG11B10F:
830 return QOpenGLTexture::UInt32_RG11B10F;
831
832 case QOpenGLTexture::RG3B2:
833 return QOpenGLTexture::UInt8_RG3B2;
834
835 case QOpenGLTexture::R5G6B5:
836 return QOpenGLTexture::UInt16_R5G6B5;
837
838 case QOpenGLTexture::RGB5A1:
839 return QOpenGLTexture::UInt16_RGB5A1;
840
841 case QOpenGLTexture::RGBA4:
842 return QOpenGLTexture::UInt16_RGBA4;
843
844 case QOpenGLTexture::RGB10A2:
845 return QOpenGLTexture::UInt32_RGB10A2;
846
847 case QOpenGLTexture::D16:
848 return QOpenGLTexture::UInt16;
849
850 case QOpenGLTexture::D24:
851 case QOpenGLTexture::D32:
852 return QOpenGLTexture::UInt32;
853
854 case QOpenGLTexture::D32F:
855 return QOpenGLTexture::Float32;
856
857 case QOpenGLTexture::D24S8:
858 return QOpenGLTexture::UInt32_D24S8;
859
860 case QOpenGLTexture::D32FS8X24:
861 return QOpenGLTexture::Float32_D32_UInt32_S8_X24;
862
863 case QOpenGLTexture::S8:
864 return QOpenGLTexture::UInt8;
865
866 case QOpenGLTexture::RGB_DXT1:
867 case QOpenGLTexture::RGBA_DXT1:
868 case QOpenGLTexture::RGBA_DXT3:
869 case QOpenGLTexture::RGBA_DXT5:
870 case QOpenGLTexture::R_ATI1N_UNorm:
871 case QOpenGLTexture::R_ATI1N_SNorm:
872 case QOpenGLTexture::RG_ATI2N_UNorm:
873 case QOpenGLTexture::RG_ATI2N_SNorm:
874 case QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT:
875 case QOpenGLTexture::RGB_BP_SIGNED_FLOAT:
876 case QOpenGLTexture::RGB_BP_UNorm:
877 case QOpenGLTexture::SRGB8:
878 case QOpenGLTexture::SRGB8_Alpha8:
879 case QOpenGLTexture::SRGB_DXT1:
880 case QOpenGLTexture::SRGB_Alpha_DXT1:
881 case QOpenGLTexture::SRGB_Alpha_DXT3:
882 case QOpenGLTexture::SRGB_Alpha_DXT5:
883 case QOpenGLTexture::SRGB_BP_UNorm:
884 case QOpenGLTexture::R11_EAC_UNorm:
885 case QOpenGLTexture::R11_EAC_SNorm:
886 case QOpenGLTexture::RG11_EAC_UNorm:
887 case QOpenGLTexture::RG11_EAC_SNorm:
888 case QOpenGLTexture::RGB8_ETC2:
889 case QOpenGLTexture::SRGB8_ETC2:
890 case QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC2:
891 case QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC2:
892 case QOpenGLTexture::RGBA8_ETC2_EAC:
893 case QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC:
894 case QOpenGLTexture::RGB8_ETC1:
895 case QOpenGLTexture::RGBA_ASTC_4x4:
896 case QOpenGLTexture::RGBA_ASTC_5x4:
897 case QOpenGLTexture::RGBA_ASTC_5x5:
898 case QOpenGLTexture::RGBA_ASTC_6x5:
899 case QOpenGLTexture::RGBA_ASTC_6x6:
900 case QOpenGLTexture::RGBA_ASTC_8x5:
901 case QOpenGLTexture::RGBA_ASTC_8x6:
902 case QOpenGLTexture::RGBA_ASTC_8x8:
903 case QOpenGLTexture::RGBA_ASTC_10x5:
904 case QOpenGLTexture::RGBA_ASTC_10x6:
905 case QOpenGLTexture::RGBA_ASTC_10x8:
906 case QOpenGLTexture::RGBA_ASTC_10x10:
907 case QOpenGLTexture::RGBA_ASTC_12x10:
908 case QOpenGLTexture::RGBA_ASTC_12x12:
909 case QOpenGLTexture::SRGB8_Alpha8_ASTC_4x4:
910 case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x4:
911 case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x5:
912 case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x5:
913 case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x6:
914 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x5:
915 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x6:
916 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x8:
917 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x5:
918 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x6:
919 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x8:
920 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x10:
921 case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x10:
922 case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x12:
923 return QOpenGLTexture::UInt8;
924
925 case QOpenGLTexture::DepthFormat:
926 return QOpenGLTexture::UInt32;
927
928 case QOpenGLTexture::AlphaFormat:
929 case QOpenGLTexture::RGBFormat:
930 case QOpenGLTexture::RGBAFormat:
931 case QOpenGLTexture::LuminanceFormat:
932 case QOpenGLTexture::LuminanceAlphaFormat:
933 return QOpenGLTexture::UInt8;
934 }
935
936 Q_UNREACHABLE_RETURN(QOpenGLTexture::NoPixelType);
937}
938
939static bool isCompressedFormat(QOpenGLTexture::TextureFormat internalFormat)
940{
941 switch (internalFormat) {
942 case QOpenGLTexture::NoFormat:
943
944 case QOpenGLTexture::R8_UNorm:
945 case QOpenGLTexture::RG8_UNorm:
946 case QOpenGLTexture::RGB8_UNorm:
947 case QOpenGLTexture::RGBA8_UNorm:
948 case QOpenGLTexture::R16_UNorm:
949 case QOpenGLTexture::RG16_UNorm:
950 case QOpenGLTexture::RGB16_UNorm:
951 case QOpenGLTexture::RGBA16_UNorm:
952 case QOpenGLTexture::R8_SNorm:
953 case QOpenGLTexture::RG8_SNorm:
954 case QOpenGLTexture::RGB8_SNorm:
955 case QOpenGLTexture::RGBA8_SNorm:
956 case QOpenGLTexture::R16_SNorm:
957 case QOpenGLTexture::RG16_SNorm:
958 case QOpenGLTexture::RGB16_SNorm:
959 case QOpenGLTexture::RGBA16_SNorm:
960 case QOpenGLTexture::R8U:
961 case QOpenGLTexture::RG8U:
962 case QOpenGLTexture::RGB8U:
963 case QOpenGLTexture::RGBA8U:
964 case QOpenGLTexture::R16U:
965 case QOpenGLTexture::RG16U:
966 case QOpenGLTexture::RGB16U:
967 case QOpenGLTexture::RGBA16U:
968 case QOpenGLTexture::R32U:
969 case QOpenGLTexture::RG32U:
970 case QOpenGLTexture::RGB32U:
971 case QOpenGLTexture::RGBA32U:
972 case QOpenGLTexture::R8I:
973 case QOpenGLTexture::RG8I:
974 case QOpenGLTexture::RGB8I:
975 case QOpenGLTexture::RGBA8I:
976 case QOpenGLTexture::R16I:
977 case QOpenGLTexture::RG16I:
978 case QOpenGLTexture::RGB16I:
979 case QOpenGLTexture::RGBA16I:
980 case QOpenGLTexture::R32I:
981 case QOpenGLTexture::RG32I:
982 case QOpenGLTexture::RGB32I:
983 case QOpenGLTexture::RGBA32I:
984 case QOpenGLTexture::R16F:
985 case QOpenGLTexture::RG16F:
986 case QOpenGLTexture::RGB16F:
987 case QOpenGLTexture::RGBA16F:
988 case QOpenGLTexture::R32F:
989 case QOpenGLTexture::RG32F:
990 case QOpenGLTexture::RGB32F:
991 case QOpenGLTexture::RGBA32F:
992 case QOpenGLTexture::RGB9E5:
993 case QOpenGLTexture::RG11B10F:
994 case QOpenGLTexture::RG3B2:
995 case QOpenGLTexture::R5G6B5:
996 case QOpenGLTexture::RGB5A1:
997 case QOpenGLTexture::RGBA4:
998 case QOpenGLTexture::RGB10A2:
999
1000 case QOpenGLTexture::D16:
1001 case QOpenGLTexture::D24:
1002 case QOpenGLTexture::D32:
1003 case QOpenGLTexture::D32F:
1004
1005 case QOpenGLTexture::D24S8:
1006 case QOpenGLTexture::D32FS8X24:
1007
1008 case QOpenGLTexture::S8:
1009 return false;
1010
1011 case QOpenGLTexture::RGB_DXT1:
1012 case QOpenGLTexture::RGBA_DXT1:
1013 case QOpenGLTexture::RGBA_DXT3:
1014 case QOpenGLTexture::RGBA_DXT5:
1015 case QOpenGLTexture::R_ATI1N_UNorm:
1016 case QOpenGLTexture::R_ATI1N_SNorm:
1017 case QOpenGLTexture::RG_ATI2N_UNorm:
1018 case QOpenGLTexture::RG_ATI2N_SNorm:
1019 case QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT:
1020 case QOpenGLTexture::RGB_BP_SIGNED_FLOAT:
1021 case QOpenGLTexture::RGB_BP_UNorm:
1022 case QOpenGLTexture::SRGB8:
1023 case QOpenGLTexture::SRGB8_Alpha8:
1024 case QOpenGLTexture::SRGB_DXT1:
1025 case QOpenGLTexture::SRGB_Alpha_DXT1:
1026 case QOpenGLTexture::SRGB_Alpha_DXT3:
1027 case QOpenGLTexture::SRGB_Alpha_DXT5:
1028 case QOpenGLTexture::SRGB_BP_UNorm:
1029 case QOpenGLTexture::R11_EAC_UNorm:
1030 case QOpenGLTexture::R11_EAC_SNorm:
1031 case QOpenGLTexture::RG11_EAC_UNorm:
1032 case QOpenGLTexture::RG11_EAC_SNorm:
1033 case QOpenGLTexture::RGB8_ETC2:
1034 case QOpenGLTexture::SRGB8_ETC2:
1035 case QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC2:
1036 case QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC2:
1037 case QOpenGLTexture::RGBA8_ETC2_EAC:
1038 case QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC:
1039 case QOpenGLTexture::RGB8_ETC1:
1040 case QOpenGLTexture::RGBA_ASTC_4x4:
1041 case QOpenGLTexture::RGBA_ASTC_5x4:
1042 case QOpenGLTexture::RGBA_ASTC_5x5:
1043 case QOpenGLTexture::RGBA_ASTC_6x5:
1044 case QOpenGLTexture::RGBA_ASTC_6x6:
1045 case QOpenGLTexture::RGBA_ASTC_8x5:
1046 case QOpenGLTexture::RGBA_ASTC_8x6:
1047 case QOpenGLTexture::RGBA_ASTC_8x8:
1048 case QOpenGLTexture::RGBA_ASTC_10x5:
1049 case QOpenGLTexture::RGBA_ASTC_10x6:
1050 case QOpenGLTexture::RGBA_ASTC_10x8:
1051 case QOpenGLTexture::RGBA_ASTC_10x10:
1052 case QOpenGLTexture::RGBA_ASTC_12x10:
1053 case QOpenGLTexture::RGBA_ASTC_12x12:
1054 case QOpenGLTexture::SRGB8_Alpha8_ASTC_4x4:
1055 case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x4:
1056 case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x5:
1057 case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x5:
1058 case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x6:
1059 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x5:
1060 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x6:
1061 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x8:
1062 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x5:
1063 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x6:
1064 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x8:
1065 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x10:
1066 case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x10:
1067 case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x12:
1068 return true;
1069
1070 case QOpenGLTexture::DepthFormat:
1071 case QOpenGLTexture::AlphaFormat:
1072 case QOpenGLTexture::RGBFormat:
1073 case QOpenGLTexture::RGBAFormat:
1074 case QOpenGLTexture::LuminanceFormat:
1075 case QOpenGLTexture::LuminanceAlphaFormat:
1076 return false;
1077 }
1078
1079 Q_UNREACHABLE_RETURN(false);
1080}
1081
1082void QOpenGLTexturePrivate::allocateMutableStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType)
1083{
1084 // There is no way to allocate mutable storage for compressed textures in in
1085 // versions older than OpenGL 3.1 and OpenGL ES 3.0, because the older specs
1086 // do not mandate accepting null data pointers for glCompressedTexImage*D,
1087 // unlike glTexImage*D (which in turn does not accept compressed formats).
1088 if (isCompressedFormat(format)) {
1089 storageAllocated = true;
1090 return;
1091 }
1092
1093 switch (target) {
1094 case QOpenGLTexture::TargetBuffer:
1095 // Buffer textures get their storage from an external OpenGL buffer
1096 qWarning("Buffer textures do not allocate storage");
1097 return;
1098
1099 case QOpenGLTexture::Target1D:
1100 if (features.testFlag(QOpenGLTexture::Texture1D)) {
1101 for (int level = 0; level < mipLevels; ++level)
1102 texFuncs->glTextureImage1D(textureId, target, bindingTarget, level, format,
1103 mipLevelSize(level, dimensions[0]),
1104 0,
1105 pixelFormat, pixelType, nullptr);
1106 } else {
1107 qWarning("1D textures are not supported");
1108 return;
1109 }
1110 break;
1111
1112 case QOpenGLTexture::Target1DArray:
1113 if (features.testFlag(QOpenGLTexture::Texture1D)
1114 && features.testFlag(QOpenGLTexture::TextureArrays)) {
1115 for (int level = 0; level < mipLevels; ++level)
1116 texFuncs->glTextureImage2D(textureId, target, bindingTarget, level, format,
1117 mipLevelSize(level, dimensions[0]),
1118 layers,
1119 0,
1120 pixelFormat, pixelType, nullptr);
1121 } else {
1122 qWarning("1D array textures are not supported");
1123 return;
1124 }
1125 break;
1126
1127 case QOpenGLTexture::Target2D:
1128 case QOpenGLTexture::TargetRectangle:
1129 for (int level = 0; level < mipLevels; ++level)
1130 texFuncs->glTextureImage2D(textureId, target, bindingTarget, level, format,
1131 mipLevelSize(level, dimensions[0]),
1132 mipLevelSize(level, dimensions[1]),
1133 0,
1134 pixelFormat, pixelType, nullptr);
1135 break;
1136
1137 case QOpenGLTexture::TargetCubeMap: {
1138 // Cubemaps are the odd one out. We have to allocate storage for each
1139 // face and miplevel using the special cubemap face targets rather than
1140 // GL_TARGET_CUBEMAP.
1141 const QOpenGLTexture::CubeMapFace faceTargets[] = {
1142 QOpenGLTexture::CubeMapPositiveX, QOpenGLTexture::CubeMapNegativeX,
1143 QOpenGLTexture::CubeMapPositiveY, QOpenGLTexture::CubeMapNegativeY,
1144 QOpenGLTexture::CubeMapPositiveZ, QOpenGLTexture::CubeMapNegativeZ
1145 };
1146
1147 for (int faceTarget = 0; faceTarget < 6; ++faceTarget) {
1148 for (int level = 0; level < mipLevels; ++level) {
1149 texFuncs->glTextureImage2D(textureId, faceTargets[faceTarget], bindingTarget,
1150 level, format,
1151 mipLevelSize(level, dimensions[0]),
1152 mipLevelSize(level, dimensions[1]),
1153 0,
1154 pixelFormat, pixelType, nullptr);
1155 }
1156 }
1157 break;
1158 }
1159
1160 case QOpenGLTexture::Target2DArray:
1161 if (features.testFlag(QOpenGLTexture::TextureArrays)) {
1162 for (int level = 0; level < mipLevels; ++level)
1163 texFuncs->glTextureImage3D(textureId, target, bindingTarget, level, format,
1164 mipLevelSize(level, dimensions[0]),
1165 mipLevelSize(level, dimensions[1]),
1166 layers,
1167 0,
1168 pixelFormat, pixelType, nullptr);
1169 } else {
1170 qWarning("Array textures are not supported");
1171 return;
1172 }
1173 break;
1174
1175 case QOpenGLTexture::TargetCubeMapArray:
1176 // Cubemap arrays must specify number of layer-faces (6 * layers) as depth parameter
1177 if (features.testFlag(QOpenGLTexture::TextureCubeMapArrays)) {
1178 for (int level = 0; level < mipLevels; ++level)
1179 texFuncs->glTextureImage3D(textureId, target, bindingTarget, level, format,
1180 mipLevelSize(level, dimensions[0]),
1181 mipLevelSize(level, dimensions[1]),
1182 6 * layers,
1183 0,
1184 pixelFormat, pixelType, nullptr);
1185 } else {
1186 qWarning("Cubemap Array textures are not supported");
1187 return;
1188 }
1189 break;
1190
1191 case QOpenGLTexture::Target3D:
1192 if (features.testFlag(QOpenGLTexture::Texture3D)) {
1193 for (int level = 0; level < mipLevels; ++level)
1194 texFuncs->glTextureImage3D(textureId, target, bindingTarget, level, format,
1195 mipLevelSize(level, dimensions[0]),
1196 mipLevelSize(level, dimensions[1]),
1197 mipLevelSize(level, dimensions[2]),
1198 0,
1199 pixelFormat, pixelType, nullptr);
1200 } else {
1201 qWarning("3D textures are not supported");
1202 return;
1203 }
1204 break;
1205
1206 case QOpenGLTexture::Target2DMultisample:
1207 if (features.testFlag(QOpenGLTexture::TextureMultisample)) {
1208 texFuncs->glTextureImage2DMultisample(textureId, target, bindingTarget, samples, format,
1209 dimensions[0], dimensions[1],
1210 fixedSamplePositions);
1211 } else {
1212 qWarning("Multisample textures are not supported");
1213 return;
1214 }
1215 break;
1216
1217 case QOpenGLTexture::Target2DMultisampleArray:
1218 if (features.testFlag(QOpenGLTexture::TextureMultisample)
1219 && features.testFlag(QOpenGLTexture::TextureArrays)) {
1220 texFuncs->glTextureImage3DMultisample(textureId, target, bindingTarget, samples, format,
1221 dimensions[0], dimensions[1], layers,
1222 fixedSamplePositions);
1223 } else {
1224 qWarning("Multisample array textures are not supported");
1225 return;
1226 }
1227 break;
1228 }
1229
1230 storageAllocated = true;
1231}
1232
1233void QOpenGLTexturePrivate::allocateImmutableStorage()
1234{
1235 switch (target) {
1236 case QOpenGLTexture::TargetBuffer:
1237 // Buffer textures get their storage from an external OpenGL buffer
1238 qWarning("Buffer textures do not allocate storage");
1239 return;
1240
1241 case QOpenGLTexture::Target1D:
1242 if (features.testFlag(QOpenGLTexture::Texture1D)) {
1243 texFuncs->glTextureStorage1D(textureId, target, bindingTarget, mipLevels, format,
1244 dimensions[0]);
1245 } else {
1246 qWarning("1D textures are not supported");
1247 return;
1248 }
1249 break;
1250
1251 case QOpenGLTexture::Target1DArray:
1252 if (features.testFlag(QOpenGLTexture::Texture1D)
1253 && features.testFlag(QOpenGLTexture::TextureArrays)) {
1254 texFuncs->glTextureStorage2D(textureId, target, bindingTarget, mipLevels, format,
1255 dimensions[0], layers);
1256 } else {
1257 qWarning("1D array textures are not supported");
1258 return;
1259 }
1260 break;
1261
1262 case QOpenGLTexture::Target2D:
1263 case QOpenGLTexture::TargetCubeMap:
1264 case QOpenGLTexture::TargetRectangle:
1265 texFuncs->glTextureStorage2D(textureId, target, bindingTarget, mipLevels, format,
1266 dimensions[0], dimensions[1]);
1267 break;
1268
1269 case QOpenGLTexture::Target2DArray:
1270 if (features.testFlag(QOpenGLTexture::TextureArrays)) {
1271 texFuncs->glTextureStorage3D(textureId, target, bindingTarget, mipLevels, format,
1272 dimensions[0], dimensions[1], layers);
1273 } else {
1274 qWarning("Array textures are not supported");
1275 return;
1276 }
1277 break;
1278
1279 case QOpenGLTexture::TargetCubeMapArray:
1280 // Cubemap arrays must specify number of layer-faces (6 * layers) as depth parameter
1281 if (features.testFlag(QOpenGLTexture::TextureCubeMapArrays)) {
1282 texFuncs->glTextureStorage3D(textureId, target, bindingTarget, mipLevels, format,
1283 dimensions[0], dimensions[1], 6 * layers);
1284 } else {
1285 qWarning("Cubemap Array textures are not supported");
1286 return;
1287 }
1288 break;
1289
1290 case QOpenGLTexture::Target3D:
1291 if (features.testFlag(QOpenGLTexture::Texture3D)) {
1292 texFuncs->glTextureStorage3D(textureId, target, bindingTarget, mipLevels, format,
1293 dimensions[0], dimensions[1], dimensions[2]);
1294 } else {
1295 qWarning("3D textures are not supported");
1296 return;
1297 }
1298 break;
1299
1300 case QOpenGLTexture::Target2DMultisample:
1301 if (features.testFlag(QOpenGLTexture::ImmutableMultisampleStorage)) {
1302 texFuncs->glTextureStorage2DMultisample(textureId, target, bindingTarget, samples, format,
1303 dimensions[0], dimensions[1],
1304 fixedSamplePositions);
1305 } else {
1306 qWarning("Multisample textures are not supported");
1307 return;
1308 }
1309 break;
1310
1311 case QOpenGLTexture::Target2DMultisampleArray:
1312 if (features.testFlag(QOpenGLTexture::ImmutableMultisampleStorage)
1313 && features.testFlag(QOpenGLTexture::TextureArrays)) {
1314 texFuncs->glTextureStorage3DMultisample(textureId, target, bindingTarget, samples, format,
1315 dimensions[0], dimensions[1], layers,
1316 fixedSamplePositions);
1317 } else {
1318 qWarning("Multisample array textures are not supported");
1319 return;
1320 }
1321 break;
1322 }
1323
1324 storageAllocated = true;
1325}
1326
1327void QOpenGLTexturePrivate::setData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace,
1328 QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType,
1329 const void *data, const QOpenGLPixelTransferOptions * const options)
1330{
1331 switch (target) {
1332 case QOpenGLTexture::Target1D:
1333 Q_UNUSED(layer);
1334 Q_UNUSED(cubeFace);
1335 Q_UNUSED(layerCount);
1336 texFuncs->glTextureSubImage1D(textureId, target, bindingTarget, mipLevel,
1337 0, mipLevelSize( mipLevel, dimensions[0] ),
1338 sourceFormat, sourceType, data, options);
1339 break;
1340
1341 case QOpenGLTexture::Target1DArray:
1342 Q_UNUSED(cubeFace);
1343 texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
1344 0, layer,
1345 mipLevelSize(mipLevel, dimensions[0]),
1346 layerCount,
1347 sourceFormat, sourceType, data, options);
1348 break;
1349
1350 case QOpenGLTexture::Target2D:
1351 Q_UNUSED(layer);
1352 Q_UNUSED(cubeFace);
1353 Q_UNUSED(layerCount);
1354 texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
1355 0, 0,
1356 mipLevelSize(mipLevel, dimensions[0]),
1357 mipLevelSize(mipLevel, dimensions[1]),
1358 sourceFormat, sourceType, data, options);
1359 break;
1360
1361 case QOpenGLTexture::Target2DArray:
1362 Q_UNUSED(cubeFace);
1363 texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
1364 0, 0, layer,
1365 mipLevelSize(mipLevel, dimensions[0]),
1366 mipLevelSize(mipLevel, dimensions[1]),
1367 layerCount,
1368 sourceFormat, sourceType, data, options);
1369 break;
1370
1371 case QOpenGLTexture::Target3D:
1372 Q_UNUSED(cubeFace);
1373 Q_UNUSED(layerCount);
1374 texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
1375 0, 0, layer,
1376 mipLevelSize(mipLevel, dimensions[0]),
1377 mipLevelSize(mipLevel, dimensions[1]),
1378 mipLevelSize(mipLevel, dimensions[2]),
1379 sourceFormat, sourceType, data, options);
1380 break;
1381
1382 case QOpenGLTexture::TargetCubeMap:
1383 Q_UNUSED(layer);
1384 Q_UNUSED(layerCount);
1385 texFuncs->glTextureSubImage2D(textureId, cubeFace, bindingTarget, mipLevel,
1386 0, 0,
1387 mipLevelSize(mipLevel, dimensions[0]),
1388 mipLevelSize(mipLevel, dimensions[1]),
1389 sourceFormat, sourceType, data, options);
1390 break;
1391
1392 case QOpenGLTexture::TargetCubeMapArray: {
1393 int faceIndex = cubeFace - QOpenGLTexture::CubeMapPositiveX;
1394 int layerFace = 6 * layer + faceIndex;
1395 texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
1396 0, 0, layerFace,
1397 mipLevelSize(mipLevel, dimensions[0]),
1398 mipLevelSize(mipLevel, dimensions[1]),
1399 layerCount,
1400 sourceFormat, sourceType, data, options);
1401 break;
1402 }
1403
1404 case QOpenGLTexture::TargetRectangle:
1405 Q_UNUSED(mipLevel);
1406 Q_UNUSED(layer);
1407 Q_UNUSED(cubeFace);
1408 Q_UNUSED(layerCount);
1409 texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, 0,
1410 0, 0,
1411 dimensions[0],
1412 dimensions[1],
1413 sourceFormat, sourceType, data, options);
1414 break;
1415
1416 case QOpenGLTexture::Target2DMultisample:
1417 case QOpenGLTexture::Target2DMultisampleArray:
1418 case QOpenGLTexture::TargetBuffer:
1419 // We don't upload pixel data for these targets
1420 qWarning("QOpenGLTexture::setData(): Texture target does not support pixel data upload");
1421 break;
1422 }
1423
1424 // If requested perform automatic mip map generation
1425 if (mipLevel == 0 && autoGenerateMipMaps && mipLevels > 1) {
1426 Q_Q(QOpenGLTexture);
1427 q->generateMipMaps();
1428 }
1429}
1430
1431void QOpenGLTexturePrivate::setData(int xOffset, int yOffset, int zOffset, int width, int height, int depth,
1432 int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace,
1433 QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType,
1434 const void *data, const QOpenGLPixelTransferOptions * const options)
1435{
1436 switch (target) {
1437 case QOpenGLTexture::Target1D:
1438 Q_UNUSED(layer);
1439 Q_UNUSED(cubeFace);
1440 Q_UNUSED(layerCount);
1441 Q_UNUSED(yOffset);
1442 Q_UNUSED(zOffset);
1443 Q_UNUSED(height);
1444 Q_UNUSED(depth);
1445 texFuncs->glTextureSubImage1D(textureId, target, bindingTarget, mipLevel,
1446 xOffset, width,
1447 sourceFormat, sourceType, data, options);
1448 break;
1449
1450 case QOpenGLTexture::Target1DArray:
1451 Q_UNUSED(cubeFace);
1452 Q_UNUSED(yOffset);
1453 Q_UNUSED(zOffset);
1454 Q_UNUSED(height);
1455 Q_UNUSED(depth);
1456 texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
1457 xOffset, layer,
1458 width,
1459 layerCount,
1460 sourceFormat, sourceType, data, options);
1461 break;
1462
1463 case QOpenGLTexture::Target2D:
1464 Q_UNUSED(layer);
1465 Q_UNUSED(cubeFace);
1466 Q_UNUSED(layerCount);
1467 Q_UNUSED(zOffset);
1468 Q_UNUSED(depth);
1469 texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
1470 xOffset, yOffset,
1471 width, height,
1472 sourceFormat, sourceType, data, options);
1473 break;
1474
1475 case QOpenGLTexture::Target2DArray:
1476 Q_UNUSED(cubeFace);
1477 Q_UNUSED(zOffset);
1478 Q_UNUSED(depth);
1479 texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
1480 xOffset, yOffset, layer,
1481 width, height, layerCount,
1482 sourceFormat, sourceType, data, options);
1483 break;
1484
1485 case QOpenGLTexture::Target3D:
1486 Q_UNUSED(cubeFace);
1487 Q_UNUSED(layerCount);
1488 texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
1489 xOffset, yOffset, zOffset,
1490 width, height, depth,
1491 sourceFormat, sourceType, data, options);
1492 break;
1493
1494 case QOpenGLTexture::TargetCubeMap:
1495 Q_UNUSED(layer);
1496 Q_UNUSED(layerCount);
1497 Q_UNUSED(zOffset);
1498 Q_UNUSED(depth);
1499 texFuncs->glTextureSubImage2D(textureId, cubeFace, bindingTarget, mipLevel,
1500 xOffset, yOffset,
1501 width, height,
1502 sourceFormat, sourceType, data, options);
1503 break;
1504
1505 case QOpenGLTexture::TargetCubeMapArray: {
1506 Q_UNUSED(zOffset);
1507 Q_UNUSED(depth);
1508 int faceIndex = cubeFace - QOpenGLTexture::CubeMapPositiveX;
1509 int layerFace = 6 * layer + faceIndex;
1510 texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
1511 xOffset, yOffset, layerFace,
1512 width, height,
1513 layerCount,
1514 sourceFormat, sourceType, data, options);
1515 break;
1516 }
1517
1518 case QOpenGLTexture::TargetRectangle:
1519 Q_UNUSED(mipLevel);
1520 Q_UNUSED(layer);
1521 Q_UNUSED(cubeFace);
1522 Q_UNUSED(layerCount);
1523 Q_UNUSED(zOffset);
1524 Q_UNUSED(depth);
1525 texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, 0,
1526 xOffset, yOffset,
1527 width, height,
1528 sourceFormat, sourceType, data, options);
1529 break;
1530
1531 case QOpenGLTexture::Target2DMultisample:
1532 case QOpenGLTexture::Target2DMultisampleArray:
1533 case QOpenGLTexture::TargetBuffer:
1534 // We don't upload pixel data for these targets
1535 qWarning("QOpenGLTexture::setData(): Texture target does not support pixel data upload");
1536 break;
1537 }
1538
1539 // If requested perform automatic mip map generation
1540 if (mipLevel == 0 && autoGenerateMipMaps && mipLevels > 1) {
1541 Q_Q(QOpenGLTexture);
1542 q->generateMipMaps();
1543 }
1544}
1545
1546
1547void QOpenGLTexturePrivate::setCompressedData(int mipLevel, int layer, int layerCount,
1548 QOpenGLTexture::CubeMapFace cubeFace,
1549 int dataSize, const void *data,
1550 const QOpenGLPixelTransferOptions * const options)
1551{
1552 if (!isCompressedFormat(format)) {
1553 qWarning("Cannot set compressed data for non-compressed format 0x%x", format);
1554 return;
1555 }
1556
1557 const bool needsFullSpec = !isUsingImmutableStorage(); // was allocateStorage() a no-op?
1558
1559 switch (target) {
1560 case QOpenGLTexture::Target1D:
1561 Q_UNUSED(layer);
1562 Q_UNUSED(cubeFace);
1563 Q_UNUSED(layerCount);
1564 if (needsFullSpec) {
1565 texFuncs->glCompressedTextureImage1D(textureId, target, bindingTarget, mipLevel,
1566 format,
1567 mipLevelSize(mipLevel, dimensions[0]),
1568 0, dataSize, data, options);
1569 } else {
1570 texFuncs->glCompressedTextureSubImage1D(textureId, target, bindingTarget, mipLevel,
1571 0, mipLevelSize( mipLevel, dimensions[0] ),
1572 format, dataSize, data, options);
1573 }
1574 break;
1575
1576 case QOpenGLTexture::Target1DArray:
1577 Q_UNUSED(cubeFace);
1578 if (!needsFullSpec) {
1579 texFuncs->glCompressedTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
1580 0, layer,
1581 mipLevelSize(mipLevel, dimensions[0]),
1582 layerCount,
1583 format, dataSize, data, options);
1584 }
1585 break;
1586
1587 case QOpenGLTexture::Target2D:
1588 Q_UNUSED(layer);
1589 Q_UNUSED(cubeFace);
1590 Q_UNUSED(layerCount);
1591 if (needsFullSpec) {
1592 texFuncs->glCompressedTextureImage2D(textureId, target, bindingTarget, mipLevel,
1593 format,
1594 mipLevelSize(mipLevel, dimensions[0]),
1595 mipLevelSize(mipLevel, dimensions[1]),
1596 0, dataSize, data, options);
1597 } else {
1598 texFuncs->glCompressedTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
1599 0, 0,
1600 mipLevelSize(mipLevel, dimensions[0]),
1601 mipLevelSize(mipLevel, dimensions[1]),
1602 format, dataSize, data, options);
1603 }
1604 break;
1605
1606 case QOpenGLTexture::Target2DArray:
1607 Q_UNUSED(cubeFace);
1608 if (!needsFullSpec) {
1609 texFuncs->glCompressedTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
1610 0, 0, layer,
1611 mipLevelSize(mipLevel, dimensions[0]),
1612 mipLevelSize(mipLevel, dimensions[1]),
1613 layerCount,
1614 format, dataSize, data, options);
1615 }
1616 break;
1617
1618 case QOpenGLTexture::Target3D:
1619 Q_UNUSED(cubeFace);
1620 Q_UNUSED(layerCount);
1621 if (needsFullSpec) {
1622 texFuncs->glCompressedTextureImage3D(textureId, target, bindingTarget, mipLevel,
1623 format,
1624 mipLevelSize(mipLevel, dimensions[0]),
1625 mipLevelSize(mipLevel, dimensions[1]),
1626 mipLevelSize(mipLevel, dimensions[2]),
1627 0, dataSize, data, options);
1628 } else {
1629 texFuncs->glCompressedTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
1630 0, 0, layer,
1631 mipLevelSize(mipLevel, dimensions[0]),
1632 mipLevelSize(mipLevel, dimensions[1]),
1633 mipLevelSize(mipLevel, dimensions[2]),
1634 format, dataSize, data, options);
1635 }
1636 break;
1637
1638 case QOpenGLTexture::TargetCubeMap:
1639 Q_UNUSED(layer);
1640 Q_UNUSED(layerCount);
1641 if (needsFullSpec) {
1642 texFuncs->glCompressedTextureImage2D(textureId, cubeFace, bindingTarget, mipLevel,
1643 format,
1644 mipLevelSize(mipLevel, dimensions[0]),
1645 mipLevelSize(mipLevel, dimensions[1]),
1646 0, dataSize, data, options);
1647 } else {
1648 texFuncs->glCompressedTextureSubImage2D(textureId, cubeFace, bindingTarget, mipLevel,
1649 0, 0,
1650 mipLevelSize(mipLevel, dimensions[0]),
1651 mipLevelSize(mipLevel, dimensions[1]),
1652 format, dataSize, data, options);
1653 }
1654 break;
1655
1656 case QOpenGLTexture::TargetCubeMapArray: {
1657 int faceIndex = cubeFace - QOpenGLTexture::CubeMapPositiveX;
1658 int layerFace = 6 * layer + faceIndex;
1659 if (!needsFullSpec) {
1660 texFuncs->glCompressedTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
1661 0, 0, layerFace,
1662 mipLevelSize(mipLevel, dimensions[0]),
1663 mipLevelSize(mipLevel, dimensions[1]),
1664 layerCount,
1665 format, dataSize, data, options);
1666 }
1667 break;
1668 }
1669
1670 case QOpenGLTexture::TargetRectangle:
1671 case QOpenGLTexture::Target2DMultisample:
1672 case QOpenGLTexture::Target2DMultisampleArray:
1673 case QOpenGLTexture::TargetBuffer:
1674 // We don't upload pixel data for these targets
1675 qWarning("QOpenGLTexture::setCompressedData(): Texture target does not support pixel data upload");
1676 break;
1677 }
1678
1679 // If requested perform automatic mip map generation
1680 if (mipLevel == 0 && autoGenerateMipMaps && mipLevels > 1) {
1681 Q_Q(QOpenGLTexture);
1682 q->generateMipMaps();
1683 }
1684}
1685
1716
1717void QOpenGLTexturePrivate::setWrapMode(QOpenGLTexture::CoordinateDirection direction, QOpenGLTexture::WrapMode mode)
1718{
1719 switch (target) {
1720 case QOpenGLTexture::Target1D:
1721 case QOpenGLTexture::Target1DArray:
1722 case QOpenGLTexture::TargetBuffer:
1723 switch (direction) {
1724 case QOpenGLTexture::DirectionS:
1725 wrapModes[0] = mode;
1726 texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
1727 break;
1728
1729 case QOpenGLTexture::DirectionT:
1730 case QOpenGLTexture::DirectionR:
1731 qWarning("QOpenGLTexture::setWrapMode() direction not valid for this texture target");
1732 break;
1733 }
1734 break;
1735
1736 case QOpenGLTexture::Target2D:
1737 case QOpenGLTexture::Target2DArray:
1738 case QOpenGLTexture::TargetCubeMap:
1739 case QOpenGLTexture::TargetCubeMapArray:
1740 case QOpenGLTexture::Target2DMultisample:
1741 case QOpenGLTexture::Target2DMultisampleArray:
1742 case QOpenGLTexture::TargetRectangle:
1743 switch (direction) {
1744 case QOpenGLTexture::DirectionS:
1745 wrapModes[0] = mode;
1746 texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
1747 break;
1748
1749 case QOpenGLTexture::DirectionT:
1750 wrapModes[1] = mode;
1751 texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_T, mode);
1752 break;
1753
1754 case QOpenGLTexture::DirectionR:
1755 qWarning("QOpenGLTexture::setWrapMode() direction not valid for this texture target");
1756 break;
1757 }
1758 break;
1759
1760 case QOpenGLTexture::Target3D:
1761 switch (direction) {
1762 case QOpenGLTexture::DirectionS:
1763 wrapModes[0] = mode;
1764 texFuncs->glTextureParameteri(textureId, target, bindingTarget, direction, mode);
1765 break;
1766
1767 case QOpenGLTexture::DirectionT:
1768 wrapModes[1] = mode;
1769 texFuncs->glTextureParameteri(textureId, target, bindingTarget, direction, mode);
1770 break;
1771
1772 case QOpenGLTexture::DirectionR:
1773 wrapModes[2] = mode;
1774 texFuncs->glTextureParameteri(textureId, target, bindingTarget, direction, mode);
1775 break;
1776 }
1777 break;
1778 }
1779}
1780
1781QOpenGLTexture::WrapMode QOpenGLTexturePrivate::wrapMode(QOpenGLTexture::CoordinateDirection direction) const
1782{
1783 switch (target) {
1784 case QOpenGLTexture::Target1D:
1785 case QOpenGLTexture::Target1DArray:
1786 case QOpenGLTexture::TargetBuffer:
1787 switch (direction) {
1788 case QOpenGLTexture::DirectionS:
1789 return wrapModes[0];
1790
1791 case QOpenGLTexture::DirectionT:
1792 case QOpenGLTexture::DirectionR:
1793 qWarning("QOpenGLTexture::wrapMode() direction not valid for this texture target");
1794 return QOpenGLTexture::Repeat;
1795 }
1796 break;
1797
1798 case QOpenGLTexture::Target2D:
1799 case QOpenGLTexture::Target2DArray:
1800 case QOpenGLTexture::TargetCubeMap:
1801 case QOpenGLTexture::TargetCubeMapArray:
1802 case QOpenGLTexture::Target2DMultisample:
1803 case QOpenGLTexture::Target2DMultisampleArray:
1804 case QOpenGLTexture::TargetRectangle:
1805 switch (direction) {
1806 case QOpenGLTexture::DirectionS:
1807 return wrapModes[0];
1808
1809 case QOpenGLTexture::DirectionT:
1810 return wrapModes[1];
1811
1812 case QOpenGLTexture::DirectionR:
1813 qWarning("QOpenGLTexture::wrapMode() direction not valid for this texture target");
1814 return QOpenGLTexture::Repeat;
1815 }
1816 break;
1817
1818 case QOpenGLTexture::Target3D:
1819 switch (direction) {
1820 case QOpenGLTexture::DirectionS:
1821 return wrapModes[0];
1822
1823 case QOpenGLTexture::DirectionT:
1824 return wrapModes[1];
1825
1826 case QOpenGLTexture::DirectionR:
1827 return wrapModes[2];
1828 }
1829 break;
1830 }
1831 // Should never get here
1832 Q_ASSERT(false);
1833 return QOpenGLTexture::Repeat;
1834}
1835
1836QOpenGLTexture *QOpenGLTexturePrivate::createTextureView(QOpenGLTexture::Target viewTarget,
1837 QOpenGLTexture::TextureFormat viewFormat,
1838 int minimumMipmapLevel, int maximumMipmapLevel,
1839 int minimumLayer, int maximumLayer) const
1840{
1841 // Do sanity checks - see http://www.opengl.org/wiki/GLAPI/glTextureView
1842
1843 // Check the targets are compatible
1844 bool viewTargetCompatible = false;
1845 switch (target) {
1846 case QOpenGLTexture::Target1D:
1847 case QOpenGLTexture::Target1DArray:
1848 viewTargetCompatible = (viewTarget == QOpenGLTexture::Target1D
1849 || viewTarget == QOpenGLTexture::Target1DArray);
1850 break;
1851
1852
1853 case QOpenGLTexture::Target2D:
1854 case QOpenGLTexture::Target2DArray:
1855 viewTargetCompatible = (viewTarget == QOpenGLTexture::Target2D
1856 || viewTarget == QOpenGLTexture::Target2DArray);
1857 break;
1858
1859 case QOpenGLTexture::Target3D:
1860 viewTargetCompatible = (viewTarget == QOpenGLTexture::Target3D);
1861 break;
1862
1863 case QOpenGLTexture::TargetCubeMap:
1864 case QOpenGLTexture::TargetCubeMapArray:
1865 viewTargetCompatible = (viewTarget == QOpenGLTexture::TargetCubeMap
1866 || viewTarget == QOpenGLTexture::Target2D
1867 || viewTarget == QOpenGLTexture::Target2DArray
1868 || viewTarget == QOpenGLTexture::TargetCubeMapArray);
1869 break;
1870
1871 case QOpenGLTexture::Target2DMultisample:
1872 case QOpenGLTexture::Target2DMultisampleArray:
1873 viewTargetCompatible = (viewTarget == QOpenGLTexture::Target2DMultisample
1874 || viewTarget == QOpenGLTexture::Target2DMultisampleArray);
1875 break;
1876
1877 case QOpenGLTexture::TargetRectangle:
1878 viewTargetCompatible = (viewTarget == QOpenGLTexture::TargetRectangle);
1879 break;
1880
1881 case QOpenGLTexture::TargetBuffer:
1882 // Cannot be used with texture views
1883 break;
1884 }
1885
1886 if (!viewTargetCompatible) {
1887 qWarning("QOpenGLTexture::createTextureView(): Incompatible source and view targets");
1888 return nullptr;
1889 }
1890
1891 // Check the formats are compatible
1892 bool viewFormatCompatible = false;
1893 switch (formatClass) {
1894 case QOpenGLTexture::NoFormatClass:
1895 break;
1896
1897 case QOpenGLTexture::FormatClass_128Bit:
1898 viewFormatCompatible = (viewFormat == QOpenGLTexture::RGBA32F
1899 || viewFormat == QOpenGLTexture::RGBA32U
1900 || viewFormat == QOpenGLTexture::RGBA32I);
1901 break;
1902
1903 case QOpenGLTexture::FormatClass_96Bit:
1904 viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB32F
1905 || viewFormat == QOpenGLTexture::RGB32U
1906 || viewFormat == QOpenGLTexture::RGB32I);
1907 break;
1908
1909 case QOpenGLTexture::FormatClass_64Bit:
1910 viewFormatCompatible = (viewFormat == QOpenGLTexture::RGBA16F
1911 || viewFormat == QOpenGLTexture::RG32F
1912 || viewFormat == QOpenGLTexture::RGBA16U
1913 || viewFormat == QOpenGLTexture::RG32U
1914 || viewFormat == QOpenGLTexture::RGBA16I
1915 || viewFormat == QOpenGLTexture::RG32I
1916 || viewFormat == QOpenGLTexture::RGBA16_UNorm
1917 || viewFormat == QOpenGLTexture::RGBA16_SNorm);
1918 break;
1919
1920 case QOpenGLTexture::FormatClass_48Bit:
1921 viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB16_UNorm
1922 || viewFormat == QOpenGLTexture::RGB16_SNorm
1923 || viewFormat == QOpenGLTexture::RGB16F
1924 || viewFormat == QOpenGLTexture::RGB16U
1925 || viewFormat == QOpenGLTexture::RGB16I);
1926 break;
1927
1928 case QOpenGLTexture::FormatClass_32Bit:
1929 viewFormatCompatible = (viewFormat == QOpenGLTexture::RG16F
1930 || viewFormat == QOpenGLTexture::RG11B10F
1931 || viewFormat == QOpenGLTexture::R32F
1932 || viewFormat == QOpenGLTexture::RGB10A2
1933 || viewFormat == QOpenGLTexture::RGBA8U
1934 || viewFormat == QOpenGLTexture::RG16U
1935 || viewFormat == QOpenGLTexture::R32U
1936 || viewFormat == QOpenGLTexture::RGBA8I
1937 || viewFormat == QOpenGLTexture::RG16I
1938 || viewFormat == QOpenGLTexture::R32I
1939 || viewFormat == QOpenGLTexture::RGBA8_UNorm
1940 || viewFormat == QOpenGLTexture::RG16_UNorm
1941 || viewFormat == QOpenGLTexture::RGBA8_SNorm
1942 || viewFormat == QOpenGLTexture::RG16_SNorm
1943 || viewFormat == QOpenGLTexture::SRGB8_Alpha8
1944 || viewFormat == QOpenGLTexture::RGB9E5);
1945 break;
1946
1947 case QOpenGLTexture::FormatClass_24Bit:
1948 viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB8_UNorm
1949 || viewFormat == QOpenGLTexture::RGB8_SNorm
1950 || viewFormat == QOpenGLTexture::SRGB8
1951 || viewFormat == QOpenGLTexture::RGB8U
1952 || viewFormat == QOpenGLTexture::RGB8I);
1953 break;
1954
1955 case QOpenGLTexture::FormatClass_16Bit:
1956 viewFormatCompatible = (viewFormat == QOpenGLTexture::R16F
1957 || viewFormat == QOpenGLTexture::RG8U
1958 || viewFormat == QOpenGLTexture::R16U
1959 || viewFormat == QOpenGLTexture::RG8I
1960 || viewFormat == QOpenGLTexture::R16I
1961 || viewFormat == QOpenGLTexture::RG8_UNorm
1962 || viewFormat == QOpenGLTexture::R16_UNorm
1963 || viewFormat == QOpenGLTexture::RG8_SNorm
1964 || viewFormat == QOpenGLTexture::R16_SNorm);
1965 break;
1966
1967 case QOpenGLTexture::FormatClass_8Bit:
1968 viewFormatCompatible = (viewFormat == QOpenGLTexture::R8U
1969 || viewFormat == QOpenGLTexture::R8I
1970 || viewFormat == QOpenGLTexture::R8_UNorm
1971 || viewFormat == QOpenGLTexture::R8_SNorm);
1972 break;
1973
1974 case QOpenGLTexture::FormatClass_RGTC1_R:
1975 viewFormatCompatible = (viewFormat == QOpenGLTexture::R_ATI1N_UNorm
1976 || viewFormat == QOpenGLTexture::R_ATI1N_SNorm);
1977 break;
1978
1979 case QOpenGLTexture::FormatClass_RGTC2_RG:
1980 viewFormatCompatible = (viewFormat == QOpenGLTexture::RG_ATI2N_UNorm
1981 || viewFormat == QOpenGLTexture::RG_ATI2N_SNorm);
1982 break;
1983
1984 case QOpenGLTexture::FormatClass_BPTC_Unorm:
1985 viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB_BP_UNorm
1986 || viewFormat == QOpenGLTexture::SRGB_BP_UNorm);
1987 break;
1988
1989 case QOpenGLTexture::FormatClass_BPTC_Float:
1990 viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT
1991 || viewFormat == QOpenGLTexture::RGB_BP_SIGNED_FLOAT);
1992 break;
1993
1994 case QOpenGLTexture::FormatClass_S3TC_DXT1_RGB:
1995 viewFormatCompatible = (viewFormat == QOpenGLTexture::RGB_DXT1
1996 || viewFormat == QOpenGLTexture::SRGB_DXT1);
1997 break;
1998
1999 case QOpenGLTexture::FormatClass_S3TC_DXT1_RGBA:
2000 viewFormatCompatible = (viewFormat == QOpenGLTexture::RGBA_DXT1
2001 || viewFormat == QOpenGLTexture::SRGB_Alpha_DXT1);
2002 break;
2003
2004 case QOpenGLTexture::FormatClass_S3TC_DXT3_RGBA:
2005 viewFormatCompatible = (viewFormat == QOpenGLTexture::RGBA_DXT3
2006 || viewFormat == QOpenGLTexture::SRGB_Alpha_DXT3);
2007 break;
2008
2009 case QOpenGLTexture::FormatClass_S3TC_DXT5_RGBA:
2010 viewFormatCompatible = (viewFormat == QOpenGLTexture::RGBA_DXT5
2011 || viewFormat == QOpenGLTexture::SRGB_Alpha_DXT5);
2012 break;
2013
2014 case QOpenGLTexture::FormatClass_Unique:
2015 viewFormatCompatible = (viewFormat == format);
2016 break;
2017 }
2018
2019 if (!viewFormatCompatible) {
2020 qWarning("QOpenGLTexture::createTextureView(): Incompatible source and view formats");
2021 return nullptr;
2022 }
2023
2024
2025 // Create a view
2026 QOpenGLTexture *view = new QOpenGLTexture(viewTarget);
2027 view->setFormat(viewFormat);
2028 view->create();
2029 view->d_ptr->textureView = true;
2030 texFuncs->glTextureView(view->textureId(), viewTarget, textureId, viewFormat,
2031 minimumMipmapLevel, maximumMipmapLevel - minimumMipmapLevel + 1,
2032 minimumLayer, maximumLayer - minimumLayer + 1);
2033 return view;
2034}
2035
2036
2449
2463QOpenGLTexture::QOpenGLTexture(const QImage& image, MipMapGeneration genMipMaps)
2464 : QOpenGLTexture(QOpenGLTexture::Target2D)
2465{
2466 setData(image, genMipMaps);
2467}
2468
2472
2478QOpenGLTexture::Target QOpenGLTexture::target() const
2479{
2480 Q_D(const QOpenGLTexture);
2481 return d->target;
2482}
2483
2501bool QOpenGLTexture::create()
2502{
2503 Q_D(QOpenGLTexture);
2504 return d->create();
2505}
2506
2513void QOpenGLTexture::destroy()
2514{
2515 Q_D(QOpenGLTexture);
2516 return d->destroy();
2517}
2518
2524bool QOpenGLTexture::isCreated() const
2525{
2526 Q_D(const QOpenGLTexture);
2527 return d->textureId != 0;
2528}
2529
2536GLuint QOpenGLTexture::textureId() const
2537{
2538 Q_D(const QOpenGLTexture);
2539 return d->textureId;
2540}
2541
2551void QOpenGLTexture::bind()
2552{
2553 Q_D(QOpenGLTexture);
2554 Q_ASSERT(d->textureId);
2555 d->bind();
2556}
2557
2570void QOpenGLTexture::bind(uint unit, TextureUnitReset reset)
2571{
2572 Q_D(QOpenGLTexture);
2573 Q_ASSERT(d->textureId);
2574 d->bind(unit, reset);
2575}
2576
2582void QOpenGLTexture::release()
2583{
2584 Q_D(QOpenGLTexture);
2585 d->release();
2586}
2587
2595void QOpenGLTexture::release(uint unit, TextureUnitReset reset)
2596{
2597 Q_D(QOpenGLTexture);
2598 d->release(unit, reset);
2599}
2600
2607bool QOpenGLTexture::isBound() const
2608{
2609 Q_D(const QOpenGLTexture);
2610 Q_ASSERT(d->textureId);
2611 return d->isBound();
2612}
2613
2620bool QOpenGLTexture::isBound(uint unit)
2621{
2622 Q_D(const QOpenGLTexture);
2623 Q_ASSERT(d->textureId);
2624 return d->isBound(unit);
2625}
2626
2631GLuint QOpenGLTexture::boundTextureId(BindingTarget target)
2632{
2633 QOpenGLContext *ctx = QOpenGLContext::currentContext();
2634 if (!ctx) {
2635 qWarning("QOpenGLTexture::boundTextureId() requires a valid current context");
2636 return 0;
2637 }
2638
2639 GLint textureId = 0;
2640 ctx->functions()->glGetIntegerv(target, &textureId);
2641 return static_cast<GLuint>(textureId);
2642}
2643
2648GLuint QOpenGLTexture::boundTextureId(uint unit, BindingTarget target)
2649{
2650 QOpenGLContext *ctx = QOpenGLContext::currentContext();
2651 if (!ctx) {
2652 qWarning("QOpenGLTexture::boundTextureId() requires a valid current context");
2653 return 0;
2654 }
2655
2656 QOpenGLFunctions *funcs = ctx->functions();
2657 funcs->initializeOpenGLFunctions();
2658
2659 GLint oldTextureUnit = 0;
2660 funcs->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
2661
2662 funcs->glActiveTexture(unit);
2663 GLint textureId = 0;
2664 funcs->glGetIntegerv(target, &textureId);
2665 funcs->glActiveTexture(oldTextureUnit);
2666
2667 return static_cast<GLuint>(textureId);
2668}
2669
2679void QOpenGLTexture::setFormat(TextureFormat format)
2680{
2681 Q_D(QOpenGLTexture);
2682 d->create();
2683 if (isStorageAllocated()) {
2684 qWarning("QOpenGLTexture::setFormat(): Cannot change format once storage has been allocated");
2685 return;
2686 }
2687
2688 d->format = format;
2689
2690 switch (format) {
2691 case NoFormat:
2692 d->formatClass = NoFormatClass;
2693 break;
2694
2695 case RGBA32F:
2696 case RGBA32U:
2697 case RGBA32I:
2698 d->formatClass = FormatClass_128Bit;
2699 break;
2700
2701 case RGB32F:
2702 case RGB32U:
2703 case RGB32I:
2704 d->formatClass = FormatClass_96Bit;
2705 break;
2706
2707 case RGBA16F:
2708 case RG32F:
2709 case RGBA16U:
2710 case RG32U:
2711 case RGBA16I:
2712 case RG32I:
2713 case RGBA16_UNorm:
2714 case RGBA16_SNorm:
2715 d->formatClass = FormatClass_64Bit;
2716 break;
2717
2718 case RGB16_UNorm:
2719 case RGB16_SNorm:
2720 case RGB16F:
2721 case RGB16U:
2722 case RGB16I:
2723 d->formatClass = FormatClass_48Bit;
2724 break;
2725
2726 case RG16F:
2727 case RG11B10F:
2728 case R32F:
2729 case RGB10A2:
2730 case RGBA8U:
2731 case RG16U:
2732 case R32U:
2733 case RGBA8I:
2734 case RG16I:
2735 case R32I:
2736 case RGBA8_UNorm:
2737 case RG16_UNorm:
2738 case RGBA8_SNorm:
2739 case RG16_SNorm:
2740 case SRGB8_Alpha8:
2741 case RGB9E5:
2742 d->formatClass = FormatClass_32Bit;
2743 break;
2744
2745 case RGB8_UNorm:
2746 case RGB8_SNorm:
2747 case SRGB8:
2748 case RGB8U:
2749 case RGB8I:
2750 d->formatClass = FormatClass_24Bit;
2751 break;
2752
2753 case R16F:
2754 case RG8U:
2755 case R16U:
2756 case RG8I:
2757 case R16I:
2758 case RG8_UNorm:
2759 case R16_UNorm:
2760 case RG8_SNorm:
2761 case R16_SNorm:
2762 d->formatClass = FormatClass_16Bit;
2763 break;
2764
2765 case R8U:
2766 case R8I:
2767 case R8_UNorm:
2768 case R8_SNorm:
2769 d->formatClass = FormatClass_8Bit;
2770 break;
2771
2772 case R_ATI1N_UNorm:
2773 case R_ATI1N_SNorm:
2774 d->formatClass = FormatClass_RGTC1_R;
2775 break;
2776
2777 case RG_ATI2N_UNorm:
2778 case RG_ATI2N_SNorm:
2779 d->formatClass = FormatClass_RGTC2_RG;
2780 break;
2781
2782 case RGB_BP_UNorm:
2783 case SRGB_BP_UNorm:
2784 d->formatClass = FormatClass_BPTC_Unorm;
2785 break;
2786
2787 case RGB_BP_UNSIGNED_FLOAT:
2788 case RGB_BP_SIGNED_FLOAT:
2789 d->formatClass = FormatClass_BPTC_Float;
2790 break;
2791
2792 case RGB_DXT1:
2793 case SRGB_DXT1:
2794 d->formatClass = FormatClass_S3TC_DXT1_RGB;
2795 break;
2796
2797 case RGBA_DXT1:
2798 case SRGB_Alpha_DXT1:
2799 d->formatClass = FormatClass_S3TC_DXT1_RGBA;
2800 break;
2801
2802 case RGBA_DXT3:
2803 case SRGB_Alpha_DXT3:
2804 d->formatClass = FormatClass_S3TC_DXT3_RGBA;
2805 break;
2806
2807 case RGBA_DXT5:
2808 case SRGB_Alpha_DXT5:
2809 d->formatClass = FormatClass_S3TC_DXT5_RGBA;
2810 break;
2811
2812 case QOpenGLTexture::R11_EAC_UNorm:
2813 case QOpenGLTexture::R11_EAC_SNorm:
2814 case QOpenGLTexture::RG11_EAC_UNorm:
2815 case QOpenGLTexture::RG11_EAC_SNorm:
2816 case QOpenGLTexture::RGB8_ETC2:
2817 case QOpenGLTexture::SRGB8_ETC2:
2818 case QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC2:
2819 case QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC2:
2820 case QOpenGLTexture::RGBA8_ETC2_EAC:
2821 case QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC:
2822 case QOpenGLTexture::RGB8_ETC1:
2823 case RG3B2:
2824 case R5G6B5:
2825 case RGB5A1:
2826 case RGBA4:
2827 case D16:
2828 case D24:
2829 case D24S8:
2830 case D32:
2831 case D32F:
2832 case D32FS8X24:
2833 case S8:
2834 case DepthFormat:
2835 case AlphaFormat:
2836 case RGBFormat:
2837 case RGBAFormat:
2838 case LuminanceFormat:
2839 case LuminanceAlphaFormat:
2840 case QOpenGLTexture::RGBA_ASTC_4x4:
2841 case QOpenGLTexture::RGBA_ASTC_5x4:
2842 case QOpenGLTexture::RGBA_ASTC_5x5:
2843 case QOpenGLTexture::RGBA_ASTC_6x5:
2844 case QOpenGLTexture::RGBA_ASTC_6x6:
2845 case QOpenGLTexture::RGBA_ASTC_8x5:
2846 case QOpenGLTexture::RGBA_ASTC_8x6:
2847 case QOpenGLTexture::RGBA_ASTC_8x8:
2848 case QOpenGLTexture::RGBA_ASTC_10x5:
2849 case QOpenGLTexture::RGBA_ASTC_10x6:
2850 case QOpenGLTexture::RGBA_ASTC_10x8:
2851 case QOpenGLTexture::RGBA_ASTC_10x10:
2852 case QOpenGLTexture::RGBA_ASTC_12x10:
2853 case QOpenGLTexture::RGBA_ASTC_12x12:
2854 case QOpenGLTexture::SRGB8_Alpha8_ASTC_4x4:
2855 case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x4:
2856 case QOpenGLTexture::SRGB8_Alpha8_ASTC_5x5:
2857 case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x5:
2858 case QOpenGLTexture::SRGB8_Alpha8_ASTC_6x6:
2859 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x5:
2860 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x6:
2861 case QOpenGLTexture::SRGB8_Alpha8_ASTC_8x8:
2862 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x5:
2863 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x6:
2864 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x8:
2865 case QOpenGLTexture::SRGB8_Alpha8_ASTC_10x10:
2866 case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x10:
2867 case QOpenGLTexture::SRGB8_Alpha8_ASTC_12x12:
2868 d->formatClass = FormatClass_Unique;
2869 break;
2870 }
2871}
2872
2878QOpenGLTexture::TextureFormat QOpenGLTexture::format() const
2879{
2880 Q_D(const QOpenGLTexture);
2881 return d->format;
2882}
2883
2884static bool isNpot(int width, int height = 1, int depth = 1)
2885{
2886 return width & (width-1) || height & (height-1) || depth & (depth-1);
2887}
2888
2902void QOpenGLTexture::setSize(int width, int height, int depth)
2903{
2904 Q_D(QOpenGLTexture);
2905 d->create();
2906 if (isStorageAllocated()) {
2907 qWarning("Cannot resize a texture that already has storage allocated.\n"
2908 "To do so, destroy() the texture and then create() and setSize()");
2909 return;
2910 }
2911
2912 if (isNpot(width, height, depth) && !hasFeature(Feature::NPOTTextureRepeat) && d->target != Target::TargetRectangle)
2913 d->setWrapMode(WrapMode::ClampToEdge);
2914
2915 switch (d->target) {
2916 case QOpenGLTexture::Target1D:
2917 case QOpenGLTexture::Target1DArray:
2918 case QOpenGLTexture::TargetBuffer:
2919 d->dimensions[0] = width;
2920 Q_UNUSED(height);
2921 Q_UNUSED(depth);
2922 break;
2923
2924 case QOpenGLTexture::Target2D:
2925 case QOpenGLTexture::Target2DArray:
2926 case QOpenGLTexture::TargetRectangle:
2927 case QOpenGLTexture::Target2DMultisample:
2928 case QOpenGLTexture::Target2DMultisampleArray:
2929 d->dimensions[0] = width;
2930 d->dimensions[1] = height;
2931 Q_UNUSED(depth);
2932 break;
2933
2934 case QOpenGLTexture::TargetCubeMap:
2935 case QOpenGLTexture::TargetCubeMapArray:
2936 if (width != height)
2937 qWarning("QAbstractOpenGLTexture::setSize(): Cube map textures must be square");
2938 d->dimensions[0] = d->dimensions[1] = width;
2939 Q_UNUSED(depth);
2940 break;
2941
2942 case QOpenGLTexture::Target3D:
2943 d->dimensions[0] = width;
2944 d->dimensions[1] = height;
2945 d->dimensions[2] = depth;
2946 break;
2947 }
2948}
2949
2955int QOpenGLTexture::width() const
2956{
2957 Q_D(const QOpenGLTexture);
2958 return d->dimensions[0];
2959}
2960
2966int QOpenGLTexture::height() const
2967{
2968 Q_D(const QOpenGLTexture);
2969 return d->dimensions[1];
2970}
2971
2977int QOpenGLTexture::depth() const
2978{
2979 Q_D(const QOpenGLTexture);
2980 return d->dimensions[2];
2981}
2982
2994void QOpenGLTexture::setMipLevels(int levels)
2995{
2996 Q_D(QOpenGLTexture);
2997 d->create();
2998 if (isStorageAllocated()) {
2999 qWarning("Cannot set mip levels on a texture that already has storage allocated.\n"
3000 "To do so, destroy() the texture and then create() and setMipLevels()");
3001 return;
3002 }
3003
3004 switch (d->target) {
3005 case QOpenGLTexture::Target1D:
3006 case QOpenGLTexture::Target1DArray:
3007 case QOpenGLTexture::Target2D:
3008 case QOpenGLTexture::Target2DArray:
3009 case QOpenGLTexture::TargetCubeMap:
3010 case QOpenGLTexture::TargetCubeMapArray:
3011 case QOpenGLTexture::Target3D:
3012 d->requestedMipLevels = levels;
3013 break;
3014
3015 case QOpenGLTexture::TargetBuffer:
3016 case QOpenGLTexture::TargetRectangle:
3017 case QOpenGLTexture::Target2DMultisample:
3018 case QOpenGLTexture::Target2DMultisampleArray:
3019 qWarning("QAbstractOpenGLTexture::setMipLevels(): This texture target does not support mipmaps");
3020 break;
3021 }
3022}
3023
3031int QOpenGLTexture::mipLevels() const
3032{
3033 Q_D(const QOpenGLTexture);
3034 return isStorageAllocated() ? d->mipLevels : d->requestedMipLevels;
3035}
3036
3043int QOpenGLTexture::maximumMipLevels() const
3044{
3045 Q_D(const QOpenGLTexture);
3046 return d->maximumMipLevelCount();
3047}
3048
3058void QOpenGLTexture::setLayers(int layers)
3059{
3060 Q_D(QOpenGLTexture);
3061 d->create();
3062 if (isStorageAllocated()) {
3063 qWarning("Cannot set layers on a texture that already has storage allocated.\n"
3064 "To do so, destroy() the texture and then create() and setLayers()");
3065 return;
3066 }
3067
3068 switch (d->target) {
3069 case QOpenGLTexture::Target1DArray:
3070 case QOpenGLTexture::Target2DArray:
3071 case QOpenGLTexture::TargetCubeMapArray:
3072 case QOpenGLTexture::Target2DMultisampleArray:
3073 d->layers = layers;
3074 break;
3075
3076 case QOpenGLTexture::Target1D:
3077 case QOpenGLTexture::Target2D:
3078 case QOpenGLTexture::Target3D:
3079 case QOpenGLTexture::TargetCubeMap:
3080 case QOpenGLTexture::TargetBuffer:
3081 case QOpenGLTexture::TargetRectangle:
3082 case QOpenGLTexture::Target2DMultisample:
3083 qWarning("Texture target does not support array layers");
3084 break;
3085 }
3086}
3087
3098int QOpenGLTexture::layers() const
3099{
3100 Q_D(const QOpenGLTexture);
3101 return d->layers;
3102}
3103
3110int QOpenGLTexture::faces() const
3111{
3112 Q_D(const QOpenGLTexture);
3113 return d->faces;
3114}
3115
3126void QOpenGLTexture::setSamples(int samples)
3127{
3128 Q_D(QOpenGLTexture);
3129 d->create();
3130 if (isStorageAllocated()) {
3131 qWarning("Cannot set sample count on a texture that already has storage allocated.\n"
3132 "To do so, destroy() the texture and then create() and setSamples()");
3133 return;
3134 }
3135
3136 switch (d->target) {
3137 case QOpenGLTexture::Target2DMultisample:
3138 case QOpenGLTexture::Target2DMultisampleArray:
3139 d->samples = samples;
3140 break;
3141
3142 case QOpenGLTexture::Target1D:
3143 case QOpenGLTexture::Target2D:
3144 case QOpenGLTexture::Target3D:
3145 case QOpenGLTexture::Target1DArray:
3146 case QOpenGLTexture::Target2DArray:
3147 case QOpenGLTexture::TargetCubeMap:
3148 case QOpenGLTexture::TargetCubeMapArray:
3149 case QOpenGLTexture::TargetBuffer:
3150 case QOpenGLTexture::TargetRectangle:
3151
3152 qWarning("Texture target does not support multisampling");
3153 break;
3154 }
3155}
3156
3167int QOpenGLTexture::samples() const
3168{
3169 Q_D(const QOpenGLTexture);
3170 return d->samples;
3171}
3172
3188void QOpenGLTexture::setFixedSamplePositions(bool fixed)
3189{
3190 Q_D(QOpenGLTexture);
3191 d->create();
3192 if (isStorageAllocated()) {
3193 qWarning("Cannot set sample positions on a texture that already has storage allocated.\n"
3194 "To do so, destroy() the texture and then create() and setFixedSamplePositions()");
3195 return;
3196 }
3197
3198 switch (d->target) {
3199 case QOpenGLTexture::Target2DMultisample:
3200 case QOpenGLTexture::Target2DMultisampleArray:
3201 d->fixedSamplePositions = fixed;
3202 break;
3203
3204 case QOpenGLTexture::Target1D:
3205 case QOpenGLTexture::Target2D:
3206 case QOpenGLTexture::Target3D:
3207 case QOpenGLTexture::Target1DArray:
3208 case QOpenGLTexture::Target2DArray:
3209 case QOpenGLTexture::TargetCubeMap:
3210 case QOpenGLTexture::TargetCubeMapArray:
3211 case QOpenGLTexture::TargetBuffer:
3212 case QOpenGLTexture::TargetRectangle:
3213
3214 qWarning("Texture target does not support multisampling");
3215 break;
3216 }
3217}
3218
3229bool QOpenGLTexture::isFixedSamplePositions() const
3230{
3231 Q_D(const QOpenGLTexture);
3232 return d->fixedSamplePositions;
3233}
3234
3261void QOpenGLTexture::allocateStorage()
3262{
3263 Q_D(QOpenGLTexture);
3264 if (d->create()) {
3265 const QOpenGLTexture::PixelFormat pixelFormat = pixelFormatCompatibleWithInternalFormat(d->format);
3266 const QOpenGLTexture::PixelType pixelType = pixelTypeCompatibleWithInternalFormat(d->format);
3267 d->allocateStorage(pixelFormat, pixelType);
3268 }
3269}
3270
3293void QOpenGLTexture::allocateStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType)
3294{
3295 Q_D(QOpenGLTexture);
3296 if (d->create())
3297 d->allocateStorage(pixelFormat, pixelType);
3298}
3299
3309bool QOpenGLTexture::isStorageAllocated() const
3310{
3311 Q_D(const QOpenGLTexture);
3312 return d->storageAllocated;
3313}
3314
3347QOpenGLTexture *QOpenGLTexture::createTextureView(Target target,
3348 TextureFormat viewFormat,
3349 int minimumMipmapLevel, int maximumMipmapLevel,
3350 int minimumLayer, int maximumLayer) const
3351{
3352 Q_D(const QOpenGLTexture);
3353 if (!isStorageAllocated()) {
3354 qWarning("Cannot set create a texture view of a texture that does not have storage allocated.");
3355 return nullptr;
3356 }
3357 Q_ASSERT(maximumMipmapLevel >= minimumMipmapLevel);
3358 Q_ASSERT(maximumLayer >= minimumLayer);
3359 return d->createTextureView(target, viewFormat,
3360 minimumMipmapLevel, maximumMipmapLevel,
3361 minimumLayer, maximumLayer);
3362}
3363
3370bool QOpenGLTexture::isTextureView() const
3371{
3372 Q_D(const QOpenGLTexture);
3373 Q_ASSERT(d->textureId);
3374 return d->textureView;
3375}
3376
3393void QOpenGLTexture::setData(int mipLevel, int layer, CubeMapFace cubeFace,
3394 PixelFormat sourceFormat, PixelType sourceType,
3395 const void *data, const QOpenGLPixelTransferOptions * const options)
3396{
3397 Q_D(QOpenGLTexture);
3398 Q_ASSERT(d->textureId);
3399 if (!isStorageAllocated()) {
3400 qWarning("Cannot set data on a texture that does not have storage allocated.\n"
3401 "To do so call allocateStorage() before this function");
3402 return;
3403 }
3404 d->setData(mipLevel, layer, 1, cubeFace, sourceFormat, sourceType, data, options);
3405}
3406
3414void QOpenGLTexture::setData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions * const options)
3415{
3416 Q_D(QOpenGLTexture);
3417 Q_ASSERT(d->textureId);
3418 if (!isStorageAllocated()) {
3419 qWarning("Cannot set data on a texture that does not have storage allocated.\n"
3420 "To do so call allocateStorage() before this function");
3421 return;
3422 }
3423 d->setData(mipLevel, layer, layerCount, cubeFace, sourceFormat, sourceType, data, options);
3424}
3425
3430void QOpenGLTexture::setData(int mipLevel, int layer,
3431 PixelFormat sourceFormat, PixelType sourceType,
3432 const void *data, const QOpenGLPixelTransferOptions * const options)
3433{
3434 Q_D(QOpenGLTexture);
3435 Q_ASSERT(d->textureId);
3436 d->setData(mipLevel, layer, 1, QOpenGLTexture::CubeMapPositiveX, sourceFormat, sourceType, data, options);
3437}
3438
3443void QOpenGLTexture::setData(int mipLevel,
3444 PixelFormat sourceFormat, PixelType sourceType,
3445 const void *data, const QOpenGLPixelTransferOptions * const options)
3446{
3447 Q_D(QOpenGLTexture);
3448 Q_ASSERT(d->textureId);
3449 d->setData(mipLevel, 0, 1, QOpenGLTexture::CubeMapPositiveX, sourceFormat, sourceType, data, options);
3450}
3451
3456void QOpenGLTexture::setData(PixelFormat sourceFormat, PixelType sourceType,
3457 const void *data, const QOpenGLPixelTransferOptions * const options)
3458{
3459 Q_D(QOpenGLTexture);
3460 Q_ASSERT(d->textureId);
3461 d->setData(0, 0, 1, QOpenGLTexture::CubeMapPositiveX, sourceFormat, sourceType, data, options);
3462}
3463
3477void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset,
3478 int width, int height, int depth,
3479 PixelFormat sourceFormat, PixelType sourceType,
3480 const void *data, const QOpenGLPixelTransferOptions * const options)
3481{
3482 Q_D(QOpenGLTexture);
3483 Q_ASSERT(d->textureId);
3484 d->setData(xOffset, yOffset, zOffset,
3485 width, height, depth,
3486 0, 0, 1,
3487 QOpenGLTexture::CubeMapPositiveX, sourceFormat,
3488 sourceType, data, options);
3489}
3490
3505void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset,
3506 int width, int height, int depth,
3507 int mipLevel,
3508 PixelFormat sourceFormat, PixelType sourceType,
3509 const void *data, const QOpenGLPixelTransferOptions * const options)
3510{
3511 Q_D(QOpenGLTexture);
3512 Q_ASSERT(d->textureId);
3513 d->setData(xOffset, yOffset, zOffset,
3514 width, height, depth,
3515 mipLevel, 0, 1,
3516 QOpenGLTexture::CubeMapPositiveX, sourceFormat,
3517 sourceType, data, options);
3518}
3519
3534void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset,
3535 int width, int height, int depth,
3536 int mipLevel, int layer,
3537 PixelFormat sourceFormat, PixelType sourceType,
3538 const void *data, const QOpenGLPixelTransferOptions * const options)
3539{
3540 Q_D(QOpenGLTexture);
3541 Q_ASSERT(d->textureId);
3542 d->setData(xOffset, yOffset, zOffset,
3543 width, height, depth,
3544 mipLevel, layer, 1,
3545 QOpenGLTexture::CubeMapPositiveX, sourceFormat,
3546 sourceType, data, options);
3547}
3548
3564void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset,
3565 int width, int height, int depth,
3566 int mipLevel, int layer,
3567 CubeMapFace face,
3568 PixelFormat sourceFormat, PixelType sourceType,
3569 const void *data, const QOpenGLPixelTransferOptions * const options)
3570{
3571 Q_D(QOpenGLTexture);
3572 Q_ASSERT(d->textureId);
3573 d->setData(xOffset, yOffset, zOffset,
3574 width, height, depth,
3575 mipLevel, layer, 1,
3576 face, sourceFormat,
3577 sourceType, data, options);
3578}
3579
3595void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset,
3596 int width, int height, int depth,
3597 int mipLevel, int layer,
3598 CubeMapFace face, int layerCount,
3599 PixelFormat sourceFormat, PixelType sourceType,
3600 const void *data, const QOpenGLPixelTransferOptions * const options)
3601{
3602 Q_D(QOpenGLTexture);
3603 Q_ASSERT(d->textureId);
3604 d->setData(xOffset, yOffset, zOffset,
3605 width, height, depth,
3606 mipLevel, layer, layerCount,
3607 face, sourceFormat,
3608 sourceType, data, options);
3609}
3610
3621void QOpenGLTexture::setData(const QImage& image, MipMapGeneration genMipMaps)
3622{
3623 QOpenGLContext *context = QOpenGLContext::currentContext();
3624 if (!context) {
3625 qWarning("QOpenGLTexture::setData() requires a valid current context");
3626 return;
3627 }
3628
3629 if (image.isNull()) {
3630 qWarning("QOpenGLTexture::setData() tried to set a null image");
3631 return;
3632 }
3633
3634 QImage glImage = image.convertToFormat(QImage::Format_RGBA8888);
3635 if (glImage.isNull()) {
3636 qWarning("QOpenGLTexture::setData() failed to convert image");
3637 return;
3638 }
3639
3640 if (context->isOpenGLES() && context->format().majorVersion() < 3)
3641 setFormat(QOpenGLTexture::RGBAFormat);
3642 else
3643 setFormat(QOpenGLTexture::RGBA8_UNorm);
3644
3645 setSize(image.width(), image.height());
3646 setMipLevels(genMipMaps == GenerateMipMaps ? maximumMipLevels() : 1);
3647 allocateStorage(QOpenGLTexture::RGBA, QOpenGLTexture::UInt8);
3648
3649 // Upload pixel data and generate mipmaps
3650 QOpenGLPixelTransferOptions uploadOptions;
3651 uploadOptions.setAlignment(1);
3652 setData(0, QOpenGLTexture::RGBA, QOpenGLTexture::UInt8, glImage.constBits(), &uploadOptions);
3653}
3654
3665void QOpenGLTexture::setCompressedData(int mipLevel, int layer, CubeMapFace cubeFace,
3666 int dataSize, const void *data,
3667 const QOpenGLPixelTransferOptions * const options)
3668{
3669 Q_D(QOpenGLTexture);
3670 Q_ASSERT(d->textureId);
3671 if (!isStorageAllocated()) {
3672 qWarning("Cannot set data on a texture that does not have storage allocated.\n"
3673 "To do so call allocateStorage() before this function");
3674 return;
3675 }
3676 d->setCompressedData(mipLevel, layer, 1, cubeFace, dataSize, data, options);
3677}
3678
3686void QOpenGLTexture::setCompressedData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace, int dataSize, const void *data, const QOpenGLPixelTransferOptions * const options)
3687{
3688 Q_D(QOpenGLTexture);
3689 Q_ASSERT(d->textureId);
3690 if (!isStorageAllocated()) {
3691 qWarning("Cannot set data on a texture that does not have storage allocated.\n"
3692 "To do so call allocateStorage() before this function");
3693 return;
3694 }
3695 d->setCompressedData(mipLevel, layer, layerCount, cubeFace, dataSize, data, options);
3696}
3697
3701void QOpenGLTexture::setCompressedData(int mipLevel, int layer, int dataSize, const void *data,
3702 const QOpenGLPixelTransferOptions * const options)
3703{
3704 Q_D(QOpenGLTexture);
3705 Q_ASSERT(d->textureId);
3706 d->setCompressedData(mipLevel, layer, 1, QOpenGLTexture::CubeMapPositiveX, dataSize, data, options);
3707}
3708
3712void QOpenGLTexture::setCompressedData(int mipLevel, int dataSize, const void *data,
3713 const QOpenGLPixelTransferOptions * const options)
3714{
3715 Q_D(QOpenGLTexture);
3716 Q_ASSERT(d->textureId);
3717 d->setCompressedData(mipLevel, 0, 1, QOpenGLTexture::CubeMapPositiveX, dataSize, data, options);
3718}
3719
3723void QOpenGLTexture::setCompressedData(int dataSize, const void *data,
3724 const QOpenGLPixelTransferOptions * const options)
3725{
3726 Q_D(QOpenGLTexture);
3727 Q_ASSERT(d->textureId);
3728 d->setCompressedData(0, 0, 1, QOpenGLTexture::CubeMapPositiveX, dataSize, data, options);
3729}
3730
3735bool QOpenGLTexture::hasFeature(Feature feature)
3736{
3737 QOpenGLContext *ctx = QOpenGLContext::currentContext();
3738 if (!ctx) {
3739 qWarning("QOpenGLTexture::hasFeature() requires a valid current context");
3740 return false;
3741 }
3742
3743 QSurfaceFormat f = ctx->format();
3744
3745 bool supported = false;
3746
3747#if !QT_CONFIG(opengles2)
3748 if (!ctx->isOpenGLES()) {
3749 switch (feature) {
3750 case ImmutableMultisampleStorage:
3751 supported = f.version() >= qMakePair(4, 3)
3752 || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_storage_multisample"));
3753 break;
3754
3755 case TextureBuffer:
3756 supported = f.version() >= qMakePair(3, 0)
3757 || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_buffer_object"));
3758 break;
3759
3760 case StencilTexturing:
3761 supported = f.version() >= qMakePair(4, 3)
3762 || ctx->hasExtension(QByteArrayLiteral("GL_ARB_stencil_texturing"));
3763 break;
3764
3765 case ImmutableStorage:
3766 supported = f.version() >= qMakePair(4, 2)
3767 || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_storage"))
3768 || ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_storage"));
3769 break;
3770
3771 case TextureCubeMapArrays:
3772 supported = f.version() >= qMakePair(4, 0)
3773 || ctx->hasExtension(QByteArrayLiteral("ARB_texture_cube_map_array"));
3774 break;
3775
3776 case Swizzle:
3777 supported = f.version() >= qMakePair(3, 3)
3778 || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_swizzle"));
3779 break;
3780
3781 case TextureMultisample:
3782 supported = f.version() >= qMakePair(3, 2)
3783 || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_multisample"));
3784 break;
3785
3786 case TextureArrays:
3787 supported = f.version() >= qMakePair(3, 0)
3788 || ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_array"));
3789 break;
3790
3791 case TextureRectangle:
3792 supported = f.version() >= qMakePair(2, 1)
3793 || ctx->hasExtension(QByteArrayLiteral("ARB_texture_rectangle"));
3794 break;
3795
3796 case Texture3D:
3797 supported = f.version() >= qMakePair(1, 3);
3798 break;
3799
3800 case AnisotropicFiltering:
3801 supported = ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_filter_anisotropic"));
3802 break;
3803
3804 case NPOTTextures:
3805 case NPOTTextureRepeat:
3806 supported = ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_non_power_of_two"));
3807 break;
3808
3809 case Texture1D:
3810 supported = f.version() >= qMakePair(1, 1);
3811 break;
3812
3813 case TextureComparisonOperators:
3814 // GL 1.4 and GL_ARB_shadow alone support only LEQUAL and GEQUAL;
3815 // since we're talking about history anyhow avoid to be extra pedantic
3816 // in the feature set, and simply claim supported if we have the full set of operators
3817 // (which has been added into 1.5 / GL_EXT_shadow_funcs).
3818 supported = f.version() >= qMakePair(1, 5)
3819 || (ctx->hasExtension(QByteArrayLiteral("GL_ARB_shadow"))
3820 && ctx->hasExtension(QByteArrayLiteral("GL_EXT_shadow_funcs")));
3821 break;
3822
3823 case TextureMipMapLevel:
3824 supported = f.version() >= qMakePair(1, 2);
3825 break;
3826
3827 case MaxFeatureFlag:
3828 break;
3829 }
3830 }
3831
3832 if (ctx->isOpenGLES())
3833#endif
3834 {
3835 const char *renderer = reinterpret_cast<const char *>(ctx->functions()->glGetString(GL_RENDERER));
3836 switch (feature) {
3837 case ImmutableStorage:
3838 supported = (f.version() >= qMakePair(3, 0) || ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_storage")))
3839 && !(renderer && strstr(renderer, "Mali")); // do not use on Mali: QTBUG-45106
3840 break;
3841
3842 case ImmutableMultisampleStorage:
3843 supported = f.version() >= qMakePair(3, 1);
3844 break;
3845
3846 case TextureRectangle:
3847 break;
3848
3849 case TextureArrays:
3850 supported = f.version() >= qMakePair(3, 0);
3851 break;
3852
3853 case Texture3D:
3854 supported = f.version() >= qMakePair(3, 0)
3855 || ctx->hasExtension(QByteArrayLiteral("GL_OES_texture_3D"));
3856 break;
3857
3858 case TextureMultisample:
3859 supported = f.version() >= qMakePair(3, 1);
3860 break;
3861
3862 case TextureBuffer:
3863 break;
3864
3865 case TextureCubeMapArrays:
3866 break;
3867
3868 case Swizzle:
3869 supported = f.version() >= qMakePair(3, 0);
3870 break;
3871
3872 case StencilTexturing:
3873 break;
3874
3875 case AnisotropicFiltering:
3876 supported = ctx->hasExtension(QByteArrayLiteral("GL_EXT_texture_filter_anisotropic"));
3877 break;
3878
3879 case NPOTTextures:
3880 case NPOTTextureRepeat:
3881 supported = f.version() >= qMakePair(3,0)
3882 || ctx->hasExtension(QByteArrayLiteral("GL_OES_texture_npot"))
3883 || ctx->hasExtension(QByteArrayLiteral("GL_ARB_texture_non_power_of_two"));
3884 break;
3885
3886 case Texture1D:
3887 break;
3888
3889 case TextureComparisonOperators:
3890 supported = f.version() >= qMakePair(3, 0)
3891 || ctx->hasExtension(QByteArrayLiteral("GL_EXT_shadow_samplers"));
3892 break;
3893
3894 case TextureMipMapLevel:
3895 supported = f.version() >= qMakePair(3, 0);
3896 break;
3897
3898 case MaxFeatureFlag:
3899 break;
3900 }
3901 }
3902
3903 return supported;
3904}
3905
3912void QOpenGLTexture::setMipBaseLevel(int baseLevel)
3913{
3914 Q_D(QOpenGLTexture);
3915 d->create();
3916 if (!d->features.testFlag(TextureMipMapLevel)) {
3917 qWarning("QOpenGLTexture::setMipBaseLevel: requires OpenGL >= 1.2 or OpenGL ES >= 3.0");
3918 return;
3919 }
3920 Q_ASSERT(d->textureId);
3921 Q_ASSERT(d->texFuncs);
3922 Q_ASSERT(baseLevel <= d->maxLevel);
3923 d->baseLevel = baseLevel;
3924 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BASE_LEVEL, baseLevel);
3925}
3926
3933int QOpenGLTexture::mipBaseLevel() const
3934{
3935 Q_D(const QOpenGLTexture);
3936 return d->baseLevel;
3937}
3938
3945void QOpenGLTexture::setMipMaxLevel(int maxLevel)
3946{
3947 Q_D(QOpenGLTexture);
3948 d->create();
3949 if (!d->features.testFlag(TextureMipMapLevel)) {
3950 qWarning("QOpenGLTexture::setMipMaxLevel: requires OpenGL >= 1.2 or OpenGL ES >= 3.0");
3951 return;
3952 }
3953 Q_ASSERT(d->textureId);
3954 Q_ASSERT(d->texFuncs);
3955 Q_ASSERT(d->baseLevel <= maxLevel);
3956 d->maxLevel = maxLevel;
3957 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LEVEL, maxLevel);
3958}
3959
3965int QOpenGLTexture::mipMaxLevel() const
3966{
3967 Q_D(const QOpenGLTexture);
3968 return d->maxLevel;
3969}
3970
3978void QOpenGLTexture::setMipLevelRange(int baseLevel, int maxLevel)
3979{
3980 Q_D(QOpenGLTexture);
3981 d->create();
3982 if (!d->features.testFlag(TextureMipMapLevel)) {
3983 qWarning("QOpenGLTexture::setMipLevelRange: requires OpenGL >= 1.2 or OpenGL ES >= 3.0");
3984 return;
3985 }
3986 Q_ASSERT(d->textureId);
3987 Q_ASSERT(d->texFuncs);
3988 Q_ASSERT(baseLevel <= maxLevel);
3989 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BASE_LEVEL, baseLevel);
3990 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LEVEL, maxLevel);
3991}
3992
3998QPair<int, int> QOpenGLTexture::mipLevelRange() const
3999{
4000 Q_D(const QOpenGLTexture);
4001 return qMakePair(d->baseLevel, d->maxLevel);
4002}
4003
4014void QOpenGLTexture::setAutoMipMapGenerationEnabled(bool enabled)
4015{
4016 Q_D(QOpenGLTexture);
4017 d->autoGenerateMipMaps = enabled;
4018}
4019
4025bool QOpenGLTexture::isAutoMipMapGenerationEnabled() const
4026{
4027 Q_D(const QOpenGLTexture);
4028 return d->autoGenerateMipMaps;
4029}
4030
4041void QOpenGLTexture::generateMipMaps()
4042{
4043 Q_D(QOpenGLTexture);
4044 Q_ASSERT(d->texFuncs);
4045 Q_ASSERT(d->textureId);
4046 if (isCompressedFormat(d->format)) {
4047 if (QOpenGLContext *ctx = QOpenGLContext::currentContext())
4048 if (ctx->isOpenGLES())
4049 return;
4050 }
4051 d->texFuncs->glGenerateTextureMipmap(d->textureId, d->target, d->bindingTarget);
4052}
4053
4066void QOpenGLTexture::generateMipMaps(int baseLevel, bool resetBaseLevel)
4067{
4068 Q_D(QOpenGLTexture);
4069 Q_ASSERT(d->texFuncs);
4070 Q_ASSERT(d->textureId);
4071 if (isCompressedFormat(d->format)) {
4072 if (QOpenGLContext *ctx = QOpenGLContext::currentContext())
4073 if (ctx->isOpenGLES())
4074 return;
4075 }
4076 int oldBaseLevel;
4077 if (resetBaseLevel)
4078 oldBaseLevel = mipBaseLevel();
4079 setMipBaseLevel(baseLevel);
4080 d->texFuncs->glGenerateTextureMipmap(d->textureId, d->target, d->bindingTarget);
4081 if (resetBaseLevel)
4082 setMipBaseLevel(oldBaseLevel);
4083}
4084
4097void QOpenGLTexture::setSwizzleMask(SwizzleComponent component, SwizzleValue value)
4098{
4099#if !defined(Q_OS_MAC) && !QT_CONFIG(opengles2)
4100 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
4101 Q_D(QOpenGLTexture);
4102 d->create();
4103 Q_ASSERT(d->texFuncs);
4104 Q_ASSERT(d->textureId);
4105 if (!d->features.testFlag(Swizzle)) {
4106 qWarning("QOpenGLTexture::setSwizzleMask() requires OpenGL >= 3.3");
4107 return;
4108 }
4109 d->swizzleMask[component - SwizzleRed] = value;
4110 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, component, value);
4111 return;
4112 }
4113#else
4114 Q_UNUSED(component);
4115 Q_UNUSED(value);
4116#endif
4117 qWarning("QOpenGLTexture: Texture swizzling is not supported");
4118}
4119
4125void QOpenGLTexture::setSwizzleMask(SwizzleValue r, SwizzleValue g,
4126 SwizzleValue b, SwizzleValue a)
4127{
4128#if !defined(Q_OS_MAC) && !QT_CONFIG(opengles2)
4129 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
4130 Q_D(QOpenGLTexture);
4131 d->create();
4132 Q_ASSERT(d->texFuncs);
4133 Q_ASSERT(d->textureId);
4134 if (!d->features.testFlag(Swizzle)) {
4135 qWarning("QOpenGLTexture::setSwizzleMask() requires OpenGL >= 3.3");
4136 return;
4137 }
4138 GLint swizzleMask[] = {GLint(r), GLint(g), GLint(b), GLint(a)};
4139 d->swizzleMask[0] = r;
4140 d->swizzleMask[1] = g;
4141 d->swizzleMask[2] = b;
4142 d->swizzleMask[3] = a;
4143 d->texFuncs->glTextureParameteriv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
4144 return;
4145 }
4146#else
4147 Q_UNUSED(r);
4148 Q_UNUSED(g);
4149 Q_UNUSED(b);
4150 Q_UNUSED(a);
4151#endif
4152 qWarning("QOpenGLTexture: Texture swizzling is not supported");
4153}
4154
4163
4186void QOpenGLTexture::setDepthStencilMode(QOpenGLTexture::DepthStencilMode mode)
4187{
4188#if !defined(Q_OS_MAC) && !QT_CONFIG(opengles2)
4189 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
4190 Q_D(QOpenGLTexture);
4191 d->create();
4192 Q_ASSERT(d->texFuncs);
4193 Q_ASSERT(d->textureId);
4194 if (!d->features.testFlag(StencilTexturing)) {
4195 qWarning("QOpenGLTexture::setDepthStencilMode() requires OpenGL >= 4.3 or GL_ARB_stencil_texturing");
4196 return;
4197 }
4198 d->depthStencilMode = mode;
4199 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_DEPTH_STENCIL_TEXTURE_MODE, mode);
4200 return;
4201 }
4202#else
4203 Q_UNUSED(mode);
4204#endif
4205 qWarning("QOpenGLTexture: DepthStencil Mode is not supported");
4206}
4207
4214QOpenGLTexture::DepthStencilMode QOpenGLTexture::depthStencilMode() const
4215{
4216 Q_D(const QOpenGLTexture);
4217 return d->depthStencilMode;
4218}
4219
4246void QOpenGLTexture::setComparisonFunction(QOpenGLTexture::ComparisonFunction function)
4247{
4248 Q_D(QOpenGLTexture);
4249 d->create();
4250 if (!d->features.testFlag(TextureComparisonOperators)) {
4251 qWarning("QOpenGLTexture::setComparisonFunction: requires OpenGL >= 1.5 or OpenGL ES >= 3.0");
4252 return;
4253 }
4254 d->comparisonFunction = function;
4255 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_COMPARE_FUNC, function);
4256}
4257
4266QOpenGLTexture::ComparisonFunction QOpenGLTexture::comparisonFunction() const
4267{
4268 Q_D(const QOpenGLTexture);
4269 return d->comparisonFunction;
4270}
4271
4289void QOpenGLTexture::setComparisonMode(QOpenGLTexture::ComparisonMode mode)
4290{
4291 Q_D(QOpenGLTexture);
4292 d->create();
4293 if (!d->features.testFlag(TextureComparisonOperators)) {
4294 qWarning("QOpenGLTexture::setComparisonMode: requires OpenGL >= 1.5 or OpenGL ES >= 3.0");
4295 return;
4296 }
4297 d->comparisonMode = mode;
4298 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_COMPARE_MODE, mode);
4299}
4300
4309QOpenGLTexture::ComparisonMode QOpenGLTexture::comparisonMode() const
4310{
4311 Q_D(const QOpenGLTexture);
4312 return d->comparisonMode;
4313}
4314
4320void QOpenGLTexture::setMinificationFilter(QOpenGLTexture::Filter filter)
4321{
4322 Q_D(QOpenGLTexture);
4323 d->create();
4324 Q_ASSERT(d->texFuncs);
4325 Q_ASSERT(d->textureId);
4326 d->minFilter = filter;
4327 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_FILTER, filter);
4328}
4329
4335QOpenGLTexture::Filter QOpenGLTexture::minificationFilter() const
4336{
4337 Q_D(const QOpenGLTexture);
4338 return d->minFilter;
4339}
4340
4346void QOpenGLTexture::setMagnificationFilter(QOpenGLTexture::Filter filter)
4347{
4348 Q_D(QOpenGLTexture);
4349 d->create();
4350 Q_ASSERT(d->texFuncs);
4351 Q_ASSERT(d->textureId);
4352 d->magFilter = filter;
4353 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAG_FILTER, filter);
4354}
4355
4361QOpenGLTexture::Filter QOpenGLTexture::magnificationFilter() const
4362{
4363 Q_D(const QOpenGLTexture);
4364 return d->magFilter;
4365}
4366
4373void QOpenGLTexture::setMinMagFilters(QOpenGLTexture::Filter minificationFilter,
4374 QOpenGLTexture::Filter magnificationFilter)
4375{
4376 Q_D(QOpenGLTexture);
4377 d->create();
4378 Q_ASSERT(d->texFuncs);
4379 Q_ASSERT(d->textureId);
4380 d->minFilter = minificationFilter;
4381 d->magFilter = magnificationFilter;
4382 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_FILTER, minificationFilter);
4383 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAG_FILTER, magnificationFilter);
4384}
4385
4391QPair<QOpenGLTexture::Filter, QOpenGLTexture::Filter> QOpenGLTexture::minMagFilters() const
4392{
4393 Q_D(const QOpenGLTexture);
4394 return QPair<QOpenGLTexture::Filter, QOpenGLTexture::Filter>(d->minFilter, d->magFilter);
4395}
4396
4403void QOpenGLTexture::setMaximumAnisotropy(float anisotropy)
4404{
4405 Q_D(QOpenGLTexture);
4406 d->create();
4407 Q_ASSERT(d->texFuncs);
4408 Q_ASSERT(d->textureId);
4409 if (!d->features.testFlag(AnisotropicFiltering)) {
4410 qWarning("QOpenGLTexture::setMaximumAnisotropy() requires GL_EXT_texture_filter_anisotropic");
4411 return;
4412 }
4413 d->maxAnisotropy = anisotropy;
4414 d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
4415}
4416
4423float QOpenGLTexture::maximumAnisotropy() const
4424{
4425 Q_D(const QOpenGLTexture);
4426 return d->maxAnisotropy;
4427}
4428
4434void QOpenGLTexture::setWrapMode(QOpenGLTexture::WrapMode mode)
4435{
4436 Q_D(QOpenGLTexture);
4437 d->create();
4438 Q_ASSERT(d->texFuncs);
4439 Q_ASSERT(d->textureId);
4440 d->setWrapMode(mode);
4441}
4442
4447void QOpenGLTexture::setWrapMode(QOpenGLTexture::CoordinateDirection direction, QOpenGLTexture::WrapMode mode)
4448{
4449 Q_D(QOpenGLTexture);
4450 d->create();
4451 Q_ASSERT(d->texFuncs);
4452 Q_ASSERT(d->textureId);
4453 d->setWrapMode(direction, mode);
4454}
4455
4466
4473void QOpenGLTexture::setBorderColor(const QColor &color)
4474{
4475 setBorderColor(static_cast<float>(color.redF()), static_cast<float>(color.greenF()),
4476 static_cast<float>(color.blueF()), static_cast<float>(color.alphaF()));
4477}
4478
4484void QOpenGLTexture::setBorderColor(float r, float g, float b, float a)
4485{
4486#if !QT_CONFIG(opengles2)
4487 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
4488 Q_D(QOpenGLTexture);
4489 d->create();
4490 Q_ASSERT(d->texFuncs);
4491 Q_ASSERT(d->textureId);
4492 float values[4];
4493 values[0] = r;
4494 values[1] = g;
4495 values[2] = b;
4496 values[3] = a;
4497 d->borderColor.clear();
4498 for (int i = 0; i < 4; ++i)
4499 d->borderColor.append(QVariant(values[i]));
4500 d->texFuncs->glTextureParameterfv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BORDER_COLOR, values);
4501 return;
4502 }
4503#else
4504 Q_UNUSED(r);
4505 Q_UNUSED(g);
4506 Q_UNUSED(b);
4507 Q_UNUSED(a);
4508#endif
4509 qWarning("QOpenGLTexture: Border color is not supported");
4510}
4511
4517void QOpenGLTexture::setBorderColor(int r, int g, int b, int a)
4518{
4519#if !QT_CONFIG(opengles2)
4520 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
4521 Q_D(QOpenGLTexture);
4522 d->create();
4523 Q_ASSERT(d->texFuncs);
4524 Q_ASSERT(d->textureId);
4525 int values[4];
4526 values[0] = r;
4527 values[1] = g;
4528 values[2] = b;
4529 values[3] = a;
4530 d->borderColor.clear();
4531 for (int i = 0; i < 4; ++i)
4532 d->borderColor.append(QVariant(values[i]));
4533 d->texFuncs->glTextureParameteriv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BORDER_COLOR, values);
4534 return;
4535 }
4536#else
4537 Q_UNUSED(r);
4538 Q_UNUSED(g);
4539 Q_UNUSED(b);
4540 Q_UNUSED(a);
4541#endif
4542 qWarning("QOpenGLTexture: Border color is not supported");
4543
4544 // TODO Handle case of using glTextureParameterIiv() based on format
4545}
4546
4552void QOpenGLTexture::setBorderColor(uint r, uint g, uint b, uint a)
4553{
4554#if !QT_CONFIG(opengles2)
4555 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
4556 Q_D(QOpenGLTexture);
4557 d->create();
4558 Q_ASSERT(d->texFuncs);
4559 Q_ASSERT(d->textureId);
4560 int values[4];
4561 values[0] = int(r);
4562 values[1] = int(g);
4563 values[2] = int(b);
4564 values[3] = int(a);
4565 d->borderColor.clear();
4566 for (int i = 0; i < 4; ++i)
4567 d->borderColor.append(QVariant(values[i]));
4568 d->texFuncs->glTextureParameteriv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BORDER_COLOR, values);
4569 return;
4570 }
4571#else
4572 Q_UNUSED(r);
4573 Q_UNUSED(g);
4574 Q_UNUSED(b);
4575 Q_UNUSED(a);
4576#endif
4577 qWarning("QOpenGLTexture: Border color is not supported");
4578
4579 // TODO Handle case of using glTextureParameterIuiv() based on format
4580}
4581
4587QColor QOpenGLTexture::borderColor() const
4588{
4589 Q_D(const QOpenGLTexture);
4590 QColor c(0.0f, 0.0f, 0.0f, 0.0f);
4591 if (!d->borderColor.isEmpty()) {
4592 c.setRedF(d->borderColor.at(0).toFloat());
4593 c.setGreenF(d->borderColor.at(1).toFloat());
4594 c.setBlueF(d->borderColor.at(2).toFloat());
4595 c.setAlphaF(d->borderColor.at(3).toFloat());
4596 }
4597 return c;
4598}
4599
4606void QOpenGLTexture::borderColor(float *border) const
4607{
4608 Q_D(const QOpenGLTexture);
4609 Q_ASSERT(border);
4610 if (d->borderColor.isEmpty()) {
4611 for (int i = 0; i < 4; ++i)
4612 border[i] = 0.0f;
4613 } else {
4614 for (int i = 0; i < 4; ++i)
4615 border[i] = d->borderColor.at(i).toFloat();
4616 }
4617}
4618
4625void QOpenGLTexture::borderColor(int *border) const
4626{
4627 Q_D(const QOpenGLTexture);
4628 Q_ASSERT(border);
4629 if (d->borderColor.isEmpty()) {
4630 for (int i = 0; i < 4; ++i)
4631 border[i] = 0;
4632 } else {
4633 for (int i = 0; i < 4; ++i)
4634 border[i] = d->borderColor.at(i).toInt();
4635 }
4636}
4637
4644void QOpenGLTexture::borderColor(unsigned int *border) const
4645{
4646 Q_D(const QOpenGLTexture);
4647 Q_ASSERT(border);
4648 if (d->borderColor.isEmpty()) {
4649 for (int i = 0; i < 4; ++i)
4650 border[i] = 0;
4651 } else {
4652 for (int i = 0; i < 4; ++i)
4653 border[i] = d->borderColor.at(i).toUInt();
4654 }
4655}
4656
4664void QOpenGLTexture::setMinimumLevelOfDetail(float value)
4665{
4666#if !QT_CONFIG(opengles2)
4667 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
4668 Q_D(QOpenGLTexture);
4669 d->create();
4670 Q_ASSERT(d->texFuncs);
4671 Q_ASSERT(d->textureId);
4672 Q_ASSERT(value < d->maxLevelOfDetail);
4673 d->minLevelOfDetail = value;
4674 d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_LOD, value);
4675 return;
4676 }
4677#else
4678 Q_UNUSED(value);
4679#endif
4680 qWarning("QOpenGLTexture: Detail level is not supported");
4681}
4682
4688float QOpenGLTexture::minimumLevelOfDetail() const
4689{
4690 Q_D(const QOpenGLTexture);
4691 return d->minLevelOfDetail;
4692}
4693
4701void QOpenGLTexture::setMaximumLevelOfDetail(float value)
4702{
4703#if !QT_CONFIG(opengles2)
4704 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
4705 Q_D(QOpenGLTexture);
4706 d->create();
4707 Q_ASSERT(d->texFuncs);
4708 Q_ASSERT(d->textureId);
4709 Q_ASSERT(value > d->minLevelOfDetail);
4710 d->maxLevelOfDetail = value;
4711 d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LOD, value);
4712 return;
4713 }
4714#else
4715 Q_UNUSED(value);
4716#endif
4717 qWarning("QOpenGLTexture: Detail level is not supported");
4718}
4719
4725float QOpenGLTexture::maximumLevelOfDetail() const
4726{
4727 Q_D(const QOpenGLTexture);
4728 return d->maxLevelOfDetail;
4729}
4730
4737void QOpenGLTexture::setLevelOfDetailRange(float min, float max)
4738{
4739#if !QT_CONFIG(opengles2)
4740 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
4741 Q_D(QOpenGLTexture);
4742 d->create();
4743 Q_ASSERT(d->texFuncs);
4744 Q_ASSERT(d->textureId);
4745 Q_ASSERT(min < max);
4746 d->minLevelOfDetail = min;
4747 d->maxLevelOfDetail = max;
4748 d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_LOD, min);
4749 d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LOD, max);
4750 return;
4751 }
4752#else
4753 Q_UNUSED(min);
4754 Q_UNUSED(max);
4755#endif
4756 qWarning("QOpenGLTexture: Detail level is not supported");
4757}
4758
4764QPair<float, float> QOpenGLTexture::levelOfDetailRange() const
4765{
4766 Q_D(const QOpenGLTexture);
4767 return qMakePair(d->minLevelOfDetail, d->maxLevelOfDetail);
4768}
4769
4779void QOpenGLTexture::setLevelofDetailBias(float bias)
4780{
4781#if !QT_CONFIG(opengles2)
4782 if (!QOpenGLContext::currentContext()->isOpenGLES()) {
4783 Q_D(QOpenGLTexture);
4784 d->create();
4785 Q_ASSERT(d->texFuncs);
4786 Q_ASSERT(d->textureId);
4787 d->levelOfDetailBias = bias;
4788 d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_LOD_BIAS, bias);
4789 return;
4790 }
4791#else
4792 Q_UNUSED(bias);
4793#endif
4794 qWarning("QOpenGLTexture: Detail level is not supported");
4795}
4796
4802float QOpenGLTexture::levelofDetailBias() const
4803{
4804 Q_D(const QOpenGLTexture);
4805 return d->levelOfDetailBias;
4806}
4807
4808#ifndef QT_NO_DEBUG_STREAM
4809QDebug operator<<(QDebug debug, const QOpenGLTexture *t)
4810{
4811 QDebugStateSaver saver(debug);
4812 debug.nospace();
4813 debug << "QOpenGLTexture(";
4814 if (t) {
4815 const QOpenGLTexturePrivate *d = t->d_ptr.data();
4816 debug << d->target << ", bindingTarget=" << d->bindingTarget
4817 << ", size=[" << d->dimensions[0]
4818 << ", " << d->dimensions[1];
4819 if (d->target == QOpenGLTexture::Target3D)
4820 debug << ", " << d->dimensions[2];
4821 debug << "], format=" << d->format << ", formatClass=" << d->formatClass;
4822 if (t->isCreated())
4823 debug << ", textureId=" << d->textureId;
4824 if (t->isBound())
4825 debug << ", [bound]";
4826 if (t->isTextureView())
4827 debug << ", [view]";
4828 if (d->fixedSamplePositions)
4829 debug << ", [fixedSamplePositions]";
4830 debug << ", mipLevels=" << d->requestedMipLevels << ", layers=" << d->layers
4831 << ", faces=" << d->faces << ", samples=" << d->samples
4832 << ", depthStencilMode=" << d->depthStencilMode << ", comparisonFunction="
4833 << d->comparisonFunction << ", comparisonMode=" << d->comparisonMode
4834 << ", features=" << d->features << ", minificationFilter=" << d->minFilter
4835 << ", magnificationFilter=" << d->magFilter << ", wrapMode=" << d->wrapModes[0];
4836 } else {
4837 debug << '0';
4838 }
4839 debug << ')';
4840 return debug;
4841}
4842#endif // QT_NO_DEBUG_STREAM
4843
4844QT_END_NAMESPACE
4845
4846#include "moc_qopengltexture.cpp"
QColor
The QColor class provides colors based on RGB, HSV or CMYK values.
Definition qcolor.h:31
QDebugStateSaver
\inmodule QtCore
QDebug
\inmodule QtCore
QImage
\inmodule QtGui
Definition qimage.h:37
QImage::Format_RGBA8888
@ Format_RGBA8888
Definition qimage.h:59
QObject::d_ptr
QScopedPointer< QObjectData > d_ptr
Definition qobject.h:373
QOpenGLContext
\inmodule QtGui
Definition qopenglcontext.h:67
QOpenGLContext::currentContext
static QOpenGLContext * currentContext()
Returns the last context which called makeCurrent in the current thread, or \nullptr,...
Definition qopenglcontext.cpp:228
QOpenGLContext::areSharing
static bool areSharing(QOpenGLContext *first, QOpenGLContext *second)
Returns true if the first and second contexts are sharing OpenGL resources.
Definition qopenglcontext.cpp:239
QOpenGLFunctions
The QOpenGLFunctions class provides cross-platform access to the OpenGL ES 2.0 API.
Definition qopenglfunctions.h:202
QOpenGLFunctions::glGenTextures
void glGenTextures(GLsizei n, GLuint *textures)
Convenience function that calls glGenTextures(n, textures).
Definition qopenglfunctions.h:769
QOpenGLFunctions::glBindTexture
void glBindTexture(GLenum target, GLuint texture)
Convenience function that calls glBindTexture(target, texture).
Definition qopenglfunctions.h:560
QOpenGLFunctions::glDeleteTextures
void glDeleteTextures(GLsizei n, const GLuint *textures)
Convenience function that calls glDeleteTextures(n, textures).
Definition qopenglfunctions.h:659
QOpenGLFunctions::glGetIntegerv
void glGetIntegerv(GLenum pname, GLint *params)
Convenience function that calls glGetIntegerv(pname, params).
Definition qopenglfunctions.h:813
QOpenGLPixelTransferOptions::setAlignment
void setAlignment(int alignment)
Sets the alignment requirements for each pixel row.
Definition qopenglpixeltransferoptions.cpp:88
QOpenGLTextureHelper::glTextureStorage2D
void glTextureStorage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height)
Definition qopengltexturehelper_p.h:91
QOpenGLTextureHelper::glTextureView
void glTextureView(GLuint texture, GLenum target, GLuint origTexture, GLenum internalFormat, GLuint minLevel, GLuint numLevels, GLuint minLayer, GLuint numLayers)
Definition qopengltexturehelper_p.h:583
QOpenGLTextureHelper::glCompressedTextureImage2D
void glCompressedTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits, const QOpenGLPixelTransferOptions *const options=nullptr)
Definition qopengltexturehelper_p.h:249
QOpenGLTextureHelper::glTextureStorage3DMultisample
void glTextureStorage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
Definition qopengltexturehelper_p.h:103
QOpenGLTextureHelper::glTextureImage2DMultisample
void glTextureImage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
Definition qopengltexturehelper_p.h:181
QOpenGLTextureHelper::glActiveTexture
void glActiveTexture(GLenum texture)
Definition qopengltexturehelper_p.h:522
QOpenGLTextureHelper::glTextureStorage1D
void glTextureStorage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width)
Definition qopengltexturehelper_p.h:97
QOpenGLTextureHelper::glTextureImage2D
void glTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
Definition qopengltexturehelper_p.h:121
QOpenGLTextureHelper::glTextureImage3DMultisample
void glTextureImage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
Definition qopengltexturehelper_p.h:175
QOpenGLTextureHelper::glTextureStorage3D
void glTextureStorage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth)
Definition qopengltexturehelper_p.h:85
QOpenGLTextureHelper::glTextureImage3D
void glTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
Definition qopengltexturehelper_p.h:115
QOpenGLTextureHelper::glCompressedTextureImage1D
void glCompressedTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits, const QOpenGLPixelTransferOptions *const options=nullptr)
Definition qopengltexturehelper_p.h:234
QOpenGLTextureHelper::glCompressedTextureSubImage1D
void glCompressedTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits, const QOpenGLPixelTransferOptions *const options=nullptr)
Definition qopengltexturehelper_p.h:187
QOpenGLTextureHelper::glTextureSubImage2D
void glTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels, const QOpenGLPixelTransferOptions *const options=nullptr)
Definition qopengltexturehelper_p.h:147
QOpenGLTextureHelper::glCompressedTextureSubImage2D
void glCompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits, const QOpenGLPixelTransferOptions *const options=nullptr)
Definition qopengltexturehelper_p.h:202
QOpenGLTextureHelper::glTextureImage1D
void glTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
Definition qopengltexturehelper_p.h:127
QOpenGLTextureHelper::glTextureSubImage3D
void glTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels, const QOpenGLPixelTransferOptions *const options=nullptr)
Definition qopengltexturehelper_p.h:133
QOpenGLTextureHelper::glCompressedTextureImage3D
void glCompressedTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits, const QOpenGLPixelTransferOptions *const options=nullptr)
Definition qopengltexturehelper_p.h:265
QOpenGLTextureHelper::glTextureStorage2DMultisample
void glTextureStorage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
Definition qopengltexturehelper_p.h:109
QOpenGLTextureHelper::glCompressedTextureSubImage3D
void glCompressedTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits, const QOpenGLPixelTransferOptions *const options=nullptr)
Definition qopengltexturehelper_p.h:218
QOpenGLTextureHelper::glTextureParameteri
void glTextureParameteri(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param)
Definition qopengltexturehelper_p.h:60
QOpenGLTextureHelper::glTextureSubImage1D
void glTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels, const QOpenGLPixelTransferOptions *const options=nullptr)
Definition qopengltexturehelper_p.h:161
QOpenGLTexturePrivate::bindingTarget
QOpenGLTexture::BindingTarget bindingTarget
Definition qopengltexture_p.h:102
QOpenGLTexturePrivate::swizzleMask
QOpenGLTexture::SwizzleValue swizzleMask[4]
Definition qopengltexture_p.h:118
QOpenGLTexturePrivate::wrapMode
QOpenGLTexture::WrapMode wrapMode(QOpenGLTexture::CoordinateDirection direction) const
Definition qopengltexture.cpp:1781
QOpenGLTexturePrivate::allocateStorage
void allocateStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType)
Definition qopengltexture.cpp:472
QOpenGLTexturePrivate::minFilter
QOpenGLTexture::Filter minFilter
Definition qopengltexture_p.h:123
QOpenGLTexturePrivate::setData
void setData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options)
Definition qopengltexture.cpp:1327
QOpenGLTexturePrivate::functions
QOpenGLFunctions * functions
Definition qopengltexture_p.h:137
QOpenGLTexturePrivate::isUsingImmutableStorage
bool isUsingImmutableStorage() const
Definition qopengltexture.cpp:461
QOpenGLTexturePrivate::magFilter
QOpenGLTexture::Filter magFilter
Definition qopengltexture_p.h:124
QOpenGLTexturePrivate::QOpenGLTexturePrivate
QOpenGLTexturePrivate(QOpenGLTexture::Target textureTarget, QOpenGLTexture *qq)
Definition qopengltexture.cpp:22
QOpenGLTexturePrivate::wrapModes
QOpenGLTexture::WrapMode wrapModes[3]
Definition qopengltexture_p.h:126
QOpenGLTexturePrivate::target
QOpenGLTexture::Target target
Definition qopengltexture_p.h:101
QOpenGLTexturePrivate::allocateMutableStorage
void allocateMutableStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType)
Definition qopengltexture.cpp:1082
QOpenGLTexturePrivate::setWrapMode
void setWrapMode(QOpenGLTexture::WrapMode mode)
Definition qopengltexture.cpp:1686
QOpenGLTexturePrivate::maximumMipLevelCount
int maximumMipLevelCount() const
Definition qopengltexture_p.h:87
QOpenGLTexturePrivate::depthStencilMode
QOpenGLTexture::DepthStencilMode depthStencilMode
Definition qopengltexture_p.h:119
QOpenGLTexturePrivate::features
QOpenGLTexture::Features features
Definition qopengltexture_p.h:139
QOpenGLTexturePrivate::createTextureView
QOpenGLTexture * createTextureView(QOpenGLTexture::Target target, QOpenGLTexture::TextureFormat viewFormat, int minimumMipmapLevel, int maximumMipmapLevel, int minimumLayer, int maximumLayer) const
Definition qopengltexture.cpp:1836
QOpenGLTexturePrivate::setCompressedData
void setCompressedData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace, int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options)
Definition qopengltexture.cpp:1547
QOpenGLTexturePrivate::mipLevelSize
static int mipLevelSize(int mipLevel, int baseLevelSize)
Definition qopengltexture_p.h:92
QOpenGLTexturePrivate::texFuncs
QOpenGLTextureHelper * texFuncs
Definition qopengltexture_p.h:136
QOpenGLTexturePrivate::context
QOpenGLContext * context
Definition qopengltexture_p.h:100
QOpenGLTexturePrivate::format
QOpenGLTexture::TextureFormat format
Definition qopengltexture_p.h:104
QOpenGLTexturePrivate::formatClass
QOpenGLTexture::TextureFormatClass formatClass
Definition qopengltexture_p.h:105
QOpenGLTexture
\inmodule QtGui
Definition qopengltexture.h:22
QOpenGLTexture::width
int width() const
Returns the width of a 1D, 2D or 3D texture.
Definition qopengltexture.cpp:2955
QOpenGLTexture::TextureFormat
TextureFormat
This enum defines the possible texture formats.
Definition qopengltexture.h:67
QOpenGLTexture::release
void release()
Unbinds this texture from the currently active texture unit.
Definition qopengltexture.cpp:2582
QOpenGLTexture::depth
int depth() const
Returns the depth of a 3D texture.
Definition qopengltexture.cpp:2977
QOpenGLTexture::isBound
bool isBound() const
Returns true if this texture is bound to the corresponding target of the currently active texture uni...
Definition qopengltexture.cpp:2607
QOpenGLTexture::setSwizzleMask
void setSwizzleMask(SwizzleComponent component, SwizzleValue value)
GLSL shaders are able to reorder the components of the vec4 returned by texture functions.
Definition qopengltexture.cpp:4097
QOpenGLTexture::setMipLevels
void setMipLevels(int levels)
For texture targets that support mipmaps, this function sets the requested number of mipmap levels to...
Definition qopengltexture.cpp:2994
QOpenGLTexture::hasFeature
static bool hasFeature(Feature feature)
Returns true if your OpenGL implementation and version supports the texture feature feature.
Definition qopengltexture.cpp:3735
QOpenGLTexture::setMaximumLevelOfDetail
void setMaximumLevelOfDetail(float value)
Sets the maximum level of detail to value.
Definition qopengltexture.cpp:4701
QOpenGLTexture::maximumLevelOfDetail
float maximumLevelOfDetail() const
Returns the maximum level of detail parameter.
Definition qopengltexture.cpp:4725
QOpenGLTexture::Filter
Filter
This enum defines the filtering parameters for a QOpenGLTexture object.
Definition qopengltexture.h:540
QOpenGLTexture::wrapMode
WrapMode wrapMode(CoordinateDirection direction) const
Returns the wrap mode for the texture dimension direction.
Definition qopengltexture.cpp:4461
QOpenGLTexture::isAutoMipMapGenerationEnabled
bool isAutoMipMapGenerationEnabled() const
Returns whether auto mipmap generation is enabled for this texture object.
Definition qopengltexture.cpp:4025
QOpenGLTexture::setLevelofDetailBias
void setLevelofDetailBias(float bias)
Sets the level of detail bias to bias.
Definition qopengltexture.cpp:4779
QOpenGLTexture::setFormat
void setFormat(TextureFormat format)
Sets the format of this texture object to format.
Definition qopengltexture.cpp:2679
QOpenGLTexture::setWrapMode
void setWrapMode(WrapMode mode)
Sets the wrap (or repeat mode) for all texture dimensions to mode.
Definition qopengltexture.cpp:4434
QOpenGLTexture::format
TextureFormat format() const
Returns the format of this texture object.
Definition qopengltexture.cpp:2878
QOpenGLTexture::MipMapGeneration
MipMapGeneration
This enum defines the options to control mipmap generation.
Definition qopengltexture.h:55
QOpenGLTexture::faces
int faces() const
Returns the number of faces for this texture.
Definition qopengltexture.cpp:3110
QOpenGLTexture::setMipMaxLevel
void setMipMaxLevel(int maxLevel)
Sets the maximum mipmap level used for all texture lookups with this texture to maxLevel.
Definition qopengltexture.cpp:3945
QOpenGLTexture::mipBaseLevel
int mipBaseLevel() const
Returns the mipmap base level used for all texture lookups with this texture.
Definition qopengltexture.cpp:3933
QOpenGLTexture::WrapMode
WrapMode
This enum defines the possible texture coordinate wrapping modes.
Definition qopengltexture.h:331
QOpenGLTexture::setMipLevelRange
void setMipLevelRange(int baseLevel, int maxLevel)
Sets the range of mipmap levels that can be used for texture lookups with this texture to range from ...
Definition qopengltexture.cpp:3978
QOpenGLTexture::setMinMagFilters
void setMinMagFilters(Filter minificationFilter, Filter magnificationFilter)
Sets the minification filter to minificationFilter and the magnification filter to magnificationFilte...
Definition qopengltexture.cpp:4373
QOpenGLTexture::depthStencilMode
DepthStencilMode depthStencilMode() const
Returns the depth stencil mode for textures using a combined depth/stencil format.
Definition qopengltexture.cpp:4214
QOpenGLTexture::samples
int samples() const
Returns the number of multisample sample points for this texture.
Definition qopengltexture.cpp:3167
QOpenGLTexture::comparisonMode
ComparisonMode comparisonMode() const
Definition qopengltexture.cpp:4309
QOpenGLTexture::setComparisonMode
void setComparisonMode(ComparisonMode mode)
Definition qopengltexture.cpp:4289
QOpenGLTexture::isStorageAllocated
bool isStorageAllocated() const
Returns true if server-side storage for this texture as been allocated.
Definition qopengltexture.cpp:3309
QOpenGLTexture::minMagFilters
QPair< Filter, Filter > minMagFilters() const
Returns the current minification and magnification filters.
Definition qopengltexture.cpp:4391
QOpenGLTexture::setMinificationFilter
void setMinificationFilter(Filter filter)
Sets the filter used for minification to filter.
Definition qopengltexture.cpp:4320
QOpenGLTexture::isCreated
bool isCreated() const
Returns true if the underlying OpenGL texture object has been created.
Definition qopengltexture.cpp:2524
QOpenGLTexture::SwizzleValue
SwizzleValue
This enum defines the possible mask values for texture swizzling.
Definition qopengltexture.h:321
QOpenGLTexture::mipLevelRange
QPair< int, int > mipLevelRange() const
Returns the range of mipmap levels that can be used for texture lookups with this texture.
Definition qopengltexture.cpp:3998
QOpenGLTexture::setAutoMipMapGenerationEnabled
void setAutoMipMapGenerationEnabled(bool enabled)
If enabled is true, enables automatic mipmap generation for this texture object to occur whenever the...
Definition qopengltexture.cpp:4014
QOpenGLTexture::setMipBaseLevel
void setMipBaseLevel(int baseLevel)
Sets the base mipmap level used for all texture lookups with this texture to baseLevel.
Definition qopengltexture.cpp:3912
QOpenGLTexture::QOpenGLTexture
QOpenGLTexture(Target target)
Creates a QOpenGLTexture object that can later be bound to target.
Definition qopengltexture.cpp:2445
QOpenGLTexture::destroy
void destroy()
Destroys the underlying OpenGL texture object.
Definition qopengltexture.cpp:2513
QOpenGLTexture::setCompressedData
void setCompressedData(int mipLevel, int layer, CubeMapFace cubeFace, int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options=nullptr)
Uploads compressed pixel data to mipLevel, array layer, and cubeFace.
Definition qopengltexture.cpp:3665
QOpenGLTexture::levelofDetailBias
float levelofDetailBias() const
Returns the level of detail bias parameter.
Definition qopengltexture.cpp:4802
QOpenGLTexture::borderColor
QColor borderColor() const
Returns the borderColor of this texture.
Definition qopengltexture.cpp:4587
QOpenGLTexture::setLevelOfDetailRange
void setLevelOfDetailRange(float min, float max)
Sets the minimum level of detail parameters to min and the maximum level to max.
Definition qopengltexture.cpp:4737
QOpenGLTexture::setComparisonFunction
void setComparisonFunction(ComparisonFunction function)
Definition qopengltexture.cpp:4246
QOpenGLTexture::isFixedSamplePositions
bool isFixedSamplePositions() const
Returns whether this texture uses a fixed pattern of multisample samples.
Definition qopengltexture.cpp:3229
QOpenGLTexture::setMaximumAnisotropy
void setMaximumAnisotropy(float anisotropy)
If your OpenGL implementation supports the GL_EXT_texture_filter_anisotropic extension this function ...
Definition qopengltexture.cpp:4403
QOpenGLTexture::CubeMapFace
CubeMapFace
This enum defines the possible CubeMap faces.
Definition qopengltexture.h:250
QOpenGLTexture::BindingTarget
BindingTarget
This enum defines the possible binding targets of texture units.
Definition qopengltexture.h:40
QOpenGLTexture::BindingTarget2DMultisampleArray
@ BindingTarget2DMultisampleArray
Definition qopengltexture.h:49
QOpenGLTexture::magnificationFilter
Filter magnificationFilter() const
Returns the magnification filter.
Definition qopengltexture.cpp:4361
QOpenGLTexture::minificationFilter
Filter minificationFilter() const
Returns the minification filter.
Definition qopengltexture.cpp:4335
QOpenGLTexture::setMinimumLevelOfDetail
void setMinimumLevelOfDetail(float value)
Sets the minimum level of detail to value.
Definition qopengltexture.cpp:4664
QOpenGLTexture::PixelType
PixelType
This enum defines the possible pixel data types for a pixel transfer operation.
Definition qopengltexture.h:283
QOpenGLTexture::setFixedSamplePositions
void setFixedSamplePositions(bool fixed)
Sets whether the sample positions and number of samples used with a multisample capable texture targe...
Definition qopengltexture.cpp:3188
QOpenGLTexture::Target
Target
This enum defines the texture target of a QOpenGLTexture object.
Definition qopengltexture.h:25
QOpenGLTexture::height
int height() const
Returns the height of a 2D or 3D texture.
Definition qopengltexture.cpp:2966
QOpenGLTexture::create
bool create()
Creates the underlying OpenGL texture object.
Definition qopengltexture.cpp:2501
QOpenGLTexture::allocateStorage
void allocateStorage()
Allocates server-side storage for this texture object taking into account, the format,...
Definition qopengltexture.cpp:3261
QOpenGLTexture::levelOfDetailRange
QPair< float, float > levelOfDetailRange() const
Returns the minimum and maximum level of detail parameters.
Definition qopengltexture.cpp:4764
QOpenGLTexture::mipLevels
int mipLevels() const
Returns the number of mipmap levels for this texture.
Definition qopengltexture.cpp:3031
QOpenGLTexture::setLayers
void setLayers(int layers)
Sets the number of array layers to allocate storage for.
Definition qopengltexture.cpp:3058
QOpenGLTexture::target
Target target() const
Returns the binding target of this texture.
Definition qopengltexture.cpp:2478
QOpenGLTexture::boundTextureId
static GLuint boundTextureId(BindingTarget target)
Returns the textureId of the texture that is bound to the target of the currently active texture unit...
Definition qopengltexture.cpp:2631
QOpenGLTexture::setMagnificationFilter
void setMagnificationFilter(Filter filter)
Sets the magnification filter to filter.
Definition qopengltexture.cpp:4346
QOpenGLTexture::maximumAnisotropy
float maximumAnisotropy() const
Returns the maximum level of anisotropy to be accounted for when performing texture lookups.
Definition qopengltexture.cpp:4423
QOpenGLTexture::bind
void bind()
Binds this texture to the currently active texture unit ready for rendering.
Definition qopengltexture.cpp:2551
QOpenGLTexture::swizzleMask
SwizzleValue swizzleMask(SwizzleComponent component) const
Returns the swizzle mask for texture component.
Definition qopengltexture.cpp:4158
QOpenGLTexture::minimumLevelOfDetail
float minimumLevelOfDetail() const
Returns the minimum level of detail parameter.
Definition qopengltexture.cpp:4688
QOpenGLTexture::PixelFormat
PixelFormat
This enum defines the possible client-side pixel formats for a pixel transfer operation.
Definition qopengltexture.h:260
QOpenGLTexture::setBorderColor
void setBorderColor(const QColor &color)
Sets the border color of the texture to color.
Definition qopengltexture.cpp:4473
QOpenGLTexture::mipMaxLevel
int mipMaxLevel() const
Returns the mipmap maximum level used for all texture lookups with this texture.
Definition qopengltexture.cpp:3965
QOpenGLTexture::textureId
GLuint textureId() const
Returns the name of the underlying OpenGL texture object or 0 if it has not yet been created.
Definition qopengltexture.cpp:2536
QOpenGLTexture::maximumMipLevels
int maximumMipLevels() const
Returns the maximum number of mipmap levels that this texture can have given the current dimensions.
Definition qopengltexture.cpp:3043
QOpenGLTexture::setData
void setData(int mipLevel, int layer, CubeMapFace cubeFace, PixelFormat sourceFormat, PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options=nullptr)
Uploads pixel data for this texture object mipLevel, array layer, and cubeFace.
Definition qopengltexture.cpp:3393
QOpenGLTexture::setDepthStencilMode
void setDepthStencilMode(DepthStencilMode mode)
If using a texture that has a combined depth/stencil format this function sets which component of the...
Definition qopengltexture.cpp:4186
QOpenGLTexture::setSize
void setSize(int width, int height=1, int depth=1)
Sets the dimensions of this texture object to width, height, and depth.
Definition qopengltexture.cpp:2902
QOpenGLTexture::comparisonFunction
ComparisonFunction comparisonFunction() const
Definition qopengltexture.cpp:4266
QOpenGLTexture::createTextureView
QOpenGLTexture * createTextureView(Target target, TextureFormat viewFormat, int minimumMipmapLevel, int maximumMipmapLevel, int minimumLayer, int maximumLayer) const
Attempts to create a texture view onto this texture.
Definition qopengltexture.cpp:3347
QOpenGLTexture::SwizzleComponent
SwizzleComponent
This enum defines the texture color components that can be assigned a swizzle mask.
Definition qopengltexture.h:313
QOpenGLTexture::Feature
Feature
This enum defines the OpenGL texture-related features that can be tested for.
Definition qopengltexture.h:347
QOpenGLTexture::TextureUnitReset
TextureUnitReset
This enum defines options ot control texture unit activation.
Definition qopengltexture.h:61
QOpenGLTexture::layers
int layers() const
Returns the number of array layers for this texture.
Definition qopengltexture.cpp:3098
QOpenGLTexture::CoordinateDirection
CoordinateDirection
This enum defines the possible texture coordinate directions.
Definition qopengltexture.h:339
QOpenGLTexture::setSamples
void setSamples(int samples)
Sets the number of samples to allocate storage for when rendering to a multisample capable texture ta...
Definition qopengltexture.cpp:3126
QOpenGLTexture::generateMipMaps
void generateMipMaps()
Generates mipmaps for this texture object from mipmap level 0.
Definition qopengltexture.cpp:4041
QOpenGLTexture::isTextureView
bool isTextureView() const
Returns true if this texture object is actually a view onto another texture object.
Definition qopengltexture.cpp:3370
QSurfaceFormat
The QSurfaceFormat class represents the format of a QSurface. \inmodule QtGui.
Definition qsurfaceformat.h:17
QSurfaceFormat::version
QPair< int, int > version() const
Returns a QPair<int, int> representing the OpenGL version.
Definition qsurfaceformat.cpp:632
QVariant
\inmodule QtCore
Definition qvariant.h:65
ctx
EGLContext ctx
Definition dmabufserverbufferintegration.h:20
funcs
static VulkanServerBufferGlFunctions * funcs
Definition vulkanserverbufferintegration.cpp:54
this
#define this
Definition dialogs.cpp:9
i
i
[1]
Definition doc_src_containers.cpp:169
direction
direction
Definition doc_src_styles.cpp:42
QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qstandardpaths_haiku.cpp:21
QT_END_NAMESPACE
Definition qsharedpointer.cpp:1590
image
Definition image.cpp:4
context
static void * context
Definition qandroidaudiosource.cpp:42
QByteArrayLiteral
#define QByteArrayLiteral(str)
Definition qbytearray.h:52
function
DBusConnection const char DBusError DBusBusType DBusError return DBusConnection DBusHandleMessageFunction function
Definition qdbus_symbols_p.h:178
value
EGLOutputLayerEXT EGLint EGLAttrib value
[5]
Definition qeglstreamconvenience_p.h:46
layers
const EGLAttrib EGLOutputLayerEXT * layers
Definition qeglstreamconvenience_p.h:44
layer
EGLOutputLayerEXT layer
Definition qeglstreamconvenience_p.h:46
qWarning
#define qWarning
Definition qlogging.h:166
qMin
constexpr const T & qMin(const T &a, const T &b)
Definition qminmax.h:40
qMax
constexpr const T & qMax(const T &a, const T &b)
Definition qminmax.h:42
GL_TEXTURE_MAX_ANISOTROPY_EXT
#define GL_TEXTURE_MAX_ANISOTROPY_EXT
Definition qopengles2ext.h:2148
values
GLenum GLsizei GLsizei GLint * values
[15]
Definition qopengles2ext.h:1032
b
GLboolean GLboolean GLboolean b
Definition qopengles2ext.h:337
faceIndex
GLenum GLsizeiptr const void GLsizei faceIndex
Definition qopengles2ext.h:3215
GLint
typedef GLint(GL_APIENTRYP PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC)(GLuint program
depth
GLint GLenum GLsizei GLsizei GLsizei depth
Definition qopengles2ext.h:603
samples
GLsizei samples
Definition qopengles2ext.h:738
mode
GLenum mode
Definition qopengles2ext.h:333
level
GLenum GLuint GLint level
Definition qopengles2ext.h:416
height
GLint GLsizei GLsizei height
Definition qopengles2ext.h:206
a
GLboolean GLboolean GLboolean GLboolean a
[7]
Definition qopengles2ext.h:337
r
GLboolean r
[2]
Definition qopengles2ext.h:337
dataSize
GLenum GLsizei dataSize
Definition qopengles2ext.h:858
data
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
Definition qopengles2ext.h:206
border
GLint GLenum GLsizei GLsizei GLsizei GLint border
Definition qopengles2ext.h:603
enabled
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition qopengles2ext.h:150
face
GLenum face
Definition qopengles2ext.h:3591
f
GLfloat GLfloat f
Definition qopengles2ext.h:795
levels
GLsizei levels
Definition qopengles2ext.h:1524
width
GLint GLsizei width
Definition qopengles2ext.h:206
color
GLuint color
[2]
Definition qopengles2ext.h:1140
target
GLenum target
Definition qopengles2ext.h:751
filter
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition qopengles2ext.h:893
g
GLboolean GLboolean g
Definition qopengles2ext.h:337
format
GLint GLsizei GLsizei GLenum format
Definition qopengles2ext.h:206
internalFormat
GLsizei GLenum internalFormat
Definition qopengles2ext.h:1524
GL_TEXTURE_COMPARE_FUNC
#define GL_TEXTURE_COMPARE_FUNC
Definition qopenglext.h:338
reset
GLboolean reset
Definition qopenglext.h:2748
GL_TEXTURE0
#define GL_TEXTURE0
Definition qopenglext.h:129
GL_DEPTH_STENCIL_TEXTURE_MODE
#define GL_DEPTH_STENCIL_TEXTURE_MODE
Definition qopenglext.h:2454
GL_TEXTURE_WRAP_R
#define GL_TEXTURE_WRAP_R
Definition qopenglext.h:87
c
const GLubyte * c
Definition qopenglext.h:12701
bias
GLfloat bias
Definition qopenglext.h:7943
GL_TEXTURE_BASE_LEVEL
#define GL_TEXTURE_BASE_LEVEL
Definition qopenglext.h:103
GL_TEXTURE_LOD_BIAS
#define GL_TEXTURE_LOD_BIAS
Definition qopenglext.h:333
GL_TEXTURE_MAX_LEVEL
#define GL_TEXTURE_MAX_LEVEL
Definition qopenglext.h:104
GL_ACTIVE_TEXTURE
#define GL_ACTIVE_TEXTURE
Definition qopenglext.h:161
GL_TEXTURE_SWIZZLE_RGBA
#define GL_TEXTURE_SWIZZLE_RGBA
Definition qopenglext.h:1552
t
GLdouble GLdouble t
Definition qopenglext.h:243
q
GLdouble GLdouble GLdouble GLdouble q
Definition qopenglext.h:259
result
GLuint64EXT * result
[6]
Definition qopenglext.h:10932
GL_TEXTURE_MAX_LOD
#define GL_TEXTURE_MAX_LOD
Definition qopenglext.h:102
GL_TEXTURE_MIN_LOD
#define GL_TEXTURE_MIN_LOD
Definition qopenglext.h:101
GL_TEXTURE_COMPARE_MODE
#define GL_TEXTURE_COMPARE_MODE
Definition qopenglext.h:337
pixelFormatCompatibleWithInternalFormat
static QOpenGLTexture::PixelFormat pixelFormatCompatibleWithInternalFormat(QOpenGLTexture::TextureFormat internalFormat)
Definition qopengltexture.cpp:483
pixelTypeCompatibleWithInternalFormat
static QOpenGLTexture::PixelType pixelTypeCompatibleWithInternalFormat(QOpenGLTexture::TextureFormat internalFormat)
Definition qopengltexture.cpp:760
isNpot
static bool isNpot(int width, int height=1, int depth=1)
Definition qopengltexture.cpp:2884
isCompressedFormat
static bool isCompressedFormat(QOpenGLTexture::TextureFormat internalFormat)
Definition qopengltexture.cpp:939
isTextureTargetMultisample
static bool isTextureTargetMultisample(QOpenGLTexture::Target target)
Definition qopengltexture.cpp:437
isSizedTextureFormat
static bool isSizedTextureFormat(QOpenGLTexture::TextureFormat internalFormat)
Definition qopengltexture.cpp:289
operator<<
QDebug operator<<(QDebug debug, const QOpenGLTexture *t)
Definition qopengltexture.cpp:4809
qopengltexture_p.h
qopengltexturehelper_p.h
qMakePair
QT_BEGIN_NAMESPACE constexpr decltype(auto) qMakePair(T1 &&value1, T2 &&value2) noexcept(noexcept(std::make_pair(std::forward< T1 >(value1), std::forward< T2 >(value2))))
Definition qpair.h:19
component
static qreal component(const QPointF &point, unsigned int i)
Definition qpathclipper.cpp:626
Q_ASSERT
#define Q_ASSERT(cond)
Definition qrandom.cpp:47
GLuint
#define GLuint
Definition qsgabstractrenderer_p.h:23
QSSGRenderTextureFilterOp::Nearest
@ Nearest
Q_UNUSED
#define Q_UNUSED(x)
Definition qtpreprocessorsupport.h:20
uint
unsigned int uint
Definition qtypes.h:34
enabled
#define enabled
Definition qopenglext.h:3098
nullptr
QObject::connect nullptr
Definition src_corelib_kernel_qobject.cpp:255
d
double d
Definition src_corelib_text_qlocale.cpp:9
false
return false
Definition src_corelib_thread_qatomic.cpp:23
view
QQuickView * view
[0]
Definition src_plugins_platforms_qnx_qqnxwindow.cpp:5
renderer
QSvgRenderer * renderer
[0]
Definition src_svg_qgraphicssvgitem.cpp:5