render_model_performance_test.hpp

Go to the documentation of this file.

#include "../console.h"
 
#include <Strings/components/resources/strings/strings.h>
#include <Strings/components/utils/converters/converters.h>
 
#include "components/core/world/world.h"
#include "components/diagnostics/logger/logger.h"
#include "components/content/tags/tags.h"
#include "components/content/tags/tag_io.h"
 
namespace Blam::Resources::Console
{
    class RenderModelPerformanceTestCommand : public BlamConsoleCommand
    {
    public:
        RenderModelPerformanceTestCommand()
        {
            name = "render_model_performance_test";
            description = "";
            syntax = "render_model_performance_test <tag> <count> <distance> [y] [disable gizmos]";
 
            type = BlamCommandType::Builtin;
        }
 
        BlamResult Execute(std::vector<std::string> arguments)
        {
            if (arguments.size() < 3)
            {
                return BlamResult::Error_Command_WrongArgumentCount;
            }
 
            std::string tag_path = arguments.at(0);
            int count = BlamStrings::Converters::StringToInt(arguments.at(1), 0);
            float distance = BlamStrings::Converters::StringToFloat(arguments.at(2), 1.0f);
            float y = 0.0f;
            bool disable_gizmos = false;
 
            if (arguments.size() >= 4)
            {
                y = BlamStrings::Converters::StringToFloat(arguments.at(3), y);
            }
 
            if (arguments.size() >= 5)
            {
                disable_gizmos = BlamStrings::Converters::StringToBool(arguments.at(4), disable_gizmos);
            }
 
            BlamTagData* tag = Blam::Content::Tags::GetTagData(tag_path);
 
            if (!tag)
            {
                BlamResult load_result = Blam::Content::Tags::LoadTagFromFile(tag_path);
 
                if (load_result == BlamResult::Error_FileNotFound)
                {
                    Blam::Logger::LogEventForce("couldn't load tag '" + tag_path + "' to place", WSV_ERROR);
                    Blam::Logger::LogEventForce("tag '" + tag_path + "' does not exist");
                    return BlamResult::Success_OK;
                }
                else if (BR_FAILED(load_result))
                {
                    Blam::Logger::LogEventForce("couldn't load tag '" + tag_path + "' to place", WSV_ERROR);
                    Blam::Logger::LogEventForce("tag '" + tag_path + "' load result was " + std::to_string(load_result)
                        + ": " + ERROR_TEXT(load_result));
                    return BlamResult::Success_OK;
                }
 
                tag = Blam::Content::Tags::GetTagData(tag_path);
            }
 
            if (!tag)
            {
                Blam::Logger::LogEventForce("couldn't load tag '" + tag_path + "' to place", WSV_ERROR);
                Blam::Logger::LogEventForce("tag '" + tag_path + "' does not exist");
                return BlamResult::Success_OK;
            }
 
            BlamWorldState* world_state = Blam::World::GetWorldState();
 
            if (!world_state)
            {
                Blam::Logger::LogEventForce("cannot place: world state not ready", WSV_ERROR);
                return BlamResult::Success_OK;
            }
 
            std::vector<BlamWorldObject_Tag*> new_objects = std::vector<BlamWorldObject_Tag*>();
 
            int length = sqrt(count) / 2;
 
            for (int x = -length; x < length; x++)
            {
                for (int z = -length; z < length; z++)
                {
                    BlamWorldObject_Tag* object = world_state->CreateTagObject(tag, false);
 
                    if (object && object->ValidateTagData())
                    {
                        new_objects.push_back(object);
                        object->SetPosition(BlamVector3(x * distance, y, z * distance));
                    }
                    else
                    {
                        if (object) delete object;
                    }
                }
            }
 
            for (BlamWorldObject_Tag* object : new_objects)
            {
                world_state->AddObject(object);
 
                if (disable_gizmos && !UsingBgfx())
                {
                    object->SetTransformEnabled(false);
                }
            }
 
            Blam::Logger::LogEventForce("placed " + std::to_string(new_objects.size()) + " of '" + tag_path + "'");
 
            return BlamResult::Success_OK;
        }
    };
}