P3D File Format - ODOLV7: Difference between revisions

From Bohemia Interactive Community
Jump to navigation Jump to search
mNo edit summary
m (Text replacement - "{{HashLink" to "{{Link")
 
(21 intermediate revisions by 3 users not shown)
Line 1: Line 1:
{{unsupported-doc}}
{{Feature|UnsupportedDoc}}
{{TOC|side}}
= General =
 
 
== Legend ==


===Legend===
see [[Generic FileFormat Data Types]]
see [[Generic FileFormat Data Types]]


===Intro===


====CompressedStruct====
== CompressedStructures ==


ODOL7 uses (potentially) compressed arrays.
(potentially) compressed arrays are endemic to most blocks contained in a p3d.


This obviously slows the engine down during loading. At the time of CWC development, game file sizes were important.
<syntaxhighlight lang="cpp">
CompressedStruct
{
ulong Count;
<type> Array[Count];
};
</syntaxhighlight>


(potentially) compressed arrays are contained in a CompressedStruct
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)


CompressedStructs are endemic to most blocks contained in the p3d.
After decompression, the Count remains the same because it is a count of the arraytype.


CompressedStruct
For uncompressed arrays (byte count < 1024) the Count and data are treated 'as is'.
{
  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)
Thus for various Array <types>
* ulong Array:    > 255  // 1024 /  sizeof(ulong)
* float thing[2]: > 127  // 1024 / 2*sizeof(float)
* SomeStructure:  >      // count * sizeof (SomeStructure) > 1023


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'.
Note that potentially compressed arrays in these structures only have an known output length. the decompressor therefore must work on infinite input length.




Thus for various Array <types>
= Odol7Stuct =
*ulong Array:    > 255  // 1024 /  sizeof(ulong)
*float thing[2]: > 127  // 1024 / 2*sizeof(float)
*SomeStructure:  >      // count * sizeof (SomeStructure) > 1023


See [[P3D Model Info]].
<syntaxhighlight lang="cpp">
ODOLV7
{
StandardP3DHeader Header;
LodStruct Lods[Header.LodCount];
ModelInfo ModelInfo;
};
</syntaxhighlight>


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===
== StandardP3DHeader ==
ODOLV7
{
  StandardP3DHeader Header;
  LodStruct Lods[LodCount];
  float    Resolution[LodCount];
  struct    ModelInfo;
};


====StandardP3DHeader====
<syntaxhighlight lang="cpp">
StandardP3DHeader
StandardP3DHeader
{
{
  char     Signature[4];     ''//"ODOL"''
char Signature[4]; //"ODOL" (vs MLOD eg)
  ulong     Version;           ''// 7''
ulong Version; // 7
  ulong     LodCount;         ''// at least one''
ulong LodCount; // at least one
}
}
</syntaxhighlight>


