#include <ImagesVk.h>

Public Member Functions
	ImagesVk (VkCommandPool cmdPool)

	ImagesVk ()

	~ImagesVk ()

void	dealloc ()

template<class T >
bool	getImage (T &iach, MIVSIvk &_)

template<class T >
MIVSIvk &	createFromRaw (ImmidiateCmd< T > &cmder, std::string Name, void *src, uint32_t w, uint32_t h, VkImageLayout dstlayout=VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL)

bool	create2D (MIVSIvk &_, VkFormat format, VkImageUsageFlags flag=VK_IMAGE_USAGE_TRANSFER_DST_BIT\|VK_IMAGE_USAGE_TRANSFER_SRC_BIT\|VK_IMAGE_USAGE_SAMPLED_BIT, VkMemoryPropertyFlags properties=VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)

bool	createCubeMap (MIVSIvk &_, VkFormat format)

bool	create2DArray (MIVSIvk &_, VkFormat format)

template<class Mem >
bool	create2DStorageArray (Mem &_, VkFormat format)

template<class T >
bool	createCubeMapFromKtx (ImmidiateCmd< T > &cmder, Iache &iach)

template<class T >
bool	createFromKtx (ImmidiateCmd< T > &cmder, std::string key, Iache &iach)

template<class T >
bool	createFromFile (ImmidiateCmd< T > &cmder, std::string key, Iache &iach)

template<class T >
bool	createFromFiles (ImmidiateCmd< T > &cmder, std::vector< std::string > keys, Iache &iach)

template<class T >
bool	createFromFileStorage (ImmidiateCmd< T > &cmder, std::string key, Iache &iach)

VkPipelineShaderStageCreateInfo	loadShader (std::string fileName, VkShaderStageFlagBits stage, PvSvk &p)

template<class T >
bool	Canvas2D (MIVvk &Color, MIVvk &Depth, T *cvs)

template<class T >
bool	$Delete (T *hach)

template<class T >
bool	$DeleteMIVSI (T *hach)

Protected Attributes
VkCommandPool	cmdPool

Detailed Description

Definition at line 652 of file ImagesVk.h.

Constructor & Destructor Documentation

◆ ImagesVk() [1/2]

ImagesVk::ImagesVk ( VkCommandPool cmdPool )

Definition at line 54 of file ImagesVk.cpp.

55 : cmdPool(cmdPool) {};

ImagesVk::cmdPool

VkCommandPool cmdPool

Definition: ImagesVk.h:656

◆ ImagesVk() [2/2]

ImagesVk::ImagesVk ( )

Definition at line 57 of file ImagesVk.cpp.

                   {
    
};

◆ ~ImagesVk()

ImagesVk::~ImagesVk ( )

Definition at line 63 of file ImagesVk.cpp.

63{ dealloc(); }

ImagesVk::dealloc

void dealloc()

Definition: ImagesVk.cpp:65

Member Function Documentation

◆ $Delete()

template<class T >

bool ImagesVk::$Delete ( T * hach )

inline

Definition at line 1186 of file ImagesVk.h.

                           {
        MIVvk  _;
        if (Mem(MIVvk,SIZE_MIV).$get(_, hach)) {
            Mem(MIVvk,SIZE_MIV).$delete$(hach);
            return true;
        }
        return true;
    };

◆ $DeleteMIVSI()

template<class T >

bool ImagesVk::$DeleteMIVSI ( T * hach )

inline

Definition at line 1196 of file ImagesVk.h.

                               {
        MIVSIvk  _;
        if (Mem(MIVSIvk, SIZE_MIVSI).$get(_, hach)) {
            Mem(MIVSIvk, SIZE_MIVSI).$delete$(hach);
            return true;
        }
        return true;
    };

◆ Canvas2D()

template<class T >

bool ImagesVk::Canvas2D	(	MIVvk &	Color,
		MIVvk &	Depth,
		T *	cvs
	)

inline

VK_IMAGE_VIEW_TYPE_2D_ARRAY;

