Merge branch 'Preview4_0' of https://github.com/TorqueGameEngines/Torque3D into Preview4_0_MenuUIRework

Engine/source/T3D/assets/ImageAsset.cpp

@@ -103,7 +103,7 @@ EndImplementEnumType;
 
 
 //-----------------------------------------------------------------------------
-ImageAsset::ImageAsset() : AssetBase(), mImage(nullptr), mUseMips(true), mIsHDRImage(false), mIsValidImage(false)
+ImageAsset::ImageAsset() : AssetBase(), mImage(nullptr), mUseMips(true), mIsHDRImage(false), mIsValidImage(false), mImageType(Albedo)
 {
    mImageFileName = StringTable->EmptyString();
 }
@@ -239,6 +239,50 @@ const char* ImageAsset::getImageInfo()
    return "";
 }
 
+const char* ImageAsset::getImageTypeNameFromType(ImageAsset::ImageTypes type)
+{
+   // must match ImageTypes order
+   static const char* _names[] = {
+      "Albedo"
+      "Normal"
+      "Composite"
+      "GUI"
+      "Roughness"
+      "AO"
+      "Metalness"
+      "Glow"
+      "Particle"
+      "Decal"
+      "Cubemap"
+   };
+
+   if (type < 0 || type >= ImageTypeCount)
+   {
+      Con::errorf("ImageAsset::getAdapterNameFromType - Invalid ImageType, defaulting to Albedo");
+      return _names[Albedo];
+   }
+
+   return _names[type];
+}
+
+ImageAsset::ImageTypes ImageAsset::getImageTypeFromName(const char* name)
+{
+   S32 ret = -1;
+   for (S32 i = 0; i < ImageTypeCount; i++)
+   {
+      if (!dStricmp(getImageTypeNameFromType((ImageTypes)i), name))
+         ret = i;
+   }
+
+   if (ret == -1)
+   {
+      Con::errorf("ImageAsset::getImageTypeFromName - Invalid ImageType name, defaulting to Albedo");
+      ret = Albedo;
+   }
+
+   return (ImageTypes)ret;
+}
+
 DefineEngineMethod(ImageAsset, getImageFilename, const char*, (), ,
    "Creates an instance of the given GameObject given the asset definition.\n"
    "@return The GameObject entity created from the asset.")

Engine/source/T3D/assets/ImageAsset.h

@@ -65,6 +65,7 @@ public:
       Particle = 8,
       Decal = 9,
       Cubemap = 10,
+      ImageTypeCount = 11
    };
 
 protected:
@@ -100,6 +101,11 @@ public:
 
    const char* getImageInfo();
 
+   static const char* getImageTypeNameFromType(ImageTypes type);
+   static ImageTypes getImageTypeFromName(const char* name);
+
+   void setImageType(ImageTypes type) { mImageType = type; }
+
 protected:
    virtual void            initializeAsset(void);
    virtual void            onAssetRefresh(void);

Engine/source/T3D/assets/ShapeAsset.cpp

@@ -44,6 +44,7 @@
 
 // Debug Profiling.
 #include "platform/profiler.h"
+#include "T3D/assets/assetImporter.h"
 
 //-----------------------------------------------------------------------------
 
