Fixing position reconstruction for deferred shaders so it works properly on both OpenGL and DX11

Renamed some camera methods more accurately

BansheeEngine/Include/BsCCamera.h

@@ -145,8 +145,8 @@ namespace BansheeEngine
 		/** @copydoc Camera::worldToScreenPoint */
 		Vector2I worldToScreenPoint(const Vector3& worldPoint) const { updateView(); return mInternal->worldToScreenPoint(worldPoint); }
 
-		/** @copydoc Camera::worldToClipPoint */
-		Vector2 worldToClipPoint(const Vector3& worldPoint) const { updateView(); return mInternal->worldToClipPoint(worldPoint); }
+		/** @copydoc Camera::worldToNdcPoint */
+		Vector2 worldToNdcPoint(const Vector3& worldPoint) const { updateView(); return mInternal->worldToNdcPoint(worldPoint); }
 
 		/** @copydoc Camera::worldToViewPoint */
 		Vector3 worldToViewPoint(const Vector3& worldPoint) const { updateView(); return mInternal->worldToViewPoint(worldPoint); }
@@ -157,8 +157,8 @@ namespace BansheeEngine
 		/** @copydoc Camera::screenToViewPoint */
 		Vector3 screenToViewPoint(const Vector2I& screenPoint, float depth = 0.5f) const { return mInternal->screenToViewPoint(screenPoint, depth); }
 
-		/** @copydoc Camera::screenToClipPoint */
-		Vector2 screenToClipPoint(const Vector2I& screenPoint) const { return mInternal->screenToClipPoint(screenPoint); }
+		/** @copydoc Camera::screenToNdcPoint */
+		Vector2 screenToNdcPoint(const Vector2I& screenPoint) const { return mInternal->screenToNdcPoint(screenPoint); }
 
 		/** @copydoc Camera::viewToWorldPoint */
 		Vector3 viewToWorldPoint(const Vector3& viewPoint) const { updateView(); return mInternal->viewToWorldPoint(viewPoint); }
@@ -166,17 +166,17 @@ namespace BansheeEngine
 		/** @copydoc Camera::viewToScreenPoint */
 		Vector2I viewToScreenPoint(const Vector3& viewPoint) const { return mInternal->viewToScreenPoint(viewPoint); }
 
-		/** @copydoc Camera::viewToClipPoint */
-		Vector2 viewToClipPoint(const Vector3& viewPoint) const { return mInternal->viewToClipPoint(viewPoint); }
+		/** @copydoc Camera::viewToNdcPoint */
+		Vector2 viewToNdcPoint(const Vector3& viewPoint) const { return mInternal->viewToNdcPoint(viewPoint); }
 
-		/** @copydoc Camera::clipToWorldPoint */
-		Vector3 clipToWorldPoint(const Vector2& clipPoint, float depth = 0.5f) const { updateView(); return mInternal->clipToWorldPoint(clipPoint, depth); }
+		/** @copydoc Camera::NdcToWorldPoint */
+		Vector3 ndcToWorldPoint(const Vector2& ndcPoint, float depth = 0.5f) const { updateView(); return mInternal->ndcToWorldPoint(ndcPoint, depth); }
 
-		/** @copydoc Camera::clipToViewPoint */
-		Vector3 clipToViewPoint(const Vector2& clipPoint, float depth = 0.5f) const { return mInternal->clipToViewPoint(clipPoint, depth); }
+		/** @copydoc Camera::NdcToViewPoint */
+		Vector3 ndcToViewPoint(const Vector2& ndcPoint, float depth = 0.5f) const { return mInternal->ndcToViewPoint(ndcPoint, depth); }
 
-		/** @copydoc Camera::clipToScreenPoint */
-		Vector2I clipToScreenPoint(const Vector2& clipPoint) const { return mInternal->clipToScreenPoint(clipPoint); }
+		/** @copydoc Camera::NdcToScreenPoint */
+		Vector2I ndcToScreenPoint(const Vector2& ndcPoint) const { return mInternal->ndcToScreenPoint(ndcPoint); }
 
 		/** @copydoc Camera::screenPointToRay */
 		Ray screenPointToRay(const Vector2I& screenPoint) const { updateView(); return mInternal->screenPointToRay(screenPoint); }

BansheeEngine/Include/BsCamera.h

@@ -305,8 +305,8 @@ namespace BansheeEngine
 		 */
 		Vector2I worldToScreenPoint(const Vector3& worldPoint) const;
 
-		/**	Converts a point in world space to normalized clip coordinates (in [0, 1] range). */
-		Vector2 worldToClipPoint(const Vector3& worldPoint) const;
+		/**	Converts a point in world space to normalized device coordinates (in [0, 1] range). */
+		Vector2 worldToNdcPoint(const Vector3& worldPoint) const;
 
 		/** Converts a point in world space to point relative to camera's coordinate system (view space). */
 		Vector3 worldToViewPoint(const Vector3& worldPoint) const;
@@ -333,9 +333,9 @@ namespace BansheeEngine
 
 		/**
 		 * Converts a point in screen space (pixels corresponding to render target attached to the camera) to normalized 
-		 * clip coordinates (in [0, 1] range).
+		 * device coordinates (in [0, 1] range).
 		 */
