use HGL_MATH_LIB instead of HGL_GLM_LIB

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)
 
 PROJECT(ULRE)
 
@@ -26,7 +26,7 @@ SET(ULRE    CMCore
             ULRE.Util
             ULRE.ShaderGen
             ULRE.SceneGraph
-            ${HGL_GLM_LIB}
+            ${HGL_MATH_LIB}
             ${RENDER_LIBRARY}
             ${Vulkan_LIBRARIES})
 

README.md

@@ -1,25 +1,33 @@
 # ULRE
 experiment project - Ultra Lightweight Rendering Engine
 
-ULRE is a project of experimental nature,Used to experiment with various rendering related techniques,And do some examples.
+ULRE is a project of an experimental nature. Used to experiment with various rendering-related techniques And do some examples.
 
-In the future, its compilicated version will be integrated into CMGameEngine.Used to replace the old rendering engine.
+In the future, its complicated version will be integrated into CMGameEngine.Used to replace the old rendering engine.
 
-Platform: Windows,Linux (WIP: Android,macOS,iOS)
+Platform: Windows, Linux (WIP: Android, macOS, iOS)
 
 Graphics API: Vulkan
 
 Milestone:
 
-    On May 6 of 2023, a test was completed, and the entire scene was drawn with only one DrawCall. Although it still has a lot of unfinished work, it is still a very important milestone.
+    2. Texture2DArray was integrated into material instances. 
+    Multiple render instances of the same model use different material instances and textures but are still merged into one render. 
+    Although the changes this time are small, they are more significant.
+    
+    1. a test was completed, and the entire scene was drawn with only one DrawCall. 
+    Although it still has a lot of unfinished work, it is still a significant milestone.
 
 #
 ULRE是一个试验性质的工程，用于试验各种渲染相关的技术，以及做一些范例。在未来它的复杂化版本会被整合到CMGameEngine中，用于替代旧的渲染引擎。
 
-平台: Windows,Linux (开发中: Android,macOS,iOS)
+平台: Windows, Linux (开发中: Android, macOS, iOS)
 
 图形API: Vulkan
 
 里程碑:
 
-    2023年5月6日，完成了一个测试，只用了一次DrawCall就绘制出了整个场景。虽然它还有很多未完成的工作，但它依然是一个非常重要的里程碑。
+    2. Texture2DArray集成在材质实例中。同一个模型的多个渲染实例使用不同的材质实例以及不同的纹理，
+    但它们依然被合并成一次渲染。这次的改变虽小，但意义更为重大。
+    
+    1. 完成了一个测试，只用了一次DrawCall就绘制出了整个场景。虽然它还有很多未完成的工作，但它依然是一个非常重要的里程碑。

ShaderLibrary/GetJointMatrix.glsl

@@ -0,0 +1,11 @@
+mat4 GetJointMatrix()
+{
+// Joint数据分Joint ID和Joint Weight两部分
+// Joint ID是一个uvec4，在shader中为整数。在C++端可使用RGBA8UI或是RGBA16UI来传递。
+// Joint Weight是权重，在shader中为浮点。在C++端使用RGBA8或RGBA4来传递。
+
+    return  joint.mats[JointID.x]*JointWeight.x+
+            joint.mats[JointID.y]*JointWeight.y+
+            joint.mats[JointID.z]*JointWeight.z+
+            joint.mats[JointID.w]*JointWeight.w;
+}

ShaderLibrary/Normal.glsl

@@ -0,0 +1,9 @@
+mat3 GetNormalMatrix()
+{
+    return mat3(camera.view*GetLocalToWorld());
+}
+
+vec3 GetNormal(mat3 normal_matrix,vec3 normal)
+{
+    return normalize(normal_matrix*normal);
+}

ShaderLibrary/Std2D/PureColor2D.mtl

@@ -0,0 +1,38 @@
+#Material
+Name PureColor2D
+Base Std2D
+
+#MaterialInstance
+Length 16
+Stage  Fragment
+Code
+{
+    vec4 Color;
+}
+
+#Vertex
+Code
+{
+    void main()
+    {
+        HandoverMI();
+
+        gl_Position=GetPosition2D();
+    }
+}
+
+#Fragment
+Output
+{
+    vec4 FragColor
+}
+
+Code
+{
+    void main()
+    {
+        MaterialInstance mi=GetMI();
+
+        FragColor=mi.Color;
+    }
+}

ShaderLibrary/Std2D/PureTexture2D.mtl

@@ -0,0 +1,39 @@
+#Material
+Name PureTexture2D
+Base Std2D
+
+#VertexInput
+vec2 TexCoord
+
+#Vertex
+Output
+{
+    vec2 TexCoord
+}
+
+Code
+{
+    void main()
+    {
+        Output.TexCoord=TexCoord;
+
+        gl_Position=GetPosition2D();
+    }
+}
+
+#Fragment
+
+sampler2D TextureColor
+
+Output
+{
+    vec4 FragColor;
+}
+
+Code
+{
+    void main()
+    {
+        FragColor=texture(TextureColor,Input.TexCoord);
+    }
+}

ShaderLibrary/Std2D/RectTexture2D.mtl

@@ -0,0 +1,68 @@
+#Material
+Name RectTexture2D
+Base Std2D
+Prim SolidRectangles,WireRectangles
+
+#VertexInput
+vec4 TexCoord
+
+#Vertex
+Output
+{
+    vec4 TexCoord
+}
+
+Code
+{
+    void main()
+    {
+        Output.TexCoord=TexCoord;
+
+        gl_Position=GetPosition2D();
+    }
+}
+
+#Geometry
+in points
+out triangle_strip,4
+
+Output
+{
+    vec2 TexCoord
+}
+
+Code
+{
+    void main()
+    {
+        vec2 vlt=gl_in[0].gl_Position.xy;
+        vec2 vrb=gl_in[0].gl_Position.zw;
+        vec2 tlt=Input[0].TexCoord.xy;
+        vec2 trb=Input[0].TexCoord.zw;
+
+        gl_Position=vec4(vlt,           vec2(0,1));Output.TexCoord=tlt;                EmitVertex();
+        gl_Position=vec4(vlt.x, vrb.y,  vec2(0,1));Output.TexCoord=vec2(tlt.x,trb.y);  EmitVertex();
+        gl_Position=vec4(vrb.x, vlt.y,  vec2(0,1));Output.TexCoord=vec2(trb.x,tlt.y);  EmitVertex();
+        gl_Position=vec4(vrb,           vec2(0,1));Output.TexCoord=trb;                EmitVertex();
+
+        EndPrimitive();
+    }
+}
+
+
+#Fragment
+
+sampler2D TextureColor
+
+Output
+{
+    vec4 FragColor;
+}
+
+Code
+{
+    void main()
+    {
+        FragColor=texture(TextureColor,Input.TexCoord);
+    }
+}

ShaderLibrary/Std2D/RectTexture2DArray.mtl

@@ -0,0 +1,79 @@
+#Material
+Name RectTexture2DArray
+Base Std2D
+Prim SolidRectangles,WireRectangles
+
+#MaterialInstance
+Length 16
+Stage  Fragment
+Code
+{
+    uvec4 id;
+}
+
+#VertexInput
+vec4 TexCoord
+
+#Vertex
+Output
+{
+    vec4 TexCoord
+}
+
+Code
+{
+    void main()
+    {
+        HandoverMI();
+        Output.TexCoord=TexCoord;
+
+        gl_Position=GetPosition2D();
+    }
+}
+
+#Geometry
+in points
+out triangle_strip,4
+
+Output
+{
+    vec2 TexCoord
+}
+
+Code
+{
+    void main()
+    {
+        vec2 vlt=gl_in[0].gl_Position.xy;
+        vec2 vrb=gl_in[0].gl_Position.zw;
+        vec2 tlt=Input[0].TexCoord.xy;
+        vec2 trb=Input[0].TexCoord.zw;
+
+        HandoverMI();gl_Position=vec4(vlt,           vec2(0,1));Output.TexCoord=tlt;                EmitVertex();
+        HandoverMI();gl_Position=vec4(vlt.x, vrb.y,  vec2(0,1));Output.TexCoord=vec2(tlt.x,trb.y);  EmitVertex();
+        HandoverMI();gl_Position=vec4(vrb.x, vlt.y,  vec2(0,1));Output.TexCoord=vec2(trb.x,tlt.y);  EmitVertex();
+        HandoverMI();gl_Position=vec4(vrb,           vec2(0,1));Output.TexCoord=trb;                EmitVertex();
+
+        EndPrimitive();
+    }
+}
+
+
+#Fragment
+
+sampler2DArray TextureColor
+
+Output
+{
+    vec4 FragColor;
+}
+
+Code
+{
+    void main()
+    {
+        MaterialInstance mi=GetMI();
+
+        FragColor=texture(TextureColor,vec3(Input.TexCoord,mi.id.x));
+    }
+}

ShaderLibrary/Std2D/VertexColor2D.mtl

@@ -0,0 +1,37 @@
+#Material
+Name VertexColor2D
+Base Std2D
+
+#VertexInput
+vec4 Color
+
+#Vertex
+Output
+{
+    vec4 Color
+}
+
+Code
+{
+    void main()
+    {
+        Output.Color=Color;
+
+        gl_Position=GetPosition2D();
+    }
+}
+
+#Fragment
+
+Output
+{
+    vec4 FragColor
+}
+
+Code
+{
+    void main()
+    {
+        FragColor=Input.Color;
+    }
+}

ShaderLibrary/Std3D/BlinnPhong/BlinnPhongSun.ubo

@@ -0,0 +1,2 @@
+vec4 direction;
+vec4 color;

ShaderLibrary/Std3D/BlinnPhong/SunLightPureColor.mtl

@@ -0,0 +1,92 @@
+#Material
+Name        BlinnPhong+HalfLambert shading model only color
+Reference   https://zhuanlan.zhihu.com/p/442023993
+Base        Std3D/BlinnPhong
+
+//某些Require并不真的存在.ubo文件，写成一行一个是为了方便未来改成带路径的
+Require     LocalToWorld
+Require     Camera
+
+define      HAVE_SPECULAR   off     //默认不定义HAVE_SPECULAR
+
+UBO
+{
+    File    BlinnPhongSun.ubo   //文件名,如果/开头表示从ShaderLibrary根目录开始，没有则表示同一目录
+    Struct  BlinnPhongSun       //结构名称
+    Name    sun                 //在代码中的变量名
+    Stage   Fragment            //会引用的shader
+    Set     Global              //Descriptor Set
+}
+
+#MaterialInstance
+Length 16
+Stage  Fragment
+Code
+{
+    vec3 Color;
+    float Gloss;
+}
+
+#VertexInput
+vec3 Normal
+
+#Vertex
+Output
+{
+    vec4 Position;
+    vec3 Normal;
+}
+
+Code
+{
+
+    void main()
+    {
+        Output.Normal   =GetNormal();
+        Output.Position =GetPosition3D();
+        
+        HandoverMI();
+
+        gl_Position     =Output.Position;
+    }
+}
+
+#Fragment
+Output
+{
+    vec4 FragColor;
+}
+
+Code
+{
+    #define HAVE_SPECULAR
+
+    void main()
+    {
+        MaterialInstance mi=GetMI();
+
+        //点乘法线和光照
+        float intensity=0.5*max(dot(Input.Normal,sun.direction.xyz),0.0)+0.5;
+
+        //直接光颜色
+        vec3 direct_color           =intensity*sun.color.rgb*mi.Color.rgb;
+
+    #ifndef HAVE_SPECULAR
+        FragColor=vec4(direct_color,1.0);
+     #else
+
+        vec3 spec_color=vec3(0.0);
+
+        if(intensity>0.0)
+        {
+            vec3 half_vector=normalize(sun.direction.xyz+normalize(Input.Position.xyz+camera.pos));
+
+            float specular=max(dot(half_vector,Input.Normal),0.0);
+
+            spec_color=specular*pow(specular,mi.Gloss)*sun.color.rgb;
+        }
+        
+        FragColor=vec4(direct_color+spec_color,1.0);
+     #endif//HAVE_SPECULAR
+    }
+}

ShaderLibrary/Std3D/MetricCellsGrid.mtl

@@ -0,0 +1,87 @@
+#Material
+Name MetricCellsGrid
+Base Std3D
+Reference https://www.shadertoy.com/view/wdSXzm
+
+#VertexInput
+vec2 TexCoord
+
+#MaterialInstance
+Length 120
+Stage  Fragment
+
+Code
+{
+    vec4 x_color;
+    vec4 y_color;
+    vec4 x_axis_color;
+    vec4 y_axis_color;
+    vec4 center_color;
+
+    vec2 lum;               //x=0.1 sub cell line,y=0.2 big cell line
+    vec2 cell_step;
+    vec2 big_cell_step;
+    vec2 scale;
+
+    float axis_line_width;
+    float center_radius;
+}
+
+#Vertex
+Output
+{
+    vec2 TexCoord
+}
+
+Code
+{
+    void main()
+    {
+        HandoverMI();
+
+        Output.TexCoord=TexCoord;
+
+        gl_Position=GetPosition3D();
+    }
+}
+
+#Fragment
+Output
+{
+    vec4 FragColor;
+}
+
+Code
+{
+    void main()
+    {
+        MaterialInstance mi=GetMI();
+
+        float edge=viewport.inv_viewport_resolution.y;
+
+        float x=(Input.TexCoord.x-0.5)*mi.scale.x;
+        float y=(Input.TexCoord.y-0.5)*mi.scale.y;
+
+        vec4 color=vec4(0,0,0,1);
+
+        // ======= Lines + Bold lines
+        color.xyz += step(1.0 - 1.0 / mi.cell_step.x,       fract(x / mi.cell_step.x    )) * mi.x_color.rgb * mi.lum.x;
+        color.xyz += step(1.0 - 1.0 / mi.big_cell_step.x,   fract(x / mi.big_cell_step.x)) * mi.x_color.rgb * mi.lum.y;
+
+        color.xyz += step(1.0 - 1.0 / mi.cell_step.y,       fract(y / mi.cell_step.y    )) * mi.y_color.rgb * mi.lum.x;
+        color.xyz += step(1.0 - 1.0 / mi.big_cell_step.y,   fract(y / mi.big_cell_step.y)) * mi.y_color.rgb * mi.lum.y;
+
+        // ======= AXES
+        float xb = step(abs(x) - mi.axis_line_width, 0.0);
+        float yb = step(abs(y) - mi.axis_line_width, 0.0);
+
+        color.rgb = mix(color.rgb, mi.x_axis_color.rgb, (xb));
+        color.rgb = mix(color.rgb, mi.y_axis_color.rgb, (yb));
+
+        // ======= CENTER
+        float cb = length(vec2(x,y))-mi.center_radius;
+        color.rgb = mix(color.rgb, mi.center_color.rgb, cb>0.0?0.0:smoothstep(0,edge*mi.scale.y,abs(cb)));
+
+        FragColor=color;
+    }
+}

ShaderLibrary/Std3D/PureColor3D.mtl

@@ -0,0 +1,38 @@
+#Material
+Name PureColor3D
+Base Std3D
+
+#MaterialInstance
+Length 16
+Stage  Fragment
+Code
+{
+    vec4 Color;
+}
+
+#Vertex
+Code
+{
+    void main()
+    {
+        HandoverMI();
+
+        gl_Position=GetPosition3D();
+    }
+}
+
+#Fragment
+Output
+{
+    vec4 FragColor;
+}
+
+Code
+{
+    void main()
+    {
+        MaterialInstance mi=GetMI();
+
+        FragColor=mi.Color;
+    }
+}

ShaderLibrary/Std3D/VertexColor3D.mtl

@@ -0,0 +1,38 @@
+#Material
+Name VertexColor3D
+Base Std3D
+
+#VertexInput
+vec4 Color
+
+#Vertex
+
+Output
+{
+    vec4 Color
+}
+
+Code
+{
+    void main()
+    {
+        Output.Color=Color;
+
+        gl_Position=GetPosition3D();
+    }
+}
+
+#Fragment
+
+Output
+{
+    vec4 FragColor;
+}
+
+Code
+{
+    void main()
+    {
+        FragColor=Input.Color;
+    }
+}

ShaderLibrary/Std3D/VertexLum3D.mtl

@@ -0,0 +1,47 @@
+#Material
+Name VertexLum3D
+Base Std3D
+
+#MaterialInstance
+Length 16
+Stage  Vertex
+Code
+{
+    vec4 Color;
+}
+
+#VertexInput
+float Luminance
+
+#Vertex
+Output
+{
+    vec4 Color
+}
+
+Code
+{
+    void main()
+    {
+        MaterialInstance mi=GetMI();
+
+        Output.Color=Luminance*mi.Color;
+
+        gl_Position=GetPosition3D();
+    }
+}
+
+#Fragment
+
+Output
+{
+    vec4 FragColor;
+}
+
+Code
+{
+    void main()
+    {
+        FragColor=Input.Color;
+    }
+}

example/2dVector/line.cpp

@@ -143,7 +143,7 @@ public:
         return(true);
     }
 
-    void Resize(int w,int h)override
+    void Resize(uint w,uint h)override
     {
         cam.width=w;
         cam.height=h;

example/2dVector/roundbox.cpp

@@ -165,7 +165,7 @@ public:
         return(true);
     }
 