Definition at line 1020 of file ImagesVk.h.

                                                     {
 
        const uint32_t multiviewLayerCount = 1;
 
        {
            bool gen = true;
            
            if (Mem(MIVvk,SIZE_MIV).$get(Color, &cvs->iachCol.hach)) {
                if (cvs->w != Color.w || cvs->h != Color.h) {
                    Mem(MIVvk,SIZE_MIV).$delete$(&cvs->iachCol.hach);
                }
                else  gen = false;
            };
            
            if (gen) {
 
                if (cvs->w == 0 || cvs->h == 0) {
                    log_bad("Create Canvas2D::Size InValid.  %u  %u \n", cvs->w, cvs->h);
                    return false;
                };
 
 
                Color.w = cvs->w;
                Color.h = cvs->h;
                Color.l = 1;
                VkImageCreateInfo imageCI = vka::plysm::imageCreateInfo();
                imageCI.imageType = VK_IMAGE_TYPE_2D;
                imageCI.format = $format.COLORFORMAT;
                imageCI.extent = { Color.w,Color.h, 1 };
                imageCI.mipLevels = 1;
                imageCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
                imageCI.arrayLayers = multiviewLayerCount;
                imageCI.samples = VK_SAMPLE_COUNT_1_BIT; // (VkSampleCountFlagBits)MSAASampleCount; ///VK_SAMPLE_COUNT_1_BIT;
                imageCI.tiling = VK_IMAGE_TILING_OPTIMAL;
                imageCI.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
                imageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;  //
                VK_CHECK_RESULT(vkCreateImage($device, &imageCI, nullptr, &Color.image));
                Color.Info.imageLayout = imageCI.initialLayout;
 
 
 
                VkMemoryRequirements memReqs;
 
                vkGetImageMemoryRequirements($device, Color.image, &memReqs);
                Color.size = memReqs.size;
 
                VkMemoryAllocateInfo memoryAllocInfo = vka::plysm::memoryAllocateInfo();
                memoryAllocInfo.allocationSize = memReqs.size;
                memoryAllocInfo.memoryTypeIndex = vka::shelve::getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
                VK_CHECK_RESULT(vkAllocateMemory($device, &memoryAllocInfo, nullptr, &Color.memory));
                VK_CHECK_RESULT(vkBindImageMemory($device, Color.image, Color.memory, 0));
 
 
 
                VkImageViewCreateInfo imageViewCI = vka::plysm::imageViewCreateInfo();
                imageViewCI.viewType = VK_IMAGE_VIEW_TYPE_2D;
                imageViewCI.format = $format.COLORFORMAT;
                imageViewCI.flags = 0;
                imageViewCI.components.r = VK_COMPONENT_SWIZZLE_R;
                imageViewCI.components.g = VK_COMPONENT_SWIZZLE_G;
                imageViewCI.components.b = VK_COMPONENT_SWIZZLE_B;
                imageViewCI.components.a = VK_COMPONENT_SWIZZLE_A;
                imageViewCI.subresourceRange = {};
                imageViewCI.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                imageViewCI.subresourceRange.baseMipLevel = 0;
                imageViewCI.subresourceRange.levelCount = 1;
                imageViewCI.subresourceRange.baseArrayLayer = 0;
                imageViewCI.subresourceRange.layerCount = multiviewLayerCount;
                imageViewCI.image = Color.image;
                VK_CHECK_RESULT(vkCreateImageView($device, &imageViewCI, nullptr, &Color.view));
 
 
                
                Mem(MIVvk,SIZE_MIV).$set$(std::move(Color), &cvs->iachCol.hach);
 
                log_img("Create Canvas2D:: %u  %u     %x    %x \n", cvs->w, cvs->h, Color.image, cvs->iachCol.hach.hash);
 
                cvs->iachCol.refCnt++; 
                cvs->iachCol.vkI = Color.view;
 
            }
            
            
            log_img("get Canvas2D:: %u  %u     %x    %x \n", cvs->w, cvs->h, Color.image, cvs->iachCol.hach.hash);
        }
 
        {
            bool gen = true;
            if (Mem(MIVvk,SIZE_MIV).$get(Depth, &cvs->iachDep.hach)) {
                if (cvs->w != Depth.w || cvs->h != Depth.h) {
                    Mem(MIVvk,SIZE_MIV).$delete$(&cvs->iachDep.hach);
                }
                else {
                    gen = false;
                }
            }
            
            if (gen) {
 
                if (cvs->w == 0 || cvs->h == 0) {
                    log_bad("Create Canvas2D::Size InValid.  %u  %u \n", cvs->w, cvs->h);
                    return  false;
                };
 
 
                Depth.w = cvs->w;
                Depth.h = cvs->h;
                Depth.l  = 1;
                VkImageCreateInfo imageCI = vka::plysm::imageCreateInfo();
                imageCI.imageType = VK_IMAGE_TYPE_2D;
                imageCI.format = $format.DEPTHFORMAT;
                imageCI.extent = { Depth.w, Depth.h, 1 };
                imageCI.mipLevels = 1;
                imageCI.arrayLayers = multiviewLayerCount;
                imageCI.samples = VK_SAMPLE_COUNT_1_BIT;
                imageCI.tiling = VK_IMAGE_TILING_OPTIMAL;
                imageCI.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
                imageCI.flags = 0;
                VK_CHECK_RESULT(vkCreateImage($device, &imageCI, nullptr, &Depth.image));
 
                VkMemoryRequirements memReqs;
                vkGetImageMemoryRequirements($device, Depth.image, &memReqs);
                Depth.size = memReqs.size;
 
                VkMemoryAllocateInfo memAllocInfo{};
                memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
                memAllocInfo.allocationSize = 0;
                memAllocInfo.memoryTypeIndex = 0;
 
                VkImageViewCreateInfo depthStencilView = {};
                depthStencilView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
                depthStencilView.pNext = NULL;
                depthStencilView.viewType = VK_IMAGE_VIEW_TYPE_2D;
                depthStencilView.format = $format.DEPTHFORMAT;
                depthStencilView.flags = 0;
                depthStencilView.subresourceRange = {};
                depthStencilView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
                depthStencilView.subresourceRange.baseMipLevel = 0;
                depthStencilView.subresourceRange.levelCount = 1;
                depthStencilView.subresourceRange.baseArrayLayer = 0;
                depthStencilView.subresourceRange.layerCount = multiviewLayerCount;
                depthStencilView.image = Depth.image;
 
                memAllocInfo.allocationSize = memReqs.size;
                memAllocInfo.memoryTypeIndex = vka::shelve::getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
                VK_CHECK_RESULT(vkAllocateMemory($device, &memAllocInfo, nullptr, &Depth.memory));
                VK_CHECK_RESULT(vkBindImageMemory($device, Depth.image, Depth.memory, 0));
                VK_CHECK_RESULT(vkCreateImageView($device, &depthStencilView, nullptr, &Depth.view));
 
 
                Mem(MIVvk,SIZE_MIV).$set$(std::move(Depth), &cvs->iachDep.hach);
                
                cvs->iachDep.refCnt++;
                cvs->iachDep.vkI = Depth.view;
 
            }
            
            
        }
 
        return true;
 
    };

