zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2026-01-09 02:01:50 +00:00
Code Activity

chore: add ability for zcg to generate files once per template

Browse Source
This commit is contained in:
Jan Laupetin
2026-01-05 12:15:14 +00:00
parent 11fdb4ad59
commit 660f34df69
17 changed files with 166 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/ZoneCodeGeneratorLib/Generating/CodeGenerator.cpp
View File

@@ -28,9 +28,9 @@ void CodeGenerator::SetupTemplates()
m_template_mapping["assetstructtests"] = std::make_unique<AssetStructTestsTemplate>();
}
bool CodeGenerator::GenerateCodeForTemplate(const RenderingContext& context, ICodeTemplate* codeTemplate) const
bool CodeGenerator::GenerateCodeOncePerTemplate(const OncePerTemplateRenderingContext& context, ICodeTemplate* codeTemplate) const
{
for (const auto& codeFile : codeTemplate->GetFilesToRender(context))
for (const auto& codeFile : codeTemplate->GetFilesToRenderOncePerTemplate(context))
{
fs::path p(m_args->m_output_directory);
p.append(codeFile.m_file_name);
@@ -47,7 +47,34 @@ bool CodeGenerator::GenerateCodeForTemplate(const RenderingContext& context, ICo
return false;
}
codeTemplate->RenderFile(stream, codeFile.m_tag, context);
codeTemplate->RenderOncePerTemplateFile(stream, codeFile.m_tag, context);
stream.close();
}
return true;
}
bool CodeGenerator::GenerateCodeOncePerAsset(const OncePerAssetRenderingContext& context, ICodeTemplate* codeTemplate) const
{
for (const auto& codeFile : codeTemplate->GetFilesToRenderOncePerAsset(context))
{
fs::path p(m_args->m_output_directory);
p.append(codeFile.m_file_name);
auto parentFolder(p);
parentFolder.remove_filename();
create_directories(parentFolder);
std::ofstream stream(p, std::fstream::out | std::fstream::binary);
if (!stream.is_open())
{
con::error("Failed to open file '{}'", p.string());
return false;
}
codeTemplate->RenderOncePerAssetFile(stream, codeFile.m_tag, context);
stream.close();
}
@@ -101,14 +128,14 @@ bool CodeGenerator::GenerateCode(const IDataRepository* repository)
const auto foundTemplate = m_template_mapping.find(lowerTemplateName);
if (foundTemplate == m_template_mapping.end())
{
con::error("Unknown template '{}'.", templateName);
con::error("Unknown template '{}'", templateName);
return false;
}
for (auto* asset : assets)
{
auto context = RenderingContext::BuildContext(repository, asset);
if (!GenerateCodeForTemplate(*context, foundTemplate->second.get()))
auto context = OncePerAssetRenderingContext::BuildContext(repository, asset);
if (!GenerateCodeOncePerAsset(*context, foundTemplate->second.get()))
{
con::error("Failed to generate code for asset '{}' with preset '{}'", asset->m_definition->GetFullName(), foundTemplate->first);
return false;
@@ -116,6 +143,17 @@ bool CodeGenerator::GenerateCode(const IDataRepository* repository)
con::info("Successfully generated code for asset '{}' with preset '{}'", asset->m_definition->GetFullName(), foundTemplate->first);
}
{
auto context = OncePerTemplateRenderingContext::BuildContext(repository);
if (!GenerateCodeOncePerTemplate(*context, foundTemplate->second.get()))
{
con::error("Failed to generate code with preset '{}'", foundTemplate->first);
return false;
}
con::info("Successfully generated code with preset '{}'", foundTemplate->first);
}
}
const auto end = std::chrono::steady_clock::now();
con::debug("Generating code took {}ms", std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count());

4
src/ZoneCodeGeneratorLib/Generating/CodeGenerator.h
View File

@@ -17,7 +17,9 @@ public:
private:
void SetupTemplates();
bool GenerateCodeForTemplate(const RenderingContext& context, ICodeTemplate* codeTemplate) const;
bool GenerateCodeOncePerTemplate(const OncePerTemplateRenderingContext& context, ICodeTemplate* codeTemplate) const;
bool GenerateCodeOncePerAsset(const OncePerAssetRenderingContext& context, ICodeTemplate* codeTemplate) const;
static bool GetAssetWithName(const IDataRepository* repository, const std::string& name, StructureInformation*& asset);
const ZoneCodeGeneratorArguments* m_args;

24
src/ZoneCodeGeneratorLib/Generating/ICodeTemplate.h
View File

@@ -1,22 +1,25 @@
#pragma once
#include "RenderingContext.h"
#include "OncePerAssetRenderingContext.h"
#include "OncePerTemplateRenderingContext.h"
#include <ostream>
#include <string>
#include <vector>
typedef unsigned CodeTemplateFileTag;
class CodeTemplateFile
{
public:
CodeTemplateFile(std::string fileName, const int tag)
CodeTemplateFile(std::string fileName, const CodeTemplateFileTag tag)
: m_file_name(std::move(fileName)),
m_tag(tag)
{
}
std::string m_file_name;
int m_tag;
CodeTemplateFileTag m_tag;
};
class ICodeTemplate
@@ -29,6 +32,17 @@ public:
ICodeTemplate& operator=(const ICodeTemplate& other) = default;
ICodeTemplate& operator=(ICodeTemplate&& other) noexcept = default;
virtual std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) = 0;
virtual void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) = 0;
virtual std::vector<CodeTemplateFile> GetFilesToRenderOncePerTemplate(const OncePerTemplateRenderingContext& context)
{
return {};
}
virtual void RenderOncePerTemplateFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerTemplateRenderingContext& context) {}
virtual std::vector<CodeTemplateFile> GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context)
{
return {};
}
virtual void RenderOncePerAssetFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context) {}
};

