zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2026-01-24 08:53:04 +00:00
Code Activity

chore: use CommonTechset instead of TechsetDefinition

Browse Source
This commit is contained in:
Jan Laupetin
2026-01-19 22:13:12 +00:00
parent 2a034d512e
commit d714afbcdd
40 changed files with 306 additions and 301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/ObjLoading/Techset/TechsetDefinitionCache.cpp → src/ObjLoading/Techset/CommonTechsetCache.cpp
View File

@@ -1,8 +1,8 @@
#include "TechsetDefinitionCache.h"
#include "CommonTechsetCache.h"
using namespace techset;
TechsetDefinition* TechsetDefinitionCache::GetCachedTechsetDefinition(const std::string& techsetName) const
CommonTechset* CommonTechsetCache::GetCachedTechsetDefinition(const std::string& techsetName) const
{
const auto foundTechset = m_cache.find(techsetName);
@@ -12,7 +12,7 @@ TechsetDefinition* TechsetDefinitionCache::GetCachedTechsetDefinition(const std:
return nullptr;
}
void TechsetDefinitionCache::AddTechsetDefinitionToCache(std::string name, std::unique_ptr<TechsetDefinition> definition)
void CommonTechsetCache::AddCommonTechsetToCache(std::string name, std::unique_ptr<CommonTechset> definition)
{
m_cache.emplace(std::make_pair(std::move(name), std::move(definition)));
}

21
src/ObjLoading/Techset/CommonTechsetCache.h Normal file
View File

@@ -0,0 +1,21 @@
#pragma once
#include "Asset/IZoneAssetCreationState.h"
#include "Techset/CommonTechset.h"
#include <memory>
#include <string>
#include <unordered_map>
namespace techset
{
class CommonTechsetCache final : public IZoneAssetCreationState
{
public:
[[nodiscard]] CommonTechset* GetCachedTechsetDefinition(const std::string& techsetName) const;
void AddCommonTechsetToCache(std::string name, std::unique_ptr<CommonTechset> definition);
private:
std::unordered_map<std::string, std::unique_ptr<CommonTechset>> m_cache;
};
} // namespace techset

41
src/ObjLoading/Techset/Parsing/Sequence/TechniqueNoScopeSequences.cpp
View File

@@ -1,41 +0,0 @@
#include "TechniqueNoScopeSequences.h"
#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
#include <cassert>
using namespace techset;
namespace techset
{
class SequencePass final : public TechniqueParser::sequence_t
{
public:
SequencePass()
{
const SimpleMatcherFactory create(this);
AddMatchers({
create.Char('{'),
});
}
protected:
void ProcessMatch(TechniqueParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
assert(state->m_in_pass == false);
state->m_in_pass = true;
state->m_acceptor->AcceptNextPass();
}
};
} // namespace techset
const std::vector<TechniqueParser::sequence_t*>& TechniqueNoScopeSequences::GetSequences()
{
static std::vector<TechniqueParser::sequence_t*> tests({
new SequencePass(),
});
return tests;
}

15
src/ObjLoading/Techset/Parsing/Sequence/TechniqueNoScopeSequences.h
View File

@@ -1,15 +0,0 @@
#pragma once
#include "Techset/Parsing/TechniqueFileParser.h"
#include <vector>
namespace techset
{
class TechniqueNoScopeSequences
{
TechniqueNoScopeSequences() = default;
public:
static const std::vector<TechniqueParser::sequence_t*>& GetSequences();
};
} // namespace techset

215
src/ObjLoading/Techset/Parsing/Sequence/TechniquePassScopeSequences.cpp
View File

@@ -1,215 +0,0 @@
#include "TechniquePassScopeSequences.h"
#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
#include <cassert>
#include <sstream>
using namespace techset;
namespace techset
{
class SequenceEndPass final : public TechniqueParser::sequence_t
{
static constexpr auto CAPTURE_FIRST_TOKEN = 1;
public:
SequenceEndPass()
{
const SimpleMatcherFactory create(this);
AddMatchers({
create.Char('}').Capture(CAPTURE_FIRST_TOKEN),
});
}
protected:
void ProcessMatch(TechniqueParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
assert(state->m_in_pass == true);
std::string errorMessage;
if (!state->m_acceptor->AcceptEndPass(errorMessage))
throw ParsingException(result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), errorMessage);
state->m_in_pass = false;
}
};
class SequenceStateMap final : public TechniqueParser::sequence_t
{
static constexpr auto CAPTURE_START = 1;
static constexpr auto CAPTURE_STATE_MAP_NAME = 2;
public:
SequenceStateMap()
{
const SimpleMatcherFactory create(this);
AddMatchers({
create.Keyword("stateMap").Capture(CAPTURE_START),
create.String().Capture(CAPTURE_STATE_MAP_NAME),
create.Char(';'),
});
}
protected:
void ProcessMatch(TechniqueParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
const auto& firstToken = result.NextCapture(CAPTURE_START);
std::string errorMessage;
const auto acceptorResult = state->m_acceptor->AcceptStateMap(result.NextCapture(CAPTURE_STATE_MAP_NAME).StringValue(), errorMessage);
if (!acceptorResult)
throw ParsingException(firstToken.GetPos(), std::move(errorMessage));
}
};
class SequenceShader final : public TechniqueParser::sequence_t
{
static constexpr auto TAG_VERTEX_SHADER = 1;
static constexpr auto TAG_PIXEL_SHADER = 2;
static constexpr auto CAPTURE_START = 1;
static constexpr auto CAPTURE_VERSION = 2;
static constexpr auto CAPTURE_VERSION_MAJOR = 3;
static constexpr auto CAPTURE_VERSION_MINOR = 4;
static constexpr auto CAPTURE_SHADER_NAME = 5;
public:
SequenceShader()
{
const SimpleMatcherFactory create(this);
AddMatchers({
create
.Or({
create.Keyword("vertexShader").Tag(TAG_VERTEX_SHADER),
create.Keyword("pixelShader").Tag(TAG_PIXEL_SHADER),
})
.Capture(CAPTURE_START),
create.Or({
create.And({
create.Integer().Capture(CAPTURE_VERSION_MAJOR),
create.Char('.'),
create.Integer().Capture(CAPTURE_VERSION_MINOR),
}),
create.FloatingPoint().Capture(CAPTURE_VERSION), // This is dumb but cod devs made the format so cannot change it
create.String().Capture(CAPTURE_VERSION),
}),
create.String().Capture(CAPTURE_SHADER_NAME),
create.Char('{'),
});
}
protected:
void ProcessMatch(TechniqueParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
const auto& firstToken = result.NextCapture(CAPTURE_START);
// Don't care about shader version since it's stated in the shader bin anyway
const auto& shaderNameToken = result.NextCapture(CAPTURE_SHADER_NAME);
bool acceptorResult;
std::string errorMessage;
const auto shaderTag = result.NextTag();
assert(shaderTag == TAG_VERTEX_SHADER || shaderTag == TAG_PIXEL_SHADER);
if (shaderTag == TAG_VERTEX_SHADER)
{
acceptorResult = state->m_acceptor->AcceptVertexShader(shaderNameToken.StringValue(), errorMessage);
state->m_current_shader = ShaderSelector::VERTEX_SHADER;
}
else
{
acceptorResult = state->m_acceptor->AcceptPixelShader(shaderNameToken.StringValue(), errorMessage);
state->m_current_shader = ShaderSelector::PIXEL_SHADER;
}
state->m_in_shader = true;
if (!acceptorResult)
throw ParsingException(firstToken.GetPos(), std::move(errorMessage));
}
};
class SequenceVertexStreamRouting final : public TechniqueParser::sequence_t
{
static constexpr auto CAPTURE_FIRST_TOKEN = 1;
static constexpr auto CAPTURE_STREAM_DESTINATION_NAME = 2;
static constexpr auto CAPTURE_STREAM_DESTINATION_INDEX = 3;
static constexpr auto CAPTURE_STREAM_SOURCE_NAME = 4;
static constexpr auto CAPTURE_STREAM_SOURCE_INDEX = 5;
public:
SequenceVertexStreamRouting()
{
const SimpleMatcherFactory create(this);
AddMatchers({
create.Keyword("vertex").Capture(CAPTURE_FIRST_TOKEN),
create.Char('.'),
create.Identifier().Capture(CAPTURE_STREAM_DESTINATION_NAME),
create.Optional(create.And({
create.Char('['),
create.Integer().Capture(CAPTURE_STREAM_DESTINATION_INDEX),
create.Char(']'),
})),
create.Char('='),
create.Keyword("code"),
create.Char('.'),
create.Identifier().Capture(CAPTURE_STREAM_SOURCE_NAME),
create.Optional(create.And({
create.Char('['),
create.Integer().Capture(CAPTURE_STREAM_SOURCE_INDEX),
create.Char(']'),
})),
create.Char(';'),
});
}
static std::string CreateRoutingString(SequenceResult<SimpleParserValue>& result, const int nameCapture, const int indexCapture)
{
if (result.HasNextCapture(indexCapture))
{
const auto& indexToken = result.NextCapture(indexCapture);
if (indexToken.IntegerValue() < 0)
throw ParsingException(indexToken.GetPos(), "Index cannot be negative");
std::ostringstream ss;
ss << result.NextCapture(nameCapture).IdentifierValue() << '[' << indexToken.IntegerValue() << ']';
return ss.str();
}
return result.NextCapture(nameCapture).IdentifierValue();
}
protected:
void ProcessMatch(TechniqueParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
const auto& firstToken = result.NextCapture(CAPTURE_FIRST_TOKEN);
const std::string destinationString = CreateRoutingString(result, CAPTURE_STREAM_DESTINATION_NAME, CAPTURE_STREAM_DESTINATION_INDEX);
const std::string sourceString = CreateRoutingString(result, CAPTURE_STREAM_SOURCE_NAME, CAPTURE_STREAM_SOURCE_INDEX);
std::string errorMessage;
if (!state->m_acceptor->AcceptVertexStreamRouting(destinationString, sourceString, errorMessage))
throw ParsingException(firstToken.GetPos(), std::move(errorMessage));
}
};
} // namespace techset
const std::vector<TechniqueParser::sequence_t*>& TechniquePassScopeSequences::GetSequences()
{
static std::vector<TechniqueParser::sequence_t*> tests({
new SequenceEndPass(),
new SequenceStateMap(),
new SequenceShader(),
new SequenceVertexStreamRouting(),
});
return tests;
}

