Updated Assimp

Added initial behavior for ImageAssets to hold a list of GFX resources of different texture profiles to avoid mem leaks with incorrect-typed usages
Added function to ImageAsset to get best-fit asset, allowing for fallbacks if the requested assetID is not found
Added function to ShapeAsset to get best-fit asset, allowing for fallbacks if the requested assetID is not found
Disabled fields for dynamic and static shadowmap refresh rates
Moved noShape model to core/rendering/shapes to place it in a more logical module position
Added an include to avoid undefined type compile error and removed unneeded semicolon from zone code
Added call to reload probe textures when a reloadTextures call is made
Adjusted default directional light shadowmap settings to not be as extreme
Added utility function to probe manager to allow any class to request a 'best fit' list of probes that would affect a given location, allowing other classes such as fog or particles to utilize IBL. Also updated probeManager's forward rendering to utilize same function to reduce code duplication.
Shifted shape loader code to utilize assimp for loader consistency and testing
Changed render bin used for SSAO postfx so it runs at the right time
Made Core_Rendering module scan for assets
Updated loose file references to a number of assets to follow proper formatting
Refactored asset import code to follow a more consistent object heirarchy structure on importing assets, allowing more reliable cross-referencing between inbound items
Updated asset import logic for materials/images so that they properly utilize ImageType. Images correctly save out the assigned image type, materials reference the images' type to know what map slot they should be used in. Importer logic also updated to better find-and-add associated images based on type.
Cleaned up a bunch of old, outdated code in the asset importer
Added initial handling for in-place importing of files without needing to process them through the UI.
Added ability to edit module script from RMB context menu if torsion path is set
Updated list field code for variable inspector to utilize correct ownerObject field

Engine/source/T3D/assets/ImageAsset.cpp

@@ -40,6 +40,8 @@
 #include "assets/assetPtr.h"
 #endif
 
+#include "gfx/gfxStringEnumTranslate.h"
+
 // Debug Profiling.
 #include "platform/profiler.h"
 
@@ -128,7 +130,30 @@ void ImageAsset::initPersistFields()
 }
 
 //------------------------------------------------------------------------------
+//Utility function to 'fill out' bindings and resources with a matching asset if one exists
+bool ImageAsset::getAssetByFilename(StringTableEntry fileName, AssetPtr<ImageAsset>* imageAsset)
+{
+   AssetQuery query;
+   S32 foundAssetcount = AssetDatabase.findAssetLooseFile(&query, fileName);
+   if (foundAssetcount == 0)
+   {
+      //Didn't find any assets, so have us fall back to a placeholder asset
+      imageAsset->setAssetId(StringTable->insert("Core_Rendering:noshape"));
 
+      if (!imageAsset->isNull())
+         return true;
+
+      //That didn't work, so fail out
+      return false;
+   }
+   else
+   {
+      //acquire and bind the asset, and return it out
+      imageAsset->setAssetId(query.mAssetList[0]);
+      return true;
+   }
+}
+//------------------------------------------------------------------------------
 void ImageAsset::copyTo(SimObject* object)
 {
    // Call to parent.
@@ -180,9 +205,49 @@ void ImageAsset::setImageFileName(const char* pScriptFile)
    mImageFileName = StringTable->insert(pScriptFile);
 }
 
+GFXTexHandle ImageAsset::getImage(GFXTextureProfile requestedProfile)
+{
+   /*if (mResourceMap.contains(requestedProfile))
+   {
+      return mResourceMap.find(requestedProfile)->value;
+   }
+   else
+   {
+      //If we don't have an existing map case to the requested format, we'll just create it and insert it in
+      GFXTexHandle newImage;
+      newImage.set(mImageFileName, &requestedProfile, avar("%s() - mImage (line %d)", __FUNCTION__, __LINE__));
+      mResourceMap.insert(requestedProfile, newImage);
+
+      return newImage;
+   }*/
+
+   return nullptr;
+}
+
+const char* ImageAsset::getImageInfo()
+{
+   if (mIsValidImage)
+   {
+      static const U32 bufSize = 2048;
+      char* returnBuffer = Con::getReturnBuffer(bufSize);
+      dSprintf(returnBuffer, bufSize, "%s %d %d %d", GFXStringTextureFormat[mImage.getFormat()], mImage.getHeight(), mImage.getWidth(), mImage.getDepth());
+
+      return returnBuffer;
+   }
+
+   return "";
+}
+
 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.")
 {
    return object->getImageFileName();
 }
