public override async Task SetObject(string filename, List <DomainNameTableEntry> nameTable, object configuration)
{
this.Modified = true;
Font = File.ReadAllBytes(filename);
FontLength = BitConverter.GetBytes(Font.Length);
ByteArrayReader FontReader = ByteArrayReader.CreateNew(FontLength.Concat(Font).ToArray(), 0);
PropertyHeader.GetProperty("Buffer").FirstOrDefault().Value.SetPropertyValue(FontReader);
PropertyHeader.GetProperty("Buffer").FirstOrDefault().Value.GetBuilderSize();
// GlyphTypeface ttf = new GlyphTypeface(new Uri(filename));
// PropertyHeader.GetProperty("FontFamilyNameArray").First().Value.SetPropertyValue(new DomainString("Lovely Creamy"));
// PropertyHeader.GetProperty("FontStyleNameArray").First().Value.SetPropertyValue(new DomainString("Lovely Creamy"));
// PropertyHeader.GetProperty("FontFullNameArray").First().Value.SetPropertyValue(new DomainString("Lovely Creamy"));
var FontFamilyName = (DomainPropertyNameArray)PropertyHeader.GetProperty("FontFamilyNameArray").First().Value;
var FontStyleName = (DomainPropertyNameArray)PropertyHeader.GetProperty("FontStyleNameArray").First().Value;
var FontFullName = (DomainPropertyNameArray)PropertyHeader.GetProperty("FontFullNameArray").First().Value;
// string FontFamilyName = ttf.Win32FamilyNames.Values.FirstOrDefault();
// string FontStyleNamee = ttf.Win32FaceNames.Values.FirstOrDefault();
Debug.WriteLine("hi2");
}
public override int GetBuilderSize()
{
BuilderSize = PropertyHeader.GetBuilderSize()
+ AdditionalDataReader?.GetBytes().Length ?? 0;
return(BuilderSize);
}
/**
* Fills tree view with description of this token
*
* @param Tree Tree to fill in
* @param ActorFilter Filter for actor name
* @param PropertyFilter Filter for property name
* @param RPCFilter Unused
*/
public override void ToDetailedTreeView(TreeNodeCollection Tree, FilterValues InFilterValues)
{
TreeNode Child = TokenHelper.AddNode(Tree, "Replicated Actors");
int NumReplicatedBits = GetNumReplicatedBits(InFilterValues);
string Flags = (bNetDirty ? "bNetDirty " : "") + (bNetInitial ? "bNetInitial" : "") + (bNetOwner ? "bNetOwner" : "");
Child = Child.Nodes.Add(string.Format("{0,-32} : {1:0.00} ({2:000}) ", NetworkStream.GetName(ActorNameIndex), TimeInMS, NumReplicatedBits / 8) + Flags);
if (Properties.Count > 0)
{
TreeNode NewChild = Child.Nodes.Add("Properties");
foreach (var Property in Properties)
{
if (Property.MatchesFilters(InFilterValues))
{
NewChild.Nodes.Add(string.Format("{0,-25} : {1:000}", NetworkStream.GetName(Property.PropertyNameIndex), Property.NumBits / 8.0f));
}
}
}
if (PropertyHeaders.Count > 0)
{
TreeNode NewChild = Child.Nodes.Add("Property Headers");
foreach (var PropertyHeader in PropertyHeaders)
{
if (PropertyHeader.MatchesFilters(InFilterValues))
{
NewChild.Nodes.Add(string.Format("{0,-25} : {1:000}", NetworkStream.GetName(PropertyHeader.PropertyNameIndex), PropertyHeader.NumBits / 8.0f));
}
}
}
}
public override async Task SetObject(string filename, List <DomainNameTableEntry> nameTable, object configuration)
{
filename = @"C:\Users\User\BnS\modding\export_new\bns\CookedPC\00054840\pomf.ogg";
Sounds[0] = File.ReadAllBytes(filename);
DomainPropertyFloatValue duration = PropertyHeader.GetProperty("Duration").FirstOrDefault()?.Value as DomainPropertyFloatValue;
DomainPropertyIntValue numchannels = PropertyHeader.GetProperty("NumChannels").FirstOrDefault()?.Value as DomainPropertyIntValue;
DomainPropertyIntValue samplerate = PropertyHeader.GetProperty("SampleRate").FirstOrDefault()?.Value as DomainPropertyIntValue;
DomainPropertyIntValue sampledatasize = PropertyHeader.GetProperty("SampleDataSize").FirstOrDefault()?.Value as DomainPropertyIntValue;
using (var vorbis = new NVorbis.VorbisReader(filename))
{
var channels = vorbis.Channels;
var sampleRate = vorbis.SampleRate;
// OPTIONALLY: get a TimeSpan indicating the total length of the Vorbis stream
var totalTime = vorbis.TotalTime;
// create a buffer for reading samples
var readBuffer = new float[channels * sampleRate / 5]; // 200ms
// get the initial position (obviously the start)
var position = System.TimeSpan.Zero;
System.Diagnostics.Debug.WriteLine("Hm");
duration?.SetPropertyValue((float)totalTime.TotalSeconds);
numchannels?.SetPropertyValue(channels);
samplerate?.SetPropertyValue(sampleRate);
sampledatasize?.SetPropertyValue(vorbis.TotalSamples * 2);
System.Diagnostics.Debug.WriteLine("Hm");
}
// sizeX?.SetPropertyValue(skipFirstMip ? width * 2 : width);
// sizeY?.SetPropertyValue(skipFirstMip ? height * 2 : height);
}
public override int GetBuilderSize()
{
BuilderSize = PropertyHeader.GetBuilderSize()
+ sizeof(int);
return(BuilderSize);
}
private Stream buildDdsImage(int mipMapIndex, out FileFormat imageFormat)
{
DomainPropertyByteValue formatProp = PropertyHeader.GetProperty("Format").FirstOrDefault()?.Value as DomainPropertyByteValue;
imageFormat = FileFormat.Unknown;
if (formatProp == null)
{
return(null);
}
string format = formatProp.PropertyString;
DomainMipMap mipMap = MipMaps[mipMapIndex];
imageFormat = DdsPixelFormat.ParseFileFormat(format);
DdsHeader ddsHeader = new DdsHeader(new DdsSaveConfig(imageFormat, 0, 0, false, false), mipMap.Width, mipMap.Height);
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
ddsHeader.Write(writer);
stream.Write(mipMap.ImageData, 0, mipMap.ImageData.Length);
stream.Flush();
stream.Position = 0;
return(stream);
}
internal unsafe void InitHeader <T>(ref PropertyHeader header) where T : struct
{
header.Size = Utilities.SizeOf <T>();
header.HeaderSize = sizeof(PropertyHeader);
header.Type = PropertyType;
header.Obj = ObjectCode;
}
public virtual async Task ReadDomainObject(ByteArrayReader reader, DomainHeader header, DomainExportTableEntry export, bool skipProperties, bool skipParse)
{
if (!skipProperties)
{
await PropertyHeader.ReadPropertyHeader(reader, header);
}
AdditionalDataOffset = export.SerialDataOffset + reader.CurrentOffset;
AdditionalDataReader = await reader.Splice();
}
public override async Task WriteBuffer(ByteArrayWriter Writer, int CurrentOffset)
{
await PropertyHeader.WriteBuffer(Writer, CurrentOffset);
await base.WriteBuffer(Writer, CurrentOffset);
for (int i = 0; i < Sounds.Count; ++i)
{
await CompressedChunks[i].WriteCompressedChunk(Writer, CurrentOffset);
}
}
public override int GetBuilderSize()
{
BuilderSize = PropertyHeader.GetBuilderSize()
+ base.GetBuilderSize()
+ sizeof(int);
foreach (byte[] Sound in Sounds)
{
BulkDataCompressionTypes flags = Sound == null || Sound.Length == 0 ? BulkDataCompressionTypes.Unused | BulkDataCompressionTypes.StoreInSeparatefile : BulkDataCompressionTypes.LZO_ENC;
BuilderSize += Task.Run(() => ProcessUncompressedBulkData(ByteArrayReader.CreateNew(Sound, 0), flags)).Result
+ sizeof(int) * 2;
}
return(BuilderSize);
}
public override int GetBuilderSize()
{
BuilderSize = PropertyHeader.GetBuilderSize()
+ base.GetBuilderSize()
+ sizeof(int);
foreach (DomainMipMap mipMap in MipMaps)
{
BulkDataCompressionTypes flags = mipMap.ImageData == null || mipMap.ImageData.Length == 0 ? BulkDataCompressionTypes.Unused | BulkDataCompressionTypes.StoreInSeparatefile : BulkDataCompressionTypes.LZO_ENC;
BuilderSize += Task.Run(() => ProcessUncompressedBulkData(ByteArrayReader.CreateNew(mipMap.ImageData, 0), flags)).Result
+ sizeof(int) * 2;
}
BuilderSize += Guid.Length;
return(BuilderSize);
}
public override async Task WriteBuffer(ByteArrayWriter Writer, int CurrentOffset)
{
await PropertyHeader.WriteBuffer(Writer, CurrentOffset);
await base.WriteBuffer(Writer, CurrentOffset);
Writer.WriteInt32(MipMaps.Count);
for (int i = 0; i < MipMaps.Count; ++i)
{
await CompressedChunks[i].WriteCompressedChunk(Writer, CurrentOffset);
Writer.WriteInt32(MipMaps[i].Width);
Writer.WriteInt32(MipMaps[i].Height);
}
await Writer.WriteBytes(Guid);
}
/**
* Converts the token into a multi-string description.
*
* @param ActorFilter Filter for actor name
* @param PropertyFilter Filter for property name
* @param RPCFilter Unused
*/
public override List <string> ToDetailedStringList(string ActorFilter, string PropertyFilter, string RPCFilter)
{
int NumReplicatedBits = GetNumReplicatedBits(ActorFilter, PropertyFilter, RPCFilter);
var ReturnList = new List <string>();
ReturnList.Add("REPLICATE ACTOR");
ReturnList.Add(" Actor : " + NetworkStream.GetName(ActorNameIndex));
ReturnList.Add(" Flags : " + (bNetDirty ? "bNetDirty " : "") + (bNetInitial ? "bNetInitial" : "") + (bNetOwner ? "bNetOwner" : ""));
ReturnList.Add(" NumBits : " + NumReplicatedBits);
ReturnList.Add(" NumBytes : " + NumReplicatedBits / 8.0f);
if (Properties.Count > 0)
{
ReturnList.Add(" PROPERTIES");
foreach (var Property in Properties)
{
if (Property.MatchesFilters(ActorFilter, PropertyFilter, RPCFilter))
{
ReturnList.Add(" Property : " + NetworkStream.GetName(Property.PropertyNameIndex));
ReturnList.Add(" NumBits : " + Property.NumBits);
ReturnList.Add(" NumBytes : " + Property.NumBits / 8.0f);
}
}
}
if (PropertyHeaders.Count > 0)
{
ReturnList.Add(" PROPERTY HEADERS");
foreach (var PropertyHeader in PropertyHeaders)
{
if (PropertyHeader.MatchesFilters(ActorFilter, PropertyFilter, RPCFilter))
{
ReturnList.Add(" Property : " + NetworkStream.GetName(PropertyHeader.PropertyNameIndex));
ReturnList.Add(" NumBits : " + PropertyHeader.NumBits);
ReturnList.Add(" NumBytes : " + PropertyHeader.NumBits / 8.0f);
}
}
}
return(ReturnList);
}
/**
* Fills tree view with description of this token
*
* @param Tree Tree to fill in
* @param ActorFilter Filter for actor name
* @param PropertyFilter Filter for property name
* @param RPCFilter Unused
*/
public override void ToDetailedTreeView(ItemCollection Tree, FilterValues InFilterValues)
{
TreeViewItem Child = TokenHelper.AddNode(Tree, "Replicated Actors");
int NumReplicatedBits = GetNumReplicatedBits(InFilterValues);
string Flags = ((NetFlags & (byte)ENetFlags.Dirty) == 1 ? "bNetDirty " : "") + ((NetFlags & (byte)ENetFlags.Initial) == 1 ? "bNetInitial" : "") + ((NetFlags & (byte)ENetFlags.Owner) == 1 ? "bNetOwner" : "");
TreeViewItem GrandChild = new TreeViewItem();
GrandChild.Header = string.Format("{0,-32} : {1:0.00} ({2:000}) ", StreamParser.NetworkStream.GetName(ActorNameIndex), TimeInMS, NumReplicatedBits / 8) + Flags;
Child.Items.Add(GrandChild);
Child = GrandChild;
if (Properties.Count > 0)
{
TreeViewItem NewChild = new TreeViewItem();
NewChild.Header = "Properties";
Child.Items.Add(NewChild);
foreach (var Property in Properties)
{
if (Property.MatchesFilters(InFilterValues))
{
NewChild.Items.Add(string.Format("{0,-25} : {1:000}", StreamParser.NetworkStream.GetName(Property.PropertyNameIndex), Property.NumBits / 8.0f));
}
}
}
if (PropertyHeaders.Count > 0)
{
TreeViewItem NewChild = new TreeViewItem();
NewChild.Header = "Property Headers";
Child.Items.Add(NewChild);
foreach (var PropertyHeader in PropertyHeaders)
{
if (PropertyHeader.MatchesFilters(InFilterValues))
{
NewChild.Items.Add(string.Format("{0,-25} : {1:000}", StreamParser.NetworkStream.GetName(PropertyHeader.PropertyNameIndex), PropertyHeader.NumBits / 8.0f));
}
}
}
}
/**
* Returns the number of bits for this replicated actor while taking filters into account.
*
* @param ActorFilter Filter for actor name
* @param PropertyFilter Filter for property name
* @param RPCFilter Unused
*/
public int GetNumReplicatedBits(FilterValues InFilterValues)
{
int NumReplicatedBits = 0;
foreach (var Property in Properties)
{
if (Property.MatchesFilters(InFilterValues))
{
NumReplicatedBits += Property.NumBits;
}
}
foreach (var PropertyHeader in PropertyHeaders)
{
if (PropertyHeader.MatchesFilters(InFilterValues))
{
NumReplicatedBits += PropertyHeader.NumBits;
}
}
return(NumReplicatedBits);
}
/**
* Returns the number of bits for this replicated actor while taking filters into account.
*
* @param ActorFilter Filter for actor name
* @param PropertyFilter Filter for property name
* @param RPCFilter Unused
*/
public int GetNumReplicatedBits(string ActorFilter, string PropertyFilter, string RPCFilter)
{
int NumReplicatedBits = 0;
foreach (var Property in Properties)
{
if (Property.MatchesFilters(ActorFilter, PropertyFilter, RPCFilter))
{
NumReplicatedBits += Property.NumBits;
}
}
foreach (var PropertyHeader in PropertyHeaders)
{
if (PropertyHeader.MatchesFilters(ActorFilter, PropertyFilter, RPCFilter))
{
NumReplicatedBits += PropertyHeader.NumBits;
}
}
return(NumReplicatedBits);
}
private MemoryStream buildDdsImage(int mipMapIndex, out ImageEngineFormat imageFormat)
{
DomainPropertyByteValue formatProp = PropertyHeader.GetProperty("Format").FirstOrDefault()?.Value as DomainPropertyByteValue;
imageFormat = ImageEngineFormat.Unknown;
if (formatProp == null)
{
return(null);
}
string format = formatProp.PropertyString.Replace("PF_", null);
switch (format)
{
case "DXT1":
{
imageFormat = ImageEngineFormat.DDS_DXT1;
break;
}
case "DXT5":
{
imageFormat = ImageEngineFormat.DDS_DXT5;
break;
}
case "G8":
{
imageFormat = ImageEngineFormat.DDS_G8_L8;
break;
}
case "A8R8G8B8":
{
imageFormat = ImageEngineFormat.DDS_ARGB;
break;
}
default:
{
return(null);
}
}
DomainMipMap mipMap = MipMaps[mipMapIndex];
DDSGeneral.DDS_HEADER header = DDSGeneral.Build_DDS_Header(0, mipMap.Height, mipMap.Width, imageFormat);
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
DDSGeneral.Write_DDS_Header(header, writer);
stream.Write(mipMap.ImageData, 0, mipMap.ImageData.Length);
stream.Flush();
stream.Position = 0;
return(stream);
}
public override async Task SetObject(string filename, List <DomainNameTableEntry> nameTable, object configuration)
{
DdsSaveConfig config = configuration as DdsSaveConfig ?? new DdsSaveConfig(FileFormat.Unknown, 0, 0, false, false);
DdsFile image = await Task.Run(() => new DdsFile(filename));
bool skipFirstMip = false;
int width = image.Width;
int height = image.Height;
if (MipMaps[0].ImageData == null || MipMaps[0].ImageData.Length == 0)
{
width *= 2;
height *= 2;
skipFirstMip = true;
}
DomainPropertyIntValue sizeX = PropertyHeader.GetProperty("SizeX").FirstOrDefault()?.Value as DomainPropertyIntValue;
DomainPropertyIntValue sizeY = PropertyHeader.GetProperty("SizeY").FirstOrDefault()?.Value as DomainPropertyIntValue;
sizeX?.SetPropertyValue(skipFirstMip ? width * 2 : width);
sizeY?.SetPropertyValue(skipFirstMip ? height * 2 : height);
DomainPropertyIntValue mipTailBaseIdx = PropertyHeader.GetProperty("MipTailBaseIdx").FirstOrDefault()?.Value as DomainPropertyIntValue;
int indexSize = width > height ? width : height;
mipTailBaseIdx?.SetPropertyValue((int)Math.Log(skipFirstMip ? indexSize * 2 : indexSize, 2));
DomainPropertyStringValue filePath = PropertyHeader.GetProperty("SourceFilePath").FirstOrDefault()?.Value as DomainPropertyStringValue;
DomainPropertyStringValue fileTime = PropertyHeader.GetProperty("SourceFileTimestamp").FirstOrDefault()?.Value as DomainPropertyStringValue;
filePath?.SetPropertyValue(filename);
fileTime?.SetPropertyValue(File.GetLastWriteTime(filename).ToString("yyyy-MM-dd hh:mm:ss"));
DomainPropertyByteValue pfFormat = PropertyHeader.GetProperty("Format").FirstOrDefault()?.Value as DomainPropertyByteValue;
FileFormat imageFormat = FileFormat.Unknown;
if (pfFormat != null)
{
imageFormat = DdsPixelFormat.ParseFileFormat(pfFormat.PropertyString);
}
if (imageFormat == FileFormat.Unknown)
{
throw new Exception($"Unknown DDS File Format ({pfFormat?.PropertyString ?? "Unknown"}).");
}
config.FileFormat = imageFormat;
MipMaps.Clear();
if (skipFirstMip)
{
MipMaps.Add(new DomainMipMap {
ImageData = null,
Width = width,
Height = height
});
}
image.GenerateMipMaps(4, 4);
foreach (DdsMipMap mipMap in image.MipMaps.OrderByDescending(mip => mip.Width))
{
MipMaps.Add(new DomainMipMap {
ImageData = image.WriteMipMap(mipMap, config),
Width = mipMap.Width,
Height = mipMap.Height
});
}
}
public override async Task SetObject(string filename, List <DomainNameTableEntry> nameTable)
{
ImageEngineImage image = await Task.Run(() => new ImageEngineImage(filename));
int width = image.Width;
int height = image.Height;
DomainPropertyIntValue sizeX = PropertyHeader.GetProperty("SizeX").FirstOrDefault()?.Value as DomainPropertyIntValue;
DomainPropertyIntValue sizeY = PropertyHeader.GetProperty("SizeY").FirstOrDefault()?.Value as DomainPropertyIntValue;
sizeX?.SetPropertyValue(width);
sizeY?.SetPropertyValue(height);
DomainPropertyIntValue mipTailBaseIdx = PropertyHeader.GetProperty("MipTailBaseIdx").FirstOrDefault()?.Value as DomainPropertyIntValue;
mipTailBaseIdx?.SetPropertyValue((int)Math.Log(width > height ? width : height, 2));
DomainPropertyStringValue filePath = PropertyHeader.GetProperty("SourceFilePath").FirstOrDefault()?.Value as DomainPropertyStringValue;
DomainPropertyStringValue fileTime = PropertyHeader.GetProperty("SourceFileTimestamp").FirstOrDefault()?.Value as DomainPropertyStringValue;
filePath?.SetPropertyValue(filename);
fileTime?.SetPropertyValue(File.GetLastWriteTime(filename).ToString("yyyy-MM-dd hh:mm:ss"));
DomainPropertyByteValue pfFormat = PropertyHeader.GetProperty("Format").FirstOrDefault()?.Value as DomainPropertyByteValue;
ImageEngineFormat imageFormat = image.Format.InternalFormat;
if (!imageFormat.ToString().Contains("DDS"))
{
throw new Exception($"Image is not in a DDS format. It is actually {imageFormat}.");
}
if (pfFormat != null)
{
string formatStr = imageFormat.ToString().Replace("DDS", "PF");
if (formatStr.Contains("ARGB"))
{
formatStr = "PF_A8R8G8B8";
}
else if (formatStr.Contains("G8"))
{
formatStr = "PF_G8";
}
DomainNameTableEntry formatTableEntry = nameTable.SingleOrDefault(nt => nt.Name.String == formatStr) ?? nameTable.AddDomainNameTableEntry(formatStr);
pfFormat.SetPropertyValue(formatTableEntry);
}
MipMaps.Clear();
while (true)
{
MemoryStream stream = new MemoryStream();
image.Save(stream, imageFormat, MipHandling.KeepTopOnly);
await stream.FlushAsync();
MipMaps.Add(new DomainMipMap
{
ImageData = (await ByteArrayReader.CreateNew(stream.ToArray(), 0x80).Splice()).GetBytes(), // Strip off 128 bytes for the DDS header
Width = image.Width,
Height = image.Height
});
if (width == 1 && height == 1)
{
break;
}
if (width > 1)
{
width /= 2;
}
if (height > 1)
{
height /= 2;
}
if (image.Width > 4 && image.Height > 4)
{
image.Resize(0.5, false);
}
}
}
public override async Task WriteBuffer(ByteArrayWriter Writer, int CurrentOffset)
{
await PropertyHeader.WriteBuffer(Writer, CurrentOffset);
Writer.WriteInt32(ObjectTableReference);
}
/**
* Parses tokens to create summary.
*/
protected void CreateSummary(int NameIndexUnreal, float DeltaTime, string ActorFilter, string PropertyFilter, string RPCFilter)
{
foreach (TokenBase Token in Tokens)
{
switch (Token.TokenType)
{
case ETokenTypes.FrameMarker:
var TokenFrameMarker = (TokenFrameMarker)Token;
if (StartTime < 0)
{
StartTime = TokenFrameMarker.RelativeTime;
EndTime = TokenFrameMarker.RelativeTime;
}
else
{
EndTime = TokenFrameMarker.RelativeTime;
}
NumFrames++;
break;
case ETokenTypes.SocketSendTo:
var TokenSocketSendTo = (TokenSocketSendTo)Token;
// Unreal game socket
if (TokenSocketSendTo.SocketNameIndex == NameIndexUnreal)
{
UnrealSocketCount++;
UnrealSocketSize += TokenSocketSendTo.BytesSent;
}
else
{
OtherSocketCount++;
OtherSocketSize += TokenSocketSendTo.BytesSent;
}
break;
case ETokenTypes.SendBunch:
var TokenSendBunch = (TokenSendBunch)Token;
SendBunchCount++;
SendBunchSizeBits += TokenSendBunch.GetNumTotalBits();
SendBunchHeaderSizeBits += TokenSendBunch.NumHeaderBits;
SendBunchCountPerChannel[TokenSendBunch.ChannelType]++;
SendBunchSizeBitsPerChannel[TokenSendBunch.ChannelType] += TokenSendBunch.GetNumTotalBits();
SendBunchHeaderSizeBitsPerChannel[TokenSendBunch.ChannelType] += TokenSendBunch.NumHeaderBits;
SendBunchPayloadSizeBitsPerChannel[TokenSendBunch.ChannelType] += TokenSendBunch.NumPayloadBits;
break;
case ETokenTypes.SendRPC:
var TokenSendRPC = (TokenSendRPC)Token;
RPCCount++;
RPCSizeBits += TokenSendRPC.GetNumTotalBits();
break;
case ETokenTypes.ReplicateActor:
var TokenReplicateActor = (TokenReplicateActor)Token;
ActorCount++;
ActorReplicateTimeInMS += TokenReplicateActor.TimeInMS;
foreach (var Property in TokenReplicateActor.Properties)
{
if (Property.MatchesFilters(ActorFilter, PropertyFilter, RPCFilter))
{
PropertyCount++;
ReplicatedSizeBits += Property.NumBits;
}
}
foreach (var PropertyHeader in TokenReplicateActor.PropertyHeaders)
{
if (PropertyHeader.MatchesFilters(ActorFilter, PropertyFilter, RPCFilter))
{
ReplicatedSizeBits += PropertyHeader.NumBits;
}
}
break;
case ETokenTypes.Event:
NumEvents++;
break;
case ETokenTypes.RawSocketData:
break;
case ETokenTypes.SendAck:
var TokenSendAck = (TokenSendAck)Token;
SendAckCount++;
SendAckSizeBits += TokenSendAck.NumBits;
break;
case ETokenTypes.ExportBunch:
var TokenExportBunch = (TokenExportBunch)Token;
ExportBunchCount++;
ExportBunchSizeBits += TokenExportBunch.NumBits;
break;
case ETokenTypes.MustBeMappedGuids:
var TokenMustBeMappedGuids = (TokenMustBeMappedGuids)Token;
MustBeMappedGuidCount += TokenMustBeMappedGuids.NumGuids;
MustBeMappedGuidSizeBits += TokenMustBeMappedGuids.NumBits;
break;
case ETokenTypes.BeginContentBlock:
var TokenBeginContentBlock = (TokenBeginContentBlock)Token;
ContentBlockHeaderCount++;
ContentBlockHeaderSizeBits += TokenBeginContentBlock.NumBits;
break;
case ETokenTypes.EndContentBlock:
var TokenEndContentBlock = (TokenEndContentBlock)Token;
ContentBlockFooterCount++;
ContentBlockFooterSizeBits += TokenEndContentBlock.NumBits;
break;
case ETokenTypes.WritePropertyHandle:
var TokenWritePropertyHandle = (TokenWritePropertyHandle)Token;
PropertyHandleCount++;
PropertyHandleSizeBits += TokenWritePropertyHandle.NumBits;
break;
default:
throw new System.IO.InvalidDataException();
}
}
EndTime += DeltaTime;
}
protected void UpdateSummary(TokenBase Token, FilterValues InFilterValues)
{
switch (Token.TokenType)
{
case ETokenTypes.FrameMarker:
var TokenFrameMarker = (TokenFrameMarker)Token;
if (StartTime < 0)
{
StartTime = TokenFrameMarker.RelativeTime;
EndTime = TokenFrameMarker.RelativeTime;
}
else
{
EndTime = TokenFrameMarker.RelativeTime;
}
NumFrames++;
break;
case ETokenTypes.SocketSendTo:
var TokenSocketSendTo = (TokenSocketSendTo)Token;
// Unreal game socket
if (TokenSocketSendTo.SocketNameIndex == NameIndexUnreal)
{
UnrealSocketCount++;
UnrealSocketSize += TokenSocketSendTo.BytesSent;
}
else
{
OtherSocketCount++;
OtherSocketSize += TokenSocketSendTo.BytesSent;
}
break;
case ETokenTypes.SendBunch:
var TokenSendBunch = (TokenSendBunch)Token;
SendBunchCount++;
SendBunchSizeBits += TokenSendBunch.GetNumTotalBits();
SendBunchHeaderSizeBits += TokenSendBunch.NumHeaderBits;
int ChannelTypeIndex = TokenSendBunch.GetChannelTypeIndex();
if (SendBunchCountPerChannel.ContainsKey(ChannelTypeIndex))
{
SendBunchCountPerChannel[ChannelTypeIndex]++;
SendBunchSizeBitsPerChannel[ChannelTypeIndex] += TokenSendBunch.GetNumTotalBits();
SendBunchHeaderSizeBitsPerChannel[ChannelTypeIndex] += TokenSendBunch.NumHeaderBits;
SendBunchPayloadSizeBitsPerChannel[ChannelTypeIndex] += TokenSendBunch.NumPayloadBits;
}
else
{
SendBunchCountPerChannel.Add(ChannelTypeIndex, 1);
SendBunchSizeBitsPerChannel.Add(ChannelTypeIndex, TokenSendBunch.GetNumTotalBits());
SendBunchHeaderSizeBitsPerChannel.Add(ChannelTypeIndex, TokenSendBunch.NumHeaderBits);
SendBunchPayloadSizeBitsPerChannel.Add(ChannelTypeIndex, TokenSendBunch.NumPayloadBits);
}
break;
case ETokenTypes.SendRPC:
var TokenSendRPC = (TokenSendRPC)Token;
RPCCount++;
RPCSizeBits += TokenSendRPC.GetNumTotalBits();
break;
case ETokenTypes.ReplicateActor:
var TokenReplicateActor = (TokenReplicateActor)Token;
ActorCount++;
if (TokenReplicateActor.Properties.Count > 0)
{
ReplicatedActorCount++;
}
ActorReplicateTimeInMS += TokenReplicateActor.TimeInMS;
foreach (var Property in TokenReplicateActor.Properties)
{
if (Property.MatchesFilters(InFilterValues))
{
PropertyCount++;
ReplicatedSizeBits += Property.NumBits;
}
}
foreach (var PropertyHeader in TokenReplicateActor.PropertyHeaders)
{
if (PropertyHeader.MatchesFilters(InFilterValues))
{
ReplicatedSizeBits += PropertyHeader.NumBits;
}
}
UniqueActors.AddItem(TokenReplicateActor, TokenReplicateActor.GetClassNameIndex());
break;
case ETokenTypes.Event:
NumEvents++;
break;
case ETokenTypes.RawSocketData:
break;
case ETokenTypes.SendAck:
var TokenSendAck = (TokenSendAck)Token;
SendAckCount++;
SendAckSizeBits += TokenSendAck.NumBits;
break;
case ETokenTypes.ExportBunch:
var TokenExportBunch = (TokenExportBunch)Token;
ExportBunchCount++;
ExportBunchSizeBits += TokenExportBunch.NumBits;
break;
case ETokenTypes.MustBeMappedGuids:
var TokenMustBeMappedGuids = (TokenMustBeMappedGuids)Token;
MustBeMappedGuidCount += TokenMustBeMappedGuids.NumGuids;
MustBeMappedGuidSizeBits += TokenMustBeMappedGuids.NumBits;
break;
case ETokenTypes.BeginContentBlock:
var TokenBeginContentBlock = (TokenBeginContentBlock)Token;
ContentBlockHeaderCount++;
ContentBlockHeaderSizeBits += TokenBeginContentBlock.NumBits;
break;
case ETokenTypes.EndContentBlock:
var TokenEndContentBlock = (TokenEndContentBlock)Token;
ContentBlockFooterCount++;
ContentBlockFooterSizeBits += TokenEndContentBlock.NumBits;
break;
case ETokenTypes.WritePropertyHandle:
var TokenWritePropertyHandle = (TokenWritePropertyHandle)Token;
PropertyHandleCount++;
PropertyHandleSizeBits += TokenWritePropertyHandle.NumBits;
break;
default:
throw new System.IO.InvalidDataException();
}
}
public override async Task WriteBuffer(ByteArrayWriter Writer, int CurrentOffset)
{
await PropertyHeader.WriteBuffer(Writer, CurrentOffset);
await Writer.WriteBytes(AdditionalDataReader?.GetBytes());
}
/// <summary>
/// Converts the xml documentation string into a description object.
/// </summary>
public static Description GetDescription(IEntity entity)
{
IHeader header = null;
var method = entity as IMethod;
if (method != null)
{
header = new MethodHeader(method);
}
var field = entity as IField;
if (field != null)
{
header = new FieldHeader(field);
}
var property = entity as IProperty;
if (property != null)
{
header = new PropertyHeader(property);
}
if (header == null)
{
header = new SimpleHeader(AmbienceService.GetCurrentAmbience().Convert(entity));
}
var description = new Description(header);
string xmlDocumentation = entity.Documentation;
if (string.IsNullOrEmpty(xmlDocumentation))
{
return(description);
}
try
{
// original pattern without escape symbols: \<see cref=\"[^\"]+\.([^\"]+)\"\ /\>
const string seeCrefPattern = "\\<see cref=\\\"[^\\\"]+\\.([^\\\"]+)\\\"\\ /\\>";
xmlDocumentation = Regex.Replace(xmlDocumentation, seeCrefPattern, "$1");
XDocument xml = XDocument.Parse("<docroot>" + xmlDocumentation + "</docroot>");
foreach (XElement element in xml.Root.Elements())
{
Test[element.Name.LocalName] = element.ToString();
}
XElement summary = xml.Descendants("summary").FirstOrDefault();
if (summary != null)
{
description.Summary = summary.Value.Trim();
}
XElement[] xmlParameters = xml.Descendants("param").ToArray();
foreach (XElement node in xmlParameters)
{
string name = node.Attribute("name").Value;
string parameterDescription = node.Value;
Parameter parameterObject =
description.Parameters.FirstOrDefault(parameter => parameter.Name == name);
if (parameterObject != null)
{
parameterObject.Description = parameterDescription;
}
}
}
catch (Exception)
{
return(new SimpleDescription(xmlDocumentation));
}
return(description);
}