15
src/ObjLoading/Techset/Parsing/Sequence/TechniquePassScopeSequences.h
View File

@@ -1,15 +0,0 @@
#pragma once
#include "Techset/Parsing/TechniqueFileParser.h"
#include <vector>
namespace techset
{
class TechniquePassScopeSequences
{
TechniquePassScopeSequences() = default;
public:
static const std::vector<TechniqueParser::sequence_t*>& GetSequences();
};
} // namespace techset

242
src/ObjLoading/Techset/Parsing/Sequence/TechniqueShaderScopeSequences.cpp
View File

@@ -1,242 +0,0 @@
#include "TechniqueShaderScopeSequences.h"
#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
#include <cassert>
using namespace techset;
namespace techset
{
class SequenceEndShader final : public TechniqueParser::sequence_t
{
public:
SequenceEndShader()
{
const SimpleMatcherFactory create(this);
AddMatchers({
create.Char('}'),
});
}
protected:
void ProcessMatch(TechniqueParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
assert(state->m_in_shader == true);
state->m_in_shader = false;
}
};
class SequenceShaderArgument final : public TechniqueParser::sequence_t
{
static constexpr auto TAG_CONSTANT = 1;
static constexpr auto TAG_SAMPLER = 2;
static constexpr auto TAG_LITERAL = 3;
static constexpr auto TAG_MATERIAL = 4;
static constexpr auto CAPTURE_FIRST_TOKEN = 1;
static constexpr auto CAPTURE_SHADER_ARGUMENT = 2;
static constexpr auto CAPTURE_SHADER_INDEX = 3;
static constexpr auto CAPTURE_CODE_ACCESSOR = 4;
static constexpr auto CAPTURE_CODE_INDEX = 5;
static constexpr auto CAPTURE_LITERAL_VALUE = 6;
static constexpr auto CAPTURE_MATERIAL_HASH = 7;
static constexpr auto CAPTURE_MATERIAL_NAME = 8;
static std::unique_ptr<matcher_t> CodeMatchers(const SimpleMatcherFactory& create)
{
return create.And({
create.Or({
create.Keyword("constant").Tag(TAG_CONSTANT),
create.Keyword("sampler").Tag(TAG_SAMPLER),
}),
create.Char('.'),
create.Identifier().Capture(CAPTURE_CODE_ACCESSOR),
create.OptionalLoop(create.And({
create.Char('.'),
create.Identifier().Capture(CAPTURE_CODE_ACCESSOR),
})),
create.Optional(create.And({
create.Char('['),
create.Integer().Capture(CAPTURE_CODE_INDEX),
create.Char(']'),
})),
});
}
static std::unique_ptr<matcher_t> LiteralValueMatchers(const SimpleMatcherFactory& create)
{
return create
.Or({
create.FloatingPoint(),
create.Integer(),
})
.Capture(CAPTURE_LITERAL_VALUE);
}
static std::unique_ptr<matcher_t> LiteralMatchers(const SimpleMatcherFactory& create)
{
return create
.And({
create.Keyword("float4"),
create.Char('('),
LiteralValueMatchers(create),
create.Char(','),
LiteralValueMatchers(create),
create.Char(','),
LiteralValueMatchers(create),
create.Char(','),
LiteralValueMatchers(create),
create.Char(')'),
})
.Tag(TAG_LITERAL);
}
static std::unique_ptr<matcher_t> MaterialMatchers(const SimpleMatcherFactory& create)
{
return create
.And({
create.Keyword("material"),
create.Char('.'),
create.Or({
create.And({
create.Char('#'),
create.Integer().Capture(CAPTURE_MATERIAL_HASH),
}),
create.Identifier().Capture(CAPTURE_MATERIAL_NAME),
}),
})
.Tag(TAG_MATERIAL);
}
public:
SequenceShaderArgument()
{
const SimpleMatcherFactory create(this);
AddMatchers({
create.Identifier().Capture(CAPTURE_FIRST_TOKEN).NoConsume(),
create.Identifier().Capture(CAPTURE_SHADER_ARGUMENT),
create.Optional(create.And({
create.Char('['),
create.Integer().Capture(CAPTURE_SHADER_INDEX),
create.Char(']'),
})),
create.Char('='),
create.Or({
CodeMatchers(create),
LiteralMatchers(create),
MaterialMatchers(create),
}),
create.Char(';'),
});
}
static void ProcessCodeArgument(const TechniqueParserState* state, SequenceResult<SimpleParserValue>& result, ShaderArgument arg, const bool isSampler)
{
std::vector<std::string> accessors;
while (result.HasNextCapture(CAPTURE_CODE_ACCESSOR))
accessors.emplace_back(result.NextCapture(CAPTURE_CODE_ACCESSOR).IdentifierValue());
ShaderArgumentCodeSource source;
if (result.HasNextCapture(CAPTURE_CODE_INDEX))
{
const auto& codeIndexToken = result.NextCapture(CAPTURE_CODE_INDEX);
if (codeIndexToken.IntegerValue() < 0)
throw ParsingException(codeIndexToken.GetPos(), "Index cannot be negative");
source = ShaderArgumentCodeSource(std::move(accessors), static_cast<size_t>(codeIndexToken.IntegerValue()));
}
else
source = ShaderArgumentCodeSource(std::move(accessors));
std::string errorMessage;
if (!isSampler)
{
if (!state->m_acceptor->AcceptShaderConstantArgument(state->m_current_shader, std::move(arg), std::move(source), errorMessage))
throw ParsingException(result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), std::move(errorMessage));
}
else
{
if (!state->m_acceptor->AcceptShaderSamplerArgument(state->m_current_shader, std::move(arg), std::move(source), errorMessage))
throw ParsingException(result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), std::move(errorMessage));
}
}
static void ProcessLiteralArgument(const TechniqueParserState* state, SequenceResult<SimpleParserValue>& result, ShaderArgument arg)
{
float value[4];
for (float& i : value)
{
const auto& literalValueToken = result.NextCapture(CAPTURE_LITERAL_VALUE);
if (literalValueToken.m_type == SimpleParserValueType::FLOATING_POINT)
i = static_cast<float>(literalValueToken.FloatingPointValue());
else
i = static_cast<float>(literalValueToken.IntegerValue());
}
const ShaderArgumentLiteralSource source(value);
std::string errorMessage;
if (!state->m_acceptor->AcceptShaderLiteralArgument(state->m_current_shader, std::move(arg), source, errorMessage))
throw ParsingException(result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), std::move(errorMessage));
}
static void ProcessMaterialArgument(const TechniqueParserState* state, SequenceResult<SimpleParserValue>& result, ShaderArgument arg)
{
std::string errorMessage;
if (result.HasNextCapture(CAPTURE_MATERIAL_HASH))
{
ShaderArgumentMaterialSource source(static_cast<size_t>(result.NextCapture(CAPTURE_MATERIAL_HASH).IntegerValue()));
if (!state->m_acceptor->AcceptShaderMaterialArgument(state->m_current_shader, std::move(arg), std::move(source), errorMessage))
throw ParsingException(result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), std::move(errorMessage));
}
else
{
ShaderArgumentMaterialSource source(result.NextCapture(CAPTURE_MATERIAL_NAME).IdentifierValue());
if (!state->m_acceptor->AcceptShaderMaterialArgument(state->m_current_shader, std::move(arg), std::move(source), errorMessage))
throw ParsingException(result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), std::move(errorMessage));
}
}
protected:
void ProcessMatch(TechniqueParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
assert(state->m_in_shader == true);
const auto& shaderArgumentNameToken = result.NextCapture(CAPTURE_SHADER_ARGUMENT);
ShaderArgument arg;
if (result.HasNextCapture(CAPTURE_SHADER_INDEX))
{
const auto& shaderArgumentIndexToken = result.NextCapture(CAPTURE_SHADER_INDEX);
if (shaderArgumentIndexToken.IntegerValue() < 0)
throw ParsingException(shaderArgumentIndexToken.GetPos(), "Index cannot be negative");
const auto index = static_cast<unsigned>(shaderArgumentIndexToken.IntegerValue());
arg = ShaderArgument(shaderArgumentNameToken.IdentifierValue(), index);
}
else
arg = ShaderArgument(shaderArgumentNameToken.IdentifierValue());
const auto typeTag = result.NextTag();
assert(typeTag == TAG_CONSTANT || typeTag == TAG_SAMPLER || typeTag == TAG_LITERAL || typeTag == TAG_MATERIAL);
if (typeTag == TAG_CONSTANT || typeTag == TAG_SAMPLER)
ProcessCodeArgument(state, result, std::move(arg), typeTag == TAG_SAMPLER);
else if (typeTag == TAG_LITERAL)
ProcessLiteralArgument(state, result, std::move(arg));
else
ProcessMaterialArgument(state, result, std::move(arg));
}
};
} // namespace techset
const std::vector<TechniqueParser::sequence_t*>& TechniqueShaderScopeSequences::GetSequences()
{
static std::vector<TechniqueParser::sequence_t*> tests({
new SequenceEndShader(),
new SequenceShaderArgument(),
});
return tests;
}

