// Fractional value for sample position in the cloud layer .
float GetHeightFractionForPoint ( float3 inPosition , float2 inCloudMinMax )
{
    // Get global fractional position in cloud zone .
    float height_fraction = (inPosition.z ? inCloudMinMax.x ) / ( inCloudMinMax.y ? inCloudMinMax.x ) ;
    return saturate ( height_fraction ) ;
}

// Utility function that maps a value from one range to another .
float Remap ( float original_value , float original_min , float original_max , float new_min , float new_max )
{
    return new_min + ( ( ( original_value ? original_min) / ( original_max ? original_min ) ) ? ( new_max ? new_min ) );
}

float SampleCloudDensity ( float3 p , float3 weather_data )
{
    // Read the low?frequency Perlin?Worley and Worley noises.
    float4 low_frequency_noises = tex3Dlod ( Cloud3DNoiseTextureA , Cloud3DNoiseSamplerA , float4 ( p , mip_level) ).rgba;

    // Build an FBM out of the low frequency Worley noises
    // that can be used to add detail to the low?frequency
    // Perlin?Worley noise.
    float low_freq_FBM = ( low_frequency_noises.g ? 0.625 )
    + ( low_frequency_noises.b ? 0.25 )
    + ( low_frequency_noises.a ? 0.125 );

    // define the base cloud shape by dilating it with the
    // low?frequency FBM made of Worley noise.
    float base_cloud = Remap ( low_frequency_noises.r , ?( 1.0 ? low_freq_FBM ) , 1 .0 , 0 .0 , 1 .0 );

    // Get the density?height gradient using the density height
    // function explained in Section 4.3.2.
    float density_height_gradient = GetDensityHeightGradientForPoint ( p , weather_data );
    
    // Apply the height function to the base cloud shape.
    base_cloud ?= density_height_gradient ;

    // Cloud coverage is stored in weather data’s red channel.
    float cloud_coverage = weather_data.r;
    
    // Use remap to apply the cloud coverage attribute.
    float base_cloud_with_coverage = Remap ( base_cloud , cloud_coverage, 1. 0 , 0. 0 , 1.0);

    // Multiply the result by the cloud coverage attribute so
    // that smaller clouds are lighter and more aesthetically
    // pleasing.
    base_cloud_with_coverage ?= cloud_coverage;


    // Add some turbulence to bottoms of clouds.
    p.xy += curl_noise.xy ? ( 1 . 0 ? height_fraction );

    // Sample high?frequency noises.
    float3 high_frequency_noises = tex3Dlod ( Cloud3DNoiseTextureB , Cloud3DNoiseSamplerB , float4 ( p ? 0.1 , mip_level) ).rgb;

    // Build?high frequency Worley noise FBM.
    float high_freq_FBM = ( high_frequency_noises.r ? 0.625 )
    + ( high_frequency_noises.g ? 0.25 )
    + ( high_frequency_noises.b ? 0.125 );

    // Get the height fraction for use with blending noise types
    // over height.
    float height_fraction = GetHeightFractionForPoint ( p , inCloudMinMax );

    // Transition from wispy shapes to billowy shapes over height.
    float high_freq_noise_modifier = mix ( high_freq_FBM ,
    1 .0 ? high_freq_FBM , saturate ( height_fraction ? 10.0 ) );

    // Erode the base cloud shape with the distorted
    // high?frequency Worley noises.
    float final_cloud = Remap ( base_cloud_with_coverage ,
    high_freq_noise_modifier ? 0.2 , 1.0 , 0.0 , 1.0 );


    return final_cloud;
}

//float base_cloud_with_coverage = Remap(base_cloud, cloud_coverage, 1.0, 0.0, 1.0);

//it seems the gpu pro7 use coverage to control the cloud's thinkness, more coverage,
more thick, so i use the below:
float base_cloud_with_coverage = Remap(base_cloud, saturate((height * scale) / cloud_coverage), 1.0, 0.0, 1.0);

d.the heightGradient

float4 cloudGradient1 = float4(0, 0.07, 0.08, 0.15);
float4 cloudGradient2 = float4(0, 0.2, 0.42, 0.6);
float4 cloudGradient3 = float4(0, 0.08, 0.75, 1);

float LerpGradient(float cloudType)
{
    float a = 1.0f - saturate(cloudType / 0.5f);
    float b = 1.0f - abs(cloudType - 0.5f) * 2.0f;
    float c = saturate(cloudType - 0.5f) * 2.0f;

    return cloudGradient1 * a + cloudGradient2 * b + cloudGradient3 * c;
}

float CalculateGradient(float a, float4 gradient)
{
    return smoothstep(gradient.x, gradient.y, a) - smoothstep(gradient.z, gradient.w, a);
}


heightGradient = CalculateGradient(height, LerpGradient(cloudType);