use short name in IDName

# Conflicts:
#	inc/hgl/graph/module/SwapchainModule.h
#	src/SceneGraph/module/GraphModule.cpp

.editorconfig

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

.gitmodules

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

CMakeLists.txt

@@ -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)

doc/AssetPath.md

@@ -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       | 操作系统真实路径访问 |

doc/CreateMaterialInstance.md

@@ -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);
-```

doc/InlineMaterial.md

@@ -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.
-```

example/2dVector/LerpLine.cpp

@@ -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);
     }
 

example/2dVector/line.cpp

@@ -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);
     }
 

example/2dVector/roundbox.cpp

@@ -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);
     }
 

example/Basic/BillboardTest.cpp

@@ -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();
@@ -112,13 +109,28 @@ 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()
     {
-        CreateComponentInfo cci(GetSceneRoot());
+        Add(prim_plane_grid,mi_plane_grid,pipeline_plane_grid);
 
-        CreateComponent<MeshComponent>(&cci,db->CreateMesh(prim_plane_grid,mi_plane_grid,pipeline_plane_grid));
-        CreateComponent<MeshComponent>(&cci,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);
 }

example/Basic/CMakeLists.txt

@@ -1,5 +1,4 @@
 macro(CreateProject name)
-
     add_executable(${name} ${ARGN} ${VULKAN_APP_FRAMEWORK})
     target_link_libraries(${name} ${ULRE})
 
@@ -11,10 +10,10 @@
     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(00_first_app                      first_app.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_RenderBoundBox                 RenderBoundBox.cpp)
+CreateProject(05_Billboard                      BillboardTest.cpp)

example/Basic/MaterialLoader/MaterialLoader.cpp

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

example/Basic/RenderBoundBox.cpp

@@ -1,361 +0,0 @@
-#include<hgl/WorkManager.h>
-#include<hgl/filesystem/FileSystem.h>
-#include<hgl/graph/VertexDataManager.h>
-#include<hgl/graph/InlineGeometry.h>
-#include<hgl/graph/PrimitiveCreater.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;
-
-constexpr const COLOR TestColor[]=
-{
-    COLOR::MozillaCharcoal,
-    COLOR::MozillaSand,
-
-    COLOR::BlenderAxisRed,
-    COLOR::BlenderAxisGreen,
-    COLOR::BlenderAxisBlue,
-
-    COLOR::BananaYellow,
-    COLOR::CherryBlossomPink
-};
-
-constexpr const size_t COLOR_COUNT=sizeof(TestColor)/sizeof(COLOR);
-
-class TestApp:public WorkObject
-{
-private:
-
-    struct MaterialData
-    {
-        Material *          material          = nullptr;
-        const VIL *         vil               = nullptr;
-
-        Pipeline *          pipeline          = nullptr;
-        MaterialInstance *  mi[COLOR_COUNT]{};
-    };
-
-    MaterialData solid;
-    MaterialData wire;
-
-    VertexDataManager * mesh_vdm=nullptr;
-
-    struct RenderMesh
-    {
-        Primitive *prim;
-        Mesh *mesh;
-        MeshComponentData *data;
-        ComponentDataPtr cdp;
-
-        MeshComponent *component;
-
-    public:
-
-        ~RenderMesh()
-        {
-            cdp.unref();
-            delete mesh;
-            delete prim;
-        }
-    };
-
-    RenderMesh  *rm_plane=nullptr,
-                *rm_sphere=nullptr,
-                *rm_cone=nullptr,
-                *rm_cylinder=nullptr,
-                *rm_torus=nullptr,
-                *rm_box=nullptr;
-
-private:
-
-    bool InitMaterialInstance(MaterialData *md)
-    {
-        if(!md)
-            return(false);
-
-        Color4f color;
-
-        for(size_t i=0;i<COLOR_COUNT;i++)
-        {
-            color=GetColor4f(TestColor[i],1.0);
-
-            md->mi[i]=CreateMaterialInstance(md->material,nullptr,&color);
-
-            if(!md->mi[i])
-                return(false);
-        }
-
-        md->vil=md->material->GetDefaultVIL();
-
-        if(!md->vil)
-            return(false);
-
-        md->pipeline=CreatePipeline(md->material,InlinePipeline::Solid3D);
-
-        return md->pipeline;
-    }
-
-    bool InitSolidMDP()
-    {
-        mtl::Material3DCreateConfig cfg(PrimitiveType::Triangles);
-
-        mtl::MaterialCreateInfo *mci=mtl::CreateGizmo3D(GetDevAttr(),&cfg);
-
-        if(!mci)
-            return(false);
-
-        solid.material=CreateMaterial("Gizmo3D",mci);
-
-        return InitMaterialInstance(&solid);
-    }
-
-    bool InitWireMDP()
-    {
-        mtl::Material3DCreateConfig cfg(PrimitiveType::Lines);
-
-        mtl::MaterialCreateInfo *mci=mtl::CreatePureColor3D(GetDevAttr(),&cfg);
-
-        if(!mci)
-            return(false);
-
-        wire.material=CreateMaterial("PureColorLine3D",mci);
-
-        return InitMaterialInstance(&wire);
-    }
-
-    bool InitVDM()
-    {
-        mesh_vdm=CreateVDM(solid.vil,HGL_SIZE_1MB);
-
-        if(!mesh_vdm)
-            return(false);
-
-        return true;
-    }
-
-    RenderMesh *CreateRenderMesh(Primitive *prim,MaterialData *md,const int color)
-    {
-        if(!prim)
-            return(nullptr);
-
-        Mesh *mesh=graph::CreateMesh(prim,md->mi[color],md->pipeline);
-
-        if(!mesh)
-            return nullptr;
-
-        RenderMesh *rm=new RenderMesh;
-
-        rm->prim=prim;
-        rm->mesh=mesh;
-        rm->data=new MeshComponentData(mesh);
-        rm->cdp =rm->data;
-
-        return rm;
-    }
-
-    bool CreateGeometryMesh()
-    {
-        using namespace inline_geometry;
-
-        PrimitiveCreater *prim_creater=new PrimitiveCreater(mesh_vdm);
-
-        if(!prim_creater)
-            return(false);
-
-        rm_plane=CreateRenderMesh(CreatePlaneSqaure(prim_creater),&solid,0);
-
-        //Sphere
-        rm_sphere=CreateRenderMesh(CreateSphere(prim_creater,64),&solid,1);
-
-        //Cone
-        {
-            struct ConeCreateInfo cci;
-
-            cci.radius      =1;         //圆锥半径
-            cci.halfExtend  =1;         //圆锤一半高度
-            cci.numberSlices=64;        //圆锥底部分割数
-            cci.numberStacks=4;         //圆锥高度分割数
-
-            rm_cone=CreateRenderMesh(CreateCone(prim_creater,&cci),&solid,2);
-        }
-
-        //Cyliner
-        {
-            struct CylinderCreateInfo cci;
-
-            cci.halfExtend  =1.25;      //圆柱一半高度
-            cci.numberSlices=16;        //圆柱底部分割数
-            cci.radius      =1.25f;     //圆柱半径
-
-            rm_cylinder=CreateRenderMesh(CreateCylinder(prim_creater,&cci),&solid,3);
-        }
-
-        //Torus
-        {
-            struct TorusCreateInfo tci;
-
-            tci.innerRadius=1.9;
-            tci.outerRadius=2.1;
-            tci.numberSlices=128;
-            tci.numberStacks=16;
-
-            rm_torus=CreateRenderMesh(CreateTorus(prim_creater,&tci),&solid,4);
-        }
-
-        delete prim_creater;
-        return(true);
-    }
-
-    bool CreateBoundingBoxMesh()
-    {
-        using namespace inline_geometry;
-
-        auto pc=GetPrimitiveCreater(wire.material);
-
-        inline_geometry::BoundingBoxCreateInfo bbci;
-
-        rm_box=CreateRenderMesh(CreateBoundingBox(pc,&bbci),&wire,5);
-
-        return rm_box;
-    }
-
-    bool InitScene()
-    {
-        CreateComponentInfo cci(GetSceneRoot());
-
-        {
-            cci.mat=AxisZRotate(45.0f)*ScaleMatrix(10,10,1);
-
-            rm_plane->component=CreateComponent<MeshComponent>(&cci,rm_plane->cdp);
-        }
-
-        {
-            cci.mat=TranslateMatrix(0,0,0.2)*AxisYRotate(deg2rad(90.0f));
-
-            rm_torus->component=CreateComponent<MeshComponent>(&cci,rm_torus->cdp);
-            rm_torus->component->SetOverrideMaterial(solid.mi[1]);
-        }
-
-        {
-            cci.mat=TranslateMatrix(0,0,1);
-            rm_cone->component=CreateComponent<MeshComponent>(&cci,rm_cone->cdp);
-            rm_cone->component->SetOverrideMaterial(solid.mi[2]);
-        }
-
-        {
-            cci.mat=TranslateMatrix(5,0,3)*AxisRotate(deg2rad(30),20,30,40);
-
-            rm_cylinder->component=CreateComponent<MeshComponent>(&cci,rm_cylinder->cdp);
-            rm_cylinder->component->SetOverrideMaterial(solid.mi[3]);
-        }
-
-        {
-            cci.mat=TranslateMatrix(0,0,4);
-
-            rm_sphere->component=CreateComponent<MeshComponent>(&cci,rm_sphere->cdp);
-            rm_sphere->component->SetOverrideMaterial(solid.mi[4]);
-        }
-
-        return(true);
-    }
-
-    bool InitBoundingBoxScene()
-    {
-        SceneNode *root=GetSceneRoot();
-
-        CreateComponentInfo cci(root);
-
-        ArrayList<Matrix4f> box_matrices;
-
-        for(Component *c:root->GetComponents())
-        {
-            if(c->GetTypeHash()!=MeshComponent::StaticTypeHash())
-                continue;
-
-            MeshComponent *component=(MeshComponent *)c;
-
-            Matrix4f mat;
-
-            if(component->GetWorldOBBMatrix(mat))
-                box_matrices.Add(mat);
-        }
-
-        //不可以直接在上面的循环中创建新的Component，因为循环本身就要读取Component列表
-
-        for(const Matrix4f &mat:box_matrices)
-        {
-            cci.mat=mat;
-
-            if(!CreateComponent<MeshComponent>(&cci,rm_box->cdp))
-                return(false);
-        }
-
-        return(true);
-    }
-
-    void SetCamera()
-    {
-        CameraControl *camera_control=GetCameraControl();
-
-        camera_control->SetPosition(Vector3f(8,8,8));
-        camera_control->SetTarget(Vector3f(0,0,0));
-    }
-
-public:
-
-    using WorkObject::WorkObject;
-
-    ~TestApp()
-    {
-        SAFE_CLEAR(rm_box)
-
-        SAFE_CLEAR(rm_torus)
-        SAFE_CLEAR(rm_cylinder)
-        SAFE_CLEAR(rm_cone)
-        SAFE_CLEAR(rm_sphere)
-        SAFE_CLEAR(rm_plane)
-
-        SAFE_CLEAR(mesh_vdm)
-    }
-
-    bool Init() override
-    {
-        if(!InitSolidMDP())
-            return(false);
-
-        if(!InitWireMDP())
-            return(false);
-
-        if(!InitVDM())
-            return(false);
-
-        if(!CreateGeometryMesh())
-            return(false);
-
-        if(!CreateBoundingBoxMesh())
-            return(false);
-
-        if(!InitScene())
-            return(false);
-
-        if(!InitBoundingBoxScene())
-            return(false);
-
-        SetCamera();
-
-        return(true);
-    }
-};//class TestApp:public CameraAppFramework
-
-int os_main(int,os_char **)
-{
-    return RunFramework<TestApp>(OS_TEXT("Render Bounding Box"),1280,720);
-}

example/Basic/auto_instance.cpp

@@ -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,59 +48,74 @@ 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);
 
         double rad;
-
-        CreateComponentInfo cci(GetSceneRoot());
+        Matrix4f mat;
         
         for(uint i=0;i<TRIANGLE_NUMBER;i++)
         {
-            rad=deg2rad<double>((360.0f/double(TRIANGLE_NUMBER))*i);       //这里一定要加<double>或<float>，否则结果用int保存会出现问题
-            cci.mat=rotate(rad,Vector3f(0,0,1));
+            rad=deg2rad<double>((360/TRIANGLE_NUMBER)*i);       //这里一定要加<float>或<float>，否则结果用int保存会出现问题
+            mat=rotate(rad,Vector3f(0,0,1));
 
-            CreateComponent<MeshComponent>(&cci,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);
@@ -102,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);
 }

example/Basic/auto_merge_material_instance.cpp

@@ -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,55 +76,89 @@ 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);
 
         db->Add(prim);
 
-        CreateComponentInfo cci(GetSceneRoot());
+        Matrix4f mat;
         
         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);
 
-            cci.mat=rotate(deg2rad<double>(TRI_ROTATE_ANGLE*i),AxisVector::Z);
+            mat=rotate(deg2rad<double>(double(360/DRAW_OBJECT_COUNT*i)),AxisVector::Z);
 
-            CreateComponent<MeshComponent>(&cci,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;
 }

example/Basic/draw_triangle_in_NDC.cpp

@@ -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);
+}

example/Basic/draw_triangle_use_UBO.cpp

@@ -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,72 +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);
-
-        CreateComponentInfo cci(GetSceneRoot());
-
-        return CreateComponent<MeshComponent>(&cci,mesh_triangle); //创建一个静态网格组件
+        if(!rpc.WriteVAB(VAN::Color,      VF_V4UN8,   color_data          ))return(false);
+        
+        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);
 }

example/Basic/first_app.cpp

@@ -0,0 +1,40 @@
+#include<hgl/graph/RenderFramework.h>
+#include<hgl/graph/module/RenderModule.h>
+#include<hgl/graph/VKCommandBuffer.h>
+#include<hgl/log/Logger.h>
+
+using namespace hgl;
+using namespace hgl::graph;
+
+class TestRenderModule:public RenderModule
+{
+public:
+
+    RENDER_MODULE_CONSTRUCT(TestRenderModule)
+
+    void OnResize(const VkExtent2D &size) override
+    {
+        LOG_INFO(OS_TEXT("Resize: ")+OSString::numberOf(size.width)+OS_TEXT("x")+OSString::numberOf(size.height));
+    }
+
+    void OnFrameRender(const double,RenderCmdBuffer *cmd) override
+    {
+        LOG_INFO(OS_TEXT("Execute"));
+
+        //cmd->Begin
+    }
+};//class TestGraphModule:public RenderModule
+
+int os_main(int,os_char **)
+{
+    RenderFramework rf;
+
+    if(!rf.Init(1280,720,OS_TEXT("FirstApp")))
+        return 1;
+
+    rf.AddModule<TestRenderModule>();
+
+    rf.Run();
+
+    return 0;
+}

example/CMakeLists.txt

@@ -1,6 +1,6 @@
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/common)
 
-SET(VULKAN_APP_FRAMEWORK    ${CMAKE_CURRENT_SOURCE_DIR}/common/VulkanAppFramework.h)
+SET(VULKAN_APP_FRAMEWORK ${CMAKE_CURRENT_SOURCE_DIR}/common/VulkanAppFramework.h)
 
 add_subdirectory(Basic)
 add_subdirectory(Texture)

example/GUI/DrawText.cpp

@@ -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);
 

example/Gizmo/BlenderAxis.cpp

@@ -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

example/Gizmo/CMakeLists.txt

@@ -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)

example/Gizmo/Gizmo.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include<hgl/graph/VK.h>
-#include<hgl/component/Component.h>
 
 VK_NAMESPACE_BEGIN
 
@@ -32,14 +31,13 @@ enum class GizmoShape:uint
     ENUM_CLASS_RANGE(Square,Torus)
 };
 
-bool InitGizmoResource(RenderFramework *);
+bool InitGizmoResource(RenderResource *);
 void FreeGizmoResource();
 
-MaterialInstance *GetGizmoMI3D(const GizmoColor &);
-ComponentDataPtr GetGizmoMeshCDP(const GizmoShape &shape);
+Renderable *GetGizmoRenderable(const GizmoShape &shape,const GizmoColor &color);
 
-SceneNode *GetGizmoMoveNode();
-//SceneNode *GetGizmoScaleMesh();
-//SceneNode *GetGizmoRotateMesh();
+StaticMesh *GetGizmoMoveStaticMesh();
+StaticMesh *GetGizmoScaleStaticMesh();
+StaticMesh *GetGizmoRotateStaticMesh();
 
 VK_NAMESPACE_END

example/Gizmo/Gizmo3DMove.cpp

@@ -22,365 +22,129 @@
 */
 
 #include"GizmoResource.h"
-#include<hgl/graph/SceneNode.h>
 #include<hgl/graph/VKRenderResource.h>
 #include<hgl/graph/InlineGeometry.h>
