source: trunk/src/ddraw/OS2DDRAW.CPP@ 5293

Last change on this file since 5293 was 5291, checked in by mike, 25 years ago

Updates/cleanup for Watcom (not complete)
File size: 63.5 KB
Line 
1/* $Id: OS2DDRAW.CPP,v 1.25 2001-03-09 22:48:46 mike Exp $ */
2
3/*
4 * DX Draw base class implementation
5 *
6 * Copyright 1998 Sander va Leeuwen
7 * Copyright 1999 Markus Montkowski
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12
13#include <stdlib.h>
14#include <string.h>
15#include <memory.h>
16
17#define INITGUID
18#include "os2ddraw.h"
19#include "os2clipper.h"
20#include "os2palette.h"
21#include "os2surface.h"
22#define _OS2WIN_H
23#define FAR
24#include <misc.h>
25#include <string.h>
26#include <winreg.h>
27#include <winuser.h>
28#include <winerror.h>
29#include "cio2.h"
30#include "os2util.h"
31// include with the videomodes we support
32// better would be to get these modes from the card
33// But for now we use standard VESA 2.0 modes with 70Hz
34#include "os2ddrawmodes.h"
35#include "os2DDWindow.h"
36#include "os2palset.h"
37
38#define KEY_DIRECT2 "\\Software\\Win32OS2\\Direct2"
39#define KEY_DIRECT2DRAW "\\Software\\Win32OS2\\Direct2\\Draw"
40
41FOURCC SupportedFourCCs[] = {FOURCC_SCRN,FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3,FOURCC_RGB4};
42//******************************************************************************
43//******************************************************************************
44OS2IDirectDraw::OS2IDirectDraw(GUID *lpGUID) :
45 Referenced(0), lastError(DD_OK),
46 pFrameBuffer(NULL), hwndClient(0), screenwidth(640),
47 screenheight(480), screenbpp(8),PrimaryExists(FALSE),pPrimSurf(NULL)
48
49{
50 HKEY hkDirectDraw2;
51 DWORD dwVSize, dwVType;
52 ULONG rc;
53 FOURCC fccModes[100];
54
55 // Setup table for 3d devices
56 Vtbl3D.AddRef = D3DAddRef;
57 Vtbl3D.Release = D3DRelease;
58 Vtbl3D.QueryInterface = D3DQueryInterface;
59 Vtbl3D.Initialize = D3DInitialize;
60 Vtbl3D.EnumDevices = D3DEnumDevices;
61 Vtbl3D.CreateLight = D3DCreateLight;
62 Vtbl3D.CreateMaterial = D3DCreateMaterial;
63 Vtbl3D.CreateViewport = D3DCreateViewport;
64 Vtbl3D.FindDevice = D3DFindDevice;
65
66 // Org Interface
67 Vtbl.AddRef = DrawAddRef;
68 Vtbl.Release = DrawRelease;
69 Vtbl.QueryInterface = DrawQueryInterface;
70 Vtbl.Compact = DrawCompact;
71 Vtbl.CreateClipper = DrawCreateClipper;
72 Vtbl.CreatePalette = DrawCreatePalette;
73 Vtbl.CreateSurface = DrawCreateSurface;
74 Vtbl.DuplicateSurface = DrawDuplicateSurface;
75 Vtbl.EnumDisplayModes = DrawEnumDisplayModes;
76 Vtbl.EnumSurfaces = DrawEnumSurfaces;
77 Vtbl.FlipToGDISurface = DrawFlipToGDISurface;
78 Vtbl.GetCaps = DrawGetCaps;
79 Vtbl.GetDisplayMode = DrawGetDisplayMode;
80 Vtbl.GetFourCCCodes = DrawGetFourCCCodes;
81 Vtbl.GetGDISurface = DrawGetGDISurface;
82 Vtbl.GetMonitorFrequency = DrawGetMonitorFrequency;
83 Vtbl.GetScanLine = DrawGetScanLine;
84 Vtbl.GetVerticalBlankStatus = DrawGetVerticalBlankStatus;
85 Vtbl.Initialize = DrawInitialize;
86 Vtbl.RestoreDisplayMode = DrawRestoreDisplayMode;
87 Vtbl.SetCooperativeLevel = DrawSetCooperativeLevel;
88 Vtbl.SetDisplayMode = DrawSetDisplayMode;
89 Vtbl.WaitForVerticalBlank = DrawWaitForVerticalBlank;
90
91 // V2 Interface
92
93 Vtbl2.AddRef = DrawAddRef;
94 Vtbl2.Release = DrawRelease;
95 Vtbl2.QueryInterface = DrawQueryInterface;
96 Vtbl2.Compact = DrawCompact;
97 Vtbl2.CreateClipper = DrawCreateClipper;
98 Vtbl2.CreatePalette = DrawCreatePalette;
99 Vtbl2.CreateSurface = DrawCreateSurface;
100 Vtbl2.DuplicateSurface = DrawDuplicateSurface;
101 Vtbl2.EnumDisplayModes = DrawEnumDisplayModes;
102 Vtbl2.EnumSurfaces = DrawEnumSurfaces;
103 Vtbl2.FlipToGDISurface = DrawFlipToGDISurface;
104 Vtbl2.GetCaps = DrawGetCaps;
105 Vtbl2.GetDisplayMode = DrawGetDisplayMode;
106 Vtbl2.GetFourCCCodes = DrawGetFourCCCodes;
107 Vtbl2.GetGDISurface = DrawGetGDISurface;
108 Vtbl2.GetMonitorFrequency = DrawGetMonitorFrequency;
109 Vtbl2.GetScanLine = DrawGetScanLine;
110 Vtbl2.GetVerticalBlankStatus = DrawGetVerticalBlankStatus;
111 Vtbl2.Initialize = DrawInitialize;
112 Vtbl2.RestoreDisplayMode = DrawRestoreDisplayMode;
113 Vtbl2.SetCooperativeLevel = DrawSetCooperativeLevel;
114 Vtbl2.SetDisplayMode = DrawSetDisplayMode2;
115 Vtbl2.WaitForVerticalBlank = DrawWaitForVerticalBlank;
116 Vtbl2.GetAvailableVidMem = DrawGetAvailableVidMem;
117
118 // New V4 interface
119 Vtbl4.AddRef = DrawAddRef; // todo change to a DrawAddRef4 as handling this has changed
120 Vtbl4.Release = DrawRelease; // see above
121 Vtbl4.QueryInterface = DrawQueryInterface;
122 Vtbl4.Compact = DrawCompact;
123 Vtbl4.CreateClipper = DrawCreateClipper;
124 Vtbl4.CreatePalette = DrawCreatePalette;
125 Vtbl4.CreateSurface = DrawCreateSurface4;//
126 Vtbl4.DuplicateSurface = DrawDuplicateSurface4;//
127 Vtbl4.EnumDisplayModes = DrawEnumDisplayModes4;//
128 Vtbl4.EnumSurfaces = DrawEnumSurfaces4; //
129 Vtbl4.FlipToGDISurface = DrawFlipToGDISurface;
130 Vtbl4.GetCaps = DrawGetCaps;
131 Vtbl4.GetDisplayMode = DrawGetDisplayMode4;//
132 Vtbl4.GetFourCCCodes = DrawGetFourCCCodes;
133 Vtbl4.GetGDISurface = DrawGetGDISurface4;//
134 Vtbl4.GetMonitorFrequency = DrawGetMonitorFrequency;
135 Vtbl4.GetScanLine = DrawGetScanLine;
136 Vtbl4.GetVerticalBlankStatus = DrawGetVerticalBlankStatus;
137 Vtbl4.Initialize = DrawInitialize;
138 Vtbl4.RestoreDisplayMode = DrawRestoreDisplayMode;
139 Vtbl4.SetCooperativeLevel = DrawSetCooperativeLevel;
140 Vtbl4.SetDisplayMode = DrawSetDisplayMode2;
141 Vtbl4.WaitForVerticalBlank = DrawWaitForVerticalBlank;
142 Vtbl4.GetAvailableVidMem = DrawGetAvailableVidMem4;
143 Vtbl4.GetSurfaceFromDC = DrawGetSurfaceFromDC;
144 Vtbl4.RestoreAllSurfaces = DrawRestoreAllSurfaces;
145 Vtbl4.TestCooperativeLevel = DrawTestCooperativeLevel;
146 Vtbl4.GetDeviceIdentifier = DrawGetDeviceIdentifier;
147
148 if(lpGUID && *lpGUID == IID_IDirect3D)
149 {
150 dprintf(("DDRAW: D3D Interface -> using V4 Interface"));
151
152 lpVtbl = &Vtbl4;
153 }
154 else
155 {
156 if(lpGUID && *lpGUID == IID_IDirectDraw4)
157 {
158 dprintf(("DDRAW: V4 Interface\n"));
159 lpVtbl = &Vtbl4;
160 }
161 else
162 {
163 dprintf(("DDRAW: <V4 Interface\n"));
164 lpVtbl = (IDirectDraw4Vtbl *) &Vtbl;
165 }
166 }
167
168 lpVtbl2 = lpVtbl;
169
170 pdwUnknownData = (DWORD*) malloc (255*sizeof(DWORD));
171 for(int i= 0 ;i<255;i++)
172 pdwUnknownData[i] = 0;
173
174 rc = DiveOpen( &hDive,
175 FALSE,
176 &pFrameBuffer);
177 if(rc)
178 {
179 dprintf(("DDRAW: ERROR: DiveOpen returned %d\n", rc));
180 lastError = DDERR_GENERIC;
181 hDive = NULL;
182 }
183 else
184 {
185 dprintf(("DDRAW: DiveOpen OK Framebuufer at 0x%08X\n",pFrameBuffer));
186 }
187 memset( &dCaps,
188 0,
189 sizeof(DIVE_CAPS) );
190 dCaps.ulStructLen = sizeof(DIVE_CAPS);
191 dCaps.ulFormatLength = 100;
192 dCaps.pFormatData = &fccModes[0];
193
194 rc = DiveQueryCaps( &dCaps,
195 DIVE_BUFFER_SCREEN);
196
197 dprintf(("DDRAW: DiveQueryCaps rc=0x%08X\n",rc));
198
199 pdwUnknownData[235] = dCaps.ulHorizontalResolution;
200 pdwUnknownData[236] = dCaps.ulVerticalResolution;
201 pdwUnknownData[241] = dCaps.ulDepth;
202
203 // Shall we run in FS mode ?
204 if(ERROR_SUCCESS==RegOpenKeyA(HKEY_LOCAL_MACHINE,KEY_DIRECT2DRAW,&hkDirectDraw2))
205 {
206 dwVSize = 4;
207 dwVType = REG_DWORD;
208 if(ERROR_SUCCESS!=RegQueryValueExA(hkDirectDraw2,"Fullscreen",NULL,&dwVType,(LPBYTE)&bScale,&dwVSize))
209 bScale = FALSE;
210 }
211 else
212 bScale = FALSE;
213
214 rc = InitIO();
215
216 if(rc) // try to get IOPL for the thread
217 {
218 dprintf(("DDRAW: No IOPL\n"));
219 }
220 else
221 {
222 dprintf(("DDRAW: IOPL 3!\n"));
223 }
224}
225//******************************************************************************
226//******************************************************************************
227OS2IDirectDraw::~OS2IDirectDraw()
228{
229 dprintf(("DDRAW: OS2IDirectDraw::~OS2IDirectDraw()\n"));
230 if(hDive)
231 DiveClose(hDive);
232
233 // Safty call in case the program did set the pal to all black
234 // so if the destructor gets called we might be able change this back
235 OS2ResetPhysPalette();
236}
237//******************************************************************************
238//******************************************************************************
239FOURCC OS2IDirectDraw::GetScreenFourCC()
240{
241 return SupportedFourCCs[screenbpp>>3];
242}
243//******************************************************************************
244//******************************************************************************
245HRESULT WIN32API DrawQueryInterface(THIS This, REFIID riid, LPVOID FAR * ppvObj)
246{
247 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
248
249 dprintf(("DDRAW: OS2IDirectDraw::QueryInterface %x %x %x", This, riid, ppvObj));
250
251 *ppvObj = NULL;
252
253 if(!IsEqualGUID(riid, CLSID_DirectDraw) &&
254 !IsEqualGUID(riid, IID_IDirectDraw) &&
255 !IsEqualGUID(riid, IID_IDirectDraw2) &&
256 !IsEqualGUID(riid, IID_IDirectDraw4) &&
257 !IsEqualGUID(riid, IID_IDirect3D))
258// !IsEqualGUID(riid, IID_IUnknown))
259 return E_NOINTERFACE;
260
261 // ToDo Better way of returning differnent interfaces for same class
262 if(IsEqualGUID(riid, IID_IDirect3D))
263 {
264 me->lpVtbl3D = &me->Vtbl3D;
265 me->lpVtbl3D2 = me->lpVtbl3D;
266 me->pdwUnknownData3D = me->pdwUnknownData;
267 *ppvObj = (LPVOID)&me->lpVtbl3D;
268 DrawAddRef(This);
269 return DD_OK;
270 }
271 else
272 {
273 if(IsEqualGUID(riid, IID_IDirectDraw4))
274 {
275 dprintf(("DDRAW: IID_IDirectDraw4 Interface\n"));
276 me->lpVtbl = &me->Vtbl4;
277 }
278 else
279 {
280 if(IsEqualGUID(riid, IID_IDirectDraw2))
281 {
282 dprintf(("DDRAW: IID_IDirectDraw2 Interface\n"));
283 me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl2;
284 }
285 else
286 {
287 dprintf(("DDRAW: IID_IDirectDraw Interface\n"));
288 me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl;
289 }
290 }
291 }
292 me->lpVtbl2 = me->lpVtbl;
293 *ppvObj = This;
294 DrawAddRef(This);
295
296 return(DD_OK);
297}
298//******************************************************************************
299//******************************************************************************
300ULONG WIN32API DrawAddRef(THIS This)
301{
302 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
303
304 dprintf(("DDRAW: OS2IDirectDraw::AddRef %d\n", me->Referenced+1));
305
306 return ++me->Referenced;
307}
308//******************************************************************************
309//******************************************************************************
310ULONG WIN32API DrawRelease(THIS This)
311{
312 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
313 ULONG rc;
314
315 dprintf(("DDRAW: OS2IDirectDraw::Release %d\n", me->Referenced-1));
316 dprintf(("DDRAW: OS2IDirectDraw::%X \n", me));
317
318 if(me->Referenced)
319 {
320
321 me->Referenced--;
322 if(me->Referenced == 0)
323 {
324 delete(me);
325 rc = 0;
326 }
327 else
328 rc = me->Referenced;
329 }
330 else
331 rc = 0;
332
333 return rc;
334}
335//******************************************************************************
336//******************************************************************************
337HRESULT WIN32API DrawCompact(THIS)
338{
339 dprintf(("DDRAW: Compact\n"));
340
341 return(DD_OK);
342}
343//******************************************************************************
344//******************************************************************************
345HRESULT WIN32API DrawCreateClipper(THIS This, DWORD, LPDIRECTDRAWCLIPPER FAR *lplpDD, IUnknown FAR * )
346{
347 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
348 OS2IDirectDrawClipper *newclip;
349 HRESULT rc;
350
351 newclip = new OS2IDirectDrawClipper(me);
352
353 dprintf(("DDRAW: CreateClipper\n"));
354
355 if(newclip == NULL)
356 {
357 rc = DDERR_OUTOFMEMORY;
358 }
359 else
360 {
361 newclip->Vtbl.AddRef((IDirectDrawClipper *)newclip);
362 rc = newclip->GetLastError();
363 if(rc != DD_OK)
364 {
365 *lplpDD = NULL;
366 delete newclip;
367 }
368 else
369 *lplpDD = (IDirectDrawClipper *)newclip;
370 }
371
372 return(rc);
373}
374//******************************************************************************
375//******************************************************************************
376HRESULT WIN32API DrawCreatePalette(THIS This, DWORD dwFlags,
377 LPPALETTEENTRY lpColorTable,
378 LPDIRECTDRAWPALETTE FAR *lplpDD,
379 IUnknown FAR *pUnkOuter)
380{
381 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
382 OS2IDirectDrawPalette *newpal;
383 HRESULT rc = DD_OK;
384 int palsize = 0;
385
386 if(dwFlags & DDPCAPS_8BITENTRIES)
387 {
388 // We Don't support Indexed palettes...
389
390 rc = DDERR_INVALIDPARAMS;
391 }
392
393 if(dwFlags & DDPCAPS_2BIT)
394 palsize = 4;
395 if(dwFlags & DDPCAPS_4BIT)
396 palsize = 16;
397 if(dwFlags & DDPCAPS_8BIT)
398 palsize = 256;
399 if(dwFlags & DDPCAPS_ALLOW256)
400 palsize = 256;
401
402 if(palsize == 0)
403 rc = DDERR_INVALIDPARAMS;
404
405 if(DD_OK == rc)
406 {
407 dprintf(("DDRAW: CreatePalette with %d colors\n", palsize));
408
409 newpal = new OS2IDirectDrawPalette((VOID*)me, palsize, lpColorTable, dwFlags);
410
411 if(newpal == NULL)
412 {
413 rc = DDERR_OUTOFMEMORY;
414 }
415 else
416 {
417 newpal->Vtbl.AddRef((IDirectDrawPalette *)newpal);
418 rc = newpal->GetLastError();
419
420 if(DD_OK != rc)
421 {
422 *lplpDD = NULL;
423 delete newpal;
424 }
425 else
426 *lplpDD = (IDirectDrawPalette *)newpal;
427 }
428 }
429
430 return(rc);
431}
432//******************************************************************************
433//******************************************************************************
434HRESULT WIN32API DrawCreateSurface(THIS This, LPDDSURFACEDESC lpDDSurfaceDesc,
435 LPDIRECTDRAWSURFACE FAR *lplpDD,
436 IUnknown FAR *pUnkOuter)
437{
438 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
439 OS2IDirectDrawSurface *newsurf;
440 HRESULT rc;
441
442 dprintf(("DDRAW: CreateSurface\n"));
443 dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc->dwSize));
444 dprintf(("DDRAW: dwFlags %X\n", lpDDSurfaceDesc->dwFlags));
445 dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc->dwHeight));
446 dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc->dwWidth));
447 dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc->lPitch));
448 dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc->dwBackBufferCount));
449 dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc->dwMipMapCount));
450 dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc->dwAlphaBitDepth));
451 dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc->ddsCaps.dwCaps));
452
453 newsurf = new OS2IDirectDrawSurface(me, (LPDDSURFACEDESC2)lpDDSurfaceDesc);
454 if(newsurf == NULL)
455 {
456 rc = DDERR_OUTOFMEMORY;
457 }
458 else
459 {
460 newsurf->Vtbl.AddRef((IDirectDrawSurface *)newsurf);
461 rc = newsurf->GetLastError();
462 if(rc != DD_OK)
463 {
464 dprintf(("DDRAW: Error createing Surface\n\n"));
465 *lplpDD = NULL;
466 delete newsurf;
467 }
468 else
469 *lplpDD = (IDirectDrawSurface *)newsurf;
470
471 dprintf(("DDRAW: New Surface created at %08X\n\n", newsurf));
472 }
473
474 return(rc);
475}
476//******************************************************************************
477//******************************************************************************
478HRESULT WIN32API DrawCreateSurface4(THIS This, LPDDSURFACEDESC2 lpDDSurfaceDesc2,
479 LPDIRECTDRAWSURFACE4 FAR *lplpDD,
480 IUnknown FAR *pUnkOuter)
481{
482 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
483 OS2IDirectDrawSurface *newsurf;
484 HRESULT rc;
485
486 dprintf(("DDRAW: CreateSurface4\n"));
487 dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc2->dwSize));
488 dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc2->dwHeight));
489 dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc2->dwWidth));
490 dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc2->lPitch));
491 dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc2->dwBackBufferCount));
492 dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc2->dwMipMapCount));
493 dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc2->dwAlphaBitDepth));
494 dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc2->ddsCaps.dwCaps));
495
496 newsurf = new OS2IDirectDrawSurface(me, lpDDSurfaceDesc2);
497
498 if(newsurf == NULL)
499 {
500 rc = DDERR_OUTOFMEMORY;
501 }
502 else
503 {
504 newsurf->Vtbl.AddRef((IDirectDrawSurface *)newsurf);
505 rc = newsurf->GetLastError();
506 if(rc != DD_OK)
507 {
508 dprintf(("DDRAW: Error createing Surface\n\n"));
509 *lplpDD = NULL;
510
511 delete newsurf;
512 }
513 else
514 *lplpDD = (IDirectDrawSurface4 *)newsurf;
515
516 dprintf(("DDRAW: New Surface created at %08X\n\n", newsurf));
517 }
518
519 return(rc);
520}
521//******************************************************************************
522//******************************************************************************
523HRESULT WIN32API DrawDuplicateSurface(THIS, LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * )
524{
525 dprintf(("DDRAW: DuplicateSurface NIY\n"));
526
527 return(DD_OK);
528}
529//******************************************************************************
530//******************************************************************************
531HRESULT WIN32API DrawDuplicateSurface4(THIS, LPDIRECTDRAWSURFACE4, LPDIRECTDRAWSURFACE4 FAR * )
532{
533 dprintf(("DDRAW: DuplicateSurface4 NIY\n"));
534
535 return(DD_OK);
536}
537//******************************************************************************
538//******************************************************************************
539HRESULT WIN32API DrawEnumDisplayModes( THIS This,
540 DWORD dwFlags,
541 LPDDSURFACEDESC lpDDSurfaceDesc,
542 LPVOID lpContext,
543 LPDDENUMMODESCALLBACK lpDDEnumModesCallback)
544{
545 int iMode = 0;
546 DDSURFACEDESC DDSurfAct;
547 BOOL fCallAgain;
548 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
549
550 dprintf(("DDRAW: EnumDisplayModes\n"));
551
552 // Check for Pointer to callback function
553 if (NULL == lpDDEnumModesCallback)
554 {
555 dprintf(("DDRAW: EnumDisplayModes : Error NO EnumFunction passed in\n"));
556
557 return(DDERR_GENERIC);
558 }
559
560
561 // Setting up the surface
562 // During enum we report resolution and bitdepth, maybe we should
563 // also report back : Caps and Pitch
564 memset(&DDSurfAct,0,sizeof(DDSURFACEDESC));
565 DDSurfAct.dwSize = sizeof(DDSURFACEDESC);
566 DDSurfAct.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT ;
567 // Only report the bitdepth hope this is ok this way, we must set the BitMask fields
568
569 DDSurfAct.ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
570 DDSurfAct.ddpfPixelFormat.dwFlags = DDPF_RGB;
571 // Check if we use DIVE or Voodoo
572 if(me->lpVtbl != (IDirectDraw4Vtbl *) &(me->Vtbl3D))
573 {
574 // DIVE modes
575
576 dprintf(("DDRAW: EnumDisplayModes : DIVE modes\n"));
577
578 // Enumerate all modes ?
579 if (NULL==lpDDSurfaceDesc)
580 {
581 // Check if we shall report 320x200 mode
582
583 dprintf(("DDRAW: EnumDisplayModes : ALL modes\n"));
584
585 if(dwFlags && DDEDM_STANDARDVGAMODES)
586 {
587 dprintf(("DDRAW: EnumDisplayModes : STANDARDVGAMODES\n"));
588
589 DDSurfAct.dwHeight = ModesDive[0].iYRes;
590 DDSurfAct.dwWidth = ModesDive[0].iXRes;
591 DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[0].iBits;
592 DDSurfAct.ddpfPixelFormat.dwFlags |= DDPF_PALETTEINDEXED8 ;
593 if(!lpDDEnumModesCallback(&DDSurfAct,lpContext))
594 {
595 dprintf(("DDRAW: EnumDisplayModes : Enum done\n"));
596 return (DD_OK);
597 }
598 }
599 // Don't know the flag for Mode X so we skip reporting it
600
601 // Now report all our modes
602 iMode = 2;
603 fCallAgain = TRUE;
604 do
605 {
606 // if the mode fits in the current resolution report it
607 // Change this if we support Fullscreen later !!!
608
609 if(ModesDive[iMode].iXRes < me->dCaps.ulHorizontalResolution)
610 {
611 DDSurfAct.dwHeight = ModesDive[iMode].iYRes;
612 DDSurfAct.dwWidth = ModesDive[iMode].iXRes;
613 DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[iMode].iBits;
614 switch(ModesDive[iMode].iBits)
615 {
616 case 8:
617 DDSurfAct.ddpfPixelFormat.dwFlags |= DDPF_PALETTEINDEXED8;
618 break;
619 case 16:
620 // VESA uses 565 encoding in 16 bit modes
621 DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
622 DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
623 DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
624 DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
625 break;
626 case 24:
627 // VESA uses per default RGB4
628 DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
629 DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
630 DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
631 DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x000000FF;
632 break;
633 default:
634 break;
635 }
636 dprintf( ("EnumDisplayModes : Enum Mode %dx%d @ %d\n",
637 DDSurfAct.dwHeight,
638 DDSurfAct.dwWidth,
639 DDSurfAct.ddpfPixelFormat.dwRGBBitCount));
640 fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
641 dprintf( ("EnumDisplayModes : Callback returned with %d\n",
642 fCallAgain));
643 }
644 iMode++;
645 }
646 while( (iMode < NUM_MODES_DIVE) &&
647 (ModesDive[iMode].iBits <= me->dCaps.ulDepth) &&
648 (TRUE==fCallAgain) );
649 }
650 else
651 {
652 // No, so filter modes with lpDDSurfaceDesc
653
654 // Return Error if the program want to use other than the 3 supported values
655 // for filtering
656
657 if (lpDDSurfaceDesc->dwFlags & !(DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT))
658 return(DDERR_INVALIDPARAMS);
659
660 iMode = 0;
661 if( (dwFlags && DDEDM_STANDARDVGAMODES) &&
662 (
663 (((lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)&&
664 (ModesDive[iMode].iXRes==lpDDSurfaceDesc->dwWidth)
665 )||(!(lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)))&&
666 (((lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)&&
667 (ModesDive[iMode].iYRes==lpDDSurfaceDesc->dwHeight))||
668 (!(lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)))&&
669 (((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) &&
670 (ModesDive[iMode].iBits==lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount))||
671 (!(lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT)))
672 )
673 )
674 {
675 DDSurfAct.dwHeight = ModesDive[0].iYRes;
676 DDSurfAct.dwWidth = ModesDive[0].iXRes;
677 DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[0].iBits;
678 DDSurfAct.ddpfPixelFormat.dwFlags |= DDPF_PALETTEINDEXED8;
679 if(!lpDDEnumModesCallback(&DDSurfAct,lpContext))
680 {
681 return (DD_OK);
682 }
683 }
684 // Don't know the flag for Mode X so we skip reporting it
685
686 // Now report all our modes
687 iMode = 2;
688 fCallAgain = TRUE;
689 do
690 {
691 // if the mode fits in the current resolution and the filter applies report it
692 // Change this if we support Fullscreen later !!!
693 if( (ModesDive[iMode].iXRes < me->dCaps.ulHorizontalResolution)&&
694 (
695 (((lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)&&
696 (ModesDive[iMode].iXRes==lpDDSurfaceDesc->dwWidth))||
697 (!(lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)))&&
698 (((lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)&&
699 (ModesDive[iMode].iYRes==lpDDSurfaceDesc->dwHeight))||
700 (!(lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)))&&
701 (((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) &&
702 (ModesDive[iMode].iBits==lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount))||
703 (!(lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT)))
704 )
705 )
706 {
707 DDSurfAct.dwHeight = ModesDive[iMode].iYRes;
708 DDSurfAct.dwWidth = ModesDive[iMode].iXRes;
709 DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[iMode].iBits;
710 switch(ModesDive[iMode].iBits)
711 {
712 case 8:
713 DDSurfAct.ddpfPixelFormat.dwFlags |= DDPF_PALETTEINDEXED8;
714 break;
715 case 16:
716 // VESA uses 565 encoding in 16 bit modes
717 DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
718 DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
719 DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
720 DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
721 break;
722 case 24:
723 // VESA uses per default RGB4
724 DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
725 DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
726 DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
727 DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x000000FF;
728 break;
729 default:
730 break;
731 }
732
733 fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
734 }
735 iMode++;
736 }
737 while((ModesDive[iMode].iBits <= me->dCaps.ulDepth) &&
738 (iMode < NUM_MODES_DIVE) && (TRUE==fCallAgain));
739
740 }
741 }
742 else
743 {
744
745 // VOODOO modes
746
747 // Enumerate all modes ?
748 if (NULL==lpDDSurfaceDesc)
749 {
750
751 // report all our modes
752 iMode = 0;
753 fCallAgain = TRUE;
754 do
755 {
756 DDSurfAct.dwHeight = ModesVoodoo[iMode].iYRes;
757 DDSurfAct.dwWidth = ModesVoodoo[iMode].iXRes;
758 DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesVoodoo[iMode].iBits;
759
760 fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
761 iMode++;
762 }
763 while((iMode < NUM_MODES_VOODOO) && (TRUE==fCallAgain));
764 }
765 else
766 {
767 // No, so filter modes with lpDDSurfaceDesc
768
769 // Return Error if the program want to use other than the 3 supported values
770 // for filtering
771
772 if (lpDDSurfaceDesc->dwFlags & !(DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT))
773 {
774 return(DDERR_INVALIDPARAMS);
775 }
776
777 iMode = 2;
778 fCallAgain = TRUE;
779 // All reported mode are 16bit
780 DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
781 DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
782 DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
783 do
784 {
785 // if the mode fits the filter applies report it
786 if(
787 (((lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)&&
788 (ModesVoodoo[iMode].iXRes==lpDDSurfaceDesc->dwWidth))||
789 (!(lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)))&&
790 (((lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)&&
791 (ModesVoodoo[iMode].iYRes==lpDDSurfaceDesc->dwHeight))||
792 (!(lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)))&&
793 (((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) &&
794 (ModesVoodoo[iMode].iBits==lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount))||
795 (!(lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT)))
796 )
797 {
798 DDSurfAct.dwHeight = ModesVoodoo[iMode].iYRes;
799 DDSurfAct.dwWidth = ModesVoodoo[iMode].iXRes;
800 DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesVoodoo[iMode].iBits;
801
802 fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
803 }
804 iMode++;
805 }
806 while((iMode < NUM_MODES_VOODOO) && (TRUE==fCallAgain));
807
808 }
809
810 }
811
812
813
814 return(DD_OK);
815}
816//******************************************************************************
817//******************************************************************************
818HRESULT WIN32API DrawEnumDisplayModes4(THIS This, DWORD dwFlags, LPDDSURFACEDESC2 lpDDSurfaceDesc2,
819 LPVOID lpContext, LPDDENUMMODESCALLBACK2 lpDDEnumModesCallback2)
820{
821 int iMode = 0;
822#if 0
823 DDSURFACEDESC DDSurfAct;
824 BOOL fCallAgain;
825#endif
826 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
827
828 dprintf(("DDRAW: EnumDisplayModes4 NIY\n"));
829 return(DD_OK);
830}
831
832//******************************************************************************
833//******************************************************************************
834HRESULT WIN32API DrawEnumSurfaces(THIS, DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK )
835{
836 dprintf(("DDRAW: EnumSurfaces NIY\n"));
837
838 return(DD_OK);
839}
840
841//******************************************************************************
842//******************************************************************************
843HRESULT WIN32API DrawEnumSurfaces4(THIS, DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK2 )
844{
845 dprintf(("DDRAW: EnumSurfaces4 NIY\n"));
846
847 return(DD_OK);
848}
849
850//******************************************************************************
851//******************************************************************************
852HRESULT WIN32API DrawFlipToGDISurface(THIS)
853{
854 dprintf(("DDRAW: FlipToGDISurface NIY\n"));
855
856 return(DD_OK);
857}
858
859//******************************************************************************
860//******************************************************************************
861HRESULT WIN32API DrawGetCaps(THIS This, LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps)
862{
863 DWORD dwSize;
864 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
865
866 dprintf(("DDRAW: DDGetCaps %x %x %x", This, lpDDDriverCaps, lpDDHELCaps));
867
868 if( (NULL==lpDDDriverCaps) && (NULL==lpDDHELCaps) )
869 return(DDERR_INVALIDPARAMS);
870
871 if(NULL!=lpDDDriverCaps)
872 {
873 // Caller want Driver Caps
874
875 dprintf(("DDRAW: Driver\n"));
876
877 if( (sizeof(DDCAPS)!=lpDDDriverCaps->dwSize) &&
878 (sizeof(DDCAPS_DX5)!=lpDDDriverCaps->dwSize) &&
879 (sizeof(DDCAPS_DX3)!=lpDDDriverCaps->dwSize) )
880 {
881 dprintf( ("Size %d Not supported ",
882 lpDDDriverCaps->dwSize));
883 return(DDERR_INVALIDPARAMS);
884 }
885 // Clear structure so we only have to set the supported flags
886
887 dwSize = lpDDDriverCaps->dwSize;
888 memset( lpDDDriverCaps,
889 0,
890 lpDDDriverCaps->dwSize);
891
892
893 // Reset the size
894 lpDDDriverCaps->dwSize = dwSize;
895
896 // Now report the CAPs back which we support
897 lpDDDriverCaps->dwCaps = DDCAPS_BLT | // We do blitting
898 DDCAPS_BLTSTRETCH |
899 DDCAPS_BLTCOLORFILL | // We do colorfills
900 DDCAPS_BLTDEPTHFILL |
901 DDCAPS_COLORKEY | // We support Colorkeying
902 DDCAPS_COLORKEYHWASSIST | // But we (may) use the CPU
903 DDCAPS_GDI | // Maybe check if we are on Voodoo ?
904 DDCAPS_PALETTEVSYNC | // Got VSync
905// DDCAPS_READSCANLINE |
906 DDCAPS_BLTFOURCC;
907
908 lpDDDriverCaps->dwCaps2 = DDCAPS2_CERTIFIED | // Who cares so say yes
909 DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
910 DDCAPS2_COPYFOURCC | // yepp memcpy will do this
911 DDCAPS2_NONLOCALVIDMEM | // All surfaces are in memory
912 DDCAPS2_WIDESURFACES; // Any size you want!
913
914 lpDDDriverCaps->dwCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
915
916 lpDDDriverCaps->dwFXCaps = DDFXCAPS_BLTMIRRORUPDOWN |
917 DDFXCAPS_BLTMIRRORLEFTRIGHT; // DIVE supports this, do we also ?
918 // Maybe later add stretching support?
919
920 lpDDDriverCaps->dwPalCaps = DDPCAPS_8BIT | // Only 8 Bits pals
921 DDPCAPS_ALLOW256 | // But all 256 colors
922 DDPCAPS_VSYNC | // Vsync yet
923 DDPCAPS_PRIMARYSURFACE; //
924 lpDDDriverCaps->dwVidMemTotal = me->dCaps.ulApertureSize; // total video memory
925 lpDDDriverCaps->dwVidMemFree = me->dCaps.ulApertureSize; // total free video memory
926 lpDDDriverCaps->dwNumFourCCCodes = MAX_FOURCC_CODES; // number of supported FOURCC codes
927/*
928 ToDo: must finde out ow the array is used for this
929 lpDDDriverCaps->dwRops[DD_ROP_SPACE] = SRCCOPY |
930 BLACKNESS |
931 WHITENESS; // Raster OPs implemented
932*/
933 lpDDDriverCaps->dwSVBCaps = DDCAPS_BLT | // We do blitting
934 DDCAPS_BLTCOLORFILL | // We do colorfills
935 DDCAPS_COLORKEY | // We support Colorkeying
936 DDCAPS_COLORKEYHWASSIST;
937 lpDDDriverCaps->dwSVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
938 lpDDDriverCaps->dwSVBFXCaps = DDCAPS_BLT | // We do blitting
939 DDCAPS_BLTCOLORFILL | // We do colorfills
940 DDCAPS_COLORKEY | // We support Colorkeying
941 DDCAPS_COLORKEYHWASSIST;
942/*
943 ToDo: must finde out ow the array is used for this
944 lpDDDriverCaps->dwSVBRops[DD_ROP_SPACE] = SRCCOPY |
945 BLACKNESS |
946 WHITENESS; // Raster OPs implemented
947*/
948 lpDDDriverCaps->dwVSBCaps = DDCAPS_BLT | // We do blitting
949 DDCAPS_BLTCOLORFILL | // We do colorfills
950 DDCAPS_COLORKEY | // We support Colorkeying
951 DDCAPS_COLORKEYHWASSIST;
952 lpDDDriverCaps->dwVSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
953 lpDDDriverCaps->dwVSBFXCaps = DDCAPS_BLT | // We do blitting
954 DDCAPS_BLTCOLORFILL | // We do colorfills
955 DDCAPS_COLORKEY | // We support Colorkeying
956 DDCAPS_COLORKEYHWASSIST;
957/*
958 ToDo: must finde out ow the array is used for this
959 lpDDDriverCaps->dwVSBRops[DD_ROP_SPACE] = SRCCOPY |
960 BLACKNESS |
961 WHITENESS; // Raster OPs implemented
962*/
963 lpDDDriverCaps->dwSSBCaps = DDCAPS_BLT | // We do blitting
964 DDCAPS_BLTCOLORFILL | // We do colorfills
965 DDCAPS_COLORKEY | // We support Colorkeying
966 DDCAPS_COLORKEYHWASSIST;
967 lpDDDriverCaps->dwSSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
968 lpDDDriverCaps->dwSSBFXCaps = DDCAPS_BLT | // We do blitting
969 DDCAPS_BLTCOLORFILL | // We do colorfills
970 DDCAPS_COLORKEY | // We support Colorkeying
971 DDCAPS_COLORKEYHWASSIST;
972/*
973 ToDo: must finde out ow the array is used for this
974 lpDDDriverCaps->dwSSBRops[SRCCOPY] = 1;
975 lpDDDriverCaps->dwSSBRops[BLACKNESS] = 1;
976 lpDDDriverCaps->dwSSBRops[WHITENESS] = 1; // Raster OPs implemented
977*/
978 // These are ony in >DX5
979 if(dwSize>sizeof(DDCAPS_DX3))
980 {
981 lpDDDriverCaps->dwSVBCaps2 = //DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
982 DDCAPS2_COPYFOURCC | // yepp memcpy will do this
983 DDCAPS2_WIDESURFACES; // Any size you want!
984 lpDDDriverCaps->dwNLVBCaps = DDCAPS_BLT | // We do blitting
985 DDCAPS_BLTCOLORFILL | // We do colorfills
986 DDCAPS_COLORKEY | // We support Colorkeying
987 DDCAPS_COLORKEYHWASSIST;
988 lpDDDriverCaps->dwNLVBCaps2 = //DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
989 DDCAPS2_COPYFOURCC | // yepp memcpy will do this
990 DDCAPS2_WIDESURFACES; // Any size you want!
991 lpDDDriverCaps->dwNLVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
992 lpDDDriverCaps->dwNLVBFXCaps = DDCAPS_BLT | // We do blitting
993 DDCAPS_BLTCOLORFILL | // We do colorfills
994 DDCAPS_COLORKEY | // We support Colorkeying
995 DDCAPS_COLORKEYHWASSIST;
996 lpDDDriverCaps->dwNLVBRops[DD_ROP_SPACE];// ToDo: Again the array ...
997
998 // General Surface caps only in DX6
999 if(dwSize>sizeof(DDCAPS_DX5))
1000 {
1001 lpDDDriverCaps->ddsCaps.dwCaps = DDSCAPS_ALPHA | DDSCAPS_BACKBUFFER |
1002 DDSCAPS_COMPLEX | DDSCAPS_FLIP |
1003 DDSCAPS_FRONTBUFFER | DDSCAPS_LOCALVIDMEM |
1004 DDSCAPS_NONLOCALVIDMEM | DDSCAPS_OFFSCREENPLAIN |
1005 // DDSCAPS_OVERLAY |
1006 DDSCAPS_PALETTE | DDSCAPS_PRIMARYSURFACE |
1007 DDSCAPS_SYSTEMMEMORY |DDSCAPS_VIDEOMEMORY |
1008 DDSCAPS_VISIBLE;
1009
1010 #ifdef USE_OPENGL
1011 lpDDDriverCaps->dwCaps |= DDCAPS_3D | DDCAPS_ZBLTS;
1012 // ToDO find and put the value for DDCAPS2_NO2DDURING3DSCENE in ddraw.h
1013 // lpDDDriverCaps->dwCaps2 |= DDCAPS2_NO2DDURING3DSCENE;
1014 lpDDDriverCaps->ddsCaps.dwCaps |= DDSCAPS_3DDEVICE | DDSCAPS_MIPMAP |
1015 DDSCAPS_TEXTURE | DDSCAPS_ZBUFFER;
1016 #endif
1017 }
1018 }
1019
1020
1021 }
1022
1023 if(NULL!=lpDDHELCaps)
1024 {
1025 // Caller wants HEL Caps
1026 dprintf(("DDRAW: HEL\n"));
1027
1028 //SvL: PowerDVD uses size 316
1029 if( (sizeof(DDCAPS) != lpDDHELCaps->dwSize) &&
1030 (sizeof(DDCAPS_DX5) != lpDDHELCaps->dwSize) &&
1031 (sizeof(DDCAPS_DX3) != lpDDHELCaps->dwSize) )
1032 {
1033 dprintf( ("Size %d Not supported ",
1034 lpDDHELCaps->dwSize));
1035 return(DDERR_INVALIDPARAMS);
1036 }
1037 // Clear structure so we only have to set the supported flags
1038
1039 dwSize = lpDDHELCaps->dwSize;
1040 memset( lpDDHELCaps,
1041 0,
1042 lpDDHELCaps->dwSize);
1043
1044 // Reset the size
1045 lpDDHELCaps->dwSize = dwSize;
1046
1047 // Now report the CAPs back which we support
1048 lpDDHELCaps->dwCaps = DDCAPS_BLT | // We do blitting
1049 DDCAPS_BLTCOLORFILL | // We do colorfills
1050 DDCAPS_COLORKEY | // We support Colorkeying
1051//SvL: This is the emulation layer; no hw support here
1052// DDCAPS_COLORKEYHWASSIST | // But we (may) use the CPU
1053 DDCAPS_GDI | // Maybe check if we are on Voodoo ?
1054 DDCAPS_PALETTEVSYNC | // Got VSync
1055 DDCAPS_BLTFOURCC;
1056
1057 lpDDHELCaps->dwCaps2 = DDCAPS2_CERTIFIED | // Who cares so say yes
1058 DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
1059 DDCAPS2_COPYFOURCC | // yepp memcpy will do this
1060 DDCAPS2_NONLOCALVIDMEM | // All surfaces are in memory
1061 DDCAPS2_WIDESURFACES; // Any size you want!
1062
1063 lpDDHELCaps->dwCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1064
1065 lpDDHELCaps->dwFXCaps = DDFXCAPS_BLTMIRRORUPDOWN |
1066 DDFXCAPS_BLTMIRRORLEFTRIGHT; // DIVE supports this, do we also ?
1067 // Maybe later add stretching support?
1068
1069 lpDDHELCaps->dwPalCaps = DDPCAPS_8BIT | // Only 8 Bits pals
1070 DDPCAPS_ALLOW256 | // But all 256 colors
1071 DDPCAPS_VSYNC | // Vsync yet
1072 DDPCAPS_PRIMARYSURFACE;
1073
1074 //Video memory for emulation layer must be 0 (verified in NT)
1075 lpDDHELCaps->dwVidMemTotal = 0; // total video memory
1076 lpDDHELCaps->dwVidMemFree = 0; // total free video memory
1077
1078 lpDDHELCaps->dwNumFourCCCodes = MAX_FOURCC_CODES; // number of supported FOURCC codes
1079 lpDDHELCaps->dwRops[DD_ROP_SPACE]; // supported raster ops
1080 lpDDHELCaps->dwSVBCaps = DDCAPS_BLT | // We do blitting
1081 DDCAPS_BLTCOLORFILL | // We do colorfills
1082 DDCAPS_COLORKEY | // We support Colorkeying
1083 DDCAPS_COLORKEYHWASSIST;
1084 lpDDHELCaps->dwSVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1085 lpDDHELCaps->dwSVBFXCaps; // .
1086 lpDDHELCaps->dwSVBRops[DD_ROP_SPACE]; // .
1087 lpDDHELCaps->dwVSBCaps = DDCAPS_BLT | // We do blitting
1088 DDCAPS_BLTCOLORFILL | // We do colorfills
1089 DDCAPS_COLORKEY | // We support Colorkeying
1090 DDCAPS_COLORKEYHWASSIST;
1091 lpDDHELCaps->dwVSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1092 lpDDHELCaps->dwVSBFXCaps; // .
1093 lpDDHELCaps->dwVSBRops[DD_ROP_SPACE]; // .
1094 lpDDHELCaps->dwSSBCaps = DDCAPS_BLT | // We do blitting
1095 DDCAPS_BLTCOLORFILL | // We do colorfills
1096 DDCAPS_COLORKEY | // We support Colorkeying
1097 DDCAPS_COLORKEYHWASSIST;
1098 lpDDHELCaps->dwSSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1099 lpDDHELCaps->dwSSBFXCaps; // .
1100 lpDDHELCaps->dwSSBRops[DD_ROP_SPACE]; // .
1101 // These are ony in >DX5
1102 if(dwSize>sizeof(DDCAPS_DX3))
1103 {
1104 lpDDHELCaps->dwSVBCaps2 = DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
1105 DDCAPS2_COPYFOURCC | // yepp memcpy will do this
1106 DDCAPS2_WIDESURFACES; // Any size you want!
1107 lpDDHELCaps->dwNLVBCaps = DDCAPS_BLT | // We do blitting
1108 DDCAPS_BLTCOLORFILL | // We do colorfills
1109 DDCAPS_COLORKEY | // We support Colorkeying
1110 DDCAPS_COLORKEYHWASSIST;
1111 lpDDHELCaps->dwNLVBCaps2 = DDCAPS2_CANRENDERWINDOWED | // Better check for Voodoo ?!
1112 DDCAPS2_COPYFOURCC | // yepp memcpy will do this
1113 DDCAPS2_WIDESURFACES; // Any size you want!
1114 lpDDHELCaps->dwNLVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1115 lpDDHELCaps->dwNLVBFXCaps; // .
1116 lpDDHELCaps->dwNLVBRops[DD_ROP_SPACE];// .
1117 }
1118
1119 }
1120
1121 return(DD_OK);
1122}
1123//******************************************************************************
1124//******************************************************************************
1125HRESULT WIN32API DrawGetDisplayMode(THIS This, LPDDSURFACEDESC lpDDSurfaceDesc)
1126{
1127 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
1128
1129 dprintf(("DDRAW: GetDisplayMode %x %x", This, lpDDSurfaceDesc));
1130
1131 // Check Parameter
1132 if(NULL==lpDDSurfaceDesc)
1133 return(DDERR_INVALIDPARAMS);
1134
1135 if(sizeof(DDSURFACEDESC)!=lpDDSurfaceDesc->dwSize)
1136 return(DDERR_INVALIDPARAMS);
1137
1138 // We report back the DIVE caps. maybe we should set up a local DDSURFACEDESC
1139 // for the object so we can change the values when we switch modes (or say so)
1140 // as a program may use this function to check the values after a mode change
1141 // An other reason to to so is Voodoo supports maybe more functions
1142
1143 // Tell what we report
1144 lpDDSurfaceDesc->dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
1145 lpDDSurfaceDesc->dwHeight = me->dCaps.ulHorizontalResolution;
1146 lpDDSurfaceDesc->dwWidth = me->dCaps.ulVerticalResolution;
1147 // Set the PixelFormat
1148 lpDDSurfaceDesc->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
1149
1150 lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC = me->dCaps.fccColorEncoding;
1151 lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = me->dCaps.ulDepth;
1152 lpDDSurfaceDesc->ddpfPixelFormat.dwRGBAlphaBitMask = 0; // No Alpha support
1153 switch(me->dCaps.ulDepth)
1154 {
1155 case 4:
1156 // Assume that no one will run OS/2 PM with less then 16 colors and try
1157 // to start a DirectX program ;)
1158 lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED4;
1159 lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0;
1160 lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0;
1161 lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0;
1162 break;
1163 case 8:
1164 lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8 |
1165 DDPF_FOURCC;
1166 lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0;
1167 lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0;
1168 lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0;
1169 break;
1170 case 15:
1171 case 16:
1172 lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = 16; // No sure about 15Bit modes
1173 lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_FOURCC;
1174 if (FOURCC_R555 == me->dCaps.fccColorEncoding)
1175 {
1176 lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x00007C00;
1177 lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x000003E0;
1178 lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000001F;
1179 }
1180 else
1181 {
1182 if(FOURCC_R565 == me->dCaps.fccColorEncoding)
1183 {
1184 lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x0000F800;
1185 lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x000007E0;
1186 lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000001F;
1187 }
1188 else
1189 {
1190 // R664
1191 lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x0000F800;
1192 lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x000003F0;
1193 lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000000F;
1194 }
1195 }
1196 break;
1197 case 24:
1198 lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_FOURCC;
1199 if(FOURCC_RGB3 == me->dCaps.fccColorEncoding)
1200 {
1201 lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
1202 lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1203 lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x000000FF;
1204 }
1205 else
1206 {
1207 // BGR3
1208 lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x000000FF;
1209 lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1210 lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
1211 }
1212 break;
1213 case 32:
1214 lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_FOURCC;
1215 if(FOURCC_RGB4 == me->dCaps.fccColorEncoding)
1216 {
1217 lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
1218 lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1219 lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x000000FF;
1220 }
1221 else
1222 {
1223 // BGR4
1224 lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x000000FF;
1225 lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1226 lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
1227 }
1228 break;
1229 default:
1230 dprintf(("DDRAW: Unsupported mode\n"));
1231 return(DDERR_UNSUPPORTEDMODE);
1232 }
1233
1234 return(DD_OK);
1235}
1236//******************************************************************************
1237//******************************************************************************
1238HRESULT WIN32API DrawGetDisplayMode4(THIS This, LPDDSURFACEDESC2 lpDDSurfaceDesc2)
1239{
1240 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
1241
1242 dprintf(("DDRAW: GetDisplayMode4 %x %x", This, lpDDSurfaceDesc2));
1243
1244 // Check Parameter
1245 if(NULL==lpDDSurfaceDesc2)
1246 return(DDERR_INVALIDPARAMS);
1247
1248 if(sizeof(DDSURFACEDESC)!=lpDDSurfaceDesc2->dwSize)
1249 return(DDERR_INVALIDPARAMS);
1250
1251 // We report back the DIVE caps. maybe we should set up a local DDSURFACEDESC
1252 // for the object so we can change the values when we switch modes (or say so)
1253 // as a program may use this function to check the values after a mode change
1254 // An other reason to to so is Voodoo supports maybe more functions
1255
1256 // Tell what we report
1257 lpDDSurfaceDesc2->dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
1258 lpDDSurfaceDesc2->dwHeight = me->dCaps.ulHorizontalResolution;
1259 lpDDSurfaceDesc2->dwWidth = me->dCaps.ulVerticalResolution;
1260 // Set the PixelFormat
1261 lpDDSurfaceDesc2->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
1262
1263 lpDDSurfaceDesc2->ddpfPixelFormat.dwFourCC = me->dCaps.fccColorEncoding;
1264 lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBBitCount = me->dCaps.ulDepth;
1265 lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBAlphaBitMask = 0; // No Alpha support
1266 switch(me->dCaps.ulDepth)
1267 {
1268 case 4:
1269 // Assume that no one will run OS/2 PM with less then 16 colors and try
1270 // to start a DirectX program ;)
1271 lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED4;
1272 lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0;
1273 lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0;
1274 lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0;
1275 break;
1276 case 8:
1277 lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8 |
1278 DDPF_FOURCC;
1279 lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0;
1280 lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0;
1281 lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0;
1282 break;
1283 case 15:
1284 case 16:
1285 lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBBitCount = 16; // No sure about 15Bit modes
1286 lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_FOURCC;
1287 if (FOURCC_R555 == me->dCaps.ulDepth)
1288 {
1289 lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x00007C00;
1290 lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x000003E0;
1291 lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x0000001F;
1292 }
1293 else
1294 {
1295 if(FOURCC_R565 == me->dCaps.fccColorEncoding)
1296 {
1297 lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x0000F800;
1298 lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x000007E0;
1299 lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x0000001F;
1300 }
1301 else
1302 {
1303 // R664
1304 lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x0000F800;
1305 lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x000003F0;
1306 lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x0000000F;
1307 }
1308 }
1309 break;
1310 case 24:
1311 lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_FOURCC;
1312 if(FOURCC_RGB3 == me->dCaps.fccColorEncoding)
1313 {
1314 lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
1315 lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1316 lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x000000FF;
1317 }
1318 else
1319 {
1320 // BGR3
1321 lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x000000FF;
1322 lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1323 lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
1324 }
1325 break;
1326 case 32:
1327 lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_FOURCC;
1328 if(FOURCC_RGB4 == me->dCaps.fccColorEncoding)
1329 {
1330 lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
1331 lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1332 lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x000000FF;
1333 }
1334 else
1335 {
1336 // BGR4
1337 lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x000000FF;
1338 lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1339 lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
1340 }
1341 break;
1342 default:
1343 dprintf(("DDRAW: Unsupported mode\n"));
1344 return(DDERR_UNSUPPORTEDMODE);
1345 }
1346
1347 return(DD_OK);
1348}
1349//******************************************************************************
1350//******************************************************************************
1351HRESULT WIN32API DrawGetFourCCCodes(THIS This, LPDWORD lpNumCodes, LPDWORD lpCodes)
1352{
1353// DWORD dwFCC[MAX_FOURCC_CODES] = {FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3,FOURCC_YUY2};
1354 DWORD dwFCC[MAX_FOURCC_CODES] = {FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3};
1355
1356 dprintf(("DDRAW: GetFourCCCodes %x %x %x", This, lpNumCodes, lpCodes));
1357
1358 if(NULL==lpNumCodes)
1359 return(DDERR_INVALIDPARAMS);
1360
1361 if(NULL==lpCodes)
1362 {
1363 *lpNumCodes = MAX_FOURCC_CODES; // LUT8, R565, RGB3 are the FourCC we support for now
1364 }
1365 else
1366 {
1367 for(int i=0;(i<MAX_FOURCC_CODES)&&(i<*lpNumCodes);i++)
1368 {
1369 *lpCodes = dwFCC[i];
1370 lpCodes++;
1371 }
1372 *lpNumCodes = MAX_FOURCC_CODES;
1373 }
1374 return(DD_OK);
1375}
1376//******************************************************************************
1377//******************************************************************************
1378HRESULT WIN32API DrawGetGDISurface(THIS, LPDIRECTDRAWSURFACE FAR *)
1379{
1380 dprintf(("DDRAW: GetGDISurface NYI\n"));
1381
1382 return(DD_OK);
1383}
1384//******************************************************************************
1385//******************************************************************************
1386HRESULT WIN32API DrawGetGDISurface4(THIS, LPDIRECTDRAWSURFACE4 FAR *)
1387{
1388 dprintf(("DDRAW: GetGDISurface NYI\n"));
1389
1390 return(DD_OK);
1391}
1392//******************************************************************************
1393//******************************************************************************
1394HRESULT WIN32API DrawGetMonitorFrequency(THIS This, LPDWORD lpdwFreq)
1395{
1396 ULONG ulTime1, ulTime2;
1397 DWORD dwFlags = DDWAITVB_BLOCKBEGIN;
1398 dprintf(("DDRAW: GetMonitorFrequency\n"));
1399 if(NULL==lpdwFreq)
1400 return(DDERR_INVALIDPARAMS);
1401
1402
1403
1404 if(DD_OK==DrawWaitForVerticalBlank(This, dwFlags, 0))
1405 {
1406 ulTime1 = GetTickCount();
1407 // Timer has an accuracy of 4 ms so call it al least 4 times
1408 DrawWaitForVerticalBlank(This, dwFlags, 0);
1409 DrawWaitForVerticalBlank(This, dwFlags, 0);
1410 DrawWaitForVerticalBlank(This, dwFlags, 0);
1411 DrawWaitForVerticalBlank(This, dwFlags, 0);
1412 ulTime2 = GetTickCount();
1413 ulTime2 -= ulTime1;
1414 if(ulTime2) // paranoid check to avoid DIV0
1415 *lpdwFreq = 4000 / ulTime2;
1416 else
1417 *lpdwFreq = 70;
1418 }
1419 else
1420 {
1421 // Assume 70 Hz maybe better return DDERR_UNSUPPORTED if this function isn't mandatory
1422 *lpdwFreq = 70;
1423 }
1424
1425
1426
1427 return(DD_OK);
1428}
1429//******************************************************************************
1430//******************************************************************************
1431HRESULT WIN32API DrawGetScanLine(THIS, LPDWORD lpdwLine)
1432{
1433// BOOL bVertBlank;
1434 dprintf(("DDRAW: GetScanLine\n"));
1435 // ToDO find a way to get this position, so for now simply return DDERR_UNSUPPORTED
1436 // as we indicated in DDCAPS we don't support this.
1437
1438 return(DDERR_UNSUPPORTED);
1439
1440 //the following code could be used if we implement this
1441 /*
1442 if(NULL==lpdwLine)
1443 return(DDERR_INVALIDPARAMS);
1444 DrawGetVertcalBlackStatus(This,&bVertBlank);
1445 if(bVertBlank)
1446 return (DDERR_VERTICALBLANKINPROGRESS);
1447 *lpdwLine = GetLine(); // GetLine would be the function which gets us the line
1448 return(DD_OK);
1449 */
1450}
1451//******************************************************************************
1452//******************************************************************************
1453HRESULT WIN32API DrawGetVerticalBlankStatus(THIS , LPBOOL lpbIsInVB)
1454{
1455// int rc;
1456 dprintf(("DDRAW: GetVerticalBlankStatus\n"));
1457 if(NULL==lpbIsInVB)
1458 return(DDERR_INVALIDPARAMS);
1459
1460 #if 0
1461 rc = io_init1();
1462
1463
1464 if(0==rc) // try to get IOPL for the thread
1465 {
1466 *lpbIsInVB = (c_inb1(0x3da)&0x08)!=0;
1467
1468 io_exit1(); // reset IOPL
1469
1470 return(DD_OK);
1471 }
1472 #else
1473 *lpbIsInVB = ! (*lpbIsInVB);
1474 #endif
1475 return(DDERR_UNSUPPORTED);
1476}
1477//******************************************************************************
1478//******************************************************************************
1479HRESULT WIN32API DrawInitialize(THIS, GUID FAR *)
1480{
1481 dprintf(("DDRAW: Initialize\n"));
1482
1483 return(DD_OK);
1484}
1485//******************************************************************************
1486//******************************************************************************
1487HRESULT WIN32API DrawRestoreDisplayMode(THIS)
1488{
1489 dprintf(("DDRAW: RestoreDisplayMod\n"));
1490
1491 return(DD_OK);
1492}
1493//******************************************************************************
1494//******************************************************************************
1495HRESULT WIN32API DrawSetCooperativeLevel(THIS This, HWND hwndClient, DWORD dwFlags)
1496{
1497 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
1498
1499 dprintf(("DDRAW: SetCooperativeLevel: hwnd %X, Flags %X\n", hwndClient, dwFlags));
1500 me->dwCoopMode = dwFlags;
1501 if(!(DDSCL_NORMAL & dwFlags))
1502 {
1503 // client window req. for all none DDSCL_NORMAL modes
1504 if(NULL==hwndClient)
1505 return(DDERR_INVALIDPARAMS);
1506 }
1507 me->hwndClient = hwndClient;
1508 #if 0
1509 OS2DDSubclassWindow(hwndClient);
1510 #endif
1511 return(DD_OK);
1512}
1513//******************************************************************************
1514//Backwards compatibility, what's that??
1515//******************************************************************************
1516HRESULT WIN32API DrawSetDisplayMode2(THIS This, DWORD dwWidth, DWORD dwHeight,
1517 DWORD dwBPP, DWORD dwRefreshRate,
1518 DWORD dwFlags)
1519{
1520 ULONG rc;
1521 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
1522 SETUP_BLITTER sBlt;
1523
1524 dprintf(("DDRAW: SetDisplayMode2 to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
1525
1526 me->screenwidth = dwWidth;
1527 me->screenheight = dwHeight;
1528 me->screenbpp = dwBPP;
1529
1530 if(me->dwCoopMode & DDSCL_FULLSCREEN)
1531 {
1532 SetWindowPos(me->hwndClient, HWND_TOP,0,0,dwWidth,dwHeight,0);
1533 }
1534
1535 memset(&sBlt,0,sizeof(sBlt));
1536 sBlt.ulStructLen = sizeof(sBlt);
1537 sBlt.fccSrcColorFormat = FOURCC_SCRN;
1538 sBlt.ulSrcWidth = dwWidth;
1539 sBlt.ulSrcHeight = dwHeight;
1540 sBlt.ulSrcPosX = 0;
1541 sBlt.ulSrcPosY = 0;
1542 sBlt.fccDstColorFormat = FOURCC_SCRN;
1543 sBlt.ulDstWidth = dwWidth;
1544 sBlt.ulDstHeight = dwHeight;
1545 sBlt.lDstPosX = 0;
1546 sBlt.lDstPosY = 0;
1547 sBlt.lScreenPosX = 0;
1548 sBlt.lScreenPosY = me->dCaps.ulVerticalResolution-dwHeight;
1549 sBlt.ulNumDstRects = DIVE_FULLY_VISIBLE;
1550
1551 rc = DiveSetupBlitter( me->hDive,
1552 &sBlt);
1553 dprintf((" DiveSetupBlitter rc=%d",rc));
1554
1555 return(DD_OK);
1556}
1557//******************************************************************************
1558//******************************************************************************
1559HRESULT WIN32API DrawSetDisplayMode(THIS This, DWORD dwWidth, DWORD dwHeight,
1560 DWORD dwBPP)
1561{
1562 ULONG rc;
1563 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
1564 SETUP_BLITTER sBlt;
1565
1566 dprintf(("DDRAW: SetDisplayMode to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
1567
1568 me->screenwidth = dwWidth;
1569 me->screenheight = dwHeight;
1570 me->screenbpp = dwBPP;
1571
1572 if(me->dwCoopMode & DDSCL_FULLSCREEN)
1573 {
1574 SetWindowPos(me->hwndClient, HWND_TOP,0,0,dwWidth,dwHeight,0);
1575 }
1576
1577 memset(&sBlt,0,sizeof(sBlt));
1578 sBlt.ulStructLen = sizeof(sBlt);
1579 sBlt.fccSrcColorFormat = FOURCC_SCRN;
1580 sBlt.ulSrcWidth = dwWidth;
1581 sBlt.ulSrcHeight = dwHeight;
1582 sBlt.ulSrcPosX = 0;
1583 sBlt.ulSrcPosY = 0;
1584 sBlt.fccDstColorFormat = FOURCC_SCRN;
1585 sBlt.ulDstWidth = dwWidth;
1586 sBlt.ulDstHeight = dwHeight;
1587 sBlt.lDstPosX = 0;
1588 sBlt.lDstPosY = 0;
1589 sBlt.lScreenPosX = 0;
1590 sBlt.lScreenPosY = me->dCaps.ulVerticalResolution-dwHeight;
1591 sBlt.ulNumDstRects = DIVE_FULLY_VISIBLE;
1592
1593 rc = DiveSetupBlitter( me->hDive,
1594 &sBlt);
1595 dprintf((" DiveSetupBlitter rc=%d",rc));
1596
1597 return(DD_OK);
1598}
1599//******************************************************************************
1600//******************************************************************************
1601HRESULT WIN32API DrawWaitForVerticalBlank(THIS, DWORD dwFlags, HANDLE hEvent)
1602{
1603// HRESULT rc;
1604// int rci;
1605// USHORT sel;
1606 dprintf(("DDRAW: WaitForVerticalBlank\n"));
1607
1608 if(DDWAITVB_BLOCKBEGINEVENT == dwFlags) // This parameter isn't support in DX
1609 return (DDERR_UNSUPPORTED);
1610
1611 return DD_OK;
1612
1613#if 0
1614 rci = InitIO();
1615
1616 if(rci) // try to get IOPL for the thread
1617 {
1618 dprintf(("DDRAW: No IOPL\n"));
1619 return (DDERR_UNSUPPORTED); // we failed so return error that we don't support this
1620 }
1621 // AT this point we should have IOPL so lets use it!
1622 dprintf(("DDRAW: IOPL 3!\n"));
1623
1624 rc = DDERR_INVALIDPARAMS; // set returnvalue to fail
1625
1626 if(DDWAITVB_BLOCKBEGIN == dwFlags)
1627 {
1628 dprintf(("DDRAW: BLOCKBEGIN\n"));
1629
1630 while ((c_inb1(0x3da)&0x08)!=0); // Wait for end of vert. retrace if one is running
1631 while ((c_inb1(0x3da)&0x08)==0); // Wait for new start of retrace
1632 rc = DD_OK;
1633 }
1634
1635 if(DDWAITVB_BLOCKEND == dwFlags)
1636 {
1637 dprintf(("DDRAW: BLOCKEND\n"));
1638 rc = DD_OK;
1639 if((c_inb1(0x3da)&0x08)!=0) // Are we in a vert. retrace
1640 {
1641 while ((c_inb1(0x3da)&0x08)!=0); // Wait for end of retrace
1642 }
1643 else
1644 {
1645 while ((c_inb1(0x3da)&0x08)==0); // Wait for new start of retrace
1646 while ((c_inb1(0x3da)&0x08)!=0); // Wait for end of vert. retrace
1647 }
1648
1649 }
1650
1651
1652 // io_exit1();
1653
1654
1655 return (rc);
1656#endif
1657}
1658
1659//******************************************************************************
1660//*** Added in the v2 interface ***
1661//******************************************************************************
1662HRESULT WIN32API DrawGetAvailableVidMem(THIS, LPDDSCAPS lpDDSCaps,
1663 LPDWORD lpdwTotal, LPDWORD lpdwFree)
1664{
1665 dprintf(("DDRAW: GetAvailableVidMem\n"));
1666
1667 // Check parameters
1668 if(NULL==lpDDSCaps)
1669 return(DDERR_INVALIDPARAMS);
1670
1671 if((NULL==lpdwTotal)&&(NULL==lpdwFree))
1672 return(DDERR_INVALIDPARAMS);
1673
1674 if(NULL!=lpdwTotal)
1675 *lpdwTotal = 2048 *1024;
1676
1677 if(NULL!=lpdwFree)
1678 *lpdwFree = 2048 *1024;
1679
1680 return(DD_OK);
1681}
1682//******************************************************************************
1683//
1684//******************************************************************************
1685HRESULT WIN32API DrawGetAvailableVidMem4(THIS, LPDDSCAPS2 lpDDSCaps2,
1686 LPDWORD lpdwTotal, LPDWORD lpdwFree)
1687{
1688 dprintf(("DDRAW: GetAvailableVidMem\n"));
1689
1690 // Check parameters
1691 if(NULL==lpDDSCaps2)
1692 return(DDERR_INVALIDPARAMS);
1693
1694 if((NULL==lpdwTotal)&&(NULL==lpdwFree))
1695 return(DDERR_INVALIDPARAMS);
1696
1697 if(NULL!=lpdwTotal)
1698 *lpdwTotal = 2048 *1024;
1699
1700 if(NULL!=lpdwFree)
1701 *lpdwFree = 2048 *1024;
1702
1703 return(DD_OK);
1704}
1705//******************************************************************************
1706//*** Added in the v4 interface ***
1707//******************************************************************************
1708HRESULT WIN32API DrawGetSurfaceFromDC(THIS, HDC hdc, LPDIRECTDRAWSURFACE4 *)
1709{
1710 dprintf(("DDRAW: GetSurfaceFromDC NYI\n"));
1711
1712 return(DD_OK);
1713}
1714//******************************************************************************
1715//******************************************************************************
1716HRESULT WIN32API DrawRestoreAllSurfaces(THIS)
1717{
1718 dprintf(("DDRAW: RestoreAllSurfaces\n"));
1719
1720 return(DD_OK);
1721}
1722//******************************************************************************
1723//******************************************************************************
1724HRESULT WIN32API DrawTestCooperativeLevel(THIS)
1725{
1726 dprintf(("DDRAW: TestCooperativeLevel\n"));
1727
1728 return(DD_OK);
1729}
1730//******************************************************************************
1731//******************************************************************************
1732HRESULT WIN32API DrawGetDeviceIdentifier( THIS, LPDDDEVICEIDENTIFIER lpdddi,
1733 DWORD dwFlags)
1734{
1735 dprintf(("DDRAW: GetDeviceIdentifier Flags = %d\n",dwFlags));
1736 if(NULL==lpdddi)
1737 return DDERR_INVALIDPARAMS;
1738
1739
1740
1741 memset( lpdddi,
1742 0,
1743 sizeof(DDDEVICEIDENTIFIER));
1744 // ToDo: Cretae a GUID and put some better data inside
1745 strcpy( lpdddi->szDriver,
1746 "OS/2 DIVE Driver");
1747 strcpy( lpdddi->szDescription,
1748 "ODIN DD Emulation Driver");
1749
1750
1751
1752 return(DD_OK);
1753}
1754//******************************************************************************
1755//******************************************************************************
1756VOID OS2IDirectDraw::SwitchDisplay(HWND hwnd)
1757{
1758 DWORD dwVType, dwVSize;
1759 HKEY hkDirectDraw2;
1760
1761
1762
1763 if (bScale)
1764 {
1765 if (ERROR_SUCCESS==RegOpenKeyA(HKEY_LOCAL_MACHINE,KEY_DIRECT2DRAW,&hkDirectDraw2))
1766 {
1767 dwVSize = 4;
1768 dwVType = REG_DWORD;
1769 if (ERROR_SUCCESS!=RegQueryValueExA( hkDirectDraw2, "Fullscreen", NULL, &dwVType,
1770 (LPBYTE)&bScale, &dwVSize))
1771 bScale = FALSE;
1772 }
1773 else
1774 bScale = FALSE;
1775 }
1776
1777
1778}
1779//******************************************************************************
1780//******************************************************************************
1781
Note: See TracBrowser for help on using the repository browser.