C++ IDirect3DIndexBuffer9::Lock方法代码示例

bool CIndexBuffer::Cache(CDisplayDevice *poDisplayDevice) {
#if RENDER == DX9
	IDirect3DIndexBuffer9* IB;

	int len = sizeof(unsigned short) * m_iNumIndices; 
	HRESULT result = poDisplayDevice->m_pDevice->CreateIndexBuffer(
		len, 
		D3DUSAGE_WRITEONLY,
		D3DFMT_INDEX16, 
		D3DPOOL_SYSTEMMEM,
		&IB, 
		0);

	if (result != D3D_OK)
		return false;

	char *buffer;
	IB->Lock(0, 0, (void **)&buffer, 0);
	memcpy(buffer, GetIndexBuffer(), len);
	IB->Unlock();

	m_pCachedData = IB;
#endif

	return true;
}

void CubeDemo::buildIndexBuffer()
{
	HR(gd3dDevice->CreateIndexBuffer(36*sizeof(WORD), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_MANAGED, &mIB, 0));

	WORD *k = 0;
	HR(mIB->Lock(0, 0, (void**)&k, 0));

	// front
	k[0] = 0; k[1] = 1; k[2] = 2;
	k[3] = 0; k[4] = 2; k[5] = 3;

	// back
	k[6] = 4; k[7] = 6; k[8] = 5;
	k[9] = 4; k[10] = 7; k[11] = 6;

	// left
	k[12] = 4; k[13] = 5; k[14] = 1;
	k[15] = 4; k[16] = 1; k[17] = 0;

	// right
	k[18] = 3; k[19] = 2; k[20] = 6;
	k[21] = 3; k[22] = 6; k[23] = 7;

	// top
	k[24] = 1; k[25] = 5; k[26] = 6;
	k[27] = 1; k[28] = 6; k[29] = 2;

	k[30] = 4; k[31] = 0; k[32] = 3;
	k[33] = 4; k[34] = 3; k[35] = 7;

	HR(mIB->Unlock());
}

void TriGridDemo::buildGeoBuffers()
{
	std::vector<D3DXVECTOR3> verts;
	std::vector<DWORD> indices;

	GenTriGrid(100, 100, 1.0f, 1.0f, D3DXVECTOR3(0.0f, 0.0f, 0.0f), verts, indices);

	mNumVertices  = 100*100;
	mNumTriangles = 99*99*2;

	HR(gd3dDevice->CreateVertexBuffer(mNumVertices * sizeof(VertexPos),
		D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mVB, 0));

	VertexPos *v = 0;
	HR(mVB->Lock(0, 0, (void**)&v, 0));
	for (DWORD i = 0; i < mNumVertices; ++i) v[i] = verts[i];
	HR(mVB->Unlock());

	HR(gd3dDevice->CreateIndexBuffer(mNumTriangles*3*sizeof(WORD), D3DUSAGE_WRITEONLY,
		D3DFMT_INDEX16, D3DPOOL_MANAGED, &mIB, 0));

	WORD *k = 0;
	HR(mIB->Lock(0, 0, (void**)&k, 0));
	for (DWORD i = 0; i < mNumTriangles*3; ++i) k[i] = (WORD)indices[i];
	HR(mIB->Unlock());
}

void Impl::Unlock(BytesPtr srcBytes, BytesPtr dstBytes)
{
    bytes::read_proc rp(srcBytes);
    ProxyId id;
    rp(id);
    
    IDirect3DIndexBuffer9 *self = procMap_->getPtr<IDirect3DIndexBuffer9>(id);
    
    UINT offset, size;
    DWORD flags;

    rp(offset);
    rp(size);
    rp(flags);
    char *ptr = nullptr;

    HRESULT res;
    
    res = self->Lock(offset, size, reinterpret_cast<void**>(&ptr), flags);
    if (SUCCEEDED(res))
    {
        rp.array(ptr, size);
        res = self->Unlock();
        Assert(SUCCEEDED(res));
    }
    else
    {
        vector<char> dump(size);
        rp.array(dump.data(), size);
        Assert(false);
    }

    bytes::write_proc wp(dstBytes);
    wp(res);
}

