static void
CleanUp(void)
{
glDeleteFramebuffersEXT(1, &MyFB);
glDeleteRenderbuffersEXT(1, &MyRB);
assert(!glIsFramebufferEXT(MyFB));
assert(!glIsRenderbufferEXT(MyRB));
glutDestroyWindow(Win);
exit(0);
}
int GlutApp::keyPressed(unsigned char key)
{
// for escape key ...
if (key == 27) {
die = 1;
glutDestroyWindow(window);
}else{
std::cout << "key pressed: " << key << std::endl;
}
}
int main(int argc, char** argv)
{
int ret = 1;
int effect;
GLenum res;
int window;
if (argc != 3) {
printf("Usage: %s <effect file> <program name>\n", argv[0]);
goto error_exit;
}
glutInit(&argc, argv);
window = glutCreateWindow("foo");
res = glewInit();
if (res != GLEW_OK) {
printf("Error initializing glew: %s\n", glewGetErrorString(res));
goto glew_error;
}
effect = glfxGenEffect();
char log[10000];
if (!glfxParseEffectFromFile(effect, argv[1])) {
printf("Error creating effect:\n");
glfxGetEffectLog(effect, log, sizeof(log));
printf("%s\n", log);
goto parse_error;
}
if (glfxCompileProgram(effect, argv[2]) < 0) {
printf("Error compiling program '%s':\n", argv[2]);
glfxGetEffectLog(effect, log, sizeof(log));
printf("%s\n", log);
goto compile_error;
}
printf("Compiled successfully\n");
ret = 0;
compile_error:
parse_error:
glfxDeleteEffect(effect);
glew_error:
glutDestroyWindow(window);
error_exit:
return ret;
}
// Keyboard callback function for OpenGL (GLUT)
void keyboard(unsigned char key, int /*x*/, int /*y*/)
{
switch (key)
{
case 27:
#if defined (__APPLE__) || defined(MACOSX)
exit(EXIT_SUCCESS);
#else
glutDestroyWindow(glutGetWindow());
return;
#endif
break;
case 'a':
case 'A':
g_bInteractive = !g_bInteractive;
printf("> Animation is %s\n", !g_bInteractive ? "ON" : "OFF");
break;
case '=':
case '+':
if (filter_radius < (int)width-1 &&
filter_radius < (int)height-1)
{
filter_radius++;
}
break;
case '-':
if (filter_radius > 1)
{
filter_radius--;
}
break;
case ']':
iterations++;
break;
case '[':
if (iterations>1)
{
iterations--;
}
break;
default:
break;
}
printf("radius = %d, iterations = %d\n", filter_radius, iterations);
}
void figure_t_t::keyboard(unsigned char key, int x, int y) {
switch(key) {
case 'q':
glutDestroyWindow(window_number);
break;
case 'p':
print();
break;
}
if(keyboard_callback) keyboard_callback(key, x, y);
}
void Cleanup( int errorCode, bool bExit )
{
if (g_iGLUTWindowHandle != 0)
{
glutDestroyWindow(g_iGLUTWindowHandle);
g_iGLUTWindowHandle = 0;
}
if (bExit)
std::exit(errorCode);
}
void GLUTStop(void)
{
// Destroy window
glutDestroyWindow(GLUTwindow);
// Delete scene
delete scene;
// Exit
exit(0);
}
static void
CleanUp(void)
{
glDeleteShader(FragShader);
glDeleteShader(VertShader);
glDeleteShader(GeomShader);
glDeleteProgram(Program);
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(1, &vbo);
glutDestroyWindow(Win);
}
static void keyPressed(unsigned char key, int x, int y)
{
if(key==ESCAPE)
{
on_exit_program();
glutDestroyWindow(window);
exit(0);
}
}
void kbd(unsigned char key, int x, int y)
{
switch((char)key) {
case 'q':
case 27:
glutDestroyWindow(wd);
exit(0);
default:
break;
}
}
void exitScene()
{
std::cout << "Exiting scene..." << std::endl;
// Close window
glutDestroyWindow(windowId);
// Free any allocated memory
// Exit program
exit(0);
}
static void Key(unsigned char key, int x, int y)
{
switch (key) {
case 27:
glutDestroyWindow(win);
exit(0);
default:
glutPostRedisplay();
return;
}
}
/************************************************************
This section handles the menu selection
**************************************************************/
void menu(int value)
{
if(value == 0)
{
glutDestroyWindow(win);
exit(0);
}else{
primitive=value;
}
glutPostRedisplay(); // you would want to redraw now
}
void ScreenSaver::exitter() {
for(int i = 0; i<NUM_BALLS; i++) {
pthread_mutex_lock(&vecMutexThreadTerminate[i]);
threadTerminate[i] = true;
pthread_mutex_unlock(&vecMutexThreadTerminate[i]);
}
glUserInterface->close();
glutDestroyWindow(windowID);
killSkybox();
}
static void
CleanUp(void)
{
glDeleteFramebuffersEXT(1, &MyFB);
glDeleteTextures(1, &TexObj);
glutDestroyWindow(Win);
exit(0);
}
void
menu2(int value)
{
printf("menu item selected: %d\n", value);
if (value != 46) {
printf("FAIL: time6 expected 45\n");
exit(1);
}
glutDestroyMenu(glutGetMenu());
glutDestroyWindow(glutGetWindow());
glutTimerFunc(1000, time7, 7);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
int width = 500;
int height = 500;
unsigned int displayMode = GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH | GLUT_STENCIL;
displayMode = defaults(displayMode, width, height);
glutInitDisplayMode (displayMode);
glutInitContextVersion (3, 3);
glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);
glutInitContextProfile(GLUT_CORE_PROFILE);
#ifdef DEBUG
glutInitContextFlags(GLUT_DEBUG);
#endif
glutInitWindowSize (width, height);
glutInitWindowPosition (300, 200);
int window = glutCreateWindow (argv[0]);
glload::LoadFunctions();
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
if(!glload::IsVersionGEQ(3, 3))
{
printf("Your OpenGL version is %i, %i. You must have at least OpenGL 3.3 to run this tutorial.\n",
glload::GetMajorVersion(), glload::GetMinorVersion());
glutDestroyWindow(window);
return 0;
}
if(glext_ARB_debug_output)
{
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
glDebugMessageCallbackARB(DebugFunc, (void*)15);
}
init();
UserListener listener;
Leap::Controller controller;
controller.addListener(listener);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
controller.removeListener(listener);
return 0;
}
void keyboard(unsigned char key, int /*x*/, int /*y*/)
{
char temp[256];
switch (key)
{
case 27:
case 'q':
case 'Q':
printf("Shutting down...\n");
#if defined (__APPLE__) || defined(MACOSX)
exit(EXIT_SUCCESS);
#else
glutDestroyWindow(glutGetWindow());
return;
#endif
break;
case '-':
imageScale -= 0.1f;
printf("brightness = %4.2f\n", imageScale);
break;
case '=':
imageScale += 0.1f;
printf("brightness = %4.2f\n", imageScale);
break;
case 'i':
case 'I':
g_SobelDisplayMode = SOBELDISPLAY_IMAGE;
sprintf(temp, "CUDA Edge Detection (%s)", filterMode[g_SobelDisplayMode]);
glutSetWindowTitle(temp);
break;
case 's':
case 'S':
g_SobelDisplayMode = SOBELDISPLAY_SOBELSHARED;
sprintf(temp, "CUDA Edge Detection (%s)", filterMode[g_SobelDisplayMode]);
glutSetWindowTitle(temp);
break;
case 't':
case 'T':
g_SobelDisplayMode = SOBELDISPLAY_SOBELTEX;
sprintf(temp, "CUDA Edge Detection (%s)", filterMode[g_SobelDisplayMode]);
glutSetWindowTitle(temp);
break;
default:
break;
}
}
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case VK_ESCAPE:
glutDestroyWindow(winID);
exit(0);
break;
default:
current_assignment.handleInput(key);
}
}
/* Fonction de gestion du clavier */
void keyPressed(unsigned char key, int x, int y)
{
if (key == ESCAPE)
{
/* Eteindre la fenêtre */
glutDestroyWindow(window);
/* Sortire du programme */
exit(0);
}
}
/* The function called whenever a normal key is pressed. */
void keyPressed(unsigned char key, int x, int y)
{
switch (key) {
case 27: // kill everything.
/* shut down our window */
glutDestroyWindow(window);
/* exit the program...normal termination. */
exit(1);
break; // redundant.
case 'a':
drawAxis = !drawAxis;
break;
case 's':
drawSine = !drawSine;
break;
case 'h':
case 'H':
drawHead = !drawHead;
break;
case 'd':
case 'D':
drawBackground = !drawBackground;
break;
case 'b':
case 'B':
blending = !blending;
break;
case 'n':
case 'N':
drawNormals = !drawNormals;
break;
case 'i':
case 'I':
initialGuess = !initialGuess;
break;
case 76:
case 108: // switch the lighting
drawLight = !drawLight;
if (!drawLight) {
glDisable(GL_LIGHTING);
} else {
glEnable(GL_LIGHTING);
}
break;
default:
break;
}
}
CUTBoolean initGL(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutInitWindowSize(10, 10);
int bla = glutCreateWindow("Cuda GL Interop (VBO)");
glutDisplayFunc(dumm_display);
// initialize necessary OpenGL extensions
glewInit();
if (! glewIsSupported("GL_VERSION_2_0 ")) {
fprintf(stderr, "ERROR: Support for necessary OpenGL extensions missing.");
fflush(stderr);
return CUTFalse;
}
// default initialization
glClearColor(0.0, 0.0, 0.0, 1.0);
glDisable(GL_DEPTH_TEST);
// viewport
glViewport(0, 0, 10, 10);
// projection
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)10 / (GLfloat) 10, 0.1, 10.0);
CUT_CHECK_ERROR_GL();
// start gui for the main application
//cudaError_t error = cudaGLSetGLDevice(0);
//cutilGLDeviceInit(argc, argv);
int deviceCount;
cutilSafeCallNoSync(cudaGetDeviceCount(&deviceCount));
if (deviceCount == 0) {
fprintf(stderr, "CUTIL CUDA error: no devices supporting CUDA.\n");
exit(-1);
}
int dev = 0;
cudaDeviceProp deviceProp;
cutilSafeCallNoSync(cudaGetDeviceProperties(&deviceProp, dev));
if (deviceProp.major < 1) {
fprintf(stderr, "cutil error: device does not support CUDA.\n");
exit(-1);
}
printf("gpu=%s\n", deviceProp.name);
cutilSafeCall(cudaGLSetGLDevice(dev));
glutDestroyWindow(bla);
return CUTTrue;
}
static void
key(unsigned char key, int x, int y)
{
switch (key) {
case 27:
glutDestroyWindow(win);
exit(0);
break;
case 'a':
v += 0.0005;
break;
case 'z':
v -= 0.0005;
break;
case 'j':
joyactive = (!joyactive);
break;
case 'h':
help = (!help);
break;
case 'f':
fog = (!fog);
break;
case 's':
shadows = !shadows;
break;
case 'R':
eject_r -= 0.03;
break;
case 'r':
eject_r += 0.03;
break;
case 't':
ridtri += 0.005;
break;
case 'T':
ridtri -= 0.005;
break;
#ifdef XMESA
case ' ':
XMesaSetFXmode(fullscreen ? XMESA_FX_FULLSCREEN : XMESA_FX_WINDOW);
fullscreen = (!fullscreen);
break;
#endif
case 'n':
NiceFog = !NiceFog;
printf("NiceFog %d\n", NiceFog);
break;
}
glutPostRedisplay();
}
void idle()
{
scale *= 0.75;
if (scale < 1e-14) {
glFinish();
glutDestroyWindow(gwin);
return;
}
set_texture();
}
void kbd(unsigned char key, int x, int y)
{
// escape
if (key == 27) {
glutDestroyWindow(wd);
exit(0);
}
glutPostRedisplay();
return;
}
static void
Key(unsigned char key, int x, int y)
{
const GLfloat step = 3.0;
(void) x;
(void) y;
switch (key) {
case 'a':
case ' ':
Anim = !Anim;
if (Anim)
glutIdleFunc(Idle);
else
glutIdleFunc(NULL);
break;
case 'b':
Blend = !Blend;
break;
case 's':
Scale /= 1.1;
break;
case 'S':
Scale *= 1.1;
break;
case 'f':
Filter = (Filter + 1) % NUM_FILTERS;
SetTexParams();
break;
case 'r':
Randomize();
break;
#if TEST_CLAMP
case 'c':
Clamp = !Clamp;
SetTexParams();
break;
#endif
case 'z':
Zrot -= step;
break;
case 'Z':
Zrot += step;
break;
case 27:
glutDestroyWindow(Win);
exit(0);
break;
}
PrintState();
glutPostRedisplay();
}
static void Key( unsigned char key, int x, int y )
{
(void) x;
(void) y;
switch (key) {
case 27:
glutDestroyWindow(Window);
exit(0);
break;
}
glutPostRedisplay();
}
/*-----------------------------------------------------------------------------------------------
Description:
Program start and end.
Parameters:
argc The number of strings in argv.
argv A pointer to an array of null-terminated, C-style strings.
Returns:
0 if program ended well, which it always does or it crashes outright, so returning 0 is fine
Exception: Safe
Creator: John Cox (2-13-2016)
-----------------------------------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
int width = 500;
int height = 500;
unsigned int displayMode = GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH | GLUT_STENCIL;
displayMode = Defaults(displayMode, width, height);
glutInitDisplayMode(displayMode);
glutInitContextVersion(4, 4);
glutInitContextProfile(GLUT_CORE_PROFILE);
// enable this for automatic message reporting (see OpenGlErrorHandling.cpp)
#define DEBUG
#ifdef DEBUG
glutInitContextFlags(GLUT_DEBUG);
#endif
glutInitWindowSize(width, height);
glutInitWindowPosition(300, 200);
int window = glutCreateWindow(argv[0]);
glload::LoadTest glLoadGood = glload::LoadFunctions();
// ??check return value??
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
if (!glload::IsVersionGEQ(3, 3))
{
printf("Your OpenGL version is %i, %i. You must have at least OpenGL 3.3 to run this tutorial.\n",
glload::GetMajorVersion(), glload::GetMinorVersion());
glutDestroyWindow(window);
return 0;
}
if (glext_ARB_debug_output)
{
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
glDebugMessageCallbackARB(DebugFunc, (void*)15);
}
Init();
glutDisplayFunc(Display);
glutReshapeFunc(Reshape);
glutKeyboardFunc(Keyboard);
glutMainLoop();
CleanupAll();
return 0;
}
GLvoid GLKeyDown(unsigned char key, int x, int y){
if(key==' ')
{
if(test_hits())
{
glutPostRedisplay();
}
}
if(key=='w')
{
vec4 pos = characters[TARGET_ID]->transform*vec4(0,0,0);
double dist = pos.length();
if(dist<MAX_TURRET_TRANSLATE)
{
vec4 mv_dir = (pos)*TURRET_SPEED;
characters[TARGET_ID]->transform.translate(mv_dir.x, 0, mv_dir.z);
characters[BARREL_ID]->transform.rotateX(2.0);
glutPostRedisplay();
}
}
if(key=='s')
{
vec4 pos = characters[TARGET_ID]->transform*vec4(0,0,0);
double dist = pos.length();
if(dist>MIN_TURRET_TRANSLATE)
{
vec4 mv_dir = (pos)*TURRET_SPEED;
characters[TARGET_ID]->transform.translate(-mv_dir.x, 0, -mv_dir.z);
characters[BARREL_ID]->transform.rotateX(-2.0);
glutPostRedisplay();
}
}
if(key=='a'&&turret_rotate<MAX_TURRET_ROTATE)
{
turret_rotate++;
characters[TARGET_ID]->transform.rotateY(TURRET_TURN);
characters[SWIVEL_ID]->transform.rotateY(TURRET_TURN);
glutPostRedisplay();
}
if(key=='d'&&turret_rotate>MIN_TURRET_ROTATE)
{
turret_rotate--;
characters[TARGET_ID]->transform.rotateY(-TURRET_TURN);
characters[SWIVEL_ID]->transform.rotateY(-TURRET_TURN);
glutPostRedisplay();
}
if(key==KEYBOARD_ESC)
{
glutDestroyWindow(glutGetWindow());
exit(0);
}
}
void System::Keyboard(unsigned char key, int x, int y)
{
switch(key)
{
case 27:
case 'q':
glutDestroyWindow(1);
break;
case 'w':
Drawer::MoveCamera(0.0, 0.1, 0.0);
break;
case 's':
Drawer::MoveCamera(0.0,-0.1, 0.0);
break;
case 'a':
Drawer::MoveCamera(-0.1, 0.0, 0.0);
break;
case 'd':
Drawer::MoveCamera( 0.1, 0.0, 0.0);
break;
case 'z':
Drawer::MoveCamera(0.0, 0.0, 0.1);
break;
case 'x':
Drawer::MoveCamera(0.0, 0.0,-0.1);
break;
case 'i':
Drawer::GetDrawable(1)->Translate(0.0, 200, 0.0);
break;
case 'k':
Drawer::GetDrawable(1)->Translate(0.0,-200, 0.0);
break;
case 'j':
Drawer::GetDrawable(1)->Translate(-200, 0.0, 0.0);
break;
case 'l':
Drawer::GetDrawable(1)->Translate( 200, 0.0, 0.0);
break;
case 'f':
Drawer::MoveLight(-200, 0, 0);
break;
case 'h':
Drawer::MoveLight(200, 0 , 0);
break;
case 't':
Drawer::MoveLight(0, 2000, 0);
break;
case 'g':
Drawer::MoveLight(0,-2000, 0);
break;
}
}