◆ create2D()

bool ImagesVk::create2D	(	MIVSIvk &	_,
		VkFormat	format,
		VkImageUsageFlags	flag = `VK_IMAGE_USAGE_TRANSFER_DST_BIT \| VK_IMAGE_USAGE_TRANSFER_SRC_BIT \| VK_IMAGE_USAGE_SAMPLED_BIT`,
		VkMemoryPropertyFlags	properties = `VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT`
	)

VK_FORMAT_R8_UNORM;

Definition at line 74 of file ImagesVk.cpp.

{
 
    VkImageCreateInfo imageInfo{};
    imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
    imageInfo.imageType = VK_IMAGE_TYPE_2D;
    imageInfo.format = format;
    imageInfo.extent.width = _.w;
    imageInfo.extent.height = _.h;
    imageInfo.extent.depth = 1;
    imageInfo.mipLevels      = 1;
    imageInfo.arrayLayers = _.l;
    imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
 
    if (properties == 0x1) imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
    else imageInfo.tiling = VK_IMAGE_TILING_LINEAR;
 
    imageInfo.usage = flag;
    imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
    imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
    VK_CHECK_RESULT(vkCreateImage($device, &imageInfo, nullptr, &_.image));
 
    vkGetImageMemoryRequirements($device, _.image, &_.memReqs);
 
    VkMemoryAllocateInfo allocInfo = vka::plysm::memoryAllocateInfo();
    allocInfo.allocationSize = _.memReqs.size;
    allocInfo.memoryTypeIndex = vka::shelve::getMemoryType(_.memReqs.memoryTypeBits, properties,nullptr);
 
    VK_CHECK_RESULT(vkAllocateMemory($device, &allocInfo, nullptr, &_.memory));
    VK_CHECK_RESULT(vkBindImageMemory($device, _.image, _.memory, 0));
 
    log_img("create2D  format  %u   w  %u  h %u   size %zu   \n", (UINT32)imageInfo.format, _.w, _.h, _.memReqs.size);
    
    _.Info = {};
    _.Info.imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
    if (properties == 0x1) {
 
 
        VkImageViewCreateInfo imageViewInfo = vka::plysm::imageViewCreateInfo();
        imageViewInfo.image = _.image;
        imageViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
        imageViewInfo.format = imageInfo.format;
        imageViewInfo.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B,    VK_COMPONENT_SWIZZLE_A };
        imageViewInfo.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
        VK_CHECK_RESULT(vkCreateImageView($device, &imageViewInfo, nullptr, &_.view));
 
 
        VkSamplerCreateInfo samplerInfo = vka::plysm::samplerCreateInfo();
        samplerInfo.magFilter = VK_FILTER_LINEAR;
        samplerInfo.minFilter = VK_FILTER_LINEAR;
        samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
        samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
        samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
        samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
        samplerInfo.mipLodBias = 0.0f;
        samplerInfo.compareOp = VK_COMPARE_OP_NEVER;
        samplerInfo.minLod = 0.0f;
        samplerInfo.maxLod = 1.0f;
        samplerInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
        VK_CHECK_RESULT(vkCreateSampler($device, &samplerInfo, nullptr, &_.sampler));
 
 
 
        _.Info.sampler = _.sampler;
        _.Info.imageView = _.view;
 
    }
 
    return true;
};

