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

Compare commits

base: hyzboy:devel_40_World
Branches Tags
hyzboy:devel_40_World
hyzboy:devel_39_Component
hyzboy:devel_39_Camera
hyzboy:devel_38_GraphManager
hyzboy:devel_36_PickGizmo
hyzboy:devel_37_RenderFramework
hyzboy:devel_35_SceneOrient
hyzboy:devel_34_Gizmo
hyzboy:devel_33_ShaderIOVariable
hyzboy:devel_32_Billboard
hyzboy:devel_31_VDMMergeRender
hyzboy:devel_30_ResumeAssignBuffer
hyzboy:devel_29_BigVBO
hyzboy:Resume_L2W_in_VertexInput
hyzboy:devel_28_Gizmo_Move
hyzboy:devel_27_Default3DMaterial
hyzboy:new_RenderList
hyzboy:devel_26_Texture2DArray
hyzboy:devel_25_MaterialInstanceArray_in_UBO
hyzboy:master
hyzboy:devel_24_L2WArray_in_UBO
hyzboy:optimize_pipeline_cache
hyzboy:debug_util
hyzboy:devel_23_instance
..
compare: hyzboy:devel_36_PickGizmo
Branches Tags
hyzboy:devel_40_World
hyzboy:devel_39_Component
hyzboy:devel_39_Camera
hyzboy:devel_38_GraphManager
hyzboy:devel_36_PickGizmo
hyzboy:devel_37_RenderFramework
hyzboy:devel_35_SceneOrient
hyzboy:devel_34_Gizmo
hyzboy:devel_33_ShaderIOVariable
hyzboy:devel_32_Billboard
hyzboy:devel_31_VDMMergeRender
hyzboy:devel_30_ResumeAssignBuffer
hyzboy:devel_29_BigVBO
hyzboy:Resume_L2W_in_VertexInput
hyzboy:devel_28_Gizmo_Move
hyzboy:devel_27_Default3DMaterial
hyzboy:new_RenderList
hyzboy:devel_26_Texture2DArray
hyzboy:devel_25_MaterialInstanceArray_in_UBO
hyzboy:master
hyzboy:devel_24_L2WArray_in_UBO
hyzboy:optimize_pipeline_cache
hyzboy:debug_util
hyzboy:devel_23_instance

8 Commits
devel_40_W ... devel_36_P

Author SHA1 Message Date
hyzboy
11ca8e7fdf refactored RenderTarget 2025-01-26 23:21:53 +08:00
hyzboy
02ac76e5bd optimized RenderCmdBuffer::BindFramebuffer 2025-01-26 12:32:24 +08:00
hyzboy
39aa63aa0a fix a bug in CreateCircle3DByIndexTrianges of InlineGeometry.cpp, that it's vertex_count error. 2025-01-25 14:59:04 +08:00
hyzboy
d73966b1d0 Moved render_cmd_buffer to SwapchainImage from VulkanAppFramework 2025-01-25 01:30:13 +08:00
hyzboy
c9b99dd125 support vk 1.4 features output. 2025-01-25 00:37:12 +08:00
hyzboy
ea6c009c70 removed GPUDevice::device_render_pass 2025-01-25 00:15:00 +08:00
hyzboy
6080422f3a use multi depth in Swapchain FBO 2025-01-24 23:45:37 +08:00
hyzboy
6ca0cd2987 Added DebugUtils::SetTexture 2025-01-24 23:44:55 +08:00
266 changed files with 4762 additions and 7533 deletions
Show Stats Expand all files Collapse all files

8
.editorconfig
View File

@ -1,8 +0,0 @@
root = true
[*]
indent_style = space
indent_size = 4
insert_final_newline = true
trim_trailing_whitespace = true

14
.gitmodules vendored
View File

@ -1,21 +1,21 @@
[submodule "CMCMakeModule"]
path = CMCMakeModule
url = https://github.com/hyzboy/CMCMakeModule
url = http://www.hyzgame.com:3000/hyzboy/CMCMakeModule
[submodule "CMCore"]
path = CMCore
url = https://github.com/hyzboy/CMCore
url = http://www.hyzgame.com:3000/hyzboy/CMCore
[submodule "CMPlatform"]
path = CMPlatform
url = https://github.com/hyzboy/CMPlatform
url = http://www.hyzgame.com:3000/hyzboy/CMPlatform
[submodule "CMAssetsManage"]
path = CMAssetsManage
url = https://github.com/hyzboy/CMAssetsManage.git
url = http://www.hyzgame.com:3000/hyzboy/CMAssetsManage.git
[submodule "res"]
path = res
url = https://github.com/hyzboy/RuntimeData.git
url = http://www.hyzgame.com:3000/hyzboy/RuntimeData.git
[submodule "CMSceneGraph"]
path = CMSceneGraph
url = https://github.com/hyzboy/CMSceneGraph.git
url = http://www.hyzgame.com:3000/hyzboy/CMSceneGraph.git
[submodule "CMUtil"]
path = CMUtil
url = https://github.com/hyzboy/CMUtil.git
url = http://www.hyzgame.com:3000/hyzboy/CMUtil.git

2
CMAssetsManage

@ -1 +1 @@
Subproject commit 0244bff1b60119806f683b54a137cda2cacc17ac
Subproject commit 0fae462338cd01c5a26d0a8f0175fe3729a65c94

2
CMCMakeModule

@ -1 +1 @@
Subproject commit 6fbc7078181cefc7e5da590c2d4ccc70507934b7
Subproject commit 737fe5c80d013f807cbb8f4d333d5a59c82571bc

2
CMCore

@ -1 +1 @@
Subproject commit c5b37f98353441520374011020dbe63c17796a4d
Subproject commit 9dd89aa5a34ef90b983895d32645df9b53cce955

2
CMPlatform

@ -1 +1 @@
Subproject commit f0ff214289a1265898feecbdbbd2ddf50bff5dca
Subproject commit aa7abe47631cdb687528400409ef295fd2c050b8

2
CMSceneGraph

@ -1 +1 @@
Subproject commit 74e33b497274e51c35a5ee19a274b12dc86deecb
Subproject commit 2370ba12d7656da491f65be66d9e134484377866

2
CMUtil

@ -1 +1 @@
Subproject commit 48383e5f63928bab43320c406219365850507246
Subproject commit 57ff3a70c99265ed7bb97b3b6840709e84bac0c1

38
CMakeLists.txt
View File

@ -8,35 +8,35 @@ set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/CMCMakeModule)
set(ULRE_3RDPTY_ROOT_PATH ${CMAKE_CURRENT_SOURCE_DIR}/3rdpty)
include_directories(${ULRE_3RDPTY_ROOT_PATH}/NvTriStrip)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/inc)
SET(ROOT_INCLUDE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/inc)
SET(ULRE_RUNTIME_PATH ${CMAKE_CURRENT_SOURCE_DIR})
include(math)
include(vulkan)
include(use_cm_module)
SET(ULRE CMCore
CMPlatform
CMAssetsManage
CMSceneGraph
CMUtil
ULRE.Work
ULRE.Util
ULRE.ShaderGen
ULRE.SceneGraph
${HGL_MATH_LIB}
${RENDER_LIBRARY}
${Vulkan_LIBRARIES})
use_cm_module(Core)
use_cm_module(Util)
use_cm_module(Platform)
use_cm_module(AssetsManage)
use_cm_module(SceneGraph)
SET(ULRE CMCore
CMPlatform
CMAssetsManage
CMSceneGraph
CMUtil
ULRE.Util
ULRE.ShaderGen
ULRE.SceneGraph
${HGL_MATH_LIB}
${RENDER_LIBRARY}
${Vulkan_LIBRARIES})
include_directories(${ULRE_3RDPTY_ROOT_PATH}/NvTriStrip)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/inc)
SET(ROOT_INCLUDE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/inc)
SET(ULRE_RUNTIME_PATH ${CMAKE_CURRENT_SOURCE_DIR})
add_subdirectory(src)
add_subdirectory(example)

28
doc/AssetPath.md
View File

@ -1,28 +0,0 @@
# AssetPath
具体源代码参见CMAssetManage中的AssetPath.h
# 大致规则
Asset代表的资产，意味应用程序本身所拥有的资源。而AssetPath意味指向这个资产的一个字符串。
AssetPath的组成规和Windows/UNIX/Linux的路径原则类似，大致如下：
```C++
LOCATION:/abc/123/test_material.mtl
```
LOCATION 它代表资产所在的大范围位置，是可以不存在的，也就是说如下的写法也是可以的
```C++
:/abc/123/test_material.mtl
```
这个LOCATION的定义我们暂时有以下几个：
| LOCATION | 意义 |
|----------|------------------|
| 不写 | 应用程序本身的资产包 |
| Asset | 应用程序本身的资产包 |
| Engine | 代表引擎资产 |
| PlugIn | 代表插件资产 |
| ExtPack | 应用程序扩展资产包(一般用于额外安装或下载的资产包) |
| OS | 操作系统真实路径访问 |

47
doc/CreateMaterialInstance.md
View File

@ -1,47 +0,0 @@
# CreateMaterialInstance
## 1st
最早最根本的方法，直接在C++代码层面通过mtl::CreateVertexColor2D()函数来创建MaterialCreateInfo
```C++
mtl::Material2DCreateConfig cfg(GetDeviceAttribute(),"VertexColor2D",PrimitiveType::Triangles);
cfg.coordinate_system=CoordinateSystem2D::NDC;
cfg.local_to_world=false;
AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreateVertexColor2D(&cfg);
material_instance=CreateMaterialInstance(mci);
```
## 2nd
注册材质系统引入后的方法，通过名称"VertexColor2D"来创建MaterialCreateInfo
```C++
mtl::Material2DCreateConfig cfg(GetDeviceAttribute(),"VertexColor2D",PrimitiveType::Triangles);
cfg.coordinate_system=CoordinateSystem2D::NDC;
cfg.local_to_world=false;
AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreateMaterialCreateInfo("VertexColor2D",&cfg);
material_instance=CreateMaterialInstance(mci);
```
## 3rd
其实是第二种方法在WorkObject层面的封装
```C++
mtl::Material2DCreateConfig cfg(GetDeviceAttribute(),"VertexColor2D",PrimitiveType::Triangles);
cfg.coordinate_system=CoordinateSystem2D::NDC;
cfg.local_to_world=false;
material_instance=CreateMaterialInstance("VertexColor2D",&cfg);
```
## 4th
是更进一步的封装，通过材质配置文件连带Material2DCreateConfig的具体配置都进行了封闭。
```C++
AssetPath path(":/asset/test_material.mtl");
material_instance=CreateMaterialInstance(path);
```

20
doc/InlineMaterial.md
View File

@ -1,20 +0,0 @@
# 程序内嵌材质/Shader
# Material/Shader embedded in program code
问题(Question):
```
即然可以从文件中加载材质了，那为什么还需要有程序代码中内嵌的材质/Shader呢？
I can load a material from a file. Why do we need a few materials/shaders embedded in the code?
```
这个问题很好，答案也很简单：
Good question, the answer is straightforward:
```
我们需要在资产损坏或丢失的情况下，依然可以渲染一些内容, 比如: 一个报错对话框。
We need to be able to render some content, such as an error dialog box, even if the asset is damaged or lost.
```

8
example/2dVector/LerpLine.cpp
View File

@ -38,7 +38,7 @@ class TestApp:public VulkanApplicationFramework
private:
MaterialInstance * material_instance =nullptr;
Mesh * render_obj =nullptr;
Renderable * render_obj =nullptr;
Pipeline * pipeline =nullptr;
@ -46,7 +46,7 @@ private:
bool InitAutoMaterial()
{
mtl::Material2DCreateConfig cfg(device->GetDevAttr(),"VertexColor2D",PrimitiveType::Lines);
mtl::Material2DCreateConfig cfg(device->GetDeviceAttribute(),"VertexColor2D",Prim::Lines);
cfg.coordinate_system=CoordinateSystem2D::NDC;
cfg.local_to_world=false;
@ -60,7 +60,7 @@ private:
bool InitPipeline()
{
pipeline=CreatePipeline(material_instance,InlinePipeline::Solid2D,PrimitiveType::Lines);
pipeline=CreatePipeline(material_instance,InlinePipeline::Solid2D,Prim::Lines);
return pipeline;
}
@ -74,7 +74,7 @@ private:
if(!rpc.WriteVAB(VAN::Position, PositionFormat, position_data))return(false);
if(!rpc.WriteVAB(VAN::Color, ColorFormat, color_data ))return(false);
render_obj=db->CreateMesh(&rpc,material_instance,pipeline);
render_obj=db->CreateRenderable(&rpc,material_instance,pipeline);
return(render_obj);
}

8
example/2dVector/line.cpp
View File

@ -36,7 +36,7 @@ private:
Camera cam;
MaterialInstance * material_instance =nullptr;
Mesh * render_obj =nullptr;
Renderable * render_obj =nullptr;
DeviceBuffer * ubo_camera_info =nullptr;
DeviceBuffer * ubo_color_material =nullptr;
DeviceBuffer * ubo_line_config =nullptr;
@ -53,8 +53,8 @@ private:
return(false);
// pipeline=db->CreatePipeline(material_instance,sc_render_target,OS_TEXT("res/pipeline/solid2d"));
//pipeline=CreatePipeline(material_instance,OS_TEXT("res/pipeline/alpha2d"),PrimitiveType::LineStrip); //等同上一行，为Framework重载，默认使用swapchain的render target
pipeline=CreatePipeline(material_instance,InlinePipeline::Alpha2D,PrimitiveType::LineStrip); //等同上一行，为Framework重载，默认使用swapchain的render target
//pipeline=CreatePipeline(material_instance,OS_TEXT("res/pipeline/alpha2d"),Prim::LineStrip); //等同上一行，为Framework重载，默认使用swapchain的render target
pipeline=CreatePipeline(material_instance,InlinePipeline::Alpha2D,Prim::LineStrip); //等同上一行，为Framework重载，默认使用swapchain的render target
if(!pipeline)
return(false);
@ -118,7 +118,7 @@ private:
if(!primitive->Set(VAN::Position, db->CreateVAB(VF_V2F,VERTEX_COUNT,position_data)))return(false);
render_obj=db->CreateMesh(primitive,material_instance,pipeline);
render_obj=db->CreateRenderable(primitive,material_instance,pipeline);
return(true);
}

6
example/2dVector/roundbox.cpp
View File

@ -42,7 +42,7 @@ private:
Camera cam;
MaterialInstance * material_instance =nullptr;
Mesh * render_obj =nullptr;
Renderable * render_obj =nullptr;
DeviceBuffer * ubo_camera_info =nullptr;
DeviceBuffer * ubo_rb_config =nullptr;
@ -66,7 +66,7 @@ private:
if(!material_instance)
return(false);
pipeline=CreatePipeline(material_instance,OS_TEXT("res/pipeline/alpha2d"),PrimitiveType::SolidRectangles); //等同上一行，为Framework重载，默认使用swapchain的render target
pipeline=CreatePipeline(material_instance,OS_TEXT("res/pipeline/alpha2d"),Prim::SolidRectangles); //等同上一行，为Framework重载，默认使用swapchain的render target
if(!pipeline)
return(false);
@ -140,7 +140,7 @@ private:
if(!primitive->Set(VAN::Position, db->CreateVAB(VF_V4I16,VERTEX_COUNT,position_data)))return(false);
render_obj=db->CreateMesh(primitive,material_instance,pipeline);
render_obj=db->CreateRenderable(primitive,material_instance,pipeline);
return(true);
}

79
example/Basic/BillboardTest.cpp
View File

@ -1,6 +1,6 @@
// Billboard
#include<hgl/WorkManager.h>
#include"VulkanAppFramework.h"
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKRenderResource.h>
@ -11,9 +11,6 @@
#include<hgl/graph/mtl/Material3DCreateConfig.h>
#include<hgl/graph/VertexDataManager.h>
#include<hgl/graph/VKVertexInputConfig.h>
#include<hgl/graph/module/TextureManager.h>
#include<hgl/graph/FirstPersonCameraControl.h>
#include<hgl/component/MeshComponent.h>
using namespace hgl;
using namespace hgl::graph;
@ -28,7 +25,7 @@ static float lumiance_data[2]={1,1};
static Color4f white_color(1,1,1,1);
static Color4f yellow_color(1,1,0,1);
class TestApp:public WorkObject
class TestApp:public SceneAppFramework
{
Color4f color;
@ -41,7 +38,7 @@ private:
MaterialInstance * mi_billboard =nullptr;
Pipeline * pipeline_billboard =nullptr;
Mesh * ro_billboard =nullptr;
Renderable * ro_billboard =nullptr;
Texture2D * texture =nullptr;
Sampler * sampler =nullptr;
@ -50,7 +47,7 @@ private:
bool InitPlaneGridMP()
{
mtl::Material3DCreateConfig cfg(PrimitiveType::Lines);
mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"VertexLuminance3D",Prim::Lines);
cfg.local_to_world=true;
@ -67,7 +64,7 @@ private:
mi_plane_grid=db->CreateMaterialInstance(mtl_plane_grid,&vil_config,&white_color);
if(!mi_plane_grid)return(false);
pipeline_plane_grid=CreatePipeline(mi_plane_grid,InlinePipeline::Solid3D);
pipeline_plane_grid=CreatePipeline(mi_plane_grid,InlinePipeline::Solid3D,Prim::Lines);
if(!pipeline_plane_grid)return(false);
}
@ -76,15 +73,17 @@ private:
bool InitBillboardMP()
{
mtl::BillboardMaterialCreateConfig cfg(PrimitiveType::Billboard);
mtl::BillboardMaterialCreateConfig cfg(device->GetDeviceAttribute(),"Billboard2D",Prim::Billboard);
{
cfg.fixed_size=true;
mi_billboard=CreateMaterialInstance(mtl::inline_material::Billboard2D,&cfg);
AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreateBillboard2D(&cfg);
mi_billboard=db->CreateMaterialInstance(mci);
if(!mi_billboard)return(false);
pipeline_billboard=CreatePipeline(mi_billboard,InlinePipeline::Solid3D);
pipeline_billboard=CreatePipeline(mi_billboard,InlinePipeline::Solid3D,Prim::Billboard);
if(!pipeline_billboard)return(false);
}
@ -93,9 +92,7 @@ private:
bool InitTexture()
{
TextureManager *tex_manager=GetTextureManager();
texture=tex_manager->LoadTexture2D(OS_TEXT("res/image/lena.Tex2D"),true);
texture=db->LoadTexture2D(OS_TEXT("res/image/lena.Tex2D"),true);
if(!texture)return(false);
sampler=db->CreateSampler();
@ -113,12 +110,27 @@ private:
return(true);
}
Renderable *Add(Primitive *r,MaterialInstance *mi,Pipeline *p)
{
Renderable *ri=db->CreateRenderable(r,mi,p);
if(!ri)
{
LOG_ERROR(OS_TEXT("Create Renderable failed."));
return(nullptr);
}
render_root.Add(new SceneNode(ri));
return ri;
}
bool CreateRenderObject()
{
using namespace inline_geometry;
{
auto pc=GetPrimitiveCreater(mi_plane_grid);
PrimitiveCreater pc(device,mi_plane_grid->GetVIL());
struct PlaneGridCreateInfo pgci;
@ -128,19 +140,18 @@ private:
pgci.lum=128;
pgci.sub_lum=192;
prim_plane_grid=CreatePlaneGrid2D(pc,&pgci);
prim_plane_grid=CreatePlaneGrid2D(&pc,&pgci);
}
{
auto pc=GetPrimitiveCreater(mi_billboard);
PrimitiveCreater pc(device,mi_billboard->GetVIL());
pc->Init("Billboard",1);
pc.Init("Billboard",1);
if(!pc->WriteVAB(VAN::Position,VF_V3F,position_data))
if(!pc.WriteVAB(VAN::Position,VF_V3F,position_data))
return(false);
ro_billboard=db->CreateMesh(pc,mi_billboard,pipeline_billboard);
ro_billboard=db->CreateRenderable(&pc,mi_billboard,pipeline_billboard);
if(!ro_billboard)
return(false);
}
@ -150,30 +161,32 @@ private:
bool InitScene()
{
SceneNode *scene_root=GetSceneRoot(); //取得缺省场景根节点
Add(prim_plane_grid,mi_plane_grid,pipeline_plane_grid);
CreateComponent<MeshComponent>(scene_root,db->CreateMesh(prim_plane_grid,mi_plane_grid,pipeline_plane_grid));
CreateComponent<MeshComponent>(scene_root,ro_billboard);
render_root.Add(new SceneNode(ro_billboard));
CameraControl *camera_control=GetCameraControl();
camera_control->SetPosition(Vector3f(32,32,32));
camera->pos=Vector3f(32,32,32);
camera_control->SetTarget(Vector3f(0,0,0));
camera_control->Refresh();
render_root.RefreshMatrix();
render_list->Expend(&render_root);
return(true);
}
public:
using WorkObject::WorkObject;
~TestApp()
{
SAFE_CLEAR(prim_plane_grid);
}
bool Init() override
bool Init(uint w,uint h)
{
if(!SceneAppFramework::Init(w,h))
return(false);
if(!InitPlaneGridMP())
return(false);
@ -191,9 +204,9 @@ public:
return(true);
}
};//class TestApp:public WorkObject
};//class TestApp:public CameraAppFramework
int os_main(int,os_char **)
int main(int,char **)
{
return RunFramework<TestApp>(OS_TEXT("Billboard"),1280,720);
return RunApp<TestApp>(1920,1080);
}

10
example/Basic/CMakeLists.txt
View File

@ -1,5 +1,4 @@
macro(CreateProject name)
add_executable(${name} ${ARGN} ${VULKAN_APP_FRAMEWORK})
target_link_libraries(${name} ${ULRE})
@ -11,8 +10,9 @@
set_property(TARGET ${name} PROPERTY FOLDER "ULRE/Example/Basic")
endmacro()
CreateProject(01_draw_triangle draw_triangle_use_UBO.cpp)
CreateProject(02_auto_instance auto_instance.cpp)
CreateProject(03_auto_merge_material_instance auto_merge_material_instance.cpp)
CreateProject(01_draw_triangle_in_NDC draw_triangle_in_NDC.cpp)
CreateProject(02_draw_triangle_use_UBO draw_triangle_use_UBO.cpp)
CreateProject(03_auto_instance auto_instance.cpp)
CreateProject(04_auto_merge_material_instance auto_merge_material_instance.cpp)
CreateProject(04_Billboard BillboardTest.cpp)
CreateProject(05_Billboard BillboardTest.cpp)

6
example/Basic/MaterialLoader/MaterialLoader.cpp
View File

@ -1,6 +0,0 @@
#include<hgl/graph/mtl/MaterialLibrary.h>
STD_MTL_NAMESPACE_BEGIN
STD_MTL_NAMESPACE_END

79
example/Basic/auto_instance.cpp
View File

@ -1,15 +1,18 @@
// 该范例主要演示使用RenderList系统绘制多个三角形，并利用RenderList进行排序以及自动合并进行Instance渲染
#include<hgl/WorkManager.h>
#include"VulkanAppFramework.h"
#include<hgl/math/Math.h>
#include<hgl/graph/PrimitiveCreater.h>
#include<hgl/graph/VKVertexInputConfig.h>
#include<hgl/graph/mtl/Material2DCreateConfig.h>
#include<hgl/component/MeshComponent.h>
#include<hgl/graph/RenderList.h>
using namespace hgl;
using namespace hgl::graph;
constexpr uint32_t SCREEN_WIDTH=1024;
constexpr uint32_t SCREEN_HEIGHT=1024;
constexpr uint32_t VERTEX_COUNT=3;
constexpr uint32_t TRIANGLE_NUMBER=12;
@ -28,12 +31,15 @@ constexpr uint8 color_data[VERTEX_COUNT][4]=
{0,0,255,255}
};
class TestApp:public WorkObject
class TestApp:public VulkanApplicationFramework
{
private:
SceneNode render_root;
RenderList * render_list =nullptr;
MaterialInstance * material_instance =nullptr;
Mesh * render_obj =nullptr;
Renderable * render_obj =nullptr;
Pipeline * pipeline =nullptr;
@ -42,33 +48,39 @@ private:
bool InitMaterial()
{
{
mtl::Material2DCreateConfig cfg(PrimitiveType::Triangles,
CoordinateSystem2D::NDC,
mtl::WithLocalToWorld::With);
mtl::Material2DCreateConfig cfg(device->GetDeviceAttribute(),"VertexColor2D",Prim::Triangles);
cfg.coordinate_system=CoordinateSystem2D::NDC;
cfg.local_to_world=true;
AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreateVertexColor2D(&cfg);
VILConfig vil_config;
vil_config.Add(VAN::Color,VF_V4UN8);
material_instance=CreateMaterialInstance(mtl::inline_material::VertexColor2D,&cfg,&vil_config);
material_instance=db->CreateMaterialInstance(mci,&vil_config);
}
if(!material_instance)
return(false);
// pipeline=db->CreatePipeline(material_instance,sc_render_target,OS_TEXT("res/pipeline/solid2d"));
pipeline=CreatePipeline(material_instance,InlinePipeline::Solid2D); //等同上一行，为Framework重载，默认使用swapchain的render target
pipeline=CreatePipeline(material_instance,InlinePipeline::Solid2D,Prim::Triangles); //等同上一行，为Framework重载，默认使用swapchain的render target
return pipeline;
}
bool InitVBO()
{
render_obj=CreateMesh("Triangle",VERTEX_COUNT,material_instance,pipeline,
{
{VAN::Position, VF_V2F, position_data},
{VAN::Color, VF_V4UN8, color_data }
});
PrimitiveCreater rpc(device,material_instance->GetVIL());
rpc.Init("Triangle",VERTEX_COUNT);
if(!rpc.WriteVAB(VAN::Position, VF_V2F, position_data))return(false);
if(!rpc.WriteVAB(VAN::Color, VF_V4UN8, color_data ))return(false);
render_obj=db->CreateRenderable(&rpc,material_instance,pipeline);
if(!render_obj)
return(false);
@ -76,26 +88,34 @@ private:
double rad;
Matrix4f mat;
SceneNode *scene_root=GetSceneRoot(); ///<取得场景根节点
for(uint i=0;i<TRIANGLE_NUMBER;i++)
{
rad=deg2rad<double>((360.0f/double(TRIANGLE_NUMBER))*i); //这里一定要加<double>或<float>，否则结果用int保存会出现问题
rad=deg2rad<double>((360/TRIANGLE_NUMBER)*i); //这里一定要加<float>或<float>，否则结果用int保存会出现问题
mat=rotate(rad,Vector3f(0,0,1));
CreateComponent<MeshComponent>(mat,scene_root,render_obj);
render_root.Add(new SceneNode(mat,render_obj));
}
render_root.RefreshMatrix();
render_list->Expend(&render_root);
return(true);
}
public:
using WorkObject::WorkObject;
bool Init() override
~TestApp()
{
GetRenderer()->SetClearColor(Color4f(0.2f,0.2f,0.2f,1.0f));
SAFE_CLEAR(render_list);
}
bool Init(uint w,uint h)
{
if(!VulkanApplicationFramework::Init(w,h))
return(false);
render_list=new RenderList(device);
if(!InitMaterial())
return(false);
@ -103,11 +123,20 @@ public:
if(!InitVBO())
return(false);
BuildCommandBuffer(render_list);
return(true);
}
};//class TestApp:public WorkObject
int os_main(int,os_char **)
void Resize(uint w,uint h)override
{
VulkanApplicationFramework::Resize(w,h);
BuildCommandBuffer(render_list);
}
};//class TestApp:public VulkanApplicationFramework
int main(int,char **)
{
return RunFramework<TestApp>(OS_TEXT("AutoInstance"),1024,1024);
return RunApp<TestApp>(SCREEN_WIDTH,SCREEN_HEIGHT);
}

