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

void TiledGroundDemo::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 texScale = 0.2f;
	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 = D3DXVECTOR2((float)j, (float)i) * texScale;
		}
	}

	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());
}

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());
}

MF_API void MFVertex_UnlockIndexBuffer(MFIndexBuffer *pIndexBuffer)
{
	MFDebug_Assert(pIndexBuffer->bLocked, "Index buffer not locked!");

	IDirect3DIndexBuffer9 *pIB = (IDirect3DIndexBuffer9*)pIndexBuffer->pPlatformData;
	pIB->Unlock();

	pIndexBuffer->pLocked = NULL;
	pIndexBuffer->bLocked = false;
/*
	// why on earth did I defer the index locking to a post process???
	IDirect3DIndexBuffer9 *pIB = (IDirect3DIndexBuffer9*)pIndexBuffer->pPlatformData;

	void *pData;
	pIB->Lock(0, 0, &pData, 0);
	MFCopyMemory(pData, pIndexBuffer->pIndices, sizeof(uint16)*pIndexBuffer->numIndices);
	pIB->Unlock();

	pIndexBuffer->bLocked = false;
*/
}

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());
}

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 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());
}

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;
//.........这里部分代码省略.........

BYTE KScene::Draw(
    IDirect3DDevice9* piDevice,
    KVertexEx* pVertex, int nVertexCount,
    KTriangleEx* pTriangle, int nTriangleCount,
    BOOL bSolid, 
    BOOL bWireframe
)
{
    BOOL                    bResult         = false;
    HRESULT                 hRetCode        = E_FAIL;
    IDirect3DVertexBuffer9* piVertexBuffer  = NULL;
    IDirect3DIndexBuffer9*  piIndexBuffer   = NULL;
    void*                   pvBuffer        = NULL;

    hRetCode = piDevice->CreateVertexBuffer(
        sizeof(KVertex) * nVertexCount, 0, 
        VERTEX_FVF, D3DPOOL_MANAGED, &piVertexBuffer, 0
    );
    KG_PROCESS_ERROR(!FAILED(hRetCode));

    hRetCode = piVertexBuffer->Lock(0, 0, &pvBuffer, D3DLOCK_DISCARD);
    KG_PROCESS_ERROR(!FAILED(hRetCode));

    for (int i = 0; i < nVertexCount; i++)
    {
        KVertex* pV = (KVertex*)pvBuffer + i;
        pV->vPos    = pVertex[i].vPos;
        pV->vNormal = pVertex[i].vNormal;
    }
    piVertexBuffer->Unlock();

    hRetCode = piDevice->CreateIndexBuffer(
        sizeof(KTriangle) * nTriangleCount, 0, 
        D3DFMT_INDEX32, D3DPOOL_MANAGED, &piIndexBuffer, 0
    );
    KG_PROCESS_ERROR(!FAILED(hRetCode));

    hRetCode = piIndexBuffer->Lock(0, 0, &pvBuffer, D3DLOCK_DISCARD);
    KG_PROCESS_ERROR(!FAILED(hRetCode));

    for (int i = 0; i < nTriangleCount; i++)
    {
        KTriangle* pT = (KTriangle*)pvBuffer + i;

        if (!pTriangle[i].pVertexA)
            pT->nA = 0;
        else
            pT->nA = (int)(pTriangle[i].pVertexA - pVertex);

        if (!pTriangle[i].pVertexB)
            pT->nB = 0;
        else
            pT->nB = (int)(pTriangle[i].pVertexB - pVertex);

        if (!pTriangle[i].pVertexC)
            pT->nC = 0;
        else
            pT->nC = (int)(pTriangle[i].pVertexC - pVertex);
    }
    piIndexBuffer->Unlock();

    piDevice->SetStreamSource(0, piVertexBuffer, 0, sizeof(KVertex));
    piDevice->SetIndices(piIndexBuffer);
    piDevice->SetFVF(VERTEX_FVF);

    if (bSolid)
    {
        piDevice->SetRenderState(D3DRS_LIGHTING, true);
        piDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
        piDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, nVertexCount, 0, nTriangleCount);
    }

    if (bWireframe)
    {
        piDevice->SetRenderState(D3DRS_LIGHTING, false);
        piDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
        piDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, nVertexCount, 0, nTriangleCount);
    }

    bResult = true;
Exit0:
    KG_COM_RELEASE(piIndexBuffer);
    KG_COM_RELEASE(piVertexBuffer);
    return bResult;
}

    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;
        }                        
    }

Map::Map(std::string RAW_File_Name,
		 int Vertex_Length,
		 int Vertex_Width,
		 int Cell_Spacing,
		 float Height_Scale)
{
	vertex_length = Vertex_Length;
	vertex_width = Vertex_Width;

	total_vertices = vertex_length * vertex_width;				//Total = L * W

	cell_length = vertex_length - 1;
	cell_width = vertex_width - 1;

	cell_spacing = Cell_Spacing;
	height_scale = Height_Scale;

	length = cell_length * cell_spacing;
	width = cell_width * cell_spacing;

	total_triangles = cell_length * cell_width * 2;

	D3DXCreateMeshFVF(cell_length * cell_width * 2,
		vertex_length * vertex_width,
		D3DXMESH_MANAGED,
		Terrain_Vertex::FVF,
		d3ddev,
		&mesh);

	if (!Raw_To_Int_Vector(RAW_File_Name))
	{
		MessageBox(0, "Raw_To_Int_Vector - FAILED", 0, 0);
		PostQuitMessage(0);
	}

	for (int i = 0; i < height_int_vector.size(); i++)
	{
		height_float_vector.push_back((float)height_int_vector[i]);

		height_float_vector[i] = height_float_vector[i] * height_scale;
	}

	if (!Create_Normals(&LightDirectionThree))
	{
		MessageBox(0, "Create_Normals - FAILED", 0, 0);
		PostQuitMessage(0);
	}

	Generate_Vertex_Normals();

	if (!Generate_Vertices())
	{
		MessageBox(0, "Generate_Vertices - FAILED", 0, 0);
		PostQuitMessage(0);
	}

	if (!Generate_Indices())									//Also Generates Mesh
	{
		MessageBox(0, "Generate_Indices - FAILED", 0, 0);
		PostQuitMessage(0);
	}

	adjacency_buffer = new DWORD[cell_width * cell_length * 2 * 3];

	mesh->GenerateAdjacency(0.001f, adjacency_buffer);
	mesh->OptimizeInplace(D3DXMESH_MANAGED |
		D3DXMESHOPT_COMPACT |
		D3DXMESHOPT_ATTRSORT | 
		D3DXMESHOPT_VERTEXCACHE,
		adjacency_buffer,
		adjacency_buffer,
		0,
		0);

	IDirect3DVertexBuffer9* bufvert;
	Terrain_Vertex* tempvert;

	mesh->GetVertexBuffer(&bufvert);
	bufvert->Lock(0, 0, (void**)&tempvert, 0);
	vertexdata = tempvert;
	bufvert->Unlock();

	IDirect3DIndexBuffer9* bufind;
	WORD* tempind;

	mesh->GetIndexBuffer(&bufind);
	bufind->Lock(0, 0, (void**)&tempind, 0);
	indexdata = tempind;
	bufind->Unlock();

	SafeRelease(bufvert);
	SafeRelease(bufind);
}