main.cpp

about the basic GA in the VC++ using GPU to

#include <d3dx9.h>
#include <d3d9types.h>
#include <d3dx9shader.h>
#include <d3d9.h>
#include <d3dx9tex.h>
#include "resource.h"
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <shlwapi.h>

#define										DIM					8
#define										FUCTION_1			1
#define										FUCTION_2			2


int											FUCTION				=   1; 


LPDIRECT3D9                                 g_pD3D = NULL;
LPDIRECT3DDEVICE9                           g_pD3DDevice = NULL;

LPDIRECT3DSURFACE9                          g_pBackBuffer = NULL;
LPD3DXEFFECT                                g_pEffect= NULL;;
HINSTANCE                                   g_hInstance;
bool										g_bRender = false;
LPDIRECT3DVERTEXBUFFER9                     g_pBuffer = NULL;

LPDIRECT3DVERTEXBUFFER9                     g_pBestBuffer = NULL;
LPDIRECT3DVERTEXBUFFER9                     g_pCrossCtrBuffer = NULL;

LPDIRECT3DTEXTURE9		                    g_pSubTexture[20];
LPDIRECT3DSURFACE9                          g_pSubSurface[20];
LPDIRECT3DVERTEXBUFFER9                     g_pSubBuffer[20];

LPDIRECT3DTEXTURE9		                    g_pGeneTexture1[DIM/4];
LPDIRECT3DSURFACE9                          g_pGeneSurface1[DIM/4];
LPDIRECT3DTEXTURE9		                    g_pGeneTexture2[DIM/4];
LPDIRECT3DSURFACE9                          g_pGeneSurface2[DIM/4];
LPDIRECT3DTEXTURE9		                    g_pResultGeneTexture[DIM/4];


LPDIRECT3DTEXTURE9		                    g_pBestGeneTexture1[DIM/4];
LPDIRECT3DSURFACE9                          g_pBestGeneSurface1[DIM/4];

LPDIRECT3DTEXTURE9		                    g_pBestGeneTexture2[DIM/4];
LPDIRECT3DSURFACE9                          g_pBestGeneSurface2[DIM/4];

LPDIRECT3DTEXTURE9		                    g_pBestGene[DIM/4];


LPDIRECT3DTEXTURE9		                    g_pBestFitTexture1;
LPDIRECT3DSURFACE9                          g_pBestFitSurface1;
LPDIRECT3DTEXTURE9		                    g_pBestFitTexture2;
LPDIRECT3DSURFACE9                          g_pBestFitSurface2;
LPDIRECT3DTEXTURE9		                    g_pResultBestFitTexture;

LPDIRECT3DTEXTURE9		                    g_pRandTexture;
LPDIRECT3DTEXTURE9		                    g_pPosTexture;
LPDIRECT3DTEXTURE9		                    g_pCrsCtrTexture;
LPDIRECT3DSURFACE9                          g_pCrsCtrSurface;

LPDIRECT3DTEXTURE9		                    g_pSelCtrTexture;
LPDIRECT3DSURFACE9                          g_pSelCtrSurface;

LPDIRECT3DTEXTURE9		                    g_pFitTexture;
LPDIRECT3DSURFACE9                          g_pFitSurface;

LPDIRECT3DTEXTURE9		                    g_pResultTexture[DIM/4];
LPDIRECT3DSURFACE9                          g_pResultSurface[DIM/4];




int											g_nHeight = 1 ;
int											g_nWidth = 1;
int											g_nHeightR = 512;
int											g_nWidthR = 512;

int											g_nHeightPos = 256;
int											g_nWidthPos = 256;

int											EdgeRecord[20];
int											Num = 0 ;

int											g_nPopSize = 1000;
int											g_nLChrom  = 24;
int											g_nGeneration = 1000;

float										g_pCross = 0.4f;
float										g_pMutation = 0.05f;
bool										g_bStopRun = false;
HWND										g_hWnd;
DWORD t1,t2;
LRESULT CALLBACK SetParamProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);

struct CUSTOMVERTEX
{
	FLOAT x, y, z,rhw;	
	FLOAT tu, tv; 
};

#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_TEX1)


#define SafeRelease(pObject) if(pObject != NULL) {pObject->Release(); pObject=NULL;}

