ichni_Official/Assets/Scripts/Game/GameElements/Track/TrackSubmodules/TrackRendererSubmodule.cs

using System;
using System.Collections;
using System.Collections.Generic;
using Dreamteck.Splines;
using Ichni.RhythmGame.Beatmap;
using Unity.VisualScripting;
using UnityEngine;
using Object = UnityEngine.Object;

namespace Ichni.RhythmGame
{
    public partial class TrackRendererSubmodule : TrackSubmodule
    {
        public MeshGenerator meshGenerator;
        public MeshRenderer meshRenderer;
        public Material renderMaterial;

        public string materialThemeBundleName;
        public string materialName;
        public bool enableEmission;
        public float emissionIntensity;
        public bool zWrite;

        public TrackRendererSubmodule(Track track, bool enableEmission, float emissionIntensity, bool zWrite) : base(track)
        {
            this.enableEmission = enableEmission;
            this.emissionIntensity = emissionIntensity;
            this.materialThemeBundleName = String.Empty;
            this.materialName = String.Empty;
            this.zWrite = zWrite;

            if (!HaveSameSubmodule)
            {
                this.track.trackRendererSubmodule = this;
            }
        }

        public void ApplyMaterial(string materialThemeBundleName, string materialName)
        {
            this.materialThemeBundleName = materialThemeBundleName;
            this.materialName = materialName;
            Material mat = ThemeBundleManager.instance.GetObject<Material>(materialThemeBundleName, materialName);
            if(mat != null)
            {
                renderMaterial = mat;
                meshRenderer.material = renderMaterial;
            }
        }

        public override void Refresh()
        {
            SetEnableZWrite();
            SetEnableEmission();
            SetEmissionIntensity();
            
            if (track.trackTimeSubmodule is TrackTimeSubmoduleMovable)
            {
                meshGenerator.clipFrom = 0;
                meshGenerator.clipTo = 0;
            }
            else
            {
                meshGenerator.clipFrom = 0;
                meshGenerator.clipTo = 1;
            }
        }

        public override void SaveBM()
        {
            throw new System.NotImplementedException();
        }
    }
    public partial class TrackRendererSubmodule
    {
        protected void SetEnableEmission()
        {
            meshRenderer.material.SetInt("_Emission", enableEmission ? 1 : 0);
        }
        
        protected void SetEnableZWrite()
        {
            meshRenderer.material.SetInt("_ZWrite", zWrite ? 1 : 0);
        }
        
        protected void SetEmissionIntensity()
        {
            meshRenderer.material.SetColor("_EmissionColor", Color.white * Mathf.Pow(2, emissionIntensity));
        }
    }

    #region AutoOrient

    public class TrackRendererSubmoduleAutoOrient : TrackRendererSubmodule
    {
        public SplineRenderer splineRenderer;

        public TrackRendererSubmoduleAutoOrient(Track track, bool enableEmission, float emissionIntensity, bool zWrite, Material material = null) :
            base(track, enableEmission, emissionIntensity, zWrite)
        {
            this.splineRenderer = track.AddComponent<SplineRenderer>();
            this.meshRenderer = splineRenderer.GetComponent<MeshRenderer>();
            this.meshGenerator = splineRenderer;
            this.renderMaterial = material == null ? GameManager.instance.basePrefabs.defaultTrackMaterial : material;
            this.splineRenderer.spline = track.trackPathSubmodule.path;
            this.splineRenderer.clipFrom = 0;
            this.splineRenderer.clipTo = 1;
            this.splineRenderer.updateMethod = SplineUser.UpdateMethod.LateUpdate;
            this.meshRenderer.material = renderMaterial;
            this.splineRenderer.color = Color.white;
            this.splineRenderer.uvRotation = 90;
        }

        public override void SaveBM()
        {
            matchedBM = new TrackRendererSubmoduleAutoOrient_BM(attachedGameElement, this);
        }
    }

    namespace Beatmap
    {
        public class TrackRendererSubmoduleAutoOrient_BM : Submodule_BM
        {
            public string materialThemeBundleName;
            public string materialName;
            public bool enableEmission;
            public float emissionIntensity;
            public bool zWrite;

            public TrackRendererSubmoduleAutoOrient_BM()
            {

            }

            public TrackRendererSubmoduleAutoOrient_BM(GameElement attachedElement,
                TrackRendererSubmoduleAutoOrient trackRendererSubmodule) : base(attachedElement)
            {
                materialThemeBundleName = trackRendererSubmodule.materialThemeBundleName;
                materialName = trackRendererSubmodule.materialName;
                enableEmission = trackRendererSubmodule.enableEmission;
                emissionIntensity = trackRendererSubmodule.emissionIntensity;
            }

