Ejemplo n.º 1
0
        public static State Read(EndianBinaryReader reader, Pointer offset, Family family)
        {
            MapLoader l = MapLoader.Loader;
            State     s = new State(offset, family);

            if (l.mode == MapLoader.Mode.Rayman3GC)
            {
                s.name = new string(reader.ReadChars(0x50)).TrimEnd('\0');
            }
            if (l.mode != MapLoader.Mode.RaymanArenaGC)
            {
                s.off_state_next = Pointer.Read(reader);
            }
            if (l.mode == MapLoader.Mode.Rayman3GC)
            {
                s.off_state_prev = Pointer.Read(reader);
                Pointer.Read(reader); // unknown offset, end of state array?
            }
            s.off_anim_ref = Pointer.Read(reader);
            s.off_state_transitions_first = Pointer.Read(reader);
            if (l.mode != MapLoader.Mode.RaymanArenaGC)
            {
                s.off_state_transitions_last = Pointer.Read(reader);                                         // same?
            }
            s.num_state_transitions = reader.ReadUInt32();
            reader.ReadUInt32();
            reader.ReadUInt32();
            if (l.mode != MapLoader.Mode.RaymanArenaGC)
            {
                reader.ReadUInt32();
            }
            s.off_state_auto = Pointer.Read(reader);
            Pointer.Read(reader); // fam end?
            if (l.mode != MapLoader.Mode.Rayman2PC)
            {
                s.off_cine_mapname = Pointer.Read(reader);
                s.off_cine_name    = Pointer.Read(reader);
            }
            reader.ReadByte();
            s.speed = reader.ReadByte();
            reader.ReadByte();
            reader.ReadByte();
            if (l.mode == MapLoader.Mode.Rayman2PC)
            {
                reader.ReadUInt32();
            }

            if (s.off_cine_mapname != null)
            {
                Pointer.Goto(ref reader, s.off_cine_mapname);
                s.cine_mapname = reader.ReadNullDelimitedString();
            }
            if (s.off_cine_name != null)
            {
                Pointer.Goto(ref reader, s.off_cine_name);
                s.cine_name = reader.ReadNullDelimitedString();
            }
            if (s.off_anim_ref != null)
            {
                Pointer.Goto(ref reader, s.off_anim_ref);
                s.anim_ref = AnimationReference.Read(reader, s.off_anim_ref);
            }

            return(s);
        }
