feat: rewrite the project parser code (#354)

* refactor: new project parser

* refactor: update render to use new data model

* fix: small mistakes in parsing (fbos not taken into account, values not validated, failed to parse properties not ignored)

* fix: parsing tex0004

* fix: pass overrides

* chore: cleanup bloom effect code

* chore: fix binds loading, more fixes on pass overrides, should cleanup soon

* chore: fix audio processing detection

* chore: DynamicValues now keep track of current type, colors should be converted to vec4/ivec4 upon reading so alpha is correct, keep combo overrides too

* chore: update to latest glslang-WallpaperEngine version

* chore: cleanup old Core stuff + update shader constant to use user settings as they should

* chore: cleanup of properties, dynamic values and shader variables

* chore: bring back support for pass commands

* chore: fix combo names not being uppercase when they should be

* chore: fix default uniform values not being applied in the right order

* chore: more fixes for visibility + camerashake can be a user setting

* chore: parse hex colors in properties

* chore: replace old properties with ones following the new model

* chore: remove annoying debug message that's not needed anymore

* chore: remove some debug messages that are not useful anymore

* chore: add parsing of usertextures

* fix: visibility wasn't entirely right, move dependant elements up the render chain

* chore: detect non-string textures and fix null terminator on custom shaders

* chore: few codefactor issues

* chore: few codefactor issues

* chore: remove magic string values in favour of enums in Material info

* chore: fix inconsistencies

* chore: moved texture assets parsing into the data model too

* chore: update to C++20 and take into account endianness

* fix: casts on old ffmpeg versions

* refactor: overhaul the filesystem layer

* chore: breakup texture parser in smaller methods

* chore: rename realpath to physicalPath so codefactor doesn't complain

* chore: move render-dependant texture code to render instead of assets

* chore: add some const qualifiers in parser to prevent changes

* chore: remove C prefix from most classes + fix namespace for textures

* chore: remove empty lines

* feat: added asset locator and replaced filesystem direct usage by asset locator

* chore: some cleanup everywhere

* chore: some cleanup everywhere

* chore: some cleanup everywhere

* fix: regression in fbo access

* chore: fix codefactor error

* chore: fix texture resolution for files with a dot in the name

CMakeLists.txt

@@ -7,7 +7,7 @@ if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
 endif()
 
 set_property(GLOBAL PROPERTY OS_FOLDERS ON)
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 set(OpenGL_GL_PREFERENCE "LEGACY")
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
@@ -104,6 +104,8 @@ find_package(CEF REQUIRED)
 # remove some switches that forbid us from using things that are commonplace in our codebase
 list(REMOVE_ITEM CEF_CXX_COMPILER_FLAGS -fno-exceptions)
 list(REMOVE_ITEM CEF_CXX_COMPILER_FLAGS -fno-rtti)
+list(REMOVE_ITEM CEF_CXX_COMPILER_FLAGS -std=c++17)
+list(APPEND CEF_CXX_COMPILER_FLAGS -std=c++20)
 # remove the vulkan library from the files to copy so it doesn't fail after removing it
 list(REMOVE_ITEM CEF_BINARY_FILES libvulkan.so.1)
 
@@ -156,16 +158,16 @@ if(WAYLAND_SUPPORT_FOUND)
         wayland-egl
         ${OPENGL_egl_LIBRARY})
     set(WAYLAND_SOURCES
-        src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.h
-        src/WallpaperEngine/Render/Drivers/CWaylandOpenGLDriver.cpp
-        src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.cpp
-        src/WallpaperEngine/Render/Drivers/Detectors/CWaylandFullScreenDetector.h
-        src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.cpp
-        src/WallpaperEngine/Render/Drivers/Output/CWaylandOutput.h
-        src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.cpp
-        src/WallpaperEngine/Render/Drivers/Output/CWaylandOutputViewport.h
-        src/WallpaperEngine/Input/Drivers/CWaylandMouseInput.cpp
-        src/WallpaperEngine/Input/Drivers/CWaylandMouseInput.h
+        src/WallpaperEngine/Render/Drivers/WaylandOpenGLDriver.h
+        src/WallpaperEngine/Render/Drivers/WaylandOpenGLDriver.cpp
+        src/WallpaperEngine/Render/Drivers/Detectors/WaylandFullScreenDetector.cpp
+        src/WallpaperEngine/Render/Drivers/Detectors/WaylandFullScreenDetector.h
+        src/WallpaperEngine/Render/Drivers/Output/WaylandOutput.cpp
+        src/WallpaperEngine/Render/Drivers/Output/WaylandOutput.h
+        src/WallpaperEngine/Render/Drivers/Output/WaylandOutputViewport.cpp
+        src/WallpaperEngine/Render/Drivers/Output/WaylandOutputViewport.h
+        src/WallpaperEngine/Input/Drivers/WaylandMouseInput.cpp
+        src/WallpaperEngine/Input/Drivers/WaylandMouseInput.h
         ${WAYLAND_OUTPUT_DIR}/xdg-shell-protocol.c
         ${WAYLAND_OUTPUT_DIR}/xdg-shell-protocol.h
         ${WAYLAND_OUTPUT_DIR}/wlr-foreign-toplevel-management-unstable-v1-protocol.c
@@ -195,10 +197,10 @@ if(X11_SUPPORT_FOUND)
         ${X11_LIBRARIES}
         ${X11_Xrandr_LIB})
     set(X11_SOURCES
-        src/WallpaperEngine/Render/Drivers/Output/CX11Output.cpp
-        src/WallpaperEngine/Render/Drivers/Output/CX11Output.h
-        src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.cpp
-        src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h)
+        src/WallpaperEngine/Render/Drivers/Output/X11Output.cpp
+        src/WallpaperEngine/Render/Drivers/Output/X11Output.h
+        src/WallpaperEngine/Render/Drivers/Detectors/X11FullScreenDetector.cpp
+        src/WallpaperEngine/Render/Drivers/Detectors/X11FullScreenDetector.h)
     SET(X11_INCLUDES
         ${X11_INCLUDE_DIR}
         ${XRANDR_INCLUDE_DIR})
