P3D File Format - ODOLV7

Legend

byte:     8 bits unsigned
char:     8 bit ascii character
char[]:   fixed length string
asciiz:   null terminated char string
asciiz... concatetaned asciiz strings
asciiz[]: fixed length and null terminated anyway
ulong:    unsigned integer 32bit. 4 bytes
ushort:   unsigned integer 16bit 2 bytes
short:    signed integer 16bit 2 bytes
float:    4 bytes

Intro

CompressedStruct

ODOL7 uses (potentially) compressed arrays.

This obviously slows the engine down during loading. At the time of CWC development, game file sizes were important.

(potentially) compressed arrays are contained in a CompressedStruct

CompressedStructs are endemic to most blocks contained in the p3d.

CompressedStruct
{
  ulong  Count;
  <type> Array[Count];
};

if Count * sizeof(<type>) exceeds 1023 bytes the array is compressed. The resulting array will be expanded using lzh compression exactly as found in pbo's (for instance)

After de-compression, the Count remains the same because it is a count of the arraytype.

For uncompressed arrays (byte count < 1024) the Count and data are treated 'as is'.

Thus for various Array <types>

*ulong Array:    > 255  // 1024 /   sizeof(ulong)
*float thing[2]: > 127  // 1024 / 2*sizeof(float)
*SomeStructure:  >      // count * sizeof (SomeStructure) > 1023

Note that potentially compressed arrays in these structures only have an known output length. the decompressor therefore must work on infinite input length. see example decompression at end of document

Odol7Stuct

struct ODOL
{
  char      Signature[4];      //"ODOL"
  ulong     Version;           // 7
  ulong     LodCount;          // at least one
  LodStruct Lod[LodCount];
  ulong     ResolutionCount;   // same as LodCount
  float     Resolution[ResolutionCount];
  byte      unknownBytes[24];
  float     offset[3];         // model offset (unknown functionality)
  ulong     mapIconColor;      // RGBA 32 color
  ulong     mapSelectedColor;  // RGBA 32 color
  ulong     unknownValue;
  float     bboxMinPosition[3]; // minimum coordinates of bounding box
  float     bboxMaxPosition[3]; // maximum coordinates of bounding box
  float     wrpModelOffset[3];  // offset value to apply when object is placed on a WRP
  float     offset2[3];         // another offset value (unknown functionality)
};

LodStruct

LodStruct
{
 CompressedStructs VerticesStruct[...];

 float             Unkown[12];          // contains some max/min vertices positions

 CompressedStructs  TexturesStruct[...];
 
 CompressedStructs TableStruct[...];

 CompressedStructs FacesStruct[...];

 CompressedStruct  UnknownStructOne[...];

 CompressedStructs NamedStruct[...];
 
 CompressedStruct UnknownStructTwo[...];

 CompressedStruct ProxiStruct[...];

};

VerticesStruct

 VerticesStruct
 { 
   CompressedStruct Attribs
   {
    ulong Count;
    ulong Attribs[Count];     // if > 255 then array is compressed 
   }
   CompressedStruct UVset
   {
    ulong Count;              // again same value
    float UVset[Count];       // if > 127 then array is compressed 
   }
   CompressedStruct Position
   {
    ulong Count;              // again same value
    float Position[Count][3]; // XZY.  If > etc
   }
   CompressedStruct Normals
   {
    ulong Count;              // again same value
    float Normals[Count][3];  // XZY. If > etc
   }
 }

TexturesStruct

 CompressedStruct Textures
 {
  ulong  Count;
  asciiz Textures[...];          // "data/1.paa\0data/2.paa\0"...
 }

Note: the Count corresponds to the number of concatenated asciiz strings. However, it's primary use is to determine whether this is a compressed array or not Since the count * sizeof(byte) is unlikely to ever exceed 1023 ! compression is not a factor. The structure however, is endemic to the way the engine decodes these blocks.

TableStruct

struct TableStruct
{
 CompressedStruct Table1
 {
  ulong  Count;
  ushort Table1[Count];// if > 511 array compressed   
 }
 CompressedStruct Table2
 {
  ulong  Count;        // this Count is same value as any Vertices.Count
  ushort Table2[Count];// > 511 then array is compressed 
 }
}

Tables are used to join vertices. Each face has got 3 or 4 vertices that are unique for each face Eg. Every vertex is owned only by 1 face.

MLODvertexindex = Table1[ Table2[ODOLvertexindex] ];

UnkownStructOne

 CompressedStruct
 {
  ulong  Count;
  byte   Unknown[Count][18];
 }

NamedStruct

NamedStruct
{
 CompressedStruct Selection
 {
  ulong  Count;
  struct NamedSelection[Count];
 }
 CompressedStruct Properties
 {
  ulong  Count;
  struct NamedPropeties[Count]
 }
}

NamedSelection

