Thanks for the quick response. Firstly, GL is column major whereas directx is row major. I've already had to transpose for my first geometry stage and it works well. 

Second, will I need to change my first stage to accommodate this change as well? Also can I just multiply it by glm::translate(0,0,0.5)xProjection

EDIT: I've switched to row major vertices in DirectX using the following:

#pragma pack_matrix( row_major )

I guess DirectX just uses row major by default. I'm still having the same issues though. I tried using the following in ViewPosFromDepth:

float z = depth * 0.5 + 0.5;

1 hour ago, Hodgman said:

yeah whenever you produce a projection matrix you have to scale in z by 0.5 and then translate in z by 0.5. You need to do this for your vertex shaders so that the rasterization is correct. When fetching from the depth buffer, don't scale/offset the fetched value

I've tried this, but now it's far too zoomed in. Originally, it did look quite like my OpenGL results. Is there a reason for this?

projection *= glm::translate(glm::vec3(0.0f,0.0f,0.5f)) * glm::scale(glm::vec3(1.0f,1.0f,0.5f));

Okay thank you a lot, Hodgman I finally got it to work! But I do have a question, my main vertex.hlsl which takes the actual geometry and pushes it into the gbuffer requires row-major whereas the rest works fine using column major. Do you have any idea why that could be?

@Hodgman Got any idea for the question above?

@Hodgman Sorry! Didn't see the response until now! Keep in mind as I used GLM, it's column major. Here's the code that works:

////////////////////////////////////////////////////////////////////////////////
// Filename: mainVert.vs
////////////////////////////////////////////////////////////////////////////////

/////////////
// GLOBALS //
/////////////
#pragma pack_matrix( row_major )

cbuffer MatrixBuffer
{
    matrix worldMatrix;
    matrix viewMatrix;
    matrix projectionMatrix;
};

//////////////
// TYPEDEFS //
//////////////
struct VertexInputType {
    float3 position : POSITION;
    float3 normal : NORMAL;
    float3 tangent : TANGENT;
    float2 texCoord : TEXCOORD0;
};

struct PixelInputType {
    float4 position : SV_POSITION;
    float3 worldPosition : POSITION;
    float3 normal : NORMAL;
    float3 tangent : TANGENT;
    float2 texCoord : TEXCOORD0;
};

////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType main(VertexInputType input) {
    float4 position;
    PixelInputType output;

    // Change the position vector to be 4 units for proper matrix calculations.
    position = float4(input.position, 1.0f);

    // Calculate the position of the vertex against the world, view, and projection matrices.
    position = mul(position, worldMatrix);
    output.worldPosition = position.xyz;
    position = mul(position, viewMatrix);
    output.position = mul(position, projectionMatrix);
    
    output.normal = normalize(mul(float4(input.normal, 1.0), worldMatrix).xyz);
    output.tangent = normalize(mul(float4(input.tangent, 1.0), worldMatrix).xyz);
    output.texCoord = float2(input.texCoord.x, -input.texCoord.y);
    
    return output;
}

////////////////////////////////////////////////////////////////////////////////
// Filename: pointLightFrag.ps
////////////////////////////////////////////////////////////////////////////////

#pragma pack_matrix( column_major )

#include "inc_transform.hlsl"
#include "inc_light.hlsl"

//////////////
// TYPEDEFS //
//////////////
struct PixelInputType {
    float4 position : SV_POSITION;
    float2 texCoord : TEXCOORD0;
    float3 viewRay : POSITION;
};

Texture2D shaderTexture[4];
SamplerState SampleType[4];

cbuffer MatrixInfoType {
    matrix invView;
    matrix invProj;
    float4 eyePos;
    float4 resolution;
};

cbuffer Light {
	float3 lightPosition;
    float lightAttenuationRadius;
	float3 lightColor;
	float lightIntensity;
};

////////////////////////////////////////////////////////////////////////////////
// Pixel Shader
////////////////////////////////////////////////////////////////////////////////
float4 main(PixelInputType input) : SV_TARGET {
    float  depth        = shaderTexture[3].Sample(SampleType[0], input.texCoord).r;
    float3 Position = WorldPosFromDepth(invProj, invView, depth, input.texCoord);
    //return float4(position, 1.0);
    /*float near = 0.1;
    float far = 100;
    float ProjectionA = far / (far - near);
    float ProjectionB = (-far * near) / (far - near);
    depth = ProjectionB / ((depth - ProjectionA));
    float4 position = float4(input.viewRay * depth, 1.0);*/
    // Convert to World Space:
    // position = mul(invView, position);
    float3 Albedo       = shaderTexture[0].Sample(SampleType[0], input.texCoord).rgb;
    float3 Normal       = shaderTexture[1].Sample(SampleType[0], input.texCoord).rgb;
    float4 Specular     = shaderTexture[2].Sample(SampleType[0], input.texCoord);

	float3 lightPow = lightColor * lightIntensity;
	float3 outColor = LightPointCalc(Albedo.rgb, Position.xyz, Specular, Normal.xyz, lightPosition, lightAttenuationRadius, lightPow, eyePos.xyz); // hdrGammaTransform()
	return float4(hdrGammaTransform(outColor), 1.0f);
}