15
src/ObjLoading/Techset/Parsing/Sequence/TechniqueShaderScopeSequences.h
View File

@@ -1,15 +0,0 @@
#pragma once
#include "Techset/Parsing/TechniqueFileParser.h"
#include <vector>
namespace techset
{
class TechniqueShaderScopeSequences
{
TechniqueShaderScopeSequences() = default;
public:
static const std::vector<TechniqueParser::sequence_t*>& GetSequences();
};
} // namespace techset

23
src/ObjLoading/Techset/Parsing/TechniqueFileParser.cpp
View File

@@ -1,23 +0,0 @@
#include "TechniqueFileParser.h"
#include "Sequence/TechniqueNoScopeSequences.h"
#include "Sequence/TechniquePassScopeSequences.h"
#include "Sequence/TechniqueShaderScopeSequences.h"
using namespace techset;
TechniqueParser::TechniqueParser(SimpleLexer* lexer, ITechniqueDefinitionAcceptor* acceptor)
: AbstractParser(lexer, std::make_unique<TechniqueParserState>(acceptor))
{
}
const std::vector<TechniqueParser::sequence_t*>& TechniqueParser::GetTestsForState()
{
if (m_state->m_in_shader)
return TechniqueShaderScopeSequences::GetSequences();
if (m_state->m_in_pass)
return TechniquePassScopeSequences::GetSequences();
return TechniqueNoScopeSequences::GetSequences();
}