Ejemplo n.º 2
0
        public static Family Read(EndianBinaryReader reader, Pointer offset)
        {
            MapLoader l = MapLoader.Loader;
            Family    f = new Family(offset);

            f.off_family_next  = Pointer.Read(reader);
            f.off_family_prev  = Pointer.Read(reader);
            f.off_family_unk   = Pointer.Read(reader); // at this offset, start and end pointers appear again
            f.family_index     = reader.ReadUInt32();
            f.name             = l.objectTypes[0][f.family_index].name;
            f.off_states_first = Pointer.Read(reader);
            if (l.mode != MapLoader.Mode.RaymanArenaGC)
            {
                f.off_states_last = Pointer.Read(reader);
            }
            f.num_states = reader.ReadUInt32();
            if (l.mode != MapLoader.Mode.Rayman2PC)
            {
                f.off_preloadAnim_first = Pointer.Read(reader); // (0x10 blocks: next, prev, list end, a3d pointer)
                if (l.mode != MapLoader.Mode.RaymanArenaGC)
                {
                    f.off_preloadAnim_last = Pointer.Read(reader);
                }
                f.num_preloadAnim = reader.ReadUInt32();
            }
            f.off_physical_list_default = Pointer.Read(reader); // Default objects table
            f.off_physical_list_first   = Pointer.Read(reader); // first physical list
            if (l.mode != MapLoader.Mode.RaymanArenaGC)
            {
                f.off_physical_list_last = Pointer.Read(reader);                                        // last physical list
            }
            f.num_physical_lists = reader.ReadUInt32();
            if (f.off_physical_list_first == f.off_physical_list_last && f.num_physical_lists > 1)
            {
                f.num_physical_lists = 1;                                                                                    // Correction for Rayman 2
            }
            f.off_bounding_volume = Pointer.Read(reader);
            if (l.mode == MapLoader.Mode.Rayman3GC || l.mode == MapLoader.Mode.Rayman3PC)
            {
                f.off_vector4s = Pointer.Read(reader);
                f.num_vector4s = reader.ReadUInt32();
                reader.ReadUInt32();
            }
            if (l.mode == MapLoader.Mode.Rayman2PC)
            {
                reader.ReadUInt32();
                f.animBank = reader.ReadByte();
                reader.ReadByte();
                reader.ReadByte();
                reader.ReadByte();
                f.properties = reader.ReadByte();
                reader.ReadByte();
                reader.ReadByte();
                reader.ReadByte();
            }
            else
            {
                reader.ReadUInt32();
                reader.ReadByte();
                reader.ReadByte();
                f.animBank   = reader.ReadByte();
                f.properties = reader.ReadByte();
            }

            f.states = new State[f.num_states];
            if (f.num_states > 0)
            {
                Pointer off_states_current = f.off_states_first;
                for (int i = 0; i < f.num_states; i++)
                {
                    Pointer.Goto(ref reader, off_states_current);
                    f.states[i] = State.Read(reader, off_states_current, f);
                    if (l.mode == MapLoader.Mode.RaymanArenaGC)
                    {
                        off_states_current = f.states[i].offset + 0x28;
                    }
                    else
                    {
                        off_states_current = f.states[i].off_state_next;
                    }
                }
            }

            f.off_physical_lists = new Pointer[f.num_physical_lists];          // Offset for each list of POs
            f.physical_objects   = new PhysicalObject[f.num_physical_lists][]; // Each list of POs. Each perso has zero/one of these lists and can switch between them.
            if (f.off_physical_list_first != null)
            {
                Pointer.Goto(ref reader, f.off_physical_list_first);
                for (uint i = 0; i < f.num_physical_lists; i++)
                {
                    f.off_physical_lists[i] = Pointer.Current(reader);
                    Pointer off_list_hdr_next = Pointer.Read(reader);
                    if (l.mode == MapLoader.Mode.Rayman3GC)
                    {
                        Pointer off_list_hdr_prev = Pointer.Read(reader);
                        Pointer off_list_hdr      = Pointer.Read(reader);
                    }
                    Pointer off_list_start = Pointer.Read(reader);
                    Pointer off_list_2     = Pointer.Read(reader); // is this a copy of the list or something?
                    ushort  num_entries    = reader.ReadUInt16();
                    reader.ReadUInt16();


                    /*// format of list_hdr:
                     * if (l.mode == MapLoader.Mode.Rayman3PC || l.mode == MapLoader.Mode.Rayman3GC) {
                     *  Pointer off_list_hdr_first = Pointer.Read(reader);
                     *  Pointer off_list_hdr_last = Pointer.Read(reader);
                     *  uint num_lists = reader.ReadUInt32(); // 1?
                     * }*/
                    if (off_list_start != null)
                    {
                        Pointer.Goto(ref reader, off_list_start);
                        f.physical_objects[i] = new PhysicalObject[num_entries];
                        for (uint j = 0; j < num_entries; j++)
                        {
                            // each entry is 0x14
                            Pointer off_po_scale = Pointer.Read(reader);
                            Pointer off_po       = Pointer.Read(reader);
                            reader.ReadUInt32();
                            reader.ReadUInt32();
                            uint lastvalue = reader.ReadUInt32();
                            if (lastvalue != 0 && off_po != null)
                            {
                                Pointer        curPos          = Pointer.Goto(ref reader, off_po);
                                PhysicalObject po              = PhysicalObject.Read(reader, off_po);
                                Vector3?       scaleMultiplier = null;
                                if (off_po_scale != null)
                                {
                                    Pointer.Goto(ref reader, off_po_scale);
                                    float x = reader.ReadSingle();
                                    float z = reader.ReadSingle();
                                    float y = reader.ReadSingle();
                                    scaleMultiplier = new Vector3(x, y, z);
                                }
                                if (po != null)
                                {
                                    f.physical_objects[i][j] = po;
                                    po.Gao.transform.parent  = f.Gao.transform;
                                    po.scaleMultiplier       = scaleMultiplier;
                                }
                                Pointer.Goto(ref reader, curPos);
                            }
                        }
                    }
                    if (off_list_hdr_next != null)
                    {
                        Pointer.Goto(ref reader, off_list_hdr_next);
                    }
                    else
                    {
                        break;
                    }
                }
            }

            /*if (l.mode == MapLoader.Mode.Rayman3GC) {
             *  Pointer off_list_hdr_next = Pointer.Read(reader);
             *  Pointer off_list_hdr_prev = Pointer.Read(reader);
             *  Pointer off_list_hdr = Pointer.Read(reader);
             *  //if (off_list_hdr != null) Pointer.Goto(ref reader, off_list_hdr);
             * } else if (l.mode == MapLoader.Mode.Rayman3PC || l.mode == MapLoader.Mode.RaymanArenaPC) {
             *  reader.ReadUInt32(); // 0
             * } else if (l.mode == MapLoader.Mode.Rayman2PC) {
             *  Pointer off_list_hdr = Pointer.Read(reader);
             *  //if (off_list_hdr != null) Pointer.Goto(ref reader, off_list_hdr);
             * }
             * if (l.mode == MapLoader.Mode.Rayman3PC || l.mode == MapLoader.Mode.Rayman3GC) {
             *  Pointer off_list_hdr_1 = Pointer.Read(reader); // copy of off_subblocklist?
             *  Pointer off_list_hdr_2 = Pointer.Read(reader); // same?
             *  reader.ReadUInt32(); // 1?
             * }*/
            return(f);
        }
