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

refactor: update render to use new data model

Browse Source
This commit is contained in:
Almamu 2025-08-13 08:50:34 +02:00
parent 73f716da84
commit 2569960681
101 changed files with 757 additions and 3593 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
CMakeLists.txt
View File

@ -261,9 +261,6 @@ add_executable(
src/WallpaperEngine/Logging/CLog.cpp
src/WallpaperEngine/Logging/CLog.h
src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.cpp
src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.h
src/WallpaperEngine/Application/CApplicationContext.cpp
src/WallpaperEngine/Application/CApplicationContext.h
src/WallpaperEngine/Application/CWallpaperApplication.cpp
@ -361,6 +358,8 @@ add_executable(
src/WallpaperEngine/Render/CRenderContext.cpp
src/WallpaperEngine/Render/CTextureCache.h
src/WallpaperEngine/Render/CTextureCache.cpp
src/WallpaperEngine/Render/CFBOProvider.cpp
src/WallpaperEngine/Render/CFBOProvider.h
src/WallpaperEngine/Render/Helpers/CContextAware.cpp
src/WallpaperEngine/Render/Helpers/CContextAware.h
@ -384,15 +383,11 @@ add_executable(
src/WallpaperEngine/Render/Objects/CImage.cpp
src/WallpaperEngine/Render/Objects/CSound.h
src/WallpaperEngine/Render/Objects/CSound.cpp
src/WallpaperEngine/Render/Objects/CEffect.h
src/WallpaperEngine/Render/Objects/CEffect.cpp
src/WallpaperEngine/Render/CFBO.h
src/WallpaperEngine/Render/CFBO.cpp
src/WallpaperEngine/Render/Objects/Effects/CPass.h
src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
src/WallpaperEngine/Render/Objects/Effects/CMaterial.h
src/WallpaperEngine/Render/Objects/Effects/CMaterial.cpp
src/WallpaperEngine/WebBrowser/CEF/CRenderHandler.cpp
src/WallpaperEngine/WebBrowser/CEF/CRenderHandler.h
@ -421,19 +416,6 @@ add_executable(
src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
src/WallpaperEngine/Core/CProject.cpp
src/WallpaperEngine/Core/CProject.h
src/WallpaperEngine/Core/CWallpaper.cpp
src/WallpaperEngine/Core/CWallpaper.h
src/WallpaperEngine/Core/Wallpapers/CScene.cpp
src/WallpaperEngine/Core/Wallpapers/CScene.h
src/WallpaperEngine/Core/Wallpapers/CVideo.cpp
src/WallpaperEngine/Core/Wallpapers/CVideo.h
src/WallpaperEngine/Core/Wallpapers/CWeb.cpp
src/WallpaperEngine/Core/Wallpapers/CWeb.h
src/WallpaperEngine/Core/CObject.cpp
src/WallpaperEngine/Core/CObject.h
src/WallpaperEngine/Core/Projects/CProperty.h
src/WallpaperEngine/Core/Projects/CProperty.cpp
src/WallpaperEngine/Core/Projects/CPropertyColor.h
@ -447,24 +429,8 @@ add_executable(
src/WallpaperEngine/Core/Projects/CPropertyText.h
src/WallpaperEngine/Core/Projects/CPropertyText.cpp
src/WallpaperEngine/Core/Scenes/CCamera.cpp
src/WallpaperEngine/Core/Scenes/CCamera.h
src/WallpaperEngine/Core/Scenes/CProjection.cpp
src/WallpaperEngine/Core/Scenes/CProjection.h
src/WallpaperEngine/Core/Objects/CImage.cpp
src/WallpaperEngine/Core/Objects/CImage.h
src/WallpaperEngine/Core/Objects/CSound.cpp
src/WallpaperEngine/Core/Objects/CSound.h
src/WallpaperEngine/Core/Objects/CEffect.cpp
src/WallpaperEngine/Core/Objects/CEffect.h
src/WallpaperEngine/Core/Objects/CParticle.cpp
src/WallpaperEngine/Core/Objects/CParticle.h
src/WallpaperEngine/Core/Objects/Effects/CFBO.h
src/WallpaperEngine/Core/Objects/Effects/CFBO.cpp
src/WallpaperEngine/Core/Objects/Effects/CBind.h
src/WallpaperEngine/Core/Objects/Effects/CBind.cpp
# src/WallpaperEngine/Core/Objects/CParticle.cpp
# src/WallpaperEngine/Core/Objects/CParticle.h
src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h
src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.cpp
@ -481,35 +447,29 @@ add_executable(
src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h
src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.cpp
src/WallpaperEngine/Core/Objects/Particles/CControlPoint.cpp
src/WallpaperEngine/Core/Objects/Particles/CControlPoint.h
src/WallpaperEngine/Core/Objects/Particles/CEmitter.cpp
src/WallpaperEngine/Core/Objects/Particles/CEmitter.h
src/WallpaperEngine/Core/Objects/Particles/CInitializer.cpp
src/WallpaperEngine/Core/Objects/Particles/CInitializer.h
src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.cpp
src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.h
src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.cpp
src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.h
src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.cpp
src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.h
src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.cpp
src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.h
src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.cpp
src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.h
src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.cpp
src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h
src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.cpp
src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h
src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.cpp
src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.h
src/WallpaperEngine/Core/Objects/Images/CMaterial.cpp
src/WallpaperEngine/Core/Objects/Images/CMaterial.h
src/WallpaperEngine/Core/Objects/Images/Materials/CPass.cpp
src/WallpaperEngine/Core/Objects/Images/Materials/CPass.h
# src/WallpaperEngine/Core/Objects/Particles/CControlPoint.cpp
# src/WallpaperEngine/Core/Objects/Particles/CControlPoint.h
# src/WallpaperEngine/Core/Objects/Particles/CEmitter.cpp
# src/WallpaperEngine/Core/Objects/Particles/CEmitter.h
# src/WallpaperEngine/Core/Objects/Particles/CInitializer.cpp
# src/WallpaperEngine/Core/Objects/Particles/CInitializer.h
#
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.cpp
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.h
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.cpp
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.h
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.cpp
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.h
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.cpp
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.h
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.cpp
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.h
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.cpp
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.cpp
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.cpp
# src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.h
src/WallpaperEngine/Data/Model/Types.h
src/WallpaperEngine/Data/Model/Project.h

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

@ -12,6 +12,8 @@
#include "WallpaperEngine/Assets/ITexture.h"
#include "WallpaperEngine/Render/CWallpaperState.h"
#include "WallpaperEngine/Data/Model/Project.h"
namespace WallpaperEngine::Application {
/**
* Application information as parsed off the command line arguments

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

@ -8,13 +8,13 @@
#include "WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.h"
#include "WallpaperEngine/Logging/CLog.h"
#include "WallpaperEngine/Render/CRenderContext.h"
#include "WallpaperEngine/PrettyPrinter/CPrettyPrinter.h"
#include "WallpaperEngine/Core/Wallpapers/CWeb.h"
#include "WallpaperEngine/Render/Drivers/CVideoFactories.h"
#include "WallpaperEngine/Data/Parsers/ProjectParser.h"
#include "WallpaperEngine/Data/Dumpers/StringPrinter.h"
#include "WallpaperEngine/Data/Model/Wallpaper.h"
#if DEMOMODE
#include "recording.h"
#endif /* DEMOMODE */
@ -29,7 +29,9 @@ float g_Time;
float g_TimeLast;
float g_Daytime;
namespace WallpaperEngine::Application {
using namespace WallpaperEngine::Application;
using namespace WallpaperEngine::Data::Model;
CWallpaperApplication::CWallpaperApplication (CApplicationContext& context) :
m_context (context) {
this->loadBackgrounds ();
@ -37,7 +39,8 @@ CWallpaperApplication::CWallpaperApplication (CApplicationContext& context) :
this->setupBrowser();
}
void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedContainer>& container, const std::string& bg) const {
ContainerUniquePtr CWallpaperApplication::setupContainer (const std::string& bg) const {
auto container = std::make_unique <CCombinedContainer> ();
const std::filesystem::path basepath = bg;
container->add (std::make_unique<CDirectory> (basepath));
@ -185,6 +188,8 @@ void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedConta
);
container->add (std::move(virtualContainer));
return container;
}
void CWallpaperApplication::loadBackgrounds () {
@ -204,27 +209,16 @@ void CWallpaperApplication::loadBackgrounds () {
}
}
std::shared_ptr<Core::CProject> CWallpaperApplication::loadBackground (const std::string& bg) {
const auto container = std::make_shared <CCombinedContainer> ();
this->setupContainer (container, bg);
// do the parsing with the new parser first
ProjectUniquePtr CWallpaperApplication::loadBackground (const std::string& bg) {
auto container = this->setupContainer (bg);
auto json = WallpaperEngine::Data::JSON::JSON::parse (container->readFileAsString ("project.json"));
const auto project = WallpaperEngine::Data::Parsers::ProjectParser::parse (json, container);
auto dumper = WallpaperEngine::Data::Dumpers::StringPrinter ();
dumper.printWallpaper (*project->wallpaper);
std::cout << dumper.str () << std::endl;
return Core::CProject::fromFile ("project.json", container);
return WallpaperEngine::Data::Parsers::ProjectParser::parse (json, std::move(container));
}
void CWallpaperApplication::setupPropertiesForProject (const std::shared_ptr<const Core::CProject>& project) {
void CWallpaperApplication::setupPropertiesForProject (const Project& project) {
// show properties if required
for (const auto& [key, cur] : project->getProperties ()) {
for (const auto& [key, cur] : project.properties) {
// update the value of the property
auto override = this->m_context.settings.general.properties.find (key);
@ -241,15 +235,16 @@ void CWallpaperApplication::setupPropertiesForProject (const std::shared_ptr<con
void CWallpaperApplication::setupProperties () {
for (const auto& [background, info] : this->m_backgrounds)
this->setupPropertiesForProject (info);
this->setupPropertiesForProject (*info);
}
void CWallpaperApplication::setupBrowser () {
bool anyWebProject = std::any_of (
this->m_backgrounds.begin (), this->m_backgrounds.end (),
[](const std::pair<const std::string, std::shared_ptr<const Core::CProject>>& pair) -> bool {
return pair.second->getWallpaper()->is<Core::Wallpapers::CWeb> ();
});
[](const std::pair<const std::string, ProjectUniquePtr>& pair) -> bool {
return pair.second->wallpaper->is<Web> ();
}
);
// do not perform any initialization if no web background is present
if (!anyWebProject) {
@ -350,9 +345,12 @@ void CWallpaperApplication::setupOutput () {
void CWallpaperApplication::setupAudio () {
// ensure audioprocessing is required by any background, and we have it enabled
bool audioProcessingRequired = std::any_of (this->m_backgrounds.begin (), this->m_backgrounds.end (), [](const auto& pair) -> bool {
return pair.second->supportsAudioProcessing ();
});
bool audioProcessingRequired = std::any_of (
this->m_backgrounds.begin (), this->m_backgrounds.end (),
[](const std::pair<const std::string, ProjectUniquePtr>& pair) -> bool {
return pair.second->supportsAudioProcessing;
}
);
if (audioProcessingRequired && this->m_context.settings.audio.audioprocessing) {
this->m_audioRecorder = std::make_unique <WallpaperEngine::Audio::Drivers::Recorders::CPulseAudioPlaybackRecorder> ();
@ -382,7 +380,7 @@ void CWallpaperApplication::prepareOutputs () {
m_renderContext->setWallpaper (
background,
WallpaperEngine::Render::CWallpaper::fromWallpaper (
info->getWallpaper (), *m_renderContext, *m_audioContext, m_browserContext.get (),
*info->wallpaper, *m_renderContext, *m_audioContext, m_browserContext.get (),
this->m_context.settings.general.screenScalings [background],
this->m_context.settings.general.screenClamps [background]
)
@ -399,6 +397,8 @@ void CWallpaperApplication::show () {
static struct tm* timeinfo;
if (this->m_context.settings.general.dumpStructure) {
// TODO: REWRITE TO USE THE NEW DUMPER
/*
auto prettyPrinter = PrettyPrinter::CPrettyPrinter ();
for (const auto& [background, info] : this->m_renderContext->getWallpapers ()) {
@ -406,6 +406,7 @@ void CWallpaperApplication::show () {
}
std::cout << prettyPrinter.str () << std::endl;
*/
}
#if DEMOMODE
@ -506,7 +507,7 @@ void CWallpaperApplication::signal (int signal) {
this->m_context.state.general.keepRunning = false;
}
const std::map<std::string, std::shared_ptr<Core::CProject>>& CWallpaperApplication::getBackgrounds () const {
const std::map<std::string, ProjectUniquePtr>& CWallpaperApplication::getBackgrounds () const {
return this->m_backgrounds;
}
@ -517,4 +518,3 @@ CApplicationContext& CWallpaperApplication::getContext () const {
const WallpaperEngine::Render::Drivers::Output::COutput& CWallpaperApplication::getOutput () const {
return this->m_renderContext->getOutput ();
}
} // namespace WallpaperEngine::Application

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

@ -4,8 +4,6 @@
#include "WallpaperEngine/Assets/CCombinedContainer.h"
#include "WallpaperEngine/Core/CProject.h"
#include "WallpaperEngine/Render/CRenderContext.h"
#include "WallpaperEngine/Render/CWallpaper.h"
#include "WallpaperEngine/Render/Drivers/CGLFWOpenGLDriver.h"
@ -17,7 +15,10 @@
#include "WallpaperEngine/Input/CInputContext.h"
#include "WallpaperEngine/WebBrowser/CWebBrowserContext.h"
#include "WallpaperEngine/Data/Model/Types.h"
namespace WallpaperEngine::Application {
using namespace WallpaperEngine::Data::Model;
/**
* Small wrapper class over the actual wallpaper's main application skeleton
*
@ -40,7 +41,7 @@ class CWallpaperApplication {
/**
* @return Maps screens to loaded backgrounds
*/
[[nodiscard]] const std::map<std::string, std::shared_ptr<Core::CProject>>& getBackgrounds () const;
[[nodiscard]] const std::map<std::string, ProjectUniquePtr>& getBackgrounds () const;
/**
* @return The current application context
*/
@ -61,7 +62,7 @@ class CWallpaperApplication {
* @param container
* @param bg
*/
void setupContainer (const std::shared_ptr<CCombinedContainer>& container, const std::string& bg) const;
ContainerUniquePtr setupContainer (const std::string& bg) const;
/**
* Loads projects based off the settings
*/
@ -72,7 +73,7 @@ class CWallpaperApplication {
* @param bg
* @return
*/
[[nodiscard]] std::shared_ptr<Core::CProject> loadBackground (const std::string& bg);
[[nodiscard]] ProjectUniquePtr loadBackground (const std::string& bg);
/**
* Prepares all background's values and updates their properties if required
*/
@ -82,7 +83,7 @@ class CWallpaperApplication {
*
* @param project
*/
void setupPropertiesForProject (const std::shared_ptr<const Core::CProject>& project);
void setupPropertiesForProject (const Project& project);
/**
* Prepares CEF browser to be used
*/
@ -109,7 +110,7 @@ class CWallpaperApplication {
/** The application context that contains the current app settings */
CApplicationContext& m_context;
/** Maps screens to backgrounds */
std::map<std::string, std::shared_ptr <Core::CProject>> m_backgrounds {};
std::map<std::string, ProjectUniquePtr> m_backgrounds {};
std::unique_ptr <WallpaperEngine::Audio::Drivers::Detectors::CAudioPlayingDetector> m_audioDetector = nullptr;
std::unique_ptr <WallpaperEngine::Audio::CAudioContext> m_audioContext = nullptr;

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

@ -1,116 +0,0 @@
#include "CObject.h"
#include <utility>
#include "WallpaperEngine/Core/CProject.h"
#include "WallpaperEngine/Core/Objects/CImage.h"
#include "WallpaperEngine/Core/Objects/CParticle.h"
#include "WallpaperEngine/Core/Objects/CSound.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
#include "WallpaperEngine/Core/Wallpapers/CScene.h"
#include "WallpaperEngine/Assets/CContainer.h"
#include "WallpaperEngine/Logging/CLog.h"
using namespace WallpaperEngine::Core;
using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Core::UserSettings;
CObject::CObject (
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
) :
m_visible (visible),
m_id (id),
m_name (std::move(name)),
m_origin (origin),
m_scale (scale),
m_angles (angles),
m_project (project),
m_dependencies (std::move(dependencies)) {}
const CObject* CObject::fromJSON (
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, *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");
const auto image_it = data.find ("image");
const auto sound_it = data.find ("sound");
const auto particle_it = data.find ("particle");
const auto text_it = data.find ("text");
const auto light_it = data.find ("light");
std::vector<int> dependencies;
std::vector<const Objects::CEffect*> effects;
const CObject* object;
if (dependencies_it != data.end () && dependencies_it->is_array ())
for (const auto& cur : *dependencies_it)
dependencies.push_back (cur);
if (image_it != data.end () && !image_it->is_null ()) {
object = Objects::CImage::fromJSON (
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 (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 (
project, particle_it->get<std::string> (), container, visible, id, name, origin, angles_val, scale, dependencies);
} catch (std::runtime_error&) {
return nullptr;
}
} else if (text_it != data.end () && !text_it->is_null ()) {
/// TODO: XXXHACK -- TO REMOVE WHEN TEXT SUPPORT IS IMPLEMENTED
return nullptr;
} else if (light_it != data.end () && !light_it->is_null ()) {
/// TODO: XXXHACK -- TO REMOVE WHEN LIGHT SUPPORT IS IMPLEMENTED
return nullptr;
} else {
sLog.exception ("Unknown object type detected: ", name);
}
return object;
}
const glm::vec3& CObject::getOrigin () const {
return this->m_origin->getVec3 ();
}
const glm::vec3& CObject::getScale () const {
return this->m_scale->getVec3 ();
}
const glm::vec3& CObject::getAngles () const {
return this->m_angles->getVec3 ();
}
const std::string& CObject::getName () const {
return this->m_name;
}
const std::vector<int>& CObject::getDependencies () const {
return this->m_dependencies;
}
bool CObject::isVisible () const {
return this->m_visible->getBool ();
}
std::shared_ptr <const CProject> CObject::getProject () const {
return this->m_project;
}
int CObject::getId () const {
return this->m_id;
}

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

@ -1,86 +0,0 @@
#pragma once
#include "Core.h"
#include "WallpaperEngine/Assets/CContainer.h"
#include "WallpaperEngine/Core/Objects/CEffect.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingFloat.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingVector3.h"
namespace WallpaperEngine::Core::Wallpapers {
class CScene;
}
namespace WallpaperEngine::Core::Objects {
class CEffect;
}
namespace WallpaperEngine::Core::UserSettings {
class CUserSettingBoolean;
}
namespace WallpaperEngine::Core {
using json = nlohmann::json;
using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Core::UserSettings;
class CObject {
friend class Wallpapers::CScene;
public:
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> ()) {
return static_cast <const T*> (this);
}
throw std::bad_cast ();
}
template <class T> [[nodiscard]] T* as () {
if (is <T> ()) {
return static_cast <T*> (this);
}
throw std::bad_cast ();
}
template <class T> [[nodiscard]] bool is () const {
return typeid (*this) == typeid(T);
}
[[nodiscard]] const std::vector<int>& getDependencies () const;
[[nodiscard]] int getId () const;
[[nodiscard]] const glm::vec3& getOrigin () const;
[[nodiscard]] const glm::vec3& getScale () const;
[[nodiscard]] const glm::vec3& getAngles () const;
[[nodiscard]] const std::string& getName () const;
[[nodiscard]] bool isVisible () const;
[[nodiscard]] std::shared_ptr <const Core::CProject> getProject () const;
protected:
CObject (
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);
virtual ~CObject () = default;
private:
const CUserSettingBoolean* m_visible;
int m_id = 0;
const std::string m_name;
const CUserSettingVector3* m_origin;
const CUserSettingVector3* m_scale;
const CUserSettingVector3* m_angles;
const std::vector<int> m_dependencies;
const std::shared_ptr <const Core::CProject> m_project;
};
} // namespace WallpaperEngine::Core

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

@ -1,118 +0,0 @@
#include <WallpaperEngine/Assets/CContainer.h>
#include <utility>
#include "CProject.h"
#include "WallpaperEngine/Core/Wallpapers/CScene.h"
#include "WallpaperEngine/Core/Wallpapers/CVideo.h"
#include "WallpaperEngine/Core/Wallpapers/CWeb.h"
#include "WallpaperEngine/Logging/CLog.h"
using namespace WallpaperEngine::Core;
using namespace WallpaperEngine::Core::Wallpapers;
using namespace WallpaperEngine::Assets;
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, std::shared_ptr<Projects::CProperty>>& properties
) :
m_workshopid(std::move(workshopid)),
m_title (std::move(title)),
m_type (std::move(type)),
m_container (std::move(container)),
m_properties (properties),
m_supportsaudioprocessing (supportsaudioprocessing) {}
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");
if (dependency != "No dependency") {
sLog.exception ("Project have dependency. They are not supported, quiting");
}
// workshopid is not required, but we have to use it for some identification stuff,
// so using a static, decreasing number should be enough
bool supportsaudioprocessing = false;
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");
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);
if (general != content.end ()) {
supportsaudioprocessing = jsonFindDefault (general, "supportsaudioprocessing", false);
const auto properties_it = general->find ("properties");
if (properties_it != general->end ()) {
for (const auto& cur : properties_it->items ()) {
auto property = Projects::CProperty::fromJSON (cur.value (), cur.key ());
if (property == nullptr) {
continue;
}
properties.emplace (property->getName (), std::move (property));
}
}
}
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--)),
container,
supportsaudioprocessing,
properties
);
if (type == "scene")
wallpaper = CScene::fromFile (file, project, container);
else if (type == "video")
wallpaper = std::make_shared<CVideo> (file, project);
else if (type == "web")
wallpaper = std::make_shared<CWeb> (file, project);
else
sLog.exception ("Unsupported wallpaper type: ", type);
project->setWallpaper (wallpaper);
return project;
}
void CProject::setWallpaper (std::shared_ptr <const CWallpaper> wallpaper) {
this->m_wallpaper = wallpaper;
}
const std::shared_ptr <const CWallpaper> CProject::getWallpaper () const {
return this->m_wallpaper;
}
const std::string& CProject::getTitle () const {
return this->m_title;
}
const std::string& CProject::getType () const {
return this->m_type;
}
const std::map<std::string, std::shared_ptr <Projects::CProperty>>& CProject::getProperties () const {
return this->m_properties;
}
const std::string& CProject::getWorkshopId () const {
return this->m_workshopid;
}
std::shared_ptr<const CContainer> CProject::getContainer () const {
return this->m_container;
}
bool CProject::supportsAudioProcessing () const {
return this->m_supportsaudioprocessing;
}

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

@ -1,53 +0,0 @@
#pragma once
#include <map>
#include <nlohmann/json.hpp>
#include "CWallpaper.h"
#include "WallpaperEngine/Core/Core.h"
#include "WallpaperEngine/Core/Projects/CProperty.h"
#include "WallpaperEngine/Assets/CContainer.h"
namespace WallpaperEngine::Core::Projects {
class CProperty;
}
namespace WallpaperEngine::Core {
using json = nlohmann::json;
using namespace WallpaperEngine::Assets;
class CWallpaper;
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, std::shared_ptr<Projects::CProperty>>& properties);
static std::shared_ptr<CProject> fromFile (const std::string& filename, std::shared_ptr<const CContainer> container);
[[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, std::shared_ptr <Projects::CProperty>>& getProperties () const;
[[nodiscard]] const std::string& getWorkshopId () const;
[[nodiscard]] bool supportsAudioProcessing () const;
[[nodiscard]] std::shared_ptr<const CContainer> getContainer () const;
protected:
void setWallpaper (std::shared_ptr <const CWallpaper> wallpaper);
private:
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;
std::shared_ptr <const CWallpaper> m_wallpaper = nullptr;
std::shared_ptr<const CContainer> m_container = nullptr;
};
} // namespace WallpaperEngine::Core

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

@ -1,12 +0,0 @@
#include "CWallpaper.h"
#include <utility>
using namespace WallpaperEngine::Core;
CWallpaper::CWallpaper (std::shared_ptr <const CProject> project) :
m_project (project) {}
std::shared_ptr <const CProject> CWallpaper::getProject () const {
return this->m_project;
}

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

@ -1,44 +0,0 @@
#pragma once
#include <cassert>
#include <string>
#include "CProject.h"
namespace WallpaperEngine::Core {
class CProject;
class CWallpaper {
public:
template <class T> [[nodiscard]] const T* as () const {
if (is<T> ()) {
return static_cast <const T*> (this);
}
throw std::bad_cast ();
}
template <class T> [[nodiscard]] T* as () {
if (is<T> ()) {
return static_cast <T*> (this);
}
throw std::bad_cast ();
}
template <class T> [[nodiscard]] bool is () const {
return typeid(*this) == typeid(T);
}
std::shared_ptr <const CProject> getProject () const;
protected:
friend class CProject;
explicit CWallpaper (std::shared_ptr <const CProject> project);
virtual ~CWallpaper() = default;
private:
std::shared_ptr <const CProject> m_project;
};
} // namespace WallpaperEngine::Core

39
src/WallpaperEngine/Core/Core.cpp
View File

@ -500,42 +500,3 @@ template const glm::vec4 Core::jsonFindDefault (const nlohmann::json& data, cons
template const glm::ivec2 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::ivec2 defaultValue);
template const glm::ivec3 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::ivec3 defaultValue);
template const glm::ivec4 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::ivec4 defaultValue);
template <typename T> const T* Core::jsonFindUserConfig (
const nlohmann::json::const_iterator& data, const CProject& project, const char* key, typename T::data_type defaultValue
) {
const auto it = data->find (key);
if (it == data->end () || it->type () == nlohmann::detail::value_t::null)
return T::fromScalar (defaultValue);
return T::fromJSON (*it, project.getProperties ());
}
template const CUserSettingBoolean* Core::jsonFindUserConfig (
const nlohmann::json::const_iterator& data, const CProject& project, const char* key,
CUserSettingBoolean::data_type defaultValue);
template const CUserSettingVector3* Core::jsonFindUserConfig (
const nlohmann::json::const_iterator& data, const CProject& project, const char* key,
CUserSettingVector3::data_type defaultValue);
template const CUserSettingFloat* Core::jsonFindUserConfig (
const nlohmann::json::const_iterator& data, const CProject& project, const char* key,
CUserSettingFloat::data_type defaultValue);
template <typename T> const T* Core::jsonFindUserConfig (
const nlohmann::json& data, const CProject& project, const char* key, typename T::data_type defaultValue
) {
const auto it = data.find (key);
if (it == data.end () || it->type () == nlohmann::detail::value_t::null)
return T::fromScalar (defaultValue);
return T::fromJSON (*it, project.getProperties ());
}
template const CUserSettingBoolean* Core::jsonFindUserConfig (
const nlohmann::json& data, const CProject& project, const char* key, CUserSettingBoolean::data_type defaultValue);
template const CUserSettingVector3* Core::jsonFindUserConfig (
const nlohmann::json& data, const CProject& project, const char* key, CUserSettingVector3::data_type defaultValue);
template const CUserSettingFloat* Core::jsonFindUserConfig (
const nlohmann::json& data, const CProject& project, const char* key, CUserSettingFloat::data_type defaultValue);

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

@ -1,6 +1,5 @@
#pragma once
#include "CProject.h"
#include <glm/mat4x4.hpp>
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
@ -44,8 +43,4 @@ template <typename T> const T jsonFindDefault (
const nlohmann::json::const_iterator& data, const char* key, const T defaultValue);
template <typename T> const T jsonFindDefault (
const nlohmann::json& data, const char* key, const T defaultValue);
template <typename T> const T* jsonFindUserConfig (
const nlohmann::json::const_iterator& data, const CProject& project, const char* key, typename T::data_type defaultValue);
template <typename T> const T* jsonFindUserConfig (
const nlohmann::json& data, const CProject& project, const char* key, typename T::data_type defaultValue);
} // namespace WallpaperEngine::Core

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

@ -1,319 +0,0 @@
#include "CEffect.h"
#include <utility>
#include "WallpaperEngine/Core/CProject.h"
#include "WallpaperEngine/Core/Objects/CImage.h"
#include "WallpaperEngine/Core/Objects/Images/Materials/CPass.h"
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h"
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h"
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h"
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h"
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h"
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
#include "WallpaperEngine/Logging/CLog.h"
using namespace WallpaperEngine;
using namespace WallpaperEngine::Core::Objects;
using namespace WallpaperEngine::Core::UserSettings;
CEffect::CEffect (
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)),
m_description (std::move(description)),
m_group (std::move(group)),
m_preview (std::move(preview)),
m_visible (visible),
m_dependencies (std::move(dependencies)),
m_fbos (std::move(fbos)),
m_project (project),
m_materials (std::move(materials)) {}
const CEffect* CEffect::fromJSON (
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");
json content = json::parse (container->readFileAsString(file));
const auto effectName = jsonFindRequired <std::string> (content, "name", "Effect must have a name");
const auto passes_it = jsonFindRequired (content, "passes", "Effect must have a pass list");
const auto fbos_it = content.find ("fbos");
// info to override in the pass information, used by material generation
std::map<int, Images::CMaterial::OverrideInfo> overrides;
std::vector<const Effects::CFBO*> fbos;
if (fbos_it != content.end ())
fbos = CEffect::fbosFromJSON (fbos_it);
if (effectpasses_it != data.end ()) {
overrides = overridesFromJSON (effectpasses_it, material, project);
}
return new CEffect (
effectName,
jsonFindDefault<std::string> (content, "description", ""),
jsonFindRequired <std::string> (content, "group", "Effect must have a group"),
jsonFindDefault<std::string> (content, "preview", ""),
project,
visible,
dependenciesFromJSON (jsonFindRequired (content, "dependencies", "")),
fbos,
materialsFromJSON (passes_it, effectName, container, overrides)
);
}
std::map<std::string, int> CEffect::combosFromJSON (const json::const_iterator& combos_it) {
std::map<std::string, int> combos;
for (const auto& cur : combos_it->items ()) {
auto uppercase = std::string (cur.key ());
std::transform (uppercase.begin (), uppercase.end (), uppercase.begin (), ::toupper);
combos.emplace (uppercase, cur.value ());
}
return combos;
}
std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> CEffect::constantsFromJSON (
const json::const_iterator& constants_it, std::shared_ptr <const Core::CProject> project
) {
std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constants;
for (auto& cur : constants_it->items ()) {
auto val = cur.value ();
Effects::Constants::CShaderConstant* constant = nullptr;
// if the constant is an object, that means the constant has some extra information
// for the UI, take the value, which is what we need
if (cur.value ().is_object ()) {
auto user = cur.value ().find ("user");
auto it = cur.value ().find ("value");
if (user == cur.value ().end () && it == cur.value ().end ()) {
sLog.error (R"(Found object for shader constant without "value" and "user" setting)");
continue;
}
if (user != cur.value ().end () && user->is_string ()) {
// look for a property with the correct name
const auto& properties = project->getProperties ();
const auto property = properties.find (*user);
if (property != properties.end ()) {
constant = new Effects::Constants::CShaderConstantProperty (property->second);
} else {
sLog.error ("Shader constant pointing to non-existant project property: ", user->get <std::string> ());
val = it.value ();
}
} else {
val = it.value ();
}
}
// TODO: REFACTOR THIS SO IT'S NOT SO DEEP INTO THE FUNCTION
if (constant == nullptr) {
if (val.is_number_float ()) {
constant = new Effects::Constants::CShaderConstantFloat (val.get<float> ());
} else if (val.is_number_integer ()) {
constant = new Effects::Constants::CShaderConstantInteger (val.get<int> ());
} else if (val.is_string ()) {
// count the amount of spaces to determine which type of vector we have
std::string value = val;
size_t spaces =
std::count_if (value.begin (), value.end (), [&] (const auto& item) { return item == ' '; });
if (spaces == 1) {
constant =
new Effects::Constants::CShaderConstantVector2 (WallpaperEngine::Core::aToVector2 (value));
} else if (spaces == 2) {
constant =
new Effects::Constants::CShaderConstantVector3 (WallpaperEngine::Core::aToVector3 (value));
} else if (spaces == 3) {
constant =
new Effects::Constants::CShaderConstantVector4 (WallpaperEngine::Core::aToVector4 (value));
} else {
sLog.exception ("unknown shader constant type ", value);
}
} else {
sLog.exception ("unknown shader constant type ", val);
}
}
constants.emplace (cur.key (), constant);
}
return constants;
}
std::vector<const Effects::CFBO*> CEffect::fbosFromJSON (const json::const_iterator& fbos_it) {
std::vector<const Effects::CFBO*> fbos;
for (const auto& cur : (*fbos_it))
fbos.push_back (Effects::CFBO::fromJSON (cur));
return fbos;
}
std::vector<std::string> CEffect::dependenciesFromJSON (const json::const_iterator& dependencies_it) {
std::vector<std::string> dependencies;
for (const auto& cur : (*dependencies_it))
dependencies.push_back (cur);
return dependencies;
}
std::vector<const Images::CMaterial*> CEffect::materialsFromJSON (
const json::const_iterator& passes_it, const std::string& name, const std::shared_ptr<const CContainer>& container,
std::map<int, Images::CMaterial::OverrideInfo> overrides
) {
std::vector<const Images::CMaterial*> materials;
int materialNumber = -1;
for (const auto& cur : (*passes_it)) {
++materialNumber;
const auto materialfile = cur.find ("material");
const auto target_it = cur.find ("target");
const auto bind_it = cur.find ("bind");
const auto command_it = cur.find ("command");
const auto compose_it = cur.find ("compose");
const Images::CMaterial* material = nullptr;
if (compose_it != cur.end ()) {
sLog.error ("Composing materials is not supported yet...");
}
if (materialfile != cur.end ()) {
std::map<int, const Effects::CBind*> textureBindings;
if (bind_it != cur.end ()) {
for (const auto& bindCur : (*bind_it)) {
const auto* bind = Effects::CBind::fromJSON (bindCur);
textureBindings.emplace (bind->getIndex (), bind);
}
}
const Images::CMaterial::OverrideInfo* overrideInfo = nullptr;
const auto overrideIt = overrides.find (materialNumber);
if (overrideIt != overrides.end ()) {
overrideInfo = &overrideIt->second;
}
if (target_it == cur.end ()) {
material = Images::CMaterial::fromFile (
materialfile->get<std::string> (), container, false, textureBindings, overrideInfo);
} else {
material = Images::CMaterial::fromFile (
materialfile->get<std::string> (), *target_it, container, false, textureBindings, overrideInfo);
}
} else if (command_it != cur.end ()) {
material = Images::CMaterial::fromCommand (cur);
} else {
sLog.exception ("Material without command nor material file: ", name, " (", materialNumber,")");
}
materials.push_back (material);
}
return materials;
}
std::map<int, Images::CMaterial::OverrideInfo> CEffect::overridesFromJSON (
const json::const_iterator& passes_it, const Images::CMaterial* material,
std::shared_ptr <const Core::CProject> project
) {
std::map<int, Images::CMaterial::OverrideInfo> result;
int materialNumber = -1;
for (const auto& cur : (*passes_it)) {
++materialNumber;
auto constants_it = cur.find ("constantshadervalues");
auto combos_it = cur.find ("combos");
auto textures_it = cur.find ("textures");
Images::CMaterial::OverrideInfo override;
int textureNumber = -1;
if (combos_it != cur.end ()) {
override.combos = CEffect::combosFromJSON (combos_it);
}
if (constants_it != cur.end ()) {
override.constants = CEffect::constantsFromJSON (constants_it, project);
}
if (textures_it != cur.end ()) {
// TODO: MAYBE CHANGE THIS TO BE SOMEWHERE ELSE? THIS IS REALLY MODIFYING THE DATA
// BUT IT'S USEFUL TO HAVE TO SIMPLIFY RENDERING CODE
for (const auto& texture : (*textures_it)) {
++textureNumber;
std::string name;
if (texture.is_null () && textureNumber > 0) {
continue;
}
if (textureNumber == 0) {
auto passTextures = (*material->getPasses ().begin ())->getTextures ();
if (passTextures.empty()) {
continue;
} else {
name = passTextures.begin ()->second;
}
} else {
name = texture;
}
override.textures.emplace (textureNumber, name);
}
}
result.emplace (materialNumber, override);
}
return result;
}
const std::vector<std::string>& CEffect::getDependencies () const {
return this->m_dependencies;
}
const std::vector<const Images::CMaterial*>& CEffect::getMaterials () const {
return this->m_materials;
}
const std::vector<const Effects::CFBO*>& CEffect::getFbos () const {
return this->m_fbos;
}
const Core::CProject& CEffect::getProject () const {
return *this->m_project;
}
bool CEffect::isVisible () const {
return this->m_visible->getBool ();
}
const Effects::CFBO* CEffect::findFBO (const std::string& name) {
for (const auto& cur : this->m_fbos)
if (cur->getName () == name)
return cur;
sLog.exception ("cannot find fbo ", name);
}

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

@ -1,102 +0,0 @@
#pragma once
#include "WallpaperEngine/Assets/CContainer.h"
#include "WallpaperEngine/Core/CObject.h"
#include "WallpaperEngine/Core/Core.h"
#include "WallpaperEngine/Core/Objects/Effects/CFBO.h"
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
#include "WallpaperEngine/Core/Objects/Images/CMaterial.h"
namespace WallpaperEngine::Core {
class CObject;
class CProject;
}
namespace WallpaperEngine::Core::UserSettings {
class CUserSettingBoolean;
}
namespace WallpaperEngine::Core::Objects {
using json = nlohmann::json;
using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Core::UserSettings;
/**
* Represents an effect applied to background objects
*/
class CEffect {
public:
CEffect (
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, 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
*/
[[nodiscard]] const std::vector<std::string>& getDependencies () const;
/**
* @return List of materials the effect applies
*/
[[nodiscard]] const std::vector<const Images::CMaterial*>& getMaterials () const;
/**
* @return The list of FBOs to be used for this effect
*/
[[nodiscard]] const std::vector<const Effects::CFBO*>& getFbos () const;
/**
* @return If the effect is visible or not
*/
[[nodiscard]] bool isVisible () const;
/**
* @return The project this effect is part of
*/
[[nodiscard]] const CProject& getProject () const;
/**
* Searches the FBOs list for the given FBO
*
* @param name The FBO to search for
*
* @return
*/
const Effects::CFBO* findFBO (const std::string& name);
protected:
static std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constantsFromJSON (
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);
static std::vector<const Images::CMaterial*> materialsFromJSON (
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,
std::shared_ptr <const Core::CProject> project);
private:
/** Effect's name */
const std::string m_name;
/** Effect's description used in the UI */
const std::string m_description;
/** Effect's group used in the UI */
const std::string m_group;
/** A project that previews the given effect, used in the UI */
const std::string m_preview;
/** If the effect is visible or not */
const UserSettings::CUserSettingBoolean* m_visible;
/** Project this effect is part of */
std::shared_ptr <const Core::CProject> m_project;
/** List of dependencies for the effect */
const std::vector<std::string> m_dependencies;
/** List of materials the effect applies */
const std::vector<const Images::CMaterial*> m_materials;
/** List of FBOs required for this effect */
const std::vector<const Effects::CFBO*> m_fbos;
};
} // namespace WallpaperEngine::Core::Objects

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

@ -1,142 +0,0 @@
#include "CImage.h"
#include <utility>
#include "WallpaperEngine/Core/Objects/Images/CMaterial.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingFloat.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingVector3.h"
#include "WallpaperEngine/Core/Wallpapers/CScene.h"
using namespace WallpaperEngine::Core::Objects;
using namespace WallpaperEngine::Core::UserSettings;
CImage::CImage (
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 (project, visible, id, std::move(name), origin, scale, angles, std::move(dependencies)),
m_size (size),
m_parallaxDepth (parallaxDepth),
m_material (material),
m_alignment (std::move(alignment)),
m_alpha (alpha),
m_brightness (brightness),
m_color (color),
m_colorBlendMode (colorBlendMode),
m_fullscreen (fullscreen),
m_passthrough (passthrough),
m_autosize (autosize),
m_effects (std::move(effects)) {}
const WallpaperEngine::Core::CObject* CImage::fromJSON (
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
) {
const auto image = jsonFindRequired <std::string>(data, "image", "Image must have an image");
std::vector<const Objects::CEffect*> effects;
json content = json::parse (container->readFileAsString (image));
const auto material = Images::CMaterial::fromFile (
jsonFindRequired<std::string> (content, "material", "Image must have a material"),
container,
jsonFindDefault (content, "solidlayer", false)
);
if (effects_it != data.end () && effects_it->is_array ()) {
for (auto& cur : *effects_it) {
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
// TODO: THAT MIGHT INCREASE COMPLEXITY THO...
// TODO: ESPECIALLY IF THAT CHANGES RENDERING OF PASSES/IMAGES
// TODO: DECISIONS, DECISIONS, DECISIONS...
if (!effectVisible->getBool ())
continue;
effects.push_back (
Objects::CEffect::fromJSON (
cur, effectVisible, project, material, container
)
);
}
}
return new CImage (
project,
material,
visible,
id,
std::move(name),
origin,
scale,
angles,
jsonFindDefault<glm::vec2> (data, "size", glm::vec2 (0.0, 0.0)),
jsonFindDefault<std::string> (data, "alignment", "center"),
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)),
jsonFindDefault<bool> (content, "fullscreen", false),
jsonFindDefault<bool> (content, "passthrough", false),
jsonFindDefault<bool> (content, "autosize", false),
effects,
std::move(dependencies)
);
}
const Images::CMaterial* CImage::getMaterial () const {
return this->m_material;
}
const glm::vec2& CImage::getSize () const {
return this->m_size;
}
const std::string& CImage::getAlignment () const {
return this->m_alignment;
}
float CImage::getAlpha () const {
return this->m_alpha->getFloat ();
}
const glm::vec3& CImage::getColor () const {
return this->m_color->getVec3 ();
}
float CImage::getBrightness () const {
return this->m_brightness;
}
uint32_t CImage::getColorBlendMode () const {
return this->m_colorBlendMode;
}
const glm::vec2& CImage::getParallaxDepth () const {
return this->m_parallaxDepth;
}
bool CImage::isFullscreen () const {
return this->m_fullscreen;
}
bool CImage::isPassthrough () const {
return this->m_passthrough;
}
bool CImage::isAutosize () const {
return this->m_autosize;
}
const std::vector<const CEffect*>& CImage::getEffects () const {
return this->m_effects;
}

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

@ -1,122 +0,0 @@
#pragma once
#include <vector>
#include "WallpaperEngine/Core/Objects/Images/CMaterial.h"
#include "WallpaperEngine/Core/CObject.h"
#include "WallpaperEngine/Core/Core.h"
#include "WallpaperEngine/Assets/CContainer.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingFloat.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingVector3.h"
namespace WallpaperEngine::Core::Wallpapers {
class CScene;
}
namespace WallpaperEngine::Core::Objects {
using json = nlohmann::json;
using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Core::UserSettings;
/**
* Represents an image in a background
*/
class CImage : public CObject {
friend class CObject;
public:
static const CObject* fromJSON (
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
*/
[[nodiscard]] const Images::CMaterial* getMaterial () const;
/**
* @return The size of the image
*/
[[nodiscard]] const glm::vec2& getSize () const;
/**
* @return The type of alignment to use for image positioning
*/
[[nodiscard]] const std::string& getAlignment () const;
/**
* @return The alpha value for the image's rendering
*/
[[nodiscard]] float getAlpha () const;
/**
* @return The color to use for the image
*/
[[nodiscard]] const glm::vec3& getColor () const;
/**
* @return The brightness to use for the image
*/
[[nodiscard]] float getBrightness () const;
/**
* @return The color blending mode to be used, special value for shaders
*/
[[nodiscard]] uint32_t getColorBlendMode () const;
/**
* @return Parallax depth of the image
*/
[[nodiscard]] const glm::vec2& getParallaxDepth () const;
/**
* @return If the image is fullscreen or not
*/
[[nodiscard]] bool isFullscreen () const;
/**
* @return If the image is passthrough or not
*/
[[nodiscard]] bool isPassthrough () const;
/**
* @return If the image is autosized or not
*/
[[nodiscard]] bool isAutosize () const;
/**
* @return All of the effects applied to this image
*/
[[nodiscard]] const std::vector<const Objects::CEffect*>& getEffects () const;
protected:
CImage (
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 */
const glm::vec2 m_size;
/** Parallax depth */
const glm::vec2 m_parallaxDepth;
/** Base material for the image */
const Images::CMaterial* m_material;
/** What type of alignment to use for the image's position */
const std::string m_alignment;
/** The alpha value for the image */
const CUserSettingFloat* m_alpha;
/** The brightness for the image */
float m_brightness;
/** The color to use for the image */
const CUserSettingVector3* m_color;
/** The color blending mode used for the image, special value for shaders */
const uint32_t m_colorBlendMode;
/** Override for effects */
const std::vector<const Objects::CEffect*> m_effects;
/** If the image is fullscreen or not */
bool m_fullscreen = false;
/** If the image is passthrough or not */
bool m_passthrough = false;
/** If the image's size should be automatically determined */
bool m_autosize = false;
};
} // namespace WallpaperEngine::Core::Objects

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

@ -1,53 +0,0 @@
#include "CSound.h"
#include <utility>
#include "WallpaperEngine/Core/CObject.h"
#include "WallpaperEngine/Logging/CLog.h"
using namespace WallpaperEngine::Core::Objects;
CSound::CSound (
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 (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 (
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
std::vector<std::string> sounds;
const auto sound_it = jsonFindRequired (data, "sound", "Sound information not present");
if (!sound_it->is_array ())
sLog.exception ("Expected sound list on element ", name);
for (const auto& cur : (*sound_it))
sounds.push_back (cur);
return new CSound (
project,
visible,
id,
name,
origin,
scale,
angles,
jsonFindDefault<std::string> (data, "playbackmode", "") == "loop",
sounds,
std::move(dependencies)
);
}
const std::vector<std::string>& CSound::getSounds () const {
return this->m_sounds;
}
bool CSound::isRepeat () const {
return this->m_repeat;
}

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

@ -1,48 +0,0 @@
#pragma once
#include "WallpaperEngine/Core/CObject.h"
#include "WallpaperEngine/Core/Core.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
namespace WallpaperEngine::Core::Wallpapers {
class CScene;
}
namespace WallpaperEngine::Core::Objects {
using json = nlohmann::json;
using namespace WallpaperEngine::Core::UserSettings;
/**
* Represents a sound played while the background is working
*/
class CSound : public CObject {
friend class CObject;
public:
static const CObject* fromJSON (
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);
/**
* @return The list of sounds to play
*/
[[nodiscard]] const std::vector<std::string>& getSounds () const;
/**
* @return If the sound should repeat or not
*/
[[nodiscard]] bool isRepeat () const;
protected:
CSound (
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);
private:
/** If the sounds should repeat or not */
bool m_repeat = false;
/** The list of sounds to play */
std::vector<std::string> m_sounds = {};
};
} // namespace WallpaperEngine::Core::Objects

24
src/WallpaperEngine/Core/Objects/Effects/CBind.cpp
View File

@ -1,24 +0,0 @@
#include "CBind.h"
#include <utility>
using namespace WallpaperEngine::Core::Objects::Effects;
CBind::CBind (std::string name, uint32_t index) :
m_name (std::move(name)),
m_index (index) {}
const CBind* CBind::fromJSON (const json& data) {
return new CBind (
jsonFindRequired <std::string> (data, "name", "bind must have texture name"),
jsonFindRequired <uint32_t> (data, "index", "bind must have index")
);
}
const std::string& CBind::getName () const {
return this->m_name;
}
const uint32_t& CBind::getIndex () const {
return this->m_index;
}

43
src/WallpaperEngine/Core/Objects/Effects/CBind.h
View File

@ -1,43 +0,0 @@
#pragma once
#include <string>
#include "WallpaperEngine/Core/Core.h"
namespace WallpaperEngine::Core::Objects::Effects {
using json = nlohmann::json;
/**
* Material's bind information, describes for passes what textures to bind
* in what positions for shaders. Used to override the textures specified inside
* the object's passes
*/
class CBind {
public:
/**
* Parses bind information off the given json data
*
* @param data
* @return
*/
static const CBind* fromJSON (const json& data);
/**
* @return The texture name, previous to use the one already specified by the object's passes
*/
[[nodiscard]] const std::string& getName () const;
/**
* @return The texture index to replace
*/
[[nodiscard]] const uint32_t& getIndex () const;
protected:
CBind (std::string name, uint32_t index);
private:
/** The texture's name */
const std::string m_name;
/** The texture index to replace */
const uint32_t m_index;
};
} // namespace WallpaperEngine::Core::Objects::Effects

31
src/WallpaperEngine/Core/Objects/Effects/CFBO.cpp
View File

@ -1,31 +0,0 @@
#include "CFBO.h"
#include <utility>
using namespace WallpaperEngine::Core;
using namespace WallpaperEngine::Core::Objects::Effects;
CFBO::CFBO (std::string name, float scale, std::string format) :
m_name (std::move(name)),
m_scale (scale),
m_format (std::move(format)) {}
const CFBO* CFBO::fromJSON (const json& data) {
return new CFBO (
jsonFindRequired <std::string> (data, "name", "Name for an FBO is required"),
jsonFindDefault <float> (data, "scale", 1.0),
jsonFindDefault <std::string> (data, "format", "")
);
}
const std::string& CFBO::getName () const {
return this->m_name;
}
const float& CFBO::getScale () const {
return this->m_scale;
}
const std::string& CFBO::getFormat () const {
return this->m_format;
}

44
src/WallpaperEngine/Core/Objects/Effects/CFBO.h
View File

@ -1,44 +0,0 @@
#pragma once
#include "WallpaperEngine/Core/Core.h"
#include <nlohmann/json.hpp>
#include <string>
namespace WallpaperEngine::Core::Objects::Effects {
using json = nlohmann::json;
/**
* FBO = Frame Buffer Object
*
* Represents a framebuffer object used in objects with multiple effects or render passes
*/
class CFBO {
public:
static const CFBO* fromJSON (const json& data);
/**
* @return The FBO name used to identify it in the background's files
*/
[[nodiscard]] const std::string& getName () const;
/**
* @return The scale factor of the FBO
*/
[[nodiscard]] const float& getScale () const;
/**
* @return The FBO's format for the render
*/
[[nodiscard]] const std::string& getFormat () const;
protected:
CFBO (std::string name, float scale, std::string format);
private:
/** The name of the FBO */
const std::string m_name;
/** The scale factor of the FBO */
const float m_scale;
/** The FBO's format for the render */
const std::string m_format;
};
} // namespace WallpaperEngine::Core::Objects::Effects

120
src/WallpaperEngine/Core/Objects/Images/CMaterial.cpp
View File

@ -1,120 +0,0 @@
#include "CMaterial.h"
#include "WallpaperEngine/Core/Objects/Images/Materials/CPass.h"
#include "WallpaperEngine/Logging/CLog.h"
#include <nlohmann/json.hpp>
#include <utility>
using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Core::Objects;
using namespace WallpaperEngine::Core::Objects::Images;
CMaterial::CMaterial (
std::string name, bool solidlayer, std::map<int, const Effects::CBind*> textureBindings,
std::vector<const Materials::CPass*> passes
) :
m_name (std::move(name)),
m_textureBindings (std::move(textureBindings)),
m_passes (std::move(passes)),
m_solidlayer (solidlayer) {}
CMaterial::CMaterial (
std::string name, std::string target, bool solidlayer,
std::map<int, const Effects::CBind*> textureBindings, std::vector<const Materials::CPass*> passes
) :
m_name (std::move(name)),
m_target (std::move(target)),
m_textureBindings (std::move(textureBindings)),
m_passes (std::move(passes)),
m_solidlayer (solidlayer) {}
const CMaterial* CMaterial::fromFile (
const std::filesystem::path& filename, const std::shared_ptr<const CContainer>& container, bool solidlayer,
std::map<int, const Effects::CBind*> textureBindings, const OverrideInfo* overrides
) {
return fromJSON (filename, json::parse (container->readFileAsString (filename)), solidlayer, std::move(textureBindings), overrides);
}
const CMaterial* CMaterial::fromFile (
const std::filesystem::path& filename, const std::string& target, const std::shared_ptr<const CContainer>& container, bool solidlayer,
std::map<int, const Effects::CBind*> textureBindings, const OverrideInfo* overrides
) {
return fromJSON (filename, json::parse (container->readFileAsString (filename)), target, solidlayer, std::move(textureBindings), overrides);
}
const CMaterial* CMaterial::fromJSON (
const std::string& name, const json& data, const std::string& target, bool solidlayer,
std::map<int, const Effects::CBind*> textureBindings, const OverrideInfo* overrides
) {
const auto passes_it = jsonFindRequired (data, "passes", "Material must have at least one pass");
std::vector<const Materials::CPass*> passes;
for (const auto& cur : (*passes_it))
passes.push_back (Materials::CPass::fromJSON (cur, overrides));
return new CMaterial (name, target, solidlayer, std::move(textureBindings), passes);
}
const CMaterial* CMaterial::fromJSON (
const std::string& name, const json& data, bool solidlayer, std::map<int, const Effects::CBind*> textureBindings,
const OverrideInfo* overrides
) {
const auto passes_it = jsonFindRequired (data, "passes", "Material must have at least one pass");
std::vector<const Materials::CPass*> passes;
for (const auto& cur : (*passes_it))
passes.push_back (Materials::CPass::fromJSON (cur, overrides));
return new CMaterial (name, solidlayer, std::move(textureBindings), passes);
}
const CMaterial* CMaterial::fromCommand (const json& data) {
const std::string& command = jsonFindRequired <std::string> (data, "command", "Command material must have a command");
const std::string& target = jsonFindRequired <std::string> (data, "target", "Command material must have a target");
const std::string& source = jsonFindRequired <std::string> (data, "source", "Command material must have a source");
std::vector<const Materials::CPass*> passes;
if (command == "copy") {
passes.push_back (
Materials::CPass::fromJSON ({
{"blending", "normal"},
{"cullmode", "nocull"},
{"depthtest", "disabled"},
{"depthwrite", "disabled"},
{"shader", "commands/copy"},
{"textures", json::array ({source, target})}
}, nullptr)
);
} else if (command == "swap") {
// TODO: HOW TO IMPLEMENT THIS ONE?
sLog.exception ("Command material swap not implemented yet");
} else {
sLog.exception ("Unknown command: ", command);
}
return new CMaterial (command, false, {}, passes);
}
const std::vector<const Materials::CPass*>& CMaterial::getPasses () const {
return this->m_passes;
}
const std::map<int, const Effects::CBind*>& CMaterial::getTextureBinds () const {
return this->m_textureBindings;
}
const std::string& CMaterial::getTarget () const {
return this->m_target;
}
const std::string& CMaterial::getName () const {
return this->m_name;
}
bool CMaterial::hasTarget () const {
return !this->m_target.empty ();
}
bool CMaterial::isSolidLayer () const {
return this->m_solidlayer;
}

89
src/WallpaperEngine/Core/Objects/Images/CMaterial.h
View File

@ -1,89 +0,0 @@
#pragma once
#include "WallpaperEngine/Core/Objects/Effects/CBind.h"
#include "WallpaperEngine/Assets/CContainer.h"
#include "WallpaperEngine/Core/Core.h"
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
namespace WallpaperEngine::Core::Objects::Images::Materials {
class CPass;
}
namespace WallpaperEngine::Core::Objects::Images {
using json = nlohmann::json;
using namespace WallpaperEngine::Assets;
/**
* Represents a material in use in the background
*/
class CMaterial {
public:
struct OverrideInfo {
std::map<std::string, int> combos;
std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constants;
std::map<int, std::string> textures;
};
static const CMaterial* fromFile (
const std::filesystem::path& filename, const std::shared_ptr<const CContainer>& container, bool solidlayer = false,
std::map<int, const Effects::CBind*> textureBindings = {}, const OverrideInfo* overrides = nullptr);
static const CMaterial* fromFile (
const std::filesystem::path& filename, const std::string& target, const std::shared_ptr<const CContainer>& container,
bool solidlayer = false, std::map<int, const Effects::CBind*> textureBindings = {},
const OverrideInfo* overrides = nullptr);
static const CMaterial* fromJSON (
const std::string& name, const json& data, bool solidlayer = false,
std::map<int, const Effects::CBind*> textureBindings = {}, const OverrideInfo* overrides = nullptr);
static const CMaterial* fromJSON (
const std::string& name, const json& data, const std::string& target, bool solidlayer = false,
std::map<int, const Effects::CBind*> textureBindings = {}, const OverrideInfo* overrides = nullptr);
static const CMaterial* fromCommand (const json& data);
/**
* @return All the rendering passes that happen for this material
*/
[[nodiscard]] const std::vector<const Materials::CPass*>& getPasses () const;
/**
* @return The textures that have to be bound while rendering the material.
* These act as an override of the textures specified by the parent effect
*/
[[nodiscard]] const std::map<int, const Effects::CBind*>& getTextureBinds () const;
/**
* @return The materials destination (fbo) if required
*/
[[nodiscard]] const std::string& getTarget () const;
/**
* @return Indicates if this material has a specific destination (fbo) while rendering
*/
[[nodiscard]] bool hasTarget () const;
/**
* @return The name of the material
*/
[[nodiscard]] const std::string& getName () const;
/**
* @return If this material is a solidlayer or not
*/
[[nodiscard]] bool isSolidLayer () const;
protected:
CMaterial (
std::string name, bool solidlayer, std::map<int, const Effects::CBind*> textureBindings,
std::vector<const Materials::CPass*> passes);
CMaterial (
std::string name, std::string target, bool solidlayer, std::map<int, const Effects::CBind*> textureBindings,
std::vector<const Materials::CPass*> passes);
private:
/** All the shader passes required to render this material */
const std::vector<const Materials::CPass*> m_passes;
/** List of texture bind overrides to use for this material */
const std::map<int, const Effects::CBind*> m_textureBindings;
/** The FBO target to render to (if any) */
const std::string m_target;
/** The material's name */
const std::string m_name;
/** If this material is a solid layer or not */
const bool m_solidlayer;
};
} // namespace WallpaperEngine::Core::Objects::Images

105
src/WallpaperEngine/Core/Objects/Images/Materials/CPass.cpp
View File

@ -1,105 +0,0 @@
#include "CPass.h"
#include "WallpaperEngine/Logging/CLog.h"
#include <utility>
using namespace WallpaperEngine::Core::Objects::Effects::Constants;
using namespace WallpaperEngine::Core::Objects::Images::Materials;
CPass::CPass (std::string blending, std::string cullmode, std::string depthtest, std::string depthwrite,
std::string shader, std::map<int, std::string> textures, std::map<std::string, int> combos,
std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constants) :
m_blending (std::move(blending)),
m_cullmode (std::move(cullmode)),
m_depthtest (std::move(depthtest)),
m_depthwrite (std::move(depthwrite)),
m_shader (std::move(shader)),
m_textures (std::move(textures)),
m_combos (std::move(combos)),
m_constants (std::move(constants)) {}
const CPass* CPass::fromJSON (const json& data, const CMaterial::OverrideInfo* overrides) {
// TODO: FIGURE OUT DEFAULT BLENDING MODE
const auto textures_it = data.find ("textures");
const auto combos_it = data.find ("combos");
std::map<int, std::string> textures;
std::map<std::string, int> combos;
std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constants;
if (textures_it != data.end ()) {
// TODO: FETCH THIS FROM CImage TO MAKE IT COMPATIBLE WITH OLDER WALLPAPERS
if (!textures_it->is_array ())
sLog.exception ("Material's textures must be a list");
int textureNumber = -1;
for (const auto& cur : (*textures_it))
textures.emplace (++textureNumber, cur.is_null () ? "" : cur);
}
if (combos_it != data.end ()) {
for (const auto& cur : combos_it->items ()) {
if (cur.value ().is_number_integer ()) {
std::string uppercase = std::string (cur.key ());
std::transform (uppercase.begin (), uppercase.end (), uppercase.begin (), ::toupper);
combos.emplace (uppercase, cur.value ());
} else {
sLog.exception ("unexpected non-integer combo on pass");
}
}
}
// apply overrides
if (overrides != nullptr) {
for (const auto& [name, value] : overrides->combos)
combos[name] = value;
for (const auto& [name, value] : overrides->constants)
constants[name] = value;
for (const auto& [id, value] : overrides->textures)
textures[id] = value;
}
return new CPass (
jsonFindDefault<std::string> (data, "blending", "normal"),
jsonFindDefault<std::string> (data, "cullmode", "nocull"),
jsonFindRequired <std::string> (data, "depthtest", "Material pass must have depthtest specified"),
jsonFindRequired <std::string> (data, "depthwrite", "Material pass must have depthwrite specified"),
jsonFindRequired <std::string> (data, "shader", "Material pass must have shader specified"),
textures,
combos,
constants
);
}
const std::map<int, std::string>& CPass::getTextures () const {
return this->m_textures;
}
const std::map<std::string, const CShaderConstant*>& CPass::getConstants () const {
return this->m_constants;
}
const std::map<std::string, int>& CPass::getCombos () const {
return this->m_combos;
}
const std::string& CPass::getShader () const {
return this->m_shader;
}
const std::string& CPass::getBlendingMode () const {
return this->m_blending;
}
const std::string& CPass::getCullingMode () const {
return this->m_cullmode;
}
const std::string& CPass::getDepthTest () const {
return this->m_depthtest;
}
const std::string& CPass::getDepthWrite () const {
return this->m_depthwrite;
}

84
src/WallpaperEngine/Core/Objects/Images/Materials/CPass.h
View File

@ -1,84 +0,0 @@
#pragma once
#include "WallpaperEngine/Core/Core.h"
#include "WallpaperEngine/Core/Objects/Images/CMaterial.h"
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
namespace WallpaperEngine::Core::Objects {
class CEffect;
}
namespace WallpaperEngine::Core::Objects::Images {
class CMaterial;
}
namespace WallpaperEngine::Core::Objects::Images::Materials {
using json = nlohmann::json;
/**
* Represents a shader pass of an object
*/
class CPass {
friend class WallpaperEngine::Core::Objects::CEffect;
public:
static const CPass* fromJSON (const json& data, const CMaterial::OverrideInfo* overrides);
/**
* @return The list of textures to bind while rendering
*/
[[nodiscard]] const std::map<int, std::string>& getTextures () const;
/**
* @return Shader constants that alter how the shader should behave
*/
[[nodiscard]] const std::map<std::string, const Effects::Constants::CShaderConstant*>& getConstants () const;
/**
* @return Shader combos that alter how the shader should behave
*/
[[nodiscard]] const std::map<std::string, int>& getCombos () const;
/**
* @return Shader to be used while rendering the pass
*/
[[nodiscard]] const std::string& getShader () const;
/**
* @return The blending mode to use while rendering
*/
[[nodiscard]] const std::string& getBlendingMode () const;
/**
* @return The culling mode to use while rendering
*/
[[nodiscard]] const std::string& getCullingMode () const;
/**
* @return If depth testing has to happen while rendering
*/
[[nodiscard]] const std::string& getDepthTest () const;
/**
* @return If depth write has to happen while rendering
*/
[[nodiscard]] const std::string& getDepthWrite () const;
protected:
CPass (std::string blending, std::string cullmode, std::string depthtest, std::string depthwrite,
std::string shader, std::map<int, std::string> textures, std::map<std::string, int> combos,
std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constants);
private:
// TODO: CREATE ENUMERATIONS FOR THESE INSTEAD OF USING STRING VALUES!
/** The blending mode to use */
const std::string m_blending;
/** The culling mode to use */
const std::string m_cullmode;
/** If depthtesting has to happen while drawing */
const std::string m_depthtest;
/** If depthwrite has to happen while drawing */
const std::string m_depthwrite;
/** The shader to use */
const std::string m_shader;
/** The list of textures to use */
const std::map<int, std::string> m_textures;
/** Different combo settings for shader input */
const std::map<std::string, int> m_combos;
/** Shader constant values to use for the shaders */
const std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> m_constants;
};
} // namespace WallpaperEngine::Core::Objects::Images::Materials

28
src/WallpaperEngine/Core/Scenes/CCamera.cpp
View File

@ -1,28 +0,0 @@
#include "CCamera.h"
using namespace WallpaperEngine::Core::Scenes;
CCamera::CCamera (glm::vec3 center, glm::vec3 eye, glm::vec3 up) :
m_center (center),
m_eye (eye),
m_up (up) {}
const glm::vec3& CCamera::getCenter () const {
return this->m_center;
}
const glm::vec3& CCamera::getEye () const {
return this->m_eye;
}
const glm::vec3& CCamera::getUp () const {
return this->m_up;
}
const CCamera* CCamera::fromJSON (const json::const_iterator& data) {
return new CCamera (
jsonFindRequired <glm::vec3> (data, "center", "Camera must have a center position"),
jsonFindRequired <glm::vec3> (data, "eye", "Camera must have an eye position"),
jsonFindRequired <glm::vec3> (data, "up", "Camera must have a up position")
);
}

24
src/WallpaperEngine/Core/Scenes/CCamera.h
View File

@ -1,24 +0,0 @@
#pragma once
#include "WallpaperEngine/Core/Core.h"
namespace WallpaperEngine::Core::Scenes {
using json = nlohmann::json;
class CCamera {
public:
static const CCamera* fromJSON (const json::const_iterator& data);
const glm::vec3& getCenter () const;
const glm::vec3& getEye () const;
const glm::vec3& getUp () const;
protected:
CCamera (glm::vec3 center, glm::vec3 eye, glm::vec3 up);
private:
const glm::vec3 m_center;
const glm::vec3 m_eye;
const glm::vec3 m_up;
};
} // namespace WallpaperEngine::Core::Scenes

46
src/WallpaperEngine/Core/Scenes/CProjection.cpp
View File

@ -1,46 +0,0 @@
#include "CProjection.h"
using namespace WallpaperEngine::Core::Scenes;
CProjection::CProjection (int width, int height) :
m_width (width),
m_height (height),
m_isAuto (false) {}
CProjection::CProjection (bool isAuto) :
m_width (0),
m_height (0),
m_isAuto (isAuto) {}
const int& CProjection::getWidth () const {
return this->m_width;
}
const int& CProjection::getHeight () const {
return this->m_height;
}
bool CProjection::isAuto () const {
return this->m_isAuto;
}
void CProjection::setWidth (int width) const {
this->m_width = width;
}
void CProjection::setHeight (int height) const {
this->m_height = height;
}
const CProjection* CProjection::fromJSON (const json::const_iterator& data) {
const auto auto_it = jsonFindDefault<bool> (data, "auto", false);
const auto width_it = jsonFindRequired (data, "width", "Projection must have width");
const auto height_it = jsonFindRequired (data, "height", "Projection must have height");
// TODO: PROPERLY SUPPORT AUTO-DETECTING SIZE
if (auto_it)
return new CProjection (true);
return new CProjection (*width_it, *height_it);
}

29
src/WallpaperEngine/Core/Scenes/CProjection.h
View File

@ -1,29 +0,0 @@
#pragma once
#include "WallpaperEngine/Core/Core.h"
namespace WallpaperEngine::Core::Scenes {
using json = nlohmann::json;
class CProjection {
public:
static const CProjection* fromJSON (const json::const_iterator& data);
[[nodiscard]] const int& getWidth () const;
[[nodiscard]] const int& getHeight () const;
[[nodiscard]] bool isAuto () const;
// TODO: CHANGE THIS SO THE RENDER IS THE ONE RESPONSIBLE FOR THIS?
void setWidth (int width) const;
void setHeight (int height) const;
protected:
CProjection (int width, int height);
explicit CProjection (bool isAuto);
private:
mutable int m_width;
mutable int m_height;
const bool m_isAuto;
};
} // namespace WallpaperEngine::Core::Scenes

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

@ -3,7 +3,6 @@
#include <utility>
#include "WallpaperEngine/Core/Core.h"
#include "WallpaperEngine/Core/CProject.h"
#include "WallpaperEngine/Core/Projects/CProperty.h"
#include "WallpaperEngine/Core/Projects/CPropertyBoolean.h"
#include "WallpaperEngine/Core/Projects/CPropertyCombo.h"

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

@ -1,7 +1,6 @@
#pragma once
#include "CUserSettingValue.h"
#include "WallpaperEngine/Core/CProject.h"
namespace WallpaperEngine::Core::Projects {
class CProperty;

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

@ -3,7 +3,6 @@
#include <utility>
#include "WallpaperEngine/Core/Core.h"
#include "WallpaperEngine/Core/CProject.h"
#include "WallpaperEngine/Core/Projects/CProperty.h"
#include "WallpaperEngine/Core/Projects/CPropertySlider.h"
#include "WallpaperEngine/Logging/CLog.h"

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

@ -1,7 +1,6 @@
#pragma once
#include "CUserSettingValue.h"
#include "WallpaperEngine/Core/CProject.h"
namespace WallpaperEngine::Core::Projects {
class CProperty;

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

@ -3,7 +3,6 @@
#include <glm/vec3.hpp>
#include "CUserSettingValue.h"
#include "WallpaperEngine/Core/CProject.h"
namespace WallpaperEngine::Core::Projects {
class CProperty;

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

@ -1,172 +0,0 @@
#include "CScene.h"
#include <utility>
#include "WallpaperEngine/Core/CProject.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingFloat.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingVector3.h"
using namespace WallpaperEngine::Core;
using namespace WallpaperEngine::Core::Wallpapers;
CScene::CScene (
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,
float cameraShakeAmplitude, float cameraShakeRoughness, float cameraShakeSpeed,
const CUserSettingVector3* clearColor, const Scenes::CProjection* orthogonalProjection, glm::vec3 skylightColor
) :
CWallpaper (project),
m_container (std::move(container)),
m_camera (camera),
m_ambientColor (ambientColor),
m_bloom (bloom),
m_bloomStrength (bloomStrength),
m_bloomThreshold (bloomThreshold),
m_cameraFade (cameraFade),
m_cameraParallax (cameraParallax),
m_cameraParallaxAmount (cameraParallaxAmount),
m_cameraParallaxDelay (cameraParallaxDelay),
m_cameraParallaxMouseInfluence (cameraParallaxMouseInfluence),
m_cameraPreview (cameraPreview),
m_cameraShake (cameraShake),
m_cameraShakeAmplitude (cameraShakeAmplitude),
m_cameraShakeRoughness (cameraShakeRoughness),
m_cameraShakeSpeed (cameraShakeSpeed),
m_clearColor (clearColor),
m_orthogonalProjection (orthogonalProjection),
m_skylightColor (skylightColor) {}
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");
const auto objects_it = jsonFindRequired (content, "objects", "Scenes must have a list of objects to display");
// TODO: FIND IF THESE DEFAULTS ARE SENSIBLE OR NOT AND PERFORM PROPER VALIDATION WHEN CAMERA PREVIEW AND CAMERA
// PARALLAX ARE PRESENT
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),
jsonFindDefault<bool> (*general_it, "camerafade", false),
jsonFindDefault<bool> (*general_it, "cameraparallax", true),
jsonFindDefault<float> (*general_it, "cameraparallaxamount", 1.0f),
jsonFindDefault<float> (*general_it, "cameraparallaxdelay", 0.0f),
jsonFindDefault<float> (*general_it, "cameraparallaxmouseinfluence", 1.0f),
jsonFindDefault<bool> (*general_it, "camerapreview", false),
jsonFindDefault<bool> (*general_it, "camerashake", false),
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}),
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, project, container));
return scene;
}
const std::map<uint32_t, const CObject*>& CScene::getObjects () const {
return this->m_objects;
}
const std::vector<const CObject*>& CScene::getObjectsByRenderOrder () const {
return this->m_objectsByRenderOrder;
}
void CScene::insertObject (const CObject* object) {
/// TODO: XXXHACK -- TO REMOVE WHEN PARTICLE SUPPORT IS PROPERLY IMPLEMENTED
if (object != nullptr) {
this->m_objects.emplace (object->getId (), object);
this->m_objectsByRenderOrder.emplace_back (object);
}
}
std::shared_ptr<const CContainer> CScene::getContainer () const {
return this->m_container;
}
const Scenes::CCamera* CScene::getCamera () const {
return this->m_camera;
}
const glm::vec3& CScene::getAmbientColor () const {
return this->m_ambientColor;
}
bool CScene::isBloom () const {
return this->m_bloom->getBool ();
}
float CScene::getBloomStrength () const {
return this->m_bloomStrength->getFloat ();
}
float CScene::getBloomThreshold () const {
return this->m_bloomThreshold->getFloat ();
}
bool CScene::isCameraFade () const {
return this->m_cameraFade;
}
bool CScene::isCameraParallax () const {
return this->m_cameraParallax;
}
float CScene::getCameraParallaxAmount () const {
return this->m_cameraParallaxAmount;
}
float CScene::getCameraParallaxDelay () const {
return this->m_cameraParallaxDelay;
}
float CScene::getCameraParallaxMouseInfluence () const {
return this->m_cameraParallaxMouseInfluence;
}
bool CScene::isCameraPreview () const {
return this->m_cameraPreview;
}
bool CScene::isCameraShake () const {
return this->m_cameraShake;
}
float CScene::getCameraShakeAmplitude () const {
return this->m_cameraShakeAmplitude;
}
float CScene::getCameraShakeRoughness () const {
return this->m_cameraShakeRoughness;
}
float CScene::getCameraShakeSpeed () const {
return this->m_cameraShakeSpeed;
}
const glm::vec3& CScene::getClearColor () const {
return this->m_clearColor->getVec3 ();
}
const Scenes::CProjection* CScene::getOrthogonalProjection () const {
return this->m_orthogonalProjection;
}
const glm::vec3& CScene::getSkylightColor () const {
return this->m_skylightColor;
}

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

@ -1,88 +0,0 @@
#pragma once
#include "WallpaperEngine/Core/CObject.h"
#include "WallpaperEngine/Core/CWallpaper.h"
#include "WallpaperEngine/Core/Core.h"
#include "WallpaperEngine/Core/Scenes/CCamera.h"
#include "WallpaperEngine/Core/Scenes/CProjection.h"
namespace WallpaperEngine::Core {
class CObject;
}
namespace WallpaperEngine::Core::Wallpapers {
using json = nlohmann::json;
class CScene : public CWallpaper {
public:
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 glm::vec3& getAmbientColor () const;
[[nodiscard]] bool isBloom () const;
[[nodiscard]] float getBloomStrength () const;
[[nodiscard]] float getBloomThreshold () const;
[[nodiscard]] bool isCameraFade () const;
[[nodiscard]] bool isCameraParallax () const;
[[nodiscard]] float getCameraParallaxAmount () const;
[[nodiscard]] float getCameraParallaxDelay () const;
[[nodiscard]] float getCameraParallaxMouseInfluence () const;
[[nodiscard]] bool isCameraPreview () const;
[[nodiscard]] bool isCameraShake () const;
[[nodiscard]] float getCameraShakeAmplitude () const;
[[nodiscard]] float getCameraShakeRoughness () const;
[[nodiscard]] float getCameraShakeSpeed () const;
[[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;
void insertObject (const CObject* object);
[[nodiscard]] std::shared_ptr<const CContainer> getContainer () const;
private:
const std::shared_ptr<const CContainer> m_container;
const Scenes::CCamera* m_camera;
// data from general section on the json
const glm::vec3 m_ambientColor;
const CUserSettingBoolean* m_bloom;
const CUserSettingFloat* m_bloomStrength;
const CUserSettingFloat* m_bloomThreshold;
const bool m_cameraFade;
const bool m_cameraParallax;
const float m_cameraParallaxAmount;
const float m_cameraParallaxDelay;
const float m_cameraParallaxMouseInfluence;
const bool m_cameraPreview;
const bool m_cameraShake;
const float m_cameraShakeAmplitude;
const float m_cameraShakeRoughness;
const float m_cameraShakeSpeed;
const CUserSettingVector3* m_clearColor;
const Scenes::CProjection* m_orthogonalProjection;
const glm::vec3 m_skylightColor;
std::map<uint32_t, const CObject*> m_objects = {};
std::vector<const CObject*> m_objectsByRenderOrder = {};
};
} // namespace WallpaperEngine::Core

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

@ -1,14 +0,0 @@
#include "CVideo.h"
#include <utility>
using namespace WallpaperEngine::Core;
using namespace WallpaperEngine::Core::Wallpapers;
CVideo::CVideo (std::string filename, std::shared_ptr <const CProject> project) :
CWallpaper (project),
m_filename (std::move(filename)) {}
const std::string& CVideo::getFilename () const {
return this->m_filename;
}

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

@ -1,25 +0,0 @@
#pragma once
#include "WallpaperEngine/Core/CWallpaper.h"
#include "WallpaperEngine/Core/Core.h"
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>
}
namespace WallpaperEngine::Core::Wallpapers {
class CVideo : public CWallpaper {
public:
CVideo (std::string filename, std::shared_ptr <const CProject> project);
const std::string& getFilename () const;
protected:
friend class CWallpaper;
const std::string m_filename;
};
} // namespace WallpaperEngine::Core

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

@ -1,14 +0,0 @@
#include "CWeb.h"
#include <utility>
using namespace WallpaperEngine::Core;
using namespace WallpaperEngine::Core::Wallpapers;
const std::string& CWeb::getFilename () const {
return this->m_filename;
}
CWeb::CWeb (std::string filename, std::shared_ptr <const CProject> project) :
CWallpaper (project),
m_filename (std::move(filename)) {}

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

@ -1,31 +0,0 @@
#pragma once
#include "WallpaperEngine/Core/CWallpaper.h"
#include "WallpaperEngine/Core/Core.h"
// Chromium Embedded Framework
#include "include/cef_render_handler.h"
#include "include/cef_client.h"
#include "include/cef_app.h"
extern "C"
{
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>
}
namespace WallpaperEngine::Core::Wallpapers {
class CWeb : public CWallpaper {
public:
CWeb (std::string filename, std::shared_ptr <const CProject> project);
const std::string& getFilename () const;
protected:
friend class CWallpaper;
const std::string m_filename;
};
}

2
src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
View File

@ -39,7 +39,7 @@ void StringPrinter::printWallpaper (const Wallpaper& wallpaper) {
for (const auto& object : scene->objects) {
this->lineEnd ();
this->printObject (*object.second);
this->printObject (*object);
this->lineEnd ();
}

2
src/WallpaperEngine/Data/Model/Effect.h
View File

@ -29,7 +29,7 @@ struct EffectPass {
/** The material to use for this effect's pass */
MaterialUniquePtr material;
/** Texture bindings for this effect's pass */
std::map <int, std::string> binds;
TextureMap binds;
/** The command this material executes (if specified) */
std::optional <PassCommand> command;
/** The target this material renders to (if specified) */

4
src/WallpaperEngine/Data/Model/Material.h
View File

@ -21,9 +21,9 @@ struct MaterialPass {
/** Shader file to use for this pass */
std::string shader;
/** List of textures defined for this pass */
std::map <int, std::string> textures;
TextureMap textures;
/** The combos and their values to pass onto the shader */
std::map <std::string, int> combos;
ComboMap combos;
};
struct Material {

1
src/WallpaperEngine/Data/Model/Object.h
View File

@ -110,6 +110,7 @@ class Image : public Object, public ImageData {
struct SoundData {
/** Playback mode, loop, */
// TODO: WRITE AN ENUM FOR THIS
std::optional <std::string> playbackmode;
std::vector <std::string> sounds;
};

5
src/WallpaperEngine/Data/Model/Project.h
View File

@ -6,7 +6,6 @@
#include "Types.h"
namespace WallpaperEngine::Data::Model {
using json = WallpaperEngine::Data::JSON::JSON;
/**
* Represents a wallpaper engine project
*/
@ -31,8 +30,8 @@ struct Project {
Properties properties;
/** The wallpaper this project defines */
WallpaperSharedPtr wallpaper;
WallpaperUniquePtr wallpaper;
/** VFS to access the project's files */
ContainerWeakPtr container;
ContainerUniquePtr container;
};
};

17
src/WallpaperEngine/Data/Model/Types.h
View File

@ -58,15 +58,12 @@ using ShaderConstantUniquePtr = std::unique_ptr <ShaderConstant>;
using ShaderConstantMap = std::map <std::string, ShaderConstantUniquePtr>;
using ProjectSharedPtr = std::shared_ptr <Project>;
using WallpaperSharedPtr = std::shared_ptr <Wallpaper>;
using WallpaperWeakPtr = std::weak_ptr <Wallpaper>;
using ProjectWeakPtr = std::weak_ptr <Project>;
using ContainerSharedPtr = std::shared_ptr <Container>;
using ContainerWeakPtr = std::weak_ptr <Container>;
using SceneSharedPtr = std::shared_ptr <Scene>;
using WebSharedPtr = std::shared_ptr <Web>;
using VideoSharedPtr = std::shared_ptr <Video>;
using ProjectUniquePtr = std::unique_ptr <Project>;
using WallpaperUniquePtr = std::unique_ptr <Wallpaper>;
using ContainerUniquePtr = std::unique_ptr <Container>;
using SceneUniquePtr = std::unique_ptr <Scene>;
using WebUniquePtr = std::unique_ptr <Web>;
using VideoUniquePtr = std::unique_ptr <Video>;
using ObjectUniquePtr = std::unique_ptr <Object>;
using SoundUniquePtr = std::unique_ptr <Sound>;
using ImageUniquePtr = std::unique_ptr <Image>;
@ -80,7 +77,7 @@ using EffectPassUniquePtr = std::unique_ptr <EffectPass>;
using FBOUniquePtr = std::unique_ptr <FBO>;
using ModelUniquePtr = std::unique_ptr <ModelStruct>;
using ObjectMap = std::map<int, ObjectUniquePtr>;
using ObjectList = std::vector<ObjectUniquePtr>;
using ComboMap = std::map<std::string, int>;
using TextureMap = std::map<int, std::string>;
}

8
src/WallpaperEngine/Data/Model/Wallpaper.h
View File

@ -16,7 +16,7 @@ using TypeCaster = WallpaperEngine::Data::Utils::TypeCaster;
struct WallpaperData {
std::string filename;
ProjectWeakPtr project;
Project& project;
};
class Wallpaper : public TypeCaster, public WallpaperData {
@ -49,7 +49,7 @@ struct SceneData {
/**
* Camera configuration
*/
struct {
struct Camera {
/** Enable fade effect */
bool fade;
/** Used by the software to allow the users to preview the background or not? */
@ -104,8 +104,8 @@ struct SceneData {
bool isAuto;
} projection;
} camera;
ObjectMap objects;
ProjectWeakPtr project;
ObjectList objects;
};
class Scene : public Wallpaper, public SceneData {

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

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

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

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

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

@ -6,21 +6,20 @@
using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Data::Model;
MaterialUniquePtr MaterialParser::load (const ProjectWeakPtr& project, const std::string& filename) {
const auto materialJson = JSON::parse (project.lock ()->container.lock ()->readFileAsString (filename));
MaterialUniquePtr MaterialParser::load (Project& project, const std::string& filename) {
const auto materialJson = JSON::parse (project.container->readFileAsString (filename));
return parse (materialJson, project, filename);
}
MaterialUniquePtr MaterialParser::parse (const JSON& it, const ProjectWeakPtr& project, const std::string& filename) {
MaterialUniquePtr MaterialParser::parse (const JSON& it, Project& project, const std::string& filename) {
return std::make_unique <Material> (Material {
.filename = filename,
//TODO: PARSE PASSES
.passes = parsePasses (it.require ("passes", "Material must have passes to render"), project),
});
}
std::vector <MaterialPassUniquePtr> MaterialParser::parsePasses (const JSON& it, const ProjectWeakPtr& project) {
std::vector <MaterialPassUniquePtr> MaterialParser::parsePasses (const JSON& it, Project& project) {
std::vector <MaterialPassUniquePtr> result = {};
if (!it.is_array ()) {
@ -34,7 +33,7 @@ std::vector <MaterialPassUniquePtr> MaterialParser::parsePasses (const JSON& it,
return result;
}
MaterialPassUniquePtr MaterialParser::parsePass (const JSON& it, const ProjectWeakPtr& project) {
MaterialPassUniquePtr MaterialParser::parsePass (const JSON& it, Project& project) {
const auto textures = it.optional ("textures");
const auto combos = it.optional ("combos");
const auto constants = it.optional ("constants");

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

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

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

@ -8,13 +8,13 @@
using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Data::Model;
ModelUniquePtr ModelParser::load (const ProjectWeakPtr& project, const std::string& filename) {
const auto model = JSON::parse (project.lock ()->container.lock ()->readFileAsString (filename));
ModelUniquePtr ModelParser::load (Project& project, const std::string& filename) {
const auto model = JSON::parse (project.container->readFileAsString (filename));
return parse (model, project, filename);
}
ModelUniquePtr ModelParser::parse (const JSON& file, const ProjectWeakPtr& project, const std::string& filename) {
ModelUniquePtr ModelParser::parse (const JSON& file, Project& project, const std::string& filename) {
const auto material = file.require <std::string> ("material", "Model must have a material");
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 {
public:
static ModelUniquePtr load (const ProjectWeakPtr& project, const std::string& filename);
static ModelUniquePtr parse (const JSON& file, const ProjectWeakPtr& project, const std::string& filename);
static ModelUniquePtr load (Project& project, const std::string& filename);
static ModelUniquePtr parse (const JSON& file, Project& project, const std::string& filename);
};
} // namespace WallpaperEngine::Data::Parsers

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

@ -10,7 +10,7 @@
using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Data::Model;
ObjectUniquePtr ObjectParser::parse (const JSON& it, const ProjectWeakPtr& project) {
ObjectUniquePtr ObjectParser::parse (const JSON& it, Project& project) {
const auto imageIt = it.find ("image");
const auto soundIt = it.find ("sound");
const auto particleIt = it.find ("particle");
@ -56,7 +56,7 @@ std::vector<int> ObjectParser::parseDependencies (const JSON& it) {
return result;
}
SoundUniquePtr ObjectParser::parseSound (const JSON& it, const ProjectWeakPtr& project, ObjectData base) {
SoundUniquePtr ObjectParser::parseSound (const JSON& it, Project& project, ObjectData base) {
const auto soundIt = it.require ("sound", "Object must have a sound");
std::vector<std::string> sounds = {};
@ -74,8 +74,8 @@ SoundUniquePtr ObjectParser::parseSound (const JSON& it, const ProjectWeakPtr& p
}
ImageUniquePtr ObjectParser::parseImage (
const JSON& it, const ProjectWeakPtr& project, ObjectData base, const std::string& image) {
const auto& properties = project.lock ()->properties;
const JSON& it, Project& project, ObjectData base, const std::string& image) {
const auto& properties = project.properties;
const auto& effects = it.optional ("effects");
return std::make_unique <Image> (
@ -98,7 +98,7 @@ ImageUniquePtr ObjectParser::parseImage (
);
}
std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, const ProjectWeakPtr& project) {
std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, Project& project) {
if (!it.is_array ()) {
return {};
}
@ -112,18 +112,18 @@ std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, c
return result;
}
ImageEffectUniquePtr ObjectParser::parseEffect (const JSON& it, const ProjectWeakPtr& project) {
ImageEffectUniquePtr ObjectParser::parseEffect (const JSON& it, Project& project) {
const auto& passsOverrides = it.optional ("passes");
return std::make_unique <ImageEffect> (ImageEffect {
.id = it.require <int> ("id", "Image effect must have an id"),
.name = it.require <std::string> ("name", "Image effect must have a name"),
.visible = it.user ("visible", project.lock ()->properties, true),
.visible = it.user ("visible", project.properties, true),
.passOverrides = passsOverrides.has_value () ? parseEffectPassOverrides (passsOverrides.value (), project) : std::vector <ImageEffectPassOverrideUniquePtr> {},
.effect = EffectParser::load (project, it.require ("file", "Image effect must have an effect"))
});
}
std::vector <ImageEffectPassOverrideUniquePtr> ObjectParser::parseEffectPassOverrides (const JSON& it, const ProjectWeakPtr& project) {
std::vector <ImageEffectPassOverrideUniquePtr> ObjectParser::parseEffectPassOverrides (const JSON& it, Project& project) {
if (!it.is_array ()) {
return {};
}
@ -137,14 +137,14 @@ std::vector <ImageEffectPassOverrideUniquePtr> ObjectParser::parseEffectPassOver
return result;
}
ImageEffectPassOverrideUniquePtr ObjectParser::parseEffectPass (const JSON& it, const ProjectWeakPtr& project) {
ImageEffectPassOverrideUniquePtr ObjectParser::parseEffectPass (const JSON& it, Project& project) {
const auto& combos = it.optional ("combos");
const auto& textures = it.optional ("textures");
const auto& constants = it.optional ("constantshadervalues");
// TODO: PARSE CONSTANT SHADER VALUES AND FIND REFS?
return std::make_unique <ImageEffectPassOverride> (ImageEffectPassOverride {
.id = it.require <int> ("id", "Image effect pass must have an id"),
.id = it.optional <int> ("id", -1),
.combos = combos.has_value () ? parseComboMap (combos.value ()) : ComboMap {},
.constants = constants.has_value () ? ShaderConstantParser::parse (constants.value (), project) : ShaderConstantMap {},
.textures = textures.has_value () ? parseTextureMap (textures.value ()) : TextureMap {},

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

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

10
src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
View File

@ -5,27 +5,29 @@
#include "WallpaperParser.h"
#include "WallpaperEngine/Data/Model/Wallpaper.h"
using namespace WallpaperEngine::Data::Parsers;
static int backgroundId = 0;
ProjectSharedPtr ProjectParser::parse (const JSON& data, const ContainerWeakPtr& container) {
ProjectUniquePtr ProjectParser::parse (const JSON& data, ContainerUniquePtr container) {
const auto general = data.optional ("general");
auto type = data.require <std::string> ("type", "Project type missing");
// lowercase for consistency
std::transform (type.begin (), type.end (), type.begin (), tolower);
auto result = std::make_shared <Project> (Project {
auto result = std::make_unique <Project> (Project {
.title = data.require <std::string> ("title", "Project title missing"),
.type = parseType (type),
.workshopId = data.optional ("workshopid", std::to_string (--backgroundId)),
.supportsAudioProcessing = general.has_value () && general.value ().optional ("supportsAudioProcessing", false),
.properties = parseProperties (general),
.container = container,
.container = std::move(container),
});
result->wallpaper = WallpaperParser::parse (data.require ("file", "Project's main file missing"), result);
result->wallpaper = WallpaperParser::parse (data.require ("file", "Project's main file missing"), *result);
return result;
}

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

@ -15,7 +15,7 @@ using namespace WallpaperEngine::Data::Model;
*/
class ProjectParser {
public:
static ProjectSharedPtr parse (const JSON& data, const ContainerWeakPtr& container);
static ProjectUniquePtr parse (const JSON& data, ContainerUniquePtr container);
private:
static Project::Type parseType (const std::string& type);

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

@ -5,7 +5,7 @@
using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Data::Model;
ShaderConstantMap ShaderConstantParser::parse (const JSON& it, const ProjectWeakPtr& project) {
ShaderConstantMap ShaderConstantParser::parse (const JSON& it, Project& project) {
if (!it.is_object ()) {
return {};
}
@ -19,7 +19,7 @@ ShaderConstantMap ShaderConstantParser::parse (const JSON& it, const ProjectWeak
return result;
}
ShaderConstantUniquePtr ShaderConstantParser::parseConstant (const JSON& it, const ProjectWeakPtr& project) {
ShaderConstantUniquePtr ShaderConstantParser::parseConstant (const JSON& it, Project& project) {
ShaderConstant* constant = nullptr;
auto valueIt = it;
@ -33,7 +33,7 @@ ShaderConstantUniquePtr ShaderConstantParser::parseConstant (const JSON& it, con
}
if (user != it.end () && user->is_string ()) {
const auto& properties = project.lock ()->properties;
const auto& properties = project.properties;
const auto& propertyIt = properties.find (*user);
if (propertyIt != properties.end ()) {

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

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

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

@ -7,31 +7,31 @@
using namespace WallpaperEngine::Data::Parsers;
WallpaperSharedPtr WallpaperParser::parse (const JSON& file, const ProjectWeakPtr& project) {
switch (project.lock ()->type) {
WallpaperUniquePtr WallpaperParser::parse (const JSON& file, Project& project) {
switch (project.type) {
case Project::Type_Scene:
return std::dynamic_pointer_cast <Wallpaper> (parseScene (file, project));
return parseScene (file, project);
case Project::Type_Video:
return std::dynamic_pointer_cast <Wallpaper> (parseVideo (file, project));
return parseVideo (file, project);
case Project::Type_Web:
return std::dynamic_pointer_cast <Wallpaper> (parseWeb (file, project));
return parseWeb (file, project);
default:
sLog.exception ("Unexpected project type value found... This is likely a bug");
}
}
SceneSharedPtr WallpaperParser::parseScene (const JSON& file, const ProjectWeakPtr& project) {
const auto scene = JSON::parse (project.lock ()->container.lock ()->readFileAsString (file));
SceneUniquePtr WallpaperParser::parseScene (const JSON& file, Project& project) {
const auto scene = JSON::parse (project.container->readFileAsString (file));
const auto camera = scene.require ("camera", "Scenes must have a camera section");
const auto general = scene.require ("general", "Scenes must have a general section");
const auto projection = general.require ("orthogonalprojection", "General section must have orthogonal projection info");
const auto objects = scene.require ("objects", "Scenes must have an objects section");
const auto& properties = project.lock ()->properties;
const auto& properties = project.properties;
// TODO: FIND IF THESE DEFAULTS ARE SENSIBLE OR NOT AND PERFORM PROPER VALIDATION WHEN CAMERA PREVIEW AND CAMERA
// PARALLAX ARE PRESENT
return std::make_shared <Scene> (
return std::make_unique <Scene> (
WallpaperData {
.filename = "",
.project = project
@ -72,34 +72,34 @@ SceneSharedPtr WallpaperParser::parseScene (const JSON& file, const ProjectWeakP
.isAuto = projection.optional ("auto", false)
}
},
.objects = parseObjects (objects, project)
.objects = parseObjects (objects, project),
}
);
}
VideoSharedPtr WallpaperParser::parseVideo (const JSON& file, const ProjectWeakPtr& project) {
VideoUniquePtr WallpaperParser::parseVideo (const JSON& file, Project& project) {
return std::make_unique <Video> (WallpaperData {
.filename = file,
.project = project
});
}
WebSharedPtr WallpaperParser::parseWeb (const JSON& file, const ProjectWeakPtr& project) {
WebUniquePtr WallpaperParser::parseWeb (const JSON& file, Project& project) {
return std::make_unique <Web> (WallpaperData {
.filename = file,
.project = project,
});
}
ObjectMap WallpaperParser::parseObjects (const JSON& objects, const ProjectWeakPtr& project) {
ObjectMap result = {};
ObjectList WallpaperParser::parseObjects (const JSON& objects, Project& project) {
ObjectList result = {};
for (const auto& cur : objects) {
auto object = 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 (object->id, std::move (object));
result.emplace_back (std::move (object));
}
return result;

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

@ -9,12 +9,12 @@ using namespace WallpaperEngine::Data::Model;
class WallpaperParser {
public:
static WallpaperSharedPtr parse (const JSON& file, const ProjectWeakPtr& project);
static WallpaperUniquePtr parse (const JSON& file, Project& project);
private:
static SceneSharedPtr parseScene (const JSON& file, const ProjectWeakPtr& project);
static VideoSharedPtr parseVideo (const JSON& file, const ProjectWeakPtr& project);
static WebSharedPtr parseWeb (const JSON& file, const ProjectWeakPtr& project);
static ObjectMap parseObjects (const JSON& objects, const ProjectWeakPtr& project);
static SceneUniquePtr parseScene (const JSON& file, Project& project);
static VideoUniquePtr parseVideo (const JSON& file, Project& project);
static WebUniquePtr parseWeb (const JSON& file, Project& project);
static ObjectList parseObjects (const JSON& objects, Project& project);
};
} // namespace WallpaperEngine::Data::Parsers

403
src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.cpp
View File

@ -1,403 +0,0 @@
#include "CPrettyPrinter.h"
#include "WallpaperEngine/Render/Wallpapers/CVideo.h"
#include "WallpaperEngine/Render/Wallpapers/CWeb.h"
#include "WallpaperEngine/Render/Objects/CEffect.h"
using namespace WallpaperEngine::Render;
using namespace WallpaperEngine::PrettyPrinter;
using namespace WallpaperEngine::Render::Objects;
CPrettyPrinter::CPrettyPrinter () :
m_out (&this->m_buffer) {}
void CPrettyPrinter::printWallpaper (const CWallpaper& wallpaper) {
bool isScene = wallpaper.is <Wallpapers::CScene> ();
bool isVideo = wallpaper.is <Wallpapers::CVideo> ();
bool isWeb = wallpaper.is <Wallpapers::CWeb> ();
if (isScene) {
const auto scene = wallpaper.as <Wallpapers::CScene> ();
this->m_out << "Scene wallpaper: ";
this->increaseIndentation ();
const auto fbos = scene->getFBOs ();
this->m_out << "FBOs count: " << fbos.size ();
if (!fbos.empty()) {
this->increaseIndentation ();
for (const auto& fbo : fbos) {
this->printFBO (*fbo.second);
}
this->decreaseIndentation ();
} else {
this->lineEnd ();
}
const auto objects = scene->getObjectsByRenderOrder ();
if (!objects.empty()) {
this->m_out << "Objects count: " << objects.size ();
this->increaseIndentation ();
for (const auto object : objects) {
if (object->is <CImage> ()) {
this->printImage (*object->as <CImage> ());
}
}
this->decreaseIndentation ();
}
this->decreaseIndentation ();
} else if (isVideo) {
const auto video = wallpaper.as <Wallpapers::CVideo> ();
this->m_out << "Video wallpaper: " << video->getVideo ()->getFilename ();
this->lineEnd ();
} else if (isWeb) {
const auto web = wallpaper.as <Wallpapers::CWeb> ();
this->m_out << "Web wallpaper";
this->lineEnd ();
}
}
void CPrettyPrinter::printImage (const CImage& image) {
auto base = image.getImage ();
this->m_out << "Image " << image.getId () << " " << base->getName () << ":";
this->increaseIndentation ();
const auto material = image.getMaterial ();
if (material != nullptr) {
this->printMaterial (*image.getMaterial ());
}
int effects = 0;
for (const auto effect : image.getEffects ()) {
this->printEffect (*effect, ++effects);
}
this->decreaseIndentation ();
}
void CPrettyPrinter::printEffect (const CEffect& effect, int effectId) {
if (effectId != 0) {
this->m_out << "Effect " << effectId << ":";
} else {
this->m_out << "Effect:";
}
this->increaseIndentation ();
this->m_out << "Visibility status: " << effect.isVisible ();
this->lineEnd ();
const auto& fbos = effect.getFBOs();
this->m_out << "FBOs count: " << fbos.size();
if (!fbos.empty()) {
this->increaseIndentation ();
for (const auto& [name, fbo] : fbos) {
this->printFBO (*fbo);
}
this->decreaseIndentation ();
} else {
this->lineEnd ();
}
const auto& materials = effect.getMaterials ();
for (const auto material : materials) {
this->printMaterial (*material);
}
this->decreaseIndentation ();
}
void CPrettyPrinter::printFBO (const CFBO& fbo) {
this->m_out << "FBO " << fbo.getName () << ":";
this->increaseIndentation ();
this->m_out << "Scale: " << fbo.getScale ();
this->lineEnd ();
this->printTextureInfo (fbo);
this->decreaseIndentation ();
}
void CPrettyPrinter::printMaterial (const CMaterial& material) {
const auto base = material.getMaterial ();
this->m_out << "Material " << base->getName () << ":";
this->increaseIndentation ();
if (base->hasTarget ()) {
this->m_out << "Target: " << base->getTarget ();
this->lineEnd ();
}
const auto& passes = material.getPasses ();
this->m_out << "Passes count: " << passes.size ();
if (!passes.empty()) {
this->increaseIndentation ();
int passId = 0;
for (const auto pass : passes) {
this->printPass (*pass, ++passId);
}
this->decreaseIndentation ();
} else {
this->lineEnd ();
}
const auto textureBinds = base->getTextureBinds ();
if (!textureBinds.empty()) {
this->m_out << "Texture binds count: " << textureBinds.size ();
this->increaseIndentation ();
for (const auto bind : textureBinds) {
this->m_out << "Bind " << bind.first << " = " << bind.second->getIndex () << "," << bind.second->getName ();
this->lineEnd ();
}
this->decreaseIndentation ();
}
this->decreaseIndentation ();
}
void CPrettyPrinter::printPass (const CPass& pass, int passId) {
const auto base = pass.getPass ();
this->m_out << "Pass " << passId << ":";
this->increaseIndentation ();
if (pass.getBlendingMode () != base->getBlendingMode ()) {
this->m_out << "Render blending mode: " << pass.getBlendingMode ();
this->lineEnd ();
this->m_out << "Blending mode: " << base->getBlendingMode ();
this->lineEnd ();
} else {
this->m_out << "Blending mode: " << base->getBlendingMode ();
this->lineEnd ();
}
this->m_out << "Culling mode: " << base->getCullingMode();
this->lineEnd ();
this->m_out << "Depth test: " << base->getDepthTest();
this->lineEnd ();
this->m_out << "Depth write: " << base->getDepthWrite();
this->lineEnd ();
this->m_out << "Shader: " << base->getShader();
this->lineEnd ();
const auto textures = base->getTextures ();
if (!textures.empty()) {
this->m_out << "Textures " << textures.size () << ":";
this->increaseIndentation ();
for (const auto& texture : textures) {
this->m_out << texture.first << ": " << texture.second;
this->lineEnd ();
}
this->decreaseIndentation ();
}
const auto& fragmentTextures = pass.getShader ()->getFragment ().getTextures ();
if (!fragmentTextures.empty()) {
this->m_out << "Fragment textures " << fragmentTextures.size () << ":";
this->increaseIndentation ();
for (const auto& texture : fragmentTextures) {
this->m_out << texture.first << ": " << texture.second;
this->lineEnd ();
}
this->decreaseIndentation ();
}
const auto& vertexTextures = pass.getShader ()->getFragment ().getTextures ();
if (!vertexTextures.empty()) {
this->m_out << "Vertex textures " << textures.size () << ":";
this->increaseIndentation ();
for (const auto& texture : vertexTextures) {
this->m_out << texture.first << ": " << texture.second;
this->lineEnd ();
}
this->decreaseIndentation ();
}
const auto& combos = base->getCombos();
if (!combos.empty()) {
this->m_out << "Combos " << combos.size () << ":";
this->increaseIndentation ();
for (const auto& combo : combos) {
this->m_out << combo.first << " = " << combo.second;
this->lineEnd ();
}
this->decreaseIndentation ();
}
const auto& vertexCombos = pass.getShader ()->getVertex ().getDiscoveredCombos ();
if (!vertexCombos.empty()) {
this->m_out << "Vertex combos " << vertexCombos.size () << ":";
this->increaseIndentation ();
for (const auto& combo : vertexCombos) {
this->m_out << combo.first << " = " << combo.second;
this->lineEnd ();
}
this->decreaseIndentation ();
}
const auto& fragmentCombos = pass.getShader ()->getFragment ().getDiscoveredCombos ();
if (!fragmentCombos.empty()) {
this->m_out << "Vertex combos " << fragmentCombos.size () << ":";
this->increaseIndentation ();
for (const auto& combo : fragmentCombos) {
this->m_out << combo.first << " = " << combo.second;
this->lineEnd ();
}
this->decreaseIndentation ();
}
const auto& constants = base->getConstants ();
if (!constants.empty()) {
this->m_out << "Constants " << constants.size () << ":";
this->increaseIndentation ();
for (const auto& constant : constants) {
this->m_out << constant.first << " = " << constant.second->toString ();
this->lineEnd ();
}
this->decreaseIndentation ();
}
this->decreaseIndentation ();
}
void CPrettyPrinter::printTextureInfo (const ITexture& texture) {
this->m_out << "Texture Dimensions: " << texture.getTextureWidth(0) << "x" << texture.getTextureHeight (0);
this->lineEnd ();
this->m_out << "Part Dimensions: " << texture.getRealWidth () << "x" << texture.getRealHeight ();
this->lineEnd ();
this->m_out << "Texture format: ";
this->printTextureFormat (texture.getFormat ());
this->lineEnd ();
this->m_out << "Texture flags: ";
this->printTextureFlags (texture.getFlags ());
this->lineEnd ();
this->m_out << "Is animated: " << texture.isAnimated ();
this->lineEnd ();
const auto& frames = texture.getFrames ();
if (frames.size () > 1) {
this->m_out << frames.size () << " frames: ";
this->increaseIndentation ();
for (const auto frame : frames) {
this->m_out << "Frame " << frame->frameNumber << ":";
this->increaseIndentation ();
this->m_out << "Frametime " << frame->frametime;
this->lineEnd ();
this->m_out << "Position in atlas: " << frame->x << "x" << frame->y;
this->lineEnd ();
this->m_out << "Size1: " << frame->width1 << "x" << frame->height1;
this->lineEnd ();
this->m_out << "Size2: " << frame->width2 << "x" << frame->height2;
this->decreaseIndentation ();
}
this->decreaseIndentation ();
}
}
void CPrettyPrinter::printTextureFormat (ITexture::TextureFormat format) {
switch (format) {
case ITexture::UNKNOWN: this->m_out << "UNKNOWN"; break;
case ITexture::ARGB8888: this->m_out << "ARGB8888"; break;
case ITexture::RGB888: this->m_out << "RGB888"; break;
case ITexture::RGB565: this->m_out << "RGB565"; break;
case ITexture::DXT5: this->m_out << "DXT5"; break;
case ITexture::DXT3: this->m_out << "DXT3"; break;
case ITexture::DXT1: this->m_out << "DXT1"; break;
case ITexture::RG88: this->m_out << "RG88"; break;
case ITexture::R8: this->m_out << "R8"; break;
case ITexture::RG1616f: this->m_out << "RG1616f"; break;
case ITexture::R16f: this->m_out << "R16f"; break;
case ITexture::BC7: this->m_out << "BC7"; break;
case ITexture::RGBa1010102: this->m_out << "RGBa1010102"; break;
case ITexture::RGBA16161616f: this->m_out << "RGBA16161616f"; break;
case ITexture::RGB161616f: this->m_out << "RGB161616f"; break;
}
}
void CPrettyPrinter::printTextureFlags (ITexture::TextureFlags flags) {
if (flags & ITexture::NoInterpolation) {
this->m_out << "No interpolation";
}
if (flags & ITexture::ClampUVs) {
this->m_out << "Clamp UVs ";
}
if (flags & ITexture::IsGif) {
this->m_out << "Is gif ";
}
if (flags & ITexture::ClampUVsBorder) {
this->m_out << "ClampUVs border ";
}
if (flags == ITexture::NoFlags) {
this->m_out << "No flags";
}
}
void CPrettyPrinter::indentation () {
this->m_out << std::string(this->m_level, '\t');
}
void CPrettyPrinter::lineEnd () {
this->m_out << '\n';
this->indentation ();
}
void CPrettyPrinter::increaseIndentation () {
this->m_level ++;
this->lineEnd ();
}
void CPrettyPrinter::decreaseIndentation () {
this->m_level --;
this->lineEnd ();
}
std::string CPrettyPrinter::str () {
return this->m_buffer.str ();
}

108
src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.h
View File

@ -1,108 +0,0 @@
#pragma once
#include <sstream>
#include "WallpaperEngine/Render/Objects/CImage.h"
using namespace WallpaperEngine::Render;
using namespace WallpaperEngine::Render::Objects;
using namespace WallpaperEngine::Render::Objects::Effects;
namespace WallpaperEngine::PrettyPrinter {
/**
* Provides insights on the actual data that is being used to render the wallpaper
* to the screens
*/
class CPrettyPrinter {
public:
CPrettyPrinter ();
~CPrettyPrinter () = default;
/**
* Prints the information of the given wallpaper
*
* @param wallpaper
*/
void printWallpaper (const CWallpaper& wallpaper);
/**
* Prints the information of the given image
* @param image
*/
void printImage (const CImage& image);
/**
* Prints the information of the given effect
*
* @param effect
* @param effectId The effect ID to show on the output if required
*/
void printEffect (const CEffect& effect, int effectId = 0);
/**
* Prints the information of the given FBO
*
* @param fbo
*/
void printFBO (const CFBO& fbo);
/**
* Prints the information of the given material
*
* @param material
*/
void printMaterial (const CMaterial& material);
/**
* Prints the information of the given material's pass
*
* @param pass
*/
void printPass (const CPass& pass, int passId = 0);
/**
* @return The contents of the pretty printer buffer
*/
std::string str ();
private:
/**
* Prints the current indentation level in tabs
*/
void indentation ();
/**
* Prints an end of line and indentates the next line to the aproppiate level
*/
void lineEnd ();
/**
* Increases the indentation level and prints a new line up to the specified level
*/
void increaseIndentation ();
/**
* Decreases the indentation level and prints a new line up to the specified level
*/
void decreaseIndentation ();
/**
* Prints a texture's format as string in-place
*
* @param format
*/
void printTextureFormat (ITexture::TextureFormat format);
/**
* Prints a texture's flags as string in-place
*
* @param flags
*/
void printTextureFlags (ITexture::TextureFlags flags);
/**
* Prints information about a given ITexture in-place
*
* @param texture
*/
void printTextureInfo (const ITexture& texture);
int m_level = 0;
std::stringbuf m_buffer = {};
std::ostream m_out;
};
}

25
src/WallpaperEngine/Render/CCamera.cpp
View File

@ -6,9 +6,11 @@
using namespace WallpaperEngine;
using namespace WallpaperEngine::Render;
CCamera::CCamera (Wallpapers::CScene* scene, const Core::Scenes::CCamera* camera) :
CCamera::CCamera (Wallpapers::CScene& scene, const SceneData::Camera& camera) :
m_camera (camera),
m_scene (scene) {
m_scene (scene),
m_width (0),
m_height (0) {
// get the lookat position
// TODO: ENSURE THIS IS ONLY USED WHEN NOT DOING AN ORTOGRAPHIC CAMERA AS IT THROWS OFF POINTS
this->m_lookat = glm::lookAt (this->getEye (), this->getCenter (), this->getUp ());
@ -17,15 +19,15 @@ CCamera::CCamera (Wallpapers::CScene* scene, const Core::Scenes::CCamera* camera
CCamera::~CCamera () = default;
const glm::vec3& CCamera::getCenter () const {
return this->m_camera->getCenter ();
return this->m_camera.configuration.center;
}
const glm::vec3& CCamera::getEye () const {
return this->m_camera->getEye ();
return this->m_camera.configuration.eye;
}
const glm::vec3& CCamera::getUp () const {
return this->m_camera->getUp ();
return this->m_camera.configuration.up;
}
const glm::mat4& CCamera::getProjection () const {
@ -40,11 +42,22 @@ bool CCamera::isOrthogonal () const {
return this->m_isOrthogonal;
}
Wallpapers::CScene* CCamera::getScene () const {
Wallpapers::CScene& CCamera::getScene () const {
return this->m_scene;
}
float CCamera::getWidth () const {
return this->m_width;
}
float CCamera::getHeight () const {
return this->m_height;
}
void CCamera::setOrthogonalProjection (float width, float height) {
this->m_width = width;
this->m_height = height;
// TODO: GET THE ZNEAR AND ZFAR FROM THE BACKGROUND (IF AVAILABLE)
// get the orthogonal projection (the float is there to ensure the values are casted to float, so maths do work)
this->m_projection = glm::ortho<float> (-width / 2.0, width / 2.0, -height / 2.0, height / 2.0, 0, 1000);

16
src/WallpaperEngine/Render/CCamera.h
View File

@ -5,16 +5,18 @@
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include "WallpaperEngine/Core/Scenes/CCamera.h"
#include "WallpaperEngine/Data/Model/Wallpaper.h"
namespace WallpaperEngine::Render::Wallpapers {
class CScene;
}
namespace WallpaperEngine::Render {
using namespace WallpaperEngine::Data::Model;
class CCamera {
public:
CCamera (Wallpapers::CScene* scene, const Core::Scenes::CCamera* camera);
CCamera (Wallpapers::CScene& scene, const SceneData::Camera& camera);
~CCamera ();
void setOrthogonalProjection (float width, float height);
@ -24,14 +26,18 @@ class CCamera {
[[nodiscard]] const glm::vec3& getUp () const;
[[nodiscard]] const glm::mat4& getProjection () const;
[[nodiscard]] const glm::mat4& getLookAt () const;
[[nodiscard]] Wallpapers::CScene* getScene () const;
[[nodiscard]] Wallpapers::CScene& getScene () const;
[[nodiscard]] bool isOrthogonal () const;
[[nodiscard]] float getWidth () const;
[[nodiscard]] float getHeight () const;
private:
float m_width;
float m_height;
bool m_isOrthogonal = false;
glm::mat4 m_projection = {};
glm::mat4 m_lookat = {};
const Core::Scenes::CCamera* m_camera;
Wallpapers::CScene* m_scene = nullptr;
const SceneData::Camera& m_camera;
Wallpapers::CScene& m_scene;
};
} // namespace WallpaperEngine::Render

4
src/WallpaperEngine/Render/CFBO.h
View File

@ -1,8 +1,8 @@
#pragma once
#include <string>
#include "WallpaperEngine/Assets/ITexture.h"
#include "WallpaperEngine/Core/Objects/CImage.h"
#include "WallpaperEngine/Core/Objects/Effects/CFBO.h"
using namespace WallpaperEngine::Assets;

57
src/WallpaperEngine/Render/CFBOProvider.cpp Normal file
View File

@ -0,0 +1,57 @@
#include "CFBOProvider.h"
#include <gmpxx.h>
using namespace WallpaperEngine::Render;
using namespace WallpaperEngine::Data::Model;
CFBOProvider::CFBOProvider (const CFBOProvider* parent) :
m_parent (parent) {}
std::shared_ptr<CFBO> CFBOProvider::create(const FBO& base, ITexture::TextureFlags flags, glm::vec2 size) {
return this->m_fbos[base.name] = std::make_shared <CFBO> (
base.name,
// TODO: PROPERLY DETERMINE FBO FORMAT BASED ON THE STRING
ITexture::TextureFormat::ARGB8888,
flags,
base.scale,
size.x / base.scale,
size.y / base.scale,
size.x / base.scale,
size.y / base.scale
);
}
std::shared_ptr<CFBO> CFBOProvider::create (
const std::string& name, ITexture::TextureFormat format, ITexture::TextureFlags flags, float scale,
glm::vec2 realSize, glm::vec2 textureSize
) {
return this->m_fbos[name] = std::make_shared <CFBO> (
name,
ITexture::TextureFormat::ARGB8888,
flags,
scale,
realSize.x,
realSize.y,
textureSize.x,
textureSize.y
);
}
std::shared_ptr<CFBO> CFBOProvider::alias (const std::string& newName, const std::string& original) {
return this->m_fbos[newName] = this->m_fbos[original];
}
std::shared_ptr<CFBO> CFBOProvider::find (const std::string& name) const {
const auto it = this->m_fbos.find (name);
if (it != this->m_fbos.end ())
return it->second;
if (this->m_parent == nullptr) {
return nullptr;
}
return this->m_parent->find (name);
}

24
src/WallpaperEngine/Render/CFBOProvider.h Normal file
View File

@ -0,0 +1,24 @@
#pragma once
#include "CFBO.h"
#include "WallpaperEngine/Data/Model/Effect.h"
namespace WallpaperEngine::Render {
using namespace WallpaperEngine::Data::Model;
class CFBOProvider {
public:
CFBOProvider (const CFBOProvider* parent);
std::shared_ptr<CFBO> create (const FBO& base, ITexture::TextureFlags flags, glm::vec2 size);
std::shared_ptr<CFBO> create (
const std::string& name, ITexture::TextureFormat format, ITexture::TextureFlags flags, float scale,
glm::vec2 realSize, glm::vec2 textureSize);
std::shared_ptr<CFBO> alias (const std::string& newName, const std::string& original);
[[nodiscard]] std::shared_ptr<CFBO> find (const std::string& name) const;
private:
const CFBOProvider* m_parent;
std::map <std::string, std::shared_ptr<CFBO>> m_fbos = {};
};
}

10
src/WallpaperEngine/Render/CObject.cpp
View File

@ -6,19 +6,19 @@ using namespace WallpaperEngine;
using namespace WallpaperEngine::Render;
using namespace WallpaperEngine::Render::Wallpapers;
CObject::CObject (Wallpapers::CScene* scene, const Core::CObject* object) :
CObject::CObject (Wallpapers::CScene& scene, const Object& object) :
Helpers::CContextAware (scene),
m_scene (scene),
m_object (object) {}
Wallpapers::CScene* CObject::getScene () const {
Wallpapers::CScene& CObject::getScene () const {
return this->m_scene;
}
std::shared_ptr<const CContainer> CObject::getContainer () const {
return this->getScene ()->getContainer ();
const CContainer& CObject::getContainer () const {
return this->getScene ().getContainer ();
}
int CObject::getId () const {
return this->m_object->getId ();
return this->m_object.id;
}

11
src/WallpaperEngine/Render/CObject.h
View File

@ -2,7 +2,6 @@
#include <string>
#include "WallpaperEngine/Core/CObject.h"
#include "WallpaperEngine/Render/Helpers/CContextAware.h"
#include "WallpaperEngine/Render/Wallpapers/CScene.h"
@ -36,16 +35,16 @@ class CObject : public Helpers::CContextAware {
virtual void render () = 0;
[[nodiscard]] Wallpapers::CScene* getScene () const;
[[nodiscard]] std::shared_ptr<const CContainer> getContainer () const;
[[nodiscard]] Wallpapers::CScene& getScene () const;
[[nodiscard]] const CContainer& getContainer () const;
[[nodiscard]] int getId () const;
protected:
CObject (Wallpapers::CScene* scene, const Core::CObject* object);
CObject (Wallpapers::CScene& scene, const Object& object);
virtual ~CObject () override = default;
private:
Wallpapers::CScene* m_scene = nullptr;
const Core::CObject* m_object;
Wallpapers::CScene& m_scene;
const Object& m_object;
};
} // namespace WallpaperEngine::Render

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

@ -5,6 +5,8 @@
#include "CRenderContext.h"
#include "CWallpaper.h"
#include "WallpaperEngine/Data/Model/Project.h"
namespace WallpaperEngine::Render {
CRenderContext::CRenderContext (Drivers::CVideoDriver& driver, CWallpaperApplication& app) :
m_driver (driver),

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

@ -3,6 +3,8 @@
#include "WallpaperEngine/Assets/CAssetLoadException.h"
#include "WallpaperEngine/Render/Helpers/CContextAware.h"
#include "WallpaperEngine/Data/Model/Project.h"
using namespace WallpaperEngine::Render;
using namespace WallpaperEngine::Assets;
@ -15,9 +17,9 @@ std::shared_ptr<const ITexture> CTextureCache::resolve (const std::string& filen
return found->second;
// search for the texture in all the different containers just in case
for (const auto& it : this->getContext ().getApp ().getBackgrounds ()) {
for (const auto& [name, project] : this->getContext ().getApp ().getBackgrounds ()) {
try {
std::shared_ptr<const ITexture> texture = it.second->getContainer ()->readTexture (filename);
std::shared_ptr<const ITexture> texture = project->container->readTexture (filename);
this->store (filename, texture);

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

@ -4,17 +4,21 @@
#include "WallpaperEngine/Render/Wallpapers/CVideo.h"
#include "WallpaperEngine/Render/Wallpapers/CWeb.h"
#include "WallpaperEngine/Data/Model/Wallpaper.h"
#include "WallpaperEngine/Data/Model/Project.h"
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
using namespace WallpaperEngine::Render;
CWallpaper::CWallpaper (
std::shared_ptr <const Core::CWallpaper> wallpaperData, CRenderContext& context,CAudioContext& audioContext,
const Wallpaper& wallpaperData, CRenderContext& context,CAudioContext& audioContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
) :
CContextAware (context),
CFBOProvider (nullptr),
m_wallpaperData (wallpaperData),
m_audioContext (audioContext),
m_state (scalingMode, clampMode) {
@ -41,11 +45,11 @@ CWallpaper::CWallpaper (
CWallpaper::~CWallpaper () = default;
std::shared_ptr<const CContainer> CWallpaper::getContainer () const {
return this->m_wallpaperData->getProject ()->getContainer ();
const CContainer& CWallpaper::getContainer () const {
return *this->m_wallpaperData.project.container;
}
std::shared_ptr <const WallpaperEngine::Core::CWallpaper> CWallpaper::getWallpaperData () const {
const Wallpaper& CWallpaper::getWallpaperData () const {
return this->m_wallpaperData;
}
@ -186,7 +190,14 @@ void CWallpaper::updateUVs (const glm::ivec4& viewport, const bool vflip) {
}
void CWallpaper::render (glm::ivec4 viewport, bool vflip) {
#if !NDEBUG
glPushDebugGroup (GL_DEBUG_SOURCE_APPLICATION, 0, -1, "Rendering scene");
#endif /* !NDEBUG */
this->renderFrame (viewport);
#if !NDEBUG
glPopDebugGroup ();
glPushDebugGroup (GL_DEBUG_SOURCE_APPLICATION, 0, -1, "Rendering scene to output");
#endif /* !NDEBUG */
// Update UVs coordinates according to scaling mode of this wallpaper
updateUVs (viewport, vflip);
auto [ustart, uend, vstart, vend] = this->m_state.getTextureUVs ();
@ -203,6 +214,7 @@ void CWallpaper::render (glm::ivec4 viewport, bool vflip) {
glDisable (GL_BLEND);
glDisable (GL_DEPTH_TEST);
glDisable (GL_CULL_FACE);
// do not use any shader
glUseProgram (this->m_shader);
// activate scene texture
@ -222,6 +234,10 @@ void CWallpaper::render (glm::ivec4 viewport, bool vflip) {
// write the framebuffer as is to the screen
glBindBuffer (GL_ARRAY_BUFFER, this->m_texCoordBuffer);
glDrawArrays (GL_TRIANGLES, 0, 6);
#if !NDEBUG
glPopDebugGroup ();
#endif /* !NDEBUG */
}
void CWallpaper::setPause (bool newState) {}
@ -232,62 +248,43 @@ void CWallpaper::setupFramebuffers () {
const ITexture::TextureFlags clamp = this->m_state.getClampingMode ();
// create framebuffer for the scene
this->m_sceneFBO = this->createFBO (
"_rt_FullFrameBuffer", ITexture::TextureFormat::ARGB8888, clamp, 1.0, width,
height, width, height);
this->m_sceneFBO = this->create (
"_rt_FullFrameBuffer", ITexture::TextureFormat::ARGB8888, clamp, 1.0, {width,
height}, {width, height});
this->aliasFBO ("_rt_MipMappedFrameBuffer", this->m_sceneFBO);
this->alias ("_rt_MipMappedFrameBuffer", "_rt_FullFrameBuffer");
}
CAudioContext& CWallpaper::getAudioContext () {
return this->m_audioContext;
}
std::shared_ptr<const CFBO> CWallpaper::createFBO (
const std::string& name, ITexture::TextureFormat format, ITexture::TextureFlags flags, float scale,
uint32_t realWidth, uint32_t realHeight, uint32_t textureWidth, uint32_t textureHeight
) {
std::shared_ptr<const CFBO> fbo = std::make_shared <CFBO> (name, format, flags, scale, realWidth, realHeight, textureWidth, textureHeight);
this->m_fbos.emplace (name, fbo);
return fbo;
}
void CWallpaper::aliasFBO (const std::string& alias, const std::shared_ptr<const CFBO>& original) {
this->m_fbos.emplace (alias, original);
}
const std::map<std::string, std::shared_ptr<const CFBO>>& CWallpaper::getFBOs () const {
return this->m_fbos;
}
std::shared_ptr<const CFBO> CWallpaper::findFBO (const std::string& name) const {
const auto it = this->m_fbos.find (name);
const auto fbo = this->find (name);
if (it == this->m_fbos.end ())
if (fbo == nullptr)
sLog.exception ("Cannot find FBO ", name);
return it->second;
return fbo;
}
std::shared_ptr<const CFBO> CWallpaper::getFBO () const {
return this->m_sceneFBO;
}
std::shared_ptr<CWallpaper> CWallpaper::fromWallpaper (
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
std::unique_ptr<CWallpaper> CWallpaper::fromWallpaper (
const Wallpaper& 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 std::make_shared <WallpaperEngine::Render::Wallpapers::CScene> (
if (wallpaper.is<Scene> ()) {
return std::make_unique <WallpaperEngine::Render::Wallpapers::CScene> (
wallpaper, context, audioContext, scalingMode, clampMode);
} else if (wallpaper->is<Core::Wallpapers::CVideo> ()) {
return std::make_shared<WallpaperEngine::Render::Wallpapers::CVideo> (
} else if (wallpaper.is<Video> ()) {
return std::make_unique<WallpaperEngine::Render::Wallpapers::CVideo> (
wallpaper, context, audioContext, scalingMode, clampMode);
} else if (wallpaper->is<Core::Wallpapers::CWeb> ()) {
return std::make_shared<WallpaperEngine::Render::Wallpapers::CWeb> (
} else if (wallpaper.is<Web> ()) {
return std::make_unique<WallpaperEngine::Render::Wallpapers::CWeb> (
wallpaper, context, audioContext, *browserContext, scalingMode, clampMode);
} else
sLog.exception ("Unsupported wallpaper type");

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

@ -6,18 +6,14 @@
#include "WallpaperEngine/Assets/CContainer.h"
#include "WallpaperEngine/Audio/CAudioContext.h"
#include "WallpaperEngine/Core/CWallpaper.h"
#include "WallpaperEngine/Core/Wallpapers/CScene.h"
#include "WallpaperEngine/Core/Wallpapers/CVideo.h"
#include "WallpaperEngine/Render/CFBO.h"
#include "WallpaperEngine/Render/CRenderContext.h"
#include "WallpaperEngine/Render/Helpers/CContextAware.h"
#include "CWallpaperState.h"
#include "WallpaperEngine/Data/Model/Wallpaper.h"
using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Audio;
#include "CFBOProvider.h"
#include "CWallpaperState.h"
namespace WallpaperEngine::WebBrowser {
class CWebBrowserContext;
@ -28,7 +24,11 @@ namespace Helpers {
class CContextAware;
}
class CWallpaper : public Helpers::CContextAware {
using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Audio;
using namespace WallpaperEngine::Data::Model;
class CWallpaper : public Helpers::CContextAware, public CFBOProvider {
public:
template <class T> [[nodiscard]] const T* as () const {
if (is <T> ()) {
@ -65,7 +65,7 @@ class CWallpaper : public Helpers::CContextAware {
/**
* @return The container to resolve files for this wallpaper
*/
[[nodiscard]] std::shared_ptr<const CContainer> getContainer () const;
[[nodiscard]] const CContainer& getContainer () const;
/**
* @return The current audio context for this wallpaper
@ -80,34 +80,6 @@ class CWallpaper : public Helpers::CContextAware {
* @return The scene's texture
*/
[[nodiscard]] virtual GLuint getWallpaperTexture () const;
/**
* Creates a new FBO for this wallpaper
*
* @param name The name of the FBO
* @param format
* @param flags
* @param scale
* @param realWidth
* @param realHeight
* @param textureWidth
* @param textureHeight
* @return
*/
std::shared_ptr<const CFBO> createFBO (
const std::string& name, ITexture::TextureFormat format, ITexture::TextureFlags flags, float scale,
uint32_t realWidth, uint32_t realHeight, uint32_t textureWidth, uint32_t textureHeight);
/**
* Creates an alias of an existing fbo
* @param alias
* @param original
*/
void aliasFBO (const std::string& alias, const std::shared_ptr<const CFBO>& original);
/**
* @return The full FBO list to work with
*/
[[nodiscard]] const std::map<std::string, std::shared_ptr<const CFBO>>& getFBOs () const;
/**
* Searches the FBO list for the given FBO
*
@ -153,14 +125,14 @@ class CWallpaper : public Helpers::CContextAware {
*
* @return
*/
static std::shared_ptr<CWallpaper> fromWallpaper (
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
static std::unique_ptr<CWallpaper> fromWallpaper (
const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
WebBrowser::CWebBrowserContext* browserContext, const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
protected:
CWallpaper (
std::shared_ptr <const WallpaperEngine::Core::CWallpaper> wallpaperData, CRenderContext& context,
const Wallpaper& wallpaperData, CRenderContext& context,
CAudioContext& audioContext, const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
@ -174,9 +146,9 @@ class CWallpaper : public Helpers::CContextAware {
*/
void setupFramebuffers ();
std::shared_ptr <const WallpaperEngine::Core::CWallpaper> m_wallpaperData;
const Wallpaper& m_wallpaperData;
[[nodiscard]] std::shared_ptr <const WallpaperEngine::Core::CWallpaper> getWallpaperData () const;
[[nodiscard]] const Wallpaper& getWallpaperData () const;
/** The FBO used for scene output */
std::shared_ptr<const CFBO> m_sceneFBO = nullptr;

60
src/WallpaperEngine/Render/Objects/CEffect.cpp
View File

@ -1,60 +0,0 @@
#include "CEffect.h"
using namespace WallpaperEngine::Render;
using namespace WallpaperEngine::Render::Objects;
CEffect::CEffect (CImage* image, const Core::Objects::CEffect* effect) :
m_image (image),
m_effect (effect) {
this->generateFBOs ();
this->generatePasses ();
}
CImage* CEffect::getImage () const {
return this->m_image;
}
const std::vector<Effects::CMaterial*>& CEffect::getMaterials () const {
return this->m_materials;
}
std::shared_ptr<const CFBO> CEffect::findFBO (const std::string& name) const {
const auto fbo = this->m_fbos.find (name);
if (fbo == this->m_fbos.end ()) {
return nullptr;
}
return fbo->second;
}
void CEffect::generatePasses () {
for (const auto& cur : this->m_effect->getMaterials ())
this->m_materials.emplace_back (new Effects::CMaterial (this, cur));
}
void CEffect::generateFBOs () {
for (const auto& cur : this->m_effect->getFbos ()) {
// TODO: IS THAT DIVISION OKAY? SHOULDN'T IT BE A MULTIPLICATION? WTF?
this->m_fbos.emplace (
cur->getName(),
new CFBO (
// TODO: SET PROPER FLAGS AND FORMAT
cur->getName (), ITexture::TextureFormat::ARGB8888,
this->m_image->getTexture ()->getFlags (), cur->getScale (),
this->m_image->getSize ().x / cur->getScale (),
this->m_image->getSize ().y / cur->getScale (),
this->m_image->getSize ().x / cur->getScale (),
this->m_image->getSize ().y / cur->getScale ()
)
);
}
}
const std::map<std::string, std::shared_ptr<const CFBO>>& CEffect::getFBOs () const {
return this->m_fbos;
}
bool CEffect::isVisible () const {
return this->m_effect->isVisible ();
}

47
src/WallpaperEngine/Render/Objects/CEffect.h
View File

@ -1,47 +0,0 @@
#pragma once
#include "WallpaperEngine/Render/CFBO.h"
#include "WallpaperEngine/Render/Objects/CImage.h"
#include "WallpaperEngine/Render/Objects/Effects/CMaterial.h"
#include "WallpaperEngine/Render/Objects/Effects/CPass.h"
#include "WallpaperEngine/PrettyPrinter/CPrettyPrinter.h"
namespace WallpaperEngine::PrettyPrinter {
class CPrettyPrinter;
}
namespace WallpaperEngine::Render::Objects::Effects {
class CMaterial;
}
namespace WallpaperEngine::Render::Objects {
class CImage;
class CEffect {
public:
CEffect (CImage* image, const Core::Objects::CEffect* effect);
[[nodiscard]] CImage* getImage () const;
[[nodiscard]] const std::vector<Effects::CMaterial*>& getMaterials () const;
[[nodiscard]] std::shared_ptr<const CFBO> findFBO (const std::string& name) const;
[[nodiscard]] bool isVisible () const;
protected:
friend class WallpaperEngine::PrettyPrinter::CPrettyPrinter;
[[nodiscard]] const std::map<std::string, std::shared_ptr<const CFBO>>& getFBOs () const;
private:
void generatePasses ();
void generateFBOs ();
CImage* m_image = nullptr;
const Core::Objects::CEffect* m_effect;
std::map<std::string, std::shared_ptr<const CFBO>> m_fbos = {};
std::vector<Effects::CMaterial*> m_materials = {};
};
} // namespace WallpaperEngine::Render::Objects

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

@ -1,11 +1,21 @@
#include "CImage.h"
#include <sstream>
#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
#include "WallpaperEngine/Data/Parsers/MaterialParser.h"
#include "WallpaperEngine/Data/Builders/UserSettingBuilder.h"
#include "WallpaperEngine/Data/Model/Object.h"
#include "WallpaperEngine/Data/Model/Material.h"
using namespace WallpaperEngine;
using namespace WallpaperEngine::Render::Objects;
using namespace WallpaperEngine::Render::Objects::Effects;
using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Data::Builders;
CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
CImage::CImage (Wallpapers::CScene& scene, const Image& image) :
Render::CObject (scene, image),
Render::CFBOProvider (&scene),
m_texture (nullptr),
m_sceneSpacePosition (GL_NONE),
m_copySpacePosition (GL_NONE),
@ -26,19 +36,19 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
m_pos (),
m_animationTime (0.0),
m_initialized (false) {
auto projection = this->getScene ()->getScene ()->getOrthogonalProjection ();
// get scene width and height to calculate positions
auto scene_width = static_cast<float> (projection->getWidth ());
auto scene_height = static_cast<float> (projection->getHeight ());
auto scene_width = static_cast<float> (scene.getWidth ());
auto scene_height = static_cast<float> (scene.getHeight ());
glm::vec3 origin = this->getImage ()->getOrigin ();
// TODO: MAKE USE OF THE USER PROPERTIES POINTER HERE TOO! SO EVERYTHING IS UPDATED ACCORDINGLY
glm::vec3 origin = this->getImage ().origin->value->getVec3 ();
glm::vec2 size = this->getSize ();
glm::vec3 scale = this->getImage ()->getScale ();
glm::vec3 scale = this->getImage ().scale->value->getVec3 ();
// fullscreen layers should use the whole projection's size
// TODO: WHAT SHOULD AUTOSIZE DO?
if (this->getImage ()->isFullscreen ()) {
if (this->getImage ().model->fullscreen) {
size = {scene_width, scene_height};
origin = {scene_width / 2, scene_height / 2, 0};
@ -53,18 +63,18 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
this->m_pos.z = origin.x + (scaledSize.x / 2);
this->m_pos.y = origin.y - (scaledSize.y / 2);
if (this->getImage ()->getAlignment ().find ("top") != std::string::npos) {
if (this->getImage ().alignment.find ("top") != std::string::npos) {
this->m_pos.y -= scaledSize.y / 2;
this->m_pos.w -= scaledSize.y / 2;
} else if (this->getImage ()->getAlignment ().find ("bottom") != std::string::npos) {
} else if (this->getImage ().alignment.find ("bottom") != std::string::npos) {
this->m_pos.y += scaledSize.y / 2;
this->m_pos.w += scaledSize.y / 2;
}
if (this->getImage ()->getAlignment ().find ("left") != std::string::npos) {
if (this->getImage ().alignment.find ("left") != std::string::npos) {
this->m_pos.x += scaledSize.x / 2;
this->m_pos.z += scaledSize.x / 2;
} else if (this->getImage ()->getAlignment ().find ("right") != std::string::npos) {
} else if (this->getImage ().alignment.find ("right") != std::string::npos) {
this->m_pos.x -= scaledSize.x / 2;
this->m_pos.z -= scaledSize.x / 2;
}
@ -76,19 +86,19 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
this->m_pos.w = scene_height / 2 - this->m_pos.w;
// detect texture (if any)
auto textures = (*this->m_image->getMaterial ()->getPasses ().begin ())->getTextures ();
auto textures = (*this->m_image.model->material->passes.begin ())->textures;
if (!textures.empty ()) {
std::string textureName = textures.begin ()->second;
if (textureName.find ("_rt_") == 0) {
this->m_texture = this->getScene ()->findFBO (textureName);
this->m_texture = this->getScene ().findFBO (textureName);
} else {
// get the first texture on the first pass (this one represents the image assigned to this object)
this->m_texture = this->getContext ().resolveTexture (textureName);
}
} else {
if (this->m_image->getMaterial ()->isSolidLayer()) {
if (this->m_image.model->solidlayer) {
size.x = scene_width;
size.y = scene_height;
}
@ -105,15 +115,15 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
std::ostringstream nameA, nameB;
// TODO: determine when _rt_imageLayerComposite and _rt_imageLayerAlbedo is used
nameA << "_rt_imageLayerComposite_" << this->getImage ()->getId () << "_a";
nameB << "_rt_imageLayerComposite_" << this->getImage ()->getId () << "_b";
nameA << "_rt_imageLayerComposite_" << this->getImage ().id << "_a";
nameB << "_rt_imageLayerComposite_" << this->getImage ().id << "_b";
this->m_currentMainFBO = this->m_mainFBO =
scene->createFBO (nameA.str (), ITexture::TextureFormat::ARGB8888, this->m_texture->getFlags (), 1,
size.x, size.y, size.x, size.y);
scene.create (nameA.str (), ITexture::TextureFormat::ARGB8888, this->m_texture->getFlags (), 1,
{size.x, size.y}, {size.x, size.y});
this->m_currentSubFBO = this->m_subFBO =
scene->createFBO (nameB.str (), ITexture::TextureFormat::ARGB8888, this->m_texture->getFlags (), 1,
size.x, size.y, size.x, size.y);
scene.create (nameB.str (), ITexture::TextureFormat::ARGB8888, this->m_texture->getFlags (), 1,
{size.x, size.y}, {size.x, size.y});
// build a list of vertices, these might need some change later (or maybe invert the camera)
GLfloat sceneSpacePosition [] = {this->m_pos.x, this->m_pos.y, 0.0f, this->m_pos.x, this->m_pos.w, 0.0f,
@ -163,13 +173,13 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
GLfloat realX = 0.0;
GLfloat realY = 0.0;
if (this->getImage ()->isPassthrough ()) {
if (this->getImage ().model->passthrough) {
x = -((this->m_pos.x + (scene_width / 2)) / size.x);
y = -((this->m_pos.w + (scene_height / 2)) / size.y);
height = (this->m_pos.y + (scene_height / 2)) / size.y;
width = (this->m_pos.z + (scene_width / 2)) / size.x;
if (this->getImage ()->isFullscreen ()) {
if (this->getImage ().model->fullscreen) {
realX = -1.0;
realY = -1.0;
realWidth = 1.0;
@ -210,7 +220,7 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
glBufferData (GL_ARRAY_BUFFER, sizeof (texcoordPass), texcoordPass, GL_STATIC_DRAW);
this->m_modelViewProjectionScreen =
this->getScene ()->getCamera ()->getProjection () * this->getScene ()->getCamera ()->getLookAt ();
this->getScene ().getCamera ().getProjection () * this->getScene ().getCamera ().getLookAt ();
this->m_modelViewProjectionScreenInverse = glm::inverse (this->m_modelViewProjectionScreen);
@ -226,62 +236,79 @@ void CImage::setup () {
return;
// TODO: SUPPORT PASSTHROUGH (IT'S A SHADER)
// passthrough images without effects are bad, do not draw them
if (this->getImage ()->isPassthrough () && this->getImage ()->getEffects ().empty ())
if (this->m_image.model->passthrough && this->m_image.effects.empty ())
return;
// generate the main material used to render the image
this->m_material = new Effects::CMaterial (
new CEffect (
this,
new Core::Objects::CEffect (
"", "", "", "", this->m_image->getProject (),
Core::UserSettings::CUserSettingBoolean::fromScalar (true),
{}, {}, {})),
this->m_image->getMaterial ()
// add blendmode to the combos
for (const auto& cur : this->getImage ().model->material->passes)
this->m_passes.push_back (
new CPass (*this, std::make_shared<CFBOProvider>(this), *cur, std::nullopt, std::nullopt, std::nullopt)
);
// add blendmode to the combos
for (const auto& cur : this->m_material->getPasses ())
this->m_passes.push_back (cur);
// TODO: MAYBE GET RID OF THE WHOLE EFFECT CLASS AND PROCESS THE EFFECTS DIRECTLY TO SIMPLIFY RENDERING CODE?
// prepare the passes list
if (!this->getImage ()->getEffects ().empty ()) {
if (!this->getImage ().effects.empty ()) {
// generate the effects used by this material
for (const auto& cur : this->getImage ()->getEffects ()) {
auto effect = new CEffect (this, cur);
for (const auto& cur : this->m_image.effects) {
auto fboProvider = std::make_shared<CFBOProvider> (this);
for (const auto& material : effect->getMaterials ())
for (const auto& pass : material->getPasses ())
this->m_passes.push_back (pass);
this->m_effects.push_back (effect);
}
// create all the fbos for this effect
for (const auto& fbo : cur->effect->fbos) {
fboProvider->create (*fbo, this->m_texture->getFlags (), this->getSize ());
}
if (this->m_image->getColorBlendMode () > 0) {
Core::Objects::Images::CMaterial::OverrideInfo overrides;
// TODO: MAKE USE OF ZIP OPERATOR IN BOOST? WAY OVERKILL JUST FOR THIS...
overrides.combos.emplace ("BLENDMODE", this->m_image->getColorBlendMode ());
const auto material =
Core::Objects::Images::CMaterial::fromFile ("materials/util/effectpassthrough.json", this->getContainer (), false, {}, &overrides);
auto curEffect = cur->effect->passes.begin ();
auto endEffect = cur->effect->passes.end ();
auto curOverride = cur->passOverrides.begin ();
auto endOverride = cur->passOverrides.end ();
// generate the main material used to render the image
this->m_colorBlendMaterial = new Effects::CMaterial (
new CEffect (
this,
new Core::Objects::CEffect (
"", "", "", "", this->m_image->getProject (),
Core::UserSettings::CUserSettingBoolean::fromScalar (true), {}, {}, {}
)
),
material
for (; curEffect != endEffect; curEffect++) {
auto curPass = (*curEffect)->material->passes.begin ();
auto endPass = (*curEffect)->material->passes.end ();
const auto override = curOverride != endOverride
? **curOverride
: std::optional<std::reference_wrapper<const ImageEffectPassOverride>> (std::nullopt);
const auto target = (*curEffect)->target.has_value ()
? *(*curEffect)->target
: std::optional<std::reference_wrapper<std::string>> (std::nullopt);
this->m_passes.push_back (
new CPass (
*this, fboProvider, **curPass, override, (*curEffect)->binds, target)
);
// add blendmode to the combos
for (const auto& cur : this->m_colorBlendMaterial->getPasses ())
this->m_passes.push_back (cur);
if (curOverride != endOverride) {
curOverride ++;
}
}
}
}
if (this->m_image.colorBlendMode > 0) {
this->m_materials.colorBlending.material = MaterialParser::load (this->getScene ().getScene ().project, "materials/util/effectpassthrough.json");
this->m_materials.colorBlending.override = std::make_unique<ImageEffectPassOverride> (ImageEffectPassOverride {
.id = -1,
.combos = {
{"BLENDMODE", this->m_image.colorBlendMode},
},
.constants = {},
.textures = {},
});
this->m_passes.push_back (
new CPass (
*this,
std::make_shared <CFBOProvider>(this),
**this->m_materials.colorBlending.material->passes.begin (),
*this->m_materials.colorBlending.override,
std::nullopt,
std::nullopt
)
);
}
// if there's more than one pass the blendmode has to be moved from the beginning to the end
@ -327,22 +354,24 @@ void CImage::setupPasses () {
pass->setViewProjectionMatrix (&this->m_viewProjectionMatrix);
// set viewport and target texture if needed
if (pass->getMaterial ()->getMaterial ()->hasTarget ()) {
if (pass->getTarget ().has_value ()) {
// setup target texture
std::string target = pass->getMaterial ()->getMaterial ()->getTarget ();
drawTo = pass->getMaterial ()->getEffect ()->findFBO (target);
std::string target = pass->getTarget ().value ();
drawTo = pass->getFBOProvider ()->find (target);
// spacePosition = this->getPassSpacePosition ();
// not a local fbo, try to find a scene fbo with the same name
if (drawTo == nullptr)
if (drawTo == nullptr) {
// this one throws if no fbo was found
drawTo = this->getScene ()->findFBO (target);
drawTo = this->getScene ().findFBO (target);
}
}
// determine if it's the last element in the list as this is a screen-copy-like process
else if (std::next (cur) == end && this->getImage ()->isVisible ()) {
// TODO: PROPERLY CHECK IF THIS IS ALL THAT'S NEEDED
else if (std::next (cur) == end && this->getImage ().visible->value->getBool ()) {
// TODO: PROPERLY CHECK EFFECT'S VISIBILITY AND TAKE IT INTO ACCOUNT
spacePosition = this->getSceneSpacePosition ();
drawTo = this->getScene ()->getFBO ();
drawTo = this->getScene ().getFBO ();
projection = &this->m_modelViewProjectionScreen;
inverseProjection = &this->m_modelViewProjectionScreenInverse;
}
@ -357,7 +386,7 @@ void CImage::setupPasses () {
texcoord = this->getTexCoordPass ();
drawTo = prevDrawTo;
if (!pass->getMaterial ()->getMaterial ()->hasTarget ())
if (!pass->getTarget ().has_value ())
this->pinpongFramebuffer (&drawTo, &asInput);
}
}
@ -387,17 +416,17 @@ void CImage::render () {
// update the position if required
// TODO: There's more images that are not affected by parallax, autosize or fullscreen are not affected
if (this->getScene ()->getScene ()->isCameraParallax () && !this->getImage ()->isFullscreen ())
if (this->getScene ().getScene ().camera.parallax.enabled && !this->getImage ().model->fullscreen)
this->updateScreenSpacePosition ();
#if !NDEBUG
std::string str = "Rendering ";
if (this->getScene ()->getScene ()->isBloom () && this->getId () == -1)
if (this->getScene ().getScene ().camera.bloom.enabled->value->getBool () && this->getId () == -1)
str += "bloom";
else {
str += this->getImage ()->getName () + " (" + std::to_string (this->getId ()) + ", " +
this->getImage ()->getMaterial ()->getName () + ")";
str += this->getImage ().name + " (" + std::to_string (this->getId ()) + ", " +
this->getImage ().model->material->filename + ")";
}
glPushDebugGroup (GL_DEBUG_SOURCE_APPLICATION, 0, -1, str.c_str ());
@ -421,20 +450,21 @@ void CImage::render () {
void CImage::updateScreenSpacePosition () {
// do not perform any changes to the image based on the parallax if it was explicitly disabled
if (this->getScene ()->getContext ().getApp ().getContext ().settings.mouse.disableparallax) {
if (this->getScene ().getContext ().getApp ().getContext ().settings.mouse.disableparallax) {
return;
}
const double parallaxAmount = this->getScene ()->getScene ()->getCameraParallaxAmount ();
const glm::vec2 depth = this->getImage ()->getParallaxDepth ();
const glm::vec2* displacement = this->getScene ()->getParallaxDisplacement ();
const double parallaxAmount = this->getScene ().getScene ().camera.parallax.amount;
const glm::vec2 depth = this->getImage ().parallaxDepth;
const glm::vec2* displacement = this->getScene ().getParallaxDisplacement ();
float x = (depth.x + parallaxAmount) * displacement->x * this->getSize ().x;
float y = (depth.y + parallaxAmount) * displacement->y * this->getSize ().x;
this->m_modelViewProjectionScreen = glm::translate (this->getScene ()->getCamera ()->getProjection () *
this->getScene ()->getCamera ()->getLookAt (),
{x, y, 0.0f});
this->m_modelViewProjectionScreen = glm::translate (
this->getScene ().getCamera ().getProjection () * this->getScene ().getCamera ().getLookAt (),
{x, y, 0.0f}
);
}
std::shared_ptr<const ITexture> CImage::getTexture () const {
@ -445,7 +475,7 @@ double CImage::getAnimationTime () const {
return this->m_animationTime;
}
const Core::Objects::CImage* CImage::getImage () const {
const Image& CImage::getImage () const {
return this->m_image;
}
@ -459,7 +489,7 @@ const Effects::CMaterial* CImage::getMaterial () const {
glm::vec2 CImage::getSize () const {
if (this->m_texture == nullptr)
return this->getImage ()->getSize ();
return this->getImage ().size;
return {this->m_texture->getRealWidth (), this->m_texture->getRealHeight ()};
}

19
src/WallpaperEngine/Render/Objects/CImage.h
View File

@ -1,10 +1,6 @@
#pragma once
#include "WallpaperEngine/Core/Objects/CImage.h"
#include "WallpaperEngine/Render/CObject.h"
#include "WallpaperEngine/Render/Objects/CEffect.h"
#include "WallpaperEngine/Render/Objects/Effects/CMaterial.h"
#include "WallpaperEngine/Render/Objects/Effects/CPass.h"
#include "WallpaperEngine/Render/Wallpapers/CScene.h"
@ -25,16 +21,16 @@ class CPass;
namespace WallpaperEngine::Render::Objects {
class CEffect;
class CImage final : public CObject {
class CImage final : public CObject, public CFBOProvider {
friend CObject;
public:
CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image);
CImage (Wallpapers::CScene& scene, const Image& image);
void setup ();
void render () override;
[[nodiscard]] const Core::Objects::CImage* getImage () const;
[[nodiscard]] const Image& getImage () const;
[[nodiscard]] const std::vector<CEffect*>& getEffects () const;
[[nodiscard]] const Effects::CMaterial* getMaterial () const;
[[nodiscard]] glm::vec2 getSize () const;
@ -83,7 +79,7 @@ class CImage final : public CObject {
std::shared_ptr<const CFBO> m_currentMainFBO = nullptr;
std::shared_ptr<const CFBO> m_currentSubFBO = nullptr;
const Core::Objects::CImage* m_image;
const Image& m_image;
std::vector<CEffect*> m_effects = {};
Effects::CMaterial* m_material = nullptr;
@ -95,5 +91,12 @@ class CImage final : public CObject {
double m_animationTime = 0.0;
bool m_initialized = false;
struct {
struct {
MaterialUniquePtr material;
ImageEffectPassOverrideUniquePtr override;
} colorBlending;
} m_materials;
};
} // namespace WallpaperEngine::Render::Objects

12
src/WallpaperEngine/Render/Objects/CSound.cpp
View File

@ -4,7 +4,7 @@
using namespace WallpaperEngine::Render::Objects;
CSound::CSound (Wallpapers::CScene* scene, const Core::Objects::CSound* sound) :
CSound::CSound (Wallpapers::CScene& scene, const Sound& sound) :
CObject (scene, sound),
m_sound (sound) {
if (this->getContext ().getApp ().getContext ().settings.audio.enabled)
@ -21,19 +21,19 @@ CSound::~CSound() {
}
void CSound::load () {
for (const auto& cur : this->m_sound->getSounds ()) {
for (const auto& cur : this->m_sound.sounds) {
uint32_t filesize = 0;
std::shared_ptr<const uint8_t[]> filebuffer = this->getContainer ()->readFile (cur, &filesize);
std::shared_ptr<const uint8_t[]> filebuffer = this->getContainer ().readFile (cur, &filesize);
auto stream = new Audio::CAudioStream (this->getScene ()->getAudioContext (), filebuffer, filesize);
auto stream = new Audio::CAudioStream (this->getScene ().getAudioContext (), filebuffer, filesize);
stream->setRepeat (this->m_sound->isRepeat ());
stream->setRepeat (this->m_sound.playbackmode.has_value() && this->m_sound.playbackmode == "loop");
this->m_audioStreams.push_back (stream);
this->m_soundBuffer.push_back (filebuffer);
// add the stream to the context so it can be played
this->getScene ()->getAudioContext ().addStream (stream);
this->getScene ().getAudioContext ().addStream (stream);
}
}

8
src/WallpaperEngine/Render/Objects/CSound.h
View File

@ -1,7 +1,5 @@
#pragma once
#include "WallpaperEngine/Core/Objects/CSound.h"
#include "WallpaperEngine/Audio/CAudioStream.h"
#include "WallpaperEngine/Render/CObject.h"
@ -12,9 +10,11 @@ class CScene;
}
namespace WallpaperEngine::Render::Objects {
using namespace WallpaperEngine::Data::Model;
class CSound final : public CObject {
public:
CSound (Wallpapers::CScene* scene, const Core::Objects::CSound* sound);
CSound (Wallpapers::CScene& scene, const Sound& sound);
~CSound () override;
void render () override;
@ -26,6 +26,6 @@ class CSound final : public CObject {
std::vector<std::shared_ptr<const uint8_t[]>> m_soundBuffer = {};
std::vector<Audio::CAudioStream*> m_audioStreams = {};
const Core::Objects::CSound* m_sound;
const Sound& m_sound;
};
} // namespace WallpaperEngine::Render::Objects

34
src/WallpaperEngine/Render/Objects/Effects/CMaterial.cpp
View File

@ -1,34 +0,0 @@
#include "CMaterial.h"
using namespace WallpaperEngine::Render::Objects;
using namespace WallpaperEngine::Render::Objects::Effects;
CMaterial::CMaterial (const Render::Objects::CEffect* effect, const Core::Objects::Images::CMaterial* material) :
Helpers::CContextAware (effect->getImage ()),
m_effect (effect),
m_material (material) {
this->generatePasses ();
}
const std::vector<CPass*>& CMaterial::getPasses () const {
return this->m_passes;
}
CImage* CMaterial::getImage () const {
return this->m_effect->getImage ();
}
void CMaterial::generatePasses () {
// these are simple now, just create the entries and done
for (const auto& cur : this->m_material->getPasses ())
this->m_passes.emplace_back (new CPass (this, cur));
}
const Core::Objects::Images::CMaterial* CMaterial::getMaterial () const {
return this->m_material;
}
const CEffect* CMaterial::getEffect () const {
return this->m_effect;
}

42
src/WallpaperEngine/Render/Objects/Effects/CMaterial.h
View File

@ -1,42 +0,0 @@
#pragma once
#include "WallpaperEngine/Core/Objects/CEffect.h"
#include "WallpaperEngine/Core/Objects/Images/CMaterial.h"
#include "WallpaperEngine/Render/Objects/CEffect.h"
#include "WallpaperEngine/Render/Objects/Effects/CPass.h"
#include "WallpaperEngine/Render/Helpers/CContextAware.h"
#include "CPass.h"
using namespace WallpaperEngine;
namespace WallpaperEngine::Render::Objects {
class CEffect;
class CImage;
} // namespace WallpaperEngine::Render::Objects
namespace WallpaperEngine::Render::Objects::Effects {
class CPass;
class CMaterial final : public Helpers::CContextAware {
friend class CPass;
public:
CMaterial (const Render::Objects::CEffect* effect, const Core::Objects::Images::CMaterial* material);
[[nodiscard]] const std::vector<CPass*>& getPasses () const;
[[nodiscard]] CImage* getImage () const;
[[nodiscard]] const Core::Objects::Images::CMaterial* getMaterial () const;
[[nodiscard]] const CEffect* getEffect () const;
private:
void generatePasses ();
const Render::Objects::CEffect* m_effect;
const Core::Objects::Images::CMaterial* m_material;
std::vector<CPass*> m_passes = {};
};
} // namespace WallpaperEngine::Render::Objects::Effects

156
src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
View File

@ -1,8 +1,15 @@
#include "CPass.h"
#include "WallpaperEngine/Render/CFBO.h"
#include <sstream>
#include <utility>
#include "WallpaperEngine/Render/Helpers/CContextAware.h"
#include "WallpaperEngine/Data/Model/Effect.h"
#include "WallpaperEngine/Data/Model/Material.h"
#include "WallpaperEngine/Render/Objects/CImage.h"
#include "WallpaperEngine/Render/CFBO.h"
#include "WallpaperEngine/Core/Projects/CProperty.h"
#include "WallpaperEngine/Core/Projects/CPropertyColor.h"
#include "WallpaperEngine/Core/Projects/CPropertyCombo.h"
@ -25,19 +32,35 @@
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h"
#include "WallpaperEngine/Logging/CLog.h"
using namespace WallpaperEngine::Core::Objects::Effects::Constants;
using namespace WallpaperEngine::Render::Shaders::Variables;
using namespace WallpaperEngine;
using namespace WallpaperEngine::Render;
using namespace WallpaperEngine::Render::Objects;
using namespace WallpaperEngine::Core::Objects::Effects::Constants;
using namespace WallpaperEngine::Render::Shaders::Variables;
using namespace WallpaperEngine::Render::Objects::Effects;
extern float g_Time;
extern float g_Daytime;
CPass::CPass (CMaterial* material, const Core::Objects::Images::Materials::CPass* pass) :
Helpers::CContextAware (material),
m_material (material),
const TextureMap DEFAULT_BINDS = {};
const ImageEffectPassOverride DEFAULT_OVERRIDE = {};
CPass::CPass (
CImage& image, std::shared_ptr<const CFBOProvider> fboProvider, const MaterialPass& pass,
std::optional<std::reference_wrapper<const ImageEffectPassOverride>> override,
std::optional<std::reference_wrapper<const TextureMap>> binds,
std::optional<std::reference_wrapper<std::string>> target
) :
Helpers::CContextAware (image),
m_image (image),
m_pass (pass),
m_blendingmode (pass->getBlendingMode ()) {
m_blendingmode (pass.blending),
m_binds (binds.has_value () ? binds.value ().get () : DEFAULT_BINDS),
m_override (override.has_value () ? override.value ().get () : DEFAULT_OVERRIDE),
m_fboProvider (fboProvider),
m_target (target) {
this->setupShaders ();
this->setupShaderVariables ();
}
@ -51,25 +74,21 @@ std::shared_ptr<const ITexture> CPass::resolveTexture (std::shared_ptr<const ITe
}
// first check in the binds and replace it if necessary
const auto it = this->m_material->getMaterial ()->getTextureBinds ().find (index);
const auto it = this->m_binds.find (index);
if (it == this->m_material->getMaterial ()->getTextureBinds ().end ())
if (it == this->m_binds.end ())
return expected;
// a bind named "previous" is just another way of telling it to use whatever texture there was already
if (it->second->getName () == "previous")
if (it->second == "previous")
return previous ?: expected;
// the bind actually has a name, search the FBO in the effect and return it
return this->resolveFBO (it->second->getName ());
return this->resolveFBO (it->second);
}
std::shared_ptr<const CFBO> CPass::resolveFBO (const std::string& name) const {
auto fbo = this->m_material->getEffect()->findFBO (name);
if (fbo == nullptr) {
fbo = this->m_material->getImage ()->getScene ()->findFBO (name);
}
auto fbo = this->m_fboProvider->find (name);
if (fbo == nullptr) {
sLog.exception ("Tried to resolve and FBO without any luck: ", name);
@ -100,19 +119,19 @@ void CPass::setupRenderFramebuffer () {
}
// set depth testing
if (this->m_pass->getDepthTest () == "disabled") {
if (this->m_pass.depthtest == "disabled") {
glDisable (GL_DEPTH_TEST);
} else {
glEnable (GL_DEPTH_TEST);
}
if (this->m_pass->getCullingMode () == "nocull") {
if (this->m_pass.cullmode == "nocull") {
glDisable (GL_CULL_FACE);
} else {
glEnable (GL_CULL_FACE);
}
if (this->m_pass->getDepthWrite () == "disabled") {
if (this->m_pass.depthwrite == "disabled") {
glDepthMask (false);
} else {
glDepthMask (true);
@ -133,7 +152,7 @@ void CPass::setupRenderTexture () {
if (texture->isAnimated ()) {
// calculate current texture and frame
double currentRenderTime = fmod (static_cast<double> (this->getContext ().getDriver ().getRenderTime ()),
this->m_material->getImage ()->getAnimationTime ());
this->m_image.getAnimationTime ());
for (const auto& frameCur : texture->getFrames ()) {
currentRenderTime -= frameCur->frametime;
@ -246,8 +265,8 @@ void CPass::setupRenderAttributes () {
#if !NDEBUG
glObjectLabel (GL_BUFFER, *cur->value, -1,
("Image " + std::to_string (this->getMaterial ()->getImage ()->getId ()) + " Pass " +
this->m_pass->getShader () + " " + cur->name)
("Image " + std::to_string (this->m_image.getId ()) + " Pass " +
this->m_pass.shader + " " + cur->name)
.c_str ());
#endif /* DEBUG */
}
@ -287,8 +306,12 @@ void CPass::render () {
this->cleanupRenderSetup ();
}
const CMaterial* CPass::getMaterial () const {
return this->m_material;
std::shared_ptr<const CFBOProvider> CPass::getFBOProvider () const {
return this->m_fboProvider;
}
const CImage& CPass::getImage () const {
return this->m_image;
}
void CPass::setDestination (std::shared_ptr<const CFBO> drawTo) {
@ -331,10 +354,14 @@ void CPass::setPosition (GLuint position) {
this->a_Position = position;
}
const Core::Objects::Images::Materials::CPass* CPass::getPass () const {
const MaterialPass& CPass::getPass () const {
return this->m_pass;
}
const std::optional<std::reference_wrapper<std::string>> CPass::getTarget () const {
return this->m_target;
}
Render::Shaders::CShader* CPass::getShader () const {
return this->m_shader;
}
@ -379,10 +406,10 @@ GLuint CPass::compileShader (const char* shader, GLuint type) {
void CPass::setupShaders () {
// ensure the constants are defined
std::shared_ptr<const ITexture> texture0 = this->m_material->getImage ()->getTexture ();
std::shared_ptr<const ITexture> texture0 = this->m_image.getTexture ();
// copy the combos from the pass
this->m_combos.insert (this->m_pass->getCombos ().begin (), this->m_pass->getCombos ().end ());
this->m_combos.insert (this->m_pass.combos.begin (), this->m_pass.combos.end ());
// TODO: THE VALUES ARE THE SAME AS THE ENUMERATION, SO MAYBE IT HAS TO BE SPECIFIED FOR THE TEXTURE 0 OF ALL
// ELEMENTS?
@ -398,8 +425,8 @@ void CPass::setupShaders () {
// TODO: USED TO BUILD THE TEXTURES LATER
// use the combos copied from the pass so it includes the texture format
this->m_shader = new Render::Shaders::CShader (
this->getMaterial ()->getImage ()->getContainer (), this->m_pass->getShader (), this->m_combos,
this->m_pass->getTextures (), this->m_pass->getConstants ()
this->m_image.getContainer (), this->m_pass.shader, this->m_combos,
this->m_pass.textures, this->m_override.constants
);
const auto shaders = Shaders::CGLSLContext::get ().toGlsl (
@ -441,9 +468,9 @@ void CPass::setupShaders () {
}
#if !NDEBUG
glObjectLabel (GL_PROGRAM, this->m_programID, -1, this->m_pass->getShader ().c_str ());
glObjectLabel (GL_SHADER, vertexShaderID, -1, (this->m_pass->getShader () + ".vert").c_str ());
glObjectLabel (GL_SHADER, fragmentShaderID, -1, (this->m_pass->getShader () + ".frag").c_str ());
glObjectLabel (GL_PROGRAM, this->m_programID, -1, this->m_pass.shader.c_str ());
glObjectLabel (GL_SHADER, vertexShaderID, -1, (this->m_pass.shader + ".vert").c_str ());
glObjectLabel (GL_SHADER, fragmentShaderID, -1, (this->m_pass.shader + ".frag").c_str ());
#endif /* DEBUG */
// after being liked shaders can be dettached and deleted
@ -507,7 +534,7 @@ void CPass::setupTextureUniforms () {
}
}
for (const auto& [index, textureName] : this->m_pass->getTextures ()) {
for (const auto& [index, textureName] : this->m_pass.textures) {
// ignore first texture as that'll be the input of the previous pass (or the image if it's the first pass)
if (index == 0) {
continue;
@ -516,23 +543,23 @@ void CPass::setupTextureUniforms () {
if (textureName.find ("_rt_") == 0) {
this->m_textures[index] = this->resolveFBO (textureName);
} else if (!textureName.empty ()) {
this->m_textures[index] = this->m_material->getImage ()->getContext ().resolveTexture (textureName);
this->m_textures[index] = this->m_image.getContext ().resolveTexture (textureName);
}
}
// binds are set last as they're the most important to be set
for (const auto& [index, bind] : this->m_material->getMaterial ()->getTextureBinds ()) {
if (bind->getName () == "previous") {
for (const auto& [index, bind] : this->m_binds) {
if (bind == "previous") {
// use nullptr as indication for "previous" texture
this->m_textures [index] = nullptr;
} else {
// a normal bind, search for the corresponding FBO and set it
this->m_textures [index] = this->resolveFBO (bind->getName ());
this->m_textures [index] = this->resolveFBO (bind);
}
}
// resolve the main texture
std::shared_ptr<const ITexture> texture = this->resolveTexture (this->m_material->getImage ()->getTexture (), 0);
std::shared_ptr<const ITexture> texture = this->resolveTexture (this->m_image.getTexture (), 0);
// register all the texture uniforms with correct values
this->addUniform ("g_Texture0", 0);
this->addUniform ("g_Texture1", 1);
@ -557,21 +584,22 @@ void CPass::setupTextureUniforms () {
void CPass::setupUniforms () {
this->setupTextureUniforms ();
const auto projection = this->getMaterial ()->getImage ()->getScene ()->getScene ()->getOrthogonalProjection ();
const auto& image = this->m_image.getImage ();
const auto& scene = this->m_image.getScene ();
const auto& sceneData = this->m_image.getScene ().getScene ();
const auto& recorder = this->m_image.getScene ().getAudioContext ().getRecorder ();
// lighting variables
this->addUniform ("g_LightAmbientColor",
this->m_material->getImage ()->getScene ()->getScene ()->getAmbientColor ());
this->addUniform ("g_LightSkylightColor",
this->m_material->getImage ()->getScene ()->getScene ()->getSkylightColor ());
this->addUniform ("g_LightAmbientColor", sceneData.colors.ambient);
this->addUniform ("g_LightSkylightColor", sceneData.colors.skylight);
// register variables like brightness and alpha with some default value
this->addUniform ("g_Brightness", this->m_material->getImage ()->getImage ()->getBrightness ());
this->addUniform ("g_UserAlpha", this->m_material->getImage ()->getImage ()->getAlpha ());
this->addUniform ("g_Alpha", this->m_material->getImage ()->getImage ()->getAlpha ());
this->addUniform ("g_Color", this->m_material->getImage ()->getImage ()->getColor ());
this->addUniform ("g_Color4", glm::vec4 (this->m_material->getImage ()->getImage ()->getColor (), 1));
this->addUniform ("g_Brightness", image.brightness);
this->addUniform ("g_UserAlpha", image.alpha->value->getFloat ());
this->addUniform ("g_Alpha", image.alpha->value->getFloat ());
this->addUniform ("g_Color", image.color->value->getVec3 ());
this->addUniform ("g_Color4", image.color->value->getVec4());
// TODO: VALIDATE THAT G_COMPOSITECOLOR REALLY COMES FROM THIS ONE
this->addUniform ("g_CompositeColor", this->m_material->getImage ()->getImage ()->getColor ());
this->addUniform ("g_CompositeColor", image.color->value->getVec3 ());
// add some external variables
this->addUniform ("g_Time", &g_Time);
this->addUniform ("g_Daytime", &g_Daytime);
@ -581,24 +609,18 @@ void CPass::setupUniforms () {
this->addUniform ("g_ModelMatrix", &this->m_modelMatrix);
this->addUniform ("g_NormalModelMatrix", glm::identity<glm::mat3> ());
this->addUniform ("g_ViewProjectionMatrix", &this->m_viewProjectionMatrix);
this->addUniform ("g_PointerPosition", this->m_material->getImage ()->getScene ()->getMousePosition ());
this->addUniform ("g_PointerPositionLast", this->m_material->getImage ()->getScene ()->getMousePositionLast ());
this->addUniform ("g_PointerPosition", scene.getMousePosition ());
this->addUniform ("g_PointerPositionLast", scene.getMousePositionLast ());
this->addUniform ("g_EffectTextureProjectionMatrix", glm::mat4 (1.0));
this->addUniform ("g_EffectTextureProjectionMatrixInverse", glm::mat4 (1.0));
this->addUniform ("g_TexelSize", glm::vec2 (1.0 / projection->getWidth (), 1.0 / projection->getHeight ()));
this->addUniform ("g_TexelSizeHalf", glm::vec2 (0.5 / projection->getWidth (), 0.5 / projection->getHeight ()));
this->addUniform ("g_AudioSpectrum16Left",
this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio16, 16);
this->addUniform ("g_AudioSpectrum16Right",
this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio16, 16);
this->addUniform ("g_AudioSpectrum32Left",
this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio32, 32);
this->addUniform ("g_AudioSpectrum32Right",
this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio32, 32);
this->addUniform ("g_AudioSpectrum64Left",
this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio64, 64);
this->addUniform ("g_AudioSpectrum64Right",
this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio64, 64);
this->addUniform ("g_TexelSize", glm::vec2 (1.0 / scene.getWidth (), 1.0 / scene.getHeight ()));
this->addUniform ("g_TexelSizeHalf", glm::vec2 (0.5 / scene.getWidth (), 0.5 / scene.getHeight ()));
this->addUniform ("g_AudioSpectrum16Left", recorder.audio16, 16);
this->addUniform ("g_AudioSpectrum16Right", recorder.audio16, 16);
this->addUniform ("g_AudioSpectrum32Left", recorder.audio32, 32);
this->addUniform ("g_AudioSpectrum32Right", recorder.audio32, 32);
this->addUniform ("g_AudioSpectrum64Left", recorder.audio64, 64);
this->addUniform ("g_AudioSpectrum64Right", recorder.audio64, 64);
}
void CPass::addAttribute (const std::string& name, GLint type, GLint elements, const GLuint* value) {
@ -680,7 +702,7 @@ void CPass::setupShaderVariables () {
this->addUniform (cur);
// find variables in the shaders and set the value with the constants if possible
for (const auto& [name, value] : this->m_pass->getConstants ()) {
for (const auto& [name, value] : this->m_override.constants) {
const auto parameters = this->m_shader->findParameter (name);
// variable not found, can be ignored
@ -692,7 +714,7 @@ void CPass::setupShaderVariables () {
// this takes care of all possible casts, even invalid ones, which will use whatever default behaviour
// of the underlying CDynamicValue used for the value
this->addUniform (var, value);
this->addUniform (var, value.get ());
}
}

34
src/WallpaperEngine/Render/Objects/Effects/CPass.h
View File

@ -5,25 +5,31 @@
#include "WallpaperEngine/Assets/ITexture.h"
#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
#include "WallpaperEngine/Core/Objects/Images/Materials/CPass.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingValue.h"
#include "WallpaperEngine/Render/CFBO.h"
#include "WallpaperEngine/Render/Objects/Effects/CMaterial.h"
#include "WallpaperEngine/Render/CFBOProvider.h"
#include "WallpaperEngine/Render/Helpers/CContextAware.h"
#include "WallpaperEngine/Render/Shaders/CShader.h"
#include "WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h"
#include "WallpaperEngine/Core/UserSettings/CUserSettingValue.h"
#include "WallpaperEngine/Render/Helpers/CContextAware.h"
namespace WallpaperEngine::Render::Objects {
class CImage;
}
namespace WallpaperEngine::Render::Objects::Effects {
using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Render::Shaders::Variables;
using namespace WallpaperEngine::Core::Projects;
using namespace WallpaperEngine::Core::Objects::Effects::Constants;
class CMaterial;
using namespace WallpaperEngine::Data::Model;
class CPass final : public Helpers::CContextAware {
public:
CPass (CMaterial* material, const Core::Objects::Images::Materials::CPass* pass);
CPass (
CImage& image, std::shared_ptr<const CFBOProvider> fboProvider, const MaterialPass& pass,
std::optional<std::reference_wrapper<const ImageEffectPassOverride>> override,
std::optional<std::reference_wrapper<const TextureMap>> binds,
std::optional<std::reference_wrapper<std::string>> target);
void render ();
@ -39,8 +45,10 @@ class CPass final : public Helpers::CContextAware {
[[nodiscard]] const std::string& getBlendingMode () const;
[[nodiscard]] std::shared_ptr<const CFBO> resolveFBO (const std::string& name) const;
[[nodiscard]] const CMaterial* getMaterial () const;
[[nodiscard]] const Core::Objects::Images::Materials::CPass* getPass () const;
[[nodiscard]] std::shared_ptr<const CFBOProvider> getFBOProvider () const;
[[nodiscard]] const CImage& getImage () const;
[[nodiscard]] const MaterialPass& getPass () const;
[[nodiscard]] const std::optional<std::reference_wrapper<std::string>> getTarget () const;
[[nodiscard]] Render::Shaders::CShader* getShader () const;
private:
@ -148,8 +156,12 @@ class CPass final : public Helpers::CContextAware {
std::shared_ptr<const ITexture> resolveTexture (std::shared_ptr<const ITexture> expected, int index, std::shared_ptr<const ITexture> previous = nullptr);
CMaterial* m_material = nullptr;
const Core::Objects::Images::Materials::CPass* m_pass;
CImage& m_image;
std::shared_ptr<const CFBOProvider> m_fboProvider;
const MaterialPass& m_pass;
const TextureMap& m_binds;
const ImageEffectPassOverride& m_override;
std::optional<std::reference_wrapper<std::string>> m_target;
std::map<int, std::shared_ptr<const CFBO>> m_fbos = {};
std::map<std::string, int> m_combos = {};
std::vector<AttribEntry*> m_attribs = {};

9
src/WallpaperEngine/Render/Shaders/CShader.cpp
View File

@ -18,17 +18,18 @@ using namespace WallpaperEngine::Assets;
namespace WallpaperEngine::Render::Shaders {
CShader::CShader (
std::shared_ptr<const CContainer> container, std::string filename, const std::map<std::string, int>& combos,
const std::map<int, std::string>& textures, const std::map<std::string, const CShaderConstant*>& constants
const CContainer& container, std::string filename,
const ComboMap& combos, const TextureMap& textures,
const ShaderConstantMap& constants
) :
m_file (std::move (filename)),
m_combos (combos),
m_passTextures (textures),
m_vertex (
CGLSLContext::UnitType_Vertex, filename, container->readVertexShader (filename),
CGLSLContext::UnitType_Vertex, filename, container.readVertexShader (filename),
container, constants, textures, combos),
m_fragment (
CGLSLContext::UnitType_Fragment, filename, container->readFragmentShader (filename),
CGLSLContext::UnitType_Fragment, filename, container.readFragmentShader (filename),
container, constants, textures, combos) {
// link shaders between them
this->m_vertex.linkToUnit (&this->m_fragment);

13
src/WallpaperEngine/Render/Shaders/CShader.h
View File

@ -13,10 +13,13 @@
#include "CShaderUnit.h"
#include "CGLSLContext.h"
#include "WallpaperEngine/Data/Model/Types.h"
namespace WallpaperEngine::Render::Shaders {
using json = nlohmann::json;
using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Core::Objects::Effects::Constants;
using namespace WallpaperEngine::Data::Model;
/**
* A basic shader loader that adds basic function definitions to every loaded shader
@ -42,9 +45,9 @@ class CShader {
* @param recursive Whether the compiler should add base definitions or not
*/
CShader (
std::shared_ptr<const CContainer> container, std::string filename,
const std::map<std::string, int>& combos, const std::map<int, std::string>& textures,
const std::map<std::string, const CShaderConstant*>& constants);
const CContainer& container, std::string filename,
const ComboMap& combos, const TextureMap& textures,
const ShaderConstantMap& constants);
/**
* @return The vertex's shader coude for OpenGL to use
*/
@ -93,10 +96,10 @@ class CShader {
/**
* The combos the shader should be generated with
*/
const std::map<std::string, int>& m_combos;
const ComboMap& m_combos;
/**
* The list of textures the pass knows about
*/
const std::map<int, std::string> m_passTextures;
const TextureMap m_passTextures;
};
} // namespace WallpaperEngine::Render::Shaders

18
src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
View File

@ -56,13 +56,12 @@ using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Render::Shaders;
CShaderUnit::CShaderUnit (
CGLSLContext::UnitType type, std::string file, std::string content, std::shared_ptr<const CContainer> container,
const std::map<std::string, const CShaderConstant*>& constants, const std::map<int, std::string>& passTextures,
const std::map<std::string, int>& combos
CGLSLContext::UnitType type, std::string file, std::string content, const CContainer& container,
const ShaderConstantMap& constants, const TextureMap& passTextures, const ComboMap& combos
) :
m_type (type),
m_link (nullptr),
m_container (std::move(container)),
m_container (container),
m_file (std::move (file)),
m_constants (constants),
m_content (std::move(content)),
@ -155,7 +154,7 @@ void CShaderUnit::preprocessIncludes () {
content += "// begin of include from file ";
content += filename;
content += "\n";
content += this->m_container->readIncludeShader (filename);
content += this->m_container.readIncludeShader (filename);
content += "\n// end of included from file ";
content += filename;
content += "\n";
@ -194,7 +193,7 @@ void CShaderUnit::preprocessIncludes () {
content = "// begin of include from file ";
content += filename;
content += "\n";
content += this->m_container->readIncludeShader (filename);
content += this->m_container.readIncludeShader (filename);
content += "\n// end of included from file ";
content += filename;
content += "\n";
@ -382,6 +381,7 @@ void CShaderUnit::parseParameterConfiguration (
// TODO: SUPPORT VALUES FOR ALL THESE TYPES
// TODO: MAYBE EVEN CONNECT THESE TO THE CORRESPONDING PROPERTY SO THINGS ARE UPDATED AS THE ORIGIN VALUES CHANGE?
// TODO: MAKE USE OF PARSERS INSTEAD OF CORE
if (type == "vec4") {
parameter = new Variables::CShaderVariableVector4 (WallpaperEngine::Core::aToVector4 (*defvalue));
} else if (type == "vec3") {
@ -500,11 +500,11 @@ void CShaderUnit::parseParameterConfiguration (
}
}
const std::map<std::string, int>& CShaderUnit::getCombos () const {
const ComboMap& CShaderUnit::getCombos () const {
return this->m_combos;
}
const std::map<std::string, int>& CShaderUnit::getDiscoveredCombos () const {
const ComboMap& CShaderUnit::getDiscoveredCombos () const {
return this->m_discoveredCombos;
}
@ -565,6 +565,6 @@ const std::string& CShaderUnit::compile () {
const std::vector<Variables::CShaderVariable*>& CShaderUnit::getParameters () const {
return this->m_parameters;
}
const std::map<int, std::string>& CShaderUnit::getTextures () const {
const TextureMap& CShaderUnit::getTextures () const {
return this->m_defaultTextures;
}

28
src/WallpaperEngine/Render/Shaders/CShaderUnit.h
View File

@ -11,19 +11,23 @@
#include "WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h"
#include "nlohmann/json.hpp"
#include "WallpaperEngine/Data/Model/Types.h"
namespace WallpaperEngine::Render::Shaders {
using json = nlohmann::json;
using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::Core::Objects::Effects::Constants;
using namespace WallpaperEngine::Data::Model;
/**
* Represents a whole shader unit
*/
class CShaderUnit {
public:
CShaderUnit (
CGLSLContext::UnitType type, std::string file, std::string content, std::shared_ptr<const CContainer> container,
const std::map<std::string, const CShaderConstant*>& constants, const std::map<int, std::string>& passTextures,
const std::map<std::string, int>& combos);
CGLSLContext::UnitType type, std::string file, std::string content, const CContainer& container,
const ShaderConstantMap& constants, const TextureMap& passTextures,
const ComboMap& combos);
~CShaderUnit () = default;
/**
@ -49,15 +53,15 @@ class CShaderUnit {
/**
* @return The textures this shader unit requires
*/
[[nodiscard]] const std::map<int, std::string>& getTextures () const;
[[nodiscard]] const TextureMap& getTextures () const;
/**
* @return The combos set for this shader unit by the configuration
*/
[[nodiscard]] const std::map<std::string, int>& getCombos () const;
[[nodiscard]] const ComboMap& getCombos () const;
/**
* @return Other combos detected by this shader unit during the preprocess
*/
[[nodiscard]] const std::map<std::string, int>& getDiscoveredCombos () const;
[[nodiscard]] const ComboMap& getDiscoveredCombos () const;
protected:
/**
@ -127,11 +131,11 @@ class CShaderUnit {
/**
* Pre-defined values for the combos
*/
const std::map<std::string, int>& m_combos;
const ComboMap& m_combos;
/**
* The combos discovered in the pre-processing step that were not in the combos list
*/
std::map<std::string, int> m_discoveredCombos = {};
ComboMap m_discoveredCombos = {};
/**
* The combos used by this unit that should be added
*/
@ -139,11 +143,11 @@ class CShaderUnit {
/**
* The constants defined for this unit
*/
const std::map<std::string, const CShaderConstant*>& m_constants;
const ShaderConstantMap& m_constants;
/** The textures that are already applied to this shader */
const std::map<int, std::string> m_passTextures;
const TextureMap m_passTextures = {};
/** The default textures to use when a texture is not applied in a given slot */
std::map<int, std::string> m_defaultTextures = {};
TextureMap m_defaultTextures = {};
/**
* The shader unit this unit is linked to
*/
@ -151,6 +155,6 @@ class CShaderUnit {
/**
* The container to source files from
*/
const std::shared_ptr<const CContainer> m_container;
const CContainer& m_container;
};
}

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

@ -1,6 +1,3 @@
#include "WallpaperEngine/Core/Objects/CImage.h"
#include "WallpaperEngine/Core/Objects/CSound.h"
#include "WallpaperEngine/Render/Objects/CImage.h"
#include "WallpaperEngine/Render/Objects/CSound.h"
@ -9,58 +6,59 @@
#include "CScene.h"
#include "WallpaperEngine/Logging/CLog.h"
#include "WallpaperEngine/Data/Model/Wallpaper.h"
#include "WallpaperEngine/Data/Parsers/ObjectParser.h"
extern float g_Time;
extern float g_TimeLast;
using namespace WallpaperEngine;
using namespace WallpaperEngine::Render;
using namespace WallpaperEngine::Data::Model;
using namespace WallpaperEngine::Data::Parsers;
using namespace WallpaperEngine::Render::Wallpapers;
CScene::CScene (
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
) :
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> ();
auto scene = wallpaper.as <Scene> ();
// setup the scene camera
this->m_camera = new CCamera (this, scene->getCamera ());
this->m_camera = std::make_unique<CCamera> (*this, scene->camera);
float width = scene->camera.projection.width;
float height = scene->camera.projection.height;
// detect size if the orthogonal project is auto
if (scene->getOrthogonalProjection ()->isAuto ()) {
// calculate the size of the projection based on the size of everything
for (const auto& [id, sceneObject] : scene->getObjects ()) {
if (!sceneObject->is<Core::Objects::CImage> ())
continue;
const glm::vec2 size = sceneObject->as<Core::Objects::CImage> ()->getSize ();
scene->getOrthogonalProjection ()->setWidth (size.x);
scene->getOrthogonalProjection ()->setHeight (size.y);
}
if (scene->camera.projection.isAuto) {
// TODO: CALCULATE ORTHOGONAL PROJECTION BASED ON CONTENT'S SIZE HERE
}
this->m_parallaxDisplacement = {0, 0};
this->m_camera->setOrthogonalProjection (scene->getOrthogonalProjection ()->getWidth (),
scene->getOrthogonalProjection ()->getHeight ());
// TODO: CONVERSION
this->m_camera->setOrthogonalProjection (width, height);
// setup framebuffers here as they're required for the scene setup
this->setupFramebuffers ();
// set clear color
const glm::vec3 clearColor = this->getScene ()->getClearColor ();
// TODO: MAKE USE OF THE REFERENCE POSSIBILITIES?!
const glm::vec3 clearColor = scene->colors.clear->value->getVec3 ();
glClearColor (clearColor.r, clearColor.g, clearColor.b, 1.0f);
// create all objects based off their dependencies
for (const auto& [id, sceneObject] : scene->getObjects ())
this->createObject (sceneObject);
for (const auto& object : scene->objects)
this->createObject (*object);
// copy over objects by render order
for (const auto& cur : scene->getObjectsByRenderOrder ()) {
auto obj = this->m_objects.find (cur->getId ());
for (const auto& cur : scene->objects) {
auto obj = this->m_objects.find (cur->id);
// ignores not created objects like particle systems
if (obj == this->m_objects.end ())
@ -69,18 +67,18 @@ CScene::CScene (
this->m_objectsByRenderOrder.emplace_back (obj->second);
}
const uint32_t sceneWidth = scene->getOrthogonalProjection ()->getWidth ();
const uint32_t sceneHeight = scene->getOrthogonalProjection ()->getHeight ();
const uint32_t sceneWidth = this->m_camera->getWidth ();
const uint32_t sceneHeight = this->m_camera->getHeight ();
// create extra framebuffers for the bloom effect
this->_rt_4FrameBuffer =
this->createFBO ("_rt_4FrameBuffer", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs, 1.0,
sceneWidth / 4, sceneHeight / 4, sceneWidth / 4, sceneHeight / 4);
this->create ("_rt_4FrameBuffer", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs, 1.0,
{sceneWidth / 4, sceneHeight / 4}, {sceneWidth / 4, sceneHeight / 4});
this->_rt_8FrameBuffer =
this->createFBO ("_rt_8FrameBuffer", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs, 1.0,
sceneWidth / 8, sceneHeight / 8, sceneWidth / 8, sceneHeight / 8);
this->_rt_Bloom = this->createFBO ("_rt_Bloom", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs,
1.0, sceneWidth / 8, sceneHeight / 8, sceneWidth / 8, sceneHeight / 8);
this->create ("_rt_8FrameBuffer", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs, 1.0,
{sceneWidth / 8, sceneHeight / 8}, {sceneWidth / 8, sceneHeight / 8});
this->_rt_Bloom = this->create ("_rt_Bloom", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs,
1.0, {sceneWidth / 8, sceneHeight / 8}, {sceneWidth / 8, sceneHeight / 8});
//
// Had to get a little creative with the effects to achieve the same bloom effect without any custom code
@ -89,6 +87,7 @@ CScene::CScene (
// (it renders directly to the screen, whereas here we never do that from a scene)
//
// TODO: TAKE THIS OUT OF HERE AND INTO THE GENERAL WALLPAPER APPLICATION?!
const std::string imagejson = "{"
"\t\"image\": \"models/wpenginelinux.json\","
"\t\"name\": \"bloomimagewpenginelinux\","
@ -112,30 +111,30 @@ CScene::CScene (
"\t\t\t\t\t\"constantshadervalues\":"
"\t\t\t\t\t{"
"\t\t\t\t\t\t\"bloomstrength\": " +
std::to_string (this->getScene ()->getBloomStrength ()) +
std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
","
"\t\t\t\t\t\t\"bloomthreshold\": " +
std::to_string (this->getScene ()->getBloomThreshold ()) +
std::to_string (this->getScene ().camera.bloom.threshold->value->getFloat ()) +
"\t\t\t\t\t}"
"\t\t\t\t},"
"\t\t\t\t{"
"\t\t\t\t\t\"constantshadervalues\":"
"\t\t\t\t\t{"
"\t\t\t\t\t\t\"bloomstrength\": " +
std::to_string (this->getScene ()->getBloomStrength ()) +
std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
","
"\t\t\t\t\t\t\"bloomthreshold\": " +
std::to_string (this->getScene ()->getBloomThreshold ()) +
std::to_string (this->getScene ().camera.bloom.threshold->value->getFloat ()) +
"\t\t\t\t\t}"
"\t\t\t\t},"
"\t\t\t\t{"
"\t\t\t\t\t\"constantshadervalues\":"
"\t\t\t\t\t{"
"\t\t\t\t\t\t\"bloomstrength\": " +
std::to_string (this->getScene ()->getBloomStrength ()) +
std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
","
"\t\t\t\t\t\t\"bloomthreshold\": " +
std::to_string (this->getScene ()->getBloomThreshold ()) +
std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
"\t\t\t\t\t}"
"\t\t\t\t}"
"\t\t\t]"
@ -148,48 +147,54 @@ CScene::CScene (
const auto json = nlohmann::json::parse (imagejson);
// create image for bloom passes
if (this->getScene ()->isBloom ()) {
this->m_bloomObject = this->createObject (
WallpaperEngine::Core::CObject::fromJSON (json, scene->getProject (), this->getContainer ()));
if (scene->camera.bloom.enabled->value->getBool ()) {
this->m_bloomObjectData = ObjectParser::parse (json, scene->project);
this->m_bloomObject = this->createObject (*this->m_bloomObjectData);
this->m_objectsByRenderOrder.push_back (this->m_bloomObject);
}
}
Render::CObject* CScene::createObject (const Core::CObject* object) {
Render::CObject* CScene::createObject (const Object& object) {
Render::CObject* renderObject = nullptr;
// ensure the item is not loaded already
const auto current = this->m_objects.find (object->getId ());
const auto current = this->m_objects.find (object.id);
if (current != this->m_objects.end ())
return current->second;
// check dependencies too!
for (const auto& cur : object->getDependencies ()) {
for (const auto& cur : object.dependencies) {
// self-dependency is a possibility...
if (cur == object->getId ())
if (cur == object.id)
continue;
auto dep = this->getScene ()->getObjects ().find (cur);
const auto dep = std::find_if (
this->getScene ().objects.begin (),
this->getScene ().objects.end (),
[&cur] (const auto& o) {
return o->id == cur;
}
);
if (dep != this->getScene ()->getObjects ().end ())
this->createObject (dep->second);
if (dep != this->getScene ().objects.end ())
this->createObject (**dep);
}
if (object->is<Core::Objects::CImage> ()) {
auto* image = new Objects::CImage (this, object->as<Core::Objects::CImage> ());
if (object.is<Image> ()) {
auto* image = new Objects::CImage (*this, *object.as<Image> ());
try {
image->setup ();
} catch (std::runtime_error&) {
// this error message is already printed, so just show extra info about it
sLog.error ("Cannot setup image ", image->getImage ()->getName ());
sLog.error ("Cannot setup image ", image->getImage ().name);
}
renderObject = image;
} else if (object->is<Core::Objects::CSound> ()) {
renderObject = new Objects::CSound (this, object->as<Core::Objects::CSound> ());
} else if (object.is<Sound> ()) {
renderObject = new Objects::CSound (*this, *object.as<Sound> ());
}
if (renderObject != nullptr)
@ -198,8 +203,8 @@ Render::CObject* CScene::createObject (const Core::CObject* object) {
return renderObject;
}
CCamera* CScene::getCamera () const {
return this->m_camera;
CCamera& CScene::getCamera () const {
return *this->m_camera;
}
void CScene::renderFrame (glm::ivec4 viewport) {
@ -207,11 +212,11 @@ void CScene::renderFrame (glm::ivec4 viewport) {
this->updateMouse (viewport);
// update the parallax position if required
if (this->getScene ()->isCameraParallax () && !this->getContext ().getApp ().getContext ().settings.mouse.disableparallax) {
const float influence = this->getScene ()->getCameraParallaxMouseInfluence ();
const float amount = this->getScene ()->getCameraParallaxAmount ();
if (this->getScene ().camera.parallax.enabled && !this->getContext ().getApp ().getContext ().settings.mouse.disableparallax) {
const float influence = this->getScene ().camera.parallax.mouseInfluence;
const float amount = this->getScene ().camera.parallax.amount;
const float delay =
glm::min (static_cast<float> (this->getScene ()->getCameraParallaxDelay ()), g_Time - g_TimeLast);
glm::min (static_cast<float> (this->getScene ().camera.parallax.delay), g_Time - g_TimeLast);
this->m_parallaxDisplacement =
glm::mix (this->m_parallaxDisplacement, (this->m_mousePosition * amount) * influence, delay);
@ -243,27 +248,27 @@ void CScene::updateMouse (glm::ivec4 viewport) {
// screen-space positions have to be transposed to what the screen will actually show
}
const Core::Wallpapers::CScene* CScene::getScene () const {
return this->getWallpaperData ()->as<Core::Wallpapers::CScene> ();
const Scene& CScene::getScene () const {
return *this->getWallpaperData ().as<Scene> ();
}
int CScene::getWidth () const {
return this->getScene ()->getOrthogonalProjection ()->getWidth ();
return this->m_camera->getWidth ();
}
int CScene::getHeight () const {
return this->getScene ()->getOrthogonalProjection ()->getHeight ();
return this->m_camera->getHeight ();
}
glm::vec2* CScene::getMousePosition () {
const glm::vec2* CScene::getMousePosition () const {
return &this->m_mousePosition;
}
glm::vec2* CScene::getMousePositionLast () {
const glm::vec2* CScene::getMousePositionLast () const {
return &this->m_mousePositionLast;
}
glm::vec2* CScene::getParallaxDisplacement () {
const glm::vec2* CScene::getParallaxDisplacement () const {
return &this->m_parallaxDisplacement;
}

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

@ -2,8 +2,6 @@
#include "WallpaperEngine/Render/CCamera.h"
#include "WallpaperEngine/Core/Wallpapers/CScene.h"
#include "WallpaperEngine/Render/CWallpaper.h"
namespace WallpaperEngine::Render {
@ -12,23 +10,25 @@ class CObject;
}
namespace WallpaperEngine::Render::Wallpapers {
using namespace WallpaperEngine::Data::Model;
class CScene final : public CWallpaper {
public:
CScene (
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
[[nodiscard]] CCamera* getCamera () const;
[[nodiscard]] CCamera& getCamera () const;
[[nodiscard]] const Core::Wallpapers::CScene* getScene () const;
[[nodiscard]] const Scene& getScene () const;
[[nodiscard]] int getWidth () const override;
[[nodiscard]] int getHeight () const override;
glm::vec2* getMousePosition ();
glm::vec2* getMousePositionLast ();
glm::vec2* getParallaxDisplacement ();
const glm::vec2* getMousePosition () const;
const glm::vec2* getMousePositionLast () const;
const glm::vec2* getParallaxDisplacement () const;
[[nodiscard]] const std::vector<CObject*>& getObjectsByRenderOrder () const;
@ -39,9 +39,10 @@ class CScene final : public CWallpaper {
friend class CWallpaper;
private:
Render::CObject* createObject (const Core::CObject* object);
Render::CObject* createObject (const Object& object);
CCamera* m_camera = nullptr;
std::unique_ptr<CCamera> m_camera;
ObjectUniquePtr m_bloomObjectData;
CObject* m_bloomObject = nullptr;
std::map<int, CObject*> m_objects = {};
std::vector<CObject*> m_objectsByRenderOrder = {};

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

@ -3,6 +3,9 @@
#include <GL/glew.h>
#include "WallpaperEngine/Data/Model/Wallpaper.h"
#include "WallpaperEngine/Data/Model/Project.h"
using namespace WallpaperEngine;
using namespace WallpaperEngine::Render;
using namespace WallpaperEngine::Render::Wallpapers;
@ -12,7 +15,7 @@ void* get_proc_address (void* ctx, const char* name) {
}
CVideo::CVideo (
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
) :
@ -54,7 +57,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 ().project.container->resolveRealFile (this->getVideo ().filename);
// build the path to the video file
const char* command [] = {"loadfile", videopath.c_str (), nullptr};
@ -118,8 +121,8 @@ void CVideo::renderFrame (glm::ivec4 viewport) {
mpv_render_context_render (this->m_mpvGl, params);
}
const Core::Wallpapers::CVideo* CVideo::getVideo () const {
return this->getWallpaperData ()->as<Core::Wallpapers::CVideo> ();
const Video& CVideo::getVideo () const {
return *this->getWallpaperData ().as<Video>();
}
void CVideo::setPause (bool newState) {

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

@ -1,7 +1,5 @@
#pragma once
#include "WallpaperEngine/Core/Wallpapers/CVideo.h"
#include "WallpaperEngine/Audio/CAudioStream.h"
#include "WallpaperEngine/Render/CWallpaper.h"
#include <mpv/client.h>
@ -11,11 +9,11 @@ namespace WallpaperEngine::Render::Wallpapers {
class CVideo final : public CWallpaper {
public:
CVideo (
std::shared_ptr<const Core::CWallpaper> video, CRenderContext& context, CAudioContext& audioContext,
const Wallpaper& video, CRenderContext& context, CAudioContext& audioContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
const Core::Wallpapers::CVideo* getVideo () const;
const Video& getVideo () const;
[[nodiscard]] int getWidth () const override;
[[nodiscard]] int getHeight () const override;

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

@ -4,6 +4,9 @@
#include "CWeb.h"
#include "WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.h"
#include "WallpaperEngine/Data/Model/Wallpaper.h"
#include "WallpaperEngine/Data/Model/Project.h"
using namespace WallpaperEngine::Render;
using namespace WallpaperEngine::Render::Wallpapers;
@ -11,7 +14,7 @@ using namespace WallpaperEngine::WebBrowser;
using namespace WallpaperEngine::WebBrowser::CEF;
CWeb::CWeb (
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
CWebBrowserContext& browserContext, const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
) :
@ -32,9 +35,9 @@ 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 ().project.workshopId) +
"://root/" +
this->getWeb()->getFilename ();
this->getWeb().filename;
this->m_browser =
CefBrowserHost::CreateBrowserSync (window_info, this->m_client, htmlURL, browserSettings, nullptr, nullptr);
}

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

@ -11,11 +11,12 @@
#include <algorithm>
#include "WallpaperEngine/Audio/CAudioStream.h"
#include "WallpaperEngine/Core/Wallpapers/CWeb.h"
#include "WallpaperEngine/Render/CWallpaper.h"
#include "WallpaperEngine/WebBrowser/CEF/CBrowserClient.h"
#include "WallpaperEngine/WebBrowser/CEF/CRenderHandler.h"
#include "WallpaperEngine/Data/Model/Wallpaper.h"
namespace WallpaperEngine::WebBrowser::CEF {
class CRenderHandler;
}
@ -25,7 +26,7 @@ class CWeb : public CWallpaper
{
public:
CWeb (
std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
WallpaperEngine::WebBrowser::CWebBrowserContext& browserContext,
const CWallpaperState::TextureUVsScaling& scalingMode,
const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
@ -39,8 +40,8 @@ class CWeb : public CWallpaper
protected:
void renderFrame (glm::ivec4 viewport) override;
void updateMouse (glm::ivec4 viewport);
const Core::Wallpapers::CWeb* getWeb () const {
return this->getWallpaperData ()->as<Core::Wallpapers::CWeb> ();
const Web& getWeb () const {
return *this->getWallpaperData ().as<Web> ();
}
friend class CWallpaper;

3
src/WallpaperEngine/WebBrowser/CEF/CSubprocessApp.cpp
View File

@ -1,12 +1,13 @@
#include "CSubprocessApp.h"
#include "CWPSchemeHandlerFactory.h"
#include "WallpaperEngine/Data/Model/Project.h"
using namespace WallpaperEngine::WebBrowser::CEF;
CSubprocessApp::CSubprocessApp (WallpaperEngine::Application::CWallpaperApplication& application) :
m_application (application) {
for (const auto& [_, info] : this->m_application.getBackgrounds()) {
this->m_handlerFactories [info->getWorkshopId ()] = new CWPSchemeHandlerFactory (info);
this->m_handlerFactories [info->workshopId] = new CWPSchemeHandlerFactory (*info);
}
}

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

@ -5,12 +5,14 @@
#include "MimeTypes.h"
#include "include/cef_parser.h"
#include "WallpaperEngine/Data/Model/Project.h"
using namespace WallpaperEngine::Assets;
using namespace WallpaperEngine::WebBrowser::CEF;
CWPSchemeHandler::CWPSchemeHandler(std::shared_ptr<const Core::CProject> project) :
m_project (project) {
this->m_container = this->m_project->getWallpaper ()->getProject ()->getContainer ();
CWPSchemeHandler::CWPSchemeHandler(const Project& project) :
m_project (project),
m_container (*this->m_project.container) {
}
bool CWPSchemeHandler::Open(CefRefPtr<CefRequest> request,
@ -46,7 +48,7 @@ bool CWPSchemeHandler::Open(CefRefPtr<CefRequest> request,
this->m_mimeType = mime;
}
this->m_contents = this->m_container->readFile (file, &this->m_filesize);
this->m_contents = this->m_container.readFile (file, &this->m_filesize);
callback->Continue ();
} catch (CAssetLoadException&) {
#if !NDEBUG

14
src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.h
View File

@ -2,7 +2,6 @@
#include <string>
#include "WallpaperEngine/Core/CProject.h"
#include "include/cef_resource_handler.h"
#include "include/wrapper/cef_helpers.h"
@ -10,13 +9,20 @@ namespace WallpaperEngine::Assets {
class CContainer;
}
namespace WallpaperEngine::Data::Model {
class Project;
}
namespace WallpaperEngine::WebBrowser::CEF {
using namespace WallpaperEngine::Data::Model;
/**
* wp{id}:// actual handler called by cef to access files
*/
class CWPSchemeHandler : public CefResourceHandler {
public:
explicit CWPSchemeHandler(std::shared_ptr<const Core::CProject> project);
explicit CWPSchemeHandler(const Project& project);
bool Open(CefRefPtr<CefRequest> request,
bool& handle_request,
@ -32,9 +38,9 @@ class CWPSchemeHandler : public CefResourceHandler {
CefRefPtr<CefResourceReadCallback> callback) override;
private:
std::shared_ptr<const Core::CProject> m_project = nullptr;
const Project& m_project;
std::shared_ptr<const Assets::CContainer> m_container = nullptr;
const Assets::CContainer& m_container;
std::shared_ptr<const uint8_t[]> m_contents = nullptr;
uint32_t m_filesize = 0;
std::string m_mimeType = "";

2
src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.cpp
View File

@ -5,7 +5,7 @@
using namespace WallpaperEngine::WebBrowser::CEF;
CWPSchemeHandlerFactory::CWPSchemeHandlerFactory (const std::shared_ptr<const Core::CProject>& project) :
CWPSchemeHandlerFactory::CWPSchemeHandlerFactory (const Project& project) :
m_project (project) {}
CefRefPtr<CefResourceHandler> CWPSchemeHandlerFactory::Create (

11
src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.h
View File

@ -1,16 +1,21 @@
#pragma once
#include <string>
#include "WallpaperEngine/Core/CProject.h"
#include "include/cef_scheme.h"
namespace WallpaperEngine::Data::Model {
class Project;
}
namespace WallpaperEngine::WebBrowser::CEF {
using namespace WallpaperEngine::Data::Model;
/**
* Simple factory that creates a scheme handler for wp when requested by Cef
*/
class CWPSchemeHandlerFactory : public CefSchemeHandlerFactory {
public:
explicit CWPSchemeHandlerFactory (const std::shared_ptr<const Core::CProject>& project);
explicit CWPSchemeHandlerFactory (const Project& project);
CefRefPtr<CefResourceHandler> Create (
CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
@ -18,7 +23,7 @@ class CWPSchemeHandlerFactory : public CefSchemeHandlerFactory {
static std::string generateSchemeName (const std::string& workshopId);
private:
std::shared_ptr<const Core::CProject> m_project = nullptr;
const Project& m_project;
IMPLEMENT_REFCOUNTING (CWPSchemeHandlerFactory);
DISALLOW_COPY_AND_ASSIGN (CWPSchemeHandlerFactory);

Some files were not shown because too many files have changed in this diff Show More