Revision control
Copy as Markdown
// Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB).
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include <QtCore/qhash.h>
#include "gltexture_p.h"
#include <private/qdebug_p.h>
#include <private/qopengltexture_p.h>
#include <private/qopengltexturehelper_p.h>
#include <QDebug>
#include <QOpenGLFunctions>
#include <QtOpenGL/QOpenGLVersionFunctionsFactory>
#include <QOpenGLTexture>
#include <QOpenGLPixelTransferOptions>
#include <Qt3DRender/qtexture.h>
#include <Qt3DRender/qtexturedata.h>
#include <Qt3DRender/qtextureimagedata.h>
#include <Qt3DRender/private/managers_p.h>
#include <Qt3DRender/private/qabstracttexture_p.h>
#include <Qt3DRender/private/qtextureimagedata_p.h>
#include <renderbuffer_p.h>
#include <Qt3DCore/private/vector_helper_p.h>
#if !QT_CONFIG(opengles2)
#include <QOpenGLFunctions_3_1>
#include <QOpenGLFunctions_4_5_Core>
#endif
QT_BEGIN_NAMESPACE
namespace Qt3DRender {
namespace Render {
namespace OpenGL {
namespace {
// This uploadGLData where the data is a fullsize subimage
// as QOpenGLTexture doesn't allow partial subimage uploads
void uploadGLData(QOpenGLTexture *glTex,
int level, int layer, QOpenGLTexture::CubeMapFace face,
const QByteArray &bytes, const QTextureImageDataPtr &data)
{
const auto alignment = data->alignment();
QOpenGLPixelTransferOptions uploadOptions;
uploadOptions.setAlignment(alignment);
if (data->isCompressed())
glTex->setCompressedData(level, layer, face, bytes.size(), bytes.constData());
else
glTex->setData(level, layer, face, data->pixelFormat(), data->pixelType(), bytes.constData(), &uploadOptions);
}
// For partial sub image uploads
void uploadGLData(QOpenGLTexture *glTex,
int mipLevel, int layer, QOpenGLTexture::CubeMapFace cubeFace,
int xOffset, int yOffset, int zOffset,
const QByteArray &bytes, const QTextureImageDataPtr &data)
{
if (data->isCompressed()) {
Q_UNREACHABLE();
} else {
const auto alignment = data->alignment();
QOpenGLPixelTransferOptions uploadOptions;
uploadOptions.setAlignment(alignment);
glTex->setData(xOffset, yOffset, zOffset,
data->width(), data->height(), data->depth(),
mipLevel, layer, cubeFace, data->layers(),
data->pixelFormat(), data->pixelType(),
bytes.constData(), &uploadOptions);
}
}
} // anonymous
GLTexture::GLTexture()
: m_dirtyFlags(None)
, m_gl(nullptr)
, m_renderBuffer(nullptr)
, m_dataFunctor()
, m_pendingDataFunctor(nullptr)
, m_sharedTextureId(-1)
, m_externalRendering(false)
, m_wasTextureRecreated(false)
{
}
GLTexture::~GLTexture()
{
}
// Must be called from RenderThread with active GL context
void GLTexture::destroy()
{
delete m_gl;
m_gl = nullptr;
delete m_renderBuffer;
m_renderBuffer = nullptr;
m_dirtyFlags = None;
m_sharedTextureId = -1;
m_externalRendering = false;
m_wasTextureRecreated = false;
m_dataFunctor.reset();
m_pendingDataFunctor = nullptr;
m_properties = {};
m_parameters = {};
m_textureData.reset();
m_images.clear();
m_imageData.clear();
m_pendingTextureDataUpdates.clear();
}
bool GLTexture::loadTextureDataFromGenerator()
{
m_textureData = m_dataFunctor->operator()();
// if there is a texture generator, most properties will be defined by it
if (m_textureData) {
const QAbstractTexture::Target target = m_textureData->target();
// If both target and functor return Automatic we are still
// probably loading the texture, return false
if (m_properties.target == QAbstractTexture::TargetAutomatic &&
target == QAbstractTexture::TargetAutomatic) {
m_textureData.reset();
return false;
}
if (m_properties.target != QAbstractTexture::TargetAutomatic &&
target != QAbstractTexture::TargetAutomatic &&
m_properties.target != target) {
qWarning() << Q_FUNC_INFO << "Generator and Properties not requesting the same texture target";
m_textureData.reset();
return false;
}
// We take target type from generator if it wasn't explicitly set by the user
if (m_properties.target == QAbstractTexture::TargetAutomatic)
m_properties.target = target;
m_properties.width = m_textureData->width();
m_properties.height = m_textureData->height();
m_properties.depth = m_textureData->depth();
m_properties.layers = m_textureData->layers();
m_properties.format = m_textureData->format();
const QList<QTextureImageDataPtr> imageData = m_textureData->imageData();
if (imageData.size() > 0) {
// Set the mips level based on the first image if autoMipMapGeneration is disabled
if (!m_properties.generateMipMaps)
m_properties.mipLevels = imageData.first()->mipLevels();
}
}
return !m_textureData.isNull();
}
void GLTexture::loadTextureDataFromImages()
{
int maxMipLevel = 0;
for (const Image &img : std::as_const(m_images)) {
const QTextureImageDataPtr imgData = img.generator->operator()();
// imgData may be null in the following cases:
// - Texture is created with TextureImages which have yet to be
// loaded (skybox where you don't yet know the path, source set by
// a property binding, queued connection ...)
// - TextureImage whose generator failed to return a valid data
// (invalid url, error opening file...)
if (imgData.isNull())
continue;
m_imageData.push_back(imgData);
maxMipLevel = qMax(maxMipLevel, img.mipLevel);
// If the texture doesn't have a texture generator, we will
// derive some properties from the first TextureImage (layer=0, miplvl=0, face=0)
if (!m_textureData && img.layer == 0 && img.mipLevel == 0 && img.face == QAbstractTexture::CubeMapPositiveX) {
if (imgData->width() != -1 && imgData->height() != -1 && imgData->depth() != -1) {
m_properties.width = imgData->width();
m_properties.height = imgData->height();
m_properties.depth = imgData->depth();
}
// Set the format of the texture if the texture format is set to Automatic
if (m_properties.format == QAbstractTexture::Automatic) {
m_properties.format = static_cast<QAbstractTexture::TextureFormat>(imgData->format());
}
setDirtyFlag(Properties, true);
}
}
// make sure the number of mip levels is set when there is no texture data generator
if (!m_dataFunctor) {
m_properties.mipLevels = maxMipLevel + 1;
setDirtyFlag(Properties, true);
}
}
// Called from RenderThread
GLTexture::TextureUpdateInfo GLTexture::createOrUpdateGLTexture()
{
TextureUpdateInfo textureInfo;
m_wasTextureRecreated = false;
const bool hasSharedTextureId = m_sharedTextureId > 0;
// Only load texture data if we are not using a sharedTextureId
// Check if dataFunctor or images have changed
if (!hasSharedTextureId) {
// If dataFunctor exists and we have no data and it hasn´t run yet
if (m_dataFunctor && !m_textureData && m_dataFunctor.get() != m_pendingDataFunctor ) {
const bool successfullyLoadedTextureData = loadTextureDataFromGenerator();
// If successful, m_textureData has content
if (successfullyLoadedTextureData) {
setDirtyFlag(Properties, true);
setDirtyFlag(TextureData, true);
} else {
if (m_pendingDataFunctor != m_dataFunctor.get()) {
qWarning() << "[Qt3DRender::GLTexture] No QTextureData generated from Texture Generator yet. Texture will be invalid for this frame";
m_pendingDataFunctor = m_dataFunctor.get();
}
textureInfo.properties.status = QAbstractTexture::Loading;
return textureInfo;
}
}
// If images have changed, clear previous images data
// and regenerate m_imageData for the images
if (testDirtyFlag(TextureImageData)) {
m_imageData.clear();
loadTextureDataFromImages();
// Mark for upload if we actually have something to upload
if (!m_imageData.empty()) {
setDirtyFlag(TextureData, true);
}
// Reset image flag
setDirtyFlag(TextureImageData, false);
}
// Don't try to create the texture if the target or format was still not set
// Format should either be set by user or if Automatic
// by either the dataGenerator of the texture or the first Image
// Target should explicitly be set by the user or the dataGenerator
if (m_properties.target == QAbstractTexture::TargetAutomatic ||
m_properties.format == QAbstractTexture::Automatic ||
m_properties.format == QAbstractTexture::NoFormat) {
textureInfo.properties.status = QAbstractTexture::Error;
return textureInfo;
}
}
// If the properties changed or texture has become a shared texture from a
// 3rd party engine, we need to destroy and maybe re-allocate the texture
if (testDirtyFlag(Properties) || testDirtyFlag(SharedTextureId)) {
delete m_gl;
m_gl = nullptr;
textureInfo.wasUpdated = true;
// If we are destroyed because of some property change but still have (some) of
// our content data make sure we are marked for upload
// TO DO: We should actually check if the textureData is still correct
// in regard to the size, target and format of the texture though.
if (!testDirtyFlag(SharedTextureId) &&
(m_textureData || !m_imageData.empty() || !m_pendingTextureDataUpdates.empty()))
setDirtyFlag(TextureData, true);
}
m_properties.status = QAbstractTexture::Ready;
if (testDirtyFlag(SharedTextureId) || hasSharedTextureId) {
// Update m_properties by doing introspection on the texture
if (hasSharedTextureId)
introspectPropertiesFromSharedTextureId();
setDirtyFlag(SharedTextureId, false);
} else {
// We only build a QOpenGLTexture if we have no shared textureId set
if (!m_gl) {
m_gl = buildGLTexture();
if (!m_gl) {
qWarning() << "[Qt3DRender::GLTexture] failed to create texture";
textureInfo.properties.status = QAbstractTexture::Error;
return textureInfo;
}
m_gl->allocateStorage();
if (!m_gl->isStorageAllocated()) {
qWarning() << "[Qt3DRender::GLTexture] failed to allocate texture";
textureInfo.properties.status = QAbstractTexture::Error;
return textureInfo;
}
m_wasTextureRecreated = true;
}
textureInfo.texture = m_gl;
// need to (re-)upload texture data?
const bool needsUpload = testDirtyFlag(TextureData);
if (needsUpload) {
uploadGLTextureData();
setDirtyFlag(TextureData, false);
}
// need to set texture parameters?
if (testDirtyFlag(Properties) || testDirtyFlag(Parameters)) {
updateGLTextureParameters();
setDirtyFlag(Properties, false);
setDirtyFlag(Parameters, false);
}
}
textureInfo.properties = m_properties;
return textureInfo;
}
RenderBuffer *GLTexture::getOrCreateRenderBuffer()
{
if (m_dataFunctor && !m_textureData) {
m_textureData = m_dataFunctor->operator()();
if (m_textureData) {
if (m_properties.target != QAbstractTexture::TargetAutomatic)
qWarning() << "[Qt3DRender::GLTexture] [renderbuffer] When a texture provides a generator, it's target is expected to be TargetAutomatic";
m_properties.width = m_textureData->width();
m_properties.height = m_textureData->height();
m_properties.format = m_textureData->format();
setDirtyFlag(Properties);
} else {
if (m_pendingDataFunctor != m_dataFunctor.get()) {
qWarning() << "[Qt3DRender::GLTexture] [renderbuffer] No QTextureData generated from Texture Generator yet. Texture will be invalid for this frame";
m_pendingDataFunctor = m_dataFunctor.get();
}
return nullptr;
}
}
if (testDirtyFlag(Properties)) {
delete m_renderBuffer;
m_renderBuffer = nullptr;
}
if (!m_renderBuffer)
m_renderBuffer = new RenderBuffer(m_properties.width, m_properties.height, m_properties.format);
setDirtyFlag(Properties, false);
setDirtyFlag(Parameters, false);
return m_renderBuffer;
}
// This must be called from the RenderThread
// So GLTexture release from the manager can only be done from that thread
void GLTexture::cleanup()
{
destroy();
}
void GLTexture::setParameters(const TextureParameters ¶ms)
{
if (m_parameters != params) {
m_parameters = params;
setDirtyFlag(Parameters);
}
}
void GLTexture::setProperties(const TextureProperties &props)
{
if (m_properties != props) {
m_properties = props;
setDirtyFlag(Properties);
}
}
void GLTexture::setImages(const std::vector<Image> &images)
{
// check if something has changed at all
const bool same = (images == m_images);
if (!same) {
m_images = images;
requestImageUpload();
}
}
void GLTexture::setGenerator(const QTextureGeneratorPtr &generator)
{
m_textureData.reset();
m_dataFunctor = generator;
m_pendingDataFunctor = nullptr;
requestUpload();
}
void GLTexture::setSharedTextureId(int textureId)
{
if (m_sharedTextureId != textureId) {
m_sharedTextureId = textureId;
setDirtyFlag(SharedTextureId);
}
}
void GLTexture::addTextureDataUpdates(const std::vector<QTextureDataUpdate> &updates)
{
Qt3DCore::append(m_pendingTextureDataUpdates, updates);
requestUpload();
}
// Return nullptr if
// - context cannot be obtained
// - texture hasn't yet been loaded
QOpenGLTexture *GLTexture::buildGLTexture()
{
QOpenGLContext *ctx = QOpenGLContext::currentContext();
if (!ctx) {
qWarning() << Q_FUNC_INFO << "requires an OpenGL context";
return nullptr;
}
const QAbstractTexture::Target actualTarget = m_properties.target;
if (actualTarget == QAbstractTexture::TargetAutomatic) {
// If the target is automatic at this point, it means that the texture
// hasn't been loaded yet (case of remote urls) and that loading failed
// and that target format couldn't be deduced
return nullptr;
}
QOpenGLTexture* glTex = new QOpenGLTexture(static_cast<QOpenGLTexture::Target>(actualTarget));
// m_format may not be ES2 compatible. Now it's time to convert it, if necessary.
QAbstractTexture::TextureFormat format = m_properties.format;
if (ctx->isOpenGLES() && ctx->format().majorVersion() < 3) {
switch (m_properties.format) {
case QAbstractTexture::RGBA8_UNorm:
case QAbstractTexture::RGBAFormat:
format = QAbstractTexture::RGBAFormat;
break;
case QAbstractTexture::RGB8_UNorm:
case QAbstractTexture::RGBFormat:
format = QAbstractTexture::RGBFormat;
break;
case QAbstractTexture::DepthFormat:
format = QAbstractTexture::DepthFormat;
break;
default:
auto warning = qWarning();
warning << "Could not find a matching OpenGL ES 2.0 texture format:";
QtDebugUtils::formatQEnum(warning, m_properties.format);
break;
}
}
// Map ETC1 to ETC2 when supported. This allows using features like
// immutable storage as ETC2 is standard in GLES 3.0, while the ETC1 extension
// is written against GLES 1.0.
if (m_properties.format == QAbstractTexture::RGB8_ETC1) {
if ((ctx->isOpenGLES() && ctx->format().majorVersion() >= 3)
|| ctx->hasExtension(QByteArrayLiteral("GL_OES_compressed_ETC2_RGB8_texture"))
|| ctx->hasExtension(QByteArrayLiteral("GL_ARB_ES3_compatibility")))
format = m_properties.format = QAbstractTexture::RGB8_ETC2;
}
glTex->setFormat(m_properties.format == QAbstractTexture::Automatic ?
QOpenGLTexture::NoFormat :
static_cast<QOpenGLTexture::TextureFormat>(format));
glTex->setSize(m_properties.width, m_properties.height, m_properties.depth);
// Set layers count if texture array
if (actualTarget == QAbstractTexture::Target1DArray ||
actualTarget == QAbstractTexture::Target2DArray ||
actualTarget == QAbstractTexture::Target2DMultisampleArray ||
actualTarget == QAbstractTexture::TargetCubeMapArray) {
glTex->setLayers(m_properties.layers);
}
if (actualTarget == QAbstractTexture::Target2DMultisample ||
actualTarget == QAbstractTexture::Target2DMultisampleArray) {
// Set samples count if multisampled texture
// (multisampled textures don't have mipmaps)
glTex->setSamples(m_properties.samples);
} else if (m_properties.generateMipMaps) {
glTex->setMipLevels(glTex->maximumMipLevels());
} else {
glTex->setAutoMipMapGenerationEnabled(false);
if (glTex->hasFeature(QOpenGLTexture::TextureMipMapLevel)) {
glTex->setMipBaseLevel(0);
glTex->setMipMaxLevel(m_properties.mipLevels - 1);
}
glTex->setMipLevels(m_properties.mipLevels);
}
if (!glTex->create()) {
qWarning() << Q_FUNC_INFO << "creating QOpenGLTexture failed";
return nullptr;
}
return glTex;
}
void GLTexture::uploadGLTextureData()
{
// Upload all QTexImageData set by the QTextureGenerator
if (m_textureData) {
const QList<QTextureImageDataPtr> imgData = m_textureData->imageData();
for (const QTextureImageDataPtr &data : imgData) {
const int mipLevels = m_properties.generateMipMaps ? 1 : data->mipLevels();
for (int layer = 0; layer < data->layers(); layer++) {
for (int face = 0; face < data->faces(); face++) {
for (int level = 0; level < mipLevels; level++) {
// ensure we don't accidentally cause a detach / copy of the raw bytes
const QByteArray bytes(data->data(layer, face, level));
uploadGLData(m_gl, level, layer,
static_cast<QOpenGLTexture::CubeMapFace>(QOpenGLTexture::CubeMapPositiveX + face),
bytes, data);
}
}
}
}
}
// Upload all QTexImageData references by the TextureImages
for (size_t i = 0; i < std::min(m_images.size(), m_imageData.size()); i++) {
const QTextureImageDataPtr &imgData = m_imageData.at(i);
// Here the bytes in the QTextureImageData contain data for a single
// layer, face or mip level, unlike the QTextureGenerator case where
// they are in a single blob. Hence QTextureImageData::data() is not suitable.
const QByteArray bytes(QTextureImageDataPrivate::get(imgData.get())->m_data);
uploadGLData(m_gl, m_images[i].mipLevel, m_images[i].layer,
static_cast<QOpenGLTexture::CubeMapFace>(m_images[i].face),
bytes, imgData);
}
// Free up image data once content has been uploaded
// Note: if data functor stores the data, this won't really free anything though
m_imageData.clear();
// Update data from TextureUpdates
const std::vector<QTextureDataUpdate> textureDataUpdates = Qt3DCore::moveAndClear(m_pendingTextureDataUpdates);
for (const QTextureDataUpdate &update : textureDataUpdates) {
const QTextureImageDataPtr imgData = update.data();
if (!imgData) {
qWarning() << Q_FUNC_INFO << "QTextureDataUpdate no QTextureImageData set";
continue;
}
const int xOffset = update.x();
const int yOffset = update.y();
const int zOffset = update.z();
const int xExtent = xOffset + imgData->width();
const int yExtent = yOffset + imgData->height();
const int zExtent = zOffset + imgData->depth();
// Check update is compatible with our texture
if (xOffset >= m_gl->width() ||
yOffset >= m_gl->height() ||
zOffset >= m_gl->depth() ||
xExtent > m_gl->width() ||
yExtent > m_gl->height() ||
zExtent > m_gl->depth() ||
update.mipLevel() >= m_gl->mipLevels() ||
update.layer() >= m_gl->layers()) {
qWarning() << Q_FUNC_INFO << "QTextureDataUpdate incompatible with texture";
continue;
}
const QByteArray bytes = (QTextureImageDataPrivate::get(imgData.get())->m_data);
// Here the bytes in the QTextureImageData contain data for a single
// layer, face or mip level, unlike the QTextureGenerator case where
// they are in a single blob. Hence QTextureImageData::data() is not suitable.
// Check if this is a full sized update
if (xOffset == 0 &&
yOffset == 0 &&
zOffset == 0 &&
xExtent == m_gl->width() &&
yExtent == m_gl->height() &&
zExtent == m_gl->depth()) {
uploadGLData(m_gl, update.mipLevel(), update.layer(),
static_cast<QOpenGLTexture::CubeMapFace>(update.face()),
bytes, imgData);
} else {
if (imgData->isCompressed()) {
qWarning() << Q_FUNC_INFO << "Uploading non full sized Compressed Data not supported yet";
} else {
uploadGLData(m_gl,
update.mipLevel(), update.layer(),
static_cast<QOpenGLTexture::CubeMapFace>(update.face()),
xOffset, yOffset, zOffset,
bytes, imgData);
}
}
}
}
void GLTexture::updateGLTextureParameters()
{
const QAbstractTexture::Target actualTarget = m_properties.target;
const bool isMultisampledTexture = (actualTarget == QAbstractTexture::Target2DMultisample ||
actualTarget == QAbstractTexture::Target2DMultisampleArray);
// Multisampled textures can only be accessed by texelFetch in shaders
// and don't support wrap modes and mig/mag filtes
if (isMultisampledTexture)
return;
m_gl->setWrapMode(QOpenGLTexture::DirectionS, static_cast<QOpenGLTexture::WrapMode>(m_parameters.wrapModeX));
if (actualTarget != QAbstractTexture::Target1D &&
actualTarget != QAbstractTexture::Target1DArray &&
actualTarget != QAbstractTexture::TargetBuffer)
m_gl->setWrapMode(QOpenGLTexture::DirectionT, static_cast<QOpenGLTexture::WrapMode>(m_parameters.wrapModeY));
if (actualTarget == QAbstractTexture::Target3D)
m_gl->setWrapMode(QOpenGLTexture::DirectionR, static_cast<QOpenGLTexture::WrapMode>(m_parameters.wrapModeZ));
m_gl->setMinMagFilters(static_cast<QOpenGLTexture::Filter>(m_parameters.minificationFilter),
static_cast<QOpenGLTexture::Filter>(m_parameters.magnificationFilter));
if (m_gl->hasFeature(QOpenGLTexture::AnisotropicFiltering))
m_gl->setMaximumAnisotropy(m_parameters.maximumAnisotropy);
if (m_gl->hasFeature(QOpenGLTexture::TextureComparisonOperators)) {
m_gl->setComparisonFunction(static_cast<QOpenGLTexture::ComparisonFunction>(m_parameters.comparisonFunction));
m_gl->setComparisonMode(static_cast<QOpenGLTexture::ComparisonMode>(m_parameters.comparisonMode));
}
}
void GLTexture::introspectPropertiesFromSharedTextureId()
{
// We know that the context is active when this function is called
QOpenGLContext *ctx = QOpenGLContext::currentContext();
if (!ctx) {
qWarning() << Q_FUNC_INFO << "requires an OpenGL context";
return;
}
QOpenGLFunctions *gl = ctx->functions();
// If the user has set the target format himself, we won't try to deduce it
if (m_properties.target != QAbstractTexture::TargetAutomatic)
return;
const QAbstractTexture::Target targets[] = {
QAbstractTexture::Target2D,
QAbstractTexture::TargetCubeMap,
#if !QT_CONFIG(opengles2)
QAbstractTexture::Target1D,
QAbstractTexture::Target1DArray,
QAbstractTexture::Target3D,
QAbstractTexture::Target2DArray,
QAbstractTexture::TargetCubeMapArray,
QAbstractTexture::Target2DMultisample,
QAbstractTexture::Target2DMultisampleArray,
QAbstractTexture::TargetRectangle,
QAbstractTexture::TargetBuffer,
#endif
};
#if !QT_CONFIG(opengles2)
// Try to find texture target with GL 4.5 functions
const QPair<int, int> ctxGLVersion = ctx->format().version();
if (ctxGLVersion.first > 4 || (ctxGLVersion.first == 4 && ctxGLVersion.second >= 5)) {
// Only for GL 4.5+
#ifdef GL_TEXTURE_TARGET
QOpenGLFunctions_4_5_Core *gl5 = QOpenGLVersionFunctionsFactory::get<QOpenGLFunctions_4_5_Core>();
if (gl5 != nullptr)
gl5->glGetTextureParameteriv(m_sharedTextureId, GL_TEXTURE_TARGET, reinterpret_cast<int *>(&m_properties.target));
#endif
}
#endif
// If GL 4.5 function unavailable or not working, try a slower way
if (m_properties.target == QAbstractTexture::TargetAutomatic) {
// // OpenGL offers no proper way of querying for the target of a texture given its id
gl->glActiveTexture(GL_TEXTURE0);
const GLenum targetBindings[] = {
GL_TEXTURE_BINDING_2D,
GL_TEXTURE_BINDING_CUBE_MAP,
#if !QT_CONFIG(opengles2)
GL_TEXTURE_BINDING_1D,
GL_TEXTURE_BINDING_1D_ARRAY,
GL_TEXTURE_BINDING_3D,
GL_TEXTURE_BINDING_2D_ARRAY,
GL_TEXTURE_BINDING_CUBE_MAP_ARRAY,
GL_TEXTURE_BINDING_2D_MULTISAMPLE,
GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY,
GL_TEXTURE_BINDING_RECTANGLE,
GL_TEXTURE_BINDING_BUFFER
#endif
};
Q_STATIC_ASSERT(sizeof(targetBindings) / sizeof(targetBindings[0]) == sizeof(targets) / sizeof(targets[0]));
for (uint i = 0; i < sizeof(targetBindings) / sizeof(targetBindings[0]); ++i) {
const int target = targets[i];
gl->glBindTexture(target, m_sharedTextureId);
int boundId = 0;
gl->glGetIntegerv(targetBindings[i], &boundId);
gl->glBindTexture(target, 0);
if (boundId == m_sharedTextureId) {
m_properties.target = static_cast<QAbstractTexture::Target>(target);
break;
}
}
}
// Return early if we weren't able to find texture target
if (std::find(std::begin(targets), std::end(targets), m_properties.target) == std::end(targets)) {
qWarning() << "Unable to determine texture target for shared GL texture";
return;
}
// Bind texture once we know its target
gl->glBindTexture(m_properties.target, m_sharedTextureId);
// TO DO: Improve by using glGetTextureParameters when available which
// support direct state access
#ifndef GL_TEXTURE_MAX_LEVEL
#define GL_TEXTURE_MAX_LEVEL 0x813D
#endif
#ifndef GL_TEXTURE_WRAP_R
#define GL_TEXTURE_WRAP_R 0x8072
#endif
gl->glGetTexParameteriv(int(m_properties.target), GL_TEXTURE_MAX_LEVEL, reinterpret_cast<int *>(&m_properties.mipLevels));
gl->glGetTexParameteriv(int(m_properties.target), GL_TEXTURE_MIN_FILTER, reinterpret_cast<int *>(&m_parameters.minificationFilter));
gl->glGetTexParameteriv(int(m_properties.target), GL_TEXTURE_MAG_FILTER, reinterpret_cast<int *>(&m_parameters.magnificationFilter));
gl->glGetTexParameteriv(int(m_properties.target), GL_TEXTURE_WRAP_R, reinterpret_cast<int *>(&m_parameters.wrapModeX));
gl->glGetTexParameteriv(int(m_properties.target), GL_TEXTURE_WRAP_S, reinterpret_cast<int *>(&m_parameters.wrapModeY));
gl->glGetTexParameteriv(int(m_properties.target), GL_TEXTURE_WRAP_T, reinterpret_cast<int *>(&m_parameters.wrapModeZ));
#if !QT_CONFIG(opengles2)
// Try to retrieve dimensions (not available on ES 2.0)
if (!ctx->isOpenGLES()) {
QOpenGLFunctions_3_1 *gl3 = QOpenGLVersionFunctionsFactory::get<QOpenGLFunctions_3_1>();
if (!gl3) {
qWarning() << "Failed to retrieve shared texture dimensions";
return;
}
gl3->glGetTexLevelParameteriv(int(m_properties.target), 0, GL_TEXTURE_WIDTH, reinterpret_cast<int *>(&m_properties.width));
gl3->glGetTexLevelParameteriv(int(m_properties.target), 0, GL_TEXTURE_HEIGHT, reinterpret_cast<int *>(&m_properties.height));
gl3->glGetTexLevelParameteriv(int(m_properties.target), 0, GL_TEXTURE_DEPTH, reinterpret_cast<int *>(&m_properties.depth));
gl3->glGetTexLevelParameteriv(int(m_properties.target), 0, GL_TEXTURE_INTERNAL_FORMAT, reinterpret_cast<int *>(&m_properties.format));
}
#endif
gl->glBindTexture(m_properties.target, 0);
}
} // namespace OpenGL
} // namespace Render
} // namespace Qt3DRender
QT_END_NAMESPACE