world_objects.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
#include <map>
 
#include <Strings/components/classes/events/events.h>
#include <Strings/components/classes/vector/vector.h>
#include <bgfx/bgfx.h>
#include <blam/api/v1/types/tags.h>
 
#ifdef BLAM_EXPORTS
#define BLAM_EXT_API __declspec(dllexport) 
#else
#define BLAM_EXT_API __declspec(dllimport) 
#endif
 
#define WORLD_OBJECT_USER_KEY "WOBJ"
#define RENDERABLE_SHADER_USER_KEY "RSHD"
 
#define STATE_FLAGS_GIZMO BGFX_STATE_WRITE_RGB | BGFX_STATE_WRITE_A | BGFX_STATE_CULL_CCW | BGFX_STATE_BLEND_ALPHA
 
namespace Ogre
{
    class ManualObject;
    class SceneNode;
    class HlmsDatablock;
    class Aabb;
    class MovableObject;
}
 
class BlamWorldState;
class BlamTagData;
class TickEvent;
class BlamWorldObject_Primitive;
class BlamWorldObject;
class BlamWorldObject_GizmoTransform;
class BlamTagObjectScript;
class BlamUIWidget_Text;
class BlamWorldObject_Text3D;
class mesh;
class ManualMesh;
struct BlamOrientedBoundingBox;
 
enum BlamQueryFlags : uint32_t
{
    QF_ENGINE_GIZMO = 1 << 1,
    QF_ENGINE_RESERVED_0 = 1 << 2,
    QF_ENGINE_RESERVED_1 = 1 << 3,
    QF_ENGINE_RESERVED_2 = 1 << 4,
    QF_ENGINE_RESERVED_3 = 1 << 5,
    QF_ENGINE_RESERVED_4 = 1 << 6,
    QF_USER_0 = 1 << 7,
    QF_USER_1 = 1 << 8,
    QF_USER_2 = 1 << 9,
    QF_USER_3 = 1 << 10,
    QF_USER_4 = 1 << 11,
    QF_USER_5 = 1 << 12,
    QF_USER_6 = 1 << 13,
    QF_USER_7 = 1 << 14,
    QF_USER_8 = 1 << 15,
    QF_USER_9 = 1 << 16,
    QF_USER_10 = 1 << 17,
    QF_USER_11 = 1 << 18,
    QF_USER_12 = 1 << 19,
    QF_USER_13 = 1 << 20,
    QF_USER_14 = 1 << 21,
    QF_USER_15 = 1 << 22,
    QF_USER_16 = 1 << 23,
    QF_USER_17 = 1 << 24,
    QF_USER_18 = 1 << 25,
    QF_USER_19 = 1 << 26,
    QF_USER_20 = 1 << 27,
    QF_USER_21 = 1 << 28,
    QF_USER_22 = 1 << 29,
    QF_USER_23 = 1 << 30,
    QF_USER_24 = 1 << 31,
 
    QF_NONE = 0,
    QF_ANY = 0xFFFFFFFF,
    QF_EXCLUDE_GIZMOS = QF_ANY & ~QF_ENGINE_GIZMO,
};
 
struct BlamRaycastEntry
{
    float distance = 0.0f;
    BlamWorldObject* object = nullptr;
};
 
enum class BlamWorldObjectType
{
    Tag,
    Primitive,
    PrimitiveCuboid,
    PrimitiveSphere,
    PrimitiveCylinder,
    PrimitiveLine,
    PrimitiveCapsule,
    Group,
    GizmoTransform,
    GizmoRotate,
    GizmoScale,
    GizmoGrid,
    GizmoVolume,
    Gizmo3DCursor,
    Text3D,
    Unspecified
};
 
enum class Blam3DPrimitiveRenderMode
{
    Solid,
    Wireframe,
    Both
};
 
enum class BlamGizmoTransformMode
{
    NONE,
    TRANSLATE,
    ROTATE,
    SCALE
};
 
enum class BlamTransformSpace
{
    Local,
    Parent,
    World
};
 
