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()))); }