Thunderkit Utilities

Nautilus/Utility/MaterialUtils.cs

@@ -19,9 +19,8 @@ internal static void Patch()
 
     private static IEnumerator LoadReferences()
     {
-#if SUBNAUTICA
         yield return PatchInternal();
-#endif
+
         IsReady = true;
 
         yield break;
@@ -32,6 +31,26 @@ private static IEnumerator LoadReferences()
     /// </summary>
     public static bool IsReady { get; private set; }
 
+    /// <summary>
+    /// Gets the basic glass material
+    /// </summary>
+    public static Material GlassMaterial { get; private set; }
+
+    /// <summary>
+    /// Gets the material for the outside of glass, such as for base windows
+    /// </summary>
+    public static Material ExteriorGlassMaterial { get; private set; }
+
+    /// <summary>
+    /// Gets the material for the inside of glass, such as the inside of the Cyclops windshield
+    /// </summary>
+    public static Material InteriorGlassMaterial { get; private set; }
+
+    /// <summary>
+    /// Gets a shiny glass material
+    /// </summary>
+    public static Material ShinyGlassMaterial { get; private set; }
+
     /// <summary>
     /// Contains references to various Shaders.
     /// </summary>

Nautilus/Utility/MaterialUtils_BelowZero.cs

@@ -0,0 +1,47 @@
+using System.Collections;
+using UnityEngine;
+
+#if BELOWZERO
+namespace Nautilus.Utility;
+
+public static partial class MaterialUtils
+{
+    private static IEnumerator PatchInternal()
+    {
+        yield return LoadGlassMaterials();
+    }
+
+    private static IEnumerator LoadGlassMaterials()
+    {
+        var seamothTask = CraftData.GetPrefabForTechTypeAsync(TechType.SeaTruck);
+
+        yield return seamothTask;
+
+        var glassMaterial = seamothTask.GetResult()
+            .transform.Find("model/seatruck_anim/Seatruck_cabin_exterior_glass_geo")
+            .GetComponent<Renderer>().material;
+
+        GlassMaterial = new Material(glassMaterial);
+
+        ExteriorGlassMaterial = new Material(glassMaterial);
+        ExteriorGlassMaterial.SetFloat("_SpecInt", 100);
+        ExteriorGlassMaterial.SetFloat("_Shininess", 6.3f);
+        ExteriorGlassMaterial.SetFloat("_Fresnel", 0.85f);
+        ExteriorGlassMaterial.SetColor("_Color", new Color(0.33f, 0.58f, 0.71f, 0.1f));
+        ExteriorGlassMaterial.SetColor("_SpecColor", new Color(0.5f, 0.76f, 1f, 1f));
+
+        ShinyGlassMaterial = new Material(glassMaterial);
+        ShinyGlassMaterial.SetColor("_Color", new Color(1, 1, 1, 0.2f));
+        ShinyGlassMaterial.SetFloat("_SpecInt", 3);
+        ShinyGlassMaterial.SetFloat("_Shininess", 8);
+        ShinyGlassMaterial.SetFloat("_Fresnel", 0.78f);
+
+        InteriorGlassMaterial = new Material(glassMaterial);
+        InteriorGlassMaterial.SetColor("_Color", new Color(0.67f, 0.71f, 0.76f, 0.56f));
+        InteriorGlassMaterial.SetFloat("_SpecInt", 2);
+        InteriorGlassMaterial.SetFloat("_Shininess", 6f);
+        InteriorGlassMaterial.SetFloat("_Fresnel", 0.88f);
+    }
+}
+
+#endif

Nautilus/Utility/MaterialUtils_Subnautica.cs

@@ -15,6 +15,8 @@ private static IEnumerator PatchInternal()
         yield return LoadAirWaterBarrierMaterial();
         yield return LoadForcefieldMaterial();
         yield return LoadGhostMaterial();
+        yield return LoadGlassMaterials();
+        yield return LoadUIMaterial();
     }
 
     /// <summary>
@@ -47,6 +49,11 @@ private static IEnumerator PatchInternal()
     /// </summary>
     public static Material GhostMaterial { get; private set; }
 
+    /// <summary>
+    /// Gets the material used by the UI in the Cyclops
+    /// </summary>
+    public static Material HolographicUIMaterial { get; private set; }
+
     private static IEnumerator LoadIonCubeMaterial()
     {
         if (IonCubeMaterial)
@@ -128,5 +135,57 @@ private static IEnumerator LoadGhostMaterial()
             GhostMaterial = wallShelf.GetComponentInChildren<Constructable>().ghostMaterial;
         }
     }
