![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rw_imp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / win32|
Return to rw_imp.c CVS log | Up to [Quake II] / quake2 / win32 |
1.1 root 1: /*
2: ** RW_IMP.C
3: **
4: ** This file contains ALL Win32 specific stuff having to do with the
5: ** software refresh. When a port is being made the following functions
6: ** must be implemented by the port:
7: **
8: ** SWimp_EndFrame
9: ** SWimp_Init
10: ** SWimp_SetPalette
11: ** SWimp_Shutdown
12: */
13: #include "..\ref_soft\r_local.h"
14: #include "rw_win.h"
15: #include "winquake.h"
16:
17: // Console variables that we need to access from this module
18:
19: swwstate_t sww_state;
20:
21: /*
22: ** VID_CreateWindow
23: */
24: #define WINDOW_CLASS_NAME "Quake 2"
25:
26: void VID_CreateWindow( int width, int height, int stylebits )
27: {
28: WNDCLASS wc;
29: RECT r;
30: cvar_t *vid_xpos, *vid_ypos, *vid_fullscreen;
31: int x, y, w, h;
32: int exstyle;
33:
34: vid_xpos = ri.Cvar_Get ("vid_xpos", "0", 0);
35: vid_ypos = ri.Cvar_Get ("vid_ypos", "0", 0);
36: vid_fullscreen = ri.Cvar_Get ("vid_fullscreen", "0", CVAR_ARCHIVE );
37:
38: if ( vid_fullscreen->value )
39: exstyle = WS_EX_TOPMOST;
40: else
41: exstyle = 0;
42:
43: /* Register the frame class */
44: wc.style = 0;
45: wc.lpfnWndProc = (WNDPROC)sww_state.wndproc;
46: wc.cbClsExtra = 0;
47: wc.cbWndExtra = 0;
48: wc.hInstance = sww_state.hInstance;
49: wc.hIcon = 0;
50: wc.hCursor = LoadCursor (NULL,IDC_ARROW);
51: wc.hbrBackground = (void *)COLOR_GRAYTEXT;
52: wc.lpszMenuName = 0;
53: wc.lpszClassName = WINDOW_CLASS_NAME;
54:
55: if (!RegisterClass (&wc) )
56: ri.Sys_Error (ERR_FATAL, "Couldn't register window class");
57:
58: r.left = 0;
59: r.top = 0;
60: r.right = width;
61: r.bottom = height;
62:
63: AdjustWindowRect (&r, stylebits, FALSE);
64:
65: w = r.right - r.left;
66: h = r.bottom - r.top;
67: x = vid_xpos->value;
68: y = vid_ypos->value;
69:
70: sww_state.hWnd = CreateWindowEx (
71: exstyle,
72: WINDOW_CLASS_NAME,
73: "Quake 2",
74: stylebits,
75: x, y, w, h,
76: NULL,
77: NULL,
78: sww_state.hInstance,
79: NULL);
80:
81: if (!sww_state.hWnd)
82: ri.Sys_Error (ERR_FATAL, "Couldn't create window");
83:
84: ShowWindow( sww_state.hWnd, SW_SHOWNORMAL );
85: UpdateWindow( sww_state.hWnd );
86: SetForegroundWindow( sww_state.hWnd );
87: SetFocus( sww_state.hWnd );
88:
89: // let the sound and input subsystems know about the new window
90: ri.Vid_NewWindow (width, height);
91: }
92:
93: /*
94: ** SWimp_Init
95: **
96: ** This routine is responsible for initializing the implementation
97: ** specific stuff in a software rendering subsystem.
98: */
99: int SWimp_Init( void *hInstance, void *wndProc )
100: {
101: sww_state.hInstance = ( HINSTANCE ) hInstance;
102: sww_state.wndproc = wndProc;
103:
104: return true;
105: }
106:
107: /*
108: ** SWimp_InitGraphics
109: **
110: ** This initializes the software refresh's implementation specific
111: ** graphics subsystem. In the case of Windows it creates DIB or
112: ** DDRAW surfaces.
113: **
114: ** The necessary width and height parameters are grabbed from
115: ** vid.width and vid.height.
116: */
117: static qboolean SWimp_InitGraphics( qboolean fullscreen )
118: {
119: // free resources in use
120: SWimp_Shutdown ();
121:
122: // create a new window
123: VID_CreateWindow (vid.width, vid.height, WINDOW_STYLE);
124:
125: // initialize the appropriate subsystem
126: if ( !fullscreen )
127: {
128: if ( !DIB_Init( &vid.buffer, &vid.rowbytes ) )
129: {
130: vid.buffer = 0;
131: vid.rowbytes = 0;
132:
133: return false;
134: }
135: }
136: else
137: {
138: if ( !DDRAW_Init( &vid.buffer, &vid.rowbytes ) )
139: {
140: vid.buffer = 0;
141: vid.rowbytes = 0;
142:
143: return false;
144: }
145: }
146:
147: return true;
148: }
149:
150: /*
151: ** SWimp_EndFrame
152: **
153: ** This does an implementation specific copy from the backbuffer to the
154: ** front buffer. In the Win32 case it uses BitBlt or BltFast depending
155: ** on whether we're using DIB sections/GDI or DDRAW.
156: */
157: void SWimp_EndFrame (void)
158: {
159: if ( !sw_state.fullscreen )
160: {
161: if ( sww_state.palettized )
162: {
163: // holdpal = SelectPalette(hdcScreen, hpalDIB, FALSE);
164: // RealizePalette(hdcScreen);
165: }
166:
167:
168: BitBlt( sww_state.hDC,
169: 0, 0,
170: vid.width,
171: vid.height,
172: sww_state.hdcDIBSection,
173: 0, 0,
174: SRCCOPY );
175:
176: if ( sww_state.palettized )
177: {
178: // SelectPalette(hdcScreen, holdpal, FALSE);
179: }
180: }
181: else
182: {
183: RECT r;
184: HRESULT rval;
185: DDSURFACEDESC ddsd;
186:
187: r.left = 0;
188: r.top = 0;
189: r.right = vid.width;
190: r.bottom = vid.height;
191:
192: sww_state.lpddsOffScreenBuffer->lpVtbl->Unlock( sww_state.lpddsOffScreenBuffer, vid.buffer );
193:
194: if ( sww_state.modex )
195: {
196: if ( ( rval = sww_state.lpddsBackBuffer->lpVtbl->BltFast( sww_state.lpddsBackBuffer,
197: 0, 0,
198: sww_state.lpddsOffScreenBuffer,
199: &r,
200: DDBLTFAST_WAIT ) ) == DDERR_SURFACELOST )
201: {
202: sww_state.lpddsBackBuffer->lpVtbl->Restore( sww_state.lpddsBackBuffer );
203: sww_state.lpddsBackBuffer->lpVtbl->BltFast( sww_state.lpddsBackBuffer,
204: 0, 0,
205: sww_state.lpddsOffScreenBuffer,
206: &r,
207: DDBLTFAST_WAIT );
208: }
209:
210: if ( ( rval = sww_state.lpddsFrontBuffer->lpVtbl->Flip( sww_state.lpddsFrontBuffer,
211: NULL, DDFLIP_WAIT ) ) == DDERR_SURFACELOST )
212: {
213: sww_state.lpddsFrontBuffer->lpVtbl->Restore( sww_state.lpddsFrontBuffer );
214: sww_state.lpddsFrontBuffer->lpVtbl->Flip( sww_state.lpddsFrontBuffer, NULL, DDFLIP_WAIT );
215: }
216: }
217: else
218: {
219: if ( ( rval = sww_state.lpddsBackBuffer->lpVtbl->BltFast( sww_state.lpddsFrontBuffer,
220: 0, 0,
221: sww_state.lpddsOffScreenBuffer,
222: &r,
223: DDBLTFAST_WAIT ) ) == DDERR_SURFACELOST )
224: {
225: sww_state.lpddsBackBuffer->lpVtbl->Restore( sww_state.lpddsFrontBuffer );
226: sww_state.lpddsBackBuffer->lpVtbl->BltFast( sww_state.lpddsFrontBuffer,
227: 0, 0,
228: sww_state.lpddsOffScreenBuffer,
229: &r,
230: DDBLTFAST_WAIT );
231: }
232: }
233:
234: memset( &ddsd, 0, sizeof( ddsd ) );
235: ddsd.dwSize = sizeof( ddsd );
236:
237: sww_state.lpddsOffScreenBuffer->lpVtbl->Lock( sww_state.lpddsOffScreenBuffer, NULL, &ddsd, DDLOCK_WAIT, NULL );
238:
239: vid.buffer = ddsd.lpSurface;
240: vid.rowbytes = ddsd.lPitch;
241: }
242: }
243:
244: /*
245: ** SWimp_SetMode
246: */
247: rserr_t SWimp_SetMode( int *pwidth, int *pheight, int mode, qboolean fullscreen )
248: {
249: const char *win_fs[] = { "W", "FS" };
250: rserr_t retval = rserr_ok;
251:
252: ri.Con_Printf (PRINT_ALL, "setting mode %d:", mode );
253:
254: if ( !ri.Vid_GetModeInfo( pwidth, pheight, mode ) )
255: {
256: ri.Con_Printf( PRINT_ALL, " invalid mode\n" );
257: return rserr_invalid_mode;
258: }
259:
260: ri.Con_Printf( PRINT_ALL, " %d %d %s\n", *pwidth, *pheight, win_fs[fullscreen] );
261:
262: sww_state.initializing = true;
263: if ( fullscreen )
264: {
265: if ( !SWimp_InitGraphics( 1 ) )
266: {
267: if ( SWimp_InitGraphics( 0 ) )
268: {
269: // mode is legal but not as fullscreen
270: fullscreen = 0;
271: retval = rserr_invalid_fullscreen;
272: }
273: else
274: {
275: // failed to set a valid mode in windowed mode
276: retval = rserr_unknown;
277: }
278: }
279: }
280: else
281: {
282: // failure to set a valid mode in windowed mode
283: if ( !SWimp_InitGraphics( fullscreen ) )
284: {
285: sww_state.initializing = true;
286: return rserr_unknown;
287: }
288: }
289:
290: sw_state.fullscreen = fullscreen;
291: #if 0
292: if ( retval != rserr_unknown )
293: {
294: if ( retval == rserr_invalid_fullscreen ||
295: ( retval == rserr_ok && !fullscreen ) )
296: {
297: SetWindowLong( sww_state.hWnd, GWL_STYLE, WINDOW_STYLE );
298: }
299: }
300: #endif
301: R_GammaCorrectAndSetPalette( ( const unsigned char * ) d_8to24table );
302: sww_state.initializing = true;
303:
304: return retval;
305: }
306:
307: /*
308: ** SWimp_SetPalette
309: **
310: ** System specific palette setting routine. A NULL palette means
311: ** to use the existing palette. The palette is expected to be in
312: ** a padded 4-byte xRGB format.
313: */
314: void SWimp_SetPalette( const unsigned char *palette )
315: {
316: // MGL - what the fuck was kendall doing here?!
317: // clear screen to black and change palette
318: // for (i=0 ; i<vid.height ; i++)
319: // memset (vid.buffer + i*vid.rowbytes, 0, vid.width);
320:
321: if ( !palette )
322: palette = ( const unsigned char * ) sw_state.currentpalette;
323:
324: if ( !sw_state.fullscreen )
325: {
326: DIB_SetPalette( ( const unsigned char * ) palette );
327: }
328: else
329: {
330: DDRAW_SetPalette( ( const unsigned char * ) palette );
331: }
332: }
333:
334: /*
335: ** SWimp_Shutdown
336: **
337: ** System specific graphics subsystem shutdown routine. Destroys
338: ** DIBs or DDRAW surfaces as appropriate.
339: */
340: void SWimp_Shutdown( void )
341: {
342: ri.Con_Printf( PRINT_ALL, "Shutting down SW imp\n" );
343: DIB_Shutdown();
344: DDRAW_Shutdown();
345:
346: if ( sww_state.hWnd )
347: {
348: ri.Con_Printf( PRINT_ALL, "...destroying window\n" );
349: ShowWindow( sww_state.hWnd, SW_SHOWNORMAL ); // prevents leaving empty slots in the taskbar
350: DestroyWindow (sww_state.hWnd);
351: sww_state.hWnd = NULL;
352: UnregisterClass (WINDOW_CLASS_NAME, sww_state.hInstance);
353: }
354: }
355:
356: /*
357: ** SWimp_AppActivate
358: */
359: void SWimp_AppActivate( qboolean active )
360: {
361: if ( active )
362: {
363: if ( sww_state.hWnd )
364: {
365: SetForegroundWindow( sww_state.hWnd );
366: ShowWindow( sww_state.hWnd, SW_RESTORE );
367: }
368: }
369: else
370: {
371: if ( sww_state.hWnd )
372: {
373: if ( sww_state.initializing )
374: return;
375: if ( vid_fullscreen->value )
376: ShowWindow( sww_state.hWnd, SW_MINIMIZE );
377: }
378: }
379: }
380:
381: //===============================================================================
382:
383:
384: /*
385: ================
386: Sys_MakeCodeWriteable
387: ================
388: */
389: void Sys_MakeCodeWriteable (unsigned long startaddr, unsigned long length)
390: {
391: DWORD flOldProtect;
392:
393: if (!VirtualProtect((LPVOID)startaddr, length, PAGE_READWRITE, &flOldProtect))
394: ri.Sys_Error(ERR_FATAL, "Protection change failed\n");
395: }
396:
397: /*
398: ** Sys_SetFPCW
399: **
400: ** For reference:
401: **
402: ** 1
403: ** 5 0
404: ** xxxxRRPP.xxxxxxxx
405: **
406: ** PP = 00 = 24-bit single precision
407: ** PP = 01 = reserved
408: ** PP = 10 = 53-bit double precision
409: ** PP = 11 = 64-bit extended precision
410: **
411: ** RR = 00 = round to nearest
412: ** RR = 01 = round down (towards -inf, floor)
413: ** RR = 10 = round up (towards +inf, ceil)
414: ** RR = 11 = round to zero (truncate/towards 0)
415: **
416: */
417: #if !id386
418: void Sys_SetFPCW (void)
419: {
420: }
421: #else
422: unsigned fpu_ceil_cw, fpu_chop_cw, fpu_full_cw, fpu_cw, fpu_pushed_cw;
423: unsigned fpu_sp24_cw, fpu_sp24_ceil_cw;
424:
425: void Sys_SetFPCW( void )
426: {
427: __asm xor eax, eax
428:
429: __asm fnstcw word ptr fpu_cw
430: __asm mov ax, word ptr fpu_cw
431:
432: __asm and ah, 0f0h
433: __asm or ah, 003h ; round to nearest mode, extended precision
434: __asm mov fpu_full_cw, eax
435:
436: __asm and ah, 0f0h
437: __asm or ah, 00fh ; RTZ/truncate/chop mode, extended precision
438: __asm mov fpu_chop_cw, eax
439:
440: __asm and ah, 0f0h
441: __asm or ah, 00bh ; ceil mode, extended precision
442: __asm mov fpu_ceil_cw, eax
443:
444: __asm and ah, 0f0h ; round to nearest, 24-bit single precision
445: __asm mov fpu_sp24_cw, eax
446:
447: __asm and ah, 0f0h ; ceil mode, 24-bit single precision
448: __asm or ah, 008h ;
449: __asm mov fpu_sp24_ceil_cw, eax
450: }
451: #endif
452:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.