Commit | Line | Data |
---|---|---|
b311480e | 1 | // Created on: 2011-09-20 |
2 | // Created by: Sergey ZERCHANINOV | |
3 | // Copyright (c) 2011-2012 OPEN CASCADE SAS | |
4 | // | |
5 | // The content of this file is subject to the Open CASCADE Technology Public | |
6 | // License Version 6.5 (the "License"). You may not use the content of this file | |
7 | // except in compliance with the License. Please obtain a copy of the License | |
8 | // at http://www.opencascade.org and read it completely before using this file. | |
9 | // | |
10 | // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its | |
11 | // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France. | |
12 | // | |
13 | // The Original Code and all software distributed under the License is | |
14 | // distributed on an "AS IS" basis, without warranty of any kind, and the | |
15 | // Initial Developer hereby disclaims all such warranties, including without | |
16 | // limitation, any warranties of merchantability, fitness for a particular | |
17 | // purpose or non-infringement. Please see the License for the specific terms | |
18 | // and conditions governing the rights and limitations under the License. | |
19 | ||
2166f0fa SK |
20 | |
21 | #include <InterfaceGraphic.hxx> | |
22 | ||
23 | #include <OpenGl_Window.hxx> | |
24 | ||
25 | #include <OpenGl_Context.hxx> | |
26 | #include <OpenGl_Display.hxx> | |
2166f0fa SK |
27 | |
28 | #include <Aspect_GraphicDeviceDefinitionError.hxx> | |
29 | #include <TCollection_AsciiString.hxx> | |
30 | ||
5f8b738e | 31 | #include <GL/glu.h> // gluOrtho2D() |
32 | ||
2166f0fa SK |
33 | IMPLEMENT_STANDARD_HANDLE(OpenGl_Window,MMgt_TShared) |
34 | IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Window,MMgt_TShared) | |
35 | ||
36 | namespace | |
37 | { | |
38 | static const TEL_COLOUR THE_DEFAULT_BG_COLOR = { { 0.F, 0.F, 0.F, 1.F } }; | |
39 | ||
2166f0fa SK |
40 | #if (defined(_WIN32) || defined(__WIN32__)) |
41 | static int find_pixel_format (HDC hDC, PIXELFORMATDESCRIPTOR* pfd, const Standard_Boolean dbuff) | |
42 | { | |
43 | PIXELFORMATDESCRIPTOR pfd0; | |
44 | memset (&pfd0, 0, sizeof (PIXELFORMATDESCRIPTOR)); | |
45 | pfd0.nSize = sizeof (PIXELFORMATDESCRIPTOR); | |
46 | pfd0.nVersion = 1; | |
47 | pfd0.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | (dbuff ? PFD_DOUBLEBUFFER : PFD_SUPPORT_GDI); | |
48 | pfd0.iPixelType = PFD_TYPE_RGBA; | |
49 | pfd0.iLayerType = PFD_MAIN_PLANE; | |
50 | ||
51 | int iPixelFormat = 0; | |
52 | int iGood = 0; | |
53 | const int cBits[] = { 32, 24 }; | |
54 | const int dBits[] = { 32, 24, 16 }; | |
55 | ||
56 | int i, j; | |
57 | for (i = 0; i < sizeof(dBits) / sizeof(int); i++) | |
58 | { | |
59 | pfd0.cDepthBits = dBits[i]; | |
60 | iGood = 0; | |
61 | for (j = 0; j < sizeof(cBits) / sizeof(int); j++) | |
62 | { | |
63 | pfd0.cColorBits = cBits[j]; | |
64 | iPixelFormat = ChoosePixelFormat (hDC, &pfd0); | |
65 | if (iPixelFormat) | |
66 | { | |
67 | pfd->cDepthBits = 0; | |
68 | pfd->cColorBits = 0; | |
69 | DescribePixelFormat (hDC, iPixelFormat, sizeof (PIXELFORMATDESCRIPTOR), pfd); | |
70 | if (pfd->cColorBits >= cBits[j] && pfd->cDepthBits >= dBits[i]) | |
71 | break; | |
72 | if (iGood == 0) | |
73 | iGood = iPixelFormat; | |
74 | } | |
75 | } | |
76 | if (j < sizeof(cBits) / sizeof(int)) | |
77 | break; | |
78 | } | |
79 | ||
80 | if (iPixelFormat == 0) | |
81 | iPixelFormat = iGood; | |
82 | ||
83 | return iPixelFormat; | |
84 | } | |
85 | #else | |
86 | static Bool WaitForNotify (Display* theDisp, XEvent* theEv, char* theArg) | |
87 | { | |
88 | return (theEv->type == MapNotify) && (theEv->xmap.window == (Window )theArg); | |
89 | } | |
90 | #endif | |
91 | ||
92 | }; | |
93 | ||
94 | // ======================================================================= | |
95 | // function : OpenGl_Window | |
96 | // purpose : | |
97 | // ======================================================================= | |
98 | OpenGl_Window::OpenGl_Window (const Handle(OpenGl_Display)& theDisplay, | |
99 | const CALL_DEF_WINDOW& theCWindow, | |
5e27df78 | 100 | Aspect_RenderingContext theGContext, |
101 | const Handle(OpenGl_Context)& theShareCtx) | |
2166f0fa | 102 | : myDisplay (theDisplay), |
2166f0fa SK |
103 | myGlContext (new OpenGl_Context()), |
104 | myOwnGContext (theGContext == 0), | |
105 | #if (defined(_WIN32) || defined(__WIN32__)) | |
2166f0fa SK |
106 | mySysPalInUse (FALSE), |
107 | #endif | |
108 | myWidth ((Standard_Integer )theCWindow.dx), | |
109 | myHeight ((Standard_Integer )theCWindow.dy), | |
110 | myBgColor (THE_DEFAULT_BG_COLOR), | |
111 | myDither (theDisplay->Dither()), | |
112 | myBackDither (theDisplay->BackDither()) | |
113 | { | |
114 | myBgColor.rgb[0] = theCWindow.Background.r; | |
115 | myBgColor.rgb[1] = theCWindow.Background.g; | |
116 | myBgColor.rgb[2] = theCWindow.Background.b; | |
117 | ||
5e27df78 | 118 | #if (defined(_WIN32) || defined(__WIN32__)) |
119 | HWND aWindow = (HWND )theCWindow.XWindow; | |
120 | HDC aWindowDC = GetDC (aWindow); | |
121 | HGLRC aGContext = (HGLRC )theGContext; | |
122 | ||
123 | PIXELFORMATDESCRIPTOR pfd; | |
124 | int iPixelFormat = find_pixel_format (aWindowDC, &pfd, myDisplay->DBuffer()); | |
125 | if (iPixelFormat == 0) | |
126 | { | |
127 | ReleaseDC (aWindow, aWindowDC); | |
128 | ||
129 | TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: ChoosePixelFormat failed. Error code: "); | |
130 | aMsg += (int )GetLastError(); | |
131 | Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString()); | |
132 | return; | |
133 | } | |
134 | ||
135 | if (pfd.dwFlags & PFD_NEED_PALETTE) | |
136 | { | |
137 | WINDOW_DATA* wd = (WINDOW_DATA* )GetWindowLongPtr (aWindow, GWLP_USERDATA); | |
138 | ||
139 | mySysPalInUse = (pfd.dwFlags & PFD_NEED_SYSTEM_PALETTE) ? TRUE : FALSE; | |
140 | InterfaceGraphic_RealizePalette (aWindowDC, wd->hPal, FALSE, mySysPalInUse); | |
141 | } | |
142 | ||
143 | if (myDither) | |
144 | myDither = (pfd.cColorBits <= 8); | |
145 | ||
146 | if (myBackDither) | |
147 | myBackDither = (pfd.cColorBits <= 8); | |
148 | ||
149 | if (!SetPixelFormat (aWindowDC, iPixelFormat, &pfd)) | |
150 | { | |
151 | ReleaseDC (aWindow, aWindowDC); | |
152 | ||
153 | TCollection_AsciiString aMsg("OpenGl_Window::CreateWindow: SetPixelFormat failed. Error code: "); | |
154 | aMsg += (int )GetLastError(); | |
155 | Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString()); | |
156 | return; | |
157 | } | |
158 | ||
159 | if (aGContext == NULL) | |
160 | { | |
161 | aGContext = wglCreateContext (aWindowDC); | |
162 | if (aGContext == NULL) | |
163 | { | |
164 | ReleaseDC (aWindow, aWindowDC); | |
165 | ||
166 | TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: wglCreateContext failed. Error code: "); | |
167 | aMsg += (int )GetLastError(); | |
168 | Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString()); | |
169 | return; | |
170 | } | |
171 | } | |
172 | ||
173 | // all GL context within one OpenGl_GraphicDriver should be shared! | |
174 | if (!theShareCtx.IsNull() && wglShareLists ((HGLRC )theShareCtx->myGContext, aGContext) != TRUE) | |
175 | { | |
176 | TCollection_AsciiString aMsg ("OpenGl_Window::CreateWindow: wglShareLists failed. Error code: "); | |
177 | aMsg += (int )GetLastError(); | |
178 | Aspect_GraphicDeviceDefinitionError::Raise (aMsg.ToCString()); | |
179 | return; | |
180 | } | |
181 | ||
182 | myGlContext->Init ((Aspect_Handle )aWindow, (Aspect_Handle )aWindowDC, (Aspect_RenderingContext )aGContext); | |
183 | #else | |
2166f0fa | 184 | WINDOW aParent = (WINDOW )theCWindow.XWindow; |
5e27df78 | 185 | WINDOW aWindow = 0; |
2166f0fa | 186 | DISPLAY* aDisp = (DISPLAY* )myDisplay->GetDisplay(); |
5e27df78 | 187 | GLXContext aGContext = (GLXContext )theGContext; |
2166f0fa | 188 | |
2166f0fa SK |
189 | XWindowAttributes wattr; |
190 | XGetWindowAttributes (aDisp, aParent, &wattr); | |
191 | const int scr = DefaultScreen (aDisp); | |
192 | ||
193 | XVisualInfo* aVis = NULL; | |
194 | { | |
195 | unsigned long aVisInfoMask = VisualIDMask | VisualScreenMask; | |
196 | XVisualInfo aVisInfo; | |
197 | aVisInfo.visualid = wattr.visual->visualid; | |
198 | aVisInfo.screen = scr; | |
199 | int aNbItems; | |
200 | aVis = XGetVisualInfo (aDisp, aVisInfoMask, &aVisInfo, &aNbItems); | |
201 | } | |
202 | ||
2166f0fa SK |
203 | if (!myOwnGContext) |
204 | { | |
205 | if (aVis != NULL) | |
206 | { | |
207 | Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: XGetVisualInfo failed."); | |
208 | return; | |
209 | } | |
210 | ||
5e27df78 | 211 | aWindow = aParent; |
2166f0fa SK |
212 | } |
213 | else | |
214 | { | |
2166f0fa SK |
215 | #if defined(__linux) || defined(Linux) |
216 | if (aVis != NULL) | |
217 | { | |
218 | // check Visual for OpenGl context's parameters compability | |
219 | int isGl = 0, isDoubleBuffer = 0, isRGBA = 0, aDepthSize = 0; | |
220 | ||
221 | if (glXGetConfig (aDisp, aVis, GLX_USE_GL, &isGl) != 0) | |
222 | isGl = 0; | |
223 | ||
224 | if (glXGetConfig (aDisp, aVis, GLX_RGBA, &isRGBA) != 0) | |
225 | isRGBA = 0; | |
226 | ||
227 | if (glXGetConfig (aDisp, aVis, GLX_DOUBLEBUFFER, &isDoubleBuffer) != 0) | |
228 | isDoubleBuffer = 0; | |
229 | ||
230 | if (glXGetConfig (aDisp, aVis, GLX_DEPTH_SIZE, &aDepthSize) != 0) | |
231 | aDepthSize = 0; | |
232 | ||
233 | if (!isGl || !aDepthSize || !isRGBA || (isDoubleBuffer ? 1 : 0) != (myDisplay->DBuffer()? 1 : 0)) | |
234 | { | |
235 | XFree (aVis); | |
236 | aVis = NULL; | |
237 | } | |
238 | } | |
239 | #endif | |
240 | ||
241 | if (aVis == NULL) | |
242 | { | |
243 | int anIter = 0; | |
244 | int anAttribs[11]; | |
245 | anAttribs[anIter++] = GLX_RGBA; | |
246 | ||
247 | anAttribs[anIter++] = GLX_DEPTH_SIZE; | |
248 | anAttribs[anIter++] = 1; | |
249 | ||
250 | anAttribs[anIter++] = GLX_RED_SIZE; | |
251 | anAttribs[anIter++] = (wattr.depth <= 8) ? 0 : 1; | |
252 | ||
253 | anAttribs[anIter++] = GLX_GREEN_SIZE; | |
254 | anAttribs[anIter++] = (wattr.depth <= 8) ? 0 : 1; | |
255 | ||
256 | anAttribs[anIter++] = GLX_BLUE_SIZE; | |
257 | anAttribs[anIter++] = (wattr.depth <= 8) ? 0 : 1; | |
258 | ||
259 | if (myDisplay->DBuffer()) | |
260 | anAttribs[anIter++] = GLX_DOUBLEBUFFER; | |
261 | ||
262 | anAttribs[anIter++] = None; | |
263 | ||
264 | aVis = glXChooseVisual (aDisp, scr, anAttribs); | |
265 | if (aVis == NULL) | |
266 | { | |
267 | Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: glXChooseVisual failed."); | |
268 | return; | |
269 | } | |
270 | } | |
271 | ||
5e27df78 | 272 | if (!theShareCtx.IsNull()) |
2166f0fa | 273 | { |
5e27df78 | 274 | // ctx est une copie du previous |
275 | aGContext = glXCreateContext (aDisp, aVis, (GLXContext )theShareCtx->myGContext, GL_TRUE); | |
2166f0fa SK |
276 | } |
277 | else | |
278 | { | |
5e27df78 | 279 | aGContext = glXCreateContext (aDisp, aVis, NULL, GL_TRUE); |
2166f0fa SK |
280 | } |
281 | ||
5e27df78 | 282 | if (!aGContext) |
2166f0fa SK |
283 | { |
284 | Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window::CreateWindow: glXCreateContext failed."); | |
285 | return; | |
286 | } | |
287 | ||
2166f0fa SK |
288 | Colormap cmap = XCreateColormap (aDisp, aParent, aVis->visual, AllocNone); |
289 | ||
290 | XColor color; | |
291 | color.red = (unsigned short) (myBgColor.rgb[0] * 0xFFFF); | |
292 | color.green = (unsigned short) (myBgColor.rgb[1] * 0xFFFF); | |
293 | color.blue = (unsigned short) (myBgColor.rgb[2] * 0xFFFF); | |
294 | color.flags = DoRed | DoGreen | DoBlue; | |
295 | XAllocColor (aDisp, cmap, &color); | |
296 | ||
297 | XSetWindowAttributes cwa; | |
298 | cwa.colormap = cmap; | |
299 | cwa.event_mask = StructureNotifyMask; | |
300 | cwa.border_pixel = color.pixel; | |
301 | cwa.background_pixel = color.pixel; | |
302 | ||
303 | if (aVis->visualid == wattr.visual->visualid) | |
304 | { | |
5e27df78 | 305 | aWindow = aParent; |
2166f0fa SK |
306 | } |
307 | else | |
308 | { | |
309 | unsigned long mask = CWBackPixel | CWColormap | CWBorderPixel | CWEventMask; | |
5e27df78 | 310 | aWindow = XCreateWindow (aDisp, aParent, 0, 0, myWidth, myHeight, 0/*bw*/, aVis->depth, InputOutput, aVis->visual, mask, &cwa); |
2166f0fa SK |
311 | } |
312 | ||
5e27df78 | 313 | XSetWindowBackground (aDisp, aWindow, cwa.background_pixel); |
314 | XClearWindow (aDisp, aWindow); | |
2166f0fa | 315 | |
5e27df78 | 316 | if (aWindow != aParent) |
2166f0fa SK |
317 | { |
318 | XEvent anEvent; | |
5e27df78 | 319 | XMapWindow (aDisp, aWindow); |
320 | XIfEvent (aDisp, &anEvent, WaitForNotify, (char* )aWindow); | |
2166f0fa | 321 | } |
2166f0fa SK |
322 | } |
323 | ||
324 | /* | |
325 | * Le BackDitherProp est utilise pour le clear du background | |
326 | * Pour eviter une difference de couleurs avec la couleur choisie | |
327 | * par l'application (XWindow) il faut desactiver le dithering | |
328 | * au dessus de 8 plans. | |
329 | * | |
330 | * Pour le DitherProp: | |
331 | * On cherchera a activer le Dithering que si le Visual a au moins | |
332 | * 8 plans pour le GLX_RED_SIZE. Le test est plus sur car on peut | |
333 | * avoir une profondeur superieure a 12 mais avoir besoin du dithering. | |
334 | * (Carte Impact avec GLX_RED_SIZE a 5 par exemple) | |
335 | */ | |
336 | ||
5e27df78 | 337 | int aValue; |
338 | glXGetConfig (aDisp, aVis, GLX_RED_SIZE, &aValue); | |
2166f0fa SK |
339 | |
340 | if (myDither) | |
5e27df78 | 341 | myDither = (aValue < 8); |
2166f0fa SK |
342 | |
343 | if (myBackDither) | |
344 | myBackDither = (aVis->depth <= 8); | |
345 | ||
346 | XFree ((char* )aVis); | |
347 | ||
5e27df78 | 348 | myGlContext->Init ((Aspect_Drawable )aWindow, (Aspect_Display )myDisplay->GetDisplay(), (Aspect_RenderingContext )aGContext); |
2166f0fa | 349 | #endif |
5e27df78 | 350 | myGlContext->Share (theShareCtx); |
2166f0fa SK |
351 | |
352 | Init(); | |
2166f0fa SK |
353 | } |
354 | ||
355 | // ======================================================================= | |
356 | // function : ~OpenGl_Window | |
357 | // purpose : | |
358 | // ======================================================================= | |
359 | OpenGl_Window::~OpenGl_Window() | |
360 | { | |
2166f0fa | 361 | #if (defined(_WIN32) || defined(__WIN32__)) |
5e27df78 | 362 | HWND aWindow = (HWND )myGlContext->myWindow; |
363 | HDC aWindowDC = (HDC )myGlContext->myWindowDC; | |
364 | HGLRC aGContext = (HGLRC )myGlContext->myGContext; | |
365 | myGlContext.Nullify(); | |
2166f0fa | 366 | |
5e27df78 | 367 | if (myOwnGContext) |
2166f0fa | 368 | { |
5e27df78 | 369 | if (wglGetCurrentContext() != NULL) |
2166f0fa | 370 | { |
5e27df78 | 371 | wglDeleteContext (aGContext); |
2166f0fa | 372 | } |
5e27df78 | 373 | ReleaseDC (aWindow, aWindowDC); |
2166f0fa | 374 | } |
5e27df78 | 375 | #else |
376 | GLXDrawable aWindow = (GLXDrawable )myGlContext->myWindow; | |
377 | Display* aDisplay = (Display* )myGlContext->myDisplay; | |
378 | GLXContext aGContext = (GLXContext )myGlContext->myGContext; | |
379 | myGlContext.Nullify(); | |
380 | ||
381 | if (aDisplay != NULL && myOwnGContext) | |
2166f0fa | 382 | { |
5e27df78 | 383 | // FSXXX sync necessary if non-direct rendering |
384 | glXWaitGL(); | |
385 | glXDestroyContext (aDisplay, aGContext); | |
2166f0fa SK |
386 | } |
387 | #endif | |
388 | } | |
389 | ||
390 | // ======================================================================= | |
391 | // function : Activate | |
392 | // purpose : | |
393 | // ======================================================================= | |
394 | Standard_Boolean OpenGl_Window::Activate() | |
395 | { | |
86fa64d9 | 396 | return myGlContext->MakeCurrent(); |
2166f0fa SK |
397 | } |
398 | ||
399 | // ======================================================================= | |
400 | // function : Resize | |
401 | // purpose : call_subr_resize | |
402 | // ======================================================================= | |
403 | void OpenGl_Window::Resize (const CALL_DEF_WINDOW& theCWindow) | |
404 | { | |
405 | DISPLAY* aDisp = (DISPLAY* )myDisplay->GetDisplay(); | |
406 | if (aDisp == NULL) | |
407 | return; | |
408 | ||
409 | // If the size is not changed - do nothing | |
410 | if ((myWidth == theCWindow.dx) && (myHeight == theCWindow.dy)) | |
411 | return; | |
412 | ||
413 | myWidth = (Standard_Integer )theCWindow.dx; | |
414 | myHeight = (Standard_Integer )theCWindow.dy; | |
415 | ||
416 | #if (!defined(_WIN32) && !defined(__WIN32__)) | |
5e27df78 | 417 | XResizeWindow (aDisp, myGlContext->myWindow, (unsigned int )myWidth, (unsigned int )myHeight); |
2166f0fa SK |
418 | XSync (aDisp, False); |
419 | #endif | |
420 | ||
421 | Init(); | |
422 | } | |
423 | ||
424 | // ======================================================================= | |
425 | // function : ReadDepths | |
426 | // purpose : TelReadDepths | |
427 | // ======================================================================= | |
428 | void OpenGl_Window::ReadDepths (const Standard_Integer theX, const Standard_Integer theY, | |
429 | const Standard_Integer theWidth, const Standard_Integer theHeight, | |
430 | float* theDepths) | |
431 | { | |
432 | if (theDepths == NULL || !Activate()) | |
433 | return; | |
434 | ||
435 | glMatrixMode (GL_PROJECTION); | |
436 | glLoadIdentity(); | |
437 | gluOrtho2D (0.0, (GLdouble )myWidth, 0.0, (GLdouble )myHeight); | |
438 | glMatrixMode (GL_MODELVIEW); | |
439 | glLoadIdentity(); | |
440 | ||
441 | glRasterPos2i (theX, theY); | |
442 | DisableFeatures(); | |
443 | glReadPixels (theX, theY, theWidth, theHeight, GL_DEPTH_COMPONENT, GL_FLOAT, theDepths); | |
444 | EnableFeatures(); | |
445 | } | |
446 | ||
447 | // ======================================================================= | |
448 | // function : SetBackgroundColor | |
449 | // purpose : call_subr_set_background | |
450 | // ======================================================================= | |
451 | void OpenGl_Window::SetBackgroundColor (const Standard_ShortReal theR, | |
452 | const Standard_ShortReal theG, | |
453 | const Standard_ShortReal theB) | |
454 | { | |
455 | myBgColor.rgb[0] = theR; | |
456 | myBgColor.rgb[1] = theG; | |
457 | myBgColor.rgb[2] = theB; | |
458 | } | |
459 | ||
460 | // ======================================================================= | |
461 | // function : Init | |
462 | // purpose : | |
463 | // ======================================================================= | |
464 | void OpenGl_Window::Init() | |
465 | { | |
466 | if (!Activate()) | |
467 | return; | |
468 | ||
469 | #if (defined(_WIN32) || defined(__WIN32__)) | |
470 | RECT cr; | |
5e27df78 | 471 | GetClientRect ((HWND )myGlContext->myWindow, &cr); |
2166f0fa SK |
472 | myWidth = cr.right - cr.left; |
473 | myHeight = cr.bottom - cr.top; | |
474 | #else | |
475 | Window aRootWin; | |
476 | int aDummy; | |
477 | unsigned int aDummyU; | |
478 | unsigned int aNewWidth = 0; | |
479 | unsigned int aNewHeight = 0; | |
480 | DISPLAY* aDisp = (DISPLAY* )myDisplay->GetDisplay(); | |
5e27df78 | 481 | XGetGeometry (aDisp, myGlContext->myWindow, &aRootWin, &aDummy, &aDummy, &aNewWidth, &aNewHeight, &aDummyU, &aDummyU); |
2166f0fa SK |
482 | myWidth = aNewWidth; |
483 | myHeight = aNewHeight; | |
484 | #endif | |
485 | ||
486 | glMatrixMode (GL_MODELVIEW); | |
487 | glViewport (0, 0, myWidth, myHeight); | |
488 | ||
489 | glDisable (GL_SCISSOR_TEST); | |
490 | glDrawBuffer (GL_BACK); | |
491 | } | |
492 | ||
493 | // ======================================================================= | |
494 | // function : EnablePolygonOffset | |
495 | // purpose : call_subr_enable_polygon_offset | |
496 | // ======================================================================= | |
497 | void OpenGl_Window::EnablePolygonOffset() const | |
498 | { | |
499 | Standard_ShortReal aFactor, aUnits; | |
500 | myDisplay->PolygonOffset (aFactor, aUnits); | |
501 | glPolygonOffset (aFactor, aUnits); | |
502 | glEnable (GL_POLYGON_OFFSET_FILL); | |
503 | } | |
504 | ||
505 | // ======================================================================= | |
506 | // function : DisablePolygonOffset | |
507 | // purpose : call_subr_disable_polygon_offset | |
508 | // ======================================================================= | |
509 | void OpenGl_Window::DisablePolygonOffset() const | |
510 | { | |
511 | glDisable (GL_POLYGON_OFFSET_FILL); | |
512 | } | |
513 | ||
514 | // ======================================================================= | |
515 | // function : EnableFeatures | |
516 | // purpose : | |
517 | // ======================================================================= | |
518 | void OpenGl_Window::EnableFeatures() const | |
519 | { | |
520 | /*glPixelTransferi (GL_MAP_COLOR, GL_TRUE);*/ | |
521 | ||
522 | if (myDither) | |
523 | glEnable (GL_DITHER); | |
524 | else | |
525 | glDisable (GL_DITHER); | |
526 | } | |
527 | ||
528 | // ======================================================================= | |
529 | // function : DisableFeatures | |
530 | // purpose : | |
531 | // ======================================================================= | |
532 | void OpenGl_Window::DisableFeatures() const | |
533 | { | |
534 | glDisable (GL_DITHER); | |
535 | glPixelTransferi (GL_MAP_COLOR, GL_FALSE); | |
536 | ||
537 | /* | |
538 | * Disable stuff that's likely to slow down glDrawPixels. | |
539 | * (Omit as much of this as possible, when you know in advance | |
540 | * that the OpenGL state will already be set correctly.) | |
541 | */ | |
542 | glDisable(GL_ALPHA_TEST); | |
543 | glDisable(GL_BLEND); | |
544 | glDisable(GL_DEPTH_TEST); | |
545 | glDisable(GL_FOG); | |
546 | glDisable(GL_LIGHTING); | |
547 | ||
548 | glDisable(GL_LOGIC_OP); | |
549 | glDisable(GL_STENCIL_TEST); | |
550 | glDisable(GL_TEXTURE_1D); | |
551 | glDisable(GL_TEXTURE_2D); | |
552 | glPixelTransferi(GL_MAP_COLOR, GL_FALSE); | |
553 | glPixelTransferi(GL_RED_SCALE, 1); | |
554 | glPixelTransferi(GL_RED_BIAS, 0); | |
555 | glPixelTransferi(GL_GREEN_SCALE, 1); | |
556 | glPixelTransferi(GL_GREEN_BIAS, 0); | |
557 | glPixelTransferi(GL_BLUE_SCALE, 1); | |
558 | glPixelTransferi(GL_BLUE_BIAS, 0); | |
559 | glPixelTransferi(GL_ALPHA_SCALE, 1); | |
560 | glPixelTransferi(GL_ALPHA_BIAS, 0); | |
561 | ||
562 | /* | |
563 | * Disable extensions that could slow down glDrawPixels. | |
564 | * (Actually, you should check for the presence of the proper | |
565 | * extension before making these calls. I've omitted that | |
566 | * code for simplicity.) | |
567 | */ | |
568 | ||
569 | #ifdef GL_EXT_convolution | |
570 | glDisable(GL_CONVOLUTION_1D_EXT); | |
571 | glDisable(GL_CONVOLUTION_2D_EXT); | |
572 | glDisable(GL_SEPARABLE_2D_EXT); | |
573 | #endif | |
574 | ||
575 | #ifdef GL_EXT_histogram | |
576 | glDisable(GL_HISTOGRAM_EXT); | |
577 | glDisable(GL_MINMAX_EXT); | |
578 | #endif | |
579 | ||
580 | #ifdef GL_EXT_texture3D | |
581 | glDisable(GL_TEXTURE_3D_EXT); | |
582 | #endif | |
583 | } | |
584 | ||
585 | // ======================================================================= | |
586 | // function : MakeFrontBufCurrent | |
587 | // purpose : TelMakeFrontBufCurrent | |
588 | // ======================================================================= | |
589 | void OpenGl_Window::MakeFrontBufCurrent() const | |
590 | { | |
591 | glDrawBuffer (GL_FRONT); | |
592 | } | |
593 | ||
594 | // ======================================================================= | |
595 | // function : MakeBackBufCurrent | |
596 | // purpose : TelMakeBackBufCurrent | |
597 | // ======================================================================= | |
598 | void OpenGl_Window::MakeBackBufCurrent() const | |
599 | { | |
600 | glDrawBuffer (GL_BACK); | |
601 | } | |
602 | ||
603 | // ======================================================================= | |
604 | // function : MakeFrontAndBackBufCurrent | |
605 | // purpose : TelMakeFrontAndBackBufCurrent | |
606 | // ======================================================================= | |
607 | void OpenGl_Window::MakeFrontAndBackBufCurrent() const | |
608 | { | |
609 | glDrawBuffer (GL_FRONT_AND_BACK); | |
610 | } | |
5e27df78 | 611 | |
612 | // ======================================================================= | |
613 | // function : GetGContext | |
614 | // purpose : | |
615 | // ======================================================================= | |
616 | GLCONTEXT OpenGl_Window::GetGContext() const | |
617 | { | |
618 | return (GLCONTEXT )myGlContext->myGContext; | |
619 | } |