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 <bgfx/bgfx.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 "components/rendering/bgfx/types.h"
#include "api/v1/types/tags.h"
#include "api/v1/types/world_objects.h"
#include "api/v1/types/tags/classes/bitmap.h"
 
#ifndef BLAM
#define BLAM
#endif
 
#define GUI_RENDER_QUEUE_GROUP_ID 200 
#define BLAM_OGRE_RESOURCE_GROUP Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME 
 
#define SHADER_DEFAULT_UNLIT "@@unlit_shader"
#define SHADER_DEFAULT_PBR "@@pbr_shader"
#define SHADER_DEFAULT_DEFERRED_GBUFFER "@@deferred_gbuffer"
#define SHADER_DEFAULT_DEFERRED_GBUFFER_INSTANCED "@@deferred_gbuffer_instanced"
#define SHADER_DEFAULT_DEFERRED_LIGHT_PASS "@@deferred_light_pass"
#define SHADER_DEFAULT_DEFERRED_POSTPROCESS "@@deferred_postprocess"
#define SHADER_DEFAULT_SSAO "@@deferred_ssao"
#define SHADER_DEFAULT_SSAO_BLUR "@@deferred_ssao_blur"
#define SHADER_DEFAULT_SHADOW "@@deferred_shadow"
#define SHADER_DEFAULT_SHADOW_POINT "@@deferred_shadow_cube"
#define SHADER_DEFAULT_SHADOW_INSTANCED "@@deferred_shadow_instanced"
#define SHADER_DEFAULT_SHADOW_POINT_INSTANCED "@@deferred_shadow_cube_instanced"
#define VIEWID_DEFAULT VIEWID_GBUFFER
 
#define PASS_SHADOW "pass_shadow"
#define PASS_GBUFFER "pass_gbuffer"
#define PASS_FORWARD "pass_forward"
#define PASS_LIGHTING "pass_lighting"
#define PASS_POSTPROCESS "pass_postprocess"
#define PASS_SSAO "pass_ssao"
#define PASS_UI "pass_ui"
 
#define VIEWID_GBUFFER Blam::RenderingBGFX::Passes::GetViewID(PASS_GBUFFER)
#define VIEWID_LIGHTING Blam::RenderingBGFX::Passes::GetViewID(PASS_LIGHTING)
#define VIEWID_FORWARD Blam::RenderingBGFX::Passes::GetViewID(PASS_FORWARD)
#define VIEWID_POSTPROCESS Blam::RenderingBGFX::Passes::GetViewID(PASS_POSTPROCESS)
#define VIEWID_2D Blam::RenderingBGFX::Passes::GetViewID(PASS_UI)
 
#define BITMAP_DEFAULT_WHITE "@@shaders/default_bitmaps/white.bitmap"
#define BITMAP_DEFAULT_GRAY_50 "@@shaders/default_bitmaps/gray_50_percent.bitmap"
#define BITMAP_DEFAULT_NORMAL "@@shaders/default_bitmaps/default_normal.bitmap"
#define BITMAP_DEFAULT_ROUGHNESS "@@shaders/default_bitmaps/default_roughness.bitmap"
 
struct material;
struct render_model;
struct light;
struct shader;
struct shader_program;
struct tile_set;
class ogre_material_info_data;
class BlamRenderPass;
class BlamShadowCasterState;
struct BlamTextureRef;
struct BlamFrustum;
 
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;   
};
 
/*struct tile_data
{
    uint32_t tile_index;
};*/
 
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
{
 
};
 
bool UsingBgfx();
 
namespace Blam::RenderingBGFX
{
    BLAM bool Initialize();
 
    BLAM void RenderLoop();
 
    BLAM void Shutdown();
 
    BLAM void HandleWindowReisze(int width, int height);
 
    BLAM void SetViewClearFlags(uint16_t flags);
    BLAM void SetResetFlags(uint32_t flags);
 
    BLAM void TakeScreenshot();
 
