float3 ComputePatchMidPoint(float3 cp0, float3 cp1, float3 cp2, float3 cp3)
{
	return (cp0 + cp1 + cp2 + cp3) / 4.0f;
}

float ComputePatchLOD(float3 midPoint)
{
	return lerp(minLOD, maxLOD, (1.0f - (saturate(distance(cameraPosition, midPoint) / maxDistance))));
}

/*
Geometry is provided by the application in the following format:

     10   11
     |    |
     |    |
8----0----2----4
     |    |
     |    |
9----1----3----5
     |    |
     |    |
     6    7
	 
The quad 0-1-2-3 is the one actually being rendered (the Domain Shader gets UV's for this
region) but the other 8 are used for adjacency information.
*/

HS_PER_PATCH_OUTPUT hsPerPatch( InputPatch<VS_OUTPUT, 12> ip, uint PatchID : SV_PrimitiveID )
{	
    HS_PER_PATCH_OUTPUT o = (HS_PER_PATCH_OUTPUT)0;
    
    // Determine the mid-point of this patch
    float3 midPoints[] =
    {
		// Main quad
		ComputePatchMidPoint( ip[0].position, ip[1].position, ip[2].position, ip[3].position )
		
		// +x neighbour
		, ComputePatchMidPoint( ip[2].position, ip[3].position, ip[4].position, ip[5].position )
		
		// +z neighbour
		, ComputePatchMidPoint( ip[1].position, ip[3].position, ip[6].position, ip[7].position )
		
		// -x neighbour
		, ComputePatchMidPoint( ip[0].position, ip[1].position, ip[8].position, ip[9].position )
		
		// -z neighbour
		, ComputePatchMidPoint( ip[0].position, ip[2].position, ip[10].position, ip[11].position )
    };
        
    // Determine the appropriate LOD for this patch
    float dist[] = 
    {
		// Main quad
		ComputePatchLOD( midPoints[0] )
		
		// +x neighbour
		, ComputePatchLOD( midPoints[1] )
		
		// +z neighbour
		, ComputePatchLOD( midPoints[2] )
		
		// -x neighbour
		, ComputePatchLOD( midPoints[3] )
		
		// -z neighbour
		, ComputePatchLOD( midPoints[4] )
	};
    
    // Set it up so that this patch always has an interior matching
    // the patch LOD.
    o.insideTesselation[0] = 
        o.insideTesselation[1] = dist[0];
        
    // For the edges its more complex as we have to match
    // the neighbouring patches. The rule in this case is:
    //
    // - If the neighbour patch is of a lower LOD we
    //   pick that LOD as the edge for this patch.
    //
    // - If the neighbour patch is a higher LOD then 
    //   we stick with our LOD and expect them to blend down
    //   towards us
    
    o.edgeTesselation[0] = min( dist[0], dist[4] );    
    o.edgeTesselation[1] = min( dist[0], dist[3] );
    o.edgeTesselation[2] = min( dist[0], dist[2] );
    o.edgeTesselation[3] = min( dist[0], dist[1] );
	
    return o;
}