Merge pull request #312 from Areloch/PostFXReorgAndUpdate

Reorgs the layout and editing of PostFX with some supplemental level save/load changes

Engine/source/T3D/Scene.cpp

@@ -34,6 +34,11 @@ void Scene::initPersistFields()
    addGroup("Gameplay");
    addField("gameModeName", TypeString, Offset(mGameModeName, Scene), "The name of the gamemode that this scene utilizes");
    endGroup("Gameplay");
+
+   addGroup("PostFX");
+   addProtectedField("EditPostEffects", TypeBool, Offset(mEditPostFX, Scene),
+      &Scene::_editPostEffects, &defaultProtectedGetFn, "Edit Scene's default Post Effects", AbstractClassRep::FieldFlags::FIELD_ComponentInspectors);
+   endGroup("PostFX");
 }
 
 bool Scene::onAdd()
@@ -88,6 +93,18 @@ void Scene::onPostAdd()
       Con::executef(this, "onPostAdd");
 }
 
+bool Scene::_editPostEffects(void* object, const char* index, const char* data)
+{
+   Scene* scene = static_cast<Scene*>(object);
+
+#ifdef TORQUE_TOOLS
+   if(Con::isFunction("editScenePostEffects"))
+      Con::executef("editScenePostEffects", scene);
+#endif
+
+   return false;
+}
+
 void Scene::addObject(SimObject* object)
 {
    //Child scene

Engine/source/T3D/Scene.h

@@ -35,6 +35,8 @@ class Scene : public NetObject, public virtual ITickable
 
    bool mIsDirty;
 
+   bool mEditPostFX;
+
    StringTableEntry mGameModeName;
 
 protected:
@@ -48,6 +50,8 @@ public:
 
    static void initPersistFields();
 
+   static bool _editPostEffects(void* object, const char* index, const char* data);
+
    virtual bool onAdd();
    virtual void onRemove();
    virtual void onPostAdd();

Engine/source/T3D/assets/LevelAsset.cpp

@@ -361,13 +361,27 @@ void LevelAsset::unloadDependencies()
    }
 }
 
-DefineEngineMethod(LevelAsset, getLevelFile, const char*, (),,
+DefineEngineMethod(LevelAsset, getLevelPath, const char*, (),,
    "Creates a new script asset using the targetFilePath.\n"
    "@return The bool result of calling exec")
 {
    return object->getLevelPath();
 }
 
+DefineEngineMethod(LevelAsset, getPostFXPresetPath, const char*, (), ,
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->getPostFXPresetPath();
+}
+
+DefineEngineMethod(LevelAsset, getDecalsPath, const char*, (), ,
+   "Creates a new script asset using the targetFilePath.\n"
+   "@return The bool result of calling exec")
+{
+   return object->getDecalsPath();
+}
+
 DefineEngineMethod(LevelAsset, loadDependencies, void, (), ,
    "Initiates the loading of asset dependencies for this level.")
 {

Templates/BaseGame/game/core/clientServer/scripts/client/levelDownload.cs

@@ -41,7 +41,7 @@
 $pref::Client::EnableDatablockCache = true;
 $pref::Client::DatablockCacheFilename = "data/cache/client/datablock_cache_c.dbc";
 
-function clientCmdMissionStartPhase1_LoadCache(%seq, %missionName)
+function clientCmdMissionStartPhase1_LoadCache(%seq, %levelAsset)
 {
   if ($pref::Client::EnableDatablockCache && $loadFromDatablockCache)
   {
@@ -57,16 +57,16 @@ function clientCmdMissionStartPhase1_LoadCache(%seq, %missionName)
     echo("<<<< Loading Datablocks From Cache >>>>");
     if (ServerConnection.loadDatablockCache_Begin())
     {
-      schedule(10, 0, "updateLoadDatablockCacheProgress", %seq, %missionName);
+      schedule(10, 0, "updateLoadDatablockCacheProgress", %seq, %levelAsset);
     }
   }
 }
 
-function updateLoadDatablockCacheProgress(%seq, %missionName)
+function updateLoadDatablockCacheProgress(%seq, %levelAsset)
 {
    if (ServerConnection.loadDatablockCache_Continue())
    {
-      $loadDatablockCacheProgressThread = schedule(10, 0, "updateLoadDatablockCacheProgress", %seq, %missionName);
+      $loadDatablockCacheProgressThread = schedule(10, 0, "updateLoadDatablockCacheProgress", %seq, %levelAsset);
       return;
    }
  
@@ -80,14 +80,14 @@ function updateLoadDatablockCacheProgress(%seq, %missionName)
    }
 
    echo("<<<< Finished Loading Datablocks From Cache >>>>");
-   clientCmdMissionStartPhase2(%seq,%missionName);
+   clientCmdMissionStartPhase2(%seq, %levelAsset);
 }
 
-function updateLoadDatablockCacheProgress(%seq, %missionName)
+function updateLoadDatablockCacheProgress(%seq, %levelAsset)
 {
    if (ServerConnection.loadDatablockCache_Continue())
    {
-      $loadDatablockCacheProgressThread = schedule(10, 0, "updateLoadDatablockCacheProgress", %seq, %missionName);
+      $loadDatablockCacheProgressThread = schedule(10, 0, "updateLoadDatablockCacheProgress", %seq, %levelAsset);
       return;
    }
  
@@ -101,21 +101,24 @@ function updateLoadDatablockCacheProgress(%seq, %missionName)
    }
 
    echo("<<<< Finished Loading Datablocks From Cache >>>>");
-   clientCmdMissionStartPhase2(%seq,%missionName);
+   clientCmdMissionStartPhase2(%seq, %levelAsset);
 }
 
-function clientCmdMissionStartPhase1(%seq, %missionName, %cache_crc)
+function clientCmdMissionStartPhase1(%seq, %levelAsset, %cache_crc)
 {
+   %levelAssetDef = AssetDatabase.acquireAsset(%levelAsset);
+   
    // These need to come after the cls.
-   echo ("*** New Mission: " @ %missionName);
+   echo ("*** New Mission: " @ %levelAssetDef.levelName);
    echo ("*** Phase 1: Download Datablocks & Targets");
    
-   $Client::MissionFile = %missionName;
+   $Client::LevelAsset = %levelAssetDef;
+   $Client::MissionFile = %levelAssetDef.getLevelPath();
    $pref::ReflectionProbes::CurrentLevelPath = filePath($Client::MissionFile) @ "/" @ fileBase($Client::MissionFile) @ "/probes/";
    
    //Prep the postFX stuff
    // Load the post effect presets for this mission.
-   %path = filePath( %missionName ) @ "/" @ fileBase( %missionName ) @ $PostFXManager::fileExtension;
+   %path = %levelAssetDef.getPostFXPresetPath();
 
    if ( isScriptFile( %path ) )
    {
@@ -190,7 +193,7 @@ function onDataBlockObjectReceived(%index, %total)
 //----------------------------------------------------------------------------
 // Phase 2
 //----------------------------------------------------------------------------
-function clientCmdMissionStartPhase2(%seq,%missionName)
+function clientCmdMissionStartPhase2(%seq, %levelAsset)
 {
    onPhaseComplete();
    echo ("*** Phase 2: Download Ghost Objects");
@@ -215,19 +218,21 @@ function onGhostAlwaysObjectReceived()
 //----------------------------------------------------------------------------
 // Phase 3
 //----------------------------------------------------------------------------
-function clientCmdMissionStartPhase3(%seq,%missionName)
+function clientCmdMissionStartPhase3(%seq, %levelAsset)
 {
    onPhaseComplete();
    StartClientReplication();
-   StartFoliageReplication();
+   
+   %levelAssetDef = AssetDatabase.acquireAsset(%levelAsset);
    
    // Load the static mission decals.
-   if(isFile(%missionName @ ".decals"))
+   if(isFile(%levelAssetDef.getDecalsPath()))
-      decalManagerLoad( %missionName @ ".decals" );
+      decalManagerLoad( %levelAssetDef.getDecalsPath() );
    
    echo ("*** Phase 3: Mission Lighting");
    $MSeq = %seq;
-   $Client::MissionFile = %missionName;
+   $Client::LevelAsset = %levelAssetDef;
+   $Client::MissionFile = %levelAssetDef.getLevelPath();
 
    // Need to light the mission before we are ready.
    // The sceneLightingComplete function will complete the handshake 

Templates/BaseGame/game/core/clientServer/scripts/server/levelDownload.cs

@@ -68,9 +68,9 @@ function GameConnection::loadMission(%this)
    }
    else
    {
-      commandToClient(%this, 'MissionStartPhase1', $missionSequence, $Server::MissionFile, %cache_crc);
+      commandToClient(%this, 'MissionStartPhase1', $missionSequence, $Server::LevelAsset.getAssetId(), %cache_crc);
          
-      echo("*** Sending mission load to client: " @ $Server::MissionFile);
+      echo("*** Sending mission load to client: " @ $Server::LevelAsset.getAssetId());
    }
 }
 
@@ -100,7 +100,7 @@ function GameConnection::onBeginDatablockCacheLoad( %this, %missionSequence )
    if (%this.currentPhase != 1)
       return;
    %this.currentPhase = 1.5;
-   commandToClient(%this, 'MissionStartPhase1_LoadCache', $missionSequence, $Server::MissionFile);
+   commandToClient(%this, 'MissionStartPhase1_LoadCache', $missionSequence, $Server::LevelAsset.getAssetId());
 }
 
 function serverCmdMissionStartPhase1Ack(%client, %seq)
@@ -129,7 +129,7 @@ function GameConnection::onDataBlocksDone( %this, %missionSequence )
    %this.currentPhase = 1.5;
 
    // On to the next phase
-   commandToClient(%this, 'MissionStartPhase2', $missionSequence, $Server::MissionFile);
+   commandToClient(%this, 'MissionStartPhase2', $missionSequence, $Server::LevelAsset.getAssetId());
 }
 
 //----------------------------------------------------------------------------
@@ -163,7 +163,7 @@ function GameConnection::onGhostAlwaysFailed(%client)
 function GameConnection::onGhostAlwaysObjectsReceived(%client)
 {
    // Ready for next phase.
-   commandToClient(%client, 'MissionStartPhase3', $missionSequence, $Server::MissionFile);
+   commandToClient(%client, 'MissionStartPhase3', $missionSequence, $Server::LevelAsset.getAssetId());
 }
 
 //----------------------------------------------------------------------------

Templates/BaseGame/game/core/clientServer/scripts/server/levelLoad.cs

@@ -44,7 +44,7 @@ function loadMission( %levelAsset, %isFirstMission )
    // increment the mission sequence (used for ghost sequencing)
    $missionSequence++;
    $missionRunning = false;
-   $Server::MissionFile = $Server::LevelAsset.getLevelFile();
+   $Server::MissionFile = $Server::LevelAsset.getLevelPath();
    $Server::LoadFailMsg = "";
    
    $Server::LevelAsset.loadDependencies();

Templates/BaseGame/game/core/gameObjects/datablocks/defaultDatablocks.cs

