void StoreSet()
{
wasController = animator.runtimeAnimatorController;
wasRootMotion = animator.applyRootMotion;
wasCullingMode = animator.cullingMode;
wasEnabled = animator.enabled;
#if UNITY_5_6_OR_NEWER
animator.applyRootMotion = false;
animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
#else
if (Application.isPlaying && animator.runtimeAnimatorController != null)
{
StoreAnimatorInfo();
}
//if we dont set controller null, unity does not initialize deactivated animators when they enable and also cause animator crashes.
//if we do set controller null, unity crashes for already activated animators.
//checking isInitialized does not work, thus checking gameobject active seems only solution until animator fixed.
if (!animator.gameObject.activeInHierarchy)
{
animator.runtimeAnimatorController = null;
}
animator.applyRootMotion = false;
animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
animator.enabled = false;
#endif
}
public static void SetApplyCullMode(this AnimatorComponent com, AnimatorCullingMode mode)
{
if (com.animator != null)
{
com.animator.cullingMode = mode;
}
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="component">Animatorオブジェクト</param>
public AnimatorKun(Component component) : base(component)
{
componentKunType = ComponentKunType.Animator;
runtimeAnimatorController = "None";
avatar = "None";
var animator = component as Animator;
if (animator)
{
if (animator.runtimeAnimatorController != null)
{
runtimeAnimatorController = animator.runtimeAnimatorController.name;
}
else
{
runtimeAnimatorController = "None";
}
if (animator.avatar != null)
{
avatar = animator.avatar.name;
}
else
{
avatar = "None";
}
applyRootMotion = animator.applyRootMotion;
updateMode = animator.updateMode;
cullingMode = animator.cullingMode;
}
}
void Awake()
{
if (CheckForControllerError())
{
return;
}
ragdollOnCollision.InitializeRagdollOnCollisions(this);
animator = GetComponent <Animator>();
// store original culling mode
originalAnimatorCullingMode = animator.cullingMode;
// store master hip bone
masterHips = animator.GetBoneTransform(HumanBodyBones.Hips);
// get all the master renderers to switch off when going ragdoll
masterRenderers = GetComponentsInChildren <Renderer>();
// set the ragdolls follow target (assumes same bone setup...)
ragdoll.SetFollowTarget(animator);
// tell the ragdoll it's being controlled
ragdoll.SetController(this);
// initialize animation following
InitializeJointFollowing();
InitializeVelocitySetValues();
GetUpImmediate(false);
//subscribe to receive a callback on ragdoll bone collision
ragdoll.onCollisionEnter += OnRagdollCollisionEnter;
}
static int IntToEnum(IntPtr L)
{
int arg0 = (int)LuaDLL.lua_tonumber(L, 1);
AnimatorCullingMode o = (AnimatorCullingMode)arg0;
LuaScriptMgr.PushEnum(L, o);
return(1);
}
public static void InitializeCharacterOptimizations(GameObject player, float genitalRange, float hairRange, float clothingRange, float bodyRange, AnimatorCullingMode cullingMode)
{
_playerObject = player;
_cullingMode = cullingMode;
SetColliderRanges(genitalRange, hairRange, clothingRange, bodyRange);
BuildCharacterList();
UpdateAnimatorCulling(_cullingMode);
}
/// <summary>
///
/// </summary>
/// <param name="binaryReader"></param>
public override void Deserialize(BinaryReader binaryReader)
{
base.Deserialize(binaryReader);
mRuntimeAnimatorController = binaryReader.ReadString();
mAvatar = binaryReader.ReadString();
mApplyRootMotion = binaryReader.ReadBoolean();
mUpdateMode = (AnimatorUpdateMode)binaryReader.ReadInt32();
mCullingMode = (AnimatorCullingMode)binaryReader.ReadInt32();
}
void StoreSet()
{
wasController = animator.runtimeAnimatorController;
wasRootMotion = animator.applyRootMotion;
wasCullingMode = animator.cullingMode;
wasEnabled = animator.enabled;
animator.applyRootMotion = false;
animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
}
public static void CreateAnimator(GameObject root, UmaTPose umaTPose, RuntimeAnimatorController controller,bool applyRootMotion, bool animatePhysics,AnimatorCullingMode cullingMode)
{
umaTPose.DeSerialize();
var animator = root.AddComponent<Animator>();
animator.avatar = CreateAvatar(root, umaTPose);
animator.runtimeAnimatorController = controller;
animator.applyRootMotion = applyRootMotion;
animator.animatePhysics = animatePhysics;
animator.cullingMode = cullingMode;
}
public static Animator CreateAnimator(UMAData umaData, UmaTPose umaTPose, RuntimeAnimatorController controller, bool applyRootMotion, bool animatePhysics, AnimatorCullingMode cullingMode)
{
umaTPose.DeSerialize();
var animator = umaData.umaRoot.AddComponent<Animator>();
animator.avatar = CreateAvatar(umaData, umaTPose);
animator.runtimeAnimatorController = controller;
animator.applyRootMotion = applyRootMotion;
animator.animatePhysics = animatePhysics;
animator.cullingMode = cullingMode;
return animator;
}
public virtual void UpdateAvatar(UMAData umaData)
{
if (umaData)
{
AnimationState[] snapshot = null;
if (umaData.animationController)
{
var animator = umaData.animator;
bool animating = false;
bool applyRootMotion = false;
bool animatePhysics = false;
AnimatorCullingMode cullingMode = AnimatorCullingMode.AlwaysAnimate;
if (animator)
{
animating = animator.enabled;
applyRootMotion = animator.applyRootMotion;
animatePhysics = animator.animatePhysics;
cullingMode = animator.cullingMode;
if (umaData.animationController == animator.runtimeAnimatorController)
{
snapshot = new AnimationState[animator.layerCount];
for (int i = 0; i < animator.layerCount; i++)
{
var state = animator.GetCurrentAnimatorStateInfo(i);
snapshot[i].stateHash = state.nameHash;
snapshot[i].stateTime = Mathf.Max(0, state.normalizedTime - Time.deltaTime / state.length);
}
}
Object.DestroyImmediate(animator);
}
var oldParent = umaData.umaRoot.transform.parent;
umaData.umaRoot.transform.parent = null;
animator = CreateAnimator(umaData, umaData.umaRecipe.raceData.TPose, umaData.animationController, applyRootMotion, animatePhysics, cullingMode);
umaData.animator = animator;
umaData.umaRoot.transform.parent = oldParent;
if (snapshot != null)
{
for (int i = 0; i < animator.layerCount; i++)
{
animator.Play(snapshot[i].stateHash, i, snapshot[i].stateTime);
}
animator.Update(0);
animator.enabled = animating;
}
}
}
}
//...
protected override void OnReverseEnter()
{
if (isMasterTrack)
{
wasCullingMode = animator.cullingMode;
animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
wasRootMotion = animator.applyRootMotion;
animator.applyRootMotion = false;
CreateAndPlayTree();
//DO NOT Re-Bake root motion
}
}
public static void UpdateAnimatorCulling(AnimatorCullingMode cullingMode)
{
List <Animator> buildingAnimators = BuildAnimatorList();
if (buildingAnimators.IsNullOrEmpty())
{
return;
}
foreach (var animator in buildingAnimators)
{
animator.cullingMode = cullingMode;
}
}
void Awake()
{
if (!profile)
{
Debug.LogWarning("No Controller Profile on " + name);
return;
}
if (!ragdoll)
{
Debug.LogWarning("No Ragdoll for " + name + " to control...");
return;
}
eventPlayer = GetComponent <AssetObjectsPacks.EventPlayer>();
eventPlayer.AddParameter(new AssetObjectsPacks.CustomParameter("OnFront", false));
animator = GetComponent <Animator>();
// store original culling mode
originalAnimatorCullingMode = animator.cullingMode;
// store master hip bone
masterHips = animator.GetBoneTransform(HumanBodyBones.Hips);
// get all the master renderers to switch off when going ragdoll
masterRenderers = GetComponentsInChildren <Renderer>();
// set the ragdolls follow target (assumes same bone setup...)
ragdoll.SetFollowTarget(animator);
// tell the ragdoll it's being controlled
ragdoll.SetController(this);
// initialize animation following
InitializeJointFollowing();
InitializeVelocitySetValues();
// disable physics
ragdoll.UseGravity(false);
//ragdoll.OverrideDepenetrationSpeed(-1);
ragdoll.IgnoreSelfCollisions(true);
ResetToAnimated();
ResetBoneDecays();
//subscribe to receive a callback on ragdoll bone collision
ragdoll.onCollisionEnter += OnRagdollCollisionEnter;
}
public static void UpdateAnimatorCulling(AnimatorCullingMode cullingMode)
{
var animalRoot = GameObject.Find("CommonSpace/MapRoot/SpawnPoint/AnimalRoot");
if (animalRoot == null)
{
return;
}
var animalAnimators = animalRoot.GetComponentsInChildren <Animator>(true);
foreach (var animator in animalAnimators)
{
animator.cullingMode = cullingMode;
}
}
public static void UpdateAnimatorCulling(AnimatorCullingMode cullingMode)
{
var worldData = GameObject.Find("map00_Beach");
if (worldData == null)
{
return;
}
var worldAnimators = worldData.GetComponentsInChildren <Animator>(true);
foreach (var animator in worldAnimators)
{
animator.cullingMode = cullingMode;
}
}
private static bool SetAnimatorCullingMode(GameObject obj, AnimatorCullingMode mode)
{
var animator = obj.GetComponentInChildren <Animator>();
if (null == animator)
{
return(false);
}
bool rt = false;
if (animator.cullingMode != mode)
{
rt = true;
animator.cullingMode = mode;
Debug.Log("SetAnimatorCullingMode succ:" + obj.name + " " + mode);
}
return(rt);
}
public static Animator CreateAnimator(UMAData umaData, UmaTPose umaTPose, RuntimeAnimatorController controller, bool applyRootMotion, bool animatePhysics, AnimatorCullingMode cullingMode)
{
var animator = umaData.umaRoot.AddComponent<Animator>();
switch (umaData.umaRecipe.raceData.umaTarget)
{
case RaceData.UMATarget.Humanoid:
umaTPose.DeSerialize();
animator.avatar = CreateAvatar(umaData, umaTPose);
break;
case RaceData.UMATarget.Generic:
animator.avatar = CreateGenericAvatar(umaData);
break;
}
animator.runtimeAnimatorController = controller;
animator.applyRootMotion = applyRootMotion;
animator.animatePhysics = animatePhysics;
animator.cullingMode = cullingMode;
return animator;
}
public void EnterState_JumpScene(xc.Machine.State s) // JumpScene State
{
Debug.Log("EnterState_JumpScene");
mJumpTime = Time.time;
if (mOwner.AnimationCtrl != null)
{
mCullingMode = mOwner.AnimationCtrl.CullMode;
mOwner.AnimationCtrl.CullMode = AnimatorCullingMode.AlwaysAnimate;
}
if (mOwner.HasAnimation(mJumpSceneAnimation))
{
mOwner.Play(mJumpSceneAnimation);
mJumpMaxTime = 3.0f;
}
else
{
mJumpMaxTime = 1.0f;
}
}
//...
protected override void OnEnter()
{
if (isMasterTrack)
{
wasCullingMode = animator.cullingMode;
animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
wasRootMotion = animator.applyRootMotion;
animator.applyRootMotion = false;
siblingTracks = parent.children.OfType <AnimatorTrack>().Where(t => t.isActive).Reverse().ToList();
var wasActive = animator.gameObject.activeSelf;
animator.gameObject.SetActive(true);
CreateAndPlayTree();
if (useRootMotion)
{
BakeRootMotion();
}
animator.gameObject.SetActive(wasActive);
}
}
public void SaveAnimatorState(Animator animator)
{
animating = animator.enabled;
applyRootMotion = animator.applyRootMotion;
updateMode = animator.updateMode;
cullingMode = animator.cullingMode;
int layerCount = animator.layerCount;
stateHashes = new int[layerCount];
stateTimes = new float[layerCount];
for (int i = 0; i < layerCount; i++)
{
var state = animator.GetCurrentAnimatorStateInfo(i);
#if UNITY_4_6
stateHashes[i] = state.nameHash;
#else
stateHashes[i] = state.fullPathHash;
#endif
stateTimes[i] = Mathf.Max(0, state.normalizedTime - Time.deltaTime / state.length);
}
}
protected override void ReadFromImpl(object obj)
{
base.ReadFromImpl(obj);
Animator uo = (Animator)obj;
rootPosition = uo.rootPosition;
rootRotation = uo.rootRotation;
applyRootMotion = uo.applyRootMotion;
updateMode = uo.updateMode;
stabilizeFeet = uo.stabilizeFeet;
feetPivotActive = uo.feetPivotActive;
speed = uo.speed;
cullingMode = uo.cullingMode;
recorderStartTime = uo.recorderStartTime;
recorderStopTime = uo.recorderStopTime;
runtimeAnimatorController = ToID(uo.runtimeAnimatorController);
layersAffectMassCenter = uo.layersAffectMassCenter;
logWarnings = uo.logWarnings;
fireEvents = uo.fireEvents;
keepAnimatorControllerStateOnDisable = uo.keepAnimatorControllerStateOnDisable;
}
public void SaveAnimatorState(Animator animator)
{
animating = animator.enabled;
applyRootMotion = animator.applyRootMotion;
updateMode = animator.updateMode;
cullingMode = animator.cullingMode;
int layerCount = animator.layerCount;
stateHashes = new int[layerCount];
stateTimes = new float[layerCount];
for (int i = 0; i < layerCount; i++)
{
var state = animator.GetCurrentAnimatorStateInfo(i);
#if UNITY_4_6
stateHashes[i] = state.nameHash;
#else
stateHashes[i] = state.fullPathHash;
#endif
stateTimes[i] = Mathf.Max(0, state.normalizedTime - Time.deltaTime / state.length);
}
}
public static void UpdateAnimatorCulling(AnimatorCullingMode cullingMode)
{
if (_playerCharacter != null)
{
_playerCharacter.animBody.cullingMode = cullingMode;
}
if (_characters.IsNullOrEmpty())
{
return;
}
foreach (var character in _characters)
{
if (character == null)
{
continue;
}
character.animBody.cullingMode = cullingMode;
}
}
private static void CheckPrefabAnimatorCore(string prefabPath, AnimatorCullingMode cullingMode = AnimatorCullingMode.CullCompletely)
{
GameObject instanceObj = PrefabUtility.LoadPrefabContents(prefabPath);
var animators = instanceObj.GetComponentsInChildren <Animator>(true);
bool change = false;
if (animators != null)
{
foreach (var animator in animators)
{
if (animator.cullingMode == AnimatorCullingMode.AlwaysAnimate)
{
animator.cullingMode = cullingMode;
change = true;
Debug.Log(prefabPath + " " + animator.gameObject.name);
}
}
}
if (change)
{
PrefabUtility.SaveAsPrefabAsset(instanceObj, prefabPath);
}
PrefabUtility.UnloadPrefabContents(instanceObj);
}
public static Animator CreateAnimator(UMAData umaData, UmaTPose umaTPose, RuntimeAnimatorController controller, bool applyRootMotion, bool animatePhysics, AnimatorCullingMode cullingMode)
{
var animator = CreateAnimator(umaData, umaTPose, controller);
animator.applyRootMotion = applyRootMotion;
animator.animatePhysics = animatePhysics;
animator.cullingMode = cullingMode;
return(animator);
}
public override void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
mOldMode = animator.cullingMode;
animator.cullingMode = mode;
}
public static Animator CreateAnimator(UMAData umaData, UmaTPose umaTPose, RuntimeAnimatorController controller, bool applyRootMotion, bool animatePhysics, AnimatorCullingMode cullingMode)
{
var animator = CreateAnimator(umaData, umaTPose, controller);
animator.applyRootMotion = applyRootMotion;
animator.animatePhysics = animatePhysics;
animator.cullingMode = cullingMode;
return animator;
}
protected override void OnEnter()
{
animator = actor.GetComponent <Animator>();
if (animator == null)
{
return;
}
if (Application.isPlaying || layerOrder != 0) //only 0 MecanimTrack layer does the recording
{
animator = null;
return;
}
wasCullingMode = animator.cullingMode;
animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
var updateInterval = (1f / RECORDING_FRAMERATE);
animator.recorderStartTime = this.startTime;
animator.recorderStopTime = this.endTime + updateInterval;
animator.StartRecording(0);
var clips = new List <IDirectable>();
foreach (var track in (parent as CutsceneGroup).tracks.OfType <MecanimTrack>().Where(t => t.isActive).Reverse())
{
clips.AddRange(track.clips.OfType <ActionClips.MecanimBaseClip>().Where(a => a.isValid).Cast <IDirectable>());
}
clips = clips.OrderBy(a => a.startTime).ToList();
var lastTime = -1f;
for (var i = startTime; i <= endTime + updateInterval; i += updateInterval)
{
foreach (var clip in clips)
{
if (i >= clip.startTime && lastTime < clip.startTime)
{
clip.Enter();
clip.Update(0, 0);
}
if (i >= clip.startTime && i <= clip.endTime)
{
clip.Update(i - clip.startTime, i - clip.startTime - updateInterval);
}
if (i > clip.endTime && lastTime <= clip.endTime)
{
clip.Update(clip.endTime - clip.startTime, Mathf.Max(0, lastTime - clip.startTime));
clip.Exit();
}
}
animator.Update(updateInterval);
lastTime = i;
}
animator.StopRecording();
animator.StartPlayback();
}
public static Animator CreateAnimator(UMAData umaData, UmaTPose umaTPose, RuntimeAnimatorController controller, bool applyRootMotion, bool animatePhysics, AnimatorCullingMode cullingMode)
{
var animator = umaData.umaRoot.AddComponent <Animator>();
switch (umaData.umaRecipe.raceData.umaTarget)
{
case RaceData.UMATarget.Humanoid:
umaTPose.DeSerialize();
animator.avatar = CreateAvatar(umaData, umaTPose);
break;
case RaceData.UMATarget.Generic:
animator.avatar = CreateGenericAvatar(umaData);
break;
}
animator.runtimeAnimatorController = controller;
animator.applyRootMotion = applyRootMotion;
animator.animatePhysics = animatePhysics;
animator.cullingMode = cullingMode;
return(animator);
}
/// <summary>
/// Bake the Mecanim preview data.
/// </summary>
public void Bake()
{
if (Actor == null || Application.isPlaying)
{
return;
}
Animator animator = Actor.GetComponent <Animator>();
if (animator == null)
{
return;
}
AnimatorCullingMode cullingData = animator.cullingMode;
animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
List <RevertInfo> revertCache = new List <RevertInfo>();
// Build the cache of revert info.
MonoBehaviour[] mb = this.GetComponentsInChildren <MonoBehaviour>();
for (int i = 0; i < mb.Length; i++)
{
IRevertable revertable = mb[i] as IRevertable;
if (revertable != null)
{
revertCache.AddRange(revertable.CacheState());
}
}
Vector3 position = Actor.transform.localPosition;
Quaternion rotation = Actor.transform.localRotation;
Vector3 scale = Actor.transform.localScale;
Cutscene cutScene = GetCutScene();
float frameRate = 30;
int frameCount = (int)((cutScene.Duration * frameRate) + 2);
animator.StopPlayback();
animator.recorderStartTime = 0;
animator.StartRecording(frameCount);
base.SetRunningTime(0);
for (int i = 0; i < frameCount - 1; i++)
{
List <TimelineTrack> tracks = GetTracks();
for (int j = 0; j < tracks.Count; j++)
{
tracks[j].UpdateTrack(i * (1.0f / frameRate), (1.0f / frameRate));
}
animator.Update(1.0f / frameRate);
}
animator.recorderStopTime = frameCount * (1.0f / frameRate);
animator.StopRecording();
animator.StartPlayback();
hasBeenBaked = true;
// Return the Actor to his initial position.
Actor.transform.localPosition = position;
Actor.transform.localRotation = rotation;
Actor.transform.localScale = scale;
for (int i = 0; i < revertCache.Count; i++)
{
RevertInfo revertable = revertCache[i];
if (revertable != null)
{
if ((revertable.EditorRevert == RevertMode.Revert && !Application.isPlaying) ||
(revertable.RuntimeRevert == RevertMode.Revert && Application.isPlaying))
{
revertable.Revert();
}
}
}
animator.cullingMode = cullingData;
base.Initialize();
}
private void Change(bool change)
{
var t = gameObject.transform;
var localPosition = t.localPosition;
var localRotation = t.localRotation;
var localScale = t.localScale;
Undo.RecordObject(this, "Change Animator Controller");
Undo.RecordObject(animatorCache, "Change Animator Controller");
if (change)
{
Assert.IsFalse(changed);
animatorCache.hideFlags |= HideFlags.NotEditable;
originalAnimatorApplyRootMotion = animatorCache.applyRootMotion;
originalAnimatorUpdateMode = animatorCache.updateMode;
originalAnimatorCullingMode = animatorCache.cullingMode;
animatorCache.applyRootMotion = false;
animatorCache.updateMode = AnimatorUpdateMode.Normal;
animatorCache.cullingMode = AnimatorCullingMode.AlwaysAnimate;
#region AnimatorController
{
originalRuntimeAnimatorController = animatorCache.runtimeAnimatorController;
tmpAnimatorController = new UnityEditor.Animations.AnimatorController();
tmpAnimatorController.name = "Very Animation Temporary Controller";
tmpAnimatorController.hideFlags |= HideFlags.HideAndDontSave;
{
tmpAnimatorController.AddLayer("Very Animation Layer");
layers = tmpAnimatorController.layers;
foreach (var layer in layers)
{
layer.iKPass = true;
var stateMachine = layer.stateMachine;
stateMachine.hideFlags |= HideFlags.HideAndDontSave;
{
state = stateMachine.AddState("Animation");
state.hideFlags |= HideFlags.HideAndDontSave;
stateNameHash = state.nameHash;
}
layer.stateMachine = stateMachine;
}
tmpAnimatorController.layers = layers;
}
UnityEditor.Animations.AnimatorController.SetAnimatorController(animatorCache, tmpAnimatorController);
}
#endregion
changed = true;
}
else
{
Assert.IsTrue(changed);
animatorCache.hideFlags &= ~HideFlags.NotEditable;
animatorCache.applyRootMotion = originalAnimatorApplyRootMotion;
animatorCache.updateMode = originalAnimatorUpdateMode;
animatorCache.cullingMode = originalAnimatorCullingMode;
#region AnimatorController
{
{
var layerCount = tmpAnimatorController.layers.Length;
for (int i = 0; i < layerCount; i++)
{
tmpAnimatorController.RemoveLayer(0);
}
}
DestroyImmediate(tmpAnimatorController);
tmpAnimatorController = null;
animatorCache.runtimeAnimatorController = originalRuntimeAnimatorController;
}
#endregion
originalRuntimeAnimatorController = null;
changed = false;
}
//Cause unknown. It does not allow initialization.
{
t.localPosition = localPosition;
t.localRotation = localRotation;
t.localScale = localScale;
}
}
public override void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
this.lastMode = animator.cullingMode;
animator.cullingMode = this.cullingMode;
}
protected override bool BuildInternal()
{
_tracksCached = GetAnimationTracks();
_validFrameRanges.Clear();
if (_tracksCached.Count == 0)
{
return(false);
}
// build preview
#if FLUX_DEBUG
Debug.LogWarning("Creating Preview");
#endif
FSequence sequence = Track.Sequence;
if (_tracksCached[0].Snapshot != null)
{
_tracksCached[0].Snapshot.Restore();
}
_snapshot = Application.isPlaying ? null : new GameObjectSnapshot(Track.Owner.gameObject);
bool ownerIsActive = Track.Owner.gameObject.activeSelf;
if (!ownerIsActive)
{
HideFlags hideFlags = Track.Owner.gameObject.hideFlags;
Track.Owner.gameObject.hideFlags |= HideFlags.DontSave;
Track.Owner.gameObject.SetActive(true);
Track.Owner.gameObject.hideFlags = hideFlags;
}
float speed = sequence.Speed;
if (speed != 1)
{
sequence.Speed = 1f;
}
Animator.speed = 1f;
int currentFrame = sequence.CurrentFrame;
bool isPlaying = sequence.IsPlaying;
if (!sequence.IsStopped)
{
sequence.Stop();
}
if (!sequence.IsInit)
{
sequence.Init();
}
FrameRange currentFrameRange = new FrameRange();
foreach (FAnimationTrack animTrack in _tracksCached)
{
animTrack.Cache = null;
animTrack.Stop(); // we need to force stop them to clear the currentEvent index
}
// RuntimeAnimatorController controller = Animator.runtimeAnimatorController;
// Animator.runtimeAnimatorController = null;
// Animator.runtimeAnimatorController = controller;
// set culling to get around Unity bug of recording at the start
AnimatorCullingMode animatorCullingMode = Animator.cullingMode;
Animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
Animator.enabled = true;
for (int i = 0; i != Animator.layerCount; ++i)
{
Animator.SetLayerWeight(i, 0f);
}
Animator.StartRecording(-1);
bool success = Animator.recorderMode == AnimatorRecorderMode.Record;
if (success)
{
Animator.enabled = false;
float delta = 1f / sequence.FrameRate;
int frame = 0;
while (frame <= sequence.Length)
{
bool wasEnabled = Animator.enabled;
foreach (FAnimationTrack animTrack in _tracksCached)
{
animTrack.UpdateEvents(frame, frame * delta);
}
if (wasEnabled)
{
currentFrameRange.End += 1;
if (Animator.enabled)
{
Animator.Update(delta);
}
else
{
Animator.enabled = true;
Animator.Update(delta);
Animator.enabled = false;
_validFrameRanges.Add(currentFrameRange);
}
}
else if (Animator.enabled)
{
Animator.Update(0);
currentFrameRange = new FrameRange(frame, frame);
}
++frame;
}
foreach (FAnimationTrack animTrack in _tracksCached)
{
animTrack.Cache = this;
}
Track = _tracksCached[0];
Animator.StopRecording();
sequence.Stop(true);
if (_snapshot != null)
{
_snapshot.Restore();
}
}
if (!ownerIsActive)
{
HideFlags hideFlags = Track.Owner.gameObject.hideFlags;
Track.Owner.gameObject.hideFlags |= HideFlags.DontSave;
Track.Owner.gameObject.SetActive(false);
Track.Owner.gameObject.hideFlags = hideFlags;
}
if (speed != 1)
{
sequence.Speed = speed;
}
Animator.cullingMode = animatorCullingMode;
if (currentFrame >= 0)
{
if (isPlaying)
{
sequence.Play(currentFrame);
}
else
{
sequence.SetCurrentFrame(currentFrame);
}
}
return(success);
}
public static void InitializeWorldOptimizations(float detailDistance, bool castShadows, GameLayers.LayerStrategy layerStrategy, bool drawTrees, LightShadows spotLightShadows, LightShadows pointLightShadows, bool enableCityPointLights, float citySpotLightIntensity, AnimatorCullingMode cullingMode)
{
terrain = GetTerrain();
if (terrain == null)
{
return;
}
SetTerrainDetailDistance(detailDistance);
SetTerrainShadows(castShadows);
EnableTreeRendering(drawTrees);
AdjustTerrainLayer(layerStrategy);
AdjustCullingMasks(layerStrategy);
SetCityLightShadows(spotLightShadows, pointLightShadows);
EnableCityPointLights(enableCityPointLights);
SetCitySpotLightIntensity(citySpotLightIntensity);
UpdateAnimatorCulling(cullingMode);
}
