public static void CopyFieldsFromBuffer <TOutputStream>(NetworkSchema schema, byte[] inputBuffer, ref TOutputStream output) where TOutputStream : NetworkCompression.IOutputStream { var input = new ByteInputStream(inputBuffer); int fieldIndex = 0; for (; fieldIndex < schema.fields.Count; ++fieldIndex) { var field = schema.fields[fieldIndex]; switch (field.fieldType) { case NetworkSchema.FieldType.Bool: case NetworkSchema.FieldType.UInt: case NetworkSchema.FieldType.Int: case NetworkSchema.FieldType.Float: output.WriteRawBits(input.ReadBits(field.bits), field.bits); break; case NetworkSchema.FieldType.Vector2: output.WriteRawBits(input.ReadUInt32(), field.bits); output.WriteRawBits(input.ReadUInt32(), field.bits); break; case NetworkSchema.FieldType.Vector3: output.WriteRawBits(input.ReadUInt32(), field.bits); output.WriteRawBits(input.ReadUInt32(), field.bits); output.WriteRawBits(input.ReadUInt32(), field.bits); break; case NetworkSchema.FieldType.Quaternion: output.WriteRawBits(input.ReadUInt32(), field.bits); output.WriteRawBits(input.ReadUInt32(), field.bits); output.WriteRawBits(input.ReadUInt32(), field.bits); output.WriteRawBits(input.ReadUInt32(), field.bits); break; case NetworkSchema.FieldType.String: case NetworkSchema.FieldType.ByteArray: { byte[] data; int dataIndex; int dataSize; input.GetByteArray(out data, out dataIndex, out dataSize, field.arraySize); output.WritePackedUInt((uint)dataSize, field.startContext); output.WriteRawBytes(data, dataIndex, dataSize); } break; default: GameDebug.Assert(false); break; } } }
static public unsafe void Write <TOutputStream>(ref TOutputStream output, NetworkSchema schema, byte[] inputData, byte[] baselineData, byte[] fieldsChangedPrediction, byte fieldMask, ref uint entity_hash) where TOutputStream : NetworkCompression.IOutputStream { GameDebug.Assert(baselineData != null); var inputStream = new ByteInputStream(inputData); var baselineStream = new ByteInputStream(baselineData); int numFields = schema.fields.Count; GameDebug.Assert(fieldsChangedPrediction.Length >= numFields / 8, "Not enough bits in fieldsChangedPrediction for all fields"); for (int i = 0, l = fieldsNotPredicted.Length; i < l; ++i) { fieldsNotPredicted[i] = 0; } // calculate bitmask of fields that need to be encoded for (int fieldIndex = 0; fieldIndex < schema.fields.Count; ++fieldIndex) { var field = schema.fields[fieldIndex]; // Skip fields that are masked out bool masked = (field.fieldMask & fieldMask) != 0; byte fieldByteOffset = (byte)((uint)fieldIndex >> 3); byte fieldBitOffset = (byte)((uint)fieldIndex & 0x7); switch (field.fieldType) { case NetworkSchema.FieldType.Bool: { uint value = inputStream.ReadBits(1); uint baseline = baselineStream.ReadUInt8(); if (!masked) { entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, value); if (value != baseline) { fieldsNotPredicted[fieldByteOffset] |= (byte)(1 << fieldBitOffset); } } break; } case NetworkSchema.FieldType.Int: { uint value = inputStream.ReadBits(field.bits); uint baseline = (uint)baselineStream.ReadBits(field.bits); if (!masked) { entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, value); if (value != baseline) { fieldsNotPredicted[fieldByteOffset] |= (byte)(1 << fieldBitOffset); } } break; } case NetworkSchema.FieldType.UInt: { uint value = inputStream.ReadBits(field.bits); uint baseline = (uint)baselineStream.ReadBits(field.bits); if (!masked) { entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, value); if (value != baseline) { fieldsNotPredicted[fieldByteOffset] |= (byte)(1 << fieldBitOffset); } } break; } case NetworkSchema.FieldType.Float: { uint value = inputStream.ReadBits(field.bits); uint baseline = (uint)baselineStream.ReadBits(field.bits); if (!masked) { entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, value); if (value != baseline) { fieldsNotPredicted[fieldByteOffset] |= (byte)(1 << fieldBitOffset); } } break; } case NetworkSchema.FieldType.Vector2: { uint vx = inputStream.ReadBits(field.bits); uint vy = inputStream.ReadBits(field.bits); uint bx = baselineStream.ReadUInt32(); uint by = baselineStream.ReadUInt32(); if (!masked) { entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, vx); entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, vy); if (vx != bx || vy != by) { fieldsNotPredicted[fieldByteOffset] |= (byte)(1 << fieldBitOffset); } } break; } case NetworkSchema.FieldType.Vector3: { uint vx = inputStream.ReadBits(field.bits); uint vy = inputStream.ReadBits(field.bits); uint vz = inputStream.ReadBits(field.bits); uint bx = baselineStream.ReadUInt32(); uint by = baselineStream.ReadUInt32(); uint bz = baselineStream.ReadUInt32(); if (!masked) { entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, vx); entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, vy); entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, vz); if (vx != bx || vy != by || vz != bz) { fieldsNotPredicted[fieldByteOffset] |= (byte)(1 << fieldBitOffset); } } break; } case NetworkSchema.FieldType.Quaternion: { uint vx = inputStream.ReadBits(field.bits); uint vy = inputStream.ReadBits(field.bits); uint vz = inputStream.ReadBits(field.bits); uint vw = inputStream.ReadBits(field.bits); uint bx = baselineStream.ReadUInt32(); uint by = baselineStream.ReadUInt32(); uint bz = baselineStream.ReadUInt32(); uint bw = baselineStream.ReadUInt32(); if (!masked) { entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, vx); entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, vy); entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, vz); entity_hash = NetworkUtils.SimpleHashStreaming(entity_hash, vw); if (vx != bx || vy != by || vz != bz || vw != bw) { fieldsNotPredicted[fieldByteOffset] |= (byte)(1 << fieldBitOffset); } } break; } case NetworkSchema.FieldType.String: case NetworkSchema.FieldType.ByteArray: { // TODO : Do a better job of string and buffer diffs? byte[] valueBuffer; int valueOffset; int valueLength; inputStream.GetByteArray(out valueBuffer, out valueOffset, out valueLength, field.arraySize); byte[] baselineBuffer = null; int baselineOffset = 0; int baselineLength = 0; baselineStream.GetByteArray(out baselineBuffer, out baselineOffset, out baselineLength, field.arraySize); if (!masked) { entity_hash += 0; // TODO client side has no easy way to hash strings. enable this when possible: NetworkUtils.SimpleHash(valueBuffer, valueLength); if (valueLength != baselineLength || NetworkUtils.MemCmp(valueBuffer, valueOffset, baselineBuffer, baselineOffset, valueLength) != 0) { fieldsNotPredicted[fieldByteOffset] |= (byte)(1 << fieldBitOffset); } } } break; } } inputStream.Reset(); baselineStream.Reset(); int skipContext = schema.id * NetworkConfig.maxContextsPerSchema + NetworkConfig.firstSchemaContext; // Client needs fieldsNotPredicted. We send the delta between it and fieldsChangedPrediction { for (int i = 0; i * 8 < numFields; i++) { byte deltaFields = (byte)(fieldsNotPredicted[i] ^ fieldsChangedPrediction[i]); output.WritePackedNibble((uint)(deltaFields & 0xF), skipContext + i * 2); output.WritePackedNibble((uint)((deltaFields >> 4) & 0xF), skipContext + i * 2 + 1); } } int startBitPosition = 0; for (int fieldIndex = 0; fieldIndex < numFields; ++fieldIndex) { var field = schema.fields[fieldIndex]; int fieldStartContext = field.startContext; startBitPosition = output.GetBitPosition2(); byte fieldByteOffset = (byte)((uint)fieldIndex >> 3); byte fieldBitOffset = (byte)((uint)fieldIndex & 0x7); var notPredicted = ((fieldsNotPredicted[fieldByteOffset] & (1 << fieldBitOffset)) != 0); switch (field.fieldType) { case NetworkSchema.FieldType.Bool: { uint value = inputStream.ReadBits(1); /*uint unused_baseline = */ baselineStream.ReadUInt8(); if (notPredicted) { output.WriteRawBits(value, 1); NetworkSchema.AddStatsToFieldBool(field, (value != 0), false, output.GetBitPosition2() - startBitPosition); } break; } case NetworkSchema.FieldType.Int: { uint value = inputStream.ReadBits(field.bits); uint baseline = (uint)baselineStream.ReadBits(field.bits); if (notPredicted) { if (field.delta) { output.WritePackedUIntDelta(value, baseline, fieldStartContext); NetworkSchema.AddStatsToFieldInt(field, (int)value, (int)baseline, output.GetBitPosition2() - startBitPosition); } else { output.WriteRawBits(value, field.bits); NetworkSchema.AddStatsToFieldInt(field, (int)value, 0, output.GetBitPosition2() - startBitPosition); } } break; } case NetworkSchema.FieldType.UInt: { uint value = inputStream.ReadBits(field.bits); uint baseline = (uint)baselineStream.ReadBits(field.bits); if (notPredicted) { if (field.delta) { output.WritePackedUIntDelta(value, baseline, fieldStartContext); NetworkSchema.AddStatsToFieldUInt(field, value, baseline, output.GetBitPosition2() - startBitPosition); } else { output.WriteRawBits(value, field.bits); NetworkSchema.AddStatsToFieldUInt(field, value, 0, output.GetBitPosition2() - startBitPosition); } } break; } case NetworkSchema.FieldType.Float: { uint value = inputStream.ReadBits(field.bits); uint baseline = (uint)baselineStream.ReadBits(field.bits); if (notPredicted) { if (field.delta) { output.WritePackedUIntDelta(value, baseline, fieldStartContext); NetworkSchema.AddStatsToFieldFloat(field, value, baseline, output.GetBitPosition2() - startBitPosition); } else { output.WriteRawBits(value, field.bits); NetworkSchema.AddStatsToFieldFloat(field, value, 0, output.GetBitPosition2() - startBitPosition); } } break; } case NetworkSchema.FieldType.Vector2: { uint vx = inputStream.ReadBits(field.bits); uint vy = inputStream.ReadBits(field.bits); uint bx = baselineStream.ReadUInt32(); uint by = baselineStream.ReadUInt32(); if (notPredicted) { if (field.delta) { output.WritePackedUIntDelta(vx, bx, fieldStartContext + 0); output.WritePackedUIntDelta(vy, by, fieldStartContext + 1); NetworkSchema.AddStatsToFieldVector2(field, vx, vy, bx, by, output.GetBitPosition2() - startBitPosition); } else { output.WriteRawBits(vx, field.bits); output.WriteRawBits(vy, field.bits); NetworkSchema.AddStatsToFieldVector2(field, vx, vy, 0, 0, output.GetBitPosition2() - startBitPosition); } } break; } case NetworkSchema.FieldType.Vector3: { uint vx = inputStream.ReadBits(field.bits); uint vy = inputStream.ReadBits(field.bits); uint vz = inputStream.ReadBits(field.bits); uint bx = baselineStream.ReadUInt32(); uint by = baselineStream.ReadUInt32(); uint bz = baselineStream.ReadUInt32(); if (notPredicted) { if (field.delta) { output.WritePackedUIntDelta(vx, bx, fieldStartContext + 0); output.WritePackedUIntDelta(vy, by, fieldStartContext + 1); output.WritePackedUIntDelta(vz, bz, fieldStartContext + 2); NetworkSchema.AddStatsToFieldVector3(field, vx, vy, vz, bx, by, bz, output.GetBitPosition2() - startBitPosition); } else { output.WriteRawBits(vx, field.bits); output.WriteRawBits(vy, field.bits); output.WriteRawBits(vz, field.bits); NetworkSchema.AddStatsToFieldVector3(field, vx, vy, vz, 0, 0, 0, output.GetBitPosition2() - startBitPosition); } } break; } case NetworkSchema.FieldType.Quaternion: { // TODO : Figure out what to do with quaternions uint vx = inputStream.ReadBits(field.bits); uint vy = inputStream.ReadBits(field.bits); uint vz = inputStream.ReadBits(field.bits); uint vw = inputStream.ReadBits(field.bits); uint bx = baselineStream.ReadUInt32(); uint by = baselineStream.ReadUInt32(); uint bz = baselineStream.ReadUInt32(); uint bw = baselineStream.ReadUInt32(); if (notPredicted) { if (field.delta) { output.WritePackedUIntDelta(vx, bx, fieldStartContext + 0); output.WritePackedUIntDelta(vy, by, fieldStartContext + 1); output.WritePackedUIntDelta(vz, bz, fieldStartContext + 2); output.WritePackedUIntDelta(vw, bw, fieldStartContext + 3); NetworkSchema.AddStatsToFieldQuaternion(field, vx, vy, vz, vw, bx, by, bz, bw, output.GetBitPosition2() - startBitPosition); } else { output.WriteRawBits(vx, field.bits); output.WriteRawBits(vy, field.bits); output.WriteRawBits(vz, field.bits); output.WriteRawBits(vw, field.bits); NetworkSchema.AddStatsToFieldQuaternion(field, vx, vy, vz, vw, 0, 0, 0, 0, output.GetBitPosition2() - startBitPosition); } } break; } case NetworkSchema.FieldType.String: case NetworkSchema.FieldType.ByteArray: { // TODO : Do a better job of string and buffer diffs? byte[] valueBuffer; int valueOffset; int valueLength; inputStream.GetByteArray(out valueBuffer, out valueOffset, out valueLength, field.arraySize); byte[] baselineBuffer = null; int baselineOffset = 0; int baselineLength = 0; baselineStream.GetByteArray(out baselineBuffer, out baselineOffset, out baselineLength, field.arraySize); if (notPredicted) { output.WritePackedUInt((uint)valueLength, fieldStartContext); output.WriteRawBytes(valueBuffer, valueOffset, valueLength); if (field.fieldType == NetworkSchema.FieldType.String) { NetworkSchema.AddStatsToFieldString(field, valueBuffer, valueOffset, valueLength, output.GetBitPosition2() - startBitPosition); } else { NetworkSchema.AddStatsToFieldByteArray(field, valueBuffer, valueOffset, valueLength, output.GetBitPosition2() - startBitPosition); } } } break; } } }