/// <summary>
/// <c>wLoad</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="lpDestTex"></param>
/// <param name="lpDestPoint"></param>
/// <param name="lpSrcTex"></param>
/// <param name="lprcSrcRect"></param>
/// <param name="dwFlags"></param>
/// <returns></returns>
HRESULT __stdcall wLoad(
LPDIRECT3DDEVICE7 d3dDevice7, LPDIRECTDRAWSURFACE7 lpDestTex, LPPOINT lpDestPoint,
LPDIRECTDRAWSURFACE7 lpSrcTex, LPRECT lprcSrcRect, ULONG dwFlags)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "Load(0x%x with 0x%x)", lpDestTex, lpSrcTex);
hResult = d3dDevice7->Load(
lpDestTex,
lpDestPoint,
lpSrcTex,
lprcSrcRect,
dwFlags);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - Load(0x%x with 0x%x)",
hResult, pszErrorMessage, lpDestTex, lpSrcTex) )
ENTER_DEBUGGER;
}
}
return hResult;
}
/// <summary>
/// <c>wLightEnable</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwLightIndex"></param>
/// <param name="Enable"></param>
/// <returns></returns>
HRESULT __stdcall wLightEnable(
LPDIRECT3DDEVICE7 d3dDevice7, ULONG dwLightIndex, bool Enable)
{
PSTR pszEnable;
PSTR pszErrorMessage;
HRESULT hResult;
if ( Enable )
pszEnable = "enable";
else
pszEnable = "disable";
InternalFunctionSpew("GameOS_Direct3D", "LightEnable(%d, %s)", dwLightIndex, pszEnable);
hResult = d3dDevice7->LightEnable(dwLightIndex, Enable);
if (FAILED(hResult))
{
if ( Enable )
pszEnable = "enable";
else
pszEnable = "disable";
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - LightEnable(%d, %s)", hResult, pszErrorMessage, dwLightIndex, pszEnable) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wDrawPrimitive</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dptPrimitiveType"></param>
/// <param name="dvtVertexType"></param>
/// <param name="lpvVertices"></param>
/// <param name="dwVertexCount"></param>
/// <param name="dwFlags"></param>
/// <returns></returns>
HRESULT __stdcall wDrawPrimitive(
LPDIRECT3DDEVICE7 d3dDevice7, D3DPRIMITIVETYPE dptPrimitiveType,
ULONG dvtVertexType, PVOID lpvVertices, ULONG dwVertexCount, ULONG dwFlags)
{
PSTR pszPrimitiveData;
PSTR pszErrorMessage;
HRESULT hResult;
pszPrimitiveData = GetDrawPrimitiveData(
dptPrimitiveType, dvtVertexType, lpvVertices, dwVertexCount, dwFlags);
InternalFunctionSpew("GameOS_Direct3D", "DrawPrimitive( %s)", pszPrimitiveData);
hResult = d3dDevice7->DrawPrimitive(
dptPrimitiveType,
dvtVertexType,
lpvVertices,
dwVertexCount,
dwFlags);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszPrimitiveData = GetDrawPrimitiveData(
dptPrimitiveType, dvtVertexType, lpvVertices, dwVertexCount, dwFlags);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - DrawPrimitive( %s)",
hResult, pszErrorMessage, pszPrimitiveData) )
ENTER_DEBUGGER;
}
}
return hResult;
}
/// <summary>
/// <c>wSetTextureStageState</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwStage"></param>
/// <param name="dwState"></param>
/// <param name="dwValue"></param>
/// <returns></returns>
HRESULT __stdcall wSetTextureStageState(
LPDIRECT3DDEVICE7 d3dDevice7, ULONG dwStage, D3DTEXTURESTAGESTATETYPE dwState, ULONG dwValue)
{
PSTR pszStageSet;
PSTR pszErrorMessage;
HRESULT hResult;
++TotalRenderStateChanges;
pszStageSet = GetStageSet(dwState, dwValue);
InternalFunctionSpew("GameOS_Direct3D", "SetTextureStageState(%d,%s)", dwStage, pszStageSet);
hResult = d3dDevice7->SetTextureStageState(dwStage, dwState, dwValue);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszStageSet = GetStageSet(dwState, dwValue);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetTextureStageState(%d,%s)",
hResult, pszErrorMessage, dwStage, pszStageSet) )
ENTER_DEBUGGER;
}
}
return hResult;
}
/// <summary>
/// <c>wMultiplyTransform</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dtstTransformStateType"></param>
/// <param name="lpD3DMatrix"></param>
/// <returns></returns>
HRESULT __stdcall wMultiplyTransform(
LPDIRECT3DDEVICE7 d3dDevice7, D3DTRANSFORMSTATETYPE dtstTransformStateType,
LPD3DMATRIX lpD3DMatrix)
{
PSTR pszTransformType;
PSTR pszErrorMessage;
HRESULT hResult;
pszTransformType = GetTransformType(dtstTransformStateType);
InternalFunctionSpew("GameOS_Direct3D", "MultiplyTransform(%s)", pszTransformType);
hResult =
d3dDevice7->MultiplyTransform(
dtstTransformStateType,
lpD3DMatrix);
if (FAILED(hResult))
{
pszTransformType = GetTransformType(dtstTransformStateType);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - MultiplyTransform()",
hResult, pszErrorMessage, pszTransformType) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wCreateVertexBuffer</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3d7"></param>
/// <param name="lpVBDesc"></param>
/// <param name="lplpD3DVertexBuffer"></param>
/// <param name="dwFlags"></param>
/// <returns></returns>
HRESULT __stdcall wCreateVertexBuffer(
LPDIRECT3D7 d3d7, LPD3DVERTEXBUFFERDESC lpVBDesc,
LPDIRECT3DVERTEXBUFFER7 *lplpD3DVertexBuffer, ULONG dwFlags)
{
ULONG dwNumVertices;
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "CreateVertexBuffer(%d Vertices)+",
lpVBDesc->dwNumVertices);
hResult = d3d7->CreateVertexBuffer(lpVBDesc, lplpD3DVertexBuffer, dwFlags);
InternalFunctionSpew("GameOS_Direct3D", " -0x%x", *lplpD3DVertexBuffer);
if (FAILED(hResult))
{
dwNumVertices = lpVBDesc->dwNumVertices;
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - CreateVertexBuffer(%d Vertices)",
hResult, pszErrorMessage, dwNumVertices) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wProcessVertices</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="D3Dvb7"></param>
/// <param name="dwVertexOp"></param>
/// <param name="dwDestIndex"></param>
/// <param name="dwCount"></param>
/// <param name="lpSrcBuffer"></param>
/// <param name="dwSrcIndex"></param>
/// <param name="lpD3DDevice"></param>
/// <param name="dwFlags"></param>
/// <returns></returns>
HRESULT __stdcall wProcessVertices(
LPDIRECT3DVERTEXBUFFER7 D3Dvb7, ULONG dwVertexOp, ULONG dwDestIndex, ULONG dwCount,
LPDIRECT3DVERTEXBUFFER7 lpSrcBuffer, ULONG dwSrcIndex, LPDIRECT3DDEVICE7 lpD3DDevice, ULONG dwFlags)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew(
"GameOS_Direct3D", "ProcessVertices(Dest=0x%x, Src=0x%x, Vertices=%d)",
D3Dvb7, lpSrcBuffer, dwCount);
hResult = D3Dvb7->ProcessVertices(
dwVertexOp,
dwDestIndex,
dwCount,
lpSrcBuffer,
dwSrcIndex,
lpD3DDevice,
dwFlags);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause(
"FAILED (0x%x - %s) - ProcessVertices(Dest=0x%x, Src=0x%x, Vertices=%d)",
hResult,
pszErrorMessage,
D3Dvb7,
lpSrcBuffer,
dwCount) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wClear</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwCount"></param>
/// <param name="lpRects"></param>
/// <param name="dwFlags"></param>
/// <param name="dwColor"></param>
/// <param name="dvZ"></param>
/// <param name="dwStencil"></param>
/// <returns></returns>
HRESULT __stdcall wClear(
LPDIRECT3DDEVICE7 d3dDevice7, ULONG dwCount, LPD3DRECT lpRects, ULONG dwFlags,
ULONG dwColor, D3DVALUE dvZ, ULONG dwStencil)
{
PSTR pszClearArea;
PSTR pszErrorMessage;
HRESULT hResult;
pszClearArea = GetClearArea(dwCount, lpRects, dwFlags);
InternalFunctionSpew("GameOS_Direct3D", "Clear(%s)", pszClearArea);
hResult = d3dDevice7->Clear(
dwCount,
lpRects,
dwFlags,
dwColor,
dvZ,
dwStencil);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszClearArea = GetClearArea(dwCount, lpRects, dwFlags);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - Clear(%s)", hResult, pszErrorMessage, pszClearArea) )
ENTER_DEBUGGER;
}
}
return hResult;
}
/// <summary>
/// <c>wACMStreamSize</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="has"></param>
/// <param name="cbInput"></param>
/// <param name="pdwOutputBytes"></param>
/// <param name="fdwSize"></param>
/// <returns>HRESULT __stdcall</returns>
HRESULT __stdcall
wACMStreamSize(HACMSTREAM has, ULONG cbInput, PULONG pdwOutputBytes, ULONG fdwSize)
{
PSTR pszErrorMessage;
MMRESULT hResult;
InternalFunctionSpew(
"GameOS_DirectSound",
"acmStreamSize(0x%x, 0x%x, 0x%x, 0x%x)",
has,
cbInput,
pdwOutputBytes,
fdwSize);
hResult = acmStreamSize(has, cbInput, pdwOutputBytes, fdwSize);
if (MMFAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause(
"FAILED (0x%x - %s) - acmStreamSize(0x%x, 0x%x, 0x%x, 0x%x)",
hResult,
pszErrorMessage,
has,
cbInput,
pdwOutputBytes,
fdwSize) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wSetViewport</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="lpViewport"></param>
/// <returns></returns>
HRESULT __stdcall wSetViewport(
LPDIRECT3DDEVICE7 d3dDevice7, LPD3DVIEWPORT7 lpViewport)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "SetViewport()");
hResult = d3dDevice7->SetViewport(lpViewport);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetViewport()", hResult, pszErrorMessage) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wLock</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="D3Dvb7"></param>
/// <param name="dwFlags"></param>
/// <param name="lplpData"></param>
/// <param name="lpdwSize"></param>
/// <returns></returns>
HRESULT __stdcall wLock(
LPDIRECT3DVERTEXBUFFER7 D3Dvb7, ULONG dwFlags, PVOID *lplpData, PULONG lpdwSize)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "Lock(0x%x)", D3Dvb7);
hResult = D3Dvb7->Lock(dwFlags, lplpData, lpdwSize);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - Lock(0x%x)", hResult, pszErrorMessage, D3Dvb7) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wGetCaps</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="lpD3DHWDevDesc"></param>
/// <returns></returns>
HRESULT __stdcall wGetCaps(
LPDIRECT3DDEVICE7 d3dDevice7, LPD3DDEVICEDESC7 lpD3DHWDevDesc)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "GetCaps(0x%x)", d3dDevice7);
hResult = d3dDevice7->GetCaps(lpD3DHWDevDesc);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - GetCaps(0x%x)", hResult, pszErrorMessage, d3dDevice7) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wEnumTextureFormats</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="lpd3dEnumPixelProc"></param>
/// <param name="lpArg"></param>
/// <returns></returns>
HRESULT __stdcall wEnumTextureFormats(
LPDIRECT3DDEVICE7 d3dDevice7, LPD3DENUMPIXELFORMATSCALLBACK lpd3dEnumPixelProc, PVOID lpArg)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "EnumTextureFormats()");
hResult = d3dDevice7->EnumTextureFormats(lpd3dEnumPixelProc, lpArg);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - EnumTextureFormats()", hResult, pszErrorMessage) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wEndScene</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <returns></returns>
HRESULT __stdcall wEndScene(
LPDIRECT3DDEVICE7 d3dDevice7)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "EndScene()");
hResult = d3dDevice7->EndScene();
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - EndScene()", hResult, pszErrorMessage) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wEnumDevices</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3d7"></param>
/// <param name="lpEnumDevicesCallback"></param>
/// <param name="lpUserArg"></param>
/// <returns></returns>
HRESULT __stdcall wEnumDevices(
LPDIRECT3D7 d3d7, LPD3DENUMDEVICESCALLBACK7 lpEnumDevicesCallback, PVOID lpUserArg)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "EnumDevices()");
hResult = d3d7->EnumDevices(lpEnumDevicesCallback, lpUserArg);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - EnumDevices()", hResult, pszErrorMessage) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wDrawIndexedPrimitiveVB</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="d3dptPrimitiveType"></param>
/// <param name="lpd3dVertexBuffer"></param>
/// <param name="dwStartVertex"></param>
/// <param name="dwNumVertices"></param>
/// <param name="lpwIndices"></param>
/// <param name="dwIndexCount"></param>
/// <param name="dwFlags"></param>
/// <returns></returns>
HRESULT __stdcall wDrawIndexedPrimitiveVB(
LPDIRECT3DDEVICE7 d3dDevice7, D3DPRIMITIVETYPE d3dptPrimitiveType,
LPDIRECT3DVERTEXBUFFER7 lpd3dVertexBuffer, ULONG dwStartVertex,
ULONG dwNumVertices, PUSHORT lpwIndices, ULONG dwIndexCount, ULONG dwFlags)
{
LPDIRECT3DVERTEXBUFFER7 pd3dVertexBufferUsed;
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "DrawIndexedPrimitiveVB(0x%x)", lpd3dVertexBuffer);
if (g_pGetDXVB)
{
pd3dVertexBufferUsed = g_pGetDXVB(lpd3dVertexBuffer, d3dDevice7);
}
else
{
pd3dVertexBufferUsed = lpd3dVertexBuffer;
}
hResult = d3dDevice7->DrawIndexedPrimitiveVB(
d3dptPrimitiveType,
pd3dVertexBufferUsed,
dwStartVertex,
dwNumVertices,
lpwIndices,
dwIndexCount,
dwFlags);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause(
"FAILED (0x%x - %s) - DrawIndexedPrimitiveVB(0x%x)",
hResult,
pszErrorMessage,
lpd3dVertexBuffer) )
ENTER_DEBUGGER;
}
}
return hResult;
}
/// <summary>
/// <c>wUnlock</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="D3Dvb7"></param>
/// <returns></returns>
HRESULT __stdcall wUnlock(
LPDIRECT3DVERTEXBUFFER7 D3Dvb7)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "Unlock(0x%x)", D3Dvb7);
hResult = D3Dvb7->Unlock();
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - Unlock(0x%x)",
hResult, pszErrorMessage, D3Dvb7) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wOptimize</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="D3Dvb7"></param>
/// <param name="lpD3DDevice"></param>
/// <param name="dwFlags"></param>
/// <returns></returns>
HRESULT __stdcall wOptimize(
LPDIRECT3DVERTEXBUFFER7 D3Dvb7, LPDIRECT3DDEVICE7 lpD3DDevice, ULONG dwFlags)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "Optimize(0x%x)", D3Dvb7);
hResult = D3Dvb7->Optimize(lpD3DDevice, dwFlags);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - Optimize(0x%x)",
hResult, pszErrorMessage, D3Dvb7) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wACMFormatSuggest</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="had"></param>
/// <param name="pwfxSrc"></param>
/// <param name="pwfxDst"></param>
/// <param name="cbwfxDst"></param>
/// <param name="fdwSuggest"></param>
/// <returns>HRESULT __stdcall</returns>
HRESULT __stdcall
wACMFormatSuggest(HACMDRIVER had, const PWAVEFORMATEX pwfxSrc, const PWAVEFORMATEX pwfxDst,
ULONG cbwfxDst, ULONG fdwSuggest)
{
PSTR pszwfDst;
PSTR pszwfSrc;
PSTR pszErrorMessage;
char Buffer2[128];
char Buffer[128];
MMRESULT hResult;
pszwfDst = GetWaveFormat(Buffer, pwfxDst);
pszwfSrc = GetWaveFormat(Buffer2, pwfxSrc);
InternalFunctionSpew(
"GameOS_DirectSound",
"acmFormatSuggest(0x%x, %s, %s, 0x%x, 0x%x)",
had,
pszwfSrc,
pszwfDst,
cbwfxDst,
fdwSuggest);
hResult = acmFormatSuggest(had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
if (MMFAILED(hResult))
{
pszwfDst = GetWaveFormat(Buffer, pwfxDst);
pszwfSrc = GetWaveFormat(Buffer2, pwfxSrc);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause(
"FAILED (0x%x - %s) - acmFormatSuggest(0x%x, %s, %s, 0x%x, 0x%x)",
hResult,
pszErrorMessage,
had,
pszwfSrc,
pszwfDst,
cbwfxDst,
fdwSuggest) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wValidateDevice</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="pExtraPasses"></param>
/// <returns></returns>
HRESULT __stdcall wValidateDevice(
LPDIRECT3DDEVICE7 d3dDevice7, PULONG pExtraPasses)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "ValidateDevice()+");
hResult = d3dDevice7->ValidateDevice(pExtraPasses);
InternalFunctionSpew("GameOS_Direct3D", " -0x%x", *pExtraPasses);
if (FAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - ValidateDevice()",
hResult, pszErrorMessage) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wSetLight</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwLightIndex"></param>
/// <param name="lpLight"></param>
/// <returns></returns>
HRESULT __stdcall wSetLight(
LPDIRECT3DDEVICE7 d3dDevice7, ULONG dwLightIndex, LPD3DLIGHT7 lpLight)
{
PSTR pszLightInfo;
PSTR pszErrorMessage;
HRESULT hResult;
pszLightInfo = GetLightInfo(lpLight);
InternalFunctionSpew("GameOS_Direct3D", "SetLight(%d, %s)", dwLightIndex, pszLightInfo);
hResult = d3dDevice7->SetLight(dwLightIndex, lpLight);
if (FAILED(hResult))
{
pszLightInfo = GetLightInfo(lpLight);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetLight(%d, %s)",
hResult, pszErrorMessage, dwLightIndex, pszLightInfo) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wSetTexture</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwStage"></param>
/// <param name="lpTexture"></param>
/// <returns></returns>
HRESULT __stdcall wSetTexture(
LPDIRECT3DDEVICE7 d3dDevice7, ULONG dwStage, LPDIRECTDRAWSURFACE7 lpTexture)
{
PSTR pszErrorMessage;
HRESULT hResult;
InternalFunctionSpew("GameOS_Direct3D", "SetTexture(%d,0x%x)", dwStage, lpTexture);
hResult = d3dDevice7->SetTexture(dwStage, lpTexture);
if (FAILED(hResult))
{
if ( hResult != DDERR_SURFACELOST)
{
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetTexture(%d,0x%x)",
hResult, pszErrorMessage, dwStage, lpTexture) )
ENTER_DEBUGGER;
}
}
return hResult;
}
/// <summary>
/// <c>wSetMaterial</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="pMaterial"></param>
/// <returns></returns>
HRESULT __stdcall wSetMaterial(
LPDIRECT3DDEVICE7 d3dDevice7, LPD3DMATERIAL7 pMaterial)
{
PSTR pszMaterialInfo;
PSTR pszErrorMessage;
HRESULT hResult;
pszMaterialInfo = GetMaterialInfo(pMaterial);
InternalFunctionSpew("GameOS_Direct3D", "SetMaterial(%s)", pszMaterialInfo);
hResult = d3dDevice7->SetMaterial(pMaterial);
if (FAILED(hResult))
{
pszMaterialInfo = GetMaterialInfo(pMaterial);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetMaterial(%s)",
hResult, pszErrorMessage, pszMaterialInfo) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wCreateDevice</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3d7"></param>
/// <param name="rclsid"></param>
/// <param name="lpDDS"></param>
/// <param name="lplpD3DDevice7"></param>
/// <returns></returns>
HRESULT __stdcall wCreateDevice(
LPDIRECT3D7 d3d7, REFCLSID rclsid, LPDIRECTDRAWSURFACE7 lpDDS, LPDIRECT3DDEVICE7 *lplpD3DDevice7)
{
PSTR pszDevice;
PSTR pszErrorMessage;
HRESULT hResult;
pszDevice = Get3DDevice(rclsid);
InternalFunctionSpew("GameOS_Direct3D", "CreateDevice(%s from 0x%x)+", pszDevice, lpDDS);
hResult = d3d7->CreateDevice(rclsid, lpDDS, lplpD3DDevice7);
InternalFunctionSpew("GameOS_Direct3D", " -0x%x", *lplpD3DDevice7);
if (FAILED(hResult))
{
pszDevice = Get3DDevice(rclsid);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - CreateDevice(%s from 0x%x)", hResult, pszErrorMessage, pszDevice, lpDDS) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wEnumZBufferFormats</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3d7"></param>
/// <param name="riidDevice"></param>
/// <param name="lpEnumCallback"></param>
/// <param name="lpContext"></param>
/// <returns></returns>
HRESULT __stdcall wEnumZBufferFormats(
LPDIRECT3D7 d3d7, REFCLSID riidDevice, LPD3DENUMPIXELFORMATSCALLBACK lpEnumCallback,
PVOID lpContext)
{
PSTR pszDevice;
PSTR pszErrorMessage;
HRESULT hResult;
pszDevice = Get3DDevice(riidDevice);
InternalFunctionSpew("GameOS_Direct3D", "EnumZBufferFormats(%s)", pszDevice);
hResult = d3d7->EnumZBufferFormats(riidDevice, lpEnumCallback, lpContext);
if (FAILED(hResult))
{
pszDevice = Get3DDevice(riidDevice);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - EnumZBufferFormats(%s)",
hResult, pszErrorMessage, pszDevice) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wACMStreamPrepareHeader</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="has"></param>
/// <param name="pash"></param>
/// <param name="fdwPrepare"></param>
/// <returns>HRESULT __stdcall</returns>
HRESULT __stdcall
wACMStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, ULONG fdwPrepare)
{
PSTR pszErrorMessage;
MMRESULT hResult;
InternalFunctionSpew("GameOS_DirectSound", "acmStreamPrepareHeader(0x%x, 0x%x, 0x%x)", has, pash, fdwPrepare);
hResult = acmStreamPrepareHeader(has, pash, fdwPrepare);
if (MMFAILED(hResult))
{
pszErrorMessage = ErrorNumberToMessage(hResult);
//PAUSE(
if ( InternalFunctionPause(
"FAILED (0x%x - %s) - acmStreamPrepareHeader(0x%x, 0x%x, 0x%x)",
hResult,
pszErrorMessage,
has,
pash,
fdwPrepare) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>wSetRenderState</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="d3dDevice7"></param>
/// <param name="dwRenderStateType"></param>
/// <param name="dwRenderState"></param>
/// <returns></returns>
HRESULT __stdcall wSetRenderState(
LPDIRECT3DDEVICE7 d3dDevice7, D3DRENDERSTATETYPE dwRenderStateType, ULONG dwRenderState)
{
PSTR pszRenderState;
PSTR pszErrorMessage;
HRESULT hResult;
++TotalRenderStateChanges;
pszRenderState = GetRenderState(dwRenderStateType, dwRenderState);
InternalFunctionSpew("GameOS_Direct3D", "SetRenderState(%s)", pszRenderState);
hResult = d3dDevice7->SetRenderState(dwRenderStateType, dwRenderState);
if (FAILED(hResult))
{
pszRenderState = GetRenderState(dwRenderStateType, dwRenderState);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause("FAILED (0x%x - %s) - SetRenderState(%s)",
hResult, pszErrorMessage, pszRenderState) )
ENTER_DEBUGGER;
}
return hResult;
}
/// <summary>
/// <c>InitLibraries</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <returns></returns>
void __stdcall InitLibraries(void)
{
PCSTR pszFormat;
PCSTR pszMessage;
size_t nBufferSize;
char szAssetsPathMessage[MAX_PATH * 2];
bool bbladepath1;
bool bbladepath2;
// char szDdrawMessage[MAX_PATH * 2];
char szDirectXVersionMessage2[128];
char szDirectXVersionMessage1[128];
char szDsetupMessage[MAX_PATH * 2];
HMODULE hModule_dsetup;
char szAssetsPath[MAX_PATH];
PDIRECTXSETUPGETVERSION pDirectXSetupGetVersion;
#if _CONSIDERED_OBSOLETE
OSVERSIONINFOA VersionInformation;
char szDirBuffer[MAX_PATH];
char szInstallMessage[256];
#endif
gos_MathExceptions(false, false);
// C6031: Return value ignored: 'CoInitialize'
CoInitialize(nullptr);
// dsetup.dll
strcpy_s(szAssetsPath, _countof(szAssetsPath), AssetsDirectory2);
strcat_s(szAssetsPath, _countof(szAssetsPath), "\\dsetup.dll");
hModule_dsetup = LoadLibraryA(szAssetsPath);
if (hModule_dsetup == nullptr)
{
strcpy_s(szAssetsPath, _countof(szAssetsPath), AssetsDirectory1);
strcat_s(szAssetsPath, _countof(szAssetsPath), "\\assets\\binaries\\dsetup.dll");
hModule_dsetup = LoadLibraryA(szAssetsPath);
if (hModule_dsetup == nullptr)
{
// pszFormat = gos_GetResourceString(gLanguageDLL, 10051u);
pszFormat = "Cannot find dsetup.dll in %s\\assets\\binaries or %s, "
"this file is required";
sprintf_s(szDsetupMessage, _countof(szDsetupMessage), pszFormat, AssetsDirectory1,
AssetsDirectory2);
MessageBoxA(nullptr, szDsetupMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
}
pDirectXSetupGetVersion = reinterpret_cast<PDIRECTXSETUPGETVERSION>(
GetProcAddress(hModule_dsetup, "DirectXSetupGetVersion"));
if (pDirectXSetupGetVersion == nullptr ||
pDirectXSetupGetVersion(&DXdwVersion, &DXdwRevision) == 0)
{
DXdwVersion = 0;
DXdwRevision = 0;
}
FreeLibrary(hModule_dsetup);
// ddraw.dll
if (gDirectX7)
{
if ((WindowsNT == false) &&
((DXdwVersion < 7) || ((DXdwVersion == 7) && (DXdwRevision < 716))))
{
pszFormat = "Requires DirectX 7.0a or later, found %s";
pszMessage = GetDirectXVersion();
sprintf_s(szDirectXVersionMessage1, _countof(szDirectXVersionMessage1), pszFormat,
pszMessage);
MessageBoxA(nullptr, szDirectXVersionMessage1, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
}
else
{
if ((DXdwVersion < 8) || ((DXdwVersion == 8) && (DXdwRevision < 400)))
{
// pszFormat = gos_GetResourceString(gLanguageDLL, 10030u); //
// language.dll : "Requires DirectX 8 or later, found %s"
pszFormat = "Requires DirectX 8 or later, found %s";
pszMessage = GetDirectXVersion();
sprintf_s(szDirectXVersionMessage2, _countof(szDirectXVersionMessage2), pszFormat,
pszMessage);
MessageBoxA(nullptr, szDirectXVersionMessage2, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
}
if (gNoBlade == true)
{
LibBlade = LoadLibraryA("ddraw.dll");
if (LibBlade == nullptr)
{
// pszMessage = gos_GetResourceString(gLanguageDLL, 10031u);
pszMessage = "Cannot find ddraw.dll, this file is required";
// sprintf_s(szDdrawMessage, _countof(szDdrawMessage), pszMessage);
MessageBoxA(nullptr, pszMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
_DirectDrawCreateEx =
reinterpret_cast<PDIRECTDRAWCREATEEX>(GetProcAddress(LibBlade, "DirectDrawCreateEx"));
_DirectDrawEnumerate = reinterpret_cast<PDIRECTDRAWENUMERATEA>(
GetProcAddress(LibBlade, "DirectDrawEnumerateA"));
_DirectDrawEnumerateEx = reinterpret_cast<PDIRECTDRAWENUMERATEEXA>(
GetProcAddress(LibBlade, "DirectDrawEnumerateExA"));
g_pGetDXVB = nullptr;
if ((_DirectDrawCreateEx == nullptr) || (_DirectDrawEnumerate == nullptr) ||
/* typo bug (_DirectDrawEnumerate == nullptr)*/
(_DirectDrawEnumerateEx == nullptr))
{
pszMessage = "Cannot find ddraw functions";
MessageBoxA(nullptr, pszMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
}
else
{
// this special dll must surely be considered obsolete whatever the
// advantages there were to use a custom ddraw library.
bbladepath2 = false;
bbladepath1 = true;
strcpy_s(BladePath, _countof(BladePath), AssetsDirectory2);
strcat_s(BladePath, _countof(BladePath), "\\bladed.dll");
LibBlade = LoadLibraryA(BladePath);
if (LibBlade == nullptr)
{
strcpy_s(BladePath, _countof(BladePath), AssetsDirectory1);
strcat_s(BladePath, _countof(BladePath), "\\assets\\binaries\\bladed.dll");
LibBlade = LoadLibraryA(BladePath);
if (LibBlade == nullptr)
{
if (strlen(AssetsDirectory2) >= 16)
{
nBufferSize = strlen(AssetsDirectory2);
if (!_strnicmp(
&AssetsDirectory2[nBufferSize - 16], "\\assets\\binaries", 0x10u))
bbladepath2 = true;
}
bbladepath1 = false;
strcpy_s(BladePath, _countof(BladePath), AssetsDirectory2);
strcat_s(BladePath, _countof(BladePath), "\\blade.dll");
LibBlade = LoadLibraryA(BladePath);
if (LibBlade == nullptr)
{
strcpy_s(BladePath, _countof(BladePath), AssetsDirectory1);
strcat_s(BladePath, _countof(BladePath), "\\assets\\binaries\\blade.dll");
LibBlade = LoadLibraryA(BladePath);
bbladepath2 = true;
if (LibBlade == nullptr)
{
// pszFormat = gos_GetResourceString(gLanguageDLL,
// 10033u);
pszFormat = "Cannot find blade.dll in "
"%s\\assets\\binaries or %s, this file is "
"required";
sprintf_s(szAssetsPathMessage, _countof(szAssetsPathMessage), pszFormat,
AssetsDirectory1, AssetsDirectory2);
MessageBoxA(
nullptr, szAssetsPathMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
}
}
}
if ((bbladepath2 == false) && _stricmp(ApplicationName, "Test Blade"))
{
if (bbladepath1 == true)
{
if (InternalFunctionPause("Warning, '%s' was used", BladePath))
ENTER_DEBUGGER;
}
else
{
if (gos_DoesFileExist("assets\\binaries") &&
InternalFunctionPause("Warning, '%s' was used", BladePath))
ENTER_DEBUGGER;
}
}
_DirectDrawCreateEx =
reinterpret_cast<PDIRECTDRAWCREATEEX>(GetProcAddress(LibBlade, "DirectDrawCreateEx"));
_DirectDrawEnumerate = reinterpret_cast<PDIRECTDRAWENUMERATEA>(
GetProcAddress(LibBlade, "DirectDrawEnumerateA"));
_DirectDrawEnumerateEx = reinterpret_cast<PDIRECTDRAWENUMERATEEXA>(
GetProcAddress(LibBlade, "DirectDrawEnumerateExA"));
g_pGetDXVB = reinterpret_cast<GETDXFUNC>(GetProcAddress(LibBlade, "GetDXVB"));
if ((_DirectDrawCreateEx == nullptr) || (_DirectDrawEnumerate == nullptr) ||
/* typo bug (_DirectDrawEnumerate == nullptr)*/
(_DirectDrawEnumerateEx == nullptr) || (g_pGetDXVB == nullptr))
{
pszMessage = "Cannot find Blade functions";
MessageBoxA(nullptr, pszMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
}
// ijl10.dll
strcpy_s(szAssetsPath, _countof(szAssetsPath), AssetsDirectory2);
strcat_s(szAssetsPath, _countof(szAssetsPath), "\\ijl10.dll");
LibJpeg = LoadLibraryA(szAssetsPath);
if (LibJpeg == nullptr)
{
strcpy_s(szAssetsPath, _countof(szAssetsPath), AssetsDirectory1);
strcat_s(szAssetsPath, _countof(szAssetsPath), "\\assets\\binaries\\ijl10.dll");
LibJpeg = LoadLibraryA(szAssetsPath);
}
if (LibJpeg)
{
_ijlInit = reinterpret_cast<PIJLINIT>(GetProcAddress(LibJpeg, "ijlInit"));
_ijlFree = reinterpret_cast<PIJLFREE>(GetProcAddress(LibJpeg, "ijlFree"));
_ijlRead = reinterpret_cast<PIJLREAD>(GetProcAddress(LibJpeg, "ijlRead"));
_ijlWrite = reinterpret_cast<PIJLWRITE>(GetProcAddress(LibJpeg, "ijlWrite"));
}
// dsound.dll
LibDsound = LoadLibraryA("dsound.dll");
if (LibDsound == nullptr)
{
// pszMessage = gos_GetResourceString(gLanguageDLL, 10036u);
pszMessage = "Cannot load DirectSound dll";
MessageBoxA(nullptr, pszMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
_DirectSoundCreate =
reinterpret_cast<PDIRECTSOUNDCREATE>(GetProcAddress(LibDsound, "DirectSoundCreate"));
_DirectSoundEnumerate = reinterpret_cast<PDIRECTSOUNDENUMERATEA>(
GetProcAddress(LibDsound, "DirectSoundEnumerateA"));
if ((_DirectSoundCreate == nullptr) && (_DirectSoundEnumerate == nullptr))
{
pszMessage = "Cannot find DirectSound functions";
MessageBoxA(nullptr, pszMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
// dinput.dll
LibDinput = LoadLibraryA("dinput.dll");
if (LibDinput == nullptr)
{
// pszMessage = gos_GetResourceString(gLanguageDLL, 10038u);
pszMessage = "Cannot load DirectInput dll";
MessageBoxA(nullptr, pszMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
_DirectInputCreateEx =
reinterpret_cast<PDIRECTINPUTCREATEEX>(GetProcAddress(LibDinput, "DirectInputCreateEx"));
if (_DirectInputCreateEx == nullptr)
{
pszMessage = "Cannot find DirectInput functions";
MessageBoxA(nullptr, pszMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
// imm32.dll
LibIME = LoadLibraryA("imm32.dll");
if (LibIME)
{
_ImmGetContext = reinterpret_cast<PIMMGETCONTEXT>(GetProcAddress(LibIME, "ImmGetContext"));
_ImmReleaseContext =
reinterpret_cast<PIMMRELEASECONTEXT>(GetProcAddress(LibIME, "ImmReleaseContext"));
_ImmAssociateContext =
reinterpret_cast<PIMMASSOCIATECONTEXT>(GetProcAddress(LibIME, "ImmAssociateContext"));
_ImmGetCompositionString = reinterpret_cast<PIMMGETCOMPOSITIONSTRINGA>(
GetProcAddress(LibIME, "ImmGetCompositionStringA"));
_ImmGetOpenStatus =
reinterpret_cast<PIMMGETOPENSTATUS>(GetProcAddress(LibIME, "ImmGetOpenStatus"));
_ImmSetOpenStatus =
reinterpret_cast<PIMMSETOPENSTATUS>(GetProcAddress(LibIME, "ImmSetOpenStatus"));
_ImmGetConversionStatus = reinterpret_cast<PIMMGETCONVERSIONSTATUS>(
GetProcAddress(LibIME, "ImmGetConversionStatus"));
_ImmGetCandidateList =
reinterpret_cast<PIMMGETCANDIDATELISTA>(GetProcAddress(LibIME, "ImmGetCandidateListA"));
_ImmGetVirtualKey =
reinterpret_cast<PIMMGETVIRTUALKEY>(GetProcAddress(LibIME, "ImmGetVirtualKey"));
_ImmLockIMC = reinterpret_cast<PIMMLOCKIMC>(GetProcAddress(LibIME, "ImmLockIMC"));
_ImmUnlockIMC = reinterpret_cast<PIMMUNLOCKIMC>(GetProcAddress(LibIME, "ImmUnlockIMCC"));
_ImmLockIMCC = reinterpret_cast<PIMMLOCKIMCC>(GetProcAddress(LibIME, "ImmLockIMCC"));
_ImmUnlockIMCC = reinterpret_cast<PIMMUNLOCKIMCC>(GetProcAddress(LibIME, "ImmUnlockIMC"));
_ImmGetDefaultIMEWnd =
reinterpret_cast<PIMMGETDEFAULTIMEWND>(GetProcAddress(LibIME, "ImmGetDefaultIMEWnd"));
_ImmGetIMEFileName =
reinterpret_cast<PIMMGETIMEFILENAME>(GetProcAddress(LibIME, "ImmGetIMEFileNameA"));
_ImmNotifyIME = reinterpret_cast<PIMMNOTIFYIME>(GetProcAddress(LibIME, "ImmNotifyIME"));
_ImmSetConversionStatus = reinterpret_cast<PIMMSETCONVERSIONSTATUS>(
GetProcAddress(LibIME, "ImmSetConversionStatus"));
_ImmSimulateHotKey =
reinterpret_cast<PIMMSIMULATEHOTKEY>(GetProcAddress(LibIME, "ImmSimulateHotKey"));
_ImmIsIME = reinterpret_cast<PIMMISIME>(GetProcAddress(LibIME, "ImmIsIME"));
}
// psapi.dll
if (WindowsNT)
LibPSAPI = LoadLibraryA("psapi.dll");
else
LibPSAPI = nullptr;
if (LibPSAPI)
{
_EmptyWorkingSet =
reinterpret_cast<PEMPTYWORKINGSET>(GetProcAddress(LibPSAPI, "EmptyWorkingSet"));
_InitializeProcessForWsWatch = reinterpret_cast<PINITIALIZEPROCESSFORWSWATCH>(
GetProcAddress(LibPSAPI, "InitializeProcessForWsWatch"));
_GetWsChanges = reinterpret_cast<PGETWSCHANGES>(GetProcAddress(LibPSAPI, "GetWsChanges"));
_GetMappedFileName =
reinterpret_cast<PGETMAPPEDFILENAMEA>(GetProcAddress(LibPSAPI, "GetMappedFileNameA"));
}
// ws2_32.dll
if (Environment.NetworkGame || gEnableGosView)
{
LibWinSock = LoadLibraryA("ws2_32.dll");
if (LibWinSock == nullptr)
LibWinSock = LoadLibraryA("wsock32.dll");
if (LibWinSock)
{
_accept = reinterpret_cast<PACCEPT>(GetProcAddress(LibWinSock, "accept"));
_bind = reinterpret_cast<PBIND>(GetProcAddress(LibWinSock, "bind"));
_closesocket =
reinterpret_cast<PCLOSESOCKET>(GetProcAddress(LibWinSock, "closesocket"));
_gethostbyname =
reinterpret_cast<PGETHOSTBYNAME>(GetProcAddress(LibWinSock, "gethostbyname"));
_gethostname =
reinterpret_cast<PGETHOSTNAME>(GetProcAddress(LibWinSock, "gethostname"));
_getservbyname =
reinterpret_cast<PGETSERVBYNAME>(GetProcAddress(LibWinSock, "getservbyname"));
_htonl = reinterpret_cast<PHTONL>(GetProcAddress(LibWinSock, "htonl"));
_htons = reinterpret_cast<PHTONS>(GetProcAddress(LibWinSock, "htons"));
_inet_addr = reinterpret_cast<PINET_ADDR>(GetProcAddress(LibWinSock, "inet_addr"));
_listen = reinterpret_cast<PLISTEN>(GetProcAddress(LibWinSock, "listen"));
_ntohl = reinterpret_cast<PNTOHL>(GetProcAddress(LibWinSock, "ntohl"));
_recv = reinterpret_cast<PRECV>(GetProcAddress(LibWinSock, "recv"));
_recvfrom = reinterpret_cast<PRECVFROM>(GetProcAddress(LibWinSock, "recvfrom"));
_send = reinterpret_cast<PSEND>(GetProcAddress(LibWinSock, "send"));
_sendto = reinterpret_cast<PSENDTO>(GetProcAddress(LibWinSock, "sendto"));
_socket = reinterpret_cast<PSOCKET>(GetProcAddress(LibWinSock, "socket"));
_WSACleanup = reinterpret_cast<PWSACLEANUP>(GetProcAddress(LibWinSock, "WSACleanup"));
_WSAGetLastError =
reinterpret_cast<PWSAGETLASTERROR>(GetProcAddress(LibWinSock, "WSAGetLastError"));
_WSAStartup = reinterpret_cast<PWSASTARTUP>(GetProcAddress(LibWinSock, "WSAStartup"));
}
}
// amstream.dll quartz.dll msadp32.acm
LibAmstream = LoadLibraryA("amstream.dll");
LibQuartz = LoadLibraryA("quartz.dll");
LibMSADP32 = LoadLibraryA("msadp32.acm");
if ((LibAmstream == nullptr) || (LibQuartz == nullptr))
{
// pszMessage = gos_GetResourceString(gLanguageDLL, 10040u);
pszMessage = "DirectX Media not installed";
MessageBoxA(nullptr, pszMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
if (LibMSADP32 == nullptr)
{
// pszMessage = gos_GetResourceString(gLanguageDLL, 10042Au);
pszMessage = "Microsoft audio compression not installed";
MessageBoxA(nullptr, pszMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
// NOTE: useless code => meant to be moved up?
if (LibAmstream == nullptr)
{
nBufferSize = strlen("amstream.dll - Version 6.01");
pszMessage = GetDLLInfo("amstream.dll", 0);
if (strncmp(pszMessage, "amstream.dll - Version 6.01", nBufferSize) < 0)
{
// pszMessage = gos_GetResourceString(gLanguageDLL, 10043u);
pszMessage = "Please install DirectX Media 6.0 or later";
MessageBoxA(nullptr, pszMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
}
_AMGetErrorText =
reinterpret_cast<PAMGETERRORTEXTA>(GetProcAddress(LibQuartz, "AMGetErrorTextA"));
if (_AMGetErrorText == nullptr)
{
pszMessage = "Cannot find DirectShow functions";
MessageBoxA(nullptr, pszMessage, ApplicationName, MB_ICONEXCLAMATION);
status = AfterExit;
_exit(EXIT_FAILURE);
}
#if _CONSIDERED_OBSOLETE
// Windows 9X vmcpd.vxd
VersionInformation.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
GetVersionExA(&VersionInformation);
if (WindowsNT == false)
{
if (HasKatmai)
{
if (LOWORD(VersionInformation.dwBuildNumber) == 1998)
{
GetSystemDirectoryA(szDirBuffer, MAX_PATH);
strcat(szDirBuffer, "\\vmm32\\vmcpd.vxd");
if (gos_DoesFileExist(szDirBuffer) == false)
{
strcpy_s(szInstallMessage, _countof(szInstallMessage),
"You need to install \"vmcpd.vxd\" This can be found "
"in DirectX 7.0 SDK \"DXF\\extras\\win98 piii dbg\" "
"folder.");
if (OnNetwork == true)
strcat_s(szInstallMessage, _countof(szInstallMessage),
"\n\n(Microsoft Internal) - This can be found at "
"\\\\dxrelease\\release\\dx7\\DXF\\extras\\win98 "
"piii dbg");
MessageBoxA(nullptr, szInstallMessage, ApplicationName, MB_ICONEXCLAMATION);
}
}
}
}
#endif
// odbc32.dll
LibODBC = LoadLibraryA("odbc32.dll");
if (LibODBC)
{
_SQLAllocHandle =
reinterpret_cast<PSQLALLOCHANDLE>(GetProcAddress(LibODBC, "SQLAllocHandle"));
_SQLBindCol = reinterpret_cast<PSQLBINDCOL>(GetProcAddress(LibODBC, "SQLBindCol"));
_SQLBindParameter =
reinterpret_cast<PSQLBINDPARAMETER>(GetProcAddress(LibODBC, "SQLBindParameter"));
_SQLDisconnect = reinterpret_cast<PSQLDISCONNECT>(GetProcAddress(LibODBC, "SQLDisconnect"));
_SQLDriverConnect =
reinterpret_cast<PSQLDRIVERCONNECT>(GetProcAddress(LibODBC, "SQLDriverConnect"));
_SQLExecDirect = reinterpret_cast<PSQLEXECDIRECT>(GetProcAddress(LibODBC, "SQLExecDirect"));
_SQLFetch = reinterpret_cast<PSQLFETCH>(GetProcAddress(LibODBC, "SQLFetch"));
_SQLFreeHandle = reinterpret_cast<PSQLFREEHANDLE>(GetProcAddress(LibODBC, "SQLFreeHandle"));
_SQLFreeStmt = reinterpret_cast<PSQLFREESTMT>(GetProcAddress(LibODBC, "SQLFreeStmt"));
_SQLGetDiagField =
reinterpret_cast<PSQLGETDIAGFIELD>(GetProcAddress(LibODBC, "SQLGetDiagField"));
_SQLGetDiagRec = reinterpret_cast<PSQLGETDIAGREC>(GetProcAddress(LibODBC, "SQLGetDiagRec"));
_SQLNumResultCols =
reinterpret_cast<PSQLNUMRESULTCOLS>(GetProcAddress(LibODBC, "SQLNumResultCols"));
_SQLSetEnvAttr = reinterpret_cast<PSQLSETENVATTR>(GetProcAddress(LibODBC, "SQLSetEnvAttr"));
}
gos_MathExceptions(true, false);
}
/// <summary>
/// <c>wACMStreamOpen</c>
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="phas"></param>
/// <param name="had"></param>
/// <param name="pwfxSrc"></param>
/// <param name="pwfxDst"></param>
/// <param name="pwfltr"></param>
/// <param name="dwCallback"></param>
/// <param name="dwInstance"></param>
/// <param name="fdwOpen"></param>
/// <returns>HRESULT __stdcall</returns>
HRESULT __stdcall
wACMStreamOpen(PHACMSTREAM phas, HACMDRIVER had, const PWAVEFORMATEX pwfxSrc,
const PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, ULONG_PTR dwCallback,
ULONG_PTR dwInstance, ULONG fdwOpen)
{
PSTR pszwfDst;
PSTR pszwfSrc;
PSTR pszErrorMessage;
MMRESULT hResult;
char BUffer2[128];
char Buffer[128];
pszwfDst = GetWaveFormat(Buffer, pwfxDst);
pszwfSrc = GetWaveFormat(BUffer2, pwfxSrc);
InternalFunctionSpew(
"GameOS_DirectSound",
"acmStreamOpen(0x%x, 0x%x, %s, %s, 0x%x,0x%x, 0x%x, 0x%x)",
phas,
had,
pszwfSrc,
pszwfDst,
pwfltr,
dwCallback,
dwInstance,
fdwOpen);
hResult = acmStreamOpen(phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, 1u);
if (MMFAILED(hResult))
{
pszwfDst = GetWaveFormat(Buffer, pwfxDst);
pszwfSrc = GetWaveFormat(BUffer2, pwfxSrc);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause(
"FAILED (0x%x - %s) - acmStreamOpen(0x%x, 0x%x, %s, %s, 0x%x,0x%x, 0x%x, 0x%x)",
hResult,
pszErrorMessage,
phas,
had,
pszwfSrc,
pszwfDst,
pwfltr,
dwCallback,
dwInstance,
fdwOpen) )
ENTER_DEBUGGER;
}
hResult = acmStreamOpen(phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
if (MMFAILED(hResult))
{
pszwfDst = GetWaveFormat(Buffer, pwfxDst);
pszwfSrc = GetWaveFormat(BUffer2, pwfxSrc);
pszErrorMessage = ErrorNumberToMessage(hResult);
if ( InternalFunctionPause(
"FAILED (0x%x - %s) - acmStreamOpen(0x%x, 0x%x, %s, %s, 0x%x,0x%x, 0x%x, 0x%x)",
hResult,
pszErrorMessage,
phas,
had,
pszwfSrc,
pszwfDst,
pwfltr,
dwCallback,
dwInstance,
fdwOpen) )
ENTER_DEBUGGER;
}
return hResult;
}
