void printVers() {
std::cout << "GLFW " << glfwGetVersionString() << std::endl;
std::cout << "GLEW " << glewGetString(GLEW_VERSION) << std::endl;
std::cout << "GL " << glGetString(GL_VERSION) << std::endl;
std::cout << "Shader version " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << std::endl;
}
int main(int ac, char **av)
{
GLFWwindow *window;
GLuint texture;
if (!glfwInit())
return (1);
ft_printf("Init ok\nGlfw version: %s\n", glfwGetVersionString());
glfwSetErrorCallback(&error_handler);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
//glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
if (!(window = glfwCreateWindow(800, 600, "Scope", NULL, NULL)))
{
glfwTerminate();
return (2);
}
glfwMakeContextCurrent(window);
glEnable(GL_DEPTH_TEST);
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
texture = texture_load((ac > 2) ? av[2] : "herbe.jpg");
ft_printf("Renderer: %s\nOpenGL version supported %s\n",
glGetString(GL_RENDERER), glGetString(GL_VERSION));
return (main_loop(window, texture, av[1]));
}
static GLboolean valid_version(void)
{
int major, minor, revision;
glfwGetVersion(&major, &minor, &revision);
printf("GLFW header version: %u.%u.%u\n",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
printf("GLFW library version: %u.%u.%u\n", major, minor, revision);
if (major != GLFW_VERSION_MAJOR)
{
printf("*** ERROR: GLFW major version mismatch! ***\n");
return GL_FALSE;
}
if (minor != GLFW_VERSION_MINOR || revision != GLFW_VERSION_REVISION)
printf("*** WARNING: GLFW version mismatch! ***\n");
printf("GLFW library version string: \"%s\"\n", glfwGetVersionString());
return GL_TRUE;
}
void Screen::setupGraphicFunctions()
{
if (initializedGLEW)
return;
LOG << "start init of GLEW" << "\n";
glewExperimental = true; // Needed for core profile
LOG << "using experimental version of GLEW" << "\n";
if (glewInit() != GLEW_OK) {
LOG << "Failed to initialize GLEW" << "\n";
}
LOG << "done with GLEW" << "\n";
glGetError(); //catches the Invalid Enum Error that GLEW Throws, not a error but a bug
LOG << string("Running Versions: \n") +
" Graphics Data:\n\n" +
" Graphic Renderer: " + (char*)glGetString(GL_RENDERER) + "\n" +
" Graphics Vendor: " + (char*)glGetString(GL_VENDOR) + "\n" +
" OpenGL: " + (char*)glGetString(GL_VERSION) + "\n" +
" GLSL: " + (char*)glGetString(GL_SHADING_LANGUAGE_VERSION) + "\n" +
" GLFW: " + (char*)glfwGetVersionString() + "\n" +
" GLEW: " + (char*)glewGetString(GLEW_VERSION) + "\n";
initializedGLEW = true;
}
GLFWRenderer::GLFWRenderer(int w, int h) : width { w }, height { h }
{
glfwInit();
glfwWindowHint(GLFW_SAMPLES, 16);
window = glfwCreateWindow(w, h, glfwGetVersionString(), nullptr, nullptr);
glfwMakeContextCurrent(window);
glewInit();
}
/*--------------------------------GLFW3 and GLEW------------------------------*/
bool start_gl () {
gl_log ("starting GLFW %s\n", glfwGetVersionString ());
glfwSetErrorCallback (glfw_error_callback);
if (!glfwInit ()) {
fprintf (stderr, "ERROR: could not start GLFW3\n");
return false;
}
// uncomment these lines if on Apple OS X
glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// glfwWindowHint (GLFW_SAMPLES, 32);
/*GLFWmonitor* mon = glfwGetPrimaryMonitor ();
const GLFWvidmode* vmode = glfwGetVideoMode (mon);
g_window = glfwCreateWindow (
vmode->width, vmode->height, "Extended GL Init", mon, NULL
);*/
g_window = glfwCreateWindow (
g_gl_width, g_gl_height, "Extended Init.", NULL, NULL
);
if (!g_window) {
fprintf (stderr, "ERROR: could not open window with GLFW3\n");
glfwTerminate();
return false;
}
glfwSetWindowSizeCallback (g_window, glfw_window_size_callback);
glfwMakeContextCurrent (g_window);
// start GLEW extension handler
glewExperimental = GL_TRUE;
glewInit ();
if (GLEW_KHR_debug) {
int param = -1;
printf ("KHR_debug extension found\n");
glDebugMessageCallback ((GLDEBUGPROC)debug_gl_callback, ¶m);
glEnable (GL_DEBUG_OUTPUT_SYNCHRONOUS);
printf ("debug callback engaged\n");
} else {
printf ("KHR_debug extension NOT found\n");
}
// get version info
const GLubyte* renderer = glGetString (GL_RENDERER); // get renderer string
const GLubyte* version = glGetString (GL_VERSION); // version as a string
printf ("Renderer: %s\n", renderer);
printf ("OpenGL version supported %s\n", version);
gl_log ("renderer: %s\nversion: %s\n", renderer, version);
//vysnch
// glfwSwapInterval (1);
return true;
}
JNIEXPORT jstring JNICALL Java_com_badlogic_jglfw_Glfw_glfwGetVersionString(JNIEnv* env, jclass clazz) {
//@line:571
return env->NewStringUTF(glfwGetVersionString());
}
bool GLFW_Window::Initialize( const char* name, bool full_screen, int width, int height, int opengl_version_major, int opengl_version_minor, int anti_aliasing )
{
GLFW_Window::instance = this;
GLFWmonitor* mon = NULL;
if(full_screen)
{
mon = glfwGetPrimaryMonitor ();
const GLFWvidmode* vmode = glfwGetVideoMode (mon);
this->width = vmode->width;
this->height = vmode->height;
}
else
{
if(!(width && height))
{
LogMessage ("ERROR: window width or height are 0 when full_screen is false");
return 1;
}
this->width = width;
this->height = height;
}
assert(GLFW_Window::RestartLog());
LogMessage ("starting GLFW\n%s\n", glfwGetVersionString ());
glfwSetErrorCallback (GLFW_Window::GLFWErrorCallback);
if (!glfwInit ()) {
LogMessage ("ERROR: could not start GLFW3");
return 1;
}
glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, opengl_version_major);
glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, opengl_version_minor);
glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint (GLFW_SAMPLES, anti_aliasing);
this->handle = glfwCreateWindow (this->width, this->height, name, mon, NULL);
glfwMakeContextCurrent (this->handle);
glfwSetWindowSizeCallback (this->handle, GLFW_Window::GLFWWindowSizeCallback);
return 0;
}
static void print_version(void)
{
int major, minor, revision;
glfwGetVersion(&major, &minor, &revision);
printf("GLFW header version: %u.%u.%u\n",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
printf("GLFW library version: %u.%u.%u\n", major, minor, revision);
printf("GLFW library version string: \"%s\"\n", glfwGetVersionString());
}
Scene::Scene()
{
log = Game::log;
// Create OpenGL context
if (!glfwInit())
{
log->write("Failed to init GLFW\n");
exit(EXIT_FAILURE);
}
log->write("GLFW version: %s\n", glfwGetVersionString());
glfwWindowHint(GLFW_SAMPLES, Game::settings->get("video.aa_samples")->n);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); /* OS X */
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
window = glfwCreateWindow(Game::settings->get("video.width")->n, \
Game::settings->get("video.height")->n, \
"Razngin", NULL, NULL);
if (window == NULL)
{
log->write("Failed to open GLFW window\n");
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glewExperimental = true;
if (glewInit() != GLEW_OK)
{
log->write("Failed to init GLEW\n");
exit(EXIT_FAILURE);
}
glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glGenVertexArrays(1, &vao_id);
glBindVertexArray(vao_id);
}
/*--------------------------------GLFW3 and GLEW-----------------------------*/
bool start_gl() {
const GLubyte *renderer;
const GLubyte *version;
gl_log( "starting GLFW %s", glfwGetVersionString() );
glfwSetErrorCallback( glfw_error_callback );
if ( !glfwInit() ) {
fprintf( stderr, "ERROR: could not start GLFW3\n" );
return false;
}
/* We must specify 3.2 core if on Apple OS X -- other O/S can specify
anything here. I defined 'APPLE' in the makefile for OS X */
#ifdef APPLE
glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 3 );
glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 2 );
glfwWindowHint( GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE );
glfwWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE );
#endif
/*GLFWmonitor* mon = glfwGetPrimaryMonitor ();
const GLFWvidmode* vmode = glfwGetVideoMode (mon);
g_window = glfwCreateWindow (
vmode->width, vmode->height, "Extended GL Init", mon, NULL
);*/
g_window = glfwCreateWindow( g_gl_width, g_gl_height, "Shaders", NULL, NULL );
if ( !g_window ) {
fprintf( stderr, "ERROR: could not open window with GLFW3\n" );
glfwTerminate();
return false;
}
glfwSetFramebufferSizeCallback( g_window, glfw_framebuffer_size_callback );
glfwMakeContextCurrent( g_window );
glfwWindowHint( GLFW_SAMPLES, 4 );
/* start GLEW extension handler */
glewExperimental = GL_TRUE;
glewInit();
/* get version info */
renderer = glGetString( GL_RENDERER ); /* get renderer string */
version = glGetString( GL_VERSION ); /* version as a string */
printf( "Renderer: %s\n", renderer );
printf( "OpenGL version supported %s\n", version );
gl_log( "renderer: %s\nversion: %s\n", renderer, version );
previous_seconds = glfwGetTime();
return true;
}
bool VideoManager::InitalizeEngine()
{
LogMessage("\n--------------------- Program Startup ----------------------\n");
glfwSetErrorCallback(glfw_error_cb);
if (!glfwInit())
{
LogError("GLFW INIT", "Could not start GLFW3");
return false;
}
LogMessage("Starting GLFW: %s\n", glfwGetVersionString());
return true;
}
/*--------------------------------GLFW3 and GLEW------------------------------*/
bool start_gl () {
gl_log ("starting GLFW %s\n", glfwGetVersionString ());
glfwSetErrorCallback (glfw_error_callback);
if (!glfwInit ()) {
fprintf (stderr, "ERROR: could not start GLFW3\n");
return false;
}
// uncomment these lines if on Apple OS X
/*glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
*/
/*GLFWmonitor* mon = glfwGetPrimaryMonitor ();
const GLFWvidmode* vmode = glfwGetVideoMode (mon);
g_window = glfwCreateWindow (
vmode->width, vmode->height, "Extended GL Init", mon, NULL
);*/
g_window = glfwCreateWindow (
g_gl_width, g_gl_height, "Extended Init.", NULL, NULL
);
if (!g_window) {
fprintf (stderr, "ERROR: could not open window with GLFW3\n");
glfwTerminate();
return false;
}
glfwSetWindowSizeCallback (g_window, glfw_window_size_callback);
glfwMakeContextCurrent (g_window);
glfwWindowHint (GLFW_SAMPLES, 4);
// start GLEW extension handler
glewExperimental = GL_TRUE;
glewInit ();
// get version info
const GLubyte* renderer = glGetString (GL_RENDERER); // get renderer string
const GLubyte* version = glGetString (GL_VERSION); // version as a string
printf ("Renderer: %s\n", renderer);
printf ("OpenGL version supported %s\n", version);
gl_log ("renderer: %s\nversion: %s\n", renderer, version);
return true;
}
/*--------------------------------GLFW3 and GLEW------------------------------*/
bool start_gl () {
gl_log ("starting GLFW %s\n", glfwGetVersionString ());
glfwSetErrorCallback (glfw_error_callback);
if (!glfwInit ()) {
fprintf (stderr, "ERROR: could not start GLFW3\n");
return false;
}
/* We must specify 3.2 core if on Apple OS X -- other O/S can specify
anything here. I defined 'APPLE' in the makefile for OS X */
glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 1);
/*GLFWmonitor* mon = glfwGetPrimaryMonitor ();
const GLFWvidmode* vmode = glfwGetVideoMode (mon);
g_window = glfwCreateWindow (
vmode->width, vmode->height, "Extended GL Init", mon, NULL
);*/
g_window = glfwCreateWindow (g_gl_width, g_gl_height, "Extended Init.",
NULL, NULL);
if (!g_window) {
fprintf (stderr, "ERROR: could not open window with GLFW3\n");
glfwTerminate();
return false;
}
glfwSetWindowSizeCallback (g_window, glfw_window_size_callback);
glfwMakeContextCurrent (g_window);
glfwWindowHint (GLFW_SAMPLES, 16);
// start GLEW extension handler
glewExperimental = GL_TRUE;
glewInit ();
// get version info
const GLubyte* renderer = glGetString (GL_RENDERER); // get renderer string
const GLubyte* version = glGetString (GL_VERSION); // version as a string
printf ("renderer: %s\n", renderer);
printf ("OpenGL version supported %s\n", version);
gl_log ("renderer: %s\nversion: %s\n", renderer, version);
return true;
}
Window::Window(Simulation *sim)
: sim(sim)
{
std::cout << "GLFW version: " << glfwGetVersionString() << std::endl;
glfwSetErrorCallback(window_error_callback);
// Initialize GLFW
if (!glfwInit())
{
std::cerr << "GLFW error!" << std::endl;
error = true;
return;
}
// Create GLFW window
window = glfwCreateWindow(640, 480, "CellSim", NULL, NULL);
if (!window)
{
std::cerr << "Could not create GLFW window!" << std::endl;
error = true;
return;
}
glfwMakeContextCurrent(window);
// Initialize GLEW
GLenum glew_init = glewInit();
if (glew_init != GLEW_OK)
{
std::cerr << glewGetErrorString(glew_init) << std::endl;
error = true;
return;
}
std::cout << "GLEW version: " << glewGetString(GLEW_VERSION) << std::endl;
// Set GLFW options
glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
glfwSetInputMode(window, GLFW_STICKY_MOUSE_BUTTONS, GL_TRUE);
glClearColor(0.0, 0.0, 0.2, 0.0);
//glfwSetCursorPosCallback(window, cursor_callback);
}
int main()
{
GLFWwindow *window;
char *userptr = "userptr";
glfwSetErrorCallback(errorcb);
assert(glfwInit() == GL_TRUE);
assert(!strcmp(glfwGetVersionString(), "3.2.1 JS WebGL Emscripten"));
assert(glfwGetCurrentContext() == NULL);
{
int major, minor, rev;
glfwGetVersion(&major, &minor, &rev);
assert(major == 3);
assert(minor == 2);
assert(rev == 1);
}
{
int count, x, y, w, h;
GLFWmonitor **monitors = glfwGetMonitors(&count);
assert(count == 1);
for (int i = 0; i < count; ++i) {
assert(monitors[i] != NULL);
}
assert(glfwGetPrimaryMonitor() != NULL);
glfwGetMonitorPos(monitors[0], &x, &y);
glfwGetMonitorPhysicalSize(monitors[0], &w, &h);
assert(glfwGetMonitorName(monitors[0]) != NULL);
glfwSetMonitorCallback(monitcb);
// XXX: not implemented
// assert(glfwGetVideoModes(monitors[0], &count) != NULL);
// assert(glfwGetVideoMode(monitors[0]) != NULL);
// glfwSetGamma(monitors[0], 1.0f);
// assert(glfwGetGammaRamp(monitors[0]) != NULL);
// glfwSetGammaRamp(monitors[0], ramp);
}
{
int x, y, w, h;
glfwDefaultWindowHints();
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
window = glfwCreateWindow(640, 480, "glfw3.c", NULL, NULL);
assert(window != NULL);
glfwSetWindowPosCallback(window, wposicb);
glfwSetWindowSizeCallback(window, wsizecb);
glfwSetWindowCloseCallback(window, wcloscb);
glfwSetWindowRefreshCallback(window, wrfrscb);
glfwSetWindowFocusCallback(window, wfocucb);
glfwSetWindowIconifyCallback(window, wiconcb);
glfwSetFramebufferSizeCallback(window, wfsizcb);
assert(glfwWindowShouldClose(window) == 0);
glfwSetWindowShouldClose(window, 1);
assert(glfwWindowShouldClose(window) == 1);
glfwSetWindowTitle(window, "test");
glfwSetWindowTitle(window, "glfw3.c");
// XXX: not implemented
// glfwSetWindowPos(window, 1, 1);
glfwGetWindowPos(window, &x, &y); // stub
glfwGetWindowSize(window, &w, &h);
assert(w == 640 && h == 480);
glfwSetWindowSize(window, 1, 1);
glfwGetWindowSize(window, &w, &h);
assert(w == 1 && h == 1);
glfwSetWindowSize(window, 640, 480);
glfwGetFramebufferSize(window, &w, &h);
// XXX: not implemented
// glfwIconifyWindow(window);
// glfwRestoreWindow(window);
// glfwShowWindow(window);
// glfwHideWindow(window);
assert(glfwGetWindowMonitor(window) == NULL);
glfwDestroyWindow(window);
window = glfwCreateWindow(640, 480, "glfw3.c", glfwGetPrimaryMonitor(), NULL);
assert(window != NULL);
assert(glfwGetWindowMonitor(window) == glfwGetPrimaryMonitor());
glfwDestroyWindow(window);
window = glfwCreateWindow(640, 480, "glfw3.c", NULL, NULL);
assert(window != NULL);
assert(glfwGetWindowAttrib(window, GLFW_CLIENT_API) == GLFW_OPENGL_ES_API);
assert(glfwGetWindowUserPointer(window) == NULL);
glfwSetWindowUserPointer(window, userptr);
assert(glfwGetWindowUserPointer(window) == userptr);
}
{
double x, y;
glfwSetKeyCallback(window, wkeypcb);
glfwSetCharCallback(window, wcharcb);
glfwSetMouseButtonCallback(window, wmbutcb);
glfwSetCursorPosCallback(window, wcurpcb);
glfwSetCursorEnterCallback(window, wcurecb);
glfwSetScrollCallback(window, wscrocb);
// XXX: stub, events come immediatly
// glfwPollEvents();
// glfwWaitEvents();
assert(glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_NORMAL);
// XXX: not implemented
// glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
glfwGetKey(window, GLFW_KEY_A);
glfwGetMouseButton(window, 0);
glfwGetCursorPos(window, &x, &y);
// XXX: not implemented
// glfwSetCursorPos(window, 0, 0);
}
{
// XXX: not implemented
// glfwJoystickPresent(joy);
// glfwGetJoystickAxes(joy, &count);
// glfwGetJoystickButtons(joy, &count);
// glfwGetJoystickName(joy);
}
{
// XXX: not implemented
// glfwSetClipboardString(window, "string");
// glfwGetClipboardString(window);
}
{
glfwGetTime();
glfwSetTime(0);
}
{
glfwMakeContextCurrent(window); // stub
assert(glfwGetCurrentContext() == window);
glfwSwapBuffers(window); // stub
glfwSwapInterval(0); // stub
}
{
assert(glfwExtensionSupported("nonexistant") == 0);
assert(glfwGetProcAddress("nonexistant") == NULL);
}
glfwTerminate();
#ifdef REPORT_RESULT
REPORT_RESULT(1);
#endif
return 0;
}
int main(int argc, const char *arg[]) {
std::string modelname = "../../media/models/primitive/cube.obj";
if (argc > 1) {
std::string model(arg[1]);
if (model == "corsair") {
modelname = "../../media/models/aircraft/f4u-corsair/f4u-no-propeller.obj";
}
else if (model == "p47") {
modelname = "../../media/models/aircraft/p47-thunderbolt/p47.obj";
}
else if (model == "ki-84" || model == "kate") {
modelname = "../../media/models/aircraft/ki-84/ki84-no-propeller.obj";
}
else if (model == "p40" || model == "warhawk") {
modelname = "../../media/models/aircraft/p40-warkhawk/P40.obj";
}
else if (model == "p38" || model == "lightning") {
modelname = "../../media/models/aircraft/p38-lightning/P38.obj";
}
else if (model == "uboat" || model == "U99") {
modelname = "../../media/models/marine/uboat-u99/U99.obj";
}
else if (model == "cube") {
modelname = "../../media/models/primitive/cube.obj";
}
else if (model == "trex" || model == "t-rex") {
modelname = "../../media/models/objects/absurd/t-rex/t-rex.obj";
}
else if (model == "path" && argc > 2) {
modelname = arg[2];
}
}
Log::initialize("RenderRigidModel.log", Log::All);
LogReport() << "GLFW version: " << glfwGetVersionString();
LogReport() << "Rendering model '" << modelname << "'.";
std::cout << "Rendering model '" << modelname << "'." << std::endl;
GLFWwindow* window;
glfwSetErrorCallback(error_callback);
if (!glfwInit()) {
exit(EXIT_FAILURE);
}
window = glfwCreateWindow(800, 800, "Render Rigid Body", NULL, NULL);
if (!window) {
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwSetKeyCallback(window, key_callback);
int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
try {
if (!application.initialize(modelname)) {
return 0;
}
}
catch (std::runtime_error &e) {
LogError() << e.what();
std::cerr << e.what() << std::endl;
return -1;
}
try {
while (!glfwWindowShouldClose(window)) {
application.update();
application.render();
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
catch (std::runtime_error &e) {
LogError() << e.what();
std::cerr << e.what() << std::endl;
}
return 0;
}
int main(int argc, char *argv[])
{
//start context
if (!glfwInit())
{
fprintf(stderr, "Error, could not start GLFW3\n");
return 1;
}
else
{
fprintf(stderr, "GLFW initialized properly.");
}
//Forward compatibility from version 3.2.
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_SAMPLES, 4); //Anti aliasing (4 passes)
//start logs
Logger::restartLog(GL_LOG_FILE);
glfwSetErrorCallback(glfwErrorCallback);
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
//init window with primary monitor resolution
//Set these modes for a fullscreen window and don't for classic fullscreen:
/*glfwWindowHint(GLFW_RED_BITS, mode->redBits);
glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits);
glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits);
glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate);*/
//------------------------------------------------
//GLFWwindow * window = glfwCreateWindow(mode->width, mode->height, "Tutorial 1: Draw a triangle", monitor, NULL); //Fullscreen
GLFWwindow * window = glfwCreateWindow(800, 600, "Tutorial 1: Draw a triangle", NULL, NULL); //Not Fullscreen
//if window initialisation failed
if (!window)
{
fprintf(stderr, "Could not open window with GLFW3\n");
glfwTerminate();
return 1;
}
glfwMakeContextCurrent(window);
glfwSetWindowSizeCallback(window, glfwWindowSizeCallback);
//start glew extension handler;
glewExperimental = GL_TRUE;
glewInit();
//get version info
const GLubyte * renderer = glGetString(GL_RENDERER);
const GLubyte * version = glGetString(GL_VERSION);
//Log informations
Logger::printToLog(GL_LOG_FILE, "Starting GLFW: %s \n", glfwGetVersionString());
logGlParams();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
//draw triangle
initTriangles();
Shader vertex = Shader("vertex.vert", GL_VERTEX_SHADER);
Shader frag_1 = Shader("frag1.frag", GL_FRAGMENT_SHADER);
Shader frag_2 = Shader("frag2.frag", GL_FRAGMENT_SHADER);
Shader shaders_1[2] = { vertex, frag_1 };
Shader shaders_2[2] = { vertex, frag_2 };
ShaderProgram shader_programme_1 = ShaderProgram(shaders_1, VERT_FRAG);
ShaderProgram shader_programme_2 = ShaderProgram(shaders_2, VERT_FRAG);
while (!glfwWindowShouldClose(window)) {
updateFpsCounter(window);
// wipe the drawing surface clear
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, g_gl_width, g_gl_height);
glClearColor(0.1f, 0.1f, 0.1f, 0.0f);
glUseProgram(shader_programme_1.get_program());
glBindVertexArray(vao_1);
// draw points 0-5 from the currently bound VAO with current in-use shader
glDrawArrays(GL_TRIANGLES, 0, 6);
glUseProgram(shader_programme_2.get_program());
glBindVertexArray(vao_2);
// draw points 0-5 from the currently bound VAO with current in-use shader
glDrawArrays(GL_TRIANGLES, 0, 3);
// update other events like input handling
glfwPollEvents();
// put the stuff we've been drawing onto the display
glfwSwapBuffers(window);
if (GLFW_PRESS == glfwGetKey(window, GLFW_KEY_ESCAPE))
{
glfwSetWindowShouldClose(window, 1);
}
}
//close gl context and other glfw resources
glfwTerminate();
return 0;
}
//********************//
//Engine Display Class//
//********************//
void Engine_Init::RunDisplay()
{
//GLFW Initiate
errchk(glfwInit());
cout << glfwGetVersionString() << endl;
//GLFW Set Window Properties
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_SAMPLES, props.MSAA);
props.init(); //Initialize the engine properties from the properties input file "Settings."
camera.init(props); //Initialize the camera class.
//Initialize Window
switch(props.FullScreen)
{
case 0:
{window = glfwCreateWindow(props.WinWidth, props.WinHeight, "GameEngine Test", nullptr, nullptr);break;}
case 1:
{window = glfwCreateWindow(props.WinWidth, props.WinHeight, "GameEngine Test", glfwGetPrimaryMonitor(), nullptr);break;}
}
if( window == NULL ){
fprintf( stderr, "Failed to open GLFW window.\n" );
glfwTerminate();
}
glfwMakeContextCurrent(window);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
//Set the call back functions
setEventHandling();
glfwSetKeyCallback(window, StateBase::keycallback_dispatch);
glfwSetCursorPosCallback(window, StateBase::mousecallback_dispatch);
glfwSetScrollCallback(window, StateBase::scrollcallback_dispatch);
//Initialize Glew
glewExperimental = GL_TRUE;
glewInit();
//Set view port dimensions
glViewport(0, 0, props.WinWidth, props.WinHeight);
//Setup OpenGL Options
glEnable(GL_DEPTH_TEST);
glEnable(GL_MULTISAMPLE);
glEnable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//Poly Fill Mode
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
//System Processors
int NProc = sysconf( _SC_NPROCESSORS_ONLN );
cout << "Number of System Processors: " << NProc << endl;
//Max Number of Attributes
GLint nrAttributes;
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &nrAttributes);
cout << "Maximum nr of vertex attributes supported: " << nrAttributes << std::endl;
GLErrorCatch("GL Preamble");
//Set the frames per second timer
fpsTimer ft;
//This sets the View and Projection "Matrices" Uniform Buffer Object at global location 0;
//TM.SetViewUniformBufferObject();
//Setup screen text writing
SW.Setup("bin/fonts/FreeSans.ttf",props.WinWidth,props.WinHeight);//Setup screen font
GLErrorCatch("Screen Writer Setup");
//Initialize Shaders
SCC.ShaderLoader();
GLErrorCatch("Shader Handling");
//Initialize SolarSystem
double TIMECHECK = glfwGetTime();
solarsystem.SetupClass(OPC);
cout << "SolarSys CLASS SETUP TIME: " << glfwGetTime() - TIMECHECK << "\n";
cout << "SolarSystem class Setup...\n";
solarsystem.GenerateSolarSystem(OPC,0,0);
cout << "SolarSystem Generated...\n";
GLErrorCatch("SolarSystem Generation");
//Setup Global Uniform Handler
GGUBO.SetGlobalUBO(SCC);
camera.SetProjViewUBO(SCC);
GLErrorCatch("Uniform Handling");
//Setup Timing Stats
TimingStats TS(SW,props);
TS.SetObject("Preamble");
TS.SetObject("camera.PrepareCameraData");
TS.SetObject("GGUBO.UpdateGlobalUBO");
TS.SetObject("solarsystem.PrepareData");
TS.SetObject("ProcessDrawArray");
TS.SetObject("PrintScreenTimers");
TS.SetObject("Screen_Console");
TS.SetObject("glfwSwapBuffers");
TS.SetObject("drawArray.ClearDrawArrays");
TS.SetObject("EventPolling");
TS.SetObject("Skybox Drawing");
while(!glfwWindowShouldClose(window))
{
//*********************
//Frame Timer
//*********************
TS.TS(0);
dt.SetTime();
//*************************
//Sets the background color
//*************************
glClearColor(Env.bgColor.x, Env.bgColor.y, Env.bgColor.z, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
TS.TE(0);
//***************
//Setup Scene
//***************
//Prepare the camera class for the frame
//cout << "***TEST1***" << endl;
TS.TS(1);
camera.PrepareCameraData();
TS.TE(1);
//Update the global uniform buffer objects
TS.TS(2);
GGUBO.UpdateGlobalUBO(camera);
TS.TE(2);
//Prepare the solarsystem data
//cout << "***TEST2***" << endl;
TS.TS(3);
solarsystem.PrepareData(OPC,drawArray,drawInstArray,camera,dt,false);
TS.TE(3);
//***************
//Scene Rendering
//***************
//cout << "***TEST3***" << endl;
//Draw all objects
TS.TS(10);
skybox.DrawSkybox(camera,props);
TS.TE(10);
TS.TS(4);
ProcessDrawArray();
TS.TE(4);
//*******************
//Interface Rendering
//*******************
//Render Frame Timer
TS.TS(5);
PrintScreenTimers(SW,ft);
TS.TE(5);
//cout << "***TEST4***" << endl;
//Console Functions
TS.TS(6);
Screen_Console(SW);
TS.TE(6);
//Statistics Rendering
TS.CalcAndRenderStats();
//*************
//Swap Buffers
//*************
TS.TS(7);
//glfwSwapInterval(1); //Seems to slow the program to 30fps
glfwSwapBuffers(window);//Something is wrong here, SUPER expensive
TS.TE(7);
//*********************
//Check and call events
//*********************
TS.TS(9);
glfwPollEvents();
//glfwWaitEvents();
Do_Movement();
TS.TE(9);
//*************
//Frame Cleanup
//*************
TS.TS(8);
drawArray.DrawArrayReset();
drawInstArray.ClearInstDrawArrays();
TS.TE(8);
//cout << "FRAME END\n";
//GLErrorCatch("MainLoop");
}
drawArray.ClearDrawArrays();
glfwTerminate();
}
int main(int argc, char** argv)
{
int ch, profile = 0, strategy = 0, major = 1, minor = 0, revision;
GLboolean debug = GL_FALSE, forward = GL_FALSE, list = GL_FALSE;
GLint flags, mask;
GLFWwindow window;
while ((ch = getopt(argc, argv, "dfhlm:n:p:r:")) != -1)
{
switch (ch)
{
case 'd':
debug = GL_TRUE;
break;
case 'f':
forward = GL_TRUE;
break;
case 'h':
usage();
exit(EXIT_SUCCESS);
case 'l':
list = GL_TRUE;
break;
case 'm':
major = atoi(optarg);
break;
case 'n':
minor = atoi(optarg);
break;
case 'p':
if (strcasecmp(optarg, PROFILE_NAME_CORE) == 0)
profile = GLFW_OPENGL_CORE_PROFILE;
else if (strcasecmp(optarg, PROFILE_NAME_COMPAT) == 0)
profile = GLFW_OPENGL_COMPAT_PROFILE;
else if (strcasecmp(optarg, PROFILE_NAME_ES2) == 0)
profile = GLFW_OPENGL_ES2_PROFILE;
else
{
usage();
exit(EXIT_FAILURE);
}
break;
case 'r':
if (strcasecmp(optarg, STRATEGY_NAME_NONE) == 0)
strategy = GLFW_OPENGL_NO_RESET_NOTIFICATION;
else if (strcasecmp(optarg, STRATEGY_NAME_LOSE) == 0)
strategy = GLFW_OPENGL_LOSE_CONTEXT_ON_RESET;
else
{
usage();
exit(EXIT_FAILURE);
}
break;
default:
usage();
exit(EXIT_FAILURE);
}
}
argc -= optind;
argv += optind;
glfwSetErrorCallback(error_callback);
if (!glfwInit())
{
fprintf(stderr, "Failed to initialize GLFW: %s\n", glfwErrorString(glfwGetError()));
exit(EXIT_FAILURE);
}
if (major != 1 || minor != 0)
{
glfwWindowHint(GLFW_OPENGL_VERSION_MAJOR, major);
glfwWindowHint(GLFW_OPENGL_VERSION_MINOR, minor);
}
if (debug)
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
if (forward)
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
if (profile != 0)
glfwWindowHint(GLFW_OPENGL_PROFILE, profile);
if (strategy)
glfwWindowHint(GLFW_OPENGL_ROBUSTNESS, strategy);
// We assume here that we stand a better chance of success by leaving all
// possible details of pixel format selection to GLFW
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Version", NULL);
if (!window)
exit(EXIT_FAILURE);
glfwMakeContextCurrent(window);
// Report GLFW version
glfwGetVersion(&major, &minor, &revision);
printf("GLFW header version: %u.%u.%u\n",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
printf("GLFW library version: %u.%u.%u\n", major, minor, revision);
if (major != GLFW_VERSION_MAJOR ||
minor != GLFW_VERSION_MINOR ||
revision != GLFW_VERSION_REVISION)
{
printf("*** WARNING: GLFW version mismatch! ***\n");
}
printf("GLFW library version string: \"%s\"\n", glfwGetVersionString());
// Report OpenGL version
printf("OpenGL context version string: \"%s\"\n", glGetString(GL_VERSION));
major = glfwGetWindowParam(window, GLFW_OPENGL_VERSION_MAJOR);
minor = glfwGetWindowParam(window, GLFW_OPENGL_VERSION_MINOR);
revision = glfwGetWindowParam(window, GLFW_OPENGL_REVISION);
printf("OpenGL context version parsed by GLFW: %u.%u.%u\n", major, minor, revision);
// Report OpenGL context properties
if (major >= 3)
{
glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
printf("OpenGL context flags (0x%08x):", flags);
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
printf(" forward-compatible");
if (flags & 0)
printf(" debug");
putchar('\n');
printf("OpenGL context flags parsed by GLFW:");
if (glfwGetWindowParam(window, GLFW_OPENGL_FORWARD_COMPAT))
printf(" forward-compatible");
if (glfwGetWindowParam(window, GLFW_OPENGL_DEBUG_CONTEXT))
printf(" debug");
putchar('\n');
}
if (major > 3 || (major == 3 && minor >= 2))
{
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
printf("OpenGL profile mask (0x%08x): %s\n", mask, get_profile_name(mask));
printf("OpenGL profile mask parsed by GLFW: %s\n",
get_glfw_profile_name(glfwGetWindowParam(window, GLFW_OPENGL_PROFILE)));
}
printf("OpenGL context renderer string: \"%s\"\n", glGetString(GL_RENDERER));
printf("OpenGL context vendor string: \"%s\"\n", glGetString(GL_VENDOR));
if (major > 1)
{
printf("OpenGL context shading language version: \"%s\"\n",
glGetString(GL_SHADING_LANGUAGE_VERSION));
}
// Report OpenGL extensions
if (list)
list_extensions(major, minor);
glfwTerminate();
exit(EXIT_SUCCESS);
}
static const char* versionGet() noexcept
{return glfwGetVersionString();}
void InitWindow()
{
const int width = GetConfigInt("window.width", 640);
const int height = GetConfigInt("window.height", 480);
const char* title = GetConfigString("window.title", "Konstrukt");
const bool debug = GetConfigBool("opengl.debug", false);
const bool vsync = GetConfigBool("opengl.vsync", true);
LogInfo("Compiled with GLFW %d.%d.%d",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
LogInfo("Using GLFW %s", glfwGetVersionString());
assert(g_Window == NULL);
glfwSetErrorCallback(OnGLFWError);
if(!glfwInit())
FatalError("GLFW init failed.");
glfwDefaultWindowHints();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_DEPTH_BITS, GetConfigInt("opengl.depth-bits", 24));
glfwWindowHint(GLFW_STENCIL_BITS, 0);
glfwWindowHint(GLFW_SAMPLES, GetConfigInt("opengl.samples", 0));
glfwWindowHint(GLFW_SRGB_CAPABLE, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, debug ? GL_TRUE : GL_FALSE);
g_Window = glfwCreateWindow(width, height, title, NULL, NULL);
if(!g_Window)
FatalError("Window creation failed.");
glfwGetWindowSize(g_Window, &g_WindowWidth, &g_WindowHeight);
glfwGetFramebufferSize(g_Window, &g_FramebufferWidth, &g_FramebufferHeight);
glfwMakeContextCurrent(g_Window);
if(!flextInit(g_Window))
FatalError("Failed to load OpenGL extensions.");
LogInfo("Using OpenGL %s\n"
"Vendor: %s\n"
"Renderer: %s\n"
"GLSL: %s",
glGetString(GL_VERSION),
glGetString(GL_VENDOR),
glGetString(GL_RENDERER),
glGetString(GL_SHADING_LANGUAGE_VERSION));
if(vsync)
{
if(glfwExtensionSupported("GLX_EXT_swap_control_tear") ||
glfwExtensionSupported("WGL_EXT_swap_control_tear"))
glfwSwapInterval(-1); // enable vsync (allow the driver to swap even if a frame arrives a little bit late)
else
glfwSwapInterval(1); // enable vsync
}
else
{
glfwSwapInterval(0); // disable vsync
}
glfwSetInputMode(g_Window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
glfwSetInputMode(g_Window, GLFW_STICKY_KEYS, GL_FALSE);
glfwSetInputMode(g_Window, GLFW_STICKY_MOUSE_BUTTONS, GL_FALSE);
if(debug)
{
if(!FLEXT_ARB_debug_output)
FatalError("Debug output requested, but it's not supported!");
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
glDebugMessageCallbackARB(OnDebugEvent, NULL);
LogInfo("Debug output supported! You may receive debug messages from your OpenGL driver.");
}
glfwSetWindowSizeCallback(g_Window, OnWindowResize);
glfwSetFramebufferSizeCallback(g_Window, OnFramebufferResize);
glfwSetMouseButtonCallback(g_Window, OnMouseButtonAction);
glfwSetScrollCallback(g_Window, OnMouseScroll);
glfwSetCursorPosCallback(g_Window, OnCursorMove);
glfwSetKeyCallback(g_Window, OnKeyAction);
}
// Very complex stuff, impossible to explain.
int main(int argc, char *argv [])
{
//Set the error callback
glfwSetErrorCallback(onError);
//Initialize GLFW
if (!glfwInit()){
exit(EXIT_FAILURE);
}
//Set the GLFW window creation hints - these are optional
//glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); //Request a specific OpenGL version
//glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); //Request a specific OpenGL version
//glfwWindowHint(GLFW_SAMPLES, 4); //Request 4x antialiasing
//glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
//Declare a window object
GLFWwindow* window;
window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT,
"Screen Space Fluid Rendering",
NULL /* glfwGetPrimaryMonitor() */,
NULL);
if (!window){
fprintf(stderr, "Failed to open GLFW window.\n");
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
// Output some information
puts(glfwGetVersionString());
printf("OpenGL version supported %s\n", glGetString(GL_VERSION));
setupCallback(window);
// AssImp init
// get a handle to the predefined STDOUT log stream and attach
// it to the logging system. It remains active for all further
// calls to aiImportFile(Ex) and aiApplyPostProcessing.
aiLogStream aiStream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT, NULL);
aiAttachLogStream(&aiStream);
// --------------------------------------------
// Initialize GLEW
// --------------------------------------------
glewExperimental = GL_TRUE;
GLenum err = glewInit();
//If GLEW hasn't initialized
if (err != GLEW_OK){
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
return 1;
}
// --------------------------------------------
// DevIL init
// --------------------------------------------
ilInit();
/*
* Now that we should have a valid GL context, perform our OpenGL
* initialization, before we enter our main loop.
*/
initialize(window);
mainLoop(window);
unload(window);
// We added a log stream to the library, it's our job to disable it
// again. This will definitely release the last resources allocated
// by Assimp.
aiDetachAllLogStreams();
//Close OpenGL window and terminate GLFW
glfwDestroyWindow(window);
//Finalize and clean up GLFW
glfwTerminate();
exit(EXIT_SUCCESS);
}
int main()
{
// open an OS window using GLFW
if(!glfwInit())
{
fprintf (stderr, "ERROR: could not start GLFW3\n");
return 1;
}
char message[256];
sprintf (message, "starting GLFW %s", glfwGetVersionString());
assert (gl_log (message, __FILE__, __LINE__));
glfwSetErrorCallback (glfw_error_callback);
// Anti-Aliasing
glfwWindowHint (GLFW_SAMPLES, 4);
// get the primary monitor
GLFWmonitor* mon = glfwGetPrimaryMonitor();
// this lets us use the video mode for the monitor we pass
const GLFWvidmode* vmode = glfwGetVideoMode(mon);
//GLFWwindow* window2 = glfwCreateWindow(vmode->width, vmode->height, "Extended GL Init",mon/* mon*/, NULL);
// if (!window2)
// {
// fprintf (stderr, "ERROR: could not open window with GLFW3\n");
// glfwTerminate();
// return 1;
// }
//glfwSetWindowSize (window2, vmode->width, vmode->height);
//glfwMakeContextCurrent (window2);
GLFWwindow * window = glfwCreateWindow(640,480,"Hello Triangle", NULL, NULL);
if (!window)
{
fprintf (stderr, "ERROR: could not open window with GLFW3\n");
glfwTerminate();
return 1;
}
glfwMakeContextCurrent(window); // set as active window
// start GLEW extension handler
glewExperimental = GL_TRUE;
glewInit();
// get version info
const GLubyte* renderer = glGetString (GL_RENDERER); // get renderer string
const GLubyte* version = glGetString (GL_VERSION); // version as a string
printf ("Renderer: %s\n", renderer);
printf ("OpenGL version supported %s\n", version);
// tell GL to only draw onto a pixel if the shape is closer to the viewer
glEnable (GL_DEPTH_TEST); // enable depth-testing
glDepthFunc (GL_LESS);
// depth-testing interprets a smaller value as "closer"
//const char* vertex_shader =
//"#version 330\n"
//"in vec3 vp;"
//"void main () {"
//" gl_Position = vec4 (vp, 1.0);"
//"}";
//const char* fragment_shader =
//"#version 330\n"
//"out vec4 frag_colour;"
//"void main () {"
//" float lerpValue = gl_FragCoord.y / 480.0f;"
//" frag_colour = mix(vec4 (1.0f, 1.0f, 1.0f, 1.0f), vec4 (0.5, 0.0, 0.5, 1.0), lerpValue);"
//"}";
//// Create a shader
//GLuint vs = glCreateShader (GL_VERTEX_SHADER);
//// put actual char* into the shader
//glShaderSource (vs, 1, &vertex_shader, NULL);
//// compile the shader
//glCompileShader(vs);
//printShaderInfoLog(vs);
//GLuint fs = glCreateShader (GL_FRAGMENT_SHADER);
//glShaderSource (fs, 1, &fragment_shader, NULL);
//glCompileShader (fs);
//printShaderInfoLog(fs);
//// create the container that holds your shaders
//GLuint shaderProgram = glCreateProgram ();
//// attach the shaders you compiled
//glAttachShader (shaderProgram, fs);
//glAttachShader (shaderProgram, vs);
//// this links the shaders together, its kinda like a compile
//glLinkProgram (shaderProgram);
//printProgramInfoLog(shaderProgram);
//std::vector<Quad> v_quads;
//Quad * tester = new Quad();
Sprite * richard = new Sprite("simmons.png",384,324,Vector4(1,1,1,1),window);
//v_quads.push_back(initQuad);
while (!glfwWindowShouldClose (window))
{
_update_fps_counter (window);
// wipe the drawing surface clear
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport (0,0, g_gl_width, g_gl_height);
glClearColor(0,1,1,1);
//glUseProgram (shaderProgram);
//// if key is pressed
//if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
//{
//// make new quad object
// Quad newQuad;
// v_quads.push_back(newQuad);
//}
/*for (int i=0;i<7;i++)
{
Quad newQuad;
v_quads.push_back(newQuad);
}*/
// for each quad in vector, bind its VAO and draw
/*for(auto quad= v_quads.begin(); quad != v_quads.end(); ++quad)
{
glBindVertexArray (quad->m_VAO);
glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
}*/
richard->Draw();
// glBindVertexArray (0);
// put the stuff we've been drawing onto the display
glfwSwapBuffers (window);
}
// close GL context and any other GLFW resources
glfwTerminate();
//char* pause = "not";
//std::cin>> pause;
return 0;
}
int main()
{
//setup to log some GLFW stuff
char message[256];
sprintf (message, "starting GLFW %s", glfwGetVersionString ());
assert (gl_log (message, __FILE__, __LINE__));
glfwSetErrorCallback (glfw_error_callback);
//open an OS window using GLFW
if(!glfwInit())
{
fprintf (stderr,"ERROR: could not start GLFW3\n");
return 1;
}
// uncomment these lines if on Apple OS X
/* glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
*/
//Anti-Aliasing
glfwWindowHint (GLFW_SAMPLES, 4);
//get the primary monitor
GLFWmonitor* mon = glfwGetPrimaryMonitor ();
//this lets us the the video mode for the monitor we pass
const GLFWvidmode* vmode = glfwGetVideoMode (mon);
GLFWwindow* window = glfwCreateWindow (
vmode->width, vmode->height, "Extended GL Init",NULL/* mon*/, NULL
);
glfwSetWindowSize(window, g_gl_width, g_gl_height);
if (!window) {
fprintf (stderr, "ERROR: could not open window with GLFW3\n");
glfwTerminate();
return 1;
}
//not sure if this works
//log_gl_params ();
glfwMakeContextCurrent(window);
//start GLEW extension handler
glewExperimental = GL_TRUE;
glewInit();
// get version info
const GLubyte* renderer = glGetString (GL_RENDERER); // get renderer string
const GLubyte* version = glGetString (GL_VERSION); // version as a string
printf ("Renderer: %s\n", renderer);
printf ("OpenGL version supported %s\n", version);
// tell GL to only draw onto a pixel if the shape is closer to the viewer
glEnable (GL_DEPTH_TEST); // enable depth-testing
glDepthFunc (GL_LESS); // depth-testing interprets a smaller value as "closer"
float speed = 1.0f; // move at 1 unit per second
float last_position = 0.0f;
//Quad * tester = new Quad();
Sprite * richard = new Sprite("./resources/simmons.png", 384, 324, Vector4(1,1,1,1), window);
//int matrix_location = glGetUniformLocation (shaderProgram, "matrix");
//glUniform1i(glGetUniformLocation(shaderProgram, "Texture"), 0);
Ortho = new Matrix4();
Orthographic(0, g_gl_width, g_gl_height, 0, 0, -1, Ortho);
while (!glfwWindowShouldClose (window)) {
/* add a timer for doing animation
static double previous_seconds = glfwGetTime ();
double current_seconds = glfwGetTime ();
double elapsed_seconds = current_seconds - previous_seconds;
previous_seconds = current_seconds;
// reverse direction when going to far left or right
if (fabs(last_position) > 1.0f) {
speed = -speed;
}
*/
glEnable (GL_CULL_FACE); // cull face
glCullFace (GL_BACK); // cull back face
glFrontFace (GL_CW); // GL_CCW for counter clock-wise
// wipe the drawing surface clear
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//resize window
glViewport (0, 0, g_gl_width, g_gl_height);
// update the matrix
// matrix[12] = elapsed_seconds * speed + last_position;
// last_position = matrix[12];
//set the shader for this VAO
// glUseProgram (shaderProgram);
//Here is where we attach the marix
// glUniformMatrix4fv (matrix_location, 1, GL_FALSE, matrix);
//bind the VAO to be drawn
// glBindVertexArray (VAO);
// draw points 0-3 from the currently bound VAO with current in-use shader
// glDrawArrays (GL_TRIANGLES, 0, 3);
richard->Input();
richard->Draw();
// update other events like input handling
glfwPollEvents ();
// put the stuff we've been drawing onto the display
glfwSwapBuffers (window);
//When do i exit?
if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_ESCAPE)) {
glfwSetWindowShouldClose (window, 1);
}
}
// close GL context and any other GLFW resources
glfwTerminate();
return 0;
}
int notmain2()
{
char message[256];
sprintf (message, "starting GLFW %s", glfwGetVersionString ());
assert (gl_log (message, __FILE__, __LINE__));
glfwSetErrorCallback (glfw_error_callback);
//open an OS window using GLFW
if(!glfwInit())
{
fprintf (stderr,"ERROR: could not start GLFW3\n");
return 1;
}
// uncomment these lines if on Apple OS X
/*glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);*/
glfwWindowHint (GLFW_SAMPLES, 4);
GLFWwindow * window = glfwCreateWindow(640,480,"Hello Triangle",NULL,NULL);
if (!window) {
fprintf (stderr, "ERROR: could not open window with GLFW3\n");
glfwTerminate();
return 1;
}
glfwMakeContextCurrent(window);
//start GLEW extension handler
glewExperimental = GL_TRUE;
glewInit();
// get version info
const GLubyte* renderer = glGetString (GL_RENDERER); // get renderer string
const GLubyte* version = glGetString (GL_VERSION); // version as a string
printf ("Renderer: %s\n", renderer);
printf ("OpenGL version supported %s\n", version);
// tell GL to only draw onto a pixel if the shape is closer to the viewer
glEnable (GL_DEPTH_TEST); // enable depth-testing
glDepthFunc (GL_LESS); // depth-testing interprets a smaller value as "closer"
/* OTHER STUFF GOES HERE NEXT */
float points[] =
{
0.0f,0.5f,0.0f,
0.5f,-0.5f,0.0f,
-0.5f,-0.5f,0.0f,
};
GLuint VBO = 0;
glGenBuffers (1, &VBO);
glBindBuffer (GL_ARRAY_BUFFER, VBO);
glBufferData (GL_ARRAY_BUFFER, 9 * sizeof (float), points, GL_STATIC_DRAW);
GLuint VAO = 0;
glGenVertexArrays (1, &VAO);
glBindVertexArray (VAO);
glEnableVertexAttribArray (0);
glBindBuffer (GL_ARRAY_BUFFER, VBO);
glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte*)NULL);
const char* vertex_shader =
"#version 400\n"
"in vec3 vp;"
"void main () {"
" gl_Position = vec4 (vp, 1.0);"
"}";
const char* fragment_shader =
"#version 400\n"
"out vec4 frag_colour;"
"void main () {"
" frag_colour = vec4 (0.5, 0.0, 0.5, 1.0);"
"}";
//Create a shader
GLuint vs = glCreateShader (GL_VERTEX_SHADER);
//put the actual char* into the shader
glShaderSource (vs, 1, &vertex_shader, NULL);
//Compile the shader
glCompileShader (vs);
GLuint fs = glCreateShader (GL_FRAGMENT_SHADER);
glShaderSource (fs, 1, &fragment_shader, NULL);
glCompileShader (fs);
//Create the container that holds your shaders
GLuint shaderProgram = glCreateProgram ();
//attach the shaders you compiled
glAttachShader (shaderProgram, fs);
glAttachShader (shaderProgram, vs);
//this is links the shaders together, its kinda like a compile
glLinkProgram (shaderProgram);
while (!glfwWindowShouldClose (window)) {
// wipe the drawing surface clear
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram (shaderProgram);
glBindVertexArray (VAO);
// draw points 0-3 from the currently bound VAO with current in-use shader
glDrawArrays (GL_TRIANGLES, 0, 3);
// update other events like input handling
glfwPollEvents ();
// put the stuff we've been drawing onto the display
glfwSwapBuffers (window);
}
// close GL context and any other GLFW resources
glfwTerminate();
return 0;
}
int main(int argc, char** argv)
{
LOG_INFO("RiftRay version %s", pRiftRayVersion);
#if defined(_WIN32)
LOG_INFO("Windows build.");
#elif defined(_LINUX)
LOG_INFO("Linux build.");
#elif defined(_MACOS)
LOG_INFO("MacOS build.");
#endif
bool useOpenGLCoreContext = false;
g_renderMode.outputType = RenderingMode::OVR_SDK;
#ifdef USE_CORE_CONTEXT
useOpenGLCoreContext = true;
#endif
#ifdef _LINUX
// Linux driver seems to be lagging a bit
useOpenGLCoreContext = false;
#endif
LOG_INFO("Using GLFW3 backend.");
LOG_INFO("Compiled against GLFW %i.%i.%i",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
int major, minor, revision;
glfwGetVersion(&major, &minor, &revision);
LOG_INFO("Running against GLFW %i.%i.%i", major, minor, revision);
LOG_INFO("glfwGetVersionString: %s", glfwGetVersionString());
// Command line options
for (int i=0; i<argc; ++i)
{
const std::string a = argv[i];
LOG_INFO("argv[%d]: %s", i, a.c_str());
if (!a.compare("-sdk"))
{
g_renderMode.outputType = RenderingMode::OVR_SDK;
}
else if (!a.compare("-client"))
{
g_renderMode.outputType = RenderingMode::OVR_Client;
}
else if (!a.compare("-core"))
{
useOpenGLCoreContext = true;
}
else if (!a.compare("-compat"))
{
useOpenGLCoreContext = false;
}
}
LoadConfigFile();
g_app.initHMD();
GLFWwindow* l_Window = NULL;
glfwSetErrorCallback(ErrorCallback);
if (!glfwInit())
{
exit(EXIT_FAILURE);
}
#ifdef __APPLE__
// Set the working directory to the Resources dir of the .app bundle
CFBundleRef mainBundle = CFBundleGetMainBundle();
CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle);
char path[PATH_MAX];
CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)path, PATH_MAX);
CFRelease(resourcesURL);
strcat( path, "/shaders" );
struct stat sb;
if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode))
chdir(path);
#endif
#ifndef _LINUX
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
# if defined(_MACOS)
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
# else
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
# endif
#endif //ndef _LINUX
if (useOpenGLCoreContext)
{
LOG_INFO("Using OpenGL core context.");
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
}
else
{
#ifndef _LINUX
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
#endif
}
glfwWindowHint(GLFW_SAMPLES, 0);
#ifdef _DEBUG
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
#endif
std::string windowTitle = "RiftRay-v" + std::string(pRiftRayVersion);
#ifdef USE_OCULUSSDK
const ovrSizei sz = g_app.getHmdResolution();
const ovrVector2i pos = g_app.getHmdWindowPos();
if (g_app.UsingDebugHmd() == true)
{
// Create a normal, decorated application window
LOG_INFO("Using Debug HMD mode.");
windowTitle += "-GLFW-DebugHMD";
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
g_app.m_dashScene.m_bDraw = false;
g_renderMode.outputType = RenderingMode::Mono_Buffered;
}
else if (g_app.UsingDirectMode())
{
LOG_INFO("Using Direct to Rift mode.");
windowTitle += "-GLFW-Direct";
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
#if defined(_WIN32)
g_app.AttachToWindow((void*)glfwGetWin32Window(l_Window));
#endif
}
else
{
LOG_INFO("Using Extended desktop mode.");
windowTitle += "-GLFW-Extended";
glfwWindowHint(GLFW_DECORATED, 0);
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
glfwWindowHint(GLFW_DECORATED, 1);
glfwSetWindowPos(l_Window, pos.x, pos.y);
}
resize(l_Window, sz.w, sz.h); // inform AppSkeleton of window size
#else
const glm::vec2 sz(800, 600);
// Create a normal, decorated application window
LOG_INFO("Using No VR SDK.");
windowTitle += "-GLFW-NoVRSDK";
g_renderMode.outputType = RenderingMode::Mono_Buffered;
l_Window = glfwCreateWindow(sz.x, sz.y, windowTitle.c_str(), NULL, NULL);
resize(l_Window, sz.x, sz.y); // inform AppSkeleton of window size
#endif //USE_OSVR|USE_OCULUSSDK
if (!l_Window)
{
LOG_INFO("Glfw failed to create a window. Exiting.");
glfwTerminate();
exit(EXIT_FAILURE);
}
#ifdef USE_OCULUSSDK
// Required for SDK rendering (to do the buffer swap on its own)
# if defined(_WIN32)
g_app.setWindow(glfwGetWin32Window(l_Window));
# elif defined(__linux__)
g_app.setWindow(glfwGetX11Display());
# endif
#endif
glfwMakeContextCurrent(l_Window);
glfwSetWindowSizeCallback(l_Window, resize);
glfwSetMouseButtonCallback(l_Window, mouseDown);
glfwSetCursorPosCallback(l_Window, mouseMove);
glfwSetScrollCallback(l_Window, mouseWheel);
glfwSetKeyCallback(l_Window, keyboard);
memset(m_keyStates, 0, GLFW_KEY_LAST*sizeof(int));
FindPreferredJoystick();
// Log system monitor information
const GLFWmonitor* pPrimary = glfwGetPrimaryMonitor();
int monitorCount = 0;
GLFWmonitor** ppMonitors = glfwGetMonitors(&monitorCount);
for (int i=0; i<monitorCount; ++i)
{
GLFWmonitor* pCur = ppMonitors[i];
const GLFWvidmode* mode = glfwGetVideoMode(pCur);
if (mode != NULL)
{
LOG_INFO("Monitor #%d: %dx%d @ %dHz %s",
i,
mode->width,
mode->height,
mode->refreshRate,
pCur==pPrimary ? "Primary":"");
}
}
printGLContextInfo(l_Window);
glfwMakeContextCurrent(l_Window);
g_pHMDWindow = l_Window;
// Don't forget to initialize Glew, turn glewExperimental on to
// avoid problems fetching function pointers...
glewExperimental = GL_TRUE;
const GLenum l_Result = glewInit();
if (l_Result != GLEW_OK)
{
LOG_INFO("glewInit() error.");
exit(EXIT_FAILURE);
}
#ifdef _DEBUG
// Debug callback initialization
// Must be done *after* glew initialization.
glDebugMessageCallback(myCallback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 0,
GL_DEBUG_SEVERITY_NOTIFICATION, -1, "Start debugging");
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
#endif
#ifdef USE_ANTTWEAKBAR
LOG_INFO("Using AntTweakbar.");
TwInit(useOpenGLCoreContext ? TW_OPENGL_CORE : TW_OPENGL, NULL);
InitializeBar();
#endif
LOG_INFO("Calling initGL...");
g_app.initGL();
LOG_INFO("Calling initVR...");
g_app.initVR();
LOG_INFO("initVR complete.");
SetVsync(1); // default to vsync on
StartShaderLoad();
while (!glfwWindowShouldClose(l_Window))
{
const bool tapped = g_app.CheckForTapOnHmd();
if (tapped && (g_receivedFirstTap == false))
{
g_app.RecenterPose();
g_receivedFirstTap = true;
}
glfwPollEvents();
joystick();
timestep();
g_fps.OnFrame();
if (g_dynamicallyScaleFBO)
{
DynamicallyScaleFBO();
}
#ifdef USE_ANTTWEAKBAR
TwRefreshBar(g_pTweakbar);
TwRefreshBar(g_pShaderTweakbar);
#endif
displayToHMD();
#ifndef _LINUX
// Indicate FPS in window title
// This is absolute death for performance in Ubuntu Linux 12.04
{
std::ostringstream oss;
oss << windowTitle
<< " "
<< static_cast<int>(g_fps.GetFPS())
<< " fps";
glfwSetWindowTitle(l_Window, oss.str().c_str());
if (g_AuxWindow != NULL)
glfwSetWindowTitle(g_AuxWindow, oss.str().c_str());
}
#endif
const float dumpInterval = 1.f;
if (g_logDumpTimer.seconds() > dumpInterval)
{
LOG_INFO("Frame rate: %d fps", static_cast<int>(g_fps.GetFPS()));
g_logDumpTimer.reset();
}
// Optionally display to auxiliary mono view
if (g_AuxWindow != NULL)
{
glfwMakeContextCurrent(g_AuxWindow);
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
///@note VAOs *cannot* be shared between contexts.
///@note GLFW windows are inextricably tied to their own unique context.
/// For these two reasons, calling draw a third time for the auxiliary window
/// is not possible. Furthermore, it is not strictly desirable for the extra
/// rendering cost.
/// Instead, we share the render target texture from the stereo render and present
/// just the left eye to the aux window.
if (g_drawToAuxWindow)
{
presentSharedFboTexture();
}
#ifdef USE_ANTTWEAKBAR
TwDraw(); ///@todo Should this go first? Will it write to a depth buffer?
#endif
glfwSwapBuffers(g_AuxWindow);
if (glfwWindowShouldClose(g_AuxWindow))
{
destroyAuxiliaryWindow(g_AuxWindow);
}
// Set context to Rift window when done
glfwMakeContextCurrent(l_Window);
}
}
g_app.exitVR();
glfwDestroyWindow(l_Window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
int main() {
char message[256];
sprintf(message, "staring glfw %s", glfwGetVersionString());
assert(GL_log(message, __FILE__, __LINE__));
glfwSetErrorCallback(glfw_error_callback);
//open and OS window using glfw
if (!glfwInit()) {
fprintf (stderr,"ERROR: could not start GLFW3\n");
return 1;
}
glfwWindowHint(GLFW_SAMPLES, 4);
//get primary monitor
GLFWmonitor* mon = glfwGetPrimaryMonitor();
//this lets us use the video mode for the monitor we pass
const GLFWvidmode* vmode = glfwGetVideoMode(mon);
GLFWwindow* window = glfwCreateWindow(vmode->width, vmode->height, "Extended GL Init", NULL/*mon*/, NULL);
glfwSetWindowSize(window, g_gl_width, g_gl_height);
if (!window) {
fprintf (stderr,"ERROR: could not open window GLFW3\n");
glfwTerminate();
return 1;
}
glfwMakeContextCurrent(window);
//start glew extention handler
glewExperimental = GL_TRUE;
glewInit();
//get version info
const GLubyte * renderer = glGetString (GL_RENDERER); //get renderer string
const GLubyte * version = glGetString (GL_VERSION); //get version as a string
printf ("Renerer: %s\n", renderer);
printf ("OpenGL version supported %s\n", version);
//tell GL to only draw onto a pixel if the shape is closer to the viewer
glEnable (GL_DEPTH_TEST); //enable depth testing
glDepthFunc (GL_LESS);
/* other stuff goes here */
/*float points[] = {
0.0f, 0.5, 0.0f,
0.5f, -0.5f, 0.0f,
-0.5f, -0.5f, 0.0f
};
GLuint VBO = 0;
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, 9 * sizeof (float), points, GL_STATIC_DRAW);
GLuint VAO = 0;
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte*)NULL);
const char* vertex_shader =
"#version 330\n"
"in vec3 pos;\n"
"void main() {"
"gl_Position = vec4(pos, 1.0);\n"
"}";
const char* fragment_shader =
"#version 330\n"
"out vec4 frag_colour;\n"
"void main() {"
"frag_colour = vec4(0.5, 0.0, 0.5, 1.0);\n"
"}";
//create a shader
GLuint vs = glCreateShader(GL_VERTEX_SHADER);
//put the actual cha* int the shader
glShaderSource(vs, 1, &vertex_shader, NULL);
//compile the shader
glCompileShader(vs);
PrintShaderInfoLog(vs);
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fs, 1, &fragment_shader, NULL);
glCompileShader(fs);
PrintShaderInfoLog(fs);
//create the container that holds the shaders
GLuint shaderProgram = glCreateProgram();
//attach the shaders
glAttachShader(shaderProgram, fs);
glAttachShader(shaderProgram, vs);
//this inks the shaders together, its kinda like a compile
glLinkProgram(shaderProgram);
PrintProgramInfoLog(shaderProgram);
//new object
float Spoints[] = {
-0.25f, -0.5f, 0.0f,
-0.25f, -0.75f, 0.0f,
0.25f, -0.5f, 0.0f,
0.25f, -0.75f, 0.0f
};
GLuint VBO2 = 0;
glGenBuffers(1, &VBO2);
glBindBuffer(GL_ARRAY_BUFFER, VBO2);
glBufferData(GL_ARRAY_BUFFER, 12 * sizeof (float), Spoints, GL_STATIC_DRAW);
GLuint VAO2 = 0;
glGenVertexArrays(1, &VAO2);
glBindVertexArray(VAO2);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte*)NULL);
const char* vertex_shader2 =
"#version 330\n"
"in vec3 vp;\n"
"void main() {"
"gl_position = vec4(vp, 2.0);\n"
"}";
const char* fragment_shader2 =
"#version 330\n"
"out vec4 frag_colour;\n"
"void main() {"
"frag_colour = vec4(0.5, 0.0, 0.0, 1.0);\n"
"}";
//create a shader
GLuint vs2 = glCreateShader(GL_VERTEX_SHADER);
//put the actual char* in the shader
glShaderSource(vs2, 1, &vertex_shader2, NULL);
//compile the shader
glCompileShader(vs2);
PrintShaderInfoLog(vs2);
GLuint fs2 = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fs2, 1, &fragment_shader2, NULL);
glCompileShader(fs2);
PrintShaderInfoLog(fs2);
//create the container that holds the shaders
GLuint secondProgram = glCreateProgram();
//attach the shaders
glAttachShader(secondProgram, fs2);
glAttachShader(secondProgram, vs2);
//this inks the shaders together, its kinda like a compile
glLinkProgram(secondProgram);
PrintProgramInfoLog(secondProgram);
*/
Ortho = new Matrix4();
Orthographic(0, g_gl_width, g_gl_height, 0, 0, -1, Ortho);
//Quad * tester1 = new Quad();
AnimatedSprite * tester = new AnimatedSprite("../resources/MegamanXSheet.xml", window);
tester->SetAnimation("teleport", ONCE);
while (!glfwWindowShouldClose(window)) {
//_update_fps_counter(window);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.5);
glEnable(GL_ALPHA);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
//wipe the drawing surface
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//resize window
glViewport (0, 0, g_gl_width, g_gl_height);
tester->Update();
//tester->Draw();
//tester->Input();
//update other events like input handling
glfwPollEvents();
//put the stuff we've been drawing into the display
glfwSwapBuffers(window);
resetDeltaTime();
if (GLFW_PRESS == glfwGetKey(window, GLFW_KEY_ESCAPE)) {
glfwSetWindowShouldClose(window, 1);
}
}
//close GL context and any other GLFW resources
//delete Ortho;
//delete tester;
glfwTerminate();
return 0;
}
std::unique_ptr<psi_serv::IWindowService> psi_serv::start_gl_window_service(GLWindowServiceArgs args) {
// -- START GLFW --
if (glfwInit() == 0)
throw std::runtime_error("Failed to initialize GLFW.");
glfwSetErrorCallback(
[] (GLint code, char const* desc) {
psi_log::error("GLFW") << "(" << code << "): " << desc << "\n";
}
);
psi_log::info("GLWindowService") << "Initialized GLFW " << glfwGetVersionString() << "\n";
// -- START GLFW WINDOW --
// GL version 4.4
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
// No backwards compatibility
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, true);
// Resizability of this window
glfwWindowHint(GLFW_RESIZABLE, args.resizable);
// Whether the window is always on top
glfwWindowHint(GLFW_FLOATING, args.always_on_top);
// How many samples to take for anti-aliasing (MSAA)
glfwWindowHint(GLFW_SAMPLES, args.samples);
// Whether it's a debug context
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, args.debug);
// sets the window to be sRGB capable, meaning it can convert linear output from shader to sRGB in framebuffer
glfwWindowHint(GLFW_SRGB_CAPABLE, true);
auto window = glfwCreateWindow(args.width, args.height, args.title, nullptr, nullptr);
if (window == nullptr)
throw std::runtime_error("Failed to create a GLFW window.");
// key presses are remembered until polled
glfwSetInputMode(window, GLFW_STICKY_KEYS, true);
// create the service and map its address to the user pointer in GLFW
auto service = new GLWindowService(window);
glfwSetWindowUserPointer(window, service);
glfwSetFramebufferSizeCallback(window,
[] (GLFWwindow* win, int width, int height) {
if (width <= 1 || height <= 1)
return;
static_cast<GLWindowService*>(glfwGetWindowUserPointer(win))->framebuffer_size_callback(width, height);
}
);
service->framebuffer_size_callback(args.width, args.height);
glfwSetKeyCallback(window,
[] (GLFWwindow* win, int key, int scancode, int action, int mods) {
static_cast<GLWindowService*>(glfwGetWindowUserPointer(win))->key_pressed_callback(key, scancode, action, mods);
}
);
glfwSetMouseButtonCallback(window,
[] (GLFWwindow* win, int button, int action, int mods) {
static_cast<GLWindowService*>(glfwGetWindowUserPointer(win))->mouse_pressed_callback(button, action, mods);
}
);
glfwSetCursorPosCallback(window,
[] (GLFWwindow* win, double x, double y) {
static_cast<GLWindowService*>(glfwGetWindowUserPointer(win))->cursor_moved_callback(x, y);
}
);
glfwMakeContextCurrent(window);
// -- INITIALIZE OPENGL --
auto load_status = gl::sys::LoadFunctions();
if (!load_status)
throw std::runtime_error(std::string("OpenGL Core ") + std::to_string(gl::sys::GetMajorVersion()) + "." + std::to_string(gl::sys::GetMinorVersion()) + " initialization failed.\n"
+ "Number of functions that failed to load: " + std::to_string(load_status.GetNumMissing()));
gl::Enable(gl::DEBUG_OUTPUT_SYNCHRONOUS);
gl::DebugMessageCallback(gl_error_callback, nullptr);
psi_log::info("GLWindowService") << "Initialized OpenGL Core " << gl::sys::GetMajorVersion() << "." << gl::sys::GetMinorVersion() << "\n";
// -- RETURN SERVICE --
return std::unique_ptr<IWindowService>(service);
}
int Game::Initialize(){
LOG(info) << "Jarg initialization start";
glfwSetErrorCallback([](int a,const char* description){LOG(error) << description;});
int glfwErrorCode = glfwInit();
if (!glfwErrorCode)
{
LOG(error) << "glfwInit error " << glfwErrorCode;
return glfwErrorCode;
}
glfwWindowHint(GLFW_SAMPLES, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, Game::MAJOR_GL);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, Game::MINOR_GL);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
monitor = nullptr;
if(fullscreen)
{
monitor = glfwGetPrimaryMonitor();
}
window = glfwCreateWindow(width, height, title.c_str(), monitor, nullptr);
if (!window)
{
glfwTerminate();
LOG(fatal) << "Ошибка создания окна GLFW.";
return false;
}
glfwMakeContextCurrent(window);
//glfwSetWindowTitle(window, AutoVersion::GetTitle().c_str());
glfwSwapInterval(0);
if (glewInit() != GLEW_OK)
{
LOG(fatal) << "GLEW не инициализирован.";
return false;
}
GameObject go;
go.seed = 123;
for (int i =0; i<100; i++)
{
GenerateStar(&go);
}
int glVersion[2] = {-1, -1};
glGetIntegerv(GL_MAJOR_VERSION, &glVersion[0]);
glGetIntegerv(GL_MINOR_VERSION, &glVersion[1]);
LOG(info) << "Renderer: " << glGetString(GL_RENDERER);
LOG(info) << "Vendor: " << glGetString(GL_VENDOR);
LOG(info) << "Version: " << glGetString(GL_VERSION);
LOG(info) << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION);
LOG(info) << "using OpenGL: " << std::to_string(glVersion[0]) << "." << std::to_string(glVersion[1]);
LOG(info) << "glfw: " << glfwGetVersionString();
Keyboard::Initialize();
glfwSetKeyCallback(window, [](GLFWwindow *win, int key, int scancode, int action, int mods){Keyboard::SetKey(key, scancode, action, mods);});
Mouse::Initialize(window);
Mouse::SetWindowSize(width, height);
// Mouse::SetFixedPosState(true);
glfwSetCursorPosCallback(window, [](GLFWwindow *window, double xpos, double ypos){Mouse::SetCursorPos(xpos, ypos);});
glfwSetCursorEnterCallback(window, [](GLFWwindow *window, int entered){Mouse::CursorClientArea(entered);});
glfwSetWindowFocusCallback(window, [](GLFWwindow *window, int focused){Mouse::WindowFocus(focused);});
glfwSetMouseButtonCallback(window, [](GLFWwindow *window, int a, int b, int c){Mouse::SetButton(a, b, c);});
glfwSetWindowSizeCallback(window, [](GLFWwindow *window, int a, int b){Game::Resize(a, b); Mouse::SetWindowSize(a, b);});
glfwSetScrollCallback(window, [](GLFWwindow *window, double a, double b){Mouse::Scroll(b);});
wire = 1;
spd = 1;
//////////////////////////////////////////////////////////////////////////
LinesShader = std::shared_ptr<BasicJargShader>(new BasicJargShader());
LinesShader->loadShaderFromSource(GL_VERTEX_SHADER, "Shaders/colored.glsl");
LinesShader->loadShaderFromSource(GL_FRAGMENT_SHADER, "Shaders/colored.glsl");
LinesShader->Link();
mvpLine = LinesShader->locateVars("MVP");
TextureShader = std::shared_ptr<BasicJargShader>(new BasicJargShader());
TextureShader->loadShaderFromSource(GL_VERTEX_SHADER, "Shaders/textured.glsl");
TextureShader->loadShaderFromSource(GL_FRAGMENT_SHADER, "Shaders/textured.glsl");
TextureShader->Link();
mvpTex = TextureShader->locateVars("MVP");
FXAAShader = std::shared_ptr<BasicJargShader>(new BasicJargShader());
FXAAShader->loadShaderFromSource(GL_VERTEX_SHADER, "Shaders/fxaa.glsl");
FXAAShader->loadShaderFromSource(GL_FRAGMENT_SHADER, "Shaders/fxaa.glsl");
FXAAShader->Link();
BasicShader = std::shared_ptr<BasicJargShader>(new BasicJargShader());
BasicShader->loadShaderFromSource(GL_VERTEX_SHADER, "Shaders/minnaert.glsl");
BasicShader->loadShaderFromSource(GL_FRAGMENT_SHADER, "Shaders/minnaert.glsl");
BasicShader->loadShaderFromSource(GL_TESS_CONTROL_SHADER, "Shaders/minnaert.glsl");
BasicShader->loadShaderFromSource(GL_TESS_EVALUATION_SHADER, "Shaders/minnaert.glsl");
BasicShader->Link();
BasicShader->UpdateUniforms();
BasicShader->locateVars("transform.viewProjection"); //var0
BasicShader->locateVars("transform.model"); //var1
BasicShader->locateVars("transform.normal"); //var2
BasicShader->locateVars("material.texture");
testtex = std::shared_ptr<Texture>(new Texture());
testtex->Empty(vec2(256,256));
uptex = std::shared_ptr<Texture>(new Texture());
uptex->Load("up.png");
//////////////////////////////////////////////////////////////////////////
light.position = vec4(5.0f, 12.0f, 3.0f, 1.0f);
light.ambient = vec4(0.2f, 0.2f, 0.2f, 1.0f);
light.diffuse = vec4(1.0f, 1.0f, 1.0f, 1.0f);
light.specular = vec4(1.0f, 1.0f, 1.0f, 1.0f);
light.attenuation = vec3(0.000f, 0.0f, 0.00000f);
batched = std::unique_ptr<Batched>(new Batched());
batched->Initialize(TextureShader.get(), LinesShader.get());
font = std::unique_ptr<Font>(new Font());
font->Initialize();
//actually not load json
if(!font->Create("font.json")){
LOG(error) << "failed to load\process font.json";
}
WindowsDesigner();
camera = std::unique_ptr<Camera>(new Camera());
camera->SetViewport(0, 0, width, height);
camera->SetPosition(vec3(2,2,2));
camera->SetLookAt(vec3(0));
gt = std::unique_ptr<GameTimer>(new GameTimer);
Generation gen;
rs = new QuadTreePlane();
rs->Init(BasicShader, *camera);
auto tex = std::shared_ptr<Texture>(new Texture());
tex->Load("normal.png");
icos = std::unique_ptr<Mesh>(new Mesh(Cube::getMesh()));
icos->Bind();
icos->shader = BasicShader;
icos->material = std::shared_ptr<Material>(new Material());
icos->material->texture = tex;
//test.LoadBinary("untitled.m");
test.Bind();
for (int i = 0; i<test.meshes.size(); i++)
{
test.meshes[i]->shader = BasicShader;
}
return true;
}