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];
}