INSANEMODE/OpenAssetTools
1
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-06-12 07:48:16 -05:00
Code Issues Packages Projects Releases Wiki Activity

Reformat code with clang format

Browse Source
This commit is contained in:
Clang Format
2023-11-19 15:28:38 +01:00
committed by Jan
parent 22e17272fd
commit 6b4f5d94a8
1099 changed files with 16763 additions and 18076 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/ObjLoading/StateMap/Parsing/Matcher/StateMapExpressionMatchers.h
View File

@ -1,10 +1,10 @@
#pragma once
#include <memory>
#include "Parsing/Simple/Expression/SimpleExpressionMatchers.h"
#include "StateMap/Parsing/StateMapParserState.h"
#include <memory>
namespace state_map
{
class StateMapExpressionMatchers final : public SimpleExpressionMatchers
@ -20,4 +20,4 @@ namespace state_map
private:
StateMapParserState* m_state;
};
}
} // namespace state_map

76
src/ObjLoading/StateMap/Parsing/StateMapParser.cpp
View File

@ -16,10 +16,7 @@ namespace state_map
{
const SimpleMatcherFactory create(this);
AddMatchers({
create.Identifier().Capture(CAPTURE_ENTRY_NAME),
create.Char('{')
});
AddMatchers({create.Identifier().Capture(CAPTURE_ENTRY_NAME), create.Char('{')});
}
protected:
@ -45,9 +42,7 @@ namespace state_map
{
const SimpleMatcherFactory create(this);
AddMatchers({
create.Char('}').Capture(CAPTURE_FIRST_TOKEN)
});
AddMatchers({create.Char('}').Capture(CAPTURE_FIRST_TOKEN)});
}
protected:
@ -72,13 +67,9 @@ namespace state_map
AddLabeledMatchers(StateMapExpressionMatchers().Expression(this), StateMapExpressionMatchers::LABEL_EXPRESSION);
const SimpleMatcherFactory create(this);
AddMatchers({
create.Or({
create.Keyword("default").Tag(TAG_DEFAULT),
create.Label(StateMapExpressionMatchers::LABEL_EXPRESSION).Tag(TAG_EXPRESSION)
}),
create.Char(':')
});
AddMatchers(
{create.Or({create.Keyword("default").Tag(TAG_DEFAULT), create.Label(StateMapExpressionMatchers::LABEL_EXPRESSION).Tag(TAG_EXPRESSION)}),
create.Char(':')});
}
protected:
@ -126,26 +117,14 @@ namespace state_map
{
const SimpleMatcherFactory create(this);
AddLabeledMatchers(create.Or({
create.Identifier(),
create.Integer()
}), LABEL_VALUE);
AddLabeledMatchers(create.Or({create.Identifier(), create.Integer()}), LABEL_VALUE);
AddLabeledMatchers({
create.Label(LABEL_VALUE).Capture(CAPTURE_VALUE),
create.OptionalLoop(create.And({
create.Char(','),
create.Label(LABEL_VALUE).Capture(CAPTURE_VALUE)
}))
}, LABEL_VALUE_LIST);
AddLabeledMatchers({create.Label(LABEL_VALUE).Capture(CAPTURE_VALUE),
create.OptionalLoop(create.And({create.Char(','), create.Label(LABEL_VALUE).Capture(CAPTURE_VALUE)}))},
LABEL_VALUE_LIST);
AddMatchers({
create.Or({
create.Keyword("passthrough").Tag(TAG_PASSTHROUGH),
create.Label(LABEL_VALUE_LIST).Tag(TAG_VALUE_LIST)
}),
create.Char(';').Capture(CAPTURE_VALUE_END)
});
AddMatchers({create.Or({create.Keyword("passthrough").Tag(TAG_PASSTHROUGH), create.Label(LABEL_VALUE_LIST).Tag(TAG_VALUE_LIST)}),
create.Char(';').Capture(CAPTURE_VALUE_END)});
}
protected:
@ -173,12 +152,15 @@ namespace state_map
if (varForResult != state->m_valid_vars.end())
{
const auto& var = state->m_layout.m_var_layout.m_vars[varForResult->second];
const auto tokenValue = valueToken.m_type == SimpleParserValueType::IDENTIFIER ? valueToken.IdentifierValue() : std::to_string(valueToken.IntegerValue());
const auto tokenValue =
valueToken.m_type == SimpleParserValueType::IDENTIFIER ? valueToken.IdentifierValue() : std::to_string(valueToken.IntegerValue());
const auto referencedValue = std::find_if(var.m_values.begin(), var.m_values.end(), [&tokenValue](const StateMapLayoutVarValue& value)
{
return value.m_name == tokenValue;
});
const auto referencedValue = std::find_if(var.m_values.begin(),
var.m_values.end(),
[&tokenValue](const StateMapLayoutVarValue& value)
{
return value.m_name == tokenValue;
});
if (referencedValue == var.m_values.end())
throw ParsingException(valueToken.GetPos(), "Not part of the valid values for this var");
@ -204,7 +186,7 @@ namespace state_map
state->m_current_rule = nullptr;
}
};
}
} // namespace state_map
StateMapParser::StateMapParser(SimpleLexer* lexer, std::string stateMapName, const StateMapLayout& layout)
: AbstractParser(lexer, std::make_unique<StateMapParserState>(std::move(stateMapName), layout))
@ -213,25 +195,15 @@ StateMapParser::StateMapParser(SimpleLexer* lexer, std::string stateMapName, con
const std::vector<StateMapParser::sequence_t*>& StateMapParser::GetTestsForState()
{
static std::vector<sequence_t*> rootSequences({
new SequenceStateMapEntry()
});
static std::vector<sequence_t*> rootSequences({new SequenceStateMapEntry()});
static std::vector<sequence_t*> entrySequences({
new SequenceStateMapEntryClose(),
new SequenceCondition()
});
static std::vector<sequence_t*> entrySequences({new SequenceStateMapEntryClose(), new SequenceCondition()});
static std::vector<sequence_t*> ruleSequences({
new SequenceCondition(),
new SequenceValue()
});
static std::vector<sequence_t*> ruleSequences({new SequenceCondition(), new SequenceValue()});
if (m_state->m_in_entry)
{
return m_state->m_current_rule
? ruleSequences
: entrySequences;
return m_state->m_current_rule ? ruleSequences : entrySequences;
}
return rootSequences;

10
src/ObjLoading/StateMap/Parsing/StateMapParser.h
View File

@ -1,11 +1,11 @@
#pragma once
#include "StateMapParserState.h"
#include "Utils/ClassUtils.h"
#include "Techset/TechsetDefinition.h"
#include "Parsing/Impl/AbstractParser.h"
#include "Parsing/Simple/SimpleLexer.h"
#include "Parsing/Simple/SimpleParserValue.h"
#include "Parsing/Impl/AbstractParser.h"
#include "StateMapParserState.h"
#include "Techset/TechsetDefinition.h"
#include "Utils/ClassUtils.h"
namespace state_map
{
@ -19,4 +19,4 @@ namespace state_map
_NODISCARD std::unique_ptr<StateMapDefinition> GetStateMapDefinition() const;
_NODISCARD StateMapParserState* GetState() const;
};
}
} // namespace state_map

