BitmapsCommand.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/utils/converters/converters.h>
#include <Strings/components/logger/logger.h>
 
#include <HEKGuerilla/components/tags/importers/bitmap/bitmap.h>
#include <HEKGuerilla/components/tags/tags.h>
#include <HEKGuerilla/components/settings/config/config.h>
 
#include "../ToolCommand.hpp"
#include "../console.h"
#include "components/utils/utils.h"
 
#ifdef TOOL_LIB_EXPORTS
#define TOOL_LIB_API __declspec(dllexport) 
#else
#define TOOL_LIB_API __declspec(dllimport) 
#endif
 
class BitmapsCommand : public ToolCommand
{
private:
    std::vector<std::string> supported_extensions =
    {
        "apng",
        "avif",
        "bmp",
        "cur",
        "gif",
        "ico",
        "jpg",
        "jpeg",
        "jpeg2k",
        "pcx",
        "png",
        "qoi",
        "svg",
        "tga",
        "tif",
        "tiff",
        "wal",
        "webp",
        "xbm"
    };
 
public:
    BitmapsCommand()
    {
        command = "bitmaps";
        syntax = "bitmaps <directory> [recursive]";
        description = "scans through a given directory and imports all images as bitmap tags. resulting tags will be placed in the specified output folder. "
            "if recursive is set to true, then all subdirectories will be scanned and imported as well. this is disabled by default. "
            "supported formats: " + BlamStrings::Utils::String::BuildFromList(supported_extensions, ", ");
    }
 
    int execute(std::vector<std::string> args)
    {
        Guerilla::Tags::LoadPlugins();
 
        std::string project_root = BlamTool::Utils::GetProjectRoot();
 
        std::string import_base_dir = BlamStrings::Utils::IO::NormalizePath(project_root + "data/");
        std::string output_base_dir = BlamStrings::Utils::IO::NormalizePath(project_root + "tags/");
 
        bool recursive_search = false;
        std::string input_directory = "";
        std::string output_directory = "";
 
        if (args.size() == 0)
        {
            BlamStrings::Logger::LogEvent("no input directory path was provided, cannot compile bitmaps", BlamLogLevel::Warning);
            return -1;
        }
 
        if (args.size() > 2)
        {
            BlamStrings::Logger::LogEvent("too many arguments specified - skipping compilation. check your input and try again. "
                "for additional help, use 'tool.exe help bitmaps'.", BlamLogLevel::Warning);
            return -1;
        }
 
        // Prepare arguments
        {
            if (args.size() == 2)
            {
                if (BlamStrings::Converters::StringToBool(args[1]))
                {
                    BlamStrings::Logger::LogEvent("enabling recursive bitmap import, if you have many subdirectories this may take a long time!");
                    recursive_search = true;
                }
            }
 
            input_directory = BlamStrings::Utils::IO::NormalizePath(import_base_dir + args[0]);
            output_directory = BlamStrings::Utils::IO::NormalizePath(output_base_dir + args[0]);
        }
 
        std::vector<std::string> file_list = std::vector<std::string>();
 
        if (recursive_search)
        {
            file_list = BlamStrings::Utils::IO::GetDeepFileList(input_directory);
        }
        else
        {
            file_list = BlamStrings::Utils::IO::GetFileList(input_directory);
        }
 
        for (std::string file_path : file_list)
        {
            if (BlamStrings::Utils::String::EndsWithAny(file_path, supported_extensions, true))
            {
                std::string file_output_dir = output_directory;
 
                if (recursive_search)
                {
                    file_output_dir = BlamStrings::Utils::String::Replace(file_path, input_directory, output_directory);
                    file_output_dir = BlamStrings::Utils::IO::GetContainingFolder(file_output_dir);
                }
 
                if (!Guerilla::Tags::Importers::Bitmap::ImportBitmap(file_path, file_output_dir))
                {
                    BlamStrings::Logger::LogEvent("failed to import bitmap '" + file_path + "'", WSV_WARNING);
                }
                else
                {
                    BlamStrings::Logger::LogEvent("successfully imported bitmap '" + file_path + "' to directory '" + file_output_dir + "'");
                }
            }
        }
 
        Guerilla::Tags::ReleasePlugins();
 
        BlamStrings::Logger::LogEvent("finished.");
        return 0;
    }
};