File: C:/Users/fred/anaconda3/Library/include/qt/QtGui/5.15.2/QtGui/private/qrhigles2_p_p.h
/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the Qt Gui module
**
** $QT_BEGIN_LICENSE:LGPL3$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPLv3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or later as published by the Free
** Software Foundation and appearing in the file LICENSE.GPL included in
** the packaging of this file. Please review the following information to
** ensure the GNU General Public License version 2.0 requirements will be
** met: http://www.gnu.org/licenses/gpl-2.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QRHIGLES2_P_H
#define QRHIGLES2_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include "qrhigles2_p.h"
#include "qrhi_p_p.h"
#include "qshaderdescription_p.h"
#include <qopengl.h>
#include <QSurface>
QT_BEGIN_NAMESPACE
class QOpenGLExtensions;
struct QGles2Buffer : public QRhiBuffer
{
QGles2Buffer(QRhiImplementation *rhi, Type type, UsageFlags usage, int size);
~QGles2Buffer();
void release() override;
bool build() override;
QRhiBuffer::NativeBuffer nativeBuffer() override;
GLuint buffer = 0;
GLenum targetForDataOps;
QByteArray ubuf;
enum Access {
AccessNone,
AccessVertex,
AccessIndex,
AccessUniform,
AccessStorageRead,
AccessStorageWrite,
AccessStorageReadWrite,
AccessUpdate
};
struct UsageState {
Access access;
};
UsageState usageState;
friend class QRhiGles2;
};
struct QGles2RenderBuffer : public QRhiRenderBuffer
{
QGles2RenderBuffer(QRhiImplementation *rhi, Type type, const QSize &pixelSize,
int sampleCount, QRhiRenderBuffer::Flags flags);
~QGles2RenderBuffer();
void release() override;
bool build() override;
QRhiTexture::Format backingFormat() const override;
GLuint renderbuffer = 0;
GLuint stencilRenderbuffer = 0; // when packed depth-stencil not supported
int samples;
friend class QRhiGles2;
};
struct QGles2SamplerData
{
GLenum glminfilter = 0;
GLenum glmagfilter = 0;
GLenum glwraps = 0;
GLenum glwrapt = 0;
GLenum glwrapr = 0;
GLenum gltexcomparefunc = 0;
};
inline bool operator==(const QGles2SamplerData &a, const QGles2SamplerData &b)
{
return a.glminfilter == b.glminfilter
&& a.glmagfilter == b.glmagfilter
&& a.glwraps == b.glwraps
&& a.glwrapt == b.glwrapt
&& a.glwrapr == b.glwrapr
&& a.gltexcomparefunc == b.gltexcomparefunc;
}
inline bool operator!=(const QGles2SamplerData &a, const QGles2SamplerData &b)
{
return !(a == b);
}
struct QGles2Texture : public QRhiTexture
{
QGles2Texture(QRhiImplementation *rhi, Format format, const QSize &pixelSize,
int sampleCount, Flags flags);
~QGles2Texture();
void release() override;
bool build() override;
bool buildFrom(NativeTexture src) override;
NativeTexture nativeTexture() override;
bool prepareBuild(QSize *adjustedSize = nullptr);
GLuint texture = 0;
bool owns = true;
GLenum target;
GLenum glintformat;
GLenum glsizedintformat;
GLenum glformat;
GLenum gltype;
QGles2SamplerData samplerState;
bool specified = false;
int mipLevelCount = 0;
enum Access {
AccessNone,
AccessSample,
AccessFramebuffer,
AccessStorageRead,
AccessStorageWrite,
AccessStorageReadWrite,
AccessUpdate,
AccessRead
};
struct UsageState {
Access access;
};
UsageState usageState;
uint generation = 0;
friend class QRhiGles2;
};
struct QGles2Sampler : public QRhiSampler
{
QGles2Sampler(QRhiImplementation *rhi, Filter magFilter, Filter minFilter, Filter mipmapMode,
AddressMode u, AddressMode v, AddressMode w);
~QGles2Sampler();
void release() override;
bool build() override;
QGles2SamplerData d;
uint generation = 0;
friend class QRhiGles2;
};
struct QGles2RenderPassDescriptor : public QRhiRenderPassDescriptor
{
QGles2RenderPassDescriptor(QRhiImplementation *rhi);
~QGles2RenderPassDescriptor();
void release() override;
bool isCompatible(const QRhiRenderPassDescriptor *other) const override;
};
struct QGles2RenderTargetData
{
QGles2RenderTargetData(QRhiImplementation *) { }
QGles2RenderPassDescriptor *rp = nullptr;
QSize pixelSize;
float dpr = 1;
int sampleCount = 1;
int colorAttCount = 0;
int dsAttCount = 0;
bool srgbUpdateAndBlend = false;
};
struct QGles2ReferenceRenderTarget : public QRhiRenderTarget
{
QGles2ReferenceRenderTarget(QRhiImplementation *rhi);
~QGles2ReferenceRenderTarget();
void release() override;
QSize pixelSize() const override;
float devicePixelRatio() const override;
int sampleCount() const override;
QGles2RenderTargetData d;
};
struct QGles2TextureRenderTarget : public QRhiTextureRenderTarget
{
QGles2TextureRenderTarget(QRhiImplementation *rhi, const QRhiTextureRenderTargetDescription &desc, Flags flags);
~QGles2TextureRenderTarget();
void release() override;
QSize pixelSize() const override;
float devicePixelRatio() const override;
int sampleCount() const override;
QRhiRenderPassDescriptor *newCompatibleRenderPassDescriptor() override;
bool build() override;
QGles2RenderTargetData d;
GLuint framebuffer = 0;
friend class QRhiGles2;
};
struct QGles2ShaderResourceBindings : public QRhiShaderResourceBindings
{
QGles2ShaderResourceBindings(QRhiImplementation *rhi);
~QGles2ShaderResourceBindings();
void release() override;
bool build() override;
uint generation = 0;
friend class QRhiGles2;
};
struct QGles2UniformDescription
{
QShaderDescription::VariableType type;
int glslLocation;
int binding;
uint offset;
int size;
int arrayDim;
};
Q_DECLARE_TYPEINFO(QGles2UniformDescription, Q_MOVABLE_TYPE);
struct QGles2SamplerDescription
{
int glslLocation;
int binding;
};
Q_DECLARE_TYPEINFO(QGles2SamplerDescription, Q_MOVABLE_TYPE);
struct QGles2GraphicsPipeline : public QRhiGraphicsPipeline
{
QGles2GraphicsPipeline(QRhiImplementation *rhi);
~QGles2GraphicsPipeline();
void release() override;
bool build() override;
GLuint program = 0;
GLenum drawMode = GL_TRIANGLES;
QVector<QGles2UniformDescription> uniforms;
QVector<QGles2SamplerDescription> samplers;
uint generation = 0;
friend class QRhiGles2;
};
struct QGles2ComputePipeline : public QRhiComputePipeline
{
QGles2ComputePipeline(QRhiImplementation *rhi);
~QGles2ComputePipeline();
void release() override;
bool build() override;
GLuint program = 0;
QVector<QGles2UniformDescription> uniforms;
QVector<QGles2SamplerDescription> samplers;
uint generation = 0;
friend class QRhiGles2;
};
struct QGles2CommandBuffer : public QRhiCommandBuffer
{
QGles2CommandBuffer(QRhiImplementation *rhi);
~QGles2CommandBuffer();
void release() override;
struct Command {
enum Cmd {
BeginFrame,
EndFrame,
ResetFrame,
Viewport,
Scissor,
BlendConstants,
StencilRef,
BindVertexBuffer,
BindIndexBuffer,
Draw,
DrawIndexed,
BindGraphicsPipeline,
BindShaderResources,
BindFramebuffer,
Clear,
BufferSubData,
GetBufferSubData,
CopyTex,
ReadPixels,
SubImage,
CompressedImage,
CompressedSubImage,
BlitFromRenderbuffer,
GenMip,
BindComputePipeline,
Dispatch,
BarriersForPass,
Barrier
};
Cmd cmd;
static const int MAX_UBUF_BINDINGS = 32; // should be more than enough
// QRhi*/QGles2* references should be kept at minimum (so no
// QRhiTexture/Buffer/etc. pointers).
union {
struct {
float x, y, w, h;
float d0, d1;
} viewport;
struct {
int x, y, w, h;
} scissor;
struct {
float r, g, b, a;
} blendConstants;
struct {
quint32 ref;
QRhiGraphicsPipeline *ps;
} stencilRef;
struct {
QRhiGraphicsPipeline *ps;
GLuint buffer;
quint32 offset;
int binding;
} bindVertexBuffer;
struct {
GLuint buffer;
quint32 offset;
GLenum type;
} bindIndexBuffer;
struct {
QRhiGraphicsPipeline *ps;
quint32 vertexCount;
quint32 firstVertex;
quint32 instanceCount;
quint32 baseInstance;
} draw;
struct {
QRhiGraphicsPipeline *ps;
quint32 indexCount;
quint32 firstIndex;
quint32 instanceCount;
quint32 baseInstance;
qint32 baseVertex;
} drawIndexed;
struct {
QRhiGraphicsPipeline *ps;
} bindGraphicsPipeline;
struct {
QRhiGraphicsPipeline *maybeGraphicsPs;
QRhiComputePipeline *maybeComputePs;
QRhiShaderResourceBindings *srb;
int dynamicOffsetCount;
uint dynamicOffsetPairs[MAX_UBUF_BINDINGS * 2]; // binding, offsetInConstants
} bindShaderResources;
struct {
GLbitfield mask;
float c[4];
float d;
quint32 s;
} clear;
struct {
GLuint fbo;
bool srgb;
int colorAttCount;
} bindFramebuffer;
struct {
GLenum target;
GLuint buffer;
int offset;
int size;
const void *data; // must come from retainData()
} bufferSubData;
struct {
QRhiBufferReadbackResult *result;
GLenum target;
GLuint buffer;
int offset;
int size;
} getBufferSubData;
struct {
GLenum srcFaceTarget;
GLuint srcTexture;
int srcLevel;
int srcX;
int srcY;
GLenum dstTarget;
GLuint dstTexture;
GLenum dstFaceTarget;
int dstLevel;
int dstX;
int dstY;
int w;
int h;
} copyTex;
struct {
QRhiReadbackResult *result;
GLuint texture;
int w;
int h;
QRhiTexture::Format format;
GLenum readTarget;
int level;
} readPixels;
struct {
GLenum target;
GLuint texture;
GLenum faceTarget;
int level;
int dx;
int dy;
int w;
int h;
GLenum glformat;
GLenum gltype;
int rowStartAlign;
const void *data; // must come from retainImage()
} subImage;
struct {
GLenum target;
GLuint texture;
GLenum faceTarget;
int level;
GLenum glintformat;
int w;
int h;
int size;
const void *data; // must come from retainData()
} compressedImage;
struct {
GLenum target;
GLuint texture;
GLenum faceTarget;
int level;
int dx;
int dy;
int w;
int h;
GLenum glintformat;
int size;
const void *data; // must come from retainData()
} compressedSubImage;
struct {
GLuint renderbuffer;
int w;
int h;
GLenum target;
GLuint texture;
int dstLevel;
} blitFromRb;
struct {
GLenum target;
GLuint texture;
} genMip;
struct {
QRhiComputePipeline *ps;
} bindComputePipeline;
struct {
GLuint x;
GLuint y;
GLuint z;
} dispatch;
struct {
int trackerIndex;
} barriersForPass;
struct {
GLbitfield barriers;
} barrier;
} args;
};
enum PassType {
NoPass,
RenderPass,
ComputePass
};
QVector<Command> commands;
QVarLengthArray<QRhiPassResourceTracker, 8> passResTrackers;
int currentPassResTrackerIndex;
PassType recordingPass;
QRhiRenderTarget *currentTarget;
QRhiGraphicsPipeline *currentGraphicsPipeline;
QRhiComputePipeline *currentComputePipeline;
uint currentPipelineGeneration;
QRhiShaderResourceBindings *currentGraphicsSrb;
QRhiShaderResourceBindings *currentComputeSrb;
uint currentSrbGeneration;
struct GraphicsPassState {
bool valid = false;
bool scissor;
bool cullFace;
GLenum cullMode;
GLenum frontFace;
bool blendEnabled;
struct ColorMask { bool r, g, b, a; } colorMask;
struct Blend {
GLenum srcColor;
GLenum dstColor;
GLenum srcAlpha;
GLenum dstAlpha;
GLenum opColor;
GLenum opAlpha;
} blend;
bool depthTest;
bool depthWrite;
GLenum depthFunc;
bool stencilTest;
GLuint stencilReadMask;
GLuint stencilWriteMask;
struct StencilFace {
GLenum func;
GLenum failOp;
GLenum zfailOp;
GLenum zpassOp;
} stencil[2]; // front, back
bool polyOffsetFill;
float polyOffsetFactor;
float polyOffsetUnits;
float lineWidth;
void reset() { valid = false; }
struct {
// not part of QRhiGraphicsPipeline but used by setGraphicsPipeline()
GLint stencilRef = 0;
} dynamic;
} graphicsPassState;
struct ComputePassState {
enum Access {
Read = 0x01,
Write = 0x02
};
QHash<QRhiResource *, QPair<int, bool> > writtenResources;
void reset() {
writtenResources.clear();
}
} computePassState;
QVector<QByteArray> dataRetainPool;
QVector<QImage> imageRetainPool;
// relies heavily on implicit sharing (no copies of the actual data will be made)
const void *retainData(const QByteArray &data) {
dataRetainPool.append(data);
return dataRetainPool.constLast().constData();
}
const void *retainImage(const QImage &image) {
imageRetainPool.append(image);
return imageRetainPool.constLast().constBits();
}
void resetCommands() {
commands.clear();
dataRetainPool.clear();
imageRetainPool.clear();
passResTrackers.clear();
currentPassResTrackerIndex = -1;
}
void resetState() {
recordingPass = NoPass;
currentTarget = nullptr;
resetCommands();
resetCachedState();
}
void resetCachedState() {
currentGraphicsPipeline = nullptr;
currentComputePipeline = nullptr;
currentPipelineGeneration = 0;
currentGraphicsSrb = nullptr;
currentComputeSrb = nullptr;
currentSrbGeneration = 0;
graphicsPassState.reset();
computePassState.reset();
}
};
Q_DECLARE_TYPEINFO(QGles2CommandBuffer::Command, Q_MOVABLE_TYPE);
inline bool operator==(const QGles2CommandBuffer::GraphicsPassState::StencilFace &a,
const QGles2CommandBuffer::GraphicsPassState::StencilFace &b)
{
return a.func == b.func
&& a.failOp == b.failOp
&& a.zfailOp == b.zfailOp
&& a.zpassOp == b.zpassOp;
}
inline bool operator!=(const QGles2CommandBuffer::GraphicsPassState::StencilFace &a,
const QGles2CommandBuffer::GraphicsPassState::StencilFace &b)
{
return !(a == b);
}
inline bool operator==(const QGles2CommandBuffer::GraphicsPassState::ColorMask &a,
const QGles2CommandBuffer::GraphicsPassState::ColorMask &b)
{
return a.r == b.r && a.g == b.g && a.b == b.b && a.a == b.a;
}
inline bool operator!=(const QGles2CommandBuffer::GraphicsPassState::ColorMask &a,
const QGles2CommandBuffer::GraphicsPassState::ColorMask &b)
{
return !(a == b);
}
inline bool operator==(const QGles2CommandBuffer::GraphicsPassState::Blend &a,
const QGles2CommandBuffer::GraphicsPassState::Blend &b)
{
return a.srcColor == b.srcColor
&& a.dstColor == b.dstColor
&& a.srcAlpha == b.srcAlpha
&& a.dstAlpha == b.dstAlpha
&& a.opColor == b.opColor
&& a.opAlpha == b.opAlpha;
}
inline bool operator!=(const QGles2CommandBuffer::GraphicsPassState::Blend &a,
const QGles2CommandBuffer::GraphicsPassState::Blend &b)
{
return !(a == b);
}
struct QGles2SwapChain : public QRhiSwapChain
{
QGles2SwapChain(QRhiImplementation *rhi);
~QGles2SwapChain();
void release() override;
QRhiCommandBuffer *currentFrameCommandBuffer() override;
QRhiRenderTarget *currentFrameRenderTarget() override;
QSize surfacePixelSize() override;
QRhiRenderPassDescriptor *newCompatibleRenderPassDescriptor() override;
bool buildOrResize() override;
QSurface *surface = nullptr;
QSize pixelSize;
QGles2ReferenceRenderTarget rt;
QGles2CommandBuffer cb;
int frameCount = 0;
};
class QRhiGles2 : public QRhiImplementation
{
public:
QRhiGles2(QRhiGles2InitParams *params, QRhiGles2NativeHandles *importDevice = nullptr);
bool create(QRhi::Flags flags) override;
void destroy() override;
QRhiGraphicsPipeline *createGraphicsPipeline() override;
QRhiComputePipeline *createComputePipeline() override;
QRhiShaderResourceBindings *createShaderResourceBindings() override;
QRhiBuffer *createBuffer(QRhiBuffer::Type type,
QRhiBuffer::UsageFlags usage,
int size) override;
QRhiRenderBuffer *createRenderBuffer(QRhiRenderBuffer::Type type,
const QSize &pixelSize,
int sampleCount,
QRhiRenderBuffer::Flags flags) override;
QRhiTexture *createTexture(QRhiTexture::Format format,
const QSize &pixelSize,
int sampleCount,
QRhiTexture::Flags flags) override;
QRhiSampler *createSampler(QRhiSampler::Filter magFilter,
QRhiSampler::Filter minFilter,
QRhiSampler::Filter mipmapMode,
QRhiSampler:: AddressMode u,
QRhiSampler::AddressMode v,
QRhiSampler::AddressMode w) override;
QRhiTextureRenderTarget *createTextureRenderTarget(const QRhiTextureRenderTargetDescription &desc,
QRhiTextureRenderTarget::Flags flags) override;
QRhiSwapChain *createSwapChain() override;
QRhi::FrameOpResult beginFrame(QRhiSwapChain *swapChain, QRhi::BeginFrameFlags flags) override;
QRhi::FrameOpResult endFrame(QRhiSwapChain *swapChain, QRhi::EndFrameFlags flags) override;
QRhi::FrameOpResult beginOffscreenFrame(QRhiCommandBuffer **cb, QRhi::BeginFrameFlags flags) override;
QRhi::FrameOpResult endOffscreenFrame(QRhi::EndFrameFlags flags) override;
QRhi::FrameOpResult finish() override;
void resourceUpdate(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resourceUpdates) override;
void beginPass(QRhiCommandBuffer *cb,
QRhiRenderTarget *rt,
const QColor &colorClearValue,
const QRhiDepthStencilClearValue &depthStencilClearValue,
QRhiResourceUpdateBatch *resourceUpdates) override;
void endPass(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resourceUpdates) override;
void setGraphicsPipeline(QRhiCommandBuffer *cb,
QRhiGraphicsPipeline *ps) override;
void setShaderResources(QRhiCommandBuffer *cb,
QRhiShaderResourceBindings *srb,
int dynamicOffsetCount,
const QRhiCommandBuffer::DynamicOffset *dynamicOffsets) override;
void setVertexInput(QRhiCommandBuffer *cb,
int startBinding, int bindingCount, const QRhiCommandBuffer::VertexInput *bindings,
QRhiBuffer *indexBuf, quint32 indexOffset,
QRhiCommandBuffer::IndexFormat indexFormat) override;
void setViewport(QRhiCommandBuffer *cb, const QRhiViewport &viewport) override;
void setScissor(QRhiCommandBuffer *cb, const QRhiScissor &scissor) override;
void setBlendConstants(QRhiCommandBuffer *cb, const QColor &c) override;
void setStencilRef(QRhiCommandBuffer *cb, quint32 refValue) override;
void draw(QRhiCommandBuffer *cb, quint32 vertexCount,
quint32 instanceCount, quint32 firstVertex, quint32 firstInstance) override;
void drawIndexed(QRhiCommandBuffer *cb, quint32 indexCount,
quint32 instanceCount, quint32 firstIndex,
qint32 vertexOffset, quint32 firstInstance) override;
void debugMarkBegin(QRhiCommandBuffer *cb, const QByteArray &name) override;
void debugMarkEnd(QRhiCommandBuffer *cb) override;
void debugMarkMsg(QRhiCommandBuffer *cb, const QByteArray &msg) override;
void beginComputePass(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resourceUpdates) override;
void endComputePass(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resourceUpdates) override;
void setComputePipeline(QRhiCommandBuffer *cb, QRhiComputePipeline *ps) override;
void dispatch(QRhiCommandBuffer *cb, int x, int y, int z) override;
const QRhiNativeHandles *nativeHandles(QRhiCommandBuffer *cb) override;
void beginExternal(QRhiCommandBuffer *cb) override;
void endExternal(QRhiCommandBuffer *cb) override;
QVector<int> supportedSampleCounts() const override;
int ubufAlignment() const override;
bool isYUpInFramebuffer() const override;
bool isYUpInNDC() const override;
bool isClipDepthZeroToOne() const override;
QMatrix4x4 clipSpaceCorrMatrix() const override;
bool isTextureFormatSupported(QRhiTexture::Format format, QRhiTexture::Flags flags) const override;
bool isFeatureSupported(QRhi::Feature feature) const override;
int resourceLimit(QRhi::ResourceLimit limit) const override;
const QRhiNativeHandles *nativeHandles() override;
void sendVMemStatsToProfiler() override;
bool makeThreadLocalNativeContextCurrent() override;
void releaseCachedResources() override;
bool isDeviceLost() const override;
bool ensureContext(QSurface *surface = nullptr) const;
void executeDeferredReleases();
void trackedBufferBarrier(QGles2CommandBuffer *cbD, QGles2Buffer *bufD, QGles2Buffer::Access access);
void trackedImageBarrier(QGles2CommandBuffer *cbD, QGles2Texture *texD, QGles2Texture::Access access);
void enqueueSubresUpload(QGles2Texture *texD, QGles2CommandBuffer *cbD,
int layer, int level, const QRhiTextureSubresourceUploadDescription &subresDesc);
void enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resourceUpdates);
void trackedRegisterBuffer(QRhiPassResourceTracker *passResTracker,
QGles2Buffer *bufD,
QRhiPassResourceTracker::BufferAccess access,
QRhiPassResourceTracker::BufferStage stage);
void trackedRegisterTexture(QRhiPassResourceTracker *passResTracker,
QGles2Texture *texD,
QRhiPassResourceTracker::TextureAccess access,
QRhiPassResourceTracker::TextureStage stage);
void executeCommandBuffer(QRhiCommandBuffer *cb);
void executeBindGraphicsPipeline(QGles2CommandBuffer *cbD, QGles2GraphicsPipeline *psD);
void bindShaderResources(QRhiGraphicsPipeline *maybeGraphicsPs, QRhiComputePipeline *maybeComputePs,
QRhiShaderResourceBindings *srb,
const uint *dynOfsPairs, int dynOfsCount);
QGles2RenderTargetData *enqueueBindFramebuffer(QRhiRenderTarget *rt, QGles2CommandBuffer *cbD,
bool *wantsColorClear = nullptr, bool *wantsDsClear = nullptr);
void enqueueBarriersForPass(QGles2CommandBuffer *cbD);
int effectiveSampleCount(int sampleCount) const;
QByteArray shaderSource(const QRhiShaderStage &shaderStage, int *glslVersion);
bool compileShader(GLuint program, const QRhiShaderStage &shaderStage, int *glslVersion);
bool linkProgram(GLuint program);
void registerUniformIfActive(const QShaderDescription::BlockVariable &var,
const QByteArray &namePrefix,
int binding,
int baseOffset,
GLuint program,
QVector<QGles2UniformDescription> *dst);
void gatherUniforms(GLuint program,
const QShaderDescription::UniformBlock &ub,
QVector<QGles2UniformDescription> *dst);
void gatherSamplers(GLuint program, const QShaderDescription::InOutVariable &v,
QVector<QGles2SamplerDescription> *dst);
bool isProgramBinaryDiskCacheEnabled() const;
enum DiskCacheResult {
DiskCacheHit,
DiskCacheMiss,
DiskCacheError
};
DiskCacheResult tryLoadFromDiskCache(const QRhiShaderStage *stages, int stageCount,
GLuint program, QByteArray *cacheKey);
void trySaveToDiskCache(GLuint program, const QByteArray &cacheKey);
QOpenGLContext *ctx = nullptr;
bool importedContext = false;
QSurfaceFormat requestedFormat;
QSurface *fallbackSurface = nullptr;
QWindow *maybeWindow = nullptr;
mutable bool needsMakeCurrent = false;
QOpenGLExtensions *f = nullptr;
uint vao = 0;
struct Caps {
Caps()
: ctxMajor(2),
ctxMinor(0),
maxTextureSize(2048),
maxDrawBuffers(4),
msaaRenderBuffer(false),
npotTextureFull(true),
gles(false),
fixedIndexPrimitiveRestart(false),
bgraExternalFormat(false),
bgraInternalFormat(false),
r8Format(false),
r16Format(false),
floatFormats(false),
depthTexture(false),
packedDepthStencil(false),
needsDepthStencilCombinedAttach(false),
srgbCapableDefaultFramebuffer(false),
coreProfile(false),
uniformBuffers(false),
elementIndexUint(false),
depth24(false),
rgba8Format(false),
instancing(false),
baseVertex(false),
compute(false),
textureCompareMode(false),
properMapBuffer(false),
nonBaseLevelFramebufferTexture(false),
texelFetch(false)
{ }
int ctxMajor;
int ctxMinor;
int maxTextureSize;
int maxDrawBuffers;
int maxSamples;
// Multisample fb and blit are supported (GLES 3.0 or OpenGL 3.x). Not
// the same as multisample textures!
uint msaaRenderBuffer : 1;
uint npotTextureFull : 1;
uint gles : 1;
uint fixedIndexPrimitiveRestart : 1;
uint bgraExternalFormat : 1;
uint bgraInternalFormat : 1;
uint r8Format : 1;
uint r16Format : 1;
uint floatFormats : 1;
uint depthTexture : 1;
uint packedDepthStencil : 1;
uint needsDepthStencilCombinedAttach : 1;
uint srgbCapableDefaultFramebuffer : 1;
uint coreProfile : 1;
uint uniformBuffers : 1;
uint elementIndexUint : 1;
uint depth24 : 1;
uint rgba8Format : 1;
uint instancing : 1;
uint baseVertex : 1;
uint compute : 1;
uint textureCompareMode : 1;
uint properMapBuffer : 1;
uint nonBaseLevelFramebufferTexture : 1;
uint texelFetch : 1;
} caps;
QGles2SwapChain *currentSwapChain = nullptr;
QVector<GLint> supportedCompressedFormats;
mutable QVector<int> supportedSampleCountList;
QRhiGles2NativeHandles nativeHandlesStruct;
mutable bool contextLost = false;
struct DeferredReleaseEntry {
enum Type {
Buffer,
Pipeline,
Texture,
RenderBuffer,
TextureRenderTarget
};
Type type;
union {
struct {
GLuint buffer;
} buffer;
struct {
GLuint program;
} pipeline;
struct {
GLuint texture;
} texture;
struct {
GLuint renderbuffer;
GLuint renderbuffer2;
} renderbuffer;
struct {
GLuint framebuffer;
} textureRenderTarget;
};
};
QVector<DeferredReleaseEntry> releaseQueue;
struct OffscreenFrame {
OffscreenFrame(QRhiImplementation *rhi) : cbWrapper(rhi) { }
bool active = false;
QGles2CommandBuffer cbWrapper;
} ofr;
QHash<QRhiShaderStage, uint> m_shaderCache;
};
Q_DECLARE_TYPEINFO(QRhiGles2::DeferredReleaseEntry, Q_MOVABLE_TYPE);
QT_END_NAMESPACE
#endif