2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS GDI32
4 * PURPOSE: GDI DirectX inteface
5 * FILE: lib/gdi32/misc/gdientry.c
6 * PROGRAMERS: Alex Ionescu (alex@relsoft.net)
7 * Magnus Olsen (magnus@greatlord.com)
10 /* INCLUDES ******************************************************************/
19 /* DATA **********************************************************************/
24 #define GetDdHandle(Handle) ((HANDLE)Handle ? (HANDLE)Handle : ghDirectDraw)
27 /* CALLBACKS *****************************************************************/
30 * Dd Surface Callbacks
34 DdAddAttachedSurface(LPDDHAL_ADDATTACHEDSURFACEDATA Attach
)
37 return NtGdiDdAddAttachedSurface((HANDLE
)Attach
->lpDDSurface
->hDDSurface
,
38 (HANDLE
)Attach
->lpSurfAttached
->hDDSurface
,
39 (PDD_ADDATTACHEDSURFACEDATA
)Attach
);
44 DdBlt(LPDDHAL_BLTDATA Blt
)
48 /* Use the right surface */
49 if (Blt
->lpDDSrcSurface
) Surface
= (HANDLE
)Blt
->lpDDSrcSurface
->hDDSurface
;
52 return NtGdiDdBlt((HANDLE
)Blt
->lpDDDestSurface
->hDDSurface
, Surface
, (PDD_BLTDATA
)Blt
);
57 DdDestroySurface(LPDDHAL_DESTROYSURFACEDATA pDestroySurface
)
59 DWORD Return
= DDHAL_DRIVER_NOTHANDLED
;
60 BOOL RealDestroy
= TRUE
;
61 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal
;
63 /* Get the local surface */
64 pSurfaceLocal
= pDestroySurface
->lpDDSurface
;
66 /* Make sure there's a surface */
67 if (pSurfaceLocal
->hDDSurface
)
69 /* Check if we shoudl really destroy it */
70 if ((pSurfaceLocal
->dwFlags
& DDRAWISURF_DRIVERMANAGED
) &&
71 (pSurfaceLocal
->dwFlags
& DDRAWISURF_INVALID
))
77 Return
= NtGdiDdDestroySurface((HANDLE
)pSurfaceLocal
->hDDSurface
,
86 DdFlip(LPDDHAL_FLIPDATA Flip
)
90 return NtGdiDdFlip( (HANDLE
)Flip
->lpSurfCurr
->hDDSurface
,
91 (HANDLE
)Flip
->lpSurfTarg
->hDDSurface
,
92 /* FIXME the two last should be current left handler */
93 (HANDLE
)Flip
->lpSurfCurr
->hDDSurface
,
94 (HANDLE
)Flip
->lpSurfTarg
->hDDSurface
,
100 DdLock(LPDDHAL_LOCKDATA Lock
)
103 return NtGdiDdLock((HANDLE
)Lock
->lpDDSurface
->hDDSurface
,
105 (HANDLE
)Lock
->lpDDSurface
->hDC
);
110 DdUnlock(LPDDHAL_UNLOCKDATA Unlock
)
113 return NtGdiDdUnlock((HANDLE
)Unlock
->lpDDSurface
->hDDSurface
,
114 (PDD_UNLOCKDATA
)Unlock
);
119 DdGetBltStatus(LPDDHAL_GETBLTSTATUSDATA GetBltStatus
)
122 return NtGdiDdGetBltStatus((HANDLE
)GetBltStatus
->lpDDSurface
->hDDSurface
,
123 (PDD_GETBLTSTATUSDATA
)GetBltStatus
);
128 DdGetFlipStatus(LPDDHAL_GETFLIPSTATUSDATA GetFlipStatus
)
131 return NtGdiDdGetFlipStatus((HANDLE
)GetFlipStatus
->lpDDSurface
->hDDSurface
,
132 (PDD_GETFLIPSTATUSDATA
)GetFlipStatus
);
137 DdUpdateOverlay(LPDDHAL_UPDATEOVERLAYDATA UpdateOverlay
)
139 /* We have to handle this manually here */
140 if (UpdateOverlay
->dwFlags
& DDOVER_KEYDEST
)
142 /* Use the override */
143 UpdateOverlay
->dwFlags
&= ~DDOVER_KEYDEST
;
144 UpdateOverlay
->dwFlags
|= DDOVER_KEYDESTOVERRIDE
;
146 /* Set the overlay */
147 UpdateOverlay
->overlayFX
.dckDestColorkey
=
148 UpdateOverlay
->lpDDDestSurface
->ddckCKDestOverlay
;
150 if (UpdateOverlay
->dwFlags
& DDOVER_KEYSRC
)
152 /* Use the override */
153 UpdateOverlay
->dwFlags
&= ~DDOVER_KEYSRC
;
154 UpdateOverlay
->dwFlags
|= DDOVER_KEYSRCOVERRIDE
;
156 /* Set the overlay */
157 UpdateOverlay
->overlayFX
.dckSrcColorkey
=
158 UpdateOverlay
->lpDDSrcSurface
->ddckCKSrcOverlay
;
162 return NtGdiDdUpdateOverlay((HANDLE
)UpdateOverlay
->lpDDDestSurface
->hDDSurface
,
163 (HANDLE
)UpdateOverlay
->lpDDSrcSurface
->hDDSurface
,
164 (PDD_UPDATEOVERLAYDATA
)UpdateOverlay
);
169 DdSetOverlayPosition(LPDDHAL_SETOVERLAYPOSITIONDATA SetOverlayPosition
)
172 return NtGdiDdSetOverlayPosition((HANDLE
)SetOverlayPosition
->
173 lpDDSrcSurface
->hDDSurface
,
174 (HANDLE
)SetOverlayPosition
->
175 lpDDDestSurface
->hDDSurface
,
176 (PDD_SETOVERLAYPOSITIONDATA
)
185 DdWaitForVerticalBlank(LPDDHAL_WAITFORVERTICALBLANKDATA WaitForVerticalBlank
)
188 return NtGdiDdWaitForVerticalBlank(GetDdHandle(
189 WaitForVerticalBlank
->lpDD
->hDD
),
190 (PDD_WAITFORVERTICALBLANKDATA
)
191 WaitForVerticalBlank
);
196 DdCanCreateSurface(LPDDHAL_CANCREATESURFACEDATA CanCreateSurface
)
199 return NtGdiDdCanCreateSurface(GetDdHandle(CanCreateSurface
->lpDD
->hDD
),
200 (PDD_CANCREATESURFACEDATA
)CanCreateSurface
);
205 DdCreateSurface(LPDDHAL_CREATESURFACEDATA pCreateSurface
)
207 DWORD Return
= DDHAL_DRIVER_NOTHANDLED
;
208 ULONG SurfaceCount
= pCreateSurface
->dwSCnt
;
209 DD_SURFACE_LOCAL DdSurfaceLocal
;
210 DD_SURFACE_MORE DdSurfaceMore
;
211 DD_SURFACE_GLOBAL DdSurfaceGlobal
;
213 HANDLE hPrevSurface
, hSurface
;
216 PDD_SURFACE_LOCAL pDdSurfaceLocal
= NULL
;
217 PDD_SURFACE_MORE pDdSurfaceMore
= NULL
;
218 PDD_SURFACE_GLOBAL pDdSurfaceGlobal
= NULL
;
220 PDD_SURFACE_LOCAL ptmpDdSurfaceLocal
= NULL
;
221 PDD_SURFACE_MORE ptmpDdSurfaceMore
= NULL
;
222 PDD_SURFACE_GLOBAL ptmpDdSurfaceGlobal
= NULL
;
223 PHANDLE phSurface
= NULL
, puhSurface
= NULL
;
225 LPDDSURFACEDESC pSurfaceDesc
= NULL
;
227 /* Check how many surfaces there are */
228 if (SurfaceCount
!= 1)
230 /* We'll have to allocate more data, our stack isn't big enough */
235 /* We'll use what we have on the stack */
236 pDdSurfaceLocal
= &DdSurfaceLocal
;
237 pDdSurfaceMore
= &DdSurfaceMore
;
238 pDdSurfaceGlobal
= &DdSurfaceGlobal
;
239 phSurface
= &hPrevSurface
;
240 puhSurface
= &hSurface
;
242 /* Clear the structures */
243 RtlZeroMemory(&DdSurfaceLocal
, sizeof(DdSurfaceLocal
));
244 RtlZeroMemory(&DdSurfaceGlobal
, sizeof(DdSurfaceGlobal
));
245 RtlZeroMemory(&DdSurfaceMore
, sizeof(DdSurfaceMore
));
248 /* check if we got a surface or not */
251 /* Loop for each surface */
252 ptmpDdSurfaceGlobal
= pDdSurfaceGlobal
;
253 ptmpDdSurfaceLocal
= pDdSurfaceLocal
;
254 ptmpDdSurfaceMore
= pDdSurfaceMore
;
255 pSurfaceDesc
= pCreateSurface
->lpDDSurfaceDesc
;
257 for (i
= 0; i
< SurfaceCount
; i
++)
259 LPDDRAWI_DDRAWSURFACE_LCL lcl
= pCreateSurface
->lplpSList
[i
];
260 LPDDRAWI_DDRAWSURFACE_GBL gpl
= pCreateSurface
->lplpSList
[i
]->lpGbl
;
262 phSurface
[i
] = (HANDLE
)lcl
->hDDSurface
;
263 ptmpDdSurfaceLocal
->ddsCaps
.dwCaps
= lcl
->ddsCaps
.dwCaps
;
265 ptmpDdSurfaceLocal
->dwFlags
= (ptmpDdSurfaceLocal
->dwFlags
&
266 (0xB0000000 | DDRAWISURF_INMASTERSPRITELIST
|
267 DDRAWISURF_HELCB
| DDRAWISURF_FRONTBUFFER
|
268 DDRAWISURF_BACKBUFFER
| DDRAWISURF_INVALID
|
269 DDRAWISURF_DCIBUSY
| DDRAWISURF_DCILOCK
)) |
270 (lcl
->dwFlags
& DDRAWISURF_DRIVERMANAGED
);
272 ptmpDdSurfaceGlobal
->wWidth
= gpl
->wWidth
;
273 ptmpDdSurfaceGlobal
->wHeight
= gpl
->wHeight
;
274 ptmpDdSurfaceGlobal
->lPitch
= gpl
->fpVidMem
;
275 ptmpDdSurfaceGlobal
->fpVidMem
= gpl
->fpVidMem
;
276 ptmpDdSurfaceGlobal
->dwBlockSizeX
= gpl
->dwBlockSizeX
;
277 ptmpDdSurfaceGlobal
->dwBlockSizeY
= gpl
->dwBlockSizeY
;
279 if (lcl
->dwFlags
& DDRAWISURF_HASPIXELFORMAT
)
281 RtlCopyMemory( &ptmpDdSurfaceGlobal
->ddpfSurface
,
283 sizeof(DDPIXELFORMAT
));
285 ptmpDdSurfaceGlobal
->ddpfSurface
.dwSize
= sizeof(DDPIXELFORMAT
);
289 RtlCopyMemory( &ptmpDdSurfaceGlobal
->ddpfSurface
,
290 &gpl
->lpDD
->vmiData
.ddpfDisplay
,
291 sizeof(DDPIXELFORMAT
));
296 ptmpDdSurfaceMore
->ddsCapsEx
.dwCaps2
= lcl
->lpSurfMore
->ddsCapsEx
.dwCaps2
;
297 ptmpDdSurfaceMore
->ddsCapsEx
.dwCaps3
= lcl
->lpSurfMore
->ddsCapsEx
.dwCaps3
;
298 ptmpDdSurfaceMore
->ddsCapsEx
.dwCaps4
= lcl
->lpSurfMore
->ddsCapsEx
.dwCaps4
;
299 ptmpDdSurfaceMore
->dwSurfaceHandle
= (DWORD
) pCreateSurface
->lplpSList
[i
]->dbnOverlayNode
.object_int
;
302 /* FIXME count to next SurfaceCount for
303 ptmpDdSurfaceGlobal = pDdSurfaceGlobal;
304 ptmpDdSurfaceLocal = pDdSurfaceLocal;
305 ptmpDdSurfaceMore = pDdSurfaceMore;
307 we only support one surface create at moment
312 /* Call win32k now */
313 pCreateSurface
->ddRVal
= DDERR_GENERIC
;
315 Return
= NtGdiDdCreateSurface(GetDdHandle(pCreateSurface
->lpDD
->hDD
),
321 (PDD_CREATESURFACEDATA
)pCreateSurface
,
324 if (SurfaceCount
== 0)
326 pCreateSurface
->ddRVal
= DDERR_GENERIC
;
330 ptmpDdSurfaceMore
= pDdSurfaceMore
;
331 ptmpDdSurfaceGlobal
= pDdSurfaceGlobal
;
332 ptmpDdSurfaceLocal
= pDdSurfaceLocal
;
334 for (i
=0;i
<SurfaceCount
;i
++)
336 LPDDRAWI_DDRAWSURFACE_LCL lcl
= pCreateSurface
->lplpSList
[i
];
337 LPDDRAWI_DDRAWSURFACE_GBL gpl
= pCreateSurface
->lplpSList
[i
]->lpGbl
;
339 gpl
->lPitch
= ptmpDdSurfaceGlobal
->lPitch
;
340 gpl
->fpVidMem
= ptmpDdSurfaceGlobal
->fpVidMem
;
341 gpl
->dwBlockSizeX
= ptmpDdSurfaceGlobal
->dwBlockSizeX
;
342 gpl
->dwBlockSizeY
= ptmpDdSurfaceGlobal
->dwBlockSizeY
;
344 if (lcl
->dwFlags
& DDRAWISURF_HASPIXELFORMAT
)
346 RtlCopyMemory( &gpl
->ddpfSurface
, &ptmpDdSurfaceGlobal
->ddpfSurface
, sizeof(DDPIXELFORMAT
));
349 if (pCreateSurface
->ddRVal
!= DD_OK
)
354 NtGdiDdDeleteSurfaceObject( (HANDLE
)lcl
->hDDSurface
);
361 lcl
->hDDSurface
= (ULONG_PTR
) puhSurface
[i
];
364 lcl
->ddsCaps
.dwCaps
= ptmpDdSurfaceLocal
->ddsCaps
.dwCaps
;
367 lcl
->lpSurfMore
->ddsCapsEx
.dwCaps2
= ptmpDdSurfaceMore
->ddsCapsEx
.dwCaps2
;
368 lcl
->lpSurfMore
->ddsCapsEx
.dwCaps3
= ptmpDdSurfaceMore
->ddsCapsEx
.dwCaps3
;
369 lcl
->lpSurfMore
->ddsCapsEx
.dwCaps4
= ptmpDdSurfaceMore
->ddsCapsEx
.dwCaps4
;
371 /* FIXME count to next SurfaceCount for
372 ptmpDdSurfaceGlobal = pDdSurfaceGlobal;
373 ptmpDdSurfaceLocal = pDdSurfaceLocal;
374 ptmpDdSurfaceMore = pDdSurfaceMore;
375 we only support one surface create at moment
380 /* Check if we have to free all our local allocations */
381 if (SurfaceCount
> 1)
392 DdSetColorKey(LPDDHAL_SETCOLORKEYDATA pSetColorKey
)
395 return NtGdiDdSetColorKey((HANDLE
)pSetColorKey
->lpDDSurface
->hDDSurface
,
396 (PDD_SETCOLORKEYDATA
)pSetColorKey
);
401 DdGetScanLine(LPDDHAL_GETSCANLINEDATA pGetScanLine
)
404 return NtGdiDdGetScanLine(GetDdHandle(pGetScanLine
->lpDD
->hDD
),
405 (PDD_GETSCANLINEDATA
)pGetScanLine
);
408 /* PRIVATE FUNCTIONS *********************************************************/
409 static ULONG RemberDdQueryDisplaySettingsUniquenessID
= 0;
413 bDDCreateSurface(LPDDRAWI_DDRAWSURFACE_LCL pSurface
,
416 DD_SURFACE_LOCAL SurfaceLocal
;
417 DD_SURFACE_GLOBAL SurfaceGlobal
;
418 DD_SURFACE_MORE SurfaceMore
;
421 RtlZeroMemory(&SurfaceLocal
, sizeof(DD_SURFACE_LOCAL
));
422 RtlZeroMemory(&SurfaceGlobal
, sizeof(DD_SURFACE_GLOBAL
));
423 RtlZeroMemory(&SurfaceMore
, sizeof(DD_SURFACE_MORE
));
425 /* Set up SurfaceLocal struct */
426 SurfaceLocal
.ddsCaps
.dwCaps
= pSurface
->ddsCaps
.dwCaps
;
427 SurfaceLocal
.dwFlags
= pSurface
->dwFlags
;
429 /* Set up SurfaceMore struct */
430 RtlMoveMemory(&SurfaceMore
.ddsCapsEx
,
431 &pSurface
->ddckCKDestBlt
,
433 SurfaceMore
.dwSurfaceHandle
= (DWORD
)pSurface
->dbnOverlayNode
.object_int
->lpVtbl
;
435 /* Set up SurfaceGlobal struct */
436 SurfaceGlobal
.fpVidMem
= pSurface
->lpGbl
->fpVidMem
;
437 SurfaceGlobal
.dwLinearSize
= pSurface
->lpGbl
->dwLinearSize
;
438 SurfaceGlobal
.wHeight
= pSurface
->lpGbl
->wHeight
;
439 SurfaceGlobal
.wWidth
= pSurface
->lpGbl
->wWidth
;
441 /* Check if we have a pixel format */
442 if (pSurface
->dwFlags
& DDSD_PIXELFORMAT
)
445 SurfaceGlobal
.ddpfSurface
= pSurface
->lpGbl
->lpDD
->vmiData
.ddpfDisplay
;
446 SurfaceGlobal
.ddpfSurface
.dwSize
= sizeof(DDPIXELFORMAT
);
451 SurfaceGlobal
.ddpfSurface
= pSurface
->lpGbl
->lpDD
->vmiData
.ddpfDisplay
;
454 /* Create the object */
455 pSurface
->hDDSurface
= (DWORD
)NtGdiDdCreateSurfaceObject(GetDdHandle(pSurface
->lpGbl
->lpDD
->hDD
),
456 (HANDLE
)pSurface
->hDDSurface
,
463 if (pSurface
->hDDSurface
) return TRUE
;
467 /* PUBLIC FUNCTIONS **********************************************************/
476 DdCreateDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal
,
481 /* Check if the global hDC (hdc == 0) is being used */
484 /* We'll only allow this if the global object doesn't exist yet */
488 if ((hdc
= CreateDC(L
"Display", NULL
, NULL
, NULL
)))
490 /* Create the DDraw Object */
491 ghDirectDraw
= NtGdiDdCreateDirectDrawObject(hdc
);
494 NtGdiDeleteObjectApp(hdc
);
498 /* If we created the object, or had one ...*/
501 /* Increase count and set success */
506 /* Zero the handle */
507 pDirectDrawGlobal
->hDD
= 0;
511 /* Using the per-process object, so create it */
512 pDirectDrawGlobal
->hDD
= (ULONG_PTR
)NtGdiDdCreateDirectDrawObject(hdc
);
514 /* Set the return value */
515 Return
= pDirectDrawGlobal
->hDD
? TRUE
: FALSE
;
518 /* Return to caller */
529 DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal
,
530 LPDDHALINFO pHalInfo
,
531 LPDDHAL_DDCALLBACKS pDDCallbacks
,
532 LPDDHAL_DDSURFACECALLBACKS pDDSurfaceCallbacks
,
533 LPDDHAL_DDPALETTECALLBACKS pDDPaletteCallbacks
,
534 LPD3DHAL_CALLBACKS pD3dCallbacks
,
535 LPD3DHAL_GLOBALDRIVERDATA pD3dDriverData
,
536 LPDDHAL_DDEXEBUFCALLBACKS pD3dBufferCallbacks
,
537 LPDDSURFACEDESC pD3dTextureFormats
,
541 PVIDEOMEMORY VidMemList
= NULL
;
543 D3DNTHAL_CALLBACKS D3dCallbacks
;
544 D3DNTHAL_GLOBALDRIVERDATA D3dDriverData
;
545 DD_D3DBUFCALLBACKS D3dBufferCallbacks
;
546 DWORD CallbackFlags
[3];
547 DWORD dwNumHeaps
=0, FourCCs
=0;
550 /* Clear the structures */
551 RtlZeroMemory(&HalInfo
, sizeof(DD_HALINFO
));
552 RtlZeroMemory(&D3dCallbacks
, sizeof(D3DNTHAL_CALLBACKS
));
553 RtlZeroMemory(&D3dDriverData
, sizeof(D3DNTHAL_GLOBALDRIVERDATA
));
554 RtlZeroMemory(&D3dBufferCallbacks
, sizeof(DD_D3DBUFCALLBACKS
));
555 RtlZeroMemory(CallbackFlags
, sizeof(DWORD
)*3);
557 /* Check if we got a list pointer */
560 /* Allocate memory for it */
561 VidMemList
= LocalAlloc(LMEM_ZEROINIT
,
562 sizeof(VIDEOMEMORY
) *
563 pHalInfo
->vmiData
.dwNumHeaps
);
567 if (!NtGdiDdQueryDirectDrawObject(GetDdHandle(pDirectDrawGlobal
->hDD
),
579 /* We failed, free the memory and return */
580 if (VidMemList
) LocalFree(VidMemList
);
584 /* Clear the incoming pointer */
585 RtlZeroMemory(pHalInfo
, sizeof(DDHALINFO
));
587 /* Convert all the data */
588 pHalInfo
->dwSize
= sizeof(DDHALINFO
);
589 pHalInfo
->lpDDCallbacks
= pDDCallbacks
;
590 pHalInfo
->lpDDSurfaceCallbacks
= pDDSurfaceCallbacks
;
591 pHalInfo
->lpDDPaletteCallbacks
= pDDPaletteCallbacks
;
593 /* Check for NT5+ D3D Data */
594 if (D3dCallbacks
.dwSize
&& D3dDriverData
.dwSize
)
596 /* Write these down */
597 pHalInfo
->lpD3DGlobalDriverData
= (ULONG_PTR
)pD3dDriverData
;
598 pHalInfo
->lpD3DHALCallbacks
= (ULONG_PTR
)pD3dCallbacks
;
600 /* Check for Buffer Callbacks */
601 if (D3dBufferCallbacks
.dwSize
)
603 /* Write this one too */
604 pHalInfo
->lpDDExeBufCallbacks
= pD3dBufferCallbacks
;
608 /* Continue converting the rest */
609 pHalInfo
->vmiData
.dwFlags
= HalInfo
.vmiData
.dwFlags
;
610 pHalInfo
->vmiData
.dwDisplayWidth
= HalInfo
.vmiData
.dwDisplayWidth
;
611 pHalInfo
->vmiData
.dwDisplayHeight
= HalInfo
.vmiData
.dwDisplayHeight
;
612 pHalInfo
->vmiData
.lDisplayPitch
= HalInfo
.vmiData
.lDisplayPitch
;
613 pHalInfo
->vmiData
.fpPrimary
= 0;
615 RtlCopyMemory( &pHalInfo
->vmiData
.ddpfDisplay
,
616 &HalInfo
.vmiData
.ddpfDisplay
,
617 sizeof(DDPIXELFORMAT
));
619 pHalInfo
->vmiData
.dwOffscreenAlign
= HalInfo
.vmiData
.dwOffscreenAlign
;
620 pHalInfo
->vmiData
.dwOverlayAlign
= HalInfo
.vmiData
.dwOverlayAlign
;
621 pHalInfo
->vmiData
.dwTextureAlign
= HalInfo
.vmiData
.dwTextureAlign
;
622 pHalInfo
->vmiData
.dwZBufferAlign
= HalInfo
.vmiData
.dwZBufferAlign
;
623 pHalInfo
->vmiData
.dwAlphaAlign
= HalInfo
.vmiData
.dwAlphaAlign
;
624 pHalInfo
->vmiData
.dwNumHeaps
= dwNumHeaps
;
625 pHalInfo
->vmiData
.pvmList
= pvmList
;
627 RtlCopyMemory( &pHalInfo
->ddCaps
, &HalInfo
.ddCaps
,sizeof(DDCORECAPS
));
629 pHalInfo
->ddCaps
.dwNumFourCCCodes
= FourCCs
;
630 pHalInfo
->lpdwFourCC
= pdwFourCC
;
631 pHalInfo
->ddCaps
.dwRops
[6] = 0x1000;
633 /* FIXME implement DdGetDriverInfo */
634 // pHalInfo->dwFlags = HalInfo.dwFlags | DDHALINFO_GETDRIVERINFOSET;
635 // pHalInfo->GetDriverInfo = DdGetDriverInfo;
637 /* Now check if we got any DD callbacks */
640 /* Zero the structure */
641 RtlZeroMemory(pDDCallbacks
, sizeof(DDHAL_DDCALLBACKS
));
643 /* Set the flags for this structure */
644 Flags
= CallbackFlags
[0];
646 /* Write the header */
647 pDDCallbacks
->dwSize
= sizeof(DDHAL_DDCALLBACKS
);
648 pDDCallbacks
->dwFlags
= Flags
;
650 /* Now write the pointers, if applicable */
651 if (Flags
& DDHAL_CB32_CREATESURFACE
)
653 pDDCallbacks
->CreateSurface
= DdCreateSurface
;
655 if (Flags
& DDHAL_CB32_WAITFORVERTICALBLANK
)
657 pDDCallbacks
->WaitForVerticalBlank
= DdWaitForVerticalBlank
;
659 if (Flags
& DDHAL_CB32_CANCREATESURFACE
)
661 pDDCallbacks
->CanCreateSurface
= DdCanCreateSurface
;
663 if (Flags
& DDHAL_CB32_GETSCANLINE
)
665 pDDCallbacks
->GetScanLine
= DdGetScanLine
;
669 /* Check for DD Surface Callbacks */
670 if (pDDSurfaceCallbacks
)
672 /* Zero the structures */
673 RtlZeroMemory(pDDSurfaceCallbacks
, sizeof(DDHAL_DDSURFACECALLBACKS
));
675 /* Set the flags for this one */
676 Flags
= CallbackFlags
[1];
678 /* Write the header, note that some functions are always exposed */
679 pDDSurfaceCallbacks
->dwSize
= sizeof(DDHAL_DDSURFACECALLBACKS
);
681 pDDSurfaceCallbacks
->dwFlags
= Flags
;
683 pDDSurfaceCallBacks->dwFlags = (DDHAL_SURFCB32_LOCK |
684 DDHAL_SURFCB32_UNLOCK |
685 DDHAL_SURFCB32_SETCOLORKEY |
686 DDHAL_SURFCB32_DESTROYSURFACE) | Flags;
689 /* Write the always-on functions */
690 pDDSurfaceCallbacks
->Lock
= DdLock
;
691 pDDSurfaceCallbacks
->Unlock
= DdUnlock
;
692 pDDSurfaceCallbacks
->SetColorKey
= DdSetColorKey
;
693 pDDSurfaceCallbacks
->DestroySurface
= DdDestroySurface
;
695 /* Write the optional ones */
696 if (Flags
& DDHAL_SURFCB32_FLIP
)
698 pDDSurfaceCallbacks
->Flip
= DdFlip
;
700 if (Flags
& DDHAL_SURFCB32_BLT
)
702 pDDSurfaceCallbacks
->Blt
= DdBlt
;
704 if (Flags
& DDHAL_SURFCB32_GETBLTSTATUS
)
706 pDDSurfaceCallbacks
->GetBltStatus
= DdGetBltStatus
;
708 if (Flags
& DDHAL_SURFCB32_GETFLIPSTATUS
)
710 pDDSurfaceCallbacks
->GetFlipStatus
= DdGetFlipStatus
;
712 if (Flags
& DDHAL_SURFCB32_UPDATEOVERLAY
)
714 pDDSurfaceCallbacks
->UpdateOverlay
= DdUpdateOverlay
;
716 if (Flags
& DDHAL_SURFCB32_SETOVERLAYPOSITION
)
718 pDDSurfaceCallbacks
->SetOverlayPosition
= DdSetOverlayPosition
;
720 if (Flags
& DDHAL_SURFCB32_ADDATTACHEDSURFACE
)
722 pDDSurfaceCallbacks
->AddAttachedSurface
= DdAddAttachedSurface
;
726 /* Check for DD Palette Callbacks */
727 if (pDDPaletteCallbacks
)
729 /* Zero the struct */
730 RtlZeroMemory(pDDPaletteCallbacks
, sizeof(DDHAL_DDPALETTECALLBACKS
));
732 /* Get the flags for this one */
733 Flags
= CallbackFlags
[2];
735 /* Write the header */
736 pDDPaletteCallbacks
->dwSize
= sizeof(DDHAL_DDPALETTECALLBACKS
);
737 pDDPaletteCallbacks
->dwFlags
= Flags
;
740 /* Check for D3D Callbacks */
743 /* Zero the struct */
744 RtlZeroMemory(pD3dCallbacks
, sizeof(D3DHAL_CALLBACKS
));
746 /* Check if we have one */
747 if (D3dCallbacks
.dwSize
)
749 /* Write the header */
750 pD3dCallbacks
->dwSize
= sizeof(D3DHAL_CALLBACKS
);
752 /* Now check for each callback */
753 if (D3dCallbacks
.ContextCreate
)
756 pD3dCallbacks->ContextCreate = D3dContextCreate;
759 if (D3dCallbacks
.ContextDestroy
)
761 pD3dCallbacks
->ContextDestroy
= (LPD3DHAL_CONTEXTDESTROYCB
) NtGdiD3dContextDestroy
;
763 if (D3dCallbacks
.ContextDestroyAll
)
766 pD3dCallbacks->ContextDestroyAll = (LPD3DHAL_CONTEXTDESTROYALLCB) NtGdiD3dContextDestroyAll;
772 /* Check for D3D Driver Data */
775 /* Copy the struct */
776 RtlMoveMemory(pD3dDriverData
,
778 sizeof(D3DHAL_GLOBALDRIVERDATA
));
780 /* Write the pointer to the texture formats */
781 pD3dDriverData
->lpTextureFormats
= pD3dTextureFormats
;
784 /* FIXME: Check for D3D Buffer Callbacks */
786 /* Check if we have a video memory list */
789 /* Start a loop here */
790 PVIDEOMEMORY VidMem
= VidMemList
;
792 /* Loop all the heaps we have */
795 /* Copy from one format to the other */
796 pvmList
->dwFlags
= VidMem
->dwFlags
;
797 pvmList
->fpStart
= VidMem
->fpStart
;
798 pvmList
->fpEnd
= VidMem
->fpEnd
;
799 pvmList
->ddsCaps
= VidMem
->ddsCaps
;
800 pvmList
->ddsCapsAlt
= VidMem
->ddsCapsAlt
;
801 pvmList
->dwHeight
= VidMem
->dwHeight
;
803 /* Advance in both structures */
808 /* Free our structure */
809 LocalFree(VidMemList
);
823 DdDeleteDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal
)
827 /* If this is the global object */
828 if(pDirectDrawGlobal
->hDD
)
831 Return
= NtGdiDdDeleteDirectDrawObject((HANDLE
)pDirectDrawGlobal
->hDD
);
834 pDirectDrawGlobal
->hDD
= 0;
837 else if (ghDirectDraw
)
839 /* Always success here */
842 /* Make sure this is the last instance */
843 if (!(--gcDirectDraw
))
845 /* Delete the object */
846 Return
= NtGdiDdDeleteDirectDrawObject(ghDirectDraw
);
865 DdCreateSurfaceObject( LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal
,
866 BOOL bPrimarySurface
)
868 return bDDCreateSurface(pSurfaceLocal
, TRUE
);
869 //return bDdCreateSurfaceObject(pSurfaceLocal, TRUE);
880 DdDeleteSurfaceObject(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal
)
884 /* Make sure there is one */
885 if (pSurfaceLocal
->hDDSurface
)
888 Return
= NtGdiDdDeleteSurfaceObject((HANDLE
)pSurfaceLocal
->hDDSurface
);
889 pSurfaceLocal
->hDDSurface
= 0;
902 DdResetVisrgn(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal
,
905 /* Call win32k directly */
906 return NtGdiDdResetVisrgn((HANDLE
) pSurfaceLocal
->hDDSurface
, hWnd
);
916 DdGetDC(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal
,
917 LPPALETTEENTRY pColorTable
)
919 /* Call win32k directly */
920 return NtGdiDdGetDC(pColorTable
, (HANDLE
) pSurfaceLocal
->hDDSurface
);
930 DdReleaseDC(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal
)
932 /* Call win32k directly */
933 return NtGdiDdReleaseDC((HANDLE
) pSurfaceLocal
->hDDSurface
);
942 DdCreateDIBSection(HDC hdc
,
943 CONST BITMAPINFO
*pbmi
,
949 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
960 DdReenableDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal
,
963 /* Call win32k directly */
964 return NtGdiDdReenableDirectDrawObject(GetDdHandle(pDirectDrawGlobal
->hDD
),
976 DdAttachSurface( LPDDRAWI_DDRAWSURFACE_LCL pSurfaceFrom
,
977 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceTo
)
979 /* Create Surface if it does not exits one */
980 if (pSurfaceFrom
->hDDSurface
)
982 if (!bDDCreateSurface(pSurfaceFrom
, FALSE
))
988 /* Create Surface if it does not exits one */
989 if (pSurfaceTo
->hDDSurface
)
991 if (!bDDCreateSurface(pSurfaceTo
, FALSE
))
998 return NtGdiDdAttachSurface((HANDLE
)pSurfaceFrom
->hDDSurface
,
999 (HANDLE
)pSurfaceTo
->hDDSurface
);
1009 DdUnattachSurface(LPDDRAWI_DDRAWSURFACE_LCL pSurface
,
1010 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceAttached
)
1013 NtGdiDdUnattachSurface((HANDLE
)pSurface
->hDDSurface
,
1014 (HANDLE
)pSurfaceAttached
->hDDSurface
);
1024 DdQueryDisplaySettingsUniqueness()
1026 return RemberDdQueryDisplaySettingsUniquenessID
;
1036 DdGetDxHandle(LPDDRAWI_DIRECTDRAW_LCL pDDraw
,
1037 LPDDRAWI_DDRAWSURFACE_LCL pSurface
,
1041 HANDLE hSurface
= (HANDLE
)pSurface
->hDDSurface
;
1043 /* Check if we already have a surface */
1046 /* We don't have one, use the DirectDraw Object handle instead */
1048 hDD
= GetDdHandle(pDDraw
->lpGbl
->hDD
);
1052 return (HANDLE
)NtGdiDdGetDxHandle(hDD
, hSurface
, bRelease
);
1062 DdSetGammaRamp(LPDDRAWI_DIRECTDRAW_LCL pDDraw
,
1066 /* Call win32k directly */
1067 return NtGdiDdSetGammaRamp(GetDdHandle(pDDraw
->lpGbl
->hDD
),
1078 DdSwapTextureHandles(LPDDRAWI_DIRECTDRAW_LCL pDDraw
,
1079 LPDDRAWI_DDRAWSURFACE_LCL pDDSLcl1
,
1080 LPDDRAWI_DDRAWSURFACE_LCL pDDSLcl2
)
1082 /* Always returns success */