Merge pull request #616 from Azaezel/SoundAssetImplements

Sound asset implements

Engine/source/T3D/accumulationVolume.cpp

@@ -85,7 +85,7 @@ AccumulationVolume::AccumulationVolume()
    mWorldToObj.identity();
 
    // Accumulation Texture.
-   INIT_IMAGEASSET(Texture);
+   INIT_ASSET(Texture);
 
    resetWorldBox();
 }
@@ -236,7 +236,7 @@ U32 AccumulationVolume::packUpdate( NetConnection *connection, U32 mask, BitStre
 
    if (stream->writeFlag(mask & InitialUpdateMask))
    {
-      PACK_IMAGEASSET(connection, Texture);
+      PACK_ASSET(connection, Texture);
    }
 
    return retMask;  
@@ -248,7 +248,7 @@ void AccumulationVolume::unpackUpdate( NetConnection *connection, BitStream *str
 
    if (stream->readFlag())
    {
-      UNPACK_IMAGEASSET(connection, Texture);
+      UNPACK_ASSET(connection, Texture);
       //setTexture(mTextureName);
    }
 }

Engine/source/T3D/accumulationVolume.h

@@ -62,7 +62,7 @@ class AccumulationVolume : public ScenePolyhedralSpace
       virtual void _renderObject( ObjectRenderInst* ri, SceneRenderState* state, BaseMatInstance* overrideMat );
 
       DECLARE_IMAGEASSET(AccumulationVolume, Texture, onTextureChanged, GFXStaticTextureSRGBProfile);
-      DECLARE_IMAGEASSET_NET_SETGET(AccumulationVolume, Texture, -1);
+      DECLARE_ASSET_NET_SETGET(AccumulationVolume, Texture, -1);
 
       void onTextureChanged() {}
 

Engine/source/T3D/assets/ImageAsset.h

@@ -47,7 +47,7 @@
 #include "sim/netConnection.h"
 
 #include <string>
-
+#include "assetMacroHelpers.h"
 //-----------------------------------------------------------------------------
 class ImageAsset : public AssetBase
 {
@@ -270,46 +270,8 @@ public: \
    GFXTexHandle get##name##Resource() \
    {\
       return m##name;\
-   }
-
-#define DECLARE_IMAGEASSET_SETGET(className, name)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      return ret;\
-   }
-
-#define DECLARE_IMAGEASSET_NET_SETGET(className, name, bitmask)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      if(ret)\
-         object->setMaskBits(bitmask);\
-      return ret;\
-   }
-
-#define DEF_IMAGEASSET_BINDS(className,name)\
-DefineEngineMethod(className, get##name, const char*, (), , "get name")\
-{\
-   return object->get##name(); \
-}\
-DefineEngineMethod(className, get##name##Asset, const char*, (), , assetText(name, asset reference))\
-{\
-   return object->m##name##AssetId; \
-}\
-DefineEngineMethod(className, set##name, bool, (const char* map), , assetText(name,assignment. first tries asset then flat file.))\
-{\
-    return object->_set##name(StringTable->insert(map));\
-}
-
-#define INIT_IMAGEASSET(name) \
-   m##name##Name = StringTable->EmptyString(); \
-   m##name##AssetId = StringTable->EmptyString(); \
-   m##name##Asset = NULL;
+   }\
+   bool name##Valid() {return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
@@ -325,11 +287,6 @@ DefineEngineMethod(className, set##name, bool, (const char* map), , assetText(na
 
 #endif // SHOW_LEGACY_FILE_FIELDS
 
-#define CLONE_IMAGEASSET(name) \
-   m##name##Name = other.m##name##Name;\
-   m##name##AssetId = other.m##name##AssetId;\
-   m##name##Asset = other.m##name##Asset;
-
 #define LOAD_IMAGEASSET(name)\
 if (m##name##AssetId != StringTable->EmptyString())\
 {\
@@ -341,40 +298,6 @@ if (m##name##AssetId != StringTable->EmptyString())\
    else Con::warnf("Warning: %s::LOAD_IMAGEASSET(%s)-%s", mClassName, m##name##AssetId, ImageAsset::getAssetErrstrn(assetState).c_str());\
 }
 
-#define PACKDATA_IMAGEASSET(name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      stream->writeString(m##name##Asset.getAssetId());\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACKDATA_IMAGEASSET(name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = stream->readSTString();\
-   }\
-   else\
-      m##name##Name = stream->readSTString();
-
-#define PACK_IMAGEASSET(netconn, name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset.getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACK_IMAGEASSET(netconn, name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-      m##name##Name = stream->readSTString();
 
 #pragma endregion
 
@@ -491,7 +414,8 @@ public: \
       if(index >= sm##name##Count || index < 0)\
          return nullptr;\
       return m##name[index];\
-   }
+   }\
+   bool name##Valid(const U32& id) {return (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok); }
 
 #define DECLARE_IMAGEASSET_ARRAY_SETGET(className, name)\
    static bool _set##name##Data(void* obj, const char* index, const char* data)\
@@ -537,13 +461,6 @@ DefineEngineMethod(className, set##name, bool, (const char* map, S32 index), , a
     return object->_set##name(StringTable->insert(map), index);\
 }
 
-#define INIT_IMAGEASSET_ARRAY(name, index) \
-{\
-   m##name##Name[index] = StringTable->EmptyString(); \
-   m##name##AssetId[index] = StringTable->EmptyString(); \
-   m##name##Asset[index] = NULL;\
-}
-
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
 #define INITPERSISTFIELD_IMAGEASSET_ARRAY(name, arraySize, consoleClass, docs) \
@@ -558,13 +475,6 @@ DefineEngineMethod(className, set##name, bool, (const char* map, S32 index), , a
 
 #endif
 
-#define CLONE_IMAGEASSET_ARRAY(name, index) \
-{\
-   m##name##Name[index] = other.m##name##Name[index];\
-   m##name##AssetId[index] = other.m##name##AssetId[index];\
-   m##name##Asset[index] = other.m##name##Asset[index];\
-}
-
 #define LOAD_IMAGEASSET_ARRAY(name, index)\
 if (m##name##AssetId[index] != StringTable->EmptyString())\
 {\
@@ -576,41 +486,6 @@ if (m##name##AssetId[index] != StringTable->EmptyString())\
    else Con::warnf("Warning: %s::LOAD_IMAGEASSET(%s)-%s", mClassName, m##name##AssetId[index], ImageAsset::getAssetErrstrn(assetState).c_str());\
 }
 
-#define PACKDATA_IMAGEASSET_ARRAY(name, index)\
-   if (stream->writeFlag(m##name##Asset[index].notNull()))\
-   {\
-      stream->writeString(m##name##Asset[index].getAssetId());\
-   }\
-   else\
-      stream->writeString(m##name##Name[index]);
-
-#define UNPACKDATA_IMAGEASSET_ARRAY(name, index)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId[index] = stream->readSTString();\
-      _set##name(m##name##AssetId[index], index);\
-   }\
-   else\
-      m##name##Name[index] = stream->readSTString();
-
-#define PACK_IMAGEASSET_ARRAY(netconn, name, index)\
-   if (stream->writeFlag(m##name##Asset[index].notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset[index].getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name[index]);
-
-#define UNPACK_IMAGEASSET_ARRAY(netconn, name, index)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId[index] = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId[index], index);\
-   }\
-   else\
-      m##name##Name[index] = stream->readSTString();
-
 #pragma endregion
 
 

Engine/source/T3D/assets/MaterialAsset.h

@@ -54,6 +54,7 @@
 #include "materials/materialDefinition.h"
 #include "materials/customMaterialDefinition.h"
 #include "materials/materialManager.h"
+#include "assetMacroHelpers.h"
 
 //-----------------------------------------------------------------------------
 class MaterialAsset : public AssetBase
@@ -260,47 +261,8 @@ public: \
    SimObjectPtr<Material> get##name##Resource() \
    {\
       return m##name;\
-   }
-
-#define DECLARE_MATERIALASSET_SETGET(className, name)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      return ret;\
-   }
-
-#define DECLARE_MATERIALASSET_NET_SETGET(className, name, bitmask)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      if(ret)\
-         object->setMaskBits(bitmask);\
-      return ret;\
-   }
-
-#define DEF_MATERIALASSET_BINDS(className,name)\
-DefineEngineMethod(className, get##name, const char*, (), , "get name")\
-{\
-   return object->get##name(); \
-}\
-DefineEngineMethod(className, get##name##Asset, const char*, (), , assetText(name, asset reference))\
-{\
-   return object->m##name##AssetId; \
-}\
-DefineEngineMethod(className, set##name, bool, (const char* mat), , assetText(name,assignment. first tries asset then material name.))\
-{\
-    return object->_set##name(StringTable->insert(mat));\
-}
-
-#define INIT_MATERIALASSET(name) \
-   m##name##Name = StringTable->EmptyString(); \
-   m##name##AssetId = StringTable->EmptyString(); \
-   m##name##Asset = NULL;\
-   m##name = NULL;
+   }\
+   bool is##name##Valid() {return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
@@ -316,11 +278,6 @@ DefineEngineMethod(className, set##name, bool, (const char* mat), , assetText(na
 
 #endif // SHOW_LEGACY_FILE_FIELDS
 
-#define CLONE_MATERIALASSET(name) \
-   m##name##Name = other.m##name##Name;\
-   m##name##AssetId = other.m##name##AssetId;\
-   m##name##Asset = other.m##name##Asset;
-
 #define LOAD_MATERIALASSET(name)\
 if (m##name##AssetId != StringTable->EmptyString())\
 {\
@@ -331,42 +288,6 @@ if (m##name##AssetId != StringTable->EmptyString())\
    }\
    else Con::warnf("Warning: %s::LOAD_MATERIALASSET(%s)-%s", mClassName, m##name##AssetId, MaterialAsset::getAssetErrstrn(assetState).c_str());\
 }
-
-#define PACKDATA_MATERIALASSET(name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      stream->writeString(m##name##Asset.getAssetId());\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACKDATA_MATERIALASSET(name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = stream->readSTString();\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-      m##name##Name = stream->readSTString();
-
-#define PACK_MATERIALASSET(netconn, name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset.getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACK_MATERIALASSET(netconn, name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-      m##name##Name = stream->readSTString();
-
 #pragma endregion
 
 #endif // _ASSET_BASE_H_

Engine/source/T3D/assets/ShapeAsset.h

@@ -60,6 +60,7 @@
 #ifndef _BITSTREAM_H_
 #include "core/stream/bitStream.h"
 #endif
+#include "assetMacroHelpers.h"
 //-----------------------------------------------------------------------------
 class ShapeAsset : public AssetBase
 {
@@ -321,47 +322,8 @@ public: \
    Resource<TSShape> get##name##Resource() \
    {\
       return m##name;\
-   }
-
-#define DECLARE_SHAPEASSET_SETGET(className, name)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      return ret;\
-   }
-
-#define DECLARE_SHAPEASSET_NET_SETGET(className, name, bitmask)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      if(ret)\
-         object->setMaskBits(bitmask);\
-      return ret;\
-   }
-
-#define DEF_SHAPEASSET_BINDS(className,name)\
-DefineEngineMethod(className, get##name, String, (), , "get name")\
-{\
-   return object->get##name(); \
-}\
-DefineEngineMethod(className, get##name##Asset, String, (), , assetText(name, asset reference))\
-{\
-   return object->m##name##AssetId; \
-}\
-DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText(name,assignment. first tries asset then flat file.))\
-{\
-   return object->_set##name(StringTable->insert(shape));\
-}
-
-#define INIT_SHAPEASSET(name) \
-   m##name##Name = StringTable->EmptyString(); \
-   m##name##AssetId = StringTable->EmptyString(); \
-   m##name##Asset = NULL; \
-   m##name = NULL;
+   }\
+   bool is##name##Valid() {return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
@@ -377,46 +339,6 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
 
 #endif // SHOW_LEGACY_FILE_FIELDS
 
-#define CLONE_SHAPEASSET(name) \
-   m##name##Name = other.m##name##Name;\
-   m##name##AssetId = other.m##name##AssetId;\
-   m##name##Asset = other.m##name##Asset;\
-
-#define PACKDATA_SHAPEASSET(name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      stream->writeString(m##name##Asset.getAssetId());\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACKDATA_SHAPEASSET(name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = stream->readSTString();\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-      m##name##Name = stream->readSTString();
-
-#define PACK_SHAPEASSET(netconn, name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset.getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACK_SHAPEASSET(netconn, name)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId);\
-   }\
-   else\
-      m##name##Name = stream->readSTString();
-
 #pragma endregion
 
 #pragma region Arrayed Asset Macros
@@ -519,59 +441,8 @@ public: \
       if(index >= sm##name##Count || index < 0)\
          return ResourceManager::get().load( "" );\
       return m##name[index];\
-   }
-
-#define DECLARE_SHAPEASSET_ARRAY_SETGET(className, name)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      if (!index) return false;\
-      U32 idx = dAtoi(index);\
-      if (idx >= sm##name##Count)\
-         return false;\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data), idx);\
-      return ret;\
-   }
-
-#define DECLARE_SHAPEASSET_ARRAY_NET_SETGET(className, name, bitmask)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      if (!index) return false;\
-      U32 idx = dAtoi(index);\
-      if (idx >= sm##name##Count)\
-         return false;\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data), idx);\
-      if(ret)\
-         object->setMaskBits(bitmask);\
-      return ret;\
-   }
-
-#define DEF_SHAPEASSET_ARRAY_BINDS(className,name)\
-DefineEngineMethod(className, get##name, String, (S32 index), , "get name")\
-{\
-   return object->get##name(index); \
-}\
-DefineEngineMethod(className, get##name##Asset, String, (S32 index), , assetText(name, asset reference))\
-{\
-   if(index >= className::sm##name##Count || index < 0)\
-      return "";\
-   return object->m##name##AssetId[index]; \
-}\
-DefineEngineMethod(className, set##name, bool, (const char*  shape, S32 index), , assetText(name,assignment. first tries asset then flat file.))\
-{\
-   return object->_set##name(StringTable->insert(shape), index);\
-}
-
-#define INIT_SHAPEASSET_ARRAY(name, index) \
-{\
-   m##name##Name[index] = StringTable->EmptyString(); \
-   m##name##AssetId[index] = StringTable->EmptyString(); \
-   m##name##Asset[index] = NULL; \
-   m##name[index] = NULL;\
-}
+   }\
+   bool is##name##Valid(const U32& id) {return (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok); }
 
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
@@ -587,48 +458,6 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape, S32 index),
 
 #endif // SHOW_LEGACY_FILE_FIELDS
 
-#define CLONE_SHAPEASSET_ARRAY(name, index) \
-{\
-   m##name##Name[index] = other.m##name##Name[index];\
-   m##name##AssetId[index] = other.m##name##AssetId[index];\
-   m##name##Asset[index] = other.m##name##Asset[index];\
-}
-
-#define PACKDATA_SHAPEASSET_ARRAY(name, index)\
-   if (stream->writeFlag(m##name##Asset[index].notNull()))\
-   {\
-      stream->writeString(m##name##Asset[index].getAssetId());\
-   }\
-   else\
-      stream->writeString(m##name##Name[index]);
-
-#define UNPACKDATA_SHAPEASSET_ARRAY(name, index)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId[index] = stream->readSTString();\
-      _set##name(m##name##AssetId[index], index);\
-   }\
-   else\
-      m##name##Name[index] = stream->readSTString();
-
-#define PACK_SHAPEASSET_ARRAY(netconn, name, index)\
-   if (stream->writeFlag(m##name##Asset[index].notNull()))\
-   {\
-      NetStringHandle assetIdStr = m##name##Asset[index].getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
-   }\
-   else\
-      stream->writeString(m##name##Name[index]);
-
-#define UNPACK_SHAPEASSET_ARRAY(netconn, name, index)\
-   if (stream->readFlag())\
-   {\
-      m##name##AssetId[index] = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId[index], index);\
-   }\
-   else\
-      m##name##Name[index] = stream->readSTString();
-
 #pragma endregion
 
 #endif

Engine/source/T3D/assets/SoundAsset.cpp

@@ -107,6 +107,7 @@ ConsoleSetType(TypeSoundAssetId)
 //-----------------------------------------------------------------------------
 
 SoundAsset::SoundAsset()
+   : AssetBase()
 {
    mSoundFile = StringTable->EmptyString();
    mSoundPath = StringTable->EmptyString();
@@ -278,18 +279,18 @@ StringTableEntry SoundAsset::getAssetIdByFileName(StringTableEntry fileName)
    return materialAssetId;
 }
 
-U32 SoundAsset::getAssetById(StringTableEntry assetId, AssetPtr<SoundAsset>* materialAsset)
+U32 SoundAsset::getAssetById(StringTableEntry assetId, AssetPtr<SoundAsset>* soundAsset)
 {
-   (*materialAsset) = assetId;
+   (*soundAsset) = assetId;
 
-   if (materialAsset->notNull())
+   if (soundAsset->notNull())
    {
-      return (*materialAsset)->mLoadedState;
+      return (*soundAsset)->mLoadedState;
    }
    else
    {
       //Well that's bad, loading the fallback failed.
-      Con::warnf("MaterialAsset::getAssetById - Finding of asset with id %s failed with no fallback asset", assetId);
+      Con::warnf("SoundAsset::getAssetById - Finding of asset with id %s failed with no fallback asset", assetId);
       return AssetErrCode::Failed;
    }
 }

Engine/source/T3D/assets/SoundAsset.h

@@ -57,6 +57,7 @@
 #include "sfx/sfxProfile.h"
 #endif // !_SFXPROFILE_H_
 
+#include "assetMacroHelpers.h"
 class SFXResource;
 
 //-----------------------------------------------------------------------------
@@ -234,7 +235,11 @@ public: \
       {\
          m##name = NULL;\
       }\
+      if(get##name() == StringTable->EmptyString())\
+         return true;\
       \
+      if(get##name() == StringTable->EmptyString())\
+         return true;\
       if (m##name##Asset.notNull() && m##name##Asset->getStatus() != SoundAsset::Ok)\
       {\
          Con::errorf("%s(%s)::_set%s() - sound asset failure\"%s\" due to [%s]", macroText(className), getName(), macroText(name), _in, SoundAsset::getAssetErrstrn(m##name##Asset->getStatus()).c_str());\
@@ -262,47 +267,14 @@ public: \
    Resource<SFXResource> get##name##Resource() \
    {\
       return m##name;\
-   }
-
-#define DECLARE_SOUNDASSET_SETGET(className, name)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
-   {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      return ret;\
-   }
-
-#define DECLARE_SOUNDASSET_NET_SETGET(className, name, bitmask)\
-   static bool _set##name##Data(void* obj, const char* index, const char* data)\
+   }\
+   SFXProfile* get##name##Profile()\
    {\
-      bool ret = false;\
-      className* object = static_cast<className*>(obj);\
-      ret = object->_set##name(StringTable->insert(data));\
-      if(ret)\
-         object->setMaskBits(bitmask);\
-      return ret;\
-   }
-
-#define DEF_SOUNDASSET_BINDS(className,name)\
-DefineEngineMethod(className, get##name, String, (), , "get name")\
-{\
-   return object->get##name(); \
-}\
-DefineEngineMethod(className, get##name##Asset, String, (), , assetText(name, asset reference))\
-{\
-   return object->m##name##AssetId; \
-}\
-DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText(name,assignment. first tries asset then flat file.))\
-{\
-   return object->_set##name(StringTable->insert(shape));\
-}
-
-#define INIT_SOUNDASSET(name) \
-   m##name##Name = StringTable->EmptyString(); \
-   m##name##AssetId = StringTable->EmptyString(); \
-   m##name##Asset = NULL; \
-   m##name = NULL;\
+      if (get##name() != StringTable->EmptyString() && m##name##Asset.notNull())\
+         return m##name##Asset->getSfxProfile();\
+      return NULL;\
+   }\
+   bool is##name##Valid() { return (get##name() != StringTable->EmptyString() && m##name##Asset->getStatus() == AssetBase::Ok); }
 
 #ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
 
@@ -318,46 +290,164 @@ DefineEngineMethod(className, set##name, bool, (const char*  shape), , assetText
 
 #endif // TORQUE_SHOW_LEGACY_FILE_FIELDS
 
-#define CLONE_SOUNDASSET(name) \
-   m##name##Name = other.m##name##Name;\
-   m##name##AssetId = other.m##name##AssetId;\
-   m##name##Asset = other.m##name##Asset;\
+#pragma endregion
+
+#pragma region Arrayed Asset Macros
 
-#define PACKDATA_SOUNDASSET(name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
+#define DECLARE_SOUNDASSET_ARRAY(className,name,max) public: \
+   static const U32 sm##name##Count = max;\
+   Resource<SFXResource> m##name[max];\
+   StringTableEntry m##name##Name[max]; \
+   StringTableEntry m##name##AssetId[max];\
+   AssetPtr<SoundAsset> m##name##Asset[max];\
+   SFXProfile* m##name##Profile[max];\
+public: \
+   const StringTableEntry get##name##File(const U32& index) const { return m##name##Name[index]; }\
+   void set##name##File(const FileName &_in, const U32& index) { m##name##Name[index] = StringTable->insert(_in.c_str());}\
+   const AssetPtr<SoundAsset> & get##name##Asset(const U32& index) const { return m##name##Asset[index]; }\
+   void set##name##Asset(const AssetPtr<SoundAsset> &_in, const U32& index) { m##name##Asset[index] = _in;}\
+   \
+   bool _set##name(StringTableEntry _in, const U32& index)\
    {\
-      stream->writeString(m##name##Asset.getAssetId());\
+      if(m##name##AssetId[index] != _in || m##name##Name[index] != _in)\
+      {\
+         if(index >= sm##name##Count || index < 0) \
+               return false;\
+         if (_in == NULL || _in == StringTable->EmptyString())\
+         {\
+            m##name##Name[index] = StringTable->EmptyString();\
+            m##name##AssetId[index] = StringTable->EmptyString();\
+            m##name##Asset[index] = NULL;\
+            m##name[index] = NULL;\
+            return true;\
+         }\
+         else if(_in[0] == '$' || _in[0] == '#')\
+         {\
+            m##name##Name[index] = _in;\
+            m##name##AssetId[index] = StringTable->EmptyString();\
+            m##name##Asset[index] = NULL;\
+            m##name[index] = NULL;\
+            return true;\
+         }\
+         \
+         if (AssetDatabase.isDeclaredAsset(_in))\
+         {\
+            m##name##AssetId[index] = _in;\
+            \
+            U32 assetState = SoundAsset::getAssetById(m##name##AssetId[index], &m##name##Asset[index]);\
+            \
+            if (SoundAsset::Ok == assetState)\
+            {\
+               m##name##Name[index] = StringTable->EmptyString();\
+            }\
+         }\
+         else\
+         {\
+            StringTableEntry assetId = SoundAsset::getAssetIdByFileName(_in);\
+            if (assetId != StringTable->EmptyString())\
+            {\
+               m##name##AssetId[index] = assetId;\
+               if(SoundAsset::getAssetById(m##name##AssetId[index], &m##name##Asset[index]) == SoundAsset::Ok)\
+               {\
+                  m##name##Name[index] = StringTable->EmptyString();\
+               }\
+            }\
+            else\
+            {\
+               m##name##Name[index] = _in;\
+               m##name##AssetId[index] = StringTable->EmptyString();\
+               m##name##Asset[index] = NULL;\
+            }\
+         }\
+      }\
+      if (get##name(index) != StringTable->EmptyString() && m##name##Asset[index].notNull())\
+      {\
+         m##name[index] = m##name##Asset[index]->getSoundResource();\
+      }\
+      else\
+      {\
+         m##name[index] = NULL;\
+      }\
+      if(get##name(index) == StringTable->EmptyString())\
+         return true;\
+      \
+      if (m##name##Asset[index].notNull() && m##name##Asset[index]->getStatus() != SoundAsset::Ok)\
+      {\
+         Con::errorf("%s(%s)::_set%s(%i) - sound asset failure\"%s\" due to [%s]", macroText(className), getName(), macroText(name),index, _in, SoundAsset::getAssetErrstrn(m##name##Asset[index]->getStatus()).c_str());\
+         return false; \
+      }\
+      else if (!m##name[index])\
+      {\
+         Con::errorf("%s(%s)::_set%s(%i) - Couldn't load sound \"%s\"", macroText(className), getName(), macroText(name),index, _in);\
+         return false;\
+      }\
+      return true;\
    }\
-   else\
-      stream->writeString(m##name##Name);
-
-#define UNPACKDATA_SOUNDASSET(name)\
-   if (stream->readFlag())\
+   \
+   const StringTableEntry get##name(const U32& index) const\
    {\
-      m##name##AssetId = stream->readSTString();\
-      _set##name(m##name##AssetId);\
+      if (m##name##Asset[index] && (m##name##Asset[index]->getSoundPath() != StringTable->EmptyString()))\
+         return m##name##Asset[index]->getSoundPath();\
+      else if (m##name##AssetId[index] != StringTable->EmptyString())\
+         return m##name##AssetId[index];\
+      else if (m##name##Name[index] != StringTable->EmptyString())\
+         return StringTable->insert(m##name##Name[index]);\
+      else\
+         return StringTable->EmptyString();\
    }\
-   else\
-      m##name##Name = stream->readSTString();
-
-#define PACK_SOUNDASSET(netconn, name)\
-   if (stream->writeFlag(m##name##Asset.notNull()))\
+   Resource<SFXResource> get##name##Resource(const U32& id) \
    {\
-      NetStringHandle assetIdStr = m##name##Asset.getAssetId();\
-      netconn->packNetStringHandleU(stream, assetIdStr);\
+      if(id >= sm##name##Count || id < 0)\
+         return ResourceManager::get().load( "" );\
+      return m##name[id];\
    }\
-   else\
-      stream->writeString(m##name##Name);
+   SFXProfile* get##name##Profile(const U32& id)\
+   {\
+      if (get##name(id) != StringTable->EmptyString() && m##name##Asset[id].notNull())\
+         return m##name##Asset[id]->getSfxProfile();\
+      return NULL;\
+   }\
+   bool is##name##Valid(const U32& id) {return (get##name(id) != StringTable->EmptyString() && m##name##Asset[id]->getStatus() == AssetBase::Ok); }
+
+
+#ifdef TORQUE_SHOW_LEGACY_FILE_FIELDS
+
+#define INITPERSISTFIELD_IMAGEASSET_ARRAY(name, arraySize, consoleClass, docs) \
+   addProtectedField(#name, TypeSoundFilename, Offset(m##name##Name, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, docs)); \
+   addProtectedField(assetText(name, Asset), TypeImageAssetId, Offset(m##name##AssetId, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, asset docs.));
+
+#else
 
-#define UNPACK_SOUNDASSET(netconn, name)\
-   if (stream->readFlag())\
+#define INITPERSISTFIELD_SOUNDASSET_ARRAY(name, arraySize, consoleClass, docs) \
+   addProtectedField(#name, TypeSoundFilename, Offset(m##name##Name, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
+   addProtectedField(assetText(name, Asset), TypeSoundAssetId, Offset(m##name##AssetId, consoleClass), _set##name##Data, &defaultProtectedGetFn, arraySize, assetDoc(name, asset docs.));
+
+#endif
+
+#define LOAD_SOUNDASSET_ARRAY(name, index)\
+if (m##name##AssetId[index] != StringTable->EmptyString())\
+{\
+   S32 assetState = SoundAsset::getAssetById(m##name##AssetId[index], &m##name##Asset[index]);\
+   if (assetState == SoundAsset::Ok )\
    {\
-      m##name##AssetId = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
-      _set##name(m##name##AssetId);\
+      m##name##Name[index] = StringTable->EmptyString();\
    }\
-   else\
-      m##name##Name = stream->readSTString();
+   else Con::warnf("Warning: %s::LOAD_SOUNDASSET_ARRAY(%s[%i])-%s", mClassName, m##name##AssetId[index], index, ImageAsset::getAssetErrstrn(assetState).c_str());\
+}
 
+#define assetEnumNameConcat(x,suff)(new std::string( x + std::string(#suff)))->c_str()
+
+#define INITPERSISTFIELD_SOUNDASSET_ENUMED(name, enumType, maxValue, consoleClass, docs) \
+   for (U32 i = 0; i < maxValue; i++)\
+   {\
+      const enumType itter = static_cast<enumType>(i);\
+      const char* enumString = castConsoleTypeToString(static_cast<enumType>(itter));\
+      if (enumString && enumString[0])\
+      {\
+         addField(assetEnumNameConcat(enumString, File), TypeSoundFilename, Offset(m##name##Name[0], consoleClass) + sizeof(m##name##Name[0])*i, assetText(name, docs), AbstractClassRep::FIELD_HideInInspectors); \
+         addField(assetEnumNameConcat(enumString, Asset), TypeSoundAssetId, Offset(m##name##AssetId[0], consoleClass) + sizeof(m##name##AssetId[0])*i, assetText(name, asset reference.));\
+      }\
+   }
 #pragma endregion
 
 #endif // _ASSET_BASE_H_

Engine/source/T3D/assets/assetMacroHelpers.h

@@ -0,0 +1,298 @@
+//-----------------------------------------------------------------------------
+// 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.
+//-----------------------------------------------------------------------------
+#pragma once
+
+//general class-injection hooks for asset support. not all cases are needed for every class/usage. 
+
+//-----------------------------------------------------------------------------
+/// INDIVIDUALIZED CLASS ENTRIES
+//-----------------------------------------------------------------------------
+
+//iniitalization
+#define INIT_ASSET(name) \
+   m##name##Name = StringTable->EmptyString(); \
+   m##name##AssetId = StringTable->EmptyString(); \
+   m##name##Asset = NULL;\
+   m##name = NULL;
+
+//load asset into memory by looking up the ID, spew a warning if anything goes wrong
+#define LOAD_ASSET(name, assetClass)\
+if (m##name##AssetId != StringTable->EmptyString())\
+{\
+   S32 assetState = assetClass::getAssetById(m##name##AssetId, &m##name##Asset);\
+   if (assetState == assetClass::Ok )\
+   {\
+      m##name##Name = StringTable->EmptyString();\
+   }\
+   else Con::warnf("Warning: %s::LOAD_ASSET(%s)-%s", mClassName, m##name##AssetId, assetClass::getAssetErrstrn(assetState).c_str());\
+}
+
+// copy constructor 
+#define CLONE_ASSET(name) \
+   m##name##Name = other.m##name##Name;\
+   m##name##AssetId = other.m##name##AssetId;\
+   m##name##Asset = other.m##name##Asset;\
+   m##name = other.m##name
+
+// addProtectedField acessors
+#define DECLARE_ASSET_SETGET(className, name)\
+   static bool _set##name##Data(void* obj, const char* index, const char* data)\
+   {\
+      bool ret = false;\
+      className* object = static_cast<className*>(obj);\
+      ret = object->_set##name(StringTable->insert(data));\
+      return ret;\
+   }
+
+// addProtectedField acessors for networked objects (sets a flag)
+#define DECLARE_ASSET_NET_SETGET(className, name, bitmask)\
+   static bool _set##name##Data(void* obj, const char* index, const char* data)\
+   {\
+      bool ret = false;\
+      className* object = static_cast<className*>(obj);\
+      ret = object->_set##name(StringTable->insert(data));\
+      if(ret)\
+         object->setMaskBits(bitmask);\
+      return ret;\
+   }
+
+//network send - datablock
+#define PACKDATA_ASSET(name)\
+   if (stream->writeFlag(m##name##Asset.notNull()))\
+   {\
+      stream->writeString(m##name##Asset.getAssetId());\
+   }\
+   else\
+      stream->writeString(m##name##Name);
+
+//network recieve - datablock
+#define UNPACKDATA_ASSET(name)\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId = stream->readSTString();\
+      _set##name(m##name##AssetId);\
+   }\
+   else\
+   {\
+      m##name##Name = stream->readSTString();\
+      _set##name(m##name##Name);\
+   }
+
+//network send - object-instance
+#define PACK_ASSET(netconn, name)\
+   if (stream->writeFlag(m##name##Asset.notNull()))\
+   {\
+      NetStringHandle assetIdStr = m##name##Asset.getAssetId();\
+      netconn->packNetStringHandleU(stream, assetIdStr);\
+   }\
+   else\
+      stream->writeString(m##name##Name);
+
+//network recieve - object-instance
+#define UNPACK_ASSET(netconn, name)\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
+      _set##name(m##name##AssetId);\
+   }\
+   else\
+      m##name##Name = stream->readSTString();
+
+//script methods for class.asset acces
+//declare general get<entry>, get<entry>Asset and set<entry> methods
+#define DEF_ASSET_BINDS(className,name)\
+DefineEngineMethod(className, get##name, String, (), , "get name")\
+{\
+   return object->get##name(); \
+}\
+DefineEngineMethod(className, get##name##Asset, String, (), , assetText(name, asset reference))\
+{\
+   return object->m##name##AssetId; \
+}\
+DefineEngineMethod(className, set##name, bool, (const char* assetName), , assetText(name,assignment. first tries asset then flat file.))\
+{\
+   return object->_set##name(StringTable->insert(assetName));\
+}
+
+//-----------------------------------------------------------------------------
+/// ARRAY CLASS ENTRIES
+//-----------------------------------------------------------------------------
+
+//iniitalization
+#define INIT_ASSET_ARRAY(name, index) \
+{\
+   m##name##Name[index] = StringTable->EmptyString(); \
+   m##name##AssetId[index] = StringTable->EmptyString(); \
+   m##name##Asset[index] = NULL;\
+   m##name[index] = NULL;\
+}
+
+//load asset into memory by looking up the ID, spew a warning if anything goes wrong
+#define LOAD_ASSET_ARRAY(name, index, assetClass)\
+if (m##name##AssetId[index] != StringTable->EmptyString())\
+{\
+   S32 assetState = assetClass::getAssetById(m##name##AssetId[index], &m##name##Asset[index]);\
+   if (assetState == assetClass::Ok )\
+   {\
+      m##name##Name[index] = StringTable->EmptyString();\
+   }\
+   else Con::warnf("Warning: %s::LOAD_ASSET(%s[%d])-%s", mClassName, m##name##AssetId[index],index, assetClass::getAssetErrstrn(assetState).c_str());\
+}
+
+// copy constructor 
+#define CLONE_ASSET_ARRAY(name, index) \
+{\
+   m##name##Name[index] = other.m##name##Name[index];\
+   m##name##AssetId[index] = other.m##name##AssetId[index];\
+   m##name##Asset[index] = other.m##name##Asset[index];\
+   m##name[index] = other.m##name[index];\
+}
+// addProtectedField acessors
+#define DECLARE_ASSET_ARRAY_SETGET(className, name)\
+   static bool _set##name##Data(void* obj, const char* index, const char* data)\
+   {\
+      if(!index) return false;\
+      U32 idx = dAtoi(index);\
+      if (idx >= sm##name##Count)\
+         return false;\
+      bool ret = false;\
+      className* object = static_cast<className*>(obj);\
+      ret = object->_set##name(StringTable->insert(data), idx);\
+      return ret;\
+   }
+// addProtectedField acessors for networked objects (sets a flag)
+#define DECLARE_ASSET_ARRAY_NET_SETGET(className, name, bitmask)\
+   static bool _set##name##Data(void* obj, const char* index, const char* data)\
+   {\
+      if (!index) return false;\
+      U32 idx = dAtoi(index);\
+      if (idx >= sm##name##Count)\
+         return false;\
+      bool ret = false;\
+      className* object = static_cast<className*>(obj);\
+      ret = object->_set##name(StringTable->insert(data), idx);\
+      if(ret)\
+         object->setMaskBits(bitmask);\
+      return ret;\
+   }
+//network send - datablock
+#define PACKDATA_ASSET_ARRAY(name, index)\
+   if (stream->writeFlag(m##name##Asset[index].notNull()))\
+   {\
+      stream->writeString(m##name##Asset[index].getAssetId());\
+   }\
+   else\
+      stream->writeString(m##name##Name[index]);
+
+//network recieve - datablock
+#define UNPACKDATA_ASSET_ARRAY(name, index)\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId[index] = stream->readSTString();\
+      _set##name(m##name##AssetId[index], index);\
+   }\
+   else\
+   {\
+      m##name##Name[index] = stream->readSTString();\
+      _set##name(m##name##Name[index], index);\
+   }
+
+//network send - object-instance
+#define PACK_ASSET_ARRAY(netconn, name, index)\
+   if (stream->writeFlag(m##name##Asset[index].notNull()))\
+   {\
+      NetStringHandle assetIdStr = m##name##Asset[index].getAssetId();\
+      netconn->packNetStringHandleU(stream, assetIdStr);\
+   }\
+   else\
+      stream->writeString(m##name##Name[index]);
+
+//network recieve - object-instance
+#define UNPACK_ASSET_ARRAY(netconn, name, index)\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId[index] = StringTable->insert(netconn->unpackNetStringHandleU(stream).getString());\
+      _set##name(m##name##AssetId[index], index);\
+   }\
+   else\
+   {\
+      m##name##Name[index] = stream->readSTString();\
+      _set##name(m##name##Name[index], index);\
+   }
+
+//script methods for class.asset acces
+//declare general get<entry>, get<entry>Asset and set<entry> methods
+//signatures are:
+//using DiffuseMap as an example
+//material.getDiffuseMap(%layer); //returns the raw file referenced
+//material.getDiffuseMapAsset(%layer); //returns the asset id
+//material.setDiffuseMap(%texture, %layer); //tries to set the asset and failing that attempts a flat file reference
+#define DEF_ASSET_ARRAY_BINDS(className,name)\
+DefineEngineMethod(className, get##name, const char*, (S32 index), , "get name")\
+{\
+   return object->get##name(index); \
+}\
+DefineEngineMethod(className, get##name##Asset, const char*, (S32 index), , assetText(name, asset reference))\
+{\
+   if(index >= className::sm##name##Count || index < 0)\
+      return "";\
+   return object->m##name##AssetId[index]; \
+}\
+DefineEngineMethod(className, set##name, bool, (const char* assetName, S32 index), , assetText(name,assignment. first tries asset then flat file.))\
+{\
+    return object->_set##name(StringTable->insert(assetName), index);\
+}
+
+//-----------------------------------------------------------------------------
+/// ARRAYS REFERENCED VIA ENUM CLASS ENTRIES
+//-----------------------------------------------------------------------------
+// 
+// substite these in to see the enum strings and assigned values
+//network send - object-instance
+#define PACKDATA_ASSET_ARRAY_ENUMED(name, enumType, index )\
+{\
+   if (stream->writeFlag(m##name##Asset[index].notNull()))\
+   {\
+      stream->writeString(m##name##Asset[index].getAssetId());\
+      const char* enumString = castConsoleTypeToString(static_cast<enumType>(index));\
+      Con::printf("pack: %s = %s",enumString, m##name##AssetId[index]);\
+   }\
+   else\
+      stream->writeString(m##name##Name[index]);\
+}
+//network recieve - object-instance
+#define UNPACKDATA_ASSET_ARRAY_ENUMED(name, enumType, index )\
+{\
+   if (stream->readFlag())\
+   {\
+      m##name##AssetId[index] = stream->readSTString();\
+      _set##name(m##name##AssetId[index], index);\
+      const char* enumString = castConsoleTypeToString(static_cast<enumType>(index));\
+      Con::printf("unpack: %s = %s",enumString, m##name##AssetId[index]);\
+   }\
+   else\
+   {\
+      m##name##Name[index] = stream->readSTString();\
+      _set##name(m##name##AssetId[index], index);\
+   }\
+}
+

Engine/source/T3D/convexShape.cpp

@@ -289,7 +289,7 @@ ConvexShape::ConvexShape()
    mSurfaceUVs.clear();
    mSurfaceTextures.clear();
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
 }
 
 ConvexShape::~ConvexShape()
@@ -527,7 +527,7 @@ U32 ConvexShape::packUpdate( NetConnection *conn, U32 mask, BitStream *stream )
 
    if ( stream->writeFlag( mask & UpdateMask ) )
    {
-      PACK_MATERIALASSET(conn, Material);
+      PACK_ASSET(conn, Material);
       
       U32 surfCount = mSurfaces.size();
       stream->writeInt( surfCount, 32 );
@@ -583,7 +583,7 @@ void ConvexShape::unpackUpdate( NetConnection *conn, BitStream *stream )
 
    if ( stream->readFlag() ) // UpdateMask
    {
-      UNPACK_MATERIALASSET(conn, Material);
+      UNPACK_ASSET(conn, Material);
 
       mSurfaces.clear();
       mSurfaceUVs.clear();
@@ -2154,4 +2154,4 @@ void ConvexShape::Geometry::generate(const Vector< PlaneF > &planes, const Vecto
    }
 }
 
-DEF_MATERIALASSET_BINDS(ConvexShape, Material);
+DEF_ASSET_BINDS(ConvexShape, Material);

Engine/source/T3D/convexShape.h

@@ -138,14 +138,14 @@ public:
       // The name of the Material we will use for rendering
       DECLARE_MATERIALASSET(surfaceMaterial, Material);
       
-      DECLARE_MATERIALASSET_SETGET(surfaceMaterial, Material);
+      DECLARE_ASSET_SETGET(surfaceMaterial, Material);
 
       // The actual Material instance
       BaseMatInstance*  materialInst;
 
       surfaceMaterial()
       {
-         INIT_MATERIALASSET(Material);
+         INIT_ASSET(Material);
 
          materialInst = NULL;
       }
@@ -264,7 +264,7 @@ protected:
 protected:
    
    DECLARE_MATERIALASSET(ConvexShape, Material);
-   DECLARE_MATERIALASSET_SETGET(ConvexShape, Material);
+   DECLARE_ASSET_SETGET(ConvexShape, Material);
 
    // The actual Material instance
    BaseMatInstance*  mMaterialInst;

Engine/source/T3D/debris.cpp

@@ -116,7 +116,7 @@ DebrisData::DebrisData()
    terminalVelocity = 0.0f;
    ignoreWater = true;
 
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 }
 
 //#define TRACK_DEBRIS_DATA_CLONES
@@ -152,7 +152,7 @@ DebrisData::DebrisData(const DebrisData& other, bool temp_clone) : GameBaseData(
    terminalVelocity = other.terminalVelocity;
    ignoreWater = other.ignoreWater;
 
-   CLONE_SHAPEASSET(Shape);
+   CLONE_ASSET(Shape);
 
    textureName = other.textureName;
    explosionId = other.explosionId; // -- for pack/unpack of explosion ptr
@@ -382,7 +382,7 @@ void DebrisData::packData(BitStream* stream)
 
    stream->writeString( textureName );
 
-   PACKDATA_SHAPEASSET(Shape);
+   PACKDATA_ASSET(Shape);
 
    for( S32 i=0; i<DDC_NUM_EMITTERS; i++ )
    {
@@ -426,7 +426,7 @@ void DebrisData::unpackData(BitStream* stream)
 
    textureName = stream->readSTString();
 
-   UNPACKDATA_SHAPEASSET(Shape);
+   UNPACKDATA_ASSET(Shape);
 
    for( S32 i=0; i<DDC_NUM_EMITTERS; i++ )
    {

Engine/source/T3D/debris.h

@@ -84,7 +84,7 @@ struct DebrisData : public GameBaseData
    bool     ignoreWater;
 
    DECLARE_SHAPEASSET(DebrisData, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(DebrisData, Shape);
+   DECLARE_ASSET_SETGET(DebrisData, Shape);
 
    StringTableEntry  textureName;
 

Engine/source/T3D/decal/decalData.cpp

@@ -76,7 +76,7 @@ ConsoleDocClass( DecalData,
 DecalData::DecalData()
 {
    size = 5;
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
 
    lifeSpan = 5000;
    fadeTime = 1000;
@@ -258,7 +258,7 @@ void DecalData::packData( BitStream *stream )
    stream->write( lookupName );
    stream->write( size );
 
-   PACKDATA_MATERIALASSET(Material);
+   PACKDATA_ASSET(Material);
 
    stream->write( lifeSpan );
    stream->write( fadeTime );
@@ -287,7 +287,7 @@ void DecalData::unpackData( BitStream *stream )
    assignName(lookupName);
    stream->read( &size );
 
-   UNPACKDATA_MATERIALASSET(Material);
+   UNPACKDATA_ASSET(Material);
    
    _updateMaterial();
    stream->read( &lifeSpan );

Engine/source/T3D/decal/decalData.h

@@ -78,7 +78,7 @@ class DecalData : public SimDataBlock
       F32 fadeEndPixelSize;
 
       DECLARE_MATERIALASSET(DecalData, Material);
-      DECLARE_MATERIALASSET_SETGET(DecalData, Material);
+      DECLARE_ASSET_SETGET(DecalData, Material);
       
       /// Material instance for decal.
       BaseMatInstance *matInst;
@@ -139,4 +139,4 @@ inline SimSet* DecalData::getSet()
    return set;
 }
 
-#endif // _DECALDATA_H_
+#endif // _DECALDATA_H_

Engine/source/T3D/examples/renderMeshExample.cpp

@@ -59,7 +59,7 @@ RenderMeshExample::RenderMeshExample()
    // Set it as a "static" object that casts shadows
    mTypeMask |= StaticObjectType | StaticShapeObjectType;
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
 }
 
 RenderMeshExample::~RenderMeshExample()
@@ -143,7 +143,7 @@ U32 RenderMeshExample::packUpdate( NetConnection *conn, U32 mask, BitStream *str
    // Write out any of the updated editable properties
    if (stream->writeFlag(mask & UpdateMask))
    {
-      PACK_MATERIALASSET(conn, Material);
+      PACK_ASSET(conn, Material);
    }
 
    return retMask;
@@ -164,7 +164,7 @@ void RenderMeshExample::unpackUpdate(NetConnection *conn, BitStream *stream)
 
    if ( stream->readFlag() )  // UpdateMask
    {
-      UNPACK_MATERIALASSET(conn, Material);
+      UNPACK_ASSET(conn, Material);
 
       if ( isProperlyAdded() )
          updateMaterial();

Engine/source/T3D/examples/renderMeshExample.h

@@ -74,7 +74,7 @@ class RenderMeshExample : public SceneObject
    BaseMatInstance* mMaterialInst;
 
    DECLARE_MATERIALASSET(RenderMeshExample, Material);
-   DECLARE_MATERIALASSET_NET_SETGET(RenderMeshExample, Material, UpdateMask);
+   DECLARE_ASSET_NET_SETGET(RenderMeshExample, Material, UpdateMask);
 
    // The GFX vertex and primitive buffers
    GFXVertexBufferHandle< VertexType > mVertexBuffer;

Engine/source/T3D/examples/renderShapeExample.cpp

@@ -145,7 +145,7 @@ U32 RenderShapeExample::packUpdate( NetConnection *conn, U32 mask, BitStream *st
    // Write out any of the updated editable properties
    if ( stream->writeFlag( mask & UpdateMask ) )
    {
-      PACK_SHAPEASSET(conn, Shape);
+      PACK_ASSET(conn, Shape);
 
       // Allow the server object a chance to handle a new shape
       createShape();
@@ -169,7 +169,7 @@ void RenderShapeExample::unpackUpdate(NetConnection *conn, BitStream *stream)
 
    if ( stream->readFlag() )  // UpdateMask
    {
-      UNPACK_SHAPEASSET(conn, Shape);
+      UNPACK_ASSET(conn, Shape);
 
       if ( isProperlyAdded() )
          createShape();
@@ -258,4 +258,4 @@ void RenderShapeExample::prepRenderImage( SceneRenderState *state )
 
    // Allow the shape to submit the RenderInst(s) for itself
    mShapeInstance->render( rdata );
-}
+}

Engine/source/T3D/examples/renderShapeExample.h

@@ -62,7 +62,7 @@ class RenderShapeExample : public SceneObject
    // Rendering variables
    //--------------------------------------------------------------------------
    DECLARE_SHAPEASSET(RenderShapeExample, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(RenderShapeExample, Shape);
+   DECLARE_ASSET_SETGET(RenderShapeExample, Shape);
 
    // The actual shape instance
    TSShapeInstance*  mShapeInstance;

Engine/source/T3D/fx/explosion.cpp

@@ -230,14 +230,16 @@ ExplosionData::ExplosionData()
 
    faceViewer   = false;
 
-   soundProfile      = NULL;
+   INIT_ASSET(Sound);
+
+   //soundProfile      = NULL;
    particleEmitter   = NULL;
    particleEmitterId = 0;
 
    explosionScale.set(1.0f, 1.0f, 1.0f);
    playSpeed = 1.0f;
 
-   INIT_SHAPEASSET(ExplosionShape);
+   INIT_ASSET(ExplosionShape);
 
    explosionAnimation = -1;
 
@@ -308,12 +310,12 @@ ExplosionData::ExplosionData(const ExplosionData& other, bool temp_clone) : Game
    faceViewer = other.faceViewer;
    particleDensity = other.particleDensity;
    particleRadius = other.particleRadius;
-   soundProfile = other.soundProfile;
+   CLONE_ASSET(Sound);
    particleEmitter = other.particleEmitter;
    particleEmitterId = other.particleEmitterId; // -- for pack/unpack of particleEmitter ptr 
    explosionScale = other.explosionScale;
    playSpeed = other.playSpeed;
-   CLONE_SHAPEASSET(ExplosionShape);
+   CLONE_ASSET(ExplosionShape);
    explosionAnimation = other.explosionAnimation; // -- from explosionShape sequence "ambient"
    dMemcpy( emitterList, other.emitterList, sizeof( emitterList ) );
    dMemcpy( emitterIDList, other.emitterIDList, sizeof( emitterIDList ) ); // -- for pack/unpack of emitterList ptrs
@@ -358,12 +360,6 @@ ExplosionData::~ExplosionData()
    if (!isTempClone())
       return;
 
-   if (soundProfile && soundProfile->isTempClone())
-   {
-      delete soundProfile;
-      soundProfile = 0;
-   }
-
    // particleEmitter, emitterList[*], debrisList[*], explosionList[*] will delete themselves
 
 #ifdef TRACK_EXPLOSION_DATA_CLONES
@@ -399,8 +395,9 @@ void ExplosionData::initPersistFields()
       "of the explosion." );
    addField( "playSpeed", TypeF32, Offset(playSpeed, ExplosionData),
       "Time scale at which to play the explosionShape <i>ambient</i> sequence." );
-   addField( "soundProfile", TYPEID< SFXTrack >(), Offset(soundProfile, ExplosionData),
-      "Non-looping sound effect that will be played at the start of the explosion." );
+
+   INITPERSISTFIELD_SOUNDASSET(Sound, ExplosionData, "Sound to play when this explosion explodes.");
+
    addField( "faceViewer", TypeBool, Offset(faceViewer, ExplosionData),
       "Controls whether the visual effects of the explosion always face the camera." );
 
@@ -523,7 +520,6 @@ void ExplosionData::initPersistFields()
    onlyKeepClearSubstitutions("debris"); // subs resolving to "~~", or "~0" are OK
    onlyKeepClearSubstitutions("emitter");
    onlyKeepClearSubstitutions("particleEmitter");
-   onlyKeepClearSubstitutions("soundProfile");
    onlyKeepClearSubstitutions("subExplosion");
    Parent::initPersistFields();
 }
@@ -654,9 +650,10 @@ void ExplosionData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   PACKDATA_SHAPEASSET(ExplosionShape);
+   PACKDATA_ASSET(ExplosionShape);
+
+   PACKDATA_ASSET(Sound);
 
-   sfxWrite( stream, soundProfile );
    if (stream->writeFlag(particleEmitter))
       stream->writeRangedU32(particleEmitter->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);
 
@@ -757,9 +754,9 @@ void ExplosionData::unpackData(BitStream* stream)
 {
 	Parent::unpackData(stream);
 
-   UNPACKDATA_SHAPEASSET(ExplosionShape);
+   UNPACKDATA_ASSET(ExplosionShape);
 
-   sfxRead( stream, &soundProfile );
+   UNPACKDATA_ASSET(Sound);
 
    if (stream->readFlag())
       particleEmitterId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
@@ -861,12 +858,21 @@ bool ExplosionData::preload(bool server, String &errorStr)
 {
    if (Parent::preload(server, errorStr) == false)
       return false;
-      
+
+   if (!server && !getSoundProfile())
+      return false;
+
    if( !server )
    {
-      String sfxErrorStr;
-      if( !sfxResolve( &soundProfile, sfxErrorStr ) )
-         Con::errorf(ConsoleLogEntry::General, "Error, unable to load sound profile for explosion datablock: %s", sfxErrorStr.c_str());
+
+      if (getSound() != StringTable->EmptyString())
+      {
+         _setSound(getSound());
+
+         if (!getSoundProfile())
+            Con::errorf(ConsoleLogEntry::General, "SplashData::preload: Cant get an sfxProfile for splash.");
+      }
+
       if (!particleEmitter && particleEmitterId != 0)
          if (Sim::findObject(particleEmitterId, particleEmitter) == false)
             Con::errorf(ConsoleLogEntry::General, "Error, unable to load particle emitter for explosion datablock");
@@ -1384,7 +1390,7 @@ bool Explosion::explode()
       resetWorldBox();
    }
 
-   SFXProfile* sound_prof = dynamic_cast<SFXProfile*>(mDataBlock->soundProfile);
+   SFXProfile* sound_prof = mDataBlock->getSoundProfile();
    if (sound_prof)
    {
       soundProfile_clone = sound_prof->cloneAndPerformSubstitutions(ss_object, ss_index);

Engine/source/T3D/fx/explosion.h

@@ -42,6 +42,7 @@
 #endif
 
 #include "T3D/assets/ShapeAsset.h"
+#include "T3D/assets/SoundAsset.h"
 
 class ParticleEmitter;
 class ParticleEmitterData;
@@ -69,7 +70,9 @@ class ExplosionData : public GameBaseData {
    S32 particleDensity;
    F32 particleRadius;
 
-   SFXTrack*        soundProfile;
+   DECLARE_SOUNDASSET(ExplosionData, Sound);
+   DECLARE_ASSET_SETGET(ExplosionData, Sound);
+
    ParticleEmitterData* particleEmitter;
    S32                  particleEmitterId;
 
@@ -77,7 +80,7 @@ class ExplosionData : public GameBaseData {
    F32                  playSpeed;
 
    DECLARE_SHAPEASSET(ExplosionData, ExplosionShape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(ExplosionData, ExplosionShape);
+   DECLARE_ASSET_SETGET(ExplosionData, ExplosionShape);
 
    S32               explosionAnimation;
 

Engine/source/T3D/fx/groundCover.cpp

@@ -459,7 +459,7 @@ GroundCover::GroundCover()
 
    mRandomSeed = 1;
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
    mMaterialInst = NULL;
 
    mMatParams = NULL;
@@ -520,7 +520,7 @@ GroundCover::GroundCover()
       mBillboardRects[i].point.set( 0.0f, 0.0f );
       mBillboardRects[i].extent.set( 1.0f, 1.0f );
 
-      INIT_SHAPEASSET_ARRAY(Shape, i);
+      INIT_ASSET_ARRAY(Shape, i);
 
       mShapeInstances[i] = NULL;
 
@@ -713,7 +713,7 @@ U32 GroundCover::packUpdate( NetConnection *connection, U32 mask, BitStream *str
       // TODO: We could probably optimize a few of these
       // based on reasonable units at some point.
 
-      PACK_MATERIALASSET(connection, Material);
+      PACK_ASSET(connection, Material);
 
       stream->write( mRadius );
       stream->write( mZOffset );
@@ -766,7 +766,7 @@ U32 GroundCover::packUpdate( NetConnection *connection, U32 mask, BitStream *str
          stream->write( mBillboardRects[i].extent.x );
          stream->write( mBillboardRects[i].extent.y );
 
-         PACK_SHAPEASSET_ARRAY(connection, Shape, i);
+         PACK_ASSET_ARRAY(connection, Shape, i);
       }
 
       stream->writeFlag( mDebugRenderCells );
@@ -784,7 +784,7 @@ void GroundCover::unpackUpdate( NetConnection *connection, BitStream *stream )
 
    if (stream->readFlag())
    {
-      UNPACK_MATERIALASSET(connection, Material);
+      UNPACK_ASSET(connection, Material);
 
       stream->read( &mRadius );
       stream->read( &mZOffset );
@@ -837,7 +837,7 @@ void GroundCover::unpackUpdate( NetConnection *connection, BitStream *stream )
          stream->read( &mBillboardRects[i].extent.x );
          stream->read( &mBillboardRects[i].extent.y );
 
-         UNPACK_SHAPEASSET_ARRAY(connection, Shape, i);
+         UNPACK_ASSET_ARRAY(connection, Shape, i);
       }
 
       mDebugRenderCells    = stream->readFlag();

Engine/source/T3D/fx/groundCover.h

@@ -269,7 +269,7 @@ protected:
    BaseMatInstance* mMaterialInst;
 
    DECLARE_MATERIALASSET(GroundCover, Material);
-   DECLARE_MATERIALASSET_NET_SETGET(GroundCover, Material, InitialUpdateMask);
+   DECLARE_ASSET_NET_SETGET(GroundCover, Material, InitialUpdateMask);
 
    GroundCoverShaderConstData mShaderConstData;
 
@@ -341,7 +341,7 @@ protected:
 
    /// The cover shape filenames.
    DECLARE_SHAPEASSET_ARRAY(GroundCover, Shape, MAX_COVERTYPES);
-   DECLARE_SHAPEASSET_ARRAY_NET_SETGET(GroundCover, Shape, -1);
+   DECLARE_ASSET_ARRAY_NET_SETGET(GroundCover, Shape, -1);
 
    /// The cover shape instances.
    TSShapeInstance* mShapeInstances[MAX_COVERTYPES];

Engine/source/T3D/fx/lightning.cpp

@@ -238,10 +238,12 @@ void LightningStrikeEvent::process(NetConnection*)
 //
 LightningData::LightningData()
 {
-   strikeSound = NULL;
+   INIT_ASSET(StrikeSound);
 
    for (S32 i = 0; i < MaxThunders; i++)
-      thunderSounds[i] = NULL;
+   {
+      INIT_ASSET_ARRAY(ThunderSound, i);
+   }
 
    for (S32 i = 0; i < MaxTextures; i++)
    {
@@ -260,12 +262,11 @@ LightningData::~LightningData()
 //--------------------------------------------------------------------------
 void LightningData::initPersistFields()
 {
-   addField( "strikeSound", TYPEID< SFXTrack >(), Offset(strikeSound, LightningData),
-      "Sound profile to play when a lightning strike occurs." );
-   addField( "thunderSounds", TYPEID< SFXTrack >(), Offset(thunderSounds, LightningData), MaxThunders,
-      "@brief List of thunder sound effects to play.\n\n"
-      "A random one of these sounds will be played shortly after each strike "
-      "occurs." );
+
+   INITPERSISTFIELD_SOUNDASSET(StrikeSound, LightningData, "Sound to play when lightning STRIKES!");
+
+   INITPERSISTFIELD_SOUNDASSET_ARRAY(ThunderSound, MaxThunders, LightningData, "Sounds for thunder.");
+
    addField( "strikeTextures", TypeString, Offset(strikeTextureNames, LightningData), MaxTextures,
       "List of textures to use to render lightning strikes." );
 
@@ -290,27 +291,32 @@ bool LightningData::preload(bool server, String &errorStr)
 
    //dQsort(thunderSounds, MaxThunders, sizeof(SFXTrack*), cmpSounds);
 
-   for (S32 i = 0; i < MaxThunders; i++) {
-	   if (thunderSounds[i]!= NULL) numThunders++;
-   }
-
+   
    if (server == false) 
    {
-      String sfxErrorStr;
-      for (U32 i = 0; i < MaxThunders; i++) {
-         if( !sfxResolve( &thunderSounds[ i ], sfxErrorStr ) )
-            Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Invalid packet: %s", sfxErrorStr.c_str());
+      for (S32 i = 0; i < MaxThunders; i++)
+      {
+         _setThunderSound(getThunderSound(i), i);
+         if (isThunderSoundValid(i) && !getThunderSoundProfile(i))
+         {
+               Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Cant get an sfxProfile for thunder.");
+
+         }
+
       }
 
-      if( !sfxResolve( &strikeSound, sfxErrorStr ) )
-         Con::errorf(ConsoleLogEntry::General, "LightningData::preload: Invalid packet: %s", sfxErrorStr.c_str());
+      _setStrikeSound(getStrikeSound());
+      if (isStrikeSoundValid() && !getStrikeSoundProfile())
+      {
+            Con::errorf(ConsoleLogEntry::General, "LightningData::preload: can't get sfxProfile from strike sound.");
+      }
 
       mNumStrikeTextures = 0;
-      for (U32 i = 0; i < MaxTextures; i++) 
+      for (U32 k = 0; k < MaxTextures; k++) 
       {
-         if (strikeTextureNames[i][0])
+         if (strikeTextureNames[k][0])
          {
-            strikeTextures[i] = GFXTexHandle(strikeTextureNames[i], &GFXStaticTextureProfile, avar("%s() - strikeTextures[%d] (line %d)", __FUNCTION__, i, __LINE__));
+            strikeTextures[k] = GFXTexHandle(strikeTextureNames[k], &GFXStaticTextureProfile, avar("%s() - strikeTextures[%d] (line %d)", __FUNCTION__, k, __LINE__));
             mNumStrikeTextures++;
          }
       }
@@ -329,8 +335,7 @@ void LightningData::packData(BitStream* stream)
    U32 i;
    for (i = 0; i < MaxThunders; i++)
    {
-      if (stream->writeFlag(thunderSounds[i]))
-         sfxWrite(stream, thunderSounds[i]);
+      PACKDATA_ASSET_ARRAY(ThunderSound, i);
    }
 
    stream->writeInt(mNumStrikeTextures, 4);
@@ -338,7 +343,7 @@ void LightningData::packData(BitStream* stream)
    for (i = 0; i < MaxTextures; i++)
       stream->writeString(strikeTextureNames[i]);
 
-   sfxWrite( stream, strikeSound );
+   PACKDATA_ASSET(StrikeSound);
 }
 
 void LightningData::unpackData(BitStream* stream)
@@ -348,10 +353,7 @@ void LightningData::unpackData(BitStream* stream)
    U32 i;
    for (i = 0; i < MaxThunders; i++)
    {
-      if (stream->readFlag())
-         sfxRead(stream, &thunderSounds[i]);
-      else
-         thunderSounds[i] = NULL;
+      UNPACKDATA_ASSET_ARRAY(ThunderSound, i);
    }
 
    mNumStrikeTextures = stream->readInt(4);
@@ -359,7 +361,7 @@ void LightningData::unpackData(BitStream* stream)
    for (i = 0; i < MaxTextures; i++)
       strikeTextureNames[i] = stream->readSTString();
 
-   sfxRead( stream, &strikeSound );
+   UNPACKDATA_ASSET(StrikeSound);
 }
 
 
@@ -584,7 +586,7 @@ void Lightning::scheduleThunder(Strike* newStrike)
          if (t <= 0.03f) {
             // If it's really close, just play it...
             U32 thunder = sgLightningRand.randI(0, mDataBlock->numThunders - 1);
-            SFX->playOnce(mDataBlock->thunderSounds[thunder]);
+            SFX->playOnce(mDataBlock->getThunderSoundProfile(thunder));
          } else {
             Thunder* pThunder = new Thunder;
             pThunder->tRemaining = t;
@@ -651,7 +653,7 @@ void Lightning::advanceTime(F32 dt)
 
          // Play the sound...
          U32 thunder = sgLightningRand.randI(0, mDataBlock->numThunders - 1);
-         SFX->playOnce(mDataBlock->thunderSounds[thunder]);
+         SFX->playOnce(mDataBlock->getThunderSoundProfile(thunder));
       } else {
          pThunderWalker = &((*pThunderWalker)->next);
       }
@@ -735,9 +737,9 @@ void Lightning::processEvent(LightningStrikeEvent* pEvent)
       MatrixF trans(true);
       trans.setPosition( strikePoint );
 
-      if (mDataBlock->strikeSound)
+      if (mDataBlock->getStrikeSoundProfile())
       {
-         SFX->playOnce(mDataBlock->strikeSound, &trans );
+         SFX->playOnce(mDataBlock->getStrikeSoundProfile(), &trans );
       }
 
 }
@@ -1337,4 +1339,4 @@ void LightningBolt::update( F32 dt )
       isFading = false;
       elapsedTime = 0.0f;
    }
-}
+}

Engine/source/T3D/fx/lightning.h

@@ -41,7 +41,8 @@
 
 #include "gfx/gfxTextureHandle.h"
 
-
+#include "T3D/assets/ImageAsset.h"
+#include "T3D/assets/SoundAsset.h"
 
 class ShapeBase;
 class LightningStrikeEvent;
@@ -62,8 +63,13 @@ class LightningData : public GameBaseData
 
    //-------------------------------------- Console set variables
   public:
-   SFXTrack*          thunderSounds[MaxThunders];
-   SFXTrack*         strikeSound;
+
+   DECLARE_SOUNDASSET_ARRAY(LightningData, ThunderSound, MaxThunders);
+   DECLARE_ASSET_ARRAY_SETGET(LightningData, ThunderSound);
+
+   DECLARE_SOUNDASSET(LightningData, StrikeSound);
+   DECLARE_ASSET_SETGET(LightningData, StrikeSound);
+
    StringTableEntry  strikeTextureNames[MaxTextures];
 
    //-------------------------------------- load set variables

Engine/source/T3D/fx/particle.cpp

@@ -122,8 +122,8 @@ ParticleData::ParticleData()
    animTexFramesString = NULL;  // string of animation frame indices
    animTexUVs = NULL;           // array of tile vertex UVs
 
-   INIT_IMAGEASSET(Texture);
-   INIT_IMAGEASSET(TextureExt);
+   INIT_ASSET(Texture);
+   INIT_ASSET(TextureExt);
 
    constrain_pos = false;
    start_angle = 0.0f;
@@ -293,7 +293,7 @@ void ParticleData::packData(BitStream* stream)
       stream->writeFloat( times[i], 8);
    }
 
-   //PACKDATA_IMAGEASSET(Texture);
+   //PACKDATA_ASSET(Texture);
 
    for (i = 0; i < 4; i++)
       mathWrite(*stream, texCoords[i]);
@@ -307,7 +307,7 @@ void ParticleData::packData(BitStream* stream)
       stream->writeInt(framesPerSec, 8);
    }
 
-   //PACKDATA_IMAGEASSET(TextureExt);
+   //PACKDATA_ASSET(TextureExt);
 
    stream->writeFlag(constrain_pos);
    stream->writeFloat(start_angle/360.0f, 11);
@@ -378,7 +378,7 @@ void ParticleData::unpackData(BitStream* stream)
       times[i] = stream->readFloat(8);
    }
 
-   //UNPACKDATA_IMAGEASSET(Texture);
+   //UNPACKDATA_ASSET(Texture);
 
    for (i = 0; i < 4; i++)
       mathRead(*stream, &texCoords[i]);
@@ -391,7 +391,7 @@ void ParticleData::unpackData(BitStream* stream)
      framesPerSec = stream->readInt(8);
    }
 
-   //UNPACKDATA_IMAGEASSET(Texture);
+   //UNPACKDATA_ASSET(Texture);
 
    constrain_pos = stream->readFlag();
    start_angle = 360.0f*stream->readFloat(11);
@@ -763,12 +763,12 @@ ParticleData::ParticleData(const ParticleData& other, bool temp_clone) : SimData
   animTexFramesString = other.animTexFramesString;
   animTexFrames = other.animTexFrames; // -- parsed from animTexFramesString
 
-  CLONE_IMAGEASSET(Texture);
+  CLONE_ASSET(Texture);
   
   spinBias = other.spinBias;
   randomizeSpinDir = other.randomizeSpinDir;
 
-  CLONE_IMAGEASSET(TextureExt);
+  CLONE_ASSET(TextureExt);
 
   constrain_pos = other.constrain_pos;
   start_angle = other.start_angle;
@@ -804,4 +804,4 @@ void ParticleData::onPerformSubstitutions()
   reload(errorBuffer);
 }
 
-DEF_IMAGEASSET_BINDS(ParticleData, Texture);
+DEF_ASSET_BINDS(ParticleData, Texture);

Engine/source/T3D/fx/particle.h

@@ -87,7 +87,7 @@ class ParticleData : public SimDataBlock
    Vector<U8>        animTexFrames;
 
    DECLARE_IMAGEASSET(ParticleData, Texture, onImageChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(ParticleData, Texture);
+   DECLARE_ASSET_SETGET(ParticleData, Texture);
 
    static bool protectedSetSizes(void* object, const char* index, const char* data);
    static bool protectedSetTimes(void* object, const char* index, const char* data);
@@ -118,7 +118,7 @@ public:
    bool  randomizeSpinDir;
   public:
    DECLARE_IMAGEASSET(ParticleData, TextureExt, onImageChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(ParticleData, TextureExt);
+   DECLARE_ASSET_SETGET(ParticleData, TextureExt);
 
    bool   constrain_pos;
    F32    start_angle;

Engine/source/T3D/fx/precipitation.cpp

@@ -127,13 +127,13 @@ ConsoleDocClass( PrecipitationData,
 //----------------------------------------------------------
 PrecipitationData::PrecipitationData()
 {
-   INIT_SOUNDASSET(Sound);
+   INIT_ASSET(Sound);
 
-   INIT_IMAGEASSET(Drop);
+   INIT_ASSET(Drop);
 
    mDropShaderName   = StringTable->EmptyString();
 
-   INIT_IMAGEASSET(Splash);
+   INIT_ASSET(Splash);
 
    mSplashShaderName = StringTable->EmptyString();
 
@@ -188,9 +188,16 @@ bool PrecipitationData::preload( bool server, String &errorStr )
 {
    if( Parent::preload( server, errorStr) == false)
       return false;
+   if (!server)
+   {
+      if (getSound() != StringTable->EmptyString())
+      {
+         _setSound(getSound());
 
-   if (!server && !getSFXProfile())
-      return false;
+         if (!getSoundProfile())
+            Con::errorf(ConsoleLogEntry::General, "SplashData::preload: Cant get an sfxProfile for splash.");
+      }
+   }
 
    return true;
 }
@@ -199,13 +206,13 @@ void PrecipitationData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   PACKDATA_SOUNDASSET(Sound);
+   PACKDATA_ASSET(Sound);
 
-   PACKDATA_IMAGEASSET(Drop);
+   PACKDATA_ASSET(Drop);
 
    stream->writeString(mDropShaderName);
 
-   PACKDATA_IMAGEASSET(Splash);
+   PACKDATA_ASSET(Splash);
 
    stream->writeString(mSplashShaderName);
    stream->write(mDropsPerSide);
@@ -216,13 +223,13 @@ void PrecipitationData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   UNPACKDATA_SOUNDASSET(Sound);
+   UNPACKDATA_ASSET(Sound);
 
-   UNPACKDATA_IMAGEASSET(Drop);
+   UNPACKDATA_ASSET(Drop);
 
    mDropShaderName = stream->readSTString();
 
-   UNPACKDATA_IMAGEASSET(Splash);
+   UNPACKDATA_ASSET(Splash);
 
    mSplashShaderName = stream->readSTString();
    stream->read(&mDropsPerSide);
@@ -597,9 +604,9 @@ bool Precipitation::onNewDataBlock( GameBaseData *dptr, bool reload )
    {
       SFX_DELETE( mAmbientSound );
 
-      if ( mDataBlock->getSFXProfile())
+      if ( mDataBlock->getSoundProfile())
       {
-         mAmbientSound = SFX->createSource(mDataBlock->getSFXProfile(), &getTransform() );
+         mAmbientSound = SFX->createSource(mDataBlock->getSoundProfile(), &getTransform() );
          if ( mAmbientSound )
             mAmbientSound->play();
       }

Engine/source/T3D/fx/precipitation.h

@@ -46,17 +46,16 @@ class PrecipitationData : public GameBaseData
    typedef GameBaseData Parent;
 
   public:
-   //SFXTrack*     soundProfile;
      DECLARE_SOUNDASSET(PrecipitationData, Sound);
-     DECLARE_SOUNDASSET_SETGET(PrecipitationData, Sound);
+     DECLARE_ASSET_SETGET(PrecipitationData, Sound);
 
       DECLARE_IMAGEASSET(PrecipitationData, Drop, onDropChanged, GFXStaticTextureSRGBProfile); ///< Texture for drop particles
-      DECLARE_IMAGEASSET_SETGET(PrecipitationData, Drop);
+      DECLARE_ASSET_SETGET(PrecipitationData, Drop);
 
       StringTableEntry mDropShaderName;   ///< The name of the shader used for raindrops
 
       DECLARE_IMAGEASSET(PrecipitationData, Splash, onSplashChanged, GFXStaticTextureSRGBProfile); ///< Texture for splash particles
-      DECLARE_IMAGEASSET_SETGET(PrecipitationData, Splash);
+      DECLARE_ASSET_SETGET(PrecipitationData, Splash);
 
       StringTableEntry mSplashShaderName; ///< The name of the shader used for raindrops
 
@@ -72,13 +71,6 @@ class PrecipitationData : public GameBaseData
 
       void onDropChanged() {}
       void onSplashChanged() {}
-
-      SFXProfile* getSFXProfile() {
-         if (mSoundAsset.notNull())
-            return mSoundAsset->getSfxProfile();
-         else
-            return NULL;
-      }
 };
 
 struct Raindrop

Engine/source/T3D/fx/splash.cpp

@@ -67,8 +67,10 @@ ConsoleDocClass( Splash,
 //--------------------------------------------------------------------------
 SplashData::SplashData()
 {
-   soundProfile      = NULL;
-   soundProfileId    = 0;
+   //soundProfile      = NULL;
+   //soundProfileId    = 0;
+
+   INIT_ASSET(Sound);
 
    scale.set(1, 1, 1);
 
@@ -95,7 +97,9 @@ SplashData::SplashData()
 
    U32 i;
    for (i = 0; i < NUM_TEX; i++)
-      INIT_IMAGEASSET_ARRAY(Texture, i);
+   {
+      INIT_ASSET_ARRAY(Texture, i);
+   }
 
    for( i=0; i<NUM_TIME_KEYS; i++ )
       times[i] = 1.0;
@@ -112,7 +116,8 @@ SplashData::SplashData()
 //--------------------------------------------------------------------------
    void SplashData::initPersistFields()
 {
-   addField("soundProfile",      TYPEID< SFXProfile >(),       Offset(soundProfile,       SplashData), "SFXProfile effect to play.\n");
+   INITPERSISTFIELD_SOUNDASSET(Sound, SplashData, "Sound to play when splash, splashes.");
+
    addField("scale",             TypePoint3F,                  Offset(scale,              SplashData), "The scale of this splashing effect, defined as the F32 points X, Y, Z.\n");
    addField("emitter",           TYPEID< ParticleEmitterData >(),   Offset(emitterList,        SplashData), NUM_EMITTERS, "List of particle emitters to create at the point of this Splash effect.\n");
    addField("delayMS",           TypeS32,                      Offset(delayMS,            SplashData), "Time to delay, in milliseconds, before actually starting this effect.\n");
@@ -158,6 +163,8 @@ void SplashData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
+   PACKDATA_ASSET(Sound);
+
    mathWrite(*stream, scale);
    stream->write(delayMS);
    stream->write(delayVariance);
@@ -201,7 +208,7 @@ void SplashData::packData(BitStream* stream)
 
    for( i=0; i<NUM_TEX; i++ )
    {
-      PACKDATA_IMAGEASSET_ARRAY(Texture, i);
+      PACKDATA_ASSET_ARRAY(Texture, i);
    }
 }
 
@@ -212,6 +219,8 @@ void SplashData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
+   UNPACKDATA_ASSET(Sound);
+
    mathRead(*stream, &scale);
    stream->read(&delayMS);
    stream->read(&delayVariance);
@@ -255,7 +264,7 @@ void SplashData::unpackData(BitStream* stream)
 
    for( i=0; i<NUM_TEX; i++ )
    {
-      UNPACKDATA_IMAGEASSET_ARRAY(Texture, i);
+      UNPACKDATA_ASSET_ARRAY(Texture, i);
    }
 }
 
@@ -269,6 +278,15 @@ bool SplashData::preload(bool server, String &errorStr)
 
    if (!server)
    {
+
+      if (getSound() != StringTable->EmptyString())
+      {
+         _setSound(getSound());
+
+         if(!getSoundProfile())
+            Con::errorf(ConsoleLogEntry::General, "SplashData::preload: Cant get an sfxProfile for splash.");
+      }
+
       S32 i;
       for( i=0; i<NUM_EMITTERS; i++ )
       {
@@ -667,6 +685,14 @@ void Splash::spawnExplosion()
 {
    if( !mDataBlock->explosion ) return;
 
+   /// could just play the explosion one, but explosion could be weapon specific,
+   /// splash sound could be liquid specific. food for thought.
+   SFXProfile* sound_prof = mDataBlock->getSoundProfile();
+   if (sound_prof)
+   {
+      SFX->playOnce(sound_prof, &getTransform());
+   }
+
    Explosion* pExplosion = new Explosion;
    pExplosion->onNewDataBlock(mDataBlock->explosion, false);
 

Engine/source/T3D/fx/splash.h

@@ -34,6 +34,7 @@
 #include "gfx/gfxTextureHandle.h"
 
 #include "T3D/assets/ImageAsset.h"
+#include "T3D/assets/SoundAsset.h"
 
 class ParticleEmitter;
 class ParticleEmitterData;
@@ -91,8 +92,11 @@ class SplashData : public GameBaseData
    };
 
 public:
-   AudioProfile*           soundProfile;
-   S32                     soundProfileId;
+   //AudioProfile*           soundProfile;
+   //S32                     soundProfileId;
+
+   DECLARE_SOUNDASSET(SplashData, Sound);
+   DECLARE_ASSET_SETGET(SplashData, Sound);
 
    ParticleEmitterData*    emitterList[NUM_EMITTERS];
    S32                     emitterIDList[NUM_EMITTERS];

Engine/source/T3D/groundPlane.cpp

@@ -87,7 +87,7 @@ GroundPlane::GroundPlane()
    mConvexList = new Convex;
    mTypeMask |= TerrainLikeObjectType;
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
 }
 
 GroundPlane::~GroundPlane()
@@ -199,7 +199,7 @@ U32 GroundPlane::packUpdate( NetConnection* connection, U32 mask, BitStream* str
    stream->write( mScaleU );
    stream->write( mScaleV );
 
-   PACK_MATERIALASSET(connection, Material);
+   PACK_ASSET(connection, Material);
 
    return retMask;
 }
@@ -212,7 +212,7 @@ void GroundPlane::unpackUpdate( NetConnection* connection, BitStream* stream )
    stream->read( &mScaleU );
    stream->read( &mScaleV );
 
-   UNPACK_MATERIALASSET(connection, Material);
+   UNPACK_ASSET(connection, Material);
 
    // If we're added then something possibly changed in 
    // the editor... do an update of the material and the

Engine/source/T3D/groundPlane.h

@@ -108,7 +108,7 @@ private:
    BaseMatInstance* mMaterialInst;
 
    DECLARE_MATERIALASSET(GroundPlane, Material);
-   DECLARE_MATERIALASSET_NET_SETGET(GroundPlane, Material, -1);
+   DECLARE_ASSET_NET_SETGET(GroundPlane, Material, -1);
 
    PhysicsBody *mPhysicsRep;
 

Engine/source/T3D/levelInfo.cpp

@@ -99,7 +99,7 @@ LevelInfo::LevelInfo()
 
    mAdvancedLightmapSupport = true;
 
-   INIT_IMAGEASSET(AccuTexture);
+   INIT_ASSET(AccuTexture);
 
    // Register with the light manager activation signal, and we need to do it first
    // so the advanced light bin manager can be instructed about MRT lightmaps
@@ -215,7 +215,7 @@ U32 LevelInfo::packUpdate(NetConnection *conn, U32 mask, BitStream *stream)
    sfxWrite( stream, mSoundAmbience );
    stream->writeInt( mSoundDistanceModel, 1 );
 
-   PACK_IMAGEASSET(conn, AccuTexture);
+   PACK_ASSET(conn, AccuTexture);
 
    return retMask;
 }
@@ -262,7 +262,7 @@ void LevelInfo::unpackUpdate(NetConnection *conn, BitStream *stream)
       SFX->setDistanceModel( mSoundDistanceModel );
    }
 
-   UNPACK_IMAGEASSET(conn, AccuTexture);
+   UNPACK_ASSET(conn, AccuTexture);
    setLevelAccuTexture(getAccuTexture());
 }
 

Engine/source/T3D/levelInfo.h

@@ -105,7 +105,7 @@ class LevelInfo : public NetObject
    protected:
 
       DECLARE_IMAGEASSET(LevelInfo, AccuTexture, onAccuTextureChanged, GFXStaticTextureSRGBProfile);
-      DECLARE_IMAGEASSET_SETGET(LevelInfo, AccuTexture);
+      DECLARE_ASSET_SETGET(LevelInfo, AccuTexture);
 
       void onAccuTextureChanged() {}
 

Engine/source/T3D/lightFlareData.cpp

@@ -133,7 +133,7 @@ LightFlareData::LightFlareData()
    for ( U32 i = 0; i < MAX_ELEMENTS; i++ )   
       mElementDist[i] = -1.0f;
 
-   INIT_IMAGEASSET(FlareTexture);
+   INIT_ASSET(FlareTexture);
 }
 
 LightFlareData::~LightFlareData()
@@ -219,7 +219,7 @@ void LightFlareData::packData( BitStream *stream )
 
    stream->writeFlag( mFlareEnabled );
 
-   PACKDATA_IMAGEASSET(FlareTexture);
+   PACKDATA_ASSET(FlareTexture);
 
    stream->write( mScale );
    stream->write( mOcclusionRadius );
@@ -244,7 +244,7 @@ void LightFlareData::unpackData( BitStream *stream )
 
    mFlareEnabled = stream->readFlag();
 
-   UNPACKDATA_IMAGEASSET(FlareTexture);
+   UNPACKDATA_ASSET(FlareTexture);
 
    stream->read( &mScale );
    stream->read( &mOcclusionRadius );

Engine/source/T3D/lightFlareData.h

@@ -121,7 +121,7 @@ protected:
    bool mFlareEnabled;
 
    DECLARE_IMAGEASSET(LightFlareData, FlareTexture, onImageChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(LightFlareData, FlareTexture);
+   DECLARE_ASSET_SETGET(LightFlareData, FlareTexture);
 
    F32 mOcclusionRadius;
    bool mRenderReflectPass;

Engine/source/T3D/physics/physicsDebris.cpp

@@ -74,7 +74,7 @@ PhysicsDebrisData::PhysicsDebrisData()
    lifetime = 5.0f;
    lifetimeVariance = 0.0f;
 
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 }
 
 bool PhysicsDebrisData::onAdd()
@@ -215,7 +215,7 @@ void PhysicsDebrisData::packData(BitStream* stream)
    stream->write( waterDampingScale );
    stream->write( buoyancyDensity );
 
-   PACKDATA_SHAPEASSET(Shape);
+   PACKDATA_ASSET(Shape);
 }
 
 void PhysicsDebrisData::unpackData(BitStream* stream)
@@ -236,7 +236,7 @@ void PhysicsDebrisData::unpackData(BitStream* stream)
    stream->read( &waterDampingScale );
    stream->read( &buoyancyDensity );
 
-   UNPACKDATA_SHAPEASSET(Shape);
+   UNPACKDATA_ASSET(Shape);
 }
 
 DefineEngineMethod( PhysicsDebrisData, preload, void, (), , 

Engine/source/T3D/physics/physicsDebris.h

@@ -87,7 +87,7 @@ public:
    bool castShadows;
 
    DECLARE_SHAPEASSET(PhysicsDebrisData, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(PhysicsDebrisData, Shape);
+   DECLARE_ASSET_SETGET(PhysicsDebrisData, Shape);
 
    PhysicsDebrisData();
 

Engine/source/T3D/physics/physicsShape.cpp

@@ -78,7 +78,7 @@ PhysicsShapeData::PhysicsShapeData()
       buoyancyDensity( 0.0f ),
       simType( SimType_ClientServer )      
 {
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 }
 
 PhysicsShapeData::~PhysicsShapeData()
@@ -180,7 +180,7 @@ void PhysicsShapeData::packData( BitStream *stream )
 { 
    Parent::packData( stream );
 
-   PACKDATA_SHAPEASSET(Shape);
+   PACKDATA_ASSET(Shape);
 
    stream->write( mass );
    stream->write( dynamicFriction );
@@ -204,7 +204,7 @@ void PhysicsShapeData::unpackData( BitStream *stream )
 {
    Parent::unpackData(stream);
 
-   UNPACKDATA_SHAPEASSET(Shape);
+   UNPACKDATA_ASSET(Shape);
 
    stream->read( &mass );
    stream->read( &dynamicFriction );

Engine/source/T3D/physics/physicsShape.h

@@ -75,7 +75,7 @@ public:
 public:
 
    DECLARE_SHAPEASSET(PhysicsShapeData, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(PhysicsShapeData, Shape);
+   DECLARE_ASSET_SETGET(PhysicsShapeData, Shape);
 
    /// The shared unscaled collision shape.
    PhysicsCollisionRef colShape;

Engine/source/T3D/player.cpp

@@ -187,6 +187,32 @@ PlayerData::ActionAnimationDef PlayerData::ActionAnimationList[NumTableActionAni
 
 
 //----------------------------------------------------------------------------
+
+typedef PlayerData::Sounds playerSoundsEnum;
+DefineEnumType(playerSoundsEnum);
+
+ImplementEnumType(playerSoundsEnum, "enum types.\n"
+   "@ingroup PlayerData\n\n")
+   { playerSoundsEnum::FootSoft,            "FootSoft", "..." },
+   { playerSoundsEnum::FootHard,            "FootHard","..." },
+   { playerSoundsEnum::FootMetal,           "FootMetal","..." },
+   { playerSoundsEnum::FootSnow,            "FootSnow","..." },
+   { playerSoundsEnum::FootShallowSplash,   "FootShallowSplash","..." },
+   { playerSoundsEnum::FootWading,          "FootWading","..." },
+   { playerSoundsEnum::FootUnderWater,      "FootUnderWater","..." },
+   { playerSoundsEnum::FootBubbles,         "FootBubbles","..." },
+   { playerSoundsEnum::MoveBubbles,         "MoveBubbles","..." },
+   { playerSoundsEnum::WaterBreath,         "WaterBreath","..." },
+   { playerSoundsEnum::ImpactSoft,          "ImpactSoft","..." },
+   { playerSoundsEnum::ImpactHard,          "ImpactHard","..." },
+   { playerSoundsEnum::ImpactMetal,         "ImpactMetal","..." },
+   { playerSoundsEnum::ImpactSnow,          "ImpactSnow","..." },
+   { playerSoundsEnum::ImpactWaterEasy,     "ImpactWaterEasy","..." },
+   { playerSoundsEnum::ImpactWaterMedium,   "ImpactWaterMedium","..." },
+   { playerSoundsEnum::ImpactWaterHard,     "ImpactWaterHard","..." },
+   { playerSoundsEnum::ExitWater,           "ExitWater","..." },
+EndImplementEnumType;
+
 //----------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
@@ -272,7 +298,7 @@ PlayerData::PlayerData()
    imageAnimPrefixFP = StringTable->EmptyString();
    for (U32 i=0; i<ShapeBase::MaxMountedImages; ++i)
    {
-      INIT_SHAPEASSET_ARRAY(ShapeFP, i);
+      INIT_ASSET_ARRAY(ShapeFP, i);
       mCRCFP[i] = 0;
       mValidShapeFP[i] = false;
    }
@@ -397,7 +423,7 @@ PlayerData::PlayerData()
    boxHeadFrontPercentage = 1;
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sound[i] = NULL;
+      INIT_ASSET_ARRAY(PlayerSound, i);
 
    footPuffEmitter = NULL;
    footPuffID = 0;
@@ -444,14 +470,16 @@ bool PlayerData::preload(bool server, String &errorStr)
    if(!Parent::preload(server, errorStr))
       return false;
 
-   // Resolve objects transmitted from server
-   if( !server )
+   for (U32 i = 0; i < MaxSounds; ++i)
    {
-      for( U32 i = 0; i < MaxSounds; ++ i )
+      _setPlayerSound(getPlayerSound(i), i);
+      if (getPlayerSound(i) != StringTable->EmptyString())
       {
-         String sfxErrorStr;
-         if( !sfxResolve( &sound[ i ], sfxErrorStr ) )
-            Con::errorf( "PlayerData::preload: %s", sfxErrorStr.c_str() );
+         if (!getPlayerSoundProfile(i))
+            Con::errorf("PlayerData::Preload() - unable to find sfxProfile for asset %d %s", i, mPlayerSoundAssetId[i]);
+
+         const char* enumString = castConsoleTypeToString(static_cast<Sounds>(i));
+            Con::printf("preload: %s = %s", enumString, mPlayerSoundAssetId[i]);
       }
    }
 
@@ -1021,65 +1049,7 @@ void PlayerData::initPersistFields()
    endGroup( "Interaction: Footsteps" );
 
    addGroup( "Interaction: Sounds" );
-
-      addField( "FootSoftSound", TypeSFXTrackName, Offset(sound[FootSoft], PlayerData),
-         "@brief Sound to play when walking on a surface with Material footstepSoundId 0.\n\n" );
-      addField( "FootHardSound", TypeSFXTrackName, Offset(sound[FootHard], PlayerData),
-         "@brief Sound to play when walking on a surface with Material footstepSoundId 1.\n\n" );
-      addField( "FootMetalSound", TypeSFXTrackName, Offset(sound[FootMetal], PlayerData),
-         "@brief Sound to play when walking on a surface with Material footstepSoundId 2.\n\n" );
-      addField( "FootSnowSound", TypeSFXTrackName, Offset(sound[FootSnow], PlayerData),
-         "@brief Sound to play when walking on a surface with Material footstepSoundId 3.\n\n" );
-
-      addField( "FootShallowSound", TypeSFXTrackName, Offset(sound[FootShallowSplash], PlayerData),
-         "@brief Sound to play when walking in water and coverage is less than "
-         "footSplashHeight.\n\n"
-         "@see footSplashHeight\n" );
-      addField( "FootWadingSound", TypeSFXTrackName, Offset(sound[FootWading], PlayerData),
-         "@brief Sound to play when walking in water and coverage is less than 1, "
-         "but > footSplashHeight.\n\n"
-         "@see footSplashHeight\n" );
-      addField( "FootUnderwaterSound", TypeSFXTrackName, Offset(sound[FootUnderWater], PlayerData),
-         "@brief Sound to play when walking in water and coverage equals 1.0 "
-         "(fully underwater).\n\n" );
-      addField( "FootBubblesSound", TypeSFXTrackName, Offset(sound[FootBubbles], PlayerData),
-         "@brief Sound to play when walking in water and coverage equals 1.0 "
-         "(fully underwater).\n\n" );
-      addField( "movingBubblesSound", TypeSFXTrackName, Offset(sound[MoveBubbles], PlayerData),
-         "@brief Sound to play when in water and coverage equals 1.0 (fully underwater).\n\n"
-         "Note that unlike FootUnderwaterSound, this sound plays even if the "
-         "player is not moving around in the water.\n" );
-      addField( "waterBreathSound", TypeSFXTrackName, Offset(sound[WaterBreath], PlayerData),
-         "@brief Sound to play when in water and coverage equals 1.0 (fully underwater).\n\n"
-         "Note that unlike FootUnderwaterSound, this sound plays even if the "
-         "player is not moving around in the water.\n" );
-
-      addField( "impactSoftSound", TypeSFXTrackName, Offset(sound[ImpactSoft], PlayerData),
-         "@brief Sound to play after falling on a surface with Material footstepSoundId 0.\n\n" );
-      addField( "impactHardSound", TypeSFXTrackName, Offset(sound[ImpactHard], PlayerData),
-         "@brief Sound to play after falling on a surface with Material footstepSoundId 1.\n\n" );
-      addField( "impactMetalSound", TypeSFXTrackName, Offset(sound[ImpactMetal], PlayerData),
-         "@brief Sound to play after falling on a surface with Material footstepSoundId 2.\n\n" );
-      addField( "impactSnowSound", TypeSFXTrackName, Offset(sound[ImpactSnow], PlayerData),
-         "@brief Sound to play after falling on a surface with Material footstepSoundId 3.\n\n" );
-
-      addField( "impactWaterEasy", TypeSFXTrackName, Offset(sound[ImpactWaterEasy], PlayerData),
-         "@brief Sound to play when entering the water with velocity < "
-         "mediumSplashSoundVelocity.\n\n"
-         "@see mediumSplashSoundVelocity\n");
-      addField( "impactWaterMedium", TypeSFXTrackName, Offset(sound[ImpactWaterMedium], PlayerData),
-         "@brief Sound to play when entering the water with velocity >= "
-         "mediumSplashSoundVelocity and < hardSplashSoundVelocity.\n\n"
-         "@see mediumSplashSoundVelocity\n"
-         "@see hardSplashSoundVelocity\n");
-      addField( "impactWaterHard", TypeSFXTrackName, Offset(sound[ImpactWaterHard], PlayerData),
-         "@brief Sound to play when entering the water with velocity >= "
-         "hardSplashSoundVelocity.\n\n"
-         "@see hardSplashSoundVelocity\n");
-      addField( "exitingWater", TypeSFXTrackName, Offset(sound[ExitWater], PlayerData),
-         "@brief Sound to play when exiting the water with velocity >= exitSplashSoundVelocity.\n\n"
-         "@see exitSplashSoundVelocity\n");
-
+   INITPERSISTFIELD_SOUNDASSET_ENUMED(PlayerSound, playerSoundsEnum, PlayerData::Sounds::MaxSounds, PlayerData, "Sounds related to player interaction.");
    endGroup( "Interaction: Sounds" );
 
    addGroup( "Interaction: Splashes" );
@@ -1303,8 +1273,8 @@ void PlayerData::packData(BitStream* stream)
    stream->write(minImpactSpeed);
    stream->write(minLateralImpactSpeed);
 
-   for( U32 i = 0; i < MaxSounds; i++)
-      sfxWrite( stream, sound[ i ] );
+   for (U32 i = 0; i < MaxSounds; i++)
+      PACKDATA_ASSET_ARRAY(PlayerSound, i);
 
    mathWrite(*stream, boxSize);
    mathWrite(*stream, crouchBoxSize);
@@ -1372,7 +1342,7 @@ void PlayerData::packData(BitStream* stream)
    stream->writeString(imageAnimPrefixFP);
    for (U32 i=0; i<ShapeBase::MaxMountedImages; ++i)
    {
-      PACKDATA_SHAPEASSET_ARRAY(ShapeFP, i);
+      PACKDATA_ASSET_ARRAY(ShapeFP, i);
 
       // computeCRC is handled in ShapeBaseData
       if (computeCRC)
@@ -1484,8 +1454,8 @@ void PlayerData::unpackData(BitStream* stream)
    stream->read(&minImpactSpeed);
    stream->read(&minLateralImpactSpeed);
 
-   for( U32 i = 0; i < MaxSounds; i++)
-      sfxRead( stream, &sound[ i ] );
+   for (U32 i = 0; i < MaxSounds; i++)
+      UNPACKDATA_ASSET_ARRAY(PlayerSound, i);
 
    mathRead(*stream, &boxSize);
    mathRead(*stream, &crouchBoxSize);
@@ -1552,7 +1522,7 @@ void PlayerData::unpackData(BitStream* stream)
    imageAnimPrefixFP = stream->readSTString();
    for (U32 i=0; i<ShapeBase::MaxMountedImages; ++i)
    {
-      UNPACKDATA_SHAPEASSET_ARRAY(ShapeFP, i);
+      UNPACKDATA_ASSET_ARRAY(ShapeFP, i);
 
       // computeCRC is handled in ShapeBaseData
       if (computeCRC)
@@ -1932,11 +1902,11 @@ bool Player::onNewDataBlock( GameBaseData *dptr, bool reload )
       SFX_DELETE( mMoveBubbleSound );
       SFX_DELETE( mWaterBreathSound );
 
-      if ( mDataBlock->sound[PlayerData::MoveBubbles] )
-         mMoveBubbleSound = SFX->createSource( mDataBlock->sound[PlayerData::MoveBubbles] );
+      if ( mDataBlock->getPlayerSound(PlayerData::MoveBubbles) )
+         mMoveBubbleSound = SFX->createSource( mDataBlock->getPlayerSoundProfile(PlayerData::MoveBubbles) );
 
-      if ( mDataBlock->sound[PlayerData::WaterBreath] )
-         mWaterBreathSound = SFX->createSource( mDataBlock->sound[PlayerData::WaterBreath] );
+      if ( mDataBlock->getPlayerSound(PlayerData::WaterBreath) )
+         mWaterBreathSound = SFX->createSource( mDataBlock->getPlayerSoundProfile(PlayerData::WaterBreath) );
    }
 
    mObjBox.maxExtents.x = mDataBlock->boxSize.x * 0.5f;
@@ -3300,7 +3270,7 @@ void Player::updateMove(const Move* move)
       {
          // exit-water splash sound happens for client only
          if ( getSpeed() >= mDataBlock->exitSplashSoundVel && !isMounted() )         
-            SFX->playOnce( mDataBlock->sound[PlayerData::ExitWater], &getTransform() );                     
+            SFX->playOnce( mDataBlock->getPlayerSoundProfile(PlayerData::ExitWater), &getTransform() );                     
       }
    }
 
@@ -7060,17 +7030,17 @@ void Player::playFootstepSound( bool triggeredLeft, Material* contactMaterial, S
       // Treading water.
 
       if ( mWaterCoverage < mDataBlock->footSplashHeight )
-         SFX->playOnce( mDataBlock->sound[ PlayerData::FootShallowSplash ], &footMat );
+         SFX->playOnce( mDataBlock->getPlayerSoundProfile( PlayerData::FootShallowSplash ), &footMat );
       else
       {
          if ( mWaterCoverage < 1.0 )
-            SFX->playOnce( mDataBlock->sound[ PlayerData::FootWading ], &footMat );
+            SFX->playOnce( mDataBlock->getPlayerSoundProfile( PlayerData::FootWading ), &footMat );
          else
          {
             if ( triggeredLeft )
             {
-               SFX->playOnce( mDataBlock->sound[ PlayerData::FootUnderWater ], &footMat );
-               SFX->playOnce( mDataBlock->sound[ PlayerData::FootBubbles ], &footMat );
+               SFX->playOnce( mDataBlock->getPlayerSoundProfile( PlayerData::FootUnderWater ), &footMat );
+               SFX->playOnce( mDataBlock->getPlayerSoundProfile( PlayerData::FootBubbles ), &footMat );
             }
          }
       }
@@ -7086,13 +7056,13 @@ void Player::playFootstepSound( bool triggeredLeft, Material* contactMaterial, S
       // Play default sound.
 
       S32 sound = -1;
-      if (contactMaterial && (contactMaterial->mFootstepSoundId>-1 && contactMaterial->mFootstepSoundId<PlayerData::MaxSoundOffsets))
+      if (contactMaterial && (contactMaterial->mFootstepSoundId > -1 && contactMaterial->mFootstepSoundId < PlayerData::WaterStart))
          sound = contactMaterial->mFootstepSoundId;
       else if( contactObject && contactObject->getTypeMask() & VehicleObjectType )
          sound = 2;
 
       if (sound>=0)
-         SFX->playOnce(mDataBlock->sound[sound], &footMat);
+         SFX->playOnce(mDataBlock->getPlayerSoundProfile(sound), &footMat);
    }
 }
 
@@ -7117,13 +7087,13 @@ void Player:: playImpactSound()
          else
          {
             S32 sound = -1;
-            if (material && (material->mImpactSoundId>-1 && material->mImpactSoundId<PlayerData::MaxSoundOffsets))
+            if (material && (material->mImpactSoundId > -1 && material->mImpactSoundId < PlayerData::WaterStart))
                sound = material->mImpactSoundId;
             else if( rInfo.object->getTypeMask() & VehicleObjectType )
                sound = 2; // Play metal;
 
             if (sound >= 0)
-               SFX->playOnce(mDataBlock->sound[PlayerData::ImpactStart + sound], &getTransform());
+               SFX->playOnce(mDataBlock->getPlayerSoundProfile(PlayerData::ImpactSoft + sound), &getTransform());
          }
       }
    }
@@ -7277,11 +7247,11 @@ bool Player::collidingWithWater( Point3F &waterHeight )
 void Player::createSplash( Point3F &pos, F32 speed )
 {
    if ( speed >= mDataBlock->hardSplashSoundVel )
-      SFX->playOnce( mDataBlock->sound[PlayerData::ImpactWaterHard], &getTransform() );
+      SFX->playOnce( mDataBlock->getPlayerSoundProfile(PlayerData::ImpactWaterHard), &getTransform() );
    else if ( speed >= mDataBlock->medSplashSoundVel )
-      SFX->playOnce( mDataBlock->sound[PlayerData::ImpactWaterMedium], &getTransform() );
+      SFX->playOnce( mDataBlock->getPlayerSoundProfile(PlayerData::ImpactWaterMedium), &getTransform() );
    else
-      SFX->playOnce( mDataBlock->sound[PlayerData::ImpactWaterEasy], &getTransform() );
+      SFX->playOnce( mDataBlock->getPlayerSoundProfile(PlayerData::ImpactWaterEasy), &getTransform() );
 
    if( mDataBlock->splash )
    {

Engine/source/T3D/player.h

@@ -35,6 +35,7 @@
 #include "collision/boxConvex.h"
 #endif
 
+#include "T3D/assets/SoundAsset.h"
 #include "T3D/gameBase/gameProcess.h"
 
 class Material;
@@ -76,7 +77,7 @@ struct PlayerData: public ShapeBaseData {
                                                                   ///  need to.
 
    DECLARE_SHAPEASSET_ARRAY(PlayerData, ShapeFP, ShapeBase::MaxMountedImages); ///< Used to render with mounted images in first person [optional]
-   DECLARE_SHAPEASSET_ARRAY_SETGET(PlayerData, ShapeFP);
+   DECLARE_ASSET_ARRAY_SETGET(PlayerData, ShapeFP);
 
    StringTableEntry  imageAnimPrefixFP;                           ///< Passed along to mounted images to modify
                                                                   ///  animation sequences played in first person. [optional]
@@ -200,7 +201,7 @@ struct PlayerData: public ShapeBaseData {
       FootHard,
       FootMetal,
       FootSnow,
-      MaxSoundOffsets,
+      WaterStart,
       FootShallowSplash,
       FootWading,
       FootUnderWater,
@@ -208,7 +209,7 @@ struct PlayerData: public ShapeBaseData {
       MoveBubbles,
       WaterBreath,
       ImpactStart,
-      ImpactSoft = ImpactStart,
+      ImpactSoft,
       ImpactHard,
       ImpactMetal,
       ImpactSnow,
@@ -218,7 +219,8 @@ struct PlayerData: public ShapeBaseData {
       ExitWater,
       MaxSounds
    };
-   SFXTrack* sound[MaxSounds];
+
+   DECLARE_SOUNDASSET_ARRAY(PlayerData, PlayerSound, Sounds::MaxSounds);
 
    Point3F boxSize;           ///< Width, depth, height
    Point3F crouchBoxSize;
@@ -877,5 +879,4 @@ public:
 typedef Player::Pose PlayerPose;
 
 DefineEnumType( PlayerPose );
-
 #endif

Engine/source/T3D/projectile.cpp

@@ -144,9 +144,9 @@ U32 Projectile::smProjectileWarpTicks = 5;
 //
 ProjectileData::ProjectileData()
 {
-   INIT_SHAPEASSET(ProjectileShape);
+   INIT_ASSET(ProjectileShape);
 
-   sound = NULL;
+   INIT_ASSET(ProjectileSound);
 
    explosion = NULL;
    explosionId = 0;
@@ -217,10 +217,10 @@ ProjectileData::ProjectileData(const ProjectileData& other, bool temp_clone) : G
    splashId = other.splashId; // -- for pack/unpack of splash ptr
    decal = other.decal;
    decalId = other.decalId; // -- for pack/unpack of decal ptr
-   sound = other.sound;
+   CLONE_ASSET(ProjectileSound);
    lightDesc = other.lightDesc;
    lightDescId = other.lightDescId; // -- for pack/unpack of lightDesc ptr
-   CLONE_SHAPEASSET(ProjectileShape);// -- TSShape loads using mProjectileShapeName
+   CLONE_ASSET(ProjectileShape);// -- TSShape loads using mProjectileShapeName
    activateSeq = other.activateSeq; // -- from projectileShape sequence "activate"
    maintainSeq = other.maintainSeq; // -- from projectileShape sequence "maintain"
    particleEmitter = other.particleEmitter;
@@ -252,8 +252,7 @@ void ProjectileData::initPersistFields()
       "@brief Scale to apply to the projectile's size.\n\n"
       "@note This is applied after SceneObject::scale\n");
 
-   addField("sound", TypeSFXTrackName, Offset(sound, ProjectileData),
-      "@brief SFXTrack datablock used to play sounds while in flight.\n\n");
+   INITPERSISTFIELD_SOUNDASSET(ProjectileSound, ProjectileData, "The sound for the projectile.");
 
    addField("explosion", TYPEID< ExplosionData >(), Offset(explosion, ProjectileData),
       "@brief Explosion datablock used when the projectile explodes outside of water.\n\n");
@@ -368,9 +367,13 @@ bool ProjectileData::preload(bool server, String &errorStr)
          if (Sim::findObject(decalId, decal) == false)
             Con::errorf(ConsoleLogEntry::General, "ProjectileData::preload: Invalid packet, bad datablockId(decal): %d", decalId);
 
-      String sfxErrorStr;
-      if( !sfxResolve( &sound, sfxErrorStr ) )
-         Con::errorf(ConsoleLogEntry::General, "ProjectileData::preload: Invalid packet: %s", sfxErrorStr.c_str());
+      if (getProjectileSound() != StringTable->EmptyString())
+      {
+         _setProjectileSound(getProjectileSound());
+
+         if (!getProjectileSoundProfile())
+            Con::errorf(ConsoleLogEntry::General, "SplashData::preload: Cant get an sfxProfile for splash.");
+      }
 
       if (!lightDesc && lightDescId != 0)
          if (Sim::findObject(lightDescId, lightDesc) == false)
@@ -403,7 +406,7 @@ void ProjectileData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   PACKDATA_SHAPEASSET(ProjectileShape);
+   PACKDATA_ASSET(ProjectileShape);
 
    stream->writeFlag(faceViewer);
    if(stream->writeFlag(scale.x != 1 || scale.y != 1 || scale.z != 1))
@@ -436,8 +439,7 @@ void ProjectileData::packData(BitStream* stream)
    if (stream->writeFlag(decal != NULL))
       stream->writeRangedU32(decal->getId(), DataBlockObjectIdFirst,
                                               DataBlockObjectIdLast);
-
-   sfxWrite( stream, sound );
+   PACKDATA_ASSET(ProjectileSound);
 
    if ( stream->writeFlag(lightDesc != NULL))
       stream->writeRangedU32(lightDesc->getId(), DataBlockObjectIdFirst,
@@ -468,7 +470,7 @@ void ProjectileData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   UNPACKDATA_SHAPEASSET(ProjectileShape);
+   UNPACKDATA_ASSET(ProjectileShape);
 
    faceViewer = stream->readFlag();
    if(stream->readFlag())
@@ -497,8 +499,8 @@ void ProjectileData::unpackData(BitStream* stream)
 
    if (stream->readFlag())
       decalId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
-   
-   sfxRead( stream, &sound );
+
+   UNPACKDATA_ASSET(ProjectileSound);
 
    if (stream->readFlag())
       lightDescId = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
@@ -884,8 +886,8 @@ bool Projectile::onNewDataBlock( GameBaseData *dptr, bool reload )
 
       SFX_DELETE( mSound );
 
-      if ( mDataBlock->sound )
-         mSound = SFX->createSource( mDataBlock->sound );
+      if ( mDataBlock->getProjectileSound() )
+         mSound = SFX->createSource( mDataBlock->getProjectileSoundProfile() );
    }
 
    return true;
@@ -1099,7 +1101,7 @@ void Projectile::explode( const Point3F &p, const Point3F &n, const U32 collideT
 
 void Projectile::updateSound()
 {
-   if (!mDataBlock->sound)
+   if (!mDataBlock->getProjectileSound())
       return;
 
    if ( mSound )

Engine/source/T3D/projectile.h

@@ -44,6 +44,7 @@
 #include "lighting/lightInfo.h"
 #endif
 
+#include "T3D/assets/SoundAsset.h"
 #include "T3D/assets/ShapeAsset.h"
 
 class ExplosionData;
@@ -71,7 +72,7 @@ protected:
 
 public:
    DECLARE_SHAPEASSET(ProjectileData, ProjectileShape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(ProjectileData, ProjectileShape);
+   DECLARE_ASSET_SETGET(ProjectileData, ProjectileShape);
 
    /// Set to true if it is a billboard and want it to always face the viewer, false otherwise
    bool faceViewer;
@@ -115,7 +116,8 @@ public:
    DecalData *decal;                   // (impact) Decal Datablock
    S32 decalId;                        // (impact) Decal ID
 
-   SFXTrack* sound;                    // Projectile Sound
+   DECLARE_SOUNDASSET(ProjectileData, ProjectileSound);
+   DECLARE_ASSET_SETGET(ProjectileData, ProjectileSound);
    
    LightDescription *lightDesc;
    S32 lightDescId;   

Engine/source/T3D/proximityMine.cpp

@@ -74,16 +74,16 @@ IMPLEMENT_CALLBACK( ProximityMineData, onExplode, void, ( ProximityMine* obj, Po
 ProximityMineData::ProximityMineData()
  : armingDelay( 0 ),
    armingSequence( -1 ),
-   armingSound( NULL ),
    triggerRadius( 5.0f ),
    triggerSpeed( 1.0f ),
    autoTriggerDelay( 0 ),
    triggerOnOwner( false ),
    triggerDelay( 0 ),
    triggerSequence( -1 ),
-   triggerSound( NULL ),
    explosionOffset( 0.05f )
 {
+   INIT_ASSET(ArmSound);
+   INIT_ASSET(TriggerSound);
 }
 
 void ProximityMineData::initPersistFields()
@@ -91,9 +91,9 @@ void ProximityMineData::initPersistFields()
    addGroup( "Arming" );
    addField( "armingDelay", TypeF32, Offset(armingDelay, ProximityMineData), 
       "Delay (in seconds) from when the mine is placed to when it becomes active." );
-   addField( "armingSound", TypeSFXTrackName, Offset(armingSound, ProximityMineData),
-      "Sound to play when the mine is armed (starts at the same time as "
-      "the <i>armed</i> sequence if defined)." );
+
+   INITPERSISTFIELD_SOUNDASSET(ArmSound, ProximityMineData, "Arming sound for this proximity mine.");
+
    endGroup( "Arming" );
 
    addGroup( "Triggering" );
@@ -111,9 +111,9 @@ void ProximityMineData::initPersistFields()
       "Speed above which moving objects within the trigger radius will trigger the mine" );
    addField( "triggerDelay", TypeF32, Offset(triggerDelay, ProximityMineData),
       "Delay (in seconds) from when the mine is triggered until it explodes." );
-   addField( "triggerSound", TypeSFXTrackName, Offset(triggerSound, ProximityMineData),
-      "Sound to play when the mine is triggered (starts at the same time as "
-      "the <i>triggered</i> sequence if defined)." );
+
+   INITPERSISTFIELD_SOUNDASSET(TriggerSound, ProximityMineData, "Arming sound for this proximity mine.");
+
    endGroup( "Triggering" );
 
    addGroup( "Explosion" );
@@ -135,12 +135,10 @@ bool ProximityMineData::preload( bool server, String& errorStr )
 
    if ( !server )
    {
-      // Resolve sounds
-      String sfxErrorStr;
-      if( !sfxResolve( &armingSound, sfxErrorStr ) )
-         Con::errorf( ConsoleLogEntry::General, "ProximityMineData::preload: Invalid packet: %s", sfxErrorStr.c_str() );
-      if( !sfxResolve( &triggerSound, sfxErrorStr ) )
-         Con::errorf( ConsoleLogEntry::General, "ProximityMineData::preload: Invalid packet: %s", sfxErrorStr.c_str() );
+      if( !getArmSound() )
+         Con::errorf( ConsoleLogEntry::General, "ProximityMineData::preload: Invalid arming sound." );
+      if( !getTriggerSound() )
+         Con::errorf( ConsoleLogEntry::General, "ProximityMineData::preload: Invalid trigger sound." );
    }
 
    if ( mShape )
@@ -158,14 +156,14 @@ void ProximityMineData::packData( BitStream* stream )
    Parent::packData( stream );
 
    stream->write( armingDelay );
-   sfxWrite( stream, armingSound );
+   PACKDATA_ASSET(ArmSound);
 
    stream->write( autoTriggerDelay );
    stream->writeFlag( triggerOnOwner );
    stream->write( triggerRadius );
    stream->write( triggerSpeed );
    stream->write( triggerDelay );
-   sfxWrite( stream, triggerSound );
+   PACKDATA_ASSET(TriggerSound);
 }
 
 void ProximityMineData::unpackData( BitStream* stream )
@@ -173,14 +171,14 @@ void ProximityMineData::unpackData( BitStream* stream )
    Parent::unpackData(stream);
 
    stream->read( &armingDelay );
-   sfxRead( stream, &armingSound );
+   UNPACKDATA_ASSET(ArmSound);
 
    stream->read( &autoTriggerDelay );
    triggerOnOwner = stream->readFlag();
    stream->read( &triggerRadius );
    stream->read( &triggerSpeed );
    stream->read( &triggerDelay );
-   sfxRead( stream, &triggerSound );
+   UNPACKDATA_ASSET(TriggerSound);
 }
 
 //----------------------------------------------------------------------------
@@ -428,8 +426,8 @@ void ProximityMine::processTick( const Move* move )
                   mAnimThread = mShapeInstance->addThread();
                   mShapeInstance->setSequence( mAnimThread, mDataBlock->armingSequence, 0.0f );
                }
-               if ( mDataBlock->armingSound )
-                  SFX->playOnce( mDataBlock->armingSound, &getRenderTransform() );
+               if ( mDataBlock->getArmSound() )
+                  SFX->playOnce( mDataBlock->getArmSoundAsset()->getSfxProfile(), &getRenderTransform() );
             }
             break;
 
@@ -469,8 +467,8 @@ void ProximityMine::processTick( const Move* move )
                   mAnimThread = mShapeInstance->addThread();
                   mShapeInstance->setSequence( mAnimThread, mDataBlock->triggerSequence, 0.0f );
                }
-               if ( mDataBlock->triggerSound )
-                  SFX->playOnce( mDataBlock->triggerSound, &getRenderTransform() );
+               if ( mDataBlock->getTriggerSound() )
+                  SFX->playOnce( mDataBlock->getTriggerSoundAsset()->getSfxProfile(), &getRenderTransform() );
 
                if ( isServerObject() )
                   mDataBlock->onTriggered_callback( this, sql.mList[0] );

Engine/source/T3D/proximityMine.h

@@ -27,6 +27,8 @@
    #include "T3D/item.h"
 #endif
 
+#include "T3D/assets/SoundAsset.h"
+
 class ExplosionData;
 class SFXTrack;
 class ProximityMine;
@@ -43,7 +45,8 @@ struct ProximityMineData: public ItemData
 public:
    F32               armingDelay;
    S32               armingSequence;
-   SFXTrack*         armingSound;
+   DECLARE_SOUNDASSET(ProximityMineData, ArmSound);
+   DECLARE_ASSET_SETGET(ProximityMineData, ArmSound);
 
    F32               autoTriggerDelay;
    bool              triggerOnOwner;
@@ -51,7 +54,8 @@ public:
    F32               triggerSpeed;
    F32               triggerDelay;
    S32               triggerSequence;
-   SFXTrack*         triggerSound;
+   DECLARE_SOUNDASSET(ProximityMineData, TriggerSound);
+   DECLARE_ASSET_SETGET(ProximityMineData, TriggerSound);
 
    F32               explosionOffset;
 

Engine/source/T3D/rigidShape.cpp

@@ -238,7 +238,7 @@ RigidShapeData::RigidShapeData()
    density = 4;
 
    for (S32 i = 0; i < Body::MaxSounds; i++)
-      body.sound[i] = 0;
+      INIT_ASSET_ARRAY(BodySounds, i);
 
    dustEmitter = NULL;
    dustID = 0;
@@ -256,7 +256,8 @@ RigidShapeData::RigidShapeData()
    hardSplashSoundVel = 3.0;
    enablePhysicsRep = true;
 
-   dMemset(waterSound, 0, sizeof(waterSound));
+   for (S32 i = 0; i < Sounds::MaxSounds; i++)
+      INIT_ASSET_ARRAY(WaterSounds, i);
 
    dragForce            = 0;
    vertFactor           = 0.25;
@@ -299,7 +300,21 @@ bool RigidShapeData::preload(bool server, String &errorStr)
    // Resolve objects transmitted from server
    if (!server) {
       for (S32 i = 0; i < Body::MaxSounds; i++)
-         sfxResolve( &body.sound[ i ], errorStr );
+      {
+         if (mBodySounds[i])
+         {
+            _setBodySounds(getBodySounds(i), i);
+         }
+      }
+
+      for (S32 j = 0; j < Sounds::MaxSounds; j++)
+      {
+         if (mWaterSounds[j])
+         {
+            _setWaterSounds(getWaterSounds(j), j);
+         }
+      }
+
    }
 
    if( !dustEmitter && dustID != 0 )
@@ -354,8 +369,10 @@ void RigidShapeData::packData(BitStream* stream)
 
    stream->write(body.restitution);
    stream->write(body.friction);
-   for( U32 i = 0; i < Body::MaxSounds; ++ i )
-      sfxWrite( stream, body.sound[ i ] );
+   for (U32 i = 0; i < Body::MaxSounds; ++i)
+   {
+      PACKDATA_ASSET_ARRAY(BodySounds, i);
+   }
 
    stream->write(minImpactSpeed);
    stream->write(softImpactSpeed);
@@ -384,8 +401,10 @@ void RigidShapeData::packData(BitStream* stream)
    stream->write(enablePhysicsRep);
 
    // write the water sound profiles
-   for( U32 i = 0; i < MaxSounds; ++ i )
-      sfxWrite( stream, waterSound[ i ] );
+   for (U32 i = 0; i < Sounds::MaxSounds; ++i)
+   {
+      PACKDATA_ASSET_ARRAY(WaterSounds, i);
+   }
 
    if (stream->writeFlag( dustEmitter ))
       stream->writeRangedU32( dustEmitter->getId(), DataBlockObjectIdFirst,  DataBlockObjectIdLast );
@@ -413,8 +432,10 @@ void RigidShapeData::unpackData(BitStream* stream)
    stream->read(&body.restitution);
    stream->read(&body.friction);
 
-   for( U32 i = 0; i < Body::MaxSounds; i++)
-      sfxRead( stream, &body.sound[ i ] );
+   for (U32 i = 0; i < Body::Sounds::MaxSounds; i++)
+   {
+      UNPACKDATA_ASSET_ARRAY(BodySounds, i);
+   }
 
    stream->read(&minImpactSpeed);
    stream->read(&softImpactSpeed);
@@ -443,8 +464,10 @@ void RigidShapeData::unpackData(BitStream* stream)
    stream->read(&enablePhysicsRep);
 
    // write the water sound profiles
-   for( U32 i = 0; i < MaxSounds; ++ i )
-      sfxRead( stream, &waterSound[ i ] );
+   for (U32 i = 0; i < Sounds::MaxSounds; ++i)
+   {
+      UNPACKDATA_ASSET_ARRAY(WaterSounds, i);
+   }
 
    if( stream->readFlag() )
       dustID = (S32) stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
@@ -516,21 +539,15 @@ void RigidShapeData::initPersistFields()
    
    addGroup( "Sounds" );
 
-      addField("softImpactSound", TypeSFXTrackName, Offset(body.sound[Body::SoftImpactSound], RigidShapeData),
-         "Sound to play when body impacts with at least softImageSpeed but less than hardImpactSpeed." );
-      addField("hardImpactSound", TypeSFXTrackName, Offset(body.sound[Body::HardImpactSound], RigidShapeData),
-         "Sound to play when body impacts with at least hardImpactSpeed." );
+      INITPERSISTFIELD_SOUNDASSET_ARRAY(BodySounds, Body::Sounds::MaxSounds, RigidShapeData, "Sounds for body.");
 
       addField("exitSplashSoundVelocity", TypeF32,       Offset(exitSplashSoundVel, RigidShapeData), "The minimum velocity at which the exit splash sound will be played when emerging from water.\n");
       addField("softSplashSoundVelocity", TypeF32,       Offset(softSplashSoundVel, RigidShapeData),"The minimum velocity at which the soft splash sound will be played when impacting water.\n");
       addField("mediumSplashSoundVelocity", TypeF32,     Offset(medSplashSoundVel, RigidShapeData), "The minimum velocity at which the medium splash sound will be played when impacting water.\n");
       addField("hardSplashSoundVelocity", TypeF32,       Offset(hardSplashSoundVel, RigidShapeData), "The minimum velocity at which the hard splash sound will be played when impacting water.\n");
-      addField("exitingWater",      TypeSFXTrackName,   Offset(waterSound[ExitWater],   RigidShapeData), "The AudioProfile will be used to produce sounds when emerging from water.\n");
-      addField("impactWaterEasy",   TypeSFXTrackName,   Offset(waterSound[ImpactSoft],   RigidShapeData), "The AudioProfile will be used to produce sounds when a soft impact with water occurs.\n");
-      addField("impactWaterMedium", TypeSFXTrackName,   Offset(waterSound[ImpactMedium],   RigidShapeData), "The AudioProfile will be used to produce sounds when a medium impact with water occurs.\n");
-      addField("impactWaterHard",   TypeSFXTrackName,   Offset(waterSound[ImpactHard],   RigidShapeData), "The AudioProfile will be used to produce sounds when a hard impact with water occurs.\n");
-      addField("waterWakeSound",    TypeSFXTrackName,   Offset(waterSound[Wake],   RigidShapeData), "The AudioProfile will be used to produce sounds when a water wake is displayed.\n");
       
+      INITPERSISTFIELD_SOUNDASSET_ARRAY(WaterSounds, Sounds::MaxSounds, RigidShapeData, "Sounds for interacting with water.");
+
    endGroup( "Sounds" );
    
    addGroup( "Camera" );
@@ -1155,27 +1172,27 @@ void RigidShape::updatePos(F32 dt)
             if (collSpeed >= mDataBlock->softImpactSpeed)
                impactSound = RigidShapeData::Body::SoftImpactSound;
 
-         if (impactSound != -1 && mDataBlock->body.sound[impactSound] != NULL)
-            SFX->playOnce(mDataBlock->body.sound[impactSound], &getTransform());
+         if (impactSound != -1 && mDataBlock->getBodySounds(impactSound) != NULL)
+            SFX->playOnce(mDataBlock->getBodySoundProfile(impactSound), &getTransform());
       }
 
       // Water volume sounds
       F32 vSpeed = getVelocity().len();
       if (!inLiquid && mWaterCoverage >= 0.8f) {
          if (vSpeed >= mDataBlock->hardSplashSoundVel)
-            SFX->playOnce(mDataBlock->waterSound[RigidShapeData::ImpactHard], &getTransform());
+            SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ImpactHard), &getTransform());
          else
             if (vSpeed >= mDataBlock->medSplashSoundVel)
-               SFX->playOnce(mDataBlock->waterSound[RigidShapeData::ImpactMedium], &getTransform());
+               SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ImpactMedium), &getTransform());
             else
                if (vSpeed >= mDataBlock->softSplashSoundVel)
-                  SFX->playOnce(mDataBlock->waterSound[RigidShapeData::ImpactSoft], &getTransform());
+                  SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ImpactSoft), &getTransform());
          inLiquid = true;
       }
       else
          if (inLiquid && mWaterCoverage < 0.8f) {
             if (vSpeed >= mDataBlock->exitSplashSoundVel)
-               SFX->playOnce(mDataBlock->waterSound[RigidShapeData::ExitWater], &getTransform());
+               SFX->playOnce(mDataBlock->getWaterSoundProfile(RigidShapeData::ExitWater), &getTransform());
             inLiquid = false;
          }
    }

Engine/source/T3D/rigidShape.h

@@ -35,6 +35,8 @@
 #include "T3D/physics/physicsBody.h"
 #endif
 
+#include "T3D/assets/SoundAsset.h"
+
 class ParticleEmitter;
 class ParticleEmitterData;
 class ClippedPolyList;
@@ -57,11 +59,21 @@ class RigidShapeData : public ShapeBaseData
          HardImpactSound,
          MaxSounds,
       };
-      SFXTrack* sound[MaxSounds];
       F32 restitution;
       F32 friction;
    } body;
 
+   DECLARE_SOUNDASSET_ARRAY(RigidShapeData, BodySounds, Body::Sounds::MaxSounds)
+   DECLARE_ASSET_ARRAY_SETGET(RigidShapeData, BodySounds);
+
+   SFXProfile* getBodySoundProfile(U32 id)
+   {
+      if (mBodySoundsAsset[id] != NULL)
+         return mBodySoundsAsset[id]->getSfxProfile();
+
+      return NULL;
+   }
+
    enum RigidShapeConsts
    {
       VC_NUM_DUST_EMITTERS = 1,
@@ -79,7 +91,16 @@ class RigidShapeData : public ShapeBaseData
       Wake,
       MaxSounds
    };
-   SFXTrack* waterSound[MaxSounds];
+   DECLARE_SOUNDASSET_ARRAY(RigidShapeData, WaterSounds, Sounds::MaxSounds)
+   DECLARE_ASSET_ARRAY_SETGET(RigidShapeData, WaterSounds);
+
+   SFXProfile* getWaterSoundProfile(U32 id)
+   {
+      if (mWaterSoundsAsset[id] != NULL)
+         return mWaterSoundsAsset[id]->getSfxProfile();
+
+      return NULL;
+   }
 
    F32 exitSplashSoundVel;
    F32 softSplashSoundVel;

Engine/source/T3D/sfx/sfxEmitter.cpp

@@ -109,7 +109,7 @@ SFXEmitter::SFXEmitter()
    mLocalProfile.mFilename = StringTable->EmptyString();
    mLocalProfile._registerSignals();
 
-   INIT_SOUNDASSET(Sound);
+   INIT_ASSET(Sound);
 
    mObjBox.minExtents.set( -1.f, -1.f, -1.f );
    mObjBox.maxExtents.set( 1.f, 1.f, 1.f );
@@ -290,7 +290,7 @@ U32 SFXEmitter::packUpdate( NetConnection *con, U32 mask, BitStream *stream )
       stream->writeAffineTransform( mObjToWorld );
 
    // track
-   PACK_SOUNDASSET(con, Sound);
+   PACK_ASSET(con, Sound);
    //if (stream->writeFlag(mDirty.test(Track)))
    //   sfxWrite( stream, mTrack );
 
@@ -401,7 +401,7 @@ void SFXEmitter::unpackUpdate( NetConnection *conn, BitStream *stream )
    }
 
    // track
-   UNPACK_SOUNDASSET(conn, Sound);
+   UNPACK_ASSET(conn, Sound);
    /*if (_readDirtyFlag(stream, Track))
    {
       String errorStr;

Engine/source/T3D/sfx/sfxEmitter.h

@@ -105,7 +105,7 @@ class SFXEmitter : public SceneObject
       BitSet32 mDirty;
 
       DECLARE_SOUNDASSET(SFXEmitter, Sound);
-      DECLARE_SOUNDASSET_NET_SETGET(SFXEmitter, Sound, DirtyUpdateMask);
+      DECLARE_ASSET_NET_SETGET(SFXEmitter, Sound, DirtyUpdateMask);
 
       /// The sound source for the emitter.
       SFXSource *mSource;

Engine/source/T3D/shapeBase.cpp

@@ -197,8 +197,8 @@ ShapeBaseData::ShapeBaseData()
    renderWhenDestroyed( true ),
    inheritEnergyFromMount( false )
 {
-   INIT_SHAPEASSET(Shape);
-   INIT_SHAPEASSET(DebrisShape);
+   INIT_ASSET(Shape);
+   INIT_ASSET(DebrisShape);
 
    dMemset( mountPointNode, -1, sizeof( S32 ) * SceneObject::NumMountPoints );
    remap_txr_tags = NULL;
@@ -214,13 +214,13 @@ ShapeBaseData::ShapeBaseData(const ShapeBaseData& other, bool temp_clone) : Game
    shadowProjectionDistance = other.shadowProjectionDistance;
    shadowSphereAdjust = other.shadowSphereAdjust;
    cloakTexName = other.cloakTexName;
-   CLONE_SHAPEASSET(Shape);
+   CLONE_ASSET(Shape);
    cubeDescName = other.cubeDescName;
    cubeDescId = other.cubeDescId;
    reflectorDesc = other.reflectorDesc;
    debris = other.debris;
    debrisID = other.debrisID; // -- for pack/unpack of debris ptr
-   CLONE_SHAPEASSET(DebrisShape);
+   CLONE_ASSET(DebrisShape);
    explosion = other.explosion;
    explosionID = other.explosionID; // -- for pack/unpack of explosion ptr
    underwaterExplosion = other.underwaterExplosion;
@@ -757,8 +757,8 @@ void ShapeBaseData::packData(BitStream* stream)
    stream->write(shadowProjectionDistance);
    stream->write(shadowSphereAdjust);
 
-   PACKDATA_SHAPEASSET(Shape);
-   PACKDATA_SHAPEASSET(DebrisShape);
+   PACKDATA_ASSET(Shape);
+   PACKDATA_ASSET(DebrisShape);
 
    stream->writeString(cloakTexName);
    if(stream->writeFlag(mass != gShapeBaseDataProto.mass))
@@ -835,8 +835,8 @@ void ShapeBaseData::unpackData(BitStream* stream)
    stream->read(&shadowProjectionDistance);
    stream->read(&shadowSphereAdjust);
 
-   UNPACKDATA_SHAPEASSET(Shape);
-   UNPACKDATA_SHAPEASSET(DebrisShape);
+   UNPACKDATA_ASSET(Shape);
+   UNPACKDATA_ASSET(DebrisShape);
 
    cloakTexName = stream->readSTString();
    if(stream->readFlag())

Engine/source/T3D/shapeBase.h

@@ -73,6 +73,7 @@
 
 // Need full definition visible for SimObjectPtr<ParticleEmitter>
 #include "T3D/fx/particleEmitter.h"
+#include "T3D/assets/SoundAsset.h"
 
 class GFXCubemap;
 class TSShapeInstance;
@@ -259,11 +260,12 @@ struct ShapeBaseImageData: public GameBaseData {
                                     ///  the imageSlot.
       ParticleEmitterData* emitter; ///< A particle emitter; this emitter will emit as long as the gun is in this
                                     ///  this state.
-      SFXTrack* sound;
+      
+      //SFXTrack* sound;
       F32 emitterTime;              ///<
       S32 emitterNode[MaxShapes];   ///< Node ID on the shape to emit from
+      SoundAsset* sound;
    };
-
    /// @name State Data
    /// Individual state data used to initialize struct array
    /// @{
@@ -321,7 +323,10 @@ struct ShapeBaseImageData: public GameBaseData {
 
    bool                    stateIgnoreLoadedForReady  [MaxStates];
 
-   SFXTrack*               stateSound                 [MaxStates];
+   DECLARE_SOUNDASSET_ARRAY(ShapeBaseImageData, stateSound, MaxStates);
+   DECLARE_ASSET_ARRAY_SETGET(ShapeBaseImageData, stateSound);
+
+   //SFXTrack*               stateSound                 [MaxStates];
    const char*             stateScript                [MaxStates];
 
    ParticleEmitterData*    stateEmitter               [MaxStates];
@@ -374,10 +379,10 @@ struct ShapeBaseImageData: public GameBaseData {
                                     ///< when the script prefix has changed.
 
    DECLARE_SHAPEASSET_ARRAY(ShapeBaseImageData, Shape, MaxShapes);  ///< Name of shape to render.
-   DECLARE_SHAPEASSET_ARRAY_SETGET(ShapeBaseImageData, Shape);
+   DECLARE_ASSET_ARRAY_SETGET(ShapeBaseImageData, Shape);
 
    //DECLARE_SHAPEASSET(ShapeBaseImageData, ShapeFP);  ///< Name of shape to render in first person (optional).
-   //DECLARE_SHAPEASSET_SETGET(ShapeBaseImageData, ShapeFP);
+   //DECLARE_ASSET_SETGET(ShapeBaseImageData, ShapeFP);
 
    StringTableEntry  imageAnimPrefix;     ///< Passed along to the mounting shape to modify
                                           ///  animation sequences played in 3rd person. [optional]
@@ -541,7 +546,7 @@ public:
    F32 shadowSphereAdjust;
 
    DECLARE_SHAPEASSET(ShapeBaseData, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(ShapeBaseData, Shape);
+   DECLARE_ASSET_SETGET(ShapeBaseData, Shape);
 
    StringTableEntry  cloakTexName;
 
@@ -557,7 +562,7 @@ public:
    S32               debrisID;
 
    DECLARE_SHAPEASSET(ShapeBaseData, DebrisShape, onDebrisChanged);
-   DECLARE_SHAPEASSET_SETGET(ShapeBaseData, DebrisShape);
+   DECLARE_ASSET_SETGET(ShapeBaseData, DebrisShape);
 
    ExplosionData*    explosion;
    S32               explosionID;
@@ -662,7 +667,7 @@ public:
    DECLARE_CALLBACK( void, onCollision, ( ShapeBase* obj, SceneObject* collObj, VectorF vec, F32 len ) );
    DECLARE_CALLBACK( void, onDamage, ( ShapeBase* obj, F32 delta ) );
    DECLARE_CALLBACK( void, onTrigger, ( ShapeBase* obj, S32 index, bool state ) );
-   DECLARE_CALLBACK(void, onEndSequence, (ShapeBase* obj, S32 slot, const char* name));
+   DECLARE_CALLBACK( void, onEndSequence, (ShapeBase* obj, S32 slot, const char* name));
    DECLARE_CALLBACK( void, onForceUncloak, ( ShapeBase* obj, const char* reason ) );
    /// @}
    struct TextureTagRemapping

Engine/source/T3D/shapeImage.cpp

@@ -132,7 +132,7 @@ ShapeBaseImageData::StateData::StateData()
    loaded = IgnoreLoaded;
    spin = IgnoreSpin;
    recoil = NoRecoil;
-   sound = 0;
+   sound = NULL;
    emitter = NULL;
    shapeSequence = NULL;
    shapeSequenceScale = true;
@@ -156,6 +156,7 @@ ShapeBaseImageData::StateData::StateData()
       flashSequence[i] = false;
       emitterNode[i] = -1;
    }
+
 }
 
 static ShapeBaseImageData::StateData gDefaultStateData;
@@ -256,7 +257,7 @@ ShapeBaseImageData::ShapeBaseImageData()
       stateShapeSequence[i] = 0;
       stateScaleShapeSequence[i] = false;
 
-      stateSound[i] = 0;
+      INIT_ASSET_ARRAY(stateSound, i);
       stateScript[i] = 0;
       stateEmitter[i] = 0;
       stateEmitterTime[i] = 0;
@@ -294,7 +295,7 @@ ShapeBaseImageData::ShapeBaseImageData()
       hasFlash[i] = false;
       shapeIsValid[i] = false;
 
-      INIT_SHAPEASSET_ARRAY(Shape, i);
+      INIT_ASSET_ARRAY(Shape, i);
    }
 
    shakeCamera = false;
@@ -303,6 +304,7 @@ ShapeBaseImageData::ShapeBaseImageData()
    camShakeDuration = 1.5f;
    camShakeRadius = 3.0f;
    camShakeFalloff = 10.0f;
+   
 }
 
 ShapeBaseImageData::~ShapeBaseImageData()
@@ -368,7 +370,8 @@ bool ShapeBaseImageData::onAdd()
          s.shapeSequence = stateShapeSequence[i];
          s.shapeSequenceScale = stateScaleShapeSequence[i];
 
-         s.sound = stateSound[i];
+         //_setstateSound(getstateSound(i),i);
+         s.sound = getstateSoundAsset(i);
          s.script = stateScript[i];
          s.emitter = stateEmitter[i];
          s.emitterTime = stateEmitterTime[i];
@@ -418,10 +421,14 @@ bool ShapeBaseImageData::preload(bool server, String &errorStr)
          if (state[i].emitter)
             if (!Sim::findObject(SimObjectId((uintptr_t)state[i].emitter), state[i].emitter))
                Con::errorf(ConsoleLogEntry::General, "Error, unable to load emitter for image datablock");
-               
-         String str;
-         if( !sfxResolve( &state[ i ].sound, str ) )
-            Con::errorf( ConsoleLogEntry::General, str.c_str() );
+
+         if (getstateSound(i) != StringTable->EmptyString())
+         {
+            _setstateSound(getstateSound(i), i);
+            if (!getstateSoundProfile(i))
+               Con::errorf("ShapeBaseImageData::preload() - Could not find profile for asset %s on state %d", getstateSound(i), i);
+         }
+
       }
    }
 
@@ -921,8 +928,8 @@ void ShapeBaseImageData::initPersistFields()
       addField( "stateScaleShapeSequence", TypeBool, Offset(stateScaleShapeSequence, ShapeBaseImageData), MaxStates,
          "Indicates if the sequence to be played on the mounting shape should be scaled to the length of the state." );
 
-      addField( "stateSound", TypeSFXTrackName, Offset(stateSound, ShapeBaseImageData), MaxStates,
-         "Sound to play on entry to this state." );
+      INITPERSISTFIELD_SOUNDASSET_ARRAY(stateSound, MaxStates, ShapeBaseImageData, "State sound.");
+
       addField( "stateScript", TypeCaseString, Offset(stateScript, ShapeBaseImageData), MaxStates,
          "@brief Method to execute on entering this state.\n\n"
          "Scoped to this image class name, then ShapeBaseImageData. The script "
@@ -975,7 +982,7 @@ void ShapeBaseImageData::packData(BitStream* stream)
 
    for (U32 j = 0; j < MaxShapes; ++j)
    {
-      PACKDATA_SHAPEASSET_ARRAY(Shape, j);        // shape 0 for normal use, shape 1 for first person use (optional)
+      PACKDATA_ASSET_ARRAY(Shape, j);        // shape 0 for normal use, shape 1 for first person use (optional)
    }
 
    stream->writeString(imageAnimPrefix);
@@ -1139,7 +1146,7 @@ void ShapeBaseImageData::packData(BitStream* stream)
             }
          }
 
-         sfxWrite( stream, s.sound );
+         PACKDATA_ASSET_ARRAY(stateSound, i);
       }
    stream->write(maxConcurrentSounds);
    stream->writeFlag(useRemainderDT);
@@ -1159,7 +1166,7 @@ void ShapeBaseImageData::unpackData(BitStream* stream)
 
    for (U32 j = 0; j < MaxShapes; ++j)
    {
-      UNPACKDATA_SHAPEASSET_ARRAY(Shape, j);        // shape 0 for normal use, shape 1 for first person use (optional)
+      UNPACKDATA_ASSET_ARRAY(Shape, j);        // shape 0 for normal use, shape 1 for first person use (optional)
    }
 
    imageAnimPrefix = stream->readSTString();
@@ -1344,7 +1351,7 @@ void ShapeBaseImageData::unpackData(BitStream* stream)
          else
             s.emitter = 0;
             
-         sfxRead( stream, &s.sound );
+         UNPACKDATA_ASSET_ARRAY(stateSound, i);
       }
    }
    
@@ -2752,9 +2759,10 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
    {
       onImageStateAnimation(imageSlot, stateData.shapeSequence, stateData.direction, stateData.shapeSequenceScale, stateData.timeoutValue);
    }
-
    // Delete any loooping sounds that were in the previous state.
-   if (lastState->sound && lastState->sound->getDescription()->mIsLooping)  
+   // this is the crazy bit =/ needs to know prev state in order to stop sounds.
+   // lastState does not return an id for the prev state so we keep track of it.
+   if (lastState->sound && lastState->sound->getSfxProfile()->getDescription()->mIsLooping)
    {  
       for(Vector<SFXSource*>::iterator i = image.mSoundSources.begin(); i != image.mSoundSources.end(); i++)      
          SFX_DELETE((*i));    
@@ -2766,7 +2774,7 @@ void ShapeBase::setImageState(U32 imageSlot, U32 newState,bool force)
    if( stateData.sound && isGhost() )
    {
       const Point3F& velocity         = getVelocity();
-      image.addSoundSource(SFX->createSource( stateData.sound, &getRenderTransform(), &velocity )); 
+      image.addSoundSource(SFX->createSource(stateData.sound->getSfxProfile(), &getRenderTransform(), &velocity ));
    }
 
    // Play animation

Engine/source/T3D/tsStatic.cpp

@@ -149,7 +149,7 @@ TSStatic::TSStatic()
    mAnimOffset = 0.0f;
    mAnimSpeed = 1.0f;
 
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 }
 
 TSStatic::~TSStatic()
@@ -958,7 +958,7 @@ U32 TSStatic::packUpdate(NetConnection* con, U32 mask, BitStream* stream)
 
    if (stream->writeFlag(mask & AdvancedStaticOptionsMask))
    {
-      PACK_SHAPEASSET(con, Shape);
+      PACK_ASSET(con, Shape);
 
       stream->write((U32)mDecalType);
 
@@ -1073,7 +1073,7 @@ void TSStatic::unpackUpdate(NetConnection* con, BitStream* stream)
 
    if (stream->readFlag()) // AdvancedStaticOptionsMask
    {
-      UNPACK_SHAPEASSET(con, Shape);
+      UNPACK_ASSET(con, Shape);
 
       stream->read((U32*)&mDecalType);
 

Engine/source/T3D/tsStatic.h

@@ -192,7 +192,7 @@ protected:
    Convex* mConvexList;
 
    DECLARE_SHAPEASSET(TSStatic, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_NET_SETGET(TSStatic, Shape, AdvancedStaticOptionsMask);
+   DECLARE_ASSET_NET_SETGET(TSStatic, Shape, AdvancedStaticOptionsMask);
 
    U32               mShapeHash;
    Vector<S32> mCollisionDetails;

Engine/source/T3D/vehicles/flyingVehicle.cpp

@@ -116,7 +116,7 @@ FlyingVehicleData::FlyingVehicleData()
       jetEmitter[j] = 0;
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sound[i] = 0;
+      INIT_ASSET_ARRAY(FlyingSounds, i);
 
    vertThrustMultiple = 1.0;
 }
@@ -131,9 +131,12 @@ bool FlyingVehicleData::preload(bool server, String &errorStr)
    // Resolve objects transmitted from server
    if (!server) {
       for (S32 i = 0; i < MaxSounds; i++)
-         if (sound[i])
-            Sim::findObject(SimObjectId((uintptr_t)sound[i]),sound[i]);
-
+      {
+         if (mFlyingSounds[i])
+         {
+            _setFlyingSounds(getFlyingSounds(i), i);
+         }
+      }
       for (S32 j = 0; j < MaxJetEmitters; j++)
          if (jetEmitter[j])
             Sim::findObject(SimObjectId((uintptr_t)jetEmitter[j]),jetEmitter[j]);
@@ -163,10 +166,8 @@ bool FlyingVehicleData::preload(bool server, String &errorStr)
 
 void FlyingVehicleData::initPersistFields()
 {
-   addField( "jetSound", TYPEID< SFXProfile >(), Offset(sound[JetSound], FlyingVehicleData),
-      "Looping sound to play while the vehicle is jetting." );
-   addField( "engineSound", TYPEID< SFXProfile >(), Offset(sound[EngineSound], FlyingVehicleData),
-      "Looping engine sound." );
+
+   INITPERSISTFIELD_SOUNDASSET_ARRAY(FlyingSounds, Sounds::MaxSounds, FlyingVehicleData, "Sounds for flying vehicle");
 
    addField( "maneuveringForce", TypeF32, Offset(maneuveringForce, FlyingVehicleData),
       "@brief Maximum X and Y (horizontal plane) maneuvering force.\n\n"
@@ -240,11 +241,7 @@ void FlyingVehicleData::packData(BitStream* stream)
 
    for (S32 i = 0; i < MaxSounds; i++)
    {
-      if (stream->writeFlag(sound[i]))
-      {
-         SimObjectId writtenId = mPacked ? SimObjectId((uintptr_t)sound[i]) : sound[i]->getId();
-         stream->writeRangedU32(writtenId, DataBlockObjectIdFirst, DataBlockObjectIdLast);
-      }
+      PACKDATA_ASSET_ARRAY(FlyingSounds, i);
    }
 
    for (S32 j = 0; j < MaxJetEmitters; j++)
@@ -277,11 +274,9 @@ void FlyingVehicleData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   for (S32 i = 0; i < MaxSounds; i++) {
-      sound[i] = NULL;
-      if (stream->readFlag())
-         sound[i] = (SFXProfile*)(uintptr_t)stream->readRangedU32(DataBlockObjectIdFirst,
-                                                         DataBlockObjectIdLast);
+   for (S32 i = 0; i < MaxSounds; i++)
+   {
+      UNPACKDATA_ASSET_ARRAY(FlyingSounds, i);
    }
 
    for (S32 j = 0; j < MaxJetEmitters; j++) {
@@ -374,11 +369,11 @@ bool FlyingVehicle::onNewDataBlock(GameBaseData* dptr, bool reload)
       SFX_DELETE( mJetSound );
       SFX_DELETE( mEngineSound );
 
-      if ( mDataBlock->sound[FlyingVehicleData::EngineSound] )
-         mEngineSound = SFX->createSource( mDataBlock->sound[FlyingVehicleData::EngineSound], &getTransform() );
+      if ( mDataBlock->getFlyingSounds(FlyingVehicleData::EngineSound) )
+         mEngineSound = SFX->createSource( mDataBlock->getFlyingSoundProfile(FlyingVehicleData::EngineSound), &getTransform() );
 
-      if ( mDataBlock->sound[FlyingVehicleData::JetSound] )
-         mJetSound = SFX->createSource( mDataBlock->sound[FlyingVehicleData::JetSound], &getTransform() );
+      if ( mDataBlock->getFlyingSounds(FlyingVehicleData::JetSound))
+         mJetSound = SFX->createSource( mDataBlock->getFlyingSoundProfile(FlyingVehicleData::JetSound), &getTransform() );
    }
 
    // Jet Sequences

Engine/source/T3D/vehicles/flyingVehicle.h

@@ -45,7 +45,15 @@ struct FlyingVehicleData: public VehicleData {
       EngineSound,
       MaxSounds,
    };
-   SFXProfile* sound[MaxSounds];
+   DECLARE_SOUNDASSET_ARRAY(FlyingVehicleData, FlyingSounds, Sounds::MaxSounds);
+   DECLARE_ASSET_ARRAY_SETGET(FlyingVehicleData, FlyingSounds);
+   SFXProfile* getFlyingSoundProfile(U32 id)
+   {
+      if (mFlyingSoundsAsset[id] != NULL)
+         return mFlyingSoundsAsset[id]->getSfxProfile();
+
+      return NULL;
+   }
 
    enum Jets {
       // These enums index into a static name list.

Engine/source/T3D/vehicles/hoverVehicle.cpp

@@ -68,6 +68,16 @@ ConsoleDocClass( HoverVehicle,
    "@ingroup Vehicles\n"
 );
 
+typedef HoverVehicleData::Sounds hoverSoundsEnum;
+DefineEnumType(hoverSoundsEnum);
+
+ImplementEnumType(hoverSoundsEnum, "enum types.\n"
+   "@ingroup HoverVehicleData\n\n")
+   { HoverVehicleData::JetSound,       "JetSound", "..." },
+   { HoverVehicleData::EngineSound,    "EngineSound", "..." },
+   { HoverVehicleData::FloatSound,     "FloatSound", "..." },
+EndImplementEnumType;
+
 namespace {
 
 const U32 sCollisionMoveMask = (TerrainObjectType     | PlayerObjectType  | 
@@ -152,7 +162,7 @@ HoverVehicleData::HoverVehicleData()
       jetEmitter[j] = 0;
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sound[i] = 0;
+      INIT_ASSET_ARRAY(HoverSounds, i);
 }
 
 HoverVehicleData::~HoverVehicleData()
@@ -232,14 +242,8 @@ void HoverVehicleData::initPersistFields()
    addField( "pitchForce", TypeF32, Offset(pitchForce, HoverVehicleData),
       "Pitch (rotation about the X-axis) force applied when steering in the y-axis direction." );
 
-   addField( "jetSound", TYPEID< SFXProfile >(), Offset(sound[JetSound], HoverVehicleData),
-      "Looping sound played when the vehicle is jetting." );
-   addField( "engineSound", TYPEID< SFXProfile >(), Offset(sound[EngineSound], HoverVehicleData),
-      "Looping engine sound.\nThe volume is dynamically adjusted based on the "
-      "current thrust level." );
-   addField( "floatSound", TYPEID< SFXProfile >(), Offset(sound[FloatSound], HoverVehicleData),
-      "Looping sound played while the vehicle is floating.\n\n@see stabMinLen" );
-
+   INITPERSISTFIELD_SOUNDASSET_ENUMED(HoverSounds, hoverSoundsEnum, Sounds::MaxSounds, HoverVehicleData, "Sounds for hover vehicle.");
+   
    addField( "dustTrailEmitter", TYPEID< ParticleEmitterData >(), Offset(dustTrailEmitter, HoverVehicleData),
       "Emitter to generate particles for the vehicle's dust trail.\nThe trail "
       "of dust particles is generated only while the vehicle is moving." );
@@ -311,9 +315,13 @@ bool HoverVehicleData::preload(bool server, String &errorStr)
 
    // Resolve objects transmitted from server
    if (!server) {
+
       for (S32 i = 0; i < MaxSounds; i++)
-         if (sound[i])
-            Sim::findObject(SimObjectId((uintptr_t)sound[i]),sound[i]);
+         if (getHoverSounds(i) != StringTable->EmptyString())
+         {
+            _setHoverSounds(getHoverSounds(i), i);
+         }
+
       for (S32 j = 0; j < MaxJetEmitters; j++)
          if (jetEmitter[j])
             Sim::findObject(SimObjectId((uintptr_t)jetEmitter[j]),jetEmitter[j]);
@@ -361,9 +369,9 @@ void HoverVehicleData::packData(BitStream* stream)
    stream->write(dustTrailFreqMod);
 
    for (S32 i = 0; i < MaxSounds; i++)
-      if (stream->writeFlag(sound[i]))
-         stream->writeRangedU32(mPacked ? SimObjectId((uintptr_t)sound[i]):
-                                sound[i]->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);
+   {
+      PACKDATA_ASSET_ARRAY(HoverSounds, i);
+   }
 
    for (S32 j = 0; j < MaxJetEmitters; j++)
    {
@@ -410,9 +418,9 @@ void HoverVehicleData::unpackData(BitStream* stream)
    stream->read(&dustTrailFreqMod);
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sound[i] = stream->readFlag()?
-         (SFXProfile*)(uintptr_t)stream->readRangedU32(DataBlockObjectIdFirst,
-                                               DataBlockObjectIdLast): 0;
+   {
+      UNPACKDATA_ASSET_ARRAY(HoverSounds, i);
+   }
 
    for (S32 j = 0; j < MaxJetEmitters; j++) {
       jetEmitter[j] = NULL;
@@ -539,14 +547,14 @@ bool HoverVehicle::onNewDataBlock(GameBaseData* dptr, bool reload)
       SFX_DELETE( mFloatSound );
       SFX_DELETE( mJetSound );
 
-      if ( mDataBlock->sound[HoverVehicleData::EngineSound] )
-         mEngineSound = SFX->createSource( mDataBlock->sound[HoverVehicleData::EngineSound], &getTransform() );
+      if ( mDataBlock->getHoverSounds(HoverVehicleData::EngineSound) )
+         mEngineSound = SFX->createSource( mDataBlock->getHoverSoundProfile(HoverVehicleData::EngineSound), &getTransform() );
 
-      if ( !mDataBlock->sound[HoverVehicleData::FloatSound] )
-         mFloatSound = SFX->createSource( mDataBlock->sound[HoverVehicleData::FloatSound], &getTransform() );
+      if ( !mDataBlock->getHoverSounds(HoverVehicleData::FloatSound) )
+         mFloatSound = SFX->createSource( mDataBlock->getHoverSoundProfile(HoverVehicleData::FloatSound), &getTransform() );
 
-      if ( mDataBlock->sound[HoverVehicleData::JetSound] )
-         mJetSound = SFX->createSource( mDataBlock->sound[HoverVehicleData::JetSound], &getTransform() );
+      if ( mDataBlock->getHoverSounds(HoverVehicleData::JetSound) )
+         mJetSound = SFX->createSource( mDataBlock->getHoverSoundProfile(HoverVehicleData::JetSound), &getTransform() );
    }
 
    // Todo: Uncomment if this is a "leaf" class

Engine/source/T3D/vehicles/hoverVehicle.h

@@ -46,7 +46,14 @@ class HoverVehicleData : public VehicleData
       FloatSound,
       MaxSounds
    };
-   SFXProfile* sound[MaxSounds];
+   DECLARE_SOUNDASSET_ARRAY(HoverVehicleData, HoverSounds, Sounds::MaxSounds);
+   SFXProfile* getHoverSoundProfile(U32 id)
+   {
+      if (mHoverSoundsAsset[id] != NULL)
+         return mHoverSoundsAsset[id]->getSfxProfile();
+
+      return NULL;
+   }
 
    enum Jets {
       // These enums index into a static name list.

Engine/source/T3D/vehicles/vehicle.cpp

@@ -80,6 +80,28 @@ static U32 sTriggerMask = ItemObjectType     |
 
 IMPLEMENT_CONOBJECT(VehicleData);
 
+typedef VehicleData::Body::Sounds bodySounds;
+DefineEnumType(bodySounds);
+
+ImplementEnumType(bodySounds, "enum types.\n"
+   "@ingroup VehicleData\n\n")
+   { VehicleData::Body::SoftImpactSound,  "SoftImpactSound", "..." },
+   { VehicleData::Body::HardImpactSound,  "HardImpactSound", "..." },
+EndImplementEnumType;
+
+
+typedef VehicleData::Sounds vehSoundsEnum;
+DefineEnumType(vehSoundsEnum);
+
+ImplementEnumType(vehSoundsEnum, "enum types.\n"
+   "@ingroup VehicleData\n\n")
+   { VehicleData::ExitWater,     "ExitWater", "..." },
+   { VehicleData::ImpactSoft,    "ImpactSoft", "..." },
+   { VehicleData::ImpactMedium,  "ImpactMedium", "..." },
+   { VehicleData::ImpactHard,    "ImpactHard", "..." },
+   { VehicleData::Wake,          "Wake", "..." },
+EndImplementEnumType;
+
 ConsoleDocClass( VehicleData,
    "@brief Base properties shared by all Vehicles (FlyingVehicle, HoverVehicle, "
    "WheeledVehicle).\n\n"
@@ -166,7 +188,9 @@ VehicleData::VehicleData()
    powerSteering = false;
 
    for (S32 i = 0; i < Body::MaxSounds; i++)
-      body.sound[i] = 0;
+   {
+      INIT_ASSET_ARRAY(VehicleBodySounds, i);
+   }
 
    dustEmitter = NULL;
    dustID = 0;
@@ -189,7 +213,8 @@ VehicleData::VehicleData()
    medSplashSoundVel = 2.0;
    hardSplashSoundVel = 3.0;
 
-   dMemset(waterSound, 0, sizeof(waterSound));
+   for (S32 i = 0; i < Sounds::MaxSounds; i++)
+      INIT_ASSET_ARRAY(VehicleWaterSounds, i);
 
    collDamageThresholdVel = 20;
    collDamageMultiplier = 0.05f;
@@ -215,8 +240,20 @@ bool VehicleData::preload(bool server, String &errorStr)
    // Resolve objects transmitted from server
    if (!server) {
       for (S32 i = 0; i < Body::MaxSounds; i++)
-         if (body.sound[i])
-            Sim::findObject(SimObjectId((uintptr_t)body.sound[i]),body.sound[i]);
+      {
+         if (getVehicleBodySounds(i) != StringTable->EmptyString() )
+         {
+            _setVehicleBodySounds(getVehicleBodySounds(i), i);
+         }
+      }
+
+      for (S32 j = 0; j < Sounds::MaxSounds; j++)
+      {
+         if (getVehicleWaterSounds(j) != StringTable->EmptyString()) 
+         {
+            _setVehicleWaterSounds(getVehicleWaterSounds(j), j);
+         }
+      }
    }
 
    if( !dustEmitter && dustID != 0 )
@@ -264,10 +301,9 @@ void VehicleData::packData(BitStream* stream)
    stream->write(body.restitution);
    stream->write(body.friction);
    for (i = 0; i < Body::MaxSounds; i++)
-      if (stream->writeFlag(body.sound[i]))
-         stream->writeRangedU32(mPacked ? SimObjectId((uintptr_t)body.sound[i]):
-                                body.sound[i]->getId(),DataBlockObjectIdFirst,
-                                DataBlockObjectIdLast);
+   {
+      PACKDATA_ASSET_ARRAY(VehicleBodySounds, i);
+   }
 
    stream->write(minImpactSpeed);
    stream->write(softImpactSpeed);
@@ -308,9 +344,10 @@ void VehicleData::packData(BitStream* stream)
    stream->write(enablePhysicsRep);
 
    // write the water sound profiles
-   for(i = 0; i < MaxSounds; i++)
-      if(stream->writeFlag(waterSound[i]))
-         stream->writeRangedU32(waterSound[i]->getId(), DataBlockObjectIdFirst,  DataBlockObjectIdLast);
+   for (i = 0; i < MaxSounds; i++)
+   {
+      PACKDATA_ASSET_ARRAY(VehicleWaterSounds, i);
+   }
 
    if (stream->writeFlag( dustEmitter ))
    {
@@ -359,11 +396,9 @@ void VehicleData::unpackData(BitStream* stream)
    stream->read(&body.restitution);
    stream->read(&body.friction);
    S32 i;
-   for (i = 0; i < Body::MaxSounds; i++) {
-      body.sound[i] = NULL;
-      if (stream->readFlag())
-         body.sound[i] = (SFXProfile*)(uintptr_t)stream->readRangedU32(DataBlockObjectIdFirst,
-                                                              DataBlockObjectIdLast);
+   for (i = 0; i < Body::MaxSounds; i++)
+   {
+      UNPACKDATA_ASSET_ARRAY(VehicleBodySounds, i);
    }
 
    stream->read(&minImpactSpeed);
@@ -405,12 +440,10 @@ void VehicleData::unpackData(BitStream* stream)
    stream->read(&enablePhysicsRep);
 
    // write the water sound profiles
-   for(i = 0; i < MaxSounds; i++)
-      if(stream->readFlag())
-      {
-         U32 id = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
-         waterSound[i] = dynamic_cast<SFXProfile*>( Sim::findObject(id) );
-      }
+   for (i = 0; i < Sounds::MaxSounds; i++)
+   {
+      UNPACKDATA_ASSET_ARRAY(VehicleWaterSounds, i);
+   }
 
    if( stream->readFlag() )
    {
@@ -491,15 +524,8 @@ void VehicleData::initPersistFields()
    addField( "bodyFriction", TypeF32, Offset(body.friction, VehicleData),
       "Collision friction coefficient.\nHow well this object will slide against "
       "objects it collides with." );
-   addField( "softImpactSound", TYPEID< SFXProfile >(), Offset(body.sound[Body::SoftImpactSound], VehicleData),
-      "@brief Sound to play on a 'soft' impact.\n\n"
-      "This sound is played if the impact speed is < hardImpactSpeed and >= "
-      "softImpactSpeed.\n\n"
-      "@see softImpactSpeed" );
-   addField( "hardImpactSound", TYPEID< SFXProfile >(), Offset(body.sound[Body::HardImpactSound], VehicleData),
-      "@brief Sound to play on a 'hard' impact.\n\n"
-      "This sound is played if the impact speed >= hardImpactSpeed.\n\n"
-      "@see hardImpactSpeed" );
+
+   INITPERSISTFIELD_SOUNDASSET_ENUMED(VehicleBodySounds, bodySounds, Body::Sounds::MaxSounds, VehicleData, "Sounds for vehicle body impacts.");
 
    addField( "minImpactSpeed", TypeF32, Offset(minImpactSpeed, VehicleData),
       "Minimum collision speed for the onImpact callback to be invoked." );
@@ -596,18 +622,8 @@ void VehicleData::initPersistFields()
    addField( "hardSplashSoundVelocity", TypeF32, Offset(hardSplashSoundVel, VehicleData),
       "Minimum velocity when entering the water for the imapactWaterHard sound "
       "to play.\n\n@see impactWaterHard" );
-   addField( "exitingWater", TYPEID< SFXProfile >(), Offset(waterSound[ExitWater], VehicleData),
-      "Sound to play when exiting the water." );
-   addField( "impactWaterEasy", TYPEID< SFXProfile >(), Offset(waterSound[ImpactSoft], VehicleData),
-      "Sound to play when entering the water with speed >= softSplashSoundVelocity "
-      "and < mediumSplashSoundVelocity." );
-   addField( "impactWaterMedium", TYPEID< SFXProfile >(), Offset(waterSound[ImpactMedium], VehicleData),
-      "Sound to play when entering the water with speed >= mediumSplashSoundVelocity "
-      "and < hardSplashSoundVelocity." );
-   addField( "impactWaterHard", TYPEID< SFXProfile >(), Offset(waterSound[ImpactHard], VehicleData),
-      "Sound to play when entering the water with speed >= hardSplashSoundVelocity." );
-   addField( "waterWakeSound", TYPEID< SFXProfile >(), Offset(waterSound[Wake], VehicleData),
-      "Looping sound to play while moving through the water." );
+
+   INITPERSISTFIELD_SOUNDASSET_ENUMED(WaterSounds, vehSoundsEnum, VehicleData::Sounds::MaxSounds, VehicleData, "Sounds for interacting with water.");
 
    addField( "collDamageThresholdVel", TypeF32, Offset(collDamageThresholdVel, VehicleData),
       "Minimum collision velocity to cause damage to this vehicle.\nCurrently unused." );
@@ -876,8 +892,8 @@ bool Vehicle::onNewDataBlock(GameBaseData* dptr,bool reload)
       // costs and makes the system easier to understand.
       SFX_DELETE( mWakeSound );
 
-      if ( mDataBlock->waterSound[VehicleData::Wake] )
-         mWakeSound = SFX->createSource( mDataBlock->waterSound[VehicleData::Wake], &getTransform() );
+      if ( mDataBlock->getVehicleWaterSounds(VehicleData::Wake) != NULL )
+         mWakeSound = SFX->createSource( mDataBlock->getVehicleWaterSoundProfile(VehicleData::Wake), &getTransform() );
    }
 
    return true;
@@ -1140,27 +1156,27 @@ void Vehicle::updatePos(F32 dt)
             if (collSpeed >= mDataBlock->softImpactSpeed)
                impactSound = VehicleData::Body::SoftImpactSound;
 
-         if (impactSound != -1 && mDataBlock->body.sound[impactSound] != NULL)
-            SFX->playOnce( mDataBlock->body.sound[impactSound], &getTransform() );
+         if (impactSound != -1 && mDataBlock->getVehicleBodySounds(impactSound) != NULL)
+            SFX->playOnce( mDataBlock->getVehicleBodySoundProfile(impactSound), &getTransform() );
       }
 
       // Water volume sounds
       F32 vSpeed = getVelocity().len();
       if (!inLiquid && mWaterCoverage >= 0.8f) {
          if (vSpeed >= mDataBlock->hardSplashSoundVel)
-            SFX->playOnce( mDataBlock->waterSound[VehicleData::ImpactHard], &getTransform() );
+            SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ImpactHard), &getTransform() );
          else
             if (vSpeed >= mDataBlock->medSplashSoundVel)
-               SFX->playOnce( mDataBlock->waterSound[VehicleData::ImpactMedium], &getTransform() );
+               SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ImpactMedium), &getTransform() );
          else
             if (vSpeed >= mDataBlock->softSplashSoundVel)
-               SFX->playOnce( mDataBlock->waterSound[VehicleData::ImpactSoft], &getTransform() );
+               SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ImpactSoft), &getTransform() );
          inLiquid = true;
       }
       else
          if(inLiquid && mWaterCoverage < 0.8f) {
             if (vSpeed >= mDataBlock->exitSplashSoundVel)
-               SFX->playOnce( mDataBlock->waterSound[VehicleData::ExitWater], &getTransform() );
+               SFX->playOnce( mDataBlock->getVehicleWaterSoundProfile(VehicleData::ExitWater), &getTransform() );
          inLiquid = false;
       }
    }

Engine/source/T3D/vehicles/vehicle.h

@@ -45,11 +45,21 @@ struct VehicleData : public RigidShapeData
          HardImpactSound,
          MaxSounds,
       };
-      SFXProfile* sound[MaxSounds];
       F32 restitution;
       F32 friction;
    } body;
 
+   DECLARE_SOUNDASSET_ARRAY(VehicleData, VehicleBodySounds, Body::Sounds::MaxSounds)
+
+   SFXProfile* getVehicleBodySoundProfile(U32 id)
+   {
+      if (mVehicleBodySoundsAsset[id] != NULL)
+         return mVehicleBodySoundsAsset[id]->getSfxProfile();
+
+      return NULL;
+   }
+
+
    enum VehicleConsts
    {
       VC_NUM_DUST_EMITTERS = 1,
@@ -69,7 +79,17 @@ struct VehicleData : public RigidShapeData
       Wake,
       MaxSounds
    };
-   SFXProfile* waterSound[MaxSounds];
+
+  DECLARE_SOUNDASSET_ARRAY(VehicleData, VehicleWaterSounds, Sounds::MaxSounds)
+
+  SFXProfile* getVehicleWaterSoundProfile(U32 id)
+  {
+     if (mVehicleWaterSoundsAsset[id] != NULL)
+        return mVehicleWaterSoundsAsset[id]->getSfxProfile();
+
+     return NULL;
+  }
+
    F32 exitSplashSoundVel;
    F32 softSplashSoundVel;
    F32 medSplashSoundVel;

Engine/source/T3D/vehicles/wheeledVehicle.cpp

@@ -75,7 +75,7 @@ ConsoleDocClass( WheeledVehicleTire,
 
 WheeledVehicleTire::WheeledVehicleTire()
 {
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 
    staticFriction = 1;
    kineticFriction = 0.5f;
@@ -177,7 +177,7 @@ void WheeledVehicleTire::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   PACKDATA_SHAPEASSET(Shape);
+   PACKDATA_ASSET(Shape);
 
    stream->write(mass);
    stream->write(staticFriction);
@@ -196,7 +196,7 @@ void WheeledVehicleTire::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   UNPACKDATA_SHAPEASSET(Shape);
+   UNPACKDATA_ASSET(Shape);
 
    stream->read(&mass);
    stream->read(&staticFriction);
@@ -289,6 +289,17 @@ ConsoleDocClass( WheeledVehicleData,
    "@ingroup Vehicles\n"
 );
 
+typedef WheeledVehicleData::Sounds wheelSoundsEnum;
+DefineEnumType(wheelSoundsEnum);
+
+ImplementEnumType(wheelSoundsEnum, "enum types.\n"
+   "@ingroup WheeledVehicleData\n\n")
+   {WheeledVehicleData::JetSound,          "JetSound", "..." },
+   {WheeledVehicleData::EngineSound,       "EngineSound", "..." },
+   {WheeledVehicleData::SquealSound,       "SquealSound", "..." },
+   {WheeledVehicleData::WheelImpactSound,  "WheelImpactSound", "..." },
+EndImplementEnumType;
+
 WheeledVehicleData::WheeledVehicleData()
 {
    tireEmitter = 0;
@@ -301,7 +312,7 @@ WheeledVehicleData::WheeledVehicleData()
    wheelCount = 0;
    dMemset(&wheel, 0, sizeof(wheel));
    for (S32 i = 0; i < MaxSounds; i++)
-      sound[i] = 0;
+      INIT_ASSET_ARRAY(WheeledVehicleSounds, i);
 }
 
 
@@ -335,10 +346,9 @@ bool WheeledVehicleData::preload(bool server, String &errorStr)
    if (!server) {
       for (S32 i = 0; i < MaxSounds; i++)
       {
-         if (!sfxResolve(&sound[i], errorStr))
+         if (getWheeledVehicleSounds(i) != StringTable->EmptyString())
          {
-            delete si;
-            return false;
+            _setWheeledVehicleSounds(getWheeledVehicleSounds(i), i);
          }
       }
 
@@ -438,16 +448,7 @@ bool WheeledVehicleData::mirrorWheel(Wheel* we)
 
 void WheeledVehicleData::initPersistFields()
 {
-   addField( "jetSound", TYPEID< SFXTrack >(), Offset(sound[JetSound], WheeledVehicleData),
-      "Looping sound played when the vehicle is jetting." );
-   addField( "engineSound", TYPEID< SFXTrack >(), Offset(sound[EngineSound], WheeledVehicleData),
-      "@brief Looping engine sound.\n\n"
-      "The pitch is dynamically adjusted based on the current engine RPM" );
-   addField("squealSound", TYPEID< SFXTrack >(), Offset(sound[SquealSound], WheeledVehicleData),
-      "@brief Looping sound played while any of the wheels is slipping.\n\n"
-      "The volume is dynamically adjusted based on how much the wheels are slipping." );
-   addField("WheelImpactSound", TYPEID< SFXTrack >(), Offset(sound[WheelImpactSound], WheeledVehicleData),
-      "Sound played when the wheels impact the ground.\nCurrently unused." );
+   INITPERSISTFIELD_SOUNDASSET_ENUMED(WheeledVehicleSounds, wheelSoundsEnum, MaxSounds, WheeledVehicleData, "Sounds related to wheeled vehicle.");
 
    addField("tireEmitter",TYPEID< ParticleEmitterData >(), Offset(tireEmitter, WheeledVehicleData),
       "ParticleEmitterData datablock used to generate particles from each wheel "
@@ -481,7 +482,9 @@ void WheeledVehicleData::packData(BitStream* stream)
          tireEmitter->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sfxWrite( stream, sound[ i ] );
+   {
+      PACKDATA_ASSET_ARRAY(WheeledVehicleSounds, i);
+   }
 
    stream->write(maxWheelSpeed);
    stream->write(engineTorque);
@@ -498,7 +501,9 @@ void WheeledVehicleData::unpackData(BitStream* stream)
          DataBlockObjectIdLast): 0;
 
    for (S32 i = 0; i < MaxSounds; i++)
-      sfxRead( stream, &sound[ i ] );
+   {
+      UNPACKDATA_ASSET_ARRAY(WheeledVehicleSounds, i);
+   }
 
    stream->read(&maxWheelSpeed);
    stream->read(&engineTorque);
@@ -683,14 +688,14 @@ bool WheeledVehicle::onNewDataBlock(GameBaseData* dptr, bool reload)
       SFX_DELETE( mSquealSound );
       SFX_DELETE( mJetSound );
 
-      if ( mDataBlock->sound[WheeledVehicleData::EngineSound] )
-         mEngineSound = SFX->createSource( mDataBlock->sound[WheeledVehicleData::EngineSound], &getTransform() );
+      if ( mDataBlock->getWheeledVehicleSounds(WheeledVehicleData::EngineSound) )
+         mEngineSound = SFX->createSource( mDataBlock->getWheeledVehicleSound(WheeledVehicleData::EngineSound), &getTransform() );
 
-      if ( mDataBlock->sound[WheeledVehicleData::SquealSound] )
-         mSquealSound = SFX->createSource( mDataBlock->sound[WheeledVehicleData::SquealSound], &getTransform() );
+      if ( mDataBlock->getWheeledVehicleSounds(WheeledVehicleData::SquealSound) )
+         mSquealSound = SFX->createSource( mDataBlock->getWheeledVehicleSound(WheeledVehicleData::SquealSound), &getTransform() );
 
-      if ( mDataBlock->sound[WheeledVehicleData::JetSound] )
-         mJetSound = SFX->createSource( mDataBlock->sound[WheeledVehicleData::JetSound], &getTransform() );
+      if ( mDataBlock->getWheeledVehicleSounds(WheeledVehicleData::JetSound) )
+         mJetSound = SFX->createSource( mDataBlock->getWheeledVehicleSound(WheeledVehicleData::JetSound), &getTransform() );
    }
 
    scriptOnNewDataBlock();

Engine/source/T3D/vehicles/wheeledVehicle.h

@@ -44,7 +44,7 @@ struct WheeledVehicleTire: public SimDataBlock
    typedef SimDataBlock Parent;
 
    DECLARE_SHAPEASSET(WheeledVehicleTire, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(WheeledVehicleTire, Shape);
+   DECLARE_ASSET_SETGET(WheeledVehicleTire, Shape);
 
    // Physical properties
    F32 mass;                  // Mass of the whole wheel
@@ -118,7 +118,17 @@ struct WheeledVehicleData: public VehicleData
       WheelImpactSound,
       MaxSounds,
    };
-   SFXTrack* sound[MaxSounds];
+
+   DECLARE_SOUNDASSET_ARRAY(WheeledVehicleData, WheeledVehicleSounds, Sounds::MaxSounds);
+
+   SFXProfile* getWheeledVehicleSound(U32 id)
+   {
+      if (mWheeledVehicleSoundsAsset[id] != NULL)
+         return mWheeledVehicleSoundsAsset[id]->getSfxProfile();
+
+      return NULL;
+   }
+
 
    ParticleEmitterData* tireEmitter;
 

Engine/source/afx/afxMagicMissile.cpp

@@ -141,7 +141,7 @@ U32 Projectile::smProjectileWarpTicks = 5;
 //
 afxMagicMissileData::afxMagicMissileData()
 {
-   INIT_SHAPEASSET(ProjectileShape);
+   INIT_ASSET(ProjectileShape);
 
    sound = NULL;
 
@@ -246,7 +246,7 @@ afxMagicMissileData::afxMagicMissileData()
 
 afxMagicMissileData::afxMagicMissileData(const afxMagicMissileData& other, bool temp_clone) : GameBaseData(other, temp_clone)
 {
-   CLONE_SHAPEASSET(ProjectileShape);
+   CLONE_ASSET(ProjectileShape);
   projectileShape = other.projectileShape; // -- TSShape loads using projectileShapeName
   sound = other.sound;
   splash = other.splash;
@@ -599,7 +599,7 @@ void afxMagicMissileData::packData(BitStream* stream)
 {
    Parent::packData(stream);
 
-   PACKDATA_SHAPEASSET(ProjectileShape);
+   PACKDATA_ASSET(ProjectileShape);
 
    /* From stock Projectile code...
    stream->writeFlag(faceViewer);
@@ -710,7 +710,7 @@ void afxMagicMissileData::unpackData(BitStream* stream)
 {
    Parent::unpackData(stream);
 
-   UNPACKDATA_SHAPEASSET(ProjectileShape);
+   UNPACKDATA_ASSET(ProjectileShape);
    /* From stock Projectile code...
    faceViewer = stream->readFlag();
    */

Engine/source/afx/afxMagicMissile.h

@@ -72,7 +72,7 @@ public:
    // variables set in datablock definition:
    // Shape related
    DECLARE_SHAPEASSET(afxMagicMissileData, ProjectileShape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(afxMagicMissileData, ProjectileShape);
+   DECLARE_ASSET_SETGET(afxMagicMissileData, ProjectileShape);
   //StringTableEntry      projectileShapeName;
 
   //bool                  hasLight;

Engine/source/afx/ce/afxBillboard.cpp

@@ -51,7 +51,7 @@ ConsoleDocClass( afxBillboardData,
 afxBillboardData::afxBillboardData()
 {
   color.set(1.0f, 1.0f, 1.0f, 1.0f);
-  INIT_IMAGEASSET(Texture);
+  INIT_ASSET(Texture);
   dimensions.set(1.0f, 1.0f);
   texCoords[0].set(0.0f, 0.0f);
   texCoords[1].set(0.0f, 1.0f);
@@ -66,7 +66,7 @@ afxBillboardData::afxBillboardData(const afxBillboardData& other, bool temp_clon
   : GameBaseData(other, temp_clone)
 {
   color = other.color;
-  CLONE_IMAGEASSET(Texture);
+  CLONE_ASSET(Texture);
   dimensions = other.dimensions;
   texCoords[0] = other.texCoords[0];
   texCoords[1] = other.texCoords[1];
@@ -123,7 +123,7 @@ void afxBillboardData::packData(BitStream* stream)
 	Parent::packData(stream);
 
   stream->write(color);
-  PACKDATA_IMAGEASSET(Texture);
+  PACKDATA_ASSET(Texture);
 
   mathWrite(*stream, dimensions);
   mathWrite(*stream, texCoords[0]);
@@ -140,7 +140,7 @@ void afxBillboardData::unpackData(BitStream* stream)
   Parent::unpackData(stream);
 
   stream->read(&color);
-  UNPACKDATA_IMAGEASSET(Texture);
+  UNPACKDATA_ASSET(Texture);
   mathRead(*stream, &dimensions);
   mathRead(*stream, &texCoords[0]);
   mathRead(*stream, &texCoords[1]);

Engine/source/afx/ce/afxBillboard.h

@@ -48,7 +48,7 @@ public:
 
 public:
    DECLARE_IMAGEASSET(afxBillboardData, Texture, onChangeTexture, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(afxBillboardData, Texture);
+   DECLARE_ASSET_SETGET(afxBillboardData, Texture);
 
 
   LinearColorF            color;

Engine/source/afx/ce/afxModel.cpp

@@ -54,7 +54,7 @@ ConsoleDocClass( afxModelData,
 
 afxModelData::afxModelData()
 {
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
   sequence = ST_NULLSTRING;
   seq_rate = 1.0f;
   seq_offset = 0.0f;
@@ -84,7 +84,7 @@ afxModelData::afxModelData()
 
 afxModelData::afxModelData(const afxModelData& other, bool temp_clone) : GameBaseData(other, temp_clone)
 {
-   CLONE_SHAPEASSET(Shape);
+   CLONE_ASSET(Shape);
   sequence = other.sequence;
   seq_rate = other.seq_rate;
   seq_offset = other.seq_offset;
@@ -253,7 +253,7 @@ void afxModelData::packData(BitStream* stream)
 {
   Parent::packData(stream);
 
-  PACKDATA_SHAPEASSET(Shape);
+  PACKDATA_ASSET(Shape);
   stream->writeString(sequence);
   stream->write(seq_rate);  
   stream->write(seq_offset);
@@ -285,7 +285,7 @@ void afxModelData::unpackData(BitStream* stream)
 {
   Parent::unpackData(stream);
 
-  UNPACKDATA_SHAPEASSET(Shape);
+  UNPACKDATA_ASSET(Shape);
   sequence = stream->readSTString();
   stream->read(&seq_rate);
   stream->read(&seq_offset);

Engine/source/afx/ce/afxModel.h

@@ -44,7 +44,7 @@ struct afxModelData : public GameBaseData
   typedef GameBaseData Parent;
 
   DECLARE_SHAPEASSET(afxModelData, Shape, onShapeChanged);
-  DECLARE_SHAPEASSET_SETGET(afxModelData, Shape);
+  DECLARE_ASSET_SETGET(afxModelData, Shape);
 
   StringTableEntry      sequence;
 

Engine/source/afx/ce/afxZodiac.cpp

@@ -78,7 +78,7 @@ bool afxZodiacData::sPreferDestinationGradients = false;
 
 afxZodiacData::afxZodiacData()
 {
-   INIT_IMAGEASSET(Texture);
+   INIT_ASSET(Texture);
 
   radius_xy = 1;
   vert_range.set(0.0f, 0.0f);
@@ -120,7 +120,7 @@ afxZodiacData::afxZodiacData()
 
 afxZodiacData::afxZodiacData(const afxZodiacData& other, bool temp_clone) : GameBaseData(other, temp_clone)
 {
-   CLONE_IMAGEASSET(Texture);
+   CLONE_ASSET(Texture);
 
   radius_xy = other.radius_xy;
   vert_range = other.vert_range;
@@ -269,7 +269,7 @@ void afxZodiacData::packData(BitStream* stream)
 
   merge_zflags();
 
-  PACKDATA_IMAGEASSET(Texture);
+  PACKDATA_ASSET(Texture);
   stream->write(radius_xy);
   stream->write(vert_range.x);
   stream->write(vert_range.y);
@@ -294,7 +294,7 @@ void afxZodiacData::unpackData(BitStream* stream)
 {
   Parent::unpackData(stream);
 
-  UNPACKDATA_IMAGEASSET(Texture);
+  UNPACKDATA_ASSET(Texture);
   stream->read(&radius_xy);
   stream->read(&vert_range.x);
   stream->read(&vert_range.y);

Engine/source/afx/ce/afxZodiac.h

@@ -60,7 +60,7 @@ public:
 
 public:
    DECLARE_IMAGEASSET(afxZodiacData, Texture, onImageChanged, AFX_GFXZodiacTextureProfile);
-   DECLARE_IMAGEASSET_SETGET(afxZodiacData, Texture);
+   DECLARE_ASSET_SETGET(afxZodiacData, Texture);
 
   F32               radius_xy;
   Point2F           vert_range;

Engine/source/afx/ce/afxZodiacPlane.cpp

@@ -51,7 +51,7 @@ ConsoleDocClass( afxZodiacPlaneData,
 
 afxZodiacPlaneData::afxZodiacPlaneData()
 {
-   INIT_IMAGEASSET(Texture);
+   INIT_ASSET(Texture);
 
   radius_xy = 1;
   start_ang = 0;
@@ -71,7 +71,7 @@ afxZodiacPlaneData::afxZodiacPlaneData()
 afxZodiacPlaneData::afxZodiacPlaneData(const afxZodiacPlaneData& other, bool temp_clone)
   : GameBaseData(other, temp_clone)
 {
-   CLONE_IMAGEASSET(Texture);
+   CLONE_ASSET(Texture);
 
   radius_xy = other.radius_xy;
   start_ang = other.start_ang;
@@ -165,7 +165,7 @@ void afxZodiacPlaneData::packData(BitStream* stream)
 
   merge_zflags();
 
-  PACKDATA_IMAGEASSET(Texture);
+  PACKDATA_ASSET(Texture);
 
   stream->write(radius_xy);
   stream->write(start_ang);
@@ -184,7 +184,7 @@ void afxZodiacPlaneData::unpackData(BitStream* stream)
 {
   Parent::unpackData(stream);
 
-  UNPACKDATA_IMAGEASSET(Texture);
+  UNPACKDATA_ASSET(Texture);
 
   stream->read(&radius_xy);
   stream->read(&start_ang);

Engine/source/afx/ce/afxZodiacPlane.h

@@ -60,7 +60,7 @@ public:
 
 public:
    DECLARE_IMAGEASSET(afxZodiacPlaneData, Texture, onImageChanged, AFX_GFXZodiacTextureProfile);
-   DECLARE_IMAGEASSET_SETGET(afxZodiacPlaneData, Texture);
+   DECLARE_ASSET_SETGET(afxZodiacPlaneData, Texture);
 
   F32               radius_xy;
   F32               start_ang;

Engine/source/assets/assetBase.h

@@ -173,6 +173,5 @@ private:
 #define assetText(x,suff) #x#suff
 #define macroText(x) #x
 #define assetDoc(x,suff) "@brief "#x" "#suff
-
 #endif // _ASSET_BASE_H_
 

Engine/source/environment/VolumetricFog.cpp

@@ -137,8 +137,8 @@ VolumetricFog::VolumetricFog()
    mSpeed1.set(0.5f, 0.0f);
    mSpeed2.set(0.1f, 0.1f);
 
-   INIT_SHAPEASSET(Shape);
-   INIT_IMAGEASSET(Texture);
+   INIT_ASSET(Shape);
+   INIT_ASSET(Texture);
 }
 
 VolumetricFog::~VolumetricFog()
@@ -543,7 +543,7 @@ U32 VolumetricFog::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
       stream->write(mFogDensity);
    if (stream->writeFlag(mask & FogModulationMask))
    {
-      PACK_IMAGEASSET(con, Texture);
+      PACK_ASSET(con, Texture);
       mTexTiles = mFabs(mTexTiles);
       stream->write(mTexTiles);
       stream->write(mStrength);
@@ -567,7 +567,7 @@ U32 VolumetricFog::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
    }
    if (stream->writeFlag(mask & FogShapeMask))
    {
-      PACK_SHAPEASSET(con, Shape);
+      PACK_ASSET(con, Shape);
       mathWrite(*stream, getTransform());
       mathWrite(*stream, getScale());
 
@@ -613,7 +613,7 @@ void VolumetricFog::unpackUpdate(NetConnection *con, BitStream *stream)
    }
    if (stream->readFlag())// Fog Modulation
    {
-      UNPACK_IMAGEASSET(con, Texture);
+      UNPACK_ASSET(con, Texture);
       stream->read(&mTexTiles);
       mTexTiles = mFabs(mTexTiles);
       stream->read(&mStrength);
@@ -667,7 +667,7 @@ void VolumetricFog::unpackUpdate(NetConnection *con, BitStream *stream)
    }
    if (stream->readFlag())//Fog shape
    {
-      UNPACK_SHAPEASSET(con, Shape);
+      UNPACK_ASSET(con, Shape);
 
       mathRead(*stream, &mat);
       mathRead(*stream, &scale);

Engine/source/environment/VolumetricFog.h

@@ -85,7 +85,7 @@ class VolumetricFog : public SceneObject
    };
 
    DECLARE_SHAPEASSET(VolumetricFog, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_NET_SETGET(VolumetricFog, Shape, FogShapeMask);
+   DECLARE_ASSET_NET_SETGET(VolumetricFog, Shape, FogShapeMask);
    
    protected:
       // Rendertargets;
@@ -163,7 +163,7 @@ class VolumetricFog : public SceneObject
    
       // Fog Modulation data
       DECLARE_IMAGEASSET(VolumetricFog, Texture, onImageChanged, GFXStaticTextureSRGBProfile);
-      DECLARE_IMAGEASSET_NET_SETGET(VolumetricFog, Texture, FogModulationMask);
+      DECLARE_ASSET_NET_SETGET(VolumetricFog, Texture, FogModulationMask);
 
       bool mIsTextured;
       F32 mTexTiles;
@@ -257,4 +257,4 @@ class VolumetricFog : public SceneObject
       DECLARE_CALLBACK(void, onEnterFog, (SimObjectId obj));
       DECLARE_CALLBACK(void, onLeaveFog, (SimObjectId obj));
 };
-#endif
+#endif

Engine/source/environment/basicClouds.cpp

@@ -215,7 +215,7 @@ U32 BasicClouds::packUpdate( NetConnection *conn, U32 mask, BitStream *stream )
    {
       stream->writeFlag( mLayerEnabled[i] );
 
-      PACK_IMAGEASSET_ARRAY(conn, Texture, i);
+      PACK_ASSET_ARRAY(conn, Texture, i);
 
       stream->write( mTexScale[i] );
       mathWrite( *stream, mTexDirection[i] );
@@ -236,7 +236,7 @@ void BasicClouds::unpackUpdate( NetConnection *conn, BitStream *stream )
    {
       mLayerEnabled[i] = stream->readFlag();
 
-      UNPACK_IMAGEASSET_ARRAY(conn, Texture, i);
+      UNPACK_ASSET_ARRAY(conn, Texture, i);
       
       stream->read( &mTexScale[i] );      
       mathRead( *stream, &mTexDirection[i] );

Engine/source/environment/cloudLayer.cpp

@@ -113,7 +113,7 @@ CloudLayer::CloudLayer()
 
    mHeight = 4.0f;
 
-   INIT_IMAGEASSET(Texture);
+   INIT_ASSET(Texture);
 }
 
 IMPLEMENT_CO_NETOBJECT_V1( CloudLayer );
@@ -242,7 +242,7 @@ U32 CloudLayer::packUpdate( NetConnection *conn, U32 mask, BitStream *stream )
 {
    U32 retMask = Parent::packUpdate( conn, mask, stream );
 
-   PACK_IMAGEASSET(conn, Texture);
+   PACK_ASSET(conn, Texture);
    
    for ( U32 i = 0; i < TEX_COUNT; i++ )
    {
@@ -264,7 +264,7 @@ void CloudLayer::unpackUpdate( NetConnection *conn, BitStream *stream )
 {
    Parent::unpackUpdate( conn, stream );
 
-   UNPACK_IMAGEASSET(conn, Texture);
+   UNPACK_ASSET(conn, Texture);
 
    if(mTextureAssetId != StringTable->EmptyString())
       mTextureAsset = mTextureAssetId;

Engine/source/environment/cloudLayer.h

@@ -97,7 +97,7 @@ protected:
    static U32 smTriangleCount;
 
    DECLARE_IMAGEASSET(CloudLayer, Texture, onImageChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_NET_SETGET(CloudLayer, Texture, CloudLayerMask);
+   DECLARE_ASSET_NET_SETGET(CloudLayer, Texture, CloudLayerMask);
 
    GFXShaderRef mShader;
 
@@ -136,4 +136,4 @@ protected:
 };
 
 
-#endif // _CLOUDLAYER_H_
+#endif // _CLOUDLAYER_H_

Engine/source/environment/decalRoad.cpp

@@ -287,7 +287,7 @@ DecalRoad::DecalRoad()
    mTypeMask |= StaticObjectType | StaticShapeObjectType;
    mNetFlags.set(Ghostable);
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
 
    mMaterialInst = nullptr;
 }
@@ -491,7 +491,7 @@ U32 DecalRoad::packUpdate(NetConnection * con, U32 mask, BitStream * stream)
    if ( stream->writeFlag( mask & DecalRoadMask ) )
    {
       // Write Texture Name.
-      PACK_MATERIALASSET(con, Material);
+      PACK_ASSET(con, Material);
 
       stream->write( mBreakAngle );      
 
@@ -580,7 +580,7 @@ void DecalRoad::unpackUpdate( NetConnection *con, BitStream *stream )
    // DecalRoadMask
    if ( stream->readFlag() )
    {
-      UNPACK_MATERIALASSET(con, Material);
+      UNPACK_ASSET(con, Material);
 
       if (isProperlyAdded())
          _initMaterial();

Engine/source/environment/decalRoad.h

@@ -243,7 +243,7 @@ protected:
    BaseMatInstance* mMaterialInst;
 
    DECLARE_MATERIALASSET(DecalRoad, Material);
-   DECLARE_MATERIALASSET_NET_SETGET(DecalRoad, Material, DecalRoadMask);
+   DECLARE_ASSET_NET_SETGET(DecalRoad, Material, DecalRoadMask);
 
    U32 mRenderPriority;
 

Engine/source/environment/editors/guiMeshRoadEditorCtrl.cpp

@@ -97,9 +97,9 @@ GuiMeshRoadEditorCtrl::GuiMeshRoadEditorCtrl()
     mHoverNodeColor( 255,255,255,255 ),
 	 mHasCopied( false )
 {
-   INIT_MATERIALASSET(TopMaterial);
-   INIT_MATERIALASSET(BottomMaterial);
-   INIT_MATERIALASSET(SideMaterial);
+   INIT_ASSET(TopMaterial);
+   INIT_ASSET(BottomMaterial);
+   INIT_ASSET(SideMaterial);
 
    mTopMaterialAssetId = Con::getVariable("$MeshRoadEditor::defaultTopMaterialAsset");
    mBottomMaterialAssetId = Con::getVariable("$MeshRoadEditor::defaultBottomMaterialAsset");

Engine/source/environment/editors/guiMeshRoadEditorCtrl.h

@@ -160,13 +160,13 @@ class GuiMeshRoadEditorCtrl : public EditTSCtrl
 	public:
 
       DECLARE_MATERIALASSET(GuiMeshRoadEditorCtrl, TopMaterial);
-      DECLARE_MATERIALASSET_SETGET(GuiMeshRoadEditorCtrl, TopMaterial);
+      DECLARE_ASSET_SETGET(GuiMeshRoadEditorCtrl, TopMaterial);
 
       DECLARE_MATERIALASSET(GuiMeshRoadEditorCtrl, BottomMaterial);
-      DECLARE_MATERIALASSET_SETGET(GuiMeshRoadEditorCtrl, BottomMaterial);
+      DECLARE_ASSET_SETGET(GuiMeshRoadEditorCtrl, BottomMaterial);
 
       DECLARE_MATERIALASSET(GuiMeshRoadEditorCtrl, SideMaterial);
-      DECLARE_MATERIALASSET_SETGET(GuiMeshRoadEditorCtrl, SideMaterial);
+      DECLARE_ASSET_SETGET(GuiMeshRoadEditorCtrl, SideMaterial);
 };
 
 class GuiMeshRoadEditorUndoAction : public UndoAction

Engine/source/environment/editors/guiRoadEditorCtrl.h

@@ -104,7 +104,7 @@ class GuiRoadEditorCtrl : public EditTSCtrl
 	public:
 
       DECLARE_MATERIALASSET(GuiRoadEditorCtrl, Material);
-      DECLARE_MATERIALASSET_SETGET(GuiRoadEditorCtrl, Material);
+      DECLARE_ASSET_SETGET(GuiRoadEditorCtrl, Material);
 
    protected:
 

Engine/source/environment/meshRoad.cpp

@@ -920,9 +920,9 @@ MeshRoad::MeshRoad()
       mTriangleCount[i] = 0;
    }
 
-   INIT_MATERIALASSET(TopMaterial);
-   INIT_MATERIALASSET(BottomMaterial);
-   INIT_MATERIALASSET(SideMaterial);
+   INIT_ASSET(TopMaterial);
+   INIT_ASSET(BottomMaterial);
+   INIT_ASSET(SideMaterial);
 
    mSideProfile.mRoad = this;
 }
@@ -1416,9 +1416,9 @@ U32 MeshRoad::packUpdate(NetConnection * con, U32 mask, BitStream * stream)
       stream->writeAffineTransform( mObjToWorld );
 
       // Write Materials
-      PACK_MATERIALASSET(con, TopMaterial);
-      PACK_MATERIALASSET(con, BottomMaterial);
-      PACK_MATERIALASSET(con, SideMaterial);
+      PACK_ASSET(con, TopMaterial);
+      PACK_ASSET(con, BottomMaterial);
+      PACK_ASSET(con, SideMaterial);
 
       stream->write( mTextureLength );      
       stream->write( mBreakAngle );
@@ -1515,9 +1515,9 @@ void MeshRoad::unpackUpdate(NetConnection * con, BitStream * stream)
       stream->readAffineTransform(&ObjectMatrix);
       Parent::setTransform(ObjectMatrix);
 
-      UNPACK_MATERIALASSET(con, TopMaterial);
-      UNPACK_MATERIALASSET(con, BottomMaterial);
-      UNPACK_MATERIALASSET(con, SideMaterial);
+      UNPACK_ASSET(con, TopMaterial);
+      UNPACK_ASSET(con, BottomMaterial);
+      UNPACK_ASSET(con, SideMaterial);
 
       if ( isProperlyAdded() )
          _initMaterial(); 

Engine/source/environment/meshRoad.h

@@ -622,13 +622,13 @@ protected:
    GFXPrimitiveBufferHandle mPB[SurfaceCount];      
 
    DECLARE_MATERIALASSET(MeshRoad, TopMaterial);
-   DECLARE_MATERIALASSET_NET_SETGET(MeshRoad, TopMaterial, MeshRoadMask);
+   DECLARE_ASSET_NET_SETGET(MeshRoad, TopMaterial, MeshRoadMask);
 
    DECLARE_MATERIALASSET(MeshRoad, BottomMaterial);
-   DECLARE_MATERIALASSET_NET_SETGET(MeshRoad, BottomMaterial, MeshRoadMask);
+   DECLARE_ASSET_NET_SETGET(MeshRoad, BottomMaterial, MeshRoadMask);
 
    DECLARE_MATERIALASSET(MeshRoad, SideMaterial);
-   DECLARE_MATERIALASSET_NET_SETGET(MeshRoad, SideMaterial, MeshRoadMask);
+   DECLARE_ASSET_NET_SETGET(MeshRoad, SideMaterial, MeshRoadMask);
 
    //String mMaterialName[SurfaceCount];   
    SimObjectPtr<Material> mMaterial[SurfaceCount];

Engine/source/environment/scatterSky.cpp

@@ -168,7 +168,7 @@ ScatterSky::ScatterSky()
    mNightCubemapName = StringTable->EmptyString();
    mSunSize = 1.0f;
 
-   INIT_MATERIALASSET(MoonMat);
+   INIT_ASSET(MoonMat);
 
    mMoonMatInst = NULL;
 
@@ -503,7 +503,7 @@ U32 ScatterSky::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
 
       stream->writeFlag( mMoonEnabled );
 
-      PACK_MATERIALASSET(con, MoonMat);
+      PACK_ASSET(con, MoonMat);
       
       stream->write( mMoonScale );
       stream->write( mMoonTint );
@@ -617,7 +617,7 @@ void ScatterSky::unpackUpdate(NetConnection *con, BitStream *stream)
 
       mMoonEnabled = stream->readFlag();
 
-      UNPACK_MATERIALASSET(con, MoonMat);
+      UNPACK_ASSET(con, MoonMat);
 
       stream->read( &mMoonScale );
       stream->read( &mMoonTint );

Engine/source/environment/scatterSky.h

@@ -212,7 +212,7 @@ protected:
    bool mMoonEnabled;
 
    DECLARE_MATERIALASSET(ScatterSky, MoonMat);
-   DECLARE_MATERIALASSET_NET_SETGET(ScatterSky, MoonMat, UpdateMask);
+   DECLARE_ASSET_NET_SETGET(ScatterSky, MoonMat, UpdateMask);
 
    BaseMatInstance *mMoonMatInst;
    F32 mMoonScale;

Engine/source/environment/skyBox.cpp

@@ -56,7 +56,7 @@ SkyBox::SkyBox()
    mTypeMask |= EnvironmentObjectType | StaticObjectType;
    mNetFlags.set(Ghostable | ScopeAlways);
 
-   INIT_MATERIALASSET(Material);
+   INIT_ASSET(Material);
    mMatInstance = NULL;
 
    mIsVBDirty = false;
@@ -139,7 +139,7 @@ U32 SkyBox::packUpdate( NetConnection *conn, U32 mask, BitStream *stream )
 {
    U32 retMask = Parent::packUpdate( conn, mask, stream );
 
-   PACK_MATERIALASSET(conn, Material);
+   PACK_ASSET(conn, Material);
 
    stream->writeFlag( mDrawBottom );
    stream->write( mFogBandHeight );
@@ -152,7 +152,7 @@ void SkyBox::unpackUpdate( NetConnection *conn, BitStream *stream )
    Parent::unpackUpdate( conn, stream );
 
    StringTableEntry oldMatName = getMaterial();
-   UNPACK_MATERIALASSET(conn, Material);
+   UNPACK_ASSET(conn, Material);
    if (oldMatName != getMaterial())
    {
       _updateMaterial();

Engine/source/environment/skyBox.h

@@ -102,7 +102,7 @@ protected:
 
    // Material
    DECLARE_MATERIALASSET(SkyBox, Material);
-   DECLARE_MATERIALASSET_NET_SETGET(SkyBox, Material, -1);
+   DECLARE_ASSET_NET_SETGET(SkyBox, Material, -1);
 
    BaseMatInstance *mMatInstance;
    SkyMatParams mMatParamHandle;

Engine/source/environment/sun.cpp

@@ -90,7 +90,7 @@ Sun::Sun()
    mCoronaUseLightColor = true;
    mCoronaMatInst = NULL;
 
-   INIT_MATERIALASSET(CoronaMaterial);
+   INIT_ASSET(CoronaMaterial);
 
    mMatrixSet = reinterpret_cast<MatrixSet *>(dMalloc_aligned(sizeof(MatrixSet), 16));
    constructInPlace(mMatrixSet);
@@ -240,7 +240,7 @@ U32 Sun::packUpdate(NetConnection *conn, U32 mask, BitStream *stream )
 
       stream->writeFlag( mCoronaEnabled );
 
-      PACK_MATERIALASSET(conn, CoronaMaterial);
+      PACK_ASSET(conn, CoronaMaterial);
 
       stream->write( mCoronaScale );
       stream->write( mCoronaTint );
@@ -286,7 +286,7 @@ void Sun::unpackUpdate( NetConnection *conn, BitStream *stream )
 
       mCoronaEnabled = stream->readFlag();
 
-      UNPACK_MATERIALASSET(conn, CoronaMaterial);
+      UNPACK_ASSET(conn, CoronaMaterial);
 
       stream->read( &mCoronaScale );
       stream->read( &mCoronaTint );

Engine/source/environment/sun.h

@@ -79,7 +79,7 @@ protected:
    bool mCoronaEnabled;
 
    DECLARE_MATERIALASSET(Sun, CoronaMaterial);
-   DECLARE_MATERIALASSET_NET_SETGET(Sun, CoronaMaterial, UpdateMask);
+   DECLARE_ASSET_NET_SETGET(Sun, CoronaMaterial, UpdateMask);
 
    BaseMatInstance *mCoronaMatInst;
    MatrixSet *mMatrixSet;   

Engine/source/environment/waterObject.cpp

@@ -260,9 +260,9 @@ WaterObject::WaterObject()
    mMatrixSet = reinterpret_cast<MatrixSet *>(dMalloc_aligned(sizeof(MatrixSet), 16));
    constructInPlace(mMatrixSet);
 
-   INIT_IMAGEASSET(RippleTex);
-   INIT_IMAGEASSET(FoamTex);
-   INIT_IMAGEASSET(DepthGradientTex);
+   INIT_ASSET(RippleTex);
+   INIT_ASSET(FoamTex);
+   INIT_ASSET(DepthGradientTex);
 
    mCubemapName = StringTable->EmptyString();
 }
@@ -546,9 +546,9 @@ U32 WaterObject::packUpdate( NetConnection * conn, U32 mask, BitStream *stream )
 
    if ( stream->writeFlag( mask & TextureMask ) )
    {
-      PACK_IMAGEASSET(conn, RippleTex);
-      PACK_IMAGEASSET(conn, DepthGradientTex);
-      PACK_IMAGEASSET(conn, FoamTex);
+      PACK_ASSET(conn, RippleTex);
+      PACK_ASSET(conn, DepthGradientTex);
+      PACK_ASSET(conn, FoamTex);
 
       stream->writeString( mCubemapName );      
    }
@@ -668,9 +668,9 @@ void WaterObject::unpackUpdate( NetConnection * conn, BitStream *stream )
    // TextureMask
    if ( stream->readFlag() )
    {
-      UNPACK_IMAGEASSET(conn, RippleTex);
-      UNPACK_IMAGEASSET(conn, DepthGradientTex);
-      UNPACK_IMAGEASSET(conn, FoamTex);
+      UNPACK_ASSET(conn, RippleTex);
+      UNPACK_ASSET(conn, DepthGradientTex);
+      UNPACK_ASSET(conn, FoamTex);
 
       mCubemapName = stream->readSTString();
 

Engine/source/environment/waterObject.h

@@ -273,11 +273,11 @@ protected:
 
    // Other textures
    DECLARE_IMAGEASSET(WaterObject, RippleTex, onRippleTexChanged, GFXStaticTextureProfile);
-   DECLARE_IMAGEASSET_NET_SETGET(WaterObject, RippleTex, TextureMask);
+   DECLARE_ASSET_NET_SETGET(WaterObject, RippleTex, TextureMask);
    DECLARE_IMAGEASSET(WaterObject, FoamTex, onFoamTexChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_NET_SETGET(WaterObject, FoamTex, TextureMask);
+   DECLARE_ASSET_NET_SETGET(WaterObject, FoamTex, TextureMask);
    DECLARE_IMAGEASSET(WaterObject, DepthGradientTex, onDepthGradientTexChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_NET_SETGET(WaterObject, DepthGradientTex, TextureMask);
+   DECLARE_ASSET_NET_SETGET(WaterObject, DepthGradientTex, TextureMask);
 
    StringTableEntry mCubemapName;
 

Engine/source/forest/forestItem.cpp

@@ -53,7 +53,7 @@ ForestItemData::ForestItemData()
       mTightnessCoefficient( 0.4f ),
       mDampingCoefficient( 0.7f )      
 {
-   INIT_SHAPEASSET(Shape);
+   INIT_ASSET(Shape);
 }
 
 void ForestItemData::initPersistFields()
@@ -164,7 +164,7 @@ void ForestItemData::packData(BitStream* stream)
 
    stream->write( localName );
 
-   PACKDATA_SHAPEASSET(Shape);
+   PACKDATA_ASSET(Shape);
    
    stream->writeFlag( mCollidable );
 
@@ -190,7 +190,7 @@ void ForestItemData::unpackData(BitStream* stream)
    stream->read( &localName );
    setInternalName( localName );
 
-   UNPACKDATA_SHAPEASSET(Shape);
+   UNPACKDATA_ASSET(Shape);
    
    mCollidable = stream->readFlag();
 

Engine/source/forest/forestItem.h

@@ -63,7 +63,7 @@ protected:
 public:
    
    DECLARE_SHAPEASSET(ForestItemData, Shape, onShapeChanged);
-   DECLARE_SHAPEASSET_SETGET(ForestItemData, Shape);
+   DECLARE_ASSET_SETGET(ForestItemData, Shape);
 
    /// This is the radius used during placement to ensure
    /// the element isn't crowded up against other trees.

Engine/source/gfx/sim/cubemapData.cpp

@@ -44,10 +44,10 @@ CubemapData::CubemapData()
 
    for (U32 i = 0; i < 6; i++)
    {
-      INIT_IMAGEASSET_ARRAY(CubeMapFace, i);
+      INIT_ASSET_ARRAY(CubeMapFace, i);
    }
 
-   INIT_IMAGEASSET(CubeMap);
+   INIT_ASSET(CubeMap);
 }
 
 CubemapData::~CubemapData()

Engine/source/gfx/sim/cubemapData.h

@@ -74,7 +74,7 @@ public:
 
 protected:
    DECLARE_IMAGEASSET(CubemapData, CubeMap, onCubemapChanged, GFXStaticTextureSRGBProfile);
-   DECLARE_IMAGEASSET_SETGET(CubemapData, CubeMap);
+   DECLARE_ASSET_SETGET(CubemapData, CubeMap);
 
    DECLARE_IMAGEASSET_ARRAY(CubemapData, CubeMapFace, GFXStaticTextureSRGBProfile, 6);
    DECLARE_IMAGEASSET_ARRAY_SETGET(CubemapData, CubeMapFace);

Engine/source/gui/buttons/guiBitmapButtonCtrl.cpp

@@ -129,7 +129,7 @@ GuiBitmapButtonCtrl::GuiBitmapButtonCtrl()
    setExtent( 140, 30 );
    mMasked = false;
 
-   INIT_IMAGEASSET(Bitmap);
+   INIT_ASSET(Bitmap);
 }
 
 //-----------------------------------------------------------------------------
@@ -668,4 +668,4 @@ bool GuiBitmapButtonCtrl::pointInControl(const Point2I& parentCoordPoint)
       return Parent::pointInControl(parentCoordPoint);
 }
 
-DEF_IMAGEASSET_BINDS(GuiBitmapButtonCtrl, Bitmap);
+DEF_ASSET_BINDS(GuiBitmapButtonCtrl, Bitmap);

Engine/source/gui/buttons/guiBitmapButtonCtrl.h

@@ -119,7 +119,7 @@ class GuiBitmapButtonCtrl : public GuiButtonCtrl
       BitmapMode mBitmapMode;
 
       DECLARE_IMAGEASSET(GuiBitmapButtonCtrl, Bitmap, onBitmapChange, GFXDefaultGUIProfile);
-      DECLARE_IMAGEASSET_SETGET(GuiBitmapButtonCtrl, Bitmap);
+      DECLARE_ASSET_SETGET(GuiBitmapButtonCtrl, Bitmap);
       
       /// alpha masking
       bool mMasked;