-#include<hgl/graph/RenderFramework.h>
-#include<hgl/graph/Scene.h>
-#include<hgl/component/MeshComponent.h>
-#include<hgl/io/event/MouseEvent.h>
-#include<hgl/graph/Ray.h>
-
-#include<iostream>
 
 VK_NAMESPACE_BEGIN
 
 namespace
 {
-    /**
-    * 移动 Gizmo 节点
-    */
-    class GizmoMoveNode:public SceneNode,io::MouseEvent
-    {
-        struct GizmoMoveAxis
-        {
-            MaterialInstance *mi;       //材质实例
-            MeshComponent *cylinder;    //圆柱
-            MeshComponent *cone;        //圆锥
-            MeshComponent *square;      //双轴调节正方形
-        };
-
-        MaterialInstance *pick_mi;
-        MeshComponent *sphere=nullptr;
-        GizmoMoveAxis axis[3]{};  //X,Y,Z 三个轴
-
-    protected:
-
-        Ray     MouseRay;
-
-        int     CurAXIS=-1;             //当前鼠标选中轴
-        float   CurDist=0;              //当前距离
-
-        int     PickAXIS=-1;            //拾取轴
-        float   PickDist=0;             //拾取辆距离轴心的距离
-        Matrix4f PickL2W;               //拾取时的变换矩阵
-        Vector3f PickCenter;            //拾取时的中心位置
-
-        TransformTranslate3f *CurTranslate=nullptr;
-
-    public:
-
-        using SceneNode::SceneNode;
-
-        io::EventDispatcher *GetEventDispatcher() override
-        {
-            return this; // GizmoMoveNode 处理鼠标事件
-        }
-
-        SceneNode *CreateNode()const override
-        {
-            return(new GizmoMoveNode);
-        }
-
-        void DuplicationComponents(SceneNode *node) const override
-        {
-            GizmoMoveNode *gmn=(GizmoMoveNode *)node;
-
-            if(!gmn)
-                return;
-
-            gmn->pick_mi=pick_mi;
-
-        #define DUPLICATION_COMPONENT(c)    gmn->c=(MeshComponent *)(c->Duplication()); \
-                                            gmn->AttachComponent(gmn->c);
-
-            DUPLICATION_COMPONENT(sphere);
-
-            for(size_t i=0;i<3;i++)
-            {
-                gmn->axis[i].mi=axis[i].mi; // 复制材质实例
-                DUPLICATION_COMPONENT(axis[i].cylinder);
-                DUPLICATION_COMPONENT(axis[i].cone);
-                DUPLICATION_COMPONENT(axis[i].square);
-            }
-
-        #undef DUPLICATION_COMPONENT
-        }
-
-        bool CreateGizmoGeometry(RenderFramework *render_framework)
-        {
-            ComponentDataPtr SpherePtr  =GetGizmoMeshCDP(GizmoShape::Sphere);
-            ComponentDataPtr CylinderPtr=GetGizmoMeshCDP(GizmoShape::Cylinder);
-            ComponentDataPtr ConePtr    =GetGizmoMeshCDP(GizmoShape::Cone);
-            ComponentDataPtr SquarePtr  =GetGizmoMeshCDP(GizmoShape::Square);
-
-            if(!SpherePtr   )return(false);
-            if(!CylinderPtr )return(false);
-            if(!ConePtr     )return(false);
-            if(!SquarePtr   )return(false);
-
-            CreateComponentInfo cci(this);
-
-            pick_mi=GetGizmoMI3D(GizmoColor::Yellow); //获取拾取材质实例
-
-            sphere=render_framework->CreateComponent<MeshComponent>(&cci,SpherePtr);        //中心球
-            sphere->SetOverrideMaterial(GetGizmoMI3D(GizmoColor::White));                     //白色
-
-            {
-                Transform tm;
-                GizmoMoveAxis *gma;
-
-                const Vector3f one_scale(1);
-                const Vector3f square_scale(2);
-                const Vector3f cylinder_scale(GIZMO_CYLINDER_RADIUS,GIZMO_CYLINDER_RADIUS,GIZMO_CYLINDER_HALF_LENGTH);
-
-                {
-                    gma=axis+size_t(AXIS::Z);
-                    gma->mi=GetGizmoMI3D(GizmoColor::Blue);
-
-                    tm.SetScale(cylinder_scale);
-                    tm.SetTranslation(0,0,GIZMO_CYLINDER_OFFSET);
-                    cci.mat=tm;
-                    gma->cylinder=render_framework->CreateComponent<MeshComponent>(&cci,CylinderPtr);       //Z 向上圆柱
-                    gma->cylinder->SetOverrideMaterial(gma->mi);
-
-                    tm.SetScale(one_scale);
-                    tm.SetTranslation(0,0,GIZMO_CONE_OFFSET);
-                    cci.mat=tm;
-                    gma->cone=render_framework->CreateComponent<MeshComponent>(&cci,ConePtr);           //Z 向上圆锥
-                    gma->cone->SetOverrideMaterial(gma->mi);
-
-                    tm.SetScale(square_scale);
-                    tm.SetTranslation(GIZMO_TWO_AXIS_OFFSET,GIZMO_TWO_AXIS_OFFSET,0);
-                    cci.mat=tm;
-                    gma->square=render_framework->CreateComponent<MeshComponent>(&cci,SquarePtr);
-                    gma->square->SetOverrideMaterial(gma->mi);
-                }
-
-                {
-                    gma=axis+size_t(AXIS::X);
-                    gma->mi=GetGizmoMI3D(GizmoColor::Red);
-
-                    tm.SetScale(cylinder_scale);
-                    tm.SetRotation(AxisVector::Y,90);
-                    tm.SetTranslation(GIZMO_CYLINDER_OFFSET,0,0);
-                    cci.mat=tm;
-                    gma->cylinder=render_framework->CreateComponent<MeshComponent>(&cci,CylinderPtr);       //X 向右圆柱
-                    gma->cylinder->SetOverrideMaterial(gma->mi);
-
-                    tm.SetScale(one_scale);
-                    tm.SetTranslation(GIZMO_CONE_OFFSET,0,0);
-                    cci.mat=tm;
-                    gma->cone=render_framework->CreateComponent<MeshComponent>(&cci,ConePtr);           //Z 向上圆锥
-                    gma->cone->SetOverrideMaterial(gma->mi);
-
-                    tm.SetScale(square_scale);
-                    tm.SetTranslation(0,GIZMO_TWO_AXIS_OFFSET,GIZMO_TWO_AXIS_OFFSET);
-                    cci.mat=tm;
-                    gma->square=render_framework->CreateComponent<MeshComponent>(&cci,SquarePtr);
-                    gma->square->SetOverrideMaterial(gma->mi);
-                }
-
-                {
-                    gma=axis+size_t(AXIS::Y);
-                    gma->mi=GetGizmoMI3D(GizmoColor::Green);
-
-                    tm.SetScale(cylinder_scale);
-                    tm.SetRotation(AxisVector::X,-90);
-                    tm.SetTranslation(0,GIZMO_CYLINDER_OFFSET,0);
-                    cci.mat=tm;
-                    gma->cylinder=render_framework->CreateComponent<MeshComponent>(&cci,CylinderPtr);       //X 向右圆柱
-                    gma->cylinder->SetOverrideMaterial(gma->mi);
-
-                    tm.SetScale(one_scale);
-                    tm.SetTranslation(0,GIZMO_CONE_OFFSET,0);
-                    cci.mat=tm;
-                    gma->cone=render_framework->CreateComponent<MeshComponent>(&cci,ConePtr);           //Z 向上圆锥
-                    gma->cone->SetOverrideMaterial(gma->mi);
-
-                    tm.SetScale(square_scale);
-                    tm.SetTranslation(GIZMO_TWO_AXIS_OFFSET,0,GIZMO_TWO_AXIS_OFFSET);
-                    cci.mat=tm;
-                    gma->square=render_framework->CreateComponent<MeshComponent>(&cci,SquarePtr);
-                    gma->square->SetOverrideMaterial(gma->mi);
-                }
-            }
-
-            return(true);
-        }
-
-        io::EventProcResult OnPressed(const Vector2i &mp,io::MouseButton mb) override
-        {
-            GizmoMoveNode::OnMove(mp);
-
-            if(CurAXIS>=0&&CurAXIS<3)
-            {
-                PickAXIS    =CurAXIS;
-                PickDist    =CurDist;
-                PickL2W     =GetLocalToWorldMatrix(); //记录拾取时的变换矩阵
-                PickCenter  =TransformPosition(PickL2W,Vector3f(0,0,0)); //记录拾取时的中心位置
-
-                if(CurTranslate)
-                {
-                    CurTranslate->SetOffset(Vector3f(0,0,0));
-                }
-                else
-                {
-                    CurTranslate=GetTransform().AddTranslate(Vector3f(0,0,0));
-                }
-
-                return io::EventProcResult::Break; // 处理完鼠标按下事件，停止进一步处理
-            }
-
-            return io::EventProcResult::Continue;
-        }
-
-        io::EventProcResult OnReleased(const Vector2i &,io::MouseButton mb) override
-        {
-            if(CurTranslate)
-            {
-                GetTransform().RemoveTransform(CurTranslate);
-                CurTranslate=nullptr;
-            }
-
-            return io::EventProcResult::Continue;
-        }
-
-        io::EventProcResult OnMoveAtControl(const Vector2i &mouse_coord)
-        {
-            CameraControl *cc=GetCameraControl();
-
-            if(!cc)
-                return io::EventProcResult::Continue;
-
-            cc->SetMouseRay(&MouseRay,mouse_coord);
-
-            const CameraInfo *ci=cc->GetCameraInfo();
-
-            Vector3f axis_vector=GetAxisVector(AXIS(PickAXIS)); //取得轴向量
-
-            Vector3f end=axis_vector*std::abs(ci->zfar-ci->znear);
-
-            end=TransformPosition(PickL2W,end); //将轴的终点转换到世界坐标
-
-            Vector3f p_ray,p_ls;
-
-            MouseRay.ClosestPoint(
-                p_ray,          // 射线上的点
-                p_ls,           // 线段上的点
-                PickCenter,     // 线段起点
-                end);           // 线段终点
-
-            CurDist=glm::length(p_ls-PickCenter); //计算线段上的点与原点的距离
-            CurTranslate->SetOffset(axis_vector*(CurDist-PickDist)); //设置偏移量
-
-            std::cout<<"PickDist: "<<PickDist<<std::endl;
-            std::cout<<"CurDist : "<<CurDist<<std::endl;
-
-            return io::EventProcResult::Continue;
-        }
-
-        io::EventProcResult OnMove(const Vector2i &mouse_coord) override
-        {
-            if(CurTranslate)
-            {
-                return OnMoveAtControl(mouse_coord); //已经选中一个轴了
-            }
-
-            CameraControl *cc=GetCameraControl();
-
-            if(!cc)
-                return io::EventProcResult::Continue;
-
-            cc->SetMouseRay(&MouseRay,mouse_coord);
-
-            Matrix4f l2w=GetLocalToWorldMatrix();
-            Vector3f center=TransformPosition(l2w,Vector3f(0,0,0));
-            Vector3f axis_vector;
-            Vector3f start;
-            Vector3f end;
-            Vector3f p_ray,p_ls;
-            float dist;
-            float pixel_per_unit;
-            float center_ppu;
-            MaterialInstance *mi;
-
-            center_ppu=cc->GetPixelPerUnit(center); //求原点坐标相对屏幕空间象素的缩放比
-
-            CurAXIS=-1;
-
-            for(int i=0;i<3;i++)
-            {
-                axis_vector=GetAxisVector(AXIS(i)); //取得轴向量
-
-                start   =TransformPosition(l2w,axis_vector*center_ppu* GIZMO_CENTER_SPHERE_RADIUS); //将轴的起点转换到世界坐标
-                end     =TransformPosition(l2w,axis_vector*center_ppu*(GIZMO_CENTER_SPHERE_RADIUS+GIZMO_CONE_LENGTH+GIZMO_CYLINDER_HALF_LENGTH));
-
-                //求射线与线段的最近点
-                MouseRay.ClosestPoint(  p_ray,         //射线上的点
-                                        p_ls,          //线段上的点
-                                        start,end);    //线段
-
-                dist=glm::distance(p_ray,p_ls); //计算射线与线段的距离
-
-                //求p_ls坐标相对屏幕空间象素的缩放比
-                pixel_per_unit=cc->GetPixelPerUnit(p_ls);
-
-                if(dist<GIZMO_CYLINDER_RADIUS*pixel_per_unit)
-                {
-                    mi=pick_mi;
-
-                    CurAXIS=i;
-                    CurDist=glm::length(p_ls-start);      //计算线段上的点与原点的距离
-                }
-                else
-                {
-                    mi=axis[i].mi;
-                }
-
-                axis[i].cylinder->SetOverrideMaterial(mi);
-                axis[i].cone->SetOverrideMaterial(mi);
-
-                //std::cout<<"Mouse:    "<<mouse_coord.x<<","<<mouse_coord.y<<std::endl;
-                //std::cout<<"Ray(Ori): "<<MouseRay.origin.x<<","<<MouseRay.origin.y<<","<<MouseRay.origin.z<<")"<<std::endl;
-                //std::cout<<"Ray(Dir): "<<MouseRay.direction.x<<","<<MouseRay.direction.y<<","<<MouseRay.direction.z<<")"<<std::endl;
-                //std::cout<<"Distance: "<<dist<<std::endl;
-            }
-
-            if(CurTranslate)
-                return io::EventProcResult::Break;
-
-            return io::EventProcResult::Continue;
-        }
-    };//class GizmoMoveNode:public SceneNode
-
-    static GizmoMoveNode *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()
 {
-    if(sn_gizmo_move)
-        return(false);
-
-    sn_gizmo_move=new GizmoMoveNode;
-
-    if(!sn_gizmo_move->CreateGizmoGeometry(render_framework))
+    Renderable *sphere=GetGizmoRenderable(GizmoShape::Sphere,GizmoColor::White);
+    Renderable *cylinder[3]
     {
-        delete sn_gizmo_move;
-        sn_gizmo_move=nullptr;
+        GetGizmoRenderable(GizmoShape::Cylinder,GizmoColor::Red),
+        GetGizmoRenderable(GizmoShape::Cylinder,GizmoColor::Green),
+        GetGizmoRenderable(GizmoShape::Cylinder,GizmoColor::Blue),
+    };
+
+    Renderable *cone[3]
+    {
+        GetGizmoRenderable(GizmoShape::Cone,GizmoColor::Red),
+        GetGizmoRenderable(GizmoShape::Cone,GizmoColor::Green),
+        GetGizmoRenderable(GizmoShape::Cone,GizmoColor::Blue),
+    };
+
+    Renderable *circle[3]=
+    {
+        GetGizmoRenderable(GizmoShape::Circle,GizmoColor::Red),
+        GetGizmoRenderable(GizmoShape::Circle,GizmoColor::Green),
+        GetGizmoRenderable(GizmoShape::Circle,GizmoColor::Blue)
+    };
+
+    if(!sphere)
         return(false);
+
+    for(int i=0;i<3;i++)
+    {
+        if(!cylinder[i])
+            return(false);
+
+        if(!cone[i])
+            return(false);
+
+        if(!circle[i])
+            return(false);
     }
 
+    {
+        SceneNode *root_node=new SceneNode();
+        
+        root_node->Add(new SceneNode(sphere));
+
+        {
+            Transform tm;
+
+            const Vector3f one_scale(1);
+            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);
+                root_node->Add(new SceneNode(tm,cylinder[2]));       //Z 向上圆柱
+
+                tm.SetScale(one_scale);
+                tm.SetTranslation(0,0,GIZMO_CONE_OFFSET);
+                root_node->Add(new SceneNode(tm,cone[2]));           //Z 向上圆锥
+
+                tm.SetScale(circle_scale);
+                tm.SetTranslation(GIZMO_TWO_AXIS_OFFSET,GIZMO_TWO_AXIS_OFFSET,0);
+                root_node->Add(new SceneNode(tm,circle[2]));
+            }
+
+            {
+                tm.SetScale(cylinder_scale);
+                tm.SetRotation(AxisVector::Y,90);
+                tm.SetTranslation(GIZMO_CYLINDER_OFFSET,0,0);
+                root_node->Add(new SceneNode(tm,cylinder[0]));       //X 向右圆柱
+
+                tm.SetScale(one_scale);
+                tm.SetTranslation(GIZMO_CONE_OFFSET,0,0);
+                root_node->Add(new SceneNode(tm,cone[0]));           //X 向右圆锥
+
+                tm.SetScale(circle_scale);
+                tm.SetTranslation(0,GIZMO_TWO_AXIS_OFFSET,GIZMO_TWO_AXIS_OFFSET);
+                root_node->Add(new SceneNode(tm,circle[0]));
+            }
+
+            {
+                tm.SetScale(cylinder_scale);
+                tm.SetRotation(AxisVector::X,-90);
+                tm.SetTranslation(0,GIZMO_CYLINDER_OFFSET,0);
+                
+                root_node->Add(new SceneNode(tm,cylinder[1]));       //Y 向前圆柱
+
+                tm.SetScale(one_scale);
+                tm.SetTranslation(0,GIZMO_CONE_OFFSET,0);
+                root_node->Add(new SceneNode(tm,cone[1]));           //Y 向前圆锥
+
+                tm.SetScale(circle_scale);
+                tm.SetTranslation(GIZMO_TWO_AXIS_OFFSET,0,GIZMO_TWO_AXIS_OFFSET);
+                root_node->Add(new SceneNode(tm,circle[1]));
+            }
+        }
+
+        sm_gizmo_move=CreateGizmoStaticMesh(root_node);
+    }
+
+    if(!sm_gizmo_move)
+        return(false);
+
     return(true);
 }
 

example/Gizmo/Gizmo3DRotate.cpp

@@ -1,5 +1,4 @@
 #include"GizmoResource.h"
-#include<hgl/graph/SceneNode.h>
 #include<hgl/graph/VKRenderResource.h>
 #include<hgl/graph/TransformFaceToCamera.h>
 
@@ -22,13 +21,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)

example/Gizmo/Gizmo3DScale.cpp

