natcoso9955/0A-KFCommonUtilityLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Upload from upload_mods.ps1

Browse Source
This commit is contained in:
Nathaniel Cosford
2025-06-04 16:13:32 +09:30
commit 7345f42201
470 changed files with 51966 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
KFAttached/Animation/MonoBehaviours/AnimatorWrapper/AnimatorWrapper.cs Normal file
View File

@@ -0,0 +1,131 @@
using System.Collections.Generic;
using UnityEngine;
public class AnimatorWrapper : IAnimatorWrapper
{
private Animator animator;
public bool IsValid => animator;
public AnimatorWrapper(Animator animator) => this.animator = animator;
public void CrossFade(string stateName, float transitionDuration) => animator.CrossFade(stateName, transitionDuration);
public void CrossFade(string stateName, float transitionDuration, int layer) => animator.CrossFade(stateName, transitionDuration, layer);
public void CrossFade(string stateName, float transitionDuration, int layer, float normalizedTime) => animator.CrossFade(stateName, transitionDuration, layer, normalizedTime);
public void CrossFade(int stateNameHash, float transitionDuration) => animator.CrossFade(stateNameHash, transitionDuration);
public void CrossFade(int stateNameHash, float transitionDuration, int layer) => animator.CrossFade(stateNameHash, transitionDuration, layer);
public void CrossFade(int stateNameHash, float transitionDuration, int layer, float normalizedTime) => animator.CrossFade(stateNameHash, transitionDuration, layer, normalizedTime);
public void CrossFadeInFixedTime(string stateName, float transitionDuration) => animator.CrossFadeInFixedTime(stateName, transitionDuration);
public void CrossFadeInFixedTime(string stateName, float transitionDuration, int layer) => animator.CrossFadeInFixedTime(stateName, transitionDuration, layer);
public void CrossFadeInFixedTime(string stateName, float transitionDuration, int layer, float fixedTime) => animator.CrossFadeInFixedTime(stateName, transitionDuration, layer, fixedTime);
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration) => animator.CrossFadeInFixedTime(stateNameHash, transitionDuration);
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration, int layer) => animator.CrossFadeInFixedTime(stateNameHash, transitionDuration, layer);
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration, int layer, float fixedTime) => animator.CrossFadeInFixedTime(stateNameHash, transitionDuration, layer, fixedTime);
public AnimatorTransitionInfo GetAnimatorTransitionInfo(int layerIndex) => animator.GetAnimatorTransitionInfo(layerIndex);
public bool GetBool(string name) => animator.GetBool(name);
public bool GetBool(int id) => animator.GetBool(id);
public AnimatorClipInfo[] GetCurrentAnimatorClipInfo(int layerIndex) => animator.GetCurrentAnimatorClipInfo(layerIndex);
public void GetCurrentAnimatorClipInfo(int layerIndex, List<AnimatorClipInfo> clips) => animator.GetCurrentAnimatorClipInfo(layerIndex, clips);
public int GetCurrentAnimatorClipInfoCount(int layerIndex) => animator.GetCurrentAnimatorClipInfoCount(layerIndex);
public AnimatorStateInfo GetCurrentAnimatorStateInfo(int layerIndex) => animator.GetCurrentAnimatorStateInfo(layerIndex);
public float GetFloat(string name) => animator.GetFloat(name);
public float GetFloat(int id) => animator.GetFloat(id);
public int GetInteger(string name) => animator.GetInteger(name);
public int GetInteger(int id) => animator.GetInteger(id);
public int GetLayerCount() => animator.layerCount;
public int GetLayerIndex(string layerName) => animator.GetLayerIndex(layerName);
public string GetLayerName(int layerIndex) => animator.GetLayerName(layerIndex);
public float GetLayerWeight(int layerIndex) => animator.GetLayerWeight(layerIndex);
public void GetNextAnimatorClipInfo(int layerIndex, List<AnimatorClipInfo> clips) => animator.GetNextAnimatorClipInfo(layerIndex, clips);
public AnimatorClipInfo[] GetNextAnimatorClipInfo(int layerIndex) => animator.GetNextAnimatorClipInfo(layerIndex);
public int GetNextAnimatorClipInfoCount(int layerIndex) => animator.GetNextAnimatorClipInfoCount(layerIndex);
public AnimatorStateInfo GetNextAnimatorStateInfo(int layerIndex) => animator.GetNextAnimatorStateInfo(layerIndex);
public AnimatorControllerParameter GetParameter(int index) => animator.GetParameter(index);
public int GetParameterCount() => animator.parameterCount;
public bool HasState(int layerIndex, int stateID) => animator.HasState(layerIndex, stateID);
public bool IsInTransition(int layerIndex) => animator.IsInTransition(layerIndex);
public bool IsParameterControlledByCurve(string name) => animator.IsParameterControlledByCurve(name);
public bool IsParameterControlledByCurve(int id) => animator.IsParameterControlledByCurve(id);
public void Play(string stateName) => animator.Play(stateName);
public void Play(string stateName, int layer) => animator.Play(stateName, layer);
public void Play(string stateName, int layer, float normalizedTime) => animator.Play(stateName, layer, normalizedTime);
public void Play(int stateNameHash) => animator.Play(stateNameHash);
public void Play(int stateNameHash, int layer) => animator.Play(stateNameHash, layer);
public void Play(int stateNameHash, int layer, float normalizedTime) => animator.Play(stateNameHash, layer, normalizedTime);
public void PlayInFixedTime(string stateName) => animator.PlayInFixedTime(stateName);
public void PlayInFixedTime(string stateName, int layer) => animator.PlayInFixedTime(stateName, layer);
public void PlayInFixedTime(string stateName, int layer, float fixedTime) => animator.PlayInFixedTime(stateName, layer, fixedTime);
public void PlayInFixedTime(int stateNameHash) => animator.PlayInFixedTime(stateNameHash);
public void PlayInFixedTime(int stateNameHash, int layer) => animator.PlayInFixedTime(stateNameHash, layer);
public void PlayInFixedTime(int stateNameHash, int layer, float fixedTime) => animator.PlayInFixedTime(stateNameHash, layer, fixedTime);
public void ResetTrigger(string name) => animator.ResetTrigger(name);
public void ResetTrigger(int id) => animator.ResetTrigger(id);
public void SetBool(string name, bool value) => animator.SetBool(name, value);
public void SetBool(int id, bool value) => animator.SetBool(id, value);
public void SetFloat(string name, float value) => animator.SetFloat(name, value);
public void SetFloat(int id, float value) => animator.SetFloat(id, value);
public void SetInteger(string name, int value) => animator.SetInteger(name, value);
public void SetInteger(int id, int value) => animator.SetInteger(id, value);
public void SetLayerWeight(int layerIndex, float weight) => animator.SetLayerWeight(layerIndex, weight);
public void SetTrigger(string name) => animator.SetTrigger(name);
public void SetTrigger(int id) => animator.SetTrigger(id);
}

