////////////////////////////////////////////////////////////////////////////

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