class BLAM_EXT_API BlamWorldObject
{
private:
    bool needs_name_update = false;
    bool needs_hidden_update = false;
    bool needs_position_update = false;
    bool needs_rotation_update = false;
    bool next_rotate_local_axes = false;
    bool needs_scale_update = false;
 
    BlamVector3 position = BlamVector3();
    BlamVector3 rotation = BlamVector3();
    BlamVector3 scale = { 1, 1, 1 };
    BlamVector3 scale_modifier = { 1, 1, 1 };
    bool hidden = false;
    std::string name = "";
 
    std::map<std::string, BlamVector4> custom_shader_parameters = std::map<std::string, BlamVector4>();
 
public:
    uint64_t id = 0;                    
    
    std::string description = "";       
    int editor_folder_id = 0;           
 
    bool disable_culling = false;
    uint64_t state_flags = BGFX_STATE_DEFAULT | BGFX_STATE_CULL_CCW | BGFX_STATE_BLEND_ALPHA;
 
    BlamWorldState* world = nullptr;    
    BlamWorldObject* parent = nullptr;
 
    BlamWorldObjectType type = BlamWorldObjectType::Unspecified; 
 
    Ogre::SceneNode* scene_node = nullptr;
 
    BlamWorldObject(BlamWorldState* _world, BlamWorldObjectType _type);
 
    BlamWorldObject(BlamWorldObject* _parent, BlamWorldObjectType _type);
    virtual ~BlamWorldObject();
 
    virtual void Render(float delta);
 
    virtual void Tick(int tick, int total_ticks) {}
 
    virtual void ShowImGuiEditControls();
 
    uint64_t GetID();
    Ogre::SceneNode* GetParentSceneNode();
 
    BlamVector3 GetRotation();
    void SetRotation(BlamVector3 _rotation, bool local_axes = true);
    void SetRotation(float x, float y, float z, bool local_axes = true);
    void SetRotation(BlamAxis axis, float amount, bool local_axes = true);
 
    BlamVector3 GetAbsolutePosition();
    BlamVector3 GetPosition();
    void SetPosition(BlamVector3 position);
    void SetPosition(float x, float y, float z);
 
    BlamVector3 GetScale();
    void SetScale(BlamVector3 scale);
    void SetScale(float x, float y, float z);
 
    BlamVector3 GetScaleModifier();
    void SetScaleModifier(BlamVector3 scale);
    void SetScaleModifier(float x, float y, float z);
 
    bool IsHidden();
    bool GetHidden();
    void SetHidden(bool hidden);
    std::string GetName();
    void SetName(std::string name);
 
    void Translate(BlamVector3 offset, BlamTransformSpace transform_space = BlamTransformSpace::Parent);
    void Rotate(BlamVector3 axis, float rotation_amount, BlamTransformSpace transform_space = BlamTransformSpace::Parent);
    BlamVector3 GetDirection();
 
    virtual void OnMouseHoverEnter();
    virtual void OnMouseHoverExit();
 
    virtual void OnMouseMove(MouseMoveEvent* event);
    virtual void OnMouseClick(MouseClickEvent* event);
    virtual void OnMouseUnclick(MouseUnclickEvent* event);
 
    virtual uint32_t GetQueryMask();
    virtual BlamOrientedBoundingBox GetWorldOBB();
 
    void CreateSceneNode();
 
    void SetShaderParameter(std::string id, float value);
    void SetShaderParameter(std::string id, BlamVector2 value);
    void SetShaderParameter(std::string id, BlamVector3 value);
    void SetShaderParameter(std::string id, BlamVector4 value);
 
    float GetShaderParameterFloat(std::string id);
    BlamVector2 GetShaderParameterVector2(std::string id);
    BlamVector3 GetShaderParameterVector3(std::string id);
    BlamVector4 GetShaderParameterVector4(std::string id);
};
 
class BLAM_EXT_API BlamWorldObject_Group : public BlamWorldObject
{
private:
    std::vector<BlamWorldObject*> children = std::vector<BlamWorldObject*>();
 
public:
    void AddObject(BlamWorldObject* object);
 
    void RemoveObject(uint64_t object_id);
 
    int GetObjectCount();
 
    bool HasObject(uint64_t object_id);
 
    BlamWorldObject* GetObjectAtIndex(int index);
 