@@ -257,258 +259,195 @@ add_executable(
     src/Steam/FileSystem/FileSystem.cpp
     src/Steam/FileSystem/FileSystem.h
 
-    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
-    src/WallpaperEngine/Application/CWallpaperApplication.h
-
-    src/WallpaperEngine/Assets/CPackageLoadException.cpp
-    src/WallpaperEngine/Assets/CPackageLoadException.h
-    src/WallpaperEngine/Assets/CAssetLoadException.cpp
-    src/WallpaperEngine/Assets/CAssetLoadException.h
-    src/WallpaperEngine/Assets/CContainer.h
-    src/WallpaperEngine/Assets/CContainer.cpp
-    src/WallpaperEngine/Assets/CVirtualContainer.h
-    src/WallpaperEngine/Assets/CVirtualContainer.cpp
-    src/WallpaperEngine/Assets/CCombinedContainer.h
-    src/WallpaperEngine/Assets/CCombinedContainer.cpp
-    src/WallpaperEngine/Assets/CDirectory.h
-    src/WallpaperEngine/Assets/CDirectory.cpp
-    src/WallpaperEngine/Assets/CPackage.h
-    src/WallpaperEngine/Assets/CPackage.cpp
-    src/WallpaperEngine/Assets/ITexture.h
-    src/WallpaperEngine/Assets/CTexture.h
-    src/WallpaperEngine/Assets/CTexture.cpp
-
-    src/WallpaperEngine/Core/Core.h
-    src/WallpaperEngine/Core/Core.cpp
-
-    src/WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.cpp
-    src/WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.h
-    src/WallpaperEngine/Audio/Drivers/Recorders/CPlaybackRecorder.cpp
-    src/WallpaperEngine/Audio/Drivers/Recorders/CPlaybackRecorder.h
-
-    src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.cpp
-    src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.h
-    src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.cpp
-    src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.h
-
-    src/WallpaperEngine/Audio/Drivers/CAudioDriver.cpp
-    src/WallpaperEngine/Audio/Drivers/CAudioDriver.h
-    src/WallpaperEngine/Audio/Drivers/CSDLAudioDriver.cpp
-    src/WallpaperEngine/Audio/Drivers/CSDLAudioDriver.h
-    src/WallpaperEngine/Audio/CAudioContext.cpp
-    src/WallpaperEngine/Audio/CAudioContext.h
-    src/WallpaperEngine/Audio/CAudioStream.cpp
-    src/WallpaperEngine/Audio/CAudioStream.h
-
-    src/WallpaperEngine/Input/CInputContext.cpp
-    src/WallpaperEngine/Input/CInputContext.h
-    src/WallpaperEngine/Input/CMouseInput.cpp
-    src/WallpaperEngine/Input/CMouseInput.h
-    src/WallpaperEngine/Input/Drivers/CGLFWMouseInput.cpp
-    src/WallpaperEngine/Input/Drivers/CGLFWMouseInput.h
-
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariable.cpp
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableFloat.h
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableFloat.cpp
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableInteger.h
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableInteger.cpp
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector2.h
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector2.cpp
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.h
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.cpp
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.h
-    src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.cpp
-
-    src/WallpaperEngine/Render/Shaders/CShader.h
-    src/WallpaperEngine/Render/Shaders/CShader.cpp
-    src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
-    src/WallpaperEngine/Render/Shaders/CShaderUnit.h
-    src/WallpaperEngine/Render/Shaders/CGLSLContext.cpp
-    src/WallpaperEngine/Render/Shaders/CGLSLContext.h
-
-    src/WallpaperEngine/Render/Helpers/CContextAware.cpp
-    src/WallpaperEngine/Render/Helpers/CContextAware.h
-
-    src/WallpaperEngine/Render/Drivers/CVideoFactories.cpp
-    src/WallpaperEngine/Render/Drivers/CVideoFactories.h
-
-    src/WallpaperEngine/Render/Drivers/Detectors/CFullScreenDetector.cpp
-    src/WallpaperEngine/Render/Drivers/Detectors/CFullScreenDetector.h
-
-    src/WallpaperEngine/Render/Drivers/Output/COutput.cpp
-    src/WallpaperEngine/Render/Drivers/Output/COutput.h
-    src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.cpp
-    src/WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.h
-    src/WallpaperEngine/Render/Drivers/Output/CGLFWOutputViewport.cpp
-    src/WallpaperEngine/Render/Drivers/Output/CGLFWOutputViewport.h
-    src/WallpaperEngine/Render/Drivers/Output/COutputViewport.cpp
-    src/WallpaperEngine/Render/Drivers/Output/COutputViewport.h
-    src/WallpaperEngine/Render/Drivers/CGLFWOpenGLDriver.h
-    src/WallpaperEngine/Render/Drivers/CGLFWOpenGLDriver.cpp
-    src/WallpaperEngine/Render/Drivers/CVideoDriver.h
-    src/WallpaperEngine/Render/Drivers/CVideoDriver.cpp
-    src/WallpaperEngine/Render/CRenderContext.h
-    src/WallpaperEngine/Render/CRenderContext.cpp
-    src/WallpaperEngine/Render/CTextureCache.h
-    src/WallpaperEngine/Render/CTextureCache.cpp
-
-    src/WallpaperEngine/Render/Helpers/CContextAware.cpp
-    src/WallpaperEngine/Render/Helpers/CContextAware.h
+    src/WallpaperEngine/Logging/Log.cpp
+    src/WallpaperEngine/Logging/Log.h
+
+    src/WallpaperEngine/Application/ApplicationContext.cpp
+    src/WallpaperEngine/Application/ApplicationContext.h
+    src/WallpaperEngine/Application/WallpaperApplication.cpp
+    src/WallpaperEngine/Application/WallpaperApplication.h
+
+    src/WallpaperEngine/Assets/AssetLoadException.cpp
+    src/WallpaperEngine/Assets/AssetLoadException.h
+    src/WallpaperEngine/Assets/AssetLocator.cpp
+    src/WallpaperEngine/Assets/AssetLocator.h
+
+    src/WallpaperEngine/FileSystem/Container.h
+    src/WallpaperEngine/FileSystem/Container.cpp
+    src/WallpaperEngine/FileSystem/Adapters/Types.h
+    src/WallpaperEngine/FileSystem/Adapters/Directory.cpp
+    src/WallpaperEngine/FileSystem/Adapters/Directory.h
+    src/WallpaperEngine/FileSystem/Adapters/Package.cpp
+    src/WallpaperEngine/FileSystem/Adapters/Package.h
+    src/WallpaperEngine/FileSystem/Adapters/Virtual.cpp
+    src/WallpaperEngine/FileSystem/Adapters/Virtual.h
+
+    src/WallpaperEngine/Audio/Drivers/Recorders/PulseAudioPlaybackRecorder.cpp
+    src/WallpaperEngine/Audio/Drivers/Recorders/PulseAudioPlaybackRecorder.h
+    src/WallpaperEngine/Audio/Drivers/Recorders/PlaybackRecorder.cpp
+    src/WallpaperEngine/Audio/Drivers/Recorders/PlaybackRecorder.h
+
+    src/WallpaperEngine/Audio/Drivers/Detectors/PulseAudioPlayingDetector.cpp
+    src/WallpaperEngine/Audio/Drivers/Detectors/PulseAudioPlayingDetector.h
+    src/WallpaperEngine/Audio/Drivers/Detectors/AudioPlayingDetector.cpp
+    src/WallpaperEngine/Audio/Drivers/Detectors/AudioPlayingDetector.h
+
+    src/WallpaperEngine/Audio/Drivers/AudioDriver.cpp
+    src/WallpaperEngine/Audio/Drivers/AudioDriver.h
+    src/WallpaperEngine/Audio/Drivers/SDLAudioDriver.cpp
+    src/WallpaperEngine/Audio/Drivers/SDLAudioDriver.h
+    src/WallpaperEngine/Audio/AudioContext.cpp
+    src/WallpaperEngine/Audio/AudioContext.h
+    src/WallpaperEngine/Audio/AudioStream.cpp
+    src/WallpaperEngine/Audio/AudioStream.h
+
+    src/WallpaperEngine/Input/InputContext.cpp
+    src/WallpaperEngine/Input/InputContext.h
+    src/WallpaperEngine/Input/MouseInput.h
+    src/WallpaperEngine/Input/Drivers/GLFWMouseInput.cpp
+    src/WallpaperEngine/Input/Drivers/GLFWMouseInput.h
+
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariable.h
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariable.cpp
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariableFloat.h
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariableFloat.cpp
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariableInteger.h
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariableInteger.cpp
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariableVector2.h
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariableVector2.cpp
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariableVector3.h
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariableVector3.cpp
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariableVector4.h
+    src/WallpaperEngine/Render/Shaders/Variables/ShaderVariableVector4.cpp
+
+    src/WallpaperEngine/Render/Shaders/Shader.h
+    src/WallpaperEngine/Render/Shaders/Shader.cpp
+    src/WallpaperEngine/Render/Shaders/ShaderUnit.cpp
+    src/WallpaperEngine/Render/Shaders/ShaderUnit.h
+    src/WallpaperEngine/Render/Shaders/GLSLContext.cpp
+    src/WallpaperEngine/Render/Shaders/GLSLContext.h
+
+    src/WallpaperEngine/Render/Helpers/ContextAware.cpp
+    src/WallpaperEngine/Render/Helpers/ContextAware.h
+
+    src/WallpaperEngine/Render/Drivers/VideoFactories.cpp
+    src/WallpaperEngine/Render/Drivers/VideoFactories.h
+
+    src/WallpaperEngine/Render/Drivers/Detectors/FullScreenDetector.cpp
+    src/WallpaperEngine/Render/Drivers/Detectors/FullScreenDetector.h
+
+    src/WallpaperEngine/Render/Drivers/Output/Output.cpp
+    src/WallpaperEngine/Render/Drivers/Output/Output.h
+    src/WallpaperEngine/Render/Drivers/Output/GLFWWindowOutput.cpp
+    src/WallpaperEngine/Render/Drivers/Output/GLFWWindowOutput.h
+    src/WallpaperEngine/Render/Drivers/Output/GLFWOutputViewport.cpp
+    src/WallpaperEngine/Render/Drivers/Output/GLFWOutputViewport.h
+    src/WallpaperEngine/Render/Drivers/Output/OutputViewport.cpp
+    src/WallpaperEngine/Render/Drivers/Output/OutputViewport.h
+    src/WallpaperEngine/Render/Drivers/GLFWOpenGLDriver.h
+    src/WallpaperEngine/Render/Drivers/GLFWOpenGLDriver.cpp
+    src/WallpaperEngine/Render/Drivers/VideoDriver.h
+    src/WallpaperEngine/Render/Drivers/VideoDriver.cpp
+    src/WallpaperEngine/Render/RenderContext.h
+    src/WallpaperEngine/Render/RenderContext.cpp
+    src/WallpaperEngine/Render/TextureCache.h
+    src/WallpaperEngine/Render/TextureCache.cpp
+    src/WallpaperEngine/Render/FBOProvider.cpp
+    src/WallpaperEngine/Render/FBOProvider.h
+
+    src/WallpaperEngine/Render/Helpers/ContextAware.cpp
+    src/WallpaperEngine/Render/Helpers/ContextAware.h
 
     src/WallpaperEngine/Render/CWallpaper.h
     src/WallpaperEngine/Render/CWallpaper.cpp
-    src/WallpaperEngine/Render/CWallpaperState.h
-    src/WallpaperEngine/Render/CWallpaperState.cpp
+    src/WallpaperEngine/Render/WallpaperState.h
+    src/WallpaperEngine/Render/WallpaperState.cpp
     src/WallpaperEngine/Render/Wallpapers/CScene.h
     src/WallpaperEngine/Render/Wallpapers/CScene.cpp
     src/WallpaperEngine/Render/Wallpapers/CVideo.h
     src/WallpaperEngine/Render/Wallpapers/CVideo.cpp
     src/WallpaperEngine/Render/Wallpapers/CWeb.h
     src/WallpaperEngine/Render/Wallpapers/CWeb.cpp
-    src/WallpaperEngine/Render/CCamera.h
-    src/WallpaperEngine/Render/CCamera.cpp
+    src/WallpaperEngine/Render/Camera.h
+    src/WallpaperEngine/Render/Camera.cpp
     src/WallpaperEngine/Render/CObject.h
     src/WallpaperEngine/Render/CObject.cpp
+    src/WallpaperEngine/Render/CTexture.cpp
+    src/WallpaperEngine/Render/CTexture.h
+    src/WallpaperEngine/Render/TextureProvider.h
 
     src/WallpaperEngine/Render/Objects/CImage.h
     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
-    src/WallpaperEngine/WebBrowser/CEF/CBrowserClient.cpp
-    src/WallpaperEngine/WebBrowser/CEF/CBrowserClient.h
-    src/WallpaperEngine/WebBrowser/CEF/CBrowserApp.cpp
-    src/WallpaperEngine/WebBrowser/CEF/CBrowserApp.h
-    src/WallpaperEngine/WebBrowser/CEF/CSubprocessApp.cpp
-    src/WallpaperEngine/WebBrowser/CEF/CSubprocessApp.h
-    src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.cpp
-    src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.h
-    src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.cpp
-    src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.h
-    src/WallpaperEngine/WebBrowser/CWebBrowserContext.cpp
-    src/WallpaperEngine/WebBrowser/CWebBrowserContext.h
-
-    src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp
-    src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
-
-    src/WallpaperEngine/Core/UserSettings/CUserSettingValue.cpp
-    src/WallpaperEngine/Core/UserSettings/CUserSettingValue.h
-    src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
-    src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
-    src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.cpp
-    src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h
-    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
-    src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
-    src/WallpaperEngine/Core/Projects/CPropertyBoolean.h
-    src/WallpaperEngine/Core/Projects/CPropertyBoolean.cpp
-    src/WallpaperEngine/Core/Projects/CPropertySlider.h
-    src/WallpaperEngine/Core/Projects/CPropertySlider.cpp
-    src/WallpaperEngine/Core/Projects/CPropertyCombo.h
-    src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
-    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/Effects/Constants/CShaderConstant.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.cpp
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.cpp
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.cpp
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.cpp
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.cpp
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.cpp
-    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/WebBrowser/CEF/RenderHandler.cpp
+    src/WallpaperEngine/WebBrowser/CEF/RenderHandler.h
+    src/WallpaperEngine/WebBrowser/CEF/BrowserClient.cpp
+    src/WallpaperEngine/WebBrowser/CEF/BrowserClient.h
+    src/WallpaperEngine/WebBrowser/CEF/BrowserApp.cpp
+    src/WallpaperEngine/WebBrowser/CEF/BrowserApp.h
+    src/WallpaperEngine/WebBrowser/CEF/SubprocessApp.cpp
+    src/WallpaperEngine/WebBrowser/CEF/SubprocessApp.h
+    src/WallpaperEngine/WebBrowser/CEF/WPSchemeHandlerFactory.cpp
+    src/WallpaperEngine/WebBrowser/CEF/WPSchemeHandlerFactory.h
+    src/WallpaperEngine/WebBrowser/CEF/WPSchemeHandler.cpp
+    src/WallpaperEngine/WebBrowser/CEF/WPSchemeHandler.h
+    src/WallpaperEngine/WebBrowser/WebBrowserContext.cpp
+    src/WallpaperEngine/WebBrowser/WebBrowserContext.h
+
+    src/WallpaperEngine/Data/Assets/Types.h
+    src/WallpaperEngine/Data/Assets/Texture.h
+    src/WallpaperEngine/Data/Assets/Package.h
+    src/WallpaperEngine/Data/Model/Types.h
+    src/WallpaperEngine/Data/Model/Project.h
+    src/WallpaperEngine/Data/Model/Wallpaper.h
+    src/WallpaperEngine/Data/Model/Object.h
+    src/WallpaperEngine/Data/Model/Material.h
+    src/WallpaperEngine/Data/Model/Effect.h
+    src/WallpaperEngine/Data/Model/Model.h
+    src/WallpaperEngine/Data/Model/UserSetting.h
+    src/WallpaperEngine/Data/Model/DynamicValue.h
+    src/WallpaperEngine/Data/Model/DynamicValue.cpp
+    src/WallpaperEngine/Data/Model/Property.h
+    src/WallpaperEngine/Data/Utils/TypeCaster.h
+    src/WallpaperEngine/Data/Utils/BinaryReader.cpp
+    src/WallpaperEngine/Data/Utils/BinaryReader.h
+    src/WallpaperEngine/Data/Utils/MemoryStream.h
+    src/WallpaperEngine/Data/Utils/SFINAE.h
+    src/WallpaperEngine/Data/Parsers/EffectParser.cpp
+    src/WallpaperEngine/Data/Parsers/EffectParser.h
+    src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
+    src/WallpaperEngine/Data/Parsers/ProjectParser.h
+    src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
+    src/WallpaperEngine/Data/Parsers/WallpaperParser.h
+    src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
+    src/WallpaperEngine/Data/Parsers/UserSettingParser.h
+    src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
+    src/WallpaperEngine/Data/Parsers/ObjectParser.h
+    src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
+    src/WallpaperEngine/Data/Parsers/MaterialParser.h
+    src/WallpaperEngine/Data/Parsers/ModelParser.cpp
+    src/WallpaperEngine/Data/Parsers/ModelParser.h
+    src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
+    src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
+    src/WallpaperEngine/Data/Parsers/PackageParser.cpp
+    src/WallpaperEngine/Data/Parsers/PackageParser.h
+    src/WallpaperEngine/Data/Parsers/PropertyParser.cpp
+    src/WallpaperEngine/Data/Parsers/PropertyParser.h
+    src/WallpaperEngine/Data/Parsers/TextureParser.cpp
+    src/WallpaperEngine/Data/Parsers/TextureParser.h
+    src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
+    src/WallpaperEngine/Data/Builders/VectorBuilder.cpp
+    src/WallpaperEngine/Data/Builders/VectorBuilder.h
+    src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
+    src/WallpaperEngine/Data/Dumpers/StringPrinter.h
+    src/WallpaperEngine/Data/JSON.cpp
 
     ${WAYLAND_SOURCES}
     ${X11_SOURCES}

CMakeModules/DownloadCEF.cmake

@@ -52,8 +52,8 @@ endfunction()
 # SET_EXECUTABLE_TARGET_PROPERTIES() instead of calling this macro directly.
 macro(REPLACED_SET_COMMON_TARGET_PROPERTIES target)
   # Compile flags. (MODIFIED FOR C/C++ SEPARATION)
-  target_compile_options(${target} PRIVATE $<$<COMPILE_LANGUAGE:C>:${CEF_COMPILER_FLAGS}>)
-  target_compile_options(${target} PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${CEF_CXX_COMPILER_FLAGS}>)
+  target_compile_options(${target} PRIVATE $<$<COMPILE_LANGUAGE:C>:${CEF_COMPILER_FLAGS} ${CEF_C_COMPILER_FLAGS}>)
+  target_compile_options(${target} PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${CEF_COMPILER_FLAGS} ${CEF_CXX_COMPILER_FLAGS}>)
   target_compile_options(${target} PRIVATE $<$<CONFIG:Debug>:${CEF_COMPILER_FLAGS_DEBUG} ${CEF_CXX_COMPILER_FLAGS_DEBUG}>)
   target_compile_options(${target} PRIVATE $<$<CONFIG:Release>:${CEF_COMPILER_FLAGS_RELEASE} ${CEF_CXX_COMPILER_FLAGS_RELEASE}>)
 

src/External/glslang-WallpaperEngine

@@ -1 +1 @@
-Subproject commit 077d4f3c89bbfbb7951a9011d4551b075f092334
+Subproject commit 9fba00b655d79ef2fe6f05b459571bd3b1f119ea

src/Steam/FileSystem/FileSystem.cpp

@@ -1,25 +1,23 @@
 #include "FileSystem.h"
-#include "WallpaperEngine/Logging/CLog.h"
+#include "WallpaperEngine/Logging/Log.h"
 #include <climits>
 #include <cstdlib>
 #include <filesystem>
 #include <sstream>
 #include <sys/stat.h>
 
-const char* assets_default_paths [] = {
+std::vector<std::string> appDirectoryPaths = {
     ".steam/steam/steamapps/common",
     ".local/share/Steam/steamapps/common",
     ".var/app/com.valvesoftware.Steam/.local/share/Steam/steamapps/common",
     "snap/steam/common/.local/share/Steam/steamapps/common",
-    nullptr
 };
 
-const char* workshop_content_default_paths [] = {
+std::vector<std::string> workshopDirectoryPaths = {
     ".local/share/Steam/steamapps/workshop/content",
     ".steam/steam/steamapps/workshop/content",
     ".var/app/com.valvesoftware.Steam/.local/share/Steam/steamapps/workshop/content",
     "snap/steam/common/.local/share/Steam/steamapps/workshop/content",
-    nullptr
 };
 
 std::filesystem::path detectHomepath () {
@@ -33,14 +31,14 @@ std::filesystem::path detectHomepath () {
     if (!std::filesystem::is_directory (path))
         sLog.exception ("Cannot find home directory for current user, ", home, " is not a directory");
 
-    return home;
+    return path;
 }
 
 std::filesystem::path Steam::FileSystem::workshopDirectory (int appID, const std::string& contentID) {
     auto homepath = detectHomepath ();
 
-    for (const char** current = workshop_content_default_paths; *current != nullptr; current++) {
-        auto currentpath = std::filesystem::path (homepath) / *current / std::to_string (appID) / contentID;
+    for (const auto& current : workshopDirectoryPaths) {
+        auto currentpath = std::filesystem::path (homepath) / current / std::to_string (appID) / contentID;
 
         if (!std::filesystem::exists (currentpath) || !std::filesystem::is_directory (currentpath))
             continue;
@@ -54,8 +52,8 @@ std::filesystem::path Steam::FileSystem::workshopDirectory (int appID, const std
 std::filesystem::path Steam::FileSystem::appDirectory (const std::string& appDirectory, const std::string& path) {
     auto homepath = detectHomepath ();
 
-    for (const char** current = assets_default_paths; *current != nullptr; current++) {
-        auto currentpath = std::filesystem::path (homepath) / *current / appDirectory / path;
+    for (const auto& current : appDirectoryPaths) {
+        auto currentpath = std::filesystem::path (homepath) / current / appDirectory / path;
 
         if (!std::filesystem::exists (currentpath) || !std::filesystem::is_directory (currentpath))
             continue;

src/WallpaperEngine/Application/CApplicationContext.cpp → src/WallpaperEngine/Application/ApplicationContext.cpp

@@ -1,7 +1,7 @@
-#include "CApplicationContext.h"
+#include "ApplicationContext.h"
 
 #include "Steam/FileSystem/FileSystem.h"
-#include "WallpaperEngine/Logging/CLog.h"
+#include "WallpaperEngine/Logging/Log.h"
 
 #include <cstdlib>
 #include <cstring>
@@ -14,7 +14,7 @@
 
 using namespace WallpaperEngine::Application;
 
-CApplicationContext::CApplicationContext (int argc, char* argv []) :
+ApplicationContext::ApplicationContext (int argc, char* argv []) :
     m_argc (argc),
     m_argv (argv) {
     std::string lastScreen;
@@ -93,16 +93,16 @@ CApplicationContext::CApplicationContext (int argc, char* argv []) :
             .help ("Scaling mode to use when rendering the background, this applies to the previous --window or --screen-root output, or the default background if no other background is specified")
             .choices ("stretch", "fit", "fill", "default")
             .action([this, &lastScreen](const std::string& value) -> void {
-                WallpaperEngine::Render::CWallpaperState::TextureUVsScaling mode;
+                WallpaperEngine::Render::WallpaperState::TextureUVsScaling mode;
 
                 if (value == "stretch") {
-                    mode = WallpaperEngine::Render::CWallpaperState::TextureUVsScaling::StretchUVs;
+                    mode = WallpaperEngine::Render::WallpaperState::TextureUVsScaling::StretchUVs;
                 } else if (value == "fit") {
-                    mode = WallpaperEngine::Render::CWallpaperState::TextureUVsScaling::ZoomFitUVs;
+                    mode = WallpaperEngine::Render::WallpaperState::TextureUVsScaling::ZoomFitUVs;
                 } else if (value == "fill") {
-                    mode = WallpaperEngine::Render::CWallpaperState::TextureUVsScaling::ZoomFillUVs;
+                    mode = WallpaperEngine::Render::WallpaperState::TextureUVsScaling::ZoomFillUVs;
                 } else if (value == "default") {
-                    mode = WallpaperEngine::Render::CWallpaperState::TextureUVsScaling::DefaultUVs;
+                    mode = WallpaperEngine::Render::WallpaperState::TextureUVsScaling::DefaultUVs;
                 } else {
                     sLog.exception ("Invalid scaling mode: ", value);
                 }
@@ -118,14 +118,14 @@ CApplicationContext::CApplicationContext (int argc, char* argv []) :
             .help ("Clamp mode to use when rendering the background, this applies to the previous --window or --screen-root output, or the default background if no other background is specified")
             .choices("clamp", "border", "repeat")
             .action([this, &lastScreen](const std::string& value) -> void {
-                WallpaperEngine::Assets::ITexture::TextureFlags flags;
+                TextureFlags flags;
 
                 if (value == "clamp") {
-                    flags = WallpaperEngine::Assets::ITexture::TextureFlags::ClampUVs;
+                    flags = TextureFlags_ClampUVs;
                 } else if (value == "border") {
-                    flags = WallpaperEngine::Assets::ITexture::TextureFlags::ClampUVsBorder;
+                    flags = TextureFlags_ClampUVsBorder;
                 } else if (value == "repeat") {
-                    flags = WallpaperEngine::Assets::ITexture::TextureFlags::NoFlags;
+                    flags = TextureFlags_NoFlags;
                 } else {
                     sLog.exception ("Invalid clamp mode: ", value);
                 }
@@ -192,7 +192,7 @@ CApplicationContext::CApplicationContext (int argc, char* argv []) :
 
         screenshotGroup.add_argument ("--screenshot-delay")
             .help ("Frames to wait before taking the screenshot")
-            .default_value (5)
+            .default_value <uint32_t> (5)
             .store_into (this->settings.screenshot.delay);
 
     auto& contentGroup = program.add_group ("Content options");
@@ -263,7 +263,7 @@ CApplicationContext::CApplicationContext (int argc, char* argv []) :
         }
 
         this->settings.audio.volume = std::max(0, std::min (this->settings.audio.volume, 128));
-        this->settings.screenshot.delay = std::max (0, std::min (this->settings.screenshot.delay, 5));
+        this->settings.screenshot.delay = std::max <uint32_t> (0, std::min <uint32_t> (this->settings.screenshot.delay, 5));
 
         // use std::cout on this in case logging is disabled, this way it's easy to look at what is running
         std::stringbuf buffer;
@@ -299,22 +299,22 @@ CApplicationContext::CApplicationContext (int argc, char* argv []) :
    }
 }
 
-int CApplicationContext::getArgc () const {
+int ApplicationContext::getArgc () const {
     return this->m_argc;
 }
 
-char** CApplicationContext::getArgv () const {
+char** ApplicationContext::getArgv () const {
     return this->m_argv;
 }
 
-std::filesystem::path CApplicationContext::translateBackground (const std::string& bgIdOrPath) {
+std::filesystem::path ApplicationContext::translateBackground (const std::string& bgIdOrPath) {
     if (bgIdOrPath.find ('/') == std::string::npos)
         return Steam::FileSystem::workshopDirectory (WORKSHOP_APP_ID, bgIdOrPath);
 
     return bgIdOrPath;
 }
 
-void CApplicationContext::validateAssets () {
+void ApplicationContext::validateAssets () {
     if (!this->settings.general.assets.empty ()) {
         sLog.out ("Using wallpaper engine's assets at ", this->settings.general.assets,
                   " based on --assets-dir parameter");
@@ -329,7 +329,7 @@ void CApplicationContext::validateAssets () {
     }
 }
 
-void CApplicationContext::validateScreenshot () const {
+void ApplicationContext::validateScreenshot () const {
     if (!this->settings.screenshot.take)
         return;
 

src/WallpaperEngine/Application/CApplicationContext.h → src/WallpaperEngine/Application/ApplicationContext.h

@@ -7,18 +7,21 @@
 
 #include <glm/vec4.hpp>
 
-#include "CApplicationState.h"
+#include "ApplicationState.h"
 
-#include "WallpaperEngine/Assets/ITexture.h"
-#include "WallpaperEngine/Render/CWallpaperState.h"
+#include "../Render/TextureProvider.h"
+#include "WallpaperEngine/Render/WallpaperState.h"
+
+#include "WallpaperEngine/Data/Model/Project.h"
 
 namespace WallpaperEngine::Application {
+using namespace WallpaperEngine::Data::Assets;
 /**
  * Application information as parsed off the command line arguments
  */
-class CApplicationContext {
+class ApplicationContext {
   public:
-    CApplicationContext (int argc, char* argv []);
+    ApplicationContext (int argc, char* argv []);
 
     enum WINDOW_MODE {
         /** Default window mode */
@@ -47,9 +50,9 @@ class CApplicationContext {
             /** Properties to change values for */
             std::map<std::string, std::string> properties;
             /** The scaling mode for different screens */
-            std::map<std::string, WallpaperEngine::Render::CWallpaperState::TextureUVsScaling> screenScalings;
+            std::map<std::string, WallpaperEngine::Render::WallpaperState::TextureUVsScaling> screenScalings;
             /** The clamping mode for different screens */
-            std::map<std::string, WallpaperEngine::Assets::ITexture::TextureFlags> screenClamps;
+            std::map<std::string, TextureFlags> screenClamps;
         } general;
 
         /**
@@ -66,8 +69,8 @@ class CApplicationContext {
             struct {
                 /** The window size used in explicit window */
                 glm::ivec4 geometry;
-                WallpaperEngine::Assets::ITexture::TextureFlags clamp;
-                WallpaperEngine::Render::CWallpaperState::TextureUVsScaling scalingMode;
+                TextureFlags clamp;
+                WallpaperEngine::Render::WallpaperState::TextureUVsScaling scalingMode;
             } window;
         } render;
 
@@ -102,7 +105,7 @@ class CApplicationContext {
             /** If an screenshot should be taken */
             bool take;
             /** The frames to wait until the screenshot is taken */
-            int delay;
+            uint32_t delay;
             /** The path to where the screenshot must be saved */
             std::filesystem::path path;
         } screenshot;
@@ -123,8 +126,8 @@ class CApplicationContext {
             .pauseOnFullscreen = true,
             .window = {
                 .geometry = {},
-                .clamp = WallpaperEngine::Assets::ITexture::TextureFlags::ClampUVs,
-                .scalingMode = WallpaperEngine::Render::CWallpaperState::TextureUVsScaling::DefaultUVs,
+                .clamp = TextureFlags_ClampUVs,
+                .scalingMode = WallpaperEngine::Render::WallpaperState::TextureUVsScaling::DefaultUVs,
             },
         },
         .audio = {
@@ -144,7 +147,7 @@ class CApplicationContext {
         },
     };
 
-    CApplicationState state;
+    ApplicationState state;
 
     [[nodiscard]] int getArgc() const;
     [[nodiscard]] char** getArgv() const;

src/WallpaperEngine/Application/CApplicationState.h → src/WallpaperEngine/Application/ApplicationState.h

@@ -1,12 +1,12 @@
 #pragma once
 
-#include "CApplicationContext.h"
+#include "ApplicationContext.h"
 
 namespace WallpaperEngine::Application {
 /**
  * Represents current application state
  */
-class CApplicationState {
+class ApplicationState {
   public:
     struct {
         bool keepRunning;

src/WallpaperEngine/Application/CWallpaperApplication.cpp → src/WallpaperEngine/Application/WallpaperApplication.cpp

@@ -1,16 +1,19 @@
-#include "CWallpaperApplication.h"
+#include "WallpaperApplication.h"
 
 #include "Steam/FileSystem/FileSystem.h"
-#include "WallpaperEngine/Application/CApplicationState.h"
-#include "WallpaperEngine/Assets/CAssetLoadException.h"
-#include "WallpaperEngine/Assets/CDirectory.h"
-#include "WallpaperEngine/Assets/CVirtualContainer.h"
-#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/Application/ApplicationState.h"
+#include "WallpaperEngine/Assets/AssetLoadException.h"
+#include "WallpaperEngine/Audio/Drivers/Detectors/PulseAudioPlayingDetector.h"
+#include "WallpaperEngine/FileSystem/Container.h"
+#include "WallpaperEngine/Logging/Log.h"
+#include "WallpaperEngine/Render/Drivers/VideoFactories.h"
+#include "WallpaperEngine/Render/RenderContext.h"
+
+#include "WallpaperEngine/Data/Dumpers/StringPrinter.h"
+#include "WallpaperEngine/Data/Parsers/ProjectParser.h"
+
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
+#include "WallpaperEngine/Data/Model/Property.h"
 
 #if DEMOMODE
 #include "recording.h"
@@ -26,29 +29,39 @@ float g_Time;
 float g_TimeLast;
 float g_Daytime;
 
-namespace WallpaperEngine::Application {
-CWallpaperApplication::CWallpaperApplication (CApplicationContext& context) :
+using namespace WallpaperEngine::Assets;
+using namespace WallpaperEngine::Application;
+using namespace WallpaperEngine::Data::Model;
+using namespace WallpaperEngine::FileSystem;
+
+WallpaperApplication::WallpaperApplication (ApplicationContext& context) :
     m_context (context) {
     this->loadBackgrounds ();
     this->setupProperties ();
     this->setupBrowser();
 }
 
-void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedContainer>& container, const std::string& bg) const {
-    const std::filesystem::path basepath = bg;
+AssetLocatorUniquePtr WallpaperApplication::setupAssetLocator (const std::string& bg) const {
+    auto container = std::make_unique <Container> ();
+
+    const std::filesystem::path path = bg;
 
-    container->add (std::make_shared<CDirectory> (basepath));
-    container->addPkg (basepath / "scene.pkg");
-    container->addPkg (basepath / "gifscene.pkg");
+    container->mount (path, "/");
+    try {
+        container->mount (path / "scene.pkg", "/");
+    } catch (std::runtime_error&) { }
+
+    try {
+        container->mount (path / "gifscene.pkg", "/");
+    } catch (std::runtime_error&) { }
 
     try {
-        container->add (std::make_shared <CDirectory> (this->m_context.settings.general.assets));
-    } catch (CAssetLoadException&) {
+        container->mount (this->m_context.settings.general.assets, "/");
+    } catch (std::runtime_error&) {
         sLog.exception ("Cannot find a valid assets folder, resolved to ", this->m_context.settings.general.assets);
     }
 
-    // TODO: move this somewhere else?
-    auto virtualContainer = std::make_shared <CVirtualContainer> ();
+    auto& vfs = container->getVFS ();
 
     //
     // Had to get a little creative with the effects to achieve the same bloom effect without any custom code
@@ -59,21 +72,21 @@ void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedConta
     // add the effect file for screen bloom
 
     // add some model for the image element even if it's going to waste rendering cycles
-    virtualContainer->add (
+    vfs.add (
         "effects/wpenginelinux/bloomeffect.json",
         {
             {"name", "camerabloom_wpengine_linux"},
             {"group", "wpengine_linux_camera"},
-            {"dependencies", json::array ()},
+            {"dependencies", JSON::array ()},
             {"passes",
-                json::array (
+                JSON::array (
                     {
                         {
                             {"material", "materials/util/downsample_quarter_bloom.json"},
                             {"target", "_rt_4FrameBuffer"},
                             {
                                 "bind",
-                                json::array (
+                                JSON::array (
                                     {
                                         {
                                             {"name", "_rt_FullFrameBuffer"},
@@ -88,7 +101,7 @@ void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedConta
                             {"target", "_rt_8FrameBuffer"},
                             {
                                 "bind",
-                                json::array (
+                                JSON::array (
                                     {
                                         {
                                             {"name", "_rt_4FrameBuffer"},
@@ -103,7 +116,7 @@ void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedConta
                             {"target", "_rt_Bloom"},
                             {
                                 "bind",
-                                json::array (
+                                JSON::array (
                                     {
                                         {
                                             {"name", "_rt_8FrameBuffer"},
@@ -118,7 +131,7 @@ void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedConta
                             {"target", "_rt_FullFrameBuffer"},
                             {
                                 "bind",
-                                json::array (
+                                JSON::array (
                                     {
                                         {
                                             {"name", "_rt_imageLayerComposite_-1_a"},
@@ -138,17 +151,17 @@ void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedConta
         }
     );
 
-    virtualContainer->add (
+    vfs.add (
         "models/wpenginelinux.json",
         {
             {"material","materials/wpenginelinux.json"}
         }
     );
 
-    virtualContainer->add(
+    vfs.add(
         "materials/wpenginelinux.json",
         {
-            {"passes", json::array (
+            {"passes", JSON::array (
                 {
                     {
                         {"blending", "normal"},
@@ -156,13 +169,13 @@ void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedConta
                         {"depthtest", "disabled"},
                         {"depthwrite", "disabled"},
                         {"shader", "genericimage2"},
-                        {"textures", json::array ({"_rt_FullFrameBuffer"})}
+                        {"textures", JSON::array ({"_rt_FullFrameBuffer"})}
                     }
                 }
             )}}
     );
 
-    virtualContainer->add(
+    vfs.add(
         "shaders/commands/copy.frag",
         "uniform sampler2D g_Texture0;\n"
         "in vec2 v_TexCoord;\n"
@@ -170,7 +183,7 @@ void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedConta
         "out_FragColor = texture (g_Texture0, v_TexCoord);\n"
         "}"
     );
-    virtualContainer->add(
+    vfs.add(
         "shaders/commands/copy.vert",
         "in vec3 a_Position;\n"
         "in vec2 a_TexCoord;\n"
@@ -181,12 +194,12 @@ void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedConta
         "}"
     );
 
-    container->add (virtualContainer);
+    return std::make_unique <AssetLocator> (std::move (container));
 }
 
-void CWallpaperApplication::loadBackgrounds () {
-    if (this->m_context.settings.render.mode == CApplicationContext::NORMAL_WINDOW ||
-        this->m_context.settings.render.mode == CApplicationContext::EXPLICIT_WINDOW) {
+void WallpaperApplication::loadBackgrounds () {
+    if (this->m_context.settings.render.mode == ApplicationContext::NORMAL_WINDOW ||
+        this->m_context.settings.render.mode == ApplicationContext::EXPLICIT_WINDOW) {
         this->m_backgrounds ["default"] = this->loadBackground (this->m_context.settings.general.defaultBackground);
         return;
     }
@@ -201,52 +214,52 @@ 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);
+ProjectUniquePtr WallpaperApplication::loadBackground (const std::string& bg) {
+    auto container = this->setupAssetLocator (bg);
+    auto json = WallpaperEngine::Data::JSON::JSON::parse (container->readString ("project.json"));
 
-    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 WallpaperApplication::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);
 
         if (override != this->m_context.settings.general.properties.end ()) {
             sLog.out ("Applying override value for ", key);
 
-            cur->set (override->second);
+            cur->update (override->second);
         }
 
         if (this->m_context.settings.general.onlyListProperties)
-            sLog.out (cur->dump ());
+            sLog.out (cur->toString ());
     }
 }
 
-void CWallpaperApplication::setupProperties () {
+void WallpaperApplication::setupProperties () {
     for (const auto& [background, info] : this->m_backgrounds)
-        this->setupPropertiesForProject (info);
+        this->setupPropertiesForProject (*info);
 }
 
-void CWallpaperApplication::setupBrowser () {
+void WallpaperApplication::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) {
         return;
     }
 
-    this->m_browserContext = std::make_unique <WebBrowser::CWebBrowserContext> (*this);
+    this->m_browserContext = std::make_unique <WebBrowser::WebBrowserContext> (*this);
 }
 
-void CWallpaperApplication::takeScreenshot (const std::filesystem::path& filename) const {
+void WallpaperApplication::takeScreenshot (const std::filesystem::path& filename) const {
     // this should be getting called at the end of the frame, so the right thing should be bound already
     const int width = this->m_renderContext->getOutput ().getFullWidth ();
     const int height = this->m_renderContext->getOutput ().getFullHeight ();
@@ -276,9 +289,7 @@ void CWallpaperApplication::takeScreenshot (const std::filesystem::path& filenam
                           GL_RGB, GL_UNSIGNED_BYTE, buffer);
         }
 
-        GLenum error = glGetError();
-
-        if (error != GL_NO_ERROR) {
+        if (const GLenum error = glGetError (); error != GL_NO_ERROR) {
             sLog.error ("Cannot obtain pixel data for screen ", screen, ". OpenGL error: ", error);
             delete [] buffer;
             continue;
@@ -287,8 +298,8 @@ void CWallpaperApplication::takeScreenshot (const std::filesystem::path& filenam
         // now get access to the pixels
         for (int y = 0; y < viewport->viewport.w; y++) {
             for (int x = 0; x < viewport->viewport.z; x++) {
-                int xfinal = x + xoffset;
-                int yfinal = vflip ? (viewport->viewport.w - y - 1) : y;
+                const int xfinal = x + xoffset;
+                const int yfinal = vflip ? (viewport->viewport.w - y - 1) : y;
 
                 bitmap [yfinal * width * 3 + xfinal * 3] = *pixel++;
                 bitmap [yfinal * width * 3 + xfinal * 3 + 1] = *pixel++;
@@ -303,9 +314,7 @@ void CWallpaperApplication::takeScreenshot (const std::filesystem::path& filenam
         delete [] buffer;
     }
 
-    auto extension = filename.extension ();
-
-    if (extension == ".bmp") {
+    if (const auto extension = filename.extension (); extension == ".bmp") {
         stbi_write_bmp (filename.c_str (), width, height, 3, bitmap);
     } else if (extension == ".png") {
         stbi_write_png (filename.c_str (), width, height, 3, bitmap, width * 3);
@@ -316,7 +325,7 @@ void CWallpaperApplication::takeScreenshot (const std::filesystem::path& filenam
     delete [] bitmap;
 }
 
-void CWallpaperApplication::setupOutput () {
+void WallpaperApplication::setupOutput () {
     const char* XDG_SESSION_TYPE = getenv ("XDG_SESSION_TYPE");
 
     if (!XDG_SESSION_TYPE) {
@@ -335,33 +344,36 @@ void CWallpaperApplication::setupOutput () {
     this->m_fullScreenDetector = sVideoFactories.createFullscreenDetector (XDG_SESSION_TYPE, this->m_context, *this->m_videoDriver);
 }
 
-void CWallpaperApplication::setupAudio () {
+void WallpaperApplication::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 ();
-    });
+    const bool audioProcessingRequired = std::ranges::any_of (
+        this->m_backgrounds,
+        [](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> ();
+        this->m_audioRecorder = std::make_unique <WallpaperEngine::Audio::Drivers::Recorders::PulseAudioPlaybackRecorder> ();
     } else {
-        this->m_audioRecorder = std::make_unique <WallpaperEngine::Audio::Drivers::Recorders::CPlaybackRecorder> ();
+        this->m_audioRecorder = std::make_unique <WallpaperEngine::Audio::Drivers::Recorders::PlaybackRecorder> ();
     }
 
     if (this->m_context.settings.audio.automute) {
-        m_audioDetector = std::make_unique <WallpaperEngine::Audio::Drivers::Detectors::CPulseAudioPlayingDetector> (this->m_context, *this->m_fullScreenDetector);
+        m_audioDetector = std::make_unique <WallpaperEngine::Audio::Drivers::Detectors::PulseAudioPlayingDetector> (this->m_context, *this->m_fullScreenDetector);
     } else {
-        m_audioDetector = std::make_unique <WallpaperEngine::Audio::Drivers::Detectors::CAudioPlayingDetector> (this->m_context, *this->m_fullScreenDetector);
+        m_audioDetector = std::make_unique <WallpaperEngine::Audio::Drivers::Detectors::AudioPlayingDetector> (this->m_context, *this->m_fullScreenDetector);
     }
 
     // initialize sdl audio driver
-    m_audioDriver = std::make_unique <WallpaperEngine::Audio::Drivers::CSDLAudioDriver> (this->m_context, *this->m_audioDetector, *this->m_audioRecorder);
+    m_audioDriver = std::make_unique <WallpaperEngine::Audio::Drivers::SDLAudioDriver> (this->m_context, *this->m_audioDetector, *this->m_audioRecorder);
     // initialize audio context
-    m_audioContext = std::make_unique <WallpaperEngine::Audio::CAudioContext> (*m_audioDriver);
+    m_audioContext = std::make_unique <WallpaperEngine::Audio::AudioContext> (*m_audioDriver);
 }
 
-void CWallpaperApplication::prepareOutputs () {
+void WallpaperApplication::prepareOutputs () {
     // initialize render context
-    m_renderContext = std::make_unique <WallpaperEngine::Render::CRenderContext> (*m_videoDriver, *this);
+    m_renderContext = std::make_unique <WallpaperEngine::Render::RenderContext> (*m_videoDriver, *this);
     // create a new background for each screen
 
     // set all the specific wallpapers required
@@ -369,7 +381,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]
             )
@@ -377,7 +389,7 @@ void CWallpaperApplication::prepareOutputs () {
     }
 }
 
-void CWallpaperApplication::show () {
+void WallpaperApplication::show () {
     this->setupOutput ();
     this->setupAudio ();
     this->prepareOutputs ();
@@ -386,10 +398,10 @@ void CWallpaperApplication::show () {
     static struct tm* timeinfo;
 
     if (this->m_context.settings.general.dumpStructure) {
-        auto prettyPrinter = PrettyPrinter::CPrettyPrinter ();
+        auto prettyPrinter = Data::Dumpers::StringPrinter ();
 
         for (const auto& [background, info] : this->m_renderContext->getWallpapers ()) {
-            prettyPrinter.printWallpaper (*info);
+            prettyPrinter.printWallpaper (info->getWallpaperData ());
         }
 
         std::cout << prettyPrinter.str () << std::endl;
@@ -406,7 +418,6 @@ void CWallpaperApplication::show () {
     std::vector<uint8_t> pixels(width * height * 3);
     bool initialized = false;
     int frame = 0;
-    int elapsed_frames = 0;
 #endif /* DEMOMODE */
 
     while (this->m_context.state.general.keepRunning) {
@@ -432,12 +443,10 @@ void CWallpaperApplication::show () {
         }
 
 #if DEMOMODE
-        elapsed_frames ++;
-
         // wait for a full render cycle before actually starting
         // this gives some extra time for video and web decoders to set themselves up
         // because of size changes
-        if (elapsed_frames > this->m_context.settings.render.maximumFPS) {
+        if (m_videoDriver->getFrameCounter () > this->m_context.settings.render.maximumFPS) {
             if (!initialized) {
                 width = this->m_renderContext->getWallpapers ().begin ()->second->getWidth ();
                 height = this->m_renderContext->getWallpapers ().begin ()->second->getHeight ();
@@ -483,25 +492,24 @@ void CWallpaperApplication::show () {
     SDL_Quit ();
 }
 
-void CWallpaperApplication::update (Render::Drivers::Output::COutputViewport* viewport) {
+void WallpaperApplication::update (Render::Drivers::Output::OutputViewport* viewport) {
     // render the scene
     m_renderContext->render (viewport);
 }
 
-void CWallpaperApplication::signal (int signal) {
+void WallpaperApplication::signal (int signal) {
     sLog.out ("Stop requested by signal ", 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>& WallpaperApplication::getBackgrounds () const {
     return this->m_backgrounds;
 }
 
-CApplicationContext& CWallpaperApplication::getContext () const {
+ApplicationContext& WallpaperApplication::getContext () const {
     return this->m_context;
 }
 
-const WallpaperEngine::Render::Drivers::Output::COutput& CWallpaperApplication::getOutput () const {
+const WallpaperEngine::Render::Drivers::Output::Output& WallpaperApplication::getOutput () const {
     return this->m_renderContext->getOutput ();
 }
-} // namespace WallpaperEngine::Application

src/WallpaperEngine/Application/CWallpaperApplication.h → src/WallpaperEngine/Application/WallpaperApplication.h

@@ -1,31 +1,30 @@
 #pragma once
 
-#include "WallpaperEngine/Application/CApplicationContext.h"
+#include "WallpaperEngine/Application/ApplicationContext.h"
+#include "WallpaperEngine/Assets/AssetLocator.h"
 
-#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"
-#include "WallpaperEngine/Render/Drivers/Detectors/CFullScreenDetector.h"
-#include "WallpaperEngine/Render/Drivers/Output/CGLFWWindowOutput.h"
+#include "WallpaperEngine/Render/Drivers/Detectors/FullScreenDetector.h"
+#include "WallpaperEngine/Render/Drivers/GLFWOpenGLDriver.h"
+#include "WallpaperEngine/Render/Drivers/Output/GLFWWindowOutput.h"
+#include "WallpaperEngine/Render/RenderContext.h"
+
+#include "WallpaperEngine/Audio/Drivers/SDLAudioDriver.h"
 
-#include "WallpaperEngine/Audio/Drivers/CSDLAudioDriver.h"
+#include "WallpaperEngine/Input/InputContext.h"
+#include "WallpaperEngine/WebBrowser/WebBrowserContext.h"
 
-#include "WallpaperEngine/Input/CInputContext.h"
-#include "WallpaperEngine/WebBrowser/CWebBrowserContext.h"
+#include "WallpaperEngine/Data/Model/Types.h"
 
 namespace WallpaperEngine::Application {
+using namespace WallpaperEngine::Assets;
+using namespace WallpaperEngine::Data::Model;
 /**
  * Small wrapper class over the actual wallpaper's main application skeleton
- *
- * @author Alexis Maiquez <almamu@almamu.com>
  */
-class CWallpaperApplication {
+class WallpaperApplication {
   public:
-    explicit CWallpaperApplication (CApplicationContext& context);
+    explicit WallpaperApplication (ApplicationContext& context);
 
     /**
      * Shows the application until it's closed
@@ -40,28 +39,27 @@ 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
      */
-    [[nodiscard]] CApplicationContext& getContext () const;
+    [[nodiscard]] ApplicationContext& getContext () const;
     /**
      * Renders a frame
      */
-    void update (Render::Drivers::Output::COutputViewport* viewport);
+    void update (Render::Drivers::Output::OutputViewport* viewport);
     /**
      * Gets the output
      */
-    [[nodiscard]] const WallpaperEngine::Render::Drivers::Output::COutput& getOutput () const;
+    [[nodiscard]] const WallpaperEngine::Render::Drivers::Output::Output& getOutput () const;
 
   private:
     /**
-     * Sets up a combined container for the given background, adding default files and directories to the list
+     * Sets up an asset locator for the given background
      *
-     * @param container
      * @param bg
      */
-    void setupContainer (const std::shared_ptr<CCombinedContainer>& container, const std::string& bg) const;
+    AssetLocatorUniquePtr setupAssetLocator (const std::string& bg) const;
     /**
      * Loads projects based off the settings
      */
@@ -72,7 +70,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 +80,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
      */
@@ -107,17 +105,17 @@ class CWallpaperApplication {
     void takeScreenshot (const std::filesystem::path& filename) const;
 
     /** The application context that contains the current app settings */
-    CApplicationContext& m_context;
+    ApplicationContext& 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;
-    std::unique_ptr <WallpaperEngine::Audio::Drivers::CSDLAudioDriver> m_audioDriver = nullptr;
-    std::unique_ptr <WallpaperEngine::Audio::Drivers::Recorders::CPlaybackRecorder> m_audioRecorder = nullptr;
-    std::unique_ptr <WallpaperEngine::Render::CRenderContext> m_renderContext = nullptr;
-    std::unique_ptr <WallpaperEngine::Render::Drivers::CVideoDriver> m_videoDriver = nullptr;
-    std::unique_ptr <WallpaperEngine::Render::Drivers::Detectors::CFullScreenDetector> m_fullScreenDetector = nullptr;
-    std::unique_ptr <WallpaperEngine::WebBrowser::CWebBrowserContext> m_browserContext = nullptr;
+    std::unique_ptr <WallpaperEngine::Audio::Drivers::Detectors::AudioPlayingDetector> m_audioDetector = nullptr;
+    std::unique_ptr <WallpaperEngine::Audio::AudioContext> m_audioContext = nullptr;
+    std::unique_ptr <WallpaperEngine::Audio::Drivers::SDLAudioDriver> m_audioDriver = nullptr;
+    std::unique_ptr <WallpaperEngine::Audio::Drivers::Recorders::PlaybackRecorder> m_audioRecorder = nullptr;
+    std::unique_ptr <WallpaperEngine::Render::RenderContext> m_renderContext = nullptr;
+    std::unique_ptr <WallpaperEngine::Render::Drivers::VideoDriver> m_videoDriver = nullptr;
+    std::unique_ptr <WallpaperEngine::Render::Drivers::Detectors::FullScreenDetector> m_fullScreenDetector = nullptr;
+    std::unique_ptr <WallpaperEngine::WebBrowser::WebBrowserContext> m_browserContext = nullptr;
 };
 } // namespace WallpaperEngine::Application

src/WallpaperEngine/Assets/AssetLoadException.cpp

@@ -0,0 +1,6 @@
+#include "AssetLoadException.h"
+
+using namespace WallpaperEngine::Assets;
+
+AssetLoadException::AssetLoadException (const std::filesystem::filesystem_error& filesystem_error) noexcept
+: std::filesystem::filesystem_error (filesystem_error) {}

src/WallpaperEngine/Assets/AssetLoadException.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <filesystem>
+
+namespace WallpaperEngine::Assets {
+class AssetLoadException final : public std::filesystem::filesystem_error {
+  public:
+    using std::filesystem::filesystem_error::filesystem_error;
+    explicit AssetLoadException (const std::filesystem::filesystem_error& filesystem_error) noexcept;
+};
+} // namespace WallpaperEngine::Assets

src/WallpaperEngine/Assets/AssetLocator.cpp

@@ -0,0 +1,97 @@
+#include "AssetLocator.h"
+
+#include "AssetLoadException.h"
+
+using namespace WallpaperEngine::Assets;
+
+AssetLocator::AssetLocator (ContainerUniquePtr filesystem) : m_filesystem (std::move (filesystem)) {}
+
+std::string AssetLocator::shader (const std::filesystem::path& filename) const {
+    try {
+        std::filesystem::path shader = filename;
+
+        // detect workshop shaders and check if there's a
+        if (auto it = shader.begin (); *it++ == "workshop") {
+            const std::filesystem::path workshopId = *it++;
+
+            if (++it != shader.end ()) {
+                const std::filesystem::path& shaderfile = *it;
+
+                try {
+                    shader = std::filesystem::path ("zcompat") / "scene" / "shaders" / workshopId / shaderfile;
+                    // replace the old path with the new one
+                    std::string contents = this->m_filesystem->readString (shader);
+
+                    sLog.out ("Replaced ", filename, " with compat ", shader);
+
+                    return contents;
+                } catch (std::filesystem::filesystem_error&) {
+                    // these exceptions can be ignored because the replacement file might not exist
+                }
+            }
+        }
+
+        return this->m_filesystem->readString ("shaders" / filename);
+    } catch (std::filesystem::filesystem_error& base) {
+        throw AssetLoadException (base);
+    }
+}
+
+std::string AssetLocator::fragmentShader (const std::filesystem::path& filename) const {
+    auto final = filename;
+
+    final.replace_extension ("frag");
+
+    return this->shader (final);
+}
+
+std::string AssetLocator::vertexShader (const std::filesystem::path& filename) const {
+    auto final = filename;
+
+    final.replace_extension ("vert");
+
+    return this->shader (final);
+}
+
+std::string AssetLocator::includeShader (const std::filesystem::path& filename) const {
+    auto final = filename;
+
+    final.replace_extension ("h");
+
+    return this->shader (final);
+}
+
+std::string AssetLocator::readString (const std::filesystem::path& filename) const {
+    try {
+        return this->m_filesystem->readString (filename);
+    } catch (std::filesystem::filesystem_error& base) {
+        throw AssetLoadException (base);
+    }
+}
+
+
+ReadStreamSharedPtr AssetLocator::texture (const std::filesystem::path& filename) const {
+    const auto final = std::filesystem::path("materials") / filename.string ().append (".tex");
+
+    try {
+        return this->m_filesystem->read (final);
+    } catch (std::filesystem::filesystem_error& base) {
+        throw AssetLoadException (base);
+    }
+}
+
+ReadStreamSharedPtr AssetLocator::read (const std::filesystem::path& path) const {
+    try {
+        return this->m_filesystem->read (path);
+    } catch (std::filesystem::filesystem_error& base) {
+        throw AssetLoadException (base);
+    }
+}
+
+std::filesystem::path AssetLocator::physicalPath (const std::filesystem::path& path) const {
+    try {
+        return this->m_filesystem->physicalPath (path);
+    } catch (std::filesystem::filesystem_error& base) {
+        throw AssetLoadException (base);
+    }
+}

src/WallpaperEngine/Assets/AssetLocator.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "WallpaperEngine/FileSystem/Container.h"
+
+namespace WallpaperEngine::Assets {
+using namespace WallpaperEngine::FileSystem;
+using namespace WallpaperEngine::Data::Model;
+class AssetLocator {
+  public:
+    explicit AssetLocator (ContainerUniquePtr filesystem);
+
+    std::string vertexShader (const std::filesystem::path& filename) const;
+    std::string fragmentShader (const std::filesystem::path& filename) const;
+    std::string includeShader (const std::filesystem::path& filename) const;
+    ReadStreamSharedPtr texture (const std::filesystem::path& filename) const;
+    std::string readString (const std::filesystem::path& filename) const;
+    ReadStreamSharedPtr read (const std::filesystem::path& path) const;
+    std::filesystem::path physicalPath (const std::filesystem::path& path) const;
+
+  private:
+    std::string shader (const std::filesystem::path& filename) const;
+
+    ContainerUniquePtr m_filesystem;
+};
+
+using AssetLocatorUniquePtr = std::unique_ptr<AssetLocator>;
+}

src/WallpaperEngine/Assets/CAssetLoadException.cpp

@@ -1,10 +0,0 @@
-#include "CAssetLoadException.h"
-
-using namespace WallpaperEngine::Assets;
-
-CAssetLoadException::CAssetLoadException (const std::string& filename, const std::string& extrainfo) :
-    m_message ("Cannot find file " + filename + ": " + extrainfo) {}
-
-const char* CAssetLoadException::what () const noexcept {
-    return this->m_message.c_str ();
-}

src/WallpaperEngine/Assets/CAssetLoadException.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <exception>
-#include <string>
-
-namespace WallpaperEngine::Assets {
-class CAssetLoadException final : public std::exception {
-  public:
-    explicit CAssetLoadException (const std::string& filename, const std::string& extrainfo = "");
-    [[nodiscard]] const char* what () const noexcept override;
-
-  private:
-    std::string m_message {};
-};
-} // namespace WallpaperEngine::Assets

src/WallpaperEngine/Assets/CCombinedContainer.cpp

@@ -1,57 +0,0 @@
-#include "CCombinedContainer.h"
-#include "CAssetLoadException.h"
-#include "CPackage.h"
-#include "CPackageLoadException.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine::Assets;
-
-CCombinedContainer::CCombinedContainer () : CContainer () {}
-
-void CCombinedContainer::add (const std::shared_ptr<CContainer>& container) {
-    this->m_containers.emplace_back (container);
-}
-
-void CCombinedContainer::addPkg (const std::filesystem::path& path) {
-    try {
-        // add the package to the list
-        this->add (std::make_shared<CPackage> (path));
-        sLog.out ("Detected ", path.filename (), " file at ", path, ". Adding to list of searchable paths");
-    } catch (CPackageLoadException&) {
-        // ignore this error, the package file was not found
-        sLog.out ("No ", path.filename (), " file found at ", path, ". Defaulting to normal folder storage");
-    } catch (std::runtime_error& ex) {
-        // the package was found but there was an error loading it (wrong header or something)
-        sLog.exception ("Failed to load ", path.filename(), " file: ", ex.what ());
-    }
-}
-
-std::filesystem::path CCombinedContainer::resolveRealFile (const std::filesystem::path& filename) const {
-    for (const auto& cur : this->m_containers) {
-        try {
-            // try to read the file on the current container, if the file doesn't exists
-            // an exception will be thrown
-            return cur->resolveRealFile (filename);
-        } catch (CAssetLoadException&) {
-            // not found in this container, next try
-        }
-    }
-
-    // no container was able to load the file, abort!
-    throw CAssetLoadException (filename, "Cannot resolve file in any of the containers");
-}
-
-std::shared_ptr<const uint8_t[]> CCombinedContainer::readFile (const std::filesystem::path& filename, uint32_t* length) const {
-    for (const auto& cur : this->m_containers) {
-        try {
-            // try to read the file on the current container, if the file doesn't exists
-            // an exception will be thrown
-            return cur->readFile (filename, length);
-        } catch (CAssetLoadException& e) {
-            // not found in this container, next try
-        }
-    }
-
-    // no container was able to load the file, abort!
-    throw CAssetLoadException (filename, "Cannot find file in any of the containers");
-}

src/WallpaperEngine/Assets/CCombinedContainer.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include "CContainer.h"
-
-#include <filesystem>
-#include <stdexcept>
-#include <vector>
-
-namespace WallpaperEngine::Assets {
-/**
- * A meta-container that allows backgrounds to have files spread across different containers
- */
-class CCombinedContainer final : public CContainer {
-  public:
-    CCombinedContainer ();
-
-    /**
-     * Adds a container to the list
-     *
-     * @param container
-     */
-    void add (const std::shared_ptr<CContainer>& container);
-    /**
-     * Adds the given package to the list
-     *
-     * @param path
-     */
-    void addPkg (const std::filesystem::path& path);
-
-    [[nodiscard]] std::filesystem::path resolveRealFile (const std::filesystem::path& filename) const override;
-    [[nodiscard]] std::shared_ptr<const uint8_t[]> readFile (const std::filesystem::path& filename, uint32_t* length) const override;
-
-  private:
-    /** The list of containers to search files off from */
-    std::vector<std::shared_ptr<CContainer>> m_containers {};
-};
-}; // namespace WallpaperEngine::Assets

src/WallpaperEngine/Assets/CContainer.cpp

@@ -1,78 +0,0 @@
-#include "CContainer.h"
-#include "CAssetLoadException.h"
-#include "CTexture.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-#include <cstring>
-#include <filesystem>
-#include <utility>
-
-using namespace WallpaperEngine::Assets;
-
-std::filesystem::path CContainer::resolveRealFile (const std::filesystem::path& filename) const {
-    throw CAssetLoadException (filename, "Cannot resolve physical file in this container");
-}
-
-std::shared_ptr <const ITexture> CContainer::readTexture (const std::filesystem::path& filename) const {
-    // get the texture's filename (usually .tex)
-    std::filesystem::path texture = "materials" / std::filesystem::path (filename.string ().append (".tex"));
-
-    const auto textureContents = this->readFile (texture, nullptr);
-    const auto result = std::make_shared<CTexture> (textureContents);
-
-#if !NDEBUG
-    glObjectLabel (GL_TEXTURE, result->getTextureID (0), -1, texture.c_str ());
-#endif /* NDEBUG */
-
-    return result;
-}
-
-std::string CContainer::readShader (const std::filesystem::path& filename) const {
-    std::filesystem::path shader = filename;
-    auto it = shader.begin ();
-
-    // detect workshop shaders and check if there's a
-    if (*it++ == "workshop") {
-        const std::filesystem::path workshopId = *it++;
-
-        if (++it != shader.end ()) {
-            const std::filesystem::path& shaderfile = *it;
-
-            try {
-                shader = std::filesystem::path ("zcompat") / "scene" / "shaders" / workshopId / shaderfile;
-                // replace the old path with the new one
-                std::string contents = this->readFileAsString (shader);
-
-                sLog.out ("Replaced ", filename, " with compat ", shader);
-
-                return contents;
-            } catch (CAssetLoadException&) {}
-        }
-    }
-
-    return this->readFileAsString ("shaders" / filename);
-}
-
-std::string CContainer::readVertexShader (const std::filesystem::path& filename) const {
-    std::filesystem::path shader = filename;
-    shader.replace_extension (".vert");
-    return this->readShader (shader);
-}
-
-std::string CContainer::readFragmentShader (const std::filesystem::path& filename) const {
-    std::filesystem::path shader = filename;
-    shader.replace_extension (".frag");
-    return this->readShader (shader);
-}
-
-std::string CContainer::readIncludeShader (const std::filesystem::path& filename) const {
-    return this->readFileAsString ("shaders" / filename);
-}
-
-std::string CContainer::readFileAsString (const std::filesystem::path& filename) const {
-    uint32_t length = 0;
-
-    return {
-        reinterpret_cast<const char*> (this->readFile (filename, &length).get ()), length
-    };
-}

src/WallpaperEngine/Assets/CContainer.h

@@ -1,91 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Assets/ITexture.h"
-
-#include <filesystem>
-#include <string>
-
-namespace WallpaperEngine::Assets {
-/**
- * File container, provides access to files for backgrounds
- */
-class CContainer {
-  public:
-    virtual ~CContainer () = default;
-
-    /**
-     * Resolves the full path to the specified file in the filesystem
-     *
-     * @param filename
-     * @return
-     */
-    [[nodiscard]] virtual std::filesystem::path resolveRealFile (const std::filesystem::path& filename) const;
-
-    /**
-     * Reads the given file from the container and returns it's data
-     * Additionally sets a length parameter to return back the file's length
-     *
-     * The returned string must be deleted[] by the caller
-     *
-     * @param filename The file to read
-     * @param length The file's length after it's been read, null for not getting anything back
-     *
-     * @return
-     */
-    [[nodiscard]] virtual std::shared_ptr<const uint8_t[]> readFile (const std::filesystem::path& filename, uint32_t* length) const = 0;
-
-    /**
-     * Wrapper for readFile, appends the texture extension at the end of the filename
-     *
-     * @param filename The texture name (without the .tex)
-     *
-     * @return
-     */
-    [[nodiscard]] std::shared_ptr <const ITexture> readTexture (const std::filesystem::path& filename) const;
-
-    /**
-     * Wrapper for readFile, checks for compat versions of the given shader file
-     *
-     * @param filename
-     *
-     * @return The shader code as an string to be used
-     */
-    [[nodiscard]] std::string readShader (const std::filesystem::path& filename) const;
-
-    /**
-     * Wrapper for readFile, appends the .vert extension at the end and opens the given shader file
-     *
-     * @param filename
-     *
-     * @return The shader code as an string to be used
-     */
-    [[nodiscard]] std::string readVertexShader (const std::filesystem::path& filename) const;
-
-    /**
-     * Wrapper for readFile, appends the .frag extension at the end and opens the given shader file
-     *
-     * @param filename
-     *
-     * @return The shader code as an string to be used
-     */
-    [[nodiscard]] std::string readFragmentShader (const std::filesystem::path& filename) const;
-
-    /**
-     * Wrapper for readFile, appends the .h extension at the end and opens the given shader file
-     *
-     * @param filename
-     *
-     * @return The shader code as an string to be used
-     */
-    [[nodiscard]] std::string readIncludeShader (const std::filesystem::path& filename) const;
-
-    /**
-     * Reads a file as string
-     *
-     * @param filename
-     *
-     * @return The file's contents as string
-     */
-    [[nodiscard]] std::string readFileAsString (const std::filesystem::path& filename) const;
-};
-} // namespace WallpaperEngine::Assets

src/WallpaperEngine/Assets/CDirectory.cpp

@@ -1,85 +0,0 @@
-#include "CAssetLoadException.h"
-#include "CDirectory.h"
-
-using namespace WallpaperEngine::Assets;
-
-CDirectory::CDirectory (const std::filesystem::path& basepath) {
-    try {
-        // resolve the path to it's real location
-        std::filesystem::path finalpath = std::filesystem::canonical(basepath);
-        std::filesystem::file_status status = std::filesystem::status (finalpath);
-
-        if (!std::filesystem::exists (finalpath)) {
-            throw CAssetLoadException (basepath, "Cannot find directory");
-        }
-
-        if (!std::filesystem::is_directory(status)) {
-            throw CAssetLoadException (basepath, "Expected directory but found a file");
-        }
-
-        this->m_basepath = finalpath;
-    } catch (std::bad_alloc&) {
-        throw CAssetLoadException (basepath, "Cannot allocate memory");
-    } catch (std::filesystem::filesystem_error& e) {
-        throw CAssetLoadException (basepath, e.what ());
-    }
-}
-
-std::filesystem::path CDirectory::resolveRealFile (const std::filesystem::path& filename) const {
-    try {
-        std::filesystem::path final = std::filesystem::canonical (this->m_basepath / filename);
-
-        // first validate the path, so the message doesn't reflect if the file exists or not unless it's under the actual directory
-        if (final.string ().find (this->m_basepath.string ()) != 0) {
-            throw CAssetLoadException (filename, "File is not a child of the given directory");
-        }
-
-        std::filesystem::file_status status = std::filesystem::status (final);
-
-        if (!std::filesystem::exists (final)) {
-            throw CAssetLoadException (filename, "Cannot find file");
-        }
-
-        if (!std::filesystem::is_regular_file (status)) {
-            throw CAssetLoadException (filename, "Expected file but found a directory");
-        }
-
-        return final;
-    } catch (std::filesystem::filesystem_error& e) {
-        throw CAssetLoadException (filename, e.what ());
-    }
-}
-
-std::shared_ptr<const uint8_t[]> CDirectory::readFile (const std::filesystem::path& filename, uint32_t* length) const {
-    std::filesystem::path final = this->resolveRealFile (filename);
-
-    FILE* fp = fopen (final.c_str (), "rb");
-
-    if (fp == nullptr) {
-        throw CAssetLoadException (filename, "Cannot open file for reading");
-    }
-
-    try {
-        // go to the end, get the position and return to the beginning
-        fseek (fp, 0, SEEK_END);
-        const long size = ftell (fp);
-        fseek (fp, 0, SEEK_SET);
-
-        // now read the whole file
-        std::shared_ptr<uint8_t[]> contents = std::shared_ptr<uint8_t[]>(new uint8_t [size]);
-
-        if (fread (contents.get(), size, 1, fp) != 1) {
-            throw CAssetLoadException (filename, "Unexpected error when reading the file");
-        }
-
-        if (length != nullptr) {
-            *length = size;
-        }
-
-        fclose (fp);
-        return contents;
-    } catch (std::filesystem::filesystem_error& e) {
-        fclose (fp);
-        throw CAssetLoadException (filename, e.what ());
-    }
-}

src/WallpaperEngine/Assets/CDirectory.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <filesystem>
-#include <map>
-#include <stdexcept>
-#include <string>
-
-#include "CContainer.h"
-#include "CFileEntry.h"
-
-namespace WallpaperEngine::Assets {
-/**
- * Directory container implementation, provides access to background files under a specific directory
- */
-class CDirectory final : public CContainer {
-  public:
-    explicit CDirectory (const std::filesystem::path& basepath);
-
-    [[nodiscard]] std::filesystem::path resolveRealFile (const std::filesystem::path& filename) const override;
-    [[nodiscard]] std::shared_ptr<const uint8_t[]> readFile (const std::filesystem::path& filename, uint32_t* length) const override;
-
-  private:
-    /** The basepath for the directory */
-    std::filesystem::path m_basepath {};
-};
-} // namespace WallpaperEngine::Assets

src/WallpaperEngine/Assets/CFileEntry.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <utility>
-
-namespace WallpaperEngine::Assets {
-/**
- * File cache entry to prevent hit the disk when loading the same file multiple times
- */
-class CFileEntry {
-  public:
-    CFileEntry (std::shared_ptr<const uint8_t[]> content, uint32_t length) :
-        content (std::move(content)),
-        length (length) {}
-    ~CFileEntry() = default;
-
-    /** File contents */
-    std::shared_ptr<const uint8_t[]> content = nullptr;
-    /** File length */
-    uint32_t length = 0;
-};
-} // namespace WallpaperEngine::Assets

src/WallpaperEngine/Assets/CPackage.cpp

@@ -1,135 +0,0 @@
-#include "CPackage.h"
-#include "CAssetLoadException.h"
-#include "CPackageLoadException.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-#include <sstream>
-#include <utility>
-
-using namespace WallpaperEngine::Assets;
-
-class CPackageEntry {
-  public:
-    CPackageEntry (std::string filename, uint32_t offset, uint32_t length) :
-        filename (filename),
-        offset (offset),
-        length (length) {}
-
-    std::string filename;
-    uint32_t offset;
-    uint32_t length;
-};
-
-CPackage::CPackage (std::filesystem::path path) : m_path (std::move (path)) {
-    this->init ();
-}
-
-std::shared_ptr<const uint8_t[]> CPackage::readFile (const std::filesystem::path& filename, uint32_t* length) const {
-    const auto it = this->m_contents.find (filename);
-
-    if (it == this->m_contents.end ())
-        throw CAssetLoadException (filename, "Cannot find the file in the package");
-
-    // set file length if required
-    if (length != nullptr)
-        *length = it->second->length;
-
-    return it->second->content;
-}
-
-void CPackage::init () {
-    FILE* fp = fopen (this->m_path.c_str (), "rb+");
-
-    if (fp == nullptr)
-        throw CPackageLoadException (this->m_path, std::to_string (errno));
-
-    // first validate header
-    this->validateHeader (fp);
-    // header is okay, load everything into memory
-    this->loadFiles (fp);
-
-    fclose (fp);
-}
-
-char* CPackage::readSizedString (FILE* fp) {
-    unsigned int length = 0;
-
-    if (fread (&length, sizeof (unsigned int), 1, fp) != 1)
-        sLog.exception ("Cannot read sized string length on file ", this->m_path);
-
-    // account for 0 termination of the string
-    length++;
-
-    char* pointer = new char [length];
-    memset (pointer, 0, length);
-
-    // read only the string bytes so the last one in the memory is 0
-    length--;
-
-    // read data from file
-    if (fread (pointer, sizeof (char), length, fp) != length)
-        sLog.exception ("Not enough bytes to read string of length ", length, " on file ", this->m_path);
-
-    return pointer;
-}
-
-uint32_t CPackage::readInteger (FILE* fp) {
-    uint32_t output;
-
-    if (fread (&output, sizeof (uint32_t), 1, fp) != 1)
-        sLog.exception ("Not enough bytes to read an integer from file ", this->m_path);
-
-    return output;
-}
-
-void CPackage::validateHeader (FILE* fp) {
-    const char* pointer = this->readSizedString (fp);
-
-    if (strncmp ("PKGV", pointer, 4) != 0) {
-        std::stringstream msg;
-        msg << "Expected PKGV indicator, found " << pointer;
-        delete [] pointer;
-        throw std::runtime_error (msg.str ());
-    }
-
-    // free memory
-    delete [] pointer;
-}
-
-void CPackage::loadFiles (FILE* fp) {
-    const uint32_t count = this->readInteger (fp);
-    std::vector<CPackageEntry> list;
-
-    for (uint32_t index = 0; index < count; index++) {
-        // first read the filename
-        char* filename = this->readSizedString (fp);
-        uint32_t offset = this->readInteger (fp);
-        uint32_t length = this->readInteger (fp);
-
-        // add the file to the list
-        list.emplace_back (filename, offset, length);
-        // only free filename, the file's contents are stored in a map for a later use
-        delete [] filename;
-    }
-
-    // get current baseOffset, this is where the files start
-    const long baseOffset = ftell (fp);
-
-    for (const auto& cur : list) {
-        const long offset = cur.offset + baseOffset;
-
-        // with all the data we can jump to the offset and read the content
-        if (fseek (fp, offset, SEEK_SET) != 0)
-            sLog.exception ("Cannot find file ", cur.filename, " from package ", this->m_path);
-
-        // allocate memory for the file's contents and read it from the file
-        std::shared_ptr<uint8_t[]> contents = std::shared_ptr<uint8_t[]>(new uint8_t [cur.length]);
-
-        if (fread (contents.get(), cur.length, 1, fp) != 1) {
-            sLog.exception ("Cannot read file ", cur.filename, " contents from package ", this->m_path);
-        }
-
-        // add the file to the map
-        this->m_contents.insert_or_assign (cur.filename, std::make_unique<CFileEntry> (contents, cur.length));
-    }
-}

src/WallpaperEngine/Assets/CPackage.h

@@ -1,68 +0,0 @@
-#pragma once
-
-#include <cstring>
-#include <exception>
-#include <filesystem>
-#include <map>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-#include "CContainer.h"
-#include "CFileEntry.h"
-
-namespace WallpaperEngine::Assets {
-/**
- * Package container implementation, provides access to background files that are stored
- * inside the WallpaperEngine's pkg format
- */
-class CPackage final : public CContainer {
-  public:
-    explicit CPackage (std::filesystem::path path);
-
-    [[nodiscard]] std::shared_ptr<const uint8_t[]> readFile (const std::filesystem::path& filename, uint32_t* length) const override;
-
-  protected:
-    /**
-     * Loads the current package file and loads all it's contents to memory
-     */
-    void init ();
-
-    /**
-     * Reads the header from the current position and ensures it's a compatible version
-     *
-     * @param fp The file where to read from
-     */
-    void validateHeader (FILE* fp);
-
-    /**
-     * Loads the files in the package into memory
-     *
-     * @param fp The file where to read from
-     */
-    void loadFiles (FILE* fp);
-
-    /**
-     * Reads a size-prefixed string
-     *
-     * @param fp File to read from
-     *
-     * @return The read data, important to free it
-     */
-    char* readSizedString (FILE* fp);
-    /**
-     * Reads a simple unsigned of 32 bits
-     *
-     * @param fp File to read from
-     *
-     * @return The read value
-     */
-    uint32_t readInteger (FILE* fp);
-
-  private:
-    /** The path to the package file */
-    std::filesystem::path m_path {};
-    /** Contents of the package file */
-    std::map<std::string, std::unique_ptr<CFileEntry>> m_contents {};
-};
-} // namespace WallpaperEngine::Assets

src/WallpaperEngine/Assets/CPackageLoadException.cpp

@@ -1,10 +0,0 @@
-#include "CPackageLoadException.h"
-
-using namespace WallpaperEngine::Assets;
-
-CPackageLoadException::CPackageLoadException (const std::string& filename, const std::string& extrainfo) :
-    m_message ("Cannot load package " + filename + ": " + extrainfo) {}
-
-const char* CPackageLoadException::what () const noexcept {
-    return this->m_message.c_str ();
-}

src/WallpaperEngine/Assets/CPackageLoadException.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <exception>
-#include <string>
-
-namespace WallpaperEngine::Assets {
-class CPackageLoadException final : public std::exception {
-  public:
-    explicit CPackageLoadException (const std::string& filename, const std::string& extrainfo = "");
-    [[nodiscard]] const char* what () const noexcept override;
-
-  private:
-    std::string m_message {};
-};
-} // namespace WallpaperEngine::Assets

src/WallpaperEngine/Assets/CTexture.cpp

@@ -1,462 +0,0 @@
-#include "CTexture.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-#include <cstring>
-#include <lz4.h>
-#include <string>
-
-#define STB_IMAGE_IMPLEMENTATION
-#include <stb_image.h>
-
-using namespace WallpaperEngine::Assets;
-
-CTexture::CTexture (const std::shared_ptr<const uint8_t[]>& buffer) : m_resolution () {
-    // ensure the header is parsed
-    const void* fileData = buffer.get ();
-    this->m_header = parseHeader (static_cast<const char*> (fileData));
-    this->setupResolution ();
-    GLint internalFormat = this->setupInternalFormat();
-
-    // allocate texture ids list
-    this->m_textureID = new GLuint [this->m_header->imageCount];
-    // ask opengl for the correct amount of textures
-    glGenTextures (this->m_header->imageCount, this->m_textureID);
-
-    auto imgCur = this->m_header->images.begin ();
-    auto imgEnd = this->m_header->images.end ();
-
-    for (int index = 0; imgCur != imgEnd; ++imgCur, index++) {
-        this->setupOpenGLParameters (index);
-
-        auto cur = imgCur->second.begin ();
-        auto end = imgCur->second.end ();
-
-        for (int32_t level = 0; cur != end; ++cur, level++) {
-            stbi_uc* handle = nullptr;
-            void* dataptr = (*cur)->uncompressedData.get ();
-            int width = (*cur)->width;
-            int height = (*cur)->height;
-            uint32_t bufferSize = (*cur)->uncompressedSize;
-            GLenum textureFormat = GL_RGBA;
-
-            if (this->m_header->freeImageFormat != FreeImageFormat::FIF_UNKNOWN) {
-                int fileChannels;
-
-                dataptr = handle = stbi_load_from_memory (
-                    reinterpret_cast <unsigned char*> ((*cur)->uncompressedData.get ()),
-                    (*cur)->uncompressedSize,
-                    &width,
-                    &height,
-                    &fileChannels,
-                    4);
-            } else {
-                if (this->m_header->format == TextureFormat::R8) {
-                    // red textures are 1-byte-per-pixel, so it's alignment has to be set manually
-                    glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
-                    textureFormat = GL_RED;
-                } else if (this->m_header->format == TextureFormat::RG88) {
-                    textureFormat = GL_RG;
-                }
-            }
-
-            switch (internalFormat) {
-                case GL_RGBA8:
-                case GL_RG8:
-                case GL_R8:
-                    glTexImage2D (
-                        GL_TEXTURE_2D, level, internalFormat, width, height, 0, textureFormat,
-                        GL_UNSIGNED_BYTE, dataptr);
-                    break;
-                case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-                case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-                case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-                    glCompressedTexImage2D (
-                        GL_TEXTURE_2D, level, internalFormat, width, height, 0, bufferSize,
-                        dataptr);
-                    break;
-                default: sLog.exception ("Cannot load texture, unknown format", this->m_header->format);
-            }
-
-            // stbi_image buffer won't be used anymore, so free memory
-            if (this->m_header->freeImageFormat != FreeImageFormat::FIF_UNKNOWN) {
-                stbi_image_free (handle);
-            }
-        }
-    }
-}
-
-void CTexture::setupResolution () {
-    if (this->isAnimated ()) {
-        this->m_resolution = {this->m_header->textureWidth, this->m_header->textureHeight, this->m_header->gifWidth,
-                              this->m_header->gifHeight};
-    } else {
-        if (this->m_header->freeImageFormat != FreeImageFormat::FIF_UNKNOWN) {
-            // wpengine-texture format always has one mipmap
-            // get first image size
-            auto element = this->m_header->images.find (0)->second.begin ();
-
-            // set the texture resolution
-            this->m_resolution = {(*element)->width, (*element)->height, this->m_header->width, this->m_header->height};
-        } else {
-            // set the texture resolution
-            this->m_resolution = {this->m_header->textureWidth, this->m_header->textureHeight, this->m_header->width,
-                                  this->m_header->height};
-        }
-    }
-}
-
-GLint CTexture::setupInternalFormat () {
-    if (this->m_header->freeImageFormat != FreeImageFormat::FIF_UNKNOWN) {
-        return GL_RGBA8;
-        // set some extra information too as it's used for image sizing
-        // this ensures that a_TexCoord uses the full image instead of just part of it
-        // TODO: MAYBE IT'S BETTER TO CREATE A TEXTURE OF THE GIVEN SIZE AND COPY OVER WHAT WE READ FROM THE FILE?
-        /*this->m_header->width = this->m_header->mipmaps [0]->width;
-        this->m_header->height = this->m_header->mipmaps [0]->height;
-        this->m_header->textureWidth = this->m_header->mipmaps [0]->width;
-        this->m_header->textureHeight = this->m_header->mipmaps [0]->height;*/
-    } else {
-        // detect the image format and hand it to openGL to be used
-        switch (this->m_header->format) {
-            case TextureFormat::DXT5: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break;
-            case TextureFormat::DXT3: return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break;
-            case TextureFormat::DXT1: return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break;
-            case TextureFormat::ARGB8888: return GL_RGBA8; break;
-            case TextureFormat::R8: return GL_R8; break;
-            case TextureFormat::RG88: return GL_RG8; break;
-            default: sLog.exception ("Cannot determine texture format");
-        }
-    }
-}
-
-void CTexture::setupOpenGLParameters (uint32_t textureID) {
-        // bind the texture to assign information to it
-        glBindTexture (GL_TEXTURE_2D, this->m_textureID [textureID]);
-
-        // set mipmap levels
-        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
-        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, this->m_header->images [textureID].size () - 1);
-
-        // setup texture wrapping and filtering
-        if (this->m_header->flags & TextureFlags::ClampUVs) {
-            glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-            glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        } else {
-            glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-            glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-        }
-
-        if (this->m_header->flags & TextureFlags::NoInterpolation) {
-            glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-            glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
-        } else {
-            glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-            glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-        }
-
-        glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY, 8.0f);
-}
-
-GLuint CTexture::getTextureID (uint32_t imageIndex) const {
-    // ensure we do not go out of bounds
-    if (imageIndex >= this->m_header->imageCount)
-        return this->m_textureID [0];
-
-    return this->m_textureID [imageIndex];
-}
-
-uint32_t CTexture::getTextureWidth (uint32_t imageIndex) const {
-    if (imageIndex >= this->m_header->imageCount)
-        return this->getHeader ()->textureWidth;
-
-    return (*this->m_header->images [imageIndex].begin ())->width;
-}
-
-uint32_t CTexture::getTextureHeight (uint32_t imageIndex) const {
-    if (imageIndex >= this->m_header->imageCount)
-        return this->getHeader ()->textureHeight;
-
-    return (*this->m_header->images [imageIndex].begin ())->height;
-}
-
-uint32_t CTexture::getRealWidth () const {
-    return this->isAnimated () ? this->getHeader ()->gifWidth : this->getHeader ()->width;
-}
-
-uint32_t CTexture::getRealHeight () const {
-    return this->isAnimated () ? this->getHeader ()->gifHeight : this->getHeader ()->height;
-}
-
-ITexture::TextureFormat CTexture::getFormat () const {
-    return this->getHeader ()->format;
-}
-
-ITexture::TextureFlags CTexture::getFlags () const {
-    return this->getHeader ()->flags;
-}
-
-const CTexture::TextureHeader* CTexture::getHeader () const {
-    return this->m_header.get ();
-}
-
-const glm::vec4* CTexture::getResolution () const {
-    return &this->m_resolution;
-}
-
-const std::vector<std::shared_ptr<ITexture::TextureFrame>>& CTexture::getFrames () const {
-    return this->getHeader ()->frames;
-}
-
-bool CTexture::isAnimated () const {
-    return this->getHeader ()->isAnimated ();
-}
-
-void CTexture::TextureMipmap::decompressData () {
-    if (this->compression != 1) {
-        return;
-    }
-
-    this->uncompressedData = std::unique_ptr <char[]> (new char [this->uncompressedSize]);
-
-    const int result = LZ4_decompress_safe (
-        this->compressedData.get (), this->uncompressedData.get (), this->compressedSize,
-        this->uncompressedSize);
-
-    if (!result)
-        sLog.exception ("Cannot decompress texture data, LZ4_decompress_safe returned an error");
-}
-
-CTexture::TextureFrame::TextureFrame () :
-    frameNumber (0),
-    frametime (0.0f),
-    x (0),
-    y (0),
-    width1 (0),
-    width2 (0),
-    height1 (0),
-    height2 (0) {}
-
-CTexture::TextureHeader::TextureHeader () :
-    flags (NoFlags),
-    width (0),
-    height (0),
-    textureWidth (0),
-    textureHeight (0),
-    gifWidth (0),
-    gifHeight (0),
-    format (TextureFormat::UNKNOWN),
-    imageCount (0),
-    isVideoMp4 (false) {}
-
-std::unique_ptr<CTexture::TextureHeader> CTexture::parseHeader (const char* fileData) {
-    // check the magic value on the header first
-    if (strncmp (fileData, "TEXV0005", 9) != 0)
-        sLog.exception ("unexpected texture container type: ", std::string_view (fileData, 9));
-    // jump to the next value
-    fileData += 9;
-    // check the sub-magic value on the header
-    if (strncmp (fileData, "TEXI0001", 9) != 0)
-        sLog.exception ("unexpected texture sub-container type: ", std::string_view (fileData, 9));
-    // jump through the string again
-    fileData += 9;
-
-    auto header = std::make_unique <TextureHeader> ();
-    const auto* pointer = reinterpret_cast<const uint32_t*> (fileData);
-
-    header->format = static_cast<TextureFormat> (*pointer++);
-    header->flags = static_cast<TextureFlags> (*pointer++);
-    header->textureWidth = *pointer++;
-    header->textureHeight = *pointer++;
-    header->width = *pointer++;
-    header->height = *pointer++;
-    pointer++; // ignore some more bytes
-
-    // now we're going to parse some more data that is string
-    // so get the current position back as string
-    fileData = reinterpret_cast<const char*> (pointer);
-    // get the position of what comes after the texture data
-    pointer = reinterpret_cast<const uint32_t*> (fileData + 9);
-
-    header->imageCount = *pointer++;
-
-    if (strncmp (fileData, "TEXB0004", 9) == 0) {
-        header->containerVersion = ContainerVersion::TEXB0004;
-        header->freeImageFormat = static_cast<FreeImageFormat> (*pointer++);
-        header->isVideoMp4 = *pointer++ == 1;
-
-        if (header->freeImageFormat == FIF_UNKNOWN) {
-            header->freeImageFormat = FIF_MP4;
-        }
-
-        // default to TEXB0003 behavior if no mp4 video is there
-        if (header->freeImageFormat != FIF_MP4) {
-            header->containerVersion = ContainerVersion::TEXB0003;
-        }
-    } else if (strncmp (fileData, "TEXB0003", 9) == 0) {
-        header->containerVersion = ContainerVersion::TEXB0003;
-        header->freeImageFormat = static_cast<FreeImageFormat> (*pointer++);
-    } else if (strncmp (fileData, "TEXB0002", 9) == 0) {
-        header->containerVersion = ContainerVersion::TEXB0002;
-    } else if (strncmp (fileData, "TEXB0001", 9) == 0) {
-        header->containerVersion = ContainerVersion::TEXB0001;
-    } else {
-        sLog.exception ("unknown texture format type: ", std::string_view (fileData, 9));
-    }
-
-    for (uint32_t image = 0; image < header->imageCount; image++) {
-        // read the number of mipmaps available for this image
-        uint32_t mipmapCount = *pointer++;
-        std::vector<std::shared_ptr<TextureMipmap>> mipmaps;
-
-        fileData = reinterpret_cast<const char*> (pointer);
-
-        for (uint32_t i = 0; i < mipmapCount; i++)
-            mipmaps.emplace_back (parseMipmap (header.get (), &fileData));
-
-        // add the pixmaps back
-        header->images.emplace (image, mipmaps);
-
-        pointer = reinterpret_cast<const uint32_t*> (fileData);
-    }
-
-    // gifs have extra information after the mipmaps
-    if (header->isAnimated ()) {
-        if (strncmp (fileData, "TEXS0002", 9) == 0) {
-            header->animatedVersion = AnimatedVersion::TEXS0002;
-        } else if (strncmp (fileData, "TEXS0003", 9) == 0) {
-            header->animatedVersion = AnimatedVersion::TEXS0003;
-        } else {
-            sLog.exception ("found animation information of unknown type: ", std::string_view (fileData, 9));
-        }
-
-        // get an integer pointer back to read the frame count
-        pointer = reinterpret_cast<const uint32_t*> (fileData + 9);
-        uint32_t framecount = *pointer++;
-
-        if (header->animatedVersion == AnimatedVersion::TEXS0003) {
-            // ignore two extra integers as those are width and height of the git
-            header->gifWidth = *pointer++;
-            header->gifHeight = *pointer++;
-        }
-
-        // get back the pointer into filedata
-        fileData = reinterpret_cast<const char*> (pointer);
-
-        while (framecount > 0) {
-            // add the frame to the list
-            header->frames.push_back (parseAnimation (&fileData));
-
-            framecount--;
-        }
-
-        // ensure gif width and height is right for TEXS0002
-        if (header->animatedVersion == AnimatedVersion::TEXS0002) {
-            auto first = *header->frames.begin ();
-
-            header->gifWidth = first->width1;
-            header->gifHeight = first->height1;
-        }
-    }
-
-    return header;
-}
-
-std::shared_ptr<CTexture::TextureFrame> CTexture::parseAnimation (const char** originalFileData) {
-    const char* fileData = *originalFileData;
-    // get back the pointer into integer
-    const auto* pointer = reinterpret_cast<const uint32_t*> (fileData);
-
-    // start reading frame information
-    auto frame = std::make_shared <TextureFrame> ();
-
-    frame->frameNumber = *pointer++;
-
-    // reinterpret the pointer into float
-    const auto* fPointer = reinterpret_cast<const float*> (pointer);
-
-    frame->frametime = *fPointer++;
-    frame->x = *fPointer++;
-    frame->y = *fPointer++;
-    frame->width1 = *fPointer++;
-    frame->width2 = *fPointer++;
-    frame->height2 = *fPointer++;
-    frame->height1 = *fPointer++;
-
-    // get back the pointer into fileData so it can be reused later
-    *originalFileData = reinterpret_cast<const char*> (fPointer);
-
-    return frame;
-}
-
-std::shared_ptr<CTexture::TextureMipmap> CTexture::parseMipmap (const TextureHeader* header, const char** originalFileData) {
-    auto mipmap = std::make_shared <TextureMipmap> ();
-    // get the current position
-    const char* fileData = *originalFileData;
-
-    // get an integer pointer
-    const auto* pointer = reinterpret_cast<const uint32_t*> (fileData);
-
-    // TEXB004 have some extra data (and even json) that we have to take into account
-    if (header->containerVersion == ContainerVersion::TEXB0004) {
-        // ignore various params, RePKG doesn't really use them
-        // and could be related to the editor really, so just ignore them
-        pointer++;
-        pointer++;
-
-        fileData = reinterpret_cast<const char*> (pointer);
-        while (*fileData != 0) {
-            mipmap->json += *fileData++;
-        }
-
-        // skip the null terminator
-        fileData ++;
-
-        pointer = reinterpret_cast<const uint32_t*> (fileData);
-    }
-
-    mipmap->width = *pointer++;
-    mipmap->height = *pointer++;
-
-    if (header->containerVersion == ContainerVersion::TEXB0002 ||
-        header->containerVersion == ContainerVersion::TEXB0003 ||
-        header->containerVersion == ContainerVersion::TEXB0004) {
-        mipmap->compression = *pointer++;
-        mipmap->uncompressedSize = *pointer++;
-    }
-
-    mipmap->compressedSize = *pointer++;
-
-    // get back a normal char pointer
-    fileData = reinterpret_cast<const char*> (pointer);
-
-    if (mipmap->compression == 0) {
-        // this might be better named as mipmap_bytes_size instead of compressedSize
-        // as in uncompressed files this variable actually holds the file length
-        mipmap->uncompressedSize = mipmap->compressedSize;
-    }
-
-    mipmap->uncompressedData = std::unique_ptr<char[]>(new char [mipmap->uncompressedSize]);
-
-    if (mipmap->compression == 1) {
-        mipmap->compressedData = std::unique_ptr<char[]>(new char [mipmap->compressedSize]);
-
-        memcpy (mipmap->compressedData.get (), fileData, mipmap->compressedSize);
-
-        mipmap->decompressData ();
-        // advance to the end of the mipmap
-        fileData += mipmap->compressedSize;
-    } else {
-        memcpy (mipmap->uncompressedData.get (), fileData, mipmap->uncompressedSize);
-        // advance to the end of the mipmap
-        fileData += mipmap->uncompressedSize;
-    }
-
-    // ensure the pointer is updated with the latest position when reading the data
-    *originalFileData = fileData;
-
-    return mipmap;
-}
-
-bool CTexture::TextureHeader::isAnimated () const {
-    return this->flags & TextureFlags::IsGif;
-}

src/WallpaperEngine/Assets/CTexture.h

@@ -1,213 +0,0 @@
-#pragma once
-
-#include "ITexture.h"
-
-#include <GL/glew.h>
-#include <glm/vec4.hpp>
-#include <map>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-namespace WallpaperEngine::Assets {
-/**
- * A normal texture file in WallpaperEngine's format
- */
-class CTexture final : public ITexture {
-    /**
-     * Different texture container versions supported
-     */
-    enum ContainerVersion : int {
-        UNKNOWN = -1,
-        TEXB0004 = 4,
-        TEXB0003 = 3,
-        TEXB0002 = 2,
-        TEXB0001 = 1
-    };
-
-    /**
-     * Different texture animation versions supported
-     */
-    enum AnimatedVersion : int {
-        TEXSUNKN = -1,
-        TEXS0002 = 0,
-        TEXS0003 = 1,
-    };
-
-    enum FreeImageFormat : int {
-        FIF_UNKNOWN = -1,
-        FIF_BMP		= 0,
-        FIF_ICO		= 1,
-        FIF_JPEG	= 2,
-        FIF_JNG		= 3,
-        FIF_KOALA	= 4,
-        FIF_LBM		= 5,
-        FIF_IFF         = FIF_LBM,
-        FIF_MNG		= 6,
-        FIF_PBM		= 7,
-        FIF_PBMRAW	= 8,
-        FIF_PCD		= 9,
-        FIF_PCX		= 10,
-        FIF_PGM		= 11,
-        FIF_PGMRAW	= 12,
-        FIF_PNG		= 13,
-        FIF_PPM		= 14,
-        FIF_PPMRAW	= 15,
-        FIF_RAS		= 16,
-        FIF_TARGA	= 17,
-        FIF_TIFF	= 18,
-        FIF_WBMP	= 19,
-        FIF_PSD		= 20,
-        FIF_CUT		= 21,
-        FIF_XBM		= 22,
-        FIF_XPM		= 23,
-        FIF_DDS		= 24,
-        FIF_GIF         = 25,
-        FIF_HDR		= 26,
-        FIF_FAXG3	= 27,
-        FIF_SGI		= 28,
-        FIF_EXR		= 29,
-        FIF_J2K		= 30,
-        FIF_JP2		= 31,
-        FIF_PFM		= 32,
-        FIF_PICT	= 33,
-        FIF_RAW		= 34,
-        FIF_WEBP	= 35,
-        FIF_MP4         = FIF_WEBP,
-        FIF_JXR		= 36
-    };
-
-    /**
-     * Texture mipmap data
-     */
-    class TextureMipmap {
-      public:
-        /** Width of the mipmap */
-        uint32_t width = 0;
-        /** Height of the mipmap */
-        uint32_t height = 0;
-        /** If the mipmap data is compressed */
-        uint32_t compression = 0;
-        /** Uncompressed size of the mipmap */
-        uint32_t uncompressedSize = 0;
-        /** Compress size of the mipmap */
-        uint32_t compressedSize = 0;
-        /** Pointer to the compressed data */
-        std::unique_ptr<char[]> compressedData = nullptr;
-        /** Pointer to the uncompressed data */
-        std::unique_ptr<char[]> uncompressedData = nullptr;
-        /** JSON data */
-        std::string json {};
-        /**
-         * Performs actual decompression of the compressed data
-         */
-        void decompressData ();
-    };
-
-    /**
-     * Texture header data
-     */
-    class TextureHeader {
-      public:
-        TextureHeader ();
-        ~TextureHeader () = default;
-
-        [[nodiscard]] bool isAnimated () const;
-
-        /** The version of the texture container */
-        ContainerVersion containerVersion = ContainerVersion::UNKNOWN;
-        /** The version of the animated data */
-        AnimatedVersion animatedVersion = AnimatedVersion::TEXSUNKN;
-        /** Flags with extra texture information */
-        TextureFlags flags = TextureFlags::NoFlags;
-        /** Real width of the texture */
-        uint32_t width = 0;
-        /** Real height of the texture */
-        uint32_t height = 0;
-        /** Texture width in memory (power of 2) */
-        uint32_t textureWidth = 0;
-        /** Texture height in memory (power of 2) */
-        uint32_t textureHeight = 0;
-        /** Gif width */
-        uint32_t gifWidth = 0;
-        /** Gif height */
-        uint32_t gifHeight = 0;
-        /** Texture data format */
-        TextureFormat format = TextureFormat::UNKNOWN;
-        /** Free Image format */
-        FreeImageFormat freeImageFormat = FreeImageFormat::FIF_UNKNOWN;
-        /** Indicates if we have an MP4 video */
-        bool isVideoMp4 = false;
-        /** The amount of images in the texture file */
-        uint32_t imageCount = 0;
-        /** List of mipmaps */
-        std::map<uint32_t, std::vector<std::shared_ptr<TextureMipmap>>> images {};
-        /** List of animation frames */
-        std::vector<std::shared_ptr<TextureFrame>> frames {};
-    };
-
-  public:
-    explicit CTexture (const std::shared_ptr<const uint8_t[]>& fileData);
-
-    [[nodiscard]] GLuint getTextureID (uint32_t imageIndex) const override;
-    [[nodiscard]] uint32_t getTextureWidth (uint32_t imageIndex) const override;
-    [[nodiscard]] uint32_t getTextureHeight (uint32_t imageIndex) const override;
-    [[nodiscard]] uint32_t getRealWidth () const override;
-    [[nodiscard]] uint32_t getRealHeight () const override;
-    [[nodiscard]] TextureFormat getFormat () const override;
-    [[nodiscard]] TextureFlags getFlags () const override;
-    [[nodiscard]] const glm::vec4* getResolution () const override;
-    [[nodiscard]] const std::vector<std::shared_ptr<TextureFrame>>& getFrames () const override;
-    [[nodiscard]] bool isAnimated () const override;
-
-  private:
-    /**
-     * @return The texture header
-     */
-    [[nodiscard]] const TextureHeader* getHeader () const;
-
-    /**
-     * Tries to parse a header off the given data pointer
-     *
-     * @param fileData The point at which to start reading data off from
-     * @return
-     */
-    static std::unique_ptr<TextureHeader> parseHeader (const char* fileData);
-    /**
-     * Tries to parse an animation frame off the given data pointer
-     *
-     * @param originalFileData The point at which to start reading data off from
-     * @return
-     */
-    static std::shared_ptr<TextureFrame> parseAnimation (const char** originalFileData);
-    /**
-     * Tries to parse mipmap information off the given data pointer
-     *
-     * @param header The file header
-     * @param fileData The point at which to start reading data off from
-     * @return
-     */
-    static std::shared_ptr<TextureMipmap> parseMipmap (const TextureHeader* header, const char** fileData);
-
-    /**
-     * Calculate's texture's resolution vec4
-     */
-    void setupResolution ();
-    /**
-     * Determines the texture's internal storage format
-     */
-    GLint setupInternalFormat ();
-    /**
-     * Prepares openGL parameters for loading texture data
-     */
-    void setupOpenGLParameters (uint32_t textureID);
-
-    /** The texture header */
-    std::unique_ptr<TextureHeader> m_header = nullptr;
-    /** OpenGL's texture ID */
-    GLuint* m_textureID = nullptr;
-    /** Resolution vector of the texture */
-    glm::vec4 m_resolution {};
-};
-} // namespace WallpaperEngine::Assets

src/WallpaperEngine/Assets/CVirtualContainer.cpp

@@ -1,42 +0,0 @@
-#include <memory.h>
-
-#include "CAssetLoadException.h"
-#include "CVirtualContainer.h"
-
-using namespace WallpaperEngine::Assets;
-
-void CVirtualContainer::add (const std::filesystem::path& filename, const std::shared_ptr<const uint8_t[]>& contents, uint32_t length) {
-    this->m_virtualFiles.emplace (filename, std::make_unique<CFileEntry> (contents, length));
-}
-
-void CVirtualContainer::add (const std::filesystem::path& filename, const std::string& contents) {
-    size_t length = contents.length () + 1;
-    std::shared_ptr<uint8_t[]> copy = std::shared_ptr<uint8_t[]> (new uint8_t [length]);
-
-    // copy the text AND the \0
-    memcpy (copy.get(), contents.c_str (), length);
-
-    // finally add to the container
-    this->add (filename, copy, length);
-}
-
-void CVirtualContainer::add (const std::filesystem::path& filename, const char* contents) {
-    this->add (filename, std::string (contents));
-}
-
-void CVirtualContainer::add (const std::filesystem::path& filename, const json& contents) {
-    this->add (filename, contents.dump ());
-}
-
-std::shared_ptr<const uint8_t[]> CVirtualContainer::readFile (const std::filesystem::path& filename, uint32_t* length) const {
-    const auto cur = this->m_virtualFiles.find (filename);
-
-    if (cur == this->m_virtualFiles.end ())
-        throw CAssetLoadException (filename, "Cannot find file in the virtual container");
-
-    if (length != nullptr)
-        *length = cur->second->length;
-
-    // clone original first
-    return cur->second->content;
-}

src/WallpaperEngine/Assets/CVirtualContainer.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <map>
-#include <string>
-#include <filesystem>
-
-#include "CContainer.h"
-#include "CFileEntry.h"
-#include <nlohmann/json.hpp>
-
-
-namespace WallpaperEngine::Assets {
-using json = nlohmann::json;
-/**
- * Virtual container implementation, provides virtual files for the backgrounds to use
- */
-class CVirtualContainer final : public CContainer {
-  public:
-    /**
-     * Adds a new file to the virtual container
-     *
-     * @param filename
-     * @param contents
-     * @param length
-     */
-    void add (const std::filesystem::path& filename, const std::shared_ptr<const uint8_t[]>& contents, uint32_t length);
-
-    /**
-     * Adds a new file to the virtual container
-     *
-     * @param filename
-     * @param contents
-     */
-    void add (const std::filesystem::path& filename, const std::string& contents);
-
-    /**
-     * Adds a new file to the virtual container
-     *
-     * @param filename
-     * @param contents
-     */
-    void add (const std::filesystem::path& filename, const char* contents);
-    /**
-     * Adds a new file to the virtual container from a json object
-     * @param filename
-     * @param contents
-     */
-    void add (const std::filesystem::path& filename, const json& contents);
-
-    /** @inheritdoc */
-    std::shared_ptr<const uint8_t[]> readFile (const std::filesystem::path& filename, uint32_t* length) const override;
-
-  private:
-    /** The recorded files in this virtual container */
-    std::map<std::string, std::unique_ptr<CFileEntry>> m_virtualFiles = {};
-};
-} // namespace WallpaperEngine::Assets

src/WallpaperEngine/Assets/ITexture.h

@@ -1,118 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <memory>
-
-#include <GL/glew.h>
-#include <glm/vec4.hpp>
-
-namespace WallpaperEngine::Assets {
-/**
- * Base interface that describes the minimum information required for a texture
- * to be displayed by the engine
- */
-class ITexture {
-  public:
-    virtual ~ITexture () = default;
-
-    /**
-     * Texture frame information for animated textures
-     */
-    class TextureFrame final {
-      public:
-        TextureFrame ();
-        virtual ~TextureFrame () = default;
-
-        /** The image index of this frame */
-        uint32_t frameNumber = 0;
-        /** The amount of time this frame spends being displayed */
-        float frametime = 0.0f;
-        /** The x position of the frame in the texture */
-        float x = 0.0f;
-        /** The y position of the frame in the texture */
-        float y = 0.0f;
-        /** The width of the frame in the texture */
-        float width1 = 0.0f;
-        float width2 = 0.0f;
-        /** The height of the frame in the texture */
-        float height1 = 0.0f;
-        float height2 = 0.0f;
-    };
-
-    /**
-     * Data formats for textures in memory
-     */
-    enum TextureFormat : uint32_t {
-        UNKNOWN = 0xFFFFFFFF,
-        ARGB8888 = 0,
-        RGB888 = 1,
-        RGB565 = 2,
-        DXT5 = 4,
-        DXT3 = 6,
-        DXT1 = 7,
-        RG88 = 8,
-        R8 = 9,
-        RG1616f = 10,
-        R16f = 11,
-        BC7 = 12,
-        RGBa1010102 = 13,
-        RGBA16161616f = 14,
-        RGB161616f = 15,
-    };
-
-    /**
-     * Different settings of the textures
-     */
-    enum TextureFlags : uint32_t {
-        NoFlags = 0,
-        NoInterpolation = 1,
-        ClampUVs = 2,
-        IsGif = 4,
-        ClampUVsBorder = 8,
-    };
-
-    /**
-     * @param imageIndex For animated textures, the frame to get the ID of
-     * @return The OpenGL texture to use when rendering
-     */
-    [[nodiscard]] virtual GLuint getTextureID (uint32_t imageIndex) const = 0;
-    /**
-     * @param imageIndex For animated textures, the frame to get the ID of
-     * @return The texture's width
-     */
-    [[nodiscard]] virtual uint32_t getTextureWidth (uint32_t imageIndex) const = 0;
-    /**
-     * @param imageIndex For animated textures, the frame to get the ID of
-     * @return The texture's height
-     */
-    [[nodiscard]] virtual uint32_t getTextureHeight (uint32_t imageIndex) const = 0;
-    /**
-     * @return The textures real width
-     */
-    [[nodiscard]] virtual uint32_t getRealWidth () const = 0;
-    /**
-     * @return The textures real height
-     */
-    [[nodiscard]] virtual uint32_t getRealHeight () const = 0;
-    /**
-     * @return The texture's memory format
-     */
-    [[nodiscard]] virtual TextureFormat getFormat () const = 0;
-    /**
-     * @return The texture's settings
-     */
-    [[nodiscard]] virtual TextureFlags getFlags () const = 0;
-    /**
-     * @return The list of frames this texture has
-     */
-    [[nodiscard]] virtual const std::vector<std::shared_ptr<TextureFrame>>& getFrames () const = 0;
-    /**
-     * @return The texture's resolution vector
-     */
-    [[nodiscard]] virtual const glm::vec4* getResolution () const = 0;
-    /**
-     * @return If the texture is animated or not
-     */
-    [[nodiscard]] virtual bool isAnimated () const = 0;
-};
-} // namespace WallpaperEngine::Assets

src/WallpaperEngine/Audio/AudioContext.cpp

@@ -0,0 +1,30 @@
+#include "AudioContext.h"
+#include "WallpaperEngine/Audio/Drivers/AudioDriver.h"
+
+namespace WallpaperEngine::Audio {
+AudioContext::AudioContext (Drivers::AudioDriver& driver) : m_driver (driver) {}
+
+void AudioContext::addStream (AudioStream* stream) const {
+    this->m_driver.addStream (stream);
+}
+
+AVSampleFormat AudioContext::getFormat () const {
+    return this->m_driver.getFormat ();
+}
+
+int AudioContext::getSampleRate () const {
+    return this->m_driver.getSampleRate ();
+}
+
+int AudioContext::getChannels () const {
+    return this->m_driver.getChannels ();
+}
+
+Application::ApplicationContext& AudioContext::getApplicationContext () const {
+    return this->m_driver.getApplicationContext ();
+}
+
+Drivers::Recorders::PlaybackRecorder& AudioContext::getRecorder () const {
+    return this->m_driver.getRecorder ();
+}
+} // namespace WallpaperEngine::Audio

src/WallpaperEngine/Audio/CAudioContext.h → src/WallpaperEngine/Audio/AudioContext.h

@@ -3,35 +3,35 @@
 #include <libavutil/samplefmt.h>
 #include <vector>
 
-#include "WallpaperEngine/Application/CApplicationContext.h"
-#include "WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.h"
+#include "WallpaperEngine/Application/ApplicationContext.h"
+#include "WallpaperEngine/Audio/Drivers/Recorders/PulseAudioPlaybackRecorder.h"
 
 namespace WallpaperEngine {
 namespace Application {
-class CApplicationContext;
+class ApplicationContext;
 }
 
 namespace Audio {
 namespace Drivers {
-class CAudioDriver;
+class AudioDriver;
 
 namespace Recorders {
-class CPulseAudioPlaybackRecorder;
+class PulseAudioPlaybackRecorder;
 }
 } // namespace Drivers
 
-class CAudioStream;
+class AudioStream;
 
-class CAudioContext {
+class AudioContext {
   public:
-    explicit CAudioContext (Drivers::CAudioDriver& driver);
+    explicit AudioContext (Drivers::AudioDriver& driver);
 
     /**
      * Registers the given stream in the driver for playing
      *
      * @param stream
      */
-    void addStream (CAudioStream* stream);
+    void addStream (AudioStream* stream) const;
 
     /**
      * TODO: MAYBE THIS SHOULD BE OUR OWN DEFINITIONS INSTEAD OF LIBRARY SPECIFIC ONES?
@@ -50,15 +50,15 @@ class CAudioContext {
     /**
      * @return The application context under which the audio driver is initialized
      */
-    Application::CApplicationContext& getApplicationContext ();
+    Application::ApplicationContext& getApplicationContext () const;
     /**
      * @return The audio recorder to use to capture stereo mix data
      */
-    [[nodiscard]] Drivers::Recorders::CPlaybackRecorder& getRecorder ();
+    [[nodiscard]] Drivers::Recorders::PlaybackRecorder& getRecorder () const;
 
   private:
     /** The audio driver in use */
-    Drivers::CAudioDriver& m_driver;
+    Drivers::AudioDriver& m_driver;
 };
 } // namespace Audio
 } // namespace WallpaperEngine

src/WallpaperEngine/Audio/CAudioStream.cpp → src/WallpaperEngine/Audio/AudioStream.cpp

@@ -1,5 +1,5 @@
-#include "CAudioStream.h"
-#include "WallpaperEngine/Logging/CLog.h"
+#include "AudioStream.h"
+#include "WallpaperEngine/Logging/Log.h"
 #include <cassert>
 #include <cmath>
 #include <iostream>
@@ -10,7 +10,7 @@ using namespace WallpaperEngine::Audio;
 
 int audio_read_thread (void* arg) {
     SDL_mutex* waitMutex = SDL_CreateMutex ();
-    auto* stream = static_cast<CAudioStream*> (arg);
+    auto* stream = static_cast<AudioStream*> (arg);
     AVPacket* packet = av_packet_alloc ();
     int ret = 0;
 
@@ -60,38 +60,36 @@ int audio_read_thread (void* arg) {
 }
 
 static int audio_read_data_callback (void* streamarg, uint8_t* buffer, int buffer_size) {
-    const auto stream = static_cast<CAudioStream*> (streamarg);
-    const int left = stream->getLength () - stream->getPosition ();
+    const auto stream = static_cast<AudioStream*> (streamarg);
 
-    buffer_size = FFMIN (buffer_size, left);
+    stream->getBuffer ()->read (reinterpret_cast<std::istream::char_type*> (buffer), buffer_size);
 
-    memcpy (buffer, stream->getBuffer ().get() + stream->getPosition (), buffer_size);
-    // update position
-    stream->setPosition (stream->getPosition () + buffer_size);
-
-    return buffer_size;
+    // return read bytes only
+    return stream->getBuffer ()->gcount ();
 }
 
 int64_t audio_seek_data_callback (void* streamarg, int64_t offset, int whence) {
-    const auto stream = static_cast<CAudioStream*> (streamarg);
+    const auto stream = static_cast<AudioStream*> (streamarg);
 
+    // this was supported before, now we don't as there's no easy way to tell length
+    // so returning <0 signals no support for it
     if (whence & AVSEEK_SIZE)
-        return stream->getLength ();
+        return -1;
 
     switch (whence) {
-        case SEEK_CUR: stream->setPosition (stream->getPosition () + offset); break;
-        case SEEK_SET: stream->setPosition (offset); break;
+        case SEEK_CUR: stream->getBuffer ()->seekg (offset, std::ios_base::cur); break;
+        case SEEK_SET: stream->getBuffer ()->seekg (offset, std::ios_base::beg); break;
     }
 
     return offset;
 }
 
-CAudioStream::CAudioStream (CAudioContext& context, const std::string& filename) :
+AudioStream::AudioStream (AudioContext& context, const std::string& filename) :
     m_audioContext (context) {
     this->loadCustomContent (filename.c_str ());
 }
 
-CAudioStream::CAudioStream (CAudioContext& context, std::shared_ptr<const uint8_t[]> buffer, uint32_t length) :
+AudioStream::AudioStream (AudioContext& context, const ReadStreamSharedPtr& buffer) :
     m_audioContext (context) {
     // setup a custom context first
     this->m_formatContext = avformat_alloc_context ();
@@ -100,8 +98,6 @@ CAudioStream::CAudioStream (CAudioContext& context, std::shared_ptr<const uint8_
         sLog.exception ("Cannot allocate ffmpeg format context");
 
     this->m_buffer = buffer;
-    this->m_length = length;
-    this->m_position = 0;
 
     // setup custom io for it
     this->m_formatContext->pb = avio_alloc_context (static_cast<uint8_t*> (av_malloc (4096)), 4096, 0, this,
@@ -114,14 +110,14 @@ CAudioStream::CAudioStream (CAudioContext& context, std::shared_ptr<const uint8_
     this->loadCustomContent ();
 }
 
-CAudioStream::CAudioStream (CAudioContext& audioContext, AVCodecContext* context) :
+AudioStream::AudioStream (AudioContext& audioContext, AVCodecContext* context) :
     m_audioContext (audioContext),
     m_context (context),
     m_queue (new PacketQueue) {
     this->initialize ();
 }
 
-CAudioStream::~CAudioStream () {
+AudioStream::~AudioStream () {
     if (this->m_swrctx != nullptr && swr_is_initialized (this->m_swrctx) == true)
         swr_close (this->m_swrctx);
     if (this->m_swrctx != nullptr)
@@ -130,7 +126,7 @@ CAudioStream::~CAudioStream () {
     // TODO: FREE EVERYTHING ELSE THAT THIS CLASS HOLDS!
 }
 
-void CAudioStream::loadCustomContent (const char* filename) {
+void AudioStream::loadCustomContent (const char* filename) {
     if (avformat_open_input (&this->m_formatContext, filename, nullptr, nullptr) != 0)
         sLog.exception ("Cannot open audio file: ", filename);
     if (avformat_find_stream_info (this->m_formatContext, nullptr) < 0)
@@ -173,7 +169,7 @@ void CAudioStream::loadCustomContent (const char* filename) {
     SDL_CreateThread (audio_read_thread, filename, this);
 }
 
-void CAudioStream::initialize () {
+void AudioStream::initialize () {
 // allocate the FIFO buffer
 #if FF_API_FIFO_OLD_API
     this->m_queue->packetList = av_fifo_alloc (sizeof (MyAVPacketList));
@@ -229,7 +225,7 @@ void CAudioStream::initialize () {
     this->m_initialized = true;
 }
 
-void CAudioStream::queuePacket (AVPacket* pkt) {
+void AudioStream::queuePacket (AVPacket* pkt) {
     // clone the packet
     AVPacket* clone = av_packet_alloc ();
 
@@ -248,11 +244,11 @@ void CAudioStream::queuePacket (AVPacket* pkt) {
         av_packet_free (&pkt);
 }
 
-bool CAudioStream::doQueue (AVPacket* pkt) {
+bool AudioStream::doQueue (AVPacket* pkt) {
     MyAVPacketList entry {pkt};
 
 #if FF_API_FIFO_OLD_API
-    if (av_fifo_space (this->m_queue->packetList) < sizeof (entry))
+    if (av_fifo_space (this->m_queue->packetList) < static_cast <int> (sizeof (entry)))
         if (av_fifo_grow (this->m_queue->packetList, sizeof (entry)) < 0)
             return false;
 
@@ -272,7 +268,7 @@ bool CAudioStream::doQueue (AVPacket* pkt) {
     return true;
 }
 
-void CAudioStream::dequeuePacket (AVPacket* output) {
+void AudioStream::dequeuePacket (AVPacket* output) {
     MyAVPacketList entry{};
 
     SDL_LockMutex (this->m_queue->mutex);
@@ -281,10 +277,10 @@ void CAudioStream::dequeuePacket (AVPacket* output) {
 #if FF_API_FIFO_OLD_API
         int ret = -1;
 
-        if (av_fifo_size (this->m_queue->packetList) >= sizeof (entry))
+        if (av_fifo_size (this->m_queue->packetList) >= static_cast <int> (sizeof (entry)))
             ret = av_fifo_generic_read (this->m_queue->packetList, &entry, sizeof (entry), nullptr);
 #else
-        int ret = av_fifo_read (this->m_queue->packetList, &entry, 1);
+        const int ret = av_fifo_read (this->m_queue->packetList, &entry, 1);
 #endif
 
         // enough data available, read it
@@ -306,59 +302,47 @@ void CAudioStream::dequeuePacket (AVPacket* output) {
     SDL_UnlockMutex (this->m_queue->mutex);
 }
 
-AVCodecContext* CAudioStream::getContext () {
+AVCodecContext* AudioStream::getContext () const {
     return this->m_context;
 }
 
-AVFormatContext* CAudioStream::getFormatContext () {
+AVFormatContext* AudioStream::getFormatContext () const {
     return this->m_formatContext;
 }
 
-int CAudioStream::getAudioStream () const {
+int AudioStream::getAudioStream () const {
     return this->m_audioStream;
 }
 
-bool CAudioStream::isInitialized () const {
+bool AudioStream::isInitialized () const {
     return this->m_initialized;
 }
 
-void CAudioStream::setRepeat (bool newRepeat) {
+void AudioStream::setRepeat (const bool newRepeat) {
     this->m_repeat = newRepeat;
 }
 
-bool CAudioStream::isRepeat () const {
+bool AudioStream::isRepeat () const {
     return this->m_repeat;
 }
 
-std::shared_ptr<const uint8_t[]> CAudioStream::getBuffer () {
+ReadStreamSharedPtr& AudioStream::getBuffer () {
     return this->m_buffer;
 }
 
-uint32_t CAudioStream::getLength () const {
-    return this->m_length;
-}
-
-uint32_t CAudioStream::getPosition () const {
-    return this->m_position;
-}
-
-void CAudioStream::setPosition (uint32_t current) {
-    this->m_position = current;
-}
-
-SDL_cond* CAudioStream::getWaitCondition () {
+SDL_cond* AudioStream::getWaitCondition () const {
     return this->m_queue->wait;
 }
 
-int CAudioStream::getQueueSize () {
+int AudioStream::getQueueSize () const {
     return this->m_queue->size;
 }
 
-int CAudioStream::getQueuePacketCount () {
+int AudioStream::getQueuePacketCount () const {
     return this->m_queue->nb_packets;
 }
 
-AVRational CAudioStream::getTimeBase () {
+AVRational AudioStream::getTimeBase () const {
     if (this->m_audioStream == NO_AUDIO_STREAM) {
         return {0, 0};
     }
@@ -366,19 +350,19 @@ AVRational CAudioStream::getTimeBase () {
     return this->m_formatContext->streams [this->m_audioStream]->time_base;
 }
 
-int64_t CAudioStream::getQueueDuration () {
+int64_t AudioStream::getQueueDuration () const {
     return this->m_queue->duration;
 }
 
-bool CAudioStream::isQueueEmpty () {
+bool AudioStream::isQueueEmpty () const {
     return this->m_queue->nb_packets == 0;
 }
 
-SDL_mutex* CAudioStream::getMutex () {
+SDL_mutex* AudioStream::getMutex () const {
     return this->m_queue->mutex;
 }
 
-void CAudioStream::stop () {
+void AudioStream::stop () {
     if (!this->isInitialized ())
         return;
 
@@ -386,7 +370,7 @@ void CAudioStream::stop () {
     this->m_initialized = false;
 }
 
-int CAudioStream::resampleAudio (const AVFrame* decoded_audio_frame, uint8_t* out_buf) {
+int AudioStream::resampleAudio (const AVFrame* decoded_audio_frame, uint8_t* out_buf) {
     int out_linesize = 0;
     int ret;
     int out_nb_channels;
@@ -498,7 +482,7 @@ int CAudioStream::resampleAudio (const AVFrame* decoded_audio_frame, uint8_t* ou
     return resampled_data_size;
 }
 
-int CAudioStream::decodeFrame (uint8_t* audioBuffer, int bufferSize) {
+int AudioStream::decodeFrame (uint8_t* audioBuffer, const int bufferSize) {
     AVPacket* pkt = av_packet_alloc ();
     static uint8_t* audio_pkt_data = nullptr;
     static int audio_pkt_size = 0;
@@ -564,6 +548,6 @@ int CAudioStream::decodeFrame (uint8_t* audioBuffer, int bufferSize) {
     return 0;
 }
 
-CAudioContext& CAudioStream::getAudioContext () const {
+AudioContext& AudioStream::getAudioContext () const {
     return this->m_audioContext;
 }

src/WallpaperEngine/Audio/CAudioStream.h → src/WallpaperEngine/Audio/AudioStream.h

@@ -14,7 +14,7 @@ extern "C" {
 #include <SDL.h>
 #include <SDL_thread.h>
 
-#include "WallpaperEngine/Audio/CAudioContext.h"
+#include "WallpaperEngine/Audio/AudioContext.h"
 
 // TODO: FIND A BETTER PLACE TO DO THIS? OLD_API MIGHT EXIST BUT THIS DEFINE MIGHT NOT BE DEFINED...
 #ifndef FF_API_FIFO_OLD_API
@@ -29,17 +29,19 @@ extern "C" {
 #define NO_AUDIO_STREAM (-1)
 
 namespace WallpaperEngine::Audio {
-class CAudioContext;
+class AudioContext;
+
+using namespace WallpaperEngine::FileSystem;
 
 /**
  * Represents a playable audio stream for the audio driver
  */
-class CAudioStream {
+class AudioStream {
   public:
-    CAudioStream (CAudioContext& context, const std::string& filename);
-    CAudioStream (CAudioContext& context, std::shared_ptr<const uint8_t[]> buffer, uint32_t length);
-    CAudioStream (CAudioContext& audioContext, AVCodecContext* context);
-    ~CAudioStream ();
+    AudioStream (AudioContext& context, const std::string& filename);
+    AudioStream (AudioContext& context, const ReadStreamSharedPtr& buffer);
+    AudioStream (AudioContext& audioContext, AVCodecContext* context);
+    ~AudioStream ();
 
     void queuePacket (AVPacket* pkt);
 
@@ -55,16 +57,16 @@ class CAudioStream {
     /**
      * @return The audio context in use for this audio stream
      */
-    [[nodiscard]] CAudioContext& getAudioContext () const;
+    [[nodiscard]] AudioContext& getAudioContext () const;
 
     /**
      * @return to the codec context, which provides information on the audio stream's format
      */
-    AVCodecContext* getContext ();
+    AVCodecContext* getContext () const;
     /**
      * @returns the format context, which controls how data is read off the audio stream
      */
-    AVFormatContext* getFormatContext ();
+    AVFormatContext* getFormatContext () const;
     /**
      * @return The audio stream index of the given file
      */
@@ -88,49 +90,35 @@ class CAudioStream {
     /**
      * @return The file data buffer
      */
-    [[nodiscard]] std::shared_ptr<const uint8_t[]> getBuffer ();
-    /**
-     * @return The length of the file data buffer
-     */
-    [[nodiscard]] uint32_t getLength () const;
-    /**
-     * @return The read position of the data buffer
-     */
-    [[nodiscard]] uint32_t getPosition () const;
-    /**
-     * Updates the read position of the data buffer
-     *
-     * @param current
-     */
-    void setPosition (uint32_t current);
+    [[nodiscard]] ReadStreamSharedPtr& getBuffer ();
     /**
      * @return The SDL_cond used to signal waiting for data
      */
-    SDL_cond* getWaitCondition ();
+    SDL_cond* getWaitCondition () const;
     /**
      * @return The data queue size
      */
-    int getQueueSize ();
+    int getQueueSize () const;
     /**
      * @return The amount of packets ready to be converted and played
      */
-    int getQueuePacketCount ();
+    int getQueuePacketCount () const;
     /**
      * @return The duration (in seconds) of the queued data to be played
      */
-    int64_t getQueueDuration ();
+    int64_t getQueueDuration () const;
     /**
      * @return Time unit used for packet playback
      */
-    AVRational getTimeBase ();
+    AVRational getTimeBase () const;
     /**
      * @return If the data queue is empty or not
      */
-    bool isQueueEmpty ();
+    bool isQueueEmpty () const;
     /**
      * @return The SDL_mutex used for thread synchronization
      */
-    SDL_mutex* getMutex ();
+    SDL_mutex* getMutex () const;
 
     /**
      * Reads a frame from the audio stream, resamples it to the driver's settings
@@ -173,7 +161,7 @@ class CAudioStream {
     /** The SwrContext that handles resampling */
     SwrContext* m_swrctx = nullptr;
     /** The audio context this stream will be played under */
-    CAudioContext& m_audioContext;
+    AudioContext& m_audioContext;
     /** If this stream was properly initialized or not */
     bool m_initialized = false;
     /** Repeat enabled? */
@@ -185,11 +173,9 @@ class CAudioStream {
     /** The stream index for the audio being played */
     int m_audioStream = NO_AUDIO_STREAM;
     /** File data pointer */
-    std::shared_ptr<const uint8_t[]> m_buffer = nullptr;
+    ReadStreamSharedPtr m_buffer = nullptr;
     /** The length of the file data pointer */
     uint32_t m_length = 0;
-    /** The read position on the file data pointer */
-    uint32_t m_position = 0;
 
     struct MyAVPacketList {
         AVPacket* packet;

src/WallpaperEngine/Audio/CAudioContext.cpp

@@ -1,30 +0,0 @@
-#include "CAudioContext.h"
-#include "WallpaperEngine/Audio/Drivers/CAudioDriver.h"
-
-namespace WallpaperEngine::Audio {
-CAudioContext::CAudioContext (Drivers::CAudioDriver& driver) : m_driver (driver) {}
-
-void CAudioContext::addStream (CAudioStream* stream) {
-    this->m_driver.addStream (stream);
-}
-
-AVSampleFormat CAudioContext::getFormat () const {
-    return this->m_driver.getFormat ();
-}
-
-int CAudioContext::getSampleRate () const {
-    return this->m_driver.getSampleRate ();
-}
-
-int CAudioContext::getChannels () const {
-    return this->m_driver.getChannels ();
-}
-
-Application::CApplicationContext& CAudioContext::getApplicationContext () {
-    return this->m_driver.getApplicationContext ();
-}
-
-Drivers::Recorders::CPlaybackRecorder& CAudioContext::getRecorder () {
-    return this->m_driver.getRecorder ();
-}
-} // namespace WallpaperEngine::Audio

src/WallpaperEngine/Audio/Drivers/AudioDriver.cpp

@@ -0,0 +1,28 @@
+#include "AudioDriver.h"
+
+namespace WallpaperEngine::Audio::Drivers {
+AudioDriver::AudioDriver (
+    Application::ApplicationContext& applicationContext, Detectors::AudioPlayingDetector& detector,
+    Recorders::PlaybackRecorder& recorder
+) :
+    m_applicationContext (applicationContext),
+    m_detector (detector),
+    m_recorder (recorder) {}
+
+void AudioDriver::update () {
+    this->m_recorder.update ();
+    this->m_detector.update ();
+}
+
+Application::ApplicationContext& AudioDriver::getApplicationContext () const {
+    return this->m_applicationContext;
+}
+
+Detectors::AudioPlayingDetector& AudioDriver::getAudioDetector () const {
+    return this->m_detector;
+}
+
+Recorders::PlaybackRecorder& AudioDriver::getRecorder () const {
+    return this->m_recorder;
+}
+} // namespace WallpaperEngine::Audio::Drivers

src/WallpaperEngine/Audio/Drivers/CAudioDriver.h → src/WallpaperEngine/Audio/Drivers/AudioDriver.h

@@ -2,44 +2,44 @@
 
 #include <vector>
 
-#include "WallpaperEngine/Application/CApplicationContext.h"
-#include "WallpaperEngine/Audio/CAudioStream.h"
-#include "WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.h"
-#include "WallpaperEngine/Audio/Drivers/Recorders/CPlaybackRecorder.h"
+#include "WallpaperEngine/Application/ApplicationContext.h"
+#include "WallpaperEngine/Audio/AudioStream.h"
+#include "WallpaperEngine/Audio/Drivers/Detectors/AudioPlayingDetector.h"
+#include "WallpaperEngine/Audio/Drivers/Recorders/PlaybackRecorder.h"
 
 namespace WallpaperEngine {
 namespace Application {
-class CApplicationContext;
+class ApplicationContext;
 }
 
 namespace Audio {
-class CAudioStream;
+class AudioStream;
 
 namespace Drivers {
 namespace Detectors {
-class CAudioPlayingDetector;
+class AudioPlayingDetector;
 }
 
 namespace Recorders {
-class CPulseAudioPlaybackRecorder;
+class PulseAudioPlaybackRecorder;
 }
 
 /**
  * Base class for audio driver implementations
  */
-class CAudioDriver {
+class AudioDriver {
   public:
-    explicit CAudioDriver (
-        Application::CApplicationContext& applicationContext, Detectors::CAudioPlayingDetector& detector,
-        Recorders::CPlaybackRecorder& recorder);
+    explicit AudioDriver (
+        Application::ApplicationContext& applicationContext, Detectors::AudioPlayingDetector& detector,
+        Recorders::PlaybackRecorder& recorder);
 
-    virtual ~CAudioDriver () = default;
+    virtual ~AudioDriver () = default;
     /**
      * Registers the given stream in the driver for playing
      *
      * @param stream
      */
-    virtual void addStream (CAudioStream* stream) = 0;
+    virtual void addStream (AudioStream* stream) = 0;
 
     /**
      * Updates status of the different audio settings
@@ -63,20 +63,20 @@ class CAudioDriver {
     /**
      * @return The application context under which the audio driver is initialized
      */
-    Application::CApplicationContext& getApplicationContext ();
+    Application::ApplicationContext& getApplicationContext () const;
     /**
      * @return The audio playing detector to use to stop playing sound when something else starts playing
      */
-    [[nodiscard]] Detectors::CAudioPlayingDetector& getAudioDetector ();
+    [[nodiscard]] Detectors::AudioPlayingDetector& getAudioDetector () const;
     /**
      * @return The audio recorder to use to capture stereo mix data
      */
-    [[nodiscard]] Recorders::CPlaybackRecorder& getRecorder ();
+    [[nodiscard]] Recorders::PlaybackRecorder& getRecorder () const;
 
   private:
-    Application::CApplicationContext& m_applicationContext;
-    Detectors::CAudioPlayingDetector& m_detector;
-    Recorders::CPlaybackRecorder& m_recorder;
+    Application::ApplicationContext& m_applicationContext;
+    Detectors::AudioPlayingDetector& m_detector;
+    Recorders::PlaybackRecorder& m_recorder;
 };
 } // namespace Drivers
 } // namespace Audio

src/WallpaperEngine/Audio/Drivers/CAudioDriver.cpp

@@ -1,28 +0,0 @@
-#include "CAudioDriver.h"
-
-namespace WallpaperEngine::Audio::Drivers {
-CAudioDriver::CAudioDriver (
-    Application::CApplicationContext& applicationContext, Detectors::CAudioPlayingDetector& detector,
-    Recorders::CPlaybackRecorder& recorder
-) :
-    m_applicationContext (applicationContext),
-    m_detector (detector),
-    m_recorder (recorder) {}
-
-void CAudioDriver::update () {
-    this->m_recorder.update ();
-    this->m_detector.update ();
-}
-
-Application::CApplicationContext& CAudioDriver::getApplicationContext () {
-    return this->m_applicationContext;
-}
-
-Detectors::CAudioPlayingDetector& CAudioDriver::getAudioDetector () {
-    return this->m_detector;
-}
-
-Recorders::CPlaybackRecorder& CAudioDriver::getRecorder () {
-    return this->m_recorder;
-}
-} // namespace WallpaperEngine::Audio::Drivers

src/WallpaperEngine/Audio/Drivers/Detectors/AudioPlayingDetector.cpp

@@ -0,0 +1,28 @@
+#include "AudioPlayingDetector.h"
+
+namespace WallpaperEngine::Audio::Drivers::Detectors {
+AudioPlayingDetector::AudioPlayingDetector (
+    Application::ApplicationContext& appContext,
+    const Render::Drivers::Detectors::FullScreenDetector& fullscreenDetector) :
+    m_applicationContext (appContext),
+    m_fullscreenDetector (fullscreenDetector) {}
+
+bool AudioPlayingDetector::anythingPlaying () const {
+    return this->m_isPlaying;
+}
+
+Application::ApplicationContext& AudioPlayingDetector::getApplicationContext () const {
+    return this->m_applicationContext;
+}
+
+const Render::Drivers::Detectors::FullScreenDetector& AudioPlayingDetector::getFullscreenDetector () const {
+    return this->m_fullscreenDetector;
+}
+
+void AudioPlayingDetector::setIsPlaying (const bool newState) {
+    this->m_isPlaying = newState;
+}
+
+void AudioPlayingDetector::update () {}
+
+} // namespace WallpaperEngine::Audio::Drivers::Detectors

src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.h → src/WallpaperEngine/Audio/Drivers/Detectors/AudioPlayingDetector.h

@@ -1,28 +1,28 @@
 #pragma once
 
-#include "WallpaperEngine/Application/CApplicationContext.h"
-#include "WallpaperEngine/Render/Drivers/Detectors/CFullScreenDetector.h"
+#include "WallpaperEngine/Application/ApplicationContext.h"
+#include "WallpaperEngine/Render/Drivers/Detectors/FullScreenDetector.h"
 
 namespace WallpaperEngine {
 namespace Application {
-class CApplicationContext;
+class ApplicationContext;
 }
 
 namespace Render::Drivers::Detectors {
-class CFullScreenDetector;
+class FullScreenDetector;
 }
 
 namespace Audio::Drivers::Detectors {
 /**
  * Base class for any implementation of audio playing detection
  */
-class CAudioPlayingDetector {
+class AudioPlayingDetector {
   public:
-    CAudioPlayingDetector (
-        Application::CApplicationContext& appContext,
-        const Render::Drivers::Detectors::CFullScreenDetector& fullscreenDetector);
+    AudioPlayingDetector (
+        Application::ApplicationContext& appContext,
+        const Render::Drivers::Detectors::FullScreenDetector& fullscreenDetector);
 
-    virtual ~CAudioPlayingDetector () = default;
+    virtual ~AudioPlayingDetector () = default;
 
     /**
      * @return If any kind of sound is currently playing on the default audio device
@@ -45,17 +45,17 @@ class CAudioPlayingDetector {
     /**
      * @return The application context using this detector
      */
-    [[nodiscard]] Application::CApplicationContext& getApplicationContext ();
+    [[nodiscard]] Application::ApplicationContext& getApplicationContext () const;
     /**
      * @return The fullscreen detector used
      */
-    [[nodiscard]] const Render::Drivers::Detectors::CFullScreenDetector& getFullscreenDetector () const;
+    [[nodiscard]] const Render::Drivers::Detectors::FullScreenDetector& getFullscreenDetector () const;
 
   private:
     bool m_isPlaying = false;
 
-    Application::CApplicationContext& m_applicationContext;
-    const Render::Drivers::Detectors::CFullScreenDetector& m_fullscreenDetector;
+    Application::ApplicationContext& m_applicationContext;
+    const Render::Drivers::Detectors::FullScreenDetector& m_fullscreenDetector;
 };
 } // namespace Audio::Drivers::Detectors
 } // namespace WallpaperEngine

src/WallpaperEngine/Audio/Drivers/Detectors/CAudioPlayingDetector.cpp

@@ -1,28 +0,0 @@
-#include "CAudioPlayingDetector.h"
-
-namespace WallpaperEngine::Audio::Drivers::Detectors {
-CAudioPlayingDetector::CAudioPlayingDetector (
-    Application::CApplicationContext& appContext,
-    const Render::Drivers::Detectors::CFullScreenDetector& fullscreenDetector) :
-    m_applicationContext (appContext),
-    m_fullscreenDetector (fullscreenDetector) {}
-
-bool CAudioPlayingDetector::anythingPlaying () const {
-    return this->m_isPlaying;
-}
-
-Application::CApplicationContext& CAudioPlayingDetector::getApplicationContext () {
-    return this->m_applicationContext;
-}
-
-const Render::Drivers::Detectors::CFullScreenDetector& CAudioPlayingDetector::getFullscreenDetector () const {
-    return this->m_fullscreenDetector;
-}
-
-void CAudioPlayingDetector::setIsPlaying (bool newState) {
-    this->m_isPlaying = newState;
-}
-
-void CAudioPlayingDetector::update () {}
-
-} // namespace WallpaperEngine::Audio::Drivers::Detectors

src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.cpp → src/WallpaperEngine/Audio/Drivers/Detectors/PulseAudioPlayingDetector.cpp

@@ -1,11 +1,11 @@
-#include "CPulseAudioPlayingDetector.h"
-#include "WallpaperEngine/Logging/CLog.h"
+#include "PulseAudioPlayingDetector.h"
+#include "WallpaperEngine/Logging/Log.h"
 
 #include <unistd.h>
 
 namespace WallpaperEngine::Audio::Drivers::Detectors {
 void sinkInputInfoCallback (pa_context* context, const pa_sink_input_info* info, int eol, void* userdata) {
-    auto* detector = static_cast<CPulseAudioPlayingDetector*> (userdata);
+    auto* detector = static_cast<PulseAudioPlayingDetector*> (userdata);
 
     if (info == nullptr)
         return;
@@ -29,10 +29,10 @@ void defaultSinkInfoCallback (pa_context* context, const pa_server_info* info, v
     pa_operation_unref (op);
 }
 
-CPulseAudioPlayingDetector::CPulseAudioPlayingDetector (
-    Application::CApplicationContext& appContext,
-    const Render::Drivers::Detectors::CFullScreenDetector& fullscreenDetector) :
-    CAudioPlayingDetector (appContext, fullscreenDetector) {
+PulseAudioPlayingDetector::PulseAudioPlayingDetector (
+    Application::ApplicationContext& appContext,
+    const Render::Drivers::Detectors::FullScreenDetector& fullscreenDetector) :
+    AudioPlayingDetector (appContext, fullscreenDetector) {
     this->m_mainloop = pa_mainloop_new ();
     this->m_mainloopApi = pa_mainloop_get_api (this->m_mainloop);
     this->m_context = pa_context_new (this->m_mainloopApi, "wallpaperengine");
@@ -44,7 +44,7 @@ CPulseAudioPlayingDetector::CPulseAudioPlayingDetector (
         pa_mainloop_iterate (this->m_mainloop, 1, nullptr);
 }
 
-CPulseAudioPlayingDetector::~CPulseAudioPlayingDetector () {
+PulseAudioPlayingDetector::~PulseAudioPlayingDetector () {
     if (this->m_context) {
         pa_context_disconnect (this->m_context);
         pa_context_unref (this->m_context);
@@ -54,7 +54,7 @@ CPulseAudioPlayingDetector::~CPulseAudioPlayingDetector () {
         pa_mainloop_free (this->m_mainloop);
 }
 
-void CPulseAudioPlayingDetector::update () {
+void PulseAudioPlayingDetector::update () {
     if (!this->getApplicationContext ().settings.audio.automute)
         return this->setIsPlaying (false);
     if (this->getFullscreenDetector ().anythingFullscreen ())

src/WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.h → src/WallpaperEngine/Audio/Drivers/Detectors/PulseAudioPlayingDetector.h

@@ -1,16 +1,16 @@
 #pragma once
 
-#include "CAudioPlayingDetector.h"
+#include "AudioPlayingDetector.h"
 #include <condition_variable>
 #include <mutex>
 #include <pulse/pulseaudio.h>
 
 namespace WallpaperEngine::Audio::Drivers::Detectors {
-class CPulseAudioPlayingDetector final : public CAudioPlayingDetector {
+class PulseAudioPlayingDetector final : public AudioPlayingDetector {
   public:
-    explicit CPulseAudioPlayingDetector (
-        Application::CApplicationContext& appContext, const Render::Drivers::Detectors::CFullScreenDetector&);
-    ~CPulseAudioPlayingDetector () override;
+    explicit PulseAudioPlayingDetector (
+        Application::ApplicationContext& appContext, const Render::Drivers::Detectors::FullScreenDetector&);
+    ~PulseAudioPlayingDetector () override;
 
     void update () override;
 

src/WallpaperEngine/Audio/Drivers/Recorders/CPlaybackRecorder.cpp

@@ -1,6 +0,0 @@
-#include "CPlaybackRecorder.h"
-
-namespace WallpaperEngine::Audio::Drivers::Recorders {
-void CPlaybackRecorder::update () {}
-
-} // namespace WallpaperEngine::Audio::Drivers::Recorders

src/WallpaperEngine/Audio/Drivers/Recorders/PlaybackRecorder.cpp

@@ -0,0 +1,6 @@
+#include "PlaybackRecorder.h"
+
+namespace WallpaperEngine::Audio::Drivers::Recorders {
+void PlaybackRecorder::update () {}
+
+} // namespace WallpaperEngine::Audio::Drivers::Recorders

src/WallpaperEngine/Audio/Drivers/Recorders/CPlaybackRecorder.h → src/WallpaperEngine/Audio/Drivers/Recorders/PlaybackRecorder.h

@@ -1,9 +1,9 @@
 #pragma once
 
 namespace WallpaperEngine::Audio::Drivers::Recorders {
-class CPlaybackRecorder {
+class PlaybackRecorder {
   public:
-    virtual ~CPlaybackRecorder () = default;
+    virtual ~PlaybackRecorder () = default;
 
     virtual void update ();
 

src/WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.cpp → src/WallpaperEngine/Audio/Drivers/Recorders/PulseAudioPlaybackRecorder.cpp

@@ -1,5 +1,5 @@
-#include "CPulseAudioPlaybackRecorder.h"
-#include "WallpaperEngine/Logging/CLog.h"
+#include "PulseAudioPlaybackRecorder.h"
+#include "WallpaperEngine/Logging/Log.h"
 #include <cmath>
 #include <cstring>
 #include <glm/common.hpp>
@@ -16,12 +16,12 @@ void pa_stream_notify_cb (pa_stream* stream, void* /*userdata*/) {
     switch (pa_stream_get_state (stream)) {
         case PA_STREAM_FAILED: sLog.error ("Cannot open stream for capture. Audio processing is disabled"); break;
         case PA_STREAM_READY: sLog.debug ("Capture stream ready"); break;
-        default: sLog.debug("pa_stream_get_state unknown result"); break;
+        default: break;
     }
 }
 
 void pa_stream_read_cb (pa_stream* stream, const size_t /*nbytes*/, void* userdata) {
-    auto* recorder = static_cast<CPulseAudioPlaybackRecorder::SPulseAudioData*> (userdata);
+    auto* recorder = static_cast<PulseAudioPlaybackRecorder::PulseAudioData*> (userdata);
 
     // Careful when to pa_stream_peek() and pa_stream_drop()!
     // c.f. https://www.freedesktop.org/software/pulseaudio/doxygen/stream_8h.html#ac2838c449cde56e169224d7fe3d00824
@@ -44,18 +44,17 @@ void pa_stream_read_cb (pa_stream* stream, const size_t /*nbytes*/, void* userda
             return;
         }
     } else if (currentSize > 0 && data) {
-        size_t dataToCopy = std::min (currentSize, WAVE_BUFFER_SIZE - recorder->currentWritePointer);
+        const size_t dataToCopy = std::min (currentSize, WAVE_BUFFER_SIZE - recorder->currentWritePointer);
 
         // depending on the amount of data available, we might want to read one or multiple frames
-        size_t end = recorder->currentWritePointer + dataToCopy;
+        const size_t end = recorder->currentWritePointer + dataToCopy;
 
         // this packet will fill the buffer, perform some extra checks for extra full buffers and get the latest one
         if (end == WAVE_BUFFER_SIZE) {
-            size_t numberOfFullBuffers = (currentSize - dataToCopy) / WAVE_BUFFER_SIZE;
-
-            if (numberOfFullBuffers > 0) {
+            if (const size_t numberOfFullBuffers = (currentSize - dataToCopy) / WAVE_BUFFER_SIZE;
+                numberOfFullBuffers > 0) {
                 // calculate the start of the last block (we need the end of the previous block, hence the - 1)
-                size_t startOfLastBuffer = std::max(dataToCopy + (numberOfFullBuffers - 1) * WAVE_BUFFER_SIZE, currentSize - WAVE_BUFFER_SIZE);
+                const size_t startOfLastBuffer = std::max(dataToCopy + (numberOfFullBuffers - 1) * WAVE_BUFFER_SIZE, currentSize - WAVE_BUFFER_SIZE);
                 // copy directly into the final buffer
                 memcpy (recorder->audioBuffer, &data [startOfLastBuffer], WAVE_BUFFER_SIZE * sizeof (uint8_t));
                 // copy whatever is left to the read/write buffer
@@ -86,7 +85,7 @@ void pa_stream_read_cb (pa_stream* stream, const size_t /*nbytes*/, void* userda
 }
 
 void pa_server_info_cb (pa_context* ctx, const pa_server_info* info, void* userdata) {
-    auto* recorder = static_cast<CPulseAudioPlaybackRecorder::SPulseAudioData*> (userdata);
+    auto* recorder = static_cast<PulseAudioPlaybackRecorder::PulseAudioData*> (userdata);
 
     pa_sample_spec spec;
     spec.format = PA_SAMPLE_U8;
@@ -145,12 +144,11 @@ void pa_context_notify_cb (pa_context* ctx, void* userdata) {
             sLog.error ("PulseAudio context initialization failed. Audio processing is disabled");
             break;
         default:
-            sLog.debug ("pa_context_get_state unknown result");
             break;
     }
 }
 
-CPulseAudioPlaybackRecorder::CPulseAudioPlaybackRecorder () :
+PulseAudioPlaybackRecorder::PulseAudioPlaybackRecorder () :
     m_captureData({
         .kisscfg = kiss_fftr_alloc (WAVE_BUFFER_SIZE, 0, nullptr, nullptr),
         .audioBuffer = new uint8_t [WAVE_BUFFER_SIZE],
@@ -172,7 +170,7 @@ CPulseAudioPlaybackRecorder::CPulseAudioPlaybackRecorder () :
         pa_mainloop_iterate (this->m_mainloop, 1, nullptr);
 }
 
-CPulseAudioPlaybackRecorder::~CPulseAudioPlaybackRecorder () {
+PulseAudioPlaybackRecorder::~PulseAudioPlaybackRecorder () {
     if (m_captureData.captureStream) {
         pa_stream_unref (m_captureData.captureStream);
     }
@@ -185,7 +183,7 @@ CPulseAudioPlaybackRecorder::~CPulseAudioPlaybackRecorder () {
     pa_mainloop_free (this->m_mainloop);
 }
 
-void CPulseAudioPlaybackRecorder::update () {
+void PulseAudioPlaybackRecorder::update () {
     pa_mainloop_iterate (this->m_mainloop, 0, nullptr);
 
     // interpolate current values to the destination

src/WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.h → src/WallpaperEngine/Audio/Drivers/Recorders/PulseAudioPlaybackRecorder.h

@@ -1,20 +1,20 @@
 #pragma once
 
+#include "PlaybackRecorder.h"
 #include "kiss_fftr.h"
-#include "CPlaybackRecorder.h"
 #include <pulse/pulseaudio.h>
 
 #define WAVE_BUFFER_SIZE 1024
 
 namespace WallpaperEngine::Audio::Drivers::Recorders {
-class CPlaybackRecorder;
+class PlaybackRecorder;
 
-class CPulseAudioPlaybackRecorder final : public CPlaybackRecorder {
+class PulseAudioPlaybackRecorder final : public PlaybackRecorder {
   public:
     /**
      * Struct that contains all the required data for the PulseAudio callbacks
      */
-    struct SPulseAudioData {
+    struct PulseAudioData {
         kiss_fftr_cfg kisscfg;
         uint8_t* audioBuffer;
         uint8_t* audioBufferTmp;
@@ -23,8 +23,8 @@ class CPulseAudioPlaybackRecorder final : public CPlaybackRecorder {
         pa_stream* captureStream;
     };
 
-    CPulseAudioPlaybackRecorder ();
-    ~CPulseAudioPlaybackRecorder () override;
+    PulseAudioPlaybackRecorder ();
+    ~PulseAudioPlaybackRecorder () override;
 
     void update () override;
 
@@ -32,7 +32,7 @@ class CPulseAudioPlaybackRecorder final : public CPlaybackRecorder {
     pa_mainloop* m_mainloop;
     pa_mainloop_api* m_mainloopApi;
     pa_context* m_context;
-    SPulseAudioData m_captureData;
+    PulseAudioData m_captureData;
 
     float m_audioFFTbuffer [WAVE_BUFFER_SIZE] = {0.0f};
     kiss_fft_cpx m_FFTinfo [WAVE_BUFFER_SIZE / 2 + 1] = {0};

src/WallpaperEngine/Audio/Drivers/CSDLAudioDriver.cpp → src/WallpaperEngine/Audio/Drivers/SDLAudioDriver.cpp

@@ -1,5 +1,5 @@
-#include "CSDLAudioDriver.h"
-#include "WallpaperEngine/Logging/CLog.h"
+#include "SDLAudioDriver.h"
+#include "WallpaperEngine/Logging/Log.h"
 
 #define SDL_AUDIO_BUFFER_SIZE 4096
 #define MAX_AUDIO_FRAME_SIZE 192000
@@ -8,7 +8,7 @@ using namespace WallpaperEngine::Audio;
 using namespace WallpaperEngine::Audio::Drivers;
 
 void audio_callback (void* userdata, uint8_t* streamData, int length) {
-    auto* driver = static_cast<CSDLAudioDriver*> (userdata);
+    auto* driver = static_cast<SDLAudioDriver*> (userdata);
 
     memset (streamData, 0, length);
 
@@ -64,11 +64,11 @@ void audio_callback (void* userdata, uint8_t* streamData, int length) {
     }
 }
 
-CSDLAudioDriver::CSDLAudioDriver (
-    Application::CApplicationContext& applicationContext, Detectors::CAudioPlayingDetector& detector,
-    Recorders::CPlaybackRecorder& recorder
+SDLAudioDriver::SDLAudioDriver (
+    Application::ApplicationContext& applicationContext, Detectors::AudioPlayingDetector& detector,
+    Recorders::PlaybackRecorder& recorder
 ) :
-    CAudioDriver (applicationContext, detector, recorder),
+    AudioDriver (applicationContext, detector, recorder),
     m_audioSpec () {
     if (SDL_InitSubSystem (SDL_INIT_AUDIO) < 0) {
         sLog.error ("Cannot initialize SDL audio system, SDL_GetError: ", SDL_GetError ());
@@ -99,47 +99,54 @@ CSDLAudioDriver::CSDLAudioDriver (
     this->m_initialized = true;
 }
 
-CSDLAudioDriver::~CSDLAudioDriver () {
+SDLAudioDriver::~SDLAudioDriver () {
     if (!this->m_initialized)
         return;
 
-    SDL_CloseAudioDevice (this->m_deviceID);
+    if (this->m_deviceID != 0) {
+        SDL_CloseAudioDevice (this->m_deviceID);
+    }
+
     SDL_QuitSubSystem (SDL_INIT_AUDIO);
 }
 
-void CSDLAudioDriver::addStream (CAudioStream* stream) {
-    this->m_streams.push_back (new CSDLAudioBuffer {stream});
+void SDLAudioDriver::addStream (AudioStream* stream) {
+    this->m_streams.push_back (new SDLAudioBuffer {stream});
 }
 
-const std::vector<CSDLAudioBuffer*>& CSDLAudioDriver::getStreams () {
+const std::vector<SDLAudioBuffer*>& SDLAudioDriver::getStreams () {
     return this->m_streams;
 }
 
-AVSampleFormat CSDLAudioDriver::getFormat () const {
+AVSampleFormat SDLAudioDriver::getFormat () const {
     switch (this->m_audioSpec.format) {
         case AUDIO_U8:
-        case AUDIO_S8: return AV_SAMPLE_FMT_U8;
+        case AUDIO_S8:
+            return AV_SAMPLE_FMT_U8;
         case AUDIO_U16MSB:
         case AUDIO_U16LSB:
         case AUDIO_S16LSB:
-        case AUDIO_S16MSB: return AV_SAMPLE_FMT_S16;
+        case AUDIO_S16MSB:
+            return AV_SAMPLE_FMT_S16;
         case AUDIO_S32LSB:
-        case AUDIO_S32MSB: return AV_SAMPLE_FMT_S32;
+        case AUDIO_S32MSB:
+            return AV_SAMPLE_FMT_S32;
         case AUDIO_F32LSB:
-        case AUDIO_F32MSB: return AV_SAMPLE_FMT_FLT;
+        case AUDIO_F32MSB:
+            return AV_SAMPLE_FMT_FLT;
+        default:
+            sLog.exception ("Cannot convert from SDL format to ffmpeg format, aborting...");
     }
-
-    sLog.exception ("Cannot convert from SDL format to ffmpeg format, aborting...");
 }
 
-int CSDLAudioDriver::getSampleRate () const {
+int SDLAudioDriver::getSampleRate () const {
     return this->m_audioSpec.freq;
 }
 
-int CSDLAudioDriver::getChannels () const {
+int SDLAudioDriver::getChannels () const {
     return this->m_audioSpec.channels;
 }
 
-const SDL_AudioSpec& CSDLAudioDriver::getSpec () const {
+const SDL_AudioSpec& SDLAudioDriver::getSpec () const {
     return this->m_audioSpec;
 }

src/WallpaperEngine/Audio/Drivers/CSDLAudioDriver.h → src/WallpaperEngine/Audio/Drivers/SDLAudioDriver.h

@@ -3,8 +3,8 @@
 #include <map>
 #include <vector>
 
-#include "WallpaperEngine/Audio/CAudioStream.h"
-#include "WallpaperEngine/Audio/Drivers/CAudioDriver.h"
+#include "WallpaperEngine/Audio/AudioStream.h"
+#include "WallpaperEngine/Audio/Drivers/AudioDriver.h"
 
 #include <SDL.h>
 
@@ -14,8 +14,8 @@ namespace WallpaperEngine::Audio::Drivers {
 /**
  * Audio output buffers for streams being played under SDL
  */
-struct CSDLAudioBuffer {
-    CAudioStream* stream = nullptr;
+struct SDLAudioBuffer {
+    AudioStream* stream = nullptr;
     uint8_t audio_buf [(MAX_AUDIO_FRAME_SIZE * 3) / 2] = {0};
     unsigned int audio_buf_size = 0;
     unsigned int audio_buf_index = 0;
@@ -24,19 +24,19 @@ struct CSDLAudioBuffer {
 /**
  * SDL's audio driver implementation
  */
-class CSDLAudioDriver final : public CAudioDriver {
+class SDLAudioDriver final : public AudioDriver {
   public:
-    CSDLAudioDriver (
-        Application::CApplicationContext& applicationContext, Detectors::CAudioPlayingDetector& detector,
-        Recorders::CPlaybackRecorder& recorder);
-    ~CSDLAudioDriver () override;
+    SDLAudioDriver (
+        Application::ApplicationContext& applicationContext, Detectors::AudioPlayingDetector& detector,
+        Recorders::PlaybackRecorder& recorder);
+    ~SDLAudioDriver () override;
 
     /** @inheritdoc */
-    void addStream (CAudioStream* stream) override;
+    void addStream (AudioStream* stream) override;
     /**
      * @return All the registered audio streams
      */
-    const std::vector<CSDLAudioBuffer*>& getStreams ();
+    const std::vector<SDLAudioBuffer*>& getStreams ();
 
     /** @inheritdoc */
     [[nodiscard]] AVSampleFormat getFormat () const override;
@@ -57,6 +57,6 @@ class CSDLAudioDriver final : public CAudioDriver {
     /** The sound output configuration */
     SDL_AudioSpec m_audioSpec {};
     /** All the playable steams */
-    std::vector<CSDLAudioBuffer*> m_streams {};
+    std::vector<SDLAudioBuffer*> m_streams {};
 };
 } // namespace WallpaperEngine::Audio::Drivers

src/WallpaperEngine/Core/CObject.cpp

@@ -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;
-}

src/WallpaperEngine/Core/CObject.h

@@ -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

src/WallpaperEngine/Core/CProject.cpp

@@ -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;
-}

src/WallpaperEngine/Core/CProject.h

@@ -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

src/WallpaperEngine/Core/CWallpaper.cpp

@@ -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;
-}

src/WallpaperEngine/Core/Core.cpp

@@ -1,541 +0,0 @@
-#include "Core.h"
-
-#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingFloat.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingVector3.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine;
-using namespace WallpaperEngine::Core::UserSettings;
-
-glm::vec4 Core::aToVector4 (const char* str) {
-    float x = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float y = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float z = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float w = strtof (str, const_cast<char**> (&str));
-
-    return {x, y, z, w};
-}
-
-glm::vec3 Core::aToVector3 (const char* str) {
-    float x = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float y = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float z = strtof (str, const_cast<char**> (&str));
-
-    return {x, y, z};
-}
-
-glm::vec2 Core::aToVector2 (const char* str) {
-    float x = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float y = strtof (str, const_cast<char**> (&str));
-
-    return {x, y};
-}
-
-glm::ivec4 Core::aToVector4i (const char* str) {
-    int x = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int y = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int z = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int w = strtol (str, const_cast<char**> (&str), 10);
-
-    return {x, y, z, w};
-}
-
-glm::ivec3 Core::aToVector3i (const char* str) {
-    int x = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int y = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int z = strtol (str, const_cast<char**> (&str), 10);
-
-    return {x, y, z};
-}
-
-glm::ivec2 Core::aToVector2i (const char* str) {
-    int x = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int y = strtol (str, const_cast<char**> (&str), 10);
-
-    return {x, y};
-}
-
-glm::vec4 Core::aToVector4 (const std::string& str) {
-    return Core::aToVector4 (str.c_str ());
-}
-
-glm::vec3 Core::aToVector3 (const std::string& str) {
-    return Core::aToVector3 (str.c_str ());
-}
-
-glm::vec2 Core::aToVector2 (const std::string& str) {
-    return Core::aToVector2 (str.c_str ());
-}
-
-glm::ivec4 Core::aToVector4i (const std::string& str) {
-    return Core::aToVector4i (str.c_str ());
-}
-
-glm::ivec3 Core::aToVector3i (const std::string& str) {
-    return Core::aToVector3i (str.c_str ());
-}
-
-glm::ivec2 Core::aToVector2i (const std::string& str) {
-    return Core::aToVector2i (str.c_str ());
-}
-
-glm::vec3 Core::aToColorf (const char* str) {
-    float r = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float g = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float b = strtof (str, const_cast<char**> (&str));
-
-    return {r, g, b};
-}
-
-glm::vec3 Core::aToColorf (const std::string& str) {
-    return aToColorf (str.c_str ());
-}
-
-glm::ivec3 Core::aToColori (const char* str) {
-    auto r = static_cast<uint8_t> (strtol (str, const_cast<char**> (&str), 10));
-    while (*str == ' ')
-        str++;
-    auto g = static_cast<uint8_t> (strtol (str, const_cast<char**> (&str), 10));
-    while (*str == ' ')
-        str++;
-    auto b = static_cast<uint8_t> (strtol (str, const_cast<char**> (&str), 10));
-
-    return {r, g, b};
-}
-
-glm::ivec3 Core::aToColori (const std::string& str) {
-    return aToColori (str.c_str ());
-}
-
-template <typename T> bool typeCheck (const nlohmann::json::const_iterator& value) {
-    if (value->type () == nlohmann::detail::value_t::null) {
-        return false;
-    }
-
-    // type checks
-    if constexpr ((std::is_same_v<T, float> || std::is_same_v<T, double>) ) {
-        if (value->type () != nlohmann::detail::value_t::number_float &&
-            value->type () != nlohmann::detail::value_t::number_integer &&
-            value->type () != nlohmann::detail::value_t::number_unsigned) {
-            return false;
-        }
-    } else if constexpr (std::is_same_v<T, std::string>) {
-        if (value->type () != nlohmann::detail::value_t::string) {
-            return false;
-        }
-    } else if constexpr (std::is_same_v<T, bool>) {
-        if (value->type () != nlohmann::detail::value_t::boolean) {
-            return false;
-        }
-    } else if constexpr (
-        std::is_same_v<T, glm::vec2> || std::is_same_v<T, glm::vec3> || std::is_same_v<T, glm::vec4> ||
-        std::is_same_v<T, glm::ivec2> || std::is_same_v<T, glm::ivec3> || std::is_same_v<T, glm::ivec4>) {
-        if (value->type () != nlohmann::detail::value_t::string) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-template <typename T> const T Core::jsonFindRequired (
-    const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg
-) {
-    const auto iterator = jsonFindRequired (data, key, notFoundMsg);
-
-    // vector types need of special handling
-    if constexpr (std::is_same_v<T, std::string>) {
-        // std::strings are special, type checking doesn't need to happen, we just want the string representation
-        // of whatever is in there
-        if (iterator->is_number_integer ()) {
-            return std::to_string (iterator->get <int> ());
-        } else if (iterator->is_number_float ()) {
-            return std::to_string (iterator->get <float> ());
-        } else if (iterator->is_boolean()) {
-            return std::to_string (iterator->get <bool> ());
-        } else if (iterator->is_null ()) {
-            return "null";
-        } else if (iterator->is_string ()) {
-            return *iterator;
-        }
-    } else if  constexpr (std::is_same_v<T, glm::vec4>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector4 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::vec3>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector3 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::vec2>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector2 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec4>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector4i (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec3>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector3i (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec2>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector2i (*iterator);
-    } else if (typeCheck<T> (iterator)) {
-        return *iterator;
-    }
-
-    sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), ": ", notFoundMsg);
-}
-
-template const bool Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const std::string Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const int16_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const uint16_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const int32_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const uint32_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const int64_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const uint64_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const float Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const double Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::vec4 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::vec3 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::vec2 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::ivec4 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::ivec3 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::ivec2 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-
-template <typename T> const T Core::jsonFindRequired (
-    const nlohmann::json& data, const char* key, const char* notFoundMsg
-) {
-    const auto iterator = jsonFindRequired (data, key, notFoundMsg);
-
-    // vector types need of special handling
-    if constexpr (std::is_same_v<T, std::string>) {
-        // std::strings are special, type checking doesn't need to happen, we just want the string representation
-        // of whatever is in there
-        if (iterator->is_number_integer ()) {
-            return std::to_string (iterator->get <int> ());
-        } else if (iterator->is_number_float ()) {
-            return std::to_string (iterator->get <float> ());
-        } else if (iterator->is_boolean()) {
-            return std::to_string (iterator->get <bool> ());
-        } else if (iterator->is_null ()) {
-            return "null";
-        } else if (iterator->is_string ()) {
-            return *iterator;
-        }
-    } else if constexpr (std::is_same_v<T, glm::vec4>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector4 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::vec3>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector3 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::vec2>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector2 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec4>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector4i (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec3>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector3i (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec2>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector2i (*iterator);
-    } else if (typeCheck<T> (iterator)) {
-        return *iterator;
-    }
-
-    sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), ": ", notFoundMsg);
-}
-
-template const bool Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const std::string Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const int16_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const uint16_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const int32_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const uint32_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const int64_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const uint64_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const float Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const double Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::vec4 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::vec3 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::vec2 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::ivec4 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::ivec3 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::ivec2 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-
-nlohmann::json::const_iterator Core::jsonFindRequired (
-    const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg
-) {
-    auto value = data->find (key);
-
-    if (value == data->end ())
-        sLog.exception ("Cannot find required key (", key, ") in json: ", notFoundMsg);
-
-    return value;
-}
-
-nlohmann::json::const_iterator Core::jsonFindRequired (
-    const nlohmann::json& data, const char* key, const char* notFoundMsg
-) {
-    auto value = data.find (key);
-
-    if (value == data.end ())
-        sLog.exception ("Cannot find required key (", key, ") in json: ", notFoundMsg);
-
-    return value;
-}
-
-template <typename T> const T Core::jsonFindDefault (
-    const nlohmann::json::const_iterator& data, const char* key, const T defaultValue
-) {
-    const auto value = data->find (key);
-
-    if (value == data->end () || value->type () == nlohmann::detail::value_t::null)
-        return defaultValue;
-
-    // vector types need of special handling
-    if constexpr (std::is_same_v<T, std::string>) {
-        // std::strings are special, type checking doesn't need to happen, we just want the string representation
-        // of whatever is in there
-        if (value->is_number_integer ()) {
-            return std::to_string (value->get <int> ());
-        } else if (value->is_number_float ()) {
-            return std::to_string (value->get <float> ());
-        } else if (value->is_boolean()) {
-            return std::to_string (value->get <bool> ());
-        } else if (value->is_null ()) {
-            return "null";
-        } else if (value->is_string ()) {
-            return *value;
-        }
-    } else if constexpr (std::is_same_v<T, glm::vec4>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector4 (*value);
-    } else if constexpr (std::is_same_v<T, glm::vec3>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector3 (*value);
-    } else if constexpr (std::is_same_v<T, glm::vec2>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector2 (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec4>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector4i (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec3>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector3i (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec2>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector2i (*value);
-    } else if (typeCheck<T> (value)) {
-        return *value;
-    }
-
-    return defaultValue;
-}
-
-template const bool Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const bool defaultValue);
-template const std::string Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const std::string defaultValue);
-template const int16_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const int16_t defaultValue);
-template const uint16_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const uint16_t defaultValue);
-template const int32_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const int32_t defaultValue);
-template const uint32_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const uint32_t defaultValue);
-template const int64_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const int64_t defaultValue);
-template const uint64_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const uint64_t defaultValue);
-template const float Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const float defaultValue);
-template const double Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const double defaultValue);
-template const glm::vec2 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::vec2 defaultValue);
-template const glm::vec3 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::vec3 defaultValue);
-template const glm::vec4 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::vec4 defaultValue);
-template const glm::ivec2 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::ivec2 defaultValue);
-template const glm::ivec3 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::ivec3 defaultValue);
-template const glm::ivec4 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::ivec4 defaultValue);
-
-template <typename T> const T Core::jsonFindDefault (
-    const nlohmann::json& data, const char* key, const T defaultValue
-) {
-    const auto value = data.find (key);
-
-    if (value == data.end () || value->type () == nlohmann::detail::value_t::null)
-        return defaultValue;
-
-    // vector types need of special handling
-    if constexpr (std::is_same_v<T, glm::vec4>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector4 (*value);
-    } else if constexpr (std::is_same_v<T, glm::vec3>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector3 (*value);
-    } else if constexpr (std::is_same_v<T, glm::vec2>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector2 (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec4>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector4i (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec3>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector3i (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec2>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector2i (*value);
-    } else if (typeCheck<T> (value)) {
-        return *value;
-    }
-
-    return defaultValue;
-}
-
-template const bool Core::jsonFindDefault (const nlohmann::json& data, const char* key, const bool defaultValue);
-template const std::string Core::jsonFindDefault (const nlohmann::json& data, const char* key, const std::string defaultValue);
-template const int16_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const int16_t defaultValue);
-template const uint16_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const uint16_t defaultValue);
-template const int32_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const int32_t defaultValue);
-template const uint32_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const uint32_t defaultValue);
-template const int64_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const int64_t defaultValue);
-template const uint64_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const uint64_t defaultValue);
-template const float Core::jsonFindDefault (const nlohmann::json& data, const char* key, const float defaultValue);
-template const double Core::jsonFindDefault (const nlohmann::json& data, const char* key, const double defaultValue);
-template const glm::vec2 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::vec2 defaultValue);
-template const glm::vec3 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::vec3 defaultValue);
-template const glm::vec4 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::vec4 defaultValue);
-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);
-}
-
-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);
-}
-
-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);

src/WallpaperEngine/Core/Core.h

@@ -1,51 +0,0 @@
-#pragma once
-
-#include "CProject.h"
-#include <glm/mat4x4.hpp>
-#include <glm/vec2.hpp>
-#include <glm/vec3.hpp>
-#include <nlohmann/json.hpp>
-#include <string>
-
-namespace WallpaperEngine::Core {
-class CProject;
-
-glm::vec4 aToVector4 (const char* str);
-glm::vec3 aToVector3 (const char* str);
-glm::vec2 aToVector2 (const char* str);
-
-glm::vec4 aToVector4 (const std::string& str);
-glm::vec3 aToVector3 (const std::string& str);
-glm::vec2 aToVector2 (const std::string& str);
-
-glm::ivec4 aToVector4i (const char* str);
-glm::ivec3 aToVector3i (const char* str);
-glm::ivec2 aToVector2i (const char* str);
-
-glm::ivec4 aToVector4i (const std::string& str);
-glm::ivec3 aToVector3i (const std::string& str);
-glm::ivec2 aToVector2i (const std::string& str);
-
-glm::vec3 aToColorf (const char* str);
-glm::vec3 aToColorf (const std::string& str);
-
-glm::ivec3 aToColori (const char* str);
-glm::ivec3 aToColori (const std::string& str);
-
-template <typename T> const T jsonFindRequired (
-    const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template <typename T> const T jsonFindRequired (
-    const nlohmann::json& data, const char* key, const char* notFoundMsg);
-nlohmann::json::const_iterator jsonFindRequired (
-    const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-nlohmann::json::const_iterator jsonFindRequired (
-    const nlohmann::json& data, const char* key, const char* notFoundMsg);
-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

src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp

@@ -1,205 +0,0 @@
-#include <algorithm>
-#include "CDynamicValue.h"
-
-using namespace WallpaperEngine::Core::DynamicValues;
-
-CDynamicValue::~CDynamicValue() {
-    for (auto* connection : this->m_incomingConnections) {
-        connection->destroyOutgoingConnection (this);
-    }
-}
-
-void CDynamicValue::update(float newValue) {
-    this->m_ivec4 = glm::ivec4(static_cast<int> (newValue));
-    this->m_ivec3 = glm::ivec3(static_cast<int> (newValue));
-    this->m_ivec2 = glm::ivec2(static_cast<int> (newValue));
-    this->m_vec4 = glm::vec4(newValue);
-    this->m_vec3 = glm::vec3(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_float = newValue;
-    this->m_int = static_cast<int> (newValue);
-    this->m_bool = static_cast<int> (newValue) != 0;
-
-    this->propagate ();
-}
-
-void CDynamicValue::update(int newValue) {
-    this->m_ivec4 = glm::ivec4(newValue);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec4 = glm::vec4(static_cast<float> (newValue));
-    this->m_vec3 = glm::vec3(static_cast<float> (newValue));
-    this->m_vec2 = glm::vec2(static_cast<float> (newValue));
-    this->m_float = static_cast<float> (newValue);
-    this->m_int = newValue;
-    this->m_bool = newValue != 0;
-
-    this->propagate ();
-}
-
-void CDynamicValue::update(bool newValue) {
-    this->m_ivec4 = glm::ivec4(newValue);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec4 = glm::vec4(newValue);
-    this->m_vec3 = glm::vec3(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_float = newValue;
-    this->m_int = newValue;
-    this->m_bool = newValue;
-
-    this->propagate ();
-}
-
-void CDynamicValue::update(const glm::vec2& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue, 0, 0);
-    this->m_ivec3 = glm::ivec3(newValue, 0);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = newValue;
-    this->m_vec3 = glm::vec3(newValue, 0.0f);
-    this->m_vec4 = glm::vec4(newValue, 0.0f, 0.0f);
-    this->m_float = newValue.x;
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0.0f;
-
-    this->propagate ();
-}
-
-void CDynamicValue::update(const glm::vec3& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue, 0);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_vec3 = newValue;
-    this->m_vec4 = glm::vec4(newValue, 0.0f);
-    this->m_float = newValue.x;
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0.0f;
-
-    this->propagate ();
-}
-
-void CDynamicValue::update(const glm::vec4& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_vec3 = glm::vec3(newValue);
-    this->m_vec4 = newValue;
-    this->m_float = newValue.x;
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0.0f;
-
-    this->propagate ();
-}
-
-void CDynamicValue::update(const glm::ivec2& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue, 0, 0);
-    this->m_ivec3 = glm::ivec3(newValue, 0);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = newValue;
-    this->m_vec3 = glm::vec3(newValue, 0.0f);
-    this->m_vec4 = glm::vec4(newValue, 0.0f, 0.0f);
-    this->m_float = static_cast<float> (newValue.x);
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0;
-
-    this->propagate ();
-}
-
-void CDynamicValue::update(const glm::ivec3& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue, 0);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_vec3 = newValue;
-    this->m_vec4 = glm::vec4(newValue, 0.0f);
-    this->m_float = static_cast<float> (newValue.x);
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0;
-
-    this->propagate ();
-}
-
-void CDynamicValue::update(const glm::ivec4& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_vec3 = glm::vec3(newValue);
-    this->m_vec4 = newValue;
-    this->m_float = static_cast<float> (newValue.x);
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0;
-
-    this->propagate ();
-}
-
-void CDynamicValue::connectOutgoing (CDynamicValue* value) const {
-    this->m_outgoingConnections.push_back (value);
-
-    // ensure that new connection has the right value
-    this->propagate ();
-    // ensure the other value keeps track of our connection too
-    value->connectIncoming (this);
-}
-
-void CDynamicValue::connectIncoming (const CDynamicValue* value) const {
-    this->m_incomingConnections.push_back (value);
-}
-
-void CDynamicValue::destroyOutgoingConnection (CDynamicValue* value) const {
-    this->m_outgoingConnections.erase (
-        std::remove (this->m_outgoingConnections.begin (), this->m_outgoingConnections.end (), value), this->m_outgoingConnections.end ()
-    );
-}
-
-void CDynamicValue::propagate () const {
-    for (auto* cur : this->m_outgoingConnections) {
-        cur->m_bool = this->m_bool;
-        cur->m_int = this->m_int;
-        cur->m_float = this->m_float;
-        cur->m_ivec2 = this->m_ivec2;
-        cur->m_ivec3 = this->m_ivec3;
-        cur->m_ivec4 = this->m_ivec4;
-        cur->m_vec2 = this->m_vec2;
-        cur->m_vec3 = this->m_vec3;
-        cur->m_vec4 = this->m_vec4;
-    }
-}
-
-const glm::ivec4& CDynamicValue::getIVec4 () const {
-    return this->m_ivec4;
-}
-
-const glm::ivec3& CDynamicValue::getIVec3 () const {
-    return this->m_ivec3;
-}
-
-const glm::ivec2& CDynamicValue::getIVec2 () const {
-    return this->m_ivec2;
-}
-
-const glm::vec4& CDynamicValue::getVec4 () const {
-    return this->m_vec4;
-}
-
-const glm::vec3& CDynamicValue::getVec3 () const {
-    return this->m_vec3;
-}
-
-const glm::vec2& CDynamicValue::getVec2 () const {
-    return this->m_vec2;
-}
-
-const float& CDynamicValue::getFloat () const {
-    return this->m_float;
-}
-
-const int& CDynamicValue::getInt () const {
-    return this->m_int;
-}
-
-const bool& CDynamicValue::getBool () const {
-    return this->m_bool;
-}

src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h

@@ -1,68 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <string>
-#include <vector>
-#include <glm/glm.hpp>
-
-namespace WallpaperEngine::Core::DynamicValues {
-class CDynamicValue {
-  public:
-    virtual ~CDynamicValue ();
-
-    [[nodiscard]] const glm::ivec4& getIVec4 () const;
-    [[nodiscard]] const glm::ivec3& getIVec3 () const;
-    [[nodiscard]] const glm::ivec2& getIVec2 () const;
-    [[nodiscard]] const glm::vec4& getVec4 () const;
-    [[nodiscard]] const glm::vec3& getVec3 () const;
-    [[nodiscard]] const glm::vec2& getVec2 () const;
-    [[nodiscard]] const float& getFloat () const;
-    [[nodiscard]] const int& getInt () const;
-    [[nodiscard]] const bool& getBool () const;
-
-    /**
-     * Connects the current instance to the given instance, updating it's values
-     * based on current instance's changes
-     *
-     * @param value
-     */
-    void connectOutgoing (CDynamicValue* value) const;
-
-  protected:
-    void update (float newValue);
-    void update (int newValue);
-    void update (bool newValue);
-    void update (const glm::vec2& newValue);
-    void update (const glm::vec3& newValue);
-    void update (const glm::vec4& newValue);
-    void update (const glm::ivec2& newValue);
-    void update (const glm::ivec3& newValue);
-    void update (const glm::ivec4& newValue);
-    /**
-     * Registers an incoming connection (another CDynamicValue affecting the current instance's value)
-     * Useful mainly for destroying the connection on delete
-     *
-     * @param value
-     */
-    void connectIncoming (const CDynamicValue* value) const;
-    void destroyOutgoingConnection (CDynamicValue* value) const;
-    /**
-     * Propagates the current value to all it's connections
-     */
-    virtual void propagate () const;
-
-  private:
-    mutable std::vector<CDynamicValue*> m_outgoingConnections = {};
-    mutable std::vector<const CDynamicValue*> m_incomingConnections = {};
-    // different values that we will be casted to automagically
-    glm::ivec4 m_ivec4 = {};
-    glm::ivec3 m_ivec3 = {};
-    glm::ivec2 m_ivec2 = {};
-    glm::vec4 m_vec4 = {};
-    glm::vec3 m_vec3 = {};
-    glm::vec2 m_vec2 = {};
-    float m_float = 0.0f;
-    int m_int = 0;
-    bool m_bool = false;
-};
-};

src/WallpaperEngine/Core/Objects/CEffect.cpp

@@ -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);
-}

src/WallpaperEngine/Core/Objects/CEffect.h

@@ -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

src/WallpaperEngine/Core/Objects/CImage.cpp

@@ -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;
-}

src/WallpaperEngine/Core/Objects/CImage.h

@@ -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

src/WallpaperEngine/Core/Objects/CParticle.cpp

@@ -1,73 +0,0 @@
-#include "CParticle.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core::Objects;
-
-const CParticle* CParticle::fromFile (
-    std::shared_ptr <const Core::CProject> project, const std::string& filename,
-    const std::shared_ptr<const CContainer>& container, const CUserSettingBoolean* visible, int id,
-    const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* angles,
-    const CUserSettingVector3* scale, std::vector<int> dependencies
-) {
-    json data = json::parse (container->readFileAsString (filename));
-    const auto controlpoint_it = data.find ("controlpoint");
-    const auto emitter_it = jsonFindRequired (data, "emitter", "Particles must have emitters");
-    const auto initializer_it = jsonFindRequired (data, "initializer", "Particles must have initializers");
-
-    std::vector<const Particles::CControlPoint*> controlpoints;
-    std::vector<const Particles::CEmitter*> emitters;
-    std::vector<const Particles::CInitializer*> initializers;
-
-    if (controlpoint_it != data.end ())
-        for (const auto& cur : (*controlpoint_it))
-            controlpoints.push_back (Particles::CControlPoint::fromJSON (cur));
-
-    for (const auto& cur : (*emitter_it))
-        emitters.push_back (Particles::CEmitter::fromJSON (cur));
-    for (const auto& cur : (*initializer_it))
-        initializers.push_back (Particles::CInitializer::fromJSON (cur));
-
-    return new CParticle (
-        project,
-        jsonFindRequired <uint32_t> (data, "starttime", "Particles must have start time"),
-        jsonFindRequired <uint32_t> (data, "maxcount", "Particles must have maximum count"),
-        visible,
-        id,
-        name,
-        origin,
-        scale,
-        angles,
-        controlpoints,
-        emitters,
-        initializers,
-        std::move(dependencies)
-    );
-}
-
-CParticle::CParticle (
-    std::shared_ptr <const Core::CProject> project, uint32_t starttime, uint32_t maxcount,
-    const CUserSettingBoolean* visible, int id, const std::string& name, const CUserSettingVector3* origin,
-    const CUserSettingVector3* scale, const CUserSettingVector3* angles,
-    const std::vector<const Particles::CControlPoint*>& controlpoints,
-    const std::vector<const Particles::CEmitter*>& emitters,
-    const std::vector<const Particles::CInitializer*>& initializers, std::vector<int> dependencies
-) :
-    CObject (project, visible, id, name, origin, scale, angles, std::move(dependencies)),
-    m_starttime (starttime),
-    m_maxcount (maxcount),
-    m_controlpoints (controlpoints),
-    m_emitters (emitters),
-    m_initializers (initializers) {}
-
-const std::vector<const Particles::CEmitter*>& CParticle::getEmitters () const {
-    return this->m_emitters;
-}
-
-const std::vector<const Particles::CControlPoint*>& CParticle::getControlPoints () const {
-    return this->m_controlpoints;
-}
-
-const std::vector<const Particles::CInitializer*>& CParticle::getInitializers () const {
-    return this->m_initializers;
-}

src/WallpaperEngine/Core/Objects/CParticle.h

@@ -1,60 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Objects/Particles/CControlPoint.h"
-#include "WallpaperEngine/Core/Objects/Particles/CEmitter.h"
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-#include "WallpaperEngine/Core/CObject.h"
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects {
-using json = nlohmann::json;
-
-/**
- * Represents a particle system in the background
- */
-class CParticle : public CObject {
-    friend class CObject;
-
-  public:
-    static const CParticle* fromFile (
-        std::shared_ptr <const Core::CProject> project, const std::string& filename,
-        const std::shared_ptr<const CContainer>& container, const CUserSettingBoolean* visible, int id,
-        const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* angles,
-        const CUserSettingVector3* scale, std::vector<int> dependencies);
-
-    /**
-     * @return The list of emitters for the particle system
-     */
-    [[nodiscard]] const std::vector<const Particles::CEmitter*>& getEmitters () const;
-    /**
-     * @return The list of control points for the particle system
-     */
-    [[nodiscard]] const std::vector<const Particles::CControlPoint*>& getControlPoints () const;
-    /**
-     * @return The list of initializers for the particle system
-     */
-    [[nodiscard]] const std::vector<const Particles::CInitializer*>& getInitializers () const;
-
-  protected:
-    CParticle (
-        std::shared_ptr <const Core::CProject> project, uint32_t starttime, uint32_t maxcount,
-        const CUserSettingBoolean* visible, int id, const std::string& name, const CUserSettingVector3* origin,
-        const CUserSettingVector3* scale, const CUserSettingVector3* angles,
-        const std::vector<const Particles::CControlPoint*>& controlpoints,
-        const std::vector<const Particles::CEmitter*>& emitters,
-        const std::vector<const Particles::CInitializer*>& initializers, std::vector<int> dependencies);
-
-  private:
-    /** The time at which the particle system should start emitting */
-    const uint32_t m_starttime;
-    /** Maximum number of particles at the same time */
-    const uint32_t m_maxcount;
-    /** List of control points */
-    const std::vector<const Particles::CControlPoint*> m_controlpoints;
-    /** List of emitters */
-    const std::vector<const Particles::CEmitter*> m_emitters;
-    /** List of initializers */
-    const std::vector<const Particles::CInitializer*> m_initializers;
-};
-} // namespace WallpaperEngine::Core::Objects

src/WallpaperEngine/Core/Objects/CSound.cpp

@@ -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;
-}

src/WallpaperEngine/Core/Objects/CSound.h

@@ -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

src/WallpaperEngine/Core/Objects/Effects/CBind.cpp

@@ -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;
-}

src/WallpaperEngine/Core/Objects/Effects/CBind.h

@@ -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

src/WallpaperEngine/Core/Objects/Effects/CFBO.cpp

@@ -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;
-}

src/WallpaperEngine/Core/Objects/Effects/CFBO.h

@@ -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

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.cpp

@@ -1,5 +0,0 @@
-#include "CShaderConstant.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h

@@ -1,40 +0,0 @@
-#pragma once
-
-#include <cassert>
-#include <string>
-#include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constants base class
- */
-class CShaderConstant : public DynamicValues::CDynamicValue {
-  public:
-    virtual ~CShaderConstant () = default;
-
-    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);
-    }
-
-    /**
-     * @return String representation of the constant's value
-     */
-    [[nodiscard]] virtual std::string toString () const = 0;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.cpp

@@ -1,11 +0,0 @@
-#include "CShaderConstantFloat.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantFloat::CShaderConstantFloat (float value) {
-    this->update (value);
-}
-
-std::string CShaderConstantFloat::toString () const {
-    return std::to_string (this->getFloat ());
-}

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "CShaderConstant.h"
-
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constant of type float
- */
-class CShaderConstantFloat : public CShaderConstant {
-  public:
-    explicit CShaderConstantFloat (float value);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.cpp

@@ -1,11 +0,0 @@
-#include "CShaderConstantInteger.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantInteger::CShaderConstantInteger (int32_t value) {
-    this->update (value);
-}
-
-std::string CShaderConstantInteger::toString () const {
-    return std::to_string (this->getInt ());
-}

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "CShaderConstant.h"
-
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constant of type integer
- */
-class CShaderConstantInteger : public CShaderConstant {
-  public:
-    explicit CShaderConstantInteger (int32_t value);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.cpp

@@ -1,12 +0,0 @@
-#include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
-#include "CShaderConstantProperty.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantProperty::CShaderConstantProperty (const std::shared_ptr <const CProperty>& property) {
-    property->connectOutgoing (this);
-}
-
-std::string CShaderConstantProperty::toString () const {
-    return "no string representation yet!";
-}

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h

@@ -1,20 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Projects/CProperty.h"
-
-#include "CShaderConstant.h"
-
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-using namespace WallpaperEngine::Core::Projects;
-/**
- * Shader constant that comes from a property
- */
-class CShaderConstantProperty : public CShaderConstant {
-  public:
-    explicit CShaderConstantProperty (const std::shared_ptr <const CProperty>& property);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.cpp

@@ -1,18 +0,0 @@
-#include "CShaderConstantVector2.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantVector2::CShaderConstantVector2 (glm::vec2 value) {
-    this->update (value);
-}
-
-std::string CShaderConstantVector2::toString () const {
-    std::string result = "(";
-
-    result.append (std::to_string (this->getVec2 ().x));
-    result.append (",");
-    result.append (std::to_string (this->getVec2 ().y));
-    result.append (")");
-
-    return result;
-}

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "CShaderConstant.h"
-
-#include <glm/vec2.hpp>
-#include <glm/vec3.hpp>
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constant of vector2 type
- */
-class CShaderConstantVector2 : public CShaderConstant {
-  public:
-    explicit CShaderConstantVector2 (glm::vec2 value);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.cpp

@@ -1,20 +0,0 @@
-#include "CShaderConstantVector3.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantVector3::CShaderConstantVector3 (glm::vec3 value) {
-    this->update (value);
-}
-
-std::string CShaderConstantVector3::toString () const {
-    std::string result = "(";
-
-    result.append (std::to_string (this->getVec3 ().x));
-    result.append (",");
-    result.append (std::to_string (this->getVec3 ().y));
-    result.append (",");
-    result.append (std::to_string (this->getVec3 ().z));
-    result.append (")");
-
-    return result;
-}

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "CShaderConstant.h"
-
-#include <glm/vec3.hpp>
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constant of vector3 type
- */
-class CShaderConstantVector3 : public CShaderConstant {
-  public:
-    explicit CShaderConstantVector3 (glm::vec3 value);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.cpp

@@ -1,22 +0,0 @@
-#include "CShaderConstantVector4.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantVector4::CShaderConstantVector4 (glm::vec4 value) {
-    this->update (value);
-}
-
-std::string CShaderConstantVector4::toString () const {
-    std::string result = "(";
-
-    result.append (std::to_string (this->getVec4 ().x));
-    result.append (",");
-    result.append (std::to_string (this->getVec4 ().y));
-    result.append (",");
-    result.append (std::to_string (this->getVec4 ().z));
-    result.append (",");
-    result.append (std::to_string (this->getVec4 ().w));
-    result.append (")");
-
-    return result;
-}

src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "CShaderConstant.h"
-
-#include <glm/vec4.hpp>
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constant of vector4 type
- */
-class CShaderConstantVector4 : public CShaderConstant {
-  public:
-    explicit CShaderConstantVector4 (glm::vec4 value);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants

src/WallpaperEngine/Core/Objects/Images/CMaterial.cpp

@@ -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;
-}

src/WallpaperEngine/Core/Objects/Images/CMaterial.h

@@ -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

src/WallpaperEngine/Core/Objects/Images/Materials/CPass.cpp

@@ -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;
-}

src/WallpaperEngine/Core/Objects/Images/Materials/CPass.h

@@ -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

src/WallpaperEngine/Core/Objects/Particles/CControlPoint.cpp

@@ -1,28 +0,0 @@
-#include "CControlPoint.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles;
-
-const CControlPoint* CControlPoint::fromJSON (const json& data) {
-    return new CControlPoint (
-        jsonFindRequired <uint32_t> (data, "id", "Particle's control point must have id"),
-        jsonFindDefault (data, "flags", 0),
-        jsonFindDefault (data, "offset", glm::vec3())
-    );
-}
-
-CControlPoint::CControlPoint (uint32_t id, uint32_t flags, glm::vec3 offset) :
-    m_id (id),
-    m_flags (flags),
-    m_offset (offset) {}
-
-uint32_t CControlPoint::getId () const {
-    return this->m_id;
-}
-
-const glm::vec3& CControlPoint::getOffset () const {
-    return this->m_offset;
-}
-
-uint32_t CControlPoint::getFlags () const {
-    return this->m_flags;
-}

src/WallpaperEngine/Core/Objects/Particles/CControlPoint.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects::Particles {
-using json = nlohmann::json;
-
-/**
- * Control point for particles
- */
-class CControlPoint {
-  public:
-    static const CControlPoint* fromJSON (const json& data);
-
-    /**
-     * @return The id of the controlpoint used for ordering purposes
-     */
-    [[nodiscard]] uint32_t getId () const;
-    /**
-     * @return The offset from origin
-     */
-    [[nodiscard]] const glm::vec3& getOffset () const;
-    /**
-     * @return Flags for the control point, controls how it should behave
-     */
-    [[nodiscard]] uint32_t getFlags () const;
-
-  protected:
-    explicit CControlPoint (uint32_t id, uint32_t flags, glm::vec3 offset);
-
-  private:
-    /** ID used for ordering purposes */
-    const uint32_t m_id;
-    /** Flags that control how it behaves */
-    const uint32_t m_flags;
-    /** The offset from starting position */
-    const glm::vec3 m_offset;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles

src/WallpaperEngine/Core/Objects/Particles/CEmitter.cpp

@@ -1,75 +0,0 @@
-#include "CEmitter.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core::Objects::Particles;
-
-const CEmitter* CEmitter::fromJSON (const json& data) {
-    const auto distancemax_it = jsonFindRequired (data, "distancemax", "Particle emitter must have maximum distance");
-    const auto distancemin_it = jsonFindRequired (data, "distancemin", "Particle emitter must have minimum distance");
-
-    auto distancemin = glm::vec3(0);
-    auto distancemax = glm::vec3(0);
-
-    if (distancemin_it->is_number()) {
-        distancemin = glm::vec3(static_cast<uint32_t>(*distancemin_it));
-    } else {
-        distancemin = WallpaperEngine::Core::aToVector3(*distancemin_it);
-    }
-
-    if (distancemax_it->is_number()) {
-        distancemax = glm::vec3(static_cast<uint32_t>(*distancemax_it));
-    } else {
-        distancemax = WallpaperEngine::Core::aToVector3(*distancemax_it);
-    }
-
-    return new CEmitter (
-        jsonFindRequired <glm::vec3> (data, "directions", "Particle emitter must have direction specified"),
-        distancemax,
-        distancemin,
-        jsonFindDefault (data, "id", 0),
-        jsonFindRequired <std::string> (data, "name", "Particle emitter must have a name"),
-        jsonFindRequired <glm::vec3> (data, "origin", "Particle emitter must have an origin"),
-        jsonFindRequired <double> (data, "rate", "Particle emitter must have a rate")
-    );
-}
-
-CEmitter::CEmitter (
-    glm::vec3 directions, glm::vec3 distancemax, glm::vec3 distancemin, uint32_t id, std::string name, glm::vec3 origin,
-    double rate
-) :
-    m_directions (directions),
-    m_distancemax (distancemax),
-    m_distancemin (distancemin),
-    m_id (id),
-    m_name (std::move(name)),
-    m_origin (origin),
-    m_rate (rate) {}
-
-uint32_t CEmitter::getId () const {
-    return this->m_id;
-}
-
-const std::string& CEmitter::getName () const {
-    return this->m_name;
-}
-
-const glm::vec3& CEmitter::getDistanceMax () const {
-    return this->m_distancemax;
-}
-
-const glm::vec3& CEmitter::getDistanceMin () const {
-    return this->m_distancemin;
-}
-
-const glm::vec3& CEmitter::getDirections () const {
-    return this->m_directions;
-}
-
-const glm::vec3& CEmitter::getOrigin () const {
-    return this->m_origin;
-}
-
-const double CEmitter::getRate () const {
-    return this->m_rate;
-}

src/WallpaperEngine/Core/Objects/Particles/CEmitter.h

@@ -1,65 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects::Particles {
-using json = nlohmann::json;
-
-/**
- * Particle emitter, controls the area where the particles have to be created
- */
-class CEmitter {
-  public:
-    static const CEmitter* fromJSON (const json& data);
-
-    /**
-     * @return The ID of the emitter
-     */
-    [[nodiscard]] uint32_t getId () const;
-    /**
-     * @return The name of the emitter, indicates what type of emission to do
-     */
-    [[nodiscard]] const std::string& getName () const;
-    /**
-     * @return The maximum distance a particle can travel before being dead
-     */
-    [[nodiscard]] const glm::vec3& getDistanceMax () const;
-    /**
-     * @return The minimum distance a particle can travel before being dead
-     */
-    [[nodiscard]] const glm::vec3& getDistanceMin () const;
-    /**
-     * @return The direction a particle should move to
-     */
-    [[nodiscard]] const glm::vec3& getDirections () const;
-    /**
-     * @return The center of the particle emission
-     */
-    [[nodiscard]] const glm::vec3& getOrigin () const;
-    /**
-     * @return The rate of particle emission
-     */
-    [[nodiscard]] const double getRate () const;
-
-  protected:
-    CEmitter (
-        glm::vec3 directions, glm::vec3 distancemax, glm::vec3 distancemin, uint32_t id, std::string name,
-        glm::vec3 origin, double rate);
-
-  private:
-    /** Direction the particles should move to */
-    const glm::vec3 m_directions;
-    /** Maximum distance before the particle is dead */
-    const glm::vec3 m_distancemax;
-    /** Minimum distance before the particle is dead */
-    const glm::vec3 m_distancemin;
-    /** ID of the emitter */
-    const uint32_t m_id;
-    /** Name of the emitter, indicates the type of emitter */
-    const std::string m_name;
-    /** The center of the emitter */
-    const glm::vec3 m_origin;
-    /** The rate of emission */
-    const double m_rate;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles

src/WallpaperEngine/Core/Objects/Particles/CInitializer.cpp

@@ -1,59 +0,0 @@
-#include "CInitializer.h"
-
-#include <utility>
-
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles;
-
-const CInitializer* CInitializer::fromJSON (const json& data) {
-    const auto name = jsonFindRequired <std::string> (data, "name", "Particle's initializer must have a name");
-    const auto id = jsonFindDefault (data, "id", 0);
-
-    if (name == "lifetimerandom") {
-        return Initializers::CLifeTimeRandom::fromJSON (data, id);
-    }
-    if (name == "sizerandom") {
-        return Initializers::CSizeRandom::fromJSON (data, id);
-    }
-    if (name == "rotationrandom") {
-        return Initializers::CRotationRandom::fromJSON (data, id);
-    }
-    if (name == "velocityrandom") {
-        return Initializers::CVelocityRandom::fromJSON (data, id);
-    }
-    if (name == "colorrandom") {
-        return Initializers::CColorRandom::fromJSON (data, id);
-    }
-    if (name == "alpharandom") {
-        return Initializers::CAlphaRandom::fromJSON (data, id);
-    }
-    if (name == "angularvelocityrandom") {
-        return Initializers::CAngularVelocityRandom::fromJSON (data, id);
-    }
-    if (name == "turbulentvelocityrandom") {
-        return Initializers::CTurbulentVelocityRandom::fromJSON (data, id);
-    }
-
-    sLog.exception ("Found unknown initializer for particles: ", name);
-}
-
-CInitializer::CInitializer (uint32_t id, std::string name) :
-    m_id (id),
-    m_name (std::move(name)) {}
-
-const std::string& CInitializer::getName () const {
-    return this->m_name;
-}
-
-uint32_t CInitializer::getId () const {
-    return this->m_id;
-}

src/WallpaperEngine/Core/Objects/Particles/CInitializer.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects::Particles {
-using json = nlohmann::json;
-
-/**
- * Initializer for particles, controls the different attributes a particle will have
- * on emission
- */
-class CInitializer {
-  public:
-    static const CInitializer* fromJSON (const json& data);
-
-    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);
-    }
-
-    /**
-     * @return The name of the particle initializer, indicates what type of initialization to do
-     */
-    [[nodiscard]] const std::string& getName () const;
-    /**
-     * @return The id of the initializer
-     */
-    [[nodiscard]] uint32_t getId () const;
-
-  protected:
-    CInitializer (uint32_t id, std::string name);
-
-    virtual ~CInitializer() = default;
-
-  private:
-    /** ID for ordering purposes */
-    const uint32_t m_id;
-    /** The name of the initializer, indicates what type of initialization to do */
-    const std::string m_name;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles

src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.cpp

@@ -1,24 +0,0 @@
-#include "CAlphaRandom.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles::Initializers;
-
-const CAlphaRandom* CAlphaRandom::fromJSON (const json& data, uint32_t id) {
-    return new CAlphaRandom (
-        id,
-        jsonFindRequired<double> (data, "min", "Alpharandom initializer must have a minimum value"),
-        jsonFindRequired<double> (data, "max", "Alpharandom initializer must have a maximum value")
-    );
-}
-
-CAlphaRandom::CAlphaRandom (uint32_t id, double min, double max) :
-    CInitializer (id, "alpharandom"),
-    m_max (max),
-    m_min (min) {}
-
-double CAlphaRandom::getMinimum () const {
-    return this->m_min;
-}
-
-double CAlphaRandom::getMaximum () const {
-    return this->m_max;
-}

src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-namespace WallpaperEngine::Core::Objects::Particles::Initializers {
-/**
- * Initializer for particles that decides the base alpha for the particles
- */
-class CAlphaRandom : CInitializer {
-  public:
-    /**
-     * @return The minimum alpha value to be used
-     */
-    [[nodiscard]] double getMinimum () const;
-    /**
-     * @return The maximum alpha value to be used
-     */
-    [[nodiscard]] double getMaximum () const;
-
-  protected:
-    friend class CInitializer;
-
-    static const CAlphaRandom* fromJSON (const json& data, uint32_t id);
-
-    CAlphaRandom (uint32_t id, double min, double max);
-
-  private:
-    /** Maximum alpha */
-    const double m_max;
-    /** Minimum alpha */
-    const double m_min;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles::Initializers

src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.cpp

@@ -1,24 +0,0 @@
-#include "CAngularVelocityRandom.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles::Initializers;
-
-const CAngularVelocityRandom* CAngularVelocityRandom::fromJSON (const json& data, uint32_t id) {
-    return new CAngularVelocityRandom (
-        id,
-        jsonFindRequired <glm::vec3> (data, "min", "Angularvelocityrandom initializer must have a minimum value"),
-        jsonFindRequired <glm::vec3> (data, "max", "Angularvelocityrandom initializer must have a maximum value")
-    );
-}
-
-CAngularVelocityRandom::CAngularVelocityRandom (uint32_t id, glm::vec3 min, glm::vec3 max) :
-    CInitializer (id, "angularvelocityrandom"),
-    m_max (max),
-    m_min (min) {}
-
-const glm::vec3& CAngularVelocityRandom::getMinimum () const {
-    return this->m_min;
-}
-
-const glm::vec3& CAngularVelocityRandom::getMaximum () const {
-    return this->m_max;
-}

src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-namespace WallpaperEngine::Core::Objects::Particles::Initializers {
-/**
- * Initializer for particles that decides the base angular velocity for particles
- */
-class CAngularVelocityRandom : CInitializer {
-  public:
-    /**
-     * @return Minimum angular velocity (direction * speed)
-     */
-    [[nodiscard]] const glm::vec3& getMinimum () const;
-    /**
-     * @return Maximum angular velocity (direction * speed)
-     */
-    [[nodiscard]] const glm::vec3& getMaximum () const;
-
-  protected:
-    friend class CInitializer;
-
-    static const CAngularVelocityRandom* fromJSON (const json& data, uint32_t id);
-
-    CAngularVelocityRandom (uint32_t id, glm::vec3 min, glm::vec3 max);
-
-  private:
-    /** Maximum velocity (direction * speed) */
-    const glm::vec3 m_max;
-    /** Minimum velocity (direction * speed) */
-    const glm::vec3 m_min;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles::Initializers