@@ -22,7 +22,6 @@
 */
 
 #include"GizmoResource.h"
-#include<hgl/graph/SceneNode.h>
 #include<hgl/graph/VKRenderResource.h>
 #include<hgl/graph/InlineGeometry.h>
 
@@ -45,26 +44,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)

example/Gizmo/GizmoResource.cpp

@@ -8,75 +8,56 @@
 #include<hgl/graph/VKRenderResource.h>
 #include<hgl/color/Color.h>
 #include<hgl/graph/InlineGeometry.h>
-#include<hgl/graph/SceneNode.h>
-#include<hgl/graph/RenderFramework.h>
-#include<hgl/component/MeshComponent.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;
+    static RenderResource *  gizmo_rr=nullptr;
 
     struct GizmoResource
     {
-        Material *          mtl;
-        MaterialInstance *  mi[size_t(GizmoColor::RANGE_SIZE)];
-        Pipeline *          pipeline;
-        VertexDataManager * vdm;
+        Material *           mtl;
+        MaterialInstance *   mi[size_t(GizmoColor::RANGE_SIZE)];
+        Pipeline *           pipeline;
+        VertexDataManager *  vdm;
 
-        PrimitiveCreater *  prim_creater;
+        PrimitiveCreater *   prim_creater;
     };
 
     static GizmoResource    gizmo_line{};
     static GizmoResource    gizmo_triangle{};
 
-    struct GizmoMesh
+    struct GizmoRenderable
     {
         Primitive *prim;
 
-        Mesh *mesh;
-        MeshComponentData *mcd;
-        ComponentDataPtr cdp;
-
-    public:
-
-        void Create(Primitive *p)
-        {
-            prim=p;
-
-            mesh=CreateMesh(prim,gizmo_triangle.mi[0],gizmo_triangle.pipeline);
-            mcd=new MeshComponentData(mesh);
-            cdp=mcd;
-        }
-
-        void Clear()
-        {
-            SAFE_CLEAR(mesh);
-            cdp.unref();
-            SAFE_CLEAR(prim)
-        }
-    };//class GizmoMesh
+        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)
+    void InitGizmoRenderable(const GizmoShape &gs,Primitive *prim,Pipeline *p)
     {
         if(!prim)
             return;
 
-        gizmo_mesh[size_t(gs)].Create(prim);
+        GizmoRenderable *gr=gizmo_rederable+size_t(gs);
+
+        gr->prim=prim;
+
+        for(uint i=0;i<uint(GizmoColor::RANGE_SIZE);i++)
+            gr->renderable[i]=CreateRenderable(prim,gizmo_triangle.mi[i],p);
     }
 
     bool InitMI(GizmoResource *gr)
@@ -91,7 +72,6 @@ namespace
             color=GetColor4f(gizmo_color[i],1.0);
 
             gr->mi[i]=gizmo_rr->CreateMaterialInstance(gr->mtl,nullptr,&color);
-
             if(!gr->mi[i])
                 return(false);
         }
@@ -99,27 +79,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);
 
@@ -127,7 +106,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);
@@ -154,27 +133,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);
 
@@ -182,7 +159,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);
         }
@@ -213,7 +190,7 @@ namespace
             using namespace inline_geometry;
 
             {
-                InitGizmoMesh(GizmoShape::Square,CreatePlaneSqaure(gizmo_triangle.prim_creater));
+                InitGizmoRenderable(GizmoShape::Square,CreatePlaneSqaure(gizmo_triangle.prim_creater),gizmo_triangle.pipeline);
             }
 
             {
@@ -224,7 +201,7 @@ namespace
                 cci.field_count=16;
                 cci.has_center=false;
                 
-                InitGizmoMesh(GizmoShape::Circle,CreateCircle3DByIndexTriangles(gizmo_triangle.prim_creater,&cci));
+                InitGizmoRenderable(GizmoShape::Circle,CreateCircle3DByIndexTriangles(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
             }
 
             {
@@ -234,11 +211,11 @@ namespace
                 cci.tangent=false;
                 cci.tex_coord=false;
 
-                InitGizmoMesh(GizmoShape::Cube,CreateCube(gizmo_triangle.prim_creater,&cci));
+                InitGizmoRenderable(GizmoShape::Cube,CreateCube(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
             }
 
             {
-                InitGizmoMesh(GizmoShape::Sphere,CreateSphere(gizmo_triangle.prim_creater,16));
+                InitGizmoRenderable(GizmoShape::Sphere,CreateSphere(gizmo_triangle.prim_creater,16),gizmo_triangle.pipeline);
             }
 
             {
@@ -249,7 +226,7 @@ namespace
                 cci.numberSlices=16;        //圆锥底部分割数
                 cci.numberStacks=3;         //圆锥高度分割数
 
-                InitGizmoMesh(GizmoShape::Cone,CreateCone(gizmo_triangle.prim_creater,&cci));
+                InitGizmoRenderable(GizmoShape::Cone,CreateCone(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
             }
 
             {
@@ -259,7 +236,7 @@ namespace
                 cci.numberSlices=16;        //圆柱底部分割数
                 cci.radius      =1;         //圆柱半径
 
-                InitGizmoMesh(GizmoShape::Cylinder,CreateCylinder(gizmo_triangle.prim_creater,&cci));
+                InitGizmoRenderable(GizmoShape::Cylinder,CreateCylinder(gizmo_triangle.prim_creater,&cci),gizmo_triangle.pipeline);
             }
 
             {
@@ -270,12 +247,12 @@ namespace
                 tci.numberSlices=64;
                 tci.numberStacks=8;
 
-                InitGizmoMesh(GizmoShape::Torus,CreateTorus(gizmo_triangle.prim_creater,&tci));
+                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);
             }
         }
@@ -284,38 +261,42 @@ 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)
-        gr.Clear();
+    for(GizmoRenderable &gr:gizmo_rederable)
+    {
+        SAFE_CLEAR(gr.prim)
+        SAFE_CLEAR_OBJECT_ARRAY(gr.renderable)
+    }
 
     SAFE_CLEAR(gizmo_triangle.prim_creater);
     SAFE_CLEAR(gizmo_triangle.vdm);
@@ -324,21 +305,26 @@ void FreeGizmoResource()
     SAFE_CLEAR(gizmo_line.vdm);
 }
 
-MaterialInstance *GetGizmoMI3D(const GizmoColor &color)
-{
-    RANGE_CHECK_RETURN_NULLPTR(color)
-
-    return gizmo_triangle.mi[size_t(color)];
-}
-
-ComponentDataPtr GetGizmoMeshCDP(const GizmoShape &shape)
+Renderable *GetGizmoRenderable(const GizmoShape &shape,const GizmoColor &color)
 {
     if(!gizmo_rr)
         return(nullptr);
 
     RANGE_CHECK_RETURN_NULLPTR(shape)
+    RANGE_CHECK_RETURN_NULLPTR(color)
 
-    return gizmo_mesh[size_t(shape)].cdp;
+    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

example/Gizmo/GizmoResource.h

@@ -1,5 +1,4 @@
 #pragma once
-
 #include"Gizmo.h"
 #include<hgl/color/Color.h>
 
@@ -7,18 +6,18 @@ VK_NAMESPACE_BEGIN
 
 class SceneNode;
 class PrimitiveCreater;
-class MeshComponent;
+class StaticMesh;
 
 constexpr const COLOR gizmo_color[size_t(GizmoColor::RANGE_SIZE)]=
 {
-    COLOR::MozillaCharcoal,         ///<黑色
-    COLOR::AntiqueWhite,            ///<白色
+    COLOR::MozillaCharcoal,
+    COLOR::BlanchedAlmond,
 
     COLOR::BlenderAxisRed,
     COLOR::BlenderAxisGreen,
     COLOR::BlenderAxisBlue,
 
-    COLOR::GoldenYellow,
+    COLOR::BlenderYellow,
 };
 
 constexpr const float GIZMO_ARROW_LENGTH        =10.0f;                                                                 ///<箭头整体长度
@@ -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

example/Gizmo/GizmoTest.cpp

@@ -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(sm_move->Duplication());
-        //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
-    //{
-    //    camera_control->Refresh();
-    //    
-    //    const CameraInfo *ci=camera_control->GetCameraInfo();
-    //    const ViewportInfo *vi=GetViewportInfo();
+    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 float screen_height=vi->GetViewportHeight();
 
-    //    const Vector4f pos=ci->Project(GizmoPosition);
+        const Vector4f pos=ci->Project(GizmoPosition);
 
-    //    //{
-    //    //    Transform tm;
+        //{
+        //    Transform tm;
 
-    //    //    tm.SetScale(pos.w*16.0f/screen_height);
+        //    tm.SetScale(pos.w*16.0f/screen_height);
 
-    //    //    root.SetLocalTransform(tm);
-    //    //}
-    //}
-};//class TestApp:public WorkObject
+        //    root.SetLocalTransform(tm);
+        //}
 
-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);
 }

example/Gizmo/MetricCellsGrid.cpp

@@ -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);
+}

example/Gizmo/PlaneGrid3D.cpp

@@ -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,54 +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);
 
-        CreateComponentInfo cci(parent_node,mat);
+        render_root.Add(new SceneNode(mat,ri));
 
-        CreateComponent<MeshComponent>(&cci,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);
 
@@ -131,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);
 }

example/Gizmo/RayPicking.cpp

@@ -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,19 +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);
         }
 
-        CreateComponentInfo cci(parent_node);
-
-        CreateComponent<MeshComponent>(&cci,ri);
+        render_root.Add(new SceneNode(ri));
 
         return ri;
     }
@@ -113,7 +112,7 @@ private:
         using namespace inline_geometry;
         
         {
-            auto pc=GetPrimitiveCreater(mi_plane_grid);
+            PrimitiveCreater pc(device,mi_plane_grid->GetVIL());
 
             struct PlaneGridCreateInfo pgci;
 
@@ -123,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);
         }
@@ -141,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);
 
@@ -177,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代表的数据数量,不是字节数
+                                 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);
 }

example/Gizmo/SimplestAxis.cpp

@@ -1,102 +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);
-
-        CreateComponentInfo cci(GetSceneRoot());
-
-        CreateComponent<MeshComponent>(&cci,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);
-}

example/LightBasic/BlinnPhongDirectionLight.cpp

@@ -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);
         }
 

example/Texture/texture_format_list.cpp

@@ -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();
 
@@ -100,4 +100,4 @@ int main(int,char **)
     delete inst;
  
     return 0;
-}
+}

example/Texture/texture_quad.cpp

@@ -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);
     }
 

example/Texture/texture_rect.cpp

@@ -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);
     }
 

example/Texture/texture_rect_array.cpp

@@ -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();

example/Vulkan/Atmosphere.cpp

@@ -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;

example/Vulkan/Cubemap.cpp

@@ -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>
 

example/Vulkan/Deferred.cpp

@@ -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))

example/Vulkan/DeferredRender.cpp

@@ -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)
             {

example/Vulkan/EquirectangularMap.cpp

@@ -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>
 

example/Vulkan/InlineGeometryScene.cpp

@@ -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,

example/common/VulkanAppFramework.h

@@ -38,24 +38,18 @@ using namespace hgl;
 using namespace hgl::io;
 using namespace hgl::graph;
 
-namespace hgl{namespace graph
-{
-    bool InitShaderCompiler();
-    void CloseShaderCompiler();
-}}//namespace hgl::graph
-
 class VulkanApplicationFramework:WindowEvent
 {
 protected:
 
-            Window *    win             =nullptr;
-    VulkanInstance *    inst            =nullptr;
+            Window *        win                         =nullptr;
+    VulkanInstance *        inst                        =nullptr;
 
 protected:
 
-    VulkanDevice *          device                      =nullptr;
+    GPUDevice *             device                      =nullptr;
     RenderPass *            device_render_pass          =nullptr;
-    SwapchainRenderTarget * sc_render_target            =nullptr;
+    RTSwapchain *           sc_render_target            =nullptr;
 
 protected:
 
@@ -84,11 +78,14 @@ public:
         rr->static_descriptor.AddUBO(mtl::SBS_ViewportInfo.name,ubo_vp_info);
     }
 
+    VulkanApplicationFramework()
+    {
+        RegistryCommonGraphModule();
+    }
+
     virtual ~VulkanApplicationFramework()
     {
-        CloseShaderCompiler();
-
-        win->RemoveChildDispatcher(this);
+        win->Unjoin(this);
 
         SAFE_CLEAR(db);
         SAFE_CLEAR_OBJECT_ARRAY_OBJECT(cmd_buf,swap_chain_count);
@@ -102,9 +99,6 @@ public:
     {
         logger::InitLogger(OS_TEXT("VulkanTest"));
 
-        if(!InitShaderCompiler())
-            return(false);
-
         SetClearColor(COLOR::MozillaCharcoal);
 
     #ifdef _DEBUG
@@ -154,7 +148,7 @@ public:
 
         InitCommandBuffer();
 
-        win->AddChildDispatcher(this);
+        win->Join(this);
 
         {
             vp_info.Set(w,h);
@@ -216,16 +210,16 @@ public:
             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));
+                cmd_buf[i]=device->CreateRenderCommandBuffer(device->GetPhysicalDevice()->GetDeviceName()+AnsiString(":RenderCmdBuffer_")+AnsiString::numberOf(i));
         }
     }
 
-    bool BuildCommandBuffer(RenderCmdBuffer *cb,Framebuffer *fbo,Mesh *ri)
+    bool BuildCommandBuffer(RenderCmdBuffer *cb,RenderPass *rp,Framebuffer *fb,Renderable *ri)
     {   
         if(!ri)return(false);
 
         cb->Begin();
-            cb->BindFramebuffer(fbo);
+            cb->BindFramebuffer(rp,fb);
             cb->SetClearColor(0,clear_color);
             cb->BeginRenderPass();
                 cb->BindPipeline(ri->GetPipeline());
@@ -238,15 +232,22 @@ public:
         return(true);
     }
 
-    bool BuildCommandBuffer(uint32_t index,Mesh *ri)
+    void BuildCommandBuffer(RenderCmdBuffer *cb,RenderTarget *rt,Renderable *ri)
+    {
+        if(!cb||!rt||!ri)
+            return;
+
+        BuildCommandBuffer(cb,rt->GetRenderPass(),rt->GetFramebuffer(),ri);
+    }
+
+    bool BuildCommandBuffer(uint32_t index,Renderable *ri)
     {   
         if(!ri)return(false);
 
-        return BuildCommandBuffer(cmd_buf[index],
-                                  sc_render_target->GetFramebuffer(),ri);
+        return BuildCommandBuffer(cmd_buf[index],sc_render_target->GetRenderPass(),sc_render_target->GetFramebuffer(index),ri);
     }
 
-    bool BuildCommandBuffer(Mesh *ri)
+    bool BuildCommandBuffer(Renderable *ri)
     {
         if(!ri)return(false);
 
@@ -256,7 +257,7 @@ public:
         return(true);
     }
 
-    bool BuildCurrentCommandBuffer(Mesh *ri)
+    bool BuildCurrentCommandBuffer(Renderable *ri)
     {
         if(!ri)return(false);
     
@@ -270,7 +271,7 @@ public:
         RenderCmdBuffer *cb=cmd_buf[index];
 
         cb->Begin();
-        cb->BindFramebuffer(sc_render_target->GetFramebuffer(index));
+        cb->BindFramebuffer(sc_render_target->GetRenderPass(),sc_render_target->GetFramebuffer(index));        
         cb->SetClearColor(0,clear_color);
             cb->BeginRenderPass();
                 rl->Render(cb);
@@ -346,6 +347,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:
@@ -403,8 +523,8 @@ public:
         ckc=new CameraKeyboardControl(camera_control);
         cmc=new CameraMouseControl(camera_control);
 
-        win->AddChildDispatcher(ckc);
-        win->AddChildDispatcher(cmc);
+        win->Join(ckc);
+        win->Join(cmc);
 
         RefreshCameraInfo(camera_control->GetCameraInfo(),&vp_info,camera);
         
@@ -498,4 +618,4 @@ template<typename T> int RunApp(uint w,uint h)
     while(app.Run());
 
     return 0;
-}
+}

inc/hgl/WorkManager.h

