zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2026-03-17 02:13:02 +00:00
Code Activity

fix: compilation with CommonTechset

Browse Source
This commit is contained in:
Jan Laupetin
2026-02-04 21:05:39 +00:00
parent bf9beb1458
commit e749514972
28 changed files with 15 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/ObjLoading/Techset/CommonTechsetCache.cpp
View File

@@ -1,18 +0,0 @@
#include "CommonTechsetCache.h"
using namespace techset;
CommonTechset* CommonTechsetCache::GetCachedTechsetDefinition(const std::string& techsetName) const
{
const auto foundTechset = m_cache.find(techsetName);
if (foundTechset != m_cache.end())
return foundTechset->second.get();
return nullptr;
}
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
View File

@@ -1,21 +0,0 @@
#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

116
src/ObjLoading/Techset/TechniqueDefinitionAcceptor.cpp
View File

@@ -1,116 +0,0 @@
#include "TechniqueDefinitionAcceptor.h"
using namespace techset;
ShaderArgument::ShaderArgument()
: m_argument_index_specified(false),
m_argument_index(0u)
{
}
ShaderArgument::ShaderArgument(std::string argumentName)
: m_argument_name(std::move(argumentName)),
m_argument_index_specified(false),
m_argument_index(0u)
{
}
ShaderArgument::ShaderArgument(std::string argumentName, const unsigned argumentIndex)
: m_argument_name(std::move(argumentName)),
m_argument_index_specified(true),
m_argument_index(argumentIndex)
{
}
ShaderArgumentCodeSource::ShaderArgumentCodeSource()
: m_index_accessor_specified(false),
m_index_accessor(0u)
{
}
ShaderArgumentCodeSource::ShaderArgumentCodeSource(std::vector<std::string> accessors)
: m_accessors(std::move(accessors)),
m_index_accessor_specified(false),
m_index_accessor(0u)
{
}
ShaderArgumentCodeSource::ShaderArgumentCodeSource(std::vector<std::string> accessors, const unsigned indexAccessor)
: m_accessors(std::move(accessors)),
m_index_accessor_specified(true),
m_index_accessor(indexAccessor)
{
}
ShaderArgumentLiteralSource::ShaderArgumentLiteralSource()
: m_value{}
{
}
ShaderArgumentLiteralSource::ShaderArgumentLiteralSource(const float v0, const float v1, const float v2, const float v3)
: m_value{v0, v1, v2, v3}
{
}
ShaderArgumentLiteralSource::ShaderArgumentLiteralSource(float value[4])
: m_value{value[0], value[1], value[2], value[3]}
{
}
namespace techset
{
bool operator<(const ShaderArgumentLiteralSource& lhs, const ShaderArgumentLiteralSource& rhs)
{
if (lhs.m_value[0] < rhs.m_value[0])
return true;
if (lhs.m_value[0] > rhs.m_value[0])
return false;
if (lhs.m_value[1] < rhs.m_value[1])
return true;
if (lhs.m_value[1] > rhs.m_value[1])
return false;
if (lhs.m_value[2] < rhs.m_value[2])
return true;
if (lhs.m_value[2] > rhs.m_value[2])
return false;
if (lhs.m_value[3] < rhs.m_value[3])
return true;
if (lhs.m_value[3] > rhs.m_value[3])
return false;
return false;
}
bool operator<=(const ShaderArgumentLiteralSource& lhs, const ShaderArgumentLiteralSource& rhs)
{
return !(rhs < lhs);
}
bool operator>(const ShaderArgumentLiteralSource& lhs, const ShaderArgumentLiteralSource& rhs)
{
return rhs < lhs;
}
bool operator>=(const ShaderArgumentLiteralSource& lhs, const ShaderArgumentLiteralSource& rhs)
{
return !(lhs < rhs);
}
} // namespace techset
ShaderArgumentMaterialSource::ShaderArgumentMaterialSource()
: m_is_hash(false),
m_hash(0u)
{
}
ShaderArgumentMaterialSource::ShaderArgumentMaterialSource(const unsigned hash)
: m_is_hash(true),
m_hash(hash)
{
}
ShaderArgumentMaterialSource::ShaderArgumentMaterialSource(std::string name)
: m_is_hash(false),
m_hash(0u),
m_name(std::move(name))
{
}

