version4.cpp

#include <windows.h>
#include <windowsx.h>
#include <mmsystem.h>
#include <ddraw.h>

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <float.h>
#include <stdio.h>
#include <io.h>
#include <fstream.h>
#include <time.h>


// DEFINES //////////////////////////

#define WINDOW_CLASS_NAME "WINDOW_CLASS"

#define SCREEN_HEIGHT 480
#define SCREEN_WIDTH 640
#define SCREEN_BPP 8
#define MAX_COLOURS 256
#define MAP_HEIGHT 512
#define MAP_WIDTH 512

#define MAX_STEPS 400

// MACROS ///////////////////////////

#define PIE              ((double)3.14159265)
#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1:0)
#define KEY_UP(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 0:1)


// STRUCTURES ///////////////////////

typedef struct bitmap_file_tag {
       
	BITMAPFILEHEADER bitmapfileheader;  
	BITMAPINFOHEADER bitmapinfoheader;  
    PALETTEENTRY     palette[256];     
    UCHAR            *buffer;     
	
} bitmap_file, *bitmap_file_ptr;


// PROTOTYPES ///////////////////////

int DD_Init(HWND hwnd);
int DD_Shutdown();
int Set_Pal_Entry(int,int,int,int);
int LoadBitmap(bitmap_file_ptr bitmap, char *filename);
void LoadDEM();



LRESULT CALLBACK WindowFunc(HWND, UINT, WPARAM, LPARAM) ;


// GLOBAL VARIABLES

LPDIRECTDRAW pdd = NULL;
LPDIRECTDRAW4 lpdd = NULL;
LPDIRECTDRAWSURFACE4 lpddsprimary = NULL;
LPDIRECTDRAWSURFACE4 lpddsback = NULL;
LPDIRECTDRAWPALETTE lpddpal = NULL;
PALETTEENTRY colour_palette[256];
DDSURFACEDESC2 ddsd;
DDSCAPS2 ddscaps;
HRESULT ddrval;
HWND main_window_handle = NULL;
UCHAR *video_buffer = NULL;
BOOL                        g_bActive = FALSE;
bitmap_file height_bmp_file, colour_bmp_file;           
char szWinName[] = "MyWin"; 

clock_t start, finish;
double  duration;


int heights[512][512];
int colours[512][512];
int x_pos = 2, y_pos = 256, z_pos = 6000;
double pitch = -(SCREEN_HEIGHT/2);
int fov = 320;
	
	
int flag = 0, poo = 5;
double Z = 0.0, X = 0.0, trash = 0.0;

double inc = 1.0/10.0;
double convert = 2.0 * PIE / 3840.0;

void Render() {

	double x,y,z,dx,dy,m,scale,y_angle;
	int row,height,colour;
	unsigned char *pix_ptr;
	


	if (KEY_DOWN(VK_UP)) {
	x_pos+=4 * cos(fov * convert);
	y_pos+=4 * sin(fov * convert);
	if(x_pos>=MAP_HEIGHT) x_pos = MAP_HEIGHT;
	if(x_pos<=0) x_pos = 0;
	if(y_pos>=MAP_WIDTH) y_pos = MAP_WIDTH;
	if(y_pos<=0) y_pos = 0;

	}

	if (KEY_DOWN(VK_DOWN)) {
	x_pos-=4 * cos(fov * convert);
	y_pos-=4 * sin(fov * convert);
	if(x_pos>=MAP_HEIGHT) x_pos = MAP_HEIGHT;
	if(x_pos<=0) x_pos = 0;
	if(y_pos>=MAP_WIDTH) y_pos = MAP_WIDTH;
	if(y_pos<=0) y_pos = 0;
	}

	if (KEY_DOWN(VK_LEFT)) {
	fov+=32;
	if(fov>=3840) fov = 0;
	}

	if (KEY_DOWN(VK_RIGHT)) {
	fov-=32;
	if(fov<=0) fov = 3840;
	}

	if (KEY_DOWN(VK_PRIOR)) {
	pitch-=4;
	if (pitch < -1000) pitch = -1000;
	}


	if (KEY_DOWN(VK_NEXT)) {
	pitch+=4;
	if (pitch > 200) pitch = 200;
	}

	video_buffer += (SCREEN_WIDTH * (SCREEN_HEIGHT - 1)); 

	y_angle = (double) fov + 320.0;
	
	for (int col = 0; col < SCREEN_WIDTH; col++) {
	
		x = x_pos; y = y_pos; z = z_pos;
	
		dx = cos(y_angle * convert);
		dy = sin(y_angle * convert);


		m = pitch * inc;
	
		scale = 0.0;
		row = 0;
	
		pix_ptr = video_buffer;
	
		for (int i = 0; i < MAX_STEPS; i++)
			{
			 	
			x+=dx;
			y+=dy;
			z+=m;

			if (x > MAP_WIDTH || x<0 || y > MAP_HEIGHT || y<0) height = 0, colour = 0;
			else {
				height = (heights[(int)x][(int)y] - poo) * 4  ;
				colour = colours[(int)x][(int)y];
			}

			scale+=inc;
			
		
			while (height > z) {				

				*pix_ptr = colour;

				pix_ptr -= SCREEN_WIDTH;

				m += inc;
	
				z += scale;
	
				if (++row >= SCREEN_HEIGHT) {
					i = MAX_STEPS;
					break;
				}
									
				
	
			} 
	
		
			
		
		} 

	
		video_buffer++;		
		y_angle--;
	} // end Render_Terrain


}

