ActionManager.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <atomic>
#if PLATFORM_LINUX || PLATFORM_MAC
#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};
    std::string mTargetId;
    std::unordered_map<std::string, std::string> mTargetOptions;
    bool mEmbedded{false};
 
    bool mStaticContent{false};
 
    bool mContentPak{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};
    bool mOpenDirectoryOnFinish{true};
    // 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};
 
    // Stashed by the Android branch: the icon source path resolved from
    // mTargetOptions["android.iconSource"] (fallback EngineConfig::mIconPath).
    // Read by the icon-generation step further down the same branch.
    std::string mAndroidResolvedIconSource;
 
    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;
        mTargetId.clear();
        mTargetOptions.clear();
        mEmbedded = false;
        mStaticContent = false;
        mContentPak = 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;
        mAndroidResolvedIconSource.clear();
        mOpenDirectoryOnFinish = true;
#if PLATFORM_LINUX || PLATFORM_MAC
        mProcessId = 0;
#elif PLATFORM_WINDOWS
        mProcessHandle = nullptr;
#endif
    }
 
#if PLATFORM_LINUX || PLATFORM_MAC
    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;
};
 
// Plugin-driven actions — addons push these via the
// PolyphaseEngineAPI::EditorAction_Push entry. The three callbacks carry
// arbitrary userData (opaque to the engine); the optional freeFn cleans
// it up when the action falls out of the history.
//
// mPluginTag identifies the owning addon DLL — used by NativeAddonManager
// during UnloadNativeAddon to scrub any PluginAction whose function
// pointers live inside the DLL that's about to be FreeLibrary'd. Without
// this, undoing into a stale history after a hot-reload calls into freed
// memory.
class PluginAction : public Action
{
public:
    using DoFn   = void (*)(void* userData);
    using UndoFn = void (*)(void* userData);
    using FreeFn = void (*)(void* userData);
 
    PluginAction(const char* name, DoFn doFn, UndoFn undoFn,
                 FreeFn freeFn, void* userData);
    ~PluginAction() override;
 
    void        Execute() override;
    void        Reverse() override;
    const char* GetName() override;
 
    void        SetPluginTag(const std::string& tag) { mPluginTag = tag; }
    const std::string& GetPluginTag() const          { return mPluginTag; }
 
private:
    std::string mName;
    std::string mPluginTag;
    DoFn        mDoFn   = nullptr;
    UndoFn      mUndoFn = nullptr;
    FreeFn      mFreeFn = nullptr;
    void*       mUserData = nullptr;
};
 
// Groups multiple actions into a single undo step. Used by plugin
// EditorAction_BeginGroup / EditorAction_EndGroup so a continuous
// paint-drag (which may push 60+ spawn actions per second) is one
// Ctrl+Z.
class ActionGroup : public Action
{
public:
    explicit ActionGroup(const char* name);
    ~ActionGroup() override;
 
    void Add(Action* a);                  // takes ownership
    bool IsEmpty() const { return mChildren.empty(); }
 
    void        Execute() override;       // forward order
    void        Reverse() override;       // reverse order
    const char* GetName() override;
 
    std::vector<Action*>&       GetChildren()       { return mChildren; }
    const std::vector<Action*>& GetChildren() const { return mChildren; }
 
private:
    std::string           mName;
    std::vector<Action*>  mChildren;
};
 
class ActionManager
{
public:
 
    ~ActionManager();
 
    static void Create();
    static void Destroy();
    POLYPHASE_API 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();
 
    // Plugin-action group helpers (used by EditorAction_BeginGroup /
    // EditorAction_EndGroup). Nesting is supported — the outermost
    // Begin starts the group; the matching End closes it and pushes
    // a single ActionGroup onto the history.
    void BeginActionGroup(const char* name);
    void EndActionGroup();
 
    // Walk mActionHistory + mActionFuture and drop any PluginAction
    // (or ActionGroup containing one) whose mPluginTag matches `tag`.
    // Called from NativeAddonManager::UnloadNativeAddon BEFORE the DLL
    // is FreeLibrary'd, so the function pointers stored on the action
    // are still valid when freeFn fires.
    void PurgePluginActions(const std::string& pluginTag);
 
