Vulkan: Implement basic uniform shader parsing.

src/common/string_utils.cpp

@@ -187,4 +187,17 @@ void ToLower(std::string *str)
     }
 }
 
+bool ReplaceSubstring(std::string *str,
+                      const std::string &substring,
+                      const std::string &replacement)
+{
+    size_t replacePos = str->find(substring);
+    if (replacePos == std::string::npos)
+    {
+        return false;
+    }
+    str->replace(replacePos, substring.size(), replacement);
+    return true;
+}
+
 }  // namespace angle

src/common/string_utils.h

@@ -65,6 +65,12 @@ bool EndsWith(const std::string& str, const char* suffix);
 
 // Convert to lower-case.
 void ToLower(std::string *str);
-}
+
+// Replaces the substring 'substring' in 'str' with 'replacement'. Returns true if successful.
+bool ReplaceSubstring(std::string *str,
+                      const std::string &substring,
+                      const std::string &replacement);
+
+}  // namespace angle
 
 #endif // LIBANGLE_STRING_UTILS_H_

src/compiler/translator/OutputGLSLBase.cpp

@@ -1104,10 +1104,7 @@ void TOutputGLSLBase::visitCodeBlock(TIntermBlock *node)
 
 TString TOutputGLSLBase::getTypeName(const TType &type)
 {
-    if (type.getBasicType() == EbtStruct)
-        return hashName(TName(type.getStruct()->name()));
-    else
-        return type.getBuiltInTypeNameString();
+    return GetTypeName(type, mHashFunction, &mNameMap);
 }
 
 TString TOutputGLSLBase::hashName(const TName &name)

src/compiler/translator/OutputVulkanGLSL.cpp

@@ -58,9 +58,14 @@ void TOutputVulkanGLSL::writeLayoutQualifier(TIntermTyped *variable)
     // This isn't super clean, but it gets the job done.
     // See corresponding code in GlslangWrapper.cpp.
     // TODO(jmadill): Ensure declarations are separated.
+
     TIntermSymbol *symbol = variable->getAsSymbolNode();
     ASSERT(symbol);
-    out << "location = @@ LOCATION-" << symbol->getName().getString() << " @@";
+
+    if (forceLocation)
+    {
+        out << "location = @@ LOCATION-" << symbol->getName().getString() << " @@";
+    }
 
     if (IsImage(type.getBasicType()) && layoutQualifier.imageInternalFormat != EiifUnspecified)
     {
@@ -71,14 +76,4 @@ void TOutputVulkanGLSL::writeLayoutQualifier(TIntermTyped *variable)
     out << ") ";
 }
 
-bool TOutputVulkanGLSL::writeVariablePrecision(TPrecision precision)
-{
-    if (precision == EbpUndefined)
-        return false;
-
-    TInfoSinkBase &out = objSink();
-    out << getPrecisionString(precision);
-    return true;
-}
-
 }  // namespace sh

src/compiler/translator/OutputVulkanGLSL.h

@@ -29,7 +29,6 @@ class TOutputVulkanGLSL : public TOutputGLSL
 
   protected:
     void writeLayoutQualifier(TIntermTyped *variable) override;
-    bool writeVariablePrecision(TPrecision precision) override;
 };
 
 }  // namespace sh

src/compiler/translator/TranslatorVulkan.cpp

@@ -13,10 +13,82 @@
 
 #include "angle_gl.h"
 #include "compiler/translator/OutputVulkanGLSL.h"