    BlamWorldObject* GetObjectById(uint64_t object_id);
 
    BlamWorldObject* GetObjectByName(std::string name, bool recursive_search = false);
 
    void Render(float delta) override;
 
    void Tick(int tick, int total_ticks) override;
};
 
class BLAM_EXT_API BlamWorldObject_Tag : public BlamWorldObject
{
private:
    int last_poke_key = 0;
    BlamTagData* old_tag_data = nullptr;
    bool valid_tag = false;
    bool needs_recreate = true;
    uint32_t query_mask = BlamQueryFlags::QF_EXCLUDE_GIZMOS;
 
    std::string script_id = "";
    BlamTagObjectScript* script = nullptr;
 
    BlamWorldObject_Primitive* bounds_object = nullptr;
    BlamWorldObject_GizmoTransform* transform = nullptr;
 
    virtual void _PreRecreateNodeObjects() {};
    virtual void _RecreateNodeObjects() {};
    virtual bool _IsTagSupported() { return false; };
    virtual void _PreRender() {};
    virtual void _Render(float delta) {};
 
protected:
    std::string error_text = "";
    BlamWorldObject_Text3D* bounds_debug_info = nullptr;
 
public:
    BlamTagData* tag_data = nullptr; 
    Ogre::MovableObject* ogre_item = nullptr;
 
    BlamWorldObject_Tag(BlamTagData* _tag_data, BlamWorldState* _world);
    BlamWorldObject_Tag(BlamTagData* _tag_data, BlamWorldObject* _parent);
    ~BlamWorldObject_Tag();
 
    void Render(float delta) override;
    void Tick(int tick, int total_ticks) override;
 
    bool ValidateTagData();
    bool IsValidTag();
    std::string GetErrorText();
    void SetTransformEnabled(bool enabled);
    void MarkForRecreate();
    void DestroyAttachments();
    void SetQueryMask(uint32_t mask);
    uint32_t GetQueryMask() override;
 
    void RecreateNodeObjects();
 
    std::vector<BlamWorldObject*> GetTransformGizmoObjects();
};
 
class BlamWorldObject_TagLight : public BlamWorldObject_Tag
{
private:
    bool is_sun = false;
    BlamWorldObject_Text3D* unsupported_warning_message = nullptr;
 
    void _PreRecreateNodeObjects() override;
    void _RecreateNodeObjects() override;
    bool _IsTagSupported() override;
    void _Render(float delta) override;
    void ShowImGuiEditControls() override;
 
public:
    bool override_color = false;
    BlamColor color = BlamColor();
 
    bool override_priority = false;
    int priority = 0;
 
    BlamWorldObject_TagLight(BlamTagData* _tag_data, BlamWorldState* _world);
    BlamWorldObject_TagLight(BlamTagData* _tag_data, BlamWorldObject* _parent);
};
 
class BlamWorldObject_TagRenderModel : public BlamWorldObject_Tag
{
private:
    mesh* mesh = nullptr;
 
    void _RecreateNodeObjects() override;
    bool _IsTagSupported() override;
    void _PreRender() override;
    void _Render(float delta) override;
 
public:
    BlamWorldObject_TagRenderModel(BlamTagData* _tag_data, BlamWorldState* _world);
    BlamWorldObject_TagRenderModel(BlamTagData* _tag_data, BlamWorldObject* _parent);
 
    BlamOrientedBoundingBox GetWorldOBB() override;
};
 
class BlamWorldObject_TagTileMap : public BlamWorldObject_Tag
{
private:
    bool last_tilemap_debug = false;
    Ogre::ManualObject* tilemap_object = nullptr;
    ManualMesh* tilemap_mesh = nullptr;
 
    void _RecreateNodeObjects() override;
    bool _IsTagSupported() override;
    void _PreRender() override;
    void _Render(float delta) override;
 
    void RecreateTilemapBgfx();
 
public:
    BlamWorldObject_TagTileMap(BlamTagData* _tag_data, BlamWorldState* _world);
    BlamWorldObject_TagTileMap(BlamTagData* _tag_data, BlamWorldObject* _parent);
    ~BlamWorldObject_TagTileMap();
};
 
