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

/// <summary>
/// 胶带端部展示类型
/// </summary>
public enum JDLineType
{
    lineoff = 1,    //无端部胶带，无胶带卷
    lineon_JDJuan,  //端部胶带，胶带卷
    lineon_NoJDJuan  //端部胶带，无胶带卷
}
/// <summary>
/// 胶带材质球控制器
/// </summary>
public class ChivaVR_JD_ShaderController : MonoBehaviour
{
    public Material jd_Mat;

    [SerializeField]
    private JDLineType jdLineType = JDLineType.lineon_JDJuan;

    #region Parameter
    public float radius;               //半径
    public float maxAngle;             //最大缠绕角度
    public float backAngle;            //伸出部分角度
    public float value;                //当前缠绕角度
    public bool setJDShaderParameter;  //Editor是否开启参数设置
    public float moveOffset;           //横向偏移量
    public float dampMoveOffsetAngle;  //不参与偏移的初始角度范围
    public float upOffset;             //纵向偏移量
    public bool hiddenLine;            //是否隐藏连接线
    public bool hiddenJDJuan;            //是否隐藏胶带卷
    public float lineShowLength;       //连接线长度
    //胶带缠绕部分贴图及法线贴图Tilling
    public Vector2 jd_TexAndNormailMap_Tiling;
    //胶带缠绕部分贴图及法线贴图Offset
    public Vector2 jd_TexAndNormailMap_Offset;
    #endregion

    #region Editor Inspector Set Parameter
    /// <summary>
    /// Inspector面板设置JDShader信息
    /// </summary>
    public void InspectorResetJDShaderInfo()
    {
        if (jd_Mat == null)
        {
            jd_Mat = this.GetComponent<MeshRenderer>().material;
        }
        SetJDValue(jd_Mat, value);
        SetJDDirectionAngle(jd_Mat, backAngle);

        ResetJDLineType();

        if (!setJDShaderParameter) return;

        jd_Mat.SetFloat("_MaxAngle", maxAngle);
        jd_Mat.SetFloat("_MoveOffset", moveOffset);
        jd_Mat.SetFloat("_DampOffsetAngle", dampMoveOffsetAngle);
        jd_Mat.SetFloat("_UpOffset", upOffset);
        jd_Mat.SetFloat("_Radius", radius);
        jd_Mat.SetFloat("_LineShowLength", lineShowLength);
        jd_Mat.SetTextureScale("_MainTex", jd_TexAndNormailMap_Tiling);
        jd_Mat.SetTextureOffset("_MainTex", jd_TexAndNormailMap_Offset);
        jd_Mat.SetTextureScale("_BumpMap", jd_TexAndNormailMap_Tiling);
        jd_Mat.SetTextureOffset("_BumpMap", jd_TexAndNormailMap_Offset);
    }

    public void ReSetJDMat()
    {
        jd_Mat = this.GetComponent<MeshRenderer>().sharedMaterial;
        InspectorUpdateJDShaderInfo();
    }

    /// <summary>
    /// Inspector面板更新当前胶带材质Shader信息
    /// </summary>
    public void InspectorUpdateJDShaderInfo()
    {
        jd_Mat = this.GetComponent<MeshRenderer>().sharedMaterial;

        value = jd_Mat.GetFloat("_Value");
        backAngle = jd_Mat.GetFloat("_BackAngle");
        if (jd_Mat.GetFloat("_HiddenLine") == 0)
        {
            hiddenLine = false;
        }
        else if (jd_Mat.GetFloat("_HiddenLine") == 1)
        {
            hiddenLine = true;
        }
        if (jd_Mat.GetFloat("_HiddenJDJuan") == 0)
        {
            hiddenJDJuan = false;
        }
        else if (jd_Mat.GetFloat("_HiddenJDJuan") == 1)
        {
            hiddenJDJuan = true;
        }

        if (hiddenLine)
        {
            jdLineType = JDLineType.lineoff;
        }
        else if (hiddenJDJuan)
        {
            jdLineType = JDLineType.lineon_NoJDJuan;
        }
        else if (!hiddenJDJuan)
        {
            jdLineType = JDLineType.lineon_JDJuan;
            ;
        }

        maxAngle = jd_Mat.GetFloat("_MaxAngle");
        moveOffset = jd_Mat.GetFloat("_MoveOffset");
        dampMoveOffsetAngle = jd_Mat.GetFloat("_DampOffsetAngle");
        upOffset = jd_Mat.GetFloat("_UpOffset");
        radius = jd_Mat.GetFloat("_Radius");
        lineShowLength = jd_Mat.GetFloat("_LineShowLength");
        jd_TexAndNormailMap_Tiling = jd_Mat.GetTextureScale("_MainTex");
        jd_TexAndNormailMap_Offset = jd_Mat.GetTextureOffset("_MainTex");
        jd_TexAndNormailMap_Tiling = jd_Mat.GetTextureScale("_BumpMap");
        jd_TexAndNormailMap_Offset = jd_Mat.GetTextureOffset("_BumpMap");
    }

