scene2.cpp

我们数据结构课的课程设计

#include "stdafx.h" 
#include "scene2.h" 
#include "glval.h"

bool Scene1(float timeDelta); 

ID3DXMesh*         maze_mesh = 0;
IDirect3DTexture9* Textures[4] = {0};// texture for each subset
float squaresize = 16.0f; 
RECT rtNext; 
RECT rtExit; 
RECT rtSelectLoadFromFile; 
RECT rtSelect; 
enum ButtonStatus nextbuttonstatus = ButtonStatus::NORMAL; 
enum ButtonStatus exitbuttonstatus = ButtonStatus::NORMAL; 


void CleanScene2()
{
    if (maze_width * maze_height)
        d3d::Release(maze_mesh); 
    d3d::Release(Textures[0]); 
    d3d::Release(Textures[1]); 
    d3d::Release(Textures[2]); 
    d3d::Release(Textures[3]); 
}

bool LoadScene2()
{
    step = false; 
    /*
	if (FAILED(D3DXCreateTextureFromFile(
		Device,  
		TEXT("white.jpg"), 
		&Textures[0])))
	{
		ERMSG("D3DXCreateTextureFromFile(white.jpg) - FAILED");
		return false;
	}
	if (FAILED(D3DXCreateTextureFromFile(
		Device,  
		TEXT("black.jpg"), 
		&Textures[1])))
	{
		ERMSG("D3DXCreateTextureFromFile(black.jpg) - FAILED");
		return false;
	}
	if (FAILED(D3DXCreateTextureFromFile(
		Device,  
		TEXT("wall.jpg"), 
		&Textures[2])))
	{
		ERMSG("D3DXCreateTextureFromFile(wall.jpg) - FAILED");
		return false;
	}
	if (FAILED(D3DXCreateTextureFromFile(
		Device,  
		TEXT("back.jpg"), 
		&Textures[3])))
	{
		ERMSG("D3DXCreateTextureFromFile(back.jpg) - FAILED");
		return false;
	}
    */
	if (FAILED(D3DXCreateTextureFromResource(
		Device,   
		resDll,   
        MAKEINTRESOURCE(111),   
		&Textures[0])))
	{
		ERMSG("D3DXCreateTextureFromResource(111) - FAILED");
		return false;
	}
	if (FAILED(D3DXCreateTextureFromResource(
		Device,  
		resDll,   
        MAKEINTRESOURCE(112),  
		&Textures[1])))
	{
		ERMSG("D3DXCreateTextureFromResource(112) - FAILED");
		return false;
	}
	if (FAILED(D3DXCreateTextureFromResource(
		Device,  
		resDll,   
        MAKEINTRESOURCE(113),  
		&Textures[2])))
	{
		ERMSG("D3DXCreateTextureFromResource(113) - FAILED");
		return false;
	}
	if (FAILED(D3DXCreateTextureFromResource(
		Device,  
		resDll,   
        MAKEINTRESOURCE(114),  
		&Textures[3])))
	{
		ERMSG("D3DXCreateTextureFromResource(114) - FAILED");
		return false;
	}
	if (FAILED(D3DXCreateMeshFVF(
		(maze_width*maze_height + 5) * 2, // 表面数  (2*2+5)*2 = 18
		(maze_width+1) * (maze_height+1) + 4 * 5, // 顶点数  3*3 + 20 = 29
		D3DXMESH_MANAGED, 
		FVF_VERTEX, 
		Device, 
		&maze_mesh)))
	{
		ERMSG("D3DXCreateMeshFVF() - FAILED");
		return false;
	}
	unsigned int i, j; 
	Vertex *vertex; 
	maze_mesh->LockVertexBuffer(0, (void**)&vertex); 
	// 填充前表面顶点
	for (i=0; i<=maze_height; i++)
	{
		for (j=0; j<=maze_width; j++)
		{
			//  0  1  2  3
			//  4  5  6  7
			//  8  9 10 11
			// 12 13 14 15
			vertex[i*(maze_width+1)+j] = Vertex(
				-(maze_width/2.0f)+j, 
				maze_height/2.0f-i, 
				0.0f, 0.0f, 0.0f, 0.0f, (FLOAT)j, (FLOAT)i); 
		}
	} 
	// 填充后表面顶点
	vertex[(maze_width+1) * (maze_height+1) + 0] = Vertex(
		(maze_width/2.0f), -(maze_height/2.0f), (maze_height/3.0f), 
		0.0f, 0.0f, (maze_height/3.0f), 0.0f, maze_height); 
	vertex[(maze_width+1) * (maze_height+1) + 1] = Vertex(
		(maze_width/2.0f), (maze_height/2.0f), (maze_height/3.0f), 
		0.0f, 0.0f, (maze_height/3.0f), 0.0f, 0.0f); 
	vertex[(maze_width+1) * (maze_height+1) + 2] = Vertex(
		-(maze_width/2.0f), (maze_height/2.0f), (maze_height/3.0f), 
		0.0f, 0.0f, (maze_height/3.0f), maze_width, 0.0f); 
	vertex[(maze_width+1) * (maze_height+1) + 3] = Vertex(
		-(maze_width/2.0f), -(maze_height/2.0f), (maze_height/3.0f), 
		0.0f, 0.0f, (maze_height/3.0f), maze_width, maze_height); 
	// 填充下表面顶点
	vertex[(maze_width+1) * (maze_height+1) + 4] = Vertex(
		-(maze_width/2.0f), -(maze_height/2.0f), (maze_height/3.0f), 
		0.0f, -(maze_height/2.0f), 0.0f, 0.0f, maze_height); 
	vertex[(maze_width+1) * (maze_height+1) + 5] = Vertex(
		-(maze_width/2.0f), -(maze_height/2.0f), 0.0f, 
		0.0f, -(maze_height/2.0f), 0.0f, 0.0f, 0.0f); 
	vertex[(maze_width+1) * (maze_height+1) + 6] = Vertex(
		(maze_width/2.0f), -(maze_height/2.0f), 0.0f, 
		0.0f, -(maze_height/2.0f), 0.0f, maze_width, 0.0f); 
	vertex[(maze_width+1) * (maze_height+1) + 7] = Vertex(
		(maze_width/2.0f), -(maze_height/2.0f), (maze_height/3.0f), 
		0.0f, -(maze_height/2.0f), 0.0f, maze_width, maze_height); 
	// 填充上表面顶点
	vertex[(maze_width+1) * (maze_height+1) + 8] = Vertex(
		-(maze_width/2.0f), (maze_height/2.0f), 0.0f, 
		0.0f, (maze_height/2.0f), 0.0f, 0.0f, maze_height);
	vertex[(maze_width+1) * (maze_height+1) + 9] = Vertex(
		-(maze_width/2.0f), (maze_height/2.0f), (maze_height/3.0f), 
		0.0f, (maze_height/2.0f), 0.0f, 0.0f, 0.0f);
	vertex[(maze_width+1) * (maze_height+1) + 10] = Vertex(
		(maze_width/2.0f), (maze_height/2.0f), (maze_height/3.0f), 
		0.0f, (maze_height/2.0f), 0.0f, maze_width, 0.0f);
	vertex[(maze_width+1) * (maze_height+1) + 11] = Vertex(
		(maze_width/2.0f), (maze_height/2.0f), 0.0f, 
		0.0f, (maze_height/2.0f), 0.0f, maze_width, maze_height);
	// 填充左表面顶点
	vertex[(maze_width+1) * (maze_height+1) + 12] = Vertex(
		-(maze_width/2.0f), -(maze_height/2.0f), (maze_height/3.0f), 
		-(maze_width/2.0f), 0.0f, 0.0f, 0.0f, maze_height);
	vertex[(maze_width+1) * (maze_height+1) + 13] = Vertex(
		-(maze_width/2.0f), (maze_height/2.0f), (maze_height/3.0f), 
		-(maze_width/2.0f), 0.0f, 0.0f, 0.0f, 0.0f);
	vertex[(maze_width+1) * (maze_height+1) + 14] = Vertex(
		-(maze_width/2.0f), (maze_height/2.0f), 0.0f, 
		-(maze_width/2.0f), 0.0f, 0.0f, maze_width, 0.0f);
	vertex[(maze_width+1) * (maze_height+1) + 15] = Vertex(
		-(maze_width/2.0f), -(maze_height/2.0f), 0.0f, 
		-(maze_width/2.0f), 0.0f, 0.0f, maze_width, maze_height);
	// 填充右表面顶点
	vertex[(maze_width+1) * (maze_height+1) + 16] = Vertex(
		(maze_width/2.0f), -(maze_height/2.0f), 0.0f, 
		(maze_width/2.0f), 0.0f, 0.0f, 0.0f, maze_height);
	vertex[(maze_width+1) * (maze_height+1) + 17] = Vertex(
		(maze_width/2.0f), (maze_height/2.0f), 0.0f, 
		(maze_width/2.0f), 0.0f, 0.0f, 0.0f, 0.0f);
	vertex[(maze_width+1) * (maze_height+1) + 18] = Vertex(
		(maze_width/2.0f), (maze_height/2.0f), (maze_height/3.0f), 
		(maze_width/2.0f), 0.0f, 0.0f, maze_width, 0.0f);
	vertex[(maze_width+1) * (maze_height+1) + 19] = Vertex(
		maze_width/2.0f, -(maze_height/2.0f), (maze_height/3.0f), 
		(maze_width/2.0f), 0.0f, 0.0f, maze_width, maze_height);

	maze_mesh->UnlockVertexBuffer(); 


	WORD *index; 
	maze_mesh->LockIndexBuffer(0, (void**)&index); 
	// 填充前表面索引
    unsigned int k = 0; 
	for(i=0; i<maze_height; i++)
    {
        for (j=0; j<maze_width; j++)
        {
            index[k++] = i*(maze_width+1)+j + (maze_width+1); 
            index[k++] = i*(maze_width+1)+j; 
            index[k++] = i*(maze_width+1)+j + 1; 

            index[k++] = i*(maze_width+1)+j + (maze_width+1); 
            index[k++] = i*(maze_width+1)+j + 1; 
            index[k++] = i*(maze_width+1)+j + (maze_width+1) + 1; 
        }
    }
	// 填充后表面索引
    index[k++] = (maze_width+1) * (maze_height+1) + 0; 
    index[k++] = (maze_width+1) * (maze_height+1) + 1; 
    index[k++] = (maze_width+1) * (maze_height+1) + 2; 
    index[k++] = (maze_width+1) * (maze_height+1) + 0; 
    index[k++] = (maze_width+1) * (maze_height+1) + 2; 
    index[k++] = (maze_width+1) * (maze_height+1) + 3; 
	// 填充下表面索引
    index[k++] = (maze_width+1) * (maze_height+1) + 4 + 0; 
    index[k++] = (maze_width+1) * (maze_height+1) + 4 + 1; 
    index[k++] = (maze_width+1) * (maze_height+1) + 4 + 2; 
    index[k++] = (maze_width+1) * (maze_height+1) + 4 + 0; 
    index[k++] = (maze_width+1) * (maze_height+1) + 4 + 2; 
    index[k++] = (maze_width+1) * (maze_height+1) + 4 + 3; 
	// 填充上表面索引
    index[k++] = (maze_width+1) * (maze_height+1) + 8 + 0; 
    index[k++] = (maze_width+1) * (maze_height+1) + 8 + 1; 
    index[k++] = (maze_width+1) * (maze_height+1) + 8 + 2; 
    index[k++] = (maze_width+1) * (maze_height+1) + 8 + 0; 
    index[k++] = (maze_width+1) * (maze_height+1) + 8 + 2; 
    index[k++] = (maze_width+1) * (maze_height+1) + 8 + 3; 
	// 填充左表面索引
    index[k++] = (maze_width+1) * (maze_height+1) + 12 + 0; 
    index[k++] = (maze_width+1) * (maze_height+1) + 12 + 1; 
    index[k++] = (maze_width+1) * (maze_height+1) + 12 + 2; 
    index[k++] = (maze_width+1) * (maze_height+1) + 12 + 0; 
    index[k++] = (maze_width+1) * (maze_height+1) + 12 + 2; 
    index[k++] = (maze_width+1) * (maze_height+1) + 12 + 3; 
	// 填充右表面索引
    index[k++] = (maze_width+1) * (maze_height+1) + 16 + 0; 
    index[k++] = (maze_width+1) * (maze_height+1) + 16 + 1; 
    index[k++] = (maze_width+1) * (maze_height+1) + 16 + 2; 
    index[k++] = (maze_width+1) * (maze_height+1) + 16 + 0; 
    index[k++] = (maze_width+1) * (maze_height+1) + 16 + 2; 
    index[k++] = (maze_width+1) * (maze_height+1) + 16 + 3;

	maze_mesh->UnlockVertexBuffer(); 

	DWORD *attr; 
	maze_mesh->LockAttributeBuffer(0, &attr); 
    for (i=0; i<maze_height; i++)
    {
        for (j=0; j<maze_width; j++)
        {
            if (matrix[i][j] == '1')
            {
                attr[(i*maze_width+j)*2] = 0; 
                attr[(i*maze_width+j)*2+1] = 0; 
            }
            else
            {
                attr[(i*maze_width+j)*2] = 1; 
                attr[(i*maze_width+j)*2+1] = 1; 
            }
        }
    }
    i = maze_height*maze_width*2; 
    for (; i<maze_height*maze_width*2+2; i++)
    {
        attr[i] = 2; 
    }
    for (; i<maze_height*maze_width*2+10; i++)
    {
        attr[i] = 3; 
    }
	maze_mesh->UnlockAttributeBuffer(); 

	vector<DWORD> adjacencyBuffer(maze_mesh->GetNumFaces() * 3);
	maze_mesh->GenerateAdjacency(0.0f, &adjacencyBuffer[0]);

	if (FAILED(maze_mesh->OptimizeInplace(		
		D3DXMESHOPT_ATTRSORT |
		D3DXMESHOPT_COMPACT  |
		D3DXMESHOPT_VERTEXCACHE,
		&adjacencyBuffer[0],
		0, 0, 0)))
    {
        ERMSG("优化失败!"); 
        return false; 
    }

	return true; 
}