18
src/ObjLoading/Techset/Parsing/TechniqueFileParser.h
View File

@@ -1,18 +0,0 @@
#pragma once
#include "Parsing/Impl/AbstractParser.h"
#include "Parsing/Simple/SimpleLexer.h"
#include "Parsing/Simple/SimpleParserValue.h"
#include "TechniqueFileParserState.h"
namespace techset
{
class TechniqueParser final : public AbstractParser<SimpleParserValue, TechniqueParserState>
{
protected:
const std::vector<sequence_t*>& GetTestsForState() override;
public:
TechniqueParser(SimpleLexer* lexer, ITechniqueDefinitionAcceptor* acceptor);
};
} // namespace techset

14
src/ObjLoading/Techset/Parsing/TechniqueFileParserState.cpp
View File

@@ -1,14 +0,0 @@
#include "TechniqueFileParserState.h"
#include <cassert>
using namespace techset;
TechniqueParserState::TechniqueParserState(ITechniqueDefinitionAcceptor* acceptor)
: m_acceptor(acceptor),
m_in_pass(false),
m_in_shader(false),
m_current_shader(ShaderSelector::VERTEX_SHADER)
{
assert(acceptor);
}

18
src/ObjLoading/Techset/Parsing/TechniqueFileParserState.h
View File