    public void ResetJDLineType()
    {
        switch (jdLineType)
        {
            case JDLineType.lineoff:
                SetJDHiddenLine(jd_Mat, true);
                jd_Mat.SetFloat("_HiddenLine", 1);
                break;
            case JDLineType.lineon_JDJuan:
                SetJDHiddenLine(jd_Mat, false);
                SetJDHiddenJDJuan(jd_Mat, false);

                jd_Mat.SetFloat("_HiddenLine", 0);
                jd_Mat.SetFloat("_HiddenJDJuan", 0);
                break;
            case JDLineType.lineon_NoJDJuan:
                SetJDHiddenLine(jd_Mat, false);
                SetJDHiddenJDJuan(jd_Mat, true);
                jd_Mat.SetFloat("_HiddenLine", 0);
                jd_Mat.SetFloat("_HiddenJDJuan", 1);
                break;
            default:
                break;
        }
    }

    /// <summary>
    /// 设置胶带Value
    /// </summary>
    /// <param name="_value"></param>
    protected void SetJDValue(Material mat, float _value)
    {
        value = Mathf.Clamp(_value, 0, maxAngle);

        mat.SetFloat("_Value", value);
    }

    /// <summary>
    /// 设置胶反向角度
    /// </summary>
    /// <param name="_value"></param>
    protected void SetJDDirectionAngle(Material mat, float _value)
    {
        backAngle = Mathf.Clamp(_value, 0, 180);

        mat.SetFloat("_BackAngle", backAngle);
    }

    /// <summary>
    /// 设置偏移量
    /// </summary>
    /// <param name="mat"></param>
    /// <param name="offset"></param>
    public void SetMoveOffset(Material mat, float offset)
    {
        moveOffset = offset;
        mat.SetFloat("_MoveOffset", moveOffset);
    }

    /// <summary>
    /// 设置不参与偏移的初始角度范围
    /// </summary>
    /// <param name="mat"></param>
    /// <param name="_value"></param>
    protected void SetDampOffsetAngle(Material mat, float _value)
    {
        dampMoveOffsetAngle = _value;
        mat.SetFloat("_DampOffsetAngle", dampMoveOffsetAngle);
    }

    /// <summary>
    /// 设置胶带伸出部分状态
    /// </summary>
    /// <param name="state"></param>
    protected void SetJDHiddenLine(Material mat, bool state)
    {
        hiddenLine = state;
        if (hiddenLine)
        {
            mat.EnableKeyword("_HIDDENLINE_ON");
        }
        else
        {
            mat.DisableKeyword("_HIDDENLINE_ON");
        }
    }

    /// <summary>
    /// 设置胶带伸出部分状态
    /// </summary>
    /// <param name="state"></param>
    protected void SetJDHiddenJDJuan(Material mat, bool state)
    {
        hiddenJDJuan = state;
        if (hiddenJDJuan)
        {
            mat.EnableKeyword("_HIDDENJDJUAN_ON");
        }
        else
        {
            mat.DisableKeyword("_HIDDENJDJUAN_ON");
        }
    }
    #endregion

    void Awake()
    {
        jd_Mat = this.GetComponent<MeshRenderer>().material;
    }

    /// <summary>
    /// 设置胶带Value
    /// </summary>
    /// <param name="_value">缠绕角度</param>
    public void SetJDValue(float _value)
    {
        SetJDValue(jd_Mat, _value);
    }

    /// <summary>
    /// 设置胶带Normail
    /// </summary>
    /// <param name="_normail">0-1胶带缠绕normail</param>
    public void SetJDNormail(float _normail)
    {
        SetJDValue(jd_Mat, _normail * maxAngle);
    }

    /// <summary>
    /// 设置胶带卷正朝向夹角角度
    /// </summary>
    /// <param name="_value">0-1胶带卷朝向夹角normail</param>
    public void SetJDDirectionAngle(float _value)
    {
        SetJDDirectionAngle(jd_Mat, _value);
    }

    /// <summary>
    /// 隐藏连接线
    /// </summary>
    /// <param name="state"></param>
    public void SetJDHiddenLine(bool state)
    {
        SetJDHiddenLine(jd_Mat, state);
    }

    /// <summary>
    /// 设置胶带端部展示类型
    /// </summary>
    /// <param name="type"></param>
    public void SetJDLineType(JDLineType type)
    {
        jdLineType = type;
        ResetJDLineType();
    }

    /// <summary>
    ///  设置胶带水平偏移量
    /// </summary>
    /// <param name="offset"></param>
    public void SetMoveOffset(float offset)
    {
        SetMoveOffset(jd_Mat, offset);
    }
}