rendering.h

Go to the documentation of this file.

#pragma once
 
#include <d3d11_1.h>
#include <d2d1_1.h>
#include <dwrite.h>
 
#include <sdl2/SDL.h>
#include <sdl2/SDL_events.h>
 
#include <OGRE/Hlms/Pbs/OgreHlmsPbsDatablock.h>
#include <OGRE/Hlms/Unlit/OgreHlmsUnlitDatablock.h>
#include <Strings/components/classes/map/map.h>
 
#include <string>
#include <vector>
 
#include "components/3rdparty/imgui/imgui.h"
#include "components/3rdparty/ogre2/GraphicsSystem.h"
#include "components/diagnostics/errors/errors.h"
#include "api/v1/types/tags.h"
 
#ifndef BLAM
#define BLAM
#endif
 
struct material;
struct bitmap;
class ogre_material_info_data;
 
enum BlamRenderingEngine
{
    DirectX11,
    BGFX,
    OGRE,
    NotReady
};
 
struct ogre_material_instance_data
{
    ogre_material_info_data* original_material = nullptr;
    std::string referencing_tag_path = "";
    Ogre::HlmsDatablock* instance_datablock = nullptr;
    material* tag_instance = nullptr;
    bool needs_reload = false;
    bool persistent_reload = false;
};
 
class ogre_material_info_data
{
public:
    std::string tag_path = "";
    Ogre::HlmsDatablock* datablock = nullptr;
    bool needs_reload = false;
    bool persistent_reload = false;
    Ogre::HlmsTypes hlms_type = Ogre::HlmsTypes::HLMS_UNLIT;
 
    BlamMap<std::string, ogre_material_instance_data*> instances = BlamMap<std::string, ogre_material_instance_data*>();
 
    ogre_material_instance_data* CreateNewInstance(BlamTagData* referencing_tag);
};
 
namespace BlamRendering
{
    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 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();
    }
 
    namespace OGRE
    {
        BLAM bool Initialize();
        BLAM void RenderLoop();
        BLAM void RenderThread();
        BLAM void Shutdown();
 
        BLAM void ProcessSDLEvents(SDL_Event* event);
 
        BLAM Demo::GraphicsSystem* GetGraphicsSystem();
 
        BLAM void HandleWindowReisze(int width, int height);
 
        BLAM int GetRenderWidth();
        BLAM int GetRenderHeight();
 
        BLAM Ogre::Window* GetRenderWindow();
 
        BLAM double GetDeltaTime();
 
        BLAM void TakeScreenshot();
        BLAM void WriteScreenshot();
 
        BLAM Ogre::SceneManager* Get2DSceneManager();
        BLAM Ogre::Camera* Get2DCamera();
 
        BLAM void DisplayBasicCrashScreen(std::string additional_info = "");
        BLAM void DisplayDetailedCrashScreen(std::string expression, std::string file, int line, std::string message);
 
        BLAM bool GetImGuiHiddenState();
        
        namespace Materials
        {
            BLAM void RebuildDatablocks();
            BLAM bool BuildDatablockFromTag(material* material_tag, std::string tag_path);
            BLAM void ReloadPendingMaterials();
            BLAM Ogre::HlmsDatablock* GetDatablockFromTag(std::string tag_path);
 
            BLAM ogre_material_instance_data* GetDatablockInstanceFromTag(std::string tag_path, std::string referencing_tag_path);
            BLAM ogre_material_instance_data* CreateDatablockInstance(std::string tag_path, std::string referencing_tag_path);
 
            BLAM bool LoadPBSDatablockFromMaterialTag(Ogre::HlmsPbsDatablock* datablock, material* material_tag);
            BLAM bool LoadUnlitDatablockFromMaterialTag(Ogre::HlmsUnlitDatablock* datablock, material* material_tag);
 
            BLAM Ogre::HlmsUnlitDatablock* CreateDefaultUnlitDatablock(std::string id);
            BLAM Ogre::HlmsUnlitDatablock* CreateDefaultUnlitDatablockForPrimitives(std::string id);
            BLAM Ogre::HlmsPbsDatablock* CreateDefaultPbsDatablock(std::string id);
            BLAM Ogre::HlmsPbsDatablock* CreateDefaultPbsDatablockForPrimitives(std::string id);
        }
 
        namespace Textures
        {
            BLAM void BuildTextureFromTag(bitmap* bitmap_tag, std::string tag_path);
            BLAM Ogre::TextureGpu* GetTextureFromTag(std::string tag_path);
            BLAM void ReloadPendingBitmaps();
 
            BLAM Ogre::TextureGpu* LoadTexture2D(std::string id, void* pixel_data, int width, int height, Ogre::PixelFormatGpu format, int bytes_per_line);
        }
 
        namespace Utils {}
 
        /*namespace ColibriUI
        {
            void Initialize();
            void RenderLoop();
            void Shutdown();
        }*/
    }
 
    // 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();
}