class BLAM_EXT_API BlamWorldObject_Primitive : public BlamWorldObject
{
private:
    bool cached_cast_shadows = true;
 
    BlamColor cached_color = BlamColor(255, 255, 255);
    BlamColor cached_color_wireframe = BlamColor(255, 255, 255);
    Blam3DPrimitiveRenderMode cached_render_mode = Blam3DPrimitiveRenderMode::Solid;
    uint32_t query_mask = BlamQueryFlags::QF_EXCLUDE_GIZMOS;
    bool cached_show_backfaces = false;
    bool needs_rebuild = false;
    bool enable_depth_check = true;
    bool depth_check_needs_update = false;
    bool query_mask_needs_update = true;
 
protected:
    ManualMesh* manual_mesh = nullptr;
 
    bool custom_datablock = false;
    bool custom_wireframe_datablock = false;
 
    virtual void CreateManualObject();
 
public:
    Ogre::ManualObject* manual_object = nullptr;
    Ogre::HlmsDatablock* datablock = nullptr;
    Ogre::HlmsDatablock* datablock_wireframe = nullptr;
 
    BlamColor color = BlamColor(255, 255, 255);
    BlamColor color_wireframe = BlamColor(255, 255, 255);
    Blam3DPrimitiveRenderMode render_mode = Blam3DPrimitiveRenderMode::Solid;
    bool show_backfaces = false;
    bool cast_shadows = true;
 
    BlamWorldObject_Primitive(BlamWorldObjectType _type, BlamWorldState* _world);
    BlamWorldObject_Primitive(BlamWorldObjectType _type, BlamWorldObject* _parent);
    ~BlamWorldObject_Primitive();
 
    void Render(float delta) override;
    void SetCustomDatabablock(Ogre::HlmsDatablock* datablock, bool wireframe);
    void ShowImGuiEditControls() override;
 
    void MarkForRebuild();
 
    void SetDepthCheckEnabled(bool enable);
 
    void SetQueryMask(uint32_t mask);
    uint32_t GetQueryMask() override;
    BlamOrientedBoundingBox GetWorldOBB() override;
};
 
class BLAM_EXT_API BlamWorldObject_PrimitiveCuboid : public BlamWorldObject_Primitive
{
private:
    void CreateManualObject() override;
 
public:
    BlamWorldObject_PrimitiveCuboid(BlamWorldState* _world);
    BlamWorldObject_PrimitiveCuboid(BlamWorldObject* _parent);
};
 
class BLAM_EXT_API BlamWorldObject_PrimitiveSphere : public BlamWorldObject_Primitive
{
private:
    void CreateManualObject() override;
 
private:
    float cached_radius_0 = 1.0f;
    float cached_radius_1 = 1.0f;
    int cached_resolution = 5;
    int cached_vertical_resolution = 5;
    int cached_lines_x = 5;
    int cached_lines_y = 5;
 
public:
    float radius_0 = 1.0f; 
    float radius_1 = 1.0f; 
    int resolution = 5;    
    int vertical_resolution = 5; 
    int lines_x = 5;
    int lines_y = 5;
 
    std::vector<BlamVector3> vertices = std::vector<BlamVector3>();
 
    BlamWorldObject_PrimitiveSphere(BlamWorldState* _world);
    BlamWorldObject_PrimitiveSphere(BlamWorldObject* _parent);
 
    void Render(float delta) override;
    void ShowImGuiEditControls() override;
};
 
class BLAM_EXT_API BlamWorldObject_PrimitiveCylinder : public BlamWorldObject_Primitive
{
private:
    void CreateManualObject() override;
 
private:
    float cached_radius_0 = 1.0f;
    float cached_radius_1 = 1.0f;
    int cached_resolution = 5;
    int cached_lines = 5;
 
public:
    float radius_0 = 1.0f; 
    float radius_1 = 1.0f; 
    int resolution = 5;    
    int lines = 5;
 
    BlamWorldObject_PrimitiveCylinder(BlamWorldState* _world);
    BlamWorldObject_PrimitiveCylinder(BlamWorldObject* _parent);
 
