277 lines
9.0 KiB
C++
277 lines
9.0 KiB
C++
// MassBuilderSaveTool
|
|
// Copyright (C) 2021-2024 Guillaume Jacquemin
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
#include <algorithm>
|
|
|
|
#include "../Logger/Logger.h"
|
|
|
|
#include "Serialisers/ArrayProperty.h"
|
|
#include "Serialisers/BoolProperty.h"
|
|
#include "Serialisers/ByteProperty.h"
|
|
#include "Serialisers/ColourProperty.h"
|
|
#include "Serialisers/DateTimeProperty.h"
|
|
#include "Serialisers/EnumProperty.h"
|
|
#include "Serialisers/FloatProperty.h"
|
|
#include "Serialisers/GuidProperty.h"
|
|
#include "Serialisers/IntProperty.h"
|
|
#include "Serialisers/MapProperty.h"
|
|
#include "Serialisers/ResourceProperty.h"
|
|
#include "Serialisers/RotatorProperty.h"
|
|
#include "Serialisers/StringProperty.h"
|
|
#include "Serialisers/SetProperty.h"
|
|
#include "Serialisers/Struct.h"
|
|
#include "Serialisers/TextProperty.h"
|
|
#include "Serialisers/VectorProperty.h"
|
|
#include "Serialisers/Vector2DProperty.h"
|
|
|
|
#include "Types/NoneProperty.h"
|
|
|
|
#include "../BinaryIo/Reader.h"
|
|
#include "../BinaryIo/Writer.h"
|
|
|
|
#include "PropertySerialiser.h"
|
|
|
|
namespace Gvas {
|
|
|
|
PropertySerialiser::PropertySerialiser() {
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::ArrayProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::BoolProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::ByteProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::ColourProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::DateTimeProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::EnumProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::FloatProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::GuidProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::IntProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::MapProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::ResourceProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::RotatorProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::StringProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::SetProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::TextProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::VectorProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::Vector2DProperty>());
|
|
arrayAppend(_serialisers, Containers::pointer<Serialisers::Struct>());
|
|
|
|
arrayAppend(_collectionSerialisers, Containers::pointer<Serialisers::Struct>());
|
|
}
|
|
|
|
PropertySerialiser&
|
|
PropertySerialiser::instance() {
|
|
static PropertySerialiser serialiser;
|
|
return serialiser;
|
|
}
|
|
|
|
Types::UnrealPropertyBase::ptr
|
|
PropertySerialiser::read(BinaryIo::Reader& reader) {
|
|
if(reader.peekChar() < 0 || reader.eof()) {
|
|
return nullptr;
|
|
}
|
|
|
|
Containers::String name;
|
|
if(!reader.readUEString(name)) {
|
|
return nullptr;
|
|
}
|
|
|
|
if(name == "None") {
|
|
return Containers::pointer<Types::NoneProperty>();
|
|
}
|
|
|
|
Containers::String type;
|
|
if(!reader.readUEString(type)) {
|
|
return nullptr;
|
|
}
|
|
|
|
std::size_t value_length;
|
|
if(!reader.readUint64(value_length)) {
|
|
return nullptr;
|
|
}
|
|
|
|
return deserialise(Utility::move(name), Utility::move(type), value_length, reader);
|
|
}
|
|
|
|
Types::UnrealPropertyBase::ptr
|
|
PropertySerialiser::readItem(BinaryIo::Reader& reader, Containers::String type, std::size_t value_length,
|
|
Containers::String name)
|
|
{
|
|
if(reader.peekChar() < 0 || reader.eof()) {
|
|
return nullptr;
|
|
}
|
|
|
|
return deserialise(Utility::move(name), Utility::move(type), value_length, reader);
|
|
}
|
|
|
|
Containers::Array<Types::UnrealPropertyBase::ptr>
|
|
PropertySerialiser::readSet(BinaryIo::Reader& reader, Containers::StringView item_type, std::uint32_t count) {
|
|
if(reader.peekChar() < 0 || reader.eof()) {
|
|
return nullptr;
|
|
}
|
|
|
|
auto serialiser = getCollectionSerialiser(item_type);
|
|
|
|
Containers::Array<Types::UnrealPropertyBase::ptr> array;
|
|
|
|
if(serialiser) {
|
|
Containers::String name;
|
|
if(!reader.readUEString(name)) {
|
|
return nullptr;
|
|
}
|
|
|
|
Containers::String type;
|
|
if(!reader.readUEString(type)) {
|
|
return nullptr;
|
|
}
|
|
|
|
std::size_t value_length;
|
|
if(!reader.readUint64(value_length)) {
|
|
return nullptr;
|
|
}
|
|
|
|
array = serialiser->deserialise(name, type, value_length, count, reader, *this);
|
|
|
|
for(auto& item : array) {
|
|
if(item->name == Containers::NullOpt) {
|
|
item->name.emplace(name);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for(std::uint32_t i = 0; i < count; i++) {
|
|
auto item = readItem(reader, item_type, std::size_t(-1), "");
|
|
arrayAppend(array, Utility::move(item));
|
|
}
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
Types::UnrealPropertyBase::ptr
|
|
PropertySerialiser::deserialise(Containers::String name, Containers::String type, std::size_t value_length,
|
|
BinaryIo::Reader& reader)
|
|
{
|
|
Types::UnrealPropertyBase::ptr prop;
|
|
auto serialiser = getSerialiser(type);
|
|
|
|
if(serialiser == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
prop = serialiser->deserialise(name, type, value_length, reader, *this);
|
|
|
|
if(!prop) {
|
|
LOG_ERROR("No property.");
|
|
return nullptr;
|
|
}
|
|
|
|
prop->name = Utility::move(name);
|
|
prop->propertyType = Utility::move(type);
|
|
|
|
return prop;
|
|
}
|
|
|
|
bool PropertySerialiser::serialise(Types::UnrealPropertyBase::ptr& prop, Containers::StringView item_type,
|
|
std::size_t& bytes_written, BinaryIo::Writer& writer)
|
|
{
|
|
auto serialiser = getSerialiser(item_type);
|
|
if(!serialiser) {
|
|
return false;
|
|
}
|
|
return serialiser->serialise(prop, bytes_written, writer, *this);
|
|
}
|
|
|
|
bool
|
|
PropertySerialiser::write(Types::UnrealPropertyBase::ptr& prop, std::size_t& bytes_written, BinaryIo::Writer& writer) {
|
|
if(prop->name == "None" && prop->propertyType == "NoneProperty" && dynamic_cast<Types::NoneProperty*>(prop.get())) {
|
|
bytes_written += writer.writeUEStringToArray(*prop->name);
|
|
return true;
|
|
}
|
|
|
|
bytes_written += writer.writeUEStringToArray(*prop->name);
|
|
bytes_written += writer.writeUEStringToArray(prop->propertyType);
|
|
|
|
std::size_t value_length = 0;
|
|
std::size_t vl_position = writer.arrayPosition();
|
|
|
|
bytes_written += writer.writeValueToArray<std::size_t>(value_length);
|
|
|
|
bool ret = serialise(prop, prop->propertyType, value_length, writer);
|
|
|
|
writer.writeValueToArrayAt(value_length, vl_position);
|
|
|
|
bytes_written += value_length;
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool
|
|
PropertySerialiser::writeItem(Types::UnrealPropertyBase::ptr& prop, Containers::StringView item_type,
|
|
std::size_t& bytes_written, BinaryIo::Writer& writer)
|
|
{
|
|
if(prop->name == "None" && prop->propertyType == "NoneProperty" && dynamic_cast<Types::NoneProperty*>(prop.get())) {
|
|
bytes_written += writer.writeUEStringToArray(*prop->name);
|
|
return true;
|
|
}
|
|
|
|
return serialise(prop, item_type, bytes_written, writer);
|
|
}
|
|
|
|
bool PropertySerialiser::writeSet(Containers::ArrayView<Types::UnrealPropertyBase::ptr> props,
|
|
Containers::StringView item_type, std::size_t& bytes_written,
|
|
BinaryIo::Writer& writer)
|
|
{
|
|
auto serialiser = getCollectionSerialiser(item_type);
|
|
if(serialiser) {
|
|
return serialiser->serialise(props, item_type, bytes_written, writer, *this);
|
|
}
|
|
else {
|
|
for(auto& prop : props) {
|
|
if(!writeItem(prop, item_type, bytes_written, writer)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
Serialisers::AbstractUnrealProperty*
|
|
PropertySerialiser::getSerialiser(Containers::StringView item_type) {
|
|
for(auto& item : _serialisers) {
|
|
for(auto serialiser_type : item->types()) {
|
|
if(item_type == serialiser_type) {
|
|
return item.get();
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
Serialisers::AbstractUnrealCollectionProperty*
|
|
PropertySerialiser::getCollectionSerialiser(Containers::StringView item_type) {
|
|
for(auto& item : _collectionSerialisers) {
|
|
for(Containers::StringView serialiser_type : item->types()) {
|
|
if(item_type == serialiser_type) {
|
|
return item.get();
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
}
|