World.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
#include <unordered_map>
#include <unordered_set>
 
#include "Assets/StaticMesh.h"
#include "Assets/Material.h"
#include "Assets/Texture.h"
#include "Nodes/Node.h"
#include "Nodes/Widgets/Widget.h"
#include "Clock.h"
#include "Line.h"
#include "EngineTypes.h"
#include "Nodes/3D/Camera3d.h"
#include "Nodes/3D/DirectionalLight3d.h"
 
class Node;
class Audio3D;
class Particle3D;
 
class POLYPHASE_API World
{
public:
 
    World();
    ~World();
 
    void Destroy();
 
    void Update(float deltaTime);
 
    Camera3D* GetMainCamera();
 
    Camera3D* GetActiveCamera();
    Camera3D* FindCameraForScreen(uint8_t targetScreen);
    Node3D* GetAudioReceiver();
 
    void SetActiveCamera(Camera3D* activeCamera);
    void SetCameraOverride(Camera3D* camera) { mCameraOverride = camera; }
    Camera3D* GetCameraOverride() const { return mCameraOverride; }
    void SetAudioReceiver(Node3D* newReceiver);
 
    Node* SpawnNode(TypeId actorType, glm::vec3 position = {});
    Node* SpawnNode(const char* typeName, glm::vec3 position = {});
    Node* SpawnScene(const char* sceneName, glm::vec3 position = {});
    Node* SpawnScene(Scene* scene, glm::vec3 position = {});
    void DespawnScene(Node* sceneRoot);
    Particle3D* SpawnParticle(ParticleSystem* sys, glm::vec3 position);
    Particle3D* SpawnParticle(ParticleSystem* sys, glm::vec3 position, glm::vec3 velocity);
 
    template<class NodeClass>
    NodeClass* SpawnNode(glm::vec3 position = {})
    {
        return (NodeClass*)SpawnNode(NodeClass::GetStaticType(), position);
    }
 
    Node* GetRootNode();
    void SetRootNode(Node* node);
    NodePtr GetRootNodePtr();
    void DestroyRootNode();
    Node* FindNode(const std::string& name);
    Node* GetNetNode(NetId netId);
    std::vector<Node*> FindNodesWithTag(const char* tag);
    std::vector<Node*> FindNodesWithName(const char* name);
    std::vector<Node*> GatherNodes();
    void GatherNodes(std::vector<Node*>& outNodes);
 
 
 
    Node* FindNodeByUuid(uint64_t uuid);
    void RegisterNodeUuid(Node* node);
    void UnregisterNodeUuid(Node* node);
 
    bool FindNavPath(glm::vec3 start, glm::vec3 end, std::vector<glm::vec3>& outPath);
    bool FindRandomNavPoint(glm::vec3& outPoint);
    bool FindClosestNavPoint(glm::vec3 inPoint, glm::vec3& outPoint);
    void BuildNavigationData();
    void EnableAutoNavRebuild(bool enable);
    bool IsAutoNavRebuildEnabled() const;
    void InvalidateNavMesh();
    void Clear();
 
    int32_t GetIndex() const;
 
    void AddLine(const Line& line);
    void RemoveLine(const Line& line);
    void RemoveAllLines();
    const std::vector<Line>& GetLines() const;
 
    const std::vector<class Light3D*>& GetLights();
    std::vector<FadingLight>& GetFadingLights();
 
    void SetAmbientLightColor(glm::vec4 color);
    glm::vec4 GetAmbientLightColor() const;
 
    void SetShadowColor(glm::vec4 shadowColor);
    glm::vec4 GetShadowColor() const;
 
    void SetFogSettings(const FogSettings& settings);
    const FogSettings& GetFogSettings() const;
 
    void SetGravity(glm::vec3 gravity);
    glm::vec3 GetGravity() const;
 
    btDynamicsWorld* GetDynamicsWorld();
    btDbvtBroadphase* GetBroadphase();
    void PurgeOverlaps(Primitive3D* prim);
 
    void RayTest(
        glm::vec3 start,
        glm::vec3 end,
        uint8_t collisionMask,
        RayTestResult& outResult,
        uint32_t numIgnoredObjects = 0,
        btCollisionObject** ignoreObjects = nullptr,
        bool ignorePureOverlap = true);
 