HRESULT InitialiseD3D(HWND hWnd)
{
	g_pD3D = Direct3DCreate9(D3D_SDK_VERSION);
	if(g_pD3D == NULL)
	{
		return E_FAIL;
	}
	D3DDISPLAYMODE d3ddm;
	if(FAILED(g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm)))
	{
		return E_FAIL;
	}
	D3DPRESENT_PARAMETERS d3dpp; 
	ZeroMemory(&d3dpp, sizeof(d3dpp));
	d3dpp.Windowed = TRUE;
	d3dpp.SwapEffect = D3DSWAPEFFECT_COPY;
	d3dpp.BackBufferFormat = d3ddm.Format;

	
	if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, hWnd, 
		D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &g_pD3DDevice)))
	{
		return E_FAIL;
	}	
	g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);	
	g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
	g_pD3DDevice->SetRenderState(D3DRS_ZENABLE,FALSE);

	if( FAILED(D3DXCreateEffectFromFile(g_pD3DDevice, "ga.fx", NULL, NULL, 
		D3DXSHADER_DEBUG, NULL, &g_pEffect, NULL )))
		return E_FAIL;

	if( FAILED(g_pD3DDevice->GetRenderTarget(0,&g_pBackBuffer)))
		return E_FAIL;

	return S_OK;
}

HRESULT InitVertexBuffer(int w, int h,LPDIRECT3DVERTEXBUFFER9 &pBuffer)
{
	VOID* pTgtSrcVertices;

	SafeRelease(pBuffer);
	CUSTOMVERTEX cvTgtSrcVertices[] =
	{
		{(float)0,  (float)h, 0.5f , 1.0,  0.0 , 1.0},
		{(float)0,   0.0f   , 0.5f , 1.0,  0.0 , 0.0},       
		{(float)w,  (float)h, 0.5f , 1.0,  1.0 , 1.0},	
		{(float)w,   0.0f   , 0.5f , 1.0,  1.0 , 0.0}

	};
	
	if(FAILED(g_pD3DDevice->CreateVertexBuffer(4 * sizeof(CUSTOMVERTEX),
		0, D3DFVF_CUSTOMVERTEX,
		D3DPOOL_DEFAULT, &pBuffer,0)))
	{
		return E_FAIL;
	}
	if(FAILED(pBuffer->Lock(0, sizeof(cvTgtSrcVertices), &pTgtSrcVertices, 0)))
	{
		return E_FAIL;
	}

	memcpy(pTgtSrcVertices, cvTgtSrcVertices, sizeof(cvTgtSrcVertices));

	pBuffer->Unlock();

	return S_OK;

}

void SaveTexture(int w,int h,LPDIRECT3DTEXTURE9 &pColorMap,char *filePath)
{

	LPD3DXBUFFER    pBuffer = NULL;
	BYTE            *pbyBits = NULL;

	int texElemCount = w*h*4;
	float *texData = new float[texElemCount];
	D3DLOCKED_RECT rfTextureLock;

	LPDIRECT3DSURFACE9 pSurf, pVectorTextureSurface;
	PDIRECT3DTEXTURE9  pTex;

	g_pD3DDevice->CreateTexture(h,w,0, NULL, D3DFMT_A32B32G32R32F, D3DPOOL_SYSTEMMEM, &pTex, NULL);
	pTex->GetSurfaceLevel(0,&pSurf);
	pColorMap->GetSurfaceLevel(0,&pVectorTextureSurface);	
	g_pD3DDevice->GetRenderTargetData(pVectorTextureSurface, pSurf);	
	pTex->LockRect(0, &rfTextureLock, NULL, D3DLOCK_READONLY);	// lock whole region in the vector texture
	float* pfTexture = (float*)rfTextureLock.pBits;
	memcpy(texData,pfTexture,texElemCount*sizeof(float));
	pTex->UnlockRect(0);

	FILE* flog = fopen(filePath,"a+");
	
	for(int i = h - 1 ; i >= 0; i--)
		for(int j = 0 ; j < w ; j++)
		{
			float r = texData[ 4 * i * w + j * 4]; 
			float g = texData[ 4 * i * w + j * 4 + 1]; 
			float b = texData[ 4 * i * w + j * 4 + 2]; 
			float a = texData[ 4 * i * w + j * 4 + 3]; 
			fprintf(flog,"index = %d, r = %.1f, g = %.1f, b = %.1f, a = %.1f\n",  (h - i - 1) * w +j,r,g,b,a) ; 

		}

	fprintf(flog,"\n\n") ;
	fclose(flog);
	
	delete texData;

	SafeRelease(pSurf);
	SafeRelease(pTex);
	SafeRelease(pVectorTextureSurface);
	SafeRelease( pBuffer );

}

