全新整理的范例程序结构

example/Vulkan/main.cpp

@@ -22,23 +22,11 @@ using namespace hgl::graph;
 constexpr uint32_t SCREEN_WIDTH=1280;
 constexpr uint32_t SCREEN_HEIGHT=720;
 
-VkShaderModule vs=nullptr;
-VkShaderModule fs=nullptr;
-
 struct WorldConfig
 {
     Matrix4f mvp;    
 }world;
 
-vulkan::Buffer *CreateUBO(vulkan::Device *dev)
-{
-    const VkExtent2D extent=dev->GetExtent();
-
-    world.mvp=ortho(extent.width,extent.height);
-
-    return dev->CreateUBO(sizeof(WorldConfig),&world);
-}
-
 constexpr uint32_t VERTEX_COUNT=3;
 
 constexpr float vertex_data[VERTEX_COUNT][2]=
@@ -54,21 +42,10 @@ constexpr float color_data[VERTEX_COUNT][3]=
     {0,0,1}
 };
 
-vulkan::VertexBuffer *vertex_buffer=nullptr;
+void wait_seconds(double seconds) 
-vulkan::VertexBuffer *color_buffer=nullptr;
-
-void CreateVertexBuffer(vulkan::Device *dev,vulkan::Renderable *render_obj)
 {
-    vertex_buffer   =dev->CreateVBO(FMT_RG32F,  VERTEX_COUNT,vertex_data);
-    color_buffer    =dev->CreateVBO(FMT_RGB32F, VERTEX_COUNT,color_data);
-
-    render_obj->Set("Vertex",   vertex_buffer);
-    render_obj->Set("Color",    color_buffer);
-}
-
-void wait_seconds(int seconds) {
 #ifdef WIN32
-    Sleep(seconds * 1000);
+    Sleep(seconds * 1000.0f);
 #elif defined(__ANDROID__)
     sleep(seconds);
 #else
@@ -76,16 +53,196 @@ void wait_seconds(int seconds) {
 #endif
 }
 
-//class ExampleFramework
+class VulkanApplicationFramework
-//{
+{
-//    Window *win=nullptr;
+private:    
-//    vulkan::Instance *inst=nullptr;
+
-//    vulkan::Device *device=nullptr;
+            Window *            win             =nullptr;
-//    vulkan::Shader *shader=nullptr;
+    vulkan::Instance *          inst            =nullptr;
-//    vulkan::Buffer *ubo_mvp=nullptr;
+
-//    vulkan::VertexInput *vi=nullptr;
+protected:
-//    vulkan::PipelineCreater
+
-//};//
+    vulkan::Device *            device          =nullptr;
+    vulkan::ShaderModuleManage *shader_manage   =nullptr;
+
+public:
+
+    virtual ~VulkanApplicationFramework()
+    {   
+        SAFE_CLEAR(shader_manage);
+        SAFE_CLEAR(device);
+        SAFE_CLEAR(inst);
+        SAFE_CLEAR(win);
+    }
+
+    virtual bool Init(int w,int h) 
+    {
+        win=CreateRenderWindow(OS_TEXT("VulkanTest"));
+        if(!win)
+            return(false);
+
+        if(!win->Create(SCREEN_WIDTH,SCREEN_HEIGHT))
+            return(false);
+
+        inst=vulkan::CreateInstance(U8_TEXT("VulkanTest"));
+
+        if(!inst)
+            return(false);
+
+        device=inst->CreateRenderDevice(win);
+
+        if(!device)
+            return(false);
+
+        shader_manage=device->CreateShaderModuleManage();
+        
+        const vulkan::PhysicalDevice *render_device=device->GetPhysicalDevice();
+
+        std::cout<<"auto select physical device: "<<render_device->GetDeviceName()<<std::endl;
+        return(true);
+    }
+
+    void AcquireNextFrame()
+    {
+        device->AcquireNextImage();
+    }
+
+    void Submit(vulkan::CommandBuffer *cmd_buf)
+    {
+        device->QueueSubmit(cmd_buf);
+        device->Wait();
+        device->QueuePresent();
+    }
+};//class VulkanApplicationFramework
+
+class TestApp:public VulkanApplicationFramework
+{
+private:    //需释放数据
+
+    vulkan::Material *          material            =nullptr;
+    vulkan::MaterialInstance *  material_instance   =nullptr;
+    vulkan::Renderable *        render_obj          =nullptr;    
+    vulkan::Buffer *            ubo_mvp             =nullptr;
+
+    vulkan::PipelineCreater *   pipeline_creater    =nullptr;
+    vulkan::Pipeline *          pipeline            =nullptr;
+    vulkan::CommandBuffer *     cmd_buf             =nullptr;
+
+    vulkan::VertexBuffer *      vertex_buffer       =nullptr;
+    vulkan::VertexBuffer *      color_buffer        =nullptr;
+
+public:
+
+    ~TestApp()
+    {
+        SAFE_CLEAR(color_buffer);
+        SAFE_CLEAR(vertex_buffer);
+        SAFE_CLEAR(cmd_buf);
+        SAFE_CLEAR(pipeline);
+        SAFE_CLEAR(pipeline_creater);
+        SAFE_CLEAR(ubo_mvp);
+        SAFE_CLEAR(render_obj);
+        SAFE_CLEAR(material_instance);
+        SAFE_CLEAR(material);
+    }
+
+private:
+
+    bool InitMaterial()
+    {
+        material=shader_manage->CreateMaterial("FlatColor.vert.spv","FlatColor.frag.spv");
+        if(!material)
+            return(false);
+
+        material_instance=material->CreateInstance();
+        if(!material_instance)
+            return(false);
+
+        render_obj=material_instance->CreateRenderable();
+        return(true);
+    }
+
+    bool InitUBO()
+    {
+        const VkExtent2D extent=device->GetExtent();
+
+        world.mvp=ortho(extent.width,extent.height);
+
+        ubo_mvp=device->CreateUBO(sizeof(WorldConfig),&world);
+
+        if(!ubo_mvp)
+            return(false);
+        
+        return material_instance->UpdateUBO("world",*ubo_mvp);
+    }
+
+    void InitVBO()
+    {    
+        vertex_buffer   =device->CreateVBO(FMT_RG32F,  VERTEX_COUNT,vertex_data);
+        color_buffer    =device->CreateVBO(FMT_RGB32F, VERTEX_COUNT,color_data);
+
+        render_obj->Set("Vertex",   vertex_buffer);
+        render_obj->Set("Color",    color_buffer);
+    }
+
+    bool InitPipeline()
+    {
+        pipeline_creater=new vulkan::PipelineCreater(device,material_instance);
+        pipeline_creater->SetDepthTest(false);
+        pipeline_creater->SetDepthWrite(false);
+        pipeline_creater->CloseCullFace();
+        pipeline_creater->Set(PRIM_TRIANGLES);
+
+        pipeline=pipeline_creater->Create();
+
+        return pipeline;
+    }
+
+    bool InitCommandBuffer()
+    {
+        cmd_buf=device->CreateCommandBuffer();
+
+        if(!cmd_buf)
+            return(false);
+
+        cmd_buf->Begin(device->GetRenderPass(),device->GetFramebuffer(0));
+        cmd_buf->Bind(pipeline);
+        cmd_buf->Bind(render_obj);
+        cmd_buf->Draw(VERTEX_COUNT);
+        cmd_buf->End();
+
+        return(true);
+    }
+
+public:
+
+    bool Init() 
+    {
+        if(!VulkanApplicationFramework::Init(SCREEN_WIDTH,SCREEN_HEIGHT))
+            return(false);
+
+        if(!InitMaterial())
+            return(false);
+
+        if(!InitUBO())
+            return(false);
+
+        InitVBO();
+
+        if(!InitPipeline())
+            return(false);
+
+        if(!InitCommandBuffer())
+            return(false);
+
+        return(true);
+    }
+
+    void Draw()
+    {
+        Submit(cmd_buf);
+    }
+};//class TestApp:public VulkanApplicationFramework
 
 int main(int,char **)
 {
@@ -94,86 +251,15 @@ int main(int,char **)
         return 0xff;
     #endif//
 
-    Window *win=CreateRenderWindow(OS_TEXT("VulkanTest"));
+    TestApp app;
 
-    win->Create(SCREEN_WIDTH,SCREEN_HEIGHT);
+    if(!app.Init())
-
-    vulkan::Instance *inst=vulkan::CreateInstance(U8_TEXT("VulkanTest"));
-
-    if(!inst)
-    {
-        delete win;
         return(-1);
-    }
 
-    vulkan::Device *device=inst->CreateRenderDevice(win);
+    app.AcquireNextFrame();
+    app.Draw();
 
-    if(!device)
+    //wait_seconds(0.1);
-    {
-        delete inst;
-        delete win;
-        return(-2);
-    }
-
-    {
-        const vulkan::PhysicalDevice *render_device=device->GetPhysicalDevice();
-
-        std::cout<<"auto select physical device: "<<render_device->GetDeviceName()<<std::endl;
-    }
-
-    vulkan::ShaderModuleManage *shader_manage=device->CreateShaderModuleManage();
-
-    const vulkan::Material *material=shader_manage->CreateMaterial("FlatColor.vert.spv","FlatColor.frag.spv");
-
-    if(!material)
-        return -3;
-
-    vulkan::MaterialInstance *mi=material->CreateInstance();
-    vulkan::Renderable *render_obj=mi->CreateRenderable();
-    CreateVertexBuffer(device,render_obj);
-
-    vulkan::Buffer *ubo=CreateUBO(device);
-    mi->UpdateUBO("world",*ubo);
-
-    vulkan::PipelineCreater pc(device,mi);    
-    pc.SetDepthTest(false);
-    pc.SetDepthWrite(false);
-    pc.CloseCullFace();
-    pc.Set(PRIM_TRIANGLES);
-
-    vulkan::Pipeline *pipeline=pc.Create();
-
-    if(!pipeline)
-        return(-4);
-
-    device->AcquireNextImage();
-
-    vulkan::CommandBuffer *cmd_buf=device->CreateCommandBuffer();
-
-    cmd_buf->Begin(device->GetRenderPass(),device->GetFramebuffer(0));
-    cmd_buf->Bind(pipeline);
-    cmd_buf->Bind(render_obj);
-    cmd_buf->Draw(VERTEX_COUNT);
-    cmd_buf->End();
-
-    device->QueueSubmit(cmd_buf);
-    device->Wait();
-    device->QueuePresent();
-
-    wait_seconds(1);
-
-    delete vertex_buffer;
-    delete color_buffer;
-
-    delete pipeline;
-
-    delete ubo;
-    delete mi;
-
-    delete cmd_buf;
-    delete device;
-    delete inst;
-    delete win;
     
     return 0;
 }