Add the shader for UnlitMaterial

This was supposed to be in 2f198e3

Add extension file for NV_half_float

This should have been in 9087cc0 but went unnoticed for a month due to
how the extension headers are handled.

Add a unit test framework and some tests for the GLSL compiler

Some of the tests fail due to bugs in the compiler.

Add expression inlining

Make the iteration init statement a Statement instead of Node

Add a new associativity type for fully associative operators

Add some comments to the more complex parts of the GLSL compiler

Visit iteration statement components in semantically correct order

Minor, largely cosmetic tweaks

Remove some unnecessary bits

Fix an issue where member assignments were incorrectly optimized away

They are now treated as subfield assignments, same as array subscripts.

Don't copy type declaration of a generated interface variable

It's better to let it be resolved again.

Fix VariableResolver doing bogus things on certain invalid constructs

Fix passthroughs being generated for non-output variables

Rename members of visitors to indicate which are "return values"

Handle all constructs when inlining GLSL functions

We need to look for function calls inside conditional and iteration
statements too, and inline calls within condition expressions.

Fix a block management error in FunctionInliner

Add a missing #include

This was left out from d5c7c7f

Store a pointer to operator info rather than the token in expressions

Also make it a property of Expression rather than the subtypes.

Further improve inlining of GLSL functions

Functions of any lenght can now be inlined, as long as they have linear
control flow.

Clear previous state when resolving functions

Remove expression statements without side effects

Fix another case of future features leaking

Fix an issue with line numbers after #line being off-by-one

I had added the flag for this back in 1083ad1 but forgot to use it.

Explicitly call base class copy constructor for expressions

Refactor FunctionInliner to do any necessary declaration reordering

Clarify SL::Compiler::optimize return values by using an enum

Inject builtins into the module

This makes identifier resolution easier to manage and also helps an
eventual SPIR-V implementation.

Debug output tweaks

Clear the stage map at the beginning if a resolving pass

This avoids accidentally resolving things to a declarations which is not
visible to the reference.

Remove things that weren't supposed to go in yet

Store functions definitions in Stage

Move function override processing to FunctionResolver

Make the GLSL parser resilient against common errors

It will now attempt to continue parsing the source, with the intent of
reporting all syntax errors at once.

Add some documentation to the GLSL compiler

Fixes for compatibility with legacy unsized PixelFormats

Don't copy layouts to generated out interfaces

Use specialization constants in the builtin material shaders

This has the side effect that RenderPass now requires a collection
to use the builtin shaders.

Add interfaces for using specialization constants with Programs

This replaces the old way of redefining variables withing the GLSL
source, and as such the Program constructor from string is now
deprecated.

Support specialization constants in the GLSL compiler

Mostly cosmetic tweaks

Copy layouts when generating interfaces

Don't allow arbitrary statements in structs or interface blocks

Store types and interface blocks in Stage

They're only allowed at top level so it seems pointless for every block
to have the maps.

Populate the interface block map in VariableResolver

They're more variable-y than block-y.

Unlink declarations on destruction

Just in case

Support automatic generation of interface blocks

Improve support for interface blocks

Blocks with instance names are now properly supported in the syntax tree.

Tweak debug output

Only generate or link interfaces in the correct scope

Don't add null entries to variable values

This triggered a bug now that function parameters are processed within
the function's scope.

Refactor interface management

Rather than having separate maps in Stage, pull the variables from the
content block's map.

Refactor block management in NodeRemover

This was supposed to go in 9971979 but I forgot.

Ignore function parameters in InterfaceGenerator

Refactor scope management

TraversingVisitor now takes care of maintaining current_block correctly
for functions and loops.  This fixes an issue where InterfaceGenerator
was treating function in/out parameters as global interface variables.
Now there's a different bug where it generates global interface variables
for them.

Avoid incorrectly matching interfaces in certain cases

I removed this in ab5f2e6, thinking it was unnecessary.  But if a stage
declares a local output variable of the same name as an output variable
in the previous stage, this is needed to avoid a mismatch.

Remove the using declarations from visitors

Instead always invoke visit through the node

Some tweaks to GLSL debug output

Output the passthrough statement in both GLSL and debug modes

Slightly refactor layout qualifiers in the GLSL parser

Their values are now stored as integers, since no qualifier takes a
value of any other type.

Check that requested shader stages are supported

Throw an exception if a feature required by a shader is missing

Workarounds are not always available.

Add a standalone GLSL compiler frontend

This makes debugging the compiler easier and will eventually allow
shaders to be compiled into SPIR-V during build.

Reduce coupling between the GLSL compiler and the graphics engine

Feature states are now recorded in a struct.

Header fixes in the GLSL compiler

Fix environment map uniform name

Update the desertpillars demo

Implement an unlit material type

Support addint datafile statements for uniform material properties

Add sampler parameter to RenderPass::set_texture

Add missing keyword to set sampler compare mode from datafile

Redesign the way shader programs are loaded

Vulkan uses SPIR-V modules which can be specialized so there has to be a
way to keep the module around.  A module can also contain multiple shader
stages.  The abstraction for individual stages with the Shader class is
outdated and has been replaced with Module.

GLSL code is stored in the Module in combined form and split into stages
when loaded to a Program.

Allow using SL::Formatter on single nodes

This is occasionally useful for debugging.

Further refactor block and scope management

TraversingVisitor now provides a current_block variable and block know
their parent block so checking if we're in the toplevel block is easy.

Tweaks to the AST debug output

Fix scoping of GLSL loop variables and function parameters

TraversingVisitor visits those before the body, so they were being
inserted into the enclosing scope's variables map.

Rewrite syntax tree modifications

BlockModifier left dangling pointers in various variable maps, which
started causing trouble when I wanted to print out the entire AST.
NodeRemover is now used for all removal operations and it properly
handles the maps.

Avoid copying raw pointers in the syntax tree

They will potentially point to incorrect nodes and must be resolved
again.

Add a visitor to dump the AST for debugging purposes

Rearrange secondary operations in GLSL compiler

These are now performed internally by the main operation visitor.

Tweaks to visitor classes in the GLSL compiler

Make RenderTargetFormat generation more robust

The functions here had accidentally gotten out of sync in 9087cc0.

Recognize the #line directive in the GLSL parser

Also add a new pragma to specify source names.

Track source names in SL::Module

Error translation has also been moved to a separate class.  This will
allow moving the creation of shaders to Program.

Remove support for the legacy stage change syntax

Load various built-in things through Resources

There's so many of them that managing them manually is becoming too
tedious.  Especially with some planned shader changes.

Refactor the interface of SL::Compiler

Report incorrect shader stages by name

Remove unused constructors

Adjust member access of the various visitors in the GLSL compiler

Most of them don't work properly if given some random node to start with.

Refactor creation of the shader builtin module

It can now use VariableResolver::apply like everything else.

Refactor the way of applying visitors to stages

Refactor handling of texture sampling functions in LegacyConverter

This structure allows to check support for sampler types which don't
have legacy variants for the texture function.

Move the StageType enum inside the Stage struct

Split SL::Compiler into several files

It was getting rather unwieldy at over 2000 lines, but now that this
subsystem has its own directory and namespace I can organize it better
without interfering with the other parts.

Follow the GLSL syntax rules more closely

Fix a bug which allowed preprocessor directives anywhere on a line,
reject characters which are not allowed in GLSL, and parse numeric
literals more robustly.

Split tokenizer and preprocessor out of the GLSL parser

Refactor error reporting in SL::Parser

There's now dedicated exception classes which take care of the
formatting.

Move the GLSL compiler entirely in its own namespace

Rearrange soucre files into subdirectories