VOID WINAPI ColorFill (D3DXVECTOR4* pOut, const D3DXVECTOR2* pTexCoord, 
					   const D3DXVECTOR2* pTexelSize, LPVOID pData)
{
	int x = (int)(pTexCoord->x * g_nWidth);
	int y = (int)(pTexCoord->y * g_nHeight);
	float *pTextureData = (float*)pData;
	*pOut = D3DXVECTOR4(pTextureData[(g_nHeight - y -1) * g_nWidth * 4 + x *4],pTextureData[(g_nHeight - y - 1) * g_nWidth * 4 + x *4 + 1],
		pTextureData[(g_nHeight - y-1) * g_nWidth * 4 + x *4 + 2], pTextureData[(g_nHeight - y-1) * g_nWidth * 4 + x *4 + 3]);
}

VOID WINAPI ColorFillRand(D3DXVECTOR4* pOut, const D3DXVECTOR2* pTexCoord, 
					   const D3DXVECTOR2* pTexelSize, LPVOID pData)
{
	int w = g_nWidthR,h = g_nHeightR;
	int x = (int)(pTexCoord->x * w);
	int y = (int)(pTexCoord->y * h);
	float *pTextureData = (float*)pData;
	*pOut = D3DXVECTOR4(pTextureData[(h - y -1) * w * 4 + x *4],pTextureData[(h - y - 1) * w * 4 + x *4 + 1],
		pTextureData[(h - y-1) * w * 4 + x *4 + 2], pTextureData[(h - y-1) * w * 4 + x *4 + 3]);
}

VOID WINAPI ColorFillPos(D3DXVECTOR4* pOut, const D3DXVECTOR2* pTexCoord, 
					   const D3DXVECTOR2* pTexelSize, LPVOID pData)
{
	int w = g_nWidthPos,h = g_nHeightPos;
	int x = (int)(pTexCoord->x * w);
	int y = (int)(pTexCoord->y * h);
	float *pTextureData = (float*)pData;
	*pOut = D3DXVECTOR4(pTextureData[(h - y -1) * w * 4 + x *4],pTextureData[(h - y - 1) * w * 4 + x *4 + 1],
		pTextureData[(h - y-1) * w * 4 + x *4 + 2], pTextureData[(h - y-1) * w * 4 + x *4 + 3]);
}


