P3D File Format - ODOLV7: Difference between revisions
m (→LodStruct) |
|||
Line 81: | Line 81: | ||
''' ''' FacesStruct[...]; | ''' ''' FacesStruct[...]; | ||
'''ulong''' uvalue2; ''// unknown'' | '''ulong''' uvalue2; ''// unknown'' | ||
'''byte''' uchar[18*uvalue2]; ''// unknown valuea'' | '''byte''' uchar[18*uvalue2]; ''// unknown valuea'' |
Revision as of 05:32, 6 January 2009
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.
(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
Compression:
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 { VerticesStruct[...]; float fvalue[12]; // unknown: contains some max/min vertices positions TexturesStruct[...]; TableStruct[...]; FacesStruct[...]; ulong uvalue2; // unknown byte uchar[18*uvalue2]; // unknown valuea NamedStruct[...]; ulong uvalue7; // unknown value ??? struct ustruct[uvalue7]; // unknown value ulong ProxiCount; struct Proxi[ProxiCount]; }; // end of lod
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] ];
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"' };
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 }