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

Float33
{
	f32 x0;
	f32 y0;
	f32 z0;
	f32 x1;
	f32 y1;
	f32 z1;
	f32 x2;
	f32 y2;
	f32 z2;
}

Float32
{
	f32 x0;
	f32 y0;
	f32 z0;
	f32 x1;
	f32 y1;
	f32 z1;
}

Float4, 16
{
	f32 x;
	f32 y;
	f32 z;
	f32 w;
}

Float4d16, 16
{
	i16 x;
	i16 y;
	i16 z;
	i16 w;
}

Short33, 2
{
	i16 x0;
	i16 y0;
	i16 z0;
	i16 x1;
	i16 y1;
	i16 z1;
	i16 x2;
	i16 y2;
	i16 z2;
}

Short32, 2
{
	i16 x0;
	i16 y0;
	i16 z0;
	i16 x1;
	i16 y1;
	i16 z1;
}

Short3, 2
{
	i16 x;
	i16 y;
	i16 z;
}

Short2, 2
{
	i16 x;
	i16 y;
}

Char3, 1
{
	i8 x;
	i8 y;
	i8 z;
}

Char33, 1
{
	i8 x0;
	i8 y0;
	i8 z0;
	i8 x1;
	i8 y1;
	i8 z1;
	i8 x2;
	i8 y2;
	i8 z2;
}

Char32, 1
{
	i8 x0;
	i8 y0;
	i8 z0;
	i8 x1;
	i8 y1;
	i8 z1;
}

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