FMudanyali/FreeGLUT-Vita
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

There should be no changes to code functionality, though a fair bit of

Browse Source 
little changes to the code appearance.

 * Fit the comments at the start of the file to fit 80 columns.
 * Noted an unusual feature of the ATTRIB() macro.
 * Added ATTRIB_VAL() macro which is really just two ATTRIB()s.
   This lets us put things like {ATTRIB (GLX_RED_SIZE); ATTRIB (1);}
   on one statement: {ATTRIB_VAL (GLX_RED_SIZE, 1);}.
   I did this to preserve some of the layout of information while also
   avoiding the nasty semi-visible ";" in the middle of a line of code.
   And by putting the {braces} in the macro definition, I was able to
   visually clean code of the form:
       if (condition)
       {
           ATTRIB( X ); ATTRIB( 1 );
       }
   ...rewriting as:
       if (condition)
           ATTRIB_VAL( X, 1 );
 * Eliminated a bunch of say-nothing-new comments in fgChooseVisual().
 * Combined some semi-useful comments into a block comment summarizing
   a loop.


git-svn-id: https://svn.code.sf.net/p/freeglut/code/trunk@272 7f0cb862-5218-0410-a997-914c9d46530a
This commit is contained in:
rkrolib 2003-10-31 03:37:27 +00:00
parent 92b5fb9d59
commit 807042d126
1 changed files with 35 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
freeglut/freeglut/src/freeglut_window.c
View File

