private static void TraverseMap(XmlNode node, PsoBuilder pb, PsoStructureEntryInfo entry, PsoStructureInfo infos, byte[] data, PsoArrayResults arrayResults)
{
var mapidx1 = entry.ReferenceKey & 0x0000FFFF;
var mapidx2 = (entry.ReferenceKey >> 16) & 0x0000FFFF;
var mapreftype1 = infos.Entries[mapidx2];
var mapreftype2 = infos.Entries[mapidx1];
if (mapreftype2.ReferenceKey != 0)
{
}
var xStruct = pb.AddMapNodeStructureInfo((MetaName)mapreftype2.ReferenceKey);
var xName = xStruct.IndexInfo.NameHash;
var kEntry = xStruct?.FindEntry(MetaName.Key);
var iEntry = xStruct?.FindEntry(MetaName.Item);
if (kEntry.Type != PsoDataType.String)
{
}
List <byte[]> nodesData = new List <byte[]>();
foreach (XmlNode cnode in node.ChildNodes)
{
var kattr = cnode.Attributes["key"].Value;
var tattr = cnode.Attributes["type"].Value;//CW invention for convenience..!
var khash = (MetaName)(uint)GetHash(kattr);
var thash = (MetaName)(uint)GetHash(tattr);
byte[] strucBytes = Traverse(cnode, pb, thash);
byte[] nodeBytes = new byte[xStruct.StructureLength];
TraverseStringRaw(kattr, pb, kEntry, nodeBytes); //write the key
if (xName != (MetaName)MetaTypeName.ARRAYINFO) // (mapreftype2.ReferenceKey != 0)
{
//value struct embedded in ARRAYINFO node
Buffer.BlockCopy(strucBytes, 0, nodeBytes, iEntry.DataOffset, strucBytes.Length);
}
else
{
//normal ARRAYINFO with pointer value
var itemptr = pb.AddItemPtr(thash, strucBytes);
itemptr.SwapEnd(); //big schmigg
var ptrbytes = MetaTypes.ConvertToBytes(itemptr);
Buffer.BlockCopy(ptrbytes, 0, nodeBytes, iEntry.DataOffset, ptrbytes.Length);
}
nodesData.Add(nodeBytes);
}
Write(0x1000000, data, entry.DataOffset);
Write(0, data, entry.DataOffset + 4);
arrayResults.Structures[entry.DataOffset + 8] = pb.AddItemArrayPtr(xName, nodesData.ToArray()); //pb.AddPointerArray(nodeptrs);
}
private void EnsureInstances(Meta Meta)
{
if (CMapData.instancedData.GrassInstanceList.Count1 != 0)
{
rage__fwGrassInstanceListDef[] batches = MetaTypes.ConvertDataArray <rage__fwGrassInstanceListDef>(Meta, MetaName.rage__fwGrassInstanceListDef, CMapData.instancedData.GrassInstanceList);
YmapGrassInstanceBatch[] gbatches = new YmapGrassInstanceBatch[batches.Length];
for (int i = 0; i < batches.Length; i++)
{
var batch = batches[i];
rage__fwGrassInstanceListDef__InstanceData[] instdatas = MetaTypes.ConvertDataArray <rage__fwGrassInstanceListDef__InstanceData>(Meta, MetaName.rage__fwGrassInstanceListDef__InstanceData, batch.InstanceList);
YmapGrassInstanceBatch gbatch = new YmapGrassInstanceBatch();
gbatch.Ymap = this;
gbatch.Batch = batch;
gbatch.Instances = instdatas;
gbatch.Position = (batch.BatchAABB.min.XYZ() + batch.BatchAABB.max.XYZ()) * 0.5f;
gbatch.Radius = (batch.BatchAABB.max.XYZ() - gbatch.Position).Length();
gbatch.AABBMin = (batch.BatchAABB.min.XYZ());
gbatch.AABBMax = (batch.BatchAABB.max.XYZ());
gbatches[i] = gbatch;
}
GrassInstanceBatches = gbatches;
}
if (CMapData.instancedData.PropInstanceList.Count1 != 0)
{
}
}
public override void Read(ResourceDataReader reader, params object[] parameters)
{
int datalength = ItemCount * StructureSize;
byte[] data = reader.ReadBytes(datalength);
Items = MetaTypes.ConvertDataArray <T>(data, 0, ItemCount);
}
public void SwapEnd()
{
VersionNumber = MetaTypes.SwapBytes(VersionNumber);
var r = RegionDefs; r.SwapEnd(); RegionDefs = r;
var g = Groups; g.SwapEnd(); Groups = g;
var i = InteriorNames; i.SwapEnd(); InteriorNames = i;
}
public void SwapEnd()
{
Pointer = MetaTypes.SwapBytes(Pointer);
Count1 = MetaTypes.SwapBytes(Count1);
Count2 = MetaTypes.SwapBytes(Count2);
Unk1 = MetaTypes.SwapBytes(Unk1);
}
public Array_Structure SwapEnd()
{
Pointer = MetaTypes.SwapBytes(Pointer);
Count1 = MetaTypes.SwapBytes(Count1);
Count2 = MetaTypes.SwapBytes(Count2);
Unk1 = MetaTypes.SwapBytes(Unk1);
return(this);
}
private static int GetEnumInt(MetaName type, string enumString, MetaStructureEntryDataType dataType)
{
var infos = MetaTypes.GetEnumInfo(type);
if (infos == null)
{
return(0);
}
bool isFlags = (dataType == MetaStructureEntryDataType.IntFlags1) ||
(dataType == MetaStructureEntryDataType.IntFlags2);// ||
//(dataType == MetaStructureEntryDataType.ShortFlags);
if (isFlags)
{
//flags enum. (multiple values, comma-separated)
var split = enumString.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
int enumVal = 0;
for (int i = 0; i < split.Length; i++)
{
var enumName = (MetaName)(uint)GetHash(split[i].Trim());
for (int j = 0; j < infos.Entries.Length; j++)
{
var entry = infos.Entries[j];
if (entry.EntryNameHash == enumName)
{
enumVal += (1 << entry.EntryValue);
break;
}
}
}
return(enumVal);
}
else
{
//single value enum.
var enumName = (MetaName)(uint)GetHash(enumString);
for (int j = 0; j < infos.Entries.Length; j++)
{
var entry = infos.Entries[j];
if (entry.EntryNameHash == enumName)
{
return(entry.EntryValue);
}
}
}
return(0);
}
private void WriteBytes <T>(T val, int offset) where T : struct
{
var data = MetaTypes.ConvertToBytes(val);
for (int i = 0; i < data.Length; i++)
{
Bytes[offset + i] = data[i];
}
}
public void SwapEnd()
{
Name = new MetaHash(MetaTypes.SwapBytes(Name.Hash));
var b = Bounds; b.SwapEnd(); Bounds = b;
var w = WeatherTypes; w.SwapEnd(); WeatherTypes = w;
HoursOnOff = MetaTypes.SwapBytes(HoursOnOff);
Flags = MetaTypes.SwapBytes(Flags);
}
private static void TraverseStringRaw(string str, PsoBuilder pb, PsoStructureEntryInfo entry, byte[] data)
{
switch (entry.Unk_5h)
{
default:
break;
case 0:
var str0len = (int)((entry.ReferenceKey >> 16) & 0xFFFF);
if (!string.IsNullOrEmpty(str))
{
byte[] strdata = Encoding.ASCII.GetBytes(str);
Buffer.BlockCopy(strdata, 0, data, entry.DataOffset, strdata.Length);
if (strdata.Length > str0len)
{
}
}
break;
case 1:
case 2:
if (!string.IsNullOrEmpty(str))
{
var bptr = pb.AddString(str);
var ptr = new PsoPOINTER(bptr.BlockID, bptr.Offset);
ptr.SwapEnd();
var val = MetaTypes.ConvertToBytes(ptr);
Buffer.BlockCopy(val, 0, data, entry.DataOffset, val.Length);
}
break;
case 3:
if (!string.IsNullOrEmpty(str))
{
var bptr = pb.AddString(str);
var ptr = new CharPointer(bptr.Pointer, str.Length);
ptr.SwapEnd();
var val = MetaTypes.ConvertToBytes(ptr);
Buffer.BlockCopy(val, 0, data, entry.DataOffset, val.Length);
}
break;
case 7: //hash only?
case 8: //hash with STRF entry?
var hashVal = string.IsNullOrEmpty(str) ? 0 : GetHash(str);
Write(hashVal, data, entry.DataOffset);
if (entry.Unk_5h == 8)
{
pb.AddStringToSTRF(str);
}
break;
}
}
private static Vector4[] TraverseVector3ArrayRaw(XmlNode node)
{
var items = new List <Vector4>();
var split = node.InnerText.Split('\n');// Regex.Split(node.InnerText, @"[\s\r\n\t]");
float x = 0f;
float y = 0f;
float z = 0f;
float w = 0f;
for (int i = 0; i < split.Length; i++)
{
var s = split[i]?.Trim();
if (string.IsNullOrEmpty(s))
{
continue;
}
var split2 = Regex.Split(s, @"[\s\t]");
int c = 0;
x = 0f; y = 0f; z = 0f;
for (int n = 0; n < split2.Length; n++)
{
var ts = split2[n]?.Trim();
if (ts.EndsWith(","))
{
ts = ts.Substring(0, ts.Length - 1);
}
if (string.IsNullOrEmpty(ts))
{
continue;
}
var f = FloatUtil.Parse(ts);
switch (c)
{
case 0: x = f; break;
case 1: y = f; break;
case 2: z = f; break;
}
c++;
}
if (c >= 3)
{
var val = new Vector4(x, y, z, w);
items.Add(MetaTypes.SwapBytes(val)); //big schmig
}
}
return(items.ToArray());
}
public void LoadChildren(Meta meta)
{
var centities = MetaTypes.ConvertDataArray <CEntityDef>(meta, MetaName.CEntityDef, _MloArchetypeDefData.entities);
if (centities != null)
{
entities = new MCEntityDef[centities.Length];
for (int i = 0; i < centities.Length; i++)
{
entities[i] = new MCEntityDef(meta, ref centities[i])
{
Archetype = this
};
}
}
var crooms = MetaTypes.ConvertDataArray <CMloRoomDef>(meta, MetaName.CMloRoomDef, _MloArchetypeDefData.rooms);
if (crooms != null)
{
rooms = new MCMloRoomDef[crooms.Length];
for (int i = 0; i < crooms.Length; i++)
{
rooms[i] = new MCMloRoomDef(meta, crooms[i])
{
Archetype = this, Index = i
};
}
}
var cportals = MetaTypes.ConvertDataArray <CMloPortalDef>(meta, MetaName.CMloPortalDef, _MloArchetypeDefData.portals);
if (cportals != null)
{
portals = new MCMloPortalDef[cportals.Length];
for (int i = 0; i < cportals.Length; i++)
{
portals[i] = new MCMloPortalDef(meta, cportals[i]);
}
}
var centitySets = MetaTypes.ConvertDataArray <CMloEntitySet>(meta, MetaName.CMloEntitySet, _MloArchetypeDefData.entitySets);
if (centitySets != null)
{
entitySets = new MCMloEntitySet[centitySets.Length];
for (int i = 0; i < centitySets.Length; i++)
{
entitySets[i] = new MCMloEntitySet(meta, centitySets[i]);
}
}
timeCycleModifiers = MetaTypes.ConvertDataArray <CMloTimeCycleModifier>(meta, MetaName.CMloTimeCycleModifier, _MloArchetypeDefData.timeCycleModifiers);
}
public void AddStructureInfo(MetaName name)
{
if (!StructureInfos.ContainsKey(name))
{
MetaStructureInfo si = MetaTypes.GetStructureInfo(name);
if (si != null)
{
StructureInfos[name] = si;
}
}
}
public void AddEnumInfo(MetaName name)
{
if (!EnumInfos.ContainsKey(name))
{
MetaEnumInfo ei = MetaTypes.GetEnumInfo(name);
if (ei != null)
{
EnumInfos[name] = ei;
}
}
}
internal Trait(
MetaTypes _metaType,
ushort _structureType,
EntityId _entityId,
LatticeId _latticeId)
{
TraitType = _traitType;
EntityId = _entityId;
LatticeId = _latticeId;
}
private void EnsureDistantLODLights(Meta Meta)
{
if (CMapData.DistantLODLightsSOA.position.Count1 != 0)
{
DistantLODLights = new YmapDistantLODLights();
DistantLODLights.Ymap = this;
DistantLODLights.CDistantLODLight = CMapData.DistantLODLightsSOA;
DistantLODLights.colours = MetaTypes.GetUintArray(Meta, CMapData.DistantLODLightsSOA.RGBI);
DistantLODLights.positions = MetaTypes.ConvertDataArray <MetaVECTOR3>(Meta, MetaName.VECTOR3, CMapData.DistantLODLightsSOA.position);
DistantLODLights.CalcBB();
}
}
private void EnsureOccludeModels(Meta meta)
{
COccludeModels = MetaTypes.ConvertDataArray <Unk_2741784237>(Meta, (MetaName)2741784237, CMapData.occludeModels);
if (COccludeModels != null)
{
OccludeModels = new YmapOccludeModel[COccludeModels.Length];
for (int i = 0; i < COccludeModels.Length; i++)
{
OccludeModels[i] = new YmapOccludeModel(this, COccludeModels[i]);
}
}
}
private static MetaHash[] TraverseHashArrayRaw(XmlNode node)
{
var items = new List <MetaHash>();
foreach (XmlNode cnode in node.ChildNodes)
{
var val = GetHash(cnode.InnerText);
items.Add(MetaTypes.SwapBytes(val));
}
return(items.ToArray());
}
private void EnsureBoxOccluders(Meta meta)
{
CBoxOccluders = MetaTypes.ConvertDataArray <Unk_975711773>(Meta, (MetaName)975711773, CMapData.boxOccluders);
if (CBoxOccluders != null)
{
BoxOccluders = new YmapBoxOccluder[CBoxOccluders.Length];
for (int i = 0; i < CBoxOccluders.Length; i++)
{
BoxOccluders[i] = new YmapBoxOccluder(this, CBoxOccluders[i]);
}
}
}
public static uint[] GetUintArray(PsoFile pso, Array_uint arr)
{
uint[] uints = GetUintArrayRaw(pso, arr);
if (uints == null)
{
return(null);
}
for (int i = 0; i < uints.Length; i++)
{
uints[i] = MetaTypes.SwapBytes(uints[i]);
}
return(uints);
}
/// <summary>
/// Returns the MetaType for the specified Type.
/// </summary>
/// <param name="type">The Type to provide the MetaType for.</param>
/// <returns>The constructed MetaType.</returns>
public static MetaType GetMetaType(Type type)
{
Debug.Assert(!TypeUtility.IsPredefinedType(type), "Should never attempt to create a MetaType for a base type.");
MetaType metaType = null;
if (!MetaTypes.TryGetValue(type, out metaType))
{
metaType = new MetaType(type);
MetaTypes[type] = metaType;
}
return(metaType);
}
public static float[] GetFloatArray(PsoFile pso, Array_float arr)
{
float[] floats = GetFloatArrayRaw(pso, arr);
if (floats == null)
{
return(null);
}
for (int i = 0; i < floats.Length; i++)
{
floats[i] = MetaTypes.SwapBytes(floats[i]);
}
return(floats);
}
public static ushort[] GetUShortArray(PsoFile pso, Array_Structure arr)
{
ushort[] ushorts = GetUShortArrayRaw(pso, arr);
if (ushorts == null)
{
return(null);
}
for (int i = 0; i < ushorts.Length; i++)
{
ushorts[i] = MetaTypes.SwapBytes(ushorts[i]);
}
return(ushorts);
}
private void EnsureCarGens(Meta Meta)
{
CCarGens = MetaTypes.ConvertDataArray <CCarGen>(Meta, MetaName.CCarGen, CMapData.carGenerators);
if (CCarGens != null)
{
//string str = MetaTypes.GetTypesInitString(resentry, Meta); //to generate structinfos and enuminfos
CarGenerators = new YmapCarGen[CCarGens.Length];
for (int i = 0; i < CCarGens.Length; i++)
{
CarGenerators[i] = new YmapCarGen(this, CCarGens[i]);
}
}
}
public static MetaHash[] GetHashArray(PsoFile pso, Array_uint arr)
{
uint[] uints = GetUintArrayRaw(pso, arr);
if (uints == null)
{
return(null);
}
MetaHash[] hashes = new MetaHash[uints.Length];
for (int n = 0; n < uints.Length; n++)
{
hashes[n].Hash = MetaTypes.SwapBytes(uints[n]);
}
return(hashes);
}
public void WriteArrays(byte[] data)
{
foreach (KeyValuePair <int, Array_Structure> ptr in Structures)
{
var _data = MetaTypes.ConvertToBytes(ptr.Value);
Buffer.BlockCopy(_data, 0, data, ptr.Key, _data.Length);
}
foreach (KeyValuePair <int, Array_StructurePointer> ptr in StructurePointers)
{
var _data = MetaTypes.ConvertToBytes(ptr.Value);
Buffer.BlockCopy(_data, 0, data, ptr.Key, _data.Length);
}
foreach (KeyValuePair <int, Array_uint> ptr in UInts)
{
var _data = MetaTypes.ConvertToBytes(ptr.Value);
Buffer.BlockCopy(_data, 0, data, ptr.Key, _data.Length);
}
foreach (KeyValuePair <int, Array_ushort> ptr in UShorts)
{
var _data = MetaTypes.ConvertToBytes(ptr.Value);
Buffer.BlockCopy(_data, 0, data, ptr.Key, _data.Length);
}
foreach (KeyValuePair <int, Array_byte> ptr in UBytes)
{
var _data = MetaTypes.ConvertToBytes(ptr.Value);
Buffer.BlockCopy(_data, 0, data, ptr.Key, _data.Length);
}
foreach (KeyValuePair <int, Array_float> ptr in Floats)
{
var _data = MetaTypes.ConvertToBytes(ptr.Value);
Buffer.BlockCopy(_data, 0, data, ptr.Key, _data.Length);
}
foreach (KeyValuePair <int, Array_Vector3> ptr in Float_XYZs)
{
var _data = MetaTypes.ConvertToBytes(ptr.Value);
Buffer.BlockCopy(_data, 0, data, ptr.Key, _data.Length);
}
foreach (KeyValuePair <int, Array_uint> ptr in Hashes)
{
var _data = MetaTypes.ConvertToBytes(ptr.Value);
Buffer.BlockCopy(_data, 0, data, ptr.Key, _data.Length);
}
}
private void LoadMeta()
{
var vVariationInfo = MetaTypes.GetTypedData <CPedVariationInfo>(Meta, MetaName.CPedVariationInfo);
VariationInfo = new MCPedVariationInfo();
VariationInfo.Load(Meta, vVariationInfo);
Strings = MetaTypes.GetStrings(Meta);
if (Strings != null)
{
foreach (string str in Strings)
{
JenkIndex.Ensure(str); //just shove them in there
}
}
}
//public uint PadCount { get; set; }
//public byte[] PadData { get; set; }
//public string[] TestStrings { get; set; }
public override void Read(ResourceDataReader reader, params object[] parameters)
{
Count = MetaTypes.SwapBytes(reader.ReadUInt32()); //okay. so this is big endian
EncryptedData = reader.ReadBytes((int)Count);
//PadCount = (uint)((8 - (reader.Position % 8)) % 8);//maybe next block just needs to be aligned instead?
//PadData = reader.ReadBytes((int)PadCount);
////none of these work :(
//var strs = new List<string>();
//foreach (var key in GTA5Keys.PC_NG_KEYS)
//{
// var decr = GTACrypto.DecryptNG(EncryptedData, key);
// strs.Add(Encoding.ASCII.GetString(decr));
//}
//TestStrings = strs.ToArray();
}
private void EnsureTimeCycleModifiers(Meta Meta)
{
CTimeCycleModifiers = MetaTypes.ConvertDataArray <CTimeCycleModifier>(Meta, MetaName.CTimeCycleModifier, CMapData.timeCycleModifiers);
if (CTimeCycleModifiers != null)
{
TimeCycleModifiers = new YmapTimeCycleModifier[CTimeCycleModifiers.Length];
for (int i = 0; i < CTimeCycleModifiers.Length; i++)
{
YmapTimeCycleModifier tcm = new YmapTimeCycleModifier();
tcm.Ymap = this;
tcm.CTimeCycleModifier = CTimeCycleModifiers[i];
tcm.BBMin = tcm.CTimeCycleModifier.minExtents;
tcm.BBMax = tcm.CTimeCycleModifier.maxExtents;
TimeCycleModifiers[i] = tcm;
}
}
}
private void LoadScenarioPointRegion(Meta meta, MetaDataBlock rootblock)
{
FileFormat = YmtFileFormat.RSC;
ContentType = YmtFileContentType.ScenarioPointRegion;
var cdata = MetaTypes.ConvertData <CScenarioPointRegion>(rootblock.Data);
CScenarioPointRegion = new MCScenarioPointRegion();
CScenarioPointRegion.Ymt = this;
CScenarioPointRegion.Load(meta, cdata);
ScenarioRegion = new ScenarioRegion();
ScenarioRegion.Load(this);
//string stypes = MetaTypes.GetTypesInitString(meta);
//if (!string.IsNullOrEmpty(stypes))
//{ }
}
/// <summary>
/// Add meta info to the PoIType.
/// </summary>
/// <param name="title">Display title</param>
/// <param name="source">Source label</param>
/// <param name="type"></param>
/// <param name="searchable"></param>
/// <param name="visibleInCallout"></param>
/// <param name="section"></param>
/// <param name="options"></param>
/// <param name="minvalue"></param>
/// <param name="maxvalue"></param>
/// <param name="format"></param>
/// <param name="editActive"></param>
/// <param name="canEdit"></param>
public MetaInfo AddMetaInfo(string title, string source, MetaTypes type = MetaTypes.text, bool searchable = false,
bool visibleInCallout = true, string section = "Info", List<string> options = null, double minvalue = Double.NaN,
double maxvalue = Double.NaN, string format = null, bool editActive = false, bool canEdit = true)
{
var metaInfo = MetaInfo ?? new MetaInfoCollection();
var mi = new MetaInfo
{
Label = source,
Title = title,
Type = type,
VisibleInCallOut = visibleInCallout,
IsSearchable = searchable,
Options = options,
MinValue = minvalue,
MaxValue = maxvalue,
StringFormat = format,
EditActive = editActive,
IsEditable = canEdit
};
if (!String.IsNullOrEmpty(section))
mi.Section = section;
metaInfo.Add(mi);
MetaInfo = metaInfo;
return mi;
}