@@ -1,91 +0,0 @@
-#pragma once
-
-#include<hgl/WorkObject.h>
-#include<hgl/graph/VKRenderTargetSwapchain.h>
-
-namespace hgl
-{
-    /**
-    * 工作管理器，管理一个序列的WorkObject<br>
-    */
-    class WorkManager:public io::WindowEvent
-    {
-    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;
-
-            rf->AddChildDispatcher(this);
-        }
-
-        virtual ~WorkManager()
-        {
-            render_framework->RemoveChildDispatcher(this);
-            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
-    {
-        graph::SwapchainModule *swapchain_module;
-
-    public:
-
-        SwapchainWorkManager(graph::RenderFramework *rf):WorkManager(rf)
-        {
-            swapchain_module=rf->GetSwapchainModule();
-        }
-
-        ~SwapchainWorkManager()=default;
-
-        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

inc/hgl/WorkObject.h

@@ -1,135 +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:
-
-        template<typename ...ARGS>
-        graph::VertexDataManager *CreateVDM(ARGS...args)
-        {
-            return render_framework?render_framework->CreateVDM(args...):nullptr;
-        }
-
-        graph::Material *CreateMaterial(const AnsiString &mi_name,const graph::mtl::MaterialCreateInfo *mci)
-        {
-            return render_framework?render_framework->CreateMaterial(mi_name,mci):nullptr;
-        }
-
-    #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(const graph::CreateComponentInfo *cci,ARGS...args)
-        {
-            return render_framework?render_framework->CreateComponent<C>(cci,args...):nullptr; //创建组件
-        }
-    };//class WorkObject
-
-    /**
-    * 但我们认为游戏开发者不应该关注如何控制渲染，而应该关注如何处理游戏逻辑.
-    * 所以我们在WorkObject的基础上再提供RenderWorkObject派生类，用于直接封装好的渲染场景树控制。
-    * 
-    * 开发者仅需要将要渲染的物件放置于场景树即可。
-
-    * 但开发者也可以直接使用WorkObject，自行管理这些事。
-    * */
-}//namespcae hgl

inc/hgl/component/Component.h

@@ -1,209 +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;
-
-    virtual const size_t GetTypeHash()const=0;              ///<取得ComponentData的类型哈希值
-    virtual const size_t GetComponentTypeHash()const=0;     ///<取得Component的类型哈希值
-    virtual const size_t GetManagerTypeHash()const=0;       ///<取得ComponentManager的类型哈希值
-};//struct ComponentData
-
-#define COMPONENT_DATA_CLASS_BODY(name)  static constexpr   const size_t StaticTypeHash         (){return hgl::GetTypeHash<name##ComponentData>();} \
-                                         static constexpr   const size_t StaticComponentTypeHash(){return hgl::GetTypeHash<name##Component>();} \
-                                         static constexpr   const size_t StaticManagerTypeHash  (){return hgl::GetTypeHash<name##ComponentManager>();}   \
-                                                            const size_t GetTypeHash            ()const override{return StaticTypeHash();} \
-                                                            const size_t GetComponentTypeHash   ()const override{return StaticComponentTypeHash();} \
-                                                            const size_t GetManagerTypeHash     ()const override{return StaticManagerTypeHash();}
-
-using ComponentDataPtr=SharedPtr<ComponentData>;
-
-/**
-* 为什么要ComponentData与Component分离？
-*
-*   ComponentData是Component的一个数据载体，但它也仅仅代表数据。
-*   它不参与任何的逻辑、事件、更新、渲染操作，而且同一份数据可以被多个Component使用。
-*   同时，Component也可以在运行时更换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 GetTypeHash()const=0;              ///<取得Component的类型哈希值
-    virtual const size_t GetDataTypeHash()const=0;          ///<取得ComponentData的类型哈希值
-    virtual const size_t GetManagerTypeHash()const=0;       ///<取得ComponentManager的类型哈希值
-
-public:
-
-    uint                GetUniqueID ()const{return unique_id;}
-
-    SceneNode *         GetOwnerNode()const{return OwnerNode;}
-    ComponentManager *  GetManager  ()const{return Manager;}
-    ComponentDataPtr    GetData     ()const{return Data;}
-
-public:
-
-    virtual bool        ChangeData(ComponentDataPtr cdp);
-
-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  StaticTypeHash          ()              {return hgl::GetTypeHash<name##Component>();} \
-                                    static  constexpr const size_t  StaticDataTypeHash      ()              {return hgl::GetTypeHash<name##ComponentData>();} \
-                                    static  constexpr const size_t  StaticManagerTypeHash   ()              {return hgl::GetTypeHash<name##ComponentManager>();} \
-                                            const size_t            GetTypeHash             ()const override{return StaticTypeHash();} \
-                                            const size_t            GetDataTypeHash         ()const override{return StaticDataTypeHash();} \
-                                            const size_t            GetManagerTypeHash      ()const override{return StaticManagerTypeHash();}
-
-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    GetComponentTypeHash()const=0;          ///<取得Component的类型哈希值
-    virtual const size_t    GetDataTypeHash()const=0;               ///<取得ComponentData的类型哈希值
-    virtual const size_t    GetTypeHash()const=0;                   ///<取得ComponentManager的类型哈希值
-
-    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    StaticTypeHash          ()              {return hgl::GetTypeHash<name##ComponentManager>();}    \
-                                                static  constexpr   const size_t    StaticDataTypeHash      ()              {return hgl::GetTypeHash<name##ComponentData>();} \
-                                                static  constexpr   const size_t    StaticComponentTypeHash ()              {return hgl::GetTypeHash<name##Component>();}   \
-                                                                    const size_t    GetComponentTypeHash    ()const override{return StaticComponentTypeHash();} \
-                                                                    const size_t    GetDataTypeHash         ()const override{return StaticDataTypeHash();} \
-                                                                    const size_t    GetTypeHash             ()const override{return StaticTypeHash();}
-
-bool RegisterComponentManager(ComponentManager *);
-ComponentManager *GetComponentManager(const size_t hash_code);
-
-template<typename T> inline T *GetComponentManager(bool create_default=true)
-{
-    T *cm=(T *)GetComponentManager(T::StaticTypeHash());
-
-    if(!cm&&create_default)
-    {
-        cm=new T;
-
-        RegisterComponentManager(cm);
-    }
-
-    return cm;
-}
-COMPONENT_NAMESPACE_END

inc/hgl/component/CreateComponentInfo.h

@@ -1,46 +0,0 @@
-#pragma once
-
-#include<hgl/math/Matrix.h>
-
-namespace hgl::graph
-{
-    class SceneNode;
-
-    struct CreateComponentInfo
-    {
-        graph::SceneNode *owner_node;           ///<所属节点
-        graph::Matrix4f mat;                    ///<变换矩阵
-
-    public:
-
-        CreateComponentInfo()
-        {
-            owner_node=nullptr;
-            mat=graph::Identity4f;
-        }
-
-        CreateComponentInfo(const CreateComponentInfo &cci)
-        {
-            owner_node=cci.owner_node;
-            mat=cci.mat;
-        }
-
-        CreateComponentInfo(graph::SceneNode *pn,const graph::Matrix4f &m)
-        {
-            owner_node=pn;
-            mat=m;
-        }
-
-        CreateComponentInfo(graph::SceneNode *pn)
-        {
-            owner_node=pn;
-            mat=graph::Identity4f;
-        }
-
-        CreateComponentInfo(const graph::Matrix4f &m)
-        {
-            owner_node=nullptr;
-            mat=m;
-        }
-    };//struct CreateComponentInfo
-}//namespace hgl::graph

inc/hgl/component/MeshComponent.h

@@ -1,171 +0,0 @@
-#pragma once
-
-#include<hgl/component/RenderComponent.h>
-#include<hgl/graph/Mesh.h>
-
-//#include<hgl/log/LogInfo.h>
-
-COMPONENT_NAMESPACE_BEGIN
-
-class MeshComponent;
-class MeshComponentManager;
-
-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();
-
-    COMPONENT_DATA_CLASS_BODY(Mesh)
-};//struct MeshComponentData
-
-class MeshComponentManager:public ComponentManager
-{
-public:
-
-    COMPONENT_MANAGER_CLASS_BODY(Mesh)
-
-public:
-
-    MeshComponentManager()=default;
-
-    Component *CreateComponent(ComponentDataPtr cdp) override;
-
-    Component *CreateComponent(Mesh *);
-};//class MeshComponentManager
-
-class MeshComponent:public RenderComponent
-{
-    WeakPtr<ComponentData> sm_data;
-    MaterialInstance* override_material = nullptr; // 新增
-
-public:
-
-    COMPONENT_CLASS_BODY(Mesh)
-
-public:
-
-    MeshComponent(ComponentDataPtr cdp,MeshComponentManager *cm):RenderComponent(cdp,cm)
-    {
-        sm_data=cdp;
-    }
-
-    virtual ~MeshComponent()=default;
-
-    virtual Component *Duplication() override
-    {
-        MeshComponent *mc=(MeshComponent *)RenderComponent::Duplication();
-
-        if(!mc)
-            return(mc);
-
-        mc->override_material=override_material;
-        return mc;
-    }
-
-            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;
-    }
-
-    const bool GetLocalAABB(AABB &box) const override
-    {
-        Mesh *mesh=GetMesh();
-
-        if (!mesh)
-            return false;
-
-        box=mesh->GetBoundingBox();
-        return true;
-    }
-
-public:
-
-    Pipeline *GetPipeline() const
-    {
-        Mesh *mesh=GetMesh();
-
-        if (!mesh)
-            return nullptr;
-
-        return mesh->GetPipeline();
-    }
-
-    void                SetOverrideMaterial     (MaterialInstance* mi){override_material=mi;}
-    MaterialInstance *  GetOverrideMaterial     ()const{return override_material;}
-    void                ClearOverrideMaterial   (){override_material=nullptr;}
-
-    MaterialInstance *  GetMaterialInstance     () const
-    {
-        if (override_material)
-            return override_material;
-
-        Mesh *mesh=GetMesh();
-
-        if (!mesh)
-            return nullptr;
-
-        return mesh->GetMaterialInstance();
-    }
-
-    Material *GetMaterial() const
-    {
-        if (override_material)
-            return override_material->GetMaterial();
-
-        Mesh *mesh=GetMesh();
-
-        if (!mesh)
-            return nullptr;
-
-        return mesh->GetMaterial();
-    }
-
-    const bool CanRender() const override
-    {
-        if (!sm_data.valid())
-            return false;
-
-        const MeshComponentData *mcd=GetData();
-
-        if (!mcd || !mcd->mesh)
-            return false;
-
-        return true;
-    }
-};//class MeshComponent
-
-COMPONENT_NAMESPACE_END

inc/hgl/component/PrimitiveComponent.h

@@ -1,64 +0,0 @@
-#pragma once
-
-#include<hgl/component/SceneComponent.h>
-#include<hgl/graph/AABB.h>
-#include<hgl/graph/OBB.h>
-
-COMPONENT_NAMESPACE_BEGIN
-
-/**
-* 图元组件<br>
-* 组件中的元素必须是一个可以明确描述的几何体，可以被明确标记尺寸、参与空间、物理计算等。
-*/
-class PrimitiveComponent:public SceneComponent
-{
-public:
-
-    using SceneComponent::SceneComponent;
-
-    virtual ~PrimitiveComponent()=default;
-
-    virtual const bool GetLocalAABB(AABB &box) const=0;
-
-    const bool GetWorldOBB(OBB &box)
-    {
-        AABB aabb;
-
-        if(!GetLocalAABB(aabb))
-            return false;
-
-        box.Set(GetLocalToWorldMatrix(),aabb);
-
-        return true;
-    }
-
-    const bool GetWorldOBBMatrix(Matrix4f &obb_matrix,const float cube_size=1.0f)
-    {
-        AABB aabb;
-
-        if(!GetLocalAABB(aabb))
-            return false;
-
-        //这两行也是对的
-        //OBB obb(GetLocalToWorldMatrix(),aabb);
-        //obb_matrix=obb.GetMatrix(cube_size);
-
-        // 1. 计算最终的缩放向量
-        const Vector3f scale_vector = aabb.GetLength() * cube_size;
-
-        // 2. 直接构建局部空间的变换矩阵 (Translate * Scale)
-        Matrix4f local_aabb_matrix;
-
-        local_aabb_matrix[0] = Vector4f(scale_vector.x, 0.0f, 0.0f, 0.0f);
-        local_aabb_matrix[1] = Vector4f(0.0f, scale_vector.y, 0.0f, 0.0f);
-        local_aabb_matrix[2] = Vector4f(0.0f, 0.0f, scale_vector.z, 0.0f);
-        local_aabb_matrix[3] = Vector4f(aabb.GetCenter(), 1.0f);
-
-        // 3. 将局部 AABB 矩阵与组件的 LocalToWorld 矩阵相乘，得到最终的世界 OBB 矩阵
-        obb_matrix = GetLocalToWorldMatrix() * local_aabb_matrix;
-
-        return(true);
-    }
-};//class PrimitiveComponent
-
-COMPONENT_NAMESPACE_END

inc/hgl/component/RenderComponent.h

@@ -1,20 +0,0 @@
-#pragma once
-
-#include<hgl/component/PrimitiveComponent.h>
-
-COMPONENT_NAMESPACE_BEGIN
-
-/**
-* 可渲染组件
-*/
-class RenderComponent:public PrimitiveComponent
-{
-public:
-
-    using PrimitiveComponent::PrimitiveComponent;
-    virtual ~RenderComponent()=default;
-
-    virtual const bool CanRender()const=0;                  ///<当前数据是否可以渲染
-};//class RenderComponent
-
-COMPONENT_NAMESPACE_END

inc/hgl/component/SceneComponent.h

@@ -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

inc/hgl/db/FieldType.h

@@ -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
 {

inc/hgl/graph/BlendMode.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include<hgl/graph/VKNamespace.h>
+#include<hgl/TypeFunc.h>
+
+VK_NAMESPACE_BEGIN
+
+enum class BlendMode
+{
+    Opaque,
+    Mask,
+    Transparent,        ///<普通的Alpha混合透明
+    PreMulti,           ///<预乘的Alpha混合透明
+    Add,                ///<加法混合
+    Subtract,           ///<减法混合
+    ReverseSubtract,    ///<反减混合
+    Min,                ///<最小混合
+    Max,                ///<最大混合
+
+    ENUM_CLASS_RANGE(Opaque,Max)
+};
+
+VK_NAMESPACE_END

inc/hgl/graph/Component.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include<hgl/type/TypeInfo.h>
+#include<hgl/graph/VK.h>
+
+VK_NAMESPACE_BEGIN
+
+class SceneNode;
+
+class ComponentData
+{
+};//class ComponentData
+
+class ComponentManager;
+
+class Component
+{
+    ComponentData *data;
+
+    SceneNode *owner_node;
+
+    ComponentManager *manager;
+
+public:
+
+    virtual const size_t GetTypeHash()=0;                                       ///<取得当前组件类型
+
+    SceneNode *GetOwnerNode()const{return owner_node;}                          ///<取得当前组件所属节点
+
+    ComponentManager *GetManager()const{return manager;}                        ///<取得当前组件所属管理器
+
+public:
+
+    Component()
+    {
+        data=nullptr;
+        owner_node=nullptr;
+        manager=nullptr;
+    }
+    Component(SceneNode *sn,ComponentData *cd,ComponentManager *cm);
+    virtual ~Component()=default;
+
+    virtual void Update(const double delta_time){};                             ///<更新组件
+};//class Component
+
+class ComponentManager
+{
+    ObjectList<Component> component_list;
+
+public:
+
+    virtual void Update(const double delta_time)
+    {
+        for(Component *c:component_list)
+        {
+            c->Update(delta_time);
+        }
+    }
+};//class ComponentManager
+
+VK_NAMESPACE_END

inc/hgl/graph/CoordinateSystem.h

@@ -1,28 +1,17 @@
 #pragma once
 
 #include<hgl/TypeFunc.h>
-namespace hgl::graph
+namespace hgl
 {
-    enum class CoordinateSystem2D
+    namespace graph
     {
-        NDC,
-        ZeroToOne,          //左上角为0,0；右下角为1,1
-        Ortho,              //左上角为0,0；右下角为(width-1),(height-1)
+        enum class CoordinateSystem2D
+        {
+            NDC,
+            ZeroToOne,          //左上角为0,0；右下角为1,1
+            Ortho,              //左上角为0,0；右下角为(width-1),(height-1)
 
-        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
+            ENUM_CLASS_RANGE(NDC,Ortho)
+        };
+    }//namespace graph
+}//namespace hgl

inc/hgl/graph/InlineGeometry.h

@@ -1,4 +1,5 @@
-#pragma once
+#ifndef HGL_GRAPH_INLINE_GEOMETRY_INCLUDE
+#define HGL_GRAPH_INLINE_GEOMETRY_INCLUDE
 
 #include<hgl/graph/VK.h>
 #include<hgl/math/Vector.h>
@@ -6,232 +7,235 @@
 #include<hgl/type/Size2.h>
 #include<hgl/color/Color4f.h>
 #include<hgl/graph/AABB.h>
-
-namespace hgl::graph
+namespace hgl
 {
-    class PrimitiveCreater;
-
-    namespace inline_geometry
+    namespace graph
     {
-        /**
-            * 矩形创建信息(扇形/三角形条)
-            */
-        struct RectangleCreateInfo
+        class PrimitiveCreater;
+
+        namespace inline_geometry
         {
-            RectScope2f scope;
-        };//struct RectangleCreateInfo
+            /**
+             * 矩形创建信息(扇形/三角形条)
+             */
+            struct RectangleCreateInfo
+            {
+                RectScope2f scope;
+            };//struct RectangleCreateInfo
 
-        Primitive *CreateRectangle(PrimitiveCreater *pc,const RectangleCreateInfo *rci);
+            Primitive *CreateRectangle(PrimitiveCreater *pc,const RectangleCreateInfo *rci);
 
-        /**
-            * 创建延迟渲染用全屏平面
-            */
-        Primitive *CreateGBufferCompositionRectangle(PrimitiveCreater *pc);
+            /**
+             * 创建延迟渲染用全屏平面
+             */
+            Primitive *CreateGBufferCompositionRectangle(PrimitiveCreater *pc);
 
-        /**
-            * 圆角矩形创建信息(扇形/线圈)
-            */
-        struct RoundRectangleCreateInfo:public RectangleCreateInfo
-        {
-            float radius;           ///<圆角半径
-            uint32_t round_per;     ///<圆角精度
-        };//struct RoundRectangleCreateInfo:public RectangleCreateInfo
+            /**
+             * 圆角矩形创建信息(扇形/线圈)
+             */
+            struct RoundRectangleCreateInfo:public RectangleCreateInfo
+            {
+                float radius;           ///<圆角半径
+                uint32_t round_per;     ///<圆角精度
+            };//struct RoundRectangleCreateInfo:public RectangleCreateInfo
 
-        Primitive *CreateRoundRectangle(PrimitiveCreater *pc,const RoundRectangleCreateInfo *rci);
+            Primitive *CreateRoundRectangle(PrimitiveCreater *pc,const RoundRectangleCreateInfo *rci);
 
-        /**
-            * 圆形创建信息
-            */
-        struct CircleCreateInfo
-        {
-            Vector2f center;            ///<圆心坐标
-            Vector2f radius;            ///<半径
-            uint field_count=8;         ///<分段数量
+            /**
+             * 圆形创建信息
+             */
+            struct CircleCreateInfo
+            {
+                Vector2f center;            ///<圆心坐标
+                Vector2f radius;            ///<半径
+                uint field_count=8;         ///<分段数量
 
-            bool has_center;            ///<是否有圆心点
+                bool has_center;            ///<是否有圆心点
 
-            Vector4f center_color;      ///<圆心颜色
-            Vector4f border_color;      ///<边缘颜色
-        };//struct CircleCreateInfo
+                Vector4f center_color;      ///<圆心颜色
+                Vector4f border_color;      ///<边缘颜色
+            };//struct CircleCreateInfo
 
-        /**
-            * 创建一个2D圆形(扇形/线圈)
-            */
-        Primitive *CreateCircle2D(PrimitiveCreater *pc,const CircleCreateInfo *cci);
+            /**
+             * 创建一个2D圆形(扇形/线圈)
+             */
+            Primitive *CreateCircle2D(PrimitiveCreater *pc,const CircleCreateInfo *cci);
             
-        /**
-            * 创建一个3D圆形(扇形/圆形，XY，Z永远为0)
-            */
-        Primitive *CreateCircle3D(PrimitiveCreater *pc,const CircleCreateInfo *cci);
+            /**
+             * 创建一个3D圆形(扇形/圆形，XY，Z永远为0)
+             */
+            Primitive *CreateCircle3D(PrimitiveCreater *pc,const CircleCreateInfo *cci);
 
-        /**
-            * 创建一个使用三角形绘制的3D圆形(扇形/圆形，XY，Z永远为0)
-            */
-        Primitive *CreateCircle3DByIndexTriangles(PrimitiveCreater *pc,const CircleCreateInfo *cci);
+            /**
+             * 创建一个使用三角形绘制的3D圆形(扇形/圆形，XY，Z永远为0)
+             */
+            Primitive *CreateCircle3DByIndexTriangles(PrimitiveCreater *pc,const CircleCreateInfo *cci);
 
-        /**
-            * 平面网格创建信息<br>
-            * 会创建一个在XY平面上居中的网格，单个格子尺寸为1。
-            */
-        struct PlaneGridCreateInfo
-        {
-            Size2u grid_size;       ///<格子数量
-
-            Size2u sub_count;       ///<细分格子数量
-
-            uint8 lum;              ///<一般线条亮度
-            uint8 sub_lum;          ///<细分及边界线条亮度
-        };//struct PlaneGridCreateInfo
-
-        /**
-            * 创建一个平面网格(线条)
-            */
-        Primitive *CreatePlaneGrid2D(PrimitiveCreater *pc,const PlaneGridCreateInfo *pgci);            //创建一个平面网格(线条)
-
-        Primitive *CreatePlaneGrid3D(PrimitiveCreater *pc,const PlaneGridCreateInfo *pgci);
-
-        /**
-            * 创建一个平面正方形(三角形)
-            */
-        Primitive *CreatePlaneSqaure(PrimitiveCreater *pc);
-
-        struct CubeCreateInfo
-        {
-            bool normal;
-            bool tangent;
-            bool tex_coord;
-
-            enum class ColorType
+            /**
+             * 平面网格创建信息<br>
+             * 会创建一个在XY平面上居中的网格，单个格子尺寸为1。
+             */
+            struct PlaneGridCreateInfo
             {
-                NoColor=0,      ///<没有颜色
-                SameColor,      ///<一个颜色
-                FaceColor,      ///<每个面一个颜色(请写入6个颜色值)
-                VertexColor,    ///<每个顶点一个颜色(请写入24个颜色值)
+                Size2u grid_size;       ///<格子数量
 
-                ENUM_CLASS_RANGE(NoColor,VertexColor)
-            };
+                Size2u sub_count;       ///<细分格子数量
 
-            ColorType color_type;
-            Vector4f color[24];
+                uint8 lum;              ///<一般线条亮度
+                uint8 sub_lum;          ///<细分及边界线条亮度
+            };//struct PlaneGridCreateInfo
 
-        public:
+            /**
+             * 创建一个平面网格(线条)
+             */
+            Primitive *CreatePlaneGrid2D(PrimitiveCreater *pc,const PlaneGridCreateInfo *pgci);            //创建一个平面网格(线条)
 
-            CubeCreateInfo()
+            Primitive *CreatePlaneGrid3D(PrimitiveCreater *pc,const PlaneGridCreateInfo *pgci);
+
+            /**
+             * 创建一个平面正方形(三角形)
+             */
+            Primitive *CreatePlaneSqaure(PrimitiveCreater *pc);
+
+            struct CubeCreateInfo
             {
-                normal=false;
-                tangent=false;
-                tex_coord=false;
+                bool normal;
+                bool tangent;
+                bool tex_coord;
 
-                color_type=ColorType::NoColor;
-            }
-        };//struct CubeCreateInfo
+                enum class ColorType
+                {
+                    NoColor=0,      ///<没有颜色
+                    SameColor,      ///<一个颜色
+                    FaceColor,      ///<每个面一个颜色(请写入6个颜色值)
+                    VertexColor,    ///<每个顶点一个颜色(请写入24个颜色值)
 
-        /**
-            * 创建一个立方体(三角形)
-            */
-        Primitive *CreateCube(PrimitiveCreater *pc,const CubeCreateInfo *cci);
+                    ENUM_CLASS_RANGE(NoColor,VertexColor)
+                };
 
-        struct BoundingBoxCreateInfo
-        {
-            bool normal;
+                ColorType color_type;
+                Vector4f color[24];
 
-            enum class ColorType
+            public:
+
+                CubeCreateInfo()
+                {
+                    normal=false;
+                    tangent=false;
+                    tex_coord=false;
+
+                    color_type=ColorType::NoColor;
+                }
+            };//struct CubeCreateInfo
+
+            /**
+             * 创建一个立方体(三角形)
+             */
+            Primitive *CreateCube(PrimitiveCreater *pc,const CubeCreateInfo *cci);
+
+            struct BoundingBoxCreateInfo
             {
-                NoColor=0,      ///<没有颜色
-                SameColor,      ///<一个颜色
-                VertexColor,    ///<每个顶点一个颜色(请写入8个颜色值)
+                bool normal;
 
-                ENUM_CLASS_RANGE(NoColor,VertexColor)
-            };
+                enum class ColorType
+                {
+                    NoColor=0,      ///<没有颜色
+                    SameColor,      ///<一个颜色
+                    VertexColor,    ///<每个顶点一个颜色(请写入8个颜色值)
 
-            ColorType color_type;
-            Vector4f color[8];
+                    ENUM_CLASS_RANGE(NoColor,VertexColor)
+                };
 
-        public:
+                ColorType color_type;
+                Vector4f color[8];
 
-            BoundingBoxCreateInfo(bool n=false,ColorType ct=ColorType::NoColor)
+            public:
+
+                BoundingBoxCreateInfo()
+                {
+                    normal=false;
+
+                    color_type=ColorType::NoColor;
+                }
+            };//struct BoundingBoxCreateInfo
+
+            /**
+             *  创建一个绑定盒(线条)
+             */
+            Primitive *CreateBoundingBox(PrimitiveCreater *pc,const BoundingBoxCreateInfo *cci);
+
+            /**
+             * 创建一个球心坐标为0,0,0，半径为1的球体(三角形)
+             */
+            Primitive *CreateSphere(PrimitiveCreater *,const uint numberSlices);
+
+            /**
+             * 创建一个穹顶(三角形)
+             */
+            Primitive *CreateDome(PrimitiveCreater *pc, const uint numberSlices);
+
+            struct TorusCreateInfo
             {
-                normal=n;
+                float   innerRadius,
+                        outerRadius;
 
-                color_type=ct;
-            }
-        };//struct BoundingBoxCreateInfo
+                uint    numberSlices,
+                        numberStacks;
 
-        /**
-            *  创建一个绑定盒(线条)
-            */
-        Primitive *CreateBoundingBox(PrimitiveCreater *pc,const BoundingBoxCreateInfo *cci);
+                Vector2f uv_scale={1.0,1.0};
+            };//struct TorusCreateInfo
 
-        /**
-            * 创建一个球心坐标为0,0,0，半径为1的球体(三角形)
-            */
-        Primitive *CreateSphere(PrimitiveCreater *,const uint numberSlices);
+            /**
+             * 创建一个圆环(三角形)
+             */
+            Primitive *CreateTorus(PrimitiveCreater *pc,const TorusCreateInfo *tci);
 
-        /**
-            * 创建一个穹顶(三角形)
-            */
-        Primitive *CreateDome(PrimitiveCreater *pc, const uint numberSlices);
-
-        struct TorusCreateInfo
-        {
-            float   innerRadius,
-                    outerRadius;
-
-            uint    numberSlices,
-                    numberStacks;
-
-            Vector2f uv_scale={1.0,1.0};
-        };//struct TorusCreateInfo
-
-        /**
-            * 创建一个圆环(三角形)
-            */
-        Primitive *CreateTorus(PrimitiveCreater *pc,const TorusCreateInfo *tci);
-
-        struct CylinderCreateInfo
-        {
-            float   halfExtend,     //高度
-                    radius;         //半径
-            uint    numberSlices;
-        };//struct CylinderCreateInfo
-
-        /**
-            * 创建一个圆柱(三角形)
-            */
-        Primitive *CreateCylinder(PrimitiveCreater *,const CylinderCreateInfo *cci);
-
-        struct ConeCreateInfo
-        {
-            float   halfExtend,     //高度
-                    radius;         //半径
-            uint    numberSlices,   //圆切分精度
-                    numberStacks;   //柱高层数
-        };//struct ConeCreateInfo
-
-        /**
-            * 创建一个圆锥(三角形)
-            */
-        Primitive *CreateCone(PrimitiveCreater *,const ConeCreateInfo *cci);
-
-        struct AxisCreateInfo
-        {
-            float size;
-            Color4f color[3];
-
-        public:
-
-            AxisCreateInfo()
+            struct CylinderCreateInfo
             {
-                size=1.0f;
-                color[0].Set(1,0,0,1);
-                color[1].Set(0,1,0,1);
-                color[2].Set(0,0,1,1);
-            }
-        };//struct AxisCreateInfo
+                float   halfExtend,     //高度
+                        radius;         //半径
+                uint    numberSlices;
+            };//struct CylinderCreateInfo
 
