//////////////////////////////
//Main Libary
/////////////////////////////
#define GLEW_STATIC
#include <windows.h>
#include "SDL/SDL_image.h"
#include <stdio.h>
#include <stdlib.h>
#include <glew.h>
#include <iostream>
#include <cassert>
#include <string>
#include <algorithm>
#include <vector>
#include <fstream>
#include <glext.h>
#include <gl/gl.h>
#include <gl/glu.h>
#include <Commdlg.h>
#include <iterator>
#include<IL/il.h>
#include "resource.h"
using namespace std;
//Screen Sizes
#define SCREEN_WIDTH 1280
#define SCREEN_HEIGHT 1024
//Buffers
GLuint matrixuniform;
GLuint Translationuniform;
GLuint vertexbuffer;
GLuint vao;
GLuint textureID[0];
struct Point
{
float x, y, z;
};
vector<unsigned int>faces;
unsigned int face[3];
size_t filesize;
vector<Point>points;
//float* point=reinterpret_cast<float*>(&points[0]);
//int num_bytes = points.size() * sizeof(points[0]);
static const GLfloat myMatrix[] =
{
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
};
//Device Context
HDC hDC;
//OpenGL
HGLRC hRC;
//Window Class
WNDCLASSEX wc;
//Window Handle
HWND hwnd;
//Messages
MSG Msg;
//LOAD SHADER FUNCTION
GLuint LoadProgram(const char * const vertex_file_path, const char * Fragment_file_path)
{
GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
//READ THE VERTEX SHADER CODE
string VertexShaderCode;
ifstream VertexShaderStream(vertex_file_path, std::ios::in);
if(VertexShaderStream.is_open())
{
string Line = "";
while(getline(VertexShaderStream, Line))
VertexShaderCode += "\n" + Line;
VertexShaderStream.close();
}
//READ THE FRAGMENT SHADER CODE
string FragmentShaderCode;
ifstream FragmentShaderStream(Fragment_file_path, std::ios::in);
if(FragmentShaderStream.is_open())
{
string Line = "";
while(getline(FragmentShaderStream, Line))
FragmentShaderCode += "\n" + Line;
FragmentShaderStream.close();
}
GLint Result = GL_FALSE;
int InfoLogLength;
//Compile Vertex Shader
printf("Compiling Shader : %s\n", vertex_file_path);
char const * VertexSourcePointer = VertexShaderCode.c_str();
glShaderSource(VertexShaderID, 1, &VertexSourcePointer, NULL);
glCompileShader(VertexShaderID);
//Check Vertex Shader
glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
vector<char> VertexShaderErrorMessage(InfoLogLength);
glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
fprintf(stdout, "%s\n", &VertexShaderErrorMessage[0]);
//Compile Fragment Shader
printf("Compiling Shader : %s\n", Fragment_file_path);
char const * FragmentSourcePointer = FragmentShaderCode.c_str();
glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer, NULL);
glCompileShader(FragmentShaderID);
//Check Fragment Shader
glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
vector<char> FragmentShaderErrorMessage(InfoLogLength);
glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
fprintf(stdout, "%s\n", &FragmentShaderErrorMessage[0]);
fprintf(stdout, "Linking Program\n");
GLuint ProgramID = glCreateProgram();
//Bind Attribute
glBindAttribLocation(ProgramID, 0, "position");
// glBindAttribLocation(ProgramID, 1, "Texcoord0");
//Link The Program
glAttachShader(ProgramID, VertexShaderID);
glAttachShader(ProgramID, FragmentShaderID);
glLinkProgram(ProgramID);
GLuint texture1;
// texture1 = glGetUniformLocation(ProgramID, "myTextureSampler");
matrixuniform = glGetUniformLocation(ProgramID, "myMatrix");
// Translationuniform = glGetUniformLocation(ProgramID, "TranslationMatrix");
//Check The Program
glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
vector<char> ProgramErrorMessage( max(InfoLogLength, int(1)) );
fprintf(stdout, "%s\n", &ProgramErrorMessage[0]);
//Delete Shader
glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);
glUseProgram(ProgramID);
//Return ProgramID
return ProgramID;
}
static const GLfloat test[] = {
-1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
};
static const GLfloat texture[] = {
-1.0f, 0.0f,
0.0f, 1.0f,
-1.0f, 1.0f
};
// number of available formats
int indexPixelFormat = 0;
GLuint PixelFormat;
int DescribePixelFormat
(
HDC hdc, // device context of interest
int iPixelFormat, // pixel format selector
UINT nBytes, // size of buffer pointed to by ppfd
LPPIXELFORMATDESCRIPTOR ppfd
// pointer to structure to receive pixel
// format data
);
const char g_szClassName[] = "myWindowClass";
HINSTANCE hInst;
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
//Step 1: Registering the Window Class
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_OWNDC | CS_VREDRAW | CS_HREDRAW;;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInst;
wc.hIcon = static_cast<HICON>(LoadImage(hInstance,MAKEINTRESOURCE(IDI_MYICON),IMAGE_ICON,32, 32, LR_DEFAULTSIZE));
wc.hIconSm = (HICON)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_MYICON), IMAGE_ICON, 16, 16, 0);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = MAKEINTRESOURCE(IDR_MYMENU);
wc.lpszClassName = g_szClassName;
wc.hIconSm = static_cast<HICON>(LoadImage(hInstance,MAKEINTRESOURCE(IDI_MYICON),IMAGE_ICON,16,16,LR_DEFAULTSIZE));
if(!RegisterClassEx(&wc))
{
MessageBox(NULL, "Window Registration Failed!", "Error!",
MB_ICONEXCLAMATION | MB_OK);
return 0;
}
// Step 2: Creating the Window
hwnd = CreateWindowEx(
3,
g_szClassName,
"program",
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT, SCREEN_WIDTH, SCREEN_HEIGHT,
NULL, NULL, hInstance, NULL);
if(hwnd == NULL)
{
MessageBox(NULL, "Window Creation Failed!", "Error!",
MB_ICONEXCLAMATION | MB_OK);
return 0;
}
hDC = GetDC(hwnd); //get current windows device context
static PIXELFORMATDESCRIPTOR pfd=
{
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number (?)
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
16, // Select A 16Bit Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored (?)
0, // No Alpha Buffer
0, // Shift Bit Ignored (?)
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored (?)
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer (?)
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved (?)
0, 0, 0 // Layer Masks Ignored (?)
};
//Choose a Pixel Format
int ChoosenPixelFormat = ChoosePixelFormat(hDC, &pfd);
//Set Pixel Format Close to Screen Format
SetPixelFormat(hDC, ChoosenPixelFormat, &pfd);
//Make OpenGL Context
hRC = wglCreateContext(hDC);
//Make Opengl Context Current
wglMakeCurrent(hDC, hRC);
glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
glGetError();
glewInit();
LoadProgram("graphicaluserinterface.v", "graphicaluserinterface.f");
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glUniformMatrix4fv(matrixuniform, 1, TRUE, myMatrix);
glBufferData(GL_ARRAY_BUFFER, points.size(), &points[0], GL_STATIC_DRAW);
glEnable(GL_DEPTH_TEST);
glGetError();
ShowWindow(hwnd, nCmdShow);
UpdateWindow(hwnd);
// Step 3: The Message Loop
while(GetMessage(&Msg, NULL, 0, 0) > 0)
{
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
return Msg.wParam;
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg,WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
switch(msg)
{
case WM_CREATE: //window being created
ValidateRect(hwnd, NULL);
return 0;
break;
case WM_ERASEBKGND:
return true;
break;
case WM_CLOSE: //window is closing
/* Deselect rendering context and delete it*/
wglMakeCurrent(hDC, NULL);
wglDeleteContext(hRC);
/* Send quit message to queue*/
PostQuitMessage(0);
return 0;
break;
case WM_COMMAND:
switch(LOWORD(wParam))
case ID_BOX:
{
OPENFILENAME ofn;
char szFileName[MAX_PATH] = "";
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn); // SEE NOTE BELOW
ofn.hwndOwner = hwnd;
ofn.lpstrFilter = ".OBJ (*.obj)\0*.obj\0All Files (*.*)\0*.*\0";
ofn.lpstrFile = szFileName;
ofn.nMaxFile = MAX_PATH;
ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
ofn.lpstrDefExt = "obj";
if(GetOpenFileName(&ofn))
{
// Do something usefull with the filename stored in szFileName <--
// cout << "File Path = "<< szFileName << endl;
//make a fileobject and store list and the index of that list in a c string
ifstream file (szFileName);
//While FileObject not equal end of file
while (!file.eof() )
{
char modelbuffer[20000];
file.getline(modelbuffer, 20000);
switch(modelbuffer[0])
{
cout << " " << endl;
case 'v' :
Point p;
sscanf(modelbuffer, "v %f %f %f", &p.x, &p.y, &p.z);
points.push_back(p);
cout << " p.x = " << p.x << " p.y = " << p.y << " p.z = " << p.x << endl;
break;
cout << " " << endl;
case 'f':
int read_count = sscanf(modelbuffer, "f %d %d %d %d", &face[0], &face[1], &face[2], &face[3]);
cout << "face[0] = " << face[0] << " face[1] = " << face[1] << " face[2] = " << face[2] << " face[3] = " << face[3] << "\n";
if(read_count !=4)
{
cout << "bad/n";
throw std::exception();
}
faces.push_back(face[0] - 1);
faces.push_back(face[1] - 1);
faces.push_back(face[2] - 1);
faces.push_back(face[3] - 1);
cout << face[0] - 1 << face[1] - 1 << face[2] - 1 << face[3] - 1 << endl;
}
}
}
}
break;
case WM_PAINT:
//Draw
hDC = BeginPaint(hwnd, &ps);
// glEnableClientState(GL_VERTEX_ARRAY);
glClearColor(1, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 2 *sizeof(points),points.data());
glDrawElements( GL_QUADS, faces.size(), GL_UNSIGNED_INT, faces.data());
SwapBuffers(hDC);
glGetError();
EndPaint(hwnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
case ID_FILE_EXIT:
PostQuitMessage(0);
return 0;
break;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return 0;
}