mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1618 lines
62 KiB
1618 lines
62 KiB
/*==========================================================================;
|
|
*
|
|
* Copyright (C) 1994-1996 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* File: ddrawi.h
|
|
* Content: DirectDraw internal header file
|
|
* Used by DirectDraw and by the display drivers.
|
|
*@@BEGIN_MSINTERNAL
|
|
* See ddrawpr.h for all information private to DirectDraw.
|
|
* History:
|
|
* Date By Reason
|
|
* ==== == ======
|
|
* 25-dec-94 craige initial implementation
|
|
* 06-jan-95 craige video memory manager integration
|
|
* 13-jan-95 craige re-worked to updated spec + ongoing work
|
|
* 21-jan-95 craige made 32-bit + ongoing work
|
|
* 31-jan-95 craige and even more ongoing work...
|
|
* 04-feb-95 craige performance tuning, ongoing work
|
|
* 22-feb-95 craige use critical sections on Win95
|
|
* 02-mar-95 craige work work work
|
|
* 06-mar-95 craige HEL integration
|
|
* 11-mar-95 craige palette stuff
|
|
* 17-mar-95 craige COM interface
|
|
* 19-mar-95 craige use HRESULTs, use same process list handling for
|
|
* driver objects as surface and palette
|
|
* 20-mar-95 craige new CSECT work
|
|
* 23-mar-95 craige attachment work
|
|
* 27-mar-95 craige linear or rectangular vidmem
|
|
* 28-mar-95 craige RGBQUAD -> PALETTEENTRY; other palette stuff
|
|
* 29-mar-95 craige removed Eitherxxx caps from DIRECTDRAW
|
|
* 31-mar-95 craige use critical sections with palettes
|
|
* 04-apr-95 craige palette tweaks
|
|
* 06-apr-95 craige split out process list stuff
|
|
* 10-apr-95 craige bug 3,16 - palette issues
|
|
* 13-apr-95 craige EricEng's little contribution to our being late
|
|
* 06-may-95 craige use driver-level csects only
|
|
* 09-may-95 craige escape call to get 32-bit DLL
|
|
* 14-may-95 craige cleaned out obsolete junk
|
|
* 15-may-95 craige made separate VMEM struct for rect & linear
|
|
* 24-may-95 kylej removed obsolete ZOrder variables
|
|
* 24-may-95 craige removed dwOrigNumHeaps
|
|
* 28-may-95 craige cleaned up HAL: added GetBltStatus;GetFlipStatus;
|
|
* GetScanLine
|
|
* 02-jun-95 craige added PROCESS_LIST2 to DIRECTDRAW object; removed
|
|
* hWndPal from DIRECTDRAW object; added lpDDSurface
|
|
* to DIRECTDRAWPALETTE object
|
|
* 06-jun-95 craige maintain entire primary surface in DIRECTDRAW object
|
|
* 07-jun-95 craige moved DCLIST to PROCESSLIST
|
|
* 10-jun-95 craige split out vmemmgr stuff
|
|
* 12-jun-95 craige new process list stuff
|
|
* 16-jun-95 craige removed fpVidMemOrig; new surface structure
|
|
* 20-jun-95 kylej added is_excl field to DDHAL_CREATEPALETTEDATA struct
|
|
* 21-jun-95 craige added DirectDrawClipper object; removed clipping
|
|
* info from surface object
|
|
* 22-jun-95 craige more clipping work
|
|
* 25-jun-95 craige one ddraw mutex
|
|
* 26-jun-95 craige reorganized surface structure
|
|
* 27-jun-95 craige added dwModeCreatedIn to surface
|
|
* 30-jun-95 kylej removed lpPrimarySurface, dwZDepth, dwAlphaDepth
|
|
* from direct draw object. Modified some surface and
|
|
* direct draw object flags.
|
|
* 01-jul-95 craige hide composition & streaming stuff
|
|
* 02-jul-95 craige added extra reserved field for HEL
|
|
* 03-jul-95 craige YEEHAW: new driver struct; added pUnkOuter to all objects
|
|
* 09-jul-95 craige track win16lock info in driver struct; added
|
|
* DDHAL_DRIVER_NOCKEYHW
|
|
* 10-jul-95 craige support SetOverlayPosition
|
|
* 13-jul-95 craige removed old junk from ddraw object; added new mode stuff;
|
|
* changed Get/SetOverlayPosition to use longs;
|
|
* fixed duplicate flag in DDRAWIPAL_xxx
|
|
* 14-jul-95 craige added VIDMEM_ISHEAP
|
|
* 20-jul-95 craige internal reorg to prevent thunking during modeset;
|
|
* palette bugs
|
|
* 22-jul-95 craige bug 230 - unsupported starting modes
|
|
* 29-jul-95 toddla remove unused palette stuff
|
|
* 31-jul-95 toddla added DD_HAL_VERSION
|
|
* 01-aug-95 toddla added dwPDevice to DDRAWI_DIRECTDRAW_GBL
|
|
* 10-aug-95 craige added VALID_ALIGNMENT
|
|
* 13-aug-95 craige internal/external version of DD_HAL_VERSION
|
|
* 21-aug-95 craige mode X support
|
|
* 27-aug-95 craige bug 742: added DDRAWIPAL_ALLOW256
|
|
* 08-nov-95 colinmc added DDRAWIPAL flags to support 1, 2 and 4 bit
|
|
* RGB and indexed palettes
|
|
* 21-nov-95 colinmc made Direct3D a queryable interface off DirectDraw
|
|
* 23-nov-95 colinmc made Direct3D textures and devices queryable off
|
|
* DirectDraw surfaces
|
|
* 09-dec-95 colinmc execute buffer support
|
|
* 12-dec-95 colinmc shared back and z-buffer support (run away, run away...)
|
|
* 22-dec-95 colinmc Direct3D support no longer conditional
|
|
* 02-jan-96 kylej New interface structures, no vtbl in local objects
|
|
* 10-jan-96 colinmc Aggregate IUnknowns of surfaces now maintained as
|
|
* list
|
|
* 18-jan-96 jeffno Changed free entries in DDRAW_GBL and SURFACE_LCL to NT
|
|
* kernel-mode handles
|
|
* 29-jan-96 colinmc Aggregated IUnknowns now stored in additional
|
|
* surface structure
|
|
* 09-feb-96 colinmc Addition of lost surface flag to local surface
|
|
* objects
|
|
* 17-feb-96 colinmc Fixed execute buffer size restriction problem
|
|
* 01-mar-96 kylej Change DDCAPS size
|
|
* 03-mar-96 colinmc Hack to keep interim drivers working
|
|
* 13-mar-96 craige Bug 7528: hw that doesn't have modex
|
|
* 14-mar-96 colinmc Class factory support for clippers
|
|
* 24-mar-96 colinmc Bug 14321: not possible to specify back buffer and
|
|
* mip-map count in a single call
|
|
* 13-apr-96 colinmc Bug 17736: no notification to driver of when GDI
|
|
* frame buffer is being displayed
|
|
* 16-apr-96 kylej Bug 17900: DBLNODE struct incompatible with ddraw 1
|
|
*@@END_MSINTERNAL
|
|
*
|
|
***************************************************************************/
|
|
#ifndef __DDRAWI_INCLUDED__
|
|
#define __DDRAWI_INCLUDED__
|
|
|
|
/*
|
|
* METAQUESTION: Why are Windows handles stored as DWORDs instead of
|
|
* their proper types?
|
|
* METAANSWER: To make the thunk to the 16-bit side completely painless.
|
|
*/
|
|
|
|
#define OBJECT_ISROOT 0x80000000l // object is root object
|
|
|
|
/*
|
|
* stuff for drivers
|
|
*/
|
|
#ifndef _WIN32
|
|
typedef long HRESULT;
|
|
typedef LPVOID REFIID;
|
|
typedef void GUID;
|
|
#define MAKE_HRESULT(sev,fac,code) \
|
|
((HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) )
|
|
#endif
|
|
|
|
//@@BEGIN_MSINTERNAL
|
|
// Include ddrawp.h for DirectDraw and D3D builds. DDK includes ddraw.h
|
|
#ifdef MSBUILD
|
|
#include "ddrawp.h"
|
|
#else
|
|
//@@END_MSINTERNAL
|
|
#include "ddraw.h"
|
|
//@@BEGIN_MSINTERNAL
|
|
#endif
|
|
//@@END_MSINTERNAL
|
|
#include "dmemmgr.h"
|
|
|
|
#ifndef _WIN32
|
|
/*
|
|
* these error codes are DIFFERENT in Win32 and Win16!!!!
|
|
*/
|
|
#undef E_NOTIMPL
|
|
#undef E_OUTOFMEMORY
|
|
#undef E_INVALIDARG
|
|
#undef E_FAIL
|
|
#define E_NOTIMPL 0x80004001L
|
|
#define E_OUTOFMEMORY 0x8007000EL
|
|
#define E_INVALIDARG 0x80070057L
|
|
#define E_FAIL 0x80004005L
|
|
#endif
|
|
|
|
|
|
#define DDUNSUPPORTEDMODE ((DWORD) -1)
|
|
|
|
|
|
#define VALID_ALIGNMENT( align ) (!((align == 0) || (align % 2) != 0 ))
|
|
|
|
/*
|
|
* List of processes attached to a DirectDraw object
|
|
*/
|
|
typedef struct _PROCESS_LIST
|
|
{
|
|
struct _PROCESS_LIST FAR *lpLink;
|
|
DWORD dwProcessId;
|
|
DWORD dwRefCnt;
|
|
DWORD dwAlphaDepth;
|
|
DWORD dwZDepth;
|
|
} PROCESS_LIST;
|
|
typedef PROCESS_LIST FAR *LPPROCESS_LIST;
|
|
|
|
/*
|
|
* DeleteFromActiveProcessList return codes
|
|
*/
|
|
#define DELETED_OK 0
|
|
#define DELETED_LASTONE 1
|
|
#define DELETED_NOTFOUND 2
|
|
|
|
#define DDBLT_ANYALPHA \
|
|
(DDBLT_ALPHASRCSURFACEOVERRIDE | \
|
|
DDBLT_ALPHASRCCONSTOVERRIDE | \
|
|
DDBLT_ALPHASRC | \
|
|
DDBLT_ALPHADESTSURFACEOVERRIDE | \
|
|
DDBLT_ALPHADESTCONSTOVERRIDE | \
|
|
DDBLT_ALPHADEST)
|
|
|
|
#define DDOVER_ANYALPHA \
|
|
(DDOVER_ALPHASRCSURFACEOVERRIDE | \
|
|
DDOVER_ALPHASRCCONSTOVERRIDE | \
|
|
DDOVER_ALPHASRC | \
|
|
DDOVER_ALPHADESTSURFACEOVERRIDE | \
|
|
DDOVER_ALPHADESTCONSTOVERRIDE | \
|
|
DDOVER_ALPHADEST)
|
|
|
|
|
|
typedef struct IDirectDrawClipperVtbl DIRECTDRAWCLIPPERCALLBACKS;
|
|
typedef struct IDirectDrawPaletteVtbl DIRECTDRAWPALETTECALLBACKS;
|
|
typedef struct IDirectDrawSurfaceVtbl DIRECTDRAWSURFACECALLBACKS;
|
|
typedef struct IDirectDrawSurface2Vtbl DIRECTDRAWSURFACE2CALLBACKS;
|
|
//@@BEGIN_MSINTERNAL
|
|
#ifdef STREAMING
|
|
typedef struct IDirectDrawSurfaceStreamingVtbl DIRECTDRAWSURFACESTREAMINGCALLBACKS;
|
|
#endif
|
|
#ifdef COMPOSITION
|
|
typedef struct IDirectDrawSurfaceCompositionVtbl DIRECTDRAWSURFACECOMPOSITIONCALLBACKS;
|
|
#endif
|
|
//@@END_MSINTERNAL
|
|
typedef struct IDirectDrawVtbl DIRECTDRAWCALLBACKS;
|
|
typedef struct IDirectDraw2Vtbl DIRECTDRAW2CALLBACKS;
|
|
|
|
typedef DIRECTDRAWCLIPPERCALLBACKS FAR *LPDIRECTDRAWCLIPPERCALLBACKS;
|
|
typedef DIRECTDRAWPALETTECALLBACKS FAR *LPDIRECTDRAWPALETTECALLBACKS;
|
|
typedef DIRECTDRAWSURFACECALLBACKS FAR *LPDIRECTDRAWSURFACECALLBACKS;
|
|
//@@BEGIN_MSINTERNAL
|
|
#ifdef STREAMING
|
|
typedef DIRECTDRAWSURFACESTREAMINGCALLBACKS FAR *LPDIRECTDRAWSURFACESTREAMINGCALLBACKS;
|
|
#endif
|
|
#ifdef COMPOSITION
|
|
typedef DIRECTDRAWSURFACECOMPOSITIONCALLBACKS FAR *LPDIRECTDRAWSURFACECOMPOSITIONCALLBACKS;
|
|
#endif
|
|
//@@END_MSINTERNAL
|
|
typedef DIRECTDRAWCALLBACKS FAR *LPDIRECTDRAWCALLBACKS;
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#if defined( IS_32 ) || defined( WIN32 ) || defined( _WIN32 )
|
|
#undef IS_32
|
|
#define IS_32
|
|
#define DDAPI WINAPI
|
|
#define EXTERN_DDAPI WINAPI
|
|
#else
|
|
#define DDAPI __loadds WINAPI
|
|
#define EXTERN_DDAPI __export WINAPI
|
|
#endif
|
|
|
|
/*
|
|
* DCI escape
|
|
*/
|
|
#ifndef DCICOMMAND
|
|
#define DCICOMMAND 3075 // escape value
|
|
#endif
|
|
|
|
/*
|
|
* this is the DirectDraw version
|
|
* passed to the driver in DCICMD.dwVersion
|
|
*/
|
|
#define DD_VERSION 0x00000200l
|
|
|
|
/*
|
|
* this is the HAL version.
|
|
* the driver returns this number from QUERYESCSUPPORT/DCICOMMAND
|
|
*/
|
|
#define DD_HAL_VERSION 0x0100
|
|
//@@BEGIN_MSINTERNAL
|
|
#define DD_HAL_VERSION_EXTERNAL 0x0100
|
|
#undef DD_HAL_VERSION
|
|
#define DD_HAL_VERSION 0x00ff // special internal version
|
|
//@@END_MSINTERNAL
|
|
|
|
#ifndef _INC_DCIDDI
|
|
/*
|
|
* Used by DirectDraw to provide input parameters for the DCICOMMAND escape
|
|
* This matches the structure in the obsolete DCI 1.0
|
|
*/
|
|
typedef struct _DCICMD
|
|
{
|
|
DWORD dwCommand; // command
|
|
DWORD dwParam1;
|
|
DWORD dwParam2;
|
|
DWORD dwVersion; // DirectDraw version
|
|
DWORD dwReserved;
|
|
} DCICMD;
|
|
|
|
typedef DCICMD FAR *LPDCICMD;
|
|
#endif
|
|
|
|
#define DDCREATEDRIVEROBJECT 10 // create an object
|
|
#define DDGET32BITDRIVERNAME 11 // get a 32-bit driver name
|
|
#define DDNEWCALLBACKFNS 12 // new callback fns coming
|
|
|
|
typedef struct
|
|
{
|
|
char szName[260]; // 32-bit driver name
|
|
char szEntryPoint[64]; // entry point
|
|
DWORD dwContext; // context to pass to entry point
|
|
} DD32BITDRIVERDATA, FAR *LPDD32BITDRIVERDATA;
|
|
|
|
typedef DWORD (FAR PASCAL *LPDD32BITDRIVERINIT)(DWORD dwContext);
|
|
|
|
/*
|
|
* pointer to video meory
|
|
*/
|
|
typedef unsigned long FLATPTR;
|
|
|
|
/*
|
|
* indicates that DDRAW.DLL has been unloaded...
|
|
*/
|
|
#define DDRAW_DLL_UNLOADED (LPVOID) 1
|
|
|
|
/*
|
|
* critical section types
|
|
*/
|
|
typedef LPVOID CSECT_HANDLE;
|
|
#ifdef NOUSE_CRITSECTS
|
|
typedef xxx CSECT; // generate an error for now
|
|
#else
|
|
#if defined( IS_32 ) && !defined( _NOCSECT_TYPE )
|
|
typedef CRITICAL_SECTION CSECT;
|
|
typedef CSECT *LPCSECT;
|
|
#else
|
|
typedef struct
|
|
{
|
|
DWORD vals[6];
|
|
} CSECT;
|
|
typedef void FAR *LPCSECT;
|
|
#endif
|
|
#endif
|
|
|
|
/*
|
|
* DLL names
|
|
*/
|
|
#define DDHAL_DRIVER_DLLNAME "DDRAW16.DLL"
|
|
#define DDHAL_APP_DLLNAME "DDRAW.DLL"
|
|
|
|
/*
|
|
* maximum size of a driver name
|
|
*/
|
|
#define MAX_DRIVER_NAME 12
|
|
|
|
/*
|
|
* largest palette supported
|
|
*/
|
|
#define MAX_PALETTE_SIZE 256
|
|
|
|
/*
|
|
* pre-declare pointers to structs containing data for DDHAL fns
|
|
*/
|
|
typedef struct _DDHAL_CREATEPALETTEDATA FAR *LPDDHAL_CREATEPALETTEDATA;
|
|
typedef struct _DDHAL_CREATESURFACEDATA FAR *LPDDHAL_CREATESURFACEDATA;
|
|
typedef struct _DDHAL_CANCREATESURFACEDATA FAR *LPDDHAL_CANCREATESURFACEDATA;
|
|
typedef struct _DDHAL_WAITFORVERTICALBLANKDATA FAR *LPDDHAL_WAITFORVERTICALBLANKDATA;
|
|
typedef struct _DDHAL_DESTROYDRIVERDATA FAR *LPDDHAL_DESTROYDRIVERDATA;
|
|
typedef struct _DDHAL_SETMODEDATA FAR *LPDDHAL_SETMODEDATA;
|
|
typedef struct _DDHAL_DRVSETCOLORKEYDATA FAR *LPDDHAL_DRVSETCOLORKEYDATA;
|
|
typedef struct _DDHAL_GETSCANLINEDATA FAR *LPDDHAL_GETSCANLINEDATA;
|
|
|
|
typedef struct _DDHAL_DESTROYPALETTEDATA FAR *LPDDHAL_DESTROYPALETTEDATA;
|
|
typedef struct _DDHAL_SETENTRIESDATA FAR *LPDDHAL_SETENTRIESDATA;
|
|
|
|
typedef struct _DDHAL_BLTDATA FAR *LPDDHAL_BLTDATA;
|
|
typedef struct _DDHAL_LOCKDATA FAR *LPDDHAL_LOCKDATA;
|
|
typedef struct _DDHAL_UNLOCKDATA FAR *LPDDHAL_UNLOCKDATA;
|
|
typedef struct _DDHAL_UPDATEOVERLAYDATA FAR *LPDDHAL_UPDATEOVERLAYDATA;
|
|
typedef struct _DDHAL_SETOVERLAYPOSITIONDATA FAR *LPDDHAL_SETOVERLAYPOSITIONDATA;
|
|
typedef struct _DDHAL_SETPALETTEDATA FAR *LPDDHAL_SETPALETTEDATA;
|
|
typedef struct _DDHAL_FLIPDATA FAR *LPDDHAL_FLIPDATA;
|
|
typedef struct _DDHAL_DESTROYSURFACEDATA FAR *LPDDHAL_DESTROYSURFACEDATA;
|
|
typedef struct _DDHAL_SETCLIPLISTDATA FAR *LPDDHAL_SETCLIPLISTDATA;
|
|
typedef struct _DDHAL_ADDATTACHEDSURFACEDATA FAR *LPDDHAL_ADDATTACHEDSURFACEDATA;
|
|
typedef struct _DDHAL_SETCOLORKEYDATA FAR *LPDDHAL_SETCOLORKEYDATA;
|
|
typedef struct _DDHAL_GETBLTSTATUSDATA FAR *LPDDHAL_GETBLTSTATUSDATA;
|
|
typedef struct _DDHAL_GETFLIPSTATUSDATA FAR *LPDDHAL_GETFLIPSTATUSDATA;
|
|
typedef struct _DDHAL_SETEXCLUSIVEMODEDATA FAR *LPDDHAL_SETEXCLUSIVEMODEDATA;
|
|
typedef struct _DDHAL_FLIPTOGDISURFACEDATA FAR *LPDDHAL_FLIPTOGDISURFACEDATA;
|
|
|
|
/*
|
|
* value in the fpVidMem; indicates dwBlockSize is valid (surface object)
|
|
*/
|
|
#define DDHAL_PLEASEALLOC_BLOCKSIZE 0x00000002l
|
|
|
|
/*
|
|
* video memory data structures (passed in DDHALINFO)
|
|
*/
|
|
typedef struct _VIDMEM
|
|
{
|
|
DWORD dwFlags; // flags
|
|
FLATPTR fpStart; // start of memory chunk
|
|
union
|
|
{
|
|
FLATPTR fpEnd; // end of memory chunk
|
|
DWORD dwWidth; // width of chunk (rectanglar memory)
|
|
};
|
|
DDSCAPS ddsCaps; // what this memory CANNOT be used for
|
|
DDSCAPS ddsCapsAlt; // what this memory CANNOT be used for if it must
|
|
union
|
|
{
|
|
LPVMEMHEAP lpHeap; // heap pointer, used by DDRAW
|
|
DWORD dwHeight; // height of chunk (rectanguler memory)
|
|
};
|
|
} VIDMEM;
|
|
typedef VIDMEM FAR *LPVIDMEM;
|
|
|
|
/*
|
|
* flags for vidmem struct
|
|
*/
|
|
#define VIDMEM_ISLINEAR 0x00000001l
|
|
#define VIDMEM_ISRECTANGULAR 0x00000002l
|
|
#define VIDMEM_ISHEAP 0x00000004l
|
|
|
|
typedef struct _VIDMEMINFO
|
|
{
|
|
FLATPTR fpPrimary; // pointer to primary surface
|
|
DWORD dwFlags; // flags
|
|
DWORD dwDisplayWidth; // current display width
|
|
DWORD dwDisplayHeight; // current display height
|
|
LONG lDisplayPitch; // current display pitch
|
|
DDPIXELFORMAT ddpfDisplay; // pixel format of display
|
|
DWORD dwOffscreenAlign; // byte alignment for offscreen surfaces
|
|
DWORD dwOverlayAlign; // byte alignment for overlays
|
|
DWORD dwTextureAlign; // byte alignment for textures
|
|
DWORD dwZBufferAlign; // byte alignment for z buffers
|
|
DWORD dwAlphaAlign; // byte alignment for alpha
|
|
DWORD dwNumHeaps; // number of memory heaps in vmList
|
|
LPVIDMEM pvmList; // array of heaps
|
|
} VIDMEMINFO;
|
|
typedef VIDMEMINFO FAR *LPVIDMEMINFO;
|
|
|
|
/*
|
|
* These structures contain the entry points in the display driver that
|
|
* DDRAW will call. Entries that the display driver does not care about
|
|
* should be NULL. Passed to DDRAW in DDHALINFO.
|
|
*/
|
|
typedef struct _DDRAWI_DIRECTDRAW_INT FAR *LPDDRAWI_DIRECTDRAW_INT;
|
|
typedef struct _DDRAWI_DIRECTDRAW_LCL FAR *LPDDRAWI_DIRECTDRAW_LCL;
|
|
typedef struct _DDRAWI_DIRECTDRAW_GBL FAR *LPDDRAWI_DIRECTDRAW_GBL;
|
|
typedef struct _DDRAWI_DDRAWSURFACE_GBL FAR *LPDDRAWI_DDRAWSURFACE_GBL;
|
|
typedef struct _DDRAWI_DDRAWPALETTE_GBL FAR *LPDDRAWI_DDRAWPALETTE_GBL;
|
|
typedef struct _DDRAWI_DDRAWPALETTE_INT FAR *LPDDRAWI_DDRAWPALETTE_INT;
|
|
typedef struct _DDRAWI_DDRAWCLIPPER_INT FAR *LPDDRAWI_DDRAWCLIPPER_INT;
|
|
typedef struct _DDRAWI_DDRAWCLIPPER_GBL FAR *LPDDRAWI_DDRAWCLIPPER_GBL;
|
|
typedef struct _DDRAWI_DDRAWSURFACE_MORE FAR *LPDDRAWI_DDRAWSURFACE_MORE;
|
|
typedef struct _DDRAWI_DDRAWSURFACE_LCL FAR *LPDDRAWI_DDRAWSURFACE_LCL;
|
|
typedef struct _DDRAWI_DDRAWSURFACE_INT FAR *LPDDRAWI_DDRAWSURFACE_INT;
|
|
//@@BEGIN_MSINTERNAL
|
|
#ifdef STREAMING
|
|
typedef struct _DDRAWI_DIRECTDRAWSURFACESTREAMING FAR *LPDDRAWI_DDRAWSURFACE_GBLSTREAMING;
|
|
#endif
|
|
//@@END_MSINTERNAL
|
|
typedef struct _DDRAWI_DDRAWPALETTE_LCL FAR *LPDDRAWI_DDRAWPALETTE_LCL;
|
|
typedef struct _DDRAWI_DDRAWCLIPPER_LCL FAR *LPDDRAWI_DDRAWCLIPPER_LCL;
|
|
|
|
//@@BEGIN_MSINTERNAL
|
|
#ifdef CLIPPER_NOTIFY
|
|
/*
|
|
* WINWATCH structure
|
|
*/
|
|
typedef struct _WINWATCH
|
|
{
|
|
LPDDRAWI_DDRAWCLIPPER_LCL lpDDClipper;
|
|
|
|
struct _WINWATCH FAR *next; // next
|
|
struct _WINWATCH FAR *next16; // next (16-bit)
|
|
|
|
struct _WINWATCH FAR *self32; // self ptr
|
|
struct _WINWATCH FAR *self16; // self ptr (16-bit)
|
|
|
|
DWORD hWnd; // window handle
|
|
|
|
LPCLIPPERCALLBACK lpCallback; // callback to call
|
|
LPVOID lpContext; // context for callback
|
|
WORD fNotify; // need notify
|
|
|
|
WORD fDirty; // changed
|
|
DWORD dwRDSize; // size of rgn data
|
|
/*
|
|
* STUFF AFTER THIS ONLY FOR 16-BIT SIDE, SIZES ARE DIFFERENT
|
|
*/
|
|
RECT rect; // intersection rect
|
|
RGNDATA NEAR *prd16; // 16-bit pointer to region data
|
|
|
|
} WINWATCH, FAR *LPWINWATCH;
|
|
#endif
|
|
//@@END_MSINTERNAL
|
|
|
|
/*
|
|
* List of IUnknowns aggregated by a DirectDraw surface.
|
|
*/
|
|
typedef struct _IUNKNOWN_LIST
|
|
{
|
|
struct _IUNKNOWN_LIST FAR *lpLink;
|
|
GUID FAR *lpGuid;
|
|
IUnknown FAR *lpIUnknown;
|
|
} IUNKNOWN_LIST;
|
|
typedef IUNKNOWN_LIST FAR *LPIUNKNOWN_LIST;
|
|
|
|
/*
|
|
* hardware emulation layer stuff
|
|
*/
|
|
typedef BOOL (FAR PASCAL *LPDDHEL_INIT)(LPDDRAWI_DIRECTDRAW_GBL,BOOL);
|
|
|
|
/*
|
|
* DIRECTDRAW object callbacks
|
|
*/
|
|
typedef DWORD (FAR PASCAL *LPDDHAL_SETCOLORKEY)(LPDDHAL_DRVSETCOLORKEYDATA );
|
|
typedef DWORD (FAR PASCAL *LPDDHAL_CANCREATESURFACE)(LPDDHAL_CANCREATESURFACEDATA );
|
|
typedef DWORD (FAR PASCAL *LPDDHAL_WAITFORVERTICALBLANK)(LPDDHAL_WAITFORVERTICALBLANKDATA );
|
|
typedef DWORD (FAR PASCAL *LPDDHAL_CREATESURFACE)(LPDDHAL_CREATESURFACEDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHAL_DESTROYDRIVER)(LPDDHAL_DESTROYDRIVERDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHAL_SETMODE)(LPDDHAL_SETMODEDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHAL_CREATEPALETTE)(LPDDHAL_CREATEPALETTEDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHAL_GETSCANLINE)(LPDDHAL_GETSCANLINEDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHAL_SETEXCLUSIVEMODE)(LPDDHAL_SETEXCLUSIVEMODEDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHAL_FLIPTOGDISURFACE)(LPDDHAL_FLIPTOGDISURFACEDATA);
|
|
|
|
typedef struct _DDHAL_DDCALLBACKS
|
|
{
|
|
DWORD dwSize;
|
|
DWORD dwFlags;
|
|
LPDDHAL_DESTROYDRIVER DestroyDriver;
|
|
LPDDHAL_CREATESURFACE CreateSurface;
|
|
LPDDHAL_SETCOLORKEY SetColorKey;
|
|
LPDDHAL_SETMODE SetMode;
|
|
LPDDHAL_WAITFORVERTICALBLANK WaitForVerticalBlank;
|
|
LPDDHAL_CANCREATESURFACE CanCreateSurface;
|
|
LPDDHAL_CREATEPALETTE CreatePalette;
|
|
LPDDHAL_GETSCANLINE GetScanLine;
|
|
LPDDHAL_SETEXCLUSIVEMODE SetExclusiveMode;
|
|
LPDDHAL_FLIPTOGDISURFACE FlipToGDISurface;
|
|
} DDHAL_DDCALLBACKS;
|
|
|
|
typedef DDHAL_DDCALLBACKS FAR *LPDDHAL_DDCALLBACKS;
|
|
|
|
#define DDHAL_CB32_DESTROYDRIVER 0x00000001l
|
|
#define DDHAL_CB32_CREATESURFACE 0x00000002l
|
|
#define DDHAL_CB32_SETCOLORKEY 0x00000004l
|
|
#define DDHAL_CB32_SETMODE 0x00000008l
|
|
#define DDHAL_CB32_WAITFORVERTICALBLANK 0x00000010l
|
|
#define DDHAL_CB32_CANCREATESURFACE 0x00000020l
|
|
#define DDHAL_CB32_CREATEPALETTE 0x00000040l
|
|
#define DDHAL_CB32_GETSCANLINE 0x00000080l
|
|
#define DDHAL_CB32_SETEXCLUSIVEMODE 0x00000100l
|
|
#define DDHAL_CB32_FLIPTOGDISURFACE 0x00000200l
|
|
|
|
/*
|
|
* DIRECTDRAWPALETTE object callbacks
|
|
*/
|
|
typedef DWORD (FAR PASCAL *LPDDHALPALCB_DESTROYPALETTE)(LPDDHAL_DESTROYPALETTEDATA );
|
|
typedef DWORD (FAR PASCAL *LPDDHALPALCB_SETENTRIES)(LPDDHAL_SETENTRIESDATA );
|
|
|
|
typedef struct _DDHAL_DDPALETTECALLBACKS
|
|
{
|
|
DWORD dwSize;
|
|
DWORD dwFlags;
|
|
LPDDHALPALCB_DESTROYPALETTE DestroyPalette;
|
|
LPDDHALPALCB_SETENTRIES SetEntries;
|
|
} DDHAL_DDPALETTECALLBACKS;
|
|
|
|
typedef DDHAL_DDPALETTECALLBACKS FAR *LPDDHAL_DDPALETTECALLBACKS;
|
|
|
|
#define DDHAL_PALCB32_DESTROYPALETTE 0x00000001l
|
|
#define DDHAL_PALCB32_SETENTRIES 0x00000002l
|
|
|
|
/*
|
|
* DIRECTDRAWSURFACE object callbacks
|
|
*/
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_LOCK)(LPDDHAL_LOCKDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_UNLOCK)(LPDDHAL_UNLOCKDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_BLT)(LPDDHAL_BLTDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_UPDATEOVERLAY)(LPDDHAL_UPDATEOVERLAYDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_SETOVERLAYPOSITION)(LPDDHAL_SETOVERLAYPOSITIONDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_SETPALETTE)(LPDDHAL_SETPALETTEDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_FLIP)(LPDDHAL_FLIPDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_DESTROYSURFACE)(LPDDHAL_DESTROYSURFACEDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_SETCLIPLIST)(LPDDHAL_SETCLIPLISTDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_ADDATTACHEDSURFACE)(LPDDHAL_ADDATTACHEDSURFACEDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_SETCOLORKEY)(LPDDHAL_SETCOLORKEYDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_GETBLTSTATUS)(LPDDHAL_GETBLTSTATUSDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALSURFCB_GETFLIPSTATUS)(LPDDHAL_GETFLIPSTATUSDATA);
|
|
|
|
|
|
typedef struct _DDHAL_DDSURFACECALLBACKS
|
|
{
|
|
DWORD dwSize;
|
|
DWORD dwFlags;
|
|
LPDDHALSURFCB_DESTROYSURFACE DestroySurface;
|
|
LPDDHALSURFCB_FLIP Flip;
|
|
LPDDHALSURFCB_SETCLIPLIST SetClipList;
|
|
LPDDHALSURFCB_LOCK Lock;
|
|
LPDDHALSURFCB_UNLOCK Unlock;
|
|
LPDDHALSURFCB_BLT Blt;
|
|
LPDDHALSURFCB_SETCOLORKEY SetColorKey;
|
|
LPDDHALSURFCB_ADDATTACHEDSURFACE AddAttachedSurface;
|
|
LPDDHALSURFCB_GETBLTSTATUS GetBltStatus;
|
|
LPDDHALSURFCB_GETFLIPSTATUS GetFlipStatus;
|
|
LPDDHALSURFCB_UPDATEOVERLAY UpdateOverlay;
|
|
LPDDHALSURFCB_SETOVERLAYPOSITION SetOverlayPosition;
|
|
LPVOID reserved4;
|
|
LPDDHALSURFCB_SETPALETTE SetPalette;
|
|
} DDHAL_DDSURFACECALLBACKS;
|
|
typedef DDHAL_DDSURFACECALLBACKS FAR *LPDDHAL_DDSURFACECALLBACKS;
|
|
|
|
#define DDHAL_SURFCB32_DESTROYSURFACE 0x00000001l
|
|
#define DDHAL_SURFCB32_FLIP 0x00000002l
|
|
#define DDHAL_SURFCB32_SETCLIPLIST 0x00000004l
|
|
#define DDHAL_SURFCB32_LOCK 0x00000008l
|
|
#define DDHAL_SURFCB32_UNLOCK 0x00000010l
|
|
#define DDHAL_SURFCB32_BLT 0x00000020l
|
|
#define DDHAL_SURFCB32_SETCOLORKEY 0x00000040l
|
|
#define DDHAL_SURFCB32_ADDATTACHEDSURFACE 0x00000080l
|
|
#define DDHAL_SURFCB32_GETBLTSTATUS 0x00000100l
|
|
#define DDHAL_SURFCB32_GETFLIPSTATUS 0x00000200l
|
|
#define DDHAL_SURFCB32_UPDATEOVERLAY 0x00000400l
|
|
#define DDHAL_SURFCB32_SETOVERLAYPOSITION 0x00000800l
|
|
#define DDHAL_SURFCB32_RESERVED4 0x00001000l
|
|
#define DDHAL_SURFCB32_SETPALETTE 0x00002000l
|
|
|
|
/*
|
|
* DIRECTDRAWEXEBUF pseudo object callbacks
|
|
*
|
|
* NOTE: Execute buffers are not a distinct object type, they piggy back off
|
|
* the surface data structures and high level API. However, they have their
|
|
* own HAL callbacks as they may have different driver semantics from "normal"
|
|
* surfaces. They also piggy back off the HAL data structures.
|
|
*
|
|
* !!! NOTE: Need to resolve whether we export execute buffer copying as a
|
|
* blit or some other from of copy instruction.
|
|
*/
|
|
typedef DWORD (FAR PASCAL *LPDDHALEXEBUFCB_CANCREATEEXEBUF)(LPDDHAL_CANCREATESURFACEDATA );
|
|
typedef DWORD (FAR PASCAL *LPDDHALEXEBUFCB_CREATEEXEBUF)(LPDDHAL_CREATESURFACEDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALEXEBUFCB_DESTROYEXEBUF)(LPDDHAL_DESTROYSURFACEDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALEXEBUFCB_LOCKEXEBUF)(LPDDHAL_LOCKDATA);
|
|
typedef DWORD (FAR PASCAL *LPDDHALEXEBUFCB_UNLOCKEXEBUF)(LPDDHAL_UNLOCKDATA);
|
|
|
|
typedef struct _DDHAL_DDEXEBUFCALLBACKS
|
|
{
|
|
DWORD dwSize;
|
|
DWORD dwFlags;
|
|
LPDDHALEXEBUFCB_CANCREATEEXEBUF CanCreateExecuteBuffer;
|
|
LPDDHALEXEBUFCB_CREATEEXEBUF CreateExecuteBuffer;
|
|
LPDDHALEXEBUFCB_DESTROYEXEBUF DestroyExecuteBuffer;
|
|
LPDDHALEXEBUFCB_LOCKEXEBUF LockExecuteBuffer;
|
|
LPDDHALEXEBUFCB_UNLOCKEXEBUF UnlockExecuteBuffer;
|
|
} DDHAL_DDEXEBUFCALLBACKS;
|
|
typedef DDHAL_DDEXEBUFCALLBACKS FAR *LPDDHAL_DDEXEBUFCALLBACKS;
|
|
|
|
#define DDHAL_EXEBUFCB32_CANCREATEEXEBUF 0x00000001l
|
|
#define DDHAL_EXEBUFCB32_CREATEEXEBUF 0x00000002l
|
|
#define DDHAL_EXEBUFCB32_DESTROYEXEBUF 0x00000004l
|
|
#define DDHAL_EXEBUFCB32_LOCKEXEBUF 0x00000008l
|
|
#define DDHAL_EXEBUFCB32_UNLOCKEXEBUF 0x00000010l
|
|
|
|
/*
|
|
* CALLBACK RETURN VALUES
|
|
* * these are values returned by the driver from the above callback routines
|
|
*/
|
|
/*
|
|
* indicates that the display driver didn't do anything with the call
|
|
*/
|
|
#define DDHAL_DRIVER_NOTHANDLED 0x00000000l
|
|
|
|
/*
|
|
* indicates that the display driver handled the call; HRESULT value is valid
|
|
*/
|
|
#define DDHAL_DRIVER_HANDLED 0x00000001l
|
|
|
|
/*
|
|
* indicates that the display driver couldn't handle the call because it
|
|
* ran out of color key hardware resources
|
|
*/
|
|
#define DDHAL_DRIVER_NOCKEYHW 0x00000002l
|
|
|
|
/*
|
|
* DDRAW palette interface struct
|
|
*/
|
|
typedef struct _DDRAWI_DDRAWPALETTE_INT
|
|
{
|
|
LPVOID lpVtbl; // pointer to array of interface methods
|
|
LPDDRAWI_DDRAWPALETTE_LCL lpLcl; // pointer to interface data
|
|
LPDDRAWI_DDRAWPALETTE_INT lpLink; // link to next interface
|
|
DWORD dwIntRefCnt; // interface reference count
|
|
} DDRAWI_DDRAWPALETTE_INT;
|
|
|
|
/*
|
|
* DDRAW internal version of DIRECTDRAWPALETTE object; it has data after the vtable
|
|
*/
|
|
typedef struct _DDRAWI_DDRAWPALETTE_GBL
|
|
{
|
|
DWORD dwRefCnt; // reference count
|
|
DWORD dwFlags; // flags
|
|
LPDDRAWI_DIRECTDRAW_LCL lpDD_lcl; // PRIVATE: DIRECTDRAW object
|
|
DWORD dwProcessId; // owning process
|
|
LPPALETTEENTRY lpColorTable; // array of palette entries
|
|
union
|
|
{
|
|
DWORD dwReserved1; // reserved for use by display driver
|
|
HPALETTE hHELGDIPalette;
|
|
};
|
|
} DDRAWI_DDRAWPALETTE_GBL;
|
|
|
|
/*
|
|
* (CMcC) The palette no longer maintains a back pointer to the owning surface
|
|
* (there may now be many owning surfaces). So the lpDDSurface is now dwReserved0
|
|
* (this mod. assumes that sizeof(DWORD) == sizeof(LPDDRAWI_DDRAWSURFACE_LCL). A
|
|
* fairly safe assumption I think.
|
|
*/
|
|
typedef struct _DDRAWI_DDRAWPALETTE_LCL
|
|
{
|
|
DWORD lpPalMore; // pointer to additional local data
|
|
LPDDRAWI_DDRAWPALETTE_GBL lpGbl; // pointer to data
|
|
DWORD dwUnused0; // not currently used.
|
|
DWORD dwLocalRefCnt; // local ref cnt
|
|
IUnknown FAR *pUnkOuter; // outer IUnknown
|
|
LPDDRAWI_DIRECTDRAW_LCL lpDD_lcl; // pointer to owning local driver object
|
|
DWORD dwReserved1; // reserved for use by display driver
|
|
} DDRAWI_DDRAWPALETTE_LCL;
|
|
|
|
#define DDRAWIPAL_256 0x00000001l // 256 entry palette
|
|
#define DDRAWIPAL_16 0x00000002l // 16 entry palette
|
|
#define DDRAWIPAL_GDI 0x00000004l // palette allocated through GDI
|
|
#define DDRAWIPAL_STORED_8 0x00000008l // palette stored as 8bpp/entry
|
|
#define DDRAWIPAL_STORED_16 0x00000010l // palette stored as 16bpp/entry
|
|
#define DDRAWIPAL_STORED_24 0x00000020l // palette stored as 24bpp/entry
|
|
#define DDRAWIPAL_EXCLUSIVE 0x00000040l // palette being used in exclusive mode
|
|
#define DDRAWIPAL_INHEL 0x00000080l // palette is done in the hel
|
|
#define DDRAWIPAL_DIRTY 0x00000100l // gdi palette out 'o sync
|
|
#define DDRAWIPAL_ALLOW256 0x00000200l // can fully update palette
|
|
#define DDRAWIPAL_4 0x00000400l // 4 entry palette
|
|
#define DDRAWIPAL_2 0x00000800l // 2 entry palette
|
|
#define DDRAWIPAL_STORED_8INDEX 0x00001000l // palatte stored as 8-bit index into dst palette
|
|
|
|
/*
|
|
* DDRAW clipper interface struct
|
|
*/
|
|
typedef struct _DDRAWI_DDRAWCLIPPER_INT
|
|
{
|
|
LPVOID lpVtbl; // pointer to array of interface methods
|
|
LPDDRAWI_DDRAWCLIPPER_LCL lpLcl; // pointer to interface data
|
|
LPDDRAWI_DDRAWCLIPPER_INT lpLink; // link to next interface
|
|
DWORD dwIntRefCnt; // interface reference count
|
|
} DDRAWI_DDRAWCLIPPER_INT;
|
|
|
|
/*
|
|
* DDRAW internal version of DIRECTDRAWCLIPPER object; it has data after the vtable
|
|
*/
|
|
typedef struct _DDRAWI_DDRAWCLIPPER_GBL
|
|
{
|
|
DWORD dwRefCnt; // reference count
|
|
DWORD dwFlags; // flags
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // PRIVATE: DIRECTDRAW object
|
|
DWORD dwProcessId; // owning process
|
|
DWORD dwReserved1; // reserved for use by display driver
|
|
DWORD hWnd; // window
|
|
LPRGNDATA lpStaticClipList; // clip list set by app
|
|
#ifdef CLIPPER_NOTIFY
|
|
LPWINWATCH lpWW; // window watch data
|
|
#endif
|
|
} DDRAWI_DDRAWCLIPPER_GBL;
|
|
|
|
/*
|
|
* (CMcC) As with palettes, the clipper no longer maintains a back pointer to the
|
|
* owning surface (there may now be many owning surfaces). So the lpDDSurface
|
|
* is now dwReserved0 (this mod. assumes that sizeof(DWORD) ==
|
|
* sizeof(LPDDRAWI_DDRAWSURFACE_LCL). A fairly safe assumption I think.
|
|
*/
|
|
typedef struct _DDRAWI_DDRAWCLIPPER_LCL
|
|
{
|
|
DWORD lpClipMore; // pointer to additional local data
|
|
LPDDRAWI_DDRAWCLIPPER_GBL lpGbl; // pointer to data
|
|
LPDDRAWI_DIRECTDRAW_LCL lpDD_lcl; // pointer to owning local DD object
|
|
DWORD dwLocalRefCnt; // local ref cnt
|
|
IUnknown FAR *pUnkOuter; // outer IUnknown
|
|
LPDDRAWI_DIRECTDRAW_INT lpDD_int; // pointer to owning DD object interface
|
|
DWORD dwReserved1; // reserved for use by display driver
|
|
} DDRAWI_DDRAWCLIPPER_LCL;
|
|
|
|
#define DDRAWICLIP_WATCHWINDOW 0x00000001l
|
|
#define DDRAWICLIP_ISINITIALIZED 0x00000002l
|
|
|
|
/*
|
|
* ATTACHLIST - internally used to maintain list of attached surfaces
|
|
*/
|
|
typedef struct _ATTACHLIST
|
|
{
|
|
DWORD dwFlags;
|
|
struct _ATTACHLIST FAR *lpLink; // link to next attached surface
|
|
struct _DDRAWI_DDRAWSURFACE_LCL FAR *lpAttached; // attached surface local obj
|
|
struct _DDRAWI_DDRAWSURFACE_INT FAR *lpIAttached; // attached surface interface
|
|
} ATTACHLIST;
|
|
typedef ATTACHLIST FAR *LPATTACHLIST;
|
|
#define DDAL_IMPLICIT 0x00000001l
|
|
|
|
/*
|
|
* DBLNODE - a node in a doubly-linked list of surface interfaces
|
|
*/
|
|
typedef struct _DBLNODE
|
|
{
|
|
struct _DBLNODE FAR *next; // link to next node
|
|
struct _DBLNODE FAR *prev; // link to previous node
|
|
LPDDRAWI_DDRAWSURFACE_LCL object; // link to object
|
|
LPDDRAWI_DDRAWSURFACE_INT object_int; // object interface
|
|
} DBLNODE;
|
|
typedef DBLNODE FAR *LPDBLNODE;
|
|
|
|
/*
|
|
* ACCESSRECTLIST - internally used to all rectangles that are accessed on a surface
|
|
*/
|
|
typedef struct _ACCESSRECTLIST
|
|
{
|
|
struct _ACCESSRECTLIST FAR *lpLink; // link to next attached surface
|
|
RECT rDest; // rectangle being used
|
|
LPDDRAWI_DIRECTDRAW_LCL lpOwner; // owning local object
|
|
LPVOID lpSurfaceData; // associated screen ptr
|
|
} ACCESSRECTLIST;
|
|
typedef ACCESSRECTLIST FAR *LPACCESSRECTLIST;
|
|
|
|
/*
|
|
* DDRAW surface interface struct
|
|
*/
|
|
typedef struct _DDRAWI_DDRAWSURFACE_INT
|
|
{
|
|
LPVOID lpVtbl; // pointer to array of interface methods
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpLcl; // pointer to interface data
|
|
LPDDRAWI_DDRAWSURFACE_INT lpLink; // link to next interface
|
|
DWORD dwIntRefCnt; // interface reference count
|
|
} DDRAWI_DDRAWSURFACE_INT;
|
|
|
|
/*
|
|
* DDRAW internal version of DIRECTDRAWSURFACE struct
|
|
*
|
|
* the GBL structure is global data for all duplicate objects
|
|
*/
|
|
typedef struct _DDRAWI_DDRAWSURFACE_GBL
|
|
{
|
|
DWORD dwRefCnt; // reference count
|
|
DWORD dwGlobalFlags; // global flags
|
|
union
|
|
{
|
|
LPACCESSRECTLIST lpRectList; // list of accesses
|
|
DWORD dwBlockSizeY; // block size that display driver requested (return)
|
|
};
|
|
union
|
|
{
|
|
LPVMEMHEAP lpVidMemHeap; // heap vidmem was alloc'ed from
|
|
DWORD dwBlockSizeX; // block size that display driver requested (return)
|
|
};
|
|
union
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // internal DIRECTDRAW object
|
|
LPVOID lpDDHandle; // handle to internal DIRECTDRAW object
|
|
// for use by display driver
|
|
// when calling fns in DDRAW16.DLL
|
|
};
|
|
FLATPTR fpVidMem; // pointer to video memory
|
|
union
|
|
{
|
|
LONG lPitch; // pitch of surface
|
|
DWORD dwLinearSize; // linear size of non-rectangular surface
|
|
};
|
|
WORD wHeight; // height of surface
|
|
WORD wWidth; // width of surface
|
|
DWORD dwUsageCount; // number of access to this surface
|
|
DWORD dwReserved1; // reserved for use by display driver
|
|
//
|
|
// NOTE: this part of the structure is ONLY allocated if the pixel
|
|
// format differs from that of the primary display
|
|
//
|
|
DDPIXELFORMAT ddpfSurface; // pixel format of surface
|
|
|
|
} DDRAWI_DDRAWSURFACE_GBL;
|
|
|
|
/*
|
|
* a structure holding additional LCL surface information (can't simply be appended
|
|
* to the LCL structure as that structure is of variable size).
|
|
*/
|
|
typedef struct _DDRAWI_DDRAWSURFACE_MORE
|
|
{
|
|
DWORD dwSize;
|
|
IUNKNOWN_LIST FAR *lpIUnknowns; // IUnknowns aggregated by this surface
|
|
LPDDRAWI_DIRECTDRAW_LCL lpDD_lcl; // Pointer to the DirectDraw local object
|
|
DWORD dwPageLockCount; // count of pagelocks
|
|
DWORD dwBytesAllocated; // size of sys mem allocated
|
|
LPDDRAWI_DIRECTDRAW_INT lpDD_int; // Pointer to the DirectDraw interface
|
|
DWORD dwMipMapCount; // Number of mip-map levels in the chain
|
|
LPDDRAWI_DDRAWCLIPPER_INT lpDDIClipper; // Interface to attached clipper object
|
|
} DDRAWI_DDRAWSURFACE_MORE;
|
|
|
|
/*
|
|
* the LCL structure is local data for each individual surface object
|
|
*/
|
|
struct _DDRAWI_DDRAWSURFACE_LCL
|
|
{
|
|
LPDDRAWI_DDRAWSURFACE_MORE lpSurfMore; // pointer to additional local data
|
|
LPDDRAWI_DDRAWSURFACE_GBL lpGbl; // pointer to surface shared data
|
|
DWORD hDDSurface; // NT Kernel-mode handle was dwUnused0
|
|
LPATTACHLIST lpAttachList; // link to surfaces we attached to
|
|
LPATTACHLIST lpAttachListFrom;// link to surfaces that attached to this one
|
|
DWORD dwLocalRefCnt; // object refcnt
|
|
DWORD dwProcessId; // owning process
|
|
DWORD dwFlags; // flags
|
|
DDSCAPS ddsCaps; // capabilities of surface
|
|
union
|
|
{
|
|
LPDDRAWI_DDRAWPALETTE_INT lpDDPalette; // associated palette
|
|
LPDDRAWI_DDRAWPALETTE_INT lp16DDPalette; // 16-bit ptr to associated palette
|
|
};
|
|
union
|
|
{
|
|
LPDDRAWI_DDRAWCLIPPER_LCL lpDDClipper; // associated clipper
|
|
LPDDRAWI_DDRAWCLIPPER_INT lp16DDClipper; // 16-bit ptr to associated clipper
|
|
};
|
|
DWORD dwModeCreatedIn;
|
|
DWORD dwBackBufferCount; // number of back buffers created
|
|
DDCOLORKEY ddckCKDestBlt; // color key for destination blt use
|
|
DDCOLORKEY ddckCKSrcBlt; // color key for source blt use
|
|
// IUnknown FAR *pUnkOuter; // outer IUnknown
|
|
DWORD hDC; // owned dc
|
|
DWORD dwReserved1; // reserved for use by display driver
|
|
|
|
/*
|
|
* NOTE: this part of the structure is ONLY allocated if the surface
|
|
* can be used for overlays. ddckCKSrcOverlay MUST NOT BE MOVED
|
|
* from the start of this area.
|
|
*/
|
|
DDCOLORKEY ddckCKSrcOverlay;// color key for source overlay use
|
|
DDCOLORKEY ddckCKDestOverlay;// color key for destination overlay use
|
|
LPDDRAWI_DDRAWSURFACE_INT lpSurfaceOverlaying; // surface we are overlaying
|
|
DBLNODE dbnOverlayNode;
|
|
/*
|
|
* overlay rectangle, used by DDHEL
|
|
*/
|
|
RECT rcOverlaySrc;
|
|
RECT rcOverlayDest;
|
|
/*
|
|
* the below values are kept here for ddhel. they're set by UpdateOverlay,
|
|
* they're used whenever the overlays are redrawn.
|
|
*/
|
|
DWORD dwClrXparent; // the *actual* color key (override, colorkey, or CLR_INVALID)
|
|
DWORD dwAlpha; // the per surface alpha
|
|
/*
|
|
* overlay position
|
|
*/
|
|
LONG lOverlayX; // current x position
|
|
LONG lOverlayY; // current y position
|
|
};
|
|
typedef struct _DDRAWI_DDRAWSURFACE_LCL DDRAWI_DDRAWSURFACE_LCL;
|
|
|
|
//@@BEGIN_MSINTERNAL
|
|
#ifdef STREAMING
|
|
struct _DDRAWI_DIRECTDRAWSURFACESTREAMING
|
|
{
|
|
LPVOID lpVtbl; // pointer to array of callback fns
|
|
LPDDRAWI_DDRAWSURFACE_GBL lpGbl; // pointer to surface data
|
|
DWORD dwLocalRefCnt; // object refcnt
|
|
DWORD dwProcessId; // owning process
|
|
LPSURFACESTREAMINGCALLBACK lpCallback; // callback
|
|
};
|
|
typedef struct _DDRAWI_DIRECTDRAWSURFACESTREAMING DDRAWI_DIRECTDRAWSURFACESTREAMING;
|
|
#endif
|
|
//@@END_MSINTERNAL
|
|
|
|
#define DDRAWISURFGBL_MEMFREE 0x00000001L // video memory has been freed
|
|
#define DDRAWISURFGBL_SYSMEMREQUESTED 0x00000002L // surface is in system memory at request of user
|
|
#define DDRAWISURFGBL_ISGDISURFACE 0x00000004L // This surface represents what GDI thinks is front buffer
|
|
/*
|
|
* NOTE: This flag was previously DDRAWISURFGBL_INVALID. This flags has been retired
|
|
* and replaced by DDRAWISURF_INVALID in the local object.
|
|
*/
|
|
#define DDRAWISURFGBL_RESERVED0 0x80000000L // Reserved flag
|
|
|
|
#define DDRAWISURF_ATTACHED 0x00000001L // surface is attached to another
|
|
#define DDRAWISURF_IMPLICITCREATE 0x00000002L // surface implicitly created
|
|
#define DDRAWISURF_ISFREE 0x00000004L // surface already freed (temp flag)
|
|
#define DDRAWISURF_ATTACHED_FROM 0x00000008L // surface has others attached to it
|
|
#define DDRAWISURF_IMPLICITROOT 0x00000010L // surface root of implicit creation
|
|
#define DDRAWISURF_PARTOFPRIMARYCHAIN 0x00000020L // surface is part of primary chain
|
|
#define DDRAWISURF_DATAISALIASED 0x00000040L // used for thunking
|
|
#define DDRAWISURF_HASDC 0x00000080L // has a DC
|
|
#define DDRAWISURF_HASCKEYDESTOVERLAY 0x00000100L // surface has CKDestOverlay
|
|
#define DDRAWISURF_HASCKEYDESTBLT 0x00000200L // surface has CKDestBlt
|
|
#define DDRAWISURF_HASCKEYSRCOVERLAY 0x00000400L // surface has CKSrcOverlay
|
|
#define DDRAWISURF_HASCKEYSRCBLT 0x00000800L // surface has CKSrcBlt
|
|
#define DDRAWISURF_LOCKEXCLUDEDCURSOR 0x00001000L // surface was locked and excluded cursor
|
|
#define DDRAWISURF_HASPIXELFORMAT 0x00002000L // surface structure has pixel format data
|
|
#define DDRAWISURF_HASOVERLAYDATA 0x00004000L // surface structure has overlay data
|
|
#define DDRAWISURF_xxxxxxxxxxx5 0x00008000L // spare bit
|
|
#define DDRAWISURF_SW_CKEYDESTOVERLAY 0x00010000L // surface expects to process colorkey in software
|
|
#define DDRAWISURF_SW_CKEYDESTBLT 0x00020000L // surface expects to process colorkey in software
|
|
#define DDRAWISURF_SW_CKEYSRCOVERLAY 0x00040000L // surface expects to process colorkey in software
|
|
#define DDRAWISURF_SW_CKEYSRCBLT 0x00080000L // surface expects to process colorkey in software
|
|
#define DDRAWISURF_HW_CKEYDESTOVERLAY 0x00100000L // surface expects to process colorkey in hardware
|
|
#define DDRAWISURF_HW_CKEYDESTBLT 0x00200000L // surface expects to process colorkey in hardware
|
|
#define DDRAWISURF_HW_CKEYSRCOVERLAY 0x00400000L // surface expects to process colorkey in hardware
|
|
#define DDRAWISURF_HW_CKEYSRCBLT 0x00800000L // surface expects to process colorkey in hardware
|
|
#define DDRAWISURF_xxxxxxxxxxx6 0x01000000L // spare bit
|
|
#define DDRAWISURF_HELCB 0x02000000L // surface is the ddhel cb. must call hel for lock/blt.
|
|
#define DDRAWISURF_FRONTBUFFER 0x04000000L // surface was originally a front buffer
|
|
#define DDRAWISURF_BACKBUFFER 0x08000000L // surface was originally backbuffer
|
|
#define DDRAWISURF_INVALID 0x10000000L // surface has been invalidated by mode set
|
|
#define DDRAWISURF_DCIBUSY 0x20000000L // HEL has turned off BUSY so DCI would work
|
|
#define DDRAWISURF_GETDCNULL 0x40000000L // getdc could not lock and so returned GetDC(NULL)
|
|
|
|
|
|
/*
|
|
* rop stuff
|
|
*/
|
|
#define ROP_HAS_SOURCE 0x00000001l
|
|
#define ROP_HAS_PATTERN 0x00000002l
|
|
#define ROP_HAS_SOURCEPATTERN ROP_HAS_SOURCE | ROP_HAS_PATTERN
|
|
|
|
/*
|
|
* mode information
|
|
*/
|
|
typedef struct _DDHALMODEINFO
|
|
{
|
|
DWORD dwWidth; // width (in pixels) of mode
|
|
DWORD dwHeight; // height (in pixels) of mode
|
|
LONG lPitch; // pitch (in bytes) of mode
|
|
DWORD dwBPP; // bits per pixel
|
|
WORD wFlags; // flags
|
|
WORD wRefreshRate; // refresh rate
|
|
DWORD dwRBitMask; // red bit mask
|
|
DWORD dwGBitMask; // green bit mask
|
|
DWORD dwBBitMask; // blue bit mask
|
|
DWORD dwAlphaBitMask; // alpha bit mask
|
|
} DDHALMODEINFO;
|
|
typedef DDHALMODEINFO FAR *LPDDHALMODEINFO;
|
|
|
|
#define DDMODEINFO_PALETTIZED 0x0001 // mode is palettized
|
|
#define DDMODEINFO_MODEX 0x0002 // mode is a modex mode
|
|
#define DDMODEINFO_UNSUPPORTED 0x0004 // mode is not supported by driver
|
|
|
|
//@@BEGIN_MSINTERNAL
|
|
#define DDMODEINFO_VALID 0x0003 // valid
|
|
//@@END_MSINTERNAL
|
|
|
|
/*
|
|
* DDRAW interface struct
|
|
*/
|
|
typedef struct _DDRAWI_DIRECTDRAW_INT
|
|
{
|
|
LPVOID lpVtbl; // pointer to array of interface methods
|
|
LPDDRAWI_DIRECTDRAW_LCL lpLcl; // pointer to interface data
|
|
LPDDRAWI_DIRECTDRAW_INT lpLink; // link to next interface
|
|
DWORD dwIntRefCnt; // interface reference count
|
|
} DDRAWI_DIRECTDRAW_INT;
|
|
|
|
/*
|
|
* DDRAW version of DirectDraw object; it has data after the vtable
|
|
*
|
|
* all entries marked as PRIVATE are not for use by the display driver
|
|
*/
|
|
typedef struct _DDHAL_CALLBACKS
|
|
{
|
|
DDHAL_DDCALLBACKS cbDDCallbacks; // addresses in display driver for DIRECTDRAW object HAL
|
|
DDHAL_DDSURFACECALLBACKS cbDDSurfaceCallbacks; // addresses in display driver for DIRECTDRAWSURFACE object HAL
|
|
DDHAL_DDPALETTECALLBACKS cbDDPaletteCallbacks; // addresses in display driver for DIRECTDRAWPALETTE object HAL
|
|
DDHAL_DDCALLBACKS HALDD; // HAL for DIRECTDRAW object
|
|
DDHAL_DDSURFACECALLBACKS HALDDSurface; // HAL for DIRECTDRAWSURFACE object
|
|
DDHAL_DDPALETTECALLBACKS HALDDPalette; // HAL for DIRECTDRAWPALETTE object
|
|
DDHAL_DDCALLBACKS HELDD; // HEL for DIRECTDRAW object
|
|
DDHAL_DDSURFACECALLBACKS HELDDSurface; // HEL for DIRECTDRAWSURFACE object
|
|
DDHAL_DDPALETTECALLBACKS HELDDPalette; // HEL for DIRECTDRAWPALETTE object
|
|
DDHAL_DDEXEBUFCALLBACKS cbDDExeBufCallbacks; // addresses in display driver for DIRECTDRAWEXEBUF pseudo object HAL
|
|
DDHAL_DDEXEBUFCALLBACKS HALDDExeBuf; // HAL for DIRECTDRAWEXEBUF pseudo object
|
|
DDHAL_DDEXEBUFCALLBACKS HELDDExeBuf; // HEL for DIRECTDRAWEXEBUF preudo object
|
|
} DDHAL_CALLBACKS, far *LPDDHAL_CALLBACKS;
|
|
|
|
|
|
typedef struct _DDRAWI_DIRECTDRAW_GBL
|
|
{
|
|
DWORD dwRefCnt; // reference count
|
|
DWORD dwFlags; // flags
|
|
FLATPTR fpPrimaryOrig; // primary surf vid mem. ptr
|
|
DDCAPS ddCaps; // driver caps
|
|
DWORD dwUnused1[10]; // not currently used
|
|
LPDDHAL_CALLBACKS lpDDCBtmp; // HAL callbacks
|
|
LPDDRAWI_DDRAWSURFACE_INT dsList; // PRIVATE: list of all surfaces
|
|
LPDDRAWI_DDRAWPALETTE_INT palList; // PRIVATE: list of all palettes
|
|
LPDDRAWI_DDRAWCLIPPER_INT clipperList; // PRIVATE: list of all clippers
|
|
LPDDRAWI_DIRECTDRAW_GBL lp16DD; // PRIVATE: 16-bit ptr to this struct
|
|
DWORD dwMaxOverlays; // maximum number of overlays
|
|
DWORD dwCurrOverlays; // current number of visible overlays
|
|
DWORD dwMonitorFrequency; // monitor frequency in current mode
|
|
DDCAPS ddHELCaps; // HEL capabilities
|
|
DWORD dwUnused2[50]; // not currently used
|
|
DDCOLORKEY ddckCKDestOverlay; // color key for destination overlay use
|
|
DDCOLORKEY ddckCKSrcOverlay; // color key for source overlay use
|
|
VIDMEMINFO vmiData; // info about vid memory
|
|
LPVOID lpDriverHandle; // handle for use by display driver
|
|
// to call fns in DDRAW16.DLL
|
|
LPDDRAWI_DIRECTDRAW_LCL lpExclusiveOwner; // PRIVATE: exclusive local object
|
|
DWORD dwModeIndex; // current mode index
|
|
DWORD dwModeIndexOrig;// original mode index
|
|
DWORD dwNumFourCC; // number of fourcc codes supported
|
|
DWORD FAR *lpdwFourCC;// PRIVATE: fourcc codes supported
|
|
DWORD dwNumModes; // number of modes supported
|
|
LPDDHALMODEINFO lpModeInfo; // PRIVATE: mode information
|
|
PROCESS_LIST plProcessList; // PRIVATE: list of processes using driver
|
|
DWORD dwSurfaceLockCount; // total number of outstanding locks
|
|
DWORD dwFree1; // PRIVATE: was system color table
|
|
DWORD dwFree2; // PRIVATE: was original palette
|
|
DWORD hDD; // PRIVATE: NT Kernel-mode handle (was dwFree3).
|
|
char cDriverName[MAX_DRIVER_NAME]; // Driver Name
|
|
DWORD dwReserved1; // reserved for use by display driver
|
|
DWORD dwReserved2; // reserved for use by display driver
|
|
DBLNODE dbnOverlayRoot; // The root node of the doubly-
|
|
// linked list of overlay z orders.
|
|
volatile LPWORD lpwPDeviceFlags;// driver physical device flags
|
|
DWORD dwPDevice; // driver physical device (16:16 pointer)
|
|
DWORD dwWin16LockCnt; // count on win16 holds
|
|
LPDDRAWI_DIRECTDRAW_LCL lpWin16LockOwner; // object owning Win16 Lock
|
|
DWORD hInstance; // instance handle of driver
|
|
DWORD dwEvent16; // 16-bit event
|
|
DWORD dwSaveNumModes; // saved number of modes supported
|
|
/* Version 2 fields */
|
|
DWORD lpD3DGlobalDriverData; // Global D3D Data
|
|
DWORD lpD3DHALCallbacks; // D3D HAL Callbacks
|
|
DDCAPS ddBothCaps; // logical AND of driver and HEL caps
|
|
} DDRAWI_DIRECTDRAW_GBL;
|
|
|
|
typedef struct _DDRAWI_DIRECTDRAW_LCL
|
|
{
|
|
DWORD lpDDMore; // pointer to additional local data
|
|
LPDDRAWI_DIRECTDRAW_GBL lpGbl; // pointer to data
|
|
DWORD dwUnused0; // not currently used
|
|
DWORD dwLocalFlags; // local flags (DDRAWILCL_)
|
|
DWORD dwLocalRefCnt; // local ref cnt
|
|
DWORD dwProcessId; // owning process id
|
|
IUnknown FAR *pUnkOuter; // outer IUnknown
|
|
DWORD dwObsolete1;
|
|
DWORD hWnd;
|
|
DWORD hDC;
|
|
DWORD dwErrorMode;
|
|
LPDDRAWI_DDRAWSURFACE_INT lpPrimary;
|
|
LPDDRAWI_DDRAWSURFACE_INT lpCB;
|
|
DWORD dwPreferredMode;
|
|
//------- Fields added in Version 2.0 -------
|
|
HINSTANCE hD3DInstance; // Handle of Direct3D's DLL.
|
|
IUnknown FAR *pD3DIUnknown; // Direct3D's aggregated IUnknown.
|
|
LPDDHAL_CALLBACKS lpDDCB; // HAL callbacks
|
|
#ifdef SHAREDZ
|
|
LPDDRAWI_DDRAWSURFACE_INT lpSharedZ; // Shared z-buffer (if any).
|
|
LPDDRAWI_DDRAWSURFACE_INT lpSharedBack; // Shared back-buffer (if any).
|
|
#endif
|
|
DWORD hDSVxd; // handle to dsound.vxd
|
|
} DDRAWI_DIRECTDRAW_LCL;
|
|
|
|
#define DDRAWILCL_HASEXCLUSIVEMODE 0x00000001l
|
|
#define DDRAWILCL_ISFULLSCREEN 0x00000002l
|
|
#define DDRAWILCL_SETCOOPCALLED 0x00000004l
|
|
#define DDRAWILCL_ACTIVEYES 0x00000008l
|
|
#define DDRAWILCL_ACTIVENO 0x00000010l
|
|
#define DDRAWILCL_HOOKEDHWND 0x00000020l
|
|
#define DDRAWILCL_ALLOWMODEX 0x00000040l
|
|
#define DDRAWILCL_V1SCLBEHAVIOUR 0x00000080l
|
|
#define DDRAWILCL_MODEHASBEENCHANGED 0x00000100l
|
|
|
|
#define DDRAWI_xxxxxxxxx1 0x00000001l // unused
|
|
#define DDRAWI_xxxxxxxxx2 0x00000002l // unused
|
|
#define DDRAWI_xxxxxxxxx3 0x00000004l // unused
|
|
#define DDRAWI_xxxxxxxxx4 0x00000008l // unused
|
|
#define DDRAWI_MODEX 0x00000010l // driver is using modex
|
|
#define DDRAWI_DISPLAYDRV 0x00000020l // driver is display driver
|
|
#define DDRAWI_FULLSCREEN 0x00000040l // driver in fullscreen mode
|
|
#define DDRAWI_MODECHANGED 0x00000080l // display mode has been changed
|
|
#define DDRAWI_NOHARDWARE 0x00000100l // no driver hardware at all
|
|
#define DDRAWI_PALETTEINIT 0x00000200l // GDI palette stuff has been initalized
|
|
#define DDRAWI_NOEMULATION 0x00000400l // no emulation at all
|
|
#define DDRAWI_HASCKEYDESTOVERLAY 0x00000800l // driver has CKDestOverlay
|
|
#define DDRAWI_HASCKEYSRCOVERLAY 0x00001000l // driver has CKSrcOverlay
|
|
#define DDRAWI_HASGDIPALETTE 0x00002000l // GDI palette exists on primary surface
|
|
#define DDRAWI_EMULATIONINITIALIZED 0x00004000l // emulation is initialized
|
|
#define DDRAWI_HASGDIPALETTE_EXCLUSIVE 0x00008000l // exclusive mode palette
|
|
#define DDRAWI_MODEXILLEGAL 0x00010000l // modex is not supported by this hardware
|
|
#define DDRAWI_FLIPPEDTOGDI 0x00020000l // driver has been flipped to show GDI surface
|
|
|
|
//@@BEGIN_MSINTERNAL
|
|
/*
|
|
* The following structure is equivalent to the DDHALINFO structure defined in DirectDraw 1.0.
|
|
* It is used by DirectDraw internally to interpret the DDHALINFO information passed from drivers written
|
|
* prior to DirectDraw 2.0. New applications and drivers should use the DDHALINFO structure defined after
|
|
* this one. DirectDraw distinguishes between the structures via the dwSize field.
|
|
*/
|
|
typedef struct _DDHALINFO_V1
|
|
{
|
|
DWORD dwSize;
|
|
LPDDHAL_DDCALLBACKS lpDDCallbacks; // direct draw object callbacks
|
|
LPDDHAL_DDSURFACECALLBACKS lpDDSurfaceCallbacks; // surface object callbacks
|
|
LPDDHAL_DDPALETTECALLBACKS lpDDPaletteCallbacks; // palette object callbacks
|
|
VIDMEMINFO vmiData; // video memory info
|
|
DDCAPS_V1 ddCaps; // hw specific caps
|
|
DWORD dwMonitorFrequency; // monitor frequency in current mode
|
|
DWORD hWndListBox; // list box for debug output
|
|
DWORD dwModeIndex; // current mode: index into array
|
|
LPDWORD lpdwFourCC; // fourcc codes supported
|
|
DWORD dwNumModes; // number of modes supported
|
|
LPDDHALMODEINFO lpModeInfo; // mode information
|
|
DWORD dwFlags; // create flags
|
|
LPVOID lpPDevice; // physical device ptr
|
|
DWORD hInstance; // instance handle of driver
|
|
} DDHALINFO_V1;
|
|
typedef DDHALINFO_V1 FAR *LPDDHALINFO_V1;
|
|
#define DDHALINFOSIZE_V1 sizeof( DDHALINFO_V1)
|
|
|
|
/*
|
|
* CAUTION: Size of the interm DDHALSTRUCTURE (post V1.0 pre V2.0)
|
|
* Here temporarily only. Added (03/02/96). Should be removed by
|
|
* (03/07/96). If not come and get me. colinmc
|
|
*/
|
|
#define DDHALINFOSIZE_VINTERIM \
|
|
(DDHALINFOSIZE_V1 + \
|
|
(sizeof(DWORD) * 2UL) + \
|
|
(sizeof(LPDDHAL_DDEXEBUFCALLBACKS)))
|
|
|
|
//@@END_MSINTERNAL
|
|
/*
|
|
* structure for display driver to call DDHAL_Create with
|
|
*/
|
|
typedef struct _DDHALINFO
|
|
{
|
|
DWORD dwSize;
|
|
LPDDHAL_DDCALLBACKS lpDDCallbacks; // direct draw object callbacks
|
|
LPDDHAL_DDSURFACECALLBACKS lpDDSurfaceCallbacks; // surface object callbacks
|
|
LPDDHAL_DDPALETTECALLBACKS lpDDPaletteCallbacks; // palette object callbacks
|
|
VIDMEMINFO vmiData; // video memory info
|
|
DDCAPS ddCaps; // hw specific caps
|
|
DWORD dwMonitorFrequency; // monitor frequency in current mode
|
|
DWORD hWndListBox; // list box for debug output
|
|
DWORD dwModeIndex; // current mode: index into array
|
|
LPDWORD lpdwFourCC; // fourcc codes supported
|
|
DWORD dwNumModes; // number of modes supported
|
|
LPDDHALMODEINFO lpModeInfo; // mode information
|
|
DWORD dwFlags; // create flags
|
|
LPVOID lpPDevice; // physical device ptr
|
|
DWORD hInstance; // instance handle of driver
|
|
//------- Fields added in Version 2.0 -------
|
|
DWORD lpD3DGlobalDriverData; // D3D global Data
|
|
DWORD lpD3DHALCallbacks; // D3D callbacks
|
|
LPDDHAL_DDEXEBUFCALLBACKS lpDDExeBufCallbacks; // Execute buffer pseudo object callbacks
|
|
} DDHALINFO;
|
|
typedef DDHALINFO FAR *LPDDHALINFO;
|
|
#define DDHALINFOSIZE_V2 sizeof( DDHALINFO )
|
|
|
|
#define DDHALINFO_ISPRIMARYDISPLAY 0x00000001l // indicates driver is primary display driver
|
|
#define DDHALINFO_MODEXILLEGAL 0x00000002l // indicates this hardware does not support modex modes
|
|
|
|
/*
|
|
* DDRAW16.DLL entry points
|
|
*/
|
|
typedef BOOL (DDAPI *LPDDHAL_SETINFO)( LPDDHALINFO lpDDHalInfo, BOOL reset );
|
|
typedef FLATPTR (DDAPI *LPDDHAL_VIDMEMALLOC)( LPDDRAWI_DIRECTDRAW_GBL lpDD, int heap, DWORD dwWidth, DWORD dwHeight );
|
|
typedef void (DDAPI *LPDDHAL_VIDMEMFREE)( LPDDRAWI_DIRECTDRAW_GBL lpDD, int heap, FLATPTR fpMem );
|
|
|
|
extern BOOL DDAPI DDHAL_SetInfo( LPDDHALINFO lpDDHALInfo, BOOL reset );
|
|
extern FLATPTR DDAPI DDHAL_VidMemAlloc( LPDDRAWI_DIRECTDRAW_GBL lpDD, int heap, DWORD dwWidth, DWORD dwHeight );
|
|
extern void DDAPI DDHAL_VidMemFree( LPDDRAWI_DIRECTDRAW_GBL lpDD, int heap, FLATPTR fpMem );
|
|
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwSize;
|
|
LPDDHAL_SETINFO lpSetInfo;
|
|
LPDDHAL_VIDMEMALLOC lpVidMemAlloc;
|
|
LPDDHAL_VIDMEMFREE lpVidMemFree;
|
|
} DDHALDDRAWFNS;
|
|
typedef DDHALDDRAWFNS FAR *LPDDHALDDRAWFNS;
|
|
|
|
/****************************************************************************
|
|
*
|
|
* DDHAL structures for Surface Object callbacks
|
|
*
|
|
***************************************************************************/
|
|
|
|
/*
|
|
* structure for passing information to DDHAL Blt fn
|
|
*/
|
|
typedef struct _DDHAL_BLTDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDDestSurface;// dest surface
|
|
RECTL rDest; // dest rect
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSrcSurface; // src surface
|
|
RECTL rSrc; // src rect
|
|
DWORD dwFlags; // blt flags
|
|
DWORD dwROPFlags; // ROP flags (valid for ROPS only)
|
|
DDBLTFX bltFX; // blt FX
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_BLT Blt; // PRIVATE: ptr to callback
|
|
BOOL IsClipped; // clipped blt?
|
|
RECTL rOrigDest; // unclipped dest rect
|
|
// (only valid if IsClipped)
|
|
RECTL rOrigSrc; // unclipped src rect
|
|
// (only valid if IsClipped)
|
|
DWORD dwRectCnt; // count of dest rects
|
|
// (only valid if IsClipped)
|
|
LPRECT prDestRects; // array of dest rects
|
|
// (only valid if IsClipped)
|
|
} DDHAL_BLTDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL Lock fn
|
|
*/
|
|
typedef struct _DDHAL_LOCKDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
|
|
DWORD bHasRect; // rArea is valid
|
|
RECTL rArea; // area being locked
|
|
LPVOID lpSurfData; // pointer to screen memory (return value)
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_LOCK Lock; // PRIVATE: ptr to callback
|
|
DWORD dwFlags; // DDLOCK flags
|
|
} DDHAL_LOCKDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL Unlock fn
|
|
*/
|
|
typedef struct _DDHAL_UNLOCKDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_UNLOCK Unlock; // PRIVATE: ptr to callback
|
|
} DDHAL_UNLOCKDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL UpdateOverlay fn
|
|
*/
|
|
typedef struct _DDHAL_UPDATEOVERLAYDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDDestSurface;// dest surface
|
|
RECTL rDest; // dest rect
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSrcSurface; // src surface
|
|
RECTL rSrc; // src rect
|
|
DWORD dwFlags; // flags
|
|
DDOVERLAYFX overlayFX; // overlay FX
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_UPDATEOVERLAY UpdateOverlay; // PRIVATE: ptr to callback
|
|
} DDHAL_UPDATEOVERLAYDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL UpdateOverlay fn
|
|
*/
|
|
typedef struct _DDHAL_SETOVERLAYPOSITIONDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSrcSurface; // src surface
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDDestSurface;// dest surface
|
|
LONG lXPos; // x position
|
|
LONG lYPos; // y position
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_SETOVERLAYPOSITION SetOverlayPosition; // PRIVATE: ptr to callback
|
|
} DDHAL_SETOVERLAYPOSITIONDATA;
|
|
/*
|
|
* structure for passing information to DDHAL SetPalette fn
|
|
*/
|
|
typedef struct _DDHAL_SETPALETTEDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
|
|
LPDDRAWI_DDRAWPALETTE_GBL lpDDPalette; // palette to set to surface
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_SETPALETTE SetPalette; // PRIVATE: ptr to callback
|
|
BOOL Attach; // attach this palette?
|
|
} DDHAL_SETPALETTEDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL Flip fn
|
|
*/
|
|
typedef struct _DDHAL_FLIPDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpSurfCurr; // current surface
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpSurfTarg; // target surface (to flip to)
|
|
DWORD dwFlags; // flags
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_FLIP Flip; // PRIVATE: ptr to callback
|
|
} DDHAL_FLIPDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL DestroySurface fn
|
|
*/
|
|
typedef struct _DDHAL_DESTROYSURFACEDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_DESTROYSURFACE DestroySurface;// PRIVATE: ptr to callback
|
|
} DDHAL_DESTROYSURFACEDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL SetClipList fn
|
|
*/
|
|
typedef struct _DDHAL_SETCLIPLISTDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_SETCLIPLIST SetClipList; // PRIVATE: ptr to callback
|
|
} DDHAL_SETCLIPLISTDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL AddAttachedSurface fn
|
|
*/
|
|
typedef struct _DDHAL_ADDATTACHEDSURFACEDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpSurfAttached; // surface to attach
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_ADDATTACHEDSURFACE AddAttachedSurface; // PRIVATE: ptr to callback
|
|
} DDHAL_ADDATTACHEDSURFACEDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL SetColorKey fn
|
|
*/
|
|
typedef struct _DDHAL_SETCOLORKEYDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
|
|
DWORD dwFlags; // flags
|
|
DDCOLORKEY ckNew; // new color key
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_SETCOLORKEY SetColorKey; // PRIVATE: ptr to callback
|
|
} DDHAL_SETCOLORKEYDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL GetBltStatus fn
|
|
*/
|
|
typedef struct _DDHAL_GETBLTSTATUSDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
|
|
DWORD dwFlags; // flags
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_GETBLTSTATUS GetBltStatus; // PRIVATE: ptr to callback
|
|
} DDHAL_GETBLTSTATUSDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL GetFlipStatus fn
|
|
*/
|
|
typedef struct _DDHAL_GETFLIPSTATUSDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
|
|
DWORD dwFlags; // flags
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALSURFCB_GETFLIPSTATUS GetFlipStatus; // PRIVATE: ptr to callback
|
|
} DDHAL_GETFLIPSTATUSDATA;
|
|
|
|
/****************************************************************************
|
|
*
|
|
* DDHAL structures for Palette Object callbacks
|
|
*
|
|
***************************************************************************/
|
|
|
|
/*
|
|
* structure for passing information to DDHAL DestroyPalette fn
|
|
*/
|
|
typedef struct _DDHAL_DESTROYPALETTEDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWPALETTE_GBL lpDDPalette; // palette struct
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALPALCB_DESTROYPALETTE DestroyPalette; // PRIVATE: ptr to callback
|
|
} DDHAL_DESTROYPALETTEDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL SetEntries fn
|
|
*/
|
|
typedef struct _DDHAL_SETENTRIESDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWPALETTE_GBL lpDDPalette; // palette struct
|
|
DWORD dwBase; // base palette index
|
|
DWORD dwNumEntries; // number of palette entries
|
|
LPPALETTEENTRY lpEntries; // color table
|
|
HRESULT ddRVal; // return value
|
|
LPDDHALPALCB_SETENTRIES SetEntries; // PRIVATE: ptr to callback
|
|
} DDHAL_SETENTRIESDATA;
|
|
|
|
/****************************************************************************
|
|
*
|
|
* DDHAL structures for Driver Object callbacks
|
|
*
|
|
***************************************************************************/
|
|
|
|
/*
|
|
* structure for passing information to DDHAL CreateSurface fn
|
|
*/
|
|
typedef struct _DDHAL_CREATESURFACEDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDSURFACEDESC lpDDSurfaceDesc;// description of surface being created
|
|
LPDDRAWI_DDRAWSURFACE_LCL FAR *lplpSList; // list of created surface objects
|
|
DWORD dwSCnt; // number of surfaces in SList
|
|
HRESULT ddRVal; // return value
|
|
LPDDHAL_CREATESURFACE CreateSurface; // PRIVATE: ptr to callback
|
|
} DDHAL_CREATESURFACEDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL CanCreateSurface fn
|
|
*/
|
|
typedef struct _DDHAL_CANCREATESURFACEDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDSURFACEDESC lpDDSurfaceDesc; // description of surface being created
|
|
DWORD bIsDifferentPixelFormat;// pixel format differs from primary surface
|
|
HRESULT ddRVal; // return value
|
|
LPDDHAL_CANCREATESURFACE CanCreateSurface; // PRIVATE: ptr to callback
|
|
} DDHAL_CANCREATESURFACEDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL CreatePalette fn
|
|
*/
|
|
typedef struct _DDHAL_CREATEPALETTEDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
LPDDRAWI_DDRAWPALETTE_GBL lpDDPalette; // ddraw palette struct
|
|
LPPALETTEENTRY lpColorTable; // colors to go in palette
|
|
HRESULT ddRVal; // return value
|
|
LPDDHAL_CREATEPALETTE CreatePalette; // PRIVATE: ptr to callback
|
|
BOOL is_excl; // process has exclusive mode
|
|
} DDHAL_CREATEPALETTEDATA;
|
|
|
|
/*
|
|
* Return if the vertical blank is in progress
|
|
*/
|
|
#define DDWAITVB_I_TESTVB 0x80000006l
|
|
|
|
/*
|
|
* structure for passing information to DDHAL WaitForVerticalBlank fn
|
|
*/
|
|
typedef struct _DDHAL_WAITFORVERTICALBLANKDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
DWORD dwFlags; // flags
|
|
DWORD bIsInVB; // is in vertical blank
|
|
DWORD hEvent; // event
|
|
HRESULT ddRVal; // return value
|
|
LPDDHAL_WAITFORVERTICALBLANK WaitForVerticalBlank; // PRIVATE: ptr to callback
|
|
} DDHAL_WAITFORVERTICALBLANKDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL DestroyDriver fn
|
|
*/
|
|
typedef struct _DDHAL_DESTROYDRIVERDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
HRESULT ddRVal; // return value
|
|
LPDDHAL_DESTROYDRIVER DestroyDriver; // PRIVATE: ptr to callback
|
|
} DDHAL_DESTROYDRIVERDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL SetMode fn
|
|
*/
|
|
typedef struct _DDHAL_SETMODEDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
DWORD dwModeIndex; // new mode
|
|
HRESULT ddRVal; // return value
|
|
LPDDHAL_SETMODE SetMode; // PRIVATE: ptr to callback
|
|
BOOL inexcl; // in exclusive mode
|
|
BOOL useRefreshRate; // use the refresh rate data in the mode info
|
|
} DDHAL_SETMODEDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL driver SetColorKey fn
|
|
*/
|
|
typedef struct _DDHAL_DRVSETCOLORKEYDATA
|
|
{
|
|
LPDDRAWI_DDRAWSURFACE_LCL lpDDSurface; // surface struct
|
|
DWORD dwFlags; // flags
|
|
DDCOLORKEY ckNew; // new color key
|
|
HRESULT ddRVal; // return value
|
|
LPDDHAL_SETCOLORKEY SetColorKey; // PRIVATE: ptr to callback
|
|
} DDHAL_DRVSETCOLORKEYDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL GetScanLine fn
|
|
*/
|
|
typedef struct _DDHAL_GETSCANLINEDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
DWORD dwScanLine; // returned scan line
|
|
HRESULT ddRVal; // return value
|
|
LPDDHAL_GETSCANLINE GetScanLine; // PRIVATE: ptr to callback
|
|
} DDHAL_GETSCANLINEDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL SetExclusiveMode fn
|
|
*/
|
|
typedef struct _DDHAL_SETEXCLUSIVEMODEDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
DWORD dwEnterExcl; // TRUE if entering exclusive mode, FALSE is leaving
|
|
DWORD dwReserved; // reserved for future use
|
|
HRESULT ddRVal; // return value
|
|
LPDDHAL_SETEXCLUSIVEMODE SetExclusiveMode; // PRIVATE: ptr to callback
|
|
} DDHAL_SETEXCLUSIVEMODEDATA;
|
|
|
|
/*
|
|
* structure for passing information to DDHAL FlipToGDISurface fn
|
|
*/
|
|
typedef struct _DDHAL_FLIPTOGDISURFACEDATA
|
|
{
|
|
LPDDRAWI_DIRECTDRAW_GBL lpDD; // driver struct
|
|
DWORD dwToGDI; // TRUE if flipping to the GDI surface, FALSE if flipping away
|
|
DWORD dwReserved; // reserved for future use
|
|
HRESULT ddRVal; // return value
|
|
LPDDHAL_FLIPTOGDISURFACE FlipToGDISurface; // PRIVATE: ptr to callback
|
|
} DDHAL_FLIPTOGDISURFACEDATA;
|
|
|
|
#ifdef __cplusplus
|
|
};
|
|
#endif
|
|
|
|
#endif
|