自学教程：C++ wglGetCurrentDC函数代码示例

/** * If we can determine the WGL extension support from the current * context, then return that, otherwise give the answer that will just * send us on to get_proc_address(). */boolepoxy_conservative_has_wgl_extension(const char *ext){    HDC hdc = wglGetCurrentDC();    if (!hdc)        return true;    return epoxy_has_wgl_extension(hdc, ext);}

void glfntInit(void){    HDC hdc;    if (LettersDL!=0) return;    hdc=wglGetCurrentDC();    SelectObject(hdc,GetStockObject(SYSTEM_FONT));    LettersDL=glGenLists(128);    wglUseFontBitmaps(hdc,32,127,LettersDL+32);}

void SpriteCreate(CCallParams& p){    CBaseOglControl* ctrl = CBaseOglControl::controls[WindowFromDC(wglGetCurrentDC())];    if (0 == ctrl || p.AsString(0) == "" || p.AsString(1) == "")return;    ctrl->Collection().SpriteList().Create(p.AsString(0));    CBaseSprite* spr = GetSprite(p.AsString(0));    if (spr == 0)return;    CBaseTexture* tex = ctrl->Collection().TextureList().Get(p.AsString(1));    spr->SetTexture(tex);}

QtRenderWindow::QtRenderWindow(QWidget* parent, QGLFormat format) : QGLWidget(format, parent){	makeCurrent();	deviceContext = wglGetCurrentDC();	glContext = wglGetCurrentContext();	onMakeCurrent();	mRealtime = false;	mNeedsUpdate = true;}

void PlatformGetBackbufferDimensions( uint32& OutWidth, uint32& OutHeight ){	OutWidth = OutHeight = 0;	HDC DeviceContext = wglGetCurrentDC();	if( DeviceContext )	{		OutWidth = GetDeviceCaps( DeviceContext, HORZRES );		OutHeight = GetDeviceCaps( DeviceContext, VERTRES );	}}

bool               P3DGLMemoryContextPBuffer::Create                                      (unsigned int        Width,                                       unsigned int        Height,                                       bool                NeedAlpha) {  int              PixelFormat;  UINT             FormatCount;  HDC              CurrDeviceContext;  CurrDeviceContext = wglGetCurrentDC();  if (wglChoosePixelFormatARB( CurrDeviceContext,                               NeedAlpha ? PBufferPixelFormatIntAttrsAlpha :                                           PBufferPixelFormatIntAttrsNoAlpha,                               NULL,                               1,                              &PixelFormat,                              &FormatCount))   {    if (FormatCount == 0)     {      return(false);     }   }  else   {    return(false);   }  PBufferHandle = wglCreatePbufferARB                   (CurrDeviceContext,                    PixelFormat,                     Width,                    Height,                    PBufferAttrs);  if (PBufferHandle == NULL)   {    return(false);   }  PBufferDC = wglGetPbufferDCARB(PBufferHandle);  GLContext = wglCreateContext(PBufferDC);  if (MakeCurrent())   {    return(P3DGLExtInit());   }  else   {    return(false);   }  return(true); }