-        /**
-            * 创建一个坐标线(线条)
-            */
-        Primitive *CreateAxis(PrimitiveCreater *pc,const AxisCreateInfo *aci);
-    }//namespace inline_geometry
-}//namespace hgl::graph
+            /**
+             * 创建一个圆柱(三角形)
+             */
+            Primitive *CreateCylinder(PrimitiveCreater *,const CylinderCreateInfo *cci);
+
+            struct ConeCreateInfo
+            {
+                float   halfExtend,     //高度
+                        radius;         //半径
+                uint    numberSlices,   //圆切分精度
+                        numberStacks;   //柱高层数
+            };//struct ConeCreateInfo
+
+            /**
+             * 创建一个圆锥(三角形)
+             */
+            Primitive *CreateCone(PrimitiveCreater *,const ConeCreateInfo *cci);
+
+            struct AxisCreateInfo
+            {
+                float size;
+                Color4f color[3];
+
+            public:
+
+                AxisCreateInfo()
+                {
+                    size=1.0f;
+                    color[0].Set(1,0,0,1);
+                    color[1].Set(0,1,0,1);
+                    color[2].Set(0,0,1,1);
+                }
+            };//struct AxisCreateInfo
+
+            /**
+             * 创建一个坐标线(线条)
+             */
+            Primitive *CreateAxis(PrimitiveCreater *pc,const AxisCreateInfo *aci);
+        }//namespace inline_geometry
+    }//namespace graph
+};//namespace hgl
+#endif//HGL_GRAPH_INLINE_GEOMETRY_INCLUDE

inc/hgl/graph/LightingModel.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include<hgl/graph/VK.h>
+
+VK_NAMESPACE_BEGIN
+
+enum class LightingModel:uint8
+{
+    Unlit,
+
+    Gizmo,          ///<Gizmo专用(Blinnphong的特定版本，内置假的太阳光方向、高光系数等，使其不需要外部UBO传入)
+
+    Blinnphong,     ///<Blinnphong光照模型
+
+    FakePBR,        ///<假PBR(使用Blinnphong+HalfLambert模拟)
+    MicroPBR,       ///<微型PBR(只有BaseColor/Normal/Metallic/Roughness四个基础数据的PBR)
+
+    WebPBR,         ///<Khronos为WebGL提供的PBR
+    FilamentPBR,    ///<Filament引擎所提供的PBR
+    AMDPBR,         ///<AMD Caulrdon框架所提供的PBR
+
+    BlenderPBR,     ///<Blender所提供的PBR
+
+    ENUM_CLASS_RANGE(Unlit,BlenderPBR)
+};//enum class LightingModel:uint8
+
+constexpr const char *LightingModelName[]=
+{
+    "Unlit",
+
+    "Gizmo",
+
+    "Blinnphong",
+
+    "FakePBR",
+    "MicroPBR",
+
+    "WebPBR",
+    "FilamentPBR",
+    "AMDPBR",
+
+    "BlenderPBR"
+};
+
+/**
+* 天光来源
+*/
+enum class SkyLightSource:uint8
+{
+    PureColor,          ///<纯色
+    GradientColor,      ///<过渡色
+    Cubemap,            ///<立方体贴图
+    IBL,                ///<IBL立方体贴图
+
+    ENUM_CLASS_RANGE(PureColor,IBL)
+};//enum class SkyLightSource:uint8
+
+/**
+ * 环境光来源
+ */
+enum class AmbientLightSource:uint8
+{
+    PureColor,          ///<纯色
+
+    Distance,           ///<距离(用于显示深邃场景，比如峡谷、深井、管道，越远越黑。理论等同AO)
+
+    LightProbe,         ///<光线探针(也许也是Cubemap，也许不是)
+
+    Cubemap,            ///<本地Cubemap
+
+};//enum class AmbientLightSource:uint8
+
+VK_NAMESPACE_END

inc/hgl/graph/MaterialRenderList.h

@@ -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

inc/hgl/graph/PrimitiveCreater.h

@@ -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();
 

inc/hgl/graph/RenderBufferName.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include<hgl/graph/VK.h>
+
+VK_NAMESPACE_BEGIN
+
+const RENDER_BUFFER_NAME RenderBuffer_Swapchain     ="Swapchain";
+
+const RENDER_BUFFER_NAME RenderBuffer_Depth         ="Depth";
+const RENDER_BUFFER_NAME RenderBuffer_Stencil       ="Stencil";
+
+const RENDER_BUFFER_NAME VBuffer_MeshID             ="VB_MeshID";               ///< 所绘制的Mesh编号, RGBA8UI格式
+const RENDER_BUFFER_NAME VBuffer_TriangleID         ="VB_TriangleID";           ///< 三角形编号, R8UI格式
+const RENDER_BUFFER_NAME VBuffer_MaterialID         ="VB_MaterialID";           ///< 材质ID与材质实例ID, RG8UI格式
+
+const RENDER_BUFFER_NAME GBuffer_BaseColor          ="GB_BaseColor";            ///<基础颜色(RGB565/RGB5A1/RGBA8/RGB10A2/RG11B10,RGBA16F)
+const RENDER_BUFFER_NAME GBuffer_Luminance          ="GB_Luminance";            ///<亮度(R8/R16F/R32F)
+const RENDER_BUFFER_NAME GBuffer_CbCr               ="GB_CbCr";                 ///<色度(RG8/RG16F)
+
+const RENDER_BUFFER_NAME GBuffer_Normal             ="GB_Normal";               ///<法线(RG8,RG16F)
+const RENDER_BUFFER_NAME GBuffer_BentNormal         ="GB_BentNormal";           ///<弯曲法线(RG8,RG16F)
+
+const RENDER_BUFFER_NAME GBuffer_Metallic           ="GB_Metallic";             ///<金属度(R8/R16F/R32F)
+const RENDER_BUFFER_NAME GBuffer_Roughness          ="GB_Roughness";            ///<粗糙度(R8/R16F/R32F)
+const RENDER_BUFFER_NAME GBuffer_Specular           ="GB_Specular";             ///<高光(R8/R16F/R32F)
+const RENDER_BUFFER_NAME GBuffer_Glossiness         ="GB_Glossiness";           ///<光泽度(R8/R16F/R32F)
+
+const RENDER_BUFFER_NAME GBuffer_Reflection         ="GB_Reflection";           ///<反射(R8)
+const RENDER_BUFFER_NAME GBuffer_Refraction         ="GB_Refraction";           ///<折射(R8)
+
+const RENDER_BUFFER_NAME GBuffer_ClearCoat          ="GB_ClearCoat";            ///<透明涂层(R8/R16F/R32F)
+const RENDER_BUFFER_NAME GBuffer_ClearCoatRoughness ="GB_ClearCoatRoughness";   ///<透明涂层粗糙度(R8/R16F/R32F)
+const RENDER_BUFFER_NAME GBuffer_ClearCoatNormal    ="GB_ClearCoatNormal";      ///<透明涂层法线(RG8/RG16F)
+
+const RENDER_BUFFER_NAME GBuffer_IOR                ="GB_IOR";                  ///<折射率(R8/R16F/R32F)
+const RENDER_BUFFER_NAME GBuffer_Tranmission        ="GB_Tranmission";          ///<透射率(R8/R16F/R32F)
+const RENDER_BUFFER_NAME GBuffer_Absorption         ="GB_Absorption";           ///<吸收率(R8/R16F/R32F)
+
+const RENDER_BUFFER_NAME GBuffer_MicroThickness     ="GB_MicroThickness";       ///<微厚度(R8/R16F/R32F)
+
+const RENDER_BUFFER_NAME GBuffer_AmbientOcclusion   ="GB_AmbientOcclusion";     ///<环境光遮蔽(R8/R16F/R32F)
+
+const RENDER_BUFFER_NAME GBuffer_Anisotropy         ="GB_Anisotropy";           ///<各向异性(R8/R16F/R32F)
+const RENDER_BUFFER_NAME GBuffer_AnisotropyDirection="GB_AnisotropyDirection";  ///<各向异性方向(RG8/RG16F/RG32F)
+
+const RENDER_BUFFER_NAME GBuffer_Emissive           ="GB_Emissive";             ///<自发光(RGB565/RGB5A1/RGBA8/RGB10A2/RG11B10,RGBA16F)
+
+const RENDER_BUFFER_NAME GBuffer_SheenColor         ="GB_SheenColor";           ///<光泽颜色(RGB565/RGB5A1/RGBA8/RGB10A2/RG11B10,RGBA16F)
+const RENDER_BUFFER_NAME GBuffer_SheenRoughness     ="GB_SheenRoughness";       ///<光泽粗糙度(R8/R16F/R32F)
+
+const RENDER_BUFFER_NAME GBuffer_SubsurfaceColor    ="GB_SubsurfaceColor";      ///<次表面颜色(RGB565/RGB5A1/RGBA8/RGB10A2/RG11B10,RGBA16F)
+
+const RENDER_BUFFER_NAME GBuffer_ShadingModel       ="GB_ShadingModel";         ///<着色模型(R4UI/R8UI)
+
+const RENDER_BUFFER_NAME GBuffer_LightingChannels   ="GB_LightingChannels";     ///<光照通道(R8UI)
+
+const RENDER_BUFFER_NAME GBuffer_MotionVector       ="GB_MotionVector";         ///<运动矢量(RG16F)
+
+const RENDER_BUFFER_NAME GBuffer_LastScreenPosition ="GB_LastScreenPosition";   ///<上一帧屏幕位置(RG16I)
+
+VK_NAMESPACE_END

