macosx_glimp.m

quakeIII源码这个不用我多说吧

/*
** GLW_InitExtensions
*/
static void GLW_InitExtensions( void )
{
        if ( !r_allowExtensions->integer )
        {
                ri.Printf( PRINT_ALL, "*** IGNORING OPENGL EXTENSIONS ***\n" );
                return;
        }

        ri.Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
        ri.Printf( PRINT_ALL, "... Supported extensions are %s\n", glConfig.extensions_string);
        
        // GL_S3_s3tc
        glConfig.textureCompression = TC_NONE;
        if ( strstr( glConfig.extensions_string, "GL_S3_s3tc" ) )
        {
                if ( r_ext_compressed_textures->integer )
                {
                        glConfig.textureCompression = TC_S3TC;
                        ri.Printf( PRINT_ALL, "...using GL_S3_s3tc\n" );
                }
                else
                {
                        glConfig.textureCompression = TC_NONE;
                        ri.Printf( PRINT_ALL, "...ignoring GL_S3_s3tc\n" );
                }
        }
        else
        {
                ri.Printf( PRINT_ALL, "...GL_S3_s3tc not found\n" );
        }


#ifdef GL_EXT_texture_env_add
        // GL_EXT_texture_env_add
        glConfig.textureEnvAddAvailable = qfalse;
        if ( strstr( glConfig.extensions_string, "GL_EXT_texture_env_add" ) )
        {
                if ( r_ext_texture_env_add->integer )
                {
                        glConfig.textureEnvAddAvailable = qtrue;
                        ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
                }
                else
                {
                        glConfig.textureEnvAddAvailable = qfalse;
                        ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
                }
        }
        else
        {
                ri.Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
        }
#endif

#ifdef GL_ARB_texture_env_add
        // GL_ARB_texture_env_add -- only if we didn't find GL_EXT_texture_env_add
        if (!glConfig.textureEnvAddAvailable) {
            if ( strstr( glConfig.extensions_string, "GL_ARB_texture_env_add" ) )
            {
                    if ( r_ext_texture_env_add->integer )
                    {
                            glConfig.textureEnvAddAvailable = qtrue;
                            ri.Printf( PRINT_ALL, "...using GL_ARB_texture_env_add\n" );
                    }
                    else
                    {
                            glConfig.textureEnvAddAvailable = qfalse;
                            ri.Printf( PRINT_ALL, "...ignoring GL_ARB_texture_env_add\n" );
                    }
            }
            else
            {
                    ri.Printf( PRINT_ALL, "...GL_ARB_texture_env_add not found\n" );
            }
        }
#endif


#if 0   // Win32 does this differently than we do -- I'll provide a C function that looks the same
        // that will do the correct ObjC stuff
        // WGL_EXT_swap_control
        qwglSwapIntervalEXT = ( BOOL (WINAPI *)(int)) qwglGetProcAddress( "wglSwapIntervalEXT" );
        if ( qwglSwapIntervalEXT )
        {
                ri.Printf( PRINT_ALL, "...using WGL_EXT_swap_control\n" );
                r_swapInterval->modified = qtrue;	// force a set next frame
        }
        else
        {
                ri.Printf( PRINT_ALL, "...WGL_EXT_swap_control not found\n" );
        }
#else
        if (r_swapInterval) {
            ri.Printf( PRINT_ALL, "...using +[NSOpenGLContext setParameter:] for qwglSwapIntervalEXT\n" );
            r_swapInterval->modified = qtrue;	// force a set next frame
        }
#endif
        
        // GL_ARB_multitexture
        qglMultiTexCoord2fARB = NULL;
        qglActiveTextureARB = NULL;
        qglClientActiveTextureARB = NULL;
        if ( strstr( glConfig.extensions_string, "GL_ARB_multitexture" )  )
        {
                if ( r_ext_multitexture->integer )
                {
                        qglMultiTexCoord2fARB = ( PFNGLMULTITEXCOORD2FARBPROC ) qwglGetProcAddress( "glMultiTexCoord2fARB" );
                        qglActiveTextureARB = ( PFNGLACTIVETEXTUREARBPROC ) qwglGetProcAddress( "glActiveTextureARB" );
                        qglClientActiveTextureARB = ( PFNGLCLIENTACTIVETEXTUREARBPROC ) qwglGetProcAddress( "glClientActiveTextureARB" );

                        if ( qglActiveTextureARB )
                        {
                                qglGetIntegerv( GL_MAX_ACTIVE_TEXTURES_ARB, (GLint *)&glConfig.maxActiveTextures );

                                if ( glConfig.maxActiveTextures > 1 )
                                {
                                        ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
                                }
                                else
                                {
                                        qglMultiTexCoord2fARB = NULL;
                                        qglActiveTextureARB = NULL;
                                        qglClientActiveTextureARB = NULL;
                                        ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
                                }
                        }
                }
                else
                {
                        ri.Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
                }
        }
        else
        {
                ri.Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
        }

        // GL_EXT_compiled_vertex_array
        qglLockArraysEXT = NULL;
        qglUnlockArraysEXT = NULL;
        if ( strstr( glConfig.extensions_string, "GL_EXT_compiled_vertex_array" ) && ( glConfig.hardwareType != GLHW_RIVA128 ) )
        {
                if ( r_ext_compiled_vertex_array->integer )
                {
                        ri.Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
                        qglLockArraysEXT = ( void ( APIENTRY * )( GLint, GLint ) ) qwglGetProcAddress( "glLockArraysEXT" );
                        qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) ) qwglGetProcAddress( "glUnlockArraysEXT" );
                        if (!qglLockArraysEXT || !qglUnlockArraysEXT) {
                                ri.Error (ERR_FATAL, "bad getprocaddress\n");
                        }
                }
                else
                {
                        ri.Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
                }
        }
        else
        {
                ri.Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
        }