-    void Resize(int w,int h)override
+    void Resize(uint w,uint h)override
     {
         cam.width=w;
         cam.height=h;

example/Basic/auto_instance.cpp

@@ -5,7 +5,7 @@
 #include<hgl/filesystem/FileSystem.h>
 #include<hgl/graph/VKRenderablePrimitiveCreater.h>
 #include<hgl/graph/VKVertexInputConfig.h>
-#include<hgl/graph/mtl/2d/Material2DCreateConfig.h>
+#include<hgl/graph/mtl/Material2DCreateConfig.h>
 #include<hgl/graph/RenderList.h>
 
 using namespace hgl;
@@ -71,7 +71,7 @@ private:
 
     bool InitVBO()
     {
-        RenderablePrimitiveCreater rpc(db,VERTEX_COUNT);
+        RenderablePrimitiveCreater rpc(db,"Triangle",VERTEX_COUNT);
 
         if(!rpc.SetVBO(VAN::Position,   VF_V2F,     position_data))return(false);
         if(!rpc.SetVBO(VAN::Color,      VF_V4UN8,   color_data   ))return(false);
@@ -116,7 +116,7 @@ public:
         return(true);
     }
 
-    void Resize(int w,int h)override
+    void Resize(uint w,uint h)override
     {
         VulkanApplicationFramework::Resize(w,h);
 

example/Basic/auto_merge_material_instance.cpp

@@ -4,7 +4,7 @@
 #include<hgl/math/Math.h>
 #include<hgl/filesystem/FileSystem.h>
 #include<hgl/graph/VKRenderablePrimitiveCreater.h>
-#include<hgl/graph/mtl/2d/Material2DCreateConfig.h>
+#include<hgl/graph/mtl/Material2DCreateConfig.h>
 #include<hgl/graph/RenderList.h>
 #include<hgl/color/Color.h>
 
@@ -25,6 +25,8 @@ constexpr float position_data[VERTEX_COUNT*2]=
 
 constexpr uint DRAW_OBJECT_COUNT=12;
 
+#define USE_MATERIAL_FILE   true        //是否使用材质文件
+
 class TestApp:public VulkanApplicationFramework
 {
 private:
@@ -52,9 +54,12 @@ private:
             cfg.coordinate_system=CoordinateSystem2D::NDC;
             cfg.local_to_world=true;
 
-            AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreatePureColor2D(&cfg);
-
+        #ifndef USE_MATERIAL_FILE
+            AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreatePureColor2D(&cfg);                       //走程序内置材质创建函数
             material=db->CreateMaterial(mci);
+        #else
+            material=db->LoadMaterial("Std2D/PureColor2D",&cfg);                                            //走材质文件加载
+        #endif//USE_MATERIAL_FILE
 
             if(!material)
                 return(false);
@@ -79,7 +84,7 @@ private:
 
     bool InitVBOAndRenderList()
     {
-        RenderablePrimitiveCreater rpc(db,VERTEX_COUNT);
+        RenderablePrimitiveCreater rpc(db,"Triangle",VERTEX_COUNT);
 
         if(!rpc.SetVBO(VAN::Position,   VF_V2F, position_data))return(false);
         
@@ -125,7 +130,7 @@ public:
         return(true);
     }
 
-    void Resize(int w,int h)override
+    void Resize(uint w,uint h)override
     {
         VulkanApplicationFramework::Resize(w,h);
 

example/Basic/draw_triangle_in_NDC.cpp

@@ -7,7 +7,7 @@
 #include<hgl/graph/SceneInfo.h>
 #include<hgl/graph/VKVertexInputConfig.h>
 #include<hgl/graph/VKRenderablePrimitiveCreater.h>
-#include<hgl/graph/mtl/2d/Material2DCreateConfig.h>
+#include<hgl/graph/mtl/Material2DCreateConfig.h>
 
 using namespace hgl;
 using namespace hgl::graph;
@@ -108,7 +108,7 @@ private:
 
     bool InitVBO()
     {
-        RenderablePrimitiveCreater rpc(db,VERTEX_COUNT);
+        RenderablePrimitiveCreater rpc(db,"Triangle",VERTEX_COUNT);
 
 #ifdef USE_HALF_FLOAT_POSITION
         Float32toFloat16(position_data_hf,position_data_float,VERTEX_COUNT*2);
@@ -145,7 +145,7 @@ public:
         return(true);
     }
 
-    void Resize(int w,int h)override
+    void Resize(uint w,uint h)override
     {
         VulkanApplicationFramework::Resize(w,h);
 

example/Basic/draw_triangle_use_UBO.cpp

@@ -4,29 +4,29 @@
 #include<hgl/math/Math.h>
 #include<hgl/filesystem/FileSystem.h>
 #include<hgl/graph/SceneInfo.h>
+#include<hgl/graph/VKVertexInputConfig.h>
 #include<hgl/graph/VKRenderablePrimitiveCreater.h>
-#include<hgl/graph/mtl/2d/Material2DCreateConfig.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;
 
-static float position_data[VERTEX_COUNT][2]=
+static float position_data_float[VERTEX_COUNT][2]=
 {
     {0.5,   0.25},
     {0.75,  0.75},
     {0.25,  0.75}
 };
 
-constexpr float color_data[VERTEX_COUNT][4]=
+static uint16 position_data_u16[VERTEX_COUNT][2]={};
+
+constexpr uint8 color_data[VERTEX_COUNT*4]=
 {   
-    {1,0,0,1},
-    {0,1,0,1},
-    {0,0,1,1}
+    255,0,0,255,
+    0,255,0,255,
+    0,0,255,255
 };
 
 //#define USE_ZERO2ONE_COORD      //使用左上角0,0右下角1,1的坐标系
@@ -46,23 +46,31 @@ private:
     {
         mtl::Material2DCreateConfig cfg(device->GetDeviceAttribute(),"VertexColor2D",Prim::Triangles);
 
+        VILConfig vil_config;
+
 #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,VF_V2U16);     //这里指定VBO中使用RG16U当做顶点数据格式
 #endif//USE_ZERO2ONE_COORD
 
+        vil_config.Add(VAN::Color,VF_V4UN8);        //这里指定VBO中使用RGBA8UNorm当做颜色数据格式
+
         cfg.local_to_world=false;
 
         AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreateVertexColor2D(&cfg);
 
-        material_instance=db->CreateMaterialInstance(mci);
+        material_instance=db->CreateMaterialInstance(mci,&vil_config);
 
         if(!material_instance)
             return(false);
-
-        db->global_descriptor.Bind(material_instance->GetMaterial());
-            
+           
 //        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
 
@@ -71,20 +79,15 @@ private:
    
     bool InitVBO()
     {
-        RenderablePrimitiveCreater rpc(db,VERTEX_COUNT);
-
-#ifndef USE_ZERO2ONE_COORD      //使用ortho坐标系
-
-        for(uint i=0;i<VERTEX_COUNT;i++)
-        {
-            position_data[i][0]*=SCREEN_WIDTH;
-            position_data[i][1]*=SCREEN_HEIGHT;
-        }
+        RenderablePrimitiveCreater rpc(db,"Triangle",VERTEX_COUNT);
 
+#ifdef USE_ZERO2ONE_COORD               //使用0 to 1坐标系
+        if(!rpc.SetVBO(VAN::Position,   VF_V2F,     position_data_float ))return(false);
+#else                                   //使用ortho坐标系
+        if(!rpc.SetVBO(VAN::Position,   VF_V2U16,   position_data_u16   ))return(false);
 #endif//USE_ZERO2ONE_COORD
 
-        if(!rpc.SetVBO(VAN::Position,   VF_V2F, position_data))return(false);
-        if(!rpc.SetVBO(VAN::Color,      VF_V4F, color_data   ))return(false);
+        if(!rpc.SetVBO(VAN::Color,      VF_V4UN8,   color_data          ))return(false);
         
         render_obj=rpc.Create(material_instance,pipeline);
         return(true);
@@ -92,11 +95,19 @@ private:
 
 public:
 
-    bool Init()
+    bool Init(uint w,uint h)
     {
-        if(!VulkanApplicationFramework::Init(SCREEN_WIDTH,SCREEN_HEIGHT))
+        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);
 
@@ -109,7 +120,7 @@ public:
         return(true);
     }
 
-    void Resize(int w,int h)override
+    void Resize(uint w,uint h)override
     {
         VulkanApplicationFramework::Resize(w,h);
 
@@ -119,12 +130,5 @@ public:
 
 int main(int,char **)
 {
-    TestApp app;
-
-    if(!app.Init())
-        return(-1);
-
-    while(app.Run());
-
-    return 0;
+    RunApp<TestApp>(1280,720);
 }

example/CMakeLists.txt

@@ -4,6 +4,7 @@ SET(VULKAN_APP_FRAMEWORK ${CMAKE_CURRENT_SOURCE_DIR}/common/VulkanAppFramework.h
 
 add_subdirectory(Basic)
 add_subdirectory(Texture)
+add_subdirectory(LightBasic)
 add_subdirectory(Gizmo)
 
 add_subdirectory(Vulkan)
@@ -21,4 +22,3 @@ macro(CreateProject name)
     set_property(TARGET ${name} PROPERTY FOLDER "ULRE/Example")
 endmacro()
 
-CreateProject(MaterialCreaterTest MaterialCreaterTest.cpp)

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,4 +10,10 @@
     set_property(TARGET ${name} PROPERTY FOLDER "ULRE/Example/Gizmo")
 endmacro()
 
-CreateProject(PlaneGrid3D PlaneGrid3D.cpp)
+CreateProject(01_PlaneGrid3D PlaneGrid3D.cpp)
+CreateProject(02_RayPicking RayPicking.cpp)
+CreateProject(03_MetricCellsGrid MetricCellsGrid.cpp)
+
+CreateProject(04_Gizmo3DMove Gizmo3DMove.cpp Gizmo.h Gizmo.cpp)
+
+#CreateProject(03_BlenderAxis BlenderAxis.cpp)

example/Gizmo/Gizmo.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include<hgl/graph/VK.h>
+
+VK_NAMESPACE_BEGIN
+
+class Gizmo
+{
+    Material *          material;
+    MaterialInstance *  mi;
+    Pipeline *          pipeline;
+    Primitive *         primitive;
+
+};//class Gizmo
+
+VK_NAMESPACE_END

example/Gizmo/Gizmo3DMove.cpp

@@ -0,0 +1,228 @@
+// Gizmo 3D Move
+
+#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/VKVertexAttribBuffer.h>
+#include<hgl/graph/mtl/Material3DCreateConfig.h>
+
+using namespace hgl;
+using namespace hgl::graph;
+
+static Color4f white_color(1,1,1,1);
+static Color4f yellow_color(1,1,0,1);
+
+class TestApp:public SceneAppFramework
+{
+    Color4f color;
+
+    DeviceBuffer *ubo_color=nullptr;
+
+private:
+
+    Material *          mtl_vtx_lum         =nullptr;
+    MaterialInstance *  mi_plane_grid       =nullptr;
+    Pipeline *          pipeline_vtx_lum    =nullptr;
+    Primitive *         prim_plane_grid     =nullptr;
+
+    Material *          mtl_vtx_color       =nullptr;
+    MaterialInstance *  mi_line             =nullptr;
+    Pipeline *          pipeline_vtx_color  =nullptr;
+    Primitive *         ro_line             =nullptr;
+
+private:
+
+    bool InitMaterialAndPipeline()
+    {
+        {
+            mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"VertexLuminance3D",Prim::Lines);
+
+            cfg.local_to_world=true;
+
+            mtl_vtx_lum=db->LoadMaterial("Std3D/VertexLum3D",&cfg);
+            if(!mtl_vtx_lum)return(false);
+
+            mi_plane_grid=db->CreateMaterialInstance(mtl_vtx_lum,nullptr,&white_color);
+            if(!mi_plane_grid)return(false);
+
+            pipeline_vtx_lum=CreatePipeline(mtl_vtx_lum,InlinePipeline::Solid3D,Prim::Lines);
+
+            if(!pipeline_vtx_lum)
+                return(false);
+        }
+
+        {
+            mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"VertexColor3D",Prim::Lines);
+
+            cfg.local_to_world=true;
+
+            mtl_vtx_color=db->LoadMaterial("Std3D/VertexColor3D",&cfg);
+            if(!mtl_vtx_color)return(false);
+
+            mi_line=db->CreateMaterialInstance(mtl_vtx_color);
+            if(!mi_line)return(false);
+
+            {
+                const PipelineData *ipd=GetPipelineData(InlinePipeline::Solid3D);
+
+                if(!ipd)
+                    return(false);
+
+                PipelineData *pd=new PipelineData(ipd);
+
+                pd->SetLineWidth(2);
+
+                pipeline_vtx_color=CreatePipeline(mtl_vtx_color,pd,Prim::Lines);
+
+                delete pd;
+
+                if(!pipeline_vtx_color)
+                    return(false);
+            }
+        }
+
+        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.CreateSubNode(ri);
+
+        return ri;
+    }
+
+    /**
+     * д<><D0B4>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+     * 
+     * \param pos       Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD>ָ<EFBFBD><D6B8>
+     * \param max_line  <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+     * \param oa1       <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>1<EFBFBD><31><EFBFBD><EFBFBD>
+     * \param oa2       <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>2<EFBFBD><32><EFBFBD><EFBFBD>
+     */
+    void WriteAxisPosition(Vector3f *pos,const Vector3f &max_line,const Vector3f &oa1,const Vector3f &oa2)
+    {
+        constexpr const float AXIS_LENGTH    =4;
+        constexpr const float AXIS_MIN_STEP  =1;
+        constexpr const float AXIS_ARROW_SIZE=0.25;
+
+        const Vector3f end_pos  =max_line*AXIS_LENGTH;                          ///<<3C><><EFBFBD>յ<EFBFBD>λ<EFBFBD><CEBB>
+        const Vector3f cross_pos=max_line*AXIS_MIN_STEP;                        ///<<3C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>β<EFBFBD><CEB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD><CEBB>
+        const Vector3f arrow_pos=max_line*(AXIS_LENGTH-AXIS_MIN_STEP);          ///<<3C><>ͷĩ<CDB7><C4A9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD>λ<EFBFBD><CEBB>
+
+        //<2F><><EFBFBD><EFBFBD>
+        pos[0]=Vector3f(0,            0, 0);
+        pos[1]=end_pos;
+
+        //<2F>ĸ<EFBFBD><C4B8><EFBFBD>ͷ<EFBFBD><CDB7>
+        pos[2]=end_pos;
+        pos[3]=arrow_pos-oa1*AXIS_ARROW_SIZE;
+
+        pos[4]=end_pos;
+        pos[5]=arrow_pos+oa1*AXIS_ARROW_SIZE;
+
+        pos[6]=end_pos;
+        pos[7]=arrow_pos-oa2*AXIS_ARROW_SIZE;
+
+        pos[8]=end_pos;
+        pos[9]=arrow_pos+oa2*AXIS_ARROW_SIZE;
+
+        //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+        pos[10]=cross_pos;
+        pos[11]=cross_pos+oa1*AXIS_MIN_STEP;
+        pos[12]=cross_pos;
+        pos[13]=cross_pos+oa2*AXIS_MIN_STEP;
+    }
+
+    bool CreateRenderObject()
+    {
+        using namespace inline_geometry;
+
+        {
+            struct PlaneGridCreateInfo pgci;
+
+            pgci.grid_size.Set(32,32);
+
+            pgci.sub_count.Set(8,8);
+
+            pgci.lum=0.5;
+            pgci.sub_lum=0.75;
+
+            prim_plane_grid=CreatePlaneGrid(db,mtl_vtx_lum->GetDefaultVIL(),&pgci);
+        }
+
+        {
+            constexpr const uint AXIS_MAX_LINES     =7;
+            constexpr const uint AXIS_MAX_VERTICES  =AXIS_MAX_LINES*2*3;
+
+            ro_line=db->CreatePrimitive("Line",AXIS_MAX_VERTICES);
+            if(!ro_line)return(false);
+
+            Vector3f position_data[3][AXIS_MAX_LINES*2];
+
+            WriteAxisPosition(position_data[0],Vector3f(1,0,0),Vector3f(0,1,0),Vector3f(0,0,1));
+            WriteAxisPosition(position_data[1],Vector3f(0,1,0),Vector3f(1,0,0),Vector3f(0,0,1));
+            WriteAxisPosition(position_data[2],Vector3f(0,0,1),Vector3f(1,0,0),Vector3f(0,1,0));
+
+            Color4f color_data[3][AXIS_MAX_LINES*2];
+
+            for(Color4f &c:color_data[0])c=Color4f(1,0,0,1);
+            for(Color4f &c:color_data[1])c=Color4f(0,1,0,1);
+            for(Color4f &c:color_data[2])c=Color4f(0,0,1,1);
+            
+            if(!ro_line->Set(VAN::Position, db->CreateVBO(VF_V3F,AXIS_MAX_VERTICES,position_data)))return(false);
+            if(!ro_line->Set(VAN::Color,    db->CreateVBO(VF_V4F,AXIS_MAX_VERTICES,color_data   )))return(false);
+        }
+
+        return(true);
+    }
+
+    bool InitScene()
+    {
+        Add(prim_plane_grid,mi_plane_grid,pipeline_vtx_lum);
+        Add(ro_line,mi_line,pipeline_vtx_color);
+
+        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:
+
+    bool Init(uint w,uint h) override
+    {
+        if(!SceneAppFramework::Init(w,h))
+            return(false);
+
+        if(!InitMaterialAndPipeline())
+            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/MetricCellsGrid.cpp

@@ -0,0 +1,142 @@
+// 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/VKRenderablePrimitiveCreater.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()
+    {
+        ro_plane=inline_geometry::CreatePlane(db,material->GetDefaultVIL());
+
+        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,4 +1,4 @@
-// 4.Geometry3D
+// PlaneGrid3D
 
 #include"VulkanAppFramework.h"
 #include<hgl/filesystem/FileSystem.h>
@@ -6,155 +6,118 @@
 #include<hgl/graph/VKRenderResource.h>
 #include<hgl/graph/RenderList.h>
 #include<hgl/graph/Camera.h>
+#include<hgl/graph/VKRenderablePrimitiveCreater.h>
+#include<hgl/graph/mtl/Material3DCreateConfig.h>
 
 using namespace hgl;
 using namespace hgl::graph;
 
-constexpr uint32_t SCREEN_WIDTH=1280;
-constexpr uint32_t SCREEN_HEIGHT=720;
-
-class TestApp:public CameraAppFramework
+class TestApp:public SceneAppFramework
 {
-    Color4f color;
-
-    DeviceBuffer *ubo_color=nullptr;
-
 private:
 
-    SceneNode           render_root;
-    RenderList *        render_list         =nullptr;
-
     Material *          material            =nullptr;
-    MaterialInstance *  material_instance   =nullptr;
     Pipeline *          pipeline            =nullptr;
 
-    Primitive *         ro_plane_grid[3]{};
+    Primitive *         prim_plane_grid     =nullptr;
+    MaterialInstance *  material_instance[3]{};
 
 private:
 
     bool InitMDP()
     {
-        material=db->CreateMaterial(OS_TEXT("res/material/VertexColor3D"));
+        mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"VertexLuminance3D",Prim::Lines);
+
+        cfg.local_to_world=true;
+
+        material=db->LoadMaterial("Std3D/VertexLum3D",&cfg);
         if(!material)return(false);
 
-        material_instance=db->CreateMaterialInstance(material);
-        if(!material_instance)return(false);
-        
-        pipeline=CreatePipeline(material_instance,InlinePipeline::Solid3D,Prim::Lines);
-        if(!pipeline)
-            return(false);
+        Color4f GridColor;
+        COLOR ce=COLOR::BlenderAxisRed;
 
-        return(true);
+        for(uint i=0;i<3;i++)
+        {
+            GridColor=GetColor4f(ce,1.0);
+
+            material_instance[i]=db->CreateMaterialInstance(material,nullptr,&GridColor);
+
+            ce=COLOR((int)ce+1);
+        }
+        
+        pipeline=CreatePipeline(material,InlinePipeline::Solid3D,Prim::Lines);
+
+        return pipeline;
     }
-    
-    Renderable *Add(Primitive *r,const Matrix4f &mat)
+
+    bool CreateRenderObject()
     {
-        Renderable *ri=db->CreateRenderable(r,material_instance,pipeline);
+        using namespace inline_geometry;
+
+        struct PlaneGridCreateInfo pgci;
+
+        pgci.grid_size.Set(32,32);
+        pgci.sub_count.Set(8,8);
+
+        pgci.lum=0.75;
+        pgci.sub_lum=1.0;
+
+        prim_plane_grid=CreatePlaneGrid(db,material->GetDefaultVIL(),&pgci);
+
+        return prim_plane_grid;
+    }
+
+    Renderable *Add(MaterialInstance *mi,const Matrix4f &mat)
+    {
+        Renderable *ri=db->CreateRenderable(prim_plane_grid,mi,pipeline);
+
+        if(!ri)
+            return(nullptr);
 
         render_root.CreateSubNode(mat,ri);
 
         return ri;
     }
 
-    void CreateRenderObject()
-    {
-        using namespace inline_geometry;
-
-        struct PlaneGridCreateInfo pgci;
-
-        pgci.coord[0]=Vector3f(-100,-100,0);
-        pgci.coord[1]=Vector3f( 100,-100,0);
-        pgci.coord[2]=Vector3f( 100, 100,0);
-        pgci.coord[3]=Vector3f(-100, 100,0);
-
-        pgci.step.x=32;
-        pgci.step.y=32;
-
-        pgci.side_step.x=8;
-        pgci.side_step.y=8;
-
-        pgci.color.Set(0.5,0,0,1);
-        pgci.side_color.Set(1,0,0,1);
-
-        const VIL *vil=material_instance->GetVIL();
-
-        ro_plane_grid[0]=CreatePlaneGrid(db,vil,&pgci);
-
-        pgci.color.Set(0,0.5,0,1);
-        pgci.side_color.Set(0,1,0,1);
-
-        ro_plane_grid[1]=CreatePlaneGrid(db,vil,&pgci);
-
-        pgci.color.Set(0,0,0.5,1);
-        pgci.side_color.Set(0,0,1,1);
-        ro_plane_grid[2]=CreatePlaneGrid(db,vil,&pgci);
-    }
-
     bool InitScene()
     {
-        Add(ro_plane_grid[0],Matrix4f(1.0f));
-        Add(ro_plane_grid[1],rotate(HGL_RAD_90,0,1,0));
-        Add(ro_plane_grid[2],rotate(HGL_RAD_90,1,0,0));
+        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));
 
-        camera->pos=Vector3f(200,200,200);
+        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(camera->info,&render_root);
+        render_list->Expend(&render_root);
 
         return(true);
     }
 
 public:
 
-    ~TestApp()
+    bool Init(uint width,uint height) override
     {
-        SAFE_CLEAR(render_list);
-    }
-
-    bool Init()
-    {
-        if(!CameraAppFramework::Init(SCREEN_WIDTH,SCREEN_HEIGHT))
+        if(!SceneAppFramework::Init(width,height))
             return(false);
-            
-        render_list=new RenderList(device);
 
         if(!InitMDP())
             return(false);
 
-        CreateRenderObject();
+        if(!CreateRenderObject())
+            return(false);
 
         if(!InitScene())
             return(false);
 
         return(true);
     }
-
-    void BuildCommandBuffer(uint32 index)
-    {
-        render_root.RefreshMatrix();
-        render_list->Expend(GetCameraInfo(),&render_root);
-
-        VulkanApplicationFramework::BuildCommandBuffer(index,render_list);
-    }
-
-    void Resize(int w,int h)override
-    {
-        CameraAppFramework::Resize(w,h);
-        
-        VulkanApplicationFramework::BuildCommandBuffer(render_list);
-    }
 };//class TestApp:public CameraAppFramework
 
 int main(int,char **)
 {
-    TestApp app;
-
-    if(!app.Init())
-        return(-1);
-
-    while(app.Run());
-
-    return 0;
+    return RunApp<TestApp>(1280,720);
 }

example/Gizmo/RayPicking.cpp

@@ -0,0 +1,168 @@
+// RayPicking
+
+#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/Ray.h>
+#include<hgl/graph/VKVertexAttribBuffer.h>
+#include<hgl/graph/mtl/Material3DCreateConfig.h>
+
+using namespace hgl;
+using namespace hgl::graph;
+
+static float position_data[2][3]=
+{
+    {100,100,100},
+    {0,0,0}
+};
+
+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 SceneAppFramework
+{
+    Color4f color;
+
+    DeviceBuffer *ubo_color=nullptr;
+
+private:
+
+    Material *          material            =nullptr;
+    MaterialInstance *  mi_plane_grid       =nullptr;
+    MaterialInstance *  mi_line             =nullptr;
+
+    Pipeline *          pipeline            =nullptr;
+
+    Primitive *         prim_plane_grid       =nullptr;
+
+    Primitive *         ro_line             =nullptr;
+
+    VBO *               vbo_pos             =nullptr;
+
+    Ray                 ray;
+
+private:
+
+    bool InitMaterialAndPipeline()
+    {
+        mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"VertexLuminance3D",Prim::Lines);
+
+        cfg.local_to_world=true;
+
+        material=db->LoadMaterial("Std3D/VertexLum3D",&cfg);
+        if(!material)return(false);
+
+        mi_plane_grid=db->CreateMaterialInstance(material,nullptr,&white_color);
+        if(!mi_plane_grid)return(false);
+
+        mi_line=db->CreateMaterialInstance(material,nullptr,&yellow_color);
+        if(!mi_line)return(false);
+
+        pipeline=CreatePipeline(material,InlinePipeline::Solid3D,Prim::Lines);
+
+        if(!pipeline)
+            return(false);
+
+        return(true);
+    }
+    
+    Renderable *Add(Primitive *r,MaterialInstance *mi)
+    {
+        Renderable *ri=db->CreateRenderable(r,mi,pipeline);
+
+        if(!ri)
+        {
+            LOG_ERROR(OS_TEXT("Create Renderable failed."));
+            return(nullptr);
+        }
+
+        render_root.CreateSubNode(ri);
+
+        return ri;
+    }
+
+    bool CreateRenderObject()
+    {
+        using namespace inline_geometry;
+
+        {
+            struct PlaneGridCreateInfo pgci;
+
+            pgci.grid_size.Set(32,32);
+            pgci.sub_count.Set(8,8);
+
+            pgci.lum=0.5;
+            pgci.sub_lum=0.75;
+
+            prim_plane_grid=CreatePlaneGrid(db,material->GetDefaultVIL(),&pgci);
+        }
+
+        {
+            ro_line=db->CreatePrimitive("Line",2);
+            if(!ro_line)return(false);
+            
+            if(!ro_line->Set(VAN::Position,  vbo_pos=   db->CreateVBO(VF_V3F,2,position_data    )))return(false);
+            if(!ro_line->Set(VAN::Luminance,            db->CreateVBO(VF_V1F,2,lumiance_data    )))return(false);
+        }
+
+        return(true);
+    }
+
+    bool InitScene()
+    {
+        Add(prim_plane_grid,mi_plane_grid);
+        Add(ro_line,mi_line);
+
+        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:
+
+    bool Init(uint w,uint h)
+    {        
+        if(!SceneAppFramework::Init(w,h))
+            return(false);
+
+        if(!InitMaterialAndPipeline())
+            return(false);
+
+        if(!CreateRenderObject())
+            return(false);
+
+        if(!InitScene())
+            return(false);
+
+        return(true);
+    }
+
+    void BuildCommandBuffer(uint32 index) override
+    {
+        const CameraInfo &ci=GetCameraInfo();
+        const ViewportInfo &vi=GetViewportInfo();
+
+        ray.Set(GetMouseCoord(),&ci,&vi);                       //设置射线查询的屏幕坐标点
+
+        const Vector3f pos=ray.ClosestPoint(Vector3f(0,0,0));   //求射线上与点(0,0,0)最近的点的坐标
+
+        vbo_pos->Write(&pos,3*sizeof(float));                   //更新VBO上这个点的位置
+
+        SceneAppFramework::BuildCommandBuffer(index);
+    }
+};//class TestApp:public CameraAppFramework
+
+int main(int,char **)
+{
+    return RunApp<TestApp>(1280,720);
+}

example/LightBasic/BlinnPhongDirectionLight.cpp

@@ -0,0 +1,271 @@
+// BlinnPhong direction light
+
+#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/Ray.h>
+#include<hgl/graph/VKVertexAttribBuffer.h>
+#include<hgl/graph/mtl/Material3DCreateConfig.h>
+#include<hgl/graph/mtl/BlinnPhong.h>
+#include<hgl/color/Color.h>
+
+using namespace hgl;
+using namespace hgl::graph;
+
+static float lumiance_data[2]={1,1};
+
+static Color4f white_color(1,1,1,1);
+
+static mtl::blinnphong::SunLight sun_light=
+{
+    Vector4f(1,1,1,0),      //direction
+    Vector4f(1,0.95,0.9,1)  //color
+};
+
+constexpr const COLOR AxisColor[4]=
+{
+    COLOR::Red,     //X轴颜色
+    COLOR::Green,   //Y轴颜色
+    COLOR::Blue,    //Z轴颜色
+    COLOR::White    //全局颜色
+};
+
+class VertexDataManager
+{
+    uint                        vi_count;       ///<顶点输入流数量
+    const VertexInputFormat *   vif_list;       ///<顶点输入格式列表
+    
+    VkDeviceSize        vbo_max_size;   ///<顶点缓冲区分配空间大小
+    VkDeviceSize        vbo_cur_size;   ///<顶点缓冲区当前使用大小
+    VBO **              vbo;            ///<顶点缓冲区列表
+    
+    VkDeviceSize        ibo_cur_size;   ///<索引缓冲区当前使用大小
+    IndexBuffer *       ibo;            ///<索引缓冲区
+
+    struct DataOffset
+    {
+        VkDeviceSize vbo_start;
+        VkDeviceSize vbo_size;
+
+        VkDeviceSize ibo_start;
+        VkDeviceSize ibo_size;
+    };
+
+public:
+
+    VertexDataManager(const VIL &_vil)
+    {
+        vi_count=_vil.GetCount();
+        vif_list=_vil.GetVIFList();
+
+        vbo_max_size=0;
+        vbo_cur_size=0;
+        vbo=hgl_zero_new<VBO *>(vi_count);
+
+        ibo_cur_size=0;
+        ibo=nullptr;
+    }
+
+    const VkDeviceSize  GetVBOMaxCount()const{return vbo_max_size;}                                  ///<取得顶点缓冲区分配的空间最大数量
+    const VkDeviceSize  GetVBOCurCount()const{return vbo_cur_size;}                                  ///<取得顶点缓冲区当前数量
+
+    const IndexType     GetIBOType      ()const{return ibo?ibo->GetType():IndexType::ERR;}           ///<取得索引缓冲区类型
+    const VkDeviceSize  GetIBOMaxCount  ()const{return ibo?ibo->GetCount():-1;}                      ///<取得索引缓冲区分配的空间最大数量
+    const VkDeviceSize  GetIBOCurCount  ()const{return ibo?ibo_cur_size:-1;}                         ///<取得索引缓冲区当前数量
+};//class VertexDataManager
+
+class TestApp:public SceneAppFramework
+{
+private:    //plane grid
+
+    Material *          mtl_vertex_lum      =nullptr;
+    MaterialInstance *  mi_plane_grid       =nullptr;
+    Pipeline *          p_line              =nullptr;
+    Primitive *         prim_plane_grid     =nullptr;
+
+private:
+
+    DeviceBuffer *      ubo_sun             =nullptr;
+
+private:    //sphere
+
+    Material *          mtl_blinnphong      =nullptr;
+    MaterialInstance *  mi_blinnphong[4]{};
+    Pipeline *          p_blinnphong        =nullptr;
+
+    Primitive *         prim_sphere         =nullptr;
+    Primitive *         prim_cone           =nullptr;
+    Primitive *         prim_cylinder       =nullptr;
+
+private:
+
+    bool InitVertexLumMP()
+    {
+        mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"VertexLuminance3D",Prim::Lines);
+
+        cfg.local_to_world=true;
+
+        mtl_vertex_lum=db->LoadMaterial("Std3D/VertexLum3D",&cfg);
+        if(!mtl_vertex_lum)return(false);
+
+        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,Prim::Lines);
+
+        if(!p_line)
+            return(false);
+
+        return(true);
+    }
+
+    bool CreateBlinnPhongUBO()
+    {
+        ubo_sun=db->CreateUBO("sun",sizeof(sun_light),&sun_light);
+        if(!ubo_sun)return(false);
+
+        return(true);
+    }
+
+    bool InitBlinnPhongSunLightMP()
+    {
+        mtl::Material3DCreateConfig cfg(device->GetDeviceAttribute(),"BlinnPhong3D",Prim::Triangles);
+
+        cfg.local_to_world=true;
+
+        mtl_blinnphong=db->LoadMaterial("Std3D/BlinnPhong/SunLightPureColor",&cfg);
+        if(!mtl_blinnphong)return(false);
+
+        mtl_blinnphong->BindUBO(DescriptorSetType::Global,"sun",ubo_sun);
+        mtl_blinnphong->Update();
+
+        Color4f mi_data;
+        for(uint i=0;i<4;i++)
+        {
+            mi_data=GetColor4f(AxisColor[i],4);
+
+            mi_blinnphong[i]=db->CreateMaterialInstance(mtl_blinnphong,nullptr,&mi_data);
+            if(!mi_blinnphong[i])return(false);
+        }
+
+        p_blinnphong=CreatePipeline(mtl_blinnphong,InlinePipeline::Solid3D,Prim::Triangles);
+
+        if(!p_blinnphong)
+            return(false);
+
+        return(true);        
+    }
+
+    bool CreateRenderObject()
+    {
+        using namespace inline_geometry;
+
+        //Plane Grid
+        {
+            struct PlaneGridCreateInfo pgci;
+
+            pgci.grid_size.Set(32,32);
+            pgci.sub_count.Set(8,8);
+
+            pgci.lum=0.5;
+            pgci.sub_lum=0.75;
+
+            prim_plane_grid=CreatePlaneGrid(db,mtl_vertex_lum->GetDefaultVIL(),&pgci);
+        }
+
+        //Sphere
+        prim_sphere=CreateSphere(db,mi_blinnphong[0]->GetVIL(),16);
+
+        //Cone
+        {
+            struct ConeCreateInfo cci;
+
+            cci.radius      =1;         //圆锥半径
+            cci.halfExtend  =1;         //圆锤一半高度
+            cci.numberSlices=16;        //圆锥底部分割数
+            cci.numberStacks=8;         //圆锥高度分割数
+
+            prim_cone=CreateCone(db,mi_blinnphong[1]->GetVIL(),&cci);
+        }
+
+        //Cyliner
+        {
+            struct CylinderCreateInfo cci;
+
+            cci.halfExtend  =4;         //圆柱一半高度
+            cci.numberSlices=16;        //圆柱底部分割数
+            cci.radius      =0.25f;     //圆柱半径
+
+            prim_cylinder=CreateCylinder(db,mi_blinnphong[2]->GetVIL(),&cci);
+        }
+
+        return(true);
+    }    
+    
+    Renderable *Add(Primitive *r,MaterialInstance *mi,Pipeline *p,const Matrix4f &mat=Identity4f)
+    {
+        Renderable *ri=db->CreateRenderable(r,mi,p);
+
+        if(!ri)
+        {
+            LOG_ERROR(OS_TEXT("Create Renderable failed."));
+            return(nullptr);
+        }
+
+        render_root.CreateSubNode(mat,ri);
+
+        return ri;
+    }
+
+    bool InitScene()
+    {
+        Add(prim_plane_grid,mi_plane_grid,p_line,Identity4f);
+
+        Add(prim_sphere,    mi_blinnphong[0],p_blinnphong,translate(Vector3f(0,0,2)));
+
+        Add(prim_cone,      mi_blinnphong[1],p_blinnphong);
+        Add(prim_cylinder,  mi_blinnphong[2],p_blinnphong,translate(Vector3f(0,0,-5)));
+
+        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:
+
+    bool Init(uint w,uint h)
+    {        
+        if(!SceneAppFramework::Init(w,h))
+            return(false);
+
+        if(!InitVertexLumMP())
+            return(false);
+        
+        if(!CreateBlinnPhongUBO())
+            return(false);
+
+        if(!InitBlinnPhongSunLightMP())
+            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/LightBasic/CMakeLists.txt

@@ -0,0 +1,13 @@
+macro(CreateProject name)
+    add_executable(${name} ${ARGN} ${VULKAN_APP_FRAMEWORK})
+    target_link_libraries(${name} ${ULRE})
+
+    IF(MSVC)
+        set_target_properties(${name} PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY ${ULRE_RUNTIME_PATH})
+        set_property(TARGET ${name} PROPERTY VS_DPI_AWARE "PerMonitor")
+    ENDIF()
+
+    set_property(TARGET ${name} PROPERTY FOLDER "ULRE/Example/Light Basic")
+endmacro()
+
+CreateProject(01_BlinnPhongDirectionLight           BlinnPhongDirectionLight.cpp)

example/MaterialCreaterTest.cpp

@@ -1,126 +0,0 @@
-#include<hgl/shadergen/MaterialCreateInfo.h>
-
-using namespace hgl;
-using namespace hgl::graph;
-using namespace hgl::shadergen;
-
-bool PureColor2DMaterial()
-{
-    MaterialCreateInfo mc("PureColor2D",1,false);                            //一个新材质，1个RT输出，默认使用Vertex/Fragment shader
-
-    //vertex部分
-    {
-        ShaderCreateInfoVertex *vsc=mc.GetVS();                //获取vertex shader creater
-
-        //以下代码会被展开为
-        /*
-            layout(location=?) in vec3 Position;            //位置属性
-        */
-        vsc->AddInput("vec2","Position");                   //添加一个vec3类型的position属性输入
-
-        vsc->SetShaderCodes(R"(
-void main()
-{
-    gl_Position=vec4(Position,0,1);
-})");
-    }
-
-    //添加一个名称为ColorMaterial的UBO定义,其内部有一个vec4 color的属性
-    //该代码会被展开为
-    /*
-        struct ColorMaterial
-        {
-            vec4 color;
-        };
-     */
-    mc.AddStruct("ColorMaterial","vec4 color;");
-
-    //添加一个UBO，该代码会被展开为
-    /*
-        layout(set=?,binding=?) uniform ColorMaterial mtl;
-    */
-    mc.AddUBO(  VK_SHADER_STAGE_FRAGMENT_BIT,               //这个UBO出现在fragment shader
-                DescriptorSetType::PerMaterial,             //它属于材质合集
-                "ColorMaterial",                            //UBO名称为ColorMaterial
-                "mtl");                                     //UBO变量名称为mtl
-
-    //fragment部分
-    {
-        ShaderCreateInfoFragment *fsc=mc.GetFS();              //获取fragment shader creater
-
-        //以下代码会被展开为
-        /*
-            layout(location=?) out vec4 Color;              //颜色输出
-        */
-        fsc->AddOutput("vec4","Color");                     //添加一个vec4类型的color属性输出
-
-        fsc->SetShaderCodes(R"(
-void main()
-{
-    Color=mtl.color;
-})");
-    }
-
-    mc.CreateShader();
-
-    return(true);
-}
-
-bool VertexColor2DMaterial()
-{
-    MaterialCreateInfo mc("VertexColor2D",1,false);
-
-    //vertex部分
-    {
-        ShaderCreateInfoVertex *vsc=mc.GetVS();
-
-        vsc->AddInput("vec2","Position");
-        vsc->AddInput("vec4","Color");
-
-        vsc->AddOutput("vec4","Color");
-
-        vsc->SetShaderCodes(R"(
-void main()
-{
-    Output.Color=Color;
-
-    gl_Position=vec4(Position,0,1);
-})");
-    }
-
-    //fragment部分
-    {
-        ShaderCreateInfoFragment *fsc=mc.GetFS();
-
-        fsc->AddOutput("vec4","Color");
-
-        fsc->SetShaderCodes(R"(
-void main()
-{
-    Color=Input.Color;
-})");
-    }
-
-    mc.CreateShader();
-
-    return(true);
-}
-
-namespace glsl_compiler
-{
-    bool Init();
-    void Close();
-}//namespace glsl_compiler
-
-int main()
-{
-    if(!glsl_compiler::Init())
-        return -1;
-
-    PureColor2DMaterial();
-    VertexColor2DMaterial();
-
-    glsl_compiler::Close();
-
-    return 0;
-}

example/Texture/texture_quad.cpp

@@ -5,7 +5,7 @@
 #include<hgl/graph/VKSampler.h>
 #include<hgl/graph/VKInlinePipeline.h>
 #include<hgl/graph/VKRenderablePrimitiveCreater.h>
-#include<hgl/graph/mtl/2d/Material2DCreateConfig.h>
+#include<hgl/graph/mtl/Material2DCreateConfig.h>
 #include<hgl/math/Math.h>
 
 using namespace hgl;
@@ -56,9 +56,7 @@ private:
         cfg.coordinate_system=CoordinateSystem2D::NDC;
         cfg.local_to_world=false;
 
-        AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreatePureTexture2D(&cfg);
-
-        material=db->CreateMaterial(mci);
+        material=db->LoadMaterial("Std2D/PureTexture2D",&cfg);
 
         if(!material)
             return(false);
@@ -87,7 +85,7 @@ private:
 
     bool InitVBO()
     {
-        RenderablePrimitiveCreater rpc(db,VERTEX_COUNT);
+        RenderablePrimitiveCreater rpc(db,"Quad",VERTEX_COUNT);
 
         if(!rpc.SetVBO(VAN::Position,   VF_V2F, position_data))return(false);
         if(!rpc.SetVBO(VAN::TexCoord,   VF_V2F, tex_coord_data))return(false);
@@ -114,7 +112,7 @@ public:
         return(true);
     }
 
-    void Resize(int w,int h)override
+    void Resize(uint w,uint h)override
     {
         VulkanApplicationFramework::Resize(w,h);
         

example/Texture/texture_rect.cpp

@@ -5,7 +5,7 @@
 #include<hgl/graph/VKSampler.h>
 #include<hgl/graph/VKInlinePipeline.h>
 #include<hgl/graph/VKRenderablePrimitiveCreater.h>
-#include<hgl/graph/mtl/2d/Material2DCreateConfig.h>
+#include<hgl/graph/mtl/Material2DCreateConfig.h>
 #include<hgl/math/Math.h>
 
 using namespace hgl;
@@ -52,9 +52,7 @@ private:
         cfg.coordinate_system=CoordinateSystem2D::ZeroToOne;
         cfg.local_to_world=false;
 
-        AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreateRectTexture2D(&cfg);
-
-        material=db->CreateMaterial(mci);
+        material=db->LoadMaterial("Std2D/RectTexture2D",&cfg);
 
         if(!material)
             return(false);
@@ -83,7 +81,7 @@ private:
 
     bool InitVBO()
     {
-        RenderablePrimitiveCreater rpc(db,1);
+        RenderablePrimitiveCreater rpc(db,"Rectangle",1);
 
         if(!rpc.SetVBO(VAN::Position,VF_V4F,position_data))return(false);
         if(!rpc.SetVBO(VAN::TexCoord,VF_V4F,tex_coord_data))return(false);
@@ -110,7 +108,7 @@ public:
         return(true);
     }
 
-    void Resize(int w,int h)override
+    void Resize(uint w,uint h)override
     {
         VulkanApplicationFramework::Resize(w,h);
         

example/Texture/texture_rect_array.cpp

@@ -5,7 +5,7 @@
 #include<hgl/graph/VKSampler.h>
 #include<hgl/graph/VKInlinePipeline.h>
 #include<hgl/graph/VKRenderablePrimitiveCreater.h>
-#include<hgl/graph/mtl/2d/Material2DCreateConfig.h>
+#include<hgl/graph/mtl/Material2DCreateConfig.h>
 #include<hgl/math/Math.h>
 #include<hgl/filesystem/Filename.h>
 
@@ -67,7 +67,8 @@ private:
 
     bool InitTexture()
     {
-        texture=db->CreateTexture2DArray(   512,512,            ///<纹理尺寸
+        texture=db->CreateTexture2DArray(   "freepik icons",
+                                            512,512,            ///<纹理尺寸
                                             TexCount,           ///<纹理层数
                                             PF_BC1_RGBAUN,      ///<纹理格式
                                             false);             ///<是否自动产生mipmaps
@@ -94,9 +95,7 @@ private:
         cfg.coordinate_system=CoordinateSystem2D::ZeroToOne;
         cfg.local_to_world=true;
 
-        AutoDelete<mtl::MaterialCreateInfo> mci=mtl::CreateRectTexture2DArray(&cfg);
-
-        material=db->CreateMaterial(mci);
+        material=db->LoadMaterial("Std2D/RectTexture2DArray",&cfg);
 
         if(!material)
             return(false);
@@ -129,7 +128,7 @@ private:
 
     bool InitVBOAndRenderList()
     {
-        RenderablePrimitiveCreater rpc(db,1);
+        RenderablePrimitiveCreater rpc(db,"Rectangle",1);
 
         position_data[2]=1.0f/float(TexCount);
 
@@ -185,7 +184,7 @@ public:
         return(true);
     }
 
-    void Resize(int w,int h)override
+    void Resize(uint w,uint h)override
     {
         VulkanApplicationFramework::Resize(w,h);
         

example/Vulkan/RayPicking.cpp

@@ -1,191 +0,0 @@
-// 18.RayPicking
-
-#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/Ray.h>
-#include<hgl/graph/VKVertexAttribBuffer.h>
-
-using namespace hgl;
-using namespace hgl::graph;
-
-constexpr uint32_t SCREEN_WIDTH=1280;
-constexpr uint32_t SCREEN_HEIGHT=720;
-
-static float position_data[2][3]=
-{
-    {100,100,100},
-    {0,0,0}
-};
-
-static float color_data[2][4]=
-{
-    {1,1,0,1},
-    {1,1,0,1}
-};
-
-class TestApp:public CameraAppFramework
-{
-    Color4f color;
-
-    DeviceBuffer *ubo_color=nullptr;
-
-private:
-
-    SceneNode           render_root;
-    RenderList *        render_list         =nullptr;
-
-    Material *          material            =nullptr;
-    MaterialInstance *  material_instance   =nullptr;
-    Pipeline *          pipeline            =nullptr;
-
-    Primitive *        ro_plane_grid       =nullptr;
-
-    Primitive *        ro_line             =nullptr;
-
-    VBO *               vbo_pos             =nullptr;
-
-    Ray                 ray;
-
-private:
-
-    bool InitMDP()
-    {
-        material=db->CreateMaterial(OS_TEXT("res/material/VertexColor3D"));
-        if(!material)return(false);
-
-        material_instance=db->CreateMaterialInstance(material);
-        if(!material_instance)return(false);
-        
-        pipeline=CreatePipeline(material_instance,InlinePipeline::Solid3D,Prim::Lines);
-        if(!pipeline)
-            return(false);
-
-        return(true);
-    }
-    
-    Renderable *Add(Primitive *r,const Matrix4f &mat)
-    {
-        Renderable *ri=db->CreateRenderable(r,material_instance,pipeline);
-
-        render_root.CreateSubNode(mat,ri);
-
-        return ri;
-    }
-
-    bool CreateRenderObject()
-    {
-        using namespace inline_geometry;
-
-        {
-            struct PlaneGridCreateInfo pgci;
-
-            pgci.coord[0]=Vector3f(-100,-100,0);
-            pgci.coord[1]=Vector3f( 100,-100,0);
-            pgci.coord[2]=Vector3f( 100, 100,0);
-            pgci.coord[3]=Vector3f(-100, 100,0);
-
-            pgci.step.x=32;
-            pgci.step.y=32;
-
-            pgci.side_step.x=8;
-            pgci.side_step.y=8;
-
-            pgci.color.Set(0.25,0,0,1);
-            pgci.side_color.Set(1,0,0,1);
-
-            const VIL *vil=material_instance->GetVIL();
-
-            ro_plane_grid=CreatePlaneGrid(db,vil,&pgci);
-        }
-
-        {
-            ro_line=db->CreatePrimitive(2);
-            if(!ro_line)return(false);
-            
-            if(!ro_line->Set(VAN::Position,  vbo_pos=db->CreateVBO(VF_V3F,2,position_data   )))return(false);
-            if(!ro_line->Set(VAN::Color,         db->CreateVBO(VF_V4F,2,color_data      )))return(false);
-        }
-
-        return(true);
-    }
-
-    bool InitScene()
-    {
-        Add(ro_plane_grid,Matrix4f(1.0f));
-        Add(ro_line,Matrix4f(1.0f));
-
-        camera->pos=Vector3f(100,100,50);
-        camera_control->SetTarget(Vector3f(0,0,0));
-        camera_control->Refresh();
-
-        render_root.RefreshMatrix();
-        render_list->Expend(camera->info,&render_root);
-
-        return(true);
-    }
-
-public:
-
-    ~TestApp()
-    {
-        SAFE_CLEAR(render_list);
-    }
-
-    bool Init()
-    {
-        if(!CameraAppFramework::Init(SCREEN_WIDTH,SCREEN_HEIGHT))
-            return(false);
-            
-        render_list=new RenderList(device);
-
-        if(!InitMDP())
-            return(false);
-
-        if(!CreateRenderObject())
-            return(false);
-
-        if(!InitScene())
-            return(false);
-
-        return(true);
-    }
-
-    void BuildCommandBuffer(uint32 index)
-    {
-        const CameraInfo &ci=GetCameraInfo();
-
-        ray.Set(GetMouseCoord(),&ci);                           //设置射线查询的屏幕坐标点
-
-        const Vector3f pos=ray.ClosestPoint(Vector3f(0,0,0));   //求射线上与点(0,0,0)最近的点的坐标
-
-        vbo_pos->Write(&pos,3*sizeof(float));                   //更新VBO上这个点的位置
-
-        render_root.RefreshMatrix();
-        render_list->Expend(ci,&render_root);
-
-        VulkanApplicationFramework::BuildCommandBuffer(index,render_list);
-    }
-
-    void Resize(int w,int h)override
-    {
-        CameraAppFramework::Resize(w,h);
-        
-        VulkanApplicationFramework::BuildCommandBuffer(render_list);
-    }
-};//class TestApp:public CameraAppFramework
-
-int main(int,char **)
-{
-    TestApp app;
-
-    if(!app.Init())
-        return(-1);
-
-    while(app.Run());
-
-    return 0;
-}

example/common/VulkanAppFramework.h

@@ -19,6 +19,9 @@
 #include<hgl/graph/VKMaterialInstance.h>
 #include<hgl/graph/VKRenderTarget.h>
 #include<hgl/graph/VKRenderResource.h>
+#ifdef _DEBUG
+#include<hgl/graph/VKDeviceAttribute.h>
+#endif//_DEBUG
 #include<hgl/graph/RenderList.h>
 #include<hgl/graph/mtl/UBOCommon.h>
 #include<hgl/color/Color.h>
@@ -87,14 +90,14 @@ public:
         SAFE_CLEAR(inst);
     }
 
-    virtual bool Init(int w,int h)
+    virtual bool Init(uint w,uint h)
     {
         logger::InitLogger(OS_TEXT("VulkanTest"));
 
         if(!InitShaderCompiler())
             return(false);
 
-        clear_color.Set(0,0,0,1);
+        SetClearColor(COLOR::MozillaCharcoal);
 
     #ifdef _DEBUG
         if(!CheckStrideBytesByFormat())
@@ -126,10 +129,16 @@ public:
                 return(false);
         }
 
-        device=CreateRenderDevice(inst,win);
+        {
+            VulkanHardwareRequirement vh_req;
 
-        if(!device)
-            return(false);
+            vh_req.wide_lines=true;
+
+            device=CreateRenderDevice(inst,win,&vh_req);
+
+            if(!device)
+                return(false);
+        }
 
         device_render_pass=device->GetRenderPass();
 
@@ -142,20 +151,30 @@ public:
         {
             vp_info.Set(w,h);
 
-            ubo_vp_info=db->CreateUBO(sizeof(ViewportInfo),&vp_info);
+            ubo_vp_info=db->CreateUBO("Viewport",sizeof(ViewportInfo),&vp_info);
 
-            db->global_descriptor.AddUBO(mtl::SBS_ViewportInfo.name,ubo_vp_info);
+            db->static_descriptor.AddUBO(mtl::SBS_ViewportInfo.name,ubo_vp_info);
         }
 
         return(true);
     }
 
-    virtual void Resize(int w,int h)
+    virtual void Resize(uint w,uint h)
     {
         vp_info.Set(w,h);
         ubo_vp_info->Write(&vp_info);
     }
 
+    ViewportInfo &GetViewportInfo()
+    {
+        return vp_info;
+    }
+
+    DeviceBuffer *GetViewportInfoBuffer()
+    {
+        return ubo_vp_info;
+    }
+
     void SetClearColor(const Color4f &cc)
     {
         clear_color=cc;
@@ -189,7 +208,7 @@ 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();
+                cmd_buf[i]=device->CreateRenderCommandBuffer(device->GetPhysicalDevice()->GetDeviceName()+AnsiString(":RenderCmdBuffer_")+AnsiString::numberOf(i));
         }
     }
 
@@ -277,7 +296,22 @@ public:
     }
 
     template<typename ...ARGS>
-    Pipeline *CreatePipeline(ARGS...args){return device_render_pass->CreatePipeline(args...);}
+    Pipeline *CreatePipeline(ARGS...args)
+    {
+        Pipeline *p=device_render_pass->CreatePipeline(args...);
+
+        if(!p)
+            return(nullptr);
+
+    #ifdef _DEBUG
+        DebugUtils *du=device->GetDebugUtils();
+        
+        if(du)
+            du->SetPipeline(*p,"Pipeline:"+p->GetName());
+    #endif//_DEBUG
+
+        return p;
+    }
 
 public:
 
@@ -368,7 +402,7 @@ class CameraMouseControl:public MouseEvent
     Vector2f mouse_pos;
     Vector2f mouse_last_pos;
 
-protected:    
+protected:
 
     bool OnPressed(int x,int y,MouseButton) override
     {
@@ -426,6 +460,7 @@ public:
     {
         camera=wc;
         cur_time=0;
+        last_time=0;
     }
 
     const Vector2f &GetMouseCoord()const{return mouse_pos;}
@@ -438,7 +473,6 @@ public:
 
 class CameraAppFramework:public VulkanApplicationFramework
 {
-
 protected:
 
     Camera *                camera                      =nullptr;
@@ -461,7 +495,7 @@ public:
         SAFE_CLEAR(camera);
     }
 
-    virtual bool Init(int w,int h)
+    virtual bool Init(uint w,uint h) override
     {
         if(!VulkanApplicationFramework::Init(w,h))
             return(false);
@@ -472,6 +506,10 @@ public:
 
     virtual void InitCamera(int w,int h)
     {
+        camera=new Camera;
+
+        camera->pos=Vector3f(10,10,10);
+
         camera_control=new FirstPersonCameraControl(&vp_info,camera);
 
         camera_control->Refresh();      //更新矩阵计算
@@ -482,16 +520,14 @@ public:
         win->Join(ckc);
         win->Join(cmc);
 
-        camera=new Camera;
-
-        camera->pos=Vector3f(10,10,10);
-
         RefreshCameraInfo(&camera_control->GetCameraInfo(),&vp_info,camera);
         
-        ubo_camera_info=db->CreateUBO(sizeof(CameraInfo),&camera_control->GetCameraInfo());
+        ubo_camera_info=db->CreateUBO("CameraInfo",sizeof(CameraInfo),&camera_control->GetCameraInfo());
+
+        db->global_descriptor.AddUBO(mtl::SBS_CameraInfo.name,ubo_camera_info);
     }
 
-    void Resize(int w,int h)override
+    void Resize(uint w,uint h)override
     {
         vp_info.Set(w,h);
 
@@ -500,7 +536,7 @@ public:
         ubo_camera_info->Write(&camera_control->GetCameraInfo());
     }
 
-    const CameraInfo &GetCameraInfo()
+    CameraInfo &GetCameraInfo()
     {
         return camera_control->GetCameraInfo();
     }
@@ -510,11 +546,6 @@ public:
         return ubo_camera_info;
     }
 
-    bool BindCameraUBO(Material *mtl)
-    {
-        return mtl->BindUBO(DescriptorSetType::Global,"g_camera",ubo_camera_info);
-    }
-
     virtual void BuildCommandBuffer(uint32_t index)=0;
 
     virtual void Draw()override
@@ -532,4 +563,55 @@ public:
         ckc->Update();
         cmc->Update();
     }
-};//class CameraAppFramework
+};//class CameraAppFramework
+
+class SceneAppFramework:public CameraAppFramework
+{
+protected:
+
+    SceneNode           render_root;
+    RenderList *        render_list         =nullptr;
+
+public:
+
+    SceneAppFramework()=default;
+
+    virtual ~SceneAppFramework()
+    {
+        SAFE_CLEAR(render_list);
+    }
+
+    virtual bool Init(uint width,uint height) override
+    {
+        if(!CameraAppFramework::Init(width,height))
+            return(false);
+            
+        render_list=new RenderList(device);
+
+        return(true);
+    }
+
+    virtual void BuildCommandBuffer(uint32 index) override
+    {
+        VulkanApplicationFramework::BuildCommandBuffer(index,render_list);
+    }
+
+    virtual void Resize(uint w,uint h) override
+    {
+        CameraAppFramework::Resize(w,h);
+        
+        VulkanApplicationFramework::BuildCommandBuffer(render_list);
+    }
+};//class SceneAppFramework:public CameraAppFramework
+
+template<typename T> int RunApp(uint w,uint h)
+{
+    T app;
+
+    if(!app.Init(w,h))
+        return(-1);
+
+    while(app.Run());
+
+    return 0;
+}

inc/hgl/graph/InlineGeometry.h

@@ -4,6 +4,7 @@
 #include<hgl/graph/VK.h>
 #include<hgl/math/Vector.h>
 #include<hgl/type/RectScope.h>
+#include<hgl/type/Size2.h>
 #include<hgl/color/Color4f.h>
 #include<hgl/graph/AABB.h>
 namespace hgl
@@ -59,17 +60,17 @@ namespace hgl
             Primitive *CreateCircle(RenderResource *db,const VIL *vil,const CircleCreateInfo *cci);
 
             /**
-             * 平面网格创建信息
+             * 平面网格创建信息<br>
+             * 会创建一个在XY平面上居中的网格，单个格子尺寸为1。
              */
             struct PlaneGridCreateInfo
             {
-                Vector3f coord[4];
-                Vector2u step;
+                Size2u grid_size;       ///<格子数量
 
-                Vector2u side_step;   //到边界的步数
+                Size2u sub_count;       ///<细分格子数量
 
-                Color4f color;          //一般线条颜色
-                Color4f side_color;     //边界线条颜色
+                float lum;              ///<一般线条颜色
+                float sub_lum;          ///<细分及边界线条颜色
             };//struct PlaneGridCreateInfo
 
             /**
@@ -77,23 +78,10 @@ namespace hgl
              */
             Primitive *CreatePlaneGrid(RenderResource *db,const VIL *vil,const PlaneGridCreateInfo *pgci);
 
-            struct PlaneCreateInfo
-            {
-                Vector2f tile;
-
-            public:
-
-                PlaneCreateInfo()
-                {
-                    tile.x=1.0f;
-                    tile.y=1.0f;
-                }
-            };//struct PlaneCreateInfo
-
             /**
              * 创建一个平面(三角形)
              */
-            Primitive *CreatePlane(RenderResource *db,const VIL *vil,const PlaneCreateInfo *pci);
+            Primitive *CreatePlane(RenderResource *db,const VIL *vil);
 
             struct CubeCreateInfo
             {

inc/hgl/graph/Light.h

@@ -2,7 +2,7 @@
 #define HGL_GRAPH_LIGHT_INCLUDE
 
 #include<hgl/math/Math.h>
-#include<hgl/type/Color4f.h>
+#include<hgl/color/Color4f.h>
 namespace hgl
 {
     namespace graph

inc/hgl/graph/MaterialRenderList.h

@@ -13,7 +13,7 @@ class MaterialRenderList
     GPUDevice *device;
     RenderCmdBuffer *cmd_buf;
 
-    Material *mtl;
+    Material *material;
 
     RenderNodeList rn_list;
 
@@ -46,12 +46,10 @@ protected:
 
             VBOList *           vbo_list;
 
-    const   VIL *               last_vil;
             Pipeline *          last_pipeline;
     const   VertexInputData *   last_vid;
             uint                last_index;
 
-    void Bind(MaterialInstance *);
     bool Bind(const VertexInputData *,const uint);
 
     void Render(RenderItem *);

inc/hgl/graph/PrimitiveCreater.h

@@ -78,7 +78,7 @@ namespace hgl
                     uint16 *                CreateIBO16(uint count,const uint16 *data=nullptr);                         ///<创建16位的索引缓冲区
                     uint32 *                CreateIBO32(uint count,const uint32 *data=nullptr);                         ///<创建32位的索引缓冲区
 
-            virtual Primitive *             Finish();                                                                   ///<结束并创建可渲染对象
+            virtual Primitive *             Finish(const AnsiString &);                                                                   ///<结束并创建可渲染对象
         };//class PrimitiveCreater
     }//namespace graph
 }//namespace hgl

inc/hgl/graph/SceneNode.h

@@ -60,6 +60,9 @@ namespace hgl
 
             SceneNode *CreateSubNode(Renderable *ri)
             {
+                if(!ri)
+                    return(nullptr);
+
                 SceneNode *sn=new SceneNode(ri);
 
                 SubNode.Add(sn);
@@ -76,6 +79,9 @@ namespace hgl
 
             SceneNode *CreateSubNode(const Matrix4f &mat,Renderable *ri)
             {
+                if(!ri)
+                    return(nullptr);
+
                 SceneNode *sn=new SceneNode(mat,ri);
 
                 SubNode.Add(sn);

inc/hgl/graph/VK.h

@@ -26,7 +26,9 @@ constexpr size_t VK_DESCRIPTOR_TYPE_RANGE_SIZE=VK_DESCRIPTOR_TYPE_END_RANGE-VK_D
 #endif//VK_DESCRIPTOR_TYPE_RANGE_SIZE
 
 using CharPointerList=hgl::List<const char *>;
-using BindingMapping=Map<uint32_t,int>;
+
+using BindingMap        =Map<AnsiString,int>;
+using BindingMapArray   =BindingMap[VK_DESCRIPTOR_TYPE_RANGE_SIZE];
 
 class VulkanInstance;
 class GPUPhysicalDevice;
@@ -142,21 +144,14 @@ enum IndexType:uint
     U16=0,
     U32,
     U8=VK_INDEX_TYPE_UINT8_EXT,
+
+    ERR=VK_INDEX_TYPE_MAX_ENUM
 };
 
-/**
- * max-lengths:
- *
-        256 bytes:  nvidia,arm
-        128 bytes:  amd,intel,powervr,adreno
- */
-struct PushConstant
-{
-    Matrix4f local_to_world;
-    Matrix4f normal;
-};
-
-constexpr uint32_t MAX_PUSH_CONSTANT_BYTES=sizeof(PushConstant);
+//Push Constant max-lengths:
+//
+//    256 bytes:  nvidia,arm
+//    128 bytes:  amd,intel,powervr,adreno
 
 inline void copy(VkExtent3D &e3d,const VkExtent2D &e2d,const uint32 depth=1)
 {

inc/hgl/graph/VKBuffer.h

@@ -36,6 +36,7 @@ public:
 
             VkBuffer                    GetBuffer       ()const{return buf.buffer;}
             DeviceMemory *              GetMemory       ()const{return buf.memory;}
+            VkDeviceMemory              GetVkMemory     ()const{return buf.memory->operator VkDeviceMemory();}
     const   VkDescriptorBufferInfo *    GetBufferInfo   ()const{return &buf.info;}
 
             void *  Map     ()                                              {return buf.memory->Map();}

inc/hgl/graph/VKCommandBuffer.h

@@ -43,9 +43,7 @@ class RenderCmdBuffer:public GPUCmdBuffer
     VkClearValue *clear_values;
     VkRect2D render_area;
     VkViewport viewport;
-
-    float default_line_width;
-    
+   
     Framebuffer *fbo;
     RenderPassBeginInfo rp_begin;
     VkPipelineLayout pipeline_layout;
@@ -179,8 +177,6 @@ public:
     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);}
 
-    void SetLineWidth       (float line_width)                                      {vkCmdSetLineWidth(cmd_buf,line_width);}
-
     void SetDepthBias       (float constant_factor,float clamp,float slope_factor)  {vkCmdSetDepthBias(cmd_buf,constant_factor,clamp,slope_factor);}
     void SetDepthBounds     (float min_db,float max_db)                             {vkCmdSetDepthBounds(cmd_buf,min_db,max_db);}
     void SetBlendConstants  (const float constants[4])                              {vkCmdSetBlendConstants(cmd_buf,constants);}

inc/hgl/graph/VKDebugMaker.h

@@ -1,86 +0,0 @@
-#ifndef HGL_GRAPH_VULKAN_DEBUG_MAKER_INCLUDE
-#define HGL_GRAPH_VULKAN_DEBUG_MAKER_INCLUDE
-
-#include<hgl/graph/VK.h>
-#include<hgl/color/Color4f.h>
-
-VK_NAMESPACE_BEGIN
-struct DebugMakerFunction
-{
-    PFN_vkDebugMarkerSetObjectTagEXT	SetObjectTag;
-    PFN_vkDebugMarkerSetObjectNameEXT	SetObjectName;
-    PFN_vkCmdDebugMarkerBeginEXT		Begin;
-    PFN_vkCmdDebugMarkerEndEXT			End;
-    PFN_vkCmdDebugMarkerInsertEXT		Insert;
-};//struct DebugMakerFunction
-
-class DebugMaker
-{
-    VkDevice device;
-    
-    DebugMakerFunction dmf;
-
-protected:
-
-    void SetObjectName(uint64_t object, VkDebugReportObjectTypeEXT objectType, const char *name);
-    void SetObjectTag(uint64_t object, VkDebugReportObjectTypeEXT objectType, uint64_t name, size_t tagSize, const void* tag);
-
-private:
-
-    friend DebugMaker *CreateDebugMaker(VkDevice device);
-
-    DebugMaker(VkDevice dev,const DebugMakerFunction &f)
-    {
-        device=dev;
-        dmf=f;
-    }
-
-public:
-    
-    void Begin(VkCommandBuffer cmdbuffer, const char * pMarkerName, const Color4f &color);
-    void Insert(VkCommandBuffer cmdbuffer, const char *markerName, const Color4f &color);
-    void End(VkCommandBuffer cmdBuffer);
-    
-    #define DEBUG_MAKER_SET_FUNC(type,MNAME)	void Set##type(Vk##type obj,const char *name){SetObjectName((uint64_t)obj,VK_DEBUG_REPORT_OBJECT_TYPE_##MNAME##_EXT,name);}
-
-    DEBUG_MAKER_SET_FUNC(Instance,                  INSTANCE)
-    DEBUG_MAKER_SET_FUNC(PhysicalDevice,            PHYSICAL_DEVICE)
-    DEBUG_MAKER_SET_FUNC(Device,                    DEVICE)
-    DEBUG_MAKER_SET_FUNC(Queue,					    QUEUE)
-    DEBUG_MAKER_SET_FUNC(Semaphore,				    SEMAPHORE)
-    DEBUG_MAKER_SET_FUNC(CommandBuffer,			    COMMAND_BUFFER)
-    DEBUG_MAKER_SET_FUNC(Fence,					    FENCE)
-    DEBUG_MAKER_SET_FUNC(DeviceMemory,			    DEVICE_MEMORY)
-    DEBUG_MAKER_SET_FUNC(Buffer,				    BUFFER)
-    DEBUG_MAKER_SET_FUNC(Image,					    IMAGE)
-    DEBUG_MAKER_SET_FUNC(Event,					    EVENT)
-    DEBUG_MAKER_SET_FUNC(QueryPool,				    QUERY_POOL)
-    DEBUG_MAKER_SET_FUNC(BufferView,			    BUFFER_VIEW)
-    DEBUG_MAKER_SET_FUNC(ShaderModule,			    SHADER_MODULE)
-    DEBUG_MAKER_SET_FUNC(PipelineCache,		        PIPELINE_CACHE)
-    DEBUG_MAKER_SET_FUNC(PipelineLayout,		    PIPELINE_LAYOUT)
-    DEBUG_MAKER_SET_FUNC(RenderPass,			    RENDER_PASS)
-    DEBUG_MAKER_SET_FUNC(Pipeline,				    PIPELINE)
-    DEBUG_MAKER_SET_FUNC(DescriptorSetLayout,	    DESCRIPTOR_SET_LAYOUT)        
-    DEBUG_MAKER_SET_FUNC(Sampler,				    SAMPLER)
-    DEBUG_MAKER_SET_FUNC(DescriptorPool,		    DESCRIPTOR_POOL)
-    DEBUG_MAKER_SET_FUNC(DescriptorSet,			    DESCRIPTOR_SET)
-    DEBUG_MAKER_SET_FUNC(Framebuffer,			    FRAMEBUFFER)
-    DEBUG_MAKER_SET_FUNC(CommandPool,               COMMAND_POOL)
-    DEBUG_MAKER_SET_FUNC(SurfaceKHR,                SURFACE_KHR)
-    DEBUG_MAKER_SET_FUNC(SwapchainKHR,              SWAPCHAIN_KHR)
-    DEBUG_MAKER_SET_FUNC(DebugReportCallbackEXT,    DEBUG_REPORT_CALLBACK_EXT)
-    DEBUG_MAKER_SET_FUNC(DisplayKHR,                DISPLAY_KHR)
-    DEBUG_MAKER_SET_FUNC(DisplayModeKHR,            DISPLAY_MODE_KHR)
-    DEBUG_MAKER_SET_FUNC(ValidationCacheEXT,        VALIDATION_CACHE_EXT)
-    DEBUG_MAKER_SET_FUNC(SamplerYcbcrConversion,    SAMPLER_YCBCR_CONVERSION)
-    DEBUG_MAKER_SET_FUNC(DescriptorUpdateTemplate,  DESCRIPTOR_UPDATE_TEMPLATE)
-    DEBUG_MAKER_SET_FUNC(CuModuleNVX,               CU_MODULE_NVX)
-    DEBUG_MAKER_SET_FUNC(CuFunctionNVX,             CU_FUNCTION_NVX)
-    DEBUG_MAKER_SET_FUNC(AccelerationStructureKHR,  ACCELERATION_STRUCTURE_KHR)
-    DEBUG_MAKER_SET_FUNC(AccelerationStructureNV,   ACCELERATION_STRUCTURE_NV)
-        
-    #undef DEBUG_MAKER_SET_FUNC
-};//class DebugMaker
-VK_NAMESPACE_END
-#endif//HGL_GRAPH_VULKAN_DEBUG_MAKER_INCLUDE

inc/hgl/graph/VKDescriptorBindingManage.h

@@ -1,8 +1,9 @@
-#ifndef HGL_GRAPH_DESCRIPTOR_BINDING_MANAGE_INCLUDE
+#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/VK.h>
 #include<hgl/graph/VKDescriptorSetType.h>
 namespace hgl
 {
@@ -11,10 +12,15 @@ namespace hgl
         class DeviceBuffer;
         class Texture;
         class Material;
+        class MaterialParameters;
 
+        /**
+         * 描述符绑定器<Br>
+         * 一般用于注册通用数据，为材质进行自动绑定。
+         */
         class DescriptorBinding
         {
-            DescriptorSetType set_type;
+            DescriptorSetType set_type;                     ///<描述符合集类型
 
             Map<AnsiString,DeviceBuffer *> ubo_map;
             Map<AnsiString,DeviceBuffer *> ssbo_map;
@@ -93,6 +99,12 @@ namespace hgl
                 texture_map.DeleteByValue(tex);
             }
 
+        private:
+
+            void BindUBO(MaterialParameters *,const BindingMap &,bool dynamic);
+
+        public:
+
             bool Bind(Material *);
         };//class DescriptorBinding
     }//namespace graph

inc/hgl/graph/VKDevice.h

@@ -47,7 +47,7 @@ private:
 
 private:
 
-    VkCommandBuffer CreateCommandBuffer();
+    VkCommandBuffer CreateCommandBuffer(const AnsiString &);
 
     bool CreateSwapchainFBO(Swapchain *);
 
@@ -85,6 +85,8 @@ public:
 
                 void                WaitIdle            ()const {vkDeviceWaitIdle(attr->device);}
 
+                DebugUtils *        GetDebugUtils       (){return attr->debug_utils;}
+
 public:
 
                 bool                Resize              (const VkExtent2D &);
@@ -212,8 +214,8 @@ public: //shader & material
 
 public: //Command Buffer 相关
 
-    RenderCmdBuffer * CreateRenderCommandBuffer();
-    TextureCmdBuffer *CreateTextureCommandBuffer();
+    RenderCmdBuffer * CreateRenderCommandBuffer(const AnsiString &);
+    TextureCmdBuffer *CreateTextureCommandBuffer(const AnsiString &);
     
 public:
 

inc/hgl/graph/VKDeviceAttribute.h

@@ -4,7 +4,6 @@
 #include<hgl/graph/VKTexture.h>
 
 #ifdef _DEBUG
-#include<hgl/graph/VKDebugMaker.h>
 #include<hgl/graph/VKDebugUtils.h>
 #endif//_DEBUG
 
@@ -48,7 +47,6 @@ struct GPUDeviceAttribute
     VkPipelineCache                     pipeline_cache  =VK_NULL_HANDLE;
 
 #ifdef _DEBUG
-    DebugMaker *                        debug_maker     =nullptr;
     DebugUtils *                        debug_utils     =nullptr;
 #endif//_DEBUG
 

inc/hgl/graph/VKDeviceCreater.h

@@ -247,10 +247,10 @@ public:
 
     VulkanDeviceCreater(VulkanInstance *vi,
                         Window *win,
+                        const VulkanHardwareRequirement *req,
                         const PreferFormats *spf_color,
                         const PreferColorSpaces *spf_color_space,
-                        const PreferFormats *spf_depth,
-                        const VulkanHardwareRequirement *req);
+                        const PreferFormats *spf_depth);
 
     virtual bool ChoosePhysicalDevice();
 
@@ -267,12 +267,12 @@ public:
 
 inline GPUDevice *CreateRenderDevice(   VulkanInstance *vi,
                                         Window *win,
+                                        const VulkanHardwareRequirement *req=nullptr,
                                         const PreferFormats *       spf_color       =&PreferSDR,
                                         const PreferColorSpaces *   spf_color_space =&PreferNonlinear,
-                                        const PreferFormats *       spf_depth       =&PreferDepth,
-                                        const VulkanHardwareRequirement *req=nullptr)
+                                        const PreferFormats *       spf_depth       =&PreferDepth)
 {
-    VulkanDeviceCreater vdc(vi,win,spf_color,spf_color_space,spf_depth,req);
+    VulkanDeviceCreater vdc(vi,win,req,spf_color,spf_color_space,spf_depth);
 
     return vdc.Create();
 }
@@ -281,34 +281,34 @@ inline GPUDevice *CreateRenderDeviceLDR(VulkanInstance *vi,
                                         Window *win,
                                         const VulkanHardwareRequirement *req=nullptr)
 {
-    return CreateRenderDevice(vi,win,&PreferLDR,&PreferNonlinear,&PreferDepth,req);
+    return CreateRenderDevice(vi,win,req,&PreferLDR,&PreferNonlinear,&PreferDepth);
 }
 
 inline GPUDevice *CreateRenderDeviceSDR(VulkanInstance *vi,
                                         Window *win,
                                         const VulkanHardwareRequirement *req=nullptr)
 {
-    return CreateRenderDevice(vi,win,&PreferSDR,&PreferNonlinear,&PreferDepth,req);
+    return CreateRenderDevice(vi,win,req,&PreferSDR,&PreferNonlinear,&PreferDepth);
 }
 
 inline GPUDevice *CreateRenderDeviceHDR16(  VulkanInstance *vi,
                                             Window *win,
                                             const VulkanHardwareRequirement *req=nullptr)
 {
-    return CreateRenderDevice(vi,win,&PreferHDR16,&PreferLinear,&PreferDepth,req);
+    return CreateRenderDevice(vi,win,req,&PreferHDR16,&PreferLinear,&PreferDepth);
 }
 
 inline GPUDevice *CreateRenderDeviceHDR32(  VulkanInstance *vi,
                                             Window *win,
                                             const VulkanHardwareRequirement *req=nullptr)
 {
-    return CreateRenderDevice(vi,win,&PreferHDR32,&PreferLinear,&PreferDepth,req);
+    return CreateRenderDevice(vi,win,req,&PreferHDR32,&PreferLinear,&PreferDepth);
 }
 
 inline GPUDevice *CreateRenderDeviceHDR(VulkanInstance *vi,
                                         Window *win,
                                         const VulkanHardwareRequirement *req=nullptr)
 {
-    return CreateRenderDevice(vi,win,&PreferHDR,&PreferLinear,&PreferDepth,req);
+    return CreateRenderDevice(vi,win,req,&PreferHDR,&PreferLinear,&PreferDepth);
 }
 VK_NAMESPACE_END

inc/hgl/graph/VKInstance.h

@@ -28,6 +28,11 @@ VK_NAMESPACE_BEGIN
             VK_BOOL1BIT(profiles)
         }khronos;
 
+        struct
+        {
+            VK_BOOL1BIT(switchable_graphics)
+        }amd;
+
         struct
         {
             VK_BOOL1BIT(optimus)

inc/hgl/graph/VKMaterial.h

@@ -49,15 +49,15 @@ public:
 
     virtual ~Material();
 
-    const   UTF8String &                        GetName                 ()const{return name;}
+    const   AnsiString &                        GetName                 ()const{return name;}
 
     const   VertexInput *                       GetVertexInput          ()const{return vertex_input;}
 
     const   ShaderStageCreateInfoList &         GetStageList            ()const{return shader_stage_list;}
 
-    const   MaterialDescriptorManager *         GetDescriptorSets       ()const{return desc_manager;}
+//    const   MaterialDescriptorManager *         GetDescriptorManager    ()const{return desc_manager;}
     const   VkPipelineLayout                    GetPipelineLayout       ()const;
-    const   PipelineLayoutData *                GetPipelineLayoutData   ()const{return pipeline_layout_data;}
+//    const   PipelineLayoutData *                GetPipelineLayoutData   ()const{return pipeline_layout_data;}
 
 public:
 
@@ -69,6 +69,7 @@ public:
             }
 
     const   bool                                hasSet                  (const DescriptorSetType &type)const;
+    const   bool                                hasAssign               ()const;
 
     const   VIL *                               GetDefaultVIL()const;
             VIL *                               CreateVIL(const VILConfig *format_map=nullptr);
@@ -81,6 +82,8 @@ public:
     bool BindSSBO(const DescriptorSetType &type,const AnsiString &name,DeviceBuffer *ubo,bool dynamic=false);
     bool BindImageSampler(const DescriptorSetType &type,const AnsiString &name,Texture *tex,Sampler *sampler);
 
+    void Update();
+
 public:
 
     const bool      HasMI           ()const{return mi_data_bytes>0;}

inc/hgl/graph/VKMaterialDescriptorManager.h

@@ -5,9 +5,6 @@
 #include<hgl/graph/VKShaderDescriptorSet.h>
 
 VK_NAMESPACE_BEGIN
-using BindingMap=Map<AnsiString,int>;
-using BindingMapArray=BindingMap[VK_DESCRIPTOR_TYPE_RANGE_SIZE];
-
 class MaterialDescriptorManager
 {
     UTF8String mtl_name;

inc/hgl/graph/VKPipeline.h

@@ -9,6 +9,9 @@ VK_NAMESPACE_BEGIN
 class Pipeline
 {
     VkDevice device;
+
+    AnsiString name;
+
     VkPipeline pipeline;
     PipelineData *data;
 
@@ -19,8 +22,10 @@ private:
 
     friend class RenderPass;
 
-    Pipeline(VkDevice dev,VkPipeline p,PipelineData *pd)
+    Pipeline(const AnsiString &n,VkDevice dev,VkPipeline p,PipelineData *pd)
     {
+        name=n;
+
         device=dev;
         pipeline=p;
         data=pd;
@@ -33,6 +38,8 @@ public:
 
     virtual ~Pipeline();
 
+    const AnsiString &GetName()const{return name;}
+
     operator VkPipeline(){return pipeline;}
 
     const PipelineData *GetData()const{return data;}

inc/hgl/graph/VKPrimitive.h

@@ -12,6 +12,9 @@ VK_NAMESPACE_BEGIN
  */
 class Primitive
 {
+    GPUDevice *device;
+    AnsiString prim_name;
+
     struct VBOData
     {
         VBO *buf;
@@ -45,7 +48,13 @@ protected:
 
 public:
 
-    Primitive(const uint32_t vc=0):vertex_count(vc){}
+    Primitive(GPUDevice *dev,const AnsiString &n,const uint32_t vc=0)
+    {
+        device=dev;
+        prim_name=n;
+        vertex_count=vc;
+    }
+
     virtual ~Primitive()=default;
 
     const   uint    GetRefCount()const{return ref_count;}
@@ -55,14 +64,7 @@ public:
 
             bool    Set(const AnsiString &name,VBO *vb,VkDeviceSize offset=0);
 
-            bool    Set(IndexBuffer *ib,VkDeviceSize offset=0)
-            {
-                if(!ib)return(false);
-
-                index_buffer_data.buffer=ib;
-                index_buffer_data.offset=offset;
-                return(true);
-            }
+            bool    Set(IndexBuffer *ib,VkDeviceSize offset=0);
 
 public:
 

inc/hgl/graph/VKRenderPass.h

@@ -25,7 +25,7 @@ protected:
 
     ObjectList<Pipeline> pipeline_list;
 
-    Pipeline *CreatePipeline(PipelineData *,const ShaderStageCreateInfoList &,VkPipelineLayout,const VIL *);
+    Pipeline *CreatePipeline(const AnsiString &,PipelineData *,const ShaderStageCreateInfoList &,VkPipelineLayout,const VIL *);
 
 private:
 

inc/hgl/graph/VKRenderResource.h

@@ -16,8 +16,16 @@
 #include<hgl/type/ObjectManage.h>
 #include<hgl/shadergen/MaterialCreateInfo.h>
 #include<hgl/graph/VKDescriptorBindingManage.h>
+#include<hgl/graph/VKDevice.h>
 
 VK_NAMESPACE_BEGIN
+
+namespace mtl
+{
+    struct Material2DCreateConfig;
+    struct Material3DCreateConfig;
+}//namespace mtl
+
 using MaterialID            =int;
 using MaterialInstanceID    =int;
 using BufferID              =int;
@@ -52,14 +60,35 @@ class RenderResource
     IDObjectManage<TextureID,              Texture>            rm_textures;                ///<纹理合集
     IDObjectManage<RenderableID,           Renderable>         rm_renderables;             ///<渲染实例集合集
 
+private:
+
+    void AddBuffer(const AnsiString &buf_name,DeviceBuffer *buf)
+    {
+        rm_buffers.Add(buf);
+
+    #ifdef _DEBUG
+        DebugUtils *du=device->GetDebugUtils();
+
+        if(du)
+        {
+            du->SetBuffer(buf->GetBuffer(),buf_name+":Buffer");
+            du->SetDeviceMemory(buf->GetVkMemory(),buf_name+":Memory");
+        }
+    #endif//_DEBUG
+    }
+
 public:
 
     //注：并非一定要走这里，这里只是提供一个注册和自动绑定的机制
+    DescriptorBinding static_descriptor;                                                    ///<静态属性描述符绑定管理
     DescriptorBinding global_descriptor;                                                    ///<全局属性描述符绑定管理
 
 public:
 
-    RenderResource(GPUDevice *dev):device(dev),global_descriptor(DescriptorSetType::Global){}
+    RenderResource(GPUDevice *dev):device(dev),
+        static_descriptor(DescriptorSetType::Static),
+        global_descriptor(DescriptorSetType::Global)
+    {}
     virtual ~RenderResource()=default;
 
 public: //Add
@@ -75,12 +104,12 @@ public: //Add
 
 public: // VBO/VAO
 
-    VBO *CreateVBO(VkFormat format,uint32_t count,const void *data,SharingMode sm=SharingMode::Exclusive);
-    VBO *CreateVBO(VkFormat format,uint32_t count,SharingMode sm=SharingMode::Exclusive){return CreateVBO(format,count,nullptr,sm);}
-    VBO *CreateVBO(const VAD *vad,SharingMode sm=SharingMode::Exclusive){return CreateVBO(vad->GetFormat(),vad->GetCount(),vad->GetData(),sm);}
+    VBO *CreateVBO(VkFormat format,uint32_t count,const void *data, SharingMode sm=SharingMode::Exclusive);
+    VBO *CreateVBO(VkFormat format,uint32_t count,                  SharingMode sm=SharingMode::Exclusive){return CreateVBO(format,             count,          nullptr,        sm);}
+    VBO *CreateVBO(const VAD *vad,                                  SharingMode sm=SharingMode::Exclusive){return CreateVBO(vad->GetFormat(),   vad->GetCount(),vad->GetData(), sm);}
 
-    #define SCENE_DB_CREATE_FUNC(name)  DeviceBuffer *Create##name(VkDeviceSize size,void *data,SharingMode sm=SharingMode::Exclusive);   \
-                                        DeviceBuffer *Create##name(VkDeviceSize size,SharingMode sm=SharingMode::Exclusive);
+    #define SCENE_DB_CREATE_FUNC(name)  DeviceBuffer *Create##name(const AnsiString &buf_name,VkDeviceSize size,void *data,SharingMode sm=SharingMode::Exclusive);   \
+                                        DeviceBuffer *Create##name(const AnsiString &buf_name,VkDeviceSize size,SharingMode sm=SharingMode::Exclusive){return Create##name(buf_name,size,nullptr,sm);}
 
             SCENE_DB_CREATE_FUNC(UBO)
             SCENE_DB_CREATE_FUNC(SSBO)
@@ -89,23 +118,36 @@ public: // VBO/VAO
     #undef SCENE_DB_CREATE_FUNC
 
     IndexBuffer *CreateIBO(IndexType index_type,uint32_t count,const void *  data,  SharingMode sm=SharingMode::Exclusive);
+    IndexBuffer *CreateIBO8 (                   uint32_t count,const uint8  *data,  SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U8 ,count,(void *)data,sm);}
     IndexBuffer *CreateIBO16(                   uint32_t count,const uint16 *data,  SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U16,count,(void *)data,sm);}
     IndexBuffer *CreateIBO32(                   uint32_t count,const uint32 *data,  SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U32,count,(void *)data,sm);}
 
-    IndexBuffer *CreateIBO(IndexType index_type,uint32_t count,SharingMode sm=SharingMode::Exclusive){return CreateIBO(index_type,count,nullptr,sm);}
-    IndexBuffer *CreateIBO16(                   uint32_t count,SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U16,count,nullptr,sm);}
-    IndexBuffer *CreateIBO32(                   uint32_t count,SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U32,count,nullptr,sm);}
+    IndexBuffer *CreateIBO(IndexType index_type,uint32_t count,SharingMode sm=SharingMode::Exclusive){return CreateIBO(index_type,      count,nullptr,sm);}
+    IndexBuffer *CreateIBO8 (                   uint32_t count,SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U8,   count,nullptr,sm);}
+    IndexBuffer *CreateIBO16(                   uint32_t count,SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U16,  count,nullptr,sm);}
+    IndexBuffer *CreateIBO32(                   uint32_t count,SharingMode sm=SharingMode::Exclusive){return CreateIBO(IndexType::U32,  count,nullptr,sm);}
 
 public: //Material
 
     const ShaderModule *CreateShaderModule(const AnsiString &shader_module_name,const ShaderCreateInfo *);
     
     Material *          CreateMaterial(const mtl::MaterialCreateInfo *);
