BOOL DbgPaint(
SURFOBJ* pso,
CLIPOBJ* pco,
BRUSHOBJ* pbo,
POINTL* pptlBrushOrg,
MIX mix)
{
BOOL u;
if (gbNull)
return(TRUE);
SYNCH_ENTER();
DISPDBG((5, "DrvPaint"));
u = DrvPaint(
pso,
pco,
pbo,
pptlBrushOrg,
mix);
DISPDBG((6, "DrvPaint done"));
SYNCH_LEAVE();
return(u);
}
BOOL DbgSetPalette(
DHPDEV dhpdev,
PALOBJ* ppalo,
FLONG fl,
ULONG iStart,
ULONG cColors)
{
BOOL u;
if (gbNull)
return(TRUE);
SYNCH_ENTER();
DISPDBG((5, "DrvSetPalette"));
u = DrvSetPalette(
dhpdev,
ppalo,
fl,
iStart,
cColors);
DISPDBG((6, "DrvSetPalette done"));
SYNCH_LEAVE();
return(u);
}
BOOL DbgRealizeBrush(
BRUSHOBJ* pbo,
SURFOBJ* psoTarget,
SURFOBJ* psoPattern,
SURFOBJ* psoMask,
XLATEOBJ* pxlo,
ULONG iHatch)
{
BOOL u;
// Note: The only time DrvRealizeBrush is called by GDI is when we've
// called BRUSHOBJ_pvGetRbrush in the middle of a DrvBitBlt
// call, and GDI had to call us back. Since we're still in the
// middle of DrvBitBlt, synchronization has already taken care of.
// For the same reason, this will never be called when 'gbNull'
// is TRUE, so it doesn't even make sense to check gbNull...
DISPDBG((5, "DrvRealizeBrush"));
u = DrvRealizeBrush(
pbo,
psoTarget,
psoPattern,
psoMask,
pxlo,
iHatch);
DISPDBG((6, "DrvRealizeBrush done"));
return(u);
}
BOOL DbgStrokePath(
SURFOBJ* pso,
PATHOBJ* ppo,
CLIPOBJ* pco,
XFORMOBJ* pxo,
BRUSHOBJ* pbo,
POINTL* pptlBrushOrg,
LINEATTRS* plineattrs,
MIX mix)
{
BOOL u;
if (gbNull)
return(TRUE);
SYNCH_ENTER();
DISPDBG((5, "DrvStrokePath"));
u = DrvStrokePath(
pso,
ppo,
pco,
pxo,
pbo,
pptlBrushOrg,
plineattrs,
mix);
DISPDBG((6, "DrvStrokePath done"));
SYNCH_LEAVE();
return(u);
}
VOID DrvDisablePDEV(DHPDEV dhpdev)
{
PPDEV ppdev;
ppdev = (PPDEV) dhpdev;
DISPDBG((2, "disabling PDEV\n"));
EngDeletePalette(devinfoVGA.hpalDefault);
// Free the preallocated saved screen bits buffer, if there is one.
if (ppdev->pjPreallocSSBBuffer != NULL)
{
EngFreeMem(ppdev->pjPreallocSSBBuffer);
}
// Free the conversion table buffer
if (ppdev->pucDIB4ToVGAConvBuffer != NULL)
{
EngFreeMem(ppdev->pucDIB4ToVGAConvBuffer);
}
// Delete the PDEV
EngFreeMem(dhpdev);
DISPDBG((2, "disabled PDEV\n"));
}
BOOL DbgCopyBits(
SURFOBJ* psoDst,
SURFOBJ* psoSrc,
CLIPOBJ* pco,
XLATEOBJ* pxlo,
RECTL* prclDst,
POINTL* pptlSrc)
{
BOOL u;
if (gbNull)
return(TRUE);
SYNCH_ENTER();
DISPDBG((5, "DrvCopyBits"));
u = DrvCopyBits(
psoDst,
psoSrc,
pco,
pxlo,
prclDst,
pptlSrc);
DISPDBG((6, "DrvCopyBits done"));
SYNCH_LEAVE();
return(u);
}
BOOL DbgFillPath(
SURFOBJ* pso,
PATHOBJ* ppo,
CLIPOBJ* pco,
BRUSHOBJ* pbo,
POINTL* pptlBrushOrg,
MIX mix,
FLONG flOptions)
{
BOOL u;
if (gbNull)
return(TRUE);
SYNCH_ENTER();
DISPDBG((5, "DrvFillPath"));
u = DrvFillPath(pso,
ppo,
pco,
pbo,
pptlBrushOrg,
mix,
flOptions);
DISPDBG((6, "DrvFillPath done"));
SYNCH_LEAVE();
return(u);
}
ULONG DbgDitherColor(
DHPDEV dhpdev,
ULONG iMode,
ULONG rgb,
ULONG* pul)
{
ULONG u;
if (gbNull)
return(DCR_DRIVER);
//
// No need to Synchronize Dither color.
//
DISPDBG((5, "DrvDitherColor"));
u = DrvDitherColor(
dhpdev,
iMode,
rgb,
pul);
DISPDBG((6, "DrvDitherColor done"));
return(u);
}
void dprec_reg_op(void* cmdq, unsigned int reg, unsigned int val, unsigned int mask)
{
int len = 0;
if(!cmdq && !in_interrupt())
MMProfileLogEx(ddp_mmp_get_events()->dprec_cpu_write_reg, MMProfileFlagPulse, reg, val);
if(cmdq)
{
if(mask)
{
DISPPR_HWOP("%s/0x%08x/0x%08x=0x%08x&0x%08x\n", _find_module_by_reg_addr(reg), (unsigned int)cmdq, reg, val ,mask);
}
else
{
DISPPR_HWOP("%s/0x%08x/0x%08x=0x%08x\n", _find_module_by_reg_addr(reg), (unsigned int)cmdq, reg, val);
}
}
else
{
if(!in_interrupt())
{
if(mask)
{
DISPDBG("%s/%08x=%08x&%08x\n", _find_module_by_reg_addr(reg), reg, val ,mask);
}
else
{
DISPDBG("%s/%08x=%08x\n", _find_module_by_reg_addr(reg), reg, val);
}
}
}
if(_control.overall_switch == 0)
{
return;
}
len += scnprintf(dprec_string_buffer+len, dprec_string_max_length - len, "[DPREC]");
len += scnprintf(dprec_string_buffer+len, dprec_string_max_length - len, "[%s]", _find_module_by_reg_addr(reg));
len += scnprintf(dprec_string_buffer+len, dprec_string_max_length - len, "[%s]", cmdq?"CMDQ":"CPU");
if(cmdq)
len += scnprintf(dprec_string_buffer+len, dprec_string_max_length - len, "[0x%08x]", cmdq);
len += scnprintf(dprec_string_buffer+len, dprec_string_max_length - len, "0x%08x=0x%08x", reg, val);
if(mask)
len += scnprintf(dprec_string_buffer+len, dprec_string_max_length - len, "&0x%08x", mask);
len += scnprintf(dprec_string_buffer+len, dprec_string_max_length - len, "\n");
printk(dprec_string_buffer);
if(_control.cmm_dump)
{
printk("[CMM]D.S SD:0x%08x %\LE %\LONG 0x%08x; write %s\n", (_control.cmm_dump_use_va)?reg:(reg&0x1fffffff), mask?(val|mask):val,_find_module_by_reg_addr(reg));
}
VOID DbgDeleteDeviceBitmap(DHSURF dhsurf)
{
SYNCH_ENTER();
DISPDBG((5, "DrvDeleteDeviceBitmap"));
DrvDeleteDeviceBitmap(dhsurf);
DISPDBG((6, "DrvDeleteDeviceBitmap done"));
SYNCH_LEAVE();
}
VOID DbgDisablePDEV(DHPDEV dhpdev)
{
SYNCH_ENTER();
DISPDBG((5, "DrvDisable"));
DrvDisablePDEV(dhpdev);
DISPDBG((6, "DrvDisable done"));
SYNCH_LEAVE();
}
// LoadOpenGL
// Attempts to load the OpenGL driver. If successful, call DescribePixelFormat
// routine in driver.
//
// Synopsis:
// BOOL LoadOpenGL(
// PPDEV ppdev)
static
BOOL LoadOpenGL (PPDEV ppdev)
{
return 0; // !!! Disable for now in Kernel Mode
#if 0
ENABLE_OPENGL enable_opengl;
char *file_name = "tgaglsrv.dll";
char lpszValue[256];
DWORD cchValue = 256;
if (cchValue = GetEnvironmentVariable("TGAGLSRVNAME", lpszValue, cchValue ))
file_name = lpszValue;
ppdev->hOpenGLDll = LoadLibrary (file_name);
if (! ppdev->hOpenGLDll)
{
DWORD lastError = EngGetLastError();
DISPDBG ((1, "TGA!load_extension - Error loading OpenGL Driver as %s - %d\n",
file_name, lastError));
return 0;
}
// Find the entry point DrvEnableEscape
enable_opengl = (ENABLE_OPENGL)GetProcAddress (ppdev->hOpenGLDll,
"DrvEnableEscape");
if (! enable_opengl)
{
DISPDBG ((0, "TGA!load_extension - Error getting address of DrvEnableEscape in OpenGL Driver %s - %d\n",
file_name, EngGetLastError()));
FreeLibrary (ppdev->hOpenGLDll);
ppdev->hOpenGLDll = NULL;
return 0;
}
// Call the OpenGL driver initialization routine
if (! enable_opengl (DDI_DRIVER_VERSION, (DHPDEV)ppdev))
{
DISPDBG ((0, "TGA!load_extension - Failure returned by DrvEnableEscape in library %s\n",
file_name));
FreeLibrary (ppdev->hOpenGLDll);
ppdev->hOpenGLDll = NULL;
return 0;
}
// We're loaded and ready to go
return 1;
#endif
}
VOID vBankStartBltDest(
PPDEV ppdev,
SURFOBJ* pso,
POINTL* pptlSrc,
RECTL* prclDest,
POINTL* pptlNewSrc,
RECTL* prclNewDest)
{
LONG iTopScan = max(0, prclDest->top);
DISPDBG((4, "vBankSTartBltDest: Entering.\n"));
if (iTopScan >= (LONG) ppdev->cyScreen)
{
// In some instances we may be asked to start on a scan below the screen.
// Since we obviously won't be drawing anything, don't bother mapping in
// a bank:
return;
}
// Map in the bank:
if (iTopScan < ppdev->rcl1WindowClip.top ||
iTopScan >= ppdev->rcl1WindowClip.bottom)
{
ppdev->pfnBankControl(ppdev, iTopScan, JustifyTop);
}
if (ppdev->rcl1WindowClip.right <= prclDest->left)
{
// We have to watch out for those rare cases where we're starting
// on a broken raster and we won't be drawing on the first part:
ASSERTVGA(ppdev->flBank & BANK_BROKEN_RASTER1, "Weird start bounds");
ppdev->pfnBankNext(ppdev);
}
pso->pvScan0 = ppdev->pvBitmapStart;
// Adjust the destination:
prclNewDest->left = prclDest->left;
prclNewDest->top = prclDest->top;
prclNewDest->bottom = min(ppdev->rcl1WindowClip.bottom, prclDest->bottom);
prclNewDest->right = min(ppdev->rcl1WindowClip.right, prclDest->right);
// Adjust the source if there is one:
if (pptlSrc != NULL)
*pptlNewSrc = *pptlSrc;
DISPDBG((4, "vBankStartBltDest: Leaving.\n"));
}
VOID DrvDisableSurface(DHPDEV dhpdev)
{
PPDEV ppdev = (PPDEV) dhpdev;
PDEVSURF pdsurf = ppdev->pdsurf;
PSAVED_SCREEN_BITS pSSB, pSSBNext;
DISPDBG((2, "disabling surface\n"));
// Free up banking-related stuff.
EngFreeMem(pdsurf->pBankSelectInfo);
if (pdsurf->pbiBankInfo != NULL) {
EngFreeMem(pdsurf->pbiBankInfo);
}
if (pdsurf->pbiBankInfo2RW != NULL) {
EngFreeMem(pdsurf->pbiBankInfo2RW);
}
if (pdsurf->pvBankBufferPlane0 != NULL) {
EngFreeMem(pdsurf->pvBankBufferPlane0);
}
if (ppdev->pPointerAttributes != NULL) {
EngFreeMem(ppdev->pPointerAttributes);
}
// Free any pending saved screen bit blocks.
pSSB = pdsurf->ssbList;
while (pSSB != (PSAVED_SCREEN_BITS) NULL) {
//
// Point to the next saved screen bits block
//
pSSBNext = (PSAVED_SCREEN_BITS) pSSB->pvNextSSB;
//
// Free the current block
//
EngFreeMem(pSSB);
pSSB = pSSBNext;
}
EngDeleteSurface((HSURF) ppdev->hsurfEng);
EngFreeMem(pdsurf); // free the surface
DISPDBG((2, "disabled surface\n"));
}
VOID DbgDestroyFont(FONTOBJ *pfo)
{
// Note: GDI synchronizes DrvDestroyFont only with other font calls.
// Calls such as DrvBitBlt may be going on at the same time
// as this call, but calls such as DrvTextOut are guaranteed
// not to happen at the same time.
DISPDBG((5, "DrvDestroyFont"));
DrvDestroyFont(pfo);
DISPDBG((6, "DrvDestroyFont done"));
}
VOID DbgMovePointer(SURFOBJ *pso,LONG x,LONG y,RECTL *prcl)
{
if (gbNull)
return;
SYNCH_ENTER();
DISPDBG((5, "DrvMovePointer"));
DrvMovePointer(pso,x,y,prcl);
DISPDBG((6, "DrvMovePointer done"));
SYNCH_LEAVE();
}
HSURF DbgEnableSurface(DHPDEV dhpdev)
{
HSURF h;
SYNCH_ENTER();
DISPDBG((5, "DrvEnableSurface"));
h = DrvEnableSurface(dhpdev);
DISPDBG((6, "DrvEnableSurface done"));
SYNCH_LEAVE();
return(h);
}
VOID DbgCompletePDEV(
DHPDEV dhpdev,
HDEV hdev)
{
SYNCH_ENTER();
DISPDBG((5, "DrvCompletePDEV"));
DrvCompletePDEV(
dhpdev,
hdev);
DISPDBG((6, "DrvCompletePDEV done"));
SYNCH_LEAVE();
}
bool IKeOpenALAudioDevice::CreateSoundBuffer( WAVEFORMATEX* wfx, IKeSoundBuffer** sound_buffer )
{
IKeOpenALSoundBuffer* sb;
ALenum error = alGetError();
/* Allocate a new sound buffer instance */
(*sound_buffer) = new IKeOpenALSoundBuffer;
sb = static_cast<IKeOpenALSoundBuffer*>( *sound_buffer );
/* Save audio format */
memmove( &sb->wfx, wfx, sizeof( WAVEFORMATEX ) );
/* Generate a sound buffer and source */
alGenBuffers( 1, &sb->buffer );
error = alGetError();
if( error != AL_NO_ERROR )
{
sb->Destroy();
DISPDBG( KE_ERROR, "Error creating buffer (0x" << error << ")!\n" );
return false;
}
alGenSources( 1, &sb->source );
error = alGetError();
if( error != AL_NO_ERROR )
{
sb->Destroy();
DISPDBG( KE_ERROR, "Error creating source (0x" << error << ")!\n" );
return false;
}
/* Default 3D sound position and velocity */
//memset( sb->position, 0, sizeof( float ) * 3 );
//memset( sb->velocity, 0, sizeof( float ) * 3 );
sb->position = nv::vec3f( 0.0f, 0.0f, 0.0f );
sb->velocity = nv::vec3f( 0.0f, 0.0f, 0.0f );
/* Set the sound source's default attributes */
sb->volume = 1.0f;
sb->pitch = 1.0f;
alSourcei( sb->source, AL_BUFFER, sb->buffer );
alSourcef( sb->source, AL_PITCH, sb->volume );
alSourcef( sb->source, AL_GAIN, sb->pitch );
alSourcefv( sb->source, AL_POSITION, sb->position._array );
alSourcefv( sb->source, AL_VELOCITY, sb->velocity._array );
alSourcei( sb->source, AL_LOOPING, 0 );
return true;
}
int extd_sw_mutex_lock(struct mutex*m)
{
///mutex_lock(m);
down_interruptible(&extd_mutex);
DISPDBG("mutex: lock\n");
return 0;
}
BOOL DbgAssertMode(
DHPDEV dhpdev,
BOOL bEnable)
{
BOOL b;
SYNCH_ENTER();
DISPDBG((5, "DrvAssertMode"));
b = DrvAssertMode(dhpdev,bEnable);
DISPDBG((6, "DrvAssertMode done"));
SYNCH_LEAVE();
return b;
}
int extd_mutex_init(struct mutex *m)
{
DISPDBG("mutex init:\n");
return 0;
mutex_init(m);
return 0;
}
int extd_sw_mutex_unlock(struct mutex*m)
{
///mutex_unlock(m);
up(&extd_mutex);
DISPDBG("mutex: unlock\n");
return 0;
}
int extd_mutex_trylock(struct mutex*m)
{
int ret = 0;
///ret = mutex_trylock(m);
DISPDBG("mutex: trylock\n");
return ret;
}
const char* KeGetSaveGameDirectory( const char* game_app_directory )
{
/* TODO: Implement */
DISPDBG( KE_WARNING, "Not yet implemented for UWP!" );
return "./";
}
/*
* Name: KeIsOnlyInstance
* Desc: Returns true if this is the only instance of the application running.
* NOTE: This is generally only relevant on desktop OSes.
*/
bool KeIsOnlyInstance( const char* title )
{
/* TODO: Implement */
DISPDBG( KE_WARNING, "Not yet implemented for UWP!" );
return true;
}
/*
* Name: KeGetDiskSpace
* Desc: Returns the amount of space free on the current disk drive.
*/
uint64_t KeGetDiskSpace()
{
/* TODO: Implement */
DISPDBG( KE_WARNING, "Not yet implemented for UWP!" );
return 0;
}
/*
* Name: KeGetCpuSpeed
* Desc: Returns this machine's current CPU speed.
*/
uint64_t KeGetCpuSpeed()
{
/* TODO: Implement */
DISPDBG( KE_WARNING, "Not yet implemented for UWP!" );
return 0;
}
/*****************************************************************************
* XGA Solid Pattern
*
* Returns TRUE if the blit was handled.
****************************************************************************/
BOOL bSolidPattern(
SURFOBJ *psoTrg,
SURFOBJ *psoSrc,
SURFOBJ *psoMask,
CLIPOBJ *pco,
XLATEOBJ *pxlo,
RECTL *prclTrg,
POINTL *pptlSrc,
POINTL *pptlMask,
BRUSHOBJ *pbo,
POINTL *pptlBrush,
ROP4 rop4)
{
BOOL b;
INT width,
height;
ULONG XGAPixelOp,
ulXgaMask;
PXGACPREGS pXgaCpRegs = ((PPDEV)psoTrg->dhpdev)->pXgaCpRegs;
DISPDBG((2, "XGA.DLL!bSolidPattern - Entry\n"));
b = bSetXgaClipping((PPDEV)psoTrg->dhpdev,pco, &ulXgaMask);
if (b == FALSE)
return (b);
// Setup the BitBlt parameters.
width = (prclTrg->right - prclTrg->left) - 1;
height = (prclTrg->bottom - prclTrg->top) - 1;
pXgaCpRegs->XGAOpDim1 = width;
pXgaCpRegs->XGAOpDim2 = height;
pXgaCpRegs->XGADestMapX = (USHORT) prclTrg->left;
pXgaCpRegs->XGADestMapY = (USHORT) prclTrg->top;
pXgaCpRegs->XGAForeGrMix = XGA_S;
pXgaCpRegs->XGABackGrMix = XGA_S;
pXgaCpRegs->XGAForeGrColorReg = pbo->iSolidColor;
pXgaCpRegs->XGABackGrColorReg = pbo->iSolidColor;
// Now build the Pel Operation Register Op Code;
XGAPixelOp = BS_BACK_COLOR | FS_FORE_COLOR |
STEP_PX_BLT |
SRC_PEL_MAP_A | DST_PEL_MAP_A |
PATT_FOREGROUND;
XGAPixelOp |= ulXgaMask;
pXgaCpRegs->XGAPixelOp = XGAPixelOp;
return (TRUE);
}
VOID vMmSolidVertical(
PDEV* ppdev,
STRIP* pStrip,
LINESTATE* pLineState)
{
BYTE* pjBase = ppdev->pjBase;
LONG cBpp = ppdev->cBpp;
LONG lDelta = ppdev->lDelta;
LONG cStrips = pStrip->cStrips;
PLONG pStrips = pStrip->alStrips;
LONG x = pStrip->ptlStart.x;
LONG y = pStrip->ptlStart.y;
LONG xy = PELS_TO_BYTES(x) + (lDelta * y);
LONG i;
ULONG ulDst;
DISPDBG((2,"vMmSolidVertical"));
if (!(pStrip->flFlips & FL_FLIP_V))
{
//
// |
// Vertical strips v
// |
// v
//
for (i = 0; i < cStrips; i++)
{
MM_DRAW_VERT_STRIP(xy, *pStrips, lDelta, cBpp);
y += *pStrips;
xy += cBpp; // x+
xy += (*pStrips * lDelta); // y+
pStrips++;
}
}
else
{
//
// ^
// Vertical strips |
// ^
// |
//
for (i = 0; i < cStrips; i++)
{
MM_DRAW_VERT_STRIP_FLIPPED(xy, *pStrips, lDelta, cBpp);
y -= *pStrips;
xy += cBpp; // x+
xy -= (*pStrips * lDelta); // y-
pStrips++;
}
}
x += cStrips;
pStrip->ptlStart.x = x;
pStrip->ptlStart.y = y;
}
