Минимальные:
Процессор: Intel Core 2 Duo или аналог от AMD
RAM: 1 GB
Видеокарта: GeForce 8800, GeForce GT220

Рекомендуемые:
Процессор: Intel Quad Core или Intel Dual Core CPU 3.0+ GHz
RAM: 2 GB
Видеокарта: GeForce GTX 260 или Radeon HD4850

Максимальные:
Процессор: Intel Core i7
RAM: 8 GB
Видеокарта: GeForce GTX480

Минимальные:
Процессор: Intel Core 2 Duo 2.7 GHz или аналог от AMD
RAM: 2 GB
Видеокарта: GeForce GTS 250 или Radeon 3870

Рекомендуемые:
Процессор: Intel Core i5 2.6 GHz или AMD Phenom II X4 965
RAM: 4 GB
Видеокарта: GeForce GTX 580 ( GTX 660 Ti ) или Radeon 7850

Максимальные:
Процессор: Intel Core i7 3.4 GHz или AMD FX-8150
RAM: 8 GB
Видеокарта: GeForce GTX 690 ( Titan ) или Radeon 7970

Минимальные:
(1080p, 30 fps, низкие настройки графики)
Операционная система: Windows 7, 8, 10
Процессор: Intel Core i5 и выше с учётом разгона, или Intel Core i7 второго поколения и выше
Оперативная память: 8 гигабайт
Видеокарта: Nvidia GTX 670, GTX 1050 или AMD Radeon HD 7870, объём памяти 2 гигабайта
Поддержка DirectX 11 или 12

Рекомендуемые:
(1080p, 60 fps, высокие настройки графики)
Операционная система: Windows 10
Процессор: Intel Core i5 и выше с учётом разгона, или Intel Core i7 второго поколения и выше
Оперативная память: 8 гигабайт
Видеокарта: Nvidia GTX 1070, RTX 2060 или AMD RX Vega 56, объём памяти 8 гигабайт
Поддержка DirectX 12

Системные требования для высоких настроек графики
(1440p, 60 fps, настройки графики «ультра»)
Операционная система: Windows10
Процессор: Intel Core i5 и выше с учётом разгона, или Intel Core i7 второго поколения и выше
Оперативная память: 16 гигабайт
Видеокарта: Nvidia GTX 1080Ti, RTX 2070 или AMD RX Vega 64, объём памяти 8 гигабайт
Поддержка DirectX 12

Системные требования для максимальных настроек графики
(4K, 45+ fps, настройки графики «экстремальные»)
Операционная система: Windows 10
Процессор: Intel Core i5 и выше с учётом разгона, или Intel Core i7 второго поколения и выше
Оперативная память: 16 гигабайт
Видеокарта: Nvidia GTX 2080Ti, объём памяти 11 гигабайт
Поддержка DirectX 12