    // Actions
    void EXE_EditProperty(void* owner, PropertyOwnerType ownerType, const std::string& name, uint32_t index, Datum newValue);
    void EXE_EditPropertyOnSelection(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, const char* socketName = nullptr);
    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);
 
    void EXE_ReplaceNodeType(Node* oldNode, TypeId newType);
 
    // 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);
 
    void ObfuscatePackagedContent(const std::string& packagedDir);
 
    bool PackPackagedContent(const std::string& packagedDir,
                             const std::string& projectName,
                             bool contentIsEmbedded);
 
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;
 
    // Open plugin-action group; non-null between BeginActionGroup
    // and the outermost matching EndActionGroup.
    ActionGroup* mOpenGroup  = nullptr;
    int          mGroupDepth = 0;
 
    // Non-blocking build state
    LocalBuildState mBuildState;
    bool mShowBuildModal = false;
    std::string mBuildDisplayOutput;
    bool mBuildAutoScroll = true;
    bool mBuildPending = false;
 
    // Extract-skeletal-animations modal state. Lives here because the modal
    // body is drawn from the editor's per-frame loop via
    // DrawExtractSkeletalAnimationsModal — same pattern as DrawBuildModal.
    AssetStub* mExtractSkelAnimSourceStub = nullptr;
    std::vector<uint8_t> mExtractSkelAnimSelections; // 1 byte per anim, 0/1
    char mExtractSkelAnimPrefix[32] = "SA_";
    bool mExtractSkelAnimOverwrite = false;
    bool mExtractSkelAnimUnique = true;
    bool mExtractSkelAnimRemoveEmbedded = false;
    bool mShowExtractSkelAnimModal = false;
 
    // Import-animations modal state (animation-only fbx/glb).
    std::string mImportAnimSourcePath;
    AssetDir* mImportAnimTargetDir = nullptr;
    std::vector<std::string> mImportAnimNames;
    std::vector<uint8_t> mImportAnimSelections;
    char mImportAnimPrefix[32] = "SA_";
    bool mImportAnimOverwrite = false;
    bool mImportAnimUnique = true;
    bool mShowImportAnimModal = false;
 
    // Retarget-animation modal state.
    AssetStub* mRetargetClipStub = nullptr;
    AssetRef mRetargetSrcAvatar;
    AssetRef mRetargetDstAvatar;
    char mRetargetOutputName[128] = "";
    int32_t mRetargetMode = 0;          // 0=NameRemap, 1=ReferencePose
    bool mRetargetOverwrite = false;
    bool mRetargetUnique = true;
    bool mShowRetargetModal = false;
    bool mRetargetModalJustOpened = false;
 
    void BuildPhase1();
    void BuildCompileThreadFunc();
    void FinalizeLocalBuild();
    // Runs the active target's PostPackage callback (if any) against an
    // already-populated Packaged dir. Returns false when the callback fails.
    bool RunPostPackage(Platform platform, const std::string& projectName, const std::string& projectDir,
                        const std::string& packagedDir, const std::string& compiledBinaryDir);
    void CancelBuild();
 