+    Material *          LoadMaterial(const AnsiString &,mtl::Material2DCreateConfig *);
+    Material *          LoadMaterial(const AnsiString &,mtl::Material3DCreateConfig *);
 
     MaterialInstance *  CreateMaterialInstance(Material *,const VILConfig *vil_cfg=nullptr);
+
+    MaterialInstance *  CreateMaterialInstance(Material *,const VILConfig *vil_cfg,const void *,const int);
+
+    template<typename T>
+    MaterialInstance *  CreateMaterialInstance(Material *mtl,const VILConfig *vil_cfg,const T *data)
+    {
+        return CreateMaterialInstance(mtl,vil_cfg,data,sizeof(T));
+    }
+
     MaterialInstance *  CreateMaterialInstance(const mtl::MaterialCreateInfo *,const VILConfig *vil_cfg=nullptr);
 
-    Primitive *         CreatePrimitive(const uint32_t vertex_count=0);
+    Primitive *         CreatePrimitive(const AnsiString &,const uint32_t vertex_count=0);
 
     Renderable *        CreateRenderable(Primitive *r,MaterialInstance *mi,Pipeline *p);
 
@@ -117,7 +159,7 @@ public: //texture
     Texture2D *         LoadTexture2D(const OSString &,bool auto_mipmaps=false);
     TextureCube *       LoadTextureCube(const OSString &,bool auto_mipmaps=false);
 
