302 lines
8.2 KiB
C++
302 lines
8.2 KiB
C++
#include <windows.h>
|
|
#include <gl/gl.h>
|
|
#include <iostream>
|
|
#include <stdio.h>
|
|
#include <jpeglib.h>
|
|
#include <GLFW/glfw.h>
|
|
|
|
using namespace std;
|
|
|
|
LRESULT CALLBACK WindowProc(HWND, UINT, WPARAM, LPARAM);
|
|
void EnableOpenGL(HWND hwnd, HDC*, HGLRC*);
|
|
void DisableOpenGL(HWND, HDC, HGLRC);
|
|
|
|
|
|
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;
|
|
}
|
|
|
|
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);;
|
|
|
|
|
|
int * pJetze = loadJpg("../img/foregrounds/2.jpeg");
|
|
cout << pJetze[0] << endl;
|
|
cout << pJetze[1] << endl;
|
|
cout << pJetze[2] << endl;
|
|
cout << pJetze[3] << endl;
|
|
cout << "Hello world!" << endl;
|
|
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 10, 10, 0, GL_RGBA8, GL_UNSIGNED_INT, pJetze);
|
|
|
|
|
|
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 */
|
|
bool first = true;
|
|
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
|
|
{
|
|
if (first) {
|
|
first = false;
|
|
|
|
|
|
GLuint textureid;
|
|
glGenTextures(1, &textureid);
|
|
glBindTexture(GL_TEXTURE_2D, textureid);
|
|
// Black/white checkerboard
|
|
float pixels[] = {
|
|
1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f,
|
|
1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f
|
|
};
|
|
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0, GL_RGB, GL_FLOAT, pixels);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 10, 10, 0, GL_RGBA8, GL_UNSIGNED_BYTE, pJetze);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, textureid);
|
|
glBegin(GL_TRIANGLES);
|
|
|
|
glTexCoord2f(0, 0); glVertex3f( -2, 0, -2 );
|
|
glTexCoord2f(2, 0); glVertex3f( 2, 0, -2 );
|
|
glTexCoord2f(0, 2); glVertex3f( -2, 2, -2 );
|
|
|
|
glEnd();
|
|
SwapBuffers(hDC);
|
|
|
|
}
|
|
/* OpenGL animation code goes here */
|
|
|
|
//glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
|
//glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
/*glBindTexture(GL_TEXTURE_2D, *pJetze);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 10, 10, 0, GL_RGBA8, GL_UNSIGNED_BYTE, &pJetze);
|
|
|
|
GLuint textures;
|
|
glGenTextures(1, &textures);
|
|
int width, height;
|
|
unsigned char* image;
|
|
|
|
//glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, textures);
|
|
//image = SOIL_load_image("sample.png", &width, &height, 0, SOIL_LOAD_RGB);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 10, 10, 0, GL_RGBA8,
|
|
GL_UNSIGNED_BYTE, pJetze);
|
|
//SOIL_free_image_data(image);
|
|
//glUniform1i(glGetUniformLocation(shaderProgram, "texKitten"), 0);
|
|
|
|
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;
|
|
|
|
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);
|
|
}
|
|
|