void MultiTexDemo::buildGridGeometry()
{
	std::vector<D3DXVECTOR3> verts;
	std::vector<DWORD> indices;

	GenTriGrid(100, 100, 1.0f, 1.0f, 
		D3DXVECTOR3(0.0f, 0.0f, 0.0f), verts, indices);

	// Save vertex count and triangle count for DrawIndexedPrimitive arguments.
	mNumGridVertices  = 100*100;
	mNumGridTriangles = 99*99*2;

	// Obtain a pointer to a new vertex buffer.
	HR(gd3dDevice->CreateVertexBuffer(mNumGridVertices * sizeof(VertexPNT), 
		D3DUSAGE_WRITEONLY,	0, D3DPOOL_MANAGED, &mGridVB, 0));

	// Now lock it to obtain a pointer to its internal data, and write the
	// grid's vertex data.
	VertexPNT* v = 0;
	HR(mGridVB->Lock(0, 0, (void**)&v, 0));

	float w = 99.0f; 
	float d = 99.0f;
	for(int i = 0; i < 100; ++i)
	{
		for(int j = 0; j < 100; ++j)
		{
			DWORD index = i * 100 + j;
			v[index].pos    = verts[index];
			v[index].normal = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
			v[index].tex0.x = (v[index].pos.x + (0.5f*w)) / w;
			v[index].tex0.y = (v[index].pos.z - (0.5f*d)) / -d;
		}
	}

	HR(mGridVB->Unlock());


	// Obtain a pointer to a new index buffer.
	HR(gd3dDevice->CreateIndexBuffer(mNumGridTriangles*3*sizeof(WORD), D3DUSAGE_WRITEONLY,
		D3DFMT_INDEX16, D3DPOOL_MANAGED, &mGridIB, 0));

	// Now lock it to obtain a pointer to its internal data, and write the
	// grid's index data.

	WORD* k = 0;
	HR(mGridIB->Lock(0, 0, (void**)&k, 0));

	for(DWORD i = 0; i < mNumGridTriangles*3; ++i)
		k[i] = (WORD)indices[i];

	HR(mGridIB->Unlock());
}

MF_API void MFVertex_LockIndexBuffer(MFIndexBuffer *pIndexBuffer, uint16 **ppIndices)
{
	MFDebug_Assert(!pIndexBuffer->bLocked, "Index buffer already locked!");

	IDirect3DIndexBuffer9 *pIB = (IDirect3DIndexBuffer9*)pIndexBuffer->pPlatformData;
	HRESULT hr = pIB->Lock(0, sizeof(uint16)*pIndexBuffer->numIndices, &pIndexBuffer->pLocked, 0);
	MFDebug_Assert(SUCCEEDED(hr), "Failed to lock index buffer");

	if(ppIndices)
		*ppIndices = (uint16*)pIndexBuffer->pLocked;

	pIndexBuffer->bLocked = true;
}

void SpotlightDemo::buildGeoBuffers()
{
	std::vector<D3DXVECTOR3> verts;
	std::vector<DWORD> indices;

	GenTriGrid(100, 100, 1.0f, 1.0f, 
		D3DXVECTOR3(0.0f, 0.0f, 0.0f), verts, indices);

	// Save vertex count and triangle count for DrawIndexedPrimitive arguments.
	mNumGridVertices  = 100*100;
	mNumGridTriangles = 99*99*2;

	// Obtain a pointer to a new vertex buffer.
	HR(gd3dDevice->CreateVertexBuffer(mNumGridVertices * sizeof(VertexPN), 
		D3DUSAGE_WRITEONLY,	0, D3DPOOL_MANAGED, &mVB, 0));

	// Now lock it to obtain a pointer to its internal data, and write the
	// grid's vertex data.
	VertexPN* v = 0;
	HR(mVB->Lock(0, 0, (void**)&v, 0));

	for(DWORD i = 0; i < mNumGridVertices; ++i)
	{
		v[i].pos = verts[i];
		v[i].normal = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
	}

	HR(mVB->Unlock());


	// Obtain a pointer to a new index buffer.
	HR(gd3dDevice->CreateIndexBuffer(mNumGridTriangles*3*sizeof(WORD), D3DUSAGE_WRITEONLY,
		D3DFMT_INDEX16, D3DPOOL_MANAGED, &mIB, 0));

	// Now lock it to obtain a pointer to its internal data, and write the
	// grid's index data.

	WORD* k = 0;
	HR(mIB->Lock(0, 0, (void**)&k, 0));

	for(DWORD i = 0; i < mNumGridTriangles*3; ++i)
		k[i] = (WORD)indices[i];

	HR(mIB->Unlock());
}

    IndexBufferLock Gfx_IndexBuffer_Lock(RenderDevice* dev, IndexBufferHandle h, uint32 offset, uint32 size) 
    { 
        IndexBufferLock lock;

        if( h.valid() )
        {
            lock.size = size;
            lock.handle = h;

            uint32 flags = buffer_mode_to_d3d_lock_flags(dev->resources->index_buffers[h].desc.mode);

            IDirect3DIndexBuffer9* ib = dev->resources->index_buffers[h].native;
            HRESULT hr = ib->Lock(offset, size, &lock.data, flags);
            validate_d3d_result(hr);
        }

        return lock;
    };