// DIRECTX FUNCTIONS

int DD_Init(HWND hwnd)
{

	int index;
	
	if(DirectDrawCreate(NULL,&pdd,NULL)!=DD_OK)
	{
		DD_Shutdown();
		return 0;
	}

	if(pdd->QueryInterface(IID_IDirectDraw4, (LPVOID *) & lpdd ) != DD_OK)
	{
		DD_Shutdown();
		return 0;
	}

	if(lpdd->SetCooperativeLevel(hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN ) != DD_OK )
	{
		DD_Shutdown();
		return 0;
	}


	if(lpdd->SetDisplayMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,0,0) != DD_OK)
	{
		DD_Shutdown();
		return 0;
	}

	ZeroMemory(&ddsd, sizeof(ddsd));
 	ddsd.dwSize = sizeof(ddsd);
	ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
	ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
	ddsd.dwBackBufferCount = 1;



	if (lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL) != DD_OK)
	{
		DD_Shutdown();
		return 0;
	}


	ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
	if (lpddsprimary->GetAttachedSurface(&ddscaps,&lpddsback) != DD_OK)
	{
		DD_Shutdown();
		return 0;
	}

	memset(colour_palette,0,256*sizeof(PALETTEENTRY));

	for(index = 0; index < 256; index++ ) 
	{
		
		
			colour_palette[index].peRed = colour_bmp_file.palette[index].peBlue ;
			colour_palette[index].peBlue = colour_bmp_file.palette[index].peRed;
			colour_palette[index].peGreen = colour_bmp_file.palette[index].peGreen;
		
		
		colour_palette[index].peFlags = PC_NOCOLLAPSE;
				
	}

	if(lpdd->CreatePalette((DDPCAPS_8BIT | DDPCAPS_INITIALIZE | DDPCAPS_ALLOW256),colour_palette,&lpddpal,NULL)!=DD_OK)
	{
		DD_Shutdown();
		return 0;
	}

	lpddsprimary->SetPalette(lpddpal);
//	lpddsback->SetPalette(lpddpal);

	

	return 1;

} // end DD_Init

int DD_Shutdown () 
{
	
	
	if(lpdd) 
	{
	
		if (lpddsprimary) 
		{
			lpddsprimary->Release();
			lpddsprimary = NULL;
				
		}
		lpdd->Release();
		lpdd = NULL;

		return 1;
	}
	return 0;

} // end DD_Shutdown


int Set_Palette_Entry(int index, int red, int blue, int green)
{
	PALETTEENTRY colour;

	colour.peRed = (BYTE)red;
	colour.peGreen = (BYTE)green;
	colour.peBlue = (BYTE)blue;
	colour.peFlags = PC_NOCOLLAPSE;

	lpddpal->SetEntries(0,index,1,&colour);

	memcpy(&colour_palette[index], &colour, sizeof(PALETTEENTRY));

	return 1;
}



