Archived

This topic is now archived and is closed to further replies.

ShadowHunter

pixel data

Recommended Posts

here is my source code, does anyone have anything specific??

#define WIN32_LEAN_AND_MEAN		// trim the excess fat from Windows

////// Defines

#define BITMAP_ID 0x4D42 // the universal bitmap ID


#pragma comment(lib, "OpenGL32.lib")
#pragma comment(lib, "GLU32.lib")

////// Includes

#include <iostream.h>
#include <windows.h> // standard Windows app include

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gl/gl.h> // standard OpenGL include

#include <gl/glu.h> // OpenGL utilties

#include <gl/glaux.h> // OpenGL auxiliary functions

int stoptime, sleeptime = .01;

////// Global Variables

HDC g_HDC; // global device context

bool fullScreen = false; // true = fullscreen; false = windowed

bool keyPressed[256]; // holds true for keys that are pressed

int x = 20, y = 20, yvel = 1, xvel = 1, z = 1;
//SHORT GetAsyncKeyState(int vkey);

#define KEY_DOWN(vkey)
#define KEY_UP(vkey)
////// Bitmap Information

BITMAPINFOHEADER bitmapInfoHeader[8]; // bitmap info header

unsigned char* bitmapData[8]; // the bitmap data

char *message;
char *string[8] = {"top.bmp", "right.bmp", "bottom.bmp", "left.bmp", "top.bmp"};
// DrawBitmap

// desc: draws the bitmap image data in bitmapImage at the location

// (350,300) in the window. (350,300) is the lower-left corner

// of the bitmap.

/*void DrawBitmap(long width, long height, unsigned char* bitmapImage)
{
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glRasterPos2i(x,y);
glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, bitmapImage);
}
*/


void input1 ()
{
if(GetAsyncKeyState(VK_RETURN))
cin.getline(message, 80);
cout << message << endl;
}
void DrawBitmap(long width, long height, unsigned char* bitmapImage);
unsigned char *LoadBitmapFile(char *filename, BITMAPINFOHEADER *bitmapInfoHeader);
void Render();
void Initialize();
void SetupPixelFormat(HDC hDC);
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);

// the main windows entry point

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
WNDCLASSEX windowClass; // window class

HWND hwnd; // window handle

MSG msg; // message

bool done; // flag saying when our app is complete

DWORD dwExStyle; // Window Extended Style

DWORD dwStyle; // Window Style

RECT windowRect;

// temp var''s

int width = 800;
int height = 600;
int bits = 32;

//fullScreen = TRUE;


windowRect.left=(long)0; // Set Left Value To 0

windowRect.right=(long)width; // Set Right Value To Requested Width

windowRect.top=(long)0; // Set Top Value To 0

windowRect.bottom=(long)height; // Set Bottom Value To Requested Height


// fill out the window class structure

windowClass.cbSize = sizeof(WNDCLASSEX);
windowClass.style = CS_HREDRAW | CS_VREDRAW;
windowClass.lpfnWndProc = WndProc;
windowClass.cbClsExtra = 0;
windowClass.cbWndExtra = 0;
windowClass.hInstance = hInstance;
windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION); // default icon

windowClass.hCursor = LoadCursor(NULL, IDC_ARROW); // default arrow

windowClass.hbrBackground = NULL; // don''t need background

windowClass.lpszMenuName = NULL; // no menu

windowClass.lpszClassName = "MyClass";
windowClass.hIconSm = LoadIcon(NULL, IDI_WINLOGO); // windows logo small icon


// register the windows class

if (!RegisterClassEx(&windowClass))
return 0;

if (fullScreen) // fullscreen?

{
DEVMODE dmScreenSettings; // device mode

memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = width; // screen width

dmScreenSettings.dmPelsHeight = height; // screen height

dmScreenSettings.dmBitsPerPel = bits; // bits per pixel

dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

//

if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{
// setting display mode failed, switch to windowed

MessageBox(NULL, "Display mode failed", NULL, MB_OK);
fullScreen=FALSE;
}
}

if (fullScreen) // Are We Still In Fullscreen Mode?

{
dwExStyle=WS_EX_APPWINDOW; // Window Extended Style

dwStyle=WS_POPUP; // Windows Style

ShowCursor(FALSE); // Hide Mouse Pointer

}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style

dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style

}