26
src/ZoneCodeGeneratorLib/Generating/RenderingContext.cpp → src/ZoneCodeGeneratorLib/Generating/OncePerAssetRenderingContext.cpp
View File

@@ -1,4 +1,4 @@
#include "RenderingContext.h"
#include "OncePerAssetRenderingContext.h"
#include "Domain/Computations/MemberComputations.h"
#include "Domain/Computations/StructureComputations.h"
@@ -18,7 +18,9 @@ RenderingUsedType::RenderingUsedType(const DataDefinition* type, StructureInform
{
}
RenderingContext::RenderingContext(std::string game, const Architecture gameArchitecture, std::vector<const FastFileBlock*> fastFileBlocks)
OncePerAssetRenderingContext::OncePerAssetRenderingContext(std::string game,
const Architecture gameArchitecture,
std::vector<const FastFileBlock*> fastFileBlocks)
: m_game(std::move(game)),
m_architecture_mismatch(gameArchitecture != OWN_ARCHITECTURE),
m_pointer_size(GetPointerSizeForArchitecture(gameArchitecture)),
@@ -40,7 +42,7 @@ RenderingContext::RenderingContext(std::string game, const Architecture gameArch
}
}
RenderingUsedType* RenderingContext::AddUsedType(std::unique_ptr<RenderingUsedType> usedType)
RenderingUsedType* OncePerAssetRenderingContext::AddUsedType(std::unique_ptr<RenderingUsedType> usedType)
{
auto* result = usedType.get();
m_used_types.push_back(usedType.get());
@@ -49,7 +51,7 @@ RenderingUsedType* RenderingContext::AddUsedType(std::unique_ptr<RenderingUsedTy
return result;
}
RenderingUsedType* RenderingContext::GetBaseType(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType)
RenderingUsedType* OncePerAssetRenderingContext::GetBaseType(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType)
{
if (usedType->m_type->GetType() == DataDefinitionType::TYPEDEF)
{
@@ -77,7 +79,7 @@ RenderingUsedType* RenderingContext::GetBaseType(const IDataRepository* reposito
return nullptr;
}
void RenderingContext::AddMembersToContext(const IDataRepository* repository, StructureInformation* info)
void OncePerAssetRenderingContext::AddMembersToContext(const IDataRepository* repository, StructureInformation* info)
{
for (const auto& member : info->m_ordered_members)
{
@@ -121,7 +123,7 @@ void RenderingContext::AddMembersToContext(const IDataRepository* repository, St
}
}
void RenderingContext::ScanUsedTypeIfNeeded(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType)
void OncePerAssetRenderingContext::ScanUsedTypeIfNeeded(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType)
{
if (usedType->m_info != nullptr && !StructureComputations(usedType->m_info).IsAsset() && !computations->IsInRuntimeBlock() && !usedType->m_members_loaded)
{
@@ -130,7 +132,7 @@ void RenderingContext::ScanUsedTypeIfNeeded(const IDataRepository* repository, M
}
}
void RenderingContext::MakeAsset(const IDataRepository* repository, StructureInformation* asset)
void OncePerAssetRenderingContext::MakeAsset(const IDataRepository* repository, StructureInformation* asset)
{
m_asset = asset;
AddUsedType(std::make_unique<RenderingUsedType>(asset->m_definition, asset));
@@ -138,7 +140,7 @@ void RenderingContext::MakeAsset(const IDataRepository* repository, StructureInf
AddMembersToContext(repository, asset);
}
void RenderingContext::CreateUsedTypeCollections()
void OncePerAssetRenderingContext::CreateUsedTypeCollections()
{
for (auto* usedType : m_used_types)
{
@@ -165,7 +167,7 @@ void RenderingContext::CreateUsedTypeCollections()
}
}
bool RenderingContext::UsedTypeHasActions(const RenderingUsedType* usedType) const
bool OncePerAssetRenderingContext::UsedTypeHasActions(const RenderingUsedType* usedType) const
{
const StructureComputations computations(usedType->m_info);
@@ -190,10 +192,10 @@ bool RenderingContext::UsedTypeHasActions(const RenderingUsedType* usedType) con
return false;
}
std::unique_ptr<RenderingContext> RenderingContext::BuildContext(const IDataRepository* repository, StructureInformation* asset)
std::unique_ptr<OncePerAssetRenderingContext> OncePerAssetRenderingContext::BuildContext(const IDataRepository* repository, StructureInformation* asset)
{
auto context =
std::make_unique<RenderingContext>(RenderingContext(repository->GetGameName(), repository->GetArchitecture(), repository->GetAllFastFileBlocks()));
auto context = std::make_unique<OncePerAssetRenderingContext>(
OncePerAssetRenderingContext(repository->GetGameName(), repository->GetArchitecture(), repository->GetAllFastFileBlocks()));
context->MakeAsset(repository, asset);
context->CreateUsedTypeCollections();

6
src/ZoneCodeGeneratorLib/Generating/RenderingContext.h → src/ZoneCodeGeneratorLib/Generating/OncePerAssetRenderingContext.h
View File

@@ -24,10 +24,10 @@ public:
bool m_pointer_array_reference_is_reusable;
};
class RenderingContext
class OncePerAssetRenderingContext
{
public:
static std::unique_ptr<RenderingContext> BuildContext(const IDataRepository* repository, StructureInformation* asset);
static std::unique_ptr<OncePerAssetRenderingContext> BuildContext(const IDataRepository* repository, StructureInformation* asset);
std::string m_game;
bool m_architecture_mismatch;
@@ -45,7 +45,7 @@ public:
const FastFileBlock* m_default_temp_block;
private:
RenderingContext(std::string game, Architecture gameArchitecture, std::vector<const FastFileBlock*> fastFileBlocks);
OncePerAssetRenderingContext(std::string game, Architecture gameArchitecture, std::vector<const FastFileBlock*> fastFileBlocks);
RenderingUsedType* AddUsedType(std::unique_ptr<RenderingUsedType> usedType);
RenderingUsedType* GetBaseType(const IDataRepository* repository, MemberComputations* computations, RenderingUsedType* usedType);

31
src/ZoneCodeGeneratorLib/Generating/OncePerTemplateRenderingContext.cpp Normal file
View File

@@ -0,0 +1,31 @@
#include "OncePerTemplateRenderingContext.h"
#include <algorithm>
OncePerTemplateRenderingContext::OncePerTemplateRenderingContext(std::string game,
const Architecture gameArchitecture,
std::vector<const FastFileBlock*> fastFileBlocks)
: m_game(std::move(game)),
m_architecture_mismatch(gameArchitecture != OWN_ARCHITECTURE),
m_pointer_size(GetPointerSizeForArchitecture(gameArchitecture)),
m_blocks(std::move(fastFileBlocks)),
m_default_normal_block(nullptr),
m_default_temp_block(nullptr)
{
for (const auto* block : m_blocks)
{
if (block->m_is_default)
{
if (block->m_type == FastFileBlockType::NORMAL && m_default_normal_block == nullptr)
m_default_normal_block = block;
else if (block->m_type == FastFileBlockType::TEMP && m_default_temp_block == nullptr)
m_default_temp_block = block;
}
}
}
std::unique_ptr<OncePerTemplateRenderingContext> OncePerTemplateRenderingContext::BuildContext(const IDataRepository* repository)
{
return std::make_unique<OncePerTemplateRenderingContext>(
OncePerTemplateRenderingContext(repository->GetGameName(), repository->GetArchitecture(), repository->GetAllFastFileBlocks()));
}

22
src/ZoneCodeGeneratorLib/Generating/OncePerTemplateRenderingContext.h Normal file
View File

@@ -0,0 +1,22 @@
#pragma once
#include "Persistence/IDataRepository.h"
#include <string>
class OncePerTemplateRenderingContext
{
public:
static std::unique_ptr<OncePerTemplateRenderingContext> BuildContext(const IDataRepository* repository);
std::string m_game;
bool m_architecture_mismatch;
unsigned m_pointer_size;
std::vector<const FastFileBlock*> m_blocks;
const FastFileBlock* m_default_normal_block;
const FastFileBlock* m_default_temp_block;
private:
OncePerTemplateRenderingContext(std::string game, Architecture gameArchitecture, std::vector<const FastFileBlock*> fastFileBlocks);
};

6
src/ZoneCodeGeneratorLib/Generating/Templates/AssetStructTestsTemplate.cpp
View File

@@ -14,7 +14,7 @@ namespace
class Template final : BaseTemplate
{
public:
Template(std::ostream& stream, const RenderingContext& context)
Template(std::ostream& stream, const OncePerAssetRenderingContext& context)
: BaseTemplate(stream, context)
{
}
@@ -81,7 +81,7 @@ namespace
};
} // namespace
std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRender(const RenderingContext& context)
std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context)
{
std::vector<CodeTemplateFile> files;
@@ -93,7 +93,7 @@ std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRender(const R
return files;
}
void AssetStructTestsTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
void AssetStructTestsTemplate::RenderOncePerAssetFile(std::ostream& stream, const CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context)
{
Template t(stream, context);

5
src/ZoneCodeGeneratorLib/Generating/Templates/AssetStructTestsTemplate.h
View File

@@ -1,9 +1,10 @@
#pragma once
#include "Generating/ICodeTemplate.h"
class AssetStructTestsTemplate final : public ICodeTemplate
{
public:
std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
std::vector<CodeTemplateFile> GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context) override;
void RenderOncePerAssetFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context) override;
};

2
src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.cpp
View File

@@ -5,7 +5,7 @@
#include <sstream>
BaseTemplate::BaseTemplate(std::ostream& stream, const RenderingContext& context)
BaseTemplate::BaseTemplate(std::ostream& stream, const OncePerAssetRenderingContext& context)
: m_out(stream),
m_env(context),
m_intendation(0u)

6
src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.h
View File

@@ -5,7 +5,7 @@
#include "Domain/Evaluation/OperandDynamic.h"
#include "Domain/Evaluation/OperandStatic.h"
#include "Domain/Evaluation/Operation.h"
#include "Generating/RenderingContext.h"
#include "Generating/OncePerAssetRenderingContext.h"
#include <format>
#include <ostream>
@@ -15,7 +15,7 @@ class BaseTemplate
protected:
static constexpr auto INTENDATION = " ";
BaseTemplate(std::ostream& stream, const RenderingContext& context);
BaseTemplate(std::ostream& stream, const OncePerAssetRenderingContext& context);
void DoIntendation() const;
@@ -37,7 +37,7 @@ protected:
static std::string MakeEvaluation(const IEvaluation* evaluation);
std::ostream& m_out;
const RenderingContext& m_env;
const OncePerAssetRenderingContext& m_env;
unsigned m_intendation;
private:

6
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp
View File

@@ -17,7 +17,7 @@ namespace
class Template final : BaseTemplate
{
public:
Template(std::ostream& stream, const RenderingContext& context)
Template(std::ostream& stream, const OncePerAssetRenderingContext& context)
: BaseTemplate(stream, context)
{
}
@@ -2198,7 +2198,7 @@ namespace
};
} // namespace
std::vector<CodeTemplateFile> ZoneLoadTemplate::GetFilesToRender(const RenderingContext& context)
std::vector<CodeTemplateFile> ZoneLoadTemplate::GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context)
{
std::vector<CodeTemplateFile> files;
@@ -2211,7 +2211,7 @@ std::vector<CodeTemplateFile> ZoneLoadTemplate::GetFilesToRender(const Rendering
return files;
}
void ZoneLoadTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
void ZoneLoadTemplate::RenderOncePerAssetFile(std::ostream& stream, const CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context)
{
Template t(stream, context);

5
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.h
View File

@@ -1,9 +1,10 @@
#pragma once
#include "Generating/ICodeTemplate.h"
class ZoneLoadTemplate final : public ICodeTemplate
{
public:
std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
std::vector<CodeTemplateFile> GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context) override;
void RenderOncePerAssetFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context) override;
};

6
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp
View File

@@ -16,7 +16,7 @@ namespace
class Template final : BaseTemplate
{
public:
Template(std::ostream& stream, const RenderingContext& context)
Template(std::ostream& stream, const OncePerAssetRenderingContext& context)
: BaseTemplate(stream, context)
{
}
@@ -764,7 +764,7 @@ namespace
};
} // namespace
std::vector<CodeTemplateFile> ZoneMarkTemplate::GetFilesToRender(const RenderingContext& context)
std::vector<CodeTemplateFile> ZoneMarkTemplate::GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context)
{
std::vector<CodeTemplateFile> files;
@@ -777,7 +777,7 @@ std::vector<CodeTemplateFile> ZoneMarkTemplate::GetFilesToRender(const Rendering
return files;
}
void ZoneMarkTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
void ZoneMarkTemplate::RenderOncePerAssetFile(std::ostream& stream, const CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context)
{
Template t(stream, context);

5
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.h
View File

@@ -1,9 +1,10 @@
#pragma once
#include "Generating/ICodeTemplate.h"
class ZoneMarkTemplate final : public ICodeTemplate
{
public:
std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
std::vector<CodeTemplateFile> GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context) override;
void RenderOncePerAssetFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context) override;
};

10
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp
View File

@@ -9,13 +9,13 @@
namespace
{
constexpr int TAG_HEADER = 1;
constexpr int TAG_SOURCE = 2;
constexpr CodeTemplateFileTag TAG_HEADER = 1;
constexpr CodeTemplateFileTag TAG_SOURCE = 2;
class Template final : BaseTemplate
{
public:
Template(std::ostream& stream, const RenderingContext& context)
Template(std::ostream& stream, const OncePerAssetRenderingContext& context)
: BaseTemplate(stream, context)
{
}
@@ -1233,7 +1233,7 @@ namespace
};
} // namespace
std::vector<CodeTemplateFile> ZoneWriteTemplate::GetFilesToRender(const RenderingContext& context)
std::vector<CodeTemplateFile> ZoneWriteTemplate::GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context)
{
std::vector<CodeTemplateFile> files;
@@ -1247,7 +1247,7 @@ std::vector<CodeTemplateFile> ZoneWriteTemplate::GetFilesToRender(const Renderin
return files;
}
void ZoneWriteTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
void ZoneWriteTemplate::RenderOncePerAssetFile(std::ostream& stream, const CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context)
{
Template t(stream, context);

5
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.h
View File

@@ -1,9 +1,10 @@
#pragma once
#include "Generating/ICodeTemplate.h"
class ZoneWriteTemplate final : public ICodeTemplate
{
public:
std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
std::vector<CodeTemplateFile> GetFilesToRenderOncePerAsset(const OncePerAssetRenderingContext& context) override;
void RenderOncePerAssetFile(std::ostream& stream, CodeTemplateFileTag fileTag, const OncePerAssetRenderingContext& context) override;
};