context.hpp

/* Copyright (c) 2016-2017, ARM Limited and Contributors
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge,
 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef FRAMEWORK_CONTEXT_HPP
#define FRAMEWORK_CONTEXT_HPP

#include "command_buffer_manager.hpp"
#include "fence_manager.hpp"
#include "framework/common.hpp"
#include <memory>
#include <vector>

namespace MaliSDK
{
class Platform;

class Context
{
public:
        Result onPlatformUpdate(Platform *pPlatform);

        VkDevice getDevice()
        {
                return device;
        }

        VkPhysicalDevice getPhysicalDevice() const;

        VkQueue getGraphicsQueue()
        {
                return queue;
        }

        Platform &getPlatform()
        {
                return *pPlatform;
        }

        VkCommandBuffer requestPrimaryCommandBuffer()
        {
                return perFrame[swapchainIndex]->commandManager.requestCommandBuffer();
        }

        VkCommandBuffer requestSecondaryCommandBuffer(unsigned threadIndex)
        {
                return perFrame[swapchainIndex]->secondaryCommandManagers[threadIndex]->requestCommandBuffer();
        }

        void submit(VkCommandBuffer cmdBuffer);

        void submitSwapchain(VkCommandBuffer cmdBuffer);

        VkSemaphore beginFrame(unsigned index, VkSemaphore acquireSemaphore)
        {
                swapchainIndex = index;
                perFrame[swapchainIndex]->beginFrame();
                return perFrame[swapchainIndex]->setSwapchainAcquireSemaphore(acquireSemaphore);
        }

        void setRenderingThreadCount(unsigned count)
        {
                vkQueueWaitIdle(queue);
                for (auto &pFrame : perFrame)
                        pFrame->setSecondaryCommandManagersCount(count);
                renderingThreadCount = count;
        }

        FenceManager &getFenceManager()
        {
                return perFrame[swapchainIndex]->fenceManager;
        }

        const VkSemaphore &getSwapchainAcquireSemaphore() const
        {
                return perFrame[swapchainIndex]->swapchainAcquireSemaphore;
        }

        const VkSemaphore &getSwapchainReleaseSemaphore() const
        {
                return perFrame[swapchainIndex]->swapchainReleaseSemaphore;
        }

private:
        Platform *pPlatform = nullptr;
        VkDevice device = VK_NULL_HANDLE;
        VkQueue queue = VK_NULL_HANDLE;
        unsigned swapchainIndex = 0;
        unsigned renderingThreadCount = 0;

        struct PerFrame
        {
                PerFrame(VkDevice device, unsigned graphicsQueueIndex);
                ~PerFrame();

                void beginFrame();
                VkSemaphore setSwapchainAcquireSemaphore(VkSemaphore acquireSemaphore);
                void setSwapchainReleaseSemaphore(VkSemaphore releaseSemaphore);
                void setSecondaryCommandManagersCount(unsigned count);

                VkDevice device = VK_NULL_HANDLE;
                FenceManager fenceManager;
                CommandBufferManager commandManager;
                std::vector<std::unique_ptr<CommandBufferManager>> secondaryCommandManagers;
                VkSemaphore swapchainAcquireSemaphore = VK_NULL_HANDLE;
                VkSemaphore swapchainReleaseSemaphore = VK_NULL_HANDLE;
                unsigned queueIndex;
        };
        std::vector<std::unique_ptr<PerFrame>> perFrame;

        void submitCommandBuffer(VkCommandBuffer, VkSemaphore acquireSemaphore, VkSemaphore releaseSemaphore);
        void waitIdle();
};
}

#endif