Polyphase Game Engine
Loading...
Searching...
No Matches
ActionManager.h
Go to the documentation of this file.
1#pragma once
2
3#include <string>
4#include <vector>
5#include <map>
6#include <unordered_map>
7#include <thread>
8#include <mutex>
9#include <atomic>
10#if PLATFORM_LINUX || PLATFORM_MAC
11#include <sys/types.h>
12#endif
13
14#include "EngineTypes.h"
15#include "EditorTypes.h"
16#include "Asset.h"
17#include "AssetRef.h"
18#include "Nodes/Node.h"
21
22class Node3D;
23class Mesh3D;
24class InstancedMesh3D;
25class Timeline;
26class Widget;
28struct MeshInstanceData;
29
31{
32 glm::vec2 mOffset;
33 glm::vec2 mSize;
34 float mRotation;
35};
36
41{
42 std::thread mBuildThread;
43 std::atomic<bool> mRunning{false};
44 std::atomic<bool> mCancelRequested{false};
45 std::atomic<bool> mComplete{false};
46 std::atomic<bool> mSuccess{false};
47 std::atomic<int> mExitCode{0};
48
49 std::mutex mOutputMutex;
50 std::string mOutput;
51 bool mOutputDirty{false};
52
53 // Build config (set in BuildData, used by Phase1 and compile thread)
60 std::string mTargetId;
68 std::unordered_map<std::string, std::string> mTargetOptions;
69 bool mEmbedded{false};
70
77 bool mStaticContent{false};
78
80 bool mContentPak{false};
81
82 std::string mPackagedDir;
83 std::string mBuildProjDir;
84 std::string mProjectDir;
85 std::string mProjectName;
86 std::string mExeSrc;
87 std::string mExtension;
88 int64_t mExeMTimeBeforeBuild{0}; // stat mtime of mExeSrc before compile, used to detect silent link.exe failures
89 bool mStandalone{false};
90 bool mNeedCompile{true};
91 bool mUseSteam{false};
92 std::string mCompileCommand;
93 std::string mPrebuiltExePath;
94 std::string mTmpMakefile;
96 std::string mStripCommand;
97 // Path to a .vcxproj that was injected with addon sources/includes before the build.
98 // Restored from .vcxproj.orig after the build completes (success or failure) so the
99 // working tree doesn't accumulate uncommitted changes.
101
102 // Post-build flags
103 bool mRunAfterBuild{false};
104 bool mRunOnDevice{false};
105 bool mForceRebuild{false};
107 // Snapshot of mForceRebuild captured in BuildData before it's cleared, so BuildPhase1
108 // can still tell whether the user requested a force rebuild when it decides whether
109 // to reuse the prebuilt Polyphase.exe.
110 bool mForceCompile{false};
111
112 // Stashed by the Android branch: the icon source path resolved from
113 // mTargetOptions["android.iconSource"] (fallback EngineConfig::mIconPath).
114 // Read by the icon-generation step further down the same branch.
116
117 void Reset()
118 {
119 // Thread must be joined before calling Reset
120 mRunning.store(false);
121 mCancelRequested.store(false);
122 mComplete.store(false);
123 mSuccess.store(false);
124 mExitCode.store(0);
125 {
126 std::lock_guard<std::mutex> lock(mOutputMutex);
127 mOutput.clear();
128 mOutputDirty = false;
129 }
131 mTargetId.clear();
132 mTargetOptions.clear();
133 mEmbedded = false;
134 mStaticContent = false;
135 mContentPak = false;
136 mPackagedDir.clear();
137 mBuildProjDir.clear();
138 mProjectDir.clear();
139 mProjectName.clear();
140 mExeSrc.clear();
141 mExtension.clear();
143 mStandalone = false;
144 mNeedCompile = true;
145 mUseSteam = false;
146 mCompileCommand.clear();
147 mPrebuiltExePath.clear();
148 mTmpMakefile.clear();
149 mShaderCompileCommand.clear();
150 mStripCommand.clear();
151 mInjectedVcxprojPath.clear();
152 mRunAfterBuild = false;
153 mRunOnDevice = false;
154 mForceRebuild = false;
155 mForceCompile = false;
158#if PLATFORM_LINUX || PLATFORM_MAC
159 mProcessId = 0;
160#elif PLATFORM_WINDOWS
161 mProcessHandle = nullptr;
162#endif
163 }
164
165#if PLATFORM_LINUX || PLATFORM_MAC
166 pid_t mProcessId{0};
167#elif PLATFORM_WINDOWS
168 void* mProcessHandle{nullptr};
169#endif
170};
171
173{
174public:
175 virtual ~Action() {}
176 virtual void Execute();
177 virtual void Reverse();
178 virtual const char* GetName() = 0;
179};
180
181// Plugin-driven actions — addons push these via the
182// PolyphaseEngineAPI::EditorAction_Push entry. The three callbacks carry
183// arbitrary userData (opaque to the engine); the optional freeFn cleans
184// it up when the action falls out of the history.
185//
186// mPluginTag identifies the owning addon DLL — used by NativeAddonManager
187// during UnloadNativeAddon to scrub any PluginAction whose function
188// pointers live inside the DLL that's about to be FreeLibrary'd. Without
189// this, undoing into a stale history after a hot-reload calls into freed
190// memory.
191class PluginAction : public Action
192{
193public:
194 using DoFn = void (*)(void* userData);
195 using UndoFn = void (*)(void* userData);
196 using FreeFn = void (*)(void* userData);
197
198 PluginAction(const char* name, DoFn doFn, UndoFn undoFn,
199 FreeFn freeFn, void* userData);
200 ~PluginAction() override;
201
202 void Execute() override;
203 void Reverse() override;
204 const char* GetName() override;
205
206 void SetPluginTag(const std::string& tag) { mPluginTag = tag; }
207 const std::string& GetPluginTag() const { return mPluginTag; }
208
209private:
210 std::string mName;
211 std::string mPluginTag;
212 DoFn mDoFn = nullptr;
213 UndoFn mUndoFn = nullptr;
214 FreeFn mFreeFn = nullptr;
215 void* mUserData = nullptr;
216};
217
218// Groups multiple actions into a single undo step. Used by plugin
219// EditorAction_BeginGroup / EditorAction_EndGroup so a continuous
220// paint-drag (which may push 60+ spawn actions per second) is one
221// Ctrl+Z.
222class ActionGroup : public Action
223{
224public:
225 explicit ActionGroup(const char* name);
226 ~ActionGroup() override;
227
228 void Add(Action* a); // takes ownership
229 bool IsEmpty() const { return mChildren.empty(); }
230
231 void Execute() override; // forward order
232 void Reverse() override; // reverse order
233 const char* GetName() override;
234
235 std::vector<Action*>& GetChildren() { return mChildren; }
236 const std::vector<Action*>& GetChildren() const { return mChildren; }
237
238private:
239 std::string mName;
240 std::vector<Action*> mChildren;
241};
242
244{
245public:
246
248
249 static void Create();
250 static void Destroy();
252
253 void Update();
254
256
257 Node* SpawnNode(TypeId nodeType, Node* parent);
258 Node* SpawnNode(TypeId nodeType, glm::vec3 position);
259
260 Node* SpawnBasicNode(const std::string& name, Node* parent, Asset* srcAsset = nullptr, bool setWorldPos = false, glm::vec3 worldPos = { 0.0f, 0.0f, 0.0f });
261
262 void ExecuteAction(Action* action);
263 void Undo();
264 void Redo();
265
266 // Plugin-action group helpers (used by EditorAction_BeginGroup /
267 // EditorAction_EndGroup). Nesting is supported — the outermost
268 // Begin starts the group; the matching End closes it and pushes
269 // a single ActionGroup onto the history.
270 void BeginActionGroup(const char* name);
272
273 // Walk mActionHistory + mActionFuture and drop any PluginAction
274 // (or ActionGroup containing one) whose mPluginTag matches `tag`.
275 // Called from NativeAddonManager::UnloadNativeAddon BEFORE the DLL
276 // is FreeLibrary'd, so the function pointers stored on the action
277 // are still valid when freeFn fires.
278 void PurgePluginActions(const std::string& pluginTag);
279
280 // Actions
281 void EXE_EditProperty(void* owner, PropertyOwnerType ownerType, const std::string& name, uint32_t index, Datum newValue);
282 void EXE_EditPropertyOnSelection(void* owner, PropertyOwnerType ownerType, const std::string& name, uint32_t index, Datum newValue);
283 void EXE_EditTransform(Node3D* node, const glm::mat4& transform);
284 void EXE_EditTransforms(const std::vector<Node3D*>& nodes, const std::vector<glm::mat4>& newTransforms);
285 void EXE_EditWidgetTransforms(const std::vector<Widget*>& widgets, const std::vector<WidgetTransformData>& newTransforms);
287 Node* EXE_SpawnNode(const char* srcTypeName);
290 void EXE_DeleteNode(Node* node);
291 std::vector<Node*> EXE_SpawnNodes(const std::vector<Node*>& nodes);
292 void EXE_DeleteNodes(const std::vector<Node*>& nodes);
293 void EXE_AttachNode(Node* node, Node* newParent, int32_t childIndex, int32_t boneIndex, const char* socketName = nullptr);
294 void EXE_SetRootNode(Node* newRoot);
295 void EXE_SetWorldRotation(Node3D* node, glm::quat rot);
296 void EXE_SetWorldPosition(Node3D* node, glm::vec3 pos);
297 void EXE_SetWorldScale(Node3D* node, glm::vec3 scale);
299 void EXE_ResetScene(Node* node);
300 void EXE_SetInstanceColors(const std::vector<ActionSetInstanceColorsData>& data);
301 void EXE_SetVoxels(class Voxel3D* voxel, const std::vector<struct VoxelChange>& changes);
302 void EXE_SetTerrainHeights(class Terrain3D* terrain, const std::vector<struct TerrainHeightChange>& changes);
303 void EXE_PaintTiles(class TileMap2D* tileMapNode, const std::vector<struct TilePaintChange>& changes);
304 void EXE_SetInstanceData(InstancedMesh3D* instMesh, int32_t startIndex, const std::vector<MeshInstanceData>& data);
305
311 void EXE_ReplaceSelectedWithAsset(Asset* asset, const std::vector<Node*>& nodes);
312
318 void EXE_ReplaceWithInstancedMesh(const std::vector<Node*>& nodes, bool merge);
319
324 void EXE_ReplaceWithStaticMesh(const std::vector<Node*>& nodes);
325
332 void EXE_ParentSelectedWith(const std::vector<Node*>& nodes, TypeId parentType,
334
341 void EXE_ReplaceNodeType(Node* oldNode, TypeId newType);
342
343 // Timeline actions
344 void EXE_TimelineAddTrack(Timeline* timeline, TypeId trackType);
345 void EXE_TimelineRemoveTrack(Timeline* timeline, int32_t trackIndex);
346 void EXE_TimelineAddClip(Timeline* timeline, int32_t trackIndex, TypeId clipType, float startTime, float duration);
347 void EXE_TimelineRemoveClip(Timeline* timeline, int32_t trackIndex, int32_t clipIndex);
348 void EXE_TimelineMoveClip(Timeline* timeline, int32_t trackIndex, int32_t clipIndex, float oldStartTime, float newStartTime);
349 void EXE_TimelineBindTrack(Timeline* timeline, int32_t trackIndex, uint64_t oldUuid, uint64_t newUuid, const std::string& oldName, const std::string& newName);
350
354 void ExileNode(NodePtr node);
356 void GatherScriptFiles(const std::string& dir, std::vector<std::string>& outFiles);
357
366 void ObfuscatePackagedContent(const std::string& packagedDir);
367
376 bool PackPackagedContent(const std::string& packagedDir,
377 const std::string& projectName,
378 bool contentIsEmbedded);
379
380protected:
381
384
385 // Raw (non-.oct) file entry to embed into gEmbeddedRawAssets[].
386 // mLookupKey is the canonical VFS lookup path the runtime will use
387 // (projectDir-relative, forward slashes, e.g. "Assets/intro.mp4" or
388 // "Packages/videoplayer/Assets/test.mp4").
390 {
391 std::string mAbsolutePath;
392 std::string mLookupKey;
393 bool mEngineAsset = false;
394 };
395
397 std::vector<std::pair<AssetStub*, std::string> >& assets,
398 std::vector<EmbeddedRawAssetEntry>& rawAssets,
399 const char* headerPath,
400 const char* sourcePath);
401
403 std::vector<std::string> files,
404 const char* headerPath,
405 const char* sourcePath);
406
407
408 std::vector<Action*> mActionHistory;
409 std::vector<Action*> mActionFuture;
410 std::vector<NodePtr> mExiledNodes;
411
412 // Open plugin-action group; non-null between BeginActionGroup
413 // and the outermost matching EndActionGroup.
415 int mGroupDepth = 0;
416
417 // Non-blocking build state
419 bool mShowBuildModal = false;
421 bool mBuildAutoScroll = true;
422 bool mBuildPending = false;
423
424 // Extract-skeletal-animations modal state. Lives here because the modal
425 // body is drawn from the editor's per-frame loop via
426 // DrawExtractSkeletalAnimationsModal — same pattern as DrawBuildModal.
428 std::vector<uint8_t> mExtractSkelAnimSelections; // 1 byte per anim, 0/1
429 char mExtractSkelAnimPrefix[32] = "SA_";
434
435 // Import-animations modal state (animation-only fbx/glb).
438 std::vector<std::string> mImportAnimNames;
439 std::vector<uint8_t> mImportAnimSelections;
440 char mImportAnimPrefix[32] = "SA_";
442 bool mImportAnimUnique = true;
444
445 // Retarget-animation modal state.
446 // One entry = single-clip retarget (editable output name). Several =
447 // batch: every clip is baked with the same avatar pair and named
448 // <clip name> + mRetargetSuffix.
449 std::vector<AssetStub*> mRetargetClipStubs;
452 char mRetargetOutputName[128] = "";
453 char mRetargetSuffix[64] = "_Retargeted";
454 int32_t mRetargetMode = 0; // 0=NameRemap, 1=ReferencePose
455 bool mRetargetOverwrite = false;
456 bool mRetargetUnique = true;
457 bool mShowRetargetModal = false;
459
463 // Runs the active target's PostPackage callback (if any) against an
464 // already-populated Packaged dir. Returns false when the callback fails.
465 bool RunPostPackage(Platform platform, const std::string& projectName, const std::string& projectDir,
466 const std::string& packagedDir, const std::string& compiledBinaryDir);
468
469public:
470
471 // Public so the build-context WriteOutputLine trampoline can forward a
472 // target's PostPackage progress into the PackagingWindow log.
473 void AppendBuildOutput(const std::string& text);
474
475 // Actions
476 void CreateNewProject(const char* folderPath = nullptr, bool cpp = false, const char* defaultSceneName = "SC_Default");
477 void OpenProject(const char* path = nullptr);
478
479 // Drop Directory.Build.props + PolyphaseConfig.cmake at the project
480 // root recording the engine path. Lets addons under <project>/Packages
481 // build via Visual Studio / cmake without env-var setup. Called from
482 // OpenProject each time a project loads, so the recorded path stays in
483 // sync with whichever editor binary opened the project.
485
486 void OpenScene();
488 // Defer OpenScene so the progress modal renders before Scene::Instantiate
489 // (which builds the node tree) blocks the main thread on large scenes.
490 // Pass nullptr to trigger the OS file dialog inside the worker; pass a
491 // stub to open that scene directly (same as the non-Request OpenScene).
494 POLYPHASE_API void SaveScene(bool saveAs);
495 // Defer SaveScene/SaveSelectedAsset/ResaveAllAssets to end-of-frame so the
496 // progress modal can render before the (potentially slow) capture and
497 // serialization work blocks the main thread. The hotkey / menu /
498 // command path should prefer these wrappers; SaveScene() etc. remain
499 // available for callers that need synchronous semantics (e.g. the REST
500 // controller, where the response must include the result).
501 void RequestSaveScene(bool saveAs);
506 // Queue non-mesh asset imports for end-of-frame. Appends to any imports
507 // already pending so a batch (file dialog multi-select, drag-drop) runs
508 // under one progress modal. Use ImportAsset(path) directly only where a
509 // synchronous result is required (REST controller).
510 void RequestImportAssets(const std::vector<std::string>& paths);
511 // End-of-frame worker for RequestImportAssets. Called from EditorMain.cpp.
513 // Defer OpenProject so the progress modal renders before LoadProject's
514 // (potentially many-second) Purge / ReloadAddons / Discover sequence
515 // blocks the main thread. Pass empty/null path to trigger the OS folder
516 // picker inside the worker (same as direct OpenProject).
517 void RequestOpenProject(const char* path);
518 // File > Close Project — closes the current project at end-of-frame.
519 // Unloads every native addon DLL on the way out so addon Intermediate
520 // folders are no longer file-locked and the user can rebuild on demand.
522 // Tools > Addons > Recover from stuck addons — Tier-2 recovery.
523 void RequestAddonRecovery(const char* reason);
524 // Tools > Addons > Restart Editor (Clean Addon Rebuild) — Tier-3 recovery.
525 // Spawns a new editor process, then exits the current one (Job Object
526 // teardown reliably kills mspdbsrv); the new instance picks up
527 // --addon-recovery and wipes intermediates before opening the project.
528 void RequestEditorRestartForAddonRecovery(const char* reason);
529 // Synchronous Tier-2 / Tier-3 implementations. Called by the EditorMain
530 // deferred-dispatcher after the request flag is set; safe to call
531 // directly when no progress modal is in flight.
533 void RecoverFromStuckAddons(const char* reason);
534 void RestartEditorForAddonRecovery(const char* reason);
535 // sceneType: 0 = 2D Canvas root, 1 = 3D Node3D root. targetDir defaults to the
536 // editor's currently-selected asset directory. Returns the created Scene asset
537 // (already saved to disk) or nullptr on failure.
538 POLYPHASE_API Scene* CreateNewScene(const char* sceneName, int sceneType, bool createCamera, bool createSkybox = false, bool createDirectionalLight = false, bool createUICanvas = false, AssetDir* targetDir = nullptr);
541 void DeleteNode(Node* node);
542 void RunScript();
544 // POLYPHASE_API: the per-asset mesh importers, exposed so an addon can drive
545 // a conversion pipeline without going through ImportScene -- which ends in
546 // OpenEditScene and so requires a fully initialized editor.
547 POLYPHASE_API Asset* ImportAsset(const std::string& path, const std::string& overrideBaseName = "", const MeshImportOptions* meshOpts = nullptr);
548 POLYPHASE_API Asset* ImportAssetCombined(const std::string& path, const std::string& overrideBaseName = "", const MeshImportOptions* meshOpts = nullptr);
549
550 // Loose-file import: copies the user-picked file(s) into the current
551 // AssetDir verbatim (no .oct conversion) and registers them with the
552 // packager. Files survive packaging as-is; Lua/native code reads them
553 // via Stream::ReadFile / SYS_AcquireFileData. Used for .json, media,
554 // and arbitrary data files an addon or script wants to ship.
556 void ImportLooseFile(const std::string& sourcePath, AssetDir* targetDir);
559 void ImportCamera(const CameraImportOptions& options);
560 // Returns the created (or reimported) Scene asset, or nullptr on failure.
561 POLYPHASE_API Asset* ImportScene(const SceneImportOptions& options);
565
566 // Extract embedded animations from a SkeletalMesh asset into standalone
567 // SkeletalAnimationAsset files. BeginExtractSkeletalAnimations opens the
568 // selection modal; ExtractSkeletalAnimations runs the actual generation.
570 {
573 std::vector<uint32_t> mAnimationIndices; // empty = all
574 std::string mPrefix = "SA_";
575 bool mOverwriteExisting = false;
576 bool mUniqueNames = true;
578 };
582
583 // Import animations from an animation-only .fbx/.glb/.gltf/.dae file
584 // (or any model file the user picks — only the embedded clips are read).
586 {
587 std::string mSourcePath;
589 std::vector<uint32_t> mAnimationIndices; // empty = all
590 std::string mPrefix = "SA_";
591 bool mOverwriteExisting = false;
592 bool mUniqueNames = true;
593 };
594 void BeginImportAnimations(AssetDir* targetDir = nullptr);
597
598 // Bake a target-rig-compatible clip from a source SkeletalAnimationAsset
599 // and a pair of HumanoidAvatarAssets. The bake mode is the user-selected
600 // tier (name-only remap vs reference-pose-aware).
602 {
607 std::string mOutputName; // empty = derive from src clip
608 int32_t mMode = 0; // 0=NameRemap, 1=ReferencePose
609 bool mOverwriteExisting = false;
610 bool mUniqueNames = true;
611 };
612 void BeginRetargetAnimation(AssetStub* sourceClipStub);
613 // Batch variant: non-clip stubs are skipped. All clips share the avatar
614 // pair / mode picked in the modal.
615 void BeginRetargetAnimation(const std::vector<AssetStub*>& sourceClipStubs);
616 // POLYPHASE_API: takes an explicit mTargetDir, so unlike most import actions
617 // it never reads EditorState::GetAssetDirectory() and is callable from a
618 // headless cook.
622 void BuildData(Platform platform, bool embedded);
632 void BuildData(const std::string& targetId, bool embedded);
644 static bool LaunchDesktopBuild(Platform platform, const std::string& outputPath);
646 bool IsBuildRunning() const;
655 bool DuplicateNodes(std::vector<Node*> nodes);
656 void AttachSelectedNodes(Node* newParent, int32_t boneIdx);
657 void AttachSelectedNodesToSocket(Node* newParent, const char* socketName);
658
659 // Project upgrade functions
662};
663
664#define DECLARE_ACTION_INTERFACE(Name) \
665 virtual void Execute() override; \
666 virtual void Reverse() override; \
667 virtual const char* GetName() { return #Name; }
668
669// Actions
670
672{
673public:
674 DECLARE_ACTION_INTERFACE(EditProperty)
675
677 void* owner,
678 PropertyOwnerType ownerType,
679 const std::string& propName,
680 uint32_t index,
681 Datum value);
682
683protected:
684
685 void GatherProps(std::vector<Property>& props);
686 Property* FindProp(std::vector<Property>& props, const std::string& name);
687
688 void* mOwner = nullptr;
691 uint32_t mIndex = 0;
693
696};
697
698// Multi-target counterpart to ActionEditProperty: applies the same value to
699// every target whose GatherProperties() yields a property of the same name
700// AND same DatumType as the source. Targets without that property (or with a
701// type mismatch) are silently skipped and not recorded for undo. One composite
702// action = one undo step. Used by the Properties panel when the user edits a
703// property with multiple Nodes selected in the Scene Hierarchy.
705{
706public:
707 DECLARE_ACTION_INTERFACE(EditProperties)
708
710 const std::vector<void*>& owners,
711 PropertyOwnerType ownerType,
712 const std::string& propName,
713 uint32_t index,
714 Datum value,
715 DatumType sourceType);
716
717protected:
718
719 void GatherPropsFor(void* owner, std::vector<Property>& props);
720
721 std::vector<void*> mOwners;
724 uint32_t mIndex = 0;
725 DatumType mSourceType = DatumType::Count;
727
728 std::vector<AssetRef> mReferencedAssets;
729 std::vector<Datum> mPreviousValues;
730 std::vector<bool> mApplied;
731};
732
734{
735public:
736 DECLARE_ACTION_INTERFACE(EditTransforms)
737
739 const std::vector<Node3D*>& nodes,
740 const std::vector<glm::mat4>& newTransforms);
741
742protected:
743 std::vector<Node3D*> mNodes;
744 std::vector<glm::mat4> mNewTransforms;
745 std::vector<glm::mat4> mPrevTransforms;
746};
747
749{
750public:
751 DECLARE_ACTION_INTERFACE(EditWidgetTransforms)
752
754 const std::vector<Widget*>& widgets,
755 const std::vector<WidgetTransformData>& newTransforms);
756
757protected:
758 std::vector<Widget*> mWidgets;
759 std::vector<WidgetTransformData> mNewTransforms;
760 std::vector<WidgetTransformData> mPrevTransforms;
761};
762
764{
765public:
766 DECLARE_ACTION_INTERFACE(SpawnNodes)
767 ActionSpawnNodes(const std::vector<TypeId>& types);
768 ActionSpawnNodes(const std::vector<const char*>& typeNames);
769 ActionSpawnNodes(const std::vector<SceneRef>& scenes);
770 ActionSpawnNodes(const std::vector<Node*>& srcNodes);
771
772 const std::vector<NodePtr>& GetNodes() const { return mNodes; }
773
774protected:
775
776 // Action inputs, only one should be filled.
777 std::vector<TypeId> mSrcTypes;
778 std::vector<const char*> mSrcTypeNames;
779 std::vector<SceneRef> mSrcScenes;
780 std::vector<NodePtr> mSrcNodes;
781
782 // Populated after first Execute()
783 std::vector<NodePtr> mNodes;
784
785 // Populated after first Reverse()
786 std::vector<NodePtr> mParents;
787};
788
790{
791public:
792 DECLARE_ACTION_INTERFACE(DeleteNodes)
793 ActionDeleteNodes(const std::vector<Node*>& nodes);
794protected:
795 std::vector<NodePtr> mNodes;
796 std::vector<NodePtr> mParents;
797 std::vector<int32_t> mChildIndices;
798 std::vector<int32_t> mBoneIndices;
799};
800
802{
803public:
804 DECLARE_ACTION_INTERFACE(AttachNode)
805 // socketName attaches to a named socket instead of a raw bone index. Passing
806 // it keeps the reparent and the socket assignment in a single undo step.
807 ActionAttachNode(Node* node, Node* newParent, int32_t childIndex, int32_t boneIndex, const char* socketName = nullptr);
808protected:
809 NodePtr mNode = nullptr;
810 NodePtr mNewParent = nullptr;
811 NodePtr mPrevParent = nullptr;
812 int32_t mChildIndex = -1;
813 int32_t mPrevChildIndex = -1;
814 int32_t mBoneIndex = -1;
815 int32_t mPrevBoneIndex = -1;
816 std::string mSocketName;
817 std::string mPrevSocketName;
818};
819
821{
822public:
823 DECLARE_ACTION_INTERFACE(SetRootNode)
825protected:
826 NodePtr mNewRoot = nullptr;
827 NodePtr mOldRoot = nullptr;
828 NodePtr mNewRootParent = nullptr;
829 int32_t mNewRootChildIndex = -1;
830};
831
833{
834public:
835 DECLARE_ACTION_INTERFACE(SetWorldRotation)
836 ActionSetWorldRotation(Node3D* node, glm::quat rot);
837protected:
838 Node3D* mNode = nullptr;
839 glm::quat mNewRotation;
840 glm::quat mPrevRotation;
841};
842
844{
845public:
846 DECLARE_ACTION_INTERFACE(SetWorldPosition)
847 ActionSetWorldPosition(Node3D* node, glm::vec3 pos);
848protected:
849 Node3D* mNode = nullptr;
850 glm::vec3 mNewPosition;
851 glm::vec3 mPrevPosition;
852};
853
855{
856public:
857 DECLARE_ACTION_INTERFACE(SetWorldScale)
858 ActionSetWorldScale(Node3D* node, glm::vec3 scale);
859protected:
860 Node3D* mNode = nullptr;
861 glm::vec3 mNewScale;
862 glm::vec3 mPrevScale;
863};
864
866{
867public:
870
871protected:
872
873 Node* mNode = nullptr;
875
876};
877
879{
880public:
883
884protected:
885
886 Node* mNode = nullptr;
888 std::vector<Property> mPrevProperties;
889};
890
892{
893 StaticMesh3D* mMesh3d = nullptr;
894 std::vector<uint32_t> mColors;
895 bool mBakedLight = false;
896};
897
899{
900public:
901 DECLARE_ACTION_INTERFACE(SetInstanceColors);
902 ActionSetInstanceColors(const std::vector<ActionSetInstanceColorsData>& data);
903
904protected:
905
906 std::vector<ActionSetInstanceColorsData> mData;
907 std::vector<ActionSetInstanceColorsData> mPrevData;
908};
909
911{
912public:
913 DECLARE_ACTION_INTERFACE(SetInstanceData);
914 ActionSetInstanceData(InstancedMesh3D* instMesh, int32_t startIndex, const std::vector<MeshInstanceData>& data);
915
916protected:
917 InstancedMesh3D* mInstMesh = nullptr;
918 int32_t mStartIndex = -1;
919
920 std::vector<MeshInstanceData> mData;
921 std::vector<MeshInstanceData> mPrevData;
922};
923
928{
929public:
930 DECLARE_ACTION_INTERFACE(ReplaceWithAsset);
931 ActionReplaceWithAsset(Asset* asset, const std::vector<Node*>& nodes);
932
933protected:
934
935 enum class ReplaceMode
936 {
938 Material,
939 Scene,
940 Invalid
941 };
942
944 ReplaceMode mMode = ReplaceMode::Invalid;
945
946 // For StaticMesh mode
947 std::vector<StaticMesh3D*> mMeshNodes;
948 std::vector<StaticMeshRef> mPrevMeshes;
949
950 // For Material mode
951 std::vector<Mesh3D*> mMatNodes;
952 std::vector<MaterialRef> mPrevMaterials;
953
954 // For Scene mode
962 std::vector<SceneReplaceEntry> mSceneEntries;
963};
964
969{
970public:
971 DECLARE_ACTION_INTERFACE(ReplaceWithInstancedMesh);
972 ActionReplaceWithInstancedMesh(const std::vector<Node*>& nodes, bool merge);
973
974protected:
975
977 {
978 std::vector<NodePtr> mOriginalNodes;
979 std::vector<NodePtr> mOriginalParents;
980 std::vector<int32_t> mOriginalChildIndices;
983 int32_t mInstancedChildIndex = -1;
984 };
985
986 std::vector<GroupEntry> mGroups;
987 bool mFirstExecute = true;
988};
989
994{
995public:
996 DECLARE_ACTION_INTERFACE(ReplaceWithStaticMesh);
997 ActionReplaceWithStaticMesh(const std::vector<Node*>& nodes);
998
999protected:
1000
1002 {
1005 int32_t mOriginalChildIndex = -1;
1006 std::vector<NodePtr> mCreatedNodes;
1007 };
1008
1009 std::vector<SplitEntry> mEntries;
1010 bool mFirstExecute = true;
1011};
1012
1017{
1018public:
1019 DECLARE_ACTION_INTERFACE(ParentSelectedWith);
1021 const std::vector<Node*>& nodes,
1022 TypeId newParentType,
1023 ArrayOrientation arrayOrientation = ArrayOrientation::Vertical);
1024
1025protected:
1026 std::vector<NodePtr> mNodes;
1027 std::vector<NodePtr> mPrevParents;
1028 std::vector<int32_t> mPrevChildIndices;
1029 std::vector<int32_t> mPrevBoneIndices;
1032 int32_t mCreatedParentChildIndex = -1;
1035 bool mFirstExecute = true;
1036};
1037
1045{
1046public:
1049
1050protected:
1054 int32_t mChildIndex = -1;
1055 std::vector<NodePtr> mMovedChildren;
1057 uint64_t mSavedUuid = 0;
1058 bool mFirstExecute = true;
1059};
1060
1061struct VoxelChange;
1062class Voxel3D;
1063
1065{
1066public:
1068 ActionSetVoxels(Voxel3D* voxel, const std::vector<VoxelChange>& changes);
1069
1070protected:
1071 Voxel3D* mVoxel = nullptr;
1072 std::vector<VoxelChange> mChanges;
1073};
1074
1075struct TerrainHeightChange;
1076class Terrain3D;
1077
1079{
1080public:
1081 DECLARE_ACTION_INTERFACE(SetTerrainHeights);
1082 ActionSetTerrainHeights(Terrain3D* terrain, const std::vector<TerrainHeightChange>& changes);
1083
1084protected:
1085 Terrain3D* mTerrain = nullptr;
1086 std::vector<TerrainHeightChange> mChanges;
1087};
1088
1089struct TilePaintChange;
1090class TileMap2D;
1091
1093{
1094public:
1096 ActionPaintTiles(TileMap2D* tileMapNode, const std::vector<TilePaintChange>& changes);
1097
1098protected:
1099 TileMap2D* mTarget = nullptr;
1100 std::vector<TilePaintChange> mChanges;
1101};
#define DECLARE_ACTION_INTERFACE(Name)
Definition ActionManager.h:664
ArrayOrientation
Definition ArrayWidget.h:11
DatumType
Definition Datum.h:29
Platform
Definition EngineTypes.h:32
PropertyOwnerType
Definition EngineTypes.h:159
uint32_t TypeId
Definition EngineTypes.h:75
#define POLYPHASE_API
Definition PolyphaseAPI.h:31
Definition ActionManager.h:802
Definition ActionManager.h:790
Definition ActionManager.h:705
Definition ActionManager.h:672
Datum mPreviousValue
Definition ActionManager.h:695
Property * FindProp(std::vector< Property > &props, const std::string &name)
Datum mValue
Definition ActionManager.h:692
void * mOwner
Definition ActionManager.h:688
void GatherProps(std::vector< Property > &props)
PropertyOwnerType mOwnerType
Definition ActionManager.h:689
std::string mPropertyName
Definition ActionManager.h:690
uint32_t mIndex
Definition ActionManager.h:691
AssetRef mReferencedAsset
Definition ActionManager.h:694
Definition ActionManager.h:734
Definition ActionManager.h:749
Definition ActionManager.h:223
ActionGroup(const char *name)
bool IsEmpty() const
Definition ActionManager.h:229
std::vector< Action * > & GetChildren()
Definition ActionManager.h:235
void Reverse() override
~ActionGroup() override
void Execute() override
const std::vector< Action * > & GetChildren() const
Definition ActionManager.h:236
const char * GetName() override
void Add(Action *a)
Definition ActionManager.h:244
void EXE_TimelineAddClip(Timeline *timeline, int32_t trackIndex, TypeId clipType, float startTime, float duration)
void WriteProjectLocalPolyphaseConfig()
std::string mBuildDisplayOutput
Definition ActionManager.h:420
bool mImportAnimOverwrite
Definition ActionManager.h:441
AssetRef mRetargetDstAvatar
Definition ActionManager.h:451
void RequestCloseProject()
void AttachSelectedNodes(Node *newParent, int32_t boneIdx)
bool mExtractSkelAnimOverwrite
Definition ActionManager.h:430
bool mShowRetargetModal
Definition ActionManager.h:457
void BeginActionGroup(const char *name)
POLYPHASE_API Asset * ImportAsset(const std::string &path, const std::string &overrideBaseName="", const MeshImportOptions *meshOpts=nullptr)
void RequestBakeOcclusion()
void BeginImportCamera()
bool PackPackagedContent(const std::string &packagedDir, const std::string &projectName, bool contentIsEmbedded)
Content Pak: fold shipped content into a single Content.pak.
bool mRetargetModalJustOpened
Definition ActionManager.h:458
void BeginReimportAssetWithNewFile(AssetStub *stub)
void DrawRetargetAnimationModal()
void EXE_DeleteNodes(const std::vector< Node * > &nodes)
bool mShowBuildModal
Definition ActionManager.h:419
std::string mImportAnimSourcePath
Definition ActionManager.h:436
void EXE_ReplaceWithInstancedMesh(const std::vector< Node * > &nodes, bool merge)
Replace selected StaticMesh3D nodes with InstancedMesh3D nodes.
static void Create()
void EndActionGroup()
void EXE_EditPropertyOnSelection(void *owner, PropertyOwnerType ownerType, const std::string &name, uint32_t index, Datum newValue)
void BuildPhase1()
void ImportTinyLLMModel()
void RestartEditorForAddonRecovery(const char *reason)
void DeleteAssetDir(AssetDir *dir)
void UpgradeProject()
void FinalizeLocalBuild()
void ExecuteAction(Action *action)
POLYPHASE_API void SaveScene(bool saveAs)
void EXE_SetRootNode(Node *newRoot)
void SaveSelectedAsset()
void BeginImportAnimations(AssetDir *targetDir=nullptr)
std::vector< NodePtr > mExiledNodes
Definition ActionManager.h:410
Node * EXE_SpawnNode(TypeId srcType)
void EXE_ReplaceNodeType(Node *oldNode, TypeId newType)
Replace a node with a new node of a different type, preserving position in parent,...
void PrepareRelease()
void EXE_SetWorldRotation(Node3D *node, glm::quat rot)
void EXE_TimelineRemoveClip(Timeline *timeline, int32_t trackIndex, int32_t clipIndex)
void ClearActionFuture()
void EXE_TimelineMoveClip(Timeline *timeline, int32_t trackIndex, int32_t clipIndex, float oldStartTime, float newStartTime)
void EXE_EditTransform(Node3D *node, const glm::mat4 &transform)
void OnSelectedNodeChanged()
char mRetargetSuffix[64]
Definition ActionManager.h:453
void AppendBuildOutput(const std::string &text)
void PurgePluginActions(const std::string &pluginTag)
void EXE_UnlinkScene(Node *node)
POLYPHASE_API bool RetargetAnimation(const RetargetAnimationOptions &options)
void ResaveAllAssets()
void ImportCamera(const CameraImportOptions &options)
int32_t mRetargetMode
Definition ActionManager.h:454
void DrawBuildModal()
bool mShowImportAnimModal
Definition ActionManager.h:443
void RequestClearOcclusion()
void ResetUndoRedo()
void BeginImportScene()
void EXE_SetWorldPosition(Node3D *node, glm::vec3 pos)
bool mImportAnimUnique
Definition ActionManager.h:442
void AttachSelectedNodesToSocket(Node *newParent, const char *socketName)
bool mExtractSkelAnimRemoveEmbedded
Definition ActionManager.h:432
void EXE_DeleteNode(Node *node)
void RestoreExiledNode(NodePtr node)
void EXE_SetVoxels(class Voxel3D *voxel, const std::vector< struct VoxelChange > &changes)
char mRetargetOutputName[128]
Definition ActionManager.h:452
void EXE_TimelineBindTrack(Timeline *timeline, int32_t trackIndex, uint64_t oldUuid, uint64_t newUuid, const std::string &oldName, const std::string &newName)
void RequestResaveAllAssets()
void EXE_SetInstanceData(InstancedMesh3D *instMesh, int32_t startIndex, const std::vector< MeshInstanceData > &data)
void RequestOpenScene(AssetStub *stub)
Node * EXE_SpawnNode(Scene *srcScene)
void DeleteAllNodes()
void ImportLooseFile()
void CreateNewProject(const char *folderPath=nullptr, bool cpp=false, const char *defaultSceneName="SC_Default")
void OpenScene()
void EXE_TimelineAddTrack(Timeline *timeline, TypeId trackType)
std::vector< AssetStub * > mRetargetClipStubs
Definition ActionManager.h:449
void DrawExtractSkeletalAnimationsModal()
void RecoverFromStuckAddons(const char *reason)
void EXE_SetTerrainHeights(class Terrain3D *terrain, const std::vector< struct TerrainHeightChange > &changes)
static ActionManager * sInstance
Definition ActionManager.h:382
bool ImportAnimations(const ImportAnimationsOptions &options)
void BeginRetargetAnimation(AssetStub *sourceClipStub)
AssetDir * mImportAnimTargetDir
Definition ActionManager.h:437
void RequestImportAssets(const std::vector< std::string > &paths)
bool mRetargetUnique
Definition ActionManager.h:456
bool ExtractSkeletalAnimations(const ExtractSkeletalAnimationsOptions &options)
static POLYPHASE_API ActionManager * Get()
void ExileNode(NodePtr node)
AssetStub * mExtractSkelAnimSourceStub
Definition ActionManager.h:427
void EXE_PaintTiles(class TileMap2D *tileMapNode, const std::vector< struct TilePaintChange > &changes)
void EXE_EditWidgetTransforms(const std::vector< Widget * > &widgets, const std::vector< WidgetTransformData > &newTransforms)
void BeginRetargetAnimation(const std::vector< AssetStub * > &sourceClipStubs)
void ClearActionHistory()
char mExtractSkelAnimPrefix[32]
Definition ActionManager.h:429
std::vector< std::string > mImportAnimNames
Definition ActionManager.h:438
std::vector< uint8_t > mImportAnimSelections
Definition ActionManager.h:439
void EXE_ReplaceWithStaticMesh(const std::vector< Node * > &nodes)
Split selected InstancedMesh3D nodes into individual StaticMesh3D nodes.
void GenerateEmbeddedAssetFiles(std::vector< std::pair< AssetStub *, std::string > > &assets, std::vector< EmbeddedRawAssetEntry > &rawAssets, const char *headerPath, const char *sourcePath)
POLYPHASE_API Asset * ImportAssetCombined(const std::string &path, const std::string &overrideBaseName="", const MeshImportOptions *meshOpts=nullptr)
bool mExtractSkelAnimUnique
Definition ActionManager.h:431
void BuildData(const std::string &targetId, bool embedded)
Run a build against a registered build target by id.
bool DuplicateNodes(std::vector< Node * > nodes)
void EXE_TimelineRemoveTrack(Timeline *timeline, int32_t trackIndex)
void EXE_EditTransforms(const std::vector< Node3D * > &nodes, const std::vector< glm::mat4 > &newTransforms)
void ClearWorld()
bool mRetargetOverwrite
Definition ActionManager.h:455
void EXE_AttachNode(Node *node, Node *newParent, int32_t childIndex, int32_t boneIndex, const char *socketName=nullptr)
void EXE_SetInstanceColors(const std::vector< ActionSetInstanceColorsData > &data)
bool mBuildPending
Definition ActionManager.h:422
void CloseProject()
LocalBuildState & GetBuildState()
Definition ActionManager.h:647
POLYPHASE_API Scene * CreateNewScene(const char *sceneName, int sceneType, bool createCamera, bool createSkybox=false, bool createDirectionalLight=false, bool createUICanvas=false, AssetDir *targetDir=nullptr)
void RecaptureAndSaveAllScenes()
POLYPHASE_API Asset * ImportScene(const SceneImportOptions &options)
void ObfuscatePackagedContent(const std::string &packagedDir)
Static Build: obfuscate shipped content under the staging dir.
bool CheckProjectNeedsUpgrade()
void DeleteNode(Node *node)
ActionGroup * mOpenGroup
Definition ActionManager.h:414
void EXE_ReplaceSelectedWithAsset(Asset *asset, const std::vector< Node * > &nodes)
Replace selected nodes' mesh/material with an asset, or replace with scene instances.
static bool LaunchDesktopBuild(Platform platform, const std::string &outputPath)
Launch a packaged desktop (Windows/Linux) build directly.
POLYPHASE_API void OpenScene(Scene *scene)
Node * SpawnNode(TypeId nodeType, Node *parent)
bool mShowExtractSkelAnimModal
Definition ActionManager.h:433
Node * EXE_SpawnNode(const char *srcTypeName)
void ImportPendingAssets()
void ImportAsset()
void RequestSaveScene(bool saveAs)
void BeginExtractSkeletalAnimations(AssetStub *skeletalMeshStub)
void OpenProject(const char *path=nullptr)
void RequestSaveSelectedAsset()
void RequestOpenSceneFromDialog()
void ImportLooseFile(const std::string &sourcePath, AssetDir *targetDir)
bool RunPostPackage(Platform platform, const std::string &projectName, const std::string &projectDir, const std::string &packagedDir, const std::string &compiledBinaryDir)
bool IsBuildRunning() const
void BeginReimportScene(AssetStub *sceneStub)
char mImportAnimPrefix[32]
Definition ActionManager.h:440
Node * EXE_SpawnNode(Node *srcNode)
void EXE_ResetScene(Node *node)
bool mBuildAutoScroll
Definition ActionManager.h:421
void RequestOpenProject(const char *path)
LocalBuildState mBuildState
Definition ActionManager.h:418
Node * SpawnBasicNode(const std::string &name, Node *parent, Asset *srcAsset=nullptr, bool setWorldPos=false, glm::vec3 worldPos={ 0.0f, 0.0f, 0.0f })
void ImportTinyLLMTokenizer()
void GatherScriptFiles(const std::string &dir, std::vector< std::string > &outFiles)
void CancelBuild()
std::vector< Action * > mActionHistory
Definition ActionManager.h:408
void RequestAddonRecovery(const char *reason)
void BuildData(Platform platform, bool embedded)
void GenerateEmbeddedScriptFiles(std::vector< std::string > files, const char *headerPath, const char *sourcePath)
static void Destroy()
void DrawImportAnimationsModal()
AssetRef mRetargetSrcAvatar
Definition ActionManager.h:450
void DeleteAsset(AssetStub *stub)
void EXE_SetWorldScale(Node3D *node, glm::vec3 scale)
std::vector< Node * > EXE_SpawnNodes(const std::vector< Node * > &nodes)
void RequestEditorRestartForAddonRecovery(const char *reason)
void DeleteSelectedNodes()
void BuildCompileThreadFunc()
void RunScript()
void EXE_EditProperty(void *owner, PropertyOwnerType ownerType, const std::string &name, uint32_t index, Datum newValue)
Node * SpawnNode(TypeId nodeType, glm::vec3 position)
std::vector< Action * > mActionFuture
Definition ActionManager.h:409
std::vector< uint8_t > mExtractSkelAnimSelections
Definition ActionManager.h:428
void EXE_ParentSelectedWith(const std::vector< Node * > &nodes, TypeId parentType, ArrayOrientation arrayOrientation=ArrayOrientation::Vertical)
Create a new parent node of the specified type and reparent all selected nodes under it.
int mGroupDepth
Definition ActionManager.h:415
Definition ActionManager.h:1093
ActionPaintTiles(TileMap2D *tileMapNode, const std::vector< TilePaintChange > &changes)
std::vector< TilePaintChange > mChanges
Definition ActionManager.h:1100
DECLARE_ACTION_INTERFACE(PaintTiles)
Action to create a new parent node and reparent selected nodes under it.
Definition ActionManager.h:1017
ActionParentSelectedWith(const std::vector< Node * > &nodes, TypeId newParentType, ArrayOrientation arrayOrientation=ArrayOrientation::Vertical)
std::vector< int32_t > mPrevChildIndices
Definition ActionManager.h:1028
NodePtr mCreatedParent
Definition ActionManager.h:1030
TypeId mNewParentType
Definition ActionManager.h:1033
std::vector< NodePtr > mNodes
Definition ActionManager.h:1026
NodePtr mCreatedParentParent
Definition ActionManager.h:1031
std::vector< NodePtr > mPrevParents
Definition ActionManager.h:1027
DECLARE_ACTION_INTERFACE(ParentSelectedWith)
std::vector< int32_t > mPrevBoneIndices
Definition ActionManager.h:1029
Action to replace a node with a new node of a different type. The new node keeps the old node's slot ...
Definition ActionManager.h:1045
TypeId mNewType
Definition ActionManager.h:1056
NodePtr mParent
Definition ActionManager.h:1053
ActionReplaceNodeType(Node *oldNode, TypeId newType)
DECLARE_ACTION_INTERFACE(ReplaceNodeType)
NodePtr mOldNode
Definition ActionManager.h:1051
std::vector< NodePtr > mMovedChildren
Definition ActionManager.h:1055
NodePtr mNewNode
Definition ActionManager.h:1052
Action to replace selected nodes' mesh or material with an asset, or replace with scene instances.
Definition ActionManager.h:928
DECLARE_ACTION_INTERFACE(ReplaceWithAsset)
std::vector< Mesh3D * > mMatNodes
Definition ActionManager.h:951
std::vector< MaterialRef > mPrevMaterials
Definition ActionManager.h:952
std::vector< SceneReplaceEntry > mSceneEntries
Definition ActionManager.h:962
ReplaceMode
Definition ActionManager.h:936
AssetRef mAsset
Definition ActionManager.h:943
std::vector< StaticMesh3D * > mMeshNodes
Definition ActionManager.h:947
ActionReplaceWithAsset(Asset *asset, const std::vector< Node * > &nodes)
std::vector< StaticMeshRef > mPrevMeshes
Definition ActionManager.h:948
Action to merge selected StaticMesh3D nodes into InstancedMesh3D nodes grouped by mesh.
Definition ActionManager.h:969
std::vector< GroupEntry > mGroups
Definition ActionManager.h:986
ActionReplaceWithInstancedMesh(const std::vector< Node * > &nodes, bool merge)
DECLARE_ACTION_INTERFACE(ReplaceWithInstancedMesh)
Action to split selected InstancedMesh3D nodes into individual StaticMesh3D nodes.
Definition ActionManager.h:994
DECLARE_ACTION_INTERFACE(ReplaceWithStaticMesh)
std::vector< SplitEntry > mEntries
Definition ActionManager.h:1009
ActionReplaceWithStaticMesh(const std::vector< Node * > &nodes)
Definition ActionManager.h:879
SceneRef mScene
Definition ActionManager.h:887
DECLARE_ACTION_INTERFACE(ResetScene)
ActionResetScene(Node *node)
std::vector< Property > mPrevProperties
Definition ActionManager.h:888
Definition ActionManager.h:899
DECLARE_ACTION_INTERFACE(SetInstanceColors)
std::vector< ActionSetInstanceColorsData > mPrevData
Definition ActionManager.h:907
std::vector< ActionSetInstanceColorsData > mData
Definition ActionManager.h:906
ActionSetInstanceColors(const std::vector< ActionSetInstanceColorsData > &data)
Definition ActionManager.h:911
std::vector< MeshInstanceData > mPrevData
Definition ActionManager.h:921
DECLARE_ACTION_INTERFACE(SetInstanceData)
std::vector< MeshInstanceData > mData
Definition ActionManager.h:920
ActionSetInstanceData(InstancedMesh3D *instMesh, int32_t startIndex, const std::vector< MeshInstanceData > &data)
Definition ActionManager.h:821
Definition ActionManager.h:1079
ActionSetTerrainHeights(Terrain3D *terrain, const std::vector< TerrainHeightChange > &changes)
DECLARE_ACTION_INTERFACE(SetTerrainHeights)
std::vector< TerrainHeightChange > mChanges
Definition ActionManager.h:1086
Definition ActionManager.h:1065
std::vector< VoxelChange > mChanges
Definition ActionManager.h:1072
DECLARE_ACTION_INTERFACE(SetVoxels)
ActionSetVoxels(Voxel3D *voxel, const std::vector< VoxelChange > &changes)
Definition ActionManager.h:844
Definition ActionManager.h:833
Definition ActionManager.h:855
Definition ActionManager.h:764
std::vector< NodePtr > mParents
Definition ActionManager.h:786
std::vector< TypeId > mSrcTypes
Definition ActionManager.h:777
std::vector< SceneRef > mSrcScenes
Definition ActionManager.h:779
std::vector< NodePtr > mNodes
Definition ActionManager.h:783
std::vector< NodePtr > mSrcNodes
Definition ActionManager.h:780
std::vector< const char * > mSrcTypeNames
Definition ActionManager.h:778
Definition ActionManager.h:866
ActionUnlinkScene(Node *node)
DECLARE_ACTION_INTERFACE(UnlinkScene)
SceneRef mScene
Definition ActionManager.h:874
Definition ActionManager.h:173
virtual void Execute()
virtual ~Action()
Definition ActionManager.h:175
virtual const char * GetName()=0
virtual void Reverse()
Definition AssetDir.h:13
Definition AssetRef.h:18
Definition Asset.h:125
Definition Datum.h:169
Definition InstancedMesh3d.h:17
Definition Material.h:48
Definition Mesh3d.h:13
Definition Node3d.h:14
Definition Node.h:67
Definition ActionManager.h:192
PluginAction(const char *name, DoFn doFn, UndoFn undoFn, FreeFn freeFn, void *userData)
void(*)(void *userData) UndoFn
Definition ActionManager.h:195
void Execute() override
~PluginAction() override
void(*)(void *userData) DoFn
Definition ActionManager.h:194
void SetPluginTag(const std::string &tag)
Definition ActionManager.h:206
const char * GetName() override
const std::string & GetPluginTag() const
Definition ActionManager.h:207
void Reverse() override
void(*)(void *userData) FreeFn
Definition ActionManager.h:196
Definition Property.h:14
Definition Scene.h:42
Definition StaticMesh3d.h:12
Definition StaticMesh.h:18
Definition Terrain3d.h:13
Definition TileMap2d.h:23
Definition Timeline.h:10
Definition Voxel3d.h:61
Definition Widget.h:57
Definition SmartPointer.h:631
Definition ActionManager.h:390
std::string mLookupKey
Definition ActionManager.h:392
bool mEngineAsset
Definition ActionManager.h:393
std::string mAbsolutePath
Definition ActionManager.h:391
AssetStub * mSourceMeshStub
Definition ActionManager.h:571
AssetDir * mTargetDir
Definition ActionManager.h:572
std::string mPrefix
Definition ActionManager.h:574
bool mUniqueNames
Definition ActionManager.h:576
std::vector< uint32_t > mAnimationIndices
Definition ActionManager.h:573
bool mRemoveEmbeddedAfterExtract
Definition ActionManager.h:577
bool mOverwriteExisting
Definition ActionManager.h:575
Definition ActionManager.h:586
std::string mSourcePath
Definition ActionManager.h:587
bool mOverwriteExisting
Definition ActionManager.h:591
AssetDir * mTargetDir
Definition ActionManager.h:588
bool mUniqueNames
Definition ActionManager.h:592
std::vector< uint32_t > mAnimationIndices
Definition ActionManager.h:589
std::string mPrefix
Definition ActionManager.h:590
Definition ActionManager.h:602
AssetStub * mTargetAvatarStub
Definition ActionManager.h:605
bool mUniqueNames
Definition ActionManager.h:610
std::string mOutputName
Definition ActionManager.h:607
AssetStub * mSourceClipStub
Definition ActionManager.h:603
bool mOverwriteExisting
Definition ActionManager.h:609
AssetDir * mTargetDir
Definition ActionManager.h:606
int32_t mMode
Definition ActionManager.h:608
AssetStub * mSourceAvatarStub
Definition ActionManager.h:604
Definition ActionManager.h:956
NodePtr mSpawnedNode
Definition ActionManager.h:960
NodePtr mOriginal
Definition ActionManager.h:957
NodePtr mParent
Definition ActionManager.h:958
Definition ActionManager.h:977
NodePtr mInstancedNode
Definition ActionManager.h:981
std::vector< int32_t > mOriginalChildIndices
Definition ActionManager.h:980
std::vector< NodePtr > mOriginalNodes
Definition ActionManager.h:978
NodePtr mInstancedParent
Definition ActionManager.h:982
std::vector< NodePtr > mOriginalParents
Definition ActionManager.h:979
Definition ActionManager.h:1002
NodePtr mOriginalParent
Definition ActionManager.h:1004
std::vector< NodePtr > mCreatedNodes
Definition ActionManager.h:1006
NodePtr mOriginalNode
Definition ActionManager.h:1003
Definition ActionManager.h:892
std::vector< uint32_t > mColors
Definition ActionManager.h:894
Definition Asset.h:94
State for async local build operations.
Definition ActionManager.h:41
std::string mProjectName
Definition ActionManager.h:85
std::string mExtension
Definition ActionManager.h:87
bool mStaticContent
Obfuscate shipped .oct / .lua / AssetRegistry.txt in the package.
Definition ActionManager.h:77
std::string mStripCommand
Definition ActionManager.h:96
std::unordered_map< std::string, std::string > mTargetOptions
Definition ActionManager.h:68
std::atomic< int > mExitCode
Definition ActionManager.h:47
bool mUseSteam
Definition ActionManager.h:91
std::string mAndroidResolvedIconSource
Definition ActionManager.h:115
std::string mCompileCommand
Definition ActionManager.h:92
bool mForceRebuild
Definition ActionManager.h:105
Platform mPlatform
Definition ActionManager.h:54
bool mStandalone
Definition ActionManager.h:89
bool mForceCompile
Definition ActionManager.h:110
std::string mPackagedDir
Definition ActionManager.h:82
void Reset()
Definition ActionManager.h:117
int64_t mExeMTimeBeforeBuild
Definition ActionManager.h:88
std::atomic< bool > mCancelRequested
Definition ActionManager.h:44
std::string mBuildProjDir
Definition ActionManager.h:83
std::string mExeSrc
Definition ActionManager.h:86
bool mNeedCompile
Definition ActionManager.h:90
bool mRunOnDevice
Definition ActionManager.h:104
bool mContentPak
Pack shipped content into Content.pak. Requires mStaticContent.
Definition ActionManager.h:80
bool mOpenDirectoryOnFinish
Definition ActionManager.h:106
std::string mInjectedVcxprojPath
Definition ActionManager.h:100
std::string mProjectDir
Definition ActionManager.h:84
bool mOutputDirty
Definition ActionManager.h:51
std::string mPrebuiltExePath
Definition ActionManager.h:93
std::string mShaderCompileCommand
Definition ActionManager.h:95
std::string mOutput
Definition ActionManager.h:50
std::mutex mOutputMutex
Definition ActionManager.h:49
std::atomic< bool > mRunning
Definition ActionManager.h:43
std::string mTmpMakefile
Definition ActionManager.h:94
bool mRunAfterBuild
Definition ActionManager.h:103
std::atomic< bool > mComplete
Definition ActionManager.h:45
bool mEmbedded
Definition ActionManager.h:69
std::string mTargetId
Definition ActionManager.h:60
std::atomic< bool > mSuccess
Definition ActionManager.h:46
std::thread mBuildThread
Definition ActionManager.h:42
Definition InstancedMesh3d.h:6
Definition ActionManager.h:31
glm::vec2 mOffset
Definition ActionManager.h:32
glm::vec2 mSize
Definition ActionManager.h:33
float mRotation
Definition ActionManager.h:34