inc/hgl/graph/RenderFramework.h

@@ -1,260 +1,145 @@
 #pragma once
 
+#include<hgl/type/List.h>
 #include<hgl/platform/Window.h>
+#include<hgl/graph/BlendMode.h>
+#include<hgl/graph/ViewportInfo.h>
+#include<hgl/graph/module/GraphModuleMap.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>
-#include<hgl/component/CreateComponentInfo.h>
 
 VK_NAMESPACE_BEGIN
 
-class FontSource;
+class GPUDevice;
+class TileData;
 class TileFont;
+class FontSource;
+
+class VulkanInstance;
+
 class RenderPassManager;
 class TextureManager;
-class RenderTargetManager;
 
-class RenderModule;
-
-class Scene;
-class Renderer;
-
-class CameraComponentManager{/*现阶段测试使用*/};
-class LightComponentManager{/*现阶段测试使用*/};
+class SwapchainModule;
 
+/**
+* 渲染框架
+*/
 class RenderFramework:public io::WindowEvent
 {
-    OSString                app_name;
+protected:
 
-    Window *                win                 =nullptr;
-    VulkanInstance *        inst                =nullptr;
+    Window *            win                 =nullptr;
+    VulkanInstance *    inst                =nullptr;
 
-    VulkanDevice *          device              =nullptr;
-
-    RenderResource *        render_resource     =nullptr;
+    GPUDevice *         device              =nullptr;
 
 protected:
 
-    GraphModuleManager *    module_manager      =nullptr;
+    GraphModulesMap graph_module_map;
 
-    RenderPassManager *     rp_manager          =nullptr;
-
-    TextureManager *        tex_manager         =nullptr;
-    RenderTargetManager *   rt_manager          =nullptr;
-
-    SwapchainModule *       sc_module           =nullptr;
+    List<GraphModule *> per_frame_module_list;
+    List<RenderModule *> render_module_list;
 
 protected:
 
-    CameraComponentManager *camera_component_manager=nullptr;
-    LightComponentManager  *light_component_manager =nullptr;
+    SwapchainModule *   swapchain_module    =nullptr;
 
-protected:  //RenderContext,未来合并成一个RenderContext结构
+protected:
 
-    Scene *                 default_scene           =nullptr;
-    Camera *                default_camera          =nullptr;
-    CameraControl *         default_camera_control  =nullptr;
-    Renderer *              default_renderer        =nullptr;
+    RenderPassManager * render_pass_manager =nullptr;
+    TextureManager *    texture_manager     =nullptr;
 
-    void OnChangeDefaultScene(Scene *);
+protected:
 
-    void CreateDefaultRenderer();
+    ViewportInfo        viewport_info;
 
-protected:  //EventDispatcher
+private:
 
-    io::MouseEvent *mouse_event=nullptr;
+    double              last_time           =0;
+    double              cur_time            =0;
+
+    int64               frame_count         =0;
 
 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();}
+    const int64     GetFrameCount       ()const noexcept{return frame_count;}                       ///<取得当前帧数
+    void            RestartFrameCount   ()noexcept{frame_count=0;}                                  ///<重新开始统计帧数
 
-            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::Material *CreateMaterial(const AnsiString &mi_name,const graph::mtl::MaterialCreateInfo *mci)
-    {
-        return render_resource->CreateMaterial(mi_name,mci);
-    }
+public: //module
 
     template<typename T>
-    graph::MaterialInstance *CreateMaterialInstance(graph::Material *mtl,const graph::VILConfig *vil_config=nullptr,const T *data=nullptr)
-    {
-        if(!mtl)
-            return(nullptr);
+    T *             GetModule(){return graph_module_map.Get<T>();}                                  ///<获取指定类型的模块
+    GraphModule *   GetModule(const AIDName &name,bool create=false);                            ///<获取指定名称的模块
 
-        return render_resource->CreateMaterialInstance(mtl,vil_config,data);
-    }
+    //template<typename T> T *AddModule()
+    //{
+    //    T *tm=new T(graph_module_manager);
 
-    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);
-    }
+    //    module_list.Add(tm);
 
-    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);
+    //    if(tm->IsPerFrame())
+    //        per_frame_module_list.Add(tm);
 
-        return render_resource->CreateMaterialInstance(mtl_name,mci,vil_cfg);
-    }
+    //    if(tm->IsRender())
+    //        render_module_list.Add(tm);
 
-    SharedPtr<graph::PrimitiveCreater> GetPrimitiveCreater(graph::Material *mtl)
-    {
-        if(!mtl)
-            return(nullptr);
+    //    return tm;
+    //}
 
-        return(new graph::PrimitiveCreater(GetDevice(),mtl->GetDefaultVIL()));
-    }
+            GPUDevice *         GetDevice           ()      {return device;}
+            VkDevice            GetVkDevice         ()const {return device->GetDevice();}
+    const   GPUPhysicalDevice * GetPhysicalDevice   ()const {return device->GetPhysicalDevice();}   ///<取得物理设备
+            GPUDeviceAttribute *GetDeviceAttribute  ()      {return device->GetDeviceAttribute();}  ///<取得设备属性
+            SwapchainModule *   GetSwapchain        ()      {return swapchain_module;}              ///<取得Swapchain模块
 
-    SharedPtr<graph::PrimitiveCreater> GetPrimitiveCreater(graph::MaterialInstance *mi)
-    {
-        if(!mi)
-            return(nullptr);
+public: //manager
 
-        return(new graph::PrimitiveCreater(GetDevice(),mi->GetVIL()));
-    }
+    RenderPassManager * GetRenderPassManager(){return render_pass_manager;}                         ///<取得渲染通道管理器
+    TextureManager *    GetTextureManager   (){return texture_manager;}                             ///<取得纹理管理器
 
-    graph::VertexDataManager *CreateVDM(const graph::VIL *vil,const VkDeviceSize vertices_number,VkDeviceSize indices_number,const IndexType type=IndexType::U16);
-    graph::VertexDataManager *CreateVDM(const graph::VIL *vil,const VkDeviceSize number,const IndexType type=IndexType::U16){return CreateVDM(vil,number,number,type);}
+public: //event
 
-public: // Primitive, Mesh
+    virtual void OnResize(uint,uint)override;
+    virtual void OnActive(bool)override;
+    virtual void OnClose ()override;
 
-    graph::Primitive *CreatePrimitive(const AnsiString &name,
-                                      const uint32_t vertices_count,
-                                      const graph::VIL *vil,
-                                      const std::initializer_list<graph::VertexAttribDataPtr> &vad_list);
+public:
 
-    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);
+    NO_COPY_NO_MOVE(RenderFramework)
 
-public: // ComponentManager
+private:
+    
+    RenderFramework();
 
-    template<typename T> T *GetComponentManager()
-    {
-        return COMPONENT_NAMESPACE::GetComponentManager<T>(true);
-    }
+    friend RenderFramework *CreateRenderFramework();
 
-    template<> CameraComponentManager *GetComponentManager<CameraComponentManager>()
-    {
-        return camera_component_manager;
-    }
+public:
 
-    template<> LightComponentManager *GetComponentManager<LightComponentManager>()
-    {
-        return light_component_manager;
-    }
+    virtual ~RenderFramework();
 
-public: //Component 相关
+    virtual bool Init(uint w,uint h,const OSString &app_name);                                      ///<初始化
 
-    template<typename C,typename ...ARGS>
-    inline C *CreateComponent(const CreateComponentInfo *cci,ARGS...args)
-    {
-        auto manager=C::GetDefaultManager();  //取得默认管理器
+    virtual void StartTime();
 
-        if(!manager)
-        {
-            //        LOG_ERROR(OS_TEXT("CreateComponent failed, no default manager!"));
-            return(nullptr);
-        }
+    /**
+    * @pragma delta_time 本帧时间间隔
+    */
+    virtual void Update(const double delta_time){}
 
-        C *c=(C *)(manager->CreateComponent(args...)); //创建组件
+    virtual void BeginFrame();                                                                      ///<开始当前帧
+    virtual void EndFrame();                                                                        ///<当前帧结束
 
-        if(!c)
-        {
-            //        LOG_ERROR(OS_TEXT("CreateComponent failed, create component failed!"));
-            return(nullptr);
-        }
+    virtual void MainLoop();                                                                        ///<主循环
 
-        /**
-        * 如果此处出现转换错误，请检查是否包含了对应的Component头文件。
-        */
-        if(cci)
-        {
-            if(cci->owner_node)
-                cci->owner_node->AttachComponent(c); //将组件附加到所属节点
+    virtual void Run();
 
-            c->graph::SceneOrient::SetLocalMatrix(cci->mat);
-        }
+public: //TileData
 
-        return c;
-    }
+    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 RenderFramework
 
+RenderFramework *CreateRenderFramework();
+
 VK_NAMESPACE_END

inc/hgl/graph/RenderList.h

@@ -1,50 +1,49 @@
-#pragma once
+#ifndef HGL_GRAPH_RENDER_LIST_INCLUDE
+#define HGL_GRAPH_RENDER_LIST_INCLUDE
 
 #include<hgl/graph/VK.h>
 #include<hgl/graph/SceneNode.h>
 #include<hgl/graph/MaterialRenderMap.h>
 #include<hgl/graph/VKArrayBuffer.h>
 #include<hgl/graph/VKMaterial.h>
-namespace hgl::graph
+namespace hgl
 {
-    /**
-        * 渲染对象列表<br>
-        * 该类会长期保存使用过的材质信息，避重新分配造成的时间和空间浪费。如需彻底清空列表请使用Clear()函数
-        */
-    class RenderList
+    namespace graph
     {
-    protected:  
+        /**
+         * 渲染对象列表<br>
+         * 该类会长期保存使用过的材质信息，避重新分配造成的时间和空间浪费。如需彻底清空列表请使用Clear()函数
+         */
+        class RenderList
+        {
+        protected:  
 
-        VulkanDevice *      device;
+            GPUDevice *         device;
 
-        CameraInfo *        camera_info;                    ///<相机信息
+            CameraInfo *        camera_info;                    ///<相机信息
 
-        uint                renderable_count;               ///<可渲染对象数量
-        MaterialRenderMap   mrl_map;                        ///<按材质分类的渲染列表
+            uint                renderable_count;               ///<可渲染对象数量
+            MaterialRenderMap   mrl_map;                        ///<按材质分类的渲染列表
 
-    protected:
+        protected:
 
-        virtual bool ExpendNode(SceneNode *);
+            virtual bool ExpendNode(SceneNode *);
 
-    public:
+        public:
 
-        const CameraInfo *GetCameraInfo()const{return camera_info;}
-
-    public:
-
-        RenderList(VulkanDevice *);
-        virtual ~RenderList()=default;
+            RenderList(GPUDevice *);
+            virtual ~RenderList()=default;
             
-        virtual void SetCameraInfo(CameraInfo *ci){camera_info=ci;}             ///<设置相机信息
-        virtual bool Expend(SceneNode *);                                       ///<展开场景树到渲染列表
+            virtual void SetCamera(CameraInfo *ci){camera_info=ci;}                 ///<设置相机信息
+            virtual bool Expend(SceneNode *);                                       ///<展开场景树到渲染列表
 
-                bool IsEmpty()const{return !renderable_count;}                  ///<是否是空的
+            virtual bool Render(RenderCmdBuffer *);                                 ///<渲染所有对象
 
-        virtual bool Render(RenderCmdBuffer *);                                 ///<渲染所有对象
+            virtual void UpdateLocalToWorld();                                      ///<更新所有对象的变换数据
+            virtual void UpdateMaterialInstance(SceneNode *);                       ///<有对象互换了材质实例
 
-        virtual void UpdateLocalToWorld();                                      ///<更新所有对象的变换数据
-        virtual void UpdateMaterialInstance(MeshComponent *);                   ///<有对象互换了材质实例
-
-        virtual void Clear();                                                   ///<彻底清理
-    };//class RenderList
-}//namespace hgl::graph
+            virtual void Clear();                                                   ///<彻底清理
+        };//class RenderList
+    }//namespace graph
+}//namespace hgl
+#endif//HGL_GRAPH_RENDER_LIST_INCLUDE

inc/hgl/graph/RenderNode.h

@@ -1,50 +1,38 @@
-#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中的索引
+            uint        index;                                          ///<在MaterialRenderList中的索引
 
-            MeshComponent * sm_component;                   ///<静态网格组件
+            SceneNode * scene_node;
 
-            uint32          l2w_version;
-            uint32          l2w_index;
+            uint32      l2w_version;
+            uint32      l2w_index;
 
-            Vector3f        world_position;
-            float           to_camera_distance;
-
-            //包围盒
-            //屏幕空间Tile分布
+            Vector3f    world_position;
+            float       to_camera_distance;
 
         public:
 
             //该函数位于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
-
-    template<> inline const int ItemComparator<graph::RenderNode>::compare(const graph::RenderNode &a,const graph::RenderNode &b)
-    {
-        return a.compare(b);
-    }
 }//namespace hgl
+#endif//HGL_GRAPH_RENDER_NODE_INCLUDE

inc/hgl/graph/RenderTask.h

@@ -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

inc/hgl/graph/RenderWorkflow.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include<hgl/graph/BlendMode.h>
+#include<hgl/graph/RenderBufferName.h>
+#include<hgl/type/SortedSet.h>
+
+VK_NAMESPACE_BEGIN
+
+enum class RenderOrder
+{
+    First,          ///<最先渲染
+
+    NearToFar,      ///<从近到远
+    Irrorder,       ///<无序渲染
+    FarToNear,      ///<从远到近
+
+    Last,           ///<最后渲染
+
+    ENUM_CLASS_RANGE(First,Last)
+};//enum class RenderOrder
+
+struct RenderWorkConfig
+{
+    BlendMode blend_mode;
+    RenderOrder render_order;
+
+    SortedSet<RENDER_BUFFER_NAME> output_buffer;
+};//struct RenderWorkConfig;
+
+VK_NAMESPACE_END

inc/hgl/graph/Renderer.h

@@ -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

inc/hgl/graph/Scene.h