@@ -329,19 +330,21 @@ bool ShapeAsset::getAssetByFilename(StringTableEntry fileName, AssetPtr<ShapeAss
       Con::warnf("ShapeAsset::getAssetByFilename - Attempted to in-place import a shapefile(%s) that had no associated asset", fileName);
 #endif
 
-      ConsoleValueRef result = Con::executef("importLooseFile", fileName, true);
-
-      if (result.getBoolValue())
+      AssetImporter* autoAssetImporter;
+      if (!Sim::findObject("autoAssetImporter", autoAssetImporter))
       {
-         StringTableEntry resultingAssetId = StringTable->insert(Con::getVariable("$importedLooseFileAsset"));
+         autoAssetImporter = new AssetImporter();
+         autoAssetImporter->registerObject("autoAssetImporter");
+      }
 
-         if (resultingAssetId != StringTable->EmptyString())
-         {
-            shapeAsset->setAssetId(resultingAssetId);
+      StringTableEntry resultingAssetId = autoAssetImporter->autoImportFile(fileName);
 
-            if (!shapeAsset->isNull())
-               return true;
-         }
+      if (resultingAssetId != StringTable->EmptyString())
+      {
+         shapeAsset->setAssetId(resultingAssetId);
+
+         if (!shapeAsset->isNull())
+            return true;
       }
 
       //Didn't work, so have us fall back to a placeholder asset
@@ -375,17 +378,19 @@ StringTableEntry ShapeAsset::getAssetIdByFilename(StringTableEntry fileName)
       Con::warnf("ShapeAsset::getAssetByFilename - Attempted to in-place import a shapefile(%s) that had no associated asset", fileName);
 #endif
 
-      ConsoleValueRef result = Con::executef("importLooseFile", fileName, true);
-
-      if (result.getBoolValue())
+      AssetImporter* autoAssetImporter;
+      if (!Sim::findObject("autoAssetImporter", autoAssetImporter))
       {
-         StringTableEntry resultingAssetId = StringTable->insert(Con::getVariable("$importedLooseFileAsset"));
+         autoAssetImporter = new AssetImporter();
+         autoAssetImporter->registerObject("autoAssetImporter");
+      }
 
-         if (resultingAssetId != StringTable->EmptyString())
-         {
-            shapeAssetId = resultingAssetId;
-            return shapeAssetId;
-         }
+      StringTableEntry resultingAssetId = autoAssetImporter->autoImportFile(fileName);
+
+      if (resultingAssetId != StringTable->EmptyString())
+      {
+         shapeAssetId = resultingAssetId;
+         return shapeAssetId;
       }
 
       //Didn't work, so have us fall back to a placeholder asset

Engine/source/T3D/assets/assetImporter.h

@@ -0,0 +1,777 @@
+#pragma once
+
+#include "assets/assetPtr.h"
+#include "assets/assetManager.h"
+#include "module/moduleManager.h"
+#include "util/settings.h"
+#include "gui/controls/guiTreeViewCtrl.h"
+
+/// <summary>
+/// AssetImportConfig is a SimObject derived object intended to act as a container for all the necessary configuration data when running the Asset Importer.
+/// It dictates if and how any given asset type will be processed when running an import action. This is because the Asset Importer utilizes a lot of informed logic
+/// to try and automate as much of the import process as possible. In theory, you would run the import on a given file, and based on your config the importer will do
+/// everything from importing the designated file, as well as finding and importing any associated files such as images or materials, and prepping the objects at time
+/// of import to avoid as much manual post-processing as possible.
+/// </summary>
+class AssetImportConfig : public SimObject
+{
+   //General Settings
+public:
+   /// <summary>
+   /// Duplicate Asset Auto-Resolution Action. Options are None, AutoPrune, AutoRename
+   /// </summary>
+   String DuplicatAutoResolution;
+
+   /// <summary>
+   /// Indicates if warnings should be treated as errors.
+   /// </summary>
+   bool WarningsAsErrors;
+
+   /// <summary>
+   /// Indicates if importing should be prevented from completing if any errors are detected at all
+   /// </summary>
+   bool PreventImportWithErrors;
+
+   /// <summary>
+   /// Should the importer automatically prompt to find missing files if they are not detected automatically by the importer
+   /// </summary>
+   bool AutomaticallyPromptMissingFiles;
+   //
+
+   //
+   //Mesh Settings
+   /// <summary>
+   /// Indicates if this config supports importing meshes
+   /// </summary>
+   bool ImportMesh;
+
+   /// <summary>
+   /// Indicates if the up axis in the model file should be overridden 
+   /// </summary>
+   bool DoUpAxisOverride;
+
+   /// <summary>
+   /// If overriding, what axis should be used as up. Options are X_AXIS, Y_AXIS, Z_AXIS
+   /// </summary>
+   String UpAxisOverride;
+
+   /// <summary>
+   /// Indicates if the scale in the model file should be overridden 
+   /// </summary>
+   bool DoScaleOverride;
+
+   /// <summary>
+   /// If overriding, what scale should be used
+   /// </summary>
+   F32 ScaleOverride;
+
+   /// <summary>
+   /// Indicates if scale of nodes should be ignored
+   /// </summary>
+   bool IgnoreNodeScale;
+
+   /// <summary>
+   /// Indicates if the center of the model file should be automatically recentered
+   /// </summary>
+   bool AdjustCenter;
+
+   /// <summary>
+   /// Indicates if the floor height of the model file should be automatically zero'd
+   /// </summary>
+   bool AdjustFloor;
+
+   /// <summary>
+   /// Indicates if submeshes should be collapsed down into a single main mesh
+   /// </summary>
+   bool CollapseSubmeshes;
+
+   /// <summary>
+   /// Indicates what LOD mode the model file should utilize to process out LODs. Options are TrailingNumber, DetectDTS, SingleSize
+   /// </summary>
+   String LODType;
+
+   //ImportAssetConfigSettingsList.addNewConfigSetting("TrailingNumber", "Trailing Number", "float", "", "2", "", "Mesh");
+   /// <summary>
+   /// A list of what nodes should be guaranteed to be imported if found in the model file. Separated by either , or ;
+   /// </summary>
+   String ImportedNodes;
+
+   /// <summary>
+   /// A list of what nodes should be guaranteed to not be imported if found in the model file. Separated by either , or ;
+   /// </summary>
+   String IgnoreNodes;
+
+   /// <summary>
+   /// A list of what mesh objects should be guaranteed to be imported if found in the model file. Separated by either , or ;
+   /// </summary>
+   String ImportMeshes;
+
+   /// <summary>
+   /// A list of what mesh objects should be guaranteed to not be imported if found in the model file. Separated by either , or ;
+   /// </summary>
+   String IgnoreMeshes;
+
+   //Assimp/Collada params
+   /// <summary>
+   /// Flag to indicate the shape loader should convert to a left-handed coordinate system
+   /// </summary>
+   bool convertLeftHanded;
+
+   /// <summary>
+   /// Should the shape loader calculate tangent space values
+   /// </summary>
+   bool calcTangentSpace;
+
+   /// <summary>
+   /// Should the shape loader automatically prune redundant/duplicate materials
+   /// </summary>
+   bool removeRedundantMats;
+
+   /// <summary>
+   /// Should the shape loader auto-generate UV Coordinates for the mesh.
+   /// </summary>
+   bool genUVCoords;
+
+   /// <summary>
+   /// Should the UV coordinates be transformed.
+   /// </summary>
+   bool TransformUVs;
+
+   /// <summary>
+   /// Should the UV coordinates be flipped
+   /// </summary>
+   bool flipUVCoords;
+
+   /// <summary>
+   /// Should the shape loader automatically look for instanced submeshes in the model file
+   /// </summary>
+   bool findInstances;
+
+   /// <summary>
+   /// Should the shape loader limit the bone weights
+   /// </summary>
+   bool limitBoneWeights;
+
+   /// <summary>
+   /// Should the shape loader automatically merge identical/duplicate verts
+   /// </summary>
+   bool JoinIdenticalVerts;
+
+   /// <summary>
+   /// Should the shape loader reverse the winding order of the mesh's face indicies
+   /// </summary>
+   bool reverseWindingOrder;
+
+   /// <summary>
+   /// Should the normals on the model be inverted
+   /// </summary>
+   bool invertNormals;
+   //
+
+   //
+   //Materials
+   /// <summary>
+   /// Does this config allow for importing of materials
+   /// </summary>
+   bool ImportMaterials;
+
+   /// <summary>
+   /// When importing a material, should it automatically attempt to merge Roughness, AO and Metalness maps into a single, composited PBR Configuration map
+   /// </summary>
+   bool CreatePBRConfig;
+
+   /// <summary>
+   /// When generating a material off of an importing image, should the importer force appending a diffusemap suffix onto the end to avoid potential naming confusion.
+   /// e.g. MyCoolStuff.png is imported, generating MyCoolStuff material asset and MyCoolStuff_Diffuse image asset
+   /// </summary>
+   bool UseDiffuseSuffixOnOriginImage;
+
+   /// <summary>
+   /// Should the importer try and use existing material assets in the game directory if at all possible. (Not currently utilized)
+   /// </summary>
+   bool UseExistingMaterials;
+
+   /// <summary>
+   /// A list of material names that should not be imported. Separated by either , or ;
+   /// </summary>
+   String IgnoreMaterials;
+
+   /// <summary>
+   /// When processing a material asset, should the importer attempt to populate the various material maps on it by looking up common naming conventions for potentially relevent image files
+   /// e.g. If MyCoolStuff_Diffuse.png is imported, generating MyCoolStuff material, it would also find MyCoolStuff_Normal and MyCoolStuff_PBR images and map them to the normal and PBRConfig maps respectively automatically
+   /// </summary>
+   bool PopulateMaterialMaps;
+
+   //
+   //Animations
+   /// <summary>
+   /// Does this config allow for importing Shape Animations
+   /// </summary>
+   bool ImportAnimations;
+
+   /// <summary>
+   /// When importing a shape file, should the animations within be separated out into unique files
+   /// </summary>
+   bool SeparateAnimations;
+
+   /// <summary>
+   /// If separating animations out from a source file, what prefix should be added to the names for grouping association
+   /// </summary>
+   String SeparateAnimationPrefix;
+
+   /// <summary>
+   /// Defines the animation timing for the given animation sequence. Options are FrameTime, Seconds, Milliseconds
+   /// </summary>
+   String animTiming;
+
+   /// <summary>
+   /// The FPS of the animation sequence
+   /// </summary>
+   F32 animFPS;
+
+   //
+   //Collision
+   /// <summary>
+   /// Does this configuration generate collision geometry when importing. (Not currently enabled)
+   /// </summary>
+   bool GenerateCollisions;
+
+   /// <summary>
+   /// What sort of collision geometry is generated. (Not currently enabled)
+   /// </summary>
+   String GenCollisionType;
+
+   /// <summary>
+   /// What prefix is added to the collision geometry generated. (Not currently enabled)
+   /// </summary>
+   String CollisionMeshPrefix;
+
+   /// <summary>
+   /// Does this configuration generate Line of Sight collision geometry. (Not currently enabled)
+   /// </summary>
+   bool  GenerateLOSCollisions;
+
+   /// <summary>
+   /// What sort of Line of Sight collision geometry is generated. (Not currently enabled)
+   /// </summary>
+   String GenLOSCollisionType;
+
+   /// <summary>
+   /// What prefix is added to the Line of Sight collision geometry generated. (Not currently enabled)
+   /// </summary>
+   String LOSCollisionMeshPrefix;
+
+   //
+   //Images
+   /// <summary>
+   /// Does this configuration support importing images.
+   /// </summary>
+   bool importImages;
+
+   /// <summary>
+   /// What is the default ImageType images are imported as. Options are: N/A, Diffuse, Normal, Metalness, Roughness, AO, PBRConfig, GUI, Cubemap
+   /// </summary>
+   String ImageType;
+
+   /// <summary>
+   /// What type of suffixes are scanned to detect if an importing image is a diffuse map.
+   /// e.g. _Albedo or _Color
+   /// </summary>
+   String DiffuseTypeSuffixes;
+
+   /// <summary>
+   /// What type of suffixes are scanned to detect if an importing image is a normal map.
+   /// e.g. _Normal or _Norm
+   /// </summary>
+   String NormalTypeSuffixes;
+
+   /// <summary>
+   /// What type of suffixes are scanned to detect if an importing image is a metalness map.
+   /// e.g. _Metalness or _Metal
+   /// </summary>
+   String MetalnessTypeSuffixes;
+
+   /// <summary>
+   /// What type of suffixes are scanned to detect if an importing image is a roughness map.
+   /// e.g. _roughness or _rough
+   /// </summary>
+   String RoughnessTypeSuffixes;
+
+   /// <summary>
+   /// What type of suffixes are scanned to detect if an importing image is a smoothness map.
+   /// e.g. _smoothness or _smooth
+   /// </summary>
+   String SmoothnessTypeSuffixes;
+
+   /// <summary>
+   /// What type of suffixes are scanned to detect if an importing image is a ambient occlusion map.
+   /// e.g. _ambient or _ao
+   /// </summary>
+   String AOTypeSuffixes;
+
+   /// <summary>
+   /// What type of suffixes are scanned to detect if an importing image is a PBRConfig map.
+   /// e.g. _Composite or _PBR
+   /// </summary>
+   String PBRTypeSuffixes;
+
+   /// <summary>
+   /// Indicates what filter mode images imported with this configuration utilizes. Options are Linear, Bilinear, Trilinear
+   /// </summary>
+   String TextureFilteringMode;
+
+   /// <summary>
+   /// Indicates if images imported with this configuration utilize mipmaps
+   /// </summary>
+   bool UseMips;
+
+   /// <summary>
+   /// Indicates if images imported with this configuration are in an HDR format
+   /// </summary>
+   bool IsHDR;
+
+   /// <summary>
+   /// Indicates what amount of scaling images imported with this configuration use
+   /// </summary>
+   F32 Scaling;
+
+   /// <summary>
+   /// Indicates if images imported with this configuration are compressed
+   /// </summary>
+   bool ImagesCompressed;
+
+   /// <summary>
+   /// Indicates if images imported with this configuration generate a parent material for it as well
+   /// </summary>
+   bool GenerateMaterialOnImport;
+
+   //
+   //Sounds
+   /// <summary>
+   /// Indicates if sounds are imported with this configuration
+   /// </summary>
+   bool importSounds;
+
+   /// <summary>
+   /// Indicates what amount the volume is adjusted on sounds imported with this configuration
+   /// </summary>
+   F32 VolumeAdjust;
+
+   /// <summary>
+   /// Indicates what amount the pitch is adjusted on sounds imported with this configuration
+   /// </summary>
+   F32 PitchAdjust;
+
+   /// <summary>
+   /// Indicates if sounds imported with this configuration are compressed
+   /// </summary>
+   bool SoundsCompressed;
+
+public:
+   AssetImportConfig();
+   virtual ~AssetImportConfig();
+
+   /// Engine.
+   static void initPersistFields();
+
+   /// <summary>
+   /// Loads a configuration from a Settings object
+   /// @param configSettings, The Settings object to load from
+   /// @param configName, The name of the configuration setting to load from the setting object
+   /// </summary>
+   void loadImportConfig(Settings* configSettings, String configName);
+
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(AssetImportConfig);
+};
+
+/// <summary>
+/// AssetImportConfig is a SimObject derived object that represents and holds information for an importing asset. They are generated and processed by the AssetImporter
+/// </summary>
+class AssetImportObject : public SimObject
+{
+   typedef SimObject Parent;
+
+public:
+   /// <summary>
+   /// What type is the importing asset
+   /// </summary>
+   String assetType;
+
+   /// <summary>
+   /// What is the source file path of the importing asset
+   /// </summary>
+   Torque::Path filePath;
+
+   /// <summary>
+   /// What is the asset's name
+   /// </summary>
+   String assetName;
+
+   /// <summary>
+   /// What is the original, unmodified by processing, asset name
+   /// </summary>
+   String cleanAssetName;
+
+   /// <summary>
+   /// What is the name of the module this asset will be importing into
+   /// </summary>
+   String moduleName;
+
+   /// <summary>
+   /// What is the current status of this asset item in it's import process
+   /// </summary>
+   String status;
+
+   /// <summary>
+   /// If there is a warning or error status, what type is the condition for this asset item
+   /// </summary>
+   String statusType;
+
+   /// <summary>
+   /// What is the articulated information of the status of the asset. Contains the error or warning log data.
+   /// </summary>
+   String statusInfo;
+
+   /// <summary>
+   /// Is the asset item currently flagged as dirty
+   /// </summary>
+   bool dirty;
+
+   /// <summary>
+   /// Is this asset item marked to be skipped. If it is, it's usually due to being marked as deleted
+   /// </summary>
+   bool skip;
+
+   /// <summary>
+   /// Has the asset item been processed
+   /// </summary>
+   bool processed;
+
+   /// <summary>
+   /// Is this specific asset item generated as part of the import process of another item
+   /// </summary>
+   bool generatedAsset;
+
+   /// <summary>
+   /// What, if any, importing asset item is this item's parent
+   /// </summary>
+   AssetImportObject* parentAssetItem;
+
+   /// <summary>
+   /// What, if any, importing asset item are children of this item
+   /// </summary>
+   Vector< AssetImportObject*> childAssetItems;
+
+   /// <summary>
+   /// What is the ultimate asset taml file path for this import item
+   /// </summary>
+   String tamlFilePath;
+
+   //
+   /// <summary>
+   /// Specific to ImageAsset type
+   /// What is the image asset's suffix type. Options are: Albedo, Normal, Roughness, AO, Metalness, PBRConfig
+   /// </summary>
+   String imageSuffixType;
+
+   //
+   /// <summary>
+   /// Specific to ShapeAsset type
+   /// Processed information about the shape file. Contains numbers and lists of meshes, materials and animations
+   /// </summary>
+   GuiTreeViewCtrl* shapeInfo;
+
+public:
+   AssetImportObject();
+   virtual ~AssetImportObject();
+
+   /// Engine.
+   static void initPersistFields();
+
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(AssetImportObject);
+};
+
+/// <summary>
+/// AssetImporter is a SimObject derived object that processed and imports files and turns them into assets if they are of valid types.
+/// Utilizes an AssetImportConfig to inform the importing process's behavior.
+/// </summary>
+class AssetImporter : public SimObject
+{
+   typedef SimObject Parent;
+
+   /// <summary>
+   /// The import configuration that is currently being utilized
+   /// </summary>
+   AssetImportConfig activeImportConfig;
+
+   /// <summary>
+   /// A log of all the actions that have been performed by the importer
+   /// </summary>
+   Vector<String> activityLog;
+
+   /// <summary>
+   /// A list of AssetImportObjects that are to be imported
+   /// </summary>
+   Vector<AssetImportObject*> importingAssets;
+
+   /// <summary>
+   /// A list of file paths that are to be imported. These are only used for resetting purposes;
+   /// </summary>
+   Vector<Torque::Path> originalImportingFiles;
+
+   /// <summary>
+   /// The Id of the module the assets are to be imported into
+   /// </summary>
+   String targetModuleId;
+
+   /// <summary>
+   /// The path any imported assets are placed in as their destination
+   /// </summary>
+   String targetPath;
+
+   /// <summary>
+   /// Are there any issues with any of the current import asset items
+   /// </summary>
+   bool importIssues;
+
+   /// <summary>
+   /// Is this import action a reimport of an existing asset
+   /// </summary>
+   bool isReimport;
+
+   /// <summary>
+   /// Has the heirarchy of asset import items changed due to processing
+   /// </summary>
+   bool assetHeirarchyChanged;
+
+   /// <summary>
+   /// A string used for writing into the importLog
+   /// </summary>
+   char importLogBuffer[1024];
+
+public:
+   AssetImporter();
+   virtual ~AssetImporter();
+
+   /// Engine.
+   static void initPersistFields();
+
+   /// Declare Console Object.
+   DECLARE_CONOBJECT(AssetImporter);
+
+   /// <summary>
+   /// Sets the target path for the assets being imported to be deposited into
+   /// <para>@param pTargetPath, The filePath of the destination point assets are imported into</para>
+   /// </summary>
+   void setTargetPath(Torque::Path pTargetPath) { targetPath = pTargetPath; }
+
+   /// <summary>
+   /// Processes a file into an AssetImportObject and adds it to the session for importing
+   /// <para>@param filePath, The filePath of the file to be imported in as an asset</para>
+   /// <para>@return AssetImportObject that was created</para>
+   /// </summary>
+   AssetImportObject* addImportingFile(Torque::Path filePath);
+
+   /// <summary>
+   /// Adds an importing asset to the current session
+   /// <para>@param assetType, Type of the asset being imported</para>
+   /// <para>@param filePath, path of the file to be imported</para>
+   /// <para>@param parentItem, AssetImportObject that the new item is a child of. null if no parent</para>
+   /// <para>@param assetNameOverride, If not blank, will be the new item's assetName instead of being created off of the filePath</para>
+   /// <para>@return AssetImportObject that was created</para>
+   /// </summary>
+   AssetImportObject* addImportingAsset(String assetType, Torque::Path filePath, AssetImportObject* parentItem, String assetNameOverride);
+
+   /// <summary>
+   /// Deletes the asset item from the import session. Affects the item's children as well
+   /// <para>@param assetItem, asset item to be marked as deleted</para>
+   /// </summary>
+   void deleteImportingAsset(AssetImportObject* assetItem);
+
+   /// <summary>
+   /// Finds an asset item in the session if it exists, by name
+   /// <para>@param assetName, Asset name to find</para>
+   /// <para>@param assetItem, if null, will loop over and recurse the main import asset items, if a specific AssetImportObject is passed in, it will recurse it's children</para>
+   /// <para>@return AssetImportObject that was found</para>
+   /// </summary>
+   AssetImportObject* findImportingAssetByName(String assetName, AssetImportObject* assetItem = nullptr);
+
+   /// <summary>
+   /// Finds the module associated with a given file path
+   /// <para>@param filePath, File path to parse the the module from</para>
+   /// <para>@return ModuleDefinition that was found</para>
+   /// </summary>
+   ModuleDefinition* getModuleFromPath(Torque::Path filePath);
+
+   /// <summary>
+   /// Parses an asset's name to try and find if any of the import config's suffix lists match to it
+   /// <para>@param assetName, Asset name to parse any image suffix out of</para>
+   /// <para>@param suffixType, output, The suffix type that was matched to the asset name</para>
+   /// <para>@return suffix that matched to the asset name</para>
+   /// </summary>
+   String parseImageSuffixes(String assetName, String* suffixType);
+
+   /// <summary>
+   /// Parses a file path to determine its asset type
+   /// <para>@param filePath, File path to parse</para>
+   /// <para>@return The asset type as a string</para>
+   /// </summary>
+   String getAssetTypeByFile(Torque::Path filePath);
+
+   /// <summary>
+   /// Resets the import session to a clean slate. This will clear all existing AssetImportObjects and the activity log
+   /// and then re-process the original filePaths again.
+   /// </summary>
+   void resetImportSession();
+
+   /// <summary>
+   /// Get the number of lines in the activity log
+   /// <para>@return Line count as S32</para>
+   /// </summary>
+   S32 getActivityLogLineCount();
+
+   /// <summary>
+   /// Gets the log line at a given index
+   /// <para>@param line, line in the log to get</para>
+   /// <para>@return The log line as a string</para>
+   /// </summary>
+   String getActivityLogLine(U32 line);
+
+   /// <summary>
+   /// Dumps the entire current activity log to the console.
+   /// </summary>
+   void dumpActivityLog();
+
+   /// <summary>
+   /// Gets the number of top-level asset items in the current import session(doesn't count children)
+   /// <para>@return Number of children</para>
+   /// </summary>
+   S32 getAssetItemCount();
+
+   /// <summary>
+   /// Get the top-level asset item in the current import session at the requested index
+   /// <para>@param index, The index of the item array to get</para>
+   /// <para>@return The AssetImportObject at the index</para>
+   /// </summary>
+   AssetImportObject* getAssetItem(U32 index);
+
+   /// <summary>
+   /// Gets the number of child asset items of a given AssetImportObject
+   /// <para>@param assetItem, The AssetImportObject to get the number of child items for</para>
+   /// <para>@return Number of children</para>
+   /// </summary>
+   S32 getAssetItemChildCount(AssetImportObject* assetItem);
+
+   /// <summary>
+   /// Get the child asset item of a specific AssetImportObject at the requested index
+   /// <para>@param assetItem, The AssetImportObject to get the number of child items for</para>
+   /// <para>@param index, The index of the child item array to get</para>
+   /// <para>@return The AssetImportObject at the index</para>
+   /// </summary>
+   AssetImportObject* getAssetItemChild(AssetImportObject* assetItem, U32 index);
+
+   /// <summary>
+   /// Process AssetImportObject's to prepare them for importing.
+   /// <para>@param assetItem, If null, will loop over the top-level asset items list, if a specific item is provided, will process it's children</para>
+   /// </summary>
+   void processImportAssets(AssetImportObject* assetItem = nullptr);
+
+   /// <summary>
+   /// Process a specific AssetImportObject that is an ImageAsset type to prepare it for importing
+   /// <para>@param assetItem, The AssetImportObject to process</para>
+   /// </summary>
+   void processImageAsset(AssetImportObject* assetItem);
+
+   /// <summary>
+   /// Process a specific AssetImportObject that is an MaterialAsset type to prepare it for importing
+   /// <para>@param assetItem, The AssetImportObject to process</para>
+   /// </summary>
+   void processMaterialAsset(AssetImportObject* assetItem);
+
+   /// <summary>
+   /// Process a specific AssetImportObject that is an ShapeAsset type to prepare it for importing
+   /// <para>@param assetItem, The AssetImportObject to process</para>
+   /// </summary>
+   void processShapeAsset(AssetImportObject* assetItem);
+
+   /// <summary>
+   /// Process a specific ShapeAsset AssetImportObject with a material id in order to parse and handle the materials listed in the shape file
+   /// <para>@param assetItem, The AssetImportObject to process</para>
+   /// <para>@param materialItemId, The materialItemId in the shapeInfo to process</para>
+   /// </summary>
+   void processShapeMaterialInfo(AssetImportObject* assetItem, S32 materialItemId);
+
+   /// <summary>
+   /// Run through and validate assets for issues, such as name collisions
+   /// </summary>
+   bool validateAssets();
+
+   /// <summary>
+   /// Validate a specific asset item
+   /// <para>@param assetItem, The AssetImportObject to validate</para>
+   /// </summary>
+   void validateAsset(AssetImportObject* assetItem);
+
+   /// <summary>
+   /// Reset the validation status of asset items
+   /// <para>@param assetItem, If null, will loop over the top-level asset items list, if a specific item is provided, will reset it's children</para>
+   /// </summary>
+   void resetAssetValidationStatus(AssetImportObject* assetItem = nullptr);
+
+   /// <summary>
+   /// Checks asset items for any collisions in the current import session
+   /// <para>@param assetItemToCheckFor, The asset to check for collisions with</para>
+   /// <para>@param assetItem, if null, will loop over and recurse the main import asset items, if a specific AssetImportObject is passed in, it will recurse it's children</para>
+   /// <para>@return If a collision was detected</para>
+   /// </summary>
+   bool checkAssetForCollision(AssetImportObject* assetItemToCheckFor, AssetImportObject* assetItem = nullptr);
+
+   /// <summary>
+   /// Attempts to automatically resolve import issues according to the import config settings
+   /// <para>@param assetItem, The AssetImportObject to resolve</para>
+   /// </summary>
+   void resolveAssetItemIssues(AssetImportObject* assetItem);
+
+   /// <summary>
+   /// Runs the import process on a single file in-place. Intended primarily for autoimporting a loose file that's in the game directory.
+   /// <para>@param filePath, The filePath of the file to be imported in as an asset</para>
+   /// <para>@return AssetId of the asset that was imported. If import failed, it will be empty.</para>
+   /// </summary>
+   StringTableEntry autoImportFile(Torque::Path filePath);
+
+   /// <summary>
+   /// Runs the import process in the current session
+   /// <para>@param assetItem, if null, will loop over and recurse the main import asset items, if a specific AssetImportObject is passed in, it will recurse it's children</para>
+   /// </summary>
+   void importAssets(AssetImportObject* assetItem = nullptr);
+
+   /// <summary>
+   /// Runs the import processing on a specific ImageAsset item
+   /// <para>@param assetItem, The asset item to import</para>
+   /// <para>@return AssetId of the asset that was imported. If import failed, it will be empty.</para>
+   /// </summary>
+   Torque::Path importImageAsset(AssetImportObject* assetItem);
+
+   /// <summary>
+   /// Runs the import processing on a specific MaterialAsset item
+   /// <para>@param assetItem, The asset item to import</para>
+   /// <para>@return AssetId of the asset that was imported. If import failed, it will be empty.</para>
+   /// </summary>
+   Torque::Path importMaterialAsset(AssetImportObject* assetItem);
+
+   /// <summary>
+   /// Runs the import processing on a specific ShapeAsset item
+   /// <para>@param assetItem, The asset item to import</para>
+   /// <para>@return AssetId of the asset that was imported. If import failed, it will be empty.</para>
+   /// </summary>
+   Torque::Path importShapeAsset(AssetImportObject* assetItem);   
+
+   //
+   /// <summary>
+   /// Gets the currently active import configuration
+   /// <para>@return Current AssetImportConfig the importer is using</para>
+   /// </summary>
+   AssetImportConfig* getImportConfig() { return &activeImportConfig; }
+};

Engine/source/T3D/assets/assetImporter_ScriptBinding.h

@@ -0,0 +1,140 @@
+#pragma once
+
+#include "console/engineAPI.h"
+#include "assetImporter.h"
+
+//Console Functions
+
+DefineEngineMethod(AssetImportConfig, loadImportConfig, void, (Settings* configSettings, String configName), (nullAsType<Settings*>(), ""),
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->loadImportConfig(configSettings, configName);
+}
+
+DefineEngineMethod(AssetImporter, setTargetPath, void, (String path), (""),
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->setTargetPath(path);
+}
+
+DefineEngineMethod(AssetImporter, resetImportSession, void, (), ,
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->resetImportSession();
+}
+
+DefineEngineMethod(AssetImporter, dumpActivityLog, void, (), ,
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->dumpActivityLog();
+}
+
+DefineEngineMethod(AssetImporter, getActivityLogLineCount, S32, (),,
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->getActivityLogLineCount();
+}
+
+DefineEngineMethod(AssetImporter, getActivityLogLine, String, (S32 i), (0),
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->getActivityLogLine(0);
+}
+
+DefineEngineMethod(AssetImporter, autoImportFile, String, (String path), (""),
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->autoImportFile(path);
+}
+
+DefineEngineMethod(AssetImporter, addImportingFile, AssetImportObject*, (String path), (""),
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->addImportingFile(path);
+}
+
+DefineEngineMethod(AssetImporter, processImportingAssets, void, (), ,
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->processImportAssets();
+}
+
+DefineEngineMethod(AssetImporter, validateImportingAssets, bool, (), ,
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->validateAssets();
+}
+
+DefineEngineMethod(AssetImporter, resolveAssetItemIssues, void, (AssetImportObject* assetItem), (nullAsType< AssetImportObject*>()),
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   object->resolveAssetItemIssues(assetItem);
+}
+
+DefineEngineMethod(AssetImporter, importAssets, void, (),,
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->importAssets();
+}
+
+DefineEngineMethod(AssetImporter, getAssetItemCount, S32, (),,
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->getAssetItemCount();
+}
+
+DefineEngineMethod(AssetImporter, getAssetItem, AssetImportObject*, (S32 index), (0),
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->getAssetItem(index);
+}
+
+DefineEngineMethod(AssetImporter, getAssetItemChildCount, S32, (AssetImportObject* assetItem), (nullAsType< AssetImportObject*>()),
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   if (assetItem == nullptr)
+      return 0;
+
+   return object->getAssetItemChildCount(assetItem);
+}
+
+DefineEngineMethod(AssetImporter, getAssetItemChild, AssetImportObject*, (AssetImportObject* assetItem, S32 index), (nullAsType< AssetImportObject*>(), 0),
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   if (assetItem == nullptr)
+      return nullptr;
+
+   return object->getAssetItemChild(assetItem, index);
+}
+
+
+/*DefineEngineFunction(enumColladaForImport, bool, (const char* shapePath, const char* ctrl, bool loadCachedDts), ("", "", true),
+   "(string shapePath, GuiTreeViewCtrl ctrl) Collect scene information from "
+   "a COLLADA file and store it in a GuiTreeView control. This function is "
+   "used by the COLLADA import gui to show a preview of the scene contents "
+   "prior to import, and is probably not much use for anything else.\n"
+   "@param shapePath COLLADA filename\n"
+   "@param ctrl GuiTreeView control to add elements to\n"
+   "@param loadCachedDts dictates if it should try and load the cached dts file if it exists"
+   "@return true if successful, false otherwise\n"
+   "@ingroup Editors\n"
+   "@internal")
+{
+   return enumColladaForImport(shapePath, ctrl, loadCachedDts);
+}*/

Engine/source/T3D/cameraSpline.cpp

@@ -36,6 +36,7 @@ CameraSpline::Knot::Knot()
    mSpeed = 0.0f;
    mType = NORMAL;
    mPath = SPLINE;
+   mDistance = 0.0f;
    prev = NULL; next = NULL;
 };
 