    void Render(float delta) override;
    void ShowImGuiEditControls() override;
};
 
class BLAM_EXT_API BlamWorldObject_PrimitiveLine : public BlamWorldObject_Primitive
{
private:
    BlamVector3 start = BlamVector3();
    BlamVector3 end = BlamVector3();
 
    void CreateManualObject() override;
 
public:
    BlamWorldObject_PrimitiveLine(BlamWorldState* _world);
    BlamWorldObject_PrimitiveLine(BlamWorldObject* _parent);
 
    void SetStartPoint(BlamVector3 point);
    void SetEndPoint(BlamVector3 point);
 
    void SetDirection(BlamVector3 direction);
    void SetLength(float length);
 
    BlamVector3 GetStartPoint();
    BlamVector3 GetEndPoint();
    BlamVector3 GetDirection();
    float GetLength();
 
    void Render(float delta) override;
    void ShowImGuiEditControls() override;
};
 
class BLAM_EXT_API BlamWorldObject_Text3D : public BlamWorldObject
{
private:
    BlamUIWidget_Text* text_element = nullptr;
 
public:
    BlamWorldObject_Text3D(BlamWorldState* _world);
    BlamWorldObject_Text3D(BlamWorldObject* _parent);
    ~BlamWorldObject_Text3D();
 
    void Render(float delta) override;
    void ShowImGuiEditControls() override;
 
    BlamColor GetColor();
    void SetColor(BlamColor color);
 
    BlamColor GetShadowColor();
    void SetShadowColor(BlamColor color);
 
    std::string GetText();
    void SetText(std::string text);
};
 
class BLAM_EXT_API BlamWorldObject_Gizmo : public BlamWorldObject
{
protected:
    bool needs_update = true;
    bool needs_rebuild = true;
    bgfx::VertexBufferHandle vb = { bgfx::kInvalidHandle };
    bgfx::IndexBufferHandle ib = { bgfx::kInvalidHandle };
    bgfx::VertexLayout vl;
 
public:
    BlamWorldObject_Gizmo(BlamWorldState* _world, BlamWorldObjectType _type) : BlamWorldObject(_world, _type) {};
    BlamWorldObject_Gizmo(BlamWorldObject* _parent, BlamWorldObjectType _type) : BlamWorldObject(_parent, _type) {};
 
    virtual void Render(float delta);
    virtual void Update() = 0;
    virtual void Rebuild() = 0;
    void MarkForUpdate();
    void MarkForRebuild();
};
 
class BLAM_EXT_API BlamWorldObject_GizmoGrid : public BlamWorldObject_Gizmo
{
private:
    int primary_spacing = 10;
    int secondary_spacing = 1;
    BlamColor primary_color = BlamColor(191, 191, 191);
    BlamColor secondary_color = BlamColor(127, 127, 127);
    bool mark_axes = false;
 
    Ogre::HlmsDatablock* primary_datablock = nullptr;
    Ogre::HlmsDatablock* secondary_datablock = nullptr;
    
    BlamVector3 origin = BlamVector3();
    int max_distance = 100;
 
    Ogre::ManualObject* manual_object = nullptr;
 
    void DestroyManualObject();
 
public:
    BlamWorldObject_GizmoGrid(BlamWorldState* _world);
    BlamWorldObject_GizmoGrid(BlamWorldObject* _parent);
    ~BlamWorldObject_GizmoGrid();
 
    void Render(float delta) override;
    void Rebuild() override;
    void Update() override;
    void ShowImGuiEditControls() override;
    BlamOrientedBoundingBox GetWorldOBB() override;
};
 
class BLAM_EXT_API BlamWorldObject_GizmoTransform : public BlamWorldObject_Gizmo
{
private:
    BlamWorldObject_PrimitiveCuboid* cube_center = nullptr;
    BlamWorldObject_PrimitiveCuboid* cube_x = nullptr;
    BlamWorldObject_PrimitiveCuboid* cube_y = nullptr;
    BlamWorldObject_PrimitiveCuboid* cube_z = nullptr;
    BlamWorldObject_PrimitiveLine* line_x = nullptr;
    BlamWorldObject_PrimitiveLine* line_y = nullptr;
    BlamWorldObject_PrimitiveLine* line_z = nullptr;
    BlamWorldObject_Primitive* rotate_x = nullptr;
    BlamWorldObject_Primitive* rotate_y = nullptr;
    BlamWorldObject_Primitive* rotate_z = nullptr;
 