-    Texture2DArray *    CreateTexture2DArray(const uint32_t width,const uint32_t height,const uint32_t layer,const VkFormat &fmt,bool auto_mipmaps=false);
+    Texture2DArray *    CreateTexture2DArray(const AnsiString &name,const uint32_t width,const uint32_t height,const uint32_t layer,const VkFormat &fmt,bool auto_mipmaps=false);
     bool                LoadTexture2DToArray(Texture2DArray *,const uint32_t layer,const OSString &);
 
 public: //Get

inc/hgl/graph/VKRenderablePrimitiveCreater.h

@@ -14,34 +14,34 @@ class RenderablePrimitiveCreater
 
 public:
 
-    RenderablePrimitiveCreater(RenderResource *_rr,uint32_t vc)
+    RenderablePrimitiveCreater(RenderResource *_rr,const AnsiString &name,uint32_t vc)
     {
         rr=_rr;
         vertex_count=vc;
 
-        prim=rr->CreatePrimitive(vertex_count);
+        prim=rr->CreatePrimitive(name,vertex_count);
     }
 
-    bool SetVBO(const AnsiString &name,const VkFormat &fmt,const void *buf)
+    VBO *SetVBO(const AnsiString &name,const VkFormat &fmt,const void *buf)
     {
         VBO *vbo=rr->CreateVBO(fmt,vertex_count,buf);
 
         if(!vbo)
-            return(false);
+            return(nullptr);
 
         prim->Set(name,vbo);
-        return(true);
+        return(vbo);
     }
 
