public void Register(KAnimConverter.IAnimConverter controller)
{
if (!isReady)
{
Debug.LogError($"Batcher isnt finished setting up, controller [{controller.GetName()}] is registering too early.");
}
BatchKey batchKey = BatchKey.Create(controller);
Vector2I vector2I = ControllerToChunkXY(controller);
if (!batchSets.TryGetValue(batchKey, out BatchSet value))
{
value = new BatchSet(GetBatchGroup(new BatchGroupKey(batchKey.groupID)), batchKey, vector2I);
batchSets[batchKey] = value;
if (value.key.materialType == KAnimBatchGroup.MaterialType.UI)
{
uiBatchSets.Add(new BatchSetInfo
{
batchSet = value,
isActive = false,
spatialIdx = vector2I
});
}
else
{
culledBatchSetInfos.Add(new BatchSetInfo
{
batchSet = value,
isActive = false,
spatialIdx = vector2I
});
}
}
value.Add(controller);
}
public static BatchKey Create(KAnimConverter.IAnimConverter controller)
{
BatchKey result = new BatchKey(controller);
result.CalculateHash();
return(result);
}
public void Add(KAnimConverter.IAnimConverter controller)
{
int layer = controller.GetLayer();
if (layer != key.layer)
{
Debug.LogError("Registering with wrong batch set (layer) " + controller.GetName());
}
HashedString batchGroupID = controller.GetBatchGroupID(false);
if (!(batchGroupID == key.groupID))
{
Debug.LogError("Registering with wrong batch set (groupID) " + controller.GetName());
}
KAnimBatchGroup.MaterialType materialType = controller.GetMaterialType();
for (int i = 0; i < batches.Count; i++)
{
if (batches[i].size < group.maxGroupSize && batches[i].materialType == materialType)
{
if (batches[i].Register(controller))
{
SetDirty();
}
return;
}
}
KAnimBatch kAnimBatch = new KAnimBatch(group, layer, controller.GetZ(), materialType);
kAnimBatch.Init();
AddBatch(kAnimBatch);
kAnimBatch.Register(controller);
}
private BatchKey(KAnimConverter.IAnimConverter controller)
{
_layer = controller.GetLayer();
_groupID = controller.GetBatchGroupID(false);
_materialType = controller.GetMaterialType();
_z = controller.GetZ();
_idx = KAnimBatchManager.ControllerToChunkXY(controller);
_hash = 0;
}
/// <summary>
/// Applied before Deregister runs.
/// </summary>
internal static bool Prefix(KAnimConverter.IAnimConverter controller,
KAnimBatch __instance)
{
var controllersToIndex = __instance.controllersToIdx;
if (!App.IsExiting && controllersToIndex.TryGetValue(controller, out int index))
{
var controllers = __instance.controllers;
var dirtySet = __instance.dirtySet;
var bs = __instance.batchset;
// All the other anims above it need to be marked dirty
float[] data = __instance.dataTex.floats;
int end = Math.Max(0, __instance.currentOffset - VERTICES), n;
controller.SetBatch(null);
controllers.RemoveAt(index);
controllersToIndex.Remove(controller);
var dirty = ListPool <int, KAnimBatch> .Allocate();
n = dirtySet.Count;
// Save every existing dirty index less than the deregistered one
for (int i = 0; i < n; i++)
{
int dirtyIdx = dirtySet[i];
if (dirtyIdx < index)
{
dirty.Add(dirtyIdx);
}
}
dirtySet.Clear();
dirtySet.AddRange(dirty);
dirty.Recycle();
n = controllers.Count;
// Refresh the index mapping table and mark everything moved-down as dirty
for (int i = index; i < n; i++)
{
controllersToIndex[controllers[i]] = i;
dirtySet.Add(i);
}
bs.SetDirty();
__instance.needsWrite = true;
// Invalidate the data beyond the end
for (int i = 0; i < VERTICES; i++)
{
data[end + i] = -1f;
}
__instance.currentOffset = end;
// If this was the last item, destroy the texture
if (n <= 0)
{
bs.RemoveBatch(__instance);
__instance.Clear();
}
}
return(false);
}
public void SetDirty(KAnimConverter.IAnimConverter controller)
{
int num = controllers.IndexOf(controller);
if (num < 0)
{
Debug.LogError("Setting controller [" + controller.GetName() + "] to dirty but its not in this batch");
}
else
{
AddToDirty(num);
}
}
/// <summary>
/// Applied before Register runs.
/// </summary>
internal static bool Prefix(KAnimConverter.IAnimConverter controller,
KAnimBatch __instance, ref bool __result)
{
var batch = controller.GetBatch();
if (batch != __instance)
{
var dirtySet = __instance.dirtySet;
var controllers = __instance.controllers;
var controllersToIndex = __instance.controllersToIdx;
// Create the texture if it is null
var tex = __instance.dataTex;
if (tex == null || tex.floats.Length < 1)
{
__instance.Init();
}
// If already present [how is this possible?], just mark it dirty
if (controllersToIndex.TryGetValue(controller, out int index))
{
if (!dirtySet.Contains(index))
{
dirtySet.Add(index);
}
}
else
{
int n = controllers.Count;
controllers.Add(controller);
dirtySet.Add(n);
controllersToIndex.Add(controller, n);
// Allocate additional spots in the texture
__instance.currentOffset += KBatchedAnimInstanceData.SIZE_IN_FLOATS;
}
__instance.batchset.SetDirty();
__instance.needsWrite = true;
if (batch != null)
{
batch.Deregister(controller);
}
controller.SetBatch(__instance);
}
else
{
#if DEBUG
PUtil.LogDebug("Registered a controller to its existing batch!");
#endif
}
__result = true;
return(false);
}
public KBatchedAnimInstanceData(KAnimConverter.IAnimConverter target)
{
this.target = target;
converter = new AnimInstanceDataToByteConverter
{
bytes = new byte[112]
};
AnimInstanceData animInstanceData = converter.animInstanceData[0];
animInstanceData.tintColour = Color.white;
animInstanceData.highlightColour = Color.black;
animInstanceData.overlayColour = Color.white;
converter.animInstanceData[0] = animInstanceData;
}
private bool WriteSymbolOverrideInfoTex(int index, KAnimConverter.IAnimConverter controller)
{
bool result = false;
SymbolOverrideInfoSlot symbolOverrideInfoSlot = symbolOverrideInfoSlots[index];
if (symbolOverrideInfoSlot.symbolOverrideInfo != controller.symbolOverrideInfoGpuData || symbolOverrideInfoSlot.dataVersion != controller.symbolOverrideInfoGpuData.version)
{
controller.symbolOverrideInfoGpuData.WriteToTexture(symbolOverrideInfoTex.bytes, index * 12 * group.data.maxSymbolFrameInstancesPerbuild * 4, index);
symbolOverrideInfoSlot.symbolOverrideInfo = controller.symbolOverrideInfoGpuData;
symbolOverrideInfoSlot.dataVersion = controller.symbolOverrideInfoGpuData.version;
symbolOverrideInfoSlots[index] = symbolOverrideInfoSlot;
result = true;
}
return(result);
}
private bool WriteSymbolInstanceData(int index, KAnimConverter.IAnimConverter controller)
{
bool result = false;
SymbolInstanceSlot symbolInstanceSlot = symbolInstanceSlots[index];
if (symbolInstanceSlot.symbolInstanceData != controller.symbolInstanceGpuData || symbolInstanceSlot.dataVersion != controller.symbolInstanceGpuData.version)
{
controller.symbolInstanceGpuData.WriteToTexture(symbolInstanceTex.bytes, index * 8 * group.data.maxSymbolsPerBuild * 4, index);
symbolInstanceSlot.symbolInstanceData = controller.symbolInstanceGpuData;
symbolInstanceSlot.dataVersion = controller.symbolInstanceGpuData.version;
symbolInstanceSlots[index] = symbolInstanceSlot;
result = true;
}
return(result);
}
public bool Register(KAnimConverter.IAnimConverter controller)
{
if (dataTex == null || dataTex.floats.Length == 0)
{
Init();
}
if (!controllers.Contains(controller))
{
controllers.Add(controller);
currentOffset += 28;
}
AddToDirty(controllers.IndexOf(controller));
controller.GetBatch()?.Deregister(controller);
controller.SetBatch(this);
return(true);
}
public void SetBatch(KAnimConverter.IAnimConverter conv)
{
converter = conv;
if (conv != null)
{
batch = conv.GetBatch();
}
else
{
batch = null;
if ((Object)uiMat != (Object)null)
{
Object.Destroy(uiMat);
uiMat = null;
}
}
if (batch != null)
{
canvass = GetComponent <CanvasRenderer>();
if ((Object)canvass == (Object)null)
{
canvass = base.gameObject.AddComponent <CanvasRenderer>();
}
rootRectTransform = GetComponent <RectTransform>();
if ((Object)rootRectTransform == (Object)null)
{
rootRectTransform = base.gameObject.AddComponent <RectTransform>();
}
if (batch.group.InitOK)
{
if ((Object)uiMat != (Object)null)
{
Object.Destroy(uiMat);
uiMat = null;
}
Material material = batch.group.GetMaterial(batch.materialType);
uiMat = new Material(material);
((IMaskable)this).RecalculateMasking();
}
}
}
public void Deregister(KAnimConverter.IAnimConverter controller)
{
if (!App.IsExiting)
{
int num = controllers.IndexOf(controller);
if (num >= 0)
{
if (!controllers.Remove(controller))
{
Debug.LogError("Failed to remove controller [" + controller.GetName() + "]");
}
controller.SetBatch(null);
currentOffset -= 28;
currentOffset = Mathf.Max(0, currentOffset);
for (int i = 0; i < 28; i++)
{
dataTex.floats[currentOffset + i] = -1f;
}
currentOffset = 28 * controllers.Count;
ClearDirty();
for (int j = 0; j < controllers.Count; j++)
{
AddToDirty(j);
}
}
else
{
Debug.LogError("Deregister called for [" + controller.GetName() + "] but its not in this batch ");
}
if (controllers.Count == 0)
{
batchset.RemoveBatch(this);
DestroyTex();
}
}
}
private BatchKey(KAnimConverter.IAnimConverter controller, Vector2I idx)
{
this = new BatchKey(controller);
_idx = idx;
}
public static Vector2I ControllerToChunkXY(KAnimConverter.IAnimConverter controller)
{
Vector2I cellXY = controller.GetCellXY();
return(CellXYToChunkXY(cellXY));
}
public int UpdateDirty(int frame)
{
if (!needsWrite)
{
return(0);
}
if (dataTex == null || dataTex.floats.Length == 0)
{
Init();
}
writtenLastFrame = 0;
bool flag = false;
bool flag2 = false;
if (dirtySet.Count > 0)
{
foreach (int item in dirtySet)
{
KAnimConverter.IAnimConverter animConverter = controllers[item];
if (animConverter != null && animConverter as Object != (Object)null)
{
WriteBatchedAnimInstanceData(item, animConverter);
bool flag3 = WriteSymbolInstanceData(item, animConverter);
flag = (flag || flag3);
if (animConverter.ApplySymbolOverrides())
{
if (symbolOverrideInfoTex == null)
{
int bestTextureSize = KAnimBatchGroup.GetBestTextureSize((float)(group.data.maxSymbolFrameInstancesPerbuild * group.maxGroupSize * 12));
symbolOverrideInfoTex = group.CreateTexture("SymbolOverrideInfoTex", bestTextureSize, ShaderProperty_symbolOverrideInfoTex, ShaderProperty_SYMBOL_OVERRIDE_INFO_TEXTURE_SIZE);
symbolOverrideInfoTex.SetTextureAndSize(matProperties);
matProperties.SetFloat(ShaderProperty_SUPPORTS_SYMBOL_OVERRIDING, 1f);
}
bool flag4 = WriteSymbolOverrideInfoTex(item, animConverter);
flag2 = (flag2 || flag4);
}
writtenLastFrame++;
}
}
if (writtenLastFrame != 0)
{
ClearDirty();
}
else
{
Debug.LogError("dirtySet not written");
}
}
dataTex.LoadRawTextureData();
dataTex.Apply();
if (flag)
{
symbolInstanceTex.LoadRawTextureData();
symbolInstanceTex.Apply();
}
if (flag2)
{
symbolOverrideInfoTex.LoadRawTextureData();
symbolOverrideInfoTex.Apply();
}
return(writtenLastFrame);
}
private void WriteBatchedAnimInstanceData(int index, KAnimConverter.IAnimConverter controller)
{
controller.GetBatchInstanceData().WriteToTexture(dataTex.bytes, index * 112, index);
}