+
+DefineEngineMethod(ImageAsset, getImageInfo, const char*, (), ,
+   "Creates an instance of the given GameObject given the asset definition.\n"
+   "@return The GameObject entity created from the asset.")
+{
+   return object->getImageInfo();
+}

Engine/source/T3D/assets/ImageAsset.h

@@ -38,6 +38,9 @@
 #ifndef _ASSET_FIELD_TYPES_H_
 #include "assets/assetFieldTypes.h"
 #endif
+#ifndef _ASSET_PTR_H_
+#include "assets/assetPtr.h"
+#endif 
 
 #include "gfx/bitmap/gBitmap.h"
 #include "gfx/gfxTextureHandle.h"
@@ -74,6 +77,8 @@ protected:
 
    ImageTypes mImageType;
 
+   Map<GFXTextureProfile, GFXTexHandle> mResourceMap;
+
 public:
    ImageAsset();
    virtual ~ImageAsset();
@@ -90,7 +95,9 @@ public:
 
    bool isValid() { return mIsValidImage; }
 
-   GFXTexHandle getImage() { return mImage; }
+   GFXTexHandle getImage(GFXTextureProfile requestedProfile);
+
+   const char* getImageInfo();
 
 protected:
    virtual void            initializeAsset(void);
@@ -100,6 +107,8 @@ protected:
    static const char* getImageFileName(void* obj, const char* data) { return static_cast<ImageAsset*>(obj)->getImageFileName(); }
 
    void loadImage();
+
+   bool getAssetByFilename(StringTableEntry fileName, AssetPtr<ImageAsset>* imageAsset);
 };
 
 DefineConsoleType(TypeImageAssetPtr, ImageAsset)

Engine/source/T3D/assets/ShapeAsset.cpp

@@ -288,6 +288,66 @@ bool ShapeAsset::loadShape()
    return true;
 }
 
+//------------------------------------------------------------------------------
+//Utility function to 'fill out' bindings and resources with a matching asset if one exists
+bool ShapeAsset::getAssetByFilename(StringTableEntry fileName, AssetPtr<ShapeAsset>* shapeAsset)
+{
+   AssetQuery query;
+   S32 foundAssetcount = AssetDatabase.findAssetLooseFile(&query, fileName);
+   if (foundAssetcount == 0)
+   {
+      //Didn't find any assets
+      //If possible, see if we can run an in-place import and the get the asset from that
+#if TORQUE_DEBUG
+      Con::warnf("ShapeAsset::getAssetByFilename - Attempted to in-place import a shapefile(%s) that had no associated asset", fileName);
+
+      ConsoleValueRef result = Con::executef("importLooseFile", fileName, true);
+
+      if (result.getBoolValue())
+      {
+         StringTableEntry resultingAssetId = StringTable->insert(Con::getVariable("$importedLooseFileAsset"));
+
+         if (resultingAssetId != StringTable->EmptyString())
+         {
+            shapeAsset->setAssetId(resultingAssetId);
+
+            if (!shapeAsset->isNull())
+               return true;
+         }
+      }
+#endif
+
+      //Didn't work, so have us fall back to a placeholder asset
+      shapeAsset->setAssetId(StringTable->insert("Core_Rendering:noshape"));
+
+      if (!shapeAsset->isNull())
+         return true;
+
+      //That didn't work, so fail out
+      return false;
+   }
+   else
+   {
+      //acquire and bind the asset, and return it out
+      shapeAsset->setAssetId(query.mAssetList[0]);
+      return true;
+   }
+}
+
+bool ShapeAsset::getAssetById(StringTableEntry assetId, AssetPtr<ShapeAsset>* shapeAsset)
+{
+   shapeAsset->setAssetId(assetId);
+   if (!shapeAsset->isNull())
+      return true;
+
+   //Didn't work, so have us fall back to a placeholder asset
+   shapeAsset->setAssetId(StringTable->insert("Core_Rendering:noshape"));
+
+   if (!shapeAsset->isNull())
+      return true;
+
+   return false;
+}
 //------------------------------------------------------------------------------
 
 void ShapeAsset::copyTo(SimObject* object)

Engine/source/T3D/assets/ShapeAsset.h

