Changing a Parabola's direction

[jister]

Hello Math wizards, I’m stuck trying to let my parabola follow the direction of my mouse drag.
I’m using the locus of a parabola method, with the focus point and directrix.
I works fine on the z axis but i have no clue how to add in the variable direction of the directrix and focal line…

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[RequireComponent(typeof(LineRenderer))]
public class Parabola : MonoBehaviour {

    public GameObject pointD, pointF, pointM;
    public LineRenderer line;

    public Vector3 mouse=Vector3.one, prev;
    public Vector3 directrix;
    public Vector3 focusPoint, directrixPointMid, directrixPointL, directrixPointR;
    public float directrixLength;
    public int resolution;
    public Vector3 focalLine;
    public float focalLenght;
    public Vector3 p;
    public List<Vector3> points = new List<Vector3>();

    void Start ()
    {
        prev = mouse;
        line = GetComponent<LineRenderer>();
        line.positionCount = resolution;
    }
   
    void Update ()
    {
        if(Input.GetMouseButton(0))
        {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;
            if(Physics.Raycast(ray, out hit, Mathf.Infinity, 1<<LayerMask.NameToLayer("Plane")))
            {
                mouse = new Vector3(hit.point.x,0,hit.point.z);
                if(prev != mouse)
                {
                    focalLine = prev - mouse;
                    focusPoint = mouse + focalLine.normalized * focalLenght;
                    directrixPointMid = mouse +(-focalLine.normalized  * focalLenght);
                    directrix = Vector3.Cross(directrixPointMid-focusPoint, Vector3.up);
                    directrixPointL = directrixPointMid +(directrix.normalized * (directrixLength/2));
                    directrixPointR = directrixPointMid +(-directrix.normalized * (directrixLength/2));

                    Debug.DrawRay(mouse, focalLine.normalized*10,Color.green);
                    Debug.DrawRay(directrixPointR, directrix.normalized*directrixLength,Color.red);

                    pointD.transform.position = directrixPointMid;
                    pointF.transform.position = focusPoint;
                    pointM.transform.position = mouse;
                    prev = mouse;
                }
            }
            points = new List<Vector3>();
            for(float i = -directrixLength/2; i<=directrixLength/2; i+=directrixLength/resolution)
            {
                //float angle = Vector3.Angle(focalLine, Vector3.forward);

                float z = 1/(2*(focusPoint.z-directrixPointMid.z))*Mathf.Pow((Mathf.Abs(directrixPointMid.x)+i)-focusPoint.x,2)+0.5f*(focusPoint.z+directrixPointMid.z);
                float x = Mathf.Abs(directrixPointMid.x)+i;
                p = new Vector3(x,1,z);

                //p = new Vector3(x*Mathf.Cos(angle)-z*Mathf.Sin(angle),1,x*Mathf.Sin(angle) + z*Mathf.Cos(angle));
                //p.z = 2*p.x + Mathf.Sin(p.x);
                //p = new Vector3(p.x*Mathf.Cos(angle)-p.z*Mathf.Sin(angle),1,p.x*Mathf.Sin(angle) + p.z*Mathf.Cos(angle));

                points.Add(p);
            }
            line.SetPositions(points.ToArray());

        }
    }
}

as you can see i tried different solutions i found on the net, but none working…

[jister]

here’s a small vid of what i got now
https://drive.google.com/file/d/0BzsZ4o9QXFtlX2xqeEg4Y1J1UXc/view?usp=sharing

[jister]

ok this works as a base. now how to get the coordinates in my shader?
In the code they are all local now, i guess verts coordinates are local to the objects transform?
so how would i get my vectors local to the object I am dragging to get recognised in my water shader?

code:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Parabola : MonoBehaviour {

    public GameObject linePrefab, pointV;

    public float offset, amp, speed;
    public int freq;
    public float directrixLength;
    public int resolution;

    private Vector3 mouse, prev;
    private Vector3 focalLine;
    private Vector3 p;
    private List<List<Vector3>> pointsR = new List<List<Vector3>>();
    private List<LineRenderer> lines = new List<LineRenderer>();
    public Renderer render;

    void Start ()
    {
        render.material.SetInt("_Length", resolution);
        render.material.SetVectorArray("_Points", new Vector4[resolution]);

        prev = mouse;
        int i = 0;
        while(i <= freq)
        {
            GameObject g = Instantiate(linePrefab);
            g.transform.SetParent(transform);
            g.transform.localPosition = Vector3.zero;
            LineRenderer line = g.GetComponent<LineRenderer>();
            line.positionCount = resolution;
            lines.Add(line);
            List<Vector3> lR = new List<Vector3>();
            pointsR.Add(lR);
            i++;
        }
    }
 
    void FixedUpdate ()
    {
        if(Input.GetMouseButton(0))
        {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;
            if(Physics.Raycast(ray, out hit, Mathf.Infinity, 1<<LayerMask.NameToLayer("Plane")))
            {
                mouse = new Vector3(hit.point.x,0,hit.point.z);
                StopCoroutine(CalculateParabola(mouse));
                StartCoroutine(CalculateParabola(mouse));
                transform.position = mouse;
                transform.forward = -focalLine;
            }
        }
    }
    IEnumerator CalculateParabola(Vector3 v)
    {
        while(prev != v)
        {
            focalLine = prev - v;

            for(int h=0; h<=freq; h++)
            {
                pointsR[h] = new List<Vector3>();
                float s = Vector3.Distance(prev.normalized,v.normalized)*speed;
                for(float i = -directrixLength/2; i<=(directrixLength+1)/2; i+=directrixLength/resolution)
                {
                    p.x = pointV.transform.localPosition.x+(i*(freq-h+Time.fixedDeltaTime*s));
                    p.z = ((amp*(freq-h))*(Time.fixedDeltaTime*s))*-Mathf.Pow(p.x,2)+(1+offset*h);
                    pointsR[h].Add(p);
                }
                lines[h].SetPositions(pointsR[h].ToArray());
                Vector4[] renderPoints = new Vector4[resolution];
                for(int i=0; i<resolution; i++)
                {
                    renderPoints[i] = pointsR[h][i];
                    render.material.SetVectorArray("_Points", renderPoints);
                }
            }
            yield return new WaitForSeconds(0.1f);
            prev = v;
        }
    }
}

my attempt of getting them into my shader

Vector4[] renderPoints = new Vector4[resolution];
                for(int i=0; i<resolution; i++)
                {
                    renderPoints = pointsR[h]; 
                }
    render.material.SetVectorArray("_Points", renderPoints);

and this is my shader for now:
```csharp
*Shader “Custom/Parabola” {
Properties {
_Color (“Color”, Color) = (1,1,1,1)
_MainTex (“Albedo (RGB)”, 2D) = “white” {}
_Glossiness (“Smoothness”, Range(0,1)) = 0.5
_Metallic (“Metallic”, Range(0,1)) = 0.0
_Size (“Size”, float) = 1
_Speed (“Speed”, float) = 1
_Amp (“Amplitude”, float) = 1
//_Points(“Points”, vector)
}
SubShader {
Tags { “RenderType”=“Opaque” }
LOD 200

    CGPROGRAM

// Upgrade NOTE: excluded shader from DX11, OpenGL ES 2.0 because it uses unsized arrays
#pragma exclude_renderers d3d11 gles
// Physically based Standard lighting model, and enable shadows on all light types
#pragma surface surf Standard fullforwardshadows vertex:vert

    // Use shader model 3.0 target, to get nicer looking lighting
    #pragma target 3.0

    sampler2D _MainTex;

    struct Input {
        float2 uv_MainTex;
    };

    half _Glossiness;
    half _Metallic;
    half _Size;
    half _Speed;
    half _Amp;
    fixed4 _Color;
    const int _Length = 100;
    uniform float4 _Points[_Length];

    // Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
    // See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
    // #pragma instancing_options assumeuniformscaling
    UNITY_INSTANCING_CBUFFER_START(Props)
        // put more per-instance properties here
    UNITY_INSTANCING_CBUFFER_END

    void vert(inout appdata_full v)
    {
        for(int i=0; i<_Length; i++)
        {
            if(v.vertex.z <= (_Points[i].z+_Size)*_Time.y*_Speed && v.vertex.z >= (_Points[i].z-_Size)*_Time.y*_Speed)
            {
                v.vertex.y += log10(sin(v.vertex.y)+_Amp);
                v.normal.xyz += log10(sin(v.vertex.y)+_Amp);
            }
        }
    }
    void surf (Input IN, inout SurfaceOutputStandard o)
    {
        // Albedo comes from a texture tinted by color
        fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
        o.Albedo = c.rgb;
        // Metallic and smoothness come from slider variables
        o.Metallic = _Metallic;
        o.Smoothness = _Glossiness;
        o.Alpha = c.a;
    }
    ENDCG
}
FallBack "Diffuse"

}
_```*_