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

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

游戏引擎

开发平台：

Visual C++

sound.cpp：源码内容
  1. /*
  2. ** Haaf's Game Engine 1.8
  3. ** Copyright (C) 2003-2007, Relish Games
  4. ** hge.relishgames.com
  5. **
  6. ** Core functions implementation: audio routines
  7. */
  10. #include "hge_impl.h"
  13. #define BASSDEF(f) (WINAPI *f) // define the functions as pointers
  14. #include "BASSbass.h"
  16. #define LOADBASSFUNCTION(f) *((void**)&f)=(void*)GetProcAddress(hBass,#f)
  19. HEFFECT CALL HGE_Impl::Effect_Load(const char *filename, DWORD size)
  20. {
  21. DWORD _size, length, samples;
  22. HSAMPLE hs;
  23. HSTREAM hstrm;
  24. BASS_CHANNELINFO info;
  25. void *buffer, *data;
  27. if(hBass)
  28. {
  29. if(bSilent) return 1;
  31. if(size) { data=(void *)filename; _size=size; }
  32. else
  33. {
  34. data=Resource_Load(filename, &_size);
  35. if(!data) return NULL;
  36. }
  38. hs=BASS_SampleLoad(TRUE, data, 0, _size, 4, BASS_SAMPLE_OVER_VOL);
  39. if(!hs) {
  40. hstrm=BASS_StreamCreateFile(TRUE, data, 0, _size, BASS_STREAM_DECODE);
  41. if(hstrm) {
  42. length=(DWORD)BASS_ChannelGetLength(hstrm);
  43. BASS_ChannelGetInfo(hstrm, &info);
  44. samples=length;
  45. if(info.chans < 2) samples>>=1;
  46. if((info.flags & BASS_SAMPLE_8BITS) == 0) samples>>=1;
  47. buffer=BASS_SampleCreate(samples, info.freq, 2, 4, info.flags | BASS_SAMPLE_OVER_VOL);
  48. if(!buffer)
  49. {
  50. BASS_StreamFree(hstrm);
  51. _PostError("Can't create sound effect: Not enough memory");
  52. }
  53. else
  54. {
  55. BASS_ChannelGetData(hstrm, buffer, length);
  56. hs=BASS_SampleCreateDone();
  57. BASS_StreamFree(hstrm);
  58. if(!hs) _PostError("Can't create sound effect");
  59. }
  60. }
  61. }
  63. if(!size) Resource_Free(data);
  64. return hs;
  65. }
  66. else return 0;
  67. }
  69. HCHANNEL CALL HGE_Impl::Effect_Play(HEFFECT eff)
  70. {
  71. if(hBass)
  72. {
  73. HCHANNEL chn;
  74. chn=BASS_SampleGetChannel(eff, FALSE);
  75. BASS_ChannelPlay(chn, TRUE);
  76. return chn;
  77. }
  78. else return 0;
  79. }
  81. HCHANNEL CALL HGE_Impl::Effect_PlayEx(HEFFECT eff, int volume, int pan, float pitch, bool loop)
  82. {
  83. if(hBass)
  84. {
  85. BASS_SAMPLE info;
  86. HCHANNEL chn;
  87. BASS_SampleGetInfo(eff, &info);
  89. chn=BASS_SampleGetChannel(eff, FALSE);
  90. BASS_ChannelSetAttributes(chn, (int)(pitch*info.freq), volume, pan);
  92. info.flags &= ~BASS_SAMPLE_LOOP;
  93. if(loop) info.flags |= BASS_SAMPLE_LOOP;
  94. BASS_ChannelSetFlags(chn, info.flags);
  95. BASS_ChannelPlay(chn, TRUE);
  96. return chn;
  97. }
  98. else return 0;
  99. }
  102. void CALL HGE_Impl::Effect_Free(HEFFECT eff)
  103. {
  104. if(hBass) BASS_SampleFree(eff);
  105. }
  108. HMUSIC CALL HGE_Impl::Music_Load(const char *filename, DWORD size)
  109. {
  110. void *data;
  111. DWORD _size;
  112. HMUSIC hm;
  114. if(hBass)
  115. {
  116. if(size)
  117. {
  118. data=(void *)filename;
  119. _size=size;
  120. }
  121. else
  122. {
  123. data=Resource_Load(filename, &_size);
  124. if(!data) return 0;
  125. }
  127. hm=BASS_MusicLoad(TRUE, data, 0, 0, BASS_MUSIC_PRESCAN | BASS_MUSIC_POSRESETEX | BASS_MUSIC_RAMP, 0);
  128. if(!hm) _PostError("Can't load music");
  129. if(!size) Resource_Free(data);
  130. return hm;
  131. }
  132. else return 0;
  133. }
  135. HCHANNEL CALL HGE_Impl::Music_Play(HMUSIC mus, bool loop, int volume, int order, int row)
  136. {
  137. if(hBass)
  138. {
  139. DWORD pos = BASS_MusicGetOrderPosition(mus);
  140. if(order == -1) order = LOWORD(pos);
  141. if(row == -1) row = HIWORD(pos);
  142. BASS_ChannelSetPosition(mus, MAKEMUSICPOS(order, row));
  144. BASS_CHANNELINFO info;
  145. BASS_ChannelGetInfo(mus, &info);
  146. BASS_ChannelSetAttributes(mus, info.freq, volume, 0);
  148. info.flags &= ~BASS_SAMPLE_LOOP;
  149. if(loop) info.flags |= BASS_SAMPLE_LOOP;
  150. BASS_ChannelSetFlags(mus, info.flags);
  152. BASS_ChannelPlay(mus, FALSE);
  154. return mus;
  155. }
  156. else return 0;
  157. }
  159. void CALL HGE_Impl::Music_Free(HMUSIC mus)
  160. {
  161. if(hBass) BASS_MusicFree(mus);
  162. }
  164. void CALL HGE_Impl::Music_SetAmplification(HMUSIC music, int ampl)
  165. {
  166. if(hBass) BASS_MusicSetAttribute(music, BASS_MUSIC_ATTRIB_AMPLIFY, ampl);
  167. }
  169. int CALL HGE_Impl::Music_GetAmplification(HMUSIC music)
  170. {
  171. if(hBass) return BASS_MusicGetAttribute(music, BASS_MUSIC_ATTRIB_AMPLIFY);
  172. else return -1;
  173. }
  175. int CALL HGE_Impl::Music_GetLength(HMUSIC music)
  176. {
  177. if(hBass)
  178. {
  179. return BASS_MusicGetOrders(music);
  180. }
  181. else return -1;
  182. }
  184. void CALL HGE_Impl::Music_SetPos(HMUSIC music, int order, int row)
  185. {
  186. if(hBass)
  187. {
  188. BASS_ChannelSetPosition(music, MAKEMUSICPOS(order, row));
  189. }
  190. }
  192. bool CALL HGE_Impl::Music_GetPos(HMUSIC music, int *order, int *row)
  193. {
  194. if(hBass)
  195. {
  196. DWORD pos;
  197. pos = BASS_MusicGetOrderPosition(music);
  198. if(pos == -1) return false;
  199. *order = LOWORD(pos);
  200. *row = HIWORD(pos);
  201. return true;
  202. }
  203. else return false;
  204. }
  206. void CALL HGE_Impl::Music_SetInstrVolume(HMUSIC music, int instr, int volume)
  207. {
  208. if(hBass)
  209. {
  210. BASS_MusicSetAttribute(music, BASS_MUSIC_ATTRIB_VOL_INST + instr, volume);
  211. }
  212. }
  214. int CALL HGE_Impl::Music_GetInstrVolume(HMUSIC music, int instr)
  215. {
  216. if(hBass)
  217. {
  218. return BASS_MusicGetAttribute(music, BASS_MUSIC_ATTRIB_VOL_INST + instr);
  219. }
  220. else return -1;
  221. }
  223. void CALL HGE_Impl::Music_SetChannelVolume(HMUSIC music, int channel, int volume)
  224. {
  225. if(hBass)
  226. {
  227. BASS_MusicSetAttribute(music, BASS_MUSIC_ATTRIB_VOL_CHAN + channel, volume);
  228. }
  229. }
  231. int CALL HGE_Impl::Music_GetChannelVolume(HMUSIC music, int channel)
  232. {
  233. if(hBass)
  234. {
  235. return BASS_MusicGetAttribute(music, BASS_MUSIC_ATTRIB_VOL_CHAN + channel);
  236. }
  237. else return -1;
  238. }
  240. HSTREAM CALL HGE_Impl::Stream_Load(const char *filename, DWORD size)
  241. {
  242. void *data;
  243. DWORD _size;
  244. HSTREAM hs;
  245. CStreamList *stmItem;
  247. if(hBass)
  248. {
  249. if(bSilent) return 1;
  251. if(size) { data=(void *)filename; _size=size; }
  252. else
  253. {
  254. data=Resource_Load(filename, &_size);
  255. if(!data) return 0;
  256. }
  257. hs=BASS_StreamCreateFile(TRUE, data, 0, _size, 0);
  258. if(!hs)
  259. {
  260. _PostError("Can't load stream");
  261. if(!size) Resource_Free(data);
  262. return 0;
  263. }
  264. if(!size)
  265. {
  266. stmItem=new CStreamList;
  267. stmItem->hstream=hs;
  268. stmItem->data=data;
  269. stmItem->next=streams;
  270. streams=stmItem;
  271. }
  272. return hs;
  273. }
  274. else return 0;
  275. }
  277. void CALL HGE_Impl::Stream_Free(HSTREAM stream)
  278. {
  279. CStreamList *stmItem=streams, *stmPrev=0;
  281. if(hBass)
  282. {
  283. while(stmItem)
  284. {
  285. if(stmItem->hstream==stream)
  286. {
  287. if(stmPrev) stmPrev->next=stmItem->next;
  288. else streams=stmItem->next;
  289. Resource_Free(stmItem->data);
  290. delete stmItem;
  291. break;
  292. }
  293. stmPrev=stmItem;
  294. stmItem=stmItem->next;
  295. }
  296. BASS_StreamFree(stream);
  297. }
  298. }
  300. HCHANNEL CALL HGE_Impl::Stream_Play(HSTREAM stream, bool loop, int volume)
  301. {
  302. if(hBass)
  303. {
  304. BASS_CHANNELINFO info;
  305. BASS_ChannelGetInfo(stream, &info);
  306. BASS_ChannelSetAttributes(stream, info.freq, volume, 0);
  308. info.flags &= ~BASS_SAMPLE_LOOP;
  309. if(loop) info.flags |= BASS_SAMPLE_LOOP;
  310. BASS_ChannelSetFlags(stream, info.flags);
  311. BASS_ChannelPlay(stream, TRUE);
  312. return stream;
  313. }
  314. else return 0;
  315. }
  317. void CALL HGE_Impl::Channel_SetPanning(HCHANNEL chn, int pan)
  318. {
  319. if(hBass) BASS_ChannelSetAttributes(chn, -1, -1, pan);
  320. }
  322. void CALL HGE_Impl::Channel_SetVolume(HCHANNEL chn, int volume)
  323. {
  324. if(hBass) BASS_ChannelSetAttributes(chn, -1, volume, -101);
  325. }
  327. void CALL HGE_Impl::Channel_SetPitch(HCHANNEL chn, float pitch)
  328. {
  329. if(hBass)
  330. {
  331. BASS_CHANNELINFO info;
  332. BASS_ChannelGetInfo(chn, &info);
  333. BASS_ChannelSetAttributes(chn, (int)(pitch*info.freq), -1, -101);
  334. }
  335. }
  337. void CALL HGE_Impl::Channel_Pause(HCHANNEL chn)
  338. {
  339. if(hBass) BASS_ChannelPause(chn);
  340. }
  342. void CALL HGE_Impl::Channel_Resume(HCHANNEL chn)
  343. {
  344. if(hBass) BASS_ChannelPlay(chn, FALSE);
  345. }
  347. void CALL HGE_Impl::Channel_Stop(HCHANNEL chn)
  348. {
  349. if(hBass) BASS_ChannelStop(chn);
  350. }
  352. void CALL HGE_Impl::Channel_PauseAll()
  353. {
  354. if(hBass) BASS_Pause();
  355. }
  357. void CALL HGE_Impl::Channel_ResumeAll()
  358. {
  359. if(hBass) BASS_Start();
  360. }
  362. void CALL HGE_Impl::Channel_StopAll()
  363. {
  364. if(hBass)
  365. {
  366. BASS_Stop();
  367. BASS_Start();
  368. }
  369. }
  371. bool CALL HGE_Impl::Channel_IsPlaying(HCHANNEL chn)
  372. {
  373. if(hBass)
  374. {
  375. if(BASS_ChannelIsActive(chn)==BASS_ACTIVE_PLAYING) return true;
  376. else return false;
  377. }
  378. else return false;
  379. }
  381. float CALL HGE_Impl::Channel_GetLength(HCHANNEL chn) {
  382. if(hBass)
  383. {
  384. return BASS_ChannelBytes2Seconds(chn, BASS_ChannelGetLength(chn));
  385. }
  386. else return -1;
  387. }
  389. float CALL HGE_Impl::Channel_GetPos(HCHANNEL chn) {
  390. if(hBass)
  391. {
  392. return BASS_ChannelBytes2Seconds(chn, BASS_ChannelGetPosition(chn));
  393. }
  394. else return -1;
  395. }
  397. void CALL HGE_Impl::Channel_SetPos(HCHANNEL chn, float fSeconds) {
  398. if(hBass)
  399. {
  400. BASS_ChannelSetPosition(chn, BASS_ChannelSeconds2Bytes(chn, fSeconds));
  401. }
  402. }
  404. void CALL HGE_Impl::Channel_SlideTo(HCHANNEL channel, float time, int volume, int pan, float pitch)
  405. {
  406. if(hBass)
  407. {
  408. BASS_CHANNELINFO info;
  409. BASS_ChannelGetInfo(channel, &info);
  411. int freq;
  412. if(pitch == -1) freq = -1;
  413. else freq = (int)(pitch*info.freq);
  415. BASS_ChannelSlideAttributes(channel, freq, volume, pan, DWORD(time*1000));
  416. }
  417. }
  419. bool CALL HGE_Impl::Channel_IsSliding(HCHANNEL channel)
  420. {
  421. if(hBass)
  422. {
  423. if(BASS_ChannelIsSliding(channel)) return true;
  424. else return false;
  425. }
  426. else return false;
  427. }
  430. //////// Implementation ////////
  433. bool HGE_Impl::_SoundInit()
  434. {
  435. if(!bUseSound || hBass) return true;
  437. hBass=LoadLibrary("bass.dll");
  438. if (!hBass)
  439. {
  440. _PostError("Can't load BASS.DLL");
  441. return false;
  442. }
  444. LOADBASSFUNCTION(BASS_GetVersion);
  446. if (HIWORD(BASS_GetVersion()) != BASSVERSION)
  447. {
  448. _PostError("Incorrect BASS.DLL version");
  449. return false;
  450. }
  452. LOADBASSFUNCTION(BASS_GetDeviceDescription);
  453. LOADBASSFUNCTION(BASS_Init);
  454. LOADBASSFUNCTION(BASS_Free);
  455. LOADBASSFUNCTION(BASS_Start);
  456. LOADBASSFUNCTION(BASS_Pause);
  457. LOADBASSFUNCTION(BASS_Stop);
  458. LOADBASSFUNCTION(BASS_SetConfig);
  459. //LOADBASSFUNCTION(BASS_ErrorGetCode);
  461. LOADBASSFUNCTION(BASS_SampleLoad);
  462. LOADBASSFUNCTION(BASS_SampleCreate);
  463. LOADBASSFUNCTION(BASS_SampleCreateDone);
  464. LOADBASSFUNCTION(BASS_SampleGetInfo);
  465. LOADBASSFUNCTION(BASS_SampleGetChannel);
  466. LOADBASSFUNCTION(BASS_SampleFree);
  468. LOADBASSFUNCTION(BASS_MusicLoad);
  469. LOADBASSFUNCTION(BASS_MusicFree);
  470. LOADBASSFUNCTION(BASS_MusicGetOrders);
  471. LOADBASSFUNCTION(BASS_MusicGetOrderPosition);
  472. LOADBASSFUNCTION(BASS_MusicSetAttribute);
  473. LOADBASSFUNCTION(BASS_MusicGetAttribute);
  475. LOADBASSFUNCTION(BASS_StreamCreateFile);
  476. LOADBASSFUNCTION(BASS_StreamFree);
  478. LOADBASSFUNCTION(BASS_ChannelGetInfo);
  479. LOADBASSFUNCTION(BASS_ChannelGetAttributes);
  480. LOADBASSFUNCTION(BASS_ChannelSetAttributes);
  481. LOADBASSFUNCTION(BASS_ChannelSlideAttributes);
  482. LOADBASSFUNCTION(BASS_ChannelIsSliding);
  483. LOADBASSFUNCTION(BASS_ChannelSetFlags);
  484. LOADBASSFUNCTION(BASS_ChannelGetData);
  485. LOADBASSFUNCTION(BASS_ChannelPlay);
  486. LOADBASSFUNCTION(BASS_ChannelPause);
  487. LOADBASSFUNCTION(BASS_ChannelStop);
  488. LOADBASSFUNCTION(BASS_ChannelIsActive);
  489. LOADBASSFUNCTION(BASS_ChannelGetLength);
  490. LOADBASSFUNCTION(BASS_ChannelGetPosition);
  491. LOADBASSFUNCTION(BASS_ChannelSetPosition);
  492. LOADBASSFUNCTION(BASS_ChannelSeconds2Bytes);
  493. LOADBASSFUNCTION(BASS_ChannelBytes2Seconds);
  495. bSilent=false;
  496. if (!BASS_Init(-1,nSampleRate,0,hwnd,NULL))
  497. {
  498. System_Log("BASS Init failed, using no sound");
  499. BASS_Init(0,nSampleRate,0,hwnd,NULL);
  500. bSilent=true;
  501. }
  502. else
  503. {
  504. System_Log("Sound Device: %s",BASS_GetDeviceDescription(1));
  505. System_Log("Sample rate: %ldn", nSampleRate);
  506. }
  508. //BASS_SetConfig(BASS_CONFIG_BUFFER, 5000);
  509. //BASS_SetConfig(BASS_CONFIG_UPDATEPERIOD, 50);
  511. _SetFXVolume(nFXVolume);
  512. _SetMusVolume(nMusVolume);
  513. _SetStreamVolume(nStreamVolume);
  515. return true;
  516. }
  518. void HGE_Impl::_SoundDone()
  519. {
  520. CStreamList *stmItem=streams, *stmNext;
  522. if(hBass)
  523. {
  524. BASS_Stop();
  525. BASS_Free();
  527. //int err = BASS_ErrorGetCode(); 
  529. FreeLibrary(hBass);
  530. hBass=0;
  532. while(stmItem)
  533. {
  534. stmNext=stmItem->next;
  535. Resource_Free(stmItem->data);
  536. delete stmItem;
  537. stmItem=stmNext;
  538. }
  539. streams=0;
  540. }
  541. }
  543. void HGE_Impl::_SetMusVolume(int vol)
  544. {
  545. if(hBass) BASS_SetConfig(BASS_CONFIG_GVOL_MUSIC, vol);
  546. }
  548. void HGE_Impl::_SetStreamVolume(int vol)
  549. {
  550. if(hBass) BASS_SetConfig(BASS_CONFIG_GVOL_STREAM, vol);
  551. }
  553. void HGE_Impl::_SetFXVolume(int vol)
  554. {
  555. if(hBass) BASS_SetConfig(BASS_CONFIG_GVOL_SAMPLE, vol);
  556. }