I've wanted to get my hands on rigged/animated models from Elite Dangerous, but there's basically no info out there on how to do it.

Here's what I currently know based on some crappy python code written by an AI:

-the data.ovx file in the game's root folder is composed of hex characters in 168-character lines.
-the first 40 characters of each line corresponds to the exact name of a file within one of the folders labeled 00 through 0f
-when opened in notepad++, many of the game files (none of which have extensions) start with "FREA"
-the files use some kind of zlib compression
-the files don't appear to be encrypted

Attached is data.ovx as well as a small portion of the files on the 0f folder.

filestoworkon.zip

The FREA sign files are compressed with unknown algo. Some of them are zlibed. But no compressed/decompressed size. But i think zlib_noerror can do the thing.

EDiT: Most of zlibed files are textures. But... there is only texture size, no width/height.

Edited Wednesday at 07:46 PM2 days by h3x3r

10 hours ago, h3x3r said:

The FREA sign files are compressed with unknown algo. Some of them are zlibed. But no compressed/decompressed size. But i think zlib_noerror can do the thing.

EDiT: Most of zlibed files are textures. But... there is only texture size, no width/height.

Has anyone published BMS scripts or github repos that might be relevant?

It's a MMO don't expect to be an easy. There are many tools but none of em are for models/textures.

Also those files has no TOC. So it must be somewhere in another files.

I can write decompressor for zlibed files, but that's it.

13 hours ago, h3x3r said:

It's a MMO don't expect to be an easy. There are many tools but none of em are for models/textures.

Also those files has no TOC. So it must be somewhere in another files.

I can write decompressor for zlibed files, but that's it.

Any insight on which file might contain the TOC? Could it potentially be data.ovx?

No *.ovx are just strings. Not sure if file names. But it doesn't store any info about offset/size.

BTW i came across model files. Those who are compressed with zlib. But can't decode vertices. My bet is they are converted with modifier value. Indices are triangles.

Stride 40. Data type unknown.

Here's my guesswork on mesh.

//------------------------------------------------
//--- 010 Editor v14.0 Binary Template
//
//      File: 
//   Authors: 
//   Version: 
//   Purpose: 
//  Category: 
// File Mask: 
//  ID Bytes: 
//   History: 
//------------------------------------------------
LittleEndian(); OutputPaneClear();

local string FileName=GetFileName(),FilePath=FileNameGetPath(FileName,true),BaseName=FileNameGetBase(FileName,false),ShapeNum;
local uint32 i,j,k,l;


struct
{
    uint32 Sign;
    uint32 Unknown_0;
    uint32 Unknown_1;
    uint32 PadSize;
    uint32 Unknown_2;
    uint32 Checksum32LE<format=hex>;
    uint32 MeshCount;
    uint32 Unknown_3;
    uint32 Unknown_4;
    
    struct
    {
        uint32 Unknown_0;
        uint32 Unknown_1;
        uint32 Unknown_2;
        uint32 Unknown_3;
        uint32 IndexInfoSize; // / 24
        uint32 Unknown_5;
        uint32 BuffersSize;
        uint32 Unknown_6;
        local uint32 ShapeCount = IndexInfoSize / 24;
        //Printf("%u\n",ShapeCount);
    }BufferDefinition[MeshCount]<optimize=false>;
    
    struct
    {
        uint32 Unknown_0;
        uint32 MeshSize;
    }MeshDefinition[MeshCount];
    
    struct
    {
        uint32 Unknown_0;
        uint32 Unknown_1;
        uint32 Unknown_2;
        uint32 DefinitionOffset;
    }UnknownDefinition[MeshCount];
    
    uint32 Unknown_5;
    uint32 Unknown_6;
    float Unknown_7;
    ubyte Unknown_8[4];
    byte Pad[PadSize];
    
    local uint32 DataBaseOffset=FTell();
}Main;

for (i=0; i < Main.MeshCount; i++) // Main.MeshCount
{
    struct
    {
        for (j=0; j < Main.BufferDefinition[i].ShapeCount; j++)
        {
            struct
            {
                uint32 IndexCount; // * 3
                uint32 Unknown_0;
                uint32 ElementCount;
                uint32 Unknown_1;
                uint32 Unknown_2;
                uint32 Unknown_3;
            }ShapeDefinition;
        }
        
        for (j=0; j < Main.BufferDefinition[i].ShapeCount; j++)
        {
            struct
            {
                for (k=0; k < ShapeDefinition[j].IndexCount; k++)
                {
                    struct
                    {
                        local uint32 AlignCheck=ReadUInt(FTell());
                        if (AlignCheck == 0)
                            FSkip(2);
                            
                        uint16 F1,F2,F3;
                    }Indices;
                }
            }IndexBuffer;
        }
        
        for (j=0; j < Main.BufferDefinition[i].ShapeCount; j++)
        {
            struct
            {
                for (k=0; k < ShapeDefinition[j].ElementCount; k++)
                {
                    struct
                    {
                        local uint32 AlignCheck=ReadUShort(FTell());
                        if (AlignCheck == 0)
                            FSkip(2);
                        int16 Unk0,Unk1,Unk2,Unk3,Unk4,Unk5,Unk6,Unk7,Unk8,Unk9;
                        int16 Unk10,Unk11,Unk12,Unk13,Unk14,Unk15,Unk16,Unk17,Unk18,Unk19;
                    }Elements;
                }
            }ElementBuffer;
        }
        FSeek(startof(Mesh[i]));
        FSkip(Main.MeshDefinition[i].MeshSize);
    }Mesh;
}

Face indices are aligned to 8 bytes I guess.

f00a489891175ce37bca1bf68c2302fb758e038a_dec.7z

Edited 7 hours ago7 hr by h3x3r