bool Application::startup()
{
if (glfwInit() == false)
{
return false;
}
this->m_window = glfwCreateWindow(1280, 720, "Computer Graphics", nullptr, nullptr);
if (this->m_window == nullptr)
{
return false;
}
glfwMakeContextCurrent(this->m_window);
if (ogl_LoadFunctions() == ogl_LOAD_FAILED)
{
glfwDestroyWindow(this->m_window);
glfwTerminate();
return false;
}
int major_version = ogl_GetMajorVersion();
int minor_version = ogl_GetMinorVersion();
printf("successfully loaded OpenGL version %d.%d\n", major_version, minor_version);
return true;
}
ApplicationFail Application::Init() {
BeforeInit();
if ( glfwInit() == false ) { return ApplicationFail::GLFW_INIT; }
window_glfw_ = glfwCreateWindow( 1280, 720, name_string_.c_str(), nullptr, nullptr );
if ( window_glfw_ == nullptr ) {
glfwTerminate();
return ApplicationFail::GLFW_CREATE_WINDOW;
}
glfwMakeContextCurrent( window_glfw_ );
if ( ogl_LoadFunctions() == ogl_LOAD_FAILED ) {
glfwDestroyWindow( window_glfw_ );
glfwTerminate();
return ApplicationFail::OGL_LOAD_FUNCTIONS;
}
const int OGL_MAJOR = ogl_GetMajorVersion();
const int OGL_MINOR = ogl_GetMinorVersion();
printf( "OpenGL Version: %i.%i\n", OGL_MAJOR, OGL_MINOR );
glClearColor( 0.25f, 0.25f, 0.25f, 1.0f );
glEnable( GL_DEPTH_TEST );
time_previous_d_ = glfwGetTime();
InputDevice::Init( window_glfw_ );
AfterInit();
return ApplicationFail::NONE;
}
bool GLApplication::InitializeOpenGL()
{
if (glfwInit() == false)
return false;
m_pWindow = glfwCreateWindow(m_windowWidth, m_windowHeight, m_appTitle.c_str(), nullptr, nullptr);
if (m_pWindow == nullptr)
{
glfwTerminate();
return false;
}
glfwMakeContextCurrent(m_pWindow);
//glfwSetInputMode(m_pWindow, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
if (ogl_LoadFunctions() == ogl_LOAD_FAILED)
{
glfwDestroyWindow(m_pWindow);
glfwTerminate();
return false;
}
auto major = ogl_GetMajorVersion();
auto minor = ogl_GetMinorVersion();
printf("GL: %i.%i\n", major, minor);
m_clearColour = vec3(0.25f);
glEnable(GL_DEPTH_TEST);
return true;
}
int Application::startup()
{
if (glfwInit() == false)
return -1;
window = glfwCreateWindow(1280, 720, "Computer Graphics", nullptr, nullptr);
if (window == nullptr)
glfwTerminate();
glfwMakeContextCurrent(window);
//the rest of our code goes here!
if (ogl_LoadFunctions() == ogl_LOAD_FAILED)
{
glfwDestroyWindow(window);
glfwTerminate();
return -3;
}
//testing what version of OpenGL we are running
auto major = ogl_GetMajorVersion();
auto minor = ogl_GetMinorVersion();
printf_s("GL: %i.%i\n", major, minor);
return 1;
}
int Init(bool a_bSetFullScreen, unsigned int a_uiWidth, unsigned int a_uiHeight, int a_uiPosX, int a_uiPosY)
{
Monitor = glfwGetMonitors(aiNumOfMonitors);
Mode = glfwGetVideoMode(Monitor[0]);
glfwWindowHint(GLFW_RED_BITS, Mode->redBits);
glfwWindowHint(GLFW_GREEN_BITS, Mode->greenBits);
glfwWindowHint(GLFW_BLUE_BITS, Mode->blueBits);
glfwWindowHint(GLFW_REFRESH_RATE, Mode->refreshRate);
if (a_bSetFullScreen)
Window = glfwCreateWindow(Mode->width, Mode->height, "The Solar System", Monitor[0], nullptr);
else
{
Window = glfwCreateWindow(a_uiWidth, a_uiHeight, "The Solar System", nullptr, nullptr);
if (a_uiPosX == -1)
a_uiPosX = (Mode->width - a_uiWidth) / 2;
if (a_uiPosY == -1)
a_uiPosY = (Mode->height - a_uiHeight) / 2;
glfwSetWindowPos(Window, a_uiPosX, a_uiPosY);
}
if (Window == nullptr)
{
glfwTerminate();
return -2;
}
//make the glfw window
glfwMakeContextCurrent(Window);
if (ogl_LoadFunctions() == ogl_LOAD_FAILED)
{
glfwDestroyWindow(Window);
glfwTerminate();
return -3;
}
// Parses the version of OpenGL and prints it
auto major = ogl_GetMajorVersion();
auto minor = ogl_GetMinorVersion();
printf_s("GL: %i.%i\n", major, minor);
//initialize all of our gizmos and set up the virtual camera
Gizmos::create();
SetView({ 10, 0, 0 }, { 0, 0, 0 }, { 0, 1, 0 });
Projection = glm::perspective(glm::pi<float>() * 0.25f, 16 / 9.f, 0.001f, 1000.f);
glClearColor(0.5f, 0.5f, 0.5f, 1);//set the clear color
glEnable(GL_DEPTH_TEST); // enables the depth buffer
return 0;
}
static void InitSystem(int width, int height)
{
SDL_Init(SDL_INIT_EVERYTHING);
atexit(SDL_Quit);
InitSDL();
if (NULL == SDL_SetVideoMode(width, height, 32, SDL_OPENGL | SDL_HWSURFACE))
{
exit(EXIT_FAILURE);
}
InitSDL(); // workaround for occassional bug in some SDL implementations
ogl_LoadFunctions();
LOG("GL v%d.%d\n", ogl_GetMajorVersion(), ogl_GetMinorVersion());
LOG("GLSL version: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
InitGL();
glViewport(0, 0, (GLsizei)width, (GLsizei)height);
}
bool Application::startup()
{
if (glfwInit() == false)
{
return false;
}
#if _DEBUG
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, true);
#endif
window_width = 1280;
window_height = 720;
this->m_window = glfwCreateWindow(window_width, window_height, "Computer Graphics", nullptr, nullptr);
if (this->m_window == nullptr)
{
return false;
}
glfwMakeContextCurrent(this->m_window);
if (ogl_LoadFunctions() == ogl_LOAD_FAILED)
{
glfwDestroyWindow(this->m_window);
glfwTerminate();
return false;
}
int major_version = ogl_GetMajorVersion();
int minor_version = ogl_GetMinorVersion();
printf("Successfully loaded OpenGL version %d.%d\n",
major_version, minor_version);
#ifdef _DEBUG
glDebugMessageCallback((GLDEBUGPROC)DebugCallback, stderr); // print debug output to stderr
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
#endif
glfwSwapInterval(1);
return true;
}
ApplicationFail Application::Init() {
if ( glfwInit() == false ) { return ApplicationFail::GLFW_INIT; }
window_glfw_ = glfwCreateWindow( 1280, 720, name_string_.c_str(), nullptr, nullptr );
if ( window_glfw_ == nullptr ) {
glfwTerminate();
return ApplicationFail::GLFW_CREATE_WINDOW;
}
glfwMakeContextCurrent( window_glfw_ );
Input::window_ = window_glfw_;
camera_ = new FlyCamera( 0.1f );
camera_->SetPerspective( glm::pi<float>() * 0.25f, SIXTEEN_NINE, 0.1f, 1000.f );
camera_->SetLookAt( vec3( 10, 10, 10 ), vec3( 0 ), vec3( 0, 1, 0 ) );
if ( ogl_LoadFunctions() == ogl_LOAD_FAILED ) {
glfwDestroyWindow( window_glfw_ );
glfwTerminate();
return ApplicationFail::OGL_LOAD_FUNCTIONS;
}
const int OGL_MAJOR = ogl_GetMajorVersion();
const int OGL_MINOR = ogl_GetMinorVersion();
printf( "OpenGL Version: %i.%i\n", OGL_MAJOR, OGL_MINOR );
glClearColor( 0.25f, 0.25f, 0.25f, 1.0f );
glEnable( GL_DEPTH_TEST );
time_previous_d_ = glfwGetTime();
Gizmos::create();
celestial_body[0]->SetPosition( 0.f, 0.f, 0.f );
celestial_body[0]->SetScale( 1.5f, 1.5f, 1.5f );
celestial_body[0]->SetColor( 1.f, 1.f, 0.f, 1.f );
celestial_body[1]->SetPosition( 5.f, 0.f, 0.f );
celestial_body[1]->SetScale( 0.5f, 0.5f, 0.5f );
celestial_body[1]->SetColor( 0.0f, 0.25f, 0.5f, 1.f );
return ApplicationFail::NONE;
}
void BaseApplication::DumpGLInfo()
{
printf("--------------------------------------------------------------------------------");
//Version print.
GLint _majorVer = ogl_GetMajorVersion();
GLint _minorVer = ogl_GetMinorVersion();
APPINFO.m_viGLVersion = ivec2(_majorVer, _minorVer);
printf("-- Successfully loaded this version of OpenGL %d.%d \n", this->m_oApp->APPINFO.m_viGLVersion.x, this->m_oApp->APPINFO.m_viGLVersion.y);
printf("--------------------------------------------------------------------------------");
//card and version supported.
const GLubyte* _vendor = glGetString(GL_VENDOR); //Get vendor
const GLubyte* _renderer = glGetString(GL_RENDERER); // get renderer string
const GLubyte* _version = glGetString(GL_VERSION); // version as a string
const GLubyte* _glslVersion = glGetString(GL_SHADING_LANGUAGE_VERSION); //GLSL supported
printf("-- Vendor: %s\n", _vendor);
printf("-- Renderer: %s\n", _renderer);
printf("-- OpenGL Version: %s\n", _version);
printf("-- GLSL Version: %s\n", _glslVersion);
printf("--------------------------------------------------------------------------------");
}
void nsfw::Window::init(unsigned a_width, unsigned a_height)
{
//TODO_D("Should create and set an active windowing context. ONLY GLFW! No GL!");
// initialize
glfwInit();
width = a_width;
height = a_height;
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, true);
glfwWindowHint(GLFW_SAMPLES, 4);
window = glfwCreateWindow(width, height, "NSFWGL", NULL, NULL);
glfwMakeContextCurrent(window);
if (ogl_LoadFunctions() == ogl_LOAD_FAILED)
{
glfwDestroyWindow(window);
glfwTerminate();
}
// TODO: only do this on ogl4.3+
#ifdef _DEBUG
if (glDebugMessageCallback)
{
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(oglErrorDefaultCallback, nullptr);
GLuint unusedIDs = 0;
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, &unusedIDs, true);
}
else
{
std::cerr << "Failed to subscribe to glDebugMessageCallback." << std::endl;
}
#endif
auto major = ogl_GetMajorVersion();
auto minor = ogl_GetMinorVersion();
printf("GL: %i.%i\n", major, minor);
}
int main()
{
if (glfwInit() == false)
return -1;
GLFWwindow * window = glfwCreateWindow(1280, 720, "Computer Graphics", nullptr, nullptr);
if (window == nullptr)
{
glfwTerminate();
return -2;
}
glfwMakeContextCurrent(window);
if (ogl_LoadFunctions() == ogl_LOAD_FAILED)
{
glfwDestroyWindow(window);
glfwTerminate();
return -3;
}
auto major = ogl_GetMajorVersion();
auto minor = ogl_GetMinorVersion();
printf_s("GL: %i.%i\n", major, minor);
while (glfwWindowShouldClose(window) == false &&
glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS)
{
// our game logic and update code goes here!
// so does our render code!
glfwSwapBuffers(window);
glfwPollEvents();
}
// the rest of our code goes here!
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
void init_gl(const opt_data *opt_data, int width, int height)
{
if(!ogl_LoadFunctions()) {
fprintf(stderr, "ERROR: Failed to load GL extensions\n");
exit(EXIT_FAILURE);
}
CHECK_GL_ERR;
if(!(ogl_GetMajorVersion() > 1 || ogl_GetMinorVersion() >= 4)) {
fprintf(stderr, "ERROR: Your OpenGL Implementation is too old\n");
exit(EXIT_FAILURE);
}
opts = opt_data;
GLboolean force_fixed = opts->gl_opts != NULL && strstr(opts->gl_opts, "fixed") != NULL;
GLboolean res_boost = opts->gl_opts != NULL && strstr(opts->gl_opts, "rboost") != NULL;
packed_intesity_pixels = opts->gl_opts != NULL && strstr(opts->gl_opts, "pintens") != NULL;
scr_w = width; scr_h = height;
if(opts->fullscreen) im_w = scr_w, im_h=scr_h;
else im_w = IMAX(make_pow2(IMAX(scr_w, scr_h)), 128)<<res_boost; im_h = im_w;
while(!check_res(im_w, im_h)) { // shrink textures until they work
printf(" %ix%i Too big! Shrink texture\n", im_h, im_w);
im_w = im_w/2;
im_h = im_h/2;
}
printf("Using internel resolution of %ix%i\n\n", im_h, im_w);
CHECK_GL_ERR;
setup_viewport(scr_w, scr_h); CHECK_GL_ERR;
//glEnable(GL_LINE_SMOOTH); CHECK_GL_ERR;
glClear(GL_COLOR_BUFFER_BIT); CHECK_GL_ERR;
glRasterPos2f(-1,1 - 20.0f/(scr_h*0.5f));
//draw_string("Loading... "); swap_buffers(); CHECK_GL_ERR;
printf("GL_VENDOR: %s\n", glGetString(GL_VENDOR));
printf("GL_RENDERER: %s\n", glGetString(GL_RENDERER));
printf("GL_VERSION: %s\n", glGetString(GL_VERSION));
if(ogl_ext_ARB_shading_language_100) printf("GL_SL_VERSION: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION_ARB));
printf("GL_EXTENSIONS: %s\n", glGetString(GL_EXTENSIONS));
printf("\n\n");
/*
void DebugMessageControlARB(enum source,
enum type,
enum severity,
sizei count,
const uint* ids,
boolean enabled);
*/
if(ogl_ext_ARB_debug_output) {
glDebugMessageCallbackARB((GLDEBUGPROCARB)gl_debug_callback, NULL);
#if DEBUG
glDebugMessageControlARB(GL_DONT_CARE,
GL_DONT_CARE,
GL_DONT_CARE,
0, NULL,
GL_TRUE);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
#else
glDebugMessageControlARB(GL_DONT_CARE,
GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB,
GL_DONT_CARE,
0, NULL,
GL_TRUE);
glDebugMessageControlARB(GL_DONT_CARE,
GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB,
GL_DONT_CARE,
0, NULL,
GL_TRUE);
#endif
printf("Have ARB_debug_output: registered callback\n");
}
CHECK_GL_ERR;
// for ES we need:
// EXT_blend_minmax
// EXT_texture_format_BGRA8888
// optionally we should use
// EXT_texture_rg + OES_texture_float/OES_texture_half_float
// OES_mapbuffer
/* if(!ogl_ext_EXT_blend_minmax) { // can stop checking for this, it's in OpenGL 1.4*/
/* printf("missing required gl extension EXT_blend_minmax!\n");*/
/* exit(1);*/
/* }*/
if(!ogl_ext_EXT_framebuffer_object && !ogl_ext_ARB_framebuffer_object) {
printf("missing required gl extension EXT_framebuffer_object!\n");
exit(1);
}
// TODO: this should also pass if we have GL 2.0+
if(!ogl_ext_ARB_shading_language_100 && !(ogl_ext_ARB_fragment_shader && ogl_ext_ARB_vertex_shader && ogl_ext_ARB_shader_objects)) {
if(!ogl_ext_ARB_pixel_buffer_object)
printf("Missing GLSL and no pixel buffer objects, WILL be slow!\n");
else
printf("No GLSL using all fixed function! (might be slow)\n");
}
if(force_fixed) {
printf("Fixed function code forced\n");
packed_intesity_pixels = GL_FALSE;
}
CHECK_GL_ERR;
if(packed_intesity_pixels) printf("Packed intensity enabled\n");
glEnable(GL_TEXTURE_2D); CHECK_GL_ERR;
init_mandel(); CHECK_GL_ERR;
if(!force_fixed) glfract = fractal_glsl_init(opts, im_w, im_h, packed_intesity_pixels);
if(!glfract) glfract = fractal_fixed_init(opts, im_w, im_h);
CHECK_GL_ERR;
if(!force_fixed) glmaxsrc = maxsrc_new_glsl(IMAX(im_w>>res_boost, 256), IMAX(im_h>>res_boost, 256), packed_intesity_pixels);
if(!glmaxsrc) glmaxsrc = maxsrc_new_fixed(IMAX(im_w>>res_boost, 256), IMAX(im_h>>res_boost, 256));
CHECK_GL_ERR;
if(!force_fixed) glpal = pal_init_glsl(packed_intesity_pixels);
if(!glpal) glpal = pal_init_fixed(im_w, im_h);
CHECK_GL_ERR;
pd = new_point_data(opts->rational_julia?4:2);
memset(frametimes, 0, sizeof(frametimes));
totframetime = frametimes[0] = MAX(10000000/opts->draw_rate, 1);
memset(worktimes, 0, sizeof(worktimes));
totworktime = worktimes[0] = MIN(10000000/opts->draw_rate, 1);
tick0 = uget_ticks();
}
