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

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

游戏引擎

开发平台：

Visual C++

sound.cpp：源码内容
  1. /*
  2. ** Haaf's Game Engine 1.5
  3. ** Copyright (C) 2003-2004, 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);
  88. chn=BASS_SampleGetChannel(eff, FALSE);
  89. BASS_ChannelSetAttributes(chn, (int)(pitch*info.freq), volume, pan);
  90. BASS_ChannelSetFlags(chn, loop ? BASS_SAMPLE_LOOP:0);
  91. BASS_ChannelPlay(chn, TRUE);
  92. return chn;
  93. }
  94. else return 0;
  95. }
  97. void CALL HGE_Impl::Effect_Free(HEFFECT eff)
  98. {
  99. if(hBass) BASS_SampleFree(eff);
  100. }
  102. HMUSIC CALL HGE_Impl::Music_Load(const char *filename, DWORD size)
  103. {
  104. void *data;
  105. DWORD _size;
  106. HMUSIC hm;
  108. if(hBass)
  109. {
  110. if(size) { data=(void *)filename; _size=size; }
  111. else
  112. {
  113. data=Resource_Load(filename, &_size);
  114. if(!data) return 0;
  115. }
  116. hm=BASS_MusicLoad(TRUE, data, 0, _size, (BASS_MUSIC_PRESCAN | BASS_MUSIC_POSRESET), 0);
  117. if(!hm) _PostError("Can't load music");
  118. if(!size) Resource_Free(data);
  119. return hm;
  120. }
  121. else return 0;
  122. }
  124. HCHANNEL CALL HGE_Impl::Music_Play(HMUSIC mus, bool loop)
  125. {
  126. if(hBass)
  127. {
  128. BASS_CHANNELINFO info;
  129. BASS_ChannelGetInfo(mus, &info);
  130. BASS_ChannelSetAttributes(mus, info.freq, 100, 0);
  131. BASS_ChannelSetFlags(mus, loop ? BASS_SAMPLE_LOOP:0);
  132. BASS_ChannelPlay(mus, TRUE);
  133. return mus;
  134. }
  135. else return 0;
  136. }
  138. void CALL HGE_Impl::Music_Free(HMUSIC mus)
  139. {
  140. if(hBass) BASS_MusicFree(mus);
  141. }
  143. HSTREAM CALL HGE_Impl::Stream_Load(const char *filename, DWORD size)
  144. {
  145. void *data;
  146. DWORD _size;
  147. HSTREAM hs;
  148. CStreamList *stmItem;
  150. if(hBass)
  151. {
  152. if(bSilent) return 1;
  154. if(size) { data=(void *)filename; _size=size; }
  155. else
  156. {
  157. data=Resource_Load(filename, &_size);
  158. if(!data) return 0;
  159. }
  160. hs=BASS_StreamCreateFile(TRUE, data, 0, _size, 0);
  161. if(!hs)
  162. {
  163. _PostError("Can't load stream");
  164. if(!size) Resource_Free(data);
  165. return 0;
  166. }
  167. if(!size)
  168. {
  169. stmItem=new CStreamList;
  170. stmItem->hstream=hs;
  171. stmItem->data=data;
  172. stmItem->next=streams;
  173. streams=stmItem;
  174. }
  175. return hs;
  176. }
  177. else return 0;
  178. }
  180. void CALL HGE_Impl::Stream_Free(HSTREAM stream)
  181. {
  182. CStreamList *stmItem=streams, *stmPrev=0;
  184. if(hBass)
  185. {
  186. while(stmItem)
  187. {
  188. if(stmItem->hstream==stream)
  189. {
  190. if(stmPrev) stmPrev->next=stmItem->next;
  191. else streams=stmItem->next;
  192. Resource_Free(stmItem->data);
  193. delete stmItem;
  194. break;
  195. }
  196. stmPrev=stmItem;
  197. stmItem=stmItem->next;
  198. }
  199. BASS_StreamFree(stream);
  200. }
  201. }
  203. HCHANNEL CALL HGE_Impl::Stream_Play(HSTREAM stream, bool loop, int volume)
  204. {
  205. if(hBass)
  206. {
  207. BASS_CHANNELINFO info;
  208. BASS_ChannelGetInfo(stream, &info);
  209. BASS_ChannelSetAttributes(stream, info.freq, volume, 0);
  210. BASS_ChannelSetFlags(stream, loop ? BASS_SAMPLE_LOOP:0);
  211. BASS_ChannelPlay(stream, TRUE);
  212. return stream;
  213. }
  214. else return 0;
  215. }
  217. void CALL HGE_Impl::Channel_SetPanning(HCHANNEL chn, int pan)
  218. {
  219. if(hBass) BASS_ChannelSetAttributes(chn, -1, -1, pan);
  220. }
  222. void CALL HGE_Impl::Channel_SetVolume(HCHANNEL chn, int volume)
  223. {
  224. if(hBass) BASS_ChannelSetAttributes(chn, -1, volume, -101);
  225. }
  227. void CALL HGE_Impl::Channel_SetPitch(HCHANNEL chn, float pitch)
  228. {
  229. if(hBass)
  230. {
  231. BASS_CHANNELINFO info;
  232. BASS_ChannelGetInfo(chn, &info);
  233. BASS_ChannelSetAttributes(chn, (int)(pitch*info.freq), -1, -101);
  234. }
  235. }
  237. void CALL HGE_Impl::Channel_Pause(HCHANNEL chn)
  238. {
  239. if(hBass) BASS_ChannelPause(chn);
  240. }
  242. void CALL HGE_Impl::Channel_Resume(HCHANNEL chn)
  243. {
  244. if(hBass) BASS_ChannelPlay(chn, FALSE);
  245. }
  247. void CALL HGE_Impl::Channel_Stop(HCHANNEL chn)
  248. {
  249. if(hBass) BASS_ChannelStop(chn);
  250. }
  252. void CALL HGE_Impl::Channel_StopAll()
  253. {
  254. if(hBass) { BASS_Stop();BASS_Start(); }
  255. }
  257. bool CALL HGE_Impl::Channel_IsPlaying(HCHANNEL chn)
  258. {
  259. if(hBass)
  260. {
  261. if(BASS_ChannelIsActive(chn)==BASS_ACTIVE_PLAYING) return true;
  262. else return false;
  263. }
  264. else return false;
  265. }
  267. float CALL HGE_Impl::Channel_GetLength(HCHANNEL chn) {
  268. if(hBass)
  269. {
  270. return BASS_ChannelBytes2Seconds(chn, BASS_ChannelGetLength(chn));
  271. }
  272. else return -1;
  273. }
  275. float CALL HGE_Impl::Channel_GetPos(HCHANNEL chn) {
  276. if(hBass)
  277. {
  278. return BASS_ChannelBytes2Seconds(chn, BASS_ChannelGetPosition(chn));
  279. }
  280. else return -1;
  281. }
  283. void CALL HGE_Impl::Channel_SetPos(HCHANNEL chn, float fSeconds) {
  284. if(hBass)
  285. {
  286. BASS_ChannelSetPosition(chn, BASS_ChannelSeconds2Bytes(chn, fSeconds));
  287. }
  288. }
  291. //////// Implementation ////////
  294. bool HGE_Impl::_SoundInit()
  295. {
  296. if(!bUseSound || hBass) return true;
  298. hBass=LoadLibrary("bass.dll");
  299. if (!hBass)
  300. {
  301. _PostError("Can't load BASS.DLL");
  302. return false;
  303. }
  305. LOADBASSFUNCTION(BASS_GetVersion);
  307. if (BASS_GetVersion()!=MAKELONG(2,2))
  308. {
  309. _PostError("Incorrect BASS.DLL version");
  310. return false;
  311. }
  313. LOADBASSFUNCTION(BASS_GetDeviceDescription);
  314. LOADBASSFUNCTION(BASS_Init);
  315. LOADBASSFUNCTION(BASS_Free);
  316. LOADBASSFUNCTION(BASS_Start);
  317. LOADBASSFUNCTION(BASS_Stop);
  318. LOADBASSFUNCTION(BASS_SetConfig);
  320. LOADBASSFUNCTION(BASS_SampleLoad);
  321. LOADBASSFUNCTION(BASS_SampleCreate);
  322. LOADBASSFUNCTION(BASS_SampleCreateDone);
  323. LOADBASSFUNCTION(BASS_SampleGetInfo);
  324. LOADBASSFUNCTION(BASS_SampleGetChannel);
  325. LOADBASSFUNCTION(BASS_SampleFree);
  327. LOADBASSFUNCTION(BASS_MusicLoad);
  328. LOADBASSFUNCTION(BASS_MusicFree);
  330. LOADBASSFUNCTION(BASS_StreamCreateFile);
  331. LOADBASSFUNCTION(BASS_StreamFree);
  333. LOADBASSFUNCTION(BASS_ChannelGetInfo);
  334. LOADBASSFUNCTION(BASS_ChannelGetAttributes);
  335. LOADBASSFUNCTION(BASS_ChannelSetAttributes);
  336. LOADBASSFUNCTION(BASS_ChannelSetFlags);
  337. LOADBASSFUNCTION(BASS_ChannelGetData);
  338. LOADBASSFUNCTION(BASS_ChannelPlay);
  339. LOADBASSFUNCTION(BASS_ChannelPause);
  340. LOADBASSFUNCTION(BASS_ChannelStop);
  341. LOADBASSFUNCTION(BASS_ChannelIsActive);
  342. LOADBASSFUNCTION(BASS_ChannelGetLength);
  343. LOADBASSFUNCTION(BASS_ChannelGetPosition);
  344. LOADBASSFUNCTION(BASS_ChannelSetPosition);
  345. LOADBASSFUNCTION(BASS_ChannelSeconds2Bytes);
  346. LOADBASSFUNCTION(BASS_ChannelBytes2Seconds);
  348. bSilent=false;
  349. if (!BASS_Init(1,nSampleRate,0,hwnd,NULL))
  350. {
  351. System_Log("BASS Init failed, using no sound");
  352. BASS_Init(0,nSampleRate,0,hwnd,NULL);
  353. bSilent=true;
  354. }
  355. else
  356. {
  357. System_Log("Sound Device: %s",BASS_GetDeviceDescription(1));
  358. System_Log("Sample rate: %ldn", nSampleRate);
  359. }
  361. _SetFXVolume(nFXVolume);
  362. _SetMusVolume(nMusVolume);
  364. return true;
  365. }
  367. void HGE_Impl::_SoundDone()
  368. {
  369. CStreamList *stmItem=streams, *stmNext;
  371. if(hBass)
  372. {
  373. BASS_Stop();
  374. BASS_Free();
  375. FreeLibrary(hBass);
  376. hBass=0;
  378. while(stmItem)
  379. {
  380. stmNext=stmItem->next;
  381. Resource_Free(stmItem->data);
  382. delete stmItem;
  383. stmItem=stmNext;
  384. }
  385. streams=0;
  386. }
  387. }
  389. void HGE_Impl::_SetMusVolume(int vol)
  390. {
  391. if(hBass) BASS_SetConfig(BASS_CONFIG_GVOL_MUSIC, vol);
  392. }
  394. void HGE_Impl::_SetFXVolume(int vol)
  395. {
  396. if(hBass) BASS_SetConfig(BASS_CONFIG_GVOL_SAMPLE, vol);
  397. }