@@ -1,18 +0,0 @@
#pragma once
#include "Techset/TechniqueDefinitionAcceptor.h"
namespace techset
{
class TechniqueParserState
{
public:
ITechniqueDefinitionAcceptor* const m_acceptor;
bool m_in_pass;
bool m_in_shader;
ShaderSelector m_current_shader;
explicit TechniqueParserState(ITechniqueDefinitionAcceptor* acceptor);
};
} // namespace techset

94
src/ObjLoading/Techset/Parsing/TechsetFileParser.cpp
View File

@@ -1,94 +0,0 @@
#include "TechsetFileParser.h"
#include "Parsing/Simple/Matcher/SimpleMatcherFactory.h"
using namespace techset;
namespace techset
{
class SequenceTechniqueTypeName final : public TechsetParser::sequence_t
{
static constexpr auto CAPTURE_TYPE_NAME = 1;
public:
SequenceTechniqueTypeName()
{
const SimpleMatcherFactory create(this);
AddMatchers({
create.String().Capture(CAPTURE_TYPE_NAME),
create.Char(':'),
});
}
protected:
void ProcessMatch(TechsetParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
const auto& typeNameToken = result.NextCapture(CAPTURE_TYPE_NAME);
size_t techniqueTypeIndex;
if (!state->FindTechniqueTypeIndex(typeNameToken.StringValue(), techniqueTypeIndex))
throw ParsingException(typeNameToken.GetPos(), "Unknown technique type name");
state->m_current_technique_types.push_back(techniqueTypeIndex);
}
};
class SequenceTechniqueName final : public TechsetParser::sequence_t
{
static constexpr auto CAPTURE_NAME = 1;
public:
SequenceTechniqueName()
{
const SimpleMatcherFactory create(this);
AddMatchers({
create
.Or({
create.Identifier(),
create.String(),
})
.Capture(CAPTURE_NAME),
create.Char(';'),
});
}
protected:
void ProcessMatch(TechsetParserState* state, SequenceResult<SimpleParserValue>& result) const override
{
assert(!state->m_current_technique_types.empty());
const auto& techniqueNameToken = result.NextCapture(CAPTURE_NAME);
const auto& techniqueName =
techniqueNameToken.m_type == SimpleParserValueType::STRING ? techniqueNameToken.StringValue() : techniqueNameToken.IdentifierValue();
for (const auto techniqueTypeIndex : state->m_current_technique_types)
state->m_definition->SetTechniqueByIndex(techniqueTypeIndex, techniqueName);
state->m_current_technique_types.clear();
}
};
} // namespace techset
TechsetParser::TechsetParser(SimpleLexer* lexer, const char** validTechniqueTypeNames, const size_t validTechniqueTypeNameCount)
: AbstractParser(lexer, std::make_unique<TechsetParserState>(validTechniqueTypeNames, validTechniqueTypeNameCount))
{
}
const std::vector<TechsetParser::sequence_t*>& TechsetParser::GetTestsForState()
{
static std::vector<sequence_t*> allTests({
new SequenceTechniqueTypeName(),
new SequenceTechniqueName(),
});
static std::vector<sequence_t*> techniqueTypeNameOnlyTests({
new SequenceTechniqueTypeName(),
});
return m_state->m_current_technique_types.empty() ? techniqueTypeNameOnlyTests : allTests;
}
std::unique_ptr<TechsetDefinition> TechsetParser::GetTechsetDefinition() const
{
return std::move(m_state->m_definition);
}

