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: moved more things to std::unique_ptr and std::shared_ptr

Browse Source
This commit is contained in:
Almamu 2025-04-26 06:08:44 +02:00
parent f5da9a01f6
commit f877d2b1a7
56 changed files with 248 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/WallpaperEngine/Application/CWallpaperApplication.cpp
View File

@ -197,7 +197,7 @@ void CWallpaperApplication::loadBackgrounds () {
}
}
std::unique_ptr<Core::CProject> CWallpaperApplication::loadBackground (const std::string& bg) {
std::shared_ptr<Core::CProject> CWallpaperApplication::loadBackground (const std::string& bg) {
const auto container = std::make_shared <CCombinedContainer> ();
this->setupContainer (container, bg);

2
src/WallpaperEngine/Application/CWallpaperApplication.h
View File

@ -72,7 +72,7 @@ class CWallpaperApplication {
* @param bg
* @return
*/
[[nodiscard]] std::unique_ptr<Core::CProject> loadBackground (const std::string& bg);
[[nodiscard]] std::shared_ptr<Core::CProject> loadBackground (const std::string& bg);
/**
* Prepares all background's values and updates their properties if required
*/

4
src/WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.cpp
View File

@ -173,6 +173,10 @@ CPulseAudioPlaybackRecorder::CPulseAudioPlaybackRecorder () :
}
CPulseAudioPlaybackRecorder::~CPulseAudioPlaybackRecorder () {
if (m_captureData.captureStream) {
pa_stream_unref (m_captureData.captureStream);
}
delete [] this->m_captureData.audioBufferTmp;
delete [] this->m_captureData.audioBuffer;
free (this->m_captureData.kisscfg);

24
src/WallpaperEngine/Core/CObject.cpp
View File

@ -17,7 +17,7 @@ using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Core::UserSettings;
CObject::CObject (
const Wallpapers::CScene* scene, const CUserSettingBoolean* visible, int id, std::string name,
std::shared_ptr <const Core::CProject> project, const CUserSettingBoolean* visible, int id, std::string name,
const CUserSettingVector3* origin, const CUserSettingVector3* scale, const CUserSettingVector3* angles,
std::vector<int> dependencies
) :
@ -27,17 +27,17 @@ CObject::CObject (
m_origin (origin),
m_scale (scale),
m_angles (angles),
m_scene (scene),
m_project (project),
m_dependencies (std::move(dependencies)) {}
const CObject* CObject::fromJSON (
const json& data, const Wallpapers::CScene* scene, const std::shared_ptr<const CContainer>& container
const json& data, std::shared_ptr <const Core::CProject> project, const std::shared_ptr<const CContainer>& container
) {
const auto id = jsonFindRequired <int> (data, "id", "Objects must have id");
const auto visible = jsonFindUserConfig<CUserSettingBoolean> (data, scene->getProject(), "visible", true);
const auto origin = jsonFindUserConfig<CUserSettingVector3> (data, scene->getProject(), "origin", {0, 0, 0});
const auto scale = jsonFindUserConfig<CUserSettingVector3> (data, scene->getProject(), "scale", {1, 1, 1});
const auto angles_val = jsonFindUserConfig<CUserSettingVector3> (data, scene->getProject(), "angles", glm::vec3 (0, 0, 0));
const auto visible = jsonFindUserConfig<CUserSettingBoolean> (data, *project, "visible", true);
const auto origin = jsonFindUserConfig<CUserSettingVector3> (data, *project, "origin", {0, 0, 0});
const auto scale = jsonFindUserConfig<CUserSettingVector3> (data, *project, "scale", {1, 1, 1});
const auto angles_val = jsonFindUserConfig<CUserSettingVector3> (data, *project, "angles", glm::vec3 (0, 0, 0));
const auto name = jsonFindRequired <std::string> (data, "name", "Objects must have name");
const auto effects_it = data.find ("effects");
const auto dependencies_it = data.find ("dependencies");
@ -59,14 +59,14 @@ const CObject* CObject::fromJSON (
if (image_it != data.end () && !image_it->is_null ()) {
object = Objects::CImage::fromJSON (
scene, data, container, visible, id, name, origin, scale, angles_val, effects_it, dependencies);
project, data, container, visible, id, name, origin, scale, angles_val, effects_it, dependencies);
} else if (sound_it != data.end () && !sound_it->is_null ()) {
object = Objects::CSound::fromJSON (scene, data, visible, id, name, origin, scale, angles_val, dependencies);
object = Objects::CSound::fromJSON (project, data, visible, id, name, origin, scale, angles_val, dependencies);
} else if (particle_it != data.end () && !particle_it->is_null ()) {
/// TODO: XXXHACK -- TO REMOVE WHEN PARTICLE SUPPORT IS PROPERLY IMPLEMENTED
try {
object = Objects::CParticle::fromFile (
scene, particle_it->get<std::string> (), container, visible, id, name, origin, angles_val, scale, dependencies);
project, particle_it->get<std::string> (), container, visible, id, name, origin, angles_val, scale, dependencies);
} catch (std::runtime_error&) {
return nullptr;
}
@ -107,8 +107,8 @@ bool CObject::isVisible () const {
return this->m_visible->getBool ();
}
const Wallpapers::CScene* CObject::getScene () const {
return this->m_scene;
std::shared_ptr <const CProject> CObject::getProject () const {
return this->m_project;
}
int CObject::getId () const {

9
src/WallpaperEngine/Core/CObject.h
View File

@ -29,7 +29,8 @@ class CObject {
friend class Wallpapers::CScene;
public:
static const CObject* fromJSON (const json& data, const Wallpapers::CScene* scene, const std::shared_ptr<const CContainer>& container);
static const CObject* fromJSON ( const json& data, std::shared_ptr <const Core::CProject> project,
const std::shared_ptr<const CContainer>& container);
template <class T> [[nodiscard]] const T* as () const {
if (is <T> ()) {
@ -60,11 +61,11 @@ class CObject {
[[nodiscard]] const std::string& getName () const;
[[nodiscard]] bool isVisible () const;
[[nodiscard]] const Wallpapers::CScene* getScene () const;
[[nodiscard]] std::shared_ptr <const Core::CProject> getProject () const;
protected:
CObject (
const Wallpapers::CScene* scene, const CUserSettingBoolean* visible, int id, std::string name,
std::shared_ptr <const Core::CProject> scene, const CUserSettingBoolean* visible, int id, std::string name,
const CUserSettingVector3* origin, const CUserSettingVector3* scale, const CUserSettingVector3* angles,
std::vector<int> dependencies);
@ -80,6 +81,6 @@ class CObject {
const std::vector<int> m_dependencies;
const Wallpapers::CScene* m_scene;
const std::shared_ptr <const Core::CProject> m_project;
};
} // namespace WallpaperEngine::Core

32
src/WallpaperEngine/Core/CProject.cpp
View File

@ -16,7 +16,7 @@ static int backgroundId = -1;
CProject::CProject (
std::string title, std::string type, std::string workshopid, std::shared_ptr<const CContainer> container,
bool supportsaudioprocessing, const std::map<std::string, Projects::CProperty*>& properties
bool supportsaudioprocessing, const std::map<std::string, std::shared_ptr<Projects::CProperty>>& properties
) :
m_workshopid(std::move(workshopid)),
m_title (std::move(title)),
@ -26,15 +26,7 @@ CProject::CProject (
m_properties (properties),
m_supportsaudioprocessing (supportsaudioprocessing) {}
CProject::~CProject () {
for (auto& [_, property] : this->m_properties) {
delete property;
}
this->m_properties.clear ();
}
std::unique_ptr<CProject> CProject::fromFile (const std::string& filename, std::shared_ptr<const CContainer> container) {
std::shared_ptr<CProject> CProject::fromFile (const std::string& filename, std::shared_ptr<const CContainer> container) {
json content = json::parse (container->readFileAsString (filename));
const auto dependency = jsonFindDefault<std::string> (content, "dependency", "No dependency");
@ -49,8 +41,8 @@ std::unique_ptr<CProject> CProject::fromFile (const std::string& filename, std::
auto type = jsonFindRequired <std::string> (content, "type", "Project type missing");
const auto file = jsonFindRequired <std::string> (content, "file", "Project's main file missing");
auto general = content.find ("general");
const CWallpaper* wallpaper;
std::map<std::string, Projects::CProperty*> properties;
std::shared_ptr <const CWallpaper> wallpaper = nullptr;
std::map<std::string, std::shared_ptr <Projects::CProperty>> properties;
std::transform (type.begin (), type.end (), type.begin (), tolower);
@ -66,12 +58,12 @@ std::unique_ptr<CProject> CProject::fromFile (const std::string& filename, std::
continue;
}
properties.emplace (property->getName (), property);
properties.emplace (property->getName (), std::move (property));
}
}
}
std::unique_ptr<CProject> project = std::make_unique <CProject> (
std::shared_ptr<CProject> project = std::make_shared <CProject> (
jsonFindRequired <std::string> (content, "title", "Project title missing"),
type,
jsonFindDefault <std::string> (content, "workshopid", std::to_string (backgroundId--)),
@ -81,11 +73,11 @@ std::unique_ptr<CProject> CProject::fromFile (const std::string& filename, std::
);
if (type == "scene")
wallpaper = CScene::fromFile (file, *project, container);
wallpaper = CScene::fromFile (file, project, container);
else if (type == "video")
wallpaper = new CVideo (file, *project);
wallpaper = std::make_shared<CVideo> (file, project);
else if (type == "web")
wallpaper = new CWeb (file, *project);
wallpaper = std::make_shared<CWeb> (file, project);
else
sLog.exception ("Unsupported wallpaper type: ", type);
@ -94,11 +86,11 @@ std::unique_ptr<CProject> CProject::fromFile (const std::string& filename, std::
return project;
}
void CProject::setWallpaper (const CWallpaper* wallpaper) {
void CProject::setWallpaper (std::shared_ptr <const CWallpaper> wallpaper) {
this->m_wallpaper = wallpaper;
}
const CWallpaper* CProject::getWallpaper () const {
const std::shared_ptr <const CWallpaper> CProject::getWallpaper () const {
return this->m_wallpaper;
}
@ -110,7 +102,7 @@ const std::string& CProject::getType () const {
return this->m_type;
}
const std::map<std::string, Projects::CProperty*>& CProject::getProperties () const {
const std::map<std::string, std::shared_ptr <Projects::CProperty>>& CProject::getProperties () const {
return this->m_properties;
}

15
src/WallpaperEngine/Core/CProject.h
View File

@ -23,15 +23,14 @@ class CProject {
public:
CProject (
std::string title, std::string type, std::string workshopid, std::shared_ptr<const CContainer> container,
bool supportsaudioprocessing, const std::map<std::string, Projects::CProperty*>& properties);
~CProject();
bool supportsaudioprocessing, const std::map<std::string, std::shared_ptr<Projects::CProperty>>& properties);
static std::unique_ptr<CProject> fromFile (const std::string& filename, std::shared_ptr<const CContainer> container);
static std::shared_ptr<CProject> fromFile (const std::string& filename, std::shared_ptr<const CContainer> container);
[[nodiscard]] const CWallpaper* getWallpaper () const;
[[nodiscard]] const std::shared_ptr <const CWallpaper> getWallpaper () const;
[[nodiscard]] const std::string& getTitle () const;
[[nodiscard]] const std::string& getType () const;
[[nodiscard]] const std::map<std::string, Projects::CProperty*>& getProperties () const;
[[nodiscard]] const std::map<std::string, std::shared_ptr <Projects::CProperty>>& getProperties () const;
[[nodiscard]] const std::string& getWorkshopId () const;
[[nodiscard]] bool supportsAudioProcessing () const;
@ -39,16 +38,16 @@ class CProject {
[[nodiscard]] std::shared_ptr<const CContainer> getContainer () const;
protected:
void setWallpaper (const CWallpaper* wallpaper);
void setWallpaper (std::shared_ptr <const CWallpaper> wallpaper);
private:
std::map<std::string, Projects::CProperty*> m_properties;
std::map<std::string, std::shared_ptr<Projects::CProperty>> m_properties;
const std::string m_workshopid;
const std::string m_title;
const std::string m_type;
const bool m_supportsaudioprocessing;
const CWallpaper* m_wallpaper;
std::shared_ptr <const CWallpaper> m_wallpaper;
std::shared_ptr<const CContainer> m_container = nullptr;
};
} // namespace WallpaperEngine::Core

4
src/WallpaperEngine/Core/CWallpaper.cpp
View File

@ -4,9 +4,9 @@
using namespace WallpaperEngine::Core;
CWallpaper::CWallpaper (const CProject& project) :
CWallpaper::CWallpaper (std::shared_ptr <const CProject> project) :
m_project (project) {}
const CProject& CWallpaper::getProject () const {
std::shared_ptr <const CProject> CWallpaper::getProject () const {
return this->m_project;
}

6
src/WallpaperEngine/Core/CWallpaper.h
View File

@ -30,15 +30,15 @@ class CWallpaper {
return typeid(*this) == typeid(T);
}
const CProject& getProject () const;
std::shared_ptr <const CProject> getProject () const;
protected:
friend class CProject;
explicit CWallpaper (const CProject& project);
explicit CWallpaper (std::shared_ptr <const CProject> project);
virtual ~CWallpaper() = default;
private:
const CProject& m_project;
std::shared_ptr <const CProject> m_project;
};
} // namespace WallpaperEngine::Core

2
src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
View File

@ -8,7 +8,7 @@
namespace WallpaperEngine::Core::DynamicValues {
class CDynamicValue {
public:
~CDynamicValue ();
virtual ~CDynamicValue ();
[[nodiscard]] const glm::ivec4& getIVec4 () const;
[[nodiscard]] const glm::ivec3& getIVec3 () const;

18
src/WallpaperEngine/Core/Objects/CEffect.cpp
View File

@ -21,8 +21,9 @@ using namespace WallpaperEngine::Core::Objects;
using namespace WallpaperEngine::Core::UserSettings;
CEffect::CEffect (
std::string name, std::string description, std::string group, std::string preview, const CProject& project,
const CUserSettingBoolean* visible, std::vector<std::string> dependencies, std::vector<const Effects::CFBO*> fbos,
std::string name, std::string description, std::string group, std::string preview,
std::shared_ptr <const Core::CProject> project, const CUserSettingBoolean* visible,
std::vector<std::string> dependencies, std::vector<const Effects::CFBO*> fbos,
std::vector<const Images::CMaterial*> materials
) :
m_name (std::move(name)),
@ -36,8 +37,8 @@ CEffect::CEffect (
m_materials (std::move(materials)) {}
const CEffect* CEffect::fromJSON (
const json& data, const CUserSettingBoolean* visible, const CProject& project, const Images::CMaterial* material,
const std::shared_ptr<const CContainer>& container
const json& data, const CUserSettingBoolean* visible, std::shared_ptr <const Core::CProject> project,
const Images::CMaterial* material, const std::shared_ptr<const CContainer>& container
) {
const auto file = jsonFindRequired <std::string> (data, "file", "Object effect must have a file");
const auto effectpasses_it = data.find ("passes");
@ -86,7 +87,7 @@ std::map<std::string, int> CEffect::combosFromJSON (const json::const_iterator&
}
std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> CEffect::constantsFromJSON (
const json::const_iterator& constants_it, const CProject& project
const json::const_iterator& constants_it, std::shared_ptr <const Core::CProject> project
) {
std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constants;
@ -109,7 +110,7 @@ std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*>
if (user != cur.value ().end () && user->is_string ()) {
// look for a property with the correct name
const auto& properties = project.getProperties ();
const auto& properties = project->getProperties ();
const auto property = properties.find (*user);
if (property != properties.end ()) {
@ -234,7 +235,8 @@ std::vector<const Images::CMaterial*> CEffect::materialsFromJSON (
}
std::map<int, Images::CMaterial::OverrideInfo> CEffect::overridesFromJSON (
const json::const_iterator& passes_it, const Images::CMaterial* material, const CProject& project
const json::const_iterator& passes_it, const Images::CMaterial* material,
std::shared_ptr <const Core::CProject> project
) {
std::map<int, Images::CMaterial::OverrideInfo> result;
@ -301,7 +303,7 @@ const std::vector<const Effects::CFBO*>& CEffect::getFbos () const {
}
const Core::CProject& CEffect::getProject () const {
return this->m_project;
return *this->m_project;
}
bool CEffect::isVisible () const {

18
src/WallpaperEngine/Core/Objects/CEffect.h
View File

@ -27,13 +27,14 @@ using namespace WallpaperEngine::Core::UserSettings;
class CEffect {
public:
CEffect (
std::string name, std::string description, std::string group, std::string preview, const CProject& project,
const CUserSettingBoolean* visible, std::vector<std::string> dependencies,
std::vector<const Effects::CFBO*> fbos, std::vector<const Images::CMaterial*> materials);
std::string name, std::string description, std::string group, std::string preview,
std::shared_ptr <const Core::CProject>, const CUserSettingBoolean* visible,
std::vector<std::string> dependencies, std::vector<const Effects::CFBO*> fbos,
std::vector<const Images::CMaterial*> materials);
static const CEffect* fromJSON (
const json& data, const CUserSettingBoolean* visible, const CProject& object, const Images::CMaterial* material,
const std::shared_ptr<const CContainer>& container);
const json& data, const CUserSettingBoolean* visible, std::shared_ptr <const Core::CProject> project,
const Images::CMaterial* material, const std::shared_ptr<const CContainer>& container);
/**
* @return List of dependencies for the effect to work
@ -66,7 +67,7 @@ class CEffect {
protected:
static std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constantsFromJSON (
const json::const_iterator& constants_it, const CProject& project);
const json::const_iterator& constants_it, std::shared_ptr <const Core::CProject> project);
static std::map<std::string, int> combosFromJSON (const json::const_iterator& combos_it);
static std::vector<const Effects::CFBO*> fbosFromJSON (const json::const_iterator& fbos_it);
static std::vector<std::string> dependenciesFromJSON (const json::const_iterator& dependencies_it);
@ -74,7 +75,8 @@ class CEffect {
const json::const_iterator& passes_it, const std::string& name,
const std::shared_ptr<const CContainer>& container, std::map<int, Images::CMaterial::OverrideInfo>);
static std::map<int, Images::CMaterial::OverrideInfo> overridesFromJSON (
const json::const_iterator& passes_it, const Images::CMaterial* material, const CProject& project);
const json::const_iterator& passes_it, const Images::CMaterial* material,
std::shared_ptr <const Core::CProject> project);
private:
/** Effect's name */
@ -88,7 +90,7 @@ class CEffect {
/** If the effect is visible or not */
const UserSettings::CUserSettingBoolean* m_visible;
/** Project this effect is part of */
const CProject& m_project;
std::shared_ptr <const Core::CProject> m_project;
/** List of dependencies for the effect */
const std::vector<std::string> m_dependencies;

25
src/WallpaperEngine/Core/Objects/CImage.cpp
View File

@ -12,13 +12,14 @@ using namespace WallpaperEngine::Core::Objects;
using namespace WallpaperEngine::Core::UserSettings;
CImage::CImage (
const Wallpapers::CScene* scene, const Images::CMaterial* material, const CUserSettingBoolean* visible, int id,
std::string name, const CUserSettingVector3* origin, const CUserSettingVector3* scale,
const CUserSettingVector3* angles, glm::vec2 size, std::string alignment, const CUserSettingVector3* color,
const CUserSettingFloat* alpha, float brightness, uint32_t colorBlendMode, glm::vec2 parallaxDepth, bool fullscreen,
bool passthrough, bool autosize, std::vector<const Objects::CEffect*> effects, std::vector<int> dependencies
std::shared_ptr <const Core::CProject> project, const Images::CMaterial* material,
const CUserSettingBoolean* visible, int id, std::string name, const CUserSettingVector3* origin,
const CUserSettingVector3* scale, const CUserSettingVector3* angles, glm::vec2 size, std::string alignment,
const CUserSettingVector3* color, const CUserSettingFloat* alpha, float brightness, uint32_t colorBlendMode,
glm::vec2 parallaxDepth, bool fullscreen, bool passthrough, bool autosize,
std::vector<const Objects::CEffect*> effects, std::vector<int> dependencies
) :
CObject (scene, visible, id, std::move(name), origin, scale, angles, std::move(dependencies)),
CObject (project, visible, id, std::move(name), origin, scale, angles, std::move(dependencies)),
m_size (size),
m_parallaxDepth (parallaxDepth),
m_material (material),
@ -33,7 +34,7 @@ CImage::CImage (
m_effects (std::move(effects)) {}
const WallpaperEngine::Core::CObject* CImage::fromJSON (
const Wallpapers::CScene* scene, const json& data, const std::shared_ptr<const CContainer>& container,
std::shared_ptr <const Core::CProject> project, const json& data, const std::shared_ptr<const CContainer>& container,
const CUserSettingBoolean* visible, int id, std::string name, const CUserSettingVector3* origin,
const CUserSettingVector3* scale, const CUserSettingVector3* angles, const json::const_iterator& effects_it,
std::vector<int> dependencies
@ -50,7 +51,7 @@ const WallpaperEngine::Core::CObject* CImage::fromJSON (
if (effects_it != data.end () && effects_it->is_array ()) {
for (auto& cur : *effects_it) {
const auto effectVisible = jsonFindUserConfig<CUserSettingBoolean> (cur, scene->getProject(), "visible", true);
const auto effectVisible = jsonFindUserConfig<CUserSettingBoolean> (cur, *project, "visible", true);
// TODO: USER CANNOT MODIFY VALUES ON THE FLY, BUT IT MIGHT BE INTERESTING TO SUPPORT THAT AT SOME POINT?
// TODO: AT LEAST THE ORIGINAL SOFTWARE ALLOWS YOU TO DO THAT IN THE PREVIEW WINDOW
@ -62,14 +63,14 @@ const WallpaperEngine::Core::CObject* CImage::fromJSON (
effects.push_back (
Objects::CEffect::fromJSON (
cur, effectVisible, scene->getProject (), material, container
cur, effectVisible, project, material, container
)
);
}
}
return new CImage (
scene,
project,
material,
visible,
id,
@ -79,8 +80,8 @@ const WallpaperEngine::Core::CObject* CImage::fromJSON (
angles,
jsonFindDefault<glm::vec2> (data, "size", glm::vec2 (0.0, 0.0)),
jsonFindDefault<std::string> (data, "alignment", "center"),
jsonFindUserConfig<CUserSettingVector3> (data, scene->getProject(), "color", {1, 1, 1}),
jsonFindUserConfig<CUserSettingFloat> (data, scene->getProject(), "alpha", 1.0),
jsonFindUserConfig<CUserSettingVector3> (data, *project, "color", {1, 1, 1}),
jsonFindUserConfig<CUserSettingFloat> (data, *project, "alpha", 1.0),
jsonFindDefault<float> (data, "brightness", 1.0),
jsonFindDefault<uint32_t> (data, "colorBlendMode", 0),
jsonFindDefault<glm::vec2> (data, "parallaxDepth", glm::vec2 (0.0, 0.0)),

20
src/WallpaperEngine/Core/Objects/CImage.h
View File

@ -30,10 +30,10 @@ class CImage : public CObject {
public:
static const CObject* fromJSON (
const Wallpapers::CScene* scene, const json& data, const std::shared_ptr<const CContainer>& container,
const CUserSettingBoolean* visible, int id, std::string name, const CUserSettingVector3* origin,
const CUserSettingVector3* scale, const CUserSettingVector3* angles, const json::const_iterator& effects_it,
std::vector<int> dependencies);
std::shared_ptr <const Core::CProject> project, const json& data,
const std::shared_ptr<const CContainer>& container, const CUserSettingBoolean* visible, int id,
std::string name, const CUserSettingVector3* origin, const CUserSettingVector3* scale,
const CUserSettingVector3* angles, const json::const_iterator& effects_it, std::vector<int> dependencies);
/**
* @return The base material to use for the image
@ -86,12 +86,12 @@ class CImage : public CObject {
protected:
CImage (
const Wallpapers::CScene* scene, const Images::CMaterial* material, const CUserSettingBoolean* visible, int id,
std::string name, const CUserSettingVector3* origin, const CUserSettingVector3* scale,
const CUserSettingVector3* angles, glm::vec2 size, std::string alignment, const CUserSettingVector3* color,
const CUserSettingFloat* alpha, float brightness, uint32_t colorBlendMode, glm::vec2 parallaxDepth,
bool fullscreen, bool passthrough, bool autosize, std::vector<const Objects::CEffect*> effects,
std::vector<int> dependencies);
std::shared_ptr <const Core::CProject> project, const Images::CMaterial* material,
const CUserSettingBoolean* visible, int id, std::string name, const CUserSettingVector3* origin,
const CUserSettingVector3* scale, const CUserSettingVector3* angles, glm::vec2 size, std::string alignment,
const CUserSettingVector3* color, const CUserSettingFloat* alpha, float brightness, uint32_t colorBlendMode,
glm::vec2 parallaxDepth, bool fullscreen, bool passthrough, bool autosize,
std::vector<const Objects::CEffect*> effects, std::vector<int> dependencies);
private:
/** The image's size */

18
src/WallpaperEngine/Core/Objects/CParticle.cpp
View File

@ -5,9 +5,10 @@
using namespace WallpaperEngine::Core::Objects;
const CParticle* CParticle::fromFile (
const Wallpapers::CScene* scene, const std::string& filename, std::shared_ptr<const CContainer> container,
const CUserSettingBoolean* visible, int id, const std::string& name, const CUserSettingVector3* origin,
const CUserSettingVector3* angles, const CUserSettingVector3* scale, std::vector<int> dependencies
std::shared_ptr <const Core::CProject> project, const std::string& filename,
const std::shared_ptr<const CContainer>& container, const CUserSettingBoolean* visible, int id,
const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* angles,
const CUserSettingVector3* scale, std::vector<int> dependencies
) {
json data = json::parse (container->readFileAsString (filename));
const auto controlpoint_it = data.find ("controlpoint");
@ -28,7 +29,7 @@ const CParticle* CParticle::fromFile (
initializers.push_back (Particles::CInitializer::fromJSON (cur));
return new CParticle (
scene,
project,
jsonFindRequired <uint32_t> (data, "starttime", "Particles must have start time"),
jsonFindRequired <uint32_t> (data, "maxcount", "Particles must have maximum count"),
visible,
@ -45,13 +46,14 @@ const CParticle* CParticle::fromFile (
}
CParticle::CParticle (
const Wallpapers::CScene* scene, uint32_t starttime, uint32_t maxcount, const CUserSettingBoolean* visible, int id,
const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* scale,
const CUserSettingVector3* angles, const std::vector<const Particles::CControlPoint*>& controlpoints,
std::shared_ptr <const Core::CProject> project, uint32_t starttime, uint32_t maxcount,
const CUserSettingBoolean* visible, int id, const std::string& name, const CUserSettingVector3* origin,
const CUserSettingVector3* scale, const CUserSettingVector3* angles,
const std::vector<const Particles::CControlPoint*>& controlpoints,
const std::vector<const Particles::CEmitter*>& emitters,
const std::vector<const Particles::CInitializer*>& initializers, std::vector<int> dependencies
) :
CObject (scene, visible, id, name, origin, scale, angles, std::move(dependencies)),
CObject (project, visible, id, name, origin, scale, angles, std::move(dependencies)),
m_starttime (starttime),
m_maxcount (maxcount),
m_controlpoints (controlpoints),

14
src/WallpaperEngine/Core/Objects/CParticle.h
View File

@ -18,9 +18,10 @@ class CParticle : public CObject {
public:
static const CParticle* fromFile (
const Wallpapers::CScene* scene, const std::string& filename, std::shared_ptr<const CContainer> container,
const CUserSettingBoolean* visible, int id, const std::string& name, const CUserSettingVector3* origin,
const CUserSettingVector3* angles, const CUserSettingVector3* scale, std::vector<int> dependencies);
std::shared_ptr <const Core::CProject> project, const std::string& filename,
const std::shared_ptr<const CContainer>& container, const CUserSettingBoolean* visible, int id,
const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* angles,
const CUserSettingVector3* scale, std::vector<int> dependencies);
/**
* @return The list of emitters for the particle system
@ -37,9 +38,10 @@ class CParticle : public CObject {
protected:
CParticle (
const Wallpapers::CScene* scene, uint32_t starttime, uint32_t maxcount, const CUserSettingBoolean* visible,
int id, const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* scale,
const CUserSettingVector3* angles, const std::vector<const Particles::CControlPoint*>& controlpoints,
std::shared_ptr <const Core::CProject> project, uint32_t starttime, uint32_t maxcount,
const CUserSettingBoolean* visible, int id, const std::string& name, const CUserSettingVector3* origin,
const CUserSettingVector3* scale, const CUserSettingVector3* angles,
const std::vector<const Particles::CControlPoint*>& controlpoints,
const std::vector<const Particles::CEmitter*>& emitters,
const std::vector<const Particles::CInitializer*>& initializers, std::vector<int> dependencies);

14
src/WallpaperEngine/Core/Objects/CSound.cpp
View File

@ -7,17 +7,17 @@
using namespace WallpaperEngine::Core::Objects;
CSound::CSound (
const Wallpapers::CScene* scene, const CUserSettingBoolean* visible, int id, std::string name,
const CUserSettingVector3* origin, const CUserSettingVector3* scale, const CUserSettingVector3* angles, bool repeat,
std::vector<std::string> sounds, std::vector<int> dependencies
std::shared_ptr <const Core::CProject> project, const CUserSettingBoolean* visible, int id, std::string name,
const CUserSettingVector3* origin, const CUserSettingVector3* scale, const CUserSettingVector3* angles,
bool repeat, std::vector<std::string> sounds, std::vector<int> dependencies
) :
CObject (scene, visible, id, std::move(name), origin, scale, angles, std::move(dependencies)),
CObject (project, visible, id, std::move(name), origin, scale, angles, std::move(dependencies)),
m_repeat (repeat),
m_sounds (std::move(sounds)) {}
const WallpaperEngine::Core::CObject* CSound::fromJSON (
const Wallpapers::CScene* scene, const json& data, const CUserSettingBoolean* visible, int id,
const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* scale,
std::shared_ptr <const Core::CProject> project, const json& data, const CUserSettingBoolean* visible,
int id, const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* scale,
const CUserSettingVector3* angles, std::vector<int> dependencies
) {
// TODO: PARSE AUDIO VOLUME
@ -31,7 +31,7 @@ const WallpaperEngine::Core::CObject* CSound::fromJSON (
sounds.push_back (cur);
return new CSound (
scene,
project,
visible,
id,
name,

6
src/WallpaperEngine/Core/Objects/CSound.h
View File

@ -20,7 +20,7 @@ class CSound : public CObject {
public:
static const CObject* fromJSON (
const Wallpapers::CScene* scene, const json& data, const CUserSettingBoolean* visible,
std::shared_ptr <const Core::CProject> project, const json& data, const CUserSettingBoolean* visible,
int id, const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* scale,
const CUserSettingVector3* angles, std::vector<int> dependencies);
@ -35,7 +35,7 @@ class CSound : public CObject {
protected:
CSound (
const Wallpapers::CScene* scene, const CUserSettingBoolean* visible, int id, std::string name,
std::shared_ptr <const Core::CProject> project, const CUserSettingBoolean* visible, int id, std::string name,
const CUserSettingVector3* origin, const CUserSettingVector3* scale, const CUserSettingVector3* angles,
bool repeat, std::vector<std::string> sounds, std::vector<int> dependencies);
@ -43,6 +43,6 @@ class CSound : public CObject {
/** If the sounds should repeat or not */
bool m_repeat = false;
/** The list of sounds to play */
std::vector<std::string> m_sounds;
std::vector<std::string> m_sounds = {};
};
} // namespace WallpaperEngine::Core::Objects

2
src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.cpp
View File

@ -3,7 +3,7 @@
using namespace WallpaperEngine::Core::Objects::Effects::Constants;
CShaderConstantProperty::CShaderConstantProperty (const CProperty* property) {
CShaderConstantProperty::CShaderConstantProperty (std::shared_ptr <const CProperty> property) {
property->connectOutgoing (this);
}

2
src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h
View File

@ -13,7 +13,7 @@ using namespace WallpaperEngine::Core::Projects;
*/
class CShaderConstantProperty : public CShaderConstant {
public:
explicit CShaderConstantProperty (const CProperty* property);
explicit CShaderConstantProperty (std::shared_ptr <const CProperty> property);
[[nodiscard]] std::string toString () const override;
};

2
src/WallpaperEngine/Core/Projects/CProperty.cpp
View File

@ -10,7 +10,7 @@
using namespace WallpaperEngine::Core::Projects;
CProperty* CProperty::fromJSON (const json& data, const std::string& name) {
std::shared_ptr<CProperty> CProperty::fromJSON (const json& data, const std::string& name) {
const auto type = jsonFindRequired (data, "type", "Project properties must have the type field");
if (*type == "color")

2
src/WallpaperEngine/Core/Projects/CProperty.h
View File

@ -16,7 +16,7 @@ class CProperty : public CDynamicValue {
public:
typedef std::function<void(const CProperty*)> function_type;
virtual ~CProperty () = default;
static CProperty* fromJSON (const json& data, const std::string& name);
static std::shared_ptr<CProperty> fromJSON (const json& data, const std::string& name);
template <class T> [[nodiscard]] const T* as () const {
if (is <T> ()) {

4
src/WallpaperEngine/Core/Projects/CPropertyBoolean.cpp
View File

@ -6,8 +6,8 @@
using namespace WallpaperEngine::Core::Projects;
CPropertyBoolean* CPropertyBoolean::fromJSON (const json& data, std::string name) {
return new CPropertyBoolean (
std::shared_ptr<CPropertyBoolean> CPropertyBoolean::fromJSON (const json& data, std::string name) {
return std::make_shared <CPropertyBoolean> (
jsonFindRequired <bool> (data, "value", "Boolean property must have a value"),
std::move(name),
jsonFindDefault<std::string> (data, "text", "")

7
src/WallpaperEngine/Core/Projects/CPropertyBoolean.h
View File

@ -10,13 +10,12 @@ using json = nlohmann::json;
*/
class CPropertyBoolean final : public CProperty {
public:
static CPropertyBoolean* fromJSON (const json& data, std::string name);
CPropertyBoolean (bool value, std::string name, std::string text);
static std::shared_ptr<CPropertyBoolean> fromJSON (const json& data, std::string name);
[[nodiscard]] std::string dump () const override;
void set (const std::string& value) override;
[[nodiscard]] const char* getType () const override;
private:
CPropertyBoolean (bool value, std::string name, std::string text);
[[nodiscard]] const char* getType () const override;
};
} // namespace WallpaperEngine::Core::Projects

4
src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
View File

@ -21,11 +21,11 @@ glm::vec3 ParseColor (std::string value) {
return WallpaperEngine::Core::aToColorf (value);
}
CPropertyColor* CPropertyColor::fromJSON (const json& data, std::string name) {
std::shared_ptr<CPropertyColor> CPropertyColor::fromJSON (const json& data, std::string name) {
const auto value = jsonFindRequired <std::string> (data, "value", "Color property must have a value");
const auto text = jsonFindDefault<std::string> (data, "text", "");
return new CPropertyColor (value, std::move(name), text);
return std::make_shared <CPropertyColor> (value, std::move(name), text);
}
void CPropertyColor::set (const std::string& value) {

7
src/WallpaperEngine/Core/Projects/CPropertyColor.h
View File

@ -12,13 +12,12 @@ using json = nlohmann::json;
*/
class CPropertyColor final : public CProperty {
public:
static CPropertyColor* fromJSON (const json& data, std::string name);
CPropertyColor (const std::string& color, std::string name, std::string text);
static std::shared_ptr<CPropertyColor> fromJSON (const json& data, std::string name);
[[nodiscard]] std::string dump () const override;
void set (const std::string& value) override;
[[nodiscard]] const char* getType () const override;
private:
CPropertyColor (const std::string& color, std::string name, std::string text);
[[nodiscard]] const char* getType () const override;
};
} // namespace WallpaperEngine::Core::Projects

32
src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
View File

@ -8,8 +8,8 @@
using namespace WallpaperEngine::Core::Projects;
CPropertyCombo* CPropertyCombo::fromJSON (const json& data, std::string name) {
std::vector<const CPropertyComboValue*> values;
std::shared_ptr<CPropertyCombo> CPropertyCombo::fromJSON (const json& data, std::string name) {
std::vector<CPropertyComboValue> values;
const auto options = jsonFindRequired (data, "options", "Options for a property combo is required");
if (!options->is_array ())
@ -21,15 +21,13 @@ CPropertyCombo* CPropertyCombo::fromJSON (const json& data, std::string name) {
continue;
// check for label and value to ensure they're there
auto prop = new CPropertyComboValue {
values.push_back ({
.label = jsonFindRequired<std::string> (cur, "label", "Label is required for a property combo option"),
.value = jsonFindRequired<std::string> (cur, "value", "Value is required for a property combo option")
};
values.push_back (prop);
});
}
return new CPropertyCombo (
return std::make_shared <CPropertyCombo> (
std::move(name),
jsonFindDefault<std::string> (data, "text", ""),
jsonFindRequired<std::string> (data, "value", "Value is required for a property combo"),
@ -38,18 +36,14 @@ CPropertyCombo* CPropertyCombo::fromJSON (const json& data, std::string name) {
}
CPropertyCombo::CPropertyCombo (
std::string name, std::string text, const std::string& defaultValue, std::vector<const CPropertyComboValue*> values
std::string name, std::string text, const std::string& defaultValue,
std::vector<CPropertyComboValue> values
) :
CProperty (std::move(name), std::move(text)),
m_values (std::move(values)) {
this->set (defaultValue);
}
CPropertyCombo::~CPropertyCombo () {
for (const auto* value : this->m_values)
delete value;
}
std::string CPropertyCombo::dump () const {
std::stringstream ss;
@ -61,8 +55,8 @@ std::string CPropertyCombo::dump () const {
<< "\t\t"
<< "Posible values:" << std::endl;
for (const auto cur : this->m_values)
ss << "\t\t" << cur->label << " -> " << cur->value << std::endl;
for (const auto& cur : this->m_values)
ss << "\t\t" << cur.label << " -> " << cur.value << std::endl;
return ss.str ();
}
@ -72,8 +66,8 @@ void CPropertyCombo::set (const std::string& value) {
int index = 0;
// ensure the value is present somewhere in the value list
for (const auto cur : this->m_values) {
if (cur->value == value) {
for (const auto& cur : this->m_values) {
if (cur.value == value) {
found = true;
break;
}
@ -92,8 +86,8 @@ int CPropertyCombo::translateValueToIndex (const std::string& value) const {
int index = 0;
// ensure the value is present somewhere in the value list
for (const auto cur : this->m_values) {
if (cur->value == value) {
for (const auto& cur : this->m_values) {
if (cur.value == value) {
found = true;
break;
}

14
src/WallpaperEngine/Core/Projects/CPropertyCombo.h
View File

@ -8,7 +8,7 @@ using json = nlohmann::json;
/**
* Represents different combo values
*/
class CPropertyComboValue {
struct CPropertyComboValue {
public:
const std::string label;
const std::string value;
@ -23,20 +23,20 @@ class CPropertyComboValue {
*/
class CPropertyCombo final : public CProperty {
public:
static CPropertyCombo* fromJSON (const json& data, std::string name);
static std::shared_ptr<CPropertyCombo> fromJSON (const json& data, std::string name);
~CPropertyCombo () override;
CPropertyCombo (
std::string name, std::string text, const std::string& defaultValue,
std::vector<CPropertyComboValue> values);
[[nodiscard]] std::string dump () const override;
void set (const std::string& value) override;
int translateValueToIndex (const std::string& value) const;
[[nodiscard]] const char* getType () const override;
private:
CPropertyCombo (
std::string name, std::string text, const std::string& defaultValue, std::vector<const CPropertyComboValue*> values);
/** List of values available to select */
const std::vector<const CPropertyComboValue*> m_values;
const std::vector<CPropertyComboValue> m_values;
};
} // namespace WallpaperEngine::Core::Projects

4
src/WallpaperEngine/Core/Projects/CPropertySlider.cpp
View File

@ -4,14 +4,14 @@
using namespace WallpaperEngine::Core::Projects;
CPropertySlider* CPropertySlider::fromJSON (const json& data, const std::string& name) {
std::shared_ptr<CPropertySlider> CPropertySlider::fromJSON (const json& data, const std::string& name) {
const auto value = data.find ("value");
const auto text = jsonFindDefault<std::string> (data, "text", "");
const auto min = jsonFindDefault (data, "min", 0.0f);
const auto max = jsonFindDefault (data, "max", 0.0f);
const auto step = jsonFindDefault (data, "step", 0.0f);
return new CPropertySlider (*value, name, text, min, max, step);
return std::make_shared <CPropertySlider> (*value, name, text, min, max, step);
}
const float& CPropertySlider::getMinValue () const {

6
src/WallpaperEngine/Core/Projects/CPropertySlider.h
View File

@ -12,8 +12,9 @@ using json = nlohmann::json;
*/
class CPropertySlider final : public CProperty {
public:
static CPropertySlider* fromJSON (const json& data, const std::string& name);
CPropertySlider (float value, const std::string& name, const std::string& text, float min, float max, float step);
static std::shared_ptr<CPropertySlider> fromJSON (const json& data, const std::string& name);
/**
* @return The slider's minimum value
*/
@ -28,10 +29,9 @@ class CPropertySlider final : public CProperty {
[[nodiscard]] const float& getStep () const;
[[nodiscard]] std::string dump () const override;
void set (const std::string& value) override;
[[nodiscard]] const char* getType () const override;
[[nodiscard]] const char* getType () const override;
private:
CPropertySlider (float value, const std::string& name, const std::string& text, float min, float max, float step);
/** Minimum value */
const float m_min;

6
src/WallpaperEngine/Core/Projects/CPropertyText.cpp
View File

@ -5,11 +5,9 @@
using namespace WallpaperEngine::Core::Projects;
CPropertyText* CPropertyText::fromJSON (const json& data, std::string name) {
std::shared_ptr<CPropertyText> CPropertyText::fromJSON (const json& data, std::string name) {
//TODO: VALIDATE THIS IS RIGHT
const auto text = data.find ("type");
return new CPropertyText (std::move(name), *text);
return std::make_shared <CPropertyText> (std::move(name), *data.find ("type"));
}
std::string CPropertyText::dump () const {

7
src/WallpaperEngine/Core/Projects/CPropertyText.h
View File

@ -10,12 +10,13 @@ using json = nlohmann::json;
*/
class CPropertyText final : public CProperty {
public:
static CPropertyText* fromJSON (const json& data, std::string name);
CPropertyText (std::string name, std::string text);
static std::shared_ptr<CPropertyText> fromJSON (const json& data, std::string name);
[[nodiscard]] std::string dump () const override;
void set (const std::string& value) override;
[[nodiscard]] const char* getType () const override;
[[nodiscard]] const char* getType () const override;
private:
CPropertyText (std::string name, std::string text);
};
} // namespace WallpaperEngine::Core::Projects

4
src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
View File

@ -16,7 +16,7 @@ using namespace WallpaperEngine::Core::Projects;
using namespace WallpaperEngine::Core::UserSettings;
CUserSettingBoolean::CUserSettingBoolean (
bool hasCondition, bool defaultValue, const Projects::CProperty* source, std::string expectedValue
bool hasCondition, bool defaultValue, std::shared_ptr <const Projects::CProperty> source, std::string expectedValue
) :
CUserSettingValue (),
m_hasCondition (hasCondition),
@ -41,7 +41,7 @@ CUserSettingBoolean::CUserSettingBoolean (
const CUserSettingBoolean* CUserSettingBoolean::fromJSON (const nlohmann::json& data, const CProject& project) {
bool hasCondition = false;
const Projects::CProperty* sourceProperty = nullptr;
std::shared_ptr <const Projects::CProperty> sourceProperty = nullptr;
bool defaultValue;
std::string source;
std::string expectedValue;

4
src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
View File

@ -17,10 +17,10 @@ class CUserSettingBoolean : public CUserSettingValue {
private:
CUserSettingBoolean (
bool hasCondition, bool defaultValue, const Projects::CProperty* source, std::string expectedValue);
bool hasCondition, bool defaultValue, std::shared_ptr <const Projects::CProperty> source, std::string expectedValue);
const bool m_hasCondition;
const std::string m_expectedValue;
const Projects::CProperty* m_source;
const std::shared_ptr <const Projects::CProperty> m_source;
};
} // namespace WallpaperEngine::Core::UserSettings

4
src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
View File

@ -13,7 +13,7 @@ using namespace WallpaperEngine::Core::Projects;
using namespace WallpaperEngine::Core::UserSettings;
CUserSettingFloat::CUserSettingFloat (
bool hasCondition, float defaultValue, const Projects::CProperty* source, std::string expectedValue
bool hasCondition, float defaultValue, std::shared_ptr <const Projects::CProperty> source, std::string expectedValue
) :
CUserSettingValue (),
m_default (defaultValue),
@ -38,7 +38,7 @@ const CUserSettingFloat* CUserSettingFloat::fromJSON (const nlohmann::json& data
std::string source;
std::string expectedValue;
bool hasCondition = false;
const Projects::CProperty* sourceProperty = nullptr;
std::shared_ptr <const Projects::CProperty> sourceProperty = nullptr;
if (data.is_object ()) {
auto animation = data.find ("animation");

4
src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
View File

@ -17,11 +17,11 @@ class CUserSettingFloat : public CUserSettingValue {
private:
CUserSettingFloat (
bool hasCondition, float defaultValue, const Projects::CProperty* source, std::string expectedValue);
bool hasCondition, float defaultValue, std::shared_ptr <const Projects::CProperty> source, std::string expectedValue);
const double m_default;
const bool m_hasCondition;
const Projects::CProperty* m_source;
const std::shared_ptr <const Projects::CProperty> m_source;
const std::string m_expectedValue;
};
} // namespace WallpaperEngine::Core::UserSettings

4
src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.cpp
View File

@ -13,7 +13,7 @@ using namespace WallpaperEngine::Core::Projects;
using namespace WallpaperEngine::Core::UserSettings;
CUserSettingVector3::CUserSettingVector3 (
bool hasCondition, glm::vec3 defaultValue, const Projects::CProperty* source, std::string expectedValue
bool hasCondition, glm::vec3 defaultValue, std::shared_ptr <const Projects::CProperty> source, std::string expectedValue
) :
CUserSettingValue (),
m_hasCondition (hasCondition),
@ -35,7 +35,7 @@ CUserSettingVector3::CUserSettingVector3 (
const CUserSettingVector3* CUserSettingVector3::fromJSON (const nlohmann::json& data, const CProject& project) {
bool hasCondition = false;
const Projects::CProperty* sourceProperty = nullptr;
std::shared_ptr <const Projects::CProperty> sourceProperty = nullptr;
glm::vec3 defaultValue;
std::string source;
std::string expectedValue;

5
src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h
View File

@ -19,10 +19,11 @@ class CUserSettingVector3 : public CUserSettingValue {
private:
CUserSettingVector3 (
bool hasCondition, glm::vec3 defaultValue, const Projects::CProperty* source, std::string expectedValue);
bool hasCondition, glm::vec3 defaultValue, std::shared_ptr<const Projects::CProperty> source,
std::string expectedValue);
const bool m_hasCondition;
const Projects::CProperty* m_source;
const std::shared_ptr <const Projects::CProperty> m_source;
const std::string m_expectedValue;
};
} // namespace WallpaperEngine::Core::UserSettings

19
src/WallpaperEngine/Core/Wallpapers/CScene.cpp
View File

@ -11,7 +11,7 @@ using namespace WallpaperEngine::Core;
using namespace WallpaperEngine::Core::Wallpapers;
CScene::CScene (
const CProject& project, std::shared_ptr<const CContainer> container, const Scenes::CCamera* camera,
std::shared_ptr <const CProject> project, std::shared_ptr<const CContainer> container, const Scenes::CCamera* camera,
glm::vec3 ambientColor, const CUserSettingBoolean* bloom, const CUserSettingFloat* bloomStrength,
const CUserSettingFloat* bloomThreshold, bool cameraFade, bool cameraParallax, float cameraParallaxAmount,
float cameraParallaxDelay, float cameraParallaxMouseInfluence, bool cameraPreview, bool cameraShake,
@ -39,7 +39,10 @@ CScene::CScene (
m_orthogonalProjection (orthogonalProjection),
m_skylightColor (skylightColor) {}
const CScene* CScene::fromFile (const std::string& filename, const CProject& project, const std::shared_ptr<const CContainer>& container) {
std::shared_ptr <const CScene> CScene::fromFile (
const std::string& filename, std::shared_ptr <const Core::CProject> project,
const std::shared_ptr<const CContainer>& container
) {
json content = json::parse (container->readFileAsString (filename));
const auto general_it = jsonFindRequired (content, "general", "Scenes must have a general section");
@ -48,13 +51,13 @@ const CScene* CScene::fromFile (const std::string& filename, const CProject& pro
// TODO: FIND IF THESE DEFAULTS ARE SENSIBLE OR NOT AND PERFORM PROPER VALIDATION WHEN CAMERA PREVIEW AND CAMERA
// PARALLAX ARE PRESENT
auto* scene = new CScene (
auto scene = std::make_shared <CScene> (
project, container,
Scenes::CCamera::fromJSON (jsonFindRequired (content, "camera", "Scenes must have a defined camera")),
jsonFindDefault<glm::vec3> (*general_it, "ambientcolor", glm::vec3 (0, 0, 0)),
jsonFindUserConfig<CUserSettingBoolean> (*general_it, project, "bloom", false),
jsonFindUserConfig<CUserSettingFloat> (*general_it, project, "bloomstrength", 0.0),
jsonFindUserConfig<CUserSettingFloat> (*general_it, project, "bloomthreshold", 0.0),
jsonFindUserConfig<CUserSettingBoolean> (*general_it, *project, "bloom", false),
jsonFindUserConfig<CUserSettingFloat> (*general_it, *project, "bloomstrength", 0.0),
jsonFindUserConfig<CUserSettingFloat> (*general_it, *project, "bloomthreshold", 0.0),
jsonFindDefault<bool> (*general_it, "camerafade", false),
jsonFindDefault<bool> (*general_it, "cameraparallax", true),
jsonFindDefault<float> (*general_it, "cameraparallaxamount", 1.0f),
@ -65,13 +68,13 @@ const CScene* CScene::fromFile (const std::string& filename, const CProject& pro
jsonFindDefault<float> (*general_it, "camerashakeamplitude", 0.0f),
jsonFindDefault<float> (*general_it, "camerashakeroughness", 0.0f),
jsonFindDefault<float> (*general_it, "camerashakespeed", 0.0f),
jsonFindUserConfig<CUserSettingVector3> (*general_it, project, "clearcolor", {1, 1, 1}),
jsonFindUserConfig<CUserSettingVector3> (*general_it, *project, "clearcolor", {1, 1, 1}),
Scenes::CProjection::fromJSON (jsonFindRequired (*general_it, "orthogonalprojection", "General section must have orthogonal projection info")),
jsonFindDefault<glm::vec3> (*general_it, "skylightcolor", glm::vec3 (0, 0, 0))
);
for (const auto& cur : *objects_it)
scene->insertObject (CObject::fromJSON (cur, scene, container));
scene->insertObject (CObject::fromJSON (cur, project, container));
return scene;
}

25
src/WallpaperEngine/Core/Wallpapers/CScene.h
View File

@ -17,11 +17,21 @@ using json = nlohmann::json;
class CScene : public CWallpaper {
public:
static const CScene* fromFile (const std::string& filename, const CProject& project, const std::shared_ptr<const CContainer>& container);
CScene (
std::shared_ptr <const Core::CProject> project, std::shared_ptr<const CContainer> container,
const Scenes::CCamera* camera, glm::vec3 ambientColor, const CUserSettingBoolean* bloom,
const CUserSettingFloat* bloomStrength, const CUserSettingFloat* bloomThreshold, bool cameraFade,
bool cameraParallax, float cameraParallaxAmount, float cameraParallaxDelay, float cameraParallaxMouseInfluence,
bool cameraPreview, bool cameraShake, float cameraShakeAmplitude, float cameraShakeRoughness,
float cameraShakeSpeed, const CUserSettingVector3* clearColor, const Scenes::CProjection* orthogonalProjection,
glm::vec3 skylightColor);
static std::shared_ptr <const CScene> fromFile (
const std::string& filename, std::shared_ptr <const Core::CProject> project,
const std::shared_ptr<const CContainer>& container);
[[nodiscard]] const std::map<uint32_t, const CObject*>& getObjects () const;
[[nodiscard]] const std::vector<const CObject*>& getObjectsByRenderOrder () const;
[[nodiscard]] const std::vector<const CObject*>& getObjectsByRenderOrder () const;
[[nodiscard]] const glm::vec3& getAmbientColor () const;
[[nodiscard]] bool isBloom () const;
[[nodiscard]] float getBloomStrength () const;
@ -39,18 +49,11 @@ class CScene : public CWallpaper {
[[nodiscard]] const glm::vec3& getClearColor () const;
[[nodiscard]] const Scenes::CProjection* getOrthogonalProjection () const;
[[nodiscard]] const glm::vec3& getSkylightColor () const;
[[nodiscard]] const Scenes::CCamera* getCamera () const;
protected:
friend class CWallpaper;
CScene (
const CProject& project, std::shared_ptr<const CContainer> container, const Scenes::CCamera* camera,
glm::vec3 ambientColor, const CUserSettingBoolean* bloom, const CUserSettingFloat* bloomStrength,
const CUserSettingFloat* bloomThreshold, bool cameraFade, bool cameraParallax, float cameraParallaxAmount,
float cameraParallaxDelay, float cameraParallaxMouseInfluence, bool cameraPreview, bool cameraShake,
float cameraShakeAmplitude, float cameraShakeRoughness, float cameraShakeSpeed,
const CUserSettingVector3* clearColor, const Scenes::CProjection* orthogonalProjection, glm::vec3 skylightColor);
friend class CWallpaper;
void insertObject (const CObject* object);

2
src/WallpaperEngine/Core/Wallpapers/CVideo.cpp
View File

@ -5,7 +5,7 @@
using namespace WallpaperEngine::Core;
using namespace WallpaperEngine::Core::Wallpapers;
CVideo::CVideo (std::string filename, const CProject& project) :
CVideo::CVideo (std::string filename, std::shared_ptr <const CProject> project) :
CWallpaper (project),
m_filename (std::move(filename)) {}

2
src/WallpaperEngine/Core/Wallpapers/CVideo.h
View File

@ -13,7 +13,7 @@ extern "C" {
namespace WallpaperEngine::Core::Wallpapers {
class CVideo : public CWallpaper {
public:
CVideo (std::string filename, const CProject& project);
CVideo (std::string filename, std::shared_ptr <const CProject> project);
const std::string& getFilename () const;

2
src/WallpaperEngine/Core/Wallpapers/CWeb.cpp
View File

@ -9,6 +9,6 @@ const std::string& CWeb::getFilename () const {
return this->m_filename;
}
CWeb::CWeb (std::string filename, const CProject& project) :
CWeb::CWeb (std::string filename, std::shared_ptr <const CProject> project) :
CWallpaper (project),
m_filename (std::move(filename)) {}

2
src/WallpaperEngine/Core/Wallpapers/CWeb.h
View File

@ -19,7 +19,7 @@ extern "C"
namespace WallpaperEngine::Core::Wallpapers {
class CWeb : public CWallpaper {
public:
CWeb (std::string filename, const CProject& project);
CWeb (std::string filename, std::shared_ptr <const CProject> project);
const std::string& getFilename () const;

4
src/WallpaperEngine/Render/CRenderContext.cpp
View File

@ -34,7 +34,7 @@ void CRenderContext::render (Drivers::Output::COutputViewport* viewport) {
viewport->swapOutput ();
}
void CRenderContext::setWallpaper (const std::string& display, CWallpaper* wallpaper) {
void CRenderContext::setWallpaper (const std::string& display, std::shared_ptr <CWallpaper> wallpaper) {
this->m_wallpapers.insert_or_assign (display, wallpaper);
}
@ -63,7 +63,7 @@ std::shared_ptr<const ITexture> CRenderContext::resolveTexture (const std::strin
return this->m_textureCache->resolve (name);
}
const std::map<std::string, CWallpaper*>& CRenderContext::getWallpapers () const {
const std::map<std::string, std::shared_ptr <CWallpaper>>& CRenderContext::getWallpapers () const {
return this->m_wallpapers;
}
} // namespace WallpaperEngine::Render

6
src/WallpaperEngine/Render/CRenderContext.h
View File

@ -35,20 +35,20 @@ class CRenderContext {
CRenderContext (Drivers::CVideoDriver& driver, CWallpaperApplication& app);
void render (Drivers::Output::COutputViewport* viewport);
void setWallpaper (const std::string& display, CWallpaper* wallpaper);
void setWallpaper (const std::string& display, std::shared_ptr <CWallpaper> wallpaper);
void setPause (bool newState);
[[nodiscard]] Input::CInputContext& getInputContext () const;
[[nodiscard]] const CWallpaperApplication& getApp () const;
[[nodiscard]] const Drivers::CVideoDriver& getDriver () const;
[[nodiscard]] const Drivers::Output::COutput& getOutput () const;
std::shared_ptr<const ITexture> resolveTexture (const std::string& name);
[[nodiscard]] const std::map<std::string, CWallpaper*>& getWallpapers () const;
[[nodiscard]] const std::map<std::string, std::shared_ptr <CWallpaper>>& getWallpapers () const;
private:
/** Video driver in use */
Drivers::CVideoDriver& m_driver;
/** Maps screen -> wallpaper list */
std::map<std::string, CWallpaper*> m_wallpapers = {};
std::map<std::string, std::shared_ptr <CWallpaper>> m_wallpapers = {};
/** App that holds the render context */
CWallpaperApplication& m_app;
/** Texture cache for the render */

32
src/WallpaperEngine/Render/CWallpaper.cpp
View File

@ -6,26 +6,16 @@
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <utility>
using namespace WallpaperEngine::Render;
CWallpaper::CWallpaper (
const Core::CWallpaper* wallpaperData, CRenderContext& context,CAudioContext& audioContext,
std::shared_ptr <const Core::CWallpaper> wallpaperData, CRenderContext& context,CAudioContext& audioContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
) :
CContextAware (context),
m_wallpaperData (wallpaperData),
m_sceneFBO (nullptr),
m_texCoordBuffer (GL_NONE),
m_positionBuffer (GL_NONE),
m_shader (GL_NONE),
g_Texture0 (GL_NONE),
a_Position (GL_NONE),
a_TexCoord (GL_NONE),
m_vaoBuffer (GL_NONE),
m_destFramebuffer (GL_NONE),
m_audioContext (audioContext),
m_state (scalingMode, clampMode) {
// generate the VAO to stop opengl from complaining
@ -52,10 +42,10 @@ CWallpaper::CWallpaper (
CWallpaper::~CWallpaper () = default;
std::shared_ptr<const CContainer> CWallpaper::getContainer () const {
return this->m_wallpaperData->getProject ().getContainer ();
return this->m_wallpaperData->getProject ()->getContainer ();
}
const WallpaperEngine::Core::CWallpaper* CWallpaper::getWallpaperData () const {
std::shared_ptr <const WallpaperEngine::Core::CWallpaper> CWallpaper::getWallpaperData () const {
return this->m_wallpaperData;
}
@ -285,20 +275,20 @@ std::shared_ptr<const CFBO> CWallpaper::getFBO () const {
return this->m_sceneFBO;
}
CWallpaper* CWallpaper::fromWallpaper (
const Core::CWallpaper* wallpaper, CRenderContext& context, CAudioContext& audioContext,
std::shared_ptr<CWallpaper> CWallpaper::fromWallpaper (
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
WebBrowser::CWebBrowserContext& browserContext, const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
) {
if (wallpaper->is<Core::Wallpapers::CScene> ()) {
return new WallpaperEngine::Render::Wallpapers::CScene (
wallpaper->as<Core::Wallpapers::CScene> (), context, audioContext, scalingMode, clampMode);
return std::make_shared <WallpaperEngine::Render::Wallpapers::CScene> (
wallpaper, context, audioContext, scalingMode, clampMode);
} else if (wallpaper->is<Core::Wallpapers::CVideo> ()) {
return new WallpaperEngine::Render::Wallpapers::CVideo (
wallpaper->as<Core::Wallpapers::CVideo> (), context, audioContext, scalingMode, clampMode);
return std::make_shared<WallpaperEngine::Render::Wallpapers::CVideo> (
wallpaper, context, audioContext, scalingMode, clampMode);
} else if (wallpaper->is<Core::Wallpapers::CWeb> ()) {
return new WallpaperEngine::Render::Wallpapers::CWeb (
wallpaper->as<Core::Wallpapers::CWeb> (), context, audioContext, browserContext, scalingMode, clampMode);
return std::make_shared<WallpaperEngine::Render::Wallpapers::CWeb> (
wallpaper, context, audioContext, browserContext, scalingMode, clampMode);
} else
sLog.exception ("Unsupported wallpaper type");
}

12
src/WallpaperEngine/Render/CWallpaper.h
View File

@ -153,15 +153,15 @@ class CWallpaper : public Helpers::CContextAware {
*
* @return
*/
static CWallpaper* fromWallpaper (
const Core::CWallpaper* wallpaper, CRenderContext& context, CAudioContext& audioContext,
static std::shared_ptr<CWallpaper> fromWallpaper (
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
WebBrowser::CWebBrowserContext& browserContext, const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
protected:
CWallpaper (
const Core::CWallpaper* wallpaperData, CRenderContext& context, CAudioContext& audioContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
std::shared_ptr <const WallpaperEngine::Core::CWallpaper> wallpaperData, CRenderContext& context,
CAudioContext& audioContext, const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
/**
@ -174,9 +174,9 @@ class CWallpaper : public Helpers::CContextAware {
*/
void setupFramebuffers ();
const Core::CWallpaper* m_wallpaperData;
std::shared_ptr <const WallpaperEngine::Core::CWallpaper> m_wallpaperData;
[[nodiscard]] const Core::CWallpaper* getWallpaperData () const;
[[nodiscard]] std::shared_ptr <const WallpaperEngine::Core::CWallpaper> getWallpaperData () const;
/** The FBO used for scene output */
std::shared_ptr<const CFBO> m_sceneFBO = nullptr;

4
src/WallpaperEngine/Render/Objects/CImage.cpp
View File

@ -236,7 +236,7 @@ void CImage::setup () {
new CEffect (
this,
new Core::Objects::CEffect (
"", "", "", "", this->m_image->getScene ()->getProject (),
"", "", "", "", this->m_image->getProject (),
Core::UserSettings::CUserSettingBoolean::fromScalar (true),
{}, {}, {})),
this->m_image->getMaterial ()
@ -272,7 +272,7 @@ void CImage::setup () {
new CEffect (
this,
new Core::Objects::CEffect (
"", "", "", "", this->m_image->getScene ()->getProject (),
"", "", "", "", this->m_image->getProject (),
Core::UserSettings::CUserSettingBoolean::fromScalar (true), {}, {}, {}
)
),

11
src/WallpaperEngine/Render/Wallpapers/CScene.cpp
View File

@ -17,14 +17,13 @@ using namespace WallpaperEngine::Render;
using namespace WallpaperEngine::Render::Wallpapers;
CScene::CScene (
const Core::Wallpapers::CScene* scene, CRenderContext& context, CAudioContext& audioContext,
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
) :
CWallpaper (scene, context, audioContext, scalingMode, clampMode),
m_mousePosition (),
m_mousePositionLast (),
m_parallaxDisplacement () {
CWallpaper (wallpaper, context, audioContext, scalingMode, clampMode) {
// caller should check this, if not a std::bad_cast is good to throw
const auto& scene = wallpaper->as <Core::Wallpapers::CScene> ();
// setup the scene camera
this->m_camera = new CCamera (this, scene->getCamera ());
@ -151,7 +150,7 @@ CScene::CScene (
// create image for bloom passes
if (this->getScene ()->isBloom ()) {
this->m_bloomObject = this->createObject (
WallpaperEngine::Core::CObject::fromJSON (json, this->getScene (), this->getContainer ()));
WallpaperEngine::Core::CObject::fromJSON (json, scene->getProject (), this->getContainer ()));
this->m_objectsByRenderOrder.push_back (this->m_bloomObject);
}

2
src/WallpaperEngine/Render/Wallpapers/CScene.h
View File

@ -15,7 +15,7 @@ namespace WallpaperEngine::Render::Wallpapers {
class CScene final : public CWallpaper {
public:
CScene (
const Core::Wallpapers::CScene* scene, CRenderContext& context, CAudioContext& audioContext,
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);

6
src/WallpaperEngine/Render/Wallpapers/CVideo.cpp
View File

@ -12,11 +12,11 @@ void* get_proc_address (void* ctx, const char* name) {
}
CVideo::CVideo (
const Core::Wallpapers::CVideo* video, CRenderContext& context, CAudioContext& audioContext,
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
) :
CWallpaper (video, context, audioContext, scalingMode, clampMode) {
CWallpaper (wallpaper, context, audioContext, scalingMode, clampMode) {
double volume = this->getContext ().getApp ().getContext ().settings.audio.volume * 100.0 / 128.0;
// create mpv contexts
@ -54,7 +54,7 @@ CVideo::CVideo (
sLog.exception ("Failed to initialize MPV's GL context");
const std::filesystem::path videopath =
this->getVideo ()->getProject ().getContainer ()->resolveRealFile (this->getVideo ()->getFilename ());
this->getVideo ()->getProject ()->getContainer ()->resolveRealFile (this->getVideo ()->getFilename ());
// build the path to the video file
const char* command [] = {"loadfile", videopath.c_str (), nullptr};

2
src/WallpaperEngine/Render/Wallpapers/CVideo.h
View File

@ -11,7 +11,7 @@ namespace WallpaperEngine::Render::Wallpapers {
class CVideo final : public CWallpaper {
public:
CVideo (
const Core::Wallpapers::CVideo* video, CRenderContext& context, CAudioContext& audioContext,
std::shared_ptr<const Core::CWallpaper> video, CRenderContext& context, CAudioContext& audioContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);

6
src/WallpaperEngine/Render/Wallpapers/CWeb.cpp
View File

@ -11,11 +11,11 @@ using namespace WallpaperEngine::WebBrowser;
using namespace WallpaperEngine::WebBrowser::CEF;
CWeb::CWeb (
const Core::Wallpapers::CWeb* web, CRenderContext& context, CAudioContext& audioContext,
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
CWebBrowserContext& browserContext, const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
) :
CWallpaper (web, context, audioContext, scalingMode, clampMode),
CWallpaper (wallpaper, context, audioContext, scalingMode, clampMode),
m_browserContext (browserContext) {
// setup framebuffers
this->setupFramebuffers ();
@ -32,7 +32,7 @@ CWeb::CWeb (
this->m_client = new WebBrowser::CEF::CBrowserClient (m_renderHandler);
// use the custom scheme for the wallpaper's files
const std::string htmlURL =
CWPSchemeHandlerFactory::generateSchemeName(this->getWeb ()->getProject ().getWorkshopId ()) +
CWPSchemeHandlerFactory::generateSchemeName(this->getWeb ()->getProject ()->getWorkshopId ()) +
"://root/" +
this->getWeb()->getFilename ();
this->m_browser =

2
src/WallpaperEngine/Render/Wallpapers/CWeb.h
View File

@ -25,7 +25,7 @@ class CWeb : public CWallpaper
{
public:
CWeb (
const Core::Wallpapers::CWeb* scene, CRenderContext& context, CAudioContext& audioContext,
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
WallpaperEngine::WebBrowser::CWebBrowserContext& browserContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);

8
src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.cpp
View File

@ -9,12 +9,8 @@ using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::WebBrowser::CEF;
CWPSchemeHandler::CWPSchemeHandler(std::shared_ptr<const Core::CProject> project) :
m_project (project),
m_contents (nullptr),
m_filesize (0),
m_mimeType (),
m_offset (0) {
this->m_container = this->m_project->getWallpaper ()->getProject ().getContainer ();
m_project (project) {
this->m_container = this->m_project->getWallpaper ()->getProject ()->getContainer ();
}
bool CWPSchemeHandler::Open(CefRefPtr<CefRequest> request,