Archived

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

ShadowHunter

pixel data

Recommended Posts

PlayGGY    122
Well, you will have to get info from the header, or at least know when the header ends and the data begins. Do a google search for more info.

Share this post


Link to post
Share on other sites
ShadowHunter    122
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.