CompileShadersCommand.hpp

Go to the documentation of this file.

#pragma once
 
#include <Strings/components/utils/io/io.h>
#include <Strings/components/utils/string/string.h>
#include <Strings/components/logger/logger.h>
#include <Strings/components/utils/list/list.h>
 
#include "../ToolCommand.hpp"
#include "../console.h"
 
#ifdef TOOL_LIB_EXPORTS
#define TOOL_LIB_API __declspec(dllexport) 
#else
#define TOOL_LIB_API __declspec(dllimport) 
#endif
 
class CompileShadersCommand : public ToolCommand
{
private:
    int successful_compiles = 0;
    int warning_compiles = 0;
    int failed_compiles = 0;
 
    void attempt_shader_compile(std::string file_path, std::string output_file_path, bool vertex_shader);
    void compile_shaders(std::string base_directory);
 
    std::string profile = "";
 
public:
 
    CompileShadersCommand()
    {
        command = "compile-shaders";
        syntax = "compile-shaders <directory> <profile> [-bulk]";
        description = "compiles a collection of shaders from a directory. if -bulk is specified, scans through a given directory and compiles all shaders found within subdirectories.";
    }
 
    int execute(std::vector<std::string> args)
    {
        if (args.size() == 0)
        {
            BlamStrings::Logger::LogEvent("no directory path was provided, cannot compile shaders", BlamLogLevel::Warning);
            return -1;
        }
 
        if (args.size() == 1)
        {
            BlamStrings::Logger::LogEvent("no shader profile was provided, cannot compile shaders", BlamLogLevel::Warning);
            return -1;
        }
        
        if (!BlamStrings::Utils::IO::FileExists(args[0]))
        {
            BlamStrings::Logger::LogEvent("directory '" + args[0] + "' does not exist, cannot compile shaders", BlamLogLevel::Warning);
            return -1;
        }
 
        if (!BlamStrings::Utils::IO::IsDirectory(args[0]))
        {
            BlamStrings::Logger::LogEvent("the path '" + args[0] + "' refers to a file, not a directory, cannot compile shaders", BlamLogLevel::Warning);
            return -1;
        }
 
        profile = args[1];
 
        bool bulk_compile = false;
 
        if (args.size() > 2)
        {
            for (int i = 2; i < args.size(); i++)
            {
                if (args.at(i) == "-bulk")
                {
                    bulk_compile = true;
                }
            }
        }
 
        if (bulk_compile)
        {
            std::vector<std::string> directory_list = BlamStrings::Utils::IO::GetDirectoryList(args[0]);
 
            for (int i = 0; i < directory_list.size(); i++)
            {
                compile_shaders(directory_list.at(i));
            }
        }
        else
        {
            compile_shaders(args[0]);
        }
 
        BlamStrings::Logger::LogEvent("shader compilation finished", TerminalColor::Cyan);
        BlamStrings::Logger::LogEvent("results:");
        BlamStrings::Logger::LogEvent("succeeded : " + std::to_string(successful_compiles), TerminalColor::BrightGreen);
        BlamStrings::Logger::LogEvent("warnings  : " + std::to_string(warning_compiles), TerminalColor::Yellow);
        BlamStrings::Logger::LogEvent("failures  : " + std::to_string(failed_compiles), TerminalColor::BrightRed);
        return 0;
    }
};