#ifdef GL_APPLE_transform_hint
        if ( strstr( glConfig.extensions_string, "GL_APPLE_transform_hint" )  ) {
            r_appleTransformHint = ri.Cvar_Get("r_appleTransformHint", "1", CVAR_ARCHIVE );
            if (r_appleTransformHint->value) {
                ri.Printf( PRINT_ALL, "...using GL_APPLE_transform_hint\n");
                qglHint(GL_TRANSFORM_HINT_APPLE, GL_FASTEST);
                CheckErrors();
            } else {
                ri.Printf( PRINT_ALL, "...ignoring using GL_APPLE_transform_hint\n");
            }
        } else {
            ri.Printf( PRINT_ALL, "...GL_APPLE_transform_hint not found\n" );
        }
#endif
}


#define MAX_RENDERER_INFO_COUNT 128

// Returns zero if there are no hardware renderers.  Otherwise, returns the max memory across all renderers (on the presumption that the screen that we'll use has the most memory).
static unsigned long Sys_QueryVideoMemory()
{
    CGLError err;
    CGLRendererInfoObj rendererInfo, rendererInfos[MAX_RENDERER_INFO_COUNT];
    long rendererInfoIndex, rendererInfoCount = MAX_RENDERER_INFO_COUNT;
    long rendererIndex, rendererCount;
    long maxVRAM = 0, vram;
    long accelerated;
    long rendererID;
    long totalRenderers = 0;
    
    err = CGLQueryRendererInfo(CGDisplayIDToOpenGLDisplayMask(Sys_DisplayToUse()), rendererInfos, &rendererInfoCount);
    if (err) {
        Com_Printf("CGLQueryRendererInfo -> %d\n", err);
        return vram;
    }
    
    //Com_Printf("rendererInfoCount = %d\n", rendererInfoCount);
    for (rendererInfoIndex = 0; rendererInfoIndex < rendererInfoCount && totalRenderers < rendererInfoCount; rendererInfoIndex++) {
        rendererInfo = rendererInfos[rendererInfoIndex];
        //Com_Printf("rendererInfo: 0x%08x\n", rendererInfo);
        

        err = CGLDescribeRenderer(rendererInfo, 0, kCGLRPRendererCount, &rendererCount);
        if (err) {
            Com_Printf("CGLDescribeRenderer(kCGLRPRendererID) -> %d\n", err);
            continue;
        }
        //Com_Printf("  rendererCount: %d\n", rendererCount);

        for (rendererIndex = 0; rendererIndex < rendererCount; rendererIndex++) {
            totalRenderers++;
            //Com_Printf("  rendererIndex: %d\n", rendererIndex);
            
            rendererID = 0xffffffff;
            err = CGLDescribeRenderer(rendererInfo, rendererIndex, kCGLRPRendererID, &rendererID);
            if (err) {
                Com_Printf("CGLDescribeRenderer(kCGLRPRendererID) -> %d\n", err);
                continue;
            }
            //Com_Printf("    rendererID: 0x%08x\n", rendererID);
            
            accelerated = 0;
            err = CGLDescribeRenderer(rendererInfo, rendererIndex, kCGLRPAccelerated, &accelerated);
            if (err) {
                Com_Printf("CGLDescribeRenderer(kCGLRPAccelerated) -> %d\n", err);
                continue;
            }
            //Com_Printf("    accelerated: %d\n", accelerated);
            if (!accelerated)
                continue;
            
            vram = 0;
            err = CGLDescribeRenderer(rendererInfo, rendererIndex, kCGLRPVideoMemory, &vram);
            if (err) {
                Com_Printf("CGLDescribeRenderer -> %d\n", err);
                continue;
            }
            //Com_Printf("    vram: 0x%08x\n", vram);
            
            // presumably we'll be running on the best card, so we'll take the max of the vrams
            if (vram > maxVRAM)
                maxVRAM = vram;
        }
        
#if 0
        err = CGLDestroyRendererInfo(rendererInfo);
        if (err) {
            Com_Printf("CGLDestroyRendererInfo -> %d\n", err);
        }
#endif
    }

    return maxVRAM;
}


