public static void PostParse(KBatchGroupData data)
 {
     for (int i = 0; i < data.GetSymbolCount(); i++)
     {
         KAnim.Build.Symbol symbol = data.GetSymbol(i);
         if (symbol == null)
         {
             Debug.LogWarning("Symbol null for [" + data.groupID + "] idx: [" + i + "]");
         }
         else
         {
             if (symbol.numLookupFrames <= 0)
             {
                 int num = symbol.numFrames;
                 for (int j = symbol.firstFrameIdx; j < symbol.firstFrameIdx + symbol.numFrames; j++)
                 {
                     KAnim.Build.SymbolFrameInstance symbolFrameInstance = data.GetSymbolFrameInstance(j);
                     num = Mathf.Max(num, symbolFrameInstance.symbolFrame.sourceFrameNum + symbolFrameInstance.symbolFrame.duration);
                 }
                 symbol.numLookupFrames = num;
             }
             symbol.frameLookup = new int[symbol.numLookupFrames];
             if (symbol.numLookupFrames <= 0)
             {
                 Debug.LogWarning("No lookup frames for  [" + data.groupID + "] build: [" + symbol.build.name + "] idx: [" + i + "] id: [" + symbol.hash + "]");
             }
             else
             {
                 for (int k = 0; k < symbol.numLookupFrames; k++)
                 {
                     symbol.frameLookup[k] = -1;
                 }
                 for (int l = symbol.firstFrameIdx; l < symbol.firstFrameIdx + symbol.numFrames; l++)
                 {
                     KAnim.Build.SymbolFrameInstance symbolFrameInstance2 = data.GetSymbolFrameInstance(l);
                     if (symbolFrameInstance2.symbolFrame == null)
                     {
                         Debug.LogWarning("No symbol frame  [" + data.groupID + "] symFrameIdx: [" + l + "] id: [" + symbol.hash + "]");
                     }
                     else
                     {
                         for (int m = symbolFrameInstance2.symbolFrame.sourceFrameNum; m < symbolFrameInstance2.symbolFrame.sourceFrameNum + symbolFrameInstance2.symbolFrame.duration; m++)
                         {
                             if (m >= symbol.frameLookup.Length)
                             {
                                 Debug.LogWarning("Too many lookup frames [" + m + ">=" + symbol.frameLookup.Length + "] for  [" + data.groupID + "] idx: [" + i + "] id: [" + symbol.hash + "]");
                             }
                             else
                             {
                                 symbol.frameLookup[m] = l;
                             }
                         }
                     }
                 }
                 string text = HashCache.Get().Get(symbol.path);
                 if (!string.IsNullOrEmpty(text))
                 {
                     int num2 = text.IndexOf("/");
                     if (num2 != -1)
                     {
                         string text2 = text.Substring(0, num2);
                         symbol.folder = new KAnimHashedString(text2);
                         HashCache.Get().Add(symbol.folder.HashValue, text2);
                     }
                 }
             }
         }
     }
 }
Пример #2
0
 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;
 }
    public static int ParseBuildData(KBatchGroupData data, KAnimHashedString fileNameHash, FastReader reader, List <Texture2D> textures)
    {
        CheckHeader("BILD", reader);
        int num = reader.ReadInt32();

        if (num != 10 && num != 9)
        {
            Debug.LogError(fileNameHash + " has invalid build.bytes version [" + num + "]");
            return(-1);
        }
        KAnimGroupFile.Group group = KAnimGroupFile.GetGroup(data.groupID);
        if (group == null)
        {
            Debug.LogErrorFormat("[{1}] Failed to get group [{0}]", data.groupID, fileNameHash.DebuggerDisplay);
        }
        KAnim.Build build = null;
        int         num2  = reader.ReadInt32();
        int         num3  = reader.ReadInt32();

        build = data.AddNewBuildFile(fileNameHash);
        build.textureCount = textures.Count;
        if (textures.Count > 0)
        {
            data.AddTextures(textures);
        }
        build.symbols  = new KAnim.Build.Symbol[num2];
        build.frames   = new KAnim.Build.SymbolFrame[num3];
        build.name     = reader.ReadKleiString();
        build.batchTag = ((!group.swapTarget.IsValid) ? data.groupID : group.target);
        build.fileHash = fileNameHash;
        int num4 = 0;

        for (int i = 0; i < build.symbols.Length; i++)
        {
            KAnimHashedString  hash   = new KAnimHashedString(reader.ReadInt32());
            KAnim.Build.Symbol symbol = new KAnim.Build.Symbol();
            symbol.build = build;
            symbol.hash  = hash;
            if (num > 9)
            {
                symbol.path = new KAnimHashedString(reader.ReadInt32());
            }
            symbol.colourChannel            = new KAnimHashedString(reader.ReadInt32());
            symbol.flags                    = reader.ReadInt32();
            symbol.firstFrameIdx            = data.symbolFrameInstances.Count;
            symbol.numFrames                = reader.ReadInt32();
            symbol.symbolIndexInSourceBuild = i;
            int num5 = 0;
            for (int j = 0; j < symbol.numFrames; j++)
            {
                KAnim.Build.SymbolFrame         symbolFrame = new KAnim.Build.SymbolFrame();
                KAnim.Build.SymbolFrameInstance item        = default(KAnim.Build.SymbolFrameInstance);
                item.symbolFrame           = symbolFrame;
                symbolFrame.fileNameHash   = fileNameHash;
                symbolFrame.sourceFrameNum = reader.ReadInt32();
                symbolFrame.duration       = reader.ReadInt32();
                item.buildImageIdx         = data.textureStartIndex[fileNameHash] + reader.ReadInt32();
                if (item.buildImageIdx >= textures.Count + data.textureStartIndex[fileNameHash])
                {
                    Debug.LogErrorFormat("{0} Symbol: [{1}] tex count: [{2}] buildImageIdx: [{3}] group total [{4}]", fileNameHash.ToString(), symbol.hash, textures.Count, item.buildImageIdx, data.textureStartIndex[fileNameHash]);
                }
                item.symbolIdx = data.GetSymbolCount();
                num5           = Math.Max(symbolFrame.sourceFrameNum + symbolFrame.duration, num5);
                float num6 = reader.ReadSingle();
                float num7 = reader.ReadSingle();
                float num8 = reader.ReadSingle();
                float num9 = reader.ReadSingle();
                symbolFrame.bboxMin = new Vector2(num6 - num8 * 0.5f, num7 - num9 * 0.5f);
                symbolFrame.bboxMax = new Vector2(num6 + num8 * 0.5f, num7 + num9 * 0.5f);
                float x     = reader.ReadSingle();
                float num10 = reader.ReadSingle();
                float x2    = reader.ReadSingle();
                float num11 = reader.ReadSingle();
                symbolFrame.uvMin  = new Vector2(x, 1f - num10);
                symbolFrame.uvMax  = new Vector2(x2, 1f - num11);
                build.frames[num4] = symbolFrame;
                data.symbolFrameInstances.Add(item);
                num4++;
            }
            symbol.numLookupFrames = num5;
            data.AddBuildSymbol(symbol);
            build.symbols[i] = symbol;
        }
        ParseHashTable(reader);
        return(build.index);
    }