Convention-Unity-Demo/Assets/Scripts/MoreSpline/PointBaseRenderer/BasicSplineRenderer.cs

using Convention;
using Demo.Game.ConfigType;
using Dreamteck.Splines;
using System.Collections;
using System.IO;
using Unity.Collections;
using UnityEngine;
using UnityEngine.Rendering;

namespace Demo.Game
{
    namespace ConfigType
    {
        public class BasicSplineRendererConfig : UpdatementConfig<SplineClipDuration>
        {
            public int MySplineCore;
            public string LinesAssetBundlePath;
            public string MyDefaultMaterial;

            public override void Deserialize(BinaryReader reader)
            {
                MySplineCore = BinarySerializeUtility.ReadInt(reader);
                LinesAssetBundlePath = BinarySerializeUtility.ReadString(reader);
                MyDefaultMaterial = BinarySerializeUtility.ReadString(reader);
                base.Deserialize(reader);
            }

            public override void Serialize(BinaryWriter writer)
            {
                BinarySerializeUtility.WriteInt(writer, MySplineCore);
                BinarySerializeUtility.WriteString(writer, LinesAssetBundlePath);
                BinarySerializeUtility.WriteString(writer, MyDefaultMaterial);
                base.Serialize(writer);
            }

            protected override void DeserializePositions(BinaryReader reader, ref NativeArray<SplineClipDuration> positions)
            {
                NativeArray<Vector2> temp = new(0, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
                int e = BinarySerializeUtility.DeserializeNativeArray(reader, ref temp);
                positions.ResizeArray(e);
                for (int i = 0; i < e; i++)
                {
                    positions[i] = new(temp[i].x, temp[i].y);
                }
                temp.Dispose();
            }

            protected override void SerializePositions(BinaryWriter writer, in NativeArray<SplineClipDuration> positions)
            {
                NativeArray<Vector2> temp = new(positions.Length, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
                for (int i = 0, e=positions.Length; i < e; i++)
                {
                    temp[i] = new(positions[i].ClipFrom, positions[i].ClipTo);
                }
                BinarySerializeUtility.SerializeNativeArray(writer, temp);
                temp.Dispose();
            }
        }
    }

    public abstract class BasicSplineRenderer : Updatement<SplineClipDuration>, IAssetBundleLoader, IDependOnSplineCore
    {
        protected override ConfigType.ScriptLoadableConfig MakeConfig()
        {
            return new BasicSplineRendererConfig();
        }
        /// <summary>
        /// 加载并绑定到新样条线
        /// </summary>
        /// <param name="path">对象路径, 不存在时则立刻加载</param>
        [Convention.RScript.Variable.Attr.Method]
        public void LoadSpline(SplineCore core)
        {
            MySplineCore = core;
        }

        [Content] public SplineCore MySplineCore { get; set; }
        [Content] private MeshFilter m_MeshFilter;
        [Content] private MeshRenderer m_MyMeshRenderer;
        [Header("LineRenderer.Material")]
        [Content] public string LinesAssetBundlePath;

        private static Material m_StaticCacheDefaultMaterial;
        protected static Material StaticCacheDefaultMaterial
        {
            get
            {
                if (m_StaticCacheDefaultMaterial == null)
                    m_StaticCacheDefaultMaterial = Resources.Load<Material>("Line/Default");
                return m_StaticCacheDefaultMaterial;
            }
        }

        [Content] public Material MyDefaultMaterial;

        public override void ResetEnterGameStatus()
        {
            base.ResetEnterGameStatus();
            MyMeshRenderer.material = MyDefaultMaterial;
        }

        public MeshFilter MyMeshFilter
        {
            get
            {
                if (m_MeshFilter == null)
                    m_MeshFilter = this.GetOrAddComponent<MeshFilter>();
                return m_MeshFilter;
            }
        }
        public MeshRenderer MyMeshRenderer
        {
            get
            {
                if (m_MyMeshRenderer == null)
                {
                    m_MyMeshRenderer = this.GetOrAddComponent<MeshRenderer>();
                    m_MyMeshRenderer.material = StaticCacheDefaultMaterial;
                }
                return m_MyMeshRenderer;
            }
        }