-    bool SetIBO(const IndexType &it,const void *buf,const uint32_t index_count)
+    IndexBuffer *SetIBO(const IndexType &it,const void *buf,const uint32_t index_count)
     {
         IndexBuffer *ibo=rr->CreateIBO(it,index_count,buf);
     
         if(!ibo)
-            return(false);
+            return(nullptr);
     
         prim->Set(ibo);
-        return(true);
+        return(ibo);
     }
 
     Renderable *Create(MaterialInstance *mi,Pipeline *p)

inc/hgl/graph/VKTexture.h

@@ -22,7 +22,7 @@ public:
 
     TextureData *               GetData             ()      {return data;}
 
-    VkDeviceMemory              GetDeviceMemory     ()      {return data?data->memory->operator VkDeviceMemory():VK_NULL_HANDLE;}
+    VkDeviceMemory              GetDeviceMemory     ()      {return data?(data->memory?data->memory->operator VkDeviceMemory():VK_NULL_HANDLE):VK_NULL_HANDLE;}
     VkImage                     GetImage            ()      {return data?data->image:VK_NULL_HANDLE;}
     VkImageLayout               GetImageLayout      ()      {return data?data->image_layout:VK_IMAGE_LAYOUT_UNDEFINED;}
     VkImageView                 GetVulkanImageView  ()      {return data?data->image_view->GetImageView():VK_NULL_HANDLE;}