21
src/ObjLoading/Techset/Parsing/TechsetFileParser.h
View File

@@ -1,21 +0,0 @@
#pragma once
#include "Parsing/Impl/AbstractParser.h"
#include "Parsing/Simple/SimpleLexer.h"
#include "Parsing/Simple/SimpleParserValue.h"
#include "Techset/TechsetDefinition.h"
#include "TechsetFileParserState.h"
#include "Utils/ClassUtils.h"
namespace techset
{
class TechsetParser final : public AbstractParser<SimpleParserValue, TechsetParserState>
{
protected:
const std::vector<sequence_t*>& GetTestsForState() override;
public:
TechsetParser(SimpleLexer* lexer, const char** validTechniqueTypeNames, size_t validTechniqueTypeNameCount);
_NODISCARD std::unique_ptr<TechsetDefinition> GetTechsetDefinition() const;
};
} // namespace techset

25
src/ObjLoading/Techset/Parsing/TechsetFileParserState.cpp
View File

@@ -1,25 +0,0 @@
#include "TechsetFileParserState.h"
using namespace techset;
TechsetParserState::TechsetParserState(const char** validTechniqueTypeNames, size_t validTechniqueTypeNameCount)
: m_definition(std::make_unique<TechsetDefinition>(validTechniqueTypeNameCount))
{
for (auto i = 0u; i < validTechniqueTypeNameCount; i++)
{
m_valid_technique_type_names.emplace(std::make_pair(std::string(validTechniqueTypeNames[i]), i));
}
}
bool TechsetParserState::FindTechniqueTypeIndex(const std::string& techniqueTypeName, size_t& techniqueTypeIndex) const
{
const auto foundTechniqueType = m_valid_technique_type_names.find(techniqueTypeName);
if (foundTechniqueType != m_valid_technique_type_names.end())
{
techniqueTypeIndex = foundTechniqueType->second;
return true;
}
return false;
}