@@ -1,71 +0,0 @@
-#pragma once
-
-#include<hgl/graph/SceneNode.h>
-#include<hgl/type/Pool.h>
-#include<hgl/io/event/EventDispatcher.h>
-
-namespace hgl::graph
-{
-    class RenderFramework;
-
-    /**
-    * 场景管理器<Br>
-    * 管理一个场景中的所有资源与场景节点
-    */
-    class Scene
-    {
-        RenderFramework *render_framework=nullptr;      ///<渲染框架
-
-        U8String SceneName;                             ///<场景名称
-
-        ObjectList<SceneNode> SceneNodePool;            ///<场景节点池
-
-        SceneNode *root_node;                           ///<场景根节点
-
-    protected:  // event dispatcher
-
-        io::EventDispatcher event_dispatcher;           ///<事件分发器
-
-    public:
-
-        const   U8String &  GetSceneName()const{return SceneName;}              ///<获取场景名称
-
-                SceneNode * GetRootNode (){return root_node;}                   ///<获取场景根节点
-
-        RenderFramework *   GetRenderFramework()const
-        {
-            return render_framework;
-        }
-
-    public:
-
-        Scene(RenderFramework *rf)
-        {
-            render_framework=rf;
-
-            root_node=new SceneNode(this);
-        }
-
-        virtual ~Scene()
-        {
-            SAFE_CLEAR(root_node);
-        }
-
-        io::EventDispatcher &GetEventDispatcher()  ///<获取事件分发器
-        {
-            return event_dispatcher;
-        }
-    };//class Scene
-
-    bool RegisterScene(Scene *sw);                      ///<注册场景
-    bool UnregisterScene(const U8String &scene_name);   ///<注销场景
-
-    inline bool UnregisterScene(Scene *sw)              ///<注销场景
-    {
-        if(!sw)return(false);
-
-        return UnregisterScene(sw->GetSceneName());
-    }
-
-    Scene *GetScene(const U8String &scene_name);        ///<获取指定名称的场景
-}//namespace hgl::graph

inc/hgl/graph/SceneManager.h

@@ -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

inc/hgl/graph/SceneNode.h

@@ -1,204 +1,114 @@
-#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/graph/OBB.h>
-#include<hgl/component/Component.h>
-
-namespace hgl::io
+namespace hgl
 {
-    class EventDispatcher; // 前向声明事件分发器
-}//
-
-namespace hgl::graph
-{
-    class Scene;        //场景主类
-    //每个SceneNode都要记录Scene来区分自己属于那个场景
-    //这个场景可能是一个确实是一个场景，也有可能只是一个StaticMesh
-
-    class CameraControl;
-
-    using SceneNodeID   =int64;
-
-    using SceneNodeList =ObjectList<SceneNode>;
-
-    HGL_DEFINE_U16_IDNAME(SceneNodeName)
-
-    /**
-    * 场景节点数据类<br>
-    * 从场景坐标变换(SceneOrient)类继承，
-    * 每个场景节点中可能包括一个可渲染数据实例，或是完全不包含(用于坐标变换的父节点，或是灯光/摄像机之类)。
-    */
-    class SceneNode:public SceneOrient                                                                              ///场景节点类
+    namespace graph
     {
-        friend class Scene;
-
-        Scene *main_scene=nullptr;                                                                                  ///<主场景
-
-        SceneNode *parent_node=nullptr;                                                                             ///<上级节点
-
-        SceneNodeID node_id=-1;                                                                                     ///<节点ID
-        SceneNodeName node_name;                                                                                    ///<节点名称
-
-        void OnChangeScene(Scene *);
-
-    protected:
-
-        AABB local_bounding_box;                                                                                    ///<本地坐标绑定盒
-        OBB world_bounding_box;                                                                                     ///<世界坐标绑定盒
-
-    protected:
-
-        SceneNodeList child_nodes;                                                                                  ///<子节点
+        using SceneNodeID   =uint64;
+        using SceneNodeName =U16IDName;
 
         /**
-        * 组件合集，一个SceneNode下可能会包含多个组件，同时一个组件也可能被多个SceneNode使用。
-        * 所以这里只保留一个指针，不拥有组件的生命周期，组件的生命周期由其对应的ComponentManager管理。
+        * 场景节点数据类<br>
+        * 从场景坐标变换(SceneOrient)类继承，
+        * 每个场景节点中可能包括一个可渲染数据实例，或是完全不包含(用于坐标变换的父节点，或是灯光/摄像机之类)。
         */
-        ComponentSet component_set;                                                                                 ///<组件合集
-
-    public:
-
-        Scene *             GetScene()const{ return main_scene; }                                                   ///<取得主场景
-        RenderFramework *   GetRenderFramework()const;                                                              ///<取得渲染框架
-        CameraControl *     GetCameraControl()const;                                                                ///<取得默认摄像机控制器
-
-        const SceneNodeID &     GetNodeID   ()const { return node_id; }                                             ///<取得节点ID
-        const SceneNodeName &   GetNodeName ()const { return node_name; }                                           ///<取得节点名称
-
-        const SceneNodeList &   GetChildNode()const { return child_nodes; }                                         ///<取得子节点列表
-
-    protected:
-
-        SceneNode(const SceneNode &)=delete;
-        SceneNode(const SceneNode *)=delete;
-
-        SceneNode():SceneOrient(){}
-        SceneNode(Scene *s):SceneOrient(),main_scene(s){}                                                           ///<从Scene构造
-        SceneNode(Scene *s,const SceneOrient &so):SceneOrient(so),main_scene(s){}                                   ///<从SceneOrient复制构造
-        SceneNode(Scene *s,const Matrix4f &mat):SceneOrient(mat),main_scene(s){}                                    ///<从Matrix4f复制构造
-
-    public:
-
-        virtual ~SceneNode();
-
-    public:
-
-        virtual SceneNode * CreateNode()const{return(new SceneNode(GetScene()));}                                   ///<创建一个同类的节点对象
-
-        virtual void        DuplicationChildNodes(SceneNode *node) const                                            ///<复制子节点到指定节点
+        class SceneNode:public SceneOrient                                                                              ///场景节点类
         {
-            for(SceneNode *sn:GetChildNode())
-                node->Add(sn->Duplication());
-        }
+            SceneNode *Owner;                                                                                           ///<上级节点
 
-        virtual void        DuplicationComponents(SceneNode *node) const                                            ///<复制组件到指定节点
-        {
-            for(Component *c:GetComponents())
-                node->AttachComponent(c->Duplication());
-        }
+            SceneNodeID NodeID;                                                                                         ///<节点ID
+            SceneNodeName NodeName;                                                                                     ///<节点名称
 
-        virtual SceneNode * Duplication() const                                                                     ///<复制一个场景节点
-        {
-            if(!this)
-                return nullptr;
+        protected:
 
-            SceneNode *node=CreateNode();
+            AABB BoundingBox;                                                                                           ///<绑定盒
+            AABB LocalBoundingBox;                                                                                      ///<本地坐标绑定盒
+            //AABB WorldBoundingBox;                                                                                      ///<世界坐标绑定盒
 
-            node->SetSceneMatrix(GetSceneMatrix());  //复制本地矩阵
+            Renderable *render_obj=nullptr;                                                                             ///<可渲染实例
 
-            DuplicationChildNodes(node);    //复制子节点
-            DuplicationComponents(node);    //复制组件
+        protected:
 
-            return node;
-        }
+            ObjectList<SceneNode> ChildNode;                                                                              ///<子节点
 
-        void Clear() override
-        {
-            SetParent(nullptr); //清除父节点
+        public:
 
-            local_bounding_box.Clear();
-            world_bounding_box.Clear();
+            const SceneNodeID &     GetNodeID   ()const { return NodeID; }                                              ///<取得节点ID
+            const SceneNodeName &   GetNodeName ()const { return NodeName; }                                            ///<取得节点名称
 
-            child_nodes.Clear();
-            component_set.Clear();
+            const ObjectList<SceneNode> &GetChildNode()const { return ChildNode; }                                             ///<取得子节点列表
 
-            SceneOrient::Clear();
-        }
+        public:
 
-        const bool ChildNodeIsEmpty()const
-        {
-            if(child_nodes.GetCount())return(false);
+            SceneNode()=default;
+            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;}
 
-            return(true);
-        }
+        public:
 
-        virtual void        SetParent(SceneNode *sn)
-        {
-            if(parent_node==sn)
-                return; //如果父节点没有变化，则不需要处理
+            virtual ~SceneNode()=default;
 
-            parent_node=sn;
+            void Clear() override
+            {
+                SceneOrient::Clear();
 
-            OnChangeScene(sn?sn->GetScene():nullptr);
-        }
+                Owner=nullptr;
 
-                SceneNode * GetParent()      noexcept{return parent_node;}
-        const   SceneNode * GetParent()const noexcept{return parent_node;}
+                BoundingBox.SetZero();
+                LocalBoundingBox.SetZero();
 
-        SceneNode *Add(SceneNode *sn)
-        {
-            if(!sn)
-                return(nullptr);
+                ChildNode.Clear();
+                render_obj=nullptr;
+            }
 
-            child_nodes.Add(sn);
-            sn->SetParent(this);
-            return sn;
-        }
+            const bool IsEmpty()const
+            {
+                if(render_obj)return(false);
+                if(ChildNode.GetCount())return(false);
 
-    public: //事件相关
+                return(true);
+            }
 
-        virtual io::EventDispatcher *GetEventDispatcher(){return nullptr;}                                          ///<取得事件分发器(如果返回nullptr,则表示该节点不支持事件分发)
+                    void        SetOwner(SceneNode *sn) {Owner=sn;}
+                    SceneNode * GetOwner()      noexcept{return Owner;}
+            const   SceneNode * GetOwner()const noexcept{return Owner;}
 
-    public: //坐标相关方法
+                    void        SetRenderable(Renderable *);
+                    Renderable *GetRenderable()      noexcept{return render_obj;}
+            const   Renderable *GetRenderable()const noexcept{return render_obj;}
 
-        virtual         void        RefreshMatrix       () override;                                                ///<刷新世界变换
-        virtual         void        RefreshBoundingBox  ();                                                         ///<刷新绑定盒
+            SceneNode *Add(SceneNode *sn)
+            {
+                if(!sn)
+                    return(nullptr);
 
-        virtual const   AABB &      GetLocalBoundingBox ()const{return local_bounding_box;}                         ///<取得本地坐标绑定盒
+                ChildNode.Add(sn);
+                sn->SetOwner(this);
+                return sn;
+            }
+
+        public: //坐标相关方法
+
+            virtual         void        SetBoundingBox      (const AABB &bb){BoundingBox=bb;}                           ///<设置绑定盒
+
+            virtual         void        RefreshMatrix       () override;                                                ///<刷新世界变换
+            virtual         void        RefreshBoundingBox  ();                                                         ///<刷新绑定盒
+
+            virtual const   AABB &      GetBoundingBox      ()const{return BoundingBox;}                                ///<取得绑定盒
+            virtual const   AABB &      GetLocalBoundingBox ()const{return LocalBoundingBox;}                           ///<取得本地坐标绑定盒
 //            virtual const   AABB &      GetWorldBoundingBox ()const{return WorldBoundingBox;}                           ///<取得世界坐标绑定盒
+        };//class SceneNode
 
-    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
-}//namespace hgl::graph
+        SceneNode *Duplication(SceneNode *);                                                                            ///<复制一个场景节点
+    }//namespace graph
+}//namespace hgl
+#endif//HGL_GRAPH_SCENE_NODE_INCLUDE

inc/hgl/graph/SceneOrient.h

@@ -1,53 +1,54 @@
-#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
 {
-    /**
-    * 方向定位数据基类<br>
-    */
-    class SceneOrient                                                                                                   ///场景定位类
+    namespace graph
     {
-    protected:
-
-        SceneMatrix scene_matrix;
-
-    public:
-
-        SceneOrient()=default;
-        SceneOrient(const SceneOrient &);
-        SceneOrient(const Matrix4f &);
-        virtual ~SceneOrient()=default;
-
-        virtual void Clear()
+        /**
+        * 方向定位数据基类<br>
+        */
+        class SceneOrient                                                                                                   ///场景定位类
         {
-            scene_matrix.Clear();
-        }
+        protected:
 
-        void SetSceneMatrix (const SceneMatrix &sm){scene_matrix=sm;}                                                       ///<设置场景矩阵
+            SceneMatrix scene_matrix;
 
-        void SetLocalNormal (const Vector3f &nor){scene_matrix.SetLocalNormal(nor);}                                        ///<设置本地法线
-        void SetLocalMatrix (const Matrix4f &mat){scene_matrix.SetLocalMatrix(mat);}                                        ///<设置本地矩阵
-        void SetParentMatrix(const Matrix4f &mat){scene_matrix.SetParentMatrix(mat);}                                       ///<设置上级到世界空间变换矩阵
+        public:
 
-    public:
+            SceneOrient()=default;
+            SceneOrient(const SceneOrient &);
+            SceneOrient(const Matrix4f &);
+            virtual ~SceneOrient()=default;
 
-        const SceneMatrix & GetSceneMatrix                          ()const {return scene_matrix;}                          ///<取得场景矩阵
+            virtual void Clear()
+            {
+                scene_matrix.Clear();
+            }
 
-        const uint32        GetLocalToWorldMatrixVersion            ()const {return scene_matrix.GetNewestVersion();}       ///<取得版本号
+            void SetLocalNormal(const Vector3f &nor) {scene_matrix.SetLocalNormal(nor);}                                        ///<设置本地法线
+            void SetLocalMatrix (const Matrix4f &mat){scene_matrix.SetLocalMatrix(mat);}                                        ///<设置本地矩阵
+            void SetParentMatrix(const Matrix4f &mat){scene_matrix.SetParentMatrix(mat);}                                       ///<设置上级到世界空间变换矩阵
 
-        const Vector3f &    GetWorldPosition                        ()const {return scene_matrix.GetWorldPosition();}       ///<取得世界坐标
-        const Matrix4f &    GetLocalMatrix                          ()const {return scene_matrix.GetLocalMatrix();}         ///<取得本地矩阵
+        public:
 
-        TransformManager &  GetTransform                            ()      {return scene_matrix.GetTransform();}           ///<取得变换管理器
+            const uint32        GetLocalToWorldMatrixVersion()const             {return scene_matrix.GetNewestVersion();}       ///<取得版本号
 
-        const Matrix4f &    GetLocalToWorldMatrix                   ()      {return scene_matrix.GetLocalToWorldMatrix();}  ///<取得本地到世界矩阵
-        const Matrix4f &    GetInverseLocalToWorldMatrix            ()      {return scene_matrix.GetInverseLocalToWorldMatrix();}
-        const Matrix4f &    GetInverseTransposeLocalToWorldMatrix   ()      {return scene_matrix.GetInverseTransposeLocalToWorldMatrix();}
+            const Vector3f &    GetWorldPosition() const                        {return scene_matrix.GetWorldPosition();}       ///<取得世界坐标
+            const Matrix4f &    GetLocalMatrix                          ()const {return scene_matrix.GetLocalMatrix();}         ///<取得本地矩阵
 
-    public:
+            TransformManager &  GetTransform                            ()      {return scene_matrix.GetTransform();}           ///<取得变换管理器
 
-        virtual void RefreshMatrix();
-    };//class SceneOrient
-}//namespace hgl::graph
+            const Matrix4f &    GetLocalToWorldMatrix                   ()      {return scene_matrix.GetLocalToWorldMatrix();}  ///<取得本地到世界矩阵
+            const Matrix4f &    GetInverseLocalToWorldMatrix            ()      {return scene_matrix.GetInverseLocalToWorldMatrix();}
+            const Matrix4f &    GetInverseTransposeLocalToWorldMatrix   ()      {return scene_matrix.GetInverseTransposeLocalToWorldMatrix();}
+
+        public:
+
+            virtual void RefreshMatrix();
+        };//class SceneOrient
+    }//namespace graph
+}//namespace hgl
+#endif//HGL_GRAPH_SCENE_ORIENT_INCLUDE

inc/hgl/graph/StaticRenderManager.h

@@ -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

inc/hgl/graph/TileData.h

@@ -20,7 +20,7 @@ namespace hgl
          */
         class TileData                                                                                                 ///Tile纹理管理
         {
-            TextureManager *tex_manager;
+            TextureManager *texture_manager;
 
         protected:
 
@@ -37,7 +37,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数据
@@ -53,7 +53,7 @@ namespace hgl
             Texture2D *	GetTexture	()const{return tile_texture;}									                    ///<取得贴图
 
         public:
-            
+
             TileData(TextureManager *,Texture2D *,const uint tw,const uint th);
             virtual ~TileData();
 

inc/hgl/graph/VK.h

@@ -1,14 +1,14 @@
 #pragma once
 
-#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>
+#include<hgl/type/IDName.h>
 #include<hgl/graph/VKNamespace.h>
 #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,35 +25,39 @@ 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;
-};
+DefineIDName(TEXTURE_NAME,char)
+DefineIDName(SHADER_NAME,char)
+DefineIDName(RENDER_BUFFER_NAME,char)
+
+class TextureManager;
+
+class GraphModule;
+class RenderModule;
+class GraphModuleManager;
+
+class SwapchainModule;
+
+void RegistryCommonGraphModule();
 
 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;
+class RTSwapchain;
 
 struct CopyBufferToImageInfo;
+struct TextureData;
+struct TextureCreateInfo;
+
+struct Image2DRegion;
 
 class Texture;
 class Texture1D;
@@ -66,15 +70,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,19 +85,18 @@ class IndexBuffer;
 class VABMap;
 class IBMap;
 
-class VulkanCmdBuffer;
+class GPUCmdBuffer;
 class RenderCmdBuffer;
 class TextureCmdBuffer;
 
 class RenderPass;
-class DeviceRenderPassManage;
+class RenderPassManager;
 
 class Fence;
 class Semaphore;
 
 struct PipelineLayoutData;
 class DescriptorSet;
-enum class DescriptorSetType;
 
 struct VertexInputAttribute;
 
@@ -124,7 +124,7 @@ using VIL=VertexInputLayout;
 
 class PrimitiveData;
 class Primitive;
-class Mesh;
+class Renderable;
 
 class VertexDataManager;
 using VDM=VertexDataManager;
