ActionManager.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
#include <map>
#include <thread>
#include <mutex>
#include <atomic>
#if PLATFORM_LINUX
#include <sys/types.h>
#endif
 
#include "EngineTypes.h"
#include "EditorTypes.h"
#include "Asset.h"
#include "AssetRef.h"
#include "Nodes/Node.h"
#include "Nodes/3D/StaticMesh3d.h"
#include "Nodes/Widgets/ArrayWidget.h"
 
class Node3D;
class Mesh3D;
class InstancedMesh3D;
class Timeline;
class Widget;
struct ActionSetInstanceColorsData;
struct MeshInstanceData;
 
struct WidgetTransformData
{
    glm::vec2 mOffset;
    glm::vec2 mSize;
    float mRotation;
};
 
struct LocalBuildState
{
    std::thread mBuildThread;
    std::atomic<bool> mRunning{false};
    std::atomic<bool> mCancelRequested{false};
    std::atomic<bool> mComplete{false};
    std::atomic<bool> mSuccess{false};
    std::atomic<int> mExitCode{0};
 
    std::mutex mOutputMutex;
    std::string mOutput;
    bool mOutputDirty{false};
 
    // Build config (set in BuildData, used by Phase1 and compile thread)
    Platform mPlatform{Platform::Linux};
    bool mEmbedded{false};
    std::string mPackagedDir;
    std::string mBuildProjDir;
    std::string mProjectDir;
    std::string mProjectName;
    std::string mExeSrc;
    std::string mExtension;
    int64_t mExeMTimeBeforeBuild{0};  // stat mtime of mExeSrc before compile, used to detect silent link.exe failures
    bool mStandalone{false};
    bool mNeedCompile{true};
    bool mUseSteam{false};
    std::string mCompileCommand;
    std::string mPrebuiltExePath;
    std::string mTmpMakefile;
    std::string mShaderCompileCommand;
    std::string mStripCommand;
    // Path to a .vcxproj that was injected with addon sources/includes before the build.
    // Restored from .vcxproj.orig after the build completes (success or failure) so the
    // working tree doesn't accumulate uncommitted changes.
    std::string mInjectedVcxprojPath;
 
    // Post-build flags
    bool mRunAfterBuild{false};
    bool mRunOnDevice{false};
    bool mForceRebuild{false};
    // Snapshot of mForceRebuild captured in BuildData before it's cleared, so BuildPhase1
    // can still tell whether the user requested a force rebuild when it decides whether
    // to reuse the prebuilt Polyphase.exe.
    bool mForceCompile{false};
 
    void Reset()
    {
        // Thread must be joined before calling Reset
        mRunning.store(false);
        mCancelRequested.store(false);
        mComplete.store(false);
        mSuccess.store(false);
        mExitCode.store(0);
        {
            std::lock_guard<std::mutex> lock(mOutputMutex);
            mOutput.clear();
            mOutputDirty = false;
        }
        mPlatform = Platform::Linux;
        mEmbedded = false;
        mPackagedDir.clear();
        mBuildProjDir.clear();
        mProjectDir.clear();
        mProjectName.clear();
        mExeSrc.clear();
        mExtension.clear();
        mExeMTimeBeforeBuild = 0;
        mStandalone = false;
        mNeedCompile = true;
        mUseSteam = false;
        mCompileCommand.clear();
        mPrebuiltExePath.clear();
        mTmpMakefile.clear();
        mShaderCompileCommand.clear();
        mStripCommand.clear();
        mInjectedVcxprojPath.clear();
        mRunAfterBuild = false;
        mRunOnDevice = false;
        mForceRebuild = false;
        mForceCompile = false;
#if PLATFORM_LINUX
        mProcessId = 0;
#elif PLATFORM_WINDOWS
        mProcessHandle = nullptr;
#endif
    }
 
#if PLATFORM_LINUX
    pid_t mProcessId{0};
#elif PLATFORM_WINDOWS
    void* mProcessHandle{nullptr};
#endif
};
 
class Action
{
public:
    virtual ~Action() {}
    virtual void Execute();
    virtual void Reverse();
    virtual const char* GetName() = 0;
};
 