-		Vector2 screenToClipPoint(const Vector2I& screenPoint) const;
+		Vector2 screenToNdcPoint(const Vector2I& screenPoint) const;
 
 		/** Converts a point relative to camera's coordinate system (view space) into a point in world space. */
 		Vector3 viewToWorldPoint(const Vector3& viewPoint) const;
@@ -347,35 +347,35 @@ namespace BansheeEngine
 		Vector2I viewToScreenPoint(const Vector3& viewPoint) const;
 
 		/**
-		 * Converts a point relative to camera's coordinate system (view space) into normalized clip coordinates 
+		 * Converts a point relative to camera's coordinate system (view space) into normalized device coordinates 
 		 * (in [0, 1] range).
 		 */
-		Vector2 viewToClipPoint(const Vector3& viewPoint) const;
+		Vector2 viewToNdcPoint(const Vector3& viewPoint) const;
 
 		/**
-		 * Converts a point in normalized clip coordinates ([0, 1] range) to a point in world space.
+		 * Converts a point in normalized device coordinates ([0, 1] range) to a point in world space.
 		 *
-		 * @param[in]	clipPoint	Point to transform.
+		 * @param[in]	ndcPoint	Point to transform.
 		 * @param[in]	depth		Depth to place the world point at. The depth is applied to the vector going from camera
 		 *							origin to the point on the near plane.
 		 */
-		Vector3 clipToWorldPoint(const Vector2& clipPoint, float depth = 0.5f) const;
+		Vector3 ndcToWorldPoint(const Vector2& ndcPoint, float depth = 0.5f) const;
 
 		/**
-		 * Converts a point in normalized clip coordinates ([0, 1] range) to a point relative to camera's coordinate system
+		 * Converts a point in normalized device coordinates ([0, 1] range) to a point relative to camera's coordinate system
 		 * (view space).
 		 *
-		 * @param[in]	clipPoint	Point to transform.
+		 * @param[in]	ndcPoint	Point to transform.
 		 * @param[in]	depth		Depth to place the world point at. The depth is applied to the vector going from camera
 		 *							origin to the point on the near plane.
 		 */
-		Vector3 clipToViewPoint(const Vector2& clipPoint, float depth = 0.5f) const;
+		Vector3 ndcToViewPoint(const Vector2& ndcPoint, float depth = 0.5f) const;
 
 		/**
-		 * Converts a point in normalized clip coordinates ([0, 1] range) to a point in screen space (pixels corresponding
+		 * Converts a point in normalized device coordinates ([0, 1] range) to a point in screen space (pixels corresponding
 		 * to render target attached to the camera).
 		 */
-		Vector2I clipToScreenPoint(const Vector2& clipPoint) const;
+		Vector2I ndcToScreenPoint(const Vector2& ndcPoint) const;
 
 		/**
 		 * Converts a point in screen space (pixels corresponding to render target attached to the camera) to a ray in world
@@ -383,10 +383,10 @@ namespace BansheeEngine
 		 */
 		Ray screenPointToRay(const Vector2I& screenPoint) const;
 
-		/**	Projects a point from view to clip space. */
+		/**	Projects a point from view to normalized device space. */
 		Vector3 projectPoint(const Vector3& point) const;
 
-		/**	Un-projects a point in clip space to view space. */
+		/**	Un-projects a point in normalized device space to view space. */
 		Vector3 unprojectPoint(const Vector3& point) const;
 
         static const float INFINITE_FAR_PLANE_ADJUST; /**< Small constant used to reduce far plane projection to avoid inaccuracies. */

BansheeEngine/Source/BsCamera.cpp

@@ -526,14 +526,14 @@ namespace BansheeEngine
 
 	Vector2I CameraBase::worldToScreenPoint(const Vector3& worldPoint) const
 	{
-		Vector2 clipPoint = worldToClipPoint(worldPoint);
-		return clipToScreenPoint(clipPoint);
+		Vector2 ndcPoint = worldToNdcPoint(worldPoint);
+		return ndcToScreenPoint(ndcPoint);
 	}
 
-	Vector2 CameraBase::worldToClipPoint(const Vector3& worldPoint) const
+	Vector2 CameraBase::worldToNdcPoint(const Vector3& worldPoint) const
 	{
 		Vector3 viewPoint = worldToViewPoint(worldPoint);
-		return viewToClipPoint(viewPoint);
+		return viewToNdcPoint(viewPoint);
 	}
 
 	Vector3 CameraBase::worldToViewPoint(const Vector3& worldPoint) const
@@ -543,25 +543,25 @@ namespace BansheeEngine
 
 	Vector3 CameraBase::screenToWorldPoint(const Vector2I& screenPoint, float depth) const
 	{
-		Vector2 clipPoint = screenToClipPoint(screenPoint);
-		return clipToWorldPoint(clipPoint, depth);
+		Vector2 ndcPoint = screenToNdcPoint(screenPoint);
+		return ndcToWorldPoint(ndcPoint, depth);
 	}
 
 	Vector3 CameraBase::screenToViewPoint(const Vector2I& screenPoint, float depth) const
 	{
-		Vector2 clipPoint = screenToClipPoint(screenPoint);
-		return clipToViewPoint(clipPoint, depth);
+		Vector2 ndcPoint = screenToNdcPoint(screenPoint);
+		return ndcToViewPoint(ndcPoint, depth);
 	}
 
