Revision control
Copy as Markdown
// Copyright (C) 2020 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 "texture_p.h"
#include <private/qdebug_p.h>
#include <rhi/qrhi.h>
#include <QDebug>
#include <Qt3DCore/private/vector_helper_p.h>
#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 <submissioncontext_p.h>
QT_BEGIN_NAMESPACE
namespace Qt3DRender {
namespace Render {
namespace Rhi {
namespace {
bool issRGBFormat(QAbstractTexture::TextureFormat format) noexcept
{
switch (format) {
case QAbstractTexture::SRGB8:
case QAbstractTexture::SRGB8_ETC2:
case QAbstractTexture::SRGB8_PunchThrough_Alpha1_ETC2:
return true;
default:
return false;
}
}
QRhiTexture::Format rhiFormatFromTextureFormat(QAbstractTexture::TextureFormat format) noexcept
{
switch (format) {
case QAbstractTexture::RGBA8_UNorm:
case QAbstractTexture::RGBAFormat:
case QAbstractTexture::SRGB8_Alpha8:
case QAbstractTexture::SRGB8:
return QRhiTexture::RGBA8;
case QAbstractTexture::R8_UNorm:
return QRhiTexture::R8;
case QAbstractTexture::R16_UNorm:
return QRhiTexture::R16;
case QAbstractTexture::RGBA16F:
return QRhiTexture::RGBA16F;
case QAbstractTexture::RGBA32F:
return QRhiTexture::RGBA32F;
case QAbstractTexture::R16F:
return QRhiTexture::R16F;
case QAbstractTexture::R32F:
return QRhiTexture::R32F;
case QAbstractTexture::D16:
return QRhiTexture::D16;
case QAbstractTexture::D24:
return QRhiTexture::D24;
case QAbstractTexture::D24S8:
return QRhiTexture::D24S8;
case QAbstractTexture::D32F:
return QRhiTexture::D32F;
case QAbstractTexture::RGB_DXT1:
case QAbstractTexture::RGBA_DXT1:
return QRhiTexture::BC1;
case QAbstractTexture::RGBA_DXT3:
return QRhiTexture::BC2;
case QAbstractTexture::RGBA_DXT5:
return QRhiTexture::BC3;
case QAbstractTexture::RGB8_ETC2:
case QAbstractTexture::SRGB8_ETC2:
return QRhiTexture::ETC2_RGB8;
case QAbstractTexture::RGB8_PunchThrough_Alpha1_ETC2:
case QAbstractTexture::SRGB8_PunchThrough_Alpha1_ETC2:
return QRhiTexture::ETC2_RGB8A1;
case QAbstractTexture::RGBA8_ETC2_EAC:
return QRhiTexture::ETC2_RGBA8;
case QAbstractTexture::DepthFormat:
return QRhiTexture::D24;
default:
qDebug() << "Unhandled texture format:" << format;
Q_UNREACHABLE_RETURN(QRhiTexture::UnknownFormat);
}
}
QRhiSampler::Filter rhiFilterFromTextureFilter(QAbstractTexture::Filter filter) noexcept
{
switch (filter) {
case QAbstractTexture::Nearest:
case QAbstractTexture::NearestMipMapNearest:
case QAbstractTexture::NearestMipMapLinear:
return QRhiSampler::Nearest;
case QAbstractTexture::Linear:
case QAbstractTexture::LinearMipMapNearest:
case QAbstractTexture::LinearMipMapLinear:
return QRhiSampler::Linear;
default:
Q_UNREACHABLE_RETURN(QRhiSampler::Nearest);
}
}
QRhiSampler::Filter rhiMipMapFilterFromTextureFilter(QAbstractTexture::Filter filter) noexcept
{
switch (filter) {
case QAbstractTexture::Nearest:
case QAbstractTexture::Linear:
return QRhiSampler::None;
case QAbstractTexture::NearestMipMapNearest:
case QAbstractTexture::LinearMipMapNearest:
return QRhiSampler::Nearest;
case QAbstractTexture::NearestMipMapLinear:
case QAbstractTexture::LinearMipMapLinear:
return QRhiSampler::Linear;
default:
Q_UNREACHABLE_RETURN(QRhiSampler::None);
}
}
std::tuple<QRhiSampler::AddressMode, QRhiSampler::AddressMode, QRhiSampler::AddressMode>
rhiWrapModeFromTextureWrapMode(QTextureWrapMode::WrapMode x, QTextureWrapMode::WrapMode y,
QTextureWrapMode::WrapMode z) noexcept
{
auto toRhiAddress = [](QTextureWrapMode::WrapMode mode) noexcept {
switch (mode) {
case Qt3DRender::QTextureWrapMode::Repeat:
return QRhiSampler::Repeat;
case Qt3DRender::QTextureWrapMode::ClampToEdge:
case Qt3DRender::QTextureWrapMode::ClampToBorder:
return QRhiSampler::ClampToEdge;
case Qt3DRender::QTextureWrapMode::MirroredRepeat:
return QRhiSampler::Mirror;
default:
Q_UNREACHABLE();
}
};
return { toRhiAddress(x), toRhiAddress(y), toRhiAddress(z) };
}
QRhiSampler::CompareOp
rhiCompareOpFromTextureCompareOp(QAbstractTexture::ComparisonFunction mode) noexcept
{
switch (mode) {
case QAbstractTexture::CompareLessEqual:
return QRhiSampler::LessOrEqual;
case QAbstractTexture::CompareGreaterEqual:
return QRhiSampler::GreaterOrEqual;
case QAbstractTexture::CompareLess:
return QRhiSampler::Less;
case QAbstractTexture::CompareGreater:
return QRhiSampler::Greater;
case QAbstractTexture::CompareEqual:
return QRhiSampler::Equal;
case QAbstractTexture::CommpareNotEqual:
return QRhiSampler::NotEqual;
case QAbstractTexture::CompareAlways:
return QRhiSampler::Always;
case QAbstractTexture::CompareNever:
return QRhiSampler::Never;
default:
return QRhiSampler::Always;
}
}
// This uploadGLData where the data is a fullsize subimage
// as QOpenGLTexture doesn't allow partial subimage uploads
QRhiTextureUploadEntry createUploadEntry(int level, int layer, const QByteArray &bytes) noexcept
{
QRhiTextureSubresourceUploadDescription description;
description.setData(bytes);
return QRhiTextureUploadEntry(layer, level, description);
}
// For Multiple Texture Image uploads from within a QTextureImageData
template<typename F>
void filterLayersAndFaces(const QTextureImageData &data, F f)
{
const int layers = data.layers();
const int faces = data.faces();
const int miplevels = data.mipLevels();
if (layers == 1 && faces == 1) {
for (int level = 0; level < miplevels; level++) {
f(createUploadEntry(level, 0, data.data(0, 0, level)));
}
} else if (layers > 1 && faces == 1) {
for (int layer = 0; layer < data.layers(); layer++) {
for (int level = 0; level < miplevels; level++) {
f(createUploadEntry(level, layer, data.data(layer, 0, level)));
}
}
} else if (faces > 1 && layers == 1) {
// Mip levels do not seem to be supported by cubemaps...
for (int face = 0; face < data.faces(); face++) {
f(createUploadEntry(0, face, data.data(0, face, 0)));
}
} else {
qWarning() << Q_FUNC_INFO << "Unsupported case";
}
}
// For a Single Texture Image Upload
template<typename F>
void filterLayerAndFace(int layer, int face, F f)
{
if (layer == 0 && face == 0) {
f(0);
} else if (layer > 0 && face == 0) {
f(layer);
} else if (layer == 0 && face > 0) {
f(face);
} else {
qWarning() << Q_FUNC_INFO << "Unsupported case";
}
}
// For partial sub image uploads
QRhiTextureUploadEntry createUploadEntry(int mipLevel, int layer, int xOffset, int yOffset,
int zOffset, const QByteArray &bytes,
const QTextureImageDataPtr &data) noexcept
{
Q_UNUSED(zOffset);
Q_UNUSED(data);
QRhiTextureSubresourceUploadDescription description;
description.setData(bytes);
description.setSourceTopLeft(QPoint(xOffset, yOffset));
return QRhiTextureUploadEntry(layer, mipLevel, description);
}
} // anonymous
RHITexture::RHITexture()
: m_dirtyFlags(None),
m_rhi(nullptr),
m_rhiSampler(nullptr),
m_renderBuffer(nullptr),
m_dataFunctor(),
m_pendingDataFunctor(nullptr),
m_sharedTextureId(-1),
m_externalRendering(false),
m_wasTextureRecreated(false)
{
}
RHITexture::~RHITexture() { }
// Must be called from RenderThread with active GL context
void RHITexture::destroy()
{
if (m_rhi)
m_rhi->destroy();
delete m_rhi;
m_rhi = nullptr;
if (m_rhiSampler)
m_rhiSampler->destroy();
delete m_rhiSampler;
m_rhiSampler = 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 RHITexture::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.empty()) {
// 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 RHITexture::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
RHITexture::TextureUpdateInfo RHITexture::createOrUpdateRhiTexture(SubmissionContext *ctx)
{
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::RHITexture] 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)) {
if (m_rhi)
m_rhi->destroy();
delete m_rhi;
m_rhi = 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_rhi) {
m_rhi = buildRhiTexture(ctx);
if (!m_rhi) {
qWarning() << "[Qt3DRender::RHITexture] failed to create texture";
textureInfo.properties.status = QAbstractTexture::Error;
return textureInfo;
}
m_wasTextureRecreated = true;
}
textureInfo.texture = m_rhi;
// need to (re-)upload texture data?
const bool needsUpload = testDirtyFlag(TextureData);
if (needsUpload) {
uploadRhiTextureData(ctx);
setDirtyFlag(TextureData, false);
}
// need to set texture parameters?
if (testDirtyFlag(Properties) || testDirtyFlag(Parameters)) {
updateRhiTextureParameters(ctx);
setDirtyFlag(Properties, false);
setDirtyFlag(Parameters, false);
}
}
textureInfo.properties = m_properties;
return textureInfo;
}
RenderBuffer *RHITexture::getOrCreateRenderBuffer()
{
if (m_dataFunctor && !m_textureData) {
m_textureData = m_dataFunctor->operator()();
if (m_textureData) {
if (m_properties.target != QAbstractTexture::TargetAutomatic)
qWarning() << "[Qt3DRender::RHITexture] [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::RHITexture] [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 RHITexture release from the manager can only be done from that thread
void RHITexture::cleanup()
{
destroy();
}
void RHITexture::setParameters(const TextureParameters ¶ms)
{
if (m_parameters != params) {
m_parameters = params;
setDirtyFlag(Parameters);
}
}
void RHITexture::setProperties(const TextureProperties &props)
{
if (m_properties != props) {
m_properties = props;
setDirtyFlag(Properties);
}
}
void RHITexture::setImages(const std::vector<Image> &images)
{
// check if something has changed at all
bool same = (images.size() == m_images.size());
if (same) {
for (size_t i = 0; i < images.size(); i++) {
if (images[i] != m_images[i]) {
same = false;
break;
}
}
}
if (!same) {
m_images = images;
requestImageUpload();
}
}
void RHITexture::setGenerator(const QTextureGeneratorPtr &generator)
{
m_textureData.reset();
m_dataFunctor = generator;
m_pendingDataFunctor = nullptr;
requestUpload();
}
void RHITexture::setSharedTextureId(int textureId)
{
if (m_sharedTextureId != textureId) {
m_sharedTextureId = textureId;
setDirtyFlag(SharedTextureId);
}
}
void RHITexture::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
QRhiTexture *RHITexture::buildRhiTexture(SubmissionContext *ctx)
{
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;
}
const QRhiTexture::Format rhiFormat = rhiFormatFromTextureFormat(m_properties.format);
const QSize pixelSize(m_properties.width, m_properties.height);
QRhiTexture::Flags rhiFlags {};
int sampleCount = 1;
const bool issRGB8Format = issRGBFormat(m_properties.format);
if (issRGB8Format)
rhiFlags |= QRhiTexture::sRGB;
if (actualTarget == QAbstractTexture::Target2DMultisample
|| actualTarget == QAbstractTexture::Target2DMultisampleArray) {
// Set samples count if multisampled texture
// (multisampled textures don't have mipmaps)
sampleCount = m_properties.samples;
}
switch (actualTarget) {
case QAbstractTexture::TargetCubeMap:
case QAbstractTexture::TargetCubeMapArray: {
rhiFlags |= QRhiTexture::CubeMap;
break;
}
default: {
// Mipmaps don't see to work with cubemaps at the moment
if (m_properties.generateMipMaps) {
rhiFlags |= QRhiTexture::UsedWithGenerateMips;
rhiFlags |= QRhiTexture::MipMapped;
} else if (m_properties.mipLevels > 1) {
rhiFlags |= QRhiTexture::MipMapped;
}
break;
}
}
if(actualTarget == QAbstractTexture::Target3D)
rhiFlags |= QRhiTexture::ThreeDimensional;
QRhiTexture *rhiTexture = nullptr;
switch (m_properties.target) {
case QAbstractTexture::Target1DArray:
case QAbstractTexture::Target2DArray:
//This will setup the array flags correctly
rhiTexture = ctx->rhi()->newTextureArray(rhiFormat, m_properties.layers, pixelSize, sampleCount, rhiFlags);
break;
default:
rhiTexture = ctx->rhi()->newTexture(rhiFormat, pixelSize, sampleCount, rhiFlags);
break;
}
if (!rhiTexture->create()) {
qWarning() << Q_FUNC_INFO << "creating QRhiTexture failed";
delete rhiTexture;
return nullptr;
}
return rhiTexture;
}
void RHITexture::uploadRhiTextureData(SubmissionContext *ctx)
{
QVarLengthArray<QRhiTextureUploadEntry> uploadEntries;
// Upload all QTexImageData set by the QTextureGenerator
if (m_textureData) {
const auto &imgData = m_textureData->imageData();
for (const QTextureImageDataPtr &data : imgData) {
const int mipLevels = data->mipLevels();
Q_ASSERT(mipLevels <= ctx->rhi()->mipLevelsForSize({ data->width(), data->height() }));
filterLayersAndFaces(*data, [&](QRhiTextureUploadEntry &&entry) {
uploadEntries.push_back(std::move(entry));
});
}
}
// 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);
// Find RHI face index for matching face enum
// Note: Default value for face on a QAbstractTextureImage is
// CubeMapPositiveX which results in index 0, therefore we don't need
// special handling for CubeMap vs 2D textures
const int face = int(m_images[i].face) - QAbstractTexture::CubeMapPositiveX;
const int layer = m_images[i].layer;
filterLayerAndFace(layer, face, [&](int rhiLayer) {
uploadEntries.push_back(createUploadEntry(m_images[i].mipLevel, rhiLayer, bytes));
});
}
// 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;
}
// TO DO: There's currently no way to check the depth of an existing QRhiTexture
const int xOffset = update.x();
const int yOffset = update.y();
const int xExtent = xOffset + imgData->width();
const int yExtent = yOffset + imgData->height();
// Check update is compatible with our texture
if (xOffset >= m_rhi->pixelSize().width() || yOffset >= m_rhi->pixelSize().height()
|| xExtent > m_rhi->pixelSize().width() || yExtent > m_rhi->pixelSize().height()) {
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.
const int layer = update.layer();
const int face = int(update.face()) - QAbstractTexture::CubeMapPositiveX;
filterLayerAndFace(layer, face, [&](int rhiLayer) {
const QRhiTextureUploadEntry entry = createUploadEntry(
update.mipLevel(), rhiLayer, xOffset, yOffset, 0, bytes, imgData);
uploadEntries.push_back(entry);
});
}
if (!uploadEntries.empty()) {
QRhiTextureUploadDescription uploadDescription;
uploadDescription.setEntries(uploadEntries.begin(), uploadEntries.end());
ctx->m_currentUpdates->uploadTexture(m_rhi, uploadDescription);
}
if (m_properties.generateMipMaps)
ctx->m_currentUpdates->generateMips(m_rhi);
}
void RHITexture::updateRhiTextureParameters(SubmissionContext *ctx)
{
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 filters
// TO DO:
if (m_rhiSampler) {
m_rhiSampler->destroy();
delete m_rhiSampler;
m_rhiSampler = nullptr;
}
const QRhiSampler::Filter magFilter = isMultisampledTexture ?
QRhiSampler::Linear :
rhiFilterFromTextureFilter(m_parameters.magnificationFilter);
const QRhiSampler::Filter minFilter = isMultisampledTexture ?
QRhiSampler::Linear :
rhiFilterFromTextureFilter(m_parameters.minificationFilter);
const QRhiSampler::Filter mipMapFilter = isMultisampledTexture ?
QRhiSampler::None :
rhiMipMapFilterFromTextureFilter(m_parameters.magnificationFilter);
const auto wrapMode = isMultisampledTexture ?
std::make_tuple(QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge) :
rhiWrapModeFromTextureWrapMode(
m_parameters.wrapModeX, m_parameters.wrapModeY, m_parameters.wrapModeZ);
const QRhiSampler::CompareOp compareOp
= m_parameters.comparisonMode == QAbstractTexture::CompareNone
? QRhiSampler::CompareOp::Never
: rhiCompareOpFromTextureCompareOp(m_parameters.comparisonFunction);
m_rhiSampler = ctx->rhi()->newSampler(magFilter, minFilter, mipMapFilter, std::get<0>(wrapMode),
std::get<1>(wrapMode), std::get<2>(wrapMode));
m_rhiSampler->setTextureCompareOp(compareOp);
if (!m_rhiSampler->create()) {
qWarning("Could not build RHI texture sampler");
}
}
void RHITexture::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,
//#ifndef QT_OPENGL_ES_2
// QAbstractTexture::Target1D,
// QAbstractTexture::Target1DArray,
// QAbstractTexture::Target3D,
// QAbstractTexture::Target2DArray,
// QAbstractTexture::TargetCubeMapArray,
// QAbstractTexture::Target2DMultisample,
// QAbstractTexture::Target2DMultisampleArray,
// QAbstractTexture::TargetRectangle,
// QAbstractTexture::TargetBuffer,
//#endif
// };
//#ifndef QT_OPENGL_ES_2
// // 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 = ctx->versionFunctions<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,
//#ifndef QT_OPENGL_ES_2
// 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_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));
//#ifndef QT_OPENGL_ES_2
// // Try to retrieve dimensions (not available on ES 2.0)
// if (!ctx->isOpenGLES()) {
// QOpenGLFunctions_3_1 *gl3 = ctx->versionFunctions<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 Rhi
} // namespace Render
} // namespace Qt3DRender
QT_END_NAMESPACE