3d游戏引擎EngineTest的系统实现3

1.TestRenderer.h

#pragma once

#include "Test.h"

class engine_test : public test
{
public:
    bool initialize() override;
    void run() override;
    void shutdown() override;

};
2.TestRenderer.cpp

#include "..\Platform\PlatformTypes.h"
#include "..\Platform\Platform.h"
#include "../Graphics/Renderer.h"
#include "TestRenderer.h"
#include "ShaderCompilation.h"

#if TEST_RENDERER

template <bool test,typename T = void>
struct enable_if {};

template <typename T>
struct enable_if<true, T> { using type = T; };

template <bool test, typename T = void>
using enable_if_t = typename enable_if<test, T>::type;

template<typename T>
using iterator_cat_t = typename std::iterator_traits<T>::iterator_category;

template<typename T>
using void_t = void;

template <typename T,typename=void>
constexpr bool is_iterator_v = false;

template<typename T>
constexpr bool is_iterator_v<T, void_t<iterator_cat_t<T>>> = true;

template<typename T, enable_if_t<is_iterator_v<T>, int> = 0>
void function(T t) 
{
    

}

void function(int T) 
{

}

using namespace primal;

graphics::render_surface _surfaces[4];

time_it timer{};
void destroy_render_surface(graphics::render_surface& surface);

LRESULT win_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    function(1234);
    function(&hwnd);

    switch (msg)
    {
    case WM_DESTROY:
    {
        bool all_closed{ true };

        for (u32 i{ 0 }; i < _countof(_surfaces); ++i) {
            for (u32 i{ 0 }; i < _countof(_surfaces); ++i)
            {

                if (!_surfaces[i].window.is_closed())
                {
                    destroy_render_surface(_surfaces[i]);

                }
                else
                
                {
                    all_closed = false;

                }

            }
        }
        if (all_closed)
        {

            PostQuitMessage(0);
            return 0;

        }

    }
    break;

    case WM_SYSCHAR:
        if (wparam == VK_RETURN && (HIWORD(lparam) & KF_ALTDOWN))
        {
            platform::window win{ platform::window_id{(id::id_type)GetWindowLongPtr(hwnd,GWLP_USERDATA)} };
            win.set_fullscreen(!win.is_fullscreen());
            return 0;

        }

        break;

    case WM_KEYDOWN:
        if (wparam == VK_ESCAPE) 
        {
            PostMessage(hwnd, WM_CLOSE, 0, 0);
            return 0;
        
        
        
        }

    }

    return DefWindowProc(hwnd, msg, wparam, lparam);

}

void 
create_render_surface(graphics::render_surface& surface, platform::window_init_info info) 
{
    surface.window = platform::create_window(&info);
    surface.surface = graphics::create_surface(surface.window);

}

void
destroy_render_surface(graphics::render_surface& surface) 
{
    
    graphics::render_surface temp{ surface };
    surface = {};
    //graphics::remove_surface(surface.surface.get_id());
    //platform::remove_window(surface.window.get_id());
    if (temp.surface.is_valid())graphics::remove_surface(temp.surface.get_id());
    if (temp.window.is_valid())platform::remove_window(temp.window.get_id());

}

bool 
engine_test::initialize()
{
    while (!compile_shaders()) 
    {
        if (MessageBox(nullptr, L"Failed to compile engine shaders.", L"Shader Compilation Error", MB_RETRYCANCEL) != IDRETRY)
            return false;
    
    
    
    }

    if (!graphics::initialize(graphics::graphics_platform::direct3d12)) return false;
    //if (!result) return result;

    platform::window_init_info info[]
    {
        {&win_proc,nullptr,L"RenderWindow 1",100 - 2000,100 - 700,400,800 },
        {&win_proc,nullptr,L"RenderWindow 2",150 - 2000,150 - 700,800,400 },
        {&win_proc,nullptr,L"RenderWindow 3",200 - 2000,200 - 700,400,400 },
        {&win_proc,nullptr,L"RenderWindow 4",250 - 2000,250 - 700,800,600 },

    };
    static_assert(_countof(info) == _countof(_surfaces));

    for (u32 i{ 0 }; i < _countof(_surfaces); ++i)
        create_render_surface(_surfaces[i], info[i]);

    return true;

}

void engine_test::run()
{
    timer.begin();
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    //graphics::render();

    for (u32 i{ 0 }; i < _countof(_surfaces); ++i) 
    {
        if (_surfaces[i].surface.is_valid()) 
        {
        
        
            _surfaces[i].surface.render();
        
        }
    
    
    
    
    }

    timer.end();

}

void engine_test::shutdown()
{

    for (u32 i{ 0 }; i < _countof(_surfaces); ++i)
    

        destroy_render_surface(_surfaces[i]);

    graphics::shutdown();

}
#endif