kotofyt/funnygame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
funnygame/external/steamworks/steamworksexample/gameenginewin32.cpp
kotofyt a9c28b8940 networking
2025-07-13 15:47:42 +03:00

2604 lines
81 KiB
C++
Raw Permalink Blame History

//========= Copyright © 1996-2008, Valve LLC, All rights reserved. ============
//
// Purpose: Main class for the game engine -- win32 implementation
//
// $NoKeywords: $
//=============================================================================
#include "stdafx.h"
#include "GameEngineWin32.h"
#include <map>
#include "steam\isteaminput.h"
#include "steam\isteamdualsense.h"
#ifdef WIN32
#include <direct.h>
#else
#define MAX_PATH PATH_MAX
#define _getcwd getcwd
#endif
#ifndef SAFE_RELEASE
#define SAFE_RELEASE( x ) if ( 0 != ( x ) ) { ( x )->Release(); x = 0; }
#endif
// Allocate static member
std::map<HWND, CGameEngineWin32* > CGameEngineWin32::m_MapEngineInstances;
//-----------------------------------------------------------------------------
// Purpose: WndProc
//-----------------------------------------------------------------------------
LRESULT CALLBACK GameWndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
switch ( msg )
{
case WM_CLOSE:
case WM_DESTROY:
case WM_QUIT:
{
CGameEngineWin32 *pGameEngine = CGameEngineWin32::FindEngineInstanceForHWND( hWnd );
if ( pGameEngine )
pGameEngine->Shutdown();
else
OutputDebugString( "Failed to find game engine instance for hwnd\n" );
PostQuitMessage( 0 );
return(0);
} break;
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
{
CGameEngineWin32 *pGameEngine = CGameEngineWin32::FindEngineInstanceForHWND( hWnd );
if ( pGameEngine )
{
pGameEngine->RecordKeyDown( (DWORD) wParam );
return 0;
}
else
{
OutputDebugString( "Failed to find game engine for hwnd, key down event lost\n" );
}
}
break;
case WM_KEYUP:
case WM_SYSKEYUP:
{
CGameEngineWin32 *pGameEngine = CGameEngineWin32::FindEngineInstanceForHWND( hWnd );
if ( pGameEngine )
{
pGameEngine->RecordKeyUp( (DWORD) wParam );
return 0;
}
else
{
OutputDebugString( "Failed to find game engine for hwnd, key up event lost\n" );
}
}
break;
// Add additional handlers for things like input here...
default:
break;
}
return DefWindowProc(hWnd, msg, wParam, lParam);
}
class CVoiceContext : public IXAudio2VoiceCallback
{
public:
CVoiceContext() : m_hBufferEndEvent( CreateEvent( NULL, FALSE, FALSE, NULL ) )
{
m_pSourceVoice = NULL;
}
virtual ~CVoiceContext()
{
CloseHandle( m_hBufferEndEvent );
}
STDMETHOD_( void, OnVoiceProcessingPassStart )( UINT32 )
{
}
STDMETHOD_( void, OnVoiceProcessingPassEnd )()
{
}
STDMETHOD_( void, OnStreamEnd )()
{
}
STDMETHOD_( void, OnBufferStart )( void* )
{
}
STDMETHOD_( void, OnBufferEnd )( void* pContext )
{
free( pContext ); // free the sound buffer
SetEvent( m_hBufferEndEvent );
}
STDMETHOD_( void, OnLoopEnd )( void* )
{
}
STDMETHOD_( void, OnVoiceError )( void*, HRESULT )
{
}
HANDLE m_hBufferEndEvent;
IXAudio2SourceVoice* m_pSourceVoice;
};
//-----------------------------------------------------------------------------
// Purpose: Constructor for game engine instance
//-----------------------------------------------------------------------------
CGameEngineWin32::CGameEngineWin32( HINSTANCE hInstance, int nShowCommand, int32 nWindowWidth, int32 nWindowHeight )
{
m_bEngineReadyForUse = false;
m_bShuttingDown = false;
m_hInstance = hInstance;
m_hWnd = NULL;
m_pD3D9Interface = NULL;
m_pD3D9Device = NULL;
m_pXAudio2 = NULL;
m_pMasteringVoice = NULL;
m_unVoiceChannelCount = 0; // 0 == invalid handle
m_nWindowWidth = nWindowWidth;
m_nWindowHeight = nWindowHeight;
m_nNextFontHandle = 1;
m_nNextVertBufferHandle = 1;
m_nNextTextureHandle = 1;
m_hLineBuffer = NULL;
m_pLineVertexes = NULL;
m_dwLinesToFlush = 0;
m_dwLineBufferBatchPos = 0;
m_hPointBuffer = NULL;
m_pPointVertexes = NULL;
m_dwPointsToFlush = 0;
m_dwPointBufferBatchPos = 0;
m_hQuadBuffer = NULL;
m_pQuadVertexes = NULL;
m_dwQuadsToFlush = 0;
m_dwQuadBufferBatchPos = 0;
m_h3DQuadBuffer = NULL;
m_p3DQuadVertexes = NULL;
m_dw3DQuadsToFlush = 0;
m_dw3DQuadBufferBatchPos = 0;
m_hTextureWhite = NULL;
m_bDeviceLost = false;
m_hLastTexture = NULL;
m_ulPreviousGameTickCount = 0;
m_ulGameTickCount = 0;
m_dwBackgroundColor = D3DCOLOR_ARGB(0, 255, 255, 255 );
m_pBackbufferDepth = NULL;
// for XAudio2
CoInitializeEx( NULL, COINIT_MULTITHREADED );
// restrict this main game thread to the first processor, so query performance counter won't jump on crappy AMD cpus
DWORD dwThreadAffinityMask = 0x01;
::SetThreadAffinityMask( ::GetCurrentThread(), dwThreadAffinityMask );
// Setup timing data
LARGE_INTEGER l;
::QueryPerformanceFrequency( &l );
m_ulPerfCounterToMillisecondsDivisor = l.QuadPart/1000;
::QueryPerformanceCounter( &l );
m_ulFirstQueryPerformanceCounterValue = l.QuadPart;
if ( !BCreateGameWindow( nShowCommand ) || !m_hWnd )
{
OutputDebugString( "Failed creating game window\n" );
return;
}
CGameEngineWin32::AddInstanceToHWNDMap( this, m_hWnd );
if ( !BInitializeD3D9() )
{
::MessageBoxA( NULL, "Failed to initialize D3D9.\n\nGame will now exit.", "SteamworksExample - Fatal error", MB_OK | MB_ICONERROR );
return;
}
RECT r;
::GetClientRect( m_hWnd, &r );
m_nViewportWidth = r.right - r.left;
m_nViewportHeight = r.bottom - r.top;
// initialize XAudio2 interface
if( FAILED( XAudio2Create( &m_pXAudio2, 0 ) ) )
{
::MessageBoxA( NULL, "Failed to init XAudio2 engine (grab the latest \"DirectX End-User Runtime Web Installer\" )", "SteamworksExample - Fatal error", MB_OK | MB_ICONERROR );
return;
}
// Create a mastering voice
if( FAILED( m_pXAudio2->CreateMasteringVoice( &m_pMasteringVoice, XAUDIO2_DEFAULT_CHANNELS, VOICE_OUTPUT_SAMPLE_RATE ) ) )
{
::MessageBoxA( NULL, "Failed to create mastering voice", "SteamworksExample", MB_OK | MB_ICONERROR );
}
// clear the action handles
for ( int i = 0; i <eControllerDigitalAction_NumActions; i++ )
{
m_ControllerDigitalActionHandles[i] = 0;
m_ControllerDigitalActionOrigins[i] = k_EInputActionOrigin_None;
}
for ( int i = 0; i <eControllerAnalogAction_NumActions; i++ )
{
m_ControllerAnalogActionHandles[i] = 0;
m_ControllerAnalogActionOrigins[i] = k_EInputActionOrigin_None;
}
for ( int i = 0; i <eControllerActionSet_NumSets; i++ )
{
m_ControllerActionSetHandles[i] = 0;
}
m_ActiveControllerHandle = 0;
InitSteamInput( );
m_bEngineReadyForUse = true;
}
//-----------------------------------------------------------------------------
// Purpose: Shutdown the game engine
//-----------------------------------------------------------------------------
void CGameEngineWin32::Shutdown()
{
// Flag that we are shutting down so the frame loop will stop running
m_bShuttingDown = true;
// Cleanup D3D fonts
{
std::map<HGAMEFONT, ID3DXFont *>::iterator iter;
for( iter = m_MapFontInstances.begin(); iter != m_MapFontInstances.end(); ++iter )
{
SAFE_RELEASE( iter->second );
}
m_MapFontInstances.clear();
}
// Cleanup D3D vertex buffers
{
std::map<HGAMEVERTBUF, VertBufData_t>::iterator iter;
for( iter = m_MapVertexBuffers.begin(); iter != m_MapVertexBuffers.end(); ++iter )
{
if ( iter->second.m_bIsLocked )
iter->second.m_pBuffer->Unlock();
SAFE_RELEASE( iter->second.m_pBuffer );
}
m_MapVertexBuffers.clear();
}
// Cleanup D3D textures
{
std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
for( iter = m_MapTextures.begin(); iter != m_MapTextures.end(); ++iter )
{
if ( iter->second.m_pRGBAData )
{
delete[] iter->second.m_pRGBAData;
iter->second.m_pRGBAData = NULL;
}
if ( iter->second.m_pTexture )
{
SAFE_RELEASE( iter->second.m_pTexture );
}
}
m_MapTextures.clear();
}
// All XAudio2 interfaces are released when the engine is destroyed, but being tidy
if ( m_pMasteringVoice )
{
m_pMasteringVoice->DestroyVoice();
m_pMasteringVoice = NULL;
}
// Cleanup D3D
SAFE_RELEASE( m_pBackbufferDepth );
SAFE_RELEASE( m_pD3D9Device );
SAFE_RELEASE( m_pD3D9Interface );
SAFE_RELEASE( m_pXAudio2 );
// Destroy our window
if ( m_hWnd )
{
if ( !DestroyWindow( m_hWnd ) )
{
// We failed to destroy our window. This shouldn't ever happen.
OutputDebugString( "Failed destroying window\n" );
}
else
{
// Clean up any pending messages.
MSG msg;
while( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
DispatchMessage(&msg);
}
}
CGameEngineWin32::RemoveInstanceFromHWNDMap( m_hWnd );
m_hWnd = NULL;
}
// Unregister our window class
if ( m_hInstance )
{
if ( !UnregisterClass( "SteamworksExample", m_hInstance ) )
{
OutputDebugString( "Failed unregistering window class\n" );
}
m_hInstance = NULL;
}
CoUninitialize();
}
//-----------------------------------------------------------------------------
// Purpose: Handle losing the d3d device (ie, release resources)
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BHandleLostDevice()
{
bool bFullySuccessful = true;
// Clear our saved FVF so that we will manually reset it once we re-acquire the device
m_dwCurrentFVF = NULL;
// Clear our internal buffers and batching data
m_dwLinesToFlush = 0;
m_dwLineBufferBatchPos = 0;
m_pLineVertexes = NULL;
m_hLineBuffer = NULL;
m_dwPointsToFlush = 0;
m_dwPointBufferBatchPos = 0;
m_pPointVertexes = NULL;
m_hPointBuffer = NULL;
m_dwQuadsToFlush = 0;
m_dwQuadBufferBatchPos = 0;
m_pQuadVertexes = NULL;
m_hQuadBuffer = NULL;
// Fonts are easy since we used d3dx, they have their own handlers
{
std::map<HGAMEFONT, ID3DXFont *>::iterator iter;
for( iter = m_MapFontInstances.begin(); iter != m_MapFontInstances.end(); ++iter )
{
if ( FAILED( iter->second->OnLostDevice() ) )
{
bFullySuccessful = false;
OutputDebugString( "Failed OnLostDevice on a font object\n" );
}
}
}
// Vertex buffers we have to release and then re-create later, since we only use them internal
// to the engine we can just free them all, and we'll know how to recreate them later on demand
{
std::map<HGAMEVERTBUF, VertBufData_t>::iterator iter;
for( iter = m_MapVertexBuffers.begin(); iter != m_MapVertexBuffers.end(); ++iter )
{
if ( iter->second.m_pBuffer )
{
if ( iter->second.m_bIsLocked )
iter->second.m_pBuffer->Unlock();
iter->second.m_bIsLocked = false;
iter->second.m_pBuffer->Release();
iter->second.m_pBuffer = NULL;
}
}
m_MapVertexBuffers.clear();
}
// Textures we can just release, and they will be recreated on demand when used again
{
std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
for( iter = m_MapTextures.begin(); iter != m_MapTextures.end(); ++iter )
{
if ( iter->second.m_pTexture )
{
iter->second.m_pTexture->Release();
iter->second.m_pTexture = NULL;
}
if ( iter->second.m_pDepthSurface )
{
iter->second.m_pDepthSurface->Release( );
iter->second.m_pDepthSurface = NULL;
}
}
}
return bFullySuccessful;
}
//-----------------------------------------------------------------------------
// Purpose: Handle device reset after losing it
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BHandleResetDevice()
{
bool bFullySuccessful = true;
ResetRenderStates();
// Fonts are easy since we used d3dx, they have their own handlers
{
std::map<HGAMEFONT, ID3DXFont *>::iterator iter;
for( iter = m_MapFontInstances.begin(); iter != m_MapFontInstances.end(); ++iter )
{
if ( FAILED( iter->second->OnResetDevice() ) )
{
OutputDebugString( "Reset for a font object failed\n" );
bFullySuccessful = false;
}
}
}
// Vertex buffers we only use internal to the class, so we know
// how to recreate them on demand. Nothing to do here for them.
return bFullySuccessful;
}
//-----------------------------------------------------------------------------
// Purpose: Updates current tick count for the game engine
//-----------------------------------------------------------------------------
void CGameEngineWin32::UpdateGameTickCount()
{
LARGE_INTEGER l;
::QueryPerformanceCounter( &l );
m_ulPreviousGameTickCount = m_ulGameTickCount;
m_ulGameTickCount = (l.QuadPart - m_ulFirstQueryPerformanceCounterValue) / m_ulPerfCounterToMillisecondsDivisor;
}
//-----------------------------------------------------------------------------
// Purpose: Tell the game engine to sleep for a bit if needed to limit frame rate. You must keep
// calling this repeatedly until it returns false. If it returns true it's slept a little, but more
// time may be needed.
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BSleepForFrameRateLimit( uint32 ulMaxFrameRate )
{
// Frame rate limiting
float flDesiredFrameMilliseconds = 1000.0f/ulMaxFrameRate;
LARGE_INTEGER l;
::QueryPerformanceCounter( &l );
uint64 ulGameTickCount = (l.QuadPart - m_ulFirstQueryPerformanceCounterValue) / m_ulPerfCounterToMillisecondsDivisor;
float flMillisecondsElapsed = (float)(ulGameTickCount - m_ulGameTickCount);
if ( flMillisecondsElapsed < flDesiredFrameMilliseconds )
{
// If enough time is left sleep, otherwise just keep spinning so we don't go over the limit...
if ( flDesiredFrameMilliseconds - flMillisecondsElapsed > 3.0f )
{
Sleep( 2 );
}
else
{
// Just return right away so we busy loop, don't want to sleep too long and go over
}
return true;
}
else
{
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose: Resets all the render, texture, and sampler states to our defaults
//-----------------------------------------------------------------------------
void CGameEngineWin32::ResetRenderStates()
{
// Since we are just a really basic rendering engine we'll setup our initial
// render states here and we can just assume that they don't change later
m_pD3D9Device->SetRenderState( D3DRS_LIGHTING, FALSE );
m_pD3D9Device->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
m_pD3D9Device->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_BOTHSRCALPHA );
m_pD3D9Device->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
// texture stage state
m_pD3D9Device->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
m_pD3D9Device->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
m_pD3D9Device->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT );
m_pD3D9Device->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
m_pD3D9Device->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
m_pD3D9Device->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_CURRENT );
// sampler state
m_pD3D9Device->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
m_pD3D9Device->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
m_pD3D9Device->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
m_pD3D9Device->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
m_pD3D9Device->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
m_pD3D9Device->SetSamplerState( 1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
m_pD3D9Device->SetSamplerState( 1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
m_pD3D9Device->SetSamplerState( 1, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
m_pD3D9Device->SetSamplerState( 1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP );
m_pD3D9Device->SetSamplerState( 1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP );
}
//-----------------------------------------------------------------------------
// Purpose: Creates the window for the game to use
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BCreateGameWindow( int nShowCommand )
{
int windowX = 0;
int windowY = 0;
WNDCLASS wc;
DWORD style;
// Register the window class.
wc.lpszClassName = "SteamworksExample";
wc.lpfnWndProc = GameWndProc;
wc.style = 0;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = m_hInstance;
wc.hIcon = LoadIcon(NULL,IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL,IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wc.lpszMenuName = NULL;
if ( !RegisterClass( &wc ) )
{
OutputDebugString( "Failure registering window class\n" );
return false;
}
// Set parent window mode (normal system window with overlap/draw-ordering)
style = WS_OVERLAPPED|WS_SYSMENU;
// Create actual window
m_hWnd = CreateWindow( "SteamworksExample",
"SteamworksExample",
style,
windowX,
windowY,
m_nWindowWidth,
m_nWindowHeight,
NULL,
NULL,
m_hInstance,
NULL );
if ( m_hWnd == NULL )
{
OutputDebugString( "Failed to create window for CGameEngine\n" );
return false;
}
// Give focus to newly created app window.
::ShowWindow( m_hWnd, nShowCommand );
::UpdateWindow( m_hWnd );
::SetFocus( m_hWnd );
return true;
}
bool CGameEngineWin32::BInitializeD3D9()
{
if ( !m_pD3D9Interface )
{
// Initialize the d3d interface
m_pD3D9Interface = Direct3DCreate9( D3D_SDK_VERSION );
if ( m_pD3D9Interface == NULL )
{
OutputDebugString( "Direct3DCreate9 failed\n" );
return false;
}
}
if ( !m_pD3D9Device )
{
D3DDISPLAYMODE d3ddisplaymode;
// Get the current desktop display mode, only needed if running in a window.
HRESULT hRes = m_pD3D9Interface->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddisplaymode );
if (FAILED(hRes))
{
OutputDebugString( "GetAdapterDisplayMode failed\n");
return false;
}
// Setup presentation parameters
ZeroMemory( &m_d3dpp, sizeof( m_d3dpp ) );
m_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
m_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; // no v-sync
m_d3dpp.hDeviceWindow = m_hWnd;
m_d3dpp.BackBufferCount = 1;
m_d3dpp.EnableAutoDepthStencil = TRUE;
m_d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
m_d3dpp.Windowed = TRUE; // bugbug jmccaskey - make a parameter?
m_d3dpp.BackBufferFormat = d3ddisplaymode.Format;
UINT nAdapter = D3DADAPTER_DEFAULT;
// Create Direct3D9 device
// (if it fails to create hardware vertex processing, then go with the software alternative).
hRes = m_pD3D9Interface->CreateDevice(
nAdapter,
D3DDEVTYPE_HAL,
m_hWnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&m_d3dpp,
&m_pD3D9Device );
// Could not create a hardware device, create a software one instead (slow....)
if ( FAILED( hRes ) )
{
hRes = m_pD3D9Interface->CreateDevice(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
m_hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&m_d3dpp,
&m_pD3D9Device );
}
// If we couldn't create a device even with software vertex processing then
// it's a fatal error
if ( FAILED( hRes ) )
{
// Make sure the pointer is NULL after failures (seems it sometimes gets modified even when failing)
m_pD3D9Device = NULL;
OutputDebugString( "Failed to create D3D9 device\n" );
return false;
}
if ( FAILED( m_pD3D9Device->GetDepthStencilSurface( &m_pBackbufferDepth ) ) )
{
m_pBackbufferDepth = NULL;
OutputDebugString( "Failed to get the backbuffer depth buffer\n" );
return false;
}
//Initialize our render, texture, and sampler stage states
ResetRenderStates();
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Set the background color to clear to
//-----------------------------------------------------------------------------
void CGameEngineWin32::SetBackgroundColor( short a, short r, short g, short b )
{
m_dwBackgroundColor = D3DCOLOR_ARGB( a, r, g, b );
}
//-----------------------------------------------------------------------------
// Purpose: Start a new frame
//-----------------------------------------------------------------------------
bool CGameEngineWin32::StartFrame()
{
// Before doing anything else pump messages
MessagePump();
// Detect if we lose focus and cause all keys do go up so they aren't stuck
if ( ::GetForegroundWindow() != m_hWnd )
{
m_SetKeysDown.clear();
}
// Message pump may have lead us to shutdown, check
if ( BShuttingDown() )
return false;
if ( !m_pD3D9Device )
return false;
// Poll Steam Controllers
PollSteamInput();
// Test that we haven't lost the device
HRESULT hRes = m_pD3D9Device->TestCooperativeLevel();
if ( hRes == D3DERR_DEVICELOST )
{
// Device is currently lost, can't render frames, but lets just let things continue so the
// simulation keeps running, the game should probably pause itself
// If it is newly lost then release resources
if ( !m_bDeviceLost )
{
OutputDebugString( "Device lost\n" );
// HandleLostDevice() will free all our resources
if ( !BHandleLostDevice() )
OutputDebugString( "Failed to release all resources for lost device\n" );
}
m_bDeviceLost = true;
}
else if ( hRes == D3DERR_DEVICENOTRESET )
{
OutputDebugString( "Getting ready to reset device\n" );
// Reset the device
hRes = m_pD3D9Device->Reset( &m_d3dpp );
if ( !FAILED( hRes ) )
{
m_bDeviceLost = false;
// Acquire all our resources again
if ( !BHandleResetDevice() )
{
OutputDebugString( "Failed to acquire all resources again after device reset\n" );
}
}
else
{
OutputDebugString( "Reset() call on device failed\n" );
::MessageBox( m_hWnd, "m_pD3D9Device->Reset() call has failed unexpectedly\n", "Fatal Error", MB_OK );
Shutdown();
return false;
}
}
// Return true even though we can't render, frames can still run otherwise
// and the game should continue its simulation or choose to pause on its own
if ( m_bDeviceLost )
return true;
hRes = m_pD3D9Device->BeginScene();
if ( FAILED( hRes ) )
return false;
// Clear the back buffer and z-buffer
hRes = m_pD3D9Device->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, m_dwBackgroundColor, 1.0f, 0 );
if ( FAILED( hRes ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: End the current frame
//-----------------------------------------------------------------------------
void CGameEngineWin32::EndFrame()
{
if ( BShuttingDown() )
return;
if ( !m_pD3D9Device )
return;
if ( m_bDeviceLost )
return;
// See if we lost the device in the middle of the frame
HRESULT hRes = m_pD3D9Device->TestCooperativeLevel();
if ( hRes == D3DERR_DEVICELOST )
{
// Ok, StartFrame will handle this next time through, but bail out early here
return;
}
// Flush point buffer
BFlushPointBuffer();
// Flush line buffer
BFlushLineBuffer();
// Flush quad buffer
BFlushQuadBuffer();
// draw the VR mode offscreen render target on a quad somewhere
hRes = m_pD3D9Device->EndScene();
if ( FAILED( hRes ) )
{
OutputDebugString( "EndScene() call failed\n" );
return;
}
hRes = m_pD3D9Device->Present( NULL, NULL, NULL, NULL );
if ( FAILED( hRes ) )
{
OutputDebugString( "Present() call failed\n" );
return;
}
}
//-----------------------------------------------------------------------------
// Purpose: Creates a new vertex buffer
//-----------------------------------------------------------------------------
HGAMEVERTBUF CGameEngineWin32::HCreateVertexBuffer( uint32 nSizeInBytes, DWORD dwUsage, DWORD dwFVF )
{
if ( !m_pD3D9Device )
return false;
// Create a vertex buffer object
IDirect3DVertexBuffer9 *pVertBuffer;
HRESULT hRes = m_pD3D9Device->CreateVertexBuffer( nSizeInBytes, dwUsage,
dwFVF, D3DPOOL_DEFAULT, &pVertBuffer, NULL );
if ( FAILED( hRes ) )
{
OutputDebugString( "Failed creating vertex buffer\n" );
return 0;
}
HGAMEFONT hVertBuf = m_nNextVertBufferHandle;
++m_nNextVertBufferHandle;
VertBufData_t data;
data.m_bIsLocked = false;
data.m_pBuffer = pVertBuffer;
m_MapVertexBuffers[ hVertBuf ] = data;
return hVertBuf;
}
//-----------------------------------------------------------------------------
// Purpose: Locks an entire vertex buffer with the specified flags into memory
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BLockEntireVertexBuffer( HGAMEVERTBUF hVertBuf, void **ppVoid, DWORD dwFlags )
{
if ( !m_pD3D9Device )
return false;
if ( m_bDeviceLost )
return false;
if ( !hVertBuf )
{
OutputDebugString( "Someone is calling BLockEntireVertexBuffer() with a null handle\n" );
return false;
}
// Find the font object for the passed handle
std::map<HGAMEVERTBUF, VertBufData_t>::iterator iter;
iter = m_MapVertexBuffers.find( hVertBuf );
if ( iter == m_MapVertexBuffers.end() )
{
OutputDebugString( "Invalid vertex buffer handle passed to BLockEntireVertexBuffer()\n" );
return false;
}
// Make sure the pointer is valid
if ( !iter->second.m_pBuffer )
{
OutputDebugString( "Pointer to vertex buffer is invalid (lost device and not recreated?)!\n" );
return false;
}
// Make sure its not already locked
if ( iter->second.m_bIsLocked )
{
OutputDebugString( "Trying to lock an already locked vertex buffer!\n" );
return false;
}
// we have the buffer, try to lock it
if( FAILED( iter->second.m_pBuffer->Lock( 0, 0, ppVoid, dwFlags ) ) )
{
OutputDebugString( "BLockEntireVertexBuffer call failed\n" );
return false;
}
// Track that we are now locked
iter->second.m_bIsLocked = true;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Unlocks a vertex buffer
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BUnlockVertexBuffer( HGAMEVERTBUF hVertBuf )
{
if ( !m_pD3D9Device )
return false;
if ( m_bDeviceLost )
return false;
if ( !hVertBuf )
{
OutputDebugString( "Someone is calling BUnlockVertexBuffer() with a null handle\n" );
return false;
}
// Find the vertex buffer for the passed handle
std::map<HGAMEVERTBUF, VertBufData_t>::iterator iter;
iter = m_MapVertexBuffers.find( hVertBuf );
if ( iter == m_MapVertexBuffers.end() )
{
OutputDebugString( "Invalid vertex buffer handle passed to BUnlockVertexBuffer()\n" );
return false;
}
// Make sure the pointer is valid
if ( !iter->second.m_pBuffer )
{
OutputDebugString( "Pointer to vertex buffer is invalid (lost device and not recreated?)!\n" );
return false;
}
// Make sure we are locked if someone is trying to unlock
if ( !iter->second.m_bIsLocked )
{
OutputDebugString( "Trying to unlock a vertex buffer that is not locked!\n" );
return false;
}
// we have the buffer, try to lock it
if( FAILED( iter->second.m_pBuffer->Unlock() ) )
{
OutputDebugString( "BUnlockVertexBuffer call failed\n" );
return false;
}
// Track that we are now unlocked
iter->second.m_bIsLocked = false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Release a vertex buffer and free its resources
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BReleaseVertexBuffer( HGAMEVERTBUF hVertBuf )
{
if ( !m_pD3D9Device )
return false;
if ( m_bDeviceLost )
return false;
if ( !hVertBuf )
{
OutputDebugString( "Someone is calling BReleaseVertexBuffer() with a null handle\n" );
return false;
}
// Find the vertex buffer object for the passed handle
std::map<HGAMEVERTBUF, VertBufData_t>::iterator iter;
iter = m_MapVertexBuffers.find( hVertBuf );
if ( iter == m_MapVertexBuffers.end() )
{
OutputDebugString( "Invalid vertex buffer handle passed to BReleaseVertexBuffer()\n" );
return false;
}
// Make sure the pointer is valid
if ( !iter->second.m_pBuffer )
{
OutputDebugString( "Pointer to vertex buffer is invalid (lost device and not recreated?)!\n" );
return false;
}
// Make sure its unlocked, if it isn't locked this will just fail quietly
if ( iter->second.m_bIsLocked )
iter->second.m_pBuffer->Unlock();
// Release the resources
iter->second.m_pBuffer->Release();
// Remove from the map
m_MapVertexBuffers.erase( iter );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Set the FVF
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BSetFVF( DWORD dwFormat )
{
if ( !m_pD3D9Device )
return false;
// Can't set the FVF when the device is lost
if ( m_bDeviceLost )
return false;
// Short circuit if the request is a noop
if ( m_dwCurrentFVF == dwFormat )
return true;
if ( FAILED( m_pD3D9Device->SetFVF( dwFormat ) ) )
{
OutputDebugString( "SetFVF() call failed\n" );
return false;
}
m_dwCurrentFVF = dwFormat;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Draw a line, the engine internally manages a vertex buffer for batching these
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BDrawLine( float xPos0, float yPos0, DWORD dwColor0, float xPos1, float yPos1, DWORD dwColor1 )
{
if ( !m_pD3D9Device )
return false;
if ( m_bDeviceLost )
return true; // Fail silently in this case
if ( !m_hLineBuffer )
{
// Create the line buffer
m_hLineBuffer = HCreateVertexBuffer( sizeof( LineVertex_t ) * LINE_BUFFER_TOTAL_SIZE * 2, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_XYZRHW | D3DFVF_DIFFUSE );
if ( !m_hLineBuffer )
{
OutputDebugString( "Can't BDrawLine() because vertex buffer creation failed\n" );
return false;
}
}
// Check if we are out of room and need to flush the buffer
if ( m_dwLinesToFlush == LINE_BUFFER_BATCH_SIZE )
{
BFlushLineBuffer();
}
// Set FVF
if ( !BSetFVF( D3DFVF_XYZRHW | D3DFVF_DIFFUSE ) )
return false;
// Lock the vertex buffer into memory
if ( !m_pLineVertexes )
{
if ( !BLockEntireVertexBuffer( m_hLineBuffer, (void**)&m_pLineVertexes, m_dwLineBufferBatchPos ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) )
{
m_pLineVertexes = NULL;
OutputDebugString( "BDrawLine failed because locking vertex buffer failed\n" );
return false;
}
}
LineVertex_t *pVertData = &m_pLineVertexes[ m_dwLineBufferBatchPos*2+m_dwLinesToFlush*2 ];
pVertData[0].rhw = 1.0;
pVertData[0].z = 1.0;
pVertData[0].x = xPos0;
pVertData[0].y = yPos0;
pVertData[0].color = dwColor0;
pVertData[1].rhw = 1.0;
pVertData[1].z = 1.0;
pVertData[1].x = xPos1;
pVertData[1].y = yPos1;
pVertData[1].color = dwColor1;
++m_dwLinesToFlush;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Flush batched lines to the screen
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BFlushLineBuffer()
{
// If the vert buffer isn't already locked into memory, then there is nothing to flush
if ( m_pLineVertexes == NULL )
return true; // consider this successful since there was no error
// OK, it is locked, so unlock now
if ( !BUnlockVertexBuffer( m_hLineBuffer ) )
{
OutputDebugString( "Failed flushing line buffer because BUnlockVertexBuffer failed\n" );
return false;
}
// Clear the memory pointer as its invalid now that we unlocked
m_pLineVertexes = NULL;
// If there is nothing to actual flush, we are done
if ( m_dwLinesToFlush == 0 )
return true;
// Set FVF (will short circuit if this is already the set FVF)
if ( !BSetFVF( D3DFVF_XYZRHW | D3DFVF_DIFFUSE ) )
{
OutputDebugString( "Failed flushing line buffer because BSetFVF failed\n" );
return false;
}
if ( !BSetStreamSource( m_hLineBuffer, 0, sizeof( LineVertex_t ) ) )
{
OutputDebugString( "Failed flushing line buffer because BSetStreamSource failed\n" );
return false;
}
// Actual render calls
if ( !BRenderPrimitive( D3DPT_LINELIST, m_dwLineBufferBatchPos*2, m_dwLinesToFlush ) )
{
OutputDebugString( "Failed flushing line buffer because BRenderPrimitive failed\n" );
return false;
}
m_dwLinesToFlush = 0;
m_dwLineBufferBatchPos += LINE_BUFFER_BATCH_SIZE;
if ( m_dwLineBufferBatchPos >= LINE_BUFFER_TOTAL_SIZE )
{
m_dwLineBufferBatchPos = 0;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Draw a point, the engine internally manages a vertex buffer for batching these
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BDrawPoint( float xPos, float yPos, DWORD dwColor )
{
if ( !m_pD3D9Device )
return false;
if ( m_bDeviceLost )
return true; // Fail silently in this case
if ( !m_hPointBuffer )
{
// Create the point buffer
m_hPointBuffer = HCreateVertexBuffer( sizeof( PointVertex_t ) * POINT_BUFFER_TOTAL_SIZE * 2, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_XYZRHW | D3DFVF_DIFFUSE );
if ( !m_hPointBuffer )
{
OutputDebugString( "Can't BDrawPoint() because vertex buffer creation failed\n" );
return false;
}
}
// Check if we are out of room and need to flush the buffer
if ( m_dwPointsToFlush == POINT_BUFFER_BATCH_SIZE )
{
BFlushPointBuffer();
}
// Set FVF
if ( !BSetFVF( D3DFVF_XYZRHW | D3DFVF_DIFFUSE ) )
return false;
// Lock the vertex buffer into memory
if ( !m_pPointVertexes )
{
if ( !BLockEntireVertexBuffer( m_hPointBuffer, (void**)&m_pPointVertexes, (m_dwPointBufferBatchPos+m_dwPointsToFlush) ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) )
{
m_pPointVertexes = NULL;
OutputDebugString( "BDrawPoint failed because locking vertex buffer failed\n" );
return false;
}
}
PointVertex_t *pVertData = &m_pPointVertexes[ m_dwPointBufferBatchPos+m_dwPointsToFlush ];
pVertData[0].rhw = 1.0;
pVertData[0].z = 1.0;
pVertData[0].x = xPos;
pVertData[0].y = yPos;
pVertData[0].color = dwColor;
++m_dwPointsToFlush;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Flush batched points to the screen
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BFlushPointBuffer()
{
// If the vert buffer isn't already locked into memory, then there is nothing to flush
if ( m_pPointVertexes == NULL )
return true; // consider this successful since there was no error
// OK, it is locked, so unlock now
if ( !BUnlockVertexBuffer( m_hPointBuffer ) )
{
OutputDebugString( "Failed flushing point buffer because BUnlockVertexBuffer failed\n" );
return false;
}
// Clear the memory pointer as its invalid now that we unlocked
m_pPointVertexes = NULL;
// If there is nothing to actual flush, we are done
if ( m_dwPointsToFlush == 0 )
return true;
// Set FVF (will short circuit if this is already the set FVF)
if ( !BSetFVF( D3DFVF_XYZRHW | D3DFVF_DIFFUSE ) )
{
OutputDebugString( "Failed flushing point buffer because BSetFVF failed\n" );
return false;
}
if ( !BSetStreamSource( m_hPointBuffer, 0, sizeof( PointVertex_t ) ) )
{
OutputDebugString( "Failed flushing point buffer because BSetStreamSource failed\n" );
return false;
}
// Actual render calls
if ( !BRenderPrimitive( D3DPT_POINTLIST, m_dwPointBufferBatchPos, m_dwPointsToFlush ) )
{
OutputDebugString( "Failed flushing point buffer because BRenderPrimitive failed\n" );
return false;
}
m_dwPointsToFlush = 0;
m_dwPointBufferBatchPos += POINT_BUFFER_BATCH_SIZE;
if ( m_dwPointBufferBatchPos >= POINT_BUFFER_TOTAL_SIZE )
{
m_dwPointBufferBatchPos = 0;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Draw a filled quad
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BDrawFilledRect( float xPos0, float yPos0, float xPos1, float yPos1, DWORD dwColor )
{
if ( !m_hTextureWhite )
{
byte *pRGBAData = new byte[ 1 * 1 * 4 ];
memset( pRGBAData, 255, 1*1*4 );
m_hTextureWhite = HCreateTexture( pRGBAData, 1, 1 );
delete[] pRGBAData;
}
return BDrawTexturedRect( xPos0, yPos0, xPos1, yPos1, 0.0f, 0.0f, 1.0f, 1.0f, dwColor, m_hTextureWhite );
}
//-----------------------------------------------------------------------------
// Purpose: Draw a textured quad
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BDrawTexturedRect( float xPos0, float yPos0, float xPos1, float yPos1, float u0, float v0, float u1, float v1, DWORD dwColor, HGAMETEXTURE hTexture )
{
if ( !m_pD3D9Device )
return false;
if ( m_bDeviceLost )
return true; // Fail silently in this case
// Find the texture
std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
iter = m_MapTextures.find( hTexture );
if ( iter == m_MapTextures.end() )
{
OutputDebugString( "BDrawTexturedQuad called with invalid hTexture value\n" );
return false;
}
if ( !m_hQuadBuffer )
{
// Create the line buffer
m_hQuadBuffer = HCreateVertexBuffer( sizeof(TexturedQuadVertex_t)* QUAD_BUFFER_TOTAL_SIZE * 4, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1 );
if ( !m_hQuadBuffer )
{
OutputDebugString( "Can't BDrawTexturedQuad() because vertex buffer creation failed\n" );
return false;
}
}
// Check if we are out of room and need to flush the buffer
if ( m_dwQuadsToFlush == QUAD_BUFFER_BATCH_SIZE )
{
BFlushQuadBuffer();
}
// Check if the texture changed so we need to flush the buffer
if ( m_hLastTexture != hTexture )
{
BFlushQuadBuffer();
}
// Save the texture to use for next flush
m_hLastTexture = hTexture;
if ( !BSetFVF( D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1 ) )
{
OutputDebugString( "Setting FVF failed for textured rect drawing\n" );
return false;
}
// Lock the vertex buffer into memory
if ( !m_pQuadVertexes )
{
if ( !BLockEntireVertexBuffer( m_hQuadBuffer, (void**)&m_pQuadVertexes, m_dwQuadBufferBatchPos ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) )
{
m_pQuadVertexes = NULL;
OutputDebugString( "BDrawTexturedQuad failed because locking vertex buffer failed\n" );
return false;
}
}
TexturedQuadVertex_t *pVertData = &m_pQuadVertexes[m_dwQuadBufferBatchPos * 4 + m_dwQuadsToFlush * 4];
pVertData[0].color = dwColor;
pVertData[0].rhw = 1.0f;
pVertData[0].z = 1.0f;
pVertData[0].x = xPos0;
pVertData[0].y = yPos0;
pVertData[0].u = u0;
pVertData[0].v = v0;
pVertData[1].color = dwColor;
pVertData[1].rhw = 1.0f;
pVertData[1].z = 1.0f;
pVertData[1].x = xPos1;
pVertData[1].y = yPos0;
pVertData[1].u = u1;
pVertData[1].v = v0;
pVertData[2].color = dwColor;
pVertData[2].rhw = 1.0f;
pVertData[2].z = 1.0f;
pVertData[2].x = xPos0;
pVertData[2].y = yPos1;
pVertData[2].u = u0;
pVertData[2].v = v1;
pVertData[3].color = dwColor;
pVertData[3].rhw = 1.0f;
pVertData[3].z = 1.0f;
pVertData[3].x = xPos1;
pVertData[3].y = yPos1;
pVertData[3].u = u1;
pVertData[3].v = v1;
++m_dwQuadsToFlush;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Draw a textured quad
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BDrawTexturedQuad( float xPos0, float yPos0, float xPos1, float yPos1, float xPos2, float yPos2 , float xPos3, float yPos3,
float u0, float v0, float u1, float v1, DWORD dwColor, HGAMETEXTURE hTexture )
{
if ( !m_pD3D9Device )
return false;
if ( m_bDeviceLost )
return true; // Fail silently in this case
// Find the texture
std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
iter = m_MapTextures.find( hTexture );
if ( iter == m_MapTextures.end() )
{
OutputDebugString( "BDrawTexturedQuad called with invalid hTexture value\n" );
return false;
}
if ( !m_hQuadBuffer )
{
// Create the line buffer
m_hQuadBuffer = HCreateVertexBuffer( sizeof(TexturedQuadVertex_t)* QUAD_BUFFER_TOTAL_SIZE * 4, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1 );
if ( !m_hQuadBuffer )
{
OutputDebugString( "Can't BDrawTexturedQuad() because vertex buffer creation failed\n" );
return false;
}
}
// Check if we are out of room and need to flush the buffer
if ( m_dwQuadsToFlush == QUAD_BUFFER_BATCH_SIZE )
{
BFlushQuadBuffer();
}
// Check if the texture changed so we need to flush the buffer
if ( m_hLastTexture != hTexture )
{
BFlushQuadBuffer();
}
// Save the texture to use for next flush
m_hLastTexture = hTexture;
if ( !BSetFVF( D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1 ) )
{
OutputDebugString( "Setting FVF failed for textured rect drawing\n" );
return false;
}
// Lock the vertex buffer into memory
if ( !m_pQuadVertexes )
{
if ( !BLockEntireVertexBuffer( m_hQuadBuffer, (void**)&m_pQuadVertexes, m_dwQuadBufferBatchPos ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) )
{
m_pQuadVertexes = NULL;
OutputDebugString( "BDrawTexturedQuad failed because locking vertex buffer failed\n" );
return false;
}
}
TexturedQuadVertex_t *pVertData = &m_pQuadVertexes[m_dwQuadBufferBatchPos * 4 + m_dwQuadsToFlush * 4];
pVertData[0].color = dwColor;
pVertData[0].rhw = 1.0f;
pVertData[0].z = 1.0f;
pVertData[0].x = xPos0;
pVertData[0].y = yPos0;
pVertData[0].u = u0;
pVertData[0].v = v0;
pVertData[1].color = dwColor;
pVertData[1].rhw = 1.0f;
pVertData[1].z = 1.0f;
pVertData[1].x = xPos1;
pVertData[1].y = yPos1;
pVertData[1].u = u1;
pVertData[1].v = v0;
pVertData[2].color = dwColor;
pVertData[2].rhw = 1.0f;
pVertData[2].z = 1.0f;
pVertData[2].x = xPos2;
pVertData[2].y = yPos2;
pVertData[2].u = u0;
pVertData[2].v = v1;
pVertData[3].color = dwColor;
pVertData[3].rhw = 1.0f;
pVertData[3].z = 1.0f;
pVertData[3].x = xPos3;
pVertData[3].y = yPos3;
pVertData[3].u = u1;
pVertData[3].v = v1;
++m_dwQuadsToFlush;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Draw a 3D textured quad
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BDraw3DTexturedQuad( Textured3DQuadVertex_t vert[4], HGAMETEXTURE hTexture )
{
if ( !m_pD3D9Device )
return false;
if ( m_bDeviceLost )
return true; // Fail silently in this case
// Find the texture
std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
iter = m_MapTextures.find( hTexture );
if ( iter == m_MapTextures.end() )
{
OutputDebugString( "BDrawTexturedQuad called with invalid hTexture value\n" );
return false;
}
if ( !m_h3DQuadBuffer )
{
// Create the line buffer
m_h3DQuadBuffer = HCreateVertexBuffer( sizeof(Textured3DQuadVertex_t)* QUAD_BUFFER_TOTAL_SIZE * 4, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1 );
if ( !m_h3DQuadBuffer )
{
OutputDebugString( "Can't BDraw3DTexturedQuad() because vertex buffer creation failed\n" );
return false;
}
}
// Check if we are out of room and need to flush the buffer
if ( m_dw3DQuadsToFlush == QUAD_BUFFER_BATCH_SIZE )
{
BFlush3DQuadBuffer();
}
// Check if the texture changed so we need to flush the buffer
if ( m_h3DLastTexture != hTexture )
{
BFlush3DQuadBuffer( );
}
// Save the texture to use for next flush
m_h3DLastTexture = hTexture;
if ( !BSetFVF( D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1 ) )
{
OutputDebugString( "Setting FVF failed for textured rect drawing\n" );
return false;
}
// Lock the vertex buffer into memory
if ( !m_p3DQuadVertexes )
{
if ( !BLockEntireVertexBuffer( m_h3DQuadBuffer, (void**)&m_p3DQuadVertexes, m_dw3DQuadBufferBatchPos ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) )
{
m_p3DQuadVertexes = NULL;
OutputDebugString( "BDrawTexturedQuad failed because locking vertex buffer failed\n" );
return false;
}
}
Textured3DQuadVertex_t *pVertData = &m_p3DQuadVertexes[m_dw3DQuadBufferBatchPos * 4 + m_dw3DQuadsToFlush * 4];
for ( int i = 0; i < 4; i++ )
{
pVertData[i] = vert[i];
}
++m_dw3DQuadsToFlush;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Flush buffered quads
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BFlushQuadBuffer()
{
// If the vert buffer isn't already locked into memory, then there is nothing to flush
if ( m_pQuadVertexes == NULL )
return true; // consider this successful since there was no error
// OK, it is locked, so unlock now
if ( !BUnlockVertexBuffer( m_hQuadBuffer ) )
{
OutputDebugString( "Failed flushing quad buffer because BUnlockVertexBuffer failed\n" );
return false;
}
// Clear the memory pointer as its invalid now that we unlocked
m_pQuadVertexes = NULL;
// If there is nothing to actual flush, we are done
if ( m_dwQuadsToFlush == 0 )
return true;
// Set FVF (will short circuit if this is already the set FVF)
if ( !BSetFVF( D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1 ) )
{
OutputDebugString( "Failed flushing quad buffer because BSetFVF failed\n" );
return false;
}
// Find the texture
if ( !BSetTexture( m_hLastTexture ) )
return false;
if ( !BSetStreamSource( m_hQuadBuffer, 0, sizeof(TexturedQuadVertex_t) ) )
{
OutputDebugString( "Failed flushing quad buffer because BSetStreamSource failed\n" );
m_pD3D9Device->SetTexture( 0, NULL ); // need to clear the texture before other drawing ops
return false;
}
// Actual render calls
for ( DWORD i=0; i < m_dwQuadsToFlush*4; i += 4 )
{
if ( !BRenderPrimitive( D3DPT_TRIANGLESTRIP, (m_dwQuadBufferBatchPos*4)+i, 2 ) )
{
OutputDebugString( "Failed flushing line buffer because BRenderPrimitive failed\n" );
m_pD3D9Device->SetTexture( 0, NULL ); // need to clear the texture before other drawing ops
return false;
}
}
m_pD3D9Device->SetTexture( 0, NULL ); // need to clear the texture before other drawing ops
m_dwQuadsToFlush = 0;
m_dwQuadBufferBatchPos += QUAD_BUFFER_BATCH_SIZE;
if ( m_dwQuadBufferBatchPos >= QUAD_BUFFER_TOTAL_SIZE )
{
m_dwQuadBufferBatchPos = 0;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Flush buffered 3D quads
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BFlush3DQuadBuffer()
{
// If the vert buffer isn't already locked into memory, then there is nothing to flush
if ( m_p3DQuadVertexes == NULL )
return true; // consider this successful since there was no error
// OK, it is locked, so unlock now
if ( !BUnlockVertexBuffer( m_h3DQuadBuffer ) )
{
OutputDebugString( "Failed flushing quad buffer because BUnlockVertexBuffer failed\n" );
return false;
}
// Clear the memory pointer as its invalid now that we unlocked
m_p3DQuadVertexes = NULL;
// If there is nothing to actual flush, we are done
if ( m_dw3DQuadsToFlush == 0 )
return true;
// Set FVF (will short circuit if this is already the set FVF)
if ( !BSetFVF( D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1 ) )
{
OutputDebugString( "Failed flushing quad buffer because BSetFVF failed\n" );
return false;
}
// Find the texture
if ( !BSetTexture( m_h3DLastTexture ) )
return false;
if ( !BSetStreamSource( m_h3DQuadBuffer, 0, sizeof(Textured3DQuadVertex_t) ) )
{
OutputDebugString( "Failed flushing 3D quad buffer because BSetStreamSource failed\n" );
m_pD3D9Device->SetTexture( 0, NULL ); // need to clear the texture before other drawing ops
return false;
}
// Actual render calls
for ( DWORD i = 0; i < m_dw3DQuadsToFlush * 4; i += 4 )
{
if ( !BRenderPrimitive( D3DPT_TRIANGLESTRIP, (m_dw3DQuadBufferBatchPos * 4) + i, 2 ) )
{
OutputDebugString( "Failed flushing line buffer because BRenderPrimitive failed\n" );
m_pD3D9Device->SetTexture( 0, NULL ); // need to clear the texture before other drawing ops
return false;
}
}
m_pD3D9Device->SetTexture( 0, NULL ); // need to clear the texture before other drawing ops
m_dw3DQuadsToFlush = 0;
m_dw3DQuadBufferBatchPos += QUAD_BUFFER_BATCH_SIZE;
if ( m_dw3DQuadBufferBatchPos >= QUAD_BUFFER_TOTAL_SIZE )
{
m_dw3DQuadBufferBatchPos = 0;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Set the current stream source (this always set stream 0, we don't support more than 1 stream presently)
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BSetStreamSource( HGAMEVERTBUF hVertBuf, uint32 uOffset, uint32 uStride )
{
if ( !m_pD3D9Device )
return false;
if ( m_bDeviceLost )
return false;
if ( !hVertBuf )
{
OutputDebugString( "Someone is calling BSetStreamSource() with a null handle\n" );
return false;
}
// Find the vertex buffer for the passed handle
std::map<HGAMEVERTBUF, VertBufData_t>::iterator iter;
iter = m_MapVertexBuffers.find( hVertBuf );
if ( iter == m_MapVertexBuffers.end() )
{
OutputDebugString( "Invalid vertex buffer handle passed to BSetStreamSource()\n" );
return false;
}
// Make sure the pointer is valid
if ( !iter->second.m_pBuffer )
{
OutputDebugString( "Pointer to vertex buffer is invalid (lost device and not recreated?)!\n" );
return false;
}
if ( FAILED( m_pD3D9Device->SetStreamSource( 0, iter->second.m_pBuffer, uOffset, uStride ) ) )
{
OutputDebugString( "SetStreamSource() call failed\n" );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Renders primitives using the current stream source
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BRenderPrimitive( D3DPRIMITIVETYPE primType, uint32 uStartVertex, uint32 uCount )
{
if ( !m_pD3D9Device )
return false;
if ( m_bDeviceLost )
return true; // Fail silently in this case
if ( FAILED( m_pD3D9Device->DrawPrimitive( primType, uStartVertex, uCount ) ) )
{
OutputDebugString( "BRenderPrimtive() call failed\n" );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Creates a new texture
//-----------------------------------------------------------------------------
HGAMETEXTURE CGameEngineWin32::HCreateTexture( byte *pRGBAData, uint32 uWidth, uint32 uHeight, ETEXTUREFORMAT eTextureFormat )
{
if ( !m_pD3D9Device )
return 0;
D3DFORMAT eD3DDeviceFormat = D3DFMT_A8R8G8B8;
switch ( eTextureFormat )
{
case eTextureFormat_RGBA:
case eTextureFormat_BGRA:
eD3DDeviceFormat = D3DFMT_A8R8G8B8;
break;
case eTextureFormat_BGRA16:
eD3DDeviceFormat = D3DFMT_A16B16G16R16;
}
TextureData_t TexData;
TexData.m_uWidth = uWidth;
TexData.m_uHeight = uHeight;
if ( pRGBAData )
{
size_t dataSize = 0;
if ( eD3DDeviceFormat == D3DFMT_A8R8G8B8 )
{
dataSize = uWidth*uHeight * 4;
}
else if ( eD3DDeviceFormat == D3DFMT_A16B16G16R16 )
{
dataSize = sizeof(uint16)* 4 * uWidth * uHeight;
}
TexData.m_pRGBAData = new byte[dataSize];
memcpy( TexData.m_pRGBAData, pRGBAData, dataSize );
}
else
{
TexData.m_pRGBAData = NULL;
}
TexData.m_pTexture = NULL;
TexData.m_pDepthSurface = NULL;
TexData.m_eFormat = eD3DDeviceFormat;
TexData.m_eTextureFormat = eTextureFormat;
int nHandle = m_nNextTextureHandle;
++m_nNextTextureHandle;
m_MapTextures[nHandle] = TexData;
return nHandle;
}
//-----------------------------------------------------------------------------
// Purpose: Creates a new font
//-----------------------------------------------------------------------------
HGAMEFONT CGameEngineWin32::HCreateFont( int nHeight, int nFontWeight, bool bItalic, const char * pchFont )
{
if ( !m_pD3D9Device )
return 0;
// Create a D3DX font object
LPD3DXFONT pFont;
HRESULT hRes = D3DXCreateFont( m_pD3D9Device, nHeight, 0, nFontWeight, 0, bItalic, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pchFont, &pFont );
if ( FAILED( hRes ) )
{
OutputDebugString( "Failed creating font via D3DXCreateFont\n" );
return 0;
}
HGAMEFONT hFont = m_nNextFontHandle;
++m_nNextFontHandle;
m_MapFontInstances[ hFont ] = pFont;
return hFont;
}
//-----------------------------------------------------------------------------
// Purpose: Draws text to the screen inside the given rectangular region, using the given font
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BDrawString( HGAMEFONT hFont, RECT rect, DWORD dwColor, DWORD dwFormat, const char *pchText )
{
if ( !m_pD3D9Device )
return false;
if ( m_bDeviceLost )
return true; // Fail silently in this case
if ( !hFont )
{
OutputDebugString( "Someone is calling BDrawString with a null font handle\n" );
return false;
}
// Find the font object for the passed handle
std::map<HGAMEFONT, LPD3DXFONT>::iterator iter;
iter = m_MapFontInstances.find( hFont );
if ( iter == m_MapFontInstances.end() )
{
OutputDebugString( "Invalid font handle passed to BDrawString()\n" );
return false;
}
// we have the font, try to draw with it
if( !iter->second->DrawText( NULL, pchText, -1, &rect, dwFormat, dwColor ) )
{
OutputDebugString( "DrawText call failed\n" );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Message pump for OS messages
//-----------------------------------------------------------------------------
void CGameEngineWin32::MessagePump()
{
MSG msg;
BOOL bRet;
while( PeekMessage( &msg, m_hWnd, 0, 0, PM_NOREMOVE ) )
{
bRet = GetMessage( &msg, m_hWnd, 0, 0 );
if( bRet != 0 && bRet != -1 )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Return true if there is an active Steam Controller
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BIsSteamInputDeviceActive( )
{
if ( m_ActiveControllerHandle )
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Initialize the steam controller actions
//-----------------------------------------------------------------------------
void CGameEngineWin32::InitSteamInput( )
{
// Digital game actions
m_ControllerDigitalActionHandles[eControllerDigitalAction_TurnLeft] = SteamInput()->GetDigitalActionHandle( "turn_left" );
m_ControllerDigitalActionHandles[eControllerDigitalAction_TurnRight] = SteamInput()->GetDigitalActionHandle( "turn_right" );
m_ControllerDigitalActionHandles[eControllerDigitalAction_ForwardThrust] = SteamInput()->GetDigitalActionHandle( "forward_thrust" );
m_ControllerDigitalActionHandles[eControllerDigitalAction_ReverseThrust] = SteamInput()->GetDigitalActionHandle( "backward_thrust" );
m_ControllerDigitalActionHandles[eControllerDigitalAction_FireLasers] = SteamInput()->GetDigitalActionHandle( "fire_lasers" );
m_ControllerDigitalActionHandles[eControllerDigitalAction_PauseMenu] = SteamInput()->GetDigitalActionHandle( "pause_menu" );
m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuUp] = SteamInput()->GetDigitalActionHandle( "menu_up" );
m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuDown] = SteamInput()->GetDigitalActionHandle( "menu_down" );
m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuLeft] = SteamInput()->GetDigitalActionHandle( "menu_left" );
m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuRight] = SteamInput()->GetDigitalActionHandle( "menu_right" );
m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuSelect] = SteamInput()->GetDigitalActionHandle( "menu_select" );
m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuCancel] = SteamInput()->GetDigitalActionHandle( "menu_cancel" );
// Analog game actions
m_ControllerAnalogActionHandles[eControllerAnalogAction_AnalogControls] = SteamInput()->GetAnalogActionHandle( "analog_controls" );
// Action set handles
m_ControllerActionSetHandles[eControllerActionSet_ShipControls] = SteamInput()->GetActionSetHandle( "ship_controls" );
m_ControllerActionSetHandles[eControllerActionSet_MenuControls] = SteamInput()->GetActionSetHandle( "menu_controls" );
// Action set layer handle
m_ControllerActionSetHandles[eControllerActionSet_Layer_Thrust] = SteamInput()->GetActionSetHandle( "thrust_action_layer" );
}
//-----------------------------------------------------------------------------
// Purpose: Find an active Steam controller
//-----------------------------------------------------------------------------
void CGameEngineWin32::FindActiveSteamInputDevice()
{
// Use the first available steam controller for all interaction. We can call this each frame to handle
// a controller disconnecting and a different one reconnecting. Handles are guaranteed to be unique for
// a given controller, even across power cycles.
// See how many Steam Controllers are active.
InputHandle_t pHandles[STEAM_CONTROLLER_MAX_COUNT];
int nNumActive = SteamInput( )->GetConnectedControllers( pHandles );
// If there's an active controller, and if we're not already using it, select the first one.
if ( nNumActive && ( m_ActiveControllerHandle != pHandles[0] ) )
{
m_ActiveControllerHandle = pHandles[ 0 ];
}
return;
}
// These are human-readable names for each of the origin enumerations. It is preferred to
// show the supplied icons in-game, but for a simple application these strings can be useful.
//--------------------------------------------------------------------------------------------------------------
// Purpose: For a given in-game action in a given action set, return a human-reaadable string to use as a prompt.
//--------------------------------------------------------------------------------------------------------------
const char *CGameEngineWin32::GetTextStringForControllerOriginDigital( ECONTROLLERACTIONSET dwActionSet, ECONTROLLERDIGITALACTION dwDigitalAction )
{
EInputActionOrigin origins[STEAM_CONTROLLER_MAX_ORIGINS];
int nNumOrigins = SteamInput( )->GetDigitalActionOrigins( m_ActiveControllerHandle, m_ControllerActionSetHandles[dwActionSet], m_ControllerDigitalActionHandles[dwDigitalAction], origins );
if ( nNumOrigins )
{
// We should handle the case where this action is bound to multiple buttons, but
// here we just grab the first.
return SteamInput()->GetStringForActionOrigin( origins[0] );
}
return SteamInput()->GetStringForActionOrigin( k_EInputActionOrigin_None ); // Return "None"
}
//--------------------------------------------------------------------------------------------------------------
// Purpose: For a given in-game action in a given action set, return a human-reaadable string to use as a prompt.
//--------------------------------------------------------------------------------------------------------------
const char *CGameEngineWin32::GetTextStringForControllerOriginAnalog( ECONTROLLERACTIONSET dwActionSet, ECONTROLLERANALOGACTION dwDigitalAction )
{
EInputActionOrigin origins[STEAM_CONTROLLER_MAX_ORIGINS];
int nNumOrigins = SteamInput( )->GetAnalogActionOrigins( m_ActiveControllerHandle, m_ControllerActionSetHandles[dwActionSet], m_ControllerDigitalActionHandles[dwDigitalAction], origins );
if ( nNumOrigins )
{
// We should handle the case where this action is bound to multiple buttons, but
// here we just grab the first.
return SteamInput()->GetStringForActionOrigin( origins[0] );
}
return SteamInput()->GetStringForActionOrigin( k_EInputActionOrigin_None ); // Return "None"
}
//-----------------------------------------------------------------------------
// Purpose: Called each frame
//-----------------------------------------------------------------------------
void CGameEngineWin32::PollSteamInput()
{
// Each frame check our active controller handle
FindActiveSteamInputDevice();
}
//-----------------------------------------------------------------------------
// Purpose: Set the LED color on the controller, if supported by controller
//-----------------------------------------------------------------------------
void CGameEngineWin32::SetControllerColor( uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags )
{
SteamInput()->SetLEDColor( m_ActiveControllerHandle, nColorR, nColorG, nColorB, nFlags );
}
//-----------------------------------------------------------------------------
// Purpose: Set the trigger effect on DualSense controllers
//-----------------------------------------------------------------------------
void CGameEngineWin32::SetTriggerEffect( bool bEnabled )
{
ScePadTriggerEffectParam param;
memset( &param, 0, sizeof( param ) );
param.triggerMask = SCE_PAD_TRIGGER_EFFECT_TRIGGER_MASK_R2;
// Clear any existing effect
param.command[ SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_R2 ].mode = SCE_PAD_TRIGGER_EFFECT_MODE_OFF;
SteamInput()->SetDualSenseTriggerEffect( m_ActiveControllerHandle, &param );
if ( bEnabled )
{
param.command[ SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_R2 ].mode = SCE_PAD_TRIGGER_EFFECT_MODE_VIBRATION;
param.command[ SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_R2 ].commandData.vibrationParam.position = 5;
param.command[ SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_R2 ].commandData.vibrationParam.amplitude = 5;
param.command[ SCE_PAD_TRIGGER_EFFECT_PARAM_INDEX_FOR_R2 ].commandData.vibrationParam.frequency = 8;
SteamInput()->SetDualSenseTriggerEffect( m_ActiveControllerHandle, &param );
}
}
//-----------------------------------------------------------------------------
// Purpose: Trigger vibration on the controller, if supported by controller
//-----------------------------------------------------------------------------
void CGameEngineWin32::TriggerControllerVibration( unsigned short nLeftSpeed, unsigned short nRightSpeed )
{
SteamInput()->TriggerVibration( m_ActiveControllerHandle, nLeftSpeed, nRightSpeed );
}
//-----------------------------------------------------------------------------
// Purpose: Trigger haptics on the controller, if supported by controller
//-----------------------------------------------------------------------------
void CGameEngineWin32::TriggerControllerHaptics( ESteamControllerPad ePad, unsigned short usOnMicroSec, unsigned short usOffMicroSec, unsigned short usRepeat )
{
SteamInput()->Legacy_TriggerRepeatedHapticPulse( m_ActiveControllerHandle, ePad, usOnMicroSec, usOffMicroSec, usRepeat, 0 );
}
//-----------------------------------------------------------------------------
// Purpose: Find out if a controller event is currently active
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BIsControllerActionActive( ECONTROLLERDIGITALACTION dwAction )
{
ControllerDigitalActionData_t digitalData = SteamInput( )->GetDigitalActionData( m_ActiveControllerHandle, m_ControllerDigitalActionHandles[dwAction] );
// Actions are only 'active' when they're assigned to a control in an action set, and that action set is active.
if ( digitalData.bActive )
return digitalData.bState;
return false;
}
//---------------------------------------------------------------------------------------------------------------------------------------------------
// Purpose: Get the current x,y state of the analog action. Examples of an analog action are a virtual joystick on the trackpad or the real joystick.
//---------------------------------------------------------------------------------------------------------------------------------------------------
void CGameEngineWin32::GetControllerAnalogAction( ECONTROLLERANALOGACTION dwAction, float *x, float *y )
{
ControllerAnalogActionData_t analogData = SteamInput( )->GetAnalogActionData( m_ActiveControllerHandle, m_ControllerAnalogActionHandles[dwAction] );
// Actions are only 'active' when they're assigned to a control in an action set, and that action set is active.
if ( analogData.bActive )
{
*x = analogData.x;
*y = analogData.y;
}
else
{
*x = 0.0f;
*y = 0.0f;
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
// Purpose: Put the controller into a specific action set. Action sets are collections of game-context actions ie "walking", "flying" or "menu"
//-----------------------------------------------------------------------------------------------------------------------------------------------------
void CGameEngineWin32::SetSteamControllerActionSet( ECONTROLLERACTIONSET dwActionSet )
{
if ( m_ActiveControllerHandle == 0 )
return;
// This call is low-overhead and can be called repeatedly from game code that is active in a specific mode.
SteamInput()->ActivateActionSet( m_ActiveControllerHandle, m_ControllerActionSetHandles[dwActionSet] );
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
// Purpose: Put the controller into a specific action set layer. Action sets layers apply modifications to an existing action set.
//-----------------------------------------------------------------------------------------------------------------------------------------------------
void CGameEngineWin32::ActivateSteamControllerActionSetLayer( ECONTROLLERACTIONSET dwActionSetLayer )
{
if ( m_ActiveControllerHandle == 0 )
return;
// This call is low-overhead and can be called repeatedly from game code that is active in a specific mode.
SteamInput()->ActivateActionSetLayer( m_ActiveControllerHandle, m_ControllerActionSetHandles[ dwActionSetLayer ] );
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
// Purpose: Deactivate an existing action set layer
//-----------------------------------------------------------------------------------------------------------------------------------------------------
void CGameEngineWin32::DeactivateSteamControllerActionSetLayer( ECONTROLLERACTIONSET dwActionSetLayer )
{
if ( m_ActiveControllerHandle == 0 )
return;
// This call is low-overhead and can be called repeatedly from game code that is active in a specific mode.
SteamInput()->DeactivateActionSetLayer( m_ActiveControllerHandle, m_ControllerActionSetHandles[ dwActionSetLayer ] );
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
// Purpose: Determine whether an action set layer is currently active
//-----------------------------------------------------------------------------------------------------------------------------------------------------
bool CGameEngineWin32::BIsActionSetLayerActive( ECONTROLLERACTIONSET dwActionSetLayer )
{
if ( m_ActiveControllerHandle == 0 )
return false;
ControllerActionSetHandle_t pActionSetLayerHandles[ 32 ];
int nActiveLayerCount = SteamInput()->GetActiveActionSetLayers( m_ActiveControllerHandle, pActionSetLayerHandles );
for( int i = 0; i < nActiveLayerCount; i++ )
{
if ( pActionSetLayerHandles[i] == m_ControllerActionSetHandles[ dwActionSetLayer ] )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Track keys which are down
//-----------------------------------------------------------------------------
void CGameEngineWin32::RecordKeyDown( DWORD dwVK )
{
m_SetKeysDown.insert( dwVK );
}
//-----------------------------------------------------------------------------
// Purpose: Track keys which are up
//-----------------------------------------------------------------------------
void CGameEngineWin32::RecordKeyUp( DWORD dwVK )
{
std::set<DWORD>::iterator iter;
iter = m_SetKeysDown.find( dwVK );
if ( iter != m_SetKeysDown.end() )
m_SetKeysDown.erase( iter );
}
//-----------------------------------------------------------------------------
// Purpose: Find out if a key is currently down
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BIsKeyDown( DWORD dwVK )
{
std::set<DWORD>::iterator iter;
iter = m_SetKeysDown.find( dwVK );
if ( iter != m_SetKeysDown.end() )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Get a down key value
//-----------------------------------------------------------------------------
bool CGameEngineWin32::BGetFirstKeyDown( DWORD *pdwVK )
{
std::set<DWORD>::iterator iter;
iter = m_SetKeysDown.begin();
if ( iter != m_SetKeysDown.end() )
{
*pdwVK = *iter;
m_SetKeysDown.erase( iter );
return true;
}
else
{
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose: Find the engine instance tied to a given hwnd
//-----------------------------------------------------------------------------
CGameEngineWin32 * CGameEngineWin32::FindEngineInstanceForHWND( HWND hWnd )
{
std::map<HWND, CGameEngineWin32 *>::iterator iter;
iter = m_MapEngineInstances.find( hWnd );
if ( iter == m_MapEngineInstances.end() )
return NULL;
else
return iter->second;
}
//-----------------------------------------------------------------------------
// Purpose: Add the engine instance tied to a given hwnd to our static map
//-----------------------------------------------------------------------------
void CGameEngineWin32::AddInstanceToHWNDMap( CGameEngineWin32* pInstance, HWND hWnd )
{
m_MapEngineInstances[hWnd] = pInstance;
}
//-----------------------------------------------------------------------------
// Purpose: Removes the instance associated with a given HWND from the map
//-----------------------------------------------------------------------------
void CGameEngineWin32::RemoveInstanceFromHWNDMap( HWND hWnd )
{
std::map<HWND, CGameEngineWin32 *>::iterator iter;
iter = m_MapEngineInstances.find( hWnd );
if ( iter != m_MapEngineInstances.end() )
m_MapEngineInstances.erase( iter );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
HGAMEVOICECHANNEL CGameEngineWin32::HCreateVoiceChannel()
{
if ( !m_pXAudio2 )
return 0;
m_unVoiceChannelCount++;
CVoiceContext* pVoiceContext = new CVoiceContext;
// The format we sample voice in.
WAVEFORMATEX voicesampleformat =
{
WAVE_FORMAT_PCM, // wFormatTag
1, // nChannels
VOICE_OUTPUT_SAMPLE_RATE,// nSamplesPerSec
VOICE_OUTPUT_SAMPLE_RATE*BYTES_PER_SAMPLE, // nAvgBytesPerSec
2, // nBlockAlign
8*BYTES_PER_SAMPLE, // wBitsPerSample
sizeof(WAVEFORMATEX) // cbSize
};
if( FAILED( m_pXAudio2->CreateSourceVoice( &pVoiceContext->m_pSourceVoice, &voicesampleformat , 0, 1.0f, pVoiceContext ) ) )
{
delete pVoiceContext;
return 0; // failed
}
pVoiceContext->m_pSourceVoice->Start( 0, 0 );
m_MapVoiceChannel[m_unVoiceChannelCount] = pVoiceContext;
return m_unVoiceChannelCount;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CGameEngineWin32::DestroyVoiceChannel( HGAMEVOICECHANNEL hChannel )
{
std::map<HGAMEVOICECHANNEL, CVoiceContext* >::iterator iter;
iter = m_MapVoiceChannel.find( hChannel );
if ( iter != m_MapVoiceChannel.end() )
{
CVoiceContext* pVoiceContext = iter->second;
XAUDIO2_VOICE_STATE state;
for(;;)
{
pVoiceContext->m_pSourceVoice->GetState( &state );
if( !state.BuffersQueued )
break;
WaitForSingleObject( pVoiceContext->m_hBufferEndEvent, INFINITE );
}
pVoiceContext->m_pSourceVoice->Stop( 0 );
pVoiceContext->m_pSourceVoice->DestroyVoice();
delete pVoiceContext;
m_MapVoiceChannel.erase( iter );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CGameEngineWin32::AddVoiceData( HGAMEVOICECHANNEL hChannel, const uint8 *pVoiceData, uint32 uLength )
{
std::map<HGAMEVOICECHANNEL, CVoiceContext* >::iterator iter;
iter = m_MapVoiceChannel.find( hChannel );
if ( iter == m_MapVoiceChannel.end() )
return false; // channel not found
CVoiceContext* pVoiceContext = iter->second;
//
// At this point we have a buffer full of audio and enough room to submit it, so
// let's submit it and get another read request going.
uint8 *pBuffer = (uint8 *) malloc( uLength );
memcpy( pBuffer, pVoiceData, uLength );
XAUDIO2_BUFFER buf = {0};
buf.AudioBytes = uLength;
buf.pAudioData = pBuffer;
buf.pContext = pBuffer; // the buffer is freed again in CVoiceContext::OnBufferEnd
if ( FAILED( pVoiceContext->m_pSourceVoice->SubmitSourceBuffer( &buf ) ) )
{
free ( pBuffer );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: update an existing texture
//-----------------------------------------------------------------------------
bool CGameEngineWin32::UpdateTexture( HGAMETEXTURE hTexture, byte *pRGBAData, uint32 uWidth, uint32 uHeight, ETEXTUREFORMAT eTextureFormat )
{
std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
iter = m_MapTextures.find( hTexture );
if (iter == m_MapTextures.end())
{
OutputDebugString( "BFlushQuadBuffer failed with invalid m_hLastTexture value\n" );
return false;
}
// Put the data into the texture
D3DLOCKED_RECT rect;
HRESULT hRes = iter->second.m_pTexture->LockRect( 0, &rect, NULL, 0 );
if (FAILED( hRes ))
{
OutputDebugString( "LockRect call failed\n" );
iter->second.m_pTexture->Release();
iter->second.m_pTexture = NULL;
return false;
}
if (iter->second.m_eFormat == D3DFMT_A8R8G8B8)
{
DWORD *pARGB = (DWORD *)rect.pBits;
byte *pRGBA = (byte *)pRGBAData;
byte r, g, b, a;
for (uint32 y = 0; y < uHeight; ++y)
{
for (uint32 x = 0; x < uWidth; ++x)
{
// swap position of alpha value from back to front to be in correct format for d3d...
r = *pRGBA++;
g = *pRGBA++;
b = *pRGBA++;
a = *pRGBA++;
if ( eTextureFormat == eTextureFormat_RGBA )
*pARGB++ = D3DCOLOR_ARGB( a, r, g, b );
else if ( eTextureFormat == eTextureFormat_BGRA)
*pARGB++ = D3DCOLOR_ARGB( a, b, g, r );
}
}
}
else if (iter->second.m_eFormat == D3DFMT_A16B16G16R16)
{
uint16 *pDest = (uint16 *)rect.pBits;
uint16 *pSrc = (uint16 *)pRGBAData;
if ( eTextureFormat != eTextureFormat_BGRA16 )
OutputDebugString( "Unsupported texture format for BGRA16 texture \n" );
memcpy( pDest, pSrc, sizeof( uint16 )* uWidth * uHeight * 4 );
}
hRes = iter->second.m_pTexture->UnlockRect( 0 );
if (FAILED( hRes ))
{
OutputDebugString( "UnlockRect call failed\n" );
iter->second.m_pTexture->Release();
iter->second.m_pTexture = NULL;
return false;
}
return true;
}
bool CGameEngineWin32::BReadyTexture( HGAMETEXTURE hTexture )
{
std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
iter = m_MapTextures.find( hTexture );
if ( iter == m_MapTextures.end() )
{
OutputDebugString( "BFlushQuadBuffer failed with invalid m_hLastTexture value\n" );
return false;
}
// See if we need to actually create the d3d texture
if ( !iter->second.m_pTexture )
{
// render targets get a special flag
DWORD dwUsage = 0;
D3DPOOL pool = D3DPOOL_MANAGED;
if ( !iter->second.m_pRGBAData )
{
dwUsage = D3DUSAGE_RENDERTARGET;
pool = D3DPOOL_DEFAULT;
}
HRESULT hRes = m_pD3D9Device->CreateTexture(
iter->second.m_uWidth,
iter->second.m_uHeight,
1, // mip map levels (0 = generate all levels down to 1x1 if supported)
dwUsage, // have to set the right flag here if you want to autogen mipmaps... we don't
iter->second.m_eFormat,
pool,
&iter->second.m_pTexture,
NULL );
if ( FAILED( hRes ) )
{
OutputDebugString( "BFlushQuadBuffer failed because CreateTexture() call failed\n" );
iter->second.m_pTexture = NULL;
return false;
}
// if the texture has source data, copy that in. Render targets don't
// have source data.
if ( iter->second.m_pRGBAData )
{
// Put the data into the texture
D3DLOCKED_RECT rect;
hRes = iter->second.m_pTexture->LockRect( 0, &rect, NULL, 0 );
if ( FAILED( hRes ) )
{
OutputDebugString( "LockRect call failed\n" );
iter->second.m_pTexture->Release();
iter->second.m_pTexture = NULL;
return false;
}
if ( iter->second.m_eFormat == D3DFMT_A8R8G8B8 )
{
DWORD *pARGB = (DWORD *)rect.pBits;
byte *pRGBA = (byte *)iter->second.m_pRGBAData;
byte r, g, b, a;
for ( uint32 y = 0; y < iter->second.m_uHeight; ++y )
{
for ( uint32 x = 0; x < iter->second.m_uWidth; ++x )
{
// swap position of alpha value from back to front to be in correct format for d3d...
r = *pRGBA++;
g = *pRGBA++;
b = *pRGBA++;
a = *pRGBA++;
if ( iter->second.m_eTextureFormat == eTextureFormat_RGBA )
*pARGB++ = D3DCOLOR_ARGB( a, r, g, b );
else
*pARGB++ = D3DCOLOR_ARGB( a, b, g, r );
}
}
}
else if ( iter->second.m_eFormat == D3DFMT_A16B16G16R16 )
{
uint16 *pDest = (uint16 *)rect.pBits;
uint16 *pSrc = (uint16 *)iter->second.m_pRGBAData;
if ( iter->second.m_eTextureFormat != eTextureFormat_BGRA16 )
OutputDebugString( "Unsupported texture format for BGRA16 texture \n" );
memcpy( pDest, pSrc, sizeof(uint16)* iter->second.m_uWidth * iter->second.m_uHeight * 4 );
}
hRes = iter->second.m_pTexture->UnlockRect( 0 );
if ( FAILED( hRes ) )
{
OutputDebugString( "UnlockRect call failed\n" );
iter->second.m_pTexture->Release();
iter->second.m_pTexture = NULL;
return false;
}
}
else
{
// for render targets we also need to create the depth buffer
hRes = m_pD3D9Device->CreateDepthStencilSurface( iter->second.m_uWidth, iter->second.m_uHeight, D3DFMT_D32F_LOCKABLE, D3DMULTISAMPLE_NONE, 0, FALSE, &iter->second.m_pDepthSurface, NULL );
if ( FAILED( hRes ) )
{
OutputDebugString( "BReadyTexture - CreateDepthStencilSurface failed\n" );
iter->second.m_pTexture->Release();
iter->second.m_pTexture = NULL;
return false;
}
}
}
return true;
}
bool CGameEngineWin32::BSetTexture( HGAMETEXTURE hTexture )
{
if ( !BReadyTexture( hTexture ) )
return false;
// Ok, texture should be created ok, do the drawing work
if ( FAILED( m_pD3D9Device->SetTexture( 0, m_MapTextures[ hTexture ].m_pTexture ) ) )
{
OutputDebugString( "BFlushQuadBuffer failed setting texture\n" );
return false;
}
return true;
}
// sets the texture as a render target.
bool CGameEngineWin32::BSetRenderTarget( HGAMETEXTURE hTexture )
{
if ( !BReadyTexture( hTexture ) )
{
OutputDebugString( "BSetRenderTarget couldn't ready the texture\n" );
return false;
}
TextureData_t & tex = m_MapTextures[hTexture];
LPDIRECT3DTEXTURE9 pTex = tex.m_pTexture;
if ( !pTex )
{
OutputDebugString( "BSetRenderTarget - no texture\n" );
return false;
}
IDirect3DSurface9 *pSurface;
if ( FAILED( pTex->GetSurfaceLevel( 0, &pSurface ) ) )
{
OutputDebugString( "BSetRenderTarget - no surface\n" );
return false;
}
if ( FAILED( m_pD3D9Device->SetRenderTarget( 0, pSurface ) ) )
{
OutputDebugString( "BSetRenderTarget failed\n" );
return false;
}
if ( FAILED( m_pD3D9Device->SetDepthStencilSurface( tex.m_pDepthSurface ) ) )
{
OutputDebugString( "BSetRenderTarget Depth stencil surface\n" );
return false;
}
return true;
}
// sets the render target back to the frame buffer
bool CGameEngineWin32::BUnsetRenderTarget()
{
IDirect3DSurface9 *pSurface;
if ( FAILED( m_pD3D9Device->GetBackBuffer( 0, 0, D3DBACKBUFFER_TYPE_MONO, &pSurface ) ) )
{
OutputDebugString( "BClearRenderTarget - no surface\n" );
return false;
}
if ( FAILED( m_pD3D9Device->SetRenderTarget( 0, pSurface ) ) )
{
OutputDebugString( "BClearRenderTarget - SetRenderTarget failed\n" );
return false;
}
if ( FAILED( m_pD3D9Device->SetDepthStencilSurface( m_pBackbufferDepth ) ) )
{
OutputDebugString( "BClearRenderTarget Depth stencil surface\n" );
return false;
}
return true;
}
Reference in New Issue View Git Blame Copy Permalink