SDL 1.2.3, OpenGL32 and FULLSCREEN

SDL Development
1

hi!

i use: SDL 1.2.3, Windows98, MinGW + MSYS, OpenGL32

when switching back from FULLSCREEN mode, the screen resolutions stays
at the resolution of the fullscreen mode.

this does NOT happen when i’m not using opengl, then everything works
fine. (SDL only: ./testwin.exe -fullscreen works fine)

i have a ASUS 7100 and upgraded to the latest drivers. results are the same.
(this is a geforce2 MX)

maybe something in SDL_Quit does not de-initialize GL things well…

has somebody had a similar problem? how to solve that problem?

the program is attached - its the known demo ‘SDLgears’ modified to
start in fullscreen mode.

Thanks &
MfG,
Armin Obersteiner–
@Armin_Obersteiner pgp public key on request CU
-------------- next part --------------
/* $Id: gears.c,v 1.2 1999/10/21 16:39:06 brianp Exp $ */

/*

  • 3-D gear wheels. This program is in the public domain.
  • Command line options:
  • -info print GL implementation information
  • Brian Paul
    */

/* Conversion to GLUT by Mark J. Kilgard */

/*

  • $Log: gears.c,v $
  • Revision 1.2 1999/10/21 16:39:06 brianp
  • added -info command line option
  • Revision 1.1.1.1 1999/08/19 00:55:40 jtg
  • Imported sources
  • Revision 3.2 1999/06/03 17:07:36 brianp
  • an extra quad was being drawn in front and back faces
  • Revision 3.1 1998/11/03 02:49:10 brianp
  • added fps output
  • Revision 3.0 1998/02/14 18:42:29 brianp
  • initial rev

*/

#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <GL/gl.h>
#include “SDL.h”

#ifndef M_PI
#define M_PI 3.14159265
#endif

static GLint T0 = 0;
static GLint Frames = 0;

/**

Draw a gear wheel. You’ll probably want to call this function when
building a display list since we do a lot of trig here.

Input: inner_radius - radius of hole at center
outer_radius - radius at center of teeth
width - width of gear
teeth - number of teeth
tooth_depth - depth of tooth

**/

static void
gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
GLint teeth, GLfloat tooth_depth)
{
GLint i;
GLfloat r0, r1, r2;
GLfloat angle, da;
GLfloat u, v, len;

r0 = inner_radius;
r1 = outer_radius - tooth_depth / 2.0;
r2 = outer_radius + tooth_depth / 2.0;

da = 2.0 * M_PI / teeth / 4.0;

glShadeModel(GL_FLAT);

glNormal3f(0.0, 0.0, 1.0);

/* draw front face */
glBegin(GL_QUAD_STRIP);
for (i = 0; i <= teeth; i++) {
angle = i * 2.0 * M_PI / teeth;
glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
if (i < teeth) {
glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
}
}
glEnd();

/* draw front sides of teeth */
glBegin(GL_QUADS);
da = 2.0 * M_PI / teeth / 4.0;
for (i = 0; i < teeth; i++) {
angle = i * 2.0 * M_PI / teeth;

glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);

}
glEnd();

glNormal3f(0.0, 0.0, -1.0);

/* draw back face */
glBegin(GL_QUAD_STRIP);
for (i = 0; i <= teeth; i++) {
angle = i * 2.0 * M_PI / teeth;
glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
if (i < teeth) {
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
}
}
glEnd();

/* draw back sides of teeth */
glBegin(GL_QUADS);
da = 2.0 * M_PI / teeth / 4.0;
for (i = 0; i < teeth; i++) {
angle = i * 2.0 * M_PI / teeth;

glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);

}
glEnd();

/* draw outward faces of teeth */
glBegin(GL_QUAD_STRIP);
for (i = 0; i < teeth; i++) {
angle = i * 2.0 * M_PI / teeth;

glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
u = r2 * cos(angle + da) - r1 * cos(angle);
v = r2 * sin(angle + da) - r1 * sin(angle);
len = sqrt(u * u + v * v);
u /= len;
v /= len;
glNormal3f(v, -u, 0.0);
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
glNormal3f(cos(angle), sin(angle), 0.0);
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
glNormal3f(v, -u, 0.0);
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
glNormal3f(cos(angle), sin(angle), 0.0);

}

glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);

glEnd();

glShadeModel(GL_SMOOTH);

/* draw inside radius cylinder */
glBegin(GL_QUAD_STRIP);
for (i = 0; i <= teeth; i++) {
angle = i * 2.0 * M_PI / teeth;
glNormal3f(-cos(angle), -sin(angle), 0.0);
glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
}
glEnd();

}

static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
static GLint gear1, gear2, gear3;
static GLfloat angle = 0.0;