@@ -128,6 +128,9 @@ public:
    void                    setShapeConstructorFile(const char* pScriptFile);
    inline StringTableEntry getShapeConstructorFile(void) const { return mConstructorFileName; };
 
+   static bool getAssetByFilename(StringTableEntry fileName, AssetPtr<ShapeAsset>* shapeAsset);
+   static bool getAssetById(StringTableEntry assetId, AssetPtr<ShapeAsset>* shapeAsset);
+
 protected:
    virtual void            onAssetRefresh(void);
 

Engine/source/T3D/fx/groundCover.cpp

@@ -948,7 +948,7 @@ void GroundCover::_initialize( U32 cellCount, U32 cellPlacementCount )
          if (!mat->mDiffuseMapFilename[0].isEmpty())
             tex = GFXTexHandle(mat->mDiffuseMapFilename[0], &GFXStaticTextureSRGBProfile, "GroundCover texture aspect ratio check");
          else if (!mat->mDiffuseMapAsset[0].isNull())
-            tex = mat->mDiffuseMapAsset[0]->getImage();
+            tex = mat->mDiffuseMapAsset[0]->getImage(GFXStaticTextureSRGBProfile);
 
          if(tex.isValid())
          {

Engine/source/T3D/fx/particleEmitter.cpp

@@ -1172,6 +1172,8 @@ void ParticleEmitter::prepRenderImage(SceneRenderState* state)
 
    ri->bbModelViewProj = renderManager->allocUniqueXform( *ri->modelViewProj * mBBObjToWorld );
 
+   ri->wsPosition = getWorldTransform().getPosition();
+
    ri->count = n_parts;
 
    ri->blendStyle = mDataBlock->blendStyle;

Engine/source/T3D/lightBase.cpp

@@ -98,8 +98,8 @@ void LightBase::initPersistFields()
       addField( "color", TypeColorF, Offset( mColor, LightBase ), "Changes the base color hue of the light." );
       addField( "brightness", TypeF32, Offset( mBrightness, LightBase ), "Adjusts the lights power, 0 being off completely." );      
       addField( "castShadows", TypeBool, Offset( mCastShadows, LightBase ), "Enables/disabled shadow casts by this light." );
-      addField( "staticRefreshFreq", TypeS32, Offset( mStaticRefreshFreq, LightBase ), "static shadow refresh rate (milliseconds)" );
-      addField( "dynamicRefreshFreq", TypeS32, Offset( mDynamicRefreshFreq, LightBase ), "dynamic shadow refresh rate (milliseconds)");
+      //addField( "staticRefreshFreq", TypeS32, Offset( mStaticRefreshFreq, LightBase ), "static shadow refresh rate (milliseconds)" );
+      //addField( "dynamicRefreshFreq", TypeS32, Offset( mDynamicRefreshFreq, LightBase ), "dynamic shadow refresh rate (milliseconds)");
       addField( "priority", TypeF32, Offset( mPriority, LightBase ), "Used for sorting of lights by the light manager. "
 		  "Priority determines if a light has a stronger effect than, those with a lower value" );
 

Engine/source/T3D/shapeImage.cpp

@@ -189,7 +189,7 @@ ShapeBaseImageData::ShapeBaseImageData()
    lightRadius = 10.f;
    lightBrightness = 1.0f;
 
-   shapeName = "core/shapes/noshape.dts";
+   shapeName = "core/rendering/shapes/noshape.dts";
    shapeNameFP = "";
    imageAnimPrefix = "";
    imageAnimPrefixFP = "";

Engine/source/T3D/zone.cpp

@@ -29,7 +29,7 @@
 #include "scene/mixin/scenePolyhedralObject.impl.h"
 
 #include "gui/worldEditor/worldEditor.h"
-
+#include "scene/sceneManager.h"
 
 IMPLEMENT_CO_NETOBJECT_V1( Zone );
 
@@ -118,11 +118,11 @@ void Zone::selectWithin()
 
             for (SceneObject::ObjectZonesIterator zoneIter(obj); zoneIter.isValid(); ++zoneIter)
             {
-               if (*zoneIter != zoneId);
+               if (*zoneIter != zoneId)
                   fullyEnclosed = false;
             }
             if (fullyEnclosed)
-               sql.insertObject(obj);
+               sql.insertObject(obj); 
          }
    }
 

Engine/source/environment/sun.cpp