@@ -46,6 +47,7 @@ CameraSpline::Knot::Knot(const Knot &k)
    mSpeed    = k.mSpeed;
    mType = k.mType;
    mPath = k.mPath;
+   mDistance = k.mDistance;
    prev = NULL; next = NULL;
 }
 
@@ -56,6 +58,7 @@ CameraSpline::Knot::Knot(const Point3F &p, const QuatF &r, F32 s, Knot::Type typ
    mSpeed    = s;
    mType = type;
    mPath = path;
+   mDistance = 0.0f;
    prev = NULL; next = NULL;
 }
 

Engine/source/T3D/convexShape.cpp

@@ -92,12 +92,12 @@ void ConvexShapeCollisionConvex::getFeatures( const MatrixF &mat, const VectorF
 	if ( pShape->mGeometry.points.empty() )
 	{
 		cf->material = 0;
-		cf->object = NULL;
+		cf->mObject = NULL;
 		return;
 	}
 
 	cf->material = 0;
-	cf->object = mObject;
+	cf->mObject = mObject;
 
 	// Simple implementation... Add all Points, Edges and Faces.
 

Engine/source/T3D/convexShape.h

@@ -50,7 +50,7 @@ protected:
 
 public:
 
-	ConvexShapeCollisionConvex() { mType = ConvexShapeCollisionConvexType; }
+   ConvexShapeCollisionConvex() { pShape = NULL; mType = ConvexShapeCollisionConvexType; }
 
 	ConvexShapeCollisionConvex( const ConvexShapeCollisionConvex& cv ) {
 		mType      = ConvexShapeCollisionConvexType;
@@ -297,4 +297,4 @@ protected:
 
 };
 
-#endif // _CONVEXSHAPE_H_
+#endif // _CONVEXSHAPE_H_

Engine/source/T3D/debris.cpp

@@ -533,6 +533,8 @@ Debris::Debris()
    mInitialTrans.identity();
    mRadius = 0.2f;
    mStatic = false;
+   mElasticity = 0.5f;
+   mFriction = 0.5f;
 
    dMemset( mEmitterList, 0, sizeof( mEmitterList ) );
 

Engine/source/T3D/decal/decalInstance.cpp

@@ -24,6 +24,23 @@
 #include "T3D/decal/decalInstance.h"
 #include "scene/sceneRenderState.h"
 
+DecalInstance::DecalInstance()
+   : mDataBlock(NULL),
+   mRotAroundNormal(0.0f),
+   mSize(0.0f),
+   mCreateTime(0),
+   mVisibility(1.0f),
+   mLastAlpha(1.0f),
+   mTextureRectIdx(0),
+   mVerts(NULL),
+   mIndices(NULL),
+   mVertCount(0),
+   mIndxCount(0),
+   mFlags(0),
+   mRenderPriority(0),
+   mId(-1),
+   mCustomTex(NULL)
+{}
 void DecalInstance::getWorldMatrix( MatrixF *outMat, bool flip )
 {
    outMat->setPosition( mPosition );

Engine/source/T3D/decal/decalInstance.h

@@ -87,7 +87,7 @@ class DecalInstance
       /// Calculates the size of this decal onscreen in pixels, used for LOD.
       F32 calcPixelSize( U32 viewportHeight, const Point3F &cameraPos, F32 worldToScreenScaleY ) const;
    		
-	   DecalInstance() : mId(-1) {}   
+      DecalInstance();
 };
 
 #endif // _DECALINSTANCE_H_

Engine/source/T3D/fx/explosion.cpp

@@ -238,6 +238,9 @@ ExplosionData::ExplosionData()
    explosionScale.set(1.0f, 1.0f, 1.0f);
    playSpeed = 1.0f;
 
+   explosionShape = NULL;
+   explosionAnimation = -1;
+
    dMemset( emitterList, 0, sizeof( emitterList ) );
    dMemset( emitterIDList, 0, sizeof( emitterIDList ) );
    dMemset( debrisList, 0, sizeof( debrisList ) );
@@ -924,6 +927,7 @@ Explosion::Explosion()
    ss_index = 0;
    mDataBlock = 0;
    soundProfile_clone = 0;
+   mRandomVal = 0;
 }
 
 Explosion::~Explosion()
