rendering.h

Go to the documentation of this file.

#pragma once
 
#include <d3d11_1.h>
#include <d2d1_1.h>
#include <dwrite.h>
 
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_win32.h>
 
#include <glew/glew.h>
#include <sdl2/SDL.h>
 
#include <string>
#include <vector>
 
#include "components/3rdparty/imgui/imgui.h"
#include "components/diagnostics/errors/errors.h"
 
#ifndef BLAM
#define BLAM
#endif
 
enum BlamRenderingEngine
{
    DirectX11,
    Vulkan,
    OpenGL3,
    BGFX,
    NotReady
};
 
namespace BlamRendering
{
    namespace Vulkan
    {
        namespace DebugMessenger
        {
            BLAM void Initialize();
 
            BLAM void Shutdown();
 
            BLAM void PopulateCreateInfo(VkDebugUtilsMessengerCreateInfoEXT* create_info);
        }
 
        namespace Device
        {
            BLAM std::vector<VkPhysicalDevice> GetDeviceList();
 
            BLAM bool IsDeviceSuitable(VkPhysicalDevice device);
 
            BLAM int RateDeviceSuitability(VkPhysicalDevice device);
 
            BLAM void SelectManualDevice(int device_index);
 
            BLAM void SelectBestDevice();
 
            BLAM void SelectDefaultDevice();
 
            BLAM void CreateLogicalDevice();
 
            BLAM void DestroyLogicalDevice();
        }
 
        namespace Presentation
        {
            BLAM void CreateSurface();
 
            BLAM VkSurfaceKHR* GetSurface();
 
            BLAM void DestroySurface();
 
            BLAM VkQueue* GetPresentQueue();
        }
 
        BLAM void Initialize();
 
        BLAM void RenderLoop();
 
        BLAM void Shutdown();
 
        BLAM bool CheckValidationLayerSupport();
 
        BLAM VkInstance* GetInstance();
        
        BLAM bool ValidationLayersEnabled();
 
        BLAM std::vector<const char*> GetEnabledLayers();
 
        BLAM std::vector<VkExtensionProperties> GetAvailableExtensions();
 
        BLAM std::vector<VkLayerProperties> GetAvailableLayers();
 
        BLAM std::vector<const char*> GetRequiredExtensions();
 
        BLAM void PrintVulkanAvailabilityInfo();
    }
 
    namespace DirectX
    {
        namespace D2D
        {
            BLAM ID2D1DeviceContext*  GetD2DRenderTarget();
 
            BLAM ID2D1Factory*        GetD2DFactory();
 
            BLAM IDWriteFactory*      GetDWriteFactory();
 
            BLAM HRESULT              LoadFontFromFile(std::string id, std::string file_path);
        }
 
        namespace WIC
        {
            BLAM IWICImagingFactory*  GetWICFactory();
 
            BLAM HRESULT              CreateD2DBitmapFromResource(int res_id, const char* res_type, ID2D1Bitmap **bitmap_pointer);
 
            BLAM HRESULT              CreateD2DBitmapFromFile(std::wstring path, ID2D1Bitmap **bitmap_pointer);
 
            BLAM HRESULT              CreateWICBitmapFromFile(std::wstring path, IWICBitmap** bitmap_pointer);
 
            BLAM HRESULT              CreateWICBitmapFromMemory(void* data, int size, IWICBitmap** bitmap_pointer);
 
            BLAM HRESULT              ConvertWICBitmapToD2D(IWICBitmap* wic_bitmap, ID2D1Bitmap** d2d_bitmap);
 
            BLAM HRESULT              ConvertWICBitmapToD2D(IWICBitmap* wic_bitmap, ID2D1Bitmap** d2d_bitmap, ID2D1RenderTarget* render_target);
 
            BLAM HRESULT              ConvertWICBitmapTo32bppPBGRA(IWICBitmap* source, IWICBitmap** destination);
 
            BLAM HRESULT              Initialize();
 
            BLAM void                 Shutdown();
        }
 
        BLAM ID3D11Device*            GetD3DDevice();
 
        BLAM ID3D11DeviceContext*     GetD3DContext();
 
        BLAM IDXGISwapChain*          GetDXGISwapChain();
 
        BLAM ID3D11RenderTargetView*  GetD3DRenderTargetView();
 
        BLAM DXGI_SWAP_CHAIN_DESC     GetSwapChainDesc();
 
        BLAM HRESULT                  Initialize(HWND hWnd);
 
        BLAM void                     Cleanup();
 
        BLAM HRESULT                  HandleWindowResize(LPARAM lParam);
 
        BLAM bool*                    RenderTargetClearing();
 
        BLAM void                     RenderLoop(bool debug);
 
        BLAM void                     ShutdownRenderThread();
 
        BLAM void                     RenderThread(bool debug);
 
        BLAM bool                     HasRenderThreadStopped();
 
        BLAM void                     SetClearColor(ImVec4 color);
 
        BLAM ImVec4*                  GetClearColor();
 
        BLAM HRESULT                  UpdateResolution(int x, int y);
 
        BLAM ID3D11Texture2D**        GetLastFrameTexture();
 
        BLAM HRESULT                  GetLastFrameTextureAlt(ID3D11Texture2D* texture);
 
        BLAM void                     ScreenshotDone();
 
        BLAM HRESULT                  GetLastFrameHResult();
        
        BLAM void                     DisplayDetailedCrashScreen(const char* expression, const char* file, int line, std::string details);
 
        BLAM void                     DisplayBasicCrashScreen();
 
        BLAM void                     DisplaySignalCrashScreen(int signal);
    }
 
    namespace OpenGL
    {
        BLAM BlamResult      Initialize();
 
        BLAM void            RenderLoop();
 
        BLAM void            Shutdown();
 
        BLAM SDL_GLContext*  GetGLContext();
    }
 
    namespace BGFX
    {
        BLAM void SetPlatformData();
 
        BLAM void Initialize();
        BLAM void RenderLoop();
        BLAM void Shutdown();
 
        BLAM void HandleWindowReisze(int width, int height);
 
        BLAM void SetViewClearFlags(int new_flags);
 
        BLAM uint16_t Get3DViewID();
        BLAM uint16_t Get2DViewID();
 
        BLAM int GetRenderWidth();
        BLAM int GetRenderHeight();
    }
 
    // Abstract/Shared Functions, these will usually interface with the active graphics API themselves //
 
    BLAM BlamRenderingEngine          GetCurrentRenderingEngine();
 
    BLAM void                         SetClearColor(ImVec4 color);
 
    BLAM ImVec4*                      GetClearColor();
 
    BLAM void                         ShowCrashScreen(const char* exc, const char* file, int line, std::string message);
 
    BLAM HRESULT                      SetDisplayRes(int x, int y); //Sets screen resolution
 
 
    BLAM void                         HandleWindowResize(int width, int height, WPARAM wParam);
}
 
namespace Blam
{
    BLAM void                         TakeScreenshot();
}