Example #1
0
bool initGL(int width, int height, bool fullscreen)
{
	glfwInit();

	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
	glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

	int fs = fullscreen ? GLFW_FULLSCREEN : GLFW_WINDOW;

	if(!glfwOpenWindow(	width,
						height,
						8, 8, 8, 8,
						32, 8,
						fs))
	{
		printf("Could not create GLFW-window\n");
		return false;
	}

	glewExperimental = GL_TRUE;
	GLenum err = glewInit();
	if (GLEW_OK != err)
	{
		printf("Could not init GLEW\n");
		return false;
	}

	printf("Successfully created OpenGL-window, version %i.%i\n",
	        glfwGetWindowParam(GLFW_OPENGL_VERSION_MAJOR),
	        glfwGetWindowParam(GLFW_OPENGL_VERSION_MINOR));

	return true;
}
Example #2
0
/*
	GLFW test.
	Simple.
*/
TEST(GLFWTest, Simple)
{
	try
	{
		if (!glfwInit())
		{
			THROW_GL_EXCEPTION(GLException::RunTimeError, "glfwInit");
		}

		glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 4);
		glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
		glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
		glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
		glfwOpenWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);

		if (!glfwOpenWindow(1280, 720, 0, 0, 0, 0, 0, 0, GLFW_WINDOW))
		{
			glfwTerminate();
			THROW_GL_EXCEPTION(GLException::RunTimeError, "glfwOpenWindow");
		}

		GLUtil::InitializeGlew();
		GLUtil::EnableDebugOutput();

		glfwTerminate();
	}
	catch (const GLException& e)
	{
		FAIL() << GLTestUtil::PrintGLException(e);
	}
}
Example #3
0
	bool __stdcall OGLStartup()
	{
		// Attempt to start up GLFW
		f1("Attempting to start up GLFW");
		if(!glfwInit())
		{
			e("Could not start up GLFW!");
			SetVError(V_ERR_OGL_GLFWINIT);
			return false;
		}

		// Create window hints
		f1("Setting window hints");
		glfwOpenWindowHint(GLFW_FSAA_SAMPLES, V_OGL_ANTIALIAS);
		glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); // We want 4.0!
		glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
		glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

		// Create the window
		f1("Creating main window");
		if(!glfwOpenWindow(V_OGL_WINDOW_W, V_OGL_WINDOW_H, 0,0,0,0,0,0, V_OGL_WINMODE))
		{
			e("Could not create main window!");
			SetVError(V_ERR_OGL_WINDOW);
			glfwTerminate();
			return false;
		}

		// Attempt to start up Glew
		f1("Attempting to startup Glew");
		if(glewInit() != GLEW_OK)
		{
			// Error and return
			e("Could not instantiate Glew!");
			SetVError(V_ERR_OGL_GLEWINIT);
			return false;
		}

		// Set the window's title
		f1("Setting window title");
		glfwSetWindowTitle(V_WINDOW_TITLE);

		// Set key callback
		glfwSetKeyCallback( handle_key_down );
		glfwEnable(GLFW_KEY_REPEAT);

		// Set swap interval
		glfwSwapInterval(1);

		// Clear the screen / set BG color
		f1("Clearing background");
		glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

		// Lastly, setup basic sticky keys
		f1("Enabling sticky keys");
		glfwEnable(GLFW_STICKY_KEYS);
		
		// All is good
		return true;
	}