12
src/ObjLoading/StateMap/Parsing/StateMapParserState.h
View File

@ -1,13 +1,13 @@
#pragma once
#include <unordered_map>
#include <memory>
#include <set>
#include <string>
#include "StateMap/StateMapDefinition.h"
#include "StateMap/StateMapLayout.h"
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
namespace state_map
{
class StateMapParserState
@ -26,4 +26,4 @@ namespace state_map
StateMapParserState(std::string stateMapName, const StateMapLayout& layout);
};
}
} // namespace state_map

6
src/ObjLoading/StateMap/StateMapDefinition.h
View File

@ -1,11 +1,11 @@
#pragma once
#include "Parsing/Simple/Expression/ISimpleExpression.h"
#include <memory>
#include <string>
#include <vector>
#include "Parsing/Simple/Expression/ISimpleExpression.h"
namespace state_map
{
class StateMapRule
@ -35,4 +35,4 @@ namespace state_map
std::string m_name;
std::vector<StateMapEntry> m_state_map_entries;
};
}
} // namespace state_map

24
src/ObjLoading/StateMap/StateMapFromTechniqueExtractor.cpp
View File

@ -7,9 +7,7 @@ std::string StateMapFromTechniqueExtractor::RetrieveStateMap()
return std::move(m_state_map);
}
void StateMapFromTechniqueExtractor::AcceptNextPass()
{
}
void StateMapFromTechniqueExtractor::AcceptNextPass() {}
bool StateMapFromTechniqueExtractor::AcceptEndPass(std::string& errorMessage)
{
@ -32,22 +30,34 @@ bool StateMapFromTechniqueExtractor::AcceptPixelShader(const std::string& pixelS
return true;
}
bool StateMapFromTechniqueExtractor::AcceptShaderConstantArgument(techset::ShaderSelector shader, techset::ShaderArgument shaderArgument, techset::ShaderArgumentCodeSource source, std::string& errorMessage)
bool StateMapFromTechniqueExtractor::AcceptShaderConstantArgument(techset::ShaderSelector shader,
techset::ShaderArgument shaderArgument,
techset::ShaderArgumentCodeSource source,
std::string& errorMessage)
{
return true;
}
bool StateMapFromTechniqueExtractor::AcceptShaderSamplerArgument(techset::ShaderSelector shader, techset::ShaderArgument shaderArgument, techset::ShaderArgumentCodeSource source, std::string& errorMessage)
bool StateMapFromTechniqueExtractor::AcceptShaderSamplerArgument(techset::ShaderSelector shader,
techset::ShaderArgument shaderArgument,
techset::ShaderArgumentCodeSource source,
std::string& errorMessage)
{
return true;
}
bool StateMapFromTechniqueExtractor::AcceptShaderLiteralArgument(techset::ShaderSelector shader, techset::ShaderArgument shaderArgument, techset::ShaderArgumentLiteralSource source, std::string& errorMessage)
bool StateMapFromTechniqueExtractor::AcceptShaderLiteralArgument(techset::ShaderSelector shader,
techset::ShaderArgument shaderArgument,
techset::ShaderArgumentLiteralSource source,
std::string& errorMessage)
{
return true;
}
bool StateMapFromTechniqueExtractor::AcceptShaderMaterialArgument(techset::ShaderSelector shader, techset::ShaderArgument shaderArgument, techset::ShaderArgumentMaterialSource source, std::string& errorMessage)
bool StateMapFromTechniqueExtractor::AcceptShaderMaterialArgument(techset::ShaderSelector shader,
techset::ShaderArgument shaderArgument,
techset::ShaderArgumentMaterialSource source,
std::string& errorMessage)
{
return true;
}

26
src/ObjLoading/StateMap/StateMapFromTechniqueExtractor.h
View File

@ -1,9 +1,9 @@
#pragma once
#include <string>
#include "Techset/TechniqueDefinitionAcceptor.h"
#include <string>
namespace state_map
{
class StateMapFromTechniqueExtractor final : public techset::ITechniqueDefinitionAcceptor
@ -16,13 +16,25 @@ namespace state_map
bool AcceptStateMap(const std::string& stateMapName, std::string& errorMessage) override;
bool AcceptVertexShader(const std::string& vertexShaderName, std::string& errorMessage) override;
bool AcceptPixelShader(const std::string& pixelShaderName, std::string& errorMessage) override;
bool AcceptShaderConstantArgument(techset::ShaderSelector shader, techset::ShaderArgument shaderArgument, techset::ShaderArgumentCodeSource source, std::string& errorMessage) override;
bool AcceptShaderSamplerArgument(techset::ShaderSelector shader, techset::ShaderArgument shaderArgument, techset::ShaderArgumentCodeSource source, std::string& errorMessage) override;
bool AcceptShaderLiteralArgument(techset::ShaderSelector shader, techset::ShaderArgument shaderArgument, techset::ShaderArgumentLiteralSource source, std::string& errorMessage) override;
bool AcceptShaderMaterialArgument(techset::ShaderSelector shader, techset::ShaderArgument shaderArgument, techset::ShaderArgumentMaterialSource source, std::string& errorMessage) override;
bool AcceptShaderConstantArgument(techset::ShaderSelector shader,
techset::ShaderArgument shaderArgument,
techset::ShaderArgumentCodeSource source,
std::string& errorMessage) override;
bool AcceptShaderSamplerArgument(techset::ShaderSelector shader,
techset::ShaderArgument shaderArgument,
techset::ShaderArgumentCodeSource source,
std::string& errorMessage) override;
bool AcceptShaderLiteralArgument(techset::ShaderSelector shader,
techset::ShaderArgument shaderArgument,
techset::ShaderArgumentLiteralSource source,
std::string& errorMessage) override;
bool AcceptShaderMaterialArgument(techset::ShaderSelector shader,
techset::ShaderArgument shaderArgument,
techset::ShaderArgumentMaterialSource source,
std::string& errorMessage) override;
bool AcceptVertexStreamRouting(const std::string& destination, const std::string& source, std::string& errorMessage) override;
private:
std::string m_state_map;
};
}
} // namespace state_map