// We will set the Sys_IsHidden global to cause input to be handle differently (we'll just let NSApp handle events in this case).  We also will unbind the GL context and restore the video mode.
qboolean Sys_Hide()
{
    if (Sys_IsHidden)
        // Eh?
        return qfalse;
    
    if (!r_fullscreen->integer)
        // We only support hiding in fullscreen mode right now
        return qfalse;
    
    Sys_IsHidden = qtrue;

    // Don't need to store the current gamma since we always keep it around in glw_state.inGameTable.

    Sys_FadeScreen(Sys_DisplayToUse());

    // Disassociate the GL context from the screen
    // Have to call both to actually deallocate kernel resources and free the NSSurface
    CGLClearDrawable(OSX_GetCGLContext());
    [OSX_GetNSGLContext() clearDrawable];
    
    // Restore the original video mode
    _GLimp_RestoreOriginalVideoSettings();

    // Restore the original gamma if needed.
    if (glConfig.deviceSupportsGamma) {
        CGDisplayRestoreColorSyncSettings();
    }

    // Release the screen(s)
    ReleaseAllDisplays();
    
    Sys_UnfadeScreens();
    
    // Shut down the input system so the mouse and keyboard settings are restore to normal
    Sys_ShutdownInput();
    
    // Hide the application so that when the user clicks on our app icon, we'll get an unhide notification
    [NSApp hide: nil];
    
    return qtrue;
}

static CGDisplayErr Sys_CaptureActiveDisplays(void)
{
    CGDisplayErr err;
    CGDisplayCount displayIndex;
    for (displayIndex = 0; displayIndex < glw_state.displayCount; displayIndex++) {
	const glwgamma_t *table;
	table = &glw_state.originalDisplayGammaTables[displayIndex];
	err = CGDisplayCapture(table->display);
	if (err != CGDisplayNoErr)
	    return err;
    }
    return CGDisplayNoErr;
}

qboolean Sys_Unhide()
{
    CGDisplayErr err;
    CGLError glErr;
    
    if (!Sys_IsHidden)
        // Eh?
        return qfalse;
        
    Sys_FadeScreens();

    // Capture the screen(s)
    err = Sys_CaptureActiveDisplays();
    if (err != CGDisplayNoErr) {
        Sys_UnfadeScreens();
        ri.Printf( PRINT_ALL, "Unhide failed -- cannot capture the display again.\n" );
        return qfalse;
    }
    
    // Restore the game mode
    err = CGDisplaySwitchToMode(glw_state.display, (CFDictionaryRef)glw_state.gameMode);
    if ( err != CGDisplayNoErr ) {
        ReleaseAllDisplays();
        Sys_UnfadeScreens();
        ri.Printf( PRINT_ALL, "Unhide failed -- Unable to set display mode\n" );
        return qfalse;
    }

    // Reassociate the GL context and the screen
    glErr = CGLSetFullScreen(OSX_GetCGLContext());
    if (err) {
        ReleaseAllDisplays();
        Sys_UnfadeScreens();
        ri.Printf( PRINT_ALL, "Unhide failed: CGLSetFullScreen -> %d (%s)\n", err, CGLErrorString(err));
        return qfalse;
    }

    // Restore the current context
    [OSX_GetNSGLContext() makeCurrentContext];
    
    // Restore the gamma that the game had set
    Sys_UnfadeScreen(Sys_DisplayToUse(), &glw_state.inGameTable);
    
    // Restore the input system (last so if something goes wrong we don't eat the mouse)
    Sys_InitInput();
    
    Sys_IsHidden = qfalse;
    return qtrue;
}