Merge branch 'development' into NetworkedFields

Engine/lib/collada/src/dae/daeRawResolver.cpp

@@ -57,8 +57,11 @@ daeElement* daeRawResolver::resolveElement(const daeURI& uri) {
 	daeElement *accessor;
 	
 	accessor = uri.getContainer();
-	if ( accessor == NULL )
-		return NULL;
+     if (accessor == NULL)
+     {
+          fclose(rawFile);
+          return NULL;
+     }
 	src = accessor->getParentElement()->getParentElement();
 	daeElementRefArray children;
 	accessor->getChildren( children );

Engine/lib/sdl/CMakeLists.txt

@@ -1166,11 +1166,6 @@ elseif(WINDOWS)
     if(HAVE_DINPUT_H)
       set(SDL_JOYSTICK_DINPUT 1)
       list(APPEND EXTRA_LIBS dinput8)
-      if(CMAKE_COMPILER_IS_MINGW)
-        list(APPEND EXTRA_LIBS dxerr8)
-      elseif (NOT USE_WINSDK_DIRECTX)
-        list(APPEND EXTRA_LIBS dxerr)
-      endif()
     endif()
     if(HAVE_XINPUT_H)
       set(SDL_JOYSTICK_XINPUT 1)

Engine/lib/sdl/configure.in

@@ -3144,7 +3144,7 @@ AC_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[defau
                 fi
                 if test x$have_dinput = xyes; then
                     AC_DEFINE(SDL_JOYSTICK_DINPUT, 1, [ ])
-                    EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldinput8 -ldxguid -ldxerr8"
+                    EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldinput8 -ldxguid"
                 fi
             else
                 AC_DEFINE(SDL_JOYSTICK_WINMM, 1, [ ])

Engine/source/T3D/assets/ComponentAsset.cpp

@@ -74,7 +74,7 @@ ConsoleSetType(TypeComponentAssetPtr)
       if (pAssetPtr == NULL)
       {
          // No, so fail.
-         //Con::warnf("(TypeTextureAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         //Con::warnf("(TypeComponentAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
          return;
       }
 
@@ -85,24 +85,20 @@ ConsoleSetType(TypeComponentAssetPtr)
    }
 
    // Warn.
-   Con::warnf("(TypeTextureAssetPtr) - Cannot set multiple args to a single asset.");
+   Con::warnf("(TypeComponentAssetPtr) - Cannot set multiple args to a single asset.");
 }
 
 //-----------------------------------------------------------------------------
 
-ComponentAsset::ComponentAsset() :
-   mpOwningAssetManager(NULL),
-   mAssetInitialized(false),
-   mAcquireReferenceCount(0)
+ComponentAsset::ComponentAsset()
 {
-   // Generate an asset definition.
-   mpAssetDefinition = new AssetDefinition();
-
-   mComponentName = StringTable->lookup("");
-   mComponentClass = StringTable->lookup("");
-   mFriendlyName = StringTable->lookup("");
-   mComponentType = StringTable->lookup("");
-   mDescription = StringTable->lookup("");
+   mComponentName = StringTable->EmptyString();
+   mComponentClass = StringTable->EmptyString();
+   mFriendlyName = StringTable->EmptyString();
+   mComponentType = StringTable->EmptyString();
+   mDescription = StringTable->EmptyString();
+
+   mScriptFile = StringTable->EmptyString();
 }
 
 //-----------------------------------------------------------------------------
@@ -127,6 +123,8 @@ void ComponentAsset::initPersistFields()
    addField("friendlyName", TypeString, Offset(mFriendlyName, ComponentAsset), "The human-readble name for the component.");
    addField("componentType", TypeString, Offset(mComponentType, ComponentAsset), "The category of the component for organizing in the editor.");
    addField("description", TypeString, Offset(mDescription, ComponentAsset), "Simple description of the component.");
+
+   addField("scriptFile", TypeString, Offset(mScriptFile, ComponentAsset), "A script file with additional scripted functionality for this component.");
 }
 
 //------------------------------------------------------------------------------
@@ -135,4 +133,16 @@ void ComponentAsset::copyTo(SimObject* object)
 {
    // Call to parent.
    Parent::copyTo(object);
+}
+
+void ComponentAsset::initializeAsset()
+{
+   if(Platform::isFile(mScriptFile))
+      Con::executeFile(mScriptFile, false, false);
+}
+
+void ComponentAsset::onAssetRefresh()
+{
+   if (Platform::isFile(mScriptFile))
+      Con::executeFile(mScriptFile, false, false);
 }

Engine/source/T3D/assets/ComponentAsset.h

@@ -44,17 +44,14 @@ class ComponentAsset : public AssetBase
 {
    typedef AssetBase Parent;
 
-   AssetManager*           mpOwningAssetManager;
-   bool                    mAssetInitialized;
-   AssetDefinition*        mpAssetDefinition;
-   U32                     mAcquireReferenceCount;
-
    StringTableEntry mComponentName;
    StringTableEntry mComponentClass;
    StringTableEntry mFriendlyName;
    StringTableEntry mComponentType;
    StringTableEntry mDescription;
 
+   StringTableEntry mScriptFile;
+
 public:
    ComponentAsset();
    virtual ~ComponentAsset();
@@ -69,12 +66,20 @@ public:
    StringTableEntry getComponentName() { return mComponentName; }
    StringTableEntry getComponentClass() { return mComponentClass; }
    StringTableEntry getFriendlyName() { return mFriendlyName; }
-   StringTableEntry getFriendlyType() { return mComponentType; }
+   StringTableEntry getComponentType() { return mComponentType; }
    StringTableEntry getDescription() { return mDescription; }
 
+   void setComponentName(StringTableEntry name) { mComponentName = name; }
+   void setComponentClass(StringTableEntry name) { mComponentClass = name; }
+   void setFriendlyName(StringTableEntry name) { mFriendlyName = name; }
+   void setComponentType(StringTableEntry typeName) { mComponentType = typeName; }
+   void setDescription(StringTableEntry description) { mDescription = description; }
+
+   AssetDefinition* getAssetDefinition() { return mpAssetDefinition; }
+
 protected:
-   virtual void            initializeAsset(void) {}
-   virtual void            onAssetRefresh(void) {}
+   virtual void            initializeAsset(void);
+   virtual void            onAssetRefresh(void);
 };
 
 DefineConsoleType(TypeComponentAssetPtr, ComponentAsset)

Engine/source/T3D/assets/ExampleAsset.cpp

@@ -74,7 +74,7 @@ ConsoleSetType(TypeExampleAssetPtr)
       if (pAssetPtr == NULL)
       {
          // No, so fail.
-         //Con::warnf("(TypeTextureAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         //Con::warnf("(TypeExampleAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
          return;
       }
 
@@ -85,18 +85,13 @@ ConsoleSetType(TypeExampleAssetPtr)
    }
 
    // Warn.
-   Con::warnf("(TypeTextureAssetPtr) - Cannot set multiple args to a single asset.");
+   Con::warnf("(TypeExampleAssetPtr) - Cannot set multiple args to a single asset.");
 }
 
 //-----------------------------------------------------------------------------
 
-ExampleAsset::ExampleAsset() :
-mpOwningAssetManager(NULL),
-mAssetInitialized(false),
-mAcquireReferenceCount(0)
+ExampleAsset::ExampleAsset()
 {
-   // Generate an asset definition.
-   mpAssetDefinition = new AssetDefinition();
 }
 
 //-----------------------------------------------------------------------------

Engine/source/T3D/assets/ExampleAsset.h

@@ -43,11 +43,6 @@ class ExampleAsset : public AssetBase
 {
    typedef AssetBase Parent;
 
-   AssetManager*           mpOwningAssetManager;
-   bool                    mAssetInitialized;
-   AssetDefinition*        mpAssetDefinition;
-   U32                     mAcquireReferenceCount;
-
 public:
    ExampleAsset();
    virtual ~ExampleAsset();

Engine/source/T3D/assets/GUIAsset.cpp

@@ -0,0 +1,222 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef GUI_ASSET_H
+#include "GUIAsset.h"
+#endif
+
+#ifndef _ASSET_MANAGER_H_
+#include "assets/assetManager.h"
+#endif
+
+#ifndef _CONSOLETYPES_H_
+#include "console/consoleTypes.h"
+#endif
+
+#ifndef _TAML_
+#include "persistence/taml/taml.h"
+#endif
+
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif
+
+// Debug Profiling.
+#include "platform/profiler.h"
+
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(GUIAsset);
+
+ConsoleType(GUIAssetPtr, TypeGUIAssetPtr, GUIAsset, ASSET_ID_FIELD_PREFIX)
+
+//-----------------------------------------------------------------------------
+
+ConsoleGetType(TypeGUIAssetPtr)
+{
+   // Fetch asset Id.
+   return (*((AssetPtr<GUIAsset>*)dptr)).getAssetId();
+}
+
+//-----------------------------------------------------------------------------
+
+ConsoleSetType(TypeGUIAssetPtr)
+{
+   // Was a single argument specified?
+   if (argc == 1)
+   {
+      // Yes, so fetch field value.
+      const char* pFieldValue = argv[0];
+
+      // Fetch asset pointer.
+      AssetPtr<GUIAsset>* pAssetPtr = dynamic_cast<AssetPtr<GUIAsset>*>((AssetPtrBase*)(dptr));
+
+      // Is the asset pointer the correct type?
+      if (pAssetPtr == NULL)
+      {
+         // No, so fail.
+         //Con::warnf("(TypeGUIAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         return;
+      }
+
+      // Set asset.
+      pAssetPtr->setAssetId(pFieldValue);
+
+      return;
+   }
+
+   // Warn.
+   Con::warnf("(TypeGUIAssetPtr) - Cannot set multiple args to a single asset.");
+}
+
+//-----------------------------------------------------------------------------
+
+GUIAsset::GUIAsset()
+{
+   mScriptFilePath = StringTable->EmptyString();
+   mGUIFilePath = StringTable->EmptyString();
+}
+
+//-----------------------------------------------------------------------------
+
+GUIAsset::~GUIAsset()
+{
+   // If the asset manager does not own the asset then we own the
+   // asset definition so delete it.
+   if (!getOwned())
+      delete mpAssetDefinition;
+}
+
+//-----------------------------------------------------------------------------
+
+void GUIAsset::initPersistFields()
+{
+   // Call parent.
+   Parent::initPersistFields();
+
+   addField("scriptFilePath", TypeString, Offset(mScriptFilePath, GUIAsset), "Path to the script file for the gui");
+   addField("GUIFilePath", TypeString, Offset(mGUIFilePath, GUIAsset), "Path to the gui file");
+}
+
+//------------------------------------------------------------------------------
+
+void GUIAsset::copyTo(SimObject* object)
+{
+   // Call to parent.
+   Parent::copyTo(object);
+}
+
+void GUIAsset::initializeAsset()
+{
+   if (Platform::isFile(mGUIFilePath))
+      Con::executeFile(mGUIFilePath, false, false);
+
+   if (Platform::isFile(mScriptFilePath))
+      Con::executeFile(mScriptFilePath, false, false);
+}
+
+void GUIAsset::onAssetRefresh()
+{
+   if (Platform::isFile(mGUIFilePath))
+      Con::executeFile(mGUIFilePath, false, false);
+
+   if (Platform::isFile(mScriptFilePath))
+      Con::executeFile(mScriptFilePath, false, false);
+}
+
+//-----------------------------------------------------------------------------
+// GuiInspectorTypeAssetId
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(GuiInspectorTypeGUIAssetPtr);
+
+ConsoleDocClass(GuiInspectorTypeGUIAssetPtr,
+   "@brief Inspector field type for GUI Asset Objects\n\n"
+   "Editor use only.\n\n"
+   "@internal"
+);
+
+void GuiInspectorTypeGUIAssetPtr::consoleInit()
+{
+   Parent::consoleInit();
+
+   ConsoleBaseType::getType(TypeGUIAssetPtr)->setInspectorFieldType("GuiInspectorTypeGUIAssetPtr");
+}
+
+GuiControl* GuiInspectorTypeGUIAssetPtr::constructEditControl()
+{
+   // Create base filename edit controls
+   GuiControl *retCtrl = Parent::constructEditControl();
+   if (retCtrl == NULL)
+      return retCtrl;
+
+   // Change filespec
+   char szBuffer[512];
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"GUIAsset\", \"AssetBrowser.changeAsset\", %d, %s);",
+      mInspector->getComponentGroupTargetId(), mCaption);
+   mBrowseButton->setField("Command", szBuffer);
+
+   // Create "Open in ShapeEditor" button
+   mSMEdButton = new GuiBitmapButtonCtrl();
+
+   dSprintf(szBuffer, sizeof(szBuffer), "echo(\"Game Object Editor not implemented yet!\");", retCtrl->getId());
+   mSMEdButton->setField("Command", szBuffer);
+
+   char bitmapName[512] = "tools/worldEditor/images/toolbar/shape-editor";
+   mSMEdButton->setBitmap(bitmapName);
+
+   mSMEdButton->setDataField(StringTable->insert("Profile"), NULL, "GuiButtonProfile");
+   mSMEdButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
+   mSMEdButton->setDataField(StringTable->insert("hovertime"), NULL, "1000");
+   mSMEdButton->setDataField(StringTable->insert("tooltip"), NULL, "Open this file in the State Machine Editor");
+
+   mSMEdButton->registerObject();
+   addObject(mSMEdButton);
+
+   return retCtrl;
+}
+
+bool GuiInspectorTypeGUIAssetPtr::updateRects()
+{
+   S32 dividerPos, dividerMargin;
+   mInspector->getDivider(dividerPos, dividerMargin);
+   Point2I fieldExtent = getExtent();
+   Point2I fieldPos = getPosition();
+
+   mCaptionRect.set(0, 0, fieldExtent.x - dividerPos - dividerMargin, fieldExtent.y);
+   mEditCtrlRect.set(fieldExtent.x - dividerPos + dividerMargin, 1, dividerPos - dividerMargin - 34, fieldExtent.y);
+
+   bool resized = mEdit->resize(mEditCtrlRect.point, mEditCtrlRect.extent);
+   if (mBrowseButton != NULL)
+   {
+      mBrowseRect.set(fieldExtent.x - 32, 2, 14, fieldExtent.y - 4);
+      resized |= mBrowseButton->resize(mBrowseRect.point, mBrowseRect.extent);
+   }
+
+   if (mSMEdButton != NULL)
+   {
+      RectI shapeEdRect(fieldExtent.x - 16, 2, 14, fieldExtent.y - 4);
+      resized |= mSMEdButton->resize(shapeEdRect.point, shapeEdRect.extent);
+   }
+
+   return resized;
+}

Engine/source/T3D/assets/GUIAsset.h

@@ -0,0 +1,89 @@
+#pragma once
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#ifndef GUI_ASSET_H
+#define GUI_ASSET_H
+
+#ifndef _ASSET_BASE_H_
+#include "assets/assetBase.h"
+#endif
+
+#ifndef _ASSET_DEFINITION_H_
+#include "assets/assetDefinition.h"
+#endif
+
+#ifndef _STRINGUNIT_H_
+#include "string/stringUnit.h"
+#endif
+
+#ifndef _ASSET_FIELD_TYPES_H_
+#include "assets/assetFieldTypes.h"
+#endif
+
+#include "gui/editor/guiInspectorTypes.h"
+
+//-----------------------------------------------------------------------------
+class GUIAsset : public AssetBase
+{
+   typedef AssetBase Parent;
+
+   StringTableEntry mScriptFilePath;
+   StringTableEntry mGUIFilePath;
+
+public:
+   GUIAsset();
+   virtual ~GUIAsset();
+
+   /// Engine.
+   static void initPersistFields();
+   virtual void copyTo(SimObject* object);
+
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(GUIAsset);
+
+protected:
+   virtual void            initializeAsset(void);
+   virtual void            onAssetRefresh(void);
+};
+
+DefineConsoleType(TypeGUIAssetPtr, GUIAsset)
+
+
+//-----------------------------------------------------------------------------
+// TypeAssetId GuiInspectorField Class
+//-----------------------------------------------------------------------------
+class GuiInspectorTypeGUIAssetPtr : public GuiInspectorTypeFileName
+{
+   typedef GuiInspectorTypeFileName Parent;
+public:
+
+   GuiBitmapButtonCtrl  *mSMEdButton;
+
+   DECLARE_CONOBJECT(GuiInspectorTypeGUIAssetPtr);
+   static void consoleInit();
+
+   virtual GuiControl* constructEditControl();
+   virtual bool updateRects();
+};
+
+#endif // _ASSET_BASE_H_
+

Engine/source/T3D/assets/GameObjectAsset.cpp

@@ -74,7 +74,7 @@ ConsoleSetType(TypeGameObjectAssetPtr)
       if (pAssetPtr == NULL)
       {
          // No, so fail.
-         //Con::warnf("(TypeTextureAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         //Con::warnf("(TypeGameObjectAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
          return;
       }
 
@@ -85,19 +85,13 @@ ConsoleSetType(TypeGameObjectAssetPtr)
    }
 
    // Warn.
-   Con::warnf("(TypeTextureAssetPtr) - Cannot set multiple args to a single asset.");
+   Con::warnf("(TypeGameObjectAssetPtr) - Cannot set multiple args to a single asset.");
 }
 
 //-----------------------------------------------------------------------------
 
-GameObjectAsset::GameObjectAsset() :
-   mpOwningAssetManager(NULL),
-   mAssetInitialized(false),
-   mAcquireReferenceCount(0)
+GameObjectAsset::GameObjectAsset()
 {
-   // Generate an asset definition.
-   mpAssetDefinition = new AssetDefinition();
-
    mGameObjectName = StringTable->lookup("");
    mScriptFilePath = StringTable->lookup("");
    mTAMLFilePath = StringTable->lookup("");
@@ -131,4 +125,94 @@ void GameObjectAsset::copyTo(SimObject* object)
 {
    // Call to parent.
    Parent::copyTo(object);
+}
+
+void GameObjectAsset::initializeAsset()
+{
+   if (Platform::isFile(mScriptFilePath))
+      Con::executeFile(mScriptFilePath, false, false);
+}
+
+void GameObjectAsset::onAssetRefresh()
+{
+   if (Platform::isFile(mScriptFilePath))
+      Con::executeFile(mScriptFilePath, false, false);
+}
+
+//-----------------------------------------------------------------------------
+// GuiInspectorTypeAssetId
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(GuiInspectorTypeGameObjectAssetPtr);
+
+ConsoleDocClass(GuiInspectorTypeGameObjectAssetPtr,
+   "@brief Inspector field type for Game Objects\n\n"
+   "Editor use only.\n\n"
+   "@internal"
+);
+
+void GuiInspectorTypeGameObjectAssetPtr::consoleInit()
+{
+   Parent::consoleInit();
+
+   ConsoleBaseType::getType(TypeGameObjectAssetPtr)->setInspectorFieldType("GuiInspectorTypeGameObjectAssetPtr");
+}
+
+GuiControl* GuiInspectorTypeGameObjectAssetPtr::constructEditControl()
+{
+   // Create base filename edit controls
+   GuiControl *retCtrl = Parent::constructEditControl();
+   if (retCtrl == NULL)
+      return retCtrl;
+
+   // Change filespec
+   char szBuffer[512];
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"GameObjectAsset\", \"AssetBrowser.changeAsset\", %d, %s);",
+      mInspector->getComponentGroupTargetId(), mCaption);
+   mBrowseButton->setField("Command", szBuffer);
+
+   // Create "Open in ShapeEditor" button
+   mSMEdButton = new GuiBitmapButtonCtrl();
+
+   dSprintf(szBuffer, sizeof(szBuffer), "echo(\"Game Object Editor not implemented yet!\");", retCtrl->getId());
+   mSMEdButton->setField("Command", szBuffer);
+
+   char bitmapName[512] = "tools/worldEditor/images/toolbar/shape-editor";
+   mSMEdButton->setBitmap(bitmapName);
+
+   mSMEdButton->setDataField(StringTable->insert("Profile"), NULL, "GuiButtonProfile");
+   mSMEdButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
+   mSMEdButton->setDataField(StringTable->insert("hovertime"), NULL, "1000");
+   mSMEdButton->setDataField(StringTable->insert("tooltip"), NULL, "Open this file in the State Machine Editor");
+
+   mSMEdButton->registerObject();
+   addObject(mSMEdButton);
+
+   return retCtrl;
+}
+
+bool GuiInspectorTypeGameObjectAssetPtr::updateRects()
+{
+   S32 dividerPos, dividerMargin;
+   mInspector->getDivider(dividerPos, dividerMargin);
+   Point2I fieldExtent = getExtent();
+   Point2I fieldPos = getPosition();
+
+   mCaptionRect.set(0, 0, fieldExtent.x - dividerPos - dividerMargin, fieldExtent.y);
+   mEditCtrlRect.set(fieldExtent.x - dividerPos + dividerMargin, 1, dividerPos - dividerMargin - 34, fieldExtent.y);
+
+   bool resized = mEdit->resize(mEditCtrlRect.point, mEditCtrlRect.extent);
+   if (mBrowseButton != NULL)
+   {
+      mBrowseRect.set(fieldExtent.x - 32, 2, 14, fieldExtent.y - 4);
+      resized |= mBrowseButton->resize(mBrowseRect.point, mBrowseRect.extent);
+   }
+
+   if (mSMEdButton != NULL)
+   {
+      RectI shapeEdRect(fieldExtent.x - 16, 2, 14, fieldExtent.y - 4);
+      resized |= mSMEdButton->resize(shapeEdRect.point, shapeEdRect.extent);
+   }
+
+   return resized;
 }

Engine/source/T3D/assets/GameObjectAsset.h

@@ -38,17 +38,15 @@
 #ifndef _ASSET_FIELD_TYPES_H_
 #include "assets/assetFieldTypes.h"
 #endif
+#ifndef _GUI_INSPECTOR_TYPES_H_
+#include "gui/editor/guiInspectorTypes.h"
+#endif
 
 //-----------------------------------------------------------------------------
 class GameObjectAsset : public AssetBase
 {
    typedef AssetBase Parent;
 
-   AssetManager*           mpOwningAssetManager;
-   bool                    mAssetInitialized;
-   AssetDefinition*        mpAssetDefinition;
-   U32                     mAcquireReferenceCount;
-
    StringTableEntry mGameObjectName;
    StringTableEntry mScriptFilePath;
    StringTableEntry mTAMLFilePath;
@@ -65,11 +63,29 @@ public:
    DECLARE_CONOBJECT(GameObjectAsset);
 
 protected:
-   virtual void            initializeAsset(void) {}
-   virtual void            onAssetRefresh(void) {}
+   virtual void            initializeAsset(void);
+   virtual void            onAssetRefresh(void);
 };
 
 DefineConsoleType(TypeGameObjectAssetPtr, GameObjectAsset)
 
+
+//-----------------------------------------------------------------------------
+// TypeAssetId GuiInspectorField Class
+//-----------------------------------------------------------------------------
+class GuiInspectorTypeGameObjectAssetPtr : public GuiInspectorTypeFileName
+{
+   typedef GuiInspectorTypeFileName Parent;
+public:
+
+   GuiBitmapButtonCtrl  *mSMEdButton;
+
+   DECLARE_CONOBJECT(GuiInspectorTypeGameObjectAssetPtr);
+   static void consoleInit();
+
+   virtual GuiControl* constructEditControl();
+   virtual bool updateRects();
+};
+
 #endif // _ASSET_BASE_H_
 

Engine/source/T3D/assets/ImageAsset.cpp

@@ -0,0 +1,156 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef IMAGE_ASSET_H
+#include "ImageAsset.h"
+#endif
+
+#ifndef _ASSET_MANAGER_H_
+#include "assets/assetManager.h"
+#endif
+
+#ifndef _CONSOLETYPES_H_
+#include "console/consoleTypes.h"
+#endif
+
+#ifndef _TAML_
+#include "persistence/taml/taml.h"
+#endif
+
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif
+
+// Debug Profiling.
+#include "platform/profiler.h"
+
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(ImageAsset);
+
+ConsoleType(ImageAssetPtr, TypeImageAssetPtr, ImageAsset, ASSET_ID_FIELD_PREFIX)
+
+//-----------------------------------------------------------------------------
+
+ConsoleGetType(TypeImageAssetPtr)
+{
+   // Fetch asset Id.
+   return (*((AssetPtr<ImageAsset>*)dptr)).getAssetId();
+}
+
+//-----------------------------------------------------------------------------
+
+ConsoleSetType(TypeImageAssetPtr)
+{
+   // Was a single argument specified?
+   if (argc == 1)
+   {
+      // Yes, so fetch field value.
+      const char* pFieldValue = argv[0];
+
+      // Fetch asset pointer.
+      AssetPtr<ImageAsset>* pAssetPtr = dynamic_cast<AssetPtr<ImageAsset>*>((AssetPtrBase*)(dptr));
+
+      // Is the asset pointer the correct type?
+      if (pAssetPtr == NULL)
+      {
+         // No, so fail.
+         //Con::warnf("(TypeImageAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         return;
+      }
+
+      // Set asset.
+      pAssetPtr->setAssetId(pFieldValue);
+
+      return;
+   }
+
+   // Warn.
+   Con::warnf("(TypeImageAssetPtr) - Cannot set multiple args to a single asset.");
+}
+
+//-----------------------------------------------------------------------------
+
+ImageAsset::ImageAsset() : AssetBase(), mImage(nullptr), mUseMips(true), mIsHDRImage(false), mIsValidImage(false)
+{
+   mImageFileName = StringTable->EmptyString();
+}
+
+//-----------------------------------------------------------------------------
+
+ImageAsset::~ImageAsset()
+{
+}
+
+//-----------------------------------------------------------------------------
+
+void ImageAsset::initPersistFields()
+{
+   // Call parent.
+   Parent::initPersistFields();
+
+   addField("imageFile", TypeString, Offset(mImageFileName, ImageAsset), "Path to the image file.");
+   addField("useMips", TypeBool, Offset(mUseMips, ImageAsset), "Should the image use mips? (Currently unused).");
+   addField("isHDRImage", TypeBool, Offset(mIsHDRImage, ImageAsset), "Is the image in an HDR format? (Currently unused)");
+}
+
+//------------------------------------------------------------------------------
+
+void ImageAsset::copyTo(SimObject* object)
+{
+   // Call to parent.
+   Parent::copyTo(object);
+}
+
+void ImageAsset::loadImage()
+{
+   SAFE_DELETE(mImage);
+
+   if (mImageFileName)
+   {
+      if (!Platform::isFile(mImageFileName))
+      {
+         Con::errorf("ImageAsset::initializeAsset: Attempted to load file %s but it was not valid!", mImageFileName);
+         return;
+      }
+
+      mImage.set(mImageFileName, &GFXStaticTextureSRGBProfile, avar("%s() - mImage (line %d)", __FUNCTION__, __LINE__));
+
+      if (mImage)
+      {
+         mIsValidImage = true;
+         return;
+      }
+   }
+
+   mIsValidImage = false;
+}
+
+void ImageAsset::initializeAsset()
+{
+   loadImage();
+}
+
+void ImageAsset::onAssetRefresh()
+{
+   loadImage();
+}

Engine/source/T3D/assets/ImageAsset.h

@@ -0,0 +1,85 @@
+#pragma once
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#ifndef IMAGE_ASSET_H
+#define IMAGE_ASSET_H
+
+#ifndef _ASSET_BASE_H_
+#include "assets/assetBase.h"
+#endif
+
+#ifndef _ASSET_DEFINITION_H_
+#include "assets/assetDefinition.h"
+#endif
+
+#ifndef _STRINGUNIT_H_
+#include "string/stringUnit.h"
+#endif
+
+#ifndef _ASSET_FIELD_TYPES_H_
+#include "assets/assetFieldTypes.h"
+#endif
+
+#include "gfx/bitmap/gBitmap.h"
+#include "gfx/gfxTextureHandle.h"
+
+//-----------------------------------------------------------------------------
+class ImageAsset : public AssetBase
+{
+   typedef AssetBase Parent;
+
+   StringTableEntry mImageFileName;
+
+   GFXTexHandle mImage;
+
+   bool mIsValidImage;
+   bool mUseMips;
+   bool mIsHDRImage;
+
+public:
+   ImageAsset();
+   virtual ~ImageAsset();
+
+   /// Engine.
+   static void initPersistFields();
+   virtual void copyTo(SimObject* object);
+
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(ImageAsset);
+
+   StringTableEntry getImageFileName() { return mImageFileName; }
+
+   bool isValid() { return mIsValidImage; }
+
+   GFXTexHandle* getImage() { return &mImage; }
+
+protected:
+   virtual void            initializeAsset(void);
+   virtual void            onAssetRefresh(void);
+
+   void loadImage();
+};
+
+DefineConsoleType(TypeImageAssetPtr, ImageAsset)
+
+#endif
+

Engine/source/T3D/assets/LevelAsset.cpp

@@ -0,0 +1,128 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef LEVEL_ASSET_H
+#include "LevelAsset.h"
+#endif
+
+#ifndef _ASSET_MANAGER_H_
+#include "assets/assetManager.h"
+#endif
+
+#ifndef _CONSOLETYPES_H_
+#include "console/consoleTypes.h"
+#endif
+
+#ifndef _TAML_
+#include "persistence/taml/taml.h"
+#endif
+
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif
+
+// Debug Profiling.
+#include "platform/profiler.h"
+
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(LevelAsset);
+
+ConsoleType(LevelAssetPtr, TypeLevelAssetPtr, LevelAsset, ASSET_ID_FIELD_PREFIX)
+
+//-----------------------------------------------------------------------------
+
+ConsoleGetType(TypeLevelAssetPtr)
+{
+   // Fetch asset Id.
+   return (*((AssetPtr<LevelAsset>*)dptr)).getAssetId();
+}
+
+//-----------------------------------------------------------------------------
+
+ConsoleSetType(TypeLevelAssetPtr)
+{
+   // Was a single argument specified?
+   if (argc == 1)
+   {
+      // Yes, so fetch field value.
+      const char* pFieldValue = argv[0];
+
+      // Fetch asset pointer.
+      AssetPtr<LevelAsset>* pAssetPtr = dynamic_cast<AssetPtr<LevelAsset>*>((AssetPtrBase*)(dptr));
+
+      // Is the asset pointer the correct type?
+      if (pAssetPtr == NULL)
+      {
+         // No, so fail.
+         //Con::warnf("(TypeLevelAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         return;
+      }
+
+      // Set asset.
+      pAssetPtr->setAssetId(pFieldValue);
+
+      return;
+   }
+
+   // Warn.
+   Con::warnf("(TypeLevelAssetPtr) - Cannot set multiple args to a single asset.");
+}
+
+//-----------------------------------------------------------------------------
+
+LevelAsset::LevelAsset() : AssetBase(), mIsSubLevel(false)
+{
+   mLevelFile = StringTable->EmptyString();
+   mPreviewImage = StringTable->EmptyString();
+
+   mMainLevelAsset = StringTable->EmptyString();
+}
+
+//-----------------------------------------------------------------------------
+
+LevelAsset::~LevelAsset()
+{
+   // If the asset manager does not own the asset then we own the
+   // asset definition so delete it.
+   if (!getOwned())
+      delete mpAssetDefinition;
+}
+
+//-----------------------------------------------------------------------------
+
+void LevelAsset::initPersistFields()
+{
+   // Call parent.
+   Parent::initPersistFields();
+
+   addField("LevelFile", TypeString, Offset(mLevelFile, LevelAsset), "Path to the actual level file.");
+   addField("PreviewImage", TypeString, Offset(mPreviewImage, LevelAsset), "Path to the image used for selection preview.");
+}
+
+//------------------------------------------------------------------------------
+
+void LevelAsset::copyTo(SimObject* object)
+{
+   // Call to parent.
+   Parent::copyTo(object);
+}

Engine/source/T3D/assets/LevelAsset.h

@@ -0,0 +1,72 @@
+#pragma once
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#ifndef LEVEL_ASSET_H
+#define LEVEL_ASSET_H
+
+#ifndef _ASSET_BASE_H_
+#include "assets/assetBase.h"
+#endif
+
+#ifndef _ASSET_DEFINITION_H_
+#include "assets/assetDefinition.h"
+#endif
+
+#ifndef _STRINGUNIT_H_
+#include "string/stringUnit.h"
+#endif
+
+#ifndef _ASSET_FIELD_TYPES_H_
+#include "assets/assetFieldTypes.h"
+#endif
+
+//-----------------------------------------------------------------------------
+class LevelAsset : public AssetBase
+{
+   typedef AssetBase Parent;
+
+   StringTableEntry        mLevelFile;
+   StringTableEntry        mPreviewImage;
+
+   bool                    mIsSubLevel;
+   StringTableEntry        mMainLevelAsset;
+
+public:
+   LevelAsset();
+   virtual ~LevelAsset();
+
+   /// Engine.
+   static void initPersistFields();
+   virtual void copyTo(SimObject* object);
+
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(LevelAsset);
+
+protected:
+   virtual void            initializeAsset(void) {}
+   virtual void            onAssetRefresh(void) {}
+};
+
+DefineConsoleType(TypeLevelAssetPtr, LevelAsset)
+
+#endif // _ASSET_BASE_H_
+

Engine/source/T3D/assets/MaterialAsset.cpp

@@ -0,0 +1,241 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef MATERIALASSET_H
+#include "MaterialAsset.h"
+#endif
+
+#ifndef _ASSET_MANAGER_H_
+#include "assets/assetManager.h"
+#endif
+
+#ifndef _CONSOLETYPES_H_
+#include "console/consoleTypes.h"
+#endif
+
+#ifndef _TAML_
+#include "persistence/taml/taml.h"
+#endif
+
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif
+
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(MaterialAsset);
+
+ConsoleType(MaterialAssetPtr, TypeMaterialAssetPtr, MaterialAsset, ASSET_ID_FIELD_PREFIX)
+
+//-----------------------------------------------------------------------------
+
+ConsoleGetType(TypeMaterialAssetPtr)
+{
+   // Fetch asset Id.
+   return (*((AssetPtr<MaterialAsset>*)dptr)).getAssetId();
+}
+
+//-----------------------------------------------------------------------------
+
+ConsoleSetType(TypeMaterialAssetPtr)
+{
+   // Was a single argument specified?
+   if (argc == 1)
+   {
+      // Yes, so fetch field value.
+      const char* pFieldValue = argv[0];
+
+      // Fetch asset pointer.
+      AssetPtr<MaterialAsset>* pAssetPtr = dynamic_cast<AssetPtr<MaterialAsset>*>((AssetPtrBase*)(dptr));
+
+      // Is the asset pointer the correct type?
+      if (pAssetPtr == NULL)
+      {
+         // No, so fail.
+         //Con::warnf("(TypeMaterialAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         return;
+      }
+
+      // Set asset.
+      pAssetPtr->setAssetId(pFieldValue);
+
+      return;
+   }
+
+   // Warn.
+   Con::warnf("(TypeMaterialAssetPtr) - Cannot set multiple args to a single asset.");
+}
+
+//-----------------------------------------------------------------------------
+
+MaterialAsset::MaterialAsset()
+{
+   mShaderGraphFile = "";
+   mScriptFile = "";
+   mMatDefinitionName = "";
+}
+
+//-----------------------------------------------------------------------------
+
+MaterialAsset::~MaterialAsset()
+{
+   // If the asset manager does not own the asset then we own the
+   // asset definition so delete it.
+   if (!getOwned())
+      delete mpAssetDefinition;
+}
+
+//-----------------------------------------------------------------------------
+
+void MaterialAsset::initPersistFields()
+{
+   // Call parent.
+   Parent::initPersistFields();
+
+   //addField("shaderGraph", TypeRealString, Offset(mShaderGraphFile, MaterialAsset), "");
+   addField("scriptFile", TypeRealString, Offset(mScriptFile, MaterialAsset), "Path to the file containing the material definition.");
+   addField("materialDefinitionName", TypeRealString, Offset(mMatDefinitionName, MaterialAsset), "Name of the material definition this asset is for.");
+}
+
+void MaterialAsset::initializeAsset()
+{
+   // Call parent.
+   Parent::initializeAsset();
+
+   compileShader();
+
+   if (Platform::isFile(mScriptFile))
+      Con::executeFile(mScriptFile, false, false);
+}
+
+void MaterialAsset::onAssetRefresh()
+{
+   if (Platform::isFile(mScriptFile))
+      Con::executeFile(mScriptFile, false, false);
+
+   if (!mMatDefinitionName.isEmpty())
+   {
+      Material* matDef;
+      if (!Sim::findObject(mMatDefinitionName.c_str(), matDef))
+      {
+         Con::errorf("MaterialAsset: Unable to find the Material %s", mMatDefinitionName.c_str());
+         return;
+      }
+
+      matDef->reload();
+   }
+}
+
+//------------------------------------------------------------------------------
+
+void MaterialAsset::compileShader()
+{
+}
+
+void MaterialAsset::copyTo(SimObject* object)
+{
+   // Call to parent.
+   Parent::copyTo(object);
+}
+
+ConsoleMethod(MaterialAsset, compileShader, void, 2, 2, "() - Compiles the material's generated shader, if any. Not yet implemented\n")
+{
+   object->compileShader();
+}
+
+//-----------------------------------------------------------------------------
+// GuiInspectorTypeAssetId
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(GuiInspectorTypeMaterialAssetPtr);
+
+ConsoleDocClass(GuiInspectorTypeMaterialAssetPtr,
+   "@brief Inspector field type for Material Asset Objects\n\n"
+   "Editor use only.\n\n"
+   "@internal"
+);
+
+void GuiInspectorTypeMaterialAssetPtr::consoleInit()
+{
+   Parent::consoleInit();
+
+   ConsoleBaseType::getType(TypeMaterialAssetPtr)->setInspectorFieldType("GuiInspectorTypeMaterialAssetPtr");
+}
+
+GuiControl* GuiInspectorTypeMaterialAssetPtr::constructEditControl()
+{
+   // Create base filename edit controls
+   GuiControl *retCtrl = Parent::constructEditControl();
+   if (retCtrl == NULL)
+      return retCtrl;
+
+   // Change filespec
+   char szBuffer[512];
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"MaterialAsset\", \"AssetBrowser.changeAsset\", %d, %s);",
+      mInspector->getComponentGroupTargetId(), mCaption);
+   mBrowseButton->setField("Command", szBuffer);
+
+   // Create "Open in ShapeEditor" button
+   mSMEdButton = new GuiBitmapButtonCtrl();
+
+   dSprintf(szBuffer, sizeof(szBuffer), "echo(\"Game Object Editor not implemented yet!\");", retCtrl->getId());
+   mSMEdButton->setField("Command", szBuffer);
+
+   char bitmapName[512] = "tools/worldEditor/images/toolbar/shape-editor";
+   mSMEdButton->setBitmap(bitmapName);
+
+   mSMEdButton->setDataField(StringTable->insert("Profile"), NULL, "GuiButtonProfile");
+   mSMEdButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
+   mSMEdButton->setDataField(StringTable->insert("hovertime"), NULL, "1000");
+   mSMEdButton->setDataField(StringTable->insert("tooltip"), NULL, "Open this file in the Material Editor");
+
+   mSMEdButton->registerObject();
+   addObject(mSMEdButton);
+
+   return retCtrl;
+}
+
+bool GuiInspectorTypeMaterialAssetPtr::updateRects()
+{
+   S32 dividerPos, dividerMargin;
+   mInspector->getDivider(dividerPos, dividerMargin);
+   Point2I fieldExtent = getExtent();
+   Point2I fieldPos = getPosition();
+
+   mCaptionRect.set(0, 0, fieldExtent.x - dividerPos - dividerMargin, fieldExtent.y);
+   mEditCtrlRect.set(fieldExtent.x - dividerPos + dividerMargin, 1, dividerPos - dividerMargin - 34, fieldExtent.y);
+
+   bool resized = mEdit->resize(mEditCtrlRect.point, mEditCtrlRect.extent);
+   if (mBrowseButton != NULL)
+   {
+      mBrowseRect.set(fieldExtent.x - 32, 2, 14, fieldExtent.y - 4);
+      resized |= mBrowseButton->resize(mBrowseRect.point, mBrowseRect.extent);
+   }
+
+   if (mSMEdButton != NULL)
+   {
+      RectI shapeEdRect(fieldExtent.x - 16, 2, 14, fieldExtent.y - 4);
+      resized |= mSMEdButton->resize(shapeEdRect.point, shapeEdRect.extent);
+   }
+
+   return resized;
+}

Engine/source/T3D/assets/MaterialAsset.h

@@ -0,0 +1,101 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#ifndef MATERIALASSET_H
+#define MATERIALASSET_H
+
+#ifndef _ASSET_BASE_H_
+#include "assets/assetBase.h"
+#endif
+
+#ifndef _ASSET_DEFINITION_H_
+#include "assets/assetDefinition.h"
+#endif
+
+#ifndef _STRINGUNIT_H_
+#include "string/stringUnit.h"
+#endif
+
+#ifndef _ASSET_FIELD_TYPES_H_
+#include "assets/assetFieldTypes.h"
+#endif
+
+#ifndef _GFXDEVICE_H_
+#include "gfx/gfxDevice.h"
+#endif
+
+#ifndef _GUI_INSPECTOR_TYPES_H_
+#include "gui/editor/guiInspectorTypes.h"
+#endif
+
+#include "materials/matTextureTarget.h"
+#include "materials/materialDefinition.h"
+#include "materials/customMaterialDefinition.h"
+
+//-----------------------------------------------------------------------------
+class MaterialAsset : public AssetBase
+{
+   typedef AssetBase Parent;
+
+   String                  mShaderGraphFile;
+   String                  mScriptFile;
+   String                  mMatDefinitionName;
+
+public:
+   MaterialAsset();
+   virtual ~MaterialAsset();
+
+   /// Engine.
+   static void initPersistFields();
+   virtual void copyTo(SimObject* object);
+
+   virtual void initializeAsset();
+   virtual void onAssetRefresh(void);
+
+   void compileShader();
+
+   String getMaterialDefinitionName() { return mMatDefinitionName; }
+
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(MaterialAsset);
+};
+
+DefineConsoleType(TypeMaterialAssetPtr, MaterialAsset)
+
+//-----------------------------------------------------------------------------
+// TypeAssetId GuiInspectorField Class
+//-----------------------------------------------------------------------------
+class GuiInspectorTypeMaterialAssetPtr : public GuiInspectorTypeFileName
+{
+   typedef GuiInspectorTypeFileName Parent;
+public:
+
+   GuiBitmapButtonCtrl  *mSMEdButton;
+
+   DECLARE_CONOBJECT(GuiInspectorTypeMaterialAssetPtr);
+   static void consoleInit();
+
+   virtual GuiControl* constructEditControl();
+   virtual bool updateRects();
+};
+
+#endif // _ASSET_BASE_H_
+

Engine/source/T3D/assets/ParticleAsset.cpp

@@ -0,0 +1,205 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef PARTICLE_ASSET_H
+#include "ParticleAsset.h"
+#endif
+
+#ifndef _ASSET_MANAGER_H_
+#include "assets/assetManager.h"
+#endif
+
+#ifndef _CONSOLETYPES_H_
+#include "console/consoleTypes.h"
+#endif
+
+#ifndef _TAML_
+#include "persistence/taml/taml.h"
+#endif
+
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif
+
+// Debug Profiling.
+#include "platform/profiler.h"
+
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(ParticleAsset);
+
+ConsoleType(ParticleAssetPtr, TypeParticleAssetPtr, ParticleAsset, ASSET_ID_FIELD_PREFIX)
+
+//-----------------------------------------------------------------------------
+
+ConsoleGetType(TypeParticleAssetPtr)
+{
+   // Fetch asset Id.
+   return (*((AssetPtr<ParticleAsset>*)dptr)).getAssetId();
+}
+
+//-----------------------------------------------------------------------------
+
+ConsoleSetType(TypeParticleAssetPtr)
+{
+   // Was a single argument specified?
+   if (argc == 1)
+   {
+      // Yes, so fetch field value.
+      const char* pFieldValue = argv[0];
+
+      // Fetch asset pointer.
+      AssetPtr<ParticleAsset>* pAssetPtr = dynamic_cast<AssetPtr<ParticleAsset>*>((AssetPtrBase*)(dptr));
+
+      // Is the asset pointer the correct type?
+      if (pAssetPtr == NULL)
+      {
+         // No, so fail.
+         //Con::warnf("(TypeParticleAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         return;
+      }
+
+      // Set asset.
+      pAssetPtr->setAssetId(pFieldValue);
+
+      return;
+   }
+
+   // Warn.
+   Con::warnf("(TypeParticleAssetPtr) - Cannot set multiple args to a single asset.");
+}
+
+//-----------------------------------------------------------------------------
+
+ParticleAsset::ParticleAsset()
+{
+   mScriptFilePath = StringTable->EmptyString();
+   mDatablockFilePath = StringTable->EmptyString();
+}
+
+//-----------------------------------------------------------------------------
+
+ParticleAsset::~ParticleAsset()
+{
+   // If the asset manager does not own the asset then we own the
+   // asset definition so delete it.
+   if (!getOwned())
+      delete mpAssetDefinition;
+}
+
+//-----------------------------------------------------------------------------
+
+void ParticleAsset::initPersistFields()
+{
+   // Call parent.
+   Parent::initPersistFields();
+
+   addField("scriptFilePath", TypeString, Offset(mScriptFilePath, ParticleAsset), "Path to the script file for the particle effect");
+   addField("DatablockFilePath", TypeString, Offset(mDatablockFilePath, ParticleAsset), "Path to the datablock file");
+}
+
+//------------------------------------------------------------------------------
+
+void ParticleAsset::copyTo(SimObject* object)
+{
+   // Call to parent.
+   Parent::copyTo(object);
+}
+
+
+//-----------------------------------------------------------------------------
+// GuiInspectorTypeAssetId
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(GuiInspectorTypeParticleAssetPtr);
+
+ConsoleDocClass(GuiInspectorTypeParticleAssetPtr,
+   "@brief Inspector field type for Partial Asset Objects\n\n"
+   "Editor use only.\n\n"
+   "@internal"
+);
+
+void GuiInspectorTypeParticleAssetPtr::consoleInit()
+{
+   Parent::consoleInit();
+
+   ConsoleBaseType::getType(TypeParticleAssetPtr)->setInspectorFieldType("GuiInspectorTypeParticleAssetPtr");
+}
+
+GuiControl* GuiInspectorTypeParticleAssetPtr::constructEditControl()
+{
+   // Create base filename edit controls
+   GuiControl *retCtrl = Parent::constructEditControl();
+   if (retCtrl == NULL)
+      return retCtrl;
+
+   // Change filespec
+   char szBuffer[512];
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"ParticleAsset\", \"AssetBrowser.changeAsset\", %d, %s);",
+      mInspector->getComponentGroupTargetId(), mCaption);
+   mBrowseButton->setField("Command", szBuffer);
+
+   // Create "Open in ShapeEditor" button
+   mSMEdButton = new GuiBitmapButtonCtrl();
+
+   dSprintf(szBuffer, sizeof(szBuffer), "echo(\"Game Object Editor not implemented yet!\");", retCtrl->getId());
+   mSMEdButton->setField("Command", szBuffer);
+
+   char bitmapName[512] = "tools/worldEditor/images/toolbar/shape-editor";
+   mSMEdButton->setBitmap(bitmapName);
+
+   mSMEdButton->setDataField(StringTable->insert("Profile"), NULL, "GuiButtonProfile");
+   mSMEdButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
+   mSMEdButton->setDataField(StringTable->insert("hovertime"), NULL, "1000");
+   mSMEdButton->setDataField(StringTable->insert("tooltip"), NULL, "Open this file in the State Machine Editor");
+
+   mSMEdButton->registerObject();
+   addObject(mSMEdButton);
+
+   return retCtrl;
+}
+
+bool GuiInspectorTypeParticleAssetPtr::updateRects()
+{
+   S32 dividerPos, dividerMargin;
+   mInspector->getDivider(dividerPos, dividerMargin);
+   Point2I fieldExtent = getExtent();
+   Point2I fieldPos = getPosition();
+
+   mCaptionRect.set(0, 0, fieldExtent.x - dividerPos - dividerMargin, fieldExtent.y);
+   mEditCtrlRect.set(fieldExtent.x - dividerPos + dividerMargin, 1, dividerPos - dividerMargin - 34, fieldExtent.y);
+
+   bool resized = mEdit->resize(mEditCtrlRect.point, mEditCtrlRect.extent);
+   if (mBrowseButton != NULL)
+   {
+      mBrowseRect.set(fieldExtent.x - 32, 2, 14, fieldExtent.y - 4);
+      resized |= mBrowseButton->resize(mBrowseRect.point, mBrowseRect.extent);
+   }
+
+   if (mSMEdButton != NULL)
+   {
+      RectI shapeEdRect(fieldExtent.x - 16, 2, 14, fieldExtent.y - 4);
+      resized |= mSMEdButton->resize(shapeEdRect.point, shapeEdRect.extent);
+   }
+
+   return resized;
+}

Engine/source/T3D/assets/ParticleAsset.h

@@ -0,0 +1,89 @@
+#pragma once
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#ifndef PARTICLE_ASSET_H
+#define PARTICLE_ASSET_H
+
+#ifndef _ASSET_BASE_H_
+#include "assets/assetBase.h"
+#endif
+
+#ifndef _ASSET_DEFINITION_H_
+#include "assets/assetDefinition.h"
+#endif
+
+#ifndef _STRINGUNIT_H_
+#include "string/stringUnit.h"
+#endif
+
+#ifndef _ASSET_FIELD_TYPES_H_
+#include "assets/assetFieldTypes.h"
+#endif
+
+#include "gui/editor/guiInspectorTypes.h"
+
+//-----------------------------------------------------------------------------
+class ParticleAsset : public AssetBase
+{
+   typedef AssetBase Parent;
+
+   StringTableEntry mScriptFilePath;
+   StringTableEntry mDatablockFilePath;
+
+public:
+   ParticleAsset();
+   virtual ~ParticleAsset();
+
+   /// Engine.
+   static void initPersistFields();
+   virtual void copyTo(SimObject* object);
+
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(ParticleAsset);
+
+protected:
+   virtual void            initializeAsset(void) {}
+   virtual void            onAssetRefresh(void) {}
+};
+
+DefineConsoleType(TypeParticleAssetPtr, ParticleAsset)
+
+
+//-----------------------------------------------------------------------------
+// TypeAssetId GuiInspectorField Class
+//-----------------------------------------------------------------------------
+class GuiInspectorTypeParticleAssetPtr : public GuiInspectorTypeFileName
+{
+   typedef GuiInspectorTypeFileName Parent;
+public:
+
+   GuiBitmapButtonCtrl  *mSMEdButton;
+
+   DECLARE_CONOBJECT(GuiInspectorTypeParticleAssetPtr);
+   static void consoleInit();
+
+   virtual GuiControl* constructEditControl();
+   virtual bool updateRects();
+};
+
+#endif // _ASSET_BASE_H_
+

Engine/source/T3D/assets/PostEffectAsset.cpp

@@ -0,0 +1,129 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef POSTEFFECT_ASSET_H
+#include "PostEffectAsset.h"
+#endif
+
+#ifndef _ASSET_MANAGER_H_
+#include "assets/assetManager.h"
+#endif
+
+#ifndef _CONSOLETYPES_H_
+#include "console/consoleTypes.h"
+#endif
+
+#ifndef _TAML_
+#include "persistence/taml/taml.h"
+#endif
+
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif
+
+// Debug Profiling.
+#include "platform/profiler.h"
+
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(PostEffectAsset);
+
+ConsoleType(PostEffectAssetPtr, TypePostEffectAssetPtr, PostEffectAsset, ASSET_ID_FIELD_PREFIX)
+
+//-----------------------------------------------------------------------------
+
+ConsoleGetType(TypePostEffectAssetPtr)
+{
+   // Fetch asset Id.
+   return (*((AssetPtr<PostEffectAsset>*)dptr)).getAssetId();
+}
+
+//-----------------------------------------------------------------------------
+
+ConsoleSetType(TypePostEffectAssetPtr)
+{
+   // Was a single argument specified?
+   if (argc == 1)
+   {
+      // Yes, so fetch field value.
+      const char* pFieldValue = argv[0];
+
+      // Fetch asset pointer.
+      AssetPtr<PostEffectAsset>* pAssetPtr = dynamic_cast<AssetPtr<PostEffectAsset>*>((AssetPtrBase*)(dptr));
+
+      // Is the asset pointer the correct type?
+      if (pAssetPtr == NULL)
+      {
+         // No, so fail.
+         //Con::warnf("(TypePostEffectAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         return;
+      }
+
+      // Set asset.
+      pAssetPtr->setAssetId(pFieldValue);
+
+      return;
+   }
+
+   // Warn.
+   Con::warnf("(TypePostEffectAssetPtr) - Cannot set multiple args to a single asset.");
+}
+
+//-----------------------------------------------------------------------------
+
+PostEffectAsset::PostEffectAsset()
+{
+   mScriptFile = StringTable->EmptyString();
+}
+
+//-----------------------------------------------------------------------------
+
+PostEffectAsset::~PostEffectAsset()
+{
+   // If the asset manager does not own the asset then we own the
+   // asset definition so delete it.
+   if (!getOwned())
+      delete mpAssetDefinition;
+}
+
+//-----------------------------------------------------------------------------
+
+void PostEffectAsset::initPersistFields()
+{
+   // Call parent.
+   Parent::initPersistFields();
+
+   addField("scriptFile", TypeString, Offset(mScriptFile, PostEffectAsset), "Path to the script file.");
+}
+
+//------------------------------------------------------------------------------
+
+void PostEffectAsset::copyTo(SimObject* object)
+{
+   // Call to parent.
+   Parent::copyTo(object);
+}
+
+void PostEffectAsset::initializeAsset()
+{
+   //mPostEffect = new PostEffect();
+}

Engine/source/platform/menus/menuBar.h → Engine/source/T3D/assets/PostEffectAsset.h

@@ -1,5 +1,6 @@
+#pragma once
 //-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
+// Copyright (c) 2013 GarageGames, LLC
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to
@@ -19,53 +20,52 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
+#ifndef POSTEFFECT_ASSET_H
+#define POSTEFFECT_ASSET_H
 
-#include "console/simBase.h"
+#ifndef _ASSET_BASE_H_
+#include "assets/assetBase.h"
+#endif
 
-#ifndef _MENUBAR_H_
-#define _MENUBAR_H_
+#ifndef _ASSET_DEFINITION_H_
+#include "assets/assetDefinition.h"
+#endif
 
-// Forward Refs
-class PlatformMenuBarData;
-class PopupMenu;
-class GuiCanvas;
+#ifndef _STRINGUNIT_H_
+#include "string/stringUnit.h"
+#endif
 
-class MenuBar : public SimSet
-{
-   typedef SimSet Parent;
+#ifndef _ASSET_FIELD_TYPES_H_
+#include "assets/assetFieldTypes.h"
+#endif
 
-protected:
-   PlatformMenuBarData *mData;
-   GuiCanvas *mCanvas;
+#include "postFx/postEffect.h"
 
-   /// Update the native menu bar to ensure consistency with the set
-   void updateMenuBar(PopupMenu *menu = NULL);
-   
-   void createPlatformPopupMenuData();
-   void deletePlatformPopupMenuData();
+//-----------------------------------------------------------------------------
+class PostEffectAsset : public AssetBase
+{
+   typedef AssetBase Parent;
+
+   StringTableEntry        mScriptFile;
    
 public:
-   MenuBar();
-   virtual ~MenuBar();
-   DECLARE_CONOBJECT(MenuBar);
-
-   /// Attach this menu bar to the native menu bar
-   void attachToCanvas(GuiCanvas *owner, S32 pos);
-   /// Remove this menu bar from the native menu bar
-   void removeFromCanvas();
+   PostEffectAsset();
+   virtual ~PostEffectAsset();
 
-   /// Returns true if this menu is attached to the menu bar
-   bool isAttachedToCanvas()                      { return mCanvas != NULL; }
+   /// Engine.
+   static void initPersistFields();
+   virtual void copyTo(SimObject* object);
 
-   virtual void insertObject(SimObject *obj, S32 pos);
+   virtual void initializeAsset();
 
-   // Overridden SimSet methods to ensure menu bar consistency when attached
-   virtual void addObject(SimObject *obj);
-   virtual void removeObject(SimObject *obj);
-   virtual void pushObject(SimObject *obj);
-   virtual void popObject();
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(PostEffectAsset);
 
-   virtual bool reOrder(SimObject *obj, SimObject *target = 0);
+protected:
+   virtual void            onAssetRefresh(void) {}
 };
 
-#endif // _MENUBAR_H_
+DefineConsoleType(TypePostEffectAssetPtr, PostEffectAsset)
+
+#endif // _ASSET_BASE_H_
+

Engine/source/T3D/assets/ScriptAsset.cpp

@@ -0,0 +1,137 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#ifndef SCRIPT_ASSET_H
+#include "ScriptAsset.h"
+#endif
+
+#ifndef _ASSET_MANAGER_H_
+#include "assets/assetManager.h"
+#endif
+
+#ifndef _CONSOLETYPES_H_
+#include "console/consoleTypes.h"
+#endif
+
+#ifndef _TAML_
+#include "persistence/taml/taml.h"
+#endif
+
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif
+
+// Debug Profiling.
+#include "platform/profiler.h"
+
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(ScriptAsset);
+
+ConsoleType(ScriptAssetPtr, TypeScriptAssetPtr, ScriptAsset, ASSET_ID_FIELD_PREFIX)
+
+//-----------------------------------------------------------------------------
+
+ConsoleGetType(TypeScriptAssetPtr)
+{
+   // Fetch asset Id.
+   return (*((AssetPtr<ScriptAsset>*)dptr)).getAssetId();
+}
+
+//-----------------------------------------------------------------------------
+
+ConsoleSetType(TypeScriptAssetPtr)
+{
+   // Was a single argument specified?
+   if (argc == 1)
+   {
+      // Yes, so fetch field value.
+      const char* pFieldValue = argv[0];
+
+      // Fetch asset pointer.
+      AssetPtr<ScriptAsset>* pAssetPtr = dynamic_cast<AssetPtr<ScriptAsset>*>((AssetPtrBase*)(dptr));
+
+      // Is the asset pointer the correct type?
+      if (pAssetPtr == NULL)
+      {
+         // No, so fail.
+         //Con::warnf("(TypeScriptAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         return;
+      }
+
+      // Set asset.
+      pAssetPtr->setAssetId(pFieldValue);
+
+      return;
+   }
+
+   // Warn.
+   Con::warnf("(TypeScriptAssetPtr) - Cannot set multiple args to a single asset.");
+}
+
+//-----------------------------------------------------------------------------
+
+ScriptAsset::ScriptAsset() : AssetBase(), mIsServerSide(true)
+{
+   mScriptFilePath = StringTable->EmptyString();
+}
+
+//-----------------------------------------------------------------------------
+
+ScriptAsset::~ScriptAsset()
+{
+   // If the asset manager does not own the asset then we own the
+   // asset definition so delete it.
+   if (!getOwned())
+      delete mpAssetDefinition;
+}
+
+//-----------------------------------------------------------------------------
+
+void ScriptAsset::initPersistFields()
+{
+   // Call parent.
+   Parent::initPersistFields();
+
+   addField("scriptFilePath", TypeString, Offset(mScriptFilePath, ScriptAsset), "Path to the script file.");
+   addField("isServerSide", TypeBool, Offset(mIsServerSide, ScriptAsset), "Is this script file to be run on the server side?");
+
+}
+
+//------------------------------------------------------------------------------
+
+void ScriptAsset::copyTo(SimObject* object)
+{
+   // Call to parent.
+   Parent::copyTo(object);
+}
+
+void ScriptAsset::initializeAsset()
+{
+   if (Platform::isFile(mScriptFilePath))
+      Con::executeFile(mScriptFilePath, false, false);
+}
+
+void ScriptAsset::onAssetRefresh()
+{
+   if (Platform::isFile(mScriptFilePath))
+      Con::executeFile(mScriptFilePath, false, false);
+}

Engine/source/platformSDL/menus/guiPlatformGenericMenuBar.h → Engine/source/T3D/assets/ScriptAsset.h

@@ -1,5 +1,5 @@
 //-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
+// Copyright (c) 2013 GarageGames, LLC
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to
@@ -19,33 +19,51 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
-
+#ifndef SCRIPT_ASSET_H
+#define SCRIPT_ASSET_H
 #pragma once
 
-#include "gui/editor/guiMenuBar.h"
-#include "platformSDL/menus/PlatformSDLPopupMenuData.h"
-#include "platform/menus/popupMenu.h"
+#ifndef _ASSET_BASE_H_
+#include "assets/assetBase.h"
+#endif
+
+#ifndef _ASSET_DEFINITION_H_
+#include "assets/assetDefinition.h"
+#endif
+
+#ifndef _STRINGUNIT_H_
+#include "string/stringUnit.h"
+#endif
 
-class GuiPlatformGenericMenuBar : public GuiMenuBar
+#ifndef _ASSET_FIELD_TYPES_H_
+#include "assets/assetFieldTypes.h"
+#endif
+
+//-----------------------------------------------------------------------------
+class ScriptAsset : public AssetBase
 {
-   typedef GuiMenuBar Parent;
-public:
-   DECLARE_CONOBJECT(GuiPlatformGenericMenuBar);
+   typedef AssetBase Parent;
 
-   virtual void menuItemSelected(Menu *menu, MenuItem *item)
-   {
-      AssertFatal(menu && item, "");
+   StringTableEntry        mScriptFilePath;
+   bool                    mIsServerSide;
 
-      PopupMenu *popupMenu = PlatformPopupMenuData::mMenuMap[menu];
-      AssertFatal(popupMenu, "");
+public:
+   ScriptAsset();
+   virtual ~ScriptAsset();
 
-      popupMenu->handleSelect(item->id);
+   /// Engine.
+   static void initPersistFields();
+   virtual void copyTo(SimObject* object);
 
-      Parent::menuItemSelected(menu, item);
-   }
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(ScriptAsset);
 
 protected:
-   /// menu id / item id
-   Map<CompoundKey<U32, U32>, String> mCmds;
+   virtual void            initializeAsset(void);
+   virtual void            onAssetRefresh(void);
+};
+
+DefineConsoleType(TypeScriptAssetPtr, ScriptAsset)
+
+#endif // _ASSET_BASE_H_
 
-};

Engine/source/T3D/assets/ShapeAnimationAsset.cpp

@@ -0,0 +1,175 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef SHAPE_ANIMATION_ASSET_H
+#include "ShapeAnimationAsset.h"
+#endif
+
+#ifndef _ASSET_MANAGER_H_
+#include "assets/assetManager.h"
+#endif
+
+#ifndef _CONSOLETYPES_H_
+#include "console/consoleTypes.h"
+#endif
+
+#ifndef _TAML_
+#include "persistence/taml/taml.h"
+#endif
+
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif
+
+#include "core/resourceManager.h"
+
+// Debug Profiling.
+#include "platform/profiler.h"
+
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(ShapeAnimationAsset);
+
+ConsoleType(ShapeAnimationAssetPtr, TypeShapeAnimationAssetPtr, ShapeAnimationAsset, ASSET_ID_FIELD_PREFIX)
+
+//-----------------------------------------------------------------------------
+
+ConsoleGetType(TypeShapeAnimationAssetPtr)
+{
+   // Fetch asset Id.
+   return (*((AssetPtr<ShapeAnimationAsset>*)dptr)).getAssetId();
+}
+
+//-----------------------------------------------------------------------------
+
+ConsoleSetType(TypeShapeAnimationAssetPtr)
+{
+   // Was a single argument specified?
+   if (argc == 1)
+   {
+      // Yes, so fetch field value.
+      const char* pFieldValue = argv[0];
+
+      // Fetch asset pointer.
+      AssetPtr<ShapeAnimationAsset>* pAssetPtr = dynamic_cast<AssetPtr<ShapeAnimationAsset>*>((AssetPtrBase*)(dptr));
+
+      // Is the asset pointer the correct type?
+      if (pAssetPtr == NULL)
+      {
+         // No, so fail.
+         //Con::warnf("(TypeShapeAnimationAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         return;
+      }
+
+      // Set asset.
+      pAssetPtr->setAssetId(pFieldValue);
+
+      return;
+   }
+
+   // Warn.
+   Con::warnf("(TypeShapeAnimationAssetPtr) - Cannot set multiple args to a single asset.");
+}
+
+//-----------------------------------------------------------------------------
+
+ShapeAnimationAsset::ShapeAnimationAsset() : 
+   mIsEmbedded(false), mIsCyclical(true), mIsBlend(false), mBlendFrame(0), mStartFrame(0), mEndFrame(-1), mPadRotation(true), mPadTransforms(false)
+{
+   mFileName = StringTable->EmptyString();
+   mAnimationName = StringTable->EmptyString();
+
+   mBlendAnimAssetName = StringTable->EmptyString();
+}
+
+//-----------------------------------------------------------------------------
+
+ShapeAnimationAsset::~ShapeAnimationAsset()
+{
+   // If the asset manager does not own the asset then we own the
+   // asset definition so delete it.
+   if (!getOwned())
+      delete mpAssetDefinition;
+}
+
+//-----------------------------------------------------------------------------
+
+void ShapeAnimationAsset::initPersistFields()
+{
+   // Call parent.
+   Parent::initPersistFields();
+
+   addField("animationFile", TypeFilename, Offset(mFileName, ShapeAnimationAsset), "Path to the file name containing the animation");
+   addField("animationName", TypeString, Offset(mAnimationName, ShapeAnimationAsset), "Name of the animation");
+
+   addField("isEmbedded", TypeBool, Offset(mIsEmbedded, ShapeAnimationAsset), "If true, this animation asset just referrs to an embedded animation of a regular shape mesh. If false, it is a self-contained animation file");
+
+   addField("isCyclic", TypeBool, Offset(mIsCyclical, ShapeAnimationAsset), "Is this animation looping?");
+
+   addField("isBlend", TypeBool, Offset(mIsBlend, ShapeAnimationAsset), "Is this animation blended with another?");
+   addField("blendRefAnimation", TypeString, Offset(mBlendAnimAssetName, ShapeAnimationAsset), "AssetID of the animation to reference for our blending");
+   addField("blendFrame", TypeS32, Offset(mBlendFrame, ShapeAnimationAsset), "Which frame of the reference animation do we use for our blending");
+
+   addField("startFrame", TypeS32, Offset(mStartFrame, ShapeAnimationAsset), "What frame does this animation clip start on");
+   addField("endFrame", TypeS32, Offset(mEndFrame, ShapeAnimationAsset), "What fram does this animation clip end on");
+   addField("padRotation", TypeBool, Offset(mPadRotation, ShapeAnimationAsset), "Are the rotation values padded");
+   addField("padTransforms", TypeBool, Offset(mPadTransforms, ShapeAnimationAsset), "Are the transform values padded");
+}
+
+//------------------------------------------------------------------------------
+
+void ShapeAnimationAsset::copyTo(SimObject* object)
+{
+   // Call to parent.
+   Parent::copyTo(object);
+}
+
+void ShapeAnimationAsset::initializeAsset(void)
+{
+   if (!mIsEmbedded)
+   {
+      //If we're not embedded, we need to load in our initial shape and do some prepwork
+
+      char filenameBuf[1024];
+      Con::expandScriptFilename(filenameBuf, sizeof(filenameBuf), mFileName);
+
+      mSourceShape = ResourceManager::get().load(filenameBuf);
+
+      if (!mSourceShape->addSequence("ambient", "", mAnimationName, mStartFrame, mEndFrame, mPadRotation, mPadTransforms))
+      {
+         Con::errorf("ShapeAnimationAsset::initializeAsset - Unable to do initial setup of the animation clip named %s for asset %s", mAnimationName, getAssetName());
+         return;
+      }
+
+      S32 sequenceId = mSourceShape->findSequence(mAnimationName);
+
+      if(mIsCyclical)
+         mSourceShape->sequences[sequenceId].flags |= TSShape::Cyclic;
+      else
+         mSourceShape->sequences[sequenceId].flags &= (~(TSShape::Cyclic));
+   }
+}
+
+void ShapeAnimationAsset::onAssetRefresh(void)
+{
+
+}

Engine/source/T3D/assets/ShapeAnimationAsset.h

@@ -0,0 +1,126 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#ifndef SHAPE_ANIMATION_ASSET_H
+#define SHAPE_ANIMATION_ASSET_H
+
+#ifndef _ASSET_BASE_H_
+#include "assets/assetBase.h"
+#endif
+
+#ifndef _ASSET_DEFINITION_H_
+#include "assets/assetDefinition.h"
+#endif
+
+#ifndef _STRINGUNIT_H_
+#include "string/stringUnit.h"
+#endif
+
+#ifndef _ASSET_FIELD_TYPES_H_
+#include "assets/assetFieldTypes.h"
+#endif
+#ifndef _TSSHAPE_H_
+#include "ts/tsShape.h"
+#endif
+#ifndef __RESOURCE_H__
+#include "core/resource.h"
+#endif
+
+//-----------------------------------------------------------------------------
+class ShapeAnimationAsset : public AssetBase
+{
+   typedef AssetBase Parent;
+
+protected:
+   StringTableEntry   mFileName;
+
+   bool            mIsEmbedded;
+   bool            mIsCyclical;
+
+   bool            mIsBlend;
+
+   StringTableEntry mBlendAnimAssetName;
+
+   S32 mBlendFrame;
+
+   //
+   StringTableEntry mAnimationName;
+   S32 mStartFrame;
+   S32 mEndFrame;
+   bool mPadRotation;
+   bool mPadTransforms;
+
+   Resource<TSShape> mSourceShape;
+
+public:
+   ShapeAnimationAsset();
+   virtual ~ShapeAnimationAsset();
+
+   /// Engine.
+   static void initPersistFields();
+   virtual void copyTo(SimObject* object);
+
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(ShapeAnimationAsset);
+
+protected:
+   virtual void            initializeAsset(void);
+   virtual void            onAssetRefresh(void);
+
+public:
+   StringTableEntry getAnimationFilename() { return mFileName; }
+   StringTableEntry getAnimationName() { return mAnimationName; }
+   StringTableEntry getBlendAnimationName() { return mBlendAnimAssetName; }
+
+   S32 getStartFrame() { return mStartFrame; }
+   S32 getEndFrame() { return mEndFrame; }
+
+   bool getPadRotation() { return mPadRotation; }
+   bool getPadTransforms() { return mPadTransforms; }
+
+   bool isEmbedded() { return mIsEmbedded; }
+   bool isCyclic() { return mIsCyclical; }
+   bool isBlend() { return mIsBlend; }
+
+   S32 getBlendFrame() { return mBlendFrame; }
+};
+
+DefineConsoleType(TypeShapeAnimationAssetPtr, ShapeAnimationAsset)
+
+//-----------------------------------------------------------------------------
+// TypeAssetId GuiInspectorField Class
+//-----------------------------------------------------------------------------
+/*class GuiInspectorTypeShapeAnimationAssetPtr : public GuiInspectorTypeFileName
+{
+   typedef GuiInspectorTypeFileName Parent;
+public:
+
+   GuiBitmapButtonCtrl  *mShapeEdButton;
+
+   DECLARE_CONOBJECT(GuiInspectorTypeShapeAnimationAssetPtr);
+   static void consoleInit();
+
+   virtual GuiControl* constructEditControl();
+   virtual bool updateRects();
+};*/
+
+#endif // _ASSET_BASE_H_
+

Engine/source/T3D/assets/ShapeAsset.cpp

@@ -49,14 +49,14 @@
 
 IMPLEMENT_CONOBJECT(ShapeAsset);
 
-ConsoleType(TestAssetPtr, TypeShapeAssetPtr, ShapeAsset, ASSET_ID_FIELD_PREFIX)
+ConsoleType(assetIdString, TypeShapeAssetPtr, String, ASSET_ID_FIELD_PREFIX)
 
 //-----------------------------------------------------------------------------
 
 ConsoleGetType(TypeShapeAssetPtr)
 {
    // Fetch asset Id.
-   return (*((AssetPtr<ShapeAsset>*)dptr)).getAssetId();
+   return *((StringTableEntry*)dptr);
 }
 
 //-----------------------------------------------------------------------------
@@ -69,33 +69,22 @@ ConsoleSetType(TypeShapeAssetPtr)
       // Yes, so fetch field value.
       const char* pFieldValue = argv[0];
 
-      // Fetch asset pointer.
-      AssetPtr<ShapeAsset>* pAssetPtr = dynamic_cast<AssetPtr<ShapeAsset>*>((AssetPtrBase*)(dptr));
+      // Fetch asset Id.
+      StringTableEntry* assetId = (StringTableEntry*)(dptr);
 
-      // Is the asset pointer the correct type?
-      if (pAssetPtr == NULL)
-      {
-         // No, so fail.
-         //Con::warnf("(TypeTextureAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
-         return;
-      }
-
-      // Set asset.
-      pAssetPtr->setAssetId(pFieldValue);
+      // Update asset value.
+      *assetId = StringTable->insert(pFieldValue);
 
       return;
    }
 
    // Warn.
-   Con::warnf("(TypeTextureAssetPtr) - Cannot set multiple args to a single asset.");
+   Con::warnf("(TypeAssetId) - Cannot set multiple args to a single asset.");
 }
 
 //-----------------------------------------------------------------------------
 
-ShapeAsset::ShapeAsset() :
-mpOwningAssetManager(NULL),
-mAssetInitialized(false),
-mAcquireReferenceCount(0)
+ShapeAsset::ShapeAsset()
 {
 }
 
@@ -116,7 +105,21 @@ void ShapeAsset::initPersistFields()
    // Call parent.
    Parent::initPersistFields();
 
-   addField("fileName", TypeFilename, Offset(mFileName, ShapeAsset), "Path to the script file we want to execute");
+   addField("fileName", TypeFilename, Offset(mFileName, ShapeAsset), "Path to the shape file we want to render");
+}
+
+void ShapeAsset::setDataField(StringTableEntry slotName, const char *array, const char *value)
+{
+   Parent::setDataField(slotName, array, value);
+
+   //Now, if it's a material slot of some fashion, set it up
+   StringTableEntry matSlotName = StringTable->insert("materialAsset");
+   if (String(slotName).startsWith(matSlotName))
+   {
+      StringTableEntry matId = StringTable->insert(value);
+
+      mMaterialAssetIds.push_back(matId);
+   }
 }
 
 void ShapeAsset::initializeAsset()
@@ -132,6 +135,45 @@ void ShapeAsset::initializeAsset()
 
 bool ShapeAsset::loadShape()
 {
+   mMaterialAssets.clear();
+   mMaterialAssetIds.clear();
+
+   //First, load any material, animation, etc assets we may be referencing in our asset
+   // Find any asset dependencies.
+   AssetManager::typeAssetDependsOnHash::Iterator assetDependenciesItr = mpOwningAssetManager->getDependedOnAssets()->find(mpAssetDefinition->mAssetId);
+
+   // Does the asset have any dependencies?
+   if (assetDependenciesItr != mpOwningAssetManager->getDependedOnAssets()->end())
+   {
+      // Iterate all dependencies.
+      while (assetDependenciesItr != mpOwningAssetManager->getDependedOnAssets()->end() && assetDependenciesItr->key == mpAssetDefinition->mAssetId)
+      {
+         StringTableEntry assetType = mpOwningAssetManager->getAssetType(assetDependenciesItr->value);
+
+         if (assetType == StringTable->insert("MaterialAsset"))
+         {
+            mMaterialAssetIds.push_back(assetDependenciesItr->value);
+
+            //Force the asset to become initialized if it hasn't been already
+            AssetPtr<MaterialAsset> matAsset = assetDependenciesItr->value;
+
+            mMaterialAssets.push_back(matAsset);
+         }
+         else if (assetType == StringTable->insert("ShapeAnimationAsset"))
+         {
+            mAnimationAssetIds.push_back(assetDependenciesItr->value);
+
+            //Force the asset to become initialized if it hasn't been already
+            AssetPtr<ShapeAnimationAsset> animAsset = assetDependenciesItr->value;
+
+            mAnimationAssets.push_back(animAsset);
+         }
+
+         // Next dependency.
+         assetDependenciesItr++;
+      }
+   }
+
    mShape = ResourceManager::get().load(mFileName);
 
    if (!mShape)
@@ -140,6 +182,51 @@ bool ShapeAsset::loadShape()
       return false; //if it failed to load, bail out
    }
 
+   bool hasBlends = false;
+
+   //Now that we've successfully loaded our shape and have any materials and animations loaded
+   //we need to set up the animations we're using on our shape
+   for (S32 i = mAnimationAssets.size()-1; i >= 0; --i)
+   {
+      String srcName = mAnimationAssets[i]->getAnimationName();
+      String srcPath(mAnimationAssets[i]->getAnimationFilename());
+      //SplitSequencePathAndName(srcPath, srcName);
+
+      if (!mShape->addSequence(srcPath, srcName, srcName,
+         mAnimationAssets[i]->getStartFrame(), mAnimationAssets[i]->getEndFrame(), mAnimationAssets[i]->getPadRotation(), mAnimationAssets[i]->getPadTransforms()))
+         return false;
+
+      if (mAnimationAssets[i]->isBlend())
+         hasBlends = true;
+   }
+
+   //if any of our animations are blends, set those up now
+   if (hasBlends)
+   {
+      for (U32 i=0; i < mAnimationAssets.size(); ++i)
+      {
+         if (mAnimationAssets[i]->isBlend() && mAnimationAssets[i]->getBlendAnimationName() != StringTable->EmptyString())
+         {
+            //gotta do a bit of logic here.
+            //First, we need to make sure the anim asset we depend on for our blend is loaded
+            AssetPtr<ShapeAnimationAsset> blendAnimAsset = mAnimationAssets[i]->getBlendAnimationName();
+
+            if (blendAnimAsset.isNull())
+            {
+               Con::errorf("ShapeAsset::initializeAsset - Unable to acquire reference animation asset %s for asset %s to blend!", mAnimationAssets[i]->getBlendAnimationName(), mAnimationAssets[i]->getAssetName());
+               return false;
+            }
+
+            String refAnimName = blendAnimAsset->getAnimationName();
+            if (!mShape->setSequenceBlend(mAnimationAssets[i]->getAnimationName(), true, blendAnimAsset->getAnimationName(), mAnimationAssets[i]->getBlendFrame()))
+            {
+               Con::errorf("ShapeAnimationAsset::initializeAsset - Unable to set animation clip %s for asset %s to blend!", mAnimationAssets[i]->getAnimationName(), mAnimationAssets[i]->getAssetName());
+               return false;
+            }
+         }
+      }
+   }
+
    return true;
 }
 
@@ -153,4 +240,141 @@ void ShapeAsset::copyTo(SimObject* object)
 
 void ShapeAsset::onAssetRefresh(void)
 {
+   if (dStrcmp(mFileName, "") == 0)
+      return;
+
+   loadShape();
+}
+
+void ShapeAsset::SplitSequencePathAndName(String& srcPath, String& srcName)
+{
+   srcName = "";
+
+   // Determine if there is a sequence name at the end of the source string, and
+   // if so, split the filename from the sequence name
+   S32 split = srcPath.find(' ', 0, String::Right);
+   S32 split2 = srcPath.find('\t', 0, String::Right);
+   if ((split == String::NPos) || (split2 > split))
+      split = split2;
+   if (split != String::NPos)
+   {
+      split2 = split + 1;
+      while ((srcPath[split2] != '\0') && dIsspace(srcPath[split2]))
+         split2++;
+
+      // now 'split' is at the end of the path, and 'split2' is at the start of the sequence name
+      srcName = srcPath.substr(split2);
+      srcPath = srcPath.erase(split, srcPath.length() - split);
+   }
+}
+
+ShapeAnimationAsset* ShapeAsset::getAnimation(S32 index)
+{
+   if (index < mAnimationAssets.size())
+   {
+      return mAnimationAssets[index];
+   }
+
+   return nullptr;
+}
+
+DefineEngineMethod(ShapeAsset, getMaterialCount, S32, (), ,
+   "Gets the number of materials for this shape asset.\n"
+   "@return Material count.\n")
+{
+   return object->getMaterialCount();
+}
+
+DefineEngineMethod(ShapeAsset, getAnimationCount, S32, (), ,
+   "Gets the number of animations for this shape asset.\n"
+   "@return Animation count.\n")
+{
+   return object->getAnimationCount();
+}
+
+DefineEngineMethod(ShapeAsset, getAnimation, ShapeAnimationAsset*, (S32 index), (0),
+   "Gets a particular shape animation asset for this shape.\n"
+   "@param animation asset index.\n"
+   "@return Shape Animation Asset.\n")
+{
+   return object->getAnimation(index);
+}
+//-----------------------------------------------------------------------------
+// GuiInspectorTypeAssetId
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(GuiInspectorTypeShapeAssetPtr);
+
+ConsoleDocClass(GuiInspectorTypeShapeAssetPtr,
+   "@brief Inspector field type for Shapes\n\n"
+   "Editor use only.\n\n"
+   "@internal"
+   );
+
+void GuiInspectorTypeShapeAssetPtr::consoleInit()
+{
+   Parent::consoleInit();
+
+   ConsoleBaseType::getType(TypeShapeAssetPtr)->setInspectorFieldType("GuiInspectorTypeShapeAssetPtr");
+}
+
+GuiControl* GuiInspectorTypeShapeAssetPtr::constructEditControl()
+{
+   // Create base filename edit controls
+   GuiControl *retCtrl = Parent::constructEditControl();
+   if (retCtrl == NULL)
+      return retCtrl;
+
+   // Change filespec
+   char szBuffer[512];
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"ShapeAsset\", \"AssetBrowser.changeAsset\", %d, %s);", 
+      mInspector->getComponentGroupTargetId(), mCaption);
+   mBrowseButton->setField("Command", szBuffer);
+
+   setDataField(StringTable->insert("ComponentOwner"), NULL, String::ToString(mInspector->getComponentGroupTargetId()).c_str());
+
+   // Create "Open in ShapeEditor" button
+   mShapeEdButton = new GuiBitmapButtonCtrl();
+
+   dSprintf(szBuffer, sizeof(szBuffer), "ShapeEditorPlugin.openShapeAsset(%d.getText());", retCtrl->getId());
+   mShapeEdButton->setField("Command", szBuffer);
+
+   char bitmapName[512] = "tools/worldEditor/images/toolbar/shape-editor";
+   mShapeEdButton->setBitmap(bitmapName);
+
+   mShapeEdButton->setDataField(StringTable->insert("Profile"), NULL, "GuiButtonProfile");
+   mShapeEdButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
+   mShapeEdButton->setDataField(StringTable->insert("hovertime"), NULL, "1000");
+   mShapeEdButton->setDataField(StringTable->insert("tooltip"), NULL, "Open this file in the Shape Editor");
+
+   mShapeEdButton->registerObject();
+   addObject(mShapeEdButton);
+
+   return retCtrl;
+}
+
+bool GuiInspectorTypeShapeAssetPtr::updateRects()
+{
+   S32 dividerPos, dividerMargin;
+   mInspector->getDivider(dividerPos, dividerMargin);
+   Point2I fieldExtent = getExtent();
+   Point2I fieldPos = getPosition();
+
+   mCaptionRect.set(0, 0, fieldExtent.x - dividerPos - dividerMargin, fieldExtent.y);
+   mEditCtrlRect.set(fieldExtent.x - dividerPos + dividerMargin, 1, dividerPos - dividerMargin - 34, fieldExtent.y);
+
+   bool resized = mEdit->resize(mEditCtrlRect.point, mEditCtrlRect.extent);
+   if (mBrowseButton != NULL)
+   {
+      mBrowseRect.set(fieldExtent.x - 32, 2, 14, fieldExtent.y - 4);
+      resized |= mBrowseButton->resize(mBrowseRect.point, mBrowseRect.extent);
+   }
+
+   if (mShapeEdButton != NULL)
+   {
+      RectI shapeEdRect(fieldExtent.x - 16, 2, 14, fieldExtent.y - 4);
+      resized |= mShapeEdButton->resize(shapeEdRect.point, shapeEdRect.extent);
+   }
+
+   return resized;
 }

Engine/source/T3D/assets/ShapeAsset.h

@@ -44,21 +44,35 @@
 #ifndef __RESOURCE_H__
 #include "core/resource.h"
 #endif
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif 
+#ifndef MATERIALASSET_H
+#include "MaterialAsset.h"
+#endif
+#ifndef SHAPE_ANIMATION_ASSET_H
+#include "ShapeAnimationAsset.h"
+#endif
+
+#include "gui/editor/guiInspectorTypes.h"
 
 //-----------------------------------------------------------------------------
 class ShapeAsset : public AssetBase
 {
    typedef AssetBase Parent;
 
-   AssetManager*           mpOwningAssetManager;
-   bool                    mAssetInitialized;
-   AssetDefinition*        mpAssetDefinition;
-   U32                     mAcquireReferenceCount;
-
 protected:
    StringTableEntry   mFileName;
    Resource<TSShape>	 mShape;
 
+   //Material assets we're dependent on and use
+   Vector<StringTableEntry> mMaterialAssetIds;
+   Vector<AssetPtr<MaterialAsset>> mMaterialAssets;
+
+   //Animation assets we're dependent on and use
+   Vector<StringTableEntry> mAnimationAssetIds;
+   Vector<AssetPtr<ShapeAnimationAsset>> mAnimationAssets;
+
 public:
    ShapeAsset();
    virtual ~ShapeAsset();
@@ -67,6 +81,8 @@ public:
    static void initPersistFields();
    virtual void copyTo(SimObject* object);
 
+   virtual void setDataField(StringTableEntry slotName, const char *array, const char *value);
+
    virtual void initializeAsset();
 
    /// Declare Console Object.
@@ -78,11 +94,37 @@ public:
 
    Resource<TSShape> getShapeResource() { return mShape; }
 
+   void SplitSequencePathAndName(String& srcPath, String& srcName);
+   String getShapeFilename() { return mFileName; }
+   
+   U32 getShapeFilenameHash() { return _StringTable::hashString(mFileName); }
+
+   S32 getMaterialCount() { return mMaterialAssets.size(); }
+   S32 getAnimationCount() { return mAnimationAssets.size(); }
+   ShapeAnimationAsset* getAnimation(S32 index);
+
 protected:
    virtual void            onAssetRefresh(void);
 };
 
-DefineConsoleType(TypeShapeAssetPtr, ShapeAsset)
+DefineConsoleType(TypeShapeAssetPtr, S32)
+
+//-----------------------------------------------------------------------------
+// TypeAssetId GuiInspectorField Class
+//-----------------------------------------------------------------------------
+class GuiInspectorTypeShapeAssetPtr : public GuiInspectorTypeFileName
+{
+   typedef GuiInspectorTypeFileName Parent;
+public:
+
+   GuiBitmapButtonCtrl  *mShapeEdButton;
+
+   DECLARE_CONOBJECT(GuiInspectorTypeShapeAssetPtr);
+   static void consoleInit();
+
+   virtual GuiControl* constructEditControl();
+   virtual bool updateRects();
+};
 
 #endif
 

Engine/source/T3D/assets/SoundAsset.cpp

@@ -0,0 +1,141 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef SOUND_ASSET_H
+#include "SoundAsset.h"
+#endif
+
+#ifndef _ASSET_MANAGER_H_
+#include "assets/assetManager.h"
+#endif
+
+#ifndef _CONSOLETYPES_H_
+#include "console/consoleTypes.h"
+#endif
+
+#ifndef _TAML_
+#include "persistence/taml/taml.h"
+#endif
+
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif
+
+// Debug Profiling.
+#include "platform/profiler.h"
+
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(SoundAsset);
+
+ConsoleType(SoundAssetPtr, TypeSoundAssetPtr, SoundAsset, ASSET_ID_FIELD_PREFIX)
+
+//-----------------------------------------------------------------------------
+
+ConsoleGetType(TypeSoundAssetPtr)
+{
+   // Fetch asset Id.
+   return (*((AssetPtr<SoundAsset>*)dptr)).getAssetId();
+}
+
+//-----------------------------------------------------------------------------
+
+ConsoleSetType(TypeSoundAssetPtr)
+{
+   // Was a single argument specified?
+   if (argc == 1)
+   {
+      // Yes, so fetch field value.
+      const char* pFieldValue = argv[0];
+
+      // Fetch asset pointer.
+      AssetPtr<SoundAsset>* pAssetPtr = dynamic_cast<AssetPtr<SoundAsset>*>((AssetPtrBase*)(dptr));
+
+      // Is the asset pointer the correct type?
+      if (pAssetPtr == NULL)
+      {
+         // No, so fail.
+         //Con::warnf("(TypeSoundAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         return;
+      }
+
+      // Set asset.
+      pAssetPtr->setAssetId(pFieldValue);
+
+      return;
+   }
+
+   // Warn.
+   Con::warnf("(TypeSoundAssetPtr) - Cannot set multiple args to a single asset.");
+}
+
+//-----------------------------------------------------------------------------
+
+SoundAsset::SoundAsset()
+{
+   mSoundFilePath = StringTable->EmptyString();
+
+   mPitchAdjust = 0;
+   mVolumeAdjust = 0;
+
+   //mSound = nullptr;
+}
+
+//-----------------------------------------------------------------------------
+
+SoundAsset::~SoundAsset()
+{
+   // If the asset manager does not own the asset then we own the
+   // asset definition so delete it.
+   if (!getOwned())
+      delete mpAssetDefinition;
+}
+
+//-----------------------------------------------------------------------------
+
+void SoundAsset::initPersistFields()
+{
+   // Call parent.
+   Parent::initPersistFields();
+
+   addField("soundFilePath", TypeFilename, Offset(mSoundFilePath, SoundAsset), "Path to the sound file.");
+
+   addField("pitchAdjust", TypeF32, Offset(mPitchAdjust, SoundAsset), "Adjustment of the pitch value");
+   addField("volumeAdjust", TypeF32, Offset(mVolumeAdjust, SoundAsset), "Adjustment to the volume.");
+}
+
+//------------------------------------------------------------------------------
+
+void SoundAsset::copyTo(SimObject* object)
+{
+   // Call to parent.
+   Parent::copyTo(object);
+}
+
+void SoundAsset::initializeAsset(void)
+{
+}
+
+void SoundAsset::onAssetRefresh(void)
+{
+
+}

Engine/source/T3D/assets/SoundAsset.h

@@ -0,0 +1,75 @@
+#pragma once
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#ifndef SOUND_ASSET_H
+#define SOUND_ASSET_H
+
+#ifndef _ASSET_BASE_H_
+#include "assets/assetBase.h"
+#endif
+
+#ifndef _ASSET_DEFINITION_H_
+#include "assets/assetDefinition.h"
+#endif
+
+#ifndef _STRINGUNIT_H_
+#include "string/stringUnit.h"
+#endif
+
+#ifndef _ASSET_FIELD_TYPES_H_
+#include "assets/assetFieldTypes.h"
+#endif
+
+class SFXTrack;
+
+//-----------------------------------------------------------------------------
+class SoundAsset : public AssetBase
+{
+   typedef AssetBase Parent;
+
+protected:
+   StringTableEntry        mSoundFilePath;
+   F32                     mPitchAdjust;
+   F32                     mVolumeAdjust;
+
+public:
+   SoundAsset();
+   virtual ~SoundAsset();
+
+   /// Engine.
+   static void initPersistFields();
+   virtual void copyTo(SimObject* object);
+
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(SoundAsset);
+
+   StringTableEntry getSoundFilePath() { return mSoundFilePath; }
+
+protected:
+   virtual void            initializeAsset(void);
+   virtual void            onAssetRefresh(void);
+};
+
+DefineConsoleType(TypeSoundAssetPtr, SoundAsset)
+
+#endif // _ASSET_BASE_H_
+

Engine/source/T3D/assets/stateMachineAsset.cpp

@@ -0,0 +1,207 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef STATE_MACHINE_ASSET_H
+#include "stateMachineAsset.h"
+#endif
+
+#ifndef _ASSET_MANAGER_H_
+#include "assets/assetManager.h"
+#endif
+
+#ifndef _CONSOLETYPES_H_
+#include "console/consoleTypes.h"
+#endif
+
+#ifndef _TAML_
+#include "persistence/taml/taml.h"
+#endif
+
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif
+
+// Debug Profiling.
+#include "platform/profiler.h"
+
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(StateMachineAsset);
+
+ConsoleType(StateMachineAssetPtr, TypeStateMachineAssetPtr, StateMachineAsset, ASSET_ID_FIELD_PREFIX)
+
+//-----------------------------------------------------------------------------
+
+ConsoleGetType(TypeStateMachineAssetPtr)
+{
+   // Fetch asset Id.
+   return (*((AssetPtr<StateMachineAsset>*)dptr)).getAssetId();
+}
+
+//-----------------------------------------------------------------------------
+
+ConsoleSetType(TypeStateMachineAssetPtr)
+{
+   // Was a single argument specified?
+   if (argc == 1)
+   {
+      // Yes, so fetch field value.
+      const char* pFieldValue = argv[0];
+
+      // Fetch asset pointer.
+      AssetPtr<StateMachineAsset>* pAssetPtr = dynamic_cast<AssetPtr<StateMachineAsset>*>((AssetPtrBase*)(dptr));
+
+      // Is the asset pointer the correct type?
+      if (pAssetPtr == NULL)
+      {
+         // No, so fail.
+         //Con::warnf("(TypeStateMachineAssetPtr) - Failed to set asset Id '%d'.", pFieldValue);
+         return;
+      }
+
+      // Set asset.
+      pAssetPtr->setAssetId(pFieldValue);
+
+      return;
+   }
+
+   // Warn.
+   Con::warnf("(TypeStateMachineAssetPtr) - Cannot set multiple args to a single asset.");
+}
+
+//-----------------------------------------------------------------------------
+
+StateMachineAsset::StateMachineAsset()
+{
+   mStateMachineFileName = StringTable->EmptyString();
+}
+
+//-----------------------------------------------------------------------------
+
+StateMachineAsset::~StateMachineAsset()
+{
+   // If the asset manager does not own the asset then we own the
+   // asset definition so delete it.
+   if (!getOwned())
+      delete mpAssetDefinition;
+}
+
+//-----------------------------------------------------------------------------
+
+void StateMachineAsset::initPersistFields()
+{
+   // Call parent.
+   Parent::initPersistFields();
+
+   addField("stateMachineFile", TypeString, Offset(mStateMachineFileName, StateMachineAsset), "Path to the state machine file.");
+}
+
+//------------------------------------------------------------------------------
+
+void StateMachineAsset::copyTo(SimObject* object)
+{
+   // Call to parent.
+   Parent::copyTo(object);
+}
+
+DefineEngineMethod(StateMachineAsset, notifyAssetChanged, void, (),,"")
+{
+   ResourceManager::get().getChangedSignal().trigger(object->getStateMachineFileName());
+}
+
+//-----------------------------------------------------------------------------
+// GuiInspectorTypeAssetId
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CONOBJECT(GuiInspectorTypeStateMachineAssetPtr);
+
+ConsoleDocClass(GuiInspectorTypeStateMachineAssetPtr,
+   "@brief Inspector field type for State Machines\n\n"
+   "Editor use only.\n\n"
+   "@internal"
+);
+
+void GuiInspectorTypeStateMachineAssetPtr::consoleInit()
+{
+   Parent::consoleInit();
+
+   ConsoleBaseType::getType(TypeStateMachineAssetPtr)->setInspectorFieldType("GuiInspectorTypeStateMachineAssetPtr");
+}
+
+GuiControl* GuiInspectorTypeStateMachineAssetPtr::constructEditControl()
+{
+   // Create base filename edit controls
+   GuiControl *retCtrl = Parent::constructEditControl();
+   if (retCtrl == NULL)
+      return retCtrl;
+
+   // Change filespec
+   char szBuffer[512];
+   dSprintf(szBuffer, sizeof(szBuffer), "AssetBrowser.showDialog(\"StateMachineAsset\", \"AssetBrowser.changeAsset\", %d, %s);",
+      mInspector->getComponentGroupTargetId(), mCaption);
+   mBrowseButton->setField("Command", szBuffer);
+
+   // Create "Open in ShapeEditor" button
+   mSMEdButton = new GuiBitmapButtonCtrl();
+
+   dSprintf(szBuffer, sizeof(szBuffer), "StateMachineEditor.loadStateMachineAsset(%d.getText()); Canvas.pushDialog(StateMachineEditor);", retCtrl->getId());
+   mSMEdButton->setField("Command", szBuffer);
+
+   char bitmapName[512] = "tools/worldEditor/images/toolbar/shape-editor";
+   mSMEdButton->setBitmap(bitmapName);
+
+   mSMEdButton->setDataField(StringTable->insert("Profile"), NULL, "GuiButtonProfile");
+   mSMEdButton->setDataField(StringTable->insert("tooltipprofile"), NULL, "GuiToolTipProfile");
+   mSMEdButton->setDataField(StringTable->insert("hovertime"), NULL, "1000");
+   mSMEdButton->setDataField(StringTable->insert("tooltip"), NULL, "Open this file in the State Machine Editor");
+
+   mSMEdButton->registerObject();
+   addObject(mSMEdButton);
+
+   return retCtrl;
+}
+
+bool GuiInspectorTypeStateMachineAssetPtr::updateRects()
+{
+   S32 dividerPos, dividerMargin;
+   mInspector->getDivider(dividerPos, dividerMargin);
+   Point2I fieldExtent = getExtent();
+   Point2I fieldPos = getPosition();
+
+   mCaptionRect.set(0, 0, fieldExtent.x - dividerPos - dividerMargin, fieldExtent.y);
+   mEditCtrlRect.set(fieldExtent.x - dividerPos + dividerMargin, 1, dividerPos - dividerMargin - 34, fieldExtent.y);
+
+   bool resized = mEdit->resize(mEditCtrlRect.point, mEditCtrlRect.extent);
+   if (mBrowseButton != NULL)
+   {
+      mBrowseRect.set(fieldExtent.x - 32, 2, 14, fieldExtent.y - 4);
+      resized |= mBrowseButton->resize(mBrowseRect.point, mBrowseRect.extent);
+   }
+
+   if (mSMEdButton != NULL)
+   {
+      RectI shapeEdRect(fieldExtent.x - 16, 2, 14, fieldExtent.y - 4);
+      resized |= mSMEdButton->resize(shapeEdRect.point, shapeEdRect.extent);
+   }
+
+   return resized;
+}

Engine/source/T3D/assets/stateMachineAsset.h

@@ -0,0 +1,89 @@
+#pragma once
+//-----------------------------------------------------------------------------
+// Copyright (c) 2013 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#ifndef STATE_MACHINE_ASSET_H
+#define STATE_MACHINE_ASSET_H
+
+#ifndef _ASSET_BASE_H_
+#include "assets/assetBase.h"
+#endif
+
+#ifndef _ASSET_DEFINITION_H_
+#include "assets/assetDefinition.h"
+#endif
+
+#ifndef _STRINGUNIT_H_
+#include "string/stringUnit.h"
+#endif
+
+#ifndef _ASSET_FIELD_TYPES_H_
+#include "assets/assetFieldTypes.h"
+#endif
+
+#include "gui/editor/guiInspectorTypes.h"
+
+//-----------------------------------------------------------------------------
+class StateMachineAsset : public AssetBase
+{
+   typedef AssetBase Parent;
+
+   StringTableEntry mStateMachineFileName;
+
+public:
+   StateMachineAsset();
+   virtual ~StateMachineAsset();
+
+   /// Engine.
+   static void initPersistFields();
+   virtual void copyTo(SimObject* object);
+
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(StateMachineAsset);
+
+   StringTableEntry getStateMachineFileName() { return mStateMachineFileName; }
+
+protected:
+   virtual void            initializeAsset(void) {}
+   virtual void            onAssetRefresh(void) {}
+};
+
+DefineConsoleType(TypeStateMachineAssetPtr, StateMachineAsset)
+
+//-----------------------------------------------------------------------------
+// TypeAssetId GuiInspectorField Class
+//-----------------------------------------------------------------------------
+class GuiInspectorTypeStateMachineAssetPtr : public GuiInspectorTypeFileName
+{
+   typedef GuiInspectorTypeFileName Parent;
+public:
+
+   GuiBitmapButtonCtrl  *mSMEdButton;
+
+   DECLARE_CONOBJECT(GuiInspectorTypeStateMachineAssetPtr);
+   static void consoleInit();
+
+   virtual GuiControl* constructEditControl();
+   virtual bool updateRects();
+};
+
+#endif
+

Engine/source/T3D/components/animation/animationComponent.cpp

@@ -72,7 +72,6 @@ IMPLEMENT_CALLBACK(AnimationComponent, onAnimationTrigger, void, (Component* obj
 AnimationComponent::AnimationComponent() : Component()
 {
    mNetworked = true;
-   mNetFlags.set(Ghostable | ScopeAlways);
 
    mFriendlyName = "Animation(Component)";
    mComponentType = "Render";
@@ -223,29 +222,17 @@ U32 AnimationComponent::packUpdate(NetConnection *con, U32 mask, BitStream *stre
 {
    U32 retMask = Parent::packUpdate(con, mask, stream);
 
-   //early test if we lack an owner, ghost-wise
-   //no point in trying, just re-queue the mask and go
-   if (!mOwner || con->getGhostIndex(mOwner) == -1)
+   for (int i = 0; i < MaxScriptThreads; i++)
    {
-      stream->writeFlag(false);
-      return retMask |= ThreadMask;
-   }
-   else
-   {
-      stream->writeFlag(true);
-
-      for (int i = 0; i < MaxScriptThreads; i++) 
+      Thread& st = mAnimationThreads[i];
+      if (stream->writeFlag((st.sequence != -1 || st.state == Thread::Destroy) && (mask & (ThreadMaskN << i))))
       {
-         Thread& st = mAnimationThreads[i];
-         if (stream->writeFlag( (st.sequence != -1 || st.state == Thread::Destroy) && (mask & (ThreadMaskN << i)) ) ) 
-         {
-            stream->writeInt(st.sequence,ThreadSequenceBits);
-            stream->writeInt(st.state,2);
-            stream->write(st.timescale);
-            stream->write(st.position);
-            stream->writeFlag(st.atEnd);
-            stream->writeFlag(st.transition);
-         }
+         stream->writeInt(st.sequence, ThreadSequenceBits);
+         stream->writeInt(st.state, 2);
+         stream->write(st.timescale);
+         stream->write(st.position);
+         stream->writeFlag(st.atEnd);
+         stream->writeFlag(st.transition);
       }
    }
 
@@ -256,29 +243,26 @@ void AnimationComponent::unpackUpdate(NetConnection *con, BitStream *stream)
 {
    Parent::unpackUpdate(con, stream);
 
-   if (stream->readFlag()) 
+   for (S32 i = 0; i < MaxScriptThreads; i++) 
    {
-      for (S32 i = 0; i < MaxScriptThreads; i++) 
+      if (stream->readFlag()) 
       {
-         if (stream->readFlag()) 
-         {
-            Thread& st = mAnimationThreads[i];
-            U32 seq = stream->readInt(ThreadSequenceBits);
-            st.state = stream->readInt(2);
-            stream->read( &st.timescale );
-            stream->read( &st.position );
-            st.atEnd = stream->readFlag();
-            bool transition = stream->readFlag();
-
-            if (!st.thread || st.sequence != seq && st.state != Thread::Destroy)
-               setThreadSequence(i, seq, false, transition);
-            else
-               updateThread(st);
-
-         }
+         Thread& st = mAnimationThreads[i];
+         U32 seq = stream->readInt(ThreadSequenceBits);
+         st.state = stream->readInt(2);
+         stream->read( &st.timescale );
+         stream->read( &st.position );
+         st.atEnd = stream->readFlag();
+         bool transition = stream->readFlag();
+
+         if (!st.thread || st.sequence != seq && st.state != Thread::Destroy)
+            setThreadSequence(i, seq, false, transition);
+         else
+            updateThread(st);
       }
    }
 }
+
 void AnimationComponent::processTick()
 {
    Parent::processTick();
@@ -327,9 +311,6 @@ const char *AnimationComponent::getThreadSequenceName(U32 slot)
 
 bool AnimationComponent::setThreadSequence(U32 slot, S32 seq, bool reset, bool transition, F32 transTime)
 {
-   if (!mOwnerShapeInstance)
-      return false;
-
    Thread& st = mAnimationThreads[slot];
    if (st.thread && st.sequence == seq && st.state == Thread::Play && !reset)
       return true;
@@ -340,7 +321,6 @@ bool AnimationComponent::setThreadSequence(U32 slot, S32 seq, bool reset, bool t
 
    if (seq < MaxSequenceIndex)
    {
-      setMaskBits(-1);
       setMaskBits(ThreadMaskN << slot);
       st.sequence = seq;
       st.transition = transition;
@@ -633,6 +613,9 @@ void AnimationComponent::advanceThreads(F32 dt)
    if (!mOwnerRenderInst)
       return;
 
+   if (mOwnerShapeInstance == nullptr || !getShape())
+      return;
+
    for (U32 i = 0; i < MaxScriptThreads; i++)
    {
       Thread& st = mAnimationThreads[i];
@@ -647,7 +630,7 @@ void AnimationComponent::advanceThreads(F32 dt)
             st.atEnd = true;
             updateThread(st);
 
-            if (!isGhost())
+            if (!isClientObject())
             {
                Con::executef(this, "onAnimationEnd", st.thread->getSequenceName());
             }
@@ -660,7 +643,7 @@ void AnimationComponent::advanceThreads(F32 dt)
             mOwnerShapeInstance->advanceTime(dt, st.thread);
          }
 
-         if (mOwnerShapeInstance && !isGhost())
+         if (mOwnerShapeInstance && !isClientObject())
          {
             for (U32 i = 1; i < 32; i++)
             {
@@ -672,8 +655,16 @@ void AnimationComponent::advanceThreads(F32 dt)
             }
          }
 
-         if (isGhost())
+         if (isClientObject())
+         {
             mOwnerShapeInstance->animate();
+            /*mOwnerShapeInstance->animateGround();
+            MatrixF groundTransform = mOwnerShapeInstance->getGroundTransform();
+            if (groundTransform != MatrixF::Identity)
+            {
+               mOwner->setPosition(groundTransform.getPosition());
+            }*/
+         }
       }
    }
 }

Engine/source/T3D/components/audio/SoundComponent.cpp

@@ -0,0 +1,422 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#include "T3D/components/audio/SoundComponent.h"
+#include "core/stream/bitStream.h"
+#include "sim/netConnection.h"
+
+#include "sfx/sfxSystem.h"
+#include "sfx/sfxSource.h"
+#include "sfx/sfxTrack.h"
+#include "sfx/sfxDescription.h"
+#include "T3D/sfx/sfx3DWorld.h"
+
+#include "sfx/sfxTrack.h"
+#include "sfx/sfxTypes.h"
+
+#include "renderInstance/renderPassManager.h"
+#include "gfx/gfxDrawUtil.h"
+
+// Timeout for non-looping sounds on a channel
+static SimTime sAudioTimeout = 500;
+
+extern bool gEditingMission;
+
+//////////////////////////////////////////////////////////////////////////
+// Constructor/Destructor
+//////////////////////////////////////////////////////////////////////////
+SoundComponent::SoundComponent() : Component()
+{
+   //These flags inform that, in this particular component, we network down to the client, which enables the pack/unpackData functions to operate
+   mNetworked = true;
+
+   mFriendlyName = "Sound(Component)";
+   mComponentType = "Sound";
+   mDescription = getDescriptionText("Stores up to 4 sounds for playback.");
+
+   for (U32 slotNum = 0; slotNum < MaxSoundThreads; slotNum++) {
+      mSoundThread[slotNum].play = false;
+      mSoundThread[slotNum].profile = 0;
+      mSoundThread[slotNum].sound = 0;
+
+      mSoundFile[slotNum] = NULL;
+      mPreviewSound[slotNum] = false;
+      mPlay[slotNum] = false;
+   }
+}
+
+SoundComponent::~SoundComponent()
+{
+}
+
+IMPLEMENT_CO_NETOBJECT_V1(SoundComponent);
+
+//Standard onAdd function, for when the component is created
+bool SoundComponent::onAdd()
+{
+   if (!Parent::onAdd())
+      return false;
+
+   for (U32 slotNum = 0; slotNum < MaxSoundThreads; slotNum++)
+      mPreviewSound[slotNum] = false;
+
+   return true;
+}
+
+//Standard onRemove function, when the component object is deleted
+void SoundComponent::onRemove()
+{
+   Parent::onRemove();
+}
+
+//This is called when the component has been added to an entity
+void SoundComponent::onComponentAdd()
+{
+   Parent::onComponentAdd();
+
+   Con::printf("We were added to an entity! SoundComponent reporting in for owner entity %i", mOwner->getId());
+}
+
+//This is called when the component has been removed from an entity
+void SoundComponent::onComponentRemove()
+{
+   Con::printf("We were removed from our entity! SoundComponent signing off for owner entity %i", mOwner->getId());
+   Parent::onComponentRemove();
+}
+
+//This is called any time a component is added to an entity. Every component currently owned by the entity is informed of the event. 
+//This allows you to do dependency behavior, like collisions being aware of a mesh component, etc
+void SoundComponent::componentAddedToOwner(Component *comp)
+{
+   for (S32 slotNum = 0; slotNum < MaxSoundThreads; slotNum++)
+   {
+      if (mPlay[slotNum])
+      {
+         playAudio(slotNum, mSoundFile[slotNum]);
+      }
+   }
+   Con::printf("Our owner entity has a new component being added! SoundComponent welcomes component %i of type %s", comp->getId(), comp->getClassRep()->getNameSpace());
+}
+
+//This is called any time a component is removed from an entity. Every component current owned by the entity is informed of the event.
+//This allows cleanup and dependency management.
+void SoundComponent::componentRemovedFromOwner(Component *comp)
+{
+   Con::printf("Our owner entity has a removed a component! SoundComponent waves farewell to component %i of type %s", comp->getId(), comp->getClassRep()->getNameSpace());
+}
+
+//Regular init persist fields function to set up static fields.
+void SoundComponent::initPersistFields()
+{
+   //addArray("Sounds", MaxSoundThreads);
+   addField("mSoundFile", TypeSFXTrackName, Offset(mSoundFile, SoundComponent), MaxSoundThreads, "If the text will not fit in the control, the deniedSound is played.");
+   addProtectedField("mPreviewSound", TypeBool, Offset(mPreviewSound, SoundComponent),
+      &_previewSound, &defaultProtectedGetFn, MaxSoundThreads, "Preview Sound", AbstractClassRep::FieldFlags::FIELD_ComponentInspectors);
+   addProtectedField("play", TypeBool, Offset(mPlay, SoundComponent),
+      &_autoplay, &defaultProtectedGetFn, MaxSoundThreads, "Whether playback of the emitter's sound should start as soon as the emitter object is added to the level.\n"
+      "If this is true, the emitter will immediately start to play when the level is loaded.");
+   //endArray("Sounds");
+   Parent::initPersistFields();
+}
+
+bool SoundComponent::_previewSound(void *object, const char *index, const char *data)
+{
+   U32 slotNum = (index != NULL) ? dAtoui(index) : 0;
+   SoundComponent* component = reinterpret_cast< SoundComponent* >(object);
+   if (!component->mPreviewSound[slotNum])
+      component->playAudio(slotNum, component->mSoundFile[slotNum]);
+   else
+      component->stopAudio(slotNum);
+   component->mPreviewSound[slotNum] = !component->mPreviewSound[slotNum];
+
+   return false;
+}
+
+bool SoundComponent::_autoplay(void *object, const char *index, const char *data)
+{
+   U32 slotNum = (index != NULL) ? dAtoui(index) : 0;
+   SoundComponent* component = reinterpret_cast< SoundComponent* >(object);
+   component->mPlay[slotNum] = dAtoui(data);
+   if (component->mPlay[slotNum])
+      component->playAudio(slotNum, component->mSoundFile[slotNum]);
+   else
+      component->stopAudio(slotNum);
+
+   return false;
+}
+
+U32 SoundComponent::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
+{
+   U32 retMask = Parent::packUpdate(con, mask, stream);
+
+   if (mask & InitialUpdateMask)
+   {
+      // mask off sounds that aren't playing
+      S32 slotNum;
+      for (slotNum = 0; slotNum < MaxSoundThreads; slotNum++)
+         if (!mSoundThread[slotNum].play)
+            mask &= ~(SoundMaskN << slotNum);
+   }
+
+   for (S32 slotNum = 0; slotNum < MaxSoundThreads; slotNum++)
+      stream->writeFlag(mPreviewSound[slotNum]);
+
+   if (stream->writeFlag(mask & SoundMask)) 
+   {
+      for (S32 slotNum = 0; slotNum < MaxSoundThreads; slotNum++) 
+      {
+         Sound& st = mSoundThread[slotNum];
+
+         if (stream->writeFlag(mask & (SoundMaskN << slotNum)))
+         {
+            if (stream->writeFlag(st.play))
+               //stream->writeRangedU32(st.profile->getId(), DataBlockObjectIdFirst,
+               //   DataBlockObjectIdLast);
+               stream->writeString(st.profile->getName());
+
+         }
+      }
+   }
+
+   return retMask;
+}
+
+void SoundComponent::unpackUpdate(NetConnection *con, BitStream *stream)
+{
+   Parent::unpackUpdate(con, stream);
+
+   for (S32 slotNum = 0; slotNum < MaxSoundThreads; slotNum++)
+      mPreviewSound[slotNum] = stream->readFlag();
+
+   if (stream->readFlag())
+   {
+      for (S32 slotNum = 0; slotNum < MaxSoundThreads; slotNum++)
+      {
+         if (stream->readFlag())
+         {
+            Sound& st = mSoundThread[slotNum];
+            st.play = stream->readFlag();
+            if (st.play)
+            {
+               //st.profile = (SFXTrack*)stream->readRangedU32(DataBlockObjectIdFirst,
+               //   DataBlockObjectIdLast);
+               char profileName[255];
+               stream->readString(profileName);
+
+               if (!Sim::findObject(profileName, st.profile))
+                  Con::errorf("Could not find SFXTrack");
+            }
+
+            //if (isProperlyAdded())
+               updateAudioState(st);
+         }
+      }
+   }
+}
+
+//This allows custom behavior in the event the owner is being edited
+void SoundComponent::onInspect()
+{
+}
+
+//This allows cleanup of the custom editor behavior if our owner stopped being edited
+void SoundComponent::onEndInspect()
+{
+}
+
+//Process tick update function, natch
+void SoundComponent::processTick()
+{
+   Parent::processTick();
+}
+
+//Client-side advance function
+void SoundComponent::advanceTime(F32 dt)
+{
+
+}
+
+//Client-side interpolation function
+void SoundComponent::interpolateTick(F32 delta)
+{
+
+}
+
+void SoundComponent::prepRenderImage(SceneRenderState *state)
+{
+   if (!mEnabled || !mOwner || !gEditingMission)
+      return;
+   ObjectRenderInst* ri = state->getRenderPass()->allocInst< ObjectRenderInst >();
+
+   ri->renderDelegate.bind(this, &SoundComponent::_renderObject);
+   ri->type = RenderPassManager::RIT_Editor;
+   ri->defaultKey = 0;
+   ri->defaultKey2 = 0;
+
+   state->getRenderPass()->addInst(ri);
+}
+
+void SoundComponent::_renderObject(ObjectRenderInst *ri,
+   SceneRenderState *state,
+   BaseMatInstance *overrideMat)
+{
+   if (overrideMat)
+      return;
+
+   GFXStateBlockDesc desc;
+   desc.setBlend(true);
+
+   MatrixF camera = GFX->getWorldMatrix();
+   camera.inverse();
+   Point3F pos = mOwner->getPosition();
+
+   for (S32 slotNum = 0; slotNum < MaxSoundThreads; slotNum++)
+   {
+      if (mPreviewSound[slotNum])
+      {
+         Sound& st = mSoundThread[slotNum];
+         if (st.sound && st.sound->getDescription())
+         {
+            F32 minRad = st.sound->getDescription()->mMinDistance;
+            F32 falloffRad = st.sound->getDescription()->mMaxDistance;
+            SphereF sphere(pos, falloffRad);
+            if (sphere.isContained(camera.getPosition()))
+               desc.setCullMode(GFXCullNone);
+
+            GFX->getDrawUtil()->drawSphere(desc, minRad, pos, ColorI(255, 0, 255, 64));
+            GFX->getDrawUtil()->drawSphere(desc, falloffRad, pos, ColorI(128, 0, 128, 64));
+         }
+      }
+   }
+}
+
+void SoundComponent::playAudio(U32 slotNum, SFXTrack* _profile)
+{
+   AssertFatal(slotNum < MaxSoundThreads, "ShapeBase::playAudio() bad slot index");
+   SFXTrack* profile = (_profile != NULL) ? _profile : mSoundFile[slotNum];
+   Sound& st = mSoundThread[slotNum];
+   if (profile && (!st.play || st.profile != profile))
+   {
+      setMaskBits(SoundMaskN << slotNum);
+      st.play = true;
+      st.profile = profile;
+      updateAudioState(st);
+   }
+}
+
+void SoundComponent::stopAudio(U32 slotNum)
+{
+   AssertFatal(slotNum < MaxSoundThreads, "ShapeBase::stopAudio() bad slot index");
+
+   Sound& st = mSoundThread[slotNum];
+   if (st.play)
+   {
+      st.play = false;
+      setMaskBits(SoundMaskN << slotNum);
+      updateAudioState(st);
+   }
+}
+
+void SoundComponent::updateServerAudio()
+{
+   // Timeout non-looping sounds
+   for (S32 slotNum = 0; slotNum < MaxSoundThreads; slotNum++) 
+   {
+      Sound& st = mSoundThread[slotNum];
+      if (st.play && st.timeout && st.timeout < Sim::getCurrentTime()) 
+      {
+         //clearMaskBits(SoundMaskN << slotNum);
+         st.play = false;
+      }
+   }
+}
+
+void SoundComponent::updateAudioState(Sound& st)
+{
+   SFX_DELETE(st.sound);
+
+   if (st.play && st.profile)
+   {
+      if (isClientObject())
+      {
+         //if (Sim::findObject(SimObjectId((uintptr_t)st.profile), st.profile))
+        // {
+            MatrixF transform = mOwner->getTransform();
+            st.sound = SFX->createSource(st.profile, &transform);
+            if (st.sound)
+               st.sound->play();
+         //}
+         else
+            st.play = false;
+      }
+      else
+      {
+         // Non-looping sounds timeout on the server
+         st.timeout = 0;
+         if (!st.profile->getDescription()->mIsLooping)
+            st.timeout = Sim::getCurrentTime() + sAudioTimeout;
+      }
+   }
+   else
+      st.play = false;
+}
+
+void SoundComponent::updateAudioPos()
+{
+   for (S32 slotNum = 0; slotNum < MaxSoundThreads; slotNum++)
+   {
+      SFXSource* source = mSoundThread[slotNum].sound;
+      if (source)
+         source->setTransform(mOwner->getTransform());
+   }
+}
+
+//----------------------------------------------------------------------------
+DefineEngineMethod(SoundComponent, playAudio, bool, (S32 slot, SFXTrack* track), (0, nullAsType<SFXTrack*>()),
+   "@brief Attach a sound to this shape and start playing it.\n\n"
+
+   "@param slot Audio slot index for the sound (valid range is 0 - 3)\n" // 3 = ShapeBase::MaxSoundThreads-1
+   "@param track SFXTrack to play\n"
+   "@return true if the sound was attached successfully, false if failed\n\n"
+
+   "@see stopAudio()\n")
+{
+   if (track && slot >= 0 && slot < SoundComponent::MaxSoundThreads) {
+      object->playAudio(slot, track);
+      return true;
+   }
+   return false;
+}
+
+DefineEngineMethod(SoundComponent, stopAudio, bool, (S32 slot), ,
+   "@brief Stop a sound started with playAudio.\n\n"
+
+   "@param slot audio slot index (started with playAudio)\n"
+   "@return true if the sound was stopped successfully, false if failed\n\n"
+
+   "@see playAudio()\n")
+{
+   if (slot >= 0 && slot < SoundComponent::MaxSoundThreads) {
+      object->stopAudio(slot);
+      return true;
+   }
+   return false;
+}

Engine/source/T3D/components/audio/SoundComponent.h

@@ -0,0 +1,129 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#ifndef EXAMPLE_COMPONENT_H
+#define EXAMPLE_COMPONENT_H
+#pragma once
+
+#ifndef COMPONENT_H
+#include "T3D/components/component.h"
+#endif
+#ifndef RENDER_COMPONENT_INTERFACE_H
+#include "T3D/components/render/renderComponentInterface.h"
+#endif
+
+class SFXSource;
+
+//SoundComponent
+//A basic example of the various functions you can utilize to make your own component!
+//This example doesn't really DO anything, persay, but you can readily copy it as a base
+//and use it as a starting point for your own.
+class SoundComponent : public Component, public RenderComponentInterface, public EditorInspectInterface
+{
+   typedef Component Parent;
+
+public:
+   enum PublicConstants
+   {
+      MaxSoundThreads = 4,            ///< Should be a power of 2
+   };
+
+   /// @name Network state masks
+   /// @{
+
+   ///
+   enum SoundComponentMasks
+   {
+      SoundMaskN = Parent::NextFreeMask << 6,       ///< Extends + MaxSoundThreads bits
+   };
+
+   enum BaseMaskConstants
+   {
+      SoundMask = (SoundMaskN << MaxSoundThreads) - SoundMaskN,
+   };
+   /// @name Scripted Sound
+   /// @{
+   struct Sound {
+      bool play;                    ///< Are we playing this sound?
+      SimTime timeout;              ///< Time until we stop playing this sound.
+      SFXTrack* profile;            ///< Profile on server
+      SFXSource* sound;             ///< Sound on client
+      Sound()
+      {
+         play = false;
+         timeout = 0;
+         profile = NULL;
+         sound = NULL;
+      }
+   };
+   Sound mSoundThread[MaxSoundThreads];
+   SFXTrack* mSoundFile[MaxSoundThreads];
+   bool mPreviewSound[MaxSoundThreads];
+   bool mPlay[MaxSoundThreads];
+   /// @}
+
+   SoundComponent();
+   virtual ~SoundComponent();
+   DECLARE_CONOBJECT(SoundComponent);
+
+   virtual bool onAdd();
+   virtual void onRemove();
+   static void initPersistFields();
+   static bool _previewSound(void *object, const char *index, const char *data);
+   static bool _autoplay(void *object, const char *index, const char *data);
+
+   virtual U32 packUpdate(NetConnection *con, U32 mask, BitStream *stream);
+   virtual void unpackUpdate(NetConnection *con, BitStream *stream);
+
+   virtual void onComponentRemove();
+   virtual void onComponentAdd();
+
+   virtual void componentAddedToOwner(Component *comp);
+   virtual void componentRemovedFromOwner(Component *comp);
+
+   virtual void onInspect();
+   virtual void onEndInspect();
+
+   virtual void processTick();
+   virtual void advanceTime(F32 dt);
+   virtual void interpolateTick(F32 delta);
+
+   void prepRenderImage(SceneRenderState* state);
+   void _renderObject(ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat);
+
+   virtual void playAudio(U32 slotNum, SFXTrack* profile = NULL);
+   virtual void stopAudio(U32 slot);
+   virtual void updateServerAudio();
+   virtual void updateAudioState(Sound& st);
+   virtual void updateAudioPos();
+
+   //why god why
+   virtual TSShape* getShape() { return NULL; };
+   Signal< void(RenderComponentInterface*) > onShapeChanged;
+   virtual TSShapeInstance* getShapeInstance() { return NULL; };
+   Signal< void(RenderComponentInterface*) > onShapeInstanceChanged;
+   virtual MatrixF getNodeTransform(S32 nodeIdx) { return MatrixF::Identity; };
+   virtual Vector<MatrixF> getNodeTransforms() { return NULL; };
+   virtual void setNodeTransforms(Vector<MatrixF> transforms) {};
+};
+
+#endif

Engine/source/T3D/components/camera/cameraComponent.cpp

@@ -79,6 +79,7 @@ CameraComponent::CameraComponent() : Component()
    mTargetNode = "";
 
    mUseParentTransform = true;
+   mNetworked = true;
 
    mFriendlyName = "Camera(Component)";
 }
@@ -202,7 +203,7 @@ void CameraComponent::setCameraFov(F32 fov)
 void CameraComponent::onCameraScopeQuery(NetConnection *cr, CameraScopeQuery * query)
 {
    // update the camera query
-   query->camera = this;
+   query->camera = mOwner;//this;
 
    if(GameConnection * con = dynamic_cast<GameConnection*>(cr))
    {
@@ -357,7 +358,8 @@ U32 CameraComponent::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
          mTargetNodeIdx = nodeIndex;
       }
 
-      stream->writeInt(mTargetNodeIdx, 32);
+      if(stream->writeFlag(mTargetNodeIdx > -1))
+         stream->writeInt(mTargetNodeIdx, 32);
       //send offsets here
 
       stream->writeCompressedPoint(mPosOffset);
@@ -382,7 +384,10 @@ void CameraComponent::unpackUpdate(NetConnection *con, BitStream *stream)
 
    if(stream->readFlag())
    {
-      mTargetNodeIdx = stream->readInt(32);
+      if (stream->readFlag())
+         mTargetNodeIdx = stream->readInt(32);
+      else
+         mTargetNodeIdx = -1;
 
       stream->readCompressedPoint(&mPosOffset);
 

Engine/source/T3D/components/collision/collisionComponent.cpp

@@ -125,8 +125,6 @@ EndImplementEnumType;
 //
 CollisionComponent::CollisionComponent() : Component()
 {
-   mNetFlags.set(Ghostable | ScopeAlways);
-
    mFriendlyName = "Collision(Component)";
 
    mOwnerRenderInterface = NULL;
@@ -144,10 +142,12 @@ CollisionComponent::CollisionComponent() : Component()
       StaticShapeObjectType | VehicleObjectType |
       VehicleBlockerObjectType | DynamicShapeObjectType | StaticObjectType | EntityObjectType | TriggerObjectType);
 
-   mPhysicsRep = NULL;
-   mPhysicsWorld = NULL;
+   mPhysicsRep = nullptr;
+   mPhysicsWorld = nullptr;
+
+   mTimeoutList = nullptr;
 
-   mTimeoutList = NULL;
+   mAnimated = false;
 }
 
 CollisionComponent::~CollisionComponent()

Engine/source/T3D/components/component.cpp

@@ -31,6 +31,7 @@
 #include "console/engineAPI.h"
 #include "sim/netConnection.h"
 #include "console/consoleInternal.h"
+#include "T3D/assets/MaterialAsset.h"
 
 #define DECLARE_NATIVE_COMPONENT( ComponentType )                   \
 	 Component* staticComponentTemplate = new ComponentType; \
@@ -52,7 +53,6 @@ Component::Component()
 
    mNetworked = false;
 
-
    // [tom, 1/12/2007] We manage the memory for the description since it
    // could be loaded from a file and thus massive. This is accomplished with
    // protected fields, but since they still call Con::getData() the field
@@ -66,7 +66,14 @@ Component::Component()
 
    mOriginatingAssetId = StringTable->EmptyString();
 
-   mNetFlags.set(Ghostable);
+   mIsServerObject = true;
+
+   componentIdx = 0;
+
+   mHidden = false;
+   mEnabled = true;
+
+   mDirtyMaskBits = 0;
 }
 
 Component::~Component()
@@ -198,7 +205,6 @@ void Component::onComponentRemove()
    {
       mOwner->onComponentAdded.remove(this, &Component::componentAddedToOwner);
       mOwner->onComponentRemoved.remove(this, &Component::componentRemovedFromOwner);
-      mOwner->onTransformSet.remove(this, &Component::ownerTransformSet);
    }
 
    mOwner = NULL;
@@ -212,7 +218,6 @@ void Component::setOwner(Entity* owner)
    {
       mOwner->onComponentAdded.remove(this, &Component::componentAddedToOwner);
       mOwner->onComponentRemoved.remove(this, &Component::componentRemovedFromOwner);
-      mOwner->onTransformSet.remove(this, &Component::ownerTransformSet);
 
       mOwner->removeComponent(this, false);
    }
@@ -223,11 +228,18 @@ void Component::setOwner(Entity* owner)
    {
       mOwner->onComponentAdded.notify(this, &Component::componentAddedToOwner);
       mOwner->onComponentRemoved.notify(this, &Component::componentRemovedFromOwner);
-      mOwner->onTransformSet.notify(this, &Component::ownerTransformSet);
    }
 
    if (isServerObject())
+   {
       setMaskBits(OwnerMask);
+
+      //if we have any outstanding maskbits, push them along to have the network update happen on the entity
+      if (mDirtyMaskBits != 0 && mOwner)
+      {
+         mOwner->setMaskBits(Entity::ComponentsUpdateMask);
+      }
+   }
 }
 
 void Component::componentAddedToOwner(Component *comp)
@@ -240,16 +252,19 @@ void Component::componentRemovedFromOwner(Component *comp)
    return;
 }
 
-void Component::ownerTransformSet(MatrixF *mat)
+void Component::setMaskBits(U32 orMask)
 {
-   return;
+   AssertFatal(orMask != 0, "Invalid net mask bits set.");
+   
+   if (mOwner)
+      mOwner->setComponentNetMask(this, orMask);
 }
 
 U32 Component::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
 {
-   U32 retMask = Parent::packUpdate(con, mask, stream);
+   U32 retMask = 0;
 
-   if (mask & OwnerMask)
+   /*if (mask & OwnerMask)
    {
       if (mOwner != NULL)
       {
@@ -274,7 +289,7 @@ U32 Component::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
       }
    }
    else
-      stream->writeFlag(false);
+      stream->writeFlag(false);*/
 
    if (stream->writeFlag(mask & EnableMask))
    {
@@ -299,9 +314,7 @@ U32 Component::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
 
 void Component::unpackUpdate(NetConnection *con, BitStream *stream)
 {
-   Parent::unpackUpdate(con, stream);
-
-   if (stream->readFlag())
+   /*if (stream->readFlag())
    {
       if (stream->readFlag())
       {
@@ -317,7 +330,7 @@ void Component::unpackUpdate(NetConnection *con, BitStream *stream)
          //it's being nulled out
          setOwner(NULL);
       }
-   }
+   }*/
 
    if (stream->readFlag())
    {
@@ -467,7 +480,7 @@ void Component::addComponentField(const char *fieldName, const char *desc, const
    else if (fieldType == StringTable->insert("vector"))
       fieldTypeMask = TypePoint3F;
    else if (fieldType == StringTable->insert("material"))
-      fieldTypeMask = TypeMaterialName;
+      fieldTypeMask = TypeMaterialAssetPtr;
    else if (fieldType == StringTable->insert("image"))
       fieldTypeMask = TypeImageFilename;
    else if (fieldType == StringTable->insert("shape"))
@@ -488,6 +501,7 @@ void Component::addComponentField(const char *fieldName, const char *desc, const
       fieldTypeMask = TypeGameObjectAssetPtr;
    else
       fieldTypeMask = TypeString;
+   field.mFieldTypeName = fieldType;
 
    field.mFieldType = fieldTypeMask;
 
@@ -528,7 +542,7 @@ const char * Component::getDescriptionText(const char *desc)
    if (desc == NULL)
       return NULL;
 
-   char *newDesc;
+   char *newDesc = "";
 
    // [tom, 1/12/2007] If it isn't a file, just do it the easy way
    if (!Platform::isFile(desc))
@@ -561,7 +575,7 @@ const char * Component::getDescriptionText(const char *desc)
    }
 
    str.close();
-   delete stream;
+   //delete stream;
 
    return newDesc;
 }

Engine/source/T3D/components/component.h

@@ -64,9 +64,9 @@ struct ComponentField
 /// 
 /// 
 //////////////////////////////////////////////////////////////////////////
-class Component : public NetObject, public UpdateInterface
+class Component : public SimObject, public UpdateInterface
 {
-   typedef NetObject Parent;
+   typedef SimObject Parent;
 
 protected:
    StringTableEntry mFriendlyName;
@@ -92,6 +92,10 @@ protected:
    StringTableEntry		      mOriginatingAssetId;
    AssetPtr<ComponentAsset>  mOriginatingAsset;
 
+   U32                        mDirtyMaskBits;
+
+   bool                 mIsServerObject;
+
 public:
    Component();
    virtual ~Component();
@@ -113,7 +117,8 @@ public:
    //This is called when a different component is removed from our owner entity
    virtual void componentRemovedFromOwner(Component *comp);  
 
-   virtual void ownerTransformSet(MatrixF *mat);
+   //Overridden by components that actually care
+   virtual void ownerTransformSet(MatrixF *mat) {}
 
    void setOwner(Entity* pOwner);
    inline Entity *getOwner() { return mOwner ? mOwner : NULL; }
@@ -190,6 +195,16 @@ public:
       NextFreeMask = BIT(5)
    };
 
+   virtual void setMaskBits(U32 orMask);
+   virtual void clearMaskBits() {
+      mDirtyMaskBits = 0;
+   }
+
+   bool isServerObject() { return mIsServerObject; }
+   bool isClientObject() { return !mIsServerObject; }
+
+   void setIsServerObject(bool isServerObj) { mIsServerObject = isServerObj; }
+
    virtual U32 packUpdate(NetConnection *con, U32 mask, BitStream *stream);
    virtual void unpackUpdate(NetConnection *con, BitStream *stream);
    /// @}

Engine/source/T3D/components/game/stateMachine.cpp

@@ -30,6 +30,10 @@ StateMachine::StateMachine()
    mStartingState = "";
 
    mCurCreateState = NULL;
+
+   mStateMachineFile = StringTable->EmptyString();
+
+   mCurCreateState = nullptr;
 }
 
 StateMachine::~StateMachine()

Engine/source/T3D/components/game/stateMachine.h

@@ -158,6 +158,8 @@ public:
    {
       if (index <= mFields.size())
          return mFields[index];
+
+      return StateField(); //return a blank one
    }
 
    Signal< void(StateMachine*, S32 stateIdx) > onStateChanged;

Engine/source/T3D/components/game/stateMachineComponent.cpp

@@ -57,7 +57,6 @@ StateMachineComponent::StateMachineComponent() : Component()
 
    //doesn't need to be networked
    mNetworked = false;
-   mNetFlags.clear();
 }
 
 StateMachineComponent::~StateMachineComponent()

Engine/source/T3D/components/physics/playerControllerComponent.cpp

@@ -119,8 +119,11 @@ PlayerControllerComponent::PlayerControllerComponent() : Component()
 
    mInputVelocity = Point3F(0, 0, 0);
 
-   mPhysicsRep = NULL;
-   mPhysicsWorld = NULL;
+   mPhysicsRep = nullptr;
+   mPhysicsWorld = nullptr;
+
+   mOwnerCollisionInterface = nullptr;
+   mIntegrationCount = 0;
 }
 
 PlayerControllerComponent::~PlayerControllerComponent()

Engine/source/T3D/components/physics/rigidBodyComponent.cpp

@@ -288,7 +288,7 @@ void RigidBodyComponent::processTick()
       return;
 
    // SINGLE PLAYER HACK!!!!
-   if (PHYSICSMGR->isSinglePlayer() && isClientObject() && getServerObject())
+   /*if (PHYSICSMGR->isSinglePlayer() && isClientObject() && getServerObject())
    {
       RigidBodyComponent *servObj = (RigidBodyComponent*)getServerObject();
       mOwner->setTransform(servObj->mState.getTransform());
@@ -296,7 +296,7 @@ void RigidBodyComponent::processTick()
       mRenderState[1] = servObj->mRenderState[1];
 
       return;
-   }
+   }*/
 
    // Store the last render state.
    mRenderState[0] = mRenderState[1];

Engine/source/T3D/components/render/meshComponent.cpp

@@ -45,52 +45,49 @@
 #include "core/strings/findMatch.h"
 #include "T3D/components/render/meshComponent_ScriptBinding.h"
 
+ImplementEnumType(BatchingMode,
+   "Type of mesh data available in a shape.\n"
+   "@ingroup gameObjects")
+{
+   MeshComponent::Individual, "Individual", "This mesh is rendered indivudally, wthout batching or instancing."
+},
+   { MeshComponent::StaticBatch, "Static Batching", "Statically batches this mesh together with others to reduce drawcalls." },
+   //{ MeshComponent::DynamicBatch, "Dynamic Batching", "Dynamical batches this mesh together with others to reduce drawcalls each frame." },
+  // { MeshComponent::Instanced, "Instanced", "This mesh is rendered as an instance, reducing draw overhead with others that share the same mesh and material." },
+      EndImplementEnumType;
+
 //////////////////////////////////////////////////////////////////////////
 // Constructor/Destructor
 //////////////////////////////////////////////////////////////////////////
-MeshComponent::MeshComponent() : Component()
+MeshComponent::MeshComponent() : Component(), mShape(nullptr), mRenderMode(Individual)
 {
-   mShapeName = StringTable->insert("");
-   mShapeAsset = StringTable->insert("");
-   mShapeInstance = NULL;
-
-   mChangingMaterials.clear();
-
-   mMaterials.clear();
-
    mFriendlyName = "Mesh Component";
    mComponentType = "Render";
 
    mDescription = getDescriptionText("Causes the object to render a non-animating 3d shape using the file provided.");
 
    mNetworked = true;
-   mNetFlags.set(Ghostable | ScopeAlways);
-}
 
-MeshComponent::~MeshComponent(){}
+   mShapeName = StringTable->EmptyString();
+   mShapeAsset = StringTable->EmptyString();
 
-IMPLEMENT_CO_NETOBJECT_V1(MeshComponent);
+   mMeshAsset = StringTable->EmptyString();
+   mMeshAssetId = StringTable->EmptyString();
 
-//==========================================================================================
-void MeshComponent::boneObject::addObject(SimObject* object)
-{
-   SceneObject* sc = dynamic_cast<SceneObject*>(object);
-
-   if(sc && mOwner)
-   {
-      if(TSShape* shape = mOwner->getShape())
-      {
-         S32 nodeID = shape->findNode(mBoneName);
+   mInterfaceData = new MeshRenderSystemInterface();
 
-         //we may have a offset on the shape's center
-         //so make sure we accomodate for that when setting up the mount offsets
-         MatrixF mat = mOwner->getNodeTransform(nodeID);
+   mRenderMode = Individual;
+}
 
-         mOwner->getOwner()->mountObject(sc, nodeID, mat);
-      }
-   }
+MeshComponent::~MeshComponent()
+{
+   if (mInterfaceData)
+      SAFE_DELETE(mInterfaceData);
 }
 
+IMPLEMENT_CO_NETOBJECT_V1(MeshComponent);
+
+//==========================================================================================
 bool MeshComponent::onAdd()
 {
    if(! Parent::onAdd())
@@ -106,6 +103,12 @@ void MeshComponent::onComponentAdd()
 {
    Parent::onComponentAdd();
 
+   if (isClientObject())
+      mInterfaceData->mIsClient = true;
+
+  // if (mInterfaceData != nullptr)
+  //   mInterfaceData->mIsClient = isClientObject();
+
    //get the default shape, if any
    updateShape();
 }
@@ -113,10 +116,6 @@ void MeshComponent::onComponentAdd()
 void MeshComponent::onRemove()
 {
    Parent::onRemove();
-
-   mMeshAsset.clear();
-
-   SAFE_DELETE(mShapeInstance);
 }
 
 void MeshComponent::onComponentRemove()
@@ -135,9 +134,14 @@ void MeshComponent::initPersistFields()
 {
    Parent::initPersistFields();
 
+   addGroup("Rendering");
+   addField("BatchingMode", TypeBatchingMode, Offset(mRenderMode, MeshComponent),
+      "The mode of batching this shape should be rendered with.");
+   endGroup("Rendering");
+
    //create a hook to our internal variables
    addGroup("Model");
-   addProtectedField("MeshAsset", TypeAssetId, Offset(mShapeAsset, MeshComponent), &_setMesh, &defaultProtectedGetFn, 
+   addProtectedField("MeshAsset", TypeShapeAssetPtr, Offset(mShapeAsset, MeshComponent), &_setMesh, &defaultProtectedGetFn,
       "The asset Id used for the mesh.", AbstractClassRep::FieldFlags::FIELD_ComponentInspectors);
    endGroup("Model");
 }
@@ -165,6 +169,9 @@ bool MeshComponent::_setShape( void *object, const char *index, const char *data
 bool MeshComponent::setMeshAsset(const char* assetName)
 {
    // Fetch the asset Id.
+   if (mInterfaceData == nullptr)
+      return false;
+
    mMeshAssetId = StringTable->insert(assetName);
 
    mMeshAsset = mMeshAssetId;
@@ -183,9 +190,129 @@ bool MeshComponent::setMeshAsset(const char* assetName)
    return true;
 }
 
+void MeshComponent::updateShape()
+{
+   if (mInterfaceData == nullptr)
+      return;
+
+   //if ((mShapeName && mShapeName[0] != '\0') || (mShapeAsset && mShapeAsset[0] != '\0'))
+   if ((mShapeName && mShapeName[0] != '\0') || (mMeshAssetId && mMeshAssetId[0] != '\0'))
+
+   {
+      if (mMeshAsset == NULL)
+         return;
+
+      mShape = mMeshAsset->getShape();
+
+      if (!mMeshAsset->getShape())
+         return;
+
+      setupShape();
+
+      //Do this on both the server and client
+      S32 materialCount = mMeshAsset->getShape()->materialList->getMaterialNameList().size();
+
+      if (isServerObject())
+      {
+         //we need to update the editor
+         for (U32 i = 0; i < mFields.size(); i++)
+         {
+            //find any with the materialslot title and clear them out
+            if (FindMatch::isMatch("MaterialSlot*", mFields[i].mFieldName, false))
+            {
+               setDataField(mFields[i].mFieldName, NULL, "");
+               mFields.erase(i);
+               continue;
+            }
+         }
+
+         //next, get a listing of our materials in the shape, and build our field list for them
+         char matFieldName[128];
+
+         if (materialCount > 0)
+            mComponentGroup = StringTable->insert("Materials");
+
+         for (U32 i = 0; i < materialCount; i++)
+         {
+            String materialname = mMeshAsset->getShape()->materialList->getMaterialName(i);
+            if (materialname == String("ShapeBounds"))
+               continue;
+
+            dSprintf(matFieldName, 128, "MaterialSlot%d", i);
+
+            addComponentField(matFieldName, "A material used in the shape file", "Material", materialname, "");
+         }
+
+         if (materialCount > 0)
+            mComponentGroup = "";
+      }
+
+      if (mOwner != NULL)
+      {
+         Point3F min, max, pos;
+         pos = mOwner->getPosition();
+
+         mOwner->getWorldToObj().mulP(pos);
+
+         min = mMeshAsset->getShape()->bounds.minExtents;
+         max = mMeshAsset->getShape()->bounds.maxExtents;
+
+         if (mInterfaceData)
+         {
+            mInterfaceData->mBounds.set(min, max);
+            mInterfaceData->mScale = mOwner->getScale();
+            mInterfaceData->mTransform = mOwner->getRenderTransform();
+         }
+
+         mOwner->setObjectBox(Box3F(min, max));
+
+         mOwner->resetWorldBox();
+
+         if (mOwner->getSceneManager() != NULL)
+            mOwner->getSceneManager()->notifyObjectDirty(mOwner);
+      }
+
+      if (isClientObject() && mInterfaceData)
+      {
+         if (mRenderMode == StaticBatch)
+         {
+            mInterfaceData->mStatic = true;
+
+            OptimizedPolyList geom;
+            MatrixF transform = mInterfaceData->mTransform;
+            mInterfaceData->mGeometry.setTransform(&transform, mInterfaceData->mScale);
+            mInterfaceData->mGeometry.setObject(mOwner);
+
+            mInterfaceData->mShapeInstance->buildPolyList(&mInterfaceData->mGeometry, 0);
+         }
+         else
+         {
+            mInterfaceData->mStatic = false;
+         }
+
+         MeshRenderSystem::rebuildBuffers();
+      }
+
+      //finally, notify that our shape was changed
+      onShapeInstanceChanged.trigger(this);
+   }
+}
+
+void MeshComponent::setupShape()
+{
+   mInterfaceData->mShapeInstance = new TSShapeInstance(mMeshAsset->getShape(), true);
+}
+
 void MeshComponent::_onResourceChanged( const Torque::Path &path )
 {
-   if ( path != Torque::Path( mShapeName ) )
+   if (mInterfaceData == nullptr)
+      return;
+
+   String filePath;
+   if (mMeshAsset)
+      filePath = Torque::Path(mMeshAsset->getShapeFilename());
+
+   if (!mMeshAsset || path != Torque::Path(mMeshAsset->getShapeFilename()) )
       return;
 
    updateShape();
@@ -216,6 +343,8 @@ U32 MeshComponent::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
    if (stream->writeFlag(mask & ShapeMask))
    {
       stream->writeString(mShapeName);
+
+      stream->writeInt(mRenderMode, 8);
    }
 
    if (stream->writeFlag( mask & MaterialMask ))
@@ -226,7 +355,7 @@ U32 MeshComponent::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
       {
          stream->writeInt(mChangingMaterials[i].slot, 16);
 
-         NetStringHandle matNameStr = mChangingMaterials[i].matName.c_str();
+         NetStringHandle matNameStr = mChangingMaterials[i].assetId.c_str();
          con->packNetStringHandleU(stream, matNameStr);
       }
 
@@ -243,6 +372,8 @@ void MeshComponent::unpackUpdate(NetConnection *con, BitStream *stream)
    if(stream->readFlag())
    {
       mShapeName = stream->readSTString();
+
+      mRenderMode = (RenderMode)stream->readInt(8);
       setMeshAsset(mShapeName);
       updateShape();
    }
@@ -256,7 +387,10 @@ void MeshComponent::unpackUpdate(NetConnection *con, BitStream *stream)
       {
          matMap newMatMap;
          newMatMap.slot = stream->readInt(16);
-         newMatMap.matName = String(con->unpackNetStringHandleU(stream).getString());
+         newMatMap.assetId = String(con->unpackNetStringHandleU(stream).getString());
+
+         //do the lookup, now
+         newMatMap.matAsset = AssetDatabase.acquireAsset<MaterialAsset>(newMatMap.assetId);
 
          mChangingMaterials.push_back(newMatMap);
       }
@@ -267,7 +401,7 @@ void MeshComponent::unpackUpdate(NetConnection *con, BitStream *stream)
 
 void MeshComponent::prepRenderImage( SceneRenderState *state )
 {
-   if (!mEnabled || !mOwner || !mShapeInstance)
+   /*if (!mEnabled || !mOwner || !mShapeInstance)
       return;
 
    Point3F cameraOffset;
@@ -300,114 +434,41 @@ void MeshComponent::prepRenderImage( SceneRenderState *state )
    rdata.setLightQuery(&query);
 
    MatrixF mat = mOwner->getRenderTransform();
-   Point3F renderPos = mat.getPosition();
-   EulerF renderRot = mat.toEuler();
-   mat.scale(objScale);
-   GFX->setWorldMatrix(mat);
-
-   mShapeInstance->render(rdata);
-}
-
-void MeshComponent::updateShape()
-{
-   bool isServer = isServerObject();
 
-   if ((mShapeName && mShapeName[0] != '\0') || (mShapeAsset && mShapeAsset[0] != '\0'))
+   if (mOwner->isMounted())
    {
-      if (mMeshAsset == NULL)
-         return;
-
-      mShape = mMeshAsset->getShape();
-
-      if (!mShape)
-         return;
-
-      setupShape();
-
-      //Do this on both the server and client
-      S32 materialCount = mShape->materialList->getMaterialNameList().size();
-
-      if(isServerObject())
-      {
-         //we need to update the editor
-         for (U32 i = 0; i < mFields.size(); i++)
-         {
-            //find any with the materialslot title and clear them out
-            if (FindMatch::isMatch("MaterialSlot*", mFields[i].mFieldName, false))
-            {
-               setDataField(mFields[i].mFieldName, NULL, "");
-               mFields.erase(i);
-               continue;
-            }
-         }
-
-         //next, get a listing of our materials in the shape, and build our field list for them
-         char matFieldName[128];
-
-         if(materialCount > 0)
-            mComponentGroup = StringTable->insert("Materials");
-
-         for(U32 i=0; i < materialCount; i++)
-         {
-            String materialname = mShape->materialList->getMaterialName(i);
-            if(materialname == String("ShapeBounds"))
-               continue;
+      MatrixF wrldPos = mOwner->getWorldTransform();
+      Point3F wrldPosPos = wrldPos.getPosition();
 
-            dSprintf(matFieldName, 128, "MaterialSlot%d", i);
-            
-            addComponentField(matFieldName, "A material used in the shape file", "TypeAssetId", materialname, "");
-         }
-
-         if(materialCount > 0)
-            mComponentGroup = "";
-      }
-
-      if(mOwner != NULL)
-      {
-         Point3F min, max, pos;
-         pos = mOwner->getPosition();
-
-         mOwner->getWorldToObj().mulP(pos);
+      Point3F mntPs = mat.getPosition();
+      EulerF mntRt = RotationF(mat).asEulerF();
 
-         min = mShape->bounds.minExtents;
-         max = mShape->bounds.maxExtents;
-
-         mShapeBounds.set(min, max);
-
-         mOwner->setObjectBox(Box3F(min, max));
-
-         if( mOwner->getSceneManager() != NULL )
-            mOwner->getSceneManager()->notifyObjectDirty( mOwner );
-      }
-
-      //finally, notify that our shape was changed
-      onShapeInstanceChanged.trigger(this);
+      bool tr = true;
    }
-}
 
-void MeshComponent::setupShape()
-{
-   mShapeInstance = new TSShapeInstance(mShape, true);
+   mat.scale(objScale);
+   GFX->setWorldMatrix(mat);
+
+   mShapeInstance->render(rdata);*/
 }
 
 void MeshComponent::updateMaterials()
 {
-   if (mChangingMaterials.empty() || !mShape)
+   if (mChangingMaterials.empty() || !mMeshAsset->getShape())
       return;
 
-   TSMaterialList* pMatList = mShapeInstance->getMaterialList();
+   TSMaterialList* pMatList = mInterfaceData->mShapeInstance->getMaterialList();
    pMatList->setTextureLookupPath(getShapeResource().getPath().getPath());
 
    const Vector<String> &materialNames = pMatList->getMaterialNameList();
    for ( S32 i = 0; i < materialNames.size(); i++ )
    {
-      const String &pName = materialNames[i];
-
       for(U32 m=0; m < mChangingMaterials.size(); m++)
       {
          if(mChangingMaterials[m].slot == i)
          {
-            pMatList->renameMaterial( i, mChangingMaterials[m].matName );
+            //Fetch the actual material asset
+            pMatList->renameMaterial( i, mChangingMaterials[m].matAsset->getMaterialDefinitionName());
          }
       }
 
@@ -415,22 +476,31 @@ void MeshComponent::updateMaterials()
    }
 
    // Initialize the material instances
-   mShapeInstance->initMaterialList();
+   mInterfaceData->mShapeInstance->initMaterialList();
 }
 
 MatrixF MeshComponent::getNodeTransform(S32 nodeIdx)
 {
-   if (mShape)
+   if (mInterfaceData != nullptr && mMeshAsset->getShape())
    {
       S32 nodeCount = getShape()->nodes.size();
 
       if(nodeIdx >= 0 && nodeIdx < nodeCount)
       {
          //animate();
-         MatrixF mountTransform = mShapeInstance->mNodeTransforms[nodeIdx];
-         mountTransform.mul(mOwner->getRenderTransform());
+         MatrixF nodeTransform = mInterfaceData->mShapeInstance->mNodeTransforms[nodeIdx];
+         const Point3F& scale = mOwner->getScale();
+
+         // The position of the node needs to be scaled.
+         Point3F position = nodeTransform.getPosition();
+         position.convolve(scale);
+         nodeTransform.setPosition(position);
+
+         MatrixF finalTransform = MatrixF::Identity;
+
+         finalTransform.mul(mOwner->getRenderTransform(), nodeTransform);
 
-         return mountTransform;
+         return finalTransform;
       }
    }
 
@@ -439,7 +509,7 @@ MatrixF MeshComponent::getNodeTransform(S32 nodeIdx)
 
 S32 MeshComponent::getNodeByName(String nodeName)
 {
-   if (mShape)
+   if (mMeshAsset->getShape())
    {
       S32 nodeIdx = getShape()->findNode(nodeName);
 
@@ -485,12 +555,18 @@ void MeshComponent::onDynamicModified(const char* slotName, const char* newValue
       if(slot == -1)
          return;
 
+      //Safe to assume the inbound value for the material will be a MaterialAsset, so lets do a lookup on the name
+      MaterialAsset* matAsset = AssetDatabase.acquireAsset<MaterialAsset>(newValue);
+      if (!matAsset)
+         return;
+
       bool found = false;
       for(U32 i=0; i < mChangingMaterials.size(); i++)
       {
          if(mChangingMaterials[i].slot == slot)
          {
-            mChangingMaterials[i].matName = String(newValue);
+            mChangingMaterials[i].matAsset = matAsset;
+            mChangingMaterials[i].assetId = newValue;
             found = true;
          }
       }
@@ -499,7 +575,8 @@ void MeshComponent::onDynamicModified(const char* slotName, const char* newValue
       {
          matMap newMatMap;
          newMatMap.slot = slot;
-         newMatMap.matName = String(newValue);
+         newMatMap.matAsset = matAsset;
+         newMatMap.assetId = newValue;
 
          mChangingMaterials.push_back(newMatMap);
       }
@@ -510,14 +587,31 @@ void MeshComponent::onDynamicModified(const char* slotName, const char* newValue
    Parent::onDynamicModified(slotName, newValue);
 }
 
-void MeshComponent::changeMaterial(U32 slot, const char* newMat)
+void MeshComponent::changeMaterial(U32 slot, MaterialAsset* newMat)
 {
    
    char fieldName[512];
 
    //update our respective field
    dSprintf(fieldName, 512, "materialSlot%d", slot);
-   setDataField(fieldName, NULL, newMat);
+   setDataField(fieldName, NULL, newMat->getAssetId());
+}
+
+bool MeshComponent::setMatInstField(U32 slot, const char* field, const char* value)
+{
+   TSMaterialList* pMatList = mInterfaceData->mShapeInstance->getMaterialList();
+   pMatList->setTextureLookupPath(getShapeResource().getPath().getPath());
+
+   MaterialParameters* params = pMatList->getMaterialInst(slot)->getMaterialParameters();
+
+   if (pMatList->getMaterialInst(slot)->getFeatures().hasFeature(MFT_DiffuseColor))
+   {
+      MaterialParameterHandle* handle = pMatList->getMaterialInst(slot)->getMaterialParameterHandle("DiffuseColor");
+
+      params->set(handle, LinearColorF(0, 0, 0));
+   }
+
+   return true;
 }
 
 void MeshComponent::onInspect()
@@ -526,4 +620,13 @@ void MeshComponent::onInspect()
 
 void MeshComponent::onEndInspect()
 {
+}
+
+void MeshComponent::ownerTransformSet(MatrixF *mat)
+{
+   if (mInterfaceData != nullptr)
+   {
+      MatrixF newTransform = *mat;
+      mInterfaceData->mTransform = newTransform;
+   }
 }

Engine/source/T3D/components/render/meshComponent.h

@@ -60,6 +60,8 @@
 #include "gfx/gfxVertexFormat.h"
 #endif
 
+#include "T3D/systems/render/meshRenderSystem.h"
+
 class TSShapeInstance;
 class SceneRenderState;
 //////////////////////////////////////////////////////////////////////////
@@ -84,37 +86,38 @@ protected:
    StringTableEntry		mShapeName;
    StringTableEntry		mShapeAsset;
    TSShape*		         mShape;
-   Box3F						mShapeBounds;
+   //Box3F						mShapeBounds;
    Point3F					mCenterOffset;
 
+   MeshRenderSystemInterface*  mInterfaceData;
+
    struct matMap
    {
-      String matName;
+      MaterialAsset* matAsset;
+      String assetId;
       U32 slot;
    };
 
    Vector<matMap>  mChangingMaterials;
    Vector<matMap>  mMaterials;
 
-   class boneObject : public SimGroup
+public:
+   enum RenderMode
    {
-      MeshComponent *mOwner;
-   public:
-      boneObject(MeshComponent *owner){ mOwner = owner; }
-
-      StringTableEntry mBoneName;
-      S32 mItemID;
-
-      virtual void addObject(SimObject *obj);
+      Individual = 0,
+      DynamicBatch,
+      StaticBatch,
+      Instanced
    };
 
-   Vector<boneObject*> mNodesList;
+protected:
+   RenderMode           mRenderMode;
 
 public:
    StringTableEntry       mMeshAssetId;
    AssetPtr<ShapeAsset>   mMeshAsset;
 
-   TSShapeInstance*       mShapeInstance;
+   //TSShapeInstance*       mShapeInstance;
 
 public:
    MeshComponent();
@@ -132,7 +135,7 @@ public:
    virtual U32 packUpdate(NetConnection *con, U32 mask, BitStream *stream);
    virtual void unpackUpdate(NetConnection *con, BitStream *stream);
 
-   Box3F getShapeBounds() { return mShapeBounds; }
+   Box3F getShapeBounds() { return mInterfaceData->mBounds; }
 
    virtual MatrixF getNodeTransform(S32 nodeIdx);
    S32 getNodeByName(String nodeName);
@@ -144,6 +147,8 @@ public:
    virtual void onComponentRemove();
    virtual void onComponentAdd();
 
+   virtual void ownerTransformSet(MatrixF *mat);
+
    static bool _setMesh(void *object, const char *index, const char *data);
    static bool _setShape(void *object, const char *index, const char *data);
    const char* _getShape(void *object, const char *data);
@@ -151,7 +156,7 @@ public:
    bool setMeshAsset(const char* assetName);
 
    virtual TSShape* getShape() { if (mMeshAsset)  return mMeshAsset->getShape(); else return NULL; }
-   virtual TSShapeInstance* getShapeInstance() { return mShapeInstance; }
+   virtual TSShapeInstance* getShapeInstance() { return mInterfaceData->mShapeInstance; }
 
    Resource<TSShape> getShapeResource() { return mMeshAsset->getShapeResource(); }
 
@@ -163,7 +168,8 @@ public:
 
    virtual void onDynamicModified(const char* slotName, const char* newValue);
 
-   void changeMaterial(U32 slot, const char* newMat);
+   void changeMaterial(U32 slot, MaterialAsset* newMat);
+   bool setMatInstField(U32 slot, const char* field, const char* value);
 
    virtual void onInspect();
    virtual void onEndInspect();
@@ -180,4 +186,7 @@ public:
    }
 };
 
+typedef MeshComponent::RenderMode BatchingMode;
+DefineEnumType(BatchingMode);
+
 #endif

Engine/source/T3D/components/render/meshComponent_ScriptBinding.h

@@ -126,6 +126,28 @@ DefineEngineMethod(MeshComponent, getNodePosition, Point3F,
    return Point3F(0, 0, 0);
 }
 
+DefineEngineMethod(MeshComponent, getNodeRotation, EulerF,
+   (S32 node), (-1),
+   "@brief Mount objB to this object at the desired slot with optional transform.\n\n"
+
+   "@param objB  Object to mount onto us\n"
+   "@param slot  Mount slot ID\n"
+   "@param txfm (optional) mount offset transform\n"
+   "@return true if successful, false if failed (objB is not valid)")
+{
+   if (node != -1)
+   {
+      //BUG: Unsure how it broke, but atm the default transform passed in here is rotated 180 degrees. This doesn't happen
+      //for the SceneObject mountobject method. Hackish, but for now, just default to a clean MatrixF::Identity
+      //object->mountObjectToNode( objB, node, /*MatrixF::Identity*/txfm.getMatrix() );
+      RotationF mat = object->getNodeTransform(node);
+
+      return mat.asEulerF(RotationF::Degrees);
+   }
+
+   return EulerF(0, 0, 0);
+}
+
 DefineEngineMethod(MeshComponent, getNodeByName, S32,
    (String nodeName), ,
    "@brief Mount objB to this object at the desired slot with optional transform.\n\n"
@@ -148,8 +170,14 @@ DefineEngineMethod(MeshComponent, getNodeByName, S32,
    return -1;
 }
 
-DefineEngineMethod(MeshComponent, changeMaterial, void, (U32 slot, const char* newMat), (0, ""),
+DefineEngineMethod(MeshComponent, changeMaterial, void, (U32 slot, MaterialAsset* newMat), (0, nullAsType<MaterialAsset*>()),
    "@brief Change one of the materials on the shape.\n\n")
 {
    object->changeMaterial(slot, newMat);
+}
+
+DefineEngineMethod(MeshComponent, setMatInstField, bool, (U32 slot, const char* field, const char* value), (0, "", ""),
+   "@brief Change one of the materials on the shape.\n\n")
+{
+   return object->setMatInstField(slot, field, value);
 }

Engine/source/T3D/entity.cpp

@@ -47,7 +47,9 @@
 #include "T3D/gameBase/std/stdMoveList.h"
 
 #include "T3D/prefab.h"
+#include "T3D/gameBase/gameConnection.h"
 
+#include <thread>
 //
 #include "gfx/sim/debugDraw.h"
 //
@@ -118,6 +120,8 @@ Entity::Entity()
 
    mInitialized = false;
 
+   mLifetimeMS = 0;
+
    mGameObjectAssetId = StringTable->insert("");
 
 }
@@ -147,6 +151,10 @@ void Entity::initPersistFields()
 
    endGroup("Transform");
 
+   addGroup("Misc");
+   addField("LifetimeMS", TypeS32, Offset(mLifetimeMS, Entity), "Object world orientation.");
+   endGroup("Misc");
+
    addGroup("GameObject");
    addProtectedField("gameObjectName", TypeGameObjectAssetPtr, Offset(mGameObjectAsset, Entity), &_setGameObject, &defaultProtectedGetFn,
       "The asset Id used for the game object this entity is based on.");
@@ -231,8 +239,19 @@ bool Entity::onAdd()
    addToScene();
 
    //Make sure we get positioned
-   setMaskBits(TransformMask);
-   setMaskBits(NamespaceMask);
+   if (isServerObject())
+   {
+      setMaskBits(TransformMask);
+      setMaskBits(NamespaceMask);
+   }
+   else
+   {
+      //We can shortcut the initialization here because stuff generally ghosts down in order, and onPostAdd isn't called on ghosts.
+      onPostAdd();
+   }
+
+   if (mLifetimeMS != 0)
+      mStartTimeMS = Platform::getRealMilliseconds();
 
    return true;
 }
@@ -245,6 +264,8 @@ void Entity::onRemove()
 
    onDataSet.removeAll();
 
+   mGameObjectAsset.clear();
+
    Parent::onRemove();
 }
 
@@ -258,6 +279,27 @@ void Entity::onPostAdd()
       mComponents[i]->onComponentAdd();
    }
 
+   //Set up the networked components
+   mNetworkedComponents.clear();
+   for (U32 i = 0; i < mComponents.size(); i++)
+   {
+      if (mComponents[i]->isNetworked())
+      {
+         NetworkedComponent netComp;
+         netComp.componentIndex = i;
+         netComp.updateState = NetworkedComponent::Adding;
+         netComp.updateMaskBits = -1;
+
+         mNetworkedComponents.push_back(netComp);
+      }
+   }
+
+   if (!mNetworkedComponents.empty())
+   {
+      setMaskBits(AddComponentsMask);
+      setMaskBits(ComponentsUpdateMask);
+   }
+
    if (isMethod("onAdd"))
       Con::executef(this, "onAdd");
 }
@@ -396,6 +438,14 @@ void Entity::processTick(const Move* move)
       mDelta.rot[1] = mRot.asQuatF();
 
       setTransform(getPosition(), mRot);
+
+      //Lifetime test
+      if (mLifetimeMS != 0)
+      {
+         S32 currentTime = Platform::getRealMilliseconds();
+         if (currentTime - mStartTimeMS >= mLifetimeMS)
+            deleteObject();
+      }
    }
 }
 
@@ -446,62 +496,107 @@ U32 Entity::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
       mathWrite(*stream, mObjBox);
    }
 
-   //pass our behaviors around
-   if (mask & ComponentsMask || mask & InitialUpdateMask)
+   if (stream->writeFlag(mask & AddComponentsMask))
    {
-      stream->writeFlag(true);
-      //now, we run through a list of our to-be-sent behaviors and begin sending them
-      //if any fail, we keep our list and re-queue the mask
-      S32 componentCount = mToLoadComponents.size();
+      U32 toAddComponentCount = 0;
 
-      //build our 'ready' list
-      //This requires both the instance and the instances' template to be prepped(if the template hasn't been ghosted,
-      //then we know we shouldn't be passing the instance's ghosts around yet)
-      U32 ghostedCompCnt = 0;
-      for (U32 i = 0; i < componentCount; i++)
+      for (U32 i = 0; i < mNetworkedComponents.size(); i++)
       {
-         if (con->getGhostIndex(mToLoadComponents[i]) != -1)
-            ghostedCompCnt++;
+         if (mNetworkedComponents[i].updateState == NetworkedComponent::Adding)
+         {
+            toAddComponentCount++;
+         }
       }
 
-      if (ghostedCompCnt != 0)
+      //you reaaaaally shouldn't have >255 networked components on a single entity
+      stream->writeInt(toAddComponentCount, 8);
+
+      for (U32 i = 0; i < mNetworkedComponents.size(); i++)
       {
-         stream->writeFlag(true);
+         NetworkedComponent::UpdateState state = mNetworkedComponents[i].updateState;
 
-         stream->writeFlag(mStartComponentUpdate);
+         if (mNetworkedComponents[i].updateState == NetworkedComponent::Adding)
+         {
+            const char* className = mComponents[mNetworkedComponents[i].componentIndex]->getClassName();
+            stream->writeString(className, strlen(className));
 
-         //if not all the behaviors have been ghosted, we'll need another pass
-         if (ghostedCompCnt != componentCount)
-            retMask |= ComponentsMask;
+            mNetworkedComponents[i].updateState = NetworkedComponent::Updating;
+         }
+      }
+   }
 
-         //write the currently ghosted behavior count
-         stream->writeInt(ghostedCompCnt, 16);
+   if (stream->writeFlag(mask & RemoveComponentsMask))
+   {
+      /*U32 toRemoveComponentCount = 0;
 
-         for (U32 i = 0; i < mToLoadComponents.size(); i++)
+      for (U32 i = 0; i < mNetworkedComponents.size(); i++)
+      {
+         if (mNetworkedComponents[i].updateState == NetworkedComponent::Adding)
          {
-            //now fetch them and pass the ghost
-            S32 ghostIndex = con->getGhostIndex(mToLoadComponents[i]);
-            if (ghostIndex != -1)
-            {
-               stream->writeInt(ghostIndex, NetConnection::GhostIdBitSize);
-               mToLoadComponents.erase(i);
-               i--;
+            toRemoveComponentCount++;
+         }
+      }
 
-               mStartComponentUpdate = false;
-            }
+      //you reaaaaally shouldn't have >255 networked components on a single entity
+      stream->writeInt(toRemoveComponentCount, 8);
+
+      for (U32 i = 0; i < mNetworkedComponents.size(); i++)
+      {
+         if (mNetworkedComponents[i].updateState == NetworkedComponent::Removing)
+         {
+            stream->writeInt(i, 16);
+         }
+      }*/
+
+      /*for (U32 i = 0; i < mNetworkedComponents.size(); i++)
+      {
+         if (mNetworkedComponents[i].updateState == NetworkedComponent::UpdateState::Removing)
+         {
+            removeComponent(mComponents[mNetworkedComponents[i].componentIndex], true);
+            mNetworkedComponents.erase(i);
+            i--;
+
+         }
+      }*/
+   }
+
+   //Update our components
+   if (stream->writeFlag(mask & ComponentsUpdateMask))
+   {
+      U32 toUpdateComponentCount = 0;
+
+      for (U32 i = 0; i < mNetworkedComponents.size(); i++)
+      {
+         if (mNetworkedComponents[i].updateState == NetworkedComponent::Updating)
+         {
+            toUpdateComponentCount++;
          }
       }
-      else if (componentCount)
+
+      //you reaaaaally shouldn't have >255 networked components on a single entity
+      stream->writeInt(toUpdateComponentCount, 8);
+
+      bool forceUpdate = false;
+
+      for (U32 i = 0; i < mNetworkedComponents.size(); i++)
       {
-         //on the odd chance we have behaviors to ghost, but NONE of them have been yet, just set the flag now
-         stream->writeFlag(false);
-         retMask |= ComponentsMask;
+         if (mNetworkedComponents[i].updateState == NetworkedComponent::Updating)
+         {
+            stream->writeInt(i, 8);
+
+            mNetworkedComponents[i].updateMaskBits = mComponents[mNetworkedComponents[i].componentIndex]->packUpdate(con, mNetworkedComponents[i].updateMaskBits, stream);
+
+            if (mNetworkedComponents[i].updateMaskBits != 0)
+               forceUpdate = true;
+            else
+               mNetworkedComponents[i].updateState = NetworkedComponent::None;
+         }
       }
-      else
-         stream->writeFlag(false);
+
+      //If we have leftover, we need to re-iterate our packing
+      if (forceUpdate)
+         setMaskBits(ComponentsUpdateMask);
    }
-   else
-      stream->writeFlag(false);
 
    /*if (stream->writeFlag(mask & NamespaceMask))
    {
@@ -594,25 +689,52 @@ void Entity::unpackUpdate(NetConnection *con, BitStream *stream)
       resetWorldBox();
    }
 
+   //AddComponentMask
    if (stream->readFlag())
    {
-      //are we passing any behaviors currently?
-      if (stream->readFlag())
+      U32 addedComponentCount = stream->readInt(8);
+
+      for (U32 i = 0; i < addedComponentCount; i++)
       {
-         //if we've just started the update, clear our behaviors
-         if (stream->readFlag())
-            clearComponents(false);
+         char className[256] = "";
+         stream->readString(className);
 
-         S32 componentCount = stream->readInt(16);
+         //Change to components, so iterate our list and create any new components
+         // Well, looks like we have to create a new object.
+         const char* componentType = className;
 
-         for (U32 i = 0; i < componentCount; i++)
+         ConsoleObject *object = ConsoleObject::create(componentType);
+
+         // Finally, set currentNewObject to point to the new one.
+         Component* newComponent = dynamic_cast<Component *>(object);
+
+         if (newComponent)
          {
-            S32 gIndex = stream->readInt(NetConnection::GhostIdBitSize);
-            addComponent(dynamic_cast<Component*>(con->resolveGhost(gIndex)));
+            addComponent(newComponent);
          }
       }
    }
 
+   //RemoveComponentMask
+   if (stream->readFlag())
+   {
+      
+   }
+
+   //ComponentUpdateMask
+   if (stream->readFlag())
+   {
+      U32 updatingComponents = stream->readInt(8);
+
+      for (U32 i = 0; i < updatingComponents; i++)
+      {
+         U32 updateComponentIndex = stream->readInt(8);
+
+         Component* comp = mComponents[updateComponentIndex];
+         comp->unpackUpdate(con, stream);
+      }
+   }
+
    /*if (stream->readFlag())
    {
       if (stream->readFlag())
@@ -640,6 +762,26 @@ void Entity::unpackUpdate(NetConnection *con, BitStream *stream)
    }*/
 }
 
+void Entity::setComponentNetMask(Component* comp, U32 mask)
+{
+   setMaskBits(Entity::ComponentsUpdateMask);
+
+   for (U32 i = 0; i < mNetworkedComponents.size(); i++)
+   {
+      U32 netCompId = mComponents[mNetworkedComponents[i].componentIndex]->getId();
+      U32 compId = comp->getId();
+
+      if (netCompId == compId && 
+         (mNetworkedComponents[i].updateState == NetworkedComponent::None || mNetworkedComponents[i].updateState == NetworkedComponent::Updating))
+      {
+         mNetworkedComponents[i].updateState = NetworkedComponent::Updating;
+         mNetworkedComponents[i].updateMaskBits |= mask;
+
+         break;
+      }
+   }
+}
+
 //Manipulation
 void Entity::setTransform(const MatrixF &mat)
 {
@@ -708,7 +850,7 @@ void Entity::setTransform(const MatrixF &mat)
    }
 }
 
-void Entity::setTransform(Point3F position, RotationF rotation)
+void Entity::setTransform(const Point3F& position, const RotationF& rotation)
 {
    MatrixF oldTransform = getTransform();
 
@@ -758,7 +900,11 @@ void Entity::setTransform(Point3F position, RotationF rotation)
       // Update the transforms.
       Parent::setTransform(newMat);
 
-      onTransformSet.trigger(&newMat);
+      U32 compCount = mComponents.size();
+      for (U32 i = 0; i < compCount; ++i)
+      {
+         mComponents[i]->ownerTransformSet(&newMat);
+      }
 
       Point3F newPos = newMat.getPosition();
       RotationF newRot = newMat;
@@ -776,7 +922,7 @@ void Entity::setRenderTransform(const MatrixF &mat)
    Parent::setRenderTransform(mat);
 }
 
-void Entity::setRenderTransform(Point3F position, RotationF rotation)
+void Entity::setRenderTransform(const Point3F& position, const RotationF& rotation)
 {
    if (isMounted())
    {
@@ -800,7 +946,11 @@ void Entity::setRenderTransform(Point3F position, RotationF rotation)
 
       Parent::setRenderTransform(newMat);
 
-      onTransformSet.trigger(&newMat);
+      U32 compCount = mComponents.size();
+      for (U32 i = 0; i < compCount; ++i)
+      {
+         mComponents[i]->ownerTransformSet(&newMat);
+      }
    }
 }
 
@@ -827,7 +977,7 @@ MatrixF Entity::getTransform()
    }
 }
 
-void Entity::setMountOffset(Point3F posOffset)
+void Entity::setMountOffset(const Point3F& posOffset)
 {
    if (isMounted())
    {
@@ -837,7 +987,7 @@ void Entity::setMountOffset(Point3F posOffset)
    }
 }
 
-void Entity::setMountRotation(EulerF rotOffset)
+void Entity::setMountRotation(const EulerF& rotOffset)
 {
    if (isMounted())
    {
@@ -961,11 +1111,12 @@ bool Entity::castRayRendered(const Point3F &start, const Point3F &end, RayInfo *
 
 bool Entity::buildPolyList(PolyListContext context, AbstractPolyList* polyList, const Box3F &box, const SphereF &sphere)
 {
-   Vector<BuildPolyListInterface*> updaters = getComponents<BuildPolyListInterface>();
+   Con::errorf("Build Poly List not yet implemented as a passthrough for Entity");
+   /*Vector<BuildPolyListInterface*> updaters = getComponents<BuildPolyListInterface>();
    for (Vector<BuildPolyListInterface*>::iterator it = updaters.begin(); it != updaters.end(); it++)
    {
       return (*it)->buildPolyList(context, polyList, box, sphere);
-   }
+   }*/
 
    return false;
 }
@@ -981,7 +1132,7 @@ void Entity::buildConvex(const Box3F& box, Convex* convex)
 
 //
 // Mounting and heirarchy manipulation
-void Entity::mountObject(SceneObject* objB, MatrixF txfm)
+void Entity::mountObject(SceneObject* objB, const MatrixF& txfm)
 {
    Parent::mountObject(objB, -1, txfm);
    Parent::addObject(objB);
@@ -1155,11 +1306,28 @@ bool Entity::addComponent(Component *comp)
    // Register the component with this owner.
    comp->setOwner(this);
 
+   comp->setIsServerObject(isServerObject());
+
    //if we've already been added and this is being added after the fact(at runtime), 
    //then just go ahead and call it's onComponentAdd so it can get to work
-   if (mInitialized)
+   //if (mInitialized)
+   {
       comp->onComponentAdd();
 
+      if (comp->isNetworked())
+      {
+         NetworkedComponent netComp;
+         netComp.componentIndex = mComponents.size() - 1;
+         netComp.updateState = NetworkedComponent::Adding;
+         netComp.updateMaskBits = -1;
+
+         mNetworkedComponents.push_back(netComp);
+
+         setMaskBits(AddComponentsMask);
+         setMaskBits(ComponentsUpdateMask);
+      }
+   }
+
    onComponentAdded.trigger(comp);
 
    return true;
@@ -1269,7 +1437,7 @@ Component *Entity::getComponent(String componentType)
          Namespace *NS = comp->getNamespace();
 
          //we shouldn't ever go past Component into net object, as we're no longer dealing with component classes
-         while (dStrcmp(NS->getName(), "NetObject"))
+         while (dStrcmp(NS->getName(), "SimObject"))
          {
             String namespaceName = NS->getName();
 
@@ -1437,7 +1605,7 @@ void Entity::onCameraScopeQuery(NetConnection* connection, CameraScopeQuery* que
    }
 }
 //
-void Entity::setObjectBox(Box3F objBox)
+void Entity::setObjectBox(const Box3F& objBox)
 {
    mObjBox = objBox;
    resetWorldBox();
@@ -1497,7 +1665,8 @@ void Entity::notifyComponents(String signalFunction, String argA, String argB, S
 
 void Entity::setComponentsDirty()
 {
-   if (mToLoadComponents.empty())
+   bool tmp = true;
+   /*if (mToLoadComponents.empty())
       mStartComponentUpdate = true;
 
    //we need to build a list of behaviors that need to be pushed across the network
@@ -1522,7 +1691,7 @@ void Entity::setComponentsDirty()
       }
    }
 
-   setMaskBits(ComponentsMask);
+   setMaskBits(ComponentsMask);*/
 }
 
 void Entity::setComponentDirty(Component *comp, bool forceUpdate)
@@ -1537,8 +1706,8 @@ void Entity::setComponentDirty(Component *comp, bool forceUpdate)
       }
    }
 
-   if (!found)
-      return;
+   //if (!found)
+   //   return;
 
    //if(mToLoadComponents.empty())
    //	mStartComponentUpdate = true;
@@ -1654,7 +1823,7 @@ ConsoleMethod(Entity, addComponents, void, 2, 2, "() - Add all fielded behaviors
    object->addComponents();
 }*/
 
-ConsoleMethod(Entity, addComponent, bool, 3, 3, "(Component* bi) - Add a behavior to the object\n"
+ConsoleMethod(Entity, addComponent, bool, 3, 3, "(ComponentInstance bi) - Add a behavior to the object\n"
    "@param bi The behavior instance to add"
    "@return (bool success) Whether or not the behavior was successfully added")
 {
@@ -1679,7 +1848,7 @@ ConsoleMethod(Entity, addComponent, bool, 3, 3, "(Component* bi) - Add a behavio
    return false;
 }
 
-ConsoleMethod(Entity, removeComponent, bool, 3, 4, "(Component* bi, [bool deleteBehavior = true])\n"
+ConsoleMethod(Entity, removeComponent, bool, 3, 4, "(ComponentInstance bi, [bool deleteBehavior = true])\n"
    "@param bi The behavior instance to remove\n"
    "@param deleteBehavior Whether or not to delete the behavior\n"
    "@return (bool success) Whether the behavior was successfully removed")
@@ -1834,4 +2003,43 @@ DefineConsoleMethod(Entity, notify, void, (String signalFunction, String argA, S
       return;
 
    object->notifyComponents(signalFunction, argA, argB, argC, argD, argE);
+}
+
+DefineConsoleFunction(findEntitiesByTag, const char*, (SimGroup* searchingGroup, String tags), (nullAsType<SimGroup*>(), ""),
+"Finds all entities that have the provided tags.\n"
+"@param searchingGroup The SimGroup to search inside. If null, we'll search the entire dictionary(this can be slow!).\n"
+"@param tags Word delimited list of tags to search for. If multiple tags are included, the list is eclusively parsed, requiring all tags provided to be found on an entity for a match.\n"
+"@return A word list of IDs of entities that match the tag search terms.")
+{
+   //if (tags.isEmpty())
+      return "";
+
+   /*if (searchingGroup == nullptr)
+   {
+      searchingGroup = Sim::getRootGroup();
+   }
+
+   StringTableEntry entityStr = StringTable->insert("Entity");
+
+   std::thread threadBob;
+
+   std::thread::id a = threadBob.get_id();
+   std::thread::id b = std::this_thread::get_id().;
+
+   if (a == b)
+   {
+      //do
+   }
+
+   for (SimGroup::iterator itr = searchingGroup->begin(); itr != searchingGroup->end(); itr++)
+   {
+      Entity* ent = dynamic_cast<Entity*>((*itr));
+
+      if (ent != nullptr)
+      {
+         ent->mTags.
+      }
+   }
+
+   object->notifyComponents(signalFunction, argA, argB, argC, argD, argE);*/
 }

Engine/source/T3D/entity.h

@@ -58,7 +58,27 @@ private:
 
    Vector<Component*>         mComponents;
 
-   Vector<Component*>         mToLoadComponents;
+   //Bit of helper data to let us track and manage the adding, removal and updating of networked components
+   struct NetworkedComponent
+   {
+      U32 componentIndex;
+
+      enum UpdateState
+      {
+         None,
+         Adding,
+         Removing,
+         Updating
+      };
+
+      UpdateState updateState;
+
+      U32 updateMaskBits;
+   };
+
+   Vector<NetworkedComponent> mNetworkedComponents;
+
+   U32                        mComponentNetMask;
 
    bool                       mStartComponentUpdate;
 
@@ -69,10 +89,12 @@ private:
 
    bool mInitialized;
 
+   String mTags;
+
    Signal< void(Component*) > onComponentAdded;
    Signal< void(Component*) > onComponentRemoved;
 
-   Signal< void(MatrixF*) > onTransformSet;
+   S32                       mLifetimeMS;
 
 protected:
 
@@ -105,10 +127,12 @@ public:
    {
       TransformMask = Parent::NextFreeMask << 0,
       BoundsMask = Parent::NextFreeMask << 1,
-      ComponentsMask = Parent::NextFreeMask << 2,
-      NoWarpMask = Parent::NextFreeMask << 3,
-      NamespaceMask = Parent::NextFreeMask << 4,
-      NextFreeMask = Parent::NextFreeMask << 5
+      ComponentsUpdateMask = Parent::NextFreeMask << 2,
+      AddComponentsMask = Parent::NextFreeMask << 3,
+      RemoveComponentsMask = Parent::NextFreeMask << 4,
+      NoWarpMask = Parent::NextFreeMask << 5,
+      NamespaceMask = Parent::NextFreeMask << 6,
+      NextFreeMask = Parent::NextFreeMask << 7
    };
 
    StateDelta mDelta;
@@ -116,6 +140,8 @@ public:
 
    Move lastMove;
 
+   S32      mStartTimeMS;
+
    //
    Entity();
    ~Entity();
@@ -126,14 +152,14 @@ public:
    virtual void setTransform(const MatrixF &mat);
    virtual void setRenderTransform(const MatrixF &mat);
 
-   void setTransform(Point3F position, RotationF rotation);
+   void setTransform(const Point3F& position, const RotationF& rotation);
 
-   void setRenderTransform(Point3F position, RotationF rotation);
+   void setRenderTransform(const Point3F& position, const RotationF& rotation);
 
    virtual MatrixF getTransform();
    virtual Point3F getPosition() const { return mPos; }
 
-   void setRotation(RotationF rotation) {
+   void setRotation(const RotationF& rotation) {
       mRot = rotation;
       setMaskBits(TransformMask);
    };
@@ -141,8 +167,8 @@ public:
 
    static bool _setGameObject(void *object, const char *index, const char *data);
 
-   void setMountOffset(Point3F posOffset);
-   void setMountRotation(EulerF rotOffset);
+   void setMountOffset(const Point3F& posOffset);
+   void setMountRotation(const EulerF& rotOffset);
 
    //static bool _setEulerRotation( void *object, const char *index, const char *data );
    static bool _setPosition(void *object, const char *index, const char *data);
@@ -155,7 +181,7 @@ public:
    virtual void getRenderMountTransform(F32 delta, S32 index, const MatrixF &xfm, MatrixF *outMat);
 
    virtual void mountObject(SceneObject *obj, S32 node, const MatrixF &xfm = MatrixF::Identity);
-   void mountObject(SceneObject* objB, MatrixF txfm);
+   void mountObject(SceneObject* objB, const MatrixF& txfm);
    void onMount(SceneObject *obj, S32 node);
    void onUnmount(SceneObject *obj, S32 node);
 
@@ -163,6 +189,9 @@ public:
    /// @param  client   Client that is now controlling this object
    virtual void setControllingClient(GameConnection *client);
 
+   //
+   //Networking
+   //
    // NetObject
    U32 packUpdate(NetConnection *conn, U32 mask, BitStream *stream);
    void unpackUpdate(NetConnection *conn, BitStream *stream);
@@ -170,6 +199,8 @@ public:
    void setComponentsDirty();
    void setComponentDirty(Component *comp, bool forceUpdate = false);
 
+   void setComponentNetMask(Component* comp, U32 mask);
+
    //Components
    virtual bool deferAddingComponents() const { return true; }
 
@@ -187,7 +218,7 @@ public:
       return mComponents.size(); 
    }
 
-   virtual void setObjectBox(Box3F objBox);
+   virtual void setObjectBox(const Box3F& objBox);
 
    void resetWorldBox() { Parent::resetWorldBox(); }
    void resetObjectBox() { Parent::resetObjectBox(); }

Engine/source/T3D/systems/componentSystem.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "console/engineAPI.h"
+
+template<typename T>
+class SystemInterface
+{
+public:
+   bool mIsEnabled;
+   bool mIsServer;
+
+   static Vector<T*> all;
+
+   SystemInterface()
+   {
+      all.push_back((T*)this);
+   }
+
+   virtual ~SystemInterface()
+   {
+      for (U32 i = 0; i < all.size(); i++)
+      {
+         if (all[i] == (T*)this)
+         {
+            all.erase(i);
+            return;
+         }
+      }
+   }
+};
+template<typename T> Vector<T*> SystemInterface<T>::all(0);

Engine/source/T3D/systems/render/meshRenderSystem.cpp

@@ -0,0 +1,378 @@
+#include "T3D/systems/render/meshRenderSystem.h"
+#include "gfx/gfxTransformSaver.h"
+#include "lighting/lightQuery.h"
+
+#include "renderInstance/renderPassManager.h"
+#include "materials/materialManager.h"
+#include "materials/baseMatInstance.h"
+
+Vector<MeshRenderSystem::BufferMaterials> MeshRenderSystem::mBufferMaterials(0);
+Vector<MeshRenderSystem::BufferSet> MeshRenderSystem::mStaticBuffers(0);
+
+void MeshRenderSystem::render(SceneManager *sceneManager, SceneRenderState* state)
+{
+   if (sceneManager == nullptr || state == nullptr)
+      return;
+
+   Frustum viewFrustum = state->getCullingFrustum();
+   MatrixF camTransform = state->getCameraTransform();
+
+   U32 count = MeshRenderSystemInterface::all.size();
+   for (U32 i = 0; i < count; i++)
+   {
+      //Server side items exist for data, but we don't actually render them
+      bool isClient = MeshRenderSystemInterface::all[i]->mIsClient;
+      if (!MeshRenderSystemInterface::all[i]->mIsClient)
+         continue;
+
+      bool isStatic = MeshRenderSystemInterface::all[i]->mStatic;
+      if (MeshRenderSystemInterface::all[i]->mStatic)
+         continue;
+
+      //First, do frustum culling
+      if (viewFrustum.isCulled(MeshRenderSystemInterface::all[i]->mBounds))
+         continue;
+
+      // Set the query box for the container query.  Never
+      // make it larger than the frustum's AABB.  In the editor,
+      // always query the full frustum as that gives objects
+      // the opportunity to render editor visualizations even if
+      // they are otherwise not in view.
+      if (!state->getCullingFrustum().getBounds().isOverlapped(state->getRenderArea()))
+      {
+         // This handles fringe cases like flying backwards into a zone where you
+         // end up pretty much standing on a zone border and looking directly into
+         // its "walls".  In that case the traversal area will be behind the frustum
+         // (remember that the camera isn't where visibility starts, it's the near
+         // distance).
+
+         continue;
+      }
+
+      //We can then sort our objects by range since we have it already, so we can do occlusion culling be rendering front-to-back
+
+      //if we've made it this far, call down to the render function to actually display our stuff
+      renderInterface(i, state);
+   }
+
+   //Static Batch rendering
+   if ( /*!mMaterialInst ||*/ !state)
+      return;
+
+   BaseMatInstance *matInst = MATMGR->getWarningMatInstance();
+
+   // Get a handy pointer to our RenderPassmanager
+   RenderPassManager *renderPass = state->getRenderPass();
+
+   for (U32 i = 0; i < mStaticBuffers.size(); i++)
+   {
+      for (U32 b = 0; b < mStaticBuffers[i].buffers.size(); b++)
+      {
+         if (mStaticBuffers[i].buffers[b].vertData.empty())
+            continue;
+
+         MeshRenderInst *ri = renderPass->allocInst<MeshRenderInst>();
+
+         // Set our RenderInst as a standard mesh render
+         ri->type = RenderPassManager::RIT_Mesh;
+
+         //If our material has transparency set on this will redirect it to proper render bin
+         if (matInst->getMaterial()->isTranslucent())
+         {
+            ri->type = RenderPassManager::RIT_Translucent;
+            ri->translucentSort = true;
+         }
+
+         // Calculate our sorting point
+         if (state)
+         {
+            // Calculate our sort point manually.
+            const Box3F& rBox = Box3F(1000);// getRenderWorldBox();
+            ri->sortDistSq = rBox.getSqDistanceToPoint(state->getCameraPosition());
+         }
+         else
+            ri->sortDistSq = 0.0f;
+
+         // Set up our transforms
+         MatrixF objectToWorld = MatrixF::Identity;//getRenderTransform();
+                                                   //objectToWorld.scale(getScale());
+
+         ri->objectToWorld = renderPass->allocUniqueXform(objectToWorld);
+         ri->worldToCamera = renderPass->allocSharedXform(RenderPassManager::View);
+         ri->projection = renderPass->allocSharedXform(RenderPassManager::Projection);
+
+         // If our material needs lights then fill the RIs 
+         // light vector with the best lights.
+         /*if (matInst->isForwardLit())
+         {
+         LightQuery query;
+         query.init(getWorldSphere());
+         query.getLights(ri->lights, 8);
+         }*/
+
+         // Make sure we have an up-to-date backbuffer in case
+         // our Material would like to make use of it
+         // NOTICE: SFXBB is removed and refraction is disabled!
+         //ri->backBuffTex = GFX->getSfxBackBuffer();
+
+         // Set our Material
+         ri->matInst = matInst;
+
+         // Set up our vertex buffer and primitive buffer
+         ri->vertBuff = &mStaticBuffers[i].buffers[b].vertexBuffer;
+         ri->primBuff = &mStaticBuffers[i].buffers[b].primitiveBuffer;
+
+         ri->prim = renderPass->allocPrim();
+         ri->prim->type = GFXTriangleList;
+         ri->prim->minIndex = 0;
+         ri->prim->startIndex = 0;
+         ri->prim->numPrimitives = mStaticBuffers[i].buffers[b].primData.size();
+         ri->prim->startVertex = 0;
+         ri->prim->numVertices = mStaticBuffers[i].buffers[b].vertData.size();
+
+         // We sort by the material then vertex buffer
+         ri->defaultKey = matInst->getStateHint();
+         ri->defaultKey2 = (uintptr_t)ri->vertBuff;
+
+                                                    // Submit our RenderInst to the RenderPassManager
+         state->getRenderPass()->addInst(ri);
+      }
+   }
+}
+
+void MeshRenderSystem::renderInterface(U32 interfaceIndex, SceneRenderState* state)
+{
+   //Fetch
+   MeshRenderSystemInterface* interface = MeshRenderSystemInterface::all[interfaceIndex];
+
+   if (interface->mShapeInstance == nullptr)
+      return;
+
+   Point3F cameraOffset;
+   interface->mTransform.getColumn(3, &cameraOffset);
+   cameraOffset -= state->getDiffuseCameraPosition();
+   F32 dist = cameraOffset.len();
+   if (dist < 0.01f)
+      dist = 0.01f;
+
+   Point3F objScale = interface->mScale;
+   F32 invScale = (1.0f / getMax(getMax(objScale.x, objScale.y), objScale.z));
+
+   interface->mShapeInstance->setDetailFromDistance(state, dist * invScale);
+
+   if (interface->mShapeInstance->getCurrentDetail() < 0)
+      return;
+
+   GFXTransformSaver saver;
+
+   // Set up our TS render state.
+   TSRenderState rdata;
+   rdata.setSceneState(state);
+   rdata.setFadeOverride(1.0f);
+   rdata.setOriginSort(false);
+
+   // We might have some forward lit materials
+   // so pass down a query to gather lights.
+   LightQuery query;
+   query.init(interface->mSphere);
+   rdata.setLightQuery(&query);
+
+   MatrixF mat = interface->mTransform;
+
+   mat.scale(objScale);
+   GFX->setWorldMatrix(mat);
+
+   interface->mShapeInstance->render(rdata);
+}
+
+void MeshRenderSystem::rebuildBuffers()
+{
+   U32 BUFFER_SIZE = 65000;
+   Vector<U32> tempIndices;
+   tempIndices.reserve(4);
+
+   Box3F newBounds = Box3F::Zero;
+
+   mStaticBuffers.clear();
+
+   for (U32 i = 0; i < MeshRenderSystemInterface::all.size(); i++)
+   {
+      if (!MeshRenderSystemInterface::all[i]->mIsEnabled)
+         continue;
+
+      if (!MeshRenderSystemInterface::all[i]->mIsClient || !MeshRenderSystemInterface::all[i]->mStatic)
+         continue;
+
+      //TODO: Properly re-implement StaticElements to container owner interfaces and buffer sets
+      for (U32 j = 0; j < MeshRenderSystemInterface::all[i]->mGeometry.mPolyList.size(); j++)
+      {
+         const OptimizedPolyList::Poly& poly = MeshRenderSystemInterface::all[i]->mGeometry.mPolyList[j];
+
+         if (poly.vertexCount < 3)
+            continue;
+
+         tempIndices.setSize(poly.vertexCount);
+         dMemset(tempIndices.address(), 0, poly.vertexCount);
+
+         if (poly.type == OptimizedPolyList::TriangleStrip ||
+            poly.type == OptimizedPolyList::TriangleFan)
+         {
+            tempIndices[0] = 0;
+            U32 idx = 1;
+
+            for (U32 k = 1; k < poly.vertexCount; k += 2)
+               tempIndices[idx++] = k;
+
+            for (U32 k = ((poly.vertexCount - 1) & (~0x1)); k > 0; k -= 2)
+               tempIndices[idx++] = k;
+         }
+         else if (poly.type == OptimizedPolyList::TriangleList)
+         {
+            for (U32 k = 0; k < poly.vertexCount; k++)
+               tempIndices[k] = k;
+         }
+         else
+            continue;
+
+         //got our data, now insert it into the correct buffer!
+         S32 bufferId = findBufferSetByMaterial(poly.material);
+
+         if (bufferId == -1)
+         {
+            //add a new buffer set if we didn't get a match!
+            BufferSet newSet;
+            newSet.surfaceMaterialId = poly.material;
+
+            mStaticBuffers.push_back(newSet);
+
+            bufferId = mStaticBuffers.size() - 1;
+         }
+
+         //see if this would push us over our buffer size limit, if it is, make a new buffer for this set
+         if (mStaticBuffers[bufferId].buffers.last().vertData.size() + 3 > BUFFER_SIZE
+            || mStaticBuffers[bufferId].buffers.last().primData.size() + 1 > BUFFER_SIZE)
+         {
+            //yep, we'll overstep with this, so spool up a new buffer in this set
+            BufferSet::Buffers newBuffer = BufferSet::Buffers();
+            mStaticBuffers[bufferId].buffers.push_back(newBuffer);
+         }
+
+         const U32& firstIdx = MeshRenderSystemInterface::all[i]->mGeometry.mIndexList[poly.vertexStart];
+         const OptimizedPolyList::VertIndex& firstVertIdx = MeshRenderSystemInterface::all[i]->mGeometry.mVertexList[firstIdx];
+
+         //Vector<Point3F> geomPoints = MeshRenderSystemInterface::all[i]->mGeometry.mPoints;
+         //Vector<Point3F> geomNormals = MeshRenderSystemInterface::all[i]->mGeometry.mNormals;
+         //Vector<Point2F> geoUVs = MeshRenderSystemInterface::all[i]->mGeometry.mUV0s;
+
+         for (U32 k = 1; k < poly.vertexCount - 1; k++)
+         {
+            const U32& secondIdx = MeshRenderSystemInterface::all[i]->mGeometry.mIndexList[poly.vertexStart + tempIndices[k]];
+            const U32& thirdIdx = MeshRenderSystemInterface::all[i]->mGeometry.mIndexList[poly.vertexStart + tempIndices[k + 1]];
+
+            const OptimizedPolyList::VertIndex& secondVertIdx = MeshRenderSystemInterface::all[i]->mGeometry.mVertexList[secondIdx];
+            const OptimizedPolyList::VertIndex& thirdVertIdx = MeshRenderSystemInterface::all[i]->mGeometry.mVertexList[thirdIdx];
+
+            Point3F points[3];
+            points[0] = MeshRenderSystemInterface::all[i]->mGeometry.mPoints[firstVertIdx.vertIdx];
+            points[1] = MeshRenderSystemInterface::all[i]->mGeometry.mPoints[secondVertIdx.vertIdx];
+            points[2] = MeshRenderSystemInterface::all[i]->mGeometry.mPoints[thirdVertIdx.vertIdx];
+
+            Point3F normals[3];
+            normals[0] = MeshRenderSystemInterface::all[i]->mGeometry.mNormals[firstVertIdx.normalIdx];
+            normals[1] = MeshRenderSystemInterface::all[i]->mGeometry.mNormals[secondVertIdx.normalIdx];
+            normals[2] = MeshRenderSystemInterface::all[i]->mGeometry.mNormals[thirdVertIdx.normalIdx];
+
+            Point3F tangents[3];
+            tangents[0] = mCross(points[1] - points[0], normals[0]);
+            tangents[1] = mCross(points[2] - points[1], normals[1]);
+            tangents[2] = mCross(points[0] - points[2], normals[2]);
+
+            Point2F uvs[3];
+            uvs[0] = MeshRenderSystemInterface::all[i]->mGeometry.mUV0s[firstVertIdx.uv0Idx];
+            uvs[1] = MeshRenderSystemInterface::all[i]->mGeometry.mUV0s[secondVertIdx.uv0Idx];
+            uvs[2] = MeshRenderSystemInterface::all[i]->mGeometry.mUV0s[thirdVertIdx.uv0Idx];
+
+            mStaticBuffers[bufferId].vertCount += 3;
+            mStaticBuffers[bufferId].primCount += 1;
+
+            for (U32 v = 0; v < 3; ++v)
+            {
+               //Build the vert and store it to the buffers!
+               GFXVertexPNTT bufVert;
+               bufVert.point = points[v];
+               bufVert.normal = normals[v];
+               bufVert.tangent = tangents[v];
+               bufVert.texCoord = uvs[v];
+
+               newBounds.extend(points[v]);
+
+               mStaticBuffers[bufferId].buffers.last().vertData.push_back(bufVert);
+
+               U32 vertPrimId = mStaticBuffers[bufferId].buffers.last().vertData.size() - 1;
+               mStaticBuffers[bufferId].buffers.last().primData.push_back(vertPrimId);
+
+               mStaticBuffers[bufferId].center += points[v];
+            }
+         }
+      }
+   }
+
+   //Now, iterate through the organized data and turn them into renderable buffers
+   for (U32 i = 0; i < mStaticBuffers.size(); i++)
+   {
+      for (U32 b = 0; b < mStaticBuffers[i].buffers.size(); b++)
+      {
+         BufferSet::Buffers& buffers = mStaticBuffers[i].buffers[b];
+
+         //if there's no data to be had in this buffer, just skip it
+         if (buffers.vertData.empty())
+            continue;
+
+         buffers.vertexBuffer.set(GFX, buffers.vertData.size(), GFXBufferTypeStatic);
+         GFXVertexPNTT *pVert = buffers.vertexBuffer.lock();
+
+         for (U32 v = 0; v < buffers.vertData.size(); v++)
+         {
+            pVert->normal = buffers.vertData[v].normal;
+            pVert->tangent = buffers.vertData[v].tangent;
+            //pVert->color = buffers.vertData[v].color;
+            pVert->point = buffers.vertData[v].point;
+            pVert->texCoord = buffers.vertData[v].texCoord;
+
+            pVert++;
+         }
+
+         buffers.vertexBuffer.unlock();
+
+         // Allocate PB
+         buffers.primitiveBuffer.set(GFX, buffers.primData.size(), buffers.primData.size() / 3, GFXBufferTypeStatic);
+
+         U16 *pIndex;
+         buffers.primitiveBuffer.lock(&pIndex);
+
+         for (U16 i = 0; i < buffers.primData.size(); i++)
+         {
+            *pIndex = i;
+            pIndex++;
+         }
+
+         buffers.primitiveBuffer.unlock();
+      }
+
+      mStaticBuffers[i].center /= mStaticBuffers[i].vertCount;
+   }
+
+   //mObjBox = newBounds;
+   //resetWorldBox();
+}
+
+U32 MeshRenderSystem::findBufferSetByMaterial(U32 matId)
+{
+   for (U32 i = 0; i < mStaticBuffers.size(); i++)
+   {
+      if (mStaticBuffers[i].surfaceMaterialId == matId)
+         return i;
+   }
+
+   return -1;
+}

Engine/source/T3D/systems/render/meshRenderSystem.h

@@ -0,0 +1,207 @@
+#pragma once
+#include "scene/sceneRenderState.h"
+#include "T3D/systems/componentSystem.h"
+#include "ts/tsShape.h"
+#include "ts/tsShapeInstance.h"
+#include "T3D/assets/ShapeAsset.h"
+#include "T3D/assets/MaterialAsset.h"
+
+#ifndef _GFXVERTEXBUFFER_H_
+#include "gfx/gfxVertexBuffer.h"
+#endif
+#ifndef _GFXPRIMITIVEBUFFER_H_
+#include "gfx/gfxPrimitiveBuffer.h"
+#endif
+#ifndef _OPTIMIZEDPOLYLIST_H_
+#include "collision/optimizedPolyList.h"
+#endif
+
+class MeshRenderSystemInterface : public SystemInterface<MeshRenderSystemInterface>
+{
+public:
+   TSShapeInstance * mShapeInstance;
+
+   MatrixF                 mTransform;
+   Point3F                 mScale;
+   Box3F						   mBounds;
+   SphereF                 mSphere;
+
+   bool                    mIsClient;
+
+   struct matMap
+   {
+      //MaterialAsset* matAsset;
+      String assetId;
+      U32 slot;
+   };
+
+   Vector<matMap>  mChangingMaterials;
+   Vector<matMap>  mMaterials;
+
+   //Static geometry stuff
+   bool                    mStatic;
+
+   OptimizedPolyList       mGeometry;
+
+   MeshRenderSystemInterface() : SystemInterface(), mShapeInstance(nullptr), mTransform(MatrixF::Identity), mScale(Point3F::One), mIsClient(false), mStatic(false)
+   {
+      mBounds = Box3F(1);
+      mSphere = SphereF();
+   }
+
+   ~MeshRenderSystemInterface()
+   {
+      //SAFE_DELETE(mShape);
+      SAFE_DELETE(mShapeInstance);
+   }
+};
+
+class MeshRenderSystem
+{
+protected:
+   /*struct StaticBatchElement
+   {
+      SimObject* owner;
+      OptimizedPolyList geometry;
+      String batchName;
+   };
+
+   static Vector<StaticBatchElement> mStaticElements;*/
+
+   //We retain the pushed geometry data for rendering here. It's static(unless forced to change through editing or whatnot)
+   //so rendering the batches is real fast
+   struct BufferMaterials
+   {
+      // The name of the Material we will use for rendering
+      String            mMaterialName;
+      // The actual Material instance
+      BaseMatInstance*  mMaterialInst;
+
+      BufferMaterials()
+      {
+         mMaterialName = "";
+         mMaterialInst = NULL;
+      }
+   };
+
+   static Vector<BufferMaterials> mBufferMaterials;
+
+   struct BufferSet
+   {
+      U32 surfaceMaterialId;
+
+      U32 vertCount;
+      U32 primCount;
+
+      Point3F center;
+
+      struct Buffers
+      {
+         U32 vertStart;
+         U32 primStart;
+         U32 vertCount;
+         U32 primCount;
+
+         Vector<GFXVertexPNTT> vertData;
+         Vector<U32> primData;
+
+         GFXVertexBufferHandle< GFXVertexPNTT > vertexBuffer;
+         GFXPrimitiveBufferHandle            primitiveBuffer;
+
+         Buffers()
+         {
+            vertStart = 0;
+            primStart = 0;
+            vertCount = 0;
+            primCount = 0;
+
+            vertexBuffer = NULL;
+            primitiveBuffer = NULL;
+         }
+      };
+
+      Vector<Buffers> buffers;
+
+      BufferSet()
+      {
+         Buffers newBuffer;
+         buffers.push_back(newBuffer);
+
+         surfaceMaterialId = 0;
+
+         vertCount = 0;
+         primCount = 0;
+
+         center = Point3F::Zero;
+      }
+   };
+
+   static Vector<BufferSet> mStaticBuffers;
+
+public:
+   /*virtual void prepRenderImage(SceneRenderState *state);
+
+   bool setMeshAsset(const char* assetName);
+
+   virtual TSShape* getShape() { if (mMeshAsset)  return mMeshAsset->getShape(); else return NULL; }
+   virtual TSShapeInstance* getShapeInstance() { return mShapeInstance; }
+
+   Resource<TSShape> getShapeResource() { return mMeshAsset->getShapeResource(); }
+
+   void _onResourceChanged(const Torque::Path &path);
+
+   virtual bool castRayRendered(const Point3F &start, const Point3F &end, RayInfo *info);
+
+   void mountObjectToNode(SceneObject* objB, String node, MatrixF txfm);
+
+   virtual void onDynamicModified(const char* slotName, const char* newValue);
+
+   void changeMaterial(U32 slot, MaterialAsset* newMat);
+   bool setMatInstField(U32 slot, const char* field, const char* value);
+
+   virtual void onInspect();
+   virtual void onEndInspect();
+
+   virtual Vector<MatrixF> getNodeTransforms()
+   {
+      Vector<MatrixF> bob;
+      return bob;
+   }
+
+   virtual void setNodeTransforms(Vector<MatrixF> transforms)
+   {
+      return;
+   }*/
+
+   /*MeshRenderSystem()
+   {
+
+   }
+   virtual ~MeshRenderSystem()
+   {
+      smInterfaceList.clear();
+   }
+
+   static MeshComponentInterface* GetNewInterface()
+   {
+      smInterfaceList.increment();
+
+      return &smInterfaceList.last();
+   }
+
+   static void RemoveInterface(T* q)
+   {
+      smInterfaceList.erase(q);
+   }*/
+
+   //Core render function, which does all the real work
+   static void render(SceneManager *sceneManager, SceneRenderState* state);
+
+   //Render our particular interface's data
+   static void renderInterface(U32 interfaceIndex, SceneRenderState* state);
+
+   //Static Batch rendering
+   static void rebuildBuffers();
+
+   static U32 findBufferSetByMaterial(U32 matId);
+};

Engine/source/T3D/systems/updateSystem.cpp

@@ -0,0 +1,34 @@
+#include "T3D/systems/updateSystem.h"
+
+void UpdateSystem::processTick()
+{
+   for (U32 i = 0; i < UpdateSystemInterface::all.size(); i++)
+   {
+      if (UpdateSystemInterface::all[i]->mIsEnabled)
+      {
+         //do work
+      }
+   }
+}
+
+void UpdateSystem::advanceTime(U32 _tickMS)
+{
+   for (U32 i = 0; i < UpdateSystemInterface::all.size(); i++)
+   {
+      if (UpdateSystemInterface::all[i]->mIsEnabled)
+      {
+         //do work
+      }
+   }
+}
+
+void UpdateSystem::interpolateTick(U32 _deltaMS)
+{
+   for (U32 i = 0; i < UpdateSystemInterface::all.size(); i++)
+   {
+      if (UpdateSystemInterface::all[i]->mIsEnabled)
+      {
+         //do work
+      }
+   }
+}

Engine/source/T3D/systems/updateSystem.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "componentSystem.h"
+
+class UpdateSystemInterface : public SystemInterface<UpdateSystemInterface>
+{
+public:
+   bool mIsEnabled;
+};
+
+class UpdateSystem
+{
+public:
+   static void processTick();
+   static void advanceTime(U32 _tickMS);
+   static void interpolateTick(U32 _deltaMS);
+};

Engine/source/assets/assetBase.cpp

@@ -69,7 +69,7 @@ AssetBase::~AssetBase()
    // If the asset manager does not own the asset then we own the
    // asset definition so delete it.
    if (!getOwned())
-      delete mpAssetDefinition;
+      SAFE_DELETE(mpAssetDefinition);
 }
 
 //-----------------------------------------------------------------------------

Engine/source/assets/assetBase.h

@@ -62,6 +62,7 @@ class AssetBase : public SimObject
 
    typedef SimObject Parent;
 
+protected:
    AssetManager*           mpOwningAssetManager;
    bool                    mAssetInitialized;
    AssetDefinition*        mpAssetDefinition;

Engine/source/assets/assetManager.cpp

@@ -61,6 +61,15 @@
 #ifndef COMPONENTASSET_H
 #include "T3D/assets/ComponentAsset.h"
 #endif
+#ifndef GUI_ASSET_H
+#include "T3D/assets/GUIAsset.h"
+#endif
+#ifndef SCRIPT_ASSET_H
+#include "T3D/assets/ScriptAsset.h"
+#endif
+#ifndef MATERIALASSET_H
+#include "T3D/assets/MaterialAsset.h"
+#endif
 
 // Script bindings.
 #include "assetManager_ScriptBinding.h"
@@ -251,6 +260,18 @@ bool AssetManager::loadModuleAutoLoadAssets(ModuleDefinition* pModuleDefinition)
             {
                assetBase = mTaml.read<ComponentAsset>(assetDef->mAssetBaseFilePath);
             }
+            else if (assetDef->mAssetType == StringTable->insert("GUIAsset"))
+            {
+               assetBase = mTaml.read<GUIAsset>(assetDef->mAssetBaseFilePath);
+            }
+            else if (assetDef->mAssetType == StringTable->insert("ScriptAsset"))
+            {
+               assetBase = mTaml.read<ScriptAsset>(assetDef->mAssetBaseFilePath);
+            }
+            else if (assetDef->mAssetType == StringTable->insert("MaterialAsset"))
+            {
+               assetBase = mTaml.read<MaterialAsset>(assetDef->mAssetBaseFilePath);
+            }
 
             //load the asset now if valid
             if (assetBase)
@@ -2369,6 +2390,13 @@ S32 AssetManager::findAssetLooseFile( AssetQuery* pAssetQuery, const char* pLoos
 
 //-----------------------------------------------------------------------------
 
+AssetManager::typeAssetDependsOnHash* AssetManager::getDependedOnAssets()
+{
+   // Find any asset dependencies.
+   return &mAssetDependsOn;
+}
+//-----------------------------------------------------------------------------
+
 bool AssetManager::scanDeclaredAssets( const char* pPath, const char* pExtension, const bool recurse, ModuleDefinition* pModuleDefinition )
 {
     // Debug Profiling.

Engine/source/assets/assetManager.h

@@ -73,15 +73,18 @@ class AssetManager : public SimObject, public ModuleCallbacks
 {
 private:
     typedef SimObject Parent;
-    typedef StringTableEntry typeAssetId;
-    typedef StringTableEntry typeAssetName;
-    typedef StringTableEntry typeReferenceFilePath;
-    typedef HashMap<typeAssetId, AssetDefinition*> typeDeclaredAssetsHash;
-    typedef HashTable<typeAssetId, typeReferenceFilePath> typeReferencedAssetsHash;
-    typedef HashTable<typeAssetId, typeAssetId> typeAssetDependsOnHash;
-    typedef HashTable<typeAssetId, typeAssetId> typeAssetIsDependedOnHash;
-    typedef HashMap<AssetPtrBase*, AssetPtrCallback*> typeAssetPtrRefreshHash;
 
+public:
+   typedef StringTableEntry typeAssetId;
+   typedef StringTableEntry typeAssetName;
+   typedef StringTableEntry typeReferenceFilePath;
+   typedef HashMap<typeAssetId, AssetDefinition*> typeDeclaredAssetsHash;
+   typedef HashTable<typeAssetId, typeReferenceFilePath> typeReferencedAssetsHash;
+   typedef HashTable<typeAssetId, typeAssetId> typeAssetDependsOnHash;
+   typedef HashTable<typeAssetId, typeAssetId> typeAssetIsDependedOnHash;
+   typedef HashMap<AssetPtrBase*, AssetPtrCallback*> typeAssetPtrRefreshHash;
+
+private:
     /// Declared assets.
     typeDeclaredAssetsHash              mDeclaredAssets;
 
@@ -368,6 +371,8 @@ public:
     S32 findTaggedAssets( AssetQuery* pAssetQuery, const char* pAssetTagNames, const bool assetQueryAsSource = false );
     S32 findAssetLooseFile( AssetQuery* pAssetQuery, const char* pLooseFile, const bool assetQueryAsSource = false );
 
+    typeAssetDependsOnHash* getDependedOnAssets();
+
     /// Declare Console Object.
     DECLARE_CONOBJECT( AssetManager );
 

Engine/source/console/codeBlock.cpp

@@ -409,6 +409,8 @@ bool CodeBlock::read(StringTableEntry fileName, Stream &st)
    U32 totSize = codeLength + lineBreakPairCount * 2;
    code = new U32[totSize];
 
+   // 0xFF is used as a flag to help compress the bytecode.
+   // If detected, the bytecode is only a U8.
    for (i = 0; i < codeLength; i++)
    {
       U8 b;
@@ -442,7 +444,11 @@ bool CodeBlock::read(StringTableEntry fileName, Stream &st)
       {
          U32 ip;
          st.read(&ip);
+#ifdef TORQUE_CPU_X64
+         *(U64*)(code + ip) = (U64)ste;
+#else
          code[ip] = *((U32 *)&ste);
+#endif
       }
    }
 

Engine/source/console/consoleObject.h

@@ -1265,10 +1265,6 @@ inline bool& ConsoleObject::getDynamicGroupExpand()
       EnginePropertyTable _propTable( sizeof( _props ) / sizeof( _props[ 0 ] ) - 1, _props );            \
    } }
 
-/// Add an auto-doc for a class.
-#define ConsoleDocClass( className, docString ) \
-   CLASSDOC( className, docString )
-
 /// @}
 
 //------------------------------------------------------------------------------

Engine/source/console/engineTypes.h

@@ -576,7 +576,7 @@ namespace _Private {
    uintptr_t( ( ( const char* ) &( ( ( ThisType* ) 16 )->fieldName ) ) - 16 ) // Artificial offset to avoid compiler warnings.
    
 ///
-#define CLASSDOC( className, doc ) \
+#define ConsoleDocClass( className, doc ) \
    template<> const char* EngineClassTypeInfo< className, className::_ClassBase >::smDocString = doc;
    
 

Engine/source/gui/containers/guiDragAndDropCtrl.cpp

@@ -152,14 +152,24 @@ ConsoleDocClass( GuiDragAndDropControl,
    "@ingroup GuiUtil"
 );
 
+IMPLEMENT_CALLBACK(GuiDragAndDropControl, onControlDragCancelled, void, (), (),
+   "Called when the we cancel out of the drag and drop action.\n"
+   "@see GuiDragAndDropControl::onControlDragCancelled");
 
 //-----------------------------------------------------------------------------
+GuiDragAndDropControl::GuiDragAndDropControl() : mDeleteOnMouseUp(true), mUseWholeCanvas(false)
+{
+
+}
 
 void GuiDragAndDropControl::initPersistFields()
 {
    addField( "deleteOnMouseUp", TypeBool, Offset( mDeleteOnMouseUp, GuiDragAndDropControl ),
       "If true, the control deletes itself when the left mouse button is released.\n\n"
       "If at this point, the drag&drop control still contains its payload, it will be deleted along with the control." );
+
+   addField("useWholeCanvas", TypeBool, Offset(mUseWholeCanvas, GuiDragAndDropControl),
+      "If true, the control can be tested against ANY control active on the canvas instead of just the direct parent.\n\n");
    
    Parent::initPersistFields();
 }
@@ -226,8 +236,10 @@ void GuiDragAndDropControl::onMouseUp(const GuiEvent& event)
    mouseUnlock();
 
    GuiControl* target = findDragTarget( event.mousePoint, "onControlDropped" );
-   if( target )
-      target->onControlDropped_callback( dynamic_cast< GuiControl* >( at( 0 ) ), getDropPoint() );
+   if (target)
+      target->onControlDropped_callback(dynamic_cast<GuiControl*>(at(0)), getDropPoint());
+   else
+      onControlDragCancelled_callback();
 
    if( mDeleteOnMouseUp )
       deleteObject();
@@ -239,6 +251,13 @@ GuiControl* GuiDragAndDropControl::findDragTarget( Point2I mousePoint, const cha
 {
    // If there are any children and we have a parent.
    GuiControl* parent = getParent();
+
+   if (mUseWholeCanvas)
+   {
+      parent->setVisible(false);
+      parent = getRoot();
+   }
+
    if (size() && parent)
    {
       mVisible = false;
@@ -252,6 +271,10 @@ GuiControl* GuiDragAndDropControl::findDragTarget( Point2I mousePoint, const cha
             dropControl = dropControl->getParent();
       }
    }
+
+   if(mUseWholeCanvas)
+      parent->setVisible(true);
+
    return NULL;
 }
 

Engine/source/gui/containers/guiDragAndDropCtrl.h

@@ -53,6 +53,8 @@ class GuiDragAndDropControl : public GuiControl
       /// If true, the control deletes itself when the left mouse button is released.
       bool mDeleteOnMouseUp;
 
+      bool mUseWholeCanvas;
+
       /// Controls may want to react when they are dragged over, entered or exited.
       SimObjectPtr<GuiControl> mLastTarget;
       
@@ -65,7 +67,7 @@ class GuiDragAndDropControl : public GuiControl
 
    public:
    
-      GuiDragAndDropControl() {}
+      GuiDragAndDropControl();
 
       void startDragging(Point2I offset = Point2I(0, 0));
 
@@ -81,6 +83,8 @@ class GuiDragAndDropControl : public GuiControl
       DECLARE_DESCRIPTION( "A special control that implements drag&drop behavior.\n"
                            "The control will notify other controls as it moves across the canvas.\n"
                            "Content can be attached through dynamic fields or child objects." );
+
+      DECLARE_CALLBACK(void, onControlDragCancelled, ());
 };
 
 #endif

Engine/source/gui/controls/guiTreeViewCtrl.cpp

@@ -2501,6 +2501,19 @@ const char * GuiTreeViewCtrl::getItemValue(S32 itemId)
 
 //-----------------------------------------------------------------------------
 
+S32 GuiTreeViewCtrl::getItemAtPosition(Point2I position)
+{
+   BitSet32 hitFlags = 0;
+   Item* item;
+
+   if (_hitTest(position, item, hitFlags))
+      return item->mId;
+   else
+      return -1;
+}
+
+//-----------------------------------------------------------------------------
+
 bool GuiTreeViewCtrl::editItem( S32 itemId, const char* newText, const char* newValue )
 {
    Item* item = getItem( itemId );
@@ -5550,3 +5563,11 @@ DefineEngineMethod( GuiTreeViewCtrl, clearFilterText, void, (),,
 {
    object->clearFilterText();
 }
+
+DefineEngineMethod(GuiTreeViewCtrl, getItemAtPosition, S32, (Point2I position), (Point2I::Zero),
+   "Get the tree item at the passed in position.\n\n"
+   "@param position The position to check for what item is below it.\n"
+   "@return The id of the item under the position.")
+{
+   return object->getItemAtPosition(position);
+}

Engine/source/gui/controls/guiTreeViewCtrl.h

@@ -513,6 +513,8 @@ class GuiTreeViewCtrl : public GuiArrayCtrl
       bool editItem( S32 itemId, const char* newText, const char* newValue );
 
       bool markItem( S32 itemId, bool mark );
+
+      S32 getItemAtPosition(Point2I position);
       
       bool isItemSelected( S32 itemId );
 

Engine/source/gui/core/guiCanvas.cpp

@@ -133,7 +133,8 @@ GuiCanvas::GuiCanvas(): GuiControl(),
                         mLastRenderMs(0),
                         mPlatformWindow(NULL),
                         mDisplayWindow(true),
-                        mMenuBarCtrl(NULL)
+                        mMenuBarCtrl(nullptr),
+                        mMenuBackground(nullptr)
 {
    setBounds(0, 0, 640, 480);
    mAwake = true;
@@ -276,8 +277,6 @@ bool GuiCanvas::onAdd()
    // Define the menu bar for this canvas (if any)
    Con::executef(this, "onCreateMenu");
 
-   Sim::findObject("PlatformGenericMenubar", mMenuBarCtrl);
-
    return parentRet;
 }
 
@@ -298,25 +297,49 @@ void GuiCanvas::setMenuBar(SimObject *obj)
     mMenuBarCtrl = dynamic_cast<GuiControl*>(obj);
 
     //remove old menubar
-    if( oldMenuBar )
-        Parent::removeObject( oldMenuBar );
+    if (oldMenuBar)
+    {
+        Parent::removeObject(oldMenuBar);
+        Parent::removeObject(mMenuBackground); //also remove the modeless wrapper
+    }
 
     // set new menubar    
-    if( mMenuBarCtrl )
-        Parent::addObject(mMenuBarCtrl);
+    if (mMenuBarCtrl)
+    {
+       //Add a wrapper control so that the menubar sizes correctly
+       GuiControlProfile* profile;
+       Sim::findObject("GuiModelessDialogProfile", profile);
+
+       if (!profile)
+       {
+          Con::errorf("GuiCanvas::setMenuBar: Unable to find the GuiModelessDialogProfile profile!");
+          return;
+       }
+
+       if (mMenuBackground == nullptr)
+       {
+           mMenuBackground = new GuiControl();
+           mMenuBackground->registerObject();
+
+           mMenuBackground->setControlProfile(profile);
+       }
+
+       mMenuBackground->addObject(mMenuBarCtrl);
+
+       Parent::addObject(mMenuBackground);
+    }
 
     // update window accelerator keys
     if( oldMenuBar != mMenuBarCtrl )
     {
-        StringTableEntry ste = StringTable->insert("menubar");
-        GuiMenuBar* menu = NULL;
-        menu = !oldMenuBar ? NULL : dynamic_cast<GuiMenuBar*>(oldMenuBar->findObjectByInternalName( ste, true));
-        if( menu )
-            menu->removeWindowAcceleratorMap( *getPlatformWindow()->getInputGenerator() );
-
-        menu = !mMenuBarCtrl ? NULL : dynamic_cast<GuiMenuBar*>(mMenuBarCtrl->findObjectByInternalName( ste, true));
-        if( menu )
-                menu->buildWindowAcceleratorMap( *getPlatformWindow()->getInputGenerator() );
+        GuiMenuBar* oldMenu = dynamic_cast<GuiMenuBar*>(oldMenuBar);
+        GuiMenuBar* newMenu = dynamic_cast<GuiMenuBar*>(mMenuBarCtrl);
+
+        if(oldMenu)
+           oldMenu->removeWindowAcceleratorMap(*getPlatformWindow()->getInputGenerator());
+
+        if(newMenu)
+           newMenu->buildWindowAcceleratorMap(*getPlatformWindow()->getInputGenerator());
     }
 }
 
@@ -1633,27 +1656,26 @@ void GuiCanvas::maintainSizing()
       Point2I newPos = screenRect.point;
 
       // if menubar is active displace content gui control
-      if( mMenuBarCtrl && (ctrl == getContentControl()) )
-      {          
-          const SimObject *menu = mMenuBarCtrl->findObjectByInternalName( StringTable->insert("menubar"), true);
+      if (mMenuBarCtrl && (ctrl == getContentControl()))
+      {
+         /*const SimObject *menu = mMenuBarCtrl->findObjectByInternalName( StringTable->insert("menubar"), true);
 
-          if( !menu )
-              continue;
+         if( !menu )
+             continue;
 
-          AssertFatal( dynamic_cast<const GuiControl*>(menu), "");
+         AssertFatal( dynamic_cast<const GuiControl*>(menu), "");*/
 
-          const U32 yOffset = static_cast<const GuiControl*>(menu)->getExtent().y;
-          newPos.y += yOffset;
-          newExt.y -= yOffset;
+         const U32 yOffset = static_cast<const GuiMenuBar*>(mMenuBarCtrl)->mMenubarHeight;
+         newPos.y += yOffset;
+         newExt.y -= yOffset;
       }
 
-      if(pos != newPos || ext != newExt)
+      if (pos != newPos || ext != newExt)
       {
          ctrl->resize(newPos, newExt);
          resetUpdateRegions();
       }
    }
-
 }
 
 void GuiCanvas::setupFences()

Engine/source/gui/core/guiCanvas.h

@@ -198,6 +198,7 @@ protected:
 	static CanvasSizeChangeSignal smCanvasSizeChangeSignal;
 
    GuiControl *mMenuBarCtrl;
+   GuiControl* mMenuBackground;
 
 public:
    DECLARE_CONOBJECT(GuiCanvas);
@@ -210,6 +211,7 @@ public:
    virtual void onRemove();
 
    void setMenuBar(SimObject *obj);
+   SimObject* getMenuBar() { return mMenuBarCtrl; }
 
    static void initPersistFields();
 

Engine/source/gui/editor/guiInspector.cpp

@@ -54,7 +54,8 @@ GuiInspector::GuiInspector()
    mOverDivider( false ),
    mMovingDivider( false ),
    mHLField( NULL ),
-   mShowCustomFields( true )
+   mShowCustomFields( true ),
+   mComponentGroupTargetId(-1)
 {
    mPadding = 1;
 }
@@ -620,7 +621,10 @@ void GuiInspector::refresh()
          else
             compName = comp->getComponentName();
 
-         GuiInspectorGroup *compGroup = new GuiInspectorComponentGroup(compName, this, comp);
+         StringBuilder captionString;
+         captionString.format("%s [%i]", compName.c_str(), comp->getId());
+
+         GuiInspectorGroup *compGroup = new GuiInspectorComponentGroup(captionString.data(), this, comp);
          if (compGroup != NULL)
          {
             compGroup->registerObject();

Engine/source/gui/editor/guiMenuBar.cpp

@@ -142,24 +142,11 @@ IMPLEMENT_CALLBACK( GuiMenuBar, onMenuItemSelect, void, ( S32 menuId, const char
    "@see GuiTickCtrl\n\n"
 );
 
-IMPLEMENT_CALLBACK( GuiMenuBar, onSubmenuSelect, void, ( S32 submenuId, const char* submenuText ),( submenuId, submenuText ),
-   "@brief Called whenever a submenu is selected.\n\n"
-   "@param submenuId Id of the selected submenu\n"
-   "@param submenuText Text of the selected submenu\n\n"
-   "@tsexample\n"
-   "GuiMenuBar::onSubmenuSelect(%this,%submenuId,%submenuText)\n"
-   "{\n"
-   "  // Code to run when the callback occurs\n"
-   "}\n"
-   "@endtsexample\n\n"
-   "@see GuiTickCtrl\n\n"
-);
-
 //------------------------------------------------------------------------------
 // console methods
 //------------------------------------------------------------------------------
 
-DefineEngineMethod( GuiMenuBar, clearMenus, void, (),,
+/*DefineEngineMethod( GuiMenuBar, clearMenus, void, (),,
    "@brief Clears all the menus from the menu bar.\n\n"
    "@tsexample\n"
    "// Inform the GuiMenuBar control to clear all menus from itself.\n"
@@ -818,14 +805,14 @@ GuiMenuBar::Menu *GuiMenuBar::findMenu(const char *menu)
    {
       U32 id = dAtoi(menu);
       for (U32 i = 0; i < mMenuList.size(); ++i)
-         if (id == mMenuList[i]->id)
+         if (id == mMenuList[i].id)
             return mMenuList[i];
       return NULL;
    }
    else
    {
       for (U32 i = 0; i < mMenuList.size(); ++i)
-         if (!dStricmp(menu, mMenuList[i]->text))
+         if (!dStricmp(menu, mMenuList[i].text))
             return mMenuList[i];
       return NULL;
    }
@@ -1093,19 +1080,18 @@ void GuiMenuBar::clearSubmenuItems(MenuItem *menuitem)
    while(menuitem->submenu->firstMenuItem)
       removeSubmenuItem(menuitem, menuitem->submenu->firstMenuItem);
 }
-
+*/
 //------------------------------------------------------------------------------
 // initialization, input and render methods
 //------------------------------------------------------------------------------
 
 GuiMenuBar::GuiMenuBar()
 {
-   mMenuList.clear();
+   //mMenuList.clear();
    menuBarDirty = true;
    mouseDownMenu = NULL;
    mouseOverMenu = NULL;
    mCurAcceleratorIndex = 0;
-   mBackground = NULL;
    mPadding = 0;
 
    mCheckmarkBitmapIndex = 0; // Default to the first image in the bitmap array for the check mark
@@ -1114,21 +1100,28 @@ GuiMenuBar::GuiMenuBar()
    mVerticalMargin = 1;   // Default number of pixels on the top and bottom of a menu's text
    mBitmapMargin = 2;     // Default number of pixels between a menu's bitmap and text
 
+   mMenubarHeight = 20;
+
    //  Added:
    mouseDownSubmenu = NULL;
    mouseOverSubmenu = NULL;
-   mSubmenuBackground = NULL;
-   mSubmenuTextList = NULL;
-   mMouseOverCounter = 0;
-   mCountMouseOver = false;
-   mMouseHoverAmount = 30;
+
+   mMouseInMenu = false;
+
    setProcessTicks(false);
 }
 
+void GuiMenuBar::onRemove()
+{
+   Parent::onRemove();
+}
+
 void GuiMenuBar::initPersistFields()
 {
    addField("padding", TypeS32, Offset( mPadding, GuiMenuBar ),"Extra padding to add to the bounds of the control.\n");
 
+   addField("menubarHeight", TypeS32, Offset(mMenubarHeight, GuiMenuBar), "Sets the height of the menubar when attached to the canvas.\n");
+
    Parent::initPersistFields();
 }
 
@@ -1153,52 +1146,75 @@ bool GuiMenuBar::onWake()
    return true;
 }
 
-GuiMenuBar::Menu *GuiMenuBar::findHitMenu(Point2I mousePoint)
+void GuiMenuBar::addObject(SimObject* object)
+{
+   PopupMenu* popup = dynamic_cast<PopupMenu*>(object);
+
+   if (!popup)
+   {
+      //if it's not a popup, handle it normally
+      Parent::addObject(object);
+   }
+   else
+   {
+      //otherwise, if it IS a popup, don't add it as a child object, but instead just insert it as a menu entry
+      insert(object, -1);
+   }
+}
+
+GuiMenuBar::MenuEntry *GuiMenuBar::findHitMenu(Point2I mousePoint)
 {
    Point2I pos = globalToLocalCoord(mousePoint);
 
    for (U32 i = 0; i < mMenuList.size(); ++i)
-      if (mMenuList[i]->visible && mMenuList[i]->bounds.pointInRect(pos))
-         return mMenuList[i];
+   {
+      if (mMenuList[i].visible && mMenuList[i].bounds.pointInRect(pos))
+         return &mMenuList[i];
+   }
+
    return NULL;
 }
 
 void GuiMenuBar::onPreRender()
 {
+   setHeight(mMenubarHeight);
+
    Parent::onPreRender();
-   if(menuBarDirty)
+   if (menuBarDirty)
    {
       menuBarDirty = false;
       U32 curX = mPadding;
       for (U32 i = 0; i < mMenuList.size(); ++i)
       {
-         if (!mMenuList[i]->visible)
+         if (!mMenuList[i].visible)
             continue;
 
-       // Bounds depends on if there is a bitmap to be drawn or not
-         if (mMenuList[i]->bitmapIndex == -1)
-       {
+         // Bounds depends on if there is a bitmap to be drawn or not
+         if (mMenuList[i].bitmapIndex == -1)
+         {
             // Text only
-            mMenuList[i]->bounds.set(curX, 0, mProfile->mFont->getStrWidth(mMenuList[i]->text) + (mHorizontalMargin * 2), getHeight() - (mVerticalMargin * 2));
+            mMenuList[i].bounds.set(curX, 0, mProfile->mFont->getStrWidth(mMenuList[i].text) + (mHorizontalMargin * 2), getHeight() - (mVerticalMargin * 2));
 
-         } else
-       {
-            // Will the bitmap and text be draw?
-          if (!mMenuList[i]->drawBitmapOnly)
+         }
+         else
          {
+            // Will the bitmap and text be draw?
+            if (!mMenuList[i].drawBitmapOnly)
+            {
                // Draw the bitmap and the text
                RectI *bitmapBounds = mProfile->mBitmapArrayRects.address();
-               mMenuList[i]->bounds.set(curX, 0, bitmapBounds[mMenuList[i]->bitmapIndex].extent.x + mProfile->mFont->getStrWidth(mMenuList[i]->text) + (mHorizontalMargin * 2), getHeight() + (mVerticalMargin * 2));
+               mMenuList[i].bounds.set(curX, 0, bitmapBounds[mMenuList[i].bitmapIndex].extent.x + mProfile->mFont->getStrWidth(mMenuList[i].text) + (mHorizontalMargin * 2), getHeight() + (mVerticalMargin * 2));
 
-         } else
-         {
+            }
+            else
+            {
                // Only the bitmap will be drawn
                RectI *bitmapBounds = mProfile->mBitmapArrayRects.address();
-               mMenuList[i]->bounds.set(curX, 0, bitmapBounds[mMenuList[i]->bitmapIndex].extent.x + mBitmapMargin + (mHorizontalMargin * 2), getHeight() + (mVerticalMargin * 2));
+               mMenuList[i].bounds.set(curX, 0, bitmapBounds[mMenuList[i].bitmapIndex].extent.x + mBitmapMargin + (mHorizontalMargin * 2), getHeight() + (mVerticalMargin * 2));
+            }
          }
-       }
 
-         curX += mMenuList[i]->bounds.extent.x;
+         curX += mMenuList[i].bounds.extent.x;
       }
       mouseOverMenu = NULL;
       mouseDownMenu = NULL;
@@ -1207,12 +1223,12 @@ void GuiMenuBar::onPreRender()
 
 void GuiMenuBar::checkMenuMouseMove(const GuiEvent &event)
 {
-   Menu *hit = findHitMenu(event.mousePoint);
+   MenuEntry *hit = findHitMenu(event.mousePoint);
    if(hit && hit != mouseDownMenu)
    {
       // gotta close out the current menu...
-      mTextList->setSelectedCell(Point2I(-1, -1));
-      closeMenu();
+      mouseDownMenu->popupMenu->hidePopup();
+      
       mouseOverMenu = mouseDownMenu = hit;
       setUpdate();
       onAction();
@@ -1221,87 +1237,63 @@ void GuiMenuBar::checkMenuMouseMove(const GuiEvent &event)
 
 void GuiMenuBar::onMouseMove(const GuiEvent &event)
 {
-   Menu *hit = findHitMenu(event.mousePoint);
-   if(hit != mouseOverMenu)
-   {
-      //  If we need to, reset the mouse over menu counter and indicate
-      // that we should track it.
-      if(hit)
-           mMouseOverCounter = 0;
-      if(!mCountMouseOver)
-      {
-           //  We've never started the counter, so start it.
-           if(hit)
-              mCountMouseOver = true;
-      }
+   MenuEntry *hit = findHitMenu(event.mousePoint);
 
-      mouseOverMenu = hit;
+   if (mouseDownMenu != nullptr && hit != nullptr)
+   {
+      //we have a standing click, so just update and go
+      mouseDownMenu = mouseOverMenu = hit;
       setUpdate();
+      onAction();
+
+      return;
    }
+
+   mouseOverMenu = hit;
+   setUpdate();
+}
+
+void GuiMenuBar::onMouseEnter(const GuiEvent &event)
+{
+   onMouseInMenu_callback(true);
+   mMouseInMenu = true;
 }
 
 void GuiMenuBar::onMouseLeave(const GuiEvent &event)
 {
    if(mouseOverMenu)
       setUpdate();
-   mouseOverMenu = NULL;
 
-   //  As we've left the control, don't track how long the mouse has been
-   // within it.
-   if(mCountMouseOver && mMouseOverCounter >= mMouseHoverAmount)
-   {
-     onMouseInMenu_callback(false); // Last parameter indicates if we've entered or left the menu
-   }
-   mCountMouseOver = false;
-   mMouseOverCounter = 0;
+   mouseOverMenu = NULL;
+   mMouseInMenu = false;
 }
 
 void GuiMenuBar::onMouseDragged(const GuiEvent &event)
 {
-   Menu *hit = findHitMenu(event.mousePoint);
-   
-   if(hit != mouseOverMenu)
-   {
-      //  If we need to, reset the mouse over menu counter and indicate
-      // that we should track it.
-      if(hit)
-           mMouseOverCounter = 0;
-      if(!mCountMouseOver)
-      {
-           //  We've never started the counter, so start it.
-           if(hit)
-              mCountMouseOver = true;
-      }
-
-      mouseOverMenu = hit;
-      mouseDownMenu = hit;
-      setUpdate();
-      onAction();
-   }
 }
 
 void GuiMenuBar::onMouseDown(const GuiEvent &event)
 {
-   mouseDownMenu = mouseOverMenu = findHitMenu(event.mousePoint);
-   setUpdate();
-   onAction();
 }
 
 void GuiMenuBar::onMouseUp(const GuiEvent &event)
 {
-   mouseDownMenu = NULL;
+   mouseDownMenu = mouseOverMenu = findHitMenu(event.mousePoint);
    setUpdate();
+   onAction();
 }
 
 void GuiMenuBar::onRender(Point2I offset, const RectI &updateRect)
 {
-   RectI ctrlRect(offset, getExtent());
+   Point2I extent = getExtent();
+
+   RectI ctrlRect(offset, extent);
 
    GFXDrawUtil* drawUtil = GFX->getDrawUtil();
 
    //if opaque, fill the update rect with the fill color
    if (mProfile->mOpaque)
-      drawUtil->drawRectFill(RectI(offset, getExtent()), mProfile->mFillColor);
+      drawUtil->drawRectFill(RectI(offset, extent), mProfile->mFillColor);
 
    //if there's a border, draw the border
    if (mProfile->mBorder)
@@ -1309,63 +1301,65 @@ void GuiMenuBar::onRender(Point2I offset, const RectI &updateRect)
 
    for (U32 i = 0; i < mMenuList.size(); ++i)
    {
-      if (!mMenuList[i]->visible)
+      if (!mMenuList[i].visible)
          continue;
+
       ColorI fontColor = mProfile->mFontColor;
-      RectI bounds = mMenuList[i]->bounds;
+      RectI bounds = mMenuList[i].bounds;
       bounds.point += offset;
-      
+
       Point2I start;
 
-      start.x = mMenuList[i]->bounds.point.x + mHorizontalMargin;
-      start.y = mMenuList[i]->bounds.point.y + (mMenuList[i]->bounds.extent.y - mProfile->mFont->getHeight()) / 2;
-
-     // Draw the border
-      if (mMenuList[i]->drawBorder)
-     {
-        RectI highlightBounds = bounds;
-        highlightBounds.inset(1,1);
-        if (mMenuList[i] == mouseDownMenu)
-            renderFilledBorder(highlightBounds, mProfile->mBorderColorHL, mProfile->mFillColorHL );
-        else if (mMenuList[i] == mouseOverMenu && mouseDownMenu == NULL)
-           renderFilledBorder(highlightBounds, mProfile->mBorderColorHL, mProfile->mFillColorHL);
-     }
-
-     // Do we draw a bitmap?
-      if (mMenuList[i]->bitmapIndex != -1)
-     {
-        S32 index = mMenuList[i]->bitmapIndex * 3;
-        if (mMenuList[i] == mouseDownMenu)
+      start.x = mMenuList[i].bounds.point.x + mHorizontalMargin;
+      start.y = mMenuList[i].bounds.point.y + (mMenuList[i].bounds.extent.y - mProfile->mFont->getHeight()) / 2;
+
+      // Draw the border
+      if (mMenuList[i].drawBorder)
+      {
+         RectI highlightBounds = bounds;
+         highlightBounds.inset(1, 1);
+         if (&mMenuList[i] == mouseDownMenu)
+            renderFilledBorder(highlightBounds, mProfile->mBorderColorHL, mProfile->mFillColorHL);
+         else if (&mMenuList[i] == mouseOverMenu && mouseDownMenu == NULL)
+            renderFilledBorder(highlightBounds, mProfile->mBorderColorHL, mProfile->mFillColorHL);
+      }
+
+      // Do we draw a bitmap?
+      if (mMenuList[i].bitmapIndex != -1)
+      {
+         S32 index = mMenuList[i].bitmapIndex * 3;
+         if (&mMenuList[i] == mouseDownMenu)
             ++index;
-        else if (mMenuList[i] == mouseOverMenu && mouseDownMenu == NULL)
+         else if (&mMenuList[i] == mouseOverMenu && mouseDownMenu == NULL)
             index += 2;
 
          RectI rect = mProfile->mBitmapArrayRects[index];
 
-       Point2I bitmapstart(start);
-       bitmapstart.y = mMenuList[i]->bounds.point.y + (mMenuList[i]->bounds.extent.y - rect.extent.y) / 2;
+         Point2I bitmapstart(start);
+         bitmapstart.y = mMenuList[i].bounds.point.y + (mMenuList[i].bounds.extent.y - rect.extent.y) / 2;
 
          drawUtil->clearBitmapModulation();
-         drawUtil->drawBitmapSR( mProfile->mTextureObject, offset + bitmapstart, rect);
+         drawUtil->drawBitmapSR(mProfile->mTextureObject, offset + bitmapstart, rect);
 
-       // Should we also draw the text?
-         if (!mMenuList[i]->drawBitmapOnly)
-       {
+         // Should we also draw the text?
+         if (!mMenuList[i].drawBitmapOnly)
+         {
             start.x += mBitmapMargin;
-      drawUtil->setBitmapModulation( fontColor );
-      drawUtil->drawText(mProfile->mFont, start + offset, mMenuList[i]->text, mProfile->mFontColors);
-       }
-     } else
-     {
-      drawUtil->setBitmapModulation( fontColor );
-      drawUtil->drawText(mProfile->mFont, start + offset, mMenuList[i]->text, mProfile->mFontColors);
-     }
+            drawUtil->setBitmapModulation(fontColor);
+            drawUtil->drawText(mProfile->mFont, start + offset, mMenuList[i].text, mProfile->mFontColors);
+         }
+      }
+      else
+      {
+         drawUtil->setBitmapModulation(fontColor);
+         drawUtil->drawText(mProfile->mFont, start + offset, mMenuList[i].text, mProfile->mFontColors);
+      }
    }
 
-   renderChildControls( offset, updateRect );
+   renderChildControls(offset, updateRect);
 }
 
-void GuiMenuBar::buildWindowAcceleratorMap( WindowInputGenerator &inputGenerator )
+void GuiMenuBar::buildWindowAcceleratorMap(WindowInputGenerator &inputGenerator)
 {
    // ok, accelerator map is cleared...
    // add all our keys:
@@ -1373,20 +1367,21 @@ void GuiMenuBar::buildWindowAcceleratorMap( WindowInputGenerator &inputGenerator
 
    for (U32 i = 0; i < mMenuList.size(); ++i)
    {
-      for (MenuItem *item = mMenuList[i]->firstMenuItem; item; item = item->nextMenuItem)
+      for (U32 item = 0; item < mMenuList[i].popupMenu->mMenuItems.size(); item++)
       {
-         if(!item->accelerator)
+         if (!mMenuList[i].popupMenu->mMenuItems[item].accelerator)
          {
-            item->accelerator = 0;
+            mMenuList[i].popupMenu->mMenuItems[item].accelerator = 0;
             continue;
          }
+
          EventDescriptor accelEvent;
-       ActionMap::createEventDescriptor(item->accelerator, &accelEvent);
-   
+         ActionMap::createEventDescriptor(mMenuList[i].popupMenu->mMenuItems[item].accelerator, &accelEvent);
+
          //now we have a modifier, and a key, add them to the canvas
-         inputGenerator.addAcceleratorKey( this, item->cmd, accelEvent.eventCode, accelEvent.flags);
+         inputGenerator.addAcceleratorKey(this, mMenuList[i].popupMenu->mMenuItems[item].cmd, accelEvent.eventCode, accelEvent.flags);
 
-         item->acceleratorIndex = mCurAcceleratorIndex;
+         mMenuList[i].popupMenu->mMenuItems[item].acceleratorIndex = mCurAcceleratorIndex;
          mCurAcceleratorIndex++;
       }
    }
@@ -1403,591 +1398,134 @@ void GuiMenuBar::acceleratorKeyPress(U32 index)
    // and find the item that corresponds to the accelerator index
    for (U32 i = 0; i < mMenuList.size(); ++i)
    {
-      if (!mMenuList[i]->visible)
+      if (!mMenuList[i].visible)
          continue;
 
-      for (MenuItem *item = mMenuList[i]->firstMenuItem; item; item = item->nextMenuItem)
+      for(U32 item = 0; item < mMenuList[i].popupMenu->mMenuItems.size(); item++)
       {
-         if(item->acceleratorIndex == index)
+         if(mMenuList[i].popupMenu->mMenuItems[item].acceleratorIndex == index)
          {
             // first, call the script callback for menu selection:
-            onMenuSelect_callback(mMenuList[i]->id, mMenuList[i]->text);
-         
-            if(item->visible)
-               menuItemSelected(mMenuList[i], item);
+            onMenuSelect_callback(mMenuList[i].popupMenu->getId(), mMenuList[i].text);
             return;
          }
       }
    }
 }
 
-//------------------------------------------------------------------------------
-// Menu display class methods
-//------------------------------------------------------------------------------
-
-GuiMenuBackgroundCtrl::GuiMenuBackgroundCtrl(GuiMenuBar *ctrl, GuiMenuTextListCtrl *textList)
-{
-   mMenuBarCtrl = ctrl;
-   mTextList = textList;
-}
-
-void GuiMenuBackgroundCtrl::onMouseDown(const GuiEvent &event)
-{
-   mTextList->setSelectedCell(Point2I(-1,-1));
-   mMenuBarCtrl->closeMenu();
-}
-
-void GuiMenuBackgroundCtrl::onMouseMove(const GuiEvent &event)
-{
-   GuiCanvas *root = getRoot();
-   GuiControl *ctrlHit = root->findHitControl(event.mousePoint, mLayer - 1);
-   if(ctrlHit == mMenuBarCtrl)  // see if the current mouse over menu is right...
-      mMenuBarCtrl->checkMenuMouseMove(event);
-}
-
-void GuiMenuBackgroundCtrl::onMouseDragged(const GuiEvent &event)
-{
-   GuiCanvas *root = getRoot();
-   GuiControl *ctrlHit = root->findHitControl(event.mousePoint, mLayer - 1);
-   if(ctrlHit == mMenuBarCtrl)  // see if the current mouse over menu is right...
-      mMenuBarCtrl->checkMenuMouseMove(event);
-}
-
-GuiMenuTextListCtrl::GuiMenuTextListCtrl(GuiMenuBar *ctrl)
+void GuiMenuBar::onSleep()
 {
-   mMenuBarCtrl = ctrl;
-   isSubMenu = false; //  Added
+   Parent::onSleep();
 }
 
-void GuiMenuTextListCtrl::onRenderCell(Point2I offset, Point2I cell, bool selected, bool mouseOver)
+//------------------------------------------------------------------------------
+void GuiMenuBar::onAction()
 {
-   if(dStrcmp(mList[cell.y].text + 3, "-\t")) //  Was: dStrcmp(mList[cell.y].text + 2, "-\t")) but has been changed to take into account the submenu flag
-      Parent::onRenderCell(offset, cell, selected, mouseOver);
-   else
-   {
-      S32 yp = offset.y + mCellSize.y / 2;
-      GFX->getDrawUtil()->drawLine(offset.x, yp, offset.x + mCellSize.x, yp, ColorI(128,128,128));
-      GFX->getDrawUtil()->drawLine(offset.x, yp+1, offset.x + mCellSize.x, yp+1, ColorI(255,255,255));
-   }
-   // now see if there's a bitmap...
-   U8 idx = mList[cell.y].text[0];
-   if(idx != 1)
-   {
-      // there's a bitmap...
-      U32 index = U32(idx - 2) * 3;
-      if(!mList[cell.y].active)
-         index += 2;
-      else if(selected || mouseOver)
-         index ++;
-
-      RectI rect = mProfile->mBitmapArrayRects[index];
-      Point2I off = mMenuBarCtrl->maxBitmapSize - rect.extent;
-      off /= 2;
-
-      GFX->getDrawUtil()->clearBitmapModulation();
-      GFX->getDrawUtil()->drawBitmapSR(mProfile->mTextureObject, offset + off, rect);
-   } 
-
-   //  Check if this is a submenu
-   idx = mList[cell.y].text[1];
-   if(idx != 1)
-   {
-      // This is a submenu, so draw an arrow
-      S32 left = offset.x + mCellSize.x - 12;
-      S32 right = left + 8;
-      S32 top = mCellSize.y / 2 + offset.y - 4;
-      S32 bottom = top + 8;
-      S32 middle = top + 4;
-
-      PrimBuild::begin( GFXTriangleList, 3 );
-         if( selected || mouseOver )
-            PrimBuild::color( mProfile->mFontColorHL );
-         else
-            PrimBuild::color( mProfile->mFontColor );
+   if(!mouseDownMenu)
+      return;
 
-         PrimBuild::vertex2i( left,  top );
-         PrimBuild::vertex2i( right, middle );
-         PrimBuild::vertex2i( left, bottom );
-      PrimBuild::end();
-   }
-}
+   mouseDownMenu->popupMenu->hidePopup();
 
-bool GuiMenuTextListCtrl::onKeyDown(const GuiEvent &event)
-{
-   //if the control is a dead end, don't process the input:
-   if ( !mVisible || !mActive || !mAwake )
-      return false;
-   
-   //see if the key down is a <return> or not
-   if ( event.modifier == 0 )
-   {
-      if ( event.keyCode == KEY_RETURN )
-      {
-         mMenuBarCtrl->closeMenu();
-         return true;
-      }
-      else if ( event.keyCode == KEY_ESCAPE )
-      {
-         mSelectedCell.set( -1, -1 );
-         mMenuBarCtrl->closeMenu();
-         return true;
-      }
-   }
-   
-   //otherwise, pass the event to it's parent
-   return Parent::onKeyDown(event);
-}
-
-void GuiMenuTextListCtrl::onMouseDown(const GuiEvent &event)
-{
-   Parent::onMouseDown(event);
-}
+   // first, call the script callback for menu selection:
+   onMenuSelect_callback(mouseDownMenu->popupMenu->getId(), mouseDownMenu->text);
 
-void GuiMenuTextListCtrl::onMouseUp(const GuiEvent &event)
-{
-   Parent::onMouseUp(event);
-   mMenuBarCtrl->closeMenu();
-}
+   mouseDownMenu->popupMenu->mMenuBarCtrl = this;
 
-void GuiMenuTextListCtrl::onCellHighlighted(Point2I cell)
-{
-   // If this text list control is part of a submenu, then don't worry about
-   // passing this along
-   if(!isSubMenu)
-   {
-      RectI globalbounds(getBounds());
-      Point2I globalpoint = localToGlobalCoord(globalbounds.point);
-      globalbounds.point = globalpoint;
-      mMenuBarCtrl->highlightedMenuItem(cell.y, globalbounds, mCellSize);
-   }
+   GuiCanvas *root = getRoot();
+   Point2I pos = Point2I(mouseDownMenu->bounds.point.x, mouseDownMenu->bounds.point.y + mouseDownMenu->bounds.extent.y);
+   mouseDownMenu->popupMenu->showPopup(root, pos.x, pos.y);
 }
 
-//------------------------------------------------------------------------------
-// Submenu display class methods
-//------------------------------------------------------------------------------
-
-GuiSubmenuBackgroundCtrl::GuiSubmenuBackgroundCtrl(GuiMenuBar *ctrl, GuiMenuTextListCtrl *textList) : GuiMenuBackgroundCtrl(ctrl, textList)
+//  Process a tick
+void GuiMenuBar::processTick()
 {
+   if(mMouseInMenu)
+      onMouseInMenu_callback(true);
 }
 
-void GuiSubmenuBackgroundCtrl::onMouseDown(const GuiEvent &event)
+void GuiMenuBar::insert(SimObject* pObject, S32 pos)
 {
-   mTextList->setSelectedCell(Point2I(-1,-1));
-   mMenuBarCtrl->closeMenu();
-}
+   PopupMenu* menu = dynamic_cast<PopupMenu*>(pObject);
+   if (menu == nullptr)
+      return;
 
-bool GuiSubmenuBackgroundCtrl::pointInControl(const Point2I& parentCoordPoint)
-{
-   S32 xt = parentCoordPoint.x - getLeft();
-   S32 yt = parentCoordPoint.y - getTop();
+   MenuEntry newMenu;
+   newMenu.pos = pos >= mMenuList.size() || pos == -1 ? pos = mMenuList.size() : pos;
+   newMenu.drawBitmapOnly = false;
+   newMenu.drawBorder = true;
+   newMenu.bitmapIndex = -1;
+   newMenu.text = menu->barTitle;
+   newMenu.visible = true;
+   newMenu.popupMenu = menu;
 
-   if(findHitControl(Point2I(xt,yt)) == this)
-      return false;
+   if (pos >= mMenuList.size() || pos == -1)
+      mMenuList.push_back(newMenu);
    else
-      return true;
-//   return xt >= 0 && yt >= 0 && xt < getWidth() && yt < getHeight();
+      mMenuList.insert(pos, newMenu);
 }
 
-//------------------------------------------------------------------------------
-
-void GuiMenuBar::menuItemSelected(GuiMenuBar::Menu *menu, GuiMenuBar::MenuItem *item)
+PopupMenu* GuiMenuBar::getMenu(U32 index)
 {
-   if(item->enabled)
-      onMenuItemSelect_callback(menu->id, menu->text, item->id, item->text);
-}
+   if (index >= mMenuList.size())
+      return nullptr;
 
-void GuiMenuBar::onSleep()
-{
-   if(mBackground) // a menu is up?
-   {
-      mTextList->setSelectedCell(Point2I(-1, -1));
-      closeMenu();
-   }
-   Parent::onSleep();
+   return mMenuList[index].popupMenu;
 }
 
-void GuiMenuBar::closeMenu()
+PopupMenu* GuiMenuBar::findMenu(StringTableEntry barTitle)
 {
-   //  First close any open submenu
-   closeSubmenu();
-
-   // Get the selection from the text list:
-   S32 selectionIndex = mTextList->getSelectedCell().y;
-
-   // Pop the background:
-   if( getRoot() )
-      getRoot()->popDialogControl(mBackground);
-   else
-      return;
-   
-   // Kill the popup:
-   mBackground->deleteObject();
-   mBackground = NULL;
-   
-   // Now perform the popup action:
-   if ( selectionIndex != -1 )
+   for (U32 i = 0; i < mMenuList.size(); i++)
    {
-      MenuItem *list = mouseDownMenu->firstMenuItem;
-
-      while(selectionIndex && list)
-      {
-         list = list->nextMenuItem;
-         selectionIndex--;
-      }
-      if(list)
-         menuItemSelected(mouseDownMenu, list);
+      if (mMenuList[i].text == barTitle)
+         return mMenuList[i].popupMenu;
    }
-   mouseDownMenu = NULL;
-}
 
-//  Called when a menu item is highlighted by the mouse
-void GuiMenuBar::highlightedMenuItem(S32 selectionIndex, const RectI& bounds, Point2I cellSize)
-{
-   S32 selstore = selectionIndex;
-
-   // Now perform the popup action:
-   if ( selectionIndex != -1 )
-   {
-      MenuItem *list = mouseDownMenu->firstMenuItem;
-
-      while(selectionIndex && list)
-      {
-         list = list->nextMenuItem;
-         selectionIndex--;
-      }
-
-      if(list)
-     {
-         // If the highlighted item has changed...
-         if(mouseOverSubmenu != list)
-       {
-            closeSubmenu();
-            mouseOverSubmenu = NULL;
-
-            // Check if this is a submenu.  If so, open the submenu.
-            if(list->isSubmenu)
-          {
-            // If there are submenu items, then open the submenu
-             if(list->submenu->firstMenuItem)
-            {
-               mouseOverSubmenu = list;
-               onSubmenuAction(selstore, bounds, cellSize);
-            }
-         }
-       }
-     }
-   }
+   return nullptr;
 }
 
-//------------------------------------------------------------------------------
-void GuiMenuBar::onAction()
+//-----------------------------------------------------------------------------
+// Console Methods
+//-----------------------------------------------------------------------------
+DefineConsoleMethod(GuiMenuBar, attachToCanvas, void, (const char *canvas, S32 pos), , "(GuiCanvas, pos)")
 {
-   if(!mouseDownMenu)
-      return;
-
-   // first, call the script callback for menu selection:
-   onMenuSelect_callback(mouseDownMenu->id, mouseDownMenu->text);
-
-   MenuItem *visWalk = mouseDownMenu->firstMenuItem;
-   while(visWalk)
-   {
-      if(visWalk->visible)
-         break;
-      visWalk = visWalk->nextMenuItem;
-   }
-   if(!visWalk)
-   {
-      mouseDownMenu = NULL;
-      return;
-   }
-
-   mTextList = new GuiMenuTextListCtrl(this);
-   mTextList->setControlProfile(mProfile);
-
-   mBackground = new GuiMenuBackgroundCtrl(this, mTextList);
-
-   GuiCanvas *root = getRoot();
-   Point2I windowExt = root->getExtent();
-
-   mBackground->resize( Point2I(0,0), root->getExtent());
-   S32 textWidth = 0, width = 0;
-   S32 acceleratorWidth = 0;
-
-   GFont *font = mProfile->mFont;
-
-   for(MenuItem *walk = mouseDownMenu->firstMenuItem; walk; walk = walk->nextMenuItem)
+   GuiCanvas* canv = dynamic_cast<GuiCanvas*>(Sim::findObject(canvas));
+   if (canv)
    {
-      if(!walk->visible)
-         continue;
-
-      S32 iTextWidth = font->getStrWidth(walk->text);
-      S32 iAcceleratorWidth = walk->accelerator ? font->getStrWidth(walk->accelerator) : 0;
-
-      if(iTextWidth > textWidth)
-         textWidth = iTextWidth;
-      if(iAcceleratorWidth > acceleratorWidth)
-         acceleratorWidth = iAcceleratorWidth;
+      canv->setMenuBar(object);
    }
-   width = textWidth + acceleratorWidth + maxBitmapSize.x * 2 + 2 + 4;
-
-   mTextList->setCellSize(Point2I(width, font->getHeight()+2));
-   mTextList->clearColumnOffsets();
-   mTextList->addColumnOffset(-1); // add an empty column in for the bitmap index.
-   mTextList->addColumnOffset(maxBitmapSize.x + 1);
-   mTextList->addColumnOffset(maxBitmapSize.x + 1 + textWidth + 4);
-
-   U32 entryCount = 0;
-
-   for(MenuItem *walk = mouseDownMenu->firstMenuItem; walk; walk = walk->nextMenuItem)
-   {
-      if(!walk->visible)
-         continue;
-
-      char buf[512];
-
-     //  If this menu item is a submenu, then set the isSubmenu to 2 to indicate
-     // an arrow should be drawn.  Otherwise set the isSubmenu normally.
-     char isSubmenu = 1;
-     if(walk->isSubmenu)
-        isSubmenu = 2;
-
-      char bitmapIndex = 1;
-      if(walk->bitmapIndex >= 0 && (walk->bitmapIndex * 3 <= mProfile->mBitmapArrayRects.size()))
-         bitmapIndex = walk->bitmapIndex + 2;
-      dSprintf(buf, sizeof(buf), "%c%c\t%s\t%s", bitmapIndex, isSubmenu, walk->text, walk->accelerator ? walk->accelerator : "");
-      mTextList->addEntry(entryCount, buf);
-
-      if(!walk->enabled)
-         mTextList->setEntryActive(entryCount, false);
-
-      entryCount++;
-   }
-   Point2I menuPoint = localToGlobalCoord(mouseDownMenu->bounds.point);
-   menuPoint.y += mouseDownMenu->bounds.extent.y; //  Used to have this at the end: + 2;
-
-   GuiControl *ctrl = new GuiControl;
-   RectI ctrlBounds(  menuPoint, mTextList->getExtent() + Point2I(6, 6));
-   
-   ctrl->setControlProfile(mProfile);
-   mTextList->setPosition( mTextList->getPosition() + Point2I(3,3) );
-   
-   //  Make sure the menu doesn't go beyond the Canvas' bottom edge.
-   if((ctrlBounds.point.y + ctrlBounds.extent.y) > windowExt.y)
-   {
-      //  Pop the menu above the menu bar
-      Point2I menuBar = localToGlobalCoord(mouseDownMenu->bounds.point);
-      ctrlBounds.point.y = menuBar.y - ctrl->getHeight();
-   }
-
-   ctrl->resize(ctrlBounds.point, ctrlBounds.extent);
-   //mTextList->setPosition(Point2I(3,3));
-
-   mTextList->registerObject();
-   mBackground->registerObject();
-   ctrl->registerObject();
-
-   mBackground->addObject( ctrl );
-   ctrl->addObject( mTextList );
-
-   root->pushDialogControl(mBackground, mLayer + 1);
-   mTextList->setFirstResponder();
 }
 
-//------------------------------------------------------------------------------
-//  Performs an action when a menu item that is a submenu is selected/highlighted
-void GuiMenuBar::onSubmenuAction(S32 selectionIndex, const RectI& bounds, Point2I cellSize)
+DefineConsoleMethod(GuiMenuBar, removeFromCanvas, void, (), , "()")
 {
-   if(!mouseOverSubmenu)
-      return;
-
-   // first, call the script callback for menu selection:
-   onSubmenuSelect_callback(mouseOverSubmenu->id, mouseOverSubmenu->text);
-
-   MenuItem *visWalk = mouseOverSubmenu->submenu->firstMenuItem;
-   while(visWalk)
-   {
-      if(visWalk->visible)
-         break;
-      visWalk = visWalk->nextMenuItem;
-   }
-   if(!visWalk)
-   {
-      mouseOverSubmenu = NULL;
-      return;
-   }
-
-   mSubmenuTextList = new GuiMenuTextListCtrl(this);
-   mSubmenuTextList->setControlProfile(mProfile);
-   mSubmenuTextList->isSubMenu = true; // Indicate that this text list is part of a submenu
-
-   mSubmenuBackground = new GuiSubmenuBackgroundCtrl(this, mSubmenuTextList);
-
-   GuiCanvas *root = getRoot();
-   Point2I windowExt = root->getExtent();
-
-   mSubmenuBackground->resize( Point2I(0,0), root->getExtent());
-   S32 textWidth = 0, width = 0;
-   S32 acceleratorWidth = 0;
-
-   GFont *font = mProfile->mFont;
-
-   for(MenuItem *walk = mouseOverSubmenu->submenu->firstMenuItem; walk; walk = walk->nextMenuItem)
-   {
-      if(!walk->visible)
-         continue;
-
-      S32 iTextWidth = font->getStrWidth(walk->text);
-      S32 iAcceleratorWidth = walk->accelerator ? font->getStrWidth(walk->accelerator) : 0;
-
-      if(iTextWidth > textWidth)
-         textWidth = iTextWidth;
-      if(iAcceleratorWidth > acceleratorWidth)
-         acceleratorWidth = iAcceleratorWidth;
-   }
-   width = textWidth + acceleratorWidth + maxBitmapSize.x * 2 + 2 + 4;
-
-   mSubmenuTextList->setCellSize(Point2I(width, font->getHeight()+3));
-   mSubmenuTextList->clearColumnOffsets();
-   mSubmenuTextList->addColumnOffset(-1); // add an empty column in for the bitmap index.
-   mSubmenuTextList->addColumnOffset(maxBitmapSize.x + 1);
-   mSubmenuTextList->addColumnOffset(maxBitmapSize.x + 1 + textWidth + 4);
-
-   U32 entryCount = 0;
-
-   for(MenuItem *walk = mouseOverSubmenu->submenu->firstMenuItem; walk; walk = walk->nextMenuItem)
-   {
-      if(!walk->visible)
-         continue;
-
-      char buf[512];
-
-     //  Can't have submenus within submenus.
-     char isSubmenu = 1;
-
-      char bitmapIndex = 1;
-      if(walk->bitmapIndex >= 0 && (walk->bitmapIndex * 3 <= mProfile->mBitmapArrayRects.size()))
-         bitmapIndex = walk->bitmapIndex + 2;
-      dSprintf(buf, sizeof(buf), "%c%c\t%s\t%s", bitmapIndex, isSubmenu, walk->text, walk->accelerator ? walk->accelerator : "");
-      mSubmenuTextList->addEntry(entryCount, buf);
+   GuiCanvas* canvas = object->getRoot();
 
-      if(!walk->enabled)
-         mSubmenuTextList->setEntryActive(entryCount, false);
-
-      entryCount++;
-   }
-   Point2I menuPoint = bounds.point; //localToGlobalCoord(bounds.point);
-   menuPoint.x += bounds.extent.x;
-   menuPoint.y += cellSize.y * selectionIndex - 6;
-
-   GuiControl *ctrl = new GuiControl;
-   RectI ctrlBounds(menuPoint, mSubmenuTextList->getExtent() + Point2I(6, 6));
-   ctrl->setControlProfile(mProfile);
-   mSubmenuTextList->setPosition( getPosition() + Point2I(3,3));
-
-   //  Make sure the menu doesn't go beyond the Canvas' bottom edge.
-   if((ctrlBounds.point.y + ctrlBounds.extent.y ) > windowExt.y)
-   {
-      //  Pop the menu above the menu bar
-      ctrlBounds.point.y -= mSubmenuTextList->getHeight() - cellSize.y - 6 - 3;
-   }
-
-   //  And the same for the right edge
-   if((ctrlBounds.point.x + ctrlBounds.extent.x) > windowExt.x)
-   {
-      //  Pop the submenu to the left of the menu
-      ctrlBounds.point.x -= mSubmenuTextList->getWidth() + cellSize.x + 6;
-   }
-   ctrl->resize(ctrlBounds.point, ctrlBounds.extent);
-
-   //mSubmenuTextList->setPosition(Point2I(3,3));
-
-   mSubmenuTextList->registerObject();
-   mSubmenuBackground->registerObject();
-   ctrl->registerObject();
-
-   mSubmenuBackground->addObject( ctrl );
-   ctrl->addObject( mSubmenuTextList );
-
-   root->pushDialogControl(mSubmenuBackground, mLayer + 1);
-   mSubmenuTextList->setFirstResponder();
+   if(canvas)
+      canvas->setMenuBar(nullptr);
 }
 
-//  Close down the submenu controls
-void GuiMenuBar::closeSubmenu()
+DefineConsoleMethod(GuiMenuBar, getMenuCount, S32, (), , "()")
 {
-   if(!mSubmenuBackground || !mSubmenuTextList)
-      return;
-
-   // Get the selection from the text list:
-   S32 selectionIndex = mSubmenuTextList->getSelectedCell().y;
-
-   // Pop the background:
-   if( getRoot() )
-      getRoot()->popDialogControl(mSubmenuBackground);
-   
-   // Kill the popup:
-   mSubmenuBackground->deleteObject();
-   mSubmenuBackground = NULL;
-   mSubmenuTextList = NULL;
-   
-   // Now perform the popup action:
-   if ( selectionIndex != -1 )
-   {
-      MenuItem *list = NULL;
-     if(mouseOverSubmenu)
-     {
-         list = mouseOverSubmenu->submenu->firstMenuItem;
-
-         while(selectionIndex && list)
-         {
-            list = list->nextMenuItem;
-            selectionIndex--;
-         }
-     }
-      if(list)
-         menuItemSelected(list->submenuParentMenu, list);
-   }
-   mouseOverSubmenu = NULL;
+   return object->getMenuListCount();
 }
 
-//  Find if the mouse pointer is within a menu item
-GuiMenuBar::MenuItem *GuiMenuBar::findHitMenuItem(Point2I mousePoint)
+DefineConsoleMethod(GuiMenuBar, getMenu, S32, (S32 index), (0), "(Index)")
 {
-
-//   for(Menu *walk = menuList; walk; walk = walk->nextMenu)
-//      if(walk->visible && walk->bounds.pointInRect(pos))
-//         return walk;
-   return NULL;
+   return object->getMenu(index)->getId();
 }
 
-//  Checks if the mouse has been moved to a new menu item
-void GuiMenuBar::checkSubmenuMouseMove(const GuiEvent &event)
+//-----------------------------------------------------------------------------
+DefineConsoleMethod(GuiMenuBar, insert, void, (SimObject* pObject, S32 pos), (nullAsType<SimObject*>(), -1), "(object, pos) insert object at position")
 {
-   MenuItem *hit = findHitMenuItem(event.mousePoint);
-   if(hit && hit != mouseOverSubmenu)
-   {
-      // gotta close out the current menu...
-      mSubmenuTextList->setSelectedCell(Point2I(-1, -1));
-//      closeSubmenu();
-      setUpdate();
-   }
+   object->insert(pObject, pos);
 }
 
-//  Process a tick
-void GuiMenuBar::processTick()
+DefineConsoleMethod(GuiMenuBar, findMenu, S32, (const char* barTitle), (""), "(barTitle)")
 {
-   // If we are to track a tick, then do so.
-   if(mCountMouseOver)
-   {
-      //  If we're at a particular number of ticks, notify the script function
-      if(mMouseOverCounter < mMouseHoverAmount)
-     {
-         ++mMouseOverCounter;
-
-     } else if(mMouseOverCounter == mMouseHoverAmount)
-     {
-         ++mMouseOverCounter;
-       onMouseInMenu_callback(true); // Last parameter indicates if we've entered or left the menu
-     }
-   }
+   StringTableEntry barTitleStr = StringTable->insert(barTitle);
+   PopupMenu* menu = object->findMenu(barTitleStr);
+
+   if (menu)
+      return menu->getId();
+   else
+      return 0;
 }

Engine/source/gui/editor/guiMenuBar.h

@@ -23,119 +23,43 @@
 #ifndef _GUIMENUBAR_H_
 #define _GUIMENUBAR_H_
 
-#ifndef _GUITEXTLISTCTRL_H_
-#include "gui/controls/guiTextListCtrl.h"
-#endif
 #ifndef _GUITICKCTRL_H_
 #include "gui/shiny/guiTickCtrl.h"
 #endif
 
+#ifndef _POPUPMENU_H_
+#include "gui/editor/popupMenu.h"
+#endif
+
 class GuiMenuBar;
-class GuiMenuTextListCtrl;
 class WindowInputGenerator;
 
-class GuiMenuBackgroundCtrl : public GuiControl
-{
-   typedef GuiControl Parent;
-
-protected:
-   GuiMenuBar *mMenuBarCtrl;
-   GuiMenuTextListCtrl *mTextList; 
-public:
-   GuiMenuBackgroundCtrl(GuiMenuBar *ctrl, GuiMenuTextListCtrl* textList);
-   void onMouseDown(const GuiEvent &event);
-   void onMouseMove(const GuiEvent &event);
-   void onMouseDragged(const GuiEvent &event);
-};
-
-class GuiSubmenuBackgroundCtrl : public GuiMenuBackgroundCtrl
-{
-   typedef GuiMenuBackgroundCtrl Parent;
-
-public:
-   GuiSubmenuBackgroundCtrl(GuiMenuBar *ctrl, GuiMenuTextListCtrl* textList);
-   bool pointInControl(const Point2I & parentCoordPoint);
-   void onMouseDown(const GuiEvent &event);
-};
-
-//------------------------------------------------------------------------------
-
-class GuiMenuTextListCtrl : public GuiTextListCtrl
-{
-   private:
-      typedef GuiTextListCtrl Parent;
-
-   protected:
-      GuiMenuBar *mMenuBarCtrl;
-
-   public:
-	  bool isSubMenu; //  Indicates that this text list is in a submenu
-
-      GuiMenuTextListCtrl(); // for inheritance
-      GuiMenuTextListCtrl(GuiMenuBar *ctrl);
-
-      // GuiControl overloads:
-      bool onKeyDown(const GuiEvent &event);
-		void onMouseDown(const GuiEvent &event);
-      void onMouseUp(const GuiEvent &event);
-      void onRenderCell(Point2I offset, Point2I cell, bool selected, bool mouseOver);
-
-      virtual void onCellHighlighted(Point2I cell); //  Added
-};
-
 //------------------------------------------------------------------------------
-
 class GuiMenuBar : public GuiTickCtrl //  Was: GuiControl
 {
    typedef GuiTickCtrl Parent; //  Was: GuiControl Parent;
 public:
 
-	struct Menu;
-
-	struct MenuItem   // an individual item in a pull-down menu
-	{
-		char *text;    // the text of the menu item
-		U32 id;        // a script-assigned identifier
-		char *accelerator; // the keyboard accelerator shortcut for the menu item
-      U32 acceleratorIndex; // index of this accelerator
-		bool enabled;        // true if the menu item is selectable
-      bool visible;        // true if the menu item is visible
-      S32 bitmapIndex;     // index of the bitmap in the bitmap array
-      S32 checkGroup;      // the group index of the item visa vi check marks - 
-                           // only one item in the group can be checked.
-		MenuItem *nextMenuItem; // next menu item in the linked list
-
-		bool isSubmenu;				//  This menu item has a submenu that will be displayed
-
-		Menu* submenuParentMenu; //  For a submenu, this is the parent menu
-      Menu* submenu;
-      String cmd;
-	};
-
-	struct Menu
-	{
-		char *text;
-		U32 id;
-		RectI bounds;
+   struct MenuEntry
+   {
+      U32 pos;
+      RectI bounds;
+
       bool visible;
 
-		S32 bitmapIndex;		// Index of the bitmap in the bitmap array (-1 = no bitmap)
-		bool drawBitmapOnly;	// Draw only the bitmap and not the text
-		bool drawBorder;		// Should a border be drawn around this menu (usually if we only have a bitmap, we don't want a border)
+      S32 bitmapIndex;
+      bool drawBitmapOnly;
 
-		Menu *nextMenu;
-		MenuItem *firstMenuItem;
-	};
-	
-	GuiMenuBackgroundCtrl *mBackground;
-	GuiMenuTextListCtrl *mTextList;
-	
-	GuiSubmenuBackgroundCtrl *mSubmenuBackground; //  Background for a submenu
-	GuiMenuTextListCtrl *mSubmenuTextList;     //  Text list for a submenu
+      bool drawBorder;
+
+      StringTableEntry text;
+      PopupMenu* popupMenu;
+   };
+
+   Vector<MenuEntry> mMenuList;
 
-   Vector<Menu*> mMenuList;
-   Menu *mouseDownMenu;
-   Menu *mouseOverMenu;
+   MenuEntry *mouseDownMenu;
+   MenuEntry *mouseOverMenu;
 
    MenuItem* mouseDownSubmenu; //  Stores the menu item that is a submenu that has been selected
    MenuItem* mouseOverSubmenu; //  Stores the menu item that is a submenu that has been highlighted
@@ -151,59 +75,26 @@ public:
    S32 mVerticalMargin;   // Top and bottom margin around the text of each menu
    S32 mBitmapMargin;     // Margin between a menu's bitmap and text
 
-   //  Used to keep track of the amount of ticks that the mouse is hovering
-   // over a menu.
-   S32 mMouseOverCounter;
-   bool mCountMouseOver;
-   S32 mMouseHoverAmount;
+   U32 mMenubarHeight;
+
+   bool mMouseInMenu;
 	
 	GuiMenuBar();
+
+   void onRemove();
    bool onWake();
    void onSleep();
 
-	// internal menu handling functions
-	// these are used by the script manipulation functions to add/remove/change menu items
-   static Menu* sCreateMenu(const char *menuText, U32 menuId);
-   void addMenu(Menu *menu, S32 pos = -1);
-   void addMenu(const char *menuText, U32 menuId);
-	Menu *findMenu(const char *menu);  // takes either a menu text or a string id
-	static MenuItem *findMenuItem(Menu *menu, const char *menuItem); // takes either a menu text or a string id
-	void removeMenu(Menu *menu);
-	static void removeMenuItem(Menu *menu, MenuItem *menuItem);
-	static MenuItem* addMenuItem(Menu *menu, const char *text, U32 id, const char *accelerator, S32 checkGroup, const char *cmd);
-   static MenuItem* addMenuItem(Menu *menu, MenuItem *menuItem);
-	static void clearMenuItems(Menu *menu);
-   void clearMenus();
-
-   void attachToMenuBar(Menu* menu, S32 pos = -1);
-   void removeFromMenuBar(Menu* menu);
-
-   //  Methods to deal with submenus
-   static MenuItem* findSubmenuItem(Menu *menu, const char *menuItem, const char *submenuItem);
-   static MenuItem* findSubmenuItem(MenuItem *menuItem, const char *submenuItem);
-   static void addSubmenuItem(Menu *menu, MenuItem *submenu, const char *text, U32 id, const char *accelerator, S32 checkGroup);
-   static void addSubmenuItem(Menu *menu, MenuItem *submenu, MenuItem *newMenuItem );
-   static void removeSubmenuItem(MenuItem *menuItem, MenuItem *submenuItem);
-   static void clearSubmenuItems(MenuItem *menuitem);
-   void onSubmenuAction(S32 selectionIndex, const RectI& bounds, Point2I cellSize);
-   void closeSubmenu();
-   void checkSubmenuMouseMove(const GuiEvent &event);
-   MenuItem *findHitMenuItem(Point2I mousePoint);
-
-   void highlightedMenuItem(S32 selectionIndex, const RectI& bounds, Point2I cellSize); //  Called whenever a menu item is highlighted by the mouse
-
-	// display/mouse functions
-
-	Menu *findHitMenu(Point2I mousePoint);
-
-   //  Called when the GUI theme changes and a bitmap arrary may need updating
-  // void onThemeChange();
+   virtual void addObject(SimObject* object);
+
+	MenuEntry *findHitMenu(Point2I mousePoint);
 
    void onPreRender();
 	void onRender(Point2I offset, const RectI &updateRect);
 
    void checkMenuMouseMove(const GuiEvent &event);
    void onMouseMove(const GuiEvent &event);
+   void onMouseEnter(const GuiEvent &event);
    void onMouseLeave(const GuiEvent &event);
    void onMouseDown(const GuiEvent &event);
    void onMouseDragged(const GuiEvent &event);
@@ -215,18 +106,22 @@ public:
    void removeWindowAcceleratorMap( WindowInputGenerator &inputGenerator );
    void acceleratorKeyPress(U32 index);
 
-   virtual void menuItemSelected(Menu *menu, MenuItem *item);
-
    //  Added to support 'ticks'
    void processTick();
 
+   void insert(SimObject* pObject, S32 pos);
+
    static void initPersistFields();
 
+   U32 getMenuListCount() { return mMenuList.size(); }
+
+   PopupMenu* getMenu(U32 index);
+   PopupMenu* findMenu(StringTableEntry barTitle);
+
    DECLARE_CONOBJECT(GuiMenuBar);
    DECLARE_CALLBACK( void, onMouseInMenu, ( bool hasLeftMenu ));
    DECLARE_CALLBACK( void, onMenuSelect, ( S32 menuId, const char* menuText ));
    DECLARE_CALLBACK( void, onMenuItemSelect, ( S32 menuId, const char* menuText, S32 menuItemId, const char* menuItemText  ));
-   DECLARE_CALLBACK( void, onSubmenuSelect, ( S32 submenuId, const char* submenuText ));
 };
 
 #endif

Engine/source/gui/editor/guiPopupMenuCtrl.cpp

@@ -25,20 +25,32 @@
 #include "gfx/primBuilder.h"
 #include "gui/core/guiCanvas.h"
 
-GuiPopupMenuBackgroundCtrl::GuiPopupMenuBackgroundCtrl(GuiPopupMenuTextListCtrl *textList)
+GuiPopupMenuBackgroundCtrl::GuiPopupMenuBackgroundCtrl()
 {
-   mTextList = textList;
-   mTextList->mBackground = this;
+   mMenuBarCtrl = nullptr;
 }
 
 void GuiPopupMenuBackgroundCtrl::onMouseDown(const GuiEvent &event)
 {
-   mTextList->setSelectedCell(Point2I(-1, -1));
+   
+}
+
+void GuiPopupMenuBackgroundCtrl::onMouseUp(const GuiEvent &event)
+{
+   clearPopups();
+
+   //Pass along the event just in case we clicked over a menu item. We don't want to eat the input for it.
+   if (mMenuBarCtrl)
+      mMenuBarCtrl->onMouseUp(event);
+
    close();
 }
 
 void GuiPopupMenuBackgroundCtrl::onMouseMove(const GuiEvent &event)
 {
+   //It's possible we're trying to pan through a menubar while a popup is displayed. Pass along our event to the menubar for good measure
+   if (mMenuBarCtrl)
+      mMenuBarCtrl->onMouseMove(event);
 }
 
 void GuiPopupMenuBackgroundCtrl::onMouseDragged(const GuiEvent &event)
@@ -47,27 +59,66 @@ void GuiPopupMenuBackgroundCtrl::onMouseDragged(const GuiEvent &event)
 
 void GuiPopupMenuBackgroundCtrl::close()
 {
-   getRoot()->removeObject(this);
+   if(getRoot())
+      getRoot()->removeObject(this);
+
+   mMenuBarCtrl = nullptr;
+}
+
+S32 GuiPopupMenuBackgroundCtrl::findPopupMenu(PopupMenu* menu)
+{
+   S32 menuId = -1;
+
+   for (U32 i = 0; i < mPopups.size(); i++)
+   {
+      if (mPopups[i]->getId() == menu->getId())
+         return i;
+   }
+
+   return menuId;
+}
+
+void GuiPopupMenuBackgroundCtrl::clearPopups()
+{
+   for (U32 i = 0; i < mPopups.size(); i++)
+   {
+      mPopups[i]->mTextList->setSelectedCell(Point2I(-1, -1));
+      mPopups[i]->mTextList->mPopup->hidePopup();
+   }
 }
 
 GuiPopupMenuTextListCtrl::GuiPopupMenuTextListCtrl()
 {
    isSubMenu = false; //  Added
-   mMenu = NULL;
-   mMenuBar = NULL;
-   mPopup = NULL;
+
+   mMenuBar = nullptr;
+   mPopup = nullptr;
+
+   mLastHighlightedMenuIdx = -1;
 }
 
 void GuiPopupMenuTextListCtrl::onRenderCell(Point2I offset, Point2I cell, bool selected, bool mouseOver)
 {
-   if (dStrcmp(mList[cell.y].text + 3, "-\t")) //  Was: dStrcmp(mList[cell.y].text + 2, "-\t")) but has been changed to take into account the submenu flag
-      Parent::onRenderCell(offset, cell, selected, mouseOver);
-   else
+   //check if we're a real entry, or if it's a divider
+   if (mPopup->mMenuItems[cell.y].isSpacer)
    {
       S32 yp = offset.y + mCellSize.y / 2;
-      GFX->getDrawUtil()->drawLine(offset.x, yp, offset.x + mCellSize.x, yp, ColorI(128, 128, 128));
-      GFX->getDrawUtil()->drawLine(offset.x, yp + 1, offset.x + mCellSize.x, yp + 1, ColorI(255, 255, 255));
+      GFX->getDrawUtil()->drawLine(offset.x + 5, yp, offset.x + mCellSize.x - 5, yp, ColorI(128, 128, 128));
+   }
+   else
+   {
+      if (dStrcmp(mList[cell.y].text + 3, "-\t")) //  Was: dStrcmp(mList[cell.y].text + 2, "-\t")) but has been changed to take into account the submenu flag
+      {
+         Parent::onRenderCell(offset, cell, selected, mouseOver);
+      }
+      else
+      {
+         S32 yp = offset.y + mCellSize.y / 2;
+         GFX->getDrawUtil()->drawLine(offset.x, yp, offset.x + mCellSize.x, yp, ColorI(128, 128, 128));
+         GFX->getDrawUtil()->drawLine(offset.x, yp + 1, offset.x + mCellSize.x, yp + 1, ColorI(255, 255, 255));
+      }
    }
+
    // now see if there's a bitmap...
    U8 idx = mList[cell.y].text[0];
    if (idx != 1)
@@ -101,16 +152,22 @@ void GuiPopupMenuTextListCtrl::onRenderCell(Point2I offset, Point2I cell, bool s
       S32 bottom = top + 8;
       S32 middle = top + 4;
 
-      PrimBuild::begin(GFXTriangleList, 3);
+      //PrimBuild::begin(GFXTriangleList, 3);
+
+      ColorI color = ColorI::BLACK;
       if (selected || mouseOver)
-         PrimBuild::color(mProfile->mFontColorHL);
+         color = mProfile->mFontColorHL;
       else
-         PrimBuild::color(mProfile->mFontColor);
+         color = mProfile->mFontColor;
+
+      GFX->getDrawUtil()->drawLine(Point2I(left, top), Point2I(right, middle), color);
+      GFX->getDrawUtil()->drawLine(Point2I(right, middle), Point2I(left, bottom), color);
+      GFX->getDrawUtil()->drawLine(Point2I(left, bottom), Point2I(left, top), color);
 
-      PrimBuild::vertex2i(left, top);
+      /*PrimBuild::vertex2i(left, top);
       PrimBuild::vertex2i(right, middle);
       PrimBuild::vertex2i(left, bottom);
-      PrimBuild::end();
+      PrimBuild::end();*/
    }
 }
 
@@ -153,17 +210,12 @@ void GuiPopupMenuTextListCtrl::onMouseUp(const GuiEvent &event)
 
    if (selectionIndex != -1)
    {
-      GuiMenuBar::MenuItem *list = mMenu->firstMenuItem;
+      MenuItem *item = &mPopup->mMenuItems[selectionIndex];
 
-      while (selectionIndex && list)
+      if (item)
       {
-         list = list->nextMenuItem;
-         selectionIndex--;
-      }
-      if (list)
-      {
-         if (list->enabled)
-            dAtob(Con::executef(mPopup, "onSelectItem", Con::getIntArg(getSelectedCell().y), list->text ? list->text : ""));
+         if (item->enabled)
+            dAtob(Con::executef(mPopup, "onSelectItem", Con::getIntArg(getSelectedCell().y), item->text.isNotEmpty() ? item->text : ""));
       }
    }
 
@@ -181,4 +233,23 @@ void GuiPopupMenuTextListCtrl::onCellHighlighted(Point2I cell)
       Point2I globalpoint = localToGlobalCoord(globalbounds.point);
       globalbounds.point = globalpoint;
    }
+
+   S32 selectionIndex = cell.y;
+
+   if (selectionIndex != -1 && mLastHighlightedMenuIdx != selectionIndex)
+   {
+      mLastHighlightedMenuIdx = selectionIndex;
+
+      mPopup->hidePopupSubmenus();
+   }
+
+   if (selectionIndex != -1)
+   {
+      MenuItem *list = &mPopup->mMenuItems[selectionIndex];
+
+      if (list->isSubmenu && list->subMenu != nullptr)
+      {
+         list->subMenu->showPopup(getRoot(), getPosition().x + mCellSize.x, getPosition().y + (selectionIndex * mCellSize.y));
+      }
+   }
 }

Engine/source/gui/editor/guiPopupMenuCtrl.h

@@ -42,6 +42,7 @@ class GuiPopupMenuBackgroundCtrl;
 class GuiPopupMenuTextListCtrl : public GuiTextListCtrl
 {
    friend class GuiPopupMenuBackgroundCtrl;
+   friend class PopupMenu;
 
 private:
    typedef GuiTextListCtrl Parent;
@@ -51,10 +52,12 @@ private:
 public:
    bool isSubMenu; //  Indicates that this text list is in a submenu
    Point2I maxBitmapSize;
-   GuiMenuBar::Menu* mMenu;
+
    GuiMenuBar* mMenuBar;
    PopupMenu* mPopup;
 
+   S32 mLastHighlightedMenuIdx;
+
    GuiPopupMenuTextListCtrl();
 
    // GuiControl overloads:
@@ -70,16 +73,21 @@ class GuiPopupMenuBackgroundCtrl : public GuiControl
 {
    typedef GuiControl Parent;
 
-protected:
-   GuiPopupMenuTextListCtrl *mTextList;
-
 public:
-   GuiPopupMenuBackgroundCtrl(GuiPopupMenuTextListCtrl* textList);
+   GuiPopupMenuBackgroundCtrl();
    void onMouseDown(const GuiEvent &event);
+   void onMouseUp(const GuiEvent &event);
    void onMouseMove(const GuiEvent &event);
    void onMouseDragged(const GuiEvent &event);
 
    void close();
+
+   void clearPopups();
+
+   S32 findPopupMenu(PopupMenu* menu);
+
+   Vector<PopupMenu*> mPopups;
+   GuiMenuBar* mMenuBarCtrl;
 };
 
 #endif

Engine/source/gui/editor/guiShapeEdPreview.cpp

@@ -926,8 +926,8 @@ void GuiShapeEdPreview::handleMouseDown(const GuiEvent& event, GizmoMode mode)
       }
    }
 
-   if ( mode == RotateMode )
-      mRenderCameraAxes = true;
+   //if ( mode == RotateMode )
+   //   mRenderCameraAxes = true;
 }
 
 void GuiShapeEdPreview::handleMouseUp(const GuiEvent& event, GizmoMode mode)
@@ -941,8 +941,8 @@ void GuiShapeEdPreview::handleMouseUp(const GuiEvent& event, GizmoMode mode)
       mGizmo->on3DMouseUp( mLastEvent );
    }
 
-   if ( mode == RotateMode )
-      mRenderCameraAxes = false;
+   //if ( mode == RotateMode )
+   //   mRenderCameraAxes = false;
 }
 
 void GuiShapeEdPreview::handleMouseMove(const GuiEvent& event, GizmoMode mode)
@@ -1164,6 +1164,19 @@ void GuiShapeEdPreview::computeSceneBounds(Box3F& bounds)
 {
    if ( mModel )
       mModel->computeBounds( mCurrentDL, bounds );
+
+   if (bounds.getExtents().x < POINT_EPSILON || bounds.getExtents().y < POINT_EPSILON || bounds.getExtents().z < POINT_EPSILON)
+   {
+      bounds.set(Point3F::Zero);
+
+      //We probably don't have any actual meshes in this model, so compute using the bones if we have them
+      for (S32 i = 0; i < mModel->getShape()->nodes.size(); i++)
+      {
+         Point3F nodePos = mModel->mNodeTransforms[i].getPosition();
+
+         bounds.extend(nodePos);
+      }
+   }
 }
 
 void GuiShapeEdPreview::updateDetailLevel(const SceneRenderState* state)

Engine/source/gui/editor/inspector/entityGroup.cpp

@@ -70,7 +70,8 @@ bool GuiInspectorEntityGroup::inspectGroup()
    {
       Entity* target = dynamic_cast<Entity*>(mParent->getInspectObject(0));
 
-      Con::executef(this, "inspectObject", target->getIdString());
+      if(target)
+         Con::executef(this, "inspectObject", target->getIdString());
    }
 
    return true;

Engine/source/gui/editor/inspector/variableField.h

@@ -57,6 +57,7 @@ public:
 
 protected:
    StringTableEntry mVariableName;
+   StringTableEntry mSetCallbackName;
    SimObject* mOwnerObject;
 };
 

Engine/source/gui/editor/inspector/variableGroup.cpp

@@ -151,6 +151,9 @@ bool GuiInspectorVariableGroup::inspectGroup()
       fieldGui->setInspectorField(NULL, mFields[i]->mFieldLabel);
       fieldGui->setDocs(mFields[i]->mFieldDescription);
 
+      if(mFields[i]->mSetCallbackName != StringTable->EmptyString())
+         fieldGui->setSpecialEditCallbackName(mFields[i]->mSetCallbackName);
+
       /*if (mFields[i]->mSetCallbackName != StringTable->EmptyString())
       {
          fieldGui->on.notify()

Engine/source/gui/editor/inspector/variableInspector.cpp

@@ -167,6 +167,10 @@ void GuiVariableInspector::addField(const char* name, const char* label, const c
       fieldTypeMask = TypeColorF;
    else if (newField.mFieldTypeName == StringTable->insert("ease"))
       fieldTypeMask = TypeEaseF;
+   else if (newField.mFieldTypeName == StringTable->insert("command"))
+      fieldTypeMask = TypeCommand;
+   else if (newField.mFieldTypeName == StringTable->insert("filename"))
+      fieldTypeMask = TypeStringFilename;
    else
       fieldTypeMask = -1;
 
@@ -191,7 +195,10 @@ void GuiVariableInspector::addCallbackField(const char* name, const char* label,
 
 void GuiVariableInspector::clearFields()
 {
+   mGroups.clear();
    mFields.clear();
+   clear();
+   
    update();
 }
 

Engine/source/gui/editor/popupMenu.cpp

@@ -0,0 +1,506 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+#include "gui/editor/popupMenu.h"
+#include "console/consoleTypes.h"
+#include "console/engineAPI.h"
+#include "gui/core/guiCanvas.h"
+#include "core/util/safeDelete.h"
+#include "gui/editor/guiPopupMenuCtrl.h"
+#include "gui/editor/guiMenuBar.h"
+
+static U32 sMaxPopupGUID = 0;
+PopupMenuEvent PopupMenu::smPopupMenuEvent;
+bool PopupMenu::smSelectionEventHandled = false;
+
+/// Event class used to remove popup menus from the event notification in a safe way
+class PopUpNotifyRemoveEvent : public SimEvent
+{   
+public:
+   void process(SimObject *object)
+   {
+      PopupMenu::smPopupMenuEvent.remove((PopupMenu *)object, &PopupMenu::handleSelectEvent);
+   }
+};
+
+//-----------------------------------------------------------------------------
+// Constructor/Destructor
+//-----------------------------------------------------------------------------
+PopupMenu::PopupMenu()
+{
+   bitmapIndex = -1;
+
+   barTitle = StringTable->EmptyString();
+
+   mMenuBarCtrl = nullptr;
+   mTextList = nullptr;
+
+   isSubmenu = false;
+}
+
+PopupMenu::~PopupMenu()
+{
+   PopupMenu::smPopupMenuEvent.remove(this, &PopupMenu::handleSelectEvent);
+}
+
+IMPLEMENT_CONOBJECT(PopupMenu);
+
+ConsoleDocClass( PopupMenu,
+   "@brief PopupMenu represents a system menu.\n\n"
+   "You can add menu items to the menu, but there is no torque object associated "
+   "with these menu items, they exist only in a  platform specific manner.\n\n"
+   "@note Internal use only\n\n"
+   "@internal"
+);
+
+//-----------------------------------------------------------------------------
+void PopupMenu::initPersistFields()
+{
+   Parent::initPersistFields();
+
+   addField("barTitle", TypeCaseString, Offset(barTitle, PopupMenu), "");
+}
+
+//-----------------------------------------------------------------------------
+bool PopupMenu::onAdd()
+{
+   if(! Parent::onAdd())
+      return false;
+
+   Con::executef(this, "onAdd");
+   return true;
+}
+
+void PopupMenu::onRemove()
+{
+   Con::executef(this, "onRemove");
+
+   Parent::onRemove();
+}
+
+//-----------------------------------------------------------------------------
+void PopupMenu::onMenuSelect()
+{
+   Con::executef(this, "onMenuSelect");
+}
+
+//-----------------------------------------------------------------------------
+void PopupMenu::handleSelectEvent(U32 popID, U32 command)
+{  
+}
+
+//-----------------------------------------------------------------------------
+bool PopupMenu::onMessageReceived(StringTableEntry queue, const char* event, const char* data)
+{
+   return Con::executef(this, "onMessageReceived", queue, event, data);
+}
+
+bool PopupMenu::onMessageObjectReceived(StringTableEntry queue, Message *msg )
+{
+   return Con::executef(this, "onMessageReceived", queue, Con::getIntArg(msg->getId()));
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Platform Menu Data
+//////////////////////////////////////////////////////////////////////////
+GuiMenuBar* PopupMenu::getMenuBarCtrl()
+{
+   return mMenuBarCtrl;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Public Methods
+//////////////////////////////////////////////////////////////////////////
+S32 PopupMenu::insertItem(S32 pos, const char *title, const char* accelerator, const char* cmd)
+{
+   String titleString = title;
+
+   MenuItem newItem;
+   newItem.id = pos;
+   newItem.text = titleString;
+   newItem.cmd = cmd;
+
+   if (titleString.isEmpty() || titleString == String("-"))
+      newItem.isSpacer = true;
+   else
+      newItem.isSpacer = false;
+
+   if (accelerator[0])
+      newItem.accelerator = dStrdup(accelerator);
+   else
+      newItem.accelerator = NULL;
+
+   newItem.visible = true;
+   newItem.isChecked = false;
+   newItem.acceleratorIndex = 0;
+   newItem.enabled = !newItem.isSpacer;
+
+   newItem.isSubmenu = false;
+   newItem.subMenu = nullptr;
+   newItem.subMenuParentMenu = nullptr;
+
+   mMenuItems.push_back(newItem);
+
+   return pos;
+}
+
+S32 PopupMenu::insertSubMenu(S32 pos, const char *title, PopupMenu *submenu)
+{
+   S32 itemPos = insertItem(pos, title, "", "");
+
+   mMenuItems[itemPos].isSubmenu = true;
+   mMenuItems[itemPos].subMenu = submenu;
+   mMenuItems[itemPos].subMenuParentMenu = this;
+
+   submenu->isSubmenu = true;
+
+   return itemPos;
+}
+
+bool PopupMenu::setItem(S32 pos, const char *title, const char* accelerator, const char* cmd)
+{
+   String titleString = title;
+
+   for (U32 i = 0; i < mMenuItems.size(); i++)
+   {
+      if (mMenuItems[i].text == titleString)
+      {
+         mMenuItems[i].id = pos;
+         mMenuItems[i].cmd = cmd;
+         
+         if (accelerator && accelerator[0])
+            mMenuItems[i].accelerator = dStrdup(accelerator);
+         else
+            mMenuItems[i].accelerator = NULL;
+         return true;
+      }
+   }
+   
+   return false;
+}
+
+void PopupMenu::removeItem(S32 itemPos)
+{
+   if (mMenuItems.size() < itemPos || itemPos < 0)
+      return;
+
+   mMenuItems.erase(itemPos);
+}
+
+//////////////////////////////////////////////////////////////////////////
+void PopupMenu::enableItem(S32 pos, bool enable)
+{
+   if (mMenuItems.size() < pos || pos < 0)
+      return;
+
+   mMenuItems[pos].enabled = enable;
+}
+
+void PopupMenu::checkItem(S32 pos, bool checked)
+{
+   if (mMenuItems.size() < pos || pos < 0)
+      return;
+
+   if (checked && mMenuItems[pos].checkGroup != -1)
+   {
+      // first, uncheck everything in the group:
+      for (U32 i = 0; i < mMenuItems.size(); i++)
+         if (mMenuItems[i].checkGroup == mMenuItems[pos].checkGroup && mMenuItems[i].isChecked)
+            mMenuItems[i].isChecked = false;
+   }
+
+   mMenuItems[pos].isChecked;
+}
+
+void PopupMenu::checkRadioItem(S32 firstPos, S32 lastPos, S32 checkPos)
+{
+   for (U32 i = 0; i < mMenuItems.size(); i++)
+   {
+      if (mMenuItems[i].id >= firstPos && mMenuItems[i].id <= lastPos)
+      {
+         mMenuItems[i].isChecked = false;
+      }
+   }
+}
+
+bool PopupMenu::isItemChecked(S32 pos)
+{
+   if (mMenuItems.size() < pos || pos < 0)
+      return false;
+
+   return mMenuItems[pos].isChecked;
+}
+
+U32 PopupMenu::getItemCount()
+{
+   return mMenuItems.size();
+}
+
+//////////////////////////////////////////////////////////////////////////
+bool PopupMenu::canHandleID(U32 id)
+{
+   return true;
+}
+
+bool PopupMenu::handleSelect(U32 command, const char *text /* = NULL */)
+{
+   return dAtob(Con::executef(this, "onSelectItem", Con::getIntArg(command), text ? text : ""));
+}
+
+//////////////////////////////////////////////////////////////////////////
+void PopupMenu::showPopup(GuiCanvas *owner, S32 x /* = -1 */, S32 y /* = -1 */)
+{
+   if (owner == NULL)
+      return;
+
+   GuiControl* editorGui;
+   Sim::findObject("EditorGui", editorGui);
+
+   if (editorGui)
+   {
+      GuiPopupMenuBackgroundCtrl* backgroundCtrl;
+      Sim::findObject("PopUpMenuControl", backgroundCtrl);
+
+      GuiControlProfile* profile;
+      Sim::findObject("GuiMenubarProfile", profile);
+
+      if (!profile)
+         return;
+
+      if (mTextList == nullptr)
+      {
+         mTextList = new GuiPopupMenuTextListCtrl();
+         mTextList->registerObject();
+         mTextList->setControlProfile(profile);
+
+         mTextList->mPopup = this;
+         mTextList->mMenuBar = getMenuBarCtrl();
+      }
+
+      if (!backgroundCtrl)
+      {
+         backgroundCtrl = new GuiPopupMenuBackgroundCtrl();
+
+         backgroundCtrl->registerObject("PopUpMenuControl");
+      }
+
+      if (!backgroundCtrl || !mTextList)
+         return;
+
+      if (!isSubmenu)
+      {
+         //if we're a 'parent' menu, then tell the background to clear out all existing other popups
+
+         backgroundCtrl->clearPopups();
+      }
+
+      //find out if we're doing a first-time add
+      S32 popupIndex = backgroundCtrl->findPopupMenu(this);
+
+      if (popupIndex == -1)
+      {
+         backgroundCtrl->addObject(mTextList);
+         backgroundCtrl->mPopups.push_back(this);
+      }
+
+      mTextList->mBackground = backgroundCtrl;
+
+      owner->pushDialogControl(backgroundCtrl, 10);
+
+      //Set the background control's menubar, if any, and if it's not already set
+      if(backgroundCtrl->mMenuBarCtrl == nullptr)
+         backgroundCtrl->mMenuBarCtrl = getMenuBarCtrl();
+
+      backgroundCtrl->setExtent(editorGui->getExtent());
+
+      mTextList->clear();
+
+      S32 textWidth = 0, width = 0;
+      S32 acceleratorWidth = 0;
+      GFont *font = profile->mFont;
+
+      Point2I maxBitmapSize = Point2I(0, 0);
+
+      S32 numBitmaps = profile->mBitmapArrayRects.size();
+      if (numBitmaps)
+      {
+         RectI *bitmapBounds = profile->mBitmapArrayRects.address();
+         for (S32 i = 0; i < numBitmaps; i++)
+         {
+            if (bitmapBounds[i].extent.x > maxBitmapSize.x)
+               maxBitmapSize.x = bitmapBounds[i].extent.x;
+            if (bitmapBounds[i].extent.y > maxBitmapSize.y)
+               maxBitmapSize.y = bitmapBounds[i].extent.y;
+         }
+      }
+
+      for (U32 i = 0; i < mMenuItems.size(); i++)
+      {
+         if (!mMenuItems[i].visible)
+            continue;
+
+         S32 iTextWidth = font->getStrWidth(mMenuItems[i].text.c_str());
+         S32 iAcceleratorWidth = mMenuItems[i].accelerator ? font->getStrWidth(mMenuItems[i].accelerator) : 0;
+
+         if (iTextWidth > textWidth)
+            textWidth = iTextWidth;
+         if (iAcceleratorWidth > acceleratorWidth)
+            acceleratorWidth = iAcceleratorWidth;
+      }
+
+      width = textWidth + acceleratorWidth + maxBitmapSize.x * 2 + 2 + 4;
+
+      mTextList->setCellSize(Point2I(width, font->getHeight() + 2));
+      mTextList->clearColumnOffsets();
+      mTextList->addColumnOffset(-1); // add an empty column in for the bitmap index.
+      mTextList->addColumnOffset(maxBitmapSize.x + 1);
+      mTextList->addColumnOffset(maxBitmapSize.x + 1 + textWidth + 4);
+
+      U32 entryCount = 0;
+
+      for (U32 i = 0; i < mMenuItems.size(); i++)
+      {
+         if (!mMenuItems[i].visible)
+            continue;
+
+         char buf[512];
+
+         //  If this menu item is a submenu, then set the isSubmenu to 2 to indicate
+         // an arrow should be drawn.  Otherwise set the isSubmenu normally.
+         char isSubmenu = 1;
+         if (mMenuItems[i].isSubmenu)
+            isSubmenu = 2;
+
+         char bitmapIndex = 1;
+         if (mMenuItems[i].bitmapIndex >= 0 && (mMenuItems[i].bitmapIndex * 3 <= profile->mBitmapArrayRects.size()))
+            bitmapIndex = mMenuItems[i].bitmapIndex + 2;
+
+         dSprintf(buf, sizeof(buf), "%c%c\t%s\t%s", bitmapIndex, isSubmenu, mMenuItems[i].text.c_str(), mMenuItems[i].accelerator ? mMenuItems[i].accelerator : "");
+         mTextList->addEntry(entryCount, buf);
+
+         if (!mMenuItems[i].enabled)
+            mTextList->setEntryActive(entryCount, false);
+
+         entryCount++;
+      }
+
+      Point2I pos = Point2I::Zero;
+
+      if (x == -1 && y == -1)
+         pos = owner->getCursorPos();
+      else
+         pos = Point2I(x, y);
+
+      mTextList->setPosition(pos);
+
+      //nudge in if we'd overshoot the screen
+      S32 widthDiff = (mTextList->getPosition().x + mTextList->getExtent().x) - backgroundCtrl->getWidth();
+      if (widthDiff > 0)
+      {
+         Point2I popupPos = mTextList->getPosition();
+         mTextList->setPosition(popupPos.x - widthDiff, popupPos.y);
+      }
+
+      mTextList->setHidden(false);
+   }
+}
+
+void PopupMenu::hidePopup()
+{
+   if (mTextList)
+   {
+      mTextList->setHidden(true);
+   }
+
+   hidePopupSubmenus();
+}
+
+void PopupMenu::hidePopupSubmenus()
+{
+   for (U32 i = 0; i < mMenuItems.size(); i++)
+   {
+      if (mMenuItems[i].subMenu != nullptr)
+         mMenuItems[i].subMenu->hidePopup();
+   }
+}
+
+//-----------------------------------------------------------------------------
+// Console Methods
+//-----------------------------------------------------------------------------
+DefineConsoleMethod(PopupMenu, insertItem, S32, (S32 pos, const char * title, const char * accelerator, const char* cmd), ("", "", ""), "(pos[, title][, accelerator][, cmd])")
+{
+   return object->insertItem(pos, title, accelerator, cmd);
+}
+
+DefineConsoleMethod(PopupMenu, removeItem, void, (S32 pos), , "(pos)")
+{
+   object->removeItem(pos);
+}
+
+DefineConsoleMethod(PopupMenu, insertSubMenu, S32, (S32 pos, String title, String subMenu), , "(pos, title, subMenu)")
+{
+   PopupMenu *mnu = dynamic_cast<PopupMenu *>(Sim::findObject(subMenu));
+   if(mnu == NULL)
+   {
+      Con::errorf("PopupMenu::insertSubMenu - Invalid PopupMenu object specified for submenu");
+      return -1;
+   }
+   return object->insertSubMenu(pos, title, mnu);
+}
+
+DefineConsoleMethod(PopupMenu, setItem, bool, (S32 pos, const char * title, const char * accelerator, const char *cmd), (""), "(pos, title[, accelerator][, cmd])")
+{
+   return object->setItem(pos, title, accelerator, cmd);
+}
+
+//-----------------------------------------------------------------------------
+
+DefineConsoleMethod(PopupMenu, enableItem, void, (S32 pos, bool enabled), , "(pos, enabled)")
+{
+   object->enableItem(pos, enabled);
+}
+
+DefineConsoleMethod(PopupMenu, checkItem, void, (S32 pos, bool checked), , "(pos, checked)")
+{
+   object->checkItem(pos, checked);
+}
+
+DefineConsoleMethod(PopupMenu, checkRadioItem, void, (S32 firstPos, S32 lastPos, S32 checkPos), , "(firstPos, lastPos, checkPos)")
+{
+   object->checkRadioItem(firstPos, lastPos, checkPos);
+}
+
+DefineConsoleMethod(PopupMenu, isItemChecked, bool, (S32 pos), , "(pos)")
+{
+   return object->isItemChecked(pos);
+}
+
+DefineConsoleMethod(PopupMenu, getItemCount, S32, (), , "()")
+{
+   return object->getItemCount();
+}
+
+//-----------------------------------------------------------------------------
+DefineConsoleMethod(PopupMenu, showPopup, void, (const char * canvasName, S32 x, S32 y), ( -1, -1), "(Canvas,[x, y])")
+{
+   GuiCanvas *pCanvas = dynamic_cast<GuiCanvas*>(Sim::findObject(canvasName));
+   object->showPopup(pCanvas, x, y);
+}

Engine/source/platform/menus/popupMenu.h → Engine/source/gui/editor/popupMenu.h

@@ -19,17 +19,43 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
+#ifndef _POPUPMENU_H_
+#define _POPUPMENU_H_
+
 #include "console/simBase.h"
 #include "core/util/tVector.h"
 #include "util/messaging/dispatcher.h"
 #include "gui/core/guiCanvas.h"
 
-#ifndef _POPUPMENU_H_
-#define _POPUPMENU_H_
+class PopupMenu;
+class GuiMenuBar;
+class GuiPopupMenuTextListCtrl;
+class GuiPopupMenuBackgroundCtrl;
+
+struct MenuItem   // an individual item in a pull-down menu
+{
+   String text;    // the text of the menu item
+   U32 id;        // a script-assigned identifier
+   char *accelerator; // the keyboard accelerator shortcut for the menu item
+   U32 acceleratorIndex; // index of this accelerator
+   bool enabled;        // true if the menu item is selectable
+   bool visible;        // true if the menu item is visible
+   S32 bitmapIndex;     // index of the bitmap in the bitmap array
+   S32 checkGroup;      // the group index of the item visa vi check marks - 
+                        // only one item in the group can be checked.
+
+   bool isSubmenu;				//  This menu item has a submenu that will be displayed
+
+   bool isChecked;
 
-// Forward ref used by the platform code
-struct PlatformPopupMenuData;
-class MenuBar;
+   bool isSpacer;
+
+   bool isMenubarEntry;
+
+   PopupMenu* subMenuParentMenu; //  For a submenu, this is the parent menu
+   PopupMenu* subMenu;
+   String cmd;
+};
 
 // PopupMenu represents a menu.
 // You can add menu items to the menu, but there is no torque object associated
@@ -37,30 +63,32 @@ class MenuBar;
 class PopupMenu : public SimObject, public virtual Dispatcher::IMessageListener
 {
    typedef SimObject Parent;
+   friend class GuiMenuBar;
+   friend class GuiPopupMenuTextListCtrl;
+   friend class GuiPopupMenuBackgroundCtrl;
 
-   friend class MenuBar;
+protected:
+   Vector<MenuItem> mMenuItems;
 
-private:
-   /// Used by MenuBar to attach the menu to the menu bar. Do not use anywhere else.
-   void attachToMenuBar(GuiCanvas *owner, S32 pos);
+   GuiMenuBar* mMenuBarCtrl;
 
-protected:
-   PlatformPopupMenuData *mData;
-   
-   SimSet *mSubmenus;
-   SimObjectPtr<GuiCanvas> mCanvas;
+   StringTableEntry barTitle;
 
-   StringTableEntry mBarTitle;
+   RectI bounds;
+   bool visible;
 
-	U32 mPopupGUID;
-   
-   bool mIsPopup;
+   S32 bitmapIndex;		// Index of the bitmap in the bitmap array (-1 = no bitmap)
+   bool drawBitmapOnly;	// Draw only the bitmap and not the text
+   bool drawBorder;		// Should a border be drawn around this menu (usually if we only have a bitmap, we don't want a border)
+
+   bool isSubmenu;
+
+   //This is the gui control that renders our popup
+   GuiPopupMenuTextListCtrl *mTextList;
 
 public:
    PopupMenu();
    virtual ~PopupMenu();
-   void createPlatformPopupMenuData();
-   void deletePlatformPopupMenuData();
    
    DECLARE_CONOBJECT(PopupMenu);
 
@@ -72,15 +100,6 @@ public:
 	static PopupMenuEvent smPopupMenuEvent;
 	static bool smSelectionEventHandled; /// Set to true if any menu or submenu handles a selection event
    
-   /// Creates the platform specific menu object, a peer to this object.
-   /// The platform menu *must* exist before calling any method that manipulates
-   /// menu items or displays the menu.
-   /// implementd on a per-platform basis.
-   void createPlatformMenu();
-
-   void setBarTitle(const char * val) { mBarTitle = StringTable->insert(val, true); }	
-   StringTableEntry getBarTitle() const { return mBarTitle; }
-   
    /// pass NULL for @p title to insert a separator
    /// returns the menu item's ID, or -1 on failure.
    /// implementd on a per-platform basis.
@@ -118,39 +137,7 @@ public:
    /// Returns the number of items in the menu.
    U32 getItemCount();
 
-	/// Returns the popup GUID
-	U32 getPopupGUID() { return mPopupGUID; }
-
-   //-----------------------------------------------------------------------------
-   // New code should not use these methods directly, use the menu bar instead.
-   //
-   // They remain for compatibility with old code and will be changing/going away
-   // once the existing code is moved over to the menu bar.
-   //-----------------------------------------------------------------------------
-
-   /// Places this menu in the menu bar of the application's main window.
-   /// @param owner The GuiCanvas that owns the PlatformWindow that this call is associated with
-   /// @param pos The relative position at which to place the menu.
-   /// @param title The name of the menu
-   void attachToMenuBar(GuiCanvas *owner, S32 pos, const char *title);
-   
-   /// Removes this menu from the menu bar.
-   void removeFromMenuBar();
-
    //-----------------------------------------------------------------------------
-
-   /// Called when the menu has been attached to the menu bar
-   void onAttachToMenuBar(GuiCanvas *canvas, S32 pos, const char *title);
-   
-   /// Called when the menu has been removed from the menu bar
-   void onRemoveFromMenuBar(GuiCanvas *canvas);
-
-   /// Returns the position index of this menu on the bar.
-   S32 getPosOnMenuBar();
-
-   /// Returns true if this menu is attached to the menu bar
-   bool isAttachedToMenuBar()       { return mCanvas != NULL; }
-
    /// Displays this menu as a popup menu and blocks until the user has selected
    /// an item.
    /// @param canvas the owner to show this popup associated with
@@ -159,6 +146,9 @@ public:
    /// implemented on a per-platform basis.
    void showPopup(GuiCanvas *owner, S32 x = -1, S32 y = -1);
 
+   void hidePopup();
+   void hidePopupSubmenus();
+
    /// Returns true iff this menu contains an item that matches @p iD.
    /// implemented on a per-platform basis.
    /// TODO: factor out common code
@@ -184,6 +174,11 @@ public:
 
    virtual bool onMessageReceived(StringTableEntry queue, const char* event, const char* data );
    virtual bool onMessageObjectReceived(StringTableEntry queue, Message *msg );
+
+   bool isVisible() { return visible; }
+   void setVisible(bool isVis) { visible = isVis; }
+
+   GuiMenuBar* getMenuBarCtrl();
 };
 
 #endif // _POPUPMENU_H_

Engine/source/lighting/advanced/advancedLightManager.cpp

@@ -39,6 +39,9 @@
 #include "gfx/gfxCardProfile.h"
 #include "gfx/gfxTextureProfile.h"
 
+#ifndef TORQUE_BASIC_LIGHTING
+F32 AdvancedLightManager::smProjectedShadowFilterDistance = 40.0f;
+#endif
 
 ImplementEnumType( ShadowType,
    "\n\n"

Engine/source/lighting/advanced/advancedLightManager.h

@@ -97,6 +97,10 @@ public:
 
    LightShadowMap* findShadowMapForObject( SimObject *object );
 
+#ifndef TORQUE_BASIC_LIGHTING
+   static F32 getShadowFilterDistance() { return smProjectedShadowFilterDistance; }
+#endif
+
 protected:   
 
    // LightManager
@@ -138,6 +142,12 @@ protected:
 
    LightingShaderConstants* getLightingShaderConstants(GFXShaderConstBuffer* shader);
    
+#ifndef TORQUE_BASIC_LIGHTING
+   /// This is used to determine the distance  
+   /// at which the shadow filtering PostEffect  
+   /// will be enabled for ProjectedShadow.  
+   static F32 smProjectedShadowFilterDistance;
+#endif
 };
 
 #endif // _ADVANCEDLIGHTMANAGER_H_

Engine/source/lighting/common/projectedShadow.cpp

@@ -43,7 +43,11 @@
 #include "materials/materialFeatureTypes.h"
 #include "console/console.h"
 #include "postFx/postEffect.h"
-#include "lighting/basic/basicLightManager.h"
+#ifdef TORQUE_BASIC_LIGHTING  
+#include "lighting/basic/basicLightManager.h"  
+#else  
+#include "lighting/advanced/advancedLightManager.h"  
+#endif 
 #include "lighting/shadowMap/shadowMatHook.h"
 #include "materials/materialManager.h"
 #include "lighting/shadowMap/lightShadowMap.h"
@@ -529,8 +533,12 @@ void ProjectedShadow::_renderToTexture( F32 camDist, const TSRenderState &rdata
    mRenderTarget->resolve();
    GFX->popActiveRenderTarget();
 
-   // If we're close enough then filter the shadow.
-   if ( camDist < BasicLightManager::getShadowFilterDistance() )
+   // If we're close enough then filter the shadow.  
+#ifdef TORQUE_BASIC_LIGHTING  
+   if (camDist < BasicLightManager::getShadowFilterDistance())
+#else  
+   if (camDist < AdvancedLightManager::getShadowFilterDistance())
+#endif  
    {
       if ( !smShadowFilter )
       {

Engine/source/lighting/shadowMap/shadowMapManager.cpp

@@ -41,6 +41,9 @@ GFX_ImplementTextureProfile(ShadowMapTexProfile,
 
 
 MODULE_BEGIN( ShadowMapManager )
+#ifndef TORQUE_BASIC_LIGHTING
+   MODULE_SHUTDOWN_AFTER(Scene)
+#endif
 
    MODULE_INIT
    {

Engine/source/module/moduleDefinition.cpp

@@ -82,6 +82,8 @@ void ModuleDefinition::initPersistFields()
     // Call parent.
     Parent::initPersistFields();
 
+    addProtectedField("ModuleId", TypeString, Offset(mModuleId, ModuleDefinition), &defaultProtectedSetFn, &defaultProtectedGetFn, "");
+
     /// Module configuration.
     addProtectedField( "ModuleId", TypeString, Offset(mModuleId, ModuleDefinition), &setModuleId, &defaultProtectedGetFn, "A unique string Id for the module.  It can contain any characters except a comma or semi-colon (the asset scope character)." );
     addProtectedField( "VersionId", TypeS32, Offset(mVersionId, ModuleDefinition), &setVersionId, &defaultProtectedGetFn, "The version Id.  Breaking changes to a module should use a higher version Id." );

Engine/source/module/moduleManager.cpp

@@ -70,7 +70,8 @@ S32 QSORT_CALLBACK moduleDefinitionVersionIdSort( const void* a, const void* b )
 ModuleManager::ModuleManager() :
     mEnforceDependencies(true),
     mEchoInfo(true),
-    mDatabaseLocks( 0 )
+    mDatabaseLocks( 0 ),
+    mIgnoreLoadedGroups(false)
 {
     // Set module extension.
     dStrcpy( mModuleExtension, MODULE_MANAGER_MODULE_DEFINITION_EXTENSION );
@@ -1300,6 +1301,106 @@ StringTableEntry ModuleManager::copyModule( ModuleDefinition* pSourceModuleDefin
 
 //-----------------------------------------------------------------------------
 
+bool ModuleManager::renameModule(ModuleDefinition* pSourceModuleDefinition, const char* pNewModuleName)
+{
+   // Sanity!
+   AssertFatal(pSourceModuleDefinition != NULL, "Cannot copy module using a NULL source module definition.");
+   AssertFatal(pNewModuleName != NULL, "Cannot rename a module using a NULL module name.");
+
+   // Fetch the source module Id.
+   StringTableEntry sourceModuleId = pSourceModuleDefinition->getModuleId();
+
+   // Is the source module definition registered with this module manager?
+   if (pSourceModuleDefinition->getModuleManager() != this)
+   {
+      // No, so warn.
+      Con::warnf("Module Manager: Cannot rename module Id '%s' as it is not registered with this module manager.", sourceModuleId);
+      return StringTable->EmptyString();
+   }
+
+   TamlModuleIdUpdateVisitor moduleIdUpdateVisitor;
+   moduleIdUpdateVisitor.setModuleIdFrom(sourceModuleId);
+   moduleIdUpdateVisitor.setModuleIdTo(pNewModuleName);
+
+   Vector<Platform::FileInfo> files;
+
+   const char* pExtension = (const char*)"Taml";
+   const U32 extensionLength = dStrlen(pExtension);
+
+   Vector<StringTableEntry> directories;
+
+   StringTableEntry modulePath = pSourceModuleDefinition->getModulePath();
+
+   // Find directories.
+   if (!Platform::dumpDirectories(modulePath, directories, -1))
+   {
+      // Warn.
+      Con::warnf("Module Manager: Cannot rename module Id '%s' in directory '%s' as sub-folder scanning/renaming failed.",
+         sourceModuleId, modulePath);
+      return false;
+   }
+
+   // Iterate directories.
+   for (Vector<StringTableEntry>::iterator basePathItr = directories.begin(); basePathItr != directories.end(); ++basePathItr)
+   {
+      // Fetch base path.
+      StringTableEntry basePath = *basePathItr;
+
+      // Find files.
+      files.clear();
+      if (!Platform::dumpPath(basePath, files, 0))
+      {
+         // Warn.
+         Con::warnf("Module Manager: Cannot rename module Id '%s' in directory '%s' as sub-folder scanning/renaming failed.",
+            sourceModuleId, modulePath);
+         return false;
+      }
+
+      // Iterate files.
+      for (Vector<Platform::FileInfo>::iterator fileItr = files.begin(); fileItr != files.end(); ++fileItr)
+      {
+         // Fetch file info.
+         Platform::FileInfo* pFileInfo = fileItr;
+
+         // Fetch filename.
+         const char* pFilename = pFileInfo->pFileName;
+
+         // Find filename length.
+         const U32 filenameLength = dStrlen(pFilename);
+
+         // Skip if extension is longer than filename.
+         if (extensionLength >= filenameLength)
+            continue;
+
+         // Skip if extension not found.
+         if (dStricmp(pFilename + filenameLength - extensionLength, pExtension) != 0)
+            continue;
+
+         char parseFileBuffer[1024];
+         dSprintf(parseFileBuffer, sizeof(parseFileBuffer), "%s/%s", pFileInfo->pFullPath, pFilename);
+
+         // Parse file.            
+         if (!mTaml.parse(parseFileBuffer, moduleIdUpdateVisitor))
+         {
+            // Warn.
+            Con::warnf("Module Manager: Failed to parse file '%s' whilst renaming module Id '%s' in directory '%s'.",
+               parseFileBuffer, sourceModuleId, modulePath);
+            return false;
+         }
+      }
+   }
+
+   // Info.
+   if (mEchoInfo)
+   {
+      Con::printf("Module Manager: Finished renaming module Id '%s' to '%s'.", sourceModuleId, pNewModuleName);
+   }
+
+   return true;
+}
+
+//-----------------------------------------------------------------------------
+
 bool ModuleManager::synchronizeDependencies( ModuleDefinition* pRootModuleDefinition, const char* pTargetDependencyPath )
 {
     // Sanity!
@@ -1986,7 +2087,7 @@ bool ModuleManager::registerModule( const char* pModulePath, const char* pModule
     }
 
     // Is the module group already loaded?
-    if ( findGroupLoaded( moduleGroup ) != NULL )
+    if ( findGroupLoaded( moduleGroup ) != NULL && !mIgnoreLoadedGroups)
     {
         // Yes, so warn.
         Con::warnf( "Module Manager: Found module: '%s' but it is in a module group '%s' which has already been loaded.",

Engine/source/module/moduleManager.h

@@ -120,6 +120,7 @@ private:
     char                        mModuleExtension[256];
     Taml                        mTaml;
     SimSet                      mNotificationListeners;
+    bool                        mIgnoreLoadedGroups;
 
     // Module definition entry.
     struct ModuleDefinitionEntry : public typeModuleDefinitionVector
@@ -161,6 +162,7 @@ public:
     bool scanModules( const char* pPath, const bool rootOnly = false );
 
     /// Module unregister.
+    bool registerModule(const char* pModulePath, const char* pModuleFile);
     bool unregisterModule( const char* pModuleId, const U32 versionId );
 
     /// Module (un)loading.
@@ -179,6 +181,9 @@ public:
     StringTableEntry copyModule( ModuleDefinition* pSourceModuleDefinition, const char* pTargetModuleId, const char* pTargetPath, const bool useVersionPathing );
     bool synchronizeDependencies( ModuleDefinition* pRootModuleDefinition, const char* pTargetDependencyPath );
 
+    /// Editing modules
+    bool renameModule(ModuleDefinition* pSourceModuleDefinition, const char* pNewModuleName);
+
     /// Module updates.
     inline bool isModuleMergeAvailable( void ) const { return Platform::isFile( getModuleMergeFilePath() ); }
     bool canMergeModules( const char* pMergeSourcePath );
@@ -188,10 +193,11 @@ public:
     void addListener( SimObject* pListener );
     void removeListener( SimObject* pListener );
 
+    void setIgnoreLoadedGroups(bool doIgnore) { mIgnoreLoadedGroups = doIgnore; }
+
 private:
     void clearDatabase( void );
     bool removeModuleDefinition( ModuleDefinition* pModuleDefinition );
-    bool registerModule( const char* pModulePath, const char* pModuleFile );
 
     void raiseModulePreLoadNotifications( ModuleDefinition* pModuleDefinition );
     void raiseModulePostLoadNotifications( ModuleDefinition* pModuleDefinition );

Engine/source/module/moduleManager_ScriptBinding.h

@@ -46,6 +46,16 @@ DefineEngineMethod(ModuleManager, scanModules, bool, (const char* pRootPath, boo
 
 //-----------------------------------------------------------------------------
 
+DefineEngineMethod(ModuleManager, registerModule, bool, (const char* pModulePath, const char* pModuleFile), ("", ""),
+   "Register the specified module.\n"
+   "@param moduleId The module Id to register.\n"
+   "@param versionId The version Id to register.\n"
+   "@return Whether the module was registered or not.\n")
+{
+   // Unregister the module.
+   return object->registerModule(pModulePath, pModuleFile);
+}
+
 DefineEngineMethod(ModuleManager, unregisterModule, bool, (const char* pModuleId, bool versionId), ("", false),
    "Unregister the specified module.\n"
    "@param moduleId The module Id to unregister.\n"
@@ -246,6 +256,30 @@ DefineEngineMethod(ModuleManager, copyModule, String, (const char* sourceModuleD
 
 //-----------------------------------------------------------------------------
 
+DefineEngineMethod(ModuleManager, renameModule, bool, (const char* sourceModuleDefinition, const char* pNewModuleName),
+("", ""),
+"Rename a module.\n"
+"@param sourceModuleDefinition The module definition to rename.\n"
+"@param pNewModuleName The new name the module should have.\n"
+"@return Weither the rename was successful or not.\n")
+{
+   // Find the source module definition.
+   ModuleDefinition* pSourceModuleDefinition = dynamic_cast<ModuleDefinition*>(Sim::findObject(sourceModuleDefinition));
+
+   // Was the module definition found?
+   if (pSourceModuleDefinition == NULL)
+   {
+      // No, so warn.
+      Con::warnf("ModuleManager::renameModule() - Could not find source module definition '%s'.", sourceModuleDefinition);
+      return "";
+   }
+
+   // Copy module.
+   return object->renameModule(pSourceModuleDefinition, pNewModuleName);
+}
+
+//-----------------------------------------------------------------------------
+
 DefineEngineMethod(ModuleManager, synchronizeDependencies, bool, (const char* rootModuleDefinition, const char* pTargetDependencyFolder), ("", ""),
    "Synchronize the module dependencies of a module definition to a target dependency folder.\n"
    "@param rootModuleDefinition The module definition used to determine dependencies.\n"
@@ -342,3 +376,14 @@ DefineEngineMethod(ModuleManager, removeListener, void, (const char* listenerObj
 
     object->removeListener( pListener );
 }
+
+//-----------------------------------------------------------------------------
+
+DefineEngineMethod(ModuleManager, ignoreLoadedGroups, void, (bool doIgnore), (false),
+   "Sets if the Module Manager should ingore laoded groups.\n"
+   "@param doIgnore Whether we should or should not ignore loaded groups.\n"
+   "@return No return value.\n")
+{
+   // Check whether the merge modules can current happen or not.
+   return object->setIgnoreLoadedGroups(doIgnore);
+}

Engine/source/platform/menus/menuBar.cpp

@@ -1,127 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "platform/platform.h"
-#include "platform/menus/menuBar.h"
-#include "platform/menus/popupMenu.h"
-#include "gui/core/guiCanvas.h"
-#include "console/engineAPI.h"
-
-//-----------------------------------------------------------------------------
-// Constructor/Destructor
-//-----------------------------------------------------------------------------
-
-MenuBar::MenuBar()
-{
-   createPlatformPopupMenuData();
-
-   mCanvas = NULL;
-}
-
-MenuBar::~MenuBar()
-{
-   removeFromCanvas();
-
-   deletePlatformPopupMenuData();
-}
-
-IMPLEMENT_CONOBJECT(MenuBar);
-
-ConsoleDocClass( MenuBar,
-   "@brief Used for rendering platform menu bars\n\n"
-   "Internal use only\n\n"
-   "@internal"
-);
-
-//-----------------------------------------------------------------------------
-// Public Methods
-//-----------------------------------------------------------------------------
-
-void MenuBar::addObject(SimObject *obj)
-{
-   Parent::addObject(obj);
-   updateMenuBar(dynamic_cast<PopupMenu *>(obj));
-}
-
-void MenuBar::removeObject(SimObject *obj)
-{
-   Parent::removeObject(obj);
-   updateMenuBar(dynamic_cast<PopupMenu *>(obj));
-}
-
-void MenuBar::insertObject(SimObject *obj, S32 pos)
-{
-   Parent::addObject(obj);
-   
-   if(pos >= size())
-      pos = size() - 1;
-
-   if(pos < size())
-   {
-      if(pos < 0) pos = 0;
-      Parent::reOrder(obj, at(pos));
-   }
-   updateMenuBar(dynamic_cast<PopupMenu *>(obj));
-}
-
-void MenuBar::pushObject(SimObject *obj)
-{
-   Parent::pushObject(obj);
-   updateMenuBar(dynamic_cast<PopupMenu *>(obj));
-}
-
-void MenuBar::popObject()
-{
-   Parent::popObject();
-   updateMenuBar();
-}
-
-bool MenuBar::reOrder(SimObject *obj, SimObject *target /*= 0*/)
-{
-   bool ret = Parent::reOrder(obj, target);
-   if(ret)
-      updateMenuBar(dynamic_cast<PopupMenu *>(obj));
-   return ret;
-}
-
-//-----------------------------------------------------------------------------
-// Console Methods
-//-----------------------------------------------------------------------------
-
-DefineConsoleMethod(MenuBar, attachToCanvas, void, (const char *canvas, S32 pos), , "(GuiCanvas, pos)")
-{
-   object->attachToCanvas(dynamic_cast<GuiCanvas*>(Sim::findObject(canvas)), pos);
-}
-
-DefineConsoleMethod(MenuBar, removeFromCanvas, void, (), , "()")
-{
-   object->removeFromCanvas();
-}
-
-//-----------------------------------------------------------------------------
-
-DefineConsoleMethod(MenuBar, insert, void, (SimObject* pObject, S32 pos), ,"(object, pos) insert object at position")
-{
-
-   if(pObject)
-      object->insertObject(pObject, pos);
-}

Engine/source/platform/menus/popupMenu.cpp

@@ -1,269 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "platform/menus/popupMenu.h"
-#include "console/consoleTypes.h"
-#include "console/engineAPI.h"
-#include "gui/core/guiCanvas.h"
-#include "core/util/safeDelete.h"
-
-static U32 sMaxPopupGUID = 0;
-PopupMenuEvent PopupMenu::smPopupMenuEvent;
-bool PopupMenu::smSelectionEventHandled = false;
-
-/// Event class used to remove popup menus from the event notification in a safe way
-class PopUpNotifyRemoveEvent : public SimEvent
-{   
-public:
-   void process(SimObject *object)
-   {
-      PopupMenu::smPopupMenuEvent.remove((PopupMenu *)object, &PopupMenu::handleSelectEvent);
-   }
-};
-
-//-----------------------------------------------------------------------------
-// Constructor/Destructor
-//-----------------------------------------------------------------------------
-
-PopupMenu::PopupMenu() : mCanvas(NULL)
-{
-   createPlatformPopupMenuData();
-
-   mSubmenus = new SimSet;
-   mSubmenus->registerObject();
-
-   mBarTitle = StringTable->EmptyString();
-   mIsPopup = false;
-
-   mPopupGUID = sMaxPopupGUID++;
-}
-
-PopupMenu::~PopupMenu()
-{
-   // This searches the menu bar so is safe to call for menus
-   // that aren't on it, since nothing will happen.
-   removeFromMenuBar();
-
-   SimSet::iterator i;
-   while((i = mSubmenus->begin()) != mSubmenus->end())
-   {
-      (*i)->deleteObject();
-   }
-
-   mSubmenus->deleteObject();
-   deletePlatformPopupMenuData();
-
-   PopupMenu::smPopupMenuEvent.remove(this, &PopupMenu::handleSelectEvent);
-}
-
-IMPLEMENT_CONOBJECT(PopupMenu);
-
-ConsoleDocClass( PopupMenu,
-   "@brief PopupMenu represents a system menu.\n\n"
-   "You can add menu items to the menu, but there is no torque object associated "
-   "with these menu items, they exist only in a  platform specific manner.\n\n"
-   "@note Internal use only\n\n"
-   "@internal"
-);
-
-
-//-----------------------------------------------------------------------------
-
-void PopupMenu::initPersistFields()
-{
-   addField("isPopup",     TypeBool,         Offset(mIsPopup, PopupMenu),  "true if this is a pop-up/context menu. defaults to false.");
-   addField("barTitle",    TypeCaseString,   Offset(mBarTitle, PopupMenu), "the title of this menu when attached to a menu bar");
-
-   Parent::initPersistFields();
-}
-
-//-----------------------------------------------------------------------------
-
-bool PopupMenu::onAdd()
-{
-   if(! Parent::onAdd())
-      return false;
-
-   createPlatformMenu();
-
-   Con::executef(this, "onAdd");
-   return true;
-}
-
-void PopupMenu::onRemove()
-{
-   Con::executef(this, "onRemove");
-
-   Parent::onRemove();
-}
-
-//-----------------------------------------------------------------------------
-
-void PopupMenu::onMenuSelect()
-{
-   Con::executef(this, "onMenuSelect");
-}
-
-//-----------------------------------------------------------------------------
-
-void PopupMenu::handleSelectEvent(U32 popID, U32 command)
-{  
-   if (popID == mPopupGUID && canHandleID(command))   
-      if (handleSelect(command))
-         smSelectionEventHandled = true;
-}
-
-//-----------------------------------------------------------------------------
-
-void PopupMenu::onAttachToMenuBar(GuiCanvas *canvas, S32 pos, const char *title)
-{
-   mCanvas = canvas;
-
-   // Attached menus must be notified of menu events
-   smPopupMenuEvent.notify(this, &PopupMenu::handleSelectEvent);
-   
-   // Pass on to sub menus
-   for(SimSet::iterator i = mSubmenus->begin();i != mSubmenus->end();++i)
-   {
-      PopupMenu *mnu = dynamic_cast<PopupMenu *>(*i);
-      if(mnu == NULL)
-         continue;
-
-      mnu->onAttachToMenuBar(canvas, pos, title);
-   }
-
-   // Call script
-   if(isProperlyAdded())
-      Con::executef(this, "onAttachToMenuBar", Con::getIntArg(canvas ? canvas->getId() : 0), Con::getIntArg(pos), title);
-}
-
-void PopupMenu::onRemoveFromMenuBar(GuiCanvas *canvas)
-{
-   mCanvas = NULL;
-
-   // We are no longer interested in select events, remove ourselves from the notification list in a safe way
-   Sim::postCurrentEvent(this, new PopUpNotifyRemoveEvent());
-      
-   // Pass on to sub menus
-   for(SimSet::iterator i = mSubmenus->begin();i != mSubmenus->end();++i)
-   {
-      PopupMenu *mnu = dynamic_cast<PopupMenu *>(*i);
-      if(mnu == NULL)
-         continue;
-
-      mnu->onRemoveFromMenuBar(canvas);
-   }
-
-   // Call script
-   if(isProperlyAdded())
-      Con::executef(this, "onRemoveFromMenuBar", Con::getIntArg(canvas ? canvas->getId() : 0));
-}
-
-//-----------------------------------------------------------------------------
-
-bool PopupMenu::onMessageReceived(StringTableEntry queue, const char* event, const char* data)
-{
-   return Con::executef(this, "onMessageReceived", queue, event, data);
-}
-
-
-bool PopupMenu::onMessageObjectReceived(StringTableEntry queue, Message *msg )
-{
-   return Con::executef(this, "onMessageReceived", queue, Con::getIntArg(msg->getId()));
-}
-
-//-----------------------------------------------------------------------------
-// Console Methods
-//-----------------------------------------------------------------------------
-
-DefineConsoleMethod(PopupMenu, insertItem, S32, (S32 pos, const char * title, const char * accelerator, const char* cmd), ("", "", ""), "(pos[, title][, accelerator][, cmd])")
-{
-   return object->insertItem(pos, title, accelerator, cmd);
-}
-
-DefineConsoleMethod(PopupMenu, removeItem, void, (S32 pos), , "(pos)")
-{
-   object->removeItem(pos);
-}
-
-DefineConsoleMethod(PopupMenu, insertSubMenu, S32, (S32 pos, String title, String subMenu), , "(pos, title, subMenu)")
-{
-   PopupMenu *mnu = dynamic_cast<PopupMenu *>(Sim::findObject(subMenu));
-   if(mnu == NULL)
-   {
-      Con::errorf("PopupMenu::insertSubMenu - Invalid PopupMenu object specified for submenu");
-      return -1;
-   }
-   return object->insertSubMenu(pos, title, mnu);
-}
-
-DefineConsoleMethod(PopupMenu, setItem, bool, (S32 pos, const char * title, const char * accelerator, const char *cmd), (""), "(pos, title[, accelerator][, cmd])")
-{
-   return object->setItem(pos, title, accelerator, cmd);
-}
-
-//-----------------------------------------------------------------------------
-
-DefineConsoleMethod(PopupMenu, enableItem, void, (S32 pos, bool enabled), , "(pos, enabled)")
-{
-   object->enableItem(pos, enabled);
-}
-
-DefineConsoleMethod(PopupMenu, checkItem, void, (S32 pos, bool checked), , "(pos, checked)")
-{
-   object->checkItem(pos, checked);
-}
-
-DefineConsoleMethod(PopupMenu, checkRadioItem, void, (S32 firstPos, S32 lastPos, S32 checkPos), , "(firstPos, lastPos, checkPos)")
-{
-   object->checkRadioItem(firstPos, lastPos, checkPos);
-}
-
-DefineConsoleMethod(PopupMenu, isItemChecked, bool, (S32 pos), , "(pos)")
-{
-   return object->isItemChecked(pos);
-}
-
-DefineConsoleMethod(PopupMenu, getItemCount, S32, (), , "()")
-{
-   return object->getItemCount();
-}
-
-//-----------------------------------------------------------------------------
-
-DefineConsoleMethod(PopupMenu, attachToMenuBar, void, (const char * canvasName, S32 pos, const char * title), , "(GuiCanvas, pos, title)")
-{
-   object->attachToMenuBar(dynamic_cast<GuiCanvas*>(Sim::findObject(canvasName)), pos, title);
-}
-
-DefineConsoleMethod(PopupMenu, removeFromMenuBar, void, (), , "()")
-{
-   object->removeFromMenuBar();
-}
-
-//-----------------------------------------------------------------------------
-
-DefineConsoleMethod(PopupMenu, showPopup, void, (const char * canvasName, S32 x, S32 y), ( -1, -1), "(Canvas,[x, y])")
-{
-   GuiCanvas *pCanvas = dynamic_cast<GuiCanvas*>(Sim::findObject(canvasName));
-   object->showPopup(pCanvas, x, y);
-}

Engine/source/platform/nativeDialogs/fileDialog.cpp

@@ -122,6 +122,7 @@ FileDialog::FileDialog() : mData()
    // Default to File Must Exist Open Dialog style
    mData.mStyle = FileDialogData::FDS_OPEN | FileDialogData::FDS_MUSTEXIST;
    mChangePath = false;
+   mForceRelativePath = true;
 }
 
 FileDialog::~FileDialog()
@@ -151,6 +152,8 @@ void FileDialog::initPersistFields()
    addProtectedField("changePath", TypeBool, Offset(mChangePath, FileDialog), &setChangePath, &getChangePath,
       "True/False whether to set the working directory to the directory returned by the dialog.");
 
+   addField("forceRelativePath", TypeBool, Offset(mForceRelativePath, FileDialog), "True/False whether to the path returned is always made to be relative.");
+
    Parent::initPersistFields();
 }
 
@@ -267,7 +270,8 @@ bool FileDialog::Execute()
    }
 
    String resultPath = String(outPath).replace(rootDir, String(""));
-   resultPath = resultPath.replace(0, 1, String("")).c_str(); //kill '\\' prefix
+   if(resultPath[0] == '\\')
+      resultPath = resultPath.replace(0, 1, String("")).c_str(); //kill '\\' prefix
    resultPath = resultPath.replace(String("\\"), String("/"));
 
    // Did we select a file?
@@ -280,7 +284,10 @@ bool FileDialog::Execute()
    if (mData.mStyle & FileDialogData::FDS_OPEN || mData.mStyle & FileDialogData::FDS_SAVE)
    {
       // Single file selection, do it the easy way
-      mData.mFile = Platform::makeRelativePathName(resultPath.c_str(), NULL);
+      if(mForceRelativePath)
+         mData.mFile = Platform::makeRelativePathName(resultPath.c_str(), NULL);
+      else
+         mData.mFile = resultPath.c_str();
    }
    else if (mData.mStyle & FileDialogData::FDS_MULTIPLEFILES)
    {
@@ -300,7 +307,11 @@ bool FileDialog::Execute()
       else
       {
          //nope, just one file, so set it as normal
-         setDataField(StringTable->insert("files"), "0", Platform::makeRelativePathName(resultPath.c_str(), NULL));
+         if (mForceRelativePath)
+            setDataField(StringTable->insert("files"), "0", Platform::makeRelativePathName(resultPath.c_str(), NULL));
+         else
+            setDataField(StringTable->insert("files"), "0", resultPath.c_str());
+
          setDataField(StringTable->insert("fileCount"), NULL, "1");
       }
    }

Engine/source/platform/nativeDialogs/fileDialog.h

@@ -106,6 +106,7 @@ protected:
    FileDialogData mData; ///< Stores platform agnostic information about the dialogs properties
    bool mChangePath; ///< Exposed ChangePath Property
    bool mBoolTranslator; ///< Internally used to translate boolean values into their respective bits of dialog style
+   bool mForceRelativePath;
 public:
 
    FileDialog();

Engine/source/platformSDL/menus/PlatformSDLPopupMenuData.h

@@ -1,35 +0,0 @@
-#ifndef PLATFORM_SDL_POPUPMENU_DATA_H
-#define PLATFORM_SDL_POPUPMENU_DATA_H
-
-#include "core/util/tDictionary.h"
-
-class GuiMenuBar;
-struct EventDescriptor;
-class PopupMenu;
-class MenuBar;
-
-struct PlatformPopupMenuData
-{
-   MenuBar *mMenuBar;
-   GuiMenuBar::Menu *mMenuGui;
-
-   static const U8 mCheckedBitmapIdx = 0;
-   static Map<GuiMenuBar::Menu*, PopupMenu*> mMenuMap;
-
-   PlatformPopupMenuData()
-   {
-      mMenuBar = NULL;
-      mMenuGui = NULL;
-   }
-
-   ~PlatformPopupMenuData()
-   {
-      
-   }
-
-   void insertAccelerator(EventDescriptor &desc, U32 id);
-   void removeAccelerator(U32 id);
-   void setAccelleratorEnabled(U32 id, bool enabled);
-};
-
-#endif //PLATFORM_SDL_POPUPMENU_DATA_H

Engine/source/platformSDL/menus/menuBarSDL.cpp

@@ -1,200 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "platform/menus/menuBar.h"
-#include "platform/menus/popupMenu.h"
-#include "gui/core/guiCanvas.h"
-#include "windowManager/platformWindowMgr.h"
-#include "core/util/safeDelete.h"
-
-#include "windowManager/sdl/sdlWindow.h"
-#include "gui/editor/guiMenuBar.h"
-
-#include "platformSDL/menus/PlatformSDLPopupMenuData.h"
-
-#include "platformSDL/menus/guiPlatformGenericMenuBar.h"
-
-#ifdef TORQUE_SDL
-
-//-----------------------------------------------------------------------------
-// Platform Data
-//-----------------------------------------------------------------------------
-
-// class PlatformMenuBarData
-// {
-// 
-// };
-
-Map<GuiMenuBar::Menu*, PopupMenu*> PlatformPopupMenuData::mMenuMap;
-
-IMPLEMENT_CONOBJECT(GuiPlatformGenericMenuBar);
-
-//-----------------------------------------------------------------------------
-// MenuBar Methods
-//-----------------------------------------------------------------------------
-
-void MenuBar::createPlatformPopupMenuData()
-{
-   mData = NULL;
-}
-
-void MenuBar::deletePlatformPopupMenuData()
-{
-//    SAFE_DELETE(mData);
-}
-
-//-----------------------------------------------------------------------------
-
-GuiPlatformGenericMenuBar* _FindMenuBarCtrl()
-{
-   GuiControl* control;
-   Sim::findObject("PlatformGenericMenubar", control);
-   AssertFatal(control, "");
-   if( !control )      
-      return NULL;   
-
-   GuiPlatformGenericMenuBar* menuBar;
-   menuBar = dynamic_cast<GuiPlatformGenericMenuBar*>( control->findObjectByInternalName(  StringTable->insert("menubar"), true) );
-   AssertFatal(menuBar, "");
-   return menuBar;
-}
-
-
-void MenuBar::updateMenuBar(PopupMenu *popupMenu /* = NULL */)
-{
-   //if(! isAttachedToCanvas())
-   //   return;   
-
-   if(!popupMenu)
-      return;
-
-   GuiPlatformGenericMenuBar* menuBarGui = _FindMenuBarCtrl();
-   popupMenu->mData->mMenuBar = this;
-
-   String menuTitle = popupMenu->getBarTitle();
-
-   //Next, find out if we're still in the list of entries
-   SimSet::iterator itr = find(begin(), end(), popupMenu);
-
-   GuiMenuBar::Menu* menuGui = menuBarGui->findMenu(menuTitle);
-   if (!menuGui)
-   {
-      //This is our first time setting this particular menu up, so we'll OK it.
-      if (itr == end())
-         menuBarGui->attachToMenuBar(popupMenu->mData->mMenuGui);
-      else
-         menuBarGui->attachToMenuBar(popupMenu->mData->mMenuGui, itr - begin());
-   }
-   else
-   {
-      //Not our first time through, so we're really updating it.
-
-      //So, first, remove it from the menubar
-      menuBarGui->removeFromMenuBar(menuGui);
-
-      //Next, find out if we're still in the list of entries
-      SimSet::iterator itr = find(begin(), end(), popupMenu);
-
-      //if we're no longer in the list, we're pretty much done here
-      if (itr == end())
-         return;
-
-      //We're still here, so this is a valid menu for our current bar configuration, so add us back in.
-      menuBarGui->attachToMenuBar(menuGui, itr - begin());
-   }
-}
-
-//-----------------------------------------------------------------------------
-
-void MenuBar::attachToCanvas(GuiCanvas *owner, S32 pos)
-{
-   if(owner == NULL || isAttachedToCanvas())
-      return;
-
-   // This is set for popup menus in the onAttachToMenuBar() callback
-   mCanvas = owner;
-
-   PlatformWindowSDL *pWindow = dynamic_cast<PlatformWindowSDL*>(owner->getPlatformWindow());
-   if(pWindow == NULL) 
-      return;
-
-   // Setup the native menu bar
-   GuiMenuBar *hWindowMenu = static_cast<GuiMenuBar*>( pWindow->getMenuHandle() );
-	if( hWindowMenu == NULL && !Journal::IsPlaying() )
-      hWindowMenu = _FindMenuBarCtrl();
-
-   if(hWindowMenu)
-   {
-      pWindow->setMenuHandle( hWindowMenu );
-      GuiControl *base = hWindowMenu->getParent();
-         
-      while( base->getParent() )
-      {
-         base = base->getParent();
-      }         
-
-      mCanvas->setMenuBar( base );
-   }
-
-   for (S32 i = 0; i < size(); ++i)
-   {
-      PopupMenu *mnu = dynamic_cast<PopupMenu *>(at(i));
-      if (mnu == NULL)
-      {
-         Con::warnf("MenuBar::attachToMenuBar - Non-PopupMenu object in set");
-         continue;
-      }
-
-      if (mnu->isAttachedToMenuBar())
-         mnu->removeFromMenuBar();
-
-      mnu->attachToMenuBar(owner, pos + i);
-   }
-   
-}
-
-void MenuBar::removeFromCanvas()
-{
-   if (mCanvas == NULL || !isAttachedToCanvas())
-      return;
-
-   //_FindMenuBarCtrl()->clearMenus();
-
-   // Add the items
-   for (S32 i = 0; i < size(); ++i)
-   {
-      PopupMenu *mnu = dynamic_cast<PopupMenu *>(at(i));
-      if (mnu == NULL)
-      {
-         Con::warnf("MenuBar::removeFromMenuBar - Non-PopupMenu object in set");
-         continue;
-      }
-
-      mnu->removeFromMenuBar();
-   }
-
-   mCanvas->setMenuBar(NULL);
-
-   mCanvas = NULL;
-}
-
-#endif

Engine/source/platformSDL/menus/popupMenuSDL.cpp

@@ -1,393 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifdef TORQUE_SDL
-
-#include "platform/menus/popupMenu.h"
-#include "platform/menus/menuBar.h"
-#include "console/consoleTypes.h"
-#include "gui/core/guiCanvas.h"
-#include "core/util/safeDelete.h"
-
-#include "sim/actionMap.h"
-#include "platform/platformInput.h"
-
-#include "windowManager/sdl/sdlWindow.h"
-#include "gui/editor/guiMenuBar.h"
-
-#include "platformSDL/menus/PlatformSDLPopupMenuData.h"
-#include "console/engineAPI.h"
-
-#include "platformSDL/menus/guiPlatformGenericMenuBar.h"
-#include "gui/editor/guiPopupMenuCtrl.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Platform Menu Data
-//////////////////////////////////////////////////////////////////////////
-GuiPlatformGenericMenuBar* findMenuBarCtrl()
-{
-   GuiControl* control;
-   Sim::findObject("PlatformGenericMenubar", control);
-   AssertFatal(control, "");
-   if (!control)
-      return NULL;
-
-   GuiPlatformGenericMenuBar* menuBar;
-   menuBar = dynamic_cast<GuiPlatformGenericMenuBar*>(control->findObjectByInternalName(StringTable->insert("menubar"), true));
-   AssertFatal(menuBar, "");
-   return menuBar;
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-void PlatformPopupMenuData::insertAccelerator(EventDescriptor &desc, U32 id)
-{
-   AssertFatal(0, "");
-}
-
-void PlatformPopupMenuData::removeAccelerator(U32 id)
-{
-   AssertFatal(0, "");
-}
-
-void PlatformPopupMenuData::setAccelleratorEnabled( U32 id, bool enabled )
-{   
-  AssertFatal(0, "");
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-void PopupMenu::createPlatformPopupMenuData()
-{
-   mData = new PlatformPopupMenuData;
-}
-
-void PopupMenu::deletePlatformPopupMenuData()
-{
-   SAFE_DELETE(mData);
-}
-void PopupMenu::createPlatformMenu()
-{
-   mData->mMenuGui = GuiMenuBar::sCreateMenu( getBarTitle(), getId() );
-   PlatformPopupMenuData::mMenuMap[ mData->mMenuGui ] = this;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-// Public Methods
-//////////////////////////////////////////////////////////////////////////
-
-S32 PopupMenu::insertItem(S32 pos, const char *title, const char* accelerator, const char* cmd)
-{   
-   GuiMenuBar::MenuItem *item = GuiMenuBar::findMenuItem( mData->mMenuGui, title );
-   
-   //We'll make a special exception for the spacer items
-   if(item && dStrcmp(title, ""))
-   {
-      setItem( pos, title, accelerator, cmd);
-      return pos;
-   }
-
-   item = GuiMenuBar::addMenuItem( mData->mMenuGui, title, pos, accelerator, -1, cmd );
-   item->submenuParentMenu = this->mData->mMenuGui;
-   
-   return pos;
-}
-
-S32 PopupMenu::insertSubMenu(S32 pos, const char *title, PopupMenu *submenu)
-{  
-   GuiMenuBar::MenuItem *item = GuiMenuBar::addMenuItem( mData->mMenuGui, title, pos, "", -1, "" );
-   item->isSubmenu = true;
-   item->submenu = submenu->mData->mMenuGui;
-   item->submenuParentMenu = this->mData->mMenuGui;
-
-   return pos;
-}
-
-bool PopupMenu::setItem(S32 pos, const char *title, const char* accelerator, const char* cmd)
-{
-   GuiMenuBar::MenuItem *item = NULL;
-
-   item = GuiMenuBar::findMenuItem( mData->mMenuGui, title );
-   
-   if(item)
-   {
-      item->id = pos;
-      item->cmd = cmd;
-      if( accelerator && accelerator[0] )
-         item->accelerator = dStrdup( accelerator );
-      else
-         item->accelerator = NULL;
-      return true;
-   }
-
-   return false;
-}
-
-void PopupMenu::removeItem(S32 itemPos)
-{
-   GuiMenuBar::MenuItem *item = GuiMenuBar::findMenuItem( mData->mMenuGui, String::ToString(itemPos) );
-   if(item)
-   {
-      GuiMenuBar::removeMenuItem( mData->mMenuGui, item);
-   }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-void PopupMenu::enableItem( S32 pos, bool enable )
-{
-   GuiMenuBar::MenuItem *item = NULL;
-   for( item = mData->mMenuGui->firstMenuItem; item; item = item->nextMenuItem )
-   {
-      if( item->id == pos)
-         item->enabled = enable;
-   }
-}
-
-void PopupMenu::checkItem(S32 pos, bool checked)
-{
-   GuiMenuBar::MenuItem *item = NULL;
-   for( item = mData->mMenuGui->firstMenuItem; item; item = item->nextMenuItem )   
-      if(item->id == pos)
-         break;   
-
-   if( !item )
-      return;
-
-   if(checked && item->checkGroup != -1)
-   {
-      // first, uncheck everything in the group:
-      for( GuiMenuBar::MenuItem *itemWalk = mData->mMenuGui->firstMenuItem; itemWalk; itemWalk = itemWalk->nextMenuItem )
-         if( itemWalk->checkGroup == item->checkGroup && itemWalk->bitmapIndex == mData->mCheckedBitmapIdx )
-            itemWalk->bitmapIndex = -1;
-   }
-
-   item->bitmapIndex = checked ? mData->mCheckedBitmapIdx : -1;   
-}
-
-void PopupMenu::checkRadioItem(S32 firstPos, S32 lastPos, S32 checkPos)
-{
-   GuiMenuBar::MenuItem *item = NULL;
-   for( item = mData->mMenuGui->firstMenuItem; item; item = item->nextMenuItem )
-   {
-      if(item->id >= firstPos && item->id <= lastPos)
-      {
-         item->bitmapIndex = (item->id  == checkPos) ? mData->mCheckedBitmapIdx : -1;  
-      }
-   }
-}
-
-bool PopupMenu::isItemChecked(S32 pos)
-{
-   GuiMenuBar::MenuItem *item = NULL;
-   for( item = mData->mMenuGui->firstMenuItem; item; item = item->nextMenuItem )   
-      if(item->id == pos)      
-         return item->bitmapIndex == mData->mCheckedBitmapIdx;   
-
-   return false;
-}
-
-U32 PopupMenu::getItemCount()
-{
-   int count = 0;
-   for( GuiMenuBar::MenuItem *item = mData->mMenuGui->firstMenuItem; item; item = item->nextMenuItem )
-      ++count;
-
-   return count;
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-bool PopupMenu::canHandleID(U32 id)
-{
-   return true;
-}
-
-bool PopupMenu::handleSelect(U32 command, const char *text /* = NULL */)
-{
-   return dAtob(Con::executef(this, "onSelectItem", Con::getIntArg(command), text ? text : ""));
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-void PopupMenu::showPopup(GuiCanvas *owner, S32 x /* = -1 */, S32 y /* = -1 */)
-{
-    if(owner == NULL)
-      return;
-
-    GuiControl* editorGui;
-    Sim::findObject("EditorGui", editorGui);
-
-    if (editorGui)
-    {
-       GuiPopupMenuTextListCtrl* textList;
-       GuiPopupMenuBackgroundCtrl* backgroundCtrl;
-       Sim::findObject("PopUpMenuControl", backgroundCtrl);
-
-       GuiControlProfile* profile;
-       Sim::findObject("GuiMenubarProfile", profile);
-
-       if (!profile)
-          return;
-
-       if (!backgroundCtrl)
-       {
-          textList = new GuiPopupMenuTextListCtrl();
-
-          textList->registerObject();
-
-          backgroundCtrl = new GuiPopupMenuBackgroundCtrl(textList);
-
-          backgroundCtrl->registerObject("PopUpMenuControl");
-
-          textList->setControlProfile(profile);
-
-          backgroundCtrl->addObject(textList);
-       }
-       else
-       {
-          textList = dynamic_cast<GuiPopupMenuTextListCtrl*>(backgroundCtrl->first());
-       }
-
-       if (!backgroundCtrl || !textList)
-          return;
-
-       owner->pushDialogControl(backgroundCtrl, 10);
-
-       backgroundCtrl->setExtent(editorGui->getExtent());
-
-       textList->clear();
-       textList->mMenu = mData->mMenuGui;
-       textList->mMenuBar = findMenuBarCtrl();
-       textList->mPopup = this;
-
-       S32 textWidth = 0, width = 0;
-       S32 acceleratorWidth = 0;
-       GFont *font = profile->mFont;
-
-       Point2I maxBitmapSize = Point2I(0, 0);
-
-       S32 numBitmaps = profile->mBitmapArrayRects.size();
-       if (numBitmaps)
-       {
-          RectI *bitmapBounds = profile->mBitmapArrayRects.address();
-          for (S32 i = 0; i < numBitmaps; i++)
-          {
-             if (bitmapBounds[i].extent.x > maxBitmapSize.x)
-                maxBitmapSize.x = bitmapBounds[i].extent.x;
-             if (bitmapBounds[i].extent.y > maxBitmapSize.y)
-                maxBitmapSize.y = bitmapBounds[i].extent.y;
-          }
-       }
-
-       for (GuiMenuBar::MenuItem *walk = mData->mMenuGui->firstMenuItem; walk; walk = walk->nextMenuItem)
-       {
-          if (!walk->visible)
-             continue;
-
-          S32 iTextWidth = font->getStrWidth(walk->text);
-          S32 iAcceleratorWidth = walk->accelerator ? font->getStrWidth(walk->accelerator) : 0;
-
-          if (iTextWidth > textWidth)
-             textWidth = iTextWidth;
-          if (iAcceleratorWidth > acceleratorWidth)
-             acceleratorWidth = iAcceleratorWidth;
-       }
-       width = textWidth + acceleratorWidth + maxBitmapSize.x * 2 + 2 + 4;
-
-       textList->setCellSize(Point2I(width, font->getHeight() + 2));
-       textList->clearColumnOffsets();
-       textList->addColumnOffset(-1); // add an empty column in for the bitmap index.
-       textList->addColumnOffset(maxBitmapSize.x + 1);
-       textList->addColumnOffset(maxBitmapSize.x + 1 + textWidth + 4);
-
-       U32 entryCount = 0;
-
-       for (GuiMenuBar::MenuItem *walk = mData->mMenuGui->firstMenuItem; walk; walk = walk->nextMenuItem)
-       {
-          if (!walk->visible)
-             continue;
-
-          char buf[512];
-
-          //  If this menu item is a submenu, then set the isSubmenu to 2 to indicate
-          // an arrow should be drawn.  Otherwise set the isSubmenu normally.
-          char isSubmenu = 1;
-          if (walk->isSubmenu)
-             isSubmenu = 2;
-
-          char bitmapIndex = 1;
-          if (walk->bitmapIndex >= 0 && (walk->bitmapIndex * 3 <= profile->mBitmapArrayRects.size()))
-             bitmapIndex = walk->bitmapIndex + 2;
-          dSprintf(buf, sizeof(buf), "%c%c\t%s\t%s", bitmapIndex, isSubmenu, walk->text, walk->accelerator ? walk->accelerator : "");
-          textList->addEntry(entryCount, buf);
-
-          if (!walk->enabled)
-             textList->setEntryActive(entryCount, false);
-
-          entryCount++;
-       }
-
-       Point2I pos = owner->getCursorPos();
-       textList->setPosition(pos);
-
-       //nudge in if we'd overshoot the screen
-       S32 widthDiff = (textList->getPosition().x + textList->getExtent().x) - backgroundCtrl->getWidth();
-       if (widthDiff > 0)
-       {
-          Point2I popupPos = textList->getPosition();
-          textList->setPosition(popupPos.x - widthDiff, popupPos.y);
-       }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-void PopupMenu::attachToMenuBar(GuiCanvas *owner, S32 pos, const char *title)
-{
-   if(owner == NULL || isAttachedToMenuBar())
-      return;   
-}
-
-// New version of above for use by MenuBar class. Do not use yet.
-void PopupMenu::attachToMenuBar(GuiCanvas *owner, S32 pos)
-{
-   if(owner == NULL || isAttachedToMenuBar())
-      return;
-
-   //mData->mMenuBar = owner->setMenuBar();
-}
-
-void PopupMenu::removeFromMenuBar()
-{
-   if(isAttachedToMenuBar())
-      return;
-}
-
-S32 PopupMenu::getPosOnMenuBar()
-{
-   
-   return 0;
-}
-
-#endif

Engine/source/platformWin32/menus/menuBarWin32.cpp

@@ -1,177 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#include "platformWin32/platformWin32.h"
-#include "platform/menus/menuBar.h"
-#include "platform/menus/popupMenu.h"
-#include "gui/core/guiCanvas.h"
-#include "windowManager/platformWindowMgr.h"
-#include "windowManager/win32/win32Window.h"
-#include "core/util/safeDelete.h"
-
-//-----------------------------------------------------------------------------
-// Platform Data
-//-----------------------------------------------------------------------------
-
-// class PlatformMenuBarData
-// {
-// 
-// };
-
-//-----------------------------------------------------------------------------
-// MenuBar Methods
-//-----------------------------------------------------------------------------
-
-#ifndef TORQUE_SDL
-
-void MenuBar::createPlatformPopupMenuData()
-{
-//    mData = new PlatformMenuBarData;
-
-   // [tom, 6/4/2007] Nothing currently needed for win32
-   mData = NULL;
-}
-
-void MenuBar::deletePlatformPopupMenuData()
-{
-//    SAFE_DELETE(mData);
-}
-
-//-----------------------------------------------------------------------------
-
-void MenuBar::updateMenuBar(PopupMenu *menu /* = NULL */)
-{
-   if(! isAttachedToCanvas())
-      return;
-
-   if(menu == NULL)
-   {
-      // [tom, 6/4/2007] Kludgetastic
-      GuiCanvas *oldCanvas = mCanvas;
-      S32 pos = -1;
-      PopupMenu *mnu = dynamic_cast<PopupMenu *>(at(0));
-      if(mnu)
-         pos = mnu->getPosOnMenuBar();
-
-      removeFromCanvas();
-      attachToCanvas(oldCanvas, pos);
-
-      return;
-   }
-
-   menu->removeFromMenuBar();
-   SimSet::iterator itr = find(begin(), end(), menu);
-   if(itr == end())
-      return;
-
-   menu->attachToMenuBar(mCanvas, itr - begin());
-
-   Win32Window *pWindow = dynamic_cast<Win32Window*>(mCanvas->getPlatformWindow());
-   if(pWindow == NULL) 
-      return;
-
-   HWND hWindow = pWindow->getHWND();
-   DrawMenuBar(hWindow);
-}
-
-//-----------------------------------------------------------------------------
-
-void MenuBar::attachToCanvas(GuiCanvas *owner, S32 pos)
-{
-   if(owner == NULL || isAttachedToCanvas())
-      return;
-
-   // This is set for popup menus in the onAttachToMenuBar() callback
-   mCanvas = owner;
-
-   Win32Window *pWindow = dynamic_cast<Win32Window*>(owner->getPlatformWindow());
-   if(pWindow == NULL) 
-      return;
-
-   // Setup the native menu bar
-   HMENU hWindowMenu = pWindow->getMenuHandle();
-	if(hWindowMenu == NULL && !Journal::IsPlaying())
-   {
-      hWindowMenu = CreateMenu();
-      if(hWindowMenu)
-      {
-         pWindow->setMenuHandle( hWindowMenu);
-      }
-   }
-
-   // Add the items
-   for(S32 i = 0;i < size();++i)
-   {
-      PopupMenu *mnu = dynamic_cast<PopupMenu *>(at(i));
-      if(mnu == NULL)
-      {
-         Con::warnf("MenuBar::attachToMenuBar - Non-PopupMenu object in set");
-         continue;
-      }
-
-      if(mnu->isAttachedToMenuBar())
-         mnu->removeFromMenuBar();
-
-      mnu->attachToMenuBar(owner, pos + i);
-   }
-
-   HWND hWindow = pWindow->getHWND();
-   SetMenu(hWindow, hWindowMenu);
-   DrawMenuBar(hWindow);
-
-}
-
-void MenuBar::removeFromCanvas()
-{
-   if(mCanvas == NULL || ! isAttachedToCanvas())
-      return;
-
-   Win32Window *pWindow = dynamic_cast<Win32Window*>(mCanvas->getPlatformWindow());
-   if(pWindow == NULL) 
-      return;
-
-   // Setup the native menu bar
-   HMENU hWindowMenu = pWindow->getMenuHandle();
-   if(hWindowMenu == NULL)
-      return;
-
-   // Add the items
-   for(S32 i = 0;i < size();++i)
-   {
-      PopupMenu *mnu = dynamic_cast<PopupMenu *>(at(i));
-      if(mnu == NULL)
-      {
-         Con::warnf("MenuBar::removeFromMenuBar - Non-PopupMenu object in set");
-         continue;
-      }
-
-      mnu->removeFromMenuBar();
-   }
-
-   HWND hWindow = pWindow->getHWND();
-   SetMenu(hWindow, NULL);
-   DrawMenuBar(hWindow);
-
-   mCanvas = NULL;
-}
-
-#endif

Engine/source/platformWin32/menus/popupMenuWin32.cpp

@@ -1,746 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
-
-#ifndef TORQUE_SDL
-
-#include "platform/menus/popupMenu.h"
-#include "platformWin32/platformWin32.h"
-#include "console/engineAPI.h"
-#include "console/consoleTypes.h"
-#include "gui/core/guiCanvas.h"
-#include "windowManager/platformWindowMgr.h"
-#include "windowManager/win32/win32Window.h"
-#include "core/util/safeDelete.h"
-
-#include "sim/actionMap.h"
-#include "platform/platformInput.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Platform Menu Data
-//////////////////////////////////////////////////////////////////////////
-
-struct PlatformPopupMenuData
-{
-   static U32 mLastPopupMenuID;
-   static const U32 PopupMenuIDRange;
-
-   HMENU mMenu;
-   U32 mMenuID;
-   U32 mLastID;
-
-   Win32Window::AcceleratorList mAccelerators;
-   Win32Window::AcceleratorList mDisabledAccelerators;
-
-   PlatformPopupMenuData()
-   {
-      mMenu = NULL;
-      mMenuID = mLastPopupMenuID++;
-      mLastID = 0;
-   }
-
-   ~PlatformPopupMenuData()
-   {
-      if(mMenu)
-         DestroyMenu(mMenu);
-   }
-
-   void insertAccelerator(EventDescriptor &desc, U32 id);
-   void removeAccelerator(U32 id);
-   void setAccelleratorEnabled(U32 id, bool enabled);
-};
-
-U32 PlatformPopupMenuData::mLastPopupMenuID = 0;
-const U32 PlatformPopupMenuData::PopupMenuIDRange = 100;
-
-//////////////////////////////////////////////////////////////////////////
-
-void PlatformPopupMenuData::insertAccelerator(EventDescriptor &desc, U32 id)
-{
-   if(desc.eventType != SI_KEY)
-      return;
-
-   Win32Window::AcceleratorList::iterator i;
-   for(i = mAccelerators.begin();i != mAccelerators.end();++i)
-   {
-      if(i->mID == id)
-      {
-         // Update existing entry
-         i->mDescriptor.eventType = desc.eventType;
-         i->mDescriptor.eventCode = desc.eventCode;
-         i->mDescriptor.flags = desc.flags;
-         return;
-      }
-
-      if(i->mDescriptor.eventType == desc.eventType && i->mDescriptor.eventCode == desc.eventCode && i->mDescriptor.flags == desc.flags)
-      {
-         // Already have a matching accelerator, don't add another one
-         return;
-      }
-   }
-
-   Win32Window::Accelerator accel;
-   accel.mDescriptor = desc;
-   accel.mID = id;
-   mAccelerators.push_back(accel);
-}
-
-void PlatformPopupMenuData::removeAccelerator(U32 id)
-{
-   Win32Window::AcceleratorList::iterator i;
-   for(i = mAccelerators.begin();i != mAccelerators.end();++i)
-   {
-      if(i->mID == id)
-      {
-         mAccelerators.erase(i);
-         return;
-      }
-   }
-}
-
-void PlatformPopupMenuData::setAccelleratorEnabled( U32 id, bool enabled )
-{   
-   Win32Window::AcceleratorList *src = NULL;
-   Win32Window::AcceleratorList *dst = NULL;
-   
-   if ( enabled )
-   {
-      src = &mDisabledAccelerators;
-      dst = &mAccelerators;
-   }
-   else
-   {
-      src = &mAccelerators;
-      dst = &mDisabledAccelerators;
-   }
-
-   Win32Window::AcceleratorList::iterator i;
-   for ( i = src->begin(); i != src->end(); ++i )
-   {
-      if ( i->mID == id )
-      {
-         Win32Window::Accelerator tmp = *i;
-         src->erase( i );
-         dst->push_back( tmp );
-         return;
-      }
-   }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-void PopupMenu::createPlatformPopupMenuData()
-{
-   mData = new PlatformPopupMenuData;
-}
-
-void PopupMenu::deletePlatformPopupMenuData()
-{
-   SAFE_DELETE(mData);
-}
-void PopupMenu::createPlatformMenu()
-{
-   mData->mMenu = mIsPopup ? CreatePopupMenu() : CreateMenu();
-   AssertFatal(mData->mMenu, "Unable to create menu");
-
-   MENUINFO mi = { 0 };
-   mi.cbSize = sizeof(mi);
-   mi.fMask = MIM_MENUDATA;
-   mi.dwMenuData = (ULONG_PTR)this;
-   SetMenuInfo(mData->mMenu, &mi);
-}
-
-//////////////////////////////////////////////////////////////////////////
-// Public Methods
-//////////////////////////////////////////////////////////////////////////
-
-S32 PopupMenu::insertItem(S32 pos, const char *title, const char* accelerator, const char *)
-{
-   Win32Window *pWindow = mCanvas ? dynamic_cast<Win32Window*>(mCanvas->getPlatformWindow()) : NULL;
-   bool isAttached = isAttachedToMenuBar();
-   if(isAttached && pWindow == NULL)
-      return -1;
-
-   MENUITEMINFOA mi = { 0 };
-   mi.cbSize = sizeof(mi);
-   mi.fMask = MIIM_ID|MIIM_TYPE;
-   mi.wID = (mData->mMenuID * PlatformPopupMenuData::PopupMenuIDRange) + mData->mLastID + 1;
-   mData->mLastID++;
-   if(title && *title)
-      mi.fType = MFT_STRING;
-   else
-      mi.fType = MFT_SEPARATOR;
-   
-   char buf[1024];
-   if(accelerator && *accelerator)
-   {
-      dSprintf(buf, sizeof(buf), "%s\t%s", title, accelerator);
-
-      if(isAttached)
-         pWindow->removeAccelerators(mData->mAccelerators);
-
-      // Build entry for accelerator table
-      EventDescriptor accelDesc;
-      if(ActionMap::createEventDescriptor(accelerator, &accelDesc))
-         mData->insertAccelerator(accelDesc, mi.wID);
-      else
-         Con::errorf("PopupMenu::insertItem - Could not create event descriptor for accelerator \"%s\"", accelerator);
-
-      if(isAttached)
-         pWindow->addAccelerators(mData->mAccelerators);
-   }
-   else
-      dSprintf(buf, sizeof(buf), "%s", title);
-
-   mi.dwTypeData = (LPSTR)buf;
-
-   if(InsertMenuItemA(mData->mMenu, pos, TRUE, &mi))
-   {
-      if(isAttached)
-      {
-         HWND hWindow = pWindow->getHWND();
-         DrawMenuBar(hWindow);
-      }
-      return mi.wID;
-   }
-
-   return -1;
-}
-
-S32 PopupMenu::insertSubMenu(S32 pos, const char *title, PopupMenu *submenu)
-{
-   Win32Window *pWindow = mCanvas ? dynamic_cast<Win32Window*>(mCanvas->getPlatformWindow()) : NULL;
-   bool isAttached = isAttachedToMenuBar();
-   if(isAttached && pWindow == NULL)
-      return -1;
-
-   for(S32 i = 0;i < mSubmenus->size();i++)
-   {
-      if(submenu == (*mSubmenus)[i])
-      {
-         Con::errorf("PopupMenu::insertSubMenu - Attempting to add submenu twice");
-         return -1;
-      }
-   }
-
-   MENUITEMINFOA mi;
-   mi.cbSize = sizeof(mi);
-   mi.fMask = MIIM_ID|MIIM_TYPE|MIIM_SUBMENU|MIIM_DATA;
-   mi.wID = (mData->mMenuID * PlatformPopupMenuData::PopupMenuIDRange) + mData->mLastID + 1;
-   if(title && *title)
-      mi.fType = MFT_STRING;
-   else
-      mi.fType = MFT_SEPARATOR;
-   mi.dwTypeData = (LPSTR)title;
-   mi.hSubMenu = submenu->mData->mMenu;
-   mi.dwItemData = (ULONG_PTR)submenu;
-   if(InsertMenuItemA(mData->mMenu, pos, TRUE, &mi))
-   {
-      mSubmenus->addObject(submenu);
-
-      if(isAttached)
-      {
-         pWindow->addAccelerators(submenu->mData->mAccelerators);
-
-         HWND hWindow = pWindow->getHWND();
-         DrawMenuBar(hWindow);
-      }
-      return mi.wID;
-   }
-
-   return -1;
-}
-
-bool PopupMenu::setItem(S32 pos, const char *title, const char* accelerator, const char *)
-{
-   Win32Window *pWindow = mCanvas ? dynamic_cast<Win32Window*>(mCanvas->getPlatformWindow()) : NULL;
-   bool isAttached = isAttachedToMenuBar();
-   if(isAttached && pWindow == NULL)
-      return false;
-
-   // Are we out of range?
-   if ( pos >= getItemCount() )
-      return false;
-
-   MENUITEMINFOA mi;
-   mi.cbSize = sizeof(mi);
-   mi.fMask = MIIM_TYPE;
-
-   if(title && *title)
-      mi.fType = MFT_STRING;
-   else
-      mi.fType = MFT_SEPARATOR;
-
-   char buf[1024];
-   if(accelerator && *accelerator)
-   {
-      dSprintf(buf, sizeof(buf), "%s\t%s", title, accelerator);
-
-      if(isAttached)
-         pWindow->removeAccelerators(mData->mAccelerators);
-
-      // Build entry for accelerator table
-      EventDescriptor accelDesc;
-      if(ActionMap::createEventDescriptor(accelerator, &accelDesc))
-         mData->insertAccelerator(accelDesc, pos);
-      else
-         Con::errorf("PopupMenu::setItem - Could not create event descriptor for accelerator \"%s\"", accelerator);
-
-      if(isAttached)
-         pWindow->addAccelerators(mData->mAccelerators);
-   }
-   else
-      dSprintf(buf, sizeof(buf), "%s", title);
-
-   mi.dwTypeData = (LPSTR)buf;
-
-   if(SetMenuItemInfoA(mData->mMenu, pos, TRUE, &mi))
-   {
-      if(isAttached)
-      {
-         HWND hWindow = pWindow->getHWND();
-         DrawMenuBar(hWindow);
-      }
-
-      return true;
-   }
-
-   return false;
-}
-
-void PopupMenu::removeItem(S32 itemPos)
-{
-   Win32Window *pWindow = mCanvas ? dynamic_cast<Win32Window*>(mCanvas->getPlatformWindow()) : NULL;
-   bool isAttached = isAttachedToMenuBar();
-   if(isAttached && pWindow == NULL)
-      return;
-   
-   MENUITEMINFOA mi;
-   mi.cbSize = sizeof(mi);
-   mi.fMask = MIIM_DATA|MIIM_ID;
-   if(GetMenuItemInfoA(mData->mMenu, itemPos, TRUE, &mi))
-   {
-      bool submenu = false;
-
-      // Update list of submenus if this is a submenu
-      if(mi.fMask & MIIM_DATA)
-      {
-         PopupMenu *mnu = (PopupMenu *)mi.dwItemData;
-         if( mnu != NULL )
-         {
-            if(isAttached)
-               pWindow->removeAccelerators(mnu->mData->mAccelerators);
-            mSubmenus->removeObject(mnu);
-
-            submenu = true;
-         }
-      }
-
-      if(! submenu)
-      {
-         // Update accelerators if this has an accelerator and wasn't a sub menu
-         for(S32 i = 0;i < mData->mAccelerators.size();++i)
-         {
-            if(mData->mAccelerators[i].mID == mi.wID)
-            {
-               if(isAttached)
-                  pWindow->removeAccelerators(mData->mAccelerators);
-
-               mData->mAccelerators.erase(i);
-
-               if(isAttached)
-                  pWindow->addAccelerators(mData->mAccelerators);
-
-               break;
-            }
-         }
-      }
-   }
-   else
-      return;
-
-   RemoveMenu(mData->mMenu, itemPos, MF_BYPOSITION);
-
-   if(isAttached)
-   {
-      HWND hWindow = pWindow->getHWND();
-      DrawMenuBar(hWindow);
-   }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-void PopupMenu::enableItem( S32 pos, bool enable )
-{
-   U32 flags = enable ? MF_ENABLED : MF_GRAYED;
-   EnableMenuItem( mData->mMenu, pos, MF_BYPOSITION|flags );
-
-   // Update accelerators.
-
-   // NOTE: This really DOES need to happen. A disabled menu item
-   // should not still have an accelerator mapped to it. 
-   //
-   // Unfortunately, the editors currently only set menu items 
-   // enabled/disabled when the menu itself is selected which means our 
-   // accelerators would be out of synch.
-
-   /*
-   Win32Window *pWindow = mCanvas ? dynamic_cast<Win32Window*>( mCanvas->getPlatformWindow() ) : NULL;
-   bool isAttached = isAttachedToMenuBar();
-   if ( isAttached && pWindow == NULL )
-      return;
-
-   MENUITEMINFOA mi;
-   mi.cbSize = sizeof(mi);
-   mi.fMask = MIIM_DATA|MIIM_ID;
-   if ( !GetMenuItemInfoA( mData->mMenu, pos, TRUE, &mi) )
-      return;
-
-   if ( isAttached )
-      pWindow->removeAccelerators( mData->mAccelerators );
-
-   mData->setAccelleratorEnabled( mi.wID, enable );
-
-   if ( isAttached )
-      pWindow->addAccelerators( mData->mAccelerators );
-   */
-}
-
-void PopupMenu::checkItem(S32 pos, bool checked)
-{
-//    U32 flags = checked ? MF_CHECKED : MF_UNCHECKED;
-//    CheckMenuItem(mData->mMenu, pos, MF_BYPOSITION|flags);
-
-   MENUITEMINFOA mi;
-   mi.cbSize = sizeof(mi);
-   mi.fMask = MIIM_STATE;
-   mi.fState = checked ? MFS_CHECKED : MFS_UNCHECKED;
-   SetMenuItemInfoA(mData->mMenu, pos, TRUE, &mi);
-}
-
-void PopupMenu::checkRadioItem(S32 firstPos, S32 lastPos, S32 checkPos)
-{
-   CheckMenuRadioItem(mData->mMenu, firstPos, lastPos, checkPos, MF_BYPOSITION);
-}
-
-bool PopupMenu::isItemChecked(S32 pos)
-{
-   MENUITEMINFOA mi;
-   mi.cbSize = sizeof(mi);
-   mi.fMask = MIIM_STATE;
-   if(GetMenuItemInfoA(mData->mMenu, pos, TRUE, &mi) && (mi.fState & MFS_CHECKED))
-      return true;
-   return false;
-}
-
-U32 PopupMenu::getItemCount()
-{
-   return GetMenuItemCount( mData->mMenu );
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-bool PopupMenu::canHandleID(U32 id)
-{
-   for(S32 i = 0;i < mSubmenus->size();i++)
-   {
-      PopupMenu *subM = dynamic_cast<PopupMenu *>((*mSubmenus)[i]);
-      if(subM == NULL)
-         continue;
-
-      if(subM->canHandleID(id))
-         return true;
-   }
-
-   if(id >= mData->mMenuID * PlatformPopupMenuData::PopupMenuIDRange &&
-      id < (mData->mMenuID+1) * PlatformPopupMenuData::PopupMenuIDRange)
-   {
-      return true;
-   }
-
-   return false;
-}
-
-bool PopupMenu::handleSelect(U32 command, const char *text /* = NULL */)
-{
-   // [tom, 8/20/2006] Pass off to a sub menu if it's for them
-   for(S32 i = 0;i < mSubmenus->size();i++)
-   {
-      PopupMenu *subM = dynamic_cast<PopupMenu *>((*mSubmenus)[i]);
-      if(subM == NULL)
-         continue;
-
-      if(subM->canHandleID(command))
-      {
-         return subM->handleSelect(command, text);
-      }
-   }
-
-   // [tom, 8/21/2006] Cheesey hack to find the position based on ID
-   char buf[512];
-   MENUITEMINFOA mi;
-   mi.cbSize = sizeof(mi);
-   mi.dwTypeData = NULL;
-
-   S32 numItems = GetMenuItemCount(mData->mMenu);
-   S32 pos = -1;
-   for(S32 i = 0;i < numItems;i++)
-   {
-      mi.fMask = MIIM_ID|MIIM_STRING|MIIM_STATE;
-      if(GetMenuItemInfoA(mData->mMenu, i, TRUE, &mi))
-      {
-         if(mi.wID == command)
-         {
-            if(text == NULL)
-            {
-               mi.dwTypeData = buf;
-               mi.cch++;
-               GetMenuItemInfoA(mData->mMenu, i, TRUE, &mi);
-               
-               // [tom, 5/11/2007] Don't do anything if the menu item is disabled
-               if(mi.fState & MFS_DISABLED)
-                  return false;
-
-               text = StringTable->insert(mi.dwTypeData);
-            }
-            pos = i;
-            break;
-         }
-      }
-   }
-
-   if(pos == -1)
-   {
-      Con::errorf("PopupMenu::handleSelect - Could not find menu item position for ID %d ... this shouldn't happen!", command);
-      return false;
-   }
-
-   // [tom, 8/20/2006] Wasn't handled by a submenu, pass off to script
-   return dAtob(Con::executef(this, "onSelectItem", Con::getIntArg(pos), text ? text : ""));
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-void PopupMenu::showPopup(GuiCanvas *owner, S32 x /* = -1 */, S32 y /* = -1 */)
-{
-   if( owner == NULL )
-   {
-      Con::warnf("PopupMenu::showPopup - Invalid canvas supplied!");
-      return;
-   }
-
-   // [tom, 6/4/2007] showPopup() blocks until the menu is closed by the user, 
-   // so the canvas pointer is not needed beyond the scope of this function
-   // when working with context menus. Setting mCanvas here will cause undesired
-   // behavior in relation to the menu bar.
-
-   Win32Window *pWindow = dynamic_cast<Win32Window*>(owner->getPlatformWindow());
-   if(pWindow == NULL)
-      return;
-   HWND hWindow = pWindow->getHWND();
-   POINT p;
-   if(x == -1 && y == -1)
-      GetCursorPos(&p);
-   else
-   {
-      p.x = x;
-      p.y = y;
-      ClientToScreen(hWindow, &p);
-   }
-
-   winState.renderThreadBlocked = true;
-   U32 opt = (int)TrackPopupMenu(mData->mMenu, TPM_NONOTIFY|TPM_RETURNCMD, p.x, p.y, 0, hWindow, NULL);
-   if(opt > 0)
-      handleSelect(opt, NULL);
-   winState.renderThreadBlocked = false;
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-void PopupMenu::attachToMenuBar(GuiCanvas *owner, S32 pos, const char *title)
-{
-   if(owner == NULL || isAttachedToMenuBar())
-      return;
-
-   // This is set for sub-menus in the onAttachToMenuBar() callback
-   mCanvas = owner;
-
-   Win32Window *pWindow = dynamic_cast<Win32Window*>(owner->getPlatformWindow());
-   if(pWindow == NULL) 
-      return;
-
-   HMENU hWindowMenu = pWindow->getMenuHandle();
-   if(hWindowMenu == NULL)
-   {
-      hWindowMenu = CreateMenu();
-      if(hWindowMenu)
-      {
-         pWindow->setMenuHandle( hWindowMenu);
-      }
-   }
-
-   MENUITEMINFOA mii;
-
-   mii.cbSize = sizeof(MENUITEMINFOA);
-
-   mii.fMask = MIIM_STRING|MIIM_DATA;
-   mii.dwTypeData = (LPSTR)title;
-   mii.fMask |= MIIM_ID;
-   mii.wID = mData->mMenuID;
-   mii.fMask |= MIIM_SUBMENU;
-   mii.hSubMenu = mData->mMenu;
-   mii.dwItemData = (ULONG_PTR)this;
-
-   InsertMenuItemA(hWindowMenu, pos, TRUE, &mii);
-
-   HWND hWindow = pWindow->getHWND();
-   DrawMenuBar(hWindow);
-
-   pWindow->addAccelerators(mData->mAccelerators);
-
-   // Add accelerators for sub menus
-   for(SimSet::iterator i = mSubmenus->begin();i != mSubmenus->end();++i)
-   {
-      PopupMenu *submenu = dynamic_cast<PopupMenu *>(*i);
-      if(submenu == NULL)
-         continue;
-
-      pWindow->addAccelerators(submenu->mData->mAccelerators);
-   }
-
-   onAttachToMenuBar(owner, pos, title);
-}
-
-// New version of above for use by MenuBar class. Do not use yet.
-void PopupMenu::attachToMenuBar(GuiCanvas *owner, S32 pos)
-{
-   Win32Window *pWindow = dynamic_cast<Win32Window*>(owner->getPlatformWindow());
-   if(pWindow == NULL) 
-      return;
-
-	//When playing a journal, the system menu is not actually shown
-	if (Journal::IsPlaying())
-	{
-		onAttachToMenuBar(owner, pos, mBarTitle);
-		return;
-	}
-
-   HMENU hWindowMenu = pWindow->getMenuHandle();
-
-   MENUITEMINFOA mii;
-
-   mii.cbSize = sizeof(MENUITEMINFOA);
-
-   mii.fMask = MIIM_STRING|MIIM_DATA;
-   mii.dwTypeData = (LPSTR)mBarTitle;
-   mii.fMask |= MIIM_ID;
-   mii.wID = mData->mMenuID;
-   mii.fMask |= MIIM_SUBMENU;
-   mii.hSubMenu = mData->mMenu;
-   mii.dwItemData = (ULONG_PTR)this;
-
-   InsertMenuItemA(hWindowMenu, pos, TRUE, &mii);
-
-   pWindow->addAccelerators(mData->mAccelerators);
-
-   // Add accelerators for sub menus (have to do this here as it's platform specific)
-   for(SimSet::iterator i = mSubmenus->begin();i != mSubmenus->end();++i)
-   {
-      PopupMenu *submenu = dynamic_cast<PopupMenu *>(*i);
-      if(submenu == NULL)
-         continue;
-
-      pWindow->addAccelerators(submenu->mData->mAccelerators);
-   }
-
-   onAttachToMenuBar(owner, pos, mBarTitle);
-}
-
-void PopupMenu::removeFromMenuBar()
-{
-   S32 pos = getPosOnMenuBar();
-   if(pos == -1)
-      return;
-
-   Win32Window *pWindow = mCanvas ? dynamic_cast<Win32Window*>(mCanvas->getPlatformWindow()) : NULL;
-   if(pWindow == NULL)
-      return;
-
-   HMENU hMenuHandle = pWindow->getMenuHandle();
-   if(!hMenuHandle)
-      return;
-
-   RemoveMenu(hMenuHandle, pos, MF_BYPOSITION);
-
-   HWND hWindow = pWindow->getHWND();
-
-   DrawMenuBar(hWindow);
-
-   pWindow->removeAccelerators(mData->mAccelerators);
-
-   // Remove accelerators for sub menus
-   for(SimSet::iterator i = mSubmenus->begin();i != mSubmenus->end();++i)
-   {
-      PopupMenu *submenu = dynamic_cast<PopupMenu *>(*i);
-      if(submenu == NULL)
-         continue;
-
-      pWindow->removeAccelerators(submenu->mData->mAccelerators);
-   }
-
-   onRemoveFromMenuBar(mCanvas);
-}
-
-S32 PopupMenu::getPosOnMenuBar()
-{
-   if(mCanvas == NULL)
-      return -1;
-
-   Win32Window *pWindow = mCanvas ? dynamic_cast<Win32Window*>(mCanvas->getPlatformWindow()) : NULL;
-   if(pWindow == NULL) 
-      return -1;
-
-   HMENU hMenuHandle = pWindow->getMenuHandle();
-   S32 numItems = GetMenuItemCount(hMenuHandle);
-   S32 pos = -1;
-   for(S32 i = 0;i < numItems;i++)
-   {
-      MENUITEMINFOA mi;
-      mi.cbSize = sizeof(mi);
-      mi.fMask = MIIM_DATA;
-      if(GetMenuItemInfoA(hMenuHandle, i, TRUE, &mi))
-      {
-         if(mi.fMask & MIIM_DATA)
-         {
-            PopupMenu *mnu = (PopupMenu *)mi.dwItemData;
-            if(mnu == this)
-            {
-               pos = i;
-               break;
-            }
-         }
-      }
-   }
-
-   return pos;
-}
-
-#endif

Engine/source/scene/sceneManager.cpp

@@ -38,6 +38,9 @@
 #include "T3D/gameBase/gameConnection.h"
 #include "math/mathUtils.h"
 
+#include "T3D/components/render/renderComponentInterface.h"
+#include "T3D/systems/render/meshRenderSystem.h"
+
 // For player object bounds workaround.
 #include "T3D/player.h"
 
@@ -358,6 +361,8 @@ void SceneManager::_renderScene( SceneRenderState* state, U32 objectMask, SceneZ
    if( gEditingMission && state->isDiffusePass() )
       objectMask = EDITOR_RENDER_TYPEMASK;
 
+   MeshRenderSystem::render(this, state);
+
    // Update the zoning state and traverse zones.
 
    if( getZoneManager() )

Engine/source/scene/sceneRenderState.cpp

@@ -106,17 +106,6 @@ void SceneRenderState::renderObjects( SceneObject** objects, U32 numObjects )
       object->prepRenderImage( this );
    }
 
-   U32 interfaceCount = RenderComponentInterface::all.size();
-   for (U32 i = 0; i < RenderComponentInterface::all.size(); i++)
-   {
-      Component* comp = dynamic_cast<Component*>(RenderComponentInterface::all[i]);
-
-      if (comp->isClientObject() && comp->isActive())
-      {
-         RenderComponentInterface::all[i]->prepRenderImage(this);
-      }
-   }
-
    PROFILE_END();
 
    // Render what the objects have batched.

Engine/source/sim/netObject.cpp

@@ -581,4 +581,10 @@ void NetObject::addNetworkedField(const char*  in_pFieldname,
    f.table = conType->getEnumTable();
 
    sg_tempFieldList.push_back(f);
+}
+
+DefineEngineMethod(NetObject, clearScopeAlways, void, (), ,
+   "@brief Clears the scope always flag on this object.\n\n")
+{
+   object->clearScopeAlways();
 }

Engine/source/ts/collada/colladaImport.cpp

@@ -198,7 +198,7 @@ DefineConsoleFunction( enumColladaForImport, bool, (const char * shapePath, cons
       for (S32 j = 0; j < libraryMats->getMaterial_array().getCount(); j++)
       {
          domMaterial* mat = libraryMats->getMaterial_array()[j];
-         tree->insertItem(matsID, _GetNameOrId(mat), _GetNameOrId(mat), "", 0, 0);
+         tree->insertItem(matsID, _GetNameOrId(mat), "", "", 0, 0);
       }
    }
 
@@ -256,5 +256,16 @@ DefineConsoleFunction( enumColladaForImport, bool, (const char * shapePath, cons
    else
       tree->setDataField(StringTable->insert("_upAxis"), 0, "Z_AXIS");
 
+   char shapesStr[16];
+   dSprintf(shapesStr, 16, "%i", stats.numMeshes);
+   char materialsStr[16];
+   dSprintf(materialsStr, 16, "%i", stats.numMaterials);
+   char animationsStr[16];
+   dSprintf(animationsStr, 16, "%i", stats.numClips);
+
+   tree->setItemValue(nodesID, StringTable->insert(shapesStr));
+   tree->setItemValue(matsID, StringTable->insert(materialsStr));
+   tree->setItemValue(animsID, StringTable->insert(animationsStr));
+
    return true;
 }

Engine/source/windowManager/sdl/sdlWindow.cpp

@@ -27,7 +27,6 @@
 #include "windowManager/sdl/sdlWindowMgr.h"
 #include "windowManager/sdl/sdlCursorController.h"
 #include "platformSDL/sdlInput.h"
-#include "platform/menus/popupMenu.h"
 #include "platform/platformInput.h"
 
 #include "gfx/gfxDevice.h"