MaterialCommand.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/tags/fields/block/block.h>
#include <HEKGuerilla/components/tags/fields/tagref/tagref.h>
#include <HEKGuerilla/components/tags/fields/enum/enum.h>
#include <HEKGuerilla/components/tags/fields/color/color.h>
#include <HEKGuerilla/components/tags/fields/float32/float32.h>
#include <HEKGuerilla/components/settings/config/config.h>
 
#include "../ToolCommand.hpp"
#include "../console.h"
#include "BitmapsCommand.hpp"
#include "components/utils/utils.h"
 
#ifdef TOOL_LIB_EXPORTS
#define TOOL_LIB_API __declspec(dllexport) 
#else
#define TOOL_LIB_API __declspec(dllimport) 
#endif
 
class MaterialCommand : public ToolCommand
{
private:
    std::vector<std::string> diffuse_texture_keywords = {
        "diffuse", "basecolor", "color", "albedo"
    };
 
    std::vector<std::string> normal_texture_keywords = {
        "normal"
    };
 
    std::vector<std::string> roughness_texture_keywords = {
        "roughness", "rough"
    };
 
    std::vector<std::string> specular_texture_keywords = {
        "specular", "spec"
    };
 
    std::vector<std::string> emissive_texture_keywords = {
        "emissive", "glow", "illum"
    };
 
    std::vector<std::string> metallic_texture_keywords = {
        "metallic", "metal"
    };
 
public:
    MaterialCommand()
    {
        command = "material";
        syntax = "material <directory> [overwrite] [skip bitmap import]";
        description = "creates a pbr material from a texture set. assigns textures based on guesses from names. materials will generally be imperfect and require fine tuning.";
    }
 
