IDX9.cpp

#include "IDX9.h"
#include "Math.h"

IDX9 ::IDX9()
{
	g_pD3D = NULL ;
	g_pd3dDevice = NULL ;
	pVertexBuffer = NULL ;
	backVertexBuffer = new ScreenVertex[BVBSize] ;
	backIndexBuffer = new int[BIBSize] ;
	BVBCursor = 0 ; 
	BIBCursor = 0 ;
}

IDX9 ::~IDX9()
{
	CleanUp() ;
}

bool IDX9 ::SetUp(HWND hwnd)
{
	if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
		return false;

	D3DPRESENT_PARAMETERS d3dpp;
	ZeroMemory( &d3dpp, sizeof( d3dpp ) );
	d3dpp.Windowed = TRUE;
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;

	if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
										D3DCREATE_SOFTWARE_VERTEXPROCESSING,
										&d3dpp, &g_pd3dDevice ) ) )
	{
		return false;
	}

	return true;
}

void IDX9 ::RefreshBackBuffer()
{
	BVBCursor = BIBCursor = 0 ;
}

bool IDX9 ::SubmitPolygonList(PolySelfContained* polyList, int count)
{
	if (count * 3 >= BVBSize)
		return false ;

	for (int i = 0; i < count; ++i)
	{
		if (polyList[i].removed)
			continue ;

		backVertexBuffer[BVBCursor].x = polyList[i].vertexList[0].x ;
		backVertexBuffer[BVBCursor].y = polyList[i].vertexList[0].y ;
		backVertexBuffer[BVBCursor].z = polyList[i].vertexList[0].z ;
		backVertexBuffer[BVBCursor].rhw = 1 / polyList[i].vertexList[0].w ;
		BIBCursor = BVBCursor * 2 ;
		backIndexBuffer[BIBCursor] = BVBCursor ;
		backIndexBuffer[BIBCursor + 1] = BVBCursor + 1 ;
		++BVBCursor ;

		backVertexBuffer[BVBCursor].x = polyList[i].vertexList[1].x ;
		backVertexBuffer[BVBCursor].y = polyList[i].vertexList[1].y ;
		backVertexBuffer[BVBCursor].z = polyList[i].vertexList[1].z ;
		backVertexBuffer[BVBCursor].rhw = 1 / polyList[i].vertexList[1].w ;
		BIBCursor = BVBCursor * 2 ;
		backIndexBuffer[BIBCursor] = BVBCursor ;
		backIndexBuffer[BIBCursor + 1] = BVBCursor + 1 ;
		++BVBCursor ;

		backVertexBuffer[BVBCursor].x = polyList[i].vertexList[2].x ;
		backVertexBuffer[BVBCursor ].y = polyList[i].vertexList[2].y ;
		backVertexBuffer[BVBCursor].z = polyList[i].vertexList[2].z ;
		backVertexBuffer[BVBCursor].rhw = 1 / polyList[i].vertexList[2].w ;
		BIBCursor = BVBCursor * 2 ;
		backIndexBuffer[BIBCursor] = BVBCursor ;
		backIndexBuffer[BIBCursor + 1] = BVBCursor - 2 ;
		++BVBCursor ;
	}

	return true ;
}

bool IDX9 ::DrawBackBuffer()
{	
	if( FAILED( g_pd3dDevice->CreateVertexBuffer(
		(BVBCursor) * sizeof( ScreenVertex ),
		0,
		SCREEN_VERTEX_FVF,
		D3DPOOL_DEFAULT,
		&pVertexBuffer,
		NULL)))
	{
		return false;
	}

	void* pVertices;
	if( FAILED( pVertexBuffer->Lock( 0, (BVBCursor) * sizeof( ScreenVertex ), ( void** )&pVertices, 0 ) ) )
		return false;
	
	memcpy(pVertices, backVertexBuffer, (BVBCursor) * sizeof( ScreenVertex ));
	
	pVertexBuffer->Unlock();

	if(FAILED( g_pd3dDevice->CreateIndexBuffer(
		(BIBCursor + 2) * sizeof(int),
		0,
		D3DFMT_INDEX32,
		D3DPOOL_DEFAULT,
		&pIndexBuffer,
		NULL)))
	{
		return false ;
	}

	void * pIndices ;
	if (FAILED(pIndexBuffer ->Lock(0, (BIBCursor + 2) * sizeof(int), (void **)&pIndices, 0)))
		return false ;

	memcpy(pIndices, backIndexBuffer, (BIBCursor + 2) * sizeof(int)) ;

	pIndexBuffer ->Unlock() ;

	return true ;
}

void IDX9 ::Render()
{
    g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB( 0, 0, 0 ), 1.0f, 0 );

    if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
    {
        g_pd3dDevice->SetStreamSource( 0, pVertexBuffer, 0, sizeof( ScreenVertex ) );
        g_pd3dDevice->SetFVF( SCREEN_VERTEX_FVF );

		g_pd3dDevice ->SetIndices(pIndexBuffer) ;

		g_pd3dDevice->DrawIndexedPrimitive(D3DPT_LINELIST, 0, 0, (BIBCursor + 2), 0, (BIBCursor + 2) / 2) ;

        g_pd3dDevice->EndScene();

    }

    g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}

void IDX9 ::CleanUp()
{
	if (pVertexBuffer != NULL)
		pVertexBuffer ->Release() ;

	if (pIndexBuffer != NULL)
		pIndexBuffer ->Release() ;

	if( g_pd3dDevice != NULL )
		g_pd3dDevice->Release();

	if( g_pD3D != NULL )
		g_pD3D->Release();
}