+
+    private static IEnumerator LoadGlassMaterials()
+    {
+        var seamothTask = CraftData.GetPrefabForTechTypeAsync(TechType.Seamoth);
+
+        yield return seamothTask;
+
+        var glassMaterial = seamothTask.GetResult()
+            .transform.Find("Model/Submersible_SeaMoth/Submersible_seaMoth_geo/Submersible_SeaMoth_glass_geo")
+            .GetComponent<Renderer>().material;
+
+        GlassMaterial = new Material(glassMaterial);
+
+        ExteriorGlassMaterial = new Material(glassMaterial);
+        ExteriorGlassMaterial.SetFloat("_SpecInt", 100);
+        ExteriorGlassMaterial.SetFloat("_Shininess", 6.3f);
+        ExteriorGlassMaterial.SetFloat("_Fresnel", 0.85f);
+        ExteriorGlassMaterial.SetColor("_Color", new Color(0.33f, 0.58f, 0.71f, 0.1f));
+        ExteriorGlassMaterial.SetColor("_SpecColor", new Color(0.5f, 0.76f, 1f, 1f));
+
+        ShinyGlassMaterial = new Material(glassMaterial);
+        ShinyGlassMaterial.SetColor("_Color", new Color(1, 1, 1, 0.2f));
+        ShinyGlassMaterial.SetFloat("_SpecInt", 3);
+        ShinyGlassMaterial.SetFloat("_Shininess", 8);
+        ShinyGlassMaterial.SetFloat("_Fresnel", 0.78f);
+
+        InteriorGlassMaterial = new Material(glassMaterial);
+        InteriorGlassMaterial.SetColor("_Color", new Color(0.67f, 0.71f, 0.76f, 0.56f));
+        InteriorGlassMaterial.SetFloat("_SpecInt", 2);
+        InteriorGlassMaterial.SetFloat("_Shininess", 6f);
+        InteriorGlassMaterial.SetFloat("_Fresnel", 0.88f);
+    }
+
+    private static bool _cyclopsLoaded;
+
+    private static IEnumerator LoadUIMaterial()
+    {
+        yield return new WaitUntil(() => LightmappedPrefabs.main);
+
+        LightmappedPrefabs.main.RequestScenePrefab("Cyclops", new LightmappedPrefabs.OnPrefabLoaded(OnCyclopsLoaded));
+
+        yield return new WaitUntil(() => _cyclopsLoaded);
+    }
+
+    private static void OnCyclopsLoaded(GameObject cyclops)
+    {
+        var holoMat = cyclops.transform.Find("HelmHUD/HelmHUDVisuals/Canvas_LeftHUD/EngineOnUI/EngineOff_Button")
+            .GetComponent<UnityEngine.UI.Image>().material;
+
+        HolographicUIMaterial = new Material(holoMat);
+        _cyclopsLoaded = true;
+    }
 }
 #endif

Nautilus/Utility/ThunderkitUtilities/ApplySNFont.cs

@@ -0,0 +1,27 @@
+using UnityEngine;
+using TMPro;
+
+namespace Nautilus.Utility.ThunderkitUtilities;
+
+internal class ApplySNFont : MonoBehaviour
+{
+    [Tooltip("How to apply the font")]
+    public GeneralSetMode fontSetMode;
+
+    private void Start()
+    {
+        switch (fontSetMode)
+        {
+            case GeneralSetMode.SingleObject:
+                GetComponent<TextMeshProUGUI>().font = FontUtils.Aller_Rg;
+                break;
+            case GeneralSetMode.AllChildObjects:
+                GetComponentsInChildren<TextMeshProUGUI>().ForEach(t => t.font = FontUtils.Aller_Rg);
+                break;
+            case GeneralSetMode.AllChildObjectsIncludeInactive:
+                GetComponentsInChildren<TextMeshProUGUI>(true).ForEach(t => t.font = FontUtils.Aller_Rg);
+                break;
+        }
+
+    }
+}

Nautilus/Utility/ThunderkitUtilities/ApplySNLayer.cs

@@ -0,0 +1,75 @@
+using System.Reflection;
+using UnityEngine;
+
+namespace Nautilus.Utility.ThunderkitUtilities;
+
+internal class ApplySNLayer : MonoBehaviour
+{
+    [Tooltip("The name of the layer you want to apply")]
+    public LayerName layerName;
+
+    [Tooltip("How to apply the layer")]
+    public GeneralSetMode layerSetMode;
+
+    private void Start()
+    {
+        int layer = layerName switch
+        {
+            LayerName.Default => LayerID.Default,
+            LayerName.Useable => LayerID.Useable,
+            LayerName.NotUseable => LayerID.NotUseable,
+            LayerName.Player => LayerID.Player,
+            LayerName.TerrainCollider => LayerID.TerrainCollider,
+            LayerName.UI => LayerID.UI,
+            LayerName.Trigger => LayerID.Trigger,
+            LayerName.BaseClipProxy => LayerID.BaseClipProxy,
+            LayerName.OnlyVehicle => LayerID.OnlyVehicle,
+            LayerName.Vehicle => LayerID.Vehicle,
+#if SUBNAUTICA
+            LayerName.DefaultCollisionMask => LayerID.DefaultCollisionMask,
+            LayerName.SubRigidbodyExclude => LayerID.SubRigidbodyExclude,
+#elif BELOWZERO          
+            LayerName.Interior => LayerID.Interior,
+            LayerName.AllowPlayerAndVehicle => LayerID.AllowPlayerAndVehicle,
+#endif
+            _ => 0
+        };
+
+        switch(layerSetMode)
+        {
+            case GeneralSetMode.SingleObject:
+                gameObject.layer = layer;
+                break;
+            case GeneralSetMode.AllChildObjects:
+                GetComponentsInChildren<GameObject>().ForEach(g => g.layer = layer);
+                break;
+            case GeneralSetMode.AllChildObjectsIncludeInactive:
+                GetComponentsInChildren<GameObject>(true).ForEach(g => g.layer = layer);
+                break;
+        }
+    }
+
+    /// <summary>
+    /// These are taken from <see cref="LayerID"/>, and are retrieved using reflection
+    /// </summary>
+    public enum LayerName
+    {
+        Default,
+        Useable,
+        NotUseable,
+        Player,
+        TerrainCollider,
+        UI,
+        Trigger,
+        BaseClipProxy,
+        OnlyVehicle,
+        Vehicle,
+#if SUBNAUTICA
+        DefaultCollisionMask,
+        SubRigidbodyExclude,
+#elif BELOWZERO
+        Interior,
+        AllowPlayerAndVehicle
+#endif
+    }
+}