@@ -962,7 +966,7 @@ void Explosion::setInitialState(const Point3F& point, const Point3F& normal, con
 void Explosion::initPersistFields()
 {
    Parent::initPersistFields();
-
+   addField("initialNormal", TypePoint3F, Offset(mInitialNormal, Explosion), "Initial starting Normal.");
    //
 }
 

Engine/source/T3D/fx/fxFoliageReplicator.cpp

@@ -286,6 +286,7 @@ fxFoliageReplicator::fxFoliageReplicator()
    // Reset Foliage Count.
    mCurrentFoliageCount = 0;
 
+   dMemset(&mFrustumRenderSet, 0, sizeof(mFrustumRenderSet));
    // Reset Creation Area Angle Animation.
    mCreationAreaAngle = 0;
 
@@ -299,8 +300,15 @@ fxFoliageReplicator::fxFoliageReplicator()
 
    // Reset Frame Serial ID.
    mFrameSerialID = 0;
-
+   mQuadTreeLevels = 0;
+   mNextAllocatedNodeIdx = 0;
    mAlphaLookup = NULL;
+   mFadeInGradient = 0.0f;
+   mFadeOutGradient = 0.0f;
+   mGlobalSwayPhase = 0.0f;
+   mGlobalSwayTimeRatio = 1.0f;
+   mGlobalLightPhase = 0.0f;
+   mGlobalLightTimeRatio = 1.0f;
 
    mDirty = true;
 
@@ -317,6 +325,8 @@ fxFoliageReplicator::fxFoliageReplicator()
    mFoliageShaderTrueBillboardSC = NULL;
    mFoliageShaderGroundAlphaSC = NULL;
    mFoliageShaderAmbientColorSC = NULL;
+   mDiffuseTextureSC = NULL;
+   mAlphaMapTextureSC = NULL;
 
    mShaderData = NULL;
 }

Engine/source/T3D/fx/lightning.cpp

@@ -248,7 +248,7 @@ LightningData::LightningData()
       strikeTextureNames[i] = NULL;
       strikeTextures[i] = NULL;
    }
-
+   numThunders = 0;
    mNumStrikeTextures = 0;
 }
 
@@ -371,6 +371,7 @@ Lightning::Lightning()
    mNetFlags.set(Ghostable|ScopeAlways);
    mTypeMask |= StaticObjectType|EnvironmentObjectType;
 
+   mDataBlock = NULL;
    mLastThink = 0;
 
    mStrikeListHead  = NULL;
@@ -1033,6 +1034,16 @@ LightningBolt::LightningBolt()
    elapsedTime = 0.0f;
    lifetime = 1.0f;
    startRender = false;
+   endPoint.zero();
+   width = 1;
+   numMajorNodes = 10;
+   maxMajorAngle = 30.0f;
+   numMinorNodes = 4;
+   maxMinorAngle = 15.0f;
+   fadeTime = 0.2f;
+   renderTime = 0.125;
+   dMemset(&mMajorNodes, 0, sizeof(mMajorNodes));
+   percentFade = 0.0f;
 }
 
 //--------------------------------------------------------------------------

Engine/source/T3D/fx/particleEmitter.cpp

@@ -846,6 +846,7 @@ ParticleEmitterData::ParticleEmitterData(const ParticleEmitterData& other, bool
    textureName = other.textureName;
    textureHandle = other.textureHandle; // -- TextureHandle loads using textureName
    highResOnly = other.highResOnly;
+   glow = other.glow;
    renderReflection = other.renderReflection;
    fade_color = other.fade_color;
    fade_size = other.fade_size;
@@ -965,7 +966,7 @@ ParticleEmitter::ParticleEmitter()
    pos_pe.set(0,0,0);
    sort_priority = 0;
    mDataBlock = 0;
-   
+   std::fill_n(sizes, ParticleData::PDC_NUM_KEYS, 0.0f);
 #if defined(AFX_CAP_PARTICLE_POOLS)
    pool = 0;
 #endif 

Engine/source/T3D/fx/ribbon.cpp

@@ -170,6 +170,7 @@ void RibbonData::unpackData(BitStream* stream)
 //
 Ribbon::Ribbon()
 {
+   mDataBlock = NULL;
    mTypeMask |= StaticObjectType;
 
    VECTOR_SET_ASSOCIATION(mSegmentPoints);

Engine/source/T3D/fx/ribbonNode.h

@@ -37,9 +37,6 @@ class RibbonNodeData : public GameBaseData
 {
    typedef GameBaseData Parent;
 
-public:
-   F32 timeMultiple;
-
 public:
    RibbonNodeData();
    ~RibbonNodeData();

Engine/source/T3D/fx/splash.cpp

@@ -309,6 +309,7 @@ Splash::Splash()
 
    mDelayMS = 0;
    mCurrMS = 0;
+   mRandAngle = 0;
    mEndingMS = 1000;
    mActive = false;
    mRadius = 0.0;
@@ -319,7 +320,8 @@ Splash::Splash()
    mElapsedTime = 0.0;
 
    mInitialNormal.set( 0.0, 0.0, 1.0 );
-
+   mFade = 0;
+   mFog = 0;
    // Only allocated client side.
    mNetFlags.set( IsGhost );
 }

Engine/source/T3D/gameBase/gameBase.cpp

@@ -254,6 +254,7 @@ GameBase::GameBase()
    mTicksSinceLastMove = 0;
    mIsAiControlled = false;
 #endif
+   mCameraFov = 90.f;
 }
 
 GameBase::~GameBase()

Engine/source/T3D/gameBase/moveList.cpp

@@ -26,6 +26,7 @@
 
 MoveList::MoveList()
 {
+   mConnection = NULL;
    mControlMismatch = false;
    reset();
 }

Engine/source/T3D/guiMaterialPreview.cpp

@@ -61,6 +61,8 @@ GuiMaterialPreview::GuiMaterialPreview()
    // By default don't do dynamic reflection
    // updates for this viewport.
    mReflectPriority = 0.0f;
+   mMountedModel = NULL;
+   mSkinTag = 0;
 }
 
 GuiMaterialPreview::~GuiMaterialPreview()

Engine/source/T3D/lighting/IBLUtilities.cpp

@@ -138,6 +138,20 @@ namespace IBLUtilities
       GFXShaderConstHandle* prefilterMipSizeSC = prefilterShader->getShaderConstHandle("$mipSize");
       GFXShaderConstHandle* prefilterResolutionSC = prefilterShader->getShaderConstHandle("$resolution");
 
+      GFXStateBlockDesc desc;
+      desc.zEnable = false;
+      desc.samplersDefined = true;
+      desc.samplers[0].addressModeU = GFXAddressClamp;
+      desc.samplers[0].addressModeV = GFXAddressClamp;
+      desc.samplers[0].addressModeW = GFXAddressClamp;
+      desc.samplers[0].magFilter = GFXTextureFilterLinear;
+      desc.samplers[0].minFilter = GFXTextureFilterLinear;
+      desc.samplers[0].mipFilter = GFXTextureFilterLinear;
+
+      GFXStateBlockRef preStateBlock;
+      preStateBlock = GFX->createStateBlock(desc);
+      GFX->setStateBlock(preStateBlock);
+
       GFX->pushActiveRenderTarget();
       GFX->setShader(prefilterShader);
       GFX->setShaderConstBuffer(prefilterConsts);

Engine/source/T3D/physics/physicsForce.cpp