-	Vector2 CameraBase::screenToClipPoint(const Vector2I& screenPoint) const
+	Vector2 CameraBase::screenToNdcPoint(const Vector2I& screenPoint) const
 	{
 		Rect2I viewport = getViewportRect();
 
-		Vector2 clipPoint;
-		clipPoint.x = (float)(((screenPoint.x - viewport.x) / (float)viewport.width) * 2.0f - 1.0f);
-		clipPoint.y = (float)((1.0f - ((screenPoint.y - viewport.y) / (float)viewport.height)) * 2.0f - 1.0f);
+		Vector2 ndcPoint;
+		ndcPoint.x = (float)(((screenPoint.x - viewport.x) / (float)viewport.width) * 2.0f - 1.0f);
+		ndcPoint.y = (float)((1.0f - ((screenPoint.y - viewport.y) / (float)viewport.height)) * 2.0f - 1.0f);
 
-		return clipPoint;
+		return ndcPoint;
 	}
 
 	Vector3 CameraBase::viewToWorldPoint(const Vector3& viewPoint) const
@@ -571,45 +571,45 @@ namespace BansheeEngine
 
 	Vector2I CameraBase::viewToScreenPoint(const Vector3& viewPoint) const
 	{
-		Vector2 clipPoint = viewToClipPoint(viewPoint);
-		return clipToScreenPoint(clipPoint);
+		Vector2 ndcPoint = viewToNdcPoint(viewPoint);
+		return ndcToScreenPoint(ndcPoint);
 	}
 
-	Vector2 CameraBase::viewToClipPoint(const Vector3& viewPoint) const
+	Vector2 CameraBase::viewToNdcPoint(const Vector3& viewPoint) const
 	{
 		Vector3 projPoint = projectPoint(viewPoint);
 
 		return Vector2(projPoint.x, projPoint.y);
 	}
 
-	Vector3 CameraBase::clipToWorldPoint(const Vector2& clipPoint, float depth) const
+	Vector3 CameraBase::ndcToWorldPoint(const Vector2& ndcPoint, float depth) const
 	{
-		Vector3 viewPoint = clipToViewPoint(clipPoint, depth);
+		Vector3 viewPoint = ndcToViewPoint(ndcPoint, depth);
 		return viewToWorldPoint(viewPoint);
 	}
 
-	Vector3 CameraBase::clipToViewPoint(const Vector2& clipPoint, float depth) const
+	Vector3 CameraBase::ndcToViewPoint(const Vector2& ndcPoint, float depth) const
 	{
-		return unprojectPoint(Vector3(clipPoint.x, clipPoint.y, depth));
+		return unprojectPoint(Vector3(ndcPoint.x, ndcPoint.y, depth));
 	}
 
