VulkanRenderPassAbstract.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 "VulkanRenderPassAbstract.h"
#include"VulkanContext.h"
#include"VulkanPipelineWarping.h"
#include"VulkanPipelineBlending.h"
#include"VulkanHelperFunction.h"
#include <iostream>
#include "commonVulkan.h"
#include "VulkanWrapper.h"
#include "InputProvider.h"
 
#include <fstream>      // std::ifstream
 
 
#ifdef __ANDROID__
static const char* kTAG = "renderPass";
#define LOGI(...) \
  ((void)__android_log_print(ANDROID_LOG_INFO, kTAG, __VA_ARGS__))
#endif
 
#ifdef OCULUS_RVS
const bool transientAttachment = false;
#else
//transient bit not always available on dekstop card
const bool transientAttachment = false;
#endif
 
VulkanRenderPassAbstract::VulkanRenderPassAbstract(VulkanContext* context, VulkanWrapper* wraps)
{
    this->context = context;
    this->wrapper = wraps;
}
 
void VulkanRenderPassAbstract::init(InputProvider* inputProvider) {
 
    createCommandPoolForBuffer();
 
    //get streams Parameter and chose how many subpasses should be created
 
    this->input = inputProvider;
    auto streamsParams = inputProvider->enumerateStreamsParameters();
 
    auto activation = wrapper->getCameraActivation();
    inputImage = 0;
    for (auto a : activation) {
        if (a) { inputImage++; }
    }
 
    //inputImage = streamsParams.size();
    std::cout << "Nb of Input view: " << streamsParams.size() << std::endl;
    std::cout << "Nb of Activated camera: " << inputImage << std::endl;
}
 
void VulkanRenderPassAbstract::cleanUp()
{
    for (auto& im : depthImages) {
        im.destroy(context->device);
    }
    depthImages.clear();
 
    context->device.destroyCommandPool(commandPoolBuffer);
}
 
void VulkanRenderPassAbstract::updateBuffer(uint32_t currentImage, bool initAll, std::span<InputProvider::StreamFrameInfo> infos, int view)
{
}
 
void VulkanRenderPassAbstract::recordCommandBuffer(vk::CommandBuffer & commandBuffer, int i, std::span<InputProvider::StreamFrameInfo> frameInfos, int view)
{
}
 
bool VulkanRenderPassAbstract::isInitialized() {
    return initialized;
}
 
void VulkanRenderPassAbstract::createDepthResources()
{
    if (wrapper->isDepthOutputRecquired() && !context->isIndepFromWindowDimension()) {
        depthFormat = wrapper->getDepthSwapchainFormat();
    }
    else {
        depthFormat = context->findDepthFormat();
    }
 
    int attachmentSize = wrapper->multiviewSetup ? wrapper->getViewNumber(): wrapper->getAttachmentSize();
    depthImages.resize(attachmentSize);
    for (int i = 0; i < (attachmentSize); i++) {
 
        depthImages[i].createStruct(context, renderingExtent,depthFormat ,vk::ImageUsageFlagBits::eDepthStencilAttachment, vk::MemoryPropertyFlagBits::eDeviceLocal,
        commandPoolBuffer, vk::ImageLayout::eDepthStencilAttachmentOptimal, vk::ImageAspectFlagBits::eDepth);
        /*
        createImage(context->device, context->physicalDevice, renderingExtent.width, renderingExtent.height, depthFormat,
            vk::ImageTiling::eOptimal, vk::ImageUsageFlagBits::eDepthStencilAttachment, vk::MemoryPropertyFlagBits::eDeviceLocal, depthImage, depthImageMemory);
        depthImageView = createImageView(context->device, depthImage, depthFormat, vk::ImageAspectFlagBits::eDepth);
 
        transitionImageLayout(context, commandPoolBuffer, depthImage, depthFormat, vk::ImageLayout::eUndefined, vk::ImageLayout::eDepthStencilAttachmentOptimal);*/
    }
    //}
 
}
 
void VulkanRenderPassAbstract::createCommandPoolForBuffer()
{
    // create a CommandPool to allocate a CommandBuffer from
    QueueFamilyIndices queueFamilyIndices = context->findQueueFamilies(context->physicalDevice);
    vk::CommandPoolCreateInfo commandPoolInfo(vk::CommandPoolCreateFlagBits::eTransient, queueFamilyIndices.graphicsFamily.value());
    commandPoolBuffer = context->device.createCommandPool(commandPoolInfo);
}