@ -41,8 +41,8 @@
* fgSetupPixelFormat -- ignores the display mode settings
* fgOpenWindow() -- check the Win32 version, -iconic handling!
* fgCloseWindow() -- check the Win32 version
* glutCreateWindow() -- see what happens when default position and size is {-1,-1}
* glutCreateSubWindow() -- see what happens when default position and size is {-1,-1}
* glutCreateWindow() -- Check when default position and size is {-1,-1}
* glutCreateSubWindow() -- Check when default position and size is {-1,-1}
* glutDestroyWindow() -- check the Win32 version
* glutSetWindow() -- check the Win32 version
* glutGetWindow() -- OK
@ -66,7 +66,8 @@
XVisualInfo* fgChooseVisual( void )
{
int bufferSize[] = { 16, 12, 8, 4, 2, 1 };
#define BUFFER_SIZES 6
int bufferSize[BUFFER_SIZES] = { 16, 12, 8, 4, 2, 1 };
GLboolean wantIndexedMode = FALSE;
int attributes[ 32 ];
int where = 0;
@ -74,90 +75,47 @@ XVisualInfo* fgChooseVisual( void )
/*
* First we have to process the display mode settings...
*/
# define ATTRIB(a) attributes[where++]=a;
/*
* Why is there a semi-colon in this #define? The code
* that uses the macro seems to always add more semicolons...
*/
#define ATTRIB(a) attributes[where++]=a;
#define ATTRIB_VAL(a,v) {ATTRIB(a); ATTRIB(v);}
/*
* Decide if we want a true or indexed color visual:
*/
if( !(fgState.DisplayMode & GLUT_INDEX) )
if( fgState.DisplayMode & GLUT_INDEX )
{
/*
* We are sure that there will be R, B and B components requested:
*/
ATTRIB( GLX_RGBA );
ATTRIB( GLX_RED_SIZE ); ATTRIB( 1 );
ATTRIB( GLX_GREEN_SIZE ); ATTRIB( 1 );
ATTRIB( GLX_BLUE_SIZE ); ATTRIB( 1 );
/*
* Check if the A component is required, too:
*/
if( fgState.DisplayMode & GLUT_ALPHA )
{
ATTRIB( GLX_ALPHA_SIZE ); ATTRIB( 1 );
}
ATTRIB_VAL( GLX_BUFFER_SIZE, 8 );
wantIndexedMode = TRUE;
}
else
{
/*
* We've got an indexed color request
*/
ATTRIB( GLX_BUFFER_SIZE ); ATTRIB( 8 );
/*
* Set the 'I want indexed mode' switch
*/
wantIndexedMode = TRUE;
ATTRIB( GLX_RGBA );
ATTRIB_VAL( GLX_RED_SIZE, 1 );
ATTRIB_VAL( GLX_GREEN_SIZE, 1 );
ATTRIB_VAL( GLX_BLUE_SIZE, 1 );
if( fgState.DisplayMode & GLUT_ALPHA )
ATTRIB_VAL( GLX_ALPHA_SIZE, 1 );
}
/*
* We can have double or single buffered contexts created
*/
if( fgState.DisplayMode & GLUT_DOUBLE )
{
ATTRIB( GLX_DOUBLEBUFFER );
}
/*
* Stereoscopy seems a nice thing to have
*/
if( fgState.DisplayMode & GLUT_STEREO )
{
ATTRIB( GLX_STEREO );
}
/*
* Depth buffer is almost always required
*/
if( fgState.DisplayMode & GLUT_DEPTH )
{
ATTRIB( GLX_DEPTH_SIZE ); ATTRIB( 1 );
}
ATTRIB_VAL( GLX_DEPTH_SIZE, 1 );
/*
* Stenciling support
*/
if( fgState.DisplayMode & GLUT_STENCIL )
{
ATTRIB( GLX_STENCIL_SIZE ); ATTRIB( 1 );
}
ATTRIB_VAL( GLX_STENCIL_SIZE, 1 );
/*
* And finally the accumulation buffers
*/
if( fgState.DisplayMode & GLUT_ACCUM )
{
ATTRIB( GLX_ACCUM_RED_SIZE ); ATTRIB( 1 );
ATTRIB( GLX_ACCUM_GREEN_SIZE ); ATTRIB( 1 );
ATTRIB( GLX_ACCUM_BLUE_SIZE ); ATTRIB( 1 );
/*
* Check if the A component is required, too:
*/
ATTRIB_VAL( GLX_ACCUM_RED_SIZE, 1 );
ATTRIB_VAL( GLX_ACCUM_GREEN_SIZE, 1 );
ATTRIB_VAL( GLX_ACCUM_BLUE_SIZE, 1 );
if( fgState.DisplayMode & GLUT_ALPHA )
{
ATTRIB( GLX_ACCUM_ALPHA_SIZE ); ATTRIB( 1 );
}
ATTRIB_VAL( GLX_ACCUM_ALPHA_SIZE, 1 );
}
/*
@ -165,48 +123,28 @@ XVisualInfo* fgChooseVisual( void )
*/
ATTRIB( None );
/*
* OKi now, we've got two cases -- RGB(A) and index mode visuals
*/
if( wantIndexedMode == FALSE )
{
/*
* The easier one. And more common, too.
*/
return( glXChooseVisual( fgDisplay.Display, fgDisplay.Screen, attributes ) );
}
return glXChooseVisual( fgDisplay.Display, fgDisplay.Screen,
attributes );
else
{
XVisualInfo* visualInfo;
int i;
/*
* In indexed mode, we need to check how many bits of depth can we achieve
* In indexed mode, we need to check how many bits of depth can we
* achieve. We do this by trying each possibility from the list
* given in the {bufferSize} array. If we match, we return to caller.
*/
for( i=0; i<6; i++ )
for( i=0; i<BUFFER_SIZES; i++ )
{
/*
* The GLX_BUFFER_SIZE value comes always first, so:
*/
attributes[ 1 ] = bufferSize[ i ];
/*
* Check if such visual is possible
*/
visualInfo = glXChooseVisual( fgDisplay.Display, fgDisplay.Screen, attributes );
/*
* The buffer size are sorted in descendant order, so choose the first:
*/
visualInfo = glXChooseVisual( fgDisplay.Display, fgDisplay.Screen,
attributes );
if( visualInfo != NULL )
return( visualInfo );
return visualInfo;
}
/*
* If we are still here, it means that the visual info was not found
*/
return( NULL );
return NULL;
}
}
#endif