diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /gfx/angle/checkout/src/compiler/translator/blocklayout.h | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | gfx/angle/checkout/src/compiler/translator/blocklayout.h | 322 |
1 files changed, 322 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/compiler/translator/blocklayout.h b/gfx/angle/checkout/src/compiler/translator/blocklayout.h new file mode 100644 index 0000000000..97f9daa251 --- /dev/null +++ b/gfx/angle/checkout/src/compiler/translator/blocklayout.h @@ -0,0 +1,322 @@ +// +// Copyright 2013 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// blocklayout.h: +// Methods and classes related to uniform layout and packing in GLSL and HLSL. +// + +#ifndef COMMON_BLOCKLAYOUT_H_ +#define COMMON_BLOCKLAYOUT_H_ + +#include <cstddef> +#include <map> +#include <vector> + +#include <GLSLANG/ShaderLang.h> +#include "angle_gl.h" + +namespace sh +{ +struct ShaderVariable; +struct InterfaceBlock; + +struct BlockMemberInfo +{ + constexpr BlockMemberInfo() = default; + + constexpr BlockMemberInfo(int offset, int arrayStride, int matrixStride, bool isRowMajorMatrix) + : offset(offset), + arrayStride(arrayStride), + matrixStride(matrixStride), + isRowMajorMatrix(isRowMajorMatrix) + {} + + constexpr BlockMemberInfo(int offset, + int arrayStride, + int matrixStride, + bool isRowMajorMatrix, + int topLevelArrayStride) + : offset(offset), + arrayStride(arrayStride), + matrixStride(matrixStride), + isRowMajorMatrix(isRowMajorMatrix), + topLevelArrayStride(topLevelArrayStride) + {} + + // A single integer identifying the offset of an active variable. + int offset = -1; + + // A single integer identifying the stride between array elements in an active variable. + int arrayStride = -1; + + // A single integer identifying the stride between columns of a column-major matrix or rows of a + // row-major matrix. + int matrixStride = -1; + + // A single integer identifying whether an active variable is a row-major matrix. + bool isRowMajorMatrix = false; + + // A single integer identifying the number of active array elements of the top-level shader + // storage block member containing the active variable. + int topLevelArrayStride = -1; +}; + +constexpr size_t ComponentAlignment(size_t numComponents) +{ + return (numComponents == 3u ? 4u : numComponents); +} + +constexpr BlockMemberInfo kDefaultBlockMemberInfo; + +class BlockLayoutEncoder +{ + public: + BlockLayoutEncoder(); + virtual ~BlockLayoutEncoder() {} + + BlockMemberInfo encodeType(GLenum type, + const std::vector<unsigned int> &arraySizes, + bool isRowMajorMatrix); + // Advance the offset based on struct size and array dimensions. Size can be calculated with + // getShaderVariableSize() or equivalent. |enterAggregateType|/|exitAggregateType| is necessary + // around this call. + BlockMemberInfo encodeArrayOfPreEncodedStructs(size_t size, + const std::vector<unsigned int> &arraySizes); + + size_t getCurrentOffset() const; + size_t getShaderVariableSize(const ShaderVariable &structVar, bool isRowMajor); + + // Called when entering/exiting a structure variable. + virtual void enterAggregateType(const ShaderVariable &structVar) = 0; + virtual void exitAggregateType(const ShaderVariable &structVar) = 0; + + static constexpr size_t kBytesPerComponent = 4u; + static constexpr unsigned int kComponentsPerRegister = 4u; + + static size_t GetBlockRegister(const BlockMemberInfo &info); + static size_t GetBlockRegisterElement(const BlockMemberInfo &info); + + protected: + void align(size_t baseAlignment); + + virtual void getBlockLayoutInfo(GLenum type, + const std::vector<unsigned int> &arraySizes, + bool isRowMajorMatrix, + int *arrayStrideOut, + int *matrixStrideOut) = 0; + virtual void advanceOffset(GLenum type, + const std::vector<unsigned int> &arraySizes, + bool isRowMajorMatrix, + int arrayStride, + int matrixStride) = 0; + + size_t mCurrentOffset; +}; + +// Will return default values for everything. +class StubBlockEncoder : public BlockLayoutEncoder +{ + public: + StubBlockEncoder() = default; + + void enterAggregateType(const ShaderVariable &structVar) override {} + void exitAggregateType(const ShaderVariable &structVar) override {} + + protected: + void getBlockLayoutInfo(GLenum type, + const std::vector<unsigned int> &arraySizes, + bool isRowMajorMatrix, + int *arrayStrideOut, + int *matrixStrideOut) override; + + void advanceOffset(GLenum type, + const std::vector<unsigned int> &arraySizes, + bool isRowMajorMatrix, + int arrayStride, + int matrixStride) override + {} +}; + +// Block layout according to the std140 block layout +// See "Standard Uniform Block Layout" in Section 2.11.6 of the OpenGL ES 3.0 specification + +class Std140BlockEncoder : public BlockLayoutEncoder +{ + public: + Std140BlockEncoder(); + + void enterAggregateType(const ShaderVariable &structVar) override; + void exitAggregateType(const ShaderVariable &structVar) override; + + protected: + void getBlockLayoutInfo(GLenum type, + const std::vector<unsigned int> &arraySizes, + bool isRowMajorMatrix, + int *arrayStrideOut, + int *matrixStrideOut) override; + void advanceOffset(GLenum type, + const std::vector<unsigned int> &arraySizes, + bool isRowMajorMatrix, + int arrayStride, + int matrixStride) override; + + virtual size_t getBaseAlignment(const ShaderVariable &variable) const; + virtual size_t getTypeBaseAlignment(GLenum type, bool isRowMajorMatrix) const; +}; + +class Std430BlockEncoder : public Std140BlockEncoder +{ + public: + Std430BlockEncoder(); + + protected: + size_t getBaseAlignment(const ShaderVariable &variable) const override; + size_t getTypeBaseAlignment(GLenum type, bool isRowMajorMatrix) const override; +}; + +using BlockLayoutMap = std::map<std::string, BlockMemberInfo>; + +void GetInterfaceBlockInfo(const std::vector<ShaderVariable> &fields, + const std::string &prefix, + BlockLayoutEncoder *encoder, + BlockLayoutMap *blockInfoOut); + +// Used for laying out the default uniform block on the Vulkan backend. +void GetActiveUniformBlockInfo(const std::vector<ShaderVariable> &uniforms, + const std::string &prefix, + BlockLayoutEncoder *encoder, + BlockLayoutMap *blockInfoOut); + +class ShaderVariableVisitor +{ + public: + virtual ~ShaderVariableVisitor() {} + + virtual void enterStruct(const ShaderVariable &structVar) {} + virtual void exitStruct(const ShaderVariable &structVar) {} + + virtual void enterStructAccess(const ShaderVariable &structVar, bool isRowMajor) {} + virtual void exitStructAccess(const ShaderVariable &structVar, bool isRowMajor) {} + + virtual void enterArray(const ShaderVariable &arrayVar) {} + virtual void exitArray(const ShaderVariable &arrayVar) {} + + virtual void enterArrayElement(const ShaderVariable &arrayVar, unsigned int arrayElement) {} + virtual void exitArrayElement(const ShaderVariable &arrayVar, unsigned int arrayElement) {} + + virtual void visitOpaqueObject(const sh::ShaderVariable &variable) {} + + virtual void visitVariable(const ShaderVariable &variable, bool isRowMajor) = 0; + + protected: + ShaderVariableVisitor() {} +}; + +class VariableNameVisitor : public ShaderVariableVisitor +{ + public: + VariableNameVisitor(const std::string &namePrefix, const std::string &mappedNamePrefix); + ~VariableNameVisitor() override; + + void enterStruct(const ShaderVariable &structVar) override; + void exitStruct(const ShaderVariable &structVar) override; + void enterStructAccess(const ShaderVariable &structVar, bool isRowMajor) override; + void exitStructAccess(const ShaderVariable &structVar, bool isRowMajor) override; + void enterArray(const ShaderVariable &arrayVar) override; + void exitArray(const ShaderVariable &arrayVar) override; + void enterArrayElement(const ShaderVariable &arrayVar, unsigned int arrayElement) override; + void exitArrayElement(const ShaderVariable &arrayVar, unsigned int arrayElement) override; + + protected: + virtual void visitNamedOpaqueObject(const sh::ShaderVariable &variable, + const std::string &name, + const std::string &mappedName, + const std::vector<unsigned int> &arraySizes) + {} + virtual void visitNamedVariable(const ShaderVariable &variable, + bool isRowMajor, + const std::string &name, + const std::string &mappedName, + const std::vector<unsigned int> &arraySizes) = 0; + + std::string collapseNameStack() const; + std::string collapseMappedNameStack() const; + + private: + void visitOpaqueObject(const sh::ShaderVariable &variable) final; + void visitVariable(const ShaderVariable &variable, bool isRowMajor) final; + + std::vector<std::string> mNameStack; + std::vector<std::string> mMappedNameStack; + std::vector<unsigned int> mArraySizeStack; +}; + +class BlockEncoderVisitor : public VariableNameVisitor +{ + public: + BlockEncoderVisitor(const std::string &namePrefix, + const std::string &mappedNamePrefix, + BlockLayoutEncoder *encoder); + ~BlockEncoderVisitor() override; + + void enterStructAccess(const ShaderVariable &structVar, bool isRowMajor) override; + void exitStructAccess(const ShaderVariable &structVar, bool isRowMajor) override; + void enterArrayElement(const ShaderVariable &arrayVar, unsigned int arrayElement) override; + void exitArrayElement(const ShaderVariable &arrayVar, unsigned int arrayElement) override; + + void visitNamedVariable(const ShaderVariable &variable, + bool isRowMajor, + const std::string &name, + const std::string &mappedName, + const std::vector<unsigned int> &arraySizes) override; + + virtual void encodeVariable(const ShaderVariable &variable, + const BlockMemberInfo &variableInfo, + const std::string &name, + const std::string &mappedName) + {} + + protected: + int mTopLevelArraySize = 1; + int mTopLevelArrayStride = 0; + bool mIsTopLevelArrayStrideReady = true; + bool mSkipEnabled = false; + + private: + BlockLayoutEncoder *mEncoder; + unsigned int mStructStackSize = 0; +}; + +void TraverseShaderVariable(const ShaderVariable &variable, + bool isRowMajorLayout, + ShaderVariableVisitor *visitor); + +template <typename T> +void TraverseShaderVariables(const std::vector<T> &vars, + bool isRowMajorLayout, + ShaderVariableVisitor *visitor) +{ + for (const T &var : vars) + { + TraverseShaderVariable(var, isRowMajorLayout, visitor); + } +} + +template <typename T> +void TraverseActiveShaderVariables(const std::vector<T> &vars, + bool isRowMajorLayout, + ShaderVariableVisitor *visitor) +{ + for (const T &var : vars) + { + if (var.active) + { + TraverseShaderVariable(var, isRowMajorLayout, visitor); + } + } +} +} // namespace sh + +#endif // COMMON_BLOCKLAYOUT_H_ |