@@ -43,6 +43,7 @@ ConsoleDocClass( PhysicsForce,
 PhysicsForce::PhysicsForce()
    :
       mWorld( NULL ),
+      mForce(0.0f),
       mPhysicsTick( false ),
       mBody( NULL )
 {

Engine/source/T3D/player.cpp

@@ -311,6 +311,11 @@ PlayerData::PlayerData()
    jumpEnergyDrain = 0.0f;
    minJumpEnergy = 0.0f;
    jumpSurfaceAngle = 78.0f;
+   jumpSurfaceCos = mCos(mDegToRad(jumpSurfaceAngle));
+
+   for (U32 i = 0; i < NumRecoilSequences; i++)
+      recoilSequence[i] = -1;
+
    jumpDelay = 30;
    minJumpSpeed = 500.0f;
    maxJumpSpeed = 2.0f * minJumpSpeed;
@@ -370,6 +375,9 @@ PlayerData::PlayerData()
 
    actionCount = 0;
    lookAction = 0;
+   dMemset(spineNode, 0, sizeof(spineNode));
+
+   pickupDelta = 0.0f;
 
    // size of bounding box
    boxSize.set(1.0f, 1.0f, 2.3f);

Engine/source/T3D/rigidShape.cpp

@@ -253,6 +253,7 @@ RigidShapeData::RigidShapeData()
 
    dustEmitter = NULL;
    dustID = 0;
+   triggerDustHeight = 3.0;
    dustHeight = 1.0;
 
    dMemset( splashEmitterList, 0, sizeof( splashEmitterList ) );

Engine/source/T3D/shapeBase.cpp

@@ -3571,7 +3571,7 @@ Point3F ShapeBaseConvex::support(const VectorF& v) const
 void ShapeBaseConvex::getFeatures(const MatrixF& mat, const VectorF& n, ConvexFeature* cf)
 {
    cf->material = 0;
-   cf->object = mObject;
+   cf->mObject = mObject;
 
    TSShape::ConvexHullAccelerator* pAccel =
       pShapeBase->mShapeInstance->getShape()->getAccelerator(pShapeBase->mDataBlock->collisionDetails[hullId]);

Engine/source/T3D/shapeBase.h

@@ -111,7 +111,7 @@ class ShapeBaseConvex : public Convex
    Box3F       box;
 
   public:
-   ShapeBaseConvex() { mType = ShapeBaseConvexType; nodeTransform = 0; }
+   ShapeBaseConvex() :pShapeBase(NULL), transform(NULL), hullId(NULL), nodeTransform(0) { mType = ShapeBaseConvexType; }
    ShapeBaseConvex(const ShapeBaseConvex& cv) {
       mObject    = cv.mObject;
       pShapeBase = cv.pShapeBase;

Engine/source/T3D/shapeImage.cpp

@@ -134,6 +134,8 @@ ShapeBaseImageData::StateData::StateData()
    recoil = NoRecoil;
    sound = 0;
    emitter = NULL;
+   shapeSequence = NULL;
+   shapeSequenceScale = true;
    script = 0;
    ignoreLoadedForReady = false;
    
@@ -1396,6 +1398,7 @@ ShapeBase::MountedImage::MountedImage()
    dataBlock = 0;
    nextImage = InvalidImagePtr;
    delayTime = 0;
+   rDT = 0.0f;
    ammo = false;
    target = false;
    triggerDown = false;
@@ -1408,6 +1411,7 @@ ShapeBase::MountedImage::MountedImage()
    motion = false;
    lightStart = 0;
    lightInfo = NULL;
+   dMemset(emitter, 0, sizeof(emitter));
 
    for (U32 i=0; i<ShapeBaseImageData::MaxGenericTriggers; ++i)
    {

Engine/source/T3D/tsStatic.cpp

@@ -284,10 +284,17 @@ bool TSStatic::_setShapeName(void* obj, const char* index, const char* data)
          if (assetId == StringTable->insert("Core_Rendering:noShape"))
          {
             ts->mShapeName = data;
+            ts->mShapeAssetId = StringTable->EmptyString();
+
             return true;
          }
+         else
+         {
+            ts->mShapeAssetId = assetId;
+            ts->mShapeName = StringTable->EmptyString();
 
-         return false;
+            return false;
+         }
       }
     }
    else
@@ -295,7 +302,7 @@ bool TSStatic::_setShapeName(void* obj, const char* index, const char* data)
       ts->mShapeAsset = StringTable->EmptyString();
    }
 
-   return false;
+   return true;
 }
 
 bool TSStatic::_setFieldSkin(void* object, const char* index, const char* data)
@@ -1486,7 +1493,7 @@ void TSStaticPolysoupConvex::getPolyList(AbstractPolyList* list)
 void TSStaticPolysoupConvex::getFeatures(const MatrixF& mat, const VectorF& n, ConvexFeature* cf)
 {
    cf->material = 0;
-   cf->object = mObject;
+   cf->mObject = mObject;
 
    // For a tetrahedron this is pretty easy... first
    // convert everything into world space.

Engine/source/T3D/turret/aiTurretShape.cpp

@@ -119,6 +119,7 @@ AITurretShapeData::AITurretShapeData()
    }
    isAnimated = false;
    statesLoaded = false;
+   fireState = -1;
 }
 
 void AITurretShapeData::initPersistFields()

Engine/source/T3D/turret/turretShape.cpp

@@ -114,17 +114,21 @@ TurretShapeData::TurretShapeData()
 
    headingNode = -1;
    pitchNode = -1;
-
-   for (U32 i=0; i<NumMirrorDirectionNodes; ++i)
+   U32 i = 0;
+   for (i=0; i<NumMirrorDirectionNodes; ++i)
    {
       pitchNodes[i] = -1;
       headingNodes[i] = -1;
    }
 
-   for (U32 i=0; i<ShapeBase::MaxMountedImages; ++i)
+   for (i=0; i<ShapeBase::MaxMountedImages; ++i)
    {
       weaponMountNode[i] = -1;
    }
+   for (i = 0; i < NumRecoilSequences;i++)
+      recoilSequence[i] = -1;
+   pitchSequence = -1;
+   headingSequence = -1;
 }
 
 void TurretShapeData::initPersistFields()
@@ -284,6 +288,8 @@ TurretShape::TurretShape()
 
    // For the Item class
    mSubclassItemHandlesScene = true;
+   mRecoilThread = NULL;
+   mImageStateThread = NULL;
 }
 
 TurretShape::~TurretShape()

Engine/source/T3D/vehicles/flyingVehicle.cpp

@@ -322,6 +322,7 @@ ConsoleDocClass( FlyingVehicle,
 
 FlyingVehicle::FlyingVehicle()
 {
+   mDataBlock = NULL;
    mSteering.set(0,0);
    mThrottle = 0;
    mJetting = false;
@@ -332,6 +333,10 @@ FlyingVehicle::FlyingVehicle()
    mBackMaintainOn = false;
    mBottomMaintainOn = false;
    createHeightOn = false;
+   mCeilingFactor = 1.0f;
+   mThrustDirection = FlyingVehicle::ThrustForward;
+   for (U32 i=0;i< JetAnimCount;i++)
+      mJetSeq[i] = -1;
 
    for (S32 i = 0; i < JetAnimCount; i++)
       mJetThread[i] = 0;

Engine/source/T3D/vehicles/flyingVehicle.h

@@ -77,7 +77,6 @@ struct FlyingVehicleData: public VehicleData {
 
    // Initialized in preload
    ClippedPolyList rigidBody;
-   S32 surfaceCount;
    F32 maxSpeed;
 
    enum JetNodes {

Engine/source/T3D/vehicles/hoverVehicle.cpp

@@ -139,6 +139,7 @@ HoverVehicleData::HoverVehicleData()
    dustTrailID = 0;
    dustTrailOffset.set( 0.0f, 0.0f, 0.0f );
    dustTrailFreqMod = 15.0f;
+   maxThrustSpeed = 0;
    triggerTrailHeight = 2.5f;
 
    floatingGravMag = 1;
@@ -436,24 +437,29 @@ void HoverVehicleData::unpackData(BitStream* stream)
 //
 HoverVehicle::HoverVehicle()
 {
+   mDataBlock = NULL;
    // Todo: ScopeAlways?
    mNetFlags.set(Ghostable);
 
    mFloating      = false;
-   mForwardThrust = 0;
-   mReverseThrust = 0;
-   mLeftThrust    = 0;
-   mRightThrust   = 0;
+   mThrustLevel   = 0.0f;
+   mForwardThrust = 0.0f;
+   mReverseThrust = 0.0f;
+   mLeftThrust    = 0.0f;
+   mRightThrust   = 0.0f;
 
    mJetSound    = NULL;
    mEngineSound = NULL;
    mFloatSound  = NULL;
-
+   mThrustDirection = HoverVehicle::ThrustForward;
    mDustTrailEmitter = NULL;
 
    mBackMaintainOn = false;
    for (S32 i = 0; i < JetAnimCount; i++)
-      mJetThread[i] = 0;
+   {
+      mJetSeq[i] = -1;
+      mJetThread[i] = NULL;
+   }
 }
 
 HoverVehicle::~HoverVehicle()

Engine/source/T3D/vehicles/wheeledVehicle.cpp

@@ -304,7 +304,7 @@ WheeledVehicleData::WheeledVehicleData()
    brakeLightSequence = -1;
    steeringSequence = -1;
    wheelCount = 0;
-
+   dMemset(&wheel, 0, sizeof(wheel));
    for (S32 i = 0; i < MaxSounds; i++)
       sound[i] = 0;
 }

Engine/source/Verve/Extension/Game/VSpawnSphereSpawnTargetTrack.cpp

@@ -29,7 +29,9 @@ IMPLEMENT_CONOBJECT( VSpawnSphereSpawnTargetTrack );
 
 VSpawnSphereSpawnTargetTrack::VSpawnSphereSpawnTargetTrack( void )
 {
-    setLabel( "SpawnTargetTrack" );
+   mDespawnOnStop = false;
+   mDespawnOnLoop = false;
+   setLabel( "SpawnTargetTrack" );
 }
 
 void VSpawnSphereSpawnTargetTrack::initPersistFields( void )
@@ -152,4 +154,4 @@ void VSpawnSphereSpawnTargetTrack::despawnTargets( void )
         // Delete the Object.
         object->deleteObject();
     }
-}
+}

Engine/source/Verve/VActor/VActorPhysicsController.cpp

@@ -49,7 +49,8 @@ VActorPhysicsController::VActorPhysicsController( void ) :
         mControlState( k_NullControlState ),
         mMoveState( k_NullMove ),
         mVelocity( VectorF::Zero ),
-        mGravity( 0.f, 0.f, -9.8f )
+        mGravity( 0.f, 0.f, -9.8f ),
+        mOnGround(false)
 {
     // Void.
 }
@@ -1274,4 +1275,4 @@ void VActorPhysicsController::unpackUpdate( NetConnection *pConnection, BitStrea
         // Apply.
         setPosition( position );
     }
-}
+}

Engine/source/Verve/VPath/VPathEditor.h

@@ -199,7 +199,7 @@ private:
     public:
 
         VPathEditorEditPathAction( const UTF8 *pName = "" ) :
-                UndoAction( pName )
+                UndoAction( pName ), mEditor(NULL), mPath(NULL)
         {
             // Void.
         };
@@ -218,9 +218,11 @@ private:
     public:
 
         VPathEditorEditNodeAction( const UTF8 *pName = "" ) :
-                UndoAction( pName )
+                UndoAction( pName ), mEditor(NULL), mPath(NULL), mNodeIndex(0), mNodeWeight(0.0f)
         {
             // Void.
+           mNodeOrientation.Type = VPathNode::k_OrientationFree;
+           mNodeOrientation.Point = Point3F(0.0f, 0.0f, 0.0f);
         };
 
         VPathEditor               *mEditor;
@@ -290,4 +292,4 @@ namespace Utility
 
 //-----------------------------------------------------------------------------
 
-#endif // _VT_VPATHEDITOR_H_
+#endif // _VT_VPATHEDITOR_H_

Engine/source/afx/afxCamera.h

@@ -147,8 +147,6 @@ public:
   DECLARE_CATEGORY("AFX");
 
 private:          // 3POV SECTION
-  U32             mBlockers_mask_3pov;
-
   void            cam_update_3pov(F32 dt, bool on_server);
   bool            avoid_blocked_view(const Point3F& start, const Point3F& end, Point3F& newpos);
   bool            test_blocked_line(const Point3F& start, const Point3F& end);

Engine/source/afx/afxConstraint.cpp

@@ -1904,6 +1904,9 @@ afxEffectConstraint::afxEffectConstraint(afxConstraintMgr* mgr)
 {
   mEffect_name = ST_NULLSTRING;
   mEffect = 0;
+  mClip_tag = 0;
+  mIs_death_clip = false;
+  mLock_tag = 0;
 }
 
 afxEffectConstraint::afxEffectConstraint(afxConstraintMgr* mgr, StringTableEntry effect_name) 
@@ -1911,6 +1914,9 @@ afxEffectConstraint::afxEffectConstraint(afxConstraintMgr* mgr, StringTableEntry
 {
   mEffect_name = effect_name;
   mEffect = 0;
+  mClip_tag = 0;
+  mIs_death_clip = false;
+  mLock_tag = 0;
 }
 
 afxEffectConstraint::~afxEffectConstraint()

Engine/source/afx/afxEffectVector.cpp

@@ -98,6 +98,7 @@ afxEffectVector::afxEffectVector()
   mOn_server = false;
   mTotal_fx_dur = 0;
   mAfter_life = 0;
+  mPhrase_dur = 0;
 }
 
 afxEffectVector::~afxEffectVector()

Engine/source/afx/afxEffectWrapper.h

@@ -298,8 +298,6 @@ protected:
   bool              mIn_scope;
   bool              mIs_aborted;
 
-  U8                mEffect_flags;
-
   afxXM_Base*       mXfm_modifiers[MAX_XFM_MODIFIERS];
 
   F32               mLive_scale_factor;

Engine/source/afx/afxMagicMissile.cpp

@@ -168,13 +168,14 @@ afxMagicMissileData::afxMagicMissileData()
    impactForce = 0.0f;
 
 	armingDelay = 0;
-   fadeDelay = 20000 / 32;
-   lifetime = 20000 / 32;
 
    activateSeq = -1;
    maintainSeq = -1;
    */
 
