private static bool ValidateHeader(Stream stream)
{
var binaryReader = new BinarySerializationReader(stream);
// Read header
var header = binaryReader.Read <Header>();
var result = new BundleDescription();
result.Header = header;
// Check magic header
if (header.MagicHeader != Header.MagicHeaderValid)
{
return(false);
}
// Ensure size has properly been set
if (header.Size != stream.Length)
{
return(false);
}
return(true);
}
/// <summary>
/// Loads an <see cref="EffectBytecode" /> from a stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns>EffectBytecode or null if the magic header is not matching</returns>
/// <exception cref="System.ArgumentNullException">stream</exception>
public static EffectBytecode FromStream(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
var reader = new BinarySerializationReader(stream);
var version = reader.Read <uint>();
// Version is not matching, return null
if (version != MagicHeader)
{
return(null);
}
return(reader.Read <EffectBytecode>());
}
public static AtmosphereData Load(GraphicsDevice device, Stream stream)
{
var reader = new BinarySerializationReader(stream);
var settings = reader.Read <AtmosphereSettings>();
long transmittanceSize = reader.ReadInt64();
long irradianceSize = reader.ReadInt64();
long inscatterSize = reader.ReadInt64();
Texture transmittance, irradiance, inscatter;
var buffer = reader.ReadBytes((int)transmittanceSize);
using (var data = new MemoryStream(buffer))
transmittance = Texture.Load(device, data);
buffer = reader.ReadBytes((int)irradianceSize);
using (var data = new MemoryStream(buffer))
irradiance = Texture.Load(device, data);
buffer = reader.ReadBytes((int)inscatterSize);
using (var data = new MemoryStream(buffer))
inscatter = Texture.Load(device, data);
return(new AtmosphereData(settings, transmittance, irradiance, inscatter));
}
/// <summary>
/// Reads the bundle description from a <see cref="Stream"/>.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns>A <see cref="BundleDescription"/> representing a description of the bundle.</returns>
/// <exception cref="InvalidDataException">Invalid bundle header.</exception>
/// <exception cref="InvalidDataException">The bundle has not been properly written.</exception>
public static BundleDescription ReadBundleDescription(Stream stream)
{
var binaryReader = new BinarySerializationReader(stream);
// Read header
Header header;
try
{
header = binaryReader.Read <Header>();
}
catch (InvalidOperationException ex)
{
throw new InvalidDataException("Invalid bundle header.", ex);
}
var result = new BundleDescription {
Header = header
};
// Check magic header
if (header.MagicHeader != Header.MagicHeaderValid)
{
throw new InvalidDataException("Invalid bundle header.");
}
// Ensure size has properly been set
if (header.Size != stream.Length)
{
throw new InvalidDataException("Bundle has not been properly written.");
}
try
{
// Read dependencies
var dependencies = result.Dependencies;
binaryReader.Serialize(ref dependencies, ArchiveMode.Deserialize);
// Read incremental bundles
var incrementalBundles = result.IncrementalBundles;
binaryReader.Serialize(ref incrementalBundles, ArchiveMode.Deserialize);
// Read objects
var objects = result.Objects;
binaryReader.Serialize(ref objects, ArchiveMode.Deserialize);
// Read assets
var assets = result.Assets;
binaryReader.Serialize(ref assets, ArchiveMode.Deserialize);
}
catch (InvalidOperationException ex)
{
throw new InvalidDataException("Bundle has not been properly written.", ex);
}
return(result);
}
/// <summary>
/// Reads the bundle description.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns></returns>
/// <exception cref="System.InvalidOperationException">
/// Invalid bundle header
/// or
/// Bundle has not been properly written
/// </exception>
public static BundleDescription ReadBundleDescription(Stream stream)
{
var binaryReader = new BinarySerializationReader(stream);
// Read header
var header = binaryReader.Read <Header>();
var result = new BundleDescription();
result.Header = header;
// Check magic header
if (header.MagicHeader != Header.MagicHeaderValid)
{
throw new InvalidOperationException("Invalid bundle header");
}
// Ensure size has properly been set
if (header.Size != stream.Length)
{
throw new InvalidOperationException("Bundle has not been properly written");
}
// Read dependencies
List <string> dependencies = result.Dependencies;
binaryReader.Serialize(ref dependencies, ArchiveMode.Deserialize);
// Read objects
List <KeyValuePair <ObjectId, ObjectInfo> > objects = result.Objects;
binaryReader.Serialize(ref objects, ArchiveMode.Deserialize);
// Read assets
List <KeyValuePair <string, ObjectId> > assets = result.Assets;
binaryReader.Serialize(ref assets, ArchiveMode.Deserialize);
return(result);
}
public void TestShaderParametersSerialization()
{
// Test serialization
var shaderParameters = new ShaderMixinParameters("Test");
shaderParameters.Set(PropertyInt, 5);
var subShaderParameters = new ShaderMixinParameters("Sub");
subShaderParameters.Set(PropertyInt, 6);
shaderParameters.Set(PropertySub, subShaderParameters);
var subShaderParametersArray = new ShaderMixinParameters[1];
var subShaderParametersArray1 = new ShaderMixinParameters("InArray1");
subShaderParametersArray[0] = subShaderParametersArray1;
subShaderParametersArray1.Set(PropertyInt, 7);
shaderParameters.Set(PropertySubs, subShaderParametersArray);
var memoryStream = new MemoryStream();
var writer = new BinarySerializationWriter(memoryStream);
writer.Write(shaderParameters);
writer.Flush();
memoryStream.Position = 0;
var reader = new BinarySerializationReader(memoryStream);
var shaderParametersReloaded = reader.Read <ShaderMixinParameters>();
// They should be strictly equal
Assert.That(shaderParametersReloaded.IsSubsetOf(shaderParameters), Is.True);
Assert.That(shaderParameters.IsSubsetOf(shaderParametersReloaded), Is.True);
// Test subset
// Check that by removing one key from the original parameters, the reloaded version is
// no longer a subset
subShaderParametersArray1.Remove(PropertyInt);
Assert.That(shaderParametersReloaded.IsSubsetOf(shaderParameters), Is.False);
}
public async Task Run()
{
Services = new ServiceRegistry();
// Database file provider
Services.AddService <IDatabaseFileProviderService>(new DatabaseFileProviderService(new DatabaseFileProvider(ObjectDatabase.CreateDefaultDatabase())));
// Content manager
Content = new ContentManager(Services);
Services.AddService <IContentManager>(Content);
Services.AddService(Content);
//Services.AddService<IGraphicsDeviceService>(new GraphicsDeviceServiceLocal(null));
// Game systems
var gameSystems = new GameSystemCollection(Services);
Services.AddService <IGameSystemCollection>(gameSystems);
gameSystems.Initialize();
// Load scene (physics only)
var loadSettings = new ContentManagerLoaderSettings
{
// Ignore all references (Model, etc...)
ContentFilter = ContentManagerLoaderSettings.NewContentFilterByType()
};
var scene = await Content.LoadAsync <Scene>("MainScene", loadSettings);
var sceneInstance = new SceneInstance(Services, scene, ExecutionMode.None);
var sceneSystem = new SceneSystem(Services)
{
SceneInstance = sceneInstance,
};
Services.AddService(sceneSystem);
var physics = new PhysicsProcessor();
sceneInstance.Processors.Add(physics);
var socket = new SimpleSocket();
socket.Connected += clientSocket =>
{
Console.WriteLine("Client connected");
var reader = new BinarySerializationReader(clientSocket.ReadStream);
while (true)
{
// Receive ray start/end
var start = reader.Read <Vector3>();
var end = reader.Read <Vector3>();
// Raycast
var result = physics.Simulation.Raycast(start, end);
Console.WriteLine($"Performing raycast: {(result.Succeeded ? "hit" : "miss")}");
// Send result
clientSocket.WriteStream.WriteByte((byte)(result.Succeeded ? 1 : 0));
clientSocket.WriteStream.Flush();
}
};
await socket.StartServer(2655, false);
Console.WriteLine("Server listening, press a key to exit");
Console.ReadKey();
}