Revision | 81 (tree) |
---|---|
Zeit | 2010-05-11 11:35:19 |
Autor | bird_may_nike |
(empty log message)
@@ -46,7 +46,7 @@ | ||
46 | 46 | drawCreate(); |
47 | 47 | SetDrawSize(DS_2); |
48 | 48 | WsInputInit(hWnd); |
49 | - SetKeyMap(0); | |
49 | + WsInputSetKeyMap(0); | |
50 | 50 | WsSplash(); |
51 | 51 | while (1) { |
52 | 52 | if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) |
@@ -9,6 +9,7 @@ | ||
9 | 9 | #include "WSHard.h" |
10 | 10 | #include "WSApu.h" |
11 | 11 | #include "WSError.h" |
12 | +#include "WSInput.h" | |
12 | 13 | |
13 | 14 | #define BUFSIZEN 0x10000 |
14 | 15 | #define BPSWAV 12000 // WSのHblankが12KHz |
@@ -45,7 +46,8 @@ | ||
45 | 46 | break; |
46 | 47 | case WOM_DONE: |
47 | 48 | rBuf++; |
48 | - if (rBuf >= BUFCOUNT) { | |
49 | + if (rBuf >= BUFCOUNT) | |
50 | + { | |
49 | 51 | rBuf = 0; |
50 | 52 | } |
51 | 53 | break; |
@@ -72,11 +74,13 @@ | ||
72 | 74 | wfe.nSamplesPerSec = BPSWAV; |
73 | 75 | wfe.nAvgBytesPerSec = wfe.nSamplesPerSec * wfe.nBlockAlign; |
74 | 76 | result = waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfe, (DWORD_PTR)apuWaveOutProc, NULL, CALLBACK_FUNCTION); |
75 | - if (result != MMSYSERR_NOERROR ) { | |
77 | + if (result != MMSYSERR_NOERROR ) | |
78 | + { | |
76 | 79 | waveOutGetErrorText(result, msg, sizeof(msg)); |
77 | 80 | ErrorMsg(ERR_WAVEOUT_OPEN); |
78 | 81 | } |
79 | - for (i = 0; i < BUFCOUNT; i++) { | |
82 | + for (i = 0; i < BUFCOUNT; i++) | |
83 | + { | |
80 | 84 | whdr[i] = (WAVEHDR*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WAVEHDR)); |
81 | 85 | whdr[i]->lpData = (char*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, BUFSIZEW * 4); |
82 | 86 | whdr[i]->dwBufferLength = BUFSIZEW * 4; |
@@ -83,7 +87,8 @@ | ||
83 | 87 | whdr[i]->dwFlags = 0; |
84 | 88 | whdr[i]->dwLoops = 0; |
85 | 89 | result = waveOutPrepareHeader(hWaveOut, whdr[i], sizeof(WAVEHDR)); |
86 | - if (result != MMSYSERR_NOERROR ) { | |
90 | + if (result != MMSYSERR_NOERROR ) | |
91 | + { | |
87 | 92 | waveOutGetErrorText(result, msg, sizeof(msg)); |
88 | 93 | ErrorMsg(ERR_WAVEOUT_PREPAREHEADER); |
89 | 94 | } |
@@ -96,8 +101,10 @@ | ||
96 | 101 | int i; |
97 | 102 | |
98 | 103 | waveOutReset(hWaveOut); |
99 | - for(i = 0; i < BUFCOUNT; i++) { | |
100 | - if (whdr[i]) { | |
104 | + for(i = 0; i < BUFCOUNT; i++) | |
105 | + { | |
106 | + if (whdr[i]) | |
107 | + { | |
101 | 108 | waveOutUnprepareHeader(hWaveOut,whdr[i],sizeof(WAVEHDR)); |
102 | 109 | HeapFree(GetProcessHeap(),0,whdr[i]->lpData); |
103 | 110 | HeapFree(GetProcessHeap(),0,whdr[i]); |
@@ -113,7 +120,8 @@ | ||
113 | 120 | int i; |
114 | 121 | |
115 | 122 | waveOutReset(hWaveOut); |
116 | - for (i = 0; i < BUFCOUNT; i++) { | |
123 | + for (i = 0; i < BUFCOUNT; i++) | |
124 | + { | |
117 | 125 | ZeroMemory(whdr[i]->lpData, BUFSIZEW * 4); |
118 | 126 | } |
119 | 127 | rBuf = 0; |
@@ -125,18 +133,23 @@ | ||
125 | 133 | { |
126 | 134 | int i, j; |
127 | 135 | |
128 | - for (i = 0; i < 4; i++) { | |
129 | - for (j = 0; j < 32; j++) { | |
136 | + for (i = 0; i < 4; i++) | |
137 | + { | |
138 | + for (j = 0; j < 32; j++) | |
139 | + { | |
130 | 140 | PData[i][j] = 8; |
131 | 141 | } |
132 | 142 | } |
133 | - for (i = 0; i < 8; i++) { | |
134 | - for (j = 0; j < BUFSIZEN; j++) { | |
143 | + for (i = 0; i < 8; i++) | |
144 | + { | |
145 | + for (j = 0; j < BUFSIZEN; j++) | |
146 | + { | |
135 | 147 | PDataN[i][j] = ((apuMrand(15 - i) & 1) ? 15 : 0); |
136 | 148 | } |
137 | 149 | } |
138 | 150 | |
139 | - for (i = 0; i < BUFSIZEN; i++) { | |
151 | + for (i = 0; i < BUFSIZEN; i++) | |
152 | + { | |
140 | 153 | RandData[i] = apuMrand(15); |
141 | 154 | } |
142 | 155 | apuWaveCreate(); |
@@ -151,7 +164,8 @@ | ||
151 | 164 | unsigned int apuMrand(unsigned int Degree) |
152 | 165 | { |
153 | 166 | #define BIT(n) (1<<n) |
154 | - typedef struct { | |
167 | + typedef struct | |
168 | + { | |
155 | 169 | unsigned int N; |
156 | 170 | int InputBit; |
157 | 171 | int Mask; |
@@ -180,31 +194,38 @@ | ||
180 | 194 | int XorReg = 0; |
181 | 195 | int Masked; |
182 | 196 | |
183 | - if(pTbl->N != Degree) { | |
197 | + if(pTbl->N != Degree) | |
198 | + { | |
184 | 199 | pTbl = TblMask; |
185 | 200 | while(pTbl->N) { |
186 | - if(pTbl->N == Degree) { | |
201 | + if(pTbl->N == Degree) | |
202 | + { | |
187 | 203 | break; |
188 | 204 | } |
189 | 205 | pTbl++; |
190 | 206 | } |
191 | - if(!pTbl->N) { | |
207 | + if(!pTbl->N) | |
208 | + { | |
192 | 209 | pTbl--; |
193 | 210 | } |
194 | 211 | ShiftReg &= pTbl->InputBit-1; |
195 | - if(!ShiftReg) { | |
212 | + if(!ShiftReg) | |
213 | + { | |
196 | 214 | ShiftReg = pTbl->InputBit-1; |
197 | 215 | } |
198 | 216 | } |
199 | 217 | Masked = ShiftReg & pTbl->Mask; |
200 | - while(Masked) { | |
218 | + while(Masked) | |
219 | + { | |
201 | 220 | XorReg ^= Masked & 0x01; |
202 | 221 | Masked >>= 1; |
203 | 222 | } |
204 | - if(XorReg) { | |
223 | + if(XorReg) | |
224 | + { | |
205 | 225 | ShiftReg |= pTbl->InputBit; |
206 | 226 | } |
207 | - else { | |
227 | + else | |
228 | + { | |
208 | 229 | ShiftReg &= ~pTbl->InputBit; |
209 | 230 | } |
210 | 231 | ShiftReg >>= 1; |
@@ -232,13 +253,16 @@ | ||
232 | 253 | { |
233 | 254 | b++; |
234 | 255 | } |
235 | - if (v < 0x80) { | |
256 | + if (v < 0x80) | |
257 | + { | |
236 | 258 | v += 0x80; |
237 | 259 | } |
238 | - else { | |
260 | + else | |
261 | + { | |
239 | 262 | v -= 0x80; |
240 | 263 | } |
241 | - if (SDMACNT <= index) { | |
264 | + if (SDMACNT <= index) | |
265 | + { | |
242 | 266 | index = 0; |
243 | 267 | b = 0; |
244 | 268 | } |
@@ -250,7 +274,8 @@ | ||
250 | 274 | { |
251 | 275 | b++; |
252 | 276 | } |
253 | - if (SDMACNT <= index) { | |
277 | + if (SDMACNT <= index) | |
278 | + { | |
254 | 279 | SDMACTL &= 0x7F; // DMA end |
255 | 280 | SDMACNT = 0; |
256 | 281 | index = 0; |
@@ -262,8 +287,10 @@ | ||
262 | 287 | |
263 | 288 | void apuSweep(void) |
264 | 289 | { |
265 | - if ((Swp.step) && Swp.on) { // sweep on | |
266 | - if (Swp.cnt < 0) { | |
290 | + if ((Swp.step) && Swp.on) // sweep on | |
291 | + { | |
292 | + if (Swp.cnt < 0) | |
293 | + { | |
267 | 294 | Swp.cnt = Swp.time; |
268 | 295 | Ch[2].freq += Swp.step; |
269 | 296 | Ch[2].freq &= 0x7ff; |
@@ -276,7 +303,8 @@ | ||
276 | 303 | { |
277 | 304 | static int nPos = 0; |
278 | 305 | // Noise counter |
279 | - if (++nPos >= BUFSIZEN) { | |
306 | + if (++nPos >= BUFSIZEN) | |
307 | + { | |
280 | 308 | nPos = 0; |
281 | 309 | } |
282 | 310 | return RandData[nPos]; |
@@ -289,33 +317,50 @@ | ||
289 | 317 | int channel, index; |
290 | 318 | short value, lVol[4], rVol[4]; |
291 | 319 | short LL, RR, vVol; |
292 | - static int wPos = 0; | |
320 | + static int wait = 0; | |
293 | 321 | short *dataAdr; |
294 | 322 | |
323 | + if (WsInputGetNowait()) | |
324 | + { | |
325 | + wait = 1; | |
326 | + } | |
327 | + else if (wait) | |
328 | + { | |
329 | + wait = 0; | |
330 | + apuWaveClear(); | |
331 | + } | |
295 | 332 | apuSweep(); |
296 | - for (channel = 0; channel < 4; channel++) { | |
333 | + for (channel = 0; channel < 4; channel++) | |
334 | + { | |
297 | 335 | lVol[channel] = 0; |
298 | 336 | rVol[channel] = 0; |
299 | - if (Ch[channel].on) { | |
300 | - if (channel == 1 && VoiceOn && Sound[4]) { | |
337 | + if (Ch[channel].on) | |
338 | + { | |
339 | + if (channel == 1 && VoiceOn && Sound[4]) | |
340 | + { | |
301 | 341 | continue; |
302 | 342 | } |
303 | - else if (channel == 2 && Swp.on && !Sound[5]) { | |
343 | + else if (channel == 2 && Swp.on && !Sound[5]) | |
344 | + { | |
304 | 345 | continue; |
305 | 346 | } |
306 | - else if (channel == 3 && Noise.on && Sound[6]){ | |
347 | + else if (channel == 3 && Noise.on && Sound[6]) | |
348 | + { | |
307 | 349 | index = (3072000 / BPSWAV) * point[3] / (2048 - Ch[3].freq); |
308 | - if ((index %= BUFSIZEN) == 0 && preindex[3]) { | |
350 | + if ((index %= BUFSIZEN) == 0 && preindex[3]) | |
351 | + { | |
309 | 352 | point[3] = 0; |
310 | 353 | } |
311 | 354 | value = (short)PDataN[Noise.pattern][index] - 8; |
312 | 355 | } |
313 | - else if (Sound[channel] == 0) { | |
356 | + else if (Sound[channel] == 0) | |
357 | + { | |
314 | 358 | continue; |
315 | 359 | } |
316 | 360 | else { |
317 | 361 | index = (3072000 / BPSWAV) * point[channel] / (2048 - Ch[channel].freq); |
318 | - if ((index %= 32) == 0 && preindex[channel]) { | |
362 | + if ((index %= 32) == 0 && preindex[channel]) | |
363 | + { | |
319 | 364 | point[channel] = 0; |
320 | 365 | } |
321 | 366 | value = (short)PData[channel][index] - 8; |
@@ -333,16 +378,21 @@ | ||
333 | 378 | dataAdr = (short*)(whdr[wBuf]->lpData); |
334 | 379 | dataAdr[wPos * 2] = LL; |
335 | 380 | dataAdr[wPos * 2 + 1] = RR; |
336 | - if (++wPos >= BUFSIZEW) { | |
381 | + if (++wPos >= BUFSIZEW) | |
382 | + { | |
337 | 383 | waveOutWrite(hWaveOut, whdr[wBuf], sizeof(WAVEHDR)); |
338 | 384 | wPos = 0; |
339 | - if (++wBuf >= BUFCOUNT) { | |
385 | + if (++wBuf >= BUFCOUNT) | |
386 | + { | |
340 | 387 | wBuf = 0; |
341 | 388 | } |
342 | - while (wBuf == rBuf) // 書き込みが再生に追いついた | |
343 | - { | |
344 | - Sleep(1); // WaveOutのコールバック関数でrBufが更新されるまで待つ | |
345 | - } | |
389 | + if (wait == 0) | |
390 | + { | |
391 | + while (wBuf == rBuf) // 書き込みが再生に追いついた | |
392 | + { | |
393 | + Sleep(1); // WaveOutのコールバック関数でrBufが更新されるまで待つ | |
394 | + } | |
395 | + } | |
346 | 396 | } |
347 | 397 | } |
348 | 398 |
@@ -319,7 +319,7 @@ | ||
319 | 319 | if(DrawMode != Mode) |
320 | 320 | { |
321 | 321 | DrawMode = Mode; |
322 | - SetKeyMap(Mode); | |
322 | + WsInputSetKeyMap(Mode); | |
323 | 323 | WsResize(); |
324 | 324 | } |
325 | 325 | return 0; |
@@ -200,10 +200,29 @@ | ||
200 | 200 | HRESULT hRet; |
201 | 201 | BYTE diKeys[256]; |
202 | 202 | WORD JoyState = 0; |
203 | - WORD ButtonState = 0; | |
203 | + WORD KeyState = 0; | |
204 | 204 | |
205 | 205 | ZeroMemory(&js, sizeof(DIJOYSTATE2)); |
206 | 206 | ZeroMemory(diKeys, 256); |
207 | + if (lpKeyDevice != NULL) | |
208 | + { | |
209 | + hRet = lpKeyDevice->Acquire(); | |
210 | + if (hRet == DI_OK || hRet == S_FALSE) | |
211 | + { | |
212 | + hRet = lpKeyDevice->GetDeviceState(256, diKeys); | |
213 | + if (hRet == DI_OK) | |
214 | + { | |
215 | + for (i = 0; i < 12; i++) | |
216 | + { | |
217 | + KeyState <<= 1; | |
218 | + if (diKeys[WsKeyboard[i]] & 0x80) | |
219 | + { | |
220 | + KeyState |= 1; | |
221 | + } | |
222 | + } | |
223 | + } | |
224 | + } | |
225 | + } | |
207 | 226 | if (lpJoyDevice != NULL) |
208 | 227 | { |
209 | 228 | hRet = lpJoyDevice->Poll(); |
@@ -210,11 +229,12 @@ | ||
210 | 229 | if (FAILED(hRet)) |
211 | 230 | { |
212 | 231 | hRet = lpJoyDevice->Acquire(); |
213 | - while(hRet == DIERR_INPUTLOST) | |
232 | + while (hRet == DIERR_INPUTLOST) | |
233 | + { | |
214 | 234 | hRet = lpJoyDevice->Acquire(); |
215 | - return 0; | |
235 | + } | |
236 | + return KeyState; | |
216 | 237 | } |
217 | - | |
218 | 238 | hRet = lpJoyDevice->GetDeviceState(sizeof(DIJOYSTATE2), &js); |
219 | 239 | if (hRet == DI_OK){ |
220 | 240 | for (i = 0; i < 12; i++) |
@@ -224,7 +244,32 @@ | ||
224 | 244 | } |
225 | 245 | } |
226 | 246 | } |
247 | + return JoyState | KeyState; | |
248 | +} | |
227 | 249 | |
250 | +void WsInputSetKeyMap(int mode) | |
251 | +{ | |
252 | + if (mode & 1) | |
253 | + { | |
254 | + WsJoypad = WsJoypadV; | |
255 | + WsKeyboard = WsKeyboardV; | |
256 | + } | |
257 | + else | |
258 | + { | |
259 | + WsJoypad = WsJoypadH; | |
260 | + WsKeyboard = WsKeyboardH; | |
261 | + } | |
262 | +} | |
263 | + | |
264 | +int WsInputGetNowait(void) | |
265 | +{ | |
266 | + int i; | |
267 | + HRESULT hRet; | |
268 | + BYTE diKeys[256]; | |
269 | + int flag = 0; | |
270 | + | |
271 | + ZeroMemory(&js, sizeof(DIJOYSTATE2)); | |
272 | + ZeroMemory(diKeys, 256); | |
228 | 273 | if (lpKeyDevice != NULL) |
229 | 274 | { |
230 | 275 | hRet = lpKeyDevice->Acquire(); |
@@ -233,30 +278,29 @@ | ||
233 | 278 | hRet = lpKeyDevice->GetDeviceState(256, diKeys); |
234 | 279 | if (hRet == DI_OK) |
235 | 280 | { |
236 | - for (i = 0; i < 12; i++) | |
281 | + if (diKeys[WsKeyboard[12]] & 0x80) | |
237 | 282 | { |
238 | - ButtonState <<= 1; | |
239 | - if (diKeys[WsKeyboard[i]] & 0x80) | |
240 | - { | |
241 | - ButtonState |= 1; | |
242 | - } | |
283 | + flag = 1; | |
243 | 284 | } |
244 | 285 | } |
245 | 286 | } |
246 | 287 | } |
247 | - return JoyState | ButtonState; | |
248 | -} | |
249 | - | |
250 | -void SetKeyMap(int mode) | |
251 | -{ | |
252 | - if (mode & 1) | |
288 | + if (lpJoyDevice != NULL) | |
253 | 289 | { |
254 | - WsJoypad = WsJoypadV; | |
255 | - WsKeyboard = WsKeyboardV; | |
290 | + hRet = lpJoyDevice->Poll(); | |
291 | + if (FAILED(hRet)) | |
292 | + { | |
293 | + hRet = lpJoyDevice->Acquire(); | |
294 | + while (hRet == DIERR_INPUTLOST) | |
295 | + { | |
296 | + hRet = lpJoyDevice->Acquire(); | |
297 | + } | |
298 | + return flag; | |
299 | + } | |
300 | + hRet = lpJoyDevice->GetDeviceState(sizeof(DIJOYSTATE2), &js); | |
301 | + if (hRet == DI_OK){ | |
302 | + flag = WsInputCheckJoy(WsJoypad[12]); | |
303 | + } | |
256 | 304 | } |
257 | - else | |
258 | - { | |
259 | - WsJoypad = WsJoypadH; | |
260 | - WsKeyboard = WsKeyboardH; | |
261 | - } | |
305 | + return flag; | |
262 | 306 | } |
@@ -57,6 +57,7 @@ | ||
57 | 57 | void WsInputRelease(void); |
58 | 58 | int WsInputCheckJoy(int value); |
59 | 59 | WORD WsInputGetState(void); |
60 | -void SetKeyMap(int mode); | |
60 | +void WsInputSetKeyMap(int mode); | |
61 | +int WsInputGetNowait(void); | |
61 | 62 | |
62 | 63 | #endif |