mirrors/linux-wallpaperengine
1
0
Fork 0
mirror of https://github.com/Almamu/linux-wallpaperengine.git synced 2025-09-14 13:56:48 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

chore: add some const qualifiers in parser to prevent changes

Browse Source
This commit is contained in:
Almamu 2025-09-11 21:43:47 +02:00
parent 256135a082
commit 1411ad6c5e
16 changed files with 59 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/WallpaperEngine/Data/Parsers/EffectParser.cpp
View File

@ -9,13 +9,13 @@
using namespace WallpaperEngine::Data::Parsers; using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Data::Model; using namespace WallpaperEngine::Data::Model;
EffectUniquePtr EffectParser::load (Project& project, const std::string& filename) { EffectUniquePtr EffectParser::load (const Project& project, const std::string& filename) {
const auto effectJson = JSON::parse (project.container->readString (filename)); const auto effectJson = JSON::parse (project.container->readString (filename));
return parse (effectJson, project); return parse (effectJson, project);
} }
EffectUniquePtr EffectParser::parse (const JSON& it, Project& project) { EffectUniquePtr EffectParser::parse (const JSON& it, const Project& project) {
const auto dependencies = it.optional ("dependencies"); const auto dependencies = it.optional ("dependencies");
const auto fbos = it.optional ("fbos"); const auto fbos = it.optional ("fbos");
@ -44,7 +44,7 @@ std::vector <std::string> EffectParser::parseDependencies (const JSON& it) {
return result; return result;
} }
std::vector <EffectPassUniquePtr> EffectParser::parseEffectPasses (const JSON& it, Project& project) { std::vector <EffectPassUniquePtr> EffectParser::parseEffectPasses (const JSON& it, const Project& project) {
std::vector <EffectPassUniquePtr> result = {}; std::vector <EffectPassUniquePtr> result = {};
if (!it.is_array ()) { if (!it.is_array ()) {

6
src/WallpaperEngine/Data/Parsers/EffectParser.h
View File

@ -9,12 +9,12 @@ using namespace WallpaperEngine::Data::Model;
class EffectParser { class EffectParser {
public: public:
static EffectUniquePtr load (Project& project, const std::string& filename); static EffectUniquePtr load (const Project& project, const std::string& filename);
private: private:
static EffectUniquePtr parse (const JSON& it, Project& project); static EffectUniquePtr parse (const JSON& it, const Project& project);
static std::vector <std::string> parseDependencies (const JSON& it); static std::vector <std::string> parseDependencies (const JSON& it);
static std::vector <EffectPassUniquePtr> parseEffectPasses (const JSON& it, Project& project); static std::vector <EffectPassUniquePtr> parseEffectPasses (const JSON& it, const Project& project);
static std::map <int, std::string> parseBinds (const JSON& it); static std::map <int, std::string> parseBinds (const JSON& it);
static std::vector <FBOUniquePtr> parseFBOs (const JSON& it); static std::vector <FBOUniquePtr> parseFBOs (const JSON& it);
}; };

14
src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
View File

@ -7,20 +7,20 @@
using namespace WallpaperEngine::Data::Parsers; using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Data::Model; using namespace WallpaperEngine::Data::Model;
MaterialUniquePtr MaterialParser::load (Project& project, const std::string& filename) { MaterialUniquePtr MaterialParser::load (const Project& project, const std::string& filename) {
const auto materialJson = JSON::parse (project.container->readString (filename)); const auto materialJson = JSON::parse (project.container->readString (filename));
return parse (materialJson, project, filename); return parse (materialJson, filename);
} }
MaterialUniquePtr MaterialParser::parse (const JSON& it, Project& project, const std::string& filename) { MaterialUniquePtr MaterialParser::parse (const JSON& it, const std::string& filename) {
return std::make_unique <Material> (Material { return std::make_unique <Material> (Material {
.filename = filename, .filename = filename,
.passes = parsePasses (it.require ("passes", "Material must have passes to render"), project), .passes = parsePasses (it.require ("passes", "Material must have passes to render")),
}); });
} }
std::vector <MaterialPassUniquePtr> MaterialParser::parsePasses (const JSON& it, Project& project) { std::vector <MaterialPassUniquePtr> MaterialParser::parsePasses (const JSON& it) {
std::vector <MaterialPassUniquePtr> result = {}; std::vector <MaterialPassUniquePtr> result = {};
if (!it.is_array ()) { if (!it.is_array ()) {
@ -28,13 +28,13 @@ std::vector <MaterialPassUniquePtr> MaterialParser::parsePasses (const JSON& it,
} }
for (const auto& cur : it) { for (const auto& cur : it) {
result.push_back (parsePass (cur, project)); result.push_back (parsePass (cur));
} }
return result; return result;
} }
MaterialPassUniquePtr MaterialParser::parsePass (const JSON& it, Project& project) { MaterialPassUniquePtr MaterialParser::parsePass (const JSON& it) {
const auto textures = it.optional ("textures"); const auto textures = it.optional ("textures");
const auto usertextures = it.optional ("usertextures"); const auto usertextures = it.optional ("usertextures");
const auto combos = it.optional ("combos"); const auto combos = it.optional ("combos");

8
src/WallpaperEngine/Data/Parsers/MaterialParser.h
View File

@ -10,10 +10,10 @@ using namespace WallpaperEngine::Data::Model;
class MaterialParser { class MaterialParser {
public: public:
static MaterialUniquePtr load (Project& project, const std::string& filename); static MaterialUniquePtr load (const Project& project, const std::string& filename);
static MaterialUniquePtr parse (const JSON& it, Project& project, const std::string& filename); static MaterialUniquePtr parse (const JSON& it, const std::string& filename);
static std::vector <MaterialPassUniquePtr> parsePasses (const JSON& it, Project& project); static std::vector <MaterialPassUniquePtr> parsePasses (const JSON& it);
static MaterialPassUniquePtr parsePass (const JSON& it, Project& project); static MaterialPassUniquePtr parsePass (const JSON& it);
static std::map <int, std::string> parseTextures (const JSON& it); static std::map <int, std::string> parseTextures (const JSON& it);
static std::map <std::string, int> parseCombos (const JSON& it); static std::map <std::string, int> parseCombos (const JSON& it);
static BlendingMode parseBlendMode (const std::string& mode); static BlendingMode parseBlendMode (const std::string& mode);

4
src/WallpaperEngine/Data/Parsers/ModelParser.cpp
View File

@ -9,13 +9,13 @@
using namespace WallpaperEngine::Data::Parsers; using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Data::Model; using namespace WallpaperEngine::Data::Model;
ModelUniquePtr ModelParser::load (Project& project, const std::string& filename) { ModelUniquePtr ModelParser::load (const Project& project, const std::string& filename) {
const auto model = JSON::parse (project.container->readString (filename)); const auto model = JSON::parse (project.container->readString (filename));
return parse (model, project, filename); return parse (model, project, filename);
} }
ModelUniquePtr ModelParser::parse (const JSON& file, Project& project, const std::string& filename) { ModelUniquePtr ModelParser::parse (const JSON& file, const Project& project, const std::string& filename) {
const auto material = file.require <std::string> ("material", "Model must have a material"); const auto material = file.require <std::string> ("material", "Model must have a material");
return std::make_unique <ModelStruct> (ModelStruct { return std::make_unique <ModelStruct> (ModelStruct {

4
src/WallpaperEngine/Data/Parsers/ModelParser.h
View File

@ -9,7 +9,7 @@ using namespace WallpaperEngine::Data::Model;
class ModelParser { class ModelParser {
public: public:
static ModelUniquePtr load (Project& project, const std::string& filename); static ModelUniquePtr load (const Project& project, const std::string& filename);
static ModelUniquePtr parse (const JSON& file, Project& project, const std::string& filename); static ModelUniquePtr parse (const JSON& file, const Project& project, const std::string& filename);
}; };
} // namespace WallpaperEngine::Data::Parsers } // namespace WallpaperEngine::Data::Parsers

17
src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
View File

@ -10,7 +10,7 @@
using namespace WallpaperEngine::Data::Parsers; using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Data::Model; using namespace WallpaperEngine::Data::Model;
ObjectUniquePtr ObjectParser::parse (const JSON& it, Project& project) { ObjectUniquePtr ObjectParser::parse (const JSON& it, const Project& project) {
const auto imageIt = it.find ("image"); const auto imageIt = it.find ("image");
const auto soundIt = it.find ("sound"); const auto soundIt = it.find ("sound");
const auto particleIt = it.find ("particle"); const auto particleIt = it.find ("particle");
@ -25,7 +25,7 @@ ObjectUniquePtr ObjectParser::parse (const JSON& it, Project& project) {
if (imageIt != it.end () && imageIt->is_string ()) { if (imageIt != it.end () && imageIt->is_string ()) {
return parseImage (it, project, basedata, *imageIt); return parseImage (it, project, basedata, *imageIt);
} else if (soundIt != it.end () && soundIt->is_array ()) { } else if (soundIt != it.end () && soundIt->is_array ()) {
return parseSound (it, project, basedata); return parseSound (it, basedata);
} else if (particleIt != it.end ()) { } else if (particleIt != it.end ()) {
sLog.error ("Particle objects are not supported yet"); sLog.error ("Particle objects are not supported yet");
} else if (textIt != it.end ()) { } else if (textIt != it.end ()) {
@ -56,7 +56,7 @@ std::vector<int> ObjectParser::parseDependencies (const JSON& it) {
return result; return result;
} }
SoundUniquePtr ObjectParser::parseSound (const JSON& it, Project& project, ObjectData base) { SoundUniquePtr ObjectParser::parseSound (const JSON& it, ObjectData base) {
const auto soundIt = it.require ("sound", "Object must have a sound"); const auto soundIt = it.require ("sound", "Object must have a sound");
std::vector<std::string> sounds = {}; std::vector<std::string> sounds = {};
@ -73,8 +73,7 @@ SoundUniquePtr ObjectParser::parseSound (const JSON& it, Project& project, Objec
); );
} }
ImageUniquePtr ObjectParser::parseImage ( ImageUniquePtr ObjectParser::parseImage (const JSON& it, const Project& project, ObjectData base, const std::string& image) {
const JSON& it, Project& project, ObjectData base, const std::string& image) {
const auto& properties = project.properties; const auto& properties = project.properties;
const auto& effects = it.optional ("effects"); const auto& effects = it.optional ("effects");
@ -107,7 +106,7 @@ ImageUniquePtr ObjectParser::parseImage (
return result; return result;
} }
std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, Project& project) { std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, const Project& project) {
if (!it.is_array ()) { if (!it.is_array ()) {
return {}; return {};
} }
@ -121,7 +120,7 @@ std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, P
return result; return result;
} }
ImageEffectUniquePtr ObjectParser::parseEffect (const JSON& it, Project& project) { ImageEffectUniquePtr ObjectParser::parseEffect (const JSON& it, const Project& project) {
const auto& passsOverrides = it.optional ("passes"); const auto& passsOverrides = it.optional ("passes");
return std::make_unique <ImageEffect> (ImageEffect { return std::make_unique <ImageEffect> (ImageEffect {
.id = it.optional <int> ("id", -1), .id = it.optional <int> ("id", -1),
@ -132,7 +131,7 @@ ImageEffectUniquePtr ObjectParser::parseEffect (const JSON& it, Project& project
}); });
} }
std::vector <ImageEffectPassOverrideUniquePtr> ObjectParser::parseEffectPassOverrides (const JSON& it, Project& project) { std::vector <ImageEffectPassOverrideUniquePtr> ObjectParser::parseEffectPassOverrides (const JSON& it, const Project& project) {
if (!it.is_array ()) { if (!it.is_array ()) {
return {}; return {};
} }
@ -146,7 +145,7 @@ std::vector <ImageEffectPassOverrideUniquePtr> ObjectParser::parseEffectPassOver
return result; return result;
} }
ImageEffectPassOverrideUniquePtr ObjectParser::parseEffectPass (const JSON& it, Project& project) { ImageEffectPassOverrideUniquePtr ObjectParser::parseEffectPass (const JSON& it, const Project& project) {
const auto& combos = it.optional ("combos"); const auto& combos = it.optional ("combos");
const auto& textures = it.optional ("textures"); const auto& textures = it.optional ("textures");
const auto& constants = it.optional ("constantshadervalues"); const auto& constants = it.optional ("constantshadervalues");

15
src/WallpaperEngine/Data/Parsers/ObjectParser.h
View File

@ -15,17 +15,16 @@ using namespace WallpaperEngine::Data::Model;
class ObjectParser { class ObjectParser {
public: public:
static ObjectUniquePtr parse (const JSON& it, Project& project); static ObjectUniquePtr parse (const JSON& it, const Project& project);
private: private:
static std::vector<int> parseDependencies (const JSON& it); static std::vector<int> parseDependencies (const JSON& it);
static SoundUniquePtr parseSound (const JSON& it, Project& project, ObjectData base); static SoundUniquePtr parseSound (const JSON& it, ObjectData base);
static ImageUniquePtr parseImage ( static ImageUniquePtr parseImage (const JSON& it, const Project& project, ObjectData base, const std::string& image);
const JSON& it, Project& project, ObjectData base, const std::string& image); static std::vector <ImageEffectUniquePtr> parseEffects (const JSON& it, const Project& project);
static std::vector <ImageEffectUniquePtr> parseEffects (const JSON& it, Project& project); static ImageEffectUniquePtr parseEffect (const JSON& it, const Project& project);
static ImageEffectUniquePtr parseEffect (const JSON& it, Project& project); static std::vector <ImageEffectPassOverrideUniquePtr> parseEffectPassOverrides (const JSON& it, const Project& project);
static std::vector <ImageEffectPassOverrideUniquePtr> parseEffectPassOverrides (const JSON& it, Project& project); static ImageEffectPassOverrideUniquePtr parseEffectPass (const JSON& it, const Project& project);
static ImageEffectPassOverrideUniquePtr parseEffectPass (const JSON& it, Project& project);
static TextureMap parseTextureMap (const JSON& it); static TextureMap parseTextureMap (const JSON& it);
static ComboMap parseComboMap (const JSON& it); static ComboMap parseComboMap (const JSON& it);
}; };

14
src/WallpaperEngine/Data/Parsers/PropertyParser.cpp
View File

@ -4,7 +4,7 @@
using namespace WallpaperEngine::Data::Parsers; using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Data::Model; using namespace WallpaperEngine::Data::Model;
PropertySharedPtr PropertyParser::parse (const JSON& it, std::string name) { PropertySharedPtr PropertyParser::parse (const JSON& it, const std::string& name) {
const auto type = it.require <std::string> ("type", "Property type is required"); const auto type = it.require <std::string> ("type", "Property type is required");
if (type == "color") { if (type == "color") {
@ -36,7 +36,7 @@ PropertySharedPtr PropertyParser::parse (const JSON& it, std::string name) {
} }
PropertySharedPtr PropertyParser::parseCombo (const JSON& it, std::string name) { PropertySharedPtr PropertyParser::parseCombo (const JSON& it, const std::string& name) {
std::map <std::string, std::string> optionsMap = {}; std::map <std::string, std::string> optionsMap = {};
const auto options = it.require ("options", "Combo property must have options"); const auto options = it.require ("options", "Combo property must have options");
@ -68,21 +68,21 @@ PropertySharedPtr PropertyParser::parseCombo (const JSON& it, std::string name)
}, value.is_number () ? std::to_string (value.get <int> ()) : value.get <std::string> ()); }, value.is_number () ? std::to_string (value.get <int> ()) : value.get <std::string> ());
} }
PropertySharedPtr PropertyParser::parseColor (const JSON& it, std::string name) { PropertySharedPtr PropertyParser::parseColor (const JSON& it, const std::string& name) {
return std::make_shared <PropertyColor> (PropertyData { return std::make_shared <PropertyColor> (PropertyData {
.name = name, .name = name,
.text = it.optional <std::string> ("text", ""), .text = it.optional <std::string> ("text", ""),
}, it.require ("value", "Property must have a value")); }, it.require ("value", "Property must have a value"));
} }
PropertySharedPtr PropertyParser::parseBoolean (const JSON& it, std::string name) { PropertySharedPtr PropertyParser::parseBoolean (const JSON& it, const std::string& name) {
return std::make_shared <PropertyBoolean> (PropertyData { return std::make_shared <PropertyBoolean> (PropertyData {
.name = name, .name = name,
.text = it.optional <std::string> ("text", ""), .text = it.optional <std::string> ("text", ""),
}, it.require ("value", "Property must have a value")); }, it.require ("value", "Property must have a value"));
} }
PropertySharedPtr PropertyParser::parseSlider (const JSON& it, std::string name) { PropertySharedPtr PropertyParser::parseSlider (const JSON& it, const std::string& name) {
return std::make_shared <PropertySlider> (PropertyData { return std::make_shared <PropertySlider> (PropertyData {
.name = name, .name = name,
.text = it.optional <std::string> ("text", ""), .text = it.optional <std::string> ("text", ""),
@ -93,14 +93,14 @@ PropertySharedPtr PropertyParser::parseSlider (const JSON& it, std::string name)
}, it.require ("value", "Property must have a value")); }, it.require ("value", "Property must have a value"));
} }
PropertySharedPtr PropertyParser::parseText (const JSON& it, std::string name) { PropertySharedPtr PropertyParser::parseText (const JSON& it, const std::string& name) {
return std::make_shared <PropertyText> (PropertyData { return std::make_shared <PropertyText> (PropertyData {
.name = name, .name = name,
.text = it.optional <std::string> ("text", ""), .text = it.optional <std::string> ("text", ""),
}); });
} }
PropertySharedPtr PropertyParser::parseSceneTexture (const JSON& it, std::string name) { PropertySharedPtr PropertyParser::parseSceneTexture (const JSON& it, const std::string& name) {
return std::make_shared <PropertySceneTexture> (PropertyData { return std::make_shared <PropertySceneTexture> (PropertyData {
.name = name, .name = name,
.text = it.optional <std::string> ("text", ""), .text = it.optional <std::string> ("text", ""),

14
src/WallpaperEngine/Data/Parsers/PropertyParser.h
View File

@ -8,14 +8,14 @@ using namespace WallpaperEngine::Data::Model;
class PropertyParser { class PropertyParser {
public: public:
static PropertySharedPtr parse (const JSON& it, std::string name); static PropertySharedPtr parse (const JSON& it, const std::string& name);
private: private:
static PropertySharedPtr parseCombo (const JSON& it, std::string name); static PropertySharedPtr parseCombo (const JSON& it, const std::string& name);
static PropertySharedPtr parseColor (const JSON& it, std::string name); static PropertySharedPtr parseColor (const JSON& it, const std::string& name);
static PropertySharedPtr parseBoolean (const JSON& it, std::string name); static PropertySharedPtr parseBoolean (const JSON& it, const std::string& name);
static PropertySharedPtr parseSlider (const JSON& it, std::string name); static PropertySharedPtr parseSlider (const JSON& it, const std::string& name);
static PropertySharedPtr parseText (const JSON& it, std::string name); static PropertySharedPtr parseText (const JSON& it, const std::string& name);
static PropertySharedPtr parseSceneTexture (const JSON& it, std::string name); static PropertySharedPtr parseSceneTexture (const JSON& it, const std::string& name);
}; };
} }

2
src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
View File

@ -6,7 +6,7 @@
using namespace WallpaperEngine::Data::Parsers; using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Data::Model; using namespace WallpaperEngine::Data::Model;
ShaderConstantMap ShaderConstantParser::parse (const JSON& it, Project& project) { ShaderConstantMap ShaderConstantParser::parse (const JSON& it, const Project& project) {
if (!it.is_object ()) { if (!it.is_object ()) {
return {}; return {};
} }

2
src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
View File

@ -9,6 +9,6 @@ using namespace WallpaperEngine::Data::Model;
class ShaderConstantParser { class ShaderConstantParser {
public: public:
static ShaderConstantMap parse (const JSON& it, Project& project); static ShaderConstantMap parse (const JSON& it, const Project& project);
}; };
} // namespace WallpaperEngine::Data::Parsers } // namespace WallpaperEngine::Data::Parsers

6
src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
View File

@ -53,11 +53,11 @@ UserSettingUniquePtr UserSettingParser::parse (const json& data, const Propertie
//TODO: VALIDATE THIS IS RIGHT? //TODO: VALIDATE THIS IS RIGHT?
if (size == 2) { if (size == 2) {
value->update ((glm::vec2) valueIt); value->update (static_cast<glm::vec2> (valueIt));
} else if (size == 3) { } else if (size == 3) {
value->update ((glm::vec3) valueIt); value->update (static_cast<glm::vec3> (valueIt));
} else { } else {
value->update ((glm::vec4) valueIt); value->update (static_cast<glm::vec4> (valueIt));
} }
} else if (valueIt.is_number_integer ()) { } else if (valueIt.is_number_integer ()) {
value->update (valueIt.get <int> ()); value->update (valueIt.get <int> ());

8
src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
View File

@ -92,15 +92,11 @@ WebUniquePtr WallpaperParser::parseWeb (const JSON& file, Project& project) {
}); });
} }
ObjectList WallpaperParser::parseObjects (const JSON& objects, Project& project) { ObjectList WallpaperParser::parseObjects (const JSON& objects, const Project& project) {
ObjectList result = {}; ObjectList result = {};
for (const auto& cur : objects) { for (const auto& cur : objects) {
auto object = ObjectParser::parse (cur, project); result.emplace_back (ObjectParser::parse (cur, project));
//TODO: DO WE REALLY WANT TO DIRECTLY CONSTRUCT UNIQUE AND SHARED PTRS EVERYWHERE?
// SHOULDN'T THAT BE HANDLED BY CALLING CODE (LIKE THIS) INSTEAD?
result.emplace_back (std::move (object));
} }
return result; return result;

2
src/WallpaperEngine/Data/Parsers/WallpaperParser.h
View File

@ -15,6 +15,6 @@ class WallpaperParser {
static SceneUniquePtr parseScene (const JSON& file, Project& project); static SceneUniquePtr parseScene (const JSON& file, Project& project);
static VideoUniquePtr parseVideo (const JSON& file, Project& project); static VideoUniquePtr parseVideo (const JSON& file, Project& project);
static WebUniquePtr parseWeb (const JSON& file, Project& project); static WebUniquePtr parseWeb (const JSON& file, Project& project);
static ObjectList parseObjects (const JSON& objects, Project& project); static ObjectList parseObjects (const JSON& objects, const Project& project);
}; };
} // namespace WallpaperEngine::Data::Parsers } // namespace WallpaperEngine::Data::Parsers

3
src/WallpaperEngine/Render/CTextureCache.cpp
View File

@ -16,9 +16,8 @@ using namespace WallpaperEngine::Data::Parsers;
CTextureCache::CTextureCache (CRenderContext& context) : Helpers::CContextAware (context) {} CTextureCache::CTextureCache (CRenderContext& context) : Helpers::CContextAware (context) {}
std::shared_ptr<const ITexture> CTextureCache::resolve (const std::string& filename) { std::shared_ptr<const ITexture> CTextureCache::resolve (const std::string& filename) {
const auto found = this->m_textureCache.find (filename);
if (found != this->m_textureCache.end ()) if (const auto found = this->m_textureCache.find (filename); found != this->m_textureCache.end ())
return found->second; return found->second;
auto finalFilename = std::filesystem::path("materials") / filename; auto finalFilename = std::filesystem::path("materials") / filename;