Ejemplo n.º 3
0
        public static List <SuperObject> Read(EndianBinaryReader reader, Pointer off_so, bool parseSiblings = true, bool parseChildren = true, SuperObject parent = null)
        {
            MapLoader          l            = MapLoader.Loader;
            List <SuperObject> superObjects = new List <SuperObject>();

            if (IsParsed(off_so))
            {
                return(null);
            }
            bool isFirstNode    = true;
            bool hasNextBrother = false;
            bool isValidNode    = true;

            while (isFirstNode || (hasNextBrother && parseSiblings))
            {
                SuperObject so = new SuperObject(off_so);
                superObjects.Add(so);   // Local list of superobjects (only this & siblings)
                l.superObjects.Add(so); // Global list of superobjects (all)
                if (parent != null)
                {
                    parent.children.Add(so);
                    so.parent = parent;
                }
                hasNextBrother      = false;
                so.type             = reader.ReadUInt32();
                so.off_data         = Pointer.Read(reader);
                so.off_child_first  = Pointer.Read(reader);
                so.off_child_last   = Pointer.Read(reader);
                so.num_children     = reader.ReadUInt32();
                so.off_brother_next = Pointer.Read(reader);
                so.off_brother_prev = Pointer.Read(reader);
                so.off_parent       = Pointer.Read(reader);
                so.off_matrix       = Pointer.Read(reader);
                //R3Pointer.Read(reader); // a copy of the matrix right after, at least in R3GC
                Vector3    pos   = Vector3.zero;
                Vector3    scale = Vector3.one;
                Quaternion rot   = Quaternion.identity;
                if (so.off_matrix != null)
                {
                    Pointer curPos = Pointer.Goto(ref reader, so.off_matrix);
                    so.matrix = Matrix.Read(reader, so.off_matrix);
                    pos       = so.matrix.GetPosition(convertAxes: true);
                    rot       = so.matrix.GetRotation(convertAxes: true);
                    scale     = so.matrix.GetScale(convertAxes: true);
                    Pointer.Goto(ref reader, curPos);
                }
                switch (so.type)
                {
                case 0x20:     // IPO
                    Pointer.Goto(ref reader, so.off_data);
                    so.data = IPO.Read(reader, so.off_data, so);
                    break;

                case 0x40:     // IPO
                    l.print("IPO with code 0x40 at offset " + String.Format("0x{0:X}", so.offset.offset));
                    Pointer.Goto(ref reader, so.off_data);
                    so.data = IPO.Read(reader, so.off_data, so);
                    break;

                case 0x02:     // e.o.
                    Pointer.Goto(ref reader, so.off_data);
                    so.data = Perso.Read(reader, so.off_data, so);
                    break;

                case 0x01:     // world superobject
                    so.data = World.New(so);
                    //print("parsing world superobject with " + num_children + " children");
                    break;

                case 0x04:     // sector
                    Pointer.Goto(ref reader, so.off_data);
                    so.data = Sector.Read(reader, so.off_data, so);
                    break;

                default:
                    l.print("Unknown SO type " + so.type + " at offset " + String.Format("0x{0:X}", so.offset.offset));
                    isValidNode = false;
                    break;
                }
                if (so.Gao != null)
                {
                    if (parent != null)
                    {
                        so.Gao.transform.parent = parent.Gao.transform;
                    }
                    so.Gao.transform.localPosition = pos;
                    so.Gao.transform.localRotation = rot;
                    so.Gao.transform.localScale    = scale;
                }
                isFirstNode = false;
                if (isValidNode)
                {
                    if (parseChildren && so.num_children > 0 && so.off_child_first != null)
                    {
                        //if (type == 0x01) print("parsing children now");
                        Pointer off_current = Pointer.Goto(ref reader, so.off_child_first);
                        SuperObject.Read(reader, so.off_child_first, true, true, so);
                        //R3Pointer.Goto(ref reader, off_current);
                    }
                    if (so.off_brother_next != null && !IsParsed(so.off_brother_next))
                    {
                        hasNextBrother = true;
                        Pointer.Goto(ref reader, so.off_brother_next);
                        off_so = so.off_brother_next;
                    }
                }
            }
            return(superObjects);
        }
