using System.Reflection;
using UnityEngine;

/*namespace UnityEditor.ShaderGraph
{
    [Title("OLD", "ParallaxOcclusionMapping")]
    public class ParallaxOcclusionMappingNode : CodeFunctionNode
    {
        protected override MethodInfo GetFunctionToConvert()
        {
            return GetType().GetMethod("Unity_POM", BindingFlags.Static | BindingFlags.NonPublic);
        }

        static string Unity_POM(
            [Slot(1, Binding.None)] Texture2D tex,
            [Slot(2, Binding.None)] Vector1 heightScale,
            [Slot(3, Binding.MeshUV0)] Vector2 UVs,
            [Slot(4, Binding.TangentSpaceViewDirection)] Vector3 viewTangentSpace,
            [Slot(5, Binding.WorldSpaceNormal)] Vector3 worldSpaceNormal,
            [Slot(6, Binding.WorldSpaceViewDirection)] Vector3 worldSpaceViewDirection,
            [Slot(7, Binding.None)] out Vector2 result)
        {
            result = Vector2.zero;

            return
                @"
{
    float2 height_map_dimensions = float2(256.0f, 256.0f);      //HARDCODE
    //height_map.tex.GetDimensions(height_map_dimensions.x, height_map_dimensions.y);

    float2 texcoord= UVs;

    // Compute the current gradients:
    float2 texcoords_per_size = texcoord * height_map_dimensions;

    // Compute all 4 derivatives in x and y in a single instruction to optimize:
    float2 dx, dy;
    float4 temp_ddx = ddx(float4(texcoords_per_size, texcoord));
    dx.xy = temp_ddx.zw;
    float4 temp_ddy = ddy(float4(texcoords_per_size, texcoord));
    dy.xy = temp_ddy.zw;

    // Start the current sample located at the input texture coordinate, which would correspond
    // to computing a bump mapping result:
    float2 result_texcoord = texcoord;

    float height_scale_value = heightScale;
    float height_scale_adjust = height_scale_value;

    float per_pixel_height_scale_value = height_scale_value * heightScale;

    // 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:
    float max_samples = 30.0f;
    float min_samples = 4.0f;

    float view_dot_normal= dot(worldSpaceNormal, worldSpaceViewDirection);

    int number_of_steps = (int)lerp(max_samples, min_samples, saturate(view_dot_normal));

    // 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 SI3D 06 paper for more details about the process and derivation.
    //

    float current_height = 0.0;
    float step_size = 1.0 / (float)number_of_steps;

    float previous_height = 1.0;
    float next_height = 0.0;


    int step_index = 0;

    // Optimization: this should move to vertex shader, however, we compute it here for simplicity of
    // integration into our shaders for now.
    float3 normalized_view_dir_in_tangent_space = normalize(viewTangentSpace.xyz);

    // Compute initial parallax displacement direction:
    float2 parallax_direction = normalize(viewTangentSpace.xy);

    // The length of this vector determines the furthest amount of displacement:
    float parallax_direction_length = length(normalized_view_dir_in_tangent_space);


    float max_parallax_amount = sqrt(parallax_direction_length * parallax_direction_length - viewTangentSpace.z * viewTangentSpace.z) / viewTangentSpace.z;

    // Compute the actual reverse parallax displacement vector:
    float2 parallax_offset_in_tangent_space = parallax_direction * max_parallax_amount;

    // Need to scale the amount of displacement to account for different height ranges
    // in height maps. This is controlled by an artist-editable parameter:
    parallax_offset_in_tangent_space *= saturate(heightScale);
    float2 texcoord_offset_per_step = step_size * parallax_offset_in_tangent_space;

    float2 current_texcoord_offset = texcoord;
    float current_bound = 1.0;
    float current_parallax_amount = 0.0;

    float2 pt1 = 0;
    float2 pt2 = 0;


    float2 temp_texcoord_offset = 0;

    while (step_index < number_of_steps)
    {
        current_texcoord_offset -= texcoord_offset_per_step;

        // Sample height map which in this case is stored in the alpha channel of the normal map:
        current_height = tex2Dgrad(tex, current_texcoord_offset, dx, dy).r;

        current_bound -= step_size;

        if (current_height > current_bound)
        {
            pt1 = float2(current_bound, current_height);
            pt2 = float2(current_bound + step_size, previous_height);
            temp_texcoord_offset = current_texcoord_offset - texcoord_offset_per_step;
            step_index = number_of_steps + 1;
        }
        else
        {
            step_index++;
            previous_height = current_height;
        }
     }   // End of while ( step_index < number_of_steps)


    float delta2 = pt2.x - pt2.y;
    float delta1 = pt1.x - pt1.y;

    float denominator = delta2 - delta1;

    // SM 3.0 and above requires a check for divide by zero since that operation
    // will generate an 'Inf' number instead of 0
    if (denominator== 0.0f)
    {
        current_parallax_amount= 0.0f;
    }
    else
    {
        current_parallax_amount= (pt1.x* delta2 - pt2.x* delta1) / denominator;
    }

    float2 parallax_offset = parallax_offset_in_tangent_space * (1.0f - current_parallax_amount);

    // The computed texture offset for the displaced point on the pseudo-extruded surface:
    float2 parallaxed_texcoord = texcoord - parallax_offset;

    result = parallaxed_texcoord;
}
";
        }
    }
}*/