Statically link shaders, update cmake version, c++ version and add CPM for cmake package managment

CMakeLists.txt

@@ -1,11 +1,19 @@
-cmake_minimum_required(VERSION 3.16)
-project(AnimeEffects VERSION 1.5.0 LANGUAGES C CXX)
+cmake_minimum_required(VERSION 3.21)
+project(AnimeEffects C CXX)
 
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
 
+set(CMAKE_CXX_STANDARD 20)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
+include(get_cpm)
+
+CPMAddPackage("gh:batterycenter/embed#v1.2.19")
+
 include(GNUInstallDirs)
 # You need to add the Qt directory to your path if you're on Windows, otherwise you'll have a very bad time
 find_package(Qt6 REQUIRED COMPONENTS Core5Compat Core Gui OpenGL OpenGLWidgets Xml Concurrent Widgets Multimedia)

cmake/modules/get_cpm.cmake

@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: MIT
+#
+# SPDX-FileCopyrightText: Copyright (c) 2019-2023 Lars Melchior and contributors
+
+set(CPM_DOWNLOAD_VERSION 0.40.2)
+set(CPM_HASH_SUM "c8cdc32c03816538ce22781ed72964dc864b2a34a310d3b7104812a5ca2d835d")
+
+if(CPM_SOURCE_CACHE)
+  set(CPM_DOWNLOAD_LOCATION "${CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+elseif(DEFINED ENV{CPM_SOURCE_CACHE})
+  set(CPM_DOWNLOAD_LOCATION "$ENV{CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+else()
+  set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+endif()
+
+# Expand relative path. This is important if the provided path contains a tilde (~)
+get_filename_component(CPM_DOWNLOAD_LOCATION ${CPM_DOWNLOAD_LOCATION} ABSOLUTE)
+
+file(DOWNLOAD
+     https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
+     ${CPM_DOWNLOAD_LOCATION} EXPECTED_HASH SHA256=${CPM_HASH_SUM}
+)
+
+include(${CPM_DOWNLOAD_LOCATION})

src/core/CMakeLists.txt

@@ -70,6 +70,21 @@ add_library(${PROJECT_NAME}
     TimeLine.cpp TimeLine.h
     TimeLineEvent.cpp TimeLineEvent.h
 )
+
+set(SHADERS_DIR ../../data/shader)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/ClipperWritingFrag.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/ClipperWritingVert.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/GridDrawingFrag.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/GridDrawingVert.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/HSVAdjustFrag.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/HSVAdjustVert.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/LayerDrawingFrag.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/LayerDrawingVert.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/MeshTransformVert.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/PartialScreenCopyingFrag.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/PartialScreenCopyingVert.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/TestBlurVert.glsl)
+
 target_include_directories(${PROJECT_NAME} PUBLIC
     ..
 )
@@ -83,6 +98,7 @@ target_compile_definitions(${PROJECT_NAME} PUBLIC
     AE_PROJECT_FORMAT_OLDEST_MAJOR_VERSION=0
     AE_PROJECT_FORMAT_OLDEST_MINOR_VERSION=4
     USE_GL_CORE_PROFILE
+    SHADERS_DIR="${SHADERS_DIR}"
 )
 
 target_link_libraries(${PROJECT_NAME} PUBLIC

src/core/DestinationTexturizer.cpp

@@ -1,6 +1,7 @@
 #include "gl/Global.h"
 #include "gl/Util.h"
 #include "core/DestinationTexturizer.h"
+#include "battery/embed.hpp"
 
 namespace {
 static const int kAttachmentId = 0;
@@ -104,13 +105,13 @@ void DestinationTexturizer::createShader() {
     auto shader = &mShader;
 
     gl::ExtendShader source;
-    if (!source.openFromFileVert("./data/shader/PartialScreenCopyingVert.glsl")) {
-        XC_FATAL_ERROR("FileIO Error", "Current location: " + QDir::currentPath() +
-                           "Failed to open vertex shader file.", source.log());
+    {
+        auto tmp = b::embed<"../../data/shader/PartialScreenCopyingVert.glsl">();
+        source.openFromTextVert(QString::fromUtf8(tmp.data(), tmp.size()));
     }
-    if (!source.openFromFileFrag("./data/shader/PartialScreenCopyingFrag.glsl")) {
-        XC_FATAL_ERROR("FileIO Error", "Current location: " + QDir::currentPath() +
-                           "Failed to open fragment shader file.", source.log());
+    {
+        auto tmp = b::embed<"../../data/shader/PartialScreenCopyingFrag.glsl">();
+        source.openFromTextFrag(QString::fromUtf8(tmp.data(), tmp.size()));
     }
 
     if (!source.resolveVariation()) {

src/core/LayerNode.cpp

@@ -29,7 +29,7 @@ LayerNode::LayerNode(const QString& aName, ShaderHolder& aShaderHolder):
     mTimeLine(),
     mShaderHolder(aShaderHolder),
     mIsClipped(),
-    mMeshTransformer("./data/shader/MeshTransformVert.glsl"),
+    mMeshTransformer(),
     mCurrentMesh(),
     mClippees() {}
 

src/core/MeshTransformer.cpp

@@ -7,9 +7,9 @@
 namespace core {
 
 //-------------------------------------------------------------------------------------------------
-MeshTransformer::MeshTransformer(const QString& aShaderPath):
+MeshTransformer::MeshTransformer():
     mResource(*(new MeshTransformerResource())), mResourceOwns(true), mOutPositions(), mOutXArrows(), mOutYArrows() {
-    mResource.setup(aShaderPath);
+    mResource.setup();
 }
 
 MeshTransformer::MeshTransformer(MeshTransformerResource& aResource):

src/core/MeshTransformer.h

@@ -16,7 +16,7 @@ namespace core {
 
 class MeshTransformer: private util::NonCopyable {
 public:
-    MeshTransformer(const QString& aShaderPath);
+    MeshTransformer();
     MeshTransformer(MeshTransformerResource& aResource);
     ~MeshTransformer();
 

src/core/MeshTransformerResource.cpp

@@ -2,15 +2,16 @@
 #include "gl/Global.h"
 #include "gl/ExtendShader.h"
 #include "core/MeshTransformerResource.h"
+#include "battery/embed.hpp"
 
 namespace core {
 
 //-------------------------------------------------------------------------------------------------
 MeshTransformerResource::MeshTransformerResource() {}
 
-void MeshTransformerResource::setup(const QString& aShaderPath) {
-    QString code;
-    loadFile(aShaderPath, code);
+void MeshTransformerResource::setup() {
+    auto tmp = b::embed<"../../data/shader/MeshTransformVert.glsl">();
+    auto code = QString::fromUtf8(tmp.data(), tmp.size());
 
     buildShader(mProgram[0], code, false, false);
     buildShader(mProgram[1], code, true, false);

src/core/MeshTransformerResource.h

@@ -8,7 +8,7 @@ namespace core {
 class MeshTransformerResource {
 public:
     MeshTransformerResource();
-    void setup(const QString& aShaderPath);
+    void setup();
     gl::EasyShaderProgram& program(bool aUseSkinning, bool aUseDualQuaternion);
     const gl::EasyShaderProgram& program(bool aUseSkinning, bool aUseDualQuaternion) const;
 

src/core/ShaderHolder.cpp

@@ -1,6 +1,7 @@
 #include "gl/ExtendShader.h"
 #include "gl/Global.h"
 #include "core/ShaderHolder.h"
+#include "battery/embed.hpp"
 
 namespace core {
 
@@ -37,13 +38,13 @@ gl::EasyShaderProgram& ShaderHolder::reserveShader(img::BlendMode aBlendMode, bo
         auto shader = mShaders[index];
 
         gl::ExtendShader source;
-        if (!source.openFromFileVert("./data/shader/LayerDrawingVert.glsl")) {
-            XC_FATAL_ERROR("FileIO Error", "Current location: " + QDir::currentPath() +
-                               "Failed to open vertex shader file.", source.log());
+        {
+            auto tmp = b::embed<"../../data/shader/LayerDrawingVert.glsl">();
+            source.openFromTextVert(QString::fromUtf8(tmp.data(), tmp.size()));
         }
-        if (!source.openFromFileFrag("./data/shader/LayerDrawingFrag.glsl")) {
-            XC_FATAL_ERROR("FileIO Error", "Current location: " + QDir::currentPath() +
-                               "Failed to open fragment shader file.", source.log());
+        {
+            auto tmp = b::embed<"../../data/shader/LayerDrawingFrag.glsl">();
+            source.openFromTextFrag(QString::fromUtf8(tmp.data(), tmp.size()));
         }
 
         auto blendFunc = QString("Blend") + img::getBlendFuncNameFromBlendMode(aBlendMode);
@@ -90,13 +91,14 @@ gl::EasyShaderProgram& ShaderHolder::reserveHSVShader() {
         auto shader = mHSVShaders[index];
 
         gl::ExtendShader source;
-        if (!source.openFromFileVert("./data/shader/HSVAdjustVert.glsl")) {
-            XC_FATAL_ERROR("FileIO Error", "Current location: " + QDir::currentPath() +
-                               "Failed to open vertex shader file.", source.log());
+
+        {
+            auto tmp = b::embed<"../../data/shader/HSVAdjustVert.glsl">();
+            source.openFromTextVert(QString::fromUtf8(tmp.data(), tmp.size()));
         }
-        if (!source.openFromFileFrag("./data/shader/HSVAdjustFrag.glsl")) {
-            XC_FATAL_ERROR("FileIO Error", "Current location: " + QDir::currentPath() +
-                               "Failed to open fragment shader file.", source.log());
+        {
+            auto tmp = b::embed<"../../data/shader/HSVAdjustFrag.glsl">();
+            source.openFromTextFrag(QString::fromUtf8(tmp.data(), tmp.size()));
         }
 
         if (!source.resolveVariation()) {
@@ -134,13 +136,13 @@ gl::EasyShaderProgram& ShaderHolder::reserveGridShader() {
         auto shader = mGridShaders[0];
 
         gl::ExtendShader source;
-        if (!source.openFromFileVert("./data/shader/GridDrawingVert.glsl")) {
-            XC_FATAL_ERROR("FileIO Error", "Current location: " + QDir::currentPath() +
-                               "Failed to open vertex shader file.", source.log());
+        {
+            auto tmp = b::embed<"../../data/shader/GridDrawingVert.glsl">();
+            source.openFromTextVert(QString::fromUtf8(tmp.data(), tmp.size()));
         }
-        if (!source.openFromFileFrag("./data/shader/GridDrawingFrag.glsl")) {
-            XC_FATAL_ERROR("FileIO Error", "Current location: " + QDir::currentPath() +
-                                "Failed to open fragment shader file.", source.log());
+        {
+            auto tmp = b::embed<"../../data/shader/GridDrawingFrag.glsl">();
+            source.openFromTextFrag(QString::fromUtf8(tmp.data(), tmp.size()));
         }
 
         if (!source.resolveVariation()) {
@@ -175,13 +177,13 @@ gl::EasyShaderProgram& ShaderHolder::reserveClipperShader(bool aIsClippee) {
         auto shader = mClipperShaders[aIsClippee];
 
         gl::ExtendShader source;
-        if (!source.openFromFileVert("./data/shader/ClipperWritingVert.glsl")) {
-            XC_FATAL_ERROR("FileIO Error", "Current location: " + QDir::currentPath() +
-                               "Failed to open vertex shader file.", source.log());
+        {
+            auto tmp = b::embed<"../../data/shader/ClipperWritingVert.glsl">();
+            source.openFromTextVert(QString::fromUtf8(tmp.data(), tmp.size()));
         }
-        if (!source.openFromFileFrag("./data/shader/ClipperWritingFrag.glsl")) {
-            XC_FATAL_ERROR("FileIO Error", "Current location: " + QDir::currentPath() +
-                               "Failed to open fragment shader file.", source.log());
+        {
+            auto tmp = b::embed<"../../data/shader/ClipperWritingFrag.glsl">();
+            source.openFromTextFrag(QString::fromUtf8(tmp.data(), tmp.size()));
         }
 
         source.setVariationValue("IS_CLIPPEE", aIsClippee ? "1" : "0");

src/ctrl/CMakeLists.txt

@@ -100,6 +100,13 @@ add_library(${PROJECT_NAME}
     time/time_Scaler.cpp time/time_Scaler.h
         ExportParams.h
 )
+
+set(SHADERS_DIR ../../data/shader)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/FFDBlurVert.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/FFDEraseVert.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/FFDFocusVertexVert.glsl)
+b_embed(${PROJECT_NAME} ${SHADERS_DIR}/FreeFormDeformVert.glsl)
+
 target_include_directories(${PROJECT_NAME} PUBLIC
     ..
 )

src/ctrl/FFDEditor.cpp

@@ -23,17 +23,12 @@ FFDEditor::FFDEditor(Project& aProject, DriverResources& aDriverResources, UILog
     if (!mDriverResources.meshTransformerResource()) {
         gl::Global::makeCurrent();
         mDriverResources.grabMeshTransformerResoure(new core::MeshTransformerResource());
-        mDriverResources.meshTransformerResource()->setup("./data/shader/MeshTransformVert.glsl");
+        mDriverResources.meshTransformerResource()->setup();
     }
     if (!mDriverResources.ffdTaskResource()) {
         gl::Global::makeCurrent();
         mDriverResources.grabFFDTaskResource(new ffd::TaskResource());
-        mDriverResources.ffdTaskResource()->setup(
-            "./data/shader/FreeFormDeformVert.glsl",
-            "./data/shader/FFDEraseVert.glsl",
-            "./data/shader/FFDFocusVertexVert.glsl",
-            "./data/shader/FFDBlurVert.glsl"
-        );
+        mDriverResources.ffdTaskResource()->setup();
     }
 
 #if 0

src/ctrl/ffd/ffd_TaskResource.cpp

@@ -2,20 +2,19 @@
 #include "gl/Global.h"
 #include "gl/ExtendShader.h"
 #include "ctrl/ffd/ffd_TaskResource.h"
+#include "battery/embed.hpp"
 
 namespace ctrl {
 namespace ffd {
 
     //-------------------------------------------------------------------------------------------------
     TaskResource::TaskResource() {}
 
-    void TaskResource::setup(
-        const QString& aBrushPath, const QString& aEraserPath, const QString& aFocuserPath, const QString& aBlurPath
-    ) {
+    void TaskResource::setup() {
         // load brush shader
         {
-            QString code;
-            loadFile(aBrushPath, code);
+            auto tmp = b::embed<"../../data/shader/FreeFormDeformVert.glsl">();
+            auto code = QString::fromUtf8(tmp.data(), tmp.size());
 
             for (int hard = 0; hard < kHardness; ++hard) {
                 buildShader(mProgram[kTypeDeformer * kHardness + hard], code, kTypeDeformer, hard);
@@ -24,8 +23,8 @@ namespace ffd {
 
         // load eraser shader
         {
-            QString code;
-            loadFile(aEraserPath, code);
+            auto tmp = b::embed<"../../data/shader/FFDEraseVert.glsl">();
+            auto code = QString::fromUtf8(tmp.data(), tmp.size());
 
             for (int hard = 0; hard < kHardness; ++hard) {
                 buildShader(mProgram[kTypeEraser * kHardness + hard], code, kTypeEraser, hard);
@@ -34,16 +33,17 @@ namespace ffd {
 
         // load focuser shader
         {
-            QString code;
-            loadFile(aFocuserPath, code);
+            auto tmp = b::embed<"../../data/shader/FFDFocusVertexVert.glsl">();
+            auto code = QString::fromUtf8(tmp.data(), tmp.size());
 
             buildShader(mProgram[kTypeFocuser * kHardness], code, kTypeFocuser, 0);
         }
 
         // load blur path
         {
-            QString code;
-            loadFile(aBlurPath, code);
+            auto tmp = b::embed<"../../data/shader/FFDBlurVert.glsl">();
+            auto code = QString::fromUtf8(tmp.data(), tmp.size());
+
             buildBlurShader(mBlurProgram, code);
         }
     }

src/ctrl/ffd/ffd_TaskResource.h

@@ -13,9 +13,7 @@ namespace ffd {
 
         TaskResource();
 
-        void setup(
-            const QString& aBrushPath, const QString& aEraserPath, const QString& aFocuserPath, const QString& aBlurPath
-        );
+        void setup();
 
         gl::EasyShaderProgram& program(int aType, int aHard);
         const gl::EasyShaderProgram& program(int aType, int aHard) const;

src/gui/MainMenuBar.cpp

@@ -20,7 +20,7 @@
 namespace gui {
 //-------------------------------------------------------------------------------------------------
 QDomDocument getVideoExportDocument() {
-    QFile file("./data/encode/VideoEncode.txt");
+    auto file = QFile("./data/encode/VideoEncode.txt");
 
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         qDebug() << file.errorString();