void ProcessMenu(int value)
{
switch(value)
{
case 1:
useBlending = !useBlending;
if (useBlending)
{
glutChangeToMenuEntry(1, "Toggle vertex blending (currently ON)", 1);
}
else
{
glutChangeToMenuEntry(1, "Toggle vertex blending (currently OFF)", 1);
}
break;
case 2:
showBones = !showBones;
if (showBones)
{
glutChangeToMenuEntry(2, "Show bones (currently ON)", 2);
}
else
{
glutChangeToMenuEntry(2, "Show bones (currently OFF)", 2);
}
break;
default:
break;
}
// Refresh the Window
glutPostRedisplay();
}
void
it(int value)
{
glutDestroyWindow(glutGetWindow());
printf("menu selection: win=%d, menu=%d\n", glutGetWindow(), glutGetMenu());
switch (value) {
case 1:
if (list == 1) {
list = 2;
} else {
list = 1;
}
break;
case 2:
exit(0);
break;
case 3:
glutAddMenuEntry("new entry", value + 9);
break;
case 4:
glutChangeToMenuEntry(1, "toggle it for drawing", 1);
glutChangeToMenuEntry(3, "motion done", 3);
glutIdleFunc(idle);
break;
case 5:
glutIdleFunc(NULL);
break;
case 6:
glutTimerFunc(2000, delayed_stop, 0);
break;
default:
printf("value = %d\n", value);
}
}
void
menu(int item)
{
switch (item) {
case ADD_PLANE:
add_plane();
break;
case REMOVE_PLANE:
remove_plane();
break;
case MOTION_ON:
moving = GL_TRUE;
glutChangeToMenuEntry(3, "Motion off", MOTION_OFF);
glutIdleFunc(animate);
break;
case MOTION_OFF:
moving = GL_FALSE;
glutChangeToMenuEntry(3, "Motion", MOTION_ON);
glutIdleFunc(NULL);
break;
case QUIT:
exit(0);
break;
}
}
/*ARGSUSED1*/
void
key(unsigned char key, int x, int y)
{
switch (key) {
case '\033':
case 'q':
case 'Q':
exit(EXIT_SUCCESS);
case '+':
if (maxPoints < 65536 && !useStrokes) {
maxPoints *= 2;
makepoints();
}
break;
case '-':
if (maxPoints > 64 && !useStrokes) {
maxPoints /= 2;
makepoints();
}
break;
case 'e':
case 'E':
if (canDrawEdges)
drawEdges = !drawEdges;
break;
case 'i':
case 'I':
viewImage = !viewImage;
glutChangeToMenuEntry(useStrokes ? 1 : 4, viewImage ? "View artistic image ('i')" : "View source image ('i')", 'i');
break;
case 'r':
case 'R':
if (!useStrokes)
makepoints();
break;
case 's':
case 'S':
useStrokes = !useStrokes;
glutSetMenu(useStrokes ? strokeMenu : sampleMenu);
if (viewImage)
glutChangeToMenuEntry(useStrokes ? 1 : 3, "View artistic image ('i')", 'i');
if (useStrokes) {
maxPoints = 65536;
free(points);
points = (Point *) malloc(maxPoints * sizeof(Point));
numPoints = 0;
} else {
maxPoints = 2048;
makepoints();
}
break;
default:
return;
}
glutPostRedisplay();
}
void menu(int opcao)
{
switch (opcao) {
case 0 :
exit(1);
break;
// velocidade bola
case 1 :
if(modelo.bola.velocidade>2)
modelo.bola.velocidade-=2;
break;
case 2 :
if(modelo.bola.velocidade<16)
modelo.bola.velocidade+=2;
break;
// tamanho bola
case 3 :
if(modelo.bola.tamanho>5)
modelo.bola.tamanho--;
break;
case 4 :
if(modelo.bola.tamanho<15)
modelo.bola.tamanho++;
break;
// velocidade raquete
case 5 :
if(modelo.velocidadeRaquetes>10)
modelo.velocidadeRaquetes-=5;
break;
case 6 :
if(modelo.velocidadeRaquetes<30)
modelo.velocidadeRaquetes+=5;
break;
// tamanho raquete
case 7 :
if(modelo.alturaRaquetes>30)
modelo.alturaRaquetes-=10;
break;
case 8 :
if(modelo.velocidadeRaquetes<100)
modelo.alturaRaquetes+=10;
break;
case 9 :
modelo.parado=!modelo.parado;
if(modelo.parado)
{
glutChangeToMenuEntry(1,"Começar",9);
glutPostRedisplay();
}
else
{
glutChangeToMenuEntry(1,"Parar",9);
}
break;
}
}
/*
* Defines what each key does
*/
void CLGLWindowKeyboard(unsigned char key, int x, int y)
{
//this way we can exit the program cleanly
switch(key)
{
// ---------- //
// QUIT CASES //
// ---------- //
case '\033': // escape quits
case '\015': // Enter quits
case 'Q': // Q quits
case 'q': // q (or escape) quits
// Cleanup up and quit
CLGLWindowDestroy();
break;
// ------------------ //
// PLAY / PAUSE CASES //
// ------------------ //
case ' ':
if(CLGLWindow::play == ON){
CLGLWindow::play = OFF; //Play Pause Button
glutChangeToMenuEntry(1, "Play", PLAY);
}
else{
CLGLWindow::play = ON;
glutChangeToMenuEntry(1, "Pause", PLAY);
}
break;
// --------------- //
// Show Info Cases //
// --------------- //
case 'i':
case 'I':
if(CLGLWindow::showInfo == ON){
CLGLWindow::showInfo = OFF;
glutChangeToMenuEntry(2, "Show Info", INFO);
}
else{
CLGLWindow::showInfo = ON;
glutChangeToMenuEntry(2, "Hide Info", INFO);
}
break;
// ------------------ //
// Refresh Rate Cases //
// ------------------ //
case 'l':
case 'L':
CLGLWindow::refreshRate++;
break;
case 'j':
case 'J':
CLGLWindow::refreshRate--;
if(CLGLWindow::refreshRate <= 0)
CLGLWindow::refreshRate = 1;
break;
}
}
void stencilDecalEnable(int enabled)
{
glutSetMenu(mainMenu);
if(enabled){
glutChangeToMenuEntry(1, "Turn off stencil decal", 0);
printf("Stencil decaling turned on\n");
glutPostRedisplay();
} else {
glutChangeToMenuEntry(1, "Turn on stencil decal", 1);
printf("Stencil decaling turned off\n");
glutPostRedisplay();
}
useStencil = enabled;
}
/*ARGSUSED1*/
void
cbKeyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
case 'q':
exit(0);
case 'l':
case 'L':
point = !point;
glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, point ? 180.0 : 60.0);
glLightf(GL_LIGHT2, GL_SPOT_CUTOFF, point ? 180.0 : 60.0);
glutChangeToMenuEntry(1, point ? "Change to spotlights ('l')"
: "Change to point lights ('l')", 'l');
break;
case 'w':
case 'W':
drawMode = (drawMode == GL_FILL) ? GL_LINE : GL_FILL;
break;
default:
return;
}
glutPostRedisplay();
}
void GLUTCALLBACK Motion(int x,int y)
{
switch(buttonDown) {
case GLUT_LEFT_BUTTON:
pos[X_AXIS]-=(x-beginX)*MOUSE_SCALE;
pos[Z_AXIS]-=(y-beginY)*MOUSE_SCALE;
break;
case GLUT_RIGHT_BUTTON:
yAngle+=(x-beginX)*MOUSE_SCALE;
xAngle+=(y-beginY)*MOUSE_SCALE;
{
char buf[40];
sprintf(buf,"Angle: %+.1f",yAngle);
glutChangeToMenuEntry(3,buf,3);
}
break;
}
beginX=x;
beginY=y;
#ifdef HAVE_GLUTCAVE
GLUTCAVE_REDISPLAY();
#else
glutPostRedisplay();
#endif
}
/*ARGSUSED1*/
void
cbKeyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
case 'q':
exit(0);
case 'm':
case 'M':
glBindTexture(GL_TEXTURE_2D, texName[1]);
break;
case 's':
case 'S':
glBindTexture(GL_TEXTURE_2D, texName[0]);
break;
case 't':
case 'T':
showTexture = !showTexture;
glutChangeToMenuEntry(4, showTexture ? "Show object ('t')" : "Show texture ('t')", 't');
break;
case 'w':
case 'W':
drawMode = (drawMode == GL_FILL) ? GL_LINE : GL_FILL;
break;
default:
return;
}
glutPostRedisplay();
}
void ProcessMenu(int value)
{
switch(value)
{
case 1:
occlusionDetection = !occlusionDetection;
if (occlusionDetection)
{
glutChangeToMenuEntry(1, "Toogle occlusion culling(currently ON", 1);
}
else
{
glutChangeToMenuEntry(1, "Toogle occlusion culling(currently OFF", 1);
}
break;
}
glutPostRedisplay();
}
void toggleMotionBlur(void)
{
useMotionBlur = !useMotionBlur;
if (useMotionBlur)
{
glutChangeToMenuEntry(2, "Toggle motion blur (currently ON)", 2);
glActiveTexture(GL_TEXTURE1);
glLoadIdentity();
glActiveTexture(GL_TEXTURE2);
glEnable(GL_TEXTURE_2D);
}
else
{
glutChangeToMenuEntry(2, "Toggle motion blur (currently OFF)", 2);
glActiveTexture(GL_TEXTURE2);
glDisable(GL_TEXTURE_2D);
}
}
void
toggleSolve(void)
{
if (solving) {
freeSolutions();
solving = 0;
glutChangeToMenuEntry(1, "Solving", 1);
glutSetWindowTitle("glpuzzle");
movingPiece = 0;
} else {
glutChangeToMenuEntry(1, "Stop solving", 1);
glutSetWindowTitle("Solving...");
if (solvePuzzle()) {
solving = 1;
}
}
changeState();
glutPostRedisplay();
}
void GLUTCALLBACK Special(int key,int x,int y)
{
char buf[40];
glutSetMenu(controlMID);
switch(key) {
case GLUT_KEY_LEFT:
pos[X_AXIS]+=TRANSLATE_DELTA;
sprintf(buf,"Pos: %+.1f,%+.1f,%+.1f",pos[0],pos[1],pos[2]);
glutChangeToMenuEntry(2,buf,2);
break;
case GLUT_KEY_RIGHT:
pos[X_AXIS]-=TRANSLATE_DELTA;
sprintf(buf,"Pos: %+.1f,%+.1f,%+.1f",pos[0],pos[1],pos[2]);
glutChangeToMenuEntry(2,buf,2);
break;
case GLUT_KEY_UP:
pos[Z_AXIS]+=TRANSLATE_DELTA;
sprintf(buf,"Pos: %+.1f,%+.1f,%+.1f",pos[0],pos[1],pos[2]);
glutChangeToMenuEntry(2,buf,2);
break;
case GLUT_KEY_DOWN:
pos[Z_AXIS]-=TRANSLATE_DELTA;
sprintf(buf,"Pos: %+.1f,%+.1f,%+.1f",pos[0],pos[1],pos[2]);
glutChangeToMenuEntry(2,buf,2);
break;
case GLUT_KEY_PAGE_UP:
pos[Y_AXIS]-=TRANSLATE_DELTA;
sprintf(buf,"Pos: %+.1f,%+.1f,%+.1f",pos[0],pos[1],pos[2]);
glutChangeToMenuEntry(2,buf,2);
break;
case GLUT_KEY_PAGE_DOWN:
pos[Y_AXIS]+=TRANSLATE_DELTA;
sprintf(buf,"Pos: %+.1f,%+.1f,%+.1f",pos[0],pos[1],pos[2]);
glutChangeToMenuEntry(2,buf,2);
break;
case GLUT_KEY_HOME:
rotAxis[axis]+=AXIS_DELTA;
sprintf(buf,"Axis: %+.1f,%+.1f,%+.1f",rotAxis[0],rotAxis[1],rotAxis[2]);
glutChangeToMenuEntry(4,buf,4);
break;
case GLUT_KEY_END:
rotAxis[axis]-=AXIS_DELTA;
sprintf(buf,"Axis: %+.1f,%+.1f,%+.1f",rotAxis[0],rotAxis[1],rotAxis[2]);
glutChangeToMenuEntry(4,buf,4);
break;
}
#ifdef HAVE_GLUTCAVE
GLUTCAVE_REDISPLAY();
#else
glutPostRedisplay();
#endif
}
void ProcessMenu(int value)
{
switch(value)
{
case 1:
noShadows = !noShadows;
showShadowMap = GL_FALSE;
if (noShadows)
{
glutChangeToMenuEntry(1, "Toggle shadows (currently OFF)", 1);
}
else
{
glutChangeToMenuEntry(1, "Toggle shadows (currently ON)", 1);
}
glutChangeToMenuEntry(2, "Toggle show shadowmap (currently OFF)", 2);
break;
case 2:
showShadowMap = !showShadowMap;
noShadows = GL_FALSE;
if (showShadowMap)
{
glutChangeToMenuEntry(2, "Toggle show shadowmap (currently ON)", 2);
}
else
{
glutChangeToMenuEntry(2, "Toggle show shadowmap (currently OFF)", 2);
}
glutChangeToMenuEntry(1, "Toggle shadows (currently ON)", 1);
break;
case 3:
controlCamera = !controlCamera;
if (controlCamera)
{
glutChangeToMenuEntry(3, "Switch to LIGHT control (currently CAMERA)", 3);
}
else
{
glutChangeToMenuEntry(3, "Switch to CAMERA control (currently LIGHT)", 3);
}
break;
default:
break;
}
// Refresh the Window
glutPostRedisplay();
}
void
menu(int choice)
{
/* simple GLUT popup menu stuff */
switch (choice) {
case SPIN_ON:
glutChangeToMenuEntry(1, "Random Spin OFF", SPIN_OFF);
glutIdleFunc(animate);
break;
case SPIN_OFF:
glutChangeToMenuEntry(1, "Random Spin ON", SPIN_ON);
glutIdleFunc(NULL);
break;
case MENU_HELP:
printCheatSheet();
break;
case MENU_EXIT:
exit(0);
break;
}
}
void togglePBOs(void)
{
usePBOs = !usePBOs;
if (usePBOs)
{
glutChangeToMenuEntry(1, "Toggle PBO usage (currently ON)", 1);
// first upload client memory to PBOs, then free them
for (int i = 0; i < 3; i++)
{
glBindBuffer(GL_PIXEL_PACK_BUFFER, i+1);
glBufferData(GL_PIXEL_PACK_BUFFER, dataHeight * dataPitch, pixels[i], usageHint);
assert(pixels[i]);
free(pixels[i]);
pixels[i] = NULL;
}
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
}
else
{
glutChangeToMenuEntry(1, "Toggle PBO usage (currently OFF)", 1);
// allocate read buffer, size of window
for (int i = 0; i < 3; i++)
{
assert(!pixels[i]);
pixels[i] = (GLubyte*)malloc(dataHeight * dataPitch);
assert(pixels[i]);
// upload PBO data, then delete
glBindBuffer(GL_PIXEL_PACK_BUFFER, i+1);
glGetBufferSubData(GL_PIXEL_PACK_BUFFER, 0, dataHeight * dataPitch, pixels[i]);
}
GLuint names[3] = {1, 2, 3};
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
glDeleteBuffers(3, names);
}
}
/*
* Menus Handler Function
*/
void CLGLWindowMenus(int value)
{
switch(value){
case PLAY:
if(CLGLWindow::play == ON){
CLGLWindow::play = OFF; //Play Pause Button
glutChangeToMenuEntry(1, "Play", PLAY);
}
else{
CLGLWindow::play = ON;
glutChangeToMenuEntry(1, "Pause", PLAY);
}
break;
case INFO:
if(CLGLWindow::showInfo == ON){
CLGLWindow::showInfo = OFF;
glutChangeToMenuEntry(2, "Show Info", INFO);
}
else{
CLGLWindow::showInfo = ON;
glutChangeToMenuEntry(2, "Hide Info", INFO);
}
break;
case RK1:
(*CLGLSim::rkx)[0] = (*CLGLSim::rkx)[1];
CLGLSim::curKernel = 1;
break;
case RK2:
(*CLGLSim::rkx)[0] = (*CLGLSim::rkx)[2];
CLGLSim::curKernel = 2;
break;
case RK4:
(*CLGLSim::rkx)[0] = (*CLGLSim::rkx)[3];
CLGLSim::curKernel = 4;
break;
case QUIT:
CLGLWindowDestroy();
break;
}
}
void reset(void)
{
if (solving) {
freeSolutions();
solving = 0;
glutChangeToMenuEntry(1, "Solving", 1);
movingPiece = 0;
changeState();
}
glutSetWindowTitle("glpuzzle");
memcpy(thePuzzle, startConfig, HEIGHT * WIDTH);
glutPostRedisplay();
}
void ProcessMenu(int value)
{
switch(value)
{
case 1:
useVertexShader = !useVertexShader;
if (useVertexShader)
{
glutChangeToMenuEntry(1, "Toggle vertex shader (currently ON)", 1);
glAttachShader(progObj, vShader);
}
else
{
glutChangeToMenuEntry(1, "Toggle vertex shader (currently OFF)", 1);
glDetachShader(progObj, vShader);
}
Relink();
break;
case 2:
useFragmentShader = !useFragmentShader;
if (useFragmentShader)
{
glutChangeToMenuEntry(2, "Toggle fragment shader (currently ON)", 2);
glAttachShader(progObj, fShader);
}
else
{
glutChangeToMenuEntry(2, "Toggle fragment shader (currently OFF)", 2);
glDetachShader(progObj, fShader);
}
Relink();
break;
case 3:
doBlink = !doBlink;
if (doBlink)
{
glutChangeToMenuEntry(3, "Toggle flicker (currently ON)", 3);
}
else
{
glutChangeToMenuEntry(3, "Toggle flicker (currently OFF)", 3);
}
if (!doBlink && (flickerLocation != -1))
glUniform1f(flickerLocation, 1.0f);
break;
default:
break;
}
// Refresh the Window
glutPostRedisplay();
}
void
keyboard(unsigned char c, int x, int y)
{
int piece;
switch (c) {
case 27:
exit(0);
break;
case 'D':
case 'd':
if (solving) {
freeSolutions();
solving = 0;
glutChangeToMenuEntry(1, "Solving", 1);
glutSetWindowTitle("glpuzzle");
movingPiece = 0;
changeState();
}
piece = selectPiece(x, y);
if (piece) {
nukePiece(piece);
}
glutPostRedisplay();
break;
case 'R':
case 'r':
reset();
break;
case 'S':
case 's':
toggleSolve();
break;
case 'b':
case 'B':
depth = 1 - depth;
if (depth) {
glEnable(GL_DEPTH_TEST);
} else {
glDisable(GL_DEPTH_TEST);
}
glutPostRedisplay();
break;
default:
break;
}
}
void
mouse(int b, int s, int x, int y)
{
float selx, sely;
mousex = x;
mousey = y;
curX = x;
curY = y;
if (s == GLUT_DOWN) {
switch (b) {
case GLUT_LEFT_BUTTON:
if (solving) {
freeSolutions();
solving = 0;
glutChangeToMenuEntry(1, "Solving", 1);
glutSetWindowTitle("glpuzzle");
movingPiece = 0;
}
left_mouse = GL_TRUE;
sel_piece = selectPiece(mousex, mousey);
if (computeCoords(sel_piece, mousex, mousey, &selx, &sely)) {
grabPiece(sel_piece, selx, sely);
}
glutPostRedisplay();
break;
case GLUT_MIDDLE_BUTTON:
middle_mouse = GL_TRUE;
glutPostRedisplay();
break;
}
} else {
switch (b) {
case GLUT_LEFT_BUTTON:
left_mouse = GL_FALSE;
dropSelection();
glutPostRedisplay();
break;
case GLUT_MIDDLE_BUTTON:
middle_mouse = GL_FALSE;
glutPostRedisplay();
break;
}
}
motion(x, y);
}
void
animate(void)
{
if (spinning) {
add_quats(lastquat, curquat, curquat);
}
glutPostRedisplay();
if (solving) {
if (!continueSolving()) {
solving = 0;
glutChangeToMenuEntry(1, "Solving", 1);
glutSetWindowTitle("glpuzzle");
}
}
if (!solving && !spinning && !visible) {
glutIdleFunc(NULL);
}
}
void HandleLoadMenu(int cset)
{
char filename[MAX_CSETNAMELEN + CSET_EXTLEN + 1];
if (cset == -1) {
MakeLoadAndSaveMenus();
CurveMenuInit();
} else {
(void)strcpy(filename, CSetNames[cset]);
(void)strcat(filename, CSET_EXT);
if (ReadCSetFromFile(filename) == 0) {
glutSetMenu(SaveMenu);
glutChangeToMenuEntry(1, CSetNames[cset], cset);
ComputeCSetAndMakeLists();
SetWindowTitles(CSetNames[cset]);
RedisplayBoth();
}
}
}
void ProcessMenu(int value)
{
switch(value)
{
case 1:
useBlending = !useBlending;
if (useBlending)
{
glutChangeToMenuEntry(1, "Toggle vertex blending (currently ON)", 1);
}
else
{
glutChangeToMenuEntry(1, "Toggle vertex blending (currently OFF)", 1);
}
break;
case 2:
showBones = !showBones;
if (showBones)
{
glutChangeToMenuEntry(2, "Show bones (currently ON)", 2);
}
else
{
glutChangeToMenuEntry(2, "Show bones (currently OFF)", 2);
}
break;
case 3:
useHighLevel = !useHighLevel;
if (useHighLevel)
{
glutChangeToMenuEntry(3, "Switch to low-level vertex shader", 3);
glUseProgramObjectARB(progObj[0]);
}
else
{
glutChangeToMenuEntry(3, "Switch to high-level vertex shader", 3);
glUseProgramObjectARB(0);
}
break;
default:
break;
}
// Refresh the Window
glutPostRedisplay();
}
static void handleMenu(int value)
{
switch (value) {
default:
break;
case MENU_SHOW_GLOBE:
mapMode = 0;
initProjection();
glutPostRedisplay();
glutChangeToMenuEntry(2, "Show Globe *", MENU_SHOW_GLOBE);
glutChangeToMenuEntry(3, "Show Map", MENU_SHOW_MAP);
break;
case MENU_SHOW_MAP:
mapMode = 1;
initProjection();
glutPostRedisplay();
glutChangeToMenuEntry(2, "Show Globe", MENU_SHOW_GLOBE);
glutChangeToMenuEntry(3, "Show Map *", MENU_SHOW_MAP);
break;
case MENU_ADJUST_GLOBE:
adjustMode = 0;
glutChangeToMenuEntry(4, "Adjust Globe *", MENU_ADJUST_GLOBE);
glutChangeToMenuEntry(5, "Adjust Day", MENU_ADJUST_DAY);
glutChangeToMenuEntry(6, "Adjust Time", MENU_ADJUST_TIME);
break;
case MENU_ADJUST_DAY:
adjustMode = 1;
glutChangeToMenuEntry(4, "Adjust Globe", MENU_ADJUST_GLOBE);
glutChangeToMenuEntry(5, "Adjust Day *", MENU_ADJUST_DAY);
glutChangeToMenuEntry(6, "Adjust Time", MENU_ADJUST_TIME);
break;
case MENU_ADJUST_TIME:
adjustMode = 2;
glutChangeToMenuEntry(4, "Adjust Globe", MENU_ADJUST_GLOBE);
glutChangeToMenuEntry(5, "Adjust Day", MENU_ADJUST_DAY);
glutChangeToMenuEntry(6, "Adjust Time *", MENU_ADJUST_TIME);
break;
case MENU_QUIT:
exit(0);
}
}
/* ARGSUSED1 */
void
gokey(unsigned char key, int x, int y)
{
char str[100];
int mods;
mods = glutGetModifiers();
printf("key = %d, mods = 0x%x\n", key, mods);
if (mods & GLUT_ACTIVE_ALT) {
switch (key) {
case '1':
printf("Change to sub menu 1\n");
glutChangeToSubMenu(1, "sub 1", submenu);
break;
case '2':
printf("Change to sub menu 2\n");
glutChangeToSubMenu(2, "sub 2", submenu);
break;
case '3':
printf("Change to sub menu 3\n");
glutChangeToSubMenu(3, "sub 3", submenu);
break;
case '4':
printf("Change to sub menu 4\n");
glutChangeToSubMenu(4, "sub 4", submenu);
break;
case '5':
printf("Change to sub menu 5\n");
glutChangeToSubMenu(5, "sub 5", submenu);
break;
}
} else {
switch (key) {
case '1':
printf("Change to menu entry 1\n");
glutChangeToMenuEntry(1, "entry 1", 1);
break;
case '2':
printf("Change to menu entry 2\n");
glutChangeToMenuEntry(2, "entry 2", 2);
break;
case '3':
printf("Change to menu entry 3\n");
glutChangeToMenuEntry(3, "entry 3", 3);
break;
case '4':
printf("Change to menu entry 4\n");
glutChangeToMenuEntry(4, "entry 4", 4);
break;
case '5':
printf("Change to menu entry 5\n");
glutChangeToMenuEntry(5, "entry 5", 5);
break;
case 'a':
case 'A':
printf("Adding menu entry %d\n", item);
sprintf(str, "added entry %d", item);
glutAddMenuEntry(str, item);
item++;
break;
case 's':
case 'S':
printf("Adding submenu %d\n", item);
sprintf(str, "added submenu %d", item);
glutAddSubMenu(str, submenu);
item++;
break;
case 'q':
printf("Remove 1\n");
glutRemoveMenuItem(1);
break;
case 'w':
printf("Remove 2\n");
glutRemoveMenuItem(2);
break;
case 'e':
printf("Remove 3\n");
glutRemoveMenuItem(3);
break;
case 'r':
printf("Remove 4\n");
glutRemoveMenuItem(4);
break;
case 't':
printf("Remove 5\n");
glutRemoveMenuItem(5);
break;
}
}
}
/*
* Class: gruenewa_opengl_GLUT__
* Method: glutChangeToMenuEntry
* Signature: (ILjava/lang/String;I)V
*/
JNIEXPORT void JNICALL Java_gruenewa_opengl_GLUT_00024_glutChangeToMenuEntry
(JNIEnv * jenv, jobject jobj, jint arg1, jobject arg2, jint arg3) {
glutChangeToMenuEntry(arg1, (*jenv)->GetDirectBufferAddress(jenv, arg2), arg3);
}
void ProcessMenu(int value)
{
switch(value)
{
case 1:
useBufferObject = !useBufferObject;
RegenerateSphere();
SetRenderingMethod();
if (useBufferObject)
{
glutChangeToMenuEntry(1, "Toggle buffer object usage (currently ON)", 1);
}
else
{
glutChangeToMenuEntry(1, "Toggle buffer object usage (currently OFF)", 1);
}
break;
case 2:
mapBufferObject = !mapBufferObject;
RegenerateSphere();
SetRenderingMethod();
if (mapBufferObject)
{
glutChangeToMenuEntry(2, "Toggle mapped buffer object (currently ON)", 2);
}
else
{
glutChangeToMenuEntry(2, "Toggle mapped buffer object (currently OFF)", 2);
}
break;
case 3:
animating = !animating;
if (animating)
{
glutChangeToMenuEntry(3, "Toggle animation (currently ON)", 3);
// Establish streaming buffer object
// Data will be loaded with subsequent calls to glBufferSubData
glBindBuffer(GL_ARRAY_BUFFER, bufferID);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) *
numSphereVertices * 3, NULL, GL_STREAM_DRAW);
}
else
{
glutChangeToMenuEntry(3, "Toggle animation (currently OFF)", 3);
// Establish static buffer object
// Data will be loaded with subsequent calls to glBufferSubData
glBindBuffer(GL_ARRAY_BUFFER, bufferID);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) *
numSphereVertices * 3, NULL, GL_STATIC_DRAW);
RegenerateSphere();
SetRenderingMethod();
}
break;
default:
break;
}
// Refresh the Window
glutPostRedisplay();
}
void GLUTCALLBACK Key(unsigned char key,int x,int y)
{
char buf[30];
glutSetMenu(controlMID);
switch(key) {
case '1':
axis=X_AXIS;
break;
case '2':
axis=Y_AXIS;
break;
case '3':
axis=Z_AXIS;
break;
case '<':
case ',':
angle-=ROTATE_DELTA;
sprintf(buf,"Angle: %+.1f",angle);
glutChangeToMenuEntry(3,buf,3);
break;
case '>':
case '.':
angle+=ROTATE_DELTA;
sprintf(buf,"Angle: %+.1f",angle);
glutChangeToMenuEntry(3,buf,3);
break;
case '+':
case '=':
if(eesrSpeed<0.9)
eesrSpeed+=0.08;
sprintf(buf,"Speed: %+.2f",eesrSpeed);
glutChangeToMenuEntry(5,buf,5);
break;
case '_':
case '-':
if(eesrSpeed>-0.9)
eesrSpeed-=0.08;
sprintf(buf,"Speed: %+.2f",eesrSpeed);
glutChangeToMenuEntry(5,buf,5);
break;
case 'T':
eesrSetTime(eesrGetTime()-1.0);
break;
case 't':
eesrSetTime(eesrGetTime()+1.0);
break;
case 'm':
if(menusActive) {
glutDetachMenu(GLUT_LEFT_BUTTON);
glutDetachMenu(GLUT_RIGHT_BUTTON);
menusActive=FALSE;
} else {
glutSetMenu(controlMID);
glutAttachMenu(GLUT_LEFT_BUTTON);
glutSetMenu(optionMID);
glutAttachMenu(GLUT_RIGHT_BUTTON);
menusActive=TRUE;
}
break;
case 27: /* escape */
case 'q':
case 'Q':
exit(0);
}
#ifdef HAVE_GLUTCAVE
GLUTCAVE_REDISPLAY();
#else
glutPostRedisplay();
#endif
}
