Ejemplo n.º 1
0
        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);
        }
Ejemplo n.º 2
0
        public override object Process(object o)
        {
            SerializableFLProgram input = (SerializableFLProgram)o;

            Dictionary <string, SerializableExternalFLFunction> convertedFuncs =
                new Dictionary <string, SerializableExternalFLFunction>();

            for (int i = input.ExternalFunctions.Count - 1; i >= 0; i--)
            {
                SerializableExternalFLFunction serializableExternalFlFunction = input.ExternalFunctions[i];
                if (serializableExternalFlFunction.Modifiers.ComputeOnce)
                {
                    string newName = "_cached_" + serializableExternalFlFunction.Name;
                    convertedFuncs.Add(newName, serializableExternalFlFunction);
                    input.ExternalFunctions.RemoveAt(i);


                    LazyLoadingFLBuffer buf = new LazyLoadingFLBuffer(
                        root =>
                    {
                        FLProgram prog =
                            serializableExternalFlFunction
                            .ExternalProgram
                            .Initialize(
                                root.Instance,
                                InstructionSet
                                );
                        FLBuffer b = new FLBuffer(
                            root.Instance,
                            root.Dimensions.x,
                            root.Dimensions.y,
                            root.Dimensions.z,
                            "CachedBuffer" +
                            serializableExternalFlFunction
                            .Name
                            );
                        prog.Run(b, true);

                        b = prog.GetActiveBuffer(true);
                        prog.FreeResources();
                        return(b);
                    },
                        serializableExternalFlFunction
                        .Modifiers.InitializeOnStart
                        );

                    input.DefinedBuffers.Add(
                        new SerializableScriptBuffer(
                            newName,
                            new FLBufferModifiers(
                                newName,
                                new[]
                    {
                        FLKeywords
                        .ReadOnlyBufferModifier
                    }
                                ),
                            buf
                            )
                        );
                }
            }

            foreach (KeyValuePair <string, SerializableExternalFLFunction> staticFunction in convertedFuncs)
            {
                foreach (SerializableFLFunction serializableFlFunction in input.Functions)
                {
                    foreach (SerializableFLInstruction serializableFlInstruction in serializableFlFunction.Instructions)
                    {
                        for (int i = 0; i < serializableFlInstruction.Arguments.Count; i++)
                        {
                            SerializableFLInstructionArgument arg = serializableFlInstruction.Arguments[i];
                            if (arg.Identifier == staticFunction.Value.Name)
                            {
                                serializableFlInstruction.Arguments[i] =
                                    new SerializeBufferArgument(staticFunction.Key);
                            }
                        }
                    }
                }
            }


            return(input);
        }