diff options
Diffstat (limited to 'src/Runtime/Source/render/Qt3DSRenderContext.h')
| -rw-r--r-- | src/Runtime/Source/render/Qt3DSRenderContext.h | 1063 |
1 files changed, 1063 insertions, 0 deletions
diff --git a/src/Runtime/Source/render/Qt3DSRenderContext.h b/src/Runtime/Source/render/Qt3DSRenderContext.h new file mode 100644 index 00000000..e5b51341 --- /dev/null +++ b/src/Runtime/Source/render/Qt3DSRenderContext.h @@ -0,0 +1,1063 @@ +/**************************************************************************** +** +** Copyright (C) 2008-2012 NVIDIA Corporation. +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of Qt 3D Studio. +** +** $QT_BEGIN_LICENSE:GPL$ +** 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 https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3 or (at your option) any later version +** approved by the KDE Free Qt Foundation. The licenses are as published by +** the Free Software Foundation and appearing in the file LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#pragma once +#ifndef QT3DS_RENDER_CONTEXT_H +#define QT3DS_RENDER_CONTEXT_H +#include "foundation/Qt3DS.h" +#include "foundation/Qt3DSAtomic.h" +#include "foundation/Qt3DSRefCounted.h" +#include "render/Qt3DSRenderBaseTypes.h" +#include "foundation/Qt3DSDataRef.h" +#include "foundation/Qt3DSMemoryBuffer.h" +#include "render/glg/Qt3DSGLImplObjects.h" +#include "render/backends/gl/Q3DSRenderBackendGLES2.h" +#include "render/backends/gl/Qt3DSRenderBackendGL3.h" +#include "render/backends/gl/Qt3DSRenderBackendGL4.h" +#include "render/backends/software/Qt3DSRenderBackendNULL.h" +#include "render/Qt3DSRenderVertexBuffer.h" +#include "render/Qt3DSRenderIndexBuffer.h" +#include "render/Qt3DSRenderConstantBuffer.h" +#include "render/Qt3DSRenderFrameBuffer.h" +#include "render/Qt3DSRenderRenderBuffer.h" +#include "render/Qt3DSRenderDepthStencilState.h" +#include "render/Qt3DSRenderRasterizerState.h" +#include "render/Qt3DSRenderDrawable.h" +#include "render/Qt3DSRenderInputAssembler.h" +#include "render/Qt3DSRenderAttribLayout.h" +#include "render/Qt3DSRenderImageTexture.h" +#include "render/Qt3DSRenderOcclusionQuery.h" +#include "render/Qt3DSRenderTimerQuery.h" +#include "render/Qt3DSRenderSync.h" +#include "render/Qt3DSRenderTexture2DArray.h" +#include "render/Qt3DSRenderTextureCube.h" +#include "render/Qt3DSRenderStorageBuffer.h" +#include "render/Qt3DSRenderAtomicCounterBuffer.h" +#include "render/Qt3DSRenderDrawIndirectBuffer.h" +#include "render/Qt3DSRenderProgramPipeline.h" +#include "render/Qt3DSRenderPathRender.h" +#include "render/Qt3DSRenderPathSpecification.h" +#include "render/Qt3DSRenderPathFontSpecification.h" +#include "render/Qt3DSRenderPathFontText.h" + +#include <QSurfaceFormat> + +// When SW fallback is defined we can support (some) object/layer advanced blend modes. If defined, +// the HW implementation is still preperred if available through extensions. SW fallback can't be +// used in custom shaders. +#define ADVANCED_BLEND_SW_FALLBACK +namespace qt3ds { +class NVFoundationBase; +} + +namespace qt3ds { +namespace render { + + using namespace foundation; + + struct NVRenderShaderProgramBinaryType + { + enum Enum { + Unknown = 0, + NVBinary = 1, + }; + }; + + // context dirty flags + struct NVRenderContextDirtyValues + { + enum Enum { + InputAssembler = 1 << 0, + }; + }; + + typedef NVFlags<NVRenderContextDirtyValues::Enum, QT3DSU32> NVRenderContextDirtyFlags; + typedef nvhash_map<CRegisteredString, NVRenderConstantBuffer *> TContextConstantBufferMap; + typedef nvhash_map<CRegisteredString, NVRenderStorageBuffer *> TContextStorageBufferMap; + typedef nvhash_map<CRegisteredString, NVRenderAtomicCounterBuffer *> + TContextAtomicCounterBufferMap; + typedef nvhash_map<NVRenderBackend::NVRenderBackendBufferObject, NVRenderDrawIndirectBuffer *> + TContextDrawIndirectBufferMap; + typedef nvhash_map<NVRenderBackend::NVRenderBackendDepthStencilStateObject, + NVRenderDepthStencilState *> + TContextDepthStencilStateMap; + typedef nvhash_map<NVRenderBackend::NVRenderBackendRasterizerStateObject, + NVRenderRasterizerState *> + TContextRasterizerStateMap; + typedef nvhash_map<NVRenderBackend::NVRenderBackendTextureObject, NVRenderTexture2DArray *> + TContextTex2DArrayToImpMap; + typedef nvhash_map<NVRenderBackend::NVRenderBackendTextureObject, NVRenderTextureCube *> + TContextTexCubeToImpMap; + typedef nvhash_map<NVRenderBackend::NVRenderBackendTextureObject, NVRenderImage2D *> + TContextImage2DToImpMap; + typedef nvhash_map<CRegisteredString, NVRenderPathFontSpecification *> + TContextPathFontSpecificationMap; + + class QT3DS_AUTOTEST_EXPORT NVRenderContext : public NVRefCounted, public NVRenderDrawable + { + public: + virtual NVRenderContextType GetRenderContextType() const = 0; + virtual bool AreMultisampleTexturesSupported() const = 0; + virtual bool GetConstantBufferSupport() const = 0; + virtual void getMaxTextureSize(QT3DSU32 &oWidth, QT3DSU32 &oHeight) = 0; + virtual const char *GetShadingLanguageVersion() = 0; + // Get the bit depth of the currently bound depth buffer. + virtual QT3DSU32 GetDepthBits() const = 0; + virtual QT3DSU32 GetStencilBits() const = 0; + virtual bool + GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::Enum inCap) const = 0; + virtual bool AreDXTImagesSupported() const = 0; + virtual bool IsDepthStencilSupported() const = 0; + virtual bool IsFpRenderTargetSupported() const = 0; + virtual bool IsTessellationSupported() const = 0; + virtual bool IsGeometryStageSupported() const = 0; + virtual bool IsComputeSupported() const = 0; + virtual bool IsSampleQuerySupported() const = 0; + virtual bool IsTimerQuerySupported() const = 0; + virtual bool IsCommandSyncSupported() const = 0; + virtual bool IsTextureArraySupported() const = 0; + virtual bool IsStorageBufferSupported() const = 0; + virtual bool IsAtomicCounterBufferSupported() const = 0; + virtual bool IsShaderImageLoadStoreSupported() const = 0; + virtual bool IsProgramPipelineSupported() const = 0; + virtual bool IsPathRenderingSupported() const = 0; + virtual bool IsBlendCoherencySupported() const = 0; + virtual bool IsAdvancedBlendHwSupported() const = 0; + virtual bool IsAdvancedBlendHwSupportedKHR() const = 0; + virtual bool IsStandardDerivativesSupported() const = 0; + virtual bool IsTextureLodSupported() const = 0; + + virtual void SetDefaultRenderTarget(QT3DSU64 targetID) = 0; + virtual void SetDefaultDepthBufferBitCount(QT3DSI32 depthBits) = 0; + + virtual NVRenderDepthStencilState * + CreateDepthStencilState(bool enableDepth, bool depthMask, NVRenderBoolOp::Enum depthFunc, + bool enableStencil, + NVRenderStencilFunctionArgument &stencilFuncFront, + NVRenderStencilFunctionArgument &stencilFuncBack, + NVRenderStencilOperationArgument &depthStencilOpFront, + NVRenderStencilOperationArgument &depthStencilOpBack) = 0; + + virtual NVRenderRasterizerState *CreateRasterizerState(QT3DSF32 depthBias, QT3DSF32 depthScale, + NVRenderFaces::Enum cullFace) = 0; + + virtual NVRenderVertexBuffer * + CreateVertexBuffer(NVRenderBufferUsageType::Enum usageType, size_t size, QT3DSU32 stride = 0, + NVConstDataRef<QT3DSU8> bufferData = NVConstDataRef<QT3DSU8>()) = 0; + virtual NVRenderVertexBuffer *GetVertexBuffer(const void *implementationHandle) = 0; + + virtual NVRenderIndexBuffer * + CreateIndexBuffer(NVRenderBufferUsageType::Enum usageType, + NVRenderComponentTypes::Enum componentType, size_t size, + NVConstDataRef<QT3DSU8> bufferData = NVConstDataRef<QT3DSU8>()) = 0; + virtual NVRenderIndexBuffer *GetIndexBuffer(const void *implementationHandle) = 0; + + virtual NVRenderConstantBuffer * + CreateConstantBuffer(const char *bufferName, + qt3ds::render::NVRenderBufferUsageType::Enum usageType, size_t size, + NVConstDataRef<QT3DSU8> bufferData) = 0; + virtual NVRenderConstantBuffer *GetConstantBuffer(CRegisteredString bufferName) = 0; + + virtual NVRenderStorageBuffer * + CreateStorageBuffer(const char *bufferName, + qt3ds::render::NVRenderBufferUsageType::Enum usageType, size_t size, + NVConstDataRef<QT3DSU8> bufferData, NVRenderDataBuffer *pBuffer) = 0; + virtual NVRenderStorageBuffer *GetStorageBuffer(CRegisteredString bufferName) = 0; + + virtual NVRenderAtomicCounterBuffer * + CreateAtomicCounterBuffer(const char *bufferName, + qt3ds::render::NVRenderBufferUsageType::Enum usageType, size_t size, + NVConstDataRef<QT3DSU8> bufferData) = 0; + virtual NVRenderAtomicCounterBuffer * + GetAtomicCounterBuffer(CRegisteredString bufferName) = 0; + virtual NVRenderAtomicCounterBuffer * + GetAtomicCounterBufferByParam(CRegisteredString paramName) = 0; + + virtual NVRenderDrawIndirectBuffer * + CreateDrawIndirectBuffer(qt3ds::render::NVRenderBufferUsageType::Enum usageType, size_t size, + NVConstDataRef<QT3DSU8> bufferData) = 0; + virtual NVRenderDrawIndirectBuffer *GetDrawIndirectBuffer( + NVRenderBackend::NVRenderBackendBufferObject implementationHandle) = 0; + + virtual void SetMemoryBarrier(NVRenderBufferBarrierFlags barriers) = 0; + + virtual NVRenderOcclusionQuery *CreateOcclusionQuery() = 0; + virtual NVRenderTimerQuery *CreateTimerQuery() = 0; + virtual NVRenderSync *CreateSync() = 0; + + virtual NVRenderTexture2D *CreateTexture2D() = 0; + virtual NVRenderTexture2D *GetTexture2D(const void *implementationHandle) = 0; + virtual NVRenderBackend *GetBackend() = 0; + + virtual NVRenderTexture2DArray *CreateTexture2DArray() = 0; + + virtual NVRenderTextureCube *CreateTextureCube() = 0; + + virtual NVRenderImage2D *CreateImage2D(NVRenderTexture2D *inTexture, + NVRenderImageAccessType::Enum inAccess) = 0; + + virtual NVRenderRenderBuffer * + CreateRenderBuffer(NVRenderRenderBufferFormats::Enum bufferFormat, QT3DSU32 width, + QT3DSU32 height) = 0; + virtual NVRenderRenderBuffer *GetRenderBuffer(const void *implementationHandle) = 0; + // Create a new frame buffer and set the current render target to that frame buffer. + virtual NVRenderFrameBuffer *CreateFrameBuffer() = 0; + virtual NVRenderFrameBuffer *GetFrameBuffer(const void *implementationHandle) = 0; + + virtual NVRenderAttribLayout * + CreateAttributeLayout(NVConstDataRef<NVRenderVertexBufferEntry> attribs) = 0; + + virtual NVRenderInputAssembler * + CreateInputAssembler(NVRenderAttribLayout *attribLayout, + NVConstDataRef<NVRenderVertexBuffer *> buffers, + const NVRenderIndexBuffer *indexBuffer, NVConstDataRef<QT3DSU32> strides, + NVConstDataRef<QT3DSU32> offsets, + NVRenderDrawMode::Enum primType = NVRenderDrawMode::Triangles, + QT3DSU32 patchVertexCount = 1) = 0; + virtual void SetInputAssembler(NVRenderInputAssembler *inputAssembler) = 0; + + virtual NVRenderVertFragCompilationResult CompileSource( + const char *shaderName, NVConstDataRef<QT3DSI8> vertShader, + NVConstDataRef<QT3DSI8> fragShader, + NVConstDataRef<QT3DSI8> tessControlShaderSource = NVConstDataRef<QT3DSI8>(), + NVConstDataRef<QT3DSI8> tessEvaluationShaderSource = NVConstDataRef<QT3DSI8>(), + NVConstDataRef<QT3DSI8> geometryShaderSource = NVConstDataRef<QT3DSI8>(), + bool separateProgram = false, + NVRenderShaderProgramBinaryType::Enum type = NVRenderShaderProgramBinaryType::Unknown, + bool binaryProgram = false) = 0; + + // You must figure out inVertLen and inFragLen yourself, this object doesn't do that. + NVRenderVertFragCompilationResult + CompileSource(const char *shaderName, const char *vertShader, QT3DSU32 inVertLen, + const char *fragShader, QT3DSU32 inFragLen, const char * = NULL, + QT3DSU32 inTCLen = 0, const char *tessEvaluationShaderSource = NULL, + QT3DSU32 inTELen = 0, const char *geometryShaderSource = NULL, QT3DSU32 inGSLen = 0, + bool separableProgram = false); + + virtual NVRenderVertFragCompilationResult + CompileBinary(const char *shaderName, NVRenderShaderProgramBinaryType::Enum type, + NVDataRef<QT3DSI8> vertShader, NVDataRef<QT3DSI8> fragShader, + NVDataRef<QT3DSI8> tessControlShaderSource = NVDataRef<QT3DSI8>(), + NVDataRef<QT3DSI8> tessEvaluationShaderSource = NVDataRef<QT3DSI8>(), + NVConstDataRef<QT3DSI8> geometryShaderSource = NVConstDataRef<QT3DSI8>()) = 0; + + virtual NVRenderVertFragCompilationResult + CompileComputeSource(const char *shaderName, NVConstDataRef<QT3DSI8> computeShaderSource) = 0; + + virtual NVRenderShaderProgram *GetShaderProgram(const void *implementationHandle) = 0; + + virtual NVRenderProgramPipeline *CreateProgramPipeline() = 0; + + virtual NVRenderPathSpecification *CreatePathSpecification() = 0; + virtual NVRenderPathRender *CreatePathRender(size_t range = 1) = 0; + virtual void SetPathProjectionMatrix(const QT3DSMat44 inPathProjection) = 0; + virtual void SetPathModelViewMatrix(const QT3DSMat44 inPathModelview) = 0; + virtual void SetPathStencilDepthOffset(QT3DSF32 inSlope, QT3DSF32 inBias) = 0; + virtual void SetPathCoverDepthFunc(NVRenderBoolOp::Enum inFunc) = 0; + + virtual NVRenderPathFontSpecification * + CreatePathFontSpecification(CRegisteredString fontName) = 0; + virtual NVRenderPathFontItem *CreatePathFontItem() = 0; + + // Specific setters for the guaranteed-to-exist context properties to set them as fast as + // possible. + // Note that this bypasses the property manage so push/pop will have no effect (unless you + // set these already + // once after a push using the property manager. + virtual void SetClearColor(QT3DSVec4 inClearColor) = 0; + virtual QT3DSVec4 GetClearColor() const = 0; + + virtual void SetBlendFunction(NVRenderBlendFunctionArgument inFunctions) = 0; + virtual NVRenderBlendFunctionArgument GetBlendFunction() const = 0; + + virtual void SetBlendEquation(NVRenderBlendEquationArgument inEquations) = 0; + virtual NVRenderBlendEquationArgument GetBlendEquation() const = 0; + + virtual void SetCullingEnabled(bool inEnabled) = 0; + virtual bool IsCullingEnabled() const = 0; + + virtual void SetDepthFunction(NVRenderBoolOp::Enum inFunction) = 0; + virtual qt3ds::render::NVRenderBoolOp::Enum GetDepthFunction() const = 0; + + virtual void SetBlendingEnabled(bool inEnabled) = 0; + virtual bool IsBlendingEnabled() const = 0; + + virtual void SetDepthWriteEnabled(bool inEnabled) = 0; + virtual bool IsDepthWriteEnabled() const = 0; + + virtual void SetDepthTestEnabled(bool inEnabled) = 0; + virtual bool IsDepthTestEnabled() const = 0; + + virtual void SetDepthStencilState(NVRenderDepthStencilState *inDepthStencilState) = 0; + virtual void SetStencilTestEnabled(bool inEnabled) = 0; + virtual bool IsStencilTestEnabled() const = 0; + + virtual void SetRasterizerState(NVRenderRasterizerState *inRasterizerState) = 0; + + virtual void SetScissorTestEnabled(bool inEnabled) = 0; + virtual bool IsScissorTestEnabled() const = 0; + + virtual void SetScissorRect(NVRenderRect inRect) = 0; + virtual NVRenderRect GetScissorRect() const = 0; + + virtual void SetViewport(NVRenderRect inViewport) = 0; + virtual NVRenderRect GetViewport() const = 0; + + virtual void SetColorWritesEnabled(bool inEnabled) = 0; + virtual bool IsColorWritesEnabled() const = 0; + + virtual void SetMultisampleEnabled(bool inEnabled) = 0; + virtual bool IsMultisampleEnabled() const = 0; + + // Used during layer rendering because we can't set the *actual* viewport to what it should + // be due to hardware problems. + // Set during begin render. + static QT3DSMat44 + ApplyVirtualViewportToProjectionMatrix(const QT3DSMat44 &inProjection, + const NVRenderRectF &inViewport, + const NVRenderRectF &inVirtualViewport); + + virtual void SetRenderTarget(NVRenderFrameBuffer *inBuffer) = 0; + virtual void SetReadTarget(NVRenderFrameBuffer *inBuffer) = 0; + virtual NVRenderFrameBuffer *GetRenderTarget() const = 0; + + virtual void SetActiveShader(NVRenderShaderProgram *inShader) = 0; + virtual NVRenderShaderProgram *GetActiveShader() const = 0; + + virtual void SetActiveProgramPipeline(NVRenderProgramPipeline *inProgramPipeline) = 0; + virtual NVRenderProgramPipeline *GetActiveProgramPipeline() const = 0; + + virtual void DispatchCompute(NVRenderShaderProgram *inShader, QT3DSU32 numGroupsX, + QT3DSU32 numGroupsY, QT3DSU32 numGroupsZ) = 0; + + // Push the entire set of properties. + virtual void PushPropertySet() = 0; + // Pop the entire set of properties, potentially forcing the values + // to opengl. Will set the hardware state to whatever at the time of push. + virtual void PopPropertySet(bool inForceSetProperties) = 0; + + // Ensure the hardware state matches the state we expect. + virtual void ResetBlendState() = 0; + + // Draw buffers are what the system will render to.. Applies to the current render context. + //-1 means none, else the integer is assumed to be an index past the draw buffer index. + // This applies only to the currently bound framebuffer. + virtual void SetDrawBuffers(NVConstDataRef<QT3DSI32> inDrawBufferSet) = 0; + virtual void SetReadBuffer(NVReadFaces::Enum inReadFace) = 0; + + virtual void ReadPixels(NVRenderRect inRect, NVRenderReadPixelFormats::Enum inFormat, + NVDataRef<QT3DSU8> inWriteBuffer) = 0; + + // Return the property manager for this render context + // virtual NVRenderPropertyManager& GetPropertyManager() = 0; + // Clear the current render target + virtual void Clear(NVRenderClearFlags flags) = 0; + // Clear this framebuffer without changing the active frame buffer + virtual void Clear(NVRenderFrameBuffer &framebuffer, NVRenderClearFlags flags) = 0; + // copy framebuffer content between read target and render target + virtual void BlitFramebuffer(QT3DSI32 srcX0, QT3DSI32 srcY0, QT3DSI32 srcX1, QT3DSI32 srcY1, + QT3DSI32 dstX0, QT3DSI32 dstY0, QT3DSI32 dstX1, QT3DSI32 dstY1, + NVRenderClearFlags flags, + NVRenderTextureMagnifyingOp::Enum filter) = 0; + + // Render, applying these immediate property values just before render. The hardware + // properties are tracked for push/pop + // but the shader properties are just set on the active shader *after* the hardware + // properties have been set. The shader properties are not tracked for push/pop. + // This call is meant to come directly before each draw call to setup the last bit of state + // before the draw operation. Note that there isn't another way to set the immedate + // property values for a given shader because it isn't clear which shader is active + // when the properties are getting set. + void Draw(NVRenderDrawMode::Enum drawMode, QT3DSU32 count, QT3DSU32 offset) override = 0; + + /** + * @brief Draw the current active vertex buffer using an indirect buffer + * This means the setup of the draw call is stored in a buffer bound to + * NVRenderBufferBindValues::Draw_Indirect + * + * @param[in] drawMode Draw mode (Triangles, ....) + * @param[in] indirect Offset into a indirect drawing setup buffer + * + * @return no return. + */ + virtual void DrawIndirect(NVRenderDrawMode::Enum drawMode, QT3DSU32 offset) = 0; + + virtual NVFoundationBase &GetFoundation() = 0; + virtual qt3ds::foundation::IStringTable &GetStringTable() = 0; + virtual NVAllocatorCallback &GetAllocator() = 0; + + virtual QSurfaceFormat format() const = 0; + + virtual void resetStates() = 0; + + static NVRenderContext &CreateGL(NVFoundationBase &foundation, IStringTable &inStringTable, + const QSurfaceFormat &format); + + static NVRenderContext &CreateNULL(NVFoundationBase &foundation, + IStringTable &inStringTable); + }; + + // Now for scoped property access. + template <typename TDataType> + struct NVRenderContextScopedProperty + : public NVRenderGenericScopedProperty<NVRenderContext, TDataType> + { + typedef typename NVRenderGenericScopedProperty<NVRenderContext, TDataType>::TGetter TGetter; + typedef typename NVRenderGenericScopedProperty<NVRenderContext, TDataType>::TSetter TSetter; + NVRenderContextScopedProperty(NVRenderContext &ctx, TGetter getter, TSetter setter) + : NVRenderGenericScopedProperty<NVRenderContext, TDataType>(ctx, getter, setter) + { + } + NVRenderContextScopedProperty(NVRenderContext &ctx, TGetter getter, TSetter setter, + const TDataType &inNewValue) + : NVRenderGenericScopedProperty<NVRenderContext, TDataType>(ctx, getter, setter, + inNewValue) + { + } + }; + +/** + * A Render Context implementation class + * + */ + +#define ITERATE_HARDWARE_CONTEXT_PROPERTIES \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(RenderTarget, FrameBuffer) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(ActiveShader, ActiveShader) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(ActiveProgramPipeline, ActiveProgramPipeline) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(InputAssembler, InputAssembler) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(BlendFunction, BlendFunction) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(CullingEnabled, CullingEnabled) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(DepthFunction, DepthFunction) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(BlendingEnabled, BlendingEnabled) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(DepthWriteEnabled, DepthWriteEnabled) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(DepthTestEnabled, DepthTestEnabled) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(StencilTestEnabled, StencilTestEnabled) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(ScissorTestEnabled, ScissorTestEnabled) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(ScissorRect, ScissorRect) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(Viewport, Viewport) \ + HANDLE_CONTEXT_HARDWARE_PROPERTY(ClearColor, ClearColor) + + // forward declarations + + class NVRenderContextImpl : public NVRenderContext, public NoCopy + { + public: + // these variables represent the current hardware state of the render context. + SNVGLHardPropertyContext m_HardwarePropertyContext; + + private: + NVScopedRefCounted<NVRenderBackend> m_backend; ///< pointer to our render backend + NVRenderContextDirtyFlags m_DirtyFlags; ///< context dirty flags + + NVRenderBackend::NVRenderBackendRenderTargetObject + m_DefaultOffscreenRenderTarget; ///< this is a special target set from outside if we + ///never render to a window directly (GL only) + QT3DSI32 m_DephBits; ///< this is the depth bits count of the default window render target + QT3DSI32 m_StencilBits; ///< this is the stencil bits count of the default window render target + + protected: + volatile QT3DSI32 mRefCount; + NVFoundationBase &m_Foundation; + qt3ds::foundation::IStringTable &m_StringTable; + + nvhash_map<const void *, NVRenderVertexBuffer *> m_VertToImpMap; + nvhash_map<const void *, NVRenderIndexBuffer *> m_IndexToImpMap; + TContextConstantBufferMap m_ConstantToImpMap; + TContextStorageBufferMap m_StorageToImpMap; + TContextAtomicCounterBufferMap m_AtomicCounterToImpMap; + TContextDrawIndirectBufferMap m_DrawIndirectToImpMap; + TContextDepthStencilStateMap m_DepthStencilStateToImpMap; + TContextRasterizerStateMap m_RasterizerStateToImpMap; + TContextPathFontSpecificationMap m_PathFontSpecToImpMap; + + nvhash_map<const void *, NVRenderTexture2D *> m_Tex2DToImpMap; + TContextTex2DArrayToImpMap m_Tex2DArrayToImpMap; + TContextTexCubeToImpMap m_TexCubeToImpMap; + TContextImage2DToImpMap m_Image2DtoImpMap; + nvhash_map<const void *, NVRenderShaderProgram *> m_ShaderToImpMap; + nvhash_map<const void *, NVRenderRenderBuffer *> m_RenderBufferToImpMap; + nvhash_map<const void *, NVRenderFrameBuffer *> m_FrameBufferToImpMap; + QT3DSU32 m_MaxTextureUnits; + QT3DSU32 m_NextTextureUnit; + QT3DSU32 m_MaxConstantBufferUnits; + QT3DSU32 m_NextConstantBufferUnit; + + nvvector<SNVGLHardPropertyContext> m_PropertyStack; + + void DoSetClearColor(QT3DSVec4 inClearColor) + { + m_HardwarePropertyContext.m_ClearColor = inClearColor; + m_backend->SetClearColor(&inClearColor); + } + + void DoSetBlendFunction(NVRenderBlendFunctionArgument inFunctions) + { + QT3DSI32_4 values; + m_HardwarePropertyContext.m_BlendFunction = inFunctions; + + m_backend->SetBlendFunc(inFunctions); + } + + void DoSetBlendEquation(NVRenderBlendEquationArgument inEquations) + { + QT3DSI32_4 values; + m_HardwarePropertyContext.m_BlendEquation = inEquations; + + m_backend->SetBlendEquation(inEquations); + } + + void DoSetCullingEnabled(bool inEnabled) + { + m_HardwarePropertyContext.m_CullingEnabled = inEnabled; + m_backend->SetRenderState(inEnabled, NVRenderState::CullFace); + } + + void DoSetDepthFunction(qt3ds::render::NVRenderBoolOp::Enum inFunction) + { + m_HardwarePropertyContext.m_DepthFunction = inFunction; + m_backend->SetDepthFunc(inFunction); + } + + void DoSetBlendingEnabled(bool inEnabled) + { + m_HardwarePropertyContext.m_BlendingEnabled = inEnabled; + m_backend->SetRenderState(inEnabled, NVRenderState::Blend); + } + + void DoSetColorWritesEnabled(bool inEnabled) + { + m_HardwarePropertyContext.m_ColorWritesEnabled = inEnabled; + m_backend->SetColorWrites(inEnabled, inEnabled, inEnabled, inEnabled); + } + + void DoSetMultisampleEnabled(bool inEnabled) + { + m_HardwarePropertyContext.m_MultisampleEnabled = inEnabled; + m_backend->SetMultisample(inEnabled); + } + + void DoSetDepthWriteEnabled(bool inEnabled) + { + m_HardwarePropertyContext.m_DepthWriteEnabled = inEnabled; + m_backend->SetDepthWrite(inEnabled); + } + + void DoSetDepthTestEnabled(bool inEnabled) + { + m_HardwarePropertyContext.m_DepthTestEnabled = inEnabled; + m_backend->SetRenderState(inEnabled, NVRenderState::DepthTest); + } + + void DoSetStencilTestEnabled(bool inEnabled) + { + m_HardwarePropertyContext.m_StencilTestEnabled = inEnabled; + m_backend->SetRenderState(inEnabled, NVRenderState::StencilTest); + } + + void DoSetScissorTestEnabled(bool inEnabled) + { + m_HardwarePropertyContext.m_ScissorTestEnabled = inEnabled; + m_backend->SetRenderState(inEnabled, NVRenderState::ScissorTest); + } + + void DoSetScissorRect(NVRenderRect inRect) + { + m_HardwarePropertyContext.m_ScissorRect = inRect; + m_backend->SetScissorRect(inRect); + } + + void DoSetViewport(NVRenderRect inViewport) + { + m_HardwarePropertyContext.m_Viewport = inViewport; + m_backend->SetViewportRect(inViewport); + } + + // Circular dependencies between shader constants and shader programs preclude + // implementation in header + void DoSetActiveShader(NVRenderShaderProgram *inShader); + void DoSetActiveProgramPipeline(NVRenderProgramPipeline *inProgramPipeline); + + void DoSetInputAssembler(NVRenderInputAssembler *inAssembler) + { + m_HardwarePropertyContext.m_InputAssembler = inAssembler; + m_DirtyFlags |= NVRenderContextDirtyValues::InputAssembler; + } + + void DoSetRenderTarget(NVRenderFrameBuffer *inBuffer) + { + if (inBuffer) + m_backend->SetRenderTarget(inBuffer->GetFrameBuffertHandle()); + else + m_backend->SetRenderTarget(m_DefaultOffscreenRenderTarget); + + m_HardwarePropertyContext.m_FrameBuffer = inBuffer; + } + + void DoSetReadTarget(NVRenderFrameBuffer *inBuffer) + { + if (inBuffer) + m_backend->SetReadTarget(inBuffer->GetFrameBuffertHandle()); + else + m_backend->SetReadTarget(NVRenderBackend::NVRenderBackendRenderTargetObject(NULL)); + } + + bool BindShaderToInputAssembler(const NVRenderInputAssembler *inputAssembler, + NVRenderShaderProgram *shader); + bool ApplyPreDrawProperties(); + void OnPostDraw(); + + public: + NVRenderContextImpl(NVFoundationBase &fnd, NVRenderBackend &inBackend, + IStringTable &inStrTable); + virtual ~NVRenderContextImpl(); + + QT3DS_IMPLEMENT_REF_COUNT_ADDREF_RELEASE_OVERRIDE(m_Foundation); + + NVRenderBackend *GetBackend() override { return m_backend; } + + void getMaxTextureSize(QT3DSU32 &oWidth, QT3DSU32 &oHeight) override; + + const char *GetShadingLanguageVersion() override + { + return m_backend->GetShadingLanguageVersion(); + } + + NVRenderContextType GetRenderContextType() const override + { + return m_backend->GetRenderContextType(); + } + + QT3DSU32 GetDepthBits() const override + { + // only query this if a framebuffer is bound + if (m_HardwarePropertyContext.m_FrameBuffer) + return m_backend->GetDepthBits(); + else + return m_DephBits; + } + + QT3DSU32 GetStencilBits() const override + { + // only query this if a framebuffer is bound + if (m_HardwarePropertyContext.m_FrameBuffer) + return m_backend->GetStencilBits(); + else + return m_StencilBits; + } + + bool GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::Enum inCap) const override + { + return m_backend->GetRenderBackendCap(inCap); + } + + bool AreMultisampleTexturesSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::MsTexture); + } + + bool GetConstantBufferSupport() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::ConstantBuffer); + } + + bool AreDXTImagesSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::DxtImages); + } + + bool IsDepthStencilSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::DepthStencilTexture); + } + + bool IsFpRenderTargetSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::FpRenderTarget); + } + + bool IsTessellationSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::Tessellation); + } + + bool IsGeometryStageSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::Geometry); + } + + bool IsComputeSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::Compute); + } + + bool IsSampleQuerySupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::SampleQuery); + } + + bool IsTimerQuerySupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::TimerQuery); + } + + bool IsCommandSyncSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::CommandSync); + } + bool IsTextureArraySupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::TextureArray); + } + bool IsStorageBufferSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::StorageBuffer); + } + bool IsAtomicCounterBufferSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::AtomicCounterBuffer); + } + bool IsShaderImageLoadStoreSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::ShaderImageLoadStore); + } + bool IsProgramPipelineSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::ProgramPipeline); + } + bool IsPathRenderingSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::PathRendering); + } + // Are blend modes really supported in HW? + bool IsAdvancedBlendHwSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::AdvancedBlend); + } + bool IsAdvancedBlendHwSupportedKHR() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::AdvancedBlendKHR); + } + bool IsBlendCoherencySupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::BlendCoherency); + } + bool IsStandardDerivativesSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::StandardDerivatives); + } + bool IsTextureLodSupported() const override + { + return GetRenderBackendCap(NVRenderBackend::NVRenderBackendCaps::TextureLod); + } + + void SetDefaultRenderTarget(QT3DSU64 targetID) override + { + m_DefaultOffscreenRenderTarget = + (NVRenderBackend::NVRenderBackendRenderTargetObject)targetID; + } + + void SetDefaultDepthBufferBitCount(QT3DSI32 depthBits) override { m_DephBits = depthBits; } + + virtual NVRenderDepthStencilState * + CreateDepthStencilState(bool enableDepth, bool depthMask, NVRenderBoolOp::Enum depthFunc, + bool enableStencil, + NVRenderStencilFunctionArgument &stencilFuncFront, + NVRenderStencilFunctionArgument &stencilFuncBack, + NVRenderStencilOperationArgument &depthStencilOpFront, + NVRenderStencilOperationArgument &depthStencilOpBack) override; + void SetDepthStencilState(NVRenderDepthStencilState *inDepthStencilState) override; + virtual void StateDestroyed(NVRenderDepthStencilState &state); + + NVRenderRasterizerState *CreateRasterizerState(QT3DSF32 depthBias, QT3DSF32 depthScale, + NVRenderFaces::Enum cullFace) override; + void SetRasterizerState(NVRenderRasterizerState *inRasterizerState) override; + virtual void StateDestroyed(NVRenderRasterizerState &state); + + NVRenderVertexBuffer *CreateVertexBuffer(NVRenderBufferUsageType::Enum usageType, + size_t size, QT3DSU32 stride, + NVConstDataRef<QT3DSU8> bufferData) override; + NVRenderVertexBuffer *GetVertexBuffer(const void *implementationHandle) override; + virtual void BufferDestroyed(NVRenderVertexBuffer &buffer); + + virtual NVRenderIndexBuffer * + CreateIndexBuffer(qt3ds::render::NVRenderBufferUsageType::Enum usageType, + qt3ds::render::NVRenderComponentTypes::Enum componentType, size_t size, + NVConstDataRef<QT3DSU8> bufferData) override; + NVRenderIndexBuffer *GetIndexBuffer(const void *implementationHandle) override; + virtual void BufferDestroyed(NVRenderIndexBuffer &buffer); + + virtual NVRenderConstantBuffer * + CreateConstantBuffer(const char *bufferName, + qt3ds::render::NVRenderBufferUsageType::Enum usageType, size_t size, + NVConstDataRef<QT3DSU8> bufferData) override; + NVRenderConstantBuffer *GetConstantBuffer(CRegisteredString bufferName) override; + virtual void BufferDestroyed(NVRenderConstantBuffer &buffer); + + virtual QT3DSU32 GetNextConstantBufferUnit(); + + virtual NVRenderStorageBuffer * + CreateStorageBuffer(const char *bufferName, + qt3ds::render::NVRenderBufferUsageType::Enum usageType, size_t size, + NVConstDataRef<QT3DSU8> bufferData, NVRenderDataBuffer *pBuffer) override; + NVRenderStorageBuffer *GetStorageBuffer(CRegisteredString bufferName) override; + virtual void BufferDestroyed(NVRenderStorageBuffer &buffer); + + virtual NVRenderAtomicCounterBuffer * + CreateAtomicCounterBuffer(const char *bufferName, + qt3ds::render::NVRenderBufferUsageType::Enum usageType, size_t size, + NVConstDataRef<QT3DSU8> bufferData) override; + NVRenderAtomicCounterBuffer *GetAtomicCounterBuffer(CRegisteredString bufferName) override; + virtual NVRenderAtomicCounterBuffer * + GetAtomicCounterBufferByParam(CRegisteredString paramName) override; + virtual void BufferDestroyed(NVRenderAtomicCounterBuffer &buffer); + + virtual NVRenderDrawIndirectBuffer * + CreateDrawIndirectBuffer(qt3ds::render::NVRenderBufferUsageType::Enum usageType, size_t size, + NVConstDataRef<QT3DSU8> bufferData) override; + virtual NVRenderDrawIndirectBuffer * + GetDrawIndirectBuffer(NVRenderBackend::NVRenderBackendBufferObject implementationHandle) override; + virtual void BufferDestroyed(NVRenderDrawIndirectBuffer &buffer); + + void SetMemoryBarrier(NVRenderBufferBarrierFlags barriers) override; + + NVRenderOcclusionQuery *CreateOcclusionQuery() override; + NVRenderTimerQuery *CreateTimerQuery() override; + NVRenderSync *CreateSync() override; + + NVRenderTexture2D *CreateTexture2D() override; + NVRenderTexture2D *GetTexture2D(const void *implementationHandle) override; + virtual void TextureDestroyed(NVRenderTexture2D &buffer); + + NVRenderTexture2DArray *CreateTexture2DArray() override; + virtual void TextureDestroyed(NVRenderTexture2DArray &buffer); + + NVRenderTextureCube *CreateTextureCube() override; + virtual void TextureDestroyed(NVRenderTextureCube &buffer); + + virtual QT3DSU32 GetNextTextureUnit(); + + NVRenderImage2D *CreateImage2D(NVRenderTexture2D *inTexture, + NVRenderImageAccessType::Enum inAccess) override; + virtual void ImageDestroyed(NVRenderImage2D &buffer); + + virtual NVRenderRenderBuffer * + CreateRenderBuffer(NVRenderRenderBufferFormats::Enum bufferFormat, QT3DSU32 width, + QT3DSU32 height) override; + NVRenderRenderBuffer *GetRenderBuffer(const void *implementationHandle) override; + virtual void RenderBufferDestroyed(NVRenderRenderBuffer &buffer); + + NVRenderFrameBuffer *CreateFrameBuffer() override; + NVRenderFrameBuffer *GetFrameBuffer(const void *implementationHandle) override; + virtual void FrameBufferDestroyed(NVRenderFrameBuffer &fb); + + virtual NVRenderAttribLayout * + CreateAttributeLayout(NVConstDataRef<NVRenderVertexBufferEntry> attribs) override; + NVRenderInputAssembler *CreateInputAssembler( + NVRenderAttribLayout *attribLayout, NVConstDataRef<NVRenderVertexBuffer *> buffers, + const NVRenderIndexBuffer *indexBuffer, NVConstDataRef<QT3DSU32> strides, + NVConstDataRef<QT3DSU32> offsets, NVRenderDrawMode::Enum primType, QT3DSU32 patchVertexCount) override; + void SetInputAssembler(NVRenderInputAssembler *inputAssembler) override; + + NVRenderVertFragCompilationResult CompileSource( + const char *shaderName, NVConstDataRef<QT3DSI8> vertShader, + NVConstDataRef<QT3DSI8> fragShader, + NVConstDataRef<QT3DSI8> tessControlShaderSource = NVConstDataRef<QT3DSI8>(), + NVConstDataRef<QT3DSI8> tessEvaluationShaderSource = NVConstDataRef<QT3DSI8>(), + NVConstDataRef<QT3DSI8> geometryShaderSource = NVConstDataRef<QT3DSI8>(), + bool separateProgram = false, + NVRenderShaderProgramBinaryType::Enum type = NVRenderShaderProgramBinaryType::Unknown, + bool binaryProgram = false) override; + + virtual NVRenderVertFragCompilationResult + CompileBinary(const char *shaderName, NVRenderShaderProgramBinaryType::Enum type, + NVDataRef<QT3DSI8> vertShader, NVDataRef<QT3DSI8> fragShader, + NVDataRef<QT3DSI8> tessControlShaderSource = NVDataRef<QT3DSI8>(), + NVDataRef<QT3DSI8> tessEvaluationShaderSource = NVDataRef<QT3DSI8>(), + NVConstDataRef<QT3DSI8> geometryShaderSource = NVConstDataRef<QT3DSI8>()) override; + + virtual NVRenderVertFragCompilationResult + CompileComputeSource(const char *shaderName, NVConstDataRef<QT3DSI8> computeShaderSource) override; + + NVRenderShaderProgram *GetShaderProgram(const void *implementationHandle) override; + virtual void ShaderDestroyed(NVRenderShaderProgram &shader); + + NVRenderProgramPipeline *CreateProgramPipeline() override; + NVRenderPathSpecification *CreatePathSpecification() override; + NVRenderPathRender *CreatePathRender(size_t range = 1) override; + void SetPathProjectionMatrix(const QT3DSMat44 inPathProjection) override; + void SetPathModelViewMatrix(const QT3DSMat44 inPathModelview) override; + void SetPathStencilDepthOffset(QT3DSF32 inSlope, QT3DSF32 inBias) override; + void SetPathCoverDepthFunc(NVRenderBoolOp::Enum inFunc) override; + + virtual NVRenderPathFontSpecification * + CreatePathFontSpecification(CRegisteredString fontName) override; + virtual void ReleasePathFontSpecification(NVRenderPathFontSpecification &inPathSpec); + NVRenderPathFontItem *CreatePathFontItem() override; + + void SetClearColor(QT3DSVec4 inClearColor) override; + QT3DSVec4 GetClearColor() const override { return m_HardwarePropertyContext.m_ClearColor; } + + void SetBlendFunction(NVRenderBlendFunctionArgument inFunctions) override; + NVRenderBlendFunctionArgument GetBlendFunction() const override + { + return m_HardwarePropertyContext.m_BlendFunction; + } + + void SetBlendEquation(NVRenderBlendEquationArgument inEquations) override; + NVRenderBlendEquationArgument GetBlendEquation() const override + { + return m_HardwarePropertyContext.m_BlendEquation; + }; + + void SetCullingEnabled(bool inEnabled) override; + bool IsCullingEnabled() const override { return m_HardwarePropertyContext.m_CullingEnabled; } + + void SetDepthFunction(qt3ds::render::NVRenderBoolOp::Enum inFunction) override; + qt3ds::render::NVRenderBoolOp::Enum GetDepthFunction() const override + { + return m_HardwarePropertyContext.m_DepthFunction; + } + + void SetBlendingEnabled(bool inEnabled) override; + bool IsBlendingEnabled() const override + { + return m_HardwarePropertyContext.m_BlendingEnabled; + } + + void SetDepthWriteEnabled(bool inEnabled) override; + bool IsDepthWriteEnabled() const override + { + return m_HardwarePropertyContext.m_DepthWriteEnabled; + } + void SetDepthTestEnabled(bool inEnabled) override; + bool IsDepthTestEnabled() const override + { + return m_HardwarePropertyContext.m_DepthTestEnabled; + } + + void SetStencilTestEnabled(bool inEnabled) override; + bool IsStencilTestEnabled() const override + { + return m_HardwarePropertyContext.m_StencilTestEnabled; + } + + void SetScissorTestEnabled(bool inEnabled) override; + bool IsScissorTestEnabled() const override + { + return m_HardwarePropertyContext.m_ScissorTestEnabled; + } + void SetScissorRect(NVRenderRect inRect) override; + NVRenderRect GetScissorRect() const override + { + return m_HardwarePropertyContext.m_ScissorRect; + } + + void SetViewport(NVRenderRect inViewport) override; + NVRenderRect GetViewport() const override { return m_HardwarePropertyContext.m_Viewport; } + + void SetColorWritesEnabled(bool inEnabled) override; + bool IsColorWritesEnabled() const override + { + return m_HardwarePropertyContext.m_ColorWritesEnabled; + } + + void SetMultisampleEnabled(bool inEnabled) override; + bool IsMultisampleEnabled() const override + { + return m_HardwarePropertyContext.m_MultisampleEnabled; + } + + void SetActiveShader(NVRenderShaderProgram *inShader) override; + NVRenderShaderProgram *GetActiveShader() const override + { + return m_HardwarePropertyContext.m_ActiveShader; + } + + void SetActiveProgramPipeline(NVRenderProgramPipeline *inProgramPipeline) override; + NVRenderProgramPipeline *GetActiveProgramPipeline() const override + { + return m_HardwarePropertyContext.m_ActiveProgramPipeline; + } + + void DispatchCompute(NVRenderShaderProgram *inShader, QT3DSU32 numGroupsX, + QT3DSU32 numGroupsY, QT3DSU32 numGroupsZ) override; + + void SetDrawBuffers(NVConstDataRef<QT3DSI32> inDrawBufferSet) override; + void SetReadBuffer(NVReadFaces::Enum inReadFace) override; + + void ReadPixels(NVRenderRect inRect, NVRenderReadPixelFormats::Enum inFormat, + NVDataRef<QT3DSU8> inWriteBuffer) override; + + void SetRenderTarget(NVRenderFrameBuffer *inBuffer) override; + void SetReadTarget(NVRenderFrameBuffer *inBuffer) override; + NVRenderFrameBuffer *GetRenderTarget() const override + { + return m_HardwarePropertyContext.m_FrameBuffer; + } + + void ResetBlendState() override; + + // Push the entire set of properties. + void PushPropertySet() override { m_PropertyStack.push_back(m_HardwarePropertyContext); } + + // Pop the entire set of properties, potentially forcing the values + // to opengl. + void PopPropertySet(bool inForceSetProperties) override; + + // clear current bound render target + void Clear(NVRenderClearFlags flags) override; + // clear passed in rendertarget + void Clear(NVRenderFrameBuffer &fb, NVRenderClearFlags flags) override; + + // copy framebuffer content between read target and render target + void BlitFramebuffer(QT3DSI32 srcX0, QT3DSI32 srcY0, QT3DSI32 srcX1, QT3DSI32 srcY1, + QT3DSI32 dstX0, QT3DSI32 dstY0, QT3DSI32 dstX1, QT3DSI32 dstY1, + NVRenderClearFlags flags, + NVRenderTextureMagnifyingOp::Enum filter) override; + + void Draw(NVRenderDrawMode::Enum drawMode, QT3DSU32 count, QT3DSU32 offset) override; + void DrawIndirect(NVRenderDrawMode::Enum drawMode, QT3DSU32 offset) override; + + NVFoundationBase &GetFoundation() override { return m_Foundation; } + qt3ds::foundation::IStringTable &GetStringTable() override { return m_StringTable; } + NVAllocatorCallback &GetAllocator() override { return m_Foundation.getAllocator(); } + QSurfaceFormat format() const override + { + return m_backend->format(); + } + virtual void resetStates() + { + PushPropertySet(); + PopPropertySet(true); + } + }; +} +} +#endif |