Ejemplo n.º 4
0
        public static VisualMaterial Read(EndianBinaryReader reader, Pointer offset)
        {
            MapLoader      l = MapLoader.Loader;
            VisualMaterial m = new VisualMaterial(offset);

            // Material struct = 0x188
            m.flags        = reader.ReadUInt32();
            m.ambientCoef  = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
            m.diffuseCoef  = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
            m.specularCoef = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
            m.color        = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
            reader.ReadUInt32(); // some specular parameter
            if (l.mode == MapLoader.Mode.Rayman2PC)
            {
                Pointer off_texture = Pointer.Read(reader);
                //Pointer off_texture2 = Pointer.Read(reader);
                int type_texture = reader.ReadInt32();
                m.off_textures.Add(off_texture);
                m.textureTypes.Add(type_texture);
            }
            else
            {
                Pointer off_animTextures = Pointer.Read(reader);
                reader.ReadUInt32(); // a repeat of last offset?
                ushort num_animTextures = reader.ReadUInt16();
                reader.ReadUInt16();
                reader.ReadUInt32();
                reader.ReadByte();
                reader.ReadByte();
                m.properties = reader.ReadByte();
                reader.ReadByte();
                reader.ReadUInt32();
                reader.ReadUInt32();
                reader.ReadUInt32();
                Pointer off_texture1 = Pointer.Read(reader);
                reader.ReadByte();
                reader.ReadByte();
                reader.ReadByte();
                reader.ReadByte();
                int type_texture1 = reader.ReadInt32();
                reader.ReadBytes(0x3C);
                Pointer off_texture2 = Pointer.Read(reader);
                reader.ReadByte();
                reader.ReadByte();
                reader.ReadByte();
                reader.ReadByte();
                int  type_texture2 = reader.ReadInt32();
                uint num_textures  = 0;
                if (off_texture1 != null)
                {
                    m.off_textures.Add(off_texture1);
                    m.textureTypes.Add(type_texture1);
                }
                if (off_texture2 != null)
                {
                    m.off_textures.Add(off_texture2);
                    m.textureTypes.Add(type_texture2);
                }

                /*if (off_texture2 != null) num_textures++;
                 * R3Pointer[] off_textures = new R3Pointer[num_textures];
                 * int[] textureTypes = new int[num_textures];
                 * if (off_texture1 != null) {
                 *  off_textures[0] = off_texture1;
                 *  textureTypes[0] = type_texture1;
                 * }
                 * if (off_texture2 != null) {
                 *  off_textures[num_textures - 1] = off_texture2;
                 *  textureTypes[num_textures - 1] = type_texture2;
                 * }*/

                /*uint num_textures = Math.Min(reader.ReadUInt32(), 2);
                 * R3Pointer[] off_textures = new R3Pointer[num_textures];
                 * int[] textureTypes = new int[num_textures];
                 * for (uint i = 0; i < num_textures; i++) {
                 *  off_textures[i] = R3Pointer.Read(reader);
                 *  reader.ReadByte();
                 *  reader.ReadByte();
                 *  reader.ReadByte();
                 *  reader.ReadByte();
                 *  textureTypes[i] = reader.ReadInt32();
                 *  if (num_textures > i + 1) reader.ReadBytes(0x3C);
                 * }*/
                if (num_animTextures > 0 && off_animTextures != null)
                {
                    Pointer.Goto(ref reader, off_animTextures);
                    for (int i = 0; i < num_animTextures; i++)
                    {
                        Pointer off_animTexture = Pointer.Read(reader);
                        m.off_animTextures.Add(off_animTexture);
                        reader.ReadUInt32();
                        Pointer off_nextAnimTexture = Pointer.Read(reader);
                        if (off_nextAnimTexture != null)
                        {
                            Pointer.Goto(ref reader, off_nextAnimTexture);
                        }
                    }
                }
            }

            return(m);
        }
