// ---------------------------------------------------------------------------------------
// Initialize the game sound system
//
// Initialize the game sound system. Depending on what sound library is being used,
// call the appropriate low-level initiailizations
//
// returns: 1 => init success
// 0 => init failed
//
int snd_init(int use_a3d, int use_eax)
{
int rval;
if ( Cmdline_freespace_no_sound )
return 0;
if (ds_initialized) {
nprintf(( "Sound", "SOUND => Direct Sound is already initialized!\n" ));
return 1;
}
snd_clear();
// Init DirectSound
// Connect to DirectSound
int num_tries=0;
int gave_warning = 0;
while(1) {
rval = ds_init(use_a3d, use_eax);
if( rval != 0 ) {
nprintf(( "Sound", "SOUND ==> Error initializing DirectSound, trying again in 1 second.\n"));
Sleep(1000);
} else {
break;
}
if ( num_tries++ > 5 ) {
if ( !gave_warning ) {
MessageBox(NULL, XSTR("DirectSound could not be initialized. If you are running any applications playing sound in the background, you should stop them before continuing.",971), NULL, MB_OK);
gave_warning = 1;
} else {
goto Failure;
}
}
}
// Init the Audio Compression Manager
if ( ACM_init() == -1 ) {
HWND hwnd = (HWND)os_get_window();
MessageBox(hwnd, XSTR("Could not properly initialize the Microsoft ADPCM codec.\n\nPlease see the readme.txt file for detailed instructions on installing the Microsoft ADPCM codec.",972), NULL, MB_OK);
// Warning(LOCATION, "Could not properly initialize the Microsoft ADPCM codec.\nPlease see the readme.txt file for detailed instructions on installing the Microsoft ADPCM codec.");
}
// Init the audio streaming stuff
audiostream_init();
ds_initialized = 1;
return 1;
Failure:
// Warning(LOCATION, "Sound system was unable to be initialized. If you continue, sound will be disabled.\n");
nprintf(( "Sound", "SOUND => Direct Sound init unsuccessful, continuing without sound.\n" ));
return 0;
}
void SDLGraphicsOperations::makeOpenGLContextCurrent(os::OpenGLContext* ctx)
{
if (ctx == nullptr)
{
SDL_GL_MakeCurrent(os_get_window(), nullptr);
} else
{
reinterpret_cast<SDLOpenGLContext*>(ctx)->makeCurrent();
}
}
// portable routine to get the mouse position, relative
// to current window
void setWindowMousePos(POINT * pt)
{
Assert(pt != NULL);
#ifdef _WIN32
ClientToScreen((HWND) os_get_window(), pt);
SetCursorPos(pt->x, pt->y);
#else
SDL_WarpMouse(pt->x, pt->y);
#endif
}
// portable routine to get the mouse position, relative
// to current window
void getWindowMousePos(POINT * pt)
{
Assert(pt != NULL);
#ifdef _WIN32
GetCursorPos(pt);
ScreenToClient((HWND)os_get_window(), pt);
#else
SDL_GetMouseState(&pt->x, &pt->y);
#endif
}
std::unique_ptr<os::OpenGLContext> SDLGraphicsOperations::createOpenGLContext(const os::OpenGLContextAttributes& attrs,
uint32_t width,
uint32_t height) {
mprintf((" Initializing SDL video...\n"));
#ifdef SCP_UNIX
// Slight hack to make Mesa advertise S3TC support without libtxc_dxtn
setenv("force_s3tc_enable", "true", 1);
#endif
if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
Error(LOCATION, "Couldn't init SDL video: %s", SDL_GetError());
return nullptr;
}
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, attrs.red_size);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, attrs.green_size);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, attrs.blue_size);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, attrs.depth_size);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, attrs.stencil_size);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, (attrs.multi_samples == 0) ? 0 : 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, attrs.multi_samples);
mprintf((" Requested SDL Video values = R: %d, G: %d, B: %d, depth: %d, stencil: %d, double-buffer: %d, FSAA: %d\n",
attrs.red_size, attrs.green_size, attrs.blue_size, attrs.depth_size, attrs.stencil_size, 1, attrs.multi_samples));
uint32_t windowflags = SDL_WINDOW_OPENGL;
if (Cmdline_fullscreen_window) {
windowflags |= SDL_WINDOW_BORDERLESS;
}
uint display = os_config_read_uint("Video", "Display", 0);
SDL_Window* window =
SDL_CreateWindow(Osreg_title, SDL_WINDOWPOS_CENTERED_DISPLAY(display), SDL_WINDOWPOS_CENTERED_DISPLAY(display),
width, height, windowflags);
if (window == nullptr) {
Error(LOCATION, "Could not create window: %s\n", SDL_GetError());
return nullptr;
}
os_set_window(window);
auto ctx = SDL_GL_CreateContext(os_get_window());
if (ctx == nullptr) {
Error(LOCATION, "Could not create OpenGL Context: %s\n", SDL_GetError());
return nullptr;
}
int r, g, b, depth, stencil, db, fsaa_samples;
SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &r);
SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &g);
SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &b);
SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &depth);
SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &db);
SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &stencil);
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &fsaa_samples);
mprintf((" Actual SDL Video values = R: %d, G: %d, B: %d, depth: %d, stencil: %d, double-buffer: %d, FSAA: %d\n",
r, g, b, depth, stencil, db, fsaa_samples));
return std::unique_ptr<os::OpenGLContext>(new SDLOpenGLContext(ctx));
}
void swapBuffers() override
{
SDL_GL_SwapWindow(os_get_window());
}
void makeCurrent()
{
SDL_GL_MakeCurrent(os_get_window(), _glCtx);
}
int di_init()
{
HRESULT hr;
return 0;
/*
* Register with the DirectInput subsystem and get a pointer
* to a IDirectInput interface we can use.
*
* Parameters:
*
* g_hinst
*
* Instance handle to our application or DLL.
*
* DIRECTINPUT_VERSION
*
* The version of DirectInput we were designed for.
* We take the value from the <dinput.h> header file.
*
* &g_pdi
*
* Receives pointer to the IDirectInput interface
* that was created.
*
* NULL
*
* We do not use OLE aggregation, so this parameter
* must be NULL.
*
*/
hr = DirectInputCreate(GetModuleHandle(NULL), 0x300, &Di_object, NULL);
if (FAILED(hr)) {
mprintf(( "DirectInputCreate failed!\n" ));
return FALSE;
}
/*
* Obtain an interface to the system keyboard device.
*
* Parameters:
*
* GUID_SysKeyboard
*
* The instance GUID for the device we wish to access.
* GUID_SysKeyboard is a predefined instance GUID that
* always refers to the system keyboard device.
*
* &g_pKeyboard
*
* Receives pointer to the IDirectInputDevice interface
* that was created.
*
* NULL
*
* We do not use OLE aggregation, so this parameter
* must be NULL.
*
*/
hr = Di_object->CreateDevice(GUID_SysKeyboard, &Di_keyboard, NULL);
if (FAILED(hr)) {
mprintf(( "CreateDevice failed!\n" ));
return FALSE;
}
/*
* Set the data format to "keyboard format".
*
* A data format specifies which controls on a device we
* are interested in, and how they should be reported.
*
* This tells DirectInput that we will be passing an array
* of 256 bytes to IDirectInputDevice::GetDeviceState.
*
* Parameters:
*
* c_dfDIKeyboard
*
* Predefined data format which describes
* an array of 256 bytes, one per scancode.
*/
hr = Di_keyboard->SetDataFormat(&c_dfDIKeyboard);
if (FAILED(hr)) {
mprintf(( "SetDataFormat failed!\n" ));
return FALSE;
}
/*
* Set the cooperativity level to let DirectInput know how
* this device should interact with the system and with other
* DirectInput applications.
*
* Parameters:
*
* DISCL_NONEXCLUSIVE
*
* Retrieve keyboard data when acquired, not interfering
* with any other applications which are reading keyboard
* data.
*
* DISCL_FOREGROUND
*
* If the user switches away from our application,
* automatically release the keyboard back to the system.
*
*/
hr = Di_keyboard->SetCooperativeLevel((HWND)os_get_window(), DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
if (FAILED(hr)) {
mprintf(( "SetCooperativeLevel failed!\n" ));
return FALSE;
}
DIPROPDWORD hdr;
// Turn on buffering
hdr.diph.dwSize = sizeof(DIPROPDWORD);
hdr.diph.dwHeaderSize = sizeof(DIPROPHEADER);
hdr.diph.dwObj = 0;
hdr.diph.dwHow = DIPH_DEVICE; // Apply to entire device
hdr.dwData = 16; //MAX_BUFFERED_KEYBOARD_EVENTS;
hr = Di_keyboard->SetProperty( DIPROP_BUFFERSIZE, &hdr.diph );
if (FAILED(hr)) {
mprintf(( "SetProperty DIPROP_BUFFERSIZE failed\n" ));
return FALSE;
}
Di_event = CreateEvent( NULL, FALSE, FALSE, NULL );
Assert(Di_event != NULL);
Di_thread = CreateThread(NULL, 1024, (LPTHREAD_START_ROUTINE)di_process, NULL, 0, &Di_thread_id);
Assert( Di_thread != NULL );
SetThreadPriority(Di_thread, THREAD_PRIORITY_HIGHEST);
hr = Di_keyboard->SetEventNotification(Di_event);
if (FAILED(hr)) {
mprintf(( "SetEventNotification failed\n" ));
return FALSE;
}
Di_keyboard->Acquire();
return TRUE;
}
void _cdecl Warning( char *filename, int line, const char *format, ... )
{
Global_warning_count++;
#ifndef NDEBUG
va_list args;
int result;
int i;
int slen = 0;
// output to the debug log before anything else (so that we have a complete record)
memset( AssertText1, 0, sizeof(AssertText1) );
memset( AssertText2, 0, sizeof(AssertText2) );
va_start(args, format);
vsnprintf(AssertText1, sizeof(AssertText1) - 1, format, args);
va_end(args);
slen = strlen(AssertText1);
// strip out the newline char so the output looks better
for (i = 0; i < slen; i++){
if (AssertText1[i] == (char)0x0a) {
AssertText2[i] = ' ';
} else {
AssertText2[i] = AssertText1[i];
}
}
// kill off extra white space at end
if (AssertText2[slen-1] == (char)0x20) {
AssertText2[slen-1] = '\0';
} else {
// just being careful
AssertText2[slen] = '\0';
}
mprintf(("WARNING: \"%s\" at %s:%d\n", AssertText2, strrchr(filename, '\\')+1, line));
// now go for the additional popup window, if we want it ...
#ifdef Allow_NoWarn
if (Cmdline_nowarn) {
return;
}
#endif
filename = strrchr(filename, '\\')+1;
sprintf(AssertText2, "Warning: %s\r\nFile: %s\r\nLine: %d\r\n", AssertText1, filename, line );
Messagebox_active = true;
gr_activate(0);
#if defined( SHOW_CALL_STACK ) && defined( PDB_DEBUGGING )
/* Dump the callstack */
SCP_DebugCallStack callStack;
SCP_DumpStack( dynamic_cast< SCP_IDumpHandler* >( &callStack ) );
/* Format the string */
SCP_string assertString( AssertText1 );
assertString += "\n";
assertString += callStack.DumpToString( );
/* Copy to the clipboard */
dump_text_to_clipboard( assertString.c_str( ) );
// truncate text
truncate_message_lines(assertString, Messagebox_lines);
assertString += "\n[ This info is in the clipboard so you can paste it somewhere now ]\n";
assertString += "\n\nUse Yes to break into Debugger, No to continue.\nand Cancel to Quit\n";
result = MessageBox( NULL, assertString.c_str( ), "Warning!", MB_YESNOCANCEL | MB_DEFBUTTON2 | MB_ICONWARNING | flags );
#elif defined ( SHOW_CALL_STACK )
//we don't want to dump the call stack for every single warning
Dump_to_log = false;
dumpBuffer.Clear();
dumpBuffer.Printf( AssertText2 );
dumpBuffer.Printf( "\r\n" );
DumpCallsStack( dumpBuffer ) ;
dump_text_to_clipboard(dumpBuffer.buffer);
// truncate text
dumpBuffer.TruncateLines(Messagebox_lines);
dumpBuffer.Printf( "\r\n[ This info is in the clipboard so you can paste it somewhere now ]\r\n" );
dumpBuffer.Printf("\r\n\r\nUse Yes to break into Debugger, No to continue.\r\nand Cancel to Quit");
result = MessageBox((HWND)os_get_window(), dumpBuffer.buffer, "Warning!", MB_YESNOCANCEL | MB_DEFBUTTON2 | MB_ICONWARNING | flags );
Dump_to_log = true;
#else
strcat_s(AssertText2,"\r\n\r\nUse Yes to break into Debugger, No to continue.\r\nand Cancel to Quit");
result = MessageBox((HWND)os_get_window(), AssertText2, "Warning!", MB_YESNOCANCEL | MB_DEFBUTTON2 | MB_ICONWARNING | flags );
#endif
switch (result)
{
case IDYES:
Int3();
break;
case IDNO:
break;
case IDCANCEL:
exit(1);
}
gr_activate(1);
Messagebox_active = false;
#endif // !NDEBUG
}
int di_init()
{
HRESULT hr;
if (Mouse_mode == MOUSE_MODE_WIN){
return 0;
}
Di_mouse_inited = 0;
hr = DirectInputCreate(GetModuleHandle(NULL), DIRECTINPUT_VERSION, &Di_mouse_obj, NULL);
if (FAILED(hr)) {
hr = DirectInputCreate(GetModuleHandle(NULL), 0x300, &Di_mouse_obj, NULL);
if (FAILED(hr)) {
mprintf(( "DirectInputCreate() failed!\n" ));
return FALSE;
}
}
hr = Di_mouse_obj->CreateDevice(GUID_SysMouse, &Di_mouse, NULL);
if (FAILED(hr)) {
mprintf(( "CreateDevice() failed!\n" ));
return FALSE;
}
hr = Di_mouse->SetDataFormat(&c_dfDIMouse);
if (FAILED(hr)) {
mprintf(( "SetDataFormat() failed!\n" ));
return FALSE;
}
hr = Di_mouse->SetCooperativeLevel((HWND)os_get_window(), DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
if (FAILED(hr)) {
mprintf(( "SetCooperativeLevel() failed!\n" ));
return FALSE;
}
/*
DIPROPDWORD hdr;
// Turn on buffering
hdr.diph.dwSize = sizeof(DIPROPDWORD);
hdr.diph.dwHeaderSize = sizeof(DIPROPHEADER);
hdr.diph.dwObj = 0;
hdr.diph.dwHow = DIPH_DEVICE; // Apply to entire device
hdr.dwData = 16; //MAX_BUFFERED_KEYBOARD_EVENTS;
hr = Di_mouse->SetProperty( DIPROP_BUFFERSIZE, &hdr.diph );
if (FAILED(hr)) {
mprintf(( "SetProperty DIPROP_BUFFERSIZE failed\n" ));
return FALSE;
}
Di_event = CreateEvent( NULL, FALSE, FALSE, NULL );
Assert(Di_event != NULL);
hr = Di_mouse->SetEventNotification(Di_event);
if (FAILED(hr)) {
mprintf(( "SetEventNotification failed\n" ));
return FALSE;
}
*/
Di_mouse->Acquire();
Di_mouse_inited = 1;
return TRUE;
}
// portable routine to get the mouse position, relative
// to current window
void setWindowMousePos(POINT * pt)
{
Assert(pt != NULL);
ClientToScreen((HWND) os_get_window(), pt);
SetCursorPos(pt->x, pt->y);
}
// portable routine to get the mouse position, relative
// to current window
void getWindowMousePos(POINT * pt)
{
Assert(pt != NULL);
GetCursorPos(pt);
ScreenToClient((HWND)os_get_window(), pt);
}
