world_objects.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
 
#include <Strings/components/classes/events/events.h>
#include <Strings/components/classes/vector/vector.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"
 
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;
 
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,
    Unspecified
};
 
enum class Blam3DPrimitiveRenderMode
{
    Solid,
    Wireframe,
    Both
};
 
enum class BlamGizmoTransformMode
{
    NONE,
    TRANSLATE,
    ROTATE,
    SCALE
};
 
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 = "";
 
public:
    uint64_t id = 0;                    
    
    std::string description = "";       
    int editor_folder_id = 0;           
 
    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();
 
    virtual void ShowImGuiEditControls();
 
    uint64_t GetID();
    Ogre::SceneNode* GetParentSceneNode();
 
    BlamVector3 GetRotation();
    void SetRotation(BlamVector3 _rotation, bool local_axes = false);
    void SetRotation(float x, float y, float z, bool local_axes = false);
    void SetRotation(BlamAxis axis, float amount, bool local_axes = false);
    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 GetHidden();
    void SetHidden(bool hidden);
    std::string GetName();
    void SetName(std::string name);
 
    virtual void OnMouseHoverEnter();
    virtual void OnMouseHoverExit();
 
    virtual void OnMouseMove(MouseMoveEvent* event);
    virtual void OnMouseClick(MouseClickEvent* event);
    virtual void OnMouseUnclick(MouseUnclickEvent* event);
};
 
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);
 
    void Render() override;
};
 
class BLAM_EXT_API BlamWorldObject_Tag : public BlamWorldObject
{
private:
    int last_poke_key = 0;
    BlamTagData* old_tag_data = nullptr;
    bool valid_tag = false;
    std::string error_text = "";
    bool needs_recreate = true;
 
    BlamWorldObject_Primitive* bounds_object = nullptr;
    BlamWorldObject_GizmoTransform* transform = nullptr;
 
    void RecreateNodeObjects();
 
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();
 
    bool ValidateTagData();
    bool IsValidTag();
    std::string GetErrorText();
    void SetTransformEnabled(bool enabled);
};
 
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_ANY;
    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:
    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() override;
    void SetCustomDatabablock(Ogre::HlmsDatablock* datablock, bool wireframe);
    void ShowImGuiEditControls() override;
 
    void MarkForRebuild();
 
    void SetDepthCheckEnabled(bool enable);
 
    void SetQueryMask(uint32_t mask);
};
 
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() 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() 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() override;
    void ShowImGuiEditControls() override;
};
 
class BLAM_EXT_API BlamWorldObject_Gizmo : public BlamWorldObject
{
protected:
    bool needs_update = true;
    bool needs_rebuild = true;
 
public:
    BlamWorldObject_Gizmo(BlamWorldState* _world, BlamWorldObjectType _type) : BlamWorldObject(_world, _type) {};
    BlamWorldObject_Gizmo(BlamWorldObject* _parent, BlamWorldObjectType _type) : BlamWorldObject(_parent, _type) {};
 
    virtual void Render();
    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() override;
    void Rebuild() override;
    void Update() override;
    void ShowImGuiEditControls() 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_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() 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();
};
 
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() 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*>(); 
 
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);
 
    bool Drop(BlamTagData* tag_data, BlamVector3 position);
 
    void OnTickEvent(TickEvent* event);
 
    void RenderObjects();
};