EBO
EBO is a file extension in EA Sports games which is used for model and animation files.
In FIFA and FIFA Manager games, EBO files are used to store animations. In other games (NHL, NBA Libe) they are also used to store models/meshes.
Games[edit | edit source]
EBO files are used in following games:
| Game | Platform | Year | Version | Content type |
|---|---|---|---|---|
| FIFA 2005 - FIFA 10 | PC | 2004 - 2009 | 17 | Animations |
| UEFA Champions League 2004/2005, 2006/2007 | PC | 2004, 2006 | 17 | Animations |
| FIFA World Cup 2006 | PC | 2006 | 17 | Animations |
| UEFA Euro 2008 | PC | 2008 | 17 | Animations |
| FIFA Manager 06 - FIFA Manager 14 | PC | 2005 - 2013 | 17 | Animations |
| NHL 2005, 06 - 09 | PC | 2004 - 2008 | 17 | Models |
| NBA Live 2005, 06 - 08 | PC | 2004 - 2007 | 17 | Models |
| NCAA March Madness 06 | PS2, XBOX | 2005 | 17 | Models |
| FIFA 07 | XBOX360 | 2006 | 19 | Animations |
| Madden NFL 07 | XBOX360 | 2006 | 19 | Animations |
General file format[edit | edit source]
010 Editor template[edit | edit source]
//------------------------------------------------
//--- 010 Editor v9.0.2 Binary Template
//
// File: Ebo File
// Authors: Dmitri
// Version: 0.2
// Purpose: -
// Category: -
// File Mask: *.ebo
// ID Bytes: EBO\0
// History: -
//------------------------------------------------
local int VERSION;
typedef char i8;
typedef short i16;
typedef int i32;
typedef float f32;
struct ptr {
if (VERSION >= 19)
unsigned __int64 value;
else
unsigned int value;
};
struct String {
unsigned int offset;
local int pos1 = FTell();
FSeek(32);
local int stringsOffset = ReadInt();
FSeek(stringsOffset + offset);
string value;
FSeek(pos1);
};
typedef String AssetName;
struct Indices_0 {
i16 mNumIndices;
i16 mIndices[mNumIndices];
};
struct TimeData_0 {
i8 mCycle;
i8 mFlag;
i16 mNumKeysMinus1;
i16 mKeyTimes[mNumKeysMinus1];
};
struct AnimObject_0 {
String mType;
ptr mObjectInfo;
};
struct Animation_0 {
AnimObject_0 Base;
i16 mSignature;
i16 mEndFrame;
};
struct SkelAnim_0 {
Animation_0 Base;
ptr mTimeData;
ptr mQData;
ptr mTData;
ptr mSData;
ptr mQConstData;
ptr mTConstData;
ptr mSConstData;
};
struct PosCompressed_0 {
i16 mX;
i16 mZ;
};
struct FacingCompressed_0 {
i16 mValue;
};
struct RootAnim_0 {
Animation_0 Base;
f32 mInvertStep;
f32 mPosScale;
i16 mNumCompressedFrames;
i8 mPad[2];
PosCompressed_0 mPositions[mNumCompressedFrames];
FacingCompressed_0 mFacings[mNumCompressedFrames];
};
struct DataObject {
String mType;
ptr mUserData;
i32 mNumExternalVariables;
i32 mGetExternalVariableHandler;
};
struct DoubleLinkedListPtrNode {
i32 mPrior; /* These are really pointers, but should NEVER be output in pipeline */
i32 mNext; /* These are really pointers, but should NEVER be output in pipeline */
};
struct ManagedPointer {
DoubleLinkedListPtrNode mInheritedData; /* This is really inherited and not a member */
ptr mData;
i16 mOffsetToAuxData;
i16 mCallbackStructIndex;
};
struct GeometryFlags {
i8 mType; // see GeometryTypeFlags
i8 mIsDirty; // 1 if SetStream or ApplyMorph was called
i8 mPad1; // pad to 32bit
i8 mPad2; // pad to 32bit
};
struct Vector3 {
f32 x;
f32 y;
f32 z;
};
struct BoundingInfo {
Vector3 min;
Vector3 max;
Vector3 center;
f32 radius;
};
struct Geometry {
DataObject mDataObject;
AssetName mName;
i32 mNumMaterials;
ptr mMaterials; // Material*
i32 mNumExternalVariables;
ptr mExternalVariables; // ExternalVariable*
ManagedPointer mManagedPointerToBaseGeometry;
GeometryFlags mFlags;
i8 mMonth; // This data is a union with mpToEboFileAllocation.
i8 mDay; // Since mpToEboFileAllocation is never written out
i8 mHour; // by the pipeline, and this data IS written out by
i8 mMinutes; // the pipeline, this works better for endian conversion.
ptr mBoundingInfo; // BoundingInfo*
i32 mModelMatrixExtVarIndex;
ptr mExportedStreamList; // StringArray*
};
struct Material {
ptr mRenderMethod;
ptr mExternalVariables;
ptr mVars;
ptr mPerMaterialVars;
Vector3 mCompressScale; /* TODO: remove*/
Vector3 mCompressOffset; /* TODO: remove*/
i32 mNumStreams;
ptr mStreamHeaderArray;
};
struct PCVertexBuffer {
i32 mSizeInBytes;
i32 mStride;
ptr mpData;
ptr mpVertexBuffer;
i32 mFVF;
i32 mUsage;
i32 mDirty;
};
struct PCIndexBuffer {
i32 mSizeInBytes;
i32 mStride;
ptr mpData;
ptr mpIndexBuffer;
i32 mUsage;
i32 mVertexShaderID;
};
struct PCDataBuffers {
ptr mpIndexBufferMemImage;
i32 mBufferOffset;
i32 mNumElem;
i32 mNumVertexBuffers;
ptr mpBatch;
ptr mpVertexBufferMemImages[mNumVertexBuffers] <optimize=false>;
};
struct XBOXD3DVertexBufferMemImage {
i32 mCommon;
ptr mData;
i32 mLock;
};
struct XBOXVertexBuffer {
XBOXD3DVertexBufferMemImage mBaseTypeInfo;
i32 mByteSize;
i32 mStride;
i32 mRegistered;
ptr mData;
};
struct EboChunkTOC {
local int tocStart = FTell();
unsigned short flags;
unsigned short USDIdx; // index to usedTypeNames
local int retPos = FTell();
FSeek(20);
local int typeNamesOffset = ReadInt();
FSeek(typeNamesOffset + USDIdx * 4);
local int nameOffset = ReadInt();
FSeek(32);
local int stringsOffset = ReadInt();
FSeek(stringsOffset + nameOffset);
string typeName;
FSeek(retPos);
unsigned int nStructs;
unsigned int alignedSize;
unsigned int oData; // ptr struct data
local int tocEnd = FTell();
FSeek(tocStart + oData);
if (typeName == "EaglAnim::Indices_0")
Indices_0 data[nStructs] <optimize=false>;
else if (typeName == "EaglAnim::TimeData_0")
TimeData_0 data[nStructs] <optimize=false>;
else if (typeName == "EaglAnim::RootAnim_0")
RootAnim_0 data[nStructs] <optimize=false>;
else if (typeName == "EaglAnim::SkelAnim_0")
SkelAnim_0 data[nStructs] <optimize=false>;
else if (typeName == "Geometry")
Geometry data[nStructs] <optimize=false>;
else if (typeName == "Material")
Material data[nStructs] <optimize=false>;
else if (typeName == "i8")
i8 data[nStructs] <optimize=false>;
else if (typeName == "ptr")
ptr data[nStructs] <optimize=false>;
else if (typeName == "AssetName")
AssetName data[nStructs] <optimize=false>;
else if (typeName == "PCVertexBuffer")
PCVertexBuffer data[nStructs] <optimize=false>;
else if (typeName == "PCIndexBuffer")
PCIndexBuffer data[nStructs] <optimize=false>;
else if (typeName == "PCDataBuffers")
PCDataBuffers data[nStructs] <optimize=false>;
else if (typeName == "XBOXVertexBuffer")
XBOXVertexBuffer data[nStructs] <optimize=false>;
else // any other data
unsigned char data[4];
FSeek(tocEnd);
};
struct EboChunk {
local int chunkStart = FTell();
unsigned short flags;
unsigned short nTOCs;
unsigned int oTOCs; // ptr to ObjectInfo array
int type; // 0
int version; // 0
unsigned int size;
if (nTOCs > 0)
EboChunkTOC TOCs[nTOCs] <optimize=false>;
local int chunkEnd = FTell();
local int otherDataSize = size + chunkStart - chunkEnd;
if (otherDataSize > 4)
unsigned char otherData[otherDataSize];
};
struct EboImport {
ptr next; // runtime, 0
ptr prev; // runtime, 0
unsigned int oTypeName;
local int pos1 = FTell();
FSeek(32);
local int stringsOffset = ReadInt();
FSeek(stringsOffset + oTypeName);
string typeName;
FSeek(pos1);
unsigned int oName;
local int pos2 = FTell();
FSeek(stringsOffset + oName);
string name;
FSeek(pos2);
unsigned int oIAT;
unsigned int nIATEntries;
};
struct EboExport {
unsigned int oTypeName;
local int pos1 = FTell();
FSeek(32);
local int stringsOffset = ReadInt();
FSeek(stringsOffset + oTypeName);
string typeName;
FSeek(pos1);
unsigned int oName;
local int pos2 = FTell();
FSeek(stringsOffset + oName);
string name;
FSeek(pos2);
int oExportedData;
};
struct AlignedString2b {
string str;
local int pos1 = FTell();
if (pos1 % 2)
char pad;
};
struct EboUSD {
unsigned int oTypeName;
if (VERSION >= 19)
unsigned int checksum;
local int endPos = FTell();
FSeek(32);
local int stringsOffset = ReadInt();
FSeek(stringsOffset + oTypeName);
string name;
FSeek(endPos);
};
struct EboFile {
unsigned int signature; // EBO\0
unsigned int version; // known versions are 17 and 19
VERSION = version;
unsigned int size; // size of the file
if (VERSION >= 19) {
//unsigned int tocSize; only in Madden NFL?
unsigned char endianOrig;
unsigned char eboRulesConfig;
unsigned char endianCurr;
unsigned char dummy;
} else {
unsigned short endianOrig; // 0
unsigned short endianCurr; // 0
}
unsigned int oChunks;
unsigned int oUSDs;
unsigned int oImports;
unsigned int oExports;
unsigned int oStrings;
unsigned short nChunks;
unsigned short nUSDs;
unsigned short nImports;
unsigned short nExports;
unsigned short nStrings;
unsigned short pad1; // 0
ptr manager; // runtime, 0
ptr next; // runtime, 0
ptr prev; // runtime, 0
ptr nextClone; // runtime, 0
ptr prevClone; // runtime, 0
ptr baseEboFile; // runtime, 0
unsigned int cloneStartOffset; // runtime, usually 0
unsigned int pFindType; // runtime, usually 0
unsigned int pFoundType; // runtime, usually 0
unsigned int foundChunk; // runtime, usually 0
unsigned int foundTOC; // runtime, usually 0
unsigned int foundCount; // runtime, usually 0
EboChunk chunks[nChunks] <optimize=false>;
EboUSD USDs[nUSDs] <optimize=false>;
EboImport imports[nImports] <optimize=false>;
if (nImports != 0) {
if (VERSION >= 19)
unsigned char importsData[oExports - oImports - nImports * 32];
else
unsigned char importsData[oExports - oImports - nImports * 24];
}
EboExport exports[nExports] <optimize=false>;
unsigned int pad2; // usually 0
AlignedString2b strings[nStrings] <optimize=false>;
};
EboFile file;
Structures[edit | edit source]
anmstruc.txt[edit | edit source]
There's a text file in motion.big which contains information about animation structures.
EA::Math::Matrix44, 16
{
f32 m[16];
}
EA::Math::Vector3, 16
{
f32 v[3];
}
EA::Math::Vector4, 16
{
f32 v[4];
}
EA::Math::Quaternion, 16
{
f32 v[4];
}
EaglAnim::ConstructInfo_0
{
void *mDataImage;
String mHeaderType;
i32 mTotalSize;
i16 mDataSize;
i16 mHeaderSize;
i16 mPatternSize;
i16 mPatternNumRepeats;
i16 mNumStrings;
i16 mNumInternalPtrs;
i16 mNumExternalPtrs;
i16 mNumChildPtrs;
i16 StringOffsets[mNumStrings];
i16 InternalPtrOffsets[mNumInternalPtrs];
i16 ExternalPtrOffsets[mNumExternalPtrs];
i16 ChildPtrOffsets[mNumChildPtrs];
}
EaglAnim::ObjectInfo_0
{
i16 mFlags;
i16 mNumChildren;
}
EaglAnim::AnimObject_0, 16
{
String mType;
ObjectInfo *mObjectInfo;
}
EaglAnim::Skeleton_0, 64
{
EaglAnim::AnimObject_0 Base;
i16 mSignature;
i16 mNumBones;
i16 *mParentBoneIds;
i8 mPad[48];
EA::Math::Matrix44 InvBaseMatrices[mNumBones];
i16 ParentBoneIds[mNumBones];
}
EaglAnim::DofRange_0
{
i16 mStartIdx;
i16 mNumValues;
}
EaglAnim::DofMask_0
{
i16 mNumTypes;
i16 mTotalNumRanges;
i16 RangeIdxs[mNumTypes];
EaglAnim::DofRange_0 Ranges[mTotalNumRanges];
}
EaglAnim::BoneDofMap_0
{
i16 mType;
i16 mSIdx;
i16 mQIdx;
i16 mTIdx;
}
EaglAnim::PoseDofMap_0, 16
{
i16 mNumBones;
i16 mNumDofs;
i16 mNumRanges;
i16 mStaticPoseSize;
float *mStaticPoseBuffer;
BoneDofMap *mBoneDofMap;
i16 *mMirrorDofMap;
PoseBufferRange *mPoseBufferRanges;
DofMask *mDofMask;
i32 mPad;
EA::Math::Vector4 StaticPoseBuffer[mStaticPoseSize];
EaglAnim::BoneDofMap_0 BoneDofMap[mNumBones];
i16 MirrorDofMap[mNumDofs];
i16 PoseBufferRanges[mNumRanges];
EaglAnim::DofMask_0 DofMask;
}
EaglAnim::Pose_0, 16
{
EaglAnim::AnimObject_0 Base;
i16 mSignature;
i16 mPoseBufferSize;
PoseDofMap *mPoseDofMap;
EA::Math::Vector4 PoseBuffer[mPoseBufferSize];
}
EaglAnim::MatricesObjectHeader_0, 64
{
EaglAnim::AnimObject_0 Base;
i32 mNumMatrices;
i32 mPad[13];
}
EaglAnim::MatricesObject_0, 64
{
EaglAnim::MatricesObjectHeader_0 Header;
EA::Math::Matrix44 Matrices[Header.mNumMatrices];
}
EaglAnim::DictEntry_0
{
String mName;
i32 mId;
}
EaglAnim::Dictionary_0, 16
{
EaglAnim::AnimObject_0 Base;
i32 mNumEntries;
EaglAnim::DictEntry_0 Entries[mNumEntries];
}
EaglAnim::Animation_0, 16
{
EaglAnim::AnimObject_0 Base;
i16 mSignature;
i16 mEndFrame;
}
EaglAnim::RawAnim_0, 16
{
EaglAnim::Animation_0 Base;
i16 *mTimes;
i16 *mDofIndices;
i16 mNumKeys;
i16 mNumQs;
i16 mNumT3s;
i16 mNumS3s;
i16 mNumT1s;
i16 mNumS1s;
i32 mNumFloatData;
i8 mCycle;
i8 mPadding[11];
f32 FloatData[mNumFloatData];
}
// We never write a plugin out to an EBO file but we need an chunk definition
// to be able to add an import of this type.
EaglAnim::EvalPlugin_0
{
String mEvalType;
ptr mInitHandler;
ptr mUninitHandler;
ptr mEvaluateHandler;
ptr mFieldChangedHandler;
i32 mNumFields;
FieldInfo *mFieldInfo;
}
EaglAnim::ExternalVariable_0
{
String mType;
String mName;
AssetName mAssetName;
i32 mData;
i32 mVariable;
}
// Evaluator inherits from EaglCore::DataObject, but since we don't have a
// definition for it we repeat the inherited fields here.
EaglAnim::Evaluator_0, 16
{
String mType;
void *mUserData;
i32 mNumExternalVariables;
ptr mGetExternalVariableHandler;
ptr mEvaluateHandler;
i32 mFlags;
}
EaglAnim::BlendPosesEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
}
EaglAnim::BlendAnimsEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
}
EaglAnim::SkelAnimCacheEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
i32 mCacheSize;
i8 Cache[mCacheSize];
}
EaglAnim::PoseToMatricesEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
}
EaglAnim::SkelMatricesEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
}
EaglAnim::BonePosEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
ptr mPose;
ptr mMatrices;
ptr mCacheAnim;
ptr mCacheQuery;
ptr mSkelAnimEval;
ptr mPoseToMatricesEval;
EA::Math::Matrix44 mCacheInvRefMatrix;
f32 mCacheRefTime;
i32 mPTMMode;
i8 mCacheMirror;
}
EaglAnim::Event_0, 4
{
i16 mEventId;
i16 mCsisCrc;
i16 mTriggerFrame;
i16 mNumParams;
i32 mParams[6];
}
EaglAnim::EventBitPackAnimEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
i16 mSearchKey;
EaglAnim::Event_0 mEvent;
}
EaglAnim::BonePosQuery_0
{
i16 mRefBone;
i16 mNumQueryBones;
i16 *mQueryBones;
i16 *mQueryDofs;
EaglAnim::DofMask_0 *mRefBoneMask;
EaglAnim::DofMask_0 *mRootToRefBoneMask;
EaglAnim::DofMask_0 *mAllBonesMask;
EaglAnim::DofMask_0 *mRootToAllBonesMask;
EaglAnim::DofMask_0 *mRootToAllQueryBonesMask;
EaglAnim::DofMask_0 *mRefBoneToAllQueryBonesMask;
}
EaglAnim::Indices_0
{
i16 mNumIndices;
i16 mIndices[mNumIndices];
}
EaglAnim::TimeData_0
{
i8 mCycle;
i8 mFlag;
i16 mNumKeysMinus1;
i16 mKeyTimes[mNumKeysMinus1];
}
EaglAnim::AnimData_0
{
EaglAnim::Indices *mIndices;
}
EaglAnim::DeltaQAnimData::RangeDecompressed_0
{
f32 mMin;
f32 mMultiplier;
f32 mPad[2];
}
EaglAnim::DeltaQAnimData::Range_0
{
i8 mMin;
i8 mMultiplier;
}
EaglAnim::DeltaQAnimData::PhysicalValue_0
{
i16 mValue[3];
}
EaglAnim::DeltaQAnimData::DeltaValue6_0
{
i8 mValue[3];
}
EaglAnim::DeltaQAnimData::DeltaValue4_0
{
i16 mValue;
}
EaglAnim::DeltaQAnimData_0
{
EaglAnim::AnimData_0 Base;
i16 mNumRanges;
i16 mNumPhysicalValues;
i16 mNumDeltaValues6;
i16 mBinLengthPower;
i16 mNumRanges4;
i16 mNumDeltaValues4;
EaglAnim::DeltaQAnimData::Range_0 mRanges[mNumRanges];
EaglAnim::DeltaQAnimData::PhysicalValue_0 mPhysicalValues[mNumPhysicalValues];
EaglAnim::DeltaQAnimData::DeltaValue4_0 mDeltaValues4[mNumDeltaValues4];
EaglAnim::DeltaQAnimData::DeltaValue6_0 mDeltaValues6[mNumDeltaValues6];
}
EaglAnim::EventBitPackAnimData::EventMetaData_0
{
i16 mCsisCrc;
i16 mEvendIdAndNumParams;
i32 mParamNumBits;
}
EaglAnim::EventBitPackAnimData_0
{
i16 mNumEvents;
i16 mEventIdNumBits;
i16 mNumKeysPlusOne;
i16 mBitPackBufferSize;
EaglAnim::EventBitPackAnimData::EventMetaData_0 mEventMetaData[mNumEvents];
i16 mKeyBitIndices[mNumKeysPlusOne];
i8 mBitPackBuffer[mBitPackBufferSize];
}
EaglAnim::DeltaQConstData_0
{
EaglAnim::AnimData_0 Base;
i16 mNumRanges;
i16 mPad;
EaglAnim::DeltaQAnimData::PhysicalValue_0 mPhysicalValues[mNumRanges];
}
EaglAnim::DeltaF1AnimData::RangeDecompressed_0
{
f32 mMin;
f32 mMultiplier;
}
EaglAnim::DeltaF1AnimData::Range_0
{
i16 mMin;
i16 mMultiplier;
}
EaglAnim::DeltaF1AnimData::PhysicalValue_0
{
i16 mValue;
}
EaglAnim::DeltaF1AnimData::DeltaValue_0
{
i8 mValue;
}
EaglAnim::DeltaF1AnimData_0
{
EaglAnim::AnimData_0 Base;
i16 mNumRanges;
i16 mNumPhysicalValues;
i16 mNumDeltaValues;
i16 mBinLengthPower;
EaglAnim::DeltaF1AnimData::RangeDecompressed_0 mPhysicalRanges[mNumRanges];
EaglAnim::DeltaF1AnimData::Range_0 mDeltaRanges[mNumRanges];
EaglAnim::DeltaF1AnimData::PhysicalValue_0 mPhysicalValues[mNumPhysicalValues];
EaglAnim::DeltaF1AnimData::DeltaValue_0 mDeltaValues[mNumDeltaValues];
}
EaglAnim::DeltaF1ConstData_0
{
EaglAnim::AnimData_0 Base;
i16 mNumRanges;
i16 mPad;
f32 mPhysicalValues[mNumRanges];
}
EaglAnim::SkelAnim_0, 16
{
EaglAnim::Animation_0 Base;
EaglAnim::TimeData_0 *mTimeData;
void *mQData;
void *mTData;
void *mSData;
void *mQConstData;
void *mTConstData;
void *mSConstData;
}
EaglAnim::EventAnim_0, 16
{
EaglAnim::Animation_0 Base;
EaglAnim::TimeData_0 *mTimeData;
void *mEventData;
}
EaglAnim::EvalInitData_0
{
String mType;
EvalPlugin *mPlugin;
}
EaglAnim::EvalSwitchTableEntry_0
{
String mEvalId;
EvalInitData *mInitData;
}
EaglAnim::EvalSwitchData_0
{
i32 mNumEvals;
EaglAnim::EvalSwitchTableEntry_0 EntryTable[mNumEvals];
}
EaglAnim::SkelDeltaAnimEvalInitData_0
{
EaglAnim::EvalInitData_0 Base;
i16 mMaxChannels;
i16 mNumMaxAnimQs;
i16 mNumMaxAnimTs;
i16 mNumMaxAnimSs;
i32 mPoseCheckSum;
}
EaglAnim::RawAnimEvalInitData_0
{
EaglAnim::EvalInitData_0 Base;
i32 mPoseCheckSum;
i16 mMaxChannels;
}
EaglAnim::UserObject_0, 16
{
EaglAnim::AnimObject_0 Base;
i16 mCheckSum;
i16 mSubclassSize;
i32 mFieldFlags;
i8 SubclassData[mSubclassSize];
}
EaglAnim::UserAnim_0, 16
{
EaglAnim::Animation_0 Base;
EaglAnim::TimeData_0 *mTimeData;
void *mQData;
void *mF1Data;
void *mQConstData;
void *mF1ConstData;
i32 mFlag;
}
EaglAnim::UserDeltaAnimEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
i16 mCurrentKeyBefore;
i16 mCurrentKeyAfter;
i16 mPrevKeyBefore;
i16 mPrevKeyAfter;
i16 mNumMaxAnimQs;
i16 mNumMaxAnimF1s;
ptr mPrevAnim;
ptr mQCache[2];
ptr mF1Cache[2];
i32 mCacheSize;
i8 mPadding[8];
i8 Cache[mCacheSize];
}
EaglAnim::UserDeltaAnimEvalInitData_0
{
EaglAnim::EvalInitData_0 Base;
i16 mNumMaxAnimQs;
i16 mNumMaxAnimF1s;
i16 mUserStructCheckSum;
i8 mPadding[2];
}
EaglAnim::MorphAnim_0, 16
{
EaglAnim::Animation_0 Base;
EaglAnim::TimeData_0 *mTimeData;
void *mWeightData;
}
EaglAnim::MorphAnimCacheEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
i32 mCacheSize;
i8 Cache[mCacheSize];
}
EaglAnim::UserAttribute_0, 16
{
EaglAnim::AnimObject_0 Base;
i16 mCheckSum;
i16 mNumFloats;
i16 mNumInts;
i16 mNumStrings;
i16 mNumIndices;
i8 mPadding[2];
i32 mFlag;
f32 float_data[mNumFloats];
i32 int_data[mNumInts];
String strings[mNumStrings];
i16 indices[mNumIndices];
}
EaglAnim::UserAttributeEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
}
EaglAnim::IkEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
}
EaglAnim::IkChain_0, 16
{
i16 mType;
}
EaglAnim::OneBoneBallIkChain_0, 16
{
EaglAnim::IkChain_0 Base;
i16 mBone;
f32 mB;
f32 mOriginLen2;
i32 mPad;
EA::Math::Vector4 mDir;
EA::Math::Vector4 mOrigin;
}
EaglAnim::TwoBoneBallHangeIkChain_0, 16
{
EaglAnim::IkChain_0 Base;
i16 mBeginBone;
i16 mHingeBone;
i16 mEndBone;
f32 mABC2;
f32 m2AB;
EA::Math::Vector4 mHinge;
EA::Math::Vector4 mPoleVector;
EA::Math::Quaternion mPreRotateQ;
EA::Math::Vector4 mRotateAxis;
EA::Math::Vector4 mContact;
}
EaglAnim::Ik_0, 16
{
i16 mSkeletonSignature;
i16 mNumIkChains;
i16 mNumTwoBoneBallHangeIkChains;
i16 mNumOneBoneBallIkChains;
i8 *mPriorityIndices;
i32 mPad;
EaglAnim::TwoBoneBallHangeIkChain_0 mTwoBoneBallHangeIkChains[mNumTwoBoneBallHangeIkChains];
EaglAnim::OneBoneBallIkChain_0 mOneBoneBallIkChains[mNumOneBoneBallIkChains];
i8 mPriorityIndices[mNumIkChains];
}
EaglAnim::RootAnim::PosCompressed_0
{
i16 mX;
i16 mZ;
}
EaglAnim::RootAnim::FacingCompressed_0
{
i16 mValue;
}
EaglAnim::RootAnim_0, 16
{
EaglAnim::Animation_0 Base;
f32 mInvertStep;
f32 mPosScale;
i16 mNumCompressedFrames;
i8 mPad[2];
EaglAnim::RootAnim::PosCompressed_0 mPositions[mNumCompressedFrames];
EaglAnim::RootAnim::FacingCompressed_0 mFacings[mNumCompressedFrames];
}
EaglAnim::RootPosEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
}
EaglAnim::RootFacingEval_0, 16
{
EaglAnim::Evaluator_0 Base;
EaglAnim::ExternalVariable_0 mExternalVariables[Base.mNumExternalVariables];
}
effectStructsCustomTypes.txt[edit | edit source]
////////////////////////////////////////////////////////////////////////////
// //
// GENERATED FILE!! DO NOT MODIFY!! //
// //
// (changes should be made to effectStructsCustomTypes.txt instead) //
// //
////////////////////////////////////////////////////////////////////////////
// Alignment structures.
// Use these in front of variables within a structure that needs to be aligned.
Align4,4
{
}
Align8,8
{
}
Align16,16
{
}
Align32,32
{
}
Align64,64
{
}
Align128,128
{
}
DoubleLinkedListPtrNode
{
i32 mPrior; /* These are really pointers, but should NEVER be output in pipeline */
i32 mNext; /* These are really pointers, but should NEVER be output in pipeline */
}
ManagedPointer
{
DoubleLinkedListPtrNode mInheritedData; /* This is really inherited and not a member */
ptr mData;
i16 mOffsetToAuxData;
i16 mCallbackStructIndex;
}
ExternalVariable
{
String mType;
String mName;
AssetName mAssetName;
i32 mData; /* THIS IS A HORRIBLE CHEAT!, These pointers should be into data that is added */
i32 mVariable; /* THIS IS A HORRIBLE CHEAT!, These pointers should be into data that is added */
}
ExternalVariableArray
{
i32 mLength;
ExternalVariable mData[mLength];
}
DataObject
{
String mType;
ptr mUserData;
i32 mNumExternalVariables;
i32 mGetExternalVariableHandler;
}
// Create the struct definitions for the geometries and indices
// Add the struct definitions
ByteArray
{
i32 mLength;
i8 mData[mLength];
}
IntArray
{
i32 mLength;
i32 mData[mLength];
}
PointerArray
{
i32 mLength;
ptr mData[mLength];
}
Vector3
{
f32 x;
f32 y;
f32 z;
}
Vector3Array
{
i32 mLength;
Vector3 mData[mLength];
}
Vector2
{
f32 x;
f32 y;
}
Vector2Array
{
i32 mLength;
Vector2 mData[mLength];
}
StringArray
{
i32 mLength;
String mData[mLength];
}
PacketStreamHeader
{
i32 mLength;
void *mpData;
i16 *mpBackMapping;
void *mpVertexHeader;
}
StreamHeader
{
String mName;
StreamHeader *mpNext;
i32 mSourceStride; // Stride, in bytes, for the raw uncompiled data.
i32 mCompiledStride; // Stride, in bytes, for the compiled data.
i32 mCompiledSize; // Size of a compiled element in the stream in bytes. Normally the same as mCompiledStride unless the destination stream is interleaved.
i32 mCompressFunction;
i32 mDecompressFunction;
i32 mSourceLength; // Number of elements in the source stream.
i32 mNumPackets;
PacketStreamHeader mPacketData[mNumPackets];
}
StreamHeaderArray
{
i32 mNumStreamHeaders;
StreamHeader mData[mNumStreamHeaders];
}
MorphTargetInfo
{
f32 mScale;
f32 mOffset;
i32 mMorphTargetNum;
}
MorphData
{
i32 mNum4Byte;
i32 mNum2Byte;
i32 mNum1Byte;
i32 m4Bytes[mNum4Byte]; // could be floats or ints -- this is just for endian-conversion
i16 m2Bytes[mNum2Byte];
i8 m1Bytes[mNum1Byte];
}
MorphStreamHeader
{
AssetName mName;
i8 mStreamDescription[7];
i8 mFixedPointType;
i32 mLength;
void *mpData;
i8 *mpRunLengthData;
i32 mNumMorphTargets;
MorphTargetInfo mMorphTargetList[mNumMorphTargets];
}
MorphTargetNameArray
{
i32 mNumMorphTargets;
AssetName mTargetNames[mNumMorphTargets];
}
Morph
{
AssetName mName;
i32 mMorphTypeFlag;
i8 mMonth; // This data is a union with mpToEboFileAllocation.
i8 mDay; // Since mpToEboFileAllocation is never written out
i8 mHour; // by the pipeline, and this data IS written out by
i8 mMinutes; // the pipeline, this works better for endian conversion.
MorphTargetNameArray *mMorphTargets;
i32 mNumStreams;
MorphStreamHeader *mpMorphStreamHeaders[mNumStreams];
}
WeightBoneQuad
{
f32 weight0;
f32 weight1;
f32 weight2;
f32 weight3;
i32 boneIndex0;
i32 boneIndex1;
i32 boneIndex2;
i32 boneIndex3;
}
WeightBoneQuadArray
{
i32 mLength;
WeightBoneQuad mData[mLength];
}
GeoPrim
{
i32 mNumVerts;
i32 mIndicesMask;
ptr mpMatrix;
ptr mpCamera;
ptr mpPoseMatrices;
ptr mpTexture;
ptr mCoordinateStream;
ptr mUVStream;
ptr mColourStream;
ptr mWeightStream;
ptr mCoordinateIndices;
ptr mUVIndices;
ptr mColourIndices;
ptr mWeightIndices;
}
GeoPrimArray
{
i32 mLength;
GeoPrim mData[mLength];
}
OldGeometry
{
DataObject mDataObject; // Inherited data object
AssetName mName;
ptr mpExternalVariableArray;
i32 mNumStreams;
ptr mStreamHeaderArray;
i32 mNumGeoPrims;
ptr mGeoPrimArray;
i32 mGeometryTypeFlags;
ManagedPointer mManagedPointerToBaseGeometry;
i32 mpToEboFileAllocation; /* Only non null in runtime compiled version from GetResult */
}
Material
{
ptr mRenderMethod;
ptr mExternalVariables;
ptr mVars;
ptr mPerMaterialVars;
Vector3 mCompressScale; /* TODO: remove*/
Vector3 mCompressOffset; /* TODO: remove*/
i32 mNumStreams;
StreamHeader *mStreamHeaderArray;
}
BoundingInfo
{
Vector3 min;
Vector3 max;
Vector3 center;
f32 radius;
}
GeometryFlags
{
i8 mType; // see GeometryTypeFlags
i8 mIsDirty; // 1 if SetStream or ApplyMorph was called
i8 mPad1; // pad to 32bit
i8 mPad2; // pad to 32bit
}
Geometry
{
DataObject mDataObject;
AssetName mName;
i32 mNumMaterials;
Material *mMaterials;
i32 mNumExternalVariables;
ExternalVariable *mExternalVariables;
ManagedPointer mManagedPointerToBaseGeometry;
GeometryFlags mFlags;
i8 mMonth; // This data is a union with mpToEboFileAllocation.
i8 mDay; // Since mpToEboFileAllocation is never written out
i8 mHour; // by the pipeline, and this data IS written out by
i8 mMinutes; // the pipeline, this works better for endian conversion.
BoundingInfo *mBoundingInfo;
i32 mModelMatrixExtVarIndex;
StringArray *mExportedStreamList;
}
FlipBookGeometry
{
Geometry **mGeometryArray;
i32 mNumGeometries;
ExternalVariable mIndex;
i32 mIsPipelineConstructed;
}
MultiBufferGeometry
{
Geometry **mGeometryArray;
i32 *mFrameNumberArray;
i32 mNumGeometries;
i32 mDrawIndex;
i32 mEditIndex;
i32 mIsPipelineConstructed;
}
//////////////////////////////////
// User defined type definitions
// PRIVATE TYPES
// CMN Private Type
CmnTypeImage
{
String mName;
i32 mByteSize;
String mCType;
String mEa3Type;
String mEboStruct;
}
// GC Private Type
GcTypeImage
{
i32 mComponentType;
i32 mComponentCount;
i8 mFixedPointLocation;
}
// PC Private Type
PcTypeImage
{
i32 mRegLines;
i32 mVertexDesc;
i32 mFVFDesc;
i32 mShaderVarConstType;
}
// PS2 Private Type
Ps2TypeImage
{
i32 mVuLines;
i32 mVcUnpack;
i32 mNumVifCodes;
i32 *mVifCodeSnippet;
}
// XBOX Private Type
XboxTypeImage
{
i32 mRegLines;
i32 mVertexDesc;
}
// PUBLIC TYPES
// CMN
BaseRMSType
{
CmnTypeImage mCmnTypeImage;
}
// PS2
PS2RMSType
{
BaseRMSType mCmnTypeImage;
Ps2TypeImage mPs2TypeImage;
}
// XBOX
XBOXRMSType
{
BaseRMSType mCmnTypeImage;
XboxTypeImage mXboxTypeImage;
}
// PC
PCRMSType
{
BaseRMSType mCmnTypeImage;
PcTypeImage mPcTypeImage;
}
//GC
GCRMSType
{
BaseRMSType mCmnTypeImage;
GcTypeImage mGcTypeImage;
}
// End user defined type defintions
//////////////////////////////////
//////////////////////////////////
// RenderMethod Struct definitions
ArraySpec
{
i32 mCount;
String mVarName;
}
DefaultInput
{
// TODO: Fill the runtime structure with something;
i32 foo;
}
VarName
{
i32 mType;
String mName;
AssetName mAssetName;
}
Assignment
{
i32 mIsConstantList;
i32 mNumExpressions;
Expression *mExpressions;
}
RenderMethodInputVariable
{
i32 mFlag;
BaseRMSType *mType;
String mTypeName;
VarName mName;
ArraySpec mCount;
String mBoundStream;
}
PlatformVariableModifierParameters
{
i32 mNumIdentifiers;
String *mIdentifiers;
}
BaseRenderMethodPlatformVariable
{
i32 mPlatformVariableType;
PlatformVariableModifierParameters mModifierParameters;
BaseRMSType *mType;
String mTypeName;
String mName;
i32 mArraySize;
String mActualArraySizeVariableName;
i32 mPacketArraySize;
i32 mPlatformVariableFlag;
i32 mIsFilledByVertexFormat;
i32 mAddress;
i32 mNumRegLines;
}
Function
{
String mName;
i32 mNumParameters;
Expression *mParameters;
String mTempVariableName;
}
Expression
{
i32 mType;
i32 mBool;
String mString;
Expression *mpLeft;
Expression *mpRight;
VarName mVarName;
Function mFunction;
i32 mInt;
f32 mFloat;
}
Statement
{
String mRefDerefMarkers;
VarName mLhsAssignment;
Expression mExpression;
i32 mNumPrereqExternVariables;
i32 *mPrereqExternVariableIndices;
i32 mNumPrereqPerMaterialVariables;
i32 *mPrereqPerMaterialVariableIndices;
i32 mNumPrereqConstants;
i32 mStateIsAnOutput;
}
GcBindSpec
{
i32 mBindType;
i32 mVertexComponent;
VarName mStreamVar;
VarName mIndexVar;
VarName mDataVar;
VarName mPrimVar;
}
GcTexCoordMatrix
{
i32 mIsVarName;
VarName mVarName;
}
GcTexGen
{
i32 mTexCoordOutputNum;
VarName mInputStream;
i32 mToNormalize;
i32 mHasTexCoordMatrix;
GcTexCoordMatrix mTexCoordMatrix;
i32 mTexCoordMatrixDimension;
i32 mHasPostTransformMatrix;
VarName mPostTransformMatrix;
}
VertexShader
{
i32 mNumParameters;
Expression *mParameters;
i32 mNumComputations;
Function *mComputations;
i32 mNumGcBindSpecs;
GcBindSpec *mGcBindSpecs;
i32 mNumGcTexGens;
GcTexGen *mGcTexGens;
i32 mIsGcSpecific;
}
GcTevEquation
{
String mOutRegEnumStr;
i32 mIsClamped;
i32 mTevOp;
f32 mBias;
f32 mScale;
// Colour/Alpha inputs
String mA;
String mB;
String mC;
String mD;
}
GcTevTexMapCoordColourStreamConstColour
{
i32 mHasInputTextureMapId;
i32 mInputTextureMapId;
i32 mHasTexCoordInputNum;
i32 mTexCoordInputNum;
i32 mHasColourStreamVar;
VarName mColourStreamVar;
i32 mHasConstColourVar;
VarName mConstColourVar;
}
GcTevStage
{
i32 mStageNumber;
GcTevTexMapCoordColourStreamConstColour mGcTevTexMapCoordColourStreamConstColour;
GcTevEquation mColourEquation;
GcTevEquation mAlphaEquation;
}
GcTevRegColour
{
i32 mRegNumber;
VarName mRegVar;
}
PixelShader
{
i32 mNumComputations;
Function *mComputations;
i32 mNumGcTevStages;
GcTevStage *mGcTevStages;
i32 mNumGcTevRegColours;
GcTevRegColour *mGcTevRegColours;
i32 mIsGcSpecific;
}
Shader
{
Expression mRootNode;
i32 mNumShaderBodies;
ShaderBody *mShaderBodies;
}
ShaderBody
{
i32 mHasVertexShader;
VertexShader mVertexShader;
i32 mHasPixelShader;
PixelShader mPixelShader;
Function mComputation;
}
CompilerFlag
{
String mFlagName;
i32 mNumParameters;
Expression *mParameters;
}
RenderMethodPlatformData
{
i32 mPlatformId;
i32 mNumIncludes;
String *mIncludes;
i32 mNumCompilerFlags;
CompilerFlag *mCompilerFlags;
i32 mNumPlatformVariables;
BaseRenderMethodPlatformVariable *mPlatformVariables;
String mVertexFormatName;
i32 mNumStatements;
Statement *mStatements;
i32 mNumShaders;
Shader *mShaders;
}
GcVertexBind
{
i32 mVertexComponent;
i32 mStreamVarIndex;
i32 mIndicesVarIndex;
}
GcShaderSection
{
i32 mPrimTypeVarIndex;
i32 mNumVertexBinds;
GcVertexBind *mVertexBinds;
}
PlatformShaders
{
i32 mNumShaderSections;
i32 mOutputPlatform;
ptr mPlatformShaderSection;
}
RenderMethod
{
i32 mPlatform;
String mName;
i32 mNumInputVariables;
RenderMethodInputVariable *mInputVariables;
String mVertexFormatName;
i32 mNumOutputVariables;
BaseRenderMethodPlatformVariable *mOutputVariables;
PlatformShaders *mPlatformExtensionModule;
}
PrivateRenderMethod
{
String mName;
i32 mNumInputVariables;
RenderMethodInputVariable *mInputVariables;
i32 mNumPlatformDataSections;
RenderMethodPlatformData *mPlatformData;
}
//END RenderMethod Struct definitions
//////////////////////////////////
//////////////////////////////////
// XBOX VertexBuffer definitions
XBOXD3DVertexBufferMemImage
{
i32 mCommon;
i32 *mData;
i32 mLock;
}
XBOXVertexBuffer
{
XBOXD3DVertexBufferMemImage mBaseTypeInfo;
i32 mByteSize;
i32 mStride;
i32 mRegistered;
i32 *mData;
}
// End XBOXVertexBuffer definitions
//////////////////////////////////
/////////////////////////////////////
// PC VertexBuffer definition
PCVertexBuffer
{
i32 mSizeInBytes;
i32 mStride;
i32 *mpData;
i32 *mpVertexBuffer;
i32 mFVF;
i32 mUsage;
i32 mDirty;
}
PCIndexBuffer
{
i32 mSizeInBytes;
i32 mStride;
i32 *mpData;
i32 *mpIndexBuffer;
i32 mUsage;
i32 mVertexShaderID;
}
PCDataBuffers
{
PCIndexBuffer *mpIndexBufferMemImage;
i32 mBufferOffset;
i32 mNumElem;
i32 mNumVertexBuffers;
void *mpBatch;
PCVertexBuffer *mpVertexBufferMemImages[mNumVertexBuffers];
}
// PC VertexBuffer definitions
//////////////////////////////////
/////////////////////////////////////
// GC vertex stream definition
GCVertexStream
{
i32 mSizeInBytes;
i32 mStride;
i32 *mpData;
}
GcIndexData
{
i32 mAttrType;
}
// The display list in here needs to be 32-byte aligned. There must be a better way
GcDisplayList,32
{
i32 mDisplayListLength;
i8 pad[28];
i8 mDisplaylist[mDisplayListLength];
}
GcCommandBuffer
{
GcDisplayList **mDisplayLists;
}
//
//////////////////////////////////
/////////////////////////////////////
// Types used by rms type definitions
// If you need more types for rms types then they have to be added here
PrimitiveType
{
i32 prim;
}
Float2
{
f32 x;
f32 y;
}
Float3
{
f32 x;
f32 y;
f32 z;
}
Float4, 16
{
f32 x;
f32 y;
f32 z;
f32 w;
}
Float4d16, 16
{
i16 x;
i16 y;
i16 z;
i16 w;
}
Short3, 2
{
i16 x;
i16 y;
i16 z;
}
Short2, 2
{
i16 x;
i16 y;
}
Char3, 1
{
i8 x;
i8 y;
i8 z;
}
Char2, 1
{
i8 x;
i8 y;
}
R6G6B6A6, 1
{
i8 colourByte1;
i8 colourByte2;
i8 colourByte3;
}
R4G4B4A4, 2
{
i16 colour;
}
R5G6B5, 2
{
i16 colour;
}
Matrix4, 16
{
Float4 _1;
Float4 _2;
Float4 _3;
Float4 _4;
}
Int4, 16
{
i32 x;
i32 y;
i32 z;
i32 w;
}
Colour
{
i32 colour;
}
PS2DrawBufferBlock
{
ptr vifBuffer;
i32 vifCnt;
}
LightBlock, 16
{
Float4 mDiffuseDir0;
Float4 mDiffuseDir1;
Float4 mDiffuseDir2;
Float4 mDiffuseColour0;
Float4 mDiffuseColour1;
Float4 mDiffuseColour2;
Float4 mAmbientColour;
}
IrradLightBlock, 16
{
Float4 Coeff[10];
}
PrimTag, 16
{
i32 someData[8];
}
//--------------------------------
// Following Are PS2 VIF Types For
// Use By The GeometryCompiler
Float_VIF
{
f32 mf32;
}
Float2_VIF
{
f32 x;
f32 y;
}
Float2d16_VIF
{
i16 x;
i16 y;
}
Float3_VIF
{
f32 x;
f32 y;
f32 z;
}
Float4_VIF
{
f32 x;
f32 y;
f32 z;
f32 w;
}
Float4d16_VIF
{
i16 x;
i16 y;
i16 z;
i16 w;
}
Matrix4_VIF
{
Float4_VIF _1;
Float4_VIF _2;
Float4_VIF _3;
Float4_VIF _4;
}
I16_VIF
{
i16 mi16;
}
I32_VIF
{
i32 mi32;
}
Int4_VIF
{
i32 _1;
i32 _2;
i32 _3;
i32 _4;
}
Colour_VIF
{
i32 colour;
}
PrimTag_VIF
{
i32 someData[8];
}
PS2DMATag, 16
{
i16 tag;
i16 qwc;
ptr addr;
i32 tte1;
i32 tte2;
}
// End RMS user type definitions
/////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// Define custom types.
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
CrowdStructure, 16
{
Matrix4 modelMatrix;
Float4 colour;
Float4 uvOffset;
}
NHLCrowdStructure, 16
{
Float4 translateAndIndex;
Float4 uvOffsetColourFactor;
}
Float3d16_VIF, 2
{
i16 x;
i16 y;
i16 z;
}