Example #4
0
// ----------------------------------------------
int main() {
  int width = 1024;
  int height = 768;

  glfwInit();

  // set window properties
  glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4); // anti aliasing
  glfwOpenWindowHint(GLFW_REFRESH_RATE, 0); // 0 = system default

  // open the window.
  if(!glfwOpenWindow(width, height, 8, 8, 8, 8,32,8, GLFW_WINDOW)) {
    glfwTerminate();
    exit(EXIT_FAILURE);
  }
  
  Simulation sim;
  sim.setup();
  
  bool running = true;
  while(running) {

    sim.update();
    sim.draw();

    glClear(GL_COLOR_BUFFER_BIT);
    glfwSwapBuffers();
    running = !(glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED));
  }
  
  glfwTerminate();
  return 0;
};
Example #5
0
int Init()
{
    if( !glfwInit() )
    {
        fprintf( stderr, "Failed to initialize GLFW\n" );
        return -1;
    }

    glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4); // 4x antialiasing
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); // I want OpenGL 3.1
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 1);

    // Open a window and create its OpenGL context
    if(glfwOpenWindow( 1024, 768, 0,0,0,0, 8,0, GLFW_WINDOW) != GL_TRUE )
    {
        fprintf( stderr, "Failed to open GLFW window\n" );
        glfwTerminate();
        return -1;
    }

    // Initialize GLEW
    if (glewInit() != GLEW_OK)
    {
        fprintf(stderr, "Failed to initialize GLEW\n");
        return -1;
    }

    glfwSetWindowTitle( "Triangle-Demo-1" );

    return 0;

}
int main(){
  //Change this line to use your name!
  yourName = "Karl Li";

  // Needed in OSX to force use of OpenGL3.2 
  glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
  glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
  glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
  glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

  init();
  initCuda();
  CUT_CHECK_ERROR_GL();
  initVAO();
  initTextures();

  GLuint passthroughProgram;
  passthroughProgram = initShader("shaders/passthroughVS.glsl", "shaders/passthroughFS.glsl");

  glUseProgram(passthroughProgram);
  glActiveTexture(GL_TEXTURE0);

  // send into GLFW main loop
  while(1){
    display();
    if (glfwGetKey(GLFW_KEY_ESC) == GLFW_PRESS || !glfwGetWindowParam( GLFW_OPENED )){
            exit(0);
    }
  }

  glfwTerminate();
  return 0;
}
Example #7
0
int initWindow(int width, int height, const std::string &title)
{
    // init GLFW
    if (!glfwInit()) {
        fprintf(stderr, "Failed to initialize FLGW\n");
        return -1;
    }

    glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4); // 4x antialising
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); // use OpenGL 3.3
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    if (!glfwOpenWindow(width, height, 0,0,0,0, 32,0, GLFW_WINDOW)) {
        fprintf(stderr, "Failed to open GLFW window\n");
        return -1;
    }

    // init GLEW
    glewExperimental = true; // needed in core profile
    if (glewInit() != GLEW_OK) {
        fprintf(stderr, "Failed to initialize GLEW\n");
        return -1;
    }

    glfwSetWindowTitle(title.c_str());

    return 0;
}
Example #8
0
void InitGraphics()
{
  // Initialise GLFW
  if( !glfwInit() )
  {
          fprintf( stderr, "Failed to initialize GLFW\n" );
          exit(-1);
  }

  glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
  glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
  glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
  glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

  // Open a window and create its OpenGL context
  if( !glfwOpenWindow( 1024, 768, 0,0,0,0, 32,0, GLFW_WINDOW ) )
  {
          fprintf( stderr, "Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.\n" );
          glfwTerminate();
          exit(-1);
  }

  // Initialize GLEW
  if (glewInit() != GLEW_OK) {
          fprintf(stderr, "Failed to initialize GLEW\n");
          exit(-1);
  }
  std::cout << "Initialized GL Components.\n";
}
Example #9
0
bool initWindow(int width, int height) {
    if (!glfwInit()) {
        std::cerr << "Couldn't init GLFW.\n";
        return false;
    }

    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 1);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 5);
    //glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    //glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
    if (!glfwOpenWindow(width, height, 8, 8, 8, 0, 0, 8, GLFW_WINDOW)) {
        std::cerr << "Couldn't open window.\n";
        return false;
    }

    if (ogl_LoadFunctions() != ogl_LOAD_SUCCEEDED) {
        std::cerr << "Couldn't init OpenGL functions.\n";
        return false;
    }

    if (ogl_IsVersionGEQ(1, 5)) {
        std::cerr << "OpenGL 1.5 not supported.\n";
        return false;
    }

    glfwSwapInterval(1);
    glViewport(0, 0, width, height);

    return true;
}
Example #10
0
int main(int argc, char** argv)
{
	glfwInit();
	glfwOpenWindowHint(GLFW_VERSION_MAJOR, 3);
	glfwOpenWindowHint(GLFW_VERSION_MINOR, 3);
	glfwOpenWindow(800, 600, 8,8,8,8, 24, 16, GLFW_WINDOW);

	glewInit();

	sigurd::Engine engine;

	sigurd::data::Mesh m;
	sigurd::data::mesh::loadFromFile(m, "data/sphere.obj");

	bool running = true;
	while(running)
	{
		glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

		engine.frameStep();
		glfwSwapBuffers();

		running = glfwGetWindowParam(GLFW_OPENED) && !glfwGetKey(GLFW_KEY_ESC);
	}

	return 0;
}
Example #11
0
int main(){
  int width, height;
  int frame = 0;
  bool running = true;

  glfwInit();
  glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
  glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
  glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
  glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);

  if(!glfwOpenWindow(512, 512, 0, 0, 0, 0, 0, 0, GLFW_WINDOW)){
    glfwTerminate();
    return 0;
  }

  glfwSetWindowTitle("GLFW APPLICATION");

  printf("RENDERER: %s\n", glGetString(GL_RENDER));
  printf("GL_VERSION: %s\n", glGetString(GL_VERSION));
  printf("GL_VERDOR: %s\n", glGetString(GL_VENDOR));
  printf("GL_SHADING_VERSION: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));

  int m, n;
  glGetIntegerv(GL_MAJOR_VERSION, &m);
  glGetIntegerv(GL_MINOR_VERSION, &n);
  printf("GL_Major: %d\n", m);
  printf("GL_Minor: %d\n", n);
  printf("GL_Extensions: %s", glGetString(GL_EXTENSIONS));

  glfwTerminate();
  return 0;

}
Example #12
0
///////////////////////////////////////////////////////////////////////////////
// Main entry point for GLFW based programs
int main( int argc , char * argv [])
{
    // initialise GLFW
    if(!glfwInit())
        throw std::runtime_error("glfwInit failed");
    
    // open a window with GLFW
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
    glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
    if(!glfwOpenWindow(800, 600, 0, 0, 0, 0, 0, 0, GLFW_WINDOW))
        throw std::runtime_error("glfwOpenWindow failed. Can your hardware handle OpenGL 3.2?");
    
    // initialise GLEW
    glewExperimental = GL_TRUE; //stops glew crashing on OSX :-/
    if (GLEW_OK != glewInit())
        throw std::runtime_error("glewInit failed");
    
    // make sure OpenGL version 3.2 API is available
    if(!GLEW_VERSION_3_2)
        throw std::runtime_error("OpenGL 3.2 API is not available.");
    
    glfwSetWindowSizeCallback(ChangeSize);
    
    SetupRC();
    
    while(glfwGetWindowParam(GLFW_OPENED) && !glfwGetKey( GLFW_KEY_ESC ))
    {
        RenderScene();
        glfwSwapBuffers();
    }
    
    glfwTerminate();
}
Example #13
0
void Window::ForceOpenGlVersion(int major, int minor)
{
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, major);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, minor);

    LeLog.WriteP("Window: Forced OpenGl version: (%i, %i)", major, minor);
}
Example #14
0
void AppMain() {
    if(!glfwInit())
        throw std::runtime_error("glfwInit failed");
    
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
    glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_FALSE);
    
    if(!glfwOpenWindow(SCREEN_SIZE.x, SCREEN_SIZE.y, 8, 8, 8, 8, 0, 0, GLFW_WINDOW))
        throw std::runtime_error("glfwOpenWindow failed. Can your hardware handle OpenGL 3.2?");
    
    glewExperimental = GL_TRUE; //stops glew crashing on OSX :-/
    if(glewInit() != GLEW_OK)
        throw std::runtime_error("glewInit failed");
    
    
    std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
    std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
    std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
    std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
    
    if(!GLEW_VERSION_3_2)
        throw std::runtime_error("OpenGL 3.2 API is not available.");
    
    glfwDisable(GLFW_MOUSE_CURSOR);
    glfwSetMousePos(0,0);
    glfwSetMouseWheel(0);
    
    LoadShaders();
    LoadTriangle();
    
    //intialise the Camera position
    gCamera.setPosition(glm::vec3(0,0,4));
    gCamera.setViewportAspectRatio(SCREEN_SIZE.x / SCREEN_SIZE.y);
    gCamera.setNearAndFarPlanes(0.5, 100.0f);
    Axis = glm::vec3(0,1,0);
    
    //intialise the Light attribute
    gLight.position = glm::vec3(0.0f,0.1f,-0.1f);
    gLight.intensities = glm::vec3(0.8,0.78,1); // white light
    gLight.attenuation = 0.2f;
    gLight.ambientCoefficient = 0.005f;
    
    double lastTime = glfwGetTime();
    while(glfwGetWindowParam(GLFW_OPENED)){
        
        double thisTime = glfwGetTime();
        Update(thisTime - lastTime);
        lastTime  = thisTime;
        Render();
        
    }
    
    glfwTerminate();
}
Example #15
0
bool Game::init()
{
    if (glfwInit() != GL_TRUE)
        return false;

    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    this->window = glfwOpenWindow(this->width, this->height, 8, 8, 8, 0, 24, 0, GLFW_WINDOW);
    if (!this->window)
        return false;

    glfwSetWindowTitle("Battlecraft Editor");
    glfwSwapInterval(1);

    // OpenGL Settings
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_LINE_SMOOTH);
    glEnable(GL_BLEND);
    glClearColor(0.1f, 0.1f, 0.1f, 1.0f);

    srand(11247);

    this->camera = new Camera(width, height, 90);

    shader = new VoxelShader();
    shader->compile();

    tileset = new Tileset(256);
    tileset->set(1, 250,20,20);
    tileset->set(2, 20,250,20);
    tileset->set(3, 20,20,250);
    tileset->set(4, 255,0,255);

    chunk = new Chunk(tileset, 16,16,16);

    chunk->compute();

    glErrorCheck("pre linesh compilation")

    linesh = new LineShader();
    if (!linesh->compile()) return false;

    bounds = new Boundbox(16,16,16);

    printf("A: %d, a: %d\n", 'A','a');

    return true;
}
Example #16
0
/////////////////////////////////////////////////////////
// createMess
//
/////////////////////////////////////////////////////////
bool gemglfw2window :: create(void)
{
  int mode = GLFW_WINDOW;
  if(0!=s_window) {
    error("window already made!");
    return false;
  }

  if(m_fullscreen)
    mode=GLFW_FULLSCREEN;

  glfwOpenWindowHint(GLFW_FSAA_SAMPLES, m_fsaa);


  if(m_profile_major) {
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, m_profile_major); // We want OpenGL 3.3
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, m_profile_minor);
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //We don't want the old OpenGL
  }

  if (!glfwOpenWindow(m_width, m_height,
                      8, 8, 8, 8,  /* RGBA bits */
                      24, 8,       /* depth/stencil bits */
                      mode)) {
    error("glfw couldn't create window");
    return false;
  }



  // FIXXME: single/double buffering

  if(!createGemWindow()) {
    destroyMess();
    return false;
  }
  s_window=this;

  titleMess(m_title);
  offsetMess(m_xoffset, m_yoffset);
  cursorMess(m_cursor);

  glfwSetWindowSizeCallback   (windowsizeCb);
  glfwSetWindowCloseCallback  (windowcloseCb);
  glfwSetWindowRefreshCallback(windowrefreshCb);
  glfwSetKeyCallback          (keyCb);
  glfwSetCharCallback         (charCb);
  glfwSetMouseButtonCallback  (mousebuttonCb);
  glfwSetMousePosCallback     (mouseposCb);
  glfwSetMouseWheelCallback   (mousewheelCb);
  dispatch();
  return (0!=s_window);
}
Example #17
0
WindowImplGLFW::WindowImplGLFW(int width, int height)
{    
    glfwInit();
    
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
	glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, 1);
    glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
	glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    
	glfwOpenWindow(width, height, 8, 8, 8, 8, 24, 0, GLFW_WINDOW);
}
Example #18
0
int main( void ) {
	if(!glfwInit()) {
		exit( EXIT_FAILURE );
	}
	
	glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 16);
	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
	glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	if(!glfwOpenWindow(SCREEN_WIDTH, SCREEN_HEIGHT, 8,8,8,8,24,8, GLFW_WINDOW)) {
		glfwTerminate();
		exit(EXIT_FAILURE);
	}
	printf("*** OpenGL %s | GLSL %s ***\n", glGetString(GL_VERSION), glGetString(GL_SHADING_LANGUAGE_VERSION));
	
	glewExperimental = GL_TRUE;
	glewInit();
	glGetError();
	
	glfwSwapInterval(1);
	glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
	glfwSetTime(0.0);
	
	glDisable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glEnable(GL_CULL_FACE);
	glCullFace(GL_BACK);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	
	Setup();
	
	int frames = 0;
	float elapsedTime = 0;
	do{
		float time = (float) glfwGetTime();
		Render(time);
		glfwSwapBuffers();
		
		/* FPS Counter */
		if((glfwGetTime()-elapsedTime) > 4.0){
			int fps = (float) ceil(frames / (glfwGetTime()-elapsedTime));
			printf("*** FPS: %d ***\n", fps);
			frames = 0;
			elapsedTime = time;
		}
		frames++;
		
	} while(!(glfwGetKey(GLFW_KEY_ESC) || glfwGetKey(81)) && glfwGetWindowParam(GLFW_OPENED));
	
	glfwTerminate();
	exit( EXIT_SUCCESS );
}
Example #19
0
/*
	GLFW test.
	Simple 2.
*/
TEST(GLFWTest, Simple2)
{
	try
	{
		if (!glfwInit())
		{
			THROW_GL_EXCEPTION(GLException::RunTimeError, "glfwInit");
		}

		glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 4);
		glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
		glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
		glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
		glfwOpenWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);

		if (!glfwOpenWindow(1280, 720, 0, 0, 0, 0, 0, 0, GLFW_WINDOW))
		{
			glfwTerminate();
			THROW_GL_EXCEPTION(GLException::RunTimeError, "glfwOpenWindow");
		}

		glfwSetWindowTitle("GLFWTest_Simple2");

		GLUtil::InitializeGlew();
		GLUtil::EnableDebugOutput();

		int running = 1;
		double start = GLTestUtil::CurrentTimeMilli();

		while (running)
		{
			double elapsed = GLTestUtil::CurrentTimeMilli() - start;
			if (elapsed >= 500.0)
			{
				break;
			}

			glClearColor((float)elapsed / 1000.0f, 1.0f, 0.0f, 1.0f);
			glClear(GL_COLOR_BUFFER_BIT);
			glfwSwapBuffers();

			running = glfwGetWindowParam(GLFW_OPENED);
		}

		glfwTerminate();
	}
	catch (const GLException& e)
	{
		FAIL() << GLTestUtil::PrintGLException(e);
	}
}
Example #20
0
        void init( float normsize, bool fullscreen )
        {
            static struct on {
                 on() { glfwInit();      }
                ~on() { glfwTerminate(); }
            } _;

            auto rect = get_screen_rect();
            screen_w = rect.first;
            screen_h = rect.second;

            {
                // reinit :P

                normsize = ( normsize <= 0 ? 1 : normsize );

                w = screen_w * normsize;
                h = screen_h * normsize;
            }

#if 0
            //wglSwapIntervalEXT(1);
            glfwOpenWindowHint( GLFW_ACCUM_RED_BITS, 16 );
            glfwOpenWindowHint( GLFW_ACCUM_GREEN_BITS, 16 );
            glfwOpenWindowHint( GLFW_ACCUM_BLUE_BITS, 16 );
            glfwOpenWindowHint( GLFW_ACCUM_ALPHA_BITS, 16 );
            if( glfwOpenWindow( w, h, 0,0,0,0,0,0, fullscreen ? GLFW_FULLSCREEN : GLFW_WINDOW ) != GL_TRUE )
            {
                std::cerr << "<gate/gate.hpp> says: Cant create " << w << 'x' << h << " window!" << std::endl;
                exit(1);
            }
#endif

            window = glfwCreateWindow(w, h, title.c_str(), NULL, NULL);
            if (!window)
            {
                glfwTerminate();
                std::cerr << "<gate/gate.hpp> says: Cant create " << w << 'x' << h << " window!" << std::endl;
                exit(1);
            }

            glfwMakeContextCurrent(window);

			glfwSetWindowTitle( window, title.c_str() );

            resize( w, h );

            init_glew();

            glInit();
        }
