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:39:22 +08:00
parent a20afeba9e
commit 0e56a6b00c
69 changed files with 304 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
example/Vulkan/Atomsphere.cpp
View File

@ -4,7 +4,7 @@
#include"VulkanAppFramework.h"
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKDatabase.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/VKRenderableInstance.h>
#include<hgl/graph/RenderList.h>
@ -40,7 +40,7 @@ private:
vulkan::MaterialInstance * material_instance =nullptr;
vulkan::Pipeline * pipeline_solid =nullptr;
vulkan::GPUBuffer * ubo_atomsphere =nullptr;
vulkan::GPUBuffer * ubo_atomsphere =nullptr;
AtmosphereData atomsphere_data;
vulkan::Renderable * ro_sphere =nullptr;

6
example/Vulkan/DeferredModel.cpp
View File

@ -4,7 +4,7 @@
#include"VulkanAppFramework.h"
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKDatabase.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/VKRenderableInstance.h>
#include<hgl/graph/RenderList.h>
#include<hgl/graph/VKTexture.h>
@ -16,7 +16,7 @@ using namespace hgl;
using namespace hgl::graph;
VK_NAMESPACE_BEGIN
Texture2D *CreateTextureFromFile(RenderDevice *device,const OSString &filename);
Texture2D *CreateTextureFromFile(GPUDevice *device,const OSString &filename);
VK_NAMESPACE_END
constexpr uint32_t SCREEN_WIDTH=512;
@ -61,7 +61,7 @@ private:
Texture2DPointer normal=nullptr;
}texture;
vulkan::CommandBuffer *gbuffer_cmd=nullptr;
vulkan::GPUCmdBuffer *gbuffer_cmd=nullptr;
public:

2
example/Vulkan/Geometry2D.cpp
View File

@ -7,7 +7,7 @@
#include"VulkanAppFramework.h"
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKDatabase.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/VKRenderableInstance.h>
#include<hgl/graph/RenderList.h>

2
example/Vulkan/Geometry3D.cpp
View File

@ -3,7 +3,7 @@
#include"VulkanAppFramework.h"
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKDatabase.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/RenderList.h>
using namespace hgl;

2
example/Vulkan/HQFilterTexture.cpp
View File

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

2
example/Vulkan/InlineGeometryScene.cpp
View File

@ -4,7 +4,7 @@
#include"VulkanAppFramework.h"
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKDatabase.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/VKRenderableInstance.h>
#include<hgl/graph/RenderList.h>

2
example/Vulkan/RectanglePrimitive.cpp
View File

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

8
example/Vulkan/TextureFormat.cpp
View File

