From 5ee7dca50bfeca84973e9fae171b2beb200f99f0 Mon Sep 17 00:00:00 2001 From: NotAKidoS <37721153+NotAKidOnSteam@users.noreply.github.com> Date: Sat, 3 Feb 2024 02:12:40 -0600 Subject: [PATCH] [BetterShadowClone] Throwing on git before i completely overcomplicate and have to revert lmao --- BetterShadowClone/BetterShadowClone.csproj | 8 + BetterShadowClone/Koneko/BoneHider.cs | 130 ++++++++++ BetterShadowClone/Main.cs | 144 +++++++++++ BetterShadowClone/ModSettings.cs | 45 ++++ BetterShadowClone/Properties/AssemblyInfo.cs | 29 +++ BetterShadowClone/README.md | 16 ++ .../Resources/bettershadowclone.assets | Bin 0 -> 9425 bytes .../ShadowClone/IShadowClone/IShadowClone.cs | 11 + .../IShadowClone/MeshShadowClone.cs | 154 ++++++++++++ .../IShadowClone/SkinnedShadowClone.cs | 223 ++++++++++++++++ .../ShadowClone/ShadowCloneManager.cs | 217 ++++++++++++++++ BetterShadowClone/ShadowCloneHelper.cs | 142 +++++++++++ .../TransformHider/FPRExclusion.cs | 30 +++ .../ITransformHider/ITransformHider.cs | 11 + .../ITransformHider/MeshTransformHider.cs | 86 +++++++ .../ITransformHider/SkinnedTransformHider.cs | 191 ++++++++++++++ .../TransformHider/TransformHiderManager.cs | 237 ++++++++++++++++++ BetterShadowClone/format.json | 23 ++ 18 files changed, 1697 insertions(+) create mode 100644 BetterShadowClone/BetterShadowClone.csproj create mode 100644 BetterShadowClone/Koneko/BoneHider.cs create mode 100644 BetterShadowClone/Main.cs create mode 100644 BetterShadowClone/ModSettings.cs create mode 100644 BetterShadowClone/Properties/AssemblyInfo.cs create mode 100644 BetterShadowClone/README.md create mode 100644 BetterShadowClone/Resources/bettershadowclone.assets create mode 100644 BetterShadowClone/ShadowClone/IShadowClone/IShadowClone.cs create mode 100644 BetterShadowClone/ShadowClone/IShadowClone/MeshShadowClone.cs create mode 100644 BetterShadowClone/ShadowClone/IShadowClone/SkinnedShadowClone.cs create mode 100644 BetterShadowClone/ShadowClone/ShadowCloneManager.cs create mode 100644 BetterShadowClone/ShadowCloneHelper.cs create mode 100644 BetterShadowClone/TransformHider/FPRExclusion.cs create mode 100644 BetterShadowClone/TransformHider/ITransformHider/ITransformHider.cs create mode 100644 BetterShadowClone/TransformHider/ITransformHider/MeshTransformHider.cs create mode 100644 BetterShadowClone/TransformHider/ITransformHider/SkinnedTransformHider.cs create mode 100644 BetterShadowClone/TransformHider/TransformHiderManager.cs create mode 100644 BetterShadowClone/format.json diff --git a/BetterShadowClone/BetterShadowClone.csproj b/BetterShadowClone/BetterShadowClone.csproj new file mode 100644 index 0000000..09ffc35 --- /dev/null +++ b/BetterShadowClone/BetterShadowClone.csproj @@ -0,0 +1,8 @@ + + + + + bettershadowclone.assets + + + diff --git a/BetterShadowClone/Koneko/BoneHider.cs b/BetterShadowClone/Koneko/BoneHider.cs new file mode 100644 index 0000000..0e0c57d --- /dev/null +++ b/BetterShadowClone/Koneko/BoneHider.cs @@ -0,0 +1,130 @@ +// using System.Collections.Generic; +// using System.Linq; +// using NAK.BetterShadowClone; +// using UnityEngine; +// using UnityEngine.Serialization; +// +// namespace Koneko.BetterHeadHider; +// +// public class BoneHider : MonoBehaviour { +// public static ComputeShader shader; +// +// public SkinnedMeshRenderer[] targets; +// public Transform shrinkBone; +// private ComputeBuffer[] weightedBuffers; +// private int[] weightedCounts; +// private int[] bufferLayouts; +// private int[] threadGroups; +// private bool Initialized; +// +// +// #region Public Methods +// public static void SetupAvatar(GameObject avatar, Transform shrinkBone, SkinnedMeshRenderer[] targets) { +// BoneHider shrink = avatar.AddComponent(); +// shrink.shrinkBone = shrinkBone; +// shrink.targets = targets; +// } +// #endregion +// +// #region Private Methods +// private void Initialize() { +// Dispose(); +// +// weightedBuffers = new ComputeBuffer[targets.Length]; +// weightedCounts = new int[targets.Length]; +// bufferLayouts = new int[targets.Length]; +// threadGroups = new int[targets.Length]; +// +// for (int i = 0; i < targets.Length; i++) { +// List weighted = FindHeadVertices(targets[i]); +// if (weighted.Count == 0) continue; +// +// targets[i].sharedMesh.vertexBufferTarget |= GraphicsBuffer.Target.Raw; +// weightedBuffers[i] = new(weighted.Count, sizeof(int)); +// weightedBuffers[i].SetData(weighted.ToArray()); +// weightedCounts[i] = weighted.Count; +// +// int bufferLayout = 0; +// if (targets[i].sharedMesh.HasVertexAttribute(UnityEngine.Rendering.VertexAttribute.Position)) bufferLayout += 3; +// if (targets[i].sharedMesh.HasVertexAttribute(UnityEngine.Rendering.VertexAttribute.Normal)) bufferLayout += 3; +// if (targets[i].sharedMesh.HasVertexAttribute(UnityEngine.Rendering.VertexAttribute.Tangent)) bufferLayout += 4; +// bufferLayouts[i] = bufferLayout; +// +// threadGroups[i] = Mathf.CeilToInt(weighted.Count / 64.0f); +// Debug.Log(threadGroups[i]); +// } +// +// Initialized = true; +// } +// +// private List FindHeadVertices(SkinnedMeshRenderer target) { +// List headVertices = new(); +// BoneWeight[] boneWeights = target.sharedMesh.boneWeights; +// HashSet bones = new(); +// +// bones = shrinkBone.GetComponentsInChildren(true).ToHashSet(); +// +// //get indexs of child bones +// HashSet weights = new(); +// for (int i = 0; i < target.bones.Length; i++) { +// if (bones.Contains(target.bones[i])) weights.Add(i); +// } +// +// for (int i = 0; i < boneWeights.Length; i++) { +// BoneWeight weight = boneWeights[i]; +// if (weights.Contains(weight.boneIndex0) || weights.Contains(weight.boneIndex1) || +// weights.Contains(weight.boneIndex2) || weights.Contains(weight.boneIndex3)) { +// headVertices.Add(i); +// } +// } +// return headVertices; +// } +// +// private void MyOnPreRender(Camera cam) { +// if (!Initialized) +// return; +// +// // NOTE: We only hide head once, so any camera rendered after wont see the head! +// +// if (cam != ShadowCloneMod.PlayerCamera // only hide in player cam, or in portable cam if debug is on +// && (!ModSettings.EntryHideInPortableCamera.Value || cam != ShadowCloneMod.HandCamera)) +// return; +// +// if (!ShadowCloneMod.CheckWantsToHideHead(cam)) +// return; // listener said no (Third Person, etc) +// +// for (int i = 0; i < targets.Length; i++) { +// SkinnedMeshRenderer target = targets[i]; +// +// if (target == null +// || !target.gameObject.activeInHierarchy +// || weightedBuffers[i] == null) continue; +// +// GraphicsBuffer vertexBuffer = targets[i].GetVertexBuffer(); +// if(vertexBuffer == null) continue; +// +// shader.SetVector(s_Pos, Vector3.positiveInfinity); // todo: fix +// shader.SetInt(s_WeightedCount, weightedCounts[i]); +// shader.SetInt(s_BufferLayout, bufferLayouts[i]); +// shader.SetBuffer(0, s_WeightedVertices, weightedBuffers[i]); +// shader.SetBuffer(0, s_VertexBuffer, vertexBuffer); +// shader.Dispatch(0, threadGroups[i], 1, 1); +// vertexBuffer.Dispose(); +// } +// } +// +// private void Dispose() { +// Initialized = false; +// if (weightedBuffers == null) return; +// foreach (ComputeBuffer c in weightedBuffers) +// c?.Dispose(); +// } +// #endregion +// +// #region Unity Events +// private void OnEnable() => Camera.onPreRender += MyOnPreRender; +// private void OnDisable() => Camera.onPreRender -= MyOnPreRender; +// private void OnDestroy() => Dispose(); +// private void Start() => Initialize(); +// #endregion +// } \ No newline at end of file diff --git a/BetterShadowClone/Main.cs b/BetterShadowClone/Main.cs new file mode 100644 index 0000000..81591fd --- /dev/null +++ b/BetterShadowClone/Main.cs @@ -0,0 +1,144 @@ +using System; +using System.IO; +using MelonLoader; +using System.Reflection; +using ABI_RC.Core.Player; +using ABI_RC.Core.Util; +using ABI_RC.Core.Util.AssetFiltering; +using ABI_RC.Systems.Camera; +using UnityEngine; + +namespace NAK.BetterShadowClone; + +public class ShadowCloneMod : MelonMod +{ + internal static MelonLogger.Instance Logger; + + + public override void OnInitializeMelon() + { + Logger = LoggerInstance; + + ModSettings.Initialize(); + //VRModeSwitchEvents.OnCompletedVRModeSwitch.AddListener(_ => FindCameras()); + + SharedFilter._avatarWhitelist.Add(typeof(FPRExclusion)); + SharedFilter._localComponentWhitelist.Add(typeof(FPRExclusion)); + + try + { + LoadAssetBundle(); + InitializePatches(); + } + catch (Exception e) + { + Logger.Error(e); + } + } + + #region Hide Head Override + + /// + /// Return false to prevent the head from being hidden. + /// + public static WantsToHideHeadDelegate wantsToHideHead; + public delegate bool WantsToHideHeadDelegate(Camera cam); + + public static bool CheckWantsToHideHead(Camera cam) + { + if (wantsToHideHead == null) + return true; + + foreach (Delegate @delegate in wantsToHideHead.GetInvocationList()) + { + WantsToHideHeadDelegate method = (WantsToHideHeadDelegate)@delegate; + if (!method(cam)) return false; + } + + return true; + } + + #endregion + + #region Asset Bundle Loading + + private const string BetterShadowCloneAssets = "bettershadowclone.assets"; + + private const string BoneHiderComputePath = "Assets/Koneko/ComputeShaders/BoneHider.compute"; + //private const string MeshCopyComputePath = "Assets/Koneko/ComputeShaders/MeshCopy.compute"; + + private const string ShadowCloneComputePath = "Assets/NotAKid/Shaders/ShadowClone.compute"; + private const string ShadowCloneShaderPath = "Assets/NotAKid/Shaders/ShadowClone.shader"; + private const string DummyCloneShaderPath = "Assets/NotAKid/Shaders/DummyClone.shader"; + + private void LoadAssetBundle() + { + Logger.Msg($"Loading required asset bundle..."); + using Stream resourceStream = MelonAssembly.Assembly.GetManifestResourceStream(BetterShadowCloneAssets); + using MemoryStream memoryStream = new(); + if (resourceStream == null) { + Logger.Error($"Failed to load {BetterShadowCloneAssets}!"); + return; + } + + resourceStream.CopyTo(memoryStream); + AssetBundle assetBundle = AssetBundle.LoadFromMemory(memoryStream.ToArray()); + if (assetBundle == null) { + Logger.Error($"Failed to load {BetterShadowCloneAssets}! Asset bundle is null!"); + return; + } + + // load shaders + ComputeShader shader = assetBundle.LoadAsset(BoneHiderComputePath); + shader.hideFlags |= HideFlags.DontUnloadUnusedAsset; + TransformHiderManager.shader = shader; + Logger.Msg($"Loaded {BoneHiderComputePath}!"); + + // load shadow clone shader + ComputeShader shadowCloneCompute = assetBundle.LoadAsset(ShadowCloneComputePath); + shadowCloneCompute.hideFlags |= HideFlags.DontUnloadUnusedAsset; + ShadowCloneHelper.shader = shadowCloneCompute; + Logger.Msg($"Loaded {ShadowCloneComputePath}!"); + + // load shadow clone material + Shader shadowCloneShader = assetBundle.LoadAsset(ShadowCloneShaderPath); + shadowCloneShader.hideFlags |= HideFlags.DontUnloadUnusedAsset; + ShadowCloneHelper.shadowMaterial = new Material(shadowCloneShader); + Logger.Msg($"Loaded {ShadowCloneShaderPath}!"); + + Logger.Msg("Asset bundle successfully loaded!"); + } + + #endregion + + #region Harmony Patches + + private void InitializePatches() + { + HarmonyInstance.Patch( + typeof(TransformHiderForMainCamera).GetMethod(nameof(TransformHiderForMainCamera.ProcessHierarchy)), + prefix: new HarmonyLib.HarmonyMethod(typeof(ShadowCloneMod).GetMethod(nameof(OnTransformHiderForMainCamera_ProcessHierarchy_Prefix), BindingFlags.NonPublic | BindingFlags.Static)) + ); + + HarmonyInstance.Patch( + typeof(PlayerSetup).GetMethod(nameof(PlayerSetup.ClearAvatar)), + prefix: new HarmonyLib.HarmonyMethod(typeof(ShadowCloneMod).GetMethod(nameof(OnPlayerSetup_ClearAvatar_Prefix), BindingFlags.NonPublic | BindingFlags.Static)) + ); + } + + private static void OnPlayerSetup_ClearAvatar_Prefix() + { + TransformHiderManager.Instance.OnAvatarCleared(); + ShadowCloneManager.Instance.OnAvatarCleared(); + } + + private static void OnTransformHiderForMainCamera_ProcessHierarchy_Prefix(ref bool __runOriginal) + { + if (!__runOriginal || (__runOriginal = !ModSettings.EntryEnabled.Value)) + return; // if something else disabled, or we are disabled, don't run + + ShadowCloneHelper.SetupAvatar(PlayerSetup.Instance._avatar); + } + + #endregion +} \ No newline at end of file diff --git a/BetterShadowClone/ModSettings.cs b/BetterShadowClone/ModSettings.cs new file mode 100644 index 0000000..aa37c5c --- /dev/null +++ b/BetterShadowClone/ModSettings.cs @@ -0,0 +1,45 @@ +using MelonLoader; +using UnityEngine; + +namespace NAK.BetterShadowClone; + +public static class ModSettings +{ + #region Melon Prefs + + private const string SettingsCategory = nameof(ShadowCloneMod); + + private static readonly MelonPreferences_Category Category = + MelonPreferences.CreateCategory(SettingsCategory); + + internal static readonly MelonPreferences_Entry EntryEnabled = + Category.CreateEntry("Enabled", true, + description: "Enable Mirror Clone."); + + internal static readonly MelonPreferences_Entry EntryUseShadowClone = + Category.CreateEntry("Use Shadow Clone", true, + description: "Should you have shadow clones?"); + + internal static readonly MelonPreferences_Entry EntryCopyMaterialToShadow = + Category.CreateEntry("Copy Material to Shadow", true, + description: "Should the shadow clone copy the material from the original mesh? Note: This can have a slight performance hit."); + + internal static readonly MelonPreferences_Entry EntryDebugHeadHide = + Category.CreateEntry("Debug Head Hide", false, + description: "Should head be hidden for first render?"); + + + #endregion + + internal static void Initialize() + { + foreach (MelonPreferences_Entry setting in Category.Entries) + setting.OnEntryValueChangedUntyped.Subscribe(OnSettingsChanged); + } + + private static void OnSettingsChanged(object oldValue = null, object newValue = null) + { + TransformHiderManager.s_DebugHeadHide = EntryDebugHeadHide.Value; + ShadowCloneManager.s_CopyMaterialsToShadow = EntryCopyMaterialToShadow.Value; + } +} \ No newline at end of file diff --git a/BetterShadowClone/Properties/AssemblyInfo.cs b/BetterShadowClone/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..f31ea23 --- /dev/null +++ b/BetterShadowClone/Properties/AssemblyInfo.cs @@ -0,0 +1,29 @@ +using MelonLoader; +using NAK.BetterShadowClone.Properties; +using System.Reflection; + +[assembly: AssemblyVersion(AssemblyInfoParams.Version)] +[assembly: AssemblyFileVersion(AssemblyInfoParams.Version)] +[assembly: AssemblyInformationalVersion(AssemblyInfoParams.Version)] +[assembly: AssemblyTitle(nameof(NAK.BetterShadowClone))] +[assembly: AssemblyCompany(AssemblyInfoParams.Author)] +[assembly: AssemblyProduct(nameof(NAK.BetterShadowClone))] + +[assembly: MelonInfo( + typeof(NAK.BetterShadowClone.ShadowCloneMod), + nameof(NAK.BetterShadowClone), + AssemblyInfoParams.Version, + AssemblyInfoParams.Author, + downloadLink: "https://github.com/NotAKidOnSteam/NAK_CVR_Mods/tree/main/ShadowCloneMod" +)] + +[assembly: MelonGame("Alpha Blend Interactive", "ChilloutVR")] +[assembly: MelonPlatform(MelonPlatformAttribute.CompatiblePlatforms.WINDOWS_X64)] +[assembly: MelonPlatformDomain(MelonPlatformDomainAttribute.CompatibleDomains.MONO)] + +namespace NAK.BetterShadowClone.Properties; +internal static class AssemblyInfoParams +{ + public const string Version = "1.0.0"; + public const string Author = "NotAKidoS & Exterrata"; +} \ No newline at end of file diff --git a/BetterShadowClone/README.md b/BetterShadowClone/README.md new file mode 100644 index 0000000..af9d39c --- /dev/null +++ b/BetterShadowClone/README.md @@ -0,0 +1,16 @@ +# EzCurls + +A mod that allows you to tune your finger curls to your liking. Supposedly can help with VR sign language, as raw finger curls are not that great for quick and precise gestures. + +The settings are not too coherent, it is mostly a bunch of things thrown at the wall, but it works for me. I hope it works for you too. + +--- + +Here is the block of text where I tell you this mod is not affiliated or endorsed by ABI. +https://documentation.abinteractive.net/official/legal/tos/#7-modding-our-games + +> This mod is an independent creation and is not affiliated with, supported by or approved by Alpha Blend Interactive. + +> Use of this mod is done so at the user's own risk and the creator cannot be held responsible for any issues arising from its use. + +> To the best of my knowledge, I have adhered to the Modding Guidelines established by Alpha Blend Interactive. diff --git a/BetterShadowClone/Resources/bettershadowclone.assets b/BetterShadowClone/Resources/bettershadowclone.assets new file mode 100644 index 0000000000000000000000000000000000000000..a80c90026db8cffb49034a3a99904004732320b3 GIT binary patch literal 9425 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 Xzmy29udSO(taj=*6R@}c{xlMt`RPha literal 0 HcmV?d00001 diff --git a/BetterShadowClone/ShadowClone/IShadowClone/IShadowClone.cs b/BetterShadowClone/ShadowClone/IShadowClone/IShadowClone.cs new file mode 100644 index 0000000..7d121b2 --- /dev/null +++ b/BetterShadowClone/ShadowClone/IShadowClone/IShadowClone.cs @@ -0,0 +1,11 @@ +using System; + +namespace NAK.BetterShadowClone; + +public interface IShadowClone : IDisposable +{ + bool IsValid { get; } + bool Process(); + void RenderForShadow(); + void RenderForUiCulling(); +} \ No newline at end of file diff --git a/BetterShadowClone/ShadowClone/IShadowClone/MeshShadowClone.cs b/BetterShadowClone/ShadowClone/IShadowClone/MeshShadowClone.cs new file mode 100644 index 0000000..f2670bd --- /dev/null +++ b/BetterShadowClone/ShadowClone/IShadowClone/MeshShadowClone.cs @@ -0,0 +1,154 @@ +using System; +using UnityEngine; +using UnityEngine.Rendering; + +namespace NAK.BetterShadowClone; + +public struct MeshShadowClone : IShadowClone +{ + // We technically don't need a clone mesh for MeshRenderer shadow clone handling, + // but as the shadows are also utilized for UI culling, we need to have a clone mesh. + // If we don't stick with UI culling, we can just set the shadowCastingMode to ShadowsOnly when player camera renders. + + // lame 2 frame init stuff + private const int FrameInitCount = 0; + private int _frameInitCounter; + private bool _hasInitialized; + + // shadow is used to cull ui, clone always exists + private readonly bool _shouldCastShadows; + private readonly MeshRenderer _mainMesh; + private readonly MeshRenderer _shadowMesh; + private readonly MeshFilter _shadowMeshFilter; + + // material copying (unity is shit) + private bool _hasShadowMaterials; + private readonly Material[] _shadowMaterials; + private readonly MaterialPropertyBlock _shadowMaterialBlock; + + #region IShadowClone Methods + + public bool IsValid => _mainMesh != null && _shadowMesh != null; + + public MeshShadowClone(MeshRenderer meshRenderer) + { + _mainMesh = meshRenderer; + MeshFilter _mainMeshFilter = meshRenderer.GetComponent(); + + if (_mainMesh == null + || _mainMesh.sharedMaterials == null + || _mainMesh.sharedMaterials.Length == 0 + || _mainMeshFilter == null + || _mainMeshFilter.sharedMesh == null) + { + Dispose(); + return; // no mesh! + } + + _shouldCastShadows = _mainMesh.shadowCastingMode != ShadowCastingMode.Off; + _mainMesh.shadowCastingMode = ShadowCastingMode.Off; // visual mesh doesn't cast shadows + + (_shadowMesh, _shadowMeshFilter) = ShadowCloneManager.InstantiateShadowClone(_mainMesh); + _shadowMesh.forceRenderingOff = true; + + // material copying shit + int materialCount = _mainMesh.sharedMaterials.Length; + Material shadowMaterial = ShadowCloneHelper.shadowMaterial; + + _shadowMaterialBlock = new MaterialPropertyBlock(); + _shadowMaterials = new Material[materialCount]; + for (int i = 0; i < materialCount; i++) _shadowMaterials[i] = shadowMaterial; + } + + public bool Process() + { + bool shouldRender = _mainMesh.enabled && _mainMesh.gameObject.activeInHierarchy; + + // copying behaviour of SkinnedShadowClone, to visually be the same when a mesh toggles + if (!shouldRender) + { + _frameInitCounter = 0; + _hasInitialized = false; + _shadowMesh.forceRenderingOff = true; + return false; + } + + if (_frameInitCounter >= FrameInitCount) + { + if (_hasInitialized) + return true; + + _hasInitialized = true; + return true; + } + + _frameInitCounter++; + return false; + } + + public void RenderForShadow() + { + _shadowMesh.shadowCastingMode = ShadowCastingMode.ShadowsOnly; + _shadowMesh.forceRenderingOff = !_shouldCastShadows; + + // shadow casting needs clone to have original materials (uv discard) + // we also want to respect material swaps... but this is fucking slow :( + + if (!ShadowCloneManager.s_CopyMaterialsToShadow) + return; + + if (_hasShadowMaterials) + { + // NOTE: will not handle material swaps unless Avatar Overrender Ui is on + _shadowMesh.sharedMaterials = _mainMesh.sharedMaterials; + _hasShadowMaterials = false; + } + + UpdateCloneMaterialProperties(); + } + + public void RenderForUiCulling() + { + _shadowMesh.shadowCastingMode = ShadowCastingMode.On; + _shadowMesh.forceRenderingOff = false; + + // UI culling needs clone to have write-to-depth shader + if (_hasShadowMaterials) return; + _shadowMesh.sharedMaterials = _shadowMaterials; + _hasShadowMaterials = true; + + // Not needed- MaterialPropertyBlock applied to renderer in RenderForShadow + //UpdateCloneMaterialProperties(); + } + + public void Dispose() + { + if (_shadowMesh == null) + return; // uh oh + + // Cleanup instanced Mesh & Materials + GameObject shadowMeshObject = _shadowMesh.gameObject; + UnityEngine.Object.Destroy(_shadowMeshFilter.sharedMesh); + UnityEngine.Object.Destroy(_shadowMeshFilter); + if (!_hasShadowMaterials) + { + var materials = _shadowMesh.sharedMaterials; + foreach (Material mat in materials) UnityEngine.Object.Destroy(mat); + } + UnityEngine.Object.Destroy(_shadowMesh); + UnityEngine.Object.Destroy(shadowMeshObject); + } + + #endregion + + #region Private Methods + + private void UpdateCloneMaterialProperties() + { + // copy material properties to shadow clone materials + _mainMesh.GetPropertyBlock(_shadowMaterialBlock); + _shadowMesh.SetPropertyBlock(_shadowMaterialBlock); + } + + #endregion +} \ No newline at end of file diff --git a/BetterShadowClone/ShadowClone/IShadowClone/SkinnedShadowClone.cs b/BetterShadowClone/ShadowClone/IShadowClone/SkinnedShadowClone.cs new file mode 100644 index 0000000..70fbdc1 --- /dev/null +++ b/BetterShadowClone/ShadowClone/IShadowClone/SkinnedShadowClone.cs @@ -0,0 +1,223 @@ +using System; +using UnityEngine; +using UnityEngine.Rendering; + +namespace NAK.BetterShadowClone; + +public class SkinnedShadowClone : IShadowClone +{ + private static readonly int s_SourceBufferId = Shader.PropertyToID("_sourceBuffer"); + private static readonly int s_TargetBufferId = Shader.PropertyToID("_targetBuffer"); + private static readonly int s_SourceBufferLayoutId = Shader.PropertyToID("_sourceBufferLayout"); + private static readonly int s_SourceRootMatrix = Shader.PropertyToID("_rootBoneMatrix"); + + // lame 2 frame init stuff + private const int FrameInitCount = 0; + private int _frameInitCounter; + private bool _hasInitialized; + + // shadow is used to cull ui, clone always exists + private readonly bool _shouldCastShadows; + private readonly SkinnedMeshRenderer _mainMesh; + private readonly MeshRenderer _shadowMesh; + private readonly MeshFilter _shadowMeshFilter; + private readonly Transform _rootBone; + + // clone copying + private GraphicsBuffer _graphicsBuffer; + private GraphicsBuffer _targetBuffer; + private int _threadGroups; + private int _bufferLayout; + + // material copying (unity is shit) + private bool _hasShadowMaterials; + private readonly Material[] _shadowMaterials; + private readonly MaterialPropertyBlock _shadowMaterialBlock; + + #region IShadowClone Methods + + // anything player can touch is suspect to death + public bool IsValid => _mainMesh != null && _shadowMesh != null && _rootBone != null; + + internal SkinnedShadowClone(SkinnedMeshRenderer renderer) + { + _mainMesh = renderer; + + if (_mainMesh == null + || _mainMesh.sharedMesh == null + || _mainMesh.sharedMaterials == null + || _mainMesh.sharedMaterials.Length == 0) + { + Dispose(); + return; // no mesh! + } + + _shouldCastShadows = _mainMesh.shadowCastingMode != ShadowCastingMode.Off; + _mainMesh.shadowCastingMode = ShadowCastingMode.Off; // visual mesh doesn't cast shadows + + (_shadowMesh, _shadowMeshFilter) = ShadowCloneManager.InstantiateShadowClone(_mainMesh); + _shadowMesh.forceRenderingOff = true; + + _rootBone = _mainMesh.rootBone; + _rootBone ??= _mainMesh.transform; // fallback to transform if no root bone + + // material copying shit + int materialCount = _mainMesh.sharedMaterials.Length; + Material shadowMaterial = ShadowCloneHelper.shadowMaterial; + + _shadowMaterialBlock = new MaterialPropertyBlock(); // TODO: check if we need one per material on renderer, idk if this is only first index + _shadowMaterials = new Material[materialCount]; + for (int i = 0; i < materialCount; i++) _shadowMaterials[i] = shadowMaterial; + } + + public bool Process() + { + // some people animate renderer.enabled instead of gameObject.activeInHierarchy + // do not disable shadow clone game object, it causes a flicker when re-enabled! + bool shouldRender = _mainMesh.enabled && _mainMesh.gameObject.activeInHierarchy; + + // GraphicsBuffer becomes stale when mesh is disabled + if (!shouldRender) + { + _frameInitCounter = 0; + _hasInitialized = false; + _shadowMesh.forceRenderingOff = true; // force off if mesh is disabled + return false; // TODO: dispose stale buffers + } + + // Unity is weird, so we need to wait 2 frames before we can get the graphics buffer + if (_frameInitCounter >= FrameInitCount) + { + if (_hasInitialized) + return true; + + _hasInitialized = true; + SetupGraphicsBuffer(); + return true; + } + + _frameInitCounter++; + return false; + } + + public void RenderForShadow() + { + ResetShadowClone(); + RenderShadowClone(); + } + + public void RenderForUiCulling() + { + ConfigureShadowCloneForUiCulling(); + RenderShadowClone(); + } + + public void Dispose() + { + if (_shadowMesh != null) + { + // Cleanup instanced Mesh & Materials + GameObject shadowMeshObject = _shadowMesh.gameObject; + UnityEngine.Object.Destroy(_shadowMeshFilter.sharedMesh); + UnityEngine.Object.Destroy(_shadowMeshFilter); + + if (!_hasShadowMaterials) + { + var materials = _shadowMesh.sharedMaterials; + foreach (Material mat in materials) UnityEngine.Object.Destroy(mat); + } + + UnityEngine.Object.Destroy(_shadowMesh); + UnityEngine.Object.Destroy(shadowMeshObject); + } + + _graphicsBuffer?.Dispose(); + _graphicsBuffer = null; + _targetBuffer?.Dispose(); + _targetBuffer = null; + } + + #endregion + + #region Private Methods + + // Unity is weird, so we need to wait 2 frames before we can get the graphics buffer + private void SetupGraphicsBuffer() + { + Mesh mesh = _mainMesh.sharedMesh; + Mesh shadowMesh = _shadowMesh.GetComponent().mesh; + + _bufferLayout = 0; + if (mesh.HasVertexAttribute(VertexAttribute.Position)) _bufferLayout += 3; + if (mesh.HasVertexAttribute(VertexAttribute.Normal)) _bufferLayout += 3; + if (mesh.HasVertexAttribute(VertexAttribute.Tangent)) _bufferLayout += 4; + _bufferLayout *= 4; // 4 bytes per float + + const float xThreadGroups = 64f; + _threadGroups = Mathf.CeilToInt(mesh.vertexCount / xThreadGroups); + + _mainMesh.vertexBufferTarget |= GraphicsBuffer.Target.Raw; + shadowMesh.vertexBufferTarget |= GraphicsBuffer.Target.Raw; + + _targetBuffer = shadowMesh.GetVertexBuffer(0); + + //Debug.Log($"Initialized! BufferLayout: {_bufferLayout}, GraphicsBuffer: {_graphicsBuffer != null}, TargetBuffer: {_targetBuffer != null}"); + } + + private void ResetShadowClone() + { + _shadowMesh.shadowCastingMode = ShadowCastingMode.ShadowsOnly; + _shadowMesh.forceRenderingOff = !_shouldCastShadows; + + // shadow casting needs clone to have original materials (uv discard) + // we also want to respect material swaps... but this is fucking slow :( + + if (!ShadowCloneManager.s_CopyMaterialsToShadow) + return; + + if (_hasShadowMaterials) + { + _shadowMesh.sharedMaterials = _mainMesh.sharedMaterials; + _hasShadowMaterials = false; + } + + UpdateCloneMaterialProperties(); + } + + private void ConfigureShadowCloneForUiCulling() + { + _shadowMesh.shadowCastingMode = ShadowCastingMode.On; + _shadowMesh.forceRenderingOff = false; + + // UI culling needs clone to have write-to-depth shader + if (_hasShadowMaterials) return; + _shadowMesh.sharedMaterials = _shadowMaterials; + _hasShadowMaterials = true; + + // Not needed- MaterialPropertyBlock applied to renderer in RenderForShadow + //UpdateCloneMaterialProperties(); + } + + private void RenderShadowClone() + { + // thanks sdraw, i suck at matrix math + Matrix4x4 rootMatrix = _mainMesh.localToWorldMatrix.inverse * Matrix4x4.TRS(_rootBone.position, _rootBone.rotation, Vector3.one); + + _graphicsBuffer = _mainMesh.GetVertexBuffer(); + ShadowCloneHelper.shader.SetMatrix(s_SourceRootMatrix, rootMatrix); + ShadowCloneHelper.shader.SetBuffer(0, s_SourceBufferId, _graphicsBuffer); + ShadowCloneHelper.shader.SetBuffer(0, s_TargetBufferId, _targetBuffer); + ShadowCloneHelper.shader.SetInt(s_SourceBufferLayoutId, _bufferLayout); + ShadowCloneHelper.shader.Dispatch(0, _threadGroups, 1, 1); + _graphicsBuffer.Release(); + } + + private void UpdateCloneMaterialProperties() + { + // copy material properties to shadow clone materials + _mainMesh.GetPropertyBlock(_shadowMaterialBlock); + _shadowMesh.SetPropertyBlock(_shadowMaterialBlock); + } + + #endregion +} \ No newline at end of file diff --git a/BetterShadowClone/ShadowClone/ShadowCloneManager.cs b/BetterShadowClone/ShadowClone/ShadowCloneManager.cs new file mode 100644 index 0000000..a8f6706 --- /dev/null +++ b/BetterShadowClone/ShadowClone/ShadowCloneManager.cs @@ -0,0 +1,217 @@ +using System.Collections.Generic; +using ABI_RC.Core; +using ABI_RC.Core.Player; +using ABI_RC.Core.Savior; +using MagicaCloth; +using UnityEngine; +using UnityEngine.Rendering; + +namespace NAK.BetterShadowClone; + +public class ShadowCloneManager : MonoBehaviour +{ + #region Singleton Implementation + + private static ShadowCloneManager _instance; + public static ShadowCloneManager Instance + { + get + { + if (_instance != null) return _instance; + _instance = new GameObject("NAK.ShadowCloneManager").AddComponent(); + DontDestroyOnLoad(_instance.gameObject); + return _instance; + } + } + + #endregion + + private const string ShadowClonePostfix = "_ShadowClone"; + //public const string CVRIgnoreForUiCulling = "CVRIgnoreForUiCulling"; // TODO: Shader Tag to ignore for UI culling? + + // Game cameras + private static Camera s_MainCamera; + private static Camera s_UiCamera; + + // Settings + internal static bool s_CopyMaterialsToShadow = true; + private static bool s_UseShadowToCullUi; + private const string ShadowCullUiSettingName = "ExperimentalAvatarOverrenderUI"; + + // Implementation + private bool _hasRenderedThisFrame; + + // Shadow Clones + private readonly List s_ShadowClones = new(); + public void AddShadowClone(IShadowClone clone) + => s_ShadowClones.Add(clone); + + // Debug + private bool _debugShadowProcessingTime; + private readonly StopWatch _stopWatch = new(); + + #region Unity Events + + private void Start() + { + if (Instance != null + && Instance != this) + { + Destroy(this); + return; + } + + UpdatePlayerCameras(); + + s_CopyMaterialsToShadow = ModSettings.EntryCopyMaterialToShadow.Value; + s_UseShadowToCullUi = MetaPort.Instance.settings.GetSettingsBool(ShadowCullUiSettingName); + MetaPort.Instance.settings.settingBoolChanged.AddListener(OnSettingsBoolChanged); + } + + private void OnEnable() + => Camera.onPreCull += MyOnPreCull; + + private void OnDisable() + => Camera.onPreCull -= MyOnPreCull; + + private void OnDestroy() + { + MetaPort.Instance.settings.settingBoolChanged.RemoveListener(OnSettingsBoolChanged); + } + + #endregion + + #region Shadow Clone Managment + + private void Update() + { + _hasRenderedThisFrame = false; + } + + private void MyOnPreCull(Camera cam) + { + bool forceRenderForUiCull = s_UseShadowToCullUi && cam == s_UiCamera; + if (_hasRenderedThisFrame && !forceRenderForUiCull) + return; + + _hasRenderedThisFrame = true; + + _stopWatch.Start(); + + for (int i = s_ShadowClones.Count - 1; i >= 0; i--) + { + IShadowClone clone = s_ShadowClones[i]; + if (clone is not { IsValid: true }) + { + clone?.Dispose(); + s_ShadowClones.RemoveAt(i); + continue; // invalid or dead + } + + if (!clone.Process()) continue; // not ready yet or disabled + + if (forceRenderForUiCull) + clone.RenderForUiCulling(); // last cam to render + else + clone.RenderForShadow(); // first cam to render + } + + _stopWatch.Stop(); + if (_debugShadowProcessingTime) Debug.Log($"ShadowCloneManager.MyOnPreCull({forceRenderForUiCull}) took {_stopWatch.ElapsedMilliseconds}ms"); + } + + #endregion + + #region Game Events + + public void OnAvatarCleared() + { + // Dispose all shadow clones BEFORE game unloads avatar + // Otherwise we memory leak the shadow clones mesh & material instances!!! + foreach (IShadowClone clone in s_ShadowClones) + clone.Dispose(); + s_ShadowClones.Clear(); + } + + private void OnSettingsBoolChanged(string settingName, bool settingValue) + { + if (settingName == ShadowCullUiSettingName) + s_UseShadowToCullUi = settingValue; + } + + private void OnVRModeSwitchCompleted(bool _, Camera __) + { + UpdatePlayerCameras(); + } + + #endregion + + #region Private Methods + + private static void UpdatePlayerCameras() + { + s_MainCamera = PlayerSetup.Instance.GetActiveCamera().GetComponent(); + s_UiCamera = s_MainCamera.transform.Find("_UICamera").GetComponent(); + //s_PortableCamera = PortableCamera.Instance.cameraComponent; + } + + #endregion + + #region Static Helpers + + internal static IShadowClone CreateShadowClone(Renderer renderer) + { + return renderer switch + { + SkinnedMeshRenderer skinnedMeshRenderer => new SkinnedShadowClone(skinnedMeshRenderer), + MeshRenderer meshRenderer => new MeshShadowClone(meshRenderer), + _ => null + }; + } + + internal static (MeshRenderer, MeshFilter) InstantiateShadowClone(SkinnedMeshRenderer meshRenderer) + { + GameObject shadowClone = new (meshRenderer.name + ShadowClonePostfix) { layer = CVRLayers.PlayerClone }; + shadowClone.transform.SetParent(meshRenderer.transform, false); + shadowClone.transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity); + shadowClone.transform.localScale = Vector3.one; + + MeshRenderer newMesh = shadowClone.AddComponent(); + MeshFilter newMeshFilter = shadowClone.AddComponent(); + + ShadowCloneHelper.ConfigureRenderer(newMesh, true); + + // only shadow clone should cast shadows + newMesh.shadowCastingMode = ShadowCastingMode.ShadowsOnly; + + // copy mesh and materials + newMeshFilter.sharedMesh = meshRenderer.sharedMesh; + newMesh.sharedMaterials = meshRenderer.sharedMaterials; + + return (newMesh, newMeshFilter); + } + + internal static (MeshRenderer, MeshFilter) InstantiateShadowClone(MeshRenderer meshRenderer) + { + GameObject shadowClone = new (meshRenderer.name + ShadowClonePostfix) { layer = CVRLayers.PlayerClone }; + shadowClone.transform.SetParent(meshRenderer.transform, false); + shadowClone.transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity); + shadowClone.transform.localScale = Vector3.one; + + MeshRenderer newMesh = shadowClone.AddComponent(); + MeshFilter newMeshFilter = shadowClone.AddComponent(); + + ShadowCloneHelper.ConfigureRenderer(newMesh, true); + + // only shadow clone should cast shadows + newMesh.shadowCastingMode = ShadowCastingMode.ShadowsOnly; + + // copy mesh and materials + newMeshFilter.sharedMesh = meshRenderer.GetComponent().sharedMesh; + newMesh.sharedMaterials = meshRenderer.sharedMaterials; + + return (newMesh, newMeshFilter); + } + + #endregion +} \ No newline at end of file diff --git a/BetterShadowClone/ShadowCloneHelper.cs b/BetterShadowClone/ShadowCloneHelper.cs new file mode 100644 index 0000000..6b66017 --- /dev/null +++ b/BetterShadowClone/ShadowCloneHelper.cs @@ -0,0 +1,142 @@ +using System; +using System.Collections.Generic; +using ABI_RC.Core; +using UnityEngine; +using UnityEngine.Rendering; +using Object = UnityEngine.Object; + +namespace NAK.BetterShadowClone; + +public static class ShadowCloneHelper +{ + public static ComputeShader shader; + public static Material shadowMaterial; + + #region Avatar Setup + + public static void SetupAvatar(GameObject avatar) + { + Animator animator = avatar.GetComponent(); + if (animator == null || animator.avatar == null || animator.avatar.isHuman == false) + { + ShadowCloneMod.Logger.Warning("Avatar is not humanoid!"); + return; + } + + Transform headBone = animator.GetBoneTransform(HumanBodyBones.Head); + if (headBone == null) + { + ShadowCloneMod.Logger.Warning("Head bone not found!"); + return; + } + + var renderers = avatar.GetComponentsInChildren(true); + if (renderers == null || renderers.Length == 0) + { + ShadowCloneMod.Logger.Warning("No renderers found!"); + return; + } + + // create shadow clones + ProcessRenderers(renderers, avatar.transform, headBone); + } + + private static void ProcessRenderers(IEnumerable renderers, Transform root, Transform headBone) + { + var exclusions = CollectExclusions2(root, headBone); + + foreach (Renderer renderer in renderers) + { + ConfigureRenderer(renderer); + + if (ModSettings.EntryUseShadowClone.Value) + { + IShadowClone clone = ShadowCloneManager.CreateShadowClone(renderer); + if (clone != null) ShadowCloneManager.Instance.AddShadowClone(clone); + } + + TransformHiderManager.CreateTransformHider(renderer, exclusions); + } + } + + #endregion + + #region FPR Exclusion Processing + + private static Dictionary CollectExclusions2(Transform root, Transform headBone) + { + // add an fpr exclusion to the head bone + headBone.gameObject.AddComponent().target = headBone; + + // get all FPRExclusions + var fprExclusions = root.GetComponentsInChildren(true).ToList(); + + // get all valid exclusion targets, and destroy invalid exclusions + Dictionary exclusionTargetRoots = new(); + for (int i = fprExclusions.Count - 1; i >= 0; i--) + { + FPRExclusion exclusion = fprExclusions[i]; + if (exclusion.target == null) + { + Object.Destroy(exclusion); + continue; + } + + exclusionTargetRoots.Add(exclusion.target, exclusion); + } + + // process each FPRExclusion (recursive) + foreach (FPRExclusion exclusion in fprExclusions) + ProcessExclusion(exclusion, exclusion.target); + + // log totals + ShadowCloneMod.Logger.Msg($"Exclusions: {fprExclusions.Count}"); + return exclusionTargetRoots; + + void ProcessExclusion(FPRExclusion exclusion, Transform transform) + { + if (exclusionTargetRoots.ContainsKey(transform) + && exclusionTargetRoots[transform] != exclusion) return; // found other exclusion root + + exclusion.affectedChildren.Add(transform); // associate with the exclusion + + foreach (Transform child in transform) + ProcessExclusion(exclusion, child); // process children + } + } + + #endregion + + #region Generic Renderer Configuration + + internal static void ConfigureRenderer(Renderer renderer, bool isShadowClone = false) + { + // generic optimizations + renderer.motionVectorGenerationMode = MotionVectorGenerationMode.ForceNoMotion; + + // don't let visual/shadow mesh cull in weird worlds + renderer.allowOcclusionWhenDynamic = false; // (third person stripped local player naked when camera was slightly occluded) + + // shadow clone optimizations (always MeshRenderer) + if (isShadowClone) + { + renderer.receiveShadows = false; + renderer.lightProbeUsage = LightProbeUsage.Off; + renderer.reflectionProbeUsage = ReflectionProbeUsage.Off; + return; + } + + if (renderer is not SkinnedMeshRenderer skinnedMeshRenderer) + return; + + // GraphicsBuffer becomes stale randomly otherwise ??? + //skinnedMeshRenderer.updateWhenOffscreen = true; + + // skin mesh renderer optimizations + skinnedMeshRenderer.skinnedMotionVectors = false; + skinnedMeshRenderer.forceMatrixRecalculationPerRender = false; // expensive + skinnedMeshRenderer.quality = SkinQuality.Bone4; + } + + #endregion +} \ No newline at end of file diff --git a/BetterShadowClone/TransformHider/FPRExclusion.cs b/BetterShadowClone/TransformHider/FPRExclusion.cs new file mode 100644 index 0000000..7c713f5 --- /dev/null +++ b/BetterShadowClone/TransformHider/FPRExclusion.cs @@ -0,0 +1,30 @@ +using UnityEngine; + +namespace NAK.BetterShadowClone; + +/// +/// Manual exclusion component for the TransformHider (FPR) system. +/// Allows you to manually hide and show a transform that would otherwise be hidden. +/// +public class FPRExclusion : MonoBehaviour +{ + public Transform target; + + internal List affectedChildren = new(); + + [NonSerialized] + internal ITransformHider[] relevantHiders; + + private void OnEnable() + => SetFPRState(true); + + private void OnDisable() + => SetFPRState(false); + + private void SetFPRState(bool state) + { + if (relevantHiders == null) return; // no hiders to set + foreach (ITransformHider hider in relevantHiders) + hider.IsActive = state; + } +} \ No newline at end of file diff --git a/BetterShadowClone/TransformHider/ITransformHider/ITransformHider.cs b/BetterShadowClone/TransformHider/ITransformHider/ITransformHider.cs new file mode 100644 index 0000000..cd4a94a --- /dev/null +++ b/BetterShadowClone/TransformHider/ITransformHider/ITransformHider.cs @@ -0,0 +1,11 @@ +namespace NAK.BetterShadowClone; + +public interface ITransformHider : IDisposable +{ + bool IsActive { get; set; } + bool IsValid { get; } + bool Process(); + bool PostProcess(); + void HideTransform(); + void ShowTransform(); +} \ No newline at end of file diff --git a/BetterShadowClone/TransformHider/ITransformHider/MeshTransformHider.cs b/BetterShadowClone/TransformHider/ITransformHider/MeshTransformHider.cs new file mode 100644 index 0000000..69e174f --- /dev/null +++ b/BetterShadowClone/TransformHider/ITransformHider/MeshTransformHider.cs @@ -0,0 +1,86 @@ +using System; +using UnityEngine; +using UnityEngine.Rendering; + +namespace NAK.BetterShadowClone; + +public class MeshTransformHider : ITransformHider +{ + // lame 2 frame init stuff + private const int FrameInitCount = 0; + private int _frameInitCounter; + private bool _hasInitialized; + private bool _markedForDeath; + + // mesh + private readonly MeshRenderer _mainMesh; + private bool _enabledState; + + #region ITransformHider Methods + + public bool IsActive { get; set; } = true; // default hide, but FPRExclusion can override + + // anything player can touch is suspect to death + public bool IsValid => _mainMesh != null && !_markedForDeath; + + public MeshTransformHider(MeshRenderer renderer) + { + _mainMesh = renderer; + + if (_mainMesh == null + || _mainMesh.sharedMaterials == null + || _mainMesh.sharedMaterials.Length == 0) + { + Dispose(); + } + } + + public bool Process() + { + bool shouldRender = _mainMesh.enabled && _mainMesh.gameObject.activeInHierarchy; + + // GraphicsBuffer becomes stale when mesh is disabled + if (!shouldRender) + { + _frameInitCounter = 0; + _hasInitialized = false; + return false; + } + + // Unity is weird, so we need to wait 2 frames before we can get the graphics buffer + if (_frameInitCounter >= FrameInitCount) + { + if (_hasInitialized) + return true; + + _hasInitialized = true; + return true; + } + + _frameInitCounter++; + return false; + } + + public bool PostProcess() + { + return true; + } + + public void HideTransform() + { + _enabledState = _mainMesh.enabled; + _mainMesh.enabled = false; + } + + public void ShowTransform() + { + _mainMesh.enabled = _enabledState; + } + + public void Dispose() + { + _markedForDeath = true; + } + + #endregion +} \ No newline at end of file diff --git a/BetterShadowClone/TransformHider/ITransformHider/SkinnedTransformHider.cs b/BetterShadowClone/TransformHider/ITransformHider/SkinnedTransformHider.cs new file mode 100644 index 0000000..fc0f285 --- /dev/null +++ b/BetterShadowClone/TransformHider/ITransformHider/SkinnedTransformHider.cs @@ -0,0 +1,191 @@ +using System; +using UnityEngine; +using UnityEngine.Rendering; + +namespace NAK.BetterShadowClone; + +public class SkinnedTransformHider : ITransformHider +{ + private static readonly int s_Pos = Shader.PropertyToID("pos"); + private static readonly int s_BufferLayout = Shader.PropertyToID("bufferLayout"); + private static readonly int s_WeightedCount = Shader.PropertyToID("weightedCount"); + private static readonly int s_WeightedVertices = Shader.PropertyToID("weightedVertices"); + private static readonly int s_VertexBuffer = Shader.PropertyToID("VertexBuffer"); + + // lame 2 frame init stuff + private const int FrameInitCount = 0; + private int _frameInitCounter; + private bool _hasInitialized; + private bool _markedForDeath; + + // mesh & bone + private readonly Transform _shrinkBone; + private readonly SkinnedMeshRenderer _mainMesh; + private readonly Transform _rootBone; + + // exclusion + private readonly FPRExclusion _exclusion; + + // hider stuff + private GraphicsBuffer _graphicsBuffer; + private int _bufferLayout; + + private ComputeBuffer _computeBuffer; + private int _vertexCount; + private int _threadGroups; + + #region ITransformHider Methods + + public bool IsActive { get; set; } = true; // default hide, but FPRExclusion can override + + // anything player can touch is suspect to death + public bool IsValid => _mainMesh != null && _shrinkBone != null && !_markedForDeath; + + public SkinnedTransformHider(SkinnedMeshRenderer renderer, FPRExclusion exclusion) + { + _mainMesh = renderer; + _shrinkBone = exclusion.target; + _exclusion = exclusion; + + if (_exclusion == null + || _shrinkBone == null + || _mainMesh == null + || _mainMesh.sharedMesh == null + || _mainMesh.sharedMaterials == null + || _mainMesh.sharedMaterials.Length == 0) + { + Dispose(); + return; // no mesh or bone! + } + + // find the head vertices + var exclusionVerts = FindExclusionVertList(); + if (exclusionVerts.Count == 0) + { + Dispose(); + return; // no head vertices! + } + + _rootBone = _mainMesh.rootBone; + _rootBone ??= _mainMesh.transform; // fallback to transform if no root bone + + _vertexCount = exclusionVerts.Count; + _computeBuffer = new ComputeBuffer(_vertexCount, sizeof(int)); + _computeBuffer.SetData(exclusionVerts.ToArray()); + } + + public bool Process() + { + bool shouldRender = _mainMesh.enabled && _mainMesh.gameObject.activeInHierarchy; + + // GraphicsBuffer becomes stale when mesh is disabled + if (!shouldRender) + { + _frameInitCounter = 0; + _hasInitialized = false; + return false; + } + + // Unity is weird, so we need to wait 2 frames before we can get the graphics buffer + if (_frameInitCounter >= FrameInitCount) + { + if (_hasInitialized) + return true; + + _hasInitialized = true; + SetupGraphicsBuffer(); + return true; + } + + _mainMesh.forceRenderingOff = true; // force off if mesh is disabled + + _frameInitCounter++; + return false; + } + + public bool PostProcess() + { + return false; // not needed + } + + public void HideTransform() + { + _mainMesh.forceRenderingOff = false; + + // probably fine + Vector3 pos = _rootBone.transform.InverseTransformPoint(_shrinkBone.position) * _rootBone.lossyScale.y; + + _graphicsBuffer = _mainMesh.GetVertexBuffer(); + TransformHiderManager.shader.SetVector(s_Pos, pos); + TransformHiderManager.shader.SetInt(s_WeightedCount, _vertexCount); + TransformHiderManager.shader.SetInt(s_BufferLayout, _bufferLayout); + TransformHiderManager.shader.SetBuffer(0, s_WeightedVertices, _computeBuffer); + TransformHiderManager.shader.SetBuffer(0, s_VertexBuffer, _graphicsBuffer); + TransformHiderManager.shader.Dispatch(0, _threadGroups, 1, 1); + _graphicsBuffer.Release(); + } + + public void ShowTransform() + { + // not needed + } + + public void Dispose() + { + _markedForDeath = true; + _graphicsBuffer?.Dispose(); + _graphicsBuffer = null; + _computeBuffer?.Dispose(); + _computeBuffer = null; + } + + #endregion + + #region Private Methods + + // Unity is weird, so we need to wait 2 frames before we can get the graphics buffer + private void SetupGraphicsBuffer() + { + Mesh mesh = _mainMesh.sharedMesh; + + _bufferLayout = 0; + if (mesh.HasVertexAttribute(VertexAttribute.Position)) _bufferLayout += 3; + if (mesh.HasVertexAttribute(VertexAttribute.Normal)) _bufferLayout += 3; + if (mesh.HasVertexAttribute(VertexAttribute.Tangent)) _bufferLayout += 4; + + // ComputeShader is doing bitshift so we dont need to multiply by 4 + //_bufferLayout *= 4; // 4 bytes per float + + const float xThreadGroups = 64f; + _threadGroups = Mathf.CeilToInt(mesh.vertexCount / xThreadGroups); + + _mainMesh.vertexBufferTarget |= GraphicsBuffer.Target.Raw; + } + + private List FindExclusionVertList() + { + var boneWeights = _mainMesh.sharedMesh.boneWeights; + var bones = _exclusion.affectedChildren; + + HashSet weights = new(); //get indexs of child bones + for (int i = 0; i < _mainMesh.bones.Length; i++) + if (bones.Contains(_mainMesh.bones[i])) weights.Add(i); + + List headVertices = new(); + + for (int i = 0; i < boneWeights.Length; i++) + { + BoneWeight weight = boneWeights[i]; + const float minWeightThreshold = 0.2f; + if (weights.Contains(weight.boneIndex0) && weight.weight0 > minWeightThreshold + || weights.Contains(weight.boneIndex1) && weight.weight1 > minWeightThreshold + || weights.Contains(weight.boneIndex2) && weight.weight2 > minWeightThreshold + || weights.Contains(weight.boneIndex3) && weight.weight3 > minWeightThreshold) + headVertices.Add(i); + } + + return headVertices; + } + + #endregion +} \ No newline at end of file diff --git a/BetterShadowClone/TransformHider/TransformHiderManager.cs b/BetterShadowClone/TransformHider/TransformHiderManager.cs new file mode 100644 index 0000000..13040e0 --- /dev/null +++ b/BetterShadowClone/TransformHider/TransformHiderManager.cs @@ -0,0 +1,237 @@ +using System.Collections.Generic; +using ABI_RC.Core.Player; +using ABI_RC.Core.Savior; +using ABI_RC.Systems.Camera; +using MagicaCloth; +using UnityEngine; + +namespace NAK.BetterShadowClone; + +// Built on top of Koneko's BoneHider but to mimic the ShadowCloneManager + +public class TransformHiderManager : MonoBehaviour +{ + public static ComputeShader shader; + + #region Singleton Implementation + + private static TransformHiderManager _instance; + public static TransformHiderManager Instance + { + get + { + if (_instance != null) return _instance; + _instance = new GameObject("Koneko.TransformHiderManager").AddComponent(); + DontDestroyOnLoad(_instance.gameObject); + return _instance; + } + } + + #endregion + + // Game cameras + private static Camera s_MainCamera; + private static Camera s_UiCamera; + + // Settings + internal static bool s_DebugHeadHide; + + // Implementation + private bool _hasRenderedThisFrame; + + // Shadow Clones + private readonly List s_TransformHider = new(); + public void AddTransformHider(ITransformHider clone) + => s_TransformHider.Add(clone); + + // Debug + private bool _debugHeadHiderProcessingTime; + private readonly StopWatch _stopWatch = new(); + + #region Unity Events + + private void Start() + { + if (Instance != null + && Instance != this) + { + Destroy(this); + return; + } + + UpdatePlayerCameras(); + + s_DebugHeadHide = ModSettings.EntryDebugHeadHide.Value; + } + + private void OnEnable() + { + Camera.onPreRender += MyOnPreRender; + Camera.onPostRender += MyOnPostRender; + } + + private void OnDisable() + { + Camera.onPreRender -= MyOnPreRender; + Camera.onPostRender -= MyOnPostRender; + } + + #endregion + + #region Transform Hider Managment + + private void Update() + { + _hasRenderedThisFrame = false; + } + + private void MyOnPreRender(Camera cam) + { + if (_hasRenderedThisFrame) + return; // can only hide head once per frame + + if (cam != s_MainCamera // only hide in player cam, or if debug is on + && !s_DebugHeadHide) + return; + + if (!CheckPlayerCamWithinRange()) + return; // player is too far away (likely HoloPort or Sitting) + + if (!ShadowCloneMod.CheckWantsToHideHead(cam)) + return; // listener said no (Third Person, etc) + + _hasRenderedThisFrame = true; + + _stopWatch.Start(); + + for (int i = s_TransformHider.Count - 1; i >= 0; i--) + { + ITransformHider hider = s_TransformHider[i]; + if (hider is not { IsValid: true }) + { + hider?.Dispose(); + s_TransformHider.RemoveAt(i); + continue; // invalid or dead + } + + if (!hider.Process()) continue; // not ready yet or disabled + + if (hider.IsActive) hider.HideTransform(); + } + + _stopWatch.Stop(); + if (_debugHeadHiderProcessingTime) Debug.Log($"TransformHiderManager.MyOnPreRender({s_DebugHeadHide}) took {_stopWatch.ElapsedMilliseconds}ms"); + } + + private void MyOnPostRender(Camera cam) + { + if (cam != s_UiCamera) return; // ui camera is expected to render last + + for (int i = s_TransformHider.Count - 1; i >= 0; i--) + { + ITransformHider hider = s_TransformHider[i]; + if (hider is not { IsValid: true }) + { + hider?.Dispose(); + s_TransformHider.RemoveAt(i); + continue; // invalid or dead + } + + if (!hider.PostProcess()) continue; // does not need post processing + + if (hider.IsActive) hider.ShowTransform(); + } + } + + #endregion + + #region Game Events + + public void OnAvatarCleared() + { + // Dispose all shadow clones BEFORE game unloads avatar + // Otherwise we memory leak the shadow clones mesh & material instances!!! + foreach (ITransformHider hider in s_TransformHider) + hider.Dispose(); + s_TransformHider.Clear(); + } + + private void OnVRModeSwitchCompleted(bool _, Camera __) + { + UpdatePlayerCameras(); + } + + #endregion + + #region Private Methods + + private static void UpdatePlayerCameras() + { + s_MainCamera = PlayerSetup.Instance.GetActiveCamera().GetComponent(); + s_UiCamera = s_MainCamera.transform.Find("_UICamera").GetComponent(); + } + + private static bool CheckPlayerCamWithinRange() + { + if (PlayerSetup.Instance == null) + return false; // hack + + const float MinHeadHidingRange = 0.5f; + Vector3 playerHeadPos = PlayerSetup.Instance.GetViewWorldPosition(); + Vector3 playerCamPos = s_MainCamera.transform.position; + float scaleModifier = PlayerSetup.Instance.GetPlaySpaceScale(); + return (Vector3.Distance(playerHeadPos, playerCamPos) < (MinHeadHidingRange * scaleModifier)); + } + + #endregion + + #region Static Helpers + + internal static bool IsLegacyFPRExcluded(Component renderer) + => renderer.gameObject.name.Contains("[FPR]"); + + internal static ITransformHider CreateTransformHider(Component renderer, Transform bone) + { + if (IsLegacyFPRExcluded(renderer)) + return null; + + return renderer switch + { + //SkinnedMeshRenderer skinnedMeshRenderer => new SkinnedTransformHider(skinnedMeshRenderer, bone), + MeshRenderer meshRenderer => new MeshTransformHider(meshRenderer), + _ => null + }; + } + + internal static void CreateTransformHider(Component renderer, Dictionary exclusions) + { + if (IsLegacyFPRExcluded(renderer)) + return; + + if (renderer is SkinnedMeshRenderer skinnedMeshRenderer) + { + // get all bones for renderer + var bones = skinnedMeshRenderer.bones; + List fprExclusions = new(); + + // check if any bones are excluded + foreach (Transform bone in bones) + { + if (!exclusions.TryGetValue(bone, out FPRExclusion exclusion)) + continue; + + fprExclusions.Add(exclusion); + } + + foreach (FPRExclusion exclusion in fprExclusions) + { + ITransformHider hider = new SkinnedTransformHider(skinnedMeshRenderer, exclusion); + Instance.AddTransformHider(hider); + } + } + + return; + } + + #endregion +} \ No newline at end of file diff --git a/BetterShadowClone/format.json b/BetterShadowClone/format.json new file mode 100644 index 0000000..6a8d72c --- /dev/null +++ b/BetterShadowClone/format.json @@ -0,0 +1,23 @@ +{ + "_id": -1, + "name": "EzCurls", + "modversion": "1.0.0", + "gameversion": "2023r173", + "loaderversion": "0.6.1", + "modtype": "Mod", + "author": "NotAKidoS", + "description": "A mod that allows you to tune your finger curls to your liking. Supposedly can help with VR sign language, as raw finger curls are not that great for quick and precise gestures.\n\nThe settings are not too coherent, it is mostly a bunch of things thrown at the wall, but it works for me. I hope it works for you too.", + "searchtags": [ + "curls", + "fingers", + "index", + "knuckles" + ], + "requirements": [ + "UIExpansionKit" + ], + "downloadlink": "https://github.com/NotAKidOnSteam/NAK_CVR_Mods/releases/download/r24/EzCurls.dll", + "sourcelink": "https://github.com/NotAKidOnSteam/NAK_CVR_Mods/tree/main/EzCurls/", + "changelog": "- Initial CVRMG release", + "embedcolor": "7d7d7d" +} \ No newline at end of file