◆ create2DArray()

bool ImagesVk::create2DArray	(	MIVSIvk &	_,
		VkFormat	format
	)

Definition at line 147 of file ImagesVk.cpp.

                                                        {
    // Create optimal tiled target image
    VkImageCreateInfo imageCreateInfo = vka::plysm::imageCreateInfo();
    imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
    imageCreateInfo.format = format;
    imageCreateInfo.mipLevels = 1;
    imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
    imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
    imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
    imageCreateInfo.initialLayout =  VK_IMAGE_LAYOUT_UNDEFINED;
    imageCreateInfo.extent = { _.w,_.h, 1 };
    imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
    imageCreateInfo.arrayLayers = _.l;
 
    VK_CHECK_RESULT(vkCreateImage($device, &imageCreateInfo, nullptr, &_.image));
 
    vkGetImageMemoryRequirements($device, _.image, &_.memReqs);
 
    VkMemoryAllocateInfo allocInfo = vka::plysm::memoryAllocateInfo();
    allocInfo.allocationSize = _.memReqs.size;
    allocInfo.memoryTypeIndex = vka::shelve::getMemoryType(_.memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, nullptr);
    log_img("Bridge Test ==>>   NUMS == 0  generate memory    Size %zu   TypeBits  %u     TypeIndex  %u \n", _.memReqs.size, (uint32_t)_.memReqs.memoryTypeBits, allocInfo.memoryTypeIndex);
 
    VK_CHECK_RESULT(vkAllocateMemory($device, &allocInfo, nullptr, &_.memory));
    VK_CHECK_RESULT(vkBindImageMemory($device, _.image, _.memory, 0));
 
 
    VkSamplerCreateInfo sampler = vka::plysm::samplerCreateInfo();
    sampler.magFilter = VK_FILTER_LINEAR;
    sampler.minFilter = VK_FILTER_LINEAR;
    sampler.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
    sampler.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;// VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
    sampler.addressModeV = sampler.addressModeU;
    sampler.addressModeW = sampler.addressModeU;
    sampler.mipLodBias = 0.0f;
    sampler.maxAnisotropy = 8;
    sampler.compareOp = VK_COMPARE_OP_NEVER;
    sampler.minLod = 0.0f;
    sampler.maxLod = 0.0f;
    sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
    VK_CHECK_RESULT(vkCreateSampler($device, &sampler, nullptr, &_.sampler));
 
 
    VkImageViewCreateInfo view = vka::plysm::imageViewCreateInfo();
    view.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
    view.format = format;
    view.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
    view.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
    view.subresourceRange.layerCount = _.l;
    view.subresourceRange.levelCount = 1;
    view.image = _.image;
    VK_CHECK_RESULT(vkCreateImageView($device, &view, nullptr, &_.view));
    _.Info = {};
    _.Info.sampler = _.sampler;
    _.Info.imageView = _.view;
    _.Info.imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    return true;
 
};

◆ create2DStorageArray()

template<class Mem >

bool ImagesVk::create2DStorageArray	(	Mem &	_,
		VkFormat	format
	)

inline