static void
draw(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glPushMatrix();
glRotatef(view_rotx, 1.0, 0.0, 0.0);
glRotatef(view_roty, 0.0, 1.0, 0.0);
glRotatef(view_rotz, 0.0, 0.0, 1.0);

glPushMatrix();
glTranslatef(-3.0, -2.0, 0.0);
glRotatef(angle, 0.0, 0.0, 1.0);
glCallList(gear1);
glPopMatrix();

glPushMatrix();
glTranslatef(3.1, -2.0, 0.0);
glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
glCallList(gear2);
glPopMatrix();

glPushMatrix();
glTranslatef(-3.1, 4.2, 0.0);
glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
glCallList(gear3);
glPopMatrix();

glPopMatrix();

SDL_GL_SwapBuffers();

Frames++;
{
GLint t = SDL_GetTicks();
if (t - T0 >= 5000) {
GLfloat seconds = (t - T0) / 1000.0;
GLfloat fps = Frames / seconds;
printf("%d frames in %g seconds = %g FPS\n", Frames, seconds, fps);
T0 = t;
Frames = 0;
}
}
}

static void
idle(void)
{
angle += 2.0;
}

/* new window size or exposure */
static void
reshape(int width, int height)
{
GLfloat h = (GLfloat) height / (GLfloat) width;

glViewport(0, 0, (GLint) width, (GLint) height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1.0, 1.0, -h, h, 5.0, 60.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0, 0.0, -40.0);
}

static void
init(int argc, char *argv[])
{
static GLfloat pos[4] =
{5.0, 5.0, 10.0, 0.0};
static GLfloat red[4] =
{0.8, 0.1, 0.0, 1.0};
static GLfloat green[4] =
{0.0, 0.8, 0.2, 1.0};
static GLfloat blue[4] =
{0.2, 0.2, 1.0, 1.0};

glLightfv(GL_LIGHT0, GL_POSITION, pos);
glEnable(GL_CULL_FACE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);

/* make the gears */
gear1 = glGenLists(1);
glNewList(gear1, GL_COMPILE);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
gear(1.0, 4.0, 1.0, 20, 0.7);
glEndList();

gear2 = glGenLists(1);
glNewList(gear2, GL_COMPILE);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
gear(0.5, 2.0, 2.0, 10, 0.7);
glEndList();

gear3 = glGenLists(1);
glNewList(gear3, GL_COMPILE);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
gear(1.3, 2.0, 0.5, 10, 0.7);
glEndList();

glEnable(GL_NORMALIZE);

if (argc > 1 && strcmp(argv[1], “-info”)==0) {
printf(“GL_RENDERER = %s\n”, (char *) glGetString(GL_RENDERER));
printf(“GL_VERSION = %s\n”, (char *) glGetString(GL_VERSION));
printf(“GL_VENDOR = %s\n”, (char *) glGetString(GL_VENDOR));
printf(“GL_EXTENSIONS = %s\n”, (char *) glGetString(GL_EXTENSIONS));
}
}

int main(int argc, char *argv[])
{
SDL_Surface *screen;
int done;
Uint8 *keys;

SDL_Init(SDL_INIT_VIDEO);

screen = SDL_SetVideoMode(640, 480, 16, SDL_OPENGL|SDL_FULLSCREEN);
if ( ! screen ) {
fprintf(stderr, “Couldn’t set 300x300 GL video mode: %s\n”, SDL_GetError());
SDL_Quit();
exit(2);
}
SDL_WM_SetCaption(“Gears”, “gears”);

init(argc, argv);
reshape(screen->w, screen->h);
done = 0;
while ( ! done ) {
SDL_Event event;

idle();
while ( SDL_PollEvent(&event) ) {
  switch(event.type) {
    case SDL_VIDEORESIZE:
      screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 16,
                                SDL_OPENGL|SDL_RESIZABLE);
      if ( screen ) {
        reshape(screen->w, screen->h);
      } else {
        /* Uh oh, we couldn't set the new video mode?? */;
      }
      break;

    case SDL_QUIT:
      done = 1;
      break;
  }
}
keys = SDL_GetKeyState(NULL);

if ( keys[SDLK_ESCAPE] ) {
  done = 1;
}
if ( keys[SDLK_UP] ) {
  view_rotx += 5.0;
}
if ( keys[SDLK_DOWN] ) {
  view_rotx -= 5.0;
}
if ( keys[SDLK_LEFT] ) {
  view_roty += 5.0;
}
if ( keys[SDLK_RIGHT] ) {
  view_roty -= 5.0;
}
if ( keys[SDLK_z] ) {
  if ( SDL_GetModState() & KMOD_SHIFT ) {
    view_rotz -= 5.0;
  } else {
    view_rotz += 5.0;
  }
}

draw();

}
SDL_Quit();
return 0; /* ANSI C requires main to return int. */
}