inc/hgl/graph/VKTextureCreateInfo.h

@@ -292,7 +292,7 @@ struct SwapchainDepthTextureCreateInfo:public TextureCreateInfo
 
 struct TextureData
 {
-    DeviceMemory *         memory;
+    DeviceMemory *      memory;
     VkImage             image;
     VkImageLayout       image_layout;
     ImageView *         image_view;

inc/hgl/graph/VertexAttribDataAccess.h

@@ -197,7 +197,7 @@ namespace hgl
              * @param v 值
              * @param count 写入数量
              */
-            bool Write(const T v,const uint32_t count)
+            bool RepeatWrite(const T v,const uint32_t count)
             {
                 if(!this->access||this->access+count>this->data_end)
                 {
@@ -303,6 +303,23 @@ namespace hgl
                 return(true);
             }
 
+            bool Write(const T *v,const uint count)
+            {
+                if(!this->access||this->access+2>this->data_end)
+                {
+                    LOG_HINT(OS_TEXT("VertexAttribDataAccess2::Write(T *) out"));
+                    return(false);
+                }
+
+                for(uint i=0;i<count;i++)
+                {
+                    *this->access++=*v++;
+                    *this->access++=*v++;
+                }
+
+                return(true);
+            }
+
             template<typename V2>
             bool Write(const V2 &v)
             {

inc/hgl/graph/mtl/3d/Material3DCreateConfig.h

@@ -1,33 +0,0 @@
-#pragma once
-
-#include<hgl/graph/mtl/MaterialConfig.h>
-#include<hgl/graph/CoordinateSystem.h>
-#include<hgl/graph/VertexAttrib.h>
-
-STD_MTL_NAMESPACE_BEGIN
-struct Material3DCreateConfig:public MaterialCreateConfig
-{
-    bool                local_to_world;         ///<包含LocalToWorld矩阵
-
-    VAT                 position_format;        ///<position格式
-
-public:
-
-    Material3DCreateConfig(const GPUDeviceAttribute *da,const AnsiString &name,const Prim &p):MaterialCreateConfig(da,name,p)
-    {
-        rt_output.color=1;          //输出一个颜色
-        rt_output.depth=true;       //不输出深度
-        rt_output.stencil=false;    //不输出stencil
-
-        local_to_world=false;
-
-        position_format=VAT_VEC3;
-    }
-};//struct Material3DCreateConfig:public MaterialCreateConfig
-
-//MaterialCreateInfo *CreateVertexColor2D(const Material2DCreateConfig *);
-//MaterialCreateInfo *CreatePureColor2D(const Material2DCreateConfig *);
-//MaterialCreateInfo *CreatePureTexture2D(const Material2DCreateConfig *);
-//MaterialCreateInfo *CreateRectTexture2D(Material2DCreateConfig *);
-//MaterialCreateInfo *CreateRectTexture2DArray(Material2DCreateConfig *);
-STD_MTL_NAMESPACE_END

inc/hgl/graph/mtl/BlinnPhong.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include<hgl/graph/mtl/StdMaterial.h>
+#include<hgl/graph/mtl/ShaderBuffer.h>
+#include<hgl/math/Vector.h>
+STD_MTL_NAMESPACE_BEGIN
+namespace blinnphong
+{
+    struct SunLight
+    {
+        Vector4f direction;
+        Vector4f color;
+    };//struct SunLight
+
+    constexpr const ShaderBufferSource SBS_SunLight=
+    {
+        "SunLight",
+        "sun",
+
+        R"(
+        vec4 direction;
+        vec4 color;
+)"
+    };
+}//namespace blinnphong
+STD_MTL_NAMESPACE_END

inc/hgl/graph/mtl/Material2DCreateConfig.h

@@ -31,6 +31,25 @@ public:
         else
             position_format=VAT_VEC2;
     }
+
+    int Comp(const Material2DCreateConfig &cfg)const
+    {
+        int off=MaterialCreateConfig::Comp(cfg);
+
+        if(off)return off;
+
+        off=(int)coordinate_system-(int)cfg.coordinate_system;
+        if(off)return off;
+
+        off=local_to_world-cfg.local_to_world;
+        if(off)return off;
+
+        off=position_format.Comp(cfg.position_format);
+        
+        return off;
+    }
+
+    CompOperator(const Material2DCreateConfig &,Comp)
 };//struct Material2DCreateConfig:public MaterialCreateConfig
 
 MaterialCreateInfo *CreateVertexColor2D(const Material2DCreateConfig *);
@@ -38,5 +57,18 @@ MaterialCreateInfo *CreatePureColor2D(const Material2DCreateConfig *);
 MaterialCreateInfo *CreatePureTexture2D(const Material2DCreateConfig *);
 MaterialCreateInfo *CreateRectTexture2D(Material2DCreateConfig *);
 MaterialCreateInfo *CreateRectTexture2DArray(Material2DCreateConfig *);
+
+// 为什么有了LoadMaterialFromFile，还需要保留以上Create系列函数？
+
+//  1.LoadMaterialFromFile载的材质，是从文件中加载的。但我们要考虑文件损坏不能加载的情况。
+//  2.从文件加载材质过于复杂，而且不利于调试。所以我们需要保留Create系列函数，以便于调试以及测试一些新的情况。同时让开发人员知道材质具体是如何创建的。
+
+/**
+ * 从文件加载材质
+ * @param mtl_name 材质名称
+ * @param cfg 材质创建参数
+ * @return 材质创建信息
+ */
+MaterialCreateInfo *LoadMaterialFromFile(const AnsiString &mtl_name,Material2DCreateConfig *cfg);        ///<从文件加载材质
 STD_MTL_NAMESPACE_END
 #endif//HGL_GRAPH_MTL_2D_CREATE_CONFIG_INCLUDE

inc/hgl/graph/mtl/Material3DCreateConfig.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include<hgl/graph/mtl/MaterialConfig.h>
+#include<hgl/graph/CoordinateSystem.h>
+#include<hgl/graph/VertexAttrib.h>
+
+STD_MTL_NAMESPACE_BEGIN
+struct Material3DCreateConfig:public MaterialCreateConfig
+{
+    bool                camera;                 ///<包含摄像机矩阵信息
+
+    bool                local_to_world;         ///<包含LocalToWorld矩阵
+
+    VAT                 position_format;        ///<position格式
+
+//    bool                reverse_depth;          ///<使用反向深度
+
+public:
+
+    Material3DCreateConfig(const GPUDeviceAttribute *da,const AnsiString &name,const Prim &p):MaterialCreateConfig(da,name,p)
+    {
+        rt_output.color=1;          //输出一个颜色
+        rt_output.depth=true;       //不输出深度
+        rt_output.stencil=false;    //不输出stencil
+
+        camera=true;
+        local_to_world=false;
+
+        position_format=VAT_VEC3;
+
+//        reverse_depth=false;
+    }
+
+    int Comp(const Material3DCreateConfig &cfg)const
+    {
+        int off=MaterialCreateConfig::Comp(cfg);
+
+        if(off)return off;
+
+        off=camera-cfg.camera;
+        if(off)return off;
+
+        off=local_to_world-cfg.local_to_world;
+        if(off)return off;
+
+        off=position_format.Comp(cfg.position_format);
+
+        return off;
+    }
+
+    CompOperator(const Material3DCreateConfig &,Comp)
+};//struct Material3DCreateConfig:public MaterialCreateConfig
+
+MaterialCreateInfo *CreateVertexColor3D(const Material3DCreateConfig *);
+MaterialCreateInfo *CreateVertexLuminance3D(const Material3DCreateConfig *);
+
+/**
+ * 从文件加载材质
+ * @param mtl_name 材质名称
+ * @param cfg 材质创建参数
+ * @return 材质创建信息
+ */
+MaterialCreateInfo *LoadMaterialFromFile(const AnsiString &name,Material3DCreateConfig *cfg);
+STD_MTL_NAMESPACE_END

inc/hgl/graph/mtl/MaterialConfig.h

@@ -5,6 +5,7 @@
 #include<hgl/type/String.h>
 #include<hgl/graph/RenderTargetOutputConfig.h>
 #include<hgl/graph/VK.h>
+#include<hgl/graph/mtl/SamplerName.h>
 
 STD_MTL_NAMESPACE_BEGIN
 class MaterialCreateInfo;
@@ -36,6 +37,23 @@ public:
 
         prim=p;
     }
+
+    int Comp(const MaterialCreateConfig &cfg)const
+    {
+        int off;
+
+        off=hgl_cmp(rt_output,cfg.rt_output);
+
+        if(off)return(off);
+
+        off=(int)prim-(int)cfg.prim;
+
+        if(off)return(off);
+
+        return shader_stage_flag_bit-cfg.shader_stage_flag_bit;
+    }
+
+    CompOperator(const MaterialCreateConfig &,Comp)
 };//struct MaterialCreateConfig
 STD_MTL_NAMESPACE_END
 #endif//HGL_GRAPH_MTL_CONFIG_INCLUDE

inc/hgl/graph/mtl/StdMaterial.h

@@ -1,16 +1,57 @@
 #pragma once
 
+#include<hgl/type/String.h>
+
 #define STD_MTL_NAMESPACE_BEGIN namespace hgl{namespace graph{namespace mtl{
 #define STD_MTL_NAMESPACE_END   }}}
 
 #define STD_MTL_NAMESPACE_USING using namespace hgl::graph::mtl;
 
+#define STD_MTL_FUNC_NAMESPACE_BEGIN namespace hgl{namespace graph{namespace mtl{namespace func{
+#define STD_MTL_FUNC_NAMESPACE_END   }}}}
+
+#define STD_MTL_FUNC NAMESPACE_USING using namespace hgl::graph::mtl::func;
+
 namespace hgl
 {
     namespace graph
     {
+        class ShaderCreateInfoVertex;
+        class ShaderCreateInfoGeometry;
+        class ShaderCreateInfoFragment;
+
         namespace mtl
         {
+            namespace func
+            {
+            }//namespace func
+
+            class MaterialCreateInfo;
+            struct MaterialCreateConfig;
+
+            class StdMaterial
+            {
+            protected:
+
+                MaterialCreateInfo *mci;
+
+            protected:
+
+                virtual bool BeginCustomShader(){return true;/*some work before create shader*/};
+
+                virtual bool CustomVertexShader(ShaderCreateInfoVertex *)=0;
+                virtual bool CustomGeometryShader(ShaderCreateInfoGeometry *){return false;}
+                virtual bool CustomFragmentShader(ShaderCreateInfoFragment *)=0;
+
+                virtual bool EndCustomShader(){return true;/*some work after create shader*/};
+
+            public:
+
+                StdMaterial(const MaterialCreateConfig *);
+                virtual ~StdMaterial()=default;
+    
+                virtual MaterialCreateInfo *Create();
+            };//class StdMaterial
         }//namespace mtl
     }//namespace graph
 }//namespace hgl

inc/hgl/graph/mtl/UniformBuffer.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include<hgl/graph/mtl/StdMaterial.h>
+#include<hgl/graph/mtl/ShaderBuffer.h>
+
+STD_MTL_NAMESPACE_BEGIN
+
+/**
+* 所有UBO的基类，它即向生成器提供代码，也可以为渲染器提供数据
+*/
+class UniformBuffer
+{
+private:
+
+    ShaderBufferSource *sbs;
+
+public:
+
+    virtual const AnsiString &GetStructName         ()const{return sbs->struct_name;}               ///<取得结构名称
+    virtual const AnsiString &GetDefaultValueName   ()const{return sbs->name;}                      ///<取得默认变量名称
+    virtual const AnsiString &GetShaderCodes        ()const{return sbs->codes;}                     ///<取得Shader代码
+};//class UniformBuffer
+
+STD_MTL_NAMESPACE_END

inc/hgl/shadergen/MaterialCreateInfo.h

@@ -83,10 +83,11 @@ namespace hgl{namespace graph
             bool AddStruct(const AnsiString &ubo_typename,const AnsiString &codes);
             bool AddStruct(const ShaderBufferSource &ss){return AddStruct(ss.struct_name,ss.codes);}
 
-            bool AddUBO(const VkShaderStageFlagBits flag_bits,const DescriptorSetType set_type,const AnsiString &type_name,const AnsiString &name);
-            bool AddSampler(const VkShaderStageFlagBits flag_bits,const DescriptorSetType set_type,const SamplerType &st,const AnsiString &name);
+            bool AddUBO(const VkShaderStageFlagBits flag_bits,const DescriptorSetType set_type,const AnsiString &struct_name,const AnsiString &name);
+            bool AddUBO(const uint32_t flag_bits,const DescriptorSetType &set_type,const AnsiString &struct_name,const AnsiString &name);
+            bool AddUBO(const uint32_t flag_bits,const DescriptorSetType &set_type,const ShaderBufferSource &ss){return AddUBO(flag_bits,set_type,ss.struct_name,ss.name);}
 
-            bool AddUBO(const uint32_t flag_bits,const DescriptorSetType &set_type,const ShaderBufferSource &ss);
+            bool AddSampler(const VkShaderStageFlagBits flag_bits,const DescriptorSetType set_type,const SamplerType &st,const AnsiString &name);
 
             bool CreateShader();
         };//class MaterialCreateInfo

inc/hgl/shadergen/ShaderCreateInfo.h

@@ -34,7 +34,7 @@ protected:
 
     AnsiString mi_codes;
 
-    AnsiStringList function_list;
+    List<const char *> function_list;
     AnsiString main_function;
 
     AnsiString final_shader;
@@ -79,12 +79,18 @@ public:
     int AddOutput(const graph::VAT &type,const AnsiString &name,Interpolation inter=Interpolation::Smooth);
     int AddOutput(const AnsiString &type,const AnsiString &name,Interpolation inter=Interpolation::Smooth);
 
-    void AddFunction(const AnsiString &str){function_list.Add(str);}
+    void AddFunction(const char *str){function_list.Add(str);}
 
     void SetMaterialInstance(UBODescriptor *,const AnsiString &);
+    void AddMaterialInstanceOutput();
+
     void SetLocalToWorld(UBODescriptor *);
 
     void SetMain(const AnsiString &str){main_function=str;}