-	Vector2I CameraBase::clipToScreenPoint(const Vector2& clipPoint) const
+	Vector2I CameraBase::ndcToScreenPoint(const Vector2& ndcPoint) const
 	{
 		Rect2I viewport = getViewportRect();
 
 		Vector2I screenPoint;
-		screenPoint.x = Math::roundToInt(viewport.x + ((clipPoint.x + 1.0f) * 0.5f) * viewport.width);
-		screenPoint.y = Math::roundToInt(viewport.y + (1.0f - (clipPoint.y + 1.0f) * 0.5f) * viewport.height);
+		screenPoint.x = Math::roundToInt(viewport.x + ((ndcPoint.x + 1.0f) * 0.5f) * viewport.width);
+		screenPoint.y = Math::roundToInt(viewport.y + (1.0f - (ndcPoint.y + 1.0f) * 0.5f) * viewport.height);
 
 		return screenPoint;
 	}
 
 	Ray CameraBase::screenPointToRay(const Vector2I& screenPoint) const
 	{
-		Vector2 clipPoint = screenToClipPoint(screenPoint);
+		Vector2 ndcPoint = screenToNdcPoint(screenPoint);
 
-		Vector3 near = unprojectPoint(Vector3(clipPoint.x, clipPoint.y, mNearDist));
-		Vector3 far = unprojectPoint(Vector3(clipPoint.x, clipPoint.y, mNearDist + 1.0f));
+		Vector3 near = unprojectPoint(Vector3(ndcPoint.x, ndcPoint.y, mNearDist));
+		Vector3 far = unprojectPoint(Vector3(ndcPoint.x, ndcPoint.y, mNearDist + 1.0f));
 
 		Ray ray(near, Vector3::normalize(far - near));
 		ray.transformAffine(getViewMatrix().inverseAffine());

BansheePhysX/Include/BsPhysXMaterial.h

@@ -12,7 +12,7 @@ namespace BansheeEngine
 	 *  @{
 	 */
 
-	/** PhysX implementation of a PhysicsMesh. */
+	/** PhysX implementation of a PhysicsMaterial. */
 	class PhysXMaterial : public PhysicsMaterial
 	{
 	public:

Doxyfile

@@ -780,7 +780,8 @@ INPUT                  = C:\Projects\BansheeEngineDev\BansheeEngine\BansheeUtili
                          BansheeCore/Include \
                          BansheeCore/Source \
                          BansheeEngine/Include \
-                         BansheeEngine/Source
+                         BansheeEngine/Source \
+                         Documentation/Manuals/Native
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -1442,7 +1443,7 @@ ECLIPSE_DOC_ID         = org.doxygen.Project
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-DISABLE_INDEX          = YES
+DISABLE_INDEX          = NO
 
 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
 # structure should be generated to display hierarchical information. If the tag
@@ -1459,7 +1460,7 @@ DISABLE_INDEX          = YES
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-GENERATE_TREEVIEW      = YES
+GENERATE_TREEVIEW      = NO
 
 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
 # doxygen will group on one line in the generated HTML documentation.

MBansheeEngine/Camera.cs

@@ -242,11 +242,11 @@ namespace BansheeEngine
         public Vector2I WorldToScreen(Vector3 value) { return native.WorldToScreen(value); }
 
         /// <summary>
-        /// Converts a point in world space to clip space coordinates.
+        /// Converts a point in world space to normalized device coordinates.
         /// </summary>
         /// <param name="value">3D point in world space.</param>
-        /// <returns>2D point in normalized coordinates ([0, 1] range), relative to the camera's viewport.</returns>
-        public Vector2 WorldToClip(Vector3 value) { return native.WorldToClip(value); }
+        /// <returns>2D point in normalized device coordinates ([0, 1] range), relative to the camera's viewport.</returns>
+        public Vector2 WorldToNDC(Vector3 value) { return native.WorldToNDC(value); }
 
         /// <summary>
         /// Converts a point in world space to view space coordinates.
@@ -274,11 +274,11 @@ namespace BansheeEngine
         public Vector3 ScreenToView(Vector2I value, float depth = 0.5f) { return native.ScreenToView(value, depth); }
 
         /// <summary>
-        /// Converts a point in screen space to a point in normalized clip space.
+        /// Converts a point in screen space to a point in normalized device coordinates.
         /// </summary>
         /// <param name="value">2D point on the render target attached to the camera, in pixels.</param>
-        /// <returns>2D point in normalized cliped space ([0, 1] range), relative to the camera's viewport.</returns>
-        public Vector2 ScreenToClip(Vector2I value) { return native.ScreenToClip(value); }
+        /// <returns>2D point in normalized device coordinates ([0, 1] range), relative to the camera's viewport.</returns>
+        public Vector2 ScreenToNDC(Vector2I value) { return native.ScreenToNDC(value); }
 
         /// <summary>
         /// Converts a point relative to camera's coordinate system (view space) into a point in world space.
@@ -295,38 +295,38 @@ namespace BansheeEngine
         public Vector2I ViewToScreen(Vector3 value) { return native.ViewToScreen(value); }
 
         /// <summary>
-        /// Converts a point relative to camera's coordinate system (view space) to normalized clip space.
+        /// Converts a point relative to camera's coordinate system (view space) to normalized device coordinates.
         /// </summary>
         /// <param name="value">3D point in view space.</param>
-        /// <returns>2D point in normalized cliped space ([0, 1] range), relative to the camera's viewport.</returns>
-        public Vector2 ViewToClip(Vector3 value) { return native.ViewToClip(value); }
+        /// <returns>2D point in normalized device coordinates ([0, 1] range), relative to the camera's viewport.</returns>
+        public Vector2 ViewToNDC(Vector3 value) { return native.ViewToNDC(value); }
 
         /// <summary>
-        /// Converts a point relative to camera's viewport in normalized clip space ([0, 1] range) into a point in 
+        /// Converts a point relative to camera's viewport in normalized device coordinates ([0, 1] range) into a point in 
         /// world space.
         /// </summary>
-        /// <param name="value">2D point in normalized clip space.</param>
+        /// <param name="value">2D point in normalized device coordinates.</param>
         /// <param name="depth">Depth at which place the world point at. The depth is applied to the vector going from
         ///                     camera origin to the point on the near plane.</param>
         /// <returns>3D point in world space.</returns>
-        public Vector3 ClipToWorld(Vector2 value, float depth = 0.5f) { return native.ClipToWorld(value, depth); }
+        public Vector3 NDCToWorld(Vector2 value, float depth = 0.5f) { return native.NDCToWorld(value, depth); }
 
         /// <summary>
-        /// Converts a point relative to camera's viewport in normalized clip space ([0, 1] range) into a point in 
+        /// Converts a point relative to camera's viewport in normalized device coordinates ([0, 1] range) into a point in 
         /// view space.
         /// </summary>
-        /// <param name="value">2D point in normalized clip space.</param>
+        /// <param name="value">2D point in normalized device coordinates.</param>
         /// <param name="depth">Depth at which place the world point at. The depth is applied to the vector going from
         ///                     camera origin to the point on the near plane.</param>
         /// <returns>3D point in view space.</returns>
-        public Vector3 ClipToView(Vector2 value, float depth = 0.5f) { return native.ClipToView(value, depth); }
+        public Vector3 NDCToView(Vector2 value, float depth = 0.5f) { return native.NDCToView(value, depth); }
 
         /// <summary>
-        /// Converts a point relative to camera's viewport in normalized clip space ([0, 1] range) to screen space.
+        /// Converts a point relative to camera's viewport in normalized device coordinates ([0, 1] range) to screen space.
         /// </summary>
-        /// <param name="value">2D point in normalized clip space.</param>
+        /// <param name="value">2D point in normalized device coordinates.</param>
         /// <returns>2D point on the render target attached to the camera, in pixels.</returns>
-        public Vector2I ClipToScreen(Vector2 value) { return native.ClipToScreen(value); }
+        public Vector2I NDCToScreen(Vector2 value) { return native.NDCToScreen(value); }
 
         /// <summary>
         /// Converts a point in screen space in a ray in world space.
@@ -337,18 +337,18 @@ namespace BansheeEngine
         public Ray ScreenToWorldRay(Vector2I value) { return native.ScreenToWorldRay(value); }
 
         /// <summary>
-        /// Projects a point in view space to a point in clip space. Similar to <see cref="ViewToClip"/> but preserves
-        /// the depth component.
+        /// Projects a point in view space to a point in normalized device coordinates. Similar to <see cref="ViewToNDC"/> 
+        /// but preserves the depth component.
         /// </summary>
         /// <param name="value">3D point in view space.</param>
-        /// <returns>3D point in normalized cliped space ([0, 1] range), relative to the camera's viewport. Z value
+        /// <returns>3D point in normalized device coordinates ([0, 1] range), relative to the camera's viewport. Z value
         ///          range depends on active render API.</returns>
         public Vector3 ProjectPoint(Vector3 value) { return native.ProjectPoint(value); }
 
         /// <summary>
-        /// Un-rpojects a point in clip space to a point in view space.
+        /// Un-rpojects a point in normalized device coordinates to a point in view space.
         /// </summary>
-        /// <param name="value">3D point in normalized cliped space ([0, 1] range), relative to the camera's viewport. 
+        /// <param name="value">3D point in normalized device coordinates ([0, 1] range), relative to the camera's viewport. 
         ///                     Z value range depends on active render API.</param>
         /// <returns>3D point in view space.</returns>
         public Vector3 UnprojectPoint(Vector3 value) { return native.UnprojectPoint(value); }

MBansheeEngine/NativeCamera.cs

@@ -213,10 +213,10 @@ namespace BansheeEngine
             return output;
         }
 
-        internal Vector2 WorldToClip(Vector3 value)
+        internal Vector2 WorldToNDC(Vector3 value)
         {
             Vector2 output;
-            Internal_WorldToClip(mCachedPtr, ref value, out output);
+            Internal_WorldToNDC(mCachedPtr, ref value, out output);
             return output;
         }
 
@@ -241,10 +241,10 @@ namespace BansheeEngine
             return output;
         }
 
-        internal Vector2 ScreenToClip(Vector2I value)
+        internal Vector2 ScreenToNDC(Vector2I value)
         {
             Vector2 output;
-            Internal_ScreenToClip(mCachedPtr, ref value, out output);
+            Internal_ScreenToNDC(mCachedPtr, ref value, out output);
             return output;
         }
 
@@ -262,31 +262,31 @@ namespace BansheeEngine
             return output;
         }
 
