public SymbolFrameInstance GetFrame(int frame)
{
int frameIdx = GetFrameIdx(frame);
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(build.batchTag);
return(batchGroupData.GetSymbolFrameInstance(frameIdx));
}
/// <summary>
/// Applied after RemoveBatch runs.
/// </summary>
internal static void Postfix(BatchSet __instance)
{
if (__instance.batches.Count < 1)
{
var key = __instance.key;
var inst = KAnimBatchManager.Instance();
if (inst != null && inst.batchSets.Remove(key))
{
// Destroy from the batch manager
IList <KAnimBatchManager.BatchSetInfo> toPurge;
int n;
if (key.materialType == MaterialType.UI)
{
toPurge = inst.uiBatchSets;
}
else
{
toPurge = inst.culledBatchSetInfos;
}
n = toPurge.Count;
for (int i = 0; i < n; i++)
{
if (toPurge[i].batchSet == __instance)
{
toPurge.RemoveAt(i);
break;
}
}
}
}
}
/// <summary>
/// Indexes a particular anim file to see if it makes any progress.
/// </summary>
/// <param name="manager">The current batched animation manager.</param>
/// <param name="data">The file data to check.</param>
private void IndexAnim(KAnimBatchManager manager, KAnimFileData data)
{
int n = data.animCount;
var build = data.build;
var bgd = manager.GetBatchGroupData(build.batchTag);
for (int i = 0; i < n; i++)
{
// Anim specifies a number of frames from the batch group's frames
var anim = data.GetAnim(i);
int start = anim.firstFrameIdx, nf = anim.numFrames, end = start + nf;
bool trivial = nf < LONG_THRESHOLD;
var id = anim.id;
if (nf > 1 && trivial)
{
var firstFrame = bgd.GetFrame(start++);
trivial = firstFrame.idx >= 0;
for (int j = start; j < end && trivial; j++)
{
// Frames of the animation are available from the batch group
var nextFrame = bgd.GetFrame(j);
trivial = nextFrame.idx >= 0 && CompareFrames(bgd, ref firstFrame,
ref nextFrame);
}
}
if (trivial && !idleAnims.ContainsKey(id))
{
// There are a couple of collisions in ONI, but they are properly handled
idleAnims.Add(id, new AnimWrapper(anim, nf));
}
}
}
public void LoadAnims()
{
if (!KAnimBatchManager.Instance().isReady)
{
Debug.LogError("KAnimBatchManager is not ready when loading anim:" + base.name);
}
if (animFiles.Length <= 0)
{
DebugUtil.Assert(false, "KBatchedAnimController has no anim files:" + base.name);
}
if (animFiles[0].buildBytes == null)
{
DebugUtil.LogErrorArgs(base.gameObject, $"First anim file needs to be the build file but {animFiles[0].GetData().name} doesn't have an associated build");
}
overrideAnims.Clear();
anims.Clear();
SetBatchGroup(animFiles[0].GetData());
for (int i = 0; i < animFiles.Length; i++)
{
AddAnims(animFiles[i]);
}
forceRebuild = true;
if (layering != null)
{
layering.HideSymbols();
}
if (usingNewSymbolOverrideSystem)
{
DebugUtil.Assert((UnityEngine.Object)GetComponent <SymbolOverrideController>() != (UnityEngine.Object)null);
}
}
private static KBatchGroupData GetAnimBatchGroupData(KAnimFileData animFile)
{
if (!animFile.batchTag.IsValid)
{
Debug.LogErrorFormat("Invalid batchTag for anim [{0}]", animFile.name);
}
Debug.Assert(animFile.batchTag.IsValid, "Invalid batch tag");
KAnimGroupFile.Group group = KAnimGroupFile.GetGroup(animFile.batchTag);
if (group == null)
{
Debug.LogErrorFormat("Null group for tag [{0}]", animFile.batchTag);
}
HashedString hashedString = animFile.batchTag;
KBatchGroupData kBatchGroupData = null;
if (group.renderType == KAnimBatchGroup.RendererType.DontRender || group.renderType == KAnimBatchGroup.RendererType.AnimOnly)
{
if (!group.swapTarget.IsValid)
{
Debug.LogErrorFormat("Invalid swap target for group [{0}]", group.id);
}
hashedString = group.swapTarget;
}
kBatchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(hashedString);
if (kBatchGroupData == null)
{
Debug.LogErrorFormat("Null batch group for tag [{0}]", hashedString);
}
return(kBatchGroupData);
}
private bool ShouldUseSidewaysSymbol(KBatchedAnimController controller)
{
KAnim.Anim currentAnim = controller.GetCurrentAnim();
if (currentAnim == null)
{
return(false);
}
int currentFrameIndex = controller.GetCurrentFrameIndex();
if (currentFrameIndex <= 0)
{
return(false);
}
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(currentAnim.animFile.animBatchTag);
KAnim.Anim.Frame frame = batchGroupData.GetFrame(currentFrameIndex);
for (int i = 0; i < frame.numElements; i++)
{
KAnim.Anim.FrameElement frameElement = batchGroupData.GetFrameElement(frame.firstElementIdx + i);
if (frameElement.symbol == HASH_SNAPTO_EYES && frameElement.frame >= FIRST_SIDEWAYS_FRAME)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Applied before Render runs.
/// </summary>
internal static bool Prefix(KAnimBatchManager __instance)
{
if (__instance.ready)
{
Render(__instance.activeBatchSets);
}
return(false);
}
private BatchKey(KAnimConverter.IAnimConverter controller)
{
_layer = controller.GetLayer();
_groupID = controller.GetBatchGroupID(false);
_materialType = controller.GetMaterialType();
_z = controller.GetZ();
_idx = KAnimBatchManager.ControllerToChunkXY(controller);
_hash = 0;
}
private void LateUpdate()
{
if (Debug.developerConsoleVisible)
{
Debug.developerConsoleVisible = false;
}
KAnimBatchManager.Instance().UpdateActiveArea(new Vector2I(0, 0), new Vector2I(9999, 9999));
KAnimBatchManager.Instance().UpdateDirty(Time.frameCount);
KAnimBatchManager.Instance().Render();
}
public Texture2D GetTexture(int index)
{
if (index < 0 || index >= textureCount)
{
Debug.LogError("Invalid texture index:" + index);
}
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(batchTag);
return(batchGroupData.GetTexure(textureStartIdx + index));
}
protected override void Register()
{
if (IsActive() && batch == null && batchGroupID.IsValid && batchGroupID != KAnimBatchManager.NO_BATCH)
{
lastChunkXY = KAnimBatchManager.ControllerToChunkXY(this);
KAnimBatchManager.Instance().Register(this);
forceRebuild = true;
SetDirty();
}
}
public void SetSymbolTint(KAnimHashedString symbol_name, Color color)
{
KAnim.Build.Symbol symbol = KAnimBatchManager.Instance().GetBatchGroupData(GetBatchGroupID(false)).GetSymbol(symbol_name);
if (symbol != null)
{
base.symbolInstanceGpuData.SetSymbolTint(symbol.symbolIndexInSourceBuild, color);
SuspendUpdates(false);
SetDirty();
}
}
private void ApplyShape(KAnim.Build.Symbol variation_symbol, KBatchedAnimController controller, KAnimFile shapes_file, HashedString symbol_name_in_shape_file, bool should_use_sideways_symbol)
{
HashedString hashedString = HASH_NEUTRAL;
if (currentExpression != null)
{
hashedString = currentExpression.face.hash;
}
KAnim.Anim anim = null;
KAnim.Anim.FrameElement frameElement = default(KAnim.Anim.FrameElement);
bool flag = false;
bool flag2 = false;
for (int i = 0; i < shapes_file.GetData().animCount; i++)
{
if (flag)
{
break;
}
KAnim.Anim anim2 = shapes_file.GetData().GetAnim(i);
if (anim2.hash == hashedString)
{
anim = anim2;
KAnim.Anim.Frame frame = anim.GetFrame(shapes_file.GetData().build.batchTag, 0);
for (int j = 0; j < frame.numElements; j++)
{
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(shapes_file.GetData().animBatchTag);
frameElement = batchGroupData.GetFrameElement(frame.firstElementIdx + j);
if (!(frameElement.symbol != symbol_name_in_shape_file))
{
if (flag2 || !should_use_sideways_symbol)
{
flag = true;
}
flag2 = true;
break;
}
}
}
}
if (anim == null)
{
DebugUtil.Assert(false, "Could not find shape for expression: " + HashCache.Get().Get(hashedString));
}
if (!flag2)
{
DebugUtil.Assert(false, "Could not find shape element for shape:" + HashCache.Get().Get(variation_symbol.hash));
}
KAnim.Build.Symbol symbol = KAnimBatchManager.Instance().GetBatchGroupData(controller.batchGroupID).GetSymbol(symbol_name_in_shape_file);
KBatchGroupData batchGroupData2 = KAnimBatchManager.Instance().GetBatchGroupData(variation_symbol.build.batchTag);
KAnim.Build.SymbolFrameInstance symbol_frame_instance = batchGroupData2.symbolFrameInstances[variation_symbol.firstFrameIdx + frameElement.frame];
symbol_frame_instance.buildImageIdx = GetComponent <SymbolOverrideController>().GetAtlasIdx(variation_symbol.build.GetTexture(0));
controller.SetSymbolOverride(symbol.firstFrameIdx, symbol_frame_instance);
}
public KAnim.Anim.FrameElement GetAnimFrameElement(int index)
{
Debug.Assert(index >= 0 && index < elementCount);
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(animBatchTag);
if (batchGroupData == null)
{
Debug.LogErrorFormat("[{0}] No such batch group [{1}]", name, animBatchTag.ToString());
}
return(batchGroupData.GetFrameElement(firstElementIndex + index));
}
public override KAnim.Anim GetAnim(int index)
{
if (!batchGroupID.IsValid || !(batchGroupID != KAnimBatchManager.NO_BATCH))
{
Debug.LogError(base.name + " batch not ready");
}
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(batchGroupID);
Debug.Assert(batchGroupData != null);
return(batchGroupData.GetAnim(index));
}
private void Awake()
{
KAnimBatchManager.DestroyInstance();
KAnimGroupFile.DestroyInstance();
KGlobalAnimParser.DestroyInstance();
KAnimBatchManager.CreateInstance();
KGlobalAnimParser.CreateInstance();
Global.Instance.modManager.Load(Content.Animation);
KAnimGroupFile.GetGroupFile().LoadAll();
KAnimBatchManager.Instance().CompleteInit();
}
public KAnim.Anim GetAnim(int index)
{
Debug.Assert(index >= 0 && index < animCount);
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(animBatchTag);
if (batchGroupData == null)
{
Debug.LogError($"[{name}] No such batch group [{animBatchTag.ToString()}]");
}
return(batchGroupData.GetAnim(index + firstAnimIndex));
}
/// <summary>
/// Indexes all kanims and finds those that do not actually make any progress.
/// </summary>
private void IndexAnims()
{
var manager = KAnimBatchManager.Instance();
idleAnims.Clear();
foreach (var file in Assets.Anims)
{
var data = file?.GetData();
if (data != null && data.build != null)
{
IndexAnim(manager, data);
}
}
}
/// <summary>
/// Loads the anims on a background thread.
/// </summary>
private static void AsyncLoadAnims()
{
#if DEBUG
PUtil.LogDebug("Loading anims on thread " + Thread.CurrentThread.ManagedThreadId);
#endif
try {
KAnimGroupFile.LoadAll();
KAnimBatchManager.Instance().CompleteInit();
} catch (Exception e) {
DebugUtil.LogException(Assets.instance, e.Message, e);
}
animsDone.Set();
LoadGameHashes();
}
private void LateUpdate()
{
if (!destroySelf)
{
if (performUpdate)
{
KAnimBatchManager.Instance().UpdateActiveArea(new Vector2I(0, 0), new Vector2I(9999, 9999));
KAnimBatchManager.Instance().UpdateDirty(Time.frameCount);
}
if (performRender)
{
KAnimBatchManager.Instance().Render();
}
}
}
public KAnimBatchGroup(HashedString id)
{
data = KAnimBatchManager.Instance().GetBatchGroupData(id);
materials = new Material[5];
batchID = id;
KAnimGroupFile.Group group = KAnimGroupFile.GetGroup(id);
if (group != null)
{
maxGroupSize = group.maxGroupSize;
if (maxGroupSize <= 0)
{
maxGroupSize = 30;
}
SetupMeshData();
InitBuildAndAnimTex();
}
}
/// <summary>
/// Applied before SetBatchGroup runs.
/// </summary>
internal static bool Prefix(KBatchedAnimController __instance, KAnimFileData kafd)
{
var id = __instance.batchGroupID;
if (id.IsValid)
{
PUtil.LogWarning("Batch group should only be set once!");
}
else if (kafd == null)
{
PUtil.LogWarning("No anim data for {0}!".F(__instance.name));
}
else if (id != kafd.batchTag)
{
var bild = kafd.build;
var inst = KAnimBatchManager.Instance();
if (bild == null)
{
PUtil.LogWarning("No build for anim {0} on {1}!".F(kafd.name, __instance.
name));
}
else if (!(id = bild.batchTag).IsValid || id == KAnimBatchManager.NO_BATCH)
{
PUtil.LogWarning("Batch is not ready: " + __instance.name);
}
else if (inst != null)
{
var bgd = KAnimBatchManager.instance.GetBatchGroupData(id);
id = bild.batchTag;
__instance.curBuild = bild;
__instance.batchGroupID = id;
__instance.symbolInstanceGpuData = new SymbolInstanceGpuData(bgd.
maxSymbolsPerBuild);
__instance.symbolOverrideInfoGpuData = new SymbolOverrideInfoGpuData(bgd.
symbolFrameInstances.Count);
}
}
return(false);
}
public void UpdateAnim(float dt)
{
if (batch != null && base.transform.hasChanged)
{
base.transform.hasChanged = false;
if (batch != null && batch.group.maxGroupSize == 1)
{
float z = lastPos.z;
Vector3 position = base.transform.GetPosition();
if (z != position.z)
{
KAnimBatch kAnimBatch = batch;
Vector3 position2 = base.transform.GetPosition();
kAnimBatch.OverrideZ(position2.z);
}
}
Vector3 vector = lastPos = base.PositionIncludingOffset;
if (visibilityType != VisibilityType.Always)
{
Vector2I u = KAnimBatchManager.ControllerToChunkXY(this);
if (u != lastChunkXY && lastChunkXY != KBatchedAnimUpdater.INVALID_CHUNK_ID)
{
DeRegister();
Register();
}
}
SetDirty();
}
if (!(batchGroupID == KAnimBatchManager.NO_BATCH) && IsActive())
{
if (!forceRebuild && (mode == KAnim.PlayMode.Paused || stopped || curAnim == null || (mode == KAnim.PlayMode.Once && curAnim != null && (base.elapsedTime > curAnim.totalTime || curAnim.totalTime <= 0f) && animQueue.Count == 0)))
{
SuspendUpdates(true);
}
if (!isVisible && !forceRebuild)
{
if (visibilityType == VisibilityType.OffscreenUpdate && !stopped && mode != KAnim.PlayMode.Paused)
{
SetElapsedTime(base.elapsedTime + dt * playSpeed);
}
}
else
{
curAnimFrameIdx = GetFrameIdx(base.elapsedTime, true);
if (eventManagerHandle.IsValid() && aem != null)
{
float elapsedTime = aem.GetElapsedTime(eventManagerHandle);
if ((int)((base.elapsedTime - elapsedTime) * 100f) != 0)
{
UpdateAnimEventSequenceTime();
}
}
UpdateFrame(base.elapsedTime);
if (!stopped && mode != KAnim.PlayMode.Paused)
{
SetElapsedTime(base.elapsedTime + dt * playSpeed);
}
forceRebuild = false;
}
}
}
public KAnim.Anim.FrameElement FindAnimFrameElement(KAnimHashedString symbolName)
{
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(animBatchTag);
return(batchGroupData.frameElements.Find((KAnim.Anim.FrameElement match) => match.symbol == symbolName));
}
/// <summary>
/// Updates an active batched anim controller.
/// </summary>
/// <param name="instance">The controller to update.</param>
/// <param name="dt">The time since the last update.</param>
private static void UpdateActive(KBatchedAnimController instance, float dt)
{
Transform transform;
var batch = instance.batch;
var visType = instance.visibilityType;
bool visible = instance.IsVisible();
// Check if moved, do this even if offscreen as it may move the anim on screen
if (batch != null && (transform = instance.transform).hasChanged)
{
var lastChunk = instance.lastChunkXY;
Vector3 pos = transform.position, posWithOffset = pos + instance.Offset;
float z = pos.z;
Vector2I cellXY;
bool always = visType == KAnimControllerBase.VisibilityType.Always;
transform.hasChanged = false;
// If this is the only anim in the batch, and the Z coordinate changed,
// override the Z in the batch
if (batch.group.maxGroupSize == 1 && instance.lastPos.z != z)
{
batch.OverrideZ(z);
}
instance.lastPos = posWithOffset;
// This is basically GetCellXY() with less accesses to __instance.transform
if (Grid.CellSizeInMeters == 0.0f)
{
// Handle out-of-game
cellXY = new Vector2I((int)posWithOffset.x, (int)posWithOffset.y);
}
else
{
cellXY = Grid.PosToXY(posWithOffset);
}
if (!always && lastChunk != KBatchedAnimUpdater.INVALID_CHUNK_ID &&
KAnimBatchManager.CellXYToChunkXY(cellXY) != lastChunk)
{
// Re-register in a different batch
instance.DeRegister();
instance.Register();
}
else if (visible || always)
{
// Only set dirty if it is on-screen now - changing visible sets dirty
// If it moved into a different chunk, Register sets dirty
instance.SetDirty();
}
}
// If it has a batch, and is active
if (instance.batchGroupID != KAnimBatchManager.NO_BATCH)
{
var anim = instance.curAnim;
var mode = instance.mode;
bool force = instance.forceRebuild, stopped = instance.stopped;
float t = instance.elapsedTime, increment = dt * instance.playSpeed;
// Suspend updates if: not currently suspended, not force update, and one
// of (paused, stopped, no anim, one time and finished with no more to play)
if (!instance.suspendUpdates && !force && (mode == KAnim.PlayMode.Paused ||
stopped || anim == null || (mode == KAnim.PlayMode.Once && (t > anim.
totalTime || anim.totalTime <= 0f) && instance.animQueue.Count == 0)))
{
instance.SuspendUpdates(true);
}
if (visible || force)
{
var aem = instance.aem;
var handle = instance.eventManagerHandle;
instance.curAnimFrameIdx = instance.GetFrameIdx(t, true);
// Trigger anim event manager if time advanced more than 0.01s
if (handle.IsValid() && aem != null)
{
float elapsedTime = aem.GetElapsedTime(handle);
if (Math.Abs(t - elapsedTime) > 0.01f)
{
aem.SetElapsedTime(handle, t);
}
}
instance.UpdateFrame(t);
// Time can be mutated by UpdateFrame
if (!stopped && mode != KAnim.PlayMode.Paused)
{
instance.SetElapsedTime(instance.elapsedTime + increment);
}
instance.forceRebuild = false;
}
else if (visType == KAnimControllerBase.VisibilityType.OffscreenUpdate &&
!stopped && mode != KAnim.PlayMode.Paused)
{
// If invisible, only advance if offscreen update is enabled
instance.SetElapsedTime(t + increment);
}
}
}
public static Vector2I PosToChunkXY(Vector3 pos)
{
Vector2I cell_xy = Grid.PosToXY(pos);
return(KAnimBatchManager.CellXYToChunkXY(cell_xy));
}
public void LoadAll()
{
Debug.Assert(!hasCompletedLoadAll, "You cannot load all the anim data twice!");
fileData.Clear();
for (int i = 0; i < groups.Count; i++)
{
if (!groups[i].id.IsValid)
{
Debug.LogErrorFormat("Group invalid groupIndex [{0}]", i);
}
KBatchGroupData kBatchGroupData = null;
kBatchGroupData = ((!groups[i].target.IsValid) ? KAnimBatchManager.Instance().GetBatchGroupData(groups[i].id) : KAnimBatchManager.Instance().GetBatchGroupData(groups[i].target));
HashedString batchTag = groups[i].id;
if (groups[i].renderType == KAnimBatchGroup.RendererType.AnimOnly)
{
if (!groups[i].swapTarget.IsValid)
{
continue;
}
kBatchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(groups[i].swapTarget);
batchTag = groups[i].swapTarget;
}
for (int j = 0; j < groups[i].files.Count; j++)
{
KAnimFile kAnimFile = groups[i].files[j];
if ((UnityEngine.Object)kAnimFile != (UnityEngine.Object)null && kAnimFile.buildBytes != null && !fileData.ContainsKey(kAnimFile.GetInstanceID()))
{
if (kAnimFile.buildBytes.Length == 0)
{
Debug.LogWarning("Build File [" + kAnimFile.GetData().name + "] has 0 bytes");
}
else
{
HashedString hash = new HashedString(kAnimFile.name);
HashCache.Get().Add(hash.HashValue, kAnimFile.name);
KAnimFileData file = KGlobalAnimParser.Get().GetFile(kAnimFile);
file.maxVisSymbolFrames = 0;
file.batchTag = batchTag;
file.buildIndex = KGlobalAnimParser.ParseBuildData(kBatchGroupData, hash, new FastReader(kAnimFile.buildBytes), kAnimFile.textureList);
fileData.Add(kAnimFile.GetInstanceID(), file);
}
}
}
}
for (int k = 0; k < groups.Count; k++)
{
if (groups[k].renderType == KAnimBatchGroup.RendererType.AnimOnly)
{
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(groups[k].swapTarget);
KBatchGroupData batchGroupData2 = KAnimBatchManager.Instance().GetBatchGroupData(groups[k].animTarget);
for (int l = 0; l < batchGroupData.builds.Count; l++)
{
KAnim.Build build = batchGroupData.builds[l];
if (build != null && build.symbols != null)
{
for (int m = 0; m < build.symbols.Length; m++)
{
KAnim.Build.Symbol symbol = build.symbols[m];
if (symbol != null && symbol.hash.IsValid() && batchGroupData2.GetFirstIndex(symbol.hash) == -1)
{
KAnim.Build.Symbol symbol2 = new KAnim.Build.Symbol();
symbol2.build = build;
symbol2.hash = symbol.hash;
symbol2.path = symbol.path;
symbol2.colourChannel = symbol.colourChannel;
symbol2.flags = symbol.flags;
symbol2.firstFrameIdx = batchGroupData2.symbolFrameInstances.Count;
symbol2.numFrames = symbol.numFrames;
symbol2.symbolIndexInSourceBuild = batchGroupData2.frameElementSymbols.Count;
for (int n = 0; n < symbol2.numFrames; n++)
{
KAnim.Build.SymbolFrameInstance symbolFrameInstance = batchGroupData.GetSymbolFrameInstance(n + symbol.firstFrameIdx);
KAnim.Build.SymbolFrameInstance item = default(KAnim.Build.SymbolFrameInstance);
item.symbolFrame = symbolFrameInstance.symbolFrame;
item.buildImageIdx = -1;
item.symbolIdx = batchGroupData2.GetSymbolCount();
batchGroupData2.symbolFrameInstances.Add(item);
}
batchGroupData2.AddBuildSymbol(symbol2);
}
}
}
}
}
}
for (int num = 0; num < groups.Count; num++)
{
if (!groups[num].id.IsValid)
{
Debug.LogErrorFormat("Group invalid groupIndex [{0}]", num);
}
if (groups[num].renderType != KAnimBatchGroup.RendererType.DontRender)
{
KBatchGroupData kBatchGroupData2 = null;
if (groups[num].animTarget.IsValid)
{
kBatchGroupData2 = KAnimBatchManager.Instance().GetBatchGroupData(groups[num].animTarget);
if (kBatchGroupData2 == null)
{
Debug.LogErrorFormat("Anim group is null for [{0}] -> [{1}]", groups[num].id, groups[num].animTarget);
}
}
else
{
kBatchGroupData2 = KAnimBatchManager.Instance().GetBatchGroupData(groups[num].id);
if (kBatchGroupData2 == null)
{
Debug.LogErrorFormat("Anim group is null for [{0}]", groups[num].id);
}
}
for (int num2 = 0; num2 < groups[num].files.Count; num2++)
{
KAnimFile kAnimFile2 = groups[num].files[num2];
if ((UnityEngine.Object)kAnimFile2 != (UnityEngine.Object)null && kAnimFile2.animBytes != null)
{
if (kAnimFile2.animBytes.Length == 0)
{
Debug.LogWarning("Anim File [" + kAnimFile2.GetData().name + "] has 0 bytes");
}
else
{
if (!fileData.ContainsKey(kAnimFile2.GetInstanceID()))
{
KAnimFileData file2 = KGlobalAnimParser.Get().GetFile(kAnimFile2);
file2.maxVisSymbolFrames = 0;
file2.batchTag = groups[num].id;
fileData.Add(kAnimFile2.GetInstanceID(), file2);
}
HashedString fileNameHash = new HashedString(kAnimFile2.name);
FastReader reader = new FastReader(kAnimFile2.animBytes);
KAnimFileData animFile = fileData[kAnimFile2.GetInstanceID()];
KGlobalAnimParser.ParseAnimData(kBatchGroupData2, fileNameHash, reader, animFile);
}
}
}
}
}
for (int num3 = 0; num3 < groups.Count; num3++)
{
if (!groups[num3].id.IsValid)
{
Debug.LogErrorFormat("Group invalid groupIndex [{0}]", num3);
}
KBatchGroupData kBatchGroupData3 = null;
if (groups[num3].target.IsValid)
{
kBatchGroupData3 = KAnimBatchManager.Instance().GetBatchGroupData(groups[num3].target);
if (kBatchGroupData3 == null)
{
Debug.LogErrorFormat("Group is null for [{0}] target [{1}]", groups[num3].id, groups[num3].target);
}
}
else
{
kBatchGroupData3 = KAnimBatchManager.Instance().GetBatchGroupData(groups[num3].id);
if (kBatchGroupData3 == null)
{
Debug.LogErrorFormat("Group is null for [{0}]", groups[num3].id);
}
}
KGlobalAnimParser.PostParse(kBatchGroupData3);
}
hasCompletedLoadAll = true;
}
private void Awake()
{
KCrashReporter crash_reporter = GetComponent <KCrashReporter>();
if (((UnityEngine.Object)crash_reporter != (UnityEngine.Object)null) & (SceneInitializerLoader.ReportDeferredError == null))
{
SceneInitializerLoader.ReportDeferredError = delegate(SceneInitializerLoader.DeferredError deferred_error)
{
crash_reporter.ShowDialog(deferred_error.msg, deferred_error.stack_trace);
};
}
globalCanvas = GameObject.Find("Canvas");
UnityEngine.Object.DontDestroyOnLoad(globalCanvas.gameObject);
OutputSystemInfo();
Debug.Assert((UnityEngine.Object)Instance == (UnityEngine.Object)null);
Instance = this;
Debug.Log("Initializing at " + System.DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff"));
Debug.Log("Save path: " + Util.RootFolder());
if (forcedAtlasInitializationList != null)
{
SpriteAtlas[] array = forcedAtlasInitializationList;
foreach (SpriteAtlas spriteAtlas in array)
{
int spriteCount = spriteAtlas.spriteCount;
Sprite[] array2 = new Sprite[spriteCount];
spriteAtlas.GetSprites(array2);
Sprite[] array3 = array2;
foreach (Sprite sprite in array3)
{
Texture2D texture = sprite.texture;
if ((UnityEngine.Object)texture != (UnityEngine.Object)null)
{
texture.filterMode = FilterMode.Bilinear;
texture.anisoLevel = 4;
texture.mipMapBias = 0f;
}
}
}
}
FileSystem.Initialize();
Singleton <StateMachineUpdater> .CreateInstance();
Singleton <StateMachineManager> .CreateInstance();
Localization.RegisterForTranslation(typeof(UI));
modManager = new KMod.Manager();
modManager.Load(Content.DLL);
modManager.Load(Content.Strings);
KSerialization.Manager.Initialize();
mInputManager = new GameInputManager(GenerateDefaultBindings());
Audio.Get();
KAnimBatchManager.CreateInstance();
Singleton <SoundEventVolumeCache> .CreateInstance();
mAnimEventManager = new AnimEventManager();
Singleton <KBatchedAnimUpdater> .CreateInstance();
DistributionPlatform.Initialize();
Localization.Initialize(false);
modManager.Load(Content.Translation);
modManager.distribution_platforms.Add(new Local("Local", Label.DistributionPlatform.Local));
modManager.distribution_platforms.Add(new Local("Dev", Label.DistributionPlatform.Dev));
mainThread = Thread.CurrentThread;
KProfiler.main_thread = Thread.CurrentThread;
RestoreLegacyMetricsSetting();
if (DistributionPlatform.Initialized)
{
if (!KPrivacyPrefs.instance.disableDataCollection)
{
Debug.Log("Logged into " + DistributionPlatform.Inst.Name + " with ID:" + DistributionPlatform.Inst.LocalUser.Id + ", NAME:" + DistributionPlatform.Inst.LocalUser.Name);
ThreadedHttps <KleiAccount> .Instance.AuthenticateUser(OnGetUserIdKey);
}
}
else
{
Debug.LogWarning("Can't init " + DistributionPlatform.Inst.Name + " distribution platform...");
OnGetUserIdKey();
}
modManager.Load(Content.LayerableFiles);
GlobalResources.Instance();
}
public Frame GetFrame(HashedString batchTag, int idx)
{
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(batchTag);
return(batchGroupData.GetFrame(idx + firstFrameIdx));
}