bool MFVertex_CreateIndexBufferPlatformSpecific(MFIndexBuffer *pIndexBuffer, uint16 *pIndexBufferMemory)
{
	IDirect3DIndexBuffer9 *pIB;
	HRESULT hr = pd3dDevice->CreateIndexBuffer(sizeof(uint16)*pIndexBuffer->numIndices, 0, D3DFMT_INDEX16, D3DPOOL_MANAGED, &pIB, NULL);
	MFDebug_Assert(SUCCEEDED(hr), "Failed to create index buffer");
	if(FAILED(hr))
		return false;

	if(pIndexBuffer->pName)
		MFRenderer_D3D9_SetDebugName(pIB, pIndexBuffer->pName);
	pIndexBuffer->pPlatformData = pIB;

	if(pIndexBufferMemory)
	{
		void *pData;
		pIB->Lock(0, 0, &pData, 0);
		MFCopyMemory(pData, pIndexBufferMemory, sizeof(uint16)*pIndexBuffer->numIndices);
		pIB->Unlock();
	}

	return true;
}

void DiffuseCubeDemo::buildIndexBuffer()
{
	// Obtain a pointer to a new index buffer.
	HR(gd3dDevice->CreateIndexBuffer(36 * sizeof(WORD), D3DUSAGE_WRITEONLY,
		D3DFMT_INDEX16, D3DPOOL_MANAGED, &mIB, 0));

	// Now lock it to obtain a pointer to its internal data, and write the
	// cube's index data.

	WORD* k = 0;

	HR(mIB->Lock(0, 0, (void**)&k, 0));

	// fill in the front face index data
	k[0] = 0; k[1] = 1; k[2] = 2;
	k[3] = 0; k[4] = 2; k[5] = 3;

	// fill in the back face index data
	k[6] = 4; k[7]  = 5; k[8]  = 6;
	k[9] = 4; k[10] = 6; k[11] = 7;

	// fill in the top face index data
	k[12] = 8; k[13] =  9; k[14] = 10;
	k[15] = 8; k[16] = 10; k[17] = 11;

	// fill in the bottom face index data
	k[18] = 12; k[19] = 13; k[20] = 14;
	k[21] = 12; k[22] = 14; k[23] = 15;

	// fill in the left face index data
	k[24] = 16; k[25] = 17; k[26] = 18;
	k[27] = 16; k[28] = 18; k[29] = 19;

	// fill in the right face index data
	k[30] = 20; k[31] = 21; k[32] = 22;
	k[33] = 20; k[34] = 22; k[35] = 23;

	HR(mIB->Unlock());
}