public:
 
    // Public so the build-context WriteOutputLine trampoline can forward a
    // target's PostPackage progress into the PackagingWindow log.
    void AppendBuildOutput(const std::string& text);
 
    // 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();
    POLYPHASE_API 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();
    POLYPHASE_API 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();
    void RequestBakeOcclusion();
    void RequestClearOcclusion();
    // Queue non-mesh asset imports for end-of-frame. Appends to any imports
    // already pending so a batch (file dialog multi-select, drag-drop) runs
    // under one progress modal. Use ImportAsset(path) directly only where a
    // synchronous result is required (REST controller).
    void RequestImportAssets(const std::vector<std::string>& paths);
    // End-of-frame worker for RequestImportAssets. Called from EditorMain.cpp.
    void ImportPendingAssets();
    // 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);
    // File > Close Project — closes the current project at end-of-frame.
    // Unloads every native addon DLL on the way out so addon Intermediate
    // folders are no longer file-locked and the user can rebuild on demand.
    void RequestCloseProject();
    // Tools > Addons > Recover from stuck addons — Tier-2 recovery.
    void RequestAddonRecovery(const char* reason);
    // Tools > Addons > Restart Editor (Clean Addon Rebuild) — Tier-3 recovery.
    // Spawns a new editor process, then exits the current one (Job Object
    // teardown reliably kills mspdbsrv); the new instance picks up
    // --addon-recovery and wipes intermediates before opening the project.
    void RequestEditorRestartForAddonRecovery(const char* reason);
    // Synchronous Tier-2 / Tier-3 implementations. Called by the EditorMain
    // deferred-dispatcher after the request flag is set; safe to call
    // directly when no progress modal is in flight.
    void CloseProject();
    void RecoverFromStuckAddons(const char* reason);
    void RestartEditorForAddonRecovery(const char* reason);
    // 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.
    POLYPHASE_API Scene* CreateNewScene(const char* sceneName, int sceneType, bool createCamera, bool createSkybox = false, bool createDirectionalLight = false, bool createUICanvas = false, AssetDir* targetDir = nullptr);
    void SaveSelectedAsset();
    void DeleteSelectedNodes();
    void DeleteNode(Node* node);
    void RunScript();
    void ImportAsset();
    // POLYPHASE_API: the per-asset mesh importers, exposed so an addon can drive
    // a conversion pipeline without going through ImportScene -- which ends in
    // OpenEditScene and so requires a fully initialized editor.
    POLYPHASE_API Asset* ImportAsset(const std::string& path, const std::string& overrideBaseName = "", const MeshImportOptions* meshOpts = nullptr);
    POLYPHASE_API Asset* ImportAssetCombined(const std::string& path, const std::string& overrideBaseName = "", const MeshImportOptions* meshOpts = nullptr);
 
    // Loose-file import: copies the user-picked file(s) into the current
    // AssetDir verbatim (no .oct conversion) and registers them with the
    // packager. Files survive packaging as-is; Lua/native code reads them
    // via Stream::ReadFile / SYS_AcquireFileData. Used for .json, media,
    // and arbitrary data files an addon or script wants to ship.
    void ImportLooseFile();
    void ImportLooseFile(const std::string& sourcePath, AssetDir* targetDir);
    void ImportTinyLLMModel();
    void ImportTinyLLMTokenizer();
    void ImportCamera(const CameraImportOptions& options);
    // Returns the created (or reimported) Scene asset, or nullptr on failure.
    POLYPHASE_API Asset* ImportScene(const SceneImportOptions& options);
    void BeginImportScene();
    void BeginReimportScene(AssetStub* sceneStub);
    void BeginReimportAssetWithNewFile(AssetStub* stub);
 
    // Extract embedded animations from a SkeletalMesh asset into standalone
    // SkeletalAnimationAsset files. BeginExtractSkeletalAnimations opens the
    // selection modal; ExtractSkeletalAnimations runs the actual generation.
    struct ExtractSkeletalAnimationsOptions
    {
        AssetStub* mSourceMeshStub = nullptr;
        AssetDir* mTargetDir = nullptr;
        std::vector<uint32_t> mAnimationIndices; // empty = all
        std::string mPrefix = "SA_";
        bool mOverwriteExisting = false;
        bool mUniqueNames = true;
        bool mRemoveEmbeddedAfterExtract = false;
    };
    void BeginExtractSkeletalAnimations(AssetStub* skeletalMeshStub);
    bool ExtractSkeletalAnimations(const ExtractSkeletalAnimationsOptions& options);
    void DrawExtractSkeletalAnimationsModal();
 
    // Import animations from an animation-only .fbx/.glb/.gltf/.dae file
    // (or any model file the user picks — only the embedded clips are read).
    struct ImportAnimationsOptions
    {
        std::string mSourcePath;
        AssetDir* mTargetDir = nullptr;
        std::vector<uint32_t> mAnimationIndices; // empty = all
        std::string mPrefix = "SA_";
        bool mOverwriteExisting = false;
        bool mUniqueNames = true;
    };
    void BeginImportAnimations(AssetDir* targetDir = nullptr);
    bool ImportAnimations(const ImportAnimationsOptions& options);
    void DrawImportAnimationsModal();
 
    // Bake a target-rig-compatible clip from a source SkeletalAnimationAsset
    // and a pair of HumanoidAvatarAssets. The bake mode is the user-selected
    // tier (name-only remap vs reference-pose-aware).
    struct RetargetAnimationOptions
    {
        AssetStub* mSourceClipStub = nullptr;
        AssetStub* mSourceAvatarStub = nullptr;
        AssetStub* mTargetAvatarStub = nullptr;
        AssetDir* mTargetDir = nullptr;
        std::string mOutputName;     // empty = derive from src clip
        int32_t mMode = 0;           // 0=NameRemap, 1=ReferencePose
        bool mOverwriteExisting = false;
        bool mUniqueNames = true;
    };
    void BeginRetargetAnimation(AssetStub* sourceClipStub);
    // POLYPHASE_API: takes an explicit mTargetDir, so unlike most import actions
    // it never reads EditorState::GetAssetDirectory() and is callable from a
    // headless cook.
    POLYPHASE_API bool RetargetAnimation(const RetargetAnimationOptions& options);
    void DrawRetargetAnimationModal();
    void BeginImportCamera();
    void BuildData(Platform platform, bool embedded);
    void BuildData(const std::string& targetId, bool embedded);
    static bool LaunchDesktopBuild(Platform platform, const std::string& outputPath);
    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);
    void AttachSelectedNodesToSocket(Node* newParent, const char* socketName);
 
    // 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;
};
 