100
src/ObjLoading/Techset/TechniqueDefinitionAcceptor.h
View File

@@ -1,100 +0,0 @@
#pragma once
#include <string>
#include <vector>
namespace techset
{
enum class ShaderSelector
{
VERTEX_SHADER,
PIXEL_SHADER
};
class ShaderArgument
{
public:
std::string m_argument_name;
bool m_argument_index_specified;
unsigned m_argument_index;
ShaderArgument();
explicit ShaderArgument(std::string argumentName);
ShaderArgument(std::string argumentName, unsigned argumentIndex);
};
class ShaderArgumentCodeSource
{
public:
std::vector<std::string> m_accessors;
bool m_index_accessor_specified;
unsigned m_index_accessor;
ShaderArgumentCodeSource();
explicit ShaderArgumentCodeSource(std::vector<std::string> accessors);
ShaderArgumentCodeSource(std::vector<std::string> accessors, unsigned indexAccessor);
};
class ShaderArgumentLiteralSource
{
public:
float m_value[4];
ShaderArgumentLiteralSource();
ShaderArgumentLiteralSource(float v0, float v1, float v2, float v3);
explicit ShaderArgumentLiteralSource(float value[4]);
friend bool operator<(const ShaderArgumentLiteralSource& lhs, const ShaderArgumentLiteralSource& rhs);
friend bool operator<=(const ShaderArgumentLiteralSource& lhs, const ShaderArgumentLiteralSource& rhs);
friend bool operator>(const ShaderArgumentLiteralSource& lhs, const ShaderArgumentLiteralSource& rhs);
friend bool operator>=(const ShaderArgumentLiteralSource& lhs, const ShaderArgumentLiteralSource& rhs);
};
class ShaderArgumentMaterialSource
{
public:
ShaderArgumentMaterialSource();
explicit ShaderArgumentMaterialSource(unsigned hash);
explicit ShaderArgumentMaterialSource(std::string name);
bool m_is_hash;
unsigned m_hash;
std::string m_name;
};
class ITechniqueDefinitionAcceptor
{
protected:
ITechniqueDefinitionAcceptor() = default;
public:
virtual ~ITechniqueDefinitionAcceptor() = default;
ITechniqueDefinitionAcceptor(const ITechniqueDefinitionAcceptor& other) = default;
ITechniqueDefinitionAcceptor(ITechniqueDefinitionAcceptor&& other) noexcept = default;
ITechniqueDefinitionAcceptor& operator=(const ITechniqueDefinitionAcceptor& other) = default;
ITechniqueDefinitionAcceptor& operator=(ITechniqueDefinitionAcceptor&& other) noexcept = default;
virtual void AcceptNextPass() = 0;
virtual bool AcceptEndPass(std::string& errorMessage) = 0;
virtual bool AcceptStateMap(const std::string& stateMapName, std::string& errorMessage) = 0;
virtual bool AcceptVertexShader(const std::string& vertexShaderName, std::string& errorMessage) = 0;
virtual bool AcceptPixelShader(const std::string& pixelShaderName, std::string& errorMessage) = 0;
virtual bool
AcceptShaderConstantArgument(ShaderSelector shader, ShaderArgument shaderArgument, ShaderArgumentCodeSource source, std::string& errorMessage) = 0;
virtual bool
AcceptShaderSamplerArgument(ShaderSelector shader, ShaderArgument shaderArgument, ShaderArgumentCodeSource source, std::string& errorMessage) = 0;
virtual bool AcceptShaderLiteralArgument(ShaderSelector shader,
ShaderArgument shaderArgument,
ShaderArgumentLiteralSource source,
std::string& errorMessage) = 0;
virtual bool AcceptShaderMaterialArgument(ShaderSelector shader,
ShaderArgument shaderArgument,
ShaderArgumentMaterialSource source,
std::string& errorMessage) = 0;
virtual bool AcceptVertexStreamRouting(const std::string& destination, const std::string& source, std::string& errorMessage) = 0;
};
} // namespace techset

39
src/ObjLoading/Techset/TechniqueFileReader.cpp
View File

