platform.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 PLATFORM_HPP
#define PLATFORM_HPP

#include <string>
#include <vector>

#include "asset_manager.hpp"
#include "framework/common.hpp"
#include "framework/context.hpp"

namespace MaliSDK
{

class Platform
{
public:
        static Platform &get();

        virtual ~Platform() = default;

        Platform(Platform &&) = delete;
        void operator=(Platform &&) = delete;

        struct SwapchainDimensions
        {
                unsigned width;
                unsigned height;
                VkFormat format;
        };

        enum Status
        {
                STATUS_RUNNING,

                STATUS_TEARDOWN
        };

        inline Context &getContext()
        {
                return *pContext;
        }

        virtual Result initialize() = 0;

        inline void addExternalLayer(const char *pName)
        {
                externalLayers.push_back(pName);
        }

        inline void setExternalDebugCallback(PFN_vkDebugReportCallbackEXT callback, void *pUserData)
        {
                externalDebugCallback = callback;
                pExternalDebugCallbackUserData = pUserData;
        }

        inline PFN_vkDebugReportCallbackEXT getExternalDebugCallback() const
        {
                return externalDebugCallback;
        }

        inline void *getExternalDebugCallbackUserData() const
        {
                return pExternalDebugCallbackUserData;
        }

        virtual SwapchainDimensions getPreferredSwapchain() = 0;

        virtual Result createWindow(const SwapchainDimensions &swapchain) = 0;

        virtual void getCurrentSwapchain(std::vector<VkImage> *images, SwapchainDimensions *swapchain) = 0;

        virtual unsigned getNumSwapchainImages() const = 0;

        virtual Result acquireNextImage(unsigned *index) = 0;

        virtual Result presentImage(unsigned index) = 0;

        virtual Status getWindowStatus() = 0;

        virtual void terminate() = 0;

        inline VkDevice getDevice() const
        {
                return device;
        }

        inline VkPhysicalDevice getPhysicalDevice() const
        {
                return gpu;
        }

        inline VkInstance getInstance() const
        {
                return instance;
        }

        inline VkQueue getGraphicsQueue() const
        {
                return queue;
        }

        inline unsigned getGraphicsQueueIndex() const
        {
                return graphicsQueueIndex;
        }

        inline const VkPhysicalDeviceProperties &getGpuProperties() const
        {
                return gpuProperties;
        }

        inline const VkPhysicalDeviceMemoryProperties &getMemoryProperties() const
        {
                return memoryProperties;
        }

protected:
        Platform() = default;

        VkInstance instance = VK_NULL_HANDLE;

        VkPhysicalDevice gpu = VK_NULL_HANDLE;

        VkDevice device = VK_NULL_HANDLE;

        VkQueue queue = VK_NULL_HANDLE;

        Context *pContext = nullptr;

        VkPhysicalDeviceProperties gpuProperties;

        VkPhysicalDeviceMemoryProperties memoryProperties;

        std::vector<VkQueueFamilyProperties> queueProperties;

        unsigned graphicsQueueIndex;

        std::vector<std::string> externalLayers;

        PFN_vkDebugReportCallbackEXT externalDebugCallback = nullptr;
        void *pExternalDebugCallbackUserData = nullptr;

        inline void addExternalLayers(std::vector<const char *> &activeLayers,
                                      const std::vector<VkLayerProperties> &supportedLayers)
        {
                for (auto &layer : externalLayers)
                {
                        for (auto &supportedLayer : supportedLayers)
                        {
                                if (layer == supportedLayer.layerName)
                                {
                                        activeLayers.push_back(supportedLayer.layerName);
                                        LOGI("Found external layer: %s\n", supportedLayer.layerName);
                                        break;
                                }
                        }
                }
        }
};
}

#endif