84
example/Basic/auto_merge_material_instance.cpp
View File

@ -1,15 +1,18 @@
// 该范例主要演示使用一个材质下的不同材质实例传递颜色参数绘制三角形，并依赖RenderList中的自动合并功能，让同一材质下所有不同材质实例的对象一次渲染完成。
#include<hgl/WorkManager.h>
#include"VulkanAppFramework.h"
#include<hgl/math/Math.h>
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/mtl/Material2DCreateConfig.h>
#include<hgl/graph/RenderList.h>
#include<hgl/color/Color.h>
#include<hgl/component/MeshComponent.h>
using namespace hgl;
using namespace hgl::graph;
constexpr uint32_t SCREEN_WIDTH=1024;
constexpr uint32_t SCREEN_HEIGHT=1024;
constexpr uint32_t VERTEX_COUNT=3;
constexpr float position_data[VERTEX_COUNT*2]=
@ -20,18 +23,22 @@ constexpr float position_data[VERTEX_COUNT*2]=
};
constexpr uint DRAW_OBJECT_COUNT=12;
constexpr double TRI_ROTATE_ANGLE=360.0f/DRAW_OBJECT_COUNT;
#define USE_MATERIAL_FILE true //是否使用材质文件
class TestApp:public WorkObject
class TestApp:public VulkanApplicationFramework
{
private:
SceneNode render_root;
RenderList * render_list =nullptr;
Material * material =nullptr;
struct
{
MaterialInstance * mi;
Mesh * mesh;
Renderable * r;
}render_obj[DRAW_OBJECT_COUNT]{};
Pipeline * pipeline =nullptr;
@ -41,7 +48,10 @@ private:
bool InitMaterial()
{
{
mtl::Material2DCreateConfig cfg(PrimitiveType::Triangles,CoordinateSystem2D::NDC,mtl::WithLocalToWorld::With);
mtl::Material2DCreateConfig cfg(device->GetDeviceAttribute(),"PureColor2D",Prim::Triangles);
cfg.coordinate_system=CoordinateSystem2D::NDC;
cfg.local_to_world=true;
#ifndef USE_MATERIAL_FILE
AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreatePureColor2D(&cfg); //走程序内置材质创建函数
@ -66,16 +76,22 @@ private:
}
}
pipeline=CreatePipeline(material,InlinePipeline::Solid2D);
pipeline=CreatePipeline(material,InlinePipeline::Solid2D,Prim::Triangles);
return pipeline;
}
bool InitVBOAndRenderList()
{
Primitive *prim=CreatePrimitive("Triangle",VERTEX_COUNT,material->GetDefaultVIL(),
{{VAN::Position, VF_V2F, position_data}});
PrimitiveCreater pc(device,material->GetDefaultVIL());
if(!pc.Init("Triangle",VERTEX_COUNT))
return(false);
if(!pc.WriteVAB(VAN::Position, VF_V2F, position_data))
return(false);
Primitive *prim=pc.Create();
if(!prim)
return(false);
@ -83,40 +99,66 @@ private:
Matrix4f mat;
SceneNode *scene_root=GetSceneRoot(); ///<取得场景根节点
for(uint i=0;i<DRAW_OBJECT_COUNT;i++)
{
render_obj[i].mesh=db->CreateMesh(prim,render_obj[i].mi,pipeline);
render_obj[i].r=db->CreateRenderable(prim,render_obj[i].mi,pipeline);
if(!render_obj[i].mesh)
if(!render_obj[i].r)
return(false);
mat=rotate(deg2rad<double>(TRI_ROTATE_ANGLE*i),AxisVector::Z);
mat=rotate(deg2rad<double>(double(360/DRAW_OBJECT_COUNT*i)),AxisVector::Z);
CreateComponent<MeshComponent>(mat,scene_root,render_obj[i].mesh);
render_root.Add(new SceneNode(mat,render_obj[i].r));
}
render_root.RefreshMatrix();
render_list->Expend(&render_root);
return(true);
}
public:
using WorkObject::WorkObject;
bool Init() override
~TestApp()
{
SAFE_CLEAR(render_list);
}
bool Init()
{
if(!VulkanApplicationFramework::Init(SCREEN_WIDTH,SCREEN_HEIGHT))
return(false);
render_list=new RenderList(device);
if(!InitMaterial())
return(false);
if(!InitVBOAndRenderList())
return(false);
BuildCommandBuffer(render_list);
return(true);
}
};//class TestApp:public WorkObject
int os_main(int,os_char **)
void Resize(uint w,uint h)override
{
VulkanApplicationFramework::Resize(w,h);
BuildCommandBuffer(render_list);
}
};//class TestApp:public VulkanApplicationFramework
int main(int,char **)
{
return RunFramework<TestApp>(OS_TEXT("AutoInstance"),1024,1024);
TestApp app;
if(!app.Init())
return(-1);
while(app.Run());
return 0;
}

158
example/Basic/draw_triangle_in_NDC.cpp Normal file
View File

@ -0,0 +1,158 @@
// 该范例主要演示使用NDC坐标系直接绘制一个渐变色的三角形
#include"VulkanAppFramework.h"
#include<hgl/math/HalfFloat.h>
#include<hgl/graph/VKVertexInputConfig.h>
#include<hgl/graph/PrimitiveCreater.h>
#include<hgl/graph/mtl/Material2DCreateConfig.h>
using namespace hgl;
using namespace hgl::graph;
constexpr uint32_t SCREEN_WIDTH=1280;
constexpr uint32_t SCREEN_HEIGHT=720;
constexpr uint32_t VERTEX_COUNT=3;
constexpr float position_data_float[VERTEX_COUNT*2]=
{
0.0, -0.5,
-0.5, 0.5,
0.5, 0.5
};
#define USE_HALF_FLOAT_POSITION
#ifdef USE_HALF_FLOAT_POSITION
constexpr VkFormat PositionFormat=VF_V2HF;
half_float position_data_hf[VERTEX_COUNT*2];
#define position_data position_data_hf
#else
constexpr VkFormat PositionFormat=VF_V2F;
#define position_data position_data_float
#endif//USE_HALF_FLOAT_POSITION
#define USE_UNORM8_COLOR
#ifdef USE_UNORM8_COLOR
constexpr uint8 color_data[VERTEX_COUNT*4]=
{ 255,0,0,255,
0,255,0,255,
0,0,255,255
};
constexpr VkFormat ColorFormat=VF_V4UN8;
#else
constexpr float color_data[VERTEX_COUNT*4]=
{ 1,0,0,1,
0,1,0,1,
0,0,1,1
};
constexpr VkFormat ColorFormat=VF_V4F;
#endif//USE_UNORM8_COLOR
class TestApp:public VulkanApplicationFramework
{
private:
#if defined(USE_HALF_FLOAT_POSITION)||defined(USE_UNORM8_COLOR)
VILConfig vil_config;
#endif
MaterialInstance * material_instance =nullptr;
Renderable * render_obj =nullptr;
Pipeline * pipeline =nullptr;
private:
void InitVIL()
{
#ifdef USE_HALF_FLOAT_POSITION
vil_config.Add(VAN::Position,PositionFormat);
#endif//USE_HALF_FLOAT_POSITION
#ifdef USE_UNORM8_COLOR
vil_config.Add(VAN::Color,ColorFormat);
#endif//USE_HALF_FLOAT_POSITION
}
bool InitAutoMaterial()
{
mtl::Material2DCreateConfig cfg(device->GetDeviceAttribute(),"VertexColor2d",Prim::Triangles);
cfg.coordinate_system=CoordinateSystem2D::NDC;
cfg.local_to_world=false;
AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreateVertexColor2D(&cfg);
material_instance=db->CreateMaterialInstance(mci,&vil_config);
return material_instance;
}
bool InitPipeline()
{
// pipeline=db->CreatePipeline(material_instance,sc_render_target,OS_TEXT("res/pipeline/solid2d"));
pipeline=CreatePipeline(material_instance,InlinePipeline::Solid2D,Prim::Triangles); //等同上一行，为Framework重载，默认使用swapchain的render target
return pipeline;
}
bool InitVBO()
{
PrimitiveCreater rpc(device,material_instance->GetVIL());
rpc.Init("Triangle",VERTEX_COUNT);
#ifdef USE_HALF_FLOAT_POSITION
Float32toFloat16(position_data_hf,position_data_float,VERTEX_COUNT*2);
#endif//USE_HALF_FLOAT_POSITION
if(!rpc.WriteVAB(VAN::Position, PositionFormat, position_data))return(false);
if(!rpc.WriteVAB(VAN::Color, ColorFormat, color_data ))return(false);
render_obj=db->CreateRenderable(&rpc,material_instance,pipeline);
return(render_obj);
}
public:
bool Init(uint w,uint h)
{
if(!VulkanApplicationFramework::Init(w,h))
return(false);
InitVIL();
if(!InitAutoMaterial())
return(false);
if(!InitPipeline())
return(false);
if(!InitVBO())
return(false);
if(!BuildCommandBuffer(render_obj))
return(false);
return(true);
}
void Resize(uint w,uint h)override
{
VulkanApplicationFramework::Resize(w,h);
BuildCommandBuffer(render_obj);
}
};//class TestApp:public VulkanApplicationFramework
int main(int,char **)
{
return RunApp<TestApp>(SCREEN_WIDTH,SCREEN_HEIGHT);
}

94
example/Basic/draw_triangle_use_UBO.cpp
View File

@ -1,12 +1,10 @@
// 该范例主要演示使用2D坐系统直接绘制一个渐变色的三角形,使用UBO传递Viewport信息
#include<hgl/WorkManager.h>
#include"VulkanAppFramework.h"
#include<hgl/graph/VKVertexInputConfig.h>
#include<hgl/graph/PrimitiveCreater.h>
#include<hgl/graph/mtl/Material2DCreateConfig.h>
#include<hgl/component/MeshComponent.h>
using namespace hgl;
using namespace hgl::graph;
@ -19,7 +17,7 @@ static float position_data_float[VERTEX_COUNT][2]=
{0.25, 0.75}
};
static int16 position_data[VERTEX_COUNT][2]={};
static uint16 position_data_u16[VERTEX_COUNT][2]={};
constexpr uint8 color_data[VERTEX_COUNT*4]=
{
@ -28,17 +26,14 @@ constexpr uint8 color_data[VERTEX_COUNT*4]=
0,0,255,255
};
constexpr VAType POSITION_SHADER_FORMAT =VAT_IVEC2;
constexpr VkFormat POSITION_DATA_FORMAT =VF_V2I16;
//#define USE_ZERO2ONE_COORD //使用左上角0,0右下角1,1的坐标系
constexpr VkFormat COLOR_DATA_FORMAT =VF_V4UN8;
class TestApp:public WorkObject
class TestApp:public VulkanApplicationFramework
{
private:
MaterialInstance * material_instance =nullptr;
Mesh * mesh_triangle =nullptr;
Renderable * render_obj =nullptr;
Pipeline * pipeline =nullptr;
@ -46,70 +41,93 @@ private:
bool InitMaterial()
{
mtl::Material2DCreateConfig cfg(PrimitiveType::Triangles,
CoordinateSystem2D::Ortho,
mtl::WithLocalToWorld::With);
mtl::Material2DCreateConfig cfg(device->GetDeviceAttribute(),"VertexColor2D",Prim::Triangles);
VILConfig vil_config;
cfg.position_format = POSITION_SHADER_FORMAT; //这里指定shader中使用ivec2当做顶点输入格式
#ifdef USE_ZERO2ONE_COORD
cfg.coordinate_system=CoordinateSystem2D::ZeroToOne;
#else
cfg.coordinate_system=CoordinateSystem2D::Ortho;
cfg.position_format =VAT_UVEC2; //这里指定shader中使用uvec2当做顶点输入格式
// ^
// + 这上下两种格式要配套，否则会出错
// v
vil_config.Add(VAN::Position, POSITION_DATA_FORMAT); //这里指定VAB中使用RG16I当做顶点数据格式
vil_config.Add(VAN::Position,VF_V2U16); //这里指定VAB中使用RG16U当做顶点数据格式
#endif//USE_ZERO2ONE_COORD
vil_config.Add(VAN::Color, COLOR_DATA_FORMAT); //这里指定VAB中使用RGBA8UNorm当做颜色数据格式
vil_config.Add(VAN::Color,VF_V4UN8); //这里指定VAB中使用RGBA8UNorm当做颜色数据格式
material_instance=CreateMaterialInstance(mtl::inline_material::VertexColor2D,&cfg,&vil_config);
cfg.local_to_world=false;
AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreateVertexColor2D(&cfg);
material_instance=db->CreateMaterialInstance(mci,&vil_config);
if(!material_instance)
return(false);
// pipeline=db->CreatePipeline(material_instance,sc_render_target,OS_TEXT("res/pipeline/solid2d"));
pipeline=CreatePipeline(material_instance,InlinePipeline::Solid2D); //等同上一行，为Framework重载，默认使用swapchain的render target
pipeline=CreatePipeline(material_instance,InlinePipeline::Solid2D,Prim::Triangles); //等同上一行，为Framework重载，默认使用swapchain的render target
return pipeline;
}
bool InitVBO()
{
const auto ext=GetExtent();
PrimitiveCreater rpc(device,material_instance->GetVIL());
for(uint i=0;i<VERTEX_COUNT;i++)
{
position_data[i][0]=position_data_float[i][0]*ext.width;
position_data[i][1]=position_data_float[i][1]*ext.height;
}
rpc.Init("Triangle",VERTEX_COUNT);
mesh_triangle=CreateMesh("Triangle",VERTEX_COUNT,material_instance,pipeline,
{
{VAN::Position,POSITION_DATA_FORMAT,position_data},
{VAN::Color, COLOR_DATA_FORMAT, color_data}
});
#ifdef USE_ZERO2ONE_COORD //使用0 to 1坐标系
if(!rpc.WriteVAB(VAN::Position, VF_V2F, position_data_float ))return(false);
#else //使用ortho坐标系
if(!rpc.WriteVAB(VAN::Position, VF_V2U16, position_data_u16 ))return(false);
#endif//USE_ZERO2ONE_COORD
if(!mesh_triangle)
return(false);
if(!rpc.WriteVAB(VAN::Color, VF_V4UN8, color_data ))return(false);
return CreateComponent<MeshComponent>(GetSceneRoot(),mesh_triangle); //创建一个静态网格组件
render_obj=db->CreateRenderable(&rpc,material_instance,pipeline);
return(true);
}
public:
using WorkObject::WorkObject;
bool Init() override
bool Init(uint w,uint h)
{
if(!VulkanApplicationFramework::Init(w,h))
return(false);
#ifndef USE_ZERO2ONE_COORD
for(uint i=0;i<VERTEX_COUNT;i++)
{
position_data_u16[i][0]=position_data_float[i][0]*w;
position_data_u16[i][1]=position_data_float[i][1]*h;
}
#endif//
if(!InitMaterial())
return(false);
if(!InitVBO())
return(false);
if(!BuildCommandBuffer(render_obj))
return(false);
return(true);
}
};//class TestApp:public WorkObject
int os_main(int,os_char **)
void Resize(uint w,uint h)override
{
VulkanApplicationFramework::Resize(w,h);
BuildCommandBuffer(render_obj);
}
};//class TestApp:public VulkanApplicationFramework
int main(int,char **)
{
return RunFramework<TestApp>(OS_TEXT("Draw triangle use UBO"));
return RunApp<TestApp>(1280,720);
}

4
example/GUI/DrawText.cpp
View File

@ -15,7 +15,7 @@ private:
TextRender * text_render =nullptr;
TextPrimitive * text_primitive =nullptr;
Mesh * render_obj =nullptr;
Renderable * render_obj =nullptr;
public:
@ -44,7 +44,7 @@ private:
if(!text_primitive)
return(false);
render_obj=text_render->CreateMesh(text_primitive);
render_obj=text_render->CreateRenderable(text_primitive);
if(!render_obj)
return(false);

30
example/Gizmo/BlenderAxis.cpp Normal file
View File

@ -0,0 +1,30 @@
// Blender axis
/**
* 0 1 2 3 4 5 6 7
* 0+---------->>>> X
* 1|
* 2|
* 3| +--+
* 4| +--+
* 5|
* 6V
* 7V
*
* 坐标轴参考Blender设计
*
* 单方向坐标轴长度为8
* 最终箭头长度为2
*
* 负责2D平移的方块尺寸为1，位置在3-4
*
*/
/**
* 缩放工具
*/
class GizmoScale
{
public:
};//class GizmoScale

13
example/Gizmo/CMakeLists.txt
View File

@ -10,15 +10,16 @@
set_property(TARGET ${name} PROPERTY FOLDER "ULRE/Example/Gizmo")
endmacro()
CreateProject(01_SimplestAxis SimplestAxis.cpp)
CreateProject(02_PlaneGrid3D PlaneGrid3D.cpp)
CreateProject(03_RayPicking RayPicking.cpp)
CreateProject(01_PlaneGrid3D PlaneGrid3D.cpp)
CreateProject(02_RayPicking RayPicking.cpp)
CreateProject(03_MetricCellsGrid MetricCellsGrid.cpp)
CreateProject(04_Gizmo3DTest GizmoTest.cpp
Gizmo.h
GizmoResource.h
GizmoResource.cpp
Gizmo3DMove.cpp
#Gizmo3DScale.cpp
#Gizmo3DRotate.cpp
)
Gizmo3DScale.cpp
Gizmo3DRotate.cpp)
#CreateProject(03_BlenderAxis BlenderAxis.cpp)

10
example/Gizmo/Gizmo.h
View File

@ -31,13 +31,13 @@ enum class GizmoShape:uint
ENUM_CLASS_RANGE(Square,Torus)
};
bool InitGizmoResource(RenderFramework *);
bool InitGizmoResource(RenderResource *);
void FreeGizmoResource();
Mesh *GetGizmoMesh(const GizmoShape &shape,const GizmoColor &color);
Renderable *GetGizmoRenderable(const GizmoShape &shape,const GizmoColor &color);
SceneNode *GetGizmoMoveNode();
//SceneNode *GetGizmoScaleMesh();
//SceneNode *GetGizmoRotateMesh();
StaticMesh *GetGizmoMoveStaticMesh();
StaticMesh *GetGizmoScaleStaticMesh();
StaticMesh *GetGizmoRotateStaticMesh();
VK_NAMESPACE_END

80
example/Gizmo/Gizmo3DMove.cpp
View File

@ -25,49 +25,46 @@
#include<hgl/graph/SceneNode.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/RenderFramework.h>
#include<hgl/component/MeshComponent.h>
VK_NAMESPACE_BEGIN
namespace
{
static SceneNode *sn_gizmo_move=nullptr;
static StaticMesh *sm_gizmo_move=nullptr;
}//namespace
SceneNode *GetGizmoMoveNode()
StaticMesh *GetGizmoMoveStaticMesh()
{
return sn_gizmo_move;
return sm_gizmo_move;
}
void ClearGizmoMoveNode()
void ClearGizmoMoveStaticMesh()
{
SAFE_CLEAR(sn_gizmo_move);
SAFE_CLEAR(sm_gizmo_move);
}
bool InitGizmoMoveNode(RenderFramework *render_framework)
bool InitGizmoMoveStaticMesh()
{
Mesh *sphere=GetGizmoMesh(GizmoShape::Sphere,GizmoColor::White);
Mesh *cylinder[3]
Renderable *sphere=GetGizmoRenderable(GizmoShape::Sphere,GizmoColor::White);
Renderable *cylinder[3]
{
GetGizmoMesh(GizmoShape::Cylinder,GizmoColor::Red),
GetGizmoMesh(GizmoShape::Cylinder,GizmoColor::Green),
GetGizmoMesh(GizmoShape::Cylinder,GizmoColor::Blue),
GetGizmoRenderable(GizmoShape::Cylinder,GizmoColor::Red),
GetGizmoRenderable(GizmoShape::Cylinder,GizmoColor::Green),
GetGizmoRenderable(GizmoShape::Cylinder,GizmoColor::Blue),
};
Mesh *cone[3]
Renderable *cone[3]
{
GetGizmoMesh(GizmoShape::Cone,GizmoColor::Red),
GetGizmoMesh(GizmoShape::Cone,GizmoColor::Green),
GetGizmoMesh(GizmoShape::Cone,GizmoColor::Blue),
GetGizmoRenderable(GizmoShape::Cone,GizmoColor::Red),
GetGizmoRenderable(GizmoShape::Cone,GizmoColor::Green),
GetGizmoRenderable(GizmoShape::Cone,GizmoColor::Blue),
};
Mesh *square[3]=
Renderable *circle[3]=
{
GetGizmoMesh(GizmoShape::Square,GizmoColor::Red),
GetGizmoMesh(GizmoShape::Square,GizmoColor::Green),
GetGizmoMesh(GizmoShape::Square,GizmoColor::Blue)
GetGizmoRenderable(GizmoShape::Circle,GizmoColor::Red),
GetGizmoRenderable(GizmoShape::Circle,GizmoColor::Green),
GetGizmoRenderable(GizmoShape::Circle,GizmoColor::Blue)
};
if(!sphere)
@ -81,69 +78,72 @@ bool InitGizmoMoveNode(RenderFramework *render_framework)
if(!cone[i])
return(false);
if(!square[i])
if(!circle[i])
return(false);
}
{
sn_gizmo_move=new SceneNode();
SceneNode *root_node=new SceneNode();
sn_gizmo_move->AttachComponent(render_framework->CreateComponent<MeshComponent>(sphere));
root_node->Add(new SceneNode(sphere));
{
Transform tm;
const Vector3f one_scale(1);
const Vector3f square_scale(2);
const Vector3f circle_scale(2);
const Vector3f cylinder_scale(GIZMO_CYLINDER_RADIUS,GIZMO_CYLINDER_RADIUS,GIZMO_CYLINDER_HALF_LENGTH);
{
tm.SetScale(cylinder_scale);
tm.SetTranslation(0,0,GIZMO_CYLINDER_OFFSET);
render_framework->CreateComponent<MeshComponent>(tm.GetMatrix(),sn_gizmo_move,cylinder[2]); //Z 向上圆柱
root_node->Add(new SceneNode(tm,cylinder[2])); //Z 向上圆柱
tm.SetScale(one_scale);
tm.SetTranslation(0,0,GIZMO_CONE_OFFSET);
render_framework->CreateComponent<MeshComponent>(tm.GetMatrix(),sn_gizmo_move,cone[2]); //Z 向上圆锥
root_node->Add(new SceneNode(tm,cone[2])); //Z 向上圆锥
tm.SetScale(square_scale);
tm.SetScale(circle_scale);
tm.SetTranslation(GIZMO_TWO_AXIS_OFFSET,GIZMO_TWO_AXIS_OFFSET,0);
render_framework->CreateComponent<MeshComponent>(tm.GetMatrix(),sn_gizmo_move,square[2]);
root_node->Add(new SceneNode(tm,circle[2]));
}
{
tm.SetScale(cylinder_scale);
tm.SetRotation(AxisVector::Y,90);
tm.SetTranslation(GIZMO_CYLINDER_OFFSET,0,0);
render_framework->CreateComponent<MeshComponent>(tm.GetMatrix(),sn_gizmo_move,cylinder[0]); //X 向右圆柱
root_node->Add(new SceneNode(tm,cylinder[0])); //X 向右圆柱
tm.SetScale(one_scale);
tm.SetTranslation(GIZMO_CONE_OFFSET,0,0);
render_framework->CreateComponent<MeshComponent>(tm.GetMatrix(),sn_gizmo_move,cone[0]); //X 向右圆锥
root_node->Add(new SceneNode(tm,cone[0])); //X 向右圆锥
tm.SetScale(square_scale);
tm.SetScale(circle_scale);
tm.SetTranslation(0,GIZMO_TWO_AXIS_OFFSET,GIZMO_TWO_AXIS_OFFSET);
render_framework->CreateComponent<MeshComponent>(tm.GetMatrix(),sn_gizmo_move,square[0]);
root_node->Add(new SceneNode(tm,circle[0]));
}
{
tm.SetScale(cylinder_scale);
tm.SetRotation(AxisVector::X,-90);
tm.SetTranslation(0,GIZMO_CYLINDER_OFFSET,0);
render_framework->CreateComponent<MeshComponent>(tm.GetMatrix(),sn_gizmo_move,cylinder[1]); //Y 向前圆柱
root_node->Add(new SceneNode(tm,cylinder[1])); //Y 向前圆柱
tm.SetScale(one_scale);
tm.SetTranslation(0,GIZMO_CONE_OFFSET,0);
render_framework->CreateComponent<MeshComponent>(tm.GetMatrix(),sn_gizmo_move,cone[1]); //Y 向前圆锥
root_node->Add(new SceneNode(tm,cone[1])); //Y 向前圆锥
tm.SetScale(square_scale);
tm.SetScale(circle_scale);
tm.SetTranslation(GIZMO_TWO_AXIS_OFFSET,0,GIZMO_TWO_AXIS_OFFSET);
render_framework->CreateComponent<MeshComponent>(tm.GetMatrix(),sn_gizmo_move,square[1]);
}
root_node->Add(new SceneNode(tm,circle[1]));
}
}
if(!sn_gizmo_move)
sm_gizmo_move=CreateGizmoStaticMesh(root_node);
}
if(!sm_gizmo_move)
return(false);
return(true);

