public BoundingBox SetPoints(ICollection <Point> vertices)
{
BoundingBox bounds = new BoundingBox();
points = BufferHelper.CreateVertexBuffer(vertices, ref bounds);
count = points.Count / points.Size;
return(bounds);
}
public BoundingBox SetPoints(IMesh mesh)
{
BoundingBox bounds = new BoundingBox();
points = BufferHelper.CreateVertexBuffer(mesh.Vertices, ref bounds);
count = points.Count / points.Size;
return(bounds);
}
public BoundingBox SetPoints(IPolygon poly)
{
BoundingBox bounds = new BoundingBox();
points = BufferHelper.CreateVertexBuffer(poly.Points, ref bounds);
count = points.Count / points.Size;
return(bounds);
}
public static string GetKeyNameText(LPARAM lParam)
{
var wrapper = new KeyNameTextWrapper {
LParam = lParam
};
// It is possible that there may be no name for a key, in which case the api will return 0 with GetLastError of 0.
return(BufferHelper.TruncatingApiInvoke(ref wrapper, null, Errors.Failed));
}
public static ResponsePacket ReadBuffer(short packetType, NetworkStream buffer)
{
var messageId = BufferHelper.ReadInt(buffer);
var payload = PayloadPacket.readPayload(buffer);
var responsePacket = new ResponsePacket(payload);
responsePacket.RequestId = messageId;
return(responsePacket);
}
private int WriteToBuffer(byte[] buffer, int offset, int count)
{
BufferHelper.AssertValidRange(buffer, "buffer", offset, "offset", count, "count");
var written = Math.Min(count, this.Capacity - this.Count);
System.Buffer.BlockCopy(buffer, offset, this.GetBuffer(), this.Count, written);
this.Count += written;
return(written);
}
private int ReadFromBuffer(byte[] buffer, int offset, int count)
{
BufferHelper.AssertValidRange(buffer, "buffer", offset, "offset", count, "count");
var readCount = Math.Min(count, this.Count - this.Index);
System.Buffer.BlockCopy(this.GetBuffer(), this.Index, buffer, offset, readCount);
this.Index += readCount;
return(readCount);
}
/// <summary>
/// Add a connection to the list of connected clients and send a message requesting the nickname.
/// </summary>
/// <param name="socket"></param>
/// <returns></returns>
public async Task OnConnected(WebSocket socket)
{
await Task.Run(() =>
{
_connections.AddConnection(socket);
});
await socket.SendAsync(BufferHelper.GetMessageToSend(ServerMessageConstants.PROVIDE_NICKNAME), WebSocketMessageType.Text, true, CancellationToken.None);
}
/// <summary>
/// Returns the expanded name of the file. Does not work for paths that are over 128
/// characters long.
/// </summary>
public unsafe static string GetExpandedName(string path)
{
return(BufferHelper.BufferInvoke((HeapBuffer buffer) =>
{
buffer.EnsureByteCapacity(Paths.MaxPath);
ValidateLzResult(Imports.GetExpandedNameA(Paths.TrimTrailingSeparators(path), buffer), path);
return BufferHelper.GetNullTerminatedAsciiString(buffer);
}));
}
public Guid Deserialize(byte[] buffer, int offset, int length)
{
if (length != 16)
{
throw new ArgumentException("length");
}
return(BufferHelper.ReadBufferGuid(buffer, offset));
}
private void DrawMeshes()
{
var objCbByteSize = BufferHelper.CalcConstantBufferByteSize <ObjectConstants>();
foreach (var mesh in this.meshes)
{
mesh.Draw(objCbByteSize, CurrFrameResource.ObjectCB.Resource.GPUVirtualAddress);
}
}
public static ControlHandshakeResponsePacket ReadBuffer(short packetType, NetworkStream buffer)
{
var messageId = BufferHelper.ReadInt(buffer);
var payload = PayloadPacket.readPayload(buffer);
var helloPacket = new ControlHandshakeResponsePacket(payload);
helloPacket.RequestId = messageId;
return(helloPacket);
}
public byte[] ToBuffer()
{
var buffer = new MemoryStream();
BufferHelper.WriteShort((short)Common.PacketType.CONTROL_HANDSHAKE, buffer);
BufferHelper.WriteInt(RequestId, buffer);
return(PayloadPacket.appendPayload(buffer, Payload));
}
public byte[] ToBuffer()
{
var buffer = new MemoryStream();
BufferHelper.WriteShort(PACKET_TYPE, buffer);
BufferHelper.WriteInt(StreamChannelId, buffer);
return(PayloadPacket.appendPayload(buffer, Payload));
}
public byte[] ToBuffer()
{
var buffer = new MemoryStream();
BufferHelper.WriteShort((short)Common.PacketType.APPLICATION_RESPONSE, buffer);
BufferHelper.WriteInt(RequestId, buffer);
return(PayloadPacket.appendPayload(buffer, Payload));
}
public void TestOutOfOrder()
{
Configuration.SocketConfig config = new Configuration.SocketConfig()
{
MinimumMTU = 1050
};
MemoryManager memoryManager = new MemoryManager(config);
Connection clientsConnectionToServer = Connection.Stub(config, memoryManager);
Connection serversConnectionToClient = Connection.Stub(config, memoryManager);
ReliableSequencedChannel clientChannel = new ReliableSequencedChannel(0, clientsConnectionToServer, config, memoryManager);
ReliableSequencedChannel serverChannel = new ReliableSequencedChannel(0, serversConnectionToClient, config, memoryManager);
// Create 3 payloads
byte[] message1 = BufferHelper.GetRandomBuffer(1024, 0);
byte[] message2 = BufferHelper.GetRandomBuffer(1024, 1);
byte[] message3 = BufferHelper.GetRandomBuffer(1024, 2);
// Sequence all payloads as outgoing
HeapMemory message1Memory = ((HeapMemory)clientChannel.CreateOutgoingMessage(new ArraySegment <byte>(message1, 0, 1024), out _, out bool dealloc).Pointers[0]);
HeapMemory message2Memory = ((HeapMemory)clientChannel.CreateOutgoingMessage(new ArraySegment <byte>(message2, 0, 1024), out _, out dealloc).Pointers[0]);
HeapMemory message3Memory = ((HeapMemory)clientChannel.CreateOutgoingMessage(new ArraySegment <byte>(message3, 0, 1024), out _, out dealloc).Pointers[0]);
// Consume 1st payload
ArraySegment <byte>?payload1 = serverChannel.HandleIncomingMessagePoll(new ArraySegment <byte>(message1Memory.Buffer, (int)message1Memory.VirtualOffset + 2, (int)message1Memory.VirtualCount - 2), out _, out bool hasMore1);
// Consume 3rd payload
ArraySegment <byte>?payload3 = serverChannel.HandleIncomingMessagePoll(new ArraySegment <byte>(message3Memory.Buffer, (int)message3Memory.VirtualOffset + 2, (int)message3Memory.VirtualCount - 2), out _, out bool hasMore3);
// Consume 2nd payload
ArraySegment <byte>?payload2 = serverChannel.HandleIncomingMessagePoll(new ArraySegment <byte>(message2Memory.Buffer, (int)message2Memory.VirtualOffset + 2, (int)message2Memory.VirtualCount - 2), out _, out bool hasMore2);
HeapMemory pollMemory = serverChannel.HandlePoll();
{
Assert.NotNull(payload1);
Assert.False(hasMore1);
Assert.That(BufferHelper.ValidateBufferSizeAndIdentity(payload1.Value, 0, 1024));
}
{
Assert.Null(payload3);
Assert.False(hasMore3);
}
{
Assert.NotNull(payload2);
Assert.True(hasMore2);
Assert.That(BufferHelper.ValidateBufferSizeAndIdentity(payload2.Value, 1, 1024));
}
{
// Check for the third packet
Assert.NotNull(pollMemory);
Assert.That(BufferHelper.ValidateBufferSizeAndIdentity(pollMemory, 2, 1024));
}
}
/// <summary>
/// Get the list of data streams for the given handle.
/// </summary>
public static IEnumerable <StreamInformation> GetStreamInformationByHandle(SafeFileHandle fileHandle)
{
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364406.aspx
// typedef struct _FILE_STREAM_INFO
// {
// DWORD NextEntryOffset;
// DWORD StreamNameLength;
// LARGE_INTEGER StreamSize;
// LARGE_INTEGER StreamAllocationSize;
// WCHAR StreamName[1];
// } FILE_STREAM_INFO, *PFILE_STREAM_INFO;
return(BufferHelper.CachedInvoke <IEnumerable <StreamInformation>, HeapBuffer>((buffer) =>
{
unsafe
{
while (!Direct.GetFileInformationByHandleEx(fileHandle, FILE_INFO_BY_HANDLE_CLASS.FileStreamInfo,
buffer.VoidPointer, checked ((uint)buffer.ByteCapacity)))
{
WindowsError error = ErrorHelper.GetLastError();
switch (error)
{
case WindowsError.ERROR_HANDLE_EOF:
// No streams
return Enumerable.Empty <StreamInformation>();
case WindowsError.ERROR_MORE_DATA:
buffer.EnsureByteCapacity(buffer.ByteCapacity * 2);
break;
default:
throw ErrorHelper.GetIoExceptionForError(error);
}
}
}
var infos = new List <StreamInformation>();
var reader = new CheckedReader(buffer);
uint offset = 0;
do
{
reader.ByteOffset = offset;
offset = reader.ReadUint();
uint nameLength = reader.ReadUint();
infos.Add(new StreamInformation
{
Size = reader.ReadUlong(),
AllocationSize = reader.ReadUlong(),
Name = reader.ReadString((int)(nameLength / 2))
});
} while (offset != 0);
return infos;
}));
}
public async Task <Message> ReceiveMessage(CancellationToken ct)
{
var buffer = ArrayPool <byte> .Shared.Rent(_receiveBufferSize);
try
{
var read = 0;
var msgSize = -1;
while (msgSize == -1 || read < msgSize)
{
var len = msgSize == -1 ? 4 : msgSize - read;
var segment = new ArraySegment <byte>(buffer, read, len);
read += await _transportChannel.ReceiveAsync(segment, ct);
if (msgSize == -1 && read >= 4)
{
msgSize = BitConverter.ToInt32(buffer, 0);
if (msgSize < _minMessageSize)
{
throw new Exception($"Received message size {msgSize} while minimum is {_minMessageSize}");
}
if (msgSize > _maxMessageSize)
{
throw new Exception($"Received message size {msgSize} while maximum is {_maxMessageSize}");
}
if (msgSize > _receiveBufferSize)
{
var newBuffer = ArrayPool <byte> .Shared.Rent(msgSize);
Buffer.BlockCopy(buffer, 0, newBuffer, 0, read);
ArrayPool <byte> .Shared.Return(buffer);
buffer = newBuffer;
}
}
ct.ThrowIfCancellationRequested();
}
var msgType = (MessageType)buffer[_messageTypeIndex];
var id = new Guid(BufferHelper.GetSubArray(buffer, _idIndex, 16));
byte[] payload = null;
var payloadLength = msgSize - _payloadIndex;
if (payloadLength > 0)
{
payload = BufferHelper.GetSubArray(buffer, _payloadIndex, payloadLength);
}
return(new Message(msgType, id, payload));
}
finally
{
ArrayPool <byte> .Shared.Return(buffer);
}
}
public long Deserialize(byte[] buffer, int offset, int length)
{
if (length != 8)
{
throw new ArgumentException("Invalid length: " + length);
}
return(BufferHelper.ReadBufferInt64(buffer, offset));
}
/// <summary>
/// Gets a canonical version of the given handle's path.
/// </summary>
public static string GetFinalPathNameByHandle(
SafeFileHandle fileHandle,
GetFinalPathNameByHandleFlags flags = GetFinalPathNameByHandleFlags.FileNameNormalized | GetFinalPathNameByHandleFlags.VolumeNameDos)
{
var wrapper = new FinalPathNameByHandleWrapper {
FileHandle = fileHandle, Flags = flags
};
return(BufferHelper.ApiInvoke(ref wrapper));
}
public void TestFloat()
{
var buffer = new byte[sizeof(float)];
BufferHelper.Write(buffer, 0, 69f);
var val = BufferHelper.ReadFloat(buffer, 0);
Assert.AreEqual(val, 69f);
}
/// <summary>
/// Gets the raw set of environment strings as name/value pairs separated by an equals character.
/// </summary>
/// <remarks>Names can have an equals character as the first character. Be cautious when splitting or use GetEnvironmentVariables().</remarks>
public static IEnumerable <string> GetEnvironmentStrings()
{
using var buffer = Imports.GetEnvironmentStringsW();
if (buffer.IsInvalid)
{
return(Enumerable.Empty <string>());
}
return(BufferHelper.SplitNullTerminatedStringList(buffer.DangerousGetHandle()));
}
/// <inheritdoc/>
public EventInfo LogData(string type, string direction, byte[] buffer, int index, int count)
{
BufferHelper.AssertValidRange(buffer, "buffer", index, "index", count, "count");
var info = new EventInfo(this.WriteStartEvent(type));
this.xmlLogWriter.WriteAttributeString(LogNames.Direction, direction);
this.xmlLogWriter.WriteBinHex(buffer, index, count);
this.WriteEndEvent();
return(info);
}
public byte[] ToBuffer()
{
var buffer = new MemoryStream();
BufferHelper.WriteShort(PACKET_TYPE, buffer);
BufferHelper.WriteInt(StreamChannelId, buffer);
BufferHelper.WriteShort((short)Code, buffer);
return(buffer.ToArray());
}
public void TestInt()
{
var buffer = new byte[sizeof(int)];
BufferHelper.Write(buffer, 0, 69);
var val = BufferHelper.ReadInt32(buffer, 0);
Assert.AreEqual(val, 69);
}
/// <inheritdoc/>
protected override void OnEngineSet()
{
base.OnEngineSet();
_vb = _buildVertexBuffer();
// Calculate bounding bodies
BoundingSphere = BufferHelper.ComputeBoundingSphere(_vb, _vertexCount);
BoundingBox = BufferHelper.ComputeBoundingBox(_vb, _vertexCount);
}
private void BuildConstantBuffers()
{
var cbvDesc = new ConstantBufferViewDescription
{
BufferLocation = CurrFrameResource.ObjectCB.Resource.GPUVirtualAddress,
SizeInBytes = BufferHelper.CalcConstantBufferByteSize <ObjectConstants>()
};
this.device.CreateConstantBufferView(cbvDesc, descriptorHeapObjects.ConstantBufferViewShaderResourceViewUnorderedAccessViewDescriptorHeap.CPUDescriptorHandleForHeapStart);
}
/// <summary>
/// Gets a canonical version of the given handle's path.
/// </summary>
public static string GetFinalPathNameByHandle(
SafeFileHandle fileHandle,
GetFinalPathNameByHandleFlags flags = GetFinalPathNameByHandleFlags.FILE_NAME_NORMALIZED | GetFinalPathNameByHandleFlags.VOLUME_NAME_DOS)
{
var wrapper = new FinalPathNameByHandleWrapper {
FileHandle = fileHandle, Flags = flags
};
return(BufferHelper.ApiInvoke(ref wrapper));
}
public void TestShort()
{
var buffer = new byte[sizeof(ushort)];
BufferHelper.Write(buffer, 0, (ushort)69);
var val = BufferHelper.ReadUInt16(buffer, 0);
Assert.AreEqual(val, 69);
}
public void Dispatch()
{
if (HeightTexture == null || NormalTexture == null)
{
return;
}
generationConstants.lodLevel = (((1 << LODLevel + 2) * (Planetoid.PlanetRadius / (LODLevel + 2)) - ((Planetoid.PlanetRadius / (LODLevel + 2)) / 2)) / Planetoid.PlanetRadius);
generationConstants.lodOctaveModifier = Planetoid.GetLODOctaveModifier(LODLevel + 1);
// NOTE : Just setup all our generator parameters...
if (Planetoid.tccps != null)
{
Planetoid.tccps.UpdateUniforms(CoreShader);
}
CreateBuffers();
QuadGenerationConstantsBuffer.SetData(new[] { generationConstants });
PreOutDataBuffer.SetData(GodManager.Instance.PreOutputDataBuffer);
PreOutDataSubBuffer.SetData(GodManager.Instance.PreOutputSubDataBuffer);
OutDataBuffer.SetData(GodManager.Instance.OutputDataBuffer);
if (CoreShader == null)
{
return;
}
EventManager.PlanetoidEvents.OnDispatchStarted.Invoke(Planetoid, this);
// NOTE : I still need this stuff...
int kernel1 = CoreShader.FindKernel("HeightMain");
int kernel2 = CoreShader.FindKernel("Transfer");
int kernel3 = CoreShader.FindKernel("HeightSub");
int kernel4 = CoreShader.FindKernel("TexturesSub");
SetUniforms(CoreShader);
CoreShader.Dispatch(kernel1, QuadSettings.THREADGROUP_SIZE_BORDER, QuadSettings.THREADGROUP_SIZE_BORDER, 1);
CoreShader.Dispatch(kernel2, QuadSettings.THREADGROUP_SIZE, QuadSettings.THREADGROUP_SIZE, 1);
CoreShader.Dispatch(kernel3, QuadSettings.THREADGROUP_SIZE_BORDER_FULL, QuadSettings.THREADGROUP_SIZE_BORDER_FULL, 1);
CoreShader.Dispatch(kernel4, QuadSettings.THREADGROUP_SIZE_FULL, QuadSettings.THREADGROUP_SIZE_FULL, 1);
Generated = true;
// NOTE : NO DATA WILL BE RECIEVED UNTIL ASYNC GET DATA!
//Release and dispose unnecessary buffers. Video memory, you are free!
BufferHelper.ReleaseAndDisposeBuffers(PreOutDataBuffer, PreOutDataSubBuffer);
BuffersCreated = false;
EventManager.PlanetoidEvents.OnDispatchEnd.Invoke(Planetoid, this);
EventManager.PlanetoidEvents.OnDispatchFinished.Invoke(Planetoid, this);
}
public PlainTextMessageCodec()
{
_mBufferHelper = new BufferHelper();
_mDateHelper = new DateHelper();
}
