hyzboy/ULRE
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

新的纹理创建

Browse Source
This commit is contained in:
hyzboy 2019-11-25 22:05:05 +08:00
parent 14e4d493dc
commit 5846913197
19 changed files with 431 additions and 363 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
3rdpty/SPIRV-Cross

@ -1 +1 @@
Subproject commit 4ce04480ec5469fe7ebbdd66c3016090a704d81b
Subproject commit fd5aa3ad51ece55a1b51fe6bfb271db6844ae291

2
3rdpty/assimp

@ -1 +1 @@
Subproject commit 23e1c0cbc9915d5e1aa9bea683c06ca4e67e4f09
Subproject commit 16397c1849c2b180bc7fe1e5ef103ba03a8990d5

2
CMCMakeModule

@ -1 +1 @@
Subproject commit 56a75a8c50661512be1cdf319a2cfabdae7ce2d0
Subproject commit 884d6883c1f58e7224f1ab14b153f3633cacd495

3
example/Vulkan/CMakeLists.txt
View File

@ -11,7 +11,8 @@ endmacro()
CreateProject(00.triangle first_triangle.cpp)
CreateProject(01.indices_rect indices_rect.cpp)
CreateProject(02.texture_rect texture_rect.cpp TGATexture.cpp)
CreateProject(02.1.texture_rect texture_rect.cpp TGATexture.cpp)
CreateProject(02.2.texture_linear texture_linear.cpp TGATexture.cpp)
CreateProject(03.HQFilterTexture HQFilterTexture.cpp TGATexture.cpp)
CreateProject(04.Geometry2D Geometry2D.cpp)
CreateProject(05.Geometry3D Geometry3D.cpp)

73
example/Vulkan/Deferred.cpp
View File

