ODOL v40 File Format
From Bohemia Interactive Community
| Disclaimer: This page describes an internal undocumented structures of Bohemia Interactive software.
|
| This page contains unofficial information.
Some usage of this information may be violating rights of Bohemia Interactive and is in no way endorsed or recommended by Bohemia Interactive and Bohemia Interactive is not willing to tolerate use of such tools if it contravenes any general licenses granted to end users of this community wiki or BI products. |
Introduction
The general file format of a ArmA ODOL v40 p3d model file is similar to the ODOL v7 format. The major differences are that in ArmA models there is now included (but not always) a model.cfg and the resolutions are ordered in the file in reverse numerical order.
The order of resolutions denoted in the header portion of the file is not necessarily the numerical order of the resolutions. (often the 11,000 resolution is the last in the header array) The header resolutions need to be sorted in descending order. The resultant sorted array of resolutions is the order in which they appear in the file.
NOTE:- As at Aug, 13th 2007, this file format is not conclusive and final. It may or may not fit the actual model file format of an Armed Assault ODOL v40 p3d model.
Legend
| Type | Description |
|---|---|
| byte | 8 bit (1 byte) |
| ushort | 16 bit unsigned short (2 bytes) |
| int | 32 bit signed integer (4 bytes) |
| float | 32 bit signed single precision floating point value (4 bytes) |
| asciiz | Null terminated (0x00) variable length ascii string |
File Format
The following is a mix of pseudo-code and structure references that could be used to discribe the file format of ODOL v40. It may or may not be accurate but has do date been used to read ODOL v40 is some cases without manual intervention. As at the writing of this article in most cases though, manual intervention is required to complete navigation throughout the given p3d file as there is some unkonwn data that prevents continuous processing.
Simple
ODOLv40
{
Header;
Model.cfg; (optional)
Resolutions; (reverse numerical order)
}
Detailed
ODOLv40
{
structP3DHeader Header;
byte[155] Unknown;
structSkeleton Skeleton;
byte unknown1;
byte unknown2;
if(unknown2== 0x00)
{
byte[31] byteArrayUnknown1;
}
else
{
byte[32] byteArrayUnknown1;
}
int unknown4;
byte unknown5;
asciiz ModelString1;
asciiz ModelString2;
byte[5] byteArrayUnknown2;
byte AnimsExist;
if (AnimsExist == 0x01)
{
int NoOfAnimSelections;
structAnimation[NoOfAnimSelections] Animations;
//Basically... for each bone there is a list of Animations and this array structure
// is stored on a per resolution basis.
int NoOfResolutions;
for(int i=0; i<NoOfResolutions; i++)
{
int NoOfBones;
for(int ii=0; ii<NoOfResolutions; ii++)
{
int NoOfAnims;
if (NoOfAnims > 0)
{
for(int iii=0; iii<NoOfAnims; iii++)
{
int Animation;
}
}
}
}
//Unknown Anim info...
//Basically... for each Animation if the TransformType !=9 then there
// is a 6 x float of positional info.
for(int i=0; i<NoOfResolutions; i++)
{
int Anim;
if (Anim != -1)
{
if (Animations[Anim].TransformType != 9)
{
float[6] UnknownAnimInfo;
}
}
}
}//AnimExist
byte[Header.NoOfResolutions * 8] Unknown8;
bool[Header.NoOfResolutions] ResolutionFaceIndicator;
//Basically...For each Resolution if the LODFaceIndicator is true
//there is a int FaceCount + 13 bytes
//I think this 'indicator' may serve other areas but at the very least it indicates
//the following structure
for (int i = 0; i < Header.NoOfResolutions; i++)
{
if (LODFaceIndicator[i])
{
int HeaderFaceCount;
byte[13] Unknown9;
}
}
int NoOfModelProxies;
if (NoOfModelProxies != 0)
{
structProxy[NoOfModelProxies] ModelProxies;
}
structResolution[Header.NoOfResolutions]; //Note:- Remember, the order in which lod's
// occur is descending numerical order.
// eg. Resolution 1.0 will be the last in
// the file.
//EndOfFile
}
Structures
structP3DHeader
struct structP3DHeader
{
asciiz Filetype; //eg. ODOL
int Version; //eg. 0x2800 0000 = 40
int NoOfResolutions;
float[NoOfResolutions] HeaderResolutions;
}
structBone
structBone
{
asciiz Bone;
asciiz Parent;
}
structSkeleton
structSkeleton
{
asciiz SkeletonName;
if (SkeletonName != null)
{
byte isInherited; // 0x00=false, 0x01=true
int NoOfBones;
structBone[NoOfBones] Bones;
}
}
structAnimation
structAnimation
{
int AnimTransformType;
asciiz AnimSelection;
asciiz AnimSource;
if (AnimTransformType == 9)
{
float[6] Transforms;
}
else
{
float[7] Transforms;
}
}
structProxy
structProxy
{
asciiz ProxyName;
float[12] ModelProxyUnknown1;
int[4] ModelProxyUnknown2;
}
structStage
structStage
{
asciiz StageTexture;
int Stage;
int UVSource;
float[3] aside;
float[3] up;
float[3] dir;
float[3] pos;
}
structMaterial
structMaterial
{
asciiz Material;
float[4] Emissive;
float[4] Ambient;
float[4] Diffuse;
float[4] forcedDiffuse;
float[4] Specular;
float SpecularPower;
int PixelShaderId;
int VertexShaderId;
structStage[] Stages;
}
//Basically... A direct replication of the information in the given .rvmat file
for (int i = 0; i < NoOfMaterials; i++)
{
asciiz Material;
byte[4] byteArrayMaterialUnknown1;
float[4] Emissive;
float[4] Ambient;
float[4] Diffuse;
float[4] forcedDiffuse;
float[4] Specular;
float SpecularPower;
int PixelShaderId; //See enumPixelShaderId
int VertexShaderId; //See enumVertexShaderId
//Based on the enumPixelShaderId that matches this PixelShaderId process a variable 'NoOfStages'
//by default one should probably process 2 stages as this seems the most common amount
if (NoOfStages > 0)
{
byte[34] byteArrayMaterialUnknown2;
for (int i = 0; i < NoOfStages; i++)
{
byte[4] byteArrayMaterialUnknown3;
asciiz StageTexture;
int StageNumber;
}
for (int i = 0; i < NoOfStages; i++)
{
int UVSource;
float[3] aside;
float[3] up;
float[3] dir;
float[3] pos;
}
byte[52] byteArrayMaterialUnknown4; //Possibly default values for a stage as same struct size
}
else
{
byte[86] byteArrayMaterialUnknown5;
}
}//EndOfMaterials
structPolygons
structPolygons
{
byte NoOfVertices; // 3 or 4
ushort[NoOfVertices] VerticesIndex; // 0-based index into Vertices Arrays
}
structComponent
structComponent
{
asciiz ComponentName;
//Selected Faces
int NoOfSelectedFaces;
ushort[NoOfSelectedFaces] SelectedFaceIndexes;
int intComponentUnknown1;
bool bComponentUnknown1;
if (bComponentUnknown1)
{
int NoOf;
int[NoOf] intArrayComponentUnknown1;
}
else
{
int intComponentUnknown2;
}
// Selected Vertices
int NoOfSelectedVertices;
ushort[NoOfSelectedVertices] SelectedVerticesIndexes; // Zero based array of index values into
// the array of Vertices.
// Note:- If expectedSize >= 1024 bytes this array is
compressed.
// Selected Vertices Properties
int NoOfSelectedVertices;
byte[NoOfSelectedVertices] SelectedVerticesProperties; // Zero based array of index values into
// the array of Vertices.
// Note:- If expectedSize >= 1024 bytes this array is
compressed.
}
structProperties
structProperties
{
asciiz Property;
asciiz Value;
}
structUV
structUV
{
float u;
float v;
}
structVerticesPosition
structVerticesPosition
{
float x;
float z;
float y;
}
structVerticesNormal
structVerticesNormal
{
float x;
float z;
float y;
}
structVerticesMinMax
structVerticesMinMax
{
float x1;
float z1;
float y1;
float x2;
float z2;
float y2;
}
structVerticesUnknown1
structVerticesUnknown1
{
ushort One;
ushort Two;
ushort Three;
ushort Four;
ushort Five;
ushort Six;
}
structResolution (simple)
structResolution
{
NoOfVertices;
<space>
NoOfTextures;
Textures;
NoOfMaterials;
Materials;
<space>
NoOfPolygons;
<space>
Polygons;
<space>
NoOfComponents;
Components;
NoOfProperties;
Properties;
<space>
NoOfVertices;
VerticesUVSet1;
NoOfVertices;
VerticesUVSet2;
NoOfVertices;
VerticesPositions;
NoOfVertices;
VerticesNormals;
NoOfVertices;
VerticesMinMax; //Looks like Min/Max info.
NoOfVertices;
VerticesUnknown1; //Looks like per vertex properties
NoOfVertices;
VerticesUnknown2; //hmmmm...
if(pointer<filesize)
{
NoOfProxies;
Proxies;
<space>
}
NoOf;
IntermittentUnknownData; // As at article date 12-Aug-2007. This data is not in every lod
// it is intermittent. Currently, structure is unknown.
// Can be bypassed by manual intervention to start of next resolution.
// Most likely is Texture-2-Face/Vertex mappings.
//This is a 'show-stopper' for continuous processing.
}
structResolution (detailed)
structResolution
{
int NoOfVertices;
byte byteResUnknown1;
byte byteResUnknown2;
switch (byteResUnknown2)
{
case 0x00: { byte[40] byteArrayResUnknown1; break; }
case 0x20: { byte[45] byteArrayResUnknown1; break; }
case 0x30: { byte[45] byteArrayResUnknown1; break; }
case 0xFF: { byte[45] byteArrayResUnknown1; break; }
case 0x3F: { byte[51] byteArrayResUnknown1; break; }
}
int NoOfTextures;
asciiz[NoOfTextures] Textures;
int NoOfMaterials;
structMaterial[NoOfMaterials] Materials;
byte[8] byteArrayResUnknown2;
int NoOfPolygons;
byte[6] byteArrayResUnknown3;
structPolygons[NoOfPolygons] Polygons;
//Model 'Section' Info. Unknown structure, however this code snippet iterates over it
int NoOfSections;
for (int i = 0; i < NoOfSections; i++)
{
byte[26] byteArrayResUnknown4;
byte byteResUnknown3;
if (byteResUnknown3 == 0xFF)
{
byte[16] byteArrayResUnknown5;
}
else
{
byte[15] byteArrayResUnknown5;
}
}//EndOf Model 'Section' info. structure
int NoOfComponents;
structComponent[NoOfComponents] Components;
int NoOfProperties;
structProperties[NoOfProperties] Properties;
ushort usUnknown1;
ushort usUnknown2;
if (usUnknown2 == 0)
{
byte[17] byteArrayResUnknown6;
}
else
{
byte[15] byteArrayResUnknown6;
}
int NoOfVertices;
byte bUV
if (bUV == 0x00)
{
structUV[NoOfVertices2ndUV] VerticesUVSet1; // Note:- If expectedSize >= 1024 bytes this array is
compressed.
int NoOfVertices2ndUV;
}
else
{
byte[12] byteArrayResUnknown7;
}
if (NoOfVertices2ndUV == 2)
{
int NoOfVertices2ndUV;
byte bUV;
if (bUV == 0x00)
{
structUV[NoOfVertices2ndUV] VerticesUVSet2; // Note:- If expectedSize >= 1024 bytes this array is
compressed.
}
else
{
byte[8] byteArrayResUnknown8;
}
}
int NoOfVertices;
structVerticesPosition[NoOfVertices] VerticesPositions; // Note:- If expectedSize >= 1024 bytes this array is
compressed.
int NoOfVertices;
byte bNormal;
if (bNormal == 0x00)
{
structVerticesNormal[NoOfVertices] VerticesNormals; // Note:- If expectedSize >= 1024 bytes this array is
} compressed.
else
{
byte[12] byteArrayResUnknown9;
}
int NoOfVertices;
if (NoOfVertices != 0)
{
structVerticesMinMax[NoOfVertices] VerticesMinMax; // Note:- If expectedSize >= 1024 bytes this array is
} compressed.
int NoOfVertices;
if (NoOfVertices != 0)
{
structVerticesUnknown1[NoOfVertices] VerticesUnknown1; // Note:- If expectedSize >= 1024 bytes this array is
int NoOfVertices; compressed.
}
if (NoOfVertices != 0)
{
byte[32][NoOfVertices] VerticesUnknown2; // Note:- If expectedSize >= 1024 bytes this array is
} compressed.
if (Pointer < Filesize)
{
int NoOfProxies;
if (ProxyCount != 0)
{
structProxy[NoOfProxies] Proxies;
}
if (Pointer < Filesize)
{
int NoOf;
int[NoOf] intArrayResUnknown1;
int NoOf;
if (NoOf > 0)
{
for (int i = 0; i < NoOf; i++)
{
int NoOf2;
int[NoOf2] intArrayResUnknown2;
}
}
else
{
int intResUnknown1;
}
}
}
// Show stopper...
// At this point there is a unknown, intermittent, variable length structure.
// Requires manual intervention to move to next resolution.
// possibly Face-2-Texture mappings.
byte[VariableLength] IntermittentUnknownData; //Only present intermitently.
//EndOfResolution
}
Decompression
In ODOL v40 format files some of the datastructures present in the file are compressed by using a form of LZ compression. Unlike pbo compression, in ArmA model files, one only knows the number of items to decompress, the expected output size (in bytes) and the expected checksum. With this information and the size of a given data item one has the necessary information to expand the data to it's original format and size.
Note:- Data structures that are identified as being compressible will only be compressed if the 'expectedSize' is >= 1024 bytes.
The code that follows is written in C# and may or may not be optimal or correct.
As an example if one was expanding the array of vertices positions...
- A vertex is described by it's x,y,z coordinates which are floats. A float is a 32bit (4 byte) number.
- If we were processing 1968 vertices then our expected output size would be 1968 * (3 * 4) = 23,616 bytes.
This 'expectedSize' is the only necessary information one would need to pass to a processing sub-routine or function.
public bool Expand(int ExpectedSize)
{
byte PacketFlagsByte; //packet flags
byte WIPByte;
BitVector32 BV;
msLZ = new MemoryStream(ExpectedSize);
BinaryWriter bwLZ = new BinaryWriter(msLZ);
byte[] Buffer = new byte[ExpectedSize + 15];
bool[] BitFlags = new bool[8];
int i = 0, PointerRef = 0, ndx = 0, CalculatedCRC = 0, ReadCRC = 0, rPos, rLen, CurrentPointerRef = 0, Count = 0;
int Bit0 = BitVector32.CreateMask();
int Bit1 = BitVector32.CreateMask(Bit0);
int Bit2 = BitVector32.CreateMask(Bit1);
int Bit3 = BitVector32.CreateMask(Bit2);
int Bit4 = BitVector32.CreateMask(Bit3);
int Bit5 = BitVector32.CreateMask(Bit4);
int Bit6 = BitVector32.CreateMask(Bit5);
int Bit7 = BitVector32.CreateMask(Bit6);
PacketFlagsByte = br.ReadByte();
do
{
BV = new BitVector32(PacketFlagsByte);
BitFlags[0] = BV[Bit0];
BitFlags[1] = BV[Bit1];
BitFlags[2] = BV[Bit2];
BitFlags[3] = BV[Bit3];
BitFlags[4] = BV[Bit4];
BitFlags[5] = BV[Bit5];
BitFlags[6] = BV[Bit6];
BitFlags[7] = BV[Bit7];
i = 0;
do
{
if ((int)bwLZ.BaseStream.Position >= ExpectedSize) { break; }
if (BitFlags[i++]) //Direct Output
{
WIPByte = br.ReadByte();
bwLZ.Write(WIPByte);
Buffer[PointerRef++] = WIPByte;
CalculatedCRC += WIPByte;
}
else //Get from previous 4k
{
rPos = (int)(br.ReadByte());
rLen = (int)(br.ReadByte());
rPos |= (rLen & 0xF0) << 4;
rLen = (rLen & 0x0F) + 2;
CurrentPointerRef = PointerRef;
if ((CurrentPointerRef - (rPos + rLen)) > 0)
{
//Case of wholly within the buffer, partially within the end of the buffer or wholly outside the end of the buffer
for (Count = 0; Count <= rLen; Count++)
{
ndx = (CurrentPointerRef - rPos) + Count;
if (ndx < 0)
{
//Beyond the start of the buffer
WIPByte = 0x20;
}
else
{
//Within the buffer
WIPByte = Buffer[ndx];
}
//}
bwLZ.Write(WIPByte);
Buffer[PointerRef++] = WIPByte;
CalculatedCRC += WIPByte;
}
}
else
{
//Case of wholly or partially beyond the start of the buffer.
for (Count = 0; Count <= rLen; Count++)
{
ndx = (CurrentPointerRef - rPos) + Count;
if (ndx < 0)
{
//Beyond the start of the buffer
WIPByte = 0x20;
}
else
{
//Within the buffer
WIPByte = Buffer[ndx];
}
bwLZ.Write(WIPByte);
Buffer[PointerRef++] = WIPByte;
CalculatedCRC += WIPByte;
}
}
}
}
while ((i < 8) & (bwLZ.BaseStream.Position < ExpectedSize));
if (bwLZ.BaseStream.Position < ExpectedSize) { PacketFlagsByte = br.ReadByte(); }
}
while (bwLZ.BaseStream.Position < ExpectedSize);
ReadCRC = br.ReadInt32();
return (ReadCRC == CalculatedCRC);
}
Reference Tables
Note: These are not part of the p3d model file but are reference tables used for processing.
Resolutions
refResolutions
{
float Resolution;
string ResolutionName;
}
| Hex-Value | Value | Value | Description |
|---|---|---|---|
| 0x447a0000 | 1.0e3 | 1,000 | View Gunner |
| 0x44898000 | 1.1e3 | 1,100 | View Pilot |
| 0x44960000 | 1.2e3 | 1,200 | View Cargo |
| 0x461c4000 | 1.0e4 | 10,000 | Stencil Shadow |
| 0x461c6800 | 1.001e4 | 10,010 | Stencil Shadow 2 |
| 0x462be000 | 1.1e4 | 11000 | Shadow Volume |
| 0x462c0800 | 1.101e4 | 11010 | Shadow Volume 2 |
| 0x551184e7 | 1.0e13 | 10,000,000,000,000 | Geometry |
| 0x58635fa9 | 1.0e15 | 1,000,000,000,000,000 | Memory |
| 0x58e35fa9 | 2.0e15 | 2,000,000,000,000,000 | Land Contact |
| 0x592a87bf | 3.0e15 | 3,000,000,000,000,000 | Roadway |
| 0x59635fa9 | 4.0e15 | 4,000,000,000,000,000 | Paths |
| 0x598e1bca | 5.0e15 | 5,000,000,000,000,000 | HitPoints |
| 0x59aa87bf | 6.0e15 | 6,000,000,000,000,000 | View Geometry |
| 0x59c6f3b4 | 7.0e15 | 7,000,000,000,000,000 | Fire Geometry |
| 0x59e35fa9 | 8.0e15 | 8,000,000,000,000,000 | View Cargo Geometry |
| 0x59ffcb9e | 9.0e15 | 9,000,000,000,000,000 | View Cargo Fire Geometry |
| 0x5a0e1bca | 1.0e16 | 10,000,000,000,000,000 | View Commander |
| 0x5a1c51c4 | 1.1e16 | 11,000,000,000,000,000 | View Commander Geometry |
| 0x5a2a87bf | 1.2e16 | 12,000,000,000,000,000 | View Commander Fire Geometry |
| 0x5a38bdb9 | 1.3e16 | 13,000,000,000,000,000 | View Pilot Geometry |
| 0x5a46f3b4 | 1.4e16 | 14,000,000,000,000,000 | View Pilot Fire Geometry |
| 0x5a5529af | 1.5e16 | 15,000,000,000,000,000 | View Gunner Geometry |
| 0x5a635fa9 | 1.6e16 | 16,000,000,000,000,000 | View Gunner Fire Geometry |
| 0x5a7195a4 | 1.7e16 | 17,000,000,000,000,000 | Sub Parts |
Note: Hex-Values are provided for convenience, as you can use those in different programming languages 'switch'-statement as opposed to floating point values.
Material Stages
The number of material stages is dependant on the type of Shader that is used to process the material by the ArmA game engine. A reference table is used when processing materials where depending on the shader specified the given number of stages should be processed.
refShaderStages
{
int PixelShaderId;
int NoOfStages;
};
| ID (Hex/Decimal) | Name | Description | NoOfStages |
|---|---|---|---|
| 0x00, 0 | Normal | diffuse color modulate, alpha replicate | 0 |
| 0x01, 1 | NormalDXTA | diffuse color modulate, alpha replicate, DXT alpha correction | 0 |
| 0x02, 2 | NormalMap | normal map shader | 3 |
| 0x03, 3 | NormalMapThrough | normal map shader - through lighting | 3 |
| 0x04, 4 | ? | ? | ? |
| 0x05, 5 | NormalMapDiffuse | ? | 2 |
| 0x06, 6 | Detail | ? | 1 |
| 0x07, 7 | ? | ? | ? |
| 0x08, 8 | Water | sea water | 2 |
| 0x09, 9 | ? | ? | ? |
| 0x0A, 10 | White | ? | 0 |
| 0x0B, 11 | ? | ? | ? |
| 0x0C, 12 | AlphaShadow | shadow alpha write | 0 |
| 0x0D, 13 | AlphaNoShadow | shadow alpha (no shadow) write | 0 |
| 0x0E, 14 | ? | ? | ? |
| 0x0F, 15 | DetailMacroAS | ? | 3 |
| 0x10, 16 | ? | ? | ? |
| 0x11, 17 | ? | ? | ? |
| 0x12, 18 | NormalMapSpecularMap | ? | 2 |
| 0x13, 19 | NormalMapDetailSpecularMap | Similar to NormalMapDiffuse | 3 |
| 0x14, 20 | NormalMapMacroASSpecularMap | ? | 4 |
| 0x15, 21 | NormalMapDetailMacroASSpecularMap | ? | 5 |
| 0x16, 22 | NormalMapSpecularDIMap | Same as NormalMapSpecularMap, but uses _SMDI texture | 2 |
| 0x17, 23 | NormalMapDetailSpecularDIMap | ? | 3 |
| 0x18, 24 | NormalMapMacroASSpecularDIMap | ? | 4 |
| 0x19, 25 | NormalMapDetailMacroASSpecularDIMap | ? | 5 |
| 0x38, 56 | Glass | ? | 2 |
| 0x3A, 58 | NormalMapSpecularThrough | ? | 3 |
| 0x3B, 59 | Grass | Special shader to allow volumetric shadows to be cast on grass clutter | 0 |
| 0x3C, 60 | NormalMapThroughSimple | ? | 0 |
Enums
int enum PixelShaderId
{
Normal = 0x00,
NormalMap = 0x02,
NormalMapDiffuse = 0x05,
NormalMapMacroASSpecularMap = 0x14,
NormalMapSpecularDIMap = 0x16,
NormalMapMacroASSpecularDIMap = 0x18,
AlphaShadow = 0x0C,
AlphaNoShadow = 0x0D,
Glass = 0x38,
Detail = 0x06,
NormalMapSpecularMap = 0x12
}
int enum VertexShaderId
{
Basic = 0x00,
NormalMap = 0x01,
NormalMapAS = 0x0F
}
Links
Article Author - Sy (Synide) -- Sy 17:16, 11 August 2007 (CEST)
Original ODOLv40 Article detailed by Bxbx (Biki'd by Mikero)
