Merge branch 'SSR4' of https://github.com/Azaezel/Torque3D into Preview4_0

Engine/source/materials/processedShaderMaterial.cpp

@@ -80,6 +80,9 @@ void ShaderConstHandles::init( GFXShader *shader, Vector<CustomShaderFeatureData
    mCameraToWorldSC = shader->getShaderConstHandle(ShaderGenVars::cameraToWorld);
    mWorldToObjSC = shader->getShaderConstHandle(ShaderGenVars::worldToObj);
    mViewToObjSC = shader->getShaderConstHandle(ShaderGenVars::viewToObj);
+   mInvCameraTransSC = shader->getShaderConstHandle(ShaderGenVars::invCameraTrans);
+   mCameraToScreenSC = shader->getShaderConstHandle(ShaderGenVars::cameraToScreen);
+   mScreenToCameraSC = shader->getShaderConstHandle(ShaderGenVars::screenToCamera);
    mCubeTransSC = shader->getShaderConstHandle(ShaderGenVars::cubeTrans);
    mCubeMipsSC = shader->getShaderConstHandle(ShaderGenVars::cubeMips);
    mObjTransSC = shader->getShaderConstHandle(ShaderGenVars::objTrans);

Engine/source/materials/processedShaderMaterial.h

@@ -66,7 +66,10 @@ public:
    GFXShaderConstHandle* mWorldToCameraSC;
    GFXShaderConstHandle* mCameraToWorldSC;
    GFXShaderConstHandle* mWorldToObjSC;         
-   GFXShaderConstHandle* mViewToObjSC;         
+   GFXShaderConstHandle* mViewToObjSC;
+   GFXShaderConstHandle* mInvCameraTransSC;
+   GFXShaderConstHandle* mCameraToScreenSC;
+   GFXShaderConstHandle* mScreenToCameraSC;
    GFXShaderConstHandle* mCubeTransSC;
    GFXShaderConstHandle* mCubeMipsSC;
    GFXShaderConstHandle* mObjTransSC;

Engine/source/math/util/matrixSet.h

@@ -43,6 +43,7 @@ class MatrixSet
       ObjectToWorld = 0,   // World
       WorldToCamera,       // View
       CameraToScreen,      // Projection
+      ScreenToCamera,      // Projection^-1
       ObjectToScreen,      // World * View * Proj
       ObjectToCamera,      // World * View
       WorldToObject,       // World^-1
@@ -63,6 +64,7 @@ class MatrixSet
    MATRIX_SET_GET_VALUE(ObjectToWorld);
    MATRIX_SET_GET_VALUE(WorldToCamera);
    MATRIX_SET_GET_VALUE(CameraToScreen);
+   MATRIX_SET_GET_VALUE(ScreenToCamera);
    MATRIX_SET_GET_VALUE(ObjectToCamera);
    MATRIX_SET_GET_VALUE(WorldToObject);
    MATRIX_SET_GET_VALUE(CameraToWorld);
@@ -82,6 +84,8 @@ class MatrixSet
 
    MATRIX_SET_MULT_ASSIGN(WorldToScreen, ObjectToWorld, ObjectToScreen);
 
+   MATRIX_SET_IS_INVERSE_OF(ScreenToCamera, CameraToScreen);
+
 public:
    MatrixSet();
 
@@ -89,6 +93,7 @@ public:
    inline const MatrixF &getObjectToWorld() const { return mTransform[ObjectToWorld]; }
    inline const MatrixF &getWorldToCamera() const { return mTransform[WorldToCamera]; }
    inline const MatrixF &getCameraToScreen() const { return mTransform[CameraToScreen]; }
+   inline const MatrixF &getScreenToCamera() const { return mTransform[ScreenToCamera]; }
 
    // Delegate driven, lazy-evaluation accessors
    inline const MatrixF &getWorldToScreen() const { return mEvalDelegate[WorldToScreen](); }
@@ -131,6 +136,7 @@ public:
       mTransform[CameraToScreen] = projection;
       mEvalDelegate[ObjectToScreen].bind(this, &MatrixSet::MATRIX_SET_MULT_ASSIGN_FN(WorldToScreen, ObjectToWorld, ObjectToScreen));
       mEvalDelegate[WorldToScreen].bind(this, &MatrixSet::MATRIX_SET_MULT_ASSIGN_FN(CameraToScreen, WorldToCamera, WorldToScreen));
+      mEvalDelegate[ScreenToCamera].bind(this, &MatrixSet::MATRIX_SET_IS_INVERSE_OF_FN(ScreenToCamera, CameraToScreen));
    }
 
    void setSceneView(const MatrixF &view)

Engine/source/postFx/postEffect.cpp

@@ -494,7 +494,10 @@ PostEffect::PostEffect()
       mAccumTimeSC( NULL ),
       mDeltaTimeSC( NULL ),
       mInvCameraMatSC( NULL ),
