Initial commit

Torque/SDK/engine/editor/worldEditor.h

@@ -0,0 +1,362 @@
+//-----------------------------------------------------------------------------
+// Torque Game Engine
+// Copyright (C) GarageGames.com, Inc.
+//-----------------------------------------------------------------------------
+
+#ifndef _WORLDEDITOR_H_
+#define _WORLDEDITOR_H_
+
+#ifndef _EDITTSCTRL_H_
+#include "editor/editTSCtrl.h"
+#endif
+#ifndef _CONSOLETYPES_H_
+#include "console/consoleTypes.h"
+#endif
+#ifndef _GTEXMANAGER_H_
+#include "dgl/gTexManager.h"
+#endif
+
+class Path;
+class SceneObject;
+class WorldEditor : public EditTSCtrl
+{
+   typedef EditTSCtrl Parent;
+
+	public:
+
+	void ignoreObjClass(U32 argc, const char** argv);
+	void clearIgnoreList();
+
+	void undo();
+	void redo();
+	
+	void clearSelection();
+	void selectObject(const char* obj);
+	void unselectObject(const char* obj);
+	
+	S32 getSelectionSize();
+	S32 getSelectObject(S32 index);	
+	const char* getSelectionCentroid();
+	
+	void dropCurrentSelection();
+	void deleteCurrentSelection();
+	void copyCurrentSelection();	
+	bool canPasteSelection();
+
+	const char* getMode();
+   bool setMode(const char *mode);
+
+	void addUndoState();
+	void redirectConsole(S32 objID);
+	
+   public:
+
+      struct CollisionInfo
+      {
+         SceneObject *     obj;
+         Point3F           pos;
+         VectorF           normal;
+      };
+
+      class Selection : public SimObject
+      {
+         typedef SimObject    Parent;
+
+         private:
+
+            Point3F        mCentroid;
+            Point3F        mBoxCentroid;
+            bool           mCentroidValid;
+            SimObjectList  mObjectList;
+            bool           mAutoSelect;
+
+            void           updateCentroid();
+
+         public:
+
+            Selection();
+            ~Selection();
+
+            //
+            U32 size()  { return(mObjectList.size()); }
+            SceneObject * operator[] (S32 index) { return((SceneObject*)mObjectList[index]); }
+
+            bool objInSet(SceneObject *);
+
+            bool addObject(SceneObject *);
+            bool removeObject(SceneObject *);
+            void clear();
+
+            void onDeleteNotify(SimObject *);
+
+            const Point3F & getCentroid();
+            const Point3F & getBoxCentroid();
+
+            void enableCollision();
+            void disableCollision();
+
+            //
+            void autoSelect(bool b) { mAutoSelect = b; }
+            void invalidateCentroid() { mCentroidValid = false; }
+
+            //
+            void offset(const Point3F &);
+            void orient(const MatrixF &, const Point3F &);
+            void rotate(const EulerF &, const Point3F &);
+            void scale(const VectorF &);
+      };
+
+      //
+      static SceneObject * getClientObj(SceneObject *);
+      static void setClientObjInfo(SceneObject *, const MatrixF &, const VectorF &);
+      static void updateClientTransforms(Selection &);
+
+   // VERY basic undo functionality - only concerned with transform/scale/...
+   private:
+
+      struct SelectionState
+      {
+         struct Entry
+         {
+            MatrixF     mMatrix;
+            VectorF     mScale;
+
+            // validation
+            U32         mObjId;
+            U32         mObjNumber;
+         };
+
+         Vector<Entry>  mEntries;
+
+         SelectionState() 
+         {
+            VECTOR_SET_ASSOCIATION(mEntries);
+         }
+      };
+
+      SelectionState * createUndo(Selection &);
+      void addUndo(Vector<SelectionState *> & list, SelectionState * sel);
+      bool processUndo(Vector<SelectionState *> & src, Vector<SelectionState *> & dest);
+      void clearUndo(Vector<SelectionState *> & list);
+
+      Vector<SelectionState*>       mUndoList;
+      Vector<SelectionState*>       mRedoList;
+
+      // someday get around to creating a growing memory stream...
+      Vector<U8[2048]>              mStreamBufs;
+
+	public:
+
+      bool deleteSelection(Selection & sel);
+		bool copySelection(Selection & sel);
+		bool pasteSelection();
+		void dropSelection(Selection & sel);
+
+      // work off of mSelected
+      void hideSelection(bool hide);
+      void lockSelection(bool lock);
+
+   private:
+      SceneObject * getControlObject();
+      bool collide(const Gui3DMouseEvent & event, CollisionInfo & info);
+
+      // render methods
+      void renderObjectBox(SceneObject * obj, const ColorI & col);
+      void renderObjectFace(SceneObject * obj, const VectorF & normal, const ColorI & col);
+      void renderSelectionWorldBox(Selection & sel);
+
+      void renderPlane(const Point3F & origin);
+      void renderMousePopupInfo();
+      void renderScreenObj(SceneObject * obj, Point2I sPos);
+
+      void renderPaths(SimObject *obj);
+      void renderSplinePath(Path *path);
+
+      // axis gizmo methods...
+      void calcAxisInfo();
+      bool collideAxisGizmo(const Gui3DMouseEvent & event);
+      void renderAxisGizmo();
+      void renderAxisGizmoText();
+
+      // axis gizmo state...
+      Point3F     mAxisGizmoCenter;
+      VectorF     mAxisGizmoVector[3];
+      F32         mAxisGizmoProjLen;
+      S32         mAxisGizmoSelAxis;
+      bool        mUsingAxisGizmo;
+
+      //
+      Point3F snapPoint(const Point3F & pnt);
+      bool                       mIsDirty;
+
+      //
+      bool                       mMouseDown;
+      Selection             mSelected;
+      bool                       mUseVertMove;
+
+      Selection             mDragSelected;
+      bool                       mDragSelect;
+      RectI                    mDragRect;
+      Point2I                 mDragStart;
+
+      // modes for when dragging a selection
+      enum {
+         Move = 0,
+         Rotate,
+         Scale
+      };
+
+      //
+      U32                        mCurrentMode;
+      U32                        mDefaultMode;
+
+      S32                        mRedirectID;
+
+      CollisionInfo              mHitInfo;
+      Point3F                    mHitOffset;
+      SimObjectPtr<SceneObject>  mHitObject;
+      Point2I                    mHitMousePos;
+      Point3F                    mHitCentroid;
+      EulerF                     mHitRotation;
+      bool                       mMouseDragged;
+      Gui3DMouseEvent            mLastMouseEvent;
+      F32                        mLastRotation;
+
+      //
+      class ClassInfo
+      {
+         public:
+            ~ClassInfo();
+
+            struct Entry
+            {
+               StringTableEntry  mName;
+               bool              mIgnoreCollision;
+               TextureHandle     mDefaultHandle;
+               TextureHandle     mSelectHandle;
+               TextureHandle     mLockedHandle;
+            };
+
+            Vector<Entry*>       mEntries;
+      };
+
+
+      ClassInfo            mClassInfo;
+      ClassInfo::Entry     mDefaultClassEntry;
+
+      bool objClassIgnored(const SceneObject * obj);
+      ClassInfo::Entry * getClassEntry(StringTableEntry name);
+      ClassInfo::Entry * getClassEntry(const SceneObject * obj);
+      bool addClassEntry(ClassInfo::Entry * entry);
+
+   // persist field data
+   public:
+
+      enum {
+         DropAtOrigin = 0,
+         DropAtCamera,
+         DropAtCameraWithRot,
+         DropBelowCamera,
+         DropAtScreenCenter,
+         DropAtCentroid,
+         DropToGround
+      };
+
+      bool              mPlanarMovement;
+      S32               mUndoLimit;
+      S32               mDropType;
+      F32               mProjectDistance;
+      bool              mBoundingBoxCollision;
+      bool              mRenderPlane;
+      bool              mRenderPlaneHashes;
+      ColorI            mGridColor;
+      F32               mPlaneDim;
+      Point3F           mGridSize;
+      bool              mRenderPopupBackground;
+      ColorI            mPopupBackgroundColor;
+      ColorI            mPopupTextColor;
+      StringTableEntry  mSelectHandle;
+      StringTableEntry  mDefaultHandle;
+      StringTableEntry  mLockedHandle;
+      ColorI            mObjectTextColor;
+      bool               mObjectsUseBoxCenter;
+      S32               mAxisGizmoMaxScreenLen;
+      bool              mAxisGizmoActive;
+      F32               mMouseMoveScale;
+      F32               mMouseRotateScale;
+      F32               mMouseScaleScale;
+      F32               mMinScaleFactor;
+      F32               mMaxScaleFactor;
+      ColorI            mObjSelectColor;
+      ColorI            mObjMouseOverSelectColor;
+      ColorI            mObjMouseOverColor;
+      bool              mShowMousePopupInfo;
+      ColorI            mDragRectColor;
+      bool              mRenderObjText;
+      bool              mRenderObjHandle;
+      StringTableEntry  mObjTextFormat;
+      ColorI            mFaceSelectColor;
+      bool              mRenderSelectionBox;
+      ColorI            mSelectionBoxColor;
+      bool              mSelectionLocked;
+      bool              mSnapToGrid;
+      bool              mSnapRotations;
+      F32               mRotationSnap;
+      bool              mToggleIgnoreList;
+      bool              mRenderNav;
+      bool              mNoMouseDrag;
+
+   private:
+      // cursor constants
+      enum {
+         HandCursor = 0,
+         RotateCursor,
+         ScaleCursor,
+         MoveCursor,
+         ArrowCursor,
+         DefaultCursor,
+
+         //
+         NumCursors
+      };
+
+      GuiCursor *                mCursors[NumCursors];
+      GuiCursor *                mCurrentCursor;
+      bool grabCursors();
+      void setCursor(U32 cursor);
+      void get3DCursor(GuiCursor *&cursor, bool &visible, const Gui3DMouseEvent &event);
+
+   public:
+
+      WorldEditor();
+      ~WorldEditor();
+
+      // SimObject
+      bool onAdd();
+      void onEditorEnable();
+      void setDirty() { mIsDirty = true; }
+
+      // EditTSCtrl
+      void on3DMouseMove(const Gui3DMouseEvent & event);
+      void on3DMouseDown(const Gui3DMouseEvent & event);
+      void on3DMouseUp(const Gui3DMouseEvent & event);
+      void on3DMouseDragged(const Gui3DMouseEvent & event);
+      void on3DMouseEnter(const Gui3DMouseEvent & event);
+      void on3DMouseLeave(const Gui3DMouseEvent & event);
+      void on3DRightMouseDown(const Gui3DMouseEvent & event);
+      void on3DRightMouseUp(const Gui3DMouseEvent & event);
+
+      void updateGuiInfo();
+
+      //
+      void renderScene(const RectI & updateRect);
+
+      static void initPersistFields();
+
+      DECLARE_CONOBJECT(WorldEditor);
+};
+
+#endif
+
+
+