+   lifetime = 20000 / 32;
+   fadeDelay = 20000 / 32;
+
    gravityMod = 1.0;
    /* From stock Projectile code...
    bounceElasticity = 0.999f;

Engine/source/afx/afxZodiacGroundPlaneRenderer_T3D.cpp

@@ -58,6 +58,10 @@ afxZodiacGroundPlaneRenderer::afxZodiacGroundPlaneRenderer()
    if (!master)
      master = this;
    shader_initialized = false;
+   zodiac_shader = NULL;
+   shader_consts = NULL;
+   projection_sc = NULL;
+   color_sc = NULL;
 }
 
 afxZodiacGroundPlaneRenderer::afxZodiacGroundPlaneRenderer(F32 renderOrder, F32 processAddOrder)
@@ -66,6 +70,10 @@ afxZodiacGroundPlaneRenderer::afxZodiacGroundPlaneRenderer(F32 renderOrder, F32
    if (!master)
      master = this;
    shader_initialized = false;
+   zodiac_shader = NULL;
+   shader_consts = NULL;
+   projection_sc = NULL;
+   color_sc = NULL;
 }
 
 afxZodiacGroundPlaneRenderer::~afxZodiacGroundPlaneRenderer()

Engine/source/afx/afxZodiacMeshRoadRenderer_T3D.cpp

@@ -58,6 +58,10 @@ afxZodiacMeshRoadRenderer::afxZodiacMeshRoadRenderer()
    if (!master)
      master = this;
    shader_initialized = false;
+   zodiac_shader = NULL;
+   shader_consts = NULL;
+   projection_sc = NULL;
+   color_sc = NULL;
 }
 
 afxZodiacMeshRoadRenderer::afxZodiacMeshRoadRenderer(F32 renderOrder, F32 processAddOrder)
@@ -66,6 +70,10 @@ afxZodiacMeshRoadRenderer::afxZodiacMeshRoadRenderer(F32 renderOrder, F32 proces
    if (!master)
      master = this;
    shader_initialized = false;
+   zodiac_shader = NULL;
+   shader_consts = NULL;
+   projection_sc = NULL;
+   color_sc = NULL;
 }
 
 afxZodiacMeshRoadRenderer::~afxZodiacMeshRoadRenderer()

Engine/source/afx/afxZodiacPolysoupRenderer_T3D.cpp

@@ -58,6 +58,10 @@ afxZodiacPolysoupRenderer::afxZodiacPolysoupRenderer()
    if (!master)
      master = this;
    shader_initialized = false;
+   zodiac_shader = NULL;
+   shader_consts = NULL;
+   projection_sc = NULL;
+   color_sc = NULL;
 }
 
 afxZodiacPolysoupRenderer::afxZodiacPolysoupRenderer(F32 renderOrder, F32 processAddOrder)
@@ -66,6 +70,10 @@ afxZodiacPolysoupRenderer::afxZodiacPolysoupRenderer(F32 renderOrder, F32 proces
    if (!master)
      master = this;
    shader_initialized = false;
+   zodiac_shader = NULL;
+   shader_consts = NULL;
+   projection_sc = NULL;
+   color_sc = NULL;
 }
 
 afxZodiacPolysoupRenderer::~afxZodiacPolysoupRenderer()

Engine/source/afx/afxZodiacTerrainRenderer_T3D.cpp

@@ -68,6 +68,10 @@ afxZodiacTerrainRenderer::afxZodiacTerrainRenderer()
    if (!master)
      master = this;
    shader_initialized = false;
+   zodiac_shader = NULL;
+   shader_consts = NULL;
+   projection_sc = NULL;
+   color_sc = NULL;
 }
 
 afxZodiacTerrainRenderer::afxZodiacTerrainRenderer(F32 renderOrder, F32 processAddOrder)
@@ -76,6 +80,10 @@ afxZodiacTerrainRenderer::afxZodiacTerrainRenderer(F32 renderOrder, F32 processA
    if (!master)
      master = this;
    shader_initialized = false;
+   zodiac_shader = NULL;
+   shader_consts = NULL;
+   projection_sc = NULL;
+   color_sc = NULL;
 }
 
 afxZodiacTerrainRenderer::~afxZodiacTerrainRenderer()

Engine/source/afx/ce/afxModel.cpp

@@ -105,6 +105,11 @@ afxModelData::afxModelData(const afxModelData& other, bool temp_clone) : GameBas
   customAmbientForSelfIllumination = other.customAmbientForSelfIllumination;
   customAmbientLighting = other.customAmbientLighting;
   shadowEnable = other.shadowEnable;
+
+  shadowSize = other.shadowSize;
+  shadowMaxVisibleDistance = other.shadowMaxVisibleDistance;
+  shadowProjectionDistance = other.shadowProjectionDistance;
+  shadowSphereAdjust = other.shadowSphereAdjust;
 }
 
 afxModelData::~afxModelData()
@@ -360,7 +365,7 @@ afxModel::afxModel()
   fade_amt = 1.0f;
   is_visible = true;
   sort_priority = 0;
-
+  mDataBlock = NULL;
   mNetFlags.set( IsGhost );
 }
 

Engine/source/afx/ce/afxMooring.cpp

@@ -133,6 +133,7 @@ afxMooring::afxMooring()
   chor_id = 0;
   hookup_with_chor = false;
   ghost_cons_name = ST_NULLSTRING;
+  mDataBlock = NULL;
 }
 
 afxMooring::afxMooring(U32 networking, U32 chor_id, StringTableEntry cons_name)
@@ -160,6 +161,7 @@ afxMooring::afxMooring(U32 networking, U32 chor_id, StringTableEntry cons_name)
   this->chor_id = chor_id;
   hookup_with_chor = false;
   this->ghost_cons_name = cons_name;
+  mDataBlock = NULL;
 }
 
 afxMooring::~afxMooring()
@@ -275,4 +277,4 @@ void afxMooring::onRemove()
   Parent::onRemove();
 }
 
-//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
+//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//

Engine/source/afx/ce/afxParticleEmitter.cpp

@@ -687,6 +687,7 @@ bool afxParticleEmitterDiscData::preload(bool server, String &errorStr)
 
 afxParticleEmitter::afxParticleEmitter()
 {
+  mDataBlock = NULL;
   pe_vector.set(0,0,1);
   pe_vector_norm.set(0,0,1);
   tpaths.clear();
@@ -1086,6 +1087,7 @@ void afxParticleEmitter::emitParticlesExt(const MatrixF& xfm, const Point3F& poi
 
 afxParticleEmitterVector::afxParticleEmitterVector()
 {
+   mDataBlock = NULL;
 }
 
 afxParticleEmitterVector::~afxParticleEmitterVector()
@@ -1151,6 +1153,7 @@ void afxParticleEmitterVector::sub_preCompute(const MatrixF& mat)
 
 afxParticleEmitterCone::afxParticleEmitterCone()
 {
+  mDataBlock = NULL;
   cone_v.set(0,0,1);
   cone_s0.set(0,0,1);
   cone_s1.set(0,0,1);
@@ -1266,6 +1269,7 @@ void afxParticleEmitterCone::sub_preCompute(const MatrixF& mat)
 
 afxParticleEmitterPath::afxParticleEmitterPath()
 {
+  mDataBlock = NULL;
   epaths.clear();
   epath_mults.clear();
   n_epath_points = 0;
@@ -1521,6 +1525,7 @@ void afxParticleEmitterPath::groundConformPoint(Point3F& point, const MatrixF& m
 
 afxParticleEmitterDisc::afxParticleEmitterDisc()
 {
+  mDataBlock = NULL;
   disc_v.set(0,0,1);
   disc_r.set(1,0,0);
 }

Engine/source/afx/ce/afxStaticShape.cpp

@@ -122,6 +122,7 @@ ConsoleDocClass( afxStaticShape,
 
 afxStaticShape::afxStaticShape()
 {
+  mDataBlock = NULL;
   mAFX_data = 0;
   mIs_visible = true;
   mChor_id = 0;
@@ -238,4 +239,4 @@ void afxStaticShape::prepRenderImage(SceneRenderState* state)
      Parent::prepRenderImage(state);
 }
 
-//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
+//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//

Engine/source/afx/ce/afxZodiac.cpp

@@ -114,6 +114,7 @@ afxZodiacData::afxZodiacData()
   grade_range_user.set(0.0f, 45.0f);
   afxZodiacData::convertGradientRangeFromDegrees(grade_range, grade_range_user);
   inv_grade_range = false;
+  zflags = 0;
 }
 
 afxZodiacData::afxZodiacData(const afxZodiacData& other, bool temp_clone) : GameBaseData(other, temp_clone)

Engine/source/afx/ce/afxZodiacPlane.cpp

@@ -61,7 +61,7 @@ afxZodiacPlaneData::afxZodiacPlaneData()
   color.set(1,1,1,1);
   blend_flags = BLEND_NORMAL;
   respect_ori_cons = false;
-
+  zflags = 0;
   double_sided = true;
   face_dir = FACES_UP;
   use_full_xfm = false;
@@ -310,4 +310,4 @@ void afxZodiacPlane::onRemove()
   Parent::onRemove();
 }
 
-//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
+//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//

Engine/source/afx/ea/afxEA_PhraseEffect.cpp

@@ -75,6 +75,7 @@ afxEA_PhraseEffect::afxEA_PhraseEffect()
 {
   phrase_fx_data = 0;
   active_phrases = &_phrases_a;
+  last_trigger_mask = 0;
 }
 
 afxEA_PhraseEffect::~afxEA_PhraseEffect()

Engine/source/afx/forces/afxF_Drag.cpp

@@ -60,7 +60,7 @@ class afxF_Drag : public afxForce
   typedef afxForce Parent;
 
 private:
-  afxF_DragData*  datablock;
+  afxF_DragData*  mDatablock;
   F32             air_friction_constant;
 
 public:
@@ -149,13 +149,14 @@ afxForceData* afxF_DragData::cloneAndPerformSubstitutions(const SimObject* owner
 
 afxF_Drag::afxF_Drag() : afxForce()
 {
+  mDatablock = NULL;
   air_friction_constant = 1.0f;
 }
 
 bool afxF_Drag::onNewDataBlock(afxForceData* dptr, bool reload)
 {
-  datablock = dynamic_cast<afxF_DragData*>(dptr);
-  if (!datablock || !Parent::onNewDataBlock(dptr, reload))
+   mDatablock = dynamic_cast<afxF_DragData*>(dptr);
+  if (!mDatablock || !Parent::onNewDataBlock(dptr, reload))
     return false;
 
   return true;
@@ -163,9 +164,9 @@ bool afxF_Drag::onNewDataBlock(afxForceData* dptr, bool reload)
 
 void afxF_Drag::start()
 {
-  air_friction_constant = 0.5f * datablock->drag_coefficient 
-                               * datablock->air_density 
-                               * datablock->cross_sectional_area;
+  air_friction_constant = 0.5f * mDatablock->drag_coefficient
+                               * mDatablock->air_density
+                               * mDatablock->cross_sectional_area;
   //Con::printf("Air Friction: %f", air_friction_constant);
 }
 

Engine/source/afx/forces/afxF_Gravity.cpp

@@ -58,7 +58,7 @@ class afxF_Gravity : public afxForce
   typedef afxForce Parent;
 
 private:
-  afxF_GravityData* datablock;
+  afxF_GravityData* mDatablock;
 
 public:
   /*C*/             afxF_Gravity();
@@ -133,12 +133,13 @@ afxForceData* afxF_GravityData::cloneAndPerformSubstitutions(const SimObject* ow
 
 afxF_Gravity::afxF_Gravity() : afxForce()
 {
+   mDatablock = NULL;
 }
 
 bool afxF_Gravity::onNewDataBlock(afxForceData* dptr, bool reload)
 {
-  datablock = dynamic_cast<afxF_GravityData*>(dptr);
-  if (!datablock || !Parent::onNewDataBlock(dptr, reload))
+   mDatablock = dynamic_cast<afxF_GravityData*>(dptr);
+  if (!mDatablock || !Parent::onNewDataBlock(dptr, reload))
     return false;
 
   return true;
@@ -146,7 +147,7 @@ bool afxF_Gravity::onNewDataBlock(afxForceData* dptr, bool reload)
 
 Point3F afxF_Gravity::evaluate(Point3F pos, Point3F v, F32 mass)
 {
-  return Point3F(0,0,-datablock->gravity)*mass;
+  return Point3F(0,0,-mDatablock->gravity)*mass;
 }
 
 

Engine/source/afx/util/afxAnimCurve.cpp

@@ -29,6 +29,8 @@
 afxAnimCurve::afxAnimCurve() : usable( false ), final_value( 0.0f ), start_value( 0.0f )
 {
 	evaluator = new afxHermiteEval();
+   final_time = 0.0f;
+   start_time = 0.0f;
 }
 
 afxAnimCurve::~afxAnimCurve()
@@ -277,4 +279,4 @@ void afxAnimCurve::printKey( int index )
 {
 	Key &k = keys[index];
 	Con::printf( "%f: %f", k.time, k.value );
-}
+}

Engine/source/afx/util/afxCurve3D.cpp

@@ -27,7 +27,7 @@
 #include "afx/util/afxCurveEval.h"
 #include "afx/util/afxCurve3D.h"
 
-afxCurve3D::afxCurve3D() : usable( false ), default_vector( 0, 0, 0 )
+afxCurve3D::afxCurve3D() : usable( false ), default_vector( 0, 0, 0 ), flip(false)
 {
 	evaluator = new afxHermiteEval();
 }
@@ -329,4 +329,4 @@ void afxCurve3D::print()
 		Con::printf( "%f: %f %f %f", p.parameter, p.point.x, p.point.y, p.point.z );
 	}
 	Con::printf( "---------------------------------" );
-}
+}

Engine/source/afx/util/afxPath3D.cpp

@@ -29,7 +29,7 @@
 
 #include "afx/util/afxPath3D.h"
 
-afxPath3D::afxPath3D() : mStart_time(0), mNum_points(0), mLoop_type(LOOP_CONSTANT)
+afxPath3D::afxPath3D() : mStart_time(0), mNum_points(0), mLoop_type(LOOP_CONSTANT), mEnd_time(0.0f)
 {
 }
 

Engine/source/app/net/httpObject.cpp

@@ -114,12 +114,22 @@ ConsoleDocClass( HTTPObject,
 //--------------------------------------
 
 HTTPObject::HTTPObject()
+   : mParseState(ParsingStatusLine),
+   mTotalBytes(0),
+   mBytesRemaining(0),
+   mStatus(0),
+   mVersion(0.0f),
+   mContentLength(0),
+   mChunkedEncoding(false),
+   mChunkSize(0),
+   mContentType(""),
+   mHostName(NULL),
+   mPath(NULL),
+   mQuery(NULL),
+   mPost(NULL),
+   mBufferSave(NULL),
+   mBufferSaveSize(0)
 {
-   mHostName = 0;
-   mPath = 0;
-   mQuery = 0;
-   mPost = 0;
-   mBufferSave = 0;
 }
 
 HTTPObject::~HTTPObject()

Engine/source/app/net/serverQuery.h

@@ -80,6 +80,7 @@ struct ServerInfo
       statusString = NULL;
       infoString = NULL;
       version = 0;
+      dMemset(&address, '\0', sizeof(NetAddress));
       ping = 0;
       cpuSpeed = 0;
       isFavorite = false;

Engine/source/collision/boxConvex.cpp

@@ -85,7 +85,7 @@ inline bool isOnPlane(const Point3F& p,PlaneF& plane)
 void BoxConvex::getFeatures(const MatrixF& mat,const VectorF& n, ConvexFeature* cf)
 {
    cf->material = 0;
-   cf->object = mObject;
+   cf->mObject = mObject;
 
    S32 v = 0;
    v += (n.x >= 0)? 1: 0;

Engine/source/collision/clippedPolyList.h

@@ -49,7 +49,7 @@ class ClippedPolyList : public AbstractPolyList
 public:
    struct Vertex {
       Point3F point;
-      U32 mask;
+      U32 mask = 0;
    };
 
    struct Poly {
@@ -61,6 +61,8 @@ public:
       U32 vertexCount;
       U32 surfaceKey;
 	  U32 polyFlags;
+     Poly() :object(NULL), material(NULL), vertexStart(0), vertexCount(0), surfaceKey(0), polyFlags(0) {}
+     ~Poly() {}
    };
 
    /// ???

Engine/source/collision/collision.h

@@ -65,7 +65,11 @@ struct Collision
       object( NULL ),
       material( NULL ),
       generateTexCoord(false),
-      texCoord(-1.0f, -1.0f)
+      texCoord(-1.0f, -1.0f),
+      face(0),
+      faceDot(0.0f),
+      distance(0)
+
    {
    }
 };

Engine/source/collision/concretePolyList.h

@@ -48,6 +48,9 @@ class ConcretePolyList : public AbstractPolyList
 
       Poly()
       {
+         vertexStart = 0;
+         vertexCount = 0;
+         surfaceKey = 0;
          object = NULL;
          material = NULL;
       }

Engine/source/collision/convex.cpp

@@ -52,7 +52,9 @@ F32 sqrDistanceEdges(const Point3F& start0,
 
 CollisionState::CollisionState()
 {
-   mLista = mListb = 0;
+   mB = mA = NULL;
+   mDist = 0.0f;
+   mListb = mLista = 0;
 }
 
 CollisionState::~CollisionState()
@@ -85,7 +87,7 @@ F32 CollisionState::distance(const MatrixF& a2w, const MatrixF& b2w, const F32 d
 void ConvexFeature::reset()
 {
    material = NULL;
-   object = NULL;
+   mObject = NULL;
    mVertexList.clear();
    mEdgeList.clear();
    mFaceList.clear();
@@ -114,7 +116,7 @@ bool ConvexFeature::collide(ConvexFeature& cf,CollisionList* cList, F32 tol)
       {
          Collision &col = (*cList)[cList->getCount() - 1];
          col.material = cf.material;
-         col.object   = cf.object;
+         col.object   = cf.mObject;
       }
       vert++;
    }
@@ -167,7 +169,7 @@ void ConvexFeature::testVertex(const Point3F& v,CollisionList* cList,bool flip,
          if (flip)
             info.normal.neg();
          info.material = material;
-         info.object = object;
+         info.object = mObject;
          info.distance = distance;
       }
    }
@@ -213,7 +215,7 @@ void ConvexFeature::testEdge(ConvexFeature* cf,const Point3F& s1, const Point3F&
       info.normal   = normal;
       info.distance = distance;
       info.material = material;
-      info.object   = object;
+      info.object   = mObject;
    }
 }
 
@@ -282,6 +284,7 @@ CollisionWorkingList::CollisionWorkingList()
 {
    wLink.mPrev = wLink.mNext = this;
    rLink.mPrev = rLink.mNext = this;
+   mConvex = NULL;
 }
 
 void CollisionWorkingList::wLinkAfter(CollisionWorkingList* ptr)
@@ -340,6 +343,8 @@ Convex::Convex()
 {
    mNext = mPrev = this;
    mTag = 0;
+   mObject = NULL;
+   mType = ConvexType::BoxConvexType;
 }
 
 Convex::~Convex()
@@ -418,7 +423,7 @@ Point3F Convex::support(const VectorF&) const
 
 void Convex::getFeatures(const MatrixF&,const VectorF&,ConvexFeature* f)
 {
-   f->object = NULL;
+   f->mObject = NULL;
 }
 
 const MatrixF& Convex::getTransform() const

Engine/source/collision/convex.h

@@ -56,10 +56,10 @@ public:
    Vector<Edge> mEdgeList;
    Vector<Face> mFaceList;
    BaseMatInstance* material;
-   SceneObject* object;
+   SceneObject* mObject;
 
    ConvexFeature()
-      : mVertexList(64), mEdgeList(128), mFaceList(64), material( 0 )
+      : mVertexList(64), mEdgeList(128), mFaceList(64), material( 0 ), mObject(NULL)
    {
       VECTOR_SET_ASSOCIATION(mVertexList);
       VECTOR_SET_ASSOCIATION(mEdgeList);

Engine/source/collision/depthSortList.cpp

@@ -46,6 +46,13 @@ S32 gBadSpots = 0;
 
 DepthSortList::DepthSortList()
 {
+   mBase = 0;
+   mBasePoly = NULL;
+   mBaseNormal = NULL;
+   mBaseDot = 0.0f;
+   mBaseYMax = 0.0f;
+   mMaxTouched = 0;
+   mBaseExtents = NULL;
    VECTOR_SET_ASSOCIATION(mPolyExtentsList);
    VECTOR_SET_ASSOCIATION(mPolyIndexList);
 }

Engine/source/collision/extrudedPolyList.cpp

@@ -47,6 +47,7 @@ ExtrudedPolyList::ExtrudedPolyList()
    mPolyPlaneList.reserve(64);
    mPlaneList.reserve(64);
    mCollisionList = 0;
+   dMemset(&mPoly, 0, sizeof(mPoly));
 }
 
 ExtrudedPolyList::~ExtrudedPolyList()

Engine/source/collision/extrudedPolyList.h

@@ -56,13 +56,15 @@ class ExtrudedPolyList: public AbstractPolyList
 public:
    struct Vertex {
       Point3F point;
-      U32 mask;
+      U32 mask = 0;
    };
 
    struct Poly {
       PlaneF plane;
       SceneObject* object;
       BaseMatInstance* material;
+      Poly() : object(NULL), material(NULL) {}
+      ~Poly() {}
    };
 
    struct ExtrudedFace {
@@ -75,6 +77,8 @@ public:
       F32 time;
       Point3F point;
       F32 height;
+      ExtrudedFace(): active(false), maxDistance(0.0f), planeMask(0), faceDot(0.0f), faceShift(0.0f), time(0.0f), height(0.0f) {}
+      ~ExtrudedFace() {}
    };
 
    typedef Vector<ExtrudedFace> ExtrudedList;
@@ -92,7 +96,6 @@ public:
    PlaneList    mPlaneList;
    VectorF      mVelocity;
    VectorF      mNormalVelocity;
-   F32          mFaceShift;
    Poly         mPoly;
 
    // Returned info

Engine/source/collision/gjk.cpp

@@ -46,6 +46,19 @@ S32 num_irregularities = 0;
 
 GjkCollisionState::GjkCollisionState()
 {
+   mBits = 0;
+   mAll_bits = 0;
+   U32 x, y;
+   for (x = 0; x < 16; x++)
+      for (y = 0; y < 4; y++)
+         mDet[x][y] = 0.0f;
+
+   for (x = 0; x < 4; x++)
+      for (y = 0; y < 4; y++)
+         mDP[x][y] = 0.0f;
+
+   mLast = 0;
+   mLast_bit = 0;
    mA = mB = 0;
 }
 

Engine/source/collision/optimizedPolyList.h

@@ -88,7 +88,9 @@ class OptimizedPolyList : public AbstractPolyList
       Poly()
          : plane( -1 ),
            material( NULL ),
+           vertexStart(0),
            vertexCount( 0 ),
+           surfaceKey(0),
            object( NULL ),
            type( TriangleFan )
       {

Engine/source/collision/planeExtractor.cpp

@@ -37,6 +37,7 @@ PlaneExtractorPolyList::PlaneExtractorPolyList()
 {
    VECTOR_SET_ASSOCIATION(mVertexList);
    VECTOR_SET_ASSOCIATION(mPolyPlaneList);
+   mPlaneList = NULL;
 }
 
 PlaneExtractorPolyList::~PlaneExtractorPolyList()

Engine/source/collision/polytope.h

@@ -76,6 +76,7 @@ public:
       Collision()
       {
          object = NULL;
+         material = NULL;
          distance = 0.0;
       }
    };

Engine/source/console/astNodes.cpp

@@ -142,6 +142,7 @@ StmtNode::StmtNode()
 {
    mNext = NULL;
    dbgFileName = CodeBlock::smCurrentParser->getCurrentFile();
+   dbgLineNumber = 0;
 }
 
 void StmtNode::setPackage(StringTableEntry)

Engine/source/console/codeBlock.cpp

@@ -56,6 +56,9 @@ CodeBlock::CodeBlock()
    name = NULL;
    fullPath = NULL;
    modPath = NULL;
+   codeSize = 0;
+   lineBreakPairCount = 0;
+   nextFile = NULL;
 }
 
 CodeBlock::~CodeBlock()

Engine/source/console/codeInterpreter.cpp

@@ -224,6 +224,9 @@ CodeInterpreter::CodeInterpreter(CodeBlock *cb) :
    mSaveCodeBlock(nullptr),
    mCurrentInstruction(0)
 {
+   dMemset(&mExec, 0, sizeof(mExec));
+   dMemset(&mObjectCreationStack, 0, sizeof(mObjectCreationStack));
+   dMemset(&mNSDocBlockClass, 0, sizeof(mNSDocBlockClass));
 }
 
 CodeInterpreter::~CodeInterpreter()

Engine/source/console/compiler.h

@@ -317,7 +317,7 @@ protected:
       U32 addr;  ///< Address to patch
       U32 value; ///< Value to place at addr
 
