diff options
Diffstat (limited to 'src/render/Qt3DSRenderShaderConstant.h')
| -rw-r--r-- | src/render/Qt3DSRenderShaderConstant.h | 448 |
1 files changed, 448 insertions, 0 deletions
diff --git a/src/render/Qt3DSRenderShaderConstant.h b/src/render/Qt3DSRenderShaderConstant.h new file mode 100644 index 0000000..7fb57ff --- /dev/null +++ b/src/render/Qt3DSRenderShaderConstant.h @@ -0,0 +1,448 @@ +/**************************************************************************** +** +** 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_SHADER_CONSTANT_H +#define QT3DS_RENDER_SHADER_CONSTANT_H + +#include "foundation/Qt3DSFoundation.h" +#include "foundation/Qt3DSAtomic.h" +#include "foundation/Qt3DSMat33.h" +#include "foundation/Qt3DSMat44.h" +#include "EASTL/string.h" +#include "EASTL/utility.h" +#include "render/Qt3DSRenderContext.h" + +namespace qt3ds { +namespace render { + using namespace foundation; + + ///< forward declarations + class NVRenderContextImpl; + class NVRenderConstantBuffer; + + ///< A shader constant belongs to a program + class QT3DS_AUTOTEST_EXPORT NVRenderShaderConstantBase + { + public: + NVRenderBackend *m_Backend; ///< pointer to backend + CRegisteredString m_Name; ///< register constant name + QT3DSI32 m_Location; ///< constant index + QT3DSI32 m_ElementCount; ///< constant element count for arrays + NVRenderShaderDataTypes::Enum m_Type; ///< constant type + QT3DSI32 m_Binding; ///< sampler/imnage binding point + + public: + NVRenderShaderConstantBase(NVRenderBackend *backend, CRegisteredString name, QT3DSI32 location, + QT3DSI32 elementCount, NVRenderShaderDataTypes::Enum type, + QT3DSI32 binding) + : m_Backend(backend) + , m_Name(name) + , m_Location(location) + , m_ElementCount(elementCount) + , m_Type(type) + , m_Binding(binding) + { + } + + NVRenderShaderDataTypes::Enum GetShaderConstantType() const { return m_Type; } + + virtual void Release() = 0; + }; + + ///< A general class for shader types + template <typename TDataType> + class NVRenderShaderConstant : public NVRenderShaderConstantBase + { + public: + NVFoundationBase &m_Foundation; ///< allocator + TDataType m_Value; ///< constant value + + public: + NVRenderShaderConstant(NVRenderBackend *backend, CRegisteredString name, QT3DSI32 location, + QT3DSI32 elementCount, NVRenderShaderDataTypes::Enum type, + QT3DSI32 binding, NVFoundationBase &allocator) + : NVRenderShaderConstantBase(backend, name, location, elementCount, type, binding) + , m_Foundation(allocator) + { + memset(&m_Value, 0, sizeof(TDataType)); + } + + NVFoundationBase &GetFoundation() { return m_Foundation; } + + void Release() override { NVDelete(GetFoundation().getAllocator(), this); } + }; + + ///< A specialized class for textures + template <> + class NVRenderShaderConstant<NVRenderTexture2DPtr> : public NVRenderShaderConstantBase + { + public: + NVFoundationBase &m_Foundation; ///< allocator + QT3DSU32 m_Value; ///< constant value + + public: + NVRenderShaderConstant(NVRenderBackend *backend, CRegisteredString name, QT3DSI32 location, + QT3DSI32 elementCount, NVRenderShaderDataTypes::Enum type, + QT3DSI32 binding, NVFoundationBase &allocator) + : NVRenderShaderConstantBase(backend, name, location, elementCount, type, binding) + , m_Foundation(allocator) + { + m_Value = QT3DS_MAX_U32; + } + + NVFoundationBase &GetFoundation() { return m_Foundation; } + + void Release() override { NVDelete(GetFoundation().getAllocator(), this); } + }; + + ///< A specialized class for textures + template <> + class NVRenderShaderConstant<NVRenderTexture2DHandle> : public NVRenderShaderConstantBase + { + public: + NVFoundationBase &m_Foundation; ///< allocator + QVector<QT3DSU32> m_Value; ///< constant value + + public: + NVRenderShaderConstant(NVRenderBackend *backend, CRegisteredString name, QT3DSI32 location, + QT3DSI32 elementCount, NVRenderShaderDataTypes::Enum type, + QT3DSI32 binding, NVFoundationBase &allocator) + : NVRenderShaderConstantBase(backend, name, location, elementCount, type, binding) + , m_Foundation(allocator) + { + m_Value.resize(elementCount); + m_Value.fill(QT3DS_MAX_U32); + } + + NVFoundationBase &GetFoundation() { return m_Foundation; } + + void Release() override { NVDelete(GetFoundation().getAllocator(), this); } + }; + + ///< A specialized class for texture arrays + template <> + class NVRenderShaderConstant<NVRenderTexture2DArrayPtr> : public NVRenderShaderConstantBase + { + public: + NVFoundationBase &m_Foundation; ///< allocator + QT3DSU32 m_Value; ///< constant value + + public: + NVRenderShaderConstant(NVRenderBackend *backend, CRegisteredString name, QT3DSI32 location, + QT3DSI32 elementCount, NVRenderShaderDataTypes::Enum type, + QT3DSI32 binding, NVFoundationBase &allocator) + : NVRenderShaderConstantBase(backend, name, location, elementCount, type, binding) + , m_Foundation(allocator) + { + m_Value = QT3DS_MAX_U32; + } + + NVFoundationBase &GetFoundation() { return m_Foundation; } + + void Release() override { NVDelete(GetFoundation().getAllocator(), this); } + }; + + ///< A specialized class for cubemap textures + template <> + class NVRenderShaderConstant<NVRenderTextureCubePtr> : public NVRenderShaderConstantBase + { + public: + NVFoundationBase &m_Foundation; ///< allocator + QT3DSU32 m_Value; ///< constant value + + public: + NVRenderShaderConstant(NVRenderBackend *backend, CRegisteredString name, QT3DSI32 location, + QT3DSI32 elementCount, NVRenderShaderDataTypes::Enum type, + QT3DSI32 binding, NVFoundationBase &allocator) + : NVRenderShaderConstantBase(backend, name, location, elementCount, type, binding) + , m_Foundation(allocator) + { + m_Value = QT3DS_MAX_U32; + } + + NVFoundationBase &GetFoundation() { return m_Foundation; } + + void Release() override { NVDelete(GetFoundation().getAllocator(), this); } + }; + + ///< A specialized class for cubemap textures + template <> + class NVRenderShaderConstant<NVRenderTextureCubeHandle> : public NVRenderShaderConstantBase + { + public: + NVFoundationBase &m_Foundation; ///< allocator + QVector<QT3DSU32> m_Value; ///< constant value + + public: + NVRenderShaderConstant(NVRenderBackend *backend, CRegisteredString name, QT3DSI32 location, + QT3DSI32 elementCount, NVRenderShaderDataTypes::Enum type, + QT3DSI32 binding, NVFoundationBase &allocator) + : NVRenderShaderConstantBase(backend, name, location, elementCount, type, binding) + , m_Foundation(allocator) + { + m_Value.resize(elementCount); + m_Value.fill(QT3DS_MAX_U32); + } + + NVFoundationBase &GetFoundation() { return m_Foundation; } + + void Release() override { NVDelete(GetFoundation().getAllocator(), this); } + }; + + ///< A specialized class for texture image buffer + template <> + class NVRenderShaderConstant<NVRenderImage2DPtr> : public NVRenderShaderConstantBase + { + public: + NVFoundationBase &m_Foundation; ///< allocator + QT3DSU32 m_Value; ///< constant value + + public: + NVRenderShaderConstant(NVRenderBackend *backend, CRegisteredString name, QT3DSI32 location, + QT3DSI32 elementCount, NVRenderShaderDataTypes::Enum type, + QT3DSI32 binding, NVFoundationBase &allocator) + : NVRenderShaderConstantBase(backend, name, location, elementCount, type, binding) + , m_Foundation(allocator) + { + m_Value = QT3DS_MAX_U32; + } + + NVFoundationBase &GetFoundation() { return m_Foundation; } + + void Release() override { NVDelete(GetFoundation().getAllocator(), this); } + }; + + ///< Base for any buffer ( constant, texture, ... ) which is used by this program + class NVRenderShaderBufferBase + { + public: + NVRenderContextImpl &m_Context; ///< pointer to context + CRegisteredString m_Name; ///< buffer name + QT3DSU32 m_Location; ///< program buffer block location + QT3DSU32 m_Binding; ///< program buffer binding + QT3DSI32 m_Size; ///< buffer size + + public: + NVRenderShaderBufferBase(NVRenderContextImpl &context, CRegisteredString name, + QT3DSI32 location, QT3DSI32 binding, QT3DSI32 size) + : m_Context(context) + , m_Name(name) + , m_Location(location) + , m_Binding(binding) + , m_Size(size) + { + } + + virtual void Release() = 0; + + virtual void Validate(NVRenderShaderProgram *inShader) = 0; + virtual void BindToProgram(NVRenderShaderProgram *inShader) = 0; + virtual void Update() = 0; + }; + + class NVRenderShaderConstantBuffer : public NVRenderShaderBufferBase + { + public: + NVFoundationBase &m_Foundation; ///< allocator + QT3DSI32 m_ParamCount; ///< count of parameters contained in the constant buffer + NVRenderConstantBuffer *m_pCB; ///< pointer to constant buffer + + public: + NVRenderShaderConstantBuffer(NVRenderContextImpl &context, CRegisteredString name, + QT3DSU32 location, QT3DSI32 binding, QT3DSI32 size, QT3DSI32 count, + NVRenderConstantBuffer *pCB, NVFoundationBase &allocator) + : NVRenderShaderBufferBase(context, name, location, binding, size) + , m_Foundation(allocator) + , m_ParamCount(count) + , m_pCB(pCB) + { + } + + NVFoundationBase &GetFoundation() { return m_Foundation; } + + void Release() override + { + if (m_pCB) + m_pCB->release(); + + NVDelete(GetFoundation().getAllocator(), this); + } + + void Validate(NVRenderShaderProgram *inShader) override + { + // A constant buffer might not be set at first call + // due to the fact that they are compiled from a cache file + // Now it must exists. + if (m_pCB) + return; + + NVRenderConstantBuffer *cb = m_Context.GetConstantBuffer(m_Name); + if (cb) { + cb->SetupBuffer(inShader, m_Location, m_Size, m_ParamCount); + cb->addRef(); + m_pCB = cb; + } else { + QT3DS_ASSERT(false); + } + } + + void Update() override + { + if (m_pCB) + m_pCB->Update(); + } + + void BindToProgram(NVRenderShaderProgram *inShader) override + { + if (m_pCB) + m_pCB->BindToShaderProgram(inShader, m_Location, m_Binding); + } + }; + + class NVRenderShaderStorageBuffer : public NVRenderShaderBufferBase + { + public: + NVFoundationBase &m_Foundation; ///< allocator + QT3DSI32 m_ParamCount; ///< count of parameters contained in the constant buffer + NVRenderStorageBuffer *m_pSB; ///< pointer to storage buffer + + public: + NVRenderShaderStorageBuffer(NVRenderContextImpl &context, CRegisteredString name, + QT3DSU32 location, QT3DSI32 binding, QT3DSI32 size, QT3DSI32 count, + NVRenderStorageBuffer *pSB, NVFoundationBase &allocator) + : NVRenderShaderBufferBase(context, name, location, binding, size) + , m_Foundation(allocator) + , m_ParamCount(count) + , m_pSB(pSB) + { + } + + NVFoundationBase &GetFoundation() { return m_Foundation; } + + void Release() override + { + if (m_pSB) + m_pSB->release(); + + NVDelete(GetFoundation().getAllocator(), this); + } + + void Validate(NVRenderShaderProgram * /*inShader*/) override + { + // A constant buffer might not be set at first call + // due to the fact that they are compile from a cache file + // Now it must exists. + if (m_pSB) + return; + + NVRenderStorageBuffer *sb = m_Context.GetStorageBuffer(m_Name); + if (sb) { + sb->addRef(); + m_pSB = sb; + } else { + QT3DS_ASSERT(false); + } + } + + void Update() override + { + if (m_pSB) + m_pSB->Update(); + } + + void BindToProgram(NVRenderShaderProgram * /*inShader*/) override + { + if (m_pSB) + m_pSB->BindToShaderProgram(m_Location); + } + }; + + class NVRenderShaderAtomicCounterBuffer : public NVRenderShaderBufferBase + { + public: + NVFoundationBase &m_Foundation; ///< allocator + QT3DSI32 m_ParamCount; ///< count of parameters contained in the constant buffer + NVRenderAtomicCounterBuffer *m_pAcB; ///< pointer to atomic counter buffer + + public: + NVRenderShaderAtomicCounterBuffer(NVRenderContextImpl &context, CRegisteredString name, + QT3DSU32 location, QT3DSI32 binding, QT3DSI32 size, QT3DSI32 count, + NVRenderAtomicCounterBuffer *pAcB, + NVFoundationBase &allocator) + : NVRenderShaderBufferBase(context, name, location, binding, size) + , m_Foundation(allocator) + , m_ParamCount(count) + , m_pAcB(pAcB) + { + } + + NVFoundationBase &GetFoundation() { return m_Foundation; } + + void Release() override + { + if (m_pAcB) + m_pAcB->release(); + + NVDelete(GetFoundation().getAllocator(), this); + } + + void Validate(NVRenderShaderProgram * /*inShader*/) override + { + // A constant buffer might not be set at first call + // due to the fact that they are compile from a cache file + // Now it must exists. + if (m_pAcB) + return; + + NVRenderAtomicCounterBuffer *acb = m_Context.GetAtomicCounterBuffer(m_Name); + if (acb) { + acb->addRef(); + m_pAcB = acb; + } else { + QT3DS_ASSERT(false); + } + } + + void Update() override + { + if (m_pAcB) + m_pAcB->Update(); + } + + void BindToProgram(NVRenderShaderProgram * /*inShader*/) override + { + if (m_pAcB) + m_pAcB->BindToShaderProgram(m_Location); + } + }; +} +} + +#endif |