void cl_context::init(){    // OpenCL    try    {        // Get available platforms        vector<cl::Platform> platforms;        cl::Platform::get(&platforms);        LOG_INFO<<platforms.front().getInfo<CL_PLATFORM_VERSION>();        // context sharing is OS specific#if defined (__APPLE__) || defined(MACOSX)        CGLContextObj curCGLContext = CGLGetCurrentContext();        CGLShareGroupObj curCGLShareGroup = CGLGetShareGroup(curCGLContext);        cl_context_properties properties[] =        {            CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE,            (cl_context_properties)curCGLShareGroup,            0        };#elif defined WIN32        cl_context_properties properties[] =        {            CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(),            CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),            CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms[0])(),            0        };#else        cl_context_properties properties[] =        {            CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),            CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),            CL_CONTEXT_PLATFORM, (cl_context_properties)(platforms[0])(),            0        };#endif        m_context = cl::Context(CL_DEVICE_TYPE_GPU, properties);        // Get a list of devices on this platform        vector<cl::Device> devices = m_context.getInfo<CL_CONTEXT_DEVICES>();        m_device = devices[0];        // Create a command queue and use the first device        m_queue = cl::CommandQueue(m_context, m_device);    }    catch(cl::Error &error)    {        LOG_ERROR << error.what() << "(" << oclErrorString(error.err()) << ")";    }}

bool CGraphicView::GetScreenPtFrom3DPoint( const CPoint3D& modelSpacePt, CPoint& screenPt ){	// this function works for any xyz point but usually we will just be returning the 	// screen point for a grid point or node.	GLint viewport[4];	GLdouble mvMatrix[16], projMatrix[16];	double winX = 0.0;	double winY = 0.0;	double winZ = 0.0; //depth value between 0 and 1 - for depth sorting	bool bSuccess = false;	HGLRC currentRC = wglGetCurrentContext();	if( !currentRC )	{		TRACE( "CGraphicView::GetScreenPtFrom3DPoint Failed in GetCurrentContext/n" );		return bSuccess;	}	HDC hDC = wglGetCurrentDC( );	if( !hDC )	{		TRACE( "CGraphicView::GetScreenPtFrom3DPoint Failed in GetCurrentDC/n" );		return bSuccess;	}	//if( !wglMakeCurrent( m_pDC->GetSafeHdc(), m_hDC ) )	if( !wglMakeCurrent( hDC, currentRC ) )	{		TRACE( "CGraphicView::GetScreenPtFrom3DPoint Failed in MakeCurrent/n" );		return bSuccess;	}	glGetIntegerv( GL_VIEWPORT, viewport );	glGetDoublev( GL_MODELVIEW_MATRIX, mvMatrix );	glGetDoublev( GL_PROJECTION_MATRIX, projMatrix );	if( !gluProject( modelSpacePt.x, modelSpacePt.y, modelSpacePt.z, 		             mvMatrix, projMatrix, viewport, 				     &winX, &winY, &winZ ) )	{		//TRACE( "Failed in GetScreenPt #2/n" );		//wglMakeCurrent( NULL, NULL );		return bSuccess;	}	//openGL convention (origin at lower left)	screenPt.x = int(winX);	screenPt.y = int(winY);	//windows convention (origin at upper left)	screenPt.y = viewport[3] - viewport[1] - screenPt.y;	bSuccess = true;	return bSuccess;}

void CL::TinyCL::selectInteropDevice(DEVICE dev, bool profile) {    try {        //We assume only the first device and platform will be used        //This is after all a lazy implementation        cl::Platform::get(&mPlatforms);        //Query the devices for the type desired        mPlatforms.at(0).getDevices(static_cast<cl_device_type>(dev), &mDevices);#ifdef _WIN32        cl_context_properties properties[] = {            CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(),            CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),            CL_CONTEXT_PLATFORM, (cl_context_properties)(mPlatforms[0])(),            0        };#elif defined(__linux__)        cl_context_properties properties[] = {            CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),            CL_WGL_HDC_KHR, (cl_context_properties)glXGetCurrentDisplay(),            CL_CONTEXT_PLATFORM, (cl_context_properties)(mPlatforms[0])(),            0        };#elif defined(__APPLE__)        CGLContextObj glContext = CGLGetCurrentContext();        CGLShareGroupObj shareGroup = CGLGetShareGroup(glContext);        cl_context_properties properties[] = {            CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE,            (cl_context_properties)shareGroup,        };#endif        mContext = cl::Context(mDevices, properties);        //Grab the OpenGL device        mDevices = mContext.getInfo<CL_CONTEXT_DEVICES>();        if (profile)            mQueue = cl::CommandQueue(mContext, mDevices.at(0), CL_QUEUE_PROFILING_ENABLE);        else            mQueue = cl::CommandQueue(mContext, mDevices.at(0));        std::cout << "OpenCL Info:"                  << "/nName: " << mDevices.at(0).getInfo<CL_DEVICE_NAME>()                  << "/nVendor: " << mDevices.at(0).getInfo<CL_DEVICE_VENDOR>()                  << "/nDriver Version: " << mDevices.at(0).getInfo<CL_DRIVER_VERSION>()                  << "/nDevice Profile: " << mDevices.at(0).getInfo<CL_DEVICE_PROFILE>()                  << "/nDevice Version: " << mDevices.at(0).getInfo<CL_DEVICE_VERSION>()                  << "/nMax Work Group Size: " << mDevices.at(0).getInfo<CL_DEVICE_MAX_WORK_GROUP_SIZE>()                  << std::endl;    }    catch (const cl::Error &e) {        std::cout << "Error selecting GL interop device: " << e.what()                  << " code: " << e.err() << std::endl;        throw e;    }}

//--------------------------------------static void fixCloseWindowOnWin32(){	//get the HWND	handle = WindowFromDC(wglGetCurrentDC());	//store the current message event handler for the window	currentWndProc = (WNDPROC)GetWindowLongPtr(handle, GWL_WNDPROC);	//tell the window to now use our event handler!	SetWindowLongPtr(handle, GWL_WNDPROC, (long)winProc);}

//---------------------------------------------------------------------------------int APIENTRY wWinMain(_In_ HINSTANCE hInstance, 	_In_opt_ HINSTANCE hPrevInstance,	_In_ LPWSTR    lpCmdLine, _In_ int       nCmdShow){		int argc = 0;	char* argv = "";	// Exit handler to check memory on exit.	const int result_1 = std::atexit(CheckMemCallback);	std::wstring commandLine(lpCmdLine);	gEditorMode = commandLine.find(L"-Editor") != std::string::npos;	// Setup glut.	glutInit(&argc, &argv);	glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);	glutInitWindowPosition(100, 100);	int glutWind = glutCreateWindow(APP_WINDOW_TITLE);		HDC dc = wglGetCurrentDC();	MAIN_WINDOW_HANDLE = WindowFromDC(dc);	glutIdleFunc(Idle);	glutDisplayFunc(Display);       // Register callback handler for window re-paint event		glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);	InitGL();                       // Our own OpenGL initialization	// Init sounds system.	CSimpleSound::GetInstance().Initialize(MAIN_WINDOW_HANDLE);		// Call user defined init.	if (gEditorMode)	{		EditorInit();	}	else	{		Init();	}	// Enter glut the event-processing loop					glutMainLoop();		// Call user shutdown.	if (gEditorMode)	{		EditorShutdown();	}	else	{		Shutdown();	}	// Shutdown sound system.	CSimpleSound::GetInstance().Shutdown();	// And we are done.	return 0;}

HANDLECreateBufferRegion(unsigned int buffers){    /* Create the buffer region. */    HANDLE FBRegion = wglCreateBufferRegionARB(wglGetCurrentDC(), 0, buffers);    if (FBRegion == 0)        puts("wglCreateBufferRegionARB Failed");    return FBRegion;}

int Server::initGLContexts(){	diplayWindow = wglGetCurrentDC();	primaryContext = wglGetCurrentContext();	loadingThreadContext = wglCreateContext(diplayWindow);	wglMakeCurrent(NULL, NULL);	BOOL error = wglShareLists(primaryContext, loadingThreadContext);	wglMakeCurrent(diplayWindow, primaryContext);	return 0;}

void CBaseOglControl::BaseInitialize(){	parser.Start();	PIXELFORMATDESCRIPTOR pfd;	int pf = 0;	HDC hDC = GetDC(hMy);		pfd.nSize        = sizeof(pfd);	pfd.nVersion     = 1;	pfd.dwFlags      = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;	pfd.iPixelType   = PFD_TYPE_RGBA;	pfd.cColorBits   = 32;	pf = ChoosePixelFormat(hDC, &pfd);	if(pf==0)	{		pf = 1;		if(DescribePixelFormat(hDC,pf,sizeof(PIXELFORMATDESCRIPTOR),&pfd)==0)		return;	}	if (SetPixelFormat(hDC, pf, &pfd) == FALSE) return;    hOGL = wglCreateContext(hDC);    	wglMakeCurrent(hDC, hOGL);			quadObj = gluNewQuadric();//Для отрисовки цилиндра, сфер и т.д.		//все перенести в скрипт		glEnable(GL_TEXTURE_2D);		glEnable(GL_LIGHTING);		glEnable(GL_LIGHT0);		glEnable(GL_COLOR_MATERIAL);		//glDisable(GL_CULL_FACE); 		glEnable(GL_DEPTH_TEST);		glEnable(GL_ALPHA_TEST);				glEnable(GL_BLEND); 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);		glEnable(GL_ALPHA_TEST);		glAlphaFunc(GL_GREATER, 0.5f);				glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);		Initialize();		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		SwapBuffers(wglGetCurrentDC());		glFlush();			wglMakeCurrent(hDC, 0);}

// The Effects of Double Buffering on Animation Frame Rates//		http://www.futuretech.blinkenlights.nl/dbuffer.htmlbool _SwapBuffers(JSContext *cx, JSObject *obj, unsigned argc, jsval *argv, jsval *rval) {//	glFlush();//	glFinish();//	JL_ASSERT( JL_GetClass(obj) == _class, RT_ERROR_INVALID_CLASS );	HDC hDC = wglGetCurrentDC(); // (TBD) un-specialize from OpenGL	JL_ASSERT( hDC != NULL, "Could not get the Current Device Context." );	BOOL res = SwapBuffers(hDC); // Doc: With multithread applications, flush the drawing commands in any other threads drawing to the same window before calling SwapBuffers.	JL_ASSERT( res, "Unable to SwapBuffers.(%x)", GetLastError() );	return true;}

static HGLRC init_ogl_context_ex(HDC dc, bool fc, int major, int minor){   HWND testwnd = NULL;   HDC testdc   = NULL;   HGLRC testrc = NULL;   HGLRC old_rc = NULL;   HDC old_dc   = NULL;   HGLRC glrc   = NULL;   testwnd = _al_win_create_hidden_window();   if (!testwnd)      return NULL;   old_rc = wglGetCurrentContext();   old_dc = wglGetCurrentDC();   testdc = GetDC(testwnd);   testrc = init_temp_context(testwnd);   if (!testrc)      goto bail;   if (is_wgl_extension_supported("WGL_ARB_create_context", testdc)) {      int attrib[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, major,                      WGL_CONTEXT_MINOR_VERSION_ARB, minor,                      WGL_CONTEXT_FLAGS_ARB, 0,                      0};      if (fc)         attrib[5] = WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;      if (!init_context_creation_extensions())         goto bail;      /* TODO: we could use the context sharing feature */      glrc = _wglCreateContextAttribsARB(dc, 0, attrib);   }   else      goto bail;bail:   wglMakeCurrent(NULL, NULL);   if (testrc) {      wglDeleteContext(testrc);   }   wglMakeCurrent(old_dc, old_rc);   _wglCreateContextAttribsARB = NULL;   if (testwnd) {      ReleaseDC(testwnd, testdc);      DestroyWindow(testwnd);   }   return glrc;}

void CBaseOglCamera::GetViewPort(RECT& vp){	if (viewPort[0] != 0 || viewPort[1] != 0 || viewPort[2] != 0 || viewPort[3] != 0)	{		vp.left = viewPort[0];		vp.top = viewPort[1];		vp.right = viewPort[2];		vp.bottom = viewPort[3];	}	else		GetClientRect(WindowFromDC(wglGetCurrentDC()), &vp);}

void RenderTarget_Win32::StartRenderingTo(){	m_hOldDeviceContext = wglGetCurrentDC();	m_hOldRenderContext = wglGetCurrentContext();	BOOL successful = wglMakeCurrent(GraphicsWindow::GetHDC(), g_HGLRC);	ASSERT_M( successful == TRUE, "wglMakeCurrent failed in RenderTarget_Win32::StartRenderingTo()" );	FlushGLErrors();	glBindTexture( GL_TEXTURE_2D, m_texHandle );	AssertNoGLError();}

/** returns true if the extension is available */static bool WGLQueryExtension(WGLExtensions *extensions, const char *name) {	const GLubyte *extension_string;	if (!extensions->WGL_ARB_extensions_string)		if (!extensions->WGL_EXT_extensions_string)			return false;		else			extension_string = (GLubyte*)extensions->wglGetExtensionsStringEXT();	else		extension_string = (GLubyte*)extensions->wglGetExtensionsStringARB(wglGetCurrentDC());	return extgl_QueryExtension(extension_string, name);}

void KH::TextDrawer::SelectFont(int size, int charset, const char* face = "Arial") { 	fontName = std::string(face);	fontSize = size;	//创建指定字体 	HFONT hFont = CreateFontA(size, 0, 0, 0, FW_MEDIUM, 0, 0, 0, charset, 							OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, 							DEFAULT_QUALITY, DEFAULT_PITCH | FF_SWISS, face							); 	//把创建的字体选入设备上下文,保存旧字体     	HFONT hOldFont = (HFONT)SelectObject(wglGetCurrentDC(), hFont); }

SkWGLExtensions::SkWGLExtensions()    : fGetExtensionsString(nullptr)    , fChoosePixelFormat(nullptr)    , fGetPixelFormatAttribfv(nullptr)    , fGetPixelFormatAttribiv(nullptr)    , fCreateContextAttribs(nullptr)    , fSwapInterval(nullptr)    , fCreatePbuffer(nullptr)    , fGetPbufferDC(nullptr)    , fReleasePbufferDC(nullptr)    , fDestroyPbuffer(nullptr) {    HDC prevDC = wglGetCurrentDC();    HGLRC prevGLRC = wglGetCurrentContext();    PIXELFORMATDESCRIPTOR dummyPFD;    ZeroMemory(&dummyPFD, sizeof(dummyPFD));    dummyPFD.nSize = sizeof(dummyPFD);    dummyPFD.nVersion = 1;    dummyPFD.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;    dummyPFD.iPixelType = PFD_TYPE_RGBA;    dummyPFD.cColorBits  = 32;    dummyPFD.cDepthBits  = 0;    dummyPFD.cStencilBits = 8;    dummyPFD.iLayerType = PFD_MAIN_PLANE;    HWND dummyWND = create_dummy_window();    if (dummyWND) {        HDC dummyDC = GetDC(dummyWND);        int dummyFormat = ChoosePixelFormat(dummyDC, &dummyPFD);        SetPixelFormat(dummyDC, dummyFormat, &dummyPFD);        HGLRC dummyGLRC = wglCreateContext(dummyDC);        SkASSERT(dummyGLRC);        wglMakeCurrent(dummyDC, dummyGLRC);        GET_PROC(GetExtensionsString, ARB);        GET_PROC(ChoosePixelFormat, ARB);        GET_PROC(GetPixelFormatAttribiv, ARB);        GET_PROC(GetPixelFormatAttribfv, ARB);        GET_PROC(CreateContextAttribs, ARB);        GET_PROC(SwapInterval, EXT);        GET_PROC(CreatePbuffer, ARB);        GET_PROC(GetPbufferDC, ARB);        GET_PROC(ReleasePbufferDC, ARB);        GET_PROC(DestroyPbuffer, ARB);        wglMakeCurrent(dummyDC, nullptr);        wglDeleteContext(dummyGLRC);        destroy_dummy_window(dummyWND);    }    wglMakeCurrent(prevDC, prevGLRC);}

void btgGLInit(CView *pView){	oldRect = drawRect;	pView->GetClientRect(&drawRect);	if(oldRect != drawRect)	{		if (hGLDeviceContext != NULL)		{			wglMakeCurrent(NULL, NULL);			wglDeleteContext(hGLRenderContext);			hGLRenderContext = 0;		}	}	hGLDeviceContext = wglGetCurrentDC();	if (hGLDeviceContext == NULL || hGLRenderContext == 0)	{		hGLDeviceContext = ::GetDC(pView->GetSafeHwnd());		setupPixelFormat(hGLDeviceContext);		setupPalette(hGLDeviceContext);		hGLRenderContext = wglCreateContext(hGLDeviceContext);  //create GL render context and select into window		wglMakeCurrent(hGLDeviceContext, hGLRenderContext);		//create the viewport for rendering		auxInitPosition(0, 0, drawRect.right - drawRect.left, drawRect.bottom - drawRect.top);		//set mode (direct color)		auxInitDisplayMode(AUX_RGB);	}	else	{		//wglMakeCurrent(hGLDeviceContext, hGLRenderContext);	}	CBTGDoc* pDoc = (CBTGDoc*)pView->GetDocument();	glClearColor((GLfloat)pDoc->mBGRed / 255.0f,				 (GLfloat)pDoc->mBGGreen / 255.0f,				 (GLfloat)pDoc->mBGBlue / 255.0f,				 1.0f);	glClear(GL_COLOR_BUFFER_BIT);	glMatrixMode(GL_PROJECTION);	glLoadIdentity();	glMatrixMode(GL_MODELVIEW);	glLoadIdentity();	gluOrtho2D(0, drawRect.right - drawRect.left, 0, drawRect.bottom - drawRect.top);	glDisable(GL_LIGHTING);	glDisable(GL_CULL_FACE);	glDisable(GL_DEPTH_TEST);	glBlendFunc(GL_SRC_ALPHA, GL_ONE);}

static void_wgl_release (void *abstract_ctx){    cairo_wgl_context_t *ctx = abstract_ctx;    if (ctx->prev_dc != wglGetCurrentDC () ||        ctx->prev_rc != wglGetCurrentContext ())    {        wglMakeCurrent (ctx->prev_dc,                        ctx->prev_rc);    }}

void KH::TextDrawer::DrawEngString(const char* str) {     	static int isFirstCall = 1;     	static GLuint lists;     	if( isFirstCall ) { 		// 如果是第一次调用，执行初始化         		// 为每一个ASCII字符产生一个显示列表         		isFirstCall = 0;         // 申请MAX_CHAR个连续的显示列表编号         		lists = glGenLists(_DRAW_MAX_CHAR);         // 把每个字符的绘制命令都装到对应的显示列表中         		wglUseFontBitmaps(wglGetCurrentDC(), 0, _DRAW_MAX_CHAR, lists);     	}     // 调用每个字符对应的显示列表，绘制每个字符     	for(; *str!='/0'; ++str)        		glCallList(lists + *str);} 

void FsSwapBuffers(void){	if(0==doubleBuffer)	{		MessageBoxA(NULL,"Error! FsSwapBuffers used in the single-buffered mode.","Error!",MB_OK);		exit(1);	}	HDC hDC;	glFlush();	hDC=wglGetCurrentDC();	SwapBuffers(hDC);}

void CBaseOglControl::ReDraw(){	SetFocus(hMy);	CalcFps();	wglMakeCurrent(GetDC(hMy), hOGL);	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	Refresh();	SwapBuffers(wglGetCurrentDC());	glFlush();	wglMakeCurrent(GetDC(hMy), 0);}

	MapilVoid GLSprite::DrawString(	SharedPointer < GraphicsFont > pFont,									const MapilTChar* pStr,									ImageTransformationMethod method,									const Vector2 < MapilFloat32 >& v,									MapilUInt32 color )	{		if( !pStr ){			return;		}#if defined ( API_WIN32API )		::HDC hdc = wglGetCurrentDC();		// Build string to be displayed.		MapilTChar str[ 4096 ];		va_list vl;		MapilInt32 len;				va_start( vl, pStr );		len = _vsctprintf( pStr, vl ) + 1;		if( len > sizeof( str ) ){			return;		}		_vstprintf( str, pStr, vl );		va_end( vl );		len = _tcslen( str );		SelectObject( hdc, reinterpret_cast < HFONT > ( pFont->Get() ) );						MapilInt32 list = glGenLists( len );		for( MapilInt32 i = 0; i < len; i++ ){			wglUseFontBitmaps( hdc, str[ i ], 1, list + i );		}		//glDisable( GL_LIGHTING );		glColor4i( ( color >> 16 ) & 0xFF , ( color >> 8 ) & 0xFF, color & 0xFF, ( color >> 24 ) & 0xFF );		//glColor4f( 1.0f, 0.0f, 0.0f, 1.0f );		glRasterPos2f( v.m_X, v.m_Y );		for( MapilInt32 i = 0; i < len; i++ ){			glCallList( list + i );		}		//glEnable( GL_LIGHTING );		glDeleteLists( list, len );#endif	// API_WIN32API	}

static void prepareSwapOnDC(HDC hdc,HDC &oldDC,HGLRC &oldRC){  oldDC = wglGetCurrentDC();  oldRC = wglGetCurrentContext();  if(oldDC != hdc)  {    HGLRC rc = rcFromDC[hdc];    if(rc)      Mine_wglMakeCurrent(hdc,rc);    else      printLog("video/opengl: SwapBuffers called on DC with no active rendering context. This is potentially bad./n");  }}

//----------------------------------------------------------------------------//void OpenGLWGLPBTextureTarget::initialisePBuffer(){    int creation_attrs[] =    {        WGL_PBUFFER_LARGEST_ARB, true,        0    };    releasePBuffer();    HDC hdc = wglGetCurrentDC();    d_pbuffer = wglCreatePbufferARB(hdc, d_pixfmt,                                     static_cast<int>(d_area.getWidth()),                                    static_cast<int>(d_area.getHeight()),                                    creation_attrs);    if (!d_pbuffer)        CEGUI_THROW(RendererException(            "OpenGLWGLPBTextureTarget::initialisePBuffer - "            "pbuffer creation failure, wglCreatePbufferARB() call failed."));    d_hdc = wglGetPbufferDCARB(d_pbuffer);    if (!d_hdc)        CEGUI_THROW(RendererException(            "OpenGLWGLPBTextureTarget::initialisePBuffer - "            "pbuffer creation failure, wglGetPbufferDCARB() call failed."));    d_context= wglCreateContext(d_hdc);    if (!d_hdc)        CEGUI_THROW(RendererException(            "OpenGLWGLPBTextureTarget::initialisePBuffer - "            "pbuffer creation failure, wglCreateContext() call failed."));    if(!wglShareLists(wglGetCurrentContext(), d_context))        CEGUI_THROW(RendererException(            "OpenGLWGLPBTextureTarget::initialisePBuffer - "            "pbuffer creation failure, wglShareLists() call failed."));    // extract the actual size of the created bufer    int actual_width, actual_height;    wglQueryPbufferARB(d_pbuffer, WGL_PBUFFER_WIDTH_ARB, &actual_width);    wglQueryPbufferARB(d_pbuffer, WGL_PBUFFER_HEIGHT_ARB, &actual_height);    d_area.setSize(Size(static_cast<float>(actual_width),                        static_cast<float>(actual_height)));    // ensure CEGUI::Texture is wrapping real GL texture and has correct size    d_CEGUITexture->setOpenGLTexture(d_texture, d_area.getSize());}

static int extensionSupportedWGL(const char* extension){    const char* extensions = NULL;    if (_glfw.wgl.GetExtensionsStringARB)        extensions = _glfw.wgl.GetExtensionsStringARB(wglGetCurrentDC());    else if (_glfw.wgl.GetExtensionsStringEXT)        extensions = _glfw.wgl.GetExtensionsStringEXT();    if (!extensions)        return GLFW_FALSE;    return _glfwStringInExtensionString(extension, extensions);}