Nautilus/Utility/ThunderkitUtilities/ApplySNMaterial.cs

@@ -0,0 +1,120 @@
+using System.Collections;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Nautilus.Utility.ThunderkitUtilities;
+
+internal class ApplySNMaterial : MonoBehaviour
+{
+    [Tooltip("How to apply the material")]
+    public MaterialSetMode materialSetMode;
+
+    [Tooltip("What material to apply")]
+    public MaterialType materialType;
+
+    [Tooltip("Run at start, or be manually called?")]
+    public bool runAtStart = true;
+
+    [Header("Single Object Settings:")]
+    public Renderer renderer;
+    public int[] materialIndices = new[] { 0 };
+
+    private void OnValidate()
+    {
+        if (!renderer) TryGetComponent(out renderer);
+    }
+
+    private void Start()
+    {
+        if (!runAtStart) return;
+
+        AssignMaterials();
+    }
+
+    /// <summary>
+    /// Applies the set material using the specified <see cref="MaterialSetMode"/>
+    /// </summary>
+    public void AssignMaterials()
+    {
+        switch(materialSetMode)
+        {
+            case MaterialSetMode.SingleObject:
+                ApplyMaterialsOnSingleRend();
+                break;
+            case MaterialSetMode.AllChildObjects:
+                ApplyMaterialsOnChildren(false);
+                break;
+            case MaterialSetMode.AllChildObjectsIncludeInactive:
+                ApplyMaterialsOnChildren(true);
+                break;
+            case MaterialSetMode.AllChildGraphics:
+                foreach (var graphic in GetComponentsInChildren<Graphic>(true))
+                {
+                    graphic.material = GetMaterial(materialType);
+                }
+                break;
+        }
+    }
+
+    private void ApplyMaterialsOnSingleRend()
+    {
+        if (renderer == null) throw new System.Exception($"The renderer is null on {gameObject} when SN materials were trying to be applied");
+
+        var mats = renderer.materials;
+        foreach (var index in materialIndices)
+        {
+            mats[index] = GetMaterial(materialType);
+        }
+
+        renderer.materials = mats;
+    }
+
+    private void ApplyMaterialsOnChildren(bool includeInactive)
+    {
+        var rends = GetComponentsInChildren<Renderer>(includeInactive);
+        foreach (var rend in rends)
+        {
+            var materials = rend.materials;
+            for (int i = 0; i < materials.Length; i++)
+            {
+                materials[i] = GetMaterial(materialType);
+            }
+
+            rend.materials = materials;
+        }
+    }
+
+    private Material GetMaterial(MaterialType type)
+    {
+        Material mat = type switch
+        {
+#if SN_STABLE
+            MaterialType.WaterBarrier => MaterialUtils.AirWaterBarrierMaterial,
+            MaterialType.ForceField => MaterialUtils.ForceFieldMaterial,
+            MaterialType.StasisField => MaterialUtils.StasisFieldMaterial,
+            MaterialType.HolographicUI => MaterialUtils.HolographicUIMaterial,
+#endif
+            MaterialType.Glass => MaterialUtils.GlassMaterial,
+            MaterialType.ExteriorGlass => MaterialUtils.ExteriorGlassMaterial,
+            MaterialType.ShinyGlass => MaterialUtils.ShinyGlassMaterial,
+            MaterialType.InteriorWindowGlass => MaterialUtils.InteriorGlassMaterial,
+            _ => null
+        };
+
+        return mat;
+    }
+
+    internal enum MaterialType
+    {
+        Glass,
+        ExteriorGlass,
+        ShinyGlass,
+        InteriorWindowGlass,
+#if SN_STABLE
+        WaterBarrier,
+        ForceField,
+        StasisField,
+        HolographicUI
+#endif
+    }
+}