Store a map of interface block registers.

include/GLSLANG/ShaderLang.h

@@ -43,7 +43,7 @@ extern "C" {
 
 // Version number for shader translation API.
 // It is incremented every time the API changes.
-#define ANGLE_SH_VERSION 126
+#define ANGLE_SH_VERSION 127
 
 typedef enum {
   SH_GLES2_SPEC = 0x8B40,
@@ -480,6 +480,17 @@ COMPILER_EXPORT int ShCheckVariablesWithinPackingLimits(
     ShVariableInfo* varInfoArray,
     size_t varInfoArraySize);
 
+// Gives the compiler-assigned register for an interface block.
+// The method writes the value to the output variable "indexOut".
+// Returns true if it found a valid interface block, false otherwise.
+// Parameters:
+// handle: Specifies the compiler
+// interfaceBlockName: Specifies the interface block
+// indexOut: output variable that stores the assigned register
+COMPILER_EXPORT bool ShGetInterfaceBlockRegister(const ShHandle handle,
+                                                 const char *interfaceBlockName,
+                                                 unsigned int *indexOut);
+
 #ifdef __cplusplus
 }
 #endif

src/compiler/translator/OutputHLSL.cpp

@@ -237,6 +237,11 @@ const std::vector<sh::Varying> &OutputHLSL::getVaryings() const
     return mActiveVaryings;
 }
 
+const std::map<std::string, unsigned int> &OutputHLSL::getInterfaceBlockRegisterMap() const
+{
+    return mUniformHLSL->getInterfaceBlockRegisterMap();
+}
+
 int OutputHLSL::vectorSize(const TType &type) const
 {
     int elementSize = type.isMatrix() ? type.getCols() : 1;

src/compiler/translator/OutputHLSL.h

@@ -39,6 +39,8 @@ class OutputHLSL : public TIntermTraverser
     const std::vector<sh::Attribute> &getAttributes() const;
     const std::vector<sh::Varying> &getVaryings() const;
 
+    const std::map<std::string, unsigned int> &getInterfaceBlockRegisterMap() const;
+
     static TString initializer(const TType &type);
 
   protected:

src/compiler/translator/ShaderLang.cpp

@@ -474,3 +474,28 @@ int ShCheckVariablesWithinPackingLimits(
     VariablePacker packer;
     return packer.CheckVariablesWithinPackingLimits(maxVectors, variables) ? 1 : 0;
 }
+
+bool ShGetInterfaceBlockRegister(const ShHandle handle,
+                                 const char *interfaceBlockName,
+                                 unsigned int *indexOut)
+{
+    if (!handle || !interfaceBlockName || !indexOut)
+    {
+        return false;
+    }
+
+    TShHandleBase* base = static_cast<TShHandleBase*>(handle);
+    TranslatorHLSL* translator = base->getAsTranslatorHLSL();
+    if (!translator)
+    {
+        return false;
+    }
+
+    if (!translator->hasInterfaceBlock(interfaceBlockName))
+    {
+        return false;
+    }
+
+    *indexOut = translator->getInterfaceBlockRegister(interfaceBlockName);
+    return true;
+}

src/compiler/translator/TranslatorHLSL.cpp

@@ -26,4 +26,17 @@ void TranslatorHLSL::translate(TIntermNode *root)
     uniforms        = outputHLSL.getUniforms();
     varyings        = outputHLSL.getVaryings();
     interfaceBlocks = outputHLSL.getInterfaceBlocks();
+
+    mInterfaceBlockRegisterMap = outputHLSL.getInterfaceBlockRegisterMap();
+}
+
+bool TranslatorHLSL::hasInterfaceBlock(const std::string &interfaceBlockName) const
+{
+    return (mInterfaceBlockRegisterMap.count(interfaceBlockName) > 0);
+}
+
+unsigned int TranslatorHLSL::getInterfaceBlockRegister(const std::string &interfaceBlockName) const
+{
+    ASSERT(hasInterfaceBlock(interfaceBlockName));
+    return mInterfaceBlockRegisterMap.find(interfaceBlockName)->second;
 }

src/compiler/translator/TranslatorHLSL.h

@@ -16,8 +16,13 @@ class TranslatorHLSL : public TCompiler
     TranslatorHLSL(sh::GLenum type, ShShaderSpec spec, ShShaderOutput output);
     virtual TranslatorHLSL *getAsTranslatorHLSL() { return this; }
 
+    bool hasInterfaceBlock(const std::string &interfaceBlockName) const;
+    unsigned int getInterfaceBlockRegister(const std::string &interfaceBlockName) const;
+
   protected:
     virtual void translate(TIntermNode* root);
+
+    std::map<std::string, unsigned int> mInterfaceBlockRegisterMap;
 };
 
 #endif  // COMPILER_TRANSLATORHLSL_H_

src/compiler/translator/UniformHLSL.cpp

@@ -236,6 +236,7 @@ TString UniformHLSL::interfaceBlocksHeader(const ReferencedSymbols &referencedIn
             traverser.traverse(*field.type(), fullFieldName);
         }
 
+        mInterfaceBlockRegisterMap[activeBlock.name] = mInterfaceBlockRegister;
         mInterfaceBlockRegister += std::max(1u, arraySize);
 
         BlockLayoutType blockLayoutType = GetBlockLayoutType(interfaceBlock.blockStorage());

src/compiler/translator/UniformHLSL.h

@@ -32,6 +32,10 @@ class UniformHLSL
 
     const std::vector<Uniform> &getUniforms() const { return mActiveUniforms; }
     const std::vector<InterfaceBlock> &getInterfaceBlocks() const { return mActiveInterfaceBlocks; }
+    const std::map<std::string, unsigned int> &getInterfaceBlockRegisterMap() const
+    {
+        return mInterfaceBlockRegisterMap;
+    }
 
   private:
     TString interfaceBlockString(const TInterfaceBlock &interfaceBlock, unsigned int registerIndex, unsigned int arrayIndex);
@@ -50,6 +54,7 @@ class UniformHLSL
 
     std::vector<Uniform> mActiveUniforms;
     std::vector<InterfaceBlock> mActiveInterfaceBlocks;
+    std::map<std::string, unsigned int> mInterfaceBlockRegisterMap;
 };
 
 }