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

a lot of rename

Browse Source
This commit is contained in:
hyzboy 2020-10-21 12:09:15 +08:00
parent 6dae81ac93
commit a20afeba9e
70 changed files with 249 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
example/2dVector/line.cpp
View File

@ -37,9 +37,9 @@ private:
vulkan::MaterialInstance * material_instance =nullptr; vulkan::MaterialInstance * material_instance =nullptr;
vulkan::RenderableInstance *render_instance =nullptr; vulkan::RenderableInstance *render_instance =nullptr;
vulkan::Buffer * ubo_world_matrix =nullptr; vulkan::GPUBuffer * ubo_world_matrix =nullptr;
vulkan::Buffer * ubo_color_material =nullptr; vulkan::GPUBuffer * ubo_color_material =nullptr;
vulkan::Buffer * ubo_line_config =nullptr; vulkan::GPUBuffer * ubo_line_config =nullptr;
vulkan::Pipeline * pipeline =nullptr; vulkan::Pipeline * pipeline =nullptr;
@ -61,9 +61,9 @@ private:
return(true); return(true);
} }
vulkan::Buffer *CreateUBO(const AnsiString &name,const VkDeviceSize size,void *data) vulkan::GPUBuffer *CreateUBO(const AnsiString &name,const VkDeviceSize size,void *data)
{ {
vulkan::Buffer *ubo=db->CreateUBO(size,data); vulkan::GPUBuffer *ubo=db->CreateUBO(size,data);
if(!ubo) if(!ubo)
return(nullptr); return(nullptr);

2
example/Vulkan/Atomsphere.cpp
View File

@ -40,7 +40,7 @@ private:
vulkan::MaterialInstance * material_instance =nullptr; vulkan::MaterialInstance * material_instance =nullptr;
vulkan::Pipeline * pipeline_solid =nullptr; vulkan::Pipeline * pipeline_solid =nullptr;
vulkan::Buffer * ubo_atomsphere =nullptr; vulkan::GPUBuffer * ubo_atomsphere =nullptr;
AtmosphereData atomsphere_data; AtmosphereData atomsphere_data;
vulkan::Renderable * ro_sphere =nullptr; vulkan::Renderable * ro_sphere =nullptr;

2
example/Vulkan/DeferredModel.cpp
View File

@ -16,7 +16,7 @@ using namespace hgl;
using namespace hgl::graph; using namespace hgl::graph;
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
Texture2D *CreateTextureFromFile(Device *device,const OSString &filename); Texture2D *CreateTextureFromFile(RenderDevice *device,const OSString &filename);
VK_NAMESPACE_END VK_NAMESPACE_END
constexpr uint32_t SCREEN_WIDTH=512; constexpr uint32_t SCREEN_WIDTH=512;

4
example/Vulkan/DrawText.cpp
View File

@ -28,8 +28,8 @@ private:
vulkan::Sampler * sampler =nullptr; vulkan::Sampler * sampler =nullptr;
vulkan::MaterialInstance * material_instance =nullptr; vulkan::MaterialInstance * material_instance =nullptr;
vulkan::Buffer * ubo_world_matrix =nullptr; vulkan::GPUBuffer * ubo_world_matrix =nullptr;
vulkan::Buffer * ubo_color =nullptr; vulkan::GPUBuffer * ubo_color =nullptr;
vulkan::Pipeline * pipeline =nullptr; vulkan::Pipeline * pipeline =nullptr;

2
example/Vulkan/DrawTile.cpp
View File

@ -42,7 +42,7 @@ private:
vulkan::MaterialInstance * material_instance =nullptr; vulkan::MaterialInstance * material_instance =nullptr;
vulkan::Renderable * render_obj =nullptr; vulkan::Renderable * render_obj =nullptr;
vulkan::RenderableInstance *render_instance =nullptr; vulkan::RenderableInstance *render_instance =nullptr;
vulkan::Buffer * ubo_world_matrix =nullptr; vulkan::GPUBuffer * ubo_world_matrix =nullptr;
vulkan::Pipeline * pipeline =nullptr; vulkan::Pipeline * pipeline =nullptr;

2
example/Vulkan/FragCoordTest.cpp
View File

@ -28,7 +28,7 @@ private:
vulkan::MaterialInstance * material_instance =nullptr; vulkan::MaterialInstance * material_instance =nullptr;
vulkan::RenderableInstance *renderable_instance =nullptr; vulkan::RenderableInstance *renderable_instance =nullptr;
vulkan::Buffer * ubo_world_matrix =nullptr; vulkan::GPUBuffer * ubo_world_matrix =nullptr;
vulkan::Pipeline * pipeline =nullptr; vulkan::Pipeline * pipeline =nullptr;

8
example/Vulkan/Geometry2D.cpp
View File

@ -35,8 +35,8 @@ private:
*ro_circle =nullptr, *ro_circle =nullptr,
*ro_round_rectangle =nullptr; *ro_round_rectangle =nullptr;
vulkan::Buffer * ubo_world_matrix =nullptr; vulkan::GPUBuffer * ubo_world_matrix =nullptr;
vulkan::Buffer * ubo_color_material =nullptr; vulkan::GPUBuffer * ubo_color_material =nullptr;
vulkan::Pipeline * pipeline =nullptr; vulkan::Pipeline * pipeline =nullptr;
@ -92,9 +92,9 @@ private:
} }
} }
vulkan::Buffer *CreateUBO(const AnsiString &name,const VkDeviceSize size,void *data) vulkan::GPUBuffer *CreateUBO(const AnsiString &name,const VkDeviceSize size,void *data)
{ {
vulkan::Buffer *ubo=db->CreateUBO(size,data); vulkan::GPUBuffer *ubo=db->CreateUBO(size,data);
if(!ubo) if(!ubo)
return(nullptr); return(nullptr);

2
example/Vulkan/Geometry3D.cpp
View File

@ -16,7 +16,7 @@ class TestApp:public CameraAppFramework
{ {
Color4f color; Color4f color;
vulkan::Buffer *ubo_color=nullptr; vulkan::GPUBuffer *ubo_color=nullptr;
private: private:

2
example/Vulkan/HQFilterTexture.cpp
View File

@ -10,7 +10,7 @@ using namespace hgl;
using namespace hgl::graph; using namespace hgl::graph;
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
Texture2D *CreateTextureFromFile(Device *device,const OSString &filename); Texture2D *CreateTextureFromFile(RenderDevice *device,const OSString &filename);
VK_NAMESPACE_END VK_NAMESPACE_END
constexpr uint32_t SCREEN_SIZE=512; constexpr uint32_t SCREEN_SIZE=512;

2
example/Vulkan/InlineGeometryScene.cpp
View File

@ -30,7 +30,7 @@ private:
vulkan::Pipeline * pipeline_line =nullptr; vulkan::Pipeline * pipeline_line =nullptr;
vulkan::Pipeline * pipeline_solid =nullptr; vulkan::Pipeline * pipeline_solid =nullptr;
vulkan::Buffer * ubo_color =nullptr; vulkan::GPUBuffer * ubo_color =nullptr;
vulkan::Renderable *ro_plane_grid, vulkan::Renderable *ro_plane_grid,
*ro_cube, *ro_cube,

2
example/Vulkan/OffscreenRender.cpp
View File

@ -16,7 +16,7 @@ class TestApp:public CameraAppFramework
Camera cam; Camera cam;
vulkan::MaterialInstance * material_instance =nullptr; vulkan::MaterialInstance * material_instance =nullptr;
vulkan::Buffer * ubo_world_matrix =nullptr; vulkan::GPUBuffer * ubo_world_matrix =nullptr;
}; };
struct:public RenderObject struct:public RenderObject

4
example/Vulkan/RectanglePrimitive.cpp
View File

@ -10,7 +10,7 @@ using namespace hgl;
using namespace hgl::graph; using namespace hgl::graph;
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
Texture2D *CreateTextureFromFile(Device *device,const OSString &filename); Texture2D *CreateTextureFromFile(RenderDevice *device,const OSString &filename);
VK_NAMESPACE_END VK_NAMESPACE_END
constexpr uint32_t SCREEN_SIZE=512; constexpr uint32_t SCREEN_SIZE=512;
@ -41,7 +41,7 @@ private:
vulkan::MaterialInstance * material_instance =nullptr; vulkan::MaterialInstance * material_instance =nullptr;
vulkan::Renderable * render_obj =nullptr; vulkan::Renderable * render_obj =nullptr;
vulkan::RenderableInstance *render_instance =nullptr; vulkan::RenderableInstance *render_instance =nullptr;
vulkan::Buffer * ubo_world_matrix =nullptr; vulkan::GPUBuffer * ubo_world_matrix =nullptr;
vulkan::Pipeline * pipeline =nullptr; vulkan::Pipeline * pipeline =nullptr;

4
example/Vulkan/TextureFormat.cpp
View File

@ -63,8 +63,8 @@ int main(int,char **)
{ {
Window * win =nullptr; Window * win =nullptr;
vulkan::Instance * inst =nullptr; vulkan::Instance * inst =nullptr;
vulkan::Device * device =nullptr; vulkan::RenderDevice * device =nullptr;
const vulkan::PhysicalDevice *physical_device =nullptr; const vulkan::PhysicalRenderDevice *physical_device =nullptr;
inst=InitVulkanInstance(); inst=InitVulkanInstance();

2
example/Vulkan/first_triangle.cpp
View File

@ -34,7 +34,7 @@ private:
vulkan::MaterialInstance * material_instance =nullptr; vulkan::MaterialInstance * material_instance =nullptr;
vulkan::RenderableInstance *render_instance =nullptr; vulkan::RenderableInstance *render_instance =nullptr;
vulkan::Buffer * ubo_world_matrix =nullptr; vulkan::GPUBuffer * ubo_world_matrix =nullptr;
vulkan::Pipeline * pipeline =nullptr; vulkan::Pipeline * pipeline =nullptr;

2
example/Vulkan/indices_rect.cpp
View File

@ -38,7 +38,7 @@ private:
vulkan::MaterialInstance * material_instance =nullptr; vulkan::MaterialInstance * material_instance =nullptr;
vulkan::RenderableInstance *renderable_instance =nullptr; vulkan::RenderableInstance *renderable_instance =nullptr;
vulkan::Buffer * ubo_world_matrix =nullptr; vulkan::GPUBuffer * ubo_world_matrix =nullptr;
vulkan::Pipeline * pipeline =nullptr; vulkan::Pipeline * pipeline =nullptr;

4
example/Vulkan/texture_rect.cpp
View File

@ -11,7 +11,7 @@ using namespace hgl;
using namespace hgl::graph; using namespace hgl::graph;
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
Texture2D *CreateTextureFromFile(Device *device,const OSString &filename); Texture2D *CreateTextureFromFile(RenderDevice *device,const OSString &filename);
VK_NAMESPACE_END VK_NAMESPACE_END
constexpr uint32_t SCREEN_WIDTH=256; constexpr uint32_t SCREEN_WIDTH=256;
@ -53,7 +53,7 @@ private:
vulkan::Sampler * sampler =nullptr; vulkan::Sampler * sampler =nullptr;
vulkan::MaterialInstance * material_instance =nullptr; vulkan::MaterialInstance * material_instance =nullptr;
vulkan::RenderableInstance *renderable_instance =nullptr; vulkan::RenderableInstance *renderable_instance =nullptr;
vulkan::Buffer * ubo_world_matrix =nullptr; vulkan::GPUBuffer * ubo_world_matrix =nullptr;
vulkan::Pipeline * pipeline =nullptr; vulkan::Pipeline * pipeline =nullptr;
private: private:

6
example/common/VulkanAppFramework.h
View File

@ -46,7 +46,7 @@ protected:
protected: protected:
vulkan::Device * device =nullptr; vulkan::RenderDevice * device =nullptr;
vulkan::SwapchainRenderTarget * sc_render_target =nullptr; vulkan::SwapchainRenderTarget * sc_render_target =nullptr;
protected: protected:
@ -332,7 +332,7 @@ class CameraAppFramework:public VulkanApplicationFramework
{ {
private: private:
vulkan::Buffer * ubo_world_matrix =nullptr; vulkan::GPUBuffer * ubo_world_matrix =nullptr;
protected: protected:
@ -375,7 +375,7 @@ public:
camera.height=h; camera.height=h;
} }
vulkan::Buffer *GetCameraMatrixBuffer() vulkan::GPUBuffer *GetCameraMatrixBuffer()
{ {
return ubo_world_matrix; return ubo_world_matrix;
} }

6
inc/hgl/graph/TileData.h
View File

@ -33,7 +33,7 @@ namespace hgl
*/ */
class TileData ///Tile纹理管理 class TileData ///Tile纹理管理
{ {
Device *device; RenderDevice *device;
protected: protected:
@ -48,7 +48,7 @@ namespace hgl
protected: protected:
vulkan::Buffer *tile_buffer; ///<Tile暂存缓冲区 vulkan::GPUBuffer *tile_buffer; ///<Tile暂存缓冲区
List<ImageRegion> commit_list; List<ImageRegion> commit_list;
uint8 *commit_ptr; uint8 *commit_ptr;
@ -67,7 +67,7 @@ namespace hgl
public: public:
TileData(Device *,Texture2D *,const uint tw,const uint th); TileData(RenderDevice *,Texture2D *,const uint tw,const uint th);
virtual ~TileData(); virtual ~TileData();
void BeginCommit(); void BeginCommit();

12
inc/hgl/graph/VK.h
View File

@ -14,9 +14,9 @@ VK_NAMESPACE_BEGIN
using CharPointerList=hgl::List<const char *>; using CharPointerList=hgl::List<const char *>;
class Instance; class Instance;
class PhysicalDevice; class PhysicalRenderDevice;
class Device; class RenderDevice;
struct DeviceAttribute; struct RenderDeviceAttribute;
class ImageView; class ImageView;
class Framebuffer; class Framebuffer;
struct Swapchain; struct Swapchain;
@ -34,8 +34,8 @@ class TextureCubemapArray;
class Sampler; class Sampler;
class Memory; class GPUMemory;
class Buffer; class GPUBuffer;
struct BufferData; struct BufferData;
class VertexAttribBuffer; class VertexAttribBuffer;
@ -45,7 +45,7 @@ class IndexBuffer;
class CommandBuffer; class CommandBuffer;
class RenderPass; class RenderPass;
class Fence; class GPUFence;
class GPUSemaphore; class GPUSemaphore;
class DescriptorSetLayoutCreater; class DescriptorSetLayoutCreater;

32
inc/hgl/graph/VKBuffer.h
View File

@ -7,11 +7,11 @@ VK_NAMESPACE_BEGIN
struct BufferData struct BufferData
{ {
VkBuffer buffer; VkBuffer buffer;
Memory * memory=nullptr; GPUMemory * memory=nullptr;
VkDescriptorBufferInfo info; VkDescriptorBufferInfo info;
};//struct BufferData };//struct BufferData
class Buffer class GPUBuffer
{ {
protected: protected:
@ -20,11 +20,11 @@ protected:
private: private:
friend class Device; friend class RenderDevice;
friend class VertexAttribBuffer; friend class VertexAttribBuffer;
friend class IndexBuffer; friend class IndexBuffer;
Buffer(VkDevice d,const BufferData &b) GPUBuffer(VkDevice d,const BufferData &b)
{ {
device=d; device=d;
buf=b; buf=b;
@ -32,10 +32,10 @@ private:
public: public:
virtual ~Buffer(); virtual ~GPUBuffer();
VkBuffer GetBuffer (){return buf.buffer;} VkBuffer GetBuffer (){return buf.buffer;}
Memory * GetMemory (){return buf.memory;} GPUMemory * GetMemory (){return buf.memory;}
const VkDescriptorBufferInfo * GetBufferInfo()const{return &buf.info;} const VkDescriptorBufferInfo * GetBufferInfo()const{return &buf.info;}
void * Map () {return buf.memory->Map();} void * Map () {return buf.memory->Map();}
@ -45,9 +45,9 @@ public:
bool Write (const void *ptr,uint32_t start,uint32_t size) {return buf.memory->Write(ptr,start,size);} bool Write (const void *ptr,uint32_t start,uint32_t size) {return buf.memory->Write(ptr,start,size);}
bool Write (const void *ptr,uint32_t size) {return buf.memory->Write(ptr,0,size);} bool Write (const void *ptr,uint32_t size) {return buf.memory->Write(ptr,0,size);}
bool Write (const void *ptr) {return buf.memory->Write(ptr);} bool Write (const void *ptr) {return buf.memory->Write(ptr);}
};//class Buffer };//class GPUBuffer
class VertexAttribBuffer:public Buffer class VertexAttribBuffer:public GPUBuffer
{ {
VkFormat format; ///<数据格式 VkFormat format; ///<数据格式
uint32_t stride; ///<单个数据字节数 uint32_t stride; ///<单个数据字节数
@ -55,9 +55,9 @@ class VertexAttribBuffer:public Buffer
private: private:
friend class Device; friend class RenderDevice;
VertexAttribBuffer(VkDevice d,const BufferData &vb,VkFormat fmt,uint32_t _stride,uint32_t _count):Buffer(d,vb) VertexAttribBuffer(VkDevice d,const BufferData &vb,VkFormat fmt,uint32_t _stride,uint32_t _count):GPUBuffer(d,vb)
{ {
format=fmt; format=fmt;
stride=_stride; stride=_stride;
@ -74,22 +74,22 @@ public:
void *Map(VkDeviceSize start=0,VkDeviceSize size=0) override void *Map(VkDeviceSize start=0,VkDeviceSize size=0) override
{ {
return Buffer::Map(start*stride,size*stride); return GPUBuffer::Map(start*stride,size*stride);
} }
};//class VertexAttribBuffer:public Buffer };//class VertexAttribBuffer:public GPUBuffer
using VAB=VertexAttribBuffer; using VAB=VertexAttribBuffer;
class IndexBuffer:public Buffer class IndexBuffer:public GPUBuffer
{ {
IndexType index_type; IndexType index_type;
uint32_t count; uint32_t count;
private: private:
friend class Device; friend class RenderDevice;
IndexBuffer(VkDevice d,const BufferData &vb,IndexType it,uint32_t _count):Buffer(d,vb) IndexBuffer(VkDevice d,const BufferData &vb,IndexType it,uint32_t _count):GPUBuffer(d,vb)
{ {
index_type=it; index_type=it;
count=_count; count=_count;
@ -101,6 +101,6 @@ public:
const IndexType GetType ()const{return index_type;} const IndexType GetType ()const{return index_type;}
const uint32 GetCount()const{return count;} const uint32 GetCount()const{return count;}
};//class IndexBuffer:public Buffer };//class IndexBuffer:public GPUBuffer
VK_NAMESPACE_END VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_BUFFER_INCLUDE #endif//HGL_GRAPH_VULKAN_BUFFER_INCLUDE

14
inc/hgl/graph/VKDatabase.h
View File

@ -31,7 +31,7 @@ class VertexAttribData;
*/ */
class Database class Database
{ {
Device *device; RenderDevice *device;
MapObject<OSString,ShaderModule> shader_module_by_name; MapObject<OSString,ShaderModule> shader_module_by_name;
Map<OSString,Material *> material_by_name; Map<OSString,Material *> material_by_name;
@ -41,14 +41,14 @@ class Database
IDResManage<PipelineID, Pipeline> rm_pipeline; ///<管线合集 IDResManage<PipelineID, Pipeline> rm_pipeline; ///<管线合集
IDResManage<DescriptorSetsID, DescriptorSets> rm_desc_sets; ///<描述符合集 IDResManage<DescriptorSetsID, DescriptorSets> rm_desc_sets; ///<描述符合集
IDResManage<RenderableID, Renderable> rm_renderables; ///<可渲染对象合集 IDResManage<RenderableID, Renderable> rm_renderables; ///<可渲染对象合集
IDResManage<BufferID, Buffer> rm_buffers; ///<顶点缓冲区合集 IDResManage<BufferID, GPUBuffer> rm_buffers; ///<顶点缓冲区合集
IDResManage<SamplerID, Sampler> rm_samplers; ///<采样器合集 IDResManage<SamplerID, Sampler> rm_samplers; ///<采样器合集
IDResManage<TextureID, Texture> rm_textures; ///<纹理合集 IDResManage<TextureID, Texture> rm_textures; ///<纹理合集
IDResManage<RenderableInstanceID, RenderableInstance> rm_renderable_instances; ///<渲染实例集合集 IDResManage<RenderableInstanceID, RenderableInstance> rm_renderable_instances; ///<渲染实例集合集
public: public:
Database(Device *dev):device(dev){} Database(RenderDevice *dev):device(dev){}
virtual ~Database()=default; virtual ~Database()=default;
public: //Add public: //Add
@ -58,7 +58,7 @@ public: //Add
PipelineID Add(Pipeline * p ){return rm_pipeline.Add(p);} PipelineID Add(Pipeline * p ){return rm_pipeline.Add(p);}
DescriptorSetsID Add(DescriptorSets * ds ){return rm_desc_sets.Add(ds);} DescriptorSetsID Add(DescriptorSets * ds ){return rm_desc_sets.Add(ds);}
RenderableID Add(Renderable * r ){return rm_renderables.Add(r);} RenderableID Add(Renderable * r ){return rm_renderables.Add(r);}
BufferID Add(Buffer * buf ){return rm_buffers.Add(buf);} BufferID Add(GPUBuffer * buf ){return rm_buffers.Add(buf);}
SamplerID Add(Sampler * s ){return rm_samplers.Add(s);} SamplerID Add(Sampler * s ){return rm_samplers.Add(s);}
TextureID Add(Texture * t ){return rm_textures.Add(t);} TextureID Add(Texture * t ){return rm_textures.Add(t);}
RenderableInstanceID Add(RenderableInstance *ri ){return rm_renderable_instances.Add(ri);} RenderableInstanceID Add(RenderableInstance *ri ){return rm_renderable_instances.Add(ri);}
@ -69,8 +69,8 @@ public: // VBO/VAO
VAB *CreateVAB(VkFormat format,uint32_t count,SharingMode sm=SharingMode::Exclusive){return CreateVAB(format,count,nullptr,sm);} VAB *CreateVAB(VkFormat format,uint32_t count,SharingMode sm=SharingMode::Exclusive){return CreateVAB(format,count,nullptr,sm);}
VAB *CreateVAB(const VAD *vad,SharingMode sm=SharingMode::Exclusive){return CreateVAB(vad->GetVulkanFormat(),vad->GetCount(),vad->GetData(),sm);} VAB *CreateVAB(const VAD *vad,SharingMode sm=SharingMode::Exclusive){return CreateVAB(vad->GetVulkanFormat(),vad->GetCount(),vad->GetData(),sm);}
#define SCENE_DB_CREATE_FUNC(name) Buffer *Create##name(VkDeviceSize size,void *data,SharingMode sm=SharingMode::Exclusive); \ #define SCENE_DB_CREATE_FUNC(name) GPUBuffer *Create##name(VkDeviceSize size,void *data,SharingMode sm=SharingMode::Exclusive); \
Buffer *Create##name(VkDeviceSize size,SharingMode sm=SharingMode::Exclusive); GPUBuffer *Create##name(VkDeviceSize size,SharingMode sm=SharingMode::Exclusive);
SCENE_DB_CREATE_FUNC(UBO) SCENE_DB_CREATE_FUNC(UBO)
SCENE_DB_CREATE_FUNC(SSBO) SCENE_DB_CREATE_FUNC(SSBO)
@ -119,7 +119,7 @@ public: //Get
Pipeline * GetPipeline (const PipelineID &id){return rm_pipeline.Get(id);} Pipeline * GetPipeline (const PipelineID &id){return rm_pipeline.Get(id);}
DescriptorSets * GetDescSets (const DescriptorSetsID &id){return rm_desc_sets.Get(id);} DescriptorSets * GetDescSets (const DescriptorSetsID &id){return rm_desc_sets.Get(id);}
Renderable * GetRenderable (const RenderableID &id){return rm_renderables.Get(id);} Renderable * GetRenderable (const RenderableID &id){return rm_renderables.Get(id);}
Buffer * GetBuffer (const BufferID &id){return rm_buffers.Get(id);} GPUBuffer * GetBuffer (const BufferID &id){return rm_buffers.Get(id);}
Sampler * GetSampler (const SamplerID &id){return rm_samplers.Get(id);} Sampler * GetSampler (const SamplerID &id){return rm_samplers.Get(id);}
Texture * GetTexture (const TextureID &id){return rm_textures.Get(id);} Texture * GetTexture (const TextureID &id){return rm_textures.Get(id);}
RenderableInstance *GetRenderableInstance (const RenderableInstanceID &id){return rm_renderable_instances.Get(id);} RenderableInstance *GetRenderableInstance (const RenderableInstanceID &id){return rm_renderable_instances.Get(id);}

6
inc/hgl/graph/VKDescriptorSets.h
View File

@ -4,7 +4,7 @@
#include<hgl/graph/VK.h> #include<hgl/graph/VK.h>
#include<hgl/type/Map.h> #include<hgl/type/Map.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
class Buffer; class GPUBuffer;
class DescriptorSets class DescriptorSets
{ {
@ -39,8 +39,8 @@ public:
const VkPipelineLayout GetPipelineLayout ()const{return pipeline_layout;} const VkPipelineLayout GetPipelineLayout ()const{return pipeline_layout;}
void Clear(); void Clear();
bool BindUBO(const int binding,const Buffer *); bool BindUBO(const int binding,const GPUBuffer *);
bool BindUBODynamic(const int binding,const Buffer *); bool BindUBODynamic(const int binding,const GPUBuffer *);
bool BindSampler(const int binding,Texture *,Sampler *); bool BindSampler(const int binding,Texture *,Sampler *);
void Update(); void Update();
};//class DescriptorSets };//class DescriptorSets

46
inc/hgl/graph/VKDevice.h
View File

@ -26,9 +26,9 @@ namespace hgl
}//namespace hgl }//namespace hgl
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
class Device class RenderDevice
{ {
DeviceAttribute *attr; RenderDeviceAttribute *attr;
SubmitQueue *textureSQ; SubmitQueue *textureSQ;
CommandBuffer *texture_cmd_buf; CommandBuffer *texture_cmd_buf;
@ -43,20 +43,20 @@ class Device
private: private:
friend Device *CreateRenderDevice(VkInstance inst,const PhysicalDevice *physical_device,VkSurfaceKHR surface,const VkExtent2D &extent); friend RenderDevice *CreateRenderDevice(VkInstance inst,const PhysicalRenderDevice *physical_device,VkSurfaceKHR surface,const VkExtent2D &extent);
Device(DeviceAttribute *da); RenderDevice(RenderDeviceAttribute *da);
public: public:
virtual ~Device(); virtual ~RenderDevice();
operator VkDevice () {return attr->device;} operator VkDevice () {return attr->device;}
DeviceAttribute * GetDeviceAttribute () {return attr;} RenderDeviceAttribute * GetRenderDeviceAttribute () {return attr;}
VkSurfaceKHR GetSurface () {return attr->surface;} VkSurfaceKHR GetSurface () {return attr->surface;}
VkDevice GetDevice ()const {return attr->device;} VkDevice GetDevice ()const {return attr->device;}
const PhysicalDevice * GetPhysicalDevice ()const {return attr->physical_device;} const PhysicalRenderDevice * GetPhysicalRenderDevice ()const {return attr->physical_device;}
VkDescriptorPool GetDescriptorPool () {return attr->desc_pool;} VkDescriptorPool GetDescriptorPool () {return attr->desc_pool;}
VkPipelineCache GetPipelineCache () {return attr->pipeline_cache;} VkPipelineCache GetPipelineCache () {return attr->pipeline_cache;}
@ -82,8 +82,8 @@ public:
public: //内存相关 public: //内存相关
Memory *CreateMemory(const VkMemoryRequirements &,const uint32_t properties); GPUMemory *CreateMemory(const VkMemoryRequirements &,const uint32_t properties);
Memory *CreateMemory(VkImage,const uint32 flag=VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); GPUMemory *CreateMemory(VkImage,const uint32 flag=VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
private: //Buffer相关 private: //Buffer相关
@ -91,8 +91,8 @@ private: //Buffer相关
public: //Buffer相关 public: //Buffer相关
Buffer * CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data, SharingMode sharing_mode=SharingMode::Exclusive); GPUBuffer * CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data, SharingMode sharing_mode=SharingMode::Exclusive);
Buffer * CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size, SharingMode sharing_mode=SharingMode::Exclusive){return CreateBuffer(buf_usage,size,nullptr,sharing_mode);} GPUBuffer * CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size, SharingMode sharing_mode=SharingMode::Exclusive){return CreateBuffer(buf_usage,size,nullptr,sharing_mode);}
VAB * CreateVAB (VkFormat format,uint32_t count,const void *data, SharingMode sharing_mode=SharingMode::Exclusive); VAB * CreateVAB (VkFormat format,uint32_t count,const void *data, SharingMode sharing_mode=SharingMode::Exclusive);
VAB * CreateVAB (VkFormat format,uint32_t count, SharingMode sharing_mode=SharingMode::Exclusive){return CreateVAB(format,count,nullptr,sharing_mode);} VAB * CreateVAB (VkFormat format,uint32_t count, SharingMode sharing_mode=SharingMode::Exclusive){return CreateVAB(format,count,nullptr,sharing_mode);}
@ -106,8 +106,8 @@ public: //Buffer相关
IndexBuffer * CreateIBO16 ( uint32_t count,SharingMode sharing_mode=SharingMode::Exclusive){return CreateIBO(IndexType::U16,count,nullptr,sharing_mode);} IndexBuffer * CreateIBO16 ( uint32_t count,SharingMode sharing_mode=SharingMode::Exclusive){return CreateIBO(IndexType::U16,count,nullptr,sharing_mode);}
IndexBuffer * CreateIBO32 ( uint32_t count,SharingMode sharing_mode=SharingMode::Exclusive){return CreateIBO(IndexType::U32,count,nullptr,sharing_mode);} IndexBuffer * CreateIBO32 ( uint32_t count,SharingMode sharing_mode=SharingMode::Exclusive){return CreateIBO(IndexType::U32,count,nullptr,sharing_mode);}
#define CREATE_BUFFER_OBJECT(LargeName,type) Buffer *Create##LargeName(VkDeviceSize size,void *data,SharingMode sharing_mode=SharingMode::Exclusive){return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,size,data,sharing_mode);} \ #define CREATE_BUFFER_OBJECT(LargeName,type) GPUBuffer *Create##LargeName(VkDeviceSize size,void *data,SharingMode sharing_mode=SharingMode::Exclusive){return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,size,data,sharing_mode);} \
Buffer *Create##LargeName(VkDeviceSize size,SharingMode sharing_mode=SharingMode::Exclusive){return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,size,nullptr,sharing_mode);} GPUBuffer *Create##LargeName(VkDeviceSize size,SharingMode sharing_mode=SharingMode::Exclusive){return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,size,nullptr,sharing_mode);}
CREATE_BUFFER_OBJECT(UBO,UNIFORM) CREATE_BUFFER_OBJECT(UBO,UNIFORM)
CREATE_BUFFER_OBJECT(SSBO,STORAGE) CREATE_BUFFER_OBJECT(SSBO,STORAGE)
@ -131,7 +131,7 @@ public: //Texture
void Clear(TextureCreateInfo *); void Clear(TextureCreateInfo *);
Texture2D *CreateTexture2D(Memory *mem,VkImage image,ImageView *image_view,VkImageLayout image_layout,ImageTiling tiling); Texture2D *CreateTexture2D(GPUMemory *mem,VkImage image,ImageView *image_view,VkImageLayout image_layout,ImageTiling tiling);
Texture2D *CreateTexture2D(VkFormat format,uint32_t width,uint32_t height,VkImageAspectFlags aspectMask,VkImage image,VkImageLayout image_layout,ImageTiling tiling=ImageTiling::Optimal); Texture2D *CreateTexture2D(VkFormat format,uint32_t width,uint32_t height,VkImageAspectFlags aspectMask,VkImage image,VkImageLayout image_layout,ImageTiling tiling=ImageTiling::Optimal);
Texture2D *CreateTexture2D(const VkFormat format,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout,ImageTiling tiling=ImageTiling::Optimal); Texture2D *CreateTexture2D(const VkFormat format,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout,ImageTiling tiling=ImageTiling::Optimal);
@ -183,7 +183,7 @@ public: //Texture
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
} }
Texture2D *CreateTexture2D( const VkFormat video_format,Buffer *buf,uint32_t width,uint32_t height, Texture2D *CreateTexture2D( const VkFormat video_format,GPUBuffer *buf,uint32_t width,uint32_t height,
const VkImageAspectFlags aspectMask =VK_IMAGE_ASPECT_COLOR_BIT, const VkImageAspectFlags aspectMask =VK_IMAGE_ASPECT_COLOR_BIT,
const uint usage =VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_SAMPLED_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,
@ -195,14 +195,14 @@ public: //Texture
const VkImageLayout image_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, const VkImageLayout image_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
const ImageTiling tiling =ImageTiling::Optimal); const ImageTiling tiling =ImageTiling::Optimal);
bool ChangeTexture2D(Texture2D *,Buffer *buf,const VkBufferImageCopy *,const int count); bool ChangeTexture2D(Texture2D *,GPUBuffer *buf,const VkBufferImageCopy *,const int count);
bool ChangeTexture2D(Texture2D *,Buffer *buf,const List<ImageRegion> &); bool ChangeTexture2D(Texture2D *,GPUBuffer *buf,const List<ImageRegion> &);
bool ChangeTexture2D(Texture2D *,Buffer *buf,uint32_t left,uint32_t top,uint32_t width,uint32_t height); bool ChangeTexture2D(Texture2D *,GPUBuffer *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); bool ChangeTexture2D(Texture2D *,void *data,uint32_t left,uint32_t top,uint32_t width,uint32_t height,uint32_t size);
template<typename T> template<typename T>
bool ChangeTexture2D(Texture2D *tex,Buffer *buf,const RectScope2<T> &rs) bool ChangeTexture2D(Texture2D *tex,GPUBuffer *buf,const RectScope2<T> &rs)
{ {
return ChangeTexture2D( tex, return ChangeTexture2D( tex,
buf, buf,
@ -238,7 +238,7 @@ public: //shader & material
Material *CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *fragment_shader_module); Material *CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *fragment_shader_module);
Material *CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *geometry_shader_module,const ShaderModule *fragment_shader_module); Material *CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *geometry_shader_module,const ShaderModule *fragment_shader_module);
public: //Command Buffer 相关 public: //Command GPUBuffer 相关
CommandBuffer * CreateCommandBuffer(const VkExtent2D &extent,const uint32_t atta_count); CommandBuffer * CreateCommandBuffer(const VkExtent2D &extent,const uint32_t atta_count);
@ -260,7 +260,7 @@ public: //Command Buffer 相关
const VkImageLayout color_final_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, const VkImageLayout color_final_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
const VkImageLayout depth_final_layout=VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); const VkImageLayout depth_final_layout=VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
Fence * CreateFence(bool); GPUFence * CreateFence(bool);
vulkan::GPUSemaphore * CreateSemaphore(); vulkan::GPUSemaphore * CreateSemaphore();
public: //FrameBuffer相关 public: //FrameBuffer相关
@ -312,7 +312,7 @@ public:
TileData *CreateTileData(const VkFormat video_format,const uint width,const uint height,const uint count); ///<创建一个Tile数据集 TileData *CreateTileData(const VkFormat video_format,const uint width,const uint height,const uint count); ///<创建一个Tile数据集
TileFont *CreateTileFont(FontSource *fs,int limit_count=-1); ///<创建一个Tile字体 TileFont *CreateTileFont(FontSource *fs,int limit_count=-1); ///<创建一个Tile字体
};//class Device };//class RenderDevice
//void CreateSubpassDependency(VkSubpassDependency *); //void CreateSubpassDependency(VkSubpassDependency *);
void CreateSubpassDependency(List<VkSubpassDependency> &dependency,const uint32_t count); void CreateSubpassDependency(List<VkSubpassDependency> &dependency,const uint32_t count);
@ -333,6 +333,6 @@ bool CreateAttachmentDescription( List<VkAttachmentDescription> &color_outp
const VkImageLayout color_final_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, const VkImageLayout color_final_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
const VkImageLayout depth_final_layout=VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); const VkImageLayout depth_final_layout=VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
Device *CreateRenderDevice(Instance *inst,Window *win,const PhysicalDevice *physical_device=nullptr); RenderDevice *CreateRenderDevice(Instance *inst,Window *win,const PhysicalRenderDevice *physical_device=nullptr);
VK_NAMESPACE_END VK_NAMESPACE_END
#endif//HGL_GRAPH_RENDER_SURFACE_INCLUDE #endif//HGL_GRAPH_RENDER_SURFACE_INCLUDE

10
inc/hgl/graph/VKDeviceAttribute.h
View File

@ -6,10 +6,10 @@ VK_NAMESPACE_BEGIN
constexpr uint32_t ERROR_FAMILY_INDEX=UINT32_MAX; constexpr uint32_t ERROR_FAMILY_INDEX=UINT32_MAX;
struct DeviceAttribute struct RenderDeviceAttribute
{ {
VkInstance instance =VK_NULL_HANDLE; VkInstance instance =VK_NULL_HANDLE;
const PhysicalDevice * physical_device =nullptr; const PhysicalRenderDevice * physical_device =nullptr;
VkSurfaceKHR surface =VK_NULL_HANDLE; VkSurfaceKHR surface =VK_NULL_HANDLE;
VkSurfaceCapabilitiesKHR surface_caps; VkSurfaceCapabilitiesKHR surface_caps;
@ -39,11 +39,11 @@ struct DeviceAttribute
public: public:
DeviceAttribute(VkInstance inst,const PhysicalDevice *pd,VkSurfaceKHR s); RenderDeviceAttribute(VkInstance inst,const PhysicalRenderDevice *pd,VkSurfaceKHR s);
~DeviceAttribute(); ~RenderDeviceAttribute();
bool CheckMemoryType(uint32_t typeBits,VkMemoryPropertyFlags properties,uint32_t *typeIndex) const; bool CheckMemoryType(uint32_t typeBits,VkMemoryPropertyFlags properties,uint32_t *typeIndex) const;
void Refresh(); void Refresh();
};//class DeviceAttribute };//class RenderDeviceAttribute
VK_NAMESPACE_END VK_NAMESPACE_END

10
inc/hgl/graph/VKFence.h
View File

@ -3,16 +3,16 @@
#include<hgl/graph/VK.h> #include<hgl/graph/VK.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
class Fence class GPUFence
{ {
VkDevice device; VkDevice device;
VkFence fence; VkFence fence;
private: private:
friend class Device; friend class RenderDevice;
Fence(VkDevice d,VkFence f) GPUFence(VkDevice d,VkFence f)
{ {
device=d; device=d;
fence=f; fence=f;
@ -20,9 +20,9 @@ private:
public: public:
~Fence(); ~GPUFence();
operator VkFence(){return fence;} operator VkFence(){return fence;}
};//class Fence };//class GPUFence
VK_NAMESPACE_END VK_NAMESPACE_END
#endif//HGL_VULKAN_GRAPH_FENCE_INCLUDE #endif//HGL_VULKAN_GRAPH_FENCE_INCLUDE

2
inc/hgl/graph/VKFramebuffer.h
View File

@ -16,7 +16,7 @@ class Framebuffer
private: private:
friend class Device; friend class RenderDevice;
Framebuffer(VkDevice,VkFramebuffer,const VkExtent2D &,VkRenderPass,uint32_t color_count,bool depth); Framebuffer(VkDevice,VkFramebuffer,const VkExtent2D &,VkRenderPass,uint32_t color_count,bool depth);

6
inc/hgl/graph/VKInstance.h
View File

@ -55,7 +55,7 @@ VK_NAMESPACE_BEGIN
VKDebugOut *debug_out; VKDebugOut *debug_out;
ObjectList<PhysicalDevice> physical_devices; ObjectList<PhysicalRenderDevice> physical_devices;
private: private:
@ -69,8 +69,8 @@ VK_NAMESPACE_BEGIN
operator VkInstance (){return inst;} operator VkInstance (){return inst;}
const ObjectList<PhysicalDevice> &GetDeviceList ()const {return physical_devices;} const ObjectList<PhysicalRenderDevice> &GetDeviceList ()const {return physical_devices;}
const PhysicalDevice * GetDevice (VkPhysicalDeviceType)const; const PhysicalRenderDevice * GetDevice (VkPhysicalDeviceType)const;
};//class Instance };//class Instance
void InitVulkanProperties(); void InitVulkanProperties();

2
inc/hgl/graph/VKMaterialInstance.h
View File

@ -25,7 +25,7 @@ public:
~MaterialInstance(); ~MaterialInstance();
bool BindUBO(const AnsiString &name,vulkan::Buffer *ubo); bool BindUBO(const AnsiString &name,vulkan::GPUBuffer *ubo);
bool BindSampler(const AnsiString &name,Texture *tex,Sampler *sampler); bool BindSampler(const AnsiString &name,Texture *tex,Sampler *sampler);
void Update(); void Update();

10
inc/hgl/graph/VKMemory.h
View File

@ -3,7 +3,7 @@
#include<hgl/graph/VK.h> #include<hgl/graph/VK.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
class Memory class GPUMemory
{ {
VkDevice device; VkDevice device;
VkDeviceMemory memory; VkDeviceMemory memory;
@ -13,9 +13,9 @@ class Memory
private: private:
friend class Device; friend class RenderDevice;
Memory(VkDevice dev,VkDeviceMemory dm,const VkMemoryRequirements &mr,const uint32 i,const uint32_t p) GPUMemory(VkDevice dev,VkDeviceMemory dm,const VkMemoryRequirements &mr,const uint32 i,const uint32_t p)
{ {
device=dev; device=dev;
memory=dm; memory=dm;
@ -26,7 +26,7 @@ private:
public: public:
virtual ~Memory(); virtual ~GPUMemory();
operator VkDeviceMemory(){return memory;} operator VkDeviceMemory(){return memory;}
@ -48,6 +48,6 @@ public:
bool BindBuffer (VkBuffer buffer); bool BindBuffer (VkBuffer buffer);
bool BindImage (VkImage image); bool BindImage (VkImage image);
};//class Memory };//class GPUMemory
VK_NAMESPACE_END VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_MEMORY_INCLUDE #endif//HGL_GRAPH_VULKAN_MEMORY_INCLUDE

8
inc/hgl/graph/VKPhysicalDevice.h
View File

@ -5,7 +5,7 @@
#include<hgl/type/Sets.h> #include<hgl/type/Sets.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
class PhysicalDevice class PhysicalRenderDevice
{ {
VkInstance instance=nullptr; VkInstance instance=nullptr;
VkPhysicalDevice physical_device=nullptr; VkPhysicalDevice physical_device=nullptr;
@ -18,8 +18,8 @@ class PhysicalDevice
public: public:
PhysicalDevice(VkInstance,VkPhysicalDevice); PhysicalRenderDevice(VkInstance,VkPhysicalDevice);
~PhysicalDevice()=default; ~PhysicalRenderDevice()=default;
operator VkPhysicalDevice(){return physical_device;} operator VkPhysicalDevice(){return physical_device;}
operator const VkPhysicalDevice()const{return physical_device;} operator const VkPhysicalDevice()const{return physical_device;}
@ -119,5 +119,5 @@ public:
min_width =properties.limits.lineWidthRange[0]; min_width =properties.limits.lineWidthRange[0];
max_width =properties.limits.lineWidthRange[1]; max_width =properties.limits.lineWidthRange[1];
} }
};//class PhysicalDevice };//class PhysicalRenderDevice
VK_NAMESPACE_END VK_NAMESPACE_END

2
inc/hgl/graph/VKRenderPass.h
View File

@ -18,7 +18,7 @@ class RenderPass
private: private:
friend class Device; friend class RenderDevice;
RenderPass(VkDevice d,VkRenderPass rp,const List<VkFormat> &cf,VkFormat df) RenderPass(VkDevice d,VkRenderPass rp,const List<VkFormat> &cf,VkFormat df)
{ {

8
inc/hgl/graph/VKRenderTarget.h
View File

@ -30,10 +30,10 @@ protected:
protected: protected:
friend class Device; friend class RenderDevice;
RenderTarget(Device *dev,Framebuffer *_fb,CommandBuffer *_cb,const uint32_t fence_count=1); RenderTarget(RenderDevice *dev,Framebuffer *_fb,CommandBuffer *_cb,const uint32_t fence_count=1);
RenderTarget(Device *dev,RenderPass *_rp,Framebuffer *_fb,CommandBuffer *_cb,Texture2D **color_texture_list,const uint32_t color_count,Texture2D *depth_texture,const uint32_t fence_count=1); RenderTarget(RenderDevice *dev,RenderPass *_rp,Framebuffer *_fb,CommandBuffer *_cb,Texture2D **color_texture_list,const uint32_t color_count,Texture2D *depth_texture,const uint32_t fence_count=1);
public: public:
@ -72,7 +72,7 @@ class SwapchainRenderTarget:public RenderTarget
public: public:
SwapchainRenderTarget(Device *dev,Swapchain *sc); SwapchainRenderTarget(RenderDevice *dev,Swapchain *sc);
~SwapchainRenderTarget(); ~SwapchainRenderTarget();
const VkRenderPass GetRenderPass ()const override {return *main_rp;} const VkRenderPass GetRenderPass ()const override {return *main_rp;}

2
inc/hgl/graph/VKSampler.h
View File

@ -12,7 +12,7 @@ class Sampler
protected: protected:
friend class Device; friend class RenderDevice;
Sampler(VkDevice dev,VkSampler s) Sampler(VkDevice dev,VkSampler s)
{ {

2
inc/hgl/graph/VKSemaphore.h
View File

@ -10,7 +10,7 @@ class GPUSemaphore
private: private:
friend class Device; friend class RenderDevice;
GPUSemaphore(VkDevice d,VkSemaphore s) GPUSemaphore(VkDevice d,VkSemaphore s)
{ {

6
inc/hgl/graph/VKSubmitQueue.h
View File

@ -8,17 +8,17 @@ class SubmitQueue
{ {
protected: protected:
Device *device; RenderDevice *device;
VkQueue queue; VkQueue queue;
uint32_t current_fence; uint32_t current_fence;
ObjectList<Fence> fence_list; ObjectList<GPUFence> fence_list;
SubmitInfo submit_info; SubmitInfo submit_info;
public: public:
SubmitQueue(Device *dev,VkQueue q,const uint32_t fence_count=1); SubmitQueue(RenderDevice *dev,VkQueue q,const uint32_t fence_count=1);
virtual ~SubmitQueue(); virtual ~SubmitQueue();
bool WaitQueue(); bool WaitQueue();

6
inc/hgl/graph/VKTexture.h
View File

@ -12,7 +12,7 @@ BitmapData *LoadBitmapFromFile(const OSString &filename);
struct TextureData struct TextureData
{ {
Memory * memory =nullptr; GPUMemory * memory =nullptr;
VkImage image =VK_NULL_HANDLE; VkImage image =VK_NULL_HANDLE;
VkImageLayout image_layout=VK_IMAGE_LAYOUT_UNDEFINED; VkImageLayout image_layout=VK_IMAGE_LAYOUT_UNDEFINED;
ImageView * image_view =nullptr; ImageView * image_view =nullptr;
@ -29,7 +29,7 @@ struct TextureCreateInfo
ImageTiling tiling; ImageTiling tiling;
VkImage image; VkImage image;
Memory * memory; GPUMemory * memory;
ImageView * image_view; ImageView * image_view;
VkImageLayout image_layout; VkImageLayout image_layout;
@ -57,7 +57,7 @@ public:
VkImageLayout GetImageLayout () {return data?data->image_layout:VK_IMAGE_LAYOUT_UNDEFINED;} VkImageLayout GetImageLayout () {return data?data->image_layout:VK_IMAGE_LAYOUT_UNDEFINED;}
VkImageView GetVulkanImageView () {return data?data->image_view->operator VkImageView():VK_NULL_HANDLE;} VkImageView GetVulkanImageView () {return data?data->image_view->operator VkImageView():VK_NULL_HANDLE;}
Memory * GetMemory () {return data?data->memory:nullptr;} GPUMemory * GetMemory () {return data?data->memory:nullptr;}
ImageView * GetImageView () {return data?data->image_view:nullptr;} ImageView * GetImageView () {return data?data->image_view:nullptr;}
const uint32 GetMipLevels ()const {return data?data->mip_levels:0;} const uint32 GetMipLevels ()const {return data?data->mip_levels:0;}

4
inc/hgl/graph/font/TextRenderable.h
View File

@ -11,7 +11,7 @@ namespace hgl
*/ */
class TextRenderable:public vulkan::Renderable class TextRenderable:public vulkan::Renderable
{ {
vulkan::Device * device; vulkan::RenderDevice * device;
vulkan::Material * mtl; vulkan::Material * mtl;
uint max_count; ///<缓冲区最大容量 uint max_count; ///<缓冲区最大容量
@ -21,7 +21,7 @@ namespace hgl
public: public:
TextRenderable(vulkan::Device *,vulkan::Material *,uint mc=1024); TextRenderable(vulkan::RenderDevice *,vulkan::Material *,uint mc=1024);
virtual ~TextRenderable(); virtual ~TextRenderable();
public: public:

6
inc/hgl/gui/ThemeEngine.h
View File

@ -10,20 +10,20 @@ namespace hgl
{ {
namespace vulkan namespace vulkan
{ {
class Device; class RenderDevice;
}//namespace vulkan }//namespace vulkan
class ThemeEngine class ThemeEngine
{ {
protected: protected:
vulkan::Device *device; vulkan::RenderDevice *device;
MapObject<Form *,ThemeForm> form_list; MapObject<Form *,ThemeForm> form_list;
public: public:
ThemeEngine(vulkan::Device *dev){device=dev;} ThemeEngine(vulkan::RenderDevice *dev){device=dev;}
virtual ~ThemeEngine()=default; virtual ~ThemeEngine()=default;
virtual bool Init()=0; virtual bool Init()=0;

2
src/GUI/DefaultThemeEngine.cpp
View File

@ -4,7 +4,7 @@ namespace hgl
{ {
namespace gui namespace gui
{ {
ThemeEngine *CreateDefaultThemeEngine(vulkan::Device *dev) ThemeEngine *CreateDefaultThemeEngine(vulkan::RenderDevice *dev)
{ {
return(new default_theme::DefaultThemeEngine(dev)); return(new default_theme::DefaultThemeEngine(dev));
} }

2
src/GUI/DefaultThemeEngine.h
View File

@ -29,7 +29,7 @@ namespace hgl
public: public:
DefaultThemeEngine(vulkan::Device *dev):ThemeEngine(dev){} DefaultThemeEngine(vulkan::RenderDevice *dev):ThemeEngine(dev){}
virtual ~DefaultThemeEngine() override; virtual ~DefaultThemeEngine() override;
bool Init() override; bool Init() override;

6
src/GUI/ThemeEngine.cpp
View File

@ -10,9 +10,9 @@ namespace hgl
ThemeEngine *default_theme_engine=nullptr; ThemeEngine *default_theme_engine=nullptr;
}//namespace }//namespace
ThemeEngine *CreateDefaultThemeEngine(vulkan::Device *dev); ThemeEngine *CreateDefaultThemeEngine(vulkan::RenderDevice *dev);
ThemeEngine *GetDefaultThemeEngine(vulkan::Device *dev) ThemeEngine *GetDefaultThemeEngine(vulkan::RenderDevice *dev)
{ {
if(!default_theme_engine) if(!default_theme_engine)
default_theme_engine=CreateDefaultThemeEngine(dev); default_theme_engine=CreateDefaultThemeEngine(dev);
@ -20,7 +20,7 @@ namespace hgl
return default_theme_engine; return default_theme_engine;
} }
ThemeEngine *CreateThemeEngine(vulkan::Device *dev) ThemeEngine *CreateThemeEngine(vulkan::RenderDevice *dev)
{ {
return GetDefaultThemeEngine(); return GetDefaultThemeEngine();
} }

2
src/RenderDevice/VKBuffer.cpp
View File

@ -1,7 +1,7 @@
#include<hgl/graph/VKBuffer.h> #include<hgl/graph/VKBuffer.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
Buffer::~Buffer() GPUBuffer::~GPUBuffer()
{ {
if(buf.memory)delete buf.memory; if(buf.memory)delete buf.memory;
vkDestroyBuffer(device,buf.buffer,nullptr); vkDestroyBuffer(device,buf.buffer,nullptr);

8
src/RenderDevice/VKDatabase.cpp
View File

@ -16,18 +16,18 @@ VAB *Database::CreateVAB(VkFormat format,uint32_t count,const void *data,Sharing
return vb; return vb;
} }
#define SCENE_DB_CREATE_BUFFER(name) Buffer *Database::Create##name(VkDeviceSize size,void *data,SharingMode sharing_mode) \ #define SCENE_DB_CREATE_BUFFER(name) GPUBuffer *Database::Create##name(VkDeviceSize size,void *data,SharingMode sharing_mode) \
{ \ { \
Buffer *buf=device->Create##name(size,data,sharing_mode); \ GPUBuffer *buf=device->Create##name(size,data,sharing_mode); \
\ \
if(!buf)return(nullptr); \ if(!buf)return(nullptr); \
rm_buffers.Add(buf); \ rm_buffers.Add(buf); \
return(buf); \ return(buf); \
} \ } \
\ \
Buffer *Database::Create##name(VkDeviceSize size,SharingMode sharing_mode) \ GPUBuffer *Database::Create##name(VkDeviceSize size,SharingMode sharing_mode) \
{ \ { \
Buffer *buf=device->Create##name(size,sharing_mode); \ GPUBuffer *buf=device->Create##name(size,sharing_mode); \
\ \
if(!buf)return(nullptr); \ if(!buf)return(nullptr); \
rm_buffers.Add(buf); \ rm_buffers.Add(buf); \

2
src/RenderDevice/VKDescriptorSetLayoutCreater.cpp
View File

@ -3,7 +3,7 @@
#include<hgl/graph/VKDevice.h> #include<hgl/graph/VKDevice.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
DescriptorSetLayoutCreater *Device::CreateDescriptorSetLayoutCreater() DescriptorSetLayoutCreater *RenderDevice::CreateDescriptorSetLayoutCreater()
{ {
return(new DescriptorSetLayoutCreater(attr->device,attr->desc_pool)); return(new DescriptorSetLayoutCreater(attr->device,attr->desc_pool));
} }

4
src/RenderDevice/VKDescriptorSets.cpp
View File

@ -11,7 +11,7 @@ void DescriptorSets::Clear()
desc_image_info.ClearData(); desc_image_info.ClearData();
} }
bool DescriptorSets::BindUBO(const int binding,const Buffer *buf) bool DescriptorSets::BindUBO(const int binding,const GPUBuffer *buf)
{ {
if(binding<0||!buf) if(binding<0||!buf)
return(false); return(false);
@ -31,7 +31,7 @@ bool DescriptorSets::BindUBO(const int binding,const Buffer *buf)
return(true); return(true);
} }
bool DescriptorSets::BindUBODynamic(const int binding,const Buffer *buf) bool DescriptorSets::BindUBODynamic(const int binding,const GPUBuffer *buf)
{ {
if(binding<0||!buf) if(binding<0||!buf)
return(false); return(false);

14
src/RenderDevice/VKDevice.cpp
View File

@ -11,7 +11,7 @@
#include<hgl/graph/VKDescriptorSets.h> #include<hgl/graph/VKDescriptorSets.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
Device::Device(DeviceAttribute *da) RenderDevice::RenderDevice(RenderDeviceAttribute *da)
{ {
attr=da; attr=da;
@ -23,7 +23,7 @@ Device::Device(DeviceAttribute *da)
Resize(attr->surface_caps.currentExtent); Resize(attr->surface_caps.currentExtent);
} }
Device::~Device() RenderDevice::~RenderDevice()
{ {
SAFE_CLEAR(swapchainRT); SAFE_CLEAR(swapchainRT);
SAFE_CLEAR(swapchain); SAFE_CLEAR(swapchain);
@ -34,7 +34,7 @@ Device::~Device()
delete attr; delete attr;
} }
bool Device::Resize(const VkExtent2D &extent) bool RenderDevice::Resize(const VkExtent2D &extent)
{ {
SAFE_CLEAR(swapchainRT); SAFE_CLEAR(swapchainRT);
SAFE_CLEAR(swapchain); SAFE_CLEAR(swapchain);
@ -55,7 +55,7 @@ bool Device::Resize(const VkExtent2D &extent)
return(true); return(true);
} }
CommandBuffer *Device::CreateCommandBuffer(const VkExtent2D &extent,const uint32_t atta_count) CommandBuffer *RenderDevice::CreateCommandBuffer(const VkExtent2D &extent,const uint32_t atta_count)
{ {
if(!attr->cmd_pool) if(!attr->cmd_pool)
return(nullptr); return(nullptr);
@ -80,7 +80,7 @@ CommandBuffer *Device::CreateCommandBuffer(const VkExtent2D &extent,const uint32
* 创建栅栏 * 创建栅栏
* @param create_signaled 是否创建初始信号 * @param create_signaled 是否创建初始信号
*/ */
Fence *Device::CreateFence(bool create_signaled) GPUFence *RenderDevice::CreateFence(bool create_signaled)
{ {
FenceCreateInfo fenceInfo(create_signaled?VK_FENCE_CREATE_SIGNALED_BIT:0); FenceCreateInfo fenceInfo(create_signaled?VK_FENCE_CREATE_SIGNALED_BIT:0);
@ -89,10 +89,10 @@ Fence *Device::CreateFence(bool create_signaled)
if(vkCreateFence(attr->device, &fenceInfo, nullptr, &fence)!=VK_SUCCESS) if(vkCreateFence(attr->device, &fenceInfo, nullptr, &fence)!=VK_SUCCESS)
return(nullptr); return(nullptr);
return(new Fence(attr->device,fence)); return(new GPUFence(attr->device,fence));
} }
vulkan::GPUSemaphore *Device::CreateSemaphore() vulkan::GPUSemaphore *RenderDevice::CreateSemaphore()
{ {
SemaphoreCreateInfo SemaphoreCreateInfo; SemaphoreCreateInfo SemaphoreCreateInfo;

8
src/RenderDevice/VKDeviceAttribute.cpp
View File

@ -5,7 +5,7 @@
#include<iostream> #include<iostream>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
DeviceAttribute::DeviceAttribute(VkInstance inst,const PhysicalDevice *pd,VkSurfaceKHR s) RenderDeviceAttribute::RenderDeviceAttribute(VkInstance inst,const PhysicalRenderDevice *pd,VkSurfaceKHR s)
{ {
instance=inst; instance=inst;
physical_device=pd; physical_device=pd;
@ -14,7 +14,7 @@ DeviceAttribute::DeviceAttribute(VkInstance inst,const PhysicalDevice *pd,VkSurf
Refresh(); Refresh();
} }
DeviceAttribute::~DeviceAttribute() RenderDeviceAttribute::~RenderDeviceAttribute()
{ {
if(pipeline_cache) if(pipeline_cache)
vkDestroyPipelineCache(device,pipeline_cache,nullptr); vkDestroyPipelineCache(device,pipeline_cache,nullptr);
@ -32,12 +32,12 @@ DeviceAttribute::~DeviceAttribute()
vkDestroySurfaceKHR(instance,surface,nullptr); vkDestroySurfaceKHR(instance,surface,nullptr);
} }
bool DeviceAttribute::CheckMemoryType(uint32_t typeBits,VkMemoryPropertyFlags properties,uint32_t *typeIndex) const bool RenderDeviceAttribute::CheckMemoryType(uint32_t typeBits,VkMemoryPropertyFlags properties,uint32_t *typeIndex) const
{ {
return physical_device->CheckMemoryType(typeBits,properties,typeIndex); return physical_device->CheckMemoryType(typeBits,properties,typeIndex);
} }
void DeviceAttribute::Refresh() void RenderDeviceAttribute::Refresh()
{ {
VkPhysicalDevice pdevice = *physical_device; VkPhysicalDevice pdevice = *physical_device;

14
src/RenderDevice/VKDeviceBuffer.cpp
View File

@ -2,7 +2,7 @@
#include<hgl/graph/VKBuffer.h> #include<hgl/graph/VKBuffer.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
bool Device::CreateBuffer(BufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode) bool RenderDevice::CreateBuffer(BufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode)
{ {
BufferCreateInfo buf_info; BufferCreateInfo buf_info;
@ -19,7 +19,7 @@ bool Device::CreateBuffer(BufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceS
vkGetBufferMemoryRequirements(attr->device,buf->buffer,&mem_reqs); vkGetBufferMemoryRequirements(attr->device,buf->buffer,&mem_reqs);
Memory *dm=CreateMemory(mem_reqs,VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); GPUMemory *dm=CreateMemory(mem_reqs,VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
if(dm&&dm->BindBuffer(buf->buffer)) if(dm&&dm->BindBuffer(buf->buffer))
{ {
@ -42,13 +42,13 @@ bool Device::CreateBuffer(BufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceS
return(false); return(false);
} }
VAB *Device::CreateVAB(VkFormat format,uint32_t count,const void *data,SharingMode sharing_mode) VAB *RenderDevice::CreateVAB(VkFormat format,uint32_t count,const void *data,SharingMode sharing_mode)
{ {
const uint32_t stride=GetStrideByFormat(format); const uint32_t stride=GetStrideByFormat(format);
if(stride==0) if(stride==0)
{ {
std::cerr<<"format["<<format<<"] stride length is 0,please use \"Device::CreateBuffer(VkBufferUsageFlags,VkDeviceSize,VkSharingMode)\" function."; std::cerr<<"format["<<format<<"] stride length is 0,please use \"RenderDevice::CreateBuffer(VkBufferUsageFlags,VkDeviceSize,VkSharingMode)\" function.";
return(nullptr); return(nullptr);
} }
@ -62,7 +62,7 @@ VAB *Device::CreateVAB(VkFormat format,uint32_t count,const void *data,SharingMo
return(new VertexAttribBuffer(attr->device,buf,format,stride,count)); return(new VertexAttribBuffer(attr->device,buf,format,stride,count));
} }
IndexBuffer *Device::CreateIBO(IndexType index_type,uint32_t count,const void *data,SharingMode sharing_mode) IndexBuffer *RenderDevice::CreateIBO(IndexType index_type,uint32_t count,const void *data,SharingMode sharing_mode)
{ {
uint32_t stride; uint32_t stride;
@ -80,13 +80,13 @@ IndexBuffer *Device::CreateIBO(IndexType index_type,uint32_t count,const void *d
return(new IndexBuffer(attr->device,buf,index_type,count)); return(new IndexBuffer(attr->device,buf,index_type,count));
} }
Buffer *Device::CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode) GPUBuffer *RenderDevice::CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode)
{ {
BufferData buf; BufferData buf;
if(!CreateBuffer(&buf,buf_usage,size,data,sharing_mode)) if(!CreateBuffer(&buf,buf_usage,size,data,sharing_mode))
return(nullptr); return(nullptr);
return(new Buffer(attr->device,buf)); return(new GPUBuffer(attr->device,buf));
} }
VK_NAMESPACE_END VK_NAMESPACE_END

16
src/RenderDevice/VKDeviceCreater.cpp
View File

@ -11,7 +11,7 @@
#include<iomanip> #include<iomanip>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
Swapchain *CreateSwapchain(const DeviceAttribute *attr,const VkExtent2D &acquire_extent); Swapchain *CreateSwapchain(const RenderDeviceAttribute *attr,const VkExtent2D &acquire_extent);
namespace namespace
{ {
@ -51,7 +51,7 @@ namespace
return nullptr; return nullptr;
} }
void GetDeviceQueue(DeviceAttribute *attr) void GetDeviceQueue(RenderDeviceAttribute *attr)
{ {
vkGetDeviceQueue(attr->device,attr->graphics_family,0,&attr->graphics_queue); vkGetDeviceQueue(attr->device,attr->graphics_family,0,&attr->graphics_queue);
@ -374,7 +374,7 @@ namespace
constexpr size_t VK_DRIVER_ID_RANGE_SIZE=VK_DRIVER_ID_END_RANGE-VK_DRIVER_ID_BEGIN_RANGE+1; constexpr size_t VK_DRIVER_ID_RANGE_SIZE=VK_DRIVER_ID_END_RANGE-VK_DRIVER_ID_BEGIN_RANGE+1;
#endif//VK_DRIVER_ID_RANGE_SIZE #endif//VK_DRIVER_ID_RANGE_SIZE
Device *CreateRenderDevice(VkInstance inst,const PhysicalDevice *physical_device,VkSurfaceKHR surface,const VkExtent2D &extent) RenderDevice *CreateRenderDevice(VkInstance inst,const PhysicalRenderDevice *physical_device,VkSurfaceKHR surface,const VkExtent2D &extent)
{ {
#ifdef _DEBUG #ifdef _DEBUG
{ {
@ -397,9 +397,9 @@ Device *CreateRenderDevice(VkInstance inst,const PhysicalDevice *physical_device
} }
#endif//_DEBUG #endif//_DEBUG
DeviceAttribute *device_attr=new DeviceAttribute(inst,physical_device,surface); RenderDeviceAttribute *device_attr=new RenderDeviceAttribute(inst,physical_device,surface);
AutoDelete<DeviceAttribute> auto_delete(device_attr); AutoDelete<RenderDeviceAttribute> auto_delete(device_attr);
if(device_attr->graphics_family==ERROR_FAMILY_INDEX) if(device_attr->graphics_family==ERROR_FAMILY_INDEX)
return(nullptr); return(nullptr);
@ -428,10 +428,10 @@ Device *CreateRenderDevice(VkInstance inst,const PhysicalDevice *physical_device
auto_delete.Discard(); auto_delete.Discard();
return(new Device(device_attr)); return(new RenderDevice(device_attr));
} }
Device *CreateRenderDevice(vulkan::Instance *inst,Window *win,const vulkan::PhysicalDevice *pd) RenderDevice *CreateRenderDevice(vulkan::Instance *inst,Window *win,const vulkan::PhysicalRenderDevice *pd)
{ {
if(!inst) if(!inst)
return(nullptr); return(nullptr);
@ -453,7 +453,7 @@ Device *CreateRenderDevice(vulkan::Instance *inst,Window *win,const vulkan::Phys
extent.width=win->GetWidth(); extent.width=win->GetWidth();
extent.height=win->GetHeight(); extent.height=win->GetHeight();
Device *device=CreateRenderDevice(*inst,pd,surface,extent); RenderDevice *device=CreateRenderDevice(*inst,pd,surface,extent);
if(!device) if(!device)
{ {

8
src/RenderDevice/VKDeviceFramebuffer.cpp
View File

@ -20,7 +20,7 @@ VkFramebuffer CreateVulkanFramebuffer(VkDevice device,RenderPass *rp,const VkExt
return fb; return fb;
} }
Framebuffer *Device::CreateFramebuffer(RenderPass *rp,ImageView **color_list,const uint color_count,ImageView *depth) Framebuffer *RenderDevice::CreateFramebuffer(RenderPass *rp,ImageView **color_list,const uint color_count,ImageView *depth)
{ {
uint att_count=color_count; uint att_count=color_count;
@ -78,7 +78,7 @@ Framebuffer *Device::CreateFramebuffer(RenderPass *rp,ImageView **color_list,con
return(new Framebuffer(GetDevice(),fbo,extent,*rp,color_count,depth)); return(new Framebuffer(GetDevice(),fbo,extent,*rp,color_count,depth));
} }
// //
//Framebuffer *Device::CreateFramebuffer(RenderPass *rp,List<ImageView *> &color,ImageView *depth) //Framebuffer *RenderDevice::CreateFramebuffer(RenderPass *rp,List<ImageView *> &color,ImageView *depth)
//{ //{
// if(!rp)return(nullptr); // if(!rp)return(nullptr);
// //
@ -89,7 +89,7 @@ Framebuffer *Device::CreateFramebuffer(RenderPass *rp,ImageView **color_list,con
// return CreateFramebuffer(rp,color.GetData(),color.GetCount(),depth); // return CreateFramebuffer(rp,color.GetData(),color.GetCount(),depth);
//} //}
Framebuffer *Device::CreateFramebuffer(RenderPass *rp,ImageView *color,ImageView *depth) Framebuffer *RenderDevice::CreateFramebuffer(RenderPass *rp,ImageView *color,ImageView *depth)
{ {
if(!rp)return(nullptr); if(!rp)return(nullptr);
if(!color&&!depth)return(nullptr); if(!color&&!depth)return(nullptr);
@ -97,7 +97,7 @@ Framebuffer *Device::CreateFramebuffer(RenderPass *rp,ImageView *color,ImageView
return CreateFramebuffer(rp,&color,1,depth); return CreateFramebuffer(rp,&color,1,depth);
} }
Framebuffer *Device::CreateFramebuffer(RenderPass *rp,ImageView *iv) Framebuffer *RenderDevice::CreateFramebuffer(RenderPass *rp,ImageView *iv)
{ {
if(!rp)return(nullptr); if(!rp)return(nullptr);
if(!iv)return(nullptr); if(!iv)return(nullptr);

8
src/RenderDevice/VKDeviceImage.cpp
View File

@ -2,7 +2,7 @@
#include<hgl/graph/VKImageCreateInfo.h> #include<hgl/graph/VKImageCreateInfo.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
VkImage Device::CreateImage(VkImageCreateInfo *ici) VkImage RenderDevice::CreateImage(VkImageCreateInfo *ici)
{ {
if(!ici)return(VK_NULL_HANDLE); if(!ici)return(VK_NULL_HANDLE);
if(!CheckVulkanFormat(ici->format))return(VK_NULL_HANDLE); if(!CheckVulkanFormat(ici->format))return(VK_NULL_HANDLE);
@ -16,20 +16,20 @@ VkImage Device::CreateImage(VkImageCreateInfo *ici)
return image; return image;
} }
void Device::DestoryImage(VkImage img) void RenderDevice::DestoryImage(VkImage img)
{ {
if(img==VK_NULL_HANDLE)return; if(img==VK_NULL_HANDLE)return;
vkDestroyImage(attr->device,img,nullptr); vkDestroyImage(attr->device,img,nullptr);
} }
Memory *Device::CreateMemory(VkImage image,const uint32_t flag) GPUMemory *RenderDevice::CreateMemory(VkImage image,const uint32_t flag)
{ {
VkMemoryRequirements memReqs; VkMemoryRequirements memReqs;
vkGetImageMemoryRequirements(attr->device,image,&memReqs); vkGetImageMemoryRequirements(attr->device,image,&memReqs);
Memory *mem=CreateMemory(memReqs,flag); GPUMemory *mem=CreateMemory(memReqs,flag);
if(!mem)return(nullptr); if(!mem)return(nullptr);

6
src/RenderDevice/VKDeviceRenderPass.cpp
View File

@ -192,7 +192,7 @@ bool CreateDepthAttachment( List<VkAttachmentReference> &ref_list,List<VkAttachm
return(true); return(true);
} }
RenderPass *Device::CreateRenderPass( const List<VkAttachmentDescription> &desc_list, RenderPass *RenderDevice::CreateRenderPass( const List<VkAttachmentDescription> &desc_list,
const List<VkSubpassDescription> &subpass, const List<VkSubpassDescription> &subpass,
const List<VkSubpassDependency> &dependency, const List<VkSubpassDependency> &dependency,
const List<VkFormat> &color_format_list, const List<VkFormat> &color_format_list,
@ -233,7 +233,7 @@ RenderPass *Device::CreateRenderPass( const List<VkAttachmentDescription> &des
return(new RenderPass(attr->device,render_pass,color_format_list,depth_format)); return(new RenderPass(attr->device,render_pass,color_format_list,depth_format));
} }
RenderPass *Device::CreateRenderPass(const List<VkFormat> &color_format_list,VkFormat depth_format,VkImageLayout color_final_layout,VkImageLayout depth_final_layout) RenderPass *RenderDevice::CreateRenderPass(const List<VkFormat> &color_format_list,VkFormat depth_format,VkImageLayout color_final_layout,VkImageLayout depth_final_layout)
{ {
for(const VkFormat &fmt:color_format_list) for(const VkFormat &fmt:color_format_list)
if(!attr->physical_device->IsColorAttachmentOptimal(fmt)) if(!attr->physical_device->IsColorAttachmentOptimal(fmt))
@ -268,7 +268,7 @@ RenderPass *Device::CreateRenderPass(const List<VkFormat> &color_format_list,VkF
return CreateRenderPass(atta_desc_list,subpass_desc_list,subpass_dependency_list,color_format_list,depth_format,color_final_layout,depth_final_layout); return CreateRenderPass(atta_desc_list,subpass_desc_list,subpass_dependency_list,color_format_list,depth_format,color_final_layout,depth_final_layout);
} }
RenderPass *Device::CreateRenderPass(VkFormat color_format,VkFormat depth_format,VkImageLayout color_final_layout,VkImageLayout depth_final_layout) RenderPass *RenderDevice::CreateRenderPass(VkFormat color_format,VkFormat depth_format,VkImageLayout color_final_layout,VkImageLayout depth_final_layout)
{ {
List<VkFormat> color_format_list; List<VkFormat> color_format_list;

8
src/RenderDevice/VKDeviceRenderTarget.cpp
View File

@ -1,14 +1,14 @@
#include<hgl/graph/VKDevice.h> #include<hgl/graph/VKDevice.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
RenderTarget *Device::CreateRenderTarget(Framebuffer *fb,const uint32_t fence_count) RenderTarget *RenderDevice::CreateRenderTarget(Framebuffer *fb,const uint32_t fence_count)
{ {
CommandBuffer *cb=CreateCommandBuffer(fb->GetExtent(),fb->GetAttachmentCount()); CommandBuffer *cb=CreateCommandBuffer(fb->GetExtent(),fb->GetAttachmentCount());
return(new RenderTarget(this,fb,cb,fence_count)); return(new RenderTarget(this,fb,cb,fence_count));
} }
RenderTarget *Device::CreateRenderTarget( const uint w,const uint h, RenderTarget *RenderDevice::CreateRenderTarget( const uint w,const uint h,
const List<VkFormat> &color_format_list, const List<VkFormat> &color_format_list,
const VkFormat depth_format, const VkFormat depth_format,
const VkImageLayout color_layout, const VkImageLayout color_layout,
@ -65,7 +65,7 @@ RenderTarget *Device::CreateRenderTarget( const uint w,const uint h,
return nullptr; return nullptr;
} }
RenderTarget *Device::CreateRenderTarget( const uint w,const uint h, RenderTarget *RenderDevice::CreateRenderTarget( const uint w,const uint h,
const VkFormat color_format, const VkFormat color_format,
const VkFormat depth_format, const VkFormat depth_format,
const VkImageLayout color_layout, const VkImageLayout color_layout,
@ -81,7 +81,7 @@ RenderTarget *Device::CreateRenderTarget( const uint w,const uint h,
return CreateRenderTarget(w,h,color_format_list,depth_format,color_layout,depth_layout,fence_count); return CreateRenderTarget(w,h,color_format_list,depth_format,color_layout,depth_layout,fence_count);
} }
RenderTarget *Device::CreateRenderTarget(const uint w,const uint h,const VkFormat format,const VkImageLayout final_layout,const uint32_t fence_count) RenderTarget *RenderDevice::CreateRenderTarget(const uint w,const uint h,const VkFormat format,const VkImageLayout final_layout,const uint32_t fence_count)
{ {
if(w<=0||h<=0)return(nullptr); if(w<=0||h<=0)return(nullptr);

8
src/RenderDevice/VKDeviceSwapchain.cpp
View File

@ -15,7 +15,7 @@ namespace
return swapchain_extent; return swapchain_extent;
} }
VkSwapchainKHR CreateSwapChain(const DeviceAttribute *dev_attr,const VkExtent2D &extent) VkSwapchainKHR CreateSwapChain(const RenderDeviceAttribute *dev_attr,const VkExtent2D &extent)
{ {
VkSwapchainCreateInfoKHR swapchain_ci; VkSwapchainCreateInfoKHR swapchain_ci;
@ -68,7 +68,7 @@ namespace
} }
}//namespace }//namespace
bool Device::CreateSwapchainColorTexture() bool RenderDevice::CreateSwapchainColorTexture()
{ {
if(vkGetSwapchainImagesKHR(attr->device,swapchain->swap_chain,&(swapchain->swap_chain_count),nullptr)!=VK_SUCCESS) if(vkGetSwapchainImagesKHR(attr->device,swapchain->swap_chain,&(swapchain->swap_chain_count),nullptr)!=VK_SUCCESS)
return(false); return(false);
@ -98,7 +98,7 @@ bool Device::CreateSwapchainColorTexture()
return(true); return(true);
} }
bool Device::CreateSwapchainDepthTexture() bool RenderDevice::CreateSwapchainDepthTexture()
{ {
const VkFormat depth_format=attr->physical_device->GetDepthFormat(); const VkFormat depth_format=attr->physical_device->GetDepthFormat();
@ -115,7 +115,7 @@ bool Device::CreateSwapchainDepthTexture()
return swapchain->sc_depth; return swapchain->sc_depth;
} }
bool Device::CreateSwapchain(const VkExtent2D &acquire_extent) bool RenderDevice::CreateSwapchain(const VkExtent2D &acquire_extent)
{ {
swapchain=new Swapchain; swapchain=new Swapchain;

34
src/RenderDevice/VKDeviceTexture.cpp
View File

@ -21,7 +21,7 @@ namespace
} }
}//namespace }//namespace
bool Device::CheckFormatSupport(const VkFormat format,const uint32_t bits,ImageTiling tiling) const bool RenderDevice::CheckFormatSupport(const VkFormat format,const uint32_t bits,ImageTiling tiling) const
{ {
const VkFormatProperties fp=attr->physical_device->GetFormatProperties(format); const VkFormatProperties fp=attr->physical_device->GetFormatProperties(format);
@ -31,7 +31,7 @@ bool Device::CheckFormatSupport(const VkFormat format,const uint32_t bits,ImageT
return(fp.linearTilingFeatures&bits); return(fp.linearTilingFeatures&bits);
} }
Texture2D *Device::CreateTexture2D(TextureData *tex_data) Texture2D *RenderDevice::CreateTexture2D(TextureData *tex_data)
{ {
if(!tex_data) if(!tex_data)
return(nullptr); return(nullptr);
@ -39,7 +39,7 @@ Texture2D *Device::CreateTexture2D(TextureData *tex_data)
return(new Texture2D(attr->device,tex_data)); return(new Texture2D(attr->device,tex_data));
} }
Texture2D *Device::CreateTexture2D(Memory *mem,VkImage image,ImageView *image_view,VkImageLayout image_layout,ImageTiling tiling) Texture2D *RenderDevice::CreateTexture2D(GPUMemory *mem,VkImage image,ImageView *image_view,VkImageLayout image_layout,ImageTiling tiling)
{ {
TextureData *tex_data=new TextureData; TextureData *tex_data=new TextureData;
@ -54,7 +54,7 @@ Texture2D *Device::CreateTexture2D(Memory *mem,VkImage image,ImageView *image_vi
return CreateTexture2D(tex_data); return CreateTexture2D(tex_data);
} }
void Device::Clear(TextureCreateInfo *tci) void RenderDevice::Clear(TextureCreateInfo *tci)
{ {
if(!tci)return; if(!tci)return;
@ -65,7 +65,7 @@ void Device::Clear(TextureCreateInfo *tci)
delete tci; delete tci;
} }
Texture2D *Device::CreateTexture2D(TextureCreateInfo *tci) Texture2D *RenderDevice::CreateTexture2D(TextureCreateInfo *tci)
{ {
if(!tci)return(nullptr); if(!tci)return(nullptr);
@ -98,7 +98,7 @@ Texture2D *Device::CreateTexture2D(TextureCreateInfo *tci)
return tex; return tex;
} }
Texture2D *Device::CreateTexture2D(VkFormat format,uint32_t width,uint32_t height,VkImageAspectFlags aspectMask,VkImage image,VkImageLayout image_layout,ImageTiling tiling) Texture2D *RenderDevice::CreateTexture2D(VkFormat format,uint32_t width,uint32_t height,VkImageAspectFlags aspectMask,VkImage image,VkImageLayout image_layout,ImageTiling tiling)
{ {
if(!CheckTextureFormatSupport(format,tiling))return(nullptr); if(!CheckTextureFormatSupport(format,tiling))return(nullptr);
@ -117,7 +117,7 @@ Texture2D *Device::CreateTexture2D(VkFormat format,uint32_t width,uint32_t heigh
return CreateTexture2D(tci); return CreateTexture2D(tci);
} }
Texture2D *Device::CreateTexture2D(const VkFormat format,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout,ImageTiling tiling) Texture2D *RenderDevice::CreateTexture2D(const VkFormat format,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout,ImageTiling tiling)
{ {
if(!CheckTextureFormatSupport(format,tiling))return(nullptr); if(!CheckTextureFormatSupport(format,tiling))return(nullptr);
@ -136,7 +136,7 @@ Texture2D *Device::CreateTexture2D(const VkFormat format,uint32_t width,uint32_t
return CreateTexture2D(tci); return CreateTexture2D(tci);
} }
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 ImageTiling tiling) Texture2D *RenderDevice::CreateTexture2D(const VkFormat format,GPUBuffer *buf,uint32_t width,uint32_t height,const VkImageAspectFlags aspectMask,const uint usage,const VkImageLayout image_layout,const ImageTiling tiling)
{ {
if(!buf)return(nullptr); if(!buf)return(nullptr);
@ -149,7 +149,7 @@ Texture2D *Device::CreateTexture2D(const VkFormat format,Buffer *buf,uint32_t wi
return(tex); 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,const ImageTiling tiling) Texture2D *RenderDevice::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 ImageTiling tiling)
{ {
Texture2D *tex=CreateTexture2D(format,width,height,aspectMask,usage,image_layout,tiling); Texture2D *tex=CreateTexture2D(format,width,height,aspectMask,usage,image_layout,tiling);
@ -157,7 +157,7 @@ Texture2D *Device::CreateTexture2D(const VkFormat format,void *data,uint32_t wid
if(data) if(data)
{ {
Buffer *buf=CreateBuffer(VK_BUFFER_USAGE_TRANSFER_SRC_BIT,size,data); GPUBuffer *buf=CreateBuffer(VK_BUFFER_USAGE_TRANSFER_SRC_BIT,size,data);
if(buf) if(buf)
{ {
@ -169,7 +169,7 @@ Texture2D *Device::CreateTexture2D(const VkFormat format,void *data,uint32_t wid
return(tex); return(tex);
} }
bool Device::ChangeTexture2D(Texture2D *tex,Buffer *buf,const VkBufferImageCopy *buffer_image_copy,const int count) bool RenderDevice::ChangeTexture2D(Texture2D *tex,GPUBuffer *buf,const VkBufferImageCopy *buffer_image_copy,const int count)
{ {
if(!tex||!buf) if(!tex||!buf)
return(false); return(false);
@ -226,7 +226,7 @@ bool Device::ChangeTexture2D(Texture2D *tex,Buffer *buf,const VkBufferImageCopy
return(true); return(true);
} }
bool Device::ChangeTexture2D(Texture2D *tex,Buffer *buf,const List<ImageRegion> &ir_list) bool RenderDevice::ChangeTexture2D(Texture2D *tex,GPUBuffer *buf,const List<ImageRegion> &ir_list)
{ {
if(!tex||!buf||ir_list.GetCount()<=0) if(!tex||!buf||ir_list.GetCount()<=0)
return(false); return(false);
@ -264,7 +264,7 @@ bool Device::ChangeTexture2D(Texture2D *tex,Buffer *buf,const List<ImageRegion>
return ChangeTexture2D(tex,buf,buffer_image_copy,ir_count); return ChangeTexture2D(tex,buf,buffer_image_copy,ir_count);
} }
bool Device::ChangeTexture2D(Texture2D *tex,Buffer *buf,uint32_t left,uint32_t top,uint32_t width,uint32_t height) bool RenderDevice::ChangeTexture2D(Texture2D *tex,GPUBuffer *buf,uint32_t left,uint32_t top,uint32_t width,uint32_t height)
{ {
if(!tex||!buf if(!tex||!buf
||left<0||left+width>tex->GetWidth() ||left<0||left+width>tex->GetWidth()
@ -290,7 +290,7 @@ bool Device::ChangeTexture2D(Texture2D *tex,Buffer *buf,uint32_t left,uint32_t t
return ChangeTexture2D(tex,buf,&buffer_image_copy,1); return ChangeTexture2D(tex,buf,&buffer_image_copy,1);
} }
bool Device::ChangeTexture2D(Texture2D *tex,void *data,uint32_t left,uint32_t top,uint32_t width,uint32_t height,uint32_t size) bool RenderDevice::ChangeTexture2D(Texture2D *tex,void *data,uint32_t left,uint32_t top,uint32_t width,uint32_t height,uint32_t size)
{ {
if(!tex||!data if(!tex||!data
||left<0||left+width>tex->GetWidth() ||left<0||left+width>tex->GetWidth()
@ -299,7 +299,7 @@ bool Device::ChangeTexture2D(Texture2D *tex,void *data,uint32_t left,uint32_t to
||size<=0) ||size<=0)
return(false); return(false);
Buffer *buf=CreateBuffer(VK_BUFFER_USAGE_TRANSFER_SRC_BIT,size,data); GPUBuffer *buf=CreateBuffer(VK_BUFFER_USAGE_TRANSFER_SRC_BIT,size,data);
bool result=ChangeTexture2D(tex,buf,left,top,width,height); bool result=ChangeTexture2D(tex,buf,left,top,width,height);
@ -308,7 +308,7 @@ bool Device::ChangeTexture2D(Texture2D *tex,void *data,uint32_t left,uint32_t to
return(result); return(result);
} }
bool Device::SubmitTexture(const VkCommandBuffer *cmd_bufs,const uint32_t count) bool RenderDevice::SubmitTexture(const VkCommandBuffer *cmd_bufs,const uint32_t count)
{ {
if(!cmd_bufs||count<=0) if(!cmd_bufs||count<=0)
return(false); return(false);
@ -319,7 +319,7 @@ bool Device::SubmitTexture(const VkCommandBuffer *cmd_bufs,const uint32_t count)
return(true); return(true);
} }
Sampler *Device::CreateSampler(VkSamplerCreateInfo *sci) Sampler *RenderDevice::CreateSampler(VkSamplerCreateInfo *sci)
{ {
static VkSamplerCreateInfo default_sampler_create_info= static VkSamplerCreateInfo default_sampler_create_info=
{ {

2
src/RenderDevice/VKFence.cpp
View File

@ -1,6 +1,6 @@
#include<hgl/graph/VKFence.h> #include<hgl/graph/VKFence.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
Fence::~Fence() GPUFence::~GPUFence()
{ {
vkDestroyFence(device,fence,nullptr); vkDestroyFence(device,fence,nullptr);
} }

8
src/RenderDevice/VKInstance.cpp
View File

@ -5,7 +5,7 @@
#include<iostream> #include<iostream>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
Device *CreateRenderDevice(VkInstance,const PhysicalDevice *,Window *); RenderDevice *CreateRenderDevice(VkInstance,const PhysicalRenderDevice *,Window *);
void CheckInstanceLayer(CharPointerList &layer_list,CreateInstanceLayerInfo *layer_info); void CheckInstanceLayer(CharPointerList &layer_list,CreateInstanceLayerInfo *layer_info);
@ -70,7 +70,7 @@ Instance::Instance(VkInstance i,VKDebugOut *out)
vkEnumeratePhysicalDevices(inst, &gpu_count,pd_list); vkEnumeratePhysicalDevices(inst, &gpu_count,pd_list);
for(uint32_t i=0;i<gpu_count;i++) for(uint32_t i=0;i<gpu_count;i++)
physical_devices.Add(new PhysicalDevice(inst,pd_list[i])); physical_devices.Add(new PhysicalRenderDevice(inst,pd_list[i]));
delete[] pd_list; delete[] pd_list;
} }
@ -84,10 +84,10 @@ Instance::~Instance()
vkDestroyInstance(inst,nullptr); vkDestroyInstance(inst,nullptr);
} }
const PhysicalDevice *Instance::GetDevice(VkPhysicalDeviceType type)const const PhysicalRenderDevice *Instance::GetDevice(VkPhysicalDeviceType type)const
{ {
const uint32_t count=physical_devices.GetCount(); const uint32_t count=physical_devices.GetCount();
PhysicalDevice **pd=physical_devices.GetData(); PhysicalRenderDevice **pd=physical_devices.GetData();
for(uint32_t i=0;i<count;i++) for(uint32_t i=0;i<count;i++)
{ {

6
src/RenderDevice/VKMaterial.cpp
View File

@ -7,7 +7,7 @@
#include<hgl/graph/VKBuffer.h> #include<hgl/graph/VKBuffer.h>
#include"VKDescriptorSetLayoutCreater.h" #include"VKDescriptorSetLayoutCreater.h"
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
Material *Device::CreateMaterial(ShaderModuleMap *shader_maps) Material *RenderDevice::CreateMaterial(ShaderModuleMap *shader_maps)
{ {
const int shader_count=shader_maps->GetCount(); const int shader_count=shader_maps->GetCount();
@ -49,7 +49,7 @@ Material *Device::CreateMaterial(ShaderModuleMap *shader_maps)
return(new Material(shader_maps,shader_stage_list,dsl_creater)); return(new Material(shader_maps,shader_stage_list,dsl_creater));
} }
Material *Device::CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *fragment_shader_module) Material *RenderDevice::CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *fragment_shader_module)
{ {
if(!vertex_shader_module||!fragment_shader_module) if(!vertex_shader_module||!fragment_shader_module)
return(nullptr); return(nullptr);
@ -65,7 +65,7 @@ Material *Device::CreateMaterial(const VertexShaderModule *vertex_shader_module,
return CreateMaterial(smm); return CreateMaterial(smm);
} }
Material *Device::CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *geometry_shader_module,const ShaderModule *fragment_shader_module) Material *RenderDevice::CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *geometry_shader_module,const ShaderModule *fragment_shader_module)
{ {
if(!vertex_shader_module if(!vertex_shader_module
||!geometry_shader_module ||!geometry_shader_module

2
src/RenderDevice/VKMaterialInstance.cpp
View File

@ -15,7 +15,7 @@ MaterialInstance::~MaterialInstance()
delete descriptor_sets; delete descriptor_sets;
} }
bool MaterialInstance::BindUBO(const AnsiString &name,vulkan::Buffer *ubo) bool MaterialInstance::BindUBO(const AnsiString &name,vulkan::GPUBuffer *ubo)
{ {
if(name.IsEmpty()||!ubo) if(name.IsEmpty()||!ubo)
return(false); return(false);

18
src/RenderDevice/VKMemory.cpp
View File

@ -2,7 +2,7 @@
#include<hgl/graph/VKMemory.h> #include<hgl/graph/VKMemory.h>
#include<hgl/graph/VKPhysicalDevice.h> #include<hgl/graph/VKPhysicalDevice.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
Memory *Device::CreateMemory(const VkMemoryRequirements &req,uint32_t properties) GPUMemory *RenderDevice::CreateMemory(const VkMemoryRequirements &req,uint32_t properties)
{ {
uint32_t index; uint32_t index;
@ -21,15 +21,15 @@ Memory *Device::CreateMemory(const VkMemoryRequirements &req,uint32_t properties
if(vkAllocateMemory(attr->device,&alloc_info,nullptr,&memory)!=VK_SUCCESS) if(vkAllocateMemory(attr->device,&alloc_info,nullptr,&memory)!=VK_SUCCESS)
return(nullptr); return(nullptr);
return(new Memory(attr->device,memory,req,index,properties)); return(new GPUMemory(attr->device,memory,req,index,properties));
} }
Memory::~Memory() GPUMemory::~GPUMemory()
{ {
vkFreeMemory(device,memory,nullptr); vkFreeMemory(device,memory,nullptr);
} }
void *Memory::Map() void *GPUMemory::Map()
{ {
void *result; void *result;
@ -39,7 +39,7 @@ void *Memory::Map()
return(nullptr); return(nullptr);
} }
void *Memory::Map(const VkDeviceSize offset,const VkDeviceSize size) void *GPUMemory::Map(const VkDeviceSize offset,const VkDeviceSize size)
{ {
if(offset<0||offset+size>=req.size) if(offset<0||offset+size>=req.size)
return(nullptr); return(nullptr);
@ -52,12 +52,12 @@ void *Memory::Map(const VkDeviceSize offset,const VkDeviceSize size)
return(nullptr); return(nullptr);
} }
void Memory::Unmap() void GPUMemory::Unmap()
{ {
vkUnmapMemory(device,memory); vkUnmapMemory(device,memory);
} }
bool Memory::Write(const void *ptr,VkDeviceSize start,VkDeviceSize size) bool GPUMemory::Write(const void *ptr,VkDeviceSize start,VkDeviceSize size)
{ {
if(!ptr)return(false); if(!ptr)return(false);
@ -71,14 +71,14 @@ bool Memory::Write(const void *ptr,VkDeviceSize start,VkDeviceSize size)
return(true); return(true);
} }
bool Memory::BindBuffer(VkBuffer buffer) bool GPUMemory::BindBuffer(VkBuffer buffer)
{ {
if(!buffer)return(false); if(!buffer)return(false);
return(vkBindBufferMemory(device,buffer,memory,0)==VK_SUCCESS); return(vkBindBufferMemory(device,buffer,memory,0)==VK_SUCCESS);
} }
bool Memory::BindImage(VkImage image) bool GPUMemory::BindImage(VkImage image)
{ {
if(!image)return(false); if(!image)return(false);

22
src/RenderDevice/VKPhysicalDevice.cpp
View File

@ -1,7 +1,7 @@
#include<hgl/graph/VKPhysicalDevice.h> #include<hgl/graph/VKPhysicalDevice.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
PhysicalDevice::PhysicalDevice(VkInstance inst,VkPhysicalDevice pd) PhysicalRenderDevice::PhysicalRenderDevice(VkInstance inst,VkPhysicalDevice pd)
{ {
instance=inst; instance=inst;
physical_device=pd; physical_device=pd;
@ -31,19 +31,19 @@ PhysicalDevice::PhysicalDevice(VkInstance inst,VkPhysicalDevice pd)
vkGetPhysicalDeviceFeatures(physical_device,&features); vkGetPhysicalDeviceFeatures(physical_device,&features);
vkGetPhysicalDeviceMemoryProperties(physical_device,&memory_properties); vkGetPhysicalDeviceMemoryProperties(physical_device,&memory_properties);
PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2=nullptr; PFN_vkGetPhysicalDeviceProperties2 GetPhysicalRenderDeviceProperties2=nullptr;
if(GetExtensionSpecVersion(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) if(GetExtensionSpecVersion(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME))
GetPhysicalDeviceProperties2=(PFN_vkGetPhysicalDeviceProperties2KHR)vkGetInstanceProcAddr(instance,"vkGetPhysicalDeviceProperties2KHR"); GetPhysicalRenderDeviceProperties2=(PFN_vkGetPhysicalDeviceProperties2KHR)vkGetInstanceProcAddr(instance,"vkGetPhysicalDeviceProperties2KHR");
if(!GetPhysicalDeviceProperties2) if(!GetPhysicalRenderDeviceProperties2)
if(GetExtensionSpecVersion(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)) if(GetExtensionSpecVersion(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME))
GetPhysicalDeviceProperties2=(PFN_vkGetPhysicalDeviceProperties2)vkGetInstanceProcAddr(instance,"vkGetPhysicalDeviceProperties2"); GetPhysicalRenderDeviceProperties2=(PFN_vkGetPhysicalDeviceProperties2)vkGetInstanceProcAddr(instance,"vkGetPhysicalDeviceProperties2");
if(GetPhysicalDeviceProperties2) if(GetPhysicalRenderDeviceProperties2)
{ {
VkPhysicalDeviceProperties2KHR properties2; VkPhysicalDeviceProperties2KHR properties2;
GetPhysicalDeviceProperties2(physical_device,&properties2); GetPhysicalRenderDeviceProperties2(physical_device,&properties2);
hgl_cpy(properties,properties2.properties); hgl_cpy(properties,properties2.properties);
@ -58,7 +58,7 @@ PhysicalDevice::PhysicalDevice(VkInstance inst,VkPhysicalDevice pd)
} }
} }
const uint32_t PhysicalDevice::GetExtensionSpecVersion(const AnsiString &name)const const uint32_t PhysicalRenderDevice::GetExtensionSpecVersion(const AnsiString &name)const
{ {
const uint count=extension_properties.GetCount(); const uint count=extension_properties.GetCount();
const VkExtensionProperties *ep=extension_properties.GetData(); const VkExtensionProperties *ep=extension_properties.GetData();
@ -72,7 +72,7 @@ const uint32_t PhysicalDevice::GetExtensionSpecVersion(const AnsiString &name)co
return 0; return 0;
} }
const bool PhysicalDevice::CheckMemoryType(uint32_t typeBits,VkMemoryPropertyFlags properties,uint32_t *typeIndex)const const bool PhysicalRenderDevice::CheckMemoryType(uint32_t typeBits,VkMemoryPropertyFlags properties,uint32_t *typeIndex)const
{ {
// Search memtypes to find first index with those properties // Search memtypes to find first index with those properties
for(uint32_t i=0; i<memory_properties.memoryTypeCount; i++) for(uint32_t i=0; i<memory_properties.memoryTypeCount; i++)
@ -92,7 +92,7 @@ const bool PhysicalDevice::CheckMemoryType(uint32_t typeBits,VkMemoryPropertyFla
return false; return false;
} }
VkFormat PhysicalDevice::GetDepthFormat(bool lower_to_high)const VkFormat PhysicalRenderDevice::GetDepthFormat(bool lower_to_high)const
{ {
constexpr VkFormat depthFormats[] = constexpr VkFormat depthFormats[] =
{ {
@ -120,7 +120,7 @@ VkFormat PhysicalDevice::GetDepthFormat(bool lower_to_high)const
return result; return result;
} }
VkFormat PhysicalDevice::GetDepthStencilFormat(bool lower_to_high)const VkFormat PhysicalRenderDevice::GetDepthStencilFormat(bool lower_to_high)const
{ {
constexpr VkFormat depthStencilFormats[] = constexpr VkFormat depthStencilFormats[] =
{ {

4
src/RenderDevice/VKPipeline.cpp
View File

@ -40,7 +40,7 @@ Pipeline *CreatePipeline(VkDevice device,VkPipelineCache pipeline_cache,Pipeline
return(new Pipeline(device,graphicsPipeline,data)); return(new Pipeline(device,graphicsPipeline,data));
} }
Pipeline *Device::CreatePipeline(const InlinePipeline &ip,const Material *mtl,const RenderTarget *rt) Pipeline *RenderDevice::CreatePipeline(const InlinePipeline &ip,const Material *mtl,const RenderTarget *rt)
{ {
PipelineData *pd=GetPipelineData(ip); PipelineData *pd=GetPipelineData(ip);
@ -49,7 +49,7 @@ Pipeline *Device::CreatePipeline(const InlinePipeline &ip,const Material *mtl,co
return VK_NAMESPACE::CreatePipeline(attr->device,attr->pipeline_cache,pd,mtl,rt); return VK_NAMESPACE::CreatePipeline(attr->device,attr->pipeline_cache,pd,mtl,rt);
} }
Pipeline *Device::CreatePipeline(PipelineData *pd,const Material *mtl,const RenderTarget *rt) Pipeline *RenderDevice::CreatePipeline(PipelineData *pd,const Material *mtl,const RenderTarget *rt)
{ {
return VK_NAMESPACE::CreatePipeline(attr->device,attr->pipeline_cache,pd,mtl,rt); return VK_NAMESPACE::CreatePipeline(attr->device,attr->pipeline_cache,pd,mtl,rt);
} }

6
src/RenderDevice/VKRenderTarget.cpp
View File

@ -5,7 +5,7 @@
#include<hgl/graph/VKSemaphore.h> #include<hgl/graph/VKSemaphore.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
RenderTarget::RenderTarget(Device *dev,Framebuffer *_fb,CommandBuffer *_cb,const uint32_t fence_count):SubmitQueue(dev,dev->GetGraphicsQueue(),fence_count) RenderTarget::RenderTarget(RenderDevice *dev,Framebuffer *_fb,CommandBuffer *_cb,const uint32_t fence_count):SubmitQueue(dev,dev->GetGraphicsQueue(),fence_count)
{ {
rp=nullptr; rp=nullptr;
fb=_fb; fb=_fb;
@ -21,7 +21,7 @@ RenderTarget::RenderTarget(Device *dev,Framebuffer *_fb,CommandBuffer *_cb,const
render_complete_semaphore=dev->CreateSemaphore(); render_complete_semaphore=dev->CreateSemaphore();
} }
RenderTarget::RenderTarget(Device *dev,RenderPass *_rp,Framebuffer *_fb,CommandBuffer *_cb,Texture2D **ctl,const uint32_t cc,Texture2D *dt,const uint32_t fence_count):SubmitQueue(dev,dev->GetGraphicsQueue(),fence_count) RenderTarget::RenderTarget(RenderDevice *dev,RenderPass *_rp,Framebuffer *_fb,CommandBuffer *_cb,Texture2D **ctl,const uint32_t cc,Texture2D *dt,const uint32_t fence_count):SubmitQueue(dev,dev->GetGraphicsQueue(),fence_count)
{ {
rp=_rp; rp=_rp;
fb=_fb; fb=_fb;
@ -68,7 +68,7 @@ bool RenderTarget::Submit(GPUSemaphore *present_complete_semaphore)
return this->SubmitQueue::Submit(*command_buffer,present_complete_semaphore,render_complete_semaphore); return this->SubmitQueue::Submit(*command_buffer,present_complete_semaphore,render_complete_semaphore);
} }
SwapchainRenderTarget::SwapchainRenderTarget(Device *dev,Swapchain *sc):RenderTarget(dev,nullptr,nullptr,sc->GetImageCount()) SwapchainRenderTarget::SwapchainRenderTarget(RenderDevice *dev,Swapchain *sc):RenderTarget(dev,nullptr,nullptr,sc->GetImageCount())
{ {
swapchain=sc; swapchain=sc;
vk_swapchain=swapchain->GetSwapchain(); vk_swapchain=swapchain->GetSwapchain();

2
src/RenderDevice/VKShaderModule.cpp
View File

@ -3,7 +3,7 @@
#include<hgl/graph/VKDevice.h> #include<hgl/graph/VKDevice.h>
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
ShaderModule *Device::CreateShaderModule(ShaderResource *sr) ShaderModule *RenderDevice::CreateShaderModule(ShaderResource *sr)
{ {
if(!sr)return(nullptr); if(!sr)return(nullptr);

2
src/RenderDevice/VKSubmitQueue.cpp
View File

@ -8,7 +8,7 @@ namespace
const VkPipelineStageFlags pipe_stage_flags=VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; const VkPipelineStageFlags pipe_stage_flags=VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
}//namespace }//namespace
SubmitQueue::SubmitQueue(Device *dev,VkQueue q,const uint32_t fence_count) SubmitQueue::SubmitQueue(RenderDevice *dev,VkQueue q,const uint32_t fence_count)
{ {
device=dev; device=dev;
queue=q; queue=q;

8
src/RenderDevice/VKTextureLoader.cpp
View File

@ -90,16 +90,16 @@ namespace
{ {
protected: protected:
Device *device; RenderDevice *device;
VkFormat format; VkFormat format;
vulkan::Buffer *buf; vulkan::GPUBuffer *buf;
Texture2D *tex; Texture2D *tex;
public: public:
VkTexture2DLoader(Device *dev):device(dev) VkTexture2DLoader(RenderDevice *dev):device(dev)
{ {
buf=nullptr; buf=nullptr;
format=VK_FORMAT_UNDEFINED; format=VK_FORMAT_UNDEFINED;
@ -169,7 +169,7 @@ namespace
};//class VkTexture2DLoader };//class VkTexture2DLoader
}//namespace }//namespace
Texture2D *CreateTextureFromFile(Device *device,const OSString &filename) Texture2D *CreateTextureFromFile(RenderDevice *device,const OSString &filename)
{ {
VkTexture2DLoader loader(device); VkTexture2DLoader loader(device);

2
src/RenderDevice/VKTileData.cpp
View File

@ -61,7 +61,7 @@ namespace
}//namespace }//namespace
VK_NAMESPACE_BEGIN VK_NAMESPACE_BEGIN
TileData *Device::CreateTileData(const VkFormat format,const uint width,const uint height,const uint count) TileData *RenderDevice::CreateTileData(const VkFormat format,const uint width,const uint height,const uint count)
{ {
if(!CheckVulkanFormat(format)) if(!CheckVulkanFormat(format))
return(nullptr); return(nullptr);

2
src/RenderDevice/VKTileFont.cpp
View File

@ -7,7 +7,7 @@ VK_NAMESPACE_BEGIN
* @param f 字体需求信息 * @param f 字体需求信息
* @param limit_count 缓冲字符数量上限 * @param limit_count 缓冲字符数量上限
*/ */
TileFont *Device::CreateTileFont(FontSource *fs,int limit_count) TileFont *RenderDevice::CreateTileFont(FontSource *fs,int limit_count)
{ {
if(!fs)return(nullptr); if(!fs)return(nullptr);

2
src/SceneGraph/TileData.cpp
View File

@ -7,7 +7,7 @@ namespace hgl
{ {
namespace graph namespace graph
{ {
TileData::TileData(Device *dev,Texture2D *tt,const uint tw,const uint th) TileData::TileData(RenderDevice *dev,Texture2D *tt,const uint tw,const uint th)
{ {
device=dev; device=dev;

2
src/SceneGraph/font/TextRenderable.cpp
View File

@ -6,7 +6,7 @@ namespace hgl
{ {
namespace graph namespace graph
{ {
TextRenderable::TextRenderable(vulkan::Device *dev,vulkan::Material *m,uint mc):vulkan::Renderable(mc) TextRenderable::TextRenderable(vulkan::RenderDevice *dev,vulkan::Material *m,uint mc):vulkan::Renderable(mc)
{ {
device=dev; device=dev;
mtl=m; mtl=m;