-        internal Vector2 ViewToClip(Vector3 value)
+        internal Vector2 ViewToNDC(Vector3 value)
         {
             Vector2 output;
-            Internal_ViewToClip(mCachedPtr, ref value, out output);
+            Internal_ViewToNDC(mCachedPtr, ref value, out output);
             return output;
         }
 
-        internal Vector3 ClipToWorld(Vector2 value, float depth)
+        internal Vector3 NDCToWorld(Vector2 value, float depth)
         {
             Vector3 output;
-            Internal_ClipToWorld(mCachedPtr, ref value, depth, out output);
+            Internal_NDCToWorld(mCachedPtr, ref value, depth, out output);
             return output;
         }
 
-        internal Vector3 ClipToView(Vector2 value, float depth)
+        internal Vector3 NDCToView(Vector2 value, float depth)
         {
             Vector3 output;
-            Internal_ClipToView(mCachedPtr, ref value, depth, out output);
+            Internal_NDCToView(mCachedPtr, ref value, depth, out output);
             return output;
         }
 
-        internal Vector2I ClipToScreen(Vector2 value)
+        internal Vector2I NDCToScreen(Vector2 value)
         {
             Vector2I output;
-            Internal_ClipToScreen(mCachedPtr, ref value, out output);
+            Internal_NDCToScreen(mCachedPtr, ref value, out output);
             return output;
         }
 
@@ -421,7 +421,7 @@ namespace BansheeEngine
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_WorldToScreen(IntPtr instance, ref Vector3 value, out Vector2I output);
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_WorldToClip(IntPtr instance, ref Vector3 value, out Vector2 output);
+        private static extern void Internal_WorldToNDC(IntPtr instance, ref Vector3 value, out Vector2 output);
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_WorldToView(IntPtr instance, ref Vector3 value, out Vector3 output);
 
@@ -430,21 +430,21 @@ namespace BansheeEngine
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_ScreenToView(IntPtr instance, ref Vector2I value, float depth, out Vector3 output);
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_ScreenToClip(IntPtr instance, ref Vector2I value, out Vector2 output);
+        private static extern void Internal_ScreenToNDC(IntPtr instance, ref Vector2I value, out Vector2 output);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_ViewToWorld(IntPtr instance, ref Vector3 value, out Vector3 output);
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_ViewToScreen(IntPtr instance, ref Vector3 value, out Vector2I output);
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_ViewToClip(IntPtr instance, ref Vector3 value, out Vector2 output);
+        private static extern void Internal_ViewToNDC(IntPtr instance, ref Vector3 value, out Vector2 output);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_ClipToWorld(IntPtr instance, ref Vector2 value, float depth, out Vector3 output);
+        private static extern void Internal_NDCToWorld(IntPtr instance, ref Vector2 value, float depth, out Vector3 output);
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_ClipToView(IntPtr instance, ref Vector2 value, float depth, out Vector3 output);
+        private static extern void Internal_NDCToView(IntPtr instance, ref Vector2 value, float depth, out Vector3 output);
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_ClipToScreen(IntPtr instance, ref Vector2 value, out Vector2I output);
+        private static extern void Internal_NDCToScreen(IntPtr instance, ref Vector2 value, out Vector2I output);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_ScreenToWorldRay(IntPtr instance, ref Vector2I value, out Ray output);