Example #21
0
// the program starts here
void AppMain() {
    // initialise GLFW
    if(!glfwInit())
        throw std::runtime_error("glfwInit failed");
    
    // open a window with GLFW
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
    glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
    if(!glfwOpenWindow((int)SCREEN_SIZE.x, (int)SCREEN_SIZE.y, 8, 8, 8, 8, 0, 0, GLFW_WINDOW))
        throw std::runtime_error("glfwOpenWindow failed. Can your hardware handle OpenGL 3.2?");
    
    // initialise GLEW
    glewExperimental = GL_TRUE; //stops glew crashing on OSX :-/
    if(glewInit() != GLEW_OK)
        throw std::runtime_error("glewInit failed");

    // print out some info about the graphics drivers
    std::cout << "OpenGL version: " << glGetString(GL_VERSION) << std::endl;
    std::cout << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
    std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
    std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;

    // make sure OpenGL version 3.2 API is available
    if(!GLEW_VERSION_3_2)
        throw std::runtime_error("OpenGL 3.2 API is not available.");

    // OpenGL settings
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    // load vertex and fragment shaders into opengl
    LoadShaders();

    // load the texture
    LoadTexture();

    // create buffer and fill it with the points of the triangle
    LoadTriangle();

    // run while the window is open
    while(glfwGetWindowParam(GLFW_OPENED)){
        // draw one frame
        Render();
    }

    // clean up and exit
    glfwTerminate();
}
Example #22
0
GLFWApp::GLFWApp()
{
	if (!glfwInit())
		exit(EXIT_FAILURE);
	wndWidth  = 800; midWidth  = wndWidth/2;
	wndHeight = 600; midHeight = wndHeight/2;
	int redBits   = 8, greenBits = 8,  blueBits    = 8;
	int alphaBits = 8, depthBits = 24, stencilBits = 8;

	glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
	glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	if (!glfwOpenWindow(wndWidth,wndHeight,redBits,greenBits,blueBits,alphaBits,depthBits,stencilBits,GLFW_WINDOW))
	{
		glfwTerminate();
		exit(EXIT_FAILURE);
	}
	GLenum err = glewInit();
	if (GLEW_OK != err)
	{
		exit(EXIT_FAILURE);
	}
	fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));

	if (GLEW_VERSION_2_1)
	{
		fprintf(stdout, "OpenGL 2.1 is supported\n");
	}
	if (GLEW_VERSION_3_3)
	{
		fprintf(stdout, "OpenGL 3.3 is supported\n");
	}
	if (GLEW_VERSION_4_0||GLEW_VERSION_4_1)
	{
		fprintf(stdout, "OpenGL 4.0 is supported\n");
	}

	glViewport(0, 0, wndWidth, wndHeight);

	glfwSetWindowTitle("RRC framework");
	framesPerSec  = 0;
	frameCnt      = 0;
	startTime     = glfwGetTime();
	deltaTime     = 0.001f;
	buffTime      = 0.0f;
	isPinMouse    = true;
	isRunning     = true;
}
Example #23
0
bool setupGL()
{
	glfwInit();

	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
	glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

	glfwOpenWindowHint( GLFW_WINDOW_NO_RESIZE, GL_TRUE );

	if(!glfwOpenWindow(	WIDTH,
						HEIGHT,
						8, 8, 8, 8,
						32, 0,
						GLFW_WINDOW))
	{
		logError("could not create GLFW-window");
		return false;
	}

	logErrorsGL();

	glewExperimental = GL_TRUE;
	if (GLEW_OK != glewInit())
	{
		logError("GLEW init error");
		return false;
	}

	logErrorsGL();

	logNote("Successfully created OpenGL-window, version %i.%i",
         glfwGetWindowParam(GLFW_OPENGL_VERSION_MAJOR),
         glfwGetWindowParam(GLFW_OPENGL_VERSION_MINOR));

	logNote("GLSL-version: %s",glGetString(GL_SHADING_LANGUAGE_VERSION));

	glEnable(GL_DEPTH_TEST);
	glEnable(GL_CULL_FACE);
  glCullFace(GL_BACK);
	glfwSwapInterval(0);
  glActiveTexture(GL_TEXTURE0);
  glClearColor(1.0, 1.0, 1.0, 0.0);
  glfwDisable(GLFW_MOUSE_CURSOR);

	glfwSetKeyCallback(keyCallback);

	return true;
}
GLFWWindow::GLFWWindow(OpenGLVersion desiredMinimumVersion, GLFWOpenGLProfile oglProfile): 
	_isInitialized(false), _windowWidth(0), _windowHeight(0)
{
	if(glfwInit())
	{
		_isInitialized = true;

		//Specify that we want to support the desired minimum
		glfwOpenWindowHint( GLFW_OPENGL_VERSION_MAJOR, desiredMinimumVersion.GetMajorVersion());
		glfwOpenWindowHint( GLFW_OPENGL_VERSION_MINOR, desiredMinimumVersion.GetMinorVersion());

		//Opengl profile
		glfwOpenWindowHint( GLFW_OPENGL_PROFILE, oglProfile.GetProfile());
	}
}
Example #25
0
int main(int argc, char** argv) {
  int running = GL_TRUE;
  
  if (!glfwInit()) {
    fprintf(stderr, "failed to initialize GLFW\n");
    exit(EXIT_FAILURE);
  }

  glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
  glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 4);
  glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);

  if (!glfwOpenWindow(WIN_WIDTH, WIN_HEIGHT, 0,0,0,0,0,0, GLFW_WINDOW)) {
    fprintf(stderr, "Failed to open GLFW window\n");
    glfwTerminate();
    exit(EXIT_FAILURE);
  }
  
  glewExperimental = true;
  if (glewInit() != GLEW_OK) {    
    return -1;
  }
  
  glfwSetWindowTitle("Hello, OpenGL");

  if (argc != 2) {
    printf("Usage: shaderquad <fragment shader>\n");
    exit(0);
  }

  setup(argv[1]);
  if (p == 0) running = GL_FALSE;

  while (running) {    
    t += 0.01f;
    render();
    
    glfwSwapBuffers();    
    running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);
    if (glfwGetKey(76)) {
        setup(argv[1]);
    }
    glfwSleep(.1);
  }
  
  glfwTerminate();
  exit(EXIT_SUCCESS);
}
Example #26
0
void initGL(int w, int h)
{
  if(glfwInit() == GL_FALSE) {
    std::cerr << "ERROR: Failed to initialize GLFW." << std::endl;
    exit(1);
  }

  glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, CTX_VERSION_MAJOR);
  glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, CTX_VERSION_MINOR);

  if(CTX_VERSION_MAJOR >= 3) {
    glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  }

  if(glfwOpenWindow(WIDTH, HEIGHT, 0, 0, 0, 0, 8, 0, GLFW_WINDOW) == GL_FALSE) {
    std::cerr << "ERROR: Failed to open a GLFW window." << std::endl;
    exit(1);
  }

  glfwSetWindowTitle("Splines demo");
 
  /*if(CTX_VERSION_MAJOR >= 3) {
    if(gl3wInit()) {
      std::cerr << "ERROR: " << gl3wGetError() << std::endl;
      exit(1);
    }
    if(!gl3wIsSupported(CTX_VERSION_MAJOR, CTX_VERSION_MINOR)) {
      std::cerr << "ERROR: OpenGL " << CTX_VERSION_MAJOR << "." << CTX_VERSION_MINOR << " is not supported." << std::endl;
      exit(1);
    }
    }*/

  std::cout << "INFO: OpenGL version: " << glGetString(GL_VERSION) << std::endl;
  std::cout << "INFO: OpenGL context renderer:" << glGetString(GL_RENDERER) << std::endl;
  std::cout << "INFO: OpenGL context vendor: " << glGetString(GL_VENDOR) << std::endl;
  if(CTX_VERSION_MAJOR >= 2)
    std::cout << "INFO: OpenGL shading language version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;

  glClearColor(1.0, 1.0, 1.0, 1.0);
  glViewport(0, 0, WIDTH, HEIGHT);

  glPointSize(4.0);

  glfwSetKeyCallback(cbKeyDown);
  glfwSetWindowSizeCallback(cbReshape);
  runlevel = 1;
}
Example #27
0
///////////////////////////////////////////////////////////////////////////////
// Main entry point for GLUT based programs
int main(int argc, char* argv[])
{
    int running = GL_TRUE;
    // Initialize GLFW
    if( !glfwInit() )
    {
        exit( EXIT_FAILURE );
    }

    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
    glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);

    // Open an OpenGL window
    if( !glfwOpenWindow( 800,600, 0,0,0,0,0,0, GLFW_WINDOW ) )
    {
        glfwTerminate();
        exit( EXIT_FAILURE );
    }

    glewExperimental = GL_TRUE; //stops glew crashing on OSX :-/
    GLenum err = glewInit();
    if ( GLEW_OK != err) {
        fprintf(stderr , "GLEW Error: %s\n" , glewGetErrorString (err));
        exit( EXIT_FAILURE );
    }

    SetupRC();

    glfwSetWindowSizeCallback(ChangeSize);

    // Main loop
    while( running )
    {
        //// OpenGL rendering goes here...
        RenderScene();
        glfwSwapBuffers();

        // Check if ESC key was pressed or window was closed
        running = !glfwGetKey( GLFW_KEY_ESC ) &&
            glfwGetWindowParam( GLFW_OPENED );
    }
    // Close window and terminate GLFW
    glfwTerminate();
    // Exit program
    exit( EXIT_SUCCESS );
}
int main(int argc, char** argv)
{
	if(!glfwInit())
		return -1;

	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
	glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#ifdef DEBUG
	glfwOpenWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
#endif

	if(!glfwOpenWindow(500, 500, 8, 8, 8, 8, 24, 8, GLFW_WINDOW))
	{
		glfwTerminate();
		return -1;
	}

	if(glload::LoadFunctions() == glload::LS_LOAD_FAILED)
	{
		glfwTerminate();
		return -1;
	}

	glfwSetWindowTitle("GLFW Demo");

	if(glext_ARB_debug_output)
	{
		glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
		glDebugMessageCallbackARB(DebugFunc, (void*)15);
	}

	init();

	glfwSetWindowSizeCallback(reshape);

	//Main loop
	while(true)
	{
		display();

		if(glfwGetKey(GLFW_KEY_ESC) || !glfwGetWindowParam(GLFW_OPENED))
			break;
	}

	glfwTerminate();
	return 0;
}
Example #29
0
    void GLManager::initGlWindow(){ 
      cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );

      if( !glfwInit() )
	{
	  std::cerr << "Failed to initalize GLFW" << std::endl;
	  exit( 1 );
	}

      glfwOpenWindowHint( GLFW_WINDOW_NO_RESIZE, GL_TRUE );

      if ( !glfwOpenWindow( width, height, 
			    8, 8, 8, 8, 8, 8,
			    GLFW_WINDOW ) )
	{
	  std::cerr << "Failed to open window" << std::endl;
	  exit( 1 );
	}

      glewInit();
      if (! glewIsSupported("GL_VERSION_2_0 ")) 
	{
	  std::cerr << "ERROR: Support for necessary OpenGL extensions missing." << std::endl;
	  exit( 1 );
	}
    


      glViewport(0, 0, height, width);
      glLoadIdentity();
      glOrtho(0.0, 1.0, 0.0, 1.0, 0.0, 1.0);

    };
Example #30
0
	Init() {
		if(!glfwInit()) {
			std::cerr << "\nCould not initialize glfw!";
			return;
		}

		glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, true);

		if(!glfwOpenWindow(screenSizeX, screenSizeY, 8, 8, 8, 8, 8, 8, GLFW_WINDOW)) {
			std::cerr << "\nCould not open the window!";
			glfwTerminate();
			return;
		}

		glfwSetWindowTitle("Colorful Game of Life");
		glfwSetWindowPos(350, 150);
		glfwSwapInterval(0);
		glfwSetTime(0);

		if(gl3wInit() != 0) {
			std::cerr << "\nCould not initialize gl3w!";
			glfwTerminate();
			return;
		}
	}