Ejemplo n.º 5
0
        public static LightInfo Read(EndianBinaryReader reader, Pointer offset)
        {
            MapLoader lo          = MapLoader.Loader;
            LightInfo parsedLight = lo.lights.FirstOrDefault(li => li.offset == offset);

            if (parsedLight != null)
            {
                return(parsedLight);
            }
            //lo.print("Light offset; " + offset);

            /* For Rayman 3:
             * light struct sz = 0x110
             * transformation matrix starts at 0x34 and is 0x50 long
             * color is at + 156(decimal) or 0x9c and is 4x 4 bytes, but it's out of range?
             * can be negative to create shadows maybe?
             * at + 252(or 0xfc) is another color
             * perso also has light sometimes (at offset + 28)*/

            /* For R2:
             * 0x160 size
             * example: astro_00 @ 1d30c
             */
            LightInfo l = new LightInfo(offset);

            l.turnedOn    = reader.ReadByte();
            l.castShadows = reader.ReadByte();
            l.giroPhare   = reader.ReadByte();
            l.pulse       = reader.ReadByte();
            reader.ReadUInt32();
            l.type = reader.ReadUInt16();
            reader.ReadUInt16();
            l.far         = reader.ReadSingle();
            l.near        = reader.ReadSingle();
            l.littleAlpha = reader.ReadSingle();
            l.bigAlpha    = reader.ReadSingle();
            l.giroStep    = reader.ReadSingle();
            l.pulseStep   = reader.ReadSingle();
            if (lo.mode != MapLoader.Mode.Rayman2PC)
            {
                l.pulseMaxRange = reader.ReadSingle();
                l.giroAngle     = reader.ReadSingle();
                reader.ReadSingle();
            }
            l.transMatrix = Matrix.Read(reader, Pointer.Current(reader));
            reader.ReadUInt32(); // 0
            reader.ReadUInt32(); // 0
            reader.ReadUInt32(); // 0
            reader.ReadUInt32(); // 0
            reader.ReadUInt32(); // 0
            reader.ReadUInt32(); // 0
            l.color = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
            if (lo.mode != MapLoader.Mode.Rayman2PC)
            {
                l.shadowIntensity = reader.ReadSingle(); // 0
            }
            reader.ReadByte();
            reader.ReadByte();
            l.paintingLightFlag = reader.ReadByte();
            l.alphaLightFlag    = reader.ReadByte();
            l.interMinPos       = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
            l.exterMinPos       = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
            l.interMaxPos       = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
            l.exterMaxPos       = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
            reader.ReadUInt32();
            reader.ReadUInt32();
            reader.ReadUInt32();
            l.attFactor3          = reader.ReadSingle();
            l.intensityMin        = reader.ReadSingle();
            l.intensityMax        = reader.ReadSingle();
            l.background_color    = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
            l.createsShadowsOrNot = reader.ReadUInt32();

            lo.lights.Add(l);
            return(l);
        }