+    void SetMain(const char *str,const int len)
+    {
+        main_function.SetString(str,len);
+    }
 
     const AnsiString &GetOutputStruct()const{return output_struct;}
     const AnsiString &GetShaderSource()const{return final_shader;}

inc/hgl/shadergen/ShaderCreateInfoFragment.h

@@ -3,10 +3,6 @@
 #include<hgl/shadergen/ShaderCreateInfo.h>
 
 namespace hgl{namespace graph{
-enum class MaterialType
-{
-    Color,                              ///<<3C><>ɫ<EFBFBD><C9AB><EFBFBD><EFBFBD>
-};
 
 class ShaderCreateInfoFragment:public ShaderCreateInfo
 {
@@ -16,7 +12,5 @@ public:
 
     ShaderCreateInfoFragment(MaterialDescriptorInfo *m):ShaderCreateInfo(VK_SHADER_STAGE_FRAGMENT_BIT,m){}
     ~ShaderCreateInfoFragment()=default;
-
-    void UseDefaultMain();
 };
 }}//namespace hgl::graph

inc/hgl/shadergen/ShaderCreateInfoVertex.h

@@ -13,12 +13,14 @@ namespace hgl
 
         public:
 
-            ShaderCreateInfoVertex(MaterialDescriptorInfo *m):ShaderCreateInfo(VK_SHADER_STAGE_VERTEX_BIT,m){}
+            ShaderCreateInfoVertex(MaterialDescriptorInfo *);
             ~ShaderCreateInfoVertex()=default;
 
             int AddInput(const graph::VAT &type,const AnsiString &name,const VkVertexInputRate input_rate=VK_VERTEX_INPUT_RATE_VERTEX,const VertexInputGroup &group=VertexInputGroup::Basic);
             int AddInput(const AnsiString &type,const AnsiString &name,const VkVertexInputRate input_rate=VK_VERTEX_INPUT_RATE_VERTEX,const VertexInputGroup &group=VertexInputGroup::Basic);
 
+            int hasInput(const char *);
+
             void AddJoint();
             void AddAssign();
         };//class ShaderCreateInfoVertex:public ShaderCreateInfo

inc/hgl/shadergen/ShaderDescriptorInfo.h

@@ -59,6 +59,8 @@ public:
     bool AddInput(ShaderAttribute *);
     bool AddOutput(ShaderAttribute *);
 
+    bool hasInput(const char *)const;     ///<是否有指定输入
+
     void AddStruct(const AnsiString &);
     bool AddUBO(DescriptorSetType type,const UBODescriptor *sd);
     bool AddSampler(DescriptorSetType type,const SamplerDescriptor *sd);

src/SceneGraph/CMakeLists.txt

@@ -106,10 +106,8 @@ SET(VK_INST_SOURCE      ${SG_INCLUDE_PATH}/VKInstance.h
                         Vulkan/VKInstance.cpp)
 
 SET(VK_DEBUG_SOURCE     ${SG_INCLUDE_PATH}/VKDebugOut.h
-                        ${SG_INCLUDE_PATH}/VKDebugMaker.h
                         ${SG_INCLUDE_PATH}/VKDebugUtils.h
                         Vulkan/Debug/VKDebugOut.cpp
-                        Vulkan/Debug/VKDebugMaker.cpp
                         Vulkan/Debug/VKDebugUtils.cpp)
 
 SET(VK_MEMORY_SOURCE    ${SG_INCLUDE_PATH}/VKMemory.h

src/SceneGraph/InlineGeometry.cpp

@@ -28,7 +28,7 @@ namespace hgl
 
                 vertex->WriteRectFan(rci->scope);
 
-                return rc.Finish();
+                return rc.Finish("Rectangle");
             }
 
             Primitive *CreateGBufferCompositionRectangle(RenderResource *db,const VIL *vil)
@@ -111,7 +111,7 @@ namespace hgl
                     delete[] coord;
                 }
 
-                return rc.Finish();
+                return rc.Finish("RoundRectangle");
             }
 
             Primitive *CreateCircle(RenderResource *db,const VIL *vil,const CircleCreateInfo *cci)
@@ -159,57 +159,60 @@ namespace hgl
                         color->Write(cci->border_color);
                 }
 
-                return rc.Finish();
+                return rc.Finish("Circle");
             }
 
             Primitive *CreatePlaneGrid(RenderResource *db,const VIL *vil,const PlaneGridCreateInfo *pgci)
             {
                 PrimitiveCreater rc(db,vil);
 
-                if(!rc.Init(((pgci->step.x+1)+(pgci->step.y+1))*2))
+                if(!rc.Init(((pgci->grid_size.Width()+1)+(pgci->grid_size.Height()+1))*2))
                     return(nullptr);
 
                 AutoDelete<VB3f> vertex=rc.AccessVAD<VB3f>(VAN::Position);
-                for(uint row=0;row<=pgci->step.x;row++)
-                {
-                    float pos=float(row)/float(pgci->step.x);
 
-                    vertex->WriteLine(  to(pgci->coord[0],pgci->coord[1],pos),
-                                        to(pgci->coord[3],pgci->coord[2],pos));
+                const float right=float(pgci->grid_size.Width())/2.0f;
+                const float left =-right;
+
+                const float bottom=float(pgci->grid_size.Height())/2.0f;
+                const float top   =-bottom;
+
+                for(int row=0;row<=pgci->grid_size.Height();row++)
+                {
+                    vertex->WriteLine(  Vector3f(left ,top+row,0),
+                                        Vector3f(right,top+row,0));
                 }
 
-                for(uint col=0;col<=pgci->step.y;col++)
+                for(int col=0;col<=pgci->grid_size.Width();col++)
                 {
-                    float pos=float(col)/float(pgci->step.y);
-
-                    vertex->WriteLine(to(pgci->coord[1],pgci->coord[2],pos),
-                                      to(pgci->coord[0],pgci->coord[3],pos));
+                    vertex->WriteLine(Vector3f(left+col,top,   0),
+                                      Vector3f(left+col,bottom,0));
                 }
 
-                AutoDelete<VB4f> color=rc.AccessVAD<VB4f>(VAN::Color);
-                if(color)
+                AutoDelete<VB1f> lum=rc.AccessVAD<VB1f>(VAN::Luminance);
+                if(lum)
                 {
-                    for(uint row=0;row<=pgci->step.x;row++)
+                    for(int row=0;row<=pgci->grid_size.Height();row++)
                     {
-                        if((row%pgci->side_step.x)==0)
-                            color->RepeatWrite(pgci->side_color,2);
+                        if((row%pgci->sub_count.Height())==0)
+                            lum->RepeatWrite(pgci->sub_lum,2);
                         else
-                            color->RepeatWrite(pgci->color,2);
+                            lum->RepeatWrite(pgci->lum,2);
                     }
 
-                    for(uint col=0;col<=pgci->step.y;col++)
+                    for(int col=0;col<=pgci->grid_size.Width();col++)
                     {
-                        if((col%pgci->side_step.y)==0)
-                            color->RepeatWrite(pgci->side_color,2);
+                        if((col%pgci->sub_count.Width())==0)
+                            lum->RepeatWrite(pgci->sub_lum,2);
                         else
-                            color->RepeatWrite(pgci->color,2);
+                            lum->RepeatWrite(pgci->lum,2);
                     }
                 }
 
-                return rc.Finish();
+                return rc.Finish("PlaneGrid");
             }
 
-            Primitive *CreatePlane(RenderResource *db,const VIL *vil,const PlaneCreateInfo *pci)
+            Primitive *CreatePlane(RenderResource *db,const VIL *vil)
             {
                 const   float       xy_vertices [] = { -0.5f,-0.5f,0.0f,  +0.5f,-0.5f,0.0f,    +0.5f,+0.5f,0.0f,    -0.5f,+0.5f,0.0f   };
                         float       xy_tex_coord[] = {  0.0f, 0.0f,        1.0f, 0.0f,          1.0f, 1.0f,          0.0f, 1.0f        };
@@ -232,22 +235,17 @@ namespace hgl
                 {
                     AutoDelete<VB3f> tangent=rc.AccessVAD<VB3f>(VAN::Tangent);
 
-                    tangent->RepeatWrite(xy_tangent,4);
+                    if(tangent)tangent->RepeatWrite(xy_tangent,4);
                 }
 
                 {
                     AutoDelete<VB2f> tex_coord=rc.AccessVAD<VB2f>(VAN::TexCoord);
 
                     if(tex_coord)
-                    {
-                        xy_tex_coord[2]=xy_tex_coord[4]=pci->tile.x;
-                        xy_tex_coord[5]=xy_tex_coord[7]=pci->tile.y;
-
-                        tex_coord->Write(xy_tex_coord);
-                    }
+                        tex_coord->Write(xy_tex_coord,4);
                 }
 
-                return rc.Finish();
+                return rc.Finish("Plane");
             }
 
             Primitive *CreateCube(RenderResource *db,const VIL *vil,const CubeCreateInfo *cci)
@@ -344,7 +342,7 @@ namespace hgl
                 }
 
                 rc.CreateIBO16(6*2*3,indices);
-                return rc.Finish();
+                return rc.Finish("Cube");
             }
 
             template<typename T> void CreateSphereIndices(T *tp,uint numberParallels,const uint numberSlices)
@@ -485,9 +483,9 @@ namespace hgl
 
                         if(np)
                         {
-                            *np=+x;++np;
-                            *np=-y;++np;
-                            *np=+z;++np;
+                            *np=x;++np;
+                            *np=y;++np;
+                            *np=z;++np;
                         }
 
                         if(tcp)
@@ -515,7 +513,7 @@ namespace hgl
                 else
                     CreateSphereIndices<uint32>(rc.CreateIBO32(numberIndices),numberParallels,numberSlices);
 
-                return rc.Finish();
+                return rc.Finish("Sphere");
             }
 
             Primitive *CreateDome(RenderResource *db,const VIL *vil,const uint numberSlices)
@@ -601,7 +599,7 @@ namespace hgl
                 else
                     CreateSphereIndices<uint32>(rc.CreateIBO32(numberIndices),numberParallels,numberSlices);
 
-                return rc.Finish();
+                return rc.Finish("Dome");
             }
 
             namespace
@@ -714,7 +712,7 @@ namespace hgl
                             // NOTE: cos (2PIx) = cos (x) and sin (2PIx) = sin (x) so, we can use this formula
                             //       normal = {cos(2PIs)cos(2PIt) , sin(2PIs)cos(2PIt) ,sin(2PIt)}
                             *np = +cos2PIs * cos2PIt;   ++np;
-                            *np = -sin2PIt;             ++np;
+                            *np = +sin2PIt;             ++np;
                             *np = +sin2PIs * cos2PIt;   ++np;
                         }
 
@@ -742,7 +740,7 @@ namespace hgl
                 else
                     CreateTorusIndices<uint32>(rc.CreateIBO32(numberIndices),tci->numberSlices,tci->numberStacks);
 
-                return rc.Finish();
+                return rc.Finish("Torus");
             }
 
             namespace
@@ -945,7 +943,7 @@ namespace hgl
                         if(np)
                         {
                             *np =  cos(currentAngle);   ++np;
-                            *np =  sin(currentAngle);   ++np;
+                            *np = -sin(currentAngle);   ++np;
                             *np = 0.0f;                 ++np;
                         }
 
@@ -971,7 +969,7 @@ namespace hgl
                 else
                     CreateCylinderIndices<uint32>(rc.CreateIBO32(numberIndices),cci->numberSlices);
 
-                return rc.Finish();
+                return rc.Finish("Cylinder");
             }
 
             namespace
@@ -1114,7 +1112,7 @@ namespace hgl
                         if(np)
                         {
                             *np = h / l *  cos(currentAngle);   ++np;
-                            *np = h / l *  sin(currentAngle);   ++np;
+                            *np =-h / l *  sin(currentAngle);   ++np;
                             *np = r / l;                        ++np;
                         }
 
@@ -1138,7 +1136,7 @@ namespace hgl
                 else
                     CreateConeIndices<uint32>(rc.CreateIBO32(numberIndices),cci->numberSlices,cci->numberStacks);
 
-                return rc.Finish();
+                return rc.Finish("Cone");
             }
 
             Primitive *CreateAxis(RenderResource *db,const VIL *vil,const AxisCreateInfo *aci)
@@ -1165,7 +1163,7 @@ namespace hgl
                 vertex->Write(0,0,0);color->Write(aci->color[2]);
                 vertex->Write(0,0,s);color->Write(aci->color[2]);
 
-                return rc.Finish();
+                return rc.Finish("Axis");
             }
 
             Primitive *CreateBoundingBox(RenderResource *db,const VIL *vil,const BoundingBoxCreateInfo *cci)
@@ -1219,7 +1217,7 @@ namespace hgl
 
                 rc.CreateIBO16(24,indices);
 
-                return rc.Finish();
+                return rc.Finish("BoundingBox");
             }
         }//namespace inline_geometry
     }//namespace graph

src/SceneGraph/MaterialRenderList.cpp

@@ -34,15 +34,6 @@ int Comparator<hgl::graph::RenderNode>::compare(const hgl::graph::RenderNode &ob
             return off;
     }
 
-    //比较顶点输入格式
-    {
-        off=ri_one->GetMaterialInstance()->GetVIL()
-           -ri_two->GetMaterialInstance()->GetVIL();
-
-        if(off)
-            return off;
-    }
-
     //比较模型
     {
         off=ri_one->GetPrimitive()
@@ -60,10 +51,14 @@ MaterialRenderList::MaterialRenderList(GPUDevice *d,Material *m)
 {
     device=d;
     cmd_buf=nullptr;
-    mtl=m;
-    assign_buffer=new RenderAssignBuffer(d,mtl->GetMIDataBytes());
+    material=m;
 
-    vbo_list=new VBOList(mtl->GetVertexInput()->GetCount());
+    if(material->hasAssign())
+        assign_buffer=new RenderAssignBuffer(d,material->GetMIDataBytes());
+    else
+        assign_buffer=nullptr;
+
+    vbo_list=new VBOList(material->GetVertexInput()->GetCount());
 }
 
 MaterialRenderList::~MaterialRenderList()
@@ -91,13 +86,16 @@ void MaterialRenderList::End()
 
     if(node_count<=0)return;
 
-    if(mtl->HasMI())
-        StatMI();
-
     Stat();
 
-    //写入LocalToWorld数据
-    assign_buffer->WriteNode(rn_list.GetData(),node_count,mi_set);
+    if(assign_buffer)
+    {
+        if(material->HasMI())
+            StatMI();
+
+        //写入LocalToWorld数据
+        assign_buffer->WriteNode(rn_list.GetData(),node_count,mi_set);
+    }
 }
 
 void MaterialRenderList::RenderItem::Set(Renderable *ri)
@@ -114,7 +112,7 @@ void MaterialRenderList::StatMI()
     for(RenderNode &rn:rn_list)
         mi_set.Add(rn.ri->GetMaterialInstance());
 
-    if(mi_set.GetCount()>mtl->GetMIMaxCount())
+    if(mi_set.GetCount()>material->GetMIMaxCount())
     {
         //超出最大数量了怎么办？？？
     }
@@ -137,7 +135,6 @@ void MaterialRenderList::Stat()
     ri->Set(rn->ri);
 
     last_pipeline   =ri->pipeline;
-    last_vil        =ri->mi->GetVIL();
     last_vid        =ri->vid;
 
     ++rn;
@@ -145,13 +142,12 @@ void MaterialRenderList::Stat()
     for(uint i=1;i<count;i++)
     {
         if(last_pipeline==rn->ri->GetPipeline())
-            if(last_vil==rn->ri->GetMaterialInstance()->GetVIL())
-                if(last_vid->Comp(rn->ri->GetVertexInputData()))
-                {
-                    ++ri->count;
-                    ++rn;
-                    continue;
-                }
+            if(last_vid->Comp(rn->ri->GetVertexInputData()))
+            {
+                ++ri->count;
+                ++rn;
+                continue;
+            }
 
         ++ri_count;
         ++ri;
@@ -161,30 +157,20 @@ void MaterialRenderList::Stat()
         ri->Set(rn->ri);
 
         last_pipeline   =ri->pipeline;
-        last_vil        =ri->mi->GetVIL();
         last_vid        =ri->vid;
 
         ++rn;
     }
 }
 
-void MaterialRenderList::Bind(MaterialInstance *mi)
-{
-    if(!mi)return;
-
-    assign_buffer->Bind(mi);
-
-    cmd_buf->BindDescriptorSets(mi->GetMaterial());
-}
-
 bool MaterialRenderList::Bind(const VertexInputData *vid,const uint ri_index)
 {
     //binding号都是在VertexInput::CreateVIL时连续紧密排列生成的，所以bind时first_binding写0就行了。
 
-    const VIL *vil=last_vil;
+    //const VIL *vil=last_vil;
 
-    if(vil->GetCount(VertexInputGroup::Basic)!=vid->binding_count)
-        return(false);                                                  //这里基本不太可能，因为CreateRenderable时就会检查值是否一样
+    //if(vil->GetCount(VertexInputGroup::Basic)!=vid->binding_count)
+    //    return(false);                                                  //这里基本不太可能，因为CreateRenderable时就会检查值是否一样
 
     vbo_list->Restart();
 
@@ -221,17 +207,10 @@ bool MaterialRenderList::Bind(const VertexInputData *vid,const uint ri_index)
     //    }
     //}
 
-    if(!vbo_list->IsFull()) //Assign组
+    //if(!vbo_list->IsFull()) //Assign组
     {
-        const uint assign_binding_count=vil->GetCount(VertexInputGroup::Assign);
-
-        if(assign_binding_count>0)
-        {
-            if(assign_binding_count!=1)
-                return(false);
-
+        if(assign_buffer)
             vbo_list->Add(assign_buffer->GetAssignVBO(),ASSIGN_VBO_STRIDE_BYTES*ri_index);
-        }
     }
 
     //if(count!=binding_count)
@@ -258,14 +237,6 @@ void MaterialRenderList::Render(RenderItem *ri)
         //这里未来尝试换pipeline同时不换mi/primitive是否需要重新绑定mi/primitive
     }
 
-    if(last_vil!=ri->mi->GetVIL())
-    {
-        Bind(ri->mi);
-        last_vil=ri->mi->GetVIL();
-
-        last_vid=nullptr;
-    }
-
     if(!ri->vid->Comp(last_vid))
     {
         Bind(ri->vid,ri->first);
@@ -300,9 +271,13 @@ void MaterialRenderList::Render(RenderCmdBuffer *rcb)
     RenderItem *ri=ri_array.GetData();
 
     last_pipeline   =nullptr;
-    last_vil        =nullptr;
     last_vid        =nullptr;
 
+    if(assign_buffer)
+        assign_buffer->Bind(material);
+
+    cmd_buf->BindDescriptorSets(material);
+
     for(uint i=0;i<ri_count;i++)
     {
         Render(ri);

src/SceneGraph/PrimitiveCreater.cpp

@@ -105,14 +105,14 @@ namespace hgl
             return (uint32 *)ibo->Map();
         }
 
-        Primitive *PrimitiveCreater::Finish()
+        Primitive *PrimitiveCreater::Finish(const AnsiString &prim_name)
         {
-            const uint si_count=vil->GetCount();
+            const uint si_count=vil->GetCount(VertexInputGroup::Basic);
 
             if(vbo_map.GetCount()!=si_count)
                 return(nullptr);
 
-            Primitive *primitive=db->CreatePrimitive(vertices_number);
+            Primitive *primitive=db->CreatePrimitive(prim_name,vertices_number);
 
             const auto *sp=vbo_map.GetDataList();
             for(uint i=0;i<si_count;i++)

src/SceneGraph/RenderAssignBuffer.cpp

@@ -25,15 +25,12 @@ VkBuffer RenderAssignBuffer::GetAssignVBO()const
     return vbo_assigns->GetBuffer();
 }
 
-void RenderAssignBuffer::Bind(MaterialInstance *mi)const
+void RenderAssignBuffer::Bind(Material *mtl)const
 {
-    const VIL *vil=mi->GetVIL();
+    if(!mtl)return;
 
-    const uint assign_binding_count=vil->GetCount(VertexInputGroup::Assign);
-
-    if(assign_binding_count<=0)return;
-
-    Material *mtl=mi->GetMaterial();
+    if(!mtl->hasAssign())
+        return;
 
     mtl->BindUBO(DescriptorSetType::PerFrame,mtl::SBS_LocalToWorld.name,ubo_l2w);
     mtl->BindUBO(DescriptorSetType::PerMaterial,mtl::SBS_MaterialInstance.name,ubo_mi);
@@ -67,6 +64,25 @@ void RenderAssignBuffer::Alloc(const uint nc,const uint mc)
     }
 
     vbo_assigns=device->CreateVBO(ASSIGN_VBO_FMT,node_count);
+
+    #ifdef _DEBUG
+        DebugUtils *du=device->GetDebugUtils();
+        
+        if(du)
+        {
+            du->SetBuffer(ubo_l2w->GetBuffer(),"UBO:Buffer:LocalToWorld");
+            du->SetDeviceMemory(ubo_l2w->GetVkMemory(),"UBO:Memory:LocalToWorld");
+
+            if(ubo_mi)
+            {
+                du->SetBuffer(ubo_mi->GetBuffer(),"UBO:Buffer:MaterialInstance");
+                du->SetDeviceMemory(ubo_mi->GetVkMemory(),"UBO:Memory:MaterialInstance");
+            }
+
+            du->SetBuffer(vbo_assigns->GetBuffer(),"VBO:Buffer:Assign");
+            du->SetDeviceMemory(vbo_assigns->GetVkMemory(),"VBO:Memory:Assign");
+        }
+    #endif//_DEBUG
 }
 
 void RenderAssignBuffer::WriteNode(RenderNode *render_node,const uint count,const MaterialInstanceSets &mi_set)