@@ -1,6 +1,6 @@
 datablock ReflectorDesc( DefaultCubeDesc )
 {  
-   texSize = 256;
+   texSize = 64;
    nearDist = 0.1;
    farDist = 1000.0;
    objectTypeMask = 0xFFFFFFFF;

Templates/BaseGame/game/core/postFX/scripts/CameraMotionBlur/CameraMotionBlurPostFX.asset.taml

@@ -0,0 +1,8 @@
+<PostEffectAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="CameraMotionBlurPostFX"
+    scriptFile="@assetFile=CameraMotionBlurPostFX.cs"
+    hlslShader="@assetFile=CameraMotionBlurPostFXP.hlsl"
+    glslShader="@assetFile=CameraMotionBlurPostFXP.glsl"
+    VersionId="1" />

Templates/BaseGame/game/core/postFX/scripts/CameraMotionBlur/CameraMotionBlurPostFX.cs

@@ -0,0 +1,124 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+$PostFX::CameraMotionBlurPostFX::samples = 5;
+$PostFX::CameraMotionBlurPostFX::velocityMultiplier = 3000;
+
+singleton ShaderData( CameraMotionBlurPostFX_Shader )
+{
+   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
+   DXPixelShaderFile 	= "./CameraMotionBlurPostFXP.hlsl";   
+   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
+   OGLPixelShaderFile   = "./CameraMotionBlurPostFXP.glsl";
+   
+   samplerNames[0] = "$backBuffer";
+   samplerNames[1] = "$deferredTex";
+   
+   pixVersion = 3.0;
+};
+
+singleton GFXStateBlockData( CameraMotionBlurPostFX_StateBlock )
+{
+   zDefined = true;
+   zEnable = false;
+   zWriteEnable = false;
+      
+   samplersDefined = true;
+   samplerStates[0] = SamplerClampLinear;
+};
+
+
+function CameraMotionBlurPostFX::setShaderConsts( %this )
+{
+   %this.setShaderConst( "$velocityMultiplier", $PostFX::CameraMotionBlurPostFX::velocityMultiplier );
+   %this.setShaderConst( "$samples", $PostFX::CameraMotionBlurPostFX::samples );
+}
+
+function CameraMotionBlurPostFX::preProcess( %this )
+{
+}
+
+function CameraMotionBlurPostFX::onAdd(%this)
+{
+   //Register the postFX with the manager
+   PostFXManager.registerPostEffect(%this);
+}
+
+function CameraMotionBlurPostFX::onEnabled( %this )
+{
+   return true;
+}
+
+function CameraMotionBlurPostFX::onDisabled( %this )
+{
+   return true;
+}
+
+//This is used to populate the PostFXEditor's settings so the post FX can be edited
+//This is automatically polled for any postFX that has been registered(in our onAdd) and the settings
+//are thus exposed for editing
+function CameraMotionBlurPostFX::populatePostFXSettings(%this)
+{
+   PostEffectEditorInspector.startGroup("CameraMotionBlurPostFX - General");
+   PostEffectEditorInspector.addCallbackField("$PostFX::CameraMotionBlurPostFX::Enabled", "Enabled", "bool", "", $PostFX::CameraMotionBlurPostFX::Enabled, "", "toggleCameraMotionBlurPostFX");
+   PostEffectEditorInspector.addField("$PostFX::CameraMotionBlurPostFX::velocityMultiplier", "Velocity Multiplier", "float", "", $PostFX::CameraMotionBlurPostFX::velocityMultiplier, "");
+   PostEffectEditorInspector.addField("$PostFX::CameraMotionBlurPostFX::samples", "Sample Count", "float", "", $PostFX::CameraMotionBlurPostFX::samples, "");
+   PostEffectEditorInspector.endGroup();
+}
+
+//This is called back from our callbackField defined in populatePostFXSettings to
+//Allow us to easily toggle the postFX and have it respond immediately
+function PostEffectEditorInspector::toggleCameraMotionBlurPostFX(%this)
+{
+   if($PostFX::CameraMotionBlurPostFX::Enabled)
+      CameraMotionBlurPostFX.enable();
+   else
+      CameraMotionBlurPostFX.disable();
+}
+
+function CameraMotionBlurPostFX::applyFromPreset(%this)
+{
+   if($PostFX::CameraMotionBlurPostFX::Enabled)
+      %this.enable();
+   else
+      %this.disable();
+}
+
+function CameraMotionBlurPostFX::savePresetSettings(%this)
+{
+   PostFXManager::savePresetSetting("$PostFX::CameraMotionBlurPostFX::Enabled");
+   PostFXManager::savePresetSetting("$PostFX::CameraMotionBlurPostFX::velocityMultiplier");
+   PostFXManager::savePresetSetting("$PostFX::CameraMotionBlurPostFX::samples");
+}
+
+//Our actual postFX
+singleton PostEffect( CameraMotionBlurPostFX )
+{
+   isEnabled = false;
+   renderTime = "PFXAfterDiffuse"; 
+
+   shader = CameraMotionBlurPostFX_Shader;
+   stateBlock = CameraMotionBlurPostFX_StateBlock;
+   texture[0] = "$backbuffer";
+   texture[1] = "#deferred";
+   target = "$backBuffer";
+};

Templates/BaseGame/game/core/postFX/scripts/CameraMotionBlur/CameraMotionBlurPostFXP.glsl

@@ -20,10 +20,10 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
 #include "shadergen:/autogenConditioners.h"
-#include "postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 #undef IN_uv0
 #define _IN_uv0 uv0

Templates/BaseGame/game/core/postFX/scripts/CameraMotionBlur/CameraMotionBlurPostFXP.hlsl

@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
-#include "../shaderModelAutoGen.hlsl"
+#include "core/rendering/shaders/shaderModelAutoGen.hlsl"
 
 uniform float4x4 matPrevScreenToWorld;
 uniform float4x4 matWorldToScreen;

Templates/BaseGame/game/core/postFX/scripts/Caustics/CausticsPostFX.asset.taml

@@ -1,6 +1,6 @@
 <PostEffectAsset
     canSave="true"
     canSaveDynamicFields="true"
-    AssetName="vignettePostFX"
+    AssetName="CausticsPostFX"
-    scriptFile="@assetFile=vignettePostFX.cs"
+    scriptFile="@assetFile=CausticsPostFX.cs"
     VersionId="1" />

Templates/BaseGame/game/core/postFX/scripts/Caustics/CausticsPostFX.cs

@@ -36,10 +36,10 @@ singleton GFXStateBlockData( PFX_CausticsStateBlock : PFX_DefaultStateBlock )
 singleton ShaderData( PFX_CausticsShader )
 {   
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/caustics/causticsP.hlsl";
+   DXPixelShaderFile 	= "./causticsP.hlsl";
          
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/caustics/gl/causticsP.glsl";
+   OGLPixelShaderFile   = "./causticsP.glsl";
       
    samplerNames[0] = "$deferredTex";
    samplerNames[1] = "$causticsTex0";

Templates/BaseGame/game/core/postFX/scripts/Caustics/CausticsPostFXP.glsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 #include "shadergen:/autogenConditioners.h"
 
 uniform vec3    eyePosWorld;

Templates/BaseGame/game/core/postFX/scripts/Caustics/CausticsPostFXP.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFx.hlsl"
-#include "../../shaderModelAutoGen.hlsl"
+#include "core/rendering/shaders/shaderModelAutoGen.hlsl"
 
 uniform float     accumTime;
 uniform float3    eyePosWorld;

Templates/BaseGame/game/core/postFX/scripts/ChromaticAberration/ChromaticAberrationPostFX.asset.taml

@@ -0,0 +1,8 @@
+<PostEffectAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="ChromaticAberrationPostFX"
+    scriptFile="@assetFile=ChromaticAberrationPostFX.cs"
+    hlslShader="@assetFile=ChromaticAberrationPostFXP.hlsl"
+    glslShader="@assetFile=ChromaticAberrationPostFXP.glsl"
+    VersionId="1" />

Templates/BaseGame/game/core/postFX/scripts/ChromaticAberration/ChromaticAberrationPostFX.cs

@@ -0,0 +1,156 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+/// The lens distortion coefficient.
+$PostFX::EnableChromaticAberrationPostFX::DistCoefficient =  -0.05;
+
+/// The cubic distortion value.
+$PostFX::EnableChromaticAberrationPostFX::CubeDistortionFactor =  -0.1;
+
+/// The amount and direction of the maxium shift for
+/// the red, green, and blue channels.
+$PostFX::EnableChromaticAberrationPostFX::ColorDistFactor = "0.005 -0.005 0.01";
+
+singleton ShaderData( ChromaticAberrationPostFX_Shader )
+{
+   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
+   DXPixelShaderFile 	= "./ChromaticAberrationPostFXP.hlsl";   
+   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
+   OGLPixelShaderFile   = "./ChromaticAberrationPostFXP.glsl";
+   
+   samplerNames[0] = "$inputTex";
+   
+   pixVersion = 2.0;
+};
+
+singleton GFXStateBlockData( ChromaticAberrationPostFX_StateBlock )
+{
+   samplersDefined = true;
+   samplerStates[0] = SamplerClampLinear;
+   samplerStates[1] = SamplerClampLinear;
+   samplerStates[2] = SamplerClampLinear;
+   samplerStates[3] = SamplerClampLinear;
+   
+   blendDefined = true;
+   blendDest = GFXBlendOne;
+   blendSrc = GFXBlendZero;
+   
+   zDefined = true;
+   zEnable = false;
+   zWriteEnable = false;
+   
+   cullDefined = true;
+   cullMode = GFXCullNone;
+};
+
+
+function ChromaticAberrationPostFX::setShaderConsts( %this )
+{
+   %this.setShaderConst( "$distCoeff", $PostFX::EnableChromaticAberrationPostFX::DistCoefficient );   
+   %this.setShaderConst( "$cubeDistort", $PostFX::EnableChromaticAberrationPostFX::CubeDistortionFactor );    
+   %this.setShaderConst( "$colorDistort", $PostFX::EnableChromaticAberrationPostFX::ColorDistFactor ); 
+}
+
+function ChromaticAberrationPostFX::preProcess( %this )
+{
+}
+
+function ChromaticAberrationPostFX::onAdd(%this)
+{
+   //Register the postFX with the manager
+   PostFXManager.registerPostEffect(%this);
+}
+
+function ChromaticAberrationPostFX::onEnabled( %this )
+{
+   return true;
+}
+
+function ChromaticAberrationPostFX::onDisabled( %this )
+{
+}
+
+//This is used to populate the PostFXEditor's settings so the post FX can be edited
+//This is automatically polled for any postFX that has been registered(in our onAdd) and the settings
+//are thus exposed for editing
+function ChromaticAberrationPostFX::populatePostFXSettings(%this)
+{
+   PostEffectEditorInspector.startGroup("ChromaticAberrationPostFX - General");
+   PostEffectEditorInspector.addCallbackField("$PostFX::EnableChromaticAberrationPostFX::Enabled", "Enabled", "bool", "", $PostFX::EnableChromaticAberrationPostFX::Enabled, "", "toggleChromaticAberrationPostFX");
+   PostEffectEditorInspector.addField("$PostFX::EnableChromaticAberrationPostFX::DistCoefficient", "Dist Coefficient", "float", "", $PostFX::EnableChromaticAberrationPostFX::DistCoefficient, "");
+   PostEffectEditorInspector.addField("$PostFX::EnableChromaticAberrationPostFX::CubeDistortionFactor", "Cube Distortion Factor", "float", "", $PostFX::EnableChromaticAberrationPostFX::CubeDistortionFactor, "");
+   PostEffectEditorInspector.addField("$PostFX::EnableChromaticAberrationPostFX::ColorDistFactor", "Color Distortion Factor", "string", "", $PostFX::EnableChromaticAberrationPostFX::ColorDistFactor, "");
+   PostEffectEditorInspector.endGroup();
+}
+
+function PostEffectEditorInspector::toggleChromaticAberrationPostFX(%this)
+{
+   if($PostFX::EnableChromaticAberrationPostFX::Enabled)
+      ChromaticAberrationPostFX.enable();
+   else
+      ChromaticAberrationPostFX.disable();
+}
+
+//This function pair(applyFromPreset and settingsApply) are done the way they are, with the separated variables
+//so that we can effectively store the 'settings' away from the live variables that the postFX's actually utilize
+//when rendering. This allows us to modify things but still leave room for reverting or temporarily applying them
+function ChromaticAberrationPostFX::applyFromPreset(%this)
+{
+   if($PostFX::EnableChromaticAberrationPostFX::Enabled)
+      %this.enable();
+   else
+      %this.disable();
+}
+
+function ChromaticAberrationPostFX::savePresetSettings(%this)
+{
+   PostFXManager::savePresetSetting("$PostFX::EnableChromaticAberrationPostFX::Enabled");
+   PostFXManager::savePresetSetting("$PostFX::EnableChromaticAberrationPostFX::DistCoefficient");
+   PostFXManager::savePresetSetting("$PostFX::EnableChromaticAberrationPostFX::CubeDistortionFactor");
+   PostFXManager::savePresetSetting("$PostFX::EnableChromaticAberrationPostFX::ColorDistFactor");
+}
+
+//Our actual postFX
+singleton PostEffect( ChromaticAberrationPostFX )
+{
+   isEnabled = false;
+   allowReflectPass = false;
+
+   // Resolve the HDR before we render any editor stuff
+   // and before we resolve the scene to the backbuffer.
+   renderTime = "PFXBeforeBin";
+   renderBin = "EditorBin";
+   renderPriority = 9999;
+      
+   // The bright pass generates a bloomed version of 
+   // the scene for pixels which are brighter than a 
+   // fixed threshold value.
+   //
+   // This is then used in the final HDR combine pass
+   // at the end of this post effect chain.
+   shader = ChromaticAberrationPostFX_Shader;
+   stateBlock = PFX_DefaultStateBlock;
+   texture[0] = "$backBuffer";
+   target = "$backBuffer";
+   targetFormat = "GFXFormatR16G16B16A16F"; 
+   targetScale = "1 1";
+};

Templates/BaseGame/game/core/postFX/scripts/ChromaticAberration/ChromaticAberrationPostFXP.glsl

@@ -0,0 +1,13 @@
+#include "core/rendering/shaders/gl/torque.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
+#include "shadergen:/autogenConditioners.h"
+#include "core/rendering/shaders/postFX/gl/postFX.glsl"
+
+uniform sampler2D inputTex;
+
+out vec4 OUT_col;
+
+void main()
+{
+   OUT_col = hdrEncode( vec4(1,1,1,1) );
+}

Templates/BaseGame/game/core/postFX/scripts/ChromaticAberration/ChromaticAberrationPostFXP.hlsl

@@ -0,0 +1,35 @@
+#include "core/rendering/shaders/postFX/postFx.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
+
+TORQUE_UNIFORM_SAMPLER2D(inputTex, 0);
+uniform float distCoeff;
+uniform float cubeDistort;
+uniform float3 colorDistort;
+
+float4 main( PFXVertToPix IN ) : TORQUE_TARGET0
+{
+   float2 tex = IN.uv0;
+
+    float f = 0;
+    float r2 = (tex.x - 0.5) * (tex.x - 0.5) + (tex.y - 0.5) * (tex.y - 0.5);       
+
+    // Only compute the cubic distortion if necessary.
+    if ( cubeDistort == 0.0 )
+        f = 1 + r2 * distCoeff;
+    else
+        f = 1 + r2 * (distCoeff + cubeDistort * sqrt(r2));
+
+    // Distort each color channel seperately to get a chromatic distortion effect.
+    float3 outColor;
+    float3 distort = f.xxx + colorDistort;
+
+   [unroll]
+    for ( int i=0; i < 3; i++ )
+    {
+        float x = distort[i] * ( tex.x - 0.5 ) + 0.5;
+        float y = distort[i] * ( tex.y - 0.5 ) + 0.5;
+        outColor[i] = TORQUE_TEX2DLOD( inputTex, float4(x,y,0,0) )[i];
+    }
+
+    return float4( outColor.rgb, 1 );
+}

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_CalcCoC_P.glsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 // These are set by the game engine.  
 uniform sampler2D shrunkSampler;  // Output of DofDownsample()  

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_CalcCoC_P.hlsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 // These are set by the game engine.  
 TORQUE_UNIFORM_SAMPLER2D(shrunkSampler, 0);  // Output of DofDownsample()

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_CalcCoC_V.glsl

@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform vec4 rtParams0;
 uniform vec4 rtParams1;

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_CalcCoC_V.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "./../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
 
 uniform float4 rtParams0;
 uniform float4 rtParams1;

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_DownSample_P.glsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
 
 // These are set by the game engine.  

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_DownSample_P.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../shaderModel.hlsl"
+#include "core/rendering/shaders/shaderModel.hlsl"
-#include "../../shaderModelAutoGen.hlsl"
+#include "core/rendering/shaders/shaderModelAutoGen.hlsl"
 
 // These are set by the game engine.  
 // The render target size is one-quarter the scene rendering size.  

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_DownSample_V.glsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
 
 in vec4 vPosition;
 in vec2 vTexCoord0;

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_DownSample_V.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "./../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
 
 struct Vert
 {

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_Final_P.glsl

@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform sampler2D colorSampler; // Original source image  
 uniform sampler2D smallBlurSampler; // Output of SmallBlurPS()  

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_Final_P.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../shaderModelAutoGen.hlsl"
+#include "core/rendering/shaders/shaderModelAutoGen.hlsl"
-#include "./../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(colorSampler,0); // Original source image 
 TORQUE_UNIFORM_SAMPLER2D(smallBlurSampler,1); // Output of SmallBlurPS()  

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_Final_V.glsl

@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform vec4 rtParams0;
 uniform vec4 rtParams1;

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_Final_V.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "./../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
 
 uniform float4 rtParams0;
 uniform float4 rtParams1;

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_Gausian_P.glsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
 
 in vec3 wsEyeRay;

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_Gausian_P.hlsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0);
 

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_Gausian_V.glsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
 
 in vec4 vPosition;
 in vec2 vTexCoord0;

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_Gausian_V.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "./../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
 
 
 uniform float4 rtParams0;

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_Passthrough_V.glsl

@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform vec4 rtParams0;
 uniform vec4 rtParams1;

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_Passthrough_V.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "./../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
 
 uniform float4 rtParams0;
 uniform float4 rtParams1;

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_SmallBlur_P.glsl

@@ -25,7 +25,7 @@
 // The sample weights are 1/16 in the corners, 2/16 on the edges,  
 // and 4/16 in the center.
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 
 uniform sampler2D colorSampler;  // Output of DofNearCoc()  
 

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_SmallBlur_P.hlsl

@@ -24,7 +24,7 @@
 // colorMapSampler, which is the same size as the render target.  
 // The sample weights are 1/16 in the corners, 2/16 on the edges,  
 // and 4/16 in the center.  
-#include "../../shaderModel.hlsl"
+#include "core/rendering/shaders/shaderModel.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(colorSampler, 0); // Output of DofNearCoc()
 

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_SmallBlur_V.glsl

@@ -25,8 +25,8 @@
 // The sample weights are 1/16 in the corners, 2/16 on the edges,  
 // and 4/16 in the center.  
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
 
 in vec4 vPosition;
 in vec2 vTexCoord0;

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DOF_SmallBlur_V.hlsl

@@ -25,8 +25,8 @@
 // The sample weights are 1/16 in the corners, 2/16 on the edges,  
 // and 4/16 in the center.  
 
-#include "./../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "./../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
 
 struct Vert
 {

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DepthOfFieldPostFX.asset.taml

@@ -0,0 +1,6 @@
+<PostEffectAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="DepthOfFieldPostFX"
+    scriptFile="@assetFile=DepthOfFieldPostFX.cs"
+    VersionId="1" />

Templates/BaseGame/game/core/postFX/scripts/DepthOfField/DepthOfFieldPostFX.cs

@@ -1,32 +1,11 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2012 GarageGames, LLC
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-//-----------------------------------------------------------------------------
 
 /*
 
 ================================================================================
- The DOFPostEffect API
+ The DepthOfFieldPostFX API
 ================================================================================
 
-DOFPostEffect::setFocalDist( %dist )
+DepthOfFieldPostFX::setFocalDist( %dist )
 
 @summary
 This method is for manually controlling the focus distance. It will have no 
@@ -38,7 +17,7 @@ float distance in meters
 
 --------------------------------------------------------------------------------
 
-DOFPostEffect::setAutoFocus( %enabled )
+DepthOfFieldPostFX::setAutoFocus( %enabled )
 
 @summary
 This method sets auto focus enabled or disabled. Makes use of the parameters set 
@@ -50,7 +29,7 @@ bool
 
 --------------------------------------------------------------------------------
 
-DOFPostEffect::setFocusParams( %nearBlurMax, %farBlurMax, %minRange, %maxRange, %nearSlope, %farSlope )
+DepthOfFieldPostFX::setFocusParams( %nearBlurMax, %farBlurMax, %minRange, %maxRange, %nearSlope, %farSlope )
 
 Set the parameters that control how the near and far equations are calculated
 from the focal distance. If you are not using auto focus you will need to call
@@ -101,19 +80,19 @@ NOTE: These are not real callbacks! Hook these up to your code where appropriate
 function onSniperZoom()
 {
    // Parameterize how you want DOF to look.
-   DOFPostEffect.setFocusParams( 0.3, 0.3, 50, 500, -5, 5 );
+   DepthOfFieldPostFX.setFocusParams( 0.3, 0.3, 50, 500, -5, 5 );
    
    // Turn on auto focus
-   DOFPostEffect.setAutoFocus( true );
+   DepthOfFieldPostFX.setAutoFocus( true );
    
    // Turn on the PostEffect
-   DOFPostEffect.enable();
+   DepthOfFieldPostFX.enable();
 }
 
 function onSniperUnzoom()
 {
    // Turn off the PostEffect
-   DOFPostEffect.disable();
+   DepthOfFieldPostFX.disable();
 }
 
 Example2: Manually control DOF with the mouse wheel.
@@ -121,13 +100,13 @@ Example2: Manually control DOF with the mouse wheel.
 // Somewhere on startup...
 
 // Parameterize how you want DOF to look.
-DOFPostEffect.setFocusParams( 0.3, 0.3, 50, 500, -5, 5 );
+DepthOfFieldPostFX.setFocusParams( 0.3, 0.3, 50, 500, -5, 5 );
 
 // Turn off auto focus
-DOFPostEffect.setAutoFocus( false );
+DepthOfFieldPostFX.setAutoFocus( false );
 
 // Turn on the PostEffect
-DOFPostEffect.enable();
+DepthOfFieldPostFX.enable();
 
 
 NOTE: These are not real callbacks! Hook these up to your code where appropriate!
@@ -136,19 +115,19 @@ function onMouseWheelUp()
 {
    // Since setFocalDist is really just a wrapper to assign to the focalDist
    // dynamic field we can shortcut and increment it directly.
-   DOFPostEffect.focalDist += 8;
+   DepthOfFieldPostFX.focalDist += 8;
 }
 
 function onMouseWheelDown()
 {
-   DOFPostEffect.focalDist -= 8;
+   DepthOfFieldPostFX.focalDist -= 8;
 }
 */
 
 /// This method is for manually controlling the focal distance. It will have no 
 /// effect if auto focus is currently enabled. Makes use of the parameters set by 
 /// setFocusParams.
-function DOFPostEffect::setFocalDist( %this, %dist )
+function DepthOfFieldPostFX::setFocalDist( %this, %dist )
 {    
    %this.focalDist = %dist;
 }
@@ -156,7 +135,7 @@ function DOFPostEffect::setFocalDist( %this, %dist )
 /// This method sets auto focus enabled or disabled. Makes use of the parameters set 
 /// by setFocusParams. When auto focus is enabled it determine the focal depth
 /// by performing a raycast at the screen-center.
-function DOFPostEffect::setAutoFocus( %this, %enabled )
+function DepthOfFieldPostFX::setAutoFocus( %this, %enabled )
 {
    %this.autoFocusEnabled = %enabled;
 }
@@ -164,7 +143,7 @@ function DOFPostEffect::setAutoFocus( %this, %enabled )
 /// Set the parameters that control how the near and far equations are calculated
 /// from the focal distance. If you are not using auto focus you will need to call
 /// setFocusParams PRIOR to calling setFocalDist.
-function DOFPostEffect::setFocusParams( %this, %nearBlurMax, %farBlurMax, %minRange, %maxRange, %nearSlope, %farSlope )
+function DepthOfFieldPostFX::setFocusParams( %this, %nearBlurMax, %farBlurMax, %minRange, %maxRange, %nearSlope, %farSlope )
 {
    %this.nearBlurMax = %nearBlurMax;
    %this.farBlurMax = %farBlurMax;
@@ -318,11 +297,11 @@ singleton GFXStateBlockData( PFX_DOFFinalStateBlock )
 
 singleton ShaderData( PFX_DOFDownSampleShader )
 {      
-   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/dof/DOF_DownSample_V.hlsl";   
+   DXVertexShaderFile 	= "./DOF_DownSample_V.hlsl";   
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/dof/DOF_DownSample_P.hlsl";            
+   DXPixelShaderFile 	= "./DOF_DownSample_P.hlsl";            
    
-   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/dof/gl/DOF_DownSample_V.glsl";
+   OGLVertexShaderFile  = "./DOF_DownSample_V.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/dof/gl/DOF_DownSample_P.glsl";
+   OGLPixelShaderFile   = "./DOF_DownSample_P.glsl";
    
    samplerNames[0] = "$colorSampler";
    samplerNames[1] = "$depthSampler";
@@ -332,11 +311,11 @@ singleton ShaderData( PFX_DOFDownSampleShader )
 
 singleton ShaderData( PFX_DOFBlurYShader )
 {
-   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/dof/DOF_Gausian_V.hlsl";
+   DXVertexShaderFile 	= "./DOF_Gausian_V.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/dof/DOF_Gausian_P.hlsl";
+   DXPixelShaderFile 	= "./DOF_Gausian_P.hlsl";
    
-   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/dof/gl/DOF_Gausian_V.glsl";
+   OGLVertexShaderFile  = "./DOF_Gausian_V.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/dof/gl/DOF_Gausian_P.glsl";
+   OGLPixelShaderFile   = "./DOF_Gausian_P.glsl";
    
    samplerNames[0] = "$diffuseMap";
    
@@ -351,11 +330,11 @@ singleton ShaderData( PFX_DOFBlurXShader : PFX_DOFBlurYShader )
 
 singleton ShaderData( PFX_DOFCalcCoCShader )
 {   
-   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/dof/DOF_CalcCoC_V.hlsl";
+   DXVertexShaderFile 	= "./DOF_CalcCoC_V.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/dof/DOF_CalcCoC_P.hlsl";         
+   DXPixelShaderFile 	= "./DOF_CalcCoC_P.hlsl";         
    
-   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/dof/gl/DOF_CalcCoC_V.glsl";
+   OGLVertexShaderFile  = "./DOF_CalcCoC_V.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/dof/gl/DOF_CalcCoC_P.glsl"; 
+   OGLPixelShaderFile   = "./DOF_CalcCoC_P.glsl"; 
 
    samplerNames[0] = "$shrunkSampler";
    samplerNames[1] = "$blurredSampler";
@@ -365,11 +344,11 @@ singleton ShaderData( PFX_DOFCalcCoCShader )
 
 singleton ShaderData( PFX_DOFSmallBlurShader )
 {   
-   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/dof/DOF_SmallBlur_V.hlsl";
+   DXVertexShaderFile 	= "./DOF_SmallBlur_V.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/dof/DOF_SmallBlur_P.hlsl";            
+   DXPixelShaderFile 	= "./DOF_SmallBlur_P.hlsl";            
    
-   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/dof/gl/DOF_SmallBlur_V.glsl";
+   OGLVertexShaderFile  = "./DOF_SmallBlur_V.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/dof/gl/DOF_SmallBlur_P.glsl";
+   OGLPixelShaderFile   = "./DOF_SmallBlur_P.glsl";
 
    samplerNames[0] = "$colorSampler";
    
@@ -378,11 +357,11 @@ singleton ShaderData( PFX_DOFSmallBlurShader )
 
 singleton ShaderData( PFX_DOFFinalShader )
 {   
-   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/dof/DOF_Final_V.hlsl";
+   DXVertexShaderFile 	= "./DOF_Final_V.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/dof/DOF_Final_P.hlsl";
+   DXPixelShaderFile 	= "./DOF_Final_P.hlsl";
    
-   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/dof/gl/DOF_Final_V.glsl";
+   OGLVertexShaderFile  = "./DOF_Final_V.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/dof/gl/DOF_Final_P.glsl";
+   OGLPixelShaderFile   = "./DOF_Final_P.glsl";
    
    samplerNames[0] = "$colorSampler";
    samplerNames[1] = "$smallBlurSampler";
@@ -396,7 +375,7 @@ singleton ShaderData( PFX_DOFFinalShader )
 // PostEffects
 //-----------------------------------------------------------------------------
 
-function DOFPostEffect::onAdd( %this )
+function DepthOfFieldPostFX::onAdd( %this )
 {
    // The weighted distribution of CoC value to the three blur textures
    // in the order small, medium, large. Most likely you will not need to
@@ -417,14 +396,16 @@ function DOFPostEffect::onAdd( %this )
    PostFXManager.registerPostEffect(%this);
 }
 
-function DOFPostEffect::setLerpDist( %this, %d0, %d1, %d2 )
+function DepthOfFieldPostFX::setLerpDist( %this, %d0, %d1, %d2 )
 {
    %this.lerpScale = -1.0 / %d0 SPC -1.0 / %d1 SPC -1.0 / %d2 SPC 1.0 / %d2;
    %this.lerpBias = 1.0 SPC ( 1.0 - %d2 ) / %d1 SPC 1.0 / %d2 SPC ( %d2 - 1.0 ) / %d2;
 }
 
-singleton PostEffect( DOFPostEffect )
+singleton PostEffect( DepthOfFieldPostFX )
 {
+   isEnabled = false;
+   
    renderTime = "PFXAfterBin";
    renderBin = "GlowBin";      
    renderPriority = 0.1;
@@ -436,75 +417,83 @@ singleton PostEffect( DOFPostEffect )
    target = "#shrunk";
    targetScale = "0.25 0.25";   
    
-   isEnabled = false;
+   singleton PostEffect( DOFBlurY )
-};
+   {
-
+      shader = PFX_DOFBlurYShader;
-singleton PostEffect( DOFBlurY )
+      stateBlock = PFX_DOFBlurStateBlock;
-{
+      texture[0] = "#shrunk";
-   shader = PFX_DOFBlurYShader;
+      target = "$outTex";
-   stateBlock = PFX_DOFBlurStateBlock;
+   };
-   texture[0] = "#shrunk";
-   target = "$outTex";
-};
-
-DOFPostEffect.add( DOFBlurY );
-
-singleton PostEffect( DOFBlurX )
-{
-   shader = PFX_DOFBlurXShader;
-   stateBlock = PFX_DOFBlurStateBlock;
-   texture[0] = "$inTex";  
-   target = "#largeBlur";
-};
-
-DOFPostEffect.add( DOFBlurX );
-
-singleton PostEffect( DOFCalcCoC )
-{
-   shader = PFX_DOFCalcCoCShader;
-   stateBlock = PFX_DOFCalcCoCStateBlock;
-   texture[0] = "#shrunk";
-   texture[1] = "#largeBlur";
-   target = "$outTex";
-};
-
-DOFPostEffect.add( DOFCalcCoc );
-  
-singleton PostEffect( DOFSmallBlur )
-{
-   shader = PFX_DOFSmallBlurShader;
-   stateBlock = PFX_DefaultDOFStateBlock;
-   texture[0] = "$inTex";
-   target = "$outTex";
-};
-
-DOFPostEffect.add( DOFSmallBlur );
    
-singleton PostEffect( DOFFinalPFX )
+   singleton PostEffect( DOFBlurX )
-{
+   {
-   shader = PFX_DOFFinalShader;
+      shader = PFX_DOFBlurXShader;
-   stateBlock = PFX_DOFFinalStateBlock;
+      stateBlock = PFX_DOFBlurStateBlock;
-   texture[0] = "$backBuffer";
+      texture[0] = "$inTex";  
-   texture[1] = "$inTex";
+      target = "#largeBlur";
-   texture[2] = "#largeBlur";   
+   };
-   texture[3] = "#deferred";   
+   
-   target = "$backBuffer";
+   singleton PostEffect( DOFCalcCoC )
+   {
+      shader = PFX_DOFCalcCoCShader;
+      stateBlock = PFX_DOFCalcCoCStateBlock;
+      texture[0] = "#shrunk";
+      texture[1] = "#largeBlur";
+      target = "$outTex";
+   };
+   
+   singleton PostEffect( DOFSmallBlur )
+   {
+      shader = PFX_DOFSmallBlurShader;
+      stateBlock = PFX_DefaultDOFStateBlock;
+      texture[0] = "$inTex";
+      target = "$outTex";
+   };
+   
+   singleton PostEffect( DOFFinalPFX )
+   {
+      shader = PFX_DOFFinalShader;
+      stateBlock = PFX_DOFFinalStateBlock;
+      texture[0] = "$backBuffer";
+      texture[1] = "$inTex";
+      texture[2] = "#largeBlur";   
+      texture[3] = "#deferred";   
+      target = "$backBuffer";
+   };
 };
 
-DOFPostEffect.add( DOFFinalPFX );
-
-
 //-----------------------------------------------------------------------------
 // Scripts
 //-----------------------------------------------------------------------------
-function DOFPostEffect::populatePostFXSettings(%this)
+function DepthOfFieldPostFX::populatePostFXSettings(%this)
 {
-   PostEffectEditorInspector.startGroup("Depth of Field");
+   PostEffectEditorInspector.startGroup("Depth of Field - General");
-   PostEffectEditorInspector.addField("isEnabled", "Enabled", "bool", "", DOFPostEffect.isEnabled, "", DOFPostEffect);
+   PostEffectEditorInspector.addCallbackField("$PostFX::DepthOfFieldPostFX::Enabled", "Enabled", "bool", "", $PostFX::DepthOfFieldPostFX::Enabled, "", "toggleDepthOfFieldPostFX");
    PostEffectEditorInspector.endGroup();
 }
 
-function DOFPostEffect::setShaderConsts( %this )
+function PostEffectEditorInspector::toggleDepthOfFieldPostFX(%this)
+{
+   if($PostFX::DepthOfFieldPostFX::Enabled)
+      DepthOfFieldPostFX.enable();
+   else
+      DepthOfFieldPostFX.disable();
+}
+
+function DepthOfFieldPostFX::applyFromPreset(%this)
+{
+   if($PostFX::DepthOfFieldPostFX::Enabled)
+      DepthOfFieldPostFX.enable();
+   else
+      DepthOfFieldPostFX.disable();
+}
+
+function DepthOfFieldPostFX::savePresetSettings(%this)
+{
+   PostFXManager::savePresetSetting("$PostFX::DepthOfFieldPostFX::Enabled");
+}
+
+function DepthOfFieldPostFX::setShaderConsts( %this )
 {
    if ( %this.autoFocusEnabled )
       %this.autoFocus();
@@ -553,7 +542,7 @@ function DOFPostEffect::setShaderConsts( %this )
    DOFFinalPFX.setShaderConst( "$dofLerpBias", %this.lerpBias );  
 }
 
-function DOFPostEffect::autoFocus( %this )
+function DepthOfFieldPostFX::autoFocus( %this )
 {      
    if ( !isObject( ServerConnection ) ||   
         !isObject( ServerConnection.getCameraObject() ) )
@@ -593,9 +582,9 @@ function DOFPostEffect::autoFocus( %this )
 function reloadDOF()
 {
    exec( "./dof.cs" );
-   DOFPostEffect.reload();  
+   DepthOfFieldPostFX.reload();  
-   DOFPostEffect.disable();
+   DepthOfFieldPostFX.disable();
-   DOFPostEffect.enable();
+   DepthOfFieldPostFX.enable();
 }
 
 function dofMetricsCallback()

Templates/BaseGame/game/core/postFX/scripts/EdgeDetect/dbgEdgeDisplayP.glsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
 
 in vec2 uv0;

Templates/BaseGame/game/core/postFX/scripts/EdgeDetect/dbgEdgeDisplayP.hlsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(edgeBuffer);
 

Templates/BaseGame/game/core/postFX/scripts/EdgeDetect/edgeAAP.glsl

@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform sampler2D edgeBuffer;
 uniform sampler2D backBuffer;

Templates/BaseGame/game/core/postFX/scripts/EdgeDetect/edgeAAP.hlsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(edgeBuffer,0);
 TORQUE_UNIFORM_SAMPLER2D(backBuffer, 1);

Templates/BaseGame/game/core/postFX/scripts/EdgeDetect/edgeAAPostFX.asset.taml

@@ -0,0 +1,6 @@
+<PostEffectAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="edgeAAPostFX"
+    scriptFile="@assetFile=edgeAAPostFX.cs"
+    VersionId="1" />

Templates/BaseGame/game/core/postFX/scripts/EdgeDetect/edgeAAPostFX.cs

@@ -35,10 +35,10 @@ singleton GFXStateBlockData( PFX_DefaultEdgeAAStateBlock )
 singleton ShaderData( PFX_EdgeAADetectShader )
 {   
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/edgeaa/edgeDetectP.hlsl";
+   DXPixelShaderFile 	= "./edgeDetectP.hlsl";
          
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/edgeaa/gl/edgeDetectP.glsl";
+   OGLPixelShaderFile   = "./edgeDetectP.glsl";
       
    samplerNames[0] = "$deferredBuffer";
    
@@ -47,11 +47,11 @@ singleton ShaderData( PFX_EdgeAADetectShader )
 
 singleton ShaderData( PFX_EdgeAAShader )
 {   
-   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/edgeaa/edgeAAV.hlsl";
+   DXVertexShaderFile 	= "./edgeAAV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/edgeaa/edgeAAP.hlsl";
+   DXPixelShaderFile 	= "./edgeAAP.hlsl";
          
-   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/edgeaa/gl/edgeAAV.glsl";
+   OGLVertexShaderFile  = "./edgeAAV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/edgeaa/gl/edgeAAP.glsl";
+   OGLPixelShaderFile   = "./edgeAAP.glsl";
       
    samplerNames[0] = "$edgeBuffer";
    samplerNames[1] = "$backBuffer";
@@ -62,10 +62,10 @@ singleton ShaderData( PFX_EdgeAAShader )
 singleton ShaderData( PFX_EdgeAADebugShader )
 {   
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/edgeaa/dbgEdgeDisplayP.hlsl";
+   DXPixelShaderFile 	= "./dbgEdgeDisplayP.hlsl";
          
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/edgeaa/gl/dbgEdgeDisplayP.glsl";
+   OGLPixelShaderFile   = "./dbgEdgeDisplayP.glsl";
       
    samplerNames[0] = "$edgeBuffer";
    

Templates/BaseGame/game/core/postFX/scripts/EdgeDetect/edgeAAV.glsl

@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform vec4 rtParams0;
 uniform vec4 rtParams1;

Templates/BaseGame/game/core/postFX/scripts/EdgeDetect/edgeAAV.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "./../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
 
 
 uniform float4 rtParams0;

Templates/BaseGame/game/core/postFX/scripts/EdgeDetect/edgeDetectP.glsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
 
 // GPU Gems 3, pg 443-444

Templates/BaseGame/game/core/postFX/scripts/EdgeDetect/edgeDetectP.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "../../shaderModelAutoGen.hlsl"
+#include "core/rendering/shaders/shaderModelAutoGen.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(deferredBuffer,0);
 

Templates/BaseGame/game/core/postFX/scripts/FXAA/FXAAPostFX.cs

@@ -36,11 +36,11 @@ singleton GFXStateBlockData( FXAA_StateBlock : PFX_DefaultStateBlock )
 
 singleton ShaderData( FXAA_ShaderData )
 {   
-   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/fxaa/fxaaV.hlsl";
+   DXVertexShaderFile 	= "./fxaaV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/fxaa/fxaaP.hlsl";
+   DXPixelShaderFile 	= "./fxaaP.hlsl";
    
-   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/fxaa/gl/fxaaV.glsl";
+   OGLVertexShaderFile  = "./fxaaV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/fxaa/gl/fxaaP.glsl";
+   OGLPixelShaderFile   = "./fxaaP.glsl";
    
    samplerNames[0] = "$colorTex";
 

Templates/BaseGame/game/core/postFX/scripts/FXAA/fxaaP.glsl

@@ -25,8 +25,8 @@
 #define FXAA_QUALITY__PRESET 12
 #define FXAA_GREEN_AS_LUMA 1
 
-#include "../Fxaa3_11.h"
+#include "Fxaa3_11.h"
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 
 uniform sampler2D colorTex ;
 uniform vec2 oneOverTargetSize;

Templates/BaseGame/game/core/postFX/scripts/FXAA/fxaaP.hlsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../shaderModel.hlsl"
+#include "core/rendering/shaders/shaderModel.hlsl"
 
 #define FXAA_PC 1
 #if TORQUE_SM == 40

Templates/BaseGame/game/core/postFX/scripts/FXAA/fxaaV.glsl

@@ -19,8 +19,8 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
 
 in vec4 vPosition;
 in vec2 vTexCoord0;

Templates/BaseGame/game/core/postFX/scripts/FXAA/fxaaV.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
-#include "./../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 struct VertToPix
 {

Templates/BaseGame/game/core/postFX/scripts/Flash/flashPostFX.asset.taml

@@ -0,0 +1,6 @@
+<PostEffectAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="flashPostFX"
+    scriptFile="@assetFile=flashPostFX.cs"
+    VersionId="1" />

Templates/BaseGame/game/core/postFX/scripts/Flash/flashPostFX.cs

@@ -23,10 +23,10 @@
 singleton ShaderData( PFX_FlashShader )
 {
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/flashP.hlsl";
+   DXPixelShaderFile 	= "./flashP.hlsl";
    
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/gl/flashP.glsl";
+   OGLPixelShaderFile   = "./flashP.glsl";
    
    samplerNames[0] = "$backBuffer";
 

Templates/BaseGame/game/core/postFX/scripts/Fog/fogP.glsl

@@ -20,10 +20,10 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 
 #include "shadergen:/autogenConditioners.h"
-#include "../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
 
 uniform sampler2D deferredTex ;
 uniform vec3    eyePosWorld;

Templates/BaseGame/game/core/postFX/scripts/Fog/fogP.hlsl

@@ -21,9 +21,9 @@
 //-----------------------------------------------------------------------------
 
 
-#include "./postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "./../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
-#include "./../shaderModelAutoGen.hlsl"
+#include "core/rendering/shaders/shaderModelAutoGen.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(deferredTex, 0);
 uniform float3    eyePosWorld;

Templates/BaseGame/game/core/postFX/scripts/Fog/fogPostFX.cs

@@ -27,10 +27,10 @@
 singleton ShaderData( FogPassShader )
 {   
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/fogP.hlsl";
+   DXPixelShaderFile 	= "./fogP.hlsl";
          
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/gl/fogP.glsl";
+   OGLPixelShaderFile   = "./fogP.glsl";
             
    samplerNames[0] = "$deferredTex";
    

Templates/BaseGame/game/core/postFX/scripts/Gamma/GammaPostFX.asset.taml

@@ -0,0 +1,8 @@
+<PostEffectAsset
+    canSave="true"
+    canSaveDynamicFields="true"
+    AssetName="GammaPostFX"
+    scriptFile="@assetFile=GammaPostFX.cs"
+    hlslShader="@assetFile=gammaP.hlsl"
+    glslShader="@assetFile=gammaP.glsl"
+    VersionId="1" />

Templates/BaseGame/game/core/postFX/scripts/Gamma/GammaPostFX.cs

@@ -23,10 +23,10 @@
 singleton ShaderData( GammaShader )
 {
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/gammaP.hlsl";
+   DXPixelShaderFile 	= "./gammaP.hlsl";
 
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/gl/gammaP.glsl";
+   OGLPixelShaderFile   = "./gammaP.glsl";
    
    samplerNames[0] = "$backBuffer";
    samplerNames[1] = "$colorCorrectionTex";
@@ -54,14 +54,11 @@ singleton PostEffect( GammaPostFX )
    stateBlock = GammaStateBlock;
    
    texture[0] = "$backBuffer";  
-   texture[1] = $HDRPostFX::colorCorrectionRamp;  
    textureSRGB[1] = true;
 };
 
 function GammaPostFX::preProcess( %this )
 {
-   if ( %this.texture[1] !$= $HDRPostFX::colorCorrectionRamp )
-      %this.setTexture( 1, $HDRPostFX::colorCorrectionRamp );         
 }
 
 function GammaPostFX::setShaderConsts( %this )
@@ -70,4 +67,60 @@ function GammaPostFX::setShaderConsts( %this )
    %this.setShaderConst( "$OneOverGamma", 1 / %clampedGamma );
    %this.setShaderConst( "$Brightness", $pref::Video::Brightness );
    %this.setShaderConst( "$Contrast", $pref::Video::Contrast );
-}
+}
+
+function GammaPostFX::onAdd(%this)
+{
+   //Register the postFX with the manager
+   PostFXManager.registerPostEffect(%this);
+}
+
+function GammaPostFX::onEnabled( %this )
+{
+   return true;
+}
+
+function GammaPostFX::onDisabled( %this )
+{
+}
+
+//This is used to populate the PostFXEditor's settings so the post FX can be edited
+//This is automatically polled for any postFX that has been registered(in our onAdd) and the settings
+//are thus exposed for editing
+function GammaPostFX::populatePostFXSettings(%this)
+{
+   PostEffectEditorInspector.startGroup("GammaPostFX - General");
+   PostEffectEditorInspector.addCallbackField("$PostFX::GammaPostFX::Enabled", "Enable", "bool", "", $PostFX::GammaPostFX::Enabled, "", "toggleGammaPostFX");
+   PostEffectEditorInspector.endGroup();
+}
+
+function PostEffectEditorInspector::toggleGammaPostFX(%this)
+{
+   //If we're toggling between gamma then we're also toggling HDR the opposite way
+   if($PostFX::GammaPostFX::Enabled)
+   {
+      HDRPostFX.disable();
+   }
+   else
+   {
+      HDRPostFX.enable();
+   }
+}
+
+function GammaPostFX::applyFromPreset(%this)
+{
+   if($PostFX::GammaPostFX::Enabled)
+   {
+      HDRPostFX.disable();
+   }
+   else
+   {
+      HDRPostFX.enable();
+   }
+}
+
+function GammaPostFX::savePresetSettings(%this)
+{
+   PostFXManager::savePresetSetting("$PostFX::GammaPostFX::Enabled");
+}
+

Templates/BaseGame/game/core/postFX/scripts/Gamma/gammaP.glsl

@@ -20,12 +20,11 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
 #include "shadergen:/autogenConditioners.h"
 
 uniform sampler2D backBuffer;
-uniform sampler1D colorCorrectionTex;
 
 uniform float OneOverGamma;
 uniform float Brightness;
@@ -39,11 +38,6 @@ void main()
 {
     vec4 color = texture(backBuffer, uv0.xy);
 
-   // Apply the color correction.
-   color.r = texture( colorCorrectionTex, color.r ).r;
-   color.g = texture( colorCorrectionTex, color.g ).g;
-   color.b = texture( colorCorrectionTex, color.b ).b;
-
    // Apply contrast
    color.rgb = ((color.rgb - 0.5f) * Contrast) + 0.5f;
  

Templates/BaseGame/game/core/postFX/scripts/Gamma/gammaP.hlsl

@@ -21,11 +21,10 @@
 //-----------------------------------------------------------------------------
 
 #include "shadergen:/autogenConditioners.h"  
-#include "./postFx.hlsl"  
+#include "core/rendering/shaders/postFX/postFx.hlsl"  
-#include "../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(backBuffer, 0);
-TORQUE_UNIFORM_SAMPLER1D(colorCorrectionTex, 1);
 
 uniform float OneOverGamma;
 uniform float Brightness;
@@ -35,11 +34,6 @@ float4 main( PFXVertToPix IN ) : TORQUE_TARGET0
 {
     float4 color = TORQUE_TEX2D(backBuffer, IN.uv0.xy);
 
-   // Apply the color correction.
-   color.r = TORQUE_TEX1D( colorCorrectionTex, color.r ).r;
-   color.g = TORQUE_TEX1D( colorCorrectionTex, color.g ).g;
-   color.b = TORQUE_TEX1D( colorCorrectionTex, color.b ).b;
-
    // Apply contrast
    color.rgb = ((color.rgb - 0.5f) * Contrast) + 0.5f;
  

Templates/BaseGame/game/core/postFX/scripts/Glow/GlowPostFX.cs

@@ -23,11 +23,11 @@
 
 singleton ShaderData( PFX_GlowBlurVertShader )
 {
-   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/glowBlurV.hlsl";
+   DXVertexShaderFile 	= "./glowBlurV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/glowBlurP.hlsl";
+   DXPixelShaderFile 	= "./glowBlurP.hlsl";
    
-   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/glowBlurV.glsl";
+   OGLVertexShaderFile  = "./glowBlurV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/gl/glowBlurP.glsl";
+   OGLPixelShaderFile   = "./glowBlurP.glsl";
       
    defines = "BLUR_DIR=float2(0.0,1.0)";
 
@@ -109,11 +109,11 @@ singleton PostEffect( GlowPostFX )
 
 singleton ShaderData( PFX_VolFogGlowBlurVertShader )
 {
-	DXVertexShaderFile = $Core::CommonShaderPath @ "/postFX/glowBlurV.hlsl";
+	DXVertexShaderFile = "./glowBlurV.hlsl";
-	DXPixelShaderFile = $Core::CommonShaderPath @ "/postFX/VolFogGlowP.hlsl";
+	DXPixelShaderFile = "./VolFogGlowP.hlsl";
 	
-	OGLVertexShaderFile = $Core::CommonShaderPath @ "/postFX/gl/glowBlurV.glsl";
+	OGLVertexShaderFile = "./glowBlurV.glsl";
-	OGLPixelShaderFile = $Core::CommonShaderPath @ "/postFX/gl/VolFogGlowP.glsl";	
+	OGLPixelShaderFile = "./VolFogGlowP.glsl";	
 	
 	defines = "BLUR_DIR=float2(0.0,1.0)";
 	samplerNames[0] = "$diffuseMap";
@@ -121,11 +121,11 @@ singleton ShaderData( PFX_VolFogGlowBlurVertShader )
 };
 singleton ShaderData( PFX_VolFogGlowBlurHorzShader : PFX_VolFogGlowBlurVertShader )
 {
-	DXVertexShaderFile = $Core::CommonShaderPath @ "/postFX/glowBlurV.hlsl";
+	DXVertexShaderFile = "./glowBlurV.hlsl";
-	DXPixelShaderFile = $Core::CommonShaderPath @ "/postFX/VolFogGlowP.hlsl";
+	DXPixelShaderFile = "./VolFogGlowP.hlsl";
 	
-	OGLVertexShaderFile = $Core::CommonShaderPath @ "/postFX/gl/glowBlurV.glsl";
+	OGLVertexShaderFile = "./glowBlurV.glsl";
-	OGLPixelShaderFile = $Core::CommonShaderPath @ "/postFX/gl/VolFogGlowP.glsl";
+	OGLPixelShaderFile = "./VolFogGlowP.glsl";
 	
 	defines = "BLUR_DIR=float2(1.0,0.0)";
 };

Templates/BaseGame/game/core/postFX/scripts/Glow/glowBlurP.glsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 
 uniform sampler2D diffuseMap ;
 

Templates/BaseGame/game/core/postFX/scripts/Glow/glowBlurP.hlsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(diffuseMap, 0);
 

Templates/BaseGame/game/core/postFX/scripts/Glow/glowBlurV.glsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
 
 in vec4 vPosition;
 in vec2 vTexCoord0;

Templates/BaseGame/game/core/postFX/scripts/Glow/glowBlurV.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "./postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "./../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
 
 
 uniform float2 texSize0;

Templates/BaseGame/game/core/postFX/scripts/HDR/HDRPostFX.cs

@@ -22,63 +22,63 @@
 
 
 /// Blends between the scene and the tone mapped scene.
-$HDRPostFX::enableToneMapping = 0.5;
+$PostFX::HDRPostFX::enableToneMapping = 0.5;
 
 /// The tone mapping middle grey or exposure value used
 /// to adjust the overall "balance" of the image.
 ///
 /// 0.18 is fairly common value.
 ///
-$HDRPostFX::keyValue = 0.18;
+$PostFX::HDRPostFX::keyValue = 0.18;
 
 /// The minimum luninace value to allow when tone mapping 
 /// the scene.  Is particularly useful if your scene very 
 /// dark or has a black ambient color in places.
-$HDRPostFX::minLuminace = 0.001;
+$PostFX::HDRPostFX::minLuminace = 0.001;
 
 /// The lowest luminance value which is mapped to white.  This
 /// is usually set to the highest visible luminance in your 
 /// scene.  By setting this to smaller values you get a contrast
 /// enhancement.
-$HDRPostFX::whiteCutoff = 1.0;
+$PostFX::HDRPostFX::whiteCutoff = 1.0;
 
 /// The rate of adaptation from the previous and new 
 /// average scene luminance. 
-$HDRPostFX::adaptRate = 2.0;
+$PostFX::HDRPostFX::adaptRate = 2.0;
 
 /// Blends between the scene and the blue shifted version
 /// of the scene for a cinematic desaturated night effect.
-$HDRPostFX::enableBlueShift = 0.0;
+$PostFX::HDRPostFX::enableBlueShift = 0.0;
 
 /// The blue shift color value.
-$HDRPostFX::blueShiftColor = "1.05 0.97 1.27";
+$PostFX::HDRPostFX::blueShiftColor = "1.05 0.97 1.27";
 
 
 /// Blends between the scene and the bloomed scene.
-$HDRPostFX::enableBloom = 1.0;
+$PostFX::HDRPostFX::enableBloom = 1.0;
 
 /// The threshold luminace value for pixels which are
 /// considered "bright" and need to be bloomed.
-$HDRPostFX::brightPassThreshold = 1.0;
+$PostFX::HDRPostFX::brightPassThreshold = 1.0;
 
 /// These are used in the gaussian blur of the
 /// bright pass for the bloom effect.
-$HDRPostFX::gaussMultiplier = 0.3;
+$PostFX::HDRPostFX::gaussMultiplier = 0.3;
-$HDRPostFX::gaussMean = 0.0;
+$PostFX::HDRPostFX::gaussMean = 0.0;
-$HDRPostFX::gaussStdDev = 0.8;
+$PostFX::HDRPostFX::gaussStdDev = 0.8;
 
-/// The 1x255 color correction ramp texture used
+// The tonemapping algo to use
-/// by both the HDR shader and the GammaPostFx shader
+$PostFX::HDRPostFX::tonemapMode = "Filmic";
-/// for doing full screen color correction. 
+
-$HDRPostFX::colorCorrectionRamp = "core/postFX/images/null_color_ramp.png";
+$PostFX::HDRPostFX::enableAutoExposure = true;
 
 
 singleton ShaderData( HDR_BrightPassShader )
 {
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/hdr/brightPassFilterP.hlsl";   
+   DXPixelShaderFile 	= "./brightPassFilterP.hlsl";   
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/hdr/gl/brightPassFilterP.glsl";
+   OGLPixelShaderFile   = "./brightPassFilterP.glsl";
    
    samplerNames[0] = "$inputTex";
    samplerNames[1] = "$luminanceTex";
@@ -88,10 +88,10 @@ singleton ShaderData( HDR_BrightPassShader )
 
 singleton ShaderData( HDR_DownScale4x4Shader )
 {
-   DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/hdr/downScale4x4V.hlsl";
+   DXVertexShaderFile 	= "./downScale4x4V.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/hdr/downScale4x4P.hlsl";
+   DXPixelShaderFile 	= "./downScale4x4P.hlsl";
-   OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/hdr/gl/downScale4x4V.glsl";
+   OGLVertexShaderFile  = "./downScale4x4V.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/hdr/gl/downScale4x4P.glsl";
+   OGLPixelShaderFile   = "./downScale4x4P.glsl";
    
    samplerNames[0] = "$inputTex";
    
@@ -101,9 +101,9 @@ singleton ShaderData( HDR_DownScale4x4Shader )
 singleton ShaderData( HDR_BloomGaussBlurHShader )
 {
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/hdr/bloomGaussBlurHP.hlsl";
+   DXPixelShaderFile 	= "./bloomGaussBlurHP.hlsl";
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/hdr/gl/bloomGaussBlurHP.glsl";
+   OGLPixelShaderFile   = "./bloomGaussBlurHP.glsl";
    
    samplerNames[0] = "$inputTex";
    
@@ -113,9 +113,9 @@ singleton ShaderData( HDR_BloomGaussBlurHShader )
 singleton ShaderData( HDR_BloomGaussBlurVShader )
 {
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/hdr/bloomGaussBlurVP.hlsl";
+   DXPixelShaderFile 	= "./bloomGaussBlurVP.hlsl";
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/hdr/gl/bloomGaussBlurVP.glsl";
+   OGLPixelShaderFile   = "./bloomGaussBlurVP.glsl";
    
    samplerNames[0] = "$inputTex";
    
@@ -125,9 +125,9 @@ singleton ShaderData( HDR_BloomGaussBlurVShader )
 singleton ShaderData( HDR_SampleLumShader )
 {
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/hdr/sampleLumInitialP.hlsl";
+   DXPixelShaderFile 	= "./sampleLumInitialP.hlsl";
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/hdr/gl/sampleLumInitialP.glsl";
+   OGLPixelShaderFile   = "./sampleLumInitialP.glsl";
    
    samplerNames[0] = "$inputTex";
    
@@ -137,9 +137,9 @@ singleton ShaderData( HDR_SampleLumShader )
 singleton ShaderData( HDR_DownSampleLumShader )
 {
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/hdr/sampleLumIterativeP.hlsl";
+   DXPixelShaderFile 	= "./sampleLumIterativeP.hlsl";
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/hdr/gl/sampleLumIterativeP.glsl";
+   OGLPixelShaderFile   = "./sampleLumIterativeP.glsl";
    
    samplerNames[0] = "$inputTex";
    
@@ -149,9 +149,9 @@ singleton ShaderData( HDR_DownSampleLumShader )
 singleton ShaderData( HDR_CalcAdaptedLumShader )
 {
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/hdr/calculateAdaptedLumP.hlsl";
+   DXPixelShaderFile 	= "./calculateAdaptedLumP.hlsl";
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/hdr/gl/calculateAdaptedLumP.glsl";
+   OGLPixelShaderFile   = "./calculateAdaptedLumP.glsl";
    
    samplerNames[0] = "$currLum";
    samplerNames[1] = "$lastAdaptedLum";
@@ -162,9 +162,9 @@ singleton ShaderData( HDR_CalcAdaptedLumShader )
 singleton ShaderData( HDR_CombineShader )
 {
    DXVertexShaderFile 	= $Core::CommonShaderPath @ "/postFX/postFxV.hlsl";
-   DXPixelShaderFile 	= $Core::CommonShaderPath @ "/postFX/hdr/finalPassCombineP.hlsl";
+   DXPixelShaderFile 	= "./finalPassCombineP.hlsl";
    OGLVertexShaderFile  = $Core::CommonShaderPath @ "/postFX/gl/postFxV.glsl";
-   OGLPixelShaderFile   = $Core::CommonShaderPath @ "/postFX/hdr/gl/finalPassCombineP.glsl";
+   OGLPixelShaderFile   = "./finalPassCombineP.glsl";
    
    samplerNames[0] = "$sceneTex";
    samplerNames[1] = "$luminanceTex";
@@ -221,20 +221,20 @@ singleton GFXStateBlockData( HDRStateBlock )
 
 function HDRPostFX::setShaderConsts( %this )
 {
-   %this.setShaderConst( "$brightPassThreshold", $HDRPostFX::brightPassThreshold );
+   %this.setShaderConst( "$brightPassThreshold", $PostFX::HDRPostFX::brightPassThreshold );
-   %this.setShaderConst( "$g_fMiddleGray", $HDRPostFX::keyValue );   
+   %this.setShaderConst( "$g_fMiddleGray", $PostFX::HDRPostFX::keyValue );   
          
    %bloomH = %this-->bloomH;
-   %bloomH.setShaderConst( "$gaussMultiplier", $HDRPostFX::gaussMultiplier );
+   %bloomH.setShaderConst( "$gaussMultiplier", $PostFX::HDRPostFX::gaussMultiplier );
-   %bloomH.setShaderConst( "$gaussMean", $HDRPostFX::gaussMean );
+   %bloomH.setShaderConst( "$gaussMean", $PostFX::HDRPostFX::gaussMean );
-   %bloomH.setShaderConst( "$gaussStdDev", $HDRPostFX::gaussStdDev );   
+   %bloomH.setShaderConst( "$gaussStdDev", $PostFX::HDRPostFX::gaussStdDev );   
 
    %bloomV = %this-->bloomV;
-   %bloomV.setShaderConst( "$gaussMultiplier", $HDRPostFX::gaussMultiplier );
+   %bloomV.setShaderConst( "$gaussMultiplier", $PostFX::HDRPostFX::gaussMultiplier );
-   %bloomV.setShaderConst( "$gaussMean", $HDRPostFX::gaussMean );
+   %bloomV.setShaderConst( "$gaussMean", $PostFX::HDRPostFX::gaussMean );
-   %bloomV.setShaderConst( "$gaussStdDev", $HDRPostFX::gaussStdDev );   
+   %bloomV.setShaderConst( "$gaussStdDev", $PostFX::HDRPostFX::gaussStdDev );   
 
-   %minLuminace = $HDRPostFX::minLuminace;
+   %minLuminace = $PostFX::HDRPostFX::minLuminace;
    if ( %minLuminace <= 0.0 )
    {
       // The min should never be pure zero else the
@@ -243,22 +243,32 @@ function HDRPostFX::setShaderConsts( %this )
    }
    %this-->adaptLum.setShaderConst( "$g_fMinLuminace", %minLuminace );
         
-   %this-->finalLum.setShaderConst( "$adaptRate", $HDRPostFX::adaptRate );
+   %this-->finalLum.setShaderConst( "$adaptRate", $PostFX::HDRPostFX::adaptRate );
    
    %combinePass = %this-->combinePass;   
-   %combinePass.setShaderConst( "$g_fEnableToneMapping", $HDRPostFX::enableToneMapping );
+   %combinePass.setShaderConst( "$g_fEnableToneMapping", $PostFX::HDRPostFX::enableToneMapping );
-   %combinePass.setShaderConst( "$g_fMiddleGray", $HDRPostFX::keyValue );
+   %combinePass.setShaderConst( "$g_fMiddleGray", $PostFX::HDRPostFX::keyValue );
-   %combinePass.setShaderConst( "$g_fBloomScale", $HDRPostFX::enableBloom );      
+   %combinePass.setShaderConst( "$g_fBloomScale", $PostFX::HDRPostFX::enableBloom );      
-   %combinePass.setShaderConst( "$g_fEnableBlueShift", $HDRPostFX::enableBlueShift );   
+   %combinePass.setShaderConst( "$g_fEnableBlueShift", $PostFX::HDRPostFX::enableBlueShift );   
-   %combinePass.setShaderConst( "$g_fBlueShiftColor", $HDRPostFX::blueShiftColor );   
+   %combinePass.setShaderConst( "$g_fBlueShiftColor", $PostFX::HDRPostFX::blueShiftColor );   
+   
+   %combinePass.setShaderConst( "$g_fEnableAutoExposure", $PostFX::HDRPostFX::enableAutoExposure );
+   
+   %tonemapMode = 1;
+   if($PostFX::HDRPostFX::tonemapMode $= "Filmic")
+      %tonemapMode = 1;
+   else if($PostFX::HDRPostFX::tonemapMode $= "ACES")
+      %tonemapMode = 2;
+      
+   %combinePass.setShaderConst( "$g_fTonemapMode", %tonemapMode );
    
    %clampedGamma  = mClamp( $pref::Video::Gamma, 2.0, 2.5);
    %combinePass.setShaderConst( "$g_fOneOverGamma",  1 / %clampedGamma );       
    %combinePass.setShaderConst( "$Brightness", $pref::Video::Brightness );
    %combinePass.setShaderConst( "$Contrast", $pref::Video::Contrast );
 
-   %whiteCutoff = ( $HDRPostFX::whiteCutoff * $HDRPostFX::whiteCutoff ) *
+   %whiteCutoff = ( $PostFX::HDRPostFX::whiteCutoff * $PostFX::HDRPostFX::whiteCutoff ) *
-                  ( $HDRPostFX::whiteCutoff * $HDRPostFX::whiteCutoff );                  
+                  ( $PostFX::HDRPostFX::whiteCutoff * $PostFX::HDRPostFX::whiteCutoff );                  
    %combinePass.setShaderConst( "$g_fWhiteCutoff", %whiteCutoff );
 }
 
@@ -266,8 +276,8 @@ function HDRPostFX::preProcess( %this )
 {
    %combinePass = %this-->combinePass;
    
-   if ( %combinePass.texture[3] !$= $HDRPostFX::colorCorrectionRamp )
+   if ( %combinePass.texture[3] !$= $PostFX::HDRPostFX::colorCorrectionRamp )
-      %combinePass.setTexture( 3, $HDRPostFX::colorCorrectionRamp );         
+      %combinePass.setTexture( 3, $PostFX::HDRPostFX::colorCorrectionRamp );         
 }
 
 function HDRPostFX::onEnabled( %this )
@@ -301,12 +311,16 @@ function HDRPostFX::onEnabled( %this )
    // hdr encoding takes effect in all the shaders and
    // that the offscreen surface is enabled.
    resetLightManager();
+   
+   $PostFX::HDRPostFX::Enabled = true;
          
    return true;
 }
 
 function HDRPostFX::onDisabled( %this )
 {
+   $PostFX::HDRPostFX::Enabled = false;
+   
    // Enable a special GammaCorrection PostFX when this is disabled.
    GammaPostFX.enable();
    
@@ -330,7 +344,7 @@ function HDRPostFX::onAdd( %this )
    //HDR should really be on at all times
    //%this.enable();
    
-   $HDRPostFX::enableToneMapping = 1;
+   $PostFX::HDRPostFX::enableToneMapping = 1;
 }
 
 //This is used to populate the PostFXEditor's settings so the post FX can be edited
@@ -339,62 +353,64 @@ function HDRPostFX::onAdd( %this )
 function HDRPostFX::populatePostFXSettings(%this)
 {
    PostEffectEditorInspector.startGroup("HDR - General");
-   PostEffectEditorInspector.addField("$PostFXManager::Settings::HDR::keyValue", "Key Value", "range", "", $HDRPostFX::keyValue, "0 1 10");
+   PostEffectEditorInspector.addCallbackField("$PostFX::HDRPostFX::Enabled", "Enabled", "bool", "", $PostFX::HDRPostFX::Enabled, "", "toggleHDRPostFX");
-   PostEffectEditorInspector.addField("$PostFXManager::Settings::HDR::minLuminace", "Minimum Luminance", "range", "", $HDRPostFX::minLuminace, "0 1 10");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::minLuminace", "Minimum Luminance", "range", "", $PostFX::HDRPostFX::minLuminace, "0 1 100");
-   PostEffectEditorInspector.addField("$PostFXManager::Settings::HDR::whiteCutoff", "White Cutoff", "range", "", $HDRPostFX::whiteCutoff, "0 1 10");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::whiteCutoff", "White Cutoff", "range", "", $PostFX::HDRPostFX::whiteCutoff, "0 10 20");
-   PostEffectEditorInspector.addField("$PostFXManager::Settings::HDR::adaptRate", "Brightness Adapt Rate", "range", "", $HDRPostFX::adaptRate, "0 1 10");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::adaptRate", "Brightness Adapt Rate", "range", "", $PostFX::HDRPostFX::adaptRate, "0 1 10");
+   PostEffectEditorInspector.endGroup();
+   
+   PostEffectEditorInspector.startGroup("HDR - Tonemapping");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::tonemapMode", "Tonemapping Mode", "list", "", $PostFX::HDRPostFX::tonemapMode, "Filmic,ACES");
    PostEffectEditorInspector.endGroup();
    
    PostEffectEditorInspector.startGroup("HDR - Bloom");
-   PostEffectEditorInspector.addField("$PostFXManager::Settings::HDR::enableBloom", "Enable Bloom", "bool", "", $HDRPostFX::enableBloom, "");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::enableBloom", "Enable Bloom", "bool", "", $PostFX::HDRPostFX::enableBloom, "");
-   PostEffectEditorInspector.addField("$PostFXManager::Settings::HDR::brightPassThreshold", "Bright Pass Threshold", "float", "", $HDRPostFX::brightPassThreshold, "");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::brightPassThreshold", "Bright Pass Threshold", "float", "", $PostFX::HDRPostFX::brightPassThreshold, "");
-   PostEffectEditorInspector.addField("$PostFXManager::Settings::HDR::gaussMultiplier", "Blur Multiplier", "float", "", $HDRPostFX::gaussMultiplier, "");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::gaussMultiplier", "Blur Multiplier", "range", "", $PostFX::HDRPostFX::gaussMultiplier, "0 1 10");
-   PostEffectEditorInspector.addField("$PostFXManager::Settings::HDR::gaussMean", "Blur \"Mean\" Value", "float", "", $HDRPostFX::gaussMean, "");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::gaussMean", "Blur Mean Value", "range", "", $PostFX::HDRPostFX::gaussMean, "0 1 10");
-   PostEffectEditorInspector.addField("$PostFXManager::Settings::HDR::gaussStdDev", "Blur \"Std. Dev\" Value", "float", "", $HDRPostFX::gaussStdDev, "");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::gaussStdDev", "Blur Std. Dev Value", "range", "", $PostFX::HDRPostFX::gaussStdDev, "0 1 10");
    PostEffectEditorInspector.endGroup();
    
-   PostEffectEditorInspector.startGroup("HDR - Effects");
+   PostEffectEditorInspector.startGroup("HDR - Adaptation");
-   PostEffectEditorInspector.addField("$PostFXManager::Settings::HDR::enableBlueShift", "Enable Blue Shift", "bool", "", $HDRPostFX::enableBlueShift, "");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::enableAutoExposure", "Enable Auto Exposure", "bool", "", $PostFX::HDRPostFX::enableAutoExposure, "");
-   PostEffectEditorInspector.addField("$PostFXManager::Settings::HDR::blueShiftColor", "Blue Shift Color", "colorF", "", $HDRPostFX::blueShiftColor, "");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::keyValue", "Key Value", "range", "", $PostFX::HDRPostFX::keyValue, "0 1 10");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::enableBlueShift", "Enable Blue Shift", "bool", "", $PostFX::HDRPostFX::enableBlueShift, "");
+   PostEffectEditorInspector.addField("$PostFX::HDRPostFX::blueShiftColor", "Blue Shift Color", "colorF", "", $PostFX::HDRPostFX::blueShiftColor, "");
    PostEffectEditorInspector.endGroup();
 }
 
-//This function pair(applyFromPreset and settingsApply) are done the way they are, with the separated variables
+function PostEffectEditorInspector::toggleHDRPostFX(%this)
-//so that we can effectively store the 'settings' away from the live variables that the postFX's actually utilize
-//when rendering. This allows us to modify things but still leave room for reverting or temporarily applying them
-function HDRPostFX::applyFromPreset(%this)
 {
-   //HDRPostFX Settings
+   if($PostFX::HDRPostFX::Enabled)
-   $HDRPostFX::adaptRate               = $PostFXManager::Settings::HDR::adaptRate;
+      HDRPostFX.enable();
-   $HDRPostFX::blueShiftColor          = $PostFXManager::Settings::HDR::blueShiftColor;
+   else
-   $HDRPostFX::brightPassThreshold     = $PostFXManager::Settings::HDR::brightPassThreshold; 
+      HDRPostFX.disable();
-   $HDRPostFX::enableBloom             = $PostFXManager::Settings::HDR::enableBloom;
-   $HDRPostFX::enableBlueShift         = $PostFXManager::Settings::HDR::enableBlueShift;
-   $HDRPostFX::enableToneMapping       = $PostFXManager::Settings::HDR::enableToneMapping;
-   $HDRPostFX::gaussMean               = $PostFXManager::Settings::HDR::gaussMean;
-   $HDRPostFX::gaussMultiplier         = $PostFXManager::Settings::HDR::gaussMultiplier;
-   $HDRPostFX::gaussStdDev             = $PostFXManager::Settings::HDR::gaussStdDev;
-   $HDRPostFX::keyValue                = $PostFXManager::Settings::HDR::keyValue;
-   $HDRPostFX::minLuminace             = $PostFXManager::Settings::HDR::minLuminace;
-   $HDRPostFX::whiteCutoff             = $PostFXManager::Settings::HDR::whiteCutoff;
-   $HDRPostFX::colorCorrectionRamp     = $PostFXManager::Settings::ColorCorrectionRamp;
 }
 
-function HDRPostFX::settingsApply(%this)
+function HDRPostFX::applyFromPreset(%this)
 {
-   $PostFXManager::Settings::HDR::adaptRate                 = $HDRPostFX::adaptRate;
+   if($PostFX::HDRPostFX::Enabled)
-   $PostFXManager::Settings::HDR::blueShiftColor            = $HDRPostFX::blueShiftColor;
+      HDRPostFX.enable();
-   $PostFXManager::Settings::HDR::brightPassThreshold       = $HDRPostFX::brightPassThreshold;
+   else
-   $PostFXManager::Settings::HDR::enableBloom               = $HDRPostFX::enableBloom;
+      HDRPostFX.disable();
-   $PostFXManager::Settings::HDR::enableBlueShift           = $HDRPostFX::enableBlueShift;
+}
-   $PostFXManager::Settings::HDR::enableToneMapping         = $HDRPostFX::enableToneMapping;
+
-   $PostFXManager::Settings::HDR::gaussMean                 = $HDRPostFX::gaussMean;
+function HDRPostFX::savePresetSettings(%this)
-   $PostFXManager::Settings::HDR::gaussMultiplier           = $HDRPostFX::gaussMultiplier;
+{
-   $PostFXManager::Settings::HDR::gaussStdDev               = $HDRPostFX::gaussStdDev;
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::Enabled");
-   $PostFXManager::Settings::HDR::keyValue                  = $HDRPostFX::keyValue;
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::minLuminace");
-   $PostFXManager::Settings::HDR::minLuminace               = $HDRPostFX::minLuminace;
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::whiteCutoff");
-   $PostFXManager::Settings::HDR::whiteCutoff               = $HDRPostFX::whiteCutoff;
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::adaptRate");
-   $PostFXManager::Settings::ColorCorrectionRamp            = $HDRPostFX::colorCorrectionRamp;
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::tonemapMode");
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::enableBloom");
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::brightPassThreshold");
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::gaussMultiplier");
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::gaussMean");
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::gaussStdDev");
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::enableAutoExposure");
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::keyValue");
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::enableBlueShift");
+   PostFXManager::savePresetSetting("$PostFX::HDRPostFX::blueShiftColor");
 }
 
 singleton PostEffect( HDRPostFX )
@@ -537,7 +553,7 @@ singleton PostEffect( HDRPostFX )
       texture[0] = "$backBuffer";
       texture[1] = "#adaptedLum";            
       texture[2] = "#bloomFinal";
-      texture[3] = $HDRPostFX::colorCorrectionRamp;
+      texture[3] = $PostFX::HDRPostFX::colorCorrectionRamp;
       target = "$backBuffer";
    };
 };
@@ -562,7 +578,7 @@ singleton GFXStateBlockData( LuminanceVisStateBlock : PFX_DefaultStateBlock )
 
 function LuminanceVisPostFX::setShaderConsts( %this )
 {
-   %this.setShaderConst( "$brightPassThreshold", $HDRPostFX::brightPassThreshold );
+   %this.setShaderConst( "$brightPassThreshold", $PostFX::HDRPostFX::brightPassThreshold );
 }
 
 singleton PostEffect( LuminanceVisPostFX )

Templates/BaseGame/game/core/postFX/scripts/HDR/bloomGaussBlurHP.glsl

@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform sampler2D inputTex ;
 uniform vec2 oneOverTargetSize;

Templates/BaseGame/game/core/postFX/scripts/HDR/bloomGaussBlurHP.hlsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(inputTex, 0);
 uniform float2 oneOverTargetSize;
@@ -47,6 +47,46 @@ float computeGaussianValue( float x, float mean, float std_deviation )
     return tmp * tmp2;
 }
 
+float SCurve (float x) 
+{
+		x = x * 2.0 - 1.0;
+		return -x * abs(x) * 0.5 + x + 0.5;
+}
+
+float4 BlurH (TORQUE_SAMPLER2D(source), float2 size, float2 uv, float radius) 
+{
+	if (radius >= 1.0)
+	{
+		float4 A = float4(0.0,0.0,0.0,0.0); 
+		float4 C = float4(0.0,0.0,0.0,0.0); 
+
+		float width = 1.0 / size.x;
+
+      float divisor = 0.0; 
+      float weight = 0.0;
+
+      float radiusMultiplier = 1.0 / radius;
+
+      // Hardcoded for radius 20 (normally we input the radius
+      // in there), needs to be literal here
+
+      for (float x = -20.0; x <= 20.0; x++)
+      {
+         A = TORQUE_TEX2D(source, uv + float2(x * width, 0.0));
+
+         weight = SCurve(1.0 - (abs(x) * radiusMultiplier)); 
+
+         C += A * weight; 
+
+         divisor += weight; 
+      }
+
+		return float4(C.r / divisor, C.g / divisor, C.b / divisor, 1.0);
+	}
+
+	return TORQUE_TEX2D(source, uv);
+}
+
 float4 main( PFXVertToPix IN ) : TORQUE_TARGET0
 {
    float4 color = { 0.0f, 0.0f, 0.0f, 0.0f };
@@ -63,6 +103,9 @@ float4 main( PFXVertToPix IN ) : TORQUE_TARGET0
       weight = gaussMultiplier * computeGaussianValue( x, gaussMean, gaussStdDev );
       color += (TORQUE_TEX2D( inputTex, IN.uv0 + float2( offset, 0.0f ) ) * weight );
    }
+
+   //float2 targetSize = 1/oneOverTargetSize;
+   //float4 color = BlurH(TORQUE_SAMPLER2D_MAKEARG(inputTex), targetSize, IN.uv0, 20.0);
    
    return float4( color.rgb, 1.0f );
 }

Templates/BaseGame/game/core/postFX/scripts/HDR/bloomGaussBlurVP.glsl

@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform sampler2D inputTex ;
 uniform vec2 oneOverTargetSize;

Templates/BaseGame/game/core/postFX/scripts/HDR/bloomGaussBlurVP.hlsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(inputTex, 0);
 uniform float2 oneOverTargetSize;
@@ -46,6 +46,44 @@ float computeGaussianValue( float x, float mean, float std_deviation )
     return tmp * tmp2;
 }
 
+float SCurve (float x) 
+{
+		x = x * 2.0 - 1.0;
+		return -x * abs(x) * 0.5 + x + 0.5;
+}
+
+float4 BlurV (TORQUE_SAMPLER2D(source), float2 size, float2 uv, float radius) 
+{
+	if (radius >= 1.0)
+	{
+		float4 A = float4(0.0,0.0,0.0,0.0); 
+		float4 C = float4(0.0,0.0,0.0,0.0); 
+
+		float height = 1.0 / size.y;
+
+		float divisor = 0.0; 
+      float weight = 0.0;
+
+      float radiusMultiplier = 1.0 / radius;
+
+      for (float y = -20.0; y <= 20.0; y++)
+      {
+         A = TORQUE_TEX2D(source, uv + float2(0.0, y * height));
+
+         weight = SCurve(1.0 - (abs(y) * radiusMultiplier)); 
+
+         C += A * weight; 
+
+         divisor += weight; 
+      }
+
+		return float4(C.r / divisor, C.g / divisor, C.b / divisor, 1.0);
+	}
+
+	return TORQUE_TEX2D(source, uv);
+}
+
+
 float4 main( PFXVertToPix IN ) : TORQUE_TARGET0
 {
    float4 color = { 0.0f, 0.0f, 0.0f, 0.0f };
@@ -63,5 +101,8 @@ float4 main( PFXVertToPix IN ) : TORQUE_TARGET0
       color += (TORQUE_TEX2D( inputTex, IN.uv0 + float2( 0.0f, offset ) ) * weight );
    }
 
+   //float2 targetSize = 1/oneOverTargetSize;
+   //float4 color = BlurV(TORQUE_SAMPLER2D_MAKEARG(inputTex), targetSize, IN.uv0, 20.0);
+
    return float4( color.rgb, 1.0f );
 }

Templates/BaseGame/game/core/postFX/scripts/HDR/brightPassFilterP.glsl

@@ -20,10 +20,10 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform sampler2D inputTex ;
 uniform sampler2D luminanceTex  ;

Templates/BaseGame/game/core/postFX/scripts/HDR/brightPassFilterP.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
 
 
 TORQUE_UNIFORM_SAMPLER2D(inputTex, 0);

Templates/BaseGame/game/core/postFX/scripts/HDR/calculateAdaptedLumP.glsl

@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform sampler2D currLum;
 uniform sampler2D lastAdaptedLum;

Templates/BaseGame/game/core/postFX/scripts/HDR/calculateAdaptedLumP.hlsl

@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(currLum, 0);
 TORQUE_UNIFORM_SAMPLER2D(lastAdaptedLum, 1);

Templates/BaseGame/game/core/postFX/scripts/HDR/downScale4x4P.glsl

@@ -21,8 +21,8 @@
 //-----------------------------------------------------------------------------
 
 #define IN_GLSL
-#include "../../../shdrConsts.h"
+#include "core/rendering/shaders/shdrConsts.h"
-#include "../../../gl/hlslCompat.glsl"
+#include ".core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
 
 in vec4 texCoords[8];

Templates/BaseGame/game/core/postFX/scripts/HDR/downScale4x4P.hlsl

@@ -21,8 +21,8 @@
 //-----------------------------------------------------------------------------
 
 #define IN_HLSL
-#include "../../shdrConsts.h"
+#include "core/rendering/shaders/shdrConsts.h"
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 //-----------------------------------------------------------------------------
 // Data 

Templates/BaseGame/game/core/postFX/scripts/HDR/downScale4x4V.glsl

@@ -21,8 +21,8 @@
 //-----------------------------------------------------------------------------
 
 #define IN_GLSL
-#include "../../../shdrConsts.h"
+#include "core/rendering/shaders/shdrConsts.h"
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 
 in vec4 vPosition;
 in vec2 vTexCoord0;

Templates/BaseGame/game/core/postFX/scripts/HDR/downScale4x4V.hlsl

@@ -21,8 +21,8 @@
 //-----------------------------------------------------------------------------
 
 #define IN_HLSL
-#include "../../shdrConsts.h"
+#include "core/rendering/shaders/shdrConsts.h"
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 //-----------------------------------------------------------------------------
 // Constants
 //-----------------------------------------------------------------------------

Templates/BaseGame/game/core/postFX/scripts/HDR/finalPassCombineP.glsl

@@ -20,15 +20,14 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 #include "shadergen:/autogenConditioners.h"
 
 uniform sampler2D sceneTex;
 uniform sampler2D luminanceTex;
 uniform sampler2D bloomTex;
-uniform sampler1D colorCorrectionTex;
 
 uniform vec2 texSize0;
 uniform vec2 texSize2;
@@ -37,6 +36,9 @@ uniform float g_fEnableToneMapping;
 uniform float g_fMiddleGray;
 uniform float g_fWhiteCutoff;
 
+uniform float g_fEnableAutoExposure;
+uniform float g_fTonemapMode;
+
 uniform float g_fEnableBlueShift;
 uniform vec3 g_fBlueShiftColor; 
 
@@ -60,15 +62,38 @@ vec3 Uncharted2Tonemap(vec3 x)
    return ((x*(A*x + C*B) + D*E) / (x*(A*x + B) + D*F)) - E / F;
 }
 
+float3 ACESFilm( float3 x )
+{
+    const float a = 2.51;
+    const float b = 0.03;
+    const float c = 2.43;
+    const float d = 0.59;
+    const float e = 0.14;
+    return sat((x*(a*x+b))/(x*(c*x+d)+e));
+}
+
 vec3 tonemap(vec3 c)
 {
-   const float W = 11.2;
+   vec3 colorOut = c;
-   float ExposureBias = 2.0f;
+
-   float ExposureAdjust = 1.5f;
+   if(g_fTonemapMode == 1.0)
-   c *= ExposureAdjust;
+   {
-   vec3 curr = Uncharted2Tonemap(ExposureBias*c);
+      const float W = 11.2;
-   vec3 whiteScale = 1.0f / Uncharted2Tonemap(vec3(W,W,W));
+      float ExposureBias = 2.0f;
-   return curr*whiteScale;
+      float ExposureAdjust = 1.5f;
+      c *= ExposureAdjust;
+      vec3 curr = Uncharted2Tonemap(ExposureBias*c);
+      vec3 whiteScale = 1.0f / Uncharted2Tonemap(vec3(W,W,W));
+
+      colorOut = curr*whiteScale;
+   }
+   }
+   else if(g_fTonemapMode == 2.0)
+   {
+      colorOut = ACESFilm(c);
+   }
+
+   return colorOut;
 }
 
 void main()
@@ -100,11 +125,6 @@ void main()
    // Add the bloom effect.
    _sample += g_fBloomScale * bloom;
 
-   // Apply the color correction.
-   _sample.r = texture( colorCorrectionTex, _sample.r ).r;
-   _sample.g = texture( colorCorrectionTex, _sample.g ).g;
-   _sample.b = texture( colorCorrectionTex, _sample.b ).b;
-
    // Apply contrast
    _sample.rgb = ((_sample.rgb - 0.5f) * Contrast) + 0.5f;
 
@@ -114,7 +134,12 @@ void main()
    //tonemapping - TODO fix up eye adaptation
    if ( g_fEnableToneMapping > 0.0f )
    {
-      _sample.rgb = tonemap(_sample.rgb);
+      float adapation = 1;
+
+      if ( g_fEnableAutoExposure > 0.0f )
+         adapation = (g_fMiddleGray / (adaptedLum + 0.0001)) * hdrLuminance( _sample.rgb );
+
+      _sample.rgb = tonemap(_sample.rgb * adapation);
    }
 
    OUT_col = _sample;

Templates/BaseGame/game/core/postFX/scripts/HDR/finalPassCombineP.hlsl

@@ -20,14 +20,13 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "../../shaderModelAutoGen.hlsl"
+#include "core/rendering/shaders/shaderModelAutoGen.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(sceneTex, 0);
 TORQUE_UNIFORM_SAMPLER2D(luminanceTex, 1);
 TORQUE_UNIFORM_SAMPLER2D(bloomTex, 2);
-TORQUE_UNIFORM_SAMPLER1D(colorCorrectionTex, 3);
 
 uniform float2 texSize0;
 uniform float2 texSize2;
@@ -37,6 +36,9 @@ uniform float g_fMiddleGray;
 uniform float g_fWhiteCutoff;
 uniform float g_fEnableBlueShift;
 
+uniform float g_fEnableAutoExposure;
+uniform float g_fTonemapMode;
+
 uniform float3 g_fBlueShiftColor;
 uniform float g_fBloomScale;
 uniform float g_fOneOverGamma;
@@ -55,14 +57,31 @@ float3 Uncharted2Tonemap(const float3 x)
    return ((x*(A*x + C*B) + D*E) / (x*(A*x + B) + D*F)) - E / F;
 }
 
+float3 ACESFilm( float3 x )
+{
+    const float a = 2.51;
+    const float b = 0.03;
+    const float c = 2.43;
+    const float d = 0.59;
+    const float e = 0.14;
+    return saturate((x*(a*x+b))/(x*(c*x+d)+e));
+}
+
 float3 tonemap(float3 color)
 {
-   const float W = 11.2;
+   if(g_fTonemapMode == 1.0)
-   float ExposureBias = 2.0f;
+   {
-   //float ExposureAdjust = 1.5f;
+      const float W = 11.2;
-   //c *= ExposureAdjust;
+      float ExposureBias = 2.0f;
-   color = Uncharted2Tonemap(ExposureBias*color);
+      //float ExposureAdjust = 1.5f;
-   color = color * (1.0f / Uncharted2Tonemap(W));
+      //c *= ExposureAdjust;
+      color = Uncharted2Tonemap(ExposureBias*color);
+      color = color * (1.0f / Uncharted2Tonemap(W));
+   }
+   else if(g_fTonemapMode == 2.0)
+   {
+      color = ACESFilm(color);
+   }
 
    return color;
 }
@@ -96,11 +115,6 @@ float4 main( PFXVertToPix IN ) : TORQUE_TARGET0
    // Add the bloom effect.
    sample += g_fBloomScale * bloom;
 
-   // Apply the color correction.
-   sample.r = TORQUE_TEX1D( colorCorrectionTex, sample.r ).r;
-   sample.g = TORQUE_TEX1D( colorCorrectionTex, sample.g ).g;
-   sample.b = TORQUE_TEX1D( colorCorrectionTex, sample.b ).b;
-
    // Apply contrast
    sample.rgb = ((sample.rgb - 0.5f) * Contrast) + 0.5f;
 
@@ -110,7 +124,12 @@ float4 main( PFXVertToPix IN ) : TORQUE_TARGET0
    //tonemapping - TODO fix up eye adaptation
    if ( g_fEnableToneMapping > 0.0f )
    {
-      sample.rgb = tonemap(sample.rgb);
+      float adapation = 1;
+
+      if( g_fEnableAutoExposure > 0.0f )
+         adapation = (g_fMiddleGray / (adaptedLum + 0.0001)) * hdrLuminance( sample.rgb );
+
+      sample.rgb = tonemap(sample.rgb * adapation);
    }
 
    return sample;

Templates/BaseGame/game/core/postFX/scripts/HDR/luminanceVisP.glsl

@@ -20,10 +20,10 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
 #include "shadergen:/autogenConditioners.h"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform sampler2D inputTex;
 uniform float brightPassThreshold;

Templates/BaseGame/game/core/postFX/scripts/HDR/luminanceVisP.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
-#include "../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
 
 
 TORQUE_UNIFORM_SAMPLER2D(inputTex, 0);

Templates/BaseGame/game/core/postFX/scripts/HDR/sampleLumInitialP.glsl

@@ -20,9 +20,9 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../../gl/torque.glsl"
+#include "core/rendering/shaders/gl/torque.glsl"
-#include "../../../gl/hlslCompat.glsl"
+#include "core/rendering/shaders/gl/hlslCompat.glsl"
-#include "../../gl/postFx.glsl"
+#include "core/rendering/shaders/postFX/gl/postFx.glsl"
 
 uniform sampler2D inputTex;
 uniform vec2 texSize0;

Templates/BaseGame/game/core/postFX/scripts/HDR/sampleLumInitialP.hlsl

@@ -20,8 +20,8 @@
 // IN THE SOFTWARE.
 //-----------------------------------------------------------------------------
 
-#include "../../torque.hlsl"
+#include "core/rendering/shaders/torque.hlsl"
-#include "../postFx.hlsl"
+#include "core/rendering/shaders/postFX/postFx.hlsl"
 
 TORQUE_UNIFORM_SAMPLER2D(inputTex, 0);
 uniform float2 texSize0;