10
example/Gizmo/Gizmo3DRotate.cpp
View File

@ -22,13 +22,13 @@ void ClearGizmoRotateStaticMesh()
bool InitGizmoRotateStaticMesh()
{
Mesh *torus[4]
Renderable *torus[4]
{
GetGizmoMesh(GizmoShape::Torus,GizmoColor::Red),
GetGizmoMesh(GizmoShape::Torus,GizmoColor::Green),
GetGizmoMesh(GizmoShape::Torus,GizmoColor::Blue),
GetGizmoRenderable(GizmoShape::Torus,GizmoColor::Red),
GetGizmoRenderable(GizmoShape::Torus,GizmoColor::Green),
GetGizmoRenderable(GizmoShape::Torus,GizmoColor::Blue),
GetGizmoMesh(GizmoShape::Torus,GizmoColor::White),
GetGizmoRenderable(GizmoShape::Torus,GizmoColor::White),
};
for(auto *r:torus)

26
example/Gizmo/Gizmo3DScale.cpp
View File

@ -45,26 +45,26 @@ void ClearGizmoScaleStaticMesh()
bool InitGizmoScaleStaticMesh()
{
Mesh *center_cube=GetGizmoMesh(GizmoShape::Cube,GizmoColor::White);
Mesh *cylinder[3]
Renderable *center_cube=GetGizmoRenderable(GizmoShape::Cube,GizmoColor::White);
Renderable *cylinder[3]
{
GetGizmoMesh(GizmoShape::Cylinder,GizmoColor::Red),
GetGizmoMesh(GizmoShape::Cylinder,GizmoColor::Green),
GetGizmoMesh(GizmoShape::Cylinder,GizmoColor::Blue),
GetGizmoRenderable(GizmoShape::Cylinder,GizmoColor::Red),
GetGizmoRenderable(GizmoShape::Cylinder,GizmoColor::Green),
GetGizmoRenderable(GizmoShape::Cylinder,GizmoColor::Blue),
};
Mesh *cube[3]
Renderable *cube[3]
{
GetGizmoMesh(GizmoShape::Cube,GizmoColor::Red),
GetGizmoMesh(GizmoShape::Cube,GizmoColor::Green),
GetGizmoMesh(GizmoShape::Cube,GizmoColor::Blue),
GetGizmoRenderable(GizmoShape::Cube,GizmoColor::Red),
GetGizmoRenderable(GizmoShape::Cube,GizmoColor::Green),
GetGizmoRenderable(GizmoShape::Cube,GizmoColor::Blue),
};
Mesh *square[3]=
Renderable *square[3]=
{
GetGizmoMesh(GizmoShape::Square,GizmoColor::Red),
GetGizmoMesh(GizmoShape::Square,GizmoColor::Green),
GetGizmoMesh(GizmoShape::Square,GizmoColor::Blue)
GetGizmoRenderable(GizmoShape::Square,GizmoColor::Red),
GetGizmoRenderable(GizmoShape::Square,GizmoColor::Green),
GetGizmoRenderable(GizmoShape::Square,GizmoColor::Blue)
};
if(!center_cube)

125
example/Gizmo/GizmoResource.cpp
View File

@ -9,23 +9,21 @@
#include<hgl/color/Color.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/SceneNode.h>
#include<hgl/graph/RenderFramework.h>
#include"GizmoResource.h"
VK_NAMESPACE_BEGIN
bool InitGizmoMoveNode(RenderFramework *);
void ClearGizmoMoveNode();
bool InitGizmoMoveStaticMesh();
void ClearGizmoMoveStaticMesh();
//bool InitGizmoScaleMesh();
//void ClearGizmoScaleMesh();
//
//bool InitGizmoRotateMesh();
//void ClearGizmoRotateMesh();
bool InitGizmoScaleStaticMesh();
void ClearGizmoScaleStaticMesh();
bool InitGizmoRotateStaticMesh();
void ClearGizmoRotateStaticMesh();
namespace
{
static RenderFramework *render_framework=nullptr;
static RenderResource * gizmo_rr=nullptr;
struct GizmoResource
@ -41,26 +39,26 @@ namespace
static GizmoResource gizmo_line{};
static GizmoResource gizmo_triangle{};
struct GizmoMesh
struct GizmoRenderable
{
Primitive *prim;
Mesh *mesh[size_t(GizmoColor::RANGE_SIZE)];
Renderable *renderable[size_t(GizmoColor::RANGE_SIZE)];
};
GizmoMesh gizmo_mesh[size_t(GizmoShape::RANGE_SIZE)]{};
GizmoRenderable gizmo_rederable[size_t(GizmoShape::RANGE_SIZE)]{};
void InitGizmoMesh(const GizmoShape &gs,Primitive *prim,Pipeline *p)
void InitGizmoRenderable(const GizmoShape &gs,Primitive *prim,Pipeline *p)
{
if(!prim)
return;
GizmoMesh *gr=gizmo_mesh+size_t(gs);
GizmoRenderable *gr=gizmo_rederable+size_t(gs);
gr->prim=prim;
for(uint i=0;i<uint(GizmoColor::RANGE_SIZE);i++)
gr->mesh[i]=CreateMesh(prim,gizmo_triangle.mi[i],p);
gr->renderable[i]=CreateRenderable(prim,gizmo_triangle.mi[i],p);
}
bool InitMI(GizmoResource *gr)
@ -82,27 +80,26 @@ namespace
return(true);
}
bool InitGizmoResource2D()
bool InitGizmoResource2D(GPUDevice *device)
{
if(!gizmo_rr)
return(false);
VulkanDevice *device=render_framework->GetDevice();
VulkanDevAttr *dev_attr=device->GetDevAttr();
RenderPass *render_pass=render_framework->GetDefaultRenderPass();
RenderPass *render_pass=device->GetRenderPass();
{
mtl::Material3DCreateConfig cfg(PrimitiveType::Lines);
mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"VertexLuminance3D",Prim::Lines);
cfg.mtl_name="VertexLuminance3D"; //注意必须用不同名字，未来改名材质文件名+cfg hash名
cfg.local_to_world=true;
cfg.position_format=VAT_VEC3;
mtl::MaterialCreateInfo *mci=CreateVertexLuminance3D(dev_attr,&cfg);
mtl::MaterialCreateInfo *mci=CreateVertexLuminance3D(&cfg);
if(!mci)
return(false);
gizmo_line.mtl=gizmo_rr->CreateMaterial("GizmoLine",mci);
gizmo_line.mtl=gizmo_rr->CreateMaterial(mci);
if(!gizmo_line.mtl)
return(false);
@ -110,7 +107,7 @@ namespace
}
{
gizmo_line.pipeline=render_pass->CreatePipeline(gizmo_line.mtl,InlinePipeline::Solid3D);
gizmo_line.pipeline=render_pass->CreatePipeline(gizmo_line.mtl,InlinePipeline::Solid3D,Prim::Lines);
if(!gizmo_line.pipeline)
return(false);
@ -137,27 +134,25 @@ namespace
return(true);
}
bool InitGizmoResource3D()
bool InitGizmoResource3D(GPUDevice *device)
{
if(!gizmo_rr)
return(false);
VulkanDevice *device=render_framework->GetDevice();
VulkanDevAttr *dev_attr=device->GetDevAttr();
RenderPass *render_pass=render_framework->GetDefaultRenderPass();
RenderPass *render_pass=device->GetRenderPass();
{
mtl::Material3DCreateConfig cfg(PrimitiveType::Triangles);
mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"Gizmo3D",Prim::Triangles);
cfg.local_to_world=true;
cfg.material_instance=true;
mtl::MaterialCreateInfo *mci=CreateGizmo3D(dev_attr,&cfg);
mtl::MaterialCreateInfo *mci=CreateMaterialGizmo3D(&cfg);
if(!mci)
return(false);
gizmo_triangle.mtl=gizmo_rr->CreateMaterial("GizmoTriangle",mci);
gizmo_triangle.mtl=gizmo_rr->CreateMaterial(mci);
if(!gizmo_triangle.mtl)
return(false);
@ -165,7 +160,7 @@ namespace
}
{
gizmo_triangle.pipeline=render_pass->CreatePipeline(gizmo_triangle.mtl,InlinePipeline::Solid3D);
gizmo_triangle.pipeline=render_pass->CreatePipeline(gizmo_triangle.mtl,InlinePipeline::Solid3D,Prim::Triangles);
if(!gizmo_triangle.pipeline)
return(false);
}
@ -196,7 +191,7 @@ namespace
using namespace inline_geometry;
{
InitGizmoMesh(GizmoShape::Square,CreatePlaneSqaure(gizmo_triangle.prim_creater),gizmo_triangle.pipeline);
InitGizmoRenderable(GizmoShape::Square,CreatePlaneSqaure(gizmo_triangle.prim_creater),gizmo_triangle.pipeline);
}
{
@ -207,7 +202,7 @@ namespace
cci.field_count=16;
cci.has_center=false;
InitGizmoMesh(GizmoShape::Circle,CreateCircle3DByIndexTriangles(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
InitGizmoRenderable(GizmoShape::Circle,CreateCircle3DByIndexTriangles(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
}
{
@ -217,11 +212,11 @@ namespace
cci.tangent=false;
cci.tex_coord=false;
InitGizmoMesh(GizmoShape::Cube,CreateCube(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
InitGizmoRenderable(GizmoShape::Cube,CreateCube(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
}
{
InitGizmoMesh(GizmoShape::Sphere,CreateSphere(gizmo_triangle.prim_creater,16),gizmo_triangle.pipeline);
InitGizmoRenderable(GizmoShape::Sphere,CreateSphere(gizmo_triangle.prim_creater,16),gizmo_triangle.pipeline);
}
{
@ -232,7 +227,7 @@ namespace
cci.numberSlices=16; //圆锥底部分割数
cci.numberStacks=3; //圆锥高度分割数
InitGizmoMesh(GizmoShape::Cone,CreateCone(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
InitGizmoRenderable(GizmoShape::Cone,CreateCone(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
}
{
@ -242,7 +237,7 @@ namespace
cci.numberSlices=16; //圆柱底部分割数
cci.radius =1; //圆柱半径
InitGizmoMesh(GizmoShape::Cylinder,CreateCylinder(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
InitGizmoRenderable(GizmoShape::Cylinder,CreateCylinder(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
}
{
@ -253,12 +248,12 @@ namespace
tci.numberSlices=64;
tci.numberStacks=8;
InitGizmoMesh(GizmoShape::Torus,CreateTorus(gizmo_triangle.prim_creater,&tci),gizmo_triangle.pipeline);
InitGizmoRenderable(GizmoShape::Torus,CreateTorus(gizmo_triangle.prim_creater,&tci),gizmo_triangle.pipeline);
}
ENUM_CLASS_FOR(GizmoShape,int,i)
{
if(!gizmo_mesh[i].prim)
if(!gizmo_rederable[i].prim)
return(false);
}
}
@ -267,40 +262,41 @@ namespace
}
}//namespace
bool InitGizmoResource(RenderFramework *rf)
bool InitGizmoResource(RenderResource *rr)
{
if(!rf)
if(!rr)
return(false);
render_framework=rf;
gizmo_rr=render_framework->GetRenderResource();
VulkanDevice *device=render_framework->GetDevice();
if(!InitGizmoResource3D())
if(gizmo_rr)
return(false);
if(!InitGizmoResource2D())
gizmo_rr=rr;
GPUDevice *device=gizmo_rr->GetDevice();
if(!InitGizmoResource3D(device))
return(false);
InitGizmoMoveNode(rf);
//InitGizmoScaleMesh();
//InitGizmoRotateMesh();
if(!InitGizmoResource2D(device))
return(false);
InitGizmoMoveStaticMesh();
InitGizmoScaleStaticMesh();
InitGizmoRotateStaticMesh();
return(true);
}
void FreeGizmoResource()
{
//ClearGizmoRotateMesh();
//ClearGizmoScaleMesh();
ClearGizmoMoveNode();
ClearGizmoRotateStaticMesh();
ClearGizmoScaleStaticMesh();
ClearGizmoMoveStaticMesh();
for(GizmoMesh &gr:gizmo_mesh)
for(GizmoRenderable &gr:gizmo_rederable)
{
SAFE_CLEAR(gr.prim)
SAFE_CLEAR_OBJECT_ARRAY(gr.mesh)
SAFE_CLEAR_OBJECT_ARRAY(gr.renderable)
}
SAFE_CLEAR(gizmo_triangle.prim_creater);
@ -310,7 +306,7 @@ void FreeGizmoResource()
SAFE_CLEAR(gizmo_line.vdm);
}
Mesh *GetGizmoMesh(const GizmoShape &shape,const GizmoColor &color)
Renderable *GetGizmoRenderable(const GizmoShape &shape,const GizmoColor &color)
{
if(!gizmo_rr)
return(nullptr);
@ -318,7 +314,18 @@ Mesh *GetGizmoMesh(const GizmoShape &shape,const GizmoColor &color)
RANGE_CHECK_RETURN_NULLPTR(shape)
RANGE_CHECK_RETURN_NULLPTR(color)
return gizmo_mesh[size_t(shape)].mesh[size_t(color)];
return gizmo_rederable[size_t(shape)].renderable[size_t(color)];
}
StaticMesh *CreateGizmoStaticMesh(SceneNode *root_node)
{
if(!root_node)
return(nullptr);
if(root_node->IsEmpty())
return(nullptr);
return(new StaticMesh(root_node));
}
VK_NAMESPACE_END

7
example/Gizmo/GizmoResource.h
View File

@ -1,5 +1,4 @@
#pragma once
#include"Gizmo.h"
#include<hgl/color/Color.h>
@ -7,7 +6,7 @@ VK_NAMESPACE_BEGIN
class SceneNode;
class PrimitiveCreater;
class MeshComponent;
class StaticMesh;
constexpr const COLOR gizmo_color[size_t(GizmoColor::RANGE_SIZE)]=
{
@ -36,6 +35,8 @@ constexpr const float GIZMO_CYLINDER_OFFSET =GIZMO_CYLINDER_HALF_LENGTH+GIZM
constexpr const float GIZMO_TWO_AXIS_OFFSET =5.0F; ///<二轴调节点偏移量(方片或圆)
Mesh *GetGizmoMesh(const GizmoShape &gs,const GizmoColor &);
Renderable *GetGizmoRenderable(const GizmoShape &gs,const GizmoColor &);
StaticMesh *CreateGizmoStaticMesh(SceneNode *);
VK_NAMESPACE_END

85
example/Gizmo/GizmoTest.cpp
View File

@ -1,4 +1,4 @@
#include<hgl/WorkManager.h>
#include"VulkanAppFramework.h"
#include"Gizmo.h"
#include<hgl/graph/Ray.h>
@ -52,81 +52,94 @@ const Vector3f GizmoPosition(0,0,0);
// }
//};//class BillboardSceneNode:public SceneNode
class TestApp:public WorkObject
class TestApp:public SceneAppFramework
{
SceneNode *sm_move=nullptr;
//StaticMesh *sm_rotate=nullptr;
//StaticMesh *sm_scale=nullptr;
SceneNode root;
StaticMesh *sm_move=nullptr;
StaticMesh *sm_rotate=nullptr;
StaticMesh *sm_scale=nullptr;
private:
bool InitGizmo()
{
if(!InitGizmoResource(GetRenderFramework()))
if(!InitGizmoResource(db))
return(false);
sm_move =GetGizmoMoveNode();
//sm_rotate =GetGizmoRotateStaticMesh();
//sm_scale =GetGizmoScaleStaticMesh();
sm_move =GetGizmoMoveStaticMesh();
sm_rotate =GetGizmoRotateStaticMesh();
sm_scale =GetGizmoScaleStaticMesh();
return(true);
}
void InitGizmoSceneTree()
{
SceneNode *root=GetSceneRoot();
camera_control->Refresh();
CameraInfo *ci=camera_control->GetCameraInfo();
root->Add(Duplication(sm_move));
//root.Add(Duplication(sm_rotate->GetScene()));
root.Clear();
//root.Add(Duplication(sm_move->GetScene()));
root.Add(Duplication(sm_rotate->GetScene()));
//root.CreateSubNode(sm_scale->GetScene());
root.RefreshMatrix();
render_list->SetCamera(ci);
render_list->Expend(&root);
}
public:
bool Init() override
bool Init(uint w,uint h)
{
if(!SceneAppFramework::Init(w,h))
return(false);
if(!InitGizmo())
return(false);
InitGizmoSceneTree();
CameraControl *camera_control=GetCameraControl();
camera_control->SetPosition(Vector3f(32,32,32));
camera->pos=Vector3f(32,32,32);
camera_control->SetTarget(Vector3f(0,0,0));
return(true);
}
using WorkObject::WorkObject;
~TestApp()
{
FreeGizmoResource();
}
//void BuildCommandBuffer(uint32 index) override
void BuildCommandBuffer(uint32 index) override
{
camera_control->Refresh();
const CameraInfo *ci=camera_control->GetCameraInfo();
const ViewportInfo *vi=GetViewportInfo();
const float screen_height=vi->GetViewportHeight();
const Vector4f pos=ci->Project(GizmoPosition);
//{
// camera_control->Refresh();
//
// const CameraInfo *ci=camera_control->GetCameraInfo();
// const ViewportInfo *vi=GetViewportInfo();
// Transform tm;
// const float screen_height=vi->GetViewportHeight();
// tm.SetScale(pos.w*16.0f/screen_height);
// const Vector4f pos=ci->Project(GizmoPosition);
// //{
// // Transform tm;
// // tm.SetScale(pos.w*16.0f/screen_height);
// // root.SetLocalTransform(tm);
// //}
// root.SetLocalTransform(tm);
//}
};//class TestApp:public WorkObject
int os_main(int,os_char **)
root.RefreshMatrix();
render_list->UpdateLocalToWorld();
SceneAppFramework::BuildCommandBuffer(index);
}
};//class TestApp:public SceneAppFramework
int main(int,char **)
{
return RunFramework<TestApp>(OS_TEXT("Gizmo"),1280,720);
return RunApp<TestApp>(1024,1024);
}

147
example/Gizmo/MetricCellsGrid.cpp Normal file
View File

@ -0,0 +1,147 @@
// Metric Cells Grid
#include"VulkanAppFramework.h"
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/RenderList.h>
#include<hgl/graph/Camera.h>
#include<hgl/graph/PrimitiveCreater.h>
#include<hgl/graph/mtl/Material3DCreateConfig.h>
using namespace hgl;
using namespace hgl::graph;
struct MetricCellsGridData
{
Color4f x_color;
Color4f y_color;
Color4f x_axis_color;
Color4f y_axis_color;
Color4f center_color;
Vector2f lum;
Vector2f cell_step;
Vector2f big_cell_step;
Vector2f scale;
float axis_line_width;
float center_radius;
};
constexpr const size_t MCG_SIZE=sizeof(MetricCellsGridData);
constexpr const float PLANE_SIZE=1024;
class TestApp:public SceneAppFramework
{
private:
MetricCellsGridData mcg_data;
Material * material =nullptr;
Pipeline * pipeline =nullptr;
Primitive * ro_plane =nullptr;
MaterialInstance * material_instance =nullptr;
private:
bool InitMDP()
{
mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"MetricCellsGrid",Prim::Fan);
cfg.local_to_world=true;
material=db->LoadMaterial("Std3D/MetricCellsGrid",&cfg);
if(!material)return(false);
{
mcg_data.x_color=Color4f(1,1,1,1);
mcg_data.y_color=Color4f(1,1,1,1);
mcg_data.x_axis_color=GetColor4f(COLOR::BlenderAxisRed, 1.0);
mcg_data.y_axis_color=GetColor4f(COLOR::BlenderAxisGreen, 1.0);
mcg_data.center_color=Color4f(1,1,0,1);
mcg_data.lum =Vector2f(0.1,0.2);
mcg_data.cell_step =Vector2f(8,8);
mcg_data.big_cell_step =Vector2f(32,32);
mcg_data.scale =Vector2f(PLANE_SIZE,PLANE_SIZE);
mcg_data.axis_line_width=1.0;
mcg_data.center_radius =4.0;
}
material_instance=db->CreateMaterialInstance(material,nullptr,&mcg_data);
pipeline=CreatePipeline(material,InlinePipeline::Solid3D,Prim::Fan);
return pipeline;
}
bool CreateRenderObject()
{
PrimitiveCreater pc(device,material->GetDefaultVIL());
ro_plane=inline_geometry::CreatePlaneSqaure(&pc);
if(ro_plane)
db->Add(ro_plane);
return ro_plane;
}
Renderable *Add(MaterialInstance *mi,const Matrix4f &mat)
{
Renderable *ri=db->CreateRenderable(ro_plane,mi,pipeline);
if(!ri)
return(nullptr);
render_root.CreateSubNode(mat,ri);
return ri;
}
bool InitScene()
{
Add(material_instance,scale(PLANE_SIZE,PLANE_SIZE,1));
camera->pos=Vector3f(PLANE_SIZE/4,PLANE_SIZE/2,PLANE_SIZE/4);
camera_control->SetTarget(Vector3f(0,0,0));
camera_control->Refresh();
// camera_control->SetReserveDirection(true,true); //反转x,y
render_root.RefreshMatrix();
render_list->Expend(&render_root);
return(true);
}
public:
bool Init(uint width,uint height) override
{
if(!SceneAppFramework::Init(width,height))
return(false);
if(!InitMDP())
return(false);
if(!CreateRenderObject())
return(false);
if(!InitScene())
return(false);
return(true);
}
};//class TestApp:public CameraAppFramework
int main(int,char **)
{
return RunApp<TestApp>(1280,720);
}

52
example/Gizmo/PlaneGrid3D.cpp
View File

@ -1,6 +1,6 @@
// PlaneGrid3D
#include<hgl/WorkManager.h>
#include"VulkanAppFramework.h"
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKRenderResource.h>
@ -8,14 +8,11 @@
#include<hgl/graph/Camera.h>
#include<hgl/graph/mtl/Material3DCreateConfig.h>
#include<hgl/graph/VKVertexInputConfig.h>
#include<hgl/graph/FirstPersonCameraControl.h>
#include<hgl/color/Color.h>
#include<hgl/component/MeshComponent.h>
using namespace hgl;
using namespace hgl::graph;
class TestApp:public WorkObject
class TestApp:public SceneAppFramework
{
private:
@ -29,7 +26,7 @@ private:
bool InitMDP()
{
mtl::Material3DCreateConfig cfg(PrimitiveType::Lines);
mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"VertexLuminance3D",Prim::Lines);
cfg.local_to_world=true;
cfg.position_format=VAT_VEC2;
@ -53,7 +50,7 @@ private:
ce=COLOR((int)ce+1);
}
pipeline=CreatePipeline(material_instance[0],InlinePipeline::Solid3D);
pipeline=CreatePipeline(material_instance[0],InlinePipeline::Solid3D,Prim::Lines);
return pipeline;
}
@ -70,52 +67,55 @@ private:
pgci.lum=180;
pgci.sub_lum=255;
auto pc=GetPrimitiveCreater(material_instance[0]);
PrimitiveCreater pc(device,material_instance[0]->GetVIL());
prim_plane_grid=CreatePlaneGrid2D(pc,&pgci);
prim_plane_grid=CreatePlaneGrid2D(&pc,&pgci);
return prim_plane_grid;
}
void Add(SceneNode *parent_node,MaterialInstance *mi,const Matrix4f &mat)
Renderable *Add(MaterialInstance *mi,const Matrix4f &mat)
{
Mesh *ri=db->CreateMesh(prim_plane_grid,mi,pipeline);
Renderable *ri=db->CreateRenderable(prim_plane_grid,mi,pipeline);
if(!ri)
return;
return(nullptr);
CreateComponent<MeshComponent>(mat,parent_node,ri);
render_root.Add(new SceneNode(mat,ri));
return ri;
}
bool InitScene()
{
SceneNode *scene_root=GetSceneRoot(); //取得缺省场景根节点
Add(material_instance[0],Matrix4f(1.0f));
Add(material_instance[1],rotate(HGL_RAD_90,0,1,0));
Add(material_instance[2],rotate(HGL_RAD_90,1,0,0));
Add(scene_root,material_instance[0],Matrix4f(1.0f));
Add(scene_root,material_instance[1],rotate(HGL_RAD_90,0,1,0));
Add(scene_root,material_instance[2],rotate(HGL_RAD_90,1,0,0));
CameraControl *camera_control=GetCameraControl();
camera_control->SetPosition(Vector3f(32,32,32));
camera->pos=Vector3f(32,32,32);
camera_control->SetTarget(Vector3f(0,0,0));
camera_control->Refresh();
// camera_control->SetReserveDirection(true,true); //反转x,y
render_root.RefreshMatrix();
render_list->Expend(&render_root);
return(true);
}
public:
using WorkObject::WorkObject;
~TestApp()
{
SAFE_CLEAR(prim_plane_grid);
}
bool Init() override
bool Init(uint width,uint height) override
{
if(!SceneAppFramework::Init(width,height))
return(false);
if(!InitMDP())
return(false);
@ -129,7 +129,7 @@ public:
}
};//class TestApp:public CameraAppFramework
int os_main(int,os_char **)
int main(int,char **)
{
return RunFramework<TestApp>(OS_TEXT("PlaneGrid3D"),1280,720);
return RunApp<TestApp>(1280,720);
}

94
example/Gizmo/RayPicking.cpp
View File

@ -1,6 +1,6 @@
// RayPicking
#include<hgl/WorkManager.h>
#include"VulkanAppFramework.h"
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKRenderResource.h>
@ -11,7 +11,6 @@
#include<hgl/graph/mtl/Material3DCreateConfig.h>
#include<hgl/graph/VertexDataManager.h>
#include<hgl/graph/VKVertexInputConfig.h>
#include<hgl/component/MeshComponent.h>
using namespace hgl;
using namespace hgl::graph;
@ -22,12 +21,12 @@ static float position_data[2][3]=
{0,0,0}
};
static uint8 lumiance_data[2]={255,255};
static float lumiance_data[2]={1,1};
static Color4f white_color(1,1,1,1);
static Color4f yellow_color(1,1,0,1);
class TestApp:public WorkObject
class TestApp:public SceneAppFramework
{
Color4f color;
@ -52,37 +51,39 @@ private:
bool InitMaterialAndPipeline()
{
mtl::Material3DCreateConfig cfg(PrimitiveType::Lines);
mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"VertexLuminance2D",Prim::Lines);
cfg.local_to_world=true;
VILConfig vil_config;
vil_config.Add(VAN::Luminance,VF_V1UN8);
{
cfg.mtl_name="VertexLuminance2D"; //注意必须用不同名字，未来改名材质文件名+cfg hash名
cfg.position_format=VAT_VEC2;
mtl_plane_grid=db->LoadMaterial("Std3D/VertexLum3D",&cfg);
if(!mtl_plane_grid)return(false);
VILConfig vil_config;
vil_config.Add(VAN::Luminance,VF_V1UN8);
mi_plane_grid=db->CreateMaterialInstance(mtl_plane_grid,&vil_config,&white_color);
if(!mi_plane_grid)return(false);
pipeline_plane_grid=CreatePipeline(mi_plane_grid,InlinePipeline::Solid3D);
pipeline_plane_grid=CreatePipeline(mi_plane_grid,InlinePipeline::Solid3D,Prim::Lines);
if(!pipeline_plane_grid)return(false);
}
{
cfg.mtl_name="VertexLuminance3D"; //注意必须用不同名字，未来改名材质文件名+cfg hash名
cfg.position_format=VAT_VEC3;
mtl_line=db->LoadMaterial("Std3D/VertexLum3D",&cfg);
if(!mtl_line)return(false);
mi_line=db->CreateMaterialInstance(mtl_line,&vil_config,&yellow_color);
mi_line=db->CreateMaterialInstance(mtl_line,nullptr,&yellow_color);
if(!mi_line)return(false);
pipeline_line=CreatePipeline(mi_line,InlinePipeline::Solid3D);
pipeline_line=CreatePipeline(mtl_line,InlinePipeline::Solid3D,Prim::Lines);
if(!pipeline_line)
return(false);
@ -91,17 +92,17 @@ private:
return(true);
}
Mesh *Add(SceneNode *parent_node,Primitive *r,MaterialInstance *mi,Pipeline *p)
Renderable *Add(Primitive *r,MaterialInstance *mi,Pipeline *p)
{
Mesh *ri=db->CreateMesh(r,mi,p);
Renderable *ri=db->CreateRenderable(r,mi,p);
if(!ri)
{
LOG_ERROR(OS_TEXT("Create Mesh failed."));
LOG_ERROR(OS_TEXT("Create Renderable failed."));
return(nullptr);
}
CreateComponent<MeshComponent>(parent_node,ri);
render_root.Add(new SceneNode(ri));
return ri;
}
@ -111,7 +112,7 @@ private:
using namespace inline_geometry;
{
auto pc=GetPrimitiveCreater(mi_plane_grid);
PrimitiveCreater pc(device,mi_plane_grid->GetVIL());
struct PlaneGridCreateInfo pgci;
@ -121,15 +122,19 @@ private:
pgci.lum=128;
pgci.sub_lum=196;
prim_plane_grid=CreatePlaneGrid2D(pc,&pgci);
prim_plane_grid=CreatePlaneGrid2D(&pc,&pgci);
}
{
prim_line=CreatePrimitive("RayLine",2,mi_line->GetVIL(),
{
{VAN::Position, VF_V3F,position_data},
{VAN::Luminance,VF_V1UN8,lumiance_data}
});
PrimitiveCreater pc(device,mtl_line->GetDefaultVIL());
if(!pc.Init("Line",2))
return(false);
if(!pc.WriteVAB(VAN::Position, VF_V3F,position_data))return(false);
if(!pc.WriteVAB(VAN::Luminance,VF_V1F,lumiance_data))return(false);
prim_line=pc.Create();
prim_line_vab_map=prim_line->GetVABMap(VAN::Position);
}
@ -139,30 +144,32 @@ private:
bool InitScene()
{
SceneNode *scene_root=GetSceneRoot(); //取得缺省场景根节点
Add(prim_plane_grid,mi_plane_grid,pipeline_plane_grid);
Add(prim_line,mi_line,pipeline_line);
Add(scene_root,prim_plane_grid,mi_plane_grid,pipeline_plane_grid);
Add(scene_root,prim_line,mi_line,pipeline_line);
CameraControl *camera_control=GetCameraControl();
camera_control->SetPosition(Vector3f(32,32,32));
camera->pos=Vector3f(32,32,32);
camera_control->SetTarget(Vector3f(0,0,0));
camera_control->Refresh();
render_root.RefreshMatrix();
render_list->Expend(&render_root);
return(true);
}
public:
using WorkObject::WorkObject;
~TestApp()
{
SAFE_CLEAR(prim_plane_grid);
SAFE_CLEAR(prim_line);
}
bool Init() override
bool Init(uint w,uint h)
{
if(!SceneAppFramework::Init(w,h))
return(false);
if(!InitMaterialAndPipeline())
return(false);
@ -175,28 +182,23 @@ public:
return(true);
}
void Tick(double) override
void BuildCommandBuffer(uint32 index) override
{
Vector2i mouse_position;
const CameraInfo *ci=GetCameraInfo();
const ViewportInfo *vi=GetViewportInfo();
if(!GetMouseCoord(&mouse_position))
return;
CameraControl *camera_control=GetCameraControl();
const CameraInfo *ci=camera_control->GetCameraInfo();
const ViewportInfo *vi=camera_control->GetViewportInfo();
ray.Set(mouse_position,ci,vi); //设置射线查询的屏幕坐标点
ray.Set(GetMouseCoord(),ci,vi); //设置射线查询的屏幕坐标点
const Vector3f pos=ray.ClosestPoint(Vector3f(0,0,0)); //求射线上与点(0,0,0)最近的点的坐标
prim_line_vab_map->Write(&pos, //更新VAB上这个点的位置
1); //这里的1代表的数据数量,不是字节数
SceneAppFramework::BuildCommandBuffer(index);
}
};//class TestApp:public CameraAppFramework
int os_main(int,os_char **)
int main(int,char **)
{
return RunFramework<TestApp>(OS_TEXT("RayPicking"),1280,720);
return RunApp<TestApp>(1280,720);
}

100
example/Gizmo/SimplestAxis.cpp
View File

@ -1,100 +0,0 @@
// SimplestAxis
// 直接从0,0,0向三个方向画一条直线，用于确认坐标轴方向
#include<hgl/WorkManager.h>
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/RenderList.h>
#include<hgl/graph/Camera.h>
#include<hgl/graph/mtl/Material3DCreateConfig.h>
#include<hgl/graph/VKVertexInputConfig.h>
#include<hgl/graph/FirstPersonCameraControl.h>
#include<hgl/color/Color.h>
#include<hgl/component/MeshComponent.h>
using namespace hgl;
using namespace hgl::graph;
class TestApp:public WorkObject
{
private:
Material * material =nullptr;
Pipeline * pipeline =nullptr;
Primitive * prim_axis =nullptr;
MaterialInstance * material_instance =nullptr;
private:
bool InitMDP()
{
mtl::Material3DCreateConfig cfg(PrimitiveType::Lines);
cfg.local_to_world=true;
material_instance=CreateMaterialInstance(mtl::inline_material::VertexColor3D,&cfg);
pipeline=CreatePipeline(material_instance,InlinePipeline::Solid3D);
return pipeline;
}
bool CreateRenderObject()
{
using namespace inline_geometry;
auto pc=GetPrimitiveCreater(material_instance);
inline_geometry::AxisCreateInfo aci;
prim_axis=CreateAxis(pc,&aci);
return prim_axis;
}
bool InitScene()
{
Mesh *ri=db->CreateMesh(prim_axis,material_instance,pipeline);
CreateComponent<MeshComponent>(GetSceneRoot(),ri);
CameraControl *camera_control=GetCameraControl();
camera_control->SetPosition(Vector3f(32,32,32));
camera_control->SetTarget(Vector3f(0,0,0));
// camera_control->SetReserveDirection(true,true); //反转x,y
return(true);
}
public:
using WorkObject::WorkObject;
~TestApp()
{
SAFE_CLEAR(prim_axis);
}
bool Init() override
{
if(!InitMDP())
return(false);
if(!CreateRenderObject())
return(false);
if(!InitScene())
return(false);
return(true);
}
};//class TestApp:public CameraAppFramework
int os_main(int,os_char **)
{
return RunFramework<TestApp>(OS_TEXT("SimplestAxis"),1280,720);
}

14
example/LightBasic/BlinnPhongDirectionLight.cpp
View File

@ -104,7 +104,7 @@ private:
bool InitVertexLumMP()
{
mtl::Material3DCreateConfig cfg(device->GetDevAttr(),"VertexLuminance3D",PrimitiveType::Lines);
mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"VertexLuminance3D",Prim::Lines);
cfg.local_to_world=true;
@ -114,7 +114,7 @@ private:
mi_plane_grid=db->CreateMaterialInstance(mtl_vertex_lum,nullptr,&white_color);
if(!mi_plane_grid)return(false);
p_line=CreatePipeline(mtl_vertex_lum,InlinePipeline::Solid3D,PrimitiveType::Lines);
p_line=CreatePipeline(mtl_vertex_lum,InlinePipeline::Solid3D,Prim::Lines);
if(!p_line)
return(false);
@ -132,7 +132,7 @@ private:
bool InitBlinnPhongSunLightMP()
{
mtl::Material3DCreateConfig cfg(device->GetDevAttr(),"BlinnPhong3D",PrimitiveType::Triangles);
mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"BlinnPhong3D",Prim::Triangles);
cfg.local_to_world=true;
cfg.material_instance=true;
@ -170,7 +170,7 @@ private:
if(!mi_blinnphong[i])return(false);
}
p_blinnphong=CreatePipeline(mtl_blinnphong,InlinePipeline::Solid3D,PrimitiveType::Triangles);
p_blinnphong=CreatePipeline(mtl_blinnphong,InlinePipeline::Solid3D,Prim::Triangles);
if(!p_blinnphong)
return(false);
@ -243,7 +243,7 @@ private:
return(true);
}
Mesh *Add(Primitive *r,MaterialInstance *mi,Pipeline *p,const Matrix4f &mat=Identity4f)
Renderable *Add(Primitive *r,MaterialInstance *mi,Pipeline *p,const Matrix4f &mat=Identity4f)
{
if(!r)
return(nullptr);
@ -252,11 +252,11 @@ private:
if(!p)
return(nullptr);
Mesh *ri=db->CreateMesh(r,mi,p);
Renderable *ri=db->CreateRenderable(r,mi,p);
if(!ri)
{
LOG_ERROR("Create Mesh failed! Primitive: "+r->GetName());
LOG_ERROR("Create Renderable failed! Primitive: "+r->GetName());
return(nullptr);
}

4
example/Texture/texture_format_list.cpp
View File

@ -38,8 +38,8 @@ int main(int,char **)
{
Window * win =nullptr;
VulkanInstance * inst =nullptr;
VulkanDevice * device =nullptr;
const VulkanPhyDevice * physical_device =nullptr;
GPUDevice * device =nullptr;
const GPUPhysicalDevice * physical_device =nullptr;
inst=InitVulkanInstance();

10
example/Texture/texture_quad.cpp
View File

@ -12,7 +12,7 @@ using namespace hgl;
using namespace hgl::graph;
VK_NAMESPACE_BEGIN
Texture2D *CreateTexture2DFromFile(VulkanDevice *device,const OSString &filename);
Texture2D *CreateTexture2DFromFile(GPUDevice *device,const OSString &filename);
VK_NAMESPACE_END
constexpr uint32_t SCREEN_WIDTH=256;
@ -44,14 +44,14 @@ private:
Sampler * sampler =nullptr;
Material * material =nullptr;
MaterialInstance * material_instance =nullptr;
Mesh * render_obj =nullptr;
Renderable * render_obj =nullptr;
Pipeline * pipeline =nullptr;
private:
bool InitMaterial()
{
mtl::Material2DCreateConfig cfg(device->GetDevAttr(),"PureTexture2D",PrimitiveType::Fan);
mtl::Material2DCreateConfig cfg(device->GetDeviceAttribute(),"PureTexture2D",Prim::Fan);
cfg.coordinate_system=CoordinateSystem2D::NDC;
cfg.local_to_world=false;
@ -62,7 +62,7 @@ private:
return(false);
// pipeline=db->CreatePipeline(material_instance,sc_render_target,OS_TEXT("res/pipeline/solid2d"));
pipeline=CreatePipeline(material,InlinePipeline::Solid2D,PrimitiveType::Fan); //等同上一行，为Framework重载，默认使用swapchain的render target
pipeline=CreatePipeline(material,InlinePipeline::Solid2D,Prim::Fan); //等同上一行，为Framework重载，默认使用swapchain的render target
if(!pipeline)
return(false);
@ -92,7 +92,7 @@ private:
if(!rpc.WriteVAB(VAN::Position, VF_V2F, position_data))return(false);
if(!rpc.WriteVAB(VAN::TexCoord, VF_V2F, tex_coord_data))return(false);
render_obj=db->CreateMesh(&rpc,material_instance,pipeline);
render_obj=db->CreateRenderable(&rpc,material_instance,pipeline);
return(render_obj);
}

10
example/Texture/texture_rect.cpp
View File

@ -12,7 +12,7 @@ using namespace hgl;
using namespace hgl::graph;
VK_NAMESPACE_BEGIN
Texture2D *CreateTexture2DFromFile(VulkanDevice *device,const OSString &filename);
Texture2D *CreateTexture2DFromFile(GPUDevice *device,const OSString &filename);
VK_NAMESPACE_END
constexpr uint32_t SCREEN_WIDTH=256;
@ -40,14 +40,14 @@ private:
Sampler * sampler =nullptr;
Material * material =nullptr;
MaterialInstance * material_instance =nullptr;
Mesh * render_obj =nullptr;
Renderable * render_obj =nullptr;
Pipeline * pipeline =nullptr;
private:
bool InitMaterial()
{
mtl::Material2DCreateConfig cfg(device->GetDevAttr(),"RectTexture2D",PrimitiveType::SolidRectangles);
mtl::Material2DCreateConfig cfg(device->GetDeviceAttribute(),"RectTexture2D",Prim::SolidRectangles);
cfg.coordinate_system=CoordinateSystem2D::ZeroToOne;
cfg.local_to_world=false;
@ -58,7 +58,7 @@ private:
return(false);
// pipeline=db->CreatePipeline(material_instance,sc_render_target,OS_TEXT("res/pipeline/solid2d"));
pipeline=CreatePipeline(material,InlinePipeline::Solid2D,PrimitiveType::SolidRectangles); //等同上一行，为Framework重载，默认使用swapchain的render target
pipeline=CreatePipeline(material,InlinePipeline::Solid2D,Prim::SolidRectangles); //等同上一行，为Framework重载，默认使用swapchain的render target
if(!pipeline)
return(false);
@ -88,7 +88,7 @@ private:
if(!rpc.WriteVAB(VAN::Position,VF_V4F,position_data))return(false);
if(!rpc.WriteVAB(VAN::TexCoord,VF_V4F,tex_coord_data))return(false);
render_obj=db->CreateMesh(&rpc,material_instance,pipeline);
render_obj=db->CreateRenderable(&rpc,material_instance,pipeline);
return(render_obj);
}

14
example/Texture/texture_rect_array.cpp
View File

@ -13,7 +13,7 @@ using namespace hgl;
using namespace hgl::graph;
VK_NAMESPACE_BEGIN
//Texture2D *CreateTexture2DFromFile(VulkanDevice *device,const OSString &filename);
//Texture2D *CreateTexture2DFromFile(GPUDevice *device,const OSString &filename);
VK_NAMESPACE_END
constexpr uint32_t SCREEN_WIDTH=256;
@ -61,7 +61,7 @@ private:
struct
{
MaterialInstance * mi;
Mesh * mesh;
Renderable * r;
}render_obj[TexCount]{};
private:
@ -91,7 +91,7 @@ private:
bool InitMaterial()
{
mtl::Material2DCreateConfig cfg(device->GetDevAttr(),"RectTexture2DArray",PrimitiveType::SolidRectangles);
mtl::Material2DCreateConfig cfg(device->GetDeviceAttribute(),"RectTexture2DArray",Prim::SolidRectangles);
cfg.coordinate_system=CoordinateSystem2D::ZeroToOne;
cfg.local_to_world=true;
@ -101,7 +101,7 @@ private:
if(!material)
return(false);
pipeline=CreatePipeline(material,InlinePipeline::Solid2D,PrimitiveType::SolidRectangles); //等同上一行，为Framework重载，默认使用swapchain的render target
pipeline=CreatePipeline(material,InlinePipeline::Solid2D,Prim::SolidRectangles); //等同上一行，为Framework重载，默认使用swapchain的render target
if(!pipeline)
return(false);
@ -144,14 +144,14 @@ private:
for(uint32_t i=0;i<TexCount;i++)
{
render_obj[i].mesh=db->CreateMesh(prim_rectangle,render_obj[i].mi,pipeline);
render_obj[i].r=db->CreateRenderable(prim_rectangle,render_obj[i].mi,pipeline);
if(!render_obj[i].mesh)
if(!render_obj[i].r)
return(false);
offset.x=position_data[2]*float(i);
render_root.CreateSubNode(translate(offset),render_obj[i].mesh);
render_root.CreateSubNode(translate(offset),render_obj[i].r);
}
render_root.RefreshMatrix();

2
example/Vulkan/Atmosphere.cpp
View File

@ -5,7 +5,7 @@
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/Mesh.h>
#include<hgl/graph/VKRenderable.h>
#include<hgl/graph/RenderList.h>
using namespace hgl;

2
example/Vulkan/Cubemap.cpp
View File

@ -5,7 +5,7 @@
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/Mesh.h>
#include<hgl/graph/VKRenderable.h>
#include<hgl/graph/VKTexture.h>
#include<hgl/graph/RenderList.h>

4
example/Vulkan/Deferred.cpp
View File

@ -103,7 +103,7 @@ private:
const VkFormat GetCandidateFormat(const VkFormat *fmt_list, const uint count)
{
auto pd = device->GetPhyDevice();
auto pd = device->GetPhysicalDevice();
for (uint i = 0; i < count; i++)
if (pd->IsColorAttachmentOptimal(fmt_list[i]))
@ -118,7 +118,7 @@ private:
const VkFormat GetDepthCandidateFormat()
{
auto pd = device->GetPhyDevice();
auto pd = device->GetPhysicalDevice();
for (VkFormat fmt : depth_candidate_format)
if (pd->IsDepthAttachmentOptimal(fmt))

10
example/Vulkan/DeferredRender.cpp
View File

@ -4,7 +4,7 @@
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/Mesh.h>
#include<hgl/graph/VKRenderable.h>
#include<hgl/graph/RenderList.h>
#include<hgl/graph/VKTexture.h>
#include<hgl/graph/VKImageView.h>
@ -16,7 +16,7 @@ using namespace hgl;
using namespace hgl::graph;
VK_NAMESPACE_BEGIN
Texture2D *CreateTexture2DFromFile(VulkanDevice *device,const OSString &filename);
Texture2D *CreateTexture2DFromFile(GPUDevice *device,const OSString &filename);
VK_NAMESPACE_END
constexpr uint32_t SCREEN_WIDTH=1280;
@ -139,7 +139,7 @@ private:
#ifdef _DEBUG
{
auto da=device->GetDevAttr();
auto da=device->GetDeviceAttribute();
if(da->debug_maker)
{
@ -172,7 +172,7 @@ private:
#ifdef _DEBUG
{
auto da=device->GetDevAttr();
auto da=device->GetDeviceAttribute();
VkQueue q=*(gbuffer.rt->GetQueue());
VkFramebuffer fbo= gbuffer.rt->GetFramebuffer()->GetFramebuffer();
@ -229,7 +229,7 @@ private:
#ifdef _DEBUG
{
auto da=device->GetDevAttr();
auto da=device->GetDeviceAttribute();
if(da->debug_maker)
{

2
example/Vulkan/EquirectangularMap.cpp
View File

@ -5,7 +5,7 @@
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/Mesh.h>
#include<hgl/graph/VKRenderable.h>
#include<hgl/graph/VKTexture.h>
#include<hgl/graph/RenderList.h>

4
example/Vulkan/InlineGeometryScene.cpp
View File

@ -5,7 +5,7 @@
#include<hgl/filesystem/FileSystem.h>
#include<hgl/graph/InlineGeometry.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/Mesh.h>
#include<hgl/graph/VKRenderable.h>
#include<hgl/graph/VKTexture.h>
#include<hgl/graph/RenderList.h>
@ -109,7 +109,7 @@ private:
VK_SAMPLER_ADDRESS_MODE_REPEAT,
0.0f,
VK_TRUE,
device->GetPhyDevice()->GetMaxSamplerAnisotropy(),
device->GetPhysicalDevice()->GetMaxSamplerAnisotropy(),
false,
VK_COMPARE_OP_NEVER,
0.0f,

201
example/common/VulkanAppFramework.h
View File

@ -53,16 +53,11 @@ protected:
protected:
VulkanDevice * device =nullptr;
RenderPass * device_render_pass =nullptr;
GPUDevice * device =nullptr;
SwapchainRenderTarget * sc_render_target =nullptr;
protected:
int32_t swap_chain_count =0;
RenderCmdBuffer ** cmd_buf =nullptr;
Color4f clear_color;
protected:
@ -91,7 +86,6 @@ public:
win->Unjoin(this);
SAFE_CLEAR(db);
SAFE_CLEAR_OBJECT_ARRAY_OBJECT(cmd_buf,swap_chain_count);
SAFE_CLEAR(device);
SAFE_CLEAR(win);
@ -146,14 +140,12 @@ public:
if(!device)
return(false);
sc_render_target=device->GetSwapchainRT();
}
device_render_pass=device->GetRenderPass();
db=new RenderResource(device);
InitCommandBuffer();
win->Join(this);
{
@ -198,34 +190,17 @@ public:
if(w>0&&h>0)
device->Resize(w,h);
InitCommandBuffer();
sc_render_target=device->GetSwapchainRT();
Resize(w,h);
}
void InitCommandBuffer()
{
if(cmd_buf)
SAFE_CLEAR_OBJECT_ARRAY_OBJECT(cmd_buf,swap_chain_count);
sc_render_target=device->GetSwapchainRT();
swap_chain_count=sc_render_target->GetImageCount();
{
const VkExtent2D extent=sc_render_target->GetExtent();
cmd_buf=hgl_zero_new<RenderCmdBuffer *>(swap_chain_count);
for(int32_t i=0;i<swap_chain_count;i++)
cmd_buf[i]=device->CreateRenderCommandBuffer(device->GetPhyDevice()->GetDeviceName()+AnsiString(":RenderCmdBuffer_")+AnsiString::numberOf(i));
}
}
bool BuildCommandBuffer(RenderCmdBuffer *cb,Framebuffer *fbo,Mesh *ri)
bool BuildCommandBuffer(RenderCmdBuffer *cb,Framebuffer *fb,Renderable *ri)
{
if(!ri)return(false);
cb->Begin();
cb->BindFramebuffer(fbo);
cb->BindFramebuffer(fb);
cb->SetClearColor(0,clear_color);
cb->BeginRenderPass();
cb->BindPipeline(ri->GetPipeline());
@ -238,25 +213,36 @@ public:
return(true);
}
bool BuildCommandBuffer(uint32_t index,Mesh *ri)
bool BuildCommandBuffer(RenderCmdBuffer *cb,RenderTarget *rt,Renderable *ri)
{
if(!ri)return(false);
if(!cb||!rt||!ri)
return(false);
return BuildCommandBuffer(cmd_buf[index],
sc_render_target->GetFramebuffer(),ri);
return BuildCommandBuffer(cb,rt->GetFramebuffer(),ri);
}
bool BuildCommandBuffer(Mesh *ri)
bool BuildCommandBuffer(uint32_t index,Renderable *ri)
{
if(!ri)return(false);
for(int32_t i=0;i<swap_chain_count;i++)
IRenderTarget *rt=sc_render_target->GetCurrentFrameRenderTarget();
return BuildCommandBuffer(rt->GetRenderCmdBuffer(),
rt->GetFramebuffer(),
ri);
}
bool BuildCommandBuffer(Renderable *ri)
{
if(!ri)return(false);
for(uint32_t i=0;i<sc_render_target->GetFrameCount();i++)
BuildCommandBuffer(i,ri);
return(true);
}
bool BuildCurrentCommandBuffer(Mesh *ri)
bool BuildCurrentCommandBuffer(Renderable *ri)
{
if(!ri)return(false);
@ -267,7 +253,7 @@ public:
{
if(!rl)return;
RenderCmdBuffer *cb=cmd_buf[index];
RenderCmdBuffer *cb=sc_render_target->GetRenderCmdBuffer(index);
cb->Begin();
cb->BindFramebuffer(sc_render_target->GetFramebuffer(index));
@ -280,7 +266,7 @@ public:
void BuildCommandBuffer(RenderList *rl)
{
for(int32_t i=0;i<swap_chain_count;i++)
for(uint32_t i=0;i<sc_render_target->GetFrameCount();i++)
BuildCommandBuffer(i,rl);
}
@ -292,7 +278,7 @@ public:
template<typename ...ARGS>
Pipeline *CreatePipeline(ARGS...args)
{
Pipeline *p=device_render_pass->CreatePipeline(args...);
Pipeline *p=sc_render_target->GetRenderPass()->CreatePipeline(args...);
if(!p)
return(nullptr);
@ -314,11 +300,9 @@ public:
return sc_render_target->AcquireNextImage();
}
virtual void SubmitDraw(int index)
virtual void SubmitDraw()
{
VkCommandBuffer cb=*cmd_buf[index];
sc_render_target->Submit(cb);
sc_render_target->Submit();
sc_render_target->PresentBackbuffer();
sc_render_target->WaitQueue();
sc_render_target->WaitFence();
@ -328,9 +312,9 @@ public:
{
int index=AcquireNextImage();
if(index<0||index>=swap_chain_count)return;
if(index<0||index>=sc_render_target->GetFrameCount())return;
SubmitDraw(index);
SubmitDraw();
}
bool Run()
@ -346,6 +330,125 @@ public:
}
};//class VulkanApplicationFramework
class CameraKeyboardControl:public KeyboardStateEvent
{
FirstPersonCameraControl *camera;
float move_speed;
public:
CameraKeyboardControl(FirstPersonCameraControl *wc)
{
camera=wc;
move_speed=1.0f;
}
bool OnPressed(const KeyboardButton &kb)override
{
if(!KeyboardStateEvent::OnPressed(kb))
return(false);
if(kb==KeyboardButton::Minus )move_speed*=0.9f;else
if(kb==KeyboardButton::Equals )move_speed*=1.1f;
return(true);
}
void Update()
{
if(HasPressed(KeyboardButton::W ))camera->Forward (move_speed);else
if(HasPressed(KeyboardButton::S ))camera->Backward (move_speed);else
if(HasPressed(KeyboardButton::A ))camera->Left (move_speed);else
if(HasPressed(KeyboardButton::D ))camera->Right (move_speed);else
//if(HasPressed(KeyboardButton::R ))camera->Up (move_speed);else
//if(HasPressed(KeyboardButton::F ))camera->Down (move_speed);else
//if(HasPressed(KeyboardButton::Left ))camera->HoriRotate( move_speed);else
//if(HasPressed(KeyboardButton::Right ))camera->HoriRotate(-move_speed);else
//if(HasPressed(KeyboardButton::Up ))camera->VertRotate( move_speed);else
//if(HasPressed(KeyboardButton::Down ))camera->VertRotate(-move_speed);else
return;
}
};
class CameraMouseControl:public MouseEvent
{
FirstPersonCameraControl *camera;
double cur_time;
double last_time;
Vector2f mouse_pos;
Vector2f mouse_last_pos;
protected:
bool OnPressed(int x,int y,MouseButton) override
{
mouse_last_pos.x=x;
mouse_last_pos.y=y;
last_time=cur_time;
return(true);
}
bool OnWheel(int,int y) override
{
if(y==0)return(false);
camera->Forward(float(y)/10.0f);
return(true);
}
bool OnMove(int x,int y) override
{
mouse_pos.x=x;
mouse_pos.y=y;
bool left=HasPressed(MouseButton::Left);
bool right=HasPressed(MouseButton::Right);
Vector2f pos(x,y);
Vector2f gap=pos-mouse_last_pos;
if(left)
{
gap/=-5.0f;
camera->Rotate(gap);
}
else
if(right)
{
gap/=10.0f;
camera->Move(Vector3f(gap.x,0,gap.y));
}
last_time=cur_time;
mouse_last_pos=Vector2f(x,y);
return(true);
}
public:
CameraMouseControl(FirstPersonCameraControl *wc)
{
camera=wc;
cur_time=0;
last_time=0;
}
const Vector2f &GetMouseCoord()const{return mouse_pos;}
void Update()
{
cur_time=GetDoubleTime();
}
};
class CameraAppFramework:public VulkanApplicationFramework
{
protected:
@ -442,7 +545,7 @@ public:
BuildCommandBuffer(index);
SubmitDraw(index);
SubmitDraw();
ckc->Update();
cmc->Update();

95
inc/hgl/WorkManager.h
View File

@ -1,95 +0,0 @@
#pragma once
#include<hgl/WorkObject.h>
#include<hgl/graph/VKRenderTargetSwapchain.h>
namespace hgl
{
/**
* 工作管理器，管理一个序列的WorkObject<br>
*/
class WorkManager
{
protected:
graph::RenderFramework *render_framework;
uint fps=60;
double frame_time=1.0f/double(fps);
double last_update_time=0;
double last_render_time=0;
double cur_time=0;
WorkObject *cur_work_object=nullptr;
public:
WorkManager(graph::RenderFramework *rf)
{
render_framework=rf;
}
virtual ~WorkManager()
{
SAFE_CLEAR(cur_work_object);
}
void SetFPS(uint f)
{
fps=f;
frame_time=1.0f/double(fps);
}
void Tick(WorkObject *wo);
virtual void Render(WorkObject *wo);
void Run(WorkObject *wo);
};//class WorkManager
class SwapchainWorkManager:public WorkManager,public io::WindowEvent
{
graph::SwapchainModule *swapchain_module;
public:
SwapchainWorkManager(graph::RenderFramework *rf):WorkManager(rf)
{
swapchain_module=rf->GetSwapchainModule();
render_framework->Join(this);
}
~SwapchainWorkManager()
{
render_framework->Unjoin(this);
}
void Render(WorkObject *wo) override;
void OnResize(uint w,uint h) override;
};
template<typename WO> int RunFramework(const OSString &title,uint width=1280,uint height=720)
{
graph::RenderFramework rf(title);
if(!rf.Init(width,height))
return(-1);
SwapchainWorkManager wm(&rf);
WO *wo=new WO(&rf);
if(!wo->Init())
{
delete wo;
return(-2);
}
wm.Run(wo);
return 0;
}
}//namespcae hgl

123
inc/hgl/WorkObject.h
View File

@ -1,123 +0,0 @@
#pragma once
#include<hgl/type/object/TickObject.h>
#include<hgl/graph/RenderFramework.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/mtl/MaterialLibrary.h>
#include<hgl/graph/Renderer.h>
#include<hgl/graph/Scene.h>
#include<hgl/Time.h>
//#include<iostream>
namespace hgl
{
namespace graph::mtl
{
class MaterialCreateInfo;
}
/**
* 工作对象</p>
*
* WorkObject被定义为工作对象，所有的渲染控制都需要被写在WorkObject的Render函数下。
*/
class WorkObject:public TickObject
{
graph::RenderFramework *render_framework=nullptr;
bool destroy_flag=false;
bool render_dirty=true;
protected:
//以下数据均取自RenderFramework
graph::RenderResource *db=nullptr; //暂时的，未来会被更好的机制替代
graph::Scene * scene=nullptr; //场景
graph::Renderer * renderer=nullptr; //渲染器
public:
graph::RenderFramework * GetRenderFramework (){return render_framework;}
graph::VulkanDevice * GetDevice (){return render_framework->GetDevice();}
graph::VulkanDevAttr * GetDevAttr (){return render_framework->GetDevAttr();}
graph::TextureManager * GetTextureManager (){return render_framework->GetTextureManager();}
const VkExtent2D & GetExtent (){return renderer->GetExtent();}
graph::Scene * GetScene (){return scene;}
graph::SceneNode * GetSceneRoot (){return scene->GetRootNode();}
graph::Renderer * GetRenderer (){return renderer;}
graph::Camera * GetCamera (){return renderer->GetCamera();}
graph::CameraControl * GetCameraControl (){return render_framework->GetDefaultCameraControl();}
bool GetMouseCoord (Vector2i *mc)const{return render_framework->GetMouseCoord(mc);}
public:
const bool IsDestroy ()const{return destroy_flag;}
void MarkDestory(){destroy_flag=true;}
const bool IsRenderDirty ()const{return render_dirty;}
void MarkRenderDirty(){render_dirty=true;}
public:
WorkObject(graph::RenderFramework *,graph::Renderer *r=nullptr);
virtual ~WorkObject()=default;
virtual bool Init()=0;
virtual void OnRendererChange(graph::RenderFramework *rf,graph::Renderer *r);
virtual void OnResize(const VkExtent2D &){}
virtual void Tick(double){}
virtual void Render(double delta_time);
public:
#define WO_FUNC_FROM_RENDER_FRAMEWORK(name,return_type) template<typename ...ARGS> return_type name(ARGS...args){return render_framework?render_framework->name(args...):nullptr;}
WO_FUNC_FROM_RENDER_FRAMEWORK(CreatePipeline,graph::Pipeline *)
WO_FUNC_FROM_RENDER_FRAMEWORK(CreateMaterialInstance,graph::MaterialInstance *)
WO_FUNC_FROM_RENDER_FRAMEWORK(GetPrimitiveCreater,SharedPtr<graph::PrimitiveCreater>)
#undef WO_FUNC_FROM_RENDER_FRAMEWORK
graph::Primitive *CreatePrimitive(const AnsiString &name,
const uint32_t vertices_count,
const graph::VIL *vil,
const std::initializer_list<graph::VertexAttribDataPtr> &vad_list)
{
return render_framework?render_framework->CreatePrimitive(name,vertices_count,vil,vad_list):nullptr;
}
graph::Mesh *CreateMesh(const AnsiString &name,
const uint32_t vertices_count,
graph::MaterialInstance *mi,
graph::Pipeline *pipeline,
const std::initializer_list<graph::VertexAttribDataPtr> &vad_list)
{
return render_framework?render_framework->CreateMesh(name,vertices_count,mi,pipeline,vad_list):nullptr;
}
public: //Component 相关
template<typename C,typename ...ARGS>
inline C *CreateComponent(ARGS...args)
{
return render_framework?render_framework->CreateComponent<C>(args...):nullptr; //创建组件
}
};//class WorkObject
/**
* 但我们认为游戏开发者不应该关注如何控制渲染，而应该关注如何处理游戏逻辑.
* 所以我们在WorkObject的基础上再提供RenderWorkObject派生类，用于直接封装好的渲染场景树控制。
*
* 开发者仅需要将要渲染的物件放置于场景树即可。
* 但开发者也可以直接使用WorkObject，自行管理这些事。
* */
}//namespcae hgl

178
inc/hgl/component/Component.h
View File

@ -1,178 +0,0 @@
#pragma once
#include<hgl/type/DataType.h>
#include<hgl/type/SortedSet.h>
#include<hgl/type/ArrayList.h>
/**
* Component/Data/Manager 体系设计简要说明
*
* 本体系参考AMD FidelityFX，但并不完全一致。
*
* AMD FidelityFX中，Component存放于Entity下，而我方中与其类似的定义为SceneNode。
* 不管是Entity还是SceneNode，它们都提供空间变换，以及子节点、Component的管理。
* 而AMD FidelityFX中的Scene，类似于我方的Scene，用于储存一个场景世界的根节点及其它世界唯一数据。
*
* ComponentData是每个Component的数据，用于向Component或是其它模块提供数据。
* ComponentManager是Component的管理器，用于管理Component的创建、销毁、更新等。
*
* 需要注意的是：同AMD FidelityFX一样，大部分ComponentManager与Scene基本无关。
* 因为同样的数据可能出现在多个World之中。
* 仅有那些与Scene密切相关的Component它对应的Manager才会出现在Scene中，比如CameraManager/LightManager。
* 而如MeshComponent之类的纯资源型就会是独立存在的。
*
* Component是组件的基类，所有组件都从这里派生。
*
* SceneComponent是场景组件基类，只要是放在场景中的都从它派生，
*
* PrimitiveComponent是图元组件的基类，所有图元组件都从这里派生。
* 它再度派生出的任何Component都必须是一个有3D空间的几何图元。
* 引擎中的空间、物理、等都由PrimitiveComponent提供数据进行计算。
* RenderComponent是可渲染组件的基类，所有可渲染组件都从这里派生。
*
* MeshComponent是静态网格组件，它是一个具体的RenderComponent实现。
*
*/
#define COMPONENT_NAMESPACE hgl::graph
#define COMPONENT_NAMESPACE_BEGIN namespace COMPONENT_NAMESPACE {
#define COMPONENT_NAMESPACE_END }
COMPONENT_NAMESPACE_BEGIN
class ComponentManager;
class SceneNode;
struct ComponentData
{
public:
ComponentData()=default;
virtual ~ComponentData()=default;
};//struct ComponentData
using ComponentDataPtr=SharedPtr<ComponentData>;
/**
* 基础组件<br>
* 是一切组件的基类
*/
class Component
{
static uint unique_id_count;
uint unique_id;
SceneNode * OwnerNode;
ComponentManager * Manager;
ComponentDataPtr Data;
protected:
friend class ComponentManager;
virtual void OnDetachManager(ComponentManager *cm)
{
if(cm==Manager)
Manager=nullptr;
}
public:
Component()=delete;
Component(ComponentDataPtr,ComponentManager *);
virtual ~Component();
virtual const size_t GetHashCode()const=0;
public:
uint GetUniqueID ()const{return unique_id;}
SceneNode * GetOwnerNode()const{return OwnerNode;}
ComponentManager * GetManager ()const{return Manager;}
ComponentDataPtr GetData ()const{return Data;}
public:
virtual Component *Duplication();
//virtual void Update(const double delta_time)=0;
public: //事件
virtual void OnAttach(SceneNode *node){if(node)OwnerNode=node;} ///<附加到节点事件
virtual void OnDetach(SceneNode *){OwnerNode=nullptr;} ///<从节点分离事件
virtual void OnFocusLost(){} ///<焦点丢失事件
virtual void OnFocusGained(){} ///<焦点获得事件
};//class Component
#define COMPONENT_CLASS_BODY(name) static name##ComponentManager *GetDefaultManager () {return name##ComponentManager::GetDefaultManager();} \
name##ComponentManager *GetManager ()const {return (name##ComponentManager *)Component::GetManager();} \
static constexpr const size_t StaticHashCode () {return hgl::GetTypeHash<name##Component>();} \
const size_t GetHashCode ()const override{return name##Component::StaticHashCode();}
using ComponentSet=SortedSet<Component *>;
using ComponentList=ArrayList<Component *>;
class ComponentManager
{
ComponentSet component_set;
protected:
friend class Component; //Component可以直接访问ComponentManager的成员
virtual void AttachComponent(Component *c){if(!c)return;component_set.Add(c);}
virtual void DetachComponent(Component *c){if(!c)return;component_set.Delete(c);}
public:
virtual const size_t GetComponentHashCode()const=0;
virtual const size_t GetHashCode()const=0;
virtual ~ComponentManager();
public:
virtual Component * CreateComponent(ComponentDataPtr)=0;
const size_t GetComponentCount()const{return component_set.GetCount();}
ComponentSet & GetComponents(){return component_set;}
int GetComponents(ComponentList &comp_list,SceneNode *);
virtual void UpdateComponents(const double delta_time);
public: //事件
virtual void OnFocusLost(){} ///<焦点丢失事件
virtual void OnFocusGained(){} ///<焦点获得事件
};//class ComponentManager
#define COMPONENT_MANAGER_CLASS_BODY(name) static name##ComponentManager * GetDefaultManager () {return GetComponentManager<name##ComponentManager>(true);} \
static constexpr const size_t StaticHashCode () {return hgl::GetTypeHash<name##ComponentManager>();} \
static constexpr const size_t StaticComponentHashCode () {return hgl::GetTypeHash<name##Component>();} \
const size_t GetComponentHashCode ()const override{return name##ComponentManager::StaticComponentHashCode();} \
const size_t GetHashCode ()const override{return name##ComponentManager::StaticHashCode();} \
bool RegistryComponentManager(ComponentManager *);
ComponentManager *GetComponentManager(const size_t hash_code);
template<typename T> inline T *GetComponentManager(bool create_default=true)
{
T *cm=(T *)GetComponentManager(T::StaticHashCode());
if(!cm&&create_default)
{
cm=new T;
RegistryComponentManager(cm);
}
return cm;
}
COMPONENT_NAMESPACE_END

90
inc/hgl/component/MeshComponent.h
View File

@ -1,90 +0,0 @@
#pragma once
#include<hgl/component/RenderComponent.h>
#include<hgl/graph/Mesh.h>
//#include<hgl/log/LogInfo.h>
COMPONENT_NAMESPACE_BEGIN
struct MeshComponentData:public ComponentData
{
//static uint unique_id_count;
//uint unique_id;
Mesh *mesh;
public:
MeshComponentData()
{
mesh=nullptr;
// unique_id=++unique_id_count;
// LOG_INFO(AnsiString("MeshComponentData():")+AnsiString::numberOf(unique_id));
}
MeshComponentData(Mesh *m)
{
mesh=m;
// unique_id=++unique_id_count;
// LOG_INFO(AnsiString("MeshComponentData(Mesh *):")+AnsiString::numberOf(unique_id));
}
virtual ~MeshComponentData();
};//struct MeshComponentData
class MeshComponent;
class MeshComponentManager:public ComponentManager
{
public:
COMPONENT_MANAGER_CLASS_BODY(Mesh)
public:
MeshComponentManager()=default;
Component *CreateComponent(ComponentDataPtr cdp) override;
MeshComponent *CreateComponent(Mesh *);
};//class MeshComponentManager
class MeshComponent:public RenderComponent
{
WeakPtr<ComponentData> sm_data;
public:
COMPONENT_CLASS_BODY(Mesh)
public:
MeshComponent(ComponentDataPtr cdp,MeshComponentManager *cm):RenderComponent(cdp,cm)
{
sm_data=cdp;
}
virtual ~MeshComponent()=default;
MeshComponentData *GetData() {return dynamic_cast< MeshComponentData *>(sm_data.get());}
const MeshComponentData *GetData()const {return dynamic_cast<const MeshComponentData *>(sm_data.const_get());}
Mesh *GetMesh()const
{
if(!sm_data.valid())
return(nullptr);
const MeshComponentData *mcd=dynamic_cast<const MeshComponentData *>(sm_data.const_get());
if(!mcd)
return(nullptr);
return mcd->mesh;
}
};//class MeshComponent
COMPONENT_NAMESPACE_END

20
inc/hgl/component/PrimitiveComponent.h
View File

@ -1,20 +0,0 @@
#pragma once
#include<hgl/component/SceneComponent.h>
COMPONENT_NAMESPACE_BEGIN
/**
* 图元组件<br>
* 组件中的元素必须是一个可以明确描述的几何体，可以被明确标记尺寸、参与空间、物理计算等。
*/
class PrimitiveComponent:public SceneComponent
{
public:
using SceneComponent::SceneComponent;
virtual ~PrimitiveComponent()=default;
};//class PrimitiveComponent
COMPONENT_NAMESPACE_END

18
inc/hgl/component/RenderComponent.h
View File

@ -1,18 +0,0 @@
#pragma once
#include<hgl/component/PrimitiveComponent.h>
COMPONENT_NAMESPACE_BEGIN
/**
* 可渲染组件
*/
class RenderComponent:public PrimitiveComponent
{
public:
using PrimitiveComponent::PrimitiveComponent;
virtual ~RenderComponent()=default;
};//class RenderComponent
COMPONENT_NAMESPACE_END

31
inc/hgl/component/SceneComponent.h
View File

@ -1,31 +0,0 @@
#pragma once
#include<hgl/component/Component.h>
#include<hgl/graph/SceneOrient.h>
COMPONENT_NAMESPACE_BEGIN
/**
* 场景组件<br>
* 场景组件中的元素必须是针对场景起作用的，并不一定需要自己绘出来，但也对场景产生影响。比如太阳光、全局风场
*/
class SceneComponent:public Component,public SceneOrient
{
public:
using Component::Component;
virtual ~SceneComponent()=default;
virtual Component *Duplication() override
{
SceneComponent *sc=(SceneComponent *)Component::Duplication();
if(!sc)
return(sc);
sc->SetLocalMatrix(GetLocalMatrix());
return sc;
}
};//class SceneComponent
COMPONENT_NAMESPACE_END

2
inc/hgl/db/FieldType.h
View File

@ -1,7 +1,7 @@
#ifndef HGL_DB_FIELD_TYPE_INCLUDE
#define HGL_DB_FIELD_TYPE_INCLUDE
#include<hgl/type/ArrayList.h>
#include<hgl/type/List.h>
#include<hgl/type/StringList.h>
namespace hgl
{

21
inc/hgl/graph/CoordinateSystem.h
View File

@ -1,8 +1,10 @@
#pragma once
#include<hgl/TypeFunc.h>
namespace hgl::graph
namespace hgl
{
namespace graph
{
enum class CoordinateSystem2D
{
NDC,
@ -11,18 +13,5 @@ namespace hgl::graph
ENUM_CLASS_RANGE(NDC,Ortho)
};
constexpr const char *CoordinateSystem2DName[]=
{
"NDC",
"0to1",
"Ortho"
};
inline const char *GetCoordinateSystem2DName(const enum class CoordinateSystem2D &cs)
{
RANGE_CHECK_RETURN_NULLPTR(cs)
return CoordinateSystem2DName[size_t(cs)];
}
}//namespace hgl::graph
}//namespace graph
}//namespace hgl

45
inc/hgl/graph/LightCullMode.h
View File

@ -1,45 +0,0 @@
#pragma once
#include<hgl/graph/VKNamespace.h>
#include<hgl/TypeFunc.h>
VK_NAMESPACE_BEGIN
/**
* 光照剔除模式
*/
enum class LightingCullingMode
{
None, ///<不剔除
/**
* 基于世界坐标的剔除模式
* 一般用于一些空间划分极为规则的场景。每个物件都可以得到较为明确的体积，并可通过世界坐标快速定位。
* 如即时战略游戏，普通的小爆炸，火光，影响的范围完全可以在世界坐标内圈定那些特件受影响，然后直接前向渲染即可。
*/
WorldCoord, ///<世界坐标剔除
/*
* 基于Tile的剔除模式
* 按屏幕XY坐标划分成多个Tile，再配合znear/zfar形成一个Volume。所有光源和Volume计算相交性
*/
Tile, ///<瓦片剔除
/**
* 基于Tile的剔除模式的改进型
* 同Tile方法，得出Tile后，再通过遍历Tile内所有象素，得出当前Tile的最远z值和最近z值。
* 根据XY与zNear/zFar得出一个Volume，计算所有光源与Volume相交性。
*/
TileVolume, ///<瓦片体积剔除
/**
* 基于Tile的剔除模式的改进型
* 同TileVolume方法得出Volume后，再将Volume按深度划分成多个Volume。
* 剔除掉没有象素的Volume，再将剩下的Volume与光源计算相交性。
*/
Cluster, ///<集簇剔除
ENUM_CLASS_RANGE(None,Cluster)
};//enum class LightingCullingMode
VK_NAMESPACE_END

26
inc/hgl/graph/MaterialRenderList.h
View File

@ -46,7 +46,7 @@ public:
*/
class MaterialRenderList
{
VulkanDevice *device;
GPUDevice *device;
RenderCmdBuffer *cmd_buf;
RenderPipelineIndex rp_index;
@ -68,12 +68,12 @@ private:
MaterialInstance * mi;
const MeshDataBuffer * pdb;
const MeshRenderData * prd;
const PrimitiveDataBuffer * pdb;
const PrimitiveRenderData * prd;
public:
void Set(Mesh *);
void Set(Renderable *);
};
IndirectDrawBuffer *icb_draw;
@ -92,24 +92,24 @@ protected:
VABList * vab_list;
const MeshDataBuffer * last_data_buffer;
const PrimitiveDataBuffer * last_data_buffer;
const VDM * last_vdm;
const MeshRenderData * last_render_data;
const PrimitiveRenderData * last_render_data;
int first_indirect_draw_index;
uint indirect_draw_count;
int first_indirect_draw_index=-1;
uint indirect_draw_count=0;
bool BindVAB(const MeshDataBuffer *,const uint);
bool BindVAB(const PrimitiveDataBuffer *,const uint);
void ProcIndirectRender();
bool Render(RenderItem *);
void Render(RenderItem *);
public:
MaterialRenderList(VulkanDevice *d,bool l2w,const RenderPipelineIndex &rpi);
MaterialRenderList(GPUDevice *d,bool l2w,const RenderPipelineIndex &rpi);
~MaterialRenderList();
void Add(MeshComponent *);
void Add(SceneNode *);
void SetCameraInfo(CameraInfo *ci){camera_info=ci;}
@ -120,6 +120,6 @@ public:
void Render(RenderCmdBuffer *);
void UpdateLocalToWorld(); //刷新所有对象的LocalToWorld矩阵
void UpdateMaterialInstance(MeshComponent *);
void UpdateMaterialInstance(SceneNode *);
};//class MaterialRenderList
VK_NAMESPACE_END

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

@ -13,7 +13,7 @@ class PrimitiveCreater
{
protected:
VulkanDevice * device;
GPUDevice * device;
VertexDataManager * vdm;
const VIL * vil;
@ -36,7 +36,7 @@ protected:
public:
PrimitiveCreater(VulkanDevice *,const VIL *);
PrimitiveCreater(GPUDevice *,const VIL *);
PrimitiveCreater(VertexDataManager *);
virtual ~PrimitiveCreater();

273
inc/hgl/graph/RenderFramework.h
View File

@ -1,273 +0,0 @@
#pragma once
#include<hgl/platform/Window.h>
#include<hgl/graph/VKDevice.h>
#include<hgl/graph/VKCommandBuffer.h>
#include<hgl/graph/module/SwapchainModule.h>
#include<hgl/graph/module/GraphModuleManager.h>
#include<hgl/graph/RenderList.h>
#include<hgl/graph/CameraControl.h>
#include<hgl/graph/Renderer.h>
#include<hgl/graph/VKRenderResource.h>
#include<hgl/graph/mtl/MaterialLibrary.h>
#include<hgl/io/event/MouseEvent.h>
VK_NAMESPACE_BEGIN
class FontSource;
class TileFont;
class RenderPassManager;
class TextureManager;
class RenderTargetManager;
class RenderModule;
class Scene;
class Renderer;
class CameraComponentManager{/*现阶段测试使用*/};
class LightComponentManager{/*现阶段测试使用*/};
class RenderFramework:public io::WindowEvent
{
OSString app_name;
Window * win =nullptr;
VulkanInstance * inst =nullptr;
VulkanDevice * device =nullptr;
RenderResource * render_resource =nullptr;
protected:
GraphModuleManager * module_manager =nullptr;
RenderPassManager * rp_manager =nullptr;
TextureManager * tex_manager =nullptr;
RenderTargetManager * rt_manager =nullptr;
SwapchainModule * sc_module =nullptr;
protected:
CameraComponentManager *camera_component_manager=nullptr;
LightComponentManager *light_component_manager =nullptr;
protected: //RenderContext,未来合并成一个RenderContext结构
Scene * default_scene =nullptr;
Camera * default_camera =nullptr;
CameraControl * default_camera_control =nullptr;
Renderer * default_renderer =nullptr;
void CreateDefaultRenderer();
protected: //InputEvent
io::MouseEvent *mouse_event=nullptr;
public:
Window * GetWindow ()const{return win;}
VulkanDevice * GetDevice ()const{return device;}
VkDevice GetVkDevice ()const{return device->GetDevice();}
const VulkanPhyDevice * GetPhyDevice ()const{return device->GetPhyDevice();}
VulkanDevAttr * GetDevAttr ()const{return device->GetDevAttr();}
RenderResource * GetRenderResource ()const{return render_resource;}
public:
GraphModuleManager * GetModuleManager (){return module_manager;}
RenderPassManager * GetRenderPassManager (){return rp_manager;}
TextureManager * GetTextureManager (){return tex_manager;}
RenderTargetManager * GetRenderTargetManager (){return rt_manager;}
SwapchainModule * GetSwapchainModule (){return sc_module;}
SwapchainRenderTarget * GetSwapchainRenderTarget(){return sc_module?sc_module->GetRenderTarget():nullptr;}
public:
Scene * GetDefaultScene (){return default_scene;}
Camera * GetDefaultCamera (){return default_camera;}
CameraControl * GetDefaultCameraControl (){return default_camera_control;}
Renderer * GetDefaultRenderer (){return default_renderer;}
RenderPass * GetDefaultRenderPass (){return default_renderer->GetRenderPass();}
public:
bool GetMouseCoord(Vector2i *mc)const
{
if(!mouse_event||!mc)
return(false);
*mc=mouse_event->GetMouseCoord();
return(true);
}
public:
RenderFramework(const OSString &);
virtual ~RenderFramework();
virtual bool Init(uint w,uint h);
public: // event
virtual void OnResize(uint w,uint h);
virtual void OnActive(bool);
virtual void OnClose();
public:
void Tick();
public: // other
RenderList *CreateRenderList()
{
return(new RenderList(device));
}
TileFont *CreateTileFont(FontSource *fs,int limit_count=-1); ///<创建只使用一种字符的Tile字符管理对象
public:
template<typename ...ARGS>
graph::Pipeline *CreatePipeline(ARGS...args)
{
return GetDefaultRenderPass()->CreatePipeline(args...);
}
graph::MaterialInstance *CreateMaterialInstance(const AnsiString &mi_name,const graph::mtl::MaterialCreateInfo *mci,const graph::VILConfig *vil_cfg=nullptr)
{
return render_resource->CreateMaterialInstance(mi_name,mci,vil_cfg);
}
graph::MaterialInstance *CreateMaterialInstance(const AnsiString &mtl_name,graph::mtl::MaterialCreateConfig *mtl_cfg,const graph::VILConfig *vil_cfg=nullptr)
{
AutoDelete<graph::mtl::MaterialCreateInfo> mci=graph::mtl::CreateMaterialCreateInfo(GetDevAttr(),mtl_name,mtl_cfg);
return render_resource->CreateMaterialInstance(mtl_name,mci,vil_cfg);
}
SharedPtr<graph::PrimitiveCreater> GetPrimitiveCreater(graph::Material *mtl)
{
if(!mtl)
return(nullptr);
return(new graph::PrimitiveCreater(GetDevice(),mtl->GetDefaultVIL()));
}
SharedPtr<graph::PrimitiveCreater> GetPrimitiveCreater(graph::MaterialInstance *mi)
{
if(!mi)
return(nullptr);
return(new graph::PrimitiveCreater(GetDevice(),mi->GetVIL()));
}
public: // Primitive, Mesh
graph::Primitive *CreatePrimitive(const AnsiString &name,
const uint32_t vertices_count,
const graph::VIL *vil,
const std::initializer_list<graph::VertexAttribDataPtr> &vad_list);
graph::Mesh *CreateMesh(const AnsiString &name,
const uint32_t vertices_count,
graph::MaterialInstance *mi,
graph::Pipeline *pipeline,
const std::initializer_list<graph::VertexAttribDataPtr> &vad_list);
public: // ComponentManager
template<typename T> T *GetComponentManager()
{
return COMPONENT_NAMESPACE::GetComponentManager<T>(true);
}
template<> CameraComponentManager *GetComponentManager<CameraComponentManager>()
{
return camera_component_manager;
}
template<> LightComponentManager *GetComponentManager<LightComponentManager>()
{
return light_component_manager;
}
public: //Component 相关
template<typename C,typename ...ARGS>
inline C *CreateComponent(ARGS...args)
{
auto manager=C::GetDefaultManager(); //取得默认管理器
if(!manager)
{
// LOG_ERROR(OS_TEXT("CreateComponent failed, no default manager!"));
return(nullptr);
}
return manager->CreateComponent(args...); //创建组件
}
template<typename C,typename ...ARGS>
inline C *CreateComponent(graph::SceneNode *parent_node,ARGS...args)
{
if(!parent_node)
{
// LOG_ERROR(OS_TEXT("CreateComponent failed, parent node is null!"));
return(nullptr);
}
C *c=this->CreateComponent<C>(args...); //创建组件
if(!c)
{
// LOG_ERROR(OS_TEXT("CreateComponent failed, create component failed!"));
return(nullptr);
}
/**
* 如果此处出现转换错误，请检查是否包含了对应的Component头文件。
*/
parent_node->AttachComponent(c); //将组件附加到父节点
return c;
}
template<typename C,typename ...ARGS>
inline C *CreateComponent(const graph::Matrix4f &mat,graph::SceneNode *parent_node,ARGS...args)
{
if(!parent_node)
{
// LOG_ERROR(OS_TEXT("CreateComponent failed, parent node is null!"));
return(nullptr);
}
C *c=this->CreateComponent<C>(args...); //创建组件
if(!c)
{
// LOG_ERROR(OS_TEXT("CreateComponent failed, create component failed!"));
return(nullptr);
}
/**
* 如果此处出现转换错误，请检查是否包含了对应的Component头文件。
*/
parent_node->AttachComponent(c); //将组件附加到父节点
c->graph::SceneOrient::SetLocalMatrix(mat);
return c;
}
};//class RenderFramework
VK_NAMESPACE_END

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

@ -18,7 +18,7 @@ namespace hgl
{
protected:
VulkanDevice * device;
GPUDevice * device;
CameraInfo * camera_info; ///<相机信息
@ -31,22 +31,16 @@ namespace hgl
public:
const CameraInfo *GetCameraInfo()const{return camera_info;}
public:
RenderList(VulkanDevice *);
RenderList(GPUDevice *);
virtual ~RenderList()=default;
virtual void SetCameraInfo(CameraInfo *ci){camera_info=ci;} ///<设置相机信息
virtual void SetCamera(CameraInfo *ci){camera_info=ci;} ///<设置相机信息
virtual bool Expend(SceneNode *); ///<展开场景树到渲染列表
bool IsEmpty()const{return !renderable_count;} ///<是否是空的
virtual bool Render(RenderCmdBuffer *); ///<渲染所有对象
virtual void UpdateLocalToWorld(); ///<更新所有对象的变换数据
virtual void UpdateMaterialInstance(MeshComponent *); ///<有对象互换了材质实例
virtual void UpdateMaterialInstance(SceneNode *); ///<有对象互换了材质实例
virtual void Clear(); ///<彻底清理
};//class RenderList

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

@ -1,21 +1,21 @@
#pragma once
#ifndef HGL_GRAPH_RENDER_NODE_INCLUDE
#define HGL_GRAPH_RENDER_NODE_INCLUDE
#include<hgl/graph/VK.h>
#include<hgl/type/SortedSet.h>
namespace hgl
{
namespace graph
{
class Mesh;
class Renderable;
class MaterialInstance;
class MeshComponent;
class SceneNode;
struct RenderNode:public Comparator<RenderNode>
{
uint index; ///<在MaterialRenderList中的索引
MeshComponent *sm_component; ///<静态网格组件
SceneNode * scene_node;
uint32 l2w_version;
uint32 l2w_index;
@ -27,15 +27,10 @@ namespace hgl
//该函数位于MaterialRenderList.cpp
const int compare(const RenderNode &)const override;
public:
Mesh *GetMesh()const;
MaterialInstance *GetMaterialInstance()const;
};
using RenderNodeList=ArrayList<RenderNode>;
using RenderNodePointerList=ArrayList<RenderNode *>;
using RenderNodeList=List<RenderNode>;
using RenderNodePointerList=List<RenderNode *>;
using MaterialInstanceSets=SortedSet<MaterialInstance *>; ///<材质实例集合
}//namespace graph
@ -45,3 +40,4 @@ namespace hgl
return a.compare(b);
}
}//namespace hgl
#endif//HGL_GRAPH_RENDER_NODE_INCLUDE

44
inc/hgl/graph/RenderTask.h
View File

@ -1,44 +0,0 @@
#pragma once
#include<hgl/graph/VK.h>
#include<hgl/type/IDName.h>
namespace hgl::graph
{
HGL_DEFINE_IDNAME(RenderTaskName,char)
/**
* 最终的具体渲染任务
*/
class RenderTask
{
RenderTaskName task_name;
IRenderTarget * render_target;
RenderList * render_list;
CameraInfo * camera_info;
public:
const RenderTaskName &GetName ()const;
IRenderTarget * GetRenderTarget ()const{return render_target;}
RenderList * GetRenderList ()const{return render_list;}
CameraInfo * GetCameraInfo ()const{return camera_info;}
public:
RenderTask(const RenderTaskName &tn,IRenderTarget *rt=nullptr,CameraInfo *ci=nullptr);
virtual ~RenderTask();
bool SetRenderTarget(IRenderTarget *);
void SetCameraInfo(CameraInfo *);
bool RebuildRenderList(SceneNode *);
bool IsEmpty()const; ///<是否是空的，不可渲染或是没啥可渲染的
bool Render(RenderCmdBuffer *);
};//class RenderTask
}//namespace hgl::graph

57
inc/hgl/graph/Renderer.h
View File

@ -1,57 +0,0 @@
#pragma once
#include<hgl/graph/RenderTask.h>
#include<hgl/graph/VKRenderTarget.h>
#include<hgl/graph/CameraControl.h>
#include<hgl/type/Map.h>
namespace hgl::graph
{
class Scene;
class CameraControl;
using RenderTaskNameMap=Map<RenderTaskName,RenderTask *>;
/**
* 渲染器
*/
class Renderer
{
IRenderTarget *render_target;
Scene *scene;
CameraControl *camera_control;
//RenderTaskNameMap static_render_task_list; ///<静态渲染任务列表
//RenderTaskNameMap dynamic_render_task_list; ///<动态渲染任务列表
RenderTask *render_task; ///<当前渲染任务
Color4f clear_color; ///<清屏颜色
bool build_frame=false;
public:
RenderPass *GetRenderPass (){return render_target->GetRenderPass();} ///<取得当前渲染器RenderPass
const VkExtent2D &GetExtent ()const{return render_target->GetExtent();} ///<取得当前渲染器画面尺寸
Scene * GetScene ()const{return scene;} ///<获取场景世界
Camera * GetCamera ()const{return camera_control->GetCamera();} ///<获取当前相机
public:
Renderer(IRenderTarget *);
virtual ~Renderer();
bool SetRenderTarget(IRenderTarget *);
void SetScene(Scene *);
void SetCameraControl(CameraControl *);
void SetClearColor(const Color4f &c){clear_color=c;}
bool RenderFrame(); ///<重新重成这一帧的CommandList
bool Submit(); ///<提交CommandList到GPU
};//class Renderer
}//namespace hgl::graph

50
inc/hgl/graph/Scene.h
View File

@ -1,50 +0,0 @@
#pragma once
#include<hgl/graph/SceneNode.h>
#include<hgl/type/Pool.h>
namespace hgl::graph
{
/**
* 场景管理器<Br>
* 管理一个场景中的所有资源与场景节点
*/
class Scene
{
U8String SceneName; ///<场景名称
ObjectList<SceneNode> SceneNodePool; ///<场景节点池
SceneNode *root_node; ///<场景根节点
public:
const U8String & GetSceneName()const{return SceneName;} ///<获取场景名称
SceneNode * GetRootNode (){return root_node;} ///<获取场景根节点
public:
Scene()
{
root_node=new SceneNode;
}
virtual ~Scene()
{
SAFE_CLEAR(root_node);
}
};//class Scene
bool RegistryScene(Scene *sw); ///<注册场景
bool UnregistryScene(const U8String &scene_name); ///<注销场景
inline bool UnregistryScene(Scene *sw) ///<注销场景
{
if(!sw)return(false);
return UnregistryScene(sw->GetSceneName());
}
Scene *GetScene(const U8String &scene_name); ///<获取指定名称的场景
}//namespace hgl::graph

31
inc/hgl/graph/SceneManager.h Normal file
View File

@ -0,0 +1,31 @@
#pragma once
#include<hgl/graph/SceneNode.h>
namespace hgl
{
namespace graph
{
/**
* 场景管理器<Br>
* 管理一个场景中的所有资源与场景节点
*/
class SceneManager
{
SceneNode *root_node;
public:
SceneNode *GetSceneRoot() {return root_node;}
const SceneNode *GetSceneRoot()const{return root_node;}
const uint GetNodeCount()const { return node_list.GetCount(); }
public:
};//class SceneManager
}//namespace graph
}//namespace hgl

116
inc/hgl/graph/SceneNode.h
View File

@ -1,18 +1,16 @@
#pragma once
#ifndef HGL_GRAPH_SCENE_NODE_INCLUDE
#define HGL_GRAPH_SCENE_NODE_INCLUDE
#include<hgl/type/ObjectList.h>
#include<hgl/type/IDName.h>
#include<hgl/graph/SceneOrient.h>
#include<hgl/graph/AABB.h>
#include<hgl/component/Component.h>
namespace hgl::graph
namespace hgl
{
using SceneNodeID =int64;
using SceneNodeList =ObjectList<SceneNode>;
HGL_DEFINE_U16_IDNAME(SceneNodeName)
namespace graph
{
using SceneNodeID =uint64;
using SceneNodeName =U16IDName;
/**
* 场景节点数据类<br>
@ -21,33 +19,29 @@ namespace hgl::graph
*/
class SceneNode:public SceneOrient ///场景节点类
{
SceneNode *parent_node=nullptr; ///<上级节点
SceneNode *Owner; ///<上级节点
SceneNodeID node_id=-1; ///<节点ID
SceneNodeName node_name; ///<节点名称
SceneNodeID NodeID; ///<节点ID
SceneNodeName NodeName; ///<节点名称
protected:
AABB bounding_box; ///<绑定盒
AABB local_bounding_box; ///<本地坐标绑定盒
AABB BoundingBox; ///<绑定盒
AABB LocalBoundingBox; ///<本地坐标绑定盒
//AABB WorldBoundingBox; ///<世界坐标绑定盒
Renderable *render_obj=nullptr; ///<可渲染实例
protected:
SceneNodeList child_nodes; ///<子节点
/**
* 组件合集，一个SceneNode下可能会包含多个组件，同时一个组件也可能被多个SceneNode使用。
* 所以这里只保留一个指针，不拥有组件的生命周期，组件的生命周期由其对应的ComponentManager管理。
*/
ComponentSet component_set; ///<组件合集
ObjectList<SceneNode> ChildNode; ///<子节点
public:
const SceneNodeID & GetNodeID ()const { return node_id; } ///<取得节点ID
const SceneNodeName & GetNodeName ()const { return node_name; } ///<取得节点名称
const SceneNodeID & GetNodeID ()const { return NodeID; } ///<取得节点ID
const SceneNodeName & GetNodeName ()const { return NodeName; } ///<取得节点名称
const SceneNodeList & GetChildNode()const { return child_nodes; } ///<取得子节点列表
const ObjectList<SceneNode> &GetChildNode()const { return ChildNode; } ///<取得子节点列表
public:
@ -55,88 +49,66 @@ namespace hgl::graph
SceneNode(const SceneNode &)=delete;
SceneNode(const SceneNode *)=delete;
SceneNode(const SceneOrient &so ):SceneOrient(so) {}
SceneNode( Renderable *ri ) {render_obj=ri;}
SceneNode(const Matrix4f &mat ):SceneOrient(mat) {}
SceneNode(const Matrix4f &mat, Renderable *ri ):SceneOrient(mat) {render_obj=ri;}
public:
virtual ~SceneNode();
virtual ~SceneNode()=default;
void Clear() override
{
SceneOrient::Clear();
parent_node=nullptr;
Owner=nullptr;
bounding_box.SetZero();
local_bounding_box.SetZero();
BoundingBox.SetZero();
LocalBoundingBox.SetZero();
child_nodes.Clear();
component_set.Clear();
ChildNode.Clear();
render_obj=nullptr;
}
const bool ChildNodeIsEmpty()const
const bool IsEmpty()const
{
if(child_nodes.GetCount())return(false);
if(render_obj)return(false);
if(ChildNode.GetCount())return(false);
return(true);
}
void SetParent(SceneNode *sn) {parent_node=sn;}
SceneNode * GetParent() noexcept{return parent_node;}
const SceneNode * GetParent()const noexcept{return parent_node;}
void SetOwner(SceneNode *sn) {Owner=sn;}
SceneNode * GetOwner() noexcept{return Owner;}
const SceneNode * GetOwner()const noexcept{return Owner;}
void SetRenderable(Renderable *);
Renderable *GetRenderable() noexcept{return render_obj;}
const Renderable *GetRenderable()const noexcept{return render_obj;}
SceneNode *Add(SceneNode *sn)
{
if(!sn)
return(nullptr);
child_nodes.Add(sn);
sn->SetParent(this);
ChildNode.Add(sn);
sn->SetOwner(this);
return sn;
}
public: //坐标相关方法
virtual void SetBoundingBox (const AABB &bb){bounding_box=bb;} ///<设置绑定盒
virtual void SetBoundingBox (const AABB &bb){BoundingBox=bb;} ///<设置绑定盒
virtual void RefreshMatrix () override; ///<刷新世界变换
virtual void RefreshBoundingBox (); ///<刷新绑定盒
virtual const AABB & GetBoundingBox ()const{return bounding_box;} ///<取得绑定盒
virtual const AABB & GetLocalBoundingBox ()const{return local_bounding_box;} ///<取得本地坐标绑定盒
virtual const AABB & GetBoundingBox ()const{return BoundingBox;} ///<取得绑定盒
virtual const AABB & GetLocalBoundingBox ()const{return LocalBoundingBox;} ///<取得本地坐标绑定盒
// virtual const AABB & GetWorldBoundingBox ()const{return WorldBoundingBox;} ///<取得世界坐标绑定盒
public: //组件相关方法
bool ComponentIsEmpty ()const{return component_set.IsEmpty();} ///<是否没有组件
virtual const int64 GetComponentCount ()const{return component_set.GetCount();} ///<取得组件数量
virtual bool AttachComponent (Component *comp) ///<添加一个组件
{
if(!comp)return(false);
if(component_set.Add(comp)<0)
return(false);
comp->OnAttach(this); //调用组件的OnAttach方法
return(true);
}
virtual void DetachComponent (Component *comp) ///<删除一个组件
{
if (!comp)return;
component_set.Delete(comp);
comp->OnDetach(this); //调用组件的OnDetach方法
}
bool Contains (Component *comp){return component_set.Contains(comp);} ///<是否包含指定组件
bool HasComponent (const ComponentManager *); ///<是否有指定组件管理器的组件
virtual int GetComponents (ComponentList &comp_list,const ComponentManager *); ///<取得所有组件
const ComponentSet &GetComponents ()const{return component_set;}
};//class SceneNode
SceneNode *Duplication(SceneNode *); ///<复制一个场景节点
}//namespace hgl::graph
}//namespace graph
}//namespace hgl
#endif//HGL_GRAPH_SCENE_NODE_INCLUDE

11
inc/hgl/graph/SceneOrient.h
View File

@ -1,9 +1,12 @@
#pragma once
#ifndef HGL_GRAPH_SCENE_ORIENT_INCLUDE
#define HGL_GRAPH_SCENE_ORIENT_INCLUDE
#include<hgl/graph/VK.h>
#include<hgl/graph/SceneMatrix.h>
namespace hgl::graph
namespace hgl
{
namespace graph
{
/**
* 方向定位数据基类<br>
*/
@ -46,4 +49,6 @@ namespace hgl::graph
virtual void RefreshMatrix();
};//class SceneOrient
}//namespace hgl::graph
}//namespace graph
}//namespace hgl
#endif//HGL_GRAPH_SCENE_ORIENT_INCLUDE

46
inc/hgl/graph/StaticMesh.h Normal file
View File

@ -0,0 +1,46 @@
#pragma once
#include<hgl/graph/VKNamespace.h>
#include<hgl/graph/StaticMeshLODPolicy.h>
#include<hgl/graph/ShadowPolicy.h>
VK_NAMESPACE_BEGIN
class SceneNode;
class StaticMesh
{
protected:
StaticMeshLODPolicy lod_policy; ///<LOD策略
SceneNode *root_node;
StaticMesh *shadow_proxy_static_mesh; ///<阴影代理静态网格
StaticMesh *physic_proxy_static_mesh; ///<物理代理静态网格
protected:
bool two_side; ///<双面渲染
ObjectDynamicShadowPolicy recommend_dynamic_shadow_policy; ///<动态阴影策略(推荐项,最终可被取代)
public:
const StaticMeshLODPolicy GetLODPolicy()const { return lod_policy; } ///<取得LOD策略
const ObjectDynamicShadowPolicy GetRecommendDynamicShadowPolicy()const { return recommend_dynamic_shadow_policy; } ///<取得推荐的动态阴影策略
public:
StaticMesh(SceneNode *);
virtual ~StaticMesh();
public:
SceneNode *GetScene(){return root_node;}
SceneNode *GetShadowNode() { return shadow_proxy_static_mesh?shadow_proxy_static_mesh->GetScene():root_node; } ///<取得阴影渲染节点
SceneNode *GetPhysicNode() { return physic_proxy_static_mesh?physic_proxy_static_mesh->GetScene():root_node; } ///<取得物理渲染节点
};//class StaticMesh
VK_NAMESPACE_END

30
inc/hgl/graph/StaticMeshLODPolicy.h Normal file
View File

@ -0,0 +1,30 @@
#pragma once
#include<hgl/graph/VKNamespace.h>
#include<hgl/TypeFunc.h>
VK_NAMESPACE_BEGIN
/**
* 静态模型LOD策略
*/
enum class StaticMeshLODPolicy:uint8
{
None=0, ///<无LOD
DiscardDetail, ///<丢弃细节
AnotherMesh, ///<另一个模型
Billboard, ///<广告牌
//Voxel, ///<体素
//MeshSDF, ///<网格SDF
//MeshCard, ///<网格卡片
ENUM_CLASS_RANGE(None,Billboard)
};//enum class StaticMeshLODPolicy
VK_NAMESPACE_END

25
inc/hgl/graph/StaticRenderManager.h Normal file
View File

@ -0,0 +1,25 @@
#ifndef HGL_GRAPH_STATIC_RENDER_MANAGER_INCLUDE
#define HGL_GRAPH_STATIC_RENDER_MANAGER_INCLUDE
#include<hgl/graph/VK.h>
VK_NAMESPACE_BEGIN
class RawMesh
{
};
/**
* 静态渲染管理器<br>
* 静态渲染指的是不会产生资源变动的内容，而不是指不会动的内容。
*/
class StaticRenderManager
{
public:
virtual ~StaticRenderManager()=default;
};//class StaticRenderManager
VK_NAMESPACE_END
#endif//HGL_GRAPH_STATIC_RENDER_MANAGER_INCLUDE

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

@ -12,15 +12,13 @@ namespace hgl
{
namespace graph
{
class TextureManager;
/**
* TileData是一种处理大量等同尺寸及格式贴图的管理机制，程序会自动根据显卡最大贴图处理能力来创建尽可能符合需求的贴图。(注：Tile的大小不必符合2次幂)
* Tile的增加或删除，程序会自动排序，尽可能小的减少I/O消耗。
*/
class TileData ///Tile纹理管理
{
TextureManager *tex_manager;
GPUDevice *device;
protected:
@ -37,7 +35,7 @@ namespace hgl
DeviceBuffer *tile_buffer; ///<Tile暂存缓冲区
ArrayList<Image2DRegion> commit_list;
List<Image2DRegion> commit_list;
uint8 *commit_ptr;
bool CommitTile(TileObject *,const void *,const uint,const int,const int); ///<提交一个Tile数据
@ -54,7 +52,7 @@ namespace hgl
public:
TileData(TextureManager *,Texture2D *,const uint tw,const uint th);
TileData(GPUDevice *,Texture2D *,const uint tw,const uint th);
virtual ~TileData();
void BeginCommit();

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

@ -1,6 +1,7 @@
#pragma once
#ifndef HGL_GRAPH_VULKAN_INCLUDE
#define HGL_GRAPH_VULKAN_INCLUDE
#include<hgl/type/ArrayList.h>
#include<hgl/type/List.h>
#include<hgl/math/Math.h>
#include<hgl/type/String.h>
#include<hgl/type/Map.h>
@ -8,7 +9,6 @@
#include<hgl/graph/VKFormat.h>
#include<hgl/graph/VKPrimitiveType.h>
#include<hgl/graph/VKStruct.h>
#include<hgl/graph/ViewportInfo.h>
#include<hgl/graph/VKRenderbufferInfo.h>
VK_NAMESPACE_BEGIN
@ -25,36 +25,20 @@ constexpr size_t VK_DESCRIPTOR_TYPE_END_RANGE=VK_DESCRIPTOR_TYPE_INPUT_ATTACHMEN
constexpr size_t VK_DESCRIPTOR_TYPE_RANGE_SIZE=VK_DESCRIPTOR_TYPE_END_RANGE-VK_DESCRIPTOR_TYPE_BEGIN_RANGE+1;
#endif//VK_DESCRIPTOR_TYPE_RANGE_SIZE
struct VertexAttribDataPtr
{
const char * name;
const VkFormat format;
const void * data;
};
using BindingMap =Map<AnsiString,int>;
using BindingMapArray =BindingMap[VK_DESCRIPTOR_TYPE_RANGE_SIZE];
class DescriptorBinding;
class GraphModule;
class RenderFramework;
class VulkanInstance;
class VulkanPhyDevice;
class VulkanDevice;
struct VulkanDevAttr;
class GPUPhysicalDevice;
class GPUDevice;
struct GPUDeviceAttribute;
class DeviceQueue;
class ImageView;
class Framebuffer;
struct Swapchain;
class IRenderTarget;
class RenderTarget;
class MultiFrameRenderTarget;
class SwapchainRenderTarget;
struct CopyBufferToImageInfo;
class Texture;
class Texture1D;
class Texture1DArray;
@ -66,15 +50,12 @@ class TextureCubeArray;
class Sampler;
class TileData;
class DeviceMemory;
class DeviceBuffer;
struct DeviceBufferData;
template<typename T> class DeviceBufferMap;
struct MeshDataBuffer;
struct MeshRenderData;
struct PrimitiveDataBuffer;
struct PrimitiveRenderData;
class VertexAttribBuffer;
using VAB=VertexAttribBuffer;
@ -84,7 +65,7 @@ class IndexBuffer;
class VABMap;
class IBMap;
class VulkanCmdBuffer;
class GPUCmdBuffer;
class RenderCmdBuffer;
class TextureCmdBuffer;
@ -96,7 +77,6 @@ class Semaphore;
struct PipelineLayoutData;
class DescriptorSet;
enum class DescriptorSetType;
struct VertexInputAttribute;
@ -124,7 +104,7 @@ using VIL=VertexInputLayout;
class PrimitiveData;
class Primitive;
class Mesh;
class Renderable;
class VertexDataManager;
using VDM=VertexDataManager;
@ -135,16 +115,7 @@ class IndirectDispatchBuffer;
class RenderResource;
class MeshComponent;
class SceneNode;
class Scene;
class RenderList;
struct CameraInfo;
struct Camera;
class Renderer;
class StaticMesh;
enum class SharingMode
{
@ -203,5 +174,5 @@ inline void copy(VkExtent3D &e3d,const VkExtent2D &e2d,const uint32 depth=1)
e3d.height =e2d.height;
e3d.depth =depth;
}
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_INCLUDE

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

@ -1,4 +1,5 @@
#pragma once
#ifndef HGL_GRAPH_VULKAN_ARRAY_BUFFER_INCLUDE
#define HGL_GRAPH_VULKAN_ARRAY_BUFFER_INCLUDE
#include<hgl/graph/VK.h>
#include<hgl/graph/VKDynamicBufferAccess.h>
@ -14,7 +15,7 @@ namespace hgl
* GPU数据阵列缓冲区<br>
* 它用于储存多份相同格式的数据，常用于多物件渲染，instance等
*/
class VulkanArrayBuffer
class GPUArrayBuffer
{
protected:
@ -32,13 +33,13 @@ namespace hgl
private:
VulkanArrayBuffer(VKMemoryAllocator *,const uint,const uint);
GPUArrayBuffer(VKMemoryAllocator *,const uint,const uint);
friend class VulkanDevice;
friend class GPUDevice;
public:
virtual ~VulkanArrayBuffer();
virtual ~GPUArrayBuffer();
const uint32_t GetAlignSize()const{return align_size;} ///<数据对齐字节数
const uint32_t GetRangeSize()const{return range_size;} ///<单次渲染访问最大字节数
@ -70,6 +71,7 @@ namespace hgl
dba->Restart();
}
};//class VulkanArrayBuffer
};//class GPUArrayBuffer
}//namespace graph
}//namespace hgl
#endif//HGL_GRAPH_VULKAN_ARRAY_BUFFER_INCLUDE

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

@ -1,9 +1,8 @@
#pragma once
#ifndef HGL_GRAPH_VULKAN_BUFFER_INCLUDE
#define HGL_GRAPH_VULKAN_BUFFER_INCLUDE
#include<hgl/graph/VK.h>
#include<hgl/graph/VKMemory.h>
#include<hgl/graph/mtl/ShaderBufferSource.h>
VK_NAMESPACE_BEGIN
struct DeviceBufferData
{
@ -21,7 +20,7 @@ protected:
private:
friend class VulkanDevice;
friend class GPUDevice;
friend class VertexAttribBuffer;
friend class IndexBuffer;
template<typename T> friend class IndirectCommandBuffer;
@ -51,68 +50,5 @@ public:
virtual 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);}
};//class DeviceBuffer
template<typename T> class DeviceBufferMap
{
protected:
DeviceBuffer *dev_buf;
T data_map;
public:
static const VkDeviceSize GetSize()
{
return sizeof(T);
}
public:
DeviceBufferMap(DeviceBuffer *buf)
{
dev_buf=buf;
}
virtual ~DeviceBufferMap()
{
delete dev_buf;
}
DeviceBuffer *GetDeviceBuffer(){return dev_buf;}
T *data(){return &data_map;}
void Update()
{
if(dev_buf)
dev_buf->Write(&data_map,sizeof(T));
}
};//template<typename T> class DeviceBufferMap
template<typename T> class UBOInstance:public DeviceBufferMap<T>
{
DescriptorSetType desc_set_type;
AnsiString ubo_name;
public:
const DescriptorSetType & set_type()const{return desc_set_type;}
const AnsiString & name ()const{return ubo_name;}
DeviceBuffer * ubo ()const{return this->dev_buf;}
public:
UBOInstance(DeviceBuffer *buf,const DescriptorSetType dst,const AnsiString &n):DeviceBufferMap<T>(buf)
{
desc_set_type=dst;
ubo_name=n;
}
UBOInstance(DeviceBuffer *buf,const ShaderBufferDesc *desc):DeviceBufferMap<T>(buf)
{
desc_set_type=desc->set_type;
ubo_name=desc->name;
}
};//template<typename T> class UBOInstance:public DeviceBufferMap<T>
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_BUFFER_INCLUDE

3
inc/hgl/graph/VKBufferMap.h
View File

@ -22,7 +22,6 @@ public:
buffer=nullptr;
offset=0;
stride=count=0;
map_ptr=nullptr;
}
virtual ~VKBufferMap()
@ -30,7 +29,7 @@ public:
Unmap();
}
void Bind(T *buf,const int32_t off,const uint32_t s,const uint32_t c)
void Set(T *buf,const int32_t off,const uint32_t s,const uint32_t c)
{
buffer=buf;
offset=off;

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

@ -1,43 +1,31 @@
#pragma once
#ifndef HGL_GRAPH_VULKAN_COMMAND_BUFFER_INCLUDE
#define HGL_GRAPH_VULKAN_COMMAND_BUFFER_INCLUDE
#include<hgl/graph/VK.h>
#include<hgl/graph/VKVABList.h>
#include<hgl/graph/VKPipeline.h>
#include<hgl/graph/VKDescriptorSet.h>
#include<hgl/graph/Mesh.h>
#include<hgl/color/Color4f.h>
VK_NAMESPACE_BEGIN
class VulkanCmdBuffer
class GPUCmdBuffer
{
protected:
const VulkanDevAttr *dev_attr;
const GPUDeviceAttribute *dev_attr;
VkCommandBuffer cmd_buf;
bool cmd_begin;
public:
VulkanCmdBuffer(const VulkanDevAttr *attr,VkCommandBuffer cb);
virtual ~VulkanCmdBuffer();
GPUCmdBuffer(const GPUDeviceAttribute *attr,VkCommandBuffer cb);
virtual ~GPUCmdBuffer();
operator VkCommandBuffer(){return cmd_buf;}
operator const VkCommandBuffer()const{return cmd_buf;}
operator const VkCommandBuffer *()const{return &cmd_buf;}
const bool IsBegin()const{return cmd_begin;}
virtual bool Begin();
virtual bool End()
{
if(!cmd_begin)
return(false);
cmd_begin=false;
return(vkEndCommandBuffer(cmd_buf)==VK_SUCCESS);
}
bool Begin();
bool End(){return(vkEndCommandBuffer(cmd_buf)==VK_SUCCESS);}
#ifdef _DEBUG
void SetDebugName(const AnsiString &);
@ -47,14 +35,9 @@ public:
void BeginRegion(const AnsiString &,const Color4f &){}
void EndRegion(){}
#endif//_DEBUG
};//class VulkanCmdBuffer
};//class GPUCmdBuffer
class DescriptorBinding;
using DescriptorBindingPtr=DescriptorBinding *;
using DescriptorBindingPtrArray=DescriptorBindingPtr[size_t(DescriptorSetType::RANGE_SIZE)];
class RenderCmdBuffer:public VulkanCmdBuffer
class RenderCmdBuffer:public GPUCmdBuffer
{
uint32_t cv_count;
VkClearValue *clear_values;
@ -64,33 +47,15 @@ class RenderCmdBuffer:public VulkanCmdBuffer
RenderPassBeginInfo rp_begin;
VkPipelineLayout pipeline_layout;
/*
* 绝大部分desc绑定会全部使用这些自动绑定器绑定
* 该数据在渲染前分别会有各自的模块设置进来
* 比如
* DescriptSetType::RenderTarget 即该由RenderTarget模块设置
* DescriptSetType::Scene 的自然由Scene模块设置
*/
DescriptorBindingPtrArray desc_binding{};
private:
void SetClear();
public:
RenderCmdBuffer(const VulkanDevAttr *attr,VkCommandBuffer cb);
RenderCmdBuffer(const GPUDeviceAttribute *attr,VkCommandBuffer cb);
~RenderCmdBuffer();
bool SetDescriptorBinding(DescriptorBinding *);
bool End() override
{
hgl_zero(desc_binding);
return VulkanCmdBuffer::End();
}
void SetRenderArea(const VkRect2D &ra){render_area=ra;}
void SetRenderArea(const VkExtent2D &);
void SetViewport(const VkViewport &vp){viewport=vp;}
@ -212,7 +177,7 @@ public:
void BindIBO(IndexBuffer *,const VkDeviceSize byte_offset=0);
bool BindDataBuffer(const MeshDataBuffer *);
bool BindDataBuffer(const PrimitiveDataBuffer *);
void SetViewport (uint32_t first,uint32_t count,const VkViewport *vp) {vkCmdSetViewport(cmd_buf,first,count,vp);}
void SetScissor (uint32_t first,uint32_t count,const VkRect2D *sci) {vkCmdSetScissor(cmd_buf,first,count,sci);}
@ -249,31 +214,18 @@ public: //draw
void DrawIndirect (VkBuffer buf, uint32_t drawCount,uint32_t stride=sizeof(VkDrawIndirectCommand )){return DrawIndirect( buf,0,drawCount,stride);}
void DrawIndexedIndirect(VkBuffer buf, uint32_t drawCount,uint32_t stride=sizeof(VkDrawIndexedIndirectCommand )){return DrawIndexedIndirect( buf,0,drawCount,stride);}
void Draw (const MeshDataBuffer *prb,const MeshRenderData *prd,const uint32_t instance_count=1,const uint32_t first_instance=0);
void Draw (const PrimitiveDataBuffer *prb,const PrimitiveRenderData *prd,const uint32_t instance_count=1,const uint32_t first_instance=0);
public: //dynamic state
};//class RenderCmdBuffer:public GPUCmdBuffer
public:
void Render(Mesh *ri)
{
if(!ri)return;
BindPipeline(ri->GetPipeline());
BindDescriptorSets(ri->GetMaterial());
BindDataBuffer(ri->GetDataBuffer());
Draw(ri->GetDataBuffer(),ri->GetRenderData());
}
};//class RenderCmdBuffer:public VulkanCmdBuffer
class TextureCmdBuffer:public VulkanCmdBuffer
class TextureCmdBuffer:public GPUCmdBuffer
{
VkImageMemoryBarrier imageMemoryBarrier;
public:
TextureCmdBuffer(const VulkanDevAttr *attr,VkCommandBuffer cb):VulkanCmdBuffer(attr,cb)
TextureCmdBuffer(const GPUDeviceAttribute *attr,VkCommandBuffer cb):GPUCmdBuffer(attr,cb)
{
imageMemoryBarrier.sType=VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
imageMemoryBarrier.pNext=nullptr;
@ -310,5 +262,6 @@ public:
0, nullptr,
1, &imageMemoryBarrier);
}
};//class TextureCmdBuffer:public VulkanCmdBuffer
};//class TextureCmdBuffer:public GPUCmdBuffer
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_COMMAND_BUFFER_INCLUDE

80
inc/hgl/graph/VKDescriptorBindingManage.h
View File

@ -1,33 +1,32 @@
#pragma once
#ifndef HGL_GRAPH_DESCRIPTOR_BINDING_MANAGE_INCLUDE
#define HGL_GRAPH_DESCRIPTOR_BINDING_MANAGE_INCLUDE
#include<hgl/type/Map.h>
#include<hgl/type/String.h>
#include<hgl/graph/VKBuffer.h>
#include<hgl/graph/VK.h>
#include<hgl/graph/VKDescriptorSetType.h>
namespace hgl
{
namespace graph
{
class DeviceBuffer;
class Texture;
class Material;
class MaterialParameters;
VK_NAMESPACE_BEGIN
class DeviceBuffer;
class Texture;
class Material;
class MaterialParameters;
/**
/**
* 描述符绑定器<Br>
* 一般用于注册通用数据，为材质进行自动绑定。
*/
class DescriptorBinding
{
class DescriptorBinding
{
DescriptorSetType set_type; ///<描述符合集类型
Map<AnsiString,DeviceBuffer *> ubo_map;
Map<AnsiString,DeviceBuffer *> ssbo_map;
Map<AnsiString,Texture *> texture_map;
public:
const DescriptorSetType GetType()const{return set_type;}
public:
public:
DescriptorBinding(const DescriptorSetType &dst)
{
@ -42,35 +41,11 @@ public:
return ubo_map.Add(name,buf);
}
template<typename T>
bool AddUBO(const AnsiString &name,DeviceBufferMap<T> *dbm)
{
if(name.IsEmpty()||!dbm)
return(false);
return ubo_map.Add(name,dbm->GetDeviceBuffer());
}
template<typename T>
bool AddUBO(const UBOInstance<T> *ubo_instance)
{
if(!ubo_instance)
return(false);
if(ubo_instance->set_type()!=set_type)
return(false);
if(ubo_instance->name().IsEmpty())
return(false);
return ubo_map.Add(ubo_instance->name(),ubo_instance->ubo());
}
DeviceBuffer *GetUBO(const AnsiString &name)
{
if(name.IsEmpty())return(nullptr);
return GetObjectFromMap(ubo_map,name);
return GetObjectFromList(ubo_map,name);
}
void RemoveUBO(DeviceBuffer *buf)
@ -88,17 +63,11 @@ public:
return ssbo_map.Add(name,buf);
}
template<typename T>
bool AddSSBO(const AnsiString &name,DeviceBufferMap<T> *dbm)
{
return AddSSBO(name,dbm->GetDeviceBuffer());
}
DeviceBuffer *GetSSBO(const AnsiString &name)
{
if(name.IsEmpty())return(nullptr);
return GetObjectFromMap(ssbo_map,name);
return GetObjectFromList(ssbo_map,name);
}
void RemoveSSBO(DeviceBuffer *buf)
@ -120,7 +89,7 @@ public:
{
if(name.IsEmpty())return(nullptr);
return GetObjectFromMap(texture_map,name);
return GetObjectFromList(texture_map,name);
}
void RemoveTexture(Texture *tex)
@ -130,13 +99,14 @@ public:
texture_map.DeleteByValue(tex);
}
private:
private:
void BindUBO(MaterialParameters *,const BindingMap &,bool dynamic);
public:
public:
bool Bind(Material *);
};//class DescriptorBinding
VK_NAMESPACE_END
};//class DescriptorBinding
}//namespace graph
}//namespace hgl
#endif//HGL_GRAPH_DESCRIPTOR_BINDING_MANAGE_INCLUDE

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

@ -18,7 +18,7 @@ class DescriptorSet
ObjectList<VkDescriptorBufferInfo> vab_list;
ObjectList<VkDescriptorImageInfo> image_list;
ArrayList<VkWriteDescriptorSet> wds_list;
List<VkWriteDescriptorSet> wds_list;
SortedSet<uint32_t> binded_sets;

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

@ -1,6 +1,7 @@
#pragma once
#ifndef HGL_GRAPH_VULKAN_DEVICE_INCLUDE
#define HGL_GRAPH_VULKAN_DEVICE_INCLUDE
#include<hgl/type/ArrayList.h>
#include<hgl/type/List.h>
#include<hgl/type/String.h>
#include<hgl/type/Map.h>
#include<hgl/type/RectScope.h>
@ -20,37 +21,55 @@ VK_NAMESPACE_BEGIN
class TileData;
class TileFont;
class FontSource;
class VulkanArrayBuffer;
class GPUArrayBuffer;
class IndirectDrawBuffer;
class IndirectDrawIndexedBuffer;
class IndirectDispatchBuffer;
struct CopyBufferToImageInfo;
class VulkanDevice
class GPUDevice
{
VulkanDevAttr *attr;
GPUDeviceAttribute *attr;
DeviceQueue *texture_queue;
TextureCmdBuffer *texture_cmd_buf;
private:
DeviceRenderPassManage *render_pass_manage;
SwapchainRenderTarget *sc_rt;
SwapchainRenderTarget *CreateSwapchainRenderTarget();
void InitRenderPassManage();
void ClearRenderPassManage();
private:
VkCommandBuffer CreateCommandBuffer(const AnsiString &);
bool CreateSwapchainFBO(Swapchain *);
Swapchain *CreateSwapchain(const VkExtent2D &acquire_extent);
private:
friend class VulkanDeviceCreater;
VulkanDevice(VulkanDevAttr *da);
GPUDevice(GPUDeviceAttribute *da);
public:
virtual ~VulkanDevice();
virtual ~GPUDevice();
operator VkDevice () {return attr->device;}
VulkanDevAttr * GetDevAttr () {return attr;}
GPUDeviceAttribute *GetDeviceAttribute () {return attr;}
VkSurfaceKHR GetSurface () {return attr->surface;}
VkDevice GetDevice ()const {return attr->device;}
const VulkanPhyDevice * GetPhyDevice ()const {return attr->physical_device;}
const GPUPhysicalDevice * GetPhysicalDevice ()const {return attr->physical_device;}
VkDescriptorPool GetDescriptorPool () {return attr->desc_pool;}
VkPipelineCache GetPipelineCache () {return attr->pipeline_cache;}
@ -59,11 +78,15 @@ public:
const VkColorSpaceKHR GetColorSpace ()const {return attr->surface_format.colorSpace;}
VkQueue GetGraphicsQueue () {return attr->graphics_queue;}
RenderPass * GetRenderPass () {return sc_rt->GetRenderPass();}
SwapchainRenderTarget * GetSwapchainRT () {return sc_rt;}
const VkExtent2D & GetSwapchainSize ()const {return sc_rt->GetExtent();}
void WaitIdle ()const {vkDeviceWaitIdle(attr->device);}
#ifdef _DEBUG
DebugUtils * GetDebugUtils (){return attr->debug_utils;}
#endif//_DEBUG
public:
@ -117,25 +140,7 @@ public: //Buffer相关
#define CREATE_BUFFER_OBJECT(LargeName,type) DeviceBuffer *Create##LargeName( VkDeviceSize size,void *data, SharingMode sm=SharingMode::Exclusive) {return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,size ,size,data, sm);} \
DeviceBuffer *Create##LargeName( VkDeviceSize size, SharingMode sm=SharingMode::Exclusive) {return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,size ,size,nullptr, sm);} \
DeviceBuffer *Create##LargeName(VkDeviceSize range,VkDeviceSize size,void *data, SharingMode sm=SharingMode::Exclusive) {return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,range,size,data, sm);} \
DeviceBuffer *Create##LargeName(VkDeviceSize range,VkDeviceSize size, SharingMode sm=SharingMode::Exclusive) {return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,range,size,nullptr, sm);} \
\
template<typename T> T *Create##LargeName() \
{ \
DeviceBuffer *buf=Create##LargeName(T::GetSize()); \
return(buf?new T(buf):nullptr); \
} \
\
template<typename T> T *Create##LargeName(const ShaderBufferDesc *desc) \
{ \
DeviceBuffer *buf=Create##LargeName(T::GetSize()); \
return(buf?new T(buf,desc):nullptr); \
} \
\
template<typename T> T *Create##LargeName(const DescriptorSetType &set_type,const AnsiString &name) \
{ \
DeviceBuffer *buf=Create##LargeName(T::GetSize()); \
return(buf?new T(buf,set_type,name):nullptr); \
}
DeviceBuffer *Create##LargeName(VkDeviceSize range,VkDeviceSize size, SharingMode sm=SharingMode::Exclusive) {return CreateBuffer(VK_BUFFER_USAGE_##type##_BUFFER_BIT,range,size,nullptr, sm);}
CREATE_BUFFER_OBJECT(UBO,UNIFORM)
CREATE_BUFFER_OBJECT(SSBO,STORAGE)
@ -143,8 +148,8 @@ public: //Buffer相关
#undef CREATE_BUFFER_OBJECT
VulkanArrayBuffer *CreateArrayInUBO(const VkDeviceSize &uint_size);
VulkanArrayBuffer *CreateArrayInSSBO(const VkDeviceSize &uint_size);
GPUArrayBuffer *CreateArrayInUBO(const VkDeviceSize &uint_size);
GPUArrayBuffer *CreateArrayInSSBO(const VkDeviceSize &uint_size);
public: //间接绘制
@ -154,6 +159,57 @@ public: //间接绘制
IndirectDrawIndexedBuffer * CreateIndirectDrawIndexedBuffer(const uint32_t cmd_count,SharingMode sm=SharingMode::Exclusive);
IndirectDispatchBuffer * CreateIndirectDispatchBuffer( const uint32_t cmd_count,SharingMode sm=SharingMode::Exclusive);
public: //Image
VkImage CreateImage (VkImageCreateInfo *);
void DestroyImage (VkImage);
private: //texture
bool CopyBufferToImage (const CopyBufferToImageInfo *info,VkPipelineStageFlags destinationStage);
bool CopyBufferToImage (Texture *,DeviceBuffer *buf,const VkBufferImageCopy *,const int count,const uint32_t base_layer,const uint32_t layer_count,VkPipelineStageFlags);//=VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
bool CopyBufferToImage2D (Texture *tex,DeviceBuffer *buf,const VkBufferImageCopy *bic_list,const int bic_count, VkPipelineStageFlags dstStage){return CopyBufferToImage(tex,buf,bic_list, bic_count, 0,1,dstStage);}
bool CopyBufferToImage2D (Texture *tex,DeviceBuffer *buf,const VkBufferImageCopy *bic, VkPipelineStageFlags dstStage){return CopyBufferToImage(tex,buf,bic, 1, 0,1,dstStage);}
bool CopyBufferToImageCube (Texture *tex,DeviceBuffer *buf,const VkBufferImageCopy *bic_list,const int bic_count, VkPipelineStageFlags dstStage){return CopyBufferToImage(tex,buf,bic_list, bic_count, 0,6,dstStage);}
bool CopyBufferToImageCube (Texture *tex,DeviceBuffer *buf,const VkBufferImageCopy *bic, VkPipelineStageFlags dstStage){return CopyBufferToImage(tex,buf,bic, 1, 0,6,dstStage);}
bool CommitTexture2D (Texture2D *,DeviceBuffer *buf,VkPipelineStageFlags stage);
bool CommitTexture2DMipmaps (Texture2D *,DeviceBuffer *buf,const VkExtent3D &,uint32_t);
bool CommitTextureCube (TextureCube *,DeviceBuffer *buf,const uint32_t mipmaps_zero_bytes,VkPipelineStageFlags stage);
bool CommitTextureCubeMipmaps (TextureCube *,DeviceBuffer *buf,const VkExtent3D &,uint32_t);
bool SubmitTexture (const VkCommandBuffer *cmd_bufs,const uint32_t count=1); ///<提交纹理处理到队列
public: //Texture
bool CheckFormatSupport(const VkFormat,const uint32_t bits,ImageTiling tiling=ImageTiling::Optimal)const;
bool CheckTextureFormatSupport(const VkFormat fmt,ImageTiling tiling=ImageTiling::Optimal)const{return CheckFormatSupport(fmt,VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,tiling);}
Texture2D *CreateTexture2D(TextureData *);
Texture2D *CreateTexture2D(TextureCreateInfo *ci);
Texture2DArray *CreateTexture2DArray(TextureData *);
Texture2DArray *CreateTexture2DArray(TextureCreateInfo *ci);
Texture2DArray *CreateTexture2DArray(const uint32_t w,const uint32_t h,const uint32 l,const VkFormat fmt,const bool mipmaps);
TextureCube *CreateTextureCube(TextureData *);
TextureCube *CreateTextureCube(TextureCreateInfo *ci);
void Clear(TextureCreateInfo *);
bool ChangeTexture2D(Texture2D *,DeviceBuffer *buf, const List<Image2DRegion> &,VkPipelineStageFlags=VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
bool ChangeTexture2D(Texture2D *,DeviceBuffer *buf, const RectScope2ui &, VkPipelineStageFlags=VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
bool ChangeTexture2D(Texture2D *,void *data,const uint32_t size,const RectScope2ui &, VkPipelineStageFlags=VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
// bool ChangeTexture2DArray(Texture2DArray *,DeviceBuffer *buf, const List<Image2DRegion> &, const uint32_t base_layer,const uint32_t layer_count,VkPipelineStageFlags=VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
bool ChangeTexture2DArray(Texture2DArray *,DeviceBuffer *buf, const RectScope2ui &, const uint32_t base_layer,const uint32_t layer_count,VkPipelineStageFlags=VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
bool ChangeTexture2DArray(Texture2DArray *,void *data,const uint32_t size,const RectScope2ui &, const uint32_t base_layer,const uint32_t layer_count,VkPipelineStageFlags=VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
public: //
Sampler *CreateSampler(VkSamplerCreateInfo *sci=nullptr);
@ -174,15 +230,30 @@ public: //Command Buffer 相关
public:
RenderPass * AcquireRenderPass( const RenderbufferInfo *,const uint subpass_count=2);
Fence * CreateFence(bool);
Semaphore * CreateGPUSemaphore();
DeviceQueue *CreateQueue(const uint32_t fence_count=1,const bool create_signaled=false);
public: //FrameBuffer相关
Framebuffer *CreateFBO(RenderPass *rp,ImageView **color_list,const uint color_count,ImageView *depth);
// Framebuffer *CreateFBO(RenderPass *,List<ImageView *> &color,ImageView *depth);
Framebuffer *CreateFBO(RenderPass *,ImageView *color,ImageView *depth);
Framebuffer *CreateFBO(RenderPass *,ImageView *);
public:
RenderTarget *CreateRT( const FramebufferInfo *fbi,RenderPass *,const uint32_t fence_count=1);
RenderTarget *CreateRT( const FramebufferInfo *fbi,const uint32_t fence_count=1);
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 VulkanDevice
};//class GPUDevice
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_DEVICE_INCLUDE

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

@ -11,10 +11,10 @@ VK_NAMESPACE_BEGIN
constexpr uint32_t ERROR_FAMILY_INDEX=UINT32_MAX;
struct VulkanDevAttr
struct GPUDeviceAttribute
{
VulkanInstance * instance =nullptr;
const VulkanPhyDevice * physical_device =nullptr;
const GPUPhysicalDevice * physical_device =nullptr;
VkPhysicalDeviceDriverPropertiesKHR driver_properties;
@ -34,7 +34,7 @@ struct VulkanDevAttr
VkQueue present_queue =VK_NULL_HANDLE;
VkSurfaceFormatKHR surface_format;
ArrayList<VkPresentModeKHR> present_modes;
List<VkPresentModeKHR> present_modes;
VkSurfaceTransformFlagBitsKHR preTransform;
VkCompositeAlphaFlagBitsKHR compositeAlpha =VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
@ -55,8 +55,8 @@ struct VulkanDevAttr
public:
VulkanDevAttr(VulkanInstance *inst,const VulkanPhyDevice *pd,VkSurfaceKHR s);
~VulkanDevAttr();
GPUDeviceAttribute(VulkanInstance *inst,const GPUPhysicalDevice *pd,VkSurfaceKHR s);
~GPUDeviceAttribute();
int GetMemoryType(uint32_t typeBits,VkMemoryPropertyFlags properties) const;
@ -75,5 +75,5 @@ public:
{
return instance->GetDeviceProc<T>(device,name);
}
};//class VulkanDevAttr
};//class GPUDeviceAttribute
VK_NAMESPACE_END

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

@ -238,7 +238,7 @@ protected:
VulkanInstance *instance;
Window *window;
const VulkanPhyDevice *physical_device;
const GPUPhysicalDevice *physical_device;
VulkanHardwareRequirement require;
@ -274,14 +274,14 @@ public:
virtual void ChooseSurfaceFormat();
virtual VulkanDevice *CreateRenderDevice();
virtual GPUDevice *CreateRenderDevice();
public:
virtual VulkanDevice *Create();
virtual GPUDevice *Create();
};//class VulkanDeviceCreater
inline VulkanDevice *CreateRenderDevice( VulkanInstance *vi,
inline GPUDevice *CreateRenderDevice( VulkanInstance *vi,
Window *win,
const VulkanHardwareRequirement *req=nullptr,
const PreferFormats * spf_color =&PreferSDR,
@ -293,35 +293,35 @@ inline VulkanDevice *CreateRenderDevice( VulkanInstance *vi,
return vdc.Create();
}
inline VulkanDevice *CreateRenderDeviceLDR(VulkanInstance *vi,
inline GPUDevice *CreateRenderDeviceLDR(VulkanInstance *vi,
Window *win,
const VulkanHardwareRequirement *req=nullptr)
{
return CreateRenderDevice(vi,win,req,&PreferLDR,&PreferNonlinear,&PreferDepth);
}
inline VulkanDevice *CreateRenderDeviceSDR(VulkanInstance *vi,
inline GPUDevice *CreateRenderDeviceSDR(VulkanInstance *vi,
Window *win,
const VulkanHardwareRequirement *req=nullptr)
{
return CreateRenderDevice(vi,win,req,&PreferSDR,&PreferNonlinear,&PreferDepth);
}
inline VulkanDevice *CreateRenderDeviceHDR16( VulkanInstance *vi,
inline GPUDevice *CreateRenderDeviceHDR16( VulkanInstance *vi,
Window *win,
const VulkanHardwareRequirement *req=nullptr)
{
return CreateRenderDevice(vi,win,req,&PreferHDR16,&PreferLinear,&PreferDepth);
}
inline VulkanDevice *CreateRenderDeviceHDR32( VulkanInstance *vi,
inline GPUDevice *CreateRenderDeviceHDR32( VulkanInstance *vi,
Window *win,
const VulkanHardwareRequirement *req=nullptr)
{
return CreateRenderDevice(vi,win,req,&PreferHDR32,&PreferLinear,&PreferDepth);
}
inline VulkanDevice *CreateRenderDeviceHDR(VulkanInstance *vi,
inline GPUDevice *CreateRenderDeviceHDR(VulkanInstance *vi,
Window *win,
const VulkanHardwareRequirement *req=nullptr)
{

40
inc/hgl/graph/VKDeviceRenderPassManage.h Normal file
View File

@ -0,0 +1,40 @@
#pragma once
#include<hgl/graph/VK.h>
#include<hgl/type/Map.h>
#include<hgl/util/hash/Hash.h>
VK_NAMESPACE_BEGIN
using RenderPassHASHCode=util::HashCode<128/8>;
inline util::Hash *CreateRenderPassHash()
{
return util::CreateHash(util::HASH::xxH3_128);
}
class DeviceRenderPassManage
{
VkDevice device;
VkPipelineCache pipeline_cache;
util::Hash *hash;
Map<RenderPassHASHCode,RenderPass *> RenderPassList;
private:
friend class GPUDevice;
DeviceRenderPassManage(VkDevice,VkPipelineCache);
~DeviceRenderPassManage();
private:
RenderPass * CreateRenderPass( const List<VkAttachmentDescription> &desc_list,
const List<VkSubpassDescription> &subpass,
const List<VkSubpassDependency> &dependency,
const RenderbufferInfo *);
RenderPass * AcquireRenderPass( const RenderbufferInfo *,const uint subpass_count=2);
};//class DeviceRenderPassManage
VK_NAMESPACE_END

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

@ -37,7 +37,7 @@ private:
index=0;
}
friend class VulkanArrayBuffer;
friend class GPUArrayBuffer;
public:

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

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

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

@ -16,7 +16,7 @@ class Framebuffer
private:
friend class RenderTargetManager;
friend class GPUDevice;
Framebuffer(VkDevice,VkFramebuffer,const VkExtent2D &,RenderPass *,uint32_t color_count,bool depth);
@ -27,7 +27,7 @@ public:
operator VkFramebuffer(){return frame_buffer;}
const VkFramebuffer GetFramebuffer ()const{return frame_buffer;}
RenderPass * GetRenderPass ()const{return render_pass;}
RenderPass * GetRenderPass () {return render_pass;}
const VkExtent2D & GetExtent ()const{return extent;}

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

@ -12,7 +12,7 @@ class IndexBuffer:public DeviceBuffer
private:
friend class VulkanDevice;
friend class GPUDevice;
IndexBuffer(VkDevice d,const DeviceBufferData &vb,IndexType it,uint32_t _count):DeviceBuffer(d,vb)
{
@ -54,7 +54,7 @@ public:
void SetIBO(IndexBuffer *ib,const int32_t index_offset,const uint32_t count)
{
VKBufferMap<IndexBuffer>::Bind(ib,index_offset,ib->GetStride(),count);
VKBufferMap<IndexBuffer>::Set(ib,index_offset,ib->GetStride(),count);
}
};//class IBMap

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

@ -19,7 +19,7 @@ public:
private:
friend class VulkanDevice;
friend class GPUDevice;
IndirectCommandBuffer(VkDevice d,const DeviceBufferData &vb,const uint32_t mc):DeviceBuffer(d,vb)
{
@ -46,7 +46,7 @@ public:
class IndirectDrawBuffer:public IndirectCommandBuffer<VkDrawIndirectCommand>
{
friend class VulkanDevice;
friend class GPUDevice;
public:
@ -64,7 +64,7 @@ public:
class IndirectDrawIndexedBuffer:public IndirectCommandBuffer<VkDrawIndexedIndirectCommand>
{
friend class VulkanDevice;
friend class GPUDevice;
public:
@ -82,7 +82,7 @@ public:
class IndirectDispatchBuffer:public IndirectCommandBuffer<VkDispatchIndirectCommand>
{
friend class VulkanDevice;
friend class GPUDevice;
public:

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

@ -62,7 +62,7 @@ VK_NAMESPACE_BEGIN
VKDebugOut *debug_out;
ObjectList<VulkanPhyDevice> physical_devices;
ObjectList<GPUPhysicalDevice> physical_devices;
private:
@ -80,8 +80,8 @@ VK_NAMESPACE_BEGIN
operator VkInstance (){return inst;}
const ObjectList<VulkanPhyDevice> &GetDeviceList ()const {return physical_devices;}
const VulkanPhyDevice * GetDevice (VkPhysicalDeviceType)const;
const ObjectList<GPUPhysicalDevice> &GetDeviceList ()const {return physical_devices;}
const GPUPhysicalDevice * GetDevice (VkPhysicalDeviceType)const;
template<typename T>
T *GetInstanceProc(const char *name)
@ -101,8 +101,8 @@ VK_NAMESPACE_BEGIN
};//class VulkanInstance
void InitVulkanInstanceProperties();
const ArrayList<VkLayerProperties> & GetInstanceLayerProperties();
const ArrayList<VkExtensionProperties> & GetInstanceExtensionProperties();
const List<VkLayerProperties> & GetInstanceLayerProperties();
const List<VkExtensionProperties> & GetInstanceExtensionProperties();
const bool CheckInstanceLayerSupport(const AnsiString &);
const bool GetInstanceLayerVersion(const AnsiString &,uint32_t &spec,uint32_t &impl);
const bool CheckInstanceExtensionSupport(const AnsiString &);

24
inc/hgl/graph/VKMaterial.h
View File

@ -1,20 +1,18 @@
#pragma once
#ifndef HGL_GRAPH_VULKAN_MATERIAL_INCLUDE
#define HGL_GRAPH_VULKAN_MATERIAL_INCLUDE
#include<hgl/graph/VK.h>
#include<hgl/type/Map.h>
#include<hgl/type/SortedSet.h>
#include<hgl/type/String.h>
#include<hgl/graph/VKShaderModuleMap.h>
#include<hgl/graph/mtl/ShaderBufferSource.h>
#include<hgl/graph/VKDescriptorSetType.h>
namespace hgl
{
class ActiveMemoryBlockManager;
}
VK_NAMESPACE_BEGIN
using ShaderStageCreateInfoList=ArrayList<VkPipelineShaderStageCreateInfo>;
using ShaderStageCreateInfoList=List<VkPipelineShaderStageCreateInfo>;
/**
* 材质类<br>
@ -24,8 +22,6 @@ class Material
{
AnsiString name;
PrimitiveType prim; ///<图元类型
VertexInput *vertex_input;
ShaderModuleMap *shader_maps;
@ -47,7 +43,7 @@ private:
friend class RenderResource;
Material(const AnsiString &,const PrimitiveType &);
Material(const AnsiString &);
public:
@ -55,8 +51,6 @@ public:
const AnsiString & GetName ()const{return name;}
const PrimitiveType & GetPrimitiveType ()const{return prim;}
const VertexInput * GetVertexInput ()const{return vertex_input;}
const ShaderStageCreateInfoList & GetStageList ()const{return shader_stage_list;}
@ -87,11 +81,6 @@ public:
bool BindSSBO(const DescriptorSetType &type,const AnsiString &name,DeviceBuffer *ubo,bool dynamic=false);
bool BindImageSampler(const DescriptorSetType &type,const AnsiString &name,Texture *tex,Sampler *sampler);
bool BindUBO(const ShaderBufferDesc *sbd,DeviceBuffer *ubo,bool dynamic=false)
{
return BindUBO(sbd->set_type,sbd->name,ubo,dynamic);
}
void Update();
public:
@ -106,5 +95,6 @@ public:
MaterialInstance *CreateMI(const VILConfig *vil_cfg=nullptr);
};//class Material
using MaterialSet=SortedSet<Material *>;
using MaterialSets=SortedSet<Material *>;
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_MATERIAL_INCLUDE

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

@ -73,7 +73,7 @@ public:
const int GetMIID ()const{return mi_id;} ///<取得材质实例ID
void * GetMIData (){return material->GetMIData(mi_id);} ///<取得材质实例数据
void WriteMIData (const void *data,const uint32 size); ///<写入材质实例数据
void WriteMIData (const void *data,const int size); ///<写入材质实例数据
template<typename T>
void WriteMIData (const T &data){WriteMIData(&data,sizeof(T));} ///<写入材质实例数据

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

@ -16,7 +16,7 @@ class DeviceMemory
private:
friend class VulkanDevice;
friend class GPUDevice;
DeviceMemory(VkDevice dev,VkDeviceMemory dm,const VkMemoryRequirements &mr,const uint32 i,const uint32_t p,const VkDeviceSize cas);

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

@ -7,7 +7,7 @@
VK_NAMESPACE_BEGIN
class VKMemoryAllocator:public AbstractMemoryAllocator
{
VulkanDevice *device;
GPUDevice *device;
uint32_t buffer_usage_flag_bits;
@ -29,7 +29,7 @@ public:
public:
VKMemoryAllocator(VulkanDevice *,const uint32_t flags,const VkDeviceSize r);
VKMemoryAllocator(GPUDevice *,const uint32_t flags,const VkDeviceSize r);
~VKMemoryAllocator();
void Free() override {/* DON'T RUN ANY OPERATION.*/}

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

@ -2,9 +2,10 @@
#include<hgl/graph/VK.h>
#include<hgl/type/String.h>
#include<hgl/type/SortedSet.h>
VK_NAMESPACE_BEGIN
class VulkanPhyDevice
class GPUPhysicalDevice
{
VkInstance instance=nullptr;
VkPhysicalDevice physical_device=nullptr;
@ -22,10 +23,9 @@ class VulkanPhyDevice
VkPhysicalDeviceVulkan14Properties properties14;
VkPhysicalDeviceMemoryProperties memory_properties;
ArrayList<VkLayerProperties> layer_properties;
ArrayList<VkExtensionProperties> extension_properties;
ArrayList<VkQueueFamilyProperties> queue_family_properties;
List<VkLayerProperties> layer_properties;
List<VkExtensionProperties> extension_properties;
List<VkQueueFamilyProperties> queue_family_properties;
private:
@ -46,8 +46,8 @@ public:
public:
VulkanPhyDevice(VkInstance,VkPhysicalDevice);
~VulkanPhyDevice()=default;
GPUPhysicalDevice(VkInstance,VkPhysicalDevice);
~GPUPhysicalDevice()=default;
operator VkPhysicalDevice() {return physical_device;}
operator const VkPhysicalDevice()const {return physical_device;}
@ -207,5 +207,5 @@ public:
}
const bool SupportDynamicState() const {return dynamic_state;}
};//class VulkanPhyDevice
};//class GPUPhysicalDevice
VK_NAMESPACE_END

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

@ -21,25 +21,19 @@ protected:
protected:
AABB bounding_box;
AABB BoundingBox;
public:
Primitive(const AnsiString &pn,PrimitiveData *pd);
virtual ~Primitive();
void SetBoundingBox(const AABB &bb) { bounding_box=bb; } ///<设置包围盒
void SetBoundingBox(const Vector3f &box_min,const Vector3f &box_max)
{
bounding_box.SetMinMax(box_min,box_max);
}
public:
const AnsiString & GetName ()const{ return prim_name; }
const VkDeviceSize GetVertexCount ()const;
const uint32_t GetVABCount ()const;
const int GetVABCount ()const;
const int GetVABIndex (const AnsiString &name)const;
VAB * GetVAB (const int);
VAB * GetVAB (const AnsiString &name){return GetVAB(GetVABIndex(name));}
@ -54,6 +48,6 @@ public:
VertexDataManager * GetVDM (); ///<取得顶点数据管理器
const AABB & GetBoundingBox ()const{return bounding_box;}
const AABB & GetBoundingBox ()const{return BoundingBox;}
};//class Primitive
VK_NAMESPACE_END

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

@ -1,4 +1,4 @@
#ifndef HGL_GRAPH_VULKAN_SUBMIT_QUEUE_INCLUDE
#ifndef HGL_GRAPH_VULKAN_SUBMIT_QUEUE_INCLUDE
#define HGL_GRAPH_VULKAN_SUBMIT_QUEUE_INCLUDE
#include<hgl/graph/VK.h>
@ -19,7 +19,7 @@ protected:
private:
friend class VulkanDevice;
friend class GPUDevice;
DeviceQueue(VkDevice dev,VkQueue q,Fence **,const uint32_t fc);
@ -31,18 +31,10 @@ public:
VkResult Present(const VkPresentInfoKHR *pi){return vkQueuePresentKHR(queue,pi);}
/**
* 等待Submit的队列完成操作。这个操作会阻塞当前线程，所以在Submit后请不要立即使用它。而是在下一次队列提交前再做这个操作。
*/
bool WaitQueue();
/**
* 等待Queue命令执行完成的fence信号
*/
bool WaitFence(const bool wait_all=true,const uint64_t time_out=HGL_NANO_SEC_PER_SEC);
bool Submit(const VkCommandBuffer &cmd_buf,Semaphore *wait_sem,Semaphore *complete_sem);
bool Submit(const VkCommandBuffer *cmd_buf,const uint32_t count,Semaphore *wait_sem,Semaphore *complete_sem);
bool Submit(VulkanCmdBuffer *cmd_buf,Semaphore *wait_sem,Semaphore *complete_sem);
};//class DeviceQueue
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_SUBMIT_QUEUE_INCLUDE

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

@ -11,13 +11,13 @@ class RenderContext
{
protected:
VulkanDevice *device;
GPUDevice *device;
VkExtent2D extent;
public:
RenderContext(VulkanDevice *,const VkExtent2D &);
RenderContext(GPUDevice *,const VkExtent2D &);
virtual ~RenderContext();
void Prepare(

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

@ -16,7 +16,7 @@ class RenderPass
VkPipelineCache pipeline_cache;
VkRenderPass render_pass;
ArrayList<VkFormat> color_formats;
List<VkFormat> color_formats;
VkFormat depth_format;
VkExtent2D granularity;
@ -29,9 +29,9 @@ protected:
private:
friend class RenderPassManager;
friend class DeviceRenderPassManage;
RenderPass(VkDevice d,VkPipelineCache pc,VkRenderPass rp,const ArrayList<VkFormat> &cf,VkFormat df);
RenderPass(VkDevice d,VkPipelineCache pc,VkRenderPass rp,const List<VkFormat> &cf,VkFormat df);
public:
@ -43,7 +43,7 @@ public:
const VkPipelineCache GetPipelineCache()const{return pipeline_cache;}
const uint GetColorCount()const{return color_formats.GetCount();}
const ArrayList<VkFormat> & GetColorFormat()const{return color_formats;}
const List<VkFormat> & GetColorFormat()const{return color_formats;}
const VkFormat GetColorFormat(int index)const
{
if(index<0||index>=color_formats.GetCount())return VK_FORMAT_UNDEFINED;
@ -56,15 +56,15 @@ public:
public:
Pipeline *CreatePipeline(Material *,const VIL *,const PipelineData *, const bool prim_restart=false);
Pipeline *CreatePipeline(Material *,const VIL *,const InlinePipeline &, const bool prim_restart=false);
Pipeline *CreatePipeline(Material *,const VIL *,const PipelineData *, const Prim &,const bool prim_restart=false);
Pipeline *CreatePipeline(Material *,const VIL *,const InlinePipeline &, const Prim &,const bool prim_restart=false);
Pipeline *CreatePipeline(Material *mtl, const PipelineData *, const bool prim_restart=false);
Pipeline *CreatePipeline(Material *mtl, const InlinePipeline &, const bool prim_restart=false);
Pipeline *CreatePipeline(Material *mtl, const PipelineData *, const Prim &,const bool prim_restart=false);
Pipeline *CreatePipeline(Material *mtl, const InlinePipeline &, const Prim &,const bool prim_restart=false);
Pipeline *CreatePipeline(MaterialInstance *, const InlinePipeline &, const bool prim_restart=false);
Pipeline *CreatePipeline(MaterialInstance *, const PipelineData *, const bool prim_restart=false);
Pipeline *CreatePipeline(MaterialInstance *, const OSString &, const bool prim_restart=false);
Pipeline *CreatePipeline(MaterialInstance *, const InlinePipeline &, const Prim &,const bool prim_restart=false);
Pipeline *CreatePipeline(MaterialInstance *, const PipelineData *, const Prim &,const bool prim_restart=false);
Pipeline *CreatePipeline(MaterialInstance *, const OSString &, const Prim &,const bool prim_restart=false);
};//class RenderPass
VK_NAMESPACE_END
#endif//HGL_GRAPH_VULKAN_RENDER_PASS_INCLUDE

61
inc/hgl/graph/VKRenderResource.h
View File

@ -11,8 +11,9 @@
#include<hgl/graph/VKTexture.h>
#include<hgl/graph/VKMaterialParameters.h>
#include<hgl/graph/VKMaterialInstance.h>
#include<hgl/graph/Mesh.h>
#include<hgl/graph/VKRenderable.h>
#include<hgl/graph/font/TextPrimitive.h>
#include<hgl/graph/StaticMesh.h>
#include<hgl/type/ObjectManage.h>
#include<hgl/shadergen/MaterialCreateInfo.h>
#include<hgl/graph/VKDescriptorBindingManage.h>
@ -31,10 +32,13 @@ using MaterialInstanceID =int;
using BufferID =int;
using DescriptorSetID =int;
using PrimitiveID =int;
using MeshID =int;
using RenderableID =int;
using SamplerID =int;
using TextureID =int;
using StaticMeshID =int;
class VertexAttribData;
using ShaderModuleMapByName=ObjectMap<AnsiString,ShaderModule>;
constexpr const size_t VK_SHADER_STAGE_TYPE_COUNT=20;//GetBitOffset((uint32_t)VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI)+1;
@ -43,10 +47,11 @@ constexpr const size_t VK_SHADER_STAGE_TYPE_COUNT=20;//GetBitOffset((uint32_t)VK
*/
class RenderResource
{
VulkanDevice *device;
GPUDevice *device;
ShaderModuleMapByName shader_module_by_name[VK_SHADER_STAGE_TYPE_COUNT];
Map<AnsiString,Material *> material_by_name;
Map<OSString,Texture *> texture_by_name;
IDObjectManage<MaterialID, Material> rm_material; ///<材质合集
IDObjectManage<MaterialInstanceID, MaterialInstance> rm_material_instance; ///<材质实例合集
@ -54,7 +59,10 @@ class RenderResource
IDObjectManage<PrimitiveID, Primitive> rm_primitives; ///<图元合集
IDObjectManage<BufferID, DeviceBuffer> rm_buffers; ///<顶点缓冲区合集
IDObjectManage<SamplerID, Sampler> rm_samplers; ///<采样器合集
IDObjectManage<MeshID, Mesh> rm_mesh; ///<渲染实例集合集
IDObjectManage<TextureID, Texture> rm_textures; ///<纹理合集
IDObjectManage<RenderableID, Renderable> rm_renderables; ///<渲染实例集合集
IDObjectManage<StaticMeshID, StaticMesh> rm_static_mesh; ///<静态网格合集
private:
@ -75,11 +83,18 @@ private:
public:
VulkanDevice *GetDevice(){return device;}
GPUDevice *GetDevice(){return device;}
//注：并非一定要走这里，这里只是提供一个注册和自动绑定的机制
DescriptorBinding static_descriptor; ///<静态属性描述符绑定管理
DescriptorBinding global_descriptor; ///<全局属性描述符绑定管理
public:
RenderResource(VulkanDevice *dev):device(dev){}
RenderResource(GPUDevice *dev):device(dev),
static_descriptor(DescriptorSetType::Static),
global_descriptor(DescriptorSetType::Global)
{}
virtual ~RenderResource()=default;
public: //添加数据到管理器（如果指针为nullptr会返回-1）
@ -90,7 +105,9 @@ public: //添加数据到管理器（如果指针为nullptr会返回-1）
PrimitiveID Add(Primitive * p ){return rm_primitives.Add(p);}
BufferID Add(DeviceBuffer * buf ){return rm_buffers.Add(buf);}
SamplerID Add(Sampler * s ){return rm_samplers.Add(s);}
MeshID Add(Mesh * r ){return rm_mesh.Add(r);}
TextureID Add(Texture * t ){return rm_textures.Add(t);}
RenderableID Add(Renderable * r ){return rm_renderables.Add(r);}
StaticMeshID Add(StaticMesh * sm ){return rm_static_mesh.Add(sm);}
public: // VAB/VAO
@ -120,9 +137,9 @@ public: //Material
const ShaderModule *CreateShaderModule(const AnsiString &shader_module_name,const ShaderCreateInfo *);
Material * CreateMaterial (const AnsiString &,const mtl::MaterialCreateInfo *);
Material * LoadMaterial (const AnsiString &,mtl::Material2DCreateConfig *);
Material * LoadMaterial (const AnsiString &,mtl::Material3DCreateConfig *);
Material * CreateMaterial(const mtl::MaterialCreateInfo *);
Material * LoadMaterial(const AnsiString &,mtl::Material2DCreateConfig *);
Material * LoadMaterial(const AnsiString &,mtl::Material3DCreateConfig *);
MaterialInstance * CreateMaterialInstance(Material *,const VILConfig *vil_cfg=nullptr);
@ -134,14 +151,22 @@ public: //Material
return CreateMaterialInstance(mtl,vil_cfg,data,sizeof(T));
}
MaterialInstance * CreateMaterialInstance(const AnsiString &mtl_name,const mtl::MaterialCreateInfo *,const VILConfig *vil_cfg=nullptr);
MaterialInstance * CreateMaterialInstance(const mtl::MaterialCreateInfo *,const VILConfig *vil_cfg=nullptr);
Mesh * CreateMesh(Primitive *r,MaterialInstance *mi,Pipeline *p);
Mesh * CreateMesh(PrimitiveCreater *pc,MaterialInstance *mi,Pipeline *p);
Renderable * CreateRenderable(Primitive *r,MaterialInstance *mi,Pipeline *p);
Renderable * CreateRenderable(PrimitiveCreater *pc,MaterialInstance *mi,Pipeline *p);
Sampler * CreateSampler(VkSamplerCreateInfo *sci=nullptr);
Sampler * CreateSampler(Texture *);
public: //texture
Texture2D * LoadTexture2D(const OSString &,bool auto_mipmaps=false);
TextureCube * LoadTextureCube(const OSString &,bool auto_mipmaps=false);
Texture2DArray * CreateTexture2DArray(const AnsiString &name,const uint32_t width,const uint32_t height,const uint32_t layer,const VkFormat &fmt,bool auto_mipmaps=false);
bool LoadTexture2DToArray(Texture2DArray *,const uint32_t layer,const OSString &);
public: //Get
Material * GetMaterial (const MaterialID &id){return rm_material.Get(id);}
@ -150,7 +175,10 @@ public: //Get
Primitive * GetPrimitive (const PrimitiveID &id){return rm_primitives.Get(id);}
DeviceBuffer * GetBuffer (const BufferID &id){return rm_buffers.Get(id);}
Sampler * GetSampler (const SamplerID &id){return rm_samplers.Get(id);}
Mesh * GetMesh (const MeshID &id){return rm_mesh.Get(id);}
Texture * GetTexture (const TextureID &id){return rm_textures.Get(id);}
Renderable * GetRenderable (const RenderableID &id){return rm_renderables.Get(id);}
StaticMesh * GetStaticMesh (const StaticMeshID &id){return rm_static_mesh.Get(id);}
public: //Release
@ -160,7 +188,10 @@ public: //Release
void Release(Primitive * p ){rm_primitives.Release(p);}
void Release(DeviceBuffer * buf ){rm_buffers.Release(buf);}
void Release(Sampler * s ){rm_samplers.Release(s);}
void Release(Mesh * r ){rm_mesh.Release(r);}
void Release(Texture * t ){rm_textures.Release(t);}
void Release(Renderable * r ){rm_renderables.Release(r);}
void Release(StaticMesh * sm ){rm_static_mesh.Release(sm);}
};//class RenderResource
/**

Some files were not shown because too many files have changed in this diff Show More