public static void AddRpmLimit(FlatBufferBuilder builder, float rpmLimit)
{
builder.AddFloat(0, rpmLimit, 0.0f);
}
public static void AddY(FlatBufferBuilder builder, float y)
{
builder.AddFloat(3, y, 0.0f);
}
public static void AddCellClip(FlatBufferBuilder builder, float cellClip)
{
builder.AddFloat(1, cellClip, 0.0f);
}
public static void AddShieldAbsorbRate(FlatBufferBuilder builder, float shieldAbsorbRate)
{
builder.AddFloat(17, shieldAbsorbRate, 0.0f);
}
public static void AddCritDamage(FlatBufferBuilder builder, float critDamage)
{
builder.AddFloat(21, critDamage, 0.0f);
}
public static void AddTestFloat(FlatBufferBuilder builder, float testFloat)
{
builder.AddFloat(0, testFloat, 0.0f);
}
public static void AddOpacity(FlatBufferBuilder builder, float opacity)
{
builder.AddFloat(2, opacity, 0.0f);
}
public static void AddFloat(FlatBufferBuilder builder, float Float)
{
builder.AddFloat(9, Float, 0.0f);
}
public static void AddFloat_(FlatBufferBuilder builder, float float_)
{
builder.AddFloat(5, float_, 1000.0f);
}
public static void AddF2(FlatBufferBuilder builder, float f2)
{
builder.AddFloat(6, f2, Single.PositiveInfinity);
}
public static void AddF3(FlatBufferBuilder builder, float f3)
{
builder.AddFloat(7, f3, Single.NegativeInfinity);
}
public static void AddF1(FlatBufferBuilder builder, float f1)
{
builder.AddFloat(5, f1, Single.NaN);
}
public static void AddF0(FlatBufferBuilder builder, float f0)
{
builder.AddFloat(4, f0, Single.NaN);
}
public static void AddTimeStamp(FlatBufferBuilder builder, float timeStamp)
{
builder.AddFloat(4, timeStamp, 0.0f);
}
private void CheckObjects(int fieldCount, int objectCount)
{
_lcg.Reset();
const int testValuesMax = 11;
var builder = new FlatBufferBuilder(1);
var objects = new int[objectCount];
for (var i = 0; i < objectCount; ++i)
{
builder.StartObject(fieldCount);
for (var j = 0; j < fieldCount; ++j)
{
var fieldType = _lcg.Next()%testValuesMax;
switch (fieldType)
{
case 0:
{
builder.AddBool(j, FuzzTestData.BoolValue, false);
break;
}
case 1:
{
builder.AddSbyte(j, FuzzTestData.Int8Value, 0);
break;
}
case 2:
{
builder.AddByte(j, FuzzTestData.UInt8Value, 0);
break;
}
case 3:
{
builder.AddShort(j, FuzzTestData.Int16Value, 0);
break;
}
case 4:
{
builder.AddUshort(j, FuzzTestData.UInt16Value, 0);
break;
}
case 5:
{
builder.AddInt(j, FuzzTestData.Int32Value, 0);
break;
}
case 6:
{
builder.AddUint(j, FuzzTestData.UInt32Value, 0);
break;
}
case 7:
{
builder.AddLong(j, FuzzTestData.Int64Value, 0);
break;
}
case 8:
{
builder.AddUlong(j, FuzzTestData.UInt64Value, 0);
break;
}
case 9:
{
builder.AddFloat(j, FuzzTestData.Float32Value, 0);
break;
}
case 10:
{
builder.AddDouble(j, FuzzTestData.Float64Value, 0);
break;
}
default:
throw new Exception("Unreachable");
}
}
var offset = builder.EndObject();
// Store the object offset
objects[i] = offset;
}
_lcg.Reset();
// Test all objects are readable and return expected values...
for (var i = 0; i < objectCount; ++i)
{
var table = new TestTable(builder.DataBuffer, builder.DataBuffer.Length - objects[i]);
for (var j = 0; j < fieldCount; ++j)
{
var fieldType = _lcg.Next() % testValuesMax;
var fc = 2 + j; // 2 == VtableMetadataFields
var f = fc * 2;
switch (fieldType)
{
case 0:
{
Assert.AreEqual(FuzzTestData.BoolValue, table.GetSlot(f, false));
break;
}
case 1:
{
Assert.AreEqual(FuzzTestData.Int8Value, table.GetSlot(f, (sbyte)0));
break;
}
case 2:
{
Assert.AreEqual(FuzzTestData.UInt8Value, table.GetSlot(f, (byte)0));
break;
}
case 3:
{
Assert.AreEqual(FuzzTestData.Int16Value, table.GetSlot(f, (short)0));
break;
}
case 4:
{
Assert.AreEqual(FuzzTestData.UInt16Value, table.GetSlot(f, (ushort)0));
break;
}
case 5:
{
Assert.AreEqual(FuzzTestData.Int32Value, table.GetSlot(f, (int)0));
break;
}
case 6:
{
Assert.AreEqual(FuzzTestData.UInt32Value, table.GetSlot(f, (uint)0));
break;
}
case 7:
{
Assert.AreEqual(FuzzTestData.Int64Value, table.GetSlot(f, (long)0));
break;
}
case 8:
{
Assert.AreEqual(FuzzTestData.UInt64Value, table.GetSlot(f, (ulong)0));
break;
}
case 9:
{
Assert.AreEqual(FuzzTestData.Float32Value, table.GetSlot(f, (float)0));
break;
}
case 10:
{
Assert.AreEqual(FuzzTestData.Float64Value, table.GetSlot(f, (double)0));
break;
}
default:
throw new Exception("Unreachable");
}
}
}
}
public static void AddTestf(FlatBufferBuilder builder, float testf)
{
builder.AddFloat(25, testf, 3.14159f);
}
public static void AddValue(FlatBufferBuilder builder, float value)
{
builder.AddFloat(1, value, 1234.0f);
}
public static void AddTestf2(FlatBufferBuilder builder, float testf2)
{
builder.AddFloat(26, testf2, 3.0f);
}
public static void AddGameSeconds(FlatBufferBuilder builder, float gameSeconds)
{
builder.AddFloat(1, gameSeconds, 0.0f);
}
public static void AddTestf3(FlatBufferBuilder builder, float testf3)
{
builder.AddFloat(27, testf3, 0.0f);
}
private void CheckObjects(int fieldCount, int objectCount)
{
_lcg.Reset();
const int testValuesMax = 11;
var builder = new FlatBufferBuilder(1);
var objects = new int[objectCount];
for (var i = 0; i < objectCount; ++i)
{
builder.StartObject(fieldCount);
for (var j = 0; j < fieldCount; ++j)
{
var fieldType = _lcg.Next() % testValuesMax;
switch (fieldType)
{
case 0:
{
builder.AddBool(j, FuzzTestData.BoolValue, false);
break;
}
case 1:
{
builder.AddSbyte(j, FuzzTestData.Int8Value, 0);
break;
}
case 2:
{
builder.AddByte(j, FuzzTestData.UInt8Value, 0);
break;
}
case 3:
{
builder.AddShort(j, FuzzTestData.Int16Value, 0);
break;
}
case 4:
{
builder.AddUshort(j, FuzzTestData.UInt16Value, 0);
break;
}
case 5:
{
builder.AddInt(j, FuzzTestData.Int32Value, 0);
break;
}
case 6:
{
builder.AddUint(j, FuzzTestData.UInt32Value, 0);
break;
}
case 7:
{
builder.AddLong(j, FuzzTestData.Int64Value, 0);
break;
}
case 8:
{
builder.AddUlong(j, FuzzTestData.UInt64Value, 0);
break;
}
case 9:
{
builder.AddFloat(j, FuzzTestData.Float32Value, 0);
break;
}
case 10:
{
builder.AddDouble(j, FuzzTestData.Float64Value, 0);
break;
}
default:
throw new Exception("Unreachable");
}
}
var offset = builder.EndObject();
// Store the object offset
objects[i] = offset;
}
_lcg.Reset();
// Test all objects are readable and return expected values...
for (var i = 0; i < objectCount; ++i)
{
var table = new TestTable(builder.DataBuffer, builder.DataBuffer.Length - objects[i]);
for (var j = 0; j < fieldCount; ++j)
{
var fieldType = _lcg.Next() % testValuesMax;
var fc = 2 + j; // 2 == VtableMetadataFields
var f = fc * 2;
switch (fieldType)
{
case 0:
{
Assert.AreEqual(FuzzTestData.BoolValue, table.GetSlot(f, false));
break;
}
case 1:
{
Assert.AreEqual(FuzzTestData.Int8Value, table.GetSlot(f, (sbyte)0));
break;
}
case 2:
{
Assert.AreEqual(FuzzTestData.UInt8Value, table.GetSlot(f, (byte)0));
break;
}
case 3:
{
Assert.AreEqual(FuzzTestData.Int16Value, table.GetSlot(f, (short)0));
break;
}
case 4:
{
Assert.AreEqual(FuzzTestData.UInt16Value, table.GetSlot(f, (ushort)0));
break;
}
case 5:
{
Assert.AreEqual(FuzzTestData.Int32Value, table.GetSlot(f, (int)0));
break;
}
case 6:
{
Assert.AreEqual(FuzzTestData.UInt32Value, table.GetSlot(f, (uint)0));
break;
}
case 7:
{
Assert.AreEqual(FuzzTestData.Int64Value, table.GetSlot(f, (long)0));
break;
}
case 8:
{
Assert.AreEqual(FuzzTestData.UInt64Value, table.GetSlot(f, (ulong)0));
break;
}
case 9:
{
Assert.AreEqual(FuzzTestData.Float32Value, table.GetSlot(f, (float)0));
break;
}
case 10:
{
Assert.AreEqual(FuzzTestData.Float64Value, table.GetSlot(f, (double)0));
break;
}
default:
throw new Exception("Unreachable");
}
}
}
}
public static void AddF32(FlatBufferBuilder builder, float f32)
{
builder.AddFloat(8, f32, 0.0f);
}
public static void AddCritRate(FlatBufferBuilder builder, float critRate)
{
builder.AddFloat(20, critRate, 0.0f);
}
public static void AddVolume(FlatBufferBuilder builder, float volume)
{
builder.AddFloat(2, volume, 1.0f);
}
public static void AddX(FlatBufferBuilder builder, float x)
{
builder.AddFloat(2, x, 0.0f);
}
public static void AddSoundGain(FlatBufferBuilder builder, float soundGain)
{
builder.AddFloat(5, soundGain, 0.0f);
}
public static void AddZ(FlatBufferBuilder builder, float z)
{
builder.AddFloat(4, z, 0.0f);
}
public static void AddSoundRadius(FlatBufferBuilder builder, float soundRadius)
{
builder.AddFloat(6, soundRadius, 0.0f);
}
public static void AddProjClip(FlatBufferBuilder builder, float projClip)
{
builder.AddFloat(2, projClip, 0.0f);
}
public static void AddKey(FlatBufferBuilder builder, float key)
{
builder.AddFloat(0, key, 0.0f);
}
public static void AddRpmMax(FlatBufferBuilder builder, float rpmMax)
{
builder.AddFloat(1, rpmMax, 0.0f);
}
public void TestWithFloat()
{
var builder = new FlatBufferBuilder(1);
builder.StartObject(1);
builder.AddFloat(0, 1, 0);
builder.EndObject();
Assert.ArrayEqual(new byte[]
{
0, 0,
6, 0, // vtable bytes
8, 0, // object length
4, 0, // start of value 0
6, 0, 0, 0, // int32 offset for start of vtable
0, 0, 128, 63, // value
},
builder.DataBuffer.Data);
}