// Multi-target counterpart to ActionEditProperty: applies the same value to
// every target whose GatherProperties() yields a property of the same name
// AND same DatumType as the source. Targets without that property (or with a
// type mismatch) are silently skipped and not recorded for undo. One composite
// action = one undo step. Used by the Properties panel when the user edits a
// property with multiple Nodes selected in the Scene Hierarchy.
class ActionEditProperties : public Action
{
public:
    DECLARE_ACTION_INTERFACE(EditProperties)
 
    ActionEditProperties(
        const std::vector<void*>& owners,
        PropertyOwnerType ownerType,
        const std::string& propName,
        uint32_t index,
        Datum value,
        DatumType sourceType);
 
protected:
 
    void GatherPropsFor(void* owner, std::vector<Property>& props);
 
    std::vector<void*> mOwners;
    PropertyOwnerType mOwnerType = PropertyOwnerType::Count;
    std::string mPropertyName;
    uint32_t mIndex = 0;
    DatumType mSourceType = DatumType::Count;
    Datum mValue;
 
    std::vector<AssetRef> mReferencedAssets;
    std::vector<Datum> mPreviousValues;
    std::vector<bool> mApplied;
};
 
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)
    // socketName attaches to a named socket instead of a raw bone index. Passing
    // it keeps the reparent and the socket assignment in a single undo step.
    ActionAttachNode(Node* node, Node* newParent, int32_t childIndex, int32_t boneIndex, const char* socketName = nullptr);
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;
    std::string mSocketName;
    std::string mPrevSocketName;
};
 
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;
};
 
class ActionReplaceNodeType : public Action
{
public:
    DECLARE_ACTION_INTERFACE(ReplaceNodeType);
    ActionReplaceNodeType(Node* oldNode, TypeId newType);
 
protected:
    NodePtr mOldNode;
    NodePtr mNewNode;
    NodePtr mParent;
    int32_t mChildIndex = -1;
    std::vector<NodePtr> mMovedChildren;
    TypeId mNewType;
    uint64_t mSavedUuid = 0;
    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;
};