Example #1
0
        static uint WriteImpl(MemoryPool memory, Button button)
        {
            var buttonMemory = memory.AllocatePadded(Constants.IntPtrSize * 16, Constants.IntPtrSize);

            using (var buttonWriter = GetWriter(buttonMemory))
            {
                buttonWriter.Write((UInt32)CharacterType.Button);
                buttonWriter.Write((UInt32)Character.SIGNATURE);
                buttonWriter.WriteBooleanUInt32(button.IsMenu);
                buttonWriter.Write((Vector4)button.Bounds);

                buttonWriter.Write((UInt32)button.Triangles.Length);
                buttonWriter.Write((UInt32)button.Vertices.Length);
                var verticesAddress  = ArrayWriter.WritePlainArray(memory, button.Vertices);
                var trianglesAddress = ArrayWriter.WritePlainArray(memory, button.Triangles);
                buttonWriter.Write((UInt32)verticesAddress);
                buttonWriter.Write((UInt32)trianglesAddress);

                buttonWriter.Write((UInt32)button.Records.Count);
                var recordsAddress = ArrayWriter.WritePlainArray(memory, button.Records);
                buttonWriter.Write((UInt32)recordsAddress);

                buttonWriter.Write((UInt32)button.Actions.Count);
                var actionsAddress = ArrayWriter.WritePlainArray(memory, button.Actions);
                buttonWriter.Write((UInt32)actionsAddress);

                buttonWriter.Write((UInt32)0);
            }

            return(buttonMemory.StartAddress);
        }
Example #2
0
        static uint WriteClipEventArray(MemoryPool memory, ICollection <ClipEvent> clipEvents)
        {
            var clipEventArrayMemory = memory.AllocatePadded(Constants.IntPtrSize * 2, Constants.IntPtrSize);

            using (var clipEventArrayWriter = GetWriter(clipEventArrayMemory))
            {
                clipEventArrayWriter.Write((UInt32)clipEvents.Count);

                var arrayAddress = ArrayWriter.WritePlainArray(memory, clipEvents);
                clipEventArrayWriter.Write((UInt32)arrayAddress);
            }
            return(clipEventArrayMemory.StartAddress);
        }
Example #3
0
        static uint WriteImpl(MemoryPool memory, Sprite sprite)
        {
            var spriteMemory = memory.AllocatePadded(Constants.IntPtrSize * 5, Constants.IntPtrSize);

            using (var spriteWriter = GetWriter(spriteMemory))
            {
                spriteWriter.Write((UInt32)CharacterType.Sprite);
                spriteWriter.Write((UInt32)Character.SIGNATURE);

                spriteWriter.Write((UInt32)sprite.Frames.Count);
                var framesAddress = ArrayWriter.WritePlainArray(memory, sprite.Frames);
                spriteWriter.Write((UInt32)framesAddress);

                spriteWriter.Write((UInt32)0); // pointer
            }
            return(spriteMemory.StartAddress);
        }
Example #4
0
        static uint WriteImpl(MemoryPool memory, Font font)
        {
            var fontMemory = memory.AllocatePadded(Constants.IntPtrSize * 5, Constants.IntPtrSize);

            using (var fontWriter = GetWriter(fontMemory))
            {
                fontWriter.Write((UInt32)CharacterType.Font);
                fontWriter.Write((UInt32)Character.SIGNATURE);

                var nameAddress = Write(memory, font.Name);
                fontWriter.Write((UInt32)nameAddress);

                fontWriter.Write((UInt32)font.Glyphs.Count);
                var glyphsAddress = ArrayWriter.WritePlainArray(memory, font.Glyphs);
                fontWriter.Write((UInt32)glyphsAddress);
            }

            return(fontMemory.StartAddress);
        }
Example #5
0
        static uint WriteImpl(MemoryPool memory, Movie movie)
        {
            var importsAddress = ArrayWriter.WritePlainArray(memory, movie.Imports);
            var exportsAddress = ArrayWriter.WritePlainArray(memory, movie.Exports);

            if (movie.Characters.First() != movie)
            {
                throw new ArgumentException("Shouldn't the first element of character array be movie itself?");
            }
            var characterArrayBegin = memory.AllocatePadded(Constants.IntPtrSize, Constants.IntPtrSize);
            var otherCharacters     = movie.Characters.Skip(1).ToList();

            ArrayWriter.WriteArrayOfPointers(memory, otherCharacters);

            var movieMemory = memory.AllocatePadded(Constants.IntPtrSize * 15, Constants.IntPtrSize);

            using (var movieWriter = GetWriter(movieMemory))
            {
                movieWriter.Write((UInt32)CharacterType.Movie);
                movieWriter.Write((UInt32)Character.SIGNATURE);
                movieWriter.Write((UInt32)movie.Frames.Count);
                movieWriter.Write((UInt32)ArrayWriter.WritePlainArray(memory, movie.Frames));
                movieWriter.Write((UInt32)0); // pointer
                movieWriter.Write((UInt32)movie.Characters.Count);
                movieWriter.Write((UInt32)characterArrayBegin.StartAddress);
                movieWriter.Write((UInt32)movie.ScreenWidth);
                movieWriter.Write((UInt32)movie.ScreenHeight);
                movieWriter.Write((UInt32)movie.MillisecondsPerFrame);
                movieWriter.Write((UInt32)movie.Imports.Count);
                movieWriter.Write((UInt32)importsAddress);
                movieWriter.Write((UInt32)movie.Exports.Count);
                movieWriter.Write((UInt32)exportsAddress);
                movieWriter.Write((UInt32)0); // count
            }
            var entryOffset = movieMemory.StartAddress;

            BitConverter.GetBytes((UInt32)entryOffset).CopyTo(characterArrayBegin.Memory, 0);
            return(entryOffset);
        }
