protected static int ParseMapS2I(GameDataParser parser, byte[] bytes, int offset, GameDataBase gameDataObj, string fieldName)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var count = BitConverter.ToInt32(bytes, offset);
offset += 4;
Dictionary <string, int> values = new Dictionary <string, int>(count);
for (int i = 0; i < count; i++)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var key = BitConverter.ToInt32(bytes, offset);
offset += 4;
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var value = BitConverter.ToInt32(bytes, offset);
offset += 4;
values.Add(parser.m_StringBuffList[key], value);
}
gameDataObj.SetDictionaryS2I(fieldName, values);
return(offset);
}
private byte[] ParseListFloat(short fieldIndex, string value)
{
List <byte> bytes = new List <byte>();
var data = BitConverter.GetBytes(fieldIndex);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
string[] valueSplit = value.Split(',');
var dataCount = valueSplit.Length;
data = BitConverter.GetBytes(dataCount);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
List <float> listValues = new List <float>(dataCount);
foreach (var v in valueSplit)
{
listValues.Add(float.Parse(v));
}
foreach (var v in listValues)
{
data = BitConverter.GetBytes(v);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
}
return(bytes.ToArray());
}
private void ParseAssetsInfo(Dictionary <string, AssetInfo> assetDependencesMap, List <string> stringBuff, byte[] bytes, int offset)
{
for (int i = 0; i < m_ItemCount; ++i)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var index = BitConverter.ToInt32(bytes, offset);
var path = stringBuff[index];
offset += 4;
var assetInfo = new AssetInfo();
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
index = BitConverter.ToInt32(bytes, offset);
assetInfo.AssetBundlePath = stringBuff[index];
offset += 4;
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var dependencesCount = BitConverter.ToInt32(bytes, offset);
offset += 4;
var dependencesList = new List <string>(dependencesCount);
for (int j = 0; j < dependencesCount; j++)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
index = BitConverter.ToInt32(bytes, offset);
dependencesList.Add(stringBuff[index]);
offset += 4;
}
assetInfo.DependencesPath = dependencesList;
assetDependencesMap.Add(path, assetInfo);
}
}
private void WriteStringBuffer(FileStream fs)
{
var bytes = BitConverter.GetBytes(this.m_ItemCount);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytes.Length);
fs.WriteByte(m_HasStringBuffer);
if (m_HasStringBuffer != 0)
{
var buffsize = GetStringBufferSize(m_StringBufferList);
bytes = BitConverter.GetBytes(buffsize);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytes.Length);
}
foreach (var strBuff in m_StringBufferList)
{
bytes = Encoding.UTF8.GetBytes(strBuff);
fs.Write(bytes, 0, bytes.Length);
fs.WriteByte(0);
}
}
private void writeItemCount(FileStream fs, short count)
{
var data = BitConverter.GetBytes(count);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
fs.Write(data, 0, data.Length);
}
private byte[] ParseHashSetString(short fieldIndex, string value)
{
List <byte> bytes = new List <byte>();
var data = BitConverter.GetBytes(fieldIndex);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
string[] valueSplit = value.Split(',');
var dataCount = valueSplit.Length;
data = BitConverter.GetBytes(dataCount);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
Dictionary <int, bool> keyMap = new Dictionary <int, bool>();
List <int> listValues = new List <int>(dataCount);
foreach (var v in valueSplit)
{
keyMap.Add(m_StringBufferToIndexMap[v], true);
listValues.Add(m_StringBufferToIndexMap[v]);
}
foreach (var v in listValues)
{
data = BitConverter.GetBytes(v);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
}
return(bytes.ToArray());
}
protected static int ParseListFloat2(GameDataParser parser, byte[] bytes, int offset, GameDataBase gameDataObj, string fieldName)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var arrayCount = BitConverter.ToInt32(bytes, offset);
offset += 4;
List <List <float> > array = new List <List <float> >(arrayCount);
for (int i = 0; i < arrayCount; i++)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var count = BitConverter.ToInt32(bytes, offset);
offset += 4;
List <float> values = new List <float>(count);
for (int j = 0; j < count; j++)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var value = BitConverter.ToSingle(bytes, offset);
offset += 4;
values.Add(value);
}
array.Add(values);
}
gameDataObj.SetListFloat2(fieldName, array);
return(offset);
}
private void ParseLoadList(byte[] bytes, int start, int end, List <string> loadList)
{
for (int i = start; i < end; i += 2)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, i, 2);
loadList.Add(m_StringCache[BitConverter.ToInt16(bytes, i)]);
}
}
protected static int ParseFloat(GameDataParser parser, byte[] bytes, int offset, GameDataBase gameDataObj, string fieldName)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var value = BitConverter.ToSingle(bytes, offset);
offset += 4;
gameDataObj.SetFloat(fieldName, value);
return(offset);
}
protected static int ParseLong(GameDataParser parser, byte[] bytes, int offset, GameDataBase gameDataObj, string fieldName)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 8);
var value = BitConverter.ToInt64(bytes, offset);
offset += 8;
gameDataObj.SetLong(fieldName, value);
return(offset);
}
protected static int ParseString(GameDataParser parser, byte[] bytes, int offset, GameDataBase gameDataObj, string fieldName)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var value = BitConverter.ToInt32(bytes, offset);
offset += 4;
gameDataObj.SetString(fieldName, parser.m_StringBuffList[value]);
return(offset);
}
private int GetStringBuffInfo(List <string> stringBuff, byte[] bytes, int offset)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var stringBuffSize = BitConverter.ToInt32(bytes, offset);
offset += 4;
ParseStringCache(bytes, offset, offset += stringBuffSize, stringBuff);
return(offset);
}
public int ParseHeadInfo(byte[] data, int offset)
{
int readBytes = 0;
BitConverterUtility.ConvertEndianFrom(data, true, offset, 4);
DataCount = BitConverter.ToInt32(data, offset);
readBytes += 4;
DataBytesStartIndex = readBytes;
return(readBytes);
}
private int GetHeadInfo(byte[] bytes)
{
var offset = 0;
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
m_ItemCount = BitConverter.ToInt32(bytes, offset);
offset += 4;
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
m_StringBuffCount = BitConverter.ToInt32(bytes, offset);
offset += 4;
return(offset);
}
private void WriteTrunk(List <short> loadList, FileStream fs)
{
if (loadList.Count > 0)
{
var bytes = BitConverter.GetBytes(loadList.Count);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, 4);
fs.Write(bytes, 0, bytes.Length);
foreach (var priority in loadList)
{
bytes = BitConverter.GetBytes(priority);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, 2);
fs.Write(bytes, 0, bytes.Length);
}
}
}
private byte[] ParseFloat(short fieldIndex, string value)
{
List <byte> bytes = new List <byte>();
var data = BitConverter.GetBytes(fieldIndex);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
var result = float.Parse(value);
data = BitConverter.GetBytes(result);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
return(bytes.ToArray());
}
private byte[] ParseString(short fieldIndex, string value)
{
List <byte> bytes = new List <byte>();
var data = BitConverter.GetBytes(fieldIndex);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
var sbIndex = m_StringBufferToIndexMap[value];
data = BitConverter.GetBytes(sbIndex);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
return(bytes.ToArray());
}
public int ParseHeadInfo(byte[] data)
{
int readBytes = 0;
BitConverterUtility.ConvertEndianFrom(data, true, readBytes, 4);
TrunkFlags = BitConverter.ToInt32(data, readBytes);
readBytes += 4;
BitConverterUtility.ConvertEndianFrom(data, true, readBytes, 4);
StringCacheCount = BitConverter.ToInt32(data, readBytes);
readBytes += 4;
BitConverterUtility.ConvertEndianFrom(data, true, readBytes, 4);
StringCacheSize = BitConverter.ToInt32(data, readBytes);
readBytes += 4;
StringCacheStartIndex = readBytes;
return(readBytes);
}
private void WriteLoadConfig(Dictionary <string, int> priorityMap, List <FileInfos> fileInfos)
{
if (Directory.Exists(m_Window.SettingUI.XmlBinExportDirectory))
{
Directory.Delete(m_Window.SettingUI.XmlBinExportDirectory, true);
}
if (!Directory.Exists(m_Window.SettingUI.XmlBinExportDirectory))
{
Directory.CreateDirectory(m_Window.SettingUI.XmlBinExportDirectory);
}
FileStream fs = File.Create(m_Window.SettingUI.XmlBinExportDirectory + "/GameDataConfig.xml");
int flag = GetTrunkFlag();
int count = priorityMap.Count;
int bufferBytes = GetStringBufferSize(priorityMap);
var bytes = BitConverter.GetBytes(flag);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, 4);
fs.Write(bytes, 0, bytes.Length);
bytes = BitConverter.GetBytes(count);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, 4);
fs.Write(bytes, 0, bytes.Length);
bytes = BitConverter.GetBytes(bufferBytes);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, 4);
fs.Write(bytes, 0, bytes.Length);
WriteStringBuff(fileInfos, fs);
WriteTrunk(m_PreloadList, fs);
WriteTrunk(m_HighList, fs);
WriteTrunk(m_MediumList, fs);
WriteTrunk(m_NormalList, fs);
WriteTrunk(m_LowList, fs);
WriteTrunk(m_DontLoadList, fs);
fs.Flush();
fs.Close();
}
protected static int ParseListInt(GameDataParser parser, byte[] bytes, int offset, GameDataBase gameDataObj, string fieldName)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var count = BitConverter.ToInt32(bytes, offset);
offset += 4;
List <int> values = new List <int>(count);
for (int i = 0; i < count; i++)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var value = BitConverter.ToInt32(bytes, offset);
offset += 4;
values.Add(value);
}
gameDataObj.SetListInt(fieldName, values);
return(offset);
}
protected int GetItems(byte[] bytes, int offset)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 2);
var itemCount = BitConverter.ToInt16(bytes, offset);
offset += 2;
for (int i = 0; i < itemCount; i++)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 2);
short fieldIndex = BitConverter.ToInt16(bytes, offset);
offset += 2;
string fieldName = m_FieldNameList[fieldIndex];
var type = m_FieldTypeList[fieldIndex];
offset = TypeParseMap[type](this, bytes, offset, m_GameDataInstance, fieldName);
}
return(offset);
}
protected static int ParseHashSetString(GameDataParser parser, byte[] bytes, int offset, GameDataBase gameDataObj, string fieldName)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var count = BitConverter.ToInt32(bytes, offset);
offset += 4;
HashSet <string> values = new HashSet <string>();
for (int i = 0; i < count; i++)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var value = BitConverter.ToInt32(bytes, offset);
offset += 4;
values.Add(parser.m_StringBuffList[value]);
}
gameDataObj.SetHashSetString(fieldName, values);
return(offset);
}
protected int GetStringBuffInfo(byte[] bytes, int offset)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
m_ItemCount = BitConverter.ToInt32(bytes, offset);
offset += 4;
var hasStringBuff = bytes[offset] != 0;
offset += 1;
if (hasStringBuff)
{
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var stringBuffSize = BitConverter.ToInt32(bytes, offset);
offset += 4;
ParseStringCache(bytes, offset, offset += stringBuffSize, m_StringBuffList);
}
return(offset);
}
private byte[] ParseListFloat2(short fieldIndex, string value)
{
List <byte> bytes = new List <byte>();
var data = BitConverter.GetBytes(fieldIndex);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
string[] valueSplit = value.Split(',');
data = BitConverter.GetBytes(valueSplit.Length);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
for (int i = 0; i < valueSplit.Length; i++)
{
var parseResult = valueSplit[i].Split('_');
data = BitConverter.GetBytes(parseResult.Length);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
List <float> listValues = new List <float>(parseResult.Length);
foreach (var v in parseResult)
{
listValues.Add(float.Parse(v));
}
foreach (var v in listValues)
{
data = BitConverter.GetBytes(v);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
}
}
return(bytes.ToArray());
}
private void WriteHead(FileStream fs)
{
var bytes = BitConverter.GetBytes(this.m_FieldCount);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytes.Length);
foreach (var type in this.m_FieldTypeList)
{
fs.WriteByte(type);
}
bytes = BitConverter.GetBytes(m_FieldNameBufferSzie);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytes.Length);
foreach (var fieldName in m_FieldNameList)
{
bytes = Encoding.UTF8.GetBytes(fieldName);
fs.Write(bytes, 0, bytes.Length);
fs.WriteByte(0);
}
}
private byte[] ParseMapS2I(short fieldIndex, string value)
{
List <byte> bytes = new List <byte>();
var data = BitConverter.GetBytes(fieldIndex);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
string[] valueSplit = value.Split(',');
data = BitConverter.GetBytes(valueSplit.Length);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
Dictionary <int, int> keySet = new Dictionary <int, int>();
for (int i = 0; i < valueSplit.Length; i++)
{
var parseResult = valueSplit[i].Split(':');
List <int> listValues = new List <int>(2);
keySet.Add(m_StringBufferToIndexMap[parseResult[0]], int.Parse(parseResult[1])); //有重复的健会报错
listValues.Add(m_StringBufferToIndexMap[parseResult[0]]);
listValues.Add(int.Parse(parseResult[1]));
foreach (var v in listValues)
{
data = BitConverter.GetBytes(v);
BitConverterUtility.ConvertToLittleEndian(data, 0, data.Length);
AddBytesData(bytes, data);
}
}
return(bytes.ToArray());
}
protected int GetHeadInfo(byte[] bytes)
{
var offset = 0;
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 2);
var fieldCount = BitConverter.ToInt16(bytes, offset);
offset += 2;
for (int i = 0; i < fieldCount; i++)
{
m_FieldTypeList.Add(bytes[offset + i]);
}
offset += fieldCount;
BitConverterUtility.ConvertEndianFrom(bytes, true, offset, 4);
var fieldNameBuffSize = BitConverter.ToInt32(bytes, offset);
offset += 4;
ParseStringCache(bytes, offset, offset += fieldNameBuffSize, m_FieldNameList);
return(offset);
}
private static void ExportAssetDependences()
{
List <string> stringBuff = new List <string>();
Dictionary <string, int> stringBuffIndex = new Dictionary <string, int>();
foreach (var gameAsset in GameAssets)
{
var path = EditorFileUtility.GetPathWithoutExt(gameAsset.Value.Path);
if (!stringBuffIndex.ContainsKey(path))
{
stringBuff.Add(path);
stringBuffIndex.Add(path, stringBuff.Count - 1);
}
if (!stringBuffIndex.ContainsKey(gameAsset.Value.AssetBundlePath))
{
stringBuff.Add(gameAsset.Value.AssetBundlePath);
stringBuffIndex.Add(gameAsset.Value.AssetBundlePath, stringBuff.Count - 1);
}
foreach (var dependence in gameAsset.Value.ChildDependences)
{
path = EditorFileUtility.GetPathWithoutExt(dependence);
if (!stringBuffIndex.ContainsKey(path))
{
stringBuff.Add(path);
stringBuffIndex.Add(path, stringBuff.Count - 1);
}
}
}
FileStream fs = File.Create(Application.dataPath + "/Resources/AssetsDependences.xml");
//资源的数量
var count = GameAssets.Count;
var bytes = BitConverter.GetBytes(count);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytes.Length);
//字符串的数量
count = stringBuff.Count;
bytes = BitConverter.GetBytes(count);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytes.Length);
//写入字符串资源
var buffsize = GetStringBufferSize(stringBuff);
bytes = BitConverter.GetBytes(buffsize);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytes.Length);
foreach (var str in stringBuff)
{
bytes = Encoding.UTF8.GetBytes(str);
fs.Write(bytes, 0, bytes.Length);
fs.WriteByte(0);
}
//写入每一个资源的条目
foreach (var gameAsset in GameAssets)
{
var index = stringBuffIndex[EditorFileUtility.GetPathWithoutExt(gameAsset.Value.Path)];
bytes = BitConverter.GetBytes(index);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytes.Length);
index = stringBuffIndex[gameAsset.Value.AssetBundlePath];
bytes = BitConverter.GetBytes(index);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytes.Length);
count = gameAsset.Value.ChildDependences.Count;
bytes = BitConverter.GetBytes(count);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytes.Length);
foreach (var d in gameAsset.Value.ChildDependences)
{
index = stringBuffIndex[EditorFileUtility.GetPathWithoutExt(d)];
bytes = BitConverter.GetBytes(index);
BitConverterUtility.ConvertToLittleEndian(bytes, 0, bytes.Length);
fs.Write(bytes, 0, bytes.Length);
}
}
fs.Flush();
fs.Close();
AssetDatabase.Refresh();
Object[] objs = new Object[1];
objs[0] = AssetDatabase.LoadMainAssetAtPath("Assets/Resources/AssetsDependences.xml");
string[] assetsName = new string[] { "Assets/Resources/AssetsDependences" };
BuildAssetBundle(objs, assetsName, Path.GetDirectoryName(Application.dataPath) + ExportDir + "/AssetsDependences.pkg");
File.Delete(Application.dataPath + "/Resources/AssetsDependences.xml");
File.Delete(Application.dataPath + "/Resources/AssetsDependences.xml.meta");
AssetDatabase.Refresh();
}
