diff options
Diffstat (limited to 'gfx/angle/checkout/src/compiler/translator/TranslatorMetalDirect.h')
-rw-r--r-- | gfx/angle/checkout/src/compiler/translator/TranslatorMetalDirect.h | 195 |
1 files changed, 195 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/compiler/translator/TranslatorMetalDirect.h b/gfx/angle/checkout/src/compiler/translator/TranslatorMetalDirect.h new file mode 100644 index 0000000000..679687df07 --- /dev/null +++ b/gfx/angle/checkout/src/compiler/translator/TranslatorMetalDirect.h @@ -0,0 +1,195 @@ +// +// Copyright 2020 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. +// + +#ifndef COMPILER_TRANSLATOR_TRANSLATORMETALDIRECT_H_ +#define COMPILER_TRANSLATOR_TRANSLATORMETALDIRECT_H_ + +#include "compiler/translator/Compiler.h" + +namespace sh +{ + +constexpr const char kUniformsVar[] = "angleUniforms"; +constexpr const char kUnassignedAttributeString[] = " __unassigned_attribute__"; + +class DriverUniform; +class DriverUniformMetal; +class SpecConst; +class TOutputMSL; +class TranslatorMetalReflection; +typedef std::unordered_map<size_t, std::string> originalNamesMap; +typedef std::unordered_map<std::string, size_t> samplerBindingMap; +typedef std::unordered_map<std::string, size_t> textureBindingMap; +typedef std::unordered_map<std::string, size_t> userUniformBufferBindingMap; +typedef std::pair<size_t, size_t> uboBindingInfo; +struct UBOBindingInfo +{ + size_t bindIndex = 0; + size_t arraySize = 0; +}; +typedef std::unordered_map<std::string, UBOBindingInfo> uniformBufferBindingMap; + +namespace mtl +{ +TranslatorMetalReflection *getTranslatorMetalReflection(const TCompiler *compiler); +} + +class TranslatorMetalReflection +{ + public: + TranslatorMetalReflection() : hasUBOs(false), hasFlatInput(false) {} + ~TranslatorMetalReflection() {} + + void addOriginalName(const size_t id, const std::string &name) + { + originalNames.insert({id, name}); + } + void addSamplerBinding(const std::string &name, size_t samplerBinding) + { + samplerBindings.insert({name, samplerBinding}); + } + void addTextureBinding(const std::string &name, size_t textureBinding) + { + textureBindings.insert({name, textureBinding}); + } + void addUserUniformBufferBinding(const std::string &name, size_t userUniformBufferBinding) + { + userUniformBufferBindings.insert({name, userUniformBufferBinding}); + } + void addUniformBufferBinding(const std::string &name, UBOBindingInfo bindingInfo) + { + uniformBufferBindings.insert({name, bindingInfo}); + } + std::string getOriginalName(const size_t id) { return originalNames.at(id); } + samplerBindingMap getSamplerBindings() const { return samplerBindings; } + textureBindingMap getTextureBindings() const { return textureBindings; } + userUniformBufferBindingMap getUserUniformBufferBindings() const + { + return userUniformBufferBindings; + } + uniformBufferBindingMap getUniformBufferBindings() const { return uniformBufferBindings; } + size_t getSamplerBinding(const std::string &name) const + { + auto it = samplerBindings.find(name); + if (it != samplerBindings.end()) + { + return it->second; + } + // If we can't find a matching sampler, assert out on Debug, and return an invalid value on + // release. + ASSERT(0); + return std::numeric_limits<size_t>::max(); + } + size_t getTextureBinding(const std::string &name) const + { + auto it = textureBindings.find(name); + if (it != textureBindings.end()) + { + return it->second; + } + // If we can't find a matching texture, assert out on Debug, and return an invalid value on + // release. + ASSERT(0); + return std::numeric_limits<size_t>::max(); + } + size_t getUserUniformBufferBinding(const std::string &name) const + { + auto it = userUniformBufferBindings.find(name); + if (it != userUniformBufferBindings.end()) + { + return it->second; + } + // If we can't find a matching Uniform binding, assert out on Debug, and return an invalid + // value. + ASSERT(0); + return std::numeric_limits<size_t>::max(); + } + UBOBindingInfo getUniformBufferBinding(const std::string &name) const + { + auto it = uniformBufferBindings.find(name); + if (it != uniformBufferBindings.end()) + { + return it->second; + } + // If we can't find a matching UBO binding by name, assert out on Debug, and return an + // invalid value. + ASSERT(0); + return {.bindIndex = std::numeric_limits<size_t>::max(), + .arraySize = std::numeric_limits<size_t>::max()}; + } + void reset() + { + hasUBOs = false; + hasFlatInput = false; + hasAtan = false; + hasInvariance = false; + originalNames.clear(); + samplerBindings.clear(); + textureBindings.clear(); + userUniformBufferBindings.clear(); + uniformBufferBindings.clear(); + } + + bool hasUBOs = false; + bool hasFlatInput = false; + bool hasAtan = false; + bool hasInvariance = false; + + private: + originalNamesMap originalNames; + samplerBindingMap samplerBindings; + textureBindingMap textureBindings; + userUniformBufferBindingMap userUniformBufferBindings; + uniformBufferBindingMap uniformBufferBindings; +}; + +class TranslatorMetalDirect : public TCompiler +{ + public: + TranslatorMetalDirect(sh::GLenum type, ShShaderSpec spec, ShShaderOutput output); + +#ifdef ANGLE_ENABLE_METAL + TranslatorMetalDirect *getAsTranslatorMetalDirect() override { return this; } +#endif + + TranslatorMetalReflection *getTranslatorMetalReflection() { return &translatorMetalReflection; } + + protected: + bool translate(TIntermBlock *root, + const ShCompileOptions &compileOptions, + PerformanceDiagnostics *perfDiagnostics) override; + + // The sample mask can't be in our fragment output struct if we read the framebuffer. Luckily, + // pixel local storage bans gl_SampleMask, so we can just not use it when PLS is active. + bool usesSampleMask() const { return !hasPixelLocalStorageUniforms(); } + + // Need to collect variables so that RemoveInactiveInterfaceVariables works. + bool shouldCollectVariables(const ShCompileOptions &compileOptions) override { return true; } + + [[nodiscard]] bool translateImpl(TInfoSinkBase &sink, + TIntermBlock *root, + const ShCompileOptions &compileOptions, + PerformanceDiagnostics *perfDiagnostics, + SpecConst *specConst, + DriverUniformMetal *driverUniforms); + + [[nodiscard]] bool shouldFlattenPragmaStdglInvariantAll() override; + + [[nodiscard]] bool transformDepthBeforeCorrection(TIntermBlock *root, + const DriverUniformMetal *driverUniforms); + + [[nodiscard]] bool appendVertexShaderDepthCorrectionToMain(TIntermBlock *root); + + [[nodiscard]] bool insertSampleMaskWritingLogic(TIntermBlock &root, + DriverUniformMetal &driverUniforms); + [[nodiscard]] bool insertRasterizationDiscardLogic(TIntermBlock &root); + + TranslatorMetalReflection translatorMetalReflection = {}; +}; + +} // namespace sh + +#endif // COMPILER_TRANSLATOR_TRANSLATORMETALDIRECT_H_ |