class ActionManager
{
public:
 
    ~ActionManager();
 
    static void Create();
    static void Destroy();
    static ActionManager* Get();
 
    void Update();
 
    void OnSelectedNodeChanged();
 
    Node* SpawnNode(TypeId nodeType, Node* parent);
    Node* SpawnNode(TypeId nodeType, glm::vec3 position);
 
    Node* SpawnBasicNode(const std::string& name, Node* parent, Asset* srcAsset = nullptr, bool setWorldPos = false, glm::vec3 worldPos = { 0.0f, 0.0f, 0.0f });
 
    void ExecuteAction(Action* action);
    void Undo();
    void Redo();
 
    // Actions
    void EXE_EditProperty(void* owner, PropertyOwnerType ownerType, const std::string& name, uint32_t index, Datum newValue);
    void EXE_EditTransform(Node3D* node, const glm::mat4& transform);
    void EXE_EditTransforms(const std::vector<Node3D*>& nodes, const std::vector<glm::mat4>& newTransforms);
    void EXE_EditWidgetTransforms(const std::vector<Widget*>& widgets, const std::vector<WidgetTransformData>& newTransforms);
    Node* EXE_SpawnNode(TypeId srcType);
    Node* EXE_SpawnNode(const char* srcTypeName);
    Node* EXE_SpawnNode(Scene* srcScene);
    Node* EXE_SpawnNode(Node* srcNode);
    void EXE_DeleteNode(Node* node);
    std::vector<Node*> EXE_SpawnNodes(const std::vector<Node*>& nodes);
    void EXE_DeleteNodes(const std::vector<Node*>& nodes);
    void EXE_AttachNode(Node* node, Node* newParent, int32_t childIndex, int32_t boneIndex);
    void EXE_SetRootNode(Node* newRoot);
    void EXE_SetWorldRotation(Node3D* node, glm::quat rot);
    void EXE_SetWorldPosition(Node3D* node, glm::vec3 pos);
    void EXE_SetWorldScale(Node3D* node, glm::vec3 scale);
    void EXE_UnlinkScene(Node* node);
    void EXE_ResetScene(Node* node);
    void EXE_SetInstanceColors(const std::vector<ActionSetInstanceColorsData>& data);
    void EXE_SetVoxels(class Voxel3D* voxel, const std::vector<struct VoxelChange>& changes);
    void EXE_SetTerrainHeights(class Terrain3D* terrain, const std::vector<struct TerrainHeightChange>& changes);
    void EXE_PaintTiles(class TileMap2D* tileMapNode, const std::vector<struct TilePaintChange>& changes);
    void EXE_SetInstanceData(InstancedMesh3D* instMesh, int32_t startIndex, const std::vector<MeshInstanceData>& data);
 
    void EXE_ReplaceSelectedWithAsset(Asset* asset, const std::vector<Node*>& nodes);
 
    void EXE_ReplaceWithInstancedMesh(const std::vector<Node*>& nodes, bool merge);
 
    void EXE_ReplaceWithStaticMesh(const std::vector<Node*>& nodes);
 
    void EXE_ParentSelectedWith(const std::vector<Node*>& nodes, TypeId parentType,
        ArrayOrientation arrayOrientation = ArrayOrientation::Vertical);
 
    // Timeline actions
    void EXE_TimelineAddTrack(Timeline* timeline, TypeId trackType);
    void EXE_TimelineRemoveTrack(Timeline* timeline, int32_t trackIndex);
    void EXE_TimelineAddClip(Timeline* timeline, int32_t trackIndex, TypeId clipType, float startTime, float duration);
    void EXE_TimelineRemoveClip(Timeline* timeline, int32_t trackIndex, int32_t clipIndex);
    void EXE_TimelineMoveClip(Timeline* timeline, int32_t trackIndex, int32_t clipIndex, float oldStartTime, float newStartTime);
    void EXE_TimelineBindTrack(Timeline* timeline, int32_t trackIndex, uint64_t oldUuid, uint64_t newUuid, const std::string& oldName, const std::string& newName);
 