#define OPENED_U_VERTEX (1 << 22)
#define OPENED_V_VERTEX (1 << 23)
#define OPENED_W_VERTEX (1 << 24)
#define NO_EARLYOUT_MASK (1 << 25)
#define UVEDGE_MASK (1 << 26)
#define VWEDGE_MASK (1 << 27)
#define WUEDGE_MASK (1 << 28)
#define KILL_DISPLACEMENT (OPENED_U_VERTEX | OPENED_V_VERTEX | OPENED_W_VERTEX | UVEDGE_MASK | VWEDGE_MASK | WUEDGE_MASK)
#define UV_CHANGED_MASK (1 << 29)
#define UNORMAL_ZNEGATIVE_MASK (1 << 29)
#define VNORMAL_ZNEGATIVE_MASK (1 << 30)
#define WNORMAL_ZNEGATIVE_MASK (1 << 31)
#define TRGLINK_MASK (~((~0) << 22))
#define VIRTUAL_DICING_OFF (1 << 31)
#define FIRST_VIRTUAL_PATCH VIRTUAL_DICING_OFF
#define DISPLACEMENT_OFF (1 << 30)
#define CULL_MASK_PLANE0 1
#define CULL_MASK_PLANE1 2
#define CULL_MASK_PLANE2 4
#define CULL_MASK_PLANE3 8
#define CULL_MASK_ALL_PLANES (CULL_MASK_PLANE0 | CULL_MASK_PLANE1 | CULL_MASK_PLANE2 | CULL_MASK_PLANE3)
#define IS_FRUSTUM_CULLED(x) ((x & CULL_MASK_ALL_PLANES) != 0)
#define CULL_MASK_EDGE0 16
#define CULL_MASK_EDGE1 32
#define CULL_MASK_EDGE2 64
#define CULL_MASK_ALL_EDGES (CULL_MASK_EDGE0 | CULL_MASK_EDGE1 | CULL_MASK_EDGE2)
#define IS_TRIANGLE_AWAY(x) ((x & CULL_MASK_ALL_EDGES) == CULL_MASK_ALL_EDGES)
#define IS_DISPLACEMENT_OFF(x) ((x & (DISPLACEMENT_OFF | VIRTUAL_DICING_OFF)) != 0)
cbuffer tempCBName%i : register( b%i ) {
float g_DisplacementScale;
float g_TessellationFactor;
float g_MinDistance;
float g_FadeDistance;
float4 g_CameraPosition;
float4x4 g_BypassPosition;
float4x4 g_Projection;
float4x4 g_InverseProjection;
float4 g_ClipPlane0;
}
%s
struct VS_OUTPUT
{
%s};
struct PS_INPUT
{
%s};
//-------------------------------------------------------------
// STREAM OUT stage
struct GS_OUTPUT
{
float4 Position : SV_POSITION;
float2 uv : TEXCOORD0;
};
float4x4 _getInverseProjection()
{
if(%d) return getInverseProjection();
float4x4 m = getProjection();
float m00 = m[0][0], m01 = m[0][1], m02 = m[0][2], m03 = m[0][3];
float m10 = m[1][0], m11 = m[1][1], m12 = m[1][2], m13 = m[1][3];
float m20 = m[2][0], m21 = m[2][1], m22 = m[2][2], m23 = m[2][3];
float m30 = m[3][0], m31 = m[3][1], m32 = m[3][2], m33 = m[3][3];
float determinant =
m03*m12*m21*m30 - m02*m13*m21*m30 - m03*m11*m22*m30 + m01*m13*m22*m30+
m02*m11*m23*m30 - m01*m12*m23*m30 - m03*m12*m20*m31 + m02*m13*m20*m31+
m03*m10*m22*m31 - m00*m13*m22*m31 - m02*m10*m23*m31 + m00*m12*m23*m31+
m03*m11*m20*m32 - m01*m13*m20*m32 - m03*m10*m21*m32 + m00*m13*m21*m32+
m01*m10*m23*m32 - m00*m11*m23*m32 - m02*m11*m20*m33 + m01*m12*m20*m33+
m02*m10*m21*m33 - m00*m12*m21*m33 - m01*m10*m22*m33 + m00*m11*m22*m33;
//if (abs(determinant) < 0.0f)
float4x4 d;
d[0][0] = m11*m22*m33 + m12*m23*m31 + m13*m21*m32 - m11*m23*m32 - m12*m21*m33 - m13*m22*m31;
d[0][1] = m03*m22*m31 - m02*m23*m31 - m03*m21*m32 + m01*m23*m32 + m02*m21*m33 - m01*m22*m33;
d[0][2] = m02*m13*m31 - m03*m12*m31 + m03*m11*m32 - m01*m13*m32 - m02*m11*m33 + m01*m12*m33;
d[0][3] = m03*m12*m21 - m02*m13*m21 - m03*m11*m22 + m01*m13*m22 + m02*m11*m23 - m01*m12*m23;
d[1][0] = m13*m22*m30 - m12*m23*m30 - m13*m20*m32 + m10*m23*m32 + m12*m20*m33 - m10*m22*m33;
d[1][1] = m02*m23*m30 - m03*m22*m30 + m03*m20*m32 - m00*m23*m32 - m02*m20*m33 + m00*m22*m33;
d[1][2] = m03*m12*m30 - m02*m13*m30 - m03*m10*m32 + m00*m13*m32 + m02*m10*m33 - m00*m12*m33;
d[1][3] = m02*m13*m20 - m03*m12*m20 + m03*m10*m22 - m00*m13*m22 - m02*m10*m23 + m00*m12*m23;
d[2][0] = m11*m23*m30 - m13*m21*m30 + m13*m20*m31 - m10*m23*m31 - m11*m20*m33 + m10*m21*m33;
d[2][1] = m03*m21*m30 - m01*m23*m30 - m03*m20*m31 + m00*m23*m31 + m01*m20*m33 - m00*m21*m33;
d[2][2] = m01*m13*m30 - m03*m11*m30 + m03*m10*m31 - m00*m13*m31 - m01*m10*m33 + m00*m11*m33;
d[2][3] = m03*m11*m20 - m01*m13*m20 - m03*m10*m21 + m00*m13*m21 + m01*m10*m23 - m00*m11*m23;
d[3][0] = m12*m21*m30 - m11*m22*m30 - m12*m20*m31 + m10*m22*m31 + m11*m20*m32 - m10*m21*m32;
d[3][1] = m01*m22*m30 - m02*m21*m30 + m02*m20*m31 - m00*m22*m31 - m01*m20*m32 + m00*m21*m32;
d[3][2] = m02*m11*m30 - m01*m12*m30 - m02*m10*m31 + m00*m12*m31 + m01*m10*m32 - m00*m11*m32;
d[3][3] = m01*m12*m20 - m02*m11*m20 + m02*m10*m21 - m00*m12*m21 - m01*m10*m22 + m00*m11*m22;
d /= determinant;
return d;
}
GS_OUTPUT transform(VS_OUTPUT i)
{
GS_OUTPUT o;
o.uv.xy = i.HeightMapUV.%s;
o.Position = mul( i.Position, _getInverseProjection() );
o.Position.xyz /= o.Position.w;
return o;
}
[maxvertexcount(3)]
void GS( triangle VS_OUTPUT i[3], inout TriangleStream<GS_OUTPUT> TriStream )
{
TriStream.Append( transform( i[0] ) );
TriStream.Append( transform( i[1] ) );
TriStream.Append( transform( i[2] ) );
TriStream.RestartStrip();
}
//-------------------------------------------------------------
//HS
Buffer<float3> g_BarycentricsBuffer : register( t0 ); //number of diced triangles * 3
Buffer<uint> InitialPatchID : register(t1); //number of diced triangles * 3
Buffer<uint> TrgLinksBuf : register(t2); //number of initial triangles
struct HS_ConstantOutput
{
float fTessFactor[3] : SV_TessFactor;
float fInsideTessFactor : SV_InsideTessFactor;
float2 Basis[3] : BASIS; //virtual dicing
uint uPrimID : PRIM_ID;
uint uTrgLink : TRIANGLE_LINK;
};
//FIXME: Should use a proper user-defined sampler, not the hardcoded one!
SamplerState sheight_HS : register(s0);
/*{
Filter = MIN_MAG_MIP_POINT;
AddressU = Wrap;
AddressV = Wrap;
};*/
Texture2D theight_HS : register(t3);
//Buffer<float3> g_PositionH : register( t4 ); //number of diced triangles * 3
bool EdgeSphereIntersect( float3 E, float3 L, float3 C, float r)
{
//E is the starting point of the ray,
//L is the end point of the ray,
//C is the center of sphere you're testing against
//r is the radius of that sphere
float3 d = L - E;// ( Direction vector of ray, from start to end )
float3 f = E - C;// ( Vector from center sphere to ray start )
float a = dot( d, d ) ;
float b = 2*dot( d, f ) ;
float c = dot( f, f ) - r*r ;
float discriminant = b*b-4*a*c;
if( discriminant < 0 )
{
// no intersection
return false;
}
else
{
// ray didn't totally miss sphere,
// so there is a solution to
// the equation.
discriminant = sqrt( discriminant );
// either solution may be on or off the ray so need to test both
// t1 is always the smaller value, because BOTH discriminant and
// a are nonnegative.
float t1 = (-b - discriminant)/(2*a);
float t2 = (-b + discriminant)/(2*a);
if( t1 >= 0 && t1 <= 1 )
{
// t1 is an intersection, and if it hits,
// it's closer than t2 would be
return true ;
}
// here t1 didn't intersect so we are either started
// inside the sphere or completely past it
if( t2 >= 0 && t2 <= 1 )
{
// ExitWound
return true ;
}
// no intn: FallShort, Past, CompletelyInside
return false ;
}
}
HS_ConstantOutput HS_Constant( InputPatch<VS_OUTPUT, 3> I, uint uPID : SV_PrimitiveID )
{
HS_ConstantOutput O;
O.Basis[0] = g_BarycentricsBuffer[ uPID * 3 + 0 ].xy;
O.Basis[1] = g_BarycentricsBuffer[ uPID * 3 + 1 ].xy;
O.Basis[2] = g_BarycentricsBuffer[ uPID * 3 + 2 ].xy;
uint pid = InitialPatchID.Load( uPID );
O.uPrimID = pid & (~FIRST_VIRTUAL_PATCH);
O.uTrgLink = TrgLinksBuf.Load( O.uPrimID );
//frustum cull in clip space
float2 P2[3];
float3 p0 = I[0].Position;
float3 p1 = I[1].Position;
float3 p2 = I[2].Position;
float q = 1.2f + 1.0f / min( 1.0f, min( p0.z, min( p1.z, p2.z ) ) );
float u = 1.0f*abs(g_DisplacementScale);
if ( p0.z > 0 && p1.z > 0 && p2.z > 0)
if (
((p0.x+u)/p0.z < -q && (p1.x+u)/p1.z < -q && (p2.x+u)/p2.z < -q) ||
((p0.x-u)/p0.z > q && (p1.x-u)/p1.z > q && (p2.x-u)/p2.z > q) ||
((p0.y+u)/p0.z < -q && (p1.y+u)/p1.z < -q && (p2.y+u)/p2.z < -q) ||
((p0.y-u)/p0.z > q && (p1.y-u)/p1.z > q && (p2.y-u)/p2.z > q)
)
{
O.fTessFactor[0] = O.fTessFactor[1] = O.fTessFactor[2] = O.fInsideTessFactor = 0;
return O;
}//*/
float4x4 ip = _getInverseProjection();
float4 wp[3];
wp[0] = mul(I[0].Position, ip); wp[0].xyz /= wp[0].w;
wp[1] = mul(I[1].Position, ip); wp[1].xyz /= wp[1].w;
wp[2] = mul(I[2].Position, ip); wp[2].xyz /= wp[2].w;
//wp[0].xyz = g_PositionH.Load( uPID * 3 + 0 ).xyz;
//wp[1].xyz = g_PositionH.Load( uPID * 3 + 1 ).xyz;
//wp[2].xyz = g_PositionH.Load( uPID * 3 + 2 ).xyz;
//whole original triangle is too far -> draw only first patch without tessellation
float3 dist3 = float3( length( getCameraPosition().xyz-wp[0].xyz ), length( getCameraPosition().xyz-wp[1].xyz ), length( getCameraPosition().xyz-wp[2].xyz ) );
float dist = min( dist3.x, min( dist3.y, dist3.z ) );
if( dist > getFadeDistance() )
{
// camera is too far to corners. Chech edges of the triangle
bool i0 = EdgeSphereIntersect( wp[0].xyz, wp[1].xyz, getCameraPosition().xyz, getFadeDistance() );
bool i1 = EdgeSphereIntersect( wp[1].xyz, wp[2].xyz, getCameraPosition().xyz, getFadeDistance() );
bool i2 = EdgeSphereIntersect( wp[2].xyz, wp[0].xyz, getCameraPosition().xyz, getFadeDistance() );
if( !i0 && !i1 && !i2 )
{
// now the final test: trace perpendicular from camera to triangle plane.
// The point of intersection must be inside the triangle and the distance to plane must be less or equal to sphere radius
//whole triangle
O.Basis[0] = float2(1,0);
O.Basis[1] = float2(0,1);
O.Basis[2] = float2(0,0);
//draw only first patch
O.fTessFactor[0] = O.fTessFactor[1] = O.fTessFactor[2] = O.fInsideTessFactor = (pid & FIRST_VIRTUAL_PATCH) ? 1 : 0;
return O;
}
}
//virtual dicing
float3 pos[3];
pos[0] = O.Basis[0].x * wp[0].xyz + O.Basis[0].y * wp[1].xyz + saturate(1-O.Basis[0].x-O.Basis[0].y) * wp[2].xyz;
pos[1] = O.Basis[1].x * wp[0].xyz + O.Basis[1].y * wp[1].xyz + saturate(1-O.Basis[1].x-O.Basis[1].y) * wp[2].xyz;
pos[2] = O.Basis[2].x * wp[0].xyz + O.Basis[2].y * wp[1].xyz + saturate(1-O.Basis[2].x-O.Basis[2].y) * wp[2].xyz;
//too far -> draw only first triangle without tessellation
dist3 = float3( length( getCameraPosition().xyz-pos[0].xyz ), length( getCameraPosition().xyz-pos[1].xyz ), length( getCameraPosition().xyz-pos[2].xyz ) );
dist = min( dist3.x, min( dist3.y, dist3.z ) );
if( dist > getFadeDistance() )
{
//Diced triangles are too small so simple test with distance to vertices should be ok
// camera is too far to corners. Chech edges of the triangle
bool i0 = EdgeSphereIntersect( pos[0].xyz, pos[1].xyz, getCameraPosition().xyz, getFadeDistance() );
bool i1 = EdgeSphereIntersect( pos[1].xyz, pos[2].xyz, getCameraPosition().xyz, getFadeDistance() );
bool i2 = EdgeSphereIntersect( pos[2].xyz, pos[0].xyz, getCameraPosition().xyz, getFadeDistance() );
if( !i0 && !i1 && !i2 )
{
O.fTessFactor[0] = O.fTessFactor[1] = O.fTessFactor[2] = O.fInsideTessFactor = 1;
return O;
}
}
O.fTessFactor[0] = g_BarycentricsBuffer[ uPID * 3 + 0 ].z;
O.fTessFactor[1] = g_BarycentricsBuffer[ uPID * 3 + 1 ].z;
O.fTessFactor[2] = g_BarycentricsBuffer[ uPID * 3 + 2 ].z;
//O.fInsideTessFactor = min(O.fTessFactor[0], min(O.fTessFactor[1], O.fTessFactor[2]) );
O.fInsideTessFactor = (O.fTessFactor[0] + O.fTessFactor[1] + O.fTessFactor[2] )/3;
//O.fInsideTessFactor = (min(O.fTessFactor[0], min(O.fTessFactor[1], O.fTessFactor[2]) ) + (O.fTessFactor[0] + O.fTessFactor[1] + O.fTessFactor[2] )/3)/2;
// Adaptively turn tessellation off for triangles that are flat enough
float3 uvt[3];
uvt[0] = float3( O.Basis[0].xy, 1.0 - O.Basis[0].x - O.Basis[0].y);
uvt[1] = float3( O.Basis[1].xy, 1.0 - O.Basis[1].x - O.Basis[1].y);
uvt[2] = float3( O.Basis[2].xy, 1.0 - O.Basis[2].x - O.Basis[2].y);
//UV for displacement map
float2 triangleUVs[3];
triangleUVs[0] = uvt[0].x * I[0].HeightMapUV + uvt[0].y * I[1].HeightMapUV + uvt[0].z * I[2].HeightMapUV;
triangleUVs[1] = uvt[1].x * I[0].HeightMapUV + uvt[1].y * I[1].HeightMapUV + uvt[1].z * I[2].HeightMapUV;
triangleUVs[2] = uvt[2].x * I[0].HeightMapUV + uvt[2].y * I[1].HeightMapUV + uvt[2].z * I[2].HeightMapUV;
// Check displacement difference texture to determine if we need to subdivide
// the patch or not
float2 minUV;
float2 maxUV;
minUV.x = min( triangleUVs[0].x, min( triangleUVs[1].x, triangleUVs[2].x ));
minUV.y = min( triangleUVs[0].y, min( triangleUVs[1].y, triangleUVs[2].y ));
maxUV.x = max( triangleUVs[0].x, max( triangleUVs[1].x, triangleUVs[2].x ));
maxUV.y = max( triangleUVs[0].y, max( triangleUVs[1].y, triangleUVs[2].y ));
uint theightWidth, theightHeight;
theight_HS.GetDimensions( theightWidth, theightHeight );
float2 sizeInTexels = (maxUV - minUV) * float2( theightWidth, theightHeight );
int mipLevel = log2( max( sizeInTexels.x, sizeInTexels.y )) + 1;
float averageDisp = theight_HS.SampleLevel( sheight_HS, (minUV + maxUV) * 0.5f, mipLevel ).a;
float2 minMaxDisp = float2( 1.0f, 0.0f );
float dispersion = 0;
for( int x = 0; x < 8; x ++ )
for( int y = 0; y < 8; y ++ )
{
float disp = theight_HS.SampleLevel( sheight_HS, minUV + (maxUV - minUV) * float2( x / 7.0f, y / 7.0f ), mipLevel - 4 ).a;
if( minMaxDisp.x > disp )
minMaxDisp.x = disp;
if( minMaxDisp.y < disp )
minMaxDisp.y = disp;
//dispersion += (disp - averageDisp) * (disp - averageDisp);
dispersion += abs( disp - averageDisp );
}
//dispersion;
float dispDifference = abs( minMaxDisp.x - minMaxDisp.y );
//float g_AdaptiveThreshold = 0.01f;
float g_AdaptiveThreshold = 0.005f;
float g_DispersionThreshold = 0.1f;
//if( dispDifference < 0.1f )
if( dispDifference * getDisplacementScale() < g_AdaptiveThreshold && dispersion * getDisplacementScale() < g_DispersionThreshold )
O.fInsideTessFactor /= 4.0f;
return O;
}
[domain("tri")]
[partitioning("integer")]
[outputtopology("triangle_cw")]
[patchconstantfunc("HS_Constant")]
[outputcontrolpoints(3)]
VS_OUTPUT mainHS( InputPatch<VS_OUTPUT, 3> I, uint uCPID : SV_OutputControlPointID)
{
return I[uCPID];
}
//-------------------------------------------------------------
//DS
float3 DecodeNormal(float2 xy, bool bZNegative)
{
float3 vNormal;
vNormal.xy = xy;
float fDot = dot(xy, xy);
vNormal.z = sqrt(1 - fDot);
if (fDot > 0.9999999)
vNormal.z = 0;
if (bZNegative)
vNormal.z = -vNormal.z;
return vNormal;
}
//SamplerState sheight : register(s1);
SamplerState sheight : register(s0);
/*{
Filter = MIN_MAG_MIP_LINEAR;
AddressU = Wrap;
AddressV = Wrap;
};*/
Texture2D theight : register(t3);
Buffer<float4> NormalsBuf : register(t4); //number of initial trialges * 3 * 3(?) normal is packed into 6 bytes + direction flags in TrgLinks
Buffer<float2> TexCoordsBuf : register(t5); //9 UVs per initial triangle
//Buffer<float3> g_Position : register( t6 ); //number of diced triangles * 3
[domain("tri")]
PS_INPUT mainDS( HS_ConstantOutput HSConstantData, const OutputPatch<VS_OUTPUT, 3> I, float3 uvt1 : SV_DomainLocation, uint uPID : SV_PrimitiveID )
{
//transform basis - compute new baricentrics based on virtual dicing
float2 outputLocation2 = HSConstantData.Basis[0] * uvt1.x + HSConstantData.Basis[1] * uvt1.y + HSConstantData.Basis[2] * uvt1.z;
float3 uvt = float3( outputLocation2.xy, 1.0 - outputLocation2.x - outputLocation2.y);
PS_INPUT Output = (PS_INPUT)0;
//UV for displacement map
//Output.Position.xy = uvt.x * I[0].Position.xy + uvt.y * I[1].Position.xy + uvt.z * I[2].Position.xy;
Output.HeightMapUV = uvt.x * I[0].HeightMapUV + uvt.y * I[1].HeightMapUV + uvt.z * I[2].HeightMapUV;
uint uTriangle = HSConstantData.uPrimID;
uint uTrgLink = HSConstantData.uTrgLink;
bool disp = true;
float fInterp = -1;
uint uEdge = 3;
if (uvt.x == 0)
{
uEdge = 1;
fInterp = uvt.y;
if(uTrgLink & VWEDGE_MASK) disp = false;
}
if (uvt.y == 0)
{
uEdge = 2;
fInterp = uvt.z;
if(uTrgLink & WUEDGE_MASK) disp = false;
}
if (uvt.z == 0)
{
uEdge = 0;
fInterp = uvt.x;
if(uTrgLink & UVEDGE_MASK) disp = false;
}
// interpolate smooth texcoord
uint iUV0 = 0;
uint iUV1 = 0;
if (fInterp == 0) // corner
{
iUV0 = iUV1 = (uEdge == 2) ? 0 : uEdge + 1;
}
else if (fInterp == 1) // another corner
{
iUV0 = iUV1 = uEdge;
}
else
{
// edge
iUV0 = 3 + uEdge * 2;
iUV1 = iUV0 + 1;
}
float2 vUV0 = TexCoordsBuf.Load((uTrgLink & TRGLINK_MASK) + iUV0);
float2 vUV1 = TexCoordsBuf.Load((uTrgLink & TRGLINK_MASK) + iUV1);
float2 vUV = vUV0 * fInterp + vUV1 * (1 - fInterp);
//inside triangle use normal mapping
if(fInterp==-1) vUV = Output.HeightMapUV.%s;
uint3 texinfo;
theight.GetDimensions(0, texinfo.x, texinfo.y, texinfo.z );
uint min_dimension = min( texinfo.x, texinfo.y );
uint lod_level = log(min_dimension);
float avg = theight.SampleLevel(sheight, vUV, lod_level).%s;
if( texinfo.z <= lod_level ) //do not measure "gray level" for texture without 1x1 mip
avg = 0;
float h = theight.SampleLevel( sheight, vUV, 0).%s;
%sh -= avg;
if(!disp) h=0;
if( iUV0 == iUV1 && (uTrgLink & (OPENED_U_VERTEX << iUV0)) ) h=0;
//float k = 0.1f;
//if(uTrgLink & UVEDGE_MASK) h *= saturate( uvt.y / k );
//h *= saturate( uvt.z / k );
//if(uTrgLink & VWEDGE_MASK) h *= saturate( uvt.y / k );
//if(uTrgLink & WUEDGE_MASK) h *= saturate( uvt.z / k );
// interpolate smooth normal
float4 vTmp = NormalsBuf.Load(uTriangle * 3);
float3 vNormal0 = DecodeNormal( vTmp.xy, (uTrgLink & UNORMAL_ZNEGATIVE_MASK) == UNORMAL_ZNEGATIVE_MASK);
float3 vNormal1 = DecodeNormal( vTmp.zw, (uTrgLink & VNORMAL_ZNEGATIVE_MASK) == VNORMAL_ZNEGATIVE_MASK);
float3 vNormal2 = DecodeNormal( NormalsBuf.Load(uTriangle * 3 + 1).xy, (uTrgLink & WNORMAL_ZNEGATIVE_MASK) == WNORMAL_ZNEGATIVE_MASK);
float3 norm = vNormal0 * uvt.x + vNormal1 * uvt.y + vNormal2 * uvt.z;
//Position unproject - interpolate - displace - project
float4x4 ip = _getInverseProjection();
float4 wp[3];
wp[0] = mul(I[0].Position, ip); wp[0].xyz /= wp[0].w;
wp[1] = mul(I[1].Position, ip); wp[1].xyz /= wp[1].w;
wp[2] = mul(I[2].Position, ip); wp[2].xyz /= wp[2].w;
//wp[0].xyz = g_Position.Load( uPID * 3 + 0 ).xyz;
//wp[1].xyz = g_Position.Load( uPID * 3 + 1 ).xyz;
//wp[2].xyz = g_Position.Load( uPID * 3 + 2 ).xyz;
float4 Position = uvt.x*wp[0] + uvt.y*wp[1] + uvt.z*wp[2];
//smoothly fade-out displacement
h *= saturate( 1 - (length( getCameraPosition().xyz-Position.xyz ) - getMinDistance())/(getFadeDistance() - getMinDistance()) );
Position.xyz += norm * getDisplacementScale() * h;
Position.w = 1;
Output.Position = mul( Position, getProjection() );
//Output.Position = uvt.x * I[0].Position + uvt.y * I[1].Position + uvt.z * I[2].Position;
//float hei1 = 11110.0f;
//float hei = Output_Position.y+11.7f;
%s
//%sOutput.Attribute%d.%s = mul( float4( Position.xyz, 1), getBypassPosition() );
//%sOutput.Attribute%d = dot( mul( float4( Position.xyz, 1), getBypassPosition() ), getClipDistance() );//
return Output;