11
KFAttached/Animation/MonoBehaviours/AnimatorWrapper/AnimatorWrapper.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 330523dd2a309f042a9aafdb565149c5
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

443
KFAttached/Animation/MonoBehaviours/AnimatorWrapper/AttachmentWrapper.cs Normal file
View File

@@ -0,0 +1,443 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
public class AttachmentWrapper : IAnimatorWrapper
{
public Animator[] animators;
public AttachmentWrapper(Animator[] animators)
{
this.animators = animators;
}
public bool IsValid => animators != null && animators.Length > 0;
public void CrossFade(string stateName, float transitionDuration)
{
foreach (var animator in animators)
{
animator.CrossFade(stateName, transitionDuration);
}
}
public void CrossFade(string stateName, float transitionDuration, int layer)
{
foreach (var animator in animators)
{
animator.CrossFade(stateName, transitionDuration, layer);
}
}
public void CrossFade(string stateName, float transitionDuration, int layer, float normalizedTime)
{
foreach (var animator in animators)
{
animator.CrossFade(stateName, transitionDuration, layer, normalizedTime);
}
}
public void CrossFade(int stateNameHash, float transitionDuration)
{
foreach (var animator in animators)
{
animator.CrossFade(stateNameHash, transitionDuration);
}
}
public void CrossFade(int stateNameHash, float transitionDuration, int layer)
{
foreach (var animator in animators)
{
animator.CrossFade(stateNameHash, transitionDuration, layer);
}
}
public void CrossFade(int stateNameHash, float transitionDuration, int layer, float normalizedTime)
{
foreach (var animator in animators)
{
animator.CrossFade(stateNameHash, transitionDuration, layer, normalizedTime);
}
}
public void CrossFadeInFixedTime(string stateName, float transitionDuration)
{
foreach (var animator in animators)
{
animator.CrossFadeInFixedTime(stateName, transitionDuration);
}
}
public void CrossFadeInFixedTime(string stateName, float transitionDuration, int layer)
{
foreach (var animator in animators)
{
animator.CrossFadeInFixedTime(stateName, transitionDuration, layer);
}
}
public void CrossFadeInFixedTime(string stateName, float transitionDuration, int layer, float fixedTime)
{
foreach (var animator in animators)
{
animator.CrossFadeInFixedTime(stateName, transitionDuration, layer, fixedTime);
}
}
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration)
{
foreach (var animator in animators)
{
animator.CrossFadeInFixedTime(stateNameHash, transitionDuration);
}
}
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration, int layer)
{
foreach (var animator in animators)
{
animator.CrossFadeInFixedTime(stateNameHash, transitionDuration, layer);
}
}
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration, int layer, float fixedTime)
{
foreach (var animator in animators)
{
animator.CrossFadeInFixedTime(stateNameHash, transitionDuration, layer, fixedTime);
}
}
public AnimatorTransitionInfo GetAnimatorTransitionInfo(int layerIndex)
{
return animators[0].GetAnimatorTransitionInfo(layerIndex);
}
public bool GetBool(string name)
{
return GetBool(Animator.StringToHash(name));
}
public bool GetBool(int id)
{
foreach (var animator in animators)
{
if (animator.GetBool(id))
return true;
}
return false;
}
public AnimatorClipInfo[] GetCurrentAnimatorClipInfo(int layerIndex)
{
return animators[0].GetCurrentAnimatorClipInfo(layerIndex);
}
public void GetCurrentAnimatorClipInfo(int layerIndex, List<AnimatorClipInfo> clips)
{
animators[0].GetCurrentAnimatorClipInfo(layerIndex, clips);
}
public int GetCurrentAnimatorClipInfoCount(int layerIndex)
{
return animators[0].GetCurrentAnimatorClipInfoCount(layerIndex);
}
public AnimatorStateInfo GetCurrentAnimatorStateInfo(int layerIndex)
{
return animators[0].GetCurrentAnimatorStateInfo(layerIndex);
}
public float GetFloat(string name)
{
return GetFloat(Animator.StringToHash(name));
}
public float GetFloat(int id)
{
foreach (var animator in animators)
{
float value = animator.GetFloat(id);
if (value != 0)
{
return value;
}
}
return 0;
}
public int GetInteger(string name)
{
return GetInteger(Animator.StringToHash(name));
}
public int GetInteger(int id)
{
foreach (var animator in animators)
{
int value = animator.GetInteger(id);
if (value != 0)
{
return value;
}
}
return 0;
}
public int GetLayerCount()
{
return animators[0].layerCount;
}
public int GetLayerIndex(string layerName)
{
return animators[0].GetLayerIndex(layerName);
}
public string GetLayerName(int layerIndex)
{
return animators[0].GetLayerName(layerIndex);
}
public float GetLayerWeight(int layerIndex)
{
return animators[0].GetLayerWeight(layerIndex);
}
public void GetNextAnimatorClipInfo(int layerIndex, List<AnimatorClipInfo> clips)
{
animators[0].GetNextAnimatorClipInfo(layerIndex, clips);
}
public AnimatorClipInfo[] GetNextAnimatorClipInfo(int layerIndex)
{
return animators[0].GetNextAnimatorClipInfo(layerIndex);
}
public int GetNextAnimatorClipInfoCount(int layerIndex)
{
return animators[0].GetNextAnimatorClipInfoCount(layerIndex);
}
public AnimatorStateInfo GetNextAnimatorStateInfo(int layerIndex)
{
return animators[0].GetNextAnimatorStateInfo(layerIndex);
}
public AnimatorControllerParameter GetParameter(int index)
{
return animators[0].GetParameter(index);
}
public int GetParameterCount()
{
return animators[0].parameterCount;
}
public bool HasState(int layerIndex, int stateID)
{
return animators[0].HasState(layerIndex, stateID);
}
public bool IsInTransition(int layerIndex)
{
return animators[0].IsInTransition(layerIndex);
}
public bool IsParameterControlledByCurve(string name)
{
return animators[0].IsParameterControlledByCurve(name);
}
public bool IsParameterControlledByCurve(int id)
{
return animators[0].IsParameterControlledByCurve(id);
}
public void Play(string stateName)
{
foreach (var animator in animators)
{
animator.Play(stateName);
}
}
public void Play(string stateName, int layer)
{
foreach (var animator in animators)
{
animator.Play(stateName, layer);
}
}
public void Play(string stateName, int layer, float normalizedTime)
{
foreach (var animator in animators)
{
animator.Play(stateName, layer, normalizedTime);
}
}
public void Play(int stateNameHash)
{
foreach (var animator in animators)
{
animator.Play(stateNameHash);
}
}
public void Play(int stateNameHash, int layer)
{
foreach (var animator in animators)
{
animator.Play(stateNameHash, layer);
}
}
public void Play(int stateNameHash, int layer, float normalizedTime)
{
foreach (var animator in animators)
{
animator.Play(stateNameHash, layer, normalizedTime);
}
}
public void PlayInFixedTime(string stateName)
{
foreach (var animator in animators)
{
animator.PlayInFixedTime(stateName);
}
}
public void PlayInFixedTime(string stateName, int layer)
{
foreach (var animator in animators)
{
animator.PlayInFixedTime(stateName, layer);
}
}
public void PlayInFixedTime(string stateName, int layer, float fixedTime)
{
foreach (var animator in animators)
{
animator.PlayInFixedTime(stateName, layer, fixedTime);
}
}
public void PlayInFixedTime(int stateNameHash)
{
foreach (var animator in animators)
{
animator.PlayInFixedTime(stateNameHash);
}
}
public void PlayInFixedTime(int stateNameHash, int layer)
{
foreach (var animator in animators)
{
animator.PlayInFixedTime(stateNameHash, layer);
}
}
public void PlayInFixedTime(int stateNameHash, int layer, float fixedTime)
{
foreach (var animator in animators)
{
animator.PlayInFixedTime(stateNameHash, layer, fixedTime);
}
}
public void ResetTrigger(string name)
{
foreach (var animator in animators)
{
animator.ResetTrigger(name);
}
}
public void ResetTrigger(int id)
{
foreach (var animator in animators)
{
animator.ResetTrigger(id);
}
}
public void SetBool(string name, bool value)
{
foreach (var animator in animators)
{
animator.SetBool(name, value);
}
}
public void SetBool(int id, bool value)
{
foreach (var animator in animators)
{
animator.SetBool(id, value);
}
}
public void SetFloat(string name, float value)
{
foreach (var animator in animators)
{
animator.SetFloat(name, value);
}
}
public void SetFloat(int id, float value)
{
foreach (var animator in animators)
{
animator.SetFloat(id, value);
}
}
public void SetInteger(string name, int value)
{
foreach (var animator in animators)
{
animator.SetInteger(name, value);
}
}
public void SetInteger(int id, int value)
{
foreach (var animator in animators)
{
animator.SetInteger(id, value);
}
}
public void SetLayerWeight(int layerIndex, float weight)
{
foreach (var animator in animators)
{
animator.SetLayerWeight(layerIndex, weight);
}
}
public void SetTrigger(string name)
{
foreach (var animator in animators)
{
animator.SetTrigger(name);
}
}
public void SetTrigger(int id)
{
foreach (var animator in animators)
{
animator.SetTrigger(id);
}
}
}