-      PatchEntry() { ; }
+      PatchEntry(): addr(0), value(0) { ; }
       PatchEntry(U32 a, U32 v) : addr(a), value(v) { ; }
    } PatchEntry;
 

Engine/source/console/consoleInternal.cpp

@@ -475,7 +475,7 @@ Dictionary::Entry::Entry(StringTableEntry in_name)
    nextEntry = NULL;
    mUsage = NULL;
    mIsConstant = false;
-
+   mNext = NULL;
    // NOTE: This is data inside a nameless
    // union, so we don't need to init the rest.
    value.init();
@@ -856,6 +856,7 @@ ExprEvalState::ExprEvalState()
    stack.reserve(64);
    mShouldReset = false;
    mResetLocked = false;
+   copyVariable = NULL;
 }
 
 ExprEvalState::~ExprEvalState()
@@ -927,6 +928,15 @@ Namespace::Entry::Entry()
    mUsage = NULL;
    mHeader = NULL;
    mNamespace = NULL;
+   cb.mStringCallbackFunc = NULL;
+   mFunctionLineNumber = 0;
+   mFunctionName = StringTable->EmptyString();
+   mFunctionOffset = 0;
+   mMinArgs = 0;
+   mMaxArgs = 0;
+   mNext = NULL;
+   mPackage = StringTable->EmptyString();
+   mToolOnly = false;
 }
 
 void Namespace::Entry::clear()
@@ -959,6 +969,7 @@ Namespace::Namespace()
    mHashSequence = 0;
    mRefCountToParent = 0;
    mClassRep = 0;
+   lastUsage = NULL;
 }
 
 Namespace::~Namespace()

Engine/source/console/consoleInternal.h

@@ -306,6 +306,7 @@ public:
          nextEntry = NULL;
          mUsage = NULL;
          mIsConstant = false;
+         mNext = NULL;
          value.init();
       }
 

Engine/source/console/consoleObject.h

@@ -220,7 +220,21 @@ public:
       : Parent( sizeof( void* ), conIdPtr, typeName )
    {
       VECTOR_SET_ASSOCIATION( mFieldList );
-
+      mCategory = StringTable->EmptyString();
+      mClassGroupMask = 0;
+      std::fill_n(mClassId, NetClassGroupsCount, -1);
+      mClassName = StringTable->EmptyString();
+      mClassSizeof = 0;
+      mClassType = 0;
+      mDescription = StringTable->EmptyString();
+#ifdef TORQUE_NET_STATS
+      dMemset(mDirtyMaskFrequency, 0, sizeof(mDirtyMaskFrequency));
+      dMemset(mDirtyMaskTotal, 0, sizeof(mDirtyMaskTotal));
+#endif
+      mDynamicGroupExpand = false;
+      mNamespace = NULL;
+      mNetEventDir = 0;
+      nextClass = NULL;
       parentClass  = NULL;
       mIsRenderEnabled = true;
       mIsSelectionEnabled = true;
@@ -496,6 +510,7 @@ public:
             validator( NULL ),
             setDataFn( NULL ),
             getDataFn( NULL ),
+            writeDataFn(NULL),
             networkMask(0)
       {
          doNotSubstitute = keepClearSubsOnly = false;

Engine/source/console/engineAPI.h

@@ -1190,7 +1190,7 @@ public:
    ConsoleValueRef _exec();
    ConsoleValueRef _execLater(SimConsoleThreadExecEvent *evt);
 
-   _BaseEngineConsoleCallbackHelper() {;}
+   _BaseEngineConsoleCallbackHelper(): mThis(NULL), mInitialArgc(0), mArgc(0), mCallbackName(StringTable->EmptyString()){;}
 };
 
 

Engine/source/console/engineExports.h

@@ -123,6 +123,7 @@ class EngineExport : public StaticEngineObject
          : mExportName( "" ),
            mExportKind( EngineExportKindScope ),
            mExportScope( NULL ),
+           mDocString(""),
            mNextExport( NULL ) {}
 };
 
@@ -165,7 +166,7 @@ class EngineExportScope : public EngineExport
    private:
    
       /// Constructor for the global scope.
-      EngineExportScope() {}
+      EngineExportScope():mExports(NULL){}
 };
 
 

Engine/source/console/engineObject.cpp

@@ -53,7 +53,7 @@ void*& _USERDATA( EngineObject* object )
 //-----------------------------------------------------------------------------
 
 EngineObject::EngineObject()
-   : mEngineObjectUserData( NULL )
+   : mEngineObjectPool(NULL), mEngineObjectUserData( NULL )
 {
    #ifdef TORQUE_DEBUG
    // Add to instance list.

Engine/source/console/engineTypeInfo.cpp

@@ -58,6 +58,7 @@ EngineTypeInfo::EngineTypeInfo( const char* typeName, EngineExportScope* scope,
      mEnumTable( NULL ),
      mFieldTable( NULL ),
      mPropertyTable( NULL ),
+     mArgumentTypeTable(NULL),
      mSuperType( NULL ),
      mNext( smFirst )
 {

Engine/source/console/simDatablock.cpp

@@ -55,6 +55,7 @@ ConsoleDocClass( SimDataBlock,
 
 SimDataBlock::SimDataBlock()
 {
+   modifiedKey = 0;
    setModDynamicFields(true);
    setModStaticFields(true);
 }

Engine/source/console/simDictionary.cpp

@@ -31,6 +31,8 @@ SimNameDictionary::SimNameDictionary()
 {
 #ifndef USE_NEW_SIMDICTIONARY
    hashTable = NULL;
+   hashTableSize = DefaultTableSize;
+   hashEntryCount = 0;
 #endif
    mutex = Mutex::createMutex();
 }

Engine/source/console/simEvents.h

@@ -62,7 +62,7 @@ public:
    ///  of addition to the list.
    SimObject *destObject;   ///< Object on which this event will be applied.
 
-   SimEvent() { destObject = NULL; }
+   SimEvent() { nextEvent = NULL; startTime = 0; time = 0; sequenceCount = 0; destObject = NULL; }
    virtual ~SimEvent() {}   ///< Destructor
    ///
    /// A dummy virtual destructor is required

Engine/source/console/simFieldDictionary.h

@@ -47,7 +47,7 @@ class SimFieldDictionary
 public:
    struct Entry
    {
-      Entry() : type(NULL) {};
+      Entry() : slotName(StringTable->EmptyString()), value(NULL), next(NULL), type(NULL) {};
 
       StringTableEntry slotName;
       char *value;
@@ -112,4 +112,4 @@ public:
 };
 
 
-#endif // _SIMFIELDDICTIONARY_H_
+#endif // _SIMFIELDDICTIONARY_H_

Engine/source/console/simObject.cpp

@@ -57,6 +57,8 @@ SimObjectId SimObject::smForcedId = 0;
 
 bool SimObject::preventNameChanging = false;
 
+IMPLEMENT_CALLBACK(SimObject, onInspectPostApply, void, (SimObject* obj), (obj), "Generic callback for when an object is edited");
+
 namespace Sim
 {
    // Defined in simManager.cpp
@@ -1380,6 +1382,7 @@ SimObject::SimObject(const SimObject& other, bool temp_clone)
    nextIdObject = other.nextIdObject;
    mGroup = other.mGroup;
    mFlags = other.mFlags;
+   mProgenitorFile = other.mProgenitorFile;
    mCopySource = other.mCopySource;
    mFieldDictionary = other.mFieldDictionary;
    //mIdString = other.mIdString; // special treatment (see below)
@@ -2237,6 +2240,7 @@ void SimObject::inspectPreApply()
 
 void SimObject::inspectPostApply()
 {
+   onInspectPostApply_callback(this);
 }
 
 //-----------------------------------------------------------------------------

Engine/source/console/simObject.h

@@ -965,6 +965,7 @@ class SimObject: public ConsoleObject, public TamlCallbacks
       virtual void getConsoleMethodData(const char * fname, S32 routingId, S32 * type, S32 * minArgs, S32 * maxArgs, void ** callback, const char ** usage) {}
       
       DECLARE_CONOBJECT( SimObject );
+      DECLARE_CALLBACK(void, onInspectPostApply, (SimObject* obj));
       
       static SimObject* __findObject( const char* id ) { return Sim::findObject( id ); }
       static const char* __getObjectId( ConsoleObject* object )

Engine/source/console/stringStack.cpp

@@ -30,7 +30,12 @@ StringStack::StringStack()
    mBuffer = NULL;
    mArgBufferSize = 0;
    mArgBuffer = NULL;
+   for (U32 i = 0; i < MaxArgs; i++)
+      mArgV[i] = "";
+   dMemset(mFrameOffsets, 0, sizeof(mFrameOffsets));
+   dMemset(mStartOffsets, 0, sizeof(mStartOffsets));
    mNumFrames = 0;
+   mArgc = 0;
    mStart = 0;
    mLen = 0;
    mStartStackSize = 0;
@@ -232,6 +237,7 @@ mStackPos(0)
       mStack[i].init();
       mStack[i].type = ConsoleValue::TypeInternalString;
    }
+   dMemset(mStackFrames, 0, sizeof(mStackFrames));
 }
 
 ConsoleValueStack::~ConsoleValueStack()

Engine/source/console/telnetConsole.cpp

@@ -88,6 +88,9 @@ TelnetConsole::TelnetConsole()
    mAcceptPort = -1;
    mClientList = NULL;
    mRemoteEchoEnabled = false;
+
+   dStrncpy(mTelnetPassword, "", PasswordMaxLength);
+   dStrncpy(mListenPassword, "", PasswordMaxLength);
 }
 
 TelnetConsole::~TelnetConsole()

Engine/source/console/telnetConsole.h

@@ -78,6 +78,7 @@ class TelnetConsole
       S32 state;                       ///< State of the client.
                                        ///  @see TelnetConsole::State
       TelnetClient *nextClient;
+      TelnetClient() { dStrncpy(curLine, "", Con::MaxLineLength); curPos = 0; state = 0; nextClient = NULL; }
    };
    TelnetClient *mClientList;
    TelnetConsole();

Engine/source/console/telnetDebugger.cpp

@@ -163,6 +163,9 @@ TelnetDebugger::TelnetDebugger()
    mProgramPaused = false;
    mWaitForClient = false;
 
+   dStrncpy(mDebuggerPassword, "", PasswordMaxLength);
+   dStrncpy(mLineBuffer, "", sizeof(mLineBuffer));
+   
    // Add the version number in a global so that
    // scripts can detect the presence of the
    // "enhanced" debugger features.

Engine/source/console/typeValidators.h

@@ -27,7 +27,8 @@ class TypeValidator
 {
    public:
    S32 fieldIndex;
-
+   TypeValidator() : fieldIndex(0) {}
+   ~TypeValidator() {}
    /// Prints a console error message for the validator.
    ///
    /// The message is prefaced with with:

Engine/source/core/color.h

@@ -203,7 +203,7 @@ public:
 class StockColorItem
 {
 private:
-   StockColorItem() {}
+   StockColorItem():mColorName("") {}
 
 public:
    StockColorItem( const char* pName, const U8 red, const U8 green, const U8 blue, const U8 alpha = 255 )
@@ -529,6 +529,7 @@ inline void ColorI::set(const Hsb& color)
 	red = (U32)((((F64)r) / 100) * 255);
 	green = (U32)((((F64)g) / 100) * 255);
 	blue = (U32)((((F64)b) / 100) * 255);
+   alpha = 255;
 }
 
 // This is a subfunction of HSLtoRGB

Engine/source/core/frameAllocator.h

@@ -295,6 +295,7 @@ public:
       AssertFatal( count > 0, "Allocating a FrameTemp with less than one instance" ); \
       mWaterMark = FrameAllocator::getWaterMark(); \
       mMemory = reinterpret_cast<type *>( FrameAllocator::alloc( sizeof( type ) * count ) ); \
+      mNumObjectsInMemory = 0; \
    } \
    template<>\
    inline FrameTemp<type>::~FrameTemp() \

Engine/source/core/ogg/oggTheoraDecoder.h

@@ -48,9 +48,9 @@ class OggTheoraFrame : public RawData
    
       typedef RawData Parent;
       
-      OggTheoraFrame() {}
+      OggTheoraFrame() :mFrameNumber(0), mFrameTime(0), mFrameDuration(0) {}
       OggTheoraFrame( S8* data, U32 size, bool ownMemory = false )
-         : Parent( data, size, ownMemory ) {}
+         : Parent( data, size, ownMemory ), mFrameNumber(0), mFrameTime(0), mFrameDuration(0) {}
          
       /// Serial number of this frame in the stream.
       U32 mFrameNumber;