340 lines
8.0 KiB
C++
340 lines
8.0 KiB
C++
#include <windows.h>
|
|
#include <gl/gl.h>
|
|
#include <string>
|
|
#include <jpeglib.h>
|
|
#include <stdio.h>
|
|
#include <iostream>
|
|
using namespace std;
|
|
|
|
LRESULT CALLBACK WindowProc(HWND, UINT, WPARAM, LPARAM);
|
|
void EnableOpenGL(HWND hwnd, HDC*, HGLRC*);
|
|
void DisableOpenGL(HWND, HDC, HGLRC);
|
|
GLuint LoadTexture(char *filename,int *textw,int *texth);
|
|
void DrawTexture(int x, int y, GLuint textureid,int textw,int texth);
|
|
int * loadJpg(const char* Name);
|
|
|
|
|
|
int WINAPI WinMain(HINSTANCE hInstance,
|
|
HINSTANCE hPrevInstance,
|
|
LPSTR lpCmdLine,
|
|
int nCmdShow)
|
|
{
|
|
WNDCLASSEX wcex;
|
|
HWND hwnd;
|
|
HDC hDC;
|
|
HGLRC hRC;
|
|
MSG msg;
|
|
BOOL bQuit = FALSE;
|
|
float theta = 0.0f;
|
|
|
|
|
|
|
|
|
|
/* register window class */
|
|
wcex.cbSize = sizeof(WNDCLASSEX);
|
|
wcex.style = CS_OWNDC;
|
|
wcex.lpfnWndProc = WindowProc;
|
|
wcex.cbClsExtra = 0;
|
|
wcex.cbWndExtra = 0;
|
|
wcex.hInstance = hInstance;
|
|
wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
|
|
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
|
|
wcex.lpszMenuName = NULL;
|
|
wcex.lpszClassName = "GLSample";
|
|
wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);;
|
|
|
|
|
|
if (!RegisterClassEx(&wcex))
|
|
return 0;
|
|
|
|
/* create main window */
|
|
hwnd = CreateWindowEx(0,
|
|
"GLSample",
|
|
"OpenGL Sample",
|
|
WS_OVERLAPPEDWINDOW,
|
|
CW_USEDEFAULT,
|
|
CW_USEDEFAULT,
|
|
256,
|
|
256,
|
|
NULL,
|
|
NULL,
|
|
hInstance,
|
|
NULL);
|
|
|
|
ShowWindow(hwnd, nCmdShow);
|
|
|
|
/* enable OpenGL for the window */
|
|
EnableOpenGL(hwnd, &hDC, &hRC);
|
|
|
|
/* program main loop */
|
|
while (!bQuit)
|
|
{
|
|
/* check for messages */
|
|
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
/* handle or dispatch messages */
|
|
if (msg.message == WM_QUIT)
|
|
{
|
|
bQuit = TRUE;
|
|
}
|
|
else
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* OpenGL animation code goes here */
|
|
|
|
/*glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
glPushMatrix();
|
|
glRotatef(theta, 0.0f, 0.0f, 1.0f);
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
|
|
glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(0.0f, 1.0f);
|
|
glColor3f(0.0f, 1.0f, 0.0f); glVertex2f(0.87f, -0.5f);
|
|
glColor3f(0.0f, 0.0f, 1.0f); glVertex2f(-0.87f, -0.5f);
|
|
|
|
glEnd();
|
|
|
|
glPopMatrix();
|
|
|
|
SwapBuffers(hDC);
|
|
|
|
theta += 1.0f;*/
|
|
|
|
|
|
GLuint myglu;
|
|
int textw, texth;
|
|
|
|
string tmp = "img/foregrounds/2.jpeg";
|
|
char tab2[1024];
|
|
strncpy(tab2, tmp.c_str(), sizeof(tab2));
|
|
tab2[sizeof(tab2) - 1] = 0;
|
|
|
|
|
|
myglu=LoadTexture(tab2,&textw,&texth);
|
|
DrawTexture(100,100,myglu,textw,texth);
|
|
|
|
SwapBuffers(hDC);
|
|
|
|
Sleep (1);
|
|
}
|
|
}
|
|
|
|
/* shutdown OpenGL */
|
|
DisableOpenGL(hwnd, hDC, hRC);
|
|
|
|
/* destroy the window explicitly */
|
|
DestroyWindow(hwnd);
|
|
|
|
return msg.wParam;
|
|
}
|
|
|
|
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WM_CLOSE:
|
|
PostQuitMessage(0);
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
return 0;
|
|
|
|
case WM_KEYDOWN:
|
|
{
|
|
switch (wParam)
|
|
{
|
|
case VK_ESCAPE:
|
|
PostQuitMessage(0);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void EnableOpenGL(HWND hwnd, HDC* hDC, HGLRC* hRC)
|
|
{
|
|
PIXELFORMATDESCRIPTOR pfd;
|
|
|
|
int iFormat;
|
|
|
|
/* get the device context (DC) */
|
|
*hDC = GetDC(hwnd);
|
|
|
|
/* set the pixel format for the DC */
|
|
ZeroMemory(&pfd, sizeof(pfd));
|
|
|
|
pfd.nSize = sizeof(pfd);
|
|
pfd.nVersion = 1;
|
|
pfd.dwFlags = PFD_DRAW_TO_WINDOW |
|
|
PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
|
|
pfd.iPixelType = PFD_TYPE_RGBA;
|
|
pfd.cColorBits = 24;
|
|
pfd.cDepthBits = 16;
|
|
pfd.iLayerType = PFD_MAIN_PLANE;
|
|
|
|
iFormat = ChoosePixelFormat(*hDC, &pfd);
|
|
|
|
SetPixelFormat(*hDC, iFormat, &pfd);
|
|
|
|
/* create and enable the render context (RC) */
|
|
*hRC = wglCreateContext(*hDC);
|
|
|
|
wglMakeCurrent(*hDC, *hRC);
|
|
}
|
|
|
|
void DisableOpenGL (HWND hwnd, HDC hDC, HGLRC hRC)
|
|
{
|
|
wglMakeCurrent(NULL, NULL);
|
|
wglDeleteContext(hRC);
|
|
ReleaseDC(hwnd, hDC);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
GLuint LoadTexture(char *filename,int *textw,int *texth) {
|
|
|
|
GLuint textureid;
|
|
int mode = GL_RGBA;
|
|
|
|
//surface = IMG_Load(filename);
|
|
|
|
int * pixels = loadJpg(filename);
|
|
|
|
*textw=10;
|
|
*texth=10;
|
|
// create one texture name
|
|
glGenTextures(1, &textureid);
|
|
|
|
// tell opengl to use the generated texture name
|
|
glBindTexture(GL_TEXTURE_2D, textureid);
|
|
|
|
// this reads from the sdl surface and puts it into an opengl texture
|
|
glTexImage2D(GL_TEXTURE_2D, 0, mode, 10, 10, 0, mode, GL_UNSIGNED_BYTE, pixels);
|
|
|
|
// these affect how this texture is drawn later on...
|
|
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
|
|
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
|
|
|
|
return textureid;
|
|
|
|
}
|
|
|
|
|
|
|
|
void DrawTexture(int x, int y, GLuint textureid,int textw,int texth) {
|
|
|
|
//int textw,texth;
|
|
// tell opengl to use the generated texture name
|
|
glBindTexture(GL_TEXTURE_2D, textureid);
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
// make a rectangle
|
|
glBegin(GL_QUADS);
|
|
|
|
// top left
|
|
glTexCoord2i(0, 0);
|
|
glVertex3f(x, y, 0);
|
|
|
|
// top right
|
|
glTexCoord2i(1, 0);
|
|
glVertex3f(x+textw, y, 0);
|
|
|
|
// bottom right
|
|
glTexCoord2i(1, 1);
|
|
glVertex3f(x+textw, y+texth, 0);
|
|
|
|
// bottom left
|
|
glTexCoord2i(0, 1);
|
|
glVertex3f(x, y+texth, 0);
|
|
|
|
glEnd();
|
|
|
|
glDisable(GL_TEXTURE_2D );
|
|
}
|
|
|
|
|
|
|
|
|
|
int * loadJpg(const char* Name) {
|
|
unsigned char a, r, g, b;
|
|
int width, height;
|
|
struct jpeg_decompress_struct cinfo;
|
|
struct jpeg_error_mgr jerr;
|
|
|
|
FILE * infile; /* source file */
|
|
JSAMPARRAY pJpegBuffer; /* Output row buffer */
|
|
int row_stride; /* physical row width in output buffer */
|
|
if ((infile = fopen(Name, "rb")) == NULL) {
|
|
fprintf(stderr, "can't open %s\n", Name);
|
|
return 0;
|
|
}
|
|
cinfo.err = jpeg_std_error(&jerr);
|
|
jpeg_create_decompress(&cinfo);
|
|
jpeg_stdio_src(&cinfo, infile);
|
|
(void) jpeg_read_header(&cinfo, TRUE);
|
|
(void) jpeg_start_decompress(&cinfo);
|
|
width = cinfo.output_width;
|
|
height = cinfo.output_height;
|
|
|
|
unsigned char * pDummy = new unsigned char [width*height*4];
|
|
unsigned char * pTest = pDummy;
|
|
if (!pDummy) {
|
|
printf("NO MEM FOR JPEG CONVERT!\n");
|
|
return 0;
|
|
}
|
|
row_stride = width * cinfo.output_components;
|
|
pJpegBuffer = (*cinfo.mem->alloc_sarray)
|
|
((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
|
|
|
|
while (cinfo.output_scanline < cinfo.output_height) {
|
|
(void) jpeg_read_scanlines(&cinfo, pJpegBuffer, 1);
|
|
for (int x = 0; x < width; x++) {
|
|
a = 0; // alpha value is not supported on jpg
|
|
r = pJpegBuffer[0][cinfo.output_components * x];
|
|
if (cinfo.output_components > 2) {
|
|
g = pJpegBuffer[0][cinfo.output_components * x + 1];
|
|
b = pJpegBuffer[0][cinfo.output_components * x + 2];
|
|
} else {
|
|
g = r;
|
|
b = r;
|
|
}
|
|
*(pDummy++) = b;
|
|
*(pDummy++) = g;
|
|
*(pDummy++) = r;
|
|
*(pDummy++) = a;
|
|
}
|
|
}
|
|
fclose(infile);
|
|
(void) jpeg_finish_decompress(&cinfo);
|
|
jpeg_destroy_decompress(&cinfo);
|
|
|
|
/*BMap = (int*)pTest;
|
|
Height = height;
|
|
Width = width;
|
|
Depth = 32;*/
|
|
int * pJetze = (int*)pTest;
|
|
cout << width << endl;
|
|
return pJetze;
|
|
}
|