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

Last change on this file since 4848 was 4139, checked in by sandervl, 25 years ago

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