int
main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow("zoomdino");
glutDisplayFunc(redraw);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutCreateMenu(controlLights);
glutAddMenuEntry("Toggle right light", 1);
glutAddMenuEntry("Toggle left light", 2);
glutAttachMenu(GLUT_RIGHT_BUTTON);
makeDinosaur();
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
defaultProjection();
gluLookAt(0.0, 0.0, 30.0, /* eye is at (0,0,30) */
0.0, 0.0, 0.0, /* center is at (0,0,0) */
0.0, 1.0, 0.); /* up is in postivie Y direction */
glPushMatrix(); /* dummy push so we can pop on model
recalc */
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
glLightfv(GL_LIGHT0, GL_POSITION, lightZeroPosition);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightZeroColor);
glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.1);
glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05);
glLightfv(GL_LIGHT1, GL_POSITION, lightOnePosition);
glLightfv(GL_LIGHT1, GL_DIFFUSE, lightOneColor);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX);
overlaySupport = glutLayerGet(GLUT_OVERLAY_POSSIBLE);
if (overlaySupport) {
glutEstablishOverlay();
glutHideOverlay();
transparent = glutLayerGet(GLUT_TRANSPARENT_INDEX);
glClearIndex(transparent);
red = (transparent + 1) % glutGet(GLUT_WINDOW_COLORMAP_SIZE);
white = (transparent + 2) % glutGet(GLUT_WINDOW_COLORMAP_SIZE);
glutSetColor(red, 1.0, 0.0, 0.0); /* Red. */
glutSetColor(white, 1.0, 1.0, 1.0); /* White. */
glutOverlayDisplayFunc(redrawOverlay);
glutReshapeFunc(reshape);
glutSetWindowTitle("zoomdino with rubber-banding");
glutAddMenuEntry("------------------", 0);
glutAddMenuEntry("Reset projection", 3);
glutAddMenuEntry("------------------", 0);
glutAddMenuEntry("Fancy rubber-banding", 4);
glutAddMenuEntry("Simple rubber-banding", 5);
glutAddMenuEntry("------------------", 0);
glutAddMenuEntry("Show help", 6);
} else {
printf("Sorry, no whizzy zoomdino overlay usage!\n");
}
glutMainLoop();
return 0; /* ANSI C requires main to return int. */
}
int
main(int argc, char **argv)
{
glutInitWindowSize(350, 350);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow("Overlay Sphere Positioning Demo");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE); /* Solid spheres benefit greatly
from back face culling. */
setupMatrices();
/* Read back matrices for use by gluUnProject. */
glGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix);
glGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
/* Set up lighting. */
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiff);
glLightfv(GL_LIGHT0, GL_SPECULAR, lightSpec);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glutInitDisplayMode(GLUT_INDEX | GLUT_SINGLE);
if (glutLayerGet(GLUT_OVERLAY_POSSIBLE) == 0) {
printf("oversphere: no overlays supported; aborting.\n");
exit(1);
}
glutEstablishOverlay();
glutHideOverlay();
glutOverlayDisplayFunc(overlayDisplay);
/* Find transparent and opaque index. */
transparent = glutLayerGet(GLUT_TRANSPARENT_INDEX);
opaque = (transparent + 1)
% glutGet(GLUT_WINDOW_COLORMAP_SIZE);
/* Draw overlay sphere as an outline. */
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
/* Make sure overlay clears to transparent. */
glClearIndex(transparent);
/* Set up overlay matrices same as normal plane. */
setupMatrices();
glutMainLoop();
return 0;
}
bool GLUTBackendCreateWindow(unsigned int Width, unsigned int Height, unsigned int bpp, bool isFullScreen, const char* pTitle) {
if (isFullScreen) {
char ModeString[64] = { 0 };
#ifdef WIN32
_snprintf_s(ModeString, sizeof(ModeString), "%dx%d@%d", Width, Height, bpp);
#else
snprintf(ModeString, sizeof(ModeString), "%dx%d@%d", Width, Height, bpp);
#endif
glutGameModeString(ModeString);
glutEnterGameMode();
} else {
glutInitWindowSize(Width, Height);
glutCreateWindow(pTitle);
}
// Must be done after glut is initialized!
GLenum res = glewInit();
if (res != GLEW_OK) {
fprintf(stderr, "Error: '%s'\n", glewGetErrorString(res));
return false;
}
glutLayerGet(GLUT_OVERLAY_POSSIBLE);
//printf("%s",glutLayerGet(GLUT_OVERLAY_POSSIBLE));
glutEstablishOverlay();
return true;
}
static void
display(void)
{
if (glutLayerGet(GLUT_NORMAL_DAMAGED) == 0) {
printf("FAIL: normal damage expected\n");
exit(1);
}
if (glutLayerGet(GLUT_OVERLAY_DAMAGED) == 0) {
printf("FAIL: overlay damage expected\n");
exit(1);
}
render();
glutDisplayFunc(display2);
glutPostRedisplay();
}
void display(void)
{
static int r = 0; //回転角の設定
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //デプスバッファのクリア
glLoadIdentity();
/* 視点位置と視線方向 */
gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
/* 光源の位置設定 */
glLightfv(GL_LIGHT0, GL_POSITION, light0pos);
glLightfv(GL_LIGHT1, GL_POSITION, light1pos);
glPushMatrix();
glTranslatef(ox,oy,oz);
glRotatef(r, 0.5, -0.5, -0.5); //回転：このように、複数の軸を中心に回転させることもできます。
/* 図形の色 (gold) */
glMaterialfv(GL_FRONT, GL_DIFFUSE, gold_diffuse);
glMaterialfv(GL_FRONT, GL_AMBIENT, gold_ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, gold_specular);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, gold_shininess);
/* 図形の描画 */
glutSolidTeapot(0.8);
if (glutLayerGet(GLUT_NORMAL_DAMAGED) == 0)//画面が描き換えられたら
{
if (r++ >= 360) //角度rxを1増やした値（++r）が360以上になったら
{
r = 0; //角度を0に戻す
glutIdleFunc(0); //アニメーションをとめる
}
}
oy=oy-0.02;
glPopMatrix();
glutPostRedisplay(); //再描画イベントを発生
glutSwapBuffers();
}
static void
display_overlay(void)
{
if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != damage_expectation) {
printf("FAIL: overlay damage not expected\n");
exit(1);
}
render_overlay();
move_on();
}
static void
display_normal(void)
{
if (glutLayerGet(GLUT_NORMAL_DAMAGED) != damage_expectation) {
printf("FAIL: normal damage not expected\n");
exit(1);
}
render_normal();
move_on();
}
static void
render(void)
{
glutUseLayer(GLUT_NORMAL);
render_normal();
if (glutLayerGet(GLUT_HAS_OVERLAY)) {
glutUseLayer(GLUT_OVERLAY);
render_overlay();
}
}
void
main_menu(int option)
{
switch (option) {
case 1:
if (glutLayerGet(GLUT_HAS_OVERLAY)) {
independent = 1;
glutOverlayDisplayFunc(overlay_display);
}
break;
case 2:
if (glutLayerGet(GLUT_HAS_OVERLAY)) {
independent = 0;
glutOverlayDisplayFunc(NULL);
}
break;
case 666:
exit(0);
break;
}
}
static void
display2(void)
{
static int been_here = 0;
if (glutLayerGet(GLUT_NORMAL_DAMAGED) != 0) {
printf("FAIL: normal damage not expected\n");
exit(1);
}
if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != 0) {
printf("FAIL: overlay damage not expected\n");
exit(1);
}
if (been_here) {
glutPostOverlayRedisplay();
} else {
glutOverlayDisplayFunc(display_overlay);
glutDisplayFunc(display_normal);
damage_expectation = 0;
glutPostOverlayRedisplay();
glutPostRedisplay();
}
}
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();
}
}
void
overlayDisplay(void)
{
if (glutLayerGet(GLUT_OVERLAY_DAMAGED)) {
/* If damaged, clear the overlay. */
glClear(GL_COLOR_BUFFER_BIT);
} else {
/* If not damaged, undraw last overlay sphere. */
glIndexi(transparent);
drawSphere(&oldOverlaySphere);
}
glIndexi(opaque);
drawSphere(&overlaySphere);
/* Single buffered window needs flush. */
glFlush();
/* Remember last overaly sphere position for undrawing. */
oldOverlaySphere = overlaySphere;
}
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
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
s2_menu(int option)
{
int transP;
switch (option) {
case 1:
glutRemoveOverlay();
break;
case 2:
glutEstablishOverlay();
transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
glClearIndex(transP);
glutSetColor((transP + 1) % 2, 0.0, 0.25, 0.0);
glIndexi((transP + 1) % 2);
break;
case 666:
exit(0);
break;
}
}
int main(int argc, char **argv)
{
GLenum type;
glutInit(&argc, argv);
if (!glutLayerGet(GLUT_OVERLAY_POSSIBLE))
{
fprintf(stderr, "Overlay not available\n");
return(1);
}
if (Args(argc, argv) == GL_FALSE) {
return(1);
}
windW = 300;
windH = 300;
glutInitWindowPosition(0, 0); glutInitWindowSize( 300, 300);
type = GLUT_RGB;
type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE;
glutInitDisplayMode(type);
if (glutCreateWindow("Overlay Test") == GL_FALSE) {
return(1);
}
glutEstablishOverlay();
Init();
glutReshapeFunc(Reshape);
glutKeyboardFunc(Key);
glutIdleFunc(Idle);
glutMainLoop();
return 0;
}
/* 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
key(unsigned char c, int w, int h)
{
int transP;
printf("c=%d w=%d h=%d\n", c, w, h);
switch (c) {
case 'e':
glutEstablishOverlay();
independent = 0;
transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
glClearIndex(transP);
glutSetColor((transP + 1) % 2, 1.0, 1.0, 0.0);
glIndexi((transP + 1) % 2);
on = 1;
break;
case 'r':
glutRemoveOverlay();
on = 0;
break;
case 'm':
if (glutLayerGet(GLUT_HAS_OVERLAY)) {
int pixel;
GLfloat red, green, blue;
transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
pixel = (transP + 1) % 2;
red = glutGetColor(pixel, GLUT_RED) + 0.2;
if (red > 1.0)
red = red - 1.0;
green = glutGetColor(pixel, GLUT_GREEN) - 0.1;
if (green > 1.0)
green = green - 1.0;
blue = glutGetColor(pixel, GLUT_BLUE) + 0.1;
if (blue > 1.0)
blue = blue - 1.0;
glutSetColor(pixel, red, green, blue);
}
break;
case 'h':
glutSetWindow(hidden_w);
glutHideWindow();
glutSetWindow(s2);
glutHideWindow();
break;
case 's':
glutSetWindow(hidden_w);
glutShowWindow();
glutSetWindow(s2);
glutShowWindow();
break;
case 'H':
glutHideOverlay();
break;
case 'S':
glutShowOverlay();
break;
case 'D':
glutDestroyWindow(main_w);
exit(0);
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;
}
}
/*
* Class: gruenewa_opengl_GLUT__
* Method: glutLayerGet
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_gruenewa_opengl_GLUT_00024_glutLayerGet
(JNIEnv * jenv, jobject jobj, jint arg1) {
return glutLayerGet(arg1);
}
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. */
}
void
redrawOverlay(void)
{
if (help) {
int i;
glClear(GL_COLOR_BUFFER_BIT);
glIndexi(white);
for (i = 0; helpMsg[i]; i++) {
output(15, 24 + i * 18, helpMsg[i]);
}
return;
}
if (glutLayerGet(GLUT_OVERLAY_DAMAGED) || clearHelp) {
/* Opps, damage means we need a full clear. */
glClear(GL_COLOR_BUFFER_BIT);
clearHelp = 0;
wasFancy = 0;
} else {
/* Goody! No damage. Just erase last rubber-band. */
if (fancy || wasFancy) {
glLineWidth(3.0);
}
glIndexi(transparent);
glBegin(GL_LINE_LOOP);
glVertex2i(anchorx, anchory);
glVertex2i(anchorx, pstretchy);
glVertex2i(pstretchx, pstretchy);
glVertex2i(pstretchx, anchory);
glEnd();
}
if (wasFancy) {
glLineWidth(1.0);
wasFancy = 0;
}
if (fancy)
glLineWidth(3.0);
glIndexi(red);
glBegin(GL_LINE_LOOP);
glVertex2i(anchorx, anchory);
glVertex2i(anchorx, stretchy);
glVertex2i(stretchx, stretchy);
glVertex2i(stretchx, anchory);
glEnd();
if (fancy) {
glLineWidth(1.0);
glIndexi(white);
glBegin(GL_LINE_LOOP);
glVertex2i(anchorx, anchory);
glVertex2i(anchorx, stretchy);
glVertex2i(stretchx, stretchy);
glVertex2i(stretchx, anchory);
glEnd();
}
glFlush();
/* Remember last place rubber-banded so the rubber-band can
be erased next redisplay. */
pstretchx = stretchx;
pstretchy = stretchy;
}