RenderBeast/Include/BsRenderBeast.h

@@ -50,6 +50,7 @@ namespace BansheeEngine
 		Matrix4 viewProj;
 		Matrix4 invProj;
 		Matrix4 invViewProj;
+		Matrix4 screenToWorld;
 		Vector2 deviceZToWorldZ;
 		Vector4 clipToUVScaleOffset;
 	};
@@ -202,9 +203,9 @@ namespace BansheeEngine
 		 * 			
 		 * @param[in]	projMatrix	Projection matrix that was used to create the device Z value to transform.
 		 * @return					Returns two values that can be used to transform device z to world z using this formula:
-		 * 							z = deviceZ * x - y.
+		 * 							z = (deviceZ + y) * x.
 		 */
-		static Vector2 getDeviceZTransform();
+		static Vector2 getDeviceZTransform(const Matrix4& projMatrix);
 
 		/**
 		 * Populates the provided camera shader data object with data from the provided camera. The object can then be used

RenderBeast/Include/BsStaticRenderableHandler.h

@@ -24,6 +24,7 @@ namespace BansheeEngine
 		BS_PARAM_BLOCK_ENTRY(Matrix4, gMatProj)
 		BS_PARAM_BLOCK_ENTRY(Matrix4, gMatInvProj)
 		BS_PARAM_BLOCK_ENTRY(Matrix4, gMatInvViewProj)
+		BS_PARAM_BLOCK_ENTRY(Matrix4, gMatScreenToWorld)
 		BS_PARAM_BLOCK_ENTRY(Vector2, gDeviceZToWorldZ)
 		BS_PARAM_BLOCK_ENTRY(Vector4, gClipToUVScaleOffset)
 	BS_PARAM_BLOCK_END

RenderBeast/Source/BsRenderBeast.cpp

@@ -797,13 +797,39 @@ namespace BansheeEngine
 		cameraData.transparentQueue->sort();
 	}
 
-	Vector2 RenderBeast::getDeviceZTransform()
+	Vector2 RenderBeast::getDeviceZTransform(const Matrix4& projMatrix)
 	{
+		// Returns a set of values that will transform depth buffer values (e.g. [0, 1] in DX, [-1, 1] in GL) to a distance
+		// in world space. This involes applying the inverse projection transform to the depth value. When you multiply
+		// a vector with the projection matrix you get [clipX, clipY, Az + B, C * z], where we don't care about clipX/clipY.
+		// A is [2, 2], B is [2, 3] and C is [3, 2] elements of the projection matrix (only ones that matter for our depth 
+		// value). The hardware will also automatically divide the z value with w to get the depth, therefore the final 
+		// formula is:
+		// depth = (Az + B) / (C * z)
+
+		// To get the z coordinate back we simply do the opposite: 
+		// z = B / (depth * C - A)
+
+		// However some APIs will also do a transformation on the depth values before storing them to the texture 
+		// (e.g. OpenGL will transform from [-1, 1] to [0, 1]). And we need to reverse that as well. Therefore the final 
+		// formula is:
+		// z = B / ((depth * (maxDepth - minDepth) + minDepth) * C - A)
+
+		// Are we reorganize it because it needs to fit the "(1.0f / (depth + y)) * x" format used in the shader:
+		// z = 1.0f / (depth + minDepth/(maxDepth - minDepth) - A/((maxDepth - minDepth) * C)) * B/((maxDepth - minDepth) * C)
+
 		RenderAPICore& rapi = RenderAPICore::instance();
 
+		float depthRange = rapi.getMaximumDepthInputValue() - rapi.getMinimumDepthInputValue();
+		float minDepth = rapi.getMinimumDepthInputValue();
+
+		float a = projMatrix[2][2];
+		float b = projMatrix[2][3];
+		float c = projMatrix[3][2];
+
 		Vector2 output;
-		output.x = 1.0f / (rapi.getMaximumDepthInputValue() - rapi.getMinimumDepthInputValue());
-		output.y = -rapi.getMinimumDepthInputValue() * output.x;
+		output.x = b / (depthRange * c);
+		output.y = minDepth / depthRange - a / (depthRange * c);
 
 		return output;
 	}
@@ -815,10 +841,23 @@ namespace BansheeEngine
 		data.view = camera.getViewMatrix();
 		data.viewProj = data.proj * data.view;
 		data.invProj = data.proj.inverse();
-		data.invViewProj = data.viewProj.inverse();
+		data.invViewProj = data.viewProj.inverse(); // Note: Calculate inverses separately (better precision possibly)
+
+		// Construct a special inverse view-projection matrix that had projection entries that affect z and w eliminated.
+		// Used to transform a vector(clip_x, clip_y, view_z, view_w), where clip_x/clip_y are in clip space, and 
+		// view_z/view_w in view space, into world space.
+
+		// Only projects z/w coordinates
+		Matrix4 projZ = Matrix4::IDENTITY;
+		projZ[2][2] = data.proj[2][2];
+		projZ[2][3] = data.proj[2][3];
+		projZ[3][2] = data.proj[3][2];
+		projZ[3][3] = 0.0f;
+
+		data.screenToWorld = data.invViewProj * projZ;
 		data.viewDir = camera.getForward();
 		data.viewOrigin = camera.getPosition();
-		data.deviceZToWorldZ = getDeviceZTransform();
+		data.deviceZToWorldZ = getDeviceZTransform(data.proj);
 
 		SPtr<ViewportCore> viewport = camera.getViewport();
 		SPtr<RenderTargetCore> rt = viewport->getTarget();
@@ -832,7 +871,7 @@ namespace BansheeEngine
 		RenderAPICore& rapi = RenderAPICore::instance();
 
 		data.clipToUVScaleOffset.x = halfWidth / rtWidth;
-		data.clipToUVScaleOffset.y = -halfHeight / rtHeight;
+		data.clipToUVScaleOffset.y = halfHeight / rtHeight; // TODO - Negate for DX11
 		data.clipToUVScaleOffset.z = viewport->getX() / rtWidth + (halfWidth + rapi.getHorizontalTexelOffset()) / rtWidth;
 		data.clipToUVScaleOffset.w = viewport->getY() / rtHeight + (halfHeight + rapi.getVerticalTexelOffset()) / rtHeight;
 

RenderBeast/Source/BsStaticRenderableHandler.cpp

@@ -120,6 +120,7 @@ namespace BansheeEngine
 		mPerCameraParams.gMatViewProj.set(cameraData.viewProj);
 		mPerCameraParams.gMatInvProj.set(cameraData.invProj);
 		mPerCameraParams.gMatInvViewProj.set(cameraData.invViewProj);
+		mPerCameraParams.gMatScreenToWorld.set(cameraData.screenToWorld);
 		mPerCameraParams.gDeviceZToWorldZ.set(cameraData.deviceZToWorldZ);
 		mPerCameraParams.gClipToUVScaleOffset.set(cameraData.clipToUVScaleOffset);
 	}

SBansheeEngine/Include/BsScriptCamera.h

@@ -106,20 +106,20 @@ namespace BansheeEngine
 		static int internal_GetHeightPixels(ScriptCamera* instance);
 
 		static void internal_WorldToScreen(ScriptCamera* instance, Vector3* value, Vector2I* output);
-		static void internal_WorldToClip(ScriptCamera* instance, Vector3* value, Vector2* output);
+		static void internal_WorldToNDC(ScriptCamera* instance, Vector3* value, Vector2* output);
 		static void internal_WorldToView(ScriptCamera* instance, Vector3* value, Vector3* output);
 
 		static void internal_ScreenToWorld(ScriptCamera* instance, Vector2I* value, float depth, Vector3* output);
 		static void internal_ScreenToView(ScriptCamera* instance, Vector2I* value, float depth, Vector3* output);
-		static void internal_ScreenToClip(ScriptCamera* instance, Vector2I* value, Vector2* output);
+		static void internal_ScreenToNDC(ScriptCamera* instance, Vector2I* value, Vector2* output);
 
 		static void internal_ViewToWorld(ScriptCamera* instance, Vector3* value, Vector3* output);
 		static void internal_ViewToScreen(ScriptCamera* instance, Vector3* value, Vector2I* output);
-		static void internal_ViewToClip(ScriptCamera* instance, Vector3* value, Vector2* output);
+		static void internal_ViewToNDC(ScriptCamera* instance, Vector3* value, Vector2* output);
 
-		static void internal_ClipToWorld(ScriptCamera* instance, Vector2* value, float depth, Vector3* output);
-		static void internal_ClipToView(ScriptCamera* instance, Vector2* value, float depth, Vector3* output);
-		static void internal_ClipToScreen(ScriptCamera* instance, Vector2* value, Vector2I* output);
+		static void internal_NDCToWorld(ScriptCamera* instance, Vector2* value, float depth, Vector3* output);
+		static void internal_NDCToView(ScriptCamera* instance, Vector2* value, float depth, Vector3* output);
+		static void internal_NDCToScreen(ScriptCamera* instance, Vector2* value, Vector2I* output);
 
 		static void internal_ScreenToWorldRay(ScriptCamera* instance, Vector2I* value, Ray* output);
 		static void internal_ProjectPoint(ScriptCamera* instance, Vector3* value, Vector3* output);

SBansheeEngine/Source/BsScriptCamera.cpp

@@ -81,20 +81,20 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_GetHeightPixels", &ScriptCamera::internal_GetHeightPixels);
 
 		metaData.scriptClass->addInternalCall("Internal_WorldToScreen", &ScriptCamera::internal_WorldToScreen);
-		metaData.scriptClass->addInternalCall("Internal_WorldToClip", &ScriptCamera::internal_WorldToClip);
+		metaData.scriptClass->addInternalCall("Internal_WorldToNDC", &ScriptCamera::internal_WorldToNDC);
 		metaData.scriptClass->addInternalCall("Internal_WorldToView", &ScriptCamera::internal_WorldToView);
 
 		metaData.scriptClass->addInternalCall("Internal_ScreenToWorld", &ScriptCamera::internal_ScreenToWorld);
 		metaData.scriptClass->addInternalCall("Internal_ScreenToView", &ScriptCamera::internal_ScreenToView);
-		metaData.scriptClass->addInternalCall("Internal_ScreenToClip", &ScriptCamera::internal_ScreenToClip);
+		metaData.scriptClass->addInternalCall("Internal_ScreenToNDC", &ScriptCamera::internal_ScreenToNDC);
 
 		metaData.scriptClass->addInternalCall("Internal_ViewToWorld", &ScriptCamera::internal_ViewToWorld);
 		metaData.scriptClass->addInternalCall("Internal_ViewToScreen", &ScriptCamera::internal_ViewToScreen);
-		metaData.scriptClass->addInternalCall("Internal_ViewToClip", &ScriptCamera::internal_ViewToClip);
+		metaData.scriptClass->addInternalCall("Internal_ViewToNDC", &ScriptCamera::internal_ViewToNDC);
 
-		metaData.scriptClass->addInternalCall("Internal_ClipToWorld", &ScriptCamera::internal_ClipToWorld);
-		metaData.scriptClass->addInternalCall("Internal_ClipToView", &ScriptCamera::internal_ClipToView);
-		metaData.scriptClass->addInternalCall("Internal_ClipToScreen", &ScriptCamera::internal_ClipToScreen);
+		metaData.scriptClass->addInternalCall("Internal_NDCToWorld", &ScriptCamera::internal_NDCToWorld);
+		metaData.scriptClass->addInternalCall("Internal_NDCToView", &ScriptCamera::internal_NDCToView);
+		metaData.scriptClass->addInternalCall("Internal_NDCToScreen", &ScriptCamera::internal_NDCToScreen);
 
 		metaData.scriptClass->addInternalCall("Internal_ScreenToWorldRay", &ScriptCamera::internal_ScreenToWorldRay);
 		metaData.scriptClass->addInternalCall("Internal_ProjectPoint", &ScriptCamera::internal_ProjectPoint);
@@ -325,9 +325,9 @@ namespace BansheeEngine
 		*output = instance->mCamera->worldToScreenPoint(*value);
 	}
 
-	void ScriptCamera::internal_WorldToClip(ScriptCamera* instance, Vector3* value, Vector2* output)
+	void ScriptCamera::internal_WorldToNDC(ScriptCamera* instance, Vector3* value, Vector2* output)
 	{
-		*output = instance->mCamera->worldToClipPoint(*value);
+		*output = instance->mCamera->worldToNdcPoint(*value);
 	}
 
 	void ScriptCamera::internal_WorldToView(ScriptCamera* instance, Vector3* value, Vector3* output)
@@ -345,9 +345,9 @@ namespace BansheeEngine
 		*output = instance->mCamera->screenToViewPoint(*value, depth);
 	}
 
-	void ScriptCamera::internal_ScreenToClip(ScriptCamera* instance, Vector2I* value, Vector2* output)
+	void ScriptCamera::internal_ScreenToNDC(ScriptCamera* instance, Vector2I* value, Vector2* output)
 	{
-		*output = instance->mCamera->screenToClipPoint(*value);
+		*output = instance->mCamera->screenToNdcPoint(*value);
 	}
 
 	void ScriptCamera::internal_ViewToWorld(ScriptCamera* instance, Vector3* value, Vector3* output)
@@ -360,24 +360,24 @@ namespace BansheeEngine
 		*output = instance->mCamera->viewToScreenPoint(*value);
 	}
 
-	void ScriptCamera::internal_ViewToClip(ScriptCamera* instance, Vector3* value, Vector2* output)
+	void ScriptCamera::internal_ViewToNDC(ScriptCamera* instance, Vector3* value, Vector2* output)
 	{
-		*output = instance->mCamera->viewToClipPoint(*value);
+		*output = instance->mCamera->viewToNdcPoint(*value);
 	}
 
-	void ScriptCamera::internal_ClipToWorld(ScriptCamera* instance, Vector2* value, float depth, Vector3* output)
+	void ScriptCamera::internal_NDCToWorld(ScriptCamera* instance, Vector2* value, float depth, Vector3* output)
 	{
-		*output = instance->mCamera->clipToWorldPoint(*value, depth);
+		*output = instance->mCamera->ndcToWorldPoint(*value, depth);
 	}
 
-	void ScriptCamera::internal_ClipToView(ScriptCamera* instance, Vector2* value, float depth, Vector3* output)
+	void ScriptCamera::internal_NDCToView(ScriptCamera* instance, Vector2* value, float depth, Vector3* output)
 	{
-		*output = instance->mCamera->clipToViewPoint(*value, depth);
+		*output = instance->mCamera->ndcToViewPoint(*value, depth);
 	}
 
-	void ScriptCamera::internal_ClipToScreen(ScriptCamera* instance, Vector2* value, Vector2I* output)
+	void ScriptCamera::internal_NDCToScreen(ScriptCamera* instance, Vector2* value, Vector2I* output)
 	{
-		*output = instance->mCamera->clipToScreenPoint(*value);
+		*output = instance->mCamera->ndcToScreenPoint(*value);
 	}
 
 	void ScriptCamera::internal_ScreenToWorldRay(ScriptCamera* instance, Vector2I* value, Ray* output)