struct NamedSelection
{
 asciiz name;
 CompressedStruct Vertices
 {
  ulong  Count;                  // if > 511 then array is compressed
  ushort Vertices[Count];
 }
 CompressedStruct UnknownUshort
 {
  ulong   Count;                 // if > 511 then array is compressed
  ushort  Unknown[Count];
 }
 CompressedStruct UnknownUlong
 {
  ulong Count;                    // if > 255 then array is compressed
  ulong Unknown[Count];
 }
 byte Unknown; 
 CompressedStruct UnknownUlong2
 {
  ulong Count;                    // if etc
  ulong Unknown[Count];
 }
 CompressedStruct Faces
 {
  ulong Count;                    // if etc
  ushort Faces[Count];
 }
 CompressedStruct UnknownByte
 {
  ulong Count;                    // if etc
  byte Unknown[Count];
 }
};

NamedPropeties

struct NamedPropeties
{
  asciiz Name;  // "noshadow\0"
  asciiz Value; //"1\0"'
};

UnkownStructTwo

CompressedStruct
{
 ulong  Count;
 struct ustruct[Count]; 
}

FacesStruct

struct Faces
{
 ulong  FacesCount;
 ulong  unknown;
              FaceStruct[FacesCount];
}

FaceStruct

struct Face
{
 ulong  Attribs;
 short  TextureIndex; 
 byte   Count;  // always 3 or 4
 ushort VerticesIndex[4];
};

The TextureIndex is a zero based array. If set to -1, there are no textures for this face.

There are *always* 4 ushort indices allocated. Either 3, or 4 are used.

Proxi

  struct Proxi
    {
      char Name[...] // zero ended  string
      float rotationMatrix[9];
      float translation[3];
    };

ustruct

  struct ustruct // unknown value
    {
      uint uvalue8;// unknown value
      uint uvalue9;// unknown value
      char uarray[12*uvalue9];// unknown value :-( i know nothing about it
    };

LZ in ODOL

Lempel-Ziv compression

Note1.

Regardless of method, 4 extra bytes representing the checksum exist at end of the data count.

Note2. The compression code is identical to that employed by pbo packed structures. However, unlike pbo's, the size of the compressed data is unknown, only it's ultimate length. The code below fudges it.

pascal code

function LZBlockRead(var F:file; var outdata:array of byte;szout:integer):byte;
var
k, r, pr, pi,po,i,j:integer;
flags:word;
buf:array[0..$100e] of byte;
c:byte;
crc:integer;
begin
po:=0;
pi:=0;
flags:=0;
r:=0;
for k := 0 to $100F-1 do buf[k] := $20;
       while (po < szout) do
        begin
           flags:= flags shr 1;
           if ((flags and $100)= 0) then
               begin
                 BlockRead(F,c,1);   // direct reading from file
                 inc(pi);
                 flags := c or $ff00;
               end;
           if (flags and 1)=1 then
                begin
                  if (po >= szout)then break;
                  BlockRead(F,c,1);   // direct reading from file
                  inc(pi);
                  outdata[po] := c;
                  inc(po);
                  buf[r] := c;
                  inc(r);
                  r :=r and $fff;
                end
           else
                begin
                  i:=0;
                  BlockRead(F,i,1);  // direct reading from file
                  inc(pi);
                  j:=0;
                  BlockRead(F,j,1); // direct reading from file
                  inc(pi);
                  i :=i or ((j and $f0) shl 4);
                  j := (j and $0f) + 2;
                  pr := r;
                  for k := 0 to j do
                    begin
                      c := buf[(pr - i + k) and $fff];
                      if (po >= szout) then break;
                      outdata[po]:= c;
                      inc(po);
                      buf[r]:= c;
                      inc(r);
                      r :=r and $fff;
                    end;
             end;
       end;
     BlockRead(F,crc,4);   // 4 byte checksum.
     result:= pi;
end;

C code

int Decode(unsigned char *in,unsigned char *out,int szin,int szout)
{
       szin = szin > 0? szin: 0x7fffffff;
       int  i, j, k, r = 0, pr, pi = 0,po = 0;
       unsigned int  flags = 0;
       unsigned char buf[0x100F], c;
       for (i = 0; i < 0x100F; buf[i] = 0x20, i++);
       while (pi < szin && po < szout)
       {
               if (((flags >>= 1) & 256) == 0)
               {
                       if(pi >= szin)break;
                       c = in[pi++];
                       flags = c | 0xff00;
               }
               if (flags & 1)
               {
                       if(pi >= szin || po >= szout)break;
                       c = in[pi++];
                       out[po++] = c;
                       buf[r++] = c;
                       r &= 0xfff;
               } else
               {
                       if(pi + 1 >= szin)break;
                       i = in[pi++];
                       j = in[pi++];
                       i |= (j & 0xf0) << 4;
                       j  = (j & 0x0f) + 2;
                       pr = r;
                        for (k = 0; k <= j; k++)
                       {
                               c = buf[(pr - i + k) & 0xfff];
                               if(po >= szout)break;
                               out[po++] = c;
                               buf[r++] = c;
                               r &= 0xfff;
                       }
               }
       }
       return pi;// next 4 bytes = checksum
}

Related Page(s)

Model File Formats