32
src/ObjLoading/StateMap/StateMapHandler.cpp
View File

@ -1,8 +1,8 @@
#include "StateMapHandler.h"
#include <algorithm>
#include <cassert>
#include <iostream>
#include <algorithm>
using namespace state_map;
@ -40,15 +40,19 @@ void StateMapHandler::ApplyStateMap(const uint32_t* baseStateBits, uint32_t* out
for (auto entryIndex = 0u; entryIndex < m_state_map.m_state_map_entries.size(); entryIndex++)
{
const auto& entry = m_state_map.m_state_map_entries[entryIndex];
const auto matchingRule = std::find_if(entry.m_rules.begin(), entry.m_rules.end(), [&vars](const std::unique_ptr<StateMapRule>& rule)
{
const auto matchingCondition = std::find_if(rule->m_conditions.begin(), rule->m_conditions.end(), [&vars](std::unique_ptr<ISimpleExpression>& condition)
{
return condition->EvaluateNonStatic(&vars).IsTruthy();
});
const auto matchingRule = std::find_if(entry.m_rules.begin(),
entry.m_rules.end(),
[&vars](const std::unique_ptr<StateMapRule>& rule)
{
const auto matchingCondition = std::find_if(rule->m_conditions.begin(),
rule->m_conditions.end(),
[&vars](std::unique_ptr<ISimpleExpression>& condition)
{
return condition->EvaluateNonStatic(&vars).IsTruthy();
});
return matchingCondition != rule->m_conditions.end();
});
return matchingCondition != rule->m_conditions.end();
});
if (matchingRule != entry.m_rules.end())
ApplyRule(m_state_map_layout.m_entry_layout.m_entries[entryIndex], **matchingRule, outStateBits);
@ -64,10 +68,12 @@ StateMapVars StateMapHandler::BuildVars(const uint32_t* baseStateBits) const
for (const auto& var : m_state_map_layout.m_var_layout.m_vars)
{
const auto baseStateBitField = baseStateBits[var.m_state_bits_index];
const auto matchingValue = std::find_if(var.m_values.begin(), var.m_values.end(), [&baseStateBitField](const StateMapLayoutVarValue& value)
{
return (baseStateBitField & value.m_state_bits_mask) == value.m_state_bits_mask;
});
const auto matchingValue = std::find_if(var.m_values.begin(),
var.m_values.end(),
[&baseStateBitField](const StateMapLayoutVarValue& value)
{
return (baseStateBitField & value.m_state_bits_mask) == value.m_state_bits_mask;
});
if (matchingValue != var.m_values.end())
result.AddValue(var.m_name, matchingValue->m_name);

10
src/ObjLoading/StateMap/StateMapHandler.h
View File

@ -1,12 +1,12 @@
#pragma once
#include "StateMap/StateMapDefinition.h"
#include "StateMap/StateMapLayout.h"
#include "Utils/ClassUtils.h"
#include <cstdint>
#include <unordered_map>
#include "Utils/ClassUtils.h"
#include "StateMap/StateMapDefinition.h"
#include "StateMap/StateMapLayout.h"
namespace state_map
{
class StateMapVars final : public ISimpleExpressionScopeValues
@ -33,4 +33,4 @@ namespace state_map
const StateMapLayout& m_state_map_layout;
const StateMapDefinition& m_state_map;
};
}
} // namespace state_map

6
src/ObjLoading/StateMap/StateMapReader.cpp
View File

@ -1,11 +1,11 @@
#include "StateMapReader.h"
#include <iostream>
#include "Parsing/StateMapParser.h"
#include "Parsing/Impl/CommentRemovingStreamProxy.h"
#include "Parsing/Impl/ParserSingleInputStream.h"
#include "Parsing/Matcher/StateMapExpressionMatchers.h"
#include "Parsing/StateMapParser.h"
#include <iostream>
using namespace state_map;

14
src/ObjLoading/StateMap/StateMapReader.h
View File

@ -1,14 +1,14 @@
#pragma once
#include "Parsing/IParserLineStream.h"
#include "Parsing/StateMapParserState.h"
#include "StateMap/StateMapLayout.h"
#include "StateMapDefinition.h"
#include "Utils/ClassUtils.h"
#include <memory>
#include <string>
#include "Utils/ClassUtils.h"
#include "StateMapDefinition.h"
#include "StateMap/StateMapLayout.h"
#include "Parsing/IParserLineStream.h"
#include "Parsing/StateMapParserState.h"
namespace state_map
{
class StateMapReader
@ -25,4 +25,4 @@ namespace state_map
_NODISCARD bool IsValidEndState(const StateMapParserState* state) const;
_NODISCARD std::unique_ptr<StateMapDefinition> ReadStateMapDefinition() const;
};
}
} // namespace state_map