@@ -1,39 +0,0 @@
#include "TechniqueFileReader.h"
#include "Parsing/Impl/CommentRemovingStreamProxy.h"
#include "Parsing/Impl/ParserSingleInputStream.h"
#include "Parsing/Simple/SimpleLexer.h"
#include "Parsing/TechniqueFileParser.h"
#include "Utils/Logging/Log.h"
#include <iostream>
using namespace techset;
TechniqueFileReader::TechniqueFileReader(std::istream& stream, std::string fileName, ITechniqueDefinitionAcceptor* acceptor)
: m_file_name(std::move(fileName)),
m_acceptor(acceptor)
{
m_base_stream = std::make_unique<ParserSingleInputStream>(stream, m_file_name);
m_comment_proxy = std::make_unique<CommentRemovingStreamProxy>(m_base_stream.get());
}
bool TechniqueFileReader::ReadTechniqueDefinition() 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 = true;
lexerConfig.m_read_floating_point_numbers = true;
const auto lexer = std::make_unique<SimpleLexer>(m_comment_proxy.get(), std::move(lexerConfig));
const auto parser = std::make_unique<TechniqueParser>(lexer.get(), m_acceptor);
const auto success = parser->Parse();
if (success)
return true;
con::error("Parsing technique file \"{}\" failed!", m_file_name);
return false;
}

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

@@ -1,25 +0,0 @@
#pragma once
#include "Parsing/IParserLineStream.h"
#include "TechniqueDefinitionAcceptor.h"
#include "Utils/ClassUtils.h"
#include <memory>
#include <string>
namespace techset
{
class TechniqueFileReader
{
public:
TechniqueFileReader(std::istream& stream, std::string fileName, ITechniqueDefinitionAcceptor* acceptor);
[[nodiscard]] bool ReadTechniqueDefinition() const;
private:
std::string m_file_name;
ITechniqueDefinitionAcceptor* m_acceptor;
std::unique_ptr<IParserLineStream> m_base_stream;
std::unique_ptr<IParserLineStream> m_comment_proxy;
};
} // namespace techset

33
src/ObjLoading/Techset/TechniqueStateMapCache.cpp
View File

@@ -1,33 +0,0 @@
#include "TechniqueStateMapCache.h"
using namespace techset;
const state_map::StateMapDefinition* TechniqueStateMapCache::GetCachedStateMap(const std::string& name) const
{
const auto foundStateMap = m_state_map_cache.find(name);
if (foundStateMap != m_state_map_cache.end())
return foundStateMap->second.get();
return nullptr;
}
void TechniqueStateMapCache::AddStateMapToCache(std::unique_ptr<state_map::StateMapDefinition> stateMap)
{
m_state_map_cache.emplace(std::make_pair(stateMap->m_name, std::move(stateMap)));
}
const state_map::StateMapDefinition* TechniqueStateMapCache::GetStateMapForTechnique(const std::string& techniqueName) const
{
const auto foundTechnique = m_state_map_per_technique.find(techniqueName);
if (foundTechnique != m_state_map_per_technique.end())
return foundTechnique->second;
return nullptr;
}
void TechniqueStateMapCache::SetTechniqueUsesStateMap(std::string techniqueName, const state_map::StateMapDefinition* stateMap)
{
m_state_map_per_technique.emplace(std::make_pair(std::move(techniqueName), stateMap));
}

26
src/ObjLoading/Techset/TechniqueStateMapCache.h
View File

@@ -1,26 +0,0 @@
#pragma once
#include "Asset/IZoneAssetCreationState.h"
#include "StateMap/StateMapDefinition.h"
#include "Utils/ClassUtils.h"
#include <memory>
#include <string>
#include <unordered_map>
namespace techset
{
class TechniqueStateMapCache final : public IZoneAssetCreationState
{
public:
_NODISCARD const state_map::StateMapDefinition* GetCachedStateMap(const std::string& name) const;
void AddStateMapToCache(std::unique_ptr<state_map::StateMapDefinition> stateMap);
_NODISCARD const state_map::StateMapDefinition* GetStateMapForTechnique(const std::string& techniqueName) const;
void SetTechniqueUsesStateMap(std::string techniqueName, const state_map::StateMapDefinition* stateMap);
private:
std::unordered_map<std::string, const state_map::StateMapDefinition*> m_state_map_per_technique;
std::unordered_map<std::string, std::unique_ptr<state_map::StateMapDefinition>> m_state_map_cache;
};
} // namespace techset