    void ClearActionHistory();
    void ClearActionFuture();
    void ResetUndoRedo();
    void ExileNode(NodePtr node);
    void RestoreExiledNode(NodePtr node);
    void GatherScriptFiles(const std::string& dir, std::vector<std::string>& outFiles);
 
protected:
 
    static ActionManager* sInstance;
    ActionManager();
 
    // Raw (non-.oct) file entry to embed into gEmbeddedRawAssets[].
    // mLookupKey is the canonical VFS lookup path the runtime will use
    // (projectDir-relative, forward slashes, e.g. "Assets/intro.mp4" or
    // "Packages/videoplayer/Assets/test.mp4").
    struct EmbeddedRawAssetEntry
    {
        std::string mAbsolutePath;
        std::string mLookupKey;
        bool        mEngineAsset = false;
    };
 
    void GenerateEmbeddedAssetFiles(
        std::vector<std::pair<AssetStub*, std::string> >& assets,
        std::vector<EmbeddedRawAssetEntry>& rawAssets,
        const char* headerPath,
        const char* sourcePath);
 
    void GenerateEmbeddedScriptFiles(
        std::vector<std::string> files,
        const char* headerPath,
        const char* sourcePath);
 
 
    std::vector<Action*> mActionHistory;
    std::vector<Action*> mActionFuture;
    std::vector<NodePtr> mExiledNodes;
 
    // Non-blocking build state
    LocalBuildState mBuildState;
    bool mShowBuildModal = false;
    std::string mBuildDisplayOutput;
    bool mBuildAutoScroll = true;
    bool mBuildPending = false;
 
    void BuildPhase1();
    void BuildCompileThreadFunc();
    void FinalizeLocalBuild();
    void AppendBuildOutput(const std::string& text);
    void CancelBuild();
 
public:
 
    // Actions
    void CreateNewProject(const char* folderPath = nullptr, bool cpp = false, const char* defaultSceneName = "SC_Default");
    void OpenProject(const char* path = nullptr);
 
    // Drop Directory.Build.props + PolyphaseConfig.cmake at the project
    // root recording the engine path. Lets addons under <project>/Packages
    // build via Visual Studio / cmake without env-var setup. Called from
    // OpenProject each time a project loads, so the recorded path stays in
    // sync with whichever editor binary opened the project.
    void WriteProjectLocalPolyphaseConfig();
 
    void OpenScene();
    void OpenScene(Scene* scene);
    // Defer OpenScene so the progress modal renders before Scene::Instantiate
    // (which builds the node tree) blocks the main thread on large scenes.
    // Pass nullptr to trigger the OS file dialog inside the worker; pass a
    // stub to open that scene directly (same as the non-Request OpenScene).
    void RequestOpenScene(AssetStub* stub);
    void RequestOpenSceneFromDialog();
    void SaveScene(bool saveAs);
    // Defer SaveScene/SaveSelectedAsset/ResaveAllAssets to end-of-frame so the
    // progress modal can render before the (potentially slow) capture and
    // serialization work blocks the main thread. The hotkey / menu /
    // command path should prefer these wrappers; SaveScene() etc. remain
    // available for callers that need synchronous semantics (e.g. the REST
    // controller, where the response must include the result).
    void RequestSaveScene(bool saveAs);
    void RequestSaveSelectedAsset();
    void RequestResaveAllAssets();
    // Defer OpenProject so the progress modal renders before LoadProject's
    // (potentially many-second) Purge / ReloadAddons / Discover sequence
    // blocks the main thread. Pass empty/null path to trigger the OS folder
    // picker inside the worker (same as direct OpenProject).
    void RequestOpenProject(const char* path);
    // sceneType: 0 = 2D Canvas root, 1 = 3D Node3D root. targetDir defaults to the
    // editor's currently-selected asset directory. Returns the created Scene asset
    // (already saved to disk) or nullptr on failure.
    Scene* CreateNewScene(const char* sceneName, int sceneType, bool createCamera, bool createSkybox = false,  AssetDir* targetDir = nullptr);
    void SaveSelectedAsset();
    void DeleteSelectedNodes();
    void DeleteNode(Node* node);
    void RunScript();
    void ImportAsset();
    Asset* ImportAsset(const std::string& path);
    void ImportTinyLLMModel();
    void ImportTinyLLMTokenizer();
    void ImportCamera(const CameraImportOptions& options);
    void ImportScene(const SceneImportOptions& options);
    void BeginImportScene();
    void BeginReimportScene(AssetStub* sceneStub);
    void BeginReimportAssetWithNewFile(AssetStub* stub);
    void BeginImportCamera();
    void BuildData(Platform platform, bool embedded);
    void DrawBuildModal();
    bool IsBuildRunning() const;
    LocalBuildState& GetBuildState() { return mBuildState; }
    void PrepareRelease();
    void ClearWorld();
    void DeleteAllNodes();
    void RecaptureAndSaveAllScenes();
    void ResaveAllAssets();
    void DeleteAsset(AssetStub* stub);
    void DeleteAssetDir(AssetDir* dir);
    bool DuplicateNodes(std::vector<Node*> nodes);
    void AttachSelectedNodes(Node* newParent, int32_t boneIdx);
 
