Merge pull request #1 from Serbernus/master

Update PS_Diffuse.hlsl

D3D11Engine/Shaders/PS_Diffuse.hlsl

@@ -6,13 +6,21 @@
 #include <DS_Defines.h>
 #include <Toolbox.h>
 
+static const float		SPECULAR_MULT		= 8.0f;
+static const float		ROUGHNESS_MULT		= 128.0f;
+
+#define USE_MIP_LOD
+
+static const float		HEIGHT_MAP_SCALE = 0.025;
+static const int		MIN_SAMPLES			= 8;
+static const int		MAX_SAMPLES			= 64;
+
 cbuffer MI_MaterialInfo : register( b2 )
 {
 	float MI_SpecularIntensity;
 	float MI_SpecularPower;
 	float MI_NormalmapStrength;
 	float MI_ParallaxOcclusionStrength;
-
 	float4 MI_Color;
 }
 
@@ -45,45 +53,222 @@ struct PS_INPUT
 	float4 vPosition		: SV_POSITION;
 };
 
+float3x3 face_orientation( float3 N, float3 p, float2 uv )
+{
+    // get edge vectors of the pixel triangle
+    float3 dp1 = ddx( p );
+    float3 dp2 = ddy( p );
+    float2 duv1 = ddx( uv );
+    float2 duv2 = ddy( uv );
+
+    // solve the linear system
+    float3 dp2perp = cross( dp2, N );
+    float3 dp1perp = cross( N, dp1 );
+    float3 T = dp2perp * duv1.x + dp1perp * duv2.x;
+    float3 B = dp2perp * duv1.y + dp1perp * duv2.y;
+
+	// Negate because of left-handedness
+	//T *= -1;
+	//B *= -1;
+
+    // construct a scale-invariant frame 
+    float invmax = rsqrt( max( dot(T,T), dot(B,B) ) );
+    return float3x3( T * invmax, B * invmax, N );
+}
+
+float2 calculateParallaxCorrectedTexCoord(PS_INPUT input, float2 parallaxOffsetTS, float3 viewTS)
+{
+	float2 texSampleBase = input.vTexcoord;
+
+	float  fMipLevel;      
+    float  fMipLevelInt;    // mip level integer portion
+    float  fMipLevelFrac;   // mip level fractional amount for blending in between levels
+
+    float  fMinTexCoordDelta;
+    float2 dTexCoords;
+
+
+#ifdef USE_MIP_LOD
+	// Compute the current gradients:
+	float2 fTexCoordsPerSize = input.vTexcoord;
+
+	// Compute all 4 derivatives in x and y in a single instruction to optimize:
+	float2 dxSize, dySize;
+	float2 dx, dy;
+
+	float4( dxSize, dx ) = ddx( float4( fTexCoordsPerSize, input.vTexcoord ) );
+	float4( dySize, dy ) = ddy( float4( fTexCoordsPerSize, input.vTexcoord ) );
+
+    // Find min of change in u and v across quad: compute du and dv magnitude across quad
+    dTexCoords = dxSize * dxSize + dySize * dySize;
+
+    // Standard mipmapping uses max here
+    fMinTexCoordDelta = max( dTexCoords.x, dTexCoords.y ) * 0.5f;
+
+    // Compute the current mip level  (* 0.5 is effectively computing a square root before )
+    fMipLevel = max( 0.5 * log2( fMinTexCoordDelta ), 0 );
+
+   // Multiplier for visualizing the level of detail (see notes for 'nLODThreshold' variable
+   // for how that is done visually)
+   float4 cLODColoring = float4( 1, 1, 3, 1 );
+
+   float fOcclusionShadow = 1.0;
+ #endif
+	// Calculate directions
+	float3 N = normalize( input.vNormalVS );
+	float3 E = normalize( viewTS );
+
+	//===============================================//
+	// Parallax occlusion mapping offset computation //
+	//===============================================//
+
+	// Utilize dynamic flow control to change the number of samples per ray 
+	// depending on the viewing angle for the surface. Oblique angles require 
+	// smaller step sizes to achieve more accurate precision for computing displacement.
+	// We express the sampling rate as a linear function of the angle between 
+	// the geometric normal and the view direction ray:
+	int nNumSteps = (int)lerp( MAX_SAMPLES, MIN_SAMPLES, dot( E, N ) );
+
+	// Intersect the view ray with the height field profile along the direction of
+	// the parallax offset ray (computed in the vertex shader. Note that the code is
+	// designed specifically to take advantage of the dynamic flow control constructs
+	// in HLSL and is very sensitive to specific syntax. When converting to other examples,
+	// if still want to use dynamic flow control in the resulting assembly shader,
+	// care must be applied.
+	// 
+	// In the below steps we approximate the height field profile as piecewise linear
+	// curve. We find the pair of endpoints between which the intersection between the 
+	// height field profile and the view ray is found and then compute line segment
+	// intersection for the view ray and the line segment formed by the two endpoints.
+	// This intersection is the displacement offset from the original texture coordinate.
+	// See the above paper for more details about the process and derivation.
+
+	float fCurrHeight = 0.0;
+	float fStepSize   = 1.0 / (float) nNumSteps;
+	float fPrevHeight = 1.0;
+	float fNextHeight = 0.0;
+
+	int    nStepIndex = 0;
+	bool   bCondition = true;
+
+	float2 vTexOffsetPerStep = fStepSize * parallaxOffsetTS;
+	float2 vTexCurrentOffset = input.vTexcoord;
+	float  fCurrentBound     = 1.0;
+	float  fParallaxAmount   = 0.0;
+
+	float2 pt1 = 0;
+	float2 pt2 = 0;
+
+	float2 texOffset2 = 0;
+
+	while ( nStepIndex < nNumSteps ) 
+	{
+		vTexCurrentOffset -= vTexOffsetPerStep;
+
+		// Sample height map
+		fCurrHeight = 1 - TX_Texture2.SampleGrad( SS_Linear, vTexCurrentOffset, dx, dy ).b;
+
+		fCurrentBound -= fStepSize;
+
+		if ( fCurrHeight > fCurrentBound ) 
+		{   
+			pt1 = float2( fCurrentBound, fCurrHeight );
+			pt2 = float2( fCurrentBound + fStepSize, fPrevHeight );
+
+			texOffset2 = vTexCurrentOffset - vTexOffsetPerStep;
+
+			nStepIndex = nNumSteps + 1;
+			fPrevHeight = fCurrHeight;
+		}
+		else
+		{
+			nStepIndex++;
+			fPrevHeight = fCurrHeight;
+		}
+	}   
+
+	float fDelta2 = pt2.x - pt2.y;
+	float fDelta1 = pt1.x - pt1.y;
+
+	float fDenominator = fDelta2 - fDelta1;
+
+	// SM 3.0 requires a check for divide by zero, since that operation will generate
+	// an 'Inf' number instead of 0, as previous models (conveniently) did:
+	if ( fDenominator == 0.0f )
+	{
+		fParallaxAmount = 0.0f;
+	}
+	else
+	{
+		fParallaxAmount = (pt1.x * fDelta2 - pt2.x * fDelta1 ) / fDenominator;
+	}
+
+	float2 vParallaxOffset = parallaxOffsetTS * (1 - fParallaxAmount );
+
+	// The computed texture offset for the displaced point on the pseudo-extruded surface:
+	texSampleBase = input.vTexcoord - vParallaxOffset;
+
+	return texSampleBase;
+}
+
 //--------------------------------------------------------------------------------------
 // Pixel Shader
 //--------------------------------------------------------------------------------------
 DEFERRED_PS_OUTPUT PSMain( PS_INPUT Input ) : SV_TARGET
 {
-	float4 color = TX_Texture0.Sample(SS_Linear, Input.vTexcoord);
+	float2 Texcoord = Input.vTexcoord;
+	float3 nrm = normalize(Input.vNormalVS);
+	float4 fx = 0.0f;
+
+#if FXMAP == 1
+	float heightmap = TX_Texture2.Sample(SS_Linear, Input.vTexcoord).b;
+
+	float3x3 TBN = face_orientation(Input.vNormalVS, -Input.vViewPosition, Input.vTexcoord);
+	float3 VTS = mul(TBN, Input.vViewPosition);
+	float3 NTS = mul(TBN, Input.vNormalVS);
+
+	// Compute initial parallax displacement direction:
+    float2 vParallaxDirection = normalize( VTS.xy );
 
-	// Do alphatest if wanted
-#if ALPHATEST == 1
-	ClipDistanceEffect(length(Input.vViewPosition), DIST_DrawDistance, color.r * 2 - 1, 500.0f);
+	// The length of this vector determines the furthest amount of displacement:
+    float fLength         = length( VTS );
+    float fParallaxLength = sqrt( fLength * fLength - VTS.z * VTS.z ) / VTS.z; 
+
+	// Compute the actual reverse parallax displacement vector:
+    float2 vParallaxOffsetTS = vParallaxDirection * fParallaxLength;
+
+	// Need to scale the amount of displacement to account for different height ranges
+    // in height maps. This is controlled by an artist-editable parameter:
+    vParallaxOffsetTS *= HEIGHT_MAP_SCALE;
 
-	// WorldMesh can always do the alphatest
-	DoAlphaTest(color.a);
+	//Texcoord = Input.vTexcoord - (vParallaxOffsetTS * (1 - heightmap));
+	Texcoord = calculateParallaxCorrectedTexCoord(Input, vParallaxOffsetTS, Input.vViewPosition);
+	fx = TX_Texture2.Sample(SS_Linear, Texcoord);
 #endif
 
+	float4 color = TX_Texture0.Sample(SS_Linear, Texcoord);
+
 	// Apply normalmapping if wanted
 #if NORMALMAPPING == 1
-	float3 nrm = perturb_normal(Input.vNormalVS, Input.vViewPosition, TX_Texture1, Input.vTexcoord, SS_Linear, MI_NormalmapStrength);
-#else
-	float3 nrm = normalize(Input.vNormalVS);
+	nrm = perturb_normal(Input.vNormalVS, Input.vViewPosition, TX_Texture1, Texcoord, SS_Linear, MI_NormalmapStrength);
 #endif
-
-	float4 fx;
-#if FXMAP == 1
-	fx = TX_Texture2.Sample(SS_Linear, Input.vTexcoord);
-#else
-	fx = 1.0f;
+
+	// Do alphatest if wanted
+#if ALPHATEST == 1
+	ClipDistanceEffect(length(Input.vViewPosition), DIST_DrawDistance, color.r * 2 - 1, 500.0f);
+
+	// WorldMesh can always do the alphatest
+	DoAlphaTest(color.a);
 #endif
+
+	float specular = SPECULAR_MULT * fx.r;
+	float roughness = ROUGHNESS_MULT * (ceil(fx.g) - fx.g);
 
 	DEFERRED_PS_OUTPUT output;
 	output.vDiffuse = float4(color.rgb, Input.vDiffuse.y);
-	//output.vDiffuse = float4(Input.vTexcoord2, 0, 1);
-	//output.vDiffuse = float4(Input.vNormalVS, 1);
 
-	output.vNrm.xyz = nrm;
-	output.vNrm.w = 1.0f;
+	output.vNrm = float4(nrm.xyz, 1.0f);
 
-	output.vSI_SP.x = MI_SpecularIntensity * fx.r;
-	output.vSI_SP.y = MI_SpecularPower * fx.g;
+	output.vSI_SP = float2(specular, roughness);
 	return output;
 }
-