// MAIN windows function

int WINAPI WinMain(HINSTANCE hThisInst, HINSTANCE hPrevInst, LPSTR lpszArgs, int nWinMode)
{
	HWND hwnd;
	MSG msg;
	WNDCLASS wcl;
	HDC hdc;
	char buffer[] = "hello";

	wcl.hInstance = hThisInst;
	wcl.lpszClassName = WINDOW_CLASS_NAME;
	wcl.lpfnWndProc = WindowFunc;
	wcl.style = CS_HREDRAW | CS_VREDRAW;

	wcl.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	//wcl.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
	wcl.hCursor = LoadCursor(NULL, IDC_ARROW);

	wcl.lpszMenuName = WINDOW_CLASS_NAME;
	wcl.cbClsExtra = 0;
	wcl.cbWndExtra = 0;	

	wcl.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);
	

	if(!RegisterClass(&wcl)) return 0;

	if(!(hwnd = CreateWindowEx (
		WS_EX_TOPMOST,
		WINDOW_CLASS_NAME,
		"My First Proper Thing 2",
		WS_POPUP,
		0,
		0,
		GetSystemMetrics(SM_CXSCREEN),
		GetSystemMetrics(SM_CYSCREEN),
		NULL,
		NULL,
		hThisInst,
		NULL
		))) return 0;

	ShowWindow(hwnd, nWinMode);
	UpdateWindow(hwnd);
	SetFocus(hwnd);
	ShowCursor(0);
	main_window_handle = hwnd;

	LoadBitmap(&colour_bmp_file,"lassen.bmp");
//	LoadBitmap(&height_bmp_file,"heightd2.bmp");
	
	if (!DD_Init(hwnd))
	{

		DestroyWindow(hwnd);
		return 0;
	}


	ofstream fout("myfile.dem");

	int i,j
		,index = 0;
	for ( i = 0; i < 512; i++) {

		for ( j = 0; j < 512; j++) {

			heights[i][j] = 0;
		
		}	

	}

	LoadDEM();

	index = 0;
	for ( i = 0; i < 512; i++) {

		for ( j = 0; j < 512; j++) {

			if ((colours[i][j] = colour_bmp_file.buffer[index++])>250) colours[i][j] = 250;
//			colours[i][j] = ((double)heights[i][j] / (double) poo) * 200.0;
		
		}	

	
	}



	for ( i = 0; i < 512; i++) {

		for ( j = 0; j < 512; j++) {

//			heights[i][j] = height_bmp_file.buffer[index++] * 8;
			fout << heights[i][j] << " ";
		
		}	

	fout << "\n";
	}


	fout.close();


	while (1) 
	{
		if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
		{
			if(msg.message == WM_QUIT) { DD_Shutdown(); break; }
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		} 
		else 
		{	
			
			memset(&ddsd,0,sizeof(ddsd));
			ddsd.dwSize = sizeof(ddsd);


		



			
			while ( lpddsback->Lock(NULL,&ddsd,DDLOCK_SURFACEMEMORYPTR,NULL) != DD_OK);

				video_buffer = (UCHAR *) ddsd.lpSurface;

				memset(video_buffer,250,SCREEN_WIDTH*SCREEN_HEIGHT);


				start = clock();

				Render();

				finish = clock();
			
				lpddsback->Unlock(NULL);
			
		duration = (double) (finish - start) / CLOCKS_PER_SEC;	

		sprintf(buffer,"%2.0f",1/duration);
	

		if (lpddsback->GetDC(&hdc) == DD_OK) {
		 
			 SetBkColor(hdc, RGB(0, 0, 255));
			SetTextColor(hdc, RGB(255, 255, 0));
       
            TextOut(hdc, 0, 0, buffer, lstrlen(buffer));
           
		
        lpddsback->ReleaseDC(hdc);
		}

		
//Z+=10;
if (Z>3840.0) Z -=3840.0;

			while (TRUE)
               {
                   ddrval = lpddsprimary->Flip(NULL, 0);
                   if (ddrval == DD_OK)
					  
					   
                       break;
                   if (ddrval == DDERR_SURFACELOST)
                   {
                       ddrval = lpddsprimary->Restore();
                       if (ddrval != DD_OK)
                           break;
                   }
                   if (ddrval != DDERR_WASSTILLDRAWING)
                       break; 
			} 
			
            
			if (KEY_DOWN(VK_ESCAPE)) {
				
			DD_Shutdown();
			
				PostMessage(main_window_handle,WM_CLOSE,0,0);
			}
		} 
	}

	DD_Shutdown();

	return(msg.wParam);

}


