GLSL Utils: added GetGLSLExtensions function

Author: TheMostDiligent

Graphics/ShaderTools/include/GLSLUtils.hpp

@@ -27,6 +27,10 @@
 
 #pragma once
 
+#include <vector>
+#include <string>
+#include <utility>
+
 #include "BasicTypes.h"
 #include "GraphicsTypes.h"
 #include "Shader.h"
@@ -73,4 +77,8 @@ void GetGLSLVersion(const ShaderCreateInfo&              ShaderCI,
                     ShaderVersion&                       GLSLVer,
                     bool&                                IsES);
 
+/// Extracts all #extension directives from the GLSL source, returning them as a vector of pairs
+/// (extension name, extension behavior). The behavior is the string following the extension name.
+std::vector<std::pair<std::string, std::string>> GetGLSLExtensions(const char* Source, size_t SourceLen = 0);
+
 } // namespace Diligent

Graphics/ShaderTools/src/GLSLUtils.cpp

@@ -36,6 +36,7 @@
 #include "RefCntAutoPtr.hpp"
 #include "DataBlobImpl.hpp"
 #include "ShaderToolsCommon.hpp"
+#include "ParsingTools.hpp"
 
 namespace Diligent
 {
@@ -403,4 +404,79 @@ String BuildGLSLSourceString(const BuildGLSLSourceStringAttribs& Attribs) noexce
     return GLSLSource;
 }
 
+std::vector<std::pair<std::string, std::string>> GetGLSLExtensions(const char* Source, size_t SourceLen)
+{
+    if (Source == nullptr)
+        return {};
+
+    if (SourceLen == 0)
+        SourceLen = std::strlen(Source);
+
+    std::vector<std::pair<std::string, std::string>> Extensions;
+
+    const auto*       Pos = Source;
+    const auto* const End = Source + SourceLen;
+    while (Pos != End)
+    {
+        const char *NameStart = nullptr, *NameEnd = nullptr;
+        Pos = Parsing::FindNextPreprocessorDirective(Pos, End, NameStart, NameEnd);
+        if (Pos == End)
+            break;
+
+        VERIFY_EXPR(*Pos == '#');
+
+        // # extension GL_ARB_shader_draw_parameters : enable
+        // ^ ^        ^
+        // | |      NameEnd
+        // | NameStart
+        // Pos
+
+        const auto* LineEnd = Parsing::SkipLine(NameEnd, End, /* GoToNextLine = */ false);
+
+        std::string DirectiveIdentifier{NameStart, NameEnd};
+        if (DirectiveIdentifier == "extension")
+        {
+            const auto* ExtNameStart = Parsing::SkipDelimiters(NameEnd, LineEnd, " \t");
+            // # extension GL_ARB_shader_draw_parameters : enable
+            //             ^
+            //             ExtNameStart
+
+            const auto* ExtNameEnd = Parsing::SkipIdentifier(ExtNameStart, LineEnd);
+            // # extension GL_ARB_shader_draw_parameters : enable
+            //                                          ^
+            //                                     ExtNameStart
+
+            std::string ExtensionName{ExtNameStart, ExtNameEnd};
+            if (!ExtensionName.empty())
+            {
+                Pos = ExtNameEnd;
+                while (Pos != LineEnd && *Pos != ':')
+                    ++Pos;
+
+                std::string ExtensionBehavior;
+                if (Pos != LineEnd && *Pos == ':')
+                {
+                    const auto* BehaviorStart = Parsing::SkipDelimiters(Pos + 1, LineEnd, " \t");
+                    // # extension GL_ARB_shader_draw_parameters : enable
+                    //                                             ^
+                    //                                         BehaviorStart
+
+                    const auto* BehaviorEnd = Parsing::SkipIdentifier(BehaviorStart, LineEnd);
+                    // # extension GL_ARB_shader_draw_parameters : enable
+                    //                                                   ^
+                    //                                               BehaviorEnd
+
+                    ExtensionBehavior.assign(BehaviorStart, BehaviorEnd);
+                }
+
+                Extensions.emplace_back(std::move(ExtensionName), std::move(ExtensionBehavior));
+            }
+        }
+
+        Pos = Parsing::SkipLine(LineEnd, End, /* GoToNextLine = */ true);
+    }
+
+    return Extensions;
+}
+
 } // namespace Diligent

Tests/DiligentCoreTest/CMakeLists.txt

@@ -9,6 +9,10 @@ project(DiligentCoreTest)
 file(GLOB_RECURSE SOURCE  src/*.*)
 file(GLOB_RECURSE SHADERS assets/shaders/*.*)
 
+if(NOT GL_SUPPORTED AND NOT GLES_SUPPORTED AND NOT VULKAN_SUPPORTED)
+    list(REMOVE_ITEM SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/src/ShaderTools/GLSLUtilsTest.cpp)
+endif()
+
 set_source_files_properties(${SHADERS} PROPERTIES VS_TOOL_OVERRIDE "None")
 
 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")

Tests/DiligentCoreTest/src/ShaderTools/GLSLUtilsTest.cpp

@@ -0,0 +1,66 @@
+/*
+ *  Copyright 2024 Diligent Graphics LLC
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  In no event and under no legal theory, whether in tort (including negligence),
+ *  contract, or otherwise, unless required by applicable law (such as deliberate
+ *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
+ *  liable for any damages, including any direct, indirect, special, incidental,
+ *  or consequential damages of any character arising as a result of this License or
+ *  out of the use or inability to use the software (including but not limited to damages
+ *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and
+ *  all other commercial damages or losses), even if such Contributor has been advised
+ *  of the possibility of such damages.
+ */
+
+#include "GLSLUtils.hpp"
+
+#include "TestingEnvironment.hpp"
+#include "gtest/gtest.h"
+
+using namespace Diligent;
+using namespace Diligent::Testing;
+
+namespace
+{
+
+TEST(GLSLUtilsTest, GetGLSLExtensions)
+{
+    auto Test = [](const std::string& Source, const std::vector<std::pair<std::string, std::string>>& RefExtensions) {
+        auto Extensions = GetGLSLExtensions(Source.c_str(), Source.length());
+        EXPECT_EQ(Extensions.size(), RefExtensions.size());
+
+        for (size_t i = 0; i < std::min(Extensions.size(), RefExtensions.size()); ++i)
+        {
+            EXPECT_EQ(Extensions[i].first, RefExtensions[i].first);
+            EXPECT_EQ(Extensions[i].second, RefExtensions[i].second);
+        }
+    };
+
+    Test("", {});
+    Test("#", {});
+    Test("# define", {});
+    Test("# extension", {});
+    Test("# extension ABC", {{"ABC", ""}});
+    Test("# extension : enable", {});
+    Test("# extension ABC : enable", {{"ABC", "enable"}});
+
+    Test(R"(
+# extension ABC : enable
+# extension XYZ : require
+)",
+         {{"ABC", "enable"}, {"XYZ", "require"}});
+}
+
+} // namespace