@@ -135,16 +135,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 +194,4 @@ inline void copy(VkExtent3D &e3d,const VkExtent2D &e2d,const uint32 depth=1)
     e3d.height  =e2d.height;
     e3d.depth   =depth;
 }
-
 VK_NAMESPACE_END

inc/hgl/graph/VKArrayBuffer.h

@@ -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

inc/hgl/graph/VKBuffer.h

@@ -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

inc/hgl/graph/VKBufferMap.h

@@ -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;

inc/hgl/graph/VKCommandBuffer.h

@@ -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,50 +35,26 @@ 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;
     VkRect2D render_area;
     VkViewport viewport;
    
+    Framebuffer *fbo;
     RenderPassBeginInfo rp_begin;
     VkPipelineLayout pipeline_layout;
 
-    /*
-    * 绝大部分desc绑定会全部使用这些自动绑定器绑定
-    * 该数据在渲染前分别会有各自的模块设置进来
-    * 比如
-    *    DescriptSetType::RenderTarget  即该由RenderTarget模块设置
-    *    DescriptSetType::Scene         的自然由Scene模块设置
-    */
-    DescriptorBindingPtrArray desc_binding{};
-
-private:
-
-    void SetClear();
+    void SetFBO(Framebuffer *);
 
 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;}
@@ -114,7 +78,7 @@ public:
 
     //以上设定在Begin开始后即不可改变
 
-    bool BindFramebuffer(Framebuffer *);
+    bool BindFramebuffer(RenderPass *rp,Framebuffer *fb);
 
     bool BeginRenderPass();
     void NextSubpass(){vkCmdNextSubpass(cmd_buf,VK_SUBPASS_CONTENTS_INLINE);}
@@ -212,7 +176,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 +213,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 +261,6 @@ public:
                                 0, nullptr,
                                 1, &imageMemoryBarrier);
     }
-};//class TextureCmdBuffer:public VulkanCmdBuffer
+};//class TextureCmdBuffer:public GPUCmdBuffer
 VK_NAMESPACE_END
+#endif//HGL_GRAPH_VULKAN_COMMAND_BUFFER_INCLUDE

inc/hgl/graph/VKDebugUtils.h

@@ -3,7 +3,6 @@
 
 #include<hgl/graph/VK.h>
 #include<hgl/color/Color4f.h>
-#include<hgl/graph/VKTexture.h>
 
 VK_NAMESPACE_BEGIN
 struct DebugUtilsFunction
@@ -37,6 +36,7 @@ private:
     }
 
 public:
+
     ~DebugUtils()=default;
 
     void SetName(VkObjectType,uint64_t,const char *);
@@ -77,10 +77,10 @@ public:
     DU_FUNC(DisplayKHR,                 DISPLAY_KHR)
     DU_FUNC(DisplayModeKHR,             DISPLAY_MODE_KHR)
     DU_FUNC(DebugReportCallbackEXT,     DEBUG_REPORT_CALLBACK_EXT)
-#ifdef VK_ENABLE_BETA_EXTENSIONS
+
     DU_FUNC(VideoSessionKHR,            VIDEO_SESSION_KHR)
-    DU_FUNC(VideoSessionParametersKHR,  VIDEO_SESSION_PARAMETERS_KH)
-#endif//VK_ENABLE_BETA_EXTENSIONS
+    DU_FUNC(VideoSessionParametersKHR,  VIDEO_SESSION_PARAMETERS_KHR)
+
     DU_FUNC(CuModuleNVX,                    CU_MODULE_NVX)
     DU_FUNC(CuFunctionNVX,                  CU_FUNCTION_NVX)
     DU_FUNC(DebugUtilsMessengerEXT,         DEBUG_UTILS_MESSENGER_EXT)
@@ -93,13 +93,6 @@ public:
 //    DU_FUNC(BufferCollectionFuchsia,        BUFFER_COLLECTION_FUCHSIA)
 
 #undef DU_FUNC
-
-    void SetTexture(Texture *tex,const AnsiString &info)
-    {   
-        SetImage(       tex->GetImage(),            info+"_Image"       );
-        SetImageView(   tex->GetVulkanImageView(),  info+"_ImageView"   );
-        SetDeviceMemory(tex->GetDeviceMemory(),     info+"_Memory"      );
-    }
     
     void QueueBegin  (VkQueue,const char *,const Color4f &color=Color4f(1,1,1,1));
     void QueueEnd    (VkQueue q){duf.QueueEnd(q);}

inc/hgl/graph/VKDescriptorBindingManage.h

@@ -1,142 +1,112 @@
-#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>
-
-VK_NAMESPACE_BEGIN
-
-class DeviceBuffer;
-class Texture;
-class Material;
-class MaterialParameters;
-
-/**
- * 描述符绑定器<Br>
- * 一般用于注册通用数据，为材质进行自动绑定。
- */
-class DescriptorBinding
+#include<hgl/graph/VK.h>
+#include<hgl/graph/VKDescriptorSetType.h>
+namespace hgl
 {
-    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:
-
-    DescriptorBinding(const DescriptorSetType &dst)
+    namespace graph
     {
-        set_type=dst;
-    }
+        class DeviceBuffer;
+        class Texture;
+        class Material;
+        class MaterialParameters;
 
-    bool AddUBO(const AnsiString &name,DeviceBuffer *buf)
-    {
-        if(!buf)return(false);
-        if(name.IsEmpty())return(false);
+        /**
+         * 描述符绑定器<Br>
+         * 一般用于注册通用数据，为材质进行自动绑定。
+         */
+        class DescriptorBinding
+        {
+            DescriptorSetType set_type;                     ///<描述符合集类型
 
-        return ubo_map.Add(name,buf);
-    }
+            Map<AnsiString,DeviceBuffer *> ubo_map;
+            Map<AnsiString,DeviceBuffer *> ssbo_map;
+            Map<AnsiString,Texture *> texture_map;
 
-    template<typename T>
-    bool AddUBO(const AnsiString &name,DeviceBufferMap<T> *dbm)
-    {
-        if(name.IsEmpty()||!dbm)
-            return(false);
+        public:
 
-        return ubo_map.Add(name,dbm->GetDeviceBuffer());
-    }
+            DescriptorBinding(const DescriptorSetType &dst)
+            {
+                set_type=dst;
+            }
 
-    template<typename T>
-    bool AddUBO(const UBOInstance<T> *ubo_instance)
-    {
-        if(!ubo_instance)
-            return(false);
+            bool AddUBO(const AnsiString &name,DeviceBuffer *buf)
+            {
+                if(!buf)return(false);
+                if(name.IsEmpty())return(false);
 
-        if(ubo_instance->set_type()!=set_type)
-            return(false);
+                return ubo_map.Add(name,buf);
+            }
 
-        if(ubo_instance->name().IsEmpty())
-            return(false);
+            DeviceBuffer *GetUBO(const AnsiString &name)
+            {
+                if(name.IsEmpty())return(nullptr);
 
-        return ubo_map.Add(ubo_instance->name(),ubo_instance->ubo());
-    }
+                return GetObjectFromList(ubo_map,name);
+            }
 
-    DeviceBuffer *GetUBO(const AnsiString &name)
-    {
-        if(name.IsEmpty())return(nullptr);
+            void RemoveUBO(DeviceBuffer *buf)
+            {
+                if(!buf)return;
 
-        return GetObjectFromMap(ubo_map,name);
-    }
+                ubo_map.DeleteByValue(buf);
+            }
 
-    void RemoveUBO(DeviceBuffer *buf)
-    {
-        if(!buf)return;
+            bool AddSSBO(const AnsiString &name,DeviceBuffer *buf)
+            {
+                if(!buf)return(false);
+                if(name.IsEmpty())return(false);
 
-        ubo_map.DeleteByValue(buf);
-    }
+                return ssbo_map.Add(name,buf);
+            }
 
-    bool AddSSBO(const AnsiString &name,DeviceBuffer *buf)
-    {
-        if(!buf)return(false);
-        if(name.IsEmpty())return(false);
+            DeviceBuffer *GetSSBO(const AnsiString &name)
+            {
+                if(name.IsEmpty())return(nullptr);
 
-        return ssbo_map.Add(name,buf);
-    }
+                return GetObjectFromList(ssbo_map,name);
+            }
 
-    template<typename T>
-    bool AddSSBO(const AnsiString &name,DeviceBufferMap<T> *dbm)
-    {
-        return AddSSBO(name,dbm->GetDeviceBuffer());
-    }
+            void RemoveSSBO(DeviceBuffer *buf)
+            {
+                if(!buf)return;
 
-    DeviceBuffer *GetSSBO(const AnsiString &name)
-    {
-        if(name.IsEmpty())return(nullptr);
+                ssbo_map.DeleteByValue(buf);
+            }
 
-        return GetObjectFromMap(ssbo_map,name);
-    }
+            bool AddTexture(const AnsiString &name,Texture *tex)
+            {
+                if(!tex)return(false);
+                if(name.IsEmpty())return(false);
 
-    void RemoveSSBO(DeviceBuffer *buf)
-    {
-        if(!buf)return;
+                return texture_map.Add(name,tex);
+            }
 
-        ssbo_map.DeleteByValue(buf);
-    }
+            Texture *GetTexture(const AnsiString &name)
+            {
+                if(name.IsEmpty())return(nullptr);
 
-    bool AddTexture(const AnsiString &name,Texture *tex)
-    {
-        if(!tex)return(false);
-        if(name.IsEmpty())return(false);
+                return GetObjectFromList(texture_map,name);
+            }
 
-        return texture_map.Add(name,tex);
-    }
+            void RemoveTexture(Texture *tex)
+            {
+                if(!tex)return;
 
-    Texture *GetTexture(const AnsiString &name)
-    {
-        if(name.IsEmpty())return(nullptr);
+                texture_map.DeleteByValue(tex);
+            }
 
-        return GetObjectFromMap(texture_map,name);
-    }
+        private:
 
-    void RemoveTexture(Texture *tex)
-    {
-        if(!tex)return;
+            void BindUBO(MaterialParameters *,const BindingMap &,bool dynamic);
 
-        texture_map.DeleteByValue(tex);
-    }
+        public:
 
-private:
-
-    void BindUBO(MaterialParameters *,const BindingMap &,bool dynamic);
-
-public:
-
-    bool Bind(Material *);
-};//class DescriptorBinding
-
-VK_NAMESPACE_END
+            bool Bind(Material *);
+        };//class DescriptorBinding
+    }//namespace graph
+}//namespace hgl
+#endif//HGL_GRAPH_DESCRIPTOR_BINDING_MANAGE_INCLUDE

inc/hgl/graph/VKDescriptorSet.h

@@ -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;
 

inc/hgl/graph/VKDevice.h

@@ -1,10 +1,9 @@
-#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>
-#include<hgl/graph/ImageRegion.h>
 #include<hgl/platform/Window.h>
 #include<hgl/graph/BitmapData.h>
 #include<hgl/graph/font/Font.h>
@@ -17,19 +16,24 @@
 #include<hgl/graph/VKDescriptorSetType.h>
 
 VK_NAMESPACE_BEGIN
+
+class SwapchainModule;
+
 class TileData;
 class TileFont;
 class FontSource;
-class VulkanArrayBuffer;
+class GPUArrayBuffer;
 class IndirectDrawBuffer;
 class IndirectDrawIndexedBuffer;
 class IndirectDispatchBuffer;
 
 struct CopyBufferToImageInfo;
 
-class VulkanDevice
+class GPUDevice
 {
-    VulkanDevAttr *attr;
+private:
+
+    GPUDeviceAttribute *attr;
 
 private:
 
@@ -39,18 +43,18 @@ 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;}
@@ -60,20 +64,8 @@ public:
                 VkQueue             GetGraphicsQueue    ()      {return attr->graphics_queue;}
 
                 void                WaitIdle            ()const {vkDeviceWaitIdle(attr->device);}
-                
-#ifdef _DEBUG
+
                 DebugUtils *        GetDebugUtils       (){return attr->debug_utils;}
-#endif//_DEBUG
-
-public:
-
-                bool                Resize              (const VkExtent2D &);
-                bool                Resize              (const uint32_t &w,const uint32_t &h)
-                {
-                    VkExtent2D extent={w,h};
-
-                    return Resize(extent);
-                }
 
 public: //内存相关
 
@@ -96,7 +88,6 @@ public: //Buffer相关
     VAB *           CreateVAB   (VkFormat format, uint32_t count,const void *data,    SharingMode sm=SharingMode::Exclusive);
     VAB *           CreateVAB   (VkFormat format, uint32_t count,                     SharingMode sm=SharingMode::Exclusive){return CreateVAB(format,count,nullptr,sm);}
 
-    const bool      IsSupport       (const IndexType &type)const; ///<检测是否支持某种索引类型
     const IndexType ChooseIndexType (const VkDeviceSize &vertex_count)const;                    ///<求一个合适的索引类型
     const bool      CheckIndexType  (const IndexType,const VkDeviceSize &vertex_count)const;    ///<检测一个索引类型是否合适
 
@@ -118,25 +109,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)
@@ -144,8 +117,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: //间接绘制
 
@@ -175,15 +148,12 @@ 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:
-
-    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

inc/hgl/graph/VKDeviceAttribute.h

@@ -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;
 
@@ -24,21 +24,21 @@ struct VulkanDevAttr
     uint32_t                            graphics_family     =ERROR_FAMILY_INDEX;
     uint32_t                            present_family      =ERROR_FAMILY_INDEX;
     uint32_t                            compute_family      =ERROR_FAMILY_INDEX;
+    uint32_t                            transfer_family     =ERROR_FAMILY_INDEX;
     uint32_t                            video_decode_family =ERROR_FAMILY_INDEX;
-
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     uint32_t                            video_encode_family =ERROR_FAMILY_INDEX;
-#endif//VK_ENABLE_BETA_EXTENSIONS
 
     VkQueue                             graphics_queue  =VK_NULL_HANDLE;
     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;
 
+    bool                                blendOpAdvance  =false;
+
     bool                                uint8_index_type=false;
     bool                                uint32_index_type=false;
 
@@ -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

inc/hgl/graph/VKDeviceCreater.h

@@ -98,6 +98,8 @@ struct VulkanHardwareRequirement
 
     uint32_t descriptor_pool;                  ///<描述符池大小(默认1024)
 
+    SupportLevel blendOperationAdvanced;       ///<要求支持高级混合
+
 public:
 
     VulkanHardwareRequirement()
@@ -110,6 +112,10 @@ public:
 
         fullDrawIndexUint8=SupportLevel::Want;
         fullDrawIndexUint32=SupportLevel::Want;
+
+        blendOperationAdvanced=SupportLevel::Want;
+
+        wideLines=SupportLevel::Want;
     }
 };
 
@@ -159,7 +165,7 @@ constexpr const VkFormat SwapchainPreferFormatsDepth[]=
     PF_D32F_S8U
 };
 
-constexpr const VkColorSpaceKHR SwapchainPreferColorSpacesNonlinear[]=
+constexpr const VkColorSpaceKHR SwapchainPreferredNonlinearColorSpaces[]=
 {
     VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
     VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
@@ -170,7 +176,7 @@ constexpr const VkColorSpaceKHR SwapchainPreferColorSpacesNonlinear[]=
     VK_COLOR_SPACE_DISPLAY_NATIVE_AMD,
 };
 
-constexpr const VkColorSpaceKHR SwapchainPreferColorSpacesLinear[]=
+constexpr const VkColorSpaceKHR SwapchainPreferredLinearColorSpaces[]=
 {
     VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT,
     VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT,
@@ -225,8 +231,8 @@ constexpr const PreferFormats PreferHDR32{SwapchainPreferFormatsHDR32,   sizeof(
 constexpr const PreferFormats PreferHDR  {SwapchainPreferFormatsHDR,     sizeof(SwapchainPreferFormatsHDR    )/sizeof(VkFormat)};
 constexpr const PreferFormats PreferDepth{SwapchainPreferFormatsDepth,   sizeof(SwapchainPreferFormatsDepth  )/sizeof(VkFormat)};
 
-constexpr const PreferColorSpaces PreferNonlinear   {SwapchainPreferColorSpacesNonlinear,   sizeof(SwapchainPreferColorSpacesNonlinear  )/sizeof(VkColorSpaceKHR)};
-constexpr const PreferColorSpaces PreferLinear      {SwapchainPreferColorSpacesLinear,      sizeof(SwapchainPreferColorSpacesLinear     )/sizeof(VkColorSpaceKHR)};
+constexpr const PreferColorSpaces PreferNonlinear   {SwapchainPreferredNonlinearColorSpaces,   sizeof(SwapchainPreferredNonlinearColorSpaces  )/sizeof(VkColorSpaceKHR)};
+constexpr const PreferColorSpaces PreferLinear      {SwapchainPreferredLinearColorSpaces,      sizeof(SwapchainPreferredLinearColorSpaces     )/sizeof(VkColorSpaceKHR)};
 
 /**
 * Vulkan设备创建器<br>
@@ -238,7 +244,7 @@ protected:
 
     VulkanInstance *instance;
     Window *window;
-    const VulkanPhyDevice *physical_device;
+    const GPUPhysicalDevice *physical_device;
 
     VulkanHardwareRequirement require;
 
@@ -274,16 +280,16 @@ 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 VulkanHardwareRequirement *req        =nullptr,
                                         const PreferFormats *       spf_color       =&PreferSDR,
                                         const PreferColorSpaces *   spf_color_space =&PreferNonlinear,
                                         const PreferFormats *       spf_depth       =&PreferDepth)
@@ -293,35 +299,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)
 {