    void RayTestMulti(
        glm::vec3 start,
        glm::vec3 end,
        uint8_t collisionMask,
        bool ignorePureOverlap,
        RayTestMultiResult& outResult);
 
    void SweepTest(
        Primitive3D* primComp,
        glm::vec3 start,
        glm::vec3 end,
        uint8_t collisionMask,
        SweepTestResult& outResult);
 
    void SweepTest(
        btConvexShape* convexShape, 
        glm::vec3 start,
        glm::vec3 end,
        glm::quat rotation,
        uint8_t collisionMask,
        SweepTestResult& outResult,
        uint32_t numIgnoreObjects = 0,
        btCollisionObject** ignoreObjects = nullptr);
 
    void RegisterNode(Node* node, bool subRoot);
    void UnregisterNode(Node* node, bool subRoot);
    const std::vector<Audio3D*>& GetAudios() const;
 
    void LoadScene(const char* name, bool instant);
    void QueueRootScene(const char* name);
    void QueueRootNode(Node* node);
    const std::string& GetLoadedSceneName() const { return mLoadedSceneName; }
    void GetLoadedSceneNames(std::vector<std::string>& outNames);
 
    void EnableInternalEdgeSmoothing(bool enable);
    bool IsInternalEdgeSmoothingEnabled() const;
 
    void DirtyAllWidgets();
 
    void UpdateRenderSettings();
    void AddNewlyRegisteredNode(Node* node);
 
    Camera3D* SpawnDefaultCamera();
    Node* SpawnDefaultRoot();
    void PlaceNewlySpawnedNode(NodePtr node, glm::vec3 position);
 
    void OverrideDynamicsWorld(btDiscreteDynamicsWorld* world);
    void RestoreDynamicsWorld();
 
    template<typename T>
    T* FindNode()
    {
        T* ret = nullptr;
 
        auto typedNodeFind = [&](Node* node) -> bool
        {
            if (node->Is(T::ClassRuntimeId()))
            {
                ret = static_cast<T*>(node);
                return false;
            }
 
            return true;
        };
 
        if (mRootNode != nullptr)
        {
            mRootNode->ForEach(typedNodeFind);
        }
 
        return ret;
    }
 
    template<typename T>
    void FindNodes(std::vector<T*>& outNodes)
    {
        auto typedNodeGather = [&](Node* node) -> bool
        {
            if (node->Is(T::ClassRuntimeId()))
            {
                outNodes.push_back(static_cast<T*>(node));
            }
 
            return true;
        };
 
        if (mRootNode != nullptr)
        {
            mRootNode->Traverse(typedNodeGather);
        }
    }
 
private:
 
    void UpdateLines(float deltaTime);
    void ExtractPersistingNodes();
 
private:
 
    static std::unordered_set<NodePtrWeak> sNewlyRegisteredNodes;
 
    NodePtr mRootNode;
    std::vector<NodePtr> mPersistingNodes;
    std::vector<Line> mLines;
    std::vector<class Light3D*> mLights;
    std::vector<class Audio3D*> mAudios;
    std::vector<FadingLight> mFadingLights;
    NodePtr mQueuedRootNode;
    std::string mLoadedSceneName;
    std::string mQueuedSceneName;
    glm::vec4 mAmbientLightColor;
    glm::vec4 mShadowColor;
    FogSettings mFogSettings;
    Camera3D* mActiveCamera;
    Camera3D* mCameraOverride = nullptr;
    Node3D* mAudioReceiver;
    bool mPendingClear = false;
    bool mAutoNavRebuild = false;
 
    // Physics
    btDefaultCollisionConfiguration* mCollisionConfig = nullptr;
    btCollisionDispatcher* mCollisionDispatcher = nullptr;
    btDbvtBroadphase* mBroadphase = nullptr;
    btSequentialImpulseConstraintSolver* mSolver = nullptr;
    btDiscreteDynamicsWorld* mDynamicsWorld = nullptr;
    btDiscreteDynamicsWorld* mDefaultDynamicsWorld = nullptr;;
    std::vector<PrimitivePair> mCurrentOverlaps;
    std::vector<PrimitivePair> mPreviousOverlaps;
 
    // Node UUID lookup
    std::unordered_map<uint64_t, Node*> mUuidMap;
};