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);
}
static void MFRenderer_RenderElements(MFRendererState &state, MFRenderElement *pElements, int numElements)
{
// set and mask the Layer + Override states
MFRenderer_ApplyRenderStates(state, state.pStateBlocks + MFSBT_Layer, MFSBT_Max - MFSBT_Layer);
MFCopyMemory(state.rsMask, state.rsSet, sizeof(state.rsMask));
// for each render element
for(int e=0; e<numElements; ++e)
{
MFRenderElement &element = pElements[e];
// collect state blocks
state.pStateBlocks[MFSBT_View] = element.pViewState;
state.pStateBlocks[MFSBT_Entity] = element.pEntityState;
state.pStateBlocks[MFSBT_Material] = element.pMaterialState;
state.pStateBlocks[MFSBT_Geometry] = element.pGeometryState;
state.pStateBlocks[MFSBT_MaterialOverride] = element.pMaterialOverrideState;
// gather render states
MFRenderer_ApplyRenderStates(state, state.pStateBlocks, MFSBT_Layer);
// select the technique here? or do it inside RenderElement()?
//...
// selection criteria:
// - animation
// - lights
// - constants present
// - values of constants?
#if defined(DEBUG)
// check that all required states are set
MFRenderer_CheckRequirements(state, element);
#endif
// apply render state
element.pMaterial->pType->materialCallbacks.pBegin(element.pMaterial, state);
// set geometry buffers
MFVertexDeclaration *pDecl = (MFVertexDeclaration*)state.pRenderStates[MFSCRS_VertexDeclaration];
if(state.pRenderStatesSet[MFSCRS_VertexDeclaration] != pDecl)
{
state.pRenderStatesSet[MFSCRS_VertexDeclaration] = pDecl;
MFVertex_SetVertexDeclaration(pDecl);
}
for(int vb = 0; vb < 8; ++vb)
{
if(pDecl->streamsUsed & MFBIT(vb))
{
MFVertexBuffer *pVB = (MFVertexBuffer*)state.pRenderStates[MFSCRS_VertexBuffer(vb)];
if(state.pRenderStatesSet[MFSCRS_VertexBuffer(vb)] != pVB)
{
state.pRenderStatesSet[MFSCRS_VertexBuffer(vb)] = pVB;
MFVertex_SetVertexStreamSource(vb, pVB);
}
}
}
// render
if(element.renderIndexed)
{
if(state.pRenderStatesSet[MFSCRS_IndexBuffer] != state.pRenderStates[MFSCRS_IndexBuffer])
{
MFIndexBuffer *pIB = (MFIndexBuffer*)state.pRenderStates[MFSCRS_IndexBuffer];
state.pRenderStatesSet[MFSCRS_IndexBuffer] = pIB;
MFVertex_SetIndexBuffer(pIB);
}
MFVertexBuffer *pVB = (MFVertexBuffer*)state.pRenderStates[MFSCRS_VertexBuffer0];
int numVertices = pVB->numVerts - (int)element.vertexBufferOffset;
MFVertex_RenderIndexedVertices(state.pTechniqueSet, (MFPrimType)element.primType, element.vertexBufferOffset, element.indexBufferOffset, numVertices, element.vertexCount);
}
else
{
MFVertex_RenderVertices(state.pTechniqueSet, (MFPrimType)element.primType, element.vertexBufferOffset, element.vertexCount);
}
}
}
