//---------------------------------------------------------------------------------------------------------------------
MFInitStatus MFPrimitive_InitModule(int moduleId, bool bPerformInitialisation)
{
MFVertexElement elements[4];
// write declaration
elements[0].stream = 0;
elements[0].type = MFVET_Position;
elements[0].index = 0;
elements[0].componentCount = 3;
elements[0].format = MFVDF_Float3;
elements[1].stream = 0;
elements[1].type = MFVET_Normal;
elements[1].index = 0;
elements[1].componentCount = 3;
elements[1].format = MFVDF_Float3;
elements[2].stream = 0;
elements[2].type = MFVET_Colour;
elements[2].index = 0;
elements[2].componentCount = 4;
elements[2].format = MFVDF_UByte4N_BGRA;
elements[3].stream = 0;
elements[3].type = MFVET_TexCoord;
elements[3].index = 0;
elements[3].componentCount = 2;
elements[3].format = MFVDF_Float2;
pDecl = MFVertex_CreateVertexDeclaration(elements, 4);
MFDebug_Assert(pDecl, "Failed to create vertex declaration..");
pIdentity = MFStateBlock_Create(128);
MFStateBlock_SetMatrix(pIdentity, MFSCM_World, MFMatrix::identity);
return MFIS_Succeeded;
}
void BuildVertexBuffers()
{
struct Vertex
{
float pos[3];
float uv[2];
uint32 col;
};
// create vertex format declaration
MFVertexElement elements[] =
{
{ 0, MFVET_Position, 0, 3 },
{ 0, MFVET_TexCoord, 0, 2 },
{ 0, MFVET_Colour, 0, 4 }
};
pVertexDecl = MFVertex_CreateVertexDeclaration(elements, sizeof(elements)/sizeof(elements[0]));
// create box vertex buffer
Vertex prism[4 * 3] = // 4 triangles, 1 per face
{
{ { 1, -1, -1 }, { 0, 0 }, 0xFFFF0000 },
{ { -1, -1, -1 }, { 0, 0 }, 0xFFFF0000 },
{ { 0, 1, 0 }, { 0, 0 }, 0xFFFF0000 },
{ { -1, -1, -1 }, { 0, 0 }, 0xFF00FF00 },
{ { -1, -1, 1 }, { 0, 0 }, 0xFF00FF00 },
{ { 0, 1, 0 }, { 0, 0 }, 0xFF00FF00 },
{ { -1, -1, 1 }, { 0, 0 }, 0xFF0000FF },
{ { 1, -1, 1 }, { 0, 0 }, 0xFF0000FF },
{ { 0, 1, 0 }, { 0, 0 }, 0xFF0000FF },
{ { 1, -1, 1 }, { 0, 0 }, 0xFFFFFF00 },
{ { 1, -1, -1 }, { 0, 0 }, 0xFFFFFF00 },
{ { 0, 1, 0 }, { 0, 0 }, 0xFFFFFF00 }
};
pPrismVertexBuffer = MFVertex_CreateVertexBuffer(pVertexDecl, 4*3, MFVBType_Static, prism);
pPrismMeshStateBlock = MFStateBlock_Create(64);
MFStateBlock_SetRenderState(pPrismMeshStateBlock, MFSCRS_VertexDeclaration, pVertexDecl);
MFStateBlock_SetRenderState(pPrismMeshStateBlock, MFSCRS_VertexBuffer(0), pPrismVertexBuffer);
// create box vertex buffer
Vertex box[12 * 3] = // 12 triangles, 2 per 6 faces of a cube
{
{ { -1, -1, -1 }, { 0, 0 }, 0xFFFFFFFF },
{ { -1, 1, -1 }, { 1, 0 }, 0xFFFFFFFF },
{ { 1, 1, -1 }, { 1, 1 }, 0xFFFFFFFF },
{ { -1, -1, -1 }, { 0, 0 }, 0xFFFFFFFF },
{ { 1, 1, -1 }, { 1, 1 }, 0xFFFFFFFF },
{ { 1, -1, -1 }, { 0, 1 }, 0xFFFFFFFF },
{ { -1, -1, 1 }, { 0, 0 }, 0xFFFFFFFF },
{ { 1, -1, 1 }, { 1, 0 }, 0xFFFFFFFF },
{ { 1, 1, 1 }, { 1, 1 }, 0xFFFFFFFF },
{ { -1, -1, 1 }, { 0, 0 }, 0xFFFFFFFF },
{ { 1, 1, 1 }, { 1, 1 }, 0xFFFFFFFF },
{ { -1, 1, 1 }, { 0, 1 }, 0xFFFFFFFF },
{ { 1, -1, 1 }, { 0, 0 }, 0xFFFFFFFF },
{ { 1, -1, -1 }, { 1, 0 }, 0xFFFFFFFF },
{ { 1, 1, -1 }, { 1, 1 }, 0xFFFFFFFF },
{ { 1, -1, 1 }, { 0, 0 }, 0xFFFFFFFF },
{ { 1, 1, -1 }, { 1, 1 }, 0xFFFFFFFF },
{ { 1, 1, 1 }, { 0, 1 }, 0xFFFFFFFF },
{ { -1, -1, 1 }, { 0, 0 }, 0xFFFFFFFF },
{ { -1, 1, 1 }, { 1, 0 }, 0xFFFFFFFF },
{ { -1, 1, -1 }, { 1, 1 }, 0xFFFFFFFF },
{ { -1, -1, 1 }, { 0, 0 }, 0xFFFFFFFF },
{ { -1, 1, -1 }, { 1, 1 }, 0xFFFFFFFF },
{ { -1, -1, -1 }, { 0, 1 }, 0xFFFFFFFF },
{ { -1, 1, 1 }, { 0, 0 }, 0xFFFFFFFF },
{ { 1, 1, 1 }, { 1, 0 }, 0xFFFFFFFF },
{ { 1, 1, -1 }, { 1, 1 }, 0xFFFFFFFF },
{ { -1, 1, 1 }, { 0, 0 }, 0xFFFFFFFF },
{ { 1, 1, -1 }, { 1, 1 }, 0xFFFFFFFF },
{ { -1, 1, -1 }, { 0, 1 }, 0xFFFFFFFF },
{ { -1, -1, 1 }, { 0, 0 }, 0xFFFFFFFF },
{ { -1, -1, -1 }, { 1, 0 }, 0xFFFFFFFF },
{ { 1, -1, -1 }, { 1, 1 }, 0xFFFFFFFF },
{ { -1, -1, 1 }, { 0, 0 }, 0xFFFFFFFF },
{ { 1, -1, -1 }, { 1, 1 }, 0xFFFFFFFF },
{ { 1, -1, 1 }, { 0, 1 }, 0xFFFFFFFF }
};
pBoxVertexBuffer = MFVertex_CreateVertexBuffer(pVertexDecl, 12*3, MFVBType_Static, box);
pBoxMeshStateBlock = MFStateBlock_Create(64);
MFStateBlock_SetRenderState(pBoxMeshStateBlock, MFSCRS_VertexDeclaration, pVertexDecl);
MFStateBlock_SetRenderState(pBoxMeshStateBlock, MFSCRS_VertexBuffer(0), pBoxVertexBuffer);
}
MF_API MFVertexDeclaration *MFVertex_CreateVertexDeclaration(const MFVertexElement *pElementArray, int elementCount)
{
// assign the auto format components before calculating the hash
MFVertexElement elements[16];
MFCopyMemory(elements, pElementArray, sizeof(MFVertexElement)*elementCount);
for(int e=0; e<elementCount; ++e)
{
if(pElementArray[e].format == MFVDF_Auto)
elements[e].format = MFVertex_ChoooseVertexDataTypePlatformSpecific(pElementArray[e].type, pElementArray[e].componentCount);
}
uint32 hash = MFUtil_HashBuffer(elements, sizeof(MFVertexElement)*elementCount);
MFVertexDeclaration *pDecl = (MFVertexDeclaration*)MFResource_Find(hash);
if(!pDecl)
{
pDecl = (MFVertexDeclaration*)MFHeap_AllocAndZero(sizeof(MFVertexDeclaration) + (sizeof(MFVertexElement) + sizeof(MFVertexElementData))*elementCount);
pDecl->numElements = elementCount;
pDecl->pElements = (MFVertexElement*)&pDecl[1];
pDecl->pElementData = (MFVertexElementData*)&pDecl->pElements[elementCount];
MFCopyMemory(pDecl->pElements, elements, sizeof(MFVertexElement)*elementCount);
int streamOffsets[16];
MFZeroMemory(streamOffsets, sizeof(streamOffsets));
// set the element data and calculate the strides
for(int e=0; e<elementCount; ++e)
{
pDecl->pElementData[e].offset = streamOffsets[elements[e].stream];
pDecl->pElementData[e].stride = 0;
streamOffsets[elements[e].stream] += gVertexDataStride[elements[e].format];
pDecl->streamsUsed |= MFBIT(elements[e].stream);
}
// set the strides for each component
for(int e=0; e<elementCount; ++e)
pDecl->pElementData[e].stride = streamOffsets[elements[e].stream];
if(!MFVertex_CreateVertexDeclarationPlatformSpecific(pDecl))
{
MFHeap_Free(pDecl);
return NULL;
}
MFResource_AddResource(pDecl, MFRT_VertexDecl, hash);
if(pDecl->streamsUsed != 1)
{
// create the stream declarations...
MFVertexElement streamElements[64];
for(int s=0; s<16; ++s)
{
if(!(pDecl->streamsUsed & (1 << s)))
continue;
int numStreamElements = 0;
for(int e=0; e<elementCount; ++e)
{
if(elements[e].stream == s)
{
streamElements[numStreamElements] = elements[e];
streamElements[numStreamElements].stream = 0;
++numStreamElements;
}
}
if(numStreamElements)
pDecl->pStreamDecl[s] = MFVertex_CreateVertexDeclaration(streamElements, numStreamElements);
}
}
}
return pDecl;
}