    BLAM int GetRenderWidth();
 
    BLAM int GetRenderHeight();
 
    BLAM uint64_t GetDefault2DStateFlags();
    BLAM void SetDefault2DStateFlags(uint64_t flags);
 
    BLAM float* GetCameraViewMatrix();
    BLAM float* GetCameraProjectionMatrix();
    BLAM BlamVector2 GetScreenPointFrom3DPoint(BlamVector3 position);
    BLAM void PrepareScreenQuad();
 
    BLAM BlamVector3 GetMousePosition3D();
    BLAM BlamVector3 GetGizmoMousePosition3D();
 
    BLAM BlamOrientedBoundingBox CreateOBBFromAABB(BlamVector3 position, BlamVector3 rotation, 
        BlamVector3 scale, BlamVector3 local_aabb_min, BlamVector3 local_aabb_max);
 
    BLAM BlamRay CreateRayFromViewportPoint(int screen_x, int screen_y);
 
    bool IsViewportMode2D();
 
    namespace Textures
    {
        BLAM void BuildTextureFromTag(bitmap* bitmap_tag, std::string tag_path);
 
        BLAM bgfx::TextureHandle GetTextureFromTag(std::string tag_path);
 
        BLAM void ReloadPendingBitmaps();
 
        BLAM bgfx::TextureHandle LoadTexture2D(std::string id, void* pixel_data, int width, int height, 
            bgfx::TextureFormat::Enum format, int bytes_per_line, uint64_t flags = 0);
 
        BLAM bgfx::TextureHandle get_newest_bitmap();
 
        BLAM bgfx::TextureHandle GetDefaultTexture();
 
        BLAM void ReleaseTextures();
 
        BLAM void LoadDefaultTextures();
 
        // Get the abstract texture ref for a bitmap tag. On first call,
        // uploads the bitmap's pixel data into the appropriate size-class
        // array and returns a ref. Subsequent calls return the cached ref.
        //
        // Returns invalid ref if the tag isn't loaded or the upload fails.
        //
        // In Phase 1, nothing in the engine currently calls this - it's
        // available for testing. Phase 2 will route material textures
        // through this API.
        BlamTextureRef GetTextureRefFromTag(std::string tag_path);
 
        // Hook for the tag system. Call this from the tag unload path
        // BEFORE the bitmap's pixel data buffer goes away. Releases both
        // GPU forms of this texture (raw handle and array ref) and
        // removes the entry from the texture map.
        //
        // Safe to call for any tag path - if the path doesn't have a
        // tracked texture, this is a no-op.
        //
        // Implementation lives in bitmaps.cpp.
        void OnBitmapTagUnloading(std::string tag_path);
 
    }
 
    namespace Models
    {
        BLAM void LoadModel(render_model* model, std::string tag_path);
        BLAM mesh* GetModelFromTagPath(std::string tag_path);
 
        BLAM void ReleaseModels();
    }
 
    namespace Materials
    {
        BLAM bool BuildMaterialFromTag(material* material_tag, std::string tag_path);
        BLAM void ApplyMaterialParameters(mesh::submesh* submesh, std::string material_tag_path);
        BLAM bgfx::ProgramHandle GetMaterialProgram(std::string material_tag_path);
 
        // Marks a single material's bake as stale. Next draw using this
        // material rebuilds the bake from the current tag state. Cheap -
        // just flips a flag, no allocation.
        //
        // Call this from:
        //   - The editor when a material's properties are edited live
        //   - Any code that mutates a material tag at runtime
        void InvalidateMaterial(std::string tag_path);
 
        // Marks ALL material bakes as stale. Use this when a global
        // state change makes per-material bake assumptions invalid.
        //
        // Currently we recommend calling this from the texture-reload
        // path (Textures::ReleaseTextures, hot-reload of a bitmap, etc),
        // because bakes hold cached bgfx::TextureHandles that get
        // invalidated when the underlying texture is destroyed and
        // recreated. See bitmaps_diff.txt for the recommended hook.
        void InvalidateAllMaterials();
 