            public override void ExecuteBM()
            {
                attachedElement = GameElement_BM.GetElement(attachedElementGuid);
                Track track = attachedElement as Track;
                track.trackRendererSubmodule = new TrackRendererSubmoduleAutoOrient(track, enableEmission, emissionIntensity, zWrite);
                if (materialName.Trim() != String.Empty)
                {
                    track.trackRendererSubmodule.ApplyMaterial(materialThemeBundleName, materialName);
                }
            }

            public override void DuplicateBM(GameElement attached)
            {
                Track track = attached as Track;
                track.trackRendererSubmodule = new TrackRendererSubmoduleAutoOrient(track, enableEmission, emissionIntensity, zWrite);
                if (materialName.Trim() != String.Empty)
                {
                    track.trackRendererSubmodule.ApplyMaterial(materialThemeBundleName, materialName);
                }
            }
        }
    }

    #endregion

    #region PathGenerator

    public class TrackRendererSubmodulePathGenerator : TrackRendererSubmodule
    {
        public PathGenerator pathGenerator;

        public TrackRendererSubmodulePathGenerator(Track track, bool enableEmission, float emissionIntensity, bool zWrite, Material material = null) :
            base(track, enableEmission, emissionIntensity, zWrite)
        {
            this.pathGenerator = track.AddComponent<PathGenerator>();
            this.meshRenderer = pathGenerator.GetComponent<MeshRenderer>();
            this.meshGenerator = pathGenerator;
            this.renderMaterial = material == null ? GameManager.instance.basePrefabs.defaultTrackMaterial : material;
            this.pathGenerator.spline = track.trackPathSubmodule.path;
            this.pathGenerator.clipFrom = 0;
            this.pathGenerator.clipTo = 1;
            this.pathGenerator.updateMethod = SplineUser.UpdateMethod.LateUpdate;
            this.meshRenderer.material = renderMaterial;
            this.pathGenerator.color = Color.white;
            this.pathGenerator.uvRotation = 90;
        }

        public override void SaveBM()
        {
            matchedBM = new TrackRendererSubmodulePathGenerator_BM(attachedGameElement, this);
        }
    }

    namespace Beatmap
    {
        public class TrackRendererSubmodulePathGenerator_BM : Submodule_BM
        {
            public string materialThemeBundleName;
            public string materialName;
            public bool enableEmission;
            public float emissionIntensity;
            public bool zWrite;

            public TrackRendererSubmodulePathGenerator_BM()
            {

            }

            public TrackRendererSubmodulePathGenerator_BM(GameElement attachedElement,
                TrackRendererSubmodulePathGenerator trackRendererSubmodule) : base(attachedElement)
            {
                materialThemeBundleName = trackRendererSubmodule.materialThemeBundleName;
                materialName = trackRendererSubmodule.materialName;
                enableEmission = trackRendererSubmodule.enableEmission;
                emissionIntensity = trackRendererSubmodule.emissionIntensity;
            }

            public override void ExecuteBM()
            {
                attachedElement = GameElement_BM.GetElement(attachedElementGuid);
                Track track = attachedElement as Track;
                track.trackRendererSubmodule = new TrackRendererSubmodulePathGenerator(track, enableEmission, emissionIntensity, zWrite);
                if (materialName.Trim() != String.Empty)
                {
                    track.trackRendererSubmodule.ApplyMaterial(materialThemeBundleName, materialName);
                }
            }

            public override void DuplicateBM(GameElement attached)
            {
                Track track = attached as Track;
                track.trackRendererSubmodule = new TrackRendererSubmodulePathGenerator(track, enableEmission, emissionIntensity, zWrite);
                if (materialName.Trim() != String.Empty)
                {
                    track.trackRendererSubmodule.ApplyMaterial(materialThemeBundleName, materialName);
                }
            }
        }
    }

    #endregion

    #region TubeGenerator

    public class TrackRendererSubmoduleTubeGenerator : TrackRendererSubmodule
    {
        public TubeGenerator tubeGenerator;
        public int sideCount;

        public TrackRendererSubmoduleTubeGenerator(Track track, bool enableEmission, float emissionIntensity, bool zWrite, 
            int sideCount, Material material = null) :
            base(track, enableEmission, emissionIntensity, zWrite)
        {
            this.sideCount = sideCount;

            this.tubeGenerator = track.AddComponent<TubeGenerator>();
            this.meshRenderer = tubeGenerator.GetComponent<MeshRenderer>();
            this.meshGenerator = tubeGenerator;
            this.renderMaterial = material == null ? GameManager.instance.basePrefabs.defaultTrackMaterial : material;
            this.tubeGenerator.spline = track.trackPathSubmodule.path;
            this.tubeGenerator.clipFrom = 0;
            this.tubeGenerator.clipTo = 1;
            this.tubeGenerator.updateMethod = SplineUser.UpdateMethod.LateUpdate;
            this.meshRenderer.material = renderMaterial;
            this.tubeGenerator.color = Color.white;
            this.tubeGenerator.uvRotation = 90;
            this.tubeGenerator.sides = sideCount;
        }

