@@ -17,6 +17,7 @@ add_library(${PROJECT_NAME})

 include(common.cmake)

 common(

     CXX_STANDARD 11

+    DISABLE_WSHADOW

     PACKAGES

         OpenGL

         GLEW

@@ -169,6 +169,39 @@ defines)` are injected after the `#version`. `Shader::Defines` is an alias for

 [`#define`]: https://www.khronos.org/opengl/wiki/Core_Language_(GLSL)#Preprocessor_directives

+#### `#include`s

+

+Support for [`#include`][]s is provided, with the same syntax as the

+[`ARB_shading_language_include`][] extension. An `#include`d path must be

+surrounded by `<` `>`, in which case it is treated as relative to

+[`root`](#loading-files), or by `"` `"`, in which case it is treated as

+relative to the including file.

+

+Even though the extension is not used for including files, an `#extension

+GL_ARB_shading_language_include : require` line is required for portability,

+otherwise an error is thrown. The line is silently dropped before the source is

+fed to OpenGL so as to not upset the shader compiler if the extension is not

+available.

+

+If the [`ARB_shading_language_include`][] extension is available, `#line`

+statements that include the file path are injected before every line (after the

+`#version`) to improve error messages from the shader compiler.

+

+Note that the `#include` statements are expanded before the source is fed to

+OpenGL, and therefore before the [GLSL preprocessor][] is run which means

+things like [include guard][]s do not work. (For portability, it is recommended

+that include guards be used anyway.) Circular includes are broken by skipping

+`#include`s where the *including file, line number, included file* tuple has

+been seen before.

+

+[`#include`]: https://www.khronos.org/opengl/wiki/Core_Language_(GLSL)#Preprocessor_directives

+[`glCompileShader`]: https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glCompileShader.xhtml

+[GLSL preprocessor]: https://www.khronos.org/opengl/wiki/Core_Language_(GLSL)#Preprocessor_directives

+[include guard]: https://en.wikipedia.org/wiki/Include_guard

+[`ARB_shading_language_include`]: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_shading_language_include.txt

+[`glNamedStringARB`]: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_shading_language_include.txt

+[`glCompileShaderIncludeARB`]: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_shading_language_include.txt

+

 ## Dependencies

 Public (interface):

@@ -1,7 +1,13 @@

 #version 110

+#extension GL_ARB_shading_language_include : require

+

+

+#include "all_green.h"

+

+

 void main()

 {

-    gl_FragColor = vec4(red, 0.5, 0.25, 1.0);

+    gl_FragColor = vec4(red, green, 0.25, 1.0);

 }

@@ -1,6 +1,23 @@

 #version 110

+#extension GL_ARB_shading_language_include : require

+

+

+#include <tests/all_topdir.h>

+#include "all_topdir.h"

+#include <tests/all_subdir/all_subdir.h>

+#include "all_subdir/all_subdir.h"

+#include </tests/all_topdir.h>

+#include "/all_topdir.h"

+#include </tests/all_subdir/all_subdir.h>

+#include "/all_subdir/all_subdir.h"

+#include "all_recursive.h"

+#include <tests/all_recursive.h>

+#include "all_subdir/all_recursive.h"

+#include <tests/all_subdir/all_recursive.h>

+

+

 void main()

 {

     gl_Position = gl_Vertex;

new file mode 100644

@@ -0,0 +1 @@

+#define green 0.5

new file mode 100644

@@ -0,0 +1,9 @@

+#ifndef RECURSIVE_H_

+#define RECURSIVE_H_

+

+

+#include "all_recursive.h"

+#include <tests/all_recursive.h>

+

+

+#endif // RECURSIVE_H_

new file mode 100644

@@ -0,0 +1,11 @@

+#ifndef SUBDIR_RECURSIVE_H_

+#define SUBDIR_RECURSIVE_H_

+

+

+#include <tests/all_subdir/all_recursive.h>

+#include "../all_subdir/all_recursive.h"

+#include <../../../../../tests/all_subdir/all_recursive.h>

+#include "../../../../../tests/all_subdir/all_recursive.h"

+

+

+#endif // SUBDIR_RECURSIVE_H_

new file mode 100644

@@ -0,0 +1,2 @@

+#include <tests/all_topdir.h>

+#include "all_subdir_other.h"

new file mode 100644

new file mode 100644

new file mode 100644

@@ -0,0 +1,13 @@

+#version 110

+

+

+#extension GL_ARB_shading_language_include : require

+

+

+#include "bad_include_malformed.h" malformed.h"

+

+

+void main()

+{

+    gl_Position = gl_Vertex;

+}

new file mode 100644

@@ -0,0 +1,10 @@

+#version 110

+

+

+#extension extension

+

+

+void main()

+{

+    gl_Position = gl_Vertex;

+}

new file mode 100644

@@ -0,0 +1,13 @@

+#version 110

+

+

+#extension GL_ARB_shading_language_include : require

+

+

+#include "bad_include_quotes.h>

+

+

+void main()

+{

+    gl_Position = gl_Vertex;

+}

new file mode 100644

@@ -0,0 +1 @@

+#extension GL_ARB_shading_language_include : require

new file mode 100644

@@ -0,0 +1,13 @@

+#version 110

+

+

+#extension GL_ARB_shading_language_include : require

+

+

+#include "include_nested_extension.h"

+

+

+void main()

+{

+    gl_Position = gl_Vertex;

+}

new file mode 100644

@@ -0,0 +1 @@

+#version 110

new file mode 100644

@@ -0,0 +1,13 @@

+#version 110

+

+

+#extension GL_ARB_shading_language_include : require

+

+

+#include "include_nested_version.h"

+

+

+void main()

+{

+    gl_Position = gl_Vertex;

+}

new file mode 100644

@@ -0,0 +1,10 @@

+#version 110

+

+

+#include "bad_include_noextension.h"

+

+

+void main()

+{

+    gl_Position = gl_Vertex;

+}

new file mode 100644

@@ -0,0 +1,13 @@

+#version 110

+

+

+#extension GL_ARB_shading_language_include : require

+

+

+#include "bad_include_nonexistent.h"

+

+

+void main()

+{

+    gl_Position = gl_Vertex;

+}

@@ -5,6 +5,7 @@

 #include <cerrno>

 #include <cstring>

 #include <fstream>

+#include <list>

 #include <memory>

 #include <regex>

 #include <sstream>

@@ -81,21 +82,48 @@ static std::string source_(

     std::string const & error,

     std::string const & path,

     std::string const & root,

-    Shader::Defines const & defines

+    Shader::Defines const & defines,

+    std::string extension_behavior = {},

+    std::list<Here> included_by = {}

 )

 {

     // Set here error.

-    auto const here_error = [](Here const & here)

+    auto const here_error = [&](std::list<Here> const & include_here)

     {

-        return STR(

-            std::get<0>(here) << ":" <<

-            std::get<1>(here) << ": " <<

-            std::get<2>(here)

+        return STR_JOIN(

+            "\n",

+            it,

+            std::get<0>(it) << ":" <<

+            std::get<1>(it) << ": " <<

+            std::get<2>(it),

+            include_here

         );

     };

+    // Set include helper.

+    auto const include_here = [&](Here const & here)

+    {

+        auto include_here = included_by;

+        include_here.push_front(here);

+        return include_here;

+    };

+

     // Set full path.

-    auto path_full = path;

+    auto path_full = std::string{};

+    {

+        auto istream = std::istringstream(path);

+        auto part    = std::string{};

+        auto parts   = std::vector<std::string>{};

+        parts.reserve((size_t)std::count(path.begin(), path.end(), '/') + 1);

+        while (std::getline(istream, part, '/'))

+        {

+            if (part == ".." && !parts.empty())

+                parts.pop_back();

+            if (part != ".." && part != ".")

+                parts.push_back(std::move(part));

+        }

+        path_full = STR_JOIN('/', it, it, parts);

+    }

     if (!root.empty())

         path_full = STR(root << "/" << path_full);

@@ -105,6 +133,7 @@ static std::string source_(

         throw std::runtime_error{STR(

             error << "; " <<

             "could not open file '" << path_full << "':\n" <<

+            here_error(included_by) << (included_by.empty() ? "" : ":\n") <<

             std::strerror(errno)

         )};

@@ -112,16 +141,21 @@ static std::string source_(

     auto ostream = std::ostringstream{};

     // Define parse regexes.

-    static auto const re_ignored = std::regex{R"(\s*//.*$)"};

-    static auto const re_words   = std::regex{R"((\w+(?:\s+\w+)*))"};

-    static auto const re_version = std::regex{R"(\s*#\s*version\s*(.*))"};

+    static auto const re_ignored   = std::regex{R"(\s*//.*$)"};

+    static auto const re_words     = std::regex{R"((\w+(?:\s+\w+)*))"};

+    static auto const re_spec      = std::regex{R"((\w+)\s*:\s*(\w+))"};

+    static auto const re_quoted    = std::regex{R"((["<])([^">]*)([">]))"};

+    static auto const re_version   = std::regex{R"(\s*#\s*version\s*(.*))"};

+    static auto const re_extension = std::regex{R"(\s*#\s*extension\s*(.*))"};

+    static auto const re_include   = std::regex{R"(\s*#\s*include\s*(.*))"};

     // Parse.

-    auto version_number = 0;

-    auto line_number    = 0;

-    auto line           = std::string{};

-    auto match          = std::smatch{};

-    auto here           = [&]()

+    auto version_number    = 0;

+    auto extension_enabled = false;

+    auto line_number       = 0;

+    auto line              = std::string{};

+    auto match             = std::smatch{};

+    auto here              = [&]()

     {

         return Here{path_full, line_number, line};

     };

@@ -130,6 +164,16 @@ static std::string source_(

         // Remove ignored.

         auto const content = std::regex_replace(line, re_ignored, "");

+        // Output `#line`.

+        auto const line_number_offset = version_number < 330 ? -1 : 0;

+        if (GLEW_ARB_shading_language_include)

+            if (!extension_behavior.empty() && extension_behavior != "disable")

+                ostream

+                    << "#line" << " "

+                    << line_number + line_number_offset << " "

+                    << "\"" << path_full << "\""

+                    << "\n";

+

         // Process version.

         if (std::regex_match(content, match, re_version))

         {

@@ -139,7 +183,7 @@ static std::string source_(

                 throw std::runtime_error{STR(

                     error << "; " <<

                     "malformed #version:\n" <<

-                    here_error(here())

+                    here_error(include_here(here()))

                 )};

             auto const version = match.str(1);

@@ -148,7 +192,13 @@ static std::string source_(

                 throw std::runtime_error{STR(

                     error << "; " <<

                     "found repeated #version:\n" <<

-                    here_error(here())

+                    here_error(include_here(here()))

+                )};

+            if (!included_by.empty())

+                throw std::runtime_error{STR(

+                    error <<  "; " <<

+                    "found #version in #include:\n" <<

+                    here_error(include_here(here()))

                 )};

             // Process.

@@ -156,6 +206,16 @@ static std::string source_(

             // Output.

             ostream << line << "\n";

+            if (GLEW_ARB_shading_language_include)

+            {

+                if (extension_behavior.empty())

+                {

+                    extension_behavior = "enable";

+                    ostream

+                        << "#extension GL_ARB_shading_language_include : "

+                        << extension_behavior << "\n";

+                }

+            }

             for (auto const & define : defines)

                 ostream

                     << "#define "

@@ -163,6 +223,103 @@ static std::string source_(

                     << define.second << "\n";

         }

+        // Process extension.

+        else if (std::regex_match(content, match, re_extension))

+        {

+            // Parse.

+            auto const spec = match.str(1);

+            if (!std::regex_match(spec, match, re_spec))

+                throw std::runtime_error{STR(

+                    error << "; " <<

+                    "malformed #extension:\n" <<

+                    here_error(include_here(here()))

+                )};

+            auto const extension = match.str(1);

+            auto const behavior  = match.str(2);

+

+            if (extension == "GL_ARB_shading_language_include")

+            {

+                // Check for errors.

+                if (!included_by.empty())

+                    throw std::runtime_error{STR(

+                        error <<  "; " <<

+                        "found #extension GL_ARB_shading_language_include " <<

+                        "in #include:\n" <<

+                        here_error(include_here(here()))

+                    )};

+

+                // Process.

+                extension_enabled = behavior != "disable";

+                extension_behavior = behavior;

+                line = "";

+            }

+

+            // Output.

+            ostream << line << "\n";

+        }

+

+        // Process include.

+        else if (std::regex_match(content, match, re_include))

+        {

+            // Parse.

+            auto const quoted = match.str(1);

+            if (!std::regex_match(quoted, match, re_quoted))

+                throw std::runtime_error{STR(

+                    error << "; " <<

+                    "malformed #include:\n" <<

+                    here_error(include_here(here()))

+                )};

+            auto const quote_open   = match.str(1);

+            auto const include_path = match.str(2);

+            auto const quote_close  = match.str(3);

+

+            // Check for errors.

+            if (!(

+                (quote_open == "\"" && quote_close == "\"") ||

+                (quote_open == "<"  && quote_close == ">" )

+            ))

+                throw std::runtime_error{STR(

+                    error << "; " <<

+                    "mismatched #include quotes '" << quote_open << "' and '"

+                    << quote_close << "':\n" <<

+                    here_error(include_here(here()))

+                )};

+            if (!extension_enabled && included_by.empty())

+                throw std::runtime_error{STR(

+                    error << "; " <<

+                    "#include found but #extension " <<

+                    "GL_ARB_shading_language_include not enabled:\n" <<

+                    here_error(include_here(here()))

+                )};

+

+            // Process.

+            auto source = std::string{};

+            if (included_by.end() == std::find(

+                included_by.begin(), included_by.end(), here()

+            ))

+            {

+                auto include_path_full = include_path;

+                if (quote_open == "\"")

+                {

+                    auto const pos = path.rfind('/');

+                    if (pos != path.npos && pos != 0)

+                        include_path_full = STR(

+                            path.substr(0, pos + 1) << include_path

+                        );

+                }

+                source = source_(

+                    error,

+                    include_path_full, root,

+                    defines,

+                    extension_behavior,

+                    include_here(here())

+                );

+            }

+

+            // Output.

+            ostream << source << "\n";

+        }

+

         // Non-processed line.

         else

         {

@@ -172,7 +329,7 @@ static std::string source_(

     }

     // Check for version.

-    if (!version_number)

+    if (!version_number && included_by.empty())

         throw std::runtime_error{STR(

             error << "; " <<

             "found no #version."

@@ -31,7 +31,7 @@ GLTEST(2, 0, 640, 480, glshader)

     GLTEST_EXPECT_EXCEPTION(true,

         Shader({"tests/create_bad_compile.vert"}),

         "Failed to compile shader 'tests/create_bad_compile.vert' of shader program 'tests/create_bad_compile.vert':\n"

-        "0:4(5): error: main() must return void\n"

+        "\"assets/shaders/tests/create_bad_compile.vert\":4(5): error: main() must return void\n"

     )

     GLTEST_EXPECT_EXCEPTION(true,

         Shader({"tests/create_bad_link.vert"}),

@@ -78,6 +78,53 @@ GLTEST(2, 0, 640, 480, glshader)

         {"red", std::to_string(red)},

     });

+    // Include.

+    GLTEST_EXPECT_EXCEPTION(true,

+        Shader({"tests/include_malformed_extension.vert"}),

+        "Failed to source shader 'tests/include_malformed_extension.vert' of shader program 'tests/include_malformed_extension.vert'; "

+        "malformed #extension:\n"

+        "assets/shaders/tests/include_malformed_extension.vert:4: #extension extension"

+    )

+    GLTEST_EXPECT_EXCEPTION(true,

+        Shader({"tests/include_malformed.vert"}),

+        "Failed to source shader 'tests/include_malformed.vert' of shader program 'tests/include_malformed.vert'; "

+        "malformed #include:\n"

+        "assets/shaders/tests/include_malformed.vert:7: #include \"bad_include_malformed.h\" malformed.h\""

+    )

+    GLTEST_EXPECT_EXCEPTION(true,

+        Shader({"tests/include_mismatched_quotes.vert"}),

+        "Failed to source shader 'tests/include_mismatched_quotes.vert' of shader program 'tests/include_mismatched_quotes.vert'; "

+        "mismatched #include quotes '\"' and '>':\n"

+        "assets/shaders/tests/include_mismatched_quotes.vert:7: #include \"bad_include_quotes.h>"

+    )

+    GLTEST_EXPECT_EXCEPTION(true,

+        Shader({"tests/include_no_extension.vert"}),

+        "Failed to source shader 'tests/include_no_extension.vert' of shader program 'tests/include_no_extension.vert'; "

+        "#include found but #extension GL_ARB_shading_language_include not enabled:\n"

+        "assets/shaders/tests/include_no_extension.vert:4: #include \"bad_include_noextension.h\""

+    )

+    GLTEST_EXPECT_EXCEPTION(true,

+        Shader({"tests/include_nonexistent.vert"}),

+        "Failed to source shader 'tests/include_nonexistent.vert' of shader program 'tests/include_nonexistent.vert'; "

+        "could not open file 'assets/shaders/tests/bad_include_nonexistent.h':\n"

+        "assets/shaders/tests/include_nonexistent.vert:7: #include \"bad_include_nonexistent.h\":\n"

+        "No such file or directory"

+    )

+    GLTEST_EXPECT_EXCEPTION(false,

+        Shader({"tests/include_nested_version.vert"}),

+        "Failed to source shader 'tests/include_nested_version.vert' of shader program 'tests/include_nested_version.vert'; "

+        "found #version in #include:\n"

+        "assets/shaders/tests/include_nested_version.h:1: #version 110\n"

+        "assets/shaders/tests/include_nested_version.vert:7: #include \"include_nested_version.h\""

+    )

+    GLTEST_EXPECT_EXCEPTION(false,

+        Shader({"tests/include_nested_extension.vert"}),

+        "Failed to source shader 'tests/include_nested_extension.vert' of shader program 'tests/include_nested_extension.vert'; "

+        "found #extension GL_ARB_shading_language_include in #include:\n"

+        "assets/shaders/tests/include_nested_extension.h:1: #extension GL_ARB_shading_language_include : require\n"

+        "assets/shaders/tests/include_nested_extension.vert:7: #include \"include_nested_extension.h\""

+    )

+

     auto all = Shader({

         "tests/all.vert",

         "tests/all.frag",