        // Frees all cached bake state. Call from engine shutdown after
        // the last frame submits but before bgfx::shutdown().
        void ReleaseMaterials();
    }
 
    namespace Shaders
    {
        BLAM void LoadDefaultShaders();
        BLAM bool ReloadShader(std::string name);
        BLAM bgfx::ProgramHandle GetDefaultProgram();
        BLAM bgfx::ProgramHandle GetProgram(std::string name);
        BLAM void ReleaseShaders();
        BLAM void ReloadPendingShaders();
        BLAM void ForceReloadAllShaders();
 
        BLAM void CreateDefaultUniforms();
        BLAM void DestroyUniforms();
 
        BLAM void SetShaderFlagsUniform(uint32_t flags = 0, bool use_globals = true);
        BLAM bgfx::UniformHandle GetUniform(std::string id);
    }
 
    namespace Stats
    {
        BLAM float GetCurrentFrameRate();
        BLAM float GetAverageFrameRate();
    }
 
    namespace Passes
    {
        BLAM BlamRenderPass* GetPass(std::string id);
        BLAM bgfx::ViewId ReserveViewID();
        BLAM bgfx::ViewId GetViewID(std::string id);
        BLAM std::vector<BlamRenderPass*> GetPassList();
    }
 
    namespace Lighting
    {
        BLAM void RefreshLightCache();
        BLAM int GetLightCacheIndex(BlamWorldObject* object);
        BLAM void SubmitLightUniforms(BlamVector3 cameraPos, BlamVector3 ambientColor);
        BLAM int FindLightSlotForShadowState(BlamShadowCasterState* state);
        BLAM int GetLightCacheCount();
        BLAM BlamWorldObject_Tag* GetLightCacheAt(int index);
 
 
        BLAM void AddShadowCaster(BlamWorldObject_TagLight* object);
        BLAM void RemoveShadowCaster(BlamWorldObject* object);
 
        // Random-access to the shadow caster list. Returns nullptr if
        // index is out of range. Use GetShadowCasterCount for bounds.
        // Callers can filter by light type and sort by their own criteria.
        BlamWorldObject_Tag* GetShadowCasterAt(int index);
 
        BLAM int GetShadowCasterCount();
 
        //BLAM int BuildFrameLightList(BlamVector3 camera_position, std::vector<BlamWorldObject_TagLight*>* out_lights);
        //
        // * Return the runtime shadow state associated with a light, creating
        // * and initializing GPU resources on first access. Returns nullptr
        // * if allocation failed (for example, if a cubemap depth attachment
        // * is not supported on the current backend).
        // */
        //BLAM BlamShadowCasterState* GetOrCreateShadowCasterState(BlamWorldObject_TagLight* object);
        //
        // * Free the GPU resources associated with a shadow caster. Called
        // * when a caster is removed, when the resolution changes, or on
        // * rendering shutdown.
        // */
        //BLAM void ReleaseShadowCasterState(BlamShadowCasterState* state);
        //
        // * Access the full list of runtime states for the current frame's
        // * active shadow casters. Populated by BlamShadowPass during its
        // * execution so the lighting pass can find matching states for
        // * lights submitted via SubmitLightUniforms.
        // */
        //BLAM std::vector<BlamShadowCasterState*>* GetActiveShadowStates();
 
        BLAM BlamWorldObject_Tag* GetFirstDirectionalShadowCaster();
    }
 
    namespace Culling
    {
        // Extract 6 frustum planes from a column-major view-projection matrix.
        // Standard Hartmann-Gribb formulation - planes come from sums and
        // differences of matrix rows.
        //
        // `vp_matrix` is expected to be col-major (bgfx convention). If you
        // have view and projection separately, multiply view * proj first.
        void ExtractFrustum(BlamFrustum* out_frustum, const float* vp_matrix);
 