bool GetINTData(float* texData,DWORD DataSpace,int nHeight)
{	
	for(int i = 0 ; i < nHeight * nHeight ; i++)
	{		
		texData[4 * i] = (DWORD)(rand()/(double)RAND_MAX* DataSpace);
		texData[4 * i + 1] = (DWORD)(rand()/(double)RAND_MAX* DataSpace) ;
		texData[4 * i + 2] = (DWORD)(rand()/(double)RAND_MAX* DataSpace) ;
		texData[4 * i + 3] = (DWORD)(rand()/(double)RAND_MAX* DataSpace);	

	}
	return true;
}
bool GetFLOATData(float* texData)
{	
	for(int i = 0 ; i < g_nHeightR * g_nWidthR ; i++)
	{		
		texData[4 * i] = (float)(rand()/(double)RAND_MAX);
		texData[4 * i + 1] = (float)(rand()/(double)RAND_MAX) ;
		texData[4 * i + 2] = (float)(rand()/(double)RAND_MAX) ;
		texData[4 * i + 3] = (float)(rand()/(double)RAND_MAX);	

	}
	return true;
}
bool InitGA()
{
	static int kk=(unsigned)time(NULL);
	srand((unsigned)time(NULL)+kk++);

	int k = 0 ; 
	while(k * k < g_nPopSize)
    {
        k = k + 2;
    }
    g_nHeight = g_nWidth = k;
	
	float *texData = new float[g_nWidth*g_nHeight*4];	
	for(int i = 0 ; i < DIM / 4 ; i++)
	{
		GetINTData(texData,(DWORD)pow(2.0,g_nLChrom),g_nHeight);
		g_pD3DDevice->CreateTexture(g_nWidth,g_nHeight,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pGeneTexture1[i], NULL);
		D3DXFillTexture(g_pGeneTexture1[i],ColorFill,(float*)texData);
		g_pGeneTexture1[i]->GetSurfaceLevel(0,&g_pGeneSurface1[i]);

		g_pResultGeneTexture[i] = g_pGeneTexture1[i];
		
		g_pD3DDevice->CreateTexture(g_nWidth,g_nHeight,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pGeneTexture2[i], NULL);
		g_pGeneTexture2[i]->GetSurfaceLevel(0,&g_pGeneSurface2[i]);

		
		g_pD3DDevice->CreateTexture(1,1,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pBestGeneTexture1[i], NULL);		
		g_pBestGeneTexture1[i]->GetSurfaceLevel(0,&g_pBestGeneSurface1[i]);

		g_pBestGene[i] = g_pBestGeneTexture1[i];
		g_pD3DDevice->CreateTexture(1,1,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pBestGeneTexture2[i], NULL);		
		g_pBestGeneTexture2[i]->GetSurfaceLevel(0,&g_pBestGeneSurface2[i]);
		
		g_pD3DDevice->CreateTexture(1,1,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pResultTexture[i], NULL);		
		g_pResultTexture[i]->GetSurfaceLevel(0,&g_pResultSurface[i]);

       
	}
	delete[] texData;
	
	g_pD3DDevice->CreateTexture(1,1,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pBestFitTexture1, NULL);
	g_pBestFitTexture1->GetSurfaceLevel(0,&g_pBestFitSurface1);

	g_pResultBestFitTexture = g_pBestFitTexture1;

	g_pD3DDevice->CreateTexture(1,1,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pBestFitTexture2, NULL);
	g_pBestFitTexture2->GetSurfaceLevel(0,&g_pBestFitSurface2);

	g_pD3DDevice->CreateTexture(g_nWidth,g_nHeight,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pFitTexture, NULL);
	g_pFitTexture->GetSurfaceLevel(0,&g_pFitSurface);
	
	float * floatData = new float[g_nHeightR*g_nWidthR*4];
	GetFLOATData(floatData);
	g_pD3DDevice->CreateTexture(g_nWidthR,g_nHeightR,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pRandTexture, NULL);
	D3DXFillTexture(g_pRandTexture,ColorFillRand,(float*)floatData);	
	delete[] floatData;


	float * intData = new float[g_nHeightPos*g_nWidthPos*4];
	GetINTData(intData,24,g_nHeightPos);
	g_pD3DDevice->CreateTexture(g_nWidthPos,g_nHeightPos,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pPosTexture, NULL);
	D3DXFillTexture(g_pPosTexture,ColorFillPos,(float*)intData);	
	delete[]intData;	

	g_pD3DDevice->CreateTexture(g_nWidth,g_nHeight,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pSelCtrTexture, NULL);
	g_pSelCtrTexture->GetSurfaceLevel(0,&g_pSelCtrSurface);

	g_pD3DDevice->CreateTexture(g_nWidth / 2,g_nHeight,1, D3DUSAGE_RENDERTARGET, D3DFMT_A32B32G32R32F, D3DPOOL_DEFAULT, &g_pCrsCtrTexture, NULL);
	g_pCrsCtrTexture->GetSurfaceLevel(0,&g_pCrsCtrSurface);

	
	return true;
}

LPDIRECT3DTEXTURE9& SetTarget(int w,int h,LPDIRECT3DTEXTURE9 &pTexture,LPDIRECT3DSURFACE9 &pSurface)
{
	SafeRelease(pTexture);
	SafeRelease(pSurface);

	g_pD3DDevice->CreateTexture(w,h,1,D3DUSAGE_RENDERTARGET,D3DFMT_A32B32G32R32F,D3DPOOL_DEFAULT,&pTexture,NULL);

	pTexture->GetSurfaceLevel(0,&pSurface);

	return pTexture;
}

bool InitSub()
{	
	int k = g_nHeight; 
	
	while( k > 1)
	{
		if(k % 2 == 0)
			k = k/2;
		else
			k = k/2 + 1;

		InitVertexBuffer(k,k,g_pSubBuffer[Num]);
		SetTarget(k,k,g_pSubTexture[Num],g_pSubSurface[Num]);
		EdgeRecord[Num] = k;

		Num++;
	}
	return true;
}

bool InitBuffer()
{
	InitVertexBuffer(g_nWidth,g_nHeight,g_pBuffer);
	InitVertexBuffer(1,1,g_pBestBuffer);
	InitVertexBuffer(g_nWidth/2,g_nHeight,g_pCrossCtrBuffer);
	InitSub();
	return true;
}