    BlamWorldObject_PrimitiveSphere* start_marker = nullptr;
    BlamWorldObject_PrimitiveSphere* end_marker = nullptr;
 
    BlamWorldObject_PrimitiveSphere* CreateSphere(BlamColor color);
    BlamWorldObject_PrimitiveCuboid* CreateCuboid(BlamColor color, BlamColor fill, BlamAxis axis = BlamAxis::NONE);
    BlamWorldObject_PrimitiveLine* CreateLine(BlamColor color, BlamVector3 start, BlamVector3 end);
    BlamWorldObject_Primitive* CreateRotationTriangle(BlamAxis axis = BlamAxis::NONE);
 
    float cube_size = 0.17f;
    float screen_scale = 0.18f;
 
    BlamGizmoTransformMode transform_mode = BlamGizmoTransformMode::NONE;
    BlamAxis axis = BlamAxis::NONE;
    BlamVector2 mouse_position_initial = BlamVector2();
 
    BlamVector3 position_initial = BlamVector3();
    BlamVector3 rotation_initial = BlamVector3();
    BlamVector3 scale_initial = BlamVector3();
 
    BlamWorldObject_Tag* associated_object = nullptr;
    uint32_t original_query_flags = 0;
 
public:
    BlamWorldObject_GizmoTransform(BlamWorldState* _world);
    BlamWorldObject_GizmoTransform(BlamWorldObject* _parent);
    ~BlamWorldObject_GizmoTransform();
 
    void Render(float delta) override;
    void Rebuild() override;
    void Update() override;
    void ShowImGuiEditControls() override;
    void OnMouseMove(MouseMoveEvent* event) override;
 
    void SetTransformMode(BlamGizmoTransformMode mode, BlamAxis _axis);
    void SetQueryMask(BlamQueryFlags mask);
 
    void SetAssociatedObject(BlamWorldObject_Tag* object);
    void RemoveAssociatedObject();
 
    std::vector<BlamWorldObject*> GetGizmoObjects();
};
 
class BLAM_EXT_API BlamWorldObject_Gizmo3DCursor : public BlamWorldObject_Gizmo
{
private:
    BlamWorldObject_PrimitiveSphere* cursor = nullptr;
 
public:
    BlamWorldObject_Gizmo3DCursor(BlamWorldState* _world);
    BlamWorldObject_Gizmo3DCursor(BlamWorldObject* _parent);
    ~BlamWorldObject_Gizmo3DCursor();
 
    void Render(float delta) override;
    void Rebuild() override;
    void Update() override;
    void ShowImGuiEditControls() override;
};
 
class BLAM_EXT_API BlamWorldState : public BlamEventListener
{
private:
    std::vector<BlamWorldObject*> objects = std::vector<BlamWorldObject*>(); 
 
    BlamWorldObject_Tag* active_camera = nullptr;
 
public:
    Ogre::SceneNode* root_node = nullptr;
 
    BlamWorldState();
 
    ~BlamWorldState();
 
    void AddObject(BlamWorldObject* object);
 
    bool RemoveObject(uint64_t object_id, bool delete_data = true);
 
    int GetObjectCount();
 
    bool HasObject(uint64_t object_id);
 
    BlamWorldObject* GetObjectAtIndex(int index);
 
    BlamWorldObject* GetObjectById(uint64_t object_id);
 
    BlamWorldObject* GetObjectByName(std::string name, bool recursive_search = false);
 
    bool Drop(BlamTagData* tag_data, BlamVector3 position);
 
    void OnTickEvent(TickEvent* event);
 
    void RenderObjects(float delta);
 
    void SetActiveCamera(BlamWorldObject_Tag* camera);
 
    BlamWorldObject_Tag* GetActiveCamera();
 
    BlamWorldObject_Tag* CreateTagObject(BlamTagData* tag_data, bool add_to_world = true);
};