WindowAbstract.cpp

/* ----------------------
* Copyright 2023 Université Libre de Bruxelles(ULB), Universidad Politécnica de Madrid(UPM), CREAL, Deutsches Zentrum für Luft - und Raumfahrt(DLR)
 
* 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 permissionsand
* limitations under the License.
---------------------- */
 
 
 
#include"WindowAbstract.h"
//#include"RVSConfig/include/Application.h"
#include "SourcesVulkan/VulkanContext.h"
#include "SourcesVulkan/VulkanWrapper.h"
#include "SourcesVulkan/VulkanHelperFunction.h"
 
const bool WindowAbstract::isValidationLayersEnabled()
{
    return enableValidationLayers;
}
 
 
bool WindowAbstract::isSwapChainNeeded()
{
    return needSwapchain;
}
 
bool WindowAbstract::isIndepFromWindowDimension()
{
    return separateFromWindowDim;
}
 
 
void WindowAbstract::setWrapper(VulkanWrapper* wraps)
{
    wrapper = wraps;
}
 
 
vk::Buffer WindowAbstract::getRenderingDestination()
{
    throw std::logic_error(std::string(__func__) + " not implemented");
    return vk::Buffer();
}
 
glm::vec3 WindowAbstract::getTranslation()
{
    return currentTranslation;
}
 
glm::vec3 WindowAbstract::getRotation()
{
    return currentRotation;
}
 
std::vector<vk::Image> WindowAbstract::getBlitDestinations(int view, int elem)
{
    auto res = std::vector<vk::Image>();
    return res;
}
 
std::vector<vk::Extent2D> WindowAbstract::getBlitExtentDestinations(int view, int elem)
{
    auto res = std::vector<vk::Extent2D>();
    /*
    if (isIndepFromWindowDimension()) {
        assert(view < swapchains.size());
        res.push_back(swapchains[view]->swapchainExtent);
    }*/
    return res;
}
 
std::vector<vk::Semaphore> WindowAbstract::getSemaphoreWait(int view, int elem)
{
    return std::vector<vk::Semaphore>();
}
 
std::vector<vk::Semaphore> WindowAbstract::getSemaphoreSignal(int view, int elem)
{
    return std::vector<vk::Semaphore>();
}
 
vk::ImageView WindowAbstract::getSwapchainImageView(int view, int elem)
{
    assert(view < swapchains.size());
    return swapchains[view]->getSwapchainImageView(elem);
}
 
vk::ImageView WindowAbstract::getDepthSwapchainImageView(int view, int elem)
{
    assert(view < depthSwapchains.size());
    return depthSwapchains[view]->getSwapchainImageView(elem);
}
 
int WindowAbstract::getViewNumber()
{
    return swapchains.size();
}
 
 
void WindowAbstract::setRotation(float v0,float v1,float v2) {
    currentRotation[0] = v0;
    currentRotation[1] = v1;
    currentRotation[2] = v2;
}
 
const bool WindowAbstract::useOpenXR() {
    return false;
}
 
bool WindowAbstract::isDepthRecquired()
{
    return false;
}
 
/*
vk::SurfaceFormatKHR WindowAbstract::chooseSwapSurfaceFormat(const std::vector<vk::SurfaceFormatKHR>& availableFormats)
{
    for (const auto& availableFormat : availableFormats) {
        
        //if (availableFormat.format == vk::Format::eB8G8R8A8Srgb && availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear) {
        //  return availableFormat;
        //}
        
        if (availableFormat.format == vk::Format::eB8G8R8Unorm && availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear) {
            return availableFormat;
        }
        else if (availableFormat.format == vk::Format::eB8G8R8A8Unorm && availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear) {
            return availableFormat;
        }
    }
    return availableFormats[0];
}*/
 
/*
vk::PresentModeKHR WindowAbstract::chooseSwapPresentMode(const std::vector<vk::PresentModeKHR>& availablePresentModes)
{
#ifndef __ANDROID__
    for (const auto& availablePresentMode : availablePresentModes) {
        if (availablePresentMode == vk::PresentModeKHR::eMailbox) {
            return availablePresentMode;
        }
    }
#endif
    return vk::PresentModeKHR::eFifo;
}
 
vk::Extent2D WindowAbstract::chooseSwapExtent(const vk::SurfaceCapabilitiesKHR& capabilities)
{
    if (capabilities.currentExtent.width != UINT32_MAX) {
        return capabilities.currentExtent;
    }
    else {
        int width, height;
 
        getFrameBufferSize(&width, &height, wrapper->context.physicalDevice);
#ifdef __ANDROID__
        LOGI("swap size w= %d, h = %d", width, height);
#endif
 
        vk::Extent2D actualExtent = {
            static_cast<uint32_t>(width),
            static_cast<uint32_t>(height)
        };
 
 
        actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width));
        actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height));
 
        return actualExtent;
    }
}
 
*/
 
/*
void WindowAbstract::createSwapchainImageViews()
{
    swapChainImageViews.resize(swapChainExtent.size());
 
    for (uint32_t view = 0; view < swapChainExtent.size(); view++) {
        int swapSize = swapChainImages[view].size();
        swapChainImageViews[view].resize(swapSize);
        for (uint32_t i = 0; i < swapSize; i++) {
            swapChainImageViews[view][i] = createImageView(wrapper->context.device, swapChainImages[view][i], swapChainImageFormat[view], vk::ImageAspectFlagBits::eColor);
            
        }
    }
 
}
*/
 
vk::Image WindowAbstract::getSwapchainImage(int view, int index) {
    assert(view < swapchains.size());
    return swapchains[view]->getSwapchainImage(index);
}
 
vk::Image WindowAbstract::getDepthSwapchainImage(int view, int index)
{
    assert(view < depthSwapchains.size());
    return depthSwapchains[view]->getSwapchainImage(index);
}
 
vk::Extent2D  WindowAbstract::getSwapchainExtent(int view)
{
    assert(view < swapchains.size());
    return swapchains[view]->swapchainExtent;
}
 
vk::Format  WindowAbstract::getSwapchainFormat(int view)
{
    assert(view < swapchains.size());
    return swapchains[view]->swapchainFormat;
}
 
vk::Format WindowAbstract::getDepthSwapchainFormat(int view)
{
    assert(view < depthSwapchains.size());
    return depthSwapchains[view]->swapchainFormat;
}
 
int WindowAbstract::getAttachmentSize()
{
    int res = 1;
    for (int i = 0; i < swapchains.size();i++) {
        int s = swapchains[i]->getAttachmentSize();
        res = s > res ? s : res;
    }
    return res;
}
 
/*
void WindowAbstract::continueInit()
{
    
    if (isSwapChainNeeded()) {
        
        createSwapChain();
        createSwapchainImageViews();
    }
} 
*/