bool Scene2(float timeDelta)
{
	if( Device )
	{
		Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0,0,0), 1.0f, 0);
		Device->BeginScene();
        // 
        // 画背景
        // 
            
		IDirect3DVertexBuffer9 *pBkgnd; 
		if (FAILED(Device->CreateVertexBuffer(
			6 * sizeof(VertexRHWTEX), 
			D3DUSAGE_WRITEONLY, 
			FVF_VERTEXRHWTEX, 
			D3DPOOL_MANAGED, 
			&pBkgnd, 
			0)))
		{
			ERMSG("Device->CreateVertexBuffer(pNextButton) -- FAILED"); 
			return 0; 
		}
        VertexRHWTEX *vertexrhwtex;
        pBkgnd->Lock(0, 6*sizeof(VertexRHWTEX), (void**)&vertexrhwtex, 0); 

        vertexrhwtex[0] = VertexRHWTEX(0, ScreenHeight, 0.9999f, 1.0f, 0.0f, ScreenHeight/46.0f); 
        vertexrhwtex[1] = VertexRHWTEX(0, 0, 0.9999f, 1.0f, 0.0f, 0.0f); 
        vertexrhwtex[2] = VertexRHWTEX(ScreenWidth, 0, 0.9999f, 1.0f, ScreenWidth/123.0f, 0.0f); 
        vertexrhwtex[3] = VertexRHWTEX(0, ScreenHeight, 0.9999f, 1.0f, 0.0f, ScreenHeight/46.0f); 
        vertexrhwtex[4] = VertexRHWTEX(ScreenWidth, 0, 0.9999f, 1.0f, ScreenWidth/123.0f, 0.0f); 
        vertexrhwtex[5] = VertexRHWTEX(ScreenWidth, ScreenHeight, 0.9999f, 1.0f, ScreenWidth/123.0f, ScreenHeight/46.0f); 

        pBkgnd->Unlock(); 
		Device->SetStreamSource(0, pBkgnd, 0, sizeof(VertexRHWTEX));
		Device->SetFVF(FVF_VERTEXRHWTEX); 
        Device->SetTexture(0, Texture_bkgnd); 
		Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2); 

		//
		// 创建字体
		//
		LOGFONT lf;
		ZeroMemory(&lf, sizeof(LOGFONT));
		lf.lfHeight = 20; 
		lf.lfWidth = 9; 
		lf.lfWeight = 500; 
		lf.lfCharSet = DEFAULT_CHARSET; 
		lstrcpy(lf.lfFaceName, TEXT("Times New Roman")); 

		LPD3DXFONT pFont; 
		if (FAILED(D3DXCreateFontIndirect(Device, &lf, &pFont)))
		{
			ERMSG("D3DXCreateFontIndirect -- FAILED"); 
			return 0; 
		}
		
        SetRect(&rtSelectLoadFromFile, 340, ScreenHeight-130, ScreenWidth, ScreenHeight-110); 

        TCHAR *title = TEXT("迷宫演示程序   作者：韩小龙，陈文豪，施自成，何健，陈卓");  
	    TCHAR *str1 = TEXT("请输入迷宫的宽: "); 
	    TCHAR *str2 = TEXT("请输入迷宫的高: "); 
        TCHAR *str3 = TEXT("从maze.ini文件中读取"); 
        TCHAR *str4 = TEXT("↓在此输入迷宫"); 
        TCHAR *str5 = TEXT("提示: 可以按W、S、A、D调整视角或按空格单步进行"); 
	    RECT rtTitle  = { 5,  5, ScreenWidth, 60}; 
	    RECT rtStr1   = {30, 35, 500, 55}; 
	    RECT rtInput1 = {30, 55, 500, 75}; 
	    RECT rtStr2   = {30, 75, 500, 95}; 
	    RECT rtInput2 = {30, 95, 500,115};
        RECT rtStr5   = {300, 30, ScreenWidth, 50}; 
        static float h = 165; 
        static int sign = 1; 
        if (h > 175)
        {
            sign = -1;
        }
        if (h < 165)
        {
            sign = 1; 
        }
        RECT rtStr4   = {10, h, 500, h+20}; 
        h += sign * timeDelta * 10.0f; 
		TCHAR szWidth[20], szHeight[20]; 
		_stprintf(szWidth, TEXT("%d"), maze_width); 
		_stprintf(szHeight, TEXT("%d"), maze_height); 

		pFont->Begin(); 

		pFont->DrawText(title, lstrlen(title), &rtTitle, DT_LEFT, D3DCOLOR_ARGB(255,255,255,0)); 
		pFont->DrawText(str1, lstrlen(str1), &rtStr1, DT_LEFT, D3DCOLOR_ARGB(255,255,255,0)); 
		pFont->DrawText(str2, lstrlen(str2), &rtStr2, DT_LEFT, D3DCOLOR_ARGB(255,255,255,0)); 
		pFont->DrawText(str4, lstrlen(str4), &rtStr4, DT_LEFT, D3DCOLOR_ARGB(255,255,255,0)); 
		pFont->DrawText(str5, lstrlen(str5), &rtStr5, DT_LEFT, D3DCOLOR_ARGB(255,255,255,0)); 
		
		pFont->DrawText(szWidth, lstrlen(szWidth), &rtInput1, DT_LEFT, D3DCOLOR_ARGB(255,255,255,0)); 
		pFont->DrawText(szHeight, lstrlen(szHeight), &rtInput2, DT_LEFT, D3DCOLOR_ARGB(255,255,255,0));