rendering.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.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"
#include "api/v1/types/world_objects.h"
 
#ifndef BLAM
#define BLAM
#endif
 
#define GUI_RENDER_QUEUE_GROUP_ID 200 
#define BLAM_OGRE_RESOURCE_GROUP Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME 
 
struct material;
struct bitmap;
struct render_model;
struct light;
class ogre_material_info_data;
 
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);
};
 
class BlamRaycast
{
 
};
 
namespace Blam::Rendering
{
    BLAM bool Initialize();
 
    BLAM void RenderLoop();
 
    BLAM void RenderThread();
 
    BLAM void PauseRenderThread();
 
    BLAM void ResumeRenderThread();
 
    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();
 
    BLAM BlamVector3 GetMousePosition3D();
    BLAM BlamVector2 GetScreenPointFrom3DPoint(BlamVector3 point);
    BLAM BlamVector3 GetGizmoMousePosition3D();
 
    BLAM std::vector<BlamWorldObject*> RaycastScreen(int screen_x, int screen_y, bool sort_by_distance = true,
        uint16_t max_results = 0U, BlamQueryFlags query_flags = BlamQueryFlags::QF_EXCLUDE_GIZMOS);
 
    BLAM std::vector<BlamWorldObject*> RaycastScreenNormalized(float screen_normalized_x, float screen_normalized_y,
        bool sort_by_distance = true, uint16_t max_results = 0U, BlamQueryFlags query_flags = BlamQueryFlags::QF_EXCLUDE_GIZMOS);
 
    BLAM std::vector<BlamWorldObject*> Raycast(BlamVector3 origin, BlamVector3 direction, bool sort_by_distance = true,
        uint16_t max_results = 0U, BlamQueryFlags query_flags = BlamQueryFlags::QF_EXCLUDE_GIZMOS);
 
    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 Models
    {
        BLAM void LoadModel(render_model* model, std::string tag_path);
        BLAM Ogre::MeshPtr GetModelFromTagPath(std::string tag_path);
        BLAM void LoadPendingModels();
        BLAM void UnloadModels();
    }
 
    namespace Lights
    {
        BLAM Ogre::Light* CreateLightFromTag(light* light);
    }
 
    namespace Utils {}
}