Application.hpp

Go to the documentation of this file.

/*
   Copyright 2022 Rishi Challa
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
       http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/
 
#pragma once
 
#include <Kale/Core/Window/Window.hpp>
#include <Kale/Core/Logger/Logger.hpp>
#include <Kale/Core/Scene/Scene.hpp>
 
#include <string>
#include <memory>
#include <thread>
#include <list>
#include <vector>
#include <mutex>
#include <queue>
#include <functional>
#include <condition_variable>
 
int main();
 
namespace Kale {
 
    class Application {
    private:
 
        static std::vector<std::function<void()>> nodeSetupFuncs;
        
        static std::vector<std::function<void()>> nodeCleanupFuncs;
        
        std::list<std::thread> updateThreads;
 
        std::queue<std::function<void()>> tasks;
 
        std::mutex threadSyncMutex;
 
        std::mutex taskManagerMutex;
 
        std::condition_variable threadSyncCondVar;
 
        std::condition_variable renderSyncCondVar;
 
        size_t numThreadsUpdated;
 
        bool updatingFinished;
 
        bool renderingFinished;
 
        float deltaTime;
 
        std::shared_ptr<Scene> presentedScene;
 
        std::shared_ptr<Scene> sceneToPresent;
 
        void update(size_t threadNum) noexcept;
 
        void synchronizeUpdate();
    
    protected:
 
        Window window;
 
        virtual void onBegin() {}
 
        virtual void onEnd() {}
 
        void run() noexcept;
 
        explicit Application(const char* applicationName) noexcept;
 
        friend int ::main();
 
    public:
 
        const std::string applicationName;
 
        // App class doesn't support copying/moving
        Application(const Application& other) = delete;
        Application(Application&& other) = delete;
        void operator=(const Application& other) = delete;
        void operator=(Application&& other) = delete;
        
        Window& getWindow() noexcept;
 
        [[nodiscard]] std::shared_ptr<Scene> getPresentedScene() noexcept;
 
        [[nodiscard]] const Window& getWindow() const noexcept;
 
        [[nodiscard]] std::shared_ptr<const Scene> getPresentedScene() const noexcept;
 
        void presentScene(const std::shared_ptr<Scene>& scene);
 
        [[nodiscard]] size_t getNumUpdateThreads() const noexcept;
 
        void runTaskOnMainThread(std::function<void()> task);
 
        std::string getAssetFolderPath() const;
 
        static void addNodeSetupFunction(std::function<void()> func) {
            nodeSetupFuncs.push_back(func);
        }
 
        static void addNodeCleanupFunction(std::function<void()> func) {
            nodeCleanupFuncs.push_back(func);
        }
    };
 
    inline Application* mainApp = nullptr;
}
 
extern Kale::Application* createApplication();