public virtual void Read(BinaryReader reader)
{
this.ChunkType = this._header.ChunkType;
this.Version = this._header.Version;
this.Offset = this._header.Offset;
this.ID = this._header.ID;
this.Size = this._header.Size;
reader.BaseStream.Seek(this._header.Offset, 0);
if (this._model.FileVersion == FileVersionEnum.CryTek_3_4 || this._model.FileVersion == FileVersionEnum.CryTek_3_5)
{
this.ChunkType = (ChunkTypeEnum)Enum.ToObject(typeof(ChunkTypeEnum), reader.ReadUInt32());
this.Version = reader.ReadUInt32();
this.Offset = reader.ReadUInt32();
this.ID = reader.ReadUInt32();
}
if (this.Offset != this._header.Offset || this.Size != this._header.Size)
{
Utils.Log(LogLevelEnum.Warning, "Conflict in chunk definition");
Utils.Log(LogLevelEnum.Warning, "{0:X}+{1:X}", this._header.Offset, this._header.Size);
Utils.Log(LogLevelEnum.Warning, "{0:X}+{1:X}", this.Offset, this.Size);
}
}
/// <summary>
/// Gets the chunk bytes for IP address type chunks.
/// </summary>
public static byte[] GetBytes(ChunkTypeEnum chunkType, IPAddress address)
{
if (chunkType == ChunkTypeEnum.IPv4SourceAddress || chunkType == ChunkTypeEnum.IPv4DesinationAddress)
{
if (address.AddressFamily != AddressFamily.InterNetwork)
{
throw new ApplicationException("Incorrect IP address family suppled to HepChunk.");
}
byte[] buf = InitBuffer(chunkType, MINIMUM_CHUNK_LENGTH + 4);
Buffer.BlockCopy(address.GetAddressBytes(), 0, buf, MINIMUM_CHUNK_LENGTH, 4);
return(buf);
}
else if (chunkType == ChunkTypeEnum.IPv6SourceAddress || chunkType == ChunkTypeEnum.IPv6DesinationAddress)
{
if (address.AddressFamily != AddressFamily.InterNetworkV6)
{
throw new ApplicationException("Incorrect IP address family suppled to HepChunk.");
}
byte[] buf = InitBuffer(chunkType, MINIMUM_CHUNK_LENGTH + 16);
Buffer.BlockCopy(address.GetAddressBytes(), 0, buf, MINIMUM_CHUNK_LENGTH, 16);
return(buf);
}
else
{
throw new ApplicationException("IP address HepChunk does not support the chunk type.");
}
}
// Write an empty node list.
private static void WriteOctreeNodes(MemoryStream stream, ChunkTypeEnum type)
{
new ChunkHeader()
{
ChunkType = type,
Version = CURRENT_VERSION_OCTREE_NODES,
Size = 0
}.WriteTo(stream);
}
public static Chunk New(ChunkTypeEnum chunkType, UInt32 version)
{
switch (chunkType)
{
case ChunkTypeEnum.SourceInfo:
return(Chunk.New <ChunkSourceInfo>(version));
case ChunkTypeEnum.Timing:
return(Chunk.New <ChunkTimingFormat>(version));
case ChunkTypeEnum.ExportFlags:
return(Chunk.New <ChunkExportFlags>(version));
case ChunkTypeEnum.Mtl:
//Utils.Log(LogLevelEnum.Debug, "Mtl Chunk here"); // Obsolete. Not used?
case ChunkTypeEnum.MtlName:
return(Chunk.New <ChunkMtlName>(version));
case ChunkTypeEnum.DataStream:
return(Chunk.New <ChunkDataStream>(version));
case ChunkTypeEnum.Mesh:
return(Chunk.New <ChunkMesh>(version));
case ChunkTypeEnum.MeshSubsets:
return(Chunk.New <ChunkMeshSubsets>(version));
case ChunkTypeEnum.Node:
return(Chunk.New <ChunkNode>(version));
case ChunkTypeEnum.CompiledBones:
return(Chunk.New <ChunkCompiledBones>(version));
case ChunkTypeEnum.Helper:
return(Chunk.New <ChunkHelper>(version));
case ChunkTypeEnum.Controller:
return(Chunk.New <ChunkController>(version));
case ChunkTypeEnum.SceneProps:
return(Chunk.New <ChunkSceneProp>(version));
case ChunkTypeEnum.CompiledPhysicalProxies:
return(Chunk.New <ChunkCompiledPhysicalProxies>(version));
case ChunkTypeEnum.MeshPhysicsData:
return(Chunk.New <ChunkMeshPhysicsData>(version));
default:
return(new ChunkUnknown());
}
}
/// <summary>
/// Gets the chunk bytes for an unsigned int chunk type.
/// </summary>
public static byte[] GetBytes(ChunkTypeEnum chunkType, uint val)
{
byte[] buf = InitBuffer(chunkType, MINIMUM_CHUNK_LENGTH + 4);
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(val)), 0, buf, MINIMUM_CHUNK_LENGTH, 4);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(val), 0, buf, MINIMUM_CHUNK_LENGTH, 4);
}
return(buf);
}
private static void WriteEmptyProviderLeaf(MemoryStream stream, UInt64 key, ChunkTypeEnum type)
{
var header = new ChunkHeader()
{
ChunkType = type,
// ReSharper disable once BuiltInTypeReferenceStyle
Size = 0 + sizeof(UInt64), // increase chunk size by the size of key (which is inserted before it)
Version = CURRENT_VERSION_OCTREE_LEAVES,
};
header.WriteTo(stream);
stream.Write(key);
}
/// <summary>
/// Creates the initial buffer for the HEP packet and sets the vendor, chunk type ID and length fields.
/// Note: Vendor ID could change and make endianess relevant.
/// </summary>
/// <param name="chunkType">The chunk type to set in the serialised chunk.</param>
/// <param name="length">The value to set in the length field of the serialised chunk.</param>
/// <returns>A buffer that contains the serialised chunk EXCEPT for the payload.</returns>
private static byte[] InitBuffer(ChunkTypeEnum chunkType, ushort length)
{
byte[] buf = new byte[length];
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(GENERIC_VENDOR_ID)), 0, buf, 0, 2);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian((ushort)chunkType)), 0, buf, 2, 2);
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian(length)), 0, buf, 4, 2);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes(GENERIC_VENDOR_ID), 0, buf, 0, 2);
Buffer.BlockCopy(BitConverter.GetBytes((ushort)chunkType), 0, buf, 2, 2);
Buffer.BlockCopy(BitConverter.GetBytes(length), 0, buf, 4, 2);
}
return(buf);
}
private static unsafe void WriteOctreeNodes(Stream stream, ChunkTypeEnum type, Dictionary <UInt64, MyOctreeNode> nodes)
{
new ChunkHeader()
{
ChunkType = type,
Version = CURRENT_VERSION_OCTREE_NODES,
Size = nodes.Count * (sizeof(UInt64) + MyOctreeNode.SERIALIZED_SIZE)
}.WriteTo(stream);
foreach (var entry in nodes)
{
stream.WriteNoAlloc(entry.Key);
var node = entry.Value;
stream.WriteNoAlloc(node.ChildMask);
stream.WriteNoAlloc(node.Data, 0, MyOctreeNode.CHILD_COUNT);
}
}
/// <summary>
/// Gets a serialised HEP packet for a SIP request or response that can be sent to a HOMER server.
/// </summary>
/// <param name="srcEndPoint">The end point that sent the SIP request or response.</param>
/// <param name="dstEndPoint">The end point that the SIP request or response was sent to.</param>
/// <param name="timestamp">The timestamp the request or response was generated.</param>
/// <param name="agentID">An agent ID that is used by the HOMER server to identify the agent generating
/// HEP packets. Ideally should be unique amongst all agents logging to the same HOMER server.</param>
/// <param name="password">The password required by the HOMER server. Can be set to null if no password
/// is required. Default value for HOMER5 and 7 is 'myHep".</param>
/// <param name="payload">The SIP request or response.</param>
/// <returns>An array of bytes representing the serialised HEP packet and that is ready for transmission
/// to a HOMER server.</returns>
public static byte[] GetBytes(SIPEndPoint srcEndPoint, SIPEndPoint dstEndPoint, DateTime timestamp, uint agentID, string password, string payload)
{
byte[] packetBuffer = new byte[1024];
int offset = 0;
// HEP3 ASCII code to start the packet.
packetBuffer[0] = 0x48;
packetBuffer[1] = 0x45;
packetBuffer[2] = 0x50;
packetBuffer[3] = 0x33;
offset = 6;
// IP family.
var familyChunkBuffer = HepChunk.GetBytes(ChunkTypeEnum.IPFamily, (byte)srcEndPoint.Address.AddressFamily);
Buffer.BlockCopy(familyChunkBuffer, 0, packetBuffer, offset, familyChunkBuffer.Length);
offset += familyChunkBuffer.Length;
// IP transport layer protocol.
var protocolChunkBuffer = HepChunk.GetBytes(ChunkTypeEnum.IPProtocolID, GetProtocolNumber(srcEndPoint.Protocol));
Buffer.BlockCopy(protocolChunkBuffer, 0, packetBuffer, offset, protocolChunkBuffer.Length);
offset += protocolChunkBuffer.Length;
// Source IP address.
ChunkTypeEnum srcChunkType = srcEndPoint.Address.AddressFamily == AddressFamily.InterNetwork ? ChunkTypeEnum.IPv4SourceAddress : ChunkTypeEnum.IPv6SourceAddress;
var srcIPAddress = HepChunk.GetBytes(srcChunkType, srcEndPoint.Address);
Buffer.BlockCopy(srcIPAddress, 0, packetBuffer, offset, srcIPAddress.Length);
offset += srcIPAddress.Length;
// Destination IP address.
ChunkTypeEnum dstChunkType = dstEndPoint.Address.AddressFamily == AddressFamily.InterNetwork ? ChunkTypeEnum.IPv4DesinationAddress : ChunkTypeEnum.IPv6DesinationAddress;
var dstIPAddress = HepChunk.GetBytes(dstChunkType, dstEndPoint.Address);
Buffer.BlockCopy(dstIPAddress, 0, packetBuffer, offset, dstIPAddress.Length);
offset += dstIPAddress.Length;
// Source port.
var srcPortBuffer = HepChunk.GetBytes(ChunkTypeEnum.SourcePort, (ushort)srcEndPoint.Port);
Buffer.BlockCopy(srcPortBuffer, 0, packetBuffer, offset, srcPortBuffer.Length);
offset += srcPortBuffer.Length;
// Destination port.
var dstPortBuffer = HepChunk.GetBytes(ChunkTypeEnum.DestinationPort, (ushort)dstEndPoint.Port);
Buffer.BlockCopy(dstPortBuffer, 0, packetBuffer, offset, dstPortBuffer.Length);
offset += dstPortBuffer.Length;
// Timestamp.
var timestampBuffer = HepChunk.GetBytes(ChunkTypeEnum.TimestampSeconds, (uint)timestamp.GetEpoch());
Buffer.BlockCopy(timestampBuffer, 0, packetBuffer, offset, timestampBuffer.Length);
offset += timestampBuffer.Length;
// Timestamp micro seconds (.NET only has milliscond resolution).
var timestampMicrosBuffer = HepChunk.GetBytes(ChunkTypeEnum.TimestampMicroSeconds, (uint)(timestamp.Millisecond * 1000));
Buffer.BlockCopy(timestampMicrosBuffer, 0, packetBuffer, offset, timestampMicrosBuffer.Length);
offset += timestampMicrosBuffer.Length;
// Protocol type, only interested in SIP at this point.
var protocolTypeBuffer = HepChunk.GetBytes(ChunkTypeEnum.ProtocolType, (byte)CaptureProtocolTypeEnum.SIP);
Buffer.BlockCopy(protocolTypeBuffer, 0, packetBuffer, offset, protocolTypeBuffer.Length);
offset += protocolTypeBuffer.Length;
// Capture agent ID.
var agentIDBuffer = HepChunk.GetBytes(ChunkTypeEnum.CaptureAgentID, agentID);
Buffer.BlockCopy(agentIDBuffer, 0, packetBuffer, offset, agentIDBuffer.Length);
offset += agentIDBuffer.Length;
// Auth key
if (!String.IsNullOrEmpty(password))
{
var passwordBuffer = HepChunk.GetBytes(ChunkTypeEnum.AuthenticationKey, Encoding.UTF8.GetBytes(password));
Buffer.BlockCopy(passwordBuffer, 0, packetBuffer, offset, passwordBuffer.Length);
offset += passwordBuffer.Length;
}
// Payload
var payloadBuffer = HepChunk.GetBytes(ChunkTypeEnum.CapturedPayload, Encoding.UTF8.GetBytes(payload));
Buffer.BlockCopy(payloadBuffer, 0, packetBuffer, offset, payloadBuffer.Length);
offset += payloadBuffer.Length;
// Length
if (BitConverter.IsLittleEndian)
{
Buffer.BlockCopy(BitConverter.GetBytes(NetConvert.DoReverseEndian((ushort)offset)), 0, packetBuffer, 4, 2);
}
else
{
Buffer.BlockCopy(BitConverter.GetBytes((ushort)offset), 0, packetBuffer, 4, 2);
}
return(packetBuffer.Take(offset).ToArray());
}
/// <summary>
/// Gets the chunk bytes for an arbitrary payload.
/// </summary>
public static byte[] GetBytes(ChunkTypeEnum chunkType, byte[] payload)
{
byte[] buf = InitBuffer(chunkType, (ushort)(MINIMUM_CHUNK_LENGTH + payload.Length));
Buffer.BlockCopy(payload, 0, buf, MINIMUM_CHUNK_LENGTH, (ushort)payload.Length);
return(buf);
}
/// <summary>
/// Gets the chunk bytes for a single byte chunk type.
/// </summary>
public static byte[] GetBytes(ChunkTypeEnum chunkType, byte val)
{
byte[] buf = InitBuffer(chunkType, MINIMUM_CHUNK_LENGTH + 1);
buf[MINIMUM_CHUNK_LENGTH] = val;
return(buf);
}
private static void WriteDefaultMicroOctreeLeaf(MemoryStream stream, UInt64 key, ChunkTypeEnum type, byte val)
{
var header = new ChunkHeader()
{
ChunkType = type,
// ReSharper disable once BuiltInTypeReferenceStyle
Size =
sizeof(int) + sizeof(byte) +
sizeof(UInt64), // increase chunk size by the size of key (which is inserted before it)
Version = CURRENT_VERSION_OCTREE_LEAVES,
};
header.WriteTo(stream);
stream.Write(4); // micro octree height
stream.Write(val); // micro octree default value
// don't write any nodes. (this *should* be okay)
}
public void ReadFrom(Stream stream)
{
ChunkType = (ChunkTypeEnum)stream.Read7BitEncodedInt();
Version = stream.Read7BitEncodedInt();
Size = stream.Read7BitEncodedInt();
}
public static Chunk New(ChunkTypeEnum chunkType, UInt32 version)
{
switch (chunkType)
{
case ChunkTypeEnum.SourceInfo:
return(Chunk.New <ChunkSourceInfo>(version));
case ChunkTypeEnum.Timing:
return(Chunk.New <ChunkTimingFormat>(version));
case ChunkTypeEnum.ExportFlags:
return(Chunk.New <ChunkExportFlags>(version));
case ChunkTypeEnum.MtlName:
return(Chunk.New <ChunkMtlName>(version));
case ChunkTypeEnum.DataStream:
return(Chunk.New <ChunkDataStream>(version));
case ChunkTypeEnum.Mesh:
return(Chunk.New <ChunkMesh>(version));
case ChunkTypeEnum.MeshSubsets:
return(Chunk.New <ChunkMeshSubsets>(version));
case ChunkTypeEnum.Node:
return(Chunk.New <ChunkNode>(version));
case ChunkTypeEnum.Helper:
return(Chunk.New <ChunkHelper>(version));
case ChunkTypeEnum.Controller:
return(Chunk.New <ChunkController>(version));
case ChunkTypeEnum.SceneProps:
return(Chunk.New <ChunkSceneProp>(version));
case ChunkTypeEnum.MeshPhysicsData:
return(Chunk.New <ChunkMeshPhysicsData>(version));
case ChunkTypeEnum.BoneAnim:
return(Chunk.New <ChunkBoneAnim>(version));
// Compiled chunks
case ChunkTypeEnum.CompiledBones:
return(Chunk.New <ChunkCompiledBones>(version));
case ChunkTypeEnum.CompiledPhysicalProxies:
return(Chunk.New <ChunkCompiledPhysicalProxies>(version));
case ChunkTypeEnum.CompiledPhysicalBones:
return(Chunk.New <ChunkCompiledPhysicalBones>(version));
case ChunkTypeEnum.CompiledIntSkinVertices:
return(Chunk.New <ChunkCompiledIntSkinVertices>(version));
case ChunkTypeEnum.CompiledMorphTargets:
return(Chunk.New <ChunkCompiledMorphTargets>(version));
case ChunkTypeEnum.CompiledExt2IntMap:
return(Chunk.New <ChunkCompiledExtToIntMap>(version));
case ChunkTypeEnum.CompiledIntFaces:
return(Chunk.New <ChunkCompiledIntFaces>(version));
// Star Citizen equivalents
case ChunkTypeEnum.CompiledBonesSC:
return(Chunk.New <ChunkCompiledBones>(version));
case ChunkTypeEnum.CompiledPhysicalBonesSC:
return(Chunk.New <ChunkCompiledPhysicalBones>(version));
case ChunkTypeEnum.CompiledExt2IntMapSC:
return(Chunk.New <ChunkCompiledExtToIntMap>(version));
case ChunkTypeEnum.CompiledIntFacesSC:
return(Chunk.New <ChunkCompiledIntFaces>(version));
case ChunkTypeEnum.CompiledIntSkinVerticesSC:
return(Chunk.New <ChunkCompiledIntSkinVertices>(version));
case ChunkTypeEnum.CompiledMorphTargetsSC:
return(Chunk.New <ChunkCompiledMorphTargets>(version));
case ChunkTypeEnum.CompiledPhysicalProxiesSC:
return(Chunk.New <ChunkCompiledPhysicalProxies>(version));
// Old chunks
case ChunkTypeEnum.BoneNameList:
return(Chunk.New <ChunkBoneNameList>(version));
case ChunkTypeEnum.MeshMorphTarget:
return(Chunk.New <ChunkMeshMorphTargets>(version));
case ChunkTypeEnum.Mtl:
//Utils.Log(LogLevelEnum.Debug, "Mtl Chunk here"); // Obsolete. Not used
default:
return(new ChunkUnknown());
}
}
public void ReadFrom(Stream stream)
{
ChunkType = (ChunkTypeEnum)stream.Read7BitEncodedInt();
Version = stream.Read7BitEncodedInt();
Size = stream.Read7BitEncodedInt();
}
