public override object Deserialize(PrimitiveValueWrapper s)
{
string name = ResolveId(s.ReadInt());
FLBufferModifiers bmod = new FLBufferModifiers(name, s.ReadArray <string>());
return(new SerializableRandomFLBuffer(name, bmod, bmod.IsArray ? s.ReadInt() : 0));
}
public override void Serialize(PrimitiveValueWrapper s, object obj)
{
if (!(obj is SerializableFromFileFLBuffer buffer))
{
throw new InvalidOperationException("Invalid type for Serializer.");
}
s.Write(ResolveName(buffer.Name));
s.Write(StoreRaw);
s.WriteArray(buffer.Modifiers.GetModifiers().ToArray());
//s.Write(buffer.IsArray);
if (StoreRaw)
{
Bitmap bmp = buffer.Bitmap;
MemoryStream ms = new MemoryStream();
bmp.Save(ms, ImageFormat.Png);
s.Write(ms.GetBuffer(), (int)ms.Position);
bmp.Dispose();
}
else
{
s.Write(buffer.File);
}
if (buffer.IsArray)
{
s.Write(buffer.Size);
}
}
/// <summary>
/// Deserializes a BasePacket from the stream.
/// </summary>
/// <param name="s">Input Stream</param>
/// <returns>Deserialized BasePacket</returns>
public override BasePacket DeserializePacket(PrimitiveValueWrapper pvw)
{
object packetType = pvw.ReadByte();
byte[] payload = pvw.ReadBytes();
return(new BasePacket(packetType, payload));
}
public override void Serialize(PrimitiveValueWrapper s, object input)
{
SerializableWaveFunctionCollapseFLBuffer obj = (SerializableWaveFunctionCollapseFLBuffer)input;
s.Write(ResolveName(obj.Name));
s.Write(obj.Parameter.Force);
s.Write(obj.Parameter.N);
s.Write(obj.Parameter.Width);
s.Write(obj.Parameter.Height);
s.Write(obj.Parameter.Symmetry);
s.Write(obj.Parameter.Ground);
s.Write(obj.Parameter.Limit);
s.Write(obj.Parameter.PeriodicInput);
s.Write(obj.Parameter.PeriodicOutput);
MemoryStream ms = new MemoryStream();
Bitmap bmp = obj.Parameter.SourceImage.Bitmap;
bmp.Save(ms, ImageFormat.Png);
s.Write(ms.GetBuffer(), (int)ms.Position);
bmp.Dispose();
}
private void WriteStringArray(PrimitiveValueWrapper s, string[] arr)
{
s.Write(arr.Length);
for (int i = 0; i < arr.Length; i++)
{
s.Write(arr[i]);
}
}
public override T DeserializePacket(PrimitiveValueWrapper s)
{
T ret = default(T);
byte[] bytes = s.ReadBytes();
PacketHelper.BytesToStruct(bytes, ref ret);
return(ret);
}
private string[] ReadStringArray(PrimitiveValueWrapper s)
{
string[] ret = new string[s.ReadInt()];
for (int i = 0; i < ret.Length; i++)
{
ret[i] = s.ReadString();
}
return(ret);
}
public override SerializableFLProgram DeserializePacket(PrimitiveValueWrapper s)
{
int funcCount = s.ReadInt();
int defCount = s.ReadInt();
int extCount = s.ReadInt();
List <SerializableFLBuffer> defs = new List <SerializableFLBuffer>();
List <SerializableFLFunction> funcs = new List <SerializableFLFunction>();
List <SerializableExternalFLFunction> exts = new List <SerializableExternalFLFunction>();
string[] idMap = ReadStringArray(s);
SetIdMap(idMap);
for (int i = 0; i < defCount; i++)
{
MemoryStream temp = new MemoryStream(s.ReadBytes());
if (!BufferSerializer.TryReadPacket(temp, out SerializableFLBuffer def))
{
throw new FLDeserializationException(
$"Can not Deserialize Serializable Defined buffer: ID: {i}"
);
}
defs.Add(def);
}
for (int i = 0; i < funcCount; i++)
{
MemoryStream temp = new MemoryStream(s.ReadBytes());
if (!BufferSerializer.TryReadPacket(temp, out SerializableFLFunction def))
{
throw new FLDeserializationException(
$"Can not Deserialize Serializable Defined buffer: ID: {i}"
);
}
funcs.Add(def);
}
for (int i = 0; i < extCount; i++)
{
MemoryStream temp = new MemoryStream(s.ReadBytes());
if (!BufferSerializer.TryReadPacket(temp, out SerializableExternalFLFunction def))
{
throw new FLDeserializationException(
$"Can not Deserialize Serializable Defined buffer: ID: {i}"
);
}
exts.Add(def);
}
return(new SerializableFLProgram("DeserializedScript", exts, funcs, defs));
}
public override void Serialize(PrimitiveValueWrapper s, object obj)
{
SerializableRandomFLBuffer input = (SerializableRandomFLBuffer)obj;
s.Write(ResolveName(input.Name));
s.WriteArray(input.Modifiers.GetModifiers().ToArray());
if (input.IsArray)
{
s.Write(input.Size);
}
}
public override void SerializePacket(PrimitiveValueWrapper s, FLHeader obj)
{
vs.SerializePacket(s, obj.HeaderVersion);
vs.SerializePacket(s, obj.CommonVersion);
vs.SerializePacket(s, obj.SerializerVersion);
s.Write(obj.ExtraSerializationSteps.Length);
for (int i = 0; i < obj.ExtraSerializationSteps.Length; i++)
{
s.Write(obj.ExtraSerializationSteps[i]);
}
}
public override void Serialize(PrimitiveValueWrapper s, object obj)
{
SerializableFLFunction input = (SerializableFLFunction)obj;
s.Write(ResolveName(input.Name));
s.Write(input.Instructions.Count);
for (int i = 0; i < input.Instructions.Count; i++)
{
instructionSerializer.Serialize(s, input.Instructions[i]);
}
}
public override void Serialize(PrimitiveValueWrapper s, object obj)
{
SerializableExternalFLFunction input = (SerializableExternalFLFunction)obj;
s.Write(input.Name);
s.WriteArray(input.Modifiers.GetModifiers().ToArray());
MemoryStream ms = new MemoryStream();
FLSerializer.SaveProgram(ms, input.ExternalProgram, instructionSet, new string[0]);
s.Write(ms.GetBuffer(), (int)ms.Position);
}
public override object Deserialize(PrimitiveValueWrapper s)
{
string name = ResolveId(s.ReadInt());
int instC = s.ReadInt();
List <SerializableFLInstruction> inst = new List <SerializableFLInstruction>();
for (int i = 0; i < instC; i++)
{
inst.Add((SerializableFLInstruction)instructionSerializer.Deserialize(s));
}
return(new SerializableFLFunction(name, inst));
}
public override object Deserialize(PrimitiveValueWrapper s)
{
string name = ResolveId(s.ReadInt());
string[] mods = s.ReadArray <string>();
FLBufferModifiers bmod = new FLBufferModifiers(name, mods);
if (bmod.IsArray)
{
return(new SerializableEmptyFLBuffer(name, s.ReadInt(), bmod));
}
return(new SerializableEmptyFLBuffer(name, bmod));
}
public override object Deserialize(PrimitiveValueWrapper s)
{
string name = ResolveId(s.ReadInt());
FLFunctionElementModifiers fmod = new FLFunctionElementModifiers(name, s.ReadArray <string>());
int instC = s.ReadInt();
List <SerializableFLInstruction> inst = new List <SerializableFLInstruction>();
for (int i = 0; i < instC; i++)
{
inst.Add((SerializableFLInstruction)instructionSerializer.Deserialize(s));
}
return(new SerializableFLFunction(name, new StaticInstruction[0], inst, fmod));
}
public override object Deserialize(PrimitiveValueWrapper s)
{
byte[] bytes = s.ReadBytes();
Stream str = new MemoryStream(bytes);
if (!ElementArgumentSerializers.TryReadPacket(str, out object obj))
{
throw new Exception("F**K");
}
return(new SerializeArrayElementArgumentEnclosedIndex(
ResolveId(s.ReadInt()),
(SerializeArrayElementArgument)obj
));
}
public override object Deserialize(PrimitiveValueWrapper s)
{
string name = s.ReadString();
FLExecutableElementModifiers emod = new FLExecutableElementModifiers(name, s.ReadArray <string>());
byte[] payload = s.ReadBytes();
MemoryStream ms = new MemoryStream(payload);
return(new SerializableExternalFLFunction(
name,
FLSerializer.LoadProgram(ms, instructionSet),
emod
));
}
public override void SerializePacket(PrimitiveValueWrapper s, FLFileFormat obj)
{
flHs.SerializePacket(s, obj.CompilerHeader);
phs.SerializePacket(s, obj.ProgramHeader);
byte[] program = obj.Program;
List <ExtraStage> extraStages = CreateExtraStages(obj.CompilerHeader.ExtraSerializationSteps);
for (int i = 0; i < extraStages.Count; i++)
{
program = extraStages[i].ToFile.Process(program);
}
s.Write(program);
}
public override object Deserialize(PrimitiveValueWrapper s)
{
string name = ResolveId(s.ReadInt());
bool raw = s.ReadBool();
FLBufferModifiers bmod = new FLBufferModifiers(name, s.ReadArray <string>());
if (raw)
{
MemoryStream ms = new MemoryStream(s.ReadBytes());
Bitmap bmp = (Bitmap)Image.FromStream(ms);
return(new SerializableFromBitmapFLBuffer(name, bmp, bmod, bmod.IsArray ? s.ReadInt() : 0));
}
string file = s.ReadString();
return(new SerializableFromFileFLBuffer(name, file, bmod, bmod.IsArray ? s.ReadInt() : 0));
}
public override void SerializePacket(PrimitiveValueWrapper wrapper, Packet obj)
{
wrapper.Write(obj.valfloat);
wrapper.Write(obj.valdouble);
wrapper.Write(obj.valint);
wrapper.Write(obj.valuint);
wrapper.Write(obj.valshort);
wrapper.Write(obj.valushort);
wrapper.Write(obj.vallong);
wrapper.Write(obj.valulong);
wrapper.Write(obj.valbytes);
wrapper.Write(obj.valbyte);
wrapper.Write(obj.valstring);
}
public override object Deserialize(PrimitiveValueWrapper s)
{
string name = ResolveId(s.ReadInt());
bool raw = s.ReadBool();
if (raw)
{
MemoryStream ms = new MemoryStream(s.ReadBytes());
Bitmap bmp = (Bitmap)Image.FromStream(ms);
return(new SerializableFromBitmapFLBuffer(name, bmp));
}
else
{
string file = s.ReadString();
return(new SerializableFromFileFLBuffer(name, file));
}
}
public override void Serialize(PrimitiveValueWrapper s, object input)
{
SerializableFLInstruction obj = (SerializableFLInstruction)input;
s.Write(ResolveName(obj.InstructionKey));
s.Write(obj.Arguments.Count);
for (int i = 0; i < obj.Arguments.Count; i++)
{
MemoryStream temp = new MemoryStream();
if (!argSerializer.TryWritePacket(temp, obj.Arguments[i]))
{
throw new FLSerializationException("Can not serialize Serializable Argument: " +
obj.Arguments[i].GetType());
}
s.Write(temp.GetBuffer(), (int)temp.Position);
}
}
public override object Deserialize(PrimitiveValueWrapper s)
{
string name = ResolveId(s.ReadInt());
FLBufferModifiers bmod = new FLBufferModifiers(name, s.ReadArray <string>());
bool force = s.ReadBool();
int n = s.ReadInt();
int width = s.ReadInt();
int height = s.ReadInt();
int symmetry = s.ReadInt();
int ground = s.ReadInt();
int limit = s.ReadInt();
bool pIn = s.ReadBool();
bool pOut = s.ReadBool();
MemoryStream ms = new MemoryStream(s.ReadBytes());
Bitmap bmp = (Bitmap)Image.FromStream(ms);
WFCParameterObject obj = new WFCParameterObject(
new SerializableFromBitmapFLBuffer(
"wfc-bin",
bmp,
bmod,
bmod.IsArray
? s.ReadInt()
: 0
),
n,
width,
height,
symmetry,
ground,
limit,
pIn,
pOut,
force
);
return(new SerializableWaveFunctionCollapseFLBuffer(name, obj, bmod));
}
public override void Serialize(PrimitiveValueWrapper s, object obj)
{
Stream str = new MemoryStream();
if (!ElementArgumentSerializers.TryWritePacket(
str,
(obj as SerializeArrayElementArgumentEnclosedIndex).Index
))
{
throw new Exception("F**K");
}
byte[] arr = new byte[str.Position];
str.Position = 0;
str.Read(arr, 0, arr.Length);
s.Write(arr);
s.Write(ResolveName((obj as SerializeArrayElementArgumentEnclosedIndex).Value));
}
public override Packet DeserializePacket(PrimitiveValueWrapper wrapper)
{
Packet p = new Packet
{
valfloat = wrapper.ReadFloat(),
valdouble = wrapper.ReadDouble(),
valint = wrapper.ReadInt(),
valuint = wrapper.ReadUInt(),
valshort = wrapper.ReadShort(),
valushort = wrapper.ReadUShort(),
vallong = wrapper.ReadLong(),
valulong = wrapper.ReadULong(),
valbytes = wrapper.ReadBytes(),
valbyte = wrapper.ReadByte(),
valstring = wrapper.ReadString(),
arrStrings = wrapper.ReadArray <string>(),
arrFloats = wrapper.ReadArray <float>()
};
return(p);
}
public override FLFileFormat DeserializePacket(PrimitiveValueWrapper s)
{
FLHeader header = flHs.DeserializePacket(s);
if (!header.IsCompatible())
{
throw new FLDeserializationException("The Loaded Script is not compatible.");
}
FLProgramHeader programHeader = phs.DeserializePacket(s);
byte[] program = s.ReadBytes();
List <ExtraStage> extraStages = CreateExtraStages(header.ExtraSerializationSteps);
for (int i = 0; i < extraStages.Count; i++)
{
program = extraStages[i].FromFile.Process(program);
}
return(new FLFileFormat(header, programHeader, program));
}
public override object Deserialize(PrimitiveValueWrapper s)
{
string key = ResolveId(s.ReadInt());
int argCount = s.ReadInt();
List <SerializableFLInstructionArgument> args = new List <SerializableFLInstructionArgument>();
for (int i = 0; i < argCount; i++)
{
MemoryStream temp = new MemoryStream(s.ReadBytes());
if (!argSerializer.TryReadPacket(temp, out SerializableFLInstructionArgument arg))
{
throw new FLDeserializationException(
$"Can not Deserialize Serializable Argument of Instruction: {key} ID: {i}");
}
args.Add(arg);
}
return(new SerializableFLInstruction(key, args));
}
public override FLHeader DeserializePacket(PrimitiveValueWrapper s)
{
Version headerVersion = vs.DeserializePacket(s);
if (FLVersions.HeaderVersion != headerVersion)
{
throw new FLDeserializationException(
$"The Header version can not be parsed. Supported Version: {FLVersions.HeaderVersion} Required Version: {headerVersion}");
}
Version commonVersion = vs.DeserializePacket(s);
Version serializerVersion = vs.DeserializePacket(s);
int len = s.ReadInt();
string[] extraInitializationSteps = new string[len];
for (int i = 0; i < len; i++)
{
extraInitializationSteps[i] = s.ReadString();
}
return(new FLHeader(headerVersion, serializerVersion, commonVersion, extraInitializationSteps));
}
/// <summary>
/// Serializes a BasePacket to the Stream
/// </summary>
/// <param name="s">Target Stream</param>
/// <param name="obj">BasePacket to Serialize</param>
public override void SerializePacket(PrimitiveValueWrapper pvw, BasePacket obj)
{
pvw.Write((byte)obj.PacketType);
pvw.Write(obj.Payload);
}
public override object Deserialize(PrimitiveValueWrapper s)
{
return(new SerializeExternalFunctionArgument(ResolveId(s.ReadInt())));
}
