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 OcclusionData;
 
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);
 
    // Keeps a transient stand-in camera alive whenever the loaded scene has no
    // Camera3D of its own, and retires it the moment a real one registers.
    // Called once per World::Update. See the implementation for why a scene
    // without any camera renders its UI incorrectly.
    void EnsureFallbackCamera();
    Camera3D* GetFallbackCamera() const { return mFallbackCamera; }
    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;
 
    // Baked occlusion culling. The data is owned by the root node's Scene.
    void SetOcclusionData(const OcclusionData* data, bool enabled);
    const OcclusionData* GetOcclusionData() const;
    bool IsOcclusionCullingEnabled() const;
    bool IsOcclusionDataStale() const;
    float GetOcclusionMoveEpsilon2() const;
    void RequestOccludeeResolve();
    bool IsOccludeeResolvePending() const;
    void ResolveOccludees();
 
    // Gameplay visibility queries: frustum test on the node's bounds plus the
    // baked occlusion tables (static bit for baked occludees, coarse dynamic
    // table otherwise). Evaluated on demand against the active camera unless
    // one is passed, so results never lag a frame. Hidden nodes and the
    // camera itself are never "seen".
    bool IsSeenByCamera(Node3D* node, Camera3D* camera = nullptr);
    // Every visible Node3D, optionally restricted to nodes carrying at least
    // one of the given tags.
    void GetSeenByCamera(std::vector<Node3D*>& outNodes, const std::vector<std::string>* tags = nullptr, Camera3D* camera = nullptr);
 
    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;
    const OcclusionData* mOcclusionData = nullptr;
    bool mOcclusionEnabled = false;
    bool mOcclusionStale = false;
    bool mOcclusionResolvePending = false;
    float mOcclusionMoveEps2 = 0.0f;
    Camera3D* mActiveCamera;
    Camera3D* mCameraOverride = nullptr;
    // Transient stand-in spawned by EnsureFallbackCamera() when the scene has
    // no camera. Raw pointer, cleared in UnregisterNode like mActiveCamera.
    Camera3D* mFallbackCamera = 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;
};