        // Test an AABB against the frustum. Returns true if the AABB is at
        // least partially inside the frustum (i.e., should not be culled).
        // Returns false if the AABB is fully outside any single plane.
        //
        // Standard "p-vertex / n-vertex" test - for each plane, find the
        // AABB corner most in the negative direction relative to the plane
        // normal. If that corner is on the outside, the entire AABB is.
        bool AABBInFrustum(const BlamFrustum* frustum, BlamVector3 aabb_min, BlamVector3 aabb_max);
 
        // Test a sphere against the frustum. Returns true if at least
        // partially inside.
        bool SphereInFrustum(const BlamFrustum* frustum, BlamVector3 center, float radius);
 
        // Transform a model-space AABB by a world matrix to produce a
        // world-space AABB that contains the rotated/scaled box.
        //
        // This is "loose" - the result over-estimates the actual world-space
        // extent for rotated meshes. But it's safe (never under-estimates)
        // and very fast. The alternative (test frustum in object space) is
        // more accurate but more math per object.
        //
        // `world_matrix` is a column-major 4x4. For the standard object
        // transform produced by bx::mtxSRT, this is what you want.
        void TransformAABB(BlamVector3 model_min, BlamVector3 model_max, const float* world_matrix, 
            BlamVector3* out_world_min, BlamVector3* out_world_max);
 
        // Transform a sphere center by a world matrix. The radius is scaled
        // by the maximum scale factor of the matrix to handle non-uniform
        // scale (still conservative - if the matrix has very different
        // scales on different axes, a true tight world-space bounding sphere
        // would be ellipsoidal, but a sphere with radius = max-axis-scale *
        // model_radius is a safe over-estimate).
        void TransformSphere(BlamVector3 model_center, float model_radius,
            const float* world_matrix, BlamVector3* out_world_center, float* out_world_radius);
 
    }
}
 
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 void SetImGuiHiddenState(bool hide);
 
    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);
 
    BLAM bool HasZoomLevelChanged();
 
    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,
            std::string tag_path = "");
 
        BLAM bool LoadUnlitDatablockFromMaterialTag(Ogre::HlmsUnlitDatablock* datablock, material* material_tag,
            std::string tag_path = "");
 
        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);
 
        BLAM Ogre::TextureGpu* CreateAtlasFromTextures(std::string id, std::vector<bitmap*> bitmaps, std::vector<BlamVector2>* out_points);
    }
 
    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();
        BLAM bool WasModelReloaded(std::string tag_path);
    }
 
    namespace Lights
    {
        BLAM Ogre::Light* CreateLightFromTag(light* light);
    }
 
    namespace Shaders
    {
        BLAM void FillInstanceParameterBuffer(float* address, BlamWorldObject_Tag* object, shader* program);
        BLAM uint16_t CalculateInstanceBufferElementCount(shader* program);
 
        BLAM void LoadShader(shader* program, std::string tag_path);
 
        BLAM Ogre::HlmsDatablock* GetShaderDatablock(std::string tag_path);
        BLAM Ogre::MaterialPtr GetRawShaderMaterial(std::string tag_path);
 
        BLAM Ogre::MaterialPtr LoadRawShader(shader* shader, std::string tag_path);
 
        BLAM Ogre::GpuProgramParametersSharedPtr GetShaderParameters(std::string tag_path, Ogre::GpuProgramType shader_type);
    }
 
    namespace Tilesets
    {
        BLAM void LoadTileset(tile_set* tileset, std::string tag_path);
        BLAM void LoadPendingTilesets();
        BLAM Ogre::HlmsLowLevelDatablock* GetTilesetDatablock(std::string tag_path, int tile_index);
        BLAM Ogre::MaterialPtr GetTilesetMaterial(std::string tag_path, int tile_index);
        BLAM int GetTilesetSourceCount(std::string tag_path);
    }
 
    namespace Utils 
    {
        BLAM Ogre::FilterOptions ConvertBitmapFilterMode(bitmap_filtering_mode filter_mode);
    }
}