@ -37,13 +37,8 @@ constexpr VkFormat normal_candidate_format []={FMT_RGBA32F,
FMT_A2BGR10SN};
constexpr VkFormat depth_candidate_format []={FMT_D32F,FMT_D32F_S8U,FMT_X8_D24UN,FMT_D24UN_S8U,FMT_D16UN,FMT_D16UN_S8U};
class TestApp:public CameraAppFramework
class DeferredRenderingFramework:public CameraAppFramework
{
private:
SceneNode render_root;
RenderList render_list;
struct DeferredGBuffer
{
vulkan::Semaphore *render_complete_semaphore = nullptr;
@ -91,36 +86,19 @@ private:
SubpassParam sp_gbuffer;
SubpassParam sp_composition;
vulkan::Renderable *ro_plane,
*ro_cube,
*ro_sphere,
*ro_torus,
*ro_cylinder,
*ro_cone,
*ro_gbc_plane;
vulkan::Sampler * sampler=nullptr;
struct
{
Texture2DPointer color=nullptr;
Texture2DPointer normal=nullptr;
// Texture2DPointer specular=nullptr;
}texture;
vulkan::CommandBuffer *gbuffer_cmd = nullptr;
public:
~TestApp()
DeferredRenderingFramework()
{
}
~DeferredRenderingFramework()
{
SAFE_CLEAR(gbuffer_cmd);
//SAFE_CLEAR(texture.specular);
SAFE_CLEAR(texture.normal);
SAFE_CLEAR(texture.color);
SAFE_CLEAR(sampler);
}
private:
const VkFormat GetCandidateFormat(const VkFormat *fmt_list, const uint count)
@ -279,6 +257,43 @@ private:
db->Add(sp->pipeline_triangles);
return(true);
}
};//class DeferredRenderingFramework:public CameraAppFramework
class TestApp:public CameraAppFramework
{
private:
SceneNode render_root;
RenderList render_list;
vulkan::Renderable *ro_plane,
*ro_cube,
*ro_sphere,
*ro_torus,
*ro_cylinder,
*ro_cone,
*ro_gbc_plane;
vulkan::Sampler * sampler=nullptr;
struct
{
Texture2DPointer color=nullptr;
Texture2DPointer normal=nullptr;
// Texture2DPointer specular=nullptr;
}texture;
public:
~TestApp()
{
//SAFE_CLEAR(texture.specular);
SAFE_CLEAR(texture.normal);
SAFE_CLEAR(texture.color);
SAFE_CLEAR(sampler);
}
bool InitMaterial()
{

2
example/Vulkan/PBRBasic.cpp
View File

@ -1,4 +1,4 @@
// 10.PBR Basic
// 10.PBR Basic
#include"VulkanAppFramework.h"
#include<hgl/filesystem/FileSystem.h>

15
example/Vulkan/TGATexture.cpp
View File

@ -138,7 +138,7 @@ namespace
}
}//namespace
Texture2D *LoadTGATexture(const OSString &filename,Device *device)
Texture2D *LoadTGATexture(const OSString &filename,Device *device,bool use_optimar)
{
io::OpenFileInputStream fis(filename);
@ -251,16 +251,21 @@ Texture2D *LoadTGATexture(const OSString &filename,Device *device)
buf->Unmap();
}
Texture2D *tex=device->CreateTexture2D(format,buf,header.width,header.height);
Texture2D *tex;
if(use_optimar)
{
device->CreateTexture2D(format,buf,header.width,header.height);
delete buf;
}
else
{
device->CreateTexture2DLinear(format,buf,header.width, header.height);
}
if(tex)
{
LOG_INFO(OS_TEXT("load image file<")+filename+OS_TEXT(">:<")+OSString(header.width)+OS_TEXT("x")+OSString(header.height)+OS_TEXT("> to texture ok"));
//下面代码用于测试修改纹理
//device->ChangeTexture2D(tex,pixel_data,header->width/4,header->height/4,header->width/2,header->height/2,line_size*header->height/4);
}
else
{

1
inc/hgl/graph/vulkan/VK.h
View File

@ -35,6 +35,7 @@ class Sampler;
class Memory;
class Buffer;
struct BufferData;
class VertexBuffer;
class IndexBuffer;

13
inc/hgl/graph/vulkan/VKBuffer.h
View File

@ -4,8 +4,7 @@
#include<hgl/graph/vulkan/VK.h>
#include<hgl/graph/vulkan/VKMemory.h>
VK_NAMESPACE_BEGIN
struct VulkanBuffer
struct BufferData
{
VkBuffer buffer;
Memory * memory=nullptr;
@ -17,7 +16,7 @@ class Buffer
protected:
VkDevice device;
VulkanBuffer buf;
BufferData buf;
private:
@ -25,10 +24,10 @@ private:
friend class VertexBuffer;
friend class IndexBuffer;
Buffer(VkDevice d,const VulkanBuffer &vb)
Buffer(VkDevice d,const BufferData &b)
{
device=d;
buf=vb;
buf=b;
}
public:
@ -57,7 +56,7 @@ private:
friend class Device;
VertexBuffer(VkDevice d,const VulkanBuffer &vb,VkFormat fmt,uint32_t _stride,uint32_t _count):Buffer(d,vb)
VertexBuffer(VkDevice d,const BufferData &vb,VkFormat fmt,uint32_t _stride,uint32_t _count):Buffer(d,vb)
{
format=fmt;
stride=_stride;
@ -87,7 +86,7 @@ private:
friend class Device;
IndexBuffer(VkDevice d,const VulkanBuffer &vb,VkIndexType it,uint32_t _count):Buffer(d,vb)
IndexBuffer(VkDevice d,const BufferData &vb,VkIndexType it,uint32_t _count):Buffer(d,vb)
{
index_type=it;
count=_count;

39
inc/hgl/graph/vulkan/VKDevice.h
View File

@ -61,7 +61,11 @@ public:
public: //内存相关
Memory *Device::CreateMemory(const VkMemoryRequirements &,uint32_t properties);
Memory *CreateMemory(const VkMemoryRequirements &,const uint32_t properties);
private: //Buffer相关
bool CreateBuffer(BufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,VkSharingMode sharing_mode);
public: //Buffer相关
@ -89,24 +93,36 @@ public: //Buffer相关
#undef CREATE_BUFFER_OBJECT
public: //material相关
public: //Image
Texture2D *CreateTexture2D(const VkFormat video_format,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout);
VkImage CreateImage(const VkFormat format,uint32_t width,uint32_t height,const uint usage,const VkImageTiling tiling);
void DestoryImage(VkImage);
Texture2D *CreateTexture2DColor(const VkFormat video_format,uint32_t width,uint32_t height)
Memory *CreateMemory(VkImage,const uint32 flag=VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
public: //Texture
Texture2D *CreateTexture2D(Memory *mem,VkImage image,ImageView *image_view,VkImageLayout image_layout,bool linear);
Texture2D *CreateTexture2D(VkFormat format,uint32_t width,uint32_t height,VkImageAspectFlagBits aspectMask,VkImage image,VkImageLayout image_layout,bool linear=false);
Texture2D *CreateTexture2D(const VkFormat format,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout,bool linear=false);
Texture2D *CreateTexture2DColor(const VkFormat video_format,uint32_t width,uint32_t height,bool linear=false)
{
return CreateTexture2D(video_format,width,height,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_SAMPLED_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
linear);
}
Texture2D *CreateTexture2DDepth(const VkFormat video_format,uint32_t width,uint32_t height)
Texture2D *CreateTexture2DDepth(const VkFormat video_format,uint32_t width,uint32_t height,bool linear=false)
{
return CreateTexture2D(video_format,width,height,
VK_IMAGE_ASPECT_DEPTH_BIT,
VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_SAMPLED_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
linear);
}
Texture2D *CreateAttachmentTexture(const VkFormat video_format,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout)
@ -133,15 +149,20 @@ public: //material相关
Texture2D *CreateTexture2D( const VkFormat video_format,Buffer *buf,uint32_t width,uint32_t height,
const VkImageAspectFlags aspectMask =VK_IMAGE_ASPECT_COLOR_BIT,
const uint usage =VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_SAMPLED_BIT,
const VkImageLayout image_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
const VkImageLayout image_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
const bool linear =false);
Texture2D *CreateTexture2D( const VkFormat video_format,void *data,uint32_t width,uint32_t height,uint32_t size,
const VkImageAspectFlags aspectMask =VK_IMAGE_ASPECT_COLOR_BIT,
const uint usage =VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_SAMPLED_BIT,
const VkImageLayout image_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
const VkImageLayout image_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
const bool linear =false);
bool ChangeTexture2D(Texture2D *,Buffer *buf,uint32_t left,uint32_t top,uint32_t width,uint32_t height);
bool ChangeTexture2D(Texture2D *,void *data,uint32_t left,uint32_t top,uint32_t width,uint32_t height,uint32_t size);
public: //
Sampler *CreateSampler(VkSamplerCreateInfo *);
ShaderModuleManage *CreateShaderModuleManage();

4
inc/hgl/graph/vulkan/VKMemory.h
View File

@ -13,7 +13,7 @@ class Memory
private:
friend Memory *CreateMemory(VkDevice device,const PhysicalDevice *pd,const VkMemoryRequirements &req,uint32_t properties);
friend class Device;
Memory(VkDevice dev,VkDeviceMemory dm,const VkMemoryRequirements &mr,const uint32 i,const uint32_t p)
{
@ -48,7 +48,5 @@ public:
bool BindBuffer(VkBuffer buffer);
bool BindImage(VkImage image);
};//class Memory
Memory *CreateMemory(VkDevice device,const PhysicalDevice *pd,const VkMemoryRequirements &req,uint32_t properties);
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_MEMORY_INCLUDE

17
inc/hgl/graph/vulkan/VKTexture.h
View File

@ -13,9 +13,6 @@ struct TextureData
ImageView * image_view =nullptr;
uint32 mip_levels =0;
bool linear =false;
VkFormat format =VK_FORMAT_UNDEFINED;
VkImageAspectFlags aspect =0;
VkExtent3D extent;
};//struct TextureData
class Texture
@ -40,9 +37,9 @@ public:
const uint32 GetMipLevels()const{return data?data->mip_levels:0;}
const bool IsLinear ()const{return data?data->linear:false;}
const VkFormat GetFormat ()const{return data?data->format:VK_FORMAT_UNDEFINED;}
const VkImageAspectFlags GetAspect ()const{return data?data->aspect:0;}
const VkExtent3D * GetExtent ()const{return data?&data->extent:nullptr;}
const VkFormat GetFormat ()const{return data?data->image_view->GetFormat():VK_FORMAT_UNDEFINED;}
const VkImageAspectFlags GetAspect ()const{return data?data->image_view->GetAspectFlags():0;}
const VkExtent3D * GetExtent ()const{return data?&data->image_view->GetExtent():nullptr;}
public:
@ -67,15 +64,13 @@ public:
class Texture2D:public Texture
{
uint32_t width,height;
public:
Texture2D(uint32_t w,uint32_t h,VkDevice dev,TextureData *td):width(w),height(h),Texture(dev,td){}
Texture2D(VkDevice dev,TextureData *td):Texture(dev,td){}
~Texture2D()=default;
const uint32_t GetWidth()const{return width;}
const uint32_t GetHeight()const{return height;}
const uint32_t GetWidth()const{return data?data->image_view->GetExtent().width:0;}
const uint32_t GetHeight()const{return data?data->image_view->GetExtent().height:0;}
};//class Texture2D:public Texture
//class Texture2DArray:public Texture

1
src/RenderDevice/Vulkan/CMakeLists.txt
View File

@ -12,6 +12,7 @@ SET(RENDER_DEVICE_VULKAN_SOURCE VKFormat.cpp
VKDeviceCreater.cpp
VKDevice.cpp
VKDeviceBuffer.cpp
VKDeviceImage.cpp
VKDeviceTexture.cpp
VKDeviceRenderPass.cpp
VKBuffer.cpp

42
src/RenderDevice/Vulkan/VKDeviceBuffer.cpp
View File

@ -2,9 +2,7 @@
#include<hgl/graph/vulkan/VKBuffer.h>
VK_NAMESPACE_BEGIN
namespace
{
bool CreateVulkanBuffer(VulkanBuffer &vb,const DeviceAttribute *rsa,VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,VkSharingMode sharing_mode)
bool Device::CreateBuffer(BufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,VkSharingMode sharing_mode)
{
VkBufferCreateInfo buf_info={};
buf_info.sType =VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
@ -16,21 +14,22 @@ namespace
buf_info.sharingMode =sharing_mode;
buf_info.flags =0;
if(vkCreateBuffer(rsa->device,&buf_info,nullptr,&vb.buffer)!=VK_SUCCESS)
if(vkCreateBuffer(attr->device,&buf_info,nullptr,&buf->buffer)!=VK_SUCCESS)
return(false);
VkMemoryRequirements mem_reqs;
vkGetBufferMemoryRequirements(rsa->device,vb.buffer,&mem_reqs);
Memory *dm=CreateMemory(rsa->device,rsa->physical_device,mem_reqs,VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
vkGetBufferMemoryRequirements(attr->device,buf->buffer,&mem_reqs);
if(dm&&dm->BindBuffer(vb.buffer))
Memory *dm=CreateMemory(mem_reqs,VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
if(dm&&dm->BindBuffer(buf->buffer))
{
vb.info.buffer =vb.buffer;
vb.info.offset =0;
vb.info.range =size;
buf->info.buffer =buf->buffer;
buf->info.offset =0;
buf->info.range =size;
vb.memory =dm;
buf->memory =dm;
if(!data)
return(true);
@ -41,10 +40,9 @@ namespace
delete dm;
vkDestroyBuffer(rsa->device,vb.buffer,nullptr);
vkDestroyBuffer(attr->device,buf->buffer,nullptr);
return(false);
}
}//namespace
VertexBuffer *Device::CreateVBO(VkFormat format,uint32_t count,const void *data,VkSharingMode sharing_mode)
{
@ -58,12 +56,12 @@ VertexBuffer *Device::CreateVBO(VkFormat format,uint32_t count,const void *data,
const VkDeviceSize size=stride*count;
VulkanBuffer vb;
BufferData buf;
if(!CreateVulkanBuffer(vb,attr,VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,size,data,sharing_mode))
if(!CreateBuffer(&buf,VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,size,data,sharing_mode))
return(nullptr);
return(new VertexBuffer(attr->device,vb,format,stride,count));
return(new VertexBuffer(attr->device,buf,format,stride,count));
}
IndexBuffer *Device::CreateIBO(VkIndexType index_type,uint32_t count,const void *data,VkSharingMode sharing_mode)
@ -76,21 +74,21 @@ IndexBuffer *Device::CreateIBO(VkIndexType index_type,uint32_t count,const void
const VkDeviceSize size=stride*count;
VulkanBuffer vb;
BufferData buf;
if(!CreateVulkanBuffer(vb,attr,VK_BUFFER_USAGE_INDEX_BUFFER_BIT,size,data,sharing_mode))
if(!CreateBuffer(&buf,VK_BUFFER_USAGE_INDEX_BUFFER_BIT,size,data,sharing_mode))
return(nullptr);
return(new IndexBuffer(attr->device,vb,index_type,count));
return(new IndexBuffer(attr->device,buf,index_type,count));
}
Buffer *Device::CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,VkSharingMode sharing_mode)
{
VulkanBuffer vb;
BufferData buf;
if(!CreateVulkanBuffer(vb,attr,buf_usage,size,data,sharing_mode))
if(!CreateBuffer(&buf,buf_usage,size,data,sharing_mode))
return(nullptr);
return(new Buffer(attr->device,vb));
return(new Buffer(attr->device,buf));
}
VK_NAMESPACE_END

52
src/RenderDevice/Vulkan/VKDeviceImage.cpp Normal file
View File

@ -0,0 +1,52 @@
#include<hgl/graph/vulkan/VKDevice.h>
VK_NAMESPACE_BEGIN
VkImage Device::CreateImage(const VkFormat format,uint32_t width,uint32_t height,const uint usage,const VkImageTiling tiling)
{
if(format<VK_FORMAT_BEGIN_RANGE||format>VK_FORMAT_END_RANGE)return(nullptr);
if(width<1||height<1)return(nullptr);
VkImageCreateInfo imageCreateInfo;
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageCreateInfo.pNext = nullptr;
imageCreateInfo.flags = 0;
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imageCreateInfo.format = format;
imageCreateInfo.extent.width = width;
imageCreateInfo.extent.height = height;
imageCreateInfo.extent.depth = 1;
imageCreateInfo.mipLevels = 1;
imageCreateInfo.arrayLayers = 1;
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageCreateInfo.usage = usage;
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageCreateInfo.queueFamilyIndexCount = 0;
imageCreateInfo.pQueueFamilyIndices = nullptr;
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageCreateInfo.tiling = tiling;
VkImage image;
if(vkCreateImage(attr->device,&imageCreateInfo, nullptr, &image)!=VK_SUCCESS)
return(nullptr);
return image;
}
void Device::DestoryImage(VkImage img)
{
if(img==VK_NULL_HANDLE)return;
vkDestroyImage(attr->device,img,nullptr);
}
Memory *Device::CreateMemory(VkImage image,const uint32_t flag)
{
VkMemoryRequirements memReqs;
vkGetImageMemoryRequirements(attr->device,image,&memReqs);
return CreateMemory(memReqs,flag);
}
VK_NAMESPACE_END

82
src/RenderDevice/Vulkan/VKDeviceTexture.cpp
View File

@ -20,22 +20,86 @@ namespace
}
}//namespace
Texture2D *Device::CreateTexture2D(const VkFormat format,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout)
Texture2D *Device::CreateTexture2D(Memory *mem,VkImage image,ImageView *image_view,VkImageLayout image_layout,bool linear)
{
TextureData *tex_data=new TextureData;
tex_data->memory = mem;
tex_data->image_layout = image_layout;
tex_data->image = image;
tex_data->image_view = image_view;
tex_data->mip_levels = 0;
tex_data->linear = linear;
return(new Texture2D(attr->device,tex_data));
}
Texture2D *Device::CreateTexture2D(VkFormat format,uint32_t width,uint32_t height,VkImageAspectFlagBits aspectMask,VkImage image,VkImageLayout image_layout,bool linear)
{
VkExtent3D extent={width,height,1};
ImageView *iv=CreateImageView(attr->device,VK_IMAGE_VIEW_TYPE_2D,format,extent,aspectMask,image);
return this->CreateTexture2D(nullptr,image,iv,image_layout,false);
}
Texture2D *Device::CreateTexture2D(const VkFormat format,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout,bool linear)
{
const VkFormatProperties fp=attr->physical_device->GetFormatProperties(format);
if(!(fp.optimalTilingFeatures&VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)
&&!(fp.linearTilingFeatures&VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))
return(nullptr);
enum VkImageTiling tiling;
return VK_NAMESPACE::CreateTexture2D(attr->device,attr->physical_device,format,width,height,aspectMask,usage,image_layout,(fp.optimalTilingFeatures&VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)?VK_IMAGE_TILING_OPTIMAL:VK_IMAGE_TILING_LINEAR);
if(linear)
{
if(fp.linearTilingFeatures&VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)
tiling=VK_IMAGE_TILING_LINEAR;
else
return(nullptr);
}
else
{
if(fp.optimalTilingFeatures&VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)
{
tiling=VK_IMAGE_TILING_OPTIMAL;
}
else
{
if(fp.linearTilingFeatures&VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)
{
tiling=VK_IMAGE_TILING_LINEAR;
linear=true;
}
else
return(nullptr);
}
}
Texture2D *Device::CreateTexture2D(const VkFormat format,Buffer *buf,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout)
VkImage img=CreateImage(format,width,height,usage,tiling);
if(!img)return(nullptr);
Memory *mem=CreateMemory(img);
if(!mem->BindImage(img))
{
delete mem;
DestoryImage(img);
return(nullptr);
}
const VkExtent3D ext={width,height,1};
ImageView *iv=CreateImageView2D(attr->device,format,ext,aspectMask,img);
return CreateTexture2D(format,width,height,aspectMask,usage,image_layout,linear);
}
Texture2D *Device::CreateTexture2D(const VkFormat format,Buffer *buf,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout,const bool linear)
{
if(!buf)return(nullptr);
Texture2D *tex=CreateTexture2D(format,width,height,aspectMask,usage,image_layout);
Texture2D *tex=CreateTexture2D(format,width,height,aspectMask,usage,image_layout,false);
if(!tex)return(nullptr);
@ -44,13 +108,13 @@ Texture2D *Device::CreateTexture2D(const VkFormat format,Buffer *buf,uint32_t wi
return(tex);
}
Texture2D *Device::CreateTexture2D(const VkFormat format,void *data,uint32_t width,uint32_t height,uint32_t size,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout)
Texture2D *Device::CreateTexture2D(const VkFormat format,void *data,uint32_t width,uint32_t height,uint32_t size,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout,const bool linear)
{
Buffer *buf=CreateBuffer(VK_BUFFER_USAGE_TRANSFER_SRC_BIT,size,data);
if(!buf)return(nullptr);
Texture2D *tex=CreateTexture2D(format,buf,width,height,aspectMask,image_layout);
Texture2D *tex=CreateTexture2D(format,buf,width,height,aspectMask,image_layout,linear);
delete buf;
return(tex);

11
src/RenderDevice/Vulkan/VKMemory.cpp
View File

@ -1,11 +1,12 @@
#include<hgl/graph/vulkan/VKMemory.h>
#include<hgl/graph/vulkan/VKDevice.h>
#include<hgl/graph/vulkan/VKMemory.h>
#include<hgl/graph/vulkan/VKPhysicalDevice.h>
VK_NAMESPACE_BEGIN
Memory *CreateMemory(VkDevice device,const PhysicalDevice *pd,const VkMemoryRequirements &req,uint32_t properties)
Memory *Device::CreateMemory(const VkMemoryRequirements &req,uint32_t properties)
{
uint32_t index;
if(!pd->CheckMemoryType(req.memoryTypeBits,properties,&index))
if(!attr->physical_device->CheckMemoryType(req.memoryTypeBits,properties,&index))
return(false);
VkMemoryAllocateInfo alloc_info;
@ -17,10 +18,10 @@ Memory *CreateMemory(VkDevice device,const PhysicalDevice *pd,const VkMemoryRequ
VkDeviceMemory memory;
if(vkAllocateMemory(device,&alloc_info,nullptr,&memory)!=VK_SUCCESS)
if(vkAllocateMemory(attr->device,&alloc_info,nullptr,&memory)!=VK_SUCCESS)
return(nullptr);
return(new Memory(device,memory,req,index,properties));
return(new Memory(attr->device,memory,req,index,properties));
}
Memory::~Memory()

83
src/RenderDevice/Vulkan/VKTexture.cpp
View File

@ -17,87 +17,4 @@ Texture::~Texture()
vkDestroyImage(device,data->image,nullptr);
}
}
Texture2D *CreateTexture2D(VkDevice device,VkFormat format,uint32_t width,uint32_t height,VkImageAspectFlagBits aspectMask,VkImage image,VkImageLayout image_layout)
{
TextureData *tex_data=new TextureData;
tex_data->extent.width =width;
tex_data->extent.height =height;
tex_data->extent.depth =1;
tex_data->memory =nullptr;
tex_data->image =image;
tex_data->image_layout =image_layout;
tex_data->image_view =CreateImageView(device,VK_IMAGE_VIEW_TYPE_2D,format,tex_data->extent,aspectMask,image);
tex_data->mip_levels =0;
tex_data->linear =false;
tex_data->format =format;
tex_data->aspect =aspectMask;
return(new Texture2D(width,height,device,tex_data));
}
Texture2D *CreateTexture2D(VkDevice device,const PhysicalDevice *pd,const VkFormat format,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout,const VkImageTiling tiling)
{
if(format<VK_FORMAT_BEGIN_RANGE||format>VK_FORMAT_END_RANGE)return(nullptr);
if(width<1||height<1)return(nullptr);
VkImageCreateInfo imageCreateInfo;
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageCreateInfo.pNext = nullptr;
imageCreateInfo.flags = 0;
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imageCreateInfo.format = format;
imageCreateInfo.extent.width = width;
imageCreateInfo.extent.height = height;
imageCreateInfo.extent.depth = 1;
imageCreateInfo.mipLevels = 1;
imageCreateInfo.arrayLayers = 1;
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageCreateInfo.usage = usage;
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageCreateInfo.queueFamilyIndexCount = 0;
imageCreateInfo.pQueueFamilyIndices = nullptr;
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageCreateInfo.tiling = tiling;
VkImage image;
if(vkCreateImage(device, &imageCreateInfo, nullptr, &image)!=VK_SUCCESS)
return(nullptr);
VkMemoryRequirements memReqs;
vkGetImageMemoryRequirements(device, image, &memReqs);
Memory *dm=CreateMemory(device,pd,memReqs,VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
if(dm&&dm->BindImage(image))
{
ImageView *image_view=CreateImageView2D(device,format,imageCreateInfo.extent,aspectMask,image);
if(image_view)
{
TextureData *tex_data=new TextureData;
tex_data->mip_levels = 0;
tex_data->memory = dm;
tex_data->image_layout = image_layout;
tex_data->image = image;
tex_data->image_view = image_view;
tex_data->format = format;
tex_data->aspect = aspectMask;
tex_data->extent = imageCreateInfo.extent;
return(new Texture2D(width,height,device,tex_data));
}
}
delete dm;
vkDestroyImage(device,image,nullptr);
return(nullptr);
}
VK_NAMESPACE_END