+#include "compiler/translator/util.h"
 
 namespace sh
 {
 
+class DeclareDefaultUniformsTraverser : public TIntermTraverser
+{
+  public:
+    DeclareDefaultUniformsTraverser(TInfoSinkBase *sink,
+                                    ShHashFunction64 hashFunction,
+                                    NameMap *nameMap)
+        : TIntermTraverser(true, true, true),
+          mSink(sink),
+          mHashFunction(hashFunction),
+          mNameMap(nameMap),
+          mInDefaultUniform(false)
+    {
+    }
+
+    bool visitDeclaration(Visit visit, TIntermDeclaration *node) override
+    {
+        const TIntermSequence &sequence = *(node->getSequence());
+
+        // TODO(jmadill): Compound declarations.
+        ASSERT(sequence.size() == 1);
+
+        TIntermTyped *variable = sequence.front()->getAsTyped();
+        const TType &type      = variable->getType();
+        bool isUniform         = (type.getQualifier() == EvqUniform);
+
+        if (visit == PreVisit)
+        {
+            if (isUniform)
+            {
+                (*mSink) << "    " << GetTypeName(type, mHashFunction, mNameMap) << " ";
+                mInDefaultUniform = true;
+            }
+        }
+        else if (visit == InVisit)
+        {
+            mInDefaultUniform = isUniform;
+        }
+        else if (visit == PostVisit)
+        {
+            if (isUniform)
+            {
+                (*mSink) << ";\n";
+            }
+
+            mInDefaultUniform = false;
+
+            // Remove the uniform declaration from the tree so it isn't parsed again.
+            TIntermSequence emptyReplacement;
+            mMultiReplacements.push_back(NodeReplaceWithMultipleEntry(getParentNode()->getAsBlock(),
+                                                                      node, emptyReplacement));
+        }
+        return true;
+    }
+
+    void visitSymbol(TIntermSymbol *symbol) override
+    {
+        if (mInDefaultUniform)
+        {
+            const TName &name = symbol->getName();
+            ASSERT(name.getString().substr(0, 3) != "gl_");
+            (*mSink) << HashName(name, mHashFunction, mNameMap);
+        }
+    }
+
+  private:
+    TInfoSinkBase *mSink;
+    ShHashFunction64 mHashFunction;
+    NameMap *mNameMap;
+    bool mInDefaultUniform;
+};
+
 TranslatorVulkan::TranslatorVulkan(sh::GLenum type, ShShaderSpec spec)
     : TCompiler(type, spec, SH_GLSL_450_CORE_OUTPUT)
 {
@@ -28,6 +100,18 @@ void TranslatorVulkan::translate(TIntermBlock *root, ShCompileOptions compileOpt
 
     sink << "#version 450 core\n";
 
+    // Write out default uniforms into a uniform block assigned to a specific set/binding.
+    if (!getUniforms().empty())
+    {
+        sink << "\nlayout(@@ DEFAULT-UNIFORMS-SET-BINDING @@) uniform defaultUniforms\n{\n";
+
+        DeclareDefaultUniformsTraverser defaultTraverser(&sink, getHashFunction(), &getNameMap());
+        root->traverse(&defaultTraverser);
+        defaultTraverser.updateTree();
+
+        sink << "};\n";
+    }
+
     // Declare gl_FragColor and glFragData as webgl_FragColor and webgl_FragData
     // if it's core profile shaders and they are used.
     if (getShaderType() == GL_FRAGMENT_SHADER)

src/compiler/translator/util.cpp

@@ -447,6 +447,14 @@ TString ArrayString(const TType &type)
     return arrayString.str();
 }
 
+TString GetTypeName(const TType &type, ShHashFunction64 hashFunction, NameMap *nameMap)
+{
+    if (type.getBasicType() == EbtStruct)
+        return HashName(TName(type.getStruct()->name()), hashFunction, nameMap);
+    else
+        return type.getBuiltInTypeNameString();
+}
+
 bool IsVaryingOut(TQualifier qualifier)
 {
     switch (qualifier)

src/compiler/translator/util.h

@@ -12,6 +12,7 @@
 #include "angle_gl.h"
 #include <GLSLANG/ShaderLang.h>
 
+#include "compiler/translator/HashNames.h"
 #include "compiler/translator/Operator.h"
 #include "compiler/translator/Types.h"
 
@@ -44,6 +45,8 @@ InterpolationType GetInterpolationType(TQualifier qualifier);
 // 3.10 section 4.1.9.
 TString ArrayString(const TType &type);
 
+TString GetTypeName(const TType &type, ShHashFunction64 hashFunction, NameMap *nameMap);
+
 TType GetShaderVariableBasicType(const sh::ShaderVariable &var);
 
 bool IsBuiltinOutputVariable(TQualifier qualifier);

src/libANGLE/renderer/d3d/DynamicHLSL.cpp

@@ -8,6 +8,7 @@
 
 #include "libANGLE/renderer/d3d/DynamicHLSL.h"
 
+#include "common/string_utils.h"
 #include "common/utilities.h"
 #include "compiler/translator/blocklayoutHLSL.h"
 #include "libANGLE/Context.h"
@@ -272,8 +273,9 @@ std::string DynamicHLSL::generateVertexShaderForInputLayout(
 
     std::string vertexHLSL(sourceShader);
 
-    size_t copyInsertionPos = vertexHLSL.find(VERTEX_ATTRIBUTE_STUB_STRING);
-    vertexHLSL.replace(copyInsertionPos, strlen(VERTEX_ATTRIBUTE_STUB_STRING), structStream.str());
+    bool success =
+        angle::ReplaceSubstring(&vertexHLSL, VERTEX_ATTRIBUTE_STUB_STRING, structStream.str());
+    ASSERT(success);
 
     return vertexHLSL;
 }
@@ -348,9 +350,9 @@ std::string DynamicHLSL::generatePixelShaderForOutputSignature(
 
     std::string pixelHLSL(sourceShader);
 
-    size_t outputInsertionPos = pixelHLSL.find(PIXEL_OUTPUT_STUB_STRING);
-    pixelHLSL.replace(outputInsertionPos, strlen(PIXEL_OUTPUT_STUB_STRING),
-                      declarationStream.str());
+    bool success =
+        angle::ReplaceSubstring(&pixelHLSL, PIXEL_OUTPUT_STUB_STRING, declarationStream.str());
+    ASSERT(success);
 
     return pixelHLSL;
 }

src/libANGLE/renderer/vulkan/GlslangWrapper.cpp

@@ -18,6 +18,8 @@
 
 #include <array>
 
+#include "common/string_utils.h"
+
 namespace rx
 {
 
@@ -70,7 +72,7 @@ gl::LinkResult GlslangWrapper::linkProgram(const gl::Context *glContext,
 {
     std::string vertexSource =
         programState.getAttachedVertexShader()->getTranslatedSource(glContext);
-    const std::string &fragmentSource =
+    std::string fragmentSource =
         programState.getAttachedFragmentShader()->getTranslatedSource(glContext);
 
     // Parse attribute locations and replace them in the vertex shader.
@@ -87,11 +89,22 @@ gl::LinkResult GlslangWrapper::linkProgram(const gl::Context *glContext,
 
         std::string locationString = Str(attribute.location);
 
-        size_t replacePos = vertexSource.find(searchString);
-        ASSERT(replacePos != std::string::npos);
-        vertexSource.replace(replacePos, searchString.size(), locationString);
+        bool success = angle::ReplaceSubstring(&vertexSource, searchString, locationString);
+        ASSERT(success);
     }
 
+    // Bind the default uniforms for vertex and fragment shaders.
+    // See corresponding code in OutputVulkanGLSL.cpp.
+    std::stringstream searchStringBuilder;
+    searchStringBuilder << "@@ DEFAULT-UNIFORMS-SET-BINDING @@";
+    std::string searchString = searchStringBuilder.str();
+
+    std::string vertexDefaultUniformsBinding   = "set = 0, binding = 0";
+    std::string fragmentDefaultUniformsBinding = "set = 0, binding = 1";
+
+    angle::ReplaceSubstring(&vertexSource, searchString, vertexDefaultUniformsBinding);
+    angle::ReplaceSubstring(&fragmentSource, searchString, fragmentDefaultUniformsBinding);
+
     std::array<const char *, 2> strings = {{vertexSource.c_str(), fragmentSource.c_str()}};
 
     std::array<int, 2> lengths = {

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -531,6 +531,8 @@ void RendererVk::generateCaps(gl::Caps *outCaps,
     outCaps->maxCombinedTextureImageUnits = 1;
     outCaps->max2DTextureSize             = 1024;
     outCaps->maxElementIndex              = std::numeric_limits<GLuint>::max() - 1;
+    outCaps->maxFragmentUniformVectors    = 8;
+    outCaps->maxVertexUniformVectors      = 8;
 
     // Enable this for simple buffer readback testing, but some functionality is missing.
     // TODO(jmadill): Support full mapBufferRange extension.

src/tests/gl_tests/SimpleOperationTest.cpp

@@ -108,13 +108,6 @@ TEST_P(SimpleOperationTest, LinkProgram)
 
 TEST_P(SimpleOperationTest, LinkProgramWithUniforms)
 {
-    if (IsVulkan())
-    {
-        // TODO(jmadill): Complete Vulkan implementation.
-        std::cout << "Test skipped on Vulkan." << std::endl;
-        return;
-    }
-
     const std::string vsSource =
         R"(void main()
         {