@@ -167,8 +167,8 @@ void Sun::initPersistFields()
       addField( "castShadows", TypeBool, Offset( mCastShadows, Sun ), 
          "Enables/disables shadows cast by objects due to Sun light");    
 
-      addField("staticRefreshFreq", TypeS32, Offset(mStaticRefreshFreq, Sun), "static shadow refresh rate (milliseconds)");
-      addField("dynamicRefreshFreq", TypeS32, Offset(mDynamicRefreshFreq, Sun), "dynamic shadow refresh rate (milliseconds)");
+      //addField("staticRefreshFreq", TypeS32, Offset(mStaticRefreshFreq, Sun), "static shadow refresh rate (milliseconds)");
+      //addField("dynamicRefreshFreq", TypeS32, Offset(mDynamicRefreshFreq, Sun), "dynamic shadow refresh rate (milliseconds)");
 
    endGroup( "Lighting" );
 

Engine/source/gfx/gfxTextureManager.cpp

@@ -34,6 +34,7 @@
 #include "core/util/dxt5nmSwizzle.h"
 #include "console/consoleTypes.h"
 #include "console/engineAPI.h"
+#include "renderInstance/renderProbeMgr.h"
 
 using namespace Torque;
 
@@ -1554,4 +1555,5 @@ DefineEngineFunction( reloadTextures, void, (),,
       return;
 
    TEXMGR->reloadTextures();
+   PROBEMGR->reloadTextures();
 }

Engine/source/lighting/shadowMap/lightShadowMap.cpp

@@ -537,9 +537,9 @@ ShadowMapParams::ShadowMapParams( LightInfo *light )
    numSplits = 4;
    logWeight = 0.91f;
    texSize = 1024;
-   shadowDistance = 400.0f;
-   shadowSoftness = 0.15f;
-   fadeStartDist = 0.0f;
+   shadowDistance = 100.0f;
+   shadowSoftness = 0.2f;
+   fadeStartDist = 75.0f;
    lastSplitTerrainOnly = false;
    mQuery = GFX->createOcclusionQuery();
 

Engine/source/materials/materialList.cpp

@@ -419,12 +419,14 @@ void MaterialList::initMatInstances(   const FeatureSet &features,
       }
       else
       {
-         REFLECTMGR->getReflectionMaterial(matInst);
+         AdvancedLightManager* lightMgr = dynamic_cast<AdvancedLightManager*>(LIGHTMGR);
+         if (lightMgr)
+         {
+            REFLECTMGR->getReflectionMaterial(matInst);
 
-         // Hunt for the pre-pass manager/target
-         
-         AdvancedLightManager* lightMgr = static_cast<AdvancedLightManager*>(LIGHTMGR);
-         lightMgr->getDeferredRenderBin()->getDeferredMaterial(matInst);
+            // Hunt for the pre-pass manager/target
+            lightMgr->getDeferredRenderBin()->getDeferredMaterial(matInst);
+         }
       }
    }
 

Engine/source/materials/processedMaterial.cpp

