RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e0675225989be571b799ac5eb9b1f7adf2d68e21
Client/Library/dxx8/samples/Multimedia/DirectSound/SoundFX/soundfx.cpp
LGram16 e067522598 Initial commit: ROW Client source code 
Game client codebase including:
- CharacterActionControl: Character and creature management
- GlobalScript: Network, items, skills, quests, utilities
- RYLClient: Main client application with GUI and event handlers
- Engine: 3D rendering engine (RYLGL)
- MemoryManager: Custom memory allocation
- Library: Third-party dependencies (DirectX, boost, etc.)
- Tools: Development utilities

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
2025-11-29 16:24:34 +09:00

1395 lines
54 KiB
C++
Raw Blame History

//-----------------------------------------------------------------------------
// File: SoundFX.cpp
//
// Desc: Sample to demonstrate soundFX and parameters in directX
//
//
// Copyright ( c ) 1998-2001 Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#define STRICT
#include <windows.h>
#include <basetsd.h>
#include <mmsystem.h>
#include <mmreg.h>
#include <dxerr8.h>
#include <dsound.h>
#include <cguid.h>
#include <commctrl.h>
#include <commdlg.h>
#include <dsound.h>
#include <stdio.h>
#include "DSUtil.h"
#include "DXUtil.h"
#include "resource.h"
//-----------------------------------------------------------------------------
// Function-prototypes
//-----------------------------------------------------------------------------
INT_PTR CALLBACK MainDlgProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam );
VOID OnInitDialog( HWND hDlg );
VOID OnTimer( HWND hDlg );
VOID OnOpenSoundFile( HWND hDlg );
HRESULT OnPlaySound( HWND hDlg );
VOID OnEffectChanged( HWND hDlg );
HRESULT ValidateWaveFile( HWND hDlg, TCHAR* strFileName );
HRESULT CreateAndFillBuffer( HWND hDlg, DWORD dwCreationFlags );
VOID SetBufferOptions( LONG lFrequency, LONG lPakn, LONG lVolume );
VOID EnablePlayUI( HWND hDlg, BOOL bEnable );
VOID LoadParameterUI ( HWND hDlg, DWORD dwFXType );
VOID ResetParameterUI ( HWND hDlg );
//-----------------------------------------------------------------------------
// Name: enum ESFXType
// Desc: each is a unique identifier mapped to a DirectSoundFX
//-----------------------------------------------------------------------------
enum ESFXType
{
eSFX_chorus = 0,
eSFX_compressor,
eSFX_distortion,
eSFX_echo,
eSFX_flanger,
eSFX_gargle,
eSFX_parameq,
eSFX_reverb,
// number of enumerated effects
eNUM_SFX
};
//-----------------------------------------------------------------------------
// Name: class CSoundFXManager
// Desc: Takes care of effects for one DirectSoundBuffer
//-----------------------------------------------------------------------------
class CSoundFXManager
{
public:
CSoundFXManager( );
~CSoundFXManager( );
public: // interface
HRESULT Initialize ( LPDIRECTSOUNDBUFFER lpDSB, BOOL bLoadDefaultParamValues );
HRESULT UnInitialize ( );
HRESULT SetFXEnable( DWORD esfxType );
HRESULT ActivateFX( );
HRESULT DisableAllFX( );
HRESULT LoadCurrentFXParameters( );
public: // members
LPDIRECTSOUNDFXCHORUS8 m_lpChorus;
LPDIRECTSOUNDFXCOMPRESSOR8 m_lpCompressor;
LPDIRECTSOUNDFXDISTORTION8 m_lpDistortion;
LPDIRECTSOUNDFXECHO8 m_lpEcho;
LPDIRECTSOUNDFXFLANGER8 m_lpFlanger;
LPDIRECTSOUNDFXGARGLE8 m_lpGargle;
LPDIRECTSOUNDFXPARAMEQ8 m_lpParamEq;
LPDIRECTSOUNDFXWAVESREVERB8 m_lpReverb;
DSFXChorus m_paramsChorus;
DSFXCompressor m_paramsCompressor;
DSFXDistortion m_paramsDistortion;
DSFXEcho m_paramsEcho;
DSFXFlanger m_paramsFlanger;
DSFXGargle m_paramsGargle;
DSFXParamEq m_paramsParamEq;
DSFXWavesReverb m_paramsReverb;
LPDIRECTSOUNDBUFFER8 m_lpDSB8;
protected:
DSEFFECTDESC m_rgFxDesc[eNUM_SFX];
const GUID * m_rgRefGuids[eNUM_SFX];
LPVOID * m_rgPtrs[eNUM_SFX];
BOOL m_rgLoaded[eNUM_SFX];
DWORD m_dwNumFX;
HRESULT EnableGenericFX( GUID guidSFXClass, REFGUID rguidInterface, LPVOID * ppObj );
HRESULT LoadDefaultParamValues( );
};
//-----------------------------------------------------------------------------
// defines and global variables
//-----------------------------------------------------------------------------
#define DEFAULT_SLIDER_MIN 1
#define DEFAULT_SLIDER_MAX 0x7FFFFF
#define DEFAULT_SLIDER_INC DEFAULT_SLIDER_MAX >> 11
CSoundManager * g_lpSoundManager = NULL;
CSound * g_lpSound = NULL;
CSoundFXManager * g_lpFXManager = NULL;
HINSTANCE g_hInst = NULL;
TCHAR g_tszFilename[MAX_PATH];
DWORD g_dwCurrentFXType = eSFX_chorus;
const TCHAR * g_tszFXNames[] = { "Chorus", "Compressor", "Distortion", "Echo",
"Flanger", "Gargle", "Param Eq", "Reverb" };
//-----------------------------------------------------------------------------
// Name: WinMain()
// Desc: Entry point for the application. Since we use a simple dialog for
// user interaction we don't need to pump messages.
//-----------------------------------------------------------------------------
INT APIENTRY WinMain( HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR pCmdLine, INT nCmdShow )
{
g_hInst = hInst;
CoInitialize( NULL );
// Init the common control dll
InitCommonControls();
// Display the main dialog box.
DialogBox( hInst, MAKEINTRESOURCE(IDD_MAIN), NULL, MainDlgProc );
CoUninitialize();
return TRUE;
}
//-----------------------------------------------------------------------------
// Name: MainDlgProc()
// Desc: Handles dialog messages
//-----------------------------------------------------------------------------
INT_PTR CALLBACK MainDlgProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
HRESULT hr;
switch( msg )
{
case WM_COMMAND:
switch( LOWORD(wParam) )
{
case IDOK:
case IDCANCEL:
EndDialog( hDlg, IDOK );
break;
case IDC_BUTTON_OPEN:
OnOpenSoundFile( hDlg );
break;
case IDC_BUTTON_PLAY:
if( FAILED( hr = OnPlaySound( hDlg ) ) )
{
DXTRACE_ERR( TEXT("OnPlaySound"), hr );
MessageBox( hDlg, "Error playing DirectSound buffer."
"Sample will now exit.", "DirectSound Sample",
MB_OK | MB_ICONERROR );
EndDialog( hDlg, IDABORT );
}
break;
case IDC_BUTTON_STOP:
if( g_lpSound )
{
g_lpSound->Stop();
g_lpSound->Reset();
}
g_lpFXManager->DisableAllFX( );
EnablePlayUI( hDlg, TRUE );
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("Sound stopped.") );
break;
case IDC_RADIO_TRIANGLE:
case IDC_RADIO_SQUARE:
case IDC_RADIO_SINE:
case IDC_RADIO_NEG_180:
case IDC_RADIO_NEG_90:
case IDC_RADIO_ZERO:
case IDC_RADIO_90:
case IDC_RADIO_180:
OnEffectChanged( hDlg );
break;
default:
if( LOWORD( wParam ) >= IDC_RADIO_CHORUS &&
LOWORD( wParam ) <= IDC_RADIO_REVERB )
{
g_dwCurrentFXType = LOWORD( wParam ) - IDC_RADIO_CHORUS;
LoadParameterUI( hDlg, g_dwCurrentFXType );
}
else
return FALSE; // Didn't handle message
}
break;
case WM_TIMER:
OnTimer( hDlg );
break;
case WM_INITDIALOG:
OnInitDialog( hDlg );
break;
case WM_NOTIFY:
{
//LPNMHDR pnmh = ( LPNMHDR ) lParam;
//if( pnmh->code >= IDC_SLIDER1 && pnmh->code <= IDC_SLIDER6 )
//{
OnEffectChanged( hDlg );
//}
break;
}
case WM_DESTROY:
// Cleanup everything
KillTimer( hDlg, 1 );
SAFE_DELETE( g_lpFXManager );
SAFE_DELETE( g_lpSound );
SAFE_DELETE( g_lpSoundManager );
break;
default:
return FALSE; // Didn't handle message
}
return TRUE; // Handled message
}
//-----------------------------------------------------------------------------
// Name: OnInitDialog()
// Desc: Initializes the dialogs (sets up UI controls, etc.)
//-----------------------------------------------------------------------------
VOID OnInitDialog( HWND hDlg )
{
HRESULT hr;
// Load the icon - will be set during WM_INITDIALOG
HICON hIcon = LoadIcon( g_hInst, MAKEINTRESOURCE( IDI_ICON ) );
PostMessage( hDlg, WM_SETICON, ICON_BIG, ( LPARAM ) hIcon );
PostMessage( hDlg, WM_SETICON, ICON_SMALL, ( LPARAM ) hIcon );
// Create a static IDirectSound in the CSound class.
// Set coop level to DSSCL_PRIORITY, and set primary buffer
// format to stereo, 22kHz and 16-bit output.
g_lpSoundManager = new CSoundManager();
g_lpFXManager = new CSoundFXManager();
if( FAILED( hr = g_lpSoundManager->Initialize( hDlg, DSSCL_PRIORITY, 2, 22050, 16 ) ) )
{
DXTRACE_ERR( TEXT("Initialize"), hr );
MessageBox( hDlg, "Error initializing DirectSound. Sample will now exit.",
"DirectSound Sample", MB_OK | MB_ICONERROR );
EndDialog( hDlg, IDABORT );
return;
}
// Create a timer, so we can check for when the soundbuffer is stopped
SetTimer( hDlg, 0, 250, NULL );
// Load default wave file
TCHAR strFile[MAX_PATH];
GetWindowsDirectory( strFile, MAX_PATH );
lstrcat( strFile, "\\media\\ding.wav" );
if( FAILED( hr = ValidateWaveFile( hDlg, strFile ) ) )
{
// Set the UI controls
SetDlgItemText( hDlg, IDC_TEXT_FILENAME, TEXT("") );
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("No file loaded.") );
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_PLAY ), FALSE );
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_STOP ), FALSE );
return;
}
if( SUCCEEDED( hr = g_lpSoundManager->Create( &g_lpSound, g_tszFilename,
DSBCAPS_CTRLFX, GUID_NULL ) ) )
{
g_lpFXManager->Initialize( g_lpSound->GetBuffer( 0 ), TRUE );
// un-attach the sound buffer
g_lpFXManager->UnInitialize( );
SAFE_DELETE( g_lpSound );
}
// set UI defaults
CheckDlgButton( hDlg, IDC_CHECK_LOOP, BST_CHECKED );
CheckRadioButton( hDlg, IDC_RADIO_CHORUS, IDC_RADIO_REVERB, IDC_RADIO_CHORUS );
LoadParameterUI( hDlg, g_dwCurrentFXType );
EnablePlayUI( hDlg, TRUE );
}
//-----------------------------------------------------------------------------
// Name: OnPlaySound()
// Desc: User hit the "Play" button
//-----------------------------------------------------------------------------
HRESULT OnPlaySound( HWND hDlg )
{
HRESULT hr;
DWORD dwCreationFlags;
DWORD dwLooped;
DWORD i;
LPDIRECTSOUNDBUFFER pDSB = NULL;
LPDIRECTSOUNDBUFFER8 pDSB8 = NULL;
BOOL bLooped = ( IsDlgButtonChecked( hDlg, IDC_CHECK_LOOP ) == BST_CHECKED );
// We would only use CTRLFX control on dsound buffer
dwCreationFlags = DSBCAPS_CTRLFX;
// Free any previous sound and FXs
g_lpFXManager->DisableAllFX( );
SAFE_DELETE( g_lpSound );
// Since the user can change the focus before the sound is played,
// we need to create the sound buffer every time the play button is pressed
// Load the wave file into a DirectSound buffer
if( FAILED( hr = g_lpSoundManager->Create( &g_lpSound, g_tszFilename,
dwCreationFlags, GUID_NULL ) ) )
{
// Not a critical failure, so just update the status
DXTRACE_ERR_NOMSGBOX( TEXT("Create"), hr );
if( hr == DSERR_BUFFERTOOSMALL )
{
// DSERR_BUFFERTOOSMALL will be returned if the buffer is
// less than DSBSIZE_FX_MIN (150ms) and the buffer is created
// with DSBCAPS_CTRLFX.
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("Wave file is too short (less than 150ms) for effect processing.") );
}
else
{
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("Could not create sound buffer.") );
}
return S_FALSE;
}
g_lpFXManager->Initialize( g_lpSound->GetBuffer( 0 ), FALSE );
for( i = IDC_CHECK_CHORUS; i <= IDC_CHECK_REVERB; i++ )
{
if( IsDlgButtonChecked( hDlg, i ) == BST_CHECKED )
g_lpFXManager->SetFXEnable( i - IDC_CHECK_CHORUS );
}
if( FAILED( hr = g_lpFXManager->ActivateFX( ) ) )
goto LFail;
if( FAILED( hr = g_lpFXManager->LoadCurrentFXParameters( ) ) )
goto LFail;
// Call SetCurrentPosition() to pre-roll any effects parameter changes
// that occurred since the last call to an API that does pre-rolling
// such as Stop(),Play(),Unlock(),or SetCurrentPosition().
g_lpSound->Reset();
// Play the sound
dwLooped = bLooped ? DSBPLAY_LOOPING : 0L;
if( FAILED( hr = g_lpSound->Play( 0, dwLooped ) ) )
return DXTRACE_ERR( TEXT("Play"), hr );
// Update the UI controls to show the sound as playing
EnablePlayUI( hDlg, FALSE );
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("Sound playing.") );
return S_OK;
LFail:
// Update the UI controls to show the sound effects could not be loaded
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("Effects creation failed. Some effect may not support 8-bit wave files.") );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: OnOpenSoundFile()
// Desc: Called when the user requests to open a sound file
//-----------------------------------------------------------------------------
VOID OnOpenSoundFile( HWND hDlg )
{
static TCHAR strFileName[MAX_PATH] = TEXT("");
static TCHAR strPath[MAX_PATH] = TEXT("");
// Setup the OPENFILENAME structure
OPENFILENAME ofn = { sizeof(OPENFILENAME), hDlg, NULL,
TEXT("Wave Files\0*.wav\0All Files\0*.*\0\0"), NULL,
0, 1, strFileName, MAX_PATH, NULL, 0, strPath,
TEXT("Open Sound File"),
OFN_FILEMUSTEXIST|OFN_HIDEREADONLY, 0, 0,
TEXT(".wav"), 0, NULL, NULL };
// Get the default media path (something like C:\WINDOWS\MEDIA)
if( '\0' == strPath[0] )
{
GetWindowsDirectory( strPath, MAX_PATH );
if( strcmp( &strPath[strlen(strPath)], TEXT("\\") ) )
strcat( strPath, TEXT("\\") );
strcat( strPath, TEXT("MEDIA") );
}
// Update the UI controls to show the sound as loading a file
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_PLAY ), FALSE );
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_STOP ), FALSE );
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("Loading file...") );
// Stop playing the current sound and disable the effects
g_lpFXManager->DisableAllFX( );
// Display the OpenFileName dialog. Then, try to load the specified file
if( TRUE != GetOpenFileName( &ofn ) )
{
// Set the UI controls
SetDlgItemText( hDlg, IDC_TEXT_FILENAME, TEXT("") );
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("No file loaded.") );
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_PLAY ), FALSE );
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_STOP ), FALSE );
return;
}
SetDlgItemText( hDlg, IDC_TEXT_FILENAME, TEXT("") );
// Make sure wave file is a valid wav file
if( FAILED( ValidateWaveFile( hDlg, strFileName ) ) )
{
// Set the UI controls
SetDlgItemText( hDlg, IDC_TEXT_FILENAME, TEXT("") );
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_PLAY ), FALSE );
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_STOP ), FALSE );
return;
}
EnablePlayUI( hDlg, TRUE );
// Remember the path for next time
strcpy( strPath, strFileName );
char* strLastSlash = strrchr( strPath, '\\' );
strLastSlash[0] = '\0';
}
//-----------------------------------------------------------------------------
// Name: OnTimer()
// Desc: When we think the sound is playing this periodically checks to see if
// the sound has stopped. If it has then updates the dialog.
//-----------------------------------------------------------------------------
VOID OnTimer( HWND hDlg )
{
if( IsWindowEnabled( GetDlgItem( hDlg, IDC_BUTTON_STOP ) ) )
{
// We think the sound is playing, so see if it has stopped yet.
if( g_lpSound && !g_lpSound->IsSoundPlaying() )
{
// Update the UI controls to show the sound as stopped
EnablePlayUI( hDlg, TRUE );
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("Sound stopped.") );
}
}
}
//-----------------------------------------------------------------------------
// Name: EnablePlayUI()
// Desc: Enables or disables the Play UI controls
//-----------------------------------------------------------------------------
VOID EnablePlayUI( HWND hDlg, BOOL bEnable )
{
if( bEnable )
{
EnableWindow( GetDlgItem( hDlg, IDC_CHECK_LOOP ), TRUE );
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_PLAY ), TRUE );
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_STOP ), FALSE );
SetFocus( GetDlgItem( hDlg, IDC_BUTTON_PLAY ) );
}
else
{
EnableWindow( GetDlgItem( hDlg, IDC_CHECK_LOOP ), FALSE );
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_PLAY ), FALSE );
EnableWindow( GetDlgItem( hDlg, IDC_BUTTON_STOP ), TRUE );
SetFocus( GetDlgItem( hDlg, IDC_BUTTON_STOP ) );
}
for( DWORD i = IDC_CHECK_CHORUS; i <= IDC_CHECK_REVERB; i++ )
EnableWindow( GetDlgItem( hDlg, i ), bEnable );
}
//-----------------------------------------------------------------------------
// Name: ResetParameterUI( )
// Desc: Blanks the paramter UI
//-----------------------------------------------------------------------------
VOID ResetParameterUI( HWND hwndDlg )
{
HWND hwndItem;
DWORD i;
for ( i = IDC_PARAM_NAME1; i <= IDC_PARAM_MAX6; i++ )
{
hwndItem = GetDlgItem( hwndDlg, i );
SendMessage( hwndItem, WM_SETTEXT, 0, ( LPARAM ) TEXT( "- - -" ) );
EnableWindow( hwndItem, FALSE );
}
for ( i = IDC_SLIDER1; i <= IDC_SLIDER6; i += 5 )
{
PostMessage( GetDlgItem( hwndDlg, i ), TBM_SETRANGEMIN, FALSE, DEFAULT_SLIDER_MIN );
PostMessage( GetDlgItem( hwndDlg, i ), TBM_SETRANGEMAX, FALSE, DEFAULT_SLIDER_MAX );
PostMessage( GetDlgItem( hwndDlg, i ), TBM_SETLINESIZE, FALSE, DEFAULT_SLIDER_INC );
PostMessage( GetDlgItem( hwndDlg, i ), TBM_SETPOS, TRUE, 0 );
}
EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO_TRIANGLE ), FALSE );
EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO_SQUARE ), FALSE );
EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO_SINE ), FALSE );
EnableWindow( GetDlgItem( hwndDlg, IDC_FRAME_WAVEFORM ), FALSE );
EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO_NEG_180 ), FALSE );
EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO_NEG_90 ), FALSE );
EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO_ZERO ), FALSE );
EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO_90 ), FALSE );
EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO_180 ), FALSE );
EnableWindow( GetDlgItem( hwndDlg, IDC_FRAME_PHASE ), FALSE );
}
//-----------------------------------------------------------------------------
// Name: EnableSingleParameter
// Desc:
//-----------------------------------------------------------------------------
VOID EnableSingleParameter( HWND hwndDlg, DWORD resID )
{
for ( DWORD i = resID; i < resID + 5; i++ )
EnableWindow( GetDlgItem( hwndDlg, i ), TRUE );
}
//-----------------------------------------------------------------------------
// Name: PosSlider
// Desc:
//-----------------------------------------------------------------------------
VOID PosSlider( HWND hwndDlg, DWORD dwSlider, FLOAT val, FLOAT min, FLOAT max,
FLOAT fSliderInc )
{
HWND hwndSlider = GetDlgItem( hwndDlg, dwSlider );
LONG lSliderInc = (LONG) ( (fSliderInc / (max - min)) * DEFAULT_SLIDER_MAX );
PostMessage( hwndSlider, TBM_SETLINESIZE, FALSE, lSliderInc );
FLOAT res = ( val - min ) / ( max - min );
if( res < 0.0f )
res = 0.0f;
else if( res > 1.0f )
res = 1.0f;
LONG pos = (LONG) ( res * DEFAULT_SLIDER_MAX );
PostMessage( hwndSlider, TBM_SETPOS, TRUE, pos );
}
//-----------------------------------------------------------------------------
// Name: LoadSingleParameter
// Desc:
//-----------------------------------------------------------------------------
VOID LoadSingleParameter( HWND hwndDlg, DWORD id, const TCHAR * tszName, FLOAT val,
FLOAT min, FLOAT max, FLOAT fSliderInc = 0.1f,
DWORD dwPrecision = 1 )
{
TCHAR tszstr[MAX_PATH];
// wet dry mix
EnableSingleParameter( hwndDlg, id );
SendMessage( GetDlgItem( hwndDlg, id ), WM_SETTEXT, 0, ( LPARAM ) tszName );
switch( dwPrecision )
{
case 0:
sprintf( tszstr, "%.0f", val );
SendMessage( GetDlgItem( hwndDlg, id + 1 ), WM_SETTEXT, 0, ( LPARAM ) tszstr );
sprintf( tszstr, "%.0f", min );
SendMessage( GetDlgItem( hwndDlg, id + 3 ), WM_SETTEXT, 0, ( LPARAM ) tszstr );
sprintf( tszstr, "%.0f", max );
SendMessage( GetDlgItem( hwndDlg, id + 4 ), WM_SETTEXT, 0, ( LPARAM ) tszstr );
break;
case 1:
sprintf( tszstr, "%.1f", val );
SendMessage( GetDlgItem( hwndDlg, id + 1 ), WM_SETTEXT, 0, ( LPARAM ) tszstr );
sprintf( tszstr, "%.1f", min );
SendMessage( GetDlgItem( hwndDlg, id + 3 ), WM_SETTEXT, 0, ( LPARAM ) tszstr );
sprintf( tszstr, "%.1f", max );
SendMessage( GetDlgItem( hwndDlg, id + 4 ), WM_SETTEXT, 0, ( LPARAM ) tszstr );
break;
default:
case 2:
sprintf( tszstr, "%.2f", val );
SendMessage( GetDlgItem( hwndDlg, id + 1 ), WM_SETTEXT, 0, ( LPARAM ) tszstr );
sprintf( tszstr, "%.2f", min );
SendMessage( GetDlgItem( hwndDlg, id + 3 ), WM_SETTEXT, 0, ( LPARAM ) tszstr );
sprintf( tszstr, "%.2f", max );
SendMessage( GetDlgItem( hwndDlg, id + 4 ), WM_SETTEXT, 0, ( LPARAM ) tszstr );
break;
}
PosSlider( hwndDlg, id + 2, val, min, max, fSliderInc );
}
//-----------------------------------------------------------------------------
// Name: SaveSingleParameter
// Desc:
//-----------------------------------------------------------------------------
VOID SaveSingleParameter( HWND hwndDlg, DWORD id, FLOAT * val, FLOAT min, FLOAT max, DWORD dwPrecision = 1 )
{
TCHAR tszstr[MAX_PATH];
DWORD pos = ( DWORD ) SendMessage( GetDlgItem( hwndDlg, id + 2), TBM_GETPOS, 0, 0 );
FLOAT percent = ( FLOAT ) ( pos - DEFAULT_SLIDER_MIN ) / ( FLOAT ) ( DEFAULT_SLIDER_MAX - DEFAULT_SLIDER_MIN );
*val = percent * ( max - min ) + min;
switch( dwPrecision )
{
case 0:
sprintf( tszstr, "%.0f", *val );
break;
case 1:
sprintf( tszstr, "%.1f", *val );
break;
case 2:
default:
sprintf( tszstr, "%.2f", *val );
break;
}
SendMessage( GetDlgItem( hwndDlg, id + 1 ), WM_SETTEXT, 0, ( LPARAM ) tszstr );
}
//-----------------------------------------------------------------------------
// Name: LoadWaveformRadio
// Desc:
//-----------------------------------------------------------------------------
VOID LoadWaveformRadio( HWND hwndDlg, LONG waveform, LONG triangle, LONG square, LONG sine )
{
if( waveform == triangle )
CheckRadioButton( hwndDlg, IDC_RADIO_TRIANGLE, IDC_RADIO_SINE, IDC_RADIO_TRIANGLE );
else if( waveform == square )
CheckRadioButton( hwndDlg, IDC_RADIO_TRIANGLE, IDC_RADIO_SINE, IDC_RADIO_SQUARE );
else if( waveform == sine )
CheckRadioButton( hwndDlg, IDC_RADIO_TRIANGLE, IDC_RADIO_SINE, IDC_RADIO_SINE );
if( triangle >= 0 )
EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO_TRIANGLE ), TRUE );
if( square >= 0 )
EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO_SQUARE ), TRUE );
if( sine >= 0 )
EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO_SINE ), TRUE );
EnableWindow( GetDlgItem( hwndDlg, IDC_FRAME_WAVEFORM ), ( triangle + square + sine != -3 ) );
}
//-----------------------------------------------------------------------------
// Name: LoadPhaseRadio
// Desc:
//-----------------------------------------------------------------------------
VOID LoadPhaseRadio( HWND hwndDlg, LONG phase, LONG neg180, LONG neg90, LONG zero, LONG pos90, LONG pos180 )
{
for( int i = IDC_RADIO_NEG_180; i <= IDC_RADIO_180; i++ )
EnableWindow( GetDlgItem( hwndDlg, i ), TRUE );
EnableWindow( GetDlgItem( hwndDlg, IDC_FRAME_PHASE), TRUE );
if( phase == neg180 )
CheckRadioButton( hwndDlg, IDC_RADIO_NEG_180, IDC_RADIO_90, IDC_RADIO_NEG_180 );
else if( phase == neg90 )
CheckRadioButton( hwndDlg, IDC_RADIO_NEG_180, IDC_RADIO_90, IDC_RADIO_NEG_90 );
else if( phase == zero )
CheckRadioButton( hwndDlg, IDC_RADIO_NEG_180, IDC_RADIO_90, IDC_RADIO_ZERO );
else if( phase == pos90 )
CheckRadioButton( hwndDlg, IDC_RADIO_NEG_180, IDC_RADIO_90, IDC_RADIO_90 );
else if( phase == pos180 )
CheckRadioButton( hwndDlg, IDC_RADIO_NEG_180, IDC_RADIO_90, IDC_RADIO_180 );
}
//-----------------------------------------------------------------------------
// Name: LoadParameterUI( )
// Desc: loads the paramter ui for particular effect
//-----------------------------------------------------------------------------
VOID LoadParameterUI( HWND hwndDlg, DWORD dwFXType )
{
TCHAR tszstr[MAX_PATH];
// reset the parameter ui
ResetParameterUI( hwndDlg );
sprintf( tszstr, "Parameters for [ %s ]", g_tszFXNames[dwFXType] );
SetDlgItemText( hwndDlg, IDC_FRAME, tszstr );
switch( dwFXType)
{
case eSFX_chorus:
{
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME1, TEXT( "Wet/Dry Mix (%)" ), g_lpFXManager->m_paramsChorus.fWetDryMix, DSFXCHORUS_WETDRYMIX_MIN, DSFXCHORUS_WETDRYMIX_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME2, TEXT( "Depth (%)" ), g_lpFXManager->m_paramsChorus.fDepth, DSFXCHORUS_DEPTH_MIN, DSFXCHORUS_DEPTH_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME3, TEXT( "Feedback (%)" ), g_lpFXManager->m_paramsChorus.fFeedback, DSFXCHORUS_FEEDBACK_MIN, DSFXCHORUS_FEEDBACK_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME4, TEXT( "Frequency (Hz)" ), g_lpFXManager->m_paramsChorus.fFrequency, DSFXCHORUS_FREQUENCY_MIN, DSFXCHORUS_FREQUENCY_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME5, TEXT( "Delay (ms)" ), g_lpFXManager->m_paramsChorus.fDelay, DSFXCHORUS_DELAY_MIN, DSFXCHORUS_DELAY_MAX );
LoadWaveformRadio( hwndDlg, g_lpFXManager->m_paramsChorus.lWaveform, DSFXCHORUS_WAVE_TRIANGLE, -1, DSFXCHORUS_WAVE_SIN );
LoadPhaseRadio( hwndDlg, g_lpFXManager->m_paramsChorus.lPhase, DSFXCHORUS_PHASE_NEG_180, DSFXCHORUS_PHASE_NEG_90, DSFXCHORUS_PHASE_ZERO, DSFXCHORUS_PHASE_90, DSFXCHORUS_PHASE_180 );
break;
}
case eSFX_compressor:
{
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME1, TEXT( "Gain (dB)" ), g_lpFXManager->m_paramsCompressor.fGain, DSFXCOMPRESSOR_GAIN_MIN, DSFXCOMPRESSOR_GAIN_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME2, TEXT( "Attack (ms)" ), g_lpFXManager->m_paramsCompressor.fAttack, DSFXCOMPRESSOR_ATTACK_MIN, DSFXCOMPRESSOR_ATTACK_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME3, TEXT( "Release (ms)" ), g_lpFXManager->m_paramsCompressor.fRelease, DSFXCOMPRESSOR_RELEASE_MIN, DSFXCOMPRESSOR_RELEASE_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME4, TEXT( "Threshold (dB)" ), g_lpFXManager->m_paramsCompressor.fThreshold, DSFXCOMPRESSOR_THRESHOLD_MIN, DSFXCOMPRESSOR_THRESHOLD_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME5, TEXT( "Ratio (x:1)" ), g_lpFXManager->m_paramsCompressor.fRatio, DSFXCOMPRESSOR_RATIO_MIN, DSFXCOMPRESSOR_RATIO_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME6, TEXT( "Predelay (ms)" ), g_lpFXManager->m_paramsCompressor.fPredelay, DSFXCOMPRESSOR_PREDELAY_MIN, DSFXCOMPRESSOR_PREDELAY_MAX, 0.05f, 2 );
break;
}
case eSFX_distortion:
{
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME1, TEXT( "Gain (dB)" ), g_lpFXManager->m_paramsDistortion.fGain, DSFXDISTORTION_GAIN_MIN, DSFXDISTORTION_GAIN_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME2, TEXT( "Edge (%)" ), g_lpFXManager->m_paramsDistortion.fEdge, DSFXDISTORTION_EDGE_MIN, DSFXDISTORTION_EDGE_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME3, TEXT( "PostEQ Center Freq (Hz)" ), g_lpFXManager->m_paramsDistortion.fPostEQCenterFrequency, DSFXDISTORTION_POSTEQCENTERFREQUENCY_MIN, DSFXDISTORTION_POSTEQCENTERFREQUENCY_MAX, 1.0f, 0 );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME4, TEXT( "PostEQ Bandwidth (Hz)" ), g_lpFXManager->m_paramsDistortion.fPostEQBandwidth, DSFXDISTORTION_POSTEQBANDWIDTH_MIN, DSFXDISTORTION_POSTEQBANDWIDTH_MAX, 1.0f, 0 );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME5, TEXT( "PreLowpass Cutoff (Hz)" ), g_lpFXManager->m_paramsDistortion.fPreLowpassCutoff, DSFXDISTORTION_PRELOWPASSCUTOFF_MIN, DSFXDISTORTION_PRELOWPASSCUTOFF_MAX, 1.0f, 0 );
break;
}
case eSFX_echo:
{
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME1, TEXT( "Wet/Dry Mix (%)" ), g_lpFXManager->m_paramsEcho.fWetDryMix, DSFXECHO_WETDRYMIX_MIN, DSFXECHO_WETDRYMIX_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME2, TEXT( "Feedback (%)" ), g_lpFXManager->m_paramsEcho.fFeedback, DSFXECHO_FEEDBACK_MIN, DSFXECHO_FEEDBACK_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME3, TEXT( "Left Delay (ms)" ), g_lpFXManager->m_paramsEcho.fLeftDelay, DSFXECHO_LEFTDELAY_MIN, DSFXECHO_LEFTDELAY_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME4, TEXT( "Right Delay (ms)" ), g_lpFXManager->m_paramsEcho.fRightDelay, DSFXECHO_RIGHTDELAY_MIN, DSFXECHO_RIGHTDELAY_MAX );
break;
}
case eSFX_flanger:
{
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME1, TEXT( "Wet/Dry Mix (%)" ), g_lpFXManager->m_paramsFlanger.fWetDryMix, DSFXFLANGER_WETDRYMIX_MIN, DSFXFLANGER_WETDRYMIX_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME2, TEXT( "Depth (%)" ), g_lpFXManager->m_paramsFlanger.fDepth, DSFXFLANGER_DEPTH_MIN, DSFXFLANGER_DEPTH_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME3, TEXT( "Feedback (%)" ), g_lpFXManager->m_paramsFlanger.fFeedback, DSFXFLANGER_FEEDBACK_MIN, DSFXFLANGER_FEEDBACK_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME4, TEXT( "Frequency (Hz)" ), g_lpFXManager->m_paramsFlanger.fFrequency, DSFXFLANGER_FREQUENCY_MIN, DSFXFLANGER_FREQUENCY_MAX, 0.01f, 2 );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME5, TEXT( "Delay (ms)" ), g_lpFXManager->m_paramsFlanger.fDelay, DSFXFLANGER_DELAY_MIN, DSFXFLANGER_DELAY_MAX, 0.01f, 2 );
LoadWaveformRadio( hwndDlg, g_lpFXManager->m_paramsFlanger.lWaveform, DSFXFLANGER_WAVE_TRIANGLE, -1, DSFXFLANGER_WAVE_SIN );
LoadPhaseRadio( hwndDlg, g_lpFXManager->m_paramsFlanger.lPhase, DSFXFLANGER_PHASE_NEG_180, DSFXFLANGER_PHASE_NEG_90, DSFXFLANGER_PHASE_ZERO, DSFXFLANGER_PHASE_90, DSFXFLANGER_PHASE_180 );
break;
}
case eSFX_gargle:
{
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME1, TEXT( "Rate (Hz)" ), ( FLOAT ) g_lpFXManager->m_paramsGargle.dwRateHz, ( FLOAT ) DSFXGARGLE_RATEHZ_MIN, ( FLOAT ) DSFXGARGLE_RATEHZ_MAX );
LoadWaveformRadio( hwndDlg, g_lpFXManager->m_paramsGargle.dwWaveShape, DSFXGARGLE_WAVE_TRIANGLE, DSFXGARGLE_WAVE_SQUARE, -1 );
break;
}
case eSFX_parameq:
{
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME1, TEXT( "Center Freq (Hz)" ), g_lpFXManager->m_paramsParamEq.fCenter, DSFXPARAMEQ_CENTER_MIN, DSFXPARAMEQ_CENTER_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME2, TEXT( "Bandwidth (Hz)" ), g_lpFXManager->m_paramsParamEq.fBandwidth, DSFXPARAMEQ_BANDWIDTH_MIN, DSFXPARAMEQ_BANDWIDTH_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME3, TEXT( "Gain (dB)" ), g_lpFXManager->m_paramsParamEq.fGain, DSFXPARAMEQ_GAIN_MIN, DSFXPARAMEQ_GAIN_MAX );
break;
}
case eSFX_reverb:
{
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME1, TEXT( "In Gain (dB)" ), g_lpFXManager->m_paramsReverb.fInGain, DSFX_WAVESREVERB_INGAIN_MIN, DSFX_WAVESREVERB_INGAIN_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME2, TEXT( "Reverb Mix (dB)" ), g_lpFXManager->m_paramsReverb.fReverbMix, DSFX_WAVESREVERB_REVERBMIX_MIN, DSFX_WAVESREVERB_REVERBMIX_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME3, TEXT( "Reverb Time (ms)" ), g_lpFXManager->m_paramsReverb.fReverbTime, DSFX_WAVESREVERB_REVERBTIME_MIN, DSFX_WAVESREVERB_REVERBTIME_MAX );
LoadSingleParameter( hwndDlg, IDC_PARAM_NAME4, TEXT( "HighFreq RT Ratio (x:1)" ), g_lpFXManager->m_paramsReverb.fHighFreqRTRatio, DSFX_WAVESREVERB_HIGHFREQRTRATIO_MIN, DSFX_WAVESREVERB_HIGHFREQRTRATIO_MAX, 0.01f, 2 );
break;
}
}
}
//-----------------------------------------------------------------------------
// Name: OnEffectChanged()
// Desc: Called when the UI prompted an effect change
//-----------------------------------------------------------------------------
VOID OnEffectChanged( HWND hwndDlg )
{
switch( g_dwCurrentFXType )
{
case eSFX_chorus:
{
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME1, &g_lpFXManager->m_paramsChorus.fWetDryMix, DSFXCHORUS_WETDRYMIX_MIN, DSFXCHORUS_WETDRYMIX_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME2, &g_lpFXManager->m_paramsChorus.fDepth, DSFXCHORUS_DEPTH_MIN, DSFXCHORUS_DEPTH_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME3, &g_lpFXManager->m_paramsChorus.fFeedback, DSFXCHORUS_FEEDBACK_MIN, DSFXCHORUS_FEEDBACK_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME4, &g_lpFXManager->m_paramsChorus.fFrequency, DSFXCHORUS_FREQUENCY_MIN, DSFXCHORUS_FREQUENCY_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME5, &g_lpFXManager->m_paramsChorus.fDelay, DSFXCHORUS_DELAY_MIN, DSFXCHORUS_DELAY_MAX );
if( IsDlgButtonChecked( hwndDlg, IDC_RADIO_TRIANGLE ) == BST_CHECKED )
g_lpFXManager->m_paramsChorus.lWaveform = DSFXCHORUS_WAVE_TRIANGLE;
else
g_lpFXManager->m_paramsChorus.lWaveform = DSFXCHORUS_WAVE_SIN;
if( IsDlgButtonChecked( hwndDlg, IDC_RADIO_NEG_180 ) == BST_CHECKED )
g_lpFXManager->m_paramsChorus.lPhase = DSFXCHORUS_PHASE_NEG_180;
else if( IsDlgButtonChecked( hwndDlg, IDC_RADIO_NEG_90 ) == BST_CHECKED )
g_lpFXManager->m_paramsChorus.lPhase = DSFXCHORUS_PHASE_NEG_90;
else if( IsDlgButtonChecked( hwndDlg, IDC_RADIO_ZERO ) == BST_CHECKED )
g_lpFXManager->m_paramsChorus.lPhase = DSFXCHORUS_PHASE_ZERO;
else if( IsDlgButtonChecked( hwndDlg, IDC_RADIO_90 ) == BST_CHECKED )
g_lpFXManager->m_paramsChorus.lPhase = DSFXCHORUS_PHASE_90;
else
g_lpFXManager->m_paramsChorus.lPhase = DSFXCHORUS_PHASE_180;
if( g_lpFXManager->m_lpChorus )
g_lpFXManager->m_lpChorus->SetAllParameters( &g_lpFXManager->m_paramsChorus );
break;
}
case eSFX_compressor:
{
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME1, &g_lpFXManager->m_paramsCompressor.fGain, DSFXCOMPRESSOR_GAIN_MIN, DSFXCOMPRESSOR_GAIN_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME2, &g_lpFXManager->m_paramsCompressor.fAttack, DSFXCOMPRESSOR_ATTACK_MIN, DSFXCOMPRESSOR_ATTACK_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME3, &g_lpFXManager->m_paramsCompressor.fRelease, DSFXCOMPRESSOR_RELEASE_MIN, DSFXCOMPRESSOR_RELEASE_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME4, &g_lpFXManager->m_paramsCompressor.fThreshold, DSFXCOMPRESSOR_THRESHOLD_MIN, DSFXCOMPRESSOR_THRESHOLD_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME5, &g_lpFXManager->m_paramsCompressor.fRatio, DSFXCOMPRESSOR_RATIO_MIN, DSFXCOMPRESSOR_RATIO_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME6, &g_lpFXManager->m_paramsCompressor.fPredelay, DSFXCOMPRESSOR_PREDELAY_MIN, DSFXCOMPRESSOR_PREDELAY_MAX, 2 );
if( g_lpFXManager->m_lpCompressor )
g_lpFXManager->m_lpCompressor->SetAllParameters( &g_lpFXManager->m_paramsCompressor );
break;
}
case eSFX_distortion:
{
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME1, &g_lpFXManager->m_paramsDistortion.fGain, DSFXDISTORTION_GAIN_MIN, DSFXDISTORTION_GAIN_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME2, &g_lpFXManager->m_paramsDistortion.fEdge, DSFXDISTORTION_EDGE_MIN, DSFXDISTORTION_EDGE_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME3, &g_lpFXManager->m_paramsDistortion.fPostEQCenterFrequency, DSFXDISTORTION_POSTEQCENTERFREQUENCY_MIN, DSFXDISTORTION_POSTEQCENTERFREQUENCY_MAX, 0 );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME4, &g_lpFXManager->m_paramsDistortion.fPostEQBandwidth, DSFXDISTORTION_POSTEQBANDWIDTH_MIN, DSFXDISTORTION_POSTEQBANDWIDTH_MAX, 0 );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME5, &g_lpFXManager->m_paramsDistortion.fPreLowpassCutoff, DSFXDISTORTION_PRELOWPASSCUTOFF_MIN, DSFXDISTORTION_PRELOWPASSCUTOFF_MAX, 0 );
if( g_lpFXManager->m_lpDistortion )
g_lpFXManager->m_lpDistortion->SetAllParameters( &g_lpFXManager->m_paramsDistortion );
break;
}
case eSFX_echo:
{
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME1, &g_lpFXManager->m_paramsEcho.fWetDryMix, DSFXECHO_WETDRYMIX_MIN, DSFXECHO_WETDRYMIX_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME2, &g_lpFXManager->m_paramsEcho.fFeedback, DSFXECHO_FEEDBACK_MIN, DSFXECHO_FEEDBACK_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME3, &g_lpFXManager->m_paramsEcho.fLeftDelay, DSFXECHO_LEFTDELAY_MIN, DSFXECHO_LEFTDELAY_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME4, &g_lpFXManager->m_paramsEcho.fRightDelay, DSFXECHO_RIGHTDELAY_MIN, DSFXECHO_RIGHTDELAY_MAX );
if( g_lpFXManager->m_lpEcho )
g_lpFXManager->m_lpEcho->SetAllParameters( &g_lpFXManager->m_paramsEcho );
break;
}
case eSFX_flanger:
{
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME1, &g_lpFXManager->m_paramsFlanger.fWetDryMix, DSFXFLANGER_WETDRYMIX_MIN, DSFXFLANGER_WETDRYMIX_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME2, &g_lpFXManager->m_paramsFlanger.fDepth, DSFXFLANGER_DEPTH_MIN, DSFXFLANGER_DEPTH_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME3, &g_lpFXManager->m_paramsFlanger.fFeedback, DSFXFLANGER_FEEDBACK_MIN, DSFXFLANGER_FEEDBACK_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME4, &g_lpFXManager->m_paramsFlanger.fFrequency, DSFXFLANGER_FREQUENCY_MIN, DSFXFLANGER_FREQUENCY_MAX, 2 );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME5, &g_lpFXManager->m_paramsFlanger.fDelay, DSFXFLANGER_DELAY_MIN, DSFXFLANGER_DELAY_MAX, 2 );
if( IsDlgButtonChecked( hwndDlg, IDC_RADIO_TRIANGLE ) == BST_CHECKED )
g_lpFXManager->m_paramsFlanger.lWaveform = DSFXFLANGER_WAVE_TRIANGLE;
else
g_lpFXManager->m_paramsFlanger.lWaveform = DSFXFLANGER_WAVE_SIN;
if( IsDlgButtonChecked( hwndDlg, IDC_RADIO_NEG_180 ) == BST_CHECKED )
g_lpFXManager->m_paramsFlanger.lPhase = DSFXFLANGER_PHASE_NEG_180;
else if( IsDlgButtonChecked( hwndDlg, IDC_RADIO_NEG_90 ) == BST_CHECKED )
g_lpFXManager->m_paramsFlanger.lPhase = DSFXFLANGER_PHASE_NEG_90;
else if( IsDlgButtonChecked( hwndDlg, IDC_RADIO_ZERO ) == BST_CHECKED )
g_lpFXManager->m_paramsFlanger.lPhase = DSFXFLANGER_PHASE_ZERO;
else if( IsDlgButtonChecked( hwndDlg, IDC_RADIO_90 ) == BST_CHECKED )
g_lpFXManager->m_paramsFlanger.lPhase = DSFXFLANGER_PHASE_90;
else
g_lpFXManager->m_paramsFlanger.lPhase = DSFXFLANGER_PHASE_180;
if( g_lpFXManager->m_lpFlanger )
g_lpFXManager->m_lpFlanger->SetAllParameters( &g_lpFXManager->m_paramsFlanger );
break;
}
case eSFX_gargle:
{
FLOAT fRateHz;
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME1, &fRateHz, DSFXGARGLE_RATEHZ_MIN, DSFXGARGLE_RATEHZ_MAX );
g_lpFXManager->m_paramsGargle.dwRateHz = (DWORD) fRateHz;
if( IsDlgButtonChecked( hwndDlg, IDC_RADIO_TRIANGLE ) == BST_CHECKED )
g_lpFXManager->m_paramsGargle.dwWaveShape = DSFXGARGLE_WAVE_TRIANGLE;
else
g_lpFXManager->m_paramsGargle.dwWaveShape = DSFXGARGLE_WAVE_SQUARE;
if( g_lpFXManager->m_lpGargle )
g_lpFXManager->m_lpGargle->SetAllParameters( &g_lpFXManager->m_paramsGargle );
break;
}
case eSFX_parameq:
{
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME1, &g_lpFXManager->m_paramsParamEq.fCenter, DSFXPARAMEQ_CENTER_MIN, DSFXPARAMEQ_CENTER_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME2, &g_lpFXManager->m_paramsParamEq.fBandwidth, DSFXPARAMEQ_BANDWIDTH_MIN, DSFXPARAMEQ_BANDWIDTH_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME3, &g_lpFXManager->m_paramsParamEq.fGain, DSFXPARAMEQ_GAIN_MIN, DSFXPARAMEQ_GAIN_MAX );
if( g_lpFXManager->m_lpParamEq )
g_lpFXManager->m_lpParamEq->SetAllParameters( &g_lpFXManager->m_paramsParamEq );
break;
}
case eSFX_reverb:
{
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME1, &g_lpFXManager->m_paramsReverb.fInGain, DSFX_WAVESREVERB_INGAIN_MIN, DSFX_WAVESREVERB_INGAIN_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME2, &g_lpFXManager->m_paramsReverb.fReverbMix, DSFX_WAVESREVERB_REVERBMIX_MIN, DSFX_WAVESREVERB_REVERBMIX_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME3, &g_lpFXManager->m_paramsReverb.fReverbTime, DSFX_WAVESREVERB_REVERBTIME_MIN, DSFX_WAVESREVERB_REVERBTIME_MAX );
SaveSingleParameter( hwndDlg, IDC_PARAM_NAME4, &g_lpFXManager->m_paramsReverb.fHighFreqRTRatio, DSFX_WAVESREVERB_HIGHFREQRTRATIO_MIN, DSFX_WAVESREVERB_HIGHFREQRTRATIO_MAX, 2 );
if( g_lpFXManager->m_lpReverb )
g_lpFXManager->m_lpReverb->SetAllParameters( &g_lpFXManager->m_paramsReverb );
break;
}
}
}
//-----------------------------------------------------------------------------
// Name: ValidateWaveFile()
// Desc: Open the wave file with the helper
// class CWaveFile to make sure it is valid
//-----------------------------------------------------------------------------
HRESULT ValidateWaveFile( HWND hDlg, TCHAR* strFileName )
{
HRESULT hr;
CWaveFile waveFile;
if( -1 == GetFileAttributes(strFileName) )
return E_FAIL;
// Load the wave file
if( FAILED( hr = waveFile.Open( strFileName, NULL, WAVEFILE_READ ) ) )
{
waveFile.Close();
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("Bad wave file.") );
return DXTRACE_ERR( TEXT("Open"), hr );
}
else // The load call succeeded
{
WAVEFORMATEX* pwfx = waveFile.GetFormat();
if( pwfx->wFormatTag != WAVE_FORMAT_PCM )
{
// Sound must be PCM when using DSBCAPS_CTRLFX
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("Wave file must be PCM for effects control.") );
SetDlgItemText( hDlg, IDC_TEXT_FILENAME, TEXT("") );
return E_FAIL;
}
// Update the UI controls to show the sound as the file is loaded
waveFile.Close();
//EnablePlayUI( hDlg, TRUE );
SetDlgItemText( hDlg, IDC_TEXT_FILENAME, strFileName );
SetDlgItemText( hDlg, IDC_TEXT_STATUS, TEXT("File loaded.") );
strcpy( g_tszFilename, strFileName );
// Get the samples per sec from the wave file
DWORD dwSamplesPerSec = waveFile.m_pwfx->nSamplesPerSec;
return S_OK;
}
}
//-----------------------------------------------------------------------------
// Name: CSoundFXManager( )
// Desc: constructor
//-----------------------------------------------------------------------------
CSoundFXManager::CSoundFXManager( )
{
m_lpChorus = NULL;
m_lpCompressor = NULL;
m_lpDistortion = NULL;
m_lpEcho = NULL;
m_lpFlanger = NULL;
m_lpGargle = NULL;
m_lpParamEq = NULL;
m_lpReverb = NULL;
ZeroMemory( &m_paramsChorus, sizeof( DSFXChorus ) );
ZeroMemory( &m_paramsCompressor, sizeof( DSFXCompressor ) );
ZeroMemory( &m_paramsDistortion, sizeof( DSFXDistortion ) );
ZeroMemory( &m_paramsFlanger, sizeof( DSFXFlanger ) );
ZeroMemory( &m_paramsEcho, sizeof( DSFXEcho ) );
ZeroMemory( &m_paramsGargle, sizeof( DSFXGargle ) );
ZeroMemory( &m_paramsParamEq, sizeof( DSFXParamEq ) );
ZeroMemory( &m_paramsReverb, sizeof( DSFXWavesReverb ) );
m_dwNumFX = 0;
ZeroMemory( m_rgFxDesc, sizeof( DSEFFECTDESC ) * eNUM_SFX );
ZeroMemory( m_rgRefGuids, sizeof( GUID * ) * eNUM_SFX );
ZeroMemory( m_rgPtrs, sizeof(LPVOID*) * eNUM_SFX );
ZeroMemory( m_rgLoaded, sizeof( BOOL ) * eNUM_SFX );
m_lpDSB8 = NULL;
}
//-----------------------------------------------------------------------------
// Name: ~CSoundFXManager( )
// Desc: destructor
//-----------------------------------------------------------------------------
CSoundFXManager::~CSoundFXManager( )
{
// free any effects
DisableAllFX( );
// release the DirectSoundBuffer
SAFE_RELEASE( m_lpDSB8 );
}
//-----------------------------------------------------------------------------
// Name: Initialize( )
// Desc: associates a DirectSoundBuffer with the manager, any effects
// enabled in the old DirectSoundBuffer will be disabled,
// and the effect objects released
//-----------------------------------------------------------------------------
HRESULT CSoundFXManager::Initialize( LPDIRECTSOUNDBUFFER lpDSB, BOOL bLoadDefaultParamValues )
{
HRESULT hr;
if( m_lpDSB8 )
{
// release the effect for the previously associated sound buffers
DisableAllFX( );
SAFE_RELEASE( m_lpDSB8 );
}
if( NULL == lpDSB )
return S_OK;
// get the interface
if( FAILED( hr = lpDSB->QueryInterface( IID_IDirectSoundBuffer8, (LPVOID*) &m_lpDSB8 ) ) )
return hr;
if( bLoadDefaultParamValues )
LoadDefaultParamValues( );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: UnInitialize( )
// Desc: the manager goes back to default state, the effects params, however
// will not be reset
//-----------------------------------------------------------------------------
HRESULT CSoundFXManager::UnInitialize( )
{
Initialize( NULL, FALSE );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: LoadDefaultParamValues( )
// Desc: loads the default param value for each effect
//-----------------------------------------------------------------------------
HRESULT CSoundFXManager::LoadDefaultParamValues( )
{
DWORD i;
if( NULL == m_lpDSB8 )
return E_FAIL;
for( i = eSFX_chorus; i < eNUM_SFX; i++ )
SetFXEnable( i );
ActivateFX( );
if( m_lpChorus )
m_lpChorus->GetAllParameters( &m_paramsChorus );
if( m_lpCompressor )
m_lpCompressor->GetAllParameters( &m_paramsCompressor );
if( m_lpDistortion )
m_lpDistortion->GetAllParameters( &m_paramsDistortion );
if( m_lpEcho )
m_lpEcho->GetAllParameters( &m_paramsEcho );
if( m_lpFlanger )
m_lpFlanger->GetAllParameters( &m_paramsFlanger );
if( m_lpGargle )
m_lpGargle->GetAllParameters( &m_paramsGargle );
if( m_lpParamEq )
m_lpParamEq->GetAllParameters( &m_paramsParamEq );
if( m_lpReverb )
m_lpReverb->GetAllParameters( &m_paramsReverb );
DisableAllFX( );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: LoadCurrentFXParameters
// Desc: loads the default param value for each effect
//-----------------------------------------------------------------------------
HRESULT CSoundFXManager::LoadCurrentFXParameters( )
{
if( m_lpChorus )
m_lpChorus->SetAllParameters( &m_paramsChorus );
if( m_lpCompressor )
m_lpCompressor->SetAllParameters( &m_paramsCompressor );
if( m_lpDistortion )
m_lpDistortion->SetAllParameters( &m_paramsDistortion );
if( m_lpEcho )
m_lpEcho->SetAllParameters( &m_paramsEcho );
if( m_lpFlanger )
m_lpFlanger->SetAllParameters( &m_paramsFlanger );
if( m_lpGargle )
m_lpGargle->SetAllParameters( &m_paramsGargle );
if( m_lpParamEq )
m_lpParamEq->SetAllParameters( &m_paramsParamEq );
if( m_lpReverb )
m_lpReverb->SetAllParameters( &m_paramsReverb );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: SetFXEnable( )
// Desc: enables a sound effect for the sound buffer associated with this
//-----------------------------------------------------------------------------
HRESULT CSoundFXManager::SetFXEnable( DWORD esfxType )
{
HRESULT hr;
if( esfxType >= eNUM_SFX )
return E_FAIL;
if( m_rgLoaded[esfxType] )
return S_FALSE;
else
m_rgLoaded[esfxType] = TRUE;
switch ( esfxType )
{
case eSFX_chorus:
hr = EnableGenericFX( GUID_DSFX_STANDARD_CHORUS, IID_IDirectSoundFXChorus8,
(LPVOID*) &m_lpChorus );
break;
case eSFX_compressor:
hr = EnableGenericFX( GUID_DSFX_STANDARD_COMPRESSOR, IID_IDirectSoundFXCompressor8,
(LPVOID*) &m_lpCompressor );
break;
case eSFX_distortion:
hr = EnableGenericFX( GUID_DSFX_STANDARD_DISTORTION, IID_IDirectSoundFXDistortion8,
(LPVOID*) &m_lpDistortion );
break;
case eSFX_echo:
hr = EnableGenericFX( GUID_DSFX_STANDARD_ECHO, IID_IDirectSoundFXEcho8,
(LPVOID*) &m_lpEcho );
break;
case eSFX_flanger:
hr = EnableGenericFX( GUID_DSFX_STANDARD_FLANGER, IID_IDirectSoundFXFlanger8,
(LPVOID*) &m_lpFlanger );
break;
case eSFX_gargle:
hr = EnableGenericFX( GUID_DSFX_STANDARD_GARGLE, IID_IDirectSoundFXGargle8,
(LPVOID*) &m_lpGargle );
break;
case eSFX_parameq:
hr = EnableGenericFX( GUID_DSFX_STANDARD_PARAMEQ, IID_IDirectSoundFXParamEq8,
(LPVOID*) &m_lpParamEq );
break;
case eSFX_reverb:
hr = EnableGenericFX( GUID_DSFX_WAVES_REVERB, IID_IDirectSoundFXWavesReverb8,
(LPVOID*) &m_lpReverb );
break;
default:
hr = E_FAIL;
break;
}
return hr;
}
//-----------------------------------------------------------------------------
// Name: DisableAllFX( )
// Desc: disables all effect in the DirectSoundBuffer, and releases all effect
// object.
//-----------------------------------------------------------------------------
HRESULT CSoundFXManager::DisableAllFX( )
{
// release all effect interfaces created with this manager so far
SAFE_RELEASE( m_lpChorus );
SAFE_RELEASE( m_lpCompressor );
SAFE_RELEASE( m_lpDistortion );
SAFE_RELEASE( m_lpEcho );
SAFE_RELEASE( m_lpFlanger );
SAFE_RELEASE( m_lpGargle );
SAFE_RELEASE( m_lpParamEq );
SAFE_RELEASE( m_lpReverb );
m_dwNumFX = 0;
ZeroMemory( m_rgFxDesc, sizeof( DSEFFECTDESC ) * eNUM_SFX );
ZeroMemory( m_rgRefGuids, sizeof( GUID * ) * eNUM_SFX );
ZeroMemory( m_rgPtrs, sizeof(LPVOID*) * eNUM_SFX );
ZeroMemory( m_rgLoaded, sizeof( BOOL ) * eNUM_SFX );
if( NULL == m_lpDSB8 )
return E_FAIL;
// Buffer must be stopped before calling SetFx
if( m_lpDSB8 )
m_lpDSB8->Stop();
// this removes all fx from the buffer
m_lpDSB8->SetFX( 0, NULL, NULL );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: ActivateFX( )
// Desc: activate the effects enabled from EnableFX( )
//-----------------------------------------------------------------------------
HRESULT CSoundFXManager::ActivateFX( )
{
DWORD dwResults[eNUM_SFX];
HRESULT hr;
DWORD i;
if( NULL == m_lpDSB8 )
return E_FAIL;
if( m_dwNumFX == 0 )
return S_FALSE;
if( FAILED( hr = m_lpDSB8->SetFX( m_dwNumFX, m_rgFxDesc, dwResults ) ) )
return hr;
// get reference to the effect object
for( i = 0; i < m_dwNumFX; i++ )
if( FAILED( hr = m_lpDSB8->GetObjectInPath( m_rgFxDesc[i].guidDSFXClass, 0, *m_rgRefGuids[i], m_rgPtrs[i] ) ) )
return DXTRACE_ERR( TEXT("GetObjectInPath"), hr );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: EnableGenericFX( )
// Desc: given information, tries to enabled an effect in a DirectSoundBuffer8,
// and tries obtain reference to effect interface
//-----------------------------------------------------------------------------
HRESULT CSoundFXManager::EnableGenericFX( GUID guidSFXClass, REFGUID rguidInterface, LPVOID * ppObj )
{
// if an effect already allocated
if( *ppObj )
return S_FALSE;
if( m_dwNumFX >= eNUM_SFX )
return E_FAIL;
// set the effect to be enabled
ZeroMemory( &m_rgFxDesc[m_dwNumFX], sizeof(DSEFFECTDESC) );
m_rgFxDesc[m_dwNumFX].dwSize = sizeof(DSEFFECTDESC);
m_rgFxDesc[m_dwNumFX].dwFlags = 0;
CopyMemory( &m_rgFxDesc[m_dwNumFX].guidDSFXClass, &guidSFXClass, sizeof(GUID) );
m_rgRefGuids[m_dwNumFX] = &rguidInterface;
m_rgPtrs[m_dwNumFX] = ppObj;
m_dwNumFX++;
return S_OK;
}
Reference in New Issue View Git Blame Copy Permalink