ShaderTools.h

#pragma once
//#include <NDEVR/ShaderBuilderModule.h>
#include <NDEVR/QTModelManager.h>
#include <NDEVR/QTWindowManager.h>
#include <NDEVR/Translator.h>
#include <NDEVR/ModuleManager.h>
#include <NDEVR/ModuleResourceManager.h>
#include <NDEVR/BufferedScanner.h>
#include <NDEVR/LocalApplicationLauncher.h>
namespace NDEVR
{
    class ShaderTools
    {
    public:
        File exe_location = File("$(VULKAN_DIR)/Bin/glslangValidator.exe"); 
        LogPtr log = nullptr;                                               
        ShaderTools()
        {
            exe_location.expandEnvironmentalVars();
        }

        void compileIndividualShader(File compile_file, File output_location)
        {
            String args = "-V " + compile_file;
            args += " -o " + output_location;
            LocalApplicationLauncher::CallApplication(exe_location, args, true, true, log);
        }

        void compileShader(File reference, const StringView& out_name, const StringView& value, bool is_simple)
        {
            reference.expandEnvironmentalVars();
            BufferedScanner s(reference);
            String data;
            while (s.nextLine())
            {
                if (s.currentLine().beginsWith("#define SIMPLE_SHADER"))
                {
                    if (is_simple)
                        data += "\n#define SIMPLE_SHADER 1\n";
                    else
                        data += "\n#define SIMPLE_SHADER 0\n";
 
                }
                else if (s.currentLine().beginsWith("#define " + value))
                    data += "#define " + value + " 1\n";
                else if (s.currentLine().beginsWith("\n#define " + value))
                    data += "\n#define " + value + " 1\n";
                else
                    data += s.currentLine() + "\n";
            }
            StringView extension = reference.getPath(File::e_file_extension);
            File new_file(reference.getParentDirectory().appendPath(out_name + extension));
            new_file.open(File::OpenMode::e_ascii_write);
            new_file << data;
            new_file.close();
            File output = reference.getParentDirectory().appendPath(out_name + ".spv");
            compileIndividualShader(new_file, output);
        }

        void compileShader(File reference)
        {
            File output = reference;
            output.setPath(".spv", File::e_file_extension);
            compileIndividualShader(reference, output);
        }

        void compileShaders(File reference)
        {
            compileShader(reference, "points_s", "POINT_SHADER", true);
            compileShader(reference, "points", "POINT_SHADER", false);
            compileShader(reference, "linework", "LINEWORK_SHADER", false);
            compileShader(reference, "solid", "SOLID_SHADER", false);
            compileShader(reference, "solid_grid", "SOLID_GRID_SHADER", false);
            compileShader(reference, "solid_texture", "SOLID_TEXTURE_SHADER", false);
        }

        void compileDefault()
        {
            File folder("$(NDEVR_SOURCE_DIR)/VulkanInterface/Resources/Shaders/");
            folder.expandEnvironmentalVars();
            compileShaders(File(folder).appendPath("Gouraud/simple.frag"));
            compileShaders(File(folder).appendPath("BackgroundGradiant/simple.frag"));
            compileShaders(File(folder).appendPath("Normal/simple.vert"));
            compileShaders(File(folder).appendPath("Integer/simple.vert"));
            compileShader(File(folder).appendPath("Integer/tbn.vert"));
            compileShader(File(folder).appendPath("Normal/tbn.vert"));
            compileShader(File(folder).appendPath("Gouraud/tbn.frag"));
 
        }
    };
    
}