===LodStruct===
LodStruct
{
  '''struct'''  VerticesStruct;
  '''struct'''  UnknownStruct; // contains some max/min vertices positions
  '''struct'''  TexturesStruct;
  '''struct'''  VertexIndices;
  '''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===
== LodStruct ==
  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.
See:
*The Position and Normals tables appear to be always uncompressed raw data.
* {{Link|#VertexTable}}
* {{Link|#Textures}}
* [[P3D Lod Edges]]
* [[P3D Lod Faces]]
* [[P3D Lod Sections]]
* [[P3D Named Selections]]
* {{Link|#NamedProperty}}
* [[P3D Lod Frames]]
* [[P3D Lod Proxies]]


====UVPair====
UVSet
{
  float U,V;
}
===UnKnownStruct===
UnKnownStruct
{
  UVPair      UnknownUV; // just a guess         
  XYZTriplet  MinPos;
  XYZTriplet  MaxPos;
  XYZTriplet  AutoCenterPos;
  float        UnknownFloat;
}


===TexturesStruct===
<syntaxhighlight lang="cpp">
  struct Textures
LodStruct
  {
{
  '''ulong'''  Count;
VertexTable VertexTable;
  '''asciiz''' Textures[...];         ''// "data/1.paa\0data/2.paa\0"...
float UnknownFloat1;
  }
float UnknownFloat2;
XYZTriplet MinPos;
XYZTriplet MaxPos;
XYZTriplet AutoCenterPos;
float UnknownFloat3;
Textures Textures;
LodEdges LodEdges;
ulong NoOfFaces;
ulong OffsetToLodSections;
LodFace LodFaces[NoOfFaces]; // ie polygons
ulong nSections;
LODSection LODSections[nSections];
ulong nNamedSelections;
NamedSelection NamedSelections[nNamedSelections];
ulong nTokens;
NamedProperty NamedProperties[nTokens];
ulong nFrames;
Frame Frames[nFrames];
ulong IconColor;
ulong SelectedColor;
ulong Unknown;
ulong nProxies;
LodProxy LodProxies[nProxies];
};
</syntaxhighlight>


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.
=== VertexTable ===


===VertexIndices===
See [[P3D Point and Face Flags]].
VertexIndices
<syntaxhighlight lang="cpp">
{
struct
  CompressedStruct
{  
  {
ulong Count;
  '''ulong'''  Count;           ''// if > 511 etc'' 
ulong PointFlags[Count]; // compressed
  '''ushort''' MlodIndex[Count];
ulong Count;
  }
UVPair UV1[Count]; // compressed
  CompressedStruct
ulong Count;
  {
XYZTriplet Points[Count]; // UNcompressed
  '''ulong'''  Count;           ''// this Count is same value as any Vertices.Count''
ulong Count;
  '''ushort''' OdolIndex[Count];''//  
XYZTriplet Normals[Count]; // UNcompressed
  }
}
}
</syntaxhighlight>


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.
*Count is the same value for all four tables.
'''MLOD'''vertexindex = MlodIndex[ OdolIndex['''ODOL'''vertexindex] ];''


===FacesStruct===
=== Textures ===
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.
<syntaxhighlight lang="cpp">
struct
{
ulong Count;
asciiz Textures[...]; // "data/1.paa\0data/2.paa\0"...
}
</syntaxhighlight>


===LOD Sections===
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.
  LODSections
  {
  '''ulong'''  nSections;
  Sections[nSections]
  {
      ulong  FaceLowerIndex;
      ulong  FaceUpperIndex;
      ulong  UserValue;
      short  TextureIndex;      // -1 if not textured
      ulong  ODOL_FaceFlags;
  };
  }


===NamedSelection===
=== NamedProperty ===
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
<syntaxhighlight lang="cpp">
  {
struct
    '''asciiz''' Name; ''// "noshadow\0"
{
    '''asciiz''' Value; ''//"1\0"'
Asciiz Property; // e.g "noshadow" = "1"
  };
Asciiz Value;
}
</syntaxhighlight>


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


===ProxiStruct===
= Related Page(s) =
ProxiStruct
{
  '''ulong'''  Count;
  '''struct''' Proxi
  {
  '''asciiz''' Name;
  '''float''' rotationMatrix[9];
  '''float''' translation[3];
  '''ulong''' Index[2];
  }[Count];;
}


==ModelInfo==
== LZ in ODOL ==
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]]
see [[Compressed LZSS File Format]]


[[BIS File Formats#3D Model File Formats|Model File Formats]]


=Related Page(s)=


[[BIS_File_Formats#3D_Model_File_Formats|Model File Formats]]
[[Category:BIS_File_Formats]]
[[Category:BIS_File_Formats]]

Latest revision as of 17:43, 4 January 2023

bi symbol white.png
Disclaimer: This page describes internal undocumented structures of Bohemia Interactive software.

This page contains unofficial information.

Some usage of this information may constitute a violation of the rights of Bohemia Interactive and is in no way endorsed or recommended by Bohemia Interactive.
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.

General

Legend

see Generic FileFormat Data Types


CompressedStructures

(potentially) compressed arrays are endemic to most blocks contained in a 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 decompression, 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.


Odol7Stuct

See P3D Model Info. 

ODOLV7
{
	StandardP3DHeader	Header;
	LodStruct			Lods[Header.LodCount];
	ModelInfo			ModelInfo;
};


StandardP3DHeader

StandardP3DHeader
{
	char	Signature[4];	//"ODOL" (vs MLOD eg)
	ulong	Version;		// 7
	ulong	LodCount;		// at least one
}


LodStruct

See: 


LodStruct
{
	VertexTable		VertexTable;
	float			UnknownFloat1;
	float			UnknownFloat2;
	XYZTriplet		MinPos;
	XYZTriplet		MaxPos;
	XYZTriplet		AutoCenterPos;
	float			UnknownFloat3;
	Textures		Textures;
	LodEdges		LodEdges;
	ulong			NoOfFaces;
	ulong			OffsetToLodSections;
	LodFace			LodFaces[NoOfFaces]; // ie polygons
	ulong			nSections;
	LODSection		LODSections[nSections];
	ulong			nNamedSelections;
	NamedSelection	NamedSelections[nNamedSelections];
	ulong			nTokens;
	NamedProperty	NamedProperties[nTokens];
	ulong			nFrames;
	Frame			Frames[nFrames];
	ulong			IconColor;
	ulong			SelectedColor;
	ulong			Unknown;
	ulong			nProxies;
	LodProxy		LodProxies[nProxies];
};

VertexTable

See P3D Point and Face Flags. 

	struct
	{ 
	ulong		Count;
	ulong		PointFlags[Count];	// compressed
	ulong		Count;
	UVPair		UV1[Count];			// compressed 
	ulong		Count;
	XYZTriplet	Points[Count];		// UNcompressed
	ulong		Count;
	XYZTriplet	Normals[Count];		// UNcompressed
	}
  • Count is the same value for all four tables.

Textures

struct
{
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.

NamedProperty

struct
{
	Asciiz Property; // e.g "noshadow" = "1"
	Asciiz Value;
}


Related Page(s)

LZ in ODOL

see Compressed LZSS File Format

Model File Formats

Retrieved from "https://community.bistudio.com/wiki?title=P3D_File_Format_-_ODOLV7&oldid=336900"