P3D File Format - ODOLV4x
Introduction
Acknowledgements
This body of work is due to Synide's sweat and tears. To whom, all honour and glory. Ably assisted by T_D and Mikero that further detailed the data and gave this article a more general and correct structure.
Versions
This Document covers ODOL versions:
- V40 Original Arma1 binarised p3d
- V43 Arma2
- V47 Arma2
- V48 Arma2
The differences, where they exist, are documented in the relevent coded sections. They are summarised here
V43
•ModelInfo struct is now same as vbs2 155+24 bytes instead of 155 for V40 •The 'extra byte' flag in the UnknownStruct1 is always set, in arma1 (v40) it was always 0
- LZSS compression is still used at this level
V47
As per V43 plus: •all compressed blocks are LZO compressed •CompressedMinMax block is now nMinMax*8 in size •CompressedNormals block is now nNormals*4 in size •UVSet structure changed to:
LodUV
{
float uvScaling[4];
ulong nVertices;
tbool DefaultFill;
if (DefaultFill)
float UV; // default fill for all nVertices
else
float UV[nVertices]; // potentially compressed
}
LodKeyFrame has 4 extra floats
V48
As per V47 plus: •ModelInfo struct is now 179+4 bytes instead of 155 for V40
General
The general file format of a ArmA ODOL v4x p3d model file is similar to the ODOL v7 format. The major differences are that in ArmA models are
- an optional model.cfg
- Lods occur in the file from highest to lowest LodType value.
Legend
see Generic FileFormat Data Types
File Paths
The PrefixRoot\ folder.
Life for modellers would be far less tedious if filenames could also be relative to the p3d they are encountered in. Altering or moving or renaming the pbo (and specifically it's prefix) would not alter the relative location of the paa's it contains.
BI choose to use hard-wired Pbo-Prefix-addressing ONLY.
All hardwired addressing is relative to a built-in-situ (ie virtual) PrefixRoot\ folder
Each and every pbo in Arma contains a unique identity name, a prefix. Irrespective of the name of the pbo, the prefixname is THE name of the pbo from the perspective of the engine. In most cases, the prefixname is, conveniently, the filename. One huge advantage of this mechanism, sorely sorely missed in OFP. is that self-documenting increasing revisions of an addonV123.pbo can be supplied to Arma, with no changes to the mission sqms and other pbos that refer to it.
The PrefixRoot\ folder contains the prefix names of all pbos encountered (almost) ANYWHERE.
Thus the pbos in the Official Addons folder, the Oem Mods\Addons folder(s), the Dta core and bin pbo's, are all examined for their unique prefix names. These prefix names become the dictionary index of where the pbo really is, AND, what filename it actually is.
Thus all filename references in a p3d, *unconditionally* contain a prefixname\someFile\SomeWhere.
In most cases they refer to the very same pbo as the containing p3d and a great pity that the extraneous information could not have been removed by (optional) relative addressing as it requires a great deal of fiddling about when modifying models.
Note also that there is some inconsistency in filename paths. Most do not have a leading \. Some, require it. Both are indeed \hardwired
An Example:
P3dProxyName ="\ca\a10\agm65";
The immediate (and unfortunate) impression is that there is an A10 folder inside the official CA.pbo addon. In fact, the prefix of the A10.pbo = "ca\A10". Thus this reference is to the A10.pbo within which, is a agm65.p3d in it's root folder. (and again, this reference is in fact an extraneous reference to itself since the referring p3d (A10.p3d) is in the same pbo)
File Format
ODOLv4x
{
StandardP3DHeader Header;
ModelInfo ModelInfo;
Skeleton Skeleton;
UnknownStruct1 UnknownStruct;
Animations Animations;
ulong StartAdressOfLods[Header.NoOfLods];// offset relative to start of file.
ulong EndAdressOfLods [Header.NoOfLods];
tbool LODFaceIndicator [Header.NoOfLods];
LodFace LodFaces[NoOfFalseLODFaceIndicators];//there are only as many LodFaces as there are false LODFaceIndicators
ODOLv40Lod ODOLv40Lods[Header.NoOfLods];
}//EndOfFile
Structures
StandardP3DHeader
StandardP3DHeader
{
char[4] Filetype; // "ODOL"
ulong Version; // 40
ulong NoOfLods; // alias NoOfResolutions;
}
common header structure for all P3D file formats
Model Info
see P3D Model Info
structSkeleton
structSkeleton
{
asciiz SkeletonName; //"A10Skeleton"
if (SkeletonName != null)
{
tbool isInherited;
ulong NoOfBoneNames;
SkeletonBoneName SkeletonBoneNames[NoOfBoneNames];
}
}
SkeletonBoneName
SkeletonBoneName
{
asciiz BoneName; //"3dhud" or "Gearlocks" or "Fuel" or ...
asciiz ParentBoneName; // "Aeileron_1"
}
corresponds to model.cfg
class cfgSkeletons
{
class SkeletonClassname: Default
{
skeletonBones[]=
{
"RightDoor1","",
"RightDoor2","",
"LeftDoor1","",
"LeftDoor2","RightDoor2",
etc"
};
};
UnknownStruct1
UnknownStruct1
{
byte UnknownByte;
tbool Extra; // generally always 0 for v40, always 1 for v43
if(Extra)
{
byte ExtraByte;
}
byte UnknownBytes[3];
float ModelMass.
ModelMassReciprocal,
ModelMassModifier;
byte UnknownBytes[16];
ulong UnknownLong;
byte UnknownByte;
asciiz ClassType; //class="" or "House" or...
asciiz DestructType; //damage="" or "Tent" or "Building",,,,
byte UnknownBytes[5];
}
Animations
Animations
{
tbool AnimsExist;
if (AnimsExist)
{
ulong nAnimationClasses; // eg NoOfAnimSelections;
AnimationClass AnimationClasses[nAnimationClasses];
ulong NoOfResolutions;// same value as Header.NoOfLods
Bones2Anims Bones2Anims[NoOfResolutions];
Anims2Bones Anims2Bones[NoOfResolutions];
//For every bone there is a list of Animations for each resolution
//And, a reversed table of every Animation gets a Bone.
//The reversed table optionally appends axis info dependent on the AnimTransformType
}
}
AnimationClass
AnimationClass
{
ulong AnimTransformType;
asciiz AnimClassName; // "RightDoor"
asciiz AnimSource; // "rotor"
float MinMaxValue[2];
float MinMaxPhase[2];
ulong sourceAddress;
switch(AnimTransformType)
case 0://rotaton
case 1://rotationX
case 2://rotationY
case 3://rotationZ
float angle[2];
break;
case 4://translation
case 5://translationX
case 6://translationY
case 7://translationZ
float offset[2];
break;
case 8: //"direct"
float axisPos[3];
float axisDir[3];
float angle; //in radians whereas the model.cfg entry is in degrees
float axisOffset;
break;
case 9: //"hide"
float hideValue;
break;
}
corresponds to model.cfg
class CfgModels
{
....
class whateverModel: Default
{
...
class Animations
{
class RightDoor //AnimClassName
{
type = "translation";//AnimTransformType
source = "rotor"; //AnimSource
etc
Bones2Anims
Bones2Anims
{
ulong NoOfBones;
Bone2AnimClassList Bone2AnimClassLists[NoOfBones];
}
Bone2AnimClassList
Bone2AnimClassList
{
ulong NoOfAnimClasses;
ulong AnimationClassIndex[NoOfAnimClasses]; // a (sometimes repeating) list of zero based indexes into above animation classes
}
Anims2Bones
Anims2Bones
{
AnimBones AnimBones[Animations.nAnimationClasses];
}
AnimBones
every lod contains an identical list of animation entries that declare the position and axis of the each animation classes
AnimBones
{
long SkeletonBoneNameIndex; // zero based index to the SkeletonBoneName name & parentname
// equivalent to selection = "LeftDoor"; eg in the model.cfg
/*
** SkeletonBoneNameIndex== -1 when no skeleton bone is for this Anim and (obviously?) no axis information follows.
*/
if (SkeletonBoneNameIndex!= -1) && (AnimationClass.AnimTransformType != 8 || 9)
{
/*
** AnimationClass.AnimTransformType 8 (direct) and 9 (hide) never require axis information.
** This because the "direct" (type 8) already has axis info in it's AnimationClass structure,
** and "hidden" (type 9) clearly doesn't need it.
*/
XYZTriplet axisPos; //describes the position of the axis used for this anim
XYZTriplet axisDir;
}
}
LodFace
//only when the LODFaceIndicator for that lod is false
LodFace
{
ulong HeaderFaceCount;
bytes Unknown[13];
}
ODOLv40Lod
ODOLv40Lod
{
ulong nProxies;
LodModelProxy LodModelProxies[nProxies];
ulong nLodItems;
ulong LodItems[nLodItems]; // potentially compressed
ulong nUsedBones;
LodUsedBone LodUsedBones[nUsedBones];
LodPointProperties[...]; // Potentially compressed
byte UnknownBytes[8];
float UnknownFloats[10];
ulong NoOfTextures;
asciiz LodPaaTextureNames[NoOfTextures]; //"ca\characters\hhl\hhl_01_co.paa"
ulong NoOfMaterials;
LodMaterial LodMaterials[NoOfMaterials];
LodEdge LodEdge1; // potentially compressed
LodEdge LodEdge2; // potentially compressed
LodPolygons[...];
ulong nSections;
LodSection LodSections[nSections];
ulong nNamedSelections;
LodNamedSelection LodNamedSelections[nNamedSelections]; // potentially compressed
ulong nTokens;
LodTokenPair LodTokenPairs[nTokens];
ulong nFrames;
LodKeyFrame LodKeyFrames[nFrames];
byte Unknown[17];
if (V40 or V43)
{
LodUV LodUV1; // Potentially compressed
ulong nUVs;
if (nUVs==2)
LodUV LodUV2; // Potentially compressed
ulong NoOfVertices;
XYZTriplet LodXZY[NoOfVertices]; // Potentially compressed
ulong nNormals;
LodNormals LodNormals[nNormals]; // Potentially compressed
ulong nMinMax;
XYZTriplet LodMinMaxXYZ[nMinMax][2]; // Potentially compressed
}else // V47 & V48
{
A2LodUV A2LodUV1; // Potentially compressed
ulong nUVs;
if (nUVs==2)
{
float A2Floats[4];
A2LodUV A2LodUV2; // Potentially compressed
}
ulong NoOfVertices;
XYZTriplet LodXZY[NoOfVertices]; // Potentially compressed, same as arma1
ulong nNormals;
A2LodNormals A2LodNormals[nNormals]; // Potentially compressed
ulong nMinMax;
float LodMinMaxXYZ[nMinMax][2]; // Potentially compressed
}
// Note that nUV1's== nNormals == NoOfVertices
ulong Count;
LodUnknownStruct UnknownLodStruct[Count]; // Potentially compressed
ulong nBytes;
byte UnknownBytes[nBytes][32]; // Potentially compressed
}
LodModelProxy
LodModelProxy
{
asciiz P3dProxyName; //"\ca\a10\agm65" (.p3d is implied) <<note the leading filename backslash
XYZTriplet RotationMatrix[3];
XYZTriplet Translation;
ulong FaceIndex;
ulong NamedSelectionIndex;
ulong Unknown[2];
}
This structure is (almost) identical to ODOL7 except it has 4 indices rather than 2.
LodUsedBone
LodUsedBone
{
ulong nIDs; //range 0..3
ulong BoneID[nIDs];
}
This struct seems to assign unique iterative IDs (starting from zero) to some bones or their anims. Quite weird way of doing that, so it is probably not the whole truth.
LodPointProperties
This table is the equivalent of Oxygen's points->properties dialog box
it specifically stores the user values and other flags for that point
See Points Flags below
LodPointProperties
{
ulong NoOfPts;
tbool UseDefault;
if (UseDefault)
ulong DefaultValue;
else // =0
ulong PropertyValues[NoOfPts]; // potentially compressed
}
PropertyValues for NoOfPts are either all the same (UseDefault), or, they are individually declared.
Similar to CompressedStructs of OdolV7, if the amount of data in the array exceeds 1023 bytes, that array is compressed.
The use of a) potential compression and b) a default fill, is endemic to many ODOLV40 type packets.
LodMaterial
//Basically... A direct replication of the information in the given .rvmat file
LodMaterial
{
asciiz RvMatName; // "ca\characters\data\soldier_captive_hhl.rvmat"
ulong Type; // 9 == Arma, 10==VBS2
D3DCOLORVALUE Emissive;
D3DCOLORVALUE Ambient;
D3DCOLORVALUE Diffuse;
D3DCOLORVALUE forcedDiffuse;
D3DCOLORVALUE Specular;
D3DCOLORVALUE Unknown; //Usually same as Specular
float SpecularPower;
ulong PixelShaderId; //See enumPixelShaderId
ulong VertexShaderId;//See enumVertexShaderId
ulong BoolFlag; //mostly 1 otherwise 0
ulong AnIndex; //0,1 or 2
asciiz BiSurfaceName; // "ca\data\Penetration\plastic.bisurf"
ulong Always0x01;
ulong aCount; //Generally 0
ulong nTextures;
ulong nTransforms; // always same as nTextures
LodStageTexture StageTextures [nTextures];
LodStageTransform StageTransforms[nTransforms];
}
- There is always one default Texture and Transform as the first entry.
- It is the only entry if a SurfaceName exists.
D3DCOLORVALUE
D3DCOLORVALUE
{
float r,g,b,a;
}
LodStageTexture
LodStageTexture
{
ulong TextureFilter; // see below
asciiz PaaTexture; // "ca\characters\data\civil_tvreport_body_as.paa
// alternatively "#(argb,8,8,3)color(0,0,0,1,CO)" (eg)
ulong StageID; // zero based, see below
};
- The StageID is iterative (linear sequential). 1st entry is 0, 2nd 1, 3rd 2, etc.
- TextureFilter maybe 1 of the following values.
- 0: Point // sometimes
- 1: Linear // rarely
- 2: TriLinear // not seen
- 3: Anisotropic (default)
LodStageTransform
LodStageTransform
{
ulong UVSource;
float Transform[4][3];//a DirectX texture space transform matrix
};
LodEdge
LodEdge
{
ulong nEdges;
ushort Edges[nEdges]; // potentially compressed
};
LodPolygons
LodPolygons
{
ulong NoOfPolygons;
ulong OffsetToSectionsStruct; // see below
ushort AlwaysZero;
PolygonVertice
{
byte NoOfVertices; // 3 or 4
ushort VerticesIndex[NoOfVertices]; // 0-based index into Vertices Arrays
}PolygonVertices[NoOfPolygons];
}
Note that there are always 3, or 4, vertices.
- 3 point vertices describe a triangle.
- 4 point vertices describe a rectangle.
The indices must be transformed as follows
- triangles : 1st posn, 2nd posn, 0th posn.
- quadrangles : 1st, 2nd, 3rd, 0th
- Because of the variable amount of vertices in this struct (3 or 4), OffsetToSectionsStruct is used to skip the block. It's value is relative to the first PolygonVertice and is computed as follows
OffsetToSectionsStruct= NoOfPolygons * (SizeofEach (PolygonVertice));
Each PolygonVertice is
nOfVertices *sizeof(ushort) + sizeof(ushort); // always 8 or 10
This, is in fact, an ERROR because the type size of the NoOfVertices is byte, NOT ushort. Hence the REAL offset is
RealOffsetToSectionsStruct = OffsetToSectionsStruct - NoOfPolygons *(sizeof(ushort)- sizeof(byte) );
or, to put it more simply
RealOffsetToSectionsStruct = OffsetToSectionsStruct - NoOfPolygons;
NOTE: See discussions for actual nature of this value
LodSection
LodSection
{
ulong FaceLowerIndex;
ulong FaceUpperIndex; //NoOfFaces = (FaceUpperIndex - FaceLowerIndex) / 8
ulong Something1;
ulong Something2;
ulong UserValue;
short TextureIndex;
short Something4;
byte ZBias;
byte Something5;
short MaterialIndex;
if MaterialIndex ==-1
{
byte ExtraByte;
}
byte Something6[2];
ulong Something7;
float Something8;
float Something9;
}
LodNamedSelection
LodNamedSelection
{
asciiz NamedSelectionName; // "rightleg" or "neck" eg
ulong NoOfSelectedFaces;
ushort SelectedFaceIndexes[NoOfSelectedFaces]; //NOTE: This array is Compressed if size > 1024.
ulong Always0;
tbool IsSectional; //Appears in the sections[]= list of a model.cfg
ulong NoOfUlongs;
ulong UnknownArray[NoOfUlongs]; // possibly subject to compression. none seen so far
ulong nSelectedVertices;
ushort SelectedVerticesIndexes[nSelectedVertices]; // NOTE: This array is Compressed if size > 1024.
ulong nTextureWeights;
byte SelectedVerticesWeights[nTextureWeights]; // NOTE: This array is Compressed if size > 1024.
}
LodTokenPair
LodTokenPair
{
asciiz Property;// "noshadow" = "1" eg
asciiz Value;
}
LodKeyFrame
LodKeyFrame
{
float FrameTime;
ulong NoOfFramePoints;
XYZTriplet LodFramePoints[NoOfFramePoints];
if V47 or V48
{
float Arma2[4];
} }
LodUV
For V40 & V3
LodUV
{
ulong nVertices;
tbool DefaultFill;
if (DefaultFill)
float UV[2]; // default fill for all nVertices
else
float UV[nVertices][2]; // potentially compressed
}
The structure either contains a single UV pair of floats. Or, pairs of UV floats for all positions (nVertices)
If a full array is declared (DefaultFill != 0) then that array is compressed if 2 * sizeof(float) * nVertices > 1023
For V47 & 8
A2LodUV
{
ulong nVertices;
tbool DefaultFill;
if (DefaultFill)
float UV; // default fill for all nVertices
else
float UV[nVertices]; // potentially compressed
}
As above, except only a single float value per vertex is used.
LodNormals
A2LodNormals
LodNormals
{
tbool DefaultFill;
if (DefaultFill)
type XZY;
else
XYZTriplet XZY[nNormals]; // Potentially compressed
}
V40 and V43 type == XYZTriplet V47 and V48 type == float
LodUnknownStruct
LodUnknownStruct // potentially compressed
{
ulong Index;
float Unknown[2]; // probably a vertices something
}
Decompression
LZSS
In ODOL v40 and v43 format files, some of the data structures present in the file are compressed by using LZSS compression. ODOL v47 and v48 use LZO 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);
}
LZO
This is LZO as defined by oberhumer
http://www.oberhumer.com/opensource/lzo/
there are 3 sources to the lzo code
minilzo (on above site) lzo version 2 (ditto) lzo version 1 http://sourceforge.net/project/showfiles.php?group_id=102072&package_id=110218&release_id=221836
// some of the includes are for compression only (not listed here)
int lzo::lzo1x_decompress_safe ( const byte* in , byte* out, unsigned OutLen)
// returns length of consumed input bytes ,or, negative status
// Outlen is the desired output 'block size' this function will return neg status if the output buffer is not completely filled
// example call
byte Array=(byte)malloc(Outlen); // no zero clearing is necessary
int status_or_len=lzo->lzo1x_decompress_safe (input, Array,OutLen);#include "minilzo.h"
#include <limits.h>
#include <stddef.h>
#include <limits.h>
#include <stddef.h>
#include <string.h>
#include <malloc.h>
#define assert(val) if (!(val)) return LZO_E_ERROR
#define M2_MAX_OFFSET 0x0800
#define NEED_OP(x) if ((unsigned)(op_end - op) < (unsigned)(x)) return LZO_E_OUTPUT_OVERRUN;
#define TEST_LB() if (m_pos < out || m_pos >= op) return LZO_E_LOOKBEHIND_OVERRUN;
#define COPY4(dst,src) * (unsigned *)(dst) = * (const unsigned *)(src)
int lzo::lzo1x_decompress_safe ( const byte* in , byte* out, unsigned OutLen)
{
register byte* op;
register const byte* ip;
register size_t t;
register const byte* m_pos;
byte* const op_end = out + OutLen;
OutLen = 0;
op = out;
ip = in;
if (*ip > 17)
{
t = *ip++ - 17;
if (t < 4) goto match_next;
assert(t > 0);// return LZO_E_ERROR;
NEED_OP(t);
do *op++ = *ip++; while (--t > 0);
goto first_literal_run;
}
while (1 )
{
t = *ip++;
if (t >= 16) goto match;
if (t == 0)
{
while (*ip == 0)
{
t += 255;
ip++;
}
t += 15 + *ip++;
}
assert(t > 0); NEED_OP(t+3);
COPY4(op,ip);
op += 4; ip += 4;
if (--t > 0)
{
if (t >= 4)
{
do {
COPY4(op,ip);
op += 4; ip += 4; t -= 4;
} while (t >= 4);
if (t > 0) do *op++ = *ip++; while (--t > 0);
}
else
do *op++ = *ip++; while (--t > 0);
}
first_literal_run:
t = *ip++;
if (t >= 16) goto match;
m_pos = op - (1 + M2_MAX_OFFSET);
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
TEST_LB();
NEED_OP(3);
*op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos;
goto match_done;
do {
match:
if (t >= 64)
{
m_pos = op - 1;
m_pos -= (t >> 2) & 7;
m_pos -= *ip++ << 3;
t = (t >> 5) - 1;
TEST_LB(); assert(t > 0); NEED_OP(t+3-1);
goto copy_match;
}
else if (t >= 32)
{
t &= 31;
if (t == 0)
{
while (*ip == 0)
{
t += 255;
ip++;
}
t += 31 + *ip++;
}
m_pos = op - 1;
m_pos -= (ip[0] >> 2) + (ip[1] << 6);
ip += 2;
}
else if (t >= 16)
{
m_pos = op;
m_pos -= (t & 8) << 11;
t &= 7;
if (t == 0)
{
while (*ip == 0)
{
t += 255;
ip++;
}
t += 7 + *ip++;
}
m_pos -= (ip[0] >> 2) + (ip[1] << 6);
ip += 2;
////// done
if (m_pos == op)
{
assert(t==1);
if (m_pos!=op_end)
return LZO_E_LOOKBEHIND_UNDERRUN;
return ip-in;
}
m_pos -= 0x4000;
}
else
{
m_pos = op - 1;
m_pos -= t >> 2;
m_pos -= *ip++ << 2;
TEST_LB();
NEED_OP(2);
*op++ = *m_pos++; *op++ = *m_pos;
goto match_done;
}
TEST_LB();
assert(t > 0);
NEED_OP(t+3-1);
if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4)
{
COPY4(op,m_pos);
op += 4; m_pos += 4; t -= 4 - (3 - 1);
do {
COPY4(op,m_pos);
op += 4; m_pos += 4; t -= 4;
} while (t >= 4);
if (t > 0) do *op++ = *m_pos++; while (--t > 0);
}
else
{
copy_match:
*op++ = *m_pos++; *op++ = *m_pos++;
do *op++ = *m_pos++; while (--t > 0);
}
match_done:
t = ip[-2] & 3;
if (t == 0) break;
match_next:
assert(t > 0); assert(t < 4); NEED_OP(t);
*op++ = *ip++;
if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
t = *ip++;
} while (1 );
}
// return LZO_E_EOF_NOT_FOUND;/never gets here
}
Reference Tables
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 | NormalMapSpecularDIMap | ? | 2 |
| 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
}
Point Flags
Point Flags are as per Oxygen's Points->Properties as follows:
0NhUUFdLS
Surface
xxxxxxx0 normal
xxxxxxx1 on surface
xxxxxxx2 above
xxxxxxx4 under
xxxxxxx8 keep height(fence)
Lighting face
xxxxxx0x normal
xxxxxx1x shine
xxxxxx2x always in shadow
xxxxxx4x full light
xxxxxx8x half light
decal
xxxxx1xx decal
Fog
xxxx0xxx none
xxxx1xxx sky
xxxx2xxx normal
UU xxUUxxxx user 0..255
H x1xxxxxx hidden vertex
Normals
x0xxxxxx by face
x2xxxxxx fixed (normal)
x4xxxxxx by impedence
</code>
Links
Article Author - Sy (Synide) -- Sy 17:16, 11 August 2007 (CEST)
Original ODOLv40 Article detailed by Bxbx (Biki'd by Mikero)