    // Project upgrade functions
    bool CheckProjectNeedsUpgrade();
    void UpgradeProject();
};
 
#define DECLARE_ACTION_INTERFACE(Name) \
    virtual void Execute() override; \
    virtual void Reverse() override; \
    virtual const char* GetName() { return #Name; }
 
// Actions
 
class ActionEditProperty : public Action
{
public:
    DECLARE_ACTION_INTERFACE(EditProperty)
 
    ActionEditProperty(
        void* owner,
        PropertyOwnerType ownerType,
        const std::string& propName,
        uint32_t index,
        Datum value);
 
protected:
 
    void GatherProps(std::vector<Property>& props);
    Property* FindProp(std::vector<Property>& props, const std::string& name);
 
    void* mOwner = nullptr;
    PropertyOwnerType mOwnerType = PropertyOwnerType::Count;
    std::string mPropertyName;
    uint32_t mIndex = 0;
    Datum mValue;
 
    AssetRef mReferencedAsset;
    Datum mPreviousValue;
};
 
class ActionEditTransforms : public Action
{
public:
    DECLARE_ACTION_INTERFACE(EditTransforms)
 
    ActionEditTransforms(
        const std::vector<Node3D*>& nodes,
        const std::vector<glm::mat4>& newTransforms);
 
protected:
    std::vector<Node3D*> mNodes;
    std::vector<glm::mat4> mNewTransforms;
    std::vector<glm::mat4> mPrevTransforms;
};
 
class ActionEditWidgetTransforms : public Action
{
public:
    DECLARE_ACTION_INTERFACE(EditWidgetTransforms)
 
    ActionEditWidgetTransforms(
        const std::vector<Widget*>& widgets,
        const std::vector<WidgetTransformData>& newTransforms);
 
protected:
    std::vector<Widget*> mWidgets;
    std::vector<WidgetTransformData> mNewTransforms;
    std::vector<WidgetTransformData> mPrevTransforms;
};
 
class ActionSpawnNodes : public Action
{
public:
    DECLARE_ACTION_INTERFACE(SpawnNodes)
    ActionSpawnNodes(const std::vector<TypeId>& types);
    ActionSpawnNodes(const std::vector<const char*>& typeNames);
    ActionSpawnNodes(const std::vector<SceneRef>& scenes);
    ActionSpawnNodes(const std::vector<Node*>& srcNodes);
 
    const std::vector<NodePtr>& GetNodes() const { return mNodes; }
 
protected:
 
    // Action inputs, only one should be filled.
    std::vector<TypeId> mSrcTypes;
    std::vector<const char*> mSrcTypeNames;
    std::vector<SceneRef> mSrcScenes;
    std::vector<NodePtr> mSrcNodes;
 
    // Populated after first Execute()
    std::vector<NodePtr> mNodes;
 
    // Populated after first Reverse()
    std::vector<NodePtr> mParents;
};
 
class ActionDeleteNodes : public Action
{
public:
    DECLARE_ACTION_INTERFACE(DeleteNodes)
    ActionDeleteNodes(const std::vector<Node*>& nodes);
protected:
    std::vector<NodePtr> mNodes;
    std::vector<NodePtr> mParents;
    std::vector<int32_t> mChildIndices;
    std::vector<int32_t> mBoneIndices;
};
 
class ActionAttachNode : public Action
{
public:
    DECLARE_ACTION_INTERFACE(AttachNode)
    ActionAttachNode(Node* node, Node* newParent, int32_t childIndex, int32_t boneIndex);
protected:
    NodePtr mNode = nullptr;
    NodePtr mNewParent = nullptr;
    NodePtr mPrevParent = nullptr;
    int32_t mChildIndex = -1;
    int32_t mPrevChildIndex = -1;
    int32_t mBoneIndex = -1;
    int32_t mPrevBoneIndex = -1;
};
 
class ActionSetRootNode : public Action
{
public:
    DECLARE_ACTION_INTERFACE(SetRootNode)
    ActionSetRootNode(Node* newRoot);
protected:
    NodePtr mNewRoot = nullptr;
    NodePtr mOldRoot = nullptr;
    NodePtr mNewRootParent = nullptr;
    int32_t mNewRootChildIndex = -1;
};
 
class ActionSetWorldRotation : public Action
{
public:
    DECLARE_ACTION_INTERFACE(SetWorldRotation)
    ActionSetWorldRotation(Node3D* node, glm::quat rot);
protected:
    Node3D* mNode = nullptr;
    glm::quat mNewRotation;
    glm::quat mPrevRotation;
};
 
class ActionSetWorldPosition : public Action
{
public:
    DECLARE_ACTION_INTERFACE(SetWorldPosition)
    ActionSetWorldPosition(Node3D* node, glm::vec3 pos);
protected:
    Node3D* mNode = nullptr;
    glm::vec3 mNewPosition;
    glm::vec3 mPrevPosition;
};
 
class ActionSetWorldScale : public Action
{
public:
    DECLARE_ACTION_INTERFACE(SetWorldScale)
    ActionSetWorldScale(Node3D* node, glm::vec3 scale);
protected:
    Node3D* mNode = nullptr;
    glm::vec3 mNewScale;
    glm::vec3 mPrevScale;
};
 
class ActionUnlinkScene : public Action
{
public:
    DECLARE_ACTION_INTERFACE(UnlinkScene);
    ActionUnlinkScene(Node* node);
 
protected:
 
    Node* mNode = nullptr;
    SceneRef mScene;
 
};
 
class ActionResetScene : public Action
{
public:
    DECLARE_ACTION_INTERFACE(ResetScene);
    ActionResetScene(Node* node);
 
protected:
 
    Node* mNode = nullptr;
    SceneRef mScene;
    std::vector<Property> mPrevProperties;
};
 
struct ActionSetInstanceColorsData
{
    StaticMesh3D* mMesh3d = nullptr;
    std::vector<uint32_t> mColors;
    bool mBakedLight = false;
};
 
class ActionSetInstanceColors : public Action
{
public:
    DECLARE_ACTION_INTERFACE(SetInstanceColors);
    ActionSetInstanceColors(const std::vector<ActionSetInstanceColorsData>& data);
 
protected:
 
    std::vector<ActionSetInstanceColorsData> mData;
    std::vector<ActionSetInstanceColorsData> mPrevData;
};
 
class ActionSetInstanceData : public Action
{
public:
    DECLARE_ACTION_INTERFACE(SetInstanceData);
    ActionSetInstanceData(InstancedMesh3D* instMesh, int32_t startIndex, const std::vector<MeshInstanceData>& data);
 
protected:
    InstancedMesh3D* mInstMesh = nullptr;
    int32_t mStartIndex = -1;
 
    std::vector<MeshInstanceData> mData;
    std::vector<MeshInstanceData> mPrevData;
};
 
class ActionReplaceWithAsset : public Action
{
public:
    DECLARE_ACTION_INTERFACE(ReplaceWithAsset);
    ActionReplaceWithAsset(Asset* asset, const std::vector<Node*>& nodes);
 
protected:
 
    enum class ReplaceMode
    {
        StaticMesh,
        Material,
        Scene,
        Invalid
    };
 
    AssetRef mAsset;
    ReplaceMode mMode = ReplaceMode::Invalid;
 
    // For StaticMesh mode
    std::vector<StaticMesh3D*> mMeshNodes;
    std::vector<StaticMeshRef> mPrevMeshes;
 
    // For Material mode
    std::vector<Mesh3D*> mMatNodes;
    std::vector<MaterialRef> mPrevMaterials;
 
    // For Scene mode
    struct SceneReplaceEntry
    {
        NodePtr mOriginal;
        NodePtr mParent;
        int32_t mChildIndex = -1;
        NodePtr mSpawnedNode;
    };
    std::vector<SceneReplaceEntry> mSceneEntries;
};
 
class ActionReplaceWithInstancedMesh : public Action
{
public:
    DECLARE_ACTION_INTERFACE(ReplaceWithInstancedMesh);
    ActionReplaceWithInstancedMesh(const std::vector<Node*>& nodes, bool merge);
 
protected:
 
    struct GroupEntry
    {
        std::vector<NodePtr> mOriginalNodes;
        std::vector<NodePtr> mOriginalParents;
        std::vector<int32_t> mOriginalChildIndices;
        NodePtr mInstancedNode;
        NodePtr mInstancedParent;
        int32_t mInstancedChildIndex = -1;
    };
 
    std::vector<GroupEntry> mGroups;
    bool mFirstExecute = true;
};
 
class ActionReplaceWithStaticMesh : public Action
{
public:
    DECLARE_ACTION_INTERFACE(ReplaceWithStaticMesh);
    ActionReplaceWithStaticMesh(const std::vector<Node*>& nodes);
 
protected:
 
    struct SplitEntry
    {
        NodePtr mOriginalNode;
        NodePtr mOriginalParent;
        int32_t mOriginalChildIndex = -1;
        std::vector<NodePtr> mCreatedNodes;
    };
 
    std::vector<SplitEntry> mEntries;
    bool mFirstExecute = true;
};
 
class ActionParentSelectedWith : public Action
{
public:
    DECLARE_ACTION_INTERFACE(ParentSelectedWith);
    ActionParentSelectedWith(
        const std::vector<Node*>& nodes,
        TypeId newParentType,
        ArrayOrientation arrayOrientation = ArrayOrientation::Vertical);
 
protected:
    std::vector<NodePtr> mNodes;
    std::vector<NodePtr> mPrevParents;
    std::vector<int32_t> mPrevChildIndices;
    std::vector<int32_t> mPrevBoneIndices;
    NodePtr mCreatedParent;
    NodePtr mCreatedParentParent;
    int32_t mCreatedParentChildIndex = -1;
    TypeId mNewParentType;
    ArrayOrientation mArrayOrientation = ArrayOrientation::Vertical;
    bool mFirstExecute = true;
};
 
struct VoxelChange;
class Voxel3D;
 
class ActionSetVoxels : public Action
{
public:
    DECLARE_ACTION_INTERFACE(SetVoxels);
    ActionSetVoxels(Voxel3D* voxel, const std::vector<VoxelChange>& changes);
 
protected:
    Voxel3D* mVoxel = nullptr;
    std::vector<VoxelChange> mChanges;
};
 
struct TerrainHeightChange;
class Terrain3D;
 
class ActionSetTerrainHeights : public Action
{
public:
    DECLARE_ACTION_INTERFACE(SetTerrainHeights);
    ActionSetTerrainHeights(Terrain3D* terrain, const std::vector<TerrainHeightChange>& changes);
 
protected:
    Terrain3D* mTerrain = nullptr;
    std::vector<TerrainHeightChange> mChanges;
};
 
struct TilePaintChange;
class TileMap2D;
 
class ActionPaintTiles : public Action
{
public:
    DECLARE_ACTION_INTERFACE(PaintTiles);
    ActionPaintTiles(TileMap2D* tileMapNode, const std::vector<TilePaintChange>& changes);
 
protected:
    TileMap2D* mTarget = nullptr;
    std::vector<TilePaintChange> mChanges;
};