22
src/ObjLoading/Techset/Parsing/TechsetFileParserState.h
View File

@@ -1,22 +0,0 @@
#pragma once
#include "Techset/TechsetDefinition.h"
#include <map>
#include <memory>
#include <string>
namespace techset
{
class TechsetParserState
{
public:
std::map<std::string, size_t> m_valid_technique_type_names;
std::unique_ptr<TechsetDefinition> m_definition;
std::vector<size_t> m_current_technique_types;
TechsetParserState(const char** validTechniqueTypeNames, size_t validTechniqueTypeNameCount);
bool FindTechniqueTypeIndex(const std::string& techniqueTypeName, size_t& techniqueTypeIndex) const;
};
} // namespace techset

31
src/ObjLoading/Techset/TechsetDefinition.cpp
View File

@@ -1,31 +0,0 @@
#include "TechsetDefinition.h"
#include <cassert>
using namespace techset;
TechsetDefinition::TechsetDefinition(const size_t techniqueTypeCount)
: m_has_technique(techniqueTypeCount),
m_technique_names(techniqueTypeCount)
{
}
bool TechsetDefinition::GetTechniqueByIndex(const size_t index, std::string& techniqueName) const
{
assert(index < m_has_technique.size());
if (index >= m_has_technique.size() || !m_has_technique[index])
return false;
techniqueName = m_technique_names[index];
return true;
}
void TechsetDefinition::SetTechniqueByIndex(const size_t index, std::string techniqueName)
{
assert(index < m_has_technique.size());
if (index >= m_has_technique.size())
return;
m_has_technique[index] = true;
m_technique_names[index] = std::move(techniqueName);
}