AdjustWindowRectEx(&windowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size


// class registered, so now create our window

hwnd = CreateWindowEx(NULL, // extended style

"MyClass", // class name

"Bitmap Example 1: Displaying a bitmap", // app name

dwStyle | WS_CLIPCHILDREN |
WS_CLIPSIBLINGS,
0, 0, // x,y coordinate

windowRect.right - windowRect.left,
windowRect.bottom - windowRect.top, // width, height

NULL, // handle to parent

NULL, // handle to menu

hInstance, // application instance

NULL); // no extra params


// check if window creation failed (hwnd would equal NULL)

if (!hwnd)
return 0;

ShowWindow(hwnd, SW_SHOW); // display the window

UpdateWindow(hwnd); // update the window


done = false; // intialize the loop condition variable

Initialize(); // initialize OpenGL

//glEnable(GL_BLEND);

// main message loop

while (!done)
{
PeekMessage(&msg, hwnd, NULL, NULL, PM_REMOVE);

if (msg.message == WM_QUIT) // do we receive a WM_QUIT message?

{
done = true; // if so, time to quit the application

}
else
{
if (keyPressed[VK_ESCAPE])
done = true;
else
{

if(x <= 0)
x = x + xvel;
if(x >= 400)
x = x - xvel;
if(y <= 0)
y = y + yvel;
if(y >= 400)
y = y - yvel;

if (GetAsyncKeyState(VK_UP))
{
y = y + yvel;
z = 4;
//Initialize();

}
if (GetAsyncKeyState(VK_RIGHT))
{
x = x + xvel;
z = 1;
//Initialize();

}
if (GetAsyncKeyState(VK_DOWN))
{
y = y - yvel;
z = 2;
//Initialize();

}
if (GetAsyncKeyState(VK_LEFT))
{
x = x - xvel;
z = 3;
//Initialize();

}

Render();

stoptime = time(NULL) + sleeptime;
while (stoptime != time(NULL))
{
}

//input1();

TranslateMessage(&msg); // translate and dispatch to event queue

DispatchMessage(&msg);
}
}
}

for(int ID = 0; ID < 7; ID++)
{
if(bitmapData[ID])
{
free(bitmapData[ID]);
bitmapData[ID] = NULL;
}
}

if (fullScreen)
{
ChangeDisplaySettings(NULL,0); // If So Switch Back To The Desktop

ShowCursor(TRUE); // Show Mouse Pointer

}

return msg.wParam;
}


void DrawBitmap(long width, long height, unsigned char* bitmapData)
{
if(bitmapData == NULL)
{
return ;
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 4); glRasterPos2i(x,y);
glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, bitmapData);
}
// LoadBitmapFile

// desc: Returns a pointer to the bitmap image of the bitmap specified

// by filename. Also returns the bitmap header information.

// No support for 8-bit bitmaps.

/*unsigned char *LoadBitmapFile(char *filename, BITMAPINFOHEADER *bitmapInfoHeader)
{
FILE *filePtr; // the file pointer
BITMAPFILEHEADER bitmapFileHeader; // bitmap file header
unsigned char *bitmapImage; // bitmap image data
int imageIdx = 0; // image index counter
unsigned char tempRGB; // swap variable

// open filename in "read binary" mode
filePtr = fopen(filename, "rb");
if (filePtr == NULL)
return NULL;

// read the bitmap file header
fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER), 1, filePtr);

// verify that this is a bitmap by checking for the universal bitmap id
if (bitmapFileHeader.bfType != BITMAP_ID)
{
fclose(filePtr);
return NULL;
}

// read the bitmap information header
fread(bitmapInfoHeader, sizeof(BITMAPINFOHEADER), 1, filePtr);

// move file pointer to beginning of bitmap data
fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);

// allocate enough memory for the bitmap image data
bitmapImage = (unsigned char*)malloc(bitmapInfoHeader->biSizeImage);

// verify memory allocation
if (!bitmapImage)
{
free(bitmapImage);
fclose(filePtr);
return NULL;
}

// read in the bitmap image data
fread(bitmapImage, 1, bitmapInfoHeader->biSizeImage, filePtr);

// make sure bitmap image data was read
if (bitmapImage == NULL)
{
fclose(filePtr);
return NULL;
}

// swap the R and B values to get RGB since the bitmap color format is in BGR
for (imageIdx = 0; imageIdx < bitmapInfoHeader->biSizeImage; imageIdx+=3)
{
tempRGB = bitmapImage[imageIdx];
bitmapImage[imageIdx] = bitmapImage[imageIdx + 2];
bitmapImage[imageIdx + 2] = tempRGB;
}

// close the file and return the bitmap image data
fclose(filePtr);
return bitmapImage;
}
*/


unsigned char *LoadBitmapFile(char *filename, BITMAPINFOHEADER *bitmapInfoHeader)
{
FILE *filePtr;
BITMAPFILEHEADER bitmapFileHeader;
unsigned char *bitmapImage;
unsigned int imageIdx = 0;
unsigned char tempRGB;

filePtr = fopen(filename, "rb");
if(filePtr == NULL)
{
//MessageBox(NULL, "Error opening the bitmap file...", "[ERROR]", MB_OK);

return NULL;
}

// read the bitmap file header

fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER), 1, filePtr);

// verify that this is a bitmap by checking for the universal bitmap id

if (bitmapFileHeader.bfType != BITMAP_ID)
{
MessageBox(NULL, "Invalid bitmap file...", "[ERROR]", MB_OK);
fclose(filePtr);
return NULL;
}