Example #6
0
        public static void Write(BinaryWriter writer, MemoryPool memory, InstructionBase instruction)
        {
            var type       = instruction.Type;
            var parameters = instruction.Parameters;

            switch (type)
            {
            case InstructionType.GotoFrame2:
            case InstructionType.EA_PushRegister:
            case InstructionType.EA_PushByte:
                writer.Write((Byte)parameters.First().ToInteger());
                break;

            case InstructionType.EA_PushShort:
                writer.Write((UInt16)parameters.First().ToInteger());
                break;

            case InstructionType.GotoFrame:
            case InstructionType.SetRegister:
            case InstructionType.BranchAlways:
            case InstructionType.BranchIfTrue:
                writer.Write((Int32)parameters.First().ToInteger());
                break;

            case InstructionType.EA_PushFloat:
                writer.Write((Single)parameters.First().ToReal());
                break;

            case InstructionType.EA_PushConstantByte:
            case InstructionType.EA_PushValueOfVar:
            case InstructionType.EA_GetNamedMember:
            case InstructionType.EA_CallNamedFuncPop:
            case InstructionType.EA_CallNamedFunc:
            case InstructionType.EA_CallNamedMethodPop:
            case InstructionType.EA_CallNamedMethod:
                writer.Write((Byte)parameters.First().ToInteger());
                break;

            case InstructionType.EA_PushConstantWord:
                writer.Write((UInt16)parameters.First().ToInteger());
                break;

            case InstructionType.GotoLabel:
            case InstructionType.EA_PushString:
            case InstructionType.EA_GetStringVar:
            case InstructionType.EA_SetStringVar:
            case InstructionType.EA_GetStringMember:
            case InstructionType.EA_SetStringMember:
            {
                var stringAddress = DataWriter.Write(memory, parameters.First().ToString());
                writer.Write((UInt32)stringAddress);
            }
            break;

            case InstructionType.GetURL:
            {
                var urlAddress    = DataWriter.Write(memory, parameters[0].ToString());
                var targetAddress = DataWriter.Write(memory, parameters[1].ToString());

                writer.Write((UInt32)urlAddress);
                writer.Write((UInt32)targetAddress);
            }
            break;

            case InstructionType.ConstantPool:
            {
                writer.Write((UInt32)parameters.Count);
                var constantIDArray        = parameters.ConvertAll <UInt32>((value) => (UInt32)value.ToInteger());
                var constantIDArrayAddress = ArrayWriter.WritePlainArray(memory, constantIDArray);
                writer.Write((UInt32)constantIDArrayAddress);
            }
            break;

            case InstructionType.DefineFunction2:
            {
                var functionNameAddress = DataWriter.Write(memory, parameters[0].ToString());
                var numberOfParameters  = parameters[1].ToInteger();
                var numberOfRegisters   = parameters[2].ToInteger();
                var flags = (UInt32)parameters[3].ToInteger();

                var registersAndParameterNameAddresses = parameters.Skip(4).SkipLast(1).Select((value, index) =>
                    {
                        if (index % 2 == 0)     // register
                        {
                            return((UInt32)value.ToInteger());
                        }
                        else     // parameter name
                        {
                            return((UInt32)DataWriter.Write(memory, value.ToString()));
                        }
                    }).ToList();

                if (registersAndParameterNameAddresses.Count != numberOfParameters * 2)
                {
                    throw new InvalidDataException();
                }

                var parameterListAddress = ArrayWriter.WritePlainArray(memory, registersAndParameterNameAddresses);
                var functionBodySize     = parameters.Last().ToInteger();

                writer.Write((UInt32)functionNameAddress);
                writer.Write((UInt32)numberOfParameters);
                writer.Write((Byte)numberOfRegisters);
                writer.WriteUInt24(flags);
                writer.Write((UInt32)parameterListAddress);
                writer.Write((UInt32)functionBodySize);
                writer.Write((UInt64)Constants.DefineFunctionUnknownNumber);
            }
            break;

            case InstructionType.PushData:
            {
                writer.Write((UInt32)parameters.Count);
                var constantIDArray        = parameters.ConvertAll <UInt32>((value) => (UInt32)value.ToInteger());
                var constantIDArrayAddress = ArrayWriter.WritePlainArray(memory, constantIDArray);
                writer.Write((UInt32)constantIDArrayAddress);
            }
            break;

            case InstructionType.DefineFunction:
            {
                var functionNameAddress  = DataWriter.Write(memory, parameters[0].ToString());
                var numberOfParameters   = parameters[1].ToInteger();
                var parameterList        = parameters.Skip(2).SkipLast(1).Select(value => value.ToString()).ToList();
                var parameterListAddress = ArrayWriter.WriteArrayOfPointers(memory, parameterList);
                var functionBodySize     = parameters.Last().ToInteger();

                writer.Write((UInt32)functionNameAddress);
                writer.Write((UInt32)numberOfParameters);
                writer.Write((UInt32)parameterListAddress);
                writer.Write((UInt32)functionBodySize);
                writer.Write((UInt64)Constants.DefineFunctionUnknownNumber);
            }
            break;

            default:
                if (parameters.Count != 0)
                {
                    throw new NotImplementedException("Unimplemented instruction:" + type.ToString());
                }
                // Otherwise, just exit since we don't have to write out any parameters
                break;
            }
        }