src/SceneGraph/RenderAssignBuffer.h

@@ -54,7 +54,7 @@ public:
 
     VkBuffer GetAssignVBO()const;
 
-    void Bind(MaterialInstance *)const;
+    void Bind(Material *)const;
 
 public:
 

src/SceneGraph/SceneNode.cpp

@@ -14,8 +14,7 @@ namespace hgl
             }
             else
             {
-                BoundingBox.minPoint=Vector3f(0,0,0);
-                BoundingBox.maxPoint=Vector3f(0,0,0);
+                BoundingBox.SetZero();
 
                 WorldBoundingBox=LocalBoundingBox=BoundingBox;
             }

src/SceneGraph/Vulkan/Debug/VKDebugMaker.cpp

@@ -1,86 +0,0 @@
-#include<hgl/graph/VKDebugMaker.h>
-
-VK_NAMESPACE_BEGIN
-void DebugMaker::SetObjectName(uint64_t object, VkDebugReportObjectTypeEXT objectType, const char *name)
-{
-	// Check for valid function pointer (may not be present if not running in a debugging application)
-	if(!dmf.SetObjectName)return;
-	
-	VkDebugMarkerObjectNameInfoEXT nameInfo = {};
-	nameInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT;
-	nameInfo.objectType = objectType;
-	nameInfo.object = object;
-	nameInfo.pObjectName = name;
-
-	dmf.SetObjectName(device, &nameInfo);
-}
-
-void DebugMaker::SetObjectTag(uint64_t object, VkDebugReportObjectTypeEXT objectType, uint64_t name, size_t tagSize, const void* tag)
-{
-	// Check for valid function pointer (may not be present if not running in a debugging application)
-	if(!dmf.SetObjectTag)return;
-
-	VkDebugMarkerObjectTagInfoEXT tagInfo = {};
-	tagInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT;
-	tagInfo.objectType = objectType;
-	tagInfo.object = object;
-	tagInfo.tagName = name;
-	tagInfo.tagSize = tagSize;
-	tagInfo.pTag = tag;
-
-	dmf.SetObjectTag(device, &tagInfo);
-}
-
-void DebugMaker::Begin(VkCommandBuffer cmdbuffer, const char * pMarkerName, const Color4f &color)
-{
-	//Check for valid function pointer (may not be present if not running in a debugging application)
-	if(!dmf.Begin)return;
-	
-	VkDebugMarkerMarkerInfoEXT markerInfo = {};
-	markerInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT;
-	memcpy(markerInfo.color, &color, sizeof(float) * 4);
-	markerInfo.pMarkerName = pMarkerName;
-	
-	dmf.Begin(cmdbuffer, &markerInfo);
-}
-
-void DebugMaker::Insert(VkCommandBuffer cmdbuffer, const char *markerName, const Color4f &color)
-{
-	// Check for valid function pointer (may not be present if not running in a debugging application)
-	if(!dmf.Insert)return;
-	
-	VkDebugMarkerMarkerInfoEXT markerInfo = {};
-	markerInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT;
-	memcpy(markerInfo.color, &color, sizeof(float) * 4);
-	markerInfo.pMarkerName = markerName;
-
-	dmf.Insert(cmdbuffer, &markerInfo);
-}
-
-void DebugMaker::End(VkCommandBuffer cmdBuffer)
-{
-	// Check for valid function (may not be present if not running in a debugging application)
-	if(!dmf.End)return;
-
-	dmf.End(cmdBuffer);
-}
-
-DebugMaker *CreateDebugMaker(VkDevice device)
-{
-	DebugMakerFunction dmf;
-
-	dmf.SetObjectTag	= reinterpret_cast<PFN_vkDebugMarkerSetObjectTagEXT	>(vkGetDeviceProcAddr(device, "vkDebugMarkerSetObjectTagEXT"));
-	dmf.SetObjectName	= reinterpret_cast<PFN_vkDebugMarkerSetObjectNameEXT>(vkGetDeviceProcAddr(device, "vkDebugMarkerSetObjectNameEXT"));
-	dmf.Begin			= reinterpret_cast<PFN_vkCmdDebugMarkerBeginEXT		>(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerBeginEXT"));
-	dmf.End				= reinterpret_cast<PFN_vkCmdDebugMarkerEndEXT		>(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerEndEXT"));
-	dmf.Insert			= reinterpret_cast<PFN_vkCmdDebugMarkerInsertEXT	>(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT"));
-
-	if(!dmf.SetObjectTag	)return(nullptr);
-	if(!dmf.SetObjectName	)return(nullptr);
-	if(!dmf.Begin			)return(nullptr);
-	if(!dmf.End				)return(nullptr);
-	if(!dmf.Insert			)return(nullptr);
-
-	return(new DebugMaker(device,dmf));
-}
-VK_NAMESPACE_END

src/SceneGraph/Vulkan/Debug/VKDebugOut.cpp

@@ -62,6 +62,7 @@ namespace
     VkResult CreateDebugUtilsMessengerEXT(VkInstance instance,const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo,const VkAllocationCallbacks *pAllocator,VkDebugUtilsMessengerEXT *pDebugMessenger)
     {
         auto func=(PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance,"vkCreateDebugUtilsMessengerEXT");
+
         if(func)
         {
             return func(instance,pCreateInfo,pAllocator,pDebugMessenger);
@@ -75,6 +76,7 @@ namespace
     void DestroyDebugUtilsMessengerEXT(VkInstance instance,VkDebugUtilsMessengerEXT debugMessenger,const VkAllocationCallbacks *pAllocator)
     {
         auto func=(PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance,"vkDestroyDebugUtilsMessengerEXT");
+
         if(func)
         {
             func(instance,debugMessenger,pAllocator);
@@ -85,10 +87,8 @@ namespace
                                             VkDebugUtilsMessageTypeFlagsEXT messageType,
                                             const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
     {
-        if(messageSeverity&VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)   
-            std::cerr<<"[ERROR] ";           else
-        if(messageSeverity&VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) 
-            std::cerr<<"[WARNING] ";         else
+        if(messageSeverity&VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)   std::cerr<<"[ERROR] ";           else
+        if(messageSeverity&VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) std::cerr<<"[WARNING] ";         else
         if(messageSeverity&VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT)    std::cerr<<"[INFO] ";            else
         if(messageSeverity&VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) std::cerr<<"[VERBOSE] ";         else
                                                                             std::cerr<<"[Validation layer] ";
@@ -147,10 +147,8 @@ namespace
     {
         const char *obj_type_name=GetVkDebugReportObjectTypename(objType);
 
-        if(msgFlags&VK_DEBUG_REPORT_ERROR_BIT_EXT)              
-            std::cerr<<"[ERROR:";               else
-        if(msgFlags&VK_DEBUG_REPORT_WARNING_BIT_EXT)            
-            std::cerr<<"[WARNING:";             else
+        if(msgFlags&VK_DEBUG_REPORT_ERROR_BIT_EXT)              std::cerr<<"[ERROR:";               else
+        if(msgFlags&VK_DEBUG_REPORT_WARNING_BIT_EXT)            std::cerr<<"[WARNING:";             else
         if(msgFlags&VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT)std::cerr<<"[PERFORMANCE WARNING:"; else
         if(msgFlags&VK_DEBUG_REPORT_INFORMATION_BIT_EXT)        std::cerr<<"[INFO:";                else
         if(msgFlags&VK_DEBUG_REPORT_DEBUG_BIT_EXT)              std::cerr<<"[DEBUG:";

src/SceneGraph/Vulkan/Debug/VKDebugUtils.cpp

@@ -23,6 +23,8 @@ DebugUtils *CreateDebugUtils(VkDevice device)
 
 void DebugUtils::SetName(VkObjectType type,uint64_t handle,const char *name)
 {
+    if(!handle||!name||!*name)return;
+
     VkDebugUtilsObjectNameInfoEXT name_info={};
 
     name_info.sType         =VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;

src/SceneGraph/Vulkan/VKCommandBuffer.cpp

@@ -28,27 +28,18 @@ bool GPUCmdBuffer::Begin()
 #ifdef _DEBUG
 void GPUCmdBuffer::SetDebugName(const UTF8String &object_name)
 {
-    if(dev_attr->debug_maker)
-        dev_attr->debug_maker->SetCommandBuffer(cmd_buf,"[debug_maker]"+object_name);
-    
     if(dev_attr->debug_utils)
-        dev_attr->debug_utils->SetCommandBuffer(cmd_buf,"[debug_utils]"+object_name);
+        dev_attr->debug_utils->SetCommandBuffer(cmd_buf,object_name);
 }
 
 void GPUCmdBuffer::BeginRegion(const UTF8String &region_name,const Color4f &color)
 {
-    if(dev_attr->debug_maker)
-        dev_attr->debug_maker->Begin(cmd_buf,"[debug_maker]"+region_name,color);
-
     if(dev_attr->debug_utils)
-        dev_attr->debug_utils->CmdBegin(cmd_buf,"[debug_utils]"+region_name,color);
+        dev_attr->debug_utils->CmdBegin(cmd_buf,region_name,color);
 }
 
 void GPUCmdBuffer::EndRegion()
 {
-    if(dev_attr->debug_maker)
-        dev_attr->debug_maker->End(cmd_buf);
-
     if(dev_attr->debug_utils)
         dev_attr->debug_utils->CmdEnd(cmd_buf);
 }

src/SceneGraph/Vulkan/VKCommandBufferRender.cpp

@@ -14,8 +14,6 @@ RenderCmdBuffer::RenderCmdBuffer(const GPUDeviceAttribute *attr,VkCommandBuffer
     hgl_zero(render_area);
     hgl_zero(viewport);
 
-    default_line_width=1.0;
-
     fbo=nullptr;
     pipeline_layout=VK_NULL_HANDLE;
 }
@@ -40,13 +38,10 @@ void RenderCmdBuffer::SetFBO(Framebuffer *fb)
         clear_values[cv_count-1].depthStencil.depth = 1.0f;
         clear_values[cv_count-1].depthStencil.stencil = 0;
     }
-    else
+    else if(clear_values)
     {
-        if(clear_values)
-        {
-            hgl_free(clear_values);
-            clear_values=nullptr;
-        }
+        hgl_free(clear_values);
+        clear_values=nullptr;
     }
 
     render_area.offset.x=0;
@@ -94,7 +89,6 @@ bool RenderCmdBuffer::BeginRenderPass()
 
     vkCmdSetViewport(cmd_buf,0,1,&viewport);
     vkCmdSetScissor(cmd_buf,0,1,&render_area);
-    vkCmdSetLineWidth(cmd_buf,default_line_width);
 
     pipeline_layout=VK_NULL_HANDLE;
 
@@ -117,6 +111,8 @@ bool RenderCmdBuffer::BindDescriptorSets(Material *mtl)
 
             if(mp)
             {
+                mp->Update();
+
                 ds[count]=mp->GetVkDescriptorSet();
                 ++count;
             }

src/SceneGraph/Vulkan/VKDescriptorBindingManage.cpp

@@ -3,6 +3,26 @@
 #include<hgl/graph/VKMaterialInstance.h>
 
 VK_NAMESPACE_BEGIN
+void DescriptorBinding::BindUBO(MaterialParameters *mp,const BindingMap &binding_map,bool dynamic)
+{
+    if (binding_map.GetCount() <= 0)return;
+        
+    DeviceBuffer* buf = nullptr;
+
+    const auto *dp      =binding_map.GetDataList();
+    const uint  count   =binding_map.GetCount();
+
+    for(uint i=0;i<count;i++)
+    {
+        buf=GetUBO((*dp)->key);
+
+        if(buf)
+            mp->BindUBO((*dp)->value,buf,dynamic);
+
+        ++dp;
+    }
+}
+
 bool DescriptorBinding::Bind(Material *mtl)
 {
     if(!mtl)
@@ -15,47 +35,13 @@ bool DescriptorBinding::Bind(Material *mtl)
 
     const BindingMapArray &bma=mp->GetBindingMap();
 
-    const BindingMap &ubo_bm=bma[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER];
-    const BindingMap &ubo_dynamic_bm=bma[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC];
-
 //    const BindingMap &ssbo_bm=bma[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER];
 //    const BindingMap &ssbo_dynamic_bm=bma[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC];
 
 //    const BindingMap &texture_bm=bma[VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER];
 
-    DeviceBuffer *buf=nullptr;
-
-    if(ubo_bm.GetCount()>0)
-    {
-        const auto *dp=ubo_bm.GetDataList();
-        const uint count=ubo_bm.GetCount();
-
-        for(uint i=0;i<count;i++)
-        {
-            buf=GetUBO((*dp)->key);
-
-            if(buf)
-                mp->BindUBO((*dp)->value,buf,false);
-
-            ++dp;
-        }
-    }
-
-    if(ubo_dynamic_bm.GetCount()>0)
-    {
-        const auto *dp=ubo_dynamic_bm.GetDataList();
-        const uint count=ubo_dynamic_bm.GetCount();
-
-        for(uint i=0;i<count;i++)
-        {
-            buf=GetUBO((*dp)->key);
-
-            if(buf)
-                mp->BindUBO((*dp)->value,buf,true);
-
-            ++dp;
-        }
-    }
+    BindUBO(mp,bma[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER],false);
+    BindUBO(mp,bma[VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC],true);
 
     mp->Update();
     return(true);

src/SceneGraph/Vulkan/VKDevice.cpp

@@ -23,7 +23,7 @@ GPUDevice::GPUDevice(GPUDeviceAttribute *da)
     sc_rt=nullptr;
     Resize(attr->surface_caps.currentExtent);
 
-    texture_cmd_buf=CreateTextureCommandBuffer();
+    texture_cmd_buf=CreateTextureCommandBuffer(attr->physical_device->GetDeviceName()+AnsiString(":TexCmdBuffer"));
     texture_queue=CreateQueue();
 }
 
@@ -50,7 +50,7 @@ bool GPUDevice::Resize(const VkExtent2D &extent)
     return(sc_rt);
 }
 
-VkCommandBuffer GPUDevice::CreateCommandBuffer()
+VkCommandBuffer GPUDevice::CreateCommandBuffer(const AnsiString &name)
 {
     if(!attr->cmd_pool)
         return(VK_NULL_HANDLE);
@@ -68,21 +68,26 @@ VkCommandBuffer GPUDevice::CreateCommandBuffer()
     if(res!=VK_SUCCESS)
         return(VK_NULL_HANDLE);
 
+#ifdef _DEBUG
+    if(attr->debug_utils)
+        attr->debug_utils->SetCommandBuffer(cmd_buf,name);
+#endif//_DEBUG
+
     return cmd_buf;
 }
 
-RenderCmdBuffer *GPUDevice::CreateRenderCommandBuffer()
+RenderCmdBuffer *GPUDevice::CreateRenderCommandBuffer(const AnsiString &name)
 {
-    VkCommandBuffer cb=CreateCommandBuffer();
+    VkCommandBuffer cb=CreateCommandBuffer(name);
 
     if(cb==VK_NULL_HANDLE)return(nullptr);
 
     return(new RenderCmdBuffer(attr,cb));
 }
 
-TextureCmdBuffer *GPUDevice::CreateTextureCommandBuffer()
+TextureCmdBuffer *GPUDevice::CreateTextureCommandBuffer(const AnsiString &name)
 {
-    VkCommandBuffer cb=CreateCommandBuffer();
+    VkCommandBuffer cb=CreateCommandBuffer(name);
 
     if(cb==VK_NULL_HANDLE)return(nullptr);
 

src/SceneGraph/Vulkan/VKDeviceAttribute.cpp

@@ -21,8 +21,6 @@ GPUDeviceAttribute::GPUDeviceAttribute(VulkanInstance *inst,const GPUPhysicalDev
 GPUDeviceAttribute::~GPUDeviceAttribute()
 {
 #ifdef _DEBUG
-    if(debug_maker)
-        delete debug_maker;
     if(debug_utils)
         delete debug_utils;
 #endif//_DEBUG

src/SceneGraph/Vulkan/VKDeviceCreater.cpp

@@ -7,7 +7,6 @@
 #include<hgl/graph/VKTexture.h>
 #include<hgl/graph/VKDeviceCreater.h>
 #include<hgl/graph/VKDevice.h>
-#include<hgl/graph/VKDebugMaker.h>
 
 #include<iostream>
 #include<iomanip>
@@ -18,7 +17,6 @@ VkPipelineCache CreatePipelineCache(VkDevice device,const VkPhysicalDeviceProper
 void SetShaderCompilerVersion(const GPUPhysicalDevice *);
 
 #ifdef _DEBUG
-DebugMaker *CreateDebugMaker(VkDevice);
 DebugUtils *CreateDebugUtils(VkDevice);
 
 void LogSurfaceFormat(const VkSurfaceFormatKHR *surface_format_list,const uint32_t format_count,const uint32_t select)
@@ -293,11 +291,6 @@ GPUDevice *VulkanDeviceCreater::CreateRenderDevice()
     if(!device_attr->device)
         return(nullptr);
 
-#ifdef _DEBUG
-    device_attr->debug_maker=CreateDebugMaker(device_attr->device);
-    device_attr->debug_utils=CreateDebugUtils(device_attr->device);
-#endif//_DEBUG
-
     ChooseSurfaceFormat();
 
     device_attr->surface_format=surface_format;
@@ -321,15 +314,29 @@ GPUDevice *VulkanDeviceCreater::CreateRenderDevice()
 
     auto_delete.Discard();  //discard autodelete
 
+    #ifdef _DEBUG
+        device_attr->debug_utils=CreateDebugUtils(device_attr->device);
+
+        if(device_attr->debug_utils)
+        {
+            device_attr->debug_utils->SetPhysicalDevice(*physical_device,"Physical Device:"+AnsiString(physical_device->GetDeviceName()));
+            device_attr->debug_utils->SetDevice(device_attr->device,"Device:"+AnsiString(physical_device->GetDeviceName()));
+            device_attr->debug_utils->SetSurfaceKHR(surface,"Surface");
+            device_attr->debug_utils->SetCommandPool(device_attr->cmd_pool,"Main Command Pool");
+            device_attr->debug_utils->SetDescriptorPool(device_attr->desc_pool,"Main Descriptor Pool");
+            device_attr->debug_utils->SetPipelineCache(device_attr->pipeline_cache,"Main Pipeline Cache");
+        }
+    #endif//_DEBUG
+
     return(new GPUDevice(device_attr));
 }
 
 VulkanDeviceCreater::VulkanDeviceCreater(   VulkanInstance *vi,
                                             Window *win,
+                                            const VulkanHardwareRequirement *req,
                                             const PreferFormats *spf_color,
                                             const PreferColorSpaces *spf_color_space,
-                                            const PreferFormats *spf_depth,
-                                            const VulkanHardwareRequirement *req)
+                                            const PreferFormats *spf_depth)
 {
     instance=vi;
     window=win;

src/SceneGraph/Vulkan/VKDeviceRenderPass.cpp

@@ -11,6 +11,11 @@ void GPUDevice::InitRenderPassManage()
     SwapchainRenderbufferInfo rbi(attr->surface_format.format,attr->physical_device->GetDepthFormat());
 
     device_render_pass=render_pass_manage->AcquireRenderPass(&rbi);
+
+    #ifdef _DEBUG
+        if(attr->debug_utils)
+            attr->debug_utils->SetRenderPass(device_render_pass->GetVkRenderPass(),"MainDeviceRenderPass");
+    #endif//_DEBUG
 }
 
 void GPUDevice::ClearRenderPassManage()