@ -35,7 +35,7 @@ constexpr char *data_type_name[]
"SRGB"
};//
vulkan::Instance *InitVulkanInstance()
vulkan::VulkanInstance *InitVulkanInstance()
{
#ifdef _DEBUG
if(!CheckStrideBytesByFormat())
@ -62,9 +62,9 @@ vulkan::Instance *InitVulkanInstance()
int main(int,char **)
{
Window * win =nullptr;
vulkan::Instance * inst =nullptr;
vulkan::RenderDevice * device =nullptr;
const vulkan::PhysicalRenderDevice *physical_device =nullptr;
vulkan::VulkanInstance * inst =nullptr;
vulkan::GPUDevice * device =nullptr;
const vulkan::GPUPhysicalDevice *physical_device =nullptr;
inst=InitVulkanInstance();

2
example/Vulkan/texture_rect.cpp
View File

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

20
example/common/VulkanAppFramework.h
View File

@ -17,7 +17,7 @@
#include<hgl/graph/VKMaterial.h>
#include<hgl/graph/VKMaterialInstance.h>
#include<hgl/graph/VKRenderTarget.h>
#include<hgl/graph/VKDatabase.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/RenderList.h>
using namespace hgl;
@ -28,7 +28,7 @@ class VulkanApplicationFramework
private:
Window * win =nullptr;
vulkan::Instance * inst =nullptr;
vulkan::VulkanInstance * inst =nullptr;
void OnKeyDown (KeyboardButton kb){key_status[kb]=true;}
void OnKeyUp (KeyboardButton kb){key_status[kb]=false;}
@ -46,20 +46,20 @@ protected:
protected:
vulkan::RenderDevice * device =nullptr;
vulkan::GPUDevice * device =nullptr;
vulkan::SwapchainRenderTarget * sc_render_target =nullptr;
protected:
int32_t swap_chain_count =0;
vulkan::CommandBuffer ** cmd_buf =nullptr;
vulkan::GPUCmdBuffer ** cmd_buf =nullptr;
Color4f clear_color;
protected:
vulkan::Database * db =nullptr;
vulkan::RenderResource * db =nullptr;
bool key_status[kbRangeSize];
@ -117,7 +117,7 @@ public:
if(!device)
return(false);
db=new vulkan::Database(device);
db=new vulkan::RenderResource(device);
InitCommandBuffer();
@ -161,7 +161,7 @@ public:
{
const VkExtent2D extent=sc_render_target->GetExtent();
cmd_buf=hgl_zero_new<vulkan::CommandBuffer *>(swap_chain_count);
cmd_buf=hgl_zero_new<vulkan::GPUCmdBuffer *>(swap_chain_count);
for(int32_t i=0;i<swap_chain_count;i++)
cmd_buf[i]=device->CreateCommandBuffer(extent,2);
@ -173,7 +173,7 @@ public:
if(!rt||!ri)
return;
vulkan::CommandBuffer *cb=rt->GetCommandBuffer();
vulkan::GPUCmdBuffer *cb=rt->GetCommandBuffer();
const vulkan::IndexBuffer *ib=ri->GetIndexBuffer();
cb->Begin();
@ -203,7 +203,7 @@ public:
const vulkan::IndexBuffer *ib=ri->GetIndexBuffer();
vulkan::CommandBuffer *cb=cmd_buf[index];
vulkan::GPUCmdBuffer *cb=cmd_buf[index];
cb->SetClearColor(0,clear_color.r,clear_color.g,clear_color.b);
@ -237,7 +237,7 @@ public:
{
if(!rl)return;
vulkan::CommandBuffer *cb=cmd_buf[index];
vulkan::GPUCmdBuffer *cb=cmd_buf[index];
cb->SetClearColor(0,clear_color.r,clear_color.g,clear_color.b);

28
inc/hgl/graph/InlineGeometry.h
View File

@ -17,12 +17,12 @@ namespace hgl
RectScope2f scope;
};//struct RectangleCreateInfo
vulkan::Renderable *CreateRenderableRectangle(vulkan::Database *db,vulkan::Material *mtl,const RectangleCreateInfo *rci);
vulkan::Renderable *CreateRenderableRectangle(vulkan::RenderResource *db,vulkan::Material *mtl,const RectangleCreateInfo *rci);
/**
* 创建延迟渲染用全屏平面
*/
vulkan::Renderable *CreateRenderableGBufferComposition(vulkan::Database *db,vulkan::Material *mtl);
vulkan::Renderable *CreateRenderableGBufferComposition(vulkan::RenderResource *db,vulkan::Material *mtl);
/**
* 圆角矩形创建信息(扇形/线圈)
@ -33,7 +33,7 @@ namespace hgl
uint32_t round_per; ///<圆角精度
};//struct RoundRectangleCreateInfo:public RectangleCreateInfo
vulkan::Renderable *CreateRenderableRoundRectangle(vulkan::Database *db,vulkan::Material *mtl,const RoundRectangleCreateInfo *rci);
vulkan::Renderable *CreateRenderableRoundRectangle(vulkan::RenderResource *db,vulkan::Material *mtl,const RoundRectangleCreateInfo *rci);
/**
* 圆形创建信息
@ -53,7 +53,7 @@ namespace hgl
/**
* 创建一个2D圆形(扇形/线圈)
*/
vulkan::Renderable *CreateRenderableCircle(vulkan::Database *db,vulkan::Material *mtl,const CircleCreateInfo *cci);
vulkan::Renderable *CreateRenderableCircle(vulkan::RenderResource *db,vulkan::Material *mtl,const CircleCreateInfo *cci);
/**
* 平面网格创建信息
@ -72,7 +72,7 @@ namespace hgl
/**
* 创建一个平面网格(线条)
*/
vulkan::Renderable *CreateRenderablePlaneGrid(vulkan::Database *db,vulkan::Material *mtl,const PlaneGridCreateInfo *pgci);
vulkan::Renderable *CreateRenderablePlaneGrid(vulkan::RenderResource *db,vulkan::Material *mtl,const PlaneGridCreateInfo *pgci);
struct PlaneCreateInfo
{
@ -89,7 +89,7 @@ namespace hgl
/**
* 创建一个平面(三角形)
*/
vulkan::Renderable *CreateRenderablePlane(vulkan::Database *db,vulkan::Material *mtl,const PlaneCreateInfo *pci);
vulkan::Renderable *CreateRenderablePlane(vulkan::RenderResource *db,vulkan::Material *mtl,const PlaneCreateInfo *pci);
struct CubeCreateInfo
{
@ -129,17 +129,17 @@ namespace hgl
/**
* 创建一个立方体(三角形)
*/
vulkan::Renderable *CreateRenderableCube(vulkan::Database *db,vulkan::Material *mtl,const CubeCreateInfo *cci);
vulkan::Renderable *CreateRenderableCube(vulkan::RenderResource *db,vulkan::Material *mtl,const CubeCreateInfo *cci);
/**
* 创建一个绑定盒(线条)
*/
vulkan::Renderable *CreateRenderableBoundingBox(vulkan::Database *db,vulkan::Material *mtl,const CubeCreateInfo *cci);
vulkan::Renderable *CreateRenderableBoundingBox(vulkan::RenderResource *db,vulkan::Material *mtl,const CubeCreateInfo *cci);
/**
* 创建一个球心坐标为0,0,0，半径为1的球体(三角形)
*/
vulkan::Renderable *CreateRenderableSphere(vulkan::Database *db,vulkan::Material *mtl,const uint numberSlices);
vulkan::Renderable *CreateRenderableSphere(vulkan::RenderResource *db,vulkan::Material *mtl,const uint numberSlices);
struct DomeCreateInfo
{
@ -150,7 +150,7 @@ namespace hgl
/**
* 创建一个穹顶(三角形)
*/
vulkan::Renderable *CreateRenderableDome(vulkan::Database *db,vulkan::Material *mtl, const DomeCreateInfo *);
vulkan::Renderable *CreateRenderableDome(vulkan::RenderResource *db,vulkan::Material *mtl, const DomeCreateInfo *);
struct TorusCreateInfo
{
@ -164,7 +164,7 @@ namespace hgl
/**
* 创建一个圆环(三角形)
*/
vulkan::Renderable *CreateRenderableTorus(vulkan::Database *db,vulkan::Material *mtl,const TorusCreateInfo *tci);
vulkan::Renderable *CreateRenderableTorus(vulkan::RenderResource *db,vulkan::Material *mtl,const TorusCreateInfo *tci);
struct CylinderCreateInfo
{
@ -176,7 +176,7 @@ namespace hgl
/**
* 创建一个圆柱(三角形)
*/
vulkan::Renderable *CreateRenderableCylinder(vulkan::Database *db,vulkan::Material *mtl,const CylinderCreateInfo *cci);
vulkan::Renderable *CreateRenderableCylinder(vulkan::RenderResource *db,vulkan::Material *mtl,const CylinderCreateInfo *cci);
struct ConeCreateInfo
{
@ -189,7 +189,7 @@ namespace hgl
/**
* 创建一个圆锥(三角形)
*/
vulkan::Renderable *CreateRenderableCone(vulkan::Database *db,vulkan::Material *mtl,const ConeCreateInfo *cci);
vulkan::Renderable *CreateRenderableCone(vulkan::RenderResource *db,vulkan::Material *mtl,const ConeCreateInfo *cci);
struct AxisCreateInfo
{
@ -229,7 +229,7 @@ namespace hgl
/**
* 创建一个坐标线(线条)
*/
vulkan::Renderable *CreateRenderableAxis(vulkan::Database *db,vulkan::Material *mtl,const AxisCreateInfo *aci);
vulkan::Renderable *CreateRenderableAxis(vulkan::RenderResource *db,vulkan::Material *mtl,const AxisCreateInfo *aci);
}//namespace graph
};//namespace hgl
#endif//HGL_GRAPH_INLINE_GEOMETRY_INCLUDE

4
inc/hgl/graph/RenderList.h
View File

@ -11,7 +11,7 @@ namespace hgl
{
class RenderList
{
vulkan::CommandBuffer *cmd_buf;
vulkan::GPUCmdBuffer *cmd_buf;
private:
@ -41,7 +41,7 @@ namespace hgl
void Add (SceneNode *node) {if(node)scene_node_list.Add(node);}
void Clear () {scene_node_list.ClearData();}
bool Render(vulkan::CommandBuffer *);
bool Render(vulkan::GPUCmdBuffer *);
};//class RenderList
}//namespace graph
}//namespace hgl

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

@ -1,7 +1,7 @@
#ifndef HGL_GRAPH_RENDERABLE_CREATER_INCLUDE
#define HGL_GRAPH_RENDERABLE_CREATER_INCLUDE
#include<hgl/graph/VKDatabase.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/VertexAttribDataAccess.h>
#include<hgl/graph/VKShaderModule.h>
namespace hgl
@ -32,7 +32,7 @@ namespace hgl
{
protected:
vulkan::Database *db;
vulkan::RenderResource *db;
vulkan::Material *mtl;
const vulkan::VertexShaderModule *vsm;
@ -50,7 +50,7 @@ namespace hgl
public:
RenderableCreater(vulkan::Database *sdb,vulkan::Material *m);
RenderableCreater(vulkan::RenderResource *sdb,vulkan::Material *m);
virtual ~RenderableCreater()=default;
virtual bool Init(const uint32 count); ///<初始化，参数为顶点数量

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

@ -33,7 +33,7 @@ namespace hgl
*/
class TileData ///Tile纹理管理
{
RenderDevice *device;
GPUDevice *device;
protected:
@ -67,7 +67,7 @@ namespace hgl
public:
TileData(RenderDevice *,Texture2D *,const uint tw,const uint th);
TileData(GPUDevice *,Texture2D *,const uint tw,const uint th);
virtual ~TileData();
void BeginCommit();

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

@ -13,10 +13,10 @@ VK_NAMESPACE_BEGIN
using CharPointerList=hgl::List<const char *>;
class Instance;
class PhysicalRenderDevice;
class RenderDevice;
struct RenderDeviceAttribute;
class VulkanInstance;
class GPUPhysicalDevice;
class GPUDevice;
struct GPUDeviceAttribute;
class ImageView;
class Framebuffer;
struct Swapchain;
@ -36,14 +36,14 @@ class Sampler;
class GPUMemory;
class GPUBuffer;
struct BufferData;
struct GPUBufferData;
class VertexAttribBuffer;
using VAB=VertexAttribBuffer;
class IndexBuffer;
class CommandBuffer;
class GPUCmdBuffer;
class RenderPass;
class GPUFence;
class GPUSemaphore;
@ -67,7 +67,7 @@ class VertexAttributeBinding;
class Renderable;
class RenderableInstance;
class Database;
class RenderResource;
enum class SharingMode
{

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

@ -4,27 +4,27 @@
#include<hgl/graph/VK.h>
#include<hgl/graph/VKMemory.h>
VK_NAMESPACE_BEGIN
struct BufferData
struct GPUBufferData
{
VkBuffer buffer;
GPUMemory * memory=nullptr;
GPUMemory * memory=nullptr;
VkDescriptorBufferInfo info;
};//struct BufferData
};//struct GPUBufferData
class GPUBuffer
{
protected:
VkDevice device;
BufferData buf;
GPUBufferData buf;
private:
friend class RenderDevice;
friend class GPUDevice;
friend class VertexAttribBuffer;
friend class IndexBuffer;
GPUBuffer(VkDevice d,const BufferData &b)
GPUBuffer(VkDevice d,const GPUBufferData &b)
{
device=d;
buf=b;
@ -55,9 +55,9 @@ class VertexAttribBuffer:public GPUBuffer
private:
friend class RenderDevice;
friend class GPUDevice;
VertexAttribBuffer(VkDevice d,const BufferData &vb,VkFormat fmt,uint32_t _stride,uint32_t _count):GPUBuffer(d,vb)
VertexAttribBuffer(VkDevice d,const GPUBufferData &vb,VkFormat fmt,uint32_t _stride,uint32_t _count):GPUBuffer(d,vb)
{
format=fmt;
stride=_stride;
@ -87,9 +87,9 @@ class IndexBuffer:public GPUBuffer
private:
friend class RenderDevice;
friend class GPUDevice;
IndexBuffer(VkDevice d,const BufferData &vb,IndexType it,uint32_t _count):GPUBuffer(d,vb)
IndexBuffer(VkDevice d,const GPUBufferData &vb,IndexType it,uint32_t _count):GPUBuffer(d,vb)
{
index_type=it;
count=_count;

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

@ -7,7 +7,7 @@
VK_NAMESPACE_BEGIN
//push constant 一般只有128/256字节，仅能存在矩阵。
//所以我们将每个对象的独立变换矩阵存在push constant中
class CommandBuffer
class GPUCmdBuffer
{
VkDevice device;
VkCommandPool pool;
@ -24,8 +24,8 @@ class CommandBuffer
public:
CommandBuffer(VkDevice dev,const VkExtent2D &extent,const uint32_t att_count,VkCommandPool cp,VkCommandBuffer cb);
~CommandBuffer();
GPUCmdBuffer(VkDevice dev,const VkExtent2D &extent,const uint32_t att_count,VkCommandPool cp,VkCommandBuffer cb);
~GPUCmdBuffer();
operator VkCommandBuffer(){return cmd_buf;}
operator const VkCommandBuffer()const{return cmd_buf;}
@ -122,6 +122,6 @@ public: //draw
void EndRenderPass(){vkCmdEndRenderPass(cmd_buf);}
bool End(){return(vkEndCommandBuffer(cmd_buf)==VK_SUCCESS);}
};//class CommandBuffer
};//class GPUCmdBuffer
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_COMMAND_BUFFER_INCLUDE

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

@ -26,12 +26,12 @@ namespace hgl
}//namespace hgl
VK_NAMESPACE_BEGIN
class RenderDevice
class GPUDevice
{
RenderDeviceAttribute *attr;
GPUDeviceAttribute *attr;
SubmitQueue *textureSQ;
CommandBuffer *texture_cmd_buf;
GPUQueue *textureSQ;
GPUCmdBuffer *texture_cmd_buf;
Swapchain *swapchain;
SwapchainRenderTarget *swapchainRT;
@ -43,20 +43,20 @@ class RenderDevice
private:
friend RenderDevice *CreateRenderDevice(VkInstance inst,const PhysicalRenderDevice *physical_device,VkSurfaceKHR surface,const VkExtent2D &extent);
friend GPUDevice *CreateRenderDevice(VkInstance inst,const GPUPhysicalDevice *physical_device,VkSurfaceKHR surface,const VkExtent2D &extent);
RenderDevice(RenderDeviceAttribute *da);
GPUDevice(GPUDeviceAttribute *da);
public:
virtual ~RenderDevice();
virtual ~GPUDevice();
operator VkDevice () {return attr->device;}
RenderDeviceAttribute * GetRenderDeviceAttribute () {return attr;}
GPUDeviceAttribute *GetGPUDeviceAttribute () {return attr;}
VkSurfaceKHR GetSurface () {return attr->surface;}
VkDevice GetDevice ()const {return attr->device;}
const PhysicalRenderDevice * GetPhysicalRenderDevice ()const {return attr->physical_device;}
const GPUPhysicalDevice * GetGPUPhysicalDevice()const {return attr->physical_device;}
VkDescriptorPool GetDescriptorPool () {return attr->desc_pool;}
VkPipelineCache GetPipelineCache () {return attr->pipeline_cache;}
@ -87,7 +87,7 @@ public: //内存相关
private: //Buffer相关
bool CreateBuffer(BufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode);
bool CreateBuffer(GPUBufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode);
public: //Buffer相关
@ -240,7 +240,7 @@ public: //shader & material
public: //Command GPUBuffer 相关
CommandBuffer * CreateCommandBuffer(const VkExtent2D &extent,const uint32_t atta_count);
GPUCmdBuffer * CreateCommandBuffer(const VkExtent2D &extent,const uint32_t atta_count);
RenderPass * CreateRenderPass( const List<VkAttachmentDescription> &desc_list,
const List<VkSubpassDescription> &subpass,
@ -312,7 +312,7 @@ public:
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字体
};//class RenderDevice
};//class GPUDevice
//void CreateSubpassDependency(VkSubpassDependency *);
void CreateSubpassDependency(List<VkSubpassDependency> &dependency,const uint32_t count);
@ -327,12 +327,12 @@ inline void CreateInputAttachmentReference(VkAttachmentReference *ref_list, uint
bool CreateColorAttachment( List<VkAttachmentReference> &ref_list,List<VkAttachmentDescription> &desc_list,const List<VkFormat> &color_format,const VkImageLayout color_final_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
bool CreateDepthAttachment( List<VkAttachmentReference> &ref_list,List<VkAttachmentDescription> &desc_list,const VkFormat &depth_format,const VkImageLayout depth_final_layout=VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
bool CreateAttachmentDescription( List<VkAttachmentDescription> &color_output_desc_list,
bool CreateAttachmentDescription( List<VkAttachmentDescription> &color_output_desc_list,
const List<VkFormat> &color_format,
const VkFormat depth_format,
const VkImageLayout color_final_layout=VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
const VkImageLayout depth_final_layout=VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
RenderDevice *CreateRenderDevice(Instance *inst,Window *win,const PhysicalRenderDevice *physical_device=nullptr);
GPUDevice *CreateRenderDevice(VulkanInstance *inst,Window *win,const GPUPhysicalDevice *physical_device=nullptr);
VK_NAMESPACE_END
#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;
struct RenderDeviceAttribute
struct GPUDeviceAttribute
{
VkInstance instance =VK_NULL_HANDLE;
const PhysicalRenderDevice * physical_device =nullptr;
const GPUPhysicalDevice * physical_device =nullptr;
VkSurfaceKHR surface =VK_NULL_HANDLE;
VkSurfaceCapabilitiesKHR surface_caps;
@ -39,11 +39,11 @@ struct RenderDeviceAttribute
public:
RenderDeviceAttribute(VkInstance inst,const PhysicalRenderDevice *pd,VkSurfaceKHR s);
~RenderDeviceAttribute();
GPUDeviceAttribute(VkInstance inst,const GPUPhysicalDevice *pd,VkSurfaceKHR s);
~GPUDeviceAttribute();
bool CheckMemoryType(uint32_t typeBits,VkMemoryPropertyFlags properties,uint32_t *typeIndex) const;
void Refresh();
};//class RenderDeviceAttribute
};//class GPUDeviceAttribute
VK_NAMESPACE_END

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

@ -10,7 +10,7 @@ class GPUFence
private:
friend class RenderDevice;
friend class GPUDevice;
GPUFence(VkDevice d,VkFence f)
{

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

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

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

@ -49,35 +49,35 @@ VK_NAMESPACE_BEGIN
};
#undef VK_BOOL1BIT
class Instance
class VulkanInstance
{
VkInstance inst;
VKDebugOut *debug_out;
ObjectList<PhysicalRenderDevice> physical_devices;
ObjectList<GPUPhysicalDevice> physical_devices;
private:
friend Instance *CreateInstance(const AnsiString &app_name,VKDebugOut *out=nullptr,CreateInstanceLayerInfo *cili=nullptr);
friend VulkanInstance *CreateInstance(const AnsiString &app_name,VKDebugOut *out=nullptr,CreateInstanceLayerInfo *cili=nullptr);
Instance(VkInstance,VKDebugOut *);
VulkanInstance(VkInstance,VKDebugOut *);
public:
virtual ~Instance();
virtual ~VulkanInstance();
operator VkInstance (){return inst;}
const ObjectList<PhysicalRenderDevice> &GetDeviceList ()const {return physical_devices;}
const PhysicalRenderDevice * GetDevice (VkPhysicalDeviceType)const;
};//class Instance
const ObjectList<GPUPhysicalDevice> &GetDeviceList ()const {return physical_devices;}
const GPUPhysicalDevice * GetDevice (VkPhysicalDeviceType)const;
};//class VulkanInstance
void InitVulkanProperties();
const List<VkLayerProperties> & GetLayerProperties();
const List<VkExtensionProperties> & GetExtensionProperties();
const bool CheckLayerSupport(const char *);
Instance *CreateInstance(const AnsiString &,VKDebugOut *,CreateInstanceLayerInfo *); ///<创建一个Vulkan实例
VulkanInstance *CreateInstance(const AnsiString &,VKDebugOut *,CreateInstanceLayerInfo *); ///<创建一个Vulkan实例
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_INSTANCE_INCLUDE

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

@ -13,7 +13,7 @@ class GPUMemory
private:
friend class RenderDevice;
friend class GPUDevice;
GPUMemory(VkDevice dev,VkDeviceMemory dm,const VkMemoryRequirements &mr,const uint32 i,const uint32_t p)
{

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

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

8
inc/hgl/graph/VKSubmitQueue.h → inc/hgl/graph/VKQueue.h
View File

@ -4,11 +4,11 @@
#include<hgl/graph/VK.h>
#include<hgl/graph/VKFence.h>
VK_NAMESPACE_BEGIN
class SubmitQueue
class GPUQueue
{
protected:
RenderDevice *device;
GPUDevice *device;
VkQueue queue;
uint32_t current_fence;
@ -18,8 +18,8 @@ protected:
public:
SubmitQueue(RenderDevice *dev,VkQueue q,const uint32_t fence_count=1);
virtual ~SubmitQueue();
GPUQueue(GPUDevice *dev,VkQueue q,const uint32_t fence_count=1);
virtual ~GPUQueue();
bool WaitQueue();
bool WaitFence(const bool wait_all=true,const uint64_t time_out=HGL_NANO_SEC_PER_SEC);

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

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

12
inc/hgl/graph/VKDatabase.h → inc/hgl/graph/VKRenderResource.h
View File

@ -29,9 +29,9 @@ class VertexAttribData;
/**
* 资源管理，用于管理场景内所需的所有数据
*/
class Database
class RenderResource
{
RenderDevice *device;
GPUDevice *device;
MapObject<OSString,ShaderModule> shader_module_by_name;
Map<OSString,Material *> material_by_name;
@ -41,15 +41,15 @@ class Database
IDResManage<PipelineID, Pipeline> rm_pipeline; ///<管线合集
IDResManage<DescriptorSetsID, DescriptorSets> rm_desc_sets; ///<描述符合集
IDResManage<RenderableID, Renderable> rm_renderables; ///<可渲染对象合集
IDResManage<BufferID, GPUBuffer> rm_buffers; ///<顶点缓冲区合集
IDResManage<BufferID, GPUBuffer> rm_buffers; ///<顶点缓冲区合集
IDResManage<SamplerID, Sampler> rm_samplers; ///<采样器合集
IDResManage<TextureID, Texture> rm_textures; ///<纹理合集
IDResManage<RenderableInstanceID, RenderableInstance> rm_renderable_instances; ///<渲染实例集合集
public:
Database(RenderDevice *dev):device(dev){}
virtual ~Database()=default;
RenderResource(GPUDevice *dev):device(dev){}
virtual ~RenderResource()=default;
public: //Add
@ -123,6 +123,6 @@ public: //Get
Sampler * GetSampler (const SamplerID &id){return rm_samplers.Get(id);}
Texture * GetTexture (const TextureID &id){return rm_textures.Get(id);}
RenderableInstance *GetRenderableInstance (const RenderableInstanceID &id){return rm_renderable_instances.Get(id);}
};//class Database
};//class RenderResource
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_DATABASE_INCLUDE

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

@ -5,12 +5,12 @@
#include<hgl/graph/VKRenderPass.h>
#include<hgl/graph/VKFramebuffer.h>
#include<hgl/graph/VKSwapchain.h>
#include<hgl/graph/VKSubmitQueue.h>
#include<hgl/graph/VKQueue.h>
VK_NAMESPACE_BEGIN
/**
* 渲染目标
*/
class RenderTarget:public SubmitQueue
class RenderTarget:public GPUQueue
{
protected:
@ -20,7 +20,7 @@ protected:
VkExtent2D extent;
GPUSemaphore * render_complete_semaphore =nullptr;
CommandBuffer * command_buffer =nullptr;
GPUCmdBuffer * command_buffer =nullptr;
protected:
@ -30,10 +30,10 @@ protected:
protected:
friend class RenderDevice;
friend class GPUDevice;
RenderTarget(RenderDevice *dev,Framebuffer *_fb,CommandBuffer *_cb,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);
RenderTarget(GPUDevice *dev,Framebuffer *_fb,GPUCmdBuffer *_cb,const uint32_t fence_count=1);
RenderTarget(GPUDevice *dev,RenderPass *_rp,Framebuffer *_fb,GPUCmdBuffer *_cb,Texture2D **color_texture_list,const uint32_t color_count,Texture2D *depth_texture,const uint32_t fence_count=1);
public:
@ -41,7 +41,7 @@ public:
const VkExtent2D & GetExtent ()const {return extent;}
GPUSemaphore * GetCompleteSemaphore(){return render_complete_semaphore;}
CommandBuffer * GetCommandBuffer () {return command_buffer;}
GPUCmdBuffer * GetCommandBuffer () {return command_buffer;}
virtual const VkRenderPass GetRenderPass ()const {return fb->GetRenderPass();}
virtual const uint32_t GetColorCount ()const {return fb->GetColorCount();}
virtual const VkFramebuffer GetFramebuffer ()const {return fb->GetFramebuffer();}
@ -72,7 +72,7 @@ class SwapchainRenderTarget:public RenderTarget
public:
SwapchainRenderTarget(RenderDevice *dev,Swapchain *sc);
SwapchainRenderTarget(GPUDevice *dev,Swapchain *sc);
~SwapchainRenderTarget();
const VkRenderPass GetRenderPass ()const override {return *main_rp;}

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

@ -14,17 +14,17 @@ VK_NAMESPACE_BEGIN
*/
class Renderable
{
struct BufferData
struct GPUBufferData
{
VAB *buf;
VkDeviceSize offset;
public:
CompOperatorMemcmp(const BufferData &);
CompOperatorMemcmp(const GPUBufferData &);
};
Map<UTF8String,BufferData> buffer_list;
Map<UTF8String,GPUBufferData> buffer_list;
protected:

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

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

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

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

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

@ -44,7 +44,7 @@ namespace hgl
virtual ~VertexAttribDataAccess()=default;
void BufferData(const T *ptr)
void GPUBufferData(const T *ptr)
{
if(!ptr)return;

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

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

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

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

2
src/GUI/DefaultThemeEngine.cpp
View File

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

2
src/GUI/DefaultThemeEngine.h
View File

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

6
src/GUI/ThemeEngine.cpp
View File

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

12
src/RenderDevice/CMakeLists.txt
View File

@ -1,10 +1,10 @@
set(VK_INCLUDE_PATH ${ROOT_INCLUDE_PATH}/hgl/graph)
SET(VK_DB_SOURCE ${VK_INCLUDE_PATH}/VKDatabase.h
VKDatabase.cpp
VKDatabaseMaterial.cpp)
SET(VK_RR_SOURCE ${VK_INCLUDE_PATH}/VKRenderResource.h
VKRenderResource.cpp
VKRenderResourceMaterial.cpp)
SOURCE_GROUP("Database" FILES ${VK_DB_SOURCE})
SOURCE_GROUP("RenderResource" FILES ${VK_RR_SOURCE})
SET(VK_INST_SOURCE ${VK_INCLUDE_PATH}/VKInstance.h
VKInstance.cpp)
@ -77,7 +77,7 @@ SET(VK_RENDER_PASS_SOURCE ${VK_INCLUDE_PATH}/VKFramebuffer.h
${VK_INCLUDE_PATH}/VKCommandBuffer.h
${VK_INCLUDE_PATH}/VKSemaphore.h
${VK_INCLUDE_PATH}/VKFence.h
VKSubmitQueue.cpp
VKQueue.cpp
VKSemaphore.cpp
VKFence.cpp
VKFramebuffer.cpp
@ -108,7 +108,7 @@ IF(WIN32)
ENDIF()
ENDIF(WIN32)
add_cm_library(ULRE.VulkanRender "ULRE" ${VK_DB_SOURCE}
add_cm_library(ULRE.VulkanRender "ULRE" ${VK_RR_SOURCE}
${VK_INST_SOURCE}
${VK_DEBUG_SOURCE}
${VK_MEMORY_SOURCE}

16
src/RenderDevice/VKCommandBuffer.cpp
View File

@ -10,7 +10,7 @@
#include<hgl/graph/VKDescriptorSets.h>
VK_NAMESPACE_BEGIN
CommandBuffer::CommandBuffer(VkDevice dev,const VkExtent2D &extent,const uint32_t atta_count,VkCommandPool cp,VkCommandBuffer cb)
GPUCmdBuffer::GPUCmdBuffer(VkDevice dev,const VkExtent2D &extent,const uint32_t atta_count,VkCommandPool cp,VkCommandBuffer cb)
{
device=dev;
pool=cp;
@ -39,21 +39,21 @@ CommandBuffer::CommandBuffer(VkDevice dev,const VkExtent2D &extent,const uint32_
pipeline_layout=VK_NULL_HANDLE;
}
CommandBuffer::~CommandBuffer()
GPUCmdBuffer::~GPUCmdBuffer()
{
delete[] clear_values;
vkFreeCommandBuffers(device,pool,1,&cmd_buf);
}
void CommandBuffer::SetRenderArea(const VkExtent2D &ext2d)
void GPUCmdBuffer::SetRenderArea(const VkExtent2D &ext2d)
{
render_area.offset.x=0;
render_area.offset.y=0;
render_area.extent=ext2d;
}
bool CommandBuffer::Begin()
bool GPUCmdBuffer::Begin()
{
CommandBufferBeginInfo cmd_buf_info;
@ -65,7 +65,7 @@ bool CommandBuffer::Begin()
return(true);
}
bool CommandBuffer::BindFramebuffer(VkRenderPass rp,VkFramebuffer fb)
bool GPUCmdBuffer::BindFramebuffer(VkRenderPass rp,VkFramebuffer fb)
{
RenderPassBeginInfo rp_begin;
@ -93,19 +93,19 @@ bool CommandBuffer::BindFramebuffer(VkRenderPass rp,VkFramebuffer fb)
return(true);
}
bool CommandBuffer::BindFramebuffer(Framebuffer *fbo)
bool GPUCmdBuffer::BindFramebuffer(Framebuffer *fbo)
{
return BindFramebuffer(fbo->GetRenderPass(),fbo->GetFramebuffer());
}
bool CommandBuffer::BindFramebuffer(RenderTarget *rt)
bool GPUCmdBuffer::BindFramebuffer(RenderTarget *rt)
{
if(!rt)return(false);
return BindFramebuffer(rt->GetRenderPass(),rt->GetFramebuffer());
}
bool CommandBuffer::BindVAB(RenderableInstance *ri)
bool GPUCmdBuffer::BindVAB(RenderableInstance *ri)
{
if(!ri)
return(false);

2
src/RenderDevice/VKDescriptorSetLayoutCreater.cpp
View File

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

16
src/RenderDevice/VKDevice.cpp
View File

@ -11,7 +11,7 @@
#include<hgl/graph/VKDescriptorSets.h>
VK_NAMESPACE_BEGIN
RenderDevice::RenderDevice(RenderDeviceAttribute *da)
GPUDevice::GPUDevice(GPUDeviceAttribute *da)
{
attr=da;
@ -23,7 +23,7 @@ RenderDevice::RenderDevice(RenderDeviceAttribute *da)
Resize(attr->surface_caps.currentExtent);
}
RenderDevice::~RenderDevice()
GPUDevice::~GPUDevice()
{
SAFE_CLEAR(swapchainRT);
SAFE_CLEAR(swapchain);
@ -34,7 +34,7 @@ RenderDevice::~RenderDevice()
delete attr;
}
bool RenderDevice::Resize(const VkExtent2D &extent)
bool GPUDevice::Resize(const VkExtent2D &extent)
{
SAFE_CLEAR(swapchainRT);
SAFE_CLEAR(swapchain);
@ -48,14 +48,14 @@ bool RenderDevice::Resize(const VkExtent2D &extent)
return(false);
texture_cmd_buf=CreateCommandBuffer(extent,0);
textureSQ=new SubmitQueue(this,attr->graphics_queue,1);
textureSQ=new GPUQueue(this,attr->graphics_queue,1);
swapchainRT=new SwapchainRenderTarget(this,swapchain);
return(true);
}
CommandBuffer *RenderDevice::CreateCommandBuffer(const VkExtent2D &extent,const uint32_t atta_count)
GPUCmdBuffer *GPUDevice::CreateCommandBuffer(const VkExtent2D &extent,const uint32_t atta_count)
{
if(!attr->cmd_pool)
return(nullptr);
@ -73,14 +73,14 @@ CommandBuffer *RenderDevice::CreateCommandBuffer(const VkExtent2D &extent,const
if(res!=VK_SUCCESS)
return(nullptr);
return(new CommandBuffer(attr->device,extent,atta_count,attr->cmd_pool,cmd_buf));
return(new GPUCmdBuffer(attr->device,extent,atta_count,attr->cmd_pool,cmd_buf));
}
/**
* 创建栅栏
* @param create_signaled 是否创建初始信号
*/
GPUFence *RenderDevice::CreateFence(bool create_signaled)
GPUFence *GPUDevice::CreateFence(bool create_signaled)
{
FenceCreateInfo fenceInfo(create_signaled?VK_FENCE_CREATE_SIGNALED_BIT:0);
@ -92,7 +92,7 @@ GPUFence *RenderDevice::CreateFence(bool create_signaled)
return(new GPUFence(attr->device,fence));
}
vulkan::GPUSemaphore *RenderDevice::CreateSemaphore()
vulkan::GPUSemaphore *GPUDevice::CreateSemaphore()
{
SemaphoreCreateInfo SemaphoreCreateInfo;

8
src/RenderDevice/VKDeviceAttribute.cpp
View File

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

16
src/RenderDevice/VKDeviceBuffer.cpp
View File

@ -2,7 +2,7 @@
#include<hgl/graph/VKBuffer.h>
VK_NAMESPACE_BEGIN
bool RenderDevice::CreateBuffer(BufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode)
bool GPUDevice::CreateBuffer(GPUBufferData *buf,VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode)
{
BufferCreateInfo buf_info;
@ -42,19 +42,19 @@ bool RenderDevice::CreateBuffer(BufferData *buf,VkBufferUsageFlags buf_usage,VkD
return(false);
}
VAB *RenderDevice::CreateVAB(VkFormat format,uint32_t count,const void *data,SharingMode sharing_mode)
VAB *GPUDevice::CreateVAB(VkFormat format,uint32_t count,const void *data,SharingMode sharing_mode)
{
const uint32_t stride=GetStrideByFormat(format);
if(stride==0)
{
std::cerr<<"format["<<format<<"] stride length is 0,please use \"RenderDevice::CreateBuffer(VkBufferUsageFlags,VkDeviceSize,VkSharingMode)\" function.";
std::cerr<<"format["<<format<<"] stride length is 0,please use \"GPUDevice::CreateBuffer(VkBufferUsageFlags,VkDeviceSize,VkSharingMode)\" function.";
return(nullptr);
}
const VkDeviceSize size=stride*count;
BufferData buf;
GPUBufferData buf;
if(!CreateBuffer(&buf,VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,size,data,sharing_mode))
return(nullptr);
@ -62,7 +62,7 @@ VAB *RenderDevice::CreateVAB(VkFormat format,uint32_t count,const void *data,Sha
return(new VertexAttribBuffer(attr->device,buf,format,stride,count));
}
IndexBuffer *RenderDevice::CreateIBO(IndexType index_type,uint32_t count,const void *data,SharingMode sharing_mode)
IndexBuffer *GPUDevice::CreateIBO(IndexType index_type,uint32_t count,const void *data,SharingMode sharing_mode)
{
uint32_t stride;
@ -72,7 +72,7 @@ IndexBuffer *RenderDevice::CreateIBO(IndexType index_type,uint32_t count,const v
const VkDeviceSize size=stride*count;
BufferData buf;
GPUBufferData buf;
if(!CreateBuffer(&buf,VK_BUFFER_USAGE_INDEX_BUFFER_BIT,size,data,sharing_mode))
return(nullptr);
@ -80,9 +80,9 @@ IndexBuffer *RenderDevice::CreateIBO(IndexType index_type,uint32_t count,const v
return(new IndexBuffer(attr->device,buf,index_type,count));
}
GPUBuffer *RenderDevice::CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode)
GPUBuffer *GPUDevice::CreateBuffer(VkBufferUsageFlags buf_usage,VkDeviceSize size,const void *data,SharingMode sharing_mode)
{
BufferData buf;
GPUBufferData buf;
if(!CreateBuffer(&buf,buf_usage,size,data,sharing_mode))
return(nullptr);

16
src/RenderDevice/VKDeviceCreater.cpp
View File

@ -11,7 +11,7 @@
#include<iomanip>
VK_NAMESPACE_BEGIN
Swapchain *CreateSwapchain(const RenderDeviceAttribute *attr,const VkExtent2D &acquire_extent);
Swapchain *CreateSwapchain(const GPUDeviceAttribute *attr,const VkExtent2D &acquire_extent);
namespace
{
@ -51,7 +51,7 @@ namespace
return nullptr;
}
void GetDeviceQueue(RenderDeviceAttribute *attr)
void GetDeviceQueue(GPUDeviceAttribute *attr)
{
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;
#endif//VK_DRIVER_ID_RANGE_SIZE
RenderDevice *CreateRenderDevice(VkInstance inst,const PhysicalRenderDevice *physical_device,VkSurfaceKHR surface,const VkExtent2D &extent)
GPUDevice *CreateRenderDevice(VkInstance inst,const GPUPhysicalDevice *physical_device,VkSurfaceKHR surface,const VkExtent2D &extent)
{
#ifdef _DEBUG
{
@ -397,9 +397,9 @@ RenderDevice *CreateRenderDevice(VkInstance inst,const PhysicalRenderDevice *phy
}
#endif//_DEBUG
RenderDeviceAttribute *device_attr=new RenderDeviceAttribute(inst,physical_device,surface);
GPUDeviceAttribute *device_attr=new GPUDeviceAttribute(inst,physical_device,surface);
AutoDelete<RenderDeviceAttribute> auto_delete(device_attr);
AutoDelete<GPUDeviceAttribute> auto_delete(device_attr);
if(device_attr->graphics_family==ERROR_FAMILY_INDEX)
return(nullptr);
@ -428,10 +428,10 @@ RenderDevice *CreateRenderDevice(VkInstance inst,const PhysicalRenderDevice *phy
auto_delete.Discard();
return(new RenderDevice(device_attr));
return(new GPUDevice(device_attr));
}
RenderDevice *CreateRenderDevice(vulkan::Instance *inst,Window *win,const vulkan::PhysicalRenderDevice *pd)
GPUDevice *CreateRenderDevice(vulkan::VulkanInstance *inst,Window *win,const vulkan::GPUPhysicalDevice *pd)
{
if(!inst)
return(nullptr);
@ -453,7 +453,7 @@ RenderDevice *CreateRenderDevice(vulkan::Instance *inst,Window *win,const vulkan
extent.width=win->GetWidth();
extent.height=win->GetHeight();
RenderDevice *device=CreateRenderDevice(*inst,pd,surface,extent);
GPUDevice *device=CreateRenderDevice(*inst,pd,surface,extent);
if(!device)
{

8
src/RenderDevice/VKDeviceFramebuffer.cpp
View File

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

6
src/RenderDevice/VKDeviceImage.cpp
View File

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

6
src/RenderDevice/VKDeviceRenderPass.cpp
View File

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

12
src/RenderDevice/VKDeviceRenderTarget.cpp
View File

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

8
src/RenderDevice/VKDeviceSwapchain.cpp
View File

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

30
src/RenderDevice/VKDeviceTexture.cpp
View File

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

16
src/RenderDevice/VKInstance.cpp
View File

@ -5,11 +5,11 @@
#include<iostream>
VK_NAMESPACE_BEGIN
RenderDevice *CreateRenderDevice(VkInstance,const PhysicalRenderDevice *,Window *);
GPUDevice *CreateRenderDevice(VkInstance,const GPUPhysicalDevice *,Window *);
void CheckInstanceLayer(CharPointerList &layer_list,CreateInstanceLayerInfo *layer_info);
Instance *CreateInstance(const AnsiString &app_name,VKDebugOut *out,CreateInstanceLayerInfo *layer_info)
VulkanInstance *CreateInstance(const AnsiString &app_name,VKDebugOut *out,CreateInstanceLayerInfo *layer_info)
{
ApplicationInfo app_info;
InstanceCreateInfo inst_info(&app_info);
@ -50,13 +50,13 @@ Instance *CreateInstance(const AnsiString &app_name,VKDebugOut *out,CreateInstan
if(out)
out->Init(inst);
return(new Instance(inst,out));
return(new VulkanInstance(inst,out));
}
return(nullptr);
}
Instance::Instance(VkInstance i,VKDebugOut *out)
VulkanInstance::VulkanInstance(VkInstance i,VKDebugOut *out)
{
inst=i;
@ -70,13 +70,13 @@ Instance::Instance(VkInstance i,VKDebugOut *out)
vkEnumeratePhysicalDevices(inst, &gpu_count,pd_list);
for(uint32_t i=0;i<gpu_count;i++)
physical_devices.Add(new PhysicalRenderDevice(inst,pd_list[i]));
physical_devices.Add(new GPUPhysicalDevice(inst,pd_list[i]));
delete[] pd_list;
}
}
Instance::~Instance()
VulkanInstance::~VulkanInstance()
{
SAFE_CLEAR(debug_out);
@ -84,10 +84,10 @@ Instance::~Instance()
vkDestroyInstance(inst,nullptr);
}
const PhysicalRenderDevice *Instance::GetDevice(VkPhysicalDeviceType type)const
const GPUPhysicalDevice *VulkanInstance::GetDevice(VkPhysicalDeviceType type)const
{
const uint32_t count=physical_devices.GetCount();
PhysicalRenderDevice **pd=physical_devices.GetData();
GPUPhysicalDevice **pd=physical_devices.GetData();
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"VKDescriptorSetLayoutCreater.h"
VK_NAMESPACE_BEGIN
Material *RenderDevice::CreateMaterial(ShaderModuleMap *shader_maps)
Material *GPUDevice::CreateMaterial(ShaderModuleMap *shader_maps)
{
const int shader_count=shader_maps->GetCount();
@ -49,7 +49,7 @@ Material *RenderDevice::CreateMaterial(ShaderModuleMap *shader_maps)
return(new Material(shader_maps,shader_stage_list,dsl_creater));
}
Material *RenderDevice::CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *fragment_shader_module)
Material *GPUDevice::CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *fragment_shader_module)
{
if(!vertex_shader_module||!fragment_shader_module)
return(nullptr);
@ -65,7 +65,7 @@ Material *RenderDevice::CreateMaterial(const VertexShaderModule *vertex_shader_m
return CreateMaterial(smm);
}
Material *RenderDevice::CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *geometry_shader_module,const ShaderModule *fragment_shader_module)
Material *GPUDevice::CreateMaterial(const VertexShaderModule *vertex_shader_module,const ShaderModule *geometry_shader_module,const ShaderModule *fragment_shader_module)
{
if(!vertex_shader_module
||!geometry_shader_module

2
src/RenderDevice/VKMemory.cpp
View File

@ -2,7 +2,7 @@
#include<hgl/graph/VKMemory.h>
#include<hgl/graph/VKPhysicalDevice.h>
VK_NAMESPACE_BEGIN
GPUMemory *RenderDevice::CreateMemory(const VkMemoryRequirements &req,uint32_t properties)
GPUMemory *GPUDevice::CreateMemory(const VkMemoryRequirements &req,uint32_t properties)
{
uint32_t index;

22
src/RenderDevice/VKPhysicalDevice.cpp
View File

@ -1,7 +1,7 @@
#include<hgl/graph/VKPhysicalDevice.h>
VK_NAMESPACE_BEGIN
PhysicalRenderDevice::PhysicalRenderDevice(VkInstance inst,VkPhysicalDevice pd)
GPUPhysicalDevice::GPUPhysicalDevice(VkInstance inst,VkPhysicalDevice pd)
{
instance=inst;
physical_device=pd;
@ -31,19 +31,19 @@ PhysicalRenderDevice::PhysicalRenderDevice(VkInstance inst,VkPhysicalDevice pd)
vkGetPhysicalDeviceFeatures(physical_device,&features);
vkGetPhysicalDeviceMemoryProperties(physical_device,&memory_properties);
PFN_vkGetPhysicalDeviceProperties2 GetPhysicalRenderDeviceProperties2=nullptr;
PFN_vkGetPhysicalDeviceProperties2 GetGPUPhysicalDeviceProperties2=nullptr;
if(GetExtensionSpecVersion(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME))
GetPhysicalRenderDeviceProperties2=(PFN_vkGetPhysicalDeviceProperties2KHR)vkGetInstanceProcAddr(instance,"vkGetPhysicalDeviceProperties2KHR");
GetGPUPhysicalDeviceProperties2=(PFN_vkGetPhysicalDeviceProperties2KHR)vkGetInstanceProcAddr(instance,"vkGetPhysicalDeviceProperties2KHR");
if(!GetPhysicalRenderDeviceProperties2)
if(!GetGPUPhysicalDeviceProperties2)
if(GetExtensionSpecVersion(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME))
GetPhysicalRenderDeviceProperties2=(PFN_vkGetPhysicalDeviceProperties2)vkGetInstanceProcAddr(instance,"vkGetPhysicalDeviceProperties2");
GetGPUPhysicalDeviceProperties2=(PFN_vkGetPhysicalDeviceProperties2)vkGetInstanceProcAddr(instance,"vkGetPhysicalDeviceProperties2");
if(GetPhysicalRenderDeviceProperties2)
if(GetGPUPhysicalDeviceProperties2)
{
VkPhysicalDeviceProperties2KHR properties2;
GetPhysicalRenderDeviceProperties2(physical_device,&properties2);
GetGPUPhysicalDeviceProperties2(physical_device,&properties2);
hgl_cpy(properties,properties2.properties);
@ -58,7 +58,7 @@ PhysicalRenderDevice::PhysicalRenderDevice(VkInstance inst,VkPhysicalDevice pd)
}
}
const uint32_t PhysicalRenderDevice::GetExtensionSpecVersion(const AnsiString &name)const
const uint32_t GPUPhysicalDevice::GetExtensionSpecVersion(const AnsiString &name)const
{
const uint count=extension_properties.GetCount();
const VkExtensionProperties *ep=extension_properties.GetData();
@ -72,7 +72,7 @@ const uint32_t PhysicalRenderDevice::GetExtensionSpecVersion(const AnsiString &n
return 0;
}
const bool PhysicalRenderDevice::CheckMemoryType(uint32_t typeBits,VkMemoryPropertyFlags properties,uint32_t *typeIndex)const
const bool GPUPhysicalDevice::CheckMemoryType(uint32_t typeBits,VkMemoryPropertyFlags properties,uint32_t *typeIndex)const
{
// Search memtypes to find first index with those properties
for(uint32_t i=0; i<memory_properties.memoryTypeCount; i++)
@ -92,7 +92,7 @@ const bool PhysicalRenderDevice::CheckMemoryType(uint32_t typeBits,VkMemoryPrope
return false;
}
VkFormat PhysicalRenderDevice::GetDepthFormat(bool lower_to_high)const
VkFormat GPUPhysicalDevice::GetDepthFormat(bool lower_to_high)const
{
constexpr VkFormat depthFormats[] =
{
@ -120,7 +120,7 @@ VkFormat PhysicalRenderDevice::GetDepthFormat(bool lower_to_high)const
return result;
}
VkFormat PhysicalRenderDevice::GetDepthStencilFormat(bool lower_to_high)const
VkFormat GPUPhysicalDevice::GetDepthStencilFormat(bool lower_to_high)const
{
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));
}
Pipeline *RenderDevice::CreatePipeline(const InlinePipeline &ip,const Material *mtl,const RenderTarget *rt)
Pipeline *GPUDevice::CreatePipeline(const InlinePipeline &ip,const Material *mtl,const RenderTarget *rt)
{
PipelineData *pd=GetPipelineData(ip);
@ -49,7 +49,7 @@ Pipeline *RenderDevice::CreatePipeline(const InlinePipeline &ip,const Material *
return VK_NAMESPACE::CreatePipeline(attr->device,attr->pipeline_cache,pd,mtl,rt);
}
Pipeline *RenderDevice::CreatePipeline(PipelineData *pd,const Material *mtl,const RenderTarget *rt)
Pipeline *GPUDevice::CreatePipeline(PipelineData *pd,const Material *mtl,const RenderTarget *rt)
{
return VK_NAMESPACE::CreatePipeline(attr->device,attr->pipeline_cache,pd,mtl,rt);
}

14
src/RenderDevice/VKSubmitQueue.cpp → src/RenderDevice/VKQueue.cpp
View File

@ -1,4 +1,4 @@
#include<hgl/graph/VKSubmitQueue.h>
#include<hgl/graph/VKQueue.h>
#include<hgl/graph/VKDevice.h>
#include<hgl/graph/VKSemaphore.h>
@ -8,7 +8,7 @@ namespace
const VkPipelineStageFlags pipe_stage_flags=VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
}//namespace
SubmitQueue::SubmitQueue(RenderDevice *dev,VkQueue q,const uint32_t fence_count)
GPUQueue::GPUQueue(GPUDevice *dev,VkQueue q,const uint32_t fence_count)
{
device=dev;
queue=q;
@ -21,12 +21,12 @@ SubmitQueue::SubmitQueue(RenderDevice *dev,VkQueue q,const uint32_t fence_count)
submit_info.pWaitDstStageMask = &pipe_stage_flags;
}
SubmitQueue::~SubmitQueue()
GPUQueue::~GPUQueue()
{
fence_list.Clear();
}
bool SubmitQueue::WaitQueue()
bool GPUQueue::WaitQueue()
{
VkResult result=vkQueueWaitIdle(queue);
@ -36,7 +36,7 @@ bool SubmitQueue::WaitQueue()
return(true);
}
bool SubmitQueue::WaitFence(const bool wait_all,uint64_t time_out)
bool GPUQueue::WaitFence(const bool wait_all,uint64_t time_out)
{
VkResult result;
VkFence fence=*fence_list[current_fence];
@ -50,7 +50,7 @@ bool SubmitQueue::WaitFence(const bool wait_all,uint64_t time_out)
return(true);
}
bool SubmitQueue::Submit(const VkCommandBuffer *cmd_buf,const uint32_t cb_count,vulkan::GPUSemaphore *wait_sem,vulkan::GPUSemaphore *complete_sem)
bool GPUQueue::Submit(const VkCommandBuffer *cmd_buf,const uint32_t cb_count,vulkan::GPUSemaphore *wait_sem,vulkan::GPUSemaphore *complete_sem)
{
VkSemaphore ws;
VkSemaphore cs;
@ -93,7 +93,7 @@ bool SubmitQueue::Submit(const VkCommandBuffer *cmd_buf,const uint32_t cb_count,
return(result==VK_SUCCESS);
}
bool SubmitQueue::Submit(const VkCommandBuffer &cmd_buf,vulkan::GPUSemaphore *wait_sem,vulkan::GPUSemaphore *complete_sem)
bool GPUQueue::Submit(const VkCommandBuffer &cmd_buf,vulkan::GPUSemaphore *wait_sem,vulkan::GPUSemaphore *complete_sem)
{
return Submit(&cmd_buf,1,wait_sem,complete_sem);
}

34
src/RenderDevice/VKDatabase.cpp → src/RenderDevice/VKRenderResource.cpp
View File

@ -1,10 +1,10 @@
#include<hgl/graph/VKDatabase.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/VKDevice.h>
#include<hgl/graph/VKRenderableInstance.h>
#include<hgl/graph/VKInlinePipeline.h>
VK_NAMESPACE_BEGIN
VAB *Database::CreateVAB(VkFormat format,uint32_t count,const void *data,SharingMode sharing_mode)
VAB *RenderResource::CreateVAB(VkFormat format,uint32_t count,const void *data,SharingMode sharing_mode)
{
VAB *vb=device->CreateVAB(format,count,data,sharing_mode);
@ -16,7 +16,7 @@ VAB *Database::CreateVAB(VkFormat format,uint32_t count,const void *data,Sharing
return vb;
}
#define SCENE_DB_CREATE_BUFFER(name) GPUBuffer *Database::Create##name(VkDeviceSize size,void *data,SharingMode sharing_mode) \
#define SCENE_DB_CREATE_BUFFER(name) GPUBuffer *RenderResource::Create##name(VkDeviceSize size,void *data,SharingMode sharing_mode) \
{ \
GPUBuffer *buf=device->Create##name(size,data,sharing_mode); \
\
@ -25,7 +25,7 @@ VAB *Database::CreateVAB(VkFormat format,uint32_t count,const void *data,Sharing
return(buf); \
} \
\
GPUBuffer *Database::Create##name(VkDeviceSize size,SharingMode sharing_mode) \
GPUBuffer *RenderResource::Create##name(VkDeviceSize size,SharingMode sharing_mode) \
{ \
GPUBuffer *buf=device->Create##name(size,sharing_mode); \
\
@ -40,7 +40,7 @@ VAB *Database::CreateVAB(VkFormat format,uint32_t count,const void *data,Sharing
#undef SCENE_DB_CREATE_BUFFER
IndexBuffer *Database::CreateIBO(IndexType index_type,uint32_t count,const void *data,SharingMode sharing_mode)
IndexBuffer *RenderResource::CreateIBO(IndexType index_type,uint32_t count,const void *data,SharingMode sharing_mode)
{
IndexBuffer *buf=device->CreateIBO(index_type,count,data,sharing_mode);
@ -49,7 +49,7 @@ IndexBuffer *Database::CreateIBO(IndexType index_type,uint32_t count,const void
return(buf);
}
MaterialInstance *Database::CreateMaterialInstance(Material *mtl)
MaterialInstance *RenderResource::CreateMaterialInstance(Material *mtl)
{
if(!mtl)return(nullptr);
@ -61,7 +61,7 @@ MaterialInstance *Database::CreateMaterialInstance(Material *mtl)
return mi;
}
MaterialInstance *Database::CreateMaterialInstance(const OSString &mtl_filename)
MaterialInstance *RenderResource::CreateMaterialInstance(const OSString &mtl_filename)
{
Material *mtl=this->CreateMaterial(mtl_filename);
@ -71,7 +71,7 @@ MaterialInstance *Database::CreateMaterialInstance(const OSString &mtl_filename)
return CreateMaterialInstance(mtl);
}
Pipeline *Database::CreatePipeline(Material *mtl,RenderTarget *rt,const InlinePipeline &ip,const Prim &prim,const bool prim_restart)
Pipeline *RenderResource::CreatePipeline(Material *mtl,RenderTarget *rt,const InlinePipeline &ip,const Prim &prim,const bool prim_restart)
{
PipelineData *pd=GetPipelineData(ip);
@ -85,12 +85,12 @@ Pipeline *Database::CreatePipeline(Material *mtl,RenderTarget *rt,const InlinePi
return(p);
}
Pipeline *Database::CreatePipeline(MaterialInstance *mi,RenderTarget *rt,const InlinePipeline &ip,const Prim &prim,const bool prim_restart)
Pipeline *RenderResource::CreatePipeline(MaterialInstance *mi,RenderTarget *rt,const InlinePipeline &ip,const Prim &prim,const bool prim_restart)
{
return CreatePipeline(mi->GetMaterial(),rt,ip,prim,prim_restart);
}
Pipeline *Database::CreatePipeline(Material *mtl,RenderTarget *rt,PipelineData *pd,const Prim &prim,const bool prim_restart)
Pipeline *RenderResource::CreatePipeline(Material *mtl,RenderTarget *rt,PipelineData *pd,const Prim &prim,const bool prim_restart)
{
pd->Set(prim,prim_restart);
@ -102,12 +102,12 @@ Pipeline *Database::CreatePipeline(Material *mtl,RenderTarget *rt,PipelineData *
return(p);
}
Pipeline *Database::CreatePipeline(MaterialInstance *mi,RenderTarget *rt,PipelineData *pd,const Prim &prim,const bool prim_restart)
Pipeline *RenderResource::CreatePipeline(MaterialInstance *mi,RenderTarget *rt,PipelineData *pd,const Prim &prim,const bool prim_restart)
{
return CreatePipeline(mi->GetMaterial(),rt,pd,prim,prim_restart);
}
Pipeline *Database::CreatePipeline(Material *mtl,RenderTarget *rt,const OSString &pipeline_filename,const Prim &prim,const bool prim_restart)
Pipeline *RenderResource::CreatePipeline(Material *mtl,RenderTarget *rt,const OSString &pipeline_filename,const Prim &prim,const bool prim_restart)
{
PipelineData *pd=vulkan::GetPipelineData(pipeline_filename);
@ -116,12 +116,12 @@ Pipeline *Database::CreatePipeline(Material *mtl,RenderTarget *rt,const OSString
return CreatePipeline(mtl,rt,pd,prim,prim_restart);
}
Pipeline *Database::CreatePipeline(MaterialInstance *mi,RenderTarget *rt,const OSString &filename,const Prim &prim,const bool prim_restart)
Pipeline *RenderResource::CreatePipeline(MaterialInstance *mi,RenderTarget *rt,const OSString &filename,const Prim &prim,const bool prim_restart)
{
return CreatePipeline(mi->GetMaterial(),rt,filename,prim,prim_restart);
}
Renderable *Database::CreateRenderable(const uint32_t vertex_count)
Renderable *RenderResource::CreateRenderable(const uint32_t vertex_count)
{
if(!vertex_count)return(nullptr);
@ -133,7 +133,7 @@ Renderable *Database::CreateRenderable(const uint32_t vertex_count)
return ro;
}
TextRenderable *Database::CreateTextRenderable(Material *mtl)
TextRenderable *RenderResource::CreateTextRenderable(Material *mtl)
{
if(!mtl)return(nullptr);
@ -145,7 +145,7 @@ TextRenderable *Database::CreateTextRenderable(Material *mtl)
return tr;
}
RenderableInstance *Database::CreateRenderableInstance(Renderable *r,MaterialInstance *mi,Pipeline *p)
RenderableInstance *RenderResource::CreateRenderableInstance(Renderable *r,MaterialInstance *mi,Pipeline *p)
{
if(!p||!mi||!r)
return(nullptr);
@ -158,7 +158,7 @@ RenderableInstance *Database::CreateRenderableInstance(Renderable *r,MaterialIns
return ri;
}
Sampler *Database::CreateSampler(VkSamplerCreateInfo *sci)
Sampler *RenderResource::CreateSampler(VkSamplerCreateInfo *sci)
{
Sampler *s=device->CreateSampler(sci);

12
src/RenderDevice/VKDatabaseMaterial.cpp → src/RenderDevice/VKRenderResourceMaterial.cpp
View File

@ -4,11 +4,11 @@
#include<hgl/graph/VKShaderModuleMap.h>
#include<hgl/graph/shader/ShaderResource.h>
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/VKDatabase.h>
#include<hgl/graph/VKRenderResource.h>
VK_NAMESPACE_BEGIN
const ShaderModule *Database::CreateShaderModule(const OSString &filename,ShaderResource *shader_resource)
const ShaderModule *RenderResource::CreateShaderModule(const OSString &filename,ShaderResource *shader_resource)
{
if(!device)return(nullptr);
if(filename.IsEmpty())return(nullptr);
@ -26,7 +26,7 @@ const ShaderModule *Database::CreateShaderModule(const OSString &filename,Shader
return sm;
}
const ShaderModule *Database::CreateShaderModule(const OSString &filename)
const ShaderModule *RenderResource::CreateShaderModule(const OSString &filename)
{
ShaderModule *sm;
@ -44,7 +44,7 @@ const ShaderModule *Database::CreateShaderModule(const OSString &filename)
return sm;
}
Material *Database::CreateMaterial(const OSString &vertex_shader_filename,const OSString &fragment_shader_filename)
Material *RenderResource::CreateMaterial(const OSString &vertex_shader_filename,const OSString &fragment_shader_filename)
{
const ShaderModule *vs=CreateShaderModule(vertex_shader_filename);
@ -59,7 +59,7 @@ Material *Database::CreateMaterial(const OSString &vertex_shader_filename,const
return(device->CreateMaterial((VertexShaderModule *)vs,fs));
}
Material *Database::CreateMaterial(const OSString &vertex_shader_filename,const OSString &geometry_shader_filename,const OSString &fragment_shader_filename)
Material *RenderResource::CreateMaterial(const OSString &vertex_shader_filename,const OSString &geometry_shader_filename,const OSString &fragment_shader_filename)
{
const ShaderModule *vs=CreateShaderModule(vertex_shader_filename);
@ -79,7 +79,7 @@ Material *Database::CreateMaterial(const OSString &vertex_shader_filename,const
return(device->CreateMaterial((VertexShaderModule *)vs,gs,fs));
}
Material *Database::CreateMaterial(const OSString &filename)
Material *RenderResource::CreateMaterial(const OSString &filename)
{
Material *mtl;

12
src/RenderDevice/VKRenderTarget.cpp
View File

@ -5,7 +5,7 @@
#include<hgl/graph/VKSemaphore.h>
VK_NAMESPACE_BEGIN
RenderTarget::RenderTarget(RenderDevice *dev,Framebuffer *_fb,CommandBuffer *_cb,const uint32_t fence_count):SubmitQueue(dev,dev->GetGraphicsQueue(),fence_count)
RenderTarget::RenderTarget(GPUDevice *dev,Framebuffer *_fb,GPUCmdBuffer *_cb,const uint32_t fence_count):GPUQueue(dev,dev->GetGraphicsQueue(),fence_count)
{
rp=nullptr;
fb=_fb;
@ -21,7 +21,7 @@ RenderTarget::RenderTarget(RenderDevice *dev,Framebuffer *_fb,CommandBuffer *_cb
render_complete_semaphore=dev->CreateSemaphore();
}
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)
RenderTarget::RenderTarget(GPUDevice *dev,RenderPass *_rp,Framebuffer *_fb,GPUCmdBuffer *_cb,Texture2D **ctl,const uint32_t cc,Texture2D *dt,const uint32_t fence_count):GPUQueue(dev,dev->GetGraphicsQueue(),fence_count)
{
rp=_rp;
fb=_fb;
@ -65,10 +65,10 @@ RenderTarget::~RenderTarget()
bool RenderTarget::Submit(GPUSemaphore *present_complete_semaphore)
{
return this->SubmitQueue::Submit(*command_buffer,present_complete_semaphore,render_complete_semaphore);
return this->GPUQueue::Submit(*command_buffer,present_complete_semaphore,render_complete_semaphore);
}
SwapchainRenderTarget::SwapchainRenderTarget(RenderDevice *dev,Swapchain *sc):RenderTarget(dev,nullptr,nullptr,sc->GetImageCount())
SwapchainRenderTarget::SwapchainRenderTarget(GPUDevice *dev,Swapchain *sc):RenderTarget(dev,nullptr,nullptr,sc->GetImageCount())
{
swapchain=sc;
vk_swapchain=swapchain->GetSwapchain();
@ -146,11 +146,11 @@ bool SwapchainRenderTarget::PresentBackbuffer()
bool SwapchainRenderTarget::Submit(VkCommandBuffer cb)
{
return SubmitQueue::Submit(cb,present_complete_semaphore,render_complete_semaphore);
return GPUQueue::Submit(cb,present_complete_semaphore,render_complete_semaphore);
}
bool SwapchainRenderTarget::Submit(VkCommandBuffer cb,GPUSemaphore *pce)
{
return SubmitQueue::Submit(cb,pce,render_complete_semaphore);
return GPUQueue::Submit(cb,pce,render_complete_semaphore);
}
VK_NAMESPACE_END

4
src/RenderDevice/VKRenderable.cpp
View File

@ -26,7 +26,7 @@ bool Renderable::Set(const UTF8String &name,VAB *vab,VkDeviceSize offset)
if(!vab)return(false);
if(buffer_list.KeyExist(name))return(false);
BufferData bd;
GPUBufferData bd;
bd.buf=vab;
bd.offset=offset;
@ -40,7 +40,7 @@ VAB *Renderable::GetVAB(const UTF8String &name,VkDeviceSize *offset)
if(!offset)return(nullptr);
if(name.IsEmpty())return(nullptr);
BufferData bd;
GPUBufferData bd;
if(buffer_list.Get(name,bd))
{

2
src/RenderDevice/VKShaderModule.cpp
View File

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

6
src/RenderDevice/VKTextureLoader.cpp
View File

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

2
src/RenderDevice/VKTileData.cpp
View File

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

2
src/RenderDevice/VKTileFont.cpp
View File

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

32
src/SceneGraph/InlineGeometry.cpp
View File

@ -5,14 +5,14 @@
#include<hgl/graph/VertexAttribDataAccess.h>
#include<hgl/graph/VKDevice.h>
#include<hgl/graph/VKShaderModule.h>
#include<hgl/graph/VKDatabase.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/RenderableCreater.h>
namespace hgl
{
namespace graph
{
vulkan::Renderable *CreateRenderableRectangle(vulkan::Database *db,vulkan::Material *mtl,const RectangleCreateInfo *rci)
vulkan::Renderable *CreateRenderableRectangle(vulkan::RenderResource *db,vulkan::Material *mtl,const RectangleCreateInfo *rci)
{
RenderableCreater rc(db,mtl);
@ -29,7 +29,7 @@ namespace hgl
return rc.Finish();
}
vulkan::Renderable *CreateRenderableGBufferComposition(vulkan::Database *db,vulkan::Material *mtl)
vulkan::Renderable *CreateRenderableGBufferComposition(vulkan::RenderResource *db,vulkan::Material *mtl)
{
RectangleCreateInfo rci;
@ -38,7 +38,7 @@ namespace hgl
return CreateRenderableRectangle(db,mtl,&rci);
}
vulkan::Renderable *CreateRenderableRoundRectangle(vulkan::Database *db,vulkan::Material *mtl,const RoundRectangleCreateInfo *rci)
vulkan::Renderable *CreateRenderableRoundRectangle(vulkan::RenderResource *db,vulkan::Material *mtl,const RoundRectangleCreateInfo *rci)
{
RenderableCreater rc(db,mtl);
@ -112,7 +112,7 @@ namespace hgl
return rc.Finish();
}
vulkan::Renderable *CreateRenderableCircle(vulkan::Database *db,vulkan::Material *mtl,const CircleCreateInfo *cci)
vulkan::Renderable *CreateRenderableCircle(vulkan::RenderResource *db,vulkan::Material *mtl,const CircleCreateInfo *cci)
{
RenderableCreater rc(db,mtl);
@ -160,7 +160,7 @@ namespace hgl
return rc.Finish();
}
vulkan::Renderable *CreateRenderablePlaneGrid(vulkan::Database *db,vulkan::Material *mtl,const PlaneGridCreateInfo *pgci)
vulkan::Renderable *CreateRenderablePlaneGrid(vulkan::RenderResource *db,vulkan::Material *mtl,const PlaneGridCreateInfo *pgci)
{
RenderableCreater rc(db,mtl);
@ -207,7 +207,7 @@ namespace hgl
return rc.Finish();
}
vulkan::Renderable *CreateRenderablePlane(vulkan::Database *db,vulkan::Material *mtl,const PlaneCreateInfo *pci)
vulkan::Renderable *CreateRenderablePlane(vulkan::RenderResource *db,vulkan::Material *mtl,const PlaneCreateInfo *pci)
{
const float xy_vertices [] = { -0.5f,-0.5f,0.0f, +0.5f,-0.5f,0.0f, +0.5f,+0.5f,0.0f, -0.5f,+0.5f,0.0f };
float xy_tex_coord[] = { 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f };
@ -241,14 +241,14 @@ namespace hgl
xy_tex_coord[2]=xy_tex_coord[4]=pci->tile.x;
xy_tex_coord[5]=xy_tex_coord[7]=pci->tile.y;
tex_coord->BufferData(xy_tex_coord);
tex_coord->GPUBufferData(xy_tex_coord);
}
}
return rc.Finish();
}
vulkan::Renderable *CreateRenderableCube(vulkan::Database *db,vulkan::Material *mtl,const CubeCreateInfo *cci)
vulkan::Renderable *CreateRenderableCube(vulkan::RenderResource *db,vulkan::Material *mtl,const CubeCreateInfo *cci)
{ // Points of a cube.
/* 4 5 */ const float points[]={ -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, +0.5f, +0.5f, -0.5f, +0.5f, +0.5f, -0.5f, -0.5f, -0.5f, +0.5f, -0.5f, -0.5f, +0.5f, +0.5f,
/* *------------* */ +0.5f, +0.5f, +0.5f, +0.5f, +0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, +0.5f, -0.5f, +0.5f, +0.5f, -0.5f, +0.5f, -0.5f, -0.5f,
@ -426,7 +426,7 @@ namespace hgl
* @param numberSlices 切片数
* @return 可渲染数据
*/
vulkan::Renderable *CreateRenderableSphere(vulkan::Database *db,vulkan::Material *mtl,const uint numberSlices)
vulkan::Renderable *CreateRenderableSphere(vulkan::RenderResource *db,vulkan::Material *mtl,const uint numberSlices)
{
RenderableCreater rc(db,mtl);
@ -502,7 +502,7 @@ namespace hgl
return rc.Finish();
}
vulkan::Renderable *CreateRenderableDome(vulkan::Database *db,vulkan::Material *mtl,const DomeCreateInfo *dci)
vulkan::Renderable *CreateRenderableDome(vulkan::RenderResource *db,vulkan::Material *mtl,const DomeCreateInfo *dci)
{
RenderableCreater rc(db,mtl);
@ -621,7 +621,7 @@ namespace hgl
}
}//namespace
vulkan::Renderable *CreateRenderableTorus(vulkan::Database *db,vulkan::Material *mtl,const TorusCreateInfo *tci)
vulkan::Renderable *CreateRenderableTorus(vulkan::RenderResource *db,vulkan::Material *mtl,const TorusCreateInfo *tci)
{
RenderableCreater rc(db,mtl);
@ -777,7 +777,7 @@ namespace hgl
}
}//namespace
vulkan::Renderable *CreateRenderableCylinder(vulkan::Database *db,vulkan::Material *mtl,const CylinderCreateInfo *cci)
vulkan::Renderable *CreateRenderableCylinder(vulkan::RenderResource *db,vulkan::Material *mtl,const CylinderCreateInfo *cci)
{
uint numberIndices = cci->numberSlices * 3 * 2 + cci->numberSlices * 6;
@ -996,7 +996,7 @@ namespace hgl
}
}//namespace
vulkan::Renderable *CreateRenderableCone(vulkan::Database *db,vulkan::Material *mtl,const ConeCreateInfo *cci)
vulkan::Renderable *CreateRenderableCone(vulkan::RenderResource *db,vulkan::Material *mtl,const ConeCreateInfo *cci)
{
RenderableCreater rc(db,mtl);
@ -1123,7 +1123,7 @@ namespace hgl
return rc.Finish();
}
vulkan::Renderable *CreateRenderableAxis(vulkan::Database *db,vulkan::Material *mtl,const AxisCreateInfo *aci)
vulkan::Renderable *CreateRenderableAxis(vulkan::RenderResource *db,vulkan::Material *mtl,const AxisCreateInfo *aci)
{
RenderableCreater rc(db,mtl);
@ -1148,7 +1148,7 @@ namespace hgl
return rc.Finish();
}
vulkan::Renderable *CreateRenderableBoundingBox(vulkan::Database *db,vulkan::Material *mtl,const CubeCreateInfo *cci)
vulkan::Renderable *CreateRenderableBoundingBox(vulkan::RenderResource *db,vulkan::Material *mtl,const CubeCreateInfo *cci)
{
// Points of a cube.
/* 4 5 */ const float points[]={ -0.5,-0.5, 0.5, 0.5,-0.5,0.5, 0.5,-0.5,-0.5, -0.5,-0.5,-0.5,

2
src/SceneGraph/RenderList.cpp
View File

@ -85,7 +85,7 @@ namespace hgl
}
}
bool RenderList::Render(vulkan::CommandBuffer *cb)
bool RenderList::Render(vulkan::GPUCmdBuffer *cb)
{
if(!cb)
return(false);

2
src/SceneGraph/RenderableCreater.cpp
View File

@ -5,7 +5,7 @@ namespace hgl
{
namespace graph
{
RenderableCreater::RenderableCreater(vulkan::Database *sdb,vulkan::Material *m)
RenderableCreater::RenderableCreater(vulkan::RenderResource *sdb,vulkan::Material *m)
{
db =sdb;
mtl =m;

2
src/SceneGraph/TileData.cpp
View File

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

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

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