private void UnpackSystem(BitPacker pack)
{
CRC = pack.UnpackUnsignedBits(32);
PartFlags = pack.UnpackUnsignedBits(32);
Pattern = (SourcePattern)pack.ByteValue;
MaxAge = pack.UnpackFixed(false, 8, 8);
StartAge = pack.UnpackFixed(false, 8, 8);
InnerAngle = pack.UnpackFixed(false, 3, 5);
OuterAngle = pack.UnpackFixed(false, 3, 5);
BurstRate = pack.UnpackFixed(false, 8, 8);
BurstRadius = pack.UnpackFixed(false, 8, 8);
BurstSpeedMin = pack.UnpackFixed(false, 8, 8);
BurstSpeedMax = pack.UnpackFixed(false, 8, 8);
BurstPartCount = pack.ByteValue;
float x = pack.UnpackFixed(true, 8, 7);
float y = pack.UnpackFixed(true, 8, 7);
float z = pack.UnpackFixed(true, 8, 7);
AngularVelocity = new Vector3(x, y, z);
x = pack.UnpackFixed(true, 8, 7);
y = pack.UnpackFixed(true, 8, 7);
z = pack.UnpackFixed(true, 8, 7);
PartAcceleration = new Vector3(x, y, z);
Texture = pack.UuidValue;
Target = pack.UuidValue;
}
public void Test1()
{
byte[] bytes = BitConverter.GetBytes(0xAA);
BitPacker packer = new BitPacker(bytes);
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
bytes = BitConverter.GetBytes(0x0A);
packer = new BitPacker(bytes);
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
}
protected virtual ISerializableWispObject DeserializeWispObject(ArraySegment <byte> value)
{
Pointer p = new Pointer();
p.Position = value.Offset + 3;
return(BitPacker.GetSerializableWispObject(value.Array, p));
}
public void Test1()
{
byte[] bytes = BitConverter.GetBytes(0xAA);
BitPacker packer = new BitPacker(bytes);
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
bytes = BitConverter.GetBytes(0x0A);
packer = new BitPacker(bytes);
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
Assert.IsFalse(packer.GetBoolean());
}
public static LayerData ToLayerMessage(List <LayerPatch> patches, LayerData.LayerDataType type, int offset, int length, out int outlength)
{
outlength = 0;
var layer = new LayerData
{
LayerType = type
};
bool extended = false;
switch (type)
{
case LayerData.LayerDataType.CloudExtended:
case LayerData.LayerDataType.LandExtended:
case LayerData.LayerDataType.WaterExtended:
case LayerData.LayerDataType.WindExtended:
extended = true;
break;
}
var header = new GroupHeader
{
Stride = STRIDE,
PatchSize = LAYER_PATCH_NUM_XY_ENTRIES,
Type = type
};
var data = new byte[1500];
var bitpack = new BitPacker(data, 0);
bitpack.PackBits(header.Stride, 16);
bitpack.PackBits(header.PatchSize, 8);
bitpack.PackBits((uint)header.Type, 8);
int remainingbits = 1300 * 8; /* 1300 is a bit more than 2 perfectly bad compressed layer patches, wind needs two per packet */
for (int i = 0; i < length; i++)
{
int patchno = i + offset;
if (patches[patchno].Data.Length != LAYER_PATCH_NUM_XY_ENTRIES * LAYER_PATCH_NUM_XY_ENTRIES)
{
throw new ArgumentException("Patch data must be a 16x16 array");
}
if (CompressPatch(bitpack, patches[patchno], extended, ref remainingbits))
{
++outlength;
}
else
{
break;
}
}
bitpack.PackBits(END_OF_PATCHES, 8);
layer.Data = new byte[bitpack.NumBytes];
Buffer.BlockCopy(bitpack.Data, 0, layer.Data, 0, bitpack.NumBytes);
return(layer);
}
private void UnpackLegacyData(BitPacker pack)
{
PartDataFlags = (ParticleDataFlags)pack.UnpackUnsignedBits(32);
PartMaxAge = pack.UnpackFixed(false, 8, 8);
PartStartColor = pack.ColorValue;
PartEndColor = pack.ColorValue;
PartStartScaleX = pack.UnpackFixed(false, 3, 5);
PartStartScaleY = pack.UnpackFixed(false, 3, 5);
PartEndScaleX = pack.UnpackFixed(false, 3, 5);
PartEndScaleY = pack.UnpackFixed(false, 3, 5);
}
private void PackLegacyData(BitPacker pack)
{
pack.PackBits((uint)PartDataFlags, 32);
pack.PackFixed(PartMaxAge, false, 8, 8);
pack.ColorValue = PartStartColor;
pack.ColorValue = PartEndColor;
pack.PackFixed(PartStartScaleX, false, 3, 5);
pack.PackFixed(PartStartScaleY, false, 3, 5);
pack.PackFixed(PartEndScaleX, false, 3, 5);
pack.PackFixed(PartEndScaleY, false, 3, 5);
}
public void TestEndian()
{
uint intValue = 0xAABBCCDD;
BitPacker.SwapEndian(ref intValue);
Assert.AreEqual(0xDDCCBBAA, intValue);
ushort ushortValue = 0xAABB;
BitPacker.SwapEndian(ref ushortValue);
Assert.AreEqual(0xBBAA, ushortValue);
}
public LayerPatch(double defaultHeight)
{
PackedData = new BitPacker(PackedDataBytes);
for (int y = 0; y < 16; ++y)
{
for (int x = 0; x < 16; ++x)
{
Data[y, x] = (float)defaultHeight;
}
}
}
public void HandleAuthSession(ref IPacketReader packet, ref IWorldManager manager)
{
Authenticator.PacketCrypt.Initialised = true;
packet.Position = 58;
int addonsize = packet.ReadInt32();
int decompressedSize = packet.ReadInt32();
byte[] addonData = this.GetAddonInfo(packet);
// get account name
packet.Position = 62 + addonsize;
var bitUnpack = new BitUnpacker(packet);
int nameLen = bitUnpack.GetBits <int>(12);
string name = packet.ReadString(nameLen).ToUpper();
Account account = new Account(name);
account.Load <Character>();
manager.Account = account;
PacketWriter writer = new PacketWriter(Sandbox.Instance.Opcodes[global::Opcodes.SMSG_AUTH_RESPONSE], "SMSG_AUTH_RESPONSE");
var bitPack = new BitPacker(writer);
bitPack.Write(0); // IsInQueue
bitPack.Write(1); // HasAccountData
bitPack.Flush();
writer.WriteUInt8(0);
writer.WriteUInt8(4);
writer.WriteUInt32(0);
writer.WriteUInt32(0);
writer.WriteUInt8(4);
writer.WriteUInt32(0);
writer.WriteUInt8(0xC);
manager.Send(writer);
// create addoninfo packet
var addonPacketInfo = new PacketReader(addonData, false);
var addonPacketResponse = new PacketWriter(Sandbox.Instance.Opcodes[global::Opcodes.SMSG_ADDON_INFO], "SMSG_ADDON_INFO");
this.WriteAddonInfo(addonPacketInfo, addonPacketResponse, decompressedSize);
manager.Send(addonPacketResponse);
// Tutorial Flags : REQUIRED
PacketWriter tutorial = new PacketWriter(Sandbox.Instance.Opcodes[global::Opcodes.SMSG_TUTORIAL_FLAGS], "SMSG_TUTORIAL_FLAGS");
for (int i = 0; i < 8; i++)
{
tutorial.WriteUInt32(0);
}
manager.Send(tutorial);
}
protected virtual ArraySegment <byte> SerializeWispObject(ISerializableWispObject value)
{
byte[] buff = new byte[512];
buff[0] = 255;
buff[1] = 128;
buff[2] = 255;
Pointer p = new Pointer();
p.Position = 3;
BitPacker.AddSerializableWispObject(ref buff, p, value);
return(new ArraySegment <byte>(buff, 0, p.Position));
}
public List <IPacket> Receive(byte[] pData)
{
FrameSerializer.BitPacking = BitPacker.FromArray(pData);
uint crcValue = FrameSerializer.BitPacking.ReadValue(CrcCheck.HashSize); // CRC
#if TRACE_LOG
Log("Read CRC : " + crcValue + " (" + CrcCheck.HashSize + "Bits)");
#endif
dCrcParameters.Check = crcValue;
byte[] dataCrcCalculation = FrameSerializer.BitPacking.GetByteBuffer();
if (CrcCheck.IsRight(dataCrcCalculation))
{
CurrentSequence = (ushort)FrameSerializer.BitPacking.ReadValue(SEQUENCE_SIZE); // Sequence
#if TRACE_LOG
Log("Read Sequence : " + Sequence + " (" + SEQUENCE_SIZE + "Bits)");
#endif
Debug.Assert(!Program.StopOnSequence.HasValue || CurrentSequence != Program.StopOnSequence.Value);
List <IPacket> result = new List <IPacket>();
int id = 0;
// Read the packets until an error occur or if the BitLenght is less than a byte.
// This is because when the data are sent they are always rounded at the superior byte and the end of a packet is filled with 0's.
while (FrameSerializer.BitPacking.BitLength >= 8 && !FrameSerializer.Error)
{
#if TRACE_LOG
Log("Packet ID : ");
#endif
FrameSerializer.Serialize(ref id, 0, dFactory.Count() - 1); // Packet ID
IPacket packet = dFactory.CreateInstance <IPacket>(id);
packet.Header = new PacketHeader(crcValue, CurrentSequence);
#if TRACE_LOG
Log("Packet Data : ");
#endif
if (packet.Serialize(FrameSerializer)) // Data
{
result.Add(packet);
}
}
return(result);
}
else
{
#if TRACE_LOG
Log("Refused packet !");
#endif
}
return(null);
}
/// Set a pixel in the display.
public void SetPixel(int x, int y, byte colorIndex)
{
// TODO Move it somewhere else.
if (!isInitialized)
{
Initialize();
}
colorIndex = (byte)(colorIndex % numColors);
int pixelNum = (y * resolution.x) + x;
BitPacker.Pack(colorIndex, pixelNum, colorIndicesCPU);
dirtyColorIndices = true;
}
public void Test2()
{
byte[] bytes;
BitPacker packer;
bytes = BitConverter.GetBytes(0xAFFF);
packer = new BitPacker(bytes);
Assert.IsTrue(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.AreEqual(15, packer.GetByte(4));
Assert.IsTrue(packer.GetBoolean());
Assert.AreEqual(95, packer.GetByte(7));
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
}
public void Test2()
{
byte[] bytes;
BitPacker packer;
bytes = BitConverter.GetBytes(0xAFFF);
packer = new BitPacker(bytes);
Assert.IsTrue(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
Assert.AreEqual(15, packer.GetByte(4));
Assert.IsTrue(packer.GetBoolean());
Assert.AreEqual(95, packer.GetByte(7));
Assert.IsFalse(packer.GetBoolean());
Assert.IsTrue(packer.GetBoolean());
}
public LayerPatch(LayerPatch p)
{
PackedData = new BitPacker(PackedDataBytes);
X = p.X;
Y = p.Y;
lock (m_Lock)
{
Serial = p.Serial;
for (int y = 0; y < 16; ++y)
{
for (int x = 0; x < 16; ++x)
{
Data[y, x] = p.Data[y, x];
}
}
}
}
private static bool CompressPatch(BitPacker pack, LayerPatch layerpatch, bool extended, ref int remainingbits)
{
lock (layerpatch)
{
/* check whether we have to run terrain compression */
if (layerpatch.Serial != layerpatch.PackedSerial)
{
layerpatch.PackedData.Reset();
if (layerpatch.Data.Length != LAYER_PATCH_NUM_XY_ENTRIES * LAYER_PATCH_NUM_XY_ENTRIES)
{
throw new ArgumentException("Patch data must be a 16x16 array");
}
var pheader = PrescanPatch(layerpatch);
pheader.QuantWBits = 136;
if (extended)
{
pheader.PatchIDs = layerpatch.Y & 0xFFFF;
pheader.PatchIDs += layerpatch.X << 16;
}
else
{
pheader.PatchIDs = layerpatch.Y & 0x1F;
pheader.PatchIDs += layerpatch.X << 5;
}
int[] patch = CompressPatch(layerpatch, pheader, 10);
int wbits = EncodePatchHeader(layerpatch.PackedData, pheader, patch, extended);
EncodePatch(layerpatch.PackedData, patch, 0, wbits);
layerpatch.PackedSerial = layerpatch.Serial;
}
if (layerpatch.PackedData.BitLength <= remainingbits)
{
remainingbits -= layerpatch.PackedData.BitLength;
pack.PackBits(layerpatch.PackedData);
return(true);
}
return(false);
}
}
private void PackSystemBytes(BitPacker pack)
{
pack.PackBits(CRC, 32);
pack.PackBits(PartFlags, 32);
pack.PackBits((uint)Pattern, 8);
pack.PackFixed(MaxAge, false, 8, 8);
pack.PackFixed(StartAge, false, 8, 8);
pack.PackFixed(InnerAngle, false, 3, 5);
pack.PackFixed(OuterAngle, false, 3, 5);
pack.PackFixed(BurstRate, false, 8, 8);
pack.PackFixed(BurstRadius, false, 8, 8);
pack.PackFixed(BurstSpeedMin, false, 8, 8);
pack.PackFixed(BurstSpeedMax, false, 8, 8);
pack.PackBits(BurstPartCount, 8);
pack.PackFixed((float)AngularVelocity.X, true, 8, 7);
pack.PackFixed((float)AngularVelocity.Y, true, 8, 7);
pack.PackFixed((float)AngularVelocity.Z, true, 8, 7);
pack.PackFixed((float)PartAcceleration.X, true, 8, 7);
pack.PackFixed((float)PartAcceleration.Y, true, 8, 7);
pack.PackFixed((float)PartAcceleration.Z, true, 8, 7);
pack.UuidValue = Texture;
pack.UuidValue = Target;
}
public void Test3()
{
byte[] bytes;
BitPacker packer;
bytes = BitConverter.GetBytes(0xAFFF);
packer = new BitPacker(bytes);
Assert.AreEqual(15, packer.GetByte(4));
Assert.AreEqual(15, packer.GetByte(4));
Assert.AreEqual(0xAF, packer.GetUshort(8));
bytes = BitConverter.GetBytes(0x0CD000);
packer = new BitPacker(bytes);
Assert.AreEqual(0x00, packer.GetByte(8));
Assert.AreEqual(0x0CD0, packer.GetUshort(16));
bytes = BitConverter.GetBytes(0x000F << 1);
packer = new BitPacker(bytes);
Assert.IsFalse(packer.GetBoolean());
Assert.AreEqual(0xF, packer.GetUshort(8));
bytes = BitConverter.GetBytes(0xAABB);
packer = new BitPacker(bytes);
Assert.AreEqual(0xAABB, packer.GetUshort(16, BitPacker.Endian.LoHi));
packer.Reset();
Assert.AreEqual(0xBBAA, packer.GetUshort(16, BitPacker.Endian.HiLo));
packer.Reset();
Assert.AreEqual(0xBBAA, packer.GetUshort(16, BitPacker.Endian.HiLo));
bytes = BitConverter.GetBytes(0x0100);
packer = new BitPacker(bytes);
Assert.AreEqual(0x0001, packer.GetUshort(16, BitPacker.Endian.HiLo));
}
public void Test3()
{
byte[] bytes;
BitPacker packer;
bytes = BitConverter.GetBytes(0xAFFF);
packer = new BitPacker(bytes);
Assert.AreEqual(15, packer.GetByte(4));
Assert.AreEqual(15, packer.GetByte(4));
Assert.AreEqual(0xAF,packer.GetUshort(8));
bytes = BitConverter.GetBytes(0x0CD000);
packer = new BitPacker(bytes);
Assert.AreEqual(0x00, packer.GetByte(8));
Assert.AreEqual(0x0CD0, packer.GetUshort(16));
bytes = BitConverter.GetBytes(0x000F << 1) ;
packer = new BitPacker(bytes);
Assert.IsFalse(packer.GetBoolean());
Assert.AreEqual(0xF, packer.GetUshort(8));
bytes = BitConverter.GetBytes(0xAABB);
packer = new BitPacker(bytes);
Assert.AreEqual(0xAABB, packer.GetUshort(16, BitPacker.Endian.LoHi));
packer.Reset();
Assert.AreEqual(0xBBAA, packer.GetUshort(16, BitPacker.Endian.HiLo));
packer.Reset();
Assert.AreEqual(0xBBAA, packer.GetUshort(16, BitPacker.Endian.HiLo));
bytes = BitConverter.GetBytes(0x0100);
packer = new BitPacker(bytes);
Assert.AreEqual(0x0001, packer.GetUshort(16, BitPacker.Endian.HiLo));
}
/// Create all the buffers, set up the Compute Shader etc. Can only be done once. Depends on the resolution
public void Initialize()
{
if (isInitialized)
{
throw new Exception("The ScreenView is already initialized!");
}
// CPU side data containers.
colorIndicesCPU = BitPacker.MakeStorageFor4BitValues(resolution.x * resolution.y);
colorPaletteCPU = CreateDefaultColorPalette();
// GPU-side data containers.
colorIndicesGPU = new ComputeBuffer(resolution.x * resolution.y, numBytesPerUint);
colorPaletteGPU = new ComputeBuffer(numColors, numBytesPerColor);
targetTexture = CreateTargetTexture();
SetupComputeShader();
SetupMaterial();
dirtyColorPalette = dirtyColorIndices = true;
isVisibleToPlayer = true;
isInitialized = true;
}
private static void EncodePatch(BitPacker output, int[] patch, int postquant, int wbits)
{
/* maximum possible length of patch data 640 Bytes */
int temp;
bool eob;
if (postquant > LAYER_PATCH_NUM_XY_ENTRIES * LAYER_PATCH_NUM_XY_ENTRIES || postquant < 0)
{
m_Log.ErrorFormat("Postquant {0} is outside the range of allowed values in EncodePatch()", postquant);
return;
}
if (postquant != 0)
{
patch[LAYER_PATCH_NUM_XY_ENTRIES * LAYER_PATCH_NUM_XY_ENTRIES - postquant] = 0;
}
for (int i = 0; i < LAYER_PATCH_NUM_XY_ENTRIES * LAYER_PATCH_NUM_XY_ENTRIES; i++)
{
eob = false;
temp = patch[i];
if (temp == 0)
{
eob = true;
for (int j = i; j < LAYER_PATCH_NUM_XY_ENTRIES * LAYER_PATCH_NUM_XY_ENTRIES - postquant; j++)
{
if (patch[j] != 0)
{
eob = false;
break;
}
}
if (eob)
{
output.PackBits(ZERO_EOB, 2);
return;
}
else
{
output.PackBits(ZERO_CODE, 1);
}
}
else
{
if (temp < 0)
{
temp *= -1;
if (temp >= (1 << wbits))
{
temp = (1 << wbits) - 1;
}
output.PackBits(NEGATIVE_VALUE, 3);
output.PackBits(temp, wbits);
}
else
{
if (temp >= (1 << wbits))
{
temp = (1 << wbits) - 1;
}
output.PackBits(POSITIVE_VALUE, 3);
output.PackBits(temp, wbits);
}
}
}
}
private static int EncodePatchHeader(BitPacker output, PatchHeader header, int[] patch, bool extended)
{
int temp;
int wbits = (header.QuantWBits & 0x0f) + 2;
uint maxWbits = (uint)wbits + 5;
uint minWbits = (uint)wbits >> 1;
wbits = (int)minWbits;
for (int i = 0; i < patch.Length; i++)
{
temp = patch[i];
if (temp != 0)
{
// Get the absolute value
if (temp < 0)
{
temp *= -1;
}
for (int j = (int)maxWbits; j > (int)minWbits; j--)
{
if ((temp & (1 << j)) != 0)
{
if (j > wbits)
{
wbits = j;
}
break;
}
}
}
}
wbits++;
if (wbits > 17)
{
wbits = 17;
}
else if (wbits < 2)
{
wbits = 2;
}
header.QuantWBits &= 0xf0;
header.QuantWBits |= wbits - 2;
output.PackBits(header.QuantWBits, 8);
output.FloatValue = header.DCOffset;
output.PackBits(header.Range, 16);
if (extended)
{
output.PackBits(header.PatchIDs, 32);
}
else
{
output.PackBits(header.PatchIDs, 10);
}
/* Bit Length of Header in VarRegion format: 56 bits => 7 Bytes */
return(wbits);
}
/// <summary>
/// Decodes a byte[] array into a ParticleSystem Object
/// </summary>
/// <param name="data">ParticleSystem object</param>
/// <param name="pos">Start position for BitPacker</param>
public ParticleSystem(byte[] data, int pos)
{
BlendFuncSource = BlendFunc.SourceAlpha;
BlendFuncDest = BlendFunc.OneMinusSourceAlpha;
MaxAge = 0.0f;
StartAge = 0.0f;
InnerAngle = 0.0f;
OuterAngle = 0.0f;
BurstRate = 0.0f;
BurstRadius = 0.0f;
BurstSpeedMin = 0.0f;
BurstSpeedMax = 0.0f;
AngularVelocity = Vector3.Zero;
PartAcceleration = Vector3.Zero;
Texture = UUID.Zero;
Target = UUID.Zero;
PartStartColor = ColorAlpha.Black;
PartEndColor = ColorAlpha.Black;
PartStartScaleX = 0.0f;
PartStartScaleY = 0.0f;
PartEndScaleX = 0.0f;
PartEndScaleY = 0.0f;
int size = data.Length - pos;
var pack = new BitPacker(data, pos);
if (size == LegacyDataBlockSize)
{
UnpackSystem(pack);
UnpackLegacyData(pack);
}
else if (size > LegacyDataBlockSize && size <= MaxDataBlockSize)
{
int sysSize = pack.UnpackSignedBits(32);
if (sysSize != SysDataSize)
{
return; // unkown particle system data size
}
UnpackSystem(pack);
/*int dataSize = */ pack.UnpackSignedBits(32);
UnpackLegacyData(pack);
if ((PartDataFlags & ParticleDataFlags.DataGlow) == ParticleDataFlags.DataGlow)
{
if (pack.Data.Length - pack.BytePos < 2)
{
return;
}
uint glow = pack.UnpackUnsignedBits(8);
PartStartGlow = glow / 255f;
glow = pack.UnpackUnsignedBits(8);
PartEndGlow = glow / 255f;
}
if ((PartDataFlags & ParticleDataFlags.DataBlend) == ParticleDataFlags.DataBlend)
{
if (pack.Data.Length - pack.BytePos < 2)
{
return;
}
BlendFuncSource = (BlendFunc)pack.UnpackUnsignedBits(8);
BlendFuncDest = (BlendFunc)pack.UnpackUnsignedBits(8);
}
}
}
public void SetColorCodeAt(int x, int y, ColorCode colorCode)
{
BitPacker.Pack((byte)colorCode, IndexAt(x, y), colorIndicesPacked);
}
public LayerPatch()
{
PackedData = new BitPacker(PackedDataBytes);
}
void compressFrame()
{
//#ifdef TIMELINE_SAMPLE_CODEC_TEST
//static BDynamicCoderBuf coderBuf(65536);
//BBitPacker<BDynamicCoderBuf> bitPacker(&coderBuf);
BDynamicCoderBuf coderBuf = new BDynamicCoderBuf(65536);
BitPacker bitPacker = new BitPacker(coderBuf);
//#ifdef DUMP_OVERHEAD_TIME_TO_TRACE
UInt64 startTime = ReadCycleCounter();
//#endif
// Reset the compressor's model to empty and compress all the samples to a buffer.
mComp.resetModel();
coderBuf.setPos(0);
bitPacker.encodeStart();
bool success;
for (uint i = 0; i < size(mCurFrame); i++)
{
/*const BRetiredProfileSample&*/ BRetiredProfileSample sample = mCurFrame[i];
BASSERT(sample.mSectionID < size(mSections));
success = mComp.codeSample(bitPacker, ref sample, ref mSections[sample.mSectionID]);
BASSERT(success);
}
/*const*/ uint totalInBytes = (uint)(size(mCurFrame) * 23 /*sizeof(BRetiredProfileSample)*/);
/*const*/ uint totalOutBytes = coderBuf.getPos();
success = bitPacker.encodeEnd();
BASSERT(success);
//#if 1
// Now decompress the samples and compare them to the original samples.
mDecomp.resetModel();
coderBuf.setPos(0);
success = bitPacker.decodeStart();
BASSERT(success);
for (uint i = 0; i < size(mCurFrame); i++)
{
/*const BRetiredProfileSample&*/ BRetiredProfileSample sample = mCurFrame[i];
BASSERT(sample.mSectionID < size(mSections));
BRetiredProfileSample decodedSample = new BRetiredProfileSample();
success = mDecomp.decodeSample(bitPacker, ref decodedSample, mSections);
BASSERT(success);
BASSERT(decodedSample.mSectionID == sample.mSectionID);
BASSERT(decodedSample.mUserID == sample.mUserID);
BASSERT(decodedSample.mLevel == sample.mLevel);
BASSERT(decodedSample.mCPUStartTime == sample.mCPUStartTime);
BASSERT(decodedSample.mCPUEndTime == sample.mCPUEndTime);
if (sample.hasGPUTimes())
{
BASSERT(decodedSample.hasGPUTimes());
BASSERT(decodedSample.mGPUStartTime == sample.mGPUStartTime);
BASSERT(decodedSample.mGPUEndTime == sample.mGPUEndTime);
}
else
{
BASSERT(!decodedSample.hasGPUTimes());
}
}
//#endif
//#ifdef DUMP_OVERHEAD_TIME_TO_TRACE
UInt64 endTime = ReadCycleCounter();
/*static UInt64 totalTime;*/
/*static uint frameCount;*/
totalTime += (endTime - startTime);
frameCount++;
if (frameCount == 60)
{
//blogtrace(String.Format("Compress/decompress: %4.3f ms/frame", totalTime / (float)(frameCount) * gpProfileManager->getOOCompCPUFreq() * 1000.0f));
frameCount = 0;
totalTime = 0;
}
if (size(mCurFrame) > 0)
{
blogtrace(String.Format("Compression samples: %i, Bytes: %i, Compressed bytes: %i, Ave. bytes per sample: %f, Ave. bits per byte: %f",
size(mCurFrame),
totalInBytes,
totalOutBytes,
(float)(totalOutBytes) / size(mCurFrame),
(totalOutBytes * 8.0f) / totalInBytes));
}
//#endif
//#endif TIMELINE_SAMPLE_CODEC_TEST
}
public void BitPacker_1()
{
var buffer = new BitPacker(1);
var xs = buffer.UnpackUInts(new byte[] { 0b10110011 });
/// <summary>
/// Generate byte[] array from particle data
/// </summary>
/// <returns>Byte array</returns>
public byte[] GetBytes()
{
int size = LegacyDataBlockSize;
if (!IsLegacyCompatible())
{
size += 8; // two new ints for size
}
if (HasGlow())
{
size += 2; // two bytes for start and end glow
}
if (HasBlendFunc())
{
size += 2; // two bytes for start end end blend function
}
var bytes = new byte[size];
var pack = new BitPacker(bytes, 0);
if (IsLegacyCompatible())
{
PackSystemBytes(pack);
PackLegacyData(pack);
}
else
{
if (HasGlow())
{
PartDataFlags |= ParticleDataFlags.DataGlow;
}
if (HasBlendFunc())
{
PartDataFlags |= ParticleDataFlags.DataBlend;
}
pack.PackBits(SysDataSize, 32);
PackSystemBytes(pack);
int partSize = PartDataSize;
if (HasGlow())
{
partSize += 2; // two bytes for start and end glow
}
if (HasBlendFunc())
{
partSize += 2; // two bytes for start end end blend function
}
pack.PackBits(partSize, 32);
PackLegacyData(pack);
if (HasGlow())
{
pack.PackBits((byte)(PartStartGlow * 255f), 8);
pack.PackBits((byte)(PartEndGlow * 255f), 8);
}
if (HasBlendFunc())
{
pack.PackBits((byte)BlendFuncSource, 8);
pack.PackBits((byte)BlendFuncDest, 8);
}
}
return(bytes);
}
public void HandleCharEnum(ref IPacketReader packet, ref IWorldManager manager)
{
var account = manager.Account;
var result = account.Characters.Where(x => x.Build == Sandbox.Instance.Build);
PacketWriter writer = new PacketWriter(Sandbox.Instance.Opcodes[global::Opcodes.SMSG_CHAR_ENUM], "SMSG_CHAR_ENUM");
BitPacker bitPacker = new BitPacker(writer);
bitPacker.Write(1);
bitPacker.Write(0, 23);
bitPacker.Write(result.Count(), 17);
foreach (Character c in result)
{
bitPacker.Write(0, 3);
bitPacker.Write(c.Guid & 0xFF);
bitPacker.Write((c.Guid >> 8) & 0xFF);
bitPacker.Write(0);
bitPacker.Write(c.Name.Length, 7);
bitPacker.Write(0, 4);
bitPacker.Write((c.Guid >> 16) & 0xFF);
bitPacker.Write((c.Guid >> 24) & 0xFF);
bitPacker.Write(0, 5);
}
bitPacker.Flush();
foreach (Character c in result)
{
writer.WriteUInt8(c.Gender);
writer.WriteUInt8((byte)c.Level);
// items
for (int i = 0; i < 0x17; i++)
{
writer.WriteUInt32(0);
writer.WriteUInt32(0);
writer.WriteUInt8(0);
}
writer.WriteGUIDByte(c.Guid, 0);
writer.WriteFloat(c.Location.Z);
writer.WriteUInt8(c.HairColor);
writer.WriteUInt32(c.Zone);
writer.WriteGUIDByte(c.Guid, 3);
writer.WriteGUIDByte(c.Guid, 1);
writer.WriteUInt32(0);
writer.WriteFloat(c.Location.X);
writer.WriteUInt8(0);
writer.WriteUInt8(c.HairStyle);
writer.WriteUInt32(c.Location.Map);
writer.WriteUInt8(c.Face);
writer.WriteUInt8(c.Skin);
writer.Write(System.Text.Encoding.ASCII.GetBytes(c.Name));
writer.WriteUInt8(c.FacialHair);
writer.WriteUInt8(c.Class);
writer.WriteUInt32(0);
writer.WriteUInt8(c.Race);
writer.WriteFloat(c.Location.Y);
writer.WriteGUIDByte(c.Guid, 2);
writer.WriteUInt32(0); // customise flags
writer.WriteUInt32(0); // char flags
writer.WriteUInt32(0);
}
manager.Send(writer);
}
public ColorCode GetColorCodeAt(int x, int y)
{
return((ColorCode)BitPacker.Unpack(IndexAt(x, y), colorIndicesPacked));
}
public ScreenBufferState(Vector2Int size)
{
this.size = size;
colorIndicesPacked = BitPacker.MakeStorageFor4BitValues(size.x * size.y);
}
