Porting OpenGL app to Metal API

Question

In OpenGL I got this ( shortened code )

void Mesh::CreateBuffer() { 
    glBindBuffer( GL_ARRAY_BUFFER, m_Buffers[POS_VB] );
    glBufferData( GL_ARRAY_BUFFER, sizeof(Positions[0] /*vec3*/) * iVerticeNum, &Positions[0], GL_STATIC_DRAW );
    glEnableVertexAttribArray( POSITION_LOCATION );
    glVertexAttribPointer( POSITION_LOCATION, 3, GL_FLOAT, GL_FALSE, 0, 0 );

    // Fill index buffer.
    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_Buffers[INDEX_BUFFER] );
    glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof(Indices[0] /*unsigned int*/) * iIndiceNum, &Indices[0], GL_STATIC_DRAW );

}

void Mesh::Render() {

    // bind vertex arrays here!
    .....

    glDrawElements( GL_TRIANGLES, this->NumIndices, GL_UNSIGNED_INT, 0);
    ....
}

The code above is working perfectly in my engine. But when I've decided to port it to Metal API I got some problems, - it just renders half of model using index data, there are NO groups in its mesh, it's just simple mesh. But when I try to render it using vertice data ( drawPrimitives ) it renders fine.

Here's Metal code I am using to initialize and render my mesh:

    INIT
    ....
    // Initialize mesh.
    MetalMesh mesh;

    mesh.vertexBuffer = [MetalDataBase->device newBufferWithBytes:Positions/* Vertice data */
                                            length:sizeof(vec3) * iNumVertices
                                           options:MTLResourceOptionCPUCacheModeDefault];
    mesh.indexBuffer = [MetalDataBase->device newBufferWithBytes:Indices
                                           length:sizeof(unsigned int) * iNumIndices
                                          options:MTLResourceOptionCPUCacheModeDefault];

    DRAW
    // Drawing..
    [MetalDataBase->commandEncoder setVertexBuffer:metalResource->metalMeshes[index].vertexBuffer offset:0 atIndex:0];

    // DrawPrimitives renders mesh **fine**, as it should.
    //[MetalDataBase->commandEncoder drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:iVerticeNum]; 

    // But it doesn't, it just renders half of model,
    // while **iIndiceNum** is right number with its data.
    [MetalDataBase->commandEncoder drawIndexedPrimitives:MTLPrimitiveTypeTriangle indexCount:iIndiceNum indexType:MTLIndexTypeUInt32 indexBuffer:metalResource->metalMeshes[index].indexBuffer indexBufferOffset:0];

Answer 1

Okay, I've managed what's wrong. Similar thread can be found here: http://www.gamedev.net/topic/544669-d3d9-only-1st-submesh-renders-w-indexed-vertexbuffer-solved/

Soo, firstly, I am using several sub meshes, in OpenGL I have something like this:

    // Count the number of vertices and indices
    for( unsigned int i = 0; i < pScene->mNumMeshes; ++i ) {
        m_Entries[i].MaterialIndex = pScene->mMeshes[i]->mMaterialIndex;
        m_Entries[i].NumIndices    = (pScene->mMeshes[i]->mNumFaces * VerticesPerPrim);
        m_Entries[i].NumVertices   = pScene->mMeshes[i]->mNumVertices;
        m_Entries[i].BaseVertex    = NumVertices;
        m_Entries[i].BaseIndex     = NumIndices;

        Con::Printf( LOG_INFO, "\t\tMesh #%i: %i vertices and %i indices\r\n", i, NumVertices, NumIndices );

        NumVertices += pScene->mMeshes[i]->mNumVertices;
        NumIndices  += m_Entries[i].NumIndices;
    }

    .... load bones, textures etc..

    // Load INDEXIES(haha) data now
    if(something) { ..
        for( unsigned int i = 0; i < paiMesh->mNumFaces; ++i ) {
            const aiFace & Face = paiMesh->mFaces[i];

            //if( Face.mNumIndices == 3 ) {
                Indices[iIndiceNum] = Face.mIndices[0]; ++iIndiceNum;
                Indices[iIndiceNum] = Face.mIndices[1]; ++iIndiceNum;
                Indices[iIndiceNum] = Face.mIndices[2]; ++iIndiceNum;
            //}
        }
     }

But after some raging and hair pulling I found a link I posted before, it helped me ( look into the last post ). So in Metal I have something like this now: ( notice the '+NumVertices' in the second line in 'for' loop )

    const unsigned int VerticesPerPrim = m_withAdjacencies ? 6 : 3;

    // Count the number of vertices and indices
    for( unsigned int i = 0; i < pScene->mNumMeshes; ++i ) {
        m_Entries[i].MaterialIndex = pScene->mMeshes[i]->mMaterialIndex;
        m_Entries[i].NumIndices    = (pScene->mMeshes[i]->mNumFaces * VerticesPerPrim)  + NumVertices ;
        m_Entries[i].NumVertices   = pScene->mMeshes[i]->mNumVertices;
        m_Entries[i].BaseVertex    = NumVertices;
        m_Entries[i].BaseIndex     = NumIndices;

        g_Console->Print( LOG_INFO, "\t\tMesh #%i: %i vertices and %i indices\r\n", i, NumVertices, NumIndices );

        NumVertices += pScene->mMeshes[i]->mNumVertices;
        NumIndices  += m_Entries[i].NumIndices;
    }


    .. load bones, textures, etc now....

    // Load INDEXIEES data
    if( something ) {
      int offset = 0;

        if( MeshIndex > 0 )
            for ( int k = 0; k < MeshIndex; k++ )
                offset += wtf->mMeshes[k]->mNumVertices;

        for( unsigned int i = 0; i < paiMesh->mNumFaces; ++i ) {
            const aiFace & Face = paiMesh->mFaces[i];

            //if( Face.mNumIndices == 3 ) {
                Indices[iIndiceNum] = Face.mIndices[0] + offset; ++iIndiceNum;
                Indices[iIndiceNum] = Face.mIndices[1] + offset; ++iIndiceNum;
                Indices[iIndiceNum] = Face.mIndices[2] + offset; ++iIndiceNum;
            //}
        }
    }

Haha, thanks for 'indexes', 'vertexes' grammar tips.

Here's how I render it using Metal:

// index = mesh index in Metal API(kinda array)
for( int i = 0; i < mesh[j]->mNumMeshes; ++i ) 
[MetalDataBase->commandEncoder drawIndexedPrimitives:MTLPrimitiveTypeTriangle indexCount:m_Entries[i].numIndices indexType:MTLIndexTypeUInt32 indexBuffer:metalResource->metalMeshes[index].indexBuffer indexBufferOffset:0];

Soo, now I got fully loaded mesh ( and its sub meshes ):