        public override void SaveBM()
        {
            matchedBM = new TrackRendererSubmoduleTubeGenerator_BM(attachedGameElement, this);
        }
    }

    namespace Beatmap
    {
        public class TrackRendererSubmoduleTubeGenerator_BM : Submodule_BM
        {
            public string materialThemeBundleName;
            public string materialName;
            public bool enableEmission;
            public float emissionIntensity;
            public bool zWrite;
            public int sideCount;

            public TrackRendererSubmoduleTubeGenerator_BM()
            {

            }

            public TrackRendererSubmoduleTubeGenerator_BM(GameElement attachedElement,
                TrackRendererSubmoduleTubeGenerator trackRendererSubmodule) : base(attachedElement)
            {
                materialThemeBundleName = trackRendererSubmodule.materialThemeBundleName;
                materialName = trackRendererSubmodule.materialName;
                enableEmission = trackRendererSubmodule.enableEmission;
                emissionIntensity = trackRendererSubmodule.emissionIntensity;
                sideCount = trackRendererSubmodule.sideCount;
            }

            public override void ExecuteBM()
            {
                attachedElement = GameElement_BM.GetElement(attachedElementGuid);
                Track track = attachedElement as Track;
                track.trackRendererSubmodule = new TrackRendererSubmoduleTubeGenerator(track, enableEmission, emissionIntensity, zWrite, sideCount);
                if (materialName.Trim() != String.Empty)
                {
                    track.trackRendererSubmodule.ApplyMaterial(materialThemeBundleName, materialName);
                }
            }

            public override void DuplicateBM(GameElement attached)
            {
                Track track = attached as Track;
                track.trackRendererSubmodule = new TrackRendererSubmoduleTubeGenerator(track, enableEmission, emissionIntensity, zWrite, sideCount);
                if (materialName.Trim() != String.Empty)
                {
                    track.trackRendererSubmodule.ApplyMaterial(materialThemeBundleName, materialName);
                }
            }
        }
    }

    #endregion

    #region Surface

    public class TrackRendererSubmoduleSurface : TrackRendererSubmodule
    {
        public SurfaceGenerator surface;

        public TrackRendererSubmoduleSurface(Track track, bool enableEmission, float emissionIntensity, bool zWrite, Material material = null) :
            base(track, enableEmission, emissionIntensity, zWrite)
        {
            this.surface = track.AddComponent<SurfaceGenerator>();
            this.meshRenderer = surface.GetComponent<MeshRenderer>();
            this.meshGenerator = surface;
            this.renderMaterial = material == null ? GameManager.instance.basePrefabs.defaultTrackMaterial : material;
            this.surface.spline = track.trackPathSubmodule.path;
            this.surface.clipFrom = 0;
            this.surface.clipTo = 1;
            this.surface.updateMethod = SplineUser.UpdateMethod.LateUpdate;
            this.meshRenderer.material = renderMaterial;
            this.surface.color = Color.white;
            this.surface.uvRotation = 90;
        }

        public override void SaveBM()
        {
            matchedBM = new TrackRendererSubmoduleSurface_BM(attachedGameElement, this);
        }
    }

    namespace Beatmap
    {
        public class TrackRendererSubmoduleSurface_BM : Submodule_BM
        {
            public string materialThemeBundleName;
            public string materialName;
            public bool enableEmission;
            public float emissionIntensity;
            public bool zWrite;

            public TrackRendererSubmoduleSurface_BM()
            {

            }

            public TrackRendererSubmoduleSurface_BM(GameElement attachedElement,
                TrackRendererSubmoduleSurface trackRendererSubmodule) : base(attachedElement)
            {
                materialThemeBundleName = trackRendererSubmodule.materialThemeBundleName;
                materialName = trackRendererSubmodule.materialName;
                enableEmission = trackRendererSubmodule.enableEmission;
                emissionIntensity = trackRendererSubmodule.emissionIntensity;
            }

            public override void ExecuteBM()
            {
                attachedElement = GameElement_BM.GetElement(attachedElementGuid);
                Track track = attachedElement as Track;
                track.trackRendererSubmodule = new TrackRendererSubmoduleSurface(track, enableEmission, emissionIntensity, zWrite);
                if (materialName.Trim() != String.Empty)
                {
                    track.trackRendererSubmodule.ApplyMaterial(materialThemeBundleName, materialName);
                }
            }

            public override void DuplicateBM(GameElement attached)
            {
                Track track = attached as Track;
                track.trackRendererSubmodule = new TrackRendererSubmoduleSurface(track, enableEmission, emissionIntensity, zWrite);
                if (materialName.Trim() != String.Empty)
                {
                    track.trackRendererSubmodule.ApplyMaterial(materialThemeBundleName, materialName);
                }
            }
        }
    }
    #endregion
}