void GateDemo::buildGateGeometry()
{
	// Gate is just a rectangle aligned with the xy-plane.


	// Obtain a pointer to a new vertex buffer.
	HR(gd3dDevice->CreateVertexBuffer(4* sizeof(VertexPNT), 
		D3DUSAGE_WRITEONLY,	0, D3DPOOL_MANAGED, &mGateVB, 0));

	// Now lock it to obtain a pointer to its internal data, and write the
	// grid's vertex data.
	VertexPNT* v = 0;
	HR(mGateVB->Lock(0, 0, (void**)&v, 0));

	// Scale texture coordinates by 4 units in the v-direction for tiling.
	v[0] = VertexPNT(-20.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
	v[1] = VertexPNT(-20.0f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
	v[2] = VertexPNT( 20.0f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 4.0f, 0.0f);
	v[3] = VertexPNT( 20.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 4.0f, 1.0f);
	HR(mGateVB->Unlock());


	// Obtain a pointer to a new index buffer.
	HR(gd3dDevice->CreateIndexBuffer(6*sizeof(WORD), D3DUSAGE_WRITEONLY,
		D3DFMT_INDEX16, D3DPOOL_MANAGED, &mGateIB, 0));

	// Now lock it to obtain a pointer to its internal data, and write the
	// grid's index data.

	WORD* k = 0;
	HR(mGateIB->Lock(0, 0, (void**)&k, 0));

	k[0] = 0;  k[1] = 1;  k[2] = 2; // Triangle 0
	k[3] = 0;  k[4] = 2;  k[5] = 3; // Triangle 1

	HR(mGateIB->Unlock());
}

bool StripifyMeshSubset(ID3DXMesh* mesh,
                        DWORD attribId,
                        ostream& meshfile)
{
    // TODO: Fall back to tri lists if the strip size is too small
    // TODO: Detect when a tri fan should be used instead of a tri list

    // Convert to tri strips
    IDirect3DIndexBuffer9* indices = NULL;
    DWORD numIndices = 0;
    ID3DXBuffer* strips = NULL;
    DWORD numStrips = 0;
    HRESULT hr;
    hr = D3DXConvertMeshSubsetToStrips(mesh,
                                       attribId,
                                       0,
                                       &indices,
                                       &numIndices,
                                       &strips,
                                       &numStrips);
    if (FAILED(hr))
    {
        cout << "Stripify failed\n";
        return false;
    }

    cout << "Converted to " << numStrips << " strips\n";
    cout << "Strip buffer size: " << strips->GetBufferSize() << '\n';
    if (numStrips != strips->GetBufferSize() / 4) 
    {
        cout << "Strip count is incorrect!\n";
        return false;
    }

    bool index32 = false;
    {
        D3DINDEXBUFFER_DESC desc;
        indices->GetDesc(&desc);
        if (desc.Format == D3DFMT_INDEX32)
        {
            index32 = true;
        }
        else if (desc.Format == D3DFMT_INDEX16)
        {
            index32 = false;
        }
        else
        {
            cout << "Bad index format.  Strange.\n";
            return false;
        }
    }

    void* indexData = NULL;
    hr = indices->Lock(0, 0, &indexData, D3DLOCK_READONLY);
    if (FAILED(hr))
    {
        cout << "Failed to lock index buffer: " << D3DErrorString(hr) << '\n';
        return false;
    }

    {
        DWORD* stripLengths = reinterpret_cast<DWORD*>(strips->GetBufferPointer());
        int k = 0;
        for (int i = 0; i < numStrips; i++)
        {
            if (stripLengths[i] == 0)
            {
                cout << "Bad triangle strip (length == 0) in mesh!\n";
                return false;
            }

            if (index32)
            {
                DWORD* indices = reinterpret_cast<DWORD*>(indexData) + k;
                int fanStart = checkForFan(stripLengths[i], indices);
                if (fanStart != 1)
                {
                    DumpTriStrip(stripLengths[i], indices, (int) attribId,
                                 meshfile);
                }
                else
                {
                    DumpTriStripAsFan(stripLengths[i], indices, (int) attribId,
                                      fanStart, meshfile);
                }
            }
            else
            {
                WORD* indices = reinterpret_cast<WORD*>(indexData) + k;
                int fanStart = checkForFan(stripLengths[i], indices);
                if (fanStart != 1)
                {
                    DumpTriStrip(stripLengths[i], indices, (int) attribId,
                                 meshfile);
                }
                else
                {
                    DumpTriStripAsFan(stripLengths[i], indices, (int) attribId,
                                      fanStart, meshfile);
//.........这里部分代码省略.........

void Evolution::drawLifeforms()
{
    if (!mbLStart)
    {
        mLVB->Release();
        mLIB->Release();
    }

    int Number = 0;
    int LNumber = 0;

    const D3DXVECTOR3 baseV[4] = {D3DXVECTOR3(-1.00000f, -1.00000f, 0.0f),
                                  D3DXVECTOR3(-1.00000f,  1.00000f, 0.0f),
                                  D3DXVECTOR3( 1.00000f,  1.00000f, 0.0f),
                                  D3DXVECTOR3( 1.00000f, -1.00000f, 0.0f)
                                 };

    const D3DXVECTOR2 baseT[4] = {D3DXVECTOR2(0.0f, 1.0f),
                                  D3DXVECTOR2(0.0f, 0.0f),
                                  D3DXVECTOR2(1.0f, 0.0f),
                                  D3DXVECTOR2(1.0f, 1.0f)
                                 };

    HR(gd3dDevice->CreateVertexBuffer((lifeformList.size()) *4* sizeof(VertexPTL), D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mLVB, 0));
    VertexPTL * lv = 0;
    HR(mLVB->Lock(0, 0, (void**)&lv, 0));

    for (std::list<Lifeform>::iterator it = lifeformList.begin(); it != lifeformList.end(); ++it)
    {
        Stat stat = it->getStat();
        float cParts = (float)(stat.carnivoreParts)/10.0f;
        if (stat.carnivoreParts >= 10)
            cParts = 1.0f;

        float sightDist = (stat.sightDistance)/10.0f;
        if (stat.sightDistance >= 10.0f)
            sightDist = 1.0f;
        if (stat.sightDistance >= 10.0f && !(stat.carnivore))
            cParts = 0.0f;



        D3DXVECTOR3 pos = it->getPosition();
        D3DXMATRIX T, R, S, F;
        D3DXMatrixRotationZ(&R, it->getRotation());
        D3DXVECTOR3 V[4];
        D3DXMatrixTranslation(&T, pos.x, pos.y, pos.z);
        D3DXMatrixScaling(&S, 8.0f, 8.0f, 0.0f);
        F = S*(R*T);

        for (int k=0; k<4; ++k)
            D3DXVec3TransformCoord(&V[k], &baseV[k], &F);

        for (int k=0; k<4; ++k)
            lv[Number+k]   = VertexPTL( V[k], baseT[k], cParts, sightDist);

        /*v[Number]   = VertexPTID(-1.0f, -1.0f, 0.0f, 0.0f, 1.0f, F, 2.0f);
        v[Number+1] = VertexPTID(-1.0f,  1.0f, 0.0f, 0.0f, 0.0f, F, 2.0f);
        v[Number+2] = VertexPTID( 1.0f,  1.0f, 0.0f, 1.0f, 0.0f, F, 2.0f);
        v[Number+3] = VertexPTID( 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, F, 2.0f);*/

        //++lv;
        Number+=4;
        ++LNumber;
    }

    HR(mLVB->Unlock());
    //Number = 0;

    HR(gd3dDevice->CreateIndexBuffer(lifeformList.size() *6* sizeof(WORD), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_MANAGED, &mLIB, 0));

    WORD* lind = 0;
    HR(mLIB->Lock(0, 0, (void**)&lind, 0));
    int k=0;
    int g=0;
    for (int n=0; n<LNumber; ++n)
    {
        lind[k] = g;
        lind[k+1] = g+1;
        lind[k+2] = g+2;
        lind[k+3] = g;
        lind[k+4] = g+2;
        lind[k+5] = g+3;
        k+=6;
        g+=4;
    }

    HR(mLIB->Unlock());


    HR(mFX->SetTechnique(mhLTech));
    HR(mFX->SetTexture(mhTex,  mLifeformTex));
    HR(mFX->SetTexture(mhTex2, mCarnTex));
    HR(mFX->SetTexture(mhTex3, mSightTex));

    HR(mFX->SetMatrix(mhWVP, &(mView*mProj)));

    HR(gd3dDevice->SetVertexDeclaration(VertexPTL::Decl));
    HR(gd3dDevice->SetStreamSource(0, mLVB, 0, sizeof(VertexPTL)));
    HR(gd3dDevice->SetIndices(mLIB));
//.........这里部分代码省略.........

void Evolution::drawEggsFood()
{
    if (!mbEFStart)
    {
        mEFVB->Release();
        mEFIB->Release();
    }

    int Number = 0;
    int FNumber = 0;
    int ENumber = 0;

    const D3DXVECTOR3 baseV[4] = {D3DXVECTOR3(-1.00000f, -1.00000f, 0.0f),
                                  D3DXVECTOR3(-1.00000f,  1.00000f, 0.0f),
                                  D3DXVECTOR3( 1.00000f,  1.00000f, 0.0f),
                                  D3DXVECTOR3( 1.00000f, -1.00000f, 0.0f)
                                 };

    const D3DXVECTOR2 baseT[4] = {D3DXVECTOR2(0.0f, 1.0f),
                                  D3DXVECTOR2(0.0f, 0.0f),
                                  D3DXVECTOR2(1.0f, 0.0f),
                                  D3DXVECTOR2(1.0f, 1.0f)
                                 };


    HR(gd3dDevice->CreateVertexBuffer((foodList.size()+eggList.size()) *4* sizeof(VertexPTEF), D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mEFVB, 0));
    VertexPTEF * efv = 0;
    HR(mEFVB->Lock(0, 0, (void**)&efv, 0));

    for (std::list<Food>::iterator it = foodList.begin(); it != foodList.end(); ++it)
    {
        D3DXVECTOR3 pos = it->getPosition();
        D3DXMATRIX T, S, F;
        D3DXVECTOR3 V[4];
        D3DXMatrixTranslation(&T, pos.x, pos.y, pos.z);
        D3DXMatrixScaling(&S, 2.0f, 2.0f, 0.0f);
        F = S*(T);

        for (int k=0; k<4; ++k)
            D3DXVec3TransformCoord(&V[k], &baseV[k], &F);

        for (int k=0; k<4; ++k)
            efv[Number+k]   = VertexPTEF( V[k], baseT[k]);

        //*v = iv;
        //++fv;
        Number+=4;
        ++FNumber;
    }

    /*if (eggList.size() != 0)
    {
    HR(gd3dDevice->CreateVertexBuffer(eggList.size() * sizeof(VertexPTEF), D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mEVB, 0));
    VertexPTEF * ev = 0;
    HR(mEVB->Lock(0, 0, (void**)&ev, 0));*/

    ENumber=FNumber;
    for (std::list<Egg>::iterator it = eggList.begin(); it != eggList.end(); ++it)
    {
        D3DXVECTOR3 pos = it->getPosition();
        D3DXMATRIX T, S, F;
        D3DXVECTOR3 V[4];
        D3DXMatrixTranslation(&T, pos.x, pos.y, pos.z);
        D3DXMatrixScaling(&S, 2.0f, 2.0f, 0.0f);
        F = S*(T);

        for (int k=0; k<4; ++k)
            D3DXVec3TransformCoord(&V[k], &baseV[k], &F);

        for (int k=0; k<4; ++k)
            efv[Number+k]   = VertexPTEF( V[k], baseT[k]);

        //*v = iv;
        //++ev;
        Number+=4;
        ++ENumber;
    }

    HR(mEFVB->Unlock());

    Number = 0;

    HR(gd3dDevice->CreateIndexBuffer((foodList.size()+eggList.size()) *6* sizeof(WORD), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16,	D3DPOOL_MANAGED, &mEFIB, 0));

    WORD* find = 0;
    HR(mEFIB->Lock(0, 0, (void**)&find, 0));

    int k=0;
    int m=0;
    int g=0;
    while (m<FNumber)
    {
        find[k] = g;
        find[k+1] = g+1;
        find[k+2] = g+2;
        find[k+3] = g;
        find[k+4] = g+2;
        find[k+5] = g+3;
        k+=6;
        g+=4;
//.........这里部分代码省略.........

    void build_submodel( SubModel& m )
    {
        const std::vector< model_vertex_type >& vsrc = m.vertex_source;
        const std::vector< WORD >&              isrc = m.index_source;

        if( vsrc.empty() || isrc.empty() ) {
            return;
        }

        // triangle vb
        {
            IDirect3DVertexBuffer9* vb = NULL;
            if( FAILED( device_->CreateVertexBuffer(
                            UINT( vsrc.size() ) *
                            sizeof( model_vertex_type ),
                            0,
                            0,
                            D3DPOOL_MANAGED,
                            &vb,
                            NULL ) ) ) {
                onError( "create vertex buffer failed\n" );
                return;
            }
                        
            model_vertex_type* p;
            if( FAILED( vb->Lock( 0, 0, (void**)&p, 0 ) ) ) {
                onError( "Lock vertexbuffer failed\n" );
                vb->Release();
                return;
            }

            int mm = int(vsrc.size());
            for( int j = 0 ; j < mm ; j++ ){
                *p++ = vsrc[j];
            }

            vb->Unlock();
            m.vb = vb;
        }

        // triangle ib
        {
            IDirect3DIndexBuffer9* ib = NULL;
            if( FAILED( device_->CreateIndexBuffer(
                            UINT( isrc.size() ) *
                            sizeof( WORD ),
                            0,
                            D3DFMT_INDEX16,
                            D3DPOOL_MANAGED,
                            &ib,
                            NULL ) ) ) {
                onError( "create index buffer failed\n" );
                m.vb->Release();
                return;
            }
                                
            WORD* p;
            if( FAILED( ib->Lock( 0, 0, (void**)&p, 0 ) ) ) {
                onError( "Lock vertexbuffer failed\n" );
                m.vb->Release();
                ib->Release();
                return;
            }

            int mm = int(isrc.size());
            for( int j = 0 ; j < mm ; j++ ){
                *p++ = isrc[j];
            }

            ib->Unlock();
            m.ib = ib;
        }                        
    }