1841 lines
58 KiB
C++
1841 lines
58 KiB
C++
//========= Copyright © 1996-2008, Valve LLC, All rights reserved. ============
|
|
//
|
|
// Purpose: Main class for the game engine -- win32 implementation
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================
|
|
|
|
#include "stdafx.h"
|
|
#include "steam/isteamps3overlayrenderer.h"
|
|
#include "GameEnginePS3.h"
|
|
#include "steam/steamps3params_internal.h"
|
|
#include <sysutil/sysutil_gamecontent.h>
|
|
#include <map>
|
|
#include <cell/sysmodule.h>
|
|
#include <cell/voice.h>
|
|
#include <sysutil/sysutil_userinfo.h>
|
|
|
|
|
|
#define DebuggerBreak() { __asm volatile ("tw 31,1,1"); }
|
|
|
|
// Allocate static member
|
|
std::map<void *, CGameEnginePS3* > CGameEnginePS3::m_MapEngineInstances;
|
|
|
|
// How big is the vertex buffer for batching lines in total?
|
|
#define LINE_BUFFER_TOTAL_SIZE 1000
|
|
|
|
// How big is the vertex buffer for batching points in total?
|
|
#define POINT_BUFFER_TOTAL_SIZE 1800
|
|
|
|
// How big is the vertex buffer for batching quads in total?
|
|
#define QUAD_BUFFER_TOTAL_SIZE 1000
|
|
|
|
// Only a single global console can be setup for output, track that here
|
|
CellDbgFontConsoleId g_DbgFontConsoleID = -1;
|
|
|
|
// Global for PS3 params
|
|
SteamPS3Params_t g_SteamPS3Params;
|
|
|
|
void RunGameLoop( IGameEngine *pGameEngine, const char *pchServerAddress, const char *pchLobbyID );
|
|
extern "C" void __cdecl SteamAPIDebugTextHook( int nSeverity, const char *pchDebugText );
|
|
|
|
void OutputDebugString( const char *pchMsg )
|
|
{
|
|
#ifndef _CERT
|
|
fprintf( stderr, "%s", pchMsg );
|
|
cellDbgFontConsolePrintf( g_DbgFontConsoleID, "%s", pchMsg );
|
|
#endif
|
|
}
|
|
|
|
// taken from sample
|
|
static const char s_npCommunicationSignature[STEAM_PS3_COMMUNICATION_SIG_MAX] = {
|
|
0xb9,0xdd,0xe1,0x3b,0x01,0x00,0x00,0x00,
|
|
0x00,0x00,0x00,0x00,0x1d,0x3c,0x55,0x0f,
|
|
0x35,0xb5,0x54,0xfe,0x4e,0x97,0x1a,0x01,
|
|
0x23,0x38,0xaa,0xd6,0x3d,0xda,0x6a,0xac,
|
|
0x3e,0x95,0xff,0x09,0x49,0xd7,0xb3,0xda,
|
|
0x11,0xae,0xf0,0xde,0xd6,0x2b,0x70,0x96,
|
|
0x40,0x09,0x0e,0xed,0x8c,0x38,0x1d,0xa4,
|
|
0xc3,0x0e,0xc9,0x30,0xc1,0xcc,0x66,0x92,
|
|
0xd1,0xb0,0x6e,0x01,0xc0,0x44,0xb2,0xa2,
|
|
0xd0,0x62,0x88,0xa8,0x26,0x7f,0x91,0xb5,
|
|
0x7b,0x40,0x0c,0x6a,0xc9,0x3b,0x5c,0x89,
|
|
0x43,0x22,0x16,0x4e,0x27,0x56,0x46,0x4a,
|
|
0x63,0xc4,0x55,0xce,0xb3,0xce,0xf7,0x92,
|
|
0x07,0x71,0x13,0x60,0x6e,0xcb,0xad,0xd5,
|
|
0xf0,0x60,0xd6,0x71,0x3a,0x45,0xaa,0x25,
|
|
0x38,0x60,0x11,0x1a,0xa5,0x0e,0xcf,0xa4,
|
|
0x21,0xc8,0x94,0x6d,0xf2,0x0d,0xac,0xcf,
|
|
0x67,0x8d,0x4a,0x14,0x14,0x4e,0xed,0x45,
|
|
0x67,0x40,0x60,0x93,0x2b,0x00,0xeb,0xb7,
|
|
0xf3,0x2f,0x09,0x36,0xb6,0x59,0x84,0x0e
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Loads the Steam PS3 module
|
|
//-----------------------------------------------------------------------------
|
|
sys_prx_id_t g_sys_prx_id_steam = -1;
|
|
static bool LoadSteamPS3Module()
|
|
{
|
|
g_sys_prx_id_steam = sys_prx_load_module( SYS_APP_HOME "/steam_api_ps3.sprx", 0, NULL );
|
|
if ( g_sys_prx_id_steam < CELL_OK )
|
|
{
|
|
OutputDebugString( "LoadSteamModule() - failed to load steam_api_ps3\n" );
|
|
return false;
|
|
}
|
|
|
|
int modres;
|
|
int res = sys_prx_start_module( g_sys_prx_id_steam, 0, NULL, &modres, 0, NULL);
|
|
if ( res < CELL_OK )
|
|
{
|
|
OutputDebugString( "LoadSteamModule() - failed to start steam_api_ps3\n" );
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Unloads the Steam PS3 module
|
|
//-----------------------------------------------------------------------------
|
|
static bool UnloadSteamPS3Module()
|
|
{
|
|
// check if loaded
|
|
if ( g_sys_prx_id_steam < CELL_OK )
|
|
return false;
|
|
|
|
int modres;
|
|
int res = sys_prx_stop_module( g_sys_prx_id_steam, 0, NULL, &modres, 0, NULL);
|
|
if ( res < CELL_OK )
|
|
{
|
|
OutputDebugString( "LoadSteamModule() - failed to stop steam_api_ps3\n" );
|
|
return false;
|
|
}
|
|
|
|
res = sys_prx_unload_module( g_sys_prx_id_steam, 0, NULL );
|
|
if ( res < CELL_OK )
|
|
{
|
|
OutputDebugString( "LoadSteamModule() - failed to unload steam_api_ps3\n" );
|
|
return false;
|
|
}
|
|
|
|
g_sys_prx_id_steam = -1;
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Initializes Steam PS3 params for our application
|
|
// This is very similar to CPs3ContentPathInfo::Init
|
|
//-----------------------------------------------------------------------------
|
|
SteamPS3ParamsInternal_t g_steamPS3ParamsInternal = { STEAM_PS3_PARAMS_INTERNAL_VERSION, k_EUniverseBeta, "", true };
|
|
bool SetSteamPS3Params( SteamPS3Params_t *pParams )
|
|
{
|
|
char bootdir[CELL_GAME_DIRNAME_SIZE] = { 0 };
|
|
char gameHDDataPath[CELL_GAME_DIRNAME_SIZE];
|
|
char gameTitle[CELL_GAME_SYSP_TITLE_SIZE];
|
|
char gameTitleID[CELL_GAME_SYSP_TITLEID_SIZE]; // CELL_GAME_PARAMID_TITLE_ID
|
|
char gameAppVer[CELL_GAME_SYSP_VERSION_SIZE]; // CELL_GAME_PARAMID_APP_VER
|
|
char gameContentPath[CELL_GAME_PATH_MAX]; // as returned by contentPermit but usually meaningless (?)
|
|
char gameBasePath[CELL_GAME_PATH_MAX];
|
|
|
|
unsigned int nBootType = 0; /// either CELL_GAME_GAMETYPE_DISC or CELL_GAME_GAMETYPE_HDD
|
|
unsigned int nBootAttribs = 0; /// some combination of attribute masks -- see .cpp for details
|
|
|
|
CellSysCacheParam sysCacheParams;
|
|
memset( &sysCacheParams, 0, sizeof( CellSysCacheParam ) );
|
|
|
|
CellGameContentSize size;
|
|
memset(&size, 0, sizeof(CellGameContentSize));
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// load sysutil GAME
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// we'll need to haul libsysutil into memory ( CELL_SYSMODULE_SYSUTIL_GAME )
|
|
bool bSysModuleIsLoaded = cellSysmoduleIsLoaded( CELL_SYSMODULE_SYSUTIL_GAME ) == CELL_SYSMODULE_LOADED ;
|
|
// if this assert trips, then:
|
|
// 1) look at where the sysutil_game module is loaded to make sure it still needs to be loaded at this point (maybe you can dump it to save memory)
|
|
// 2) if it's being taken care of somewhere else, we don't need to load the module here.
|
|
if ( !bSysModuleIsLoaded )
|
|
{
|
|
// SYSUTIL_GAME module not loaded yet
|
|
if ( CELL_OK != cellSysmoduleLoadModule( CELL_SYSMODULE_SYSUTIL_GAME ) )
|
|
return false;
|
|
}
|
|
|
|
// get the base to the content directory.
|
|
bool bSuccess = CELL_GAME_RET_OK == cellGameBootCheck( &nBootType, &nBootAttribs, &size, bootdir );
|
|
|
|
if ( bSuccess )
|
|
{
|
|
|
|
bSuccess &= CELL_GAME_RET_OK == cellGameGetParamString( CELL_GAME_PARAMID_TITLE, gameTitle, sizeof( gameTitle ) );
|
|
bSuccess &= CELL_GAME_RET_OK == cellGameGetParamString( CELL_GAME_PARAMID_TITLE_ID, gameTitleID, sizeof( gameTitleID ) );
|
|
bSuccess &= CELL_GAME_RET_OK == cellGameGetParamString( CELL_GAME_PARAMID_APP_VER, gameAppVer, sizeof( gameAppVer ) );
|
|
}
|
|
|
|
if ( bSuccess )
|
|
{
|
|
bSuccess = CELL_GAME_RET_OK == cellGameContentPermit( gameContentPath, gameBasePath ) ;
|
|
}
|
|
|
|
if ( bSuccess )
|
|
{
|
|
// Get the game data directory on the hard disk.
|
|
memset(&size, 0, sizeof(CellGameContentSize));
|
|
const int ret = cellGameDataCheck( CELL_GAME_GAMETYPE_GAMEDATA, gameTitleID, &size );
|
|
if ( ret == CELL_GAME_RET_NONE )
|
|
{
|
|
// create game directory for the first time
|
|
CellGameSetInitParams init; memset( &init, 0, sizeof( init ) );
|
|
memcpy( init.title, gameTitle, sizeof( gameTitle ) );
|
|
memcpy( init.titleId, gameTitleID, sizeof( gameTitleID ) );
|
|
memcpy( init.version, gameAppVer, sizeof( gameAppVer ) );
|
|
|
|
char tmp_contentInfoPath[CELL_GAME_PATH_MAX] = {0};
|
|
char tmp_usrdirPath[CELL_GAME_PATH_MAX] = {0};
|
|
|
|
bSuccess = CELL_GAME_RET_OK == cellGameCreateGameData( &init, tmp_contentInfoPath, tmp_usrdirPath );
|
|
}
|
|
else if ( ret != CELL_GAME_RET_OK )
|
|
{
|
|
// failure
|
|
bSuccess = false;
|
|
}
|
|
}
|
|
|
|
if ( bSuccess )
|
|
{
|
|
char contentInfoPath[256];
|
|
bSuccess = CELL_GAME_RET_OK == cellGameContentPermit( contentInfoPath, gameHDDataPath );
|
|
}
|
|
|
|
if ( bSuccess )
|
|
{
|
|
// Steam needs the system cache path. Passing an empty string so it is always cleared for testing
|
|
// memcpy( sysCacheParams.cacheId, gameTitleID, sizeof( gameTitleID ) );
|
|
sysCacheParams.cacheId[0] = '\0';
|
|
|
|
const int ret = cellSysCacheMount( &sysCacheParams );
|
|
bSuccess = ( ret == CELL_SYSCACHE_RET_OK_CLEARED ) || ( ret == CELL_SYSCACHE_RET_OK_RELAYED );
|
|
}
|
|
|
|
if ( !bSysModuleIsLoaded )
|
|
{
|
|
// actually this means it wasn't loaded when we got into the function. unload again
|
|
cellSysmoduleUnloadModule( CELL_SYSMODULE_SYSUTIL_GAME );
|
|
}
|
|
|
|
if ( bSuccess )
|
|
{
|
|
// Internal params, not used by public games.
|
|
pParams->pReserved = &g_steamPS3ParamsInternal;
|
|
|
|
// configure the Steamworks PS3 parameters. All params need to be set.
|
|
pParams->m_nAppId = 480;
|
|
|
|
pParams->m_cSteamInputTTY = SYS_TTYP3;
|
|
|
|
strncpy( pParams->m_rgchNpServiceID, "UD0031-NPXX00848_00", STEAM_PS3_SERVICE_ID_MAX );
|
|
strncpy( pParams->m_rgchNpCommunicationID, "NPXS00022", STEAM_PS3_COMMUNICATION_ID_MAX );
|
|
memcpy( pParams->m_rgchNpCommunicationSig, s_npCommunicationSignature, STEAM_PS3_COMMUNICATION_SIG_MAX );
|
|
strncpy( pParams->m_rgchInstallationPath, SYS_APP_HOME, STEAM_PS3_PATH_MAX );
|
|
strncpy( pParams->m_rgchSystemCache, sysCacheParams.getCachePath, STEAM_PS3_PATH_MAX );
|
|
strncpy( pParams->m_rgchGameData, gameHDDataPath, STEAM_PS3_PATH_MAX );
|
|
strncpy( pParams->m_rgchSteamLanguage, "english", STEAM_PS3_LANGUAGE_MAX );
|
|
strncpy( pParams->m_rgchRegionCode, "SCEA", STEAM_PS3_REGION_CODE_MAX );
|
|
|
|
pParams->m_sysNetInitInfo.m_bNeedInit = true; // default network initialization
|
|
pParams->m_sysJpgInitInfo.m_bNeedInit = true;
|
|
pParams->m_sysSysUtilUserInfo.m_bNeedInit = true;
|
|
pParams->m_sysPngInitInfo.m_bNeedInit = true;
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Path to save user data
|
|
//-----------------------------------------------------------------------------
|
|
static char g_rgchUserDataPath[CELL_GAME_PATH_MAX] = {0};
|
|
bool SetUserSaveDataPath()
|
|
{
|
|
// On PS3, we need to save the user's stats & achievement information into the save container. In this example, we are simply
|
|
// saving the data to a known location on disk.
|
|
|
|
// To get a unique path per user, include the local user id in the file name
|
|
|
|
// need the user info module
|
|
if ( cellSysmoduleLoadModule( CELL_SYSMODULE_SYSUTIL_USERINFO ) != CELL_OK )
|
|
return false;
|
|
|
|
// get local id
|
|
CellSysutilUserId unLocalUserID;
|
|
if ( cellUserInfoGetList( NULL, NULL, &unLocalUserID ) != CELL_USERINFO_RET_OK )
|
|
return false;
|
|
|
|
// can now unload the module
|
|
cellSysmoduleUnloadModule( CELL_SYSMODULE_SYSUTIL_USERINFO );
|
|
|
|
// save to the game directory
|
|
if ( snprintf( g_rgchUserDataPath, sizeof( g_rgchUserDataPath ), "%s/%u_stats.bin", g_SteamPS3Params.m_rgchGameData, unLocalUserID ) > sizeof( g_rgchUserDataPath ) - 1 )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
const char *GetUserSaveDataPath()
|
|
{
|
|
return g_rgchUserDataPath;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Main entry point for the program -- ps3
|
|
//-----------------------------------------------------------------------------
|
|
int main( int argc, char *argv[] )
|
|
{
|
|
#ifdef PS3_MTT_DEBUG
|
|
mttLogInit( "/app_home/libmtt_log.txt" );
|
|
#endif
|
|
OutputDebugString( "PS3 main\n" );
|
|
|
|
// Initialize 6 SPUs but reserve 1 SPU as a raw SPU for PSGL
|
|
sys_spu_initialize(6, 1);
|
|
|
|
// Load Steam
|
|
if ( !LoadSteamPS3Module() )
|
|
return EXIT_FAILURE;
|
|
|
|
// Construct a new instance of the game engine
|
|
// bugbug jmccaskey - make screen resolution dynamic, maybe take it on command line?
|
|
CGameEnginePS3 *pGameEngine = new CGameEnginePS3();
|
|
|
|
// No restart app if necessary, or CEG initialization on PS3
|
|
|
|
// Initialize SteamAPI, if this fails we bail out since we depend on Steam for lots of stuff.
|
|
// You don't necessarily have to though if you write your code to check whether all the Steam
|
|
// interfaces are NULL before using them and provide alternate paths when they are unavailable.
|
|
|
|
if ( !SetSteamPS3Params( &g_SteamPS3Params ) )
|
|
{
|
|
OutputDebugString( "SetSteamPS3Params() failed\n" );
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
// do before SteamAPI_Init(), so we can load and unload the userinfo module (we will tell Steam it isn't loaded)
|
|
if ( !SetUserSaveDataPath() )
|
|
{
|
|
OutputDebugString( "SetUserSaveDataPath() failed\n" );
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if ( !SteamAPI_Init( &g_SteamPS3Params ) )
|
|
{
|
|
OutputDebugString( "SteamAPI_Init() failed\n" );
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
// set our debug handler
|
|
SteamClient()->SetWarningMessageHook( &SteamAPIDebugTextHook );
|
|
|
|
// set text for Steam to use for PSN game invites
|
|
SteamUtils()->SetPSNGameBootInviteStrings( "Spacewar Invite", "You've been invited to join a Spacewar lobby!" );
|
|
|
|
// Setup overlay render interface for PS3 Steam overlay
|
|
SteamPS3OverlayRender()->BHostInitialize( pGameEngine->GetViewportWidth(), pGameEngine->GetViewportHeight(), 60, pGameEngine, NULL );
|
|
|
|
// No +connect support on PS3 since Steam isn't launching us, but we check for PSN boot invites, and this may postback a lobby join
|
|
// requested callback to us.
|
|
|
|
// bugbug jmccaskey - MUST call cellGameBootCheck() to get attributes param to pass here!
|
|
SteamMatchmaking()->CheckForPSNGameBootInvite( 0 );
|
|
|
|
// This call will block and run until the game exits
|
|
RunGameLoop( pGameEngine, NULL, NULL );
|
|
|
|
#ifdef PS3_MTT_DEBUG
|
|
mttLogShutdown();
|
|
#endif
|
|
|
|
// Shutdown the SteamAPI
|
|
SteamAPI_Shutdown();
|
|
|
|
// Unload Steam
|
|
UnloadSteamPS3Module();
|
|
|
|
// exit
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: PS3 callback handler
|
|
//-----------------------------------------------------------------------------
|
|
static void PS3SysutilCallback( uint64_t status, uint64_t param, void* userdata )
|
|
{
|
|
(void) param;
|
|
|
|
CGameEnginePS3 *pGameEngine = CGameEnginePS3::FindEngineInstanceForPtr( userdata );
|
|
|
|
switch( status )
|
|
{
|
|
case CELL_SYSUTIL_REQUEST_EXITGAME:
|
|
pGameEngine->Shutdown();
|
|
break;
|
|
case CELL_SYSUTIL_DRAWING_BEGIN:
|
|
case CELL_SYSUTIL_DRAWING_END:
|
|
break;
|
|
case CELL_SYSUTIL_SYSTEM_MENU_OPEN:
|
|
OutputDebugString( "System menu opened!\n" );
|
|
break;
|
|
case CELL_SYSUTIL_SYSTEM_MENU_CLOSE:
|
|
OutputDebugString( "System menu closed!\n" );
|
|
break;
|
|
default:
|
|
// Ok that we don't know them all, Steam handles some that we don't know.
|
|
//OutputDebugString( "PS3SysutilCallback: Unknown status received\n" );
|
|
break;
|
|
}
|
|
|
|
// Must call this to pass along to Steam which may need async status provided by these
|
|
// callbacks as well.
|
|
SteamUtils()->PostPS3SysutilCallback( status, param, userdata );
|
|
}
|
|
|
|
struct PacketQueue_t
|
|
{
|
|
uint32 unSize;
|
|
void *pData;
|
|
uint32 unWritten;
|
|
PacketQueue_t *pNext;
|
|
};
|
|
|
|
class CVoiceContext
|
|
{
|
|
public:
|
|
CVoiceContext()
|
|
{
|
|
m_PortIdInput = 0;
|
|
m_PortIdOutput = 0;
|
|
m_pQueue = NULL;
|
|
}
|
|
virtual ~CVoiceContext()
|
|
{
|
|
//
|
|
}
|
|
|
|
uint32_t m_PortIdInput;
|
|
uint32_t m_PortIdOutput;
|
|
PacketQueue_t *m_pQueue;
|
|
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor for game engine instance
|
|
//-----------------------------------------------------------------------------
|
|
CGameEnginePS3::CGameEnginePS3()
|
|
{
|
|
m_bEngineReadyForUse = false;
|
|
m_bShuttingDown = false;
|
|
m_nWindowWidth = 0;
|
|
m_nWindowHeight = 0;
|
|
m_ulPreviousGameTickCount = 0;
|
|
m_ulGameTickCount = 0;
|
|
m_hTextureWhite = 0;
|
|
m_pPSGLContext = NULL;
|
|
m_pPSGLDevice = NULL;
|
|
m_DbgFontConsoleID = -1;
|
|
m_nNextFontHandle = 1;
|
|
m_nNextTextureHandle = 1;
|
|
m_hLastTexture = 0;
|
|
|
|
m_rgflPointsData = new GLfloat[ 3*POINT_BUFFER_TOTAL_SIZE ];
|
|
m_rgflPointsColorData = new GLubyte[ 4*POINT_BUFFER_TOTAL_SIZE ];
|
|
m_dwPointsToFlush = 0;
|
|
|
|
m_rgflLinesData = new GLfloat[ 6*LINE_BUFFER_TOTAL_SIZE ];
|
|
m_rgflLinesColorData = new GLubyte[ 8*LINE_BUFFER_TOTAL_SIZE ];
|
|
m_dwLinesToFlush = 0;
|
|
|
|
m_rgflQuadsData = new GLfloat [ 12*QUAD_BUFFER_TOTAL_SIZE ];
|
|
m_rgflQuadsColorData = new GLubyte[ 16*QUAD_BUFFER_TOTAL_SIZE ];
|
|
m_rgflQuadsTextureData = new GLfloat[ 8*QUAD_BUFFER_TOTAL_SIZE ];
|
|
m_dwQuadsToFlush = 0;
|
|
m_unVoiceChannelCount = 0;
|
|
|
|
|
|
CGameEnginePS3::AddInstanceToPtrMap( this );
|
|
|
|
// Setup timing data
|
|
m_ulGameTickCount = cell::fios::FIOSAbstimeToMilliseconds( cell::fios::FIOSGetCurrentTime() );
|
|
|
|
// Register sysutil exit callback
|
|
int ret = cellSysutilRegisterCallback( 0, PS3SysutilCallback, this );
|
|
if( ret != CELL_OK )
|
|
{
|
|
OutputDebugString( "!! Registering sysutil callback failed...\n" );
|
|
return;
|
|
}
|
|
|
|
if( !BInitializePSGL() )
|
|
{
|
|
OutputDebugString( "!! Initializing PSGL failed\n" );
|
|
return;
|
|
}
|
|
|
|
if( !BInitializeCellDbgFont() )
|
|
{
|
|
OutputDebugString( "!! Initializing CellDbgFont failed\n" );
|
|
return;
|
|
}
|
|
|
|
if ( !BInitializeLibPad() )
|
|
{
|
|
OutputDebugString( "!! Initializing libpad failed\n" );
|
|
return;
|
|
}
|
|
|
|
if ( !BInitializeAudio() )
|
|
{
|
|
OutputDebugString( "!! Initializing audio failed\n" );
|
|
return;
|
|
}
|
|
|
|
m_bEngineReadyForUse = true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Shutdown the game engine
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::Shutdown()
|
|
{
|
|
// Flag that we are shutting down so the frame loop will stop running
|
|
m_bShuttingDown = true;
|
|
|
|
// Shutdown dbg font library
|
|
if ( m_DbgFontConsoleID >= 0 )
|
|
{
|
|
cellDbgFontConsoleClose( m_DbgFontConsoleID );
|
|
cellDbgFontExit();
|
|
}
|
|
|
|
// Should be safe to call even if we didn't actually init.
|
|
cellPadEnd();
|
|
|
|
// PS3 docs say it's best not to call this and allow the os/vshell to handle it instead to avoid brief noise
|
|
// in the video display
|
|
|
|
if ( m_rgflPointsData )
|
|
{
|
|
delete[] m_rgflPointsData;
|
|
m_rgflPointsData = NULL;
|
|
}
|
|
|
|
if ( m_rgflPointsColorData )
|
|
{
|
|
delete[] m_rgflPointsColorData;
|
|
m_rgflPointsColorData = NULL;
|
|
}
|
|
|
|
if ( m_rgflLinesData )
|
|
{
|
|
delete[] m_rgflLinesData;
|
|
m_rgflLinesData = NULL;
|
|
}
|
|
|
|
if ( m_rgflLinesColorData )
|
|
{
|
|
delete[] m_rgflLinesColorData;
|
|
m_rgflLinesColorData = NULL;
|
|
}
|
|
|
|
if ( m_rgflQuadsData )
|
|
{
|
|
delete[] m_rgflQuadsData;
|
|
m_rgflQuadsData = NULL;
|
|
}
|
|
|
|
if ( m_rgflQuadsColorData )
|
|
{
|
|
delete[] m_rgflQuadsColorData;
|
|
m_rgflQuadsColorData = NULL;
|
|
}
|
|
|
|
if ( m_rgflQuadsTextureData )
|
|
{
|
|
delete[] m_rgflQuadsTextureData;
|
|
m_rgflQuadsTextureData = NULL;
|
|
}
|
|
|
|
m_dwLinesToFlush = 0;
|
|
m_dwPointsToFlush = 0;
|
|
m_dwQuadsToFlush = 0;
|
|
|
|
/*
|
|
|
|
// PS3 docs say it's best not to call this and allow the os/vshell to handle it instead to avoid brief noise
|
|
// in the video display. Should we not do this then?
|
|
//
|
|
// bugbug jmccaskey - don't do this?
|
|
if ( m_pPSGLDevice )
|
|
{
|
|
psglMakeCurrent( NULL, m_pPSGLDevice );
|
|
if ( m_pPSGLContext )
|
|
{
|
|
psglDestroyContext( m_pPSGLContext );
|
|
m_pPSGLContext = NULL;
|
|
}
|
|
|
|
psglDestroyDevice( m_pPSGLDevice );
|
|
m_pPSGLDevice = NULL;
|
|
}
|
|
|
|
psglExit();
|
|
|
|
*/
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Initialize voice/audio interfaces
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BInitializeAudio()
|
|
{
|
|
int ret = cellSysmoduleLoadModule(CELL_SYSMODULE_VOICE);
|
|
if ( ret < 0 )
|
|
return false;
|
|
|
|
CellVoiceInitParam Params;
|
|
memset(&Params, 0, sizeof(CellVoiceInitParam));
|
|
Params.appType = CELLVOICE_APPTYPE_GAME_1MB;
|
|
Params.version = CELLVOICE_VERSION_100;
|
|
|
|
ret = cellVoiceInitEx( &Params );
|
|
|
|
if (ret != CELL_OK )
|
|
return false;
|
|
|
|
sys_ipc_key_t voiceEventKey;
|
|
sys_event_queue_t voiceQueue;
|
|
int err = cellVoiceCreateNotifyEventQueue(&voiceQueue, &voiceEventKey);
|
|
if (err != CELL_OK)
|
|
return false;
|
|
|
|
uint64_t source = 12345;
|
|
|
|
err = cellVoiceSetNotifyEventQueue(voiceEventKey, source);
|
|
|
|
if (err != CELL_OK)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Initialize libpad for controller input
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BInitializeLibPad()
|
|
{
|
|
int ret = cellPadInit( CELL_PAD_MAX_PORT_NUM );
|
|
if ( ret != CELL_OK )
|
|
return false;
|
|
|
|
// We don't use pressure sensitivity or sixaxis
|
|
for ( int i=0; i<CELL_PAD_MAX_PORT_NUM; ++i )
|
|
{
|
|
// May be we don't have all ports connected, but this setting will be set and persist anyway
|
|
cellPadSetPortSetting( i, CELL_PAD_SETTING_PRESS_OFF | CELL_PAD_SETTING_SENSOR_OFF );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Initialize the PSGL rendering interfaces and default state
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BInitializePSGL()
|
|
{
|
|
// Clear any errors
|
|
glGetError();
|
|
|
|
// First, initialize PSGL
|
|
// Note that since we initialized the SPUs ourselves earlier we should
|
|
// make sure that PSGL doesn't try to do so as well.
|
|
PSGLinitOptions initOpts = {
|
|
enable: PSGL_INIT_MAX_SPUS | PSGL_INIT_INITIALIZE_SPUS | PSGL_INIT_HOST_MEMORY_SIZE,
|
|
maxSPUs: 1,
|
|
initializeSPUs: false,
|
|
// We're not specifying values for these options, the code is only here
|
|
// to alleviate compiler warnings.
|
|
persistentMemorySize: 0,
|
|
transientMemorySize: 0,
|
|
errorConsole: 0,
|
|
fifoSize: 0,
|
|
hostMemorySize: 8*1024*1024, // 8mb for host memory
|
|
};
|
|
|
|
psglInit( &initOpts );
|
|
|
|
m_pPSGLDevice = psglCreateDeviceAuto( GL_ARGB_SCE, GL_DEPTH_COMPONENT24, GL_MULTISAMPLING_4X_SQUARE_ROTATED_SCE );
|
|
if ( !m_pPSGLDevice )
|
|
{
|
|
OutputDebugString( "!! Failed to init the device \n" );
|
|
return false;
|
|
}
|
|
|
|
GLuint width, height;
|
|
psglGetDeviceDimensions( m_pPSGLDevice, &width, &height );
|
|
m_nWindowHeight = height;
|
|
m_nWindowWidth = width;
|
|
|
|
// Now create a PSGL context
|
|
m_pPSGLContext = psglCreateContext();
|
|
if ( !m_pPSGLContext )
|
|
{
|
|
OutputDebugString( "Error creating PSGL context\n" );
|
|
return false;
|
|
}
|
|
|
|
// Make this context current for the device we initialized
|
|
psglMakeCurrent( m_pPSGLContext, m_pPSGLDevice );
|
|
|
|
// Our sub texture updates trigger this warning, we don't care since this is a trivial example app.
|
|
psglDisableReport( PSGL_REPORT_TEXTURE_COPY_BACK );
|
|
|
|
// Since we're using fixed function stuff (i.e. not using our own shader
|
|
// yet), we need to load shaders.bin that contains the fixed function
|
|
// shaders.
|
|
psglLoadShaderLibrary( SYS_APP_HOME"/shaders.bin" );
|
|
|
|
// Reset the context
|
|
psglResetCurrentContext();
|
|
|
|
glViewport( 0, 0, width, height );
|
|
glScissor( 0, 0, width, height );
|
|
glClearDepthf(1.0f);
|
|
glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
|
|
glEnable( GL_VSYNC_SCE );
|
|
|
|
glEnable( GL_BLEND );
|
|
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
|
|
|
|
glDisable( GL_CULL_FACE );
|
|
glDisable( GL_ALPHA_TEST );
|
|
glDisable( GL_STENCIL_TEST );
|
|
glDisable( GL_SCISSOR_TEST );
|
|
glDisable( GL_LIGHTING );
|
|
glDisable( GL_DEPTH_TEST );
|
|
glDisable( GL_FOG );
|
|
|
|
glDepthMask( GL_FALSE );
|
|
|
|
// We always need these two
|
|
glEnableClientState( GL_COLOR_ARRAY );
|
|
glEnableClientState( GL_VERTEX_ARRAY );
|
|
|
|
// This we'll enable as needed
|
|
glDisableClientState( GL_TEXTURE_COORD_ARRAY );
|
|
|
|
glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
|
|
|
|
glMatrixMode( GL_PROJECTION );
|
|
glLoadIdentity();
|
|
glOrthof( 0, width, height, 0, -1.0f, 1.0f );
|
|
glTranslatef( 0, 0, 0 );
|
|
|
|
glMatrixMode( GL_MODELVIEW );
|
|
glLoadIdentity();
|
|
glTranslatef( 0, 0, 0 );
|
|
|
|
glMatrixMode( GL_TEXTURE );
|
|
glLoadIdentity();
|
|
glTranslatef( 0, 0, 0 );
|
|
|
|
glDepthRangef( 0.0f, 1.0f );
|
|
|
|
// PSGL doesn't clear the screen on startup, so let's do that here.
|
|
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
|
|
psglSwap();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Initialize the debug font library
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BInitializeCellDbgFont()
|
|
{
|
|
// initialize debug font library, then open 2 consoles
|
|
CellDbgFontConfig cfg;
|
|
cfg.bufSize = 4096;
|
|
cfg.screenWidth = m_nWindowWidth;
|
|
cfg.screenHeight = m_nWindowHeight;
|
|
if ( cellDbgFontInit( &cfg) != CELL_OK )
|
|
{
|
|
OutputDebugString( "Failed initializing CellDbgFont\n" );
|
|
}
|
|
|
|
CellDbgFontConsoleConfig ccfg0;
|
|
ccfg0.posLeft = 0.18f;
|
|
ccfg0.posTop = 0.82f;
|
|
ccfg0.cnsWidth = 128;
|
|
ccfg0.cnsHeight = 8;
|
|
ccfg0.scale = 0.65f;
|
|
ccfg0.color = 0xff0080ff; // ABGR -> orange
|
|
g_DbgFontConsoleID = m_DbgFontConsoleID = cellDbgFontConsoleOpen( &ccfg0 );
|
|
if ( g_DbgFontConsoleID < 0 )
|
|
{
|
|
OutputDebugString( "Failed creating CellDbgFontConsole\n" );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Updates current tick count for the game engine
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::UpdateGameTickCount()
|
|
{
|
|
m_ulPreviousGameTickCount = m_ulGameTickCount;
|
|
m_ulGameTickCount = cell::fios::FIOSAbstimeToMilliseconds( cell::fios::FIOSGetCurrentTime() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 CGameEnginePS3::BSleepForFrameRateLimit( uint32 ulMaxFrameRate )
|
|
{
|
|
// Frame rate limiting
|
|
float flDesiredFrameMilliseconds = 1000.0f/ulMaxFrameRate;
|
|
|
|
uint64 ulGameTickCount = cell::fios::FIOSAbstimeToMilliseconds( cell::fios::FIOSGetCurrentTime() );
|
|
|
|
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 )
|
|
{
|
|
sys_timer_usleep( 2000 );
|
|
}
|
|
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: Set the background color to clear to
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::SetBackgroundColor( short a, short r, short g, short b )
|
|
{
|
|
glClearColor( (float)r/255.0f, (float)g/255.0f, (float)b/255.0f, (float)a/255.0f );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Start a new frame
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::StartFrame()
|
|
{
|
|
#ifdef PS3_MTT_DEBUG
|
|
mttLogNewFrame();
|
|
#endif
|
|
// Pump PS3 system callbacks
|
|
MessagePump();
|
|
|
|
// We may now be shutting down, check and don't start a frame then
|
|
if ( BShuttingDown() )
|
|
return false;
|
|
|
|
// Clear the screen for the new frame
|
|
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: End the current frame
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::EndFrame()
|
|
{
|
|
if ( BShuttingDown() )
|
|
return;
|
|
|
|
if ( !m_pPSGLDevice )
|
|
return;
|
|
|
|
if ( !m_pPSGLContext )
|
|
return;
|
|
|
|
// Flush point buffer
|
|
BFlushPointBuffer();
|
|
|
|
// Flush line buffer
|
|
BFlushLineBuffer();
|
|
|
|
// Flush quad buffer
|
|
BFlushQuadBuffer();
|
|
|
|
// Flush dbg font data
|
|
cellDbgFontDraw();
|
|
|
|
// Tell the Steam overlay to draw now
|
|
SteamPS3OverlayRender()->Render();
|
|
|
|
// Draw a few lines, for 10% and 15% safe boundaries
|
|
DWORD dwColor = D3DCOLOR_ARGB( 50, 255, 0, 0 );
|
|
|
|
float flXSafe = GetViewportWidth()*0.05f;
|
|
float flYSafe = GetViewportHeight()*0.05f;
|
|
BDrawLine( flXSafe, flYSafe, dwColor, flXSafe, GetViewportHeight()-flYSafe, dwColor );
|
|
BDrawLine( flXSafe, flYSafe, dwColor, GetViewportWidth()-flXSafe, flYSafe, dwColor );
|
|
BDrawLine( GetViewportWidth()-flXSafe, flYSafe, dwColor, GetViewportWidth()-flXSafe, GetViewportHeight()-flYSafe, dwColor );
|
|
BDrawLine( flXSafe, GetViewportHeight()-flYSafe, dwColor, GetViewportWidth()-flXSafe, GetViewportHeight()-flYSafe, dwColor );
|
|
|
|
dwColor = D3DCOLOR_ARGB( 50, 255, 255, 0 );
|
|
flXSafe = GetViewportWidth()*0.075f;
|
|
flYSafe = GetViewportHeight()*0.075f;
|
|
BDrawLine( flXSafe, flYSafe, dwColor, flXSafe, GetViewportHeight()-flYSafe, dwColor );
|
|
BDrawLine( flXSafe, flYSafe, dwColor, GetViewportWidth()-flXSafe, flYSafe, dwColor );
|
|
BDrawLine( GetViewportWidth()-flXSafe, flYSafe, dwColor, GetViewportWidth()-flXSafe, GetViewportHeight()-flYSafe, dwColor );
|
|
BDrawLine( flXSafe, GetViewportHeight()-flYSafe, dwColor, GetViewportWidth()-flXSafe, GetViewportHeight()-flYSafe, dwColor );
|
|
|
|
// Flush quads a second time, as Steam may have queued more batches.
|
|
BFlushQuadBuffer();
|
|
|
|
// Flush lines again
|
|
BFlushLineBuffer();
|
|
|
|
// Swap buffers now that everything is flushed
|
|
psglSwap();
|
|
|
|
RunAudio();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw a line, the engine internally manages a vertex buffer for batching these
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BDrawLine( float xPos0, float yPos0, DWORD dwColor0, float xPos1, float yPos1, DWORD dwColor1 )
|
|
{
|
|
if ( !m_pPSGLContext || !m_pPSGLDevice || m_bShuttingDown )
|
|
return false;
|
|
|
|
|
|
// Check if we are out of room and need to flush the buffer
|
|
if ( m_dwLinesToFlush == LINE_BUFFER_TOTAL_SIZE )
|
|
{
|
|
BFlushLineBuffer();
|
|
}
|
|
|
|
DWORD dwOffset = m_dwLinesToFlush*6;
|
|
m_rgflLinesData[dwOffset] = xPos0;
|
|
m_rgflLinesData[dwOffset+1] = yPos0;
|
|
m_rgflLinesData[dwOffset+2] = 1.0;
|
|
m_rgflLinesData[dwOffset+3] = xPos1;
|
|
m_rgflLinesData[dwOffset+4] = yPos1;
|
|
m_rgflLinesData[dwOffset+5] = 1.0;
|
|
|
|
dwOffset = m_dwLinesToFlush*8;
|
|
m_rgflLinesColorData[dwOffset] = COLOR_RED( dwColor0 );
|
|
m_rgflLinesColorData[dwOffset+1] = COLOR_GREEN( dwColor0 );
|
|
m_rgflLinesColorData[dwOffset+2] = COLOR_BLUE( dwColor0 );
|
|
m_rgflLinesColorData[dwOffset+3] = COLOR_ALPHA( dwColor0 );
|
|
m_rgflLinesColorData[dwOffset+4] = COLOR_RED( dwColor1 );
|
|
m_rgflLinesColorData[dwOffset+5] = COLOR_GREEN( dwColor1 );
|
|
m_rgflLinesColorData[dwOffset+6] = COLOR_BLUE( dwColor1 );
|
|
m_rgflLinesColorData[dwOffset+7] = COLOR_ALPHA( dwColor1 );
|
|
|
|
++m_dwLinesToFlush;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Flush batched lines to the screen
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BFlushLineBuffer()
|
|
{
|
|
if ( !m_pPSGLContext || !m_pPSGLDevice || !m_rgflLinesColorData || !m_rgflLinesData || m_bShuttingDown )
|
|
return false;
|
|
|
|
if ( m_dwLinesToFlush )
|
|
{
|
|
glColorPointer( 4, GL_UNSIGNED_BYTE, 0, m_rgflLinesColorData );
|
|
glVertexPointer( 3, GL_FLOAT, 0, m_rgflLinesData );
|
|
glDrawArrays( GL_LINES, 0, m_dwLinesToFlush*2 );
|
|
|
|
m_dwLinesToFlush = 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw a point, the engine internally manages a vertex buffer for batching these
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BDrawPoint( float xPos, float yPos, DWORD dwColor )
|
|
{
|
|
|
|
if ( !m_pPSGLContext || !m_pPSGLDevice || m_bShuttingDown )
|
|
return false;
|
|
|
|
|
|
// Check if we are out of room and need to flush the buffer
|
|
if ( m_dwPointsToFlush == POINT_BUFFER_TOTAL_SIZE )
|
|
{
|
|
BFlushPointBuffer();
|
|
}
|
|
|
|
DWORD dwOffset = m_dwPointsToFlush*3;
|
|
m_rgflPointsData[dwOffset] = xPos;
|
|
m_rgflPointsData[dwOffset+1] = yPos;
|
|
m_rgflPointsData[dwOffset+2] = 1.0;
|
|
|
|
dwOffset = m_dwPointsToFlush*4;
|
|
m_rgflPointsColorData[dwOffset] = COLOR_RED( dwColor );
|
|
m_rgflPointsColorData[dwOffset+1] = COLOR_GREEN( dwColor );
|
|
m_rgflPointsColorData[dwOffset+2] = COLOR_BLUE( dwColor );
|
|
m_rgflPointsColorData[dwOffset+3] = COLOR_ALPHA( dwColor );
|
|
|
|
++m_dwPointsToFlush;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Flush batched points to the screen
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BFlushPointBuffer()
|
|
{
|
|
if ( !m_pPSGLContext || !m_pPSGLDevice || !m_rgflPointsColorData || !m_rgflPointsData || m_bShuttingDown )
|
|
return false;
|
|
|
|
if ( m_dwPointsToFlush )
|
|
{
|
|
glColorPointer( 4, GL_UNSIGNED_BYTE, 0, m_rgflPointsColorData );
|
|
glVertexPointer( 3, GL_FLOAT, 0, m_rgflPointsData );
|
|
glDrawArrays( GL_POINTS, 0, m_dwPointsToFlush );
|
|
|
|
m_dwPointsToFlush = 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw a filled quad
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BDrawFilledQuad( 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 BDrawTexturedQuad( xPos0, yPos0, xPos1, yPos1, 0.0f, 0.0f, 1.0f, 1.0f, dwColor, m_hTextureWhite );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw a textured quad
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BDrawTexturedQuad( float xPos0, float yPos0, float xPos1, float yPos1, float u0, float v0, float u1, float v1, DWORD dwColor, HGAMETEXTURE hTexture )
|
|
{
|
|
return BDrawTexturedGradientQuad( xPos0, yPos0, xPos1, yPos1, u0, v0, u1, v1, dwColor, dwColor, dwColor, dwColor, hTexture );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw a textured quad, with different colors at each vertex
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BDrawTexturedGradientQuad( float xPos0, float yPos0, float xPos1, float yPos1,
|
|
float u0, float v0, float u1, float v1,
|
|
DWORD dwColorTopLeft, DWORD dwColorTopRight, DWORD dwColorBottomLeft, DWORD dwColorBottomRight, HGAMETEXTURE hTexture )
|
|
{
|
|
if ( m_bShuttingDown || !m_pPSGLDevice || !m_pPSGLContext )
|
|
return false;
|
|
|
|
// 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;
|
|
}
|
|
|
|
// Check if we are out of room and need to flush the buffer, or if our texture is changing
|
|
// then we also need to flush the buffer.
|
|
if ( m_dwQuadsToFlush == QUAD_BUFFER_TOTAL_SIZE || m_hLastTexture != hTexture )
|
|
{
|
|
BFlushQuadBuffer();
|
|
}
|
|
|
|
// Bind the new texture
|
|
glBindTexture( GL_TEXTURE_2D, iter->second.m_uTextureID );
|
|
|
|
DWORD dwOffset = m_dwQuadsToFlush*12;
|
|
m_rgflQuadsData[dwOffset] = xPos0;
|
|
m_rgflQuadsData[dwOffset+1] = yPos0;
|
|
m_rgflQuadsData[dwOffset+2] = 1.0f;
|
|
m_rgflQuadsData[dwOffset+3] = xPos1;
|
|
m_rgflQuadsData[dwOffset+4] = yPos0;
|
|
m_rgflQuadsData[dwOffset+5] = 1.0f;
|
|
m_rgflQuadsData[dwOffset+6] = xPos1;
|
|
m_rgflQuadsData[dwOffset+7] = yPos1;
|
|
m_rgflQuadsData[dwOffset+8] = 1.0f;
|
|
m_rgflQuadsData[dwOffset+9] = xPos0;
|
|
m_rgflQuadsData[dwOffset+10] = yPos1;
|
|
m_rgflQuadsData[dwOffset+11] = 1.0f;
|
|
|
|
dwOffset = m_dwQuadsToFlush*16;
|
|
m_rgflQuadsColorData[dwOffset] = COLOR_RED( dwColorTopLeft );
|
|
m_rgflQuadsColorData[dwOffset+1] = COLOR_GREEN( dwColorTopLeft );
|
|
m_rgflQuadsColorData[dwOffset+2] = COLOR_BLUE( dwColorTopLeft );
|
|
m_rgflQuadsColorData[dwOffset+3] = COLOR_ALPHA( dwColorTopLeft );
|
|
m_rgflQuadsColorData[dwOffset+4] = COLOR_RED( dwColorTopRight );
|
|
m_rgflQuadsColorData[dwOffset+5] = COLOR_GREEN( dwColorTopRight );
|
|
m_rgflQuadsColorData[dwOffset+6] = COLOR_BLUE( dwColorTopRight );
|
|
m_rgflQuadsColorData[dwOffset+7] = COLOR_ALPHA( dwColorTopRight );
|
|
m_rgflQuadsColorData[dwOffset+8] = COLOR_RED( dwColorBottomLeft );
|
|
m_rgflQuadsColorData[dwOffset+9] = COLOR_GREEN( dwColorBottomLeft );
|
|
m_rgflQuadsColorData[dwOffset+10] = COLOR_BLUE( dwColorBottomLeft );
|
|
m_rgflQuadsColorData[dwOffset+11] = COLOR_ALPHA( dwColorBottomLeft );
|
|
m_rgflQuadsColorData[dwOffset+12] = COLOR_RED( dwColorBottomRight );
|
|
m_rgflQuadsColorData[dwOffset+13] = COLOR_GREEN( dwColorBottomRight );
|
|
m_rgflQuadsColorData[dwOffset+14] = COLOR_BLUE( dwColorBottomRight );
|
|
m_rgflQuadsColorData[dwOffset+15] = COLOR_ALPHA( dwColorBottomRight );
|
|
|
|
dwOffset = m_dwQuadsToFlush*8;
|
|
m_rgflQuadsTextureData[dwOffset] = u0;
|
|
m_rgflQuadsTextureData[dwOffset+1] = v0;
|
|
m_rgflQuadsTextureData[dwOffset+2] = u1;
|
|
m_rgflQuadsTextureData[dwOffset+3] = v0;
|
|
m_rgflQuadsTextureData[dwOffset+4] = u1;
|
|
m_rgflQuadsTextureData[dwOffset+5] = v1;
|
|
m_rgflQuadsTextureData[dwOffset+6] = u0;
|
|
m_rgflQuadsTextureData[dwOffset+7] = v1;
|
|
|
|
|
|
++m_dwQuadsToFlush;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Flush buffered quads
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BFlushQuadBuffer()
|
|
{
|
|
if ( !m_pPSGLContext || !m_pPSGLDevice || !m_rgflPointsColorData || !m_rgflPointsData || m_bShuttingDown )
|
|
return false;
|
|
|
|
if ( m_dwQuadsToFlush )
|
|
{
|
|
glEnable( GL_TEXTURE_2D );
|
|
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
|
|
|
|
glColorPointer( 4, GL_UNSIGNED_BYTE, 0, m_rgflQuadsColorData );
|
|
glVertexPointer( 3, GL_FLOAT, 0, m_rgflQuadsData );
|
|
glTexCoordPointer( 2, GL_FLOAT, 0, m_rgflQuadsTextureData );
|
|
glDrawArrays( GL_QUADS, 0, m_dwQuadsToFlush*4 );
|
|
|
|
glDisable( GL_TEXTURE_2D );
|
|
glDisableClientState( GL_TEXTURE_COORD_ARRAY );
|
|
|
|
m_dwQuadsToFlush = 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Creates a new texture
|
|
//-----------------------------------------------------------------------------
|
|
HGAMETEXTURE CGameEnginePS3::HCreateTexture( byte *pRGBAData, uint32 uWidth, uint32 uHeight )
|
|
{
|
|
if ( m_bShuttingDown || !m_pPSGLDevice || !m_pPSGLContext )
|
|
return 0;
|
|
|
|
BFlushQuadBuffer();
|
|
|
|
TextureData_t TexData;
|
|
TexData.m_uWidth = uWidth;
|
|
TexData.m_uHeight = uHeight;
|
|
TexData.m_uTextureID = 0;
|
|
|
|
glEnable( GL_TEXTURE_2D );
|
|
glGenTextures( 1, &TexData.m_uTextureID );
|
|
glBindTexture( GL_TEXTURE_2D, TexData.m_uTextureID );
|
|
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0 );
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0 );
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
|
|
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
|
|
|
|
// build our texture mipmaps
|
|
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, uWidth, uHeight, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, (void *)pRGBAData );
|
|
glDisable( GL_TEXTURE_2D );
|
|
|
|
int nHandle = m_nNextTextureHandle;
|
|
++m_nNextTextureHandle;
|
|
m_MapTextures[nHandle] = TexData;
|
|
|
|
return nHandle;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Creates a new font
|
|
//-----------------------------------------------------------------------------
|
|
HGAMEFONT CGameEnginePS3::HCreateFont( int nHeight, int nFontWeight, bool bItalic, const char * pchFont )
|
|
{
|
|
HGAMEFONT hFont = m_nNextFontHandle;
|
|
++m_nNextFontHandle;
|
|
|
|
// weight + italic are not supported in our dbg font output on ps3. Neither is specifying font.
|
|
// We also have to compute a "scale" relative to screen size, so it may not match pc exactly.
|
|
|
|
// 1.0f for scale means 80 characters fit the screen width, 32 lines fit the height.
|
|
// We'll call that 1.0 scale font roughly equivalent to 28pt font height on pc/d3d.
|
|
|
|
PS3DbgFont_t font;
|
|
font.m_nScale = (float)nHeight/28.0f;
|
|
m_MapGameFonts[ hFont ] = font;
|
|
|
|
return hFont;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draws text to the screen inside the given rectangular region, using the given font
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::BDrawString( HGAMEFONT hFont, RECT rect, DWORD dwColor, DWORD dwFormat, const char *pchText )
|
|
{
|
|
if ( !hFont )
|
|
{
|
|
OutputDebugString( "Someone is calling BDrawString with a null font handle\n" );
|
|
return false;
|
|
}
|
|
|
|
float fCharWidth = m_nWindowWidth/80.0f;
|
|
float fCharHeight = m_nWindowHeight/32.0f;
|
|
|
|
// Find the font object for the passed handle
|
|
std::map<HGAMEFONT, PS3DbgFont_t>::iterator iter;
|
|
iter = m_MapGameFonts.find( hFont );
|
|
if ( iter == m_MapGameFonts.end() )
|
|
{
|
|
OutputDebugString( "Invalid font handle passed to BDrawString()\n" );
|
|
return false;
|
|
}
|
|
|
|
fCharWidth *= iter->second.m_nScale;
|
|
fCharHeight *= iter->second.m_nScale;
|
|
|
|
// Compute width/height in chars/lines
|
|
int nLinesInText = 1;
|
|
int nCharsWideMax = 0;
|
|
int nCharsLine = 0;
|
|
for( int i=0; i < strlen(pchText); ++i )
|
|
{
|
|
if ( pchText[i] == '\n' )
|
|
{
|
|
++nLinesInText;
|
|
nCharsWideMax = MAX( nCharsLine, nCharsWideMax );
|
|
nCharsLine = 0;
|
|
}
|
|
else
|
|
{
|
|
// We assume all non linebreak chars are printable, don't pass others!
|
|
++nCharsLine;
|
|
}
|
|
}
|
|
nCharsWideMax = MAX( nCharsLine, nCharsWideMax );
|
|
|
|
// Assume top left positioning
|
|
float x = (float)rect.left;
|
|
float y = (float)rect.top;
|
|
|
|
if ( TEXTPOS_CENTER & dwFormat )
|
|
{
|
|
float fTextWidth = nCharsWideMax * fCharWidth;
|
|
x = (float)rect.left + ((float)( rect.right-rect.left) - fTextWidth)/2.0f;
|
|
}
|
|
else if ( TEXTPOS_RIGHT &dwFormat )
|
|
{
|
|
float fTextWidth = nCharsWideMax * fCharWidth;
|
|
x = (float)rect.right - fTextWidth;
|
|
}
|
|
|
|
if ( TEXTPOS_VCENTER & dwFormat )
|
|
{
|
|
float fTextHeight = nLinesInText * fCharHeight;
|
|
y = (float)rect.top + ((float)( rect.bottom-rect.top) - fTextHeight)/2.0f;
|
|
}
|
|
else if ( TEXTPOS_RIGHT &dwFormat )
|
|
{
|
|
float fTextHeight = nLinesInText * fCharHeight;
|
|
y = (float)rect.bottom - fTextHeight;
|
|
}
|
|
|
|
// Convert x/y to 0.0->1.0 range vs screen size
|
|
x = x/(float)m_nWindowWidth;
|
|
y = y/(float)m_nWindowHeight;
|
|
|
|
// we have the font, try to draw with it
|
|
if( cellDbgFontPuts( x, y, iter->second.m_nScale, DWARGB_TO_DWABGR(dwColor), pchText ) < 0 )
|
|
{
|
|
OutputDebugString( "cellDbgFontPuts call failed\n" );
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Message pump for OS messages
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::MessagePump()
|
|
{
|
|
cellSysutilCheckCallback();
|
|
|
|
// Running callbacks may have triggered shutdown, if not run input
|
|
if ( !m_bShuttingDown )
|
|
{
|
|
CellPadInfo2 padInfo;
|
|
int ret = cellPadGetInfo2( &padInfo );
|
|
if ( ret == CELL_OK )
|
|
{
|
|
if ( padInfo.system_info & CELL_PAD_INFO_INTERCEPTED )
|
|
{
|
|
// System has taken control of controller info, we can't currently access it.
|
|
}
|
|
|
|
bool bControllerFound = false;
|
|
m_iCurrentPadIndex = -1;
|
|
for( int i=0; i < CELL_PAD_MAX_PORT_NUM; ++i )
|
|
{
|
|
if ( padInfo.port_status[i] & CELL_PAD_STATUS_ASSIGN_CHANGES )
|
|
{
|
|
if ( (padInfo.port_status[i] & CELL_PAD_STATUS_CONNECTED) == 0 )
|
|
{
|
|
char rgchBuffer[512];
|
|
sprintf_safe( rgchBuffer, "Gamepad %d removed\n", i );
|
|
OutputDebugString( rgchBuffer );
|
|
}
|
|
else if ( (padInfo.port_status[i] & CELL_PAD_STATUS_CONNECTED) > 0 )
|
|
{
|
|
char rgchBuffer[512];
|
|
sprintf_safe( rgchBuffer, "Gamepad %d connected\n", i );
|
|
OutputDebugString( rgchBuffer );
|
|
}
|
|
}
|
|
|
|
if ( (padInfo.port_status[i] & CELL_PAD_STATUS_CONNECTED ) > 0 && padInfo.device_type[i] == CELL_PAD_DEV_TYPE_STANDARD )
|
|
{
|
|
bControllerFound = true;
|
|
m_iCurrentPadIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( padInfo.system_info & CELL_PAD_INFO_INTERCEPTED )
|
|
{
|
|
// Pass zeroed pad data to overlay to clear it's button state too
|
|
SteamPS3OverlayRender()->BResetInputState();
|
|
|
|
// Clear all keys
|
|
m_SetKeysDown.clear();
|
|
}
|
|
|
|
if ( !bControllerFound )
|
|
{
|
|
// Definitely no appropriate controller plugged in, can't do input
|
|
static DWORD dwLastSpewTime = 0;
|
|
if ( GetGameTickCount() - dwLastSpewTime > 3000 || dwLastSpewTime == 0 || dwLastSpewTime > GetGameTickCount() )
|
|
{
|
|
dwLastSpewTime = GetGameTickCount();
|
|
OutputDebugString( "No supported controllers are active, activate one.\n" );
|
|
}
|
|
|
|
// Pass zeroed pad data to overlay to clear it's button state too
|
|
SteamPS3OverlayRender()->BResetInputState();
|
|
|
|
// Clear all keys
|
|
m_SetKeysDown.clear();
|
|
}
|
|
else
|
|
{
|
|
// Get status of the first found controller now
|
|
CellPadData padData;
|
|
int ret = cellPadGetData( m_iCurrentPadIndex, &padData );
|
|
|
|
// If we got data ok, and if the data is new (len != 0) then process it
|
|
if ( ret == CELL_OK && padData.len )
|
|
{
|
|
if ( !SteamPS3OverlayRender()->BHandleCellPadData( padData ) )
|
|
{
|
|
if ( padData.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_R2 )
|
|
{
|
|
m_SetKeysDown.insert( 0x57 ); // W key, thrusters, mapped to R2 on PS3
|
|
}
|
|
else
|
|
{
|
|
m_SetKeysDown.erase( 0x57 );
|
|
}
|
|
|
|
if ( padData.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_L2 )
|
|
{
|
|
m_SetKeysDown.insert( 0x53 ); // S key, reverse thrusters, mapped to L2 on PS3
|
|
}
|
|
else
|
|
{
|
|
m_SetKeysDown.erase( 0x53 );
|
|
}
|
|
|
|
if ( padData.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_CROSS )
|
|
{
|
|
// Mapped to both enter in menus, and fire in game
|
|
m_SetKeysDown.insert( VK_RETURN );
|
|
m_SetKeysDown.insert( VK_SPACE );
|
|
}
|
|
else
|
|
{
|
|
m_SetKeysDown.erase( VK_RETURN );
|
|
m_SetKeysDown.erase( VK_SPACE );
|
|
}
|
|
|
|
if ( padData.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_CIRCLE )
|
|
{
|
|
m_SetKeysDown.insert( VK_ESCAPE );
|
|
}
|
|
else
|
|
{
|
|
m_SetKeysDown.erase( VK_ESCAPE );
|
|
}
|
|
|
|
if ( padData.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_UP || padData.button[CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y] == 0x00 )
|
|
{
|
|
m_SetKeysDown.insert( VK_UP );
|
|
}
|
|
else
|
|
{
|
|
m_SetKeysDown.erase( VK_UP );
|
|
}
|
|
|
|
if ( padData.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_DOWN || padData.button[CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y] == 0xFF )
|
|
{
|
|
m_SetKeysDown.insert( VK_DOWN );
|
|
}
|
|
else
|
|
{
|
|
m_SetKeysDown.erase( VK_DOWN );
|
|
}
|
|
|
|
if ( padData.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_LEFT || padData.button[CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X] == 0x00 )
|
|
{
|
|
m_SetKeysDown.insert( 0x41 ); // A Key, mapped to left on PS3
|
|
}
|
|
else
|
|
{
|
|
m_SetKeysDown.erase( 0x41 );
|
|
}
|
|
|
|
if ( padData.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_RIGHT || padData.button[CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X] == 0xFF )
|
|
{
|
|
m_SetKeysDown.insert( 0x44 ); // D key, mapped to right on PS3
|
|
}
|
|
else
|
|
{
|
|
m_SetKeysDown.erase( 0x44 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find out if a key is currently down
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::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 CGameEnginePS3::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 ptr
|
|
//-----------------------------------------------------------------------------
|
|
CGameEnginePS3 * CGameEnginePS3::FindEngineInstanceForPtr( void *ptr )
|
|
{
|
|
std::map<void *, CGameEnginePS3 *>::iterator iter;
|
|
iter = m_MapEngineInstances.find( ptr );
|
|
if ( iter == m_MapEngineInstances.end() )
|
|
return NULL;
|
|
else
|
|
return iter->second;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Add the engine instance tied to a given ptr to our static map
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::AddInstanceToPtrMap( CGameEnginePS3 *pInstance )
|
|
{
|
|
m_MapEngineInstances[(void*)pInstance] = pInstance;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Removes the instance associated with a given ptr from the map
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::RemoveInstanceFromPtrMap( void *ptr )
|
|
{
|
|
std::map<void *, CGameEnginePS3 *>::iterator iter;
|
|
iter = m_MapEngineInstances.find( ptr );
|
|
if ( iter != m_MapEngineInstances.end() )
|
|
m_MapEngineInstances.erase( iter );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
HGAMEVOICECHANNEL CGameEnginePS3::HCreateVoiceChannel()
|
|
{
|
|
m_unVoiceChannelCount++;
|
|
CVoiceContext* pVoiceContext = new CVoiceContext;
|
|
|
|
CellVoicePortParam PortArgs;
|
|
memset( &PortArgs, 0, sizeof(PortArgs) );
|
|
|
|
PortArgs.portType = CELLVOICE_PORTTYPE_IN_PCMAUDIO;
|
|
PortArgs.bMute = false;
|
|
PortArgs.threshold = 100;
|
|
PortArgs.volume = 1.0f;
|
|
PortArgs.pcmaudio.format.sampleRate= CELLVOICE_SAMPLINGRATE_16000;
|
|
PortArgs.pcmaudio.format.dataType = CELLVOICE_PCM_SHORT;
|
|
PortArgs.pcmaudio.bufSize = 11000;
|
|
|
|
int ret= cellVoiceCreatePort( &pVoiceContext->m_PortIdInput, &PortArgs );
|
|
|
|
PortArgs.portType = CELLVOICE_PORTTYPE_OUT_SECONDARY;
|
|
PortArgs.bMute = false;
|
|
PortArgs.threshold = 100;
|
|
PortArgs.volume = 1.0f;
|
|
PortArgs.device.playerId = 0;
|
|
|
|
ret = cellVoiceCreatePort( &pVoiceContext->m_PortIdOutput, &PortArgs );
|
|
|
|
ret = cellVoiceConnectIPortToOPort( pVoiceContext->m_PortIdInput, pVoiceContext->m_PortIdOutput );
|
|
|
|
if( ret != CELL_OK )
|
|
{
|
|
delete pVoiceContext;
|
|
return 0; // failed
|
|
}
|
|
|
|
if ( m_unVoiceChannelCount == 1 )
|
|
{
|
|
CellVoiceStartParam startParams;
|
|
startParams.container = SYS_MEMORY_CONTAINER_ID_INVALID;
|
|
ret = sys_memory_container_create(&startParams.container,1024*1024);
|
|
ret = cellVoiceStartEx(&startParams);
|
|
}
|
|
|
|
m_MapVoiceChannel[m_unVoiceChannelCount] = pVoiceContext;
|
|
|
|
return m_unVoiceChannelCount;
|
|
}
|
|
|
|
void CGameEnginePS3::RunAudio()
|
|
{
|
|
std::map<HGAMEVOICECHANNEL, CVoiceContext* >::iterator iter;
|
|
|
|
for( iter = m_MapVoiceChannel.begin(); iter!=m_MapVoiceChannel.end(); ++iter)
|
|
{
|
|
CVoiceContext* pVoiceContext = iter->second;
|
|
|
|
PacketQueue_t *pVoicePacket = pVoiceContext->m_pQueue;
|
|
|
|
if ( pVoicePacket )
|
|
{
|
|
CellVoiceBasePortInfo PortInfo;
|
|
memset(&PortInfo, 0, sizeof(PortInfo));
|
|
int Result = cellVoiceGetPortInfo( pVoiceContext->m_PortIdInput, &PortInfo );
|
|
if (Result != CELL_OK && Result != CELL_VOICE_ERROR_SERVICE_DETACHED )
|
|
{
|
|
printf("cellVoiceGetPortInfo PCMInputPort failed %x\n",Result);
|
|
}
|
|
|
|
if ( PortInfo.numByte > pVoicePacket->unSize )
|
|
{
|
|
uint32_t bytes = pVoicePacket->unSize;
|
|
Result = cellVoiceWriteToIPort( pVoiceContext->m_PortIdInput, pVoicePacket->pData, &bytes );
|
|
pVoicePacket->unWritten += bytes;
|
|
|
|
if ( pVoicePacket->unWritten >= pVoicePacket->unSize )
|
|
{
|
|
pVoiceContext->m_pQueue = pVoicePacket->pNext;
|
|
free( pVoicePacket->pData );
|
|
delete pVoicePacket;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::DestroyVoiceChannel( HGAMEVOICECHANNEL hChannel )
|
|
{
|
|
std::map<HGAMEVOICECHANNEL, CVoiceContext* >::iterator iter;
|
|
iter = m_MapVoiceChannel.find( hChannel );
|
|
if ( iter != m_MapVoiceChannel.end() )
|
|
{
|
|
CVoiceContext* pVoiceContext = iter->second;
|
|
|
|
// free outstanding voice packets
|
|
|
|
PacketQueue_t *pVoicePacket = pVoiceContext->m_pQueue;
|
|
|
|
while( pVoicePacket )
|
|
{
|
|
PacketQueue_t *pNextPacket = pVoicePacket->pNext;
|
|
|
|
free( pVoicePacket->pData );
|
|
delete pVoicePacket;
|
|
|
|
pVoicePacket = pNextPacket;
|
|
}
|
|
|
|
// stop voice
|
|
|
|
cellVoiceDisconnectIPortFromOPort( pVoiceContext->m_PortIdInput, pVoiceContext->m_PortIdOutput );
|
|
cellVoiceDeletePort( pVoiceContext->m_PortIdInput );
|
|
cellVoiceDeletePort( pVoiceContext->m_PortIdOutput );
|
|
|
|
delete pVoiceContext;
|
|
|
|
m_MapVoiceChannel.erase( iter );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CGameEnginePS3::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;
|
|
|
|
PacketQueue_t *pVoicePacket = new PacketQueue_t;
|
|
|
|
pVoicePacket->pData = malloc ( uLength );
|
|
memcpy( pVoicePacket->pData, pVoiceData, uLength );
|
|
pVoicePacket->unSize = uLength;
|
|
pVoicePacket->pNext = NULL;
|
|
pVoicePacket->unWritten = 0;
|
|
|
|
if ( pVoiceContext->m_pQueue == NULL )
|
|
{
|
|
// start queue
|
|
pVoiceContext->m_pQueue = pVoicePacket;
|
|
}
|
|
else
|
|
{
|
|
PacketQueue_t *pLastPacket = pVoiceContext->m_pQueue;
|
|
|
|
// find tail
|
|
while ( pLastPacket->pNext )
|
|
pLastPacket = pLastPacket->pNext;
|
|
|
|
// append to tail
|
|
pLastPacket->pNext = pVoicePacket;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Part of the render host interface for Steam overlay to draw through
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::DrawTexturedRect( int x0, int y0, int x1, int y1, float u0, float v0, float u1, float v1, int32 iTextureID, DWORD colorStart, DWORD colorEnd, EOverlayGradientDirection eDirection )
|
|
{
|
|
std::map<int, HGAMETEXTURE>::iterator iter;
|
|
iter = m_MapSteamTextures.find( iTextureID );
|
|
if ( iter != m_MapSteamTextures.end() )
|
|
{
|
|
if ( eDirection == k_EOverlayGradientHorizontal )
|
|
BDrawTexturedGradientQuad( x0, y0, x1, y1, u0, v0, u1, v1, colorStart, colorEnd, colorEnd, colorStart, iter->second );
|
|
else if ( eDirection == k_EOverlayGradientVertical )
|
|
BDrawTexturedGradientQuad( x0, y0, x1, y1, u0, v0, u1, v1, colorStart, colorStart, colorEnd, colorEnd, iter->second );
|
|
else
|
|
BDrawTexturedGradientQuad( x0, y0, x1, y1, u0, v0, u1, v1, colorStart, colorStart, colorStart, colorStart, iter->second );
|
|
|
|
}
|
|
else
|
|
{
|
|
char rgchBuf[512];
|
|
sprintf_safe( rgchBuf, "Steam trying to draw for invalid textureid: %d\n", iTextureID );
|
|
OutputDebugString( rgchBuf );
|
|
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Part of the render host interface for Steam overlay to draw through
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::LoadOrUpdateTexture( int32 iTextureID, bool bIsFullTexture, int x0, int y0, uint32 uWidth, uint32 uHeight, int32 iBytes, char *pData )
|
|
{
|
|
BFlushQuadBuffer();
|
|
m_hLastTexture = 0;
|
|
|
|
if ( !bIsFullTexture )
|
|
{
|
|
bool bUpdated = false;
|
|
std::map<int, HGAMETEXTURE>::iterator iter_steam;
|
|
iter_steam = m_MapSteamTextures.find( iTextureID );
|
|
if ( iter_steam != m_MapSteamTextures.end() )
|
|
{
|
|
std::map<HGAMETEXTURE, TextureData_t>::iterator iter_game;
|
|
iter_game = m_MapTextures.find( iter_steam->second );
|
|
if ( iter_game != m_MapTextures.end() )
|
|
{
|
|
TextureData_t &TexData = iter_game->second;
|
|
|
|
glEnable( GL_TEXTURE_2D );
|
|
glBindTexture( GL_TEXTURE_2D, TexData.m_uTextureID );
|
|
glTexSubImage2D( GL_TEXTURE_2D, 0, x0, y0, uWidth, uHeight, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, pData );
|
|
glDisable( GL_TEXTURE_2D );
|
|
|
|
bUpdated = true;
|
|
}
|
|
else
|
|
{
|
|
char rgchBuf[512];
|
|
sprintf_safe( rgchBuf, "Couldn't find texture: %d\n", iTextureID );
|
|
OutputDebugString( rgchBuf );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
char rgchBuf[512];
|
|
sprintf_safe( rgchBuf, "Couldn't find Steam mapping for texture: %d\n", iTextureID );
|
|
OutputDebugString( rgchBuf );
|
|
}
|
|
|
|
if ( !bUpdated )
|
|
{
|
|
char rgchBuf[512];
|
|
sprintf_safe( rgchBuf, "Failed updating texture: %d\n", iTextureID );
|
|
OutputDebugString( rgchBuf );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HGAMETEXTURE hGameTexture = HCreateTexture( (byte*)pData, uWidth, uHeight );
|
|
m_MapSteamTextures[iTextureID] = hGameTexture;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Part of the render host interface for Steam overlay to draw through
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::DeleteTexture( int32 iTextureID )
|
|
{
|
|
std::map<int, HGAMETEXTURE>::iterator iter;
|
|
iter = m_MapSteamTextures.find( iTextureID );
|
|
if ( iter != m_MapSteamTextures.end() )
|
|
{
|
|
// Our game engine doesn't know how to free textures, lol.
|
|
m_MapSteamTextures.erase( iter );
|
|
}
|
|
else
|
|
{
|
|
char rgchBuf[512];
|
|
sprintf_safe( rgchBuf, "Got DeleteTexture from Steam for texture we don't have mapped: %d\n", iTextureID );
|
|
OutputDebugString( rgchBuf );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Part of the render host interface for Steam overlay to draw through
|
|
//-----------------------------------------------------------------------------
|
|
void CGameEnginePS3::DeleteAllTextures()
|
|
{
|
|
m_MapSteamTextures.clear();
|
|
|
|
// Don't really know how to delete textures in the engine, lol.
|
|
}
|