P3D File Format - ODOLV7

Legend

see Generic FileFormat Data Types

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

ODOLV7
{
  StandardP3DHeader Header;
  LodStruct Lods[LodCount];
  float     Resolution[LodCount];
  struct    ModelInfo;
};

StandardP3DHeader

StandardP3DHeader
{
  char      Signature[4];      //"ODOL"
  ulong     Version;           // 7
  ulong     LodCount;          // at least one
}

LodStruct

LodStruct
{
 struct VerticesStruct;

 float[2]   UnknownFloat1;           // contains some max/min vertices positions
 XYZTriplet   MinPos;
 XYZTriplet   MaxPos;
 XYZTriplet   AutoCenterPos;
 float      UnknownFloat2;

 struct  TexturesStruct;
 
 structs TableStructs; 

 struct  FacesStruct;

 struct  LODSections;

 ulong          nNamedSelections;
 NamedSelection NamedSelections[nNamedSelections];
 ulong          nNamedProperties;
 NamedProperty  NamedProperties[nNamedProperties];
 ulong          nFrames;
 Frame          Frames[nFrames];
 
 ulong   Unknown[3];

 struct  ProxiStruct;
};

VerticesStruct

 VerticesStruct
 { 
   CompressedStruct PointFlags //(vertices)
   {
    ulong Count;              // see P3D Point(Vertex) Flags
    ulong PointFlag[Count];     
   }
   CompressedStruct UVset
   {
    ulong  Count;              // if > 127 then array is compressed 
    UVPair UVsets[Count];       
   }
   struct Points // (Vertices)
   {
    ulong      Count;              
    XYZTriplet Point[Count]; 
   }
   struct Normals
   {
    ulong Count;             
    float Normals[Count][3];  // XZY
   }
 }

• Count is the same value for all four tables.
• The Position and Normals tables appear to be always uncompressed raw data.

UVPair

UVSet
{
 float U,V;
}

TexturesStruct

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

Count corresponds to the number of concatenated strings. It is required, since, architecturally at least, one of more of the asciiz strings could be null.

TableStruct

struct TableStruct
{
 CompressedStruct 
 {
  ulong  Count;            // if > 511 etc  
  ushort MlodIndex[Count];
 }
 CompressedStruct
 {
  ulong  Count;           // this Count is same value as any Vertices.Count
  ushort OdolIndex[Count];// 
 }
}

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 = MlodIndex[ OdolIndex[ODOLvertexindex] ];

FacesStruct

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

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

LOD Sections

 LODSections
 {
  ulong  nSections;
  Sections[nSections]
  {
     ulong   FaceLowerIndex;
     ulong   FaceUpperIndex;
     ulong   UserValue;
     short   TextureIndex;      // -1 if not textured
     ulong   ODOL_FaceFlags; 
  };
 }

NamedSelection

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 IsSectional; 
 CompressedStruct UnknownUlong2
 {
  ulong Count;                    // if etc
  ulong Unknown[Count];
 }
 CompressedStruct Faces
 {
  ulong Count;                    // if etc
  ushort Faces[Count];
 }
 CompressedStruct TextureWeights      // probably
 {
  ulong Count;                    // if etc
  byte TextureWeights[Count];
 }
};

NamedProperty

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

Frame

   Frame
   {
     float FrameTime;
     ulong nBones;
     XYZTriplet [nBones];
   };

ProxiStruct

ProxiStruct
{
 ulong  Count;
 struct Proxi
 {
  asciiz Name;
  float rotationMatrix[9];
  float translation[3];
  ulong Index[2];
 }[Count];;
}

ModelInfo

ModelInfo
{
  ulong      Index;             // typically 02 01 00 00
  float      Pair[2];           // typically 48 74 07 3F  : 48 74 07 3F . pair is often the same
  XYZTriplet Unknown;           // typically 00 00 00 00 00 00 00 00 00 00 B0 0D 
  XYZTriplet offset;            // model offset (unknown functionality)
  ulong      mapIconColor;      // RGBA 32 color
  ulong      mapSelectedColor;  // RGBA 32 color
  ulong      unknownValue;
  XYZTriplet bboxMinPosition;   // minimum coordinates of bounding box
  XYZTriplet bboxMaxPosition;   // maximum coordinates of bounding box
  XYZTriplet wrpModelOffset;    // offset value to apply when object is placed on a WRP
  XYZTriplet offset2;           // another offset value (unknown functionality)
  XYZTriplet offset3;           // another offset value (unknown functionality)
  float      fArray[9];         // a mixture of floats and index values
  bytes      UnknownFlags[6];   // typically 01 00 00 01 00 16
  ulong      Count;
  float      Array[Count];      // potentially compressed
  float      Mass;
  XYZTriplet Unknown1;          // almost consistently  F9 02 15 50 : 00 00 48 43 : 0A D7 A3 3B
  XYZTriplet Unknown2;          // generally FF FF FF FF FF FF FF FF FF FF FF FF
}

LZ in ODOL

see Compressed LZSS File Format

Related Page(s)

Model File Formats