void glutDestroyWindow(int win)
{
   glFBDevMakeCurrent( NULL, NULL, NULL);
   glFBDevDestroyContext(Context);
   glFBDevDestroyBuffer(Buffer);
   glFBDevDestroyVisual(Visual);
  
   Visual = NULL;
}
int glutCreateWindow (const char *title)
{
   if(Initialized == 0) {
      int argc = 0;
      char *argv[] = {NULL};
      glutInit(&argc, argv);
   }

   if(Context)
      return 0;

   if(DisplayMode & GLUT_INDEX)
      VarInfo.bits_per_pixel = 8;
   else
      if(VarInfo.bits_per_pixel == 8)
	 VarInfo.bits_per_pixel = 32;
    
   if (DesiredDepth)
      VarInfo.bits_per_pixel = DesiredDepth;

   VarInfo.xoffset = 0;
   VarInfo.yoffset = 0;
   VarInfo.nonstd = 0;
   VarInfo.vmode &= ~FB_VMODE_YWRAP; /* turn off scrolling */

   SetVideoMode();
   CreateVisual();
   CreateBuffer();

   if(!(Context = glFBDevCreateContext(Visual, NULL))) {
      sprintf(exiterror, "Failure to create Context\n");
      exit(0);
   }

   if(!glFBDevMakeCurrent( Context, Buffer, Buffer )) {
      sprintf(exiterror, "Failure to Make Current\n");
      exit(0);
   }

   InitializeCursor();
   InitializeMenus();

   glutSetWindowTitle(title);

   signal(SIGWINCH, SignalWinch);

   Visible = 1;
   VisibleSwitch = 1;
   Redisplay = 1;
   return 1;
}
Example #3
0
void
glFBDevDestroyBuffer( GLFBDevBufferPtr buffer )
{
   if (buffer) {
      /* check if destroying the current buffer */
      GLFBDevBufferPtr curDraw = glFBDevGetCurrentDrawBuffer();
      GLFBDevBufferPtr curRead = glFBDevGetCurrentReadBuffer();
      if (buffer == curDraw || buffer == curRead) {
         glFBDevMakeCurrent( NULL, NULL, NULL);
      }
      {
         struct gl_framebuffer *fb = &buffer->glframebuffer;
         _mesa_reference_framebuffer(&fb, NULL);
      }
   }
}
void glutLeaveGameMode(void)
{
   if(!GameMode)
      return;

   glFBDevDestroyContext(GameContext);
   glFBDevDestroyVisual(Visual);

   VarInfo = NormVarInfo;
   Visual = NormVisual;
   
   if(Visual) {
      SetVideoMode();
      CreateBuffer();
   
      if(!glFBDevMakeCurrent( Context, Buffer, Buffer )) {
	 sprintf(exiterror, "Failure to Make Current\n");
	 exit(0);
      }
      
      Redisplay = 1;
   }

   KeyboardFunc = KeyFuncs[0];
   KeyboardUpFunc = KeyFuncs[1];

   DisplayFunc = NormFuncs[0];
   ReshapeFunc = NormFuncs[1];
   MouseFunc = NormFuncs[2];
   MotionFunc = NormFuncs[3];
   PassiveMotionFunc = NormFuncs[4];
   VisibilityFunc = NormFuncs[5];
   SpecialFunc = NormFuncs[6];
   SpecialUpFunc = NormFuncs[7];

   GameMode = 0;
}
Example #5
0
static void
gltest( void )
{
   static const int attribs[] = {
      GLFBDEV_DOUBLE_BUFFER,
      GLFBDEV_DEPTH_SIZE, 16,
      GLFBDEV_NONE
   };
   GLFBDevContextPtr ctx;
   GLFBDevBufferPtr buf;
   GLFBDevVisualPtr vis;
   int bytes, r, g, b, a;
   float ang;

   printf("GLFBDEV_VENDOR = %s\n", glFBDevGetString(GLFBDEV_VENDOR));
   printf("GLFBDEV_VERSION = %s\n", glFBDevGetString(GLFBDEV_VERSION));

   /* framebuffer size */
   bytes = VarInfo.xres_virtual * VarInfo.yres_virtual * VarInfo.bits_per_pixel / 8;

   vis = glFBDevCreateVisual( &FixedInfo, &VarInfo, attribs );
   assert(vis);

   buf = glFBDevCreateBuffer( &FixedInfo, &VarInfo, vis, FrameBuffer, NULL, bytes );
   assert(buf);

   ctx = glFBDevCreateContext( vis, NULL );
   assert(buf);

   b = glFBDevMakeCurrent( ctx, buf, buf );
   assert(b);

   /*printf("GL_EXTENSIONS: %s\n", glGetString(GL_EXTENSIONS));*/
   glGetIntegerv(GL_RED_BITS, &r);
   glGetIntegerv(GL_GREEN_BITS, &g);
   glGetIntegerv(GL_BLUE_BITS, &b);
   glGetIntegerv(GL_ALPHA_BITS, &a);
   printf("RED_BITS=%d GREEN_BITS=%d BLUE_BITS=%d ALPHA_BITS=%d\n",
          r, g, b, a);

   glClearColor(0.5, 0.5, 1.0, 0);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   glFrustum(-1, 1, -1, 1, 2, 30);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glTranslatef(0, 0, -15);
   glViewport(0, 0, VarInfo.xres_virtual, VarInfo.yres_virtual);
   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);
   glEnable(GL_DEPTH_TEST);

   for (ang = 0; ang <= 180; ang += 15) {
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      glPushMatrix();
      glRotatef(ang, 1, 0, 0);
      glutSolidTorus(1, 3, 40, 20);
      glPopMatrix();
      glFBDevSwapBuffers(buf);
   }

   /* clean up */
   b = glFBDevMakeCurrent( NULL, NULL, NULL);
   assert(b);

   glFBDevDestroyContext(ctx);
   glFBDevDestroyBuffer(buf);
   glFBDevDestroyVisual(vis);
}
int glutEnterGameMode(void)
{
   if(ActiveMenu)
      return 0;

   if(!ModePossible)
      return 0;

   if(GameMode) {
      if(!memcmp(&GameVarInfo, &VarInfo, sizeof VarInfo)) {
	 DispChanged = 0;
	 return 1;
      }
      glutLeaveGameMode();
   }

   if (ioctl(FrameBufferFD, FBIOPUT_VSCREENINFO, &GameVarInfo))
      return 0;

   NormVarInfo = VarInfo;
   VarInfo = GameVarInfo;

   NormVisual = Visual;
   SetVideoMode();
   CreateVisual();
   CreateBuffer();

   if(!(GameContext = glFBDevCreateContext(Visual, NULL))) {
      sprintf(exiterror, "Failure to create Context\n");
      exit(0);
   }

   if(!glFBDevMakeCurrent( GameContext, Buffer, Buffer )) {
      sprintf(exiterror, "Failure to Make Game Current\n");
      exit(0);
   }

   InitializeCursor();

   KeyFuncs[0] = KeyboardFunc;
   KeyFuncs[1] = KeyboardUpFunc;

   NormFuncs[0] = DisplayFunc;
   NormFuncs[1] = ReshapeFunc;
   NormFuncs[2] = MouseFunc;
   NormFuncs[3] = MotionFunc;
   NormFuncs[4] = PassiveMotionFunc;
   NormFuncs[5] = VisibilityFunc;
   NormFuncs[6] = SpecialFunc;
   NormFuncs[7] = SpecialUpFunc;

   DisplayFunc = NULL;
   ReshapeFunc = NULL;
   KeyboardFunc = NULL;
   KeyboardUpFunc = NULL;
   MouseFunc = NULL;
   MotionFunc = NULL;
   PassiveMotionFunc = NULL;
   VisibilityFunc = NULL;
   SpecialFunc = SpecialUpFunc = NULL;

   DispChanged = 1;
   GameMode = 1;
   Visible = 1;
   VisibleSwitch = 1;
   Redisplay = 1;
   return 1;
}
void glutMainLoop(void)
{
   int idleiters;

   if(ReshapeFunc)
      ReshapeFunc(VarInfo.xres, VarInfo.yres);

   if(!DisplayFunc) {
      sprintf(exiterror, "Fatal Error: No Display Function registered\n");
      exit(0);
   }   

   for(;;) {
      ProcessTimers();

      if(Active)
	 ReceiveInput();
      else
	 if(VisiblePoll)
	    TestVisible();

      if(IdleFunc)
	 IdleFunc();
      
      if(VisibleSwitch) {
	 VisibleSwitch = 0;
	 if(VisibilityFunc)
	    VisibilityFunc(Visible ? GLUT_VISIBLE : GLUT_NOT_VISIBLE);
      }

      if(Resized) {
         SetVideoMode();
         CreateBuffer();

         if(!glFBDevMakeCurrent( Context, Buffer, Buffer )) {
            sprintf(exiterror, "Failure to Make Current\n");
            exit(0);
         }

         InitializeMenus();

         if(ReshapeFunc)
            ReshapeFunc(VarInfo.xres, VarInfo.yres);

         Redisplay = 1;
         Resized = 0;
      }

      if(Visible && Redisplay) {
	 Redisplay = 0;
         EraseCursor();
	 DisplayFunc();
	 if(!(DisplayMode & GLUT_DOUBLE)) {
	    if(ActiveMenu)
	       DrawMenus();
            DrawCursor();
	 }
         idleiters = 0;
      } else {
         /* we sleep if not receiving redisplays, and
            the main loop is running faster than 2khz */

         static int lasttime;
         int time = glutGet(GLUT_ELAPSED_TIME);
         if(time > lasttime) {
            if(idleiters >= 2)
               usleep(100);

            idleiters = 0;
            lasttime = time;
         }
         idleiters++;         
      }
   }
}