11
KFAttached/Animation/MonoBehaviours/AnimatorWrapper/AttachmentWrapper.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 9aff1989baed1884fb65a80108d5ab68
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

92
KFAttached/Animation/MonoBehaviours/AnimatorWrapper/PlayableWrapper.cs Normal file
View File

@@ -0,0 +1,92 @@
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Animations;
using UnityEngine.Playables;
public class PlayableWrapper : IAnimatorWrapper
{
private AnimatorControllerPlayable playable;
public PlayableWrapper(AnimatorControllerPlayable playable)
{
this.playable = playable;
}
public bool IsValid => playable.IsValid();
public float GetFloat(string name) => playable.GetFloat(name);
public float GetFloat(int id) => playable.GetFloat(id);
public void SetFloat(string name, float value) => playable.SetFloat(name, value);
public void SetFloat(int id, float value) => playable.SetFloat(id, value);
public bool GetBool(string name) => playable.GetBool(name);
public bool GetBool(int id) => playable.GetBool(id);
public void SetBool(string name, bool value) => playable.SetBool(name, value);
public void SetBool(int id, bool value) => playable.SetBool(id, value);
public int GetInteger(string name) => playable.GetInteger(name);
public int GetInteger(int id) => playable.GetInteger(id);
public void SetInteger(string name, int value) => playable.SetInteger(name, value);
public void SetInteger(int id, int value) => playable.SetInteger(id, value);
public void SetTrigger(string name) => playable.SetTrigger(name);
public void SetTrigger(int id) => playable.SetTrigger(id);
public void ResetTrigger(string name) => playable.ResetTrigger(name);
public void ResetTrigger(int id) => playable.ResetTrigger(id);
public bool IsParameterControlledByCurve(string name) => playable.IsParameterControlledByCurve(name);
public bool IsParameterControlledByCurve(int id) => playable.IsParameterControlledByCurve(id);
public int GetLayerCount() => playable.GetLayerCount();
public string GetLayerName(int layerIndex) => playable.GetLayerName(layerIndex);
public int GetLayerIndex(string layerName) => playable.GetLayerIndex(layerName);
public float GetLayerWeight(int layerIndex) => playable.GetLayerWeight(layerIndex);
public void SetLayerWeight(int layerIndex, float weight) => playable.SetLayerWeight(layerIndex, weight);
public AnimatorStateInfo GetCurrentAnimatorStateInfo(int layerIndex) => playable.GetCurrentAnimatorStateInfo(layerIndex);
public AnimatorStateInfo GetNextAnimatorStateInfo(int layerIndex) => playable.GetNextAnimatorStateInfo(layerIndex);
public AnimatorTransitionInfo GetAnimatorTransitionInfo(int layerIndex) => playable.GetAnimatorTransitionInfo(layerIndex);
public AnimatorClipInfo[] GetCurrentAnimatorClipInfo(int layerIndex) => playable.GetCurrentAnimatorClipInfo(layerIndex);
public void GetCurrentAnimatorClipInfo(int layerIndex, List<AnimatorClipInfo> clips) => playable.GetCurrentAnimatorClipInfo(layerIndex, clips);
public void GetNextAnimatorClipInfo(int layerIndex, List<AnimatorClipInfo> clips) => playable.GetNextAnimatorClipInfo(layerIndex, clips);
public int GetCurrentAnimatorClipInfoCount(int layerIndex) => playable.GetCurrentAnimatorClipInfoCount(layerIndex);
public int GetNextAnimatorClipInfoCount(int layerIndex) => playable.GetNextAnimatorClipInfoCount(layerIndex);
public AnimatorClipInfo[] GetNextAnimatorClipInfo(int layerIndex) => playable.GetNextAnimatorClipInfo(layerIndex);
public bool IsInTransition(int layerIndex) => playable.IsInTransition(layerIndex);
public int GetParameterCount() => playable.GetParameterCount();
public AnimatorControllerParameter GetParameter(int index) => playable.GetParameter(index);
public void CrossFadeInFixedTime(string stateName, float transitionDuration) => playable.CrossFadeInFixedTime(stateName, transitionDuration);
public void CrossFadeInFixedTime(string stateName, float transitionDuration, int layer) => playable.CrossFadeInFixedTime(stateName, transitionDuration, layer);
public void CrossFadeInFixedTime(string stateName, float transitionDuration, int layer, float fixedTime) => playable.CrossFadeInFixedTime(stateName, transitionDuration, layer, fixedTime);
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration) => playable.CrossFadeInFixedTime(stateNameHash, transitionDuration);
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration, int layer) => playable.CrossFadeInFixedTime(stateNameHash, transitionDuration, layer);
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration, int layer, float fixedTime) => playable.CrossFadeInFixedTime(stateNameHash, transitionDuration, layer, fixedTime);
public void CrossFade(string stateName, float transitionDuration) => playable.CrossFade(stateName, transitionDuration);
public void CrossFade(string stateName, float transitionDuration, int layer) => playable.CrossFade(stateName, transitionDuration, layer);
public void CrossFade(string stateName, float transitionDuration, int layer, float normalizedTime) => playable.CrossFade(stateName, transitionDuration, layer, normalizedTime);
public void CrossFade(int stateNameHash, float transitionDuration) => playable.CrossFade(stateNameHash, transitionDuration);
public void CrossFade(int stateNameHash, float transitionDuration, int layer) => playable.CrossFade(stateNameHash, transitionDuration, layer);
public void CrossFade(int stateNameHash, float transitionDuration, int layer, float normalizedTime) => playable.CrossFade(stateNameHash, transitionDuration, layer, normalizedTime);
public void PlayInFixedTime(string stateName) => playable.PlayInFixedTime(stateName);
public void PlayInFixedTime(string stateName, int layer) => playable.PlayInFixedTime(stateName, layer);
public void PlayInFixedTime(string stateName, int layer, float fixedTime) => playable.PlayInFixedTime(stateName, layer, fixedTime);
public void PlayInFixedTime(int stateNameHash) => playable.PlayInFixedTime(stateNameHash);
public void PlayInFixedTime(int stateNameHash, int layer) => playable.PlayInFixedTime(stateNameHash, layer);
public void PlayInFixedTime(int stateNameHash, int layer, float fixedTime) => playable.PlayInFixedTime(stateNameHash, layer, fixedTime);
public void Play(string stateName) => playable.Play(stateName);
public void Play(string stateName, int layer) => playable.Play(stateName, layer);
public void Play(string stateName, int layer, float normalizedTime) => playable.Play(stateName, layer, normalizedTime);
public void Play(int stateNameHash) => playable.Play(stateNameHash);
public void Play(int stateNameHash, int layer) => playable.Play(stateNameHash, layer);
public void Play(int stateNameHash, int layer, float normalizedTime) => playable.Play(stateNameHash, layer, normalizedTime);
public bool HasState(int layerIndex, int stateID) => playable.HasState(layerIndex, stateID);
}

11
KFAttached/Animation/MonoBehaviours/AnimatorWrapper/PlayableWrapper.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: af94698a131639a4ba070db09410d746
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: