Windows GL Multisample Tutorial(ish)

[Baker]

Quick and dirty "mostly a tutorial" on implementing multisample in Windows/OpenGL.

Step 1: Use the "Starting Quake Dialog". Multisample requires restarting the OpenGL window (and doing a DestroyWindow too, to the best of my knowledge). This is annoying and causes the screen to flash. Since I do not want that, I have the "Starting Quake" window create a GL context and check for multisample there.

sys_win.c

Code: Select all

#if 1 //johnfitz -- 0 to supress the 'starting quake' dialog
	if (!isDedicated)
	{
		wplat.hwnd_dialog = CreateDialog(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), NULL, NULL);

		if (wplat.hwnd_dialog)
		{
			RECT rect;
			GetWindowRect (wplat.hwnd_dialog, &rect);
			WIN_AdjustRectToCenterScreen (&rect);
			SetWindowPos
			(
				wplat.hwnd_dialog,
				NULL,
				rect.left,
				rect.top,
				0,
				0,
				SWP_NOZORDER | SWP_NOSIZE
			);
			ShowWindow (wplat.hwnd_dialog, SW_SHOWDEFAULT);
			UpdateWindow (wplat.hwnd_dialog);
			SetForegroundWindow (wplat.hwnd_dialog);
		}
	}
#endif

Step 2: Kill multiple bitsperpixel support in your engine and instead ALWAYS use the desktop resolution. This is going to be 32 bits per pixel for 99.999999% and it won't the 5 people that use 16 bits per pixel.

Grabbing desktop bpp =

Code: Select all

vmode_t VID_Local_GetDesktopProperties (void)
{
	DEVMODE	devmode;
	vmode_t desktop = {0};

	if (!EnumDisplaySettings (NULL, ENUM_CURRENT_SETTINGS, &devmode))
	{
		Sys_Error ("VID_UpdateDesktopProperties: EnumDisplaySettings failed\n");
		return desktop;
	}

	desktop.type		=	MODE_FULLSCREEN;
	desktop.width		=	devmode.dmPelsWidth;
	desktop.height		=	devmode.dmPelsHeight;
	desktop.bpp			=	devmode.dmBitsPerPel;
	
	return desktop;
}

Step 3: When you are closing the starting Quake dialog, take the time to get available pixel format info and check wgl extensions and poke around for multisample. If you find it, you'll get an "int" value of the pixel format you want, which you will use instead of querying the pfd.

Code: Select all

	if (wplat.hwnd_dialog)
	{
		if (vid_multisample.value)
		{
			// Poke into it for the PFD
			HDC	hdc			= GetDC(wplat.hwnd_dialog);
			int unused		= WIN_SetupPixelFormat (hdc);
			HGLRC wglHRC	= wglCreateContext( hdc );
			HDC wglHDC 		= wglGetCurrentDC();
			int unused2		= wglMakeCurrent( hdc, wglHRC);
			int ask_samples	= (int)vid_multisample.value;

			if (ask_samples != 2 && ask_samples != 4 && ask_samples != 8)
			{
				Con_Warning ("Multisamples requested \"%i\" is invalid, trying 4\n", ask_samples);
				ask_samples = 4;
			}

			// Do it.  We already have desktop properties
			wplat.multisamples = WIN_InitMultisample (wplat.hInstance, wplat.hwnd_dialog, wplat.pfd, ask_samples, &wplat.forcePixelFormat);

			// Your mission is complete.  You may leave now ...		
			wglMakeCurrent(NULL, NULL);
			wglDeleteContext(wglHRC);
			ReleaseDC(wplat.hwnd_dialog, wglHDC);
			ReleaseDC(wplat.hwnd_dialog, hdc);

			if (wplat.multisamples)
				Con_Printf ("Multisample x %i Enabled (Requested %i, Received %i).\n", wplat.multisamples, ask_samples, wplat.multisamples);
			else Con_Warning ("Multisample: Requested but not available.\n");
		} else Con_Printf ("Note: Multisample not requested\n");

		// Post teardown
		DestroyWindow (wplat.hwnd_dialog);
		wplat.hwnd_dialog = NULL;
	}

4. My modified PFD function looks like this:

Code: Select all

BOOL WIN_SetupPixelFormat (HDC hDC)
{
    static PIXELFORMATDESCRIPTOR pfd = {
	sizeof(PIXELFORMATDESCRIPTOR),	// size of this pfd
	1,						// version number
	PFD_DRAW_TO_WINDOW |	// support window
	PFD_SUPPORT_OPENGL |	// support OpenGL
	PFD_DOUBLEBUFFER,		// double buffered
	PFD_TYPE_RGBA,			// RGBA type
	24,						// 24-bit color depth
	0, 0, 0, 0, 0, 0,		// color bits ignored
	0,						// no alpha buffer
	0,						// shift bit ignored
	0,						// no accumulation buffer
	0, 0, 0, 0, 			// accum bits ignored
	32,						// 32-bit z-buffer
	8,						// 8-bit stencil buffer
	0,						// no auxiliary buffer
	PFD_MAIN_PLANE,			// main layer
	0,						// reserved
	0, 0, 0					// layer masks ignored
    };
    int pixelformat;
	PIXELFORMATDESCRIPTOR  test; //johnfitz

#ifdef SUPPORTS_MULTISAMPLE // Baker change
	if (!wplat.multisamples)
	{
#endif // Baker change + #ifdef SUPPORTS_MULTISAMPLE // Baker change
		if ( (pixelformat = ChoosePixelFormat(hDC, &pfd)) == 0 )
		{
			Sys_Error ("Video: ChoosePixelFormat failed");
			return FALSE;
		}
#ifdef SUPPORTS_MULTISAMPLE // Baker change
	} else pixelformat = wplat.forcePixelFormat; // Multisample overrride
#endif // Baker change + #ifdef SUPPORTS_MULTISAMPLE // Baker change

	DescribePixelFormat(hDC, pixelformat, sizeof(PIXELFORMATDESCRIPTOR), &test);

    if (SetPixelFormat(hDC, pixelformat, &pfd) == FALSE)
    {
        Sys_Error ("SetPixelFormat failed");
        return FALSE;
    }

#ifdef SUPPORTS_MULTISAMPLE // Baker change
	memcpy (&wplat.pfd, &pfd, sizeof(pfd) );
#endif // Baker change + #ifdef SUPPORTS_MULTISAMPLE // Baker change
    return TRUE;
}

5. The function to check for multisample availability, mostly from NeHe and modified some while looking at FTE's implementation.

Code: Select all

#include "vid_wglext.h"		//WGL extensions

int	arbMultisampleSupported	= false;
int		arbMultisampleFormat	= 0;

// WGLisExtensionSupported: This Is A Form Of The Extension For WGL
int WGLisExtensionSupported(const char *extension)
{
	const size_t extlen = strlen(extension);
	const char *supported = NULL;
	const char* p;

	// Try To Use wglGetExtensionStringARB On Current DC, If Possible
	PROC wglGetExtString = wglGetProcAddress("wglGetExtensionsStringARB");

	if (wglGetExtString)
		supported = ((char*(__stdcall*)(HDC))wglGetExtString)(wglGetCurrentDC());

	// If That Failed, Try Standard Opengl Extensions String
	if (supported == NULL)
		supported = (char*)glGetString(GL_EXTENSIONS);

	// If That Failed Too, Must Be No Extensions Supported
	if (supported == NULL)
		return false;

	// Begin Examination At Start Of String, Increment By 1 On False Match
	for (p = supported; ; p++)
	{
		// Advance p Up To The Next Possible Match
		p = strstr(p, extension);

		if (p == NULL)
			return false;															// No Match

		// Make Sure That Match Is At The Start Of The String Or That
		// The Previous Char Is A Space, Or Else We Could Accidentally
		// Match "wglFunkywglExtension" With "wglExtension"

		// Also, Make Sure That The Following Character Is Space Or NULL
		// Or Else "wglExtensionTwo" Might Match "wglExtension"
		if ((p==supported || p[-1]==' ') && (p[extlen]=='\0' || p[extlen]==' '))
			return true;															// Match
	}
}

// InitMultisample: Used To Query The Multisample Frequencies
int WIN_InitMultisample (HINSTANCE hInstance,HWND hWnd,PIXELFORMATDESCRIPTOR pfd, int ask_samples, int* pixelForceFormat)
{  
	 // See If The String Exists In WGL!
	if (!WGLisExtensionSupported("WGL_ARB_multisample"))
	{
		arbMultisampleSupported=false;
		return false;
	}

	{		
		// Get Our Pixel Format
		PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB");	
		if (!wglChoosePixelFormatARB) 
		{
			arbMultisampleSupported=false;
			return false;
		}


		{
			// Get Our Current Device Context
			HDC hDC = GetDC(hWnd);

			int		pixelFormat;
			int		valid;
			UINT	numFormats;
			float	fAttributes[] = {0,0};

			// These Attributes Are The Bits We Want To Test For In Our Sample
			// Everything Is Pretty Standard, The Only One We Want To 
			// Really Focus On Is The SAMPLE BUFFERS ARB And WGL SAMPLES
			// These Two Are Going To Do The Main Testing For Whether Or Not
			// We Support Multisampling On This Hardware.
			int iAttributes[] =
			{
				WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
				WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
				WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
				WGL_COLOR_BITS_ARB, 24 /*currentbpp? Nah */, // Baker: Mirror current bpp color depth?
				WGL_ALPHA_BITS_ARB,8,
				WGL_DEPTH_BITS_ARB,16,
				WGL_STENCIL_BITS_ARB,8, // Baker: Stencil bits
				WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
				WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
				WGL_SAMPLES_ARB, ask_samples /*multisample bits*/,
				0,0
			};

			
			while (ask_samples == 8 || ask_samples == 4 || ask_samples == 2)
			{
				iAttributes[19] = ask_samples;

				// First We Check To See If We Can Get A Pixel Format For 4 Samples
				valid = wglChoosePixelFormatARB(hDC,iAttributes,fAttributes,1,&pixelFormat,&numFormats);

				// If We Returned True, And Our Format Count Is Greater Than 1
				if (valid && numFormats >= 1)
				{				
					*pixelForceFormat = arbMultisampleFormat = pixelFormat;
					return (arbMultisampleSupported = ask_samples);
				}

				ask_samples >>= 1; // Divide by 2
			}
			  
			// Return Fail
			return  (arbMultisampleSupported = 0); 
		}
	}
}

Multisample gets rid of the "jaggies" but with some performance cost. Barnes pointed out in another thread there are better and more refined versions to do this that emerged, these look like they require shaders and for now the moment I'm sticking with the OpenGL 1.x level feature-set.

[Barnes]

Very short code my multisample block too large.
You can easy add nvidia CSAA modes (gf 8x +)

Nvidia Coverange AA

Samples # of Color/Z/Stencil # of Coverage Samples
8x 4 8
8xQ (Quality) 8 8
16x 4 16
16xQ (Quality) 8 16

Code: Select all

		gl_state.wgl_nv_multisample_coverage = false;
		if (strstr(glw_state.wglExtsString, "WGL_NV_multisample_coverage")) {
		
		if(r_arbSamples->value < 2){
		Com_Printf(""S_COLOR_YELLOW"...ignoring WGL_NV_multisample_coverage\n");
		gl_state.wgl_nv_multisample_coverage = false;
		gl_state.wgl_nv_multisample_coverage_aviable = true;
		}else{
		Com_Printf("...using WGL_NV_multisample_coverage\n");
		gl_state.wgl_nv_multisample_coverage = true;
		gl_state.wgl_nv_multisample_coverage_aviable = true;
		
		if(r_arbSamples->value >=16){ // clamp regular msaa 16x value to csaa 16q 
		Cvar_SetValue("r_arbSamples", 8);
		Cvar_SetValue("r_nvSamplesCoverange", 16);
		}

Code: Select all

	iAttributes[0] = WGL_DOUBLE_BUFFER_ARB;
		iAttributes[1] = TRUE;
		
		if(gl_state.wgl_nv_multisample_coverage){
		
		iAttributes[2] = WGL_COLOR_SAMPLES_NV;
		iAttributes[3] = (int)r_arbSamples->value;
		
		}else{
		
		iAttributes[2] = WGL_COLOR_BITS_ARB;
		iAttributes[3] = 32;
		}

		iAttributes[4] = WGL_DEPTH_BITS_ARB;
		iAttributes[5] = 24;

		iAttributes[6] = WGL_ALPHA_BITS_ARB;
		iAttributes[7] = 8;

		iAttributes[8] = WGL_STENCIL_BITS_ARB;
		iAttributes[9] = 8;
		
		iAttributes[10] = arbMultisampleSupported ? WGL_SAMPLE_BUFFERS_ARB : 0;
		iAttributes[11] = arbMultisampleSupported ? TRUE : 0;
		
		if(gl_state.wgl_nv_multisample_coverage){
							
		iAttributes[12] = arbMultisampleSupported ? WGL_COVERAGE_SAMPLES_NV : 0;
		iAttributes[13] = arbMultisampleSupported ? (int)r_nvSamplesCoverange->value : 0;
		}
		else
		{
		iAttributes[12] = arbMultisampleSupported ? WGL_SAMPLES_ARB : 0;
		iAttributes[13] = arbMultisampleSupported ? (int)r_arbSamples->value : 0;
		}
		iAttributes[14] = 0;
		iAttributes[15] = 0;

[Baker]

Very short code my multisample block too large.
You can easy add nvidia CSAA modes (gf 8x +)

Ah! Very nice. Unsurprisingly, my ATI card doesn't have that NVidia wgl extension so I can't test at least not on this machine.

But very nice code.

/My code, yeah I revised it to be small. I don't trust large code = too hard to supervise. I try to get code to be compact and "modular" (i.e. I can identify it, add it or remove it easily.)