/// <summary>
/// Handles the signaling of this <see cref="DataWatcher"/>.
/// </summary>
protected override void HandleSignaling()
{
lock (_locker)
{
DateTime utcLastModified = DateTime.UtcNow;
List <object[]> values = new List <object[]>();
DataManager manager = Manager.Clone();
using (DbDataReader reader = manager.ExecuteReader(Command, Parameters))
{
while (reader.Read())
{
object[] readerValues = new object[reader.FieldCount];
reader.GetValues(readerValues);
values.Add(readerValues);
}
}
long currentSignature = StructUtility.GetHashCode64(EnumerableConverter.Parse(values, o => o.GetHashCode()));
values.Clear();
if (Signature == 0)
{
Signature = currentSignature;
}
if (!Signature.Equals(currentSignature))
{
SetUtcLastModified(utcLastModified);
OnChangedRaised();
}
Signature = currentSignature;
}
}
/// <summary>
/// Sets a callback to be used whenever texture data is requested by a shader.
/// The callback will be passed the u, v and w coordinates.
/// </summary>
/// <typeparam name="TColor">Color type, i.e. Vector4.</typeparam>
/// <param name="name">Name of the resource.</param>
/// <param name="callback">The callback will be executed once for each texture fetch,
/// and will be passed the u, v and w coordinates.</param>
public void SetResource <TColor>(string name, ResourceCallback <TColor> callback)
where TColor : struct
{
// Validate.
var resourceIndex = _resourceBindings.FindIndex(x => x.Name == name);
if (resourceIndex == -1)
{
throw new ArgumentException("Could not find resource named '" + name + "'", "name");
}
if (StructUtility.SizeOf <TColor>() != Number4.SizeInBytes)
{
throw new ArgumentException(string.Format("Expected color struct to be {0} bytes, but was {1}'",
Number4.SizeInBytes, StructUtility.SizeOf <TColor>()));
}
// Set resource into virtual machine. We also set a default sampler state.
var registerIndex = new RegisterIndex((ushort)resourceIndex);
_virtualMachine.SetSampler(registerIndex, new SamplerState());
_virtualMachine.SetTexture(registerIndex,
new FakeTexture((u, v, w, i) =>
{
var bytes = StructUtility.ToBytes(callback(u, v, w, i));
return(Number4.FromByteArray(bytes, 0));
}));
}
/// <summary>
/// Combines a sequence of objects into one object, and computes a hash value of the specified <paramref name="values"/>.
/// </summary>
/// <param name="values">The objects to compute a hash code for.</param>
/// <param name="setup">The <see cref="HashOptions"/> which need to be configured.</param>
/// <returns>A <see cref="HashResult"/> containing the computed hash value of the specified object sequence <paramref name="values"/>.</returns>
public static HashResult ComputeHash(object[] values, Action <HashOptions> setup = null)
{
Validator.ThrowIfNull(values, nameof(values));
var options = setup.ConfigureOptions();
long signature = StructUtility.GetHashCode64(EnumerableConverter.Parse(values, o => o.GetHashCode()));
return(ComputeHash(BitConverter.GetBytes(signature), o => o.AlgorithmType = options.AlgorithmType));
}
private void HandlePacket(PacketHeader packet, byte[] bytes)
{
_telemetryRecorder.RecordPacket(packet, bytes);
switch (packet.PacketType)
{
case PacketType.Motion:
var motionPacket = StructUtility.ConvertToPacket <PacketMotionData>(bytes);
OnMotionPacketReceived(new PacketReceivedEventArgs <PacketMotionData>(_oldMotionData, motionPacket));
_oldMotionData = motionPacket;
break;
case PacketType.Session:
var sessionPacket = StructUtility.ConvertToPacket <PacketSessionData>(bytes);
OnSessionPacketReceived(new PacketReceivedEventArgs <PacketSessionData>(_oldSessionData, sessionPacket));
_oldSessionData = sessionPacket;
break;
case PacketType.LapData:
var lapPacket = StructUtility.ConvertToPacket <PacketLapData>(bytes);
OnLapPacketReceivedReceived(new PacketReceivedEventArgs <PacketLapData>(_oldLapData, lapPacket));
_oldLapData = lapPacket;
break;
case PacketType.Event:
var eventPacket = StructUtility.ConvertToPacket <EventPacket>(bytes);
OnEventPacketReceived(new PacketReceivedEventArgs <EventPacket>(_oldEventPacket, eventPacket));
_oldEventPacket = eventPacket;
break;
case PacketType.Participants:
var participantPacket = StructUtility.ConvertToPacket <PacketParticipantsData>(bytes);
OnParticipantsPacketReceived(new PacketReceivedEventArgs <PacketParticipantsData>(_oldParticipantsData, participantPacket));
_oldParticipantsData = participantPacket;
break;
case PacketType.CarSetups:
var carSetupsPacket = StructUtility.ConvertToPacket <PacketCarSetupData>(bytes);
OnCarSetupPacketReceived(new PacketReceivedEventArgs <PacketCarSetupData>(_oldCarSetupData, carSetupsPacket));
_oldCarSetupData = carSetupsPacket;
break;
case PacketType.CarTelemetry:
var carTelemetryPacket = StructUtility.ConvertToPacket <PacketCarTelemetryData>(bytes);
OnCarTelemetryPacketReceived(new PacketReceivedEventArgs <PacketCarTelemetryData>(_oldCarTelemetryData, carTelemetryPacket));
_oldCarTelemetryData = carTelemetryPacket;
break;
case PacketType.CarStatus:
var carStatusPacket = StructUtility.ConvertToPacket <PacketCarStatusData>(bytes);
OnCarStatusPacketReceived(new PacketReceivedEventArgs <PacketCarStatusData>(_oldCarStatusData, carStatusPacket));
_oldCarStatusData = carStatusPacket;
break;
}
_oldSessionId = packet.SessionUId;
_oldFrameIdentifier = packet.FrameIdentifier;
}
private static void SetConstantBuffer <T>(VirtualMachine vm, ushort constantBufferIndex, T data)
{
var bytes = StructUtility.ToBytes(data);
for (var i = 0; i < bytes.Length; i += 16)
{
vm.SetRegister(0, OperandType.ConstantBuffer,
new RegisterIndex(constantBufferIndex, (ushort)(i / 16)),
Number4.FromByteArray(bytes, i));
}
}
public void OnDebugDataSelected(object sender, SelectionChangedEventArgs e)
{
if (e.AddedItems.Count == 0)
{
return;
}
var selectedDebugData = ((DebugModel)e.AddedItems[0]);
switch (selectedDebugData.PacketType)
{
case PacketType.Motion:
PacketMotionData motionData = StructUtility.ConvertToPacket <PacketMotionData>(selectedDebugData.Data);
DebugDetails = new ObjectViewModelHierarchy(motionData);
return;
case PacketType.Session:
PacketSessionData sessionData = StructUtility.ConvertToPacket <PacketSessionData>(selectedDebugData.Data);
DebugDetails = new ObjectViewModelHierarchy(sessionData);
return;
case PacketType.LapData:
PacketLapData lapData = StructUtility.ConvertToPacket <PacketLapData>(selectedDebugData.Data);
DebugDetails = new ObjectViewModelHierarchy(lapData);
return;
case PacketType.Event:
EventPacket eventData = StructUtility.ConvertToPacket <EventPacket>(selectedDebugData.Data);
DebugDetails = new ObjectViewModelHierarchy(eventData);
return;
case PacketType.Participants:
PacketParticipantsData participantsData = StructUtility.ConvertToPacket <PacketParticipantsData>(selectedDebugData.Data);
DebugDetails = new ObjectViewModelHierarchy(participantsData);
return;
case PacketType.CarSetups:
PacketCarSetupData carSetupsData = StructUtility.ConvertToPacket <PacketCarSetupData>(selectedDebugData.Data);
DebugDetails = new ObjectViewModelHierarchy(carSetupsData);
return;
case PacketType.CarTelemetry:
PacketCarTelemetryData carTelemetryData = StructUtility.ConvertToPacket <PacketCarTelemetryData>(selectedDebugData.Data);
DebugDetails = new ObjectViewModelHierarchy(carTelemetryData);
return;
case PacketType.CarStatus:
PacketCarStatusData carStatusData = StructUtility.ConvertToPacket <PacketCarStatusData>(selectedDebugData.Data);
DebugDetails = new ObjectViewModelHierarchy(carStatusData);
return;
}
}
/// <summary>
/// Combines the <paramref name="additionalChecksum"/> to the representation of this instance.
/// </summary>
/// <param name="additionalChecksum">A <see cref="String"/> array that contains zero or more checksums of the additional data this instance must represent.</param>
public ChecksumBuilder CombineWith(params string[] additionalChecksum)
{
List <long> result = new List <long>();
if (additionalChecksum == null)
{
result.Add(StructUtility.HashCodeForNullValue);
}
else
{
for (int i = 0; i < additionalChecksum.Length; i++)
{
result.Add(StructUtility.GetHashCode64(additionalChecksum[i]));
}
}
return(CombineWith(result.ToArray()));
}
/// <summary>
/// Sets a constant buffer with the given name and value.
/// This must be done before executing the shader.
/// </summary>
public void SetConstantBuffer <T>(string name, T value)
where T : struct
{
// Validate.
var constantBufferIndex = _constantBuffers.FindIndex(x => x.Name == name);
if (constantBufferIndex == -1)
{
throw new ArgumentException("Could not find constant buffer named '" + name + "'", "name");
}
// Set constant buffer into virtual machine registers.
var bytes = StructUtility.ToBytes(value);
for (var i = 0; i < bytes.Length; i += 16)
{
_virtualMachine.SetConstantBufferRegisterValue(constantBufferIndex, i / 16,
Number4.FromByteArray(bytes, i));
}
}
private void UdpLoop()
{
while (true)
{
InitUdp(_port);
try
{
_udpClient.Client.ReceiveTimeout = 5000;
byte[] receiveBytes = _udpClient.Receive(ref _senderIp);
var packet = StructUtility.ConvertToPacket <PacketHeader>(receiveBytes);
HandlePacket(packet, receiveBytes);
}
#pragma warning disable RECS0022 // A catch clause that catches System.Exception and has an empty body
catch (Exception)
#pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body
{
// can be ignored (timeout etc)
}
}
}
/// <summary>
/// Executes the shader. First, the input value is set into the input registers.
/// Then the shader is executed. Finally, the output value is extracted from
/// the output registers.
/// </summary>
/// <typeparam name="TInput">Input type. This must be a struct whose byte count
/// exactly matches the shader input.</typeparam>
/// <typeparam name="TOutput">Output type. This must be a struct whose byte count
/// exactly matches the shader output.</typeparam>
/// <param name="input">Input to the shader.</param>
/// <returns>Shader output.</returns>
public TOutput Execute <TInput, TOutput>(TInput input)
where TInput : struct
where TOutput : struct
{
// Validate.
if (StructUtility.SizeOf <TInput>() != _inputSignatureSize)
{
throw new ArgumentException(string.Format("Expected input struct to be {0} bytes, but was {1}'",
_inputSignatureSize, StructUtility.SizeOf <TInput>()));
}
// Set input parameters into virtual machine registers. Use knowledge of byte size of each
// parameter to extract the right values from the input.
var inputBytes = StructUtility.ToBytes(input);
var inputByteIndex = 0;
for (int i = 0; i < _inputSignature.Parameters.Count; i++)
{
var inputParameter = _inputSignature.Parameters[i];
var registerBytes = new byte[Number4.SizeInBytes];
Array.Copy(inputBytes, inputByteIndex, registerBytes, 0, inputParameter.ByteCount);
_virtualMachine.SetInputRegisterValue(ContextIndex, 0, i, Number4.FromByteArray(registerBytes, 0));
inputByteIndex += inputParameter.ByteCount;
}
// Execute shader.
_virtualMachine.Execute();
// Get output parameters from virtual machine registers.
var outputBytes = new byte[_outputSignatureSize];
var outputByteIndex = 0;
for (var i = 0; i < _outputSignature.Parameters.Count; i++)
{
var outputParameter = _outputSignature.Parameters[i];
var registerBytes = _virtualMachine.GetOutputRegisterValue(ContextIndex, i).RawBytes;
Array.Copy(registerBytes, 0, outputBytes, outputByteIndex, outputParameter.ByteCount);
outputByteIndex += outputParameter.ByteCount;
}
return(StructUtility.FromBytes <TOutput>(outputBytes));
}
public static BasicHlsl.VertexShaderOutput ExecuteVertexShader(string compiledShaderFile,
BasicHlsl.ConstantBufferGlobals globals, VertexPositionNormalTexture vertex)
{
var device = new Device(DriverType.Warp);
var vertexShaderBytes = File.ReadAllBytes(compiledShaderFile);
var vertexShaderBytecode = new ShaderBytecode(vertexShaderBytes);
var vertexShader = new VertexShader(device, vertexShaderBytecode);
var layout = new InputLayout(device,
ShaderSignature.GetInputSignature(vertexShaderBytecode),
new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("NORMAL", 0, Format.R32G32B32_Float, 16, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 28, 0)
});
var vertices = Buffer.Create(device, BindFlags.VertexBuffer, new[] { vertex });
var constantBuffer = Buffer.Create(device, ref globals, new BufferDescription
{
BindFlags = BindFlags.ConstantBuffer,
CpuAccessFlags = CpuAccessFlags.None,
Usage = ResourceUsage.Default
});
var geometryShader = new GeometryShader(device, vertexShaderBytecode,
new[]
{
new StreamOutputElement {
SemanticName = "SV_POSITION", ComponentCount = 4
},
new StreamOutputElement {
SemanticName = "COLOR", ComponentCount = 4
},
new StreamOutputElement {
SemanticName = "TEXCOORD", ComponentCount = 2
}
},
BasicHlsl.VertexShaderOutput.SizeInBytes);
var outputBuffer = Buffer.Create(device, new BasicHlsl.VertexShaderOutput[1],
new BufferDescription
{
CpuAccessFlags = CpuAccessFlags.None,
BindFlags = BindFlags.StreamOutput,
Usage = ResourceUsage.Default
});
var stagingBuffer = Buffer.Create(device, new BasicHlsl.VertexShaderOutput[1],
new BufferDescription
{
CpuAccessFlags = CpuAccessFlags.Read,
BindFlags = BindFlags.None,
Usage = ResourceUsage.Staging
});
device.InputAssembler.InputLayout = layout;
device.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList;
device.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertices, VertexPositionNormalTexture.SizeInBytes, 0));
device.VertexShader.SetConstantBuffer(0, constantBuffer);
device.VertexShader.Set(vertexShader);
device.GeometryShader.Set(geometryShader);
device.StreamOutput.SetTargets(new StreamOutputBufferBinding(outputBuffer, 0));
device.Draw(1, 0);
device.CopyResource(outputBuffer, stagingBuffer);
device.Flush();
var stream = stagingBuffer.Map(MapMode.Read, SharpDX.Direct3D10.MapFlags.None);
var bytes = new byte[BasicHlsl.VertexShaderOutput.SizeInBytes];
stream.Read(bytes, 0, bytes.Length);
stream.Dispose();
outputBuffer.Dispose();
vertices.Dispose();
layout.Dispose();
geometryShader.Dispose();
vertexShader.Dispose();
vertexShaderBytecode.Dispose();
device.Dispose();
return(StructUtility.FromBytes <BasicHlsl.VertexShaderOutput>(bytes));
}
/// <summary>
/// Computes and returns a MD5 signature of the following properties: <see cref="P:Cuemon.IO.JsonInstance.Name"/>, <see cref="P:Cuemon.IO.JsonInstance.Value"/>, <see cref="P:Cuemon.IO.JsonInstance.NodeNumber"/> and <see cref="NodeType"/>.
/// </summary>
/// <returns>
/// A MD5 signature of the following properties: <see cref="P:Cuemon.IO.JsonInstance.Name"/>, <see cref="P:Cuemon.IO.JsonInstance.Value"/>, <see cref="P:Cuemon.IO.JsonInstance.NodeNumber"/> and <see cref="NodeType"/>.
/// </returns>
public override string GetSignature()
{
return(StructUtility.GetHashCode64(string.Concat(Name, Value, NodeNumber, Enum.GetName(typeof(XPathNodeType), NodeType))).ToString());
}
private static long GenerateGroupKey(string key, string group)
{
return(StructUtility.GetHashCode64(group == NoGroup ? key : string.Concat(key, group)));
}
/// <summary>
/// Initializes a new instance of the <see cref="CacheValidator"/> class.
/// </summary>
/// <param name="created">A <see cref="DateTime"/> value for when data this instance represents was first created.</param>
/// <param name="modified">A <see cref="DateTime"/> value for when data this instance represents was last modified.</param>
/// <param name="checksum">A <see cref="String"/> value containing a byte-for-byte checksum of the data this instance represents.</param>
/// <param name="setup">The <see cref="CacheValidatorOptions"/> which need to be configured.</param>
public CacheValidator(DateTime created, DateTime?modified, string checksum, Action <CacheValidatorOptions> setup = null)
: this(created, modified, checksum == null ? StructUtility.HashCodeForNullValue : StructUtility.GetHashCode64(checksum), setup)
{
}
/// <summary>
/// Computes and returns a MD5 signature of the following properties: <see cref="Name"/>, <see cref="Value"/> and <see cref="NodeNumber"/>.
/// </summary>
/// <returns>A MD5 signature of the following properties: <see cref="Name"/>, <see cref="Value"/> and <see cref="NodeNumber"/>.</returns>
public virtual string GetSignature()
{
return(StructUtility.GetHashCode64(string.Concat(Name, Value, NodeNumber)).ToString(CultureInfo.InvariantCulture));
}
/// <summary>
/// Initializes a new instance of the <see cref="ChecksumBuilder"/> class.
/// </summary>
/// <param name="checksum">A <see cref="String"/> value containing a byte-for-byte checksum of the data this instance represents.</param>
/// <param name="setup">The <see cref="ChecksumBuilderOptions"/> which need to be configured.</param>
public ChecksumBuilder(string checksum, Action <ChecksumBuilderOptions> setup = null) : this(checksum == null ? StructUtility.HashCodeForNullValue : StructUtility.GetHashCode64(checksum), setup)
{
}
/// <summary>
/// Returns a hash code for this instance.
/// </summary>
/// <returns>A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.</returns>
public override int GetHashCode()
{
return(StructUtility.GetHashCode32(EnumerableConverter.FromArray(PageSize, PageNumber, (int)SortOrderDirection, Data.GetHashCode())) ^ StringUtility.GetHashCode(string.Concat(SearchCriteria, SortOrderBy)));
}
