////////////////////////////////////////////////////////////
// DrawUnsorted
////////////////////////////////////////////////////////////
bool MeshRender::DrawUnsorted(unsigned int iIndex)
{
    ai_assert(iIndex < scene->mNumMeshes);

    // set vertex and index buffer
    devices.d3ddev->SetStreamSource(0,apcMeshes[iIndex]->piVB,0,
        sizeof(Vertex));

    devices.d3ddev->SetIndices(apcMeshes[iIndex]->piIB);

    D3DPRIMITIVETYPE type;
    switch (scene->mMeshes[iIndex]->mPrimitiveTypes) {
        case aiPrimitiveType_POINT:
            type = D3DPT_POINTLIST;break;
        case aiPrimitiveType_LINE:
            type = D3DPT_LINELIST;break;
        case aiPrimitiveType_TRIANGLE:
            type = D3DPT_TRIANGLELIST;break;
    }
    // and draw the mesh
    devices.d3ddev->DrawIndexedPrimitive(type,
                                         0,0,
                                         scene->mMeshes[iIndex]->mNumVertices,0,
                                         scene->mMeshes[iIndex]->mNumFaces);

    return true;
}

////////////////////////////////////////////////////////////
// DrawSorted
////////////////////////////////////////////////////////////
bool MeshRender::DrawSorted(unsigned int iIndex,const aiMatrix4x4& mWorld)
{
    ai_assert(iIndex < scene->mNumMeshes);

    MeshHelper* pcHelper = apcMeshes[iIndex];
    const aiMesh* pcMesh = scene->mMeshes[iIndex];

    if (!pcHelper || !pcMesh || !pcHelper->piIB)
        return false;

    if (pcMesh->mPrimitiveTypes != aiPrimitiveType_TRIANGLE || pcMesh->HasBones())
        return DrawUnsorted(iIndex);


    // compute the position of the camera in worldspace
    aiMatrix4x4 mWorldInverse = mWorld;
    mWorldInverse.Inverse();
    mWorldInverse.Transpose();
    const aiVector3D vLocalCamera = mWorldInverse * aiVector3D(0.0f, 0.0f, 15.0f);

    // well ... this is really funny now. We must compute their distance
    // from the camera. We take the average distance of a face and add it
    // to a map which sorts it
    std::map<float,unsigned int, std::greater<float>> smap;

    for (unsigned int iFace = 0; iFace < pcMesh->mNumFaces;++iFace)
    {
        const aiFace* pcFace = &pcMesh->mFaces[iFace];
        float fDist = 0.0f;
        for (unsigned int c = 0; c < 3;++c)
        {
            aiVector3D vPos = pcMesh->mVertices[pcFace->mIndices[c]];
            vPos -= vLocalCamera;
            fDist += vPos.SquareLength();
        }
        smap.insert(std::pair<float, unsigned int>(fDist,iFace));
    }

    // now we can lock the index buffer and rebuild it
    D3DINDEXBUFFER_DESC sDesc;
    pcHelper->piIB->GetDesc(&sDesc);

    if (D3DFMT_INDEX16 == sDesc.Format)
    {
        uint16_t* aiIndices;
        pcHelper->piIB->Lock(0,0,(void**)&aiIndices,D3DLOCK_DISCARD);

        for (std::map<float,unsigned int, std::greater<float> >::const_iterator
            i =  smap.begin();
            i != smap.end();++i)
        {
            const aiFace* pcFace =  &pcMesh->mFaces[(*i).second];
            *aiIndices++ = (uint16_t)pcFace->mIndices[0];
            *aiIndices++ = (uint16_t)pcFace->mIndices[1];
            *aiIndices++ = (uint16_t)pcFace->mIndices[2];
        }
    }
    else if (D3DFMT_INDEX32 == sDesc.Format)
    {
        uint32_t* aiIndices;
        pcHelper->piIB->Lock(0,0,(void**)&aiIndices,D3DLOCK_DISCARD);

        for (std::map<float,unsigned int, std::greater<float>>::const_iterator
            i =  smap.begin();
            i != smap.end();++i)
        {
            const aiFace* pcFace =  &pcMesh->mFaces[(*i).second];
            *aiIndices++ = (uint32_t)pcFace->mIndices[0];
            *aiIndices++ = (uint32_t)pcFace->mIndices[1];
            *aiIndices++ = (uint32_t)pcFace->mIndices[2];
        }
    }
    pcHelper->piIB->Unlock();

    // set vertex and index buffer
    devices.d3ddev->SetStreamSource(0,pcHelper->piVB,0,sizeof(Vertex));

    // and draw the mesh
    devices.d3ddev->SetIndices(pcHelper->piIB);
    devices.d3ddev->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,
                                         0,0,
                                         pcMesh->mNumVertices,0,
                                         pcMesh->mNumFaces);

    return true;
}