// Message Function

LRESULT CALLBACK WindowFunc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{

	switch(message) {
	case WM_ACTIVATE:
            g_bActive = wParam;
            return 0L;

	case WM_SETCURSOR:
            // Turn off the cursor since this is a full-screen app
            SetCursor(NULL);
            return TRUE;
	case WM_DESTROY:
		DD_Shutdown();
		PostQuitMessage(0);
		return 0L;
		break;
	}
	
	return DefWindowProc(hwnd,message,wParam,lParam);
	
}

int LoadBitmap(bitmap_file_ptr bitmap, char *filename)
{
// this function opens a bitmap file and loads the data into bitmap
// this function will only work with non-compressed 8 bit palettized images
// it uses file handles instead of streams just for a change, no reason

#define BITMAP_ID        0x4D42       // this is the universal id for a bitmap

int      file_handle,                 // the file handle
         index;                       // looping index

OFSTRUCT file_data;                   // the file data information

// open the file if it exists
if ((file_handle = OpenFile(filename,&file_data,OF_READ))==-1)
   return(0);
 
// now load the bitmap file header
_lread(file_handle, &bitmap->bitmapfileheader,sizeof(BITMAPFILEHEADER));

// test if this is a bitmap file
if (bitmap->bitmapfileheader.bfType!=BITMAP_ID)
   {
   // close the file
   _lclose(file_handle);
 
   // return error
   return(0);

   } // end if

// we know this is a bitmap, so read in all the sections

// load the bitmap file header
_lread(file_handle, &bitmap->bitmapinfoheader,sizeof(BITMAPINFOHEADER));

// now the palette
_lread(file_handle, &bitmap->palette,256*sizeof(PALETTEENTRY));


// finally the image data itself
_lseek(file_handle,-(int)(bitmap->bitmapinfoheader.biSizeImage),SEEK_END);

// allocate the memory for the image
if (!(bitmap->buffer = new UCHAR [bitmap->bitmapinfoheader.biSizeImage]))
   {
   // close the file
   _lclose(file_handle);

   // return error
   return(0);

   } // end if

// now read it in
_lread(file_handle,bitmap->buffer,bitmap->bitmapinfoheader.biSizeImage);

// bitmaps are usually upside down, so flip the image
int biWidth  = bitmap->bitmapinfoheader.biWidth,
    biHeight = bitmap->bitmapinfoheader.biHeight;

// allocate the temporary buffer
UCHAR *flip_buffer = new UCHAR[biWidth*biHeight];

// copy image to work area
memcpy(flip_buffer,bitmap->buffer,biWidth*biHeight);

// flip vertically
for (index=0; index<biHeight; index++)
    memcpy(&bitmap->buffer[((biHeight-1) - index)*biWidth],&flip_buffer[index * biWidth], biWidth);

// release the working memory
delete [] flip_buffer;

// close the file
_lclose(file_handle);

// return success
return(1);

} // end Load_Bitmap_File

void LoadDEM() {

	int profile, points, templow = 6000, temphigh = 0;
	char ch = 0;
	
	ifstream fin("lassen.txt");
 	
	while (!fin.eof()) {

		fin >> poo;

		fin >> profile >> points;

		fin >> poo; 

		fin >> trash >> trash >> trash >> trash >> trash;

		for (int j = 0; j < points; j++) {

			fin >> poo;
			if(poo < templow) templow = poo;
			if(poo > temphigh) temphigh = poo;
			heights[profile][j] = poo;
			
		}
		
	

	} 

	fin.close();
	poo =  templow;

}