// read the bitmap information header

fread(bitmapInfoHeader, sizeof(BITMAPINFOHEADER), 1, filePtr);
// move file pointer to beginning of bitmap data

fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);

// allocate enough memory for the bitmap image data

bitmapImage = (unsigned char*)malloc(bitmapInfoHeader->biSizeImage);
// verify memory allocation

if(!bitmapImage)
{
//free(bitmapImage); //--Already NULL

MessageBox(NULL, "Unable to allocate memory for the bitmap...", "[ERROR]", MB_OK);
fclose(filePtr);
return NULL;
}

// read in the bitmap image data

fread(bitmapImage, 1, bitmapInfoHeader->biSizeImage, filePtr);
// make sure bitmap image data was read

if(bitmapImage == NULL)
{
MessageBox(NULL, "Error reading the bitmap bits...", "[ERROR]", MB_OK);
fclose(filePtr);
return NULL;
}

// swap the R and B values to get RGB since the bitmap color format is in BGR

for (imageIdx = 0; imageIdx < bitmapInfoHeader->biSizeImage; imageIdx+=3)
{
tempRGB = bitmapImage[imageIdx];
bitmapImage[imageIdx] = bitmapImage[imageIdx + 2];
bitmapImage[imageIdx + 2] = tempRGB;
}

// close the file and return the bitmap image data

fclose(filePtr);
return bitmapImage;
}
// Initialize

// desc: initializes OpenGL

void Initialize()
{
// enable depth buffer, and backface culling

glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);

// Clear background to black

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

// load our bitmap file

for(int ID = 0; ID < 7; ID++)
{
bitmapData[ID] = LoadBitmapFile(string[ID], &bitmapInfoHeader[ID]);
}
}

// Render

// desc: handles drawing of scene


void Render()
{
// clear screen and depth buffer

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// draw the bitmap image

DrawBitmap(bitmapInfoHeader[z].biWidth, bitmapInfoHeader[z].biHeight, bitmapData[z]);

glFlush();
SwapBuffers(g_HDC); // bring backbuffer to foreground

}

// function to set the pixel format for the device context

void SetupPixelFormat(HDC hDC)
{
int nPixelFormat; // our pixel format index


static PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), // size of structure

1, // default version

PFD_DRAW_TO_WINDOW | // window drawing support

PFD_SUPPORT_OPENGL | // OpenGL support

PFD_DOUBLEBUFFER, // double buffering support

PFD_TYPE_RGBA, // RGBA color mode

32, // 32 bit color mode

0, 0, 0, 0, 0, 0, // ignore color bits, non-palettized mode

0, // no alpha buffer

0, // ignore shift bit

0, // no accumulation buffer

0, 0, 0, 0, // ignore accumulation bits

16, // 16 bit z-buffer size

0, // no stencil buffer

0, // no auxiliary buffer

PFD_MAIN_PLANE, // main drawing plane

0, // reserved

0, 0, 0 }; // layer masks ignored


nPixelFormat = ChoosePixelFormat(hDC, &pfd); // choose best matching pixel format


SetPixelFormat(hDC, nPixelFormat, &pfd); // set pixel format to device context

}

// the Windows Procedure event handler

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HGLRC hRC; // rendering context

static HDC hDC; // device context

int width, height; // window width and height


switch(message)
{
case WM_CREATE: // window is being created


hDC = GetDC(hwnd); // get current window''s device context

g_HDC = hDC;
SetupPixelFormat(hDC); // call our pixel format setup function


// create rendering context and make it current

hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);

return 0;
break;

case WM_CLOSE: // windows is closing


// deselect rendering context and delete it

wglMakeCurrent(hDC, NULL);
wglDeleteContext(hRC);

// send WM_QUIT to message queue

PostQuitMessage(0);

return 0;
break;

case WM_SIZE:
height = HIWORD(lParam); // retrieve width and height

width = LOWORD(lParam);

if (height==0) // don''t want a divide by zero

{
height=1;
}

glViewport(0, 0, width, height); // reset the viewport to new dimensions

glMatrixMode(GL_PROJECTION); // set projection matrix current matrix

glLoadIdentity(); // reset projection matrix


// calculate aspect ratio of window

//gluPerspective(54.0f,(GLfloat)width/(GLfloat)height,1.0f,1000.0f);

glOrtho(0.0f, width - 1.0, 0.0, height - 1.0, -1.0, 1.0);

glMatrixMode(GL_MODELVIEW); // set modelview matrix

glLoadIdentity(); // reset modelview matrix


return 0;
break;

case WM_KEYDOWN: // is a key pressed?

keyPressed[wParam] = true;
return 0;
break;

case WM_KEYUP:
keyPressed[wParam] = false;
return 0;
break;

default:
break;
}

return (DefWindowProc(hwnd, message, wParam, lParam));
}

Share this post


Link to post
Share on other sites
Guest
This topic is now closed to further replies.