-
Notifications
You must be signed in to change notification settings - Fork 47
/
ShaderFileLoader.h
128 lines (104 loc) · 3.68 KB
/
ShaderFileLoader.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#pragma once
#if 0
#include <regex>
#include "iarchive.h"
#include "ifilesystem.h"
#include "TableDefinition.h"
#include "ShaderTemplate.h"
#include "ShaderDefinition.h"
#include "ShaderLibrary.h"
#include "parser/DefBlockTokeniser.h"
#include "parser/ThreadedDeclParser.h"
#include "materials/ParseLib.h"
#include "string/replace.h"
#include "string/predicate.h"
#include "debugging/ScopedDebugTimer.h"
namespace shaders
{
// VFS functor class which loads material (mtr) files.
class ShaderFileLoader :
public parser::ThreadedDeclParser<ShaderLibraryPtr>
{
private:
ShaderLibraryPtr _library;
public:
/// Construct and initialise the ShaderFileLoader
ShaderFileLoader() :
parser::ThreadedDeclParser<ShaderLibraryPtr>(decl::Type::Material,
getMaterialsFolderName(), getMaterialFileExtension(), 1)
{}
protected:
void onBeginParsing() override
{
// Load the shader files from the VFS into a fresh library
_library = std::make_shared<ShaderLibrary>();
}
void parse(std::istream& stream, const vfs::FileInfo& fileInfo, const std::string& modDir) override
{
// Parse the file with a blocktokeniser, the actual block contents
// will be parsed separately.
parser::BasicDefBlockTokeniser<std::istream> tokeniser(stream);
while (tokeniser.hasMoreBlocks())
{
// Get the next block
parser::BlockTokeniser::Block block = tokeniser.nextBlock();
#if 0
// Try to parse tables
if (parseTable(block, fileInfo))
{
continue; // table successfully parsed
}
#endif
if (block.name.substr(0, 5) == "skin ")
{
continue; // skip skin definition
}
if (block.name.substr(0, 9) == "particle ")
{
continue; // skip particle definition
}
string::replace_all(block.name, "\\", "/"); // use forward slashes
auto shaderTemplate = std::make_shared<ShaderTemplate>(block.name, block.contents);
// Construct the ShaderDefinition wrapper class
ShaderDefinition def(shaderTemplate, fileInfo);
// Insert into the definitions map, if not already present
if (!_library->addDefinition(block.name, def))
{
rError() << "[shaders] " << fileInfo.name << ": shader " << block.name << " already defined." << std::endl;
}
}
}
ShaderLibraryPtr onFinishParsing() override
{
rMessage() << _library->getNumDefinitions() << " shader definitions found." << std::endl;
// Move the resource contained in the local shared_ptr
return std::move(_library);
}
private:
#if 0
bool parseTable(const parser::BlockTokeniser::Block& block, const vfs::FileInfo& fileInfo)
{
if (block.name.length() <= 5 || !string::starts_with(block.name, "table"))
{
return false; // definitely not a table decl
}
// Look closer by trying to split up the table name from the decl
// it can still be a material starting with "table_" (#5188)
std::regex expr("^table\\s+(.+)$");
std::smatch matches;
if (std::regex_match(block.name, matches, expr))
{
auto tableName = matches[1].str();
auto table = std::make_shared<TableDefinition>(tableName, block.contents);
if (!_library->addTableDefinition(table))
{
rError() << "[shaders] " << fileInfo.name << ": table " << tableName << " already defined." << std::endl;
}
return true;
}
return false;
}
#endif
};
}
#endif