-      mMatCameraToWorldSC( NULL)
+      mMatCameraToWorldSC( NULL),
+      mInvCameraTransSC(NULL),
+      mMatCameraToScreenSC(NULL),
+      mMatScreenToCameraSC(NULL)
 {
    dMemset( mTexSRGB, 0, sizeof(bool) * NumTextures);
    dMemset( mActiveTextures, 0, sizeof( GFXTextureObject* ) * NumTextures );
@@ -804,6 +807,10 @@ void PostEffect::_setupConstants( const SceneRenderState *state )
       mInvCameraMatSC = mShader->getShaderConstHandle( "$invCameraMat" );
 
       mMatCameraToWorldSC = mShader->getShaderConstHandle("$cameraToWorld");
+
+      mInvCameraTransSC = mShader->getShaderConstHandle("$invCameraTrans");
+      mMatCameraToScreenSC = mShader->getShaderConstHandle("$cameraToScreen");
+      mMatScreenToCameraSC = mShader->getShaderConstHandle("$screenToCamera");
    }
 
    // Set up shader constants for source image size
@@ -945,6 +952,30 @@ void PostEffect::_setupConstants( const SceneRenderState *state )
       mShaderConsts->set(mMatCameraToWorldSC, tempMat);
    }
 
+   if (mInvCameraTransSC->isValid())
+   {
+      MatrixF mat = state->getCameraTransform();
+      mat.fullInverse();
+      mShaderConsts->set(mInvCameraTransSC, mat, mInvCameraTransSC->getType());
+   }
+   //Projection Matrix
+   if (mMatCameraToScreenSC->isValid())
+   {
+
+      MatrixF tempMat = thisFrame.cameraToScreen;
+      mShaderConsts->set(mMatCameraToScreenSC, tempMat, mMatCameraToScreenSC->getType());
+   }
+
+
+   //Inverse Projection Matrix
+   if (mMatScreenToCameraSC->isValid())
+   {
+
+      MatrixF tempMat = thisFrame.cameraToScreen;
+      tempMat.fullInverse();
+
+      mShaderConsts->set(mMatScreenToCameraSC, tempMat, mMatScreenToCameraSC->getType());
+   }
    mShaderConsts->setSafe( mAccumTimeSC, MATMGR->getTotalTime() );
    mShaderConsts->setSafe( mDeltaTimeSC, MATMGR->getDeltaTime() );
 

Engine/source/postFx/postEffect.h

@@ -155,6 +155,9 @@ protected:
    GFXShaderConstHandle *mDeltaTimeSC;
    GFXShaderConstHandle *mInvCameraMatSC;
    GFXShaderConstHandle *mMatCameraToWorldSC;
+   GFXShaderConstHandle *mInvCameraTransSC;
+   GFXShaderConstHandle *mMatCameraToScreenSC;
+   GFXShaderConstHandle *mMatScreenToCameraSC;
 
    bool mAllowReflectPass;
 

Engine/source/scene/sceneRenderState.cpp

@@ -93,6 +93,11 @@ const MatrixF& SceneRenderState::getProjectionMatrix() const
    return getRenderPass()->getMatrixSet().getCameraToScreen();
 }
 
+const MatrixF& SceneRenderState::getInvProjectionMatrix() const
+{
+   return getRenderPass()->getMatrixSet().getScreenToCamera();
+}
+
 //-----------------------------------------------------------------------------
 
 void SceneRenderState::renderObjects( SceneObject** objects, U32 numObjects )

Engine/source/scene/sceneRenderState.h

@@ -247,6 +247,8 @@ class SceneRenderState
 
       /// Return the project transform matrix.
       const MatrixF& getProjectionMatrix() const;
+      /// Return the inverse project transform matrix.
+      const MatrixF& getInvProjectionMatrix() const;
 
       /// Returns the actual camera position.
       /// @see getDiffuseCameraPosition

Engine/source/shaderGen/shaderGenVars.cpp

@@ -29,6 +29,9 @@ const String ShaderGenVars::worldToCamera("$worldToCamera");
 const String ShaderGenVars::cameraToWorld("$cameraToWorld");
 const String ShaderGenVars::worldToObj("$worldToObj");
 const String ShaderGenVars::viewToObj("$viewToObj");
+const String ShaderGenVars::invCameraTrans("$invCameraTrans");
+const String ShaderGenVars::cameraToScreen("$cameraToScreen");
+const String ShaderGenVars::screenToCamera("$screenToCamera");
 const String ShaderGenVars::cubeTrans("$cubeTrans");
 const String ShaderGenVars::cubeMips("$cubeMips");
 const String ShaderGenVars::objTrans("$objTrans");

Engine/source/shaderGen/shaderGenVars.h

@@ -38,6 +38,9 @@ struct ShaderGenVars
    const static String cameraToWorld;
    const static String worldToObj;
    const static String viewToObj;
+   const static String invCameraTrans;
+   const static String cameraToScreen;
+   const static String screenToCamera;
    const static String cubeTrans;
    const static String cubeMips;
    const static String objTrans;