开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
Audio.cpp
资源名称：3dexplorerTest.rar　[点击查看]
上传用户：hkb425
上传日期：2007-06-16
资源大小：34191k
文件大小：16k
源码类别：

游戏引擎

开发平台：

Visual C++

Audio.cpp：源码内容
  1. // Audio.cpp: implementation of the CAudio class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "Audio.h"
  7. /////////////////////////////////////////////
  9. void CAudioSegment::Set3DPos(VERTEX *pos)
  10. {
  11. if(ds3DBuffer)
  12. {
  13.      ds3DBuffer->SetPosition(pos->xpos, pos->ypos, -pos->zpos, 
  14.                     DS3D_IMMEDIATE);
  15. }
  16. }
  18. //------------------------------------------------------------------//
  19. //- void CAudioSegment::Set3DDistances(float, float) -----------------------//
  20. //------------------------------------------------------------------//
  21. //- Sets the max, and minimum distance for a CAudioSegment to be heard.    -//
  22. //------------------------------------------------------------------//
  23. void CAudioSegment::Set3DDistances(float minDistance, float maxDistance)
  24. {
  25. if(ds3DBuffer)
  26. {
  27. ds3DBuffer->SetMinDistance(minDistance, DS3D_IMMEDIATE);
  28. ds3DBuffer->SetMaxDistance(maxDistance, DS3D_IMMEDIATE);
  29. }
  30. }
  32. //------------------------------------------------------------------//
  33. //- void CAudioSegment::Shutdown(void) -------------------------------------//
  34. //------------------------------------------------------------------//
  35. //- Shutdown the CAudioSegment, I originally had this in the destructor,   -//
  36. //- but it was acting screwy... so I now it has it's own function. -//
  37. //------------------------------------------------------------------//
  38. void CAudioSegment::Shutdown(void)
  39. {
  40. if(dmSegment!=NULL)
  41. {
  42. dmSegment->Release();
  43. dmSegment= NULL;
  44. }
  45. if(ds3DBuffer!=NULL)
  46. {
  47. ds3DBuffer->Release(); 
  48. ds3DBuffer= NULL;
  49. }
  50. if(vPosition!=NULL)
  51. {
  52. delete vPosition; 
  53. vPosition= NULL;
  54. }
  55. }
  56. /////////////////////////////////////////////////////////
  57. //////////////// class CAudio
  59. LPDIRECTMUSICLOADER8   CAudio::dmLoader=NULL; // the loader
  60. LPDIRECTMUSICPERFORMANCE8 CAudio::dmPerformance=NULL;             // the performance
  61. LPDIRECTMUSICAUDIOPATH    CAudio::dm3DAudioPath=NULL;             // the audiopath
  62.     //////////////////////////////////
  63. CAudioSegment  *CAudio::pSound=NULL;
  64. char           *CAudio::pSoundState=NULL;
  65. VERTEX          CAudio::vListenerPos=VERTEX(0,0,0);
  66. float           CAudio::froty=0;
  67. bool            CAudio::bEnable=true;
  68. bool            CAudio::bActive=true;
  69. int             CAudio::m_numUser=0;
  70. //////////////////////////////////////////////////////////////////////
  71. // Construction/Destruction
  72. //////////////////////////////////////////////////////////////////////
  73. CAudio::CAudio()
  74. {
  75. if(m_numUser==0)
  76. {
  77. if(!InitAudio())
  78. {
  79. bEnable=false;
  80. bActive=false;
  81. }
  82. }
  83. m_numUser++;
  84. }
  85. CAudio::~CAudio()
  86. {
  87. m_numUser--;
  88. if(m_numUser==0)
  89. {
  90.         ReleaseAudio();
  91. }
  93. }
  94. ////////////////////////////////////////////////////
  95. //------------------------------------------------------------------//
  96. //- bool CAudio::Init(void) ----------------------------------//
  97. //------------------------------------------------------------------//
  98. //- Initiates DirectAudio.  This function must be called by the    -//
  99. //- programmer, though the shutdown function is automatically    -//
  100. //- called by the destructor (as, not shutting down DAudio    -//
  101. //- correctly can have some bad consequences).    -//
  102. //------------------------------------------------------------------//
  103. bool CAudio::InitAudio()
  104. {
  105. HRESULT hr;
  106. WCHAR wcharStr[MAX_PATH];
  107. char pathStr[MAX_PATH];
  109. hr=CoInitialize(NULL);
  110. if(FAILED(hr))
  111. {
  112. // MessageBox(NULL, "Unable to CoInitialize", "ERROR", MB_OK);
  113. return false;
  114. }
  115. //Create the loader object, load it... and load it good.
  116. hr= CoCreateInstance(CLSID_DirectMusicLoader, NULL, CLSCTX_INPROC,
  117. IID_IDirectMusicLoader8, (void**)&dmLoader);
  118. if(FAILED(hr))
  119. {
  120. // MessageBox(NULL, "Unable to create main DirectAudio file loader", "ERROR", MB_OK);
  121. return false;
  122. }
  124. //Create the performance object for that.... performance stuff. 
  125. hr= CoCreateInstance(CLSID_DirectMusicPerformance, NULL, CLSCTX_INPROC,
  126.  IID_IDirectMusicPerformance8, (void**)&dmPerformance);
  127. if(FAILED(hr))
  128. {
  129. // MessageBox(NULL, "Unable to create main DirectAudio performance object", "ERROR", MB_OK);
  130.         ReleaseAudio();
  131. return false;
  132. }
  134. //Initialize the performance with the standard audio path information
  135. dmPerformance->InitAudio(NULL, NULL, NULL, DMUS_APATH_DYNAMIC_3D   , 64,
  136.  DMUS_AUDIOF_ALL, NULL);
  138.      //Create a simple 3D audiopath
  139.  hr= dmPerformance->CreateStandardAudioPath(DMUS_APATH_DYNAMIC_3D,
  140. 64, TRUE, &dm3DAudioPath);
  141.      if(FAILED(hr))
  142. {
  143. // MessageBox(NULL, "Unable to create the DirectAudio audio path", "ERROR", MB_OK);
  144.         ReleaseAudio();
  145. return false;
  146. }
  148. //Retrieve the current directory
  149. GetCurrentDirectory(MAX_PATH, pathStr);
  151. //Convert the file name to a unicode string... as thats what COM needs
  152. MultiByteToWideChar(CP_ACP, 0, pathStr, -1, wcharStr, MAX_PATH);
  154. //Set the search directory
  155. dmLoader->SetSearchDirectory(GUID_DirectMusicAllTypes, wcharStr, FALSE);
  157. ///////////////////
  158. ////////////////////////////////////
  159. pSound=new CAudioSegment[MAX_SOUND_NUM];
  160. pSoundState=new char [MAX_SOUND_NUM];
  162. for(unsigned int i=0;i<MAX_SOUND_NUM;i++)
  163. pSoundState[i]=SOUND_NULL;
  165. return true;
  166. }
  168. //------------------------------------------------------------------//
  169. //- bool CAudio::Create(CAudioSegment*, char*, bool) -----------------//
  170. //------------------------------------------------------------------//
  171. //- Use the audio manager to create an individual CAudioSegment effect from-//
  172. //- a file.    -//
  173. //------------------------------------------------------------------//
  174. bool CAudio::CreateSound(unsigned int NumOfSound, char* filename, bool is3DSound)
  175. {
  176.     if(!bEnable)return false;
  177. if(NumOfSound>(MAX_SOUND_NUM-1) || pSoundState[NumOfSound]!=SOUND_NULL)  return false ;
  179. HRESULT hr;
  180. WCHAR wcharStr[MAX_PATH];
  182. //Convert the file name to the string that DirectAudio needs
  183. MultiByteToWideChar(CP_ACP, 0, filename, -1, wcharStr, MAX_PATH);
  185. //Load the audio segment from a file
  186. hr= dmLoader->LoadObjectFromFile(CLSID_DirectMusicSegment,
  187.  IID_IDirectMusicSegment8,
  188.  wcharStr,
  189.  (void**)&pSound[NumOfSound].dmSegment);
  190. if(FAILED(hr))
  191. return false;
  192. //Do code specific for 3D CAudioSegments
  193. if(is3DSound)
  194. {
  195. //Get the 3D buffer, and audio path
  196. hr= dm3DAudioPath->GetObjectInPath(DMUS_PCHANNEL_ALL, DMUS_PATH_BUFFER, 0, 
  197.    GUID_NULL, 0, IID_IDirectSound3DBuffer,
  198.    (void**)&pSound[NumOfSound].ds3DBuffer);
  199. if(FAILED(hr))
  200. return false;
  201. //Get the 3D buffer paramters
  202. pSound[NumOfSound].vPosition = new VERTEX; 
  203. pSound[NumOfSound].vPosition->xpos=0;
  204. pSound[NumOfSound].vPosition->ypos=0;
  205. pSound[NumOfSound].vPosition->zpos=0;
  207. DS3DBUFFER dsBufferParams; 
  208. dsBufferParams.dwSize= sizeof(DS3DBUFFER);
  209. pSound[NumOfSound].ds3DBuffer->GetAllParameters(&dsBufferParams);
  210. //Set some new parameters
  211. dsBufferParams.dwMode= DS3DMODE_HEADRELATIVE;    // relative to the listener
  212.         dsBufferParams.flMinDistance=100;
  213. dsBufferParams.flMaxDistance=3000;
  214. pSound[NumOfSound].ds3DBuffer->SetAllParameters(&dsBufferParams, DS3D_IMMEDIATE);
  215. //Set the 3D CAudioSegment flag to true
  216. pSound[NumOfSound].is3DSound = true;
  218. pSoundState[NumOfSound]=SOUND_3D_IDLE;
  220. }
  221. else//Do code specific to non-3D CAudioSegments (background music)
  222. {
  223. //Set the 3D buffer to null since we don't need it
  224. pSound[NumOfSound].ds3DBuffer= NULL;
  225. //Set the 3D CAudioSegment flag to false, since we don't need it either
  226. pSound[NumOfSound].is3DSound= false;
  228. pSoundState[NumOfSound]=SOUND_2D_IDLE;
  229. }
  230.     
  231. ////////////////////////////
  233. return true;
  234. }
  236. //------------------------------------------------------------------//
  237. //- void CAudio::Play(CAudioSegment*, DWORD) -------------------------//
  238. //------------------------------------------------------------------//
  239. //- Play the CAudioSegment, and repeat it numRepeats amount of times.    -//
  240. //------------------------------------------------------------------//
  241. void CAudio::Play(unsigned int NumOfSound, DWORD numRepeats, bool bPrimary,bool bCheckOlyOne )
  242. {
  243. if(!bEnable || !bActive)return;
  244. if(NumOfSound>(MAX_SOUND_NUM-1) || pSoundState[NumOfSound]==SOUND_NULL) return  ;
  245.     if(bCheckOlyOne && CheckSoundPlaying(NumOfSound))return;
  247. //Set the number of repeats that we want for the specific CAudioSegment
  248. pSound[NumOfSound].dmSegment->SetRepeats(numRepeats);
  250. DWORD dwFlags;
  251. if(bPrimary)dwFlags=DMUS_SEGF_DEFAULT;
  252. else dwFlags=DMUS_SEGF_DEFAULT | DMUS_SEGF_SECONDARY;
  254. if(pSound[NumOfSound].is3DSound)
  255. {
  256. pSound[NumOfSound].dmSegment->Download(dmPerformance);
  257. //Play the segment using the 3D audio path
  258. dmPerformance->PlaySegmentEx(pSound[NumOfSound].dmSegment, NULL, NULL, 
  259.  dwFlags , 0,
  260.  NULL, NULL, dm3DAudioPath);
  262. pSoundState[NumOfSound]=SOUND_3D_PLAYING;
  263.     }
  264. else
  265. {
  266. //Download the segment's performance object
  267. pSound[NumOfSound].dmSegment->Download(dmPerformance);
  268. //Play the non-3D CAudioSegment segment
  269. dmPerformance->PlaySegmentEx(pSound[NumOfSound].dmSegment, NULL, NULL, 
  270.  dwFlags, 0,
  271.  NULL, NULL, NULL);
  273. pSoundState[NumOfSound]=SOUND_2D_PLAYING;
  274. }
  275. }
  277. //------------------------------------------------------------------//
  278. //- void CAudio::Stop(CAudioSegment*) --------------------------------//
  279. //------------------------------------------------------------------//
  280. //- Stop playing the specified CAudioSegment.    -//
  281. //------------------------------------------------------------------//
  282. void CAudio::Stop(unsigned int NumOfSound)
  283. {
  284. if(!bEnable)return;
  285. if(NumOfSound>(MAX_SOUND_NUM-1) ||
  286.    pSoundState[NumOfSound]==SOUND_NULL ||
  287.    pSoundState[NumOfSound]==SOUND_2D_IDLE  ) return  ;
  288.     
  289. dmPerformance->StopEx(pSound[NumOfSound].dmSegment, 0, 0);
  291. if(pSound[NumOfSound].is3DSound)
  292. pSoundState[NumOfSound]=SOUND_3D_IDLE;
  293. else
  294. pSoundState[NumOfSound]=SOUND_2D_IDLE;
  296. }
  297. void CAudio::StopAll()
  298. {
  299. if(!bEnable)return;
  300. dmPerformance->StopEx(0, 0, 0);
  301. for(unsigned int i=0;i< MAX_SOUND_NUM;i++)
  302. if(pSoundState[i]!=SOUND_NULL)
  303. {
  304. if(pSound[i].is3DSound)
  305.         pSoundState[i]=SOUND_3D_IDLE;
  306.          else
  307.          pSoundState[i]=SOUND_2D_IDLE;
  308. }
  309. }
  310. void CAudio::SetVolume(int iVolume)
  311. {   
  312. if(!bEnable)return;
  313. if(iVolume<0)iVolume=0;
  314. if(iVolume>100)iVolume=100;
  315.     int volume=-4000+iVolume*60;
  316. dmPerformance->SetGlobalParam( GUID_PerfMasterVolume, 
  317.                                            (void*)&volume, sizeof(int) );      
  318. }
  320. //------------------------------------------------------------------//
  321. //- void CAudio::SetListenerPos(float, float, float) ---------//
  322. //------------------------------------------------------------------//
  323. //- Set the listener's (player's) position in 3D space.    -//
  324. //------------------------------------------------------------------//
  325. void CAudio::SetListenerPos(VERTEX *pos,float roty)
  326. {
  327. if(!bEnable)return;
  328. VERTEX v0;
  329. froty=roty;
  330. vListenerPos.xpos=pos->xpos;
  331. vListenerPos.ypos=pos->ypos;
  332. vListenerPos.zpos=pos->zpos;
  333. /*
  334. for(unsigned int i=0;i<MAX_SOUND_NUM;i++)
  335. {
  336. if(pSound[i].is3DSound && pSoundState[i]!=SOUND_NULL)
  337. {
  338. v0=GetTransformSoundPos(pSound[i].vPosition);
  339.      pSound[i].Set3DPos(&v0);
  340.         }
  341. }*/
  342. }
  343. //------------------------------------------------------------------//
  344. //- void CAudio::SetSoundPos(int ,float, float, float) ---------//
  345. //------------------------------------------------------------------//
  346. //- Set the sound's  position in 3D space.    -//
  347. void CAudio::SetSoundPos(unsigned int NumOfSound,VERTEX *pos)
  348. {
  349. if(!bEnable)return;
  350. if(NumOfSound>(MAX_SOUND_NUM-1) || pSoundState[NumOfSound]==SOUND_NULL)  return  ;
  352. if(pSound[NumOfSound].is3DSound)
  353. {
  354.         pSound[NumOfSound].vPosition->xpos=pos->xpos;
  355.         pSound[NumOfSound].vPosition->ypos=pos->ypos;
  356.         pSound[NumOfSound].vPosition->zpos=pos->zpos;
  357.         VERTEX v0=GetTransformSoundPos(pos);
  358. pSound[NumOfSound].Set3DPos(&v0);
  359.     }
  360. }
  361. //------------------------------------------------------------------//
  362. //- void CAudio::GetTransformSoundPos(VERTEX *vSoundPos)------------------//
  363. //------------------------------------------------------------------//
  364. VERTEX CAudio::GetTransformSoundPos(VERTEX *vSoundPos)
  365. {
  366.     //////// translation
  367.     VERTEX v0=VERTEX(vSoundPos->xpos - vListenerPos.xpos,
  368.                  vSoundPos->ypos - vListenerPos.ypos,
  369.                  vSoundPos->zpos - vListenerPos.zpos);
  371.     //////// y rotate
  372.     VERTEX v1=VERTEX(v0.xpos*cosf(froty*0.0174533f)-
  373.                      v0.zpos*sinf(froty*0.0174533f),
  374.                  v0.ypos,
  375.                      v0.xpos*sinf(froty*0.0174533f)+
  376.                      v0.zpos*cosf(froty*0.0174533f));
  377. return v1;
  378. }
  379. //------------------------------------------------------------------//
  380. //- void CAudio::CheckSoundPlaying(unsigned int NumOfSound)-------------------//
  381. //------------------------------------------------------------------//
  382. bool CAudio::CheckSoundPlaying(unsigned int NumOfSound)
  383. {
  384. if(!bEnable)return false;
  385. if(NumOfSound>(MAX_SOUND_NUM-1) || pSoundState[NumOfSound]==SOUND_NULL)return false ;
  387. HRESULT hr=dmPerformance->IsPlaying(pSound[NumOfSound].dmSegment,0);
  389. if(hr==S_OK)
  390. {
  391. if(pSound[NumOfSound].is3DSound)
  392.     pSoundState[NumOfSound]=SOUND_3D_PLAYING;
  393.         else
  394.         pSoundState[NumOfSound]=SOUND_2D_PLAYING;
  396.     return true;
  397. }
  398. else
  399. {
  400. if(pSound[NumOfSound].is3DSound)
  401.     pSoundState[NumOfSound]=SOUND_3D_IDLE;
  402.         else
  403.         pSoundState[NumOfSound]=SOUND_2D_IDLE;
  405.     return false;
  406. }
  407. }
  408. //------------------------------------------------------------------//
  409. //- CAudio::GetSoundState(unsigned int NumOfSound)------------------//
  410. //------------------------------------------------------------------//
  411. int  CAudio::GetSoundState(unsigned int NumOfSound)
  412. {
  413. if(!bEnable)return 0;
  414. if(pSoundState[NumOfSound]==SOUND_3D_PLAYING || pSoundState[NumOfSound]==SOUND_2D_PLAYING)
  415. CheckSoundPlaying(NumOfSound);
  417. return (int)pSoundState[NumOfSound];
  418. }
  419. //------------------------------------------------------------------//
  420. //- void CAudio::SetListenerRolloff(float) -------------------//
  421. //------------------------------------------------------------------//
  422. //- Set the listener's CAudioSegment volume rolloff with distance.    -//
  423. //------------------------------------------------------------------//
  424. void CAudio::SetSoundRolloff(float rolloff)
  425. {
  427. }
  428. //------------------------------------------------------------------//
  429. //- void CAudio::ShutdowSound(unsigned int NumOfSound) ------------------------//
  430. //------------------------------------------------------------------//
  431. void CAudio::DeleteSound(unsigned int NumOfSound)
  432. {
  433. if(!bEnable)return;
  434.     if(pSoundState[NumOfSound]!=SOUND_NULL)
  435. {
  436. pSound[NumOfSound].Shutdown();
  437.         pSoundState[NumOfSound]=SOUND_NULL;
  438. }
  439. }
  440. bool CAudio::SetAudioActive(bool bAudioActive)
  441. {
  442. if(!bEnable)return false;
  443.     bActive=bAudioActive;
  444. return true;
  445. }
  446. bool CAudio::IsAudioEnable()
  447. {
  448. return bEnable;
  449. }
  450. bool CAudio::IsAudioActive()
  451. {
  452. return bActive;
  453. }
  455. //------------------------------------------------------------------//
  456. //- void CAudio::ReleaseAudio(void) ------------------------//
  457. //------------------------------------------------------------------//
  458. //- Shuts down DirectAudio.  This function is called automatically -//
  459. //- by the CAudio destructor, hence the reason why this    -//
  460. //- function is private.    -//
  461. //------------------------------------------------------------------//
  462. void CAudio::ReleaseAudio(void)
  463. {
  464. if(pSound!=NULL && pSoundState!=NULL)
  465. {
  466.         for(unsigned int i=0;i < MAX_SOUND_NUM;i++)
  467. {
  468.     if(pSoundState[i]!=SOUND_NULL)pSound[i].Shutdown();
  469. }
  470.         delete [] pSound;
  471.     delete [] pSoundState;
  472.     pSound=NULL;
  473.     pSoundState=NULL;
  474. }
  476. //Shut down the direct music performance information
  477. if(dmPerformance!=NULL)
  478. {
  479. dmPerformance->Stop(NULL, NULL, 0, 0);
  480. dmPerformance->CloseDown();
  482. dmPerformance->Release();
  483. dmPerformance=NULL;
  484. }
  486. //Shut down the direct music audiopath
  487. if(dm3DAudioPath!=NULL)
  488. {
  489. dm3DAudioPath->Release();
  490. dm3DAudioPath=NULL;
  491. }
  493. //Shut down the direct music loader
  494.    if(dmLoader!=NULL)
  495. {
  496.      dmLoader->Release();
  497. dmLoader=NULL;
  498. }
  499. //Uninitialize COM (*MUST* be done, or you're asking for trouble)
  500. CoUninitialize();
  502. }