@@ -424,7 +424,7 @@ void ProcessedMaterial::_setStageData()
       }
       else if (mMaterial->mDiffuseMapAsset[i] && !mMaterial->mDiffuseMapAsset[i].isNull())
       {
-         mStages[i].setTex(MFT_DiffuseMap, mMaterial->mDiffuseMapAsset[i]->getImage());
+         mStages[i].setTex(MFT_DiffuseMap, mMaterial->mDiffuseMapAsset[i]->getImage(GFXStaticTextureSRGBProfile));
          if (!mStages[i].getTex(MFT_DiffuseMap))
          {
             // Load a debug texture to make it clear to the user 

Engine/source/renderInstance/renderPassManager.h

@@ -449,6 +449,8 @@ struct ParticleRenderInst : public RenderInst
    /// Bounding box render transform
    const MatrixF *bbModelViewProj;
 
+   Point3F wsPosition;
+
    /// The particle texture.
    GFXTextureObject *diffuseTex;
 

Engine/source/renderInstance/renderProbeMgr.cpp

@@ -505,6 +505,17 @@ void RenderProbeMgr::updateProbeTexture(ProbeRenderInst* probeInfo)
 #endif
 }
 
+void RenderProbeMgr::reloadTextures()
+{
+   U32 probeCount = mRegisteredProbes.size();
+   for (U32 i = 0; i < probeCount; i++)
+   {
+      updateProbeTexture(&mRegisteredProbes[i]);
+   }
+
+   mProbesDirty = true;
+}
+
 void RenderProbeMgr::_setupPerFrameParameters(const SceneRenderState *state)
 {
    PROFILE_SCOPE(RenderProbeMgr_SetupPerFrameParameters);
@@ -562,112 +573,33 @@ void RenderProbeMgr::_update4ProbeConsts(const SceneData &sgData,
 {
    PROFILE_SCOPE(ProbeManager_Update4ProbeConsts);
 
+   return;
+
    // Skip over gathering lights if we don't have to!
    //if (probeShaderConsts->isValid())
    {
       PROFILE_SCOPE(ProbeManager_Update4ProbeConsts_setProbes);
 
       const U32 MAX_FORWARD_PROBES = 4;
-
-      static AlignedArray<Point4F> probePositionArray(MAX_FORWARD_PROBES, sizeof(Point4F));
-      static AlignedArray<Point4F> refBoxMinArray(MAX_FORWARD_PROBES, sizeof(Point4F));
-      static AlignedArray<Point4F> refBoxMaxArray(MAX_FORWARD_PROBES, sizeof(Point4F));
-      static AlignedArray<Point4F> probeRefPositionArray(MAX_FORWARD_PROBES, sizeof(Point4F));
-      static AlignedArray<Point4F> probeConfigArray(MAX_FORWARD_PROBES, sizeof(Point4F));
-
-      Vector<MatrixF> probeWorldToObjArray;
-      probeWorldToObjArray.setSize(MAX_FORWARD_PROBES);
-      //static AlignedArray<CubemapData> probeCubemap(4, sizeof(CubemapData));
-      //F32 range;
-
-      // Need to clear the buffers so that we don't leak
-      // lights from previous passes or have NaNs.
-      dMemset(probePositionArray.getBuffer(), 0, probePositionArray.getBufferSize());
-      dMemset(refBoxMinArray.getBuffer(), 0, refBoxMinArray.getBufferSize());
-      dMemset(refBoxMaxArray.getBuffer(), 0, refBoxMaxArray.getBufferSize());
-      dMemset(probeRefPositionArray.getBuffer(), 0, probeRefPositionArray.getBufferSize());
-      dMemset(probeConfigArray.getBuffer(), 0, probeConfigArray.getBufferSize());
+      ProbeDataSet probeSet(MAX_FORWARD_PROBES);
 
       matSet.restoreSceneViewProjection();
 
-      //Array rendering
-      U32 probeCount = mRegisteredProbes.size();
+      getBestProbes(sgData.objTrans->getPosition(), &probeSet);
 
-      S8 bestPickProbes[4] = { -1,-1,-1,-1 };
+      shaderConsts->setSafe(probeShaderConsts->mProbeCountSC, (S32)probeSet.effectiveProbeCount);
 
-      S32 skyLightIdx = -1;
-
-      U32 effectiveProbeCount = 0;
-      for (U32 i = 0; i < probeCount; i++)
-      {
-         //if (effectiveProbeCount >= MAX_FORWARD_PROBES)
-         //   break;
-
-         const ProbeRenderInst& curEntry = mRegisteredProbes[i];
-         if (!curEntry.mIsEnabled)
-            continue;
-
-         if (!curEntry.mIsSkylight)
-         {
-            F32 dist = Point3F(sgData.objTrans->getPosition() - curEntry.getPosition()).len();
-
-            if (dist > curEntry.mRadius || dist > curEntry.mExtents.len())
-               continue;
-
-            if(bestPickProbes[0] == -1 || (Point3F(sgData.objTrans->getPosition() - mRegisteredProbes[bestPickProbes[0]].mPosition).len() > dist))
-               bestPickProbes[0] = i;
-            else if (bestPickProbes[1] == -1 || (Point3F(sgData.objTrans->getPosition() - mRegisteredProbes[bestPickProbes[1]].mPosition).len() > dist))
-               bestPickProbes[1] = i;
-            else if (bestPickProbes[2] == -1 || (Point3F(sgData.objTrans->getPosition() - mRegisteredProbes[bestPickProbes[2]].mPosition).len() > dist))
-               bestPickProbes[2] = i;
-            else if (bestPickProbes[3] == -1 || (Point3F(sgData.objTrans->getPosition() - mRegisteredProbes[bestPickProbes[3]].mPosition).len() > dist))
-               bestPickProbes[3] = i;
-         }
-         else
-         {
-            skyLightIdx = curEntry.mCubemapIndex;
-         }
-      }
-
-      //Grab our best probe picks
-      for (U32 i = 0; i < 4; i++)
-      {
-         if (bestPickProbes[i] == -1)
-            continue;
-
-         const ProbeRenderInst& curEntry = mRegisteredProbes[bestPickProbes[i]];
-
-         probePositionArray[effectiveProbeCount] = curEntry.getPosition();
-         probeRefPositionArray[effectiveProbeCount] = curEntry.mProbeRefOffset;
-         probeWorldToObjArray[effectiveProbeCount] = curEntry.getTransform();
-
-         Point3F refPos = curEntry.getPosition() + curEntry.mProbeRefOffset;
-         Point3F refBoxMin = refPos - curEntry.mProbeRefScale * curEntry.getTransform().getScale();
-         Point3F refBoxMax = refPos + curEntry.mProbeRefScale * curEntry.getTransform().getScale();
-
-         refBoxMinArray[effectiveProbeCount] = Point4F(refBoxMin.x, refBoxMin.y, refBoxMin.z, 0);
-         refBoxMaxArray[effectiveProbeCount] = Point4F(refBoxMax.x, refBoxMax.y, refBoxMax.z, 0);
-         probeConfigArray[effectiveProbeCount] = Point4F(curEntry.mProbeShapeType,
-            curEntry.mRadius,
-            curEntry.mAtten,
-            curEntry.mCubemapIndex);
-
-         effectiveProbeCount++;
-      }
-
-      shaderConsts->setSafe(probeShaderConsts->mProbeCountSC, (S32)effectiveProbeCount);
-
-      shaderConsts->setSafe(probeShaderConsts->mProbePositionSC, probePositionArray);
-      shaderConsts->setSafe(probeShaderConsts->mProbeRefPosSC, probeRefPositionArray);
+      shaderConsts->setSafe(probeShaderConsts->mProbePositionSC, probeSet.probePositionArray);
+      shaderConsts->setSafe(probeShaderConsts->mProbeRefPosSC, probeSet.probeRefPositionArray);
 
       if(probeShaderConsts->isValid())
-         shaderConsts->set(probeShaderConsts->mWorldToObjArraySC, probeWorldToObjArray.address(), effectiveProbeCount, GFXSCT_Float4x4);
+         shaderConsts->set(probeShaderConsts->mWorldToObjArraySC, probeSet.probeWorldToObjArray.address(), probeSet.effectiveProbeCount, GFXSCT_Float4x4);
 
-      shaderConsts->setSafe(probeShaderConsts->mRefBoxMinSC, refBoxMinArray);
-      shaderConsts->setSafe(probeShaderConsts->mRefBoxMaxSC, refBoxMaxArray);
-      shaderConsts->setSafe(probeShaderConsts->mProbeConfigDataSC, probeConfigArray);
+      shaderConsts->setSafe(probeShaderConsts->mRefBoxMinSC, probeSet.refBoxMinArray);
+      shaderConsts->setSafe(probeShaderConsts->mRefBoxMaxSC, probeSet.refBoxMaxArray);
+      shaderConsts->setSafe(probeShaderConsts->mProbeConfigDataSC, probeSet.probeConfigArray);
 
-      shaderConsts->setSafe(probeShaderConsts->mSkylightCubemapIdxSC, (float)skyLightIdx);
+      shaderConsts->setSafe(probeShaderConsts->mSkylightCubemapIdxSC, (float)probeSet.skyLightIdx);
 
       if(probeShaderConsts->mBRDFTextureMap->getSamplerRegister() != -1 && mBRDFTexture.isValid())
          GFX->setTexture(probeShaderConsts->mBRDFTextureMap->getSamplerRegister(), mBRDFTexture);
@@ -679,6 +611,90 @@ void RenderProbeMgr::_update4ProbeConsts(const SceneData &sgData,
    }
 }
 
+void RenderProbeMgr::getBestProbes(const Point3F& objPosition, ProbeDataSet* probeDataSet)
+{
+   PROFILE_SCOPE(ProbeManager_getBestProbes);
+
+   // Skip over gathering lights if we don't have to!
+   //if (probeShaderConsts->isValid())
+   {
+      //Array rendering
+      U32 probeCount = mRegisteredProbes.size();
+
+      Vector<S8> bestPickProbes;
+
+      probeDataSet->effectiveProbeCount = 0;
+      for (U32 i = 0; i < probeCount; i++)
+      {
+         const ProbeRenderInst& curEntry = mRegisteredProbes[i];
+         if (!curEntry.mIsEnabled)
+            continue;
+
+         if (!curEntry.mIsSkylight)
+         {
+            F32 dist = Point3F(objPosition - curEntry.getPosition()).len();
+
+            if (dist > curEntry.mRadius || dist > curEntry.mExtents.len())
+               continue;
+
+            S32 bestPickIndex = -1;
+            for (U32 p = 0; p < bestPickProbes.size(); p++)
+            {
+               if (p > probeDataSet->MAX_PROBE_COUNT)
+                  break;
+
+               if (bestPickProbes[p] == -1 || (Point3F(objPosition - mRegisteredProbes[bestPickProbes[p]].mPosition).len() > dist))
+                  bestPickIndex = p;
+            }
+
+            //Can't have over our max count. Otherwise, if we haven't found a good slot for our best pick, insert it
+            //if we have a best pick slot, update it
+            if (bestPickIndex == -1 || bestPickProbes.size() >= probeDataSet->MAX_PROBE_COUNT)
+               bestPickProbes.push_back(i);
+            else
+               bestPickProbes[bestPickIndex] = i;
+         }
+         else
+         {
+            probeDataSet->skyLightIdx = curEntry.mCubemapIndex;
+         }
+      }
+
+      //Grab our best probe picks
+      for (U32 i = 0; i < bestPickProbes.size(); i++)
+      {
+         if (bestPickProbes[i] == -1)
+            continue;
+
+         const ProbeRenderInst& curEntry = mRegisteredProbes[bestPickProbes[i]];
+
+         probeDataSet->probePositionArray[probeDataSet->effectiveProbeCount] = curEntry.getPosition();
+         probeDataSet->probeRefPositionArray[probeDataSet->effectiveProbeCount] = curEntry.mProbeRefOffset;
+         probeDataSet->probeWorldToObjArray[probeDataSet->effectiveProbeCount] = curEntry.getTransform();
+
+         Point3F refPos = curEntry.getPosition() + curEntry.mProbeRefOffset;
+         Point3F refBoxMin = refPos - curEntry.mProbeRefScale * curEntry.getTransform().getScale();
+         Point3F refBoxMax = refPos + curEntry.mProbeRefScale * curEntry.getTransform().getScale();
+
+         probeDataSet->refBoxMinArray[probeDataSet->effectiveProbeCount] = Point4F(refBoxMin.x, refBoxMin.y, refBoxMin.z, 0);
+         probeDataSet->refBoxMaxArray[probeDataSet->effectiveProbeCount] = Point4F(refBoxMax.x, refBoxMax.y, refBoxMax.z, 0);
+         probeDataSet->probeConfigArray[probeDataSet->effectiveProbeCount] = Point4F(curEntry.mProbeShapeType,
+            curEntry.mRadius,
+            curEntry.mAtten,
+            curEntry.mCubemapIndex);
+
+         probeDataSet->effectiveProbeCount++;
+      }
+   }
+}
+
+void RenderProbeMgr::getProbeTextureData(ProbeTextureArrayData* probeTextureSet)
+{
+   probeTextureSet->BRDFTexture = mBRDFTexture;
+   probeTextureSet->prefilterArray = mPrefilterArray;
+   probeTextureSet->irradianceArray = mIrradianceArray;
+}
+
 void RenderProbeMgr::setProbeInfo(ProcessedMaterial *pmat,
    const Material *mat,
    const SceneData &sgData,

Engine/source/renderInstance/renderProbeMgr.h

@@ -100,6 +100,8 @@ struct ProbeRenderInst
 
    U32 mProbeIdx;
 
+   F32 mMultiplier;
+
 public:
 
    ProbeRenderInst();
@@ -165,6 +167,51 @@ struct ProbeShaderConstants
 
 typedef Map<GFXShader*, ProbeShaderConstants*> ProbeConstantMap;
 
+struct ProbeDataSet
+{
+   AlignedArray<Point4F> probePositionArray;
+   AlignedArray<Point4F> refBoxMinArray;
+   AlignedArray<Point4F> refBoxMaxArray;
+   AlignedArray<Point4F> probeRefPositionArray;
+   AlignedArray<Point4F> probeConfigArray;
+
+   Vector<MatrixF> probeWorldToObjArray;
+
+   S32 skyLightIdx;
+
+   U32 effectiveProbeCount;
+
+   U32 MAX_PROBE_COUNT;
+
+   ProbeDataSet(U32 maxProbeCount)
+   {
+      MAX_PROBE_COUNT = maxProbeCount;
+
+      probePositionArray = AlignedArray<Point4F>(maxProbeCount, sizeof(Point4F));
+      refBoxMinArray = AlignedArray<Point4F>(maxProbeCount, sizeof(Point4F));
+      refBoxMaxArray = AlignedArray<Point4F>(maxProbeCount, sizeof(Point4F));
+      probeRefPositionArray = AlignedArray<Point4F>(maxProbeCount, sizeof(Point4F));
+      probeConfigArray = AlignedArray<Point4F>(maxProbeCount, sizeof(Point4F));
+
+      probeWorldToObjArray.setSize(maxProbeCount);
+
+      // Need to clear the buffers so that we don't leak
+      // lights from previous passes or have NaNs.
+      dMemset(probePositionArray.getBuffer(), 0, probePositionArray.getBufferSize());
+      dMemset(refBoxMinArray.getBuffer(), 0, refBoxMinArray.getBufferSize());
+      dMemset(refBoxMaxArray.getBuffer(), 0, refBoxMaxArray.getBufferSize());
+      dMemset(probeRefPositionArray.getBuffer(), 0, probeRefPositionArray.getBufferSize());
+      dMemset(probeConfigArray.getBuffer(), 0, probeConfigArray.getBufferSize());
+   }
+};
+
+struct ProbeTextureArrayData
+{
+   GFXTexHandle BRDFTexture;
+   GFXCubemapArrayHandle prefilterArray;
+   GFXCubemapArrayHandle irradianceArray;
+};
+
 //**************************************************************************
 // RenderObjectMgr
 //**************************************************************************
@@ -292,11 +339,18 @@ public:
 
    void updateProbeTexture(ProbeRenderInst* probeInfo);
 
+   void reloadTextures();
+
    /// Debug rendering
    static bool smRenderReflectionProbes;
 
    void bakeProbe(ReflectionProbe *probeInfo);
    void bakeProbes();
+
+   void getProbeTextureData(ProbeTextureArrayData* probeTextureSet);
+   S32 getSkylightIndex() { return mSkylightCubemapIdx; }
+   //accumulates the best fit of probes given the object position
+   void getBestProbes(const Point3F& objPosition, ProbeDataSet* probeDataSet);
 };
 
 RenderProbeMgr* RenderProbeMgr::getProbeManager()

Engine/source/ts/tsShape.cpp

@@ -2143,7 +2143,7 @@ template<> void *Resource<TSShape>::create(const Torque::Path &path)
       ret = new TSShape;
       readSuccess = ret->read(&stream);
    }
-   else if ( extension.equal( "dae", String::NoCase ) || extension.equal( "kmz", String::NoCase ) )
+   /*else if ( extension.equal( "dae", String::NoCase ) || extension.equal( "kmz", String::NoCase ) )
    {
 #ifdef TORQUE_COLLADA
       // Attempt to load the DAE file
@@ -2164,7 +2164,7 @@ template<> void *Resource<TSShape>::create(const Torque::Path &path)
       ret = new TSShape;
       readSuccess = ret->read(&stream);
 #endif
-   }
+   }*/
    else
    {
       //Con::errorf( "Resource<TSShape>::create - '%s' has an unknown file format", path.getFullPath().c_str() );

Engine/source/util/fpsTracker.cpp

@@ -76,6 +76,8 @@ void FPSTracker::update()
    F32 update = fpsRealLast - fpsNext;
    if (update > 0.5f)
    {
+      F32 delta = realSeconds - fpsNext;
+      Con::setVariable( "fps::frameDelta",avar("%g", delta));
       Con::setVariable( "fps::real",      avar( "%4.1f", 1.0f / fpsReal ) );
       Con::setVariable( "fps::realMin",   avar( "%4.1f", 1.0f / fpsRealMin ) );
       Con::setVariable( "fps::realMax",   avar( "%4.1f", 1.0f / fpsRealMax ) );