Definition at line 709 of file ImagesVk.h.

                                                       {
       
 
        VkImageCreateInfo imageCreateInfo = vka::plysm::imageCreateInfo();
        imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
        imageCreateInfo.format = format;
        imageCreateInfo.mipLevels = 1;
        imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
        imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
        imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
        imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        imageCreateInfo.extent = { _.w,_.h, 1 };
        imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT;
        imageCreateInfo.arrayLayers = _.l;
 
        VK_CHECK_RESULT(vkCreateImage($device, &imageCreateInfo, nullptr, &_.image));
 
        vkGetImageMemoryRequirements($device, _.image, &_.memReqs);
 
        VkMemoryAllocateInfo allocInfo = vka::plysm::memoryAllocateInfo();
        allocInfo.allocationSize = _.memReqs.size;
        allocInfo.memoryTypeIndex = vka::shelve::getMemoryType(_.memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, nullptr);
        log_img("Bridge Test ==>>   NUMS == 0  generate memory    Size %zu   TypeBits  %u     TypeIndex  %u \n", _.memReqs.size, (uint32_t)_.memReqs.memoryTypeBits, allocInfo.memoryTypeIndex);
 
        VK_CHECK_RESULT(vkAllocateMemory($device, &allocInfo, nullptr, &_.memory));
        VK_CHECK_RESULT(vkBindImageMemory($device, _.image, _.memory, 0));
 
 
 
 
        VkSamplerCreateInfo sampler = vka::plysm::samplerCreateInfo();
        sampler.magFilter = VK_FILTER_LINEAR;
        sampler.minFilter = VK_FILTER_LINEAR;
        sampler.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
        sampler.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
        sampler.addressModeV = sampler.addressModeU;
        sampler.addressModeW = sampler.addressModeU;
        sampler.mipLodBias = 0.0f;
        sampler.maxAnisotropy = 8;
        sampler.compareOp = VK_COMPARE_OP_NEVER;
        sampler.minLod = 0.0f;
        sampler.maxLod = 0.0f;
        sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
        VK_CHECK_RESULT(vkCreateSampler($device, &sampler, nullptr, &_.sampler));
 
 
        VkImageViewCreateInfo view = vka::plysm::imageViewCreateInfo();
        view.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
        view.format = format;
        view.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
        view.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
        view.subresourceRange.layerCount = _.l;
        view.subresourceRange.levelCount = 1;
        view.image = _.image;
        VK_CHECK_RESULT(vkCreateImageView($device, &view, nullptr, &_.view));
 
        return true;
    };

◆ createCubeMap()

bool ImagesVk::createCubeMap	(	MIVSIvk &	_,
		VkFormat	format
	)

VK_FORMAT_R8_UNORM;

Definition at line 207 of file ImagesVk.cpp.

                                                        {
 
    VkImageCreateInfo imageInfo{};
    imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
    imageInfo.imageType = VK_IMAGE_TYPE_2D;
    imageInfo.format = format;
    imageInfo.extent.width = _.w;
    imageInfo.extent.height = _.h;
    imageInfo.extent.depth = 1;
    imageInfo.mipLevels = _.mipLevel;
    imageInfo.arrayLayers = _.l;
    imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
    imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
    imageInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
    imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
    imageInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
 
    VK_CHECK_RESULT(vkCreateImage($device, &imageInfo, nullptr, &_.image));
 
    vkGetImageMemoryRequirements($device, _.image, &_.memReqs);
 
 
    VkMemoryAllocateInfo allocInfo = vka::plysm::memoryAllocateInfo();
    allocInfo.allocationSize        = _.memReqs.size;
    allocInfo.memoryTypeIndex = vka::shelve::getMemoryType(_.memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, nullptr);
 
    VK_CHECK_RESULT(vkAllocateMemory($device, &allocInfo, nullptr, &_.memory));
    VK_CHECK_RESULT(vkBindImageMemory($device, _.image, _.memory, 0));
 
    log_img("createCubemap  format  %u   w  %u  h %u   size %zu   \n", (UINT32)imageInfo.format, _.w, _.h, _.memReqs.size);
 
    VkSamplerCreateInfo sampler = vka::plysm::samplerCreateInfo();
    sampler.magFilter = VK_FILTER_LINEAR;
    sampler.minFilter = VK_FILTER_LINEAR;
    sampler.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
    sampler.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
    sampler.addressModeV = sampler.addressModeU;
    sampler.addressModeW = sampler.addressModeU;
    sampler.mipLodBias = 0.0f;
    sampler.compareOp = VK_COMPARE_OP_NEVER;
    sampler.minLod = 0.0f;
    sampler.maxLod =float( _.mipLevel);
    sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
    sampler.maxAnisotropy = 1.0f;
 
    if ($features.samplerAnisotropy)
    {
        sampler.maxAnisotropy = $properties.limits.maxSamplerAnisotropy;
        sampler.anisotropyEnable = VK_TRUE;
    }
    VK_CHECK_RESULT(vkCreateSampler($device, &sampler, nullptr, &_.sampler));
 
 
 
    VkImageViewCreateInfo imageViewInfo = vka::plysm::imageViewCreateInfo();
    imageViewInfo.image = _.image;
    imageViewInfo.viewType = VK_IMAGE_VIEW_TYPE_CUBE;
    imageViewInfo.format = imageInfo.format;
    imageViewInfo.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B,    VK_COMPONENT_SWIZZLE_A };
    imageViewInfo.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
    imageViewInfo.subresourceRange.layerCount = _.l;
    // Set number of mip levels
    imageViewInfo.subresourceRange.levelCount = _.mipLevel;
    VK_CHECK_RESULT(vkCreateImageView($device, &imageViewInfo, nullptr, &_.view));
 
 
    _.Info = {};
    _.Info.sampler = _.sampler;
    _.Info.imageView = _.view;
    _.Info.imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
    return true;
};