        public abstract Vector3 EvaluateClipFromPosition(float time);

        public abstract Vector3 EvaluateClipToPosition(float time);

        public abstract SplineSample EvaluateClipFrom(float time);

        public abstract SplineSample EvaluateClipTo(float time);

        public override IEnumerator UnloadScript()
        {
            if (string.IsNullOrEmpty(LinesAssetBundlePath) == false)
                yield return this.UnloadAssetBundle(LinesAssetBundlePath);
            LinesAssetBundlePath = "";
            yield return base.UnloadScript();
        }

        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="time">插值时间</param>
        /// <param name="from"></param>
        /// <param name="to"></param>
        /// <param name="curveType">可取值为30种缓动曲线</param>
        [Convention.RScript.Variable.Attr.Method]
        public void Add(float time, float from, float to, MathExtension.EaseCurveType curveType)
        {
            ManualAddEntry(time, new(from, to), curveType);
        }

        /// <summary>
        /// 加载对应ab包并加载指定材质
        /// </summary>
        /// <param name="ab"></param>
        /// <param name="material"></param>
        [Convention.RScript.Variable.Attr.Method]
        public void LoadMaterial(string ab, string material)
        {
            MyMeshRenderer.enabled = true;
            LinesAssetBundlePath = ab;
            this.LoadAssetBundle(ab, x =>
            {
                MyDefaultMaterial = x.LoadAsset<Material>(material);
            });
        }

        protected override SplineClipDuration Lerp(SplineClipDuration begin, SplineClipDuration end, float t)
        {
            return new(Mathf.Lerp(begin.ClipFrom, end.ClipFrom, t), Mathf.Lerp(begin.ClipTo, end.ClipTo, t));
        }
    }

    public class BasicSplineRenderer<TMeshGenerator>: BasicSplineRenderer where TMeshGenerator : MeshGenerator
    {
        [Content] public TMeshGenerator MyMeshGenerator;

        protected override IEnumerator DoSomethingDuringApplyScript()
        {
            yield return base.DoSomethingDuringApplyScript();
            MyMeshGenerator = this.GetOrAddComponent<TMeshGenerator>();
            if (MySplineCore)
            {
                MyMeshGenerator.spline = MySplineCore.MySplineComputer;
                SetupMeshGenerator(MyMeshGenerator);
                MyMeshGenerator.RebuildImmediate();
            }
            else
            {
                Debug.LogError($"{nameof(MySplineCore)} not setup", this);
            }
        }

        #region SetupMeshGenerator

        [Content] public MeshGenerator.UVMode MyUVMode = default;

        public virtual void SetupMeshGenerator(TMeshGenerator meshGenerater)
        {
            meshGenerater.uvMode = MyUVMode;
        }

        /// <summary>
        /// 设置材质UV映射
        /// </summary>
        /// <param name="mode">Clip, UniformClip, Clamp, UniformClamp</param>
        [Convention.RScript.Variable.Attr.Method]
        public void SetUVMode(MeshGenerator.UVMode mode)
        {
            MyUVMode = mode;
        }

        #endregion

        protected override void UpdateData(SplineClipDuration data)
        {
            MyMeshGenerator.SetClipRange(data.ClipFrom, data.ClipTo);
        }

        protected override void UpdateTicks(float currentTime, float deltaTime, TickType tickType)
        {
            //保护措施
            if (MyMeshGenerator == null)
                return;
            base.UpdateTicks(currentTime, deltaTime, tickType);
        }

        public override Vector3 EvaluateClipFromPosition(float time)
        {
            return MySplineCore.MySplineComputer.EvaluatePosition(Evaluate(time).ClipFrom);
        }

        public override Vector3 EvaluateClipToPosition(float time)
        {
            return MySplineCore.MySplineComputer.EvaluatePosition(Evaluate(time).ClipTo);
        }

        public override SplineSample EvaluateClipFrom(float time)
        {
            return MySplineCore.MySplineComputer.Evaluate(Evaluate(time).ClipFrom);
        }

        public override SplineSample EvaluateClipTo(float time)
        {
            return MySplineCore.MySplineComputer.Evaluate(Evaluate(time).ClipTo);
        }
    }
}