void
mouse(int button, int state, int x, int y)
{
if (button == GLUT_LEFT_BUTTON) {
if (state == GLUT_DOWN) {
glutSetCursor(GLUT_CURSOR_LEFT_RIGHT);
moving = 1;
begin = x;
} else if (state == GLUT_UP) {
glutSetCursor(GLUT_CURSOR_INHERIT);
moving = 0;
}
}
if (overlaySupport && button == GLUT_MIDDLE_BUTTON) {
if (state == GLUT_DOWN) {
help = 0;
clearHelp = 1;
rubberbanding = 1;
anchorx = x;
anchory = y;
stretchx = x;
stretchy = y;
glutShowOverlay();
} else if (state == GLUT_UP) {
rubberbanding = 0;
glutHideOverlay();
glutUseLayer(GLUT_NORMAL);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
#undef max
#undef min
#define max(a,b) ((a) > (b) ? (a) : (b))
#define min(a,b) ((a) < (b) ? (a) : (b))
wx = min(anchorx, stretchx);
wy = min(H - anchory, H - stretchy);
wx2 = max(anchorx, stretchx);
wy2 = max(H - anchory, H - stretchy);
ww = wx2 - wx;
wh = wy2 - wy;
if (ww == 0 || wh == 0) {
glutUseLayer(GLUT_NORMAL);
defaultProjection();
} else {
vx2 = wx2 / W * vw + vx;
vx = wx / W * vw + vx;
vy2 = wy2 / H * vh + vy;
vy = wy / H * vh + vy;
vw = vx2 - vx;
vh = vy2 - vy;
glFrustum(vx, vx + vw, vy, vy + vh, 1.0, 40);
}
glutPostRedisplay();
glMatrixMode(GL_MODELVIEW);
}
}
}
static void Idle(void)
{
if (overlayInit == GL_FALSE) {
glutUseLayer(GLUT_OVERLAY);
glClear(GL_COLOR_BUFFER_BIT);
/* glColor3f(1.0, 0.0, 0.0);*/
glIndexf( 2.0 );
glBegin(GL_POLYGON);
glVertex2i(windW/4-10, windH/4-10);
glVertex2i(windW/2-10, windH/4-10);
glVertex2i(windW/2-10, windH/2-10);
glVertex2i(windW/4-10, windH/2-10);
glEnd();
glIndexf( 0.0 );
glBegin(GL_POLYGON);
glVertex2i(windW/4, windH/4);
glVertex2i(windW/2, windH/4);
glVertex2i(windW/2, windH/2);
glVertex2i(windW/4, windH/2);
glEnd();
glIndexf( 1.0 );
glBegin(GL_POLYGON);
glVertex2i(windW/4+10, windH/4+10);
glVertex2i(windW/2+10, windH/4+10);
glVertex2i(windW/2+10, windH/2+10);
glVertex2i(windW/4+10, windH/2+10);
glEnd();
glutUseLayer(GLUT_NORMAL);
overlayInit = GL_TRUE;
}
MoveStars();
ShowStars();
if (nitro > 0) {
speed = (float)(nitro / 10) + 1.0;
if (speed > MAXWARP) {
speed = MAXWARP;
}
if (++nitro > MAXWARP*10) {
nitro = -nitro;
}
} else if (nitro < 0) {
nitro++;
speed = (float)(-nitro / 10) + 1.0;
if (speed > MAXWARP) {
speed = MAXWARP;
}
}
glFlush();
if (doubleBuffer) {
glutSwapBuffers();
}
}
static void
render(void)
{
glutUseLayer(GLUT_NORMAL);
render_normal();
if (glutLayerGet(GLUT_HAS_OVERLAY)) {
glutUseLayer(GLUT_OVERLAY);
render_overlay();
}
}
void
reshape(int w, int h)
{
glutUseLayer(GLUT_NORMAL);
glViewport(0, 0, w, h);
if (on) {
glutUseLayer(GLUT_OVERLAY);
glViewport(0, 0, w, h);
printf("w=%d, h=%d\n", w, h);
}
}
void
reshape(int w, int h)
{
width = w;
height = h;
/* Reshape both layers. */
glutUseLayer(GLUT_OVERLAY);
glViewport(0, 0, w, h);
glutUseLayer(GLUT_NORMAL);
glViewport(0, 0, w, h);
/* Read back viewport for gluUnProject. */
glGetIntegerv(GL_VIEWPORT, viewport);
}
void
mouse(int button, int state, int x, int y)
{
GLdouble objx, objy, objz;
gluUnProject(x, height - y, 0.95,
modelMatrix, projMatrix, viewport,
&objx, &objy, &objz);
overlaySphere.x = objx;
overlaySphere.y = objy;
overlaySphere.z = objz;
overlaySphere.material = button;
glutUseLayer(GLUT_OVERLAY);
glutSetColor(opaque,
2 * matColor[button][0], /* Red. */
2 * matColor[button][1], /* Green. */
2 * matColor[button][2]); /* Blue. */
if (state == GLUT_UP) {
glutHideOverlay();
if (spheres < MAX_SPHERES) {
sphereInfo[spheres] = overlaySphere;
sphereInfo[spheres].detail = 25; /* Fine tesselation. */
spheres++;
} else {
printf("oversphere: Out of spheres.\n");
}
glutPostRedisplay();
} else {
overlaySphere.detail = 10; /* Coarse tesselation. */
glutShowOverlay();
glutPostOverlayRedisplay();
}
}
void
display2(void)
{
glutUseLayer(GLUT_NORMAL);
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
if (glutLayerGet(GLUT_HAS_OVERLAY)) {
glutUseLayer(GLUT_OVERLAY);
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POLYGON);
glVertex2f(.2, .28);
glVertex2f(.5, .58);
glVertex2f(.2, .58);
glEnd();
glFlush();
}
}
void
reshape(int w, int h)
{
if (overlaySupport) {
glutUseLayer(GLUT_OVERLAY);
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, 0, h);
glScalef(1, -1, 1);
glTranslatef(0, -h, 0);
glMatrixMode(GL_MODELVIEW);
glutUseLayer(GLUT_NORMAL);
}
glViewport(0, 0, w, h);
W = w;
H = h;
}
static void
render_normal(void)
{
glutUseLayer(GLUT_NORMAL);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0, 0.0, 1.0);
glBegin(GL_POLYGON);
glVertex2f(.2, .28);
glVertex2f(.5, .58);
glVertex2f(.2, .58);
glEnd();
glFlush();
}
static void Reshape(int width, int height)
{
windW = (GLint)width;
windH = (GLint)height;
glutUseLayer(GLUT_OVERLAY);
glViewport(0, 0, windW, windH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-0.5, windW+0.5, -0.5, windH+0.5);
glMatrixMode(GL_MODELVIEW);
overlayInit = GL_FALSE;
glutUseLayer(GLUT_NORMAL);
glViewport(0, 0, windW, windH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-0.5, windW+0.5, -0.5, windH+0.5);
glMatrixMode(GL_MODELVIEW);
}
void
overlay_display(void)
{
printf("overlay_display: damaged=%d\n", glutLayerGet(GLUT_OVERLAY_DAMAGED));
if (on) {
glutUseLayer(GLUT_OVERLAY);
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POLYGON);
glVertex2f(.2 + x, .2 + y);
glVertex2f(.5 + x, .5 + y);
glVertex2f(.2 + x, .5 + y);
glEnd();
glFlush();
}
}
/* ARGSUSED1 */
void
key2(unsigned char c, int w, int h)
{
int transP;
printf("c=%d\n", c);
switch (c) {
case 'g':
glutReshapeWindow(
glutGet(GLUT_WINDOW_WIDTH) + 2, glutGet(GLUT_WINDOW_HEIGHT) + 2);
break;
case 's':
glutReshapeWindow(
glutGet(GLUT_WINDOW_WIDTH) - 2, glutGet(GLUT_WINDOW_HEIGHT) - 2);
break;
case 'u':
glutPopWindow();
break;
case 'd':
glutPushWindow();
break;
case 'e':
glutEstablishOverlay();
transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
glClearIndex(transP);
glutSetColor((transP + 1) % 2, 0.0, 0.25, 0.0);
glIndexi((transP + 1) % 2);
break;
case 'c':
if (glutLayerGet(GLUT_HAS_OVERLAY)) {
glutUseLayer(GLUT_OVERLAY);
glutCopyColormap(main_w);
}
break;
case 'r':
glutRemoveOverlay();
break;
case ' ':
printf("overlay possible: %d\n", glutLayerGet(GLUT_OVERLAY_POSSIBLE));
printf("layer in use: %d\n", glutLayerGet(GLUT_LAYER_IN_USE));
printf("has overlay: %d\n", glutLayerGet(GLUT_HAS_OVERLAY));
printf("transparent index: %d\n", glutLayerGet(GLUT_TRANSPARENT_INDEX));
break;
}
}
void
display(void)
{
printf("normal_display: damaged=%d\n", glutLayerGet(GLUT_NORMAL_DAMAGED));
glutUseLayer(GLUT_NORMAL);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 0.0, 0.0);
glBegin(GL_POLYGON);
glVertex2f(.2, .28);
glVertex2f(.5, .58);
glVertex2f(.2, .58);
glEnd();
if (!independent) {
overlay_display();
} else {
printf("not calling overlay_display\n");
}
}
void
controlLights(int value)
{
glutUseLayer(GLUT_NORMAL);
switch (value) {
case 1:
lightZeroSwitch = !lightZeroSwitch;
if (lightZeroSwitch) {
glEnable(GL_LIGHT0);
} else {
glDisable(GL_LIGHT0);
}
break;
case 2:
lightOneSwitch = !lightOneSwitch;
if (lightOneSwitch) {
glEnable(GL_LIGHT1);
} else {
glDisable(GL_LIGHT1);
}
break;
case 3:
defaultProjection();
break;
case 4:
fancy = 1;
break;
case 5:
fancy = 0;
wasFancy = 1;
break;
case 6:
if (!rubberbanding)
help = 1;
glutShowOverlay();
glutPostOverlayRedisplay();
break;
}
glutPostRedisplay();
}
int
main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitWindowSize(300, 300);
glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX);
if (!glutLayerGet(GLUT_OVERLAY_POSSIBLE)) {
printf("UNRESOLVED: need overlays for this test (your window system lacks overlays)\n");
exit(0);
}
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
main_win = glutCreateWindow("test17");
if (glutLayerGet(GLUT_LAYER_IN_USE) == GLUT_OVERLAY) {
printf("FAIL: overlay should not be in use\n");
exit(1);
}
if (glutLayerGet(GLUT_HAS_OVERLAY)) {
printf("FAIL: overlay should not exist\n");
exit(1);
}
if (glutLayerGet(GLUT_TRANSPARENT_INDEX) != -1) {
printf("FAIL: transparent pixel of normal plane should be -1\n");
exit(1);
}
if (glutLayerGet(GLUT_NORMAL_DAMAGED) != 0) {
printf("FAIL: no normal damage yet\n");
exit(1);
}
if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != -1) {
printf("FAIL: no overlay damage status yet\n");
exit(1);
}
glClearColor(0.0, 1.0, 0.0, 0.0);
glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX);
/* Small torture test. */
glutEstablishOverlay();
glutRemoveOverlay();
glutEstablishOverlay();
glutEstablishOverlay();
glutShowOverlay();
glutHideOverlay();
glutShowOverlay();
glutRemoveOverlay();
glutRemoveOverlay();
glutEstablishOverlay();
if (glutGet(GLUT_WINDOW_RGBA)) {
printf("FAIL: overlay should not be RGBA\n");
exit(1);
}
glutUseLayer(GLUT_NORMAL);
if (!glutGet(GLUT_WINDOW_RGBA)) {
printf("FAIL: normal should be RGBA\n");
exit(1);
}
glutUseLayer(GLUT_OVERLAY);
if (glutGet(GLUT_WINDOW_RGBA)) {
printf("FAIL: overlay should not be RGBA\n");
exit(1);
}
if (glutLayerGet(GLUT_LAYER_IN_USE) == GLUT_NORMAL) {
printf("FAIL: overlay should be in use\n");
exit(1);
}
if (glutLayerGet(GLUT_HAS_OVERLAY) == 0) {
printf("FAIL: overlay should exist\n");
exit(1);
}
if (glutLayerGet(GLUT_TRANSPARENT_INDEX) == -1) {
printf("FAIL: transparent pixel should exist\n");
exit(1);
}
if (glutLayerGet(GLUT_NORMAL_DAMAGED) != 0) {
printf("FAIL: no normal damage yet\n");
exit(1);
}
if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != 0) {
printf("FAIL: no overlay damage yet\n");
exit(1);
}
transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
glClearIndex(glutLayerGet(GLUT_TRANSPARENT_INDEX));
glutSetColor((transP + 1) % 2, 1.0, 0.0, 1.0);
glIndexi((transP + 1) % 2);
glutUseLayer(GLUT_NORMAL);
if (glutLayerGet(GLUT_LAYER_IN_USE) == GLUT_OVERLAY) {
printf("FAIL: overlay should not be in use\n");
exit(1);
}
glutDisplayFunc(display);
glutMainLoop();
return 0; /* ANSI C requires main to return int. */
}
/*
* Class: gruenewa_opengl_GLUT__
* Method: glutUseLayer
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_gruenewa_opengl_GLUT_00024_glutUseLayer
(JNIEnv * jenv, jobject jobj, jint arg1) {
glutUseLayer(arg1);
}
