Method LoadAndUpload

src/VK/base/Texture.cpp:392–478

    }

    void Texture::LoadAndUpload(Device *pDevice, UploadHeap *pUploadHeap, ImgLoader *pDds, VkImage pTexture2D)
    {
        // Upload Image
        {
            VkImageMemoryBarrier copy_barrier = {};
            copy_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
            copy_barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
            copy_barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
            copy_barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
            copy_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            copy_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            copy_barrier.image = pTexture2D;
            copy_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            copy_barrier.subresourceRange.baseMipLevel = 0;
            copy_barrier.subresourceRange.levelCount = m_header.mipMapCount;
            copy_barrier.subresourceRange.layerCount = m_header.arraySize;
            pUploadHeap->AddPreBarrier(copy_barrier);
        }

        //compute pixel size
        //
        UINT32 bytesPerPixel = (UINT32)GetPixelByteSize((DXGI_FORMAT)m_header.format); // note that bytesPerPixel in BC formats is treated as bytesPerBlock 
        UINT32 pixelsPerBlock = 1;
        if (IsBCFormat(m_header.format))
        {
            pixelsPerBlock = 4*4; // BC formats have 4*4 pixels per block
        }

        for (uint32_t a = 0; a < m_header.arraySize; a++)
        {
            // copy all the mip slices into the offsets specified by the footprint structure
            //
            for (uint32_t mip = 0; mip < m_header.mipMapCount; mip++)
            {
                uint32_t dwWidth = std::max<uint32_t>(m_header.width >> mip, 1);
                uint32_t dwHeight = std::max<uint32_t>(m_header.height >> mip, 1);

                UINT64 UplHeapSize = (dwWidth * dwHeight * bytesPerPixel) / pixelsPerBlock;
                UINT8 *pixels = pUploadHeap->BeginSuballocate(SIZE_T(UplHeapSize), 512);

                if (pixels == NULL)
                {
                    // oh! We ran out of mem in the upload heap, flush it and try allocating mem from it again
                    pUploadHeap->FlushAndFinish(true);
                    pixels = pUploadHeap->Suballocate(SIZE_T(UplHeapSize), 512);
                    assert(pixels != NULL);
                }

                uint32_t offset = uint32_t(pixels - pUploadHeap->BasePtr());

                pDds->CopyPixels(pixels, (dwWidth * bytesPerPixel) / pixelsPerBlock, (dwWidth * bytesPerPixel) / pixelsPerBlock, dwHeight);

                pUploadHeap->EndSuballocate();

                {
                    VkBufferImageCopy region = {};
                    region.bufferOffset = offset;
                    region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;