public async Task UT_Cache_RawOverrideSerializer_Async()
{
var raw = new RawSerializer();
raw.SetSerializerFor <User>(u => Encoding.UTF8.GetBytes(u.Id.ToString()),
b => new User()
{
Id = int.Parse(Encoding.UTF8.GetString(b))
});
var ctx = new Context(Common.Config, raw);
Thread.Sleep(100);
var users = await GetUsersAsync();
string key = "UT_Cache_RawOverrideSerializer_Async";
string key2 = "UT_Cache_RawOverrideSerializer_Async2";
ctx.Cache.Remove(new[] { key, key2 });
await ctx.Cache.SetObjectAsync(key, users[0]);
await ctx.Cache.SetHashedAsync(key2, "X", users[1]);
var v = await ctx.Cache.GetObjectAsync <User>(key);
var v2 = await ctx.Cache.GetHashedAsync <User>(key2, "X");
var v3 = await ctx.Cache.GetObjectAsync <int>(key);
Assert.AreEqual(users[0].Id, v.Id);
Assert.AreEqual(users[1].Id, v2.Id);
Assert.AreEqual(users[0].Id, v3);
}
public void StreamDeserializationTest()
{
using (MemoryStream testStream = new MemoryStream(this.TestStructInstanceData))
{
TestStruct deserialized = RawSerializer.ReadStructFromRawData <TestStruct>(testStream);
Assert.AreEqual <TestStruct>(deserialized, this.TestStructInstance);
}
}
private object DeserializePacket(byte[] buffer, object packet)
{
RawSerializer rawSerializer = new RawSerializer(packet.GetType(), false);
MemoryStream source = new MemoryStream(buffer);
rawSerializer.Deserialize(packet, source);
return(packet);
}
//---------------------------------------------------------------
#endregion
//---------------------------------------------------------------
//---------------------------------------------------------------
#region Methods
//---------------------------------------------------------------
/// <summary>
/// Helper function loading a lump from file into structs
/// </summary>
/// <param name="lump">Vertices, Faces, ...</param>
/// <param name="structType">type of struct to load into</param>
/// <returns>list of instances of structType</returns>
private IList LoadLump(QuakeLumps lump, Type structType)
{
LumpLocation location = (LumpLocation)locations[(int)lump];
stream.Seek(location.Offset, SeekOrigin.Begin);
int vertexNum = (int)(location.Length / Marshal.SizeOf(structType));
return(RawSerializer.DeserializeArray(stream, structType, vertexNum));
}
private ushort SerializePacket(byte[] buffer, object packet)
{
RawSerializer rawSerializer = new RawSerializer(packet.GetType(), false);
MemoryStream target = new MemoryStream(buffer);
int num;
rawSerializer.Serialize(packet, target, out num);
return((ushort)num);
}
public void StreamSerializationTest()
{
using (MemoryStream testStream = new MemoryStream())
{
RawSerializer.WriteRawData(testStream, this.TestStructInstance);
byte[] serialized = testStream.ToArray();
Assert.IsTrue(Enumerable.SequenceEqual <byte>(serialized, this.TestStructInstanceData));
}
}
private void SerializeHeader(byte[] buffer, ushort size, ushort command)
{
HEADER hEADER = new HEADER(size + 5, command);
RawSerializer rawSerializer = new RawSerializer(hEADER.GetType(), false);
MemoryStream target = new MemoryStream(buffer);
int num;
rawSerializer.Serialize(hEADER, target, out num);
}
/// <summary>
/// Initialize the serializer, consisting of the following stack:
/// GZip -> Crypto -> MemoryStream
/// </summary>
/// <param name="key"></param>
/// <param name="iv"></param>
protected void InitializeSerializer(byte[] key, byte[] iv)
{
writeBuffer = new MemoryStream();
EncryptTransformer et = new EncryptTransformer(EncryptionAlgorithm.Rijndael);
et.IV = iv;
ICryptoTransform ict = et.GetCryptoServiceProvider(key);
encStream = new CryptoStream(writeBuffer, ict, CryptoStreamMode.Write);
comp = new GZipStream(encStream, CompressionMode.Compress, true); // important to be set to true!
serializer = new RawSerializer(comp);
}
private int RecvHeader(ref HEADER header)
{
try
{
byte[] buffer = new byte[5];
int result = this._parent.Sock.Receive(buffer);
RawSerializer rawSerializer = new RawSerializer(header.GetType(), false);
MemoryStream source = new MemoryStream(buffer);
rawSerializer.Deserialize <HEADER>(ref header, source);
return(result);
}
catch (Exception)
{
}
return(0);
}
public void UT_Cache_RawOverrideSerializer_object()
{
var raw = new RawSerializer();
raw.SetSerializerFor <object>(o => Encoding.UTF8.GetBytes(o.GetHashCode().ToString()),
b => int.Parse(Encoding.UTF8.GetString(b)));
var ctx = new Context(Common.Config, raw);
Thread.Sleep(1000);
string key = "UT_Cache_RawOverrideSerializer_object";
ctx.Cache.Remove(new[] { key });
ctx.Cache.SetObject(key, this);
var v = ctx.Cache.GetObject <int>(key);
Assert.AreEqual(this.GetHashCode(), v);
}
public async Task UT_Cache_RawOverrideSerializer_object_Async()
{
var raw = new RawSerializer();
raw.SetSerializerFor <object>(o => Encoding.UTF8.GetBytes(o.GetHashCode().ToString()),
b => int.Parse(Encoding.UTF8.GetString(b)));
var ctx = new Context(Common.Config, raw);
Thread.Sleep(100);
string key = "UT_Cache_RawOverrideSerializer_object_Async";
ctx.Cache.Remove(new[] { key });
User usr = new User();
await ctx.Cache.SetObjectAsync <object>(key, usr);
var v = await ctx.Cache.GetObjectAsync <object>(key);
Assert.AreEqual(usr.GetHashCode(), v);
}
/// <summary>
/// DataSet���л���ѹ��
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
public static byte[] CompressDataSet(DataSet ds)
{
byte[] compressedBuf;
#region serialize
RawSerializer rs = new RawSerializer();
byte[] buf = rs.Serialize(ds);
#endregion
System.IO.MemoryStream ms = new System.IO.MemoryStream();
System.IO.Compression.GZipStream gs = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Compress, true);
gs.Write(buf, 0, buf.Length);
gs.Close();
compressedBuf = ms.ToArray();
return compressedBuf;
}
/// <summary>
/// Loads the model.
/// </summary>
/// <param name="stream">Stream to load model from.</param>
/// <returns>The loaded model.</returns>
public Model LoadModel(Stream stream)
{
BlendMesh mesh;
// get header and check if it is ok
MD2_Header header = (MD2_Header)RawSerializer.Deserialize(stream, typeof(MD2_Header));
if (header.Ident != 844121161 || header.Version != 8)
{
return(null);
}
// Load skins
MD2_Skin[] skinNames = (MD2_Skin[])RawSerializer.DeserializeArray(stream, typeof(MD2_Skin), header.NumSkins);
// Load texture coordinates
MD2_TextureCoordinate[] textureCoordinates = (MD2_TextureCoordinate[])RawSerializer.DeserializeArray(stream, typeof(MD2_TextureCoordinate), header.NumTextureCoordinates);
// Load triangless
MD2_Triangle[] triangles = (MD2_Triangle[])RawSerializer.DeserializeArray(stream, typeof(MD2_Triangle), header.NumTris);
IndexStream indexStream = new IndexStream16(triangles.Length);
for (int i = 0; i < triangles.Length; i++)
{
// indexStream[i] = triangles[i].VertexIndex[j;
}
mesh = new BlendMesh(header.NumFrames);
// Load frames
for (int i = 0; i < header.NumFrames; i++)
{
MD2_Frame frame = (MD2_Frame)RawSerializer.Deserialize(stream, typeof(MD2_Frame));
MD2_Vertex[] vertices = (MD2_Vertex[])RawSerializer.DeserializeArray(stream, typeof(MD2_Vertex), header.NumVertices);
VertexUnit vu = new VertexUnit(VertexFormat.Position, vertices.Length);
PositionStream ps = (PositionStream)vu[typeof(Purple.Graphics.VertexStreams.PositionStream)];
mesh.Meshes[i] = new Mesh(new SubSet(vu, indexStream));
}
return(new Model(mesh, null));
}
static void DumpHeaders(string file)
{
using (var stream = File.OpenRead(file))
{
Console.WriteLine("MAT header data for file {0}:".FormatInvariant(file));
Console.WriteLine("MAT Header section");
var header = RawSerializer.Deserialize <MatHeader>(stream);
if (header.Type == MatHeader.MatType.Texture)
{
Console.WriteLine(header);
for (int i = 0; i < header.MatRecordCount; i++)
{
Console.WriteLine();
Console.WriteLine("MAT record section");
Console.WriteLine(RawSerializer.Deserialize <MatRecordHeader>(stream));
}
for (int i = 0; i < header.MatRecordCount; i++)
{
var textureHeader = RawSerializer.Deserialize <TextureDataHeader>(stream);
Console.WriteLine();
Console.WriteLine("MAT record section");
Console.WriteLine(textureHeader);
// Skip over texture data
long dataSize = textureHeader.SizeX * textureHeader.SizeY * header.Bitdepth;
stream.Seek(dataSize, SeekOrigin.Current);
}
}
else
{
Console.WriteLine("Unsupported or unrecognized MAT type, only texture MATs are supported");
Environment.Exit(1);
}
}
}
/// <summary>
/// loads a quake3 level from a stream
/// </summary>
/// <param name="stream">stream to load from</param>
/// <returns>level as a mesh</returns>
public Mesh Load(Stream stream)
{
Mesh mesh = new Mesh();
this.stream = stream;
// get header and check if it is ok
QuakeHeader header = (QuakeHeader)RawSerializer.Deserialize(stream, typeof(QuakeHeader));
if (header.ID != 1347633737 || header.Version != 0x2e)
{
return(null);
}
// get locations of lumps
locations = RawSerializer.DeserializeArray(stream, typeof(LumpLocation), (int)QuakeLumps.LumpNumber);
// get lumps
IList quakeVertices = LoadLump(QuakeLumps.Vertices, typeof(QuakeVertex));
IList quakeFaces = LoadLump(QuakeLumps.Faces, typeof(QuakeFace));
IList quakeTextures = LoadLump(QuakeLumps.Textures, typeof(QuakeTexture));
IList quakeLightMaps = LoadLump(QuakeLumps.Lightmaps, typeof(QuakeLightMap));
// Load all texture images and put into array
IList textures = LoadTextures(quakeTextures);
// Load lightMaps, create texture and put into array
IList lightMaps = LoadLightMaps(quakeLightMaps);
// create list from vertices
VertexUnit vertexUnit = new VertexUnit(VertexFormat.PositionTexture2, quakeVertices.Count);
PositionStream pos = (PositionStream)vertexUnit[typeof(PositionStream)];
TextureStream texStream = (TextureStream)vertexUnit[typeof(TextureStream)];
TextureStream light = (TextureStream)vertexUnit[typeof(TextureStream), 1];
int i = 0;
foreach (QuakeVertex v in quakeVertices)
{
pos[i] = new Math.Vector3(v.Position[0], v.Position[2], -v.Position[1]);
texStream[i] = new Math.Vector2(v.TextureCoord[0], v.TextureCoord[1]);
light[i] = new Math.Vector2(v.LightmapCoord[0], v.LightmapCoord[1]);
i++;
}
// presort faces
Array.Sort(((Array)quakeFaces));
// create mesh
int oldLightMap = ((QuakeFace)quakeFaces[0]).LightmapID;
int oldTexture = ((QuakeFace)quakeFaces[0]).TextureID;
ArrayList indices = new ArrayList();
for (i = 0; i < quakeFaces.Count; ++i)
{
QuakeFace qf = (QuakeFace)quakeFaces[i];
if (qf.Type == 1)
{
if (qf.TextureID != oldTexture || qf.LightmapID != oldLightMap)
{
mesh.SubSets.Add(new SubSet(vertexUnit, IndexStream.Create(indices, vertexUnit.Size)));
Textures texs = new Textures("color", (ITexture)textures[oldTexture]);
if (oldLightMap == -1)
{
texs["lightMap"] = null;
}
else
{
texs["lightMap"] = (ITexture)lightMaps[oldLightMap];
}
mesh.Textures.Add(texs);
indices.Clear();
}
// add indices => convert from fan to list
for (int j = 2; j < qf.NumOfVerts; j++)
{
indices.Add(qf.VertexIndex);
indices.Add(qf.VertexIndex + j - 1);
indices.Add(qf.VertexIndex + j);
}
oldTexture = qf.TextureID;
oldLightMap = qf.LightmapID;
}
}
return(mesh);
}
public void ByteArrayDeserializationTest()
{
TestStruct deserialized = RawSerializer.GetStructFromRawData <TestStruct>(this.TestStructInstanceData);
Assert.AreEqual <TestStruct>(deserialized, this.TestStructInstance);
}
public void ByteArraySerializationTest()
{
byte[] serialized = RawSerializer.GetRawData <TestStruct>(this.TestStructInstance);
Assert.IsTrue(Enumerable.SequenceEqual <byte>(serialized, this.TestStructInstanceData));
}
public void UT_Cache_RawOverrideSerializer()
{
var raw = new RawSerializer();
raw.SetSerializerFor<User>(u => Encoding.UTF8.GetBytes(u.Id.ToString()),
b => new User() {Id = int.Parse(Encoding.UTF8.GetString(b))});
var ctx = new Context(Common.Config, raw);
Thread.Sleep(1000);
var users = GetUsers();
string key = "UT_Cache_RawOverrideSerializer";
string key2 = "UT_Cache_RawOverrideSerializer2";
ctx.Cache.Remove(new[] {key, key2});
ctx.Cache.SetObject(key, users[0]);
ctx.Cache.SetHashed(key2, "X", users[1]);
var v = ctx.Cache.GetObject<User>(key);
var v2 = ctx.Cache.GetHashed<User>(key2, "X");
var v3 = ctx.Cache.GetObject<int>(key);
Assert.AreEqual(users[0].Id, v.Id);
Assert.AreEqual(users[1].Id, v2.Id);
Assert.AreEqual(users[0].Id, v3);
}
public void UT_Cache_RawOverrideSerializer_object()
{
var raw = new RawSerializer();
raw.SetSerializerFor<object>(o => Encoding.UTF8.GetBytes(o.GetHashCode().ToString()),
b => int.Parse(Encoding.UTF8.GetString(b)));
var ctx = new Context(Common.Config, raw);
Thread.Sleep(1000);
string key = "UT_Cache_RawOverrideSerializer_object";
ctx.Cache.Remove(new[] { key });
User usr = new User();
ctx.Cache.SetObject<object>(key, usr);
var v = ctx.Cache.GetObject<object>(key);
Assert.AreEqual(usr.GetHashCode(), v);
}
private MD3Part LoadMD3(string part)
{
using (Stream stream = fileSystem.Open(path + part + ".md3")) {
// get header and check if it is ok
MD3_Header header = (MD3_Header)RawSerializer.Deserialize(stream, typeof(MD3_Header));
if (header.Id != 860898377 || header.Version != 15)
{
return(null);
}
// load bone frames
MD3_Frame[] frames = (MD3_Frame[])RawSerializer.DeserializeArray(stream, typeof(MD3_Frame), header.NumFrames);
// load tags
SortedList links = GetLinks((MD3_Tag[])RawSerializer.DeserializeArray(stream, typeof(MD3_Tag), header.NumTags * header.NumFrames));
long meshOffset = stream.Position;
// one mesh for every frame
BlendMesh mesh = new BlendMesh(header.NumFrames);
// load meshes
for (int iMesh = 0; iMesh < header.NumMeshes; iMesh++)
{
stream.Position = meshOffset;
MD3_MeshHeader meshHeader = (MD3_MeshHeader)RawSerializer.Deserialize(stream, typeof(MD3_MeshHeader));
MD3_Skin[] skins = (MD3_Skin[])RawSerializer.DeserializeArray(stream, typeof(MD3_Skin), meshHeader.NumSkins);
stream.Position = meshOffset + meshHeader.TriangleOffset;
MD3_Triangle[] triangles = (MD3_Triangle[])RawSerializer.DeserializeArray(stream, typeof(MD3_Triangle), meshHeader.NumTriangles);
stream.Position = meshOffset + meshHeader.TexCoordOffset;
MD3_TexCoord[] texCoords = (MD3_TexCoord[])RawSerializer.DeserializeArray(stream, typeof(MD3_TexCoord), meshHeader.NumVertices);
stream.Position = meshOffset + meshHeader.VertexOffset;
MD3_Vertex[] vertices = (MD3_Vertex[])RawSerializer.DeserializeArray(stream, typeof(MD3_Vertex), meshHeader.NumFrames * meshHeader.NumVertices);
float scale = 64.0f;
string name = StringHelper.Convert(meshHeader.Name);
ITexture tx = (ITexture)textures[name];
Triangle[] tris = new Triangle[triangles.Length];
for (int i = 0; i < triangles.Length; i++)
{
tris[i].A = (triangles[i]).A;
tris[i].B = (triangles[i]).B;
tris[i].C = (triangles[i]).C;
}
IndexStream indexStream = IndexStream16.FromTriangles(tris);
int vertCount = meshHeader.NumVertices; // *meshHeader.NumFrames;
for (int iFrame = 0; iFrame < meshHeader.NumFrames; iFrame++)
{
VertexUnit vertexUnit = new VertexUnit(VertexFormat.PositionNormalTexture, vertCount);
PositionStream pos = (PositionStream)vertexUnit[typeof(PositionStream)];
NormalStream normal = (NormalStream)vertexUnit[typeof(NormalStream)];
TextureStream tex = (TextureStream)vertexUnit[typeof(TextureStream)];
for (int i = 0; i < vertCount; i++)
{
int vertIndex = iFrame * meshHeader.NumVertices + i;
pos[i] = new Vector3(vertices[vertIndex].X / scale,
vertices[vertIndex].Z / scale,
-vertices[vertIndex].Y / scale);
int texIndex = i % meshHeader.NumVertices;
tex[i] = new Vector2(texCoords[texIndex].U,
texCoords[texIndex].V);
//Normal vector
int compressedNormal = ((MD3_Vertex)vertices[vertIndex]).Normal;
float lng = (compressedNormal & 0xFF) * Math.Basic.PI / 128;
float lat = ((compressedNormal >> 8) & 0xFF) * Math.Basic.PI / 128;
normal[i] = new Vector3(Math.Trigonometry.Cos(lat) * Math.Trigonometry.Sin(lng),
Math.Trigonometry.Cos(lng),
-Math.Trigonometry.Sin(lat) * Math.Trigonometry.Sin(lng));
}
if (mesh.Meshes[iFrame] == null)
{
mesh.Meshes[iFrame] = new Mesh();
}
mesh.Meshes[iFrame].SubSets.Add(new SubSet(vertexUnit, indexStream));
mesh.Meshes[iFrame].Textures.Add(new Textures("color", tx));
}
// Increase the offset into the file
meshOffset += meshHeader.MeshSize;
}
return(new MD3Part(mesh, links));
}
}