    int execute(std::vector<std::string> args)
    {
        if (args.size() == 0)
        {
            BlamStrings::Logger::LogEvent("no input directory path was provided, cannot compile bitmaps", BlamLogLevel::Warning);
            return -1;
        }
 
        if (args.size() > 3)
        {
            BlamStrings::Logger::LogEvent("too many arguments specified - skipping import. check your input and try again. "
                "for additional help, use 'tool.exe help material'.", BlamLogLevel::Warning);
            return -1;
        }
 
        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 overwrite = false;
        bool skip_bitmaps = false;
        std::string input_directory = "";
        std::string output_directory = "";
        std::string material_tag_name = "";
 
        // Prepare arguments
        {
            if (args.size() >= 2)
            {
                if (BlamStrings::Converters::StringToBool(args[1]))
                {
                    overwrite = true;
                }
            }
 
            if (args.size() >= 3)
            {
                if (BlamStrings::Converters::StringToBool(args[2]))
                {
                    skip_bitmaps = true;
                }
            }
 
            input_directory = BlamStrings::Utils::IO::NormalizePath(import_base_dir + args[0]);
            output_directory = BlamStrings::Utils::IO::NormalizePath(output_base_dir + args[0]);
            material_tag_name = BlamStrings::Utils::IO::GetFileName(output_directory);
        }
 
        BitmapsCommand* bitmaps_command = (BitmapsCommand*)BlamTool::Console::GetCommand("bitmaps");
 
        if (!bitmaps_command)
        {
            BlamStrings::Logger::LogEvent("cannot resolve bitmaps command - this is a bug and should be reported", BlamLogLevel::Warning);
            return -1;
        }
 
        BlamStrings::Logger::LogEvent("step 1: bitmap import");
 
        if (!skip_bitmaps)
        {
            if (bitmaps_command->execute({ args.at(0), "true" }) != 0)
            {
                BlamStrings::Logger::LogEvent("bitmaps command execution returned non-zero, bitmaps may not be imported", BlamLogLevel::Warning);
            }
        }
 
        BlamStrings::Logger::LogEvent("step 2: material creation");
 
        if (BlamStrings::Utils::IO::FileExists(output_directory + "/" + material_tag_name + ".material") && !overwrite)
        {
            BlamStrings::Logger::LogEvent("not creating new material tag, file already exists - to force material creation anyway, set override to true (will destroy existing tag!)", BlamLogLevel::Warning);
            return -1;
        }
 
        Guerilla::Tags::LoadPlugins();
 
        std::vector<std::string> bitmap_paths = std::vector<std::string>();
 
        for (std::string file_path : BlamStrings::Utils::IO::GetFileList(output_directory))
        {
            if (!str_tolower(file_path).ends_with(".bitmap"))
            {
                continue;
            }
 
            bitmap_paths.push_back(file_path);
        }
        
        BlamPlugin* material_plugin = Guerilla::Tags::GetPlugin("material");
 
        if (!material_plugin)
        {
            BlamStrings::Logger::LogEvent("cannot create material: cannot locate material plugin", WSV_WARNING);
            return -1;
        }
 
        BlamTag* tag = material_plugin->CreateNewTag();
 
        tag->file_path = output_directory + "/" + material_tag_name + ".material";
 
        BlamTagField_Block* pbr_material_block = tag->GetField<BlamTagField_Block>("pbr_material");
 
        if (!pbr_material_block)
        {
            BlamStrings::Logger::LogEvent("cannot create material: material plugin is missing a pbr_material block", WSV_WARNING);
            return -1;
        }
 
        pbr_material_block->AddEntry();
        BlamTagBlockEntry* entry = pbr_material_block->entries.at(0);
        BlamTagField_Block* textures_block = entry->GetField<BlamTagField_Block>("textures");
 
        if (!textures_block)
        {
            BlamStrings::Logger::LogEvent("cannot create material: pbr_material block is missing a textures block", WSV_WARNING);
            return -1;
        }
 
        std::string diffuse = "";
        std::string normal = "";
        std::string specular = "";
        std::string roughness = "";
        std::string emissive = "";
        std::string metallic = "";
 
        for (std::string texture_file : bitmap_paths)
        {
            std::string tag_path = str_replace(texture_file, output_base_dir, "");
            std::string tag_name = BlamStrings::Utils::IO::GetFileName(tag_path);
 
            if (diffuse.length() == 0 && BlamStrings::Utils::String::ContainsAny(tag_name, diffuse_texture_keywords, true))
                diffuse = tag_path;
 
            if (normal.length() == 0 && BlamStrings::Utils::String::ContainsAny(tag_name, normal_texture_keywords, true))
                normal = tag_path;
 
            if (specular.length() == 0 && BlamStrings::Utils::String::ContainsAny(tag_name, specular_texture_keywords, true))
                specular = tag_path;
 
            if (roughness.length() == 0 && BlamStrings::Utils::String::ContainsAny(tag_name, roughness_texture_keywords, true))
                roughness = tag_path;
 
            if (emissive.length() == 0 && BlamStrings::Utils::String::ContainsAny(tag_name, emissive_texture_keywords, true))
                emissive = tag_path;
 
            if (metallic.length() == 0 && BlamStrings::Utils::String::ContainsAny(tag_name, metallic_texture_keywords, true))
                metallic = tag_path;
        }
 
        if (diffuse.length() > 0) CreateNewTextureEntry(textures_block, "diffuse", diffuse);
        if (normal.length() > 0) CreateNewTextureEntry(textures_block, "normal", normal);
        if (specular.length() > 0) CreateNewTextureEntry(textures_block, "specular", specular);
        if (roughness.length() > 0) CreateNewTextureEntry(textures_block, "roughness", roughness);
        if (emissive.length() > 0) CreateNewTextureEntry(textures_block, "emissive", emissive);
        if (metallic.length() > 0) CreateNewTextureEntry(textures_block, "metallic", metallic);
 
        // Set other fields to moderate defaults
        {
            BlamTagField_Float32* metalness = entry->GetField<BlamTagField_Float32>("metalness");
            BlamTagField_Float32* roughness = entry->GetField<BlamTagField_Float32>("roughness");
            BlamTagField_Color* emissive_color = entry->GetField<BlamTagField_Color>("emissive_color");
 
            if (metalness) metalness->value = 0.5f;
            if (roughness) roughness->value = 0.5f;
            if (emissive_color) emissive_color->value = BlamColor(0, 0, 0, 0);
        }
 
        if (!Guerilla::Tags::SaveTag(tag))
        {
            BlamStrings::Logger::LogEvent("failed to save material tag - see log for details", WSV_WARNING);
        }
 
        Guerilla::Tags::ReleasePlugins();
 
        BlamStrings::Logger::LogEvent("finished.");
        return 0;
    }
 
    bool CreateNewTextureEntry(BlamTagField_Block* block, std::string type, std::string tag)
    {
        if (!block->AddEntry())
        {
            BlamStrings::Logger::LogEvent("failed to add material entry for '" + type + "': add entry failed", WSV_WARNING);
            return false;
        }
 
        BlamTagBlockEntry* entry = block->entries.at(block->entries.size() - 1);
 
        entry->name = type;
        BlamTagField_Enum* texture_type = entry->GetField<BlamTagField_Enum>("texture_type", BlamTagFieldType::Enum32);
        BlamTagField_Tagref* texture = entry->GetField<BlamTagField_Tagref>("texture");
 
        if (!texture_type || !texture)
        {
            BlamStrings::Logger::LogEvent("failed to add material entry for '" + type
                + "': missing texture_type (enum32) and/or texture (tagref) fields", WSV_WARNING);
            return false;
        }
 
        texture_type->current_option = type;
        texture->referenced_tag_class = "bitm";
        texture->referenced_tag_path = tag;
        return true;
    }
};