18
src/ObjLoading/Techset/TechsetDefinition.h
View File

@@ -1,18 +0,0 @@
#pragma once
#include <string>
#include <vector>
namespace techset
{
class TechsetDefinition
{
std::vector<bool> m_has_technique;
std::vector<std::string> m_technique_names;
public:
explicit TechsetDefinition(size_t techniqueTypeCount);
bool GetTechniqueByIndex(size_t index, std::string& techniqueName) const;
void SetTechniqueByIndex(size_t index, std::string techniqueName);
};
} // namespace techset

22
src/ObjLoading/Techset/TechsetDefinitionCache.h
View File

@@ -1,22 +0,0 @@
#pragma once
#include "Asset/IZoneAssetCreationState.h"
#include "TechsetDefinition.h"
#include "Utils/ClassUtils.h"
#include <memory>
#include <string>
#include <unordered_map>
namespace techset
{
class TechsetDefinitionCache final : public IZoneAssetCreationState
{
public:
_NODISCARD TechsetDefinition* GetCachedTechsetDefinition(const std::string& techsetName) const;
void AddTechsetDefinitionToCache(std::string name, std::unique_ptr<TechsetDefinition> definition);
private:
std::unordered_map<std::string, std::unique_ptr<TechsetDefinition>> m_cache;
};
} // namespace techset

40
src/ObjLoading/Techset/TechsetFileReader.cpp
View File

@@ -1,40 +0,0 @@
#include "TechsetFileReader.h"
#include "Parsing/Impl/CommentRemovingStreamProxy.h"
#include "Parsing/Impl/ParserSingleInputStream.h"
#include "Parsing/TechsetFileParser.h"
#include "Utils/Logging/Log.h"
#include <format>
#include <iostream>
using namespace techset;
TechsetFileReader::TechsetFileReader(std::istream& stream, std::string fileName, const char** validTechniqueTypeNames, const size_t validTechniqueTypeNameCount)
: m_file_name(std::move(fileName)),
m_valid_technique_type_names(validTechniqueTypeNames),
m_valid_technique_type_name_count(validTechniqueTypeNameCount)
{
m_base_stream = std::make_unique<ParserSingleInputStream>(stream, m_file_name);
m_comment_proxy = std::make_unique<CommentRemovingStreamProxy>(m_base_stream.get());
}
std::unique_ptr<techset::TechsetDefinition> TechsetFileReader::ReadTechsetDefinition() const
{
SimpleLexer::Config lexerConfig;
lexerConfig.m_emit_new_line_tokens = false;
lexerConfig.m_read_strings = true;
lexerConfig.m_string_escape_sequences = false;
lexerConfig.m_read_integer_numbers = false;
lexerConfig.m_read_floating_point_numbers = false;
const auto lexer = std::make_unique<SimpleLexer>(m_comment_proxy.get(), std::move(lexerConfig));
const auto parser = std::make_unique<techset::TechsetParser>(lexer.get(), m_valid_technique_type_names, m_valid_technique_type_name_count);
const auto success = parser->Parse();
if (success)
return parser->GetTechsetDefinition();
con::error("Parsing techset file \"{}\" failed!", m_file_name);
return nullptr;
}

25
src/ObjLoading/Techset/TechsetFileReader.h
View File

@@ -1,25 +0,0 @@
#pragma once
#include "Parsing/IParserLineStream.h"
#include "TechsetDefinition.h"
#include "Utils/ClassUtils.h"
#include <memory>
#include <string>
namespace techset
{
class TechsetFileReader
{
std::string m_file_name;
const char** m_valid_technique_type_names;
size_t m_valid_technique_type_name_count;
std::unique_ptr<IParserLineStream> m_base_stream;
std::unique_ptr<IParserLineStream> m_comment_proxy;
public:
TechsetFileReader(std::istream& stream, std::string fileName, const char** validTechniqueTypeNames, size_t validTechniqueTypeNameCount);
_NODISCARD std::unique_ptr<TechsetDefinition> ReadTechsetDefinition() const;
};
} // namespace techset