◆ createCubeMapFromKtx()

template<class T >

bool ImagesVk::createCubeMapFromKtx	(	ImmidiateCmd< T > &	cmder,
		Iache &	iach
	)

inline

Definition at line 769 of file ImagesVk.h.

    {
        MIVSIvk  miv;
 
        if (!(Mem(MIVSIvk, SIZE_MIVSI).$get(miv, &iach.hach))) {
            ktxResult result;
            ktxTexture* ktxTexture;
 
            iach.name  = IMAGE_PATH + iach.name;
            if (!vka::shelve::fileExists(iach.name)) {
                log_bad("Could not load texture from  %s \n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", iach.name.c_str());
            }
 
            result = ktxTexture_CreateFromNamedFile(iach.name.c_str(), KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT, &ktxTexture);
 
            assert(result == KTX_SUCCESS);
 
            // Get properties required for using and upload texture data from the ktx texture object
            miv.w = ktxTexture->baseWidth;
            miv.h = ktxTexture->baseHeight;
            //ktxTexture->numLevels = 1;
            miv.l = 6;
            miv.mipLevel = ktxTexture->numLevels;
            ktx_uint8_t* ktxTextureData = ktxTexture_GetData(ktxTexture);
            ktx_size_t ktxTextureSize = ktxTexture_GetSize(ktxTexture);
 
            miv.size = ktxTextureSize;
            createCubeMap(miv, iach.format);
 
 
            std::vector<VkBufferImageCopy> bufferCopyRegions;
    
 
            for (uint32_t face = 0; face < 6; face++)
            {
                for (uint32_t level = 0; level < miv.mipLevel; level++)
                {
 
                    ktx_size_t offset;
                    KTX_error_code ret = ktxTexture_GetImageOffset(ktxTexture, level, 0, face, &offset);
                    assert(ret == KTX_SUCCESS);
                    VkBufferImageCopy bufferCopyRegion = {};
                    bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                    bufferCopyRegion.imageSubresource.mipLevel = level;
                    bufferCopyRegion.imageSubresource.baseArrayLayer = face;
                    bufferCopyRegion.imageSubresource.layerCount = 1;
                    bufferCopyRegion.imageExtent.width = ktxTexture->baseWidth >> level;
                    bufferCopyRegion.imageExtent.height = ktxTexture->baseHeight >> level;
                    bufferCopyRegion.imageExtent.depth = 1;
                    bufferCopyRegion.bufferOffset = offset;
                    bufferCopyRegions.push_back(bufferCopyRegion);
                }
            }
 
            miv.Info.imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
            cmder.bridgeMap(miv, ktxTextureData, bufferCopyRegions, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
            
            miv.Info.sampler     = miv.sampler;
            miv.Info.imageView = miv.view;
 
            Mem(MIVSIvk, SIZE_MIVSI).$set$(std::move(miv), &iach.hach);
            iach.refCnt++;
 
            ktxTexture_Destroy(ktxTexture);
        }
        return true;
    }

◆ createFromFile()

template<class T >

bool ImagesVk::createFromFile	(	ImmidiateCmd< T > &	cmder,
		std::string	key,
		Iache &	iach
	)

inline

create2D(_, VK_FORMAT_R32G32B32A32_SFLOAT); cmder.bridgeMap(_, (char*)loader.images->packed, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

Definition at line 896 of file ImagesVk.h.

                                                                            {
 
        MIVSIvk   _;
 
        if (!(Mem(MIVSIvk,SIZE_MIVSI).$get(_, &iach.hach))) {
 
            std::string name = IMAGE_PATH + key;
            log_once("Image Loading...... %s    \n", (name).c_str());
 
            ktx::loadmap loader;
 
            if (ktx::Flags::Error == loader.load(name.c_str())) {
                log_bad("stb Load %s    \n", (name).c_str());
            };
 
            _.w = loader.images->w;
            _.h = loader.images->h;
            _.c = 4;
            _.l = 1;
            _.size = _.w * _.h * _.c * _.l;
 
            create2D(_, iach.format);
            cmder.bridgeMap(_, (char*)loader.images->packed, iach.layout);
 
            Mem(MIVSIvk,SIZE_MIVSI).$set$(std::move(_), &iach.hach);
            iach.refCnt++;
            return true;
        }
 
        return true;
 
    };

◆ createFromFiles()

template<class T >

bool ImagesVk::createFromFiles	(	ImmidiateCmd< T > &	cmder,
		std::vector< std::string >	keys,
		Iache &	iach
	)

inline

VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

Definition at line 932 of file ImagesVk.h.

                                                                                         {
 
        MIVSIvk   _;
 
        if (!(Mem(MIVSIvk, SIZE_MIVSI).$get(_, &iach.hach))) {
 
            int l = 0;;
 
            _.l  =  keys.size();
            for (std::string key : keys) {
 
                std::string name = IMAGE_PATH + key;
                log_once("Image Loading...... %s    \n", (name).c_str());
 
                ktx::loadmap loader;
 
                if (ktx::Flags::Error == loader.load(name.c_str())) {
                    log_bad("stb Load %s    \n", (name).c_str());
                };
                if (l ==0) {
                    _.w = loader.images->w;
                    _.h = loader.images->h;
                    _.c = 4;
                    _.size = _.w * _.h * _.c;
                    create2DArray(_, iach.format);
                }
 
                _.Info.imageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
                cmder.bridgeMap(_, (char*)loader.images->packed,l, iach.layout);
                l++;
            }
 
            _.size *= _.l ;
            Mem(MIVSIvk, SIZE_MIVSI).$set$(std::move(_), &iach.hach);
            iach.refCnt++;
            return true;
        }
 
        return true;
 
    };

◆ createFromFileStorage()

template<class T >

bool ImagesVk::createFromFileStorage	(	ImmidiateCmd< T > &	cmder,
		std::string	key,
		Iache &	iach
	)

inline

VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

Definition at line 975 of file ImagesVk.h.

                                                                                   {
 
        MIVSIvk   _;
 
        if (!(Mem(MIVSIvk,SIZE_MIVSI).$get(_, &iach.hach))) {
 
            std::string name = IMAGE_PATH + key;
            log_once("Image Loading...... %s    \n", (name).c_str());
 
            ktx::loadmap loader;
 
            if (ktx::Flags::Error == loader.load(name.c_str())) {
                log_bad("stb Load %s    \n", (name).c_str());
            };
 
            _.w = loader.images->w;
            _.h = loader.images->h;
            _.c = 4;
            _.l =  2;
            _.size = _.w * _.h * _.c * _.l;
 
            create2DStorageArray(_, iach.format);
 
            if (iach.format == VK_FORMAT_R32G32B32A32_SFLOAT) {
                _.size = _.w * _.h * _.c * 4;
            }
            else {
                _.size = _.w * _.h * _.c;
            };
            
 
            cmder.bridgeMap(_, (char*)loader.images->packed, iach.layout);
            
            Mem(MIVSIvk,SIZE_MIVSI).$set$(std::move(_), &iach.hach);
            iach.refCnt++;
            return true;
        }
 
        return true;
 
    };

◆ createFromKtx()

template<class T >

bool ImagesVk::createFromKtx	(	ImmidiateCmd< T > &	cmder,
		std::string	key,
		Iache &	iach
	)

inline

ktx_size_t ktxTextureSize = ktxTexture_GetSize(ktxTexture);

cache[filename] = _;

Definition at line 838 of file ImagesVk.h.

    {
 
 
        MIVSIvk  miv;
 
        if (!(Mem(MIVSIvk,SIZE_MIVSI).$get(miv, &iach.hach))) {
 
            std::string  filename = IMAGE_PATH + key;
 
            ktxResult              result;
            ktxTexture* ktxTexture;
 
            if (!vka::shelve::fileExists(filename)) {
                log_bad("Could not load texture from  %s \n\nThe file may be part of the additional asset pack.\n\nRun \"download_assets.py\" in the repository root to download the latest version.", filename.c_str());
            }
            result = ktxTexture_CreateFromNamedFile(filename.c_str(), KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT, &ktxTexture);
 
            assert(result == KTX_SUCCESS);
 
            // Get properties required for using and upload texture data from the ktx texture object
            miv.w = ktxTexture->baseWidth;
            miv.h = ktxTexture->baseHeight;
            miv.l = ktxTexture->numLayers;
            miv.size = ktxTexture_GetSize(ktxTexture);
        //  ktx_uint8_t* ktxTextureData = ktxTexture_GetData(ktxTexture);
            if (miv.l == 1) {
                create2D(miv, iach.format);
            }
            else {
                create2DArray(miv, iach.format);
            }
 
            cmder.bridgeMapArray(miv, ktxTexture, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 
            ktxTexture_Destroy(ktxTexture);
 
 
 
            miv.Info = {};
            miv.Info.sampler = miv.sampler;
            miv.Info.imageView = miv.view;
            miv.Info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
            Mem(MIVSIvk,SIZE_MIVSI).$set$(std::move(miv), &iach.hach);
            iach.refCnt++;
 
            log_img("ImagesVk Create KTX   TexArray   %x    %s    \n",miv.view,filename.c_str());
 
            return true;
        };
 
        return true;
    };

◆ createFromRaw()

template<class T >

MIVSIvk & ImagesVk::createFromRaw	(	ImmidiateCmd< T > &	cmder,
		std::string	Name,
		void *	src,
		uint32_t	w,
		uint32_t	h,
		VkImageLayout	dstlayout = `VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL`
	)

inline

Definition at line 676 of file ImagesVk.h.

    {
        MIVSIvk  _;
        /*
        if (cache.count(Name) > 0)return cache[Name];
 
        MIVSIvk& _ = cache[Name];
 
        _.w = w;
        _.h = h;
        _.c = 4;
        _.l = 1;
        _.size = _.w * _.h * _.c * _.l;
 
        create2D(_, VK_FORMAT_R8G8B8A8_UNORM);
        //reate2D(_, VK_FORMAT_R8G8B8_SNORM);
        //create2D(_, VK_FORMAT_R8G8B8_UNORM);
        cmder.bridgeMap(_, src, dstlayout);
        */
 
        return _;
 
    };

◆ dealloc()

void ImagesVk::dealloc ( )

Definition at line 65 of file ImagesVk.cpp.

                       {
 
};

◆ getImage()

template<class T >

bool ImagesVk::getImage	(	T &	iach,
		MIVSIvk &	_
	)

inline

Definition at line 667 of file ImagesVk.h.

                                      {
        if (Mem(MIVSIvk,SIZE_MIVSI).$get(_, &iach.hach)) {
            return true;
        };
        return false;
    };

◆ loadShader()

VkPipelineShaderStageCreateInfo ImagesVk::loadShader	(	std::string	fileName,
		VkShaderStageFlagBits	stage,
		PvSvk &	p
	)

Definition at line 282 of file ImagesVk.cpp.

{
    VkPipelineShaderStageCreateInfo shaderStage = {};
    shaderStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    shaderStage.stage = stage;
 
    shaderStage.module = vka::shelve::loadShader(fileName.c_str(), $device);
    shaderStage.pName = "main"; // todo : make param
    p.shaderModules.push_back(shaderStage.module);
    assert(shaderStage.module != VK_NULL_HANDLE);
    return shaderStage;
};

Member Data Documentation

◆ cmdPool

VkCommandPool ImagesVk::cmdPool

protected

Definition at line 656 of file ImagesVk.h.

The documentation for this struct was generated from the following files:

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ImagesVk() [1/2]

◆ ImagesVk() [2/2]

◆ ~ImagesVk()

Member Function Documentation

◆ $Delete()

◆ $DeleteMIVSI()

◆ Canvas2D()

◆ create2D()

◆ create2DArray()

◆ create2DStorageArray()

◆ createCubeMap()

◆ createCubeMapFromKtx()

◆ createFromFile()

◆ createFromFiles()

◆ createFromFileStorage()

◆ createFromKtx()

◆ createFromRaw()

◆ dealloc()

◆ getImage()

◆ loadShader()

Member Data Documentation

◆ cmdPool