- The mouse system has been rewritten so that we don't need to do mouse capturing while interacting with GUI widgets, which could be buggy sometimes. - Fixed a bug when exiting from Edit Op. screen #4 ("Sample chord editor") and reopening it. It could mess up the UI in worst case scenarios. - Some other small miscellaneous changes not worth of a mention - Small code cleanup (and also the opposite :-)
Unified · Split
| @@ -53,11 +53,10 @@ typedef struct voice_t · 52 unmodified lines | ||
| 53 | 53 | } paulaVoice_t; |
| 54 | 54 | |
| 55 | 55 | static volatile int8_t filterFlags; |
| 56 | −static volatile bool audioLocked; | |
| 57 | 56 | static int8_t defStereoSep; |
| 58 | 57 | static bool amigaPanFlag, wavRenderingDone; |
| 59 | −static uint16_t ch1Pan, ch2Pan, ch3Pan, ch4Pan, oldPeriod; | |
| 60 | −static int32_t sampleCounter, maxSamplesToMix, randSeed = INITIAL_DITHER_SEED; | |
| 58 | +static uint16_t ch1Pan, ch2Pan, ch3Pan, ch4Pan; | |
| 59 | +static int32_t oldPeriod, sampleCounter, maxSamplesToMix, randSeed = INITIAL_DITHER_SEED; | |
| 61 | 60 | static uint32_t oldScopeDelta; |
| 62 | 61 | static double *dMixBufferL, *dMixBufferR, *dMixBufferLUnaligned, *dMixBufferRUnaligned, dOldVoiceDelta, dOldVoiceDeltaMul; |
| 63 | 62 | static double dPrngStateL, dPrngStateR; |
| @@ -69,7 +68,6 @@ static paulaVoice_t paula[AMIGA_VOICES]; · 5 unmodified lines | ||
| 69 | 68 | static SDL_AudioDeviceID dev; |
| 70 | 69 | |
| 71 | 70 | // globalized |
| 72 | −bool forceMixerOff = false; | |
| 73 | 71 | int32_t samplesPerTick; |
| 74 | 72 | |
| 75 | 73 | bool intMusic(void); // defined in pt_modplayer.c |
| @@ -128,7 +126,8 @@ static void calcCoeffLED(double dSr, double dHz, ledFilterCoeff_t *filter) · 52 unmodified lines | ||
| 128 | 126 | |
| 129 | 127 | #ifndef NO_FILTER_FINETUNING |
| 130 | 128 | /* 8bitbubsy: makes the filter curve sound (and look) much closer to the real deal. |
| 131 | − ** This has been tested against both an A500 and A1200 (real units). */ | |
| 129 | + ** This has been tested against both an A500 and A1200 (real units). | |
| 130 | + */ | |
| 132 | 131 | dFb *= 0.62; |
| 133 | 132 | #endif |
| 134 | 133 | |
| @@ -184,7 +183,8 @@ void lossyIntegrator(lossyIntegrator_t *filter, double *dIn, double *dOut) · 49 unmodified lines | ||
| 184 | 183 | ** This implementation has a less smooth cutoff curve compared to the old one, so it's |
| 185 | 184 | ** maybe not the best. However, I stick to this one because it has a higher gain |
| 186 | 185 | ** at the end of the curve (closer to real tested Amiga 500). It also sounds much closer when |
| 187 | − ** comparing whitenoise on an A500. */ | |
| 186 | + ** comparing whitenoise on an A500. | |
| 187 | + */ | |
| 188 | 188 | |
| 189 | 189 | // left channel low-pass |
| 190 | 190 | filter->dBuffer[0] = (filter->b0 * dIn[0]) + (filter->b1 * filter->dBuffer[0]) + DENORMAL_OFFSET; |
| @@ -224,7 +224,8 @@ void lossyIntegratorHighPassMono(lossyIntegrator_t *filter, double dIn, double * · 33 unmodified lines | ||
| 224 | 224 | ** parameter range and have 'normalized' (1/2 = 0db) coeffs |
| 225 | 225 | ** |
| 226 | 226 | ** the coeffs are for LERP(x, x * x, 0.224) * sqrt(2) |
| 227 | −** max_error is minimized with 0.224 = 0.0013012886 */ | |
| 227 | +** max_error is minimized with 0.224 = 0.0013012886 | |
| 228 | +*/ | |
| 228 | 229 | static double sinApx(double fX) |
| 229 | 230 | { |
| 230 | 231 | fX = fX * (2.0 - fX); |
| @@ -242,7 +243,7 @@ void lockAudio(void) · 11 unmodified lines | ||
| 242 | 243 | if (dev != 0) |
| 243 | 244 | SDL_LockAudioDevice(dev); |
| 244 | 245 | |
| 245 | − audioLocked = true; | |
| 246 | + audio.locked = true; | |
| 246 | 247 | } |
| 247 | 248 | |
| 248 | 249 | void unlockAudio(void) |
| @@ -250,33 +251,7 @@ void unlockAudio(void) · 1 unmodified line | ||
| 250 | 251 | if (dev != 0) |
| 251 | 252 | SDL_UnlockAudioDevice(dev); |
| 252 | 253 | |
| 253 | − audioLocked = false; | |
| 254 | −} | |
| 255 | − | |
| 256 | −void clearPaulaAndScopes(void) | |
| 257 | −{ | |
| 258 | − uint8_t i; | |
| 259 | − double dOldPanL[4], dOldPanR[4]; | |
| 260 | − | |
| 261 | − // copy old pans | |
| 262 | − for (i = 0; i < AMIGA_VOICES; i++) | |
| 263 | − { | |
| 264 | − dOldPanL[i] = paula[i].dPanL; | |
| 265 | − dOldPanR[i] = paula[i].dPanR; | |
| 266 | − } | |
| 267 | − | |
| 268 | − lockAudio(); | |
| 269 | − memset(paula, 0, sizeof (paula)); | |
| 270 | − unlockAudio(); | |
| 271 | − | |
| 272 | − // store old pans | |
| 273 | − for (i = 0; i < AMIGA_VOICES; i++) | |
| 274 | − { | |
| 275 | − paula[i].dPanL = dOldPanL[i]; | |
| 276 | − paula[i].dPanR = dOldPanR[i]; | |
| 277 | − } | |
| 278 | − | |
| 279 | − clearScopes(); | |
| 254 | + audio.locked = false; | |
| 280 | 255 | } |
| 281 | 256 | |
| 282 | 257 | void mixerUpdateLoops(void) // updates Paula loop (+ scopes) |
| @@ -284,14 +259,14 @@ void mixerUpdateLoops(void) // updates Paula loop (+ scopes) · 1 unmodified line | ||
| 284 | 259 | moduleChannel_t *ch; |
| 285 | 260 | moduleSample_t *s; |
| 286 | 261 | |
| 287 | − for (uint8_t i = 0; i < AMIGA_VOICES; i++) | |
| 262 | + for (int32_t i = 0; i < AMIGA_VOICES; i++) | |
| 288 | 263 | { |
| 289 | 264 | ch = &modEntry->channels[i]; |
| 290 | 265 | if (ch->n_samplenum == editor.currSample) |
| 291 | 266 | { |
| 292 | 267 | s = &modEntry->samples[editor.currSample]; |
| 293 | 268 | paulaSetData(i, ch->n_start + s->loopStart); |
| 294 | − paulaSetLength(i, s->loopLength / 2); | |
| 269 | + paulaSetLength(i, s->loopLength >> 1); | |
| 295 | 270 | } |
| 296 | 271 | } |
| 297 | 272 | } |
| @@ -302,7 +277,8 @@ static void mixerSetVoicePan(uint8_t ch, uint16_t pan) // pan = 0..256 · 4 unmodified lines | ||
| 302 | 277 | |
| 303 | 278 | /* proper 'normalized' equal-power panning is (assuming pan left to right): |
| 304 | 279 | ** L = cos(p * pi * 1/2) * sqrt(2); |
| 305 | − ** R = sin(p * pi * 1/2) * sqrt(2); */ | |
| 280 | + ** R = sin(p * pi * 1/2) * sqrt(2); | |
| 281 | + */ | |
| 306 | 282 | dPan = pan * (1.0 / 256.0); // 0.0..1.0 |
| 307 | 283 | |
| 308 | 284 | paula[ch].dPanL = cosApx(dPan); |
| @@ -311,24 +287,34 @@ static void mixerSetVoicePan(uint8_t ch, uint16_t pan) // pan = 0..256 · 2 unmodified lines | ||
| 311 | 287 | |
| 312 | 288 | void mixerKillVoice(uint8_t ch) |
| 313 | 289 | { |
| 314 | − paulaVoice_t *v; | |
| 315 | − scopeChannelExt_t *s; | |
| 290 | + const bool wasLocked = audio.locked; | |
| 291 | + if (!wasLocked) | |
| 292 | + lockAudio(); | |
| 316 | 293 | |
| 317 | − v = &paula[ch]; | |
| 318 | − s = &scopeExt[ch]; | |
| 294 | + // copy old pans | |
| 295 | + const double dOldPanL = paula[ch].dPanL; | |
| 296 | + const double dOldPanR = paula[ch].dPanR; | |
| 319 | 297 | |
| 320 | − v->active = false; | |
| 321 | − v->dVolume = 0.0; | |
| 298 | + memset(&paula[ch], 0, sizeof (paulaVoice_t)); | |
| 299 | + stopScope(ch); | |
| 322 | 300 | |
| 323 | − s->active = false; | |
| 324 | − s->didSwapData = false; | |
| 301 | + // store old pans | |
| 302 | + paula[ch].dPanL = dOldPanL; | |
| 303 | + paula[ch].dPanR = dOldPanR; | |
| 325 | 304 | |
| 326 | 305 | memset(&blep[ch], 0, sizeof (blep_t)); |
| 327 | 306 | memset(&blepVol[ch], 0, sizeof (blep_t)); |
| 307 | + | |
| 308 | + if (!wasLocked) | |
| 309 | + unlockAudio(); | |
| 328 | 310 | } |
| 329 | 311 | |
| 330 | 312 | void turnOffVoices(void) |
| 331 | 313 | { |
| 314 | + const bool wasLocked = audio.locked; | |
| 315 | + if (!wasLocked) | |
| 316 | + lockAudio(); | |
| 317 | + | |
| 332 | 318 | for (uint8_t i = 0; i < AMIGA_VOICES; i++) |
| 333 | 319 | mixerKillVoice(i); |
| 334 | 320 | |
| @@ -339,121 +325,59 @@ void turnOffVoices(void) · 4 unmodified lines | ||
| 339 | 325 | resetAudioDithering(); |
| 340 | 326 | |
| 341 | 327 | editor.tuningFlag = false; |
| 342 | −} | |
| 343 | 328 | |
| 344 | −void paulaStopDMA(uint8_t ch) | |
| 345 | −{ | |
| 346 | − scopeExt[ch].active = paula[ch].active = false; | |
| 347 | −} | |
| 348 | − | |
| 349 | −void paulaStartDMA(uint8_t ch) | |
| 350 | −{ | |
| 351 | − const int8_t *dat; | |
| 352 | − int32_t length; | |
| 353 | − paulaVoice_t *v; | |
| 354 | − scopeChannel_t s, *sc; | |
| 355 | − scopeChannelExt_t *se; | |
| 356 | − | |
| 357 | − // trigger voice | |
| 358 | − | |
| 359 | − v = &paula[ch]; | |
| 360 | − | |
| 361 | − dat = v->newData; | |
| 362 | − if (dat == NULL) | |
| 363 | − dat = &modEntry->sampleData[RESERVED_SAMPLE_OFFSET]; // dummy sample | |
| 364 | − | |
| 365 | − length = v->newLength; | |
| 366 | − if (length < 2) | |
| 367 | − length = 2; // for safety | |
| 368 | − | |
| 369 | − v->dPhase = 0.0; | |
| 370 | − v->pos = 0; | |
| 371 | − v->data = dat; | |
| 372 | − v->length = length; | |
| 373 | − v->active = true; | |
| 374 | − | |
| 375 | − // trigger scope | |
| 376 | − | |
| 377 | − sc = &scope[ch]; | |
| 378 | − se = &scopeExt[ch]; | |
| 379 | − s = *sc; // cache it | |
| 380 | − | |
| 381 | − dat = se->newData; | |
| 382 | − if (dat == NULL) | |
| 383 | − dat = &modEntry->sampleData[RESERVED_SAMPLE_OFFSET]; // dummy sample | |
| 384 | − | |
| 385 | − s.length = length; | |
| 386 | − s.data = dat; | |
| 387 | − | |
| 388 | − s.pos = 0; | |
| 389 | − s.posFrac = 0; | |
| 390 | − | |
| 391 | − // data/length is already set from replayer thread (important) | |
| 392 | − s.loopFlag = se->newLoopFlag; | |
| 393 | − s.loopStart = se->newLoopStart; | |
| 394 | − | |
| 395 | − se->didSwapData = false; | |
| 396 | − se->active = true; | |
| 397 | − | |
| 398 | − *sc = s; // update it | |
| 329 | + if (!wasLocked) | |
| 330 | + unlockAudio(); | |
| 399 | 331 | } |
| 400 | 332 | |
| 401 | 333 | void resetCachedMixerPeriod(void) |
| 402 | 334 | { |
| 403 | − oldPeriod = 0; | |
| 335 | + oldPeriod = 0xFFFFFFFF; | |
| 404 | 336 | } |
| 405 | 337 | |
| 338 | +// the following routines are only called from the mixer thread. | |
| 339 | + | |
| 406 | 340 | void paulaSetPeriod(uint8_t ch, uint16_t period) |
| 407 | 341 | { |
| 342 | + int32_t realPeriod; | |
| 408 | 343 | double dPeriodToDeltaDiv; |
| 409 | 344 | paulaVoice_t *v; |
| 410 | 345 | |
| 411 | 346 | v = &paula[ch]; |
| 412 | 347 | |
| 413 | 348 | if (period == 0) |
| 414 | − { | |
| 415 | − v->dDelta = 0.0; // confirmed behavior on real Amiga | |
| 416 | − v->dDeltaMul = 1.0; // for BLEP synthesis | |
| 417 | − setScopeDelta(ch, 0); | |
| 418 | − return; | |
| 419 | − } | |
| 420 | − | |
| 421 | − if (period < 113) | |
| 422 | − period = 113; // confirmed behavior on real Amiga | |
| 349 | + realPeriod = 65536; // confirmed behavior on real Amiga | |
| 350 | + else if (period < 113) | |
| 351 | + realPeriod = 113; // confirmed behavior on real Amiga | |
| 352 | + else | |
| 353 | + realPeriod = period; | |
| 423 | 354 | |
| 424 | 355 | // if the new period was the same as the previous period, use cached deltas |
| 425 | − if (period == oldPeriod) | |
| 426 | − { | |
| 427 | − v->dDelta = dOldVoiceDelta; | |
| 428 | − v->dDeltaMul = dOldVoiceDeltaMul; // for BLEP synthesis | |
| 429 | − setScopeDelta(ch, oldScopeDelta); | |
| 430 | − } | |
| 431 | − else | |
| 356 | + if (realPeriod != oldPeriod) | |
| 432 | 357 | { |
| 358 | + oldPeriod = realPeriod; | |
| 359 | + | |
| 433 | 360 | // this period is not cached, calculate mixer/scope deltas |
| 434 | 361 | |
| 435 | 362 | #if SCOPE_HZ != 64 |
| 436 | 363 | #error Scope Hz is not 64 (2^n), change rate calc. to use doubles+round in pt2_scope.c |
| 437 | 364 | #endif |
| 438 | − oldPeriod = period; | |
| 439 | − | |
| 440 | 365 | // if we are rendering pattern to sample (PAT2SMP), use different frequencies |
| 441 | 366 | if (editor.isSMPRendering) |
| 442 | 367 | dPeriodToDeltaDiv = editor.pat2SmpHQ ? (PAULA_PAL_CLK / 28836.0) : (PAULA_PAL_CLK / 22168.0); |
| 443 | 368 | else |
| 444 | 369 | dPeriodToDeltaDiv = audio.dPeriodToDeltaDiv; |
| 445 | 370 | |
| 446 | − v->dDelta = dPeriodToDeltaDiv / period; | |
| 447 | − v->dDeltaMul = 1.0 / v->dDelta; // for BLEP synthesis | |
| 448 | − | |
| 449 | 371 | // cache these |
| 450 | − dOldVoiceDelta = v->dDelta; | |
| 451 | − dOldVoiceDeltaMul = v->dDeltaMul; // for BLEP synthesis | |
| 452 | − oldScopeDelta = (PAULA_PAL_CLK * (65536UL / SCOPE_HZ)) / period; | |
| 453 | − | |
| 454 | − setScopeDelta(ch, oldScopeDelta); | |
| 372 | + dOldVoiceDelta = dPeriodToDeltaDiv / realPeriod; | |
| 373 | + dOldVoiceDeltaMul = 1.0 / dOldVoiceDelta; // for BLEP synthesis | |
| 374 | + oldScopeDelta = (PAULA_PAL_CLK * (65536UL / SCOPE_HZ)) / realPeriod; | |
| 455 | 375 | } |
| 456 | 376 | |
| 377 | + v->dDelta = dOldVoiceDelta; | |
| 378 | + v->dDeltaMul = dOldVoiceDeltaMul; // for BLEP synthesis | |
| 379 | + setScopeDelta(ch, oldScopeDelta); | |
| 380 | + | |
| 457 | 381 | // for BLEP synthesis |
| 458 | 382 | |
| 459 | 383 | if (v->dLastDelta == 0.0) |
| @@ -478,13 +402,13 @@ void paulaSetLength(uint8_t ch, uint16_t len) · 18 unmodified lines | ||
| 478 | 402 | if (len == 0) |
| 479 | 403 | { |
| 480 | 404 | len = 65535; |
| 481 | − /* confirmed behavior on real Amiga (also needed for safety) | |
| 405 | + /* Confirmed behavior on real Amiga (also needed for safety). | |
| 482 | 406 | ** And yes, we have room for this, it will never overflow! |
| 483 | 407 | */ |
| 484 | 408 | } |
| 485 | 409 | |
| 486 | 410 | // our mixer works with bytes, not words. Multiply by two |
| 487 | − scopeExt[ch].newLength = paula[ch].newLength = len * 2; | |
| 411 | + scopeExt[ch].newLength = paula[ch].newLength = len << 1; | |
| 488 | 412 | } |
| 489 | 413 | |
| 490 | 414 | void paulaSetData(uint8_t ch, const int8_t *src) |
| @@ -514,25 +438,86 @@ void paulaSetData(uint8_t ch, const int8_t *src) · 23 unmodified lines | ||
| 514 | 438 | *se = tmp; // update it |
| 515 | 439 | } |
| 516 | 440 | |
| 441 | +void paulaStopDMA(uint8_t ch) | |
| 442 | +{ | |
| 443 | + scopeExt[ch].active = paula[ch].active = false; | |
| 444 | +} | |
| 445 | + | |
| 446 | +void paulaStartDMA(uint8_t ch) | |
| 447 | +{ | |
| 448 | + const int8_t *dat; | |
| 449 | + int32_t length; | |
| 450 | + paulaVoice_t *v; | |
| 451 | + scopeChannel_t s, *sc; | |
| 452 | + scopeChannelExt_t *se; | |
| 453 | + | |
| 454 | + // trigger voice | |
| 455 | + | |
| 456 | + v = &paula[ch]; | |
| 457 | + | |
| 458 | + dat = v->newData; | |
| 459 | + if (dat == NULL) | |
| 460 | + dat = &modEntry->sampleData[RESERVED_SAMPLE_OFFSET]; // dummy sample | |
| 461 | + | |
| 462 | + length = v->newLength; | |
| 463 | + if (length < 2) | |
| 464 | + length = 2; // for safety | |
| 465 | + | |
| 466 | + v->dPhase = 0.0; | |
| 467 | + v->pos = 0; | |
| 468 | + v->data = dat; | |
| 469 | + v->length = length; | |
| 470 | + v->active = true; | |
| 471 | + | |
| 472 | + // trigger scope | |
| 473 | + | |
| 474 | + sc = &scope[ch]; | |
| 475 | + se = &scopeExt[ch]; | |
| 476 | + s = *sc; // cache it | |
| 477 | + | |
| 478 | + dat = se->newData; | |
| 479 | + if (dat == NULL) | |
| 480 | + dat = &modEntry->sampleData[RESERVED_SAMPLE_OFFSET]; // dummy sample | |
| 481 | + | |
| 482 | + s.length = length; | |
| 483 | + s.data = dat; | |
| 484 | + | |
| 485 | + s.pos = 0; | |
| 486 | + s.posFrac = 0; | |
| 487 | + | |
| 488 | + // data/length is already set from replayer thread (important) | |
| 489 | + s.loopFlag = se->newLoopFlag; | |
| 490 | + s.loopStart = se->newLoopStart; | |
| 491 | + | |
| 492 | + se->didSwapData = false; | |
| 493 | + se->active = true; | |
| 494 | + | |
| 495 | + *sc = s; // update it | |
| 496 | +} | |
| 497 | + | |
| 517 | 498 | void toggleA500Filters(void) |
| 518 | 499 | { |
| 500 | + lockAudio(); | |
| 501 | + clearLossyIntegrator(&filterLo); | |
| 502 | + clearLossyIntegrator(&filterHi); | |
| 503 | + clearLEDFilter(&filterLED); | |
| 504 | + unlockAudio(); | |
| 505 | + | |
| 519 | 506 | if (filterFlags & FILTER_A500) |
| 520 | 507 | { |
| 521 | 508 | filterFlags &= ~FILTER_A500; |
| 522 | − displayMsg("FILTER MOD: A1200"); | |
| 509 | + displayMsg("LP FILTER: A1200"); | |
| 523 | 510 | } |
| 524 | 511 | else |
| 525 | 512 | { |
| 526 | 513 | filterFlags |= FILTER_A500; |
| 527 | − clearLossyIntegrator(&filterLo); | |
| 528 | − displayMsg("FILTER MOD: A500"); | |
| 514 | + displayMsg("LP FILTER: A500"); | |
| 529 | 515 | } |
| 530 | 516 | } |
| 531 | 517 | |
| 532 | 518 | void mixChannels(int32_t numSamples) |
| 533 | 519 | { |
| 534 | − const int8_t *dataPtr; | |
| 535 | − double dTempSample, dTempVolume; | |
| 520 | + double dSmp, dVol; | |
| 536 | 521 | blep_t *bSmp, *bVol; |
| 537 | 522 | paulaVoice_t *v; |
| 538 | 523 | |
| @@ -542,7 +527,7 @@ void mixChannels(int32_t numSamples) · 3 unmodified lines | ||
| 542 | 527 | for (int32_t i = 0; i < AMIGA_VOICES; i++) |
| 543 | 528 | { |
| 544 | 529 | v = &paula[i]; |
| 545 | − if (!v->active) | |
| 530 | + if (!v->active || v->data == NULL) | |
| 546 | 531 | continue; |
| 547 | 532 | |
| 548 | 533 | bSmp = &blep[i]; |
| @@ -550,47 +535,108 @@ void mixChannels(int32_t numSamples) · 1 unmodified line | ||
| 550 | 535 | |
| 551 | 536 | for (int32_t j = 0; j < numSamples; j++) |
| 552 | 537 | { |
| 553 | − dataPtr = v->data; | |
| 554 | − if (dataPtr == NULL) | |
| 538 | + assert(v->data != NULL); | |
| 539 | + dSmp = v->data[v->pos] * (1.0 / 128.0); | |
| 540 | + dVol = v->dVolume; | |
| 541 | + | |
| 542 | + if (dSmp != bSmp->dLastValue) | |
| 555 | 543 | { |
| 556 | − dTempSample = 0.0; | |
| 557 | − dTempVolume = 0.0; | |
| 544 | + if (v->dLastDelta > v->dLastPhase) | |
| 545 | + { | |
| 546 | + // div->mul trick: v->dLastDeltaMul is 1.0 / v->dLastDelta | |
| 547 | + blepAdd(bSmp, v->dLastPhase * v->dLastDeltaMul, bSmp->dLastValue - dSmp); | |
| 548 | + } | |
| 549 | + | |
| 550 | + bSmp->dLastValue = dSmp; | |
| 558 | 551 | } |
| 559 | − else | |
| 552 | + | |
| 553 | + if (dVol != bVol->dLastValue) | |
| 560 | 554 | { |
| 561 | − dTempSample = dataPtr[v->pos] * (1.0 / 128.0); | |
| 562 | − dTempVolume = v->dVolume; | |
| 555 | + blepVolAdd(bVol, bVol->dLastValue - dVol); | |
| 556 | + bVol->dLastValue = dVol; | |
| 563 | 557 | } |
| 564 | 558 | |
| 565 | − if (dTempSample != bSmp->dLastValue) | |
| 559 | + if (bSmp->samplesLeft > 0) dSmp += blepRun(bSmp); | |
| 560 | + if (bVol->samplesLeft > 0) dVol += blepRun(bVol); | |
| 561 | + | |
| 562 | + dSmp *= dVol; | |
| 563 | + | |
| 564 | + dMixBufferL[j] += dSmp * v->dPanL; | |
| 565 | + dMixBufferR[j] += dSmp * v->dPanR; | |
| 566 | + | |
| 567 | + v->dPhase += v->dDelta; | |
| 568 | + if (v->dPhase >= 1.0) | |
| 569 | + { | |
| 570 | + v->dPhase -= 1.0; | |
| 571 | + | |
| 572 | + v->dLastPhase = v->dPhase; | |
| 573 | + v->dLastDelta = v->dDelta; | |
| 574 | + v->dLastDeltaMul = v->dDeltaMul; | |
| 575 | + | |
| 576 | + if (++v->pos >= v->length) | |
| 577 | + { | |
| 578 | + v->pos = 0; | |
| 579 | + | |
| 580 | + // re-fetch new Paula register values now | |
| 581 | + v->length = v->newLength; | |
| 582 | + v->data = v->newData; | |
| 583 | + } | |
| 584 | + } | |
| 585 | + } | |
| 586 | + } | |
| 587 | +} | |
| 588 | + | |
| 589 | +void mixChannelsMultiStep(int32_t numSamples) // for PAT2SMP | |
| 590 | +{ | |
| 591 | + double dSmp, dVol; | |
| 592 | + blep_t *bSmp, *bVol; | |
| 593 | + paulaVoice_t *v; | |
| 594 | + | |
| 595 | + memset(dMixBufferL, 0, numSamples * sizeof (double)); | |
| 596 | + memset(dMixBufferR, 0, numSamples * sizeof (double)); | |
| 597 | + | |
| 598 | + for (int32_t i = 0; i < AMIGA_VOICES; i++) | |
| 599 | + { | |
| 600 | + v = &paula[i]; | |
| 601 | + if (!v->active || v->data == NULL) | |
| 602 | + continue; | |
| 603 | + | |
| 604 | + bSmp = &blep[i]; | |
| 605 | + bVol = &blepVol[i]; | |
| 606 | + | |
| 607 | + for (int32_t j = 0; j < numSamples; j++) | |
| 608 | + { | |
| 609 | + assert(v->data != NULL); | |
| 610 | + dSmp = v->data[v->pos] * (1.0 / 128.0); | |
| 611 | + dVol = v->dVolume; | |
| 612 | + | |
| 613 | + if (dSmp != bSmp->dLastValue) | |
| 566 | 614 | { |
| 567 | 615 | if (v->dLastDelta > v->dLastPhase) |
| 568 | 616 | { |
| 569 | 617 | // div->mul trick: v->dLastDeltaMul is 1.0 / v->dLastDelta |
| 570 | − blepAdd(bSmp, v->dLastPhase * v->dLastDeltaMul, bSmp->dLastValue - dTempSample); | |
| 618 | + blepAdd(bSmp, v->dLastPhase * v->dLastDeltaMul, bSmp->dLastValue - dSmp); | |
| 571 | 619 | } |
| 572 | 620 | |
| 573 | − bSmp->dLastValue = dTempSample; | |
| 621 | + bSmp->dLastValue = dSmp; | |
| 574 | 622 | } |
| 575 | 623 | |
| 576 | − if (dTempVolume != bVol->dLastValue) | |
| 624 | + if (dVol != bVol->dLastValue) | |
| 577 | 625 | { |
| 578 | − blepVolAdd(bVol, bVol->dLastValue - dTempVolume); | |
| 579 | − bVol->dLastValue = dTempVolume; | |
| 626 | + blepVolAdd(bVol, bVol->dLastValue - dVol); | |
| 627 | + bVol->dLastValue = dVol; | |
| 580 | 628 | } |
| 581 | 629 | |
| 582 | − if (bSmp->samplesLeft > 0) dTempSample += blepRun(bSmp); | |
| 583 | − if (bVol->samplesLeft > 0) dTempVolume += blepRun(bVol); | |
| 630 | + if (bSmp->samplesLeft > 0) dSmp += blepRun(bSmp); | |
| 631 | + if (bVol->samplesLeft > 0) dVol += blepRun(bVol); | |
| 584 | 632 | |
| 585 | − dTempSample *= dTempVolume; | |
| 633 | + dSmp *= dVol; | |
| 586 | 634 | |
| 587 | − dMixBufferL[j] += dTempSample * v->dPanL; | |
| 588 | − dMixBufferR[j] += dTempSample * v->dPanR; | |
| 635 | + dMixBufferL[j] += dSmp * v->dPanL; | |
| 636 | + dMixBufferR[j] += dSmp * v->dPanR; | |
| 589 | 637 | |
| 590 | 638 | v->dPhase += v->dDelta; |
| 591 | − | |
| 592 | − // PAT2SMP needs multi-step, so use while() here (will be only one iteration in normal mixing mode) | |
| 593 | − while (v->dPhase >= 1.0) | |
| 639 | + while (v->dPhase >= 1.0) // multi-step | |
| 594 | 640 | { |
| 595 | 641 | v->dPhase -= 1.0; |
| 596 | 642 | |
| @@ -636,9 +682,42 @@ static inline void processMixedSamplesA1200(int32_t i, int16_t *out) · 39 unmodified lines | ||
| 636 | 682 | |
| 637 | 683 | // don't process any low-pass filter since the cut-off is around 28-31kHz on A1200 |
| 638 | 684 | |
| 685 | + // process high-pass filter | |
| 686 | + lossyIntegratorHighPass(&filterHi, dOut, dOut); | |
| 687 | + | |
| 688 | + // normalize and flip phase (A500/A1200 has an inverted audio signal) | |
| 689 | + dOut[0] *= -(INT16_MAX / AMIGA_VOICES); | |
| 690 | + dOut[1] *= -(INT16_MAX / AMIGA_VOICES); | |
| 691 | + | |
| 692 | + // left channel - 1-bit triangular dithering (high-pass filtered) | |
| 693 | + dPrng = random32() * (0.5 / INT32_MAX); // -0.5..0.5 | |
| 694 | + dOut[0] = (dOut[0] + dPrng) - dPrngStateL; | |
| 695 | + dPrngStateL = dPrng; | |
| 696 | + smp32 = (int32_t)dOut[0]; | |
| 697 | + CLAMP16(smp32); | |
| 698 | + out[0] = (int16_t)smp32; | |
| 699 | + | |
| 700 | + // right channel - 1-bit triangular dithering (high-pass filtered) | |
| 701 | + dPrng = random32() * (0.5 / INT32_MAX); // -0.5..0.5 | |
| 702 | + dOut[1] = (dOut[1] + dPrng) - dPrngStateR; | |
| 703 | + dPrngStateR = dPrng; | |
| 704 | + smp32 = (int32_t)dOut[1]; | |
| 705 | + CLAMP16(smp32); | |
| 706 | + out[1] = (int16_t)smp32; | |
| 707 | +} | |
| 708 | + | |
| 709 | +static inline void processMixedSamplesA1200LED(int32_t i, int16_t *out) | |
| 710 | +{ | |
| 711 | + int32_t smp32; | |
| 712 | + double dOut[2], dPrng; | |
| 713 | + | |
| 714 | + dOut[0] = dMixBufferL[i]; | |
| 715 | + dOut[1] = dMixBufferR[i]; | |
| 716 | + | |
| 717 | + // don't process any low-pass filter since the cut-off is around 28-31kHz on A1200 | |
| 718 | + | |
| 639 | 719 | // process "LED" filter |
| 640 | − if (filterFlags & FILTER_LED_ENABLED) | |
| 641 | − lossyIntegratorLED(filterLEDC, &filterLED, dOut, dOut); | |
| 720 | + lossyIntegratorLED(filterLEDC, &filterLED, dOut, dOut); | |
| 642 | 721 | |
| 643 | 722 | // process high-pass filter |
| 644 | 723 | lossyIntegratorHighPass(&filterHi, dOut, dOut); |
| @@ -702,17 +781,54 @@ static inline void processMixedSamplesA500(int32_t i, int16_t *out) · 57 unmodified lines | ||
| 702 | 781 | out[1] = (int16_t)smp32; |
| 703 | 782 | } |
| 704 | 783 | |
| 784 | +static inline void processMixedSamplesA500LED(int32_t i, int16_t *out) | |
| 785 | +{ | |
| 786 | + int32_t smp32; | |
| 787 | + double dOut[2], dPrng; | |
| 788 | + | |
| 789 | + dOut[0] = dMixBufferL[i]; | |
| 790 | + dOut[1] = dMixBufferR[i]; | |
| 791 | + | |
| 792 | + // process low-pass filter | |
| 793 | + lossyIntegrator(&filterLo, dOut, dOut); | |
| 794 | + | |
| 795 | + // process "LED" filter | |
| 796 | + lossyIntegratorLED(filterLEDC, &filterLED, dOut, dOut); | |
| 797 | + | |
| 798 | + // process high-pass filter | |
| 799 | + lossyIntegratorHighPass(&filterHi, dOut, dOut); | |
| 800 | + | |
| 801 | + dOut[0] *= -(INT16_MAX / AMIGA_VOICES); | |
| 802 | + dOut[1] *= -(INT16_MAX / AMIGA_VOICES); | |
| 803 | + | |
| 804 | + // left channel - 1-bit triangular dithering (high-pass filtered) | |
| 805 | + dPrng = random32() * (0.5 / INT32_MAX); // -0.5..0.5 | |
| 806 | + dOut[0] = (dOut[0] + dPrng) - dPrngStateL; | |
| 807 | + dPrngStateL = dPrng; | |
| 808 | + smp32 = (int32_t)dOut[0]; | |
| 809 | + CLAMP16(smp32); | |
| 810 | + out[0] = (int16_t)smp32; | |
| 811 | + | |
| 812 | + // right channel - 1-bit triangular dithering (high-pass filtered) | |
| 813 | + dPrng = random32() * (0.5 / INT32_MAX); // -0.5..0.5 | |
| 814 | + dOut[1] = (dOut[1] + dPrng) - dPrngStateR; | |
| 815 | + dPrngStateR = dPrng; | |
| 816 | + smp32 = (int32_t)dOut[1]; | |
| 817 | + CLAMP16(smp32); | |
| 818 | + out[1] = (int16_t)smp32; | |
| 819 | +} | |
| 820 | + | |
| 705 | 821 | void outputAudio(int16_t *target, int32_t numSamples) |
| 706 | 822 | { |
| 707 | 823 | int16_t *outStream, out[2]; |
| 708 | 824 | int32_t j; |
| 709 | 825 | |
| 710 | − mixChannels(numSamples); | |
| 711 | − | |
| 712 | 826 | if (editor.isSMPRendering) |
| 713 | 827 | { |
| 714 | 828 | // render to sample (PAT2SMP) |
| 715 | 829 | |
| 830 | + mixChannelsMultiStep(numSamples); | |
| 831 | + | |
| 716 | 832 | for (j = 0; j < numSamples; j++) |
| 717 | 833 | { |
| 718 | 834 | processMixedSamplesA1200(j, out); |
| @@ -730,23 +846,53 @@ void outputAudio(int16_t *target, int32_t numSamples) · 11 unmodified lines | ||
| 730 | 846 | { |
| 731 | 847 | // render to stream |
| 732 | 848 | |
| 849 | + mixChannels(numSamples); | |
| 850 | + | |
| 733 | 851 | outStream = target; |
| 734 | 852 | if (filterFlags & FILTER_A500) |
| 735 | 853 | { |
| 736 | − for (j = 0; j < numSamples; j++) | |
| 854 | + // Amiga 500 filter model | |
| 855 | + | |
| 856 | + if (filterFlags & FILTER_LED_ENABLED) | |
| 737 | 857 | { |
| 738 | − processMixedSamplesA500(j, out); | |
| 739 | − *outStream++ = out[0]; | |
| 740 | − *outStream++ = out[1]; | |
| 858 | + for (j = 0; j < numSamples; j++) | |
| 859 | + { | |
| 860 | + processMixedSamplesA500LED(j, out); | |
| 861 | + *outStream++ = out[0]; | |
| 862 | + *outStream++ = out[1]; | |
| 863 | + } | |
| 864 | + } | |
| 865 | + else | |
| 866 | + { | |
| 867 | + for (j = 0; j < numSamples; j++) | |
| 868 | + { | |
| 869 | + processMixedSamplesA500(j, out); | |
| 870 | + *outStream++ = out[0]; | |
| 871 | + *outStream++ = out[1]; | |
| 872 | + } | |
| 741 | 873 | } |
| 742 | 874 | } |
| 743 | 875 | else |
| 744 | 876 | { |
| 745 | − for (j = 0; j < numSamples; j++) | |
| 877 | + // Amiga 1200 filter model | |
| 878 | + | |
| 879 | + if (filterFlags & FILTER_LED_ENABLED) | |
| 746 | 880 | { |
| 747 | − processMixedSamplesA1200(j, out); | |
| 748 | − *outStream++ = out[0]; | |
| 749 | − *outStream++ = out[1]; | |
| 881 | + for (j = 0; j < numSamples; j++) | |
| 882 | + { | |
| 883 | + processMixedSamplesA1200LED(j, out); | |
| 884 | + *outStream++ = out[0]; | |
| 885 | + *outStream++ = out[1]; | |
| 886 | + } | |
| 887 | + } | |
| 888 | + else | |
| 889 | + { | |
| 890 | + for (j = 0; j < numSamples; j++) | |
| 891 | + { | |
| 892 | + processMixedSamplesA1200(j, out); | |
| 893 | + *outStream++ = out[0]; | |
| 894 | + *outStream++ = out[1]; | |
| 895 | + } | |
| 750 | 896 | } |
| 751 | 897 | } |
| 752 | 898 | } |
| @@ -759,7 +905,7 @@ static void SDLCALL audioCallback(void *userdata, Uint8 *stream, int len) · 6 unmodified lines | ||
| 759 | 905 | |
| 760 | 906 | (void)userdata; |
| 761 | 907 | |
| 762 | − if (forceMixerOff) // during MOD2WAV | |
| 908 | + if (audio.forceMixerOff) // during MOD2WAV | |
| 763 | 909 | { |
| 764 | 910 | memset(stream, 0, len); |
| 765 | 911 | return; |
| @@ -878,12 +1024,12 @@ bool setupAudio(void) · 112 unmodified lines | ||
| 878 | 1024 | { |
| 879 | 1025 | SDL_AudioSpec want, have; |
| 880 | 1026 | |
| 881 | − want.freq = ptConfig.soundFrequency; | |
| 1027 | + want.freq = config.soundFrequency; | |
| 882 | 1028 | want.format = AUDIO_S16; |
| 883 | 1029 | want.channels = 2; |
| 884 | 1030 | want.callback = audioCallback; |
| 885 | 1031 | want.userdata = NULL; |
| 886 | − want.samples = ptConfig.soundBufferSize; | |
| 1032 | + want.samples = config.soundBufferSize; | |
| 887 | 1033 | |
| 888 | 1034 | dev = SDL_OpenAudioDevice(NULL, 0, &want, &have, 0); |
| 889 | 1035 | if (dev == 0) |
| @@ -921,15 +1067,15 @@ bool setupAudio(void) · 31 unmodified lines | ||
| 921 | 1067 | dMixBufferR = (double *)ALIGN_PTR(dMixBufferRUnaligned, 256); |
| 922 | 1068 | |
| 923 | 1069 | audio.audioBufferSize = have.samples; |
| 924 | − ptConfig.soundFrequency = have.freq; | |
| 925 | − audio.audioFreq = ptConfig.soundFrequency; | |
| 926 | − audio.dAudioFreq = (double)ptConfig.soundFrequency; | |
| 1070 | + config.soundFrequency = have.freq; | |
| 1071 | + audio.audioFreq = config.soundFrequency; | |
| 1072 | + audio.dAudioFreq = (double)config.soundFrequency; | |
| 927 | 1073 | audio.dPeriodToDeltaDiv = PAULA_PAL_CLK / audio.dAudioFreq; |
| 928 | 1074 | |
| 929 | − mixerCalcVoicePans(ptConfig.stereoSeparation); | |
| 930 | − defStereoSep = ptConfig.stereoSeparation; | |
| 1075 | + mixerCalcVoicePans(config.stereoSeparation); | |
| 1076 | + defStereoSep = config.stereoSeparation; | |
| 931 | 1077 | |
| 932 | − filterFlags = ptConfig.a500LowPassFilter ? FILTER_A500 : 0; | |
| 1078 | + filterFlags = config.a500LowPassFilter ? FILTER_A500 : 0; | |
| 933 | 1079 | |
| 934 | 1080 | calculateFilterCoeffs(); |
| 935 | 1081 | generateBpmTables(); |
| @@ -37,7 +37,6 @@ void paulaSetLength(uint8_t ch, uint16_t len); · 36 unmodified lines | ||
| 37 | 37 | void paulaSetData(uint8_t ch, const int8_t *src); |
| 38 | 38 | void lockAudio(void); |
| 39 | 39 | void unlockAudio(void); |
| 40 | −void clearPaulaAndScopes(void); | |
| 41 | 40 | void mixerUpdateLoops(void); |
| 42 | 41 | void mixerKillVoice(uint8_t ch); |
| 43 | 42 | void turnOffVoices(void); |
| @@ -41,26 +41,26 @@ void loadConfig(void) · 40 unmodified lines | ||
| 41 | 41 | FILE *f; |
| 42 | 42 | |
| 43 | 43 | // set default config values first |
| 44 | − ptConfig.fullScreenStretch = false; | |
| 45 | − ptConfig.pattDots = false; | |
| 46 | − ptConfig.dottedCenterFlag = true; | |
| 47 | − ptConfig.a500LowPassFilter = false; | |
| 48 | − ptConfig.soundFrequency = 48000; | |
| 49 | − ptConfig.rememberPlayMode = false; | |
| 50 | − ptConfig.stereoSeparation = 20; | |
| 51 | − ptConfig.videoScaleFactor = 2; | |
| 52 | − ptConfig.realVuMeters = false; | |
| 53 | − ptConfig.modDot = false; | |
| 54 | − ptConfig.accidental = 0; // sharp | |
| 55 | − ptConfig.quantizeValue = 1; | |
| 56 | − ptConfig.transDel = false; | |
| 57 | − ptConfig.blankZeroFlag = false; | |
| 58 | − ptConfig.compoMode = false; | |
| 59 | − ptConfig.soundBufferSize = 1024; | |
| 60 | − ptConfig.autoCloseDiskOp = true; | |
| 61 | − ptConfig.vsyncOff = false; | |
| 62 | − ptConfig.hwMouse = false; | |
| 63 | − ptConfig.sampleLowpass = true; | |
| 44 | + config.fullScreenStretch = false; | |
| 45 | + config.pattDots = false; | |
| 46 | + config.dottedCenterFlag = true; | |
| 47 | + config.a500LowPassFilter = false; | |
| 48 | + config.soundFrequency = 48000; | |
| 49 | + config.rememberPlayMode = false; | |
| 50 | + config.stereoSeparation = 20; | |
| 51 | + config.videoScaleFactor = 2; | |
| 52 | + config.realVuMeters = false; | |
| 53 | + config.modDot = false; | |
| 54 | + config.accidental = 0; // sharp | |
| 55 | + config.quantizeValue = 1; | |
| 56 | + config.transDel = false; | |
| 57 | + config.blankZeroFlag = false; | |
| 58 | + config.compoMode = false; | |
| 59 | + config.soundBufferSize = 1024; | |
| 60 | + config.autoCloseDiskOp = true; | |
| 61 | + config.vsyncOff = false; | |
| 62 | + config.hwMouse = false; | |
| 63 | + config.sampleLowpass = true; | |
| 64 | 64 | |
| 65 | 65 | #ifndef _WIN32 |
| 66 | 66 | getcwd(oldCwd, PATH_MAX); |
| @@ -191,127 +191,127 @@ static bool loadProTrackerDotIni(FILE *f) · 124 unmodified lines | ||
| 191 | 191 | // HWMOUSE |
| 192 | 192 | else if (!_strnicmp(configLine, "HWMOUSE=", 8)) |
| 193 | 193 | { |
| 194 | − if (!_strnicmp(&configLine[8], "TRUE", 4)) ptConfig.hwMouse = true; | |
| 195 | − else if (!_strnicmp(&configLine[8], "FALSE", 5)) ptConfig.hwMouse = false; | |
| 194 | + if (!_strnicmp(&configLine[8], "TRUE", 4)) config.hwMouse = true; | |
| 195 | + else if (!_strnicmp(&configLine[8], "FALSE", 5)) config.hwMouse = false; | |
| 196 | 196 | } |
| 197 | 197 | |
| 198 | 198 | // SAMPLELOWPASS |
| 199 | 199 | else if (!_strnicmp(configLine, "SAMPLELOWPASS=", 14)) |
| 200 | 200 | { |
| 201 | − if (!_strnicmp(&configLine[14], "TRUE", 4)) ptConfig.sampleLowpass = true; | |
| 202 | − else if (!_strnicmp(&configLine[14], "FALSE", 5)) ptConfig.sampleLowpass = false; | |
| 201 | + if (!_strnicmp(&configLine[14], "TRUE", 4)) config.sampleLowpass = true; | |
| 202 | + else if (!_strnicmp(&configLine[14], "FALSE", 5)) config.sampleLowpass = false; | |
| 203 | 203 | } |
| 204 | 204 | |
| 205 | 205 | // VSYNCOFF |
| 206 | 206 | else if (!_strnicmp(configLine, "VSYNCOFF=", 9)) |
| 207 | 207 | { |
| 208 | − if (!_strnicmp(&configLine[9], "TRUE", 4)) ptConfig.vsyncOff = true; | |
| 209 | − else if (!_strnicmp(&configLine[9], "FALSE", 5)) ptConfig.vsyncOff = false; | |
| 208 | + if (!_strnicmp(&configLine[9], "TRUE", 4)) config.vsyncOff = true; | |
| 209 | + else if (!_strnicmp(&configLine[9], "FALSE", 5)) config.vsyncOff = false; | |
| 210 | 210 | } |
| 211 | 211 | |
| 212 | 212 | // FULLSCREENSTRETCH |
| 213 | 213 | else if (!_strnicmp(configLine, "FULLSCREENSTRETCH=", 18)) |
| 214 | 214 | { |
| 215 | − if (!_strnicmp(&configLine[18], "TRUE", 4)) ptConfig.fullScreenStretch = true; | |
| 216 | − else if (!_strnicmp(&configLine[18], "FALSE", 5)) ptConfig.fullScreenStretch = false; | |
| 215 | + if (!_strnicmp(&configLine[18], "TRUE", 4)) config.fullScreenStretch = true; | |
| 216 | + else if (!_strnicmp(&configLine[18], "FALSE", 5)) config.fullScreenStretch = false; | |
| 217 | 217 | } |
| 218 | 218 | |
| 219 | 219 | // HIDEDISKOPDATES |
| 220 | 220 | else if (!_strnicmp(configLine, "HIDEDISKOPDATES=", 16)) |
| 221 | 221 | { |
| 222 | − if (!_strnicmp(&configLine[16], "TRUE", 4)) ptConfig.hideDiskOpDates = true; | |
| 223 | − else if (!_strnicmp(&configLine[16], "FALSE", 5)) ptConfig.hideDiskOpDates = false; | |
| 222 | + if (!_strnicmp(&configLine[16], "TRUE", 4)) config.hideDiskOpDates = true; | |
| 223 | + else if (!_strnicmp(&configLine[16], "FALSE", 5)) config.hideDiskOpDates = false; | |
| 224 | 224 | } |
| 225 | 225 | |
| 226 | 226 | // AUTOCLOSEDISKOP |
| 227 | 227 | else if (!_strnicmp(configLine, "AUTOCLOSEDISKOP=", 16)) |
| 228 | 228 | { |
| 229 | − if (!_strnicmp(&configLine[16], "TRUE", 4)) ptConfig.autoCloseDiskOp = true; | |
| 230 | − else if (!_strnicmp(&configLine[16], "FALSE", 5)) ptConfig.autoCloseDiskOp = false; | |
| 229 | + if (!_strnicmp(&configLine[16], "TRUE", 4)) config.autoCloseDiskOp = true; | |
| 230 | + else if (!_strnicmp(&configLine[16], "FALSE", 5)) config.autoCloseDiskOp = false; | |
| 231 | 231 | } |
| 232 | 232 | |
| 233 | 233 | // COMPOMODE |
| 234 | 234 | else if (!_strnicmp(configLine, "COMPOMODE=", 10)) |
| 235 | 235 | { |
| 236 | − if (!_strnicmp(&configLine[10], "TRUE", 4)) ptConfig.compoMode = true; | |
| 237 | − else if (!_strnicmp(&configLine[10], "FALSE", 5)) ptConfig.compoMode = false; | |
| 236 | + if (!_strnicmp(&configLine[10], "TRUE", 4)) config.compoMode = true; | |
| 237 | + else if (!_strnicmp(&configLine[10], "FALSE", 5)) config.compoMode = false; | |
| 238 | 238 | } |
| 239 | 239 | |
| 240 | 240 | // PATTDOTS |
| 241 | 241 | else if (!_strnicmp(configLine, "PATTDOTS=", 9)) |
| 242 | 242 | { |
| 243 | − if (!_strnicmp(&configLine[9], "TRUE", 4)) ptConfig.pattDots = true; | |
| 244 | − else if (!_strnicmp(&configLine[9], "FALSE", 5)) ptConfig.pattDots = false; | |
| 243 | + if (!_strnicmp(&configLine[9], "TRUE", 4)) config.pattDots = true; | |
| 244 | + else if (!_strnicmp(&configLine[9], "FALSE", 5)) config.pattDots = false; | |
| 245 | 245 | } |
| 246 | 246 | |
| 247 | 247 | // BLANKZERO |
| 248 | 248 | else if (!_strnicmp(configLine, "BLANKZERO=", 10)) |
| 249 | 249 | { |
| 250 | − if (!_strnicmp(&configLine[10], "TRUE", 4)) ptConfig.blankZeroFlag = true; | |
| 251 | − else if (!_strnicmp(&configLine[10], "FALSE", 5)) ptConfig.blankZeroFlag = false; | |
| 250 | + if (!_strnicmp(&configLine[10], "TRUE", 4)) config.blankZeroFlag = true; | |
| 251 | + else if (!_strnicmp(&configLine[10], "FALSE", 5)) config.blankZeroFlag = false; | |
| 252 | 252 | } |
| 253 | 253 | |
| 254 | 254 | // REALVUMETERS |
| 255 | 255 | else if (!_strnicmp(configLine, "REALVUMETERS=", 13)) |
| 256 | 256 | { |
| 257 | − if (!_strnicmp(&configLine[13], "TRUE", 4)) ptConfig.realVuMeters = true; | |
| 258 | − else if (!_strnicmp(&configLine[13], "FALSE", 5)) ptConfig.realVuMeters = false; | |
| 257 | + if (!_strnicmp(&configLine[13], "TRUE", 4)) config.realVuMeters = true; | |
| 258 | + else if (!_strnicmp(&configLine[13], "FALSE", 5)) config.realVuMeters = false; | |
| 259 | 259 | } |
| 260 | 260 | |
| 261 | 261 | // ACCIDENTAL |
| 262 | 262 | else if (!_strnicmp(configLine, "ACCIDENTAL=", 11)) |
| 263 | 263 | { |
| 264 | − if (!_strnicmp(&configLine[11], "SHARP", 4)) ptConfig.accidental = 0; | |
| 265 | − else if (!_strnicmp(&configLine[11], "FLAT", 5)) ptConfig.accidental = 1; | |
| 264 | + if (!_strnicmp(&configLine[11], "SHARP", 4)) config.accidental = 0; | |
| 265 | + else if (!_strnicmp(&configLine[11], "FLAT", 5)) config.accidental = 1; | |
| 266 | 266 | } |
| 267 | 267 | |
| 268 | 268 | // QUANTIZE |
| 269 | 269 | else if (!_strnicmp(configLine, "QUANTIZE=", 9)) |
| 270 | 270 | { |
| 271 | 271 | if (configLine[9] != '\0') |
| 272 | − ptConfig.quantizeValue = (int16_t)(CLAMP(atoi(&configLine[9]), 0, 63)); | |
| 272 | + config.quantizeValue = (int16_t)(CLAMP(atoi(&configLine[9]), 0, 63)); | |
| 273 | 273 | } |
| 274 | 274 | |
| 275 | 275 | // TRANSDEL |
| 276 | 276 | else if (!_strnicmp(configLine, "TRANSDEL=", 9)) |
| 277 | 277 | { |
| 278 | − if (!_strnicmp(&configLine[9], "TRUE", 4)) ptConfig.transDel = true; | |
| 279 | − else if (!_strnicmp(&configLine[9], "FALSE", 5)) ptConfig.transDel = false; | |
| 278 | + if (!_strnicmp(&configLine[9], "TRUE", 4)) config.transDel = true; | |
| 279 | + else if (!_strnicmp(&configLine[9], "FALSE", 5)) config.transDel = false; | |
| 280 | 280 | } |
| 281 | 281 | |
| 282 | 282 | // DOTTEDCENTER |
| 283 | 283 | else if (!_strnicmp(configLine, "DOTTEDCENTER=", 13)) |
| 284 | 284 | { |
| 285 | − if (!_strnicmp(&configLine[13], "TRUE", 4)) ptConfig.dottedCenterFlag = true; | |
| 286 | − else if (!_strnicmp(&configLine[13], "FALSE", 5)) ptConfig.dottedCenterFlag = false; | |
| 285 | + if (!_strnicmp(&configLine[13], "TRUE", 4)) config.dottedCenterFlag = true; | |
| 286 | + else if (!_strnicmp(&configLine[13], "FALSE", 5)) config.dottedCenterFlag = false; | |
| 287 | 287 | } |
| 288 | 288 | |
| 289 | 289 | // MODDOT |
| 290 | 290 | else if (!_strnicmp(configLine, "MODDOT=", 7)) |
| 291 | 291 | { |
| 292 | − if (!_strnicmp(&configLine[7], "TRUE", 4)) ptConfig.modDot = true; | |
| 293 | − else if (!_strnicmp(&configLine[7], "FALSE", 5)) ptConfig.modDot = false; | |
| 292 | + if (!_strnicmp(&configLine[7], "TRUE", 4)) config.modDot = true; | |
| 293 | + else if (!_strnicmp(&configLine[7], "FALSE", 5)) config.modDot = false; | |
| 294 | 294 | } |
| 295 | 295 | |
| 296 | 296 | // SCALE3X (deprecated) |
| 297 | 297 | else if (!_strnicmp(configLine, "SCALE3X=", 8)) |
| 298 | 298 | { |
| 299 | − if (!_strnicmp(&configLine[8], "TRUE", 4)) ptConfig.videoScaleFactor = 3; | |
| 300 | − else if (!_strnicmp(&configLine[8], "FALSE", 5)) ptConfig.videoScaleFactor = 2; | |
| 299 | + if (!_strnicmp(&configLine[8], "TRUE", 4)) config.videoScaleFactor = 3; | |
| 300 | + else if (!_strnicmp(&configLine[8], "FALSE", 5)) config.videoScaleFactor = 2; | |
| 301 | 301 | } |
| 302 | 302 | |
| 303 | 303 | // VIDEOSCALE |
| 304 | 304 | else if (!_strnicmp(configLine, "VIDEOSCALE=", 11)) |
| 305 | 305 | { |
| 306 | 306 | if (lineLen >= 13 && configLine[12] == 'X' && isdigit(configLine[11])) |
| 307 | − ptConfig.videoScaleFactor = configLine[11] - '0'; | |
| 307 | + config.videoScaleFactor = configLine[11] - '0'; | |
| 308 | 308 | } |
| 309 | 309 | |
| 310 | 310 | // REMEMBERPLAYMODE |
| 311 | 311 | else if (!_strnicmp(configLine, "REMEMBERPLAYMODE=", 17)) |
| 312 | 312 | { |
| 313 | − if (!_strnicmp(&configLine[17], "TRUE", 4)) ptConfig.rememberPlayMode = true; | |
| 314 | − else if (!_strnicmp(&configLine[17], "FALSE", 5)) ptConfig.rememberPlayMode = false; | |
| 313 | + if (!_strnicmp(&configLine[17], "TRUE", 4)) config.rememberPlayMode = true; | |
| 314 | + else if (!_strnicmp(&configLine[17], "FALSE", 5)) config.rememberPlayMode = false; | |
| 315 | 315 | } |
| 316 | 316 | |
| 317 | 317 | // DEFAULTDIR |
| @@ -325,7 +325,7 @@ static bool loadProTrackerDotIni(FILE *f) · 7 unmodified lines | ||
| 325 | 325 | |
| 326 | 326 | lineLen -= i; |
| 327 | 327 | if (lineLen > 0) |
| 328 | − strncpy(ptConfig.defModulesDir, &configLine[i], (lineLen > PATH_MAX) ? PATH_MAX : lineLen); | |
| 328 | + strncpy(config.defModulesDir, &configLine[i], (lineLen > PATH_MAX) ? PATH_MAX : lineLen); | |
| 329 | 329 | } |
| 330 | 330 | } |
| 331 | 331 | |
| @@ -340,43 +340,43 @@ static bool loadProTrackerDotIni(FILE *f) · 8 unmodified lines | ||
| 340 | 340 | |
| 341 | 341 | lineLen -= i; |
| 342 | 342 | if (lineLen > 0) |
| 343 | − strncpy(ptConfig.defSamplesDir, &configLine[i], (lineLen > PATH_MAX) ? PATH_MAX : lineLen); | |
| 343 | + strncpy(config.defSamplesDir, &configLine[i], (lineLen > PATH_MAX) ? PATH_MAX : lineLen); | |
| 344 | 344 | } |
| 345 | 345 | } |
| 346 | 346 | |
| 347 | 347 | // A500LOWPASSFILTER |
| 348 | 348 | else if (!_strnicmp(configLine, "A500LOWPASSFILTER=", 18)) |
| 349 | 349 | { |
| 350 | − if (!_strnicmp(&configLine[18], "TRUE", 4)) ptConfig.a500LowPassFilter = true; | |
| 351 | − else if (!_strnicmp(&configLine[18], "FALSE", 5)) ptConfig.a500LowPassFilter = false; | |
| 350 | + if (!_strnicmp(&configLine[18], "TRUE", 4)) config.a500LowPassFilter = true; | |
| 351 | + else if (!_strnicmp(&configLine[18], "FALSE", 5)) config.a500LowPassFilter = false; | |
| 352 | 352 | } |
| 353 | 353 | |
| 354 | 354 | // A4000LOWPASSFILTER (deprecated, same as A500LOWPASSFILTER) |
| 355 | 355 | else if (!_strnicmp(configLine, "A4000LOWPASSFILTER=", 19)) |
| 356 | 356 | { |
| 357 | − if (!_strnicmp(&configLine[19], "TRUE", 4)) ptConfig.a500LowPassFilter = true; | |
| 358 | − else if (!_strnicmp(&configLine[19], "FALSE", 5)) ptConfig.a500LowPassFilter = false; | |
| 357 | + if (!_strnicmp(&configLine[19], "TRUE", 4)) config.a500LowPassFilter = true; | |
| 358 | + else if (!_strnicmp(&configLine[19], "FALSE", 5)) config.a500LowPassFilter = false; | |
| 359 | 359 | } |
| 360 | 360 | |
| 361 | 361 | // FREQUENCY |
| 362 | 362 | else if (!_strnicmp(configLine, "FREQUENCY=", 10)) |
| 363 | 363 | { |
| 364 | 364 | if (configLine[10] != '\0') |
| 365 | − ptConfig.soundFrequency = (uint32_t)(CLAMP(atoi(&configLine[10]), 32000, 96000)); | |
| 365 | + config.soundFrequency = (uint32_t)(CLAMP(atoi(&configLine[10]), 32000, 96000)); | |
| 366 | 366 | } |
| 367 | 367 | |
| 368 | 368 | // BUFFERSIZE |
| 369 | 369 | else if (!_strnicmp(configLine, "BUFFERSIZE=", 11)) |
| 370 | 370 | { |
| 371 | 371 | if (configLine[11] != '\0') |
| 372 | − ptConfig.soundBufferSize = (uint32_t)(CLAMP(atoi(&configLine[11]), 128, 8192)); | |
| 372 | + config.soundBufferSize = (uint32_t)(CLAMP(atoi(&configLine[11]), 128, 8192)); | |
| 373 | 373 | } |
| 374 | 374 | |
| 375 | 375 | // STEREOSEPARATION |
| 376 | 376 | else if (!_strnicmp(configLine, "STEREOSEPARATION=", 17)) |
| 377 | 377 | { |
| 378 | 378 | if (configLine[17] != '\0') |
| 379 | − ptConfig.stereoSeparation = (int8_t)(CLAMP(atoi(&configLine[17]), 0, 100)); | |
| 379 | + config.stereoSeparation = (int8_t)(CLAMP(atoi(&configLine[17]), 0, 100)); | |
| 380 | 380 | } |
| 381 | 381 | |
| 382 | 382 | configLine = strtok(NULL, "\n"); |
| @@ -450,20 +450,20 @@ static bool loadPTDotConfig(FILE *f) · 67 unmodified lines | ||
| 450 | 450 | { |
| 451 | 451 | fread(&tmp16, 2, 1, f); // stored as Big-Endian |
| 452 | 452 | tmp16 = SWAP16(tmp16); |
| 453 | − palette[i] = RGB12_to_RGB24(tmp16); | |
| 453 | + video.palette[i] = RGB12_to_RGB24(tmp16); | |
| 454 | 454 | } |
| 455 | 455 | |
| 456 | 456 | // Transpose Delete (delete out of range notes on transposing) |
| 457 | 457 | fseek(f, 174, SEEK_SET); |
| 458 | 458 | fread(&tmp8, 1, 1, f); |
| 459 | − ptConfig.transDel = tmp8 ? true : false; | |
| 460 | − ptConfig.transDel = ptConfig.transDel; | |
| 459 | + config.transDel = tmp8 ? true : false; | |
| 460 | + config.transDel = config.transDel; | |
| 461 | 461 | |
| 462 | 462 | // Note style (sharps/flats) |
| 463 | 463 | fseek(f, 200, SEEK_SET); |
| 464 | 464 | fread(&tmp8, 1, 1, f); |
| 465 | − ptConfig.accidental = tmp8 ? 1 : 0; | |
| 466 | − ptConfig.accidental = ptConfig.accidental; | |
| 465 | + config.accidental = tmp8 ? 1 : 0; | |
| 466 | + config.accidental = config.accidental; | |
| 467 | 467 | |
| 468 | 468 | // Multi Mode Next |
| 469 | 469 | fseek(f, 462, SEEK_SET); |
| @@ -489,8 +489,8 @@ static bool loadPTDotConfig(FILE *f) · 19 unmodified lines | ||
| 489 | 489 | // Blank Zeroes |
| 490 | 490 | fseek(f, 490, SEEK_SET); |
| 491 | 491 | fread(&tmp8, 1, 1, f); |
| 492 | − ptConfig.blankZeroFlag = tmp8 ? true : false; | |
| 493 | − ptConfig.blankZeroFlag = ptConfig.blankZeroFlag; | |
| 492 | + config.blankZeroFlag = tmp8 ? true : false; | |
| 493 | + config.blankZeroFlag = config.blankZeroFlag; | |
| 494 | 494 | |
| 495 | 495 | // Initial Tempo (don't load if timing is set to VBLANK) |
| 496 | 496 | if (editor.timingMode == TEMPO_MODE_CIA) |
| @@ -603,7 +603,7 @@ static bool loadColorsDotIni(void) · 106 unmodified lines | ||
| 603 | 603 | { |
| 604 | 604 | color = (hex2int(configLine[0]) << 8) | (hex2int(configLine[1]) << 4) | hex2int(configLine[2]); |
| 605 | 605 | color &= 0xFFF; |
| 606 | − palette[line] = RGB12_to_RGB24(color); | |
| 606 | + video.palette[line] = RGB12_to_RGB24(color); | |
| 607 | 607 | |
| 608 | 608 | configLine = strtok(NULL, "\n"); |
| 609 | 609 | line++; |
| @@ -3,7 +3,7 @@ · 2 unmodified lines | ||
| 3 | 3 | #include <stdint.h> |
| 4 | 4 | #include <stdbool.h> |
| 5 | 5 | |
| 6 | −struct ptConfig_t | |
| 6 | +struct config_t | |
| 7 | 7 | { |
| 8 | 8 | char *defModulesDir, *defSamplesDir; |
| 9 | 9 | bool dottedCenterFlag, pattDots, a500LowPassFilter, compoMode, autoCloseDiskOp, hideDiskOpDates, hwMouse; |
| @@ -12,6 +12,6 @@ struct ptConfig_t · 2 unmodified lines | ||
| 12 | 12 | int8_t stereoSeparation, videoScaleFactor, accidental; |
| 13 | 13 | uint16_t quantizeValue; |
| 14 | 14 | uint32_t soundFrequency, soundBufferSize; |
| 15 | −} ptConfig; | |
| 15 | +} config; | |
| 16 | 16 | |
| 17 | 17 | void loadConfig(void); |
| @@ -450,12 +450,12 @@ bool diskOpSetPath(UNICHAR *path, bool cache) · 449 unmodified lines | ||
| 450 | 450 | void diskOpSetInitPath(void) |
| 451 | 451 | { |
| 452 | 452 | // default module path |
| 453 | − if (ptConfig.defModulesDir[0] != '\0') | |
| 453 | + if (config.defModulesDir[0] != '\0') | |
| 454 | 454 | { |
| 455 | 455 | #ifdef _WIN32 |
| 456 | − MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, ptConfig.defModulesDir, -1, pathTmp, PATH_MAX); | |
| 456 | + MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, config.defModulesDir, -1, pathTmp, PATH_MAX); | |
| 457 | 457 | #else |
| 458 | − strcpy(pathTmp, ptConfig.defModulesDir); | |
| 458 | + strcpy(pathTmp, config.defModulesDir); | |
| 459 | 459 | #endif |
| 460 | 460 | UNICHAR_STRCPY(editor.modulesPathU, pathTmp); |
| 461 | 461 | } |
| @@ -466,12 +466,12 @@ void diskOpSetInitPath(void) · 4 unmodified lines | ||
| 466 | 466 | } |
| 467 | 467 | |
| 468 | 468 | // default sample path |
| 469 | − if (ptConfig.defSamplesDir[0] != '\0') | |
| 469 | + if (config.defSamplesDir[0] != '\0') | |
| 470 | 470 | { |
| 471 | 471 | #ifdef _WIN32 |
| 472 | − MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, ptConfig.defSamplesDir, -1, pathTmp, PATH_MAX); | |
| 472 | + MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, config.defSamplesDir, -1, pathTmp, PATH_MAX); | |
| 473 | 473 | #else |
| 474 | − strcpy(pathTmp, ptConfig.defSamplesDir); | |
| 474 | + strcpy(pathTmp, config.defSamplesDir); | |
| 475 | 475 | #endif |
| 476 | 476 | UNICHAR_STRCPY(editor.samplesPathU, pathTmp); |
| 477 | 477 | } |
| @@ -715,14 +715,14 @@ static int32_t SDLCALL diskOpFillThreadFunc(void *ptr) · 237 unmodified lines | ||
| 715 | 715 | return true; |
| 716 | 716 | } |
| 717 | 717 | |
| 718 | −static void printFileSize(uint32_t *frameBuffer, fileEntry_t *entry, uint16_t x, uint16_t y) | |
| 718 | +static void printFileSize(fileEntry_t *entry, uint16_t x, uint16_t y) | |
| 719 | 719 | { |
| 720 | 720 | char tmpStr[7]; |
| 721 | 721 | uint32_t fileSize, j; |
| 722 | 722 | |
| 723 | 723 | if (entry->filesize == -1) // -1 means that the original filesize is above 2GB in our directory reader |
| 724 | 724 | { |
| 725 | − textOut(frameBuffer, x, y, " >2GB", palette[PAL_QADSCP]); | |
| 725 | + textOut(x, y, " >2GB", video.palette[PAL_QADSCP]); | |
| 726 | 726 | return; |
| 727 | 727 | } |
| 728 | 728 | |
| @@ -754,27 +754,27 @@ static void printFileSize(uint32_t *frameBuffer, fileEntry_t *entry, uint16_t x, · 25 unmodified lines | ||
| 754 | 754 | tmpStr[j] = ' '; |
| 755 | 755 | } |
| 756 | 756 | |
| 757 | − textOut(frameBuffer, x, y, tmpStr, palette[PAL_QADSCP]); | |
| 757 | + textOut(x, y, tmpStr, video.palette[PAL_QADSCP]); | |
| 758 | 758 | } |
| 759 | 759 | |
| 760 | −static void printEntryName(uint32_t *frameBuffer, char *entryName, int32_t entryLength, int32_t maxLength, uint16_t x, uint16_t y) | |
| 760 | +static void printEntryName(char *entryName, int32_t entryLength, int32_t maxLength, uint16_t x, uint16_t y) | |
| 761 | 761 | { |
| 762 | 762 | if (entryLength > maxLength) |
| 763 | 763 | { |
| 764 | 764 | // shorten name and add ".." to end |
| 765 | 765 | for (int32_t j = 0; j < maxLength-2; j++) |
| 766 | − charOut(frameBuffer, x + (j * FONT_CHAR_W), y, entryName[j], palette[PAL_QADSCP]); | |
| 766 | + charOut(x + (j * FONT_CHAR_W), y, entryName[j], video.palette[PAL_QADSCP]); | |
| 767 | 767 | |
| 768 | − textOut(frameBuffer, x + ((maxLength - 2) * FONT_CHAR_W), y, "..", palette[PAL_QADSCP]); | |
| 768 | + textOut(x + ((maxLength - 2) * FONT_CHAR_W), y, "..", video.palette[PAL_QADSCP]); | |
| 769 | 769 | } |
| 770 | 770 | else |
| 771 | 771 | { |
| 772 | 772 | // print whole name |
| 773 | − textOut(frameBuffer, x, y, entryName, palette[PAL_QADSCP]); | |
| 773 | + textOut(x, y, entryName, video.palette[PAL_QADSCP]); | |
| 774 | 774 | } |
| 775 | 775 | } |
| 776 | 776 | |
| 777 | −void diskOpRenderFileList(uint32_t *frameBuffer) | |
| 777 | +void diskOpRenderFileList(void) | |
| 778 | 778 | { |
| 779 | 779 | char *entryName; |
| 780 | 780 | uint8_t maxFilenameChars, maxDirNameChars; |
| @@ -783,7 +783,7 @@ void diskOpRenderFileList(uint32_t *frameBuffer) · 2 unmodified lines | ||
| 783 | 783 | uint32_t *dstPtr; |
| 784 | 784 | fileEntry_t *entry; |
| 785 | 785 | |
| 786 | − if (ptConfig.hideDiskOpDates) | |
| 786 | + if (config.hideDiskOpDates) | |
| 787 | 787 | { |
| 788 | 788 | textXStart = 8; |
| 789 | 789 | maxFilenameChars = 30; |
| @@ -813,11 +813,11 @@ void diskOpRenderFileList(uint32_t *frameBuffer) · 23 unmodified lines | ||
| 813 | 813 | } |
| 814 | 814 | |
| 815 | 815 | // clear list |
| 816 | − dstPtr = &frameBuffer[(35 * SCREEN_W) + 8]; | |
| 816 | + dstPtr = &video.frameBuffer[(35 * SCREEN_W) + 8]; | |
| 817 | 817 | for (y = 0; y < 59; y++) |
| 818 | 818 | { |
| 819 | 819 | for (x = 0; x < 295; x++) |
| 820 | − dstPtr[x] = palette[PAL_BACKGRD]; | |
| 820 | + dstPtr[x] = video.palette[PAL_BACKGRD]; | |
| 821 | 821 | |
| 822 | 822 | dstPtr += SCREEN_W; |
| 823 | 823 | } |
| @@ -840,19 +840,19 @@ void diskOpRenderFileList(uint32_t *frameBuffer) · 16 unmodified lines | ||
| 840 | 840 | |
| 841 | 841 | if (!entry->isDir) |
| 842 | 842 | { |
| 843 | − printEntryName(frameBuffer, entryName, entryLength, maxFilenameChars, x, y); | |
| 843 | + printEntryName(entryName, entryLength, maxFilenameChars, x, y); | |
| 844 | 844 | |
| 845 | 845 | // print modification date |
| 846 | − if (!ptConfig.hideDiskOpDates) | |
| 847 | − textOut(frameBuffer, 8, y, entry->dateChanged, palette[PAL_QADSCP]); | |
| 846 | + if (!config.hideDiskOpDates) | |
| 847 | + textOut(8, y, entry->dateChanged, video.palette[PAL_QADSCP]); | |
| 848 | 848 | |
| 849 | 849 | // print file size |
| 850 | − printFileSize(frameBuffer, entry, 256, y); | |
| 850 | + printFileSize(entry, 256, y); | |
| 851 | 851 | } |
| 852 | 852 | else |
| 853 | 853 | { |
| 854 | − printEntryName(frameBuffer, entryName, entryLength, maxDirNameChars, x, y); | |
| 855 | − textOut(frameBuffer, 264, y, "(DIR)", palette[PAL_QADSCP]); | |
| 854 | + printEntryName(entryName, entryLength, maxDirNameChars, x, y); | |
| 855 | + textOut(264, y, "(DIR)", video.palette[PAL_QADSCP]); | |
| 856 | 856 | } |
| 857 | 857 | } |
| 858 | 858 | } |
| @@ -900,10 +900,10 @@ void diskOpLoadFile(uint32_t fileEntryRow, bool songModifiedCheck) · 41 unmodified lines | ||
| 900 | 900 | |
| 901 | 901 | statusAllRight(); |
| 902 | 902 | |
| 903 | − if (ptConfig.autoCloseDiskOp) | |
| 903 | + if (config.autoCloseDiskOp) | |
| 904 | 904 | editor.ui.diskOpScreenShown = false; |
| 905 | 905 | |
| 906 | − if (ptConfig.rememberPlayMode) | |
| 906 | + if (config.rememberPlayMode) | |
| 907 | 907 | { |
| 908 | 908 | if (oldMode == MODE_PLAY || oldMode == MODE_RECORD) |
| 909 | 909 | { |
| @@ -22,7 +22,7 @@ char *diskOpGetAnsiEntry(int32_t fileIndex); · 21 unmodified lines | ||
| 22 | 22 | UNICHAR *diskOpGetUnicodeEntry(int32_t fileIndex); |
| 23 | 23 | bool diskOpSetPath(UNICHAR *path, bool cache); |
| 24 | 24 | void diskOpSetInitPath(void); |
| 25 | −void diskOpRenderFileList(uint32_t *frameBuffer); | |
| 25 | +void diskOpRenderFileList(void); | |
| 26 | 26 | bool allocDiskOpVars(void); |
| 27 | 27 | void freeDiskOpMem(void); |
| 28 | 28 | void freeDiskOpEntryMem(void); |
| @@ -256,14 +256,14 @@ void exitGetTextLine(bool updateValue) · 255 unmodified lines | ||
| 256 | 256 | |
| 257 | 257 | case PTB_EO_QUANTIZE: |
| 258 | 258 | { |
| 259 | − editor.quantizeValueDisp = &ptConfig.quantizeValue; | |
| 259 | + editor.quantizeValueDisp = &config.quantizeValue; | |
| 260 | 260 | |
| 261 | 261 | if (updateValue) |
| 262 | 262 | { |
| 263 | 263 | if (editor.ui.tmpDisp16 > 63) |
| 264 | 264 | editor.ui.tmpDisp16 = 63; |
| 265 | 265 | |
| 266 | − ptConfig.quantizeValue = editor.ui.tmpDisp16; | |
| 266 | + config.quantizeValue = editor.ui.tmpDisp16; | |
| 267 | 267 | editor.ui.updateQuantizeText = true; |
| 268 | 268 | } |
| 269 | 269 | } |
| @@ -679,7 +679,7 @@ void handleEditKeys(SDL_Scancode scancode, bool normalMode) · 409 unmodified lines | ||
| 679 | 679 | if (editor.ui.samplerScreenShown || (editor.currMode == MODE_IDLE || editor.currMode == MODE_PLAY)) |
| 680 | 680 | { |
| 681 | 681 | // at this point it will only jam, not place it |
| 682 | − if (!input.keyb.leftAltPressed && !input.keyb.leftAmigaPressed && !input.keyb.leftCtrlPressed && !input.keyb.shiftPressed) | |
| 682 | + if (!keyb.leftAltPressed && !keyb.leftAmigaPressed && !keyb.leftCtrlPressed && !keyb.shiftPressed) | |
| 683 | 683 | jamAndPlaceSample(scancode, normalMode); |
| 684 | 684 | |
| 685 | 685 | return; |
| @@ -701,7 +701,7 @@ void handleEditKeys(SDL_Scancode scancode, bool normalMode) · 15 unmodified lines | ||
| 701 | 701 | if (editor.cursor.mode != CURSOR_NOTE) |
| 702 | 702 | { |
| 703 | 703 | // if we held down any key modifier at this point, then do nothing |
| 704 | − if (input.keyb.leftAltPressed || input.keyb.leftAmigaPressed || input.keyb.leftCtrlPressed || input.keyb.shiftPressed) | |
| 704 | + if (keyb.leftAltPressed || keyb.leftAmigaPressed || keyb.leftCtrlPressed || keyb.shiftPressed) | |
| 705 | 705 | return; |
| 706 | 706 | |
| 707 | 707 | if (editor.currMode == MODE_EDIT || editor.currMode == MODE_RECORD) |
| @@ -821,13 +821,13 @@ void handleEditKeys(SDL_Scancode scancode, bool normalMode) · 113 unmodified lines | ||
| 821 | 821 | { |
| 822 | 822 | note = &modEntry->patterns[modEntry->currPattern][(modEntry->currRow * AMIGA_VOICES) + editor.cursor.channel]; |
| 823 | 823 | |
| 824 | − if (!input.keyb.leftAltPressed) | |
| 824 | + if (!keyb.leftAltPressed) | |
| 825 | 825 | { |
| 826 | 826 | note->sample = 0; |
| 827 | 827 | note->period = 0; |
| 828 | 828 | } |
| 829 | 829 | |
| 830 | − if (input.keyb.shiftPressed || input.keyb.leftAltPressed) | |
| 830 | + if (keyb.shiftPressed || keyb.leftAltPressed) | |
| 831 | 831 | { |
| 832 | 832 | note->command = 0; |
| 833 | 833 | note->param = 0; |
| @@ -842,7 +842,7 @@ void handleEditKeys(SDL_Scancode scancode, bool normalMode) · 8 unmodified lines | ||
| 842 | 842 | else |
| 843 | 843 | { |
| 844 | 844 | // if we held down any key modifier at this point, then do nothing |
| 845 | − if (input.keyb.leftAltPressed || input.keyb.leftAmigaPressed || input.keyb.leftCtrlPressed || input.keyb.shiftPressed) | |
| 845 | + if (keyb.leftAltPressed || keyb.leftAmigaPressed || keyb.leftCtrlPressed || keyb.shiftPressed) | |
| 846 | 846 | return; |
| 847 | 847 | |
| 848 | 848 | jamAndPlaceSample(scancode, normalMode); |
| @@ -854,7 +854,7 @@ bool handleSpecialKeys(SDL_Scancode scancode) · 5 unmodified lines | ||
| 854 | 854 | { |
| 855 | 855 | note_t *patt, *note, *prevNote; |
| 856 | 856 | |
| 857 | − if (!input.keyb.leftAltPressed) | |
| 857 | + if (!keyb.leftAltPressed) | |
| 858 | 858 | return false; |
| 859 | 859 | |
| 860 | 860 | patt = modEntry->patterns[modEntry->currPattern]; |
| @@ -1015,7 +1015,7 @@ uint8_t quantizeCheck(uint8_t row) · 154 unmodified lines | ||
| 1015 | 1015 | { |
| 1016 | 1016 | uint8_t tempRow, quantize; |
| 1017 | 1017 | |
| 1018 | − quantize = (uint8_t)ptConfig.quantizeValue; | |
| 1018 | + quantize = (uint8_t)config.quantizeValue; | |
| 1019 | 1019 | |
| 1020 | 1020 | editor.didQuantize = false; |
| 1021 | 1021 | if (editor.currMode == MODE_RECORD) |
| @@ -1307,7 +1307,7 @@ void trackNoteUp(bool sampleAllFlag, uint8_t from, uint8_t to) · 285 unmodified lines | ||
| 1307 | 1307 | { |
| 1308 | 1308 | j = 35; |
| 1309 | 1309 | |
| 1310 | − if (ptConfig.transDel) | |
| 1310 | + if (config.transDel) | |
| 1311 | 1311 | { |
| 1312 | 1312 | noteSrc->period = 0; |
| 1313 | 1313 | noteSrc->sample = 0; |
| @@ -1360,7 +1360,7 @@ void trackNoteDown(bool sampleAllFlag, uint8_t from, uint8_t to) · 46 unmodified lines | ||
| 1360 | 1360 | { |
| 1361 | 1361 | j = 0; |
| 1362 | 1362 | |
| 1363 | − if (ptConfig.transDel) | |
| 1363 | + if (config.transDel) | |
| 1364 | 1364 | { |
| 1365 | 1365 | noteSrc->period = 0; |
| 1366 | 1366 | noteSrc->sample = 0; |
| @@ -1409,7 +1409,7 @@ void trackOctaUp(bool sampleAllFlag, uint8_t from, uint8_t to) · 42 unmodified lines | ||
| 1409 | 1409 | } |
| 1410 | 1410 | |
| 1411 | 1411 | noteDeleted = false; |
| 1412 | − if (j+12 > 35 && ptConfig.transDel) | |
| 1412 | + if (j+12 > 35 && config.transDel) | |
| 1413 | 1413 | { |
| 1414 | 1414 | noteSrc->period = 0; |
| 1415 | 1415 | noteSrc->sample = 0; |
| @@ -1460,7 +1460,7 @@ void trackOctaDown(bool sampleAllFlag, uint8_t from, uint8_t to) · 44 unmodified lines | ||
| 1460 | 1460 | } |
| 1461 | 1461 | |
| 1462 | 1462 | noteDeleted = false; |
| 1463 | − if (j-12 < 0 && ptConfig.transDel) | |
| 1463 | + if (j-12 < 0 && config.transDel) | |
| 1464 | 1464 | { |
| 1465 | 1465 | noteSrc->period = 0; |
| 1466 | 1466 | noteSrc->sample = 0; |
| @@ -1510,7 +1510,7 @@ void pattNoteUp(bool sampleAllFlag) · 43 unmodified lines | ||
| 1510 | 1510 | { |
| 1511 | 1511 | k = 35; |
| 1512 | 1512 | |
| 1513 | − if (ptConfig.transDel) | |
| 1513 | + if (config.transDel) | |
| 1514 | 1514 | { |
| 1515 | 1515 | noteSrc->period = 0; |
| 1516 | 1516 | noteSrc->sample = 0; |
| @@ -1559,7 +1559,7 @@ void pattNoteDown(bool sampleAllFlag) · 42 unmodified lines | ||
| 1559 | 1559 | { |
| 1560 | 1560 | k = 0; |
| 1561 | 1561 | |
| 1562 | − if (ptConfig.transDel) | |
| 1562 | + if (config.transDel) | |
| 1563 | 1563 | { |
| 1564 | 1564 | noteSrc->period = 0; |
| 1565 | 1565 | noteSrc->sample = 0; |
| @@ -1604,7 +1604,7 @@ void pattOctaUp(bool sampleAllFlag) · 38 unmodified lines | ||
| 1604 | 1604 | } |
| 1605 | 1605 | |
| 1606 | 1606 | noteDeleted = false; |
| 1607 | − if (k+12 > 35 && ptConfig.transDel) | |
| 1607 | + if (k+12 > 35 && config.transDel) | |
| 1608 | 1608 | { |
| 1609 | 1609 | noteSrc->period = 0; |
| 1610 | 1610 | noteSrc->sample = 0; |
| @@ -1651,7 +1651,7 @@ void pattOctaDown(bool sampleAllFlag) · 40 unmodified lines | ||
| 1651 | 1651 | } |
| 1652 | 1652 | |
| 1653 | 1653 | noteDeleted = false; |
| 1654 | − if (k-12 < 0 && ptConfig.transDel) | |
| 1654 | + if (k-12 < 0 && config.transDel) | |
| 1655 | 1655 | { |
| 1656 | 1656 | noteSrc->period = 0; |
| 1657 | 1657 | noteSrc->sample = 0; |
| @@ -12,8 +12,9 @@ · 11 unmodified lines | ||
| 12 | 12 | #endif |
| 13 | 13 | #include <stdint.h> |
| 14 | 14 | #include "pt2_unicode.h" |
| 15 | +#include "pt2_palette.h" | |
| 15 | 16 | |
| 16 | −#define PROG_VER_STR "1.07" | |
| 17 | +#define PROG_VER_STR "1.08" | |
| 17 | 18 | |
| 18 | 19 | #ifdef _WIN32 |
| 19 | 20 | #define DIR_DELIMITER '\\' |
| @@ -285,39 +286,53 @@ typedef struct module_t · 265 unmodified lines | ||
| 285 | 286 | note_t *patterns[MAX_PATTERNS]; |
| 286 | 287 | } module_t; |
| 287 | 288 | |
| 288 | −struct cpu_t | |
| 289 | −{ | |
| 290 | − bool hasSSE, hasSSE2; | |
| 291 | −} cpu; | |
| 292 | − | |
| 293 | 289 | struct audio_t |
| 294 | 290 | { |
| 291 | + volatile bool locked; | |
| 292 | + bool forceMixerOff; | |
| 295 | 293 | uint16_t bpmTab[256-32], bpmTab28kHz[256-32], bpmTab22kHz[256-32]; |
| 296 | 294 | uint32_t audioFreq, audioBufferSize; |
| 297 | 295 | double dAudioFreq, dPeriodToDeltaDiv; |
| 298 | 296 | } audio; |
| 299 | 297 | |
| 300 | −struct input_t | |
| 298 | +struct keyb_t | |
| 301 | 299 | { |
| 302 | − struct keyb_t | |
| 303 | − { | |
| 304 | − bool repeatKey, delayKey; | |
| 305 | − bool shiftPressed, leftCtrlPressed, leftAltPressed; | |
| 306 | − bool leftCommandPressed, leftAmigaPressed, keypadEnterPressed; | |
| 307 | − uint8_t repeatCounter, delayCounter; | |
| 308 | − uint64_t repeatFrac; | |
| 309 | − SDL_Scancode lastRepKey, lastKey; | |
| 310 | − } keyb; | |
| 311 | − | |
| 312 | − struct mouse_t | |
| 313 | − { | |
| 314 | − volatile bool setPosFlag; | |
| 315 | − bool buttonWaiting, leftButtonPressed, rightButtonPressed; | |
| 316 | − uint8_t repeatCounter, buttonWaitCounter; | |
| 317 | − int32_t setPosX, setPosY, lastGUIButton, lastSmpFilterButton, prevX, prevY; | |
| 318 | − int16_t x, y, lastMouseX; | |
| 319 | − } mouse; | |
| 320 | −} input; | |
| 300 | + bool repeatKey, delayKey; | |
| 301 | + bool shiftPressed, leftCtrlPressed, leftAltPressed; | |
| 302 | + bool leftCommandPressed, leftAmigaPressed, keypadEnterPressed; | |
| 303 | + uint8_t repeatCounter, delayCounter; | |
| 304 | + uint64_t repeatFrac; | |
| 305 | + SDL_Scancode lastRepKey, lastKey; | |
| 306 | +} keyb; | |
| 307 | + | |
| 308 | +struct mouse_t | |
| 309 | +{ | |
| 310 | + volatile bool setPosFlag; | |
| 311 | + bool buttonWaiting, leftButtonPressed, rightButtonPressed; | |
| 312 | + uint8_t repeatCounter, buttonWaitCounter; | |
| 313 | + int32_t x, y, lastMouseX, setPosX, setPosY, lastGUIButton, lastSmpFilterButton, prevX, prevY; | |
| 314 | + uint32_t buttonState; | |
| 315 | +} mouse; | |
| 316 | + | |
| 317 | +struct video_t | |
| 318 | +{ | |
| 319 | + bool fullscreen, vsync60HzPresent, windowHidden; | |
| 320 | + int32_t renderX, renderY, renderW, renderH, displayW, displayH; | |
| 321 | + int32_t xScale, yScale; | |
| 322 | + double dMouseXMul, dMouseYMul; | |
| 323 | + SDL_PixelFormat *pixelFormat; | |
| 324 | + uint32_t *frameBuffer, *frameBufferUnaligned; | |
| 325 | + | |
| 326 | + SDL_Window *window; | |
| 327 | + SDL_Renderer *renderer; | |
| 328 | + SDL_Texture *texture; | |
| 329 | + | |
| 330 | + uint32_t palette[PALETTE_NUM]; | |
| 331 | + | |
| 332 | +#ifdef _WIN32 | |
| 333 | + HWND hWnd; | |
| 334 | +#endif | |
| 335 | +} video; | |
| 321 | 336 | |
| 322 | 337 | // this is massive... |
| 323 | 338 | struct editor_t |
| @@ -337,7 +352,7 @@ struct editor_t · 13 unmodified lines | ||
| 337 | 352 | |
| 338 | 353 | bool errorMsgActive, errorMsgBlock, multiFlag, metroFlag, keypadToggle8CFlag, normalizeFiltersFlag; |
| 339 | 354 | bool sampleAllFlag, halfClipFlag, newOldFlag, pat2SmpHQ, mixFlag, useLEDFilter; |
| 340 | − bool modLoaded, fullscreen, autoInsFlag, repeatKeyFlag, sampleZero, tuningFlag; | |
| 355 | + bool modLoaded, autoInsFlag, repeatKeyFlag, sampleZero, tuningFlag; | |
| 341 | 356 | bool stepPlayEnabled, stepPlayBackwards, blockBufferFlag, blockMarkFlag, didQuantize; |
| 342 | 357 | bool swapChannelFlag, configFound, abortMod2Wav, chordLengthMin, rowVisitTable[MOD_ORDERS * MOD_ROWS]; |
| 343 | 358 | bool muted[AMIGA_VOICES]; |
| @@ -430,17 +445,10 @@ struct editor_t · 86 unmodified lines | ||
| 430 | 445 | // these are used when things are drawn on top, for example clear/ask dialogs |
| 431 | 446 | bool disablePosEd, disableVisualizer; |
| 432 | 447 | |
| 433 | − bool vsync60HzPresent; | |
| 434 | 448 | int16_t lineCurX, lineCurY, editObject, sampleMarkingPos; |
| 435 | 449 | uint16_t *numPtr16, tmpDisp16, *dstOffset, dstPos, textLength, editTextPos; |
| 436 | 450 | uint16_t dstOffsetEnd, lastSampleOffset; |
| 437 | − int32_t askTempData, renderX, renderY, renderW, renderH, displayW, displayH; | |
| 438 | − int32_t xScale, yScale; | |
| 439 | − double dMouseXMul, dMouseYMul; | |
| 440 | − SDL_PixelFormat *pixelFormat; | |
| 441 | −#ifdef _WIN32 | |
| 442 | − HWND hWnd; | |
| 443 | −#endif | |
| 451 | + int32_t askTempData; | |
| 444 | 452 | } ui; |
| 445 | 453 | |
| 446 | 454 | struct sampler_t |
| @@ -448,8 +456,8 @@ struct editor_t · 1 unmodified line | ||
| 448 | 456 | const int8_t *samStart; |
| 449 | 457 | int8_t *blankSample, *copyBuf; |
| 450 | 458 | int16_t loopStartPos, loopEndPos; |
| 451 | − uint16_t dragStart, dragEnd, saveMouseX, lastSamPos; | |
| 452 | − int32_t samPointWidth, samOffset, samDisplay, samLength; | |
| 459 | + uint16_t dragStart, dragEnd; | |
| 460 | + int32_t samPointWidth, samOffset, samDisplay, samLength, saveMouseX, lastSamPos; | |
| 453 | 461 | int32_t lastMouseX, lastMouseY, tmpLoopStart, tmpLoopLength; |
| 454 | 462 | uint32_t copyBufSize, samDrawStart, samDrawEnd; |
| 455 | 463 | } sampler; |
| @@ -20,8 +20,6 @@ · 19 unmodified lines | ||
| 20 | 20 | #include "pt2_tables.h" |
| 21 | 21 | #include "pt2_palette.h" |
| 22 | 22 | |
| 23 | −extern SDL_Window *window; // pt_main.c | |
| 24 | − | |
| 25 | 23 | // used for Windows usleep() implementation |
| 26 | 24 | #ifdef _WIN32 |
| 27 | 25 | static NTSTATUS (__stdcall *NtDelayExecution)(BOOL Alertable, PLARGE_INTEGER DelayInterval); |
| @@ -71,7 +69,7 @@ void showErrorMsgBox(const char *fmt, ...) · 43 unmodified lines | ||
| 71 | 69 | va_end(args); |
| 72 | 70 | |
| 73 | 71 | // window can be NULL here, no problem... |
| 74 | − SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Critical Error", strBuf, window); | |
| 72 | + SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Critical Error", strBuf, video.window); | |
| 75 | 73 | } |
| 76 | 74 | |
| 77 | 75 | void sanitizeFilenameChar(char *chr) |
| @@ -129,14 +127,14 @@ void updateWindowTitle(bool modified) · 51 unmodified lines | ||
| 129 | 127 | { |
| 130 | 128 | if (modified) |
| 131 | 129 | { |
| 132 | − if (ptConfig.modDot) | |
| 130 | + if (config.modDot) | |
| 133 | 131 | sprintf(titleTemp, "ProTracker 2 clone v%s - \"mod.%s\" (unsaved)", PROG_VER_STR, modEntry->head.moduleTitle); |
| 134 | 132 | else |
| 135 | 133 | sprintf(titleTemp, "ProTracker 2 clone v%s - \"%s.mod\" (unsaved)", PROG_VER_STR, modEntry->head.moduleTitle); |
| 136 | 134 | } |
| 137 | 135 | else |
| 138 | 136 | { |
| 139 | − if (ptConfig.modDot) | |
| 137 | + if (config.modDot) | |
| 140 | 138 | sprintf(titleTemp, "ProTracker 2 clone v%s - \"mod.%s\"", PROG_VER_STR, modEntry->head.moduleTitle); |
| 141 | 139 | else |
| 142 | 140 | sprintf(titleTemp, "ProTracker 2 clone v%s - \"%s.mod\"", PROG_VER_STR, modEntry->head.moduleTitle); |
| @@ -146,21 +144,21 @@ void updateWindowTitle(bool modified) · 3 unmodified lines | ||
| 146 | 144 | { |
| 147 | 145 | if (modified) |
| 148 | 146 | { |
| 149 | − if (ptConfig.modDot) | |
| 147 | + if (config.modDot) | |
| 150 | 148 | sprintf(titleTemp, "ProTracker 2 clone v%s - \"mod.untitled\" (unsaved)", PROG_VER_STR); |
| 151 | 149 | else |
| 152 | 150 | sprintf(titleTemp, "ProTracker 2 clone v%s - \"untitled.mod\" (unsaved)", PROG_VER_STR); |
| 153 | 151 | } |
| 154 | 152 | else |
| 155 | 153 | { |
| 156 | − if (ptConfig.modDot) | |
| 154 | + if (config.modDot) | |
| 157 | 155 | sprintf(titleTemp, "ProTracker 2 clone v%s - \"mod.untitled\"", PROG_VER_STR); |
| 158 | 156 | else |
| 159 | 157 | sprintf(titleTemp, "ProTracker 2 clone v%s - \"untitled.mod\"", PROG_VER_STR); |
| 160 | 158 | } |
| 161 | 159 | } |
| 162 | 160 | |
| 163 | − SDL_SetWindowTitle(window, titleTemp); | |
| 161 | + SDL_SetWindowTitle(video.window, titleTemp); | |
| 164 | 162 | } |
| 165 | 163 | |
| 166 | 164 | void recalcChordLength(void) |
| @@ -32,8 +32,6 @@ extern bool windowsKeyIsDown; · 31 unmodified lines | ||
| 32 | 32 | extern HHOOK g_hKeyboardHook; |
| 33 | 33 | #endif |
| 34 | 34 | |
| 35 | −extern SDL_Window *window; | |
| 36 | − | |
| 37 | 35 | void movePatCurPrevCh(void); |
| 38 | 36 | void movePatCurNextCh(void); |
| 39 | 37 | void movePatCurRight(void); |
| @@ -58,14 +56,14 @@ void readKeyModifiers(void) · 18 unmodified lines | ||
| 58 | 56 | |
| 59 | 57 | modState = SDL_GetModState(); |
| 60 | 58 | |
| 61 | − input.keyb.leftCtrlPressed = (modState & KMOD_LCTRL) ? true : false; | |
| 62 | − input.keyb.leftAltPressed = (modState & KMOD_LALT) ? true : false; | |
| 63 | − input.keyb.shiftPressed = (modState & (KMOD_LSHIFT + KMOD_RSHIFT)) ? true : false; | |
| 59 | + keyb.leftCtrlPressed = (modState & KMOD_LCTRL) ? true : false; | |
| 60 | + keyb.leftAltPressed = (modState & KMOD_LALT) ? true : false; | |
| 61 | + keyb.shiftPressed = (modState & (KMOD_LSHIFT + KMOD_RSHIFT)) ? true : false; | |
| 64 | 62 | #ifdef __APPLE__ |
| 65 | − input.keyb.leftCommandPressed = (modState & KMOD_LGUI) ? true : false; | |
| 63 | + keyb.leftCommandPressed = (modState & KMOD_LGUI) ? true : false; | |
| 66 | 64 | #endif |
| 67 | 65 | #ifndef _WIN32 // MS Windows: handled in lowLevelKeyboardProc |
| 68 | − input.keyb.leftAmigaPressed = (modState & KMOD_LGUI) ? true : false; | |
| 66 | + keyb.leftAmigaPressed = (modState & KMOD_LGUI) ? true : false; | |
| 69 | 67 | #endif |
| 70 | 68 | } |
| 71 | 69 | |
| @@ -88,7 +86,7 @@ LRESULT CALLBACK lowLevelKeyboardProc(int32_t nCode, WPARAM wParam, LPARAM lPara · 16 unmodified lines | ||
| 88 | 86 | case WM_KEYUP: |
| 89 | 87 | case WM_KEYDOWN: |
| 90 | 88 | { |
| 91 | − bEatKeystroke = (SDL_GetWindowFlags(window) & SDL_WINDOW_INPUT_FOCUS) && (p->vkCode == VK_LWIN || p->vkCode == VK_NUMLOCK); | |
| 89 | + bEatKeystroke = (SDL_GetWindowFlags(video.window) & SDL_WINDOW_INPUT_FOCUS) && (p->vkCode == VK_LWIN || p->vkCode == VK_NUMLOCK); | |
| 92 | 90 | |
| 93 | 91 | if (bEatKeystroke) |
| 94 | 92 | { |
| @@ -109,7 +107,7 @@ LRESULT CALLBACK lowLevelKeyboardProc(int32_t nCode, WPARAM wParam, LPARAM lPara · 14 unmodified lines | ||
| 109 | 107 | else if (!windowsKeyIsDown) |
| 110 | 108 | { |
| 111 | 109 | windowsKeyIsDown = true; |
| 112 | − input.keyb.leftAmigaPressed = true; | |
| 110 | + keyb.leftAmigaPressed = true; | |
| 113 | 111 | |
| 114 | 112 | memset(&inputEvent, 0, sizeof (SDL_Event)); |
| 115 | 113 | inputEvent.type = SDL_KEYDOWN; |
| @@ -136,7 +134,7 @@ LRESULT CALLBACK lowLevelKeyboardProc(int32_t nCode, WPARAM wParam, LPARAM lPara · 20 unmodified lines | ||
| 136 | 134 | else |
| 137 | 135 | { |
| 138 | 136 | windowsKeyIsDown = false; |
| 139 | − input.keyb.leftAmigaPressed = false; | |
| 137 | + keyb.leftAmigaPressed = false; | |
| 140 | 138 | |
| 141 | 139 | memset(&inputEvent, 0, sizeof (SDL_Event)); |
| 142 | 140 | inputEvent.type = SDL_KEYUP; |
| @@ -329,11 +327,11 @@ void keyUpHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 186 unmodified lines | ||
| 329 | 327 | |
| 330 | 328 | if (scancode == SDL_SCANCODE_KP_PLUS) |
| 331 | 329 | { |
| 332 | − input.keyb.keypadEnterPressed = false; | |
| 330 | + keyb.keypadEnterPressed = false; | |
| 333 | 331 | } |
| 334 | 332 | |
| 335 | − if (scancode == input.keyb.lastRepKey) | |
| 336 | − input.keyb.lastRepKey = SDL_SCANCODE_UNKNOWN; | |
| 333 | + if (scancode == keyb.lastRepKey) | |
| 334 | + keyb.lastRepKey = SDL_SCANCODE_UNKNOWN; | |
| 337 | 335 | |
| 338 | 336 | switch (scancode) |
| 339 | 337 | { |
| @@ -353,10 +351,10 @@ void keyUpHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 13 unmodified lines | ||
| 353 | 351 | |
| 354 | 352 | default: |
| 355 | 353 | { |
| 356 | − input.keyb.repeatKey = false; | |
| 357 | − input.keyb.delayKey = false; | |
| 358 | − input.keyb.repeatFrac = 0; | |
| 359 | − input.keyb.delayCounter = 0; | |
| 354 | + keyb.repeatKey = false; | |
| 355 | + keyb.delayKey = false; | |
| 356 | + keyb.repeatFrac = 0; | |
| 357 | + keyb.delayCounter = 0; | |
| 360 | 358 | } |
| 361 | 359 | break; |
| 362 | 360 | } |
| @@ -392,17 +390,17 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 29 unmodified lines | ||
| 392 | 390 | } |
| 393 | 391 | |
| 394 | 392 | // kludge to allow certain repeat-keys to use custom repeat/delay values |
| 395 | − if (editor.repeatKeyFlag && input.keyb.repeatKey && scancode == input.keyb.lastRepKey && | |
| 396 | − (input.keyb.leftAltPressed || input.keyb.leftAmigaPressed || input.keyb.leftCtrlPressed)) | |
| 393 | + if (editor.repeatKeyFlag && keyb.repeatKey && scancode == keyb.lastRepKey && | |
| 394 | + (keyb.leftAltPressed || keyb.leftAmigaPressed || keyb.leftCtrlPressed)) | |
| 397 | 395 | { |
| 398 | 396 | return; |
| 399 | 397 | } |
| 400 | 398 | |
| 401 | 399 | if (scancode == SDL_SCANCODE_KP_PLUS) |
| 402 | − input.keyb.keypadEnterPressed = true; | |
| 400 | + keyb.keypadEnterPressed = true; | |
| 403 | 401 | |
| 404 | 402 | // TOGGLE FULLSCREEN (should always react) |
| 405 | − if (scancode == SDL_SCANCODE_F11 && !input.keyb.leftAltPressed) | |
| 403 | + if (scancode == SDL_SCANCODE_F11 && !keyb.leftAltPressed) | |
| 406 | 404 | { |
| 407 | 405 | toggleFullScreen(); |
| 408 | 406 | |
| @@ -428,23 +426,23 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 19 unmodified lines | ||
| 428 | 426 | if (editor.repeatKeyFlag) |
| 429 | 427 | { |
| 430 | 428 | // if Repeat Flag, repeat all keys |
| 431 | − if (!input.keyb.repeatKey) | |
| 429 | + if (!keyb.repeatKey) | |
| 432 | 430 | { |
| 433 | − input.keyb.repeatCounter = 0; | |
| 434 | − input.keyb.repeatFrac = 0; | |
| 431 | + keyb.repeatCounter = 0; | |
| 432 | + keyb.repeatFrac = 0; | |
| 435 | 433 | } |
| 436 | 434 | |
| 437 | − input.keyb.repeatKey = true; | |
| 438 | − input.keyb.delayKey = true; | |
| 435 | + keyb.repeatKey = true; | |
| 436 | + keyb.delayKey = true; | |
| 439 | 437 | } |
| 440 | 438 | |
| 441 | − input.keyb.repeatCounter = 0; | |
| 442 | − input.keyb.repeatFrac = 0; | |
| 443 | − input.keyb.lastRepKey = scancode; | |
| 439 | + keyb.repeatCounter = 0; | |
| 440 | + keyb.repeatFrac = 0; | |
| 441 | + keyb.lastRepKey = scancode; | |
| 444 | 442 | } |
| 445 | 443 | |
| 446 | 444 | // ENTRY JUMPING IN DISK OP. FILELIST |
| 447 | − if (editor.ui.diskOpScreenShown && input.keyb.shiftPressed && !editor.ui.editTextFlag) | |
| 445 | + if (editor.ui.diskOpScreenShown && keyb.shiftPressed && !editor.ui.editTextFlag) | |
| 448 | 446 | { |
| 449 | 447 | if (keycode >= 32 && keycode <= 126) |
| 450 | 448 | { |
| @@ -472,7 +470,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 21 unmodified lines | ||
| 472 | 470 | { |
| 473 | 471 | if (editor.autoInsFlag) |
| 474 | 472 | { |
| 475 | − if (input.keyb.shiftPressed) | |
| 473 | + if (keyb.shiftPressed) | |
| 476 | 474 | editor.autoInsSlot -= 4; |
| 477 | 475 | else |
| 478 | 476 | editor.autoInsSlot--; |
| @@ -487,7 +485,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 8 unmodified lines | ||
| 487 | 485 | |
| 488 | 486 | case SDL_SCANCODE_BACKSLASH: |
| 489 | 487 | { |
| 490 | − if (input.keyb.leftAltPressed) | |
| 488 | + if (keyb.leftAltPressed) | |
| 491 | 489 | { |
| 492 | 490 | if (handleSpecialKeys(scancode) && editor.currMode != MODE_RECORD) |
| 493 | 491 | modSetPos(DONT_SET_ORDER, (modEntry->currRow + editor.editMoveAdd) & 0x3F); |
| @@ -496,7 +494,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 2 unmodified lines | ||
| 496 | 494 | { |
| 497 | 495 | if (editor.autoInsFlag) |
| 498 | 496 | { |
| 499 | − if (input.keyb.shiftPressed) | |
| 497 | + if (keyb.shiftPressed) | |
| 500 | 498 | editor.autoInsSlot += 4; |
| 501 | 499 | else |
| 502 | 500 | editor.autoInsSlot++; |
| @@ -644,11 +642,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 141 unmodified lines | ||
| 644 | 642 | } |
| 645 | 643 | } |
| 646 | 644 | |
| 647 | − if (!input.keyb.repeatKey) | |
| 648 | − input.keyb.delayCounter = 0; | |
| 645 | + if (!keyb.repeatKey) | |
| 646 | + keyb.delayCounter = 0; | |
| 649 | 647 | |
| 650 | − input.keyb.repeatKey = true; | |
| 651 | − input.keyb.delayKey = true; | |
| 648 | + keyb.repeatKey = true; | |
| 649 | + keyb.delayKey = true; | |
| 652 | 650 | } |
| 653 | 651 | break; |
| 654 | 652 | |
| @@ -681,11 +679,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 26 unmodified lines | ||
| 681 | 679 | modSetPos(DONT_SET_ORDER, modEntry->currRow + 16); |
| 682 | 680 | } |
| 683 | 681 | |
| 684 | − if (!input.keyb.repeatKey) | |
| 685 | − input.keyb.delayCounter = 0; | |
| 682 | + if (!keyb.repeatKey) | |
| 683 | + keyb.delayCounter = 0; | |
| 686 | 684 | |
| 687 | − input.keyb.repeatKey = true; | |
| 688 | − input.keyb.delayKey = true; | |
| 685 | + keyb.repeatKey = true; | |
| 686 | + keyb.delayKey = true; | |
| 689 | 687 | } |
| 690 | 688 | break; |
| 691 | 689 | |
| @@ -745,7 +743,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 53 unmodified lines | ||
| 745 | 743 | |
| 746 | 744 | case SDL_SCANCODE_F12: |
| 747 | 745 | { |
| 748 | − if (input.keyb.leftCtrlPressed) | |
| 746 | + if (keyb.leftCtrlPressed) | |
| 749 | 747 | { |
| 750 | 748 | editor.timingMode ^= 1; |
| 751 | 749 | if (editor.timingMode == TEMPO_MODE_VBLANK) |
| @@ -760,7 +758,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 8 unmodified lines | ||
| 760 | 758 | |
| 761 | 759 | editor.ui.updateSongTiming = true; |
| 762 | 760 | } |
| 763 | − else if (input.keyb.shiftPressed) | |
| 761 | + else if (keyb.shiftPressed) | |
| 764 | 762 | { |
| 765 | 763 | toggleAmigaPanMode(); |
| 766 | 764 | } |
| @@ -783,10 +781,10 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 16 unmodified lines | ||
| 783 | 781 | } |
| 784 | 782 | else |
| 785 | 783 | { |
| 786 | − if (input.keyb.shiftPressed || input.keyb.leftAltPressed || input.keyb.leftCtrlPressed) | |
| 784 | + if (keyb.shiftPressed || keyb.leftAltPressed || keyb.leftCtrlPressed) | |
| 787 | 785 | { |
| 788 | 786 | saveUndo(); |
| 789 | − if (input.keyb.leftAltPressed && !input.keyb.leftCtrlPressed) | |
| 787 | + if (keyb.leftAltPressed && !keyb.leftCtrlPressed) | |
| 790 | 788 | { |
| 791 | 789 | if (modEntry->currRow < 63) |
| 792 | 790 | { |
| @@ -821,7 +819,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 28 unmodified lines | ||
| 821 | 819 | noteSrc = &modEntry->patterns[modEntry->currPattern][((i + 0) * AMIGA_VOICES) + editor.cursor.channel]; |
| 822 | 820 | noteDst = &modEntry->patterns[modEntry->currPattern][((i + 1) * AMIGA_VOICES) + editor.cursor.channel]; |
| 823 | 821 | |
| 824 | − if (input.keyb.leftCtrlPressed) | |
| 822 | + if (keyb.leftCtrlPressed) | |
| 825 | 823 | { |
| 826 | 824 | noteDst->command = noteSrc->command; |
| 827 | 825 | noteDst->param = noteSrc->param; |
| @@ -834,7 +832,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 6 unmodified lines | ||
| 834 | 832 | |
| 835 | 833 | noteDst = &modEntry->patterns[modEntry->currPattern][((i + 1) * AMIGA_VOICES) + editor.cursor.channel]; |
| 836 | 834 | |
| 837 | − if (!input.keyb.leftCtrlPressed) | |
| 835 | + if (!keyb.leftCtrlPressed) | |
| 838 | 836 | { |
| 839 | 837 | noteDst->period = 0; |
| 840 | 838 | noteDst->sample = 0; |
| @@ -903,7 +901,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 62 unmodified lines | ||
| 903 | 901 | } |
| 904 | 902 | else |
| 905 | 903 | { |
| 906 | − if (input.keyb.shiftPressed) | |
| 904 | + if (keyb.shiftPressed) | |
| 907 | 905 | { |
| 908 | 906 | // cut channel and put in buffer |
| 909 | 907 | saveUndo(); |
| @@ -923,7 +921,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 13 unmodified lines | ||
| 923 | 921 | updateWindowTitle(MOD_IS_MODIFIED); |
| 924 | 922 | editor.ui.updatePatternData = true; |
| 925 | 923 | } |
| 926 | − else if (input.keyb.leftAltPressed) | |
| 924 | + else if (keyb.leftAltPressed) | |
| 927 | 925 | { |
| 928 | 926 | // cut pattern and put in buffer |
| 929 | 927 | saveUndo(); |
| @@ -937,7 +935,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 7 unmodified lines | ||
| 937 | 935 | updateWindowTitle(MOD_IS_MODIFIED); |
| 938 | 936 | editor.ui.updatePatternData = true; |
| 939 | 937 | } |
| 940 | − else if (input.keyb.leftCtrlPressed) | |
| 938 | + else if (keyb.leftCtrlPressed) | |
| 941 | 939 | { |
| 942 | 940 | // cut channel commands and put in buffer |
| 943 | 941 | saveUndo(); |
| @@ -967,7 +965,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 23 unmodified lines | ||
| 967 | 965 | } |
| 968 | 966 | else |
| 969 | 967 | { |
| 970 | − if (input.keyb.shiftPressed) | |
| 968 | + if (keyb.shiftPressed) | |
| 971 | 969 | { |
| 972 | 970 | // copy channel to buffer |
| 973 | 971 | |
| @@ -975,14 +973,14 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 1 unmodified line | ||
| 975 | 973 | for (i = 0; i < MOD_ROWS; i++) |
| 976 | 974 | *noteDst++ = modEntry->patterns[modEntry->currPattern][(i * AMIGA_VOICES) + editor.cursor.channel]; |
| 977 | 975 | } |
| 978 | − else if (input.keyb.leftAltPressed) | |
| 976 | + else if (keyb.leftAltPressed) | |
| 979 | 977 | { |
| 980 | 978 | // copy pattern to buffer |
| 981 | 979 | |
| 982 | 980 | memcpy(editor.patternBuffer, modEntry->patterns[modEntry->currPattern], |
| 983 | 981 | sizeof (note_t) * (AMIGA_VOICES * MOD_ROWS)); |
| 984 | 982 | } |
| 985 | − else if (input.keyb.leftCtrlPressed) | |
| 983 | + else if (keyb.leftCtrlPressed) | |
| 986 | 984 | { |
| 987 | 985 | // copy channel commands to buffer |
| 988 | 986 | |
| @@ -1008,7 +1006,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 19 unmodified lines | ||
| 1008 | 1006 | } |
| 1009 | 1007 | else |
| 1010 | 1008 | { |
| 1011 | − if (input.keyb.shiftPressed) | |
| 1009 | + if (keyb.shiftPressed) | |
| 1012 | 1010 | { |
| 1013 | 1011 | // paste channel buffer to channel |
| 1014 | 1012 | saveUndo(); |
| @@ -1020,7 +1018,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 5 unmodified lines | ||
| 1020 | 1018 | updateWindowTitle(MOD_IS_MODIFIED); |
| 1021 | 1019 | editor.ui.updatePatternData = true; |
| 1022 | 1020 | } |
| 1023 | − else if (input.keyb.leftAltPressed) | |
| 1021 | + else if (keyb.leftAltPressed) | |
| 1024 | 1022 | { |
| 1025 | 1023 | // paste pattern buffer to pattern |
| 1026 | 1024 | saveUndo(); |
| @@ -1031,7 +1029,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 4 unmodified lines | ||
| 1031 | 1029 | updateWindowTitle(MOD_IS_MODIFIED); |
| 1032 | 1030 | editor.ui.updatePatternData = true; |
| 1033 | 1031 | } |
| 1034 | − else if (input.keyb.leftCtrlPressed) | |
| 1032 | + else if (keyb.leftCtrlPressed) | |
| 1035 | 1033 | { |
| 1036 | 1034 | // paste channel commands buffer to channel |
| 1037 | 1035 | saveUndo(); |
| @@ -1055,14 +1053,14 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 17 unmodified lines | ||
| 1055 | 1053 | |
| 1056 | 1054 | case SDL_SCANCODE_F6: |
| 1057 | 1055 | { |
| 1058 | − if (input.keyb.shiftPressed) | |
| 1056 | + if (keyb.shiftPressed) | |
| 1059 | 1057 | { |
| 1060 | 1058 | editor.f6Pos = modEntry->currRow; |
| 1061 | 1059 | displayMsg("POSITION SET"); |
| 1062 | 1060 | } |
| 1063 | 1061 | else |
| 1064 | 1062 | { |
| 1065 | − if (input.keyb.leftAltPressed) | |
| 1063 | + if (keyb.leftAltPressed) | |
| 1066 | 1064 | { |
| 1067 | 1065 | editor.playMode = PLAY_MODE_PATTERN; |
| 1068 | 1066 | modPlay(modEntry->currPattern, DONT_SET_ORDER, editor.f6Pos); |
| @@ -1071,7 +1069,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 2 unmodified lines | ||
| 1071 | 1069 | pointerSetMode(POINTER_MODE_PLAY, DO_CARRY); |
| 1072 | 1070 | statusAllRight(); |
| 1073 | 1071 | } |
| 1074 | − else if (input.keyb.leftCtrlPressed) | |
| 1072 | + else if (keyb.leftCtrlPressed) | |
| 1075 | 1073 | { |
| 1076 | 1074 | if (!editor.ui.samplerScreenShown) |
| 1077 | 1075 | { |
| @@ -1083,7 +1081,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 5 unmodified lines | ||
| 1083 | 1081 | statusAllRight(); |
| 1084 | 1082 | } |
| 1085 | 1083 | } |
| 1086 | − else if (input.keyb.leftAmigaPressed) | |
| 1084 | + else if (keyb.leftAmigaPressed) | |
| 1087 | 1085 | { |
| 1088 | 1086 | editor.playMode = PLAY_MODE_NORMAL; |
| 1089 | 1087 | modPlay(DONT_SET_PATTERN, modEntry->currOrder, editor.f6Pos); |
| @@ -1102,14 +1100,14 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1102 | 1100 | |
| 1103 | 1101 | case SDL_SCANCODE_F7: |
| 1104 | 1102 | { |
| 1105 | − if (input.keyb.shiftPressed) | |
| 1103 | + if (keyb.shiftPressed) | |
| 1106 | 1104 | { |
| 1107 | 1105 | editor.f7Pos = modEntry->currRow; |
| 1108 | 1106 | displayMsg("POSITION SET"); |
| 1109 | 1107 | } |
| 1110 | 1108 | else |
| 1111 | 1109 | { |
| 1112 | − if (input.keyb.leftAltPressed) | |
| 1110 | + if (keyb.leftAltPressed) | |
| 1113 | 1111 | { |
| 1114 | 1112 | editor.playMode = PLAY_MODE_PATTERN; |
| 1115 | 1113 | modPlay(modEntry->currPattern, DONT_SET_ORDER, editor.f7Pos); |
| @@ -1118,7 +1116,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 2 unmodified lines | ||
| 1118 | 1116 | pointerSetMode(POINTER_MODE_PLAY, DO_CARRY); |
| 1119 | 1117 | statusAllRight(); |
| 1120 | 1118 | } |
| 1121 | − else if (input.keyb.leftCtrlPressed) | |
| 1119 | + else if (keyb.leftCtrlPressed) | |
| 1122 | 1120 | { |
| 1123 | 1121 | if (!editor.ui.samplerScreenShown) |
| 1124 | 1122 | { |
| @@ -1130,7 +1128,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 5 unmodified lines | ||
| 1130 | 1128 | statusAllRight(); |
| 1131 | 1129 | } |
| 1132 | 1130 | } |
| 1133 | − else if (input.keyb.leftAmigaPressed) | |
| 1131 | + else if (keyb.leftAmigaPressed) | |
| 1134 | 1132 | { |
| 1135 | 1133 | editor.playMode = PLAY_MODE_NORMAL; |
| 1136 | 1134 | modPlay(DONT_SET_PATTERN, modEntry->currOrder, editor.f7Pos); |
| @@ -1149,14 +1147,14 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1149 | 1147 | |
| 1150 | 1148 | case SDL_SCANCODE_F8: |
| 1151 | 1149 | { |
| 1152 | − if (input.keyb.shiftPressed) | |
| 1150 | + if (keyb.shiftPressed) | |
| 1153 | 1151 | { |
| 1154 | 1152 | editor.f8Pos = modEntry->currRow; |
| 1155 | 1153 | displayMsg("POSITION SET"); |
| 1156 | 1154 | } |
| 1157 | 1155 | else |
| 1158 | 1156 | { |
| 1159 | − if (input.keyb.leftAltPressed) | |
| 1157 | + if (keyb.leftAltPressed) | |
| 1160 | 1158 | { |
| 1161 | 1159 | editor.playMode = PLAY_MODE_PATTERN; |
| 1162 | 1160 | modPlay(modEntry->currPattern, DONT_SET_ORDER, editor.f8Pos); |
| @@ -1165,7 +1163,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 2 unmodified lines | ||
| 1165 | 1163 | pointerSetMode(POINTER_MODE_PLAY, DO_CARRY); |
| 1166 | 1164 | statusAllRight(); |
| 1167 | 1165 | } |
| 1168 | − else if (input.keyb.leftCtrlPressed) | |
| 1166 | + else if (keyb.leftCtrlPressed) | |
| 1169 | 1167 | { |
| 1170 | 1168 | if (!editor.ui.samplerScreenShown) |
| 1171 | 1169 | { |
| @@ -1177,7 +1175,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 5 unmodified lines | ||
| 1177 | 1175 | statusAllRight(); |
| 1178 | 1176 | } |
| 1179 | 1177 | } |
| 1180 | − else if (input.keyb.leftAmigaPressed) | |
| 1178 | + else if (keyb.leftAmigaPressed) | |
| 1181 | 1179 | { |
| 1182 | 1180 | editor.playMode = PLAY_MODE_NORMAL; |
| 1183 | 1181 | modPlay(DONT_SET_PATTERN, modEntry->currOrder, editor.f8Pos); |
| @@ -1196,14 +1194,14 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1196 | 1194 | |
| 1197 | 1195 | case SDL_SCANCODE_F9: |
| 1198 | 1196 | { |
| 1199 | − if (input.keyb.shiftPressed) | |
| 1197 | + if (keyb.shiftPressed) | |
| 1200 | 1198 | { |
| 1201 | 1199 | editor.f9Pos = modEntry->currRow; |
| 1202 | 1200 | displayMsg("POSITION SET"); |
| 1203 | 1201 | } |
| 1204 | 1202 | else |
| 1205 | 1203 | { |
| 1206 | − if (input.keyb.leftAltPressed) | |
| 1204 | + if (keyb.leftAltPressed) | |
| 1207 | 1205 | { |
| 1208 | 1206 | editor.playMode = PLAY_MODE_PATTERN; |
| 1209 | 1207 | modPlay(modEntry->currPattern, DONT_SET_ORDER, editor.f9Pos); |
| @@ -1212,7 +1210,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 2 unmodified lines | ||
| 1212 | 1210 | pointerSetMode(POINTER_MODE_PLAY, DO_CARRY); |
| 1213 | 1211 | statusAllRight(); |
| 1214 | 1212 | } |
| 1215 | − else if (input.keyb.leftCtrlPressed) | |
| 1213 | + else if (keyb.leftCtrlPressed) | |
| 1216 | 1214 | { |
| 1217 | 1215 | if (!editor.ui.samplerScreenShown) |
| 1218 | 1216 | { |
| @@ -1224,7 +1222,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 5 unmodified lines | ||
| 1224 | 1222 | statusAllRight(); |
| 1225 | 1223 | } |
| 1226 | 1224 | } |
| 1227 | − else if (input.keyb.leftAmigaPressed) | |
| 1225 | + else if (keyb.leftAmigaPressed) | |
| 1228 | 1226 | { |
| 1229 | 1227 | editor.playMode = PLAY_MODE_NORMAL; |
| 1230 | 1228 | modPlay(DONT_SET_PATTERN, modEntry->currOrder, editor.f9Pos); |
| @@ -1243,14 +1241,14 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1243 | 1241 | |
| 1244 | 1242 | case SDL_SCANCODE_F10: |
| 1245 | 1243 | { |
| 1246 | − if (input.keyb.shiftPressed) | |
| 1244 | + if (keyb.shiftPressed) | |
| 1247 | 1245 | { |
| 1248 | 1246 | editor.f10Pos = modEntry->currRow; |
| 1249 | 1247 | displayMsg("POSITION SET"); |
| 1250 | 1248 | } |
| 1251 | 1249 | else |
| 1252 | 1250 | { |
| 1253 | − if (input.keyb.leftAltPressed) | |
| 1251 | + if (keyb.leftAltPressed) | |
| 1254 | 1252 | { |
| 1255 | 1253 | editor.playMode = PLAY_MODE_PATTERN; |
| 1256 | 1254 | modPlay(modEntry->currPattern, DONT_SET_ORDER, editor.f10Pos); |
| @@ -1259,7 +1257,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 2 unmodified lines | ||
| 1259 | 1257 | pointerSetMode(POINTER_MODE_PLAY, DO_CARRY); |
| 1260 | 1258 | statusAllRight(); |
| 1261 | 1259 | } |
| 1262 | − else if (input.keyb.leftCtrlPressed) | |
| 1260 | + else if (keyb.leftCtrlPressed) | |
| 1263 | 1261 | { |
| 1264 | 1262 | if (!editor.ui.samplerScreenShown) |
| 1265 | 1263 | { |
| @@ -1271,7 +1269,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 5 unmodified lines | ||
| 1271 | 1269 | statusAllRight(); |
| 1272 | 1270 | } |
| 1273 | 1271 | } |
| 1274 | − else if (input.keyb.leftAmigaPressed) | |
| 1272 | + else if (keyb.leftAmigaPressed) | |
| 1275 | 1273 | { |
| 1276 | 1274 | editor.playMode = PLAY_MODE_NORMAL; |
| 1277 | 1275 | modPlay(DONT_SET_PATTERN, modEntry->currOrder, editor.f10Pos); |
| @@ -1290,17 +1288,17 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1290 | 1288 | |
| 1291 | 1289 | case SDL_SCANCODE_F11: |
| 1292 | 1290 | { |
| 1293 | − if (input.keyb.leftAltPressed) | |
| 1291 | + if (keyb.leftAltPressed) | |
| 1294 | 1292 | { |
| 1295 | − ptConfig.realVuMeters ^= 1; | |
| 1296 | − displayMsg(ptConfig.realVuMeters ? "VU-METERS: REAL" : "VU-METERS: FAKE"); | |
| 1293 | + config.realVuMeters ^= 1; | |
| 1294 | + displayMsg(config.realVuMeters ? "VU-METERS: REAL" : "VU-METERS: FAKE"); | |
| 1297 | 1295 | } |
| 1298 | 1296 | } |
| 1299 | 1297 | break; |
| 1300 | 1298 | |
| 1301 | 1299 | case SDL_SCANCODE_TAB: |
| 1302 | 1300 | { |
| 1303 | − if (input.keyb.shiftPressed) | |
| 1301 | + if (keyb.shiftPressed) | |
| 1304 | 1302 | movePatCurPrevCh(); |
| 1305 | 1303 | else |
| 1306 | 1304 | movePatCurNextCh(); |
| @@ -1309,13 +1307,13 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 2 unmodified lines | ||
| 1309 | 1307 | |
| 1310 | 1308 | case SDL_SCANCODE_0: |
| 1311 | 1309 | { |
| 1312 | − if (input.keyb.leftCtrlPressed) | |
| 1310 | + if (keyb.leftCtrlPressed) | |
| 1313 | 1311 | { |
| 1314 | 1312 | editor.editMoveAdd = 0; |
| 1315 | 1313 | displayMsg("EDITSKIP = 0"); |
| 1316 | 1314 | editor.ui.updateTrackerFlags = true; |
| 1317 | 1315 | } |
| 1318 | − else if (input.keyb.shiftPressed) | |
| 1316 | + else if (keyb.shiftPressed) | |
| 1319 | 1317 | { |
| 1320 | 1318 | noteSrc = &modEntry->patterns[modEntry->currPattern][(modEntry->currRow * AMIGA_VOICES) + editor.cursor.channel]; |
| 1321 | 1319 | editor.effectMacros[9] = (noteSrc->command << 8) | noteSrc->param; |
| @@ -1330,23 +1328,23 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 8 unmodified lines | ||
| 1330 | 1328 | |
| 1331 | 1329 | case SDL_SCANCODE_1: |
| 1332 | 1330 | { |
| 1333 | − if (input.keyb.leftAmigaPressed) | |
| 1331 | + if (keyb.leftAmigaPressed) | |
| 1334 | 1332 | { |
| 1335 | 1333 | trackNoteUp(TRANSPOSE_ALL, 0, MOD_ROWS - 1); |
| 1336 | 1334 | } |
| 1337 | − else if (input.keyb.leftCtrlPressed) | |
| 1335 | + else if (keyb.leftCtrlPressed) | |
| 1338 | 1336 | { |
| 1339 | 1337 | editor.editMoveAdd = 1; |
| 1340 | 1338 | displayMsg("EDITSKIP = 1"); |
| 1341 | 1339 | editor.ui.updateTrackerFlags = true; |
| 1342 | 1340 | } |
| 1343 | − else if (input.keyb.shiftPressed) | |
| 1341 | + else if (keyb.shiftPressed) | |
| 1344 | 1342 | { |
| 1345 | 1343 | noteSrc = &modEntry->patterns[modEntry->currPattern][(modEntry->currRow * AMIGA_VOICES) + editor.cursor.channel]; |
| 1346 | 1344 | editor.effectMacros[0] = (noteSrc->command << 8) | noteSrc->param; |
| 1347 | 1345 | displayMsg("COMMAND STORED!"); |
| 1348 | 1346 | } |
| 1349 | − else if (editor.currMode == MODE_IDLE && input.keyb.leftAltPressed) | |
| 1347 | + else if (editor.currMode == MODE_IDLE && keyb.leftAltPressed) | |
| 1350 | 1348 | { |
| 1351 | 1349 | incMulti(0); |
| 1352 | 1350 | } |
| @@ -1359,23 +1357,23 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 6 unmodified lines | ||
| 1359 | 1357 | |
| 1360 | 1358 | case SDL_SCANCODE_2: |
| 1361 | 1359 | { |
| 1362 | − if (input.keyb.leftAmigaPressed) | |
| 1360 | + if (keyb.leftAmigaPressed) | |
| 1363 | 1361 | { |
| 1364 | 1362 | pattNoteUp(TRANSPOSE_ALL); |
| 1365 | 1363 | } |
| 1366 | − else if (input.keyb.leftCtrlPressed) | |
| 1364 | + else if (keyb.leftCtrlPressed) | |
| 1367 | 1365 | { |
| 1368 | 1366 | editor.editMoveAdd = 2; |
| 1369 | 1367 | displayMsg("EDITSKIP = 2"); |
| 1370 | 1368 | editor.ui.updateTrackerFlags = true; |
| 1371 | 1369 | } |
| 1372 | − else if (input.keyb.shiftPressed) | |
| 1370 | + else if (keyb.shiftPressed) | |
| 1373 | 1371 | { |
| 1374 | 1372 | noteSrc = &modEntry->patterns[modEntry->currPattern][(modEntry->currRow * AMIGA_VOICES) + editor.cursor.channel]; |
| 1375 | 1373 | editor.effectMacros[1] = (noteSrc->command << 8) | noteSrc->param; |
| 1376 | 1374 | displayMsg("COMMAND STORED!"); |
| 1377 | 1375 | } |
| 1378 | − else if (editor.currMode == MODE_IDLE && input.keyb.leftAltPressed) | |
| 1376 | + else if (editor.currMode == MODE_IDLE && keyb.leftAltPressed) | |
| 1379 | 1377 | { |
| 1380 | 1378 | incMulti(1); |
| 1381 | 1379 | } |
| @@ -1388,23 +1386,23 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 6 unmodified lines | ||
| 1388 | 1386 | |
| 1389 | 1387 | case SDL_SCANCODE_3: |
| 1390 | 1388 | { |
| 1391 | − if (input.keyb.leftAmigaPressed) | |
| 1389 | + if (keyb.leftAmigaPressed) | |
| 1392 | 1390 | { |
| 1393 | 1391 | trackNoteUp(TRANSPOSE_ALL, 0, MOD_ROWS - 1); |
| 1394 | 1392 | } |
| 1395 | − else if (input.keyb.leftCtrlPressed) | |
| 1393 | + else if (keyb.leftCtrlPressed) | |
| 1396 | 1394 | { |
| 1397 | 1395 | editor.editMoveAdd = 3; |
| 1398 | 1396 | displayMsg("EDITSKIP = 3"); |
| 1399 | 1397 | editor.ui.updateTrackerFlags = true; |
| 1400 | 1398 | } |
| 1401 | − else if (input.keyb.shiftPressed) | |
| 1399 | + else if (keyb.shiftPressed) | |
| 1402 | 1400 | { |
| 1403 | 1401 | noteSrc = &modEntry->patterns[modEntry->currPattern][(modEntry->currRow * AMIGA_VOICES) + editor.cursor.channel]; |
| 1404 | 1402 | editor.effectMacros[2] = (noteSrc->command << 8) | noteSrc->param; |
| 1405 | 1403 | displayMsg("COMMAND STORED!"); |
| 1406 | 1404 | } |
| 1407 | − else if (editor.currMode == MODE_IDLE && input.keyb.leftAltPressed) | |
| 1405 | + else if (editor.currMode == MODE_IDLE && keyb.leftAltPressed) | |
| 1408 | 1406 | { |
| 1409 | 1407 | incMulti(2); |
| 1410 | 1408 | } |
| @@ -1417,23 +1415,23 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 6 unmodified lines | ||
| 1417 | 1415 | |
| 1418 | 1416 | case SDL_SCANCODE_4: |
| 1419 | 1417 | { |
| 1420 | − if (input.keyb.leftAmigaPressed) | |
| 1418 | + if (keyb.leftAmigaPressed) | |
| 1421 | 1419 | { |
| 1422 | 1420 | pattNoteUp(TRANSPOSE_ALL); |
| 1423 | 1421 | } |
| 1424 | − else if (input.keyb.leftCtrlPressed) | |
| 1422 | + else if (keyb.leftCtrlPressed) | |
| 1425 | 1423 | { |
| 1426 | 1424 | editor.editMoveAdd = 4; |
| 1427 | 1425 | displayMsg("EDITSKIP = 4"); |
| 1428 | 1426 | editor.ui.updateTrackerFlags = true; |
| 1429 | 1427 | } |
| 1430 | − else if (input.keyb.shiftPressed) | |
| 1428 | + else if (keyb.shiftPressed) | |
| 1431 | 1429 | { |
| 1432 | 1430 | noteSrc = &modEntry->patterns[modEntry->currPattern][(modEntry->currRow * AMIGA_VOICES) + editor.cursor.channel]; |
| 1433 | 1431 | editor.effectMacros[3] = (noteSrc->command << 8) | noteSrc->param; |
| 1434 | 1432 | displayMsg("COMMAND STORED!"); |
| 1435 | 1433 | } |
| 1436 | − else if (editor.currMode == MODE_IDLE && input.keyb.leftAltPressed) | |
| 1434 | + else if (editor.currMode == MODE_IDLE && keyb.leftAltPressed) | |
| 1437 | 1435 | { |
| 1438 | 1436 | incMulti(3); |
| 1439 | 1437 | } |
| @@ -1446,13 +1444,13 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 6 unmodified lines | ||
| 1446 | 1444 | |
| 1447 | 1445 | case SDL_SCANCODE_5: |
| 1448 | 1446 | { |
| 1449 | − if (input.keyb.leftCtrlPressed) | |
| 1447 | + if (keyb.leftCtrlPressed) | |
| 1450 | 1448 | { |
| 1451 | 1449 | editor.editMoveAdd = 5; |
| 1452 | 1450 | displayMsg("EDITSKIP = 5"); |
| 1453 | 1451 | editor.ui.updateTrackerFlags = true; |
| 1454 | 1452 | } |
| 1455 | − else if (input.keyb.shiftPressed) | |
| 1453 | + else if (keyb.shiftPressed) | |
| 1456 | 1454 | { |
| 1457 | 1455 | noteSrc = &modEntry->patterns[modEntry->currPattern][(modEntry->currRow * AMIGA_VOICES) + editor.cursor.channel]; |
| 1458 | 1456 | editor.effectMacros[4] = (noteSrc->command << 8) | noteSrc->param; |
| @@ -1467,13 +1465,13 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 8 unmodified lines | ||
| 1467 | 1465 | |
| 1468 | 1466 | case SDL_SCANCODE_6: |
| 1469 | 1467 | { |
| 1470 | − if (input.keyb.leftCtrlPressed) | |
| 1468 | + if (keyb.leftCtrlPressed) | |
| 1471 | 1469 | { |
| 1472 | 1470 | editor.editMoveAdd = 6; |
| 1473 | 1471 | displayMsg("EDITSKIP = 6"); |
| 1474 | 1472 | editor.ui.updateTrackerFlags = true; |
| 1475 | 1473 | } |
| 1476 | − else if (input.keyb.shiftPressed) | |
| 1474 | + else if (keyb.shiftPressed) | |
| 1477 | 1475 | { |
| 1478 | 1476 | noteSrc = &modEntry->patterns[modEntry->currPattern][(modEntry->currRow * AMIGA_VOICES) + editor.cursor.channel]; |
| 1479 | 1477 | editor.effectMacros[5] = (noteSrc->command << 8) | noteSrc->param; |
| @@ -1488,13 +1486,13 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 8 unmodified lines | ||
| 1488 | 1486 | |
| 1489 | 1487 | case SDL_SCANCODE_7: |
| 1490 | 1488 | { |
| 1491 | − if (input.keyb.leftCtrlPressed) | |
| 1489 | + if (keyb.leftCtrlPressed) | |
| 1492 | 1490 | { |
| 1493 | 1491 | editor.editMoveAdd = 7; |
| 1494 | 1492 | displayMsg("EDITSKIP = 7"); |
| 1495 | 1493 | editor.ui.updateTrackerFlags = true; |
| 1496 | 1494 | } |
| 1497 | − else if (input.keyb.shiftPressed) | |
| 1495 | + else if (keyb.shiftPressed) | |
| 1498 | 1496 | { |
| 1499 | 1497 | noteSrc = &modEntry->patterns[modEntry->currPattern][(modEntry->currRow * AMIGA_VOICES) + editor.cursor.channel]; |
| 1500 | 1498 | editor.effectMacros[6] = (noteSrc->command << 8) | noteSrc->param; |
| @@ -1509,13 +1507,13 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 8 unmodified lines | ||
| 1509 | 1507 | |
| 1510 | 1508 | case SDL_SCANCODE_8: |
| 1511 | 1509 | { |
| 1512 | − if (input.keyb.leftCtrlPressed) | |
| 1510 | + if (keyb.leftCtrlPressed) | |
| 1513 | 1511 | { |
| 1514 | 1512 | editor.editMoveAdd = 8; |
| 1515 | 1513 | displayMsg("EDITSKIP = 8"); |
| 1516 | 1514 | editor.ui.updateTrackerFlags = true; |
| 1517 | 1515 | } |
| 1518 | − else if (input.keyb.shiftPressed) | |
| 1516 | + else if (keyb.shiftPressed) | |
| 1519 | 1517 | { |
| 1520 | 1518 | noteSrc = &modEntry->patterns[modEntry->currPattern][(modEntry->currRow * AMIGA_VOICES) + editor.cursor.channel]; |
| 1521 | 1519 | editor.effectMacros[7] = (noteSrc->command << 8) | noteSrc->param; |
| @@ -1530,13 +1528,13 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 8 unmodified lines | ||
| 1530 | 1528 | |
| 1531 | 1529 | case SDL_SCANCODE_9: |
| 1532 | 1530 | { |
| 1533 | − if (input.keyb.leftCtrlPressed) | |
| 1531 | + if (keyb.leftCtrlPressed) | |
| 1534 | 1532 | { |
| 1535 | 1533 | editor.editMoveAdd = 9; |
| 1536 | 1534 | displayMsg("EDITSKIP = 9"); |
| 1537 | 1535 | editor.ui.updateTrackerFlags = true; |
| 1538 | 1536 | } |
| 1539 | − else if (input.keyb.shiftPressed) | |
| 1537 | + else if (keyb.shiftPressed) | |
| 1540 | 1538 | { |
| 1541 | 1539 | noteSrc = &modEntry->patterns[modEntry->currPattern][(modEntry->currRow * AMIGA_VOICES) + editor.cursor.channel]; |
| 1542 | 1540 | editor.effectMacros[8] = (noteSrc->command << 8) | noteSrc->param; |
| @@ -1562,7 +1560,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 19 unmodified lines | ||
| 1562 | 1560 | editor.currSample = editor.keypadSampleOffset + 12; |
| 1563 | 1561 | |
| 1564 | 1562 | updateCurrSample(); |
| 1565 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1563 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1566 | 1564 | { |
| 1567 | 1565 | editor.ui.changingDrumPadNote = true; |
| 1568 | 1566 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1581,7 +1579,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1581 | 1579 | editor.currSample = editor.keypadSampleOffset + 13; |
| 1582 | 1580 | |
| 1583 | 1581 | updateCurrSample(); |
| 1584 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1582 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1585 | 1583 | { |
| 1586 | 1584 | editor.ui.changingDrumPadNote = true; |
| 1587 | 1585 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1600,7 +1598,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1600 | 1598 | editor.currSample = editor.keypadSampleOffset + 14; |
| 1601 | 1599 | |
| 1602 | 1600 | updateCurrSample(); |
| 1603 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1601 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1604 | 1602 | { |
| 1605 | 1603 | editor.ui.changingDrumPadNote = true; |
| 1606 | 1604 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1619,7 +1617,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1619 | 1617 | editor.currSample = editor.keypadSampleOffset + 8; |
| 1620 | 1618 | |
| 1621 | 1619 | updateCurrSample(); |
| 1622 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1620 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1623 | 1621 | { |
| 1624 | 1622 | editor.ui.changingDrumPadNote = true; |
| 1625 | 1623 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1638,7 +1636,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1638 | 1636 | editor.currSample = editor.keypadSampleOffset + 9; |
| 1639 | 1637 | |
| 1640 | 1638 | updateCurrSample(); |
| 1641 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1639 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1642 | 1640 | { |
| 1643 | 1641 | editor.ui.changingDrumPadNote = true; |
| 1644 | 1642 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1657,7 +1655,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1657 | 1655 | editor.currSample = editor.keypadSampleOffset + 10; |
| 1658 | 1656 | |
| 1659 | 1657 | updateCurrSample(); |
| 1660 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1658 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1661 | 1659 | { |
| 1662 | 1660 | editor.ui.changingDrumPadNote = true; |
| 1663 | 1661 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1676,7 +1674,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1676 | 1674 | editor.currSample = editor.keypadSampleOffset + 4; |
| 1677 | 1675 | |
| 1678 | 1676 | updateCurrSample(); |
| 1679 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1677 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1680 | 1678 | { |
| 1681 | 1679 | editor.ui.changingDrumPadNote = true; |
| 1682 | 1680 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1695,7 +1693,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1695 | 1693 | editor.currSample = editor.keypadSampleOffset + 5; |
| 1696 | 1694 | |
| 1697 | 1695 | updateCurrSample(); |
| 1698 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1696 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1699 | 1697 | { |
| 1700 | 1698 | editor.ui.changingDrumPadNote = true; |
| 1701 | 1699 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1714,7 +1712,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1714 | 1712 | editor.currSample = editor.keypadSampleOffset + 6; |
| 1715 | 1713 | |
| 1716 | 1714 | updateCurrSample(); |
| 1717 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1715 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1718 | 1716 | { |
| 1719 | 1717 | editor.ui.changingDrumPadNote = true; |
| 1720 | 1718 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1757,7 +1755,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 36 unmodified lines | ||
| 1757 | 1755 | editor.currSample--; |
| 1758 | 1756 | |
| 1759 | 1757 | updateCurrSample(); |
| 1760 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1758 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1761 | 1759 | { |
| 1762 | 1760 | editor.ui.changingDrumPadNote = true; |
| 1763 | 1761 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1782,7 +1780,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 18 unmodified lines | ||
| 1782 | 1780 | editor.currSample = editor.keypadSampleOffset + (0x08 - 1); |
| 1783 | 1781 | |
| 1784 | 1782 | updateCurrSample(); |
| 1785 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1783 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1786 | 1784 | displayErrorMsg("INVALID PAD KEY !"); |
| 1787 | 1785 | |
| 1788 | 1786 | editor.keypadToggle8CFlag ^= 1; |
| @@ -1795,7 +1793,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 6 unmodified lines | ||
| 1795 | 1793 | editor.currSample = editor.keypadSampleOffset + 3; |
| 1796 | 1794 | |
| 1797 | 1795 | updateCurrSample(); |
| 1798 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1796 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1799 | 1797 | { |
| 1800 | 1798 | editor.ui.changingDrumPadNote = true; |
| 1801 | 1799 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1814,7 +1812,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1814 | 1812 | editor.currSample = editor.keypadSampleOffset + 2; |
| 1815 | 1813 | |
| 1816 | 1814 | updateCurrSample(); |
| 1817 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1815 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1818 | 1816 | { |
| 1819 | 1817 | editor.ui.changingDrumPadNote = true; |
| 1820 | 1818 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1833,7 +1831,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1833 | 1831 | editor.currSample = editor.keypadSampleOffset + 1; |
| 1834 | 1832 | |
| 1835 | 1833 | updateCurrSample(); |
| 1836 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1834 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1837 | 1835 | { |
| 1838 | 1836 | editor.ui.changingDrumPadNote = true; |
| 1839 | 1837 | setStatusMessage("SELECT NOTE", NO_CARRY); |
| @@ -1852,7 +1850,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 1852 | 1850 | editor.currSample = editor.keypadSampleOffset + 0; |
| 1853 | 1851 | |
| 1854 | 1852 | updateCurrSample(); |
| 1855 | − if (input.keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1853 | + if (keyb.leftAltPressed && editor.pNoteFlag > 0) | |
| 1856 | 1854 | { |
| 1857 | 1855 | editor.ui.changingDrumPadNote = true; |
| 1858 | 1856 | |
| @@ -1879,15 +1877,15 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 20 unmodified lines | ||
| 1879 | 1877 | |
| 1880 | 1878 | case SDL_SCANCODE_DOWN: |
| 1881 | 1879 | { |
| 1882 | − input.keyb.delayKey = false; | |
| 1883 | − input.keyb.repeatKey = false; | |
| 1880 | + keyb.delayKey = false; | |
| 1881 | + keyb.repeatKey = false; | |
| 1884 | 1882 | |
| 1885 | 1883 | if (editor.ui.diskOpScreenShown) |
| 1886 | 1884 | { |
| 1887 | 1885 | if (editor.diskop.numEntries > DISKOP_LINES) |
| 1888 | 1886 | { |
| 1889 | 1887 | editor.diskop.scrollOffset++; |
| 1890 | − if (input.mouse.rightButtonPressed) // PT quirk: right mouse button speeds up scrolling even on keyb UP/DOWN | |
| 1888 | + if (mouse.rightButtonPressed) // PT quirk: right mouse button speeds up scrolling even on keyb UP/DOWN | |
| 1891 | 1889 | editor.diskop.scrollOffset += 3; |
| 1892 | 1890 | |
| 1893 | 1891 | if (editor.diskop.scrollOffset > editor.diskop.numEntries-DISKOP_LINES) |
| @@ -1896,11 +1894,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 2 unmodified lines | ||
| 1896 | 1894 | editor.ui.updateDiskOpFileList = true; |
| 1897 | 1895 | } |
| 1898 | 1896 | |
| 1899 | − if (!input.keyb.repeatKey) | |
| 1900 | − input.keyb.delayCounter = 0; | |
| 1897 | + if (!keyb.repeatKey) | |
| 1898 | + keyb.delayCounter = 0; | |
| 1901 | 1899 | |
| 1902 | − input.keyb.repeatKey = true; | |
| 1903 | − input.keyb.delayKey = false; | |
| 1900 | + keyb.repeatKey = true; | |
| 1901 | + keyb.delayKey = false; | |
| 1904 | 1902 | } |
| 1905 | 1903 | else if (editor.ui.posEdScreenShown) |
| 1906 | 1904 | { |
| @@ -1913,31 +1911,31 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 6 unmodified lines | ||
| 1913 | 1911 | editor.ui.updatePosEd = true; |
| 1914 | 1912 | } |
| 1915 | 1913 | |
| 1916 | − if (!input.keyb.repeatKey) | |
| 1917 | − input.keyb.delayCounter = 0; | |
| 1914 | + if (!keyb.repeatKey) | |
| 1915 | + keyb.delayCounter = 0; | |
| 1918 | 1916 | |
| 1919 | − input.keyb.repeatKey = true; | |
| 1920 | − input.keyb.delayKey = true; | |
| 1917 | + keyb.repeatKey = true; | |
| 1918 | + keyb.delayKey = true; | |
| 1921 | 1919 | } |
| 1922 | 1920 | else if (!editor.ui.samplerScreenShown) |
| 1923 | 1921 | { |
| 1924 | 1922 | if (editor.currMode != MODE_PLAY && editor.currMode != MODE_RECORD) |
| 1925 | 1923 | modSetPos(DONT_SET_ORDER, (modEntry->currRow + 1) & 0x3F); |
| 1926 | 1924 | |
| 1927 | − input.keyb.repeatKey = true; | |
| 1925 | + keyb.repeatKey = true; | |
| 1928 | 1926 | } |
| 1929 | 1927 | } |
| 1930 | 1928 | break; |
| 1931 | 1929 | |
| 1932 | 1930 | case SDL_SCANCODE_UP: |
| 1933 | 1931 | { |
| 1934 | − input.keyb.delayKey = false; | |
| 1935 | − input.keyb.repeatKey = false; | |
| 1932 | + keyb.delayKey = false; | |
| 1933 | + keyb.repeatKey = false; | |
| 1936 | 1934 | |
| 1937 | 1935 | if (editor.ui.diskOpScreenShown) |
| 1938 | 1936 | { |
| 1939 | 1937 | editor.diskop.scrollOffset--; |
| 1940 | − if (input.mouse.rightButtonPressed) // PT quirk: right mouse button speeds up scrolling even on keyb UP/DOWN | |
| 1938 | + if (mouse.rightButtonPressed) // PT quirk: right mouse button speeds up scrolling even on keyb UP/DOWN | |
| 1941 | 1939 | editor.diskop.scrollOffset -= 3; |
| 1942 | 1940 | |
| 1943 | 1941 | if (editor.diskop.scrollOffset < 0) |
| @@ -1945,11 +1943,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 1 unmodified line | ||
| 1945 | 1943 | |
| 1946 | 1944 | editor.ui.updateDiskOpFileList = true; |
| 1947 | 1945 | |
| 1948 | − if (!input.keyb.repeatKey) | |
| 1949 | − input.keyb.delayCounter = 0; | |
| 1946 | + if (!keyb.repeatKey) | |
| 1947 | + keyb.delayCounter = 0; | |
| 1950 | 1948 | |
| 1951 | − input.keyb.repeatKey = true; | |
| 1952 | − input.keyb.delayKey = false; | |
| 1949 | + keyb.repeatKey = true; | |
| 1950 | + keyb.delayKey = false; | |
| 1953 | 1951 | } |
| 1954 | 1952 | else if (editor.ui.posEdScreenShown) |
| 1955 | 1953 | { |
| @@ -1959,115 +1957,115 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 3 unmodified lines | ||
| 1959 | 1957 | editor.ui.updatePosEd = true; |
| 1960 | 1958 | } |
| 1961 | 1959 | |
| 1962 | − if (!input.keyb.repeatKey) | |
| 1963 | − input.keyb.delayCounter = 0; | |
| 1960 | + if (!keyb.repeatKey) | |
| 1961 | + keyb.delayCounter = 0; | |
| 1964 | 1962 | |
| 1965 | − input.keyb.repeatKey = true; | |
| 1966 | − input.keyb.delayKey = true; | |
| 1963 | + keyb.repeatKey = true; | |
| 1964 | + keyb.delayKey = true; | |
| 1967 | 1965 | } |
| 1968 | 1966 | else if (!editor.ui.samplerScreenShown) |
| 1969 | 1967 | { |
| 1970 | 1968 | if ((editor.currMode != MODE_PLAY) && (editor.currMode != MODE_RECORD)) |
| 1971 | 1969 | modSetPos(DONT_SET_ORDER, (modEntry->currRow - 1) & 0x3F); |
| 1972 | 1970 | |
| 1973 | − input.keyb.repeatKey = true; | |
| 1971 | + keyb.repeatKey = true; | |
| 1974 | 1972 | } |
| 1975 | 1973 | } |
| 1976 | 1974 | break; |
| 1977 | 1975 | |
| 1978 | 1976 | case SDL_SCANCODE_LEFT: |
| 1979 | 1977 | { |
| 1980 | − input.keyb.delayKey = false; | |
| 1981 | − input.keyb.repeatKey = false; | |
| 1978 | + keyb.delayKey = false; | |
| 1979 | + keyb.repeatKey = false; | |
| 1982 | 1980 | |
| 1983 | − if (input.keyb.leftCtrlPressed) | |
| 1981 | + if (keyb.leftCtrlPressed) | |
| 1984 | 1982 | { |
| 1985 | 1983 | sampleDownButton(); |
| 1986 | 1984 | if (editor.repeatKeyFlag) |
| 1987 | 1985 | { |
| 1988 | − input.keyb.delayKey = true; | |
| 1989 | − input.keyb.repeatKey = true; | |
| 1986 | + keyb.delayKey = true; | |
| 1987 | + keyb.repeatKey = true; | |
| 1990 | 1988 | } |
| 1991 | 1989 | } |
| 1992 | − else if (input.keyb.shiftPressed) | |
| 1990 | + else if (keyb.shiftPressed) | |
| 1993 | 1991 | { |
| 1994 | 1992 | if (modEntry->currOrder > 0) |
| 1995 | 1993 | { |
| 1996 | 1994 | modSetPos(modEntry->currOrder - 1, DONT_SET_ROW); |
| 1997 | 1995 | if (editor.repeatKeyFlag) |
| 1998 | 1996 | { |
| 1999 | − input.keyb.delayKey = true; | |
| 2000 | − input.keyb.repeatKey = true; | |
| 1997 | + keyb.delayKey = true; | |
| 1998 | + keyb.repeatKey = true; | |
| 2001 | 1999 | } |
| 2002 | 2000 | } |
| 2003 | 2001 | } |
| 2004 | − else if (input.keyb.leftAltPressed) | |
| 2002 | + else if (keyb.leftAltPressed) | |
| 2005 | 2003 | { |
| 2006 | 2004 | decPatt(); |
| 2007 | 2005 | if (editor.repeatKeyFlag) |
| 2008 | 2006 | { |
| 2009 | − input.keyb.delayKey = true; | |
| 2010 | − input.keyb.repeatKey = true; | |
| 2007 | + keyb.delayKey = true; | |
| 2008 | + keyb.repeatKey = true; | |
| 2011 | 2009 | } |
| 2012 | 2010 | } |
| 2013 | 2011 | else |
| 2014 | 2012 | { |
| 2015 | 2013 | movePatCurLeft(); |
| 2016 | − input.keyb.repeatKey = true; | |
| 2014 | + keyb.repeatKey = true; | |
| 2017 | 2015 | } |
| 2018 | 2016 | } |
| 2019 | 2017 | break; |
| 2020 | 2018 | |
| 2021 | 2019 | case SDL_SCANCODE_RIGHT: |
| 2022 | 2020 | { |
| 2023 | − input.keyb.delayKey = false; | |
| 2024 | − input.keyb.repeatKey = false; | |
| 2021 | + keyb.delayKey = false; | |
| 2022 | + keyb.repeatKey = false; | |
| 2025 | 2023 | |
| 2026 | − if (input.keyb.leftCtrlPressed) | |
| 2024 | + if (keyb.leftCtrlPressed) | |
| 2027 | 2025 | { |
| 2028 | 2026 | sampleUpButton(); |
| 2029 | 2027 | if (editor.repeatKeyFlag) |
| 2030 | 2028 | { |
| 2031 | − input.keyb.delayKey = true; | |
| 2032 | − input.keyb.repeatKey = true; | |
| 2029 | + keyb.delayKey = true; | |
| 2030 | + keyb.repeatKey = true; | |
| 2033 | 2031 | } |
| 2034 | 2032 | } |
| 2035 | − else if (input.keyb.shiftPressed) | |
| 2033 | + else if (keyb.shiftPressed) | |
| 2036 | 2034 | { |
| 2037 | 2035 | if (modEntry->currOrder < 126) |
| 2038 | 2036 | { |
| 2039 | 2037 | modSetPos(modEntry->currOrder + 1, DONT_SET_ROW); |
| 2040 | 2038 | if (editor.repeatKeyFlag) |
| 2041 | 2039 | { |
| 2042 | − input.keyb.delayKey = true; | |
| 2043 | − input.keyb.repeatKey = true; | |
| 2040 | + keyb.delayKey = true; | |
| 2041 | + keyb.repeatKey = true; | |
| 2044 | 2042 | } |
| 2045 | 2043 | } |
| 2046 | 2044 | } |
| 2047 | − else if (input.keyb.leftAltPressed) | |
| 2045 | + else if (keyb.leftAltPressed) | |
| 2048 | 2046 | { |
| 2049 | 2047 | incPatt(); |
| 2050 | 2048 | if (editor.repeatKeyFlag) |
| 2051 | 2049 | { |
| 2052 | − input.keyb.delayKey = true; | |
| 2053 | − input.keyb.repeatKey = true; | |
| 2050 | + keyb.delayKey = true; | |
| 2051 | + keyb.repeatKey = true; | |
| 2054 | 2052 | } |
| 2055 | 2053 | } |
| 2056 | 2054 | else |
| 2057 | 2055 | { |
| 2058 | 2056 | movePatCurRight(); |
| 2059 | − input.keyb.repeatKey = true; | |
| 2057 | + keyb.repeatKey = true; | |
| 2060 | 2058 | } |
| 2061 | 2059 | } |
| 2062 | 2060 | break; |
| 2063 | 2061 | |
| 2064 | 2062 | case SDL_SCANCODE_A: |
| 2065 | 2063 | { |
| 2066 | − if (input.keyb.leftAmigaPressed) | |
| 2064 | + if (keyb.leftAmigaPressed) | |
| 2067 | 2065 | { |
| 2068 | 2066 | trackOctaUp(TRANSPOSE_ALL, 0, MOD_ROWS - 1); |
| 2069 | 2067 | } |
| 2070 | − else if (input.keyb.leftCtrlPressed) | |
| 2068 | + else if (keyb.leftCtrlPressed) | |
| 2071 | 2069 | { |
| 2072 | 2070 | if (editor.ui.samplerScreenShown) |
| 2073 | 2071 | { |
| @@ -2075,7 +2073,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 1 unmodified line | ||
| 2075 | 2073 | } |
| 2076 | 2074 | else |
| 2077 | 2075 | { |
| 2078 | − if (input.keyb.shiftPressed) | |
| 2076 | + if (keyb.shiftPressed) | |
| 2079 | 2077 | { |
| 2080 | 2078 | editor.muted[0] = true; |
| 2081 | 2079 | editor.muted[1] = true; |
| @@ -2100,7 +2098,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 18 unmodified lines | ||
| 2100 | 2098 | |
| 2101 | 2099 | case SDL_SCANCODE_B: |
| 2102 | 2100 | { |
| 2103 | − if (input.keyb.leftCtrlPressed) | |
| 2101 | + if (keyb.leftCtrlPressed) | |
| 2104 | 2102 | { |
| 2105 | 2103 | // CTRL+B doesn't change the status message back, so do this: |
| 2106 | 2104 | if (editor.ui.introScreenShown) |
| @@ -2122,7 +2120,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 15 unmodified lines | ||
| 2122 | 2120 | |
| 2123 | 2121 | editor.ui.updateStatusText = true; |
| 2124 | 2122 | } |
| 2125 | − else if (input.keyb.leftAltPressed) | |
| 2123 | + else if (keyb.leftAltPressed) | |
| 2126 | 2124 | { |
| 2127 | 2125 | s = &modEntry->samples[editor.currSample]; |
| 2128 | 2126 | if (s->length == 0) |
| @@ -2145,11 +2143,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 16 unmodified lines | ||
| 2145 | 2143 | |
| 2146 | 2144 | case SDL_SCANCODE_C: |
| 2147 | 2145 | { |
| 2148 | − if (input.keyb.leftAmigaPressed) | |
| 2146 | + if (keyb.leftAmigaPressed) | |
| 2149 | 2147 | { |
| 2150 | 2148 | trackOctaDown(TRANSPOSE_ALL, 0, MOD_ROWS - 1); |
| 2151 | 2149 | } |
| 2152 | − else if (input.keyb.leftCtrlPressed) | |
| 2150 | + else if (keyb.leftCtrlPressed) | |
| 2153 | 2151 | { |
| 2154 | 2152 | if (editor.ui.samplerScreenShown) |
| 2155 | 2153 | { |
| @@ -2184,7 +2182,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 28 unmodified lines | ||
| 2184 | 2182 | } |
| 2185 | 2183 | else |
| 2186 | 2184 | { |
| 2187 | − if (input.keyb.leftAltPressed) | |
| 2185 | + if (keyb.leftAltPressed) | |
| 2188 | 2186 | { |
| 2189 | 2187 | editor.muted[2] ^= 1; // toggle channel 3 |
| 2190 | 2188 | renderMuteButtons(); |
| @@ -2199,17 +2197,17 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 8 unmodified lines | ||
| 2199 | 2197 | |
| 2200 | 2198 | case SDL_SCANCODE_D: |
| 2201 | 2199 | { |
| 2202 | − if (input.keyb.leftAmigaPressed) | |
| 2200 | + if (keyb.leftAmigaPressed) | |
| 2203 | 2201 | { |
| 2204 | 2202 | trackOctaUp(TRANSPOSE_ALL, 0, MOD_ROWS - 1); |
| 2205 | 2203 | } |
| 2206 | − else if (input.keyb.leftCtrlPressed) | |
| 2204 | + else if (keyb.leftCtrlPressed) | |
| 2207 | 2205 | { |
| 2208 | 2206 | saveUndo(); |
| 2209 | 2207 | } |
| 2210 | 2208 | else |
| 2211 | 2209 | { |
| 2212 | − if (input.keyb.leftAltPressed) | |
| 2210 | + if (keyb.leftAltPressed) | |
| 2213 | 2211 | { |
| 2214 | 2212 | if (!editor.ui.posEdScreenShown) |
| 2215 | 2213 | { |
| @@ -2239,11 +2237,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 23 unmodified lines | ||
| 2239 | 2237 | |
| 2240 | 2238 | case SDL_SCANCODE_E: |
| 2241 | 2239 | { |
| 2242 | − if (input.keyb.leftAmigaPressed) | |
| 2240 | + if (keyb.leftAmigaPressed) | |
| 2243 | 2241 | { |
| 2244 | 2242 | trackNoteDown(TRANSPOSE_ALL, 0, MOD_ROWS - 1); |
| 2245 | 2243 | } |
| 2246 | − else if (input.keyb.leftAltPressed) | |
| 2244 | + else if (keyb.leftAltPressed) | |
| 2247 | 2245 | { |
| 2248 | 2246 | if (!editor.ui.diskOpScreenShown && !editor.ui.posEdScreenShown) |
| 2249 | 2247 | { |
| @@ -2255,7 +2253,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 5 unmodified lines | ||
| 2255 | 2253 | renderEditOpScreen(); |
| 2256 | 2254 | } |
| 2257 | 2255 | } |
| 2258 | − else if (input.keyb.leftCtrlPressed) | |
| 2256 | + else if (keyb.leftCtrlPressed) | |
| 2259 | 2257 | { |
| 2260 | 2258 | saveUndo(); |
| 2261 | 2259 | |
| @@ -2290,17 +2288,17 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 28 unmodified lines | ||
| 2290 | 2288 | case SDL_SCANCODE_F: |
| 2291 | 2289 | { |
| 2292 | 2290 | #ifdef __APPLE__ |
| 2293 | − if (input.keyb.leftCommandPressed && input.keyb.leftCtrlPressed) | |
| 2291 | + if (keyb.leftCommandPressed && keyb.leftCtrlPressed) | |
| 2294 | 2292 | { |
| 2295 | 2293 | toggleFullScreen(); |
| 2296 | 2294 | } |
| 2297 | 2295 | else |
| 2298 | 2296 | #endif |
| 2299 | − if (input.keyb.leftAmigaPressed) | |
| 2297 | + if (keyb.leftAmigaPressed) | |
| 2300 | 2298 | { |
| 2301 | 2299 | pattOctaUp(TRANSPOSE_ALL); |
| 2302 | 2300 | } |
| 2303 | − else if (input.keyb.leftCtrlPressed) | |
| 2301 | + else if (keyb.leftCtrlPressed) | |
| 2304 | 2302 | { |
| 2305 | 2303 | toggleLEDFilter(); |
| 2306 | 2304 | |
| @@ -2309,7 +2307,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 2 unmodified lines | ||
| 2309 | 2307 | else |
| 2310 | 2308 | displayMsg("LED FILTER OFF"); |
| 2311 | 2309 | } |
| 2312 | − else if (input.keyb.leftAltPressed) | |
| 2310 | + else if (keyb.leftAltPressed) | |
| 2313 | 2311 | { |
| 2314 | 2312 | s = &modEntry->samples[editor.currSample]; |
| 2315 | 2313 | if (s->length == 0) |
| @@ -2331,7 +2329,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 15 unmodified lines | ||
| 2331 | 2329 | |
| 2332 | 2330 | case SDL_SCANCODE_G: |
| 2333 | 2331 | { |
| 2334 | − if (input.keyb.leftCtrlPressed) | |
| 2332 | + if (keyb.leftCtrlPressed) | |
| 2335 | 2333 | { |
| 2336 | 2334 | editor.ui.askScreenShown = true; |
| 2337 | 2335 | editor.ui.askScreenType = ASK_BOOST_ALL_SAMPLES; |
| @@ -2339,7 +2337,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 1 unmodified line | ||
| 2339 | 2337 | setStatusMessage("BOOST ALL SAMPLES", NO_CARRY); |
| 2340 | 2338 | renderAskDialog(); |
| 2341 | 2339 | } |
| 2342 | − else if (input.keyb.leftAltPressed) // toggle record mode (PT clone and PT2.3E only) | |
| 2340 | + else if (keyb.leftAltPressed) // toggle record mode (PT clone and PT2.3E only) | |
| 2343 | 2341 | { |
| 2344 | 2342 | editor.recordMode ^= 1; |
| 2345 | 2343 | if (editor.recordMode == 0) |
| @@ -2359,7 +2357,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 13 unmodified lines | ||
| 2359 | 2357 | |
| 2360 | 2358 | case SDL_SCANCODE_H: |
| 2361 | 2359 | { |
| 2362 | − if (input.keyb.leftCtrlPressed) | |
| 2360 | + if (keyb.leftCtrlPressed) | |
| 2363 | 2361 | { |
| 2364 | 2362 | if (!editor.blockMarkFlag) |
| 2365 | 2363 | { |
| @@ -2378,7 +2376,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 2378 | 2376 | |
| 2379 | 2377 | case SDL_SCANCODE_I: |
| 2380 | 2378 | { |
| 2381 | − if (input.keyb.leftCtrlPressed) | |
| 2379 | + if (keyb.leftCtrlPressed) | |
| 2382 | 2380 | { |
| 2383 | 2381 | if (!editor.blockBufferFlag) |
| 2384 | 2382 | { |
| @@ -2408,7 +2406,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 23 unmodified lines | ||
| 2408 | 2406 | = editor.blockBuffer[editor.buffFromPos + i]; |
| 2409 | 2407 | } |
| 2410 | 2408 | |
| 2411 | − if (!input.keyb.shiftPressed) | |
| 2409 | + if (!keyb.shiftPressed) | |
| 2412 | 2410 | { |
| 2413 | 2411 | modEntry->currRow += i & 0xFF; |
| 2414 | 2412 | if (modEntry->currRow > 63) |
| @@ -2418,7 +2416,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 3 unmodified lines | ||
| 2418 | 2416 | updateWindowTitle(MOD_IS_MODIFIED); |
| 2419 | 2417 | editor.ui.updatePatternData = true; |
| 2420 | 2418 | } |
| 2421 | − else if (input.keyb.leftAltPressed) | |
| 2419 | + else if (keyb.leftAltPressed) | |
| 2422 | 2420 | { |
| 2423 | 2421 | editor.autoInsFlag ^= 1; |
| 2424 | 2422 | editor.ui.updateTrackerFlags = true; |
| @@ -2432,7 +2430,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 7 unmodified lines | ||
| 2432 | 2430 | |
| 2433 | 2431 | case SDL_SCANCODE_J: |
| 2434 | 2432 | { |
| 2435 | − if (input.keyb.leftCtrlPressed) | |
| 2433 | + if (keyb.leftCtrlPressed) | |
| 2436 | 2434 | { |
| 2437 | 2435 | if (!editor.blockBufferFlag) |
| 2438 | 2436 | { |
| @@ -2466,7 +2464,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 27 unmodified lines | ||
| 2466 | 2464 | j++; |
| 2467 | 2465 | } |
| 2468 | 2466 | |
| 2469 | − if (!input.keyb.shiftPressed) | |
| 2467 | + if (!keyb.shiftPressed) | |
| 2470 | 2468 | { |
| 2471 | 2469 | modEntry->currRow += (editor.buffToPos-editor.buffFromPos) + 1; |
| 2472 | 2470 | if (modEntry->currRow > 63) |
| @@ -2485,7 +2483,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 2485 | 2483 | |
| 2486 | 2484 | case SDL_SCANCODE_K: |
| 2487 | 2485 | { |
| 2488 | − if (input.keyb.leftAltPressed) | |
| 2486 | + if (keyb.leftAltPressed) | |
| 2489 | 2487 | { |
| 2490 | 2488 | for (i = 0; i < MOD_ROWS; i++) |
| 2491 | 2489 | { |
| @@ -2502,12 +2500,12 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 10 unmodified lines | ||
| 2502 | 2500 | updateWindowTitle(MOD_IS_MODIFIED); |
| 2503 | 2501 | editor.ui.updatePatternData = true; |
| 2504 | 2502 | } |
| 2505 | − else if (input.keyb.leftCtrlPressed) | |
| 2503 | + else if (keyb.leftCtrlPressed) | |
| 2506 | 2504 | { |
| 2507 | 2505 | saveUndo(); |
| 2508 | 2506 | |
| 2509 | 2507 | i = modEntry->currRow; |
| 2510 | − if (input.keyb.shiftPressed) | |
| 2508 | + if (keyb.shiftPressed) | |
| 2511 | 2509 | { |
| 2512 | 2510 | // kill to start |
| 2513 | 2511 | while (i >= 0) |
| @@ -2548,7 +2546,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 34 unmodified lines | ||
| 2548 | 2546 | |
| 2549 | 2547 | case SDL_SCANCODE_L: |
| 2550 | 2548 | { |
| 2551 | − if (input.keyb.leftCtrlPressed) | |
| 2549 | + if (keyb.leftCtrlPressed) | |
| 2552 | 2550 | { |
| 2553 | 2551 | if (!editor.blockMarkFlag) |
| 2554 | 2552 | { |
| @@ -2567,15 +2565,15 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 2567 | 2565 | |
| 2568 | 2566 | case SDL_SCANCODE_M: |
| 2569 | 2567 | { |
| 2570 | − if (input.keyb.leftCtrlPressed) | |
| 2568 | + if (keyb.leftCtrlPressed) | |
| 2571 | 2569 | { |
| 2572 | 2570 | editor.multiFlag ^= 1; |
| 2573 | 2571 | editor.ui.updateTrackerFlags = true; |
| 2574 | 2572 | editor.ui.updateKeysText = true; |
| 2575 | 2573 | } |
| 2576 | − else if (input.keyb.leftAltPressed) | |
| 2574 | + else if (keyb.leftAltPressed) | |
| 2577 | 2575 | { |
| 2578 | − if (input.keyb.shiftPressed) | |
| 2576 | + if (keyb.shiftPressed) | |
| 2579 | 2577 | editor.metroChannel = editor.cursor.channel + 1; |
| 2580 | 2578 | else |
| 2581 | 2579 | editor.metroFlag ^= 1; |
| @@ -2591,7 +2589,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 9 unmodified lines | ||
| 2591 | 2589 | |
| 2592 | 2590 | case SDL_SCANCODE_N: |
| 2593 | 2591 | { |
| 2594 | − if (input.keyb.leftCtrlPressed) | |
| 2592 | + if (keyb.leftCtrlPressed) | |
| 2595 | 2593 | { |
| 2596 | 2594 | editor.blockMarkFlag = true; |
| 2597 | 2595 | modEntry->currRow = editor.blockToPos; |
| @@ -2605,7 +2603,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 7 unmodified lines | ||
| 2605 | 2603 | |
| 2606 | 2604 | case SDL_SCANCODE_O: |
| 2607 | 2605 | { |
| 2608 | − if (input.keyb.leftCtrlPressed) | |
| 2606 | + if (keyb.leftCtrlPressed) | |
| 2609 | 2607 | { |
| 2610 | 2608 | // fun fact: this function is broken in PT but I fixed it in my clone |
| 2611 | 2609 | |
| @@ -2642,7 +2640,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 30 unmodified lines | ||
| 2642 | 2640 | |
| 2643 | 2641 | case SDL_SCANCODE_P: |
| 2644 | 2642 | { |
| 2645 | − if (input.keyb.leftCtrlPressed) | |
| 2643 | + if (keyb.leftCtrlPressed) | |
| 2646 | 2644 | { |
| 2647 | 2645 | if (!editor.blockBufferFlag) |
| 2648 | 2646 | { |
| @@ -2667,7 +2665,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 18 unmodified lines | ||
| 2667 | 2665 | j++; |
| 2668 | 2666 | } |
| 2669 | 2667 | |
| 2670 | − if (!input.keyb.shiftPressed) | |
| 2668 | + if (!keyb.shiftPressed) | |
| 2671 | 2669 | { |
| 2672 | 2670 | modEntry->currRow += (editor.buffToPos-editor.buffFromPos) + 1; |
| 2673 | 2671 | if (modEntry->currRow > 63) |
| @@ -2677,7 +2675,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 3 unmodified lines | ||
| 2677 | 2675 | updateWindowTitle(MOD_IS_MODIFIED); |
| 2678 | 2676 | editor.ui.updatePatternData = true; |
| 2679 | 2677 | } |
| 2680 | − else if (input.keyb.leftAltPressed) | |
| 2678 | + else if (keyb.leftAltPressed) | |
| 2681 | 2679 | { |
| 2682 | 2680 | if (!editor.ui.diskOpScreenShown) |
| 2683 | 2681 | { |
| @@ -2702,11 +2700,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 18 unmodified lines | ||
| 2702 | 2700 | |
| 2703 | 2701 | case SDL_SCANCODE_Q: |
| 2704 | 2702 | { |
| 2705 | − if (input.keyb.leftAmigaPressed) | |
| 2703 | + if (keyb.leftAmigaPressed) | |
| 2706 | 2704 | { |
| 2707 | 2705 | trackNoteDown(TRANSPOSE_ALL, 0, MOD_ROWS - 1); |
| 2708 | 2706 | } |
| 2709 | − else if (input.keyb.leftCtrlPressed) | |
| 2707 | + else if (keyb.leftCtrlPressed) | |
| 2710 | 2708 | { |
| 2711 | 2709 | editor.muted[0] = false; |
| 2712 | 2710 | editor.muted[1] = false; |
| @@ -2714,7 +2712,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 1 unmodified line | ||
| 2714 | 2712 | editor.muted[3] = false; |
| 2715 | 2713 | renderMuteButtons(); |
| 2716 | 2714 | } |
| 2717 | − else if (input.keyb.leftAltPressed) | |
| 2715 | + else if (keyb.leftAltPressed) | |
| 2718 | 2716 | { |
| 2719 | 2717 | editor.ui.askScreenShown = true; |
| 2720 | 2718 | editor.ui.askScreenType = ASK_QUIT; |
| @@ -2732,11 +2730,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 11 unmodified lines | ||
| 2732 | 2730 | |
| 2733 | 2731 | case SDL_SCANCODE_R: |
| 2734 | 2732 | { |
| 2735 | − if (input.keyb.leftAmigaPressed) | |
| 2733 | + if (keyb.leftAmigaPressed) | |
| 2736 | 2734 | { |
| 2737 | 2735 | pattNoteDown(TRANSPOSE_ALL); |
| 2738 | 2736 | } |
| 2739 | − else if (input.keyb.leftCtrlPressed) | |
| 2737 | + else if (keyb.leftCtrlPressed) | |
| 2740 | 2738 | { |
| 2741 | 2739 | editor.f6Pos = 0; |
| 2742 | 2740 | editor.f7Pos = 16; |
| @@ -2746,7 +2744,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 3 unmodified lines | ||
| 2746 | 2744 | |
| 2747 | 2745 | displayMsg("POS RESTORED !"); |
| 2748 | 2746 | } |
| 2749 | − else if (input.keyb.leftAltPressed) | |
| 2747 | + else if (keyb.leftAltPressed) | |
| 2750 | 2748 | { |
| 2751 | 2749 | editor.ui.askScreenShown = true; |
| 2752 | 2750 | editor.ui.askScreenType = ASK_RESAMPLE; |
| @@ -2763,7 +2761,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 10 unmodified lines | ||
| 2763 | 2761 | |
| 2764 | 2762 | case SDL_SCANCODE_S: |
| 2765 | 2763 | { |
| 2766 | − if (input.keyb.leftCtrlPressed) | |
| 2764 | + if (keyb.leftCtrlPressed) | |
| 2767 | 2765 | { |
| 2768 | 2766 | // if we're in sample load/save mode, set current dir to modules path |
| 2769 | 2767 | if (editor.diskop.mode == DISKOP_MODE_SMP) |
| @@ -2775,11 +2773,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 5 unmodified lines | ||
| 2775 | 2773 | if (editor.diskop.mode == DISKOP_MODE_SMP) |
| 2776 | 2774 | UNICHAR_CHDIR(editor.samplesPathU); |
| 2777 | 2775 | } |
| 2778 | − else if (input.keyb.leftAmigaPressed) | |
| 2776 | + else if (keyb.leftAmigaPressed) | |
| 2779 | 2777 | { |
| 2780 | 2778 | pattOctaUp(TRANSPOSE_ALL); |
| 2781 | 2779 | } |
| 2782 | − else if (input.keyb.leftAltPressed) | |
| 2780 | + else if (keyb.leftAltPressed) | |
| 2783 | 2781 | { |
| 2784 | 2782 | samplerScreen(); |
| 2785 | 2783 | } |
| @@ -2792,13 +2790,13 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 6 unmodified lines | ||
| 2792 | 2790 | |
| 2793 | 2791 | case SDL_SCANCODE_T: |
| 2794 | 2792 | { |
| 2795 | − if (input.keyb.leftCtrlPressed) | |
| 2793 | + if (keyb.leftCtrlPressed) | |
| 2796 | 2794 | { |
| 2797 | 2795 | editor.swapChannelFlag = true; |
| 2798 | 2796 | pointerSetMode(POINTER_MODE_MSG1, NO_CARRY); |
| 2799 | 2797 | setStatusMessage("SWAP (1/2/3/4) ?", NO_CARRY); |
| 2800 | 2798 | } |
| 2801 | − else if (input.keyb.leftAltPressed) | |
| 2799 | + else if (keyb.leftAltPressed) | |
| 2802 | 2800 | { |
| 2803 | 2801 | toggleTuningTone(); |
| 2804 | 2802 | } |
| @@ -2811,7 +2809,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 6 unmodified lines | ||
| 2811 | 2809 | |
| 2812 | 2810 | case SDL_SCANCODE_U: |
| 2813 | 2811 | { |
| 2814 | − if (input.keyb.leftCtrlPressed) | |
| 2812 | + if (keyb.leftCtrlPressed) | |
| 2815 | 2813 | undoLastChange(); |
| 2816 | 2814 | else |
| 2817 | 2815 | handleEditKeys(scancode, EDIT_NORMAL); |
| @@ -2820,11 +2818,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 2 unmodified lines | ||
| 2820 | 2818 | |
| 2821 | 2819 | case SDL_SCANCODE_V: |
| 2822 | 2820 | { |
| 2823 | − if (input.keyb.leftAmigaPressed) | |
| 2821 | + if (keyb.leftAmigaPressed) | |
| 2824 | 2822 | { |
| 2825 | 2823 | pattOctaDown(TRANSPOSE_ALL); |
| 2826 | 2824 | } |
| 2827 | − else if (input.keyb.leftCtrlPressed) | |
| 2825 | + else if (keyb.leftCtrlPressed) | |
| 2828 | 2826 | { |
| 2829 | 2827 | if (editor.ui.samplerScreenShown) |
| 2830 | 2828 | { |
| @@ -2840,7 +2838,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 9 unmodified lines | ||
| 2840 | 2838 | renderAskDialog(); |
| 2841 | 2839 | } |
| 2842 | 2840 | } |
| 2843 | − else if (input.keyb.leftAltPressed) | |
| 2841 | + else if (keyb.leftAltPressed) | |
| 2844 | 2842 | { |
| 2845 | 2843 | editor.muted[3] ^= 1; // toggle channel 4 |
| 2846 | 2844 | renderMuteButtons(); |
| @@ -2854,11 +2852,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 7 unmodified lines | ||
| 2854 | 2852 | |
| 2855 | 2853 | case SDL_SCANCODE_W: |
| 2856 | 2854 | { |
| 2857 | − if (input.keyb.leftAmigaPressed) | |
| 2855 | + if (keyb.leftAmigaPressed) | |
| 2858 | 2856 | { |
| 2859 | 2857 | pattNoteDown(TRANSPOSE_ALL); |
| 2860 | 2858 | } |
| 2861 | − else if (input.keyb.leftCtrlPressed) | |
| 2859 | + else if (keyb.leftCtrlPressed) | |
| 2862 | 2860 | { |
| 2863 | 2861 | // Polyphonize Block |
| 2864 | 2862 | if (!editor.blockBufferFlag) |
| @@ -2893,7 +2891,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 28 unmodified lines | ||
| 2893 | 2891 | gotoNextMulti(); |
| 2894 | 2892 | } |
| 2895 | 2893 | |
| 2896 | − if (!input.keyb.shiftPressed) | |
| 2894 | + if (!keyb.shiftPressed) | |
| 2897 | 2895 | { |
| 2898 | 2896 | modEntry->currRow += (editor.buffToPos-editor.buffFromPos) + 1; |
| 2899 | 2897 | if (modEntry->currRow > 63) |
| @@ -2912,11 +2910,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 12 unmodified lines | ||
| 2912 | 2910 | |
| 2913 | 2911 | case SDL_SCANCODE_X: |
| 2914 | 2912 | { |
| 2915 | − if (input.keyb.leftAmigaPressed) | |
| 2913 | + if (keyb.leftAmigaPressed) | |
| 2916 | 2914 | { |
| 2917 | 2915 | pattOctaDown(TRANSPOSE_ALL); |
| 2918 | 2916 | } |
| 2919 | − else if (input.keyb.leftCtrlPressed) | |
| 2917 | + else if (keyb.leftCtrlPressed) | |
| 2920 | 2918 | { |
| 2921 | 2919 | if (editor.ui.samplerScreenShown) |
| 2922 | 2920 | { |
| @@ -2963,7 +2961,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 40 unmodified lines | ||
| 2963 | 2961 | } |
| 2964 | 2962 | else |
| 2965 | 2963 | { |
| 2966 | − if (input.keyb.leftAltPressed) | |
| 2964 | + if (keyb.leftAltPressed) | |
| 2967 | 2965 | { |
| 2968 | 2966 | editor.muted[1] ^= 1; // toggle channel 2 |
| 2969 | 2967 | renderMuteButtons(); |
| @@ -2978,7 +2976,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 8 unmodified lines | ||
| 2978 | 2976 | |
| 2979 | 2977 | case SDL_SCANCODE_Y: |
| 2980 | 2978 | { |
| 2981 | − if (input.keyb.leftCtrlPressed) | |
| 2979 | + if (keyb.leftCtrlPressed) | |
| 2982 | 2980 | { |
| 2983 | 2981 | if (!editor.blockMarkFlag) |
| 2984 | 2982 | { |
| @@ -3018,7 +3016,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 33 unmodified lines | ||
| 3018 | 3016 | updateWindowTitle(MOD_IS_MODIFIED); |
| 3019 | 3017 | editor.ui.updatePatternData = true; |
| 3020 | 3018 | } |
| 3021 | − else if (input.keyb.leftAltPressed) | |
| 3019 | + else if (keyb.leftAltPressed) | |
| 3022 | 3020 | { |
| 3023 | 3021 | editor.ui.askScreenShown = true; |
| 3024 | 3022 | editor.ui.askScreenType = ASK_SAVE_ALL_SAMPLES; |
| @@ -3035,11 +3033,11 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 10 unmodified lines | ||
| 3035 | 3033 | |
| 3036 | 3034 | case SDL_SCANCODE_Z: |
| 3037 | 3035 | { |
| 3038 | − if (input.keyb.leftAmigaPressed) | |
| 3036 | + if (keyb.leftAmigaPressed) | |
| 3039 | 3037 | { |
| 3040 | 3038 | trackOctaDown(TRANSPOSE_ALL, 0, MOD_ROWS - 1); |
| 3041 | 3039 | } |
| 3042 | − else if (input.keyb.leftCtrlPressed) | |
| 3040 | + else if (keyb.leftCtrlPressed) | |
| 3043 | 3041 | { |
| 3044 | 3042 | if (editor.ui.samplerScreenShown) |
| 3045 | 3043 | { |
| @@ -3067,7 +3065,7 @@ void keyDownHandler(SDL_Scancode scancode, SDL_Keycode keycode) · 21 unmodified lines | ||
| 3067 | 3065 | displayMsg("EFX RESTORED !"); |
| 3068 | 3066 | } |
| 3069 | 3067 | } |
| 3070 | − else if (input.keyb.leftAltPressed) | |
| 3068 | + else if (keyb.leftAltPressed) | |
| 3071 | 3069 | { |
| 3072 | 3070 | editor.muted[0] ^= 1; // toggle channel 1 |
| 3073 | 3071 | renderMuteButtons(); |
| @@ -3145,16 +3143,16 @@ void handleKeyRepeat(SDL_Scancode scancode) · 71 unmodified lines | ||
| 3145 | 3143 | { |
| 3146 | 3144 | uint8_t repeatNum; |
| 3147 | 3145 | |
| 3148 | − if (!input.keyb.repeatKey || (editor.ui.clearScreenShown || editor.ui.askScreenShown)) | |
| 3146 | + if (!keyb.repeatKey || (editor.ui.clearScreenShown || editor.ui.askScreenShown)) | |
| 3149 | 3147 | { |
| 3150 | − input.keyb.repeatFrac = 0; | |
| 3151 | − input.keyb.repeatCounter = 0; | |
| 3148 | + keyb.repeatFrac = 0; | |
| 3149 | + keyb.repeatCounter = 0; | |
| 3152 | 3150 | return; |
| 3153 | 3151 | } |
| 3154 | 3152 | |
| 3155 | − if (input.keyb.delayKey && input.keyb.delayCounter < KEYB_REPEAT_DELAY) | |
| 3153 | + if (keyb.delayKey && keyb.delayCounter < KEYB_REPEAT_DELAY) | |
| 3156 | 3154 | { |
| 3157 | − input.keyb.delayCounter++; | |
| 3155 | + keyb.delayCounter++; | |
| 3158 | 3156 | return; |
| 3159 | 3157 | } |
| 3160 | 3158 | |
| @@ -3162,9 +3160,9 @@ void handleKeyRepeat(SDL_Scancode scancode) · 1 unmodified line | ||
| 3162 | 3160 | { |
| 3163 | 3161 | case SDL_SCANCODE_PAGEUP: |
| 3164 | 3162 | { |
| 3165 | − if (input.keyb.repeatCounter >= 3) | |
| 3163 | + if (keyb.repeatCounter >= 3) | |
| 3166 | 3164 | { |
| 3167 | − input.keyb.repeatCounter = 0; | |
| 3165 | + keyb.repeatCounter = 0; | |
| 3168 | 3166 | |
| 3169 | 3167 | if (editor.ui.posEdScreenShown) |
| 3170 | 3168 | { |
| @@ -3199,9 +3197,9 @@ void handleKeyRepeat(SDL_Scancode scancode) · 28 unmodified lines | ||
| 3199 | 3197 | |
| 3200 | 3198 | case SDL_SCANCODE_PAGEDOWN: |
| 3201 | 3199 | { |
| 3202 | − if (input.keyb.repeatCounter >= 3) | |
| 3200 | + if (keyb.repeatCounter >= 3) | |
| 3203 | 3201 | { |
| 3204 | − input.keyb.repeatCounter = 0; | |
| 3202 | + keyb.repeatCounter = 0; | |
| 3205 | 3203 | |
| 3206 | 3204 | if (editor.ui.posEdScreenShown) |
| 3207 | 3205 | { |
| @@ -3233,45 +3231,45 @@ void handleKeyRepeat(SDL_Scancode scancode) · 25 unmodified lines | ||
| 3233 | 3231 | { |
| 3234 | 3232 | if (editor.ui.editTextFlag) |
| 3235 | 3233 | { |
| 3236 | − if (input.keyb.repeatCounter >= 4) | |
| 3234 | + if (keyb.repeatCounter >= 4) | |
| 3237 | 3235 | { |
| 3238 | − input.keyb.repeatCounter = 0; | |
| 3236 | + keyb.repeatCounter = 0; | |
| 3239 | 3237 | textCharPrevious(); |
| 3240 | 3238 | } |
| 3241 | 3239 | } |
| 3242 | 3240 | else |
| 3243 | 3241 | { |
| 3244 | − if (input.keyb.leftCtrlPressed) | |
| 3242 | + if (keyb.leftCtrlPressed) | |
| 3245 | 3243 | { |
| 3246 | − if (input.keyb.repeatCounter >= 6) | |
| 3244 | + if (keyb.repeatCounter >= 6) | |
| 3247 | 3245 | { |
| 3248 | − input.keyb.repeatCounter = 0; | |
| 3246 | + keyb.repeatCounter = 0; | |
| 3249 | 3247 | sampleDownButton(); |
| 3250 | 3248 | } |
| 3251 | 3249 | } |
| 3252 | − else if (input.keyb.shiftPressed) | |
| 3250 | + else if (keyb.shiftPressed) | |
| 3253 | 3251 | { |
| 3254 | − if (input.keyb.repeatCounter >= 6) | |
| 3252 | + if (keyb.repeatCounter >= 6) | |
| 3255 | 3253 | { |
| 3256 | − input.keyb.repeatCounter = 0; | |
| 3254 | + keyb.repeatCounter = 0; | |
| 3257 | 3255 | if (modEntry->currOrder > 0) |
| 3258 | 3256 | modSetPos(modEntry->currOrder - 1, DONT_SET_ROW); |
| 3259 | 3257 | } |
| 3260 | 3258 | } |
| 3261 | − else if (input.keyb.leftAltPressed) | |
| 3259 | + else if (keyb.leftAltPressed) | |
| 3262 | 3260 | { |
| 3263 | − if (input.keyb.repeatCounter >= 4) | |
| 3261 | + if (keyb.repeatCounter >= 4) | |
| 3264 | 3262 | { |
| 3265 | − input.keyb.repeatCounter = 0; | |
| 3263 | + keyb.repeatCounter = 0; | |
| 3266 | 3264 | decPatt(); |
| 3267 | 3265 | } |
| 3268 | 3266 | } |
| 3269 | 3267 | else |
| 3270 | 3268 | { |
| 3271 | − if (input.keyb.repeatCounter >= 6) | |
| 3269 | + if (keyb.repeatCounter >= 6) | |
| 3272 | 3270 | { |
| 3273 | − input.keyb.repeatCounter = 0; | |
| 3274 | − if (!input.keyb.shiftPressed && !input.keyb.leftAltPressed && !input.keyb.leftCtrlPressed) | |
| 3271 | + keyb.repeatCounter = 0; | |
| 3272 | + if (!keyb.shiftPressed && !keyb.leftAltPressed && !keyb.leftCtrlPressed) | |
| 3275 | 3273 | movePatCurLeft(); |
| 3276 | 3274 | } |
| 3277 | 3275 | } |
| @@ -3283,45 +3281,45 @@ void handleKeyRepeat(SDL_Scancode scancode) · 5 unmodified lines | ||
| 3283 | 3281 | { |
| 3284 | 3282 | if (editor.ui.editTextFlag) |
| 3285 | 3283 | { |
| 3286 | − if (input.keyb.repeatCounter >= 4) | |
| 3284 | + if (keyb.repeatCounter >= 4) | |
| 3287 | 3285 | { |
| 3288 | − input.keyb.repeatCounter = 0; | |
| 3286 | + keyb.repeatCounter = 0; | |
| 3289 | 3287 | textCharNext(); |
| 3290 | 3288 | } |
| 3291 | 3289 | } |
| 3292 | 3290 | else |
| 3293 | 3291 | { |
| 3294 | − if (input.keyb.leftCtrlPressed) | |
| 3292 | + if (keyb.leftCtrlPressed) | |
| 3295 | 3293 | { |
| 3296 | − if (input.keyb.repeatCounter >= 6) | |
| 3294 | + if (keyb.repeatCounter >= 6) | |
| 3297 | 3295 | { |
| 3298 | − input.keyb.repeatCounter = 0; | |
| 3296 | + keyb.repeatCounter = 0; | |
| 3299 | 3297 | sampleUpButton(); |
| 3300 | 3298 | } |
| 3301 | 3299 | } |
| 3302 | − else if (input.keyb.shiftPressed) | |
| 3300 | + else if (keyb.shiftPressed) | |
| 3303 | 3301 | { |
| 3304 | − if (input.keyb.repeatCounter >= 6) | |
| 3302 | + if (keyb.repeatCounter >= 6) | |
| 3305 | 3303 | { |
| 3306 | − input.keyb.repeatCounter = 0; | |
| 3304 | + keyb.repeatCounter = 0; | |
| 3307 | 3305 | if (modEntry->currOrder < 126) |
| 3308 | 3306 | modSetPos(modEntry->currOrder + 1, DONT_SET_ROW); |
| 3309 | 3307 | } |
| 3310 | 3308 | } |
| 3311 | − else if (input.keyb.leftAltPressed) | |
| 3309 | + else if (keyb.leftAltPressed) | |
| 3312 | 3310 | { |
| 3313 | − if (input.keyb.repeatCounter >= 4) | |
| 3311 | + if (keyb.repeatCounter >= 4) | |
| 3314 | 3312 | { |
| 3315 | − input.keyb.repeatCounter = 0; | |
| 3313 | + keyb.repeatCounter = 0; | |
| 3316 | 3314 | incPatt(); |
| 3317 | 3315 | } |
| 3318 | 3316 | } |
| 3319 | 3317 | else |
| 3320 | 3318 | { |
| 3321 | − if (input.keyb.repeatCounter >= 6) | |
| 3319 | + if (keyb.repeatCounter >= 6) | |
| 3322 | 3320 | { |
| 3323 | − input.keyb.repeatCounter = 0; | |
| 3324 | − if (!input.keyb.shiftPressed && !input.keyb.leftAltPressed && !input.keyb.leftCtrlPressed) | |
| 3321 | + keyb.repeatCounter = 0; | |
| 3322 | + if (!keyb.shiftPressed && !keyb.leftAltPressed && !keyb.leftCtrlPressed) | |
| 3325 | 3323 | movePatCurRight(); |
| 3326 | 3324 | } |
| 3327 | 3325 | } |
| @@ -3333,12 +3331,12 @@ void handleKeyRepeat(SDL_Scancode scancode) · 5 unmodified lines | ||
| 3333 | 3331 | { |
| 3334 | 3332 | if (editor.ui.diskOpScreenShown) |
| 3335 | 3333 | { |
| 3336 | − if (input.keyb.repeatCounter >= 1) | |
| 3334 | + if (keyb.repeatCounter >= 1) | |
| 3337 | 3335 | { |
| 3338 | − input.keyb.repeatCounter = 0; | |
| 3336 | + keyb.repeatCounter = 0; | |
| 3339 | 3337 | |
| 3340 | 3338 | editor.diskop.scrollOffset--; |
| 3341 | − if (input.mouse.rightButtonPressed) // PT quirk: right mouse button speeds up scrolling even on keyb UP/DOWN | |
| 3339 | + if (mouse.rightButtonPressed) // PT quirk: right mouse button speeds up scrolling even on keyb UP/DOWN | |
| 3342 | 3340 | editor.diskop.scrollOffset -= 3; |
| 3343 | 3341 | |
| 3344 | 3342 | if (editor.diskop.scrollOffset < 0) |
| @@ -3349,9 +3347,9 @@ void handleKeyRepeat(SDL_Scancode scancode) · 4 unmodified lines | ||
| 3349 | 3347 | } |
| 3350 | 3348 | else if (editor.ui.posEdScreenShown) |
| 3351 | 3349 | { |
| 3352 | − if (input.keyb.repeatCounter >= 3) | |
| 3350 | + if (keyb.repeatCounter >= 3) | |
| 3353 | 3351 | { |
| 3354 | − input.keyb.repeatCounter = 0; | |
| 3352 | + keyb.repeatCounter = 0; | |
| 3355 | 3353 | if (modEntry->currOrder > 0) |
| 3356 | 3354 | { |
| 3357 | 3355 | modSetPos(modEntry->currOrder - 1, DONT_SET_ROW); |
| @@ -3364,14 +3362,14 @@ void handleKeyRepeat(SDL_Scancode scancode) · 6 unmodified lines | ||
| 3364 | 3362 | if (editor.currMode != MODE_PLAY && editor.currMode != MODE_RECORD) |
| 3365 | 3363 | { |
| 3366 | 3364 | repeatNum = 6; |
| 3367 | − if (input.keyb.leftAltPressed) | |
| 3365 | + if (keyb.leftAltPressed) | |
| 3368 | 3366 | repeatNum = 1; |
| 3369 | − else if (input.keyb.shiftPressed) | |
| 3367 | + else if (keyb.shiftPressed) | |
| 3370 | 3368 | repeatNum = 3; |
| 3371 | 3369 | |
| 3372 | − if (input.keyb.repeatCounter >= repeatNum) | |
| 3370 | + if (keyb.repeatCounter >= repeatNum) | |
| 3373 | 3371 | { |
| 3374 | − input.keyb.repeatCounter = 0; | |
| 3372 | + keyb.repeatCounter = 0; | |
| 3375 | 3373 | modSetPos(DONT_SET_ORDER, (modEntry->currRow - 1) & 0x3F); |
| 3376 | 3374 | } |
| 3377 | 3375 | } |
| @@ -3383,14 +3381,14 @@ void handleKeyRepeat(SDL_Scancode scancode) · 5 unmodified lines | ||
| 3383 | 3381 | { |
| 3384 | 3382 | if (editor.ui.diskOpScreenShown) |
| 3385 | 3383 | { |
| 3386 | − if (input.keyb.repeatCounter >= 1) | |
| 3384 | + if (keyb.repeatCounter >= 1) | |
| 3387 | 3385 | { |
| 3388 | − input.keyb.repeatCounter = 0; | |
| 3386 | + keyb.repeatCounter = 0; | |
| 3389 | 3387 | |
| 3390 | 3388 | if (editor.diskop.numEntries > DISKOP_LINES) |
| 3391 | 3389 | { |
| 3392 | 3390 | editor.diskop.scrollOffset++; |
| 3393 | − if (input.mouse.rightButtonPressed) // PT quirk: right mouse button speeds up scrolling even on keyb UP/DOWN | |
| 3391 | + if (mouse.rightButtonPressed) // PT quirk: right mouse button speeds up scrolling even on keyb UP/DOWN | |
| 3394 | 3392 | editor.diskop.scrollOffset += 3; |
| 3395 | 3393 | |
| 3396 | 3394 | if (editor.diskop.scrollOffset > editor.diskop.numEntries-DISKOP_LINES) |
| @@ -3402,9 +3400,9 @@ void handleKeyRepeat(SDL_Scancode scancode) · 5 unmodified lines | ||
| 3402 | 3400 | } |
| 3403 | 3401 | else if (editor.ui.posEdScreenShown) |
| 3404 | 3402 | { |
| 3405 | − if (input.keyb.repeatCounter >= 3) | |
| 3403 | + if (keyb.repeatCounter >= 3) | |
| 3406 | 3404 | { |
| 3407 | − input.keyb.repeatCounter = 0; | |
| 3405 | + keyb.repeatCounter = 0; | |
| 3408 | 3406 | |
| 3409 | 3407 | if (modEntry->currOrder != modEntry->head.orderCount-1) |
| 3410 | 3408 | { |
| @@ -3421,14 +3419,14 @@ void handleKeyRepeat(SDL_Scancode scancode) · 10 unmodified lines | ||
| 3421 | 3419 | if (editor.currMode != MODE_PLAY && editor.currMode != MODE_RECORD) |
| 3422 | 3420 | { |
| 3423 | 3421 | repeatNum = 6; |
| 3424 | − if (input.keyb.leftAltPressed) | |
| 3422 | + if (keyb.leftAltPressed) | |
| 3425 | 3423 | repeatNum = 1; |
| 3426 | − else if (input.keyb.shiftPressed) | |
| 3424 | + else if (keyb.shiftPressed) | |
| 3427 | 3425 | repeatNum = 3; |
| 3428 | 3426 | |
| 3429 | − if (input.keyb.repeatCounter >= repeatNum) | |
| 3427 | + if (keyb.repeatCounter >= repeatNum) | |
| 3430 | 3428 | { |
| 3431 | − input.keyb.repeatCounter = 0; | |
| 3429 | + keyb.repeatCounter = 0; | |
| 3432 | 3430 | modSetPos(DONT_SET_ORDER, (modEntry->currRow + 1) & 0x3F); |
| 3433 | 3431 | } |
| 3434 | 3432 | } |
| @@ -3441,9 +3439,9 @@ void handleKeyRepeat(SDL_Scancode scancode) · 6 unmodified lines | ||
| 3441 | 3439 | if (editor.ui.editTextFlag) |
| 3442 | 3440 | { |
| 3443 | 3441 | // only repeat backspace while editing texts |
| 3444 | − if (input.keyb.repeatCounter >= 3) | |
| 3442 | + if (keyb.repeatCounter >= 3) | |
| 3445 | 3443 | { |
| 3446 | − input.keyb.repeatCounter = 0; | |
| 3444 | + keyb.repeatCounter = 0; | |
| 3447 | 3445 | keyDownHandler(scancode, 0); |
| 3448 | 3446 | } |
| 3449 | 3447 | } |
| @@ -3456,9 +3454,9 @@ void handleKeyRepeat(SDL_Scancode scancode) · 6 unmodified lines | ||
| 3456 | 3454 | |
| 3457 | 3455 | default: |
| 3458 | 3456 | { |
| 3459 | − if (input.keyb.repeatCounter >= 3) | |
| 3457 | + if (keyb.repeatCounter >= 3) | |
| 3460 | 3458 | { |
| 3461 | − input.keyb.repeatCounter = 0; | |
| 3459 | + keyb.repeatCounter = 0; | |
| 3462 | 3460 | keyDownHandler(scancode, 0); |
| 3463 | 3461 | } |
| 3464 | 3462 | } |
| @@ -3469,11 +3467,11 @@ void handleKeyRepeat(SDL_Scancode scancode) · 4 unmodified lines | ||
| 3469 | 3467 | |
| 3470 | 3468 | const uint64_t keyRepeatDelta = ((uint64_t)AMIGA_PAL_VBLANK_HZ << 32) / VBLANK_HZ; |
| 3471 | 3469 | |
| 3472 | − input.keyb.repeatFrac += keyRepeatDelta; // 32.32 fixed-point counter | |
| 3473 | − if (input.keyb.repeatFrac > 0xFFFFFFFF) | |
| 3470 | + keyb.repeatFrac += keyRepeatDelta; // 32.32 fixed-point counter | |
| 3471 | + if (keyb.repeatFrac > 0xFFFFFFFF) | |
| 3474 | 3472 | { |
| 3475 | − input.keyb.repeatFrac &= 0xFFFFFFFF; | |
| 3476 | − input.keyb.repeatCounter++; | |
| 3473 | + keyb.repeatFrac &= 0xFFFFFFFF; | |
| 3474 | + keyb.repeatCounter++; | |
| 3477 | 3475 | } |
| 3478 | 3476 | } |
| 3479 | 3477 | |
| @@ -4064,11 +4062,11 @@ void handleTextEditInputChar(char textChar) · 584 unmodified lines | ||
| 4064 | 4062 | |
| 4065 | 4063 | updateTextObject(editor.ui.editObject); |
| 4066 | 4064 | |
| 4067 | − if (!input.keyb.repeatKey) | |
| 4068 | − input.keyb.delayCounter = 0; | |
| 4065 | + if (!keyb.repeatKey) | |
| 4066 | + keyb.delayCounter = 0; | |
| 4069 | 4067 | |
| 4070 | − input.keyb.repeatKey = true; | |
| 4071 | − input.keyb.delayKey = true; | |
| 4068 | + keyb.repeatKey = true; | |
| 4069 | + keyb.delayKey = true; | |
| 4072 | 4070 | } |
| 4073 | 4071 | |
| 4074 | 4072 | bool handleTextEditMode(SDL_Scancode scancode) |
| @@ -4119,16 +4117,16 @@ bool handleTextEditMode(SDL_Scancode scancode) · 44 unmodified lines | ||
| 4119 | 4117 | if (editor.ui.editTextFlag) |
| 4120 | 4118 | { |
| 4121 | 4119 | textCharPrevious(); |
| 4122 | − if (!input.keyb.repeatKey) | |
| 4123 | − input.keyb.delayCounter = 0; | |
| 4120 | + if (!keyb.repeatKey) | |
| 4121 | + keyb.delayCounter = 0; | |
| 4124 | 4122 | |
| 4125 | − input.keyb.repeatKey = true; | |
| 4126 | − input.keyb.delayKey = false; | |
| 4123 | + keyb.repeatKey = true; | |
| 4124 | + keyb.delayKey = false; | |
| 4127 | 4125 | } |
| 4128 | 4126 | else |
| 4129 | 4127 | { |
| 4130 | − input.keyb.delayKey = false; | |
| 4131 | − input.keyb.repeatKey = true; | |
| 4128 | + keyb.delayKey = false; | |
| 4129 | + keyb.repeatKey = true; | |
| 4132 | 4130 | } |
| 4133 | 4131 | } |
| 4134 | 4132 | break; |
| @@ -4138,16 +4136,16 @@ bool handleTextEditMode(SDL_Scancode scancode) · 3 unmodified lines | ||
| 4138 | 4136 | if (editor.ui.editTextFlag) |
| 4139 | 4137 | { |
| 4140 | 4138 | textCharNext(); |
| 4141 | − if (!input.keyb.repeatKey) | |
| 4142 | − input.keyb.delayCounter = 0; | |
| 4139 | + if (!keyb.repeatKey) | |
| 4140 | + keyb.delayCounter = 0; | |
| 4143 | 4141 | |
| 4144 | − input.keyb.repeatKey = true; | |
| 4145 | − input.keyb.delayKey = false; | |
| 4142 | + keyb.repeatKey = true; | |
| 4143 | + keyb.delayKey = false; | |
| 4146 | 4144 | } |
| 4147 | 4145 | else |
| 4148 | 4146 | { |
| 4149 | − input.keyb.delayKey = false; | |
| 4150 | − input.keyb.repeatKey = true; | |
| 4147 | + keyb.delayKey = false; | |
| 4148 | + keyb.repeatKey = true; | |
| 4151 | 4149 | } |
| 4152 | 4150 | } |
| 4153 | 4151 | break; |
| @@ -4170,11 +4168,11 @@ bool handleTextEditMode(SDL_Scancode scancode) · 16 unmodified lines | ||
| 4170 | 4168 | if (editor.ui.editObject == PTB_SONGNAME || editor.ui.editObject == PTB_SAMPLENAME) |
| 4171 | 4169 | *editor.ui.textEndPtr = '\0'; |
| 4172 | 4170 | |
| 4173 | − if (!input.keyb.repeatKey) | |
| 4174 | − input.keyb.delayCounter = 0; | |
| 4171 | + if (!keyb.repeatKey) | |
| 4172 | + keyb.delayCounter = 0; | |
| 4175 | 4173 | |
| 4176 | − input.keyb.repeatKey = true; | |
| 4177 | − input.keyb.delayKey = false; | |
| 4174 | + keyb.repeatKey = true; | |
| 4175 | + keyb.delayKey = false; | |
| 4178 | 4176 | |
| 4179 | 4177 | updateTextObject(editor.ui.editObject); |
| 4180 | 4178 | } |
| @@ -4207,11 +4205,11 @@ bool handleTextEditMode(SDL_Scancode scancode) · 26 unmodified lines | ||
| 4207 | 4205 | updateTextObject(editor.ui.editObject); |
| 4208 | 4206 | } |
| 4209 | 4207 | |
| 4210 | − if (!input.keyb.repeatKey) | |
| 4211 | − input.keyb.delayCounter = 0; | |
| 4208 | + if (!keyb.repeatKey) | |
| 4209 | + keyb.delayCounter = 0; | |
| 4212 | 4210 | |
| 4213 | − input.keyb.repeatKey = true; | |
| 4214 | − input.keyb.delayKey = false; | |
| 4211 | + keyb.repeatKey = true; | |
| 4212 | + keyb.delayKey = false; | |
| 4215 | 4213 | } |
| 4216 | 4214 | else |
| 4217 | 4215 | { |
| @@ -4223,10 +4221,10 @@ bool handleTextEditMode(SDL_Scancode scancode) · 5 unmodified lines | ||
| 4223 | 4221 | diskOpSetPath("..", DISKOP_CACHE); |
| 4224 | 4222 | #endif |
| 4225 | 4223 | } |
| 4226 | − else if (input.keyb.shiftPressed || input.keyb.leftAltPressed || input.keyb.leftCtrlPressed) | |
| 4224 | + else if (keyb.shiftPressed || keyb.leftAltPressed || keyb.leftCtrlPressed) | |
| 4227 | 4225 | { |
| 4228 | 4226 | saveUndo(); |
| 4229 | − if (input.keyb.leftAltPressed && !input.keyb.leftCtrlPressed) | |
| 4227 | + if (keyb.leftAltPressed && !keyb.leftCtrlPressed) | |
| 4230 | 4228 | { |
| 4231 | 4229 | if (modEntry->currRow > 0) |
| 4232 | 4230 | { |
| @@ -4259,7 +4257,7 @@ bool handleTextEditMode(SDL_Scancode scancode) · 26 unmodified lines | ||
| 4259 | 4257 | noteSrc = &modEntry->patterns[modEntry->currPattern][((i + 1) * AMIGA_VOICES) + editor.cursor.channel]; |
| 4260 | 4258 | noteDst = &modEntry->patterns[modEntry->currPattern][(i * AMIGA_VOICES) + editor.cursor.channel]; |
| 4261 | 4259 | |
| 4262 | − if (input.keyb.leftCtrlPressed) | |
| 4260 | + if (keyb.leftCtrlPressed) | |
| 4263 | 4261 | { |
| 4264 | 4262 | noteDst->command = noteSrc->command; |
| 4265 | 4263 | noteDst->param = noteSrc->param; |
| @@ -40,13 +40,6 @@ · 39 unmodified lines | ||
| 40 | 40 | |
| 41 | 41 | module_t *modEntry = NULL; // globalized |
| 42 | 42 | |
| 43 | −// accessed by pt_visuals.c | |
| 44 | −uint32_t *pixelBuffer = NULL; | |
| 45 | −SDL_Window *window = NULL; | |
| 46 | −SDL_Renderer *renderer = NULL; | |
| 47 | −SDL_Texture *texture = NULL; | |
| 48 | −// ----------------------------- | |
| 49 | − | |
| 50 | 43 | static bool backupMadeAfterCrash; |
| 51 | 44 | |
| 52 | 45 | #ifdef _WIN32 |
| @@ -73,9 +66,6 @@ static void exceptionHandler(int32_t signal); · 20 unmodified lines | ||
| 73 | 66 | #endif |
| 74 | 67 | #endif |
| 75 | 68 | |
| 76 | −extern bool forceMixerOff; // pt_audio.c | |
| 77 | −extern uint32_t palette[PALETTE_NUM]; // pt_palette.c | |
| 78 | − | |
| 79 | 69 | #ifdef _WIN32 |
| 80 | 70 | static void makeSureDirIsProgramDir(void); |
| 81 | 71 | static void disableWasapi(void); |
| @@ -110,9 +100,6 @@ int main(int argc, char *argv[]) · 28 unmodified lines | ||
| 110 | 100 | #pragma message("WARNING: The SDL2 dev lib is older than ver 2.0.5. You'll get fullscreen mode issues.") |
| 111 | 101 | #endif |
| 112 | 102 | |
| 113 | − cpu.hasSSE = SDL_HasSSE(); | |
| 114 | − cpu.hasSSE2 = SDL_HasSSE2(); | |
| 115 | − | |
| 116 | 103 | // set up crash handler |
| 117 | 104 | #ifndef _DEBUG |
| 118 | 105 | #ifdef _WIN32 |
| @@ -154,14 +141,14 @@ int main(int argc, char *argv[]) · 35 unmodified lines | ||
| 154 | 141 | #endif |
| 155 | 142 | |
| 156 | 143 | #ifdef _WIN32 |
| 157 | − if (!cpu.hasSSE) | |
| 144 | + if (!SDL_HasSSE()) | |
| 158 | 145 | { |
| 159 | − showErrorMsgBox("Your computer's processor doesn't have the SSE instruction set\n" \ | |
| 146 | + showErrorMsgBox("Your computer's processor doesn't have the SSE+SSE2 instruction set\n" \ | |
| 160 | 147 | "which is needed for this program to run. Sorry!"); |
| 161 | 148 | return 0; |
| 162 | 149 | } |
| 163 | 150 | |
| 164 | − if (!cpu.hasSSE2) | |
| 151 | + if (!SDL_HasSSE2()) | |
| 165 | 152 | { |
| 166 | 153 | showErrorMsgBox("Your computer's processor doesn't have the SSE2 instruction set\n" \ |
| 167 | 154 | "which is needed for this program to run. Sorry!"); |
| @@ -170,12 +157,14 @@ int main(int argc, char *argv[]) · 2 unmodified lines | ||
| 170 | 157 | |
| 171 | 158 | setupWin32Usleep(); |
| 172 | 159 | disableWasapi(); // disable problematic WASAPI SDL2 audio driver on Windows (causes clicks/pops sometimes...) |
| 160 | + // 13.03.2020: This is still needed with SDL 2.0.12... | |
| 173 | 161 | #endif |
| 174 | 162 | |
| 175 | 163 | /* SDL 2.0.9 for Windows has a serious bug where you need to initialize the joystick subsystem |
| 176 | 164 | ** (even if you don't use it) or else weird things happen like random stutters, keyboard (rarely) being |
| 177 | 165 | ** reinitialized in Windows and what not. |
| 178 | − ** Ref.: https://bugzilla.libsdl.org/show_bug.cgi?id=4391 */ | |
| 166 | + ** Ref.: https://bugzilla.libsdl.org/show_bug.cgi?id=4391 | |
| 167 | + */ | |
| 179 | 168 | #if defined _WIN32 && SDL_PATCHLEVEL == 9 |
| 180 | 169 | if (SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) != 0) |
| 181 | 170 | #else |
| @@ -190,7 +179,8 @@ int main(int argc, char *argv[]) · 8 unmodified lines | ||
| 190 | 179 | |
| 191 | 180 | /* Text input is started by default in SDL2, turn it off to remove ~2ms spikes per key press. |
| 192 | 181 | ** We manuallay start it again when someone clicks on a text edit box, and stop it when done. |
| 193 | − ** Ref.: https://bugzilla.libsdl.org/show_bug.cgi?id=4166 */ | |
| 182 | + ** Ref.: https://bugzilla.libsdl.org/show_bug.cgi?id=4166 | |
| 183 | + */ | |
| 194 | 184 | SDL_StopTextInput(); |
| 195 | 185 | |
| 196 | 186 | #ifdef __APPLE__ |
| @@ -299,7 +289,7 @@ int main(int argc, char *argv[]) · 102 unmodified lines | ||
| 299 | 289 | fillToVuMetersBgBuffer(); |
| 300 | 290 | updateCursorPos(); |
| 301 | 291 | |
| 302 | − SDL_ShowWindow(window); | |
| 292 | + SDL_ShowWindow(video.window); | |
| 303 | 293 | |
| 304 | 294 | changePathToHome(); // set path to home/user-dir now |
| 305 | 295 | diskOpSetInitPath(); // set path to custom path in config (if present) |
| @@ -313,9 +303,9 @@ int main(int argc, char *argv[]) · 7 unmodified lines | ||
| 313 | 303 | readKeyModifiers(); // set/clear CTRL/ALT/SHIFT/AMIGA key states |
| 314 | 304 | handleInput(); |
| 315 | 305 | updateMouseCounters(); |
| 316 | − handleKeyRepeat(input.keyb.lastRepKey); | |
| 306 | + handleKeyRepeat(keyb.lastRepKey); | |
| 317 | 307 | |
| 318 | − if (!input.mouse.buttonWaiting && editor.ui.sampleMarkingPos == -1 && | |
| 308 | + if (!mouse.buttonWaiting && editor.ui.sampleMarkingPos == -1 && | |
| 319 | 309 | !editor.ui.forceSampleDrag && !editor.ui.forceVolDrag && !editor.ui.forceSampleEdit) |
| 320 | 310 | { |
| 321 | 311 | handleGUIButtonRepeat(); |
| @@ -339,17 +329,27 @@ static void handleInput(void) · 17 unmodified lines | ||
| 339 | 329 | |
| 340 | 330 | while (SDL_PollEvent(&event)) |
| 341 | 331 | { |
| 342 | − if (editor.ui.vsync60HzPresent) | |
| 332 | + if (event.type == SDL_WINDOWEVENT) | |
| 343 | 333 | { |
| 344 | − /* if we minimize the window and vsync is present, vsync is temporarily turned off. | |
| 345 | − ** recalc waitVBL() vars so that it can sleep properly in said mode. */ | |
| 346 | − if (event.type == SDL_WINDOWEVENT && | |
| 347 | − (event.window.event == SDL_WINDOWEVENT_MINIMIZED || event.window.event == SDL_WINDOWEVENT_FOCUS_LOST)) | |
| 334 | + if (event.window.event == SDL_WINDOWEVENT_HIDDEN) | |
| 335 | + video.windowHidden = true; | |
| 336 | + else if (event.window.event == SDL_WINDOWEVENT_SHOWN) | |
| 337 | + video.windowHidden = false; | |
| 338 | + | |
| 339 | + if (video.vsync60HzPresent) | |
| 348 | 340 | { |
| 349 | − setupWaitVBL(); | |
| 341 | + /* if we minimize the window and vsync is present, vsync is temporarily turned off. | |
| 342 | + ** recalc waitVBL() vars so that it can sleep properly in said mode. | |
| 343 | + */ | |
| 344 | + if (event.window.event == SDL_WINDOWEVENT_MINIMIZED || | |
| 345 | + event.window.event == SDL_WINDOWEVENT_FOCUS_LOST) | |
| 346 | + { | |
| 347 | + setupWaitVBL(); | |
| 348 | + } | |
| 350 | 349 | } |
| 351 | 350 | } |
| 352 | 351 | |
| 352 | + | |
| 353 | 353 | #ifdef _WIN32 |
| 354 | 354 | handleSysMsg(event); |
| 355 | 355 | #endif |
| @@ -373,7 +373,7 @@ static void handleInput(void) · 17 unmodified lines | ||
| 373 | 373 | { |
| 374 | 374 | loadDroppedFile(event.drop.file, (uint32_t)strlen(event.drop.file), false, true); |
| 375 | 375 | SDL_free(event.drop.file); |
| 376 | − SDL_RaiseWindow(window); // set window focus | |
| 376 | + SDL_RaiseWindow(video.window); // set window focus | |
| 377 | 377 | } |
| 378 | 378 | if (event.type == SDL_QUIT) |
| 379 | 379 | { |
| @@ -385,7 +385,7 @@ static void handleInput(void) · 5 unmodified lines | ||
| 385 | 385 | } |
| 386 | 386 | else if (event.type == SDL_KEYDOWN) |
| 387 | 387 | { |
| 388 | − if (editor.repeatKeyFlag || input.keyb.lastRepKey != event.key.keysym.scancode) | |
| 388 | + if (editor.repeatKeyFlag || keyb.lastRepKey != event.key.keysym.scancode) | |
| 389 | 389 | keyDownHandler(event.key.keysym.scancode, event.key.keysym.sym); |
| 390 | 390 | } |
| 391 | 391 | else if (event.type == SDL_MOUSEBUTTONUP) |
| @@ -435,9 +435,13 @@ static void handleInput(void) · 43 unmodified lines | ||
| 435 | 435 | static bool initializeVars(void) |
| 436 | 436 | { |
| 437 | 437 | // clear common structs |
| 438 | − memset(&input, 0, sizeof (input)); | |
| 438 | + memset(&keyb, 0, sizeof (keyb)); | |
| 439 | + memset(&mouse, 0, sizeof (mouse)); | |
| 440 | + memset(&video, 0, sizeof (video)); | |
| 439 | 441 | memset(&editor, 0, sizeof (editor)); |
| 440 | − memset(&ptConfig, 0, sizeof (ptConfig)); | |
| 442 | + memset(&config, 0, sizeof (config)); | |
| 443 | + | |
| 444 | + setDefaultPalette(); | |
| 441 | 445 | |
| 442 | 446 | editor.repeatKeyFlag = (SDL_GetModState() & KMOD_CAPS) ? true : false; |
| 443 | 447 | |
| @@ -450,17 +454,17 @@ static bool initializeVars(void) · 6 unmodified lines | ||
| 450 | 454 | if (!allocSamplerVars() || !allocDiskOpVars()) |
| 451 | 455 | goto oom; |
| 452 | 456 | |
| 453 | − ptConfig.defModulesDir = (char *)calloc(PATH_MAX + 1, sizeof (char)); | |
| 454 | − ptConfig.defSamplesDir = (char *)calloc(PATH_MAX + 1, sizeof (char)); | |
| 457 | + config.defModulesDir = (char *)calloc(PATH_MAX + 1, sizeof (char)); | |
| 458 | + config.defSamplesDir = (char *)calloc(PATH_MAX + 1, sizeof (char)); | |
| 455 | 459 | editor.tempSample = (int8_t *)calloc(MAX_SAMPLE_LEN, 1); |
| 456 | 460 | |
| 457 | − if (ptConfig.defModulesDir == NULL || ptConfig.defSamplesDir == NULL || | |
| 461 | + if (config.defModulesDir == NULL || config.defSamplesDir == NULL || | |
| 458 | 462 | editor.tempSample == NULL) |
| 459 | 463 | { |
| 460 | 464 | goto oom; |
| 461 | 465 | } |
| 462 | 466 | |
| 463 | − clearPaulaAndScopes(); | |
| 467 | + turnOffVoices(); | |
| 464 | 468 | |
| 465 | 469 | // set various non-zero values |
| 466 | 470 | editor.vol1 = 100; |
| @@ -519,7 +523,7 @@ static bool initializeVars(void) · 52 unmodified lines | ||
| 519 | 523 | editor.sampleFromDisp = &editor.sampleFrom; |
| 520 | 524 | editor.chordLengthDisp = &editor.chordLength; |
| 521 | 525 | editor.metroChannelDisp = &editor.metroChannel; |
| 522 | − editor.quantizeValueDisp = &ptConfig.quantizeValue; | |
| 526 | + editor.quantizeValueDisp = &config.quantizeValue; | |
| 523 | 527 | |
| 524 | 528 | editor.programRunning = true; |
| 525 | 529 | return true; |
| @@ -535,11 +539,11 @@ static void handleSigTerm(void) · 9 unmodified lines | ||
| 535 | 539 | { |
| 536 | 540 | resetAllScreens(); |
| 537 | 541 | |
| 538 | − if (!editor.fullscreen) | |
| 542 | + if (!video.fullscreen) | |
| 539 | 543 | { |
| 540 | 544 | // de-minimize window and set focus so that the user sees the message box |
| 541 | − SDL_RestoreWindow(window); | |
| 542 | − SDL_RaiseWindow(window); | |
| 545 | + SDL_RestoreWindow(video.window); | |
| 546 | + SDL_RaiseWindow(video.window); | |
| 543 | 547 | } |
| 544 | 548 | |
| 545 | 549 | editor.ui.askScreenShown = true; |
| @@ -725,7 +729,7 @@ static bool instanceAlreadyOpen(void) · 179 unmodified lines | ||
| 725 | 729 | sharedMemBuf = (LPTSTR)MapViewOfFile(oneInstHandle, FILE_MAP_ALL_ACCESS, 0, 0, sizeof (HWND)); |
| 726 | 730 | if (sharedMemBuf != NULL) |
| 727 | 731 | { |
| 728 | − CopyMemory((PVOID)sharedMemBuf, &editor.ui.hWnd, sizeof (HWND)); | |
| 732 | + CopyMemory((PVOID)sharedMemBuf, &video.hWnd, sizeof (HWND)); | |
| 729 | 733 | UnmapViewOfFile(sharedMemBuf); |
| 730 | 734 | sharedMemBuf = NULL; |
| 731 | 735 | } |
| @@ -739,10 +743,10 @@ static bool handleSingleInstancing(int32_t argc, char **argv) · 7 unmodified lines | ||
| 739 | 743 | SDL_SysWMinfo wmInfo; |
| 740 | 744 | |
| 741 | 745 | SDL_VERSION(&wmInfo.version); |
| 742 | − if (!SDL_GetWindowWMInfo(window, &wmInfo)) | |
| 746 | + if (!SDL_GetWindowWMInfo(video.window, &wmInfo)) | |
| 743 | 747 | return false; |
| 744 | 748 | |
| 745 | − editor.ui.hWnd = wmInfo.info.win.window; | |
| 749 | + video.hWnd = wmInfo.info.win.window; | |
| 746 | 750 | if (instanceAlreadyOpen() && argc >= 2 && argv[1][0] != '\0') |
| 747 | 751 | { |
| 748 | 752 | sharedMemBuf = (LPTSTR)MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, sizeof (HWND)); |
| @@ -864,8 +868,8 @@ static void cleanUp(void) // never call this inside the main loop! · 115 unmodified lines | ||
| 864 | 868 | videoClose(); |
| 865 | 869 | freeSprites(); |
| 866 | 870 | |
| 867 | − if (ptConfig.defModulesDir != NULL) free(ptConfig.defModulesDir); | |
| 868 | − if (ptConfig.defSamplesDir != NULL) free(ptConfig.defSamplesDir); | |
| 871 | + if (config.defModulesDir != NULL) free(config.defModulesDir); | |
| 872 | + if (config.defSamplesDir != NULL) free(config.defSamplesDir); | |
| 869 | 873 | if (editor.tempSample != NULL) free(editor.tempSample); |
| 870 | 874 | |
| 871 | 875 | #ifdef _WIN32 |
| @@ -39,8 +39,6 @@ static char oldFullPath[(PATH_MAX * 2) + 2]; · 38 unmodified lines | ||
| 39 | 39 | static uint32_t oldFullPathLen; |
| 40 | 40 | static module_t *tempMod; |
| 41 | 41 | |
| 42 | −extern SDL_Window *window; | |
| 43 | − | |
| 44 | 42 | static MEMFILE *mopen(const uint8_t *src, uint32_t length); |
| 45 | 43 | static void mclose(MEMFILE **buf); |
| 46 | 44 | static int32_t mgetc(MEMFILE *buf); |
| @@ -656,6 +654,7 @@ module_t *modLoad(UNICHAR *fileName) · 609 unmodified lines | ||
| 656 | 654 | { |
| 657 | 655 | // "DFJ SoundTracker II" or later |
| 658 | 656 | |
| 657 | + // TODO: This needs more detection and is NOT correct! | |
| 659 | 658 | if (note->command == 0xD) |
| 660 | 659 | { |
| 661 | 660 | if (veryLateSTKVerFlag) // "DFJ SoundTracker III" or later |
| @@ -806,7 +805,7 @@ bool saveModule(bool checkIfFileExist, bool giveNewFreeFilename) · 144 unmodified lines | ||
| 806 | 805 | |
| 807 | 806 | memset(fileName, 0, sizeof (fileName)); |
| 808 | 807 | |
| 809 | − if (ptConfig.modDot) | |
| 808 | + if (config.modDot) | |
| 810 | 809 | { |
| 811 | 810 | // extension.filename |
| 812 | 811 | if (*modEntry->head.moduleTitle == '\0') |
| @@ -848,7 +847,7 @@ bool saveModule(bool checkIfFileExist, bool giveNewFreeFilename) · 35 unmodified lines | ||
| 848 | 847 | for (uint16_t j = 1; j <= 9999; j++) |
| 849 | 848 | { |
| 850 | 849 | memset(fileName, 0, sizeof (fileName)); |
| 851 | − if (ptConfig.modDot) | |
| 850 | + if (config.modDot) | |
| 852 | 851 | { |
| 853 | 852 | // extension.filename |
| 854 | 853 | if (*modEntry->head.moduleTitle == '\0') |
| @@ -1326,8 +1325,8 @@ void loadDroppedFile(char *fullPath, uint32_t fullPathLen, bool autoPlay, bool s · 471 unmodified lines | ||
| 1326 | 1325 | oldAutoPlay = autoPlay; |
| 1327 | 1326 | |
| 1328 | 1327 | // de-minimize window and set focus so that the user sees the message box |
| 1329 | − SDL_RestoreWindow(window); | |
| 1330 | − SDL_RaiseWindow(window); | |
| 1328 | + SDL_RestoreWindow(video.window); | |
| 1329 | + SDL_RaiseWindow(video.window); | |
| 1331 | 1330 | |
| 1332 | 1331 | showSongUnsavedAskBox(ASK_DISCARD_SONG_DRAGNDROP); |
| 1333 | 1332 | return; |
| @@ -24,8 +24,6 @@ · 23 unmodified lines | ||
| 24 | 24 | #include "pt2_textout.h" |
| 25 | 25 | #include "pt2_scopes.h" |
| 26 | 26 | |
| 27 | −extern bool forceMixerOff; // pt_audio.c | |
| 28 | − | |
| 29 | 27 | static bool posJumpAssert, pBreakFlag, updateUIPositions, modHasBeenPlayed; |
| 30 | 28 | static int8_t pBreakPosition, oldRow, modPattern; |
| 31 | 29 | static uint8_t pattDelTime, setBPMFlag, lowMask = 0xFF, pattDelTime2, oldSpeed; |
| @@ -63,13 +61,14 @@ void doStopIt(void) · 31 unmodified lines | ||
| 63 | 61 | moduleChannel_t *c; |
| 64 | 62 | uint8_t i; |
| 65 | 63 | |
| 64 | + editor.songPlaying = false; | |
| 65 | + | |
| 66 | 66 | resetCachedMixerPeriod(); |
| 67 | 67 | |
| 68 | 68 | pattDelTime = 0; |
| 69 | 69 | pattDelTime2 = 0; |
| 70 | 70 | editor.playMode = PLAY_MODE_NORMAL; |
| 71 | 71 | editor.currMode = MODE_IDLE; |
| 72 | − editor.songPlaying = false; | |
| 73 | 72 | |
| 74 | 73 | pointerSetMode(POINTER_MODE_IDLE, DO_CARRY); |
| 75 | 74 | |
| @@ -919,7 +918,7 @@ static void nextPosition(void) · 843 unmodified lines | ||
| 919 | 918 | modOrder = 0; |
| 920 | 919 | modHasBeenPlayed = true; |
| 921 | 920 | |
| 922 | − if (ptConfig.compoMode) // stop song for music competitions playing | |
| 921 | + if (config.compoMode) // stop song for music competitions playing | |
| 923 | 922 | { |
| 924 | 923 | doStopIt(); |
| 925 | 924 | turnOffVoices(); |
| @@ -1249,6 +1248,10 @@ void modPlay(int16_t patt, int16_t order, int8_t row) · 323 unmodified lines | ||
| 1249 | 1248 | { |
| 1250 | 1249 | uint8_t oldPlayMode, oldMode; |
| 1251 | 1250 | |
| 1251 | + doStopIt(); | |
| 1252 | + turnOffVoices(); | |
| 1253 | + mixerClearSampleCounter(); | |
| 1254 | + | |
| 1252 | 1255 | if (row != -1) |
| 1253 | 1256 | { |
| 1254 | 1257 | if (row >= 0 && row <= 63) |
| @@ -1301,9 +1304,6 @@ void modPlay(int16_t patt, int16_t order, int8_t row) · 46 unmodified lines | ||
| 1301 | 1304 | oldPlayMode = editor.playMode; |
| 1302 | 1305 | oldMode = editor.currMode; |
| 1303 | 1306 | |
| 1304 | − doStopIt(); | |
| 1305 | − turnOffVoices(); | |
| 1306 | − | |
| 1307 | 1307 | editor.playMode = oldPlayMode; |
| 1308 | 1308 | editor.currMode = oldMode; |
| 1309 | 1309 | |
| @@ -1320,8 +1320,6 @@ void modPlay(int16_t patt, int16_t order, int8_t row) · 10 unmodified lines | ||
| 1320 | 1320 | editor.ui.updateSongPattern = true; |
| 1321 | 1321 | editor.ui.updateCurrPattText = true; |
| 1322 | 1322 | } |
| 1323 | − | |
| 1324 | − mixerClearSampleCounter(); | |
| 1325 | 1323 | } |
| 1326 | 1324 | |
| 1327 | 1325 | void clearSong(void) |
| @@ -1438,7 +1436,11 @@ void modFree(void) · 110 unmodified lines | ||
| 1438 | 1436 | if (modEntry == NULL) |
| 1439 | 1437 | return; // not allocated |
| 1440 | 1438 | |
| 1441 | − lockAudio(); | |
| 1439 | + const bool wasLocked = audio.locked; | |
| 1440 | + if (!wasLocked) | |
| 1441 | + lockAudio(); | |
| 1442 | + | |
| 1443 | + turnOffVoices(); | |
| 1442 | 1444 | |
| 1443 | 1445 | for (i = 0; i < MAX_PATTERNS; i++) |
| 1444 | 1446 | { |
| @@ -1447,15 +1449,13 @@ void modFree(void) · 2 unmodified lines | ||
| 1447 | 1449 | } |
| 1448 | 1450 | |
| 1449 | 1451 | if (modEntry->sampleData != NULL) |
| 1450 | − { | |
| 1451 | − clearPaulaAndScopes(); | |
| 1452 | 1452 | free(modEntry->sampleData); |
| 1453 | − } | |
| 1454 | 1453 | |
| 1455 | 1454 | free(modEntry); |
| 1456 | 1455 | modEntry = NULL; |
| 1457 | 1456 | |
| 1458 | − unlockAudio(); | |
| 1457 | + if (!wasLocked) | |
| 1458 | + unlockAudio(); | |
| 1459 | 1459 | } |
| 1460 | 1460 | |
| 1461 | 1461 | void restartSong(void) // for the beginning of MOD2WAV/PAT2SMP |
| @@ -1465,7 +1465,7 @@ void restartSong(void) // for the beginning of MOD2WAV/PAT2SMP · 3 unmodified lines | ||
| 1465 | 1465 | |
| 1466 | 1466 | editor.playMode = PLAY_MODE_NORMAL; |
| 1467 | 1467 | editor.blockMarkFlag = false; |
| 1468 | − forceMixerOff = true; | |
| 1468 | + audio.forceMixerOff = true; | |
| 1469 | 1469 | |
| 1470 | 1470 | modEntry->row = 0; |
| 1471 | 1471 | modEntry->currRow = 0; |
| @@ -1528,5 +1528,5 @@ void resetSong(void) // only call this after storeTempVariables() has been calle · 56 unmodified lines | ||
| 1528 | 1528 | |
| 1529 | 1529 | editor.modTick = 0; |
| 1530 | 1530 | modHasBeenPlayed = false; |
| 1531 | − forceMixerOff = false; | |
| 1531 | + audio.forceMixerOff = false; | |
| 1532 | 1532 | } |
| @@ -25,13 +25,11 @@ · 24 unmodified lines | ||
| 25 | 25 | #include "pt2_keyboard.h" |
| 26 | 26 | |
| 27 | 27 | /* TODO: Move irrelevant routines outta here! Disgusting design! |
| 28 | − * Keep in mind that this was programmed in my early programming days... */ | |
| 28 | +** Keep in mind that this was programmed in my early programming days... | |
| 29 | +**/ | |
| 29 | 30 | |
| 30 | 31 | SDL_Cursor *cursors[NUM_CURSORS]; |
| 31 | 32 | |
| 32 | −extern SDL_Renderer *renderer; | |
| 33 | −extern SDL_Window *window; | |
| 34 | − | |
| 35 | 33 | void edNote1UpButton(void); |
| 36 | 34 | void edNote1DownButton(void); |
| 37 | 35 | void edNote2UpButton(void); |
| @@ -80,11 +78,11 @@ static void pointerSetColor(uint8_t cursorColorIndex) · 42 unmodified lines | ||
| 80 | 78 | { |
| 81 | 79 | assert(cursorColorIndex <= 5); |
| 82 | 80 | |
| 83 | − palette[PAL_MOUSE_1] = cursorColors[cursorColorIndex][0]; | |
| 84 | − palette[PAL_MOUSE_2] = cursorColors[cursorColorIndex][1]; | |
| 85 | − palette[PAL_MOUSE_3] = cursorColors[cursorColorIndex][2]; | |
| 81 | + video.palette[PAL_MOUSE_1] = cursorColors[cursorColorIndex][0]; | |
| 82 | + video.palette[PAL_MOUSE_2] = cursorColors[cursorColorIndex][1]; | |
| 83 | + video.palette[PAL_MOUSE_3] = cursorColors[cursorColorIndex][2]; | |
| 86 | 84 | |
| 87 | − if (ptConfig.hwMouse) | |
| 85 | + if (config.hwMouse) | |
| 88 | 86 | setSystemCursor(cursors[cursorColorIndex]); |
| 89 | 87 | } |
| 90 | 88 | |
| @@ -155,14 +153,15 @@ bool createMouseCursors(void) // creates scaled SDL surfaces for current mouse p · 64 unmodified lines | ||
| 155 | 153 | { |
| 156 | 154 | freeMouseCursors(); |
| 157 | 155 | |
| 158 | − uint8_t scaling = editor.ui.yScale; | |
| 156 | + uint8_t scaleFactor = video.yScale; | |
| 157 | + | |
| 159 | 158 | for (uint32_t i = 0; i < NUM_CURSORS; i++) |
| 160 | 159 | { |
| 161 | − SDL_Surface *surface = SDL_CreateRGBSurface(0, POINTER_W*scaling, POINTER_H*scaling, 32, 0, 0, 0, 0); | |
| 160 | + SDL_Surface *surface = SDL_CreateRGBSurface(0, POINTER_W*scaleFactor, POINTER_H*scaleFactor, 32, 0, 0, 0, 0); | |
| 162 | 161 | if (surface == NULL) |
| 163 | 162 | { |
| 164 | 163 | freeMouseCursors(); |
| 165 | − ptConfig.hwMouse = false; // enable software mouse | |
| 164 | + config.hwMouse = false; // enable software mouse | |
| 166 | 165 | return false; |
| 167 | 166 | } |
| 168 | 167 | |
| @@ -171,9 +170,9 @@ bool createMouseCursors(void) // creates scaled SDL surfaces for current mouse p · 2 unmodified lines | ||
| 171 | 170 | uint32_t color3 = cursorColors[i][2]; |
| 172 | 171 | uint32_t colorkey = 0x12345678; |
| 173 | 172 | |
| 174 | − color1 = SDL_MapRGB(surface->format, R24(color1), G24(color1), B24(color1)); | |
| 175 | − color2 = SDL_MapRGB(surface->format, R24(color2), G24(color2), B24(color2)); | |
| 176 | − color3 = SDL_MapRGB(surface->format, R24(color3), G24(color3), B24(color3)); | |
| 173 | + color1 = SDL_MapRGB(surface->format, R24(color1), G24(color1), B24(color1)); | |
| 174 | + color2 = SDL_MapRGB(surface->format, R24(color2), G24(color2), B24(color2)); | |
| 175 | + color3 = SDL_MapRGB(surface->format, R24(color3), G24(color3), B24(color3)); | |
| 177 | 176 | colorkey = SDL_MapRGB(surface->format, R24(colorkey), G24(colorkey), B24(colorkey)); |
| 178 | 177 | |
| 179 | 178 | SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_NONE); |
| @@ -190,8 +189,8 @@ bool createMouseCursors(void) // creates scaled SDL surfaces for current mouse p · 10 unmodified lines | ||
| 190 | 189 | // blit upscaled cursor to surface |
| 191 | 190 | for (uint32_t y = 0; y < POINTER_H; y++) |
| 192 | 191 | { |
| 193 | − uint32_t *outX = &dstPixels32[(y * scaling) * surface->w]; | |
| 194 | − for (uint32_t yScale = 0; yScale < scaling; yScale++) | |
| 192 | + uint32_t *outX = &dstPixels32[(y * scaleFactor) * surface->w]; | |
| 193 | + for (uint32_t yScale = 0; yScale < scaleFactor; yScale++) | |
| 195 | 194 | { |
| 196 | 195 | for (uint32_t x = 0; x < POINTER_W; x++) |
| 197 | 196 | { |
| @@ -204,11 +203,11 @@ bool createMouseCursors(void) // creates scaled SDL surfaces for current mouse p · 6 unmodified lines | ||
| 204 | 203 | else if (srcPix == PAL_MOUSE_2) pixel = color2; |
| 205 | 204 | else if (srcPix == PAL_MOUSE_3) pixel = color3; |
| 206 | 205 | |
| 207 | − for (uint32_t xScale = 0; xScale < scaling; xScale++) | |
| 206 | + for (uint32_t xScale = 0; xScale < scaleFactor; xScale++) | |
| 208 | 207 | outX[xScale] = pixel; |
| 209 | 208 | } |
| 210 | 209 | |
| 211 | − outX += scaling; | |
| 210 | + outX += scaleFactor; | |
| 212 | 211 | } |
| 213 | 212 | } |
| 214 | 213 | } |
| @@ -220,7 +219,7 @@ bool createMouseCursors(void) // creates scaled SDL surfaces for current mouse p · 5 unmodified lines | ||
| 220 | 219 | { |
| 221 | 220 | SDL_FreeSurface(surface); |
| 222 | 221 | freeMouseCursors(); |
| 223 | − ptConfig.hwMouse = false; // enable software mouse | |
| 222 | + config.hwMouse = false; // enable software mouse | |
| 224 | 223 | return false; |
| 225 | 224 | } |
| 226 | 225 | |
| @@ -233,102 +232,112 @@ bool createMouseCursors(void) // creates scaled SDL surfaces for current mouse p · 6 unmodified lines | ||
| 233 | 232 | |
| 234 | 233 | void updateMouseScaling(void) |
| 235 | 234 | { |
| 236 | − if (editor.ui.renderW > 0) editor.ui.dMouseXMul = (double)SCREEN_W / editor.ui.renderW; | |
| 237 | − if (editor.ui.renderH > 0) editor.ui.dMouseYMul = (double)SCREEN_H / editor.ui.renderH; | |
| 235 | + if (video.renderW > 0) video.dMouseXMul = (double)SCREEN_W / video.renderW; | |
| 236 | + if (video.renderH > 0) video.dMouseYMul = (double)SCREEN_H / video.renderH; | |
| 238 | 237 | } |
| 239 | 238 | |
| 240 | 239 | void readMouseXY(void) |
| 241 | 240 | { |
| 242 | − int32_t mx, my; | |
| 241 | + int32_t mx, my, windowX, windowY; | |
| 243 | 242 | |
| 244 | − if (input.mouse.setPosFlag) | |
| 243 | + if (mouse.setPosFlag) | |
| 245 | 244 | { |
| 246 | − input.mouse.setPosFlag = false; | |
| 247 | − | |
| 248 | − if (SDL_GetWindowFlags(window) & SDL_WINDOW_SHOWN) | |
| 249 | − SDL_WarpMouseInWindow(window, input.mouse.setPosX, input.mouse.setPosY); | |
| 245 | + if (!video.windowHidden) | |
| 246 | + SDL_WarpMouseInWindow(video.window, mouse.setPosX, mouse.setPosY); | |
| 250 | 247 | |
| 248 | + mouse.setPosFlag = false; | |
| 251 | 249 | return; |
| 252 | 250 | } |
| 253 | 251 | |
| 254 | − SDL_PumpEvents(); // gathers all pending input from devices into the event queue (less mouse lag) | |
| 255 | − SDL_GetMouseState(&mx, &my); | |
| 252 | + mouse.buttonState = SDL_GetGlobalMouseState(&mx, &my); | |
| 256 | 253 | |
| 257 | − /* in centered fullscreen mode, trap the mouse inside the framed image | |
| 258 | − * and subtract the coords to match the OS mouse position (fixes touch from touchscreens) */ | |
| 259 | − if (editor.fullscreen && !ptConfig.fullScreenStretch) | |
| 254 | + if (video.fullscreen) | |
| 260 | 255 | { |
| 261 | − if (mx < editor.ui.renderX) | |
| 262 | − { | |
| 263 | − mx = editor.ui.renderX; | |
| 264 | − SDL_WarpMouseInWindow(window, mx, my); | |
| 265 | − } | |
| 266 | − else if (mx >= editor.ui.renderX+editor.ui.renderW) | |
| 267 | − { | |
| 268 | − mx = (editor.ui.renderX + editor.ui.renderW) - 1; | |
| 269 | − SDL_WarpMouseInWindow(window, mx, my); | |
| 270 | − } | |
| 256 | + /* If fullscreen without filtering mode, translate coords and warp mouse | |
| 257 | + ** inside the render space. | |
| 258 | + ** Fullscreen + filtering mode takes up 100% of the screen area used, so no | |
| 259 | + ** need to translate coords in that mode. | |
| 260 | + */ | |
| 271 | 261 | |
| 272 | − if (my < editor.ui.renderY) | |
| 262 | + if (!config.fullScreenStretch) | |
| 273 | 263 | { |
| 274 | − my = editor.ui.renderY; | |
| 275 | − SDL_WarpMouseInWindow(window, mx, my); | |
| 276 | − } | |
| 277 | − else if (my >= editor.ui.renderY+editor.ui.renderH) | |
| 278 | − { | |
| 279 | − my = (editor.ui.renderY + editor.ui.renderH) - 1; | |
| 280 | − SDL_WarpMouseInWindow(window, mx, my); | |
| 281 | − } | |
| 264 | + if (!config.hwMouse) | |
| 265 | + { | |
| 266 | + bool warpMouse = false; | |
| 282 | 267 | |
| 283 | − mx -= editor.ui.renderX; | |
| 284 | − my -= editor.ui.renderY; | |
| 285 | − } | |
| 268 | + if (mx < video.renderX) | |
| 269 | + { | |
| 270 | + mx = video.renderX; | |
| 271 | + warpMouse = true; | |
| 272 | + } | |
| 273 | + else if (mx >= video.renderX+video.renderW) | |
| 274 | + { | |
| 275 | + mx = (video.renderX + video.renderW) - 1; | |
| 276 | + warpMouse = true; | |
| 277 | + } | |
| 286 | 278 | |
| 287 | − if (mx < 0) mx = 0; | |
| 288 | − if (my < 0) my = 0; | |
| 279 | + if (my < video.renderY) | |
| 280 | + { | |
| 281 | + my = video.renderY; | |
| 282 | + warpMouse = true; | |
| 283 | + } | |
| 284 | + else if (my >= video.renderY+video.renderH) | |
| 285 | + { | |
| 286 | + my = (video.renderY + video.renderH) - 1; | |
| 287 | + warpMouse = true; | |
| 288 | + } | |
| 289 | 289 | |
| 290 | − // multiply coords by video scaling factors (do not round) | |
| 291 | − mx = (int32_t)(mx * editor.ui.dMouseXMul); | |
| 292 | − my = (int32_t)(my * editor.ui.dMouseYMul); | |
| 290 | + if (warpMouse) | |
| 291 | + SDL_WarpMouseInWindow(video.window, mx, my); | |
| 292 | + } | |
| 293 | 293 | |
| 294 | − if (mx >= SCREEN_W) mx = SCREEN_W - 1; | |
| 295 | − if (my >= SCREEN_H) my = SCREEN_H - 1; | |
| 294 | + // convert fullscreen coords to window (centered image) coords | |
| 295 | + mx -= video.renderX; | |
| 296 | + my -= video.renderY; | |
| 297 | + } | |
| 298 | + } | |
| 299 | + else | |
| 300 | + { | |
| 301 | + // convert desktop coords to window coords | |
| 302 | + | |
| 303 | + // (a call to this function is really fast in windowed mode) | |
| 304 | + SDL_GetWindowPosition(video.window, &windowX, &windowY); | |
| 305 | + | |
| 306 | + mx -= windowX; | |
| 307 | + my -= windowY; | |
| 308 | + } | |
| 296 | 309 | |
| 297 | − input.mouse.x = (int16_t)mx; | |
| 298 | − input.mouse.y = (int16_t)my; | |
| 310 | + // multiply coords by video upscaling factors (don't round) | |
| 311 | + mouse.x = (int32_t)(mx * video.dMouseXMul); | |
| 312 | + mouse.y = (int32_t)(my * video.dMouseYMul); | |
| 299 | 313 | |
| 300 | − if (ptConfig.hwMouse) | |
| 314 | + if (config.hwMouse) | |
| 301 | 315 | { |
| 302 | − // hardware mouse | |
| 316 | + // hardware mouse mode (OS) | |
| 303 | 317 | hideSprite(SPRITE_MOUSE_POINTER); |
| 304 | 318 | } |
| 305 | 319 | else |
| 306 | 320 | { |
| 307 | − // software mouse | |
| 308 | − setSpritePos(SPRITE_MOUSE_POINTER, input.mouse.x, input.mouse.y); | |
| 321 | + // software mouse mode (PT mouse) | |
| 322 | + setSpritePos(SPRITE_MOUSE_POINTER, mouse.x, mouse.y); | |
| 309 | 323 | } |
| 310 | 324 | } |
| 311 | 325 | |
| 312 | 326 | void mouseButtonUpHandler(uint8_t mouseButton) |
| 313 | 327 | { |
| 314 | −#ifndef __APPLE__ | |
| 315 | − if (!editor.fullscreen) | |
| 316 | − SDL_SetWindowGrab(window, SDL_FALSE); | |
| 317 | −#endif | |
| 318 | − | |
| 319 | − input.mouse.buttonWaitCounter = 0; | |
| 320 | − input.mouse.buttonWaiting = false; | |
| 328 | + mouse.buttonWaitCounter = 0; | |
| 329 | + mouse.buttonWaiting = false; | |
| 321 | 330 | |
| 322 | 331 | if (mouseButton == SDL_BUTTON_LEFT) |
| 323 | 332 | { |
| 324 | − input.mouse.leftButtonPressed = false; | |
| 333 | + mouse.leftButtonPressed = false; | |
| 325 | 334 | editor.ui.forceSampleDrag = false; |
| 326 | 335 | editor.ui.forceVolDrag = false; |
| 327 | 336 | editor.ui.leftLoopPinMoving = false; |
| 328 | 337 | editor.ui.rightLoopPinMoving = false; |
| 329 | 338 | editor.ui.sampleMarkingPos = -1; |
| 330 | 339 | |
| 331 | − switch (input.mouse.lastGUIButton) | |
| 340 | + switch (mouse.lastGUIButton) | |
| 332 | 341 | { |
| 333 | 342 | case PTB_SLENGTHU: |
| 334 | 343 | case PTB_SLENGTHD: |
| @@ -358,32 +367,27 @@ void mouseButtonUpHandler(uint8_t mouseButton) · 23 unmodified lines | ||
| 358 | 367 | break; |
| 359 | 368 | } |
| 360 | 369 | |
| 361 | − input.mouse.lastGUIButton = -1; | |
| 362 | − input.mouse.lastSmpFilterButton = -1; | |
| 370 | + mouse.lastGUIButton = -1; | |
| 371 | + mouse.lastSmpFilterButton = -1; | |
| 363 | 372 | } |
| 364 | 373 | |
| 365 | 374 | if (mouseButton == SDL_BUTTON_RIGHT) |
| 366 | 375 | { |
| 367 | − input.mouse.rightButtonPressed = false; | |
| 376 | + mouse.rightButtonPressed = false; | |
| 368 | 377 | editor.ui.forceSampleEdit = false; |
| 369 | 378 | } |
| 370 | 379 | } |
| 371 | 380 | |
| 372 | 381 | void mouseButtonDownHandler(uint8_t mouseButton) |
| 373 | 382 | { |
| 374 | −#ifndef __APPLE__ | |
| 375 | − if (!editor.fullscreen) | |
| 376 | − SDL_SetWindowGrab(window, SDL_TRUE); | |
| 377 | −#endif | |
| 378 | − | |
| 379 | 383 | if (mouseButton == SDL_BUTTON_LEFT) |
| 380 | 384 | { |
| 381 | − input.mouse.leftButtonPressed = true; | |
| 382 | − input.mouse.buttonWaiting = true; | |
| 385 | + mouse.leftButtonPressed = true; | |
| 386 | + mouse.buttonWaiting = true; | |
| 383 | 387 | } |
| 384 | 388 | |
| 385 | 389 | if (mouseButton == SDL_BUTTON_RIGHT) |
| 386 | − input.mouse.rightButtonPressed = true; | |
| 390 | + mouse.rightButtonPressed = true; | |
| 387 | 391 | |
| 388 | 392 | // when red mouse pointer (error), block further input for a while |
| 389 | 393 | if (editor.errorMsgActive && editor.errorMsgBlock) |
| @@ -397,10 +401,10 @@ void mouseButtonDownHandler(uint8_t mouseButton) · 7 unmodified lines | ||
| 397 | 401 | |
| 398 | 402 | void handleGUIButtonRepeat(void) |
| 399 | 403 | { |
| 400 | − if (!input.mouse.leftButtonPressed) | |
| 404 | + if (!mouse.leftButtonPressed) | |
| 401 | 405 | { |
| 402 | 406 | // left mouse button released, stop repeating buttons |
| 403 | − input.mouse.repeatCounter = 0; | |
| 407 | + mouse.repeatCounter = 0; | |
| 404 | 408 | return; |
| 405 | 409 | } |
| 406 | 410 | |
| @@ -410,20 +414,20 @@ void handleGUIButtonRepeat(void) · 3 unmodified lines | ||
| 410 | 414 | return; |
| 411 | 415 | } |
| 412 | 416 | |
| 413 | − if (input.mouse.lastGUIButton != checkGUIButtons()) // FIXME: This can potentially do a ton of iterations, bad design! | |
| 417 | + if (mouse.lastGUIButton != checkGUIButtons()) // FIXME: This can potentially do a ton of iterations, bad design! | |
| 414 | 418 | { |
| 415 | 419 | // only repeat the button that was first clicked (e.g. if you hold and move mouse to another button) |
| 416 | − input.mouse.repeatCounter = 0; | |
| 420 | + mouse.repeatCounter = 0; | |
| 417 | 421 | return; |
| 418 | 422 | } |
| 419 | 423 | |
| 420 | 424 | handleRepeatedGUIButtons(); |
| 421 | − input.mouse.repeatCounter++; | |
| 425 | + mouse.repeatCounter++; | |
| 422 | 426 | } |
| 423 | 427 | |
| 424 | 428 | void edNote1UpButton(void) |
| 425 | 429 | { |
| 426 | − if (input.mouse.rightButtonPressed) | |
| 430 | + if (mouse.rightButtonPressed) | |
| 427 | 431 | editor.note1 += 12; |
| 428 | 432 | else |
| 429 | 433 | editor.note1++; |
| @@ -437,7 +441,7 @@ void edNote1UpButton(void) · 7 unmodified lines | ||
| 437 | 441 | |
| 438 | 442 | void edNote1DownButton(void) |
| 439 | 443 | { |
| 440 | − if (input.mouse.rightButtonPressed) | |
| 444 | + if (mouse.rightButtonPressed) | |
| 441 | 445 | editor.note1 -= 12; |
| 442 | 446 | else |
| 443 | 447 | editor.note1--; |
| @@ -451,7 +455,7 @@ void edNote1DownButton(void) · 7 unmodified lines | ||
| 451 | 455 | |
| 452 | 456 | void edNote2UpButton(void) |
| 453 | 457 | { |
| 454 | − if (input.mouse.rightButtonPressed) | |
| 458 | + if (mouse.rightButtonPressed) | |
| 455 | 459 | editor.note2 += 12; |
| 456 | 460 | else |
| 457 | 461 | editor.note2++; |
| @@ -465,7 +469,7 @@ void edNote2UpButton(void) · 7 unmodified lines | ||
| 465 | 469 | |
| 466 | 470 | void edNote2DownButton(void) |
| 467 | 471 | { |
| 468 | − if (input.mouse.rightButtonPressed) | |
| 472 | + if (mouse.rightButtonPressed) | |
| 469 | 473 | editor.note2 -= 12; |
| 470 | 474 | else |
| 471 | 475 | editor.note2--; |
| @@ -479,7 +483,7 @@ void edNote2DownButton(void) · 7 unmodified lines | ||
| 479 | 483 | |
| 480 | 484 | void edNote3UpButton(void) |
| 481 | 485 | { |
| 482 | − if (input.mouse.rightButtonPressed) | |
| 486 | + if (mouse.rightButtonPressed) | |
| 483 | 487 | editor.note3 += 12; |
| 484 | 488 | else |
| 485 | 489 | editor.note3++; |
| @@ -493,7 +497,7 @@ void edNote3UpButton(void) · 7 unmodified lines | ||
| 493 | 497 | |
| 494 | 498 | void edNote3DownButton(void) |
| 495 | 499 | { |
| 496 | − if (input.mouse.rightButtonPressed) | |
| 500 | + if (mouse.rightButtonPressed) | |
| 497 | 501 | editor.note3 -= 12; |
| 498 | 502 | else |
| 499 | 503 | editor.note3--; |
| @@ -507,7 +511,7 @@ void edNote3DownButton(void) · 7 unmodified lines | ||
| 507 | 511 | |
| 508 | 512 | void edNote4UpButton(void) |
| 509 | 513 | { |
| 510 | − if (input.mouse.rightButtonPressed) | |
| 514 | + if (mouse.rightButtonPressed) | |
| 511 | 515 | editor.note4 += 12; |
| 512 | 516 | else |
| 513 | 517 | editor.note4++; |
| @@ -521,7 +525,7 @@ void edNote4UpButton(void) · 7 unmodified lines | ||
| 521 | 525 | |
| 522 | 526 | void edNote4DownButton(void) |
| 523 | 527 | { |
| 524 | − if (input.mouse.rightButtonPressed) | |
| 528 | + if (mouse.rightButtonPressed) | |
| 525 | 529 | editor.note4 -= 12; |
| 526 | 530 | else |
| 527 | 531 | editor.note4--; |
| @@ -535,7 +539,7 @@ void edNote4DownButton(void) · 7 unmodified lines | ||
| 535 | 539 | |
| 536 | 540 | void edPosUpButton(bool fast) |
| 537 | 541 | { |
| 538 | − if (input.mouse.rightButtonPressed) | |
| 542 | + if (mouse.rightButtonPressed) | |
| 539 | 543 | { |
| 540 | 544 | if (fast) |
| 541 | 545 | { |
| @@ -578,7 +582,7 @@ void edPosUpButton(bool fast) · 36 unmodified lines | ||
| 578 | 582 | |
| 579 | 583 | void edPosDownButton(bool fast) |
| 580 | 584 | { |
| 581 | − if (input.mouse.rightButtonPressed) | |
| 585 | + if (mouse.rightButtonPressed) | |
| 582 | 586 | { |
| 583 | 587 | if (fast) |
| 584 | 588 | { |
| @@ -618,7 +622,7 @@ void edPosDownButton(bool fast) · 33 unmodified lines | ||
| 618 | 622 | |
| 619 | 623 | void edModUpButton(void) |
| 620 | 624 | { |
| 621 | − if (input.mouse.rightButtonPressed) | |
| 625 | + if (mouse.rightButtonPressed) | |
| 622 | 626 | editor.modulateSpeed += 10; |
| 623 | 627 | else |
| 624 | 628 | editor.modulateSpeed++; |
| @@ -631,7 +635,7 @@ void edModUpButton(void) · 6 unmodified lines | ||
| 631 | 635 | |
| 632 | 636 | void edModDownButton(void) |
| 633 | 637 | { |
| 634 | − if (input.mouse.rightButtonPressed) | |
| 638 | + if (mouse.rightButtonPressed) | |
| 635 | 639 | { |
| 636 | 640 | editor.modulateSpeed -= 10; |
| 637 | 641 | } |
| @@ -648,7 +652,7 @@ void edModDownButton(void) · 10 unmodified lines | ||
| 648 | 652 | |
| 649 | 653 | void edVolUpButton(void) |
| 650 | 654 | { |
| 651 | − if (input.mouse.rightButtonPressed) | |
| 655 | + if (mouse.rightButtonPressed) | |
| 652 | 656 | { |
| 653 | 657 | if (editor.sampleVol <= 999-10) |
| 654 | 658 | editor.sampleVol += 10; |
| @@ -666,7 +670,7 @@ void edVolUpButton(void) · 11 unmodified lines | ||
| 666 | 670 | |
| 667 | 671 | void edVolDownButton(void) |
| 668 | 672 | { |
| 669 | − if (input.mouse.rightButtonPressed) | |
| 673 | + if (mouse.rightButtonPressed) | |
| 670 | 674 | { |
| 671 | 675 | if (editor.sampleVol >= 10) |
| 672 | 676 | editor.sampleVol -= 10; |
| @@ -712,7 +716,7 @@ void sampleFineTuneUpButton(void) · 39 unmodified lines | ||
| 712 | 716 | if (finetune != 7) |
| 713 | 717 | modEntry->samples[editor.currSample].fineTune = (finetune + 1) & 0xF; |
| 714 | 718 | |
| 715 | − if (input.mouse.rightButtonPressed) | |
| 719 | + if (mouse.rightButtonPressed) | |
| 716 | 720 | modEntry->samples[editor.currSample].fineTune = 0; |
| 717 | 721 | |
| 718 | 722 | recalcChordLength(); |
| @@ -725,7 +729,7 @@ void sampleFineTuneDownButton(void) · 6 unmodified lines | ||
| 725 | 729 | if (finetune != 8) |
| 726 | 730 | modEntry->samples[editor.currSample].fineTune = (finetune - 1) & 0xF; |
| 727 | 731 | |
| 728 | − if (input.mouse.rightButtonPressed) | |
| 732 | + if (mouse.rightButtonPressed) | |
| 729 | 733 | modEntry->samples[editor.currSample].fineTune = 0; |
| 730 | 734 | |
| 731 | 735 | recalcChordLength(); |
| @@ -736,7 +740,7 @@ void sampleVolumeUpButton(void) · 4 unmodified lines | ||
| 736 | 740 | { |
| 737 | 741 | int8_t val = modEntry->samples[editor.currSample].volume; |
| 738 | 742 | |
| 739 | − if (input.mouse.rightButtonPressed) | |
| 743 | + if (mouse.rightButtonPressed) | |
| 740 | 744 | val += 16; |
| 741 | 745 | else |
| 742 | 746 | val++; |
| @@ -752,7 +756,7 @@ void sampleVolumeDownButton(void) · 9 unmodified lines | ||
| 752 | 756 | { |
| 753 | 757 | int8_t val = modEntry->samples[editor.currSample].volume; |
| 754 | 758 | |
| 755 | − if (input.mouse.rightButtonPressed) | |
| 759 | + if (mouse.rightButtonPressed) | |
| 756 | 760 | val -= 16; |
| 757 | 761 | else |
| 758 | 762 | val--; |
| @@ -772,7 +776,7 @@ void sampleLengthUpButton(bool fast) · 13 unmodified lines | ||
| 772 | 776 | return; |
| 773 | 777 | |
| 774 | 778 | val = modEntry->samples[editor.currSample].length; |
| 775 | − if (input.mouse.rightButtonPressed) | |
| 779 | + if (mouse.rightButtonPressed) | |
| 776 | 780 | { |
| 777 | 781 | if (fast) |
| 778 | 782 | val += 64; |
| @@ -812,7 +816,7 @@ void sampleLengthDownButton(bool fast) · 33 unmodified lines | ||
| 812 | 816 | } |
| 813 | 817 | |
| 814 | 818 | val = modEntry->samples[editor.currSample].length; |
| 815 | − if (input.mouse.rightButtonPressed) | |
| 819 | + if (mouse.rightButtonPressed) | |
| 816 | 820 | { |
| 817 | 821 | if (fast) |
| 818 | 822 | val -= 64; |
| @@ -855,7 +859,7 @@ void sampleRepeatUpButton(bool fast) · 36 unmodified lines | ||
| 855 | 859 | return; |
| 856 | 860 | } |
| 857 | 861 | |
| 858 | − if (input.mouse.rightButtonPressed) | |
| 862 | + if (mouse.rightButtonPressed) | |
| 859 | 863 | { |
| 860 | 864 | if (fast) |
| 861 | 865 | val += 64; |
| @@ -898,7 +902,7 @@ void sampleRepeatDownButton(bool fast) · 36 unmodified lines | ||
| 898 | 902 | return; |
| 899 | 903 | } |
| 900 | 904 | |
| 901 | − if (input.mouse.rightButtonPressed) | |
| 905 | + if (mouse.rightButtonPressed) | |
| 902 | 906 | { |
| 903 | 907 | if (fast) |
| 904 | 908 | val -= 64; |
| @@ -942,7 +946,7 @@ void sampleRepeatLengthUpButton(bool fast) · 37 unmodified lines | ||
| 942 | 946 | return; |
| 943 | 947 | } |
| 944 | 948 | |
| 945 | − if (input.mouse.rightButtonPressed) | |
| 949 | + if (mouse.rightButtonPressed) | |
| 946 | 950 | { |
| 947 | 951 | if (fast) |
| 948 | 952 | val += 64; |
| @@ -985,7 +989,7 @@ void sampleRepeatLengthDownButton(bool fast) · 36 unmodified lines | ||
| 985 | 989 | return; |
| 986 | 990 | } |
| 987 | 991 | |
| 988 | − if (input.mouse.rightButtonPressed) | |
| 992 | + if (mouse.rightButtonPressed) | |
| 989 | 993 | { |
| 990 | 994 | if (fast) |
| 991 | 995 | val -= 64; |
| @@ -1023,7 +1027,7 @@ void tempoUpButton(void) · 31 unmodified lines | ||
| 1023 | 1027 | return; |
| 1024 | 1028 | |
| 1025 | 1029 | val = modEntry->currBPM; |
| 1026 | − if (input.mouse.rightButtonPressed) | |
| 1030 | + if (mouse.rightButtonPressed) | |
| 1027 | 1031 | val += 10; |
| 1028 | 1032 | else |
| 1029 | 1033 | val++; |
| @@ -1044,7 +1048,7 @@ void tempoDownButton(void) · 14 unmodified lines | ||
| 1044 | 1048 | return; |
| 1045 | 1049 | |
| 1046 | 1050 | val = modEntry->currBPM; |
| 1047 | − if (input.mouse.rightButtonPressed) | |
| 1051 | + if (mouse.rightButtonPressed) | |
| 1048 | 1052 | val -= 10; |
| 1049 | 1053 | else |
| 1050 | 1054 | val--; |
| @@ -1062,7 +1066,7 @@ void songLengthUpButton(void) · 11 unmodified lines | ||
| 1062 | 1066 | int16_t val; |
| 1063 | 1067 | |
| 1064 | 1068 | val = modEntry->head.orderCount; |
| 1065 | − if (input.mouse.rightButtonPressed) | |
| 1069 | + if (mouse.rightButtonPressed) | |
| 1066 | 1070 | val += 10; |
| 1067 | 1071 | else |
| 1068 | 1072 | val++; |
| @@ -1084,7 +1088,7 @@ void songLengthDownButton(void) · 15 unmodified lines | ||
| 1084 | 1088 | { |
| 1085 | 1089 | int16_t val = modEntry->head.orderCount; |
| 1086 | 1090 | |
| 1087 | − if (input.mouse.rightButtonPressed) | |
| 1091 | + if (mouse.rightButtonPressed) | |
| 1088 | 1092 | val -= 10; |
| 1089 | 1093 | else |
| 1090 | 1094 | val--; |
| @@ -1106,7 +1110,7 @@ void patternUpButton(void) · 15 unmodified lines | ||
| 1106 | 1110 | { |
| 1107 | 1111 | int16_t val = modEntry->head.order[modEntry->currOrder]; |
| 1108 | 1112 | |
| 1109 | − if (input.mouse.rightButtonPressed) | |
| 1113 | + if (mouse.rightButtonPressed) | |
| 1110 | 1114 | val += 10; |
| 1111 | 1115 | else |
| 1112 | 1116 | val++; |
| @@ -1126,7 +1130,7 @@ void patternDownButton(void) · 13 unmodified lines | ||
| 1126 | 1130 | { |
| 1127 | 1131 | int16_t val = modEntry->head.order[modEntry->currOrder]; |
| 1128 | 1132 | |
| 1129 | − if (input.mouse.rightButtonPressed) | |
| 1133 | + if (mouse.rightButtonPressed) | |
| 1130 | 1134 | val -= 10; |
| 1131 | 1135 | else |
| 1132 | 1136 | val--; |
| @@ -1146,7 +1150,7 @@ void positionUpButton(void) · 13 unmodified lines | ||
| 1146 | 1150 | { |
| 1147 | 1151 | int16_t val = modEntry->currOrder; |
| 1148 | 1152 | |
| 1149 | − if (input.mouse.rightButtonPressed) | |
| 1153 | + if (mouse.rightButtonPressed) | |
| 1150 | 1154 | val += 10; |
| 1151 | 1155 | else |
| 1152 | 1156 | val++; |
| @@ -1161,7 +1165,7 @@ void positionDownButton(void) · 8 unmodified lines | ||
| 1161 | 1165 | { |
| 1162 | 1166 | int16_t val = modEntry->currOrder; |
| 1163 | 1167 | |
| 1164 | − if (input.mouse.rightButtonPressed) | |
| 1168 | + if (mouse.rightButtonPressed) | |
| 1165 | 1169 | val -= 10; |
| 1166 | 1170 | else |
| 1167 | 1171 | val--; |
| @@ -1181,7 +1185,7 @@ void handleSamplerVolumeBox(void) · 13 unmodified lines | ||
| 1181 | 1185 | double dSmp; |
| 1182 | 1186 | moduleSample_t *s; |
| 1183 | 1187 | |
| 1184 | − if (input.mouse.rightButtonPressed) | |
| 1188 | + if (mouse.rightButtonPressed) | |
| 1185 | 1189 | { |
| 1186 | 1190 | if (editor.ui.editTextFlag) |
| 1187 | 1191 | { |
| @@ -1200,14 +1204,14 @@ void handleSamplerVolumeBox(void) · 12 unmodified lines | ||
| 1200 | 1204 | return; |
| 1201 | 1205 | |
| 1202 | 1206 | // check buttons |
| 1203 | − if (input.mouse.leftButtonPressed) | |
| 1207 | + if (mouse.leftButtonPressed) | |
| 1204 | 1208 | { |
| 1205 | 1209 | // restore sample ask dialog |
| 1206 | 1210 | if (editor.ui.askScreenShown && editor.ui.askScreenType == ASK_RESTORE_SAMPLE) |
| 1207 | 1211 | { |
| 1208 | − if (input.mouse.y >= 71 && input.mouse.y <= 81) | |
| 1212 | + if (mouse.y >= 71 && mouse.y <= 81) | |
| 1209 | 1213 | { |
| 1210 | − if (input.mouse.x >= 171 && input.mouse.x <= 196) | |
| 1214 | + if (mouse.x >= 171 && mouse.x <= 196) | |
| 1211 | 1215 | { |
| 1212 | 1216 | // YES button |
| 1213 | 1217 | editor.ui.askScreenShown = false; |
| @@ -1215,7 +1219,7 @@ void handleSamplerVolumeBox(void) · 1 unmodified line | ||
| 1215 | 1219 | editor.ui.answerYes = true; |
| 1216 | 1220 | handleAskYes(); |
| 1217 | 1221 | } |
| 1218 | − else if (input.mouse.x >= 234 && input.mouse.x <= 252) | |
| 1222 | + else if (mouse.x >= 234 && mouse.x <= 252) | |
| 1219 | 1223 | { |
| 1220 | 1224 | // NO button |
| 1221 | 1225 | editor.ui.askScreenShown = false; |
| @@ -1231,31 +1235,31 @@ void handleSamplerVolumeBox(void) · 9 unmodified lines | ||
| 1231 | 1235 | // MAIN SCREEN STOP |
| 1232 | 1236 | if (!editor.ui.diskOpScreenShown && !editor.ui.posEdScreenShown) |
| 1233 | 1237 | { |
| 1234 | − if (input.mouse.x >= 182 && input.mouse.x <= 243 && input.mouse.y >= 0 && input.mouse.y <= 10) | |
| 1238 | + if (mouse.x >= 182 && mouse.x <= 243 && mouse.y >= 0 && mouse.y <= 10) | |
| 1235 | 1239 | { |
| 1236 | 1240 | modStop(); |
| 1237 | 1241 | return; |
| 1238 | 1242 | } |
| 1239 | 1243 | } |
| 1240 | 1244 | |
| 1241 | − if (input.mouse.x >= 32 && input.mouse.x <= 95) | |
| 1245 | + if (mouse.x >= 32 && mouse.x <= 95) | |
| 1242 | 1246 | { |
| 1243 | 1247 | // SAMPLER SCREEN PLAY WAVEFORM |
| 1244 | − if (input.mouse.y >= 211 && input.mouse.y <= 221) | |
| 1248 | + if (mouse.y >= 211 && mouse.y <= 221) | |
| 1245 | 1249 | { |
| 1246 | 1250 | samplerPlayWaveform(); |
| 1247 | 1251 | return; |
| 1248 | 1252 | } |
| 1249 | 1253 | |
| 1250 | 1254 | // SAMPLER SCREEN PLAY DISPLAY |
| 1251 | − else if (input.mouse.y >= 222 && input.mouse.y <= 232) | |
| 1255 | + else if (mouse.y >= 222 && mouse.y <= 232) | |
| 1252 | 1256 | { |
| 1253 | 1257 | samplerPlayDisplay(); |
| 1254 | 1258 | return; |
| 1255 | 1259 | } |
| 1256 | 1260 | |
| 1257 | 1261 | // SAMPLER SCREEN PLAY RANGE |
| 1258 | − else if (input.mouse.y >= 233 && input.mouse.y <= 243) | |
| 1262 | + else if (mouse.y >= 233 && mouse.y <= 243) | |
| 1259 | 1263 | { |
| 1260 | 1264 | samplerPlayRange(); |
| 1261 | 1265 | return; |
| @@ -1263,7 +1267,7 @@ void handleSamplerVolumeBox(void) · 1 unmodified line | ||
| 1263 | 1267 | } |
| 1264 | 1268 | |
| 1265 | 1269 | // SAMPLER SCREEN STOP |
| 1266 | − if (input.mouse.x >= 0 && input.mouse.x <= 31 && input.mouse.y >= 222 && input.mouse.y <= 243) | |
| 1270 | + if (mouse.x >= 0 && mouse.x <= 31 && mouse.y >= 222 && mouse.y <= 243) | |
| 1267 | 1271 | { |
| 1268 | 1272 | for (i = 0; i < AMIGA_VOICES; i++) |
| 1269 | 1273 | mixerKillVoice(i); |
| @@ -1271,7 +1275,7 @@ void handleSamplerVolumeBox(void) · 1 unmodified line | ||
| 1271 | 1275 | } |
| 1272 | 1276 | |
| 1273 | 1277 | // VOLUME button (toggle) |
| 1274 | − if (input.mouse.x >= 96 && input.mouse.x <= 135 && input.mouse.y >= 244 && input.mouse.y <= 254) | |
| 1278 | + if (mouse.x >= 96 && mouse.x <= 135 && mouse.y >= 244 && mouse.y <= 254) | |
| 1275 | 1279 | { |
| 1276 | 1280 | editor.ui.samplerVolBoxShown = false; |
| 1277 | 1281 | removeSamplerVolBox(); |
| @@ -1279,16 +1283,16 @@ void handleSamplerVolumeBox(void) · 1 unmodified line | ||
| 1279 | 1283 | } |
| 1280 | 1284 | |
| 1281 | 1285 | // DRAG BOXES |
| 1282 | − if (input.mouse.x >= 72 && input.mouse.x <= 173 && input.mouse.y >= 154 && input.mouse.y <= 175) | |
| 1286 | + if (mouse.x >= 72 && mouse.x <= 173 && mouse.y >= 154 && mouse.y <= 175) | |
| 1283 | 1287 | { |
| 1284 | 1288 | volBoxBarPressed(MOUSE_BUTTON_NOT_HELD); |
| 1285 | 1289 | return; |
| 1286 | 1290 | } |
| 1287 | 1291 | |
| 1288 | − if (input.mouse.x >= 174 && input.mouse.x <= 207) | |
| 1292 | + if (mouse.x >= 174 && mouse.x <= 207) | |
| 1289 | 1293 | { |
| 1290 | 1294 | // FROM NUM |
| 1291 | − if (input.mouse.y >= 154 && input.mouse.y <= 164) | |
| 1295 | + if (mouse.y >= 154 && mouse.y <= 164) | |
| 1292 | 1296 | { |
| 1293 | 1297 | editor.ui.tmpDisp16 = editor.vol1; |
| 1294 | 1298 | editor.vol1Disp = &editor.ui.tmpDisp16; |
| @@ -1300,7 +1304,7 @@ void handleSamplerVolumeBox(void) · 5 unmodified lines | ||
| 1300 | 1304 | } |
| 1301 | 1305 | |
| 1302 | 1306 | // TO NUM |
| 1303 | − else if (input.mouse.y >= 165 && input.mouse.y <= 175) | |
| 1307 | + else if (mouse.y >= 165 && mouse.y <= 175) | |
| 1304 | 1308 | { |
| 1305 | 1309 | editor.ui.tmpDisp16 = editor.vol2; |
| 1306 | 1310 | editor.vol2Disp = &editor.ui.tmpDisp16; |
| @@ -1312,10 +1316,10 @@ void handleSamplerVolumeBox(void) · 5 unmodified lines | ||
| 1312 | 1316 | } |
| 1313 | 1317 | } |
| 1314 | 1318 | |
| 1315 | − if (input.mouse.y >= 176 && input.mouse.y <= 186) | |
| 1319 | + if (mouse.y >= 176 && mouse.y <= 186) | |
| 1316 | 1320 | { |
| 1317 | 1321 | // NORMALIZE |
| 1318 | − if (input.mouse.x >= 101 && input.mouse.x <= 143) | |
| 1322 | + if (mouse.x >= 101 && mouse.x <= 143) | |
| 1319 | 1323 | { |
| 1320 | 1324 | s = &modEntry->samples[editor.currSample]; |
| 1321 | 1325 | if (s->length == 0) |
| @@ -1374,7 +1378,7 @@ void handleSamplerVolumeBox(void) · 52 unmodified lines | ||
| 1374 | 1378 | } |
| 1375 | 1379 | |
| 1376 | 1380 | // RAMP DOWN |
| 1377 | − else if (input.mouse.x >= 144 && input.mouse.x <= 153) | |
| 1381 | + else if (mouse.x >= 144 && mouse.x <= 153) | |
| 1378 | 1382 | { |
| 1379 | 1383 | editor.vol1 = 100; |
| 1380 | 1384 | editor.vol2 = 0; |
| @@ -1386,7 +1390,7 @@ void handleSamplerVolumeBox(void) · 5 unmodified lines | ||
| 1386 | 1390 | } |
| 1387 | 1391 | |
| 1388 | 1392 | // RAMP UP |
| 1389 | − else if (input.mouse.x >= 154 && input.mouse.x <= 163) | |
| 1393 | + else if (mouse.x >= 154 && mouse.x <= 163) | |
| 1390 | 1394 | { |
| 1391 | 1395 | editor.vol1 = 0; |
| 1392 | 1396 | editor.vol2 = 100; |
| @@ -1398,7 +1402,7 @@ void handleSamplerVolumeBox(void) · 5 unmodified lines | ||
| 1398 | 1402 | } |
| 1399 | 1403 | |
| 1400 | 1404 | // RAMP UNITY |
| 1401 | − else if (input.mouse.x >= 164 && input.mouse.x <= 173) | |
| 1405 | + else if (mouse.x >= 164 && mouse.x <= 173) | |
| 1402 | 1406 | { |
| 1403 | 1407 | editor.vol1 = 100; |
| 1404 | 1408 | editor.vol2 = 100; |
| @@ -1410,7 +1414,7 @@ void handleSamplerVolumeBox(void) · 5 unmodified lines | ||
| 1410 | 1414 | } |
| 1411 | 1415 | |
| 1412 | 1416 | // CANCEL |
| 1413 | − else if (input.mouse.x >= 174 && input.mouse.x <= 207) | |
| 1417 | + else if (mouse.x >= 174 && mouse.x <= 207) | |
| 1414 | 1418 | { |
| 1415 | 1419 | editor.ui.samplerVolBoxShown = false; |
| 1416 | 1420 | removeSamplerVolBox(); |
| @@ -1418,7 +1422,7 @@ void handleSamplerVolumeBox(void) · 1 unmodified line | ||
| 1418 | 1422 | } |
| 1419 | 1423 | |
| 1420 | 1424 | // RAMP |
| 1421 | − else if (input.mouse.x >= 72 && input.mouse.x <= 100) | |
| 1425 | + else if (mouse.x >= 72 && mouse.x <= 100) | |
| 1422 | 1426 | { |
| 1423 | 1427 | s = &modEntry->samples[editor.currSample]; |
| 1424 | 1428 | if (s->length == 0) |
| @@ -1478,14 +1482,14 @@ void handleSamplerVolumeBox(void) · 53 unmodified lines | ||
| 1478 | 1482 | |
| 1479 | 1483 | static void handleRepeatedSamplerFilterButtons(void) |
| 1480 | 1484 | { |
| 1481 | − if (!input.mouse.leftButtonPressed || input.mouse.lastSmpFilterButton == -1) | |
| 1485 | + if (!mouse.leftButtonPressed || mouse.lastSmpFilterButton == -1) | |
| 1482 | 1486 | return; |
| 1483 | 1487 | |
| 1484 | − switch (input.mouse.lastSmpFilterButton) | |
| 1488 | + switch (mouse.lastSmpFilterButton) | |
| 1485 | 1489 | { |
| 1486 | 1490 | case 0: // low-pass cutoff up |
| 1487 | 1491 | { |
| 1488 | − if (input.mouse.rightButtonPressed) | |
| 1492 | + if (mouse.rightButtonPressed) | |
| 1489 | 1493 | { |
| 1490 | 1494 | if (editor.lpCutOff <= 0xFFFF-50) |
| 1491 | 1495 | editor.lpCutOff += 50; |
| @@ -1509,7 +1513,7 @@ static void handleRepeatedSamplerFilterButtons(void) · 17 unmodified lines | ||
| 1509 | 1513 | |
| 1510 | 1514 | case 1: // low-pass cutoff down |
| 1511 | 1515 | { |
| 1512 | − if (input.mouse.rightButtonPressed) | |
| 1516 | + if (mouse.rightButtonPressed) | |
| 1513 | 1517 | { |
| 1514 | 1518 | if (editor.lpCutOff >= 50) |
| 1515 | 1519 | editor.lpCutOff -= 50; |
| @@ -1530,7 +1534,7 @@ static void handleRepeatedSamplerFilterButtons(void) · 14 unmodified lines | ||
| 1530 | 1534 | |
| 1531 | 1535 | case 2: // high-pass cutoff up |
| 1532 | 1536 | { |
| 1533 | − if (input.mouse.rightButtonPressed) | |
| 1537 | + if (mouse.rightButtonPressed) | |
| 1534 | 1538 | { |
| 1535 | 1539 | if (editor.hpCutOff <= 0xFFFF-50) |
| 1536 | 1540 | editor.hpCutOff += 50; |
| @@ -1554,7 +1558,7 @@ static void handleRepeatedSamplerFilterButtons(void) · 17 unmodified lines | ||
| 1554 | 1558 | |
| 1555 | 1559 | case 3: // high-pass cutoff down |
| 1556 | 1560 | { |
| 1557 | − if (input.mouse.rightButtonPressed) | |
| 1561 | + if (mouse.rightButtonPressed) | |
| 1558 | 1562 | { |
| 1559 | 1563 | if (editor.hpCutOff >= 50) |
| 1560 | 1564 | editor.hpCutOff -= 50; |
| @@ -1582,21 +1586,21 @@ void handleSamplerFiltersBox(void) · 21 unmodified lines | ||
| 1582 | 1586 | uint8_t i; |
| 1583 | 1587 | moduleSample_t *s; |
| 1584 | 1588 | |
| 1585 | − if (input.mouse.rightButtonPressed && editor.ui.editTextFlag) | |
| 1589 | + if (mouse.rightButtonPressed && editor.ui.editTextFlag) | |
| 1586 | 1590 | { |
| 1587 | 1591 | exitGetTextLine(EDIT_TEXT_NO_UPDATE); |
| 1588 | 1592 | return; |
| 1589 | 1593 | } |
| 1590 | 1594 | |
| 1591 | − if (editor.ui.editTextFlag || input.mouse.lastSmpFilterButton > -1 || !input.mouse.leftButtonPressed) | |
| 1595 | + if (editor.ui.editTextFlag || mouse.lastSmpFilterButton > -1 || !mouse.leftButtonPressed) | |
| 1592 | 1596 | return; |
| 1593 | 1597 | |
| 1594 | 1598 | // restore sample ask dialog |
| 1595 | 1599 | if (editor.ui.askScreenShown && editor.ui.askScreenType == ASK_RESTORE_SAMPLE) |
| 1596 | 1600 | { |
| 1597 | − if (input.mouse.y >= 71 && input.mouse.y <= 81) | |
| 1601 | + if (mouse.y >= 71 && mouse.y <= 81) | |
| 1598 | 1602 | { |
| 1599 | − if (input.mouse.x >= 171 && input.mouse.x <= 196) | |
| 1603 | + if (mouse.x >= 171 && mouse.x <= 196) | |
| 1600 | 1604 | { |
| 1601 | 1605 | // YES button |
| 1602 | 1606 | editor.ui.askScreenShown = false; |
| @@ -1604,7 +1608,7 @@ void handleSamplerFiltersBox(void) · 1 unmodified line | ||
| 1604 | 1608 | editor.ui.answerYes = true; |
| 1605 | 1609 | handleAskYes(); |
| 1606 | 1610 | } |
| 1607 | − else if ((input.mouse.x >= 234) && (input.mouse.x <= 252)) | |
| 1611 | + else if ((mouse.x >= 234) && (mouse.x <= 252)) | |
| 1608 | 1612 | { |
| 1609 | 1613 | // NO button |
| 1610 | 1614 | editor.ui.askScreenShown = false; |
| @@ -1618,7 +1622,7 @@ void handleSamplerFiltersBox(void) · 7 unmodified lines | ||
| 1618 | 1622 | } |
| 1619 | 1623 | |
| 1620 | 1624 | // FILTERS button (toggle) |
| 1621 | − if (input.mouse.x >= 211 && input.mouse.x <= 245 && input.mouse.y >= 244 && input.mouse.y <= 254) | |
| 1625 | + if (mouse.x >= 211 && mouse.x <= 245 && mouse.y >= 244 && mouse.y <= 254) | |
| 1622 | 1626 | { |
| 1623 | 1627 | editor.ui.samplerFiltersBoxShown = false; |
| 1624 | 1628 | removeSamplerFiltersBox(); |
| @@ -1628,31 +1632,31 @@ void handleSamplerFiltersBox(void) · 3 unmodified lines | ||
| 1628 | 1632 | // MAIN SCREEN STOP |
| 1629 | 1633 | if (!editor.ui.diskOpScreenShown && !editor.ui.posEdScreenShown) |
| 1630 | 1634 | { |
| 1631 | − if (input.mouse.x >= 182 && input.mouse.x <= 243 && input.mouse.y >= 0 && input.mouse.y <= 10) | |
| 1635 | + if (mouse.x >= 182 && mouse.x <= 243 && mouse.y >= 0 && mouse.y <= 10) | |
| 1632 | 1636 | { |
| 1633 | 1637 | modStop(); |
| 1634 | 1638 | return; |
| 1635 | 1639 | } |
| 1636 | 1640 | } |
| 1637 | 1641 | |
| 1638 | − if (input.mouse.x >= 32 && input.mouse.x <= 95) | |
| 1642 | + if (mouse.x >= 32 && mouse.x <= 95) | |
| 1639 | 1643 | { |
| 1640 | 1644 | // SAMPLER SCREEN PLAY WAVEFORM |
| 1641 | − if (input.mouse.y >= 211 && input.mouse.y <= 221) | |
| 1645 | + if (mouse.y >= 211 && mouse.y <= 221) | |
| 1642 | 1646 | { |
| 1643 | 1647 | samplerPlayWaveform(); |
| 1644 | 1648 | return; |
| 1645 | 1649 | } |
| 1646 | 1650 | |
| 1647 | 1651 | // SAMPLER SCREEN PLAY DISPLAY |
| 1648 | − else if (input.mouse.y >= 222 && input.mouse.y <= 232) | |
| 1652 | + else if (mouse.y >= 222 && mouse.y <= 232) | |
| 1649 | 1653 | { |
| 1650 | 1654 | samplerPlayDisplay(); |
| 1651 | 1655 | return; |
| 1652 | 1656 | } |
| 1653 | 1657 | |
| 1654 | 1658 | // SAMPLER SCREEN PLAY RANGE |
| 1655 | − else if (input.mouse.y >= 233 && input.mouse.y <= 243) | |
| 1659 | + else if (mouse.y >= 233 && mouse.y <= 243) | |
| 1656 | 1660 | { |
| 1657 | 1661 | samplerPlayRange(); |
| 1658 | 1662 | return; |
| @@ -1660,7 +1664,7 @@ void handleSamplerFiltersBox(void) · 1 unmodified line | ||
| 1660 | 1664 | } |
| 1661 | 1665 | |
| 1662 | 1666 | // SAMPLER SCREEN STOP |
| 1663 | − if (input.mouse.x >= 0 && input.mouse.x <= 31 && input.mouse.y >= 222 && input.mouse.y <= 243) | |
| 1667 | + if (mouse.x >= 0 && mouse.x <= 31 && mouse.y >= 222 && mouse.y <= 243) | |
| 1664 | 1668 | { |
| 1665 | 1669 | for (i = 0; i < AMIGA_VOICES; i++) |
| 1666 | 1670 | mixerKillVoice(i); |
| @@ -1668,7 +1672,7 @@ void handleSamplerFiltersBox(void) · 1 unmodified line | ||
| 1668 | 1672 | } |
| 1669 | 1673 | |
| 1670 | 1674 | // UNDO |
| 1671 | − if (input.mouse.x >= 65 && input.mouse.x <= 75 && input.mouse.y >= 154 && input.mouse.y <= 184) | |
| 1675 | + if (mouse.x >= 65 && mouse.x <= 75 && mouse.y >= 154 && mouse.y <= 184) | |
| 1672 | 1676 | { |
| 1673 | 1677 | s = &modEntry->samples[editor.currSample]; |
| 1674 | 1678 | if (s->length == 0) |
| @@ -1686,10 +1690,10 @@ void handleSamplerFiltersBox(void) · 11 unmodified lines | ||
| 1686 | 1690 | return; |
| 1687 | 1691 | } |
| 1688 | 1692 | |
| 1689 | − if (input.mouse.y >= 154 && input.mouse.y <= 164) | |
| 1693 | + if (mouse.y >= 154 && mouse.y <= 164) | |
| 1690 | 1694 | { |
| 1691 | 1695 | // DO LOW-PASS FILTER |
| 1692 | − if (input.mouse.x >= 76 && input.mouse.x <= 165) | |
| 1696 | + if (mouse.x >= 76 && mouse.x <= 165) | |
| 1693 | 1697 | { |
| 1694 | 1698 | lowPassSample(editor.lpCutOff); |
| 1695 | 1699 | renderSamplerFiltersBox(); |
| @@ -1697,9 +1701,9 @@ void handleSamplerFiltersBox(void) · 1 unmodified line | ||
| 1697 | 1701 | } |
| 1698 | 1702 | |
| 1699 | 1703 | // LOW-PASS CUTOFF |
| 1700 | − else if (input.mouse.x >= 166 && input.mouse.x <= 217) | |
| 1704 | + else if (mouse.x >= 166 && mouse.x <= 217) | |
| 1701 | 1705 | { |
| 1702 | − if (input.mouse.rightButtonPressed) | |
| 1706 | + if (mouse.rightButtonPressed) | |
| 1703 | 1707 | { |
| 1704 | 1708 | editor.lpCutOff = 0; |
| 1705 | 1709 | editor.ui.updateLPText = true; |
| @@ -1718,10 +1722,10 @@ void handleSamplerFiltersBox(void) · 12 unmodified lines | ||
| 1718 | 1722 | } |
| 1719 | 1723 | |
| 1720 | 1724 | // LOW-PASS CUTOFF UP |
| 1721 | − else if (input.mouse.x >= 218 && input.mouse.x <= 228) | |
| 1725 | + else if (mouse.x >= 218 && mouse.x <= 228) | |
| 1722 | 1726 | { |
| 1723 | − input.mouse.lastSmpFilterButton = 0; | |
| 1724 | − if (input.mouse.rightButtonPressed) | |
| 1727 | + mouse.lastSmpFilterButton = 0; | |
| 1728 | + if (mouse.rightButtonPressed) | |
| 1725 | 1729 | { |
| 1726 | 1730 | if (editor.lpCutOff <= 0xFFFF-100) |
| 1727 | 1731 | editor.lpCutOff += 100; |
| @@ -1744,10 +1748,10 @@ void handleSamplerFiltersBox(void) · 16 unmodified lines | ||
| 1744 | 1748 | } |
| 1745 | 1749 | |
| 1746 | 1750 | // LOW-PASS CUTOFF DOWN |
| 1747 | − else if (input.mouse.x >= 229 && input.mouse.x <= 239) | |
| 1751 | + else if (mouse.x >= 229 && mouse.x <= 239) | |
| 1748 | 1752 | { |
| 1749 | − input.mouse.lastSmpFilterButton = 1; | |
| 1750 | − if (input.mouse.rightButtonPressed) | |
| 1753 | + mouse.lastSmpFilterButton = 1; | |
| 1754 | + if (mouse.rightButtonPressed) | |
| 1751 | 1755 | { |
| 1752 | 1756 | if (editor.lpCutOff >= 100) |
| 1753 | 1757 | editor.lpCutOff -= 100; |
| @@ -1767,10 +1771,10 @@ void handleSamplerFiltersBox(void) · 13 unmodified lines | ||
| 1767 | 1771 | } |
| 1768 | 1772 | } |
| 1769 | 1773 | |
| 1770 | − if (input.mouse.y >= 164 && input.mouse.y <= 174) | |
| 1774 | + if (mouse.y >= 164 && mouse.y <= 174) | |
| 1771 | 1775 | { |
| 1772 | 1776 | // DO HIGH-PASS FILTER |
| 1773 | − if (input.mouse.x >= 76 && input.mouse.x <= 165) | |
| 1777 | + if (mouse.x >= 76 && mouse.x <= 165) | |
| 1774 | 1778 | { |
| 1775 | 1779 | highPassSample(editor.hpCutOff); |
| 1776 | 1780 | renderSamplerFiltersBox(); |
| @@ -1778,9 +1782,9 @@ void handleSamplerFiltersBox(void) · 1 unmodified line | ||
| 1778 | 1782 | } |
| 1779 | 1783 | |
| 1780 | 1784 | // HIGH-PASS CUTOFF |
| 1781 | − else if (input.mouse.x >= 166 && input.mouse.x <= 217) | |
| 1785 | + else if (mouse.x >= 166 && mouse.x <= 217) | |
| 1782 | 1786 | { |
| 1783 | − if (input.mouse.rightButtonPressed) | |
| 1787 | + if (mouse.rightButtonPressed) | |
| 1784 | 1788 | { |
| 1785 | 1789 | editor.hpCutOff = 0; |
| 1786 | 1790 | editor.ui.updateHPText = true; |
| @@ -1799,10 +1803,10 @@ void handleSamplerFiltersBox(void) · 12 unmodified lines | ||
| 1799 | 1803 | } |
| 1800 | 1804 | |
| 1801 | 1805 | // HIGH-PASS CUTOFF UP |
| 1802 | − else if (input.mouse.x >= 218 && input.mouse.x <= 228) | |
| 1806 | + else if (mouse.x >= 218 && mouse.x <= 228) | |
| 1803 | 1807 | { |
| 1804 | − input.mouse.lastSmpFilterButton = 2; | |
| 1805 | − if (input.mouse.rightButtonPressed) | |
| 1808 | + mouse.lastSmpFilterButton = 2; | |
| 1809 | + if (mouse.rightButtonPressed) | |
| 1806 | 1810 | { |
| 1807 | 1811 | if (editor.hpCutOff <= 0xFFFF-100) |
| 1808 | 1812 | editor.hpCutOff += 100; |
| @@ -1825,10 +1829,10 @@ void handleSamplerFiltersBox(void) · 16 unmodified lines | ||
| 1825 | 1829 | } |
| 1826 | 1830 | |
| 1827 | 1831 | // HIGH-PASS CUTOFF DOWN |
| 1828 | − else if (input.mouse.x >= 229 && input.mouse.x <= 239) | |
| 1832 | + else if (mouse.x >= 229 && mouse.x <= 239) | |
| 1829 | 1833 | { |
| 1830 | − input.mouse.lastSmpFilterButton = 3; | |
| 1831 | − if (input.mouse.rightButtonPressed) | |
| 1834 | + mouse.lastSmpFilterButton = 3; | |
| 1835 | + if (mouse.rightButtonPressed) | |
| 1832 | 1836 | { |
| 1833 | 1837 | if (editor.hpCutOff >= 100) |
| 1834 | 1838 | editor.hpCutOff -= 100; |
| @@ -1849,7 +1853,7 @@ void handleSamplerFiltersBox(void) · 14 unmodified lines | ||
| 1849 | 1853 | } |
| 1850 | 1854 | |
| 1851 | 1855 | // NORMALIZE SAMPLE FLAG |
| 1852 | − if (input.mouse.x >= 76 && input.mouse.x <= 239 && input.mouse.y >= 174 && input.mouse.y <= 186) | |
| 1856 | + if (mouse.x >= 76 && mouse.x <= 239 && mouse.y >= 174 && mouse.y <= 186) | |
| 1853 | 1857 | { |
| 1854 | 1858 | editor.normalizeFiltersFlag ^= 1; |
| 1855 | 1859 | editor.ui.updateNormFlag = true; |
| @@ -1857,7 +1861,7 @@ void handleSamplerFiltersBox(void) · 1 unmodified line | ||
| 1857 | 1861 | } |
| 1858 | 1862 | |
| 1859 | 1863 | // EXIT |
| 1860 | − if (input.mouse.x >= 240 && input.mouse.x <= 250 && input.mouse.y >= 154 && input.mouse.y <= 186) | |
| 1864 | + if (mouse.x >= 240 && mouse.x <= 250 && mouse.y >= 154 && mouse.y <= 186) | |
| 1861 | 1865 | { |
| 1862 | 1866 | editor.ui.samplerFiltersBoxShown = false; |
| 1863 | 1867 | removeSamplerFiltersBox(); |
| @@ -1866,7 +1870,7 @@ void handleSamplerFiltersBox(void) · 2 unmodified lines | ||
| 1866 | 1870 | |
| 1867 | 1871 | static bool withinButtonRect(const guiButton_t *b) |
| 1868 | 1872 | { |
| 1869 | − if (input.mouse.x >= b->x1 && input.mouse.x <= b->x2 && input.mouse.y >= b->y1 && input.mouse.y <= b->y2) | |
| 1873 | + if (mouse.x >= b->x1 && mouse.x <= b->x2 && mouse.y >= b->y1 && mouse.y <= b->y2) | |
| 1870 | 1874 | return true; |
| 1871 | 1875 | |
| 1872 | 1876 | return false; |
| @@ -1900,7 +1904,7 @@ int32_t checkGUIButtons(void) · 27 unmodified lines | ||
| 1900 | 1904 | } |
| 1901 | 1905 | |
| 1902 | 1906 | // QUIT (xy 0,0) works on all screens except for ask/clear screen |
| 1903 | − if (input.mouse.x == 0 && input.mouse.y == 0) | |
| 1907 | + if (mouse.x == 0 && mouse.y == 0) | |
| 1904 | 1908 | return PTB_QUIT; |
| 1905 | 1909 | |
| 1906 | 1910 | // top screen buttons |
| @@ -1960,10 +1964,10 @@ void handleTextEditing(uint8_t mouseButton) · 53 unmodified lines | ||
| 1960 | 1964 | } |
| 1961 | 1965 | else if (mouseButton == SDL_BUTTON_LEFT && !editor.mixFlag) |
| 1962 | 1966 | { |
| 1963 | − tmp16 = input.mouse.y - editor.ui.lineCurY; | |
| 1967 | + tmp16 = mouse.y - editor.ui.lineCurY; | |
| 1964 | 1968 | if (tmp16 <= 2 && tmp16 >= -9) |
| 1965 | 1969 | { |
| 1966 | − tmp16 = (uint16_t)((input.mouse.x - editor.ui.lineCurX) + 4) >> 3; | |
| 1970 | + tmp16 = (uint16_t)((mouse.x - editor.ui.lineCurX) + 4) >> 3; | |
| 1967 | 1971 | while (tmp16 != 0) // 0 = pos we want |
| 1968 | 1972 | { |
| 1969 | 1973 | if (tmp16 > 0) |
| @@ -2038,7 +2042,7 @@ void mouseWheelUpHandler(void) · 68 unmodified lines | ||
| 2038 | 2042 | if (editor.ui.editTextFlag || editor.ui.askScreenShown || editor.ui.clearScreenShown || editor.swapChannelFlag) |
| 2039 | 2043 | return; |
| 2040 | 2044 | |
| 2041 | − if (input.mouse.y < 121) | |
| 2045 | + if (mouse.y < 121) | |
| 2042 | 2046 | { |
| 2043 | 2047 | // upper part of screen |
| 2044 | 2048 | if (editor.ui.diskOpScreenShown) |
| @@ -2069,7 +2073,7 @@ void mouseWheelDownHandler(void) · 24 unmodified lines | ||
| 2069 | 2073 | if (editor.ui.editTextFlag || editor.ui.askScreenShown || editor.ui.clearScreenShown || editor.swapChannelFlag) |
| 2070 | 2074 | return; |
| 2071 | 2075 | |
| 2072 | − if (input.mouse.y < 121) | |
| 2076 | + if (mouse.y < 121) | |
| 2073 | 2077 | { |
| 2074 | 2078 | // upper part of screen |
| 2075 | 2079 | if (editor.ui.diskOpScreenShown) |
| @@ -2097,7 +2101,7 @@ void mouseWheelDownHandler(void) · 21 unmodified lines | ||
| 2097 | 2101 | |
| 2098 | 2102 | bool handleRightMouseButton(void) |
| 2099 | 2103 | { |
| 2100 | − if (!input.mouse.rightButtonPressed) | |
| 2104 | + if (!mouse.rightButtonPressed) | |
| 2101 | 2105 | return false; |
| 2102 | 2106 | |
| 2103 | 2107 | // exit sample swap mode with right mouse button (if present) |
| @@ -2136,23 +2140,23 @@ bool handleRightMouseButton(void) · 32 unmodified lines | ||
| 2136 | 2140 | } |
| 2137 | 2141 | |
| 2138 | 2142 | // toggle channel muting with right mouse button |
| 2139 | − if (editor.ui.visualizerMode == VISUAL_QUADRASCOPE && input.mouse.y >= 55 && input.mouse.y <= 87) | |
| 2143 | + if (editor.ui.visualizerMode == VISUAL_QUADRASCOPE && mouse.y >= 55 && mouse.y <= 87) | |
| 2140 | 2144 | { |
| 2141 | 2145 | if (!editor.ui.posEdScreenShown && !editor.ui.editOpScreenShown && !editor.ui.diskOpScreenShown && |
| 2142 | 2146 | !editor.ui.aboutScreenShown && !editor.ui.samplerVolBoxShown && |
| 2143 | 2147 | !editor.ui.samplerFiltersBoxShown && !editor.isWAVRendering) |
| 2144 | 2148 | { |
| 2145 | − if (input.mouse.x > 127 && input.mouse.x <= 167) editor.muted[0] ^= 1; | |
| 2146 | − else if (input.mouse.x > 175 && input.mouse.x <= 215) editor.muted[1] ^= 1; | |
| 2147 | − else if (input.mouse.x > 223 && input.mouse.x <= 263) editor.muted[2] ^= 1; | |
| 2148 | − else if (input.mouse.x > 271 && input.mouse.x <= 311) editor.muted[3] ^= 1; | |
| 2149 | + if (mouse.x > 127 && mouse.x <= 167) editor.muted[0] ^= 1; | |
| 2150 | + else if (mouse.x > 175 && mouse.x <= 215) editor.muted[1] ^= 1; | |
| 2151 | + else if (mouse.x > 223 && mouse.x <= 263) editor.muted[2] ^= 1; | |
| 2152 | + else if (mouse.x > 271 && mouse.x <= 311) editor.muted[3] ^= 1; | |
| 2149 | 2153 | |
| 2150 | 2154 | renderMuteButtons(); |
| 2151 | 2155 | } |
| 2152 | 2156 | } |
| 2153 | 2157 | |
| 2154 | 2158 | // sample hand drawing |
| 2155 | − if (input.mouse.y >= 138 && input.mouse.y <= 201 && editor.ui.samplerScreenShown && | |
| 2159 | + if (mouse.y >= 138 && mouse.y <= 201 && editor.ui.samplerScreenShown && | |
| 2156 | 2160 | !editor.ui.samplerVolBoxShown && !editor.ui.samplerFiltersBoxShown) |
| 2157 | 2161 | { |
| 2158 | 2162 | samplerEditSample(false); |
| @@ -2185,9 +2189,9 @@ bool handleLeftMouseButton(void) · 26 unmodified lines | ||
| 2185 | 2189 | // "downsample before loading sample" ask dialog |
| 2186 | 2190 | if (editor.ui.askScreenShown && editor.ui.askScreenType == ASK_LOAD_DOWNSAMPLE) |
| 2187 | 2191 | { |
| 2188 | − if (input.mouse.y >= 83 && input.mouse.y <= 93) | |
| 2192 | + if (mouse.y >= 83 && mouse.y <= 93) | |
| 2189 | 2193 | { |
| 2190 | − if (input.mouse.x >= 179 && input.mouse.x <= 204) | |
| 2194 | + if (mouse.x >= 179 && mouse.x <= 204) | |
| 2191 | 2195 | { |
| 2192 | 2196 | // YES button |
| 2193 | 2197 | editor.ui.askScreenShown = false; |
| @@ -2196,7 +2200,7 @@ bool handleLeftMouseButton(void) · 2 unmodified lines | ||
| 2196 | 2200 | handleAskYes(); |
| 2197 | 2201 | return true; |
| 2198 | 2202 | } |
| 2199 | − else if (input.mouse.x >= 242 && input.mouse.x <= 260) | |
| 2203 | + else if (mouse.x >= 242 && mouse.x <= 260) | |
| 2200 | 2204 | { |
| 2201 | 2205 | // NO button |
| 2202 | 2206 | editor.ui.askScreenShown = false; |
| @@ -2213,7 +2217,7 @@ bool handleLeftMouseButton(void) · 10 unmodified lines | ||
| 2213 | 2217 | // cancel note input gadgets with left/right mouse button |
| 2214 | 2218 | if (editor.ui.changingSmpResample || editor.ui.changingChordNote || editor.ui.changingDrumPadNote) |
| 2215 | 2219 | { |
| 2216 | − if (input.mouse.leftButtonPressed || input.mouse.rightButtonPressed) | |
| 2220 | + if (mouse.leftButtonPressed || mouse.rightButtonPressed) | |
| 2217 | 2221 | { |
| 2218 | 2222 | editor.ui.changingSmpResample = false; |
| 2219 | 2223 | editor.ui.changingChordNote = false; |
| @@ -2232,7 +2236,7 @@ bool handleLeftMouseButton(void) · 12 unmodified lines | ||
| 2232 | 2236 | return true; |
| 2233 | 2237 | } |
| 2234 | 2238 | |
| 2235 | − if (!input.mouse.leftButtonPressed) | |
| 2239 | + if (!mouse.leftButtonPressed) | |
| 2236 | 2240 | return false; |
| 2237 | 2241 | |
| 2238 | 2242 | // handle QUIT ask dialog while Disk Op. filling is ongoing |
| @@ -2240,9 +2244,9 @@ bool handleLeftMouseButton(void) · 1 unmodified line | ||
| 2240 | 2244 | { |
| 2241 | 2245 | if (editor.ui.askScreenShown && editor.ui.askScreenType == ASK_QUIT) |
| 2242 | 2246 | { |
| 2243 | − if (input.mouse.y >= 71 && input.mouse.y <= 81) | |
| 2247 | + if (mouse.y >= 71 && mouse.y <= 81) | |
| 2244 | 2248 | { |
| 2245 | − if (input.mouse.x >= 171 && input.mouse.x <= 196) | |
| 2249 | + if (mouse.x >= 171 && mouse.x <= 196) | |
| 2246 | 2250 | { |
| 2247 | 2251 | // YES button |
| 2248 | 2252 | editor.ui.askScreenShown = false; |
| @@ -2250,7 +2254,7 @@ bool handleLeftMouseButton(void) · 1 unmodified line | ||
| 2250 | 2254 | editor.ui.answerYes = true; |
| 2251 | 2255 | handleAskYes(); |
| 2252 | 2256 | } |
| 2253 | − else if (input.mouse.x >= 234 && input.mouse.x <= 252) | |
| 2257 | + else if (mouse.x >= 234 && mouse.x <= 252) | |
| 2254 | 2258 | { |
| 2255 | 2259 | // NO button |
| 2256 | 2260 | editor.ui.askScreenShown = false; |
| @@ -2269,7 +2273,7 @@ bool handleLeftMouseButton(void) · 12 unmodified lines | ||
| 2269 | 2273 | { |
| 2270 | 2274 | if (editor.ui.askScreenShown && editor.ui.askScreenType == ASK_QUIT) |
| 2271 | 2275 | { |
| 2272 | − if (input.mouse.x >= 171 && input.mouse.x <= 196) | |
| 2276 | + if (mouse.x >= 171 && mouse.x <= 196) | |
| 2273 | 2277 | { |
| 2274 | 2278 | // YES button |
| 2275 | 2279 | editor.isWAVRendering = false; |
| @@ -2280,7 +2284,7 @@ bool handleLeftMouseButton(void) · 4 unmodified lines | ||
| 2280 | 2284 | editor.ui.answerYes = true; |
| 2281 | 2285 | handleAskYes(); |
| 2282 | 2286 | } |
| 2283 | − else if (input.mouse.x >= 234 && input.mouse.x <= 252) | |
| 2287 | + else if (mouse.x >= 234 && mouse.x <= 252) | |
| 2284 | 2288 | { |
| 2285 | 2289 | // NO button |
| 2286 | 2290 | editor.ui.askScreenShown = false; |
| @@ -2292,7 +2296,7 @@ bool handleLeftMouseButton(void) · 5 unmodified lines | ||
| 2292 | 2296 | setStatusMessage("RENDERING MOD...", NO_CARRY); |
| 2293 | 2297 | } |
| 2294 | 2298 | } |
| 2295 | − else if (input.mouse.y >= 58 && input.mouse.y <= 68 && input.mouse.x >= 133 && input.mouse.x <= 186) | |
| 2299 | + else if (mouse.y >= 58 && mouse.y <= 68 && mouse.x >= 133 && mouse.x <= 186) | |
| 2296 | 2300 | { |
| 2297 | 2301 | // CANCEL button |
| 2298 | 2302 | editor.abortMod2Wav = true; |
| @@ -2310,12 +2314,12 @@ bool handleLeftMouseButton(void) · 11 unmodified lines | ||
| 2310 | 2314 | |
| 2311 | 2315 | void updateMouseCounters(void) |
| 2312 | 2316 | { |
| 2313 | − if (input.mouse.buttonWaiting) | |
| 2317 | + if (mouse.buttonWaiting) | |
| 2314 | 2318 | { |
| 2315 | − if (++input.mouse.buttonWaitCounter > VBLANK_HZ/4) // quarter of a second | |
| 2319 | + if (++mouse.buttonWaitCounter > VBLANK_HZ/4) // quarter of a second | |
| 2316 | 2320 | { |
| 2317 | − input.mouse.buttonWaitCounter = 0; | |
| 2318 | − input.mouse.buttonWaiting = false; | |
| 2321 | + mouse.buttonWaitCounter = 0; | |
| 2322 | + mouse.buttonWaiting = false; | |
| 2319 | 2323 | } |
| 2320 | 2324 | } |
| 2321 | 2325 | |
| @@ -2465,7 +2469,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 143 unmodified lines | ||
| 2465 | 2469 | |
| 2466 | 2470 | case PTB_EO_QUANTIZE: |
| 2467 | 2471 | { |
| 2468 | − editor.ui.tmpDisp16 = ptConfig.quantizeValue; | |
| 2472 | + editor.ui.tmpDisp16 = config.quantizeValue; | |
| 2469 | 2473 | editor.quantizeValueDisp = &editor.ui.tmpDisp16; |
| 2470 | 2474 | editor.ui.numPtr16 = &editor.ui.tmpDisp16; |
| 2471 | 2475 | editor.ui.numLen = 2; |
| @@ -2573,7 +2577,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 101 unmodified lines | ||
| 2573 | 2577 | |
| 2574 | 2578 | case PTB_EO_MIX: |
| 2575 | 2579 | { |
| 2576 | − if (!input.mouse.rightButtonPressed) | |
| 2580 | + if (!mouse.rightButtonPressed) | |
| 2577 | 2581 | { |
| 2578 | 2582 | editor.mixFlag = true; |
| 2579 | 2583 | editor.ui.showTextPtr = editor.mixText; |
| @@ -2729,7 +2733,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 149 unmodified lines | ||
| 2729 | 2733 | |
| 2730 | 2734 | case PTB_EO_POS_NUM: |
| 2731 | 2735 | { |
| 2732 | − if (input.mouse.rightButtonPressed) | |
| 2736 | + if (mouse.rightButtonPressed) | |
| 2733 | 2737 | { |
| 2734 | 2738 | editor.samplePos = 0; |
| 2735 | 2739 | editor.ui.updatePosText = true; |
| @@ -2786,7 +2790,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 50 unmodified lines | ||
| 2786 | 2790 | |
| 2787 | 2791 | case PTB_EO_MOD_NUM: |
| 2788 | 2792 | { |
| 2789 | − if (input.mouse.rightButtonPressed) | |
| 2793 | + if (mouse.rightButtonPressed) | |
| 2790 | 2794 | { |
| 2791 | 2795 | editor.modulateSpeed = 0; |
| 2792 | 2796 | editor.ui.updateModText = true; |
| @@ -3089,7 +3093,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 296 unmodified lines | ||
| 3089 | 3093 | |
| 3090 | 3094 | case PTB_EO_VOL_NUM: |
| 3091 | 3095 | { |
| 3092 | − if (input.mouse.rightButtonPressed) | |
| 3096 | + if (mouse.rightButtonPressed) | |
| 3093 | 3097 | { |
| 3094 | 3098 | editor.sampleVol = 100; |
| 3095 | 3099 | editor.ui.updateVolText = true; |
| @@ -3212,7 +3216,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 116 unmodified lines | ||
| 3212 | 3216 | |
| 3213 | 3217 | case PTB_EO_NOTE1: |
| 3214 | 3218 | { |
| 3215 | − if (input.mouse.rightButtonPressed) | |
| 3219 | + if (mouse.rightButtonPressed) | |
| 3216 | 3220 | { |
| 3217 | 3221 | editor.note1 = 36; |
| 3218 | 3222 | } |
| @@ -3231,7 +3235,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 12 unmodified lines | ||
| 3231 | 3235 | |
| 3232 | 3236 | case PTB_EO_NOTE2: |
| 3233 | 3237 | { |
| 3234 | − if (input.mouse.rightButtonPressed) | |
| 3238 | + if (mouse.rightButtonPressed) | |
| 3235 | 3239 | { |
| 3236 | 3240 | editor.note2 = 36; |
| 3237 | 3241 | } |
| @@ -3250,7 +3254,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 12 unmodified lines | ||
| 3250 | 3254 | |
| 3251 | 3255 | case PTB_EO_NOTE3: |
| 3252 | 3256 | { |
| 3253 | − if (input.mouse.rightButtonPressed) | |
| 3257 | + if (mouse.rightButtonPressed) | |
| 3254 | 3258 | { |
| 3255 | 3259 | editor.note3 = 36; |
| 3256 | 3260 | } |
| @@ -3269,7 +3273,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 12 unmodified lines | ||
| 3269 | 3273 | |
| 3270 | 3274 | case PTB_EO_NOTE4: |
| 3271 | 3275 | { |
| 3272 | − if (input.mouse.rightButtonPressed) | |
| 3276 | + if (mouse.rightButtonPressed) | |
| 3273 | 3277 | { |
| 3274 | 3278 | editor.note4 = 36; |
| 3275 | 3279 | } |
| @@ -3440,7 +3444,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 164 unmodified lines | ||
| 3440 | 3444 | { |
| 3441 | 3445 | if (modEntry->samples[editor.currSample].loopLength == 2 && modEntry->samples[editor.currSample].loopStart == 0) |
| 3442 | 3446 | { |
| 3443 | − editor.chordLengthMin = input.mouse.rightButtonPressed ? true : false; | |
| 3447 | + editor.chordLengthMin = mouse.rightButtonPressed ? true : false; | |
| 3444 | 3448 | recalcChordLength(); |
| 3445 | 3449 | } |
| 3446 | 3450 | } |
| @@ -3563,7 +3567,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 116 unmodified lines | ||
| 3563 | 3567 | { |
| 3564 | 3568 | if (editor.currMode == MODE_IDLE || editor.currMode == MODE_EDIT) |
| 3565 | 3569 | { |
| 3566 | − if (input.mouse.rightButtonPressed) | |
| 3570 | + if (mouse.rightButtonPressed) | |
| 3567 | 3571 | { |
| 3568 | 3572 | modEntry->currOrder = 0; |
| 3569 | 3573 | editor.currPatternDisp = &modEntry->head.order[modEntry->currOrder]; |
| @@ -3588,7 +3592,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 18 unmodified lines | ||
| 3588 | 3592 | { |
| 3589 | 3593 | if (editor.currMode == MODE_IDLE || editor.currMode == MODE_EDIT) |
| 3590 | 3594 | { |
| 3591 | − if (input.mouse.rightButtonPressed) | |
| 3595 | + if (mouse.rightButtonPressed) | |
| 3592 | 3596 | { |
| 3593 | 3597 | modEntry->head.order[modEntry->currOrder] = 0; |
| 3594 | 3598 | |
| @@ -3615,7 +3619,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 20 unmodified lines | ||
| 3615 | 3619 | { |
| 3616 | 3620 | if (editor.currMode == MODE_IDLE || editor.currMode == MODE_EDIT) |
| 3617 | 3621 | { |
| 3618 | − if (input.mouse.rightButtonPressed) | |
| 3622 | + if (mouse.rightButtonPressed) | |
| 3619 | 3623 | { |
| 3620 | 3624 | modEntry->head.orderCount = 1; |
| 3621 | 3625 | |
| @@ -3674,7 +3678,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 52 unmodified lines | ||
| 3674 | 3678 | |
| 3675 | 3679 | case PTB_SVOLUMES: |
| 3676 | 3680 | { |
| 3677 | − if (input.mouse.rightButtonPressed) | |
| 3681 | + if (mouse.rightButtonPressed) | |
| 3678 | 3682 | { |
| 3679 | 3683 | modEntry->samples[editor.currSample].volume = 0; |
| 3680 | 3684 | } |
| @@ -3693,7 +3697,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 12 unmodified lines | ||
| 3693 | 3697 | |
| 3694 | 3698 | case PTB_SLENGTHS: |
| 3695 | 3699 | { |
| 3696 | − if (input.mouse.rightButtonPressed) | |
| 3700 | + if (mouse.rightButtonPressed) | |
| 3697 | 3701 | { |
| 3698 | 3702 | s = &modEntry->samples[editor.currSample]; |
| 3699 | 3703 | |
| @@ -3730,7 +3734,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 30 unmodified lines | ||
| 3730 | 3734 | |
| 3731 | 3735 | case PTB_SREPEATS: |
| 3732 | 3736 | { |
| 3733 | − if (input.mouse.rightButtonPressed) | |
| 3737 | + if (mouse.rightButtonPressed) | |
| 3734 | 3738 | { |
| 3735 | 3739 | s = &modEntry->samples[editor.currSample]; |
| 3736 | 3740 | |
| @@ -3770,7 +3774,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 33 unmodified lines | ||
| 3770 | 3774 | |
| 3771 | 3775 | case PTB_SREPLENS: |
| 3772 | 3776 | { |
| 3773 | − if (input.mouse.rightButtonPressed) | |
| 3777 | + if (mouse.rightButtonPressed) | |
| 3774 | 3778 | { |
| 3775 | 3779 | s = &modEntry->samples[editor.currSample]; |
| 3776 | 3780 | |
| @@ -3813,12 +3817,17 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 36 unmodified lines | ||
| 3813 | 3817 | |
| 3814 | 3818 | case PTB_EDITOP: |
| 3815 | 3819 | { |
| 3816 | − if (editor.ui.editOpScreen == 3) // chord screen | |
| 3817 | − editor.ui.editOpScreen = 0; | |
| 3818 | − else if (editor.ui.editOpScreenShown) | |
| 3819 | − editor.ui.editOpScreen = (editor.ui.editOpScreen + 1) % 3; | |
| 3820 | + if (editor.ui.editOpScreenShown) | |
| 3821 | + { | |
| 3822 | + if (editor.ui.editOpScreen == 3) | |
| 3823 | + editor.ui.editOpScreen = 0; | |
| 3824 | + else | |
| 3825 | + editor.ui.editOpScreen = (editor.ui.editOpScreen + 1) % 3; | |
| 3826 | + } | |
| 3820 | 3827 | else |
| 3828 | + { | |
| 3821 | 3829 | editor.ui.editOpScreenShown = true; |
| 3830 | + } | |
| 3822 | 3831 | |
| 3823 | 3832 | renderEditOpScreen(); |
| 3824 | 3833 | } |
| @@ -3927,7 +3936,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 102 unmodified lines | ||
| 3927 | 3936 | |
| 3928 | 3937 | case PTB_SA_ZOOMBARAREA: |
| 3929 | 3938 | { |
| 3930 | − input.mouse.lastGUIButton = button; | |
| 3939 | + mouse.lastGUIButton = button; | |
| 3931 | 3940 | if (!editor.ui.forceSampleDrag) |
| 3932 | 3941 | { |
| 3933 | 3942 | samplerBarPressed(MOUSE_BUTTON_NOT_HELD); |
| @@ -4083,7 +4092,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 149 unmodified lines | ||
| 4083 | 4092 | |
| 4084 | 4093 | case PTB_DO_DATAPATH: |
| 4085 | 4094 | { |
| 4086 | − if (input.mouse.rightButtonPressed) | |
| 4095 | + if (mouse.rightButtonPressed) | |
| 4087 | 4096 | { |
| 4088 | 4097 | memset(editor.currPath, 0, PATH_MAX + 1); |
| 4089 | 4098 | editor.ui.updateDiskOpPathText = true; |
| @@ -4101,7 +4110,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 11 unmodified lines | ||
| 4101 | 4110 | |
| 4102 | 4111 | case PTB_SONGNAME: |
| 4103 | 4112 | { |
| 4104 | − if (input.mouse.rightButtonPressed) | |
| 4113 | + if (mouse.rightButtonPressed) | |
| 4105 | 4114 | { |
| 4106 | 4115 | memset(modEntry->head.moduleTitle, 0, sizeof (modEntry->head.moduleTitle)); |
| 4107 | 4116 | editor.ui.updateSongName = true; |
| @@ -4122,7 +4131,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 14 unmodified lines | ||
| 4122 | 4131 | |
| 4123 | 4132 | case PTB_SAMPLENAME: |
| 4124 | 4133 | { |
| 4125 | − if (input.mouse.rightButtonPressed) | |
| 4134 | + if (mouse.rightButtonPressed) | |
| 4126 | 4135 | { |
| 4127 | 4136 | memset(modEntry->samples[editor.currSample].text, 0, sizeof (modEntry->samples[editor.currSample].text)); |
| 4128 | 4137 | editor.ui.updateCurrSampleName = true; |
| @@ -4186,7 +4195,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 57 unmodified lines | ||
| 4186 | 4195 | { |
| 4187 | 4196 | editor.ui.aboutScreenShown = false; |
| 4188 | 4197 | } |
| 4189 | − else if (!input.mouse.rightButtonPressed) | |
| 4198 | + else if (!mouse.rightButtonPressed) | |
| 4190 | 4199 | { |
| 4191 | 4200 | editor.ui.visualizerMode = (editor.ui.visualizerMode + 1) % 2; |
| 4192 | 4201 | if (editor.ui.visualizerMode == VISUAL_SPECTRUM) |
| @@ -4212,7 +4221,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 19 unmodified lines | ||
| 4212 | 4221 | |
| 4213 | 4222 | case PTB_CHAN1: |
| 4214 | 4223 | { |
| 4215 | − if (input.mouse.rightButtonPressed) | |
| 4224 | + if (mouse.rightButtonPressed) | |
| 4216 | 4225 | { |
| 4217 | 4226 | editor.muted[0] = false; |
| 4218 | 4227 | editor.muted[1] = true; |
| @@ -4230,7 +4239,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 11 unmodified lines | ||
| 4230 | 4239 | |
| 4231 | 4240 | case PTB_CHAN2: |
| 4232 | 4241 | { |
| 4233 | − if (input.mouse.rightButtonPressed) | |
| 4242 | + if (mouse.rightButtonPressed) | |
| 4234 | 4243 | { |
| 4235 | 4244 | editor.muted[0] = true; |
| 4236 | 4245 | editor.muted[1] = false; |
| @@ -4248,7 +4257,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 11 unmodified lines | ||
| 4248 | 4257 | |
| 4249 | 4258 | case PTB_CHAN3: |
| 4250 | 4259 | { |
| 4251 | − if (input.mouse.rightButtonPressed) | |
| 4260 | + if (mouse.rightButtonPressed) | |
| 4252 | 4261 | { |
| 4253 | 4262 | editor.muted[0] = true; |
| 4254 | 4263 | editor.muted[1] = true; |
| @@ -4266,7 +4275,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 11 unmodified lines | ||
| 4266 | 4275 | |
| 4267 | 4276 | case PTB_CHAN4: |
| 4268 | 4277 | { |
| 4269 | − if (input.mouse.rightButtonPressed) | |
| 4278 | + if (mouse.rightButtonPressed) | |
| 4270 | 4279 | { |
| 4271 | 4280 | editor.muted[0] = true; |
| 4272 | 4281 | editor.muted[1] = true; |
| @@ -4285,7 +4294,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 12 unmodified lines | ||
| 4285 | 4294 | case PTB_SAMPLER: samplerScreen(); break; |
| 4286 | 4295 | case PTB_SA_EXIT: exitFromSam(); break; |
| 4287 | 4296 | |
| 4288 | − case PTB_DO_FILEAREA: diskOpLoadFile((input.mouse.y - 34) / 6, true); break; | |
| 4297 | + case PTB_DO_FILEAREA: diskOpLoadFile((mouse.y - 34) / 6, true); break; | |
| 4289 | 4298 | case PTB_DO_PARENT: |
| 4290 | 4299 | { |
| 4291 | 4300 | #ifdef _WIN32 |
| @@ -4366,7 +4375,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 74 unmodified lines | ||
| 4366 | 4375 | { |
| 4367 | 4376 | editor.playMode = PLAY_MODE_NORMAL; |
| 4368 | 4377 | |
| 4369 | − if (input.mouse.rightButtonPressed) | |
| 4378 | + if (mouse.rightButtonPressed) | |
| 4370 | 4379 | modPlay(DONT_SET_PATTERN, modEntry->currOrder, modEntry->currRow); |
| 4371 | 4380 | else |
| 4372 | 4381 | modPlay(DONT_SET_PATTERN, modEntry->currOrder, DONT_SET_ROW); |
| @@ -4381,7 +4390,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 8 unmodified lines | ||
| 4381 | 4390 | { |
| 4382 | 4391 | editor.playMode = PLAY_MODE_PATTERN; |
| 4383 | 4392 | |
| 4384 | − if (input.mouse.rightButtonPressed) | |
| 4393 | + if (mouse.rightButtonPressed) | |
| 4385 | 4394 | modPlay(modEntry->currPattern, DONT_SET_ORDER, modEntry->currRow); |
| 4386 | 4395 | else |
| 4387 | 4396 | modPlay(modEntry->currPattern, DONT_SET_ORDER, DONT_SET_ROW); |
| @@ -4411,7 +4420,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 23 unmodified lines | ||
| 4411 | 4420 | { |
| 4412 | 4421 | editor.playMode = PLAY_MODE_PATTERN; |
| 4413 | 4422 | |
| 4414 | − if (input.mouse.rightButtonPressed) | |
| 4423 | + if (mouse.rightButtonPressed) | |
| 4415 | 4424 | modPlay(modEntry->currPattern, DONT_SET_ORDER, modEntry->currRow); |
| 4416 | 4425 | else |
| 4417 | 4426 | modPlay(modEntry->currPattern, DONT_SET_ORDER, DONT_SET_ROW); |
| @@ -4486,7 +4495,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 68 unmodified lines | ||
| 4486 | 4495 | |
| 4487 | 4496 | case PTB_SAMPLEU: |
| 4488 | 4497 | { |
| 4489 | − if (input.mouse.rightButtonPressed) | |
| 4498 | + if (mouse.rightButtonPressed) | |
| 4490 | 4499 | { |
| 4491 | 4500 | editor.sampleZero = true; |
| 4492 | 4501 | editor.ui.updateCurrSampleNum = true; |
| @@ -4500,7 +4509,7 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 7 unmodified lines | ||
| 4500 | 4509 | |
| 4501 | 4510 | case PTB_SAMPLED: |
| 4502 | 4511 | { |
| 4503 | − if (input.mouse.rightButtonPressed) | |
| 4512 | + if (mouse.rightButtonPressed) | |
| 4504 | 4513 | { |
| 4505 | 4514 | editor.sampleZero = true; |
| 4506 | 4515 | editor.ui.updateCurrSampleNum = true; |
| @@ -4658,20 +4667,20 @@ static bool handleGUIButtons(int32_t button) // are you prepared to enter the ju · 151 unmodified lines | ||
| 4658 | 4667 | default: displayErrorMsg("NOT IMPLEMENTED"); return false; // button not mapped |
| 4659 | 4668 | } |
| 4660 | 4669 | |
| 4661 | − input.mouse.lastGUIButton = button; | |
| 4670 | + mouse.lastGUIButton = button; | |
| 4662 | 4671 | return false; |
| 4663 | 4672 | } |
| 4664 | 4673 | |
| 4665 | 4674 | static void handleRepeatedGUIButtons(void) |
| 4666 | 4675 | { |
| 4667 | 4676 | // repeat button |
| 4668 | − switch (input.mouse.lastGUIButton) | |
| 4677 | + switch (mouse.lastGUIButton) | |
| 4669 | 4678 | { |
| 4670 | 4679 | case PTB_EO_NOTE1_UP: |
| 4671 | 4680 | { |
| 4672 | − if (input.mouse.repeatCounter >= 4) | |
| 4681 | + if (mouse.repeatCounter >= 4) | |
| 4673 | 4682 | { |
| 4674 | − input.mouse.repeatCounter = 0; | |
| 4683 | + mouse.repeatCounter = 0; | |
| 4675 | 4684 | edNote1UpButton(); |
| 4676 | 4685 | } |
| 4677 | 4686 | } |
| @@ -4679,9 +4688,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4679 | 4688 | |
| 4680 | 4689 | case PTB_EO_NOTE1_DOWN: |
| 4681 | 4690 | { |
| 4682 | − if (input.mouse.repeatCounter >= 4) | |
| 4691 | + if (mouse.repeatCounter >= 4) | |
| 4683 | 4692 | { |
| 4684 | − input.mouse.repeatCounter = 0; | |
| 4693 | + mouse.repeatCounter = 0; | |
| 4685 | 4694 | edNote1DownButton(); |
| 4686 | 4695 | } |
| 4687 | 4696 | } |
| @@ -4689,9 +4698,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4689 | 4698 | |
| 4690 | 4699 | case PTB_EO_NOTE2_UP: |
| 4691 | 4700 | { |
| 4692 | − if (input.mouse.repeatCounter >= 4) | |
| 4701 | + if (mouse.repeatCounter >= 4) | |
| 4693 | 4702 | { |
| 4694 | − input.mouse.repeatCounter = 0; | |
| 4703 | + mouse.repeatCounter = 0; | |
| 4695 | 4704 | edNote2UpButton(); |
| 4696 | 4705 | } |
| 4697 | 4706 | } |
| @@ -4699,9 +4708,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4699 | 4708 | |
| 4700 | 4709 | case PTB_EO_NOTE2_DOWN: |
| 4701 | 4710 | { |
| 4702 | − if (input.mouse.repeatCounter >= 4) | |
| 4711 | + if (mouse.repeatCounter >= 4) | |
| 4703 | 4712 | { |
| 4704 | − input.mouse.repeatCounter = 0; | |
| 4713 | + mouse.repeatCounter = 0; | |
| 4705 | 4714 | edNote2DownButton(); |
| 4706 | 4715 | } |
| 4707 | 4716 | } |
| @@ -4709,9 +4718,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4709 | 4718 | |
| 4710 | 4719 | case PTB_EO_NOTE3_UP: |
| 4711 | 4720 | { |
| 4712 | − if (input.mouse.repeatCounter >= 4) | |
| 4721 | + if (mouse.repeatCounter >= 4) | |
| 4713 | 4722 | { |
| 4714 | − input.mouse.repeatCounter = 0; | |
| 4723 | + mouse.repeatCounter = 0; | |
| 4715 | 4724 | edNote3UpButton(); |
| 4716 | 4725 | } |
| 4717 | 4726 | } |
| @@ -4719,9 +4728,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4719 | 4728 | |
| 4720 | 4729 | case PTB_EO_NOTE3_DOWN: |
| 4721 | 4730 | { |
| 4722 | − if (input.mouse.repeatCounter >= 4) | |
| 4731 | + if (mouse.repeatCounter >= 4) | |
| 4723 | 4732 | { |
| 4724 | − input.mouse.repeatCounter = 0; | |
| 4733 | + mouse.repeatCounter = 0; | |
| 4725 | 4734 | edNote3DownButton(); |
| 4726 | 4735 | } |
| 4727 | 4736 | } |
| @@ -4729,9 +4738,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4729 | 4738 | |
| 4730 | 4739 | case PTB_EO_NOTE4_UP: |
| 4731 | 4740 | { |
| 4732 | − if (input.mouse.repeatCounter >= 4) | |
| 4741 | + if (mouse.repeatCounter >= 4) | |
| 4733 | 4742 | { |
| 4734 | − input.mouse.repeatCounter = 0; | |
| 4743 | + mouse.repeatCounter = 0; | |
| 4735 | 4744 | edNote4UpButton(); |
| 4736 | 4745 | } |
| 4737 | 4746 | } |
| @@ -4739,9 +4748,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4739 | 4748 | |
| 4740 | 4749 | case PTB_EO_NOTE4_DOWN: |
| 4741 | 4750 | { |
| 4742 | − if (input.mouse.repeatCounter >= 4) | |
| 4751 | + if (mouse.repeatCounter >= 4) | |
| 4743 | 4752 | { |
| 4744 | − input.mouse.repeatCounter = 0; | |
| 4753 | + mouse.repeatCounter = 0; | |
| 4745 | 4754 | edNote4DownButton(); |
| 4746 | 4755 | } |
| 4747 | 4756 | } |
| @@ -4749,9 +4758,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4749 | 4758 | |
| 4750 | 4759 | case PTB_EO_VOL_UP: |
| 4751 | 4760 | { |
| 4752 | − if (input.mouse.repeatCounter >= 2) | |
| 4761 | + if (mouse.repeatCounter >= 2) | |
| 4753 | 4762 | { |
| 4754 | − input.mouse.repeatCounter = 0; | |
| 4763 | + mouse.repeatCounter = 0; | |
| 4755 | 4764 | edVolUpButton(); |
| 4756 | 4765 | } |
| 4757 | 4766 | } |
| @@ -4759,9 +4768,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4759 | 4768 | |
| 4760 | 4769 | case PTB_EO_VOL_DOWN: |
| 4761 | 4770 | { |
| 4762 | − if (input.mouse.repeatCounter >= 2) | |
| 4771 | + if (mouse.repeatCounter >= 2) | |
| 4763 | 4772 | { |
| 4764 | − input.mouse.repeatCounter = 0; | |
| 4773 | + mouse.repeatCounter = 0; | |
| 4765 | 4774 | edVolDownButton(); |
| 4766 | 4775 | } |
| 4767 | 4776 | } |
| @@ -4769,9 +4778,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4769 | 4778 | |
| 4770 | 4779 | case PTB_EO_MOD_UP: |
| 4771 | 4780 | { |
| 4772 | − if (input.mouse.repeatCounter >= 2) | |
| 4781 | + if (mouse.repeatCounter >= 2) | |
| 4773 | 4782 | { |
| 4774 | − input.mouse.repeatCounter = 0; | |
| 4783 | + mouse.repeatCounter = 0; | |
| 4775 | 4784 | edModUpButton(); |
| 4776 | 4785 | } |
| 4777 | 4786 | } |
| @@ -4779,9 +4788,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4779 | 4788 | |
| 4780 | 4789 | case PTB_EO_MOD_DOWN: |
| 4781 | 4790 | { |
| 4782 | − if (input.mouse.repeatCounter >= 2) | |
| 4791 | + if (mouse.repeatCounter >= 2) | |
| 4783 | 4792 | { |
| 4784 | − input.mouse.repeatCounter = 0; | |
| 4793 | + mouse.repeatCounter = 0; | |
| 4785 | 4794 | edModDownButton(); |
| 4786 | 4795 | } |
| 4787 | 4796 | } |
| @@ -4789,9 +4798,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4789 | 4798 | |
| 4790 | 4799 | case PTB_EO_POS_UP: |
| 4791 | 4800 | { |
| 4792 | − if (input.mouse.repeatCounter >= 1) | |
| 4801 | + if (mouse.repeatCounter >= 1) | |
| 4793 | 4802 | { |
| 4794 | − input.mouse.repeatCounter = 0; | |
| 4803 | + mouse.repeatCounter = 0; | |
| 4795 | 4804 | edPosUpButton(INCREMENT_FAST); |
| 4796 | 4805 | } |
| 4797 | 4806 | } |
| @@ -4799,9 +4808,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4799 | 4808 | |
| 4800 | 4809 | case PTB_EO_POS_DOWN: |
| 4801 | 4810 | { |
| 4802 | − if (input.mouse.repeatCounter >= 1) | |
| 4811 | + if (mouse.repeatCounter >= 1) | |
| 4803 | 4812 | { |
| 4804 | − input.mouse.repeatCounter = 0; | |
| 4813 | + mouse.repeatCounter = 0; | |
| 4805 | 4814 | edPosDownButton(INCREMENT_FAST); |
| 4806 | 4815 | } |
| 4807 | 4816 | } |
| @@ -4809,9 +4818,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4809 | 4818 | |
| 4810 | 4819 | case PTB_EO_FROM_UP: |
| 4811 | 4820 | { |
| 4812 | − if (input.mouse.repeatCounter >= 2) | |
| 4821 | + if (mouse.repeatCounter >= 2) | |
| 4813 | 4822 | { |
| 4814 | − input.mouse.repeatCounter = 0; | |
| 4823 | + mouse.repeatCounter = 0; | |
| 4815 | 4824 | if (editor.sampleFrom < 0x1F) |
| 4816 | 4825 | { |
| 4817 | 4826 | editor.sampleFrom++; |
| @@ -4823,9 +4832,9 @@ static void handleRepeatedGUIButtons(void) · 5 unmodified lines | ||
| 4823 | 4832 | |
| 4824 | 4833 | case PTB_EO_FROM_DOWN: |
| 4825 | 4834 | { |
| 4826 | − if (input.mouse.repeatCounter >= 2) | |
| 4835 | + if (mouse.repeatCounter >= 2) | |
| 4827 | 4836 | { |
| 4828 | − input.mouse.repeatCounter = 0; | |
| 4837 | + mouse.repeatCounter = 0; | |
| 4829 | 4838 | if (editor.sampleFrom > 0x00) |
| 4830 | 4839 | { |
| 4831 | 4840 | editor.sampleFrom--; |
| @@ -4837,9 +4846,9 @@ static void handleRepeatedGUIButtons(void) · 5 unmodified lines | ||
| 4837 | 4846 | |
| 4838 | 4847 | case PTB_EO_TO_UP: |
| 4839 | 4848 | { |
| 4840 | − if (input.mouse.repeatCounter >= 2) | |
| 4849 | + if (mouse.repeatCounter >= 2) | |
| 4841 | 4850 | { |
| 4842 | − input.mouse.repeatCounter = 0; | |
| 4851 | + mouse.repeatCounter = 0; | |
| 4843 | 4852 | if (editor.sampleTo < 0x1F) |
| 4844 | 4853 | { |
| 4845 | 4854 | editor.sampleTo++; |
| @@ -4851,9 +4860,9 @@ static void handleRepeatedGUIButtons(void) · 5 unmodified lines | ||
| 4851 | 4860 | |
| 4852 | 4861 | case PTB_EO_TO_DOWN: |
| 4853 | 4862 | { |
| 4854 | − if (input.mouse.repeatCounter >= 2) | |
| 4863 | + if (mouse.repeatCounter >= 2) | |
| 4855 | 4864 | { |
| 4856 | − input.mouse.repeatCounter = 0; | |
| 4865 | + mouse.repeatCounter = 0; | |
| 4857 | 4866 | if (editor.sampleTo > 0x00) |
| 4858 | 4867 | { |
| 4859 | 4868 | editor.sampleTo--; |
| @@ -4865,10 +4874,10 @@ static void handleRepeatedGUIButtons(void) · 5 unmodified lines | ||
| 4865 | 4874 | |
| 4866 | 4875 | case PTB_SAMPLEU: |
| 4867 | 4876 | { |
| 4868 | − if (input.mouse.repeatCounter >= 5) | |
| 4877 | + if (mouse.repeatCounter >= 5) | |
| 4869 | 4878 | { |
| 4870 | − input.mouse.repeatCounter = 0; | |
| 4871 | − if (!input.mouse.rightButtonPressed) | |
| 4879 | + mouse.repeatCounter = 0; | |
| 4880 | + if (!mouse.rightButtonPressed) | |
| 4872 | 4881 | sampleUpButton(); |
| 4873 | 4882 | else |
| 4874 | 4883 | editor.ui.updateCurrSampleNum = true; |
| @@ -4878,10 +4887,10 @@ static void handleRepeatedGUIButtons(void) · 3 unmodified lines | ||
| 4878 | 4887 | |
| 4879 | 4888 | case PTB_SAMPLED: |
| 4880 | 4889 | { |
| 4881 | − if (input.mouse.repeatCounter >= 5) | |
| 4890 | + if (mouse.repeatCounter >= 5) | |
| 4882 | 4891 | { |
| 4883 | − input.mouse.repeatCounter = 0; | |
| 4884 | − if (!input.mouse.rightButtonPressed) | |
| 4892 | + mouse.repeatCounter = 0; | |
| 4893 | + if (!mouse.rightButtonPressed) | |
| 4885 | 4894 | sampleDownButton(); |
| 4886 | 4895 | else |
| 4887 | 4896 | editor.ui.updateCurrSampleNum = true; |
| @@ -4891,9 +4900,9 @@ static void handleRepeatedGUIButtons(void) · 3 unmodified lines | ||
| 4891 | 4900 | |
| 4892 | 4901 | case PTB_FTUNEU: |
| 4893 | 4902 | { |
| 4894 | − if (input.mouse.repeatCounter >= 5) | |
| 4903 | + if (mouse.repeatCounter >= 5) | |
| 4895 | 4904 | { |
| 4896 | − input.mouse.repeatCounter = 0; | |
| 4905 | + mouse.repeatCounter = 0; | |
| 4897 | 4906 | sampleFineTuneUpButton(); |
| 4898 | 4907 | } |
| 4899 | 4908 | } |
| @@ -4901,9 +4910,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4901 | 4910 | |
| 4902 | 4911 | case PTB_FTUNED: |
| 4903 | 4912 | { |
| 4904 | − if (input.mouse.repeatCounter >= 5) | |
| 4913 | + if (mouse.repeatCounter >= 5) | |
| 4905 | 4914 | { |
| 4906 | − input.mouse.repeatCounter = 0; | |
| 4915 | + mouse.repeatCounter = 0; | |
| 4907 | 4916 | sampleFineTuneDownButton(); |
| 4908 | 4917 | } |
| 4909 | 4918 | } |
| @@ -4911,9 +4920,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4911 | 4920 | |
| 4912 | 4921 | case PTB_SVOLUMEU: |
| 4913 | 4922 | { |
| 4914 | − if (input.mouse.repeatCounter >= 5) | |
| 4923 | + if (mouse.repeatCounter >= 5) | |
| 4915 | 4924 | { |
| 4916 | − input.mouse.repeatCounter = 0; | |
| 4925 | + mouse.repeatCounter = 0; | |
| 4917 | 4926 | sampleVolumeUpButton(); |
| 4918 | 4927 | } |
| 4919 | 4928 | } |
| @@ -4921,9 +4930,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4921 | 4930 | |
| 4922 | 4931 | case PTB_SVOLUMED: |
| 4923 | 4932 | { |
| 4924 | − if (input.mouse.repeatCounter >= 5) | |
| 4933 | + if (mouse.repeatCounter >= 5) | |
| 4925 | 4934 | { |
| 4926 | − input.mouse.repeatCounter = 0; | |
| 4935 | + mouse.repeatCounter = 0; | |
| 4927 | 4936 | sampleVolumeDownButton(); |
| 4928 | 4937 | } |
| 4929 | 4938 | } |
| @@ -4931,9 +4940,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4931 | 4940 | |
| 4932 | 4941 | case PTB_SLENGTHU: |
| 4933 | 4942 | { |
| 4934 | − if (input.mouse.rightButtonPressed || input.mouse.repeatCounter >= 1) | |
| 4943 | + if (mouse.rightButtonPressed || mouse.repeatCounter >= 1) | |
| 4935 | 4944 | { |
| 4936 | − input.mouse.repeatCounter = 0; | |
| 4945 | + mouse.repeatCounter = 0; | |
| 4937 | 4946 | sampleLengthUpButton(INCREMENT_FAST); |
| 4938 | 4947 | } |
| 4939 | 4948 | } |
| @@ -4941,9 +4950,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4941 | 4950 | |
| 4942 | 4951 | case PTB_SLENGTHD: |
| 4943 | 4952 | { |
| 4944 | − if (input.mouse.rightButtonPressed || input.mouse.repeatCounter >= 1) | |
| 4953 | + if (mouse.rightButtonPressed || mouse.repeatCounter >= 1) | |
| 4945 | 4954 | { |
| 4946 | − input.mouse.repeatCounter = 0; | |
| 4955 | + mouse.repeatCounter = 0; | |
| 4947 | 4956 | sampleLengthDownButton(INCREMENT_FAST); |
| 4948 | 4957 | } |
| 4949 | 4958 | } |
| @@ -4951,9 +4960,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4951 | 4960 | |
| 4952 | 4961 | case PTB_SREPEATU: |
| 4953 | 4962 | { |
| 4954 | − if (input.mouse.rightButtonPressed || input.mouse.repeatCounter >= 1) | |
| 4963 | + if (mouse.rightButtonPressed || mouse.repeatCounter >= 1) | |
| 4955 | 4964 | { |
| 4956 | − input.mouse.repeatCounter = 0; | |
| 4965 | + mouse.repeatCounter = 0; | |
| 4957 | 4966 | sampleRepeatUpButton(INCREMENT_FAST); |
| 4958 | 4967 | } |
| 4959 | 4968 | } |
| @@ -4961,9 +4970,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4961 | 4970 | |
| 4962 | 4971 | case PTB_SREPEATD: |
| 4963 | 4972 | { |
| 4964 | − if (input.mouse.rightButtonPressed || input.mouse.repeatCounter >= 1) | |
| 4973 | + if (mouse.rightButtonPressed || mouse.repeatCounter >= 1) | |
| 4965 | 4974 | { |
| 4966 | − input.mouse.repeatCounter = 0; | |
| 4975 | + mouse.repeatCounter = 0; | |
| 4967 | 4976 | sampleRepeatDownButton(INCREMENT_FAST); |
| 4968 | 4977 | } |
| 4969 | 4978 | } |
| @@ -4971,9 +4980,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4971 | 4980 | |
| 4972 | 4981 | case PTB_SREPLENU: |
| 4973 | 4982 | { |
| 4974 | − if (input.mouse.rightButtonPressed || input.mouse.repeatCounter >= 1) | |
| 4983 | + if (mouse.rightButtonPressed || mouse.repeatCounter >= 1) | |
| 4975 | 4984 | { |
| 4976 | − input.mouse.repeatCounter = 0; | |
| 4985 | + mouse.repeatCounter = 0; | |
| 4977 | 4986 | sampleRepeatLengthUpButton(INCREMENT_FAST); |
| 4978 | 4987 | } |
| 4979 | 4988 | } |
| @@ -4981,9 +4990,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4981 | 4990 | |
| 4982 | 4991 | case PTB_SREPLEND: |
| 4983 | 4992 | { |
| 4984 | − if (input.mouse.rightButtonPressed || input.mouse.repeatCounter >= 1) | |
| 4993 | + if (mouse.rightButtonPressed || mouse.repeatCounter >= 1) | |
| 4985 | 4994 | { |
| 4986 | − input.mouse.repeatCounter = 0; | |
| 4995 | + mouse.repeatCounter = 0; | |
| 4987 | 4996 | sampleRepeatLengthDownButton(INCREMENT_FAST); |
| 4988 | 4997 | } |
| 4989 | 4998 | } |
| @@ -4991,9 +5000,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 4991 | 5000 | |
| 4992 | 5001 | case PTB_TEMPOU: |
| 4993 | 5002 | { |
| 4994 | − if (input.mouse.repeatCounter >= 3) | |
| 5003 | + if (mouse.repeatCounter >= 3) | |
| 4995 | 5004 | { |
| 4996 | − input.mouse.repeatCounter = 0; | |
| 5005 | + mouse.repeatCounter = 0; | |
| 4997 | 5006 | tempoUpButton(); |
| 4998 | 5007 | } |
| 4999 | 5008 | } |
| @@ -5001,9 +5010,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 5001 | 5010 | |
| 5002 | 5011 | case PTB_TEMPOD: |
| 5003 | 5012 | { |
| 5004 | − if (input.mouse.repeatCounter >= 3) | |
| 5013 | + if (mouse.repeatCounter >= 3) | |
| 5005 | 5014 | { |
| 5006 | − input.mouse.repeatCounter = 0; | |
| 5015 | + mouse.repeatCounter = 0; | |
| 5007 | 5016 | tempoDownButton(); |
| 5008 | 5017 | } |
| 5009 | 5018 | } |
| @@ -5011,9 +5020,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 5011 | 5020 | |
| 5012 | 5021 | case PTB_LENGTHU: |
| 5013 | 5022 | { |
| 5014 | − if (input.mouse.repeatCounter >= 7) | |
| 5023 | + if (mouse.repeatCounter >= 7) | |
| 5015 | 5024 | { |
| 5016 | − input.mouse.repeatCounter = 0; | |
| 5025 | + mouse.repeatCounter = 0; | |
| 5017 | 5026 | songLengthUpButton(); |
| 5018 | 5027 | } |
| 5019 | 5028 | } |
| @@ -5021,9 +5030,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 5021 | 5030 | |
| 5022 | 5031 | case PTB_LENGTHD: |
| 5023 | 5032 | { |
| 5024 | − if (input.mouse.repeatCounter >= 7) | |
| 5033 | + if (mouse.repeatCounter >= 7) | |
| 5025 | 5034 | { |
| 5026 | − input.mouse.repeatCounter = 0; | |
| 5035 | + mouse.repeatCounter = 0; | |
| 5027 | 5036 | songLengthDownButton(); |
| 5028 | 5037 | } |
| 5029 | 5038 | } |
| @@ -5031,9 +5040,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 5031 | 5040 | |
| 5032 | 5041 | case PTB_PATTERNU: |
| 5033 | 5042 | { |
| 5034 | − if (input.mouse.repeatCounter >= 7) | |
| 5043 | + if (mouse.repeatCounter >= 7) | |
| 5035 | 5044 | { |
| 5036 | − input.mouse.repeatCounter = 0; | |
| 5045 | + mouse.repeatCounter = 0; | |
| 5037 | 5046 | patternUpButton(); |
| 5038 | 5047 | } |
| 5039 | 5048 | } |
| @@ -5041,9 +5050,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 5041 | 5050 | |
| 5042 | 5051 | case PTB_PATTERND: |
| 5043 | 5052 | { |
| 5044 | − if (input.mouse.repeatCounter >= 7) | |
| 5053 | + if (mouse.repeatCounter >= 7) | |
| 5045 | 5054 | { |
| 5046 | − input.mouse.repeatCounter = 0; | |
| 5055 | + mouse.repeatCounter = 0; | |
| 5047 | 5056 | patternDownButton(); |
| 5048 | 5057 | } |
| 5049 | 5058 | } |
| @@ -5051,9 +5060,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 5051 | 5060 | |
| 5052 | 5061 | case PTB_POSU: |
| 5053 | 5062 | { |
| 5054 | − if (input.mouse.repeatCounter >= 7) | |
| 5063 | + if (mouse.repeatCounter >= 7) | |
| 5055 | 5064 | { |
| 5056 | − input.mouse.repeatCounter = 0; | |
| 5065 | + mouse.repeatCounter = 0; | |
| 5057 | 5066 | positionUpButton(); |
| 5058 | 5067 | } |
| 5059 | 5068 | } |
| @@ -5061,9 +5070,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 5061 | 5070 | |
| 5062 | 5071 | case PTB_POSD: |
| 5063 | 5072 | { |
| 5064 | − if (input.mouse.repeatCounter >= 7) | |
| 5073 | + if (mouse.repeatCounter >= 7) | |
| 5065 | 5074 | { |
| 5066 | − input.mouse.repeatCounter = 0; | |
| 5075 | + mouse.repeatCounter = 0; | |
| 5067 | 5076 | positionDownButton(); |
| 5068 | 5077 | } |
| 5069 | 5078 | } |
| @@ -5071,9 +5080,9 @@ static void handleRepeatedGUIButtons(void) · 1 unmodified line | ||
| 5071 | 5080 | |
| 5072 | 5081 | case PTB_PE_SCROLLUP: |
| 5073 | 5082 | { |
| 5074 | − if (input.mouse.repeatCounter >= 2) | |
| 5083 | + if (mouse.repeatCounter >= 2) | |
| 5075 | 5084 | { |
| 5076 | − input.mouse.repeatCounter = 0; | |
| 5085 | + mouse.repeatCounter = 0; | |
| 5077 | 5086 | if (modEntry->currOrder > 0) |
| 5078 | 5087 | modSetPos(modEntry->currOrder - 1, DONT_SET_ROW); |
| 5079 | 5088 | } |
| @@ -5082,9 +5091,9 @@ static void handleRepeatedGUIButtons(void) · 2 unmodified lines | ||
| 5082 | 5091 | |
| 5083 | 5092 | case PTB_PE_SCROLLDOWN: |
| 5084 | 5093 | { |
| 5085 | − if (input.mouse.repeatCounter >= 2) | |
| 5094 | + if (mouse.repeatCounter >= 2) | |
| 5086 | 5095 | { |
| 5087 | − input.mouse.repeatCounter = 0; | |
| 5096 | + mouse.repeatCounter = 0; | |
| 5088 | 5097 | if (modEntry->currOrder < modEntry->head.orderCount-1) |
| 5089 | 5098 | modSetPos(modEntry->currOrder + 1, DONT_SET_ROW); |
| 5090 | 5099 | } |
| @@ -5093,12 +5102,12 @@ static void handleRepeatedGUIButtons(void) · 2 unmodified lines | ||
| 5093 | 5102 | |
| 5094 | 5103 | case PTB_DO_SCROLLUP: |
| 5095 | 5104 | { |
| 5096 | − if (input.mouse.repeatCounter >= 1) | |
| 5105 | + if (mouse.repeatCounter >= 1) | |
| 5097 | 5106 | { |
| 5098 | − input.mouse.repeatCounter = 0; | |
| 5107 | + mouse.repeatCounter = 0; | |
| 5099 | 5108 | |
| 5100 | 5109 | editor.diskop.scrollOffset--; |
| 5101 | − if (input.mouse.rightButtonPressed) | |
| 5110 | + if (mouse.rightButtonPressed) | |
| 5102 | 5111 | editor.diskop.scrollOffset -= 3; |
| 5103 | 5112 | |
| 5104 | 5113 | if (editor.diskop.scrollOffset < 0) |
| @@ -5111,14 +5120,14 @@ static void handleRepeatedGUIButtons(void) · 6 unmodified lines | ||
| 5111 | 5120 | |
| 5112 | 5121 | case PTB_DO_SCROLLDOWN: |
| 5113 | 5122 | { |
| 5114 | − if (input.mouse.repeatCounter >= 1) | |
| 5123 | + if (mouse.repeatCounter >= 1) | |
| 5115 | 5124 | { |
| 5116 | − input.mouse.repeatCounter = 0; | |
| 5125 | + mouse.repeatCounter = 0; | |
| 5117 | 5126 | |
| 5118 | 5127 | if (editor.diskop.numEntries > DISKOP_LINES) |
| 5119 | 5128 | { |
| 5120 | 5129 | editor.diskop.scrollOffset++; |
| 5121 | − if (input.mouse.rightButtonPressed) | |
| 5130 | + if (mouse.rightButtonPressed) | |
| 5122 | 5131 | editor.diskop.scrollOffset += 3; |
| 5123 | 5132 | |
| 5124 | 5133 | if (editor.diskop.scrollOffset > editor.diskop.numEntries-DISKOP_LINES) |
| @@ -5132,9 +5141,9 @@ static void handleRepeatedGUIButtons(void) · 7 unmodified lines | ||
| 5132 | 5141 | |
| 5133 | 5142 | case PTB_SA_ZOOMBARAREA: |
| 5134 | 5143 | { |
| 5135 | − if (input.mouse.repeatCounter >= 4) | |
| 5144 | + if (mouse.repeatCounter >= 4) | |
| 5136 | 5145 | { |
| 5137 | − input.mouse.repeatCounter = 0; | |
| 5146 | + mouse.repeatCounter = 0; | |
| 5138 | 5147 | if (!editor.ui.forceSampleDrag) |
| 5139 | 5148 | samplerBarPressed(MOUSE_BUTTON_NOT_HELD); |
| 5140 | 5149 | } |
| @@ -1,28 +1,21 @@ | ||
| 1 | −#include <stdint.h> | |
| 2 | 1 | #include "pt2_palette.h" |
| 3 | 2 | #include "pt2_header.h" |
| 4 | −#include "pt2_helpers.h" | |
| 5 | −#include "pt2_tables.h" | |
| 6 | 3 | |
| 7 | −uint32_t palette[PALETTE_NUM] = | |
| 4 | +void setDefaultPalette(void) | |
| 8 | 5 | { |
| 9 | − // ----------------------------- | |
| 10 | − 0x000000, // 00- PAL_BACKGRD | |
| 11 | − 0xBBBBBB, // 01- PAL_BORDER | |
| 12 | − 0x888888, // 02- PAL_GENBKG | |
| 13 | − 0x555555, // 03- PAL_GENBKG2 | |
| 14 | − 0xFFDD00, // 04- PAL_QADSCP | |
| 15 | − 0xDD0044, // 05- PAL_PATCURSOR | |
| 16 | − 0x000000, // 06- PAL_GENTXT | |
| 17 | − 0x3344FF, // 07- PAL_PATTXT | |
| 18 | − // ----------------------------- | |
| 19 | − 0x00FFFF, // 08- PAL_SAMPLLINE | |
| 20 | − 0x0000FF, // 09- PAL_LOOPPIN | |
| 21 | − 0x770077, // 10- PAL_TEXTMARK | |
| 22 | − 0x444444, // 11- PAL_MOUSE_1 | |
| 23 | − 0x777777, // 12- PAL_MOUSE_2 | |
| 24 | − 0xAAAAAA, // 13- PAL_MOUSE_3 | |
| 25 | − // ----------------------------- | |
| 26 | − 0xC0FFEE // 14- PAL_COLORKEY | |
| 27 | − // ----------------------------- | |
| 28 | −}; | |
| 6 | + video.palette[PAL_BACKGRD] = 0x000000; | |
| 7 | + video.palette[PAL_BORDER] = 0xBBBBBB; | |
| 8 | + video.palette[PAL_GENBKG] = 0x888888; | |
| 9 | + video.palette[PAL_GENBKG2] = 0x555555; | |
| 10 | + video.palette[PAL_QADSCP] = 0xFFDD00; | |
| 11 | + video.palette[PAL_PATCURSOR] = 0xDD0044; | |
| 12 | + video.palette[PAL_GENTXT] = 0x000000; | |
| 13 | + video.palette[PAL_PATTXT] = 0x3344FF; | |
| 14 | + video.palette[PAL_SAMPLLINE] = 0x00FFFF; | |
| 15 | + video.palette[PAL_LOOPPIN] = 0x0000FF; | |
| 16 | + video.palette[PAL_TEXTMARK] = 0x770077; | |
| 17 | + video.palette[PAL_MOUSE_1] = 0x444444; | |
| 18 | + video.palette[PAL_MOUSE_2] = 0x777777; | |
| 19 | + video.palette[PAL_MOUSE_3] = 0xAAAAAA; | |
| 20 | + video.palette[PAL_COLORKEY] = 0xC0FFEE; | |
| 21 | +} | |
| @@ -1,8 +1,5 @@ | ||
| 1 | 1 | #pragma once |
| 2 | 2 | |
| 3 | −#include <stdint.h> | |
| 4 | −#include <stdbool.h> | |
| 5 | − | |
| 6 | 3 | enum |
| 7 | 4 | { |
| 8 | 5 | // ----------------------------- |
| @@ -26,3 +23,5 @@ enum · 17 unmodified lines | ||
| 26 | 23 | // ----------------------------- |
| 27 | 24 | PALETTE_NUM |
| 28 | 25 | }; |
| 26 | + | |
| 27 | +void setDefaultPalette(void); | |
| @@ -33,11 +33,11 @@ static uint8_t periodToNote(int16_t period) · 32 unmodified lines | ||
| 33 | 33 | return 255; // illegal period |
| 34 | 34 | } |
| 35 | 35 | |
| 36 | −void drawPatternNormal(uint32_t *frameBuffer) | |
| 36 | +static void drawPatternNormal(void) | |
| 37 | 37 | { |
| 38 | 38 | int8_t rowMiddlePos; |
| 39 | 39 | uint8_t j, h, tempNote, rowDispCheck; |
| 40 | − uint16_t putXOffset, putYOffset, rowData; | |
| 40 | + uint16_t x, y, rowData; | |
| 41 | 41 | const uint32_t *srcPtr; |
| 42 | 42 | uint32_t bufferOffset, *dstPtr; |
| 43 | 43 | note_t note; |
| @@ -50,93 +50,93 @@ void drawPatternNormal(uint32_t *frameBuffer) · 6 unmodified lines | ||
| 50 | 50 | if (rowDispCheck < MOD_ROWS) |
| 51 | 51 | { |
| 52 | 52 | rowData = rowDispCheck * 4; |
| 53 | − putYOffset = 140 + (i * 7); | |
| 53 | + y = 140 + (i * 7); | |
| 54 | 54 | |
| 55 | 55 | if (i == 7) // are we on the play row (middle)? |
| 56 | 56 | { |
| 57 | − putYOffset++; // align font to play row (middle) | |
| 57 | + y++; // align font to play row (middle) | |
| 58 | 58 | |
| 59 | 59 | // put current row number |
| 60 | − printTwoDecimalsBigBg(frameBuffer, 8, putYOffset, rowMiddlePos + modEntry->currRow, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 60 | + printTwoDecimalsBigBg(8, y, rowMiddlePos + modEntry->currRow, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 61 | 61 | |
| 62 | 62 | // pattern data |
| 63 | 63 | for (j = 0; j < AMIGA_VOICES; j++) |
| 64 | 64 | { |
| 65 | 65 | note = modEntry->patterns[modEntry->currPattern][rowData + j]; |
| 66 | − putXOffset = 26 + (j * 72); | |
| 66 | + x = 26 + (j * 72); | |
| 67 | 67 | |
| 68 | 68 | if (note.period == 0) |
| 69 | 69 | { |
| 70 | − textOutBigBg(frameBuffer, putXOffset + 6, putYOffset, "---", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 70 | + textOutBigBg(x + 6, y, "---", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 71 | 71 | } |
| 72 | 72 | else |
| 73 | 73 | { |
| 74 | 74 | tempNote = periodToNote(note.period); |
| 75 | 75 | if (tempNote == 255) |
| 76 | − textOutBigBg(frameBuffer, putXOffset + 6, putYOffset, "???", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 76 | + textOutBigBg(x + 6, y, "???", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 77 | 77 | else |
| 78 | − textOutBigBg(frameBuffer, putXOffset + 6, putYOffset, ptConfig.accidental ? noteNames2[tempNote] : noteNames1[tempNote], palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 78 | + textOutBigBg(x + 6, y, config.accidental ? noteNames2[tempNote] : noteNames1[tempNote], video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 79 | 79 | } |
| 80 | 80 | |
| 81 | − if (ptConfig.blankZeroFlag) | |
| 81 | + if (config.blankZeroFlag) | |
| 82 | 82 | { |
| 83 | 83 | if (note.sample & 0xF0) |
| 84 | − printOneHexBigBg(frameBuffer, putXOffset + 30, putYOffset, note.sample >> 4, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 84 | + printOneHexBigBg(x + 30, y, note.sample >> 4, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 85 | 85 | else |
| 86 | − printOneHexBigBg(frameBuffer, putXOffset + 30, putYOffset, ' ', palette[PAL_GENBKG], palette[PAL_GENBKG]); | |
| 86 | + printOneHexBigBg(x + 30, y, ' ', video.palette[PAL_GENBKG], video.palette[PAL_GENBKG]); | |
| 87 | 87 | } |
| 88 | 88 | else |
| 89 | 89 | { |
| 90 | − printOneHexBigBg(frameBuffer, putXOffset + 30, putYOffset, note.sample >> 4, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 90 | + printOneHexBigBg(x + 30, y, note.sample >> 4, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 91 | 91 | } |
| 92 | 92 | |
| 93 | − printOneHexBigBg(frameBuffer, putXOffset + 38, putYOffset, note.sample & 0x0F, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 94 | − printOneHexBigBg(frameBuffer, putXOffset + 46, putYOffset, note.command, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 95 | − printTwoHexBigBg(frameBuffer, putXOffset + 54, putYOffset, note.param, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 93 | + printOneHexBigBg(x + 38, y, note.sample & 0x0F, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 94 | + printOneHexBigBg(x + 46, y, note.command, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 95 | + printTwoHexBigBg(x + 54, y, note.param, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 96 | 96 | } |
| 97 | 97 | } |
| 98 | 98 | else |
| 99 | 99 | { |
| 100 | 100 | if (i > 7) |
| 101 | − putYOffset += 7; // beyond play row, jump some pixels out of the row (middle) | |
| 101 | + y += 7; // beyond play row, jump some pixels out of the row (middle) | |
| 102 | 102 | |
| 103 | 103 | // put current row number |
| 104 | − printTwoDecimalsBg(frameBuffer, 8, putYOffset, rowMiddlePos + modEntry->currRow, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 104 | + printTwoDecimalsBg(8, y, rowMiddlePos + modEntry->currRow, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 105 | 105 | |
| 106 | 106 | // pattern data |
| 107 | 107 | for (j = 0; j < AMIGA_VOICES; j++) |
| 108 | 108 | { |
| 109 | 109 | note = modEntry->patterns[modEntry->currPattern][rowData + j]; |
| 110 | − putXOffset = 26 + (j * 72); | |
| 110 | + x = 26 + (j * 72); | |
| 111 | 111 | |
| 112 | 112 | if (note.period == 0) |
| 113 | 113 | { |
| 114 | − textOutBg(frameBuffer, putXOffset + 6, putYOffset, "---", palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 114 | + textOutBg(x + 6, y, "---", video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 115 | 115 | } |
| 116 | 116 | else |
| 117 | 117 | { |
| 118 | 118 | tempNote = periodToNote(note.period); |
| 119 | 119 | if (tempNote == 255) |
| 120 | − textOutBg(frameBuffer, putXOffset + 6, putYOffset, "???", palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 120 | + textOutBg(x + 6, y, "???", video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 121 | 121 | else |
| 122 | − textOutBg(frameBuffer, putXOffset + 6, putYOffset, ptConfig.accidental ? noteNames2[tempNote] : noteNames1[tempNote], palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 122 | + textOutBg(x + 6, y, config.accidental ? noteNames2[tempNote] : noteNames1[tempNote], video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 123 | 123 | } |
| 124 | 124 | |
| 125 | − if (ptConfig.blankZeroFlag) | |
| 125 | + if (config.blankZeroFlag) | |
| 126 | 126 | { |
| 127 | 127 | if (note.sample & 0xF0) |
| 128 | − printOneHexBg(frameBuffer, putXOffset + 30, putYOffset, note.sample >> 4, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 128 | + printOneHexBg(x + 30, y, note.sample >> 4, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 129 | 129 | else |
| 130 | − printOneHexBg(frameBuffer, putXOffset + 30, putYOffset, ' ', palette[PAL_BACKGRD], palette[PAL_BACKGRD]); | |
| 130 | + printOneHexBg(x + 30, y, ' ', video.palette[PAL_BACKGRD], video.palette[PAL_BACKGRD]); | |
| 131 | 131 | } |
| 132 | 132 | else |
| 133 | 133 | { |
| 134 | − printOneHexBg(frameBuffer, putXOffset + 30, putYOffset, note.sample >> 4, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 134 | + printOneHexBg(x + 30, y, note.sample >> 4, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 135 | 135 | } |
| 136 | 136 | |
| 137 | − printOneHexBg(frameBuffer, putXOffset + 38, putYOffset, note.sample & 0x0F, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 138 | − printOneHexBg(frameBuffer, putXOffset + 46, putYOffset, note.command, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 139 | − printTwoHexBg(frameBuffer, putXOffset + 54, putYOffset, note.param, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 137 | + printOneHexBg(x + 38, y, note.sample & 0x0F, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 138 | + printOneHexBg(x + 46, y, note.command, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 139 | + printTwoHexBg(x + 54, y, note.param, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 140 | 140 | } |
| 141 | 141 | } |
| 142 | 142 | } |
| @@ -147,7 +147,7 @@ void drawPatternNormal(uint32_t *frameBuffer) · 4 unmodified lines | ||
| 147 | 147 | if (modEntry->currRow <= 6) |
| 148 | 148 | { |
| 149 | 149 | srcPtr = &trackerFrameBMP[140 * SCREEN_W]; |
| 150 | − dstPtr = &frameBuffer[140 * SCREEN_W]; | |
| 150 | + dstPtr = &video.frameBuffer[140 * SCREEN_W]; | |
| 151 | 151 | memcpy(dstPtr, srcPtr, (SCREEN_W * sizeof (int32_t)) * ((7 - modEntry->currRow) * 7)); |
| 152 | 152 | } |
| 153 | 153 | else if (modEntry->currRow >= 57) |
| @@ -156,16 +156,16 @@ void drawPatternNormal(uint32_t *frameBuffer) · 2 unmodified lines | ||
| 156 | 156 | bufferOffset = (250 - h) * SCREEN_W; |
| 157 | 157 | |
| 158 | 158 | srcPtr = &trackerFrameBMP[bufferOffset]; |
| 159 | − dstPtr = &frameBuffer[bufferOffset]; | |
| 159 | + dstPtr = &video.frameBuffer[bufferOffset]; | |
| 160 | 160 | memcpy(dstPtr, srcPtr, (SCREEN_W * sizeof (int32_t)) * h); |
| 161 | 161 | } |
| 162 | 162 | } |
| 163 | 163 | |
| 164 | −void drawPatternDotted(uint32_t *frameBuffer) | |
| 164 | +static void drawPatternDotted(void) | |
| 165 | 165 | { |
| 166 | 166 | int8_t rowMiddlePos; |
| 167 | 167 | uint8_t j, h, tempNote, rowDispCheck; |
| 168 | − uint16_t putXOffset, putYOffset, rowData; | |
| 168 | + uint16_t x, y, rowData; | |
| 169 | 169 | const uint32_t *srcPtr; |
| 170 | 170 | uint32_t bufferOffset, *dstPtr; |
| 171 | 171 | note_t note; |
| @@ -178,110 +178,110 @@ void drawPatternDotted(uint32_t *frameBuffer) · 6 unmodified lines | ||
| 178 | 178 | if (rowDispCheck < MOD_ROWS) |
| 179 | 179 | { |
| 180 | 180 | rowData = rowDispCheck * 4; |
| 181 | − putYOffset = 140 + (i * 7); | |
| 181 | + y = 140 + (i * 7); | |
| 182 | 182 | |
| 183 | 183 | if (i == 7) // are we on the play row (middle)? |
| 184 | 184 | { |
| 185 | − putYOffset++; // align font to play row (middle) | |
| 185 | + y++; // align font to play row (middle) | |
| 186 | 186 | |
| 187 | 187 | // put current row number |
| 188 | − printTwoDecimalsBigBg(frameBuffer, 8, putYOffset, rowMiddlePos + modEntry->currRow, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 188 | + printTwoDecimalsBigBg(8, y, rowMiddlePos + modEntry->currRow, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 189 | 189 | |
| 190 | 190 | // pattern data |
| 191 | 191 | for (j = 0; j < AMIGA_VOICES; j++) |
| 192 | 192 | { |
| 193 | 193 | note = modEntry->patterns[modEntry->currPattern][rowData + j]; |
| 194 | − putXOffset = 26 + (j * 72); | |
| 194 | + x = 26 + (j * 72); | |
| 195 | 195 | |
| 196 | 196 | if (note.period == 0) |
| 197 | 197 | { |
| 198 | − charOutBigBg(frameBuffer, putXOffset + 6, putYOffset, -128, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 199 | − charOutBigBg(frameBuffer, putXOffset + 14, putYOffset, -128, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 200 | − charOutBigBg(frameBuffer, putXOffset + 22, putYOffset, -128, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 198 | + charOutBigBg(x + 6, y, -128, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 199 | + charOutBigBg(x + 14, y, -128, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 200 | + charOutBigBg(x + 22, y, -128, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 201 | 201 | } |
| 202 | 202 | else |
| 203 | 203 | { |
| 204 | 204 | tempNote = periodToNote(note.period); |
| 205 | 205 | if (tempNote == 255) |
| 206 | − textOutBigBg(frameBuffer, putXOffset + 6, putYOffset, "???", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 206 | + textOutBigBg(x + 6, y, "???", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 207 | 207 | else |
| 208 | − textOutBigBg(frameBuffer, putXOffset + 6, putYOffset, ptConfig.accidental ? noteNames2[tempNote] : noteNames1[tempNote], palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 208 | + textOutBigBg(x + 6, y, config.accidental ? noteNames2[tempNote] : noteNames1[tempNote], video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 209 | 209 | } |
| 210 | 210 | |
| 211 | 211 | if (note.sample) |
| 212 | 212 | { |
| 213 | − printOneHexBigBg(frameBuffer, putXOffset + 30, putYOffset, note.sample >> 4, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 214 | − printOneHexBigBg(frameBuffer, putXOffset + 38, putYOffset, note.sample & 0x0F, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 213 | + printOneHexBigBg(x + 30, y, note.sample >> 4, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 214 | + printOneHexBigBg(x + 38, y, note.sample & 0x0F, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 215 | 215 | } |
| 216 | 216 | else |
| 217 | 217 | { |
| 218 | − charOutBigBg(frameBuffer, putXOffset + 30, putYOffset, -128, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 219 | − charOutBigBg(frameBuffer, putXOffset + 38, putYOffset, -128, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 218 | + charOutBigBg(x + 30, y, -128, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 219 | + charOutBigBg(x + 38, y, -128, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 220 | 220 | } |
| 221 | 221 | |
| 222 | 222 | if ((note.command | note.param) == 0) |
| 223 | 223 | { |
| 224 | − charOutBigBg(frameBuffer, putXOffset + 46, putYOffset, -128, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 225 | − charOutBigBg(frameBuffer, putXOffset + 54, putYOffset, -128, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 226 | − charOutBigBg(frameBuffer, putXOffset + 62, putYOffset, -128, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 224 | + charOutBigBg(x + 46, y, -128, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 225 | + charOutBigBg(x + 54, y, -128, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 226 | + charOutBigBg(x + 62, y, -128, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 227 | 227 | } |
| 228 | 228 | else |
| 229 | 229 | { |
| 230 | − printOneHexBigBg(frameBuffer, putXOffset + 46, putYOffset, note.command, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 231 | − printTwoHexBigBg(frameBuffer, putXOffset + 54, putYOffset, note.param, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 230 | + printOneHexBigBg(x + 46, y, note.command, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 231 | + printTwoHexBigBg(x + 54, y, note.param, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 232 | 232 | } |
| 233 | 233 | } |
| 234 | 234 | } |
| 235 | 235 | else |
| 236 | 236 | { |
| 237 | 237 | if (i > 7) |
| 238 | − putYOffset += 7; // beyond play row, jump some pixels out of the row (middle) | |
| 238 | + y += 7; // beyond play row, jump some pixels out of the row (middle) | |
| 239 | 239 | |
| 240 | 240 | // put current row number |
| 241 | − printTwoDecimalsBg(frameBuffer, 8, putYOffset, rowMiddlePos + modEntry->currRow, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 241 | + printTwoDecimalsBg(8, y, rowMiddlePos + modEntry->currRow, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 242 | 242 | |
| 243 | 243 | // pattern data |
| 244 | 244 | for (j = 0; j < AMIGA_VOICES; j++) |
| 245 | 245 | { |
| 246 | 246 | note = modEntry->patterns[modEntry->currPattern][rowData + j]; |
| 247 | − putXOffset = 26 + (j * 72); | |
| 247 | + x = 26 + (j * 72); | |
| 248 | 248 | |
| 249 | 249 | if (note.period == 0) |
| 250 | 250 | { |
| 251 | − charOutBg(frameBuffer, putXOffset + 6, putYOffset, -128, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 252 | − charOutBg(frameBuffer, putXOffset + 14, putYOffset, -128, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 253 | − charOutBg(frameBuffer, putXOffset + 22, putYOffset, -128, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 251 | + charOutBg(x + 6, y, -128, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 252 | + charOutBg(x + 14, y, -128, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 253 | + charOutBg(x + 22, y, -128, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 254 | 254 | } |
| 255 | 255 | else |
| 256 | 256 | { |
| 257 | 257 | tempNote = periodToNote(note.period); |
| 258 | 258 | if (tempNote == 255) |
| 259 | − textOutBg(frameBuffer, putXOffset + 6, putYOffset, "???", palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 259 | + textOutBg(x + 6, y, "???", video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 260 | 260 | else |
| 261 | − textOutBg(frameBuffer, putXOffset + 6, putYOffset, ptConfig.accidental ? noteNames2[tempNote] : noteNames1[tempNote], palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 261 | + textOutBg(x + 6, y, config.accidental ? noteNames2[tempNote] : noteNames1[tempNote], video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 262 | 262 | } |
| 263 | 263 | |
| 264 | 264 | if (note.sample) |
| 265 | 265 | { |
| 266 | − printOneHexBg(frameBuffer, putXOffset + 30, putYOffset, note.sample >> 4, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 267 | − printOneHexBg(frameBuffer, putXOffset + 38, putYOffset, note.sample & 0x0F, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 266 | + printOneHexBg(x + 30, y, note.sample >> 4, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 267 | + printOneHexBg(x + 38, y, note.sample & 0x0F, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 268 | 268 | } |
| 269 | 269 | else |
| 270 | 270 | { |
| 271 | − charOutBg(frameBuffer, putXOffset + 30, putYOffset, -128, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 272 | − charOutBg(frameBuffer, putXOffset + 38, putYOffset, -128, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 271 | + charOutBg(x + 30, y, -128, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 272 | + charOutBg(x + 38, y, -128, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 273 | 273 | } |
| 274 | 274 | |
| 275 | 275 | if ((note.command | note.param) == 0) |
| 276 | 276 | { |
| 277 | − charOutBg(frameBuffer, putXOffset + 46, putYOffset, -128, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 278 | − charOutBg(frameBuffer, putXOffset + 54, putYOffset, -128, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 279 | − charOutBg(frameBuffer, putXOffset + 62, putYOffset, -128, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 277 | + charOutBg(x + 46, y, -128, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 278 | + charOutBg(x + 54, y, -128, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 279 | + charOutBg(x + 62, y, -128, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 280 | 280 | } |
| 281 | 281 | else |
| 282 | 282 | { |
| 283 | − printOneHexBg(frameBuffer, putXOffset + 46, putYOffset, note.command, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 284 | − printTwoHexBg(frameBuffer, putXOffset + 54, putYOffset, note.param, palette[PAL_PATTXT], palette[PAL_BACKGRD]); | |
| 283 | + printOneHexBg(x + 46, y, note.command, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 284 | + printTwoHexBg(x + 54, y, note.param, video.palette[PAL_PATTXT], video.palette[PAL_BACKGRD]); | |
| 285 | 285 | } |
| 286 | 286 | } |
| 287 | 287 | } |
| @@ -293,7 +293,7 @@ void drawPatternDotted(uint32_t *frameBuffer) · 5 unmodified lines | ||
| 293 | 293 | if (modEntry->currRow <= 6) |
| 294 | 294 | { |
| 295 | 295 | srcPtr = &trackerFrameBMP[140 * SCREEN_W]; |
| 296 | − dstPtr = &frameBuffer[140 * SCREEN_W]; | |
| 296 | + dstPtr = &video.frameBuffer[140 * SCREEN_W]; | |
| 297 | 297 | memcpy(dstPtr, srcPtr, (SCREEN_W * sizeof (int32_t)) * ((7 - modEntry->currRow) * 7)); |
| 298 | 298 | } |
| 299 | 299 | else if (modEntry->currRow >= 57) |
| @@ -302,15 +302,15 @@ void drawPatternDotted(uint32_t *frameBuffer) · 2 unmodified lines | ||
| 302 | 302 | bufferOffset = (250 - h) * SCREEN_W; |
| 303 | 303 | |
| 304 | 304 | srcPtr = &trackerFrameBMP[bufferOffset]; |
| 305 | − dstPtr = &frameBuffer[bufferOffset]; | |
| 305 | + dstPtr = &video.frameBuffer[bufferOffset]; | |
| 306 | 306 | memcpy(dstPtr, srcPtr, (SCREEN_W * sizeof (int32_t)) * h); |
| 307 | 307 | } |
| 308 | 308 | } |
| 309 | 309 | |
| 310 | −void redrawPattern(uint32_t *frameBuffer) | |
| 310 | +void redrawPattern(void) | |
| 311 | 311 | { |
| 312 | − if (ptConfig.pattDots) | |
| 313 | − drawPatternDotted(frameBuffer); | |
| 312 | + if (config.pattDots) | |
| 313 | + drawPatternDotted(); | |
| 314 | 314 | else |
| 315 | − drawPatternNormal(frameBuffer); | |
| 315 | + drawPatternNormal(); | |
| 316 | 316 | } |
| @@ -1,5 +1,3 @@ | ||
| 1 | 1 | #pragma once |
| 2 | 2 | |
| 3 | −#include <stdint.h> | |
| 4 | − | |
| 5 | −void redrawPattern(uint32_t *frameBuffer); | |
| 3 | +void redrawPattern(void); | |
| @@ -289,7 +289,7 @@ bool loadWAVSample(UNICHAR *fileName, char *entryName, int8_t forceDownSampling) · 288 unmodified lines | ||
| 289 | 289 | // 2x downsampling - remove every other sample (if needed) |
| 290 | 290 | if (forceDownSampling) |
| 291 | 291 | { |
| 292 | − if (ptConfig.sampleLowpass) | |
| 292 | + if (config.sampleLowpass) | |
| 293 | 293 | lowPassSample8BitUnsigned(audioDataU8, sampleLength, sampleRate, sampleRate / DOWNSAMPLE_CUTOFF_FACTOR); |
| 294 | 294 | |
| 295 | 295 | sampleLength /= 2; |
| @@ -348,7 +348,7 @@ bool loadWAVSample(UNICHAR *fileName, char *entryName, int8_t forceDownSampling) · 52 unmodified lines | ||
| 348 | 348 | // 2x downsampling - remove every other sample (if needed) |
| 349 | 349 | if (forceDownSampling) |
| 350 | 350 | { |
| 351 | − if (ptConfig.sampleLowpass) | |
| 351 | + if (config.sampleLowpass) | |
| 352 | 352 | lowPassSample16Bit(audioDataS16, sampleLength, sampleRate, sampleRate / DOWNSAMPLE_CUTOFF_FACTOR); |
| 353 | 353 | |
| 354 | 354 | sampleLength /= 2; |
| @@ -410,7 +410,7 @@ bool loadWAVSample(UNICHAR *fileName, char *entryName, int8_t forceDownSampling) · 55 unmodified lines | ||
| 410 | 410 | // 2x downsampling - remove every other sample (if needed) |
| 411 | 411 | if (forceDownSampling) |
| 412 | 412 | { |
| 413 | − if (ptConfig.sampleLowpass) | |
| 413 | + if (config.sampleLowpass) | |
| 414 | 414 | lowPassSample32Bit(audioDataS32, sampleLength, sampleRate, sampleRate / DOWNSAMPLE_CUTOFF_FACTOR); |
| 415 | 415 | |
| 416 | 416 | sampleLength /= 2; |
| @@ -473,7 +473,7 @@ bool loadWAVSample(UNICHAR *fileName, char *entryName, int8_t forceDownSampling) · 56 unmodified lines | ||
| 473 | 473 | // 2x downsampling - remove every other sample (if needed) |
| 474 | 474 | if (forceDownSampling) |
| 475 | 475 | { |
| 476 | − if (ptConfig.sampleLowpass) | |
| 476 | + if (config.sampleLowpass) | |
| 477 | 477 | lowPassSample32Bit(audioDataS32, sampleLength, sampleRate, sampleRate / DOWNSAMPLE_CUTOFF_FACTOR); |
| 478 | 478 | |
| 479 | 479 | sampleLength /= 2; |
| @@ -536,7 +536,7 @@ bool loadWAVSample(UNICHAR *fileName, char *entryName, int8_t forceDownSampling) · 56 unmodified lines | ||
| 536 | 536 | // 2x downsampling - remove every other sample (if needed) |
| 537 | 537 | if (forceDownSampling) |
| 538 | 538 | { |
| 539 | − if (ptConfig.sampleLowpass) | |
| 539 | + if (config.sampleLowpass) | |
| 540 | 540 | lowPassSampleFloat(fAudioDataFloat, sampleLength, sampleRate, sampleRate / DOWNSAMPLE_CUTOFF_FACTOR); |
| 541 | 541 | |
| 542 | 542 | sampleLength /= 2; |
| @@ -605,7 +605,7 @@ bool loadWAVSample(UNICHAR *fileName, char *entryName, int8_t forceDownSampling) · 62 unmodified lines | ||
| 605 | 605 | // 2x downsampling - remove every other sample (if needed) |
| 606 | 606 | if (forceDownSampling) |
| 607 | 607 | { |
| 608 | − if (ptConfig.sampleLowpass) | |
| 608 | + if (config.sampleLowpass) | |
| 609 | 609 | lowPassSampleDouble(dAudioDataDouble, sampleLength, sampleRate, sampleRate / DOWNSAMPLE_CUTOFF_FACTOR); |
| 610 | 610 | |
| 611 | 611 | sampleLength /= 2; |
| @@ -1295,7 +1295,7 @@ bool loadAIFFSample(UNICHAR *fileName, char *entryName, int8_t forceDownSampling · 683 unmodified lines | ||
| 1295 | 1295 | // 2x downsampling - remove every other sample (if needed) |
| 1296 | 1296 | if (forceDownSampling) |
| 1297 | 1297 | { |
| 1298 | − if (ptConfig.sampleLowpass) | |
| 1298 | + if (config.sampleLowpass) | |
| 1299 | 1299 | lowPassSample8Bit(audioDataS8, sampleLength, sampleRate, sampleRate / DOWNSAMPLE_CUTOFF_FACTOR); |
| 1300 | 1300 | |
| 1301 | 1301 | sampleLength /= 2; |
| @@ -1358,7 +1358,7 @@ bool loadAIFFSample(UNICHAR *fileName, char *entryName, int8_t forceDownSampling · 56 unmodified lines | ||
| 1358 | 1358 | // 2x downsampling - remove every other sample (if needed) |
| 1359 | 1359 | if (forceDownSampling) |
| 1360 | 1360 | { |
| 1361 | − if (ptConfig.sampleLowpass) | |
| 1361 | + if (config.sampleLowpass) | |
| 1362 | 1362 | lowPassSample16Bit(audioDataS16, sampleLength, sampleRate, sampleRate / DOWNSAMPLE_CUTOFF_FACTOR); |
| 1363 | 1363 | |
| 1364 | 1364 | sampleLength /= 2; |
| @@ -1428,7 +1428,7 @@ bool loadAIFFSample(UNICHAR *fileName, char *entryName, int8_t forceDownSampling · 63 unmodified lines | ||
| 1428 | 1428 | // 2x downsampling - remove every other sample (if needed) |
| 1429 | 1429 | if (forceDownSampling) |
| 1430 | 1430 | { |
| 1431 | − if (ptConfig.sampleLowpass) | |
| 1431 | + if (config.sampleLowpass) | |
| 1432 | 1432 | lowPassSample32Bit(audioDataS32, sampleLength, sampleRate, sampleRate / DOWNSAMPLE_CUTOFF_FACTOR); |
| 1433 | 1433 | |
| 1434 | 1434 | sampleLength /= 2; |
| @@ -1495,7 +1495,7 @@ bool loadAIFFSample(UNICHAR *fileName, char *entryName, int8_t forceDownSampling · 60 unmodified lines | ||
| 1495 | 1495 | // 2x downsampling - remove every other sample (if needed) |
| 1496 | 1496 | if (forceDownSampling) |
| 1497 | 1497 | { |
| 1498 | − if (ptConfig.sampleLowpass) | |
| 1498 | + if (config.sampleLowpass) | |
| 1499 | 1499 | lowPassSample32Bit(audioDataS32, sampleLength, sampleRate, sampleRate / DOWNSAMPLE_CUTOFF_FACTOR); |
| 1500 | 1500 | |
| 1501 | 1501 | sampleLength /= 2; |
| @@ -32,7 +32,7 @@ typedef struct sampleMixer_t · 31 unmodified lines | ||
| 32 | 32 | uint32_t posFrac, delta; |
| 33 | 33 | } sampleMixer_t; |
| 34 | 34 | |
| 35 | −static int32_t samOffsetScaled; | |
| 35 | +static int32_t samOffsetScaled, lastDrawX, lastDrawY; | |
| 36 | 36 | static uint32_t waveInvertTable[8]; |
| 37 | 37 | |
| 38 | 38 | static const int8_t tuneToneData[32] = // Tuning Tone (Sine Wave) |
| @@ -43,16 +43,14 @@ static const int8_t tuneToneData[32] = // Tuning Tone (Sine Wave) · 4 unmodified lines | ||
| 43 | 43 | -127,-126,-118,-106, -91, -71, -49, -25 |
| 44 | 44 | }; |
| 45 | 45 | |
| 46 | −extern uint32_t *pixelBuffer; // pt_main.c | |
| 47 | − | |
| 48 | 46 | void setLoopSprites(void); |
| 49 | 47 | |
| 50 | 48 | void createSampleMarkTable(void) |
| 51 | 49 | { |
| 52 | 50 | // used for invertRange() (sample data marking) |
| 53 | 51 | |
| 54 | − waveInvertTable[0] = 0x00000000 | palette[PAL_BACKGRD]; | |
| 55 | − waveInvertTable[1] = 0x01000000 | palette[PAL_QADSCP]; | |
| 52 | + waveInvertTable[0] = 0x00000000 | video.palette[PAL_BACKGRD]; | |
| 53 | + waveInvertTable[1] = 0x01000000 | video.palette[PAL_QADSCP]; | |
| 56 | 54 | waveInvertTable[2] = 0x02000000 | CENTER_LINE_COLOR; |
| 57 | 55 | waveInvertTable[3] = 0x03000000; // spacer, not used |
| 58 | 56 | waveInvertTable[4] = 0x04000000 | MARK_COLOR_1; |
| @@ -106,10 +104,10 @@ void fillSampleFilterUndoBuffer(void) · 47 unmodified lines | ||
| 106 | 104 | } |
| 107 | 105 | } |
| 108 | 106 | |
| 109 | −static void sampleLine(uint32_t *frameBuffer, int16_t line_x1, int16_t line_x2, int16_t line_y1, int16_t line_y2) | |
| 107 | +static void sampleLine(int16_t line_x1, int16_t line_x2, int16_t line_y1, int16_t line_y2) | |
| 110 | 108 | { |
| 111 | 109 | int16_t d, x, y, ax, ay, sx, sy, dx, dy; |
| 112 | − uint32_t color = 0x01000000 | palette[PAL_QADSCP]; | |
| 110 | + uint32_t color = 0x01000000 | video.palette[PAL_QADSCP]; | |
| 113 | 111 | |
| 114 | 112 | assert(line_x1 >= 0 || line_x2 >= 0 || line_x1 < SCREEN_W || line_x2 < SCREEN_W); |
| 115 | 113 | assert(line_y1 >= 0 || line_y2 >= 0 || line_y1 < SCREEN_H || line_y2 < SCREEN_H); |
| @@ -130,7 +128,7 @@ static void sampleLine(uint32_t *frameBuffer, int16_t line_x1, int16_t line_x2, · 14 unmodified lines | ||
| 130 | 128 | { |
| 131 | 129 | assert(y >= 0 || x >= 0 || y < SCREEN_H || x < SCREEN_W); |
| 132 | 130 | |
| 133 | − frameBuffer[(y * SCREEN_W) + x] = color; | |
| 131 | + video.frameBuffer[(y * SCREEN_W) + x] = color; | |
| 134 | 132 | |
| 135 | 133 | if (x == line_x2) |
| 136 | 134 | break; |
| @@ -152,7 +150,7 @@ static void sampleLine(uint32_t *frameBuffer, int16_t line_x1, int16_t line_x2, · 15 unmodified lines | ||
| 152 | 150 | { |
| 153 | 151 | assert(y >= 0 || x >= 0 || y < SCREEN_H || x < SCREEN_W); |
| 154 | 152 | |
| 155 | − frameBuffer[(y * SCREEN_W) + x] = color; | |
| 153 | + video.frameBuffer[(y * SCREEN_W) + x] = color; | |
| 156 | 154 | |
| 157 | 155 | if (y == line_y2) |
| 158 | 156 | break; |
| @@ -192,9 +190,9 @@ static void setDragBar(void) · 33 unmodified lines | ||
| 192 | 190 | |
| 193 | 191 | // draw drag bar |
| 194 | 192 | |
| 195 | − dstPtr = &pixelBuffer[206 * SCREEN_W]; | |
| 196 | − pixel = palette[PAL_QADSCP]; | |
| 197 | − bgPixel = palette[PAL_BACKGRD]; | |
| 193 | + dstPtr = &video.frameBuffer[206 * SCREEN_W]; | |
| 194 | + pixel = video.palette[PAL_QADSCP]; | |
| 195 | + bgPixel = video.palette[PAL_BACKGRD]; | |
| 198 | 196 | |
| 199 | 197 | for (int32_t y = 0; y < 4; y++) |
| 200 | 198 | { |
| @@ -213,8 +211,8 @@ static void setDragBar(void) · 12 unmodified lines | ||
| 213 | 211 | { |
| 214 | 212 | // clear drag bar background |
| 215 | 213 | |
| 216 | − dstPtr = &pixelBuffer[(206 * SCREEN_W) + 4]; | |
| 217 | − pixel = palette[PAL_BACKGRD]; | |
| 214 | + dstPtr = &video.frameBuffer[(206 * SCREEN_W) + 4]; | |
| 215 | + pixel = video.palette[PAL_BACKGRD]; | |
| 218 | 216 | |
| 219 | 217 | for (int32_t y = 0; y < 4; y++) |
| 220 | 218 | { |
| @@ -264,6 +262,9 @@ int32_t scr2SmpPos(int32_t x) // screen x pos -> sample pos · 43 unmodified lines | ||
| 264 | 262 | x += samOffsetScaled; |
| 265 | 263 | x = (uint32_t)(x * editor.sampler.samDisplay) / SAMPLE_AREA_WIDTH; // truncate here |
| 266 | 264 | |
| 265 | + if (x > editor.sampler.samLength) | |
| 266 | + x = editor.sampler.samLength; | |
| 267 | + | |
| 267 | 268 | return x; |
| 268 | 269 | } |
| 269 | 270 | |
| @@ -297,8 +298,8 @@ static void renderSampleData(void) · 27 unmodified lines | ||
| 297 | 298 | |
| 298 | 299 | // clear sample data background |
| 299 | 300 | |
| 300 | − dstPtr = &pixelBuffer[(138 * SCREEN_W) + 3]; | |
| 301 | − pixel = palette[PAL_BACKGRD]; | |
| 301 | + dstPtr = &video.frameBuffer[(138 * SCREEN_W) + 3]; | |
| 302 | + pixel = video.palette[PAL_BACKGRD]; | |
| 302 | 303 | |
| 303 | 304 | for (y = 0; y < SAMPLE_VIEW_HEIGHT; y++) |
| 304 | 305 | { |
| @@ -309,9 +310,9 @@ static void renderSampleData(void) · 4 unmodified lines | ||
| 309 | 310 | } |
| 310 | 311 | |
| 311 | 312 | // display center line |
| 312 | − if (ptConfig.dottedCenterFlag) | |
| 313 | + if (config.dottedCenterFlag) | |
| 313 | 314 | { |
| 314 | − dstPtr = &pixelBuffer[(SAMPLE_AREA_Y_CENTER * SCREEN_W) + 3]; | |
| 315 | + dstPtr = &video.frameBuffer[(SAMPLE_AREA_Y_CENTER * SCREEN_W) + 3]; | |
| 315 | 316 | for (x = 0; x < SAMPLE_AREA_WIDTH; x++) |
| 316 | 317 | dstPtr[x] = 0x02000000 | CENTER_LINE_COLOR; |
| 317 | 318 | } |
| @@ -327,7 +328,7 @@ static void renderSampleData(void) · 9 unmodified lines | ||
| 327 | 328 | for (x = 1; x < SAMPLE_AREA_WIDTH; x++) |
| 328 | 329 | { |
| 329 | 330 | y2 = SAMPLE_AREA_Y_CENTER - getScaledSample(scr2SmpPos(x)); |
| 330 | − sampleLine(pixelBuffer, x + 2, x + 3, y1, y2); | |
| 331 | + sampleLine(x + 2, x + 3, y1, y2); | |
| 331 | 332 | y1 = y2; |
| 332 | 333 | } |
| 333 | 334 | } |
| @@ -355,11 +356,11 @@ static void renderSampleData(void) · 21 unmodified lines | ||
| 355 | 356 | |
| 356 | 357 | if (x > 0) |
| 357 | 358 | { |
| 358 | − if (min > oldMax) sampleLine(pixelBuffer, x + 2, x + 3, oldMax, min); | |
| 359 | − if (max < oldMin) sampleLine(pixelBuffer, x + 2, x + 3, oldMin, max); | |
| 359 | + if (min > oldMax) sampleLine(x + 2, x + 3, oldMax, min); | |
| 360 | + if (max < oldMin) sampleLine(x + 2, x + 3, oldMin, max); | |
| 360 | 361 | } |
| 361 | 362 | |
| 362 | − sampleLine(pixelBuffer, x + 3, x + 3, max, min); | |
| 363 | + sampleLine(x + 3, x + 3, max, min); | |
| 363 | 364 | |
| 364 | 365 | oldMin = min; |
| 365 | 366 | oldMax = max; |
| @@ -369,9 +370,9 @@ static void renderSampleData(void) · 3 unmodified lines | ||
| 369 | 370 | |
| 370 | 371 | // render "sample display" text |
| 371 | 372 | if (editor.sampler.samStart == editor.sampler.blankSample) |
| 372 | − printFiveDecimalsBg(pixelBuffer, 272, 214, 0, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 373 | + printFiveDecimalsBg(272, 214, 0, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 373 | 374 | else |
| 374 | − printFiveDecimalsBg(pixelBuffer, 272, 214, editor.sampler.samDisplay, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 375 | + printFiveDecimalsBg(272, 214, editor.sampler.samDisplay, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 375 | 376 | |
| 376 | 377 | setDragBar(); |
| 377 | 378 | setLoopSprites(); |
| @@ -398,7 +399,7 @@ void invertRange(void) · 20 unmodified lines | ||
| 398 | 399 | if (rangeLen < 1) |
| 399 | 400 | rangeLen = 1; |
| 400 | 401 | |
| 401 | − dstPtr = &pixelBuffer[(138 * SCREEN_W) + (start + 3)]; | |
| 402 | + dstPtr = &video.frameBuffer[(138 * SCREEN_W) + (start + 3)]; | |
| 402 | 403 | for (y = 0; y < 64; y++) |
| 403 | 404 | { |
| 404 | 405 | for (x = 0; x < rangeLen; x++) |
| @@ -1435,7 +1436,7 @@ void sampleMarkerToBeg(void) · 1030 unmodified lines | ||
| 1435 | 1436 | else |
| 1436 | 1437 | { |
| 1437 | 1438 | invertRange(); |
| 1438 | − if (input.keyb.shiftPressed && editor.markStartOfs != -1) | |
| 1439 | + if (keyb.shiftPressed && editor.markStartOfs != -1) | |
| 1439 | 1440 | { |
| 1440 | 1441 | editor.markStartOfs = editor.sampler.samOffset; |
| 1441 | 1442 | } |
| @@ -1471,7 +1472,7 @@ void sampleMarkerToCenter(void) · 29 unmodified lines | ||
| 1471 | 1472 | middlePos = editor.sampler.samOffset + ((editor.sampler.samDisplay + 1) / 2); |
| 1472 | 1473 | |
| 1473 | 1474 | invertRange(); |
| 1474 | − if (input.keyb.shiftPressed && editor.markStartOfs != -1) | |
| 1475 | + if (keyb.shiftPressed && editor.markStartOfs != -1) | |
| 1475 | 1476 | { |
| 1476 | 1477 | if (editor.markStartOfs < middlePos) |
| 1477 | 1478 | editor.markEndOfs = middlePos; |
| @@ -1507,7 +1508,7 @@ void sampleMarkerToEnd(void) · 29 unmodified lines | ||
| 1507 | 1508 | else |
| 1508 | 1509 | { |
| 1509 | 1510 | invertRange(); |
| 1510 | − if (input.keyb.shiftPressed && editor.markStartOfs != -1) | |
| 1511 | + if (keyb.shiftPressed && editor.markStartOfs != -1) | |
| 1511 | 1512 | { |
| 1512 | 1513 | editor.markEndOfs = s->length; |
| 1513 | 1514 | } |
| @@ -1995,7 +1996,7 @@ void setLoopSprites(void) · 481 unmodified lines | ||
| 1995 | 1996 | hideSprite(SPRITE_LOOP_PIN_RIGHT); |
| 1996 | 1997 | } |
| 1997 | 1998 | |
| 1998 | − textOutBg(pixelBuffer, 288, 225, (s->loopStart+s->loopLength > 2) ? "ON " : "OFF", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1999 | + textOutBg(288, 225, (s->loopStart+s->loopLength > 2) ? "ON " : "OFF", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1999 | 2000 | } |
| 2000 | 2001 | |
| 2001 | 2002 | void samplerShowAll(void) |
| @@ -2081,12 +2082,12 @@ static void samplerZoomOut(int32_t step, int16_t x) · 79 unmodified lines | ||
| 2081 | 2082 | |
| 2082 | 2083 | void samplerZoomInMouseWheel(void) |
| 2083 | 2084 | { |
| 2084 | − samplerZoomIn((editor.sampler.samDisplay + 5) / 10, input.mouse.x); | |
| 2085 | + samplerZoomIn((editor.sampler.samDisplay + 5) / 10, mouse.x); | |
| 2085 | 2086 | } |
| 2086 | 2087 | |
| 2087 | 2088 | void samplerZoomOutMouseWheel(void) |
| 2088 | 2089 | { |
| 2089 | − samplerZoomOut((editor.sampler.samDisplay + 5) / 10, input.mouse.x); | |
| 2090 | + samplerZoomOut((editor.sampler.samDisplay + 5) / 10, mouse.x); | |
| 2090 | 2091 | } |
| 2091 | 2092 | |
| 2092 | 2093 | void samplerZoomOut2x(void) |
| @@ -2158,22 +2159,19 @@ void volBoxBarPressed(bool mouseButtonHeld) · 65 unmodified lines | ||
| 2158 | 2159 | { |
| 2159 | 2160 | int32_t mouseX; |
| 2160 | 2161 | |
| 2161 | − if (input.mouse.y < 0 || input.mouse.x < 0 || input.mouse.y >= SCREEN_H || input.mouse.x >= SCREEN_W) | |
| 2162 | − return; | |
| 2163 | − | |
| 2164 | 2162 | if (!mouseButtonHeld) |
| 2165 | 2163 | { |
| 2166 | − if (input.mouse.x >= 72 && input.mouse.x <= 173) | |
| 2164 | + if (mouse.x >= 72 && mouse.x <= 173) | |
| 2167 | 2165 | { |
| 2168 | − if (input.mouse.y >= 154 && input.mouse.y <= 174) editor.ui.forceVolDrag = 1; | |
| 2169 | − if (input.mouse.y >= 165 && input.mouse.y <= 175) editor.ui.forceVolDrag = 2; | |
| 2166 | + if (mouse.y >= 154 && mouse.y <= 174) editor.ui.forceVolDrag = 1; | |
| 2167 | + if (mouse.y >= 165 && mouse.y <= 175) editor.ui.forceVolDrag = 2; | |
| 2170 | 2168 | } |
| 2171 | 2169 | } |
| 2172 | 2170 | else |
| 2173 | 2171 | { |
| 2174 | − if (editor.sampler.lastMouseX != input.mouse.x) | |
| 2172 | + if (editor.sampler.lastMouseX != mouse.x) | |
| 2175 | 2173 | { |
| 2176 | − editor.sampler.lastMouseX = input.mouse.x; | |
| 2174 | + editor.sampler.lastMouseX = mouse.x; | |
| 2177 | 2175 | mouseX = CLAMP(editor.sampler.lastMouseX - 107, 0, 60); |
| 2178 | 2176 | |
| 2179 | 2177 | if (editor.ui.forceVolDrag == 1) |
| @@ -2196,14 +2194,11 @@ void samplerBarPressed(bool mouseButtonHeld) · 16 unmodified lines | ||
| 2196 | 2194 | { |
| 2197 | 2195 | int32_t tmp32; |
| 2198 | 2196 | |
| 2199 | − if (input.mouse.y < 0 || input.mouse.x < 0 || input.mouse.y >= SCREEN_H || input.mouse.x >= SCREEN_W) | |
| 2200 | − return; | |
| 2201 | − | |
| 2202 | 2197 | if (!mouseButtonHeld) |
| 2203 | 2198 | { |
| 2204 | − if (input.mouse.x >= 4 && input.mouse.x <= 315) | |
| 2199 | + if (mouse.x >= 4 && mouse.x <= 315) | |
| 2205 | 2200 | { |
| 2206 | − if (input.mouse.x < editor.sampler.dragStart) | |
| 2201 | + if (mouse.x < editor.sampler.dragStart) | |
| 2207 | 2202 | { |
| 2208 | 2203 | tmp32 = editor.sampler.samOffset - editor.sampler.samDisplay; |
| 2209 | 2204 | if (tmp32 < 0) |
| @@ -2219,7 +2214,7 @@ void samplerBarPressed(bool mouseButtonHeld) · 9 unmodified lines | ||
| 2219 | 2214 | return; |
| 2220 | 2215 | } |
| 2221 | 2216 | |
| 2222 | − if (input.mouse.x > editor.sampler.dragEnd) | |
| 2217 | + if (mouse.x > editor.sampler.dragEnd) | |
| 2223 | 2218 | { |
| 2224 | 2219 | tmp32 = editor.sampler.samOffset + editor.sampler.samDisplay; |
| 2225 | 2220 | if (tmp32+editor.sampler.samDisplay <= editor.sampler.samLength) |
| @@ -2243,22 +2238,21 @@ void samplerBarPressed(bool mouseButtonHeld) · 17 unmodified lines | ||
| 2243 | 2238 | return; |
| 2244 | 2239 | } |
| 2245 | 2240 | |
| 2246 | − editor.sampler.lastSamPos = (uint16_t)input.mouse.x; | |
| 2241 | + editor.sampler.lastSamPos = mouse.x; | |
| 2247 | 2242 | editor.sampler.saveMouseX = editor.sampler.lastSamPos - editor.sampler.dragStart; |
| 2248 | 2243 | |
| 2249 | 2244 | editor.ui.forceSampleDrag = true; |
| 2250 | 2245 | } |
| 2251 | 2246 | } |
| 2252 | 2247 | |
| 2253 | − if (input.mouse.x != editor.sampler.lastSamPos) | |
| 2248 | + if (mouse.x != editor.sampler.lastSamPos) | |
| 2254 | 2249 | { |
| 2255 | − editor.sampler.lastSamPos = (uint16_t)input.mouse.x; | |
| 2250 | + editor.sampler.lastSamPos = mouse.x; | |
| 2256 | 2251 | |
| 2257 | 2252 | tmp32 = editor.sampler.lastSamPos - editor.sampler.saveMouseX - 4; |
| 2258 | − if (tmp32 < 0) | |
| 2259 | − tmp32 = 0; | |
| 2253 | + tmp32 = CLAMP(tmp32, 0, SAMPLE_AREA_WIDTH); | |
| 2260 | 2254 | |
| 2261 | − tmp32 = (int32_t)(((tmp32 * editor.sampler.samLength) + (311/2)) / 311); // rounded | |
| 2255 | + tmp32 = ((tmp32 * editor.sampler.samLength) + (311/2)) / 311; // rounded | |
| 2262 | 2256 | if (tmp32+editor.sampler.samDisplay <= editor.sampler.samLength) |
| 2263 | 2257 | { |
| 2264 | 2258 | if (tmp32 == editor.sampler.samOffset) |
| @@ -2280,162 +2274,166 @@ void samplerBarPressed(bool mouseButtonHeld) · 15 unmodified lines | ||
| 2280 | 2274 | } |
| 2281 | 2275 | } |
| 2282 | 2276 | |
| 2283 | −static int32_t x2LoopX(int32_t mouseX) | |
| 2284 | −{ | |
| 2285 | − moduleSample_t *s = &modEntry->samples[editor.currSample]; | |
| 2286 | − | |
| 2287 | − mouseX -= 3; | |
| 2288 | − if (mouseX < 0) | |
| 2289 | − mouseX = 0; | |
| 2290 | − | |
| 2291 | − mouseX = scr2SmpPos(mouseX); | |
| 2292 | − mouseX = CLAMP(mouseX, 0, s->length); | |
| 2293 | − | |
| 2294 | − return mouseX; | |
| 2295 | −} | |
| 2296 | − | |
| 2297 | −static int32_t xToSmpX(int32_t x, int32_t smpLen) | |
| 2277 | +static int32_t mouseYToSampleY(int32_t my) | |
| 2298 | 2278 | { |
| 2299 | − x = scr2SmpPos(x); | |
| 2300 | − x = CLAMP(x, 0, smpLen - 1); | |
| 2301 | − | |
| 2302 | − return x; | |
| 2303 | −} | |
| 2279 | + int32_t tmp32; | |
| 2304 | 2280 | |
| 2305 | −static int8_t yToSmpY(int32_t mouseY) | |
| 2306 | −{ | |
| 2307 | − mouseY = (SAMPLE_AREA_Y_CENTER - mouseY) * 4; | |
| 2308 | − CLAMP8(mouseY); | |
| 2281 | + if (my == SAMPLE_AREA_Y_CENTER) // center | |
| 2282 | + { | |
| 2283 | + return 128; | |
| 2284 | + } | |
| 2285 | + else | |
| 2286 | + { | |
| 2287 | + tmp32 = my - 138; | |
| 2288 | + tmp32 = ((tmp32 << 8) + (SAMPLE_AREA_HEIGHT/2)) / SAMPLE_AREA_HEIGHT; | |
| 2289 | + tmp32 = CLAMP(tmp32, 0, 255); | |
| 2290 | + tmp32 ^= 0xFF; | |
| 2291 | + } | |
| 2309 | 2292 | |
| 2310 | − return mouseY; | |
| 2293 | + return tmp32; | |
| 2311 | 2294 | } |
| 2312 | 2295 | |
| 2313 | 2296 | void samplerEditSample(bool mouseButtonHeld) |
| 2314 | 2297 | { |
| 2315 | − int8_t y; | |
| 2316 | − int32_t mouseY, x, smp_x0, smp_x1, xDistance, smp_y0, smp_y1, yDistance, smp; | |
| 2298 | + int8_t *ptr8; | |
| 2299 | + int32_t mx, my, tmp32, p, vl, tvl, r, rl, rvl, start, end; | |
| 2317 | 2300 | moduleSample_t *s; |
| 2318 | 2301 | |
| 2319 | 2302 | assert(editor.currSample >= 0 && editor.currSample <= 30); |
| 2303 | + s = &modEntry->samples[editor.currSample]; | |
| 2320 | 2304 | |
| 2321 | − if (input.mouse.y < 0 || input.mouse.x < 0 || input.mouse.y >= SCREEN_H || input.mouse.x >= SCREEN_W) | |
| 2305 | + if (s->length == 0) | |
| 2306 | + { | |
| 2307 | + displayErrorMsg("SAMPLE LENGTH = 0"); | |
| 2322 | 2308 | return; |
| 2309 | + } | |
| 2323 | 2310 | |
| 2324 | − s = &modEntry->samples[editor.currSample]; | |
| 2311 | + mx = mouse.x; | |
| 2312 | + if (mx > 4+SAMPLE_AREA_WIDTH) | |
| 2313 | + mx = 4+SAMPLE_AREA_WIDTH; | |
| 2314 | + | |
| 2315 | + my = mouse.y; | |
| 2325 | 2316 | |
| 2326 | 2317 | if (!mouseButtonHeld) |
| 2327 | 2318 | { |
| 2328 | − if (input.mouse.x >= 3 && input.mouse.x <= 316 && input.mouse.y >= 138 && input.mouse.y <= 201) | |
| 2329 | − { | |
| 2330 | − if (s->length == 0) | |
| 2331 | − { | |
| 2332 | − displayErrorMsg("SAMPLE LENGTH = 0"); | |
| 2333 | − } | |
| 2334 | − else | |
| 2335 | − { | |
| 2336 | − editor.sampler.lastMouseX = input.mouse.x; | |
| 2337 | − editor.sampler.lastMouseY = input.mouse.y; | |
| 2338 | − editor.ui.forceSampleEdit = true; | |
| 2339 | − updateWindowTitle(MOD_IS_MODIFIED); | |
| 2340 | − } | |
| 2341 | − } | |
| 2319 | + lastDrawX = scr2SmpPos(mx); | |
| 2320 | + lastDrawY = mouseYToSampleY(my); | |
| 2342 | 2321 | |
| 2343 | − return; | |
| 2322 | + editor.ui.forceSampleEdit = true; | |
| 2323 | + updateWindowTitle(MOD_IS_MODIFIED); | |
| 2324 | + } | |
| 2325 | + else if (mx == editor.sampler.lastMouseX && my == editor.sampler.lastMouseY) | |
| 2326 | + { | |
| 2327 | + return; // don't continue if we didn't move the mouse | |
| 2344 | 2328 | } |
| 2345 | 2329 | |
| 2346 | − mouseY = input.keyb.shiftPressed ? editor.sampler.lastMouseY : input.mouse.y; | |
| 2330 | + if (mx != editor.sampler.lastMouseX) | |
| 2331 | + p = scr2SmpPos(mx); | |
| 2332 | + else | |
| 2333 | + p = lastDrawX; | |
| 2334 | + | |
| 2335 | + if (!keyb.shiftPressed && my != editor.sampler.lastMouseY) | |
| 2336 | + vl = mouseYToSampleY(my); | |
| 2337 | + else | |
| 2338 | + vl = lastDrawY; | |
| 2347 | 2339 | |
| 2348 | − x = xToSmpX(input.mouse.x - 3, s->length); | |
| 2349 | − y = yToSmpY(mouseY); | |
| 2340 | + editor.sampler.lastMouseX = mx; | |
| 2341 | + editor.sampler.lastMouseY = my; | |
| 2350 | 2342 | |
| 2351 | − modEntry->sampleData[s->offset+x] = y; | |
| 2343 | + r = p; | |
| 2344 | + rvl = vl; | |
| 2352 | 2345 | |
| 2353 | − // interpolate x gaps | |
| 2354 | − if (input.mouse.x != editor.sampler.lastMouseX) | |
| 2346 | + // swap x/y if needed | |
| 2347 | + if (p > lastDrawX) | |
| 2355 | 2348 | { |
| 2356 | − smp_y0 = yToSmpY(editor.sampler.lastMouseY); | |
| 2349 | + // swap x | |
| 2350 | + tmp32 = p; | |
| 2351 | + p = lastDrawX; | |
| 2352 | + lastDrawX = tmp32; | |
| 2357 | 2353 | |
| 2358 | − smp_y1 = y; | |
| 2359 | − yDistance = smp_y1 - smp_y0; | |
| 2354 | + // swap y | |
| 2355 | + tmp32 = lastDrawY; | |
| 2356 | + lastDrawY = vl; | |
| 2357 | + vl = tmp32; | |
| 2358 | + } | |
| 2360 | 2359 | |
| 2361 | − if (input.mouse.x > editor.sampler.lastMouseX) | |
| 2362 | − { | |
| 2363 | − smp_x1 = x; | |
| 2364 | − smp_x0 = xToSmpX(editor.sampler.lastMouseX - 3, s->length); | |
| 2360 | + ptr8 = &modEntry->sampleData[s->offset]; | |
| 2365 | 2361 | |
| 2366 | − xDistance = smp_x1 - smp_x0; | |
| 2367 | − if (xDistance > 0) | |
| 2368 | − { | |
| 2369 | − for (x = smp_x0; x < smp_x1; x++) | |
| 2370 | − { | |
| 2371 | − assert(x < s->length); | |
| 2362 | + start = p; | |
| 2363 | + if (start < 0) | |
| 2364 | + start = 0; | |
| 2372 | 2365 | |
| 2373 | − smp = smp_y0 + (((x - smp_x0) * yDistance) / xDistance); | |
| 2374 | − CLAMP8(smp); | |
| 2375 | − modEntry->sampleData[s->offset + x] = (int8_t)smp; | |
| 2376 | − } | |
| 2377 | − } | |
| 2378 | − } | |
| 2379 | − else if (input.mouse.x < editor.sampler.lastMouseX) | |
| 2366 | + end = lastDrawX+1; | |
| 2367 | + if (end > s->length) | |
| 2368 | + end = s->length; | |
| 2369 | + | |
| 2370 | + if (p == lastDrawX) | |
| 2371 | + { | |
| 2372 | + const int8_t smpVal = (int8_t)(vl ^ 0x80); | |
| 2373 | + for (rl = start; rl < end; rl++) | |
| 2374 | + ptr8[rl] = smpVal; | |
| 2375 | + } | |
| 2376 | + else | |
| 2377 | + { | |
| 2378 | + int32_t y = lastDrawY - vl; | |
| 2379 | + int32_t x = lastDrawX - p; | |
| 2380 | + | |
| 2381 | + if (x != 0) | |
| 2380 | 2382 | { |
| 2381 | − smp_x0 = x; | |
| 2382 | − smp_x1 = xToSmpX(editor.sampler.lastMouseX - 3, s->length); | |
| 2383 | + double dMul = 1.0 / x; | |
| 2384 | + int32_t i = 0; | |
| 2383 | 2385 | |
| 2384 | − xDistance = smp_x1 - smp_x0; | |
| 2385 | − if (xDistance > 0) | |
| 2386 | + for (rl = start; rl < end; rl++) | |
| 2386 | 2387 | { |
| 2387 | − for (x = smp_x0; x < smp_x1; x++) | |
| 2388 | − { | |
| 2389 | − assert(x < s->length); | |
| 2388 | + tvl = y * i; | |
| 2389 | + tvl = (int32_t)(tvl * dMul); // tvl /= x | |
| 2390 | + tvl += vl; | |
| 2391 | + tvl ^= 0x80; | |
| 2390 | 2392 | |
| 2391 | − smp = smp_y0 + (((smp_x1 - x) * yDistance) / xDistance); | |
| 2392 | − CLAMP8(smp); | |
| 2393 | − modEntry->sampleData[s->offset + x] = (int8_t)smp; | |
| 2394 | − } | |
| 2393 | + ptr8[rl] = (int8_t)tvl; | |
| 2394 | + i++; | |
| 2395 | 2395 | } |
| 2396 | 2396 | } |
| 2397 | − | |
| 2398 | − editor.sampler.lastMouseX = input.mouse.x; | |
| 2399 | − | |
| 2400 | − if (!input.keyb.shiftPressed) | |
| 2401 | − editor.sampler.lastMouseY = input.mouse.y; | |
| 2402 | 2397 | } |
| 2403 | 2398 | |
| 2399 | + lastDrawY = rvl; | |
| 2400 | + lastDrawX = r; | |
| 2401 | + | |
| 2404 | 2402 | displaySample(); |
| 2405 | 2403 | } |
| 2406 | 2404 | |
| 2407 | 2405 | void samplerSamplePressed(bool mouseButtonHeld) |
| 2408 | 2406 | { |
| 2409 | − int16_t mouseX; | |
| 2410 | − int32_t tmpPos; | |
| 2407 | + int32_t mouseX, tmpPos; | |
| 2411 | 2408 | moduleSample_t *s; |
| 2412 | 2409 | |
| 2413 | 2410 | assert(editor.currSample >= 0 && editor.currSample <= 30); |
| 2414 | 2411 | |
| 2415 | 2412 | if (!mouseButtonHeld) |
| 2416 | 2413 | { |
| 2417 | − if (input.mouse.y < 142) | |
| 2414 | + if (mouse.y < 142) | |
| 2418 | 2415 | { |
| 2419 | − if (input.mouse.x >= editor.sampler.loopStartPos && input.mouse.x <= editor.sampler.loopStartPos+3) | |
| 2416 | + if (mouse.x >= editor.sampler.loopStartPos && mouse.x <= editor.sampler.loopStartPos+3) | |
| 2420 | 2417 | { |
| 2421 | 2418 | editor.ui.leftLoopPinMoving = true; |
| 2422 | 2419 | editor.ui.rightLoopPinMoving = false; |
| 2423 | 2420 | editor.ui.sampleMarkingPos = 1; |
| 2424 | − editor.sampler.lastMouseX = input.mouse.x; | |
| 2421 | + editor.sampler.lastMouseX = mouse.x; | |
| 2425 | 2422 | return; |
| 2426 | 2423 | } |
| 2427 | − else if (input.mouse.x >= editor.sampler.loopEndPos+3 && input.mouse.x <= editor.sampler.loopEndPos+6) | |
| 2424 | + else if (mouse.x >= editor.sampler.loopEndPos+3 && mouse.x <= editor.sampler.loopEndPos+6) | |
| 2428 | 2425 | { |
| 2429 | 2426 | editor.ui.rightLoopPinMoving = true; |
| 2430 | 2427 | editor.ui.leftLoopPinMoving = false; |
| 2431 | 2428 | editor.ui.sampleMarkingPos = 1; |
| 2432 | − editor.sampler.lastMouseX = input.mouse.x; | |
| 2429 | + editor.sampler.lastMouseX = mouse.x; | |
| 2433 | 2430 | return; |
| 2434 | 2431 | } |
| 2435 | 2432 | } |
| 2436 | 2433 | } |
| 2437 | 2434 | |
| 2438 | − mouseX = (int16_t)input.mouse.x; | |
| 2435 | + mouseX = CLAMP(mouse.x, 0, SCREEN_W+8); // allow some extra pixels outside of the screen | |
| 2436 | + | |
| 2439 | 2437 | s = &modEntry->samples[editor.currSample]; |
| 2440 | 2438 | |
| 2441 | 2439 | if (editor.ui.leftLoopPinMoving) |
| @@ -2444,7 +2442,7 @@ void samplerSamplePressed(bool mouseButtonHeld) · 2 unmodified lines | ||
| 2444 | 2442 | { |
| 2445 | 2443 | editor.sampler.lastMouseX = mouseX; |
| 2446 | 2444 | |
| 2447 | − tmpPos = (x2LoopX(mouseX + 2) - s->loopStart) & 0xFFFFFFFE; | |
| 2445 | + tmpPos = (scr2SmpPos(mouseX - 1) - s->loopStart) & 0xFFFFFFFE; | |
| 2448 | 2446 | if (tmpPos > MAX_SAMPLE_LEN) |
| 2449 | 2447 | tmpPos = MAX_SAMPLE_LEN; |
| 2450 | 2448 | |
| @@ -2482,7 +2480,7 @@ void samplerSamplePressed(bool mouseButtonHeld) · 31 unmodified lines | ||
| 2482 | 2480 | |
| 2483 | 2481 | s = &modEntry->samples[editor.currSample]; |
| 2484 | 2482 | |
| 2485 | − tmpPos = (x2LoopX(mouseX - 1) - s->loopStart) & 0xFFFFFFFE; | |
| 2483 | + tmpPos = (scr2SmpPos(mouseX - 4) - s->loopStart) & 0xFFFFFFFE; | |
| 2486 | 2484 | tmpPos = CLAMP(tmpPos, 2, MAX_SAMPLE_LEN); |
| 2487 | 2485 | |
| 2488 | 2486 | s->loopLength = tmpPos; |
| @@ -2500,7 +2498,7 @@ void samplerSamplePressed(bool mouseButtonHeld) · 11 unmodified lines | ||
| 2500 | 2498 | |
| 2501 | 2499 | if (!mouseButtonHeld) |
| 2502 | 2500 | { |
| 2503 | − if (mouseX < 3 || mouseX > 319) | |
| 2501 | + if (mouseX < 3 || mouseX >= SCREEN_W) | |
| 2504 | 2502 | return; |
| 2505 | 2503 | |
| 2506 | 2504 | editor.ui.sampleMarkingPos = (int16_t)mouseX; |
| @@ -2540,7 +2538,7 @@ void samplerSamplePressed(bool mouseButtonHeld) · 33 unmodified lines | ||
| 2540 | 2538 | return; |
| 2541 | 2539 | } |
| 2542 | 2540 | |
| 2543 | − mouseX = CLAMP(mouseX, 3, 319); | |
| 2541 | + mouseX = CLAMP(mouseX, 3, SCREEN_W); | |
| 2544 | 2542 | |
| 2545 | 2543 | if (mouseX != editor.sampler.lastSamPos) |
| 2546 | 2544 | { |
| @@ -2643,7 +2641,7 @@ void samplerLoopToggle(void) · 96 unmodified lines | ||
| 2643 | 2641 | void exitFromSam(void) |
| 2644 | 2642 | { |
| 2645 | 2643 | editor.ui.samplerScreenShown = false; |
| 2646 | − memcpy(&pixelBuffer[121 * SCREEN_W], &trackerFrameBMP[121 * SCREEN_W], 320 * 134 * sizeof (int32_t)); | |
| 2644 | + memcpy(&video.frameBuffer[121 * SCREEN_W], &trackerFrameBMP[121 * SCREEN_W], 320 * 134 * sizeof (int32_t)); | |
| 2647 | 2645 | |
| 2648 | 2646 | updateCursorPos(); |
| 2649 | 2647 | setLoopSprites(); |
| @@ -2667,7 +2665,7 @@ void samplerScreen(void) · 17 unmodified lines | ||
| 2667 | 2665 | } |
| 2668 | 2666 | |
| 2669 | 2667 | editor.ui.samplerScreenShown = true; |
| 2670 | − memcpy(&pixelBuffer[(121 * SCREEN_W)], samplerScreenBMP, 320 * 134 * sizeof (int32_t)); | |
| 2668 | + memcpy(&video.frameBuffer[(121 * SCREEN_W)], samplerScreenBMP, 320 * 134 * sizeof (int32_t)); | |
| 2671 | 2669 | hideSprite(SPRITE_PATTERN_CURSOR); |
| 2672 | 2670 | |
| 2673 | 2671 | editor.ui.updateStatusText = true; |
| @@ -24,11 +24,8 @@ static uint32_t scopeTimeLen, scopeTimeLenFrac; · 23 unmodified lines | ||
| 24 | 24 | static uint64_t timeNext64, timeNext64Frac; |
| 25 | 25 | static SDL_Thread *scopeThread; |
| 26 | 26 | |
| 27 | −scopeChannel_t scope[4]; // global | |
| 28 | −scopeChannelExt_t scopeExt[4]; // global | |
| 29 | − | |
| 30 | −extern bool forceMixerOff; // pt_audio.c | |
| 31 | −extern uint32_t *pixelBuffer; // pt_main.c | |
| 27 | +scopeChannel_t scope[AMIGA_VOICES]; // global | |
| 28 | +scopeChannelExt_t scopeExt[AMIGA_VOICES]; // global | |
| 32 | 29 | |
| 33 | 30 | int32_t getSampleReadPos(uint8_t ch, uint8_t smpNum) |
| 34 | 31 | { |
| @@ -47,9 +44,10 @@ int32_t getSampleReadPos(uint8_t ch, uint8_t smpNum) · 12 unmodified lines | ||
| 47 | 44 | { |
| 48 | 45 | s = &modEntry->samples[smpNum]; |
| 49 | 46 | |
| 50 | − /* get real sampling position regardless of where the scope data points to | |
| 47 | + /* Get real sampling position regardless of where the scope data points to | |
| 51 | 48 | ** sc->data changes during loop, offset and so on, so this has to be done |
| 52 | − ** (sadly, because it's really hackish) */ | |
| 49 | + ** (sadly, because it's really hackish). | |
| 50 | + */ | |
| 53 | 51 | pos = (int32_t)(&data[pos] - &modEntry->sampleData[s->offset]); |
| 54 | 52 | if (pos >= s->length) |
| 55 | 53 | return -1; |
| @@ -73,7 +71,7 @@ void updateScopes(void) · 17 unmodified lines | ||
| 73 | 71 | if (editor.isWAVRendering) |
| 74 | 72 | return; |
| 75 | 73 | |
| 76 | − for (uint32_t i = 0; i < AMIGA_VOICES; i++) | |
| 74 | + for (int32_t i = 0; i < AMIGA_VOICES; i++) | |
| 77 | 75 | { |
| 78 | 76 | sc = &scope[i]; |
| 79 | 77 | se = &scopeExt[i]; |
| @@ -93,8 +91,9 @@ void updateScopes(void) · 13 unmodified lines | ||
| 93 | 91 | { |
| 94 | 92 | // sample reached end, simulate Paula register update (sample swapping) |
| 95 | 93 | |
| 96 | − /* wrap pos around one time with current length, then set new length | |
| 97 | − ** and wrap around it (handles one-shot loops and sample swapping) */ | |
| 94 | + /* Wrap pos around one time with current length, then set new length | |
| 95 | + ** and wrap around it (handles one-shot loops and sample swapping). | |
| 96 | + */ | |
| 98 | 97 | tmp.pos -= tmp.length; |
| 99 | 98 | tmp.length = tmpExt.newLength; |
| 100 | 99 | |
| @@ -114,7 +113,8 @@ void updateScopes(void) · 13 unmodified lines | ||
| 114 | 113 | |
| 115 | 114 | /* This routine gets the average sample peak through the running scope voices. |
| 116 | 115 | ** This gives a much more smooth and stable result than getting the peak from |
| 117 | −** the mixer, and we don't care about including filters/BLEP in the peak calculation. */ | |
| 116 | +** the mixer, and we don't care about including filters/BLEP in the peak calculation. | |
| 117 | +*/ | |
| 118 | 118 | static void updateRealVuMeters(void) |
| 119 | 119 | { |
| 120 | 120 | bool didSwapData; |
| @@ -195,7 +195,7 @@ static void updateRealVuMeters(void) · 74 unmodified lines | ||
| 195 | 195 | } |
| 196 | 196 | } |
| 197 | 197 | |
| 198 | − smpPeak = ((smpPeak * 48) + (1 << 12)) >> 13; | |
| 198 | + smpPeak = ((smpPeak * 48) + (1 << 12)) >> 13; // rounded | |
| 199 | 199 | if (smpPeak > editor.realVuMeterVolumes[i]) |
| 200 | 200 | editor.realVuMeterVolumes[i] = smpPeak; |
| 201 | 201 | } |
| @@ -216,7 +216,7 @@ void drawScopes(void) · 14 unmodified lines | ||
| 216 | 216 | { |
| 217 | 217 | // --- QUADRASCOPE --- |
| 218 | 218 | |
| 219 | − scopePtr = &pixelBuffer[(71 * SCREEN_W) + 128]; | |
| 219 | + scopePtr = &video.frameBuffer[(71 * SCREEN_W) + 128]; | |
| 220 | 220 | for (i = 0; i < AMIGA_VOICES; i++) |
| 221 | 221 | { |
| 222 | 222 | sc = &scope[i]; |
| @@ -226,7 +226,7 @@ void drawScopes(void) · 3 unmodified lines | ||
| 226 | 226 | tmpScope = *sc; |
| 227 | 227 | didSwapData = se->didSwapData; |
| 228 | 228 | |
| 229 | − volume = -modEntry->channels[i].n_volume; // 0..64 -> -64..0 | |
| 229 | + volume = -modEntry->channels[i].n_volume; // invert volume | |
| 230 | 230 | |
| 231 | 231 | // render scope |
| 232 | 232 | if (se->active && tmpScope.data != NULL && volume != 0 && tmpScope.length > 0) |
| @@ -237,8 +237,8 @@ void drawScopes(void) · 4 unmodified lines | ||
| 237 | 237 | |
| 238 | 238 | // draw scope background |
| 239 | 239 | |
| 240 | − dstPtr = &pixelBuffer[(55 * SCREEN_W) + (128 + (i * (SCOPE_WIDTH + 8)))]; | |
| 241 | − scopePixel = palette[PAL_BACKGRD]; // this palette can change | |
| 240 | + dstPtr = &video.frameBuffer[(55 * SCREEN_W) + (128 + (i * (SCOPE_WIDTH + 8)))]; | |
| 241 | + scopePixel = video.palette[PAL_BACKGRD]; // this palette can change | |
| 242 | 242 | |
| 243 | 243 | for (y = 0; y < SCOPE_HEIGHT; y++) |
| 244 | 244 | { |
| @@ -250,7 +250,7 @@ void drawScopes(void) · 5 unmodified lines | ||
| 250 | 250 | |
| 251 | 251 | // render scope data |
| 252 | 252 | |
| 253 | − scopePixel = palette[PAL_QADSCP]; | |
| 253 | + scopePixel = video.palette[PAL_QADSCP]; | |
| 254 | 254 | |
| 255 | 255 | readPos = tmpScope.pos; |
| 256 | 256 | if (tmpScope.loopFlag) |
| @@ -299,8 +299,8 @@ void drawScopes(void) · 42 unmodified lines | ||
| 299 | 299 | { |
| 300 | 300 | // draw scope background |
| 301 | 301 | |
| 302 | − dstPtr = &pixelBuffer[(55 * SCREEN_W) + (128 + (i * (SCOPE_WIDTH + 8)))]; | |
| 303 | − scopePixel = palette[PAL_BACKGRD]; | |
| 302 | + dstPtr = &video.frameBuffer[(55 * SCREEN_W) + (128 + (i * (SCOPE_WIDTH + 8)))]; | |
| 303 | + scopePixel = video.palette[PAL_BACKGRD]; | |
| 304 | 304 | |
| 305 | 305 | for (y = 0; y < SCOPE_HEIGHT; y++) |
| 306 | 306 | { |
| @@ -312,7 +312,7 @@ void drawScopes(void) · 5 unmodified lines | ||
| 312 | 312 | |
| 313 | 313 | // draw line |
| 314 | 314 | |
| 315 | − scopePixel = palette[PAL_QADSCP]; | |
| 315 | + scopePixel = video.palette[PAL_QADSCP]; | |
| 316 | 316 | for (x = 0; x < SCOPE_WIDTH; x++) |
| 317 | 317 | scopePtr[x] = scopePixel; |
| 318 | 318 | |
| @@ -332,8 +332,6 @@ static int32_t SDLCALL scopeThreadFunc(void *ptr) · 13 unmodified lines | ||
| 332 | 332 | uint32_t diff32; |
| 333 | 333 | uint64_t time64; |
| 334 | 334 | |
| 335 | − (void)ptr; | |
| 336 | − | |
| 337 | 335 | // this is needed for scope stability (confirmed) |
| 338 | 336 | SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH); |
| 339 | 337 | |
| @@ -343,7 +341,7 @@ static int32_t SDLCALL scopeThreadFunc(void *ptr) · 3 unmodified lines | ||
| 343 | 341 | |
| 344 | 342 | while (editor.programRunning) |
| 345 | 343 | { |
| 346 | − if (ptConfig.realVuMeters) | |
| 344 | + if (config.realVuMeters) | |
| 347 | 345 | updateRealVuMeters(); |
| 348 | 346 | |
| 349 | 347 | updateScopes(); |
| @@ -372,6 +370,7 @@ static int32_t SDLCALL scopeThreadFunc(void *ptr) · 22 unmodified lines | ||
| 372 | 370 | } |
| 373 | 371 | } |
| 374 | 372 | |
| 373 | + (void)ptr; | |
| 375 | 374 | return true; |
| 376 | 375 | } |
| 377 | 376 | |
| @@ -383,7 +382,7 @@ bool initScopes(void) · 5 unmodified lines | ||
| 383 | 382 | dFrac = modf(editor.dPerfFreq / SCOPE_HZ, &dInt); |
| 384 | 383 | |
| 385 | 384 | // integer part |
| 386 | − scopeTimeLen = (uint32_t)dInt; | |
| 385 | + scopeTimeLen = (int32_t)dInt; | |
| 387 | 386 | |
| 388 | 387 | // fractional part scaled to 0..2^32-1 |
| 389 | 388 | dFrac *= UINT32_MAX; |
| @@ -400,18 +399,20 @@ bool initScopes(void) · 10 unmodified lines | ||
| 400 | 399 | return true; |
| 401 | 400 | } |
| 402 | 401 | |
| 403 | −void waitOnScopes(void) | |
| 402 | +void stopScope(uint8_t ch) | |
| 404 | 403 | { |
| 405 | 404 | while (scopesReading); |
| 406 | −} | |
| 405 | + memset(&scopeExt[ch], 0, sizeof (scopeChannelExt_t)); | |
| 407 | 406 | |
| 408 | −void clearScopes(void) | |
| 409 | −{ | |
| 410 | − waitOnScopes(); | |
| 407 | + while (scopesReading); | |
| 408 | + memset(&scope[ch], 0, sizeof (scopeChannel_t)); | |
| 411 | 409 | |
| 412 | − memset(scope, 0, sizeof (scope)); | |
| 413 | − memset(scopeExt, 0, sizeof (scopeExt)); | |
| 410 | + scope[ch].length = scopeExt[ch].newLength = 2; | |
| 411 | + while (scopesReading); // final wait to make sure scopes are all inactive | |
| 412 | +} | |
| 414 | 413 | |
| 415 | − for (uint8_t i = 0; i < AMIGA_VOICES; i++) | |
| 416 | − scope[i].length = scopeExt[i].newLength = 2; | |
| 414 | +void stopAllScopes(void) | |
| 415 | +{ | |
| 416 | + for (int32_t i = 0; i < AMIGA_VOICES; i++) | |
| 417 | + stopScope(i); | |
| 417 | 418 | } |
| @@ -2,6 +2,7 @@ · 1 unmodified line | ||
| 2 | 2 | |
| 3 | 3 | #include <stdint.h> |
| 4 | 4 | #include <stdbool.h> |
| 5 | +#include "pt2_header.h" | |
| 5 | 6 | |
| 6 | 7 | typedef struct scopeChannel_t // internal scope state |
| 7 | 8 | { |
| @@ -24,8 +25,8 @@ int32_t getSampleReadPos(uint8_t ch, uint8_t smpNum); · 16 unmodified lines | ||
| 24 | 25 | void updateScopes(void); |
| 25 | 26 | void drawScopes(void); |
| 26 | 27 | bool initScopes(void); |
| 27 | −void waitOnScopes(void); | |
| 28 | −void clearScopes(void); | |
| 28 | +void stopScope(uint8_t ch); | |
| 29 | +void stopAllScopes(void); | |
| 29 | 30 | |
| 30 | −extern scopeChannel_t scope[4]; | |
| 31 | −extern scopeChannelExt_t scopeExt[4]; | |
| 31 | +extern scopeChannel_t scope[AMIGA_VOICES]; | |
| 32 | +extern scopeChannelExt_t scopeExt[AMIGA_VOICES]; | |
| @@ -70,9 +70,6 @@ extern uint32_t *arrowBMP; · 69 unmodified lines | ||
| 70 | 70 | extern uint32_t *editOpModeCharsBMP; |
| 71 | 71 | extern uint32_t *pat2SmpDialogBMP; |
| 72 | 72 | |
| 73 | −// PALETTE | |
| 74 | −extern uint32_t palette[PALETTE_NUM]; | |
| 75 | − | |
| 76 | 73 | // button tables taken from the ptplay project + modified |
| 77 | 74 | |
| 78 | 75 | // MODIFY THESE EVERY TIME YOU REMOVE/ADD A BUTTON! |
| @@ -12,7 +12,7 @@ static const char hexTable[16] = · 11 unmodified lines | ||
| 12 | 12 | '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' |
| 13 | 13 | }; |
| 14 | 14 | |
| 15 | −void charOut(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uint32_t color) | |
| 15 | +void charOut(uint32_t xPos, uint32_t yPos, char ch, uint32_t color) | |
| 16 | 16 | { |
| 17 | 17 | const uint8_t *srcPtr; |
| 18 | 18 | uint32_t *dstPtr; |
| @@ -21,7 +21,7 @@ void charOut(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uint3 · 2 unmodified lines | ||
| 21 | 21 | return; |
| 22 | 22 | |
| 23 | 23 | srcPtr = &fontBMP[(uint8_t)ch * (FONT_CHAR_W * FONT_CHAR_H)]; |
| 24 | − dstPtr = &frameBuffer[(yPos * SCREEN_W) + xPos]; | |
| 24 | + dstPtr = &video.frameBuffer[(yPos * SCREEN_W) + xPos]; | |
| 25 | 25 | |
| 26 | 26 | for (uint32_t y = 0; y < FONT_CHAR_H; y++) |
| 27 | 27 | { |
| @@ -36,7 +36,7 @@ void charOut(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uint3 · 8 unmodified lines | ||
| 36 | 36 | } |
| 37 | 37 | } |
| 38 | 38 | |
| 39 | −void charOutBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uint32_t fgColor, uint32_t bgColor) | |
| 39 | +void charOutBg(uint32_t xPos, uint32_t yPos, char ch, uint32_t fgColor, uint32_t bgColor) | |
| 40 | 40 | { |
| 41 | 41 | const uint8_t *srcPtr; |
| 42 | 42 | uint32_t *dstPtr; |
| @@ -48,7 +48,7 @@ void charOutBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uin · 5 unmodified lines | ||
| 48 | 48 | ch = ' '; |
| 49 | 49 | |
| 50 | 50 | srcPtr = &fontBMP[(uint8_t)ch * (FONT_CHAR_W * FONT_CHAR_H)]; |
| 51 | − dstPtr = &frameBuffer[(yPos * SCREEN_W) + xPos]; | |
| 51 | + dstPtr = &video.frameBuffer[(yPos * SCREEN_W) + xPos]; | |
| 52 | 52 | |
| 53 | 53 | for (uint32_t y = 0; y < FONT_CHAR_H; y++) |
| 54 | 54 | { |
| @@ -60,7 +60,7 @@ void charOutBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uin · 5 unmodified lines | ||
| 60 | 60 | } |
| 61 | 61 | } |
| 62 | 62 | |
| 63 | −void charOutBig(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uint32_t color) | |
| 63 | +void charOutBig(uint32_t xPos, uint32_t yPos, char ch, uint32_t color) | |
| 64 | 64 | { |
| 65 | 65 | const uint8_t *srcPtr; |
| 66 | 66 | uint32_t *dstPtr; |
| @@ -69,7 +69,7 @@ void charOutBig(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, ui · 2 unmodified lines | ||
| 69 | 69 | return; |
| 70 | 70 | |
| 71 | 71 | srcPtr = &fontBMP[(uint8_t)ch * (FONT_CHAR_W * FONT_CHAR_H)]; |
| 72 | − dstPtr = &frameBuffer[(yPos * SCREEN_W) + xPos]; | |
| 72 | + dstPtr = &video.frameBuffer[(yPos * SCREEN_W) + xPos]; | |
| 73 | 73 | |
| 74 | 74 | for (uint32_t y = 0; y < FONT_CHAR_H; y++) |
| 75 | 75 | { |
| @@ -87,7 +87,7 @@ void charOutBig(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, ui · 11 unmodified lines | ||
| 87 | 87 | } |
| 88 | 88 | } |
| 89 | 89 | |
| 90 | −void charOutBigBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uint32_t fgColor, uint32_t bgColor) | |
| 90 | +void charOutBigBg(uint32_t xPos, uint32_t yPos, char ch, uint32_t fgColor, uint32_t bgColor) | |
| 91 | 91 | { |
| 92 | 92 | const uint8_t *srcPtr; |
| 93 | 93 | uint32_t *dstPtr; |
| @@ -99,7 +99,7 @@ void charOutBigBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, · 5 unmodified lines | ||
| 99 | 99 | ch = ' '; |
| 100 | 100 | |
| 101 | 101 | srcPtr = &fontBMP[(uint8_t)ch * (FONT_CHAR_W * FONT_CHAR_H)]; |
| 102 | − dstPtr = &frameBuffer[(yPos * SCREEN_W) + xPos]; | |
| 102 | + dstPtr = &video.frameBuffer[(yPos * SCREEN_W) + xPos]; | |
| 103 | 103 | |
| 104 | 104 | for (uint32_t y = 0; y < FONT_CHAR_H; y++) |
| 105 | 105 | { |
| @@ -122,151 +122,151 @@ void charOutBigBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, · 16 unmodified lines | ||
| 122 | 122 | } |
| 123 | 123 | } |
| 124 | 124 | |
| 125 | −void textOut(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, const char *text, uint32_t color) | |
| 125 | +void textOut(uint32_t xPos, uint32_t yPos, const char *text, uint32_t color) | |
| 126 | 126 | { |
| 127 | 127 | uint32_t x = xPos; |
| 128 | 128 | while (*text != '\0') |
| 129 | 129 | { |
| 130 | − charOut(frameBuffer, x, yPos, *text++, color); | |
| 130 | + charOut(x, yPos, *text++, color); | |
| 131 | 131 | x += FONT_CHAR_W; |
| 132 | 132 | } |
| 133 | 133 | } |
| 134 | 134 | |
| 135 | −void textOutTight(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, const char *text, uint32_t color) | |
| 135 | +void textOutTight(uint32_t xPos, uint32_t yPos, const char *text, uint32_t color) | |
| 136 | 136 | { |
| 137 | 137 | uint32_t x = xPos; |
| 138 | 138 | while (*text != '\0') |
| 139 | 139 | { |
| 140 | − charOut(frameBuffer, x, yPos, *text++, color); | |
| 140 | + charOut(x, yPos, *text++, color); | |
| 141 | 141 | x += (FONT_CHAR_W - 1); |
| 142 | 142 | } |
| 143 | 143 | } |
| 144 | 144 | |
| 145 | −void textOutBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, const char *text, uint32_t fgColor, uint32_t bgColor) | |
| 145 | +void textOutBg(uint32_t xPos, uint32_t yPos, const char *text, uint32_t fgColor, uint32_t bgColor) | |
| 146 | 146 | { |
| 147 | 147 | uint32_t x = xPos; |
| 148 | 148 | while (*text != '\0') |
| 149 | 149 | { |
| 150 | − charOutBg(frameBuffer, x, yPos, *text++, fgColor, bgColor); | |
| 150 | + charOutBg(x, yPos, *text++, fgColor, bgColor); | |
| 151 | 151 | x += FONT_CHAR_W; |
| 152 | 152 | } |
| 153 | 153 | } |
| 154 | 154 | |
| 155 | −void textOutBig(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, const char *text, uint32_t color) | |
| 155 | +void textOutBig(uint32_t xPos, uint32_t yPos, const char *text, uint32_t color) | |
| 156 | 156 | { |
| 157 | 157 | uint32_t x = xPos; |
| 158 | 158 | while (*text != '\0') |
| 159 | 159 | { |
| 160 | − charOutBig(frameBuffer, x, yPos, *text++, color); | |
| 160 | + charOutBig(x, yPos, *text++, color); | |
| 161 | 161 | x += FONT_CHAR_W; |
| 162 | 162 | } |
| 163 | 163 | } |
| 164 | 164 | |
| 165 | −void textOutBigBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, const char *text, uint32_t fgColor, uint32_t bgColor) | |
| 165 | +void textOutBigBg(uint32_t xPos, uint32_t yPos, const char *text, uint32_t fgColor, uint32_t bgColor) | |
| 166 | 166 | { |
| 167 | 167 | uint32_t x = xPos; |
| 168 | 168 | while (*text != '\0') |
| 169 | 169 | { |
| 170 | − charOutBigBg(frameBuffer, x, yPos, *text++, fgColor, bgColor); | |
| 170 | + charOutBigBg(x, yPos, *text++, fgColor, bgColor); | |
| 171 | 171 | x += FONT_CHAR_W; |
| 172 | 172 | } |
| 173 | 173 | } |
| 174 | 174 | |
| 175 | −void printTwoDecimals(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 175 | +void printTwoDecimals(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 176 | 176 | { |
| 177 | 177 | if (value == 0) |
| 178 | 178 | { |
| 179 | − textOut(frameBuffer, x, y, "00", fontColor); | |
| 179 | + textOut(x, y, "00", fontColor); | |
| 180 | 180 | } |
| 181 | 181 | else |
| 182 | 182 | { |
| 183 | 183 | if (value > 99) |
| 184 | 184 | value = 99; |
| 185 | 185 | |
| 186 | − charOut(frameBuffer, x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor); value /= 10; | |
| 187 | − charOut(frameBuffer, x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor); | |
| 186 | + charOut(x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor); value /= 10; | |
| 187 | + charOut(x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor); | |
| 188 | 188 | } |
| 189 | 189 | } |
| 190 | 190 | |
| 191 | −void printTwoDecimalsBig(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 191 | +void printTwoDecimalsBig(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 192 | 192 | { |
| 193 | 193 | if (value == 0) |
| 194 | 194 | { |
| 195 | − textOutBig(frameBuffer, x, y, "00", fontColor); | |
| 195 | + textOutBig(x, y, "00", fontColor); | |
| 196 | 196 | } |
| 197 | 197 | else |
| 198 | 198 | { |
| 199 | 199 | if (value > 99) |
| 200 | 200 | value = 99; |
| 201 | 201 | |
| 202 | − charOutBig(frameBuffer, x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor); value /= 10; | |
| 203 | − charOutBig(frameBuffer, x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor); | |
| 202 | + charOutBig(x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor); value /= 10; | |
| 203 | + charOutBig(x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor); | |
| 204 | 204 | } |
| 205 | 205 | } |
| 206 | 206 | |
| 207 | −void printThreeDecimals(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 207 | +void printThreeDecimals(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 208 | 208 | { |
| 209 | 209 | if (value == 0) |
| 210 | 210 | { |
| 211 | − textOut(frameBuffer, x, y, "000", fontColor); | |
| 211 | + textOut(x, y, "000", fontColor); | |
| 212 | 212 | } |
| 213 | 213 | else |
| 214 | 214 | { |
| 215 | 215 | if (value > 999) |
| 216 | 216 | value = 999; |
| 217 | 217 | |
| 218 | − charOut(frameBuffer, x + (FONT_CHAR_W * 2), y, '0' + (value % 10), fontColor); value /= 10; | |
| 219 | − charOut(frameBuffer, x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor); value /= 10; | |
| 220 | − charOut(frameBuffer, x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor); | |
| 218 | + charOut(x + (FONT_CHAR_W * 2), y, '0' + (value % 10), fontColor); value /= 10; | |
| 219 | + charOut(x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor); value /= 10; | |
| 220 | + charOut(x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor); | |
| 221 | 221 | } |
| 222 | 222 | } |
| 223 | 223 | |
| 224 | −void printFourDecimals(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 224 | +void printFourDecimals(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 225 | 225 | { |
| 226 | 226 | if (value == 0) |
| 227 | 227 | { |
| 228 | − textOut(frameBuffer, x, y, "0000", fontColor); | |
| 228 | + textOut(x, y, "0000", fontColor); | |
| 229 | 229 | } |
| 230 | 230 | else |
| 231 | 231 | { |
| 232 | 232 | if (value > 9999) |
| 233 | 233 | value = 9999; |
| 234 | 234 | |
| 235 | − charOut(frameBuffer, x + (FONT_CHAR_W * 3), y, '0' + (value % 10), fontColor); value /= 10; | |
| 236 | − charOut(frameBuffer, x + (FONT_CHAR_W * 2), y, '0' + (value % 10), fontColor); value /= 10; | |
| 237 | − charOut(frameBuffer, x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor); value /= 10; | |
| 238 | − charOut(frameBuffer, x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor); | |
| 235 | + charOut(x + (FONT_CHAR_W * 3), y, '0' + (value % 10), fontColor); value /= 10; | |
| 236 | + charOut(x + (FONT_CHAR_W * 2), y, '0' + (value % 10), fontColor); value /= 10; | |
| 237 | + charOut(x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor); value /= 10; | |
| 238 | + charOut(x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor); | |
| 239 | 239 | } |
| 240 | 240 | } |
| 241 | 241 | |
| 242 | −void printFiveDecimals(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 242 | +void printFiveDecimals(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 243 | 243 | { |
| 244 | 244 | if (value == 0) |
| 245 | 245 | { |
| 246 | − textOut(frameBuffer, x, y, "00000", fontColor); | |
| 246 | + textOut(x, y, "00000", fontColor); | |
| 247 | 247 | } |
| 248 | 248 | else |
| 249 | 249 | { |
| 250 | 250 | if (value > 99999) |
| 251 | 251 | value = 99999; |
| 252 | 252 | |
| 253 | − charOut(frameBuffer, x + (FONT_CHAR_W * 4), y, '0' + (value % 10), fontColor); value /= 10; | |
| 254 | − charOut(frameBuffer, x + (FONT_CHAR_W * 3), y, '0' + (value % 10), fontColor); value /= 10; | |
| 255 | − charOut(frameBuffer, x + (FONT_CHAR_W * 2), y, '0' + (value % 10), fontColor); value /= 10; | |
| 256 | − charOut(frameBuffer, x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor); value /= 10; | |
| 257 | − charOut(frameBuffer, x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor); | |
| 253 | + charOut(x + (FONT_CHAR_W * 4), y, '0' + (value % 10), fontColor); value /= 10; | |
| 254 | + charOut(x + (FONT_CHAR_W * 3), y, '0' + (value % 10), fontColor); value /= 10; | |
| 255 | + charOut(x + (FONT_CHAR_W * 2), y, '0' + (value % 10), fontColor); value /= 10; | |
| 256 | + charOut(x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor); value /= 10; | |
| 257 | + charOut(x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor); | |
| 258 | 258 | } |
| 259 | 259 | } |
| 260 | 260 | |
| 261 | 261 | // this one is used for module size and sampler screen display length (zeroes are padded with space) |
| 262 | −void printSixDecimals(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 262 | +void printSixDecimals(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 263 | 263 | { |
| 264 | 264 | char numberText[7]; |
| 265 | 265 | uint8_t i; |
| 266 | 266 | |
| 267 | 267 | if (value == 0) |
| 268 | 268 | { |
| 269 | − textOut(frameBuffer, x, y, " 0", fontColor); | |
| 269 | + textOut(x, y, " 0", fontColor); | |
| 270 | 270 | } |
| 271 | 271 | else |
| 272 | 272 | { |
| @@ -285,177 +285,177 @@ void printSixDecimals(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t va · 12 unmodified lines | ||
| 285 | 285 | while (numberText[i] == '0') |
| 286 | 286 | numberText[i++] = ' '; |
| 287 | 287 | |
| 288 | − textOut(frameBuffer, x, y, numberText, fontColor); | |
| 288 | + textOut(x, y, numberText, fontColor); | |
| 289 | 289 | } |
| 290 | 290 | } |
| 291 | 291 | |
| 292 | −void printOneHex(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 292 | +void printOneHex(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 293 | 293 | { |
| 294 | − charOut(frameBuffer, x, y, hexTable[value & 15], fontColor); | |
| 294 | + charOut(x, y, hexTable[value & 15], fontColor); | |
| 295 | 295 | } |
| 296 | 296 | |
| 297 | −void printOneHexBig(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 297 | +void printOneHexBig(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 298 | 298 | { |
| 299 | − charOutBig(frameBuffer, x, y, hexTable[value & 15], fontColor); | |
| 299 | + charOutBig(x, y, hexTable[value & 15], fontColor); | |
| 300 | 300 | } |
| 301 | 301 | |
| 302 | −void printTwoHex(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 302 | +void printTwoHex(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 303 | 303 | { |
| 304 | 304 | if (value == 0) |
| 305 | 305 | { |
| 306 | − textOut(frameBuffer, x, y, "00", fontColor); | |
| 306 | + textOut(x, y, "00", fontColor); | |
| 307 | 307 | } |
| 308 | 308 | else |
| 309 | 309 | { |
| 310 | 310 | value &= 0xFF; |
| 311 | 311 | |
| 312 | − charOut(frameBuffer, x + (FONT_CHAR_W * 0), y, hexTable[value >> 4], fontColor); | |
| 313 | − charOut(frameBuffer, x + (FONT_CHAR_W * 1), y, hexTable[value & 15], fontColor); | |
| 312 | + charOut(x + (FONT_CHAR_W * 0), y, hexTable[value >> 4], fontColor); | |
| 313 | + charOut(x + (FONT_CHAR_W * 1), y, hexTable[value & 15], fontColor); | |
| 314 | 314 | } |
| 315 | 315 | } |
| 316 | 316 | |
| 317 | −void printTwoHexBig(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 317 | +void printTwoHexBig(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 318 | 318 | { |
| 319 | 319 | if (value == 0) |
| 320 | 320 | { |
| 321 | − textOutBig(frameBuffer, x, y, "00", fontColor); | |
| 321 | + textOutBig(x, y, "00", fontColor); | |
| 322 | 322 | } |
| 323 | 323 | else |
| 324 | 324 | { |
| 325 | 325 | value &= 0xFF; |
| 326 | 326 | |
| 327 | − charOutBig(frameBuffer, x + (FONT_CHAR_W * 0), y, hexTable[value >> 4], fontColor); | |
| 328 | − charOutBig(frameBuffer, x + (FONT_CHAR_W * 1), y, hexTable[value & 15], fontColor); | |
| 327 | + charOutBig(x + (FONT_CHAR_W * 0), y, hexTable[value >> 4], fontColor); | |
| 328 | + charOutBig(x + (FONT_CHAR_W * 1), y, hexTable[value & 15], fontColor); | |
| 329 | 329 | } |
| 330 | 330 | } |
| 331 | 331 | |
| 332 | −void printThreeHex(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 332 | +void printThreeHex(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 333 | 333 | { |
| 334 | 334 | if (value == 0) |
| 335 | 335 | { |
| 336 | − textOut(frameBuffer, x, y, "000", fontColor); | |
| 336 | + textOut(x, y, "000", fontColor); | |
| 337 | 337 | } |
| 338 | 338 | else |
| 339 | 339 | { |
| 340 | 340 | value &= 0xFFF; |
| 341 | 341 | |
| 342 | − charOut(frameBuffer, x + (FONT_CHAR_W * 0), y, hexTable[value >> 8], fontColor); | |
| 343 | − charOut(frameBuffer, x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 4)) >> 4], fontColor); | |
| 344 | − charOut(frameBuffer, x + (FONT_CHAR_W * 2), y, hexTable[value & 15], fontColor); | |
| 342 | + charOut(x + (FONT_CHAR_W * 0), y, hexTable[value >> 8], fontColor); | |
| 343 | + charOut(x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 4)) >> 4], fontColor); | |
| 344 | + charOut(x + (FONT_CHAR_W * 2), y, hexTable[value & 15], fontColor); | |
| 345 | 345 | } |
| 346 | 346 | } |
| 347 | 347 | |
| 348 | −void printFourHex(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 348 | +void printFourHex(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 349 | 349 | { |
| 350 | 350 | if (value == 0) |
| 351 | 351 | { |
| 352 | − textOut(frameBuffer, x, y, "0000", fontColor); | |
| 352 | + textOut(x, y, "0000", fontColor); | |
| 353 | 353 | } |
| 354 | 354 | else |
| 355 | 355 | { |
| 356 | 356 | value &= 0xFFFF; |
| 357 | 357 | |
| 358 | − charOut(frameBuffer, x + (FONT_CHAR_W * 0), y, hexTable[value >> 12], fontColor); | |
| 359 | − charOut(frameBuffer, x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 8)) >> 8], fontColor); | |
| 360 | − charOut(frameBuffer, x + (FONT_CHAR_W * 2), y, hexTable[(value & (15 << 4)) >> 4], fontColor); | |
| 361 | − charOut(frameBuffer, x + (FONT_CHAR_W * 3), y, hexTable[value & 15], fontColor); | |
| 358 | + charOut(x + (FONT_CHAR_W * 0), y, hexTable[value >> 12], fontColor); | |
| 359 | + charOut(x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 8)) >> 8], fontColor); | |
| 360 | + charOut(x + (FONT_CHAR_W * 2), y, hexTable[(value & (15 << 4)) >> 4], fontColor); | |
| 361 | + charOut(x + (FONT_CHAR_W * 3), y, hexTable[value & 15], fontColor); | |
| 362 | 362 | } |
| 363 | 363 | } |
| 364 | 364 | |
| 365 | −void printFiveHex(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 365 | +void printFiveHex(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor) | |
| 366 | 366 | { |
| 367 | 367 | if (value == 0) |
| 368 | 368 | { |
| 369 | − textOut(frameBuffer, x, y, "00000", fontColor); | |
| 369 | + textOut(x, y, "00000", fontColor); | |
| 370 | 370 | } |
| 371 | 371 | else |
| 372 | 372 | { |
| 373 | 373 | value &= 0xFFFFF; |
| 374 | 374 | |
| 375 | − charOut(frameBuffer, x + (FONT_CHAR_W * 0), y, hexTable[value >> 16], fontColor); | |
| 376 | − charOut(frameBuffer, x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 12)) >> 12], fontColor); | |
| 377 | − charOut(frameBuffer, x + (FONT_CHAR_W * 2), y, hexTable[(value & (15 << 8)) >> 8], fontColor); | |
| 378 | − charOut(frameBuffer, x + (FONT_CHAR_W * 3), y, hexTable[(value & (15 << 4)) >> 4], fontColor); | |
| 379 | − charOut(frameBuffer, x + (FONT_CHAR_W * 4), y, hexTable[value & 15], fontColor); | |
| 375 | + charOut(x + (FONT_CHAR_W * 0), y, hexTable[value >> 16], fontColor); | |
| 376 | + charOut(x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 12)) >> 12], fontColor); | |
| 377 | + charOut(x + (FONT_CHAR_W * 2), y, hexTable[(value & (15 << 8)) >> 8], fontColor); | |
| 378 | + charOut(x + (FONT_CHAR_W * 3), y, hexTable[(value & (15 << 4)) >> 4], fontColor); | |
| 379 | + charOut(x + (FONT_CHAR_W * 4), y, hexTable[value & 15], fontColor); | |
| 380 | 380 | } |
| 381 | 381 | } |
| 382 | 382 | |
| 383 | −void printTwoDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 383 | +void printTwoDecimalsBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 384 | 384 | { |
| 385 | 385 | if (value == 0) |
| 386 | 386 | { |
| 387 | − textOutBg(frameBuffer, x, y, "00", fontColor, backColor); | |
| 387 | + textOutBg(x, y, "00", fontColor, backColor); | |
| 388 | 388 | } |
| 389 | 389 | else |
| 390 | 390 | { |
| 391 | 391 | if (value > 99) |
| 392 | 392 | value = 99; |
| 393 | 393 | |
| 394 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 395 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor, backColor); | |
| 394 | + charOutBg(x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 395 | + charOutBg(x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor, backColor); | |
| 396 | 396 | } |
| 397 | 397 | } |
| 398 | 398 | |
| 399 | −void printTwoDecimalsBigBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 399 | +void printTwoDecimalsBigBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 400 | 400 | { |
| 401 | 401 | if (value == 0) |
| 402 | 402 | { |
| 403 | − textOutBigBg(frameBuffer, x, y, "00", fontColor, backColor); | |
| 403 | + textOutBigBg(x, y, "00", fontColor, backColor); | |
| 404 | 404 | } |
| 405 | 405 | else |
| 406 | 406 | { |
| 407 | 407 | if (value > 99) |
| 408 | 408 | value = 99; |
| 409 | 409 | |
| 410 | − charOutBigBg(frameBuffer, x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 411 | − charOutBigBg(frameBuffer, x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor, backColor); | |
| 410 | + charOutBigBg(x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 411 | + charOutBigBg(x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor, backColor); | |
| 412 | 412 | } |
| 413 | 413 | } |
| 414 | 414 | |
| 415 | −void printThreeDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 415 | +void printThreeDecimalsBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 416 | 416 | { |
| 417 | 417 | if (value == 0) |
| 418 | 418 | { |
| 419 | − textOutBg(frameBuffer, x, y, "000", fontColor, backColor); | |
| 419 | + textOutBg(x, y, "000", fontColor, backColor); | |
| 420 | 420 | } |
| 421 | 421 | else |
| 422 | 422 | { |
| 423 | 423 | if (value > 999) |
| 424 | 424 | value = 999; |
| 425 | 425 | |
| 426 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 2), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 427 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 428 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor, backColor); | |
| 426 | + charOutBg(x + (FONT_CHAR_W * 2), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 427 | + charOutBg(x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 428 | + charOutBg(x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor, backColor); | |
| 429 | 429 | } |
| 430 | 430 | } |
| 431 | 431 | |
| 432 | −void printFourDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 432 | +void printFourDecimalsBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 433 | 433 | { |
| 434 | 434 | if (value == 0) |
| 435 | 435 | { |
| 436 | − textOutBg(frameBuffer, x, y, "0000", fontColor, backColor); | |
| 436 | + textOutBg(x, y, "0000", fontColor, backColor); | |
| 437 | 437 | } |
| 438 | 438 | else |
| 439 | 439 | { |
| 440 | 440 | if (value > 9999) |
| 441 | 441 | value = 9999; |
| 442 | 442 | |
| 443 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 3), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 444 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 2), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 445 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 446 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor, backColor); | |
| 443 | + charOutBg(x + (FONT_CHAR_W * 3), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 444 | + charOutBg(x + (FONT_CHAR_W * 2), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 445 | + charOutBg(x + (FONT_CHAR_W * 1), y, '0' + (value % 10), fontColor, backColor); value /= 10; | |
| 446 | + charOutBg(x + (FONT_CHAR_W * 0), y, '0' + (value % 10), fontColor, backColor); | |
| 447 | 447 | } |
| 448 | 448 | } |
| 449 | 449 | |
| 450 | 450 | // this one is used for "DISP:" in the sampler screen (zeroes are padded with space) |
| 451 | −void printFiveDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 451 | +void printFiveDecimalsBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 452 | 452 | { |
| 453 | 453 | char numberText[6]; |
| 454 | 454 | uint8_t i; |
| 455 | 455 | |
| 456 | 456 | if (value == 0) |
| 457 | 457 | { |
| 458 | − textOutBg(frameBuffer, x, y, " 0", fontColor, backColor); | |
| 458 | + textOutBg(x, y, " 0", fontColor, backColor); | |
| 459 | 459 | } |
| 460 | 460 | else |
| 461 | 461 | { |
| @@ -473,19 +473,19 @@ void printFiveDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t · 11 unmodified lines | ||
| 473 | 473 | while (numberText[i] == '0') |
| 474 | 474 | numberText[i++] = ' '; |
| 475 | 475 | |
| 476 | − textOutBg(frameBuffer, x, y, numberText, fontColor, backColor); | |
| 476 | + textOutBg(x, y, numberText, fontColor, backColor); | |
| 477 | 477 | } |
| 478 | 478 | } |
| 479 | 479 | |
| 480 | 480 | // this one is used for module size (zeroes are padded with space) |
| 481 | −void printSixDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 481 | +void printSixDecimalsBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 482 | 482 | { |
| 483 | 483 | char numberText[7]; |
| 484 | 484 | uint8_t i; |
| 485 | 485 | |
| 486 | 486 | if (value == 0) |
| 487 | 487 | { |
| 488 | − textOutBg(frameBuffer, x, y, " 0", fontColor, backColor); | |
| 488 | + textOutBg(x, y, " 0", fontColor, backColor); | |
| 489 | 489 | } |
| 490 | 490 | else |
| 491 | 491 | { |
| @@ -504,98 +504,98 @@ void printSixDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t · 12 unmodified lines | ||
| 504 | 504 | while (numberText[i] == '0') |
| 505 | 505 | numberText[i++] = ' '; |
| 506 | 506 | |
| 507 | − textOutBg(frameBuffer, x, y, numberText, fontColor, backColor); | |
| 507 | + textOutBg(x, y, numberText, fontColor, backColor); | |
| 508 | 508 | } |
| 509 | 509 | } |
| 510 | 510 | |
| 511 | −void printOneHexBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 511 | +void printOneHexBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 512 | 512 | { |
| 513 | − charOutBg(frameBuffer, x, y, hexTable[value & 0xF], fontColor, backColor); | |
| 513 | + charOutBg(x, y, hexTable[value & 0xF], fontColor, backColor); | |
| 514 | 514 | } |
| 515 | 515 | |
| 516 | −void printOneHexBigBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 516 | +void printOneHexBigBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 517 | 517 | { |
| 518 | − charOutBigBg(frameBuffer, x, y, hexTable[value & 0xF], fontColor, backColor); | |
| 518 | + charOutBigBg(x, y, hexTable[value & 0xF], fontColor, backColor); | |
| 519 | 519 | } |
| 520 | 520 | |
| 521 | −void printTwoHexBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 521 | +void printTwoHexBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 522 | 522 | { |
| 523 | 523 | if (value == 0) |
| 524 | 524 | { |
| 525 | − textOutBg(frameBuffer, x, y, "00", fontColor, backColor); | |
| 525 | + textOutBg(x, y, "00", fontColor, backColor); | |
| 526 | 526 | } |
| 527 | 527 | else |
| 528 | 528 | { |
| 529 | 529 | value &= 0xFF; |
| 530 | 530 | |
| 531 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 0), y, hexTable[value >> 4], fontColor, backColor); | |
| 532 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 1), y, hexTable[value & 15], fontColor, backColor); | |
| 531 | + charOutBg(x + (FONT_CHAR_W * 0), y, hexTable[value >> 4], fontColor, backColor); | |
| 532 | + charOutBg(x + (FONT_CHAR_W * 1), y, hexTable[value & 15], fontColor, backColor); | |
| 533 | 533 | } |
| 534 | 534 | } |
| 535 | 535 | |
| 536 | −void printTwoHexBigBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 536 | +void printTwoHexBigBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 537 | 537 | { |
| 538 | 538 | if (value == 0) |
| 539 | 539 | { |
| 540 | − textOutBigBg(frameBuffer, x, y, "00", fontColor, backColor); | |
| 540 | + textOutBigBg(x, y, "00", fontColor, backColor); | |
| 541 | 541 | } |
| 542 | 542 | else |
| 543 | 543 | { |
| 544 | 544 | value &= 0xFF; |
| 545 | 545 | |
| 546 | − charOutBigBg(frameBuffer, x + (FONT_CHAR_W * 0), y, hexTable[value >> 4], fontColor, backColor); | |
| 547 | − charOutBigBg(frameBuffer, x + (FONT_CHAR_W * 1), y, hexTable[value & 15], fontColor, backColor); | |
| 546 | + charOutBigBg(x + (FONT_CHAR_W * 0), y, hexTable[value >> 4], fontColor, backColor); | |
| 547 | + charOutBigBg(x + (FONT_CHAR_W * 1), y, hexTable[value & 15], fontColor, backColor); | |
| 548 | 548 | } |
| 549 | 549 | } |
| 550 | 550 | |
| 551 | −void printThreeHexBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 551 | +void printThreeHexBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 552 | 552 | { |
| 553 | 553 | if (value == 0) |
| 554 | 554 | { |
| 555 | − textOutBg(frameBuffer, x, y, "000", fontColor, backColor); | |
| 555 | + textOutBg(x, y, "000", fontColor, backColor); | |
| 556 | 556 | } |
| 557 | 557 | else |
| 558 | 558 | { |
| 559 | 559 | value &= 0xFFF; |
| 560 | 560 | |
| 561 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 0), y, hexTable[value >> 8], fontColor, backColor); | |
| 562 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 4)) >> 4], fontColor, backColor); | |
| 563 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 2), y, hexTable[value & 15], fontColor, backColor); | |
| 561 | + charOutBg(x + (FONT_CHAR_W * 0), y, hexTable[value >> 8], fontColor, backColor); | |
| 562 | + charOutBg(x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 4)) >> 4], fontColor, backColor); | |
| 563 | + charOutBg(x + (FONT_CHAR_W * 2), y, hexTable[value & 15], fontColor, backColor); | |
| 564 | 564 | } |
| 565 | 565 | } |
| 566 | 566 | |
| 567 | −void printFourHexBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 567 | +void printFourHexBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 568 | 568 | { |
| 569 | 569 | if (value == 0) |
| 570 | 570 | { |
| 571 | − textOutBg(frameBuffer, x, y, "0000", fontColor, backColor); | |
| 571 | + textOutBg(x, y, "0000", fontColor, backColor); | |
| 572 | 572 | } |
| 573 | 573 | else |
| 574 | 574 | { |
| 575 | 575 | value &= 0xFFFF; |
| 576 | 576 | |
| 577 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 0), y, hexTable[value >> 12], fontColor, backColor); | |
| 578 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 8)) >> 8], fontColor, backColor); | |
| 579 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 2), y, hexTable[(value & (15 << 4)) >> 4], fontColor, backColor); | |
| 580 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 3), y, hexTable[value & 15], fontColor, backColor); | |
| 577 | + charOutBg(x + (FONT_CHAR_W * 0), y, hexTable[value >> 12], fontColor, backColor); | |
| 578 | + charOutBg(x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 8)) >> 8], fontColor, backColor); | |
| 579 | + charOutBg(x + (FONT_CHAR_W * 2), y, hexTable[(value & (15 << 4)) >> 4], fontColor, backColor); | |
| 580 | + charOutBg(x + (FONT_CHAR_W * 3), y, hexTable[value & 15], fontColor, backColor); | |
| 581 | 581 | } |
| 582 | 582 | } |
| 583 | 583 | |
| 584 | −void printFiveHexBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 584 | +void printFiveHexBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor) | |
| 585 | 585 | { |
| 586 | 586 | if (value == 0) |
| 587 | 587 | { |
| 588 | − textOutBg(frameBuffer, x, y, "00000", fontColor, backColor); | |
| 588 | + textOutBg(x, y, "00000", fontColor, backColor); | |
| 589 | 589 | } |
| 590 | 590 | else |
| 591 | 591 | { |
| 592 | 592 | value &= 0xFFFFF; |
| 593 | 593 | |
| 594 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 0), y, hexTable[value >> 16], fontColor, backColor); | |
| 595 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 12)) >> 12], fontColor, backColor); | |
| 596 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 2), y, hexTable[(value & (15 << 8)) >> 8], fontColor, backColor); | |
| 597 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 3), y, hexTable[(value & (15 << 4)) >> 4], fontColor, backColor); | |
| 598 | − charOutBg(frameBuffer, x + (FONT_CHAR_W * 4), y, hexTable[value & 15], fontColor, backColor); | |
| 594 | + charOutBg(x + (FONT_CHAR_W * 0), y, hexTable[value >> 16], fontColor, backColor); | |
| 595 | + charOutBg(x + (FONT_CHAR_W * 1), y, hexTable[(value & (15 << 12)) >> 12], fontColor, backColor); | |
| 596 | + charOutBg(x + (FONT_CHAR_W * 2), y, hexTable[(value & (15 << 8)) >> 8], fontColor, backColor); | |
| 597 | + charOutBg(x + (FONT_CHAR_W * 3), y, hexTable[(value & (15 << 4)) >> 4], fontColor, backColor); | |
| 598 | + charOutBg(x + (FONT_CHAR_W * 4), y, hexTable[value & 15], fontColor, backColor); | |
| 599 | 599 | } |
| 600 | 600 | } |
| 601 | 601 | |
| @@ -3,41 +3,41 @@ · 2 unmodified lines | ||
| 3 | 3 | #include <stdint.h> |
| 4 | 4 | #include <stdbool.h> |
| 5 | 5 | |
| 6 | −void charOut(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uint32_t color); | |
| 7 | −void charOutBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uint32_t fgColor, uint32_t bgColor); | |
| 8 | −void charOutBig(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uint32_t color); | |
| 9 | −void charOutBigBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, char ch, uint32_t fgColor, uint32_t bgColor); | |
| 10 | −void textOut(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, const char *text, uint32_t color); | |
| 11 | −void textOutTight(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, const char *text, uint32_t color); | |
| 12 | −void textOutBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, const char *text, uint32_t fgColor, uint32_t bgColor); | |
| 13 | −void textOutBig(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, const char *text, uint32_t color); | |
| 14 | −void textOutBigBg(uint32_t *frameBuffer, uint32_t xPos, uint32_t yPos, const char *text, uint32_t fgColor, uint32_t bgColor); | |
| 15 | −void printOneHex(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 16 | −void printTwoHex(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 17 | −void printThreeHex(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 18 | −void printFourHex(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 19 | −void printFiveHex(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 20 | −void printOneHexBig(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 21 | −void printTwoHexBig(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 22 | −void printSixDecimals(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 23 | −void printTwoDecimals(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 24 | −void printFourDecimals(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 25 | −void printFiveDecimals(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 26 | −void printThreeDecimals(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 27 | −void printTwoDecimalsBig(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 28 | −void printOneHexBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 29 | −void printTwoHexBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 30 | −void printThreeHexBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 31 | −void printFourHexBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 32 | −void printFiveHexBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 33 | −void printOneHexBigBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 34 | −void printTwoHexBigBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 35 | −void printSixDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 36 | −void printTwoDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 37 | −void printFourDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 38 | −void printFiveDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 39 | −void printThreeDecimalsBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 40 | −void printTwoDecimalsBigBg(uint32_t *frameBuffer, uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 6 | +void charOut(uint32_t xPos, uint32_t yPos, char ch, uint32_t color); | |
| 7 | +void charOutBg(uint32_t xPos, uint32_t yPos, char ch, uint32_t fgColor, uint32_t bgColor); | |
| 8 | +void charOutBig(uint32_t xPos, uint32_t yPos, char ch, uint32_t color); | |
| 9 | +void charOutBigBg(uint32_t xPos, uint32_t yPos, char ch, uint32_t fgColor, uint32_t bgColor); | |
| 10 | +void textOut(uint32_t xPos, uint32_t yPos, const char *text, uint32_t color); | |
| 11 | +void textOutTight(uint32_t xPos, uint32_t yPos, const char *text, uint32_t color); | |
| 12 | +void textOutBg(uint32_t xPos, uint32_t yPos, const char *text, uint32_t fgColor, uint32_t bgColor); | |
| 13 | +void textOutBig(uint32_t xPos, uint32_t yPos, const char *text, uint32_t color); | |
| 14 | +void textOutBigBg(uint32_t xPos, uint32_t yPos, const char *text, uint32_t fgColor, uint32_t bgColor); | |
| 15 | +void printOneHex(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 16 | +void printTwoHex(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 17 | +void printThreeHex(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 18 | +void printFourHex(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 19 | +void printFiveHex(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 20 | +void printOneHexBig(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 21 | +void printTwoHexBig(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 22 | +void printSixDecimals(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 23 | +void printTwoDecimals(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 24 | +void printFourDecimals(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 25 | +void printFiveDecimals(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 26 | +void printThreeDecimals(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 27 | +void printTwoDecimalsBig(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor); | |
| 28 | +void printOneHexBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 29 | +void printTwoHexBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 30 | +void printThreeHexBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 31 | +void printFourHexBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 32 | +void printFiveHexBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 33 | +void printOneHexBigBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 34 | +void printTwoHexBigBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 35 | +void printSixDecimalsBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 36 | +void printTwoDecimalsBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 37 | +void printFourDecimalsBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 38 | +void printFiveDecimalsBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 39 | +void printThreeDecimalsBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 40 | +void printTwoDecimalsBigBg(uint32_t x, uint32_t y, uint32_t value, uint32_t fontColor, uint32_t backColor); | |
| 41 | 41 | void setPrevStatusMessage(void); |
| 42 | 42 | void setStatusMessage(const char *msg, bool carry); |
| 43 | 43 | void displayMsg(const char *msg); |
| @@ -40,24 +40,16 @@ typedef struct sprite_t · 39 unmodified lines | ||
| 40 | 40 | { |
| 41 | 41 | bool visible; |
| 42 | 42 | int8_t pixelType; |
| 43 | − uint16_t newX, newY, x, y, w, h; | |
| 43 | + int16_t newX, newY, x, y, w, h; | |
| 44 | 44 | uint32_t colorKey, *refreshBuffer; |
| 45 | 45 | const void *data; |
| 46 | 46 | } sprite_t; |
| 47 | 47 | |
| 48 | 48 | static uint32_t vuMetersBg[4 * (10 * 48)]; |
| 49 | −static uint64_t timeNext64, timeNext64Frac, _50HzCounter; | |
| 49 | +static uint64_t timeNext64, timeNext64Frac; | |
| 50 | 50 | |
| 51 | 51 | sprite_t sprites[SPRITE_NUM]; // globalized |
| 52 | 52 | |
| 53 | −extern bool forceMixerOff; // pt_audio.c | |
| 54 | − | |
| 55 | −// pt_main.c | |
| 56 | −extern uint32_t *pixelBuffer; | |
| 57 | −extern SDL_Window *window; | |
| 58 | −extern SDL_Renderer *renderer; | |
| 59 | −extern SDL_Texture *texture; | |
| 60 | − | |
| 61 | 53 | static const uint16_t cursorPosTable[24] = |
| 62 | 54 | { |
| 63 | 55 | 30, 54, 62, 70, 78, 86, |
| @@ -98,7 +90,7 @@ void setupPerfFreq(void) · 34 unmodified lines | ||
| 98 | 90 | dFrac = modf(editor.dPerfFreq / VBLANK_HZ, &dInt); |
| 99 | 91 | |
| 100 | 92 | // integer part |
| 101 | − editor.vblankTimeLen = (uint32_t)dInt; | |
| 93 | + editor.vblankTimeLen = (int32_t)dInt; | |
| 102 | 94 | |
| 103 | 95 | // fractional part scaled to 0..2^32-1 |
| 104 | 96 | dFrac *= UINT32_MAX; |
| @@ -156,7 +148,7 @@ void renderFrame(void) · 51 unmodified lines | ||
| 156 | 148 | updateSampler(); |
| 157 | 149 | updatePosEd(); |
| 158 | 150 | updateVisualizer(); |
| 159 | − updateDragBars(); | |
| 151 | + handleLastGUIObjectDown(); | |
| 160 | 152 | drawSamplerLine(); |
| 161 | 153 | } |
| 162 | 154 | |
| @@ -203,7 +195,7 @@ void renderAskDialog(void) · 40 unmodified lines | ||
| 203 | 195 | // render ask dialog |
| 204 | 196 | |
| 205 | 197 | srcPtr = editor.ui.pat2SmpDialogShown ? pat2SmpDialogBMP : yesNoDialogBMP; |
| 206 | − dstPtr = &pixelBuffer[(51 * SCREEN_W) + 160]; | |
| 198 | + dstPtr = &video.frameBuffer[(51 * SCREEN_W) + 160]; | |
| 207 | 199 | |
| 208 | 200 | for (uint32_t y = 0; y < 39; y++) |
| 209 | 201 | { |
| @@ -225,7 +217,7 @@ void renderBigAskDialog(void) · 15 unmodified lines | ||
| 225 | 217 | // render custom big ask dialog |
| 226 | 218 | |
| 227 | 219 | srcPtr = bigYesNoDialogBMP; |
| 228 | − dstPtr = &pixelBuffer[(44 * SCREEN_W) + 120]; | |
| 220 | + dstPtr = &video.frameBuffer[(44 * SCREEN_W) + 120]; | |
| 229 | 221 | |
| 230 | 222 | for (uint32_t y = 0; y < 55; y++) |
| 231 | 223 | { |
| @@ -244,10 +236,10 @@ void showDownsampleAskDialog(void) · 12 unmodified lines | ||
| 244 | 236 | setStatusMessage("PLEASE SELECT", NO_CARRY); |
| 245 | 237 | renderBigAskDialog(); |
| 246 | 238 | |
| 247 | − textOutTight(pixelBuffer, 133, 49, "THE SAMPLE'S FREQUENCY IS", palette[PAL_BACKGRD]); | |
| 248 | − textOutTight(pixelBuffer, 178, 57, "ABOVE 22KHZ.", palette[PAL_BACKGRD]); | |
| 249 | − textOutTight(pixelBuffer, 133, 65, "DO YOU WANT TO DOWNSAMPLE", palette[PAL_BACKGRD]); | |
| 250 | − textOutTight(pixelBuffer, 156, 73, "BEFORE LOADING IT?", palette[PAL_BACKGRD]); | |
| 239 | + textOutTight(133, 49, "THE SAMPLE'S FREQUENCY IS", video.palette[PAL_BACKGRD]); | |
| 240 | + textOutTight(178, 57, "ABOVE 22KHZ.", video.palette[PAL_BACKGRD]); | |
| 241 | + textOutTight(133, 65, "DO YOU WANT TO DOWNSAMPLE", video.palette[PAL_BACKGRD]); | |
| 242 | + textOutTight(156, 73, "BEFORE LOADING IT?", video.palette[PAL_BACKGRD]); | |
| 251 | 243 | } |
| 252 | 244 | |
| 253 | 245 | static void fillFromVuMetersBgBuffer(void) |
| @@ -259,7 +251,7 @@ static void fillFromVuMetersBgBuffer(void) · 5 unmodified lines | ||
| 259 | 251 | return; |
| 260 | 252 | |
| 261 | 253 | srcPtr = vuMetersBg; |
| 262 | − dstPtr = &pixelBuffer[(187 * SCREEN_W) + 55]; | |
| 254 | + dstPtr = &video.frameBuffer[(187 * SCREEN_W) + 55]; | |
| 263 | 255 | |
| 264 | 256 | for (uint32_t i = 0; i < AMIGA_VOICES; i++) |
| 265 | 257 | { |
| @@ -284,7 +276,7 @@ void fillToVuMetersBgBuffer(void) · 18 unmodified lines | ||
| 284 | 276 | if (editor.ui.samplerScreenShown || editor.isWAVRendering || editor.isSMPRendering) |
| 285 | 277 | return; |
| 286 | 278 | |
| 287 | − srcPtr = &pixelBuffer[(187 * SCREEN_W) + 55]; | |
| 279 | + srcPtr = &video.frameBuffer[(187 * SCREEN_W) + 55]; | |
| 288 | 280 | dstPtr = vuMetersBg; |
| 289 | 281 | |
| 290 | 282 | for (uint32_t i = 0; i < AMIGA_VOICES; i++) |
| @@ -312,10 +304,10 @@ void renderVuMeters(void) · 21 unmodified lines | ||
| 312 | 304 | |
| 313 | 305 | fillToVuMetersBgBuffer(); |
| 314 | 306 | |
| 315 | − dstPtr = &pixelBuffer[(187 * SCREEN_W) + 55]; | |
| 307 | + dstPtr = &video.frameBuffer[(187 * SCREEN_W) + 55]; | |
| 316 | 308 | for (uint32_t i = 0; i < AMIGA_VOICES; i++) |
| 317 | 309 | { |
| 318 | − if (ptConfig.realVuMeters) | |
| 310 | + if (config.realVuMeters) | |
| 319 | 311 | h = editor.realVuMeterVolumes[i]; |
| 320 | 312 | else |
| 321 | 313 | h = editor.vuMeterVolumes[i]; |
| @@ -349,20 +341,20 @@ void updateSongInfo1(void) // left side of screen, when Disk Op. is hidden · 27 unmodified lines | ||
| 349 | 341 | if (editor.ui.updateSongPos) |
| 350 | 342 | { |
| 351 | 343 | editor.ui.updateSongPos = false; |
| 352 | − printThreeDecimalsBg(pixelBuffer, 72, 3, *editor.currPosDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 344 | + printThreeDecimalsBg(72, 3, *editor.currPosDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 353 | 345 | } |
| 354 | 346 | |
| 355 | 347 | if (editor.ui.updateSongPattern) |
| 356 | 348 | { |
| 357 | 349 | editor.ui.updateSongPattern = false; |
| 358 | − printTwoDecimalsBg(pixelBuffer, 80, 14, *editor.currPatternDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 350 | + printTwoDecimalsBg(80, 14, *editor.currPatternDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 359 | 351 | } |
| 360 | 352 | |
| 361 | 353 | if (editor.ui.updateSongLength) |
| 362 | 354 | { |
| 363 | 355 | editor.ui.updateSongLength = false; |
| 364 | 356 | if (!editor.isWAVRendering) |
| 365 | − printThreeDecimalsBg(pixelBuffer, 72, 25, *editor.currLengthDisp,palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 357 | + printThreeDecimalsBg(72, 25, *editor.currLengthDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 366 | 358 | } |
| 367 | 359 | |
| 368 | 360 | if (editor.ui.updateCurrSampleFineTune) |
| @@ -373,18 +365,18 @@ void updateSongInfo1(void) // left side of screen, when Disk Op. is hidden · 4 unmodified lines | ||
| 373 | 365 | { |
| 374 | 366 | if (currSample->fineTune >= 8) |
| 375 | 367 | { |
| 376 | − charOutBg(pixelBuffer, 80, 36, '-', palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 377 | − charOutBg(pixelBuffer, 88, 36, '0' + (0x10 - (currSample->fineTune & 0xF)), palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 368 | + charOutBg(80, 36, '-', video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 369 | + charOutBg(88, 36, '0' + (0x10 - (currSample->fineTune & 0xF)), video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 378 | 370 | } |
| 379 | 371 | else if (currSample->fineTune > 0) |
| 380 | 372 | { |
| 381 | − charOutBg(pixelBuffer, 80, 36, '+', palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 382 | − charOutBg(pixelBuffer, 88, 36, '0' + (currSample->fineTune & 0xF), palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 373 | + charOutBg(80, 36, '+', video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 374 | + charOutBg(88, 36, '0' + (currSample->fineTune & 0xF), video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 383 | 375 | } |
| 384 | 376 | else |
| 385 | 377 | { |
| 386 | − charOutBg(pixelBuffer, 80, 36, ' ', palette[PAL_GENBKG], palette[PAL_GENBKG]); | |
| 387 | − charOutBg(pixelBuffer, 88, 36, '0', palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 378 | + charOutBg(80, 36, ' ', video.palette[PAL_GENBKG], video.palette[PAL_GENBKG]); | |
| 379 | + charOutBg(88, 36, '0', video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 388 | 380 | } |
| 389 | 381 | } |
| 390 | 382 | } |
| @@ -394,8 +386,8 @@ void updateSongInfo1(void) // left side of screen, when Disk Op. is hidden · 3 unmodified lines | ||
| 394 | 386 | editor.ui.updateCurrSampleNum = false; |
| 395 | 387 | if (!editor.isWAVRendering) |
| 396 | 388 | { |
| 397 | − printTwoHexBg(pixelBuffer, 80, 47, | |
| 398 | − editor.sampleZero ? 0 : ((*editor.currSampleDisp) + 1), palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 389 | + printTwoHexBg(80, 47, | |
| 390 | + editor.sampleZero ? 0 : ((*editor.currSampleDisp) + 1), video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 399 | 391 | } |
| 400 | 392 | } |
| 401 | 393 | |
| @@ -403,26 +395,26 @@ void updateSongInfo1(void) // left side of screen, when Disk Op. is hidden · 1 unmodified line | ||
| 403 | 395 | { |
| 404 | 396 | editor.ui.updateCurrSampleVolume = false; |
| 405 | 397 | if (!editor.isWAVRendering) |
| 406 | − printTwoHexBg(pixelBuffer, 80, 58, *currSample->volumeDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 398 | + printTwoHexBg(80, 58, *currSample->volumeDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 407 | 399 | } |
| 408 | 400 | |
| 409 | 401 | if (editor.ui.updateCurrSampleLength) |
| 410 | 402 | { |
| 411 | 403 | editor.ui.updateCurrSampleLength = false; |
| 412 | 404 | if (!editor.isWAVRendering) |
| 413 | − printFourHexBg(pixelBuffer, 64, 69, *currSample->lengthDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 405 | + printFourHexBg(64, 69, *currSample->lengthDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 414 | 406 | } |
| 415 | 407 | |
| 416 | 408 | if (editor.ui.updateCurrSampleRepeat) |
| 417 | 409 | { |
| 418 | 410 | editor.ui.updateCurrSampleRepeat = false; |
| 419 | − printFourHexBg(pixelBuffer, 64, 80, *currSample->loopStartDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 411 | + printFourHexBg(64, 80, *currSample->loopStartDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 420 | 412 | } |
| 421 | 413 | |
| 422 | 414 | if (editor.ui.updateCurrSampleReplen) |
| 423 | 415 | { |
| 424 | 416 | editor.ui.updateCurrSampleReplen = false; |
| 425 | − printFourHexBg(pixelBuffer, 64, 91, *currSample->loopLengthDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 417 | + printFourHexBg(64, 91, *currSample->loopLengthDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 426 | 418 | } |
| 427 | 419 | } |
| 428 | 420 | |
| @@ -437,30 +429,30 @@ void updateSongInfo2(void) // two middle rows of screen, always present · 8 unmodified lines | ||
| 437 | 429 | editor.ui.updateStatusText = false; |
| 438 | 430 | |
| 439 | 431 | // clear background |
| 440 | − textOutBg(pixelBuffer, 88, 127, " ", palette[PAL_GENBKG], palette[PAL_GENBKG]); | |
| 432 | + textOutBg(88, 127, " ", video.palette[PAL_GENBKG], video.palette[PAL_GENBKG]); | |
| 441 | 433 | |
| 442 | 434 | // render status text |
| 443 | 435 | if (!editor.errorMsgActive && editor.blockMarkFlag && !editor.ui.askScreenShown |
| 444 | 436 | && !editor.ui.clearScreenShown && !editor.swapChannelFlag) |
| 445 | 437 | { |
| 446 | − textOut(pixelBuffer, 88, 127, "MARK BLOCK", palette[PAL_GENTXT]); | |
| 447 | − charOut(pixelBuffer, 192, 127, '-', palette[PAL_GENTXT]); | |
| 438 | + textOut(88, 127, "MARK BLOCK", video.palette[PAL_GENTXT]); | |
| 439 | + charOut(192, 127, '-', video.palette[PAL_GENTXT]); | |
| 448 | 440 | |
| 449 | 441 | editor.blockToPos = modEntry->currRow; |
| 450 | 442 | if (editor.blockFromPos >= editor.blockToPos) |
| 451 | 443 | { |
| 452 | − printTwoDecimals(pixelBuffer, 176, 127, editor.blockToPos, palette[PAL_GENTXT]); | |
| 453 | − printTwoDecimals(pixelBuffer, 200, 127, editor.blockFromPos, palette[PAL_GENTXT]); | |
| 444 | + printTwoDecimals(176, 127, editor.blockToPos, video.palette[PAL_GENTXT]); | |
| 445 | + printTwoDecimals(200, 127, editor.blockFromPos, video.palette[PAL_GENTXT]); | |
| 454 | 446 | } |
| 455 | 447 | else |
| 456 | 448 | { |
| 457 | − printTwoDecimals(pixelBuffer, 176, 127, editor.blockFromPos, palette[PAL_GENTXT]); | |
| 458 | − printTwoDecimals(pixelBuffer, 200, 127, editor.blockToPos, palette[PAL_GENTXT]); | |
| 449 | + printTwoDecimals(176, 127, editor.blockFromPos, video.palette[PAL_GENTXT]); | |
| 450 | + printTwoDecimals(200, 127, editor.blockToPos, video.palette[PAL_GENTXT]); | |
| 459 | 451 | } |
| 460 | 452 | } |
| 461 | 453 | else |
| 462 | 454 | { |
| 463 | − textOut(pixelBuffer, 88, 127, editor.ui.statusMessage, palette[PAL_GENTXT]); | |
| 455 | + textOut(88, 127, editor.ui.statusMessage, video.palette[PAL_GENTXT]); | |
| 464 | 456 | } |
| 465 | 457 | } |
| 466 | 458 | |
| @@ -468,62 +460,62 @@ void updateSongInfo2(void) // two middle rows of screen, always present · 1 unmodified line | ||
| 468 | 460 | { |
| 469 | 461 | editor.ui.updateSongBPM = false; |
| 470 | 462 | if (!editor.ui.samplerScreenShown) |
| 471 | − printThreeDecimalsBg(pixelBuffer, 32, 123, modEntry->currBPM, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 463 | + printThreeDecimalsBg(32, 123, modEntry->currBPM, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 472 | 464 | } |
| 473 | 465 | |
| 474 | 466 | if (editor.ui.updateCurrPattText) |
| 475 | 467 | { |
| 476 | 468 | editor.ui.updateCurrPattText = false; |
| 477 | 469 | if (!editor.ui.samplerScreenShown) |
| 478 | − printTwoDecimalsBg(pixelBuffer, 8, 127, *editor.currEditPatternDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 470 | + printTwoDecimalsBg(8, 127, *editor.currEditPatternDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 479 | 471 | } |
| 480 | 472 | |
| 481 | 473 | if (editor.ui.updateTrackerFlags) |
| 482 | 474 | { |
| 483 | 475 | editor.ui.updateTrackerFlags = false; |
| 484 | 476 | |
| 485 | − charOutBg(pixelBuffer, 1, 113, ' ', palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 486 | − charOutBg(pixelBuffer, 8, 113, ' ', palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 477 | + charOutBg(1, 113, ' ', video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 478 | + charOutBg(8, 113, ' ', video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 487 | 479 | |
| 488 | 480 | if (editor.autoInsFlag) |
| 489 | 481 | { |
| 490 | − charOut(pixelBuffer, 0, 113, 'I', palette[PAL_GENTXT]); | |
| 482 | + charOut(0, 113, 'I', video.palette[PAL_GENTXT]); | |
| 491 | 483 | |
| 492 | 484 | // in Amiga PT, "auto insert" 9 means 0 |
| 493 | 485 | if (editor.autoInsSlot == 9) |
| 494 | − charOut(pixelBuffer, 8, 113, '0', palette[PAL_GENTXT]); | |
| 486 | + charOut(8, 113, '0', video.palette[PAL_GENTXT]); | |
| 495 | 487 | else |
| 496 | − charOut(pixelBuffer, 8, 113, '1' + editor.autoInsSlot, palette[PAL_GENTXT]); | |
| 488 | + charOut(8, 113, '1' + editor.autoInsSlot, video.palette[PAL_GENTXT]); | |
| 497 | 489 | } |
| 498 | 490 | |
| 499 | − charOutBg(pixelBuffer, 1, 102, ' ', palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 491 | + charOutBg(1, 102, ' ', video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 500 | 492 | if (editor.metroFlag) |
| 501 | − charOut(pixelBuffer, 0, 102, 'M', palette[PAL_GENTXT]); | |
| 493 | + charOut(0, 102, 'M', video.palette[PAL_GENTXT]); | |
| 502 | 494 | |
| 503 | − charOutBg(pixelBuffer, 16, 102, ' ', palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 495 | + charOutBg(16, 102, ' ', video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 504 | 496 | if (editor.multiFlag) |
| 505 | − charOut(pixelBuffer, 16, 102, 'M', palette[PAL_GENTXT]); | |
| 497 | + charOut(16, 102, 'M', video.palette[PAL_GENTXT]); | |
| 506 | 498 | |
| 507 | − charOutBg(pixelBuffer, 24, 102, '0' + editor.editMoveAdd,palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 499 | + charOutBg(24, 102, '0' + editor.editMoveAdd, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 508 | 500 | |
| 509 | − charOutBg(pixelBuffer, 311, 128, ' ', palette[PAL_GENBKG], palette[PAL_GENBKG]); | |
| 501 | + charOutBg(311, 128, ' ', video.palette[PAL_GENBKG], video.palette[PAL_GENBKG]); | |
| 510 | 502 | if (editor.pNoteFlag == 1) |
| 511 | 503 | { |
| 512 | − pixelBuffer[(129 * SCREEN_W) + 314] = palette[PAL_GENTXT]; | |
| 513 | − pixelBuffer[(129 * SCREEN_W) + 315] = palette[PAL_GENTXT]; | |
| 504 | + video.frameBuffer[(129 * SCREEN_W) + 314] = video.palette[PAL_GENTXT]; | |
| 505 | + video.frameBuffer[(129 * SCREEN_W) + 315] = video.palette[PAL_GENTXT]; | |
| 514 | 506 | } |
| 515 | 507 | else if (editor.pNoteFlag == 2) |
| 516 | 508 | { |
| 517 | − pixelBuffer[(128 * SCREEN_W) + 314] = palette[PAL_GENTXT]; | |
| 518 | − pixelBuffer[(128 * SCREEN_W) + 315] = palette[PAL_GENTXT]; | |
| 519 | − pixelBuffer[(130 * SCREEN_W) + 314] = palette[PAL_GENTXT]; | |
| 520 | − pixelBuffer[(130 * SCREEN_W) + 315] = palette[PAL_GENTXT]; | |
| 509 | + video.frameBuffer[(128 * SCREEN_W) + 314] = video.palette[PAL_GENTXT]; | |
| 510 | + video.frameBuffer[(128 * SCREEN_W) + 315] = video.palette[PAL_GENTXT]; | |
| 511 | + video.frameBuffer[(130 * SCREEN_W) + 314] = video.palette[PAL_GENTXT]; | |
| 512 | + video.frameBuffer[(130 * SCREEN_W) + 315] = video.palette[PAL_GENTXT]; | |
| 521 | 513 | } |
| 522 | 514 | } |
| 523 | 515 | |
| 524 | 516 | // playback timer |
| 525 | 517 | |
| 526 | − secs = ((editor.musicTime / 256) * 5) / 512; | |
| 518 | + secs = ((editor.musicTime >> 8) * 5) >> 9; | |
| 527 | 519 | secs -= ((secs / 3600) * 3600); |
| 528 | 520 | |
| 529 | 521 | if (secs <= 5999) // below 99 minutes 59 seconds |
| @@ -532,14 +524,14 @@ void updateSongInfo2(void) // two middle rows of screen, always present · 2 unmodified lines | ||
| 532 | 524 | MI_TimeS = secs - (MI_TimeM * 60); |
| 533 | 525 | |
| 534 | 526 | // xx:xx |
| 535 | − printTwoDecimalsBg(pixelBuffer, 272, 102, MI_TimeM, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 536 | − printTwoDecimalsBg(pixelBuffer, 296, 102, MI_TimeS, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 527 | + printTwoDecimalsBg(272, 102, MI_TimeM, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 528 | + printTwoDecimalsBg(296, 102, MI_TimeS, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 537 | 529 | } |
| 538 | 530 | else |
| 539 | 531 | { |
| 540 | 532 | // 99:59 |
| 541 | − printTwoDecimalsBg(pixelBuffer, 272, 102, 99, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 542 | − printTwoDecimalsBg(pixelBuffer, 296, 102, 59, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 533 | + printTwoDecimalsBg(272, 102, 99, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 534 | + printTwoDecimalsBg(296, 102, 59, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 543 | 535 | } |
| 544 | 536 | |
| 545 | 537 | if (editor.ui.updateSongName) |
| @@ -551,7 +543,7 @@ void updateSongInfo2(void) // two middle rows of screen, always present · 5 unmodified lines | ||
| 551 | 543 | if (tempChar == '\0') |
| 552 | 544 | tempChar = '_'; |
| 553 | 545 | |
| 554 | − charOutBg(pixelBuffer, 104 + (x * FONT_CHAR_W), 102, tempChar, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 546 | + charOutBg(104 + (x * FONT_CHAR_W), 102, tempChar, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 555 | 547 | } |
| 556 | 548 | } |
| 557 | 549 | |
| @@ -566,7 +558,7 @@ void updateSongInfo2(void) // two middle rows of screen, always present · 8 unmodified lines | ||
| 566 | 558 | if (tempChar == '\0') |
| 567 | 559 | tempChar = '_'; |
| 568 | 560 | |
| 569 | − charOutBg(pixelBuffer, 104 + (x * FONT_CHAR_W), 113, tempChar, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 561 | + charOutBg(104 + (x * FONT_CHAR_W), 113, tempChar, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 570 | 562 | } |
| 571 | 563 | } |
| 572 | 564 | |
| @@ -575,7 +567,7 @@ void updateSongInfo2(void) // two middle rows of screen, always present · 2 unmodified lines | ||
| 575 | 567 | editor.ui.updateSongSize = false; |
| 576 | 568 | |
| 577 | 569 | // clear background |
| 578 | − textOutBg(pixelBuffer, 264, 123, " ", palette[PAL_GENBKG], palette[PAL_GENBKG]); | |
| 570 | + textOutBg(264, 123, " ", video.palette[PAL_GENBKG], video.palette[PAL_GENBKG]); | |
| 579 | 571 | |
| 580 | 572 | // calculate module length |
| 581 | 573 | uint32_t totalSampleDataSize = 0; |
| @@ -592,19 +584,19 @@ void updateSongInfo2(void) // two middle rows of screen, always present · 10 unmodified lines | ||
| 592 | 584 | uint32_t moduleSize = 2108 + (totalPatterns * 1024) + totalSampleDataSize; |
| 593 | 585 | if (moduleSize > 999999) |
| 594 | 586 | { |
| 595 | − charOut(pixelBuffer, 304, 123, 'K', palette[PAL_GENTXT]); | |
| 596 | − printFourDecimals(pixelBuffer, 272, 123, moduleSize / 1000, palette[PAL_GENTXT]); | |
| 587 | + charOut(304, 123, 'K', video.palette[PAL_GENTXT]); | |
| 588 | + printFourDecimals(272, 123, moduleSize / 1000, video.palette[PAL_GENTXT]); | |
| 597 | 589 | } |
| 598 | 590 | else |
| 599 | 591 | { |
| 600 | − printSixDecimals(pixelBuffer, 264, 123, moduleSize, palette[PAL_GENTXT]); | |
| 592 | + printSixDecimals(264, 123, moduleSize, video.palette[PAL_GENTXT]); | |
| 601 | 593 | } |
| 602 | 594 | } |
| 603 | 595 | |
| 604 | 596 | if (editor.ui.updateSongTiming) |
| 605 | 597 | { |
| 606 | 598 | editor.ui.updateSongTiming = false; |
| 607 | − textOutBg(pixelBuffer, 288, 130, (editor.timingMode == TEMPO_MODE_CIA) ? "CIA" : "VBL", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 599 | + textOutBg(288, 130, (editor.timingMode == TEMPO_MODE_CIA) ? "CIA" : "VBL", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 608 | 600 | } |
| 609 | 601 | } |
| 610 | 602 | |
| @@ -626,11 +618,11 @@ void updateSampler(void) · 15 unmodified lines | ||
| 626 | 618 | s = &modEntry->samples[editor.currSample]; |
| 627 | 619 | |
| 628 | 620 | // update 9xx offset |
| 629 | − if (input.mouse.y >= 138 && input.mouse.y <= 201 && input.mouse.x >= 3 && input.mouse.x <= 316) | |
| 621 | + if (mouse.y >= 138 && mouse.y <= 201 && mouse.x >= 3 && mouse.x <= 316) | |
| 630 | 622 | { |
| 631 | 623 | if (!editor.ui.samplerVolBoxShown && !editor.ui.samplerFiltersBoxShown && s->length > 0) |
| 632 | 624 | { |
| 633 | − tmpSampleOffset = (scr2SmpPos(input.mouse.x-3) + (1 << 7)) >> 8; // rounded | |
| 625 | + tmpSampleOffset = (scr2SmpPos(mouse.x-3) + (1 << 7)) >> 8; // rounded | |
| 634 | 626 | tmpSampleOffset = 0x900 + CLAMP(tmpSampleOffset, 0x00, 0xFF); |
| 635 | 627 | |
| 636 | 628 | if (tmpSampleOffset != editor.ui.lastSampleOffset) |
| @@ -645,7 +637,7 @@ void updateSampler(void) · 8 unmodified lines | ||
| 645 | 637 | if (editor.ui.update9xxPos) |
| 646 | 638 | { |
| 647 | 639 | editor.ui.update9xxPos = false; |
| 648 | − printThreeHexBg(pixelBuffer, 288, 247, editor.ui.lastSampleOffset, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 640 | + printThreeHexBg(288, 247, editor.ui.lastSampleOffset, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 649 | 641 | } |
| 650 | 642 | |
| 651 | 643 | if (editor.ui.updateResampleNote) |
| @@ -655,14 +647,14 @@ void updateSampler(void) · 3 unmodified lines | ||
| 655 | 647 | // show resample note |
| 656 | 648 | if (editor.ui.changingSmpResample) |
| 657 | 649 | { |
| 658 | − textOutBg(pixelBuffer, 288, 236, "---", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 650 | + textOutBg(288, 236, "---", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 659 | 651 | } |
| 660 | 652 | else |
| 661 | 653 | { |
| 662 | 654 | assert(editor.resampleNote < 36); |
| 663 | − textOutBg(pixelBuffer, 288, 236, | |
| 664 | − ptConfig.accidental ? noteNames2[editor.resampleNote] : noteNames1[editor.resampleNote], | |
| 665 | − palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 655 | + textOutBg(288, 236, | |
| 656 | + config.accidental ? noteNames2[editor.resampleNote] : noteNames1[editor.resampleNote], | |
| 657 | + video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 666 | 658 | } |
| 667 | 659 | } |
| 668 | 660 | |
| @@ -671,13 +663,13 @@ void updateSampler(void) · 2 unmodified lines | ||
| 671 | 663 | if (editor.ui.updateVolFromText) |
| 672 | 664 | { |
| 673 | 665 | editor.ui.updateVolFromText = false; |
| 674 | − printThreeDecimalsBg(pixelBuffer, 176, 157, *editor.vol1Disp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 666 | + printThreeDecimalsBg(176, 157, *editor.vol1Disp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 675 | 667 | } |
| 676 | 668 | |
| 677 | 669 | if (editor.ui.updateVolToText) |
| 678 | 670 | { |
| 679 | 671 | editor.ui.updateVolToText = false; |
| 680 | − printThreeDecimalsBg(pixelBuffer, 176, 168, *editor.vol2Disp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 672 | + printThreeDecimalsBg(176, 168, *editor.vol2Disp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 681 | 673 | } |
| 682 | 674 | } |
| 683 | 675 | else if (editor.ui.samplerFiltersBoxShown) |
| @@ -685,13 +677,13 @@ void updateSampler(void) · 1 unmodified line | ||
| 685 | 677 | if (editor.ui.updateLPText) |
| 686 | 678 | { |
| 687 | 679 | editor.ui.updateLPText = false; |
| 688 | − printFourDecimalsBg(pixelBuffer, 168, 157, *editor.lpCutOffDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 680 | + printFourDecimalsBg(168, 157, *editor.lpCutOffDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 689 | 681 | } |
| 690 | 682 | |
| 691 | 683 | if (editor.ui.updateHPText) |
| 692 | 684 | { |
| 693 | 685 | editor.ui.updateHPText = false; |
| 694 | − printFourDecimalsBg(pixelBuffer, 168, 168, *editor.hpCutOffDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 686 | + printFourDecimalsBg(168, 168, *editor.hpCutOffDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 695 | 687 | } |
| 696 | 688 | |
| 697 | 689 | if (editor.ui.updateNormFlag) |
| @@ -699,9 +691,9 @@ void updateSampler(void) · 1 unmodified line | ||
| 699 | 691 | editor.ui.updateNormFlag = false; |
| 700 | 692 | |
| 701 | 693 | if (editor.normalizeFiltersFlag) |
| 702 | − textOutBg(pixelBuffer, 208, 179, "YES", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 694 | + textOutBg(208, 179, "YES", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 703 | 695 | else |
| 704 | − textOutBg(pixelBuffer, 208, 179, "NO ", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 696 | + textOutBg(208, 179, "NO ", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 705 | 697 | } |
| 706 | 698 | } |
| 707 | 699 | } |
| @@ -712,9 +704,9 @@ void showVolFromSlider(void) · 4 unmodified lines | ||
| 712 | 704 | |
| 713 | 705 | sliderStart = ((editor.vol1 * 3) + 5) / 10; |
| 714 | 706 | sliderEnd = sliderStart + 4; |
| 715 | − pixel = palette[PAL_QADSCP]; | |
| 716 | − bgPixel = palette[PAL_BACKGRD]; | |
| 717 | − dstPtr = &pixelBuffer[(158 * SCREEN_W) + 105]; | |
| 707 | + pixel = video.palette[PAL_QADSCP]; | |
| 708 | + bgPixel = video.palette[PAL_BACKGRD]; | |
| 709 | + dstPtr = &video.frameBuffer[(158 * SCREEN_W) + 105]; | |
| 718 | 710 | |
| 719 | 711 | for (uint32_t y = 0; y < 3; y++) |
| 720 | 712 | { |
| @@ -736,9 +728,9 @@ void showVolToSlider(void) · 15 unmodified lines | ||
| 736 | 728 | |
| 737 | 729 | sliderStart = ((editor.vol2 * 3) + 5) / 10; |
| 738 | 730 | sliderEnd = sliderStart + 4; |
| 739 | − pixel = palette[PAL_QADSCP]; | |
| 740 | − bgPixel = palette[PAL_BACKGRD]; | |
| 741 | − dstPtr = &pixelBuffer[(169 * SCREEN_W) + 105]; | |
| 731 | + pixel = video.palette[PAL_QADSCP]; | |
| 732 | + bgPixel = video.palette[PAL_BACKGRD]; | |
| 733 | + dstPtr = &video.frameBuffer[(169 * SCREEN_W) + 105]; | |
| 742 | 734 | |
| 743 | 735 | for (uint32_t y = 0; y < 3; y++) |
| 744 | 736 | { |
| @@ -760,7 +752,7 @@ void renderSamplerVolBox(void) · 15 unmodified lines | ||
| 760 | 752 | uint32_t *dstPtr; |
| 761 | 753 | |
| 762 | 754 | srcPtr = samplerVolumeBMP; |
| 763 | − dstPtr = &pixelBuffer[(154 * SCREEN_W) + 72]; | |
| 755 | + dstPtr = &video.frameBuffer[(154 * SCREEN_W) + 72]; | |
| 764 | 756 | |
| 765 | 757 | for (uint32_t y = 0; y < 33; y++) |
| 766 | 758 | { |
| @@ -791,7 +783,7 @@ void renderSamplerFiltersBox(void) · 24 unmodified lines | ||
| 791 | 783 | uint32_t *dstPtr; |
| 792 | 784 | |
| 793 | 785 | srcPtr = samplerFiltersBMP; |
| 794 | − dstPtr = &pixelBuffer[(154 * SCREEN_W) + 65]; | |
| 786 | + dstPtr = &video.frameBuffer[(154 * SCREEN_W) + 65]; | |
| 795 | 787 | |
| 796 | 788 | for (uint32_t y = 0; y < 33; y++) |
| 797 | 789 | { |
| @@ -801,8 +793,8 @@ void renderSamplerFiltersBox(void) · 3 unmodified lines | ||
| 801 | 793 | dstPtr += SCREEN_W; |
| 802 | 794 | } |
| 803 | 795 | |
| 804 | − textOut(pixelBuffer, 200, 157, "HZ", palette[PAL_GENTXT]); | |
| 805 | − textOut(pixelBuffer, 200, 168, "HZ", palette[PAL_GENTXT]); | |
| 796 | + textOut(200, 157, "HZ", video.palette[PAL_GENTXT]); | |
| 797 | + textOut(200, 168, "HZ", video.palette[PAL_GENTXT]); | |
| 806 | 798 | |
| 807 | 799 | editor.ui.updateLPText = true; |
| 808 | 800 | editor.ui.updateHPText = true; |
| @@ -820,7 +812,7 @@ void removeSamplerFiltersBox(void) · 11 unmodified lines | ||
| 820 | 812 | |
| 821 | 813 | void renderDiskOpScreen(void) |
| 822 | 814 | { |
| 823 | − memcpy(pixelBuffer, diskOpScreenBMP, (99 * 320) * sizeof (int32_t)); | |
| 815 | + memcpy(video.frameBuffer, diskOpScreenBMP, (99 * 320) * sizeof (int32_t)); | |
| 824 | 816 | |
| 825 | 817 | editor.ui.updateDiskOpPathText = true; |
| 826 | 818 | editor.ui.updatePackText = true; |
| @@ -841,7 +833,7 @@ void updateDiskOp(void) · 14 unmodified lines | ||
| 841 | 833 | if (editor.ui.updateDiskOpFileList) |
| 842 | 834 | { |
| 843 | 835 | editor.ui.updateDiskOpFileList = false; |
| 844 | − diskOpRenderFileList(pixelBuffer); | |
| 836 | + diskOpRenderFileList(); | |
| 845 | 837 | } |
| 846 | 838 | |
| 847 | 839 | if (editor.ui.updateLoadMode) |
| @@ -849,13 +841,13 @@ void updateDiskOp(void) · 1 unmodified line | ||
| 849 | 841 | editor.ui.updateLoadMode = false; |
| 850 | 842 | |
| 851 | 843 | // clear backgrounds |
| 852 | − charOutBg(pixelBuffer, 147, 3, ' ', palette[PAL_GENBKG], palette[PAL_GENBKG]); | |
| 853 | − charOutBg(pixelBuffer, 147, 14, ' ', palette[PAL_GENBKG], palette[PAL_GENBKG]); | |
| 844 | + charOutBg(147, 3, ' ', video.palette[PAL_GENBKG], video.palette[PAL_GENBKG]); | |
| 845 | + charOutBg(147, 14, ' ', video.palette[PAL_GENBKG], video.palette[PAL_GENBKG]); | |
| 854 | 846 | |
| 855 | 847 | // draw load mode arrow |
| 856 | 848 | |
| 857 | 849 | srcPtr = arrowBMP; |
| 858 | − dstPtr = &pixelBuffer[(((11 * editor.diskop.mode) + 3) * SCREEN_W) + 148]; | |
| 850 | + dstPtr = &video.frameBuffer[(((11 * editor.diskop.mode) + 3) * SCREEN_W) + 148]; | |
| 859 | 851 | |
| 860 | 852 | for (uint32_t y = 0; y < 5; y++) |
| 861 | 853 | { |
| @@ -870,15 +862,15 @@ void updateDiskOp(void) · 8 unmodified lines | ||
| 870 | 862 | if (editor.ui.updatePackText) |
| 871 | 863 | { |
| 872 | 864 | editor.ui.updatePackText = false; |
| 873 | − textOutBg(pixelBuffer, 120, 3, editor.diskop.modPackFlg ? "ON " : "OFF", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 865 | + textOutBg(120, 3, editor.diskop.modPackFlg ? "ON " : "OFF", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 874 | 866 | } |
| 875 | 867 | |
| 876 | 868 | if (editor.ui.updateSaveFormatText) |
| 877 | 869 | { |
| 878 | 870 | editor.ui.updateSaveFormatText = false; |
| 879 | − if (editor.diskop.smpSaveType == DISKOP_SMP_WAV) textOutBg(pixelBuffer, 120, 14, "WAV", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 880 | − else if (editor.diskop.smpSaveType == DISKOP_SMP_IFF) textOutBg(pixelBuffer, 120, 14, "IFF", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 881 | − else if (editor.diskop.smpSaveType == DISKOP_SMP_RAW) textOutBg(pixelBuffer, 120, 14, "RAW", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 871 | + if (editor.diskop.smpSaveType == DISKOP_SMP_WAV) textOutBg(120, 14, "WAV", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 872 | + else if (editor.diskop.smpSaveType == DISKOP_SMP_IFF) textOutBg(120, 14, "IFF", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 873 | + else if (editor.diskop.smpSaveType == DISKOP_SMP_RAW) textOutBg(120, 14, "RAW", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 882 | 874 | } |
| 883 | 875 | |
| 884 | 876 | if (editor.ui.updateDiskOpPathText) |
| @@ -892,7 +884,7 @@ void updateDiskOp(void) · 7 unmodified lines | ||
| 892 | 884 | if (tmpChar == '\0') |
| 893 | 885 | tmpChar = '_'; |
| 894 | 886 | |
| 895 | − charOutBg(pixelBuffer, 24 + (i * FONT_CHAR_W), 25, tmpChar, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 887 | + charOutBg(24 + (i * FONT_CHAR_W), 25, tmpChar, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 896 | 888 | } |
| 897 | 889 | } |
| 898 | 890 | } |
| @@ -910,7 +902,7 @@ void updatePosEd(void) · 11 unmodified lines | ||
| 910 | 902 | |
| 911 | 903 | if (!editor.ui.disablePosEd) |
| 912 | 904 | { |
| 913 | − bgPixel = palette[PAL_BACKGRD]; | |
| 905 | + bgPixel = video.palette[PAL_BACKGRD]; | |
| 914 | 906 | |
| 915 | 907 | posEdPosition = modEntry->currOrder; |
| 916 | 908 | if (posEdPosition > modEntry->head.orderCount-1) |
| @@ -921,15 +913,12 @@ void updatePosEd(void) · 4 unmodified lines | ||
| 921 | 913 | { |
| 922 | 914 | if (posEdPosition-(5-y) >= 0) |
| 923 | 915 | { |
| 924 | − printThreeDecimalsBg(pixelBuffer, 128, 23+(y*6), | |
| 925 | − posEdPosition-(5-y), palette[PAL_QADSCP], palette[PAL_BACKGRD]); | |
| 926 | − | |
| 927 | − printTwoDecimalsBg(pixelBuffer, 160, 23+(y*6), modEntry->head.order[posEdPosition-(5-y)], | |
| 928 | − palette[PAL_QADSCP], palette[PAL_BACKGRD]); | |
| 916 | + printThreeDecimalsBg(128, 23+(y*6), posEdPosition-(5-y), video.palette[PAL_QADSCP], video.palette[PAL_BACKGRD]); | |
| 917 | + printTwoDecimalsBg(160, 23+(y*6), modEntry->head.order[posEdPosition-(5-y)], video.palette[PAL_QADSCP], video.palette[PAL_BACKGRD]); | |
| 929 | 918 | } |
| 930 | 919 | else |
| 931 | 920 | { |
| 932 | − dstPtr = &pixelBuffer[((23+(y*6)) * SCREEN_W) + 128]; | |
| 921 | + dstPtr = &video.frameBuffer[((23+(y*6)) * SCREEN_W) + 128]; | |
| 933 | 922 | for (y2 = 0; y2 < 5; y2++) |
| 934 | 923 | { |
| 935 | 924 | for (x = 0; x < FONT_CHAR_W*22; x++) |
| @@ -941,23 +930,20 @@ void updatePosEd(void) · 5 unmodified lines | ||
| 941 | 930 | } |
| 942 | 931 | |
| 943 | 932 | // middle |
| 944 | − printThreeDecimalsBg(pixelBuffer, 128, 53, posEdPosition, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 945 | − printTwoDecimalsBg(pixelBuffer, 160, 53, *editor.currPosEdPattDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 933 | + printThreeDecimalsBg(128, 53, posEdPosition, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 934 | + printTwoDecimalsBg(160, 53, *editor.currPosEdPattDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 946 | 935 | |
| 947 | 936 | // bottom six |
| 948 | 937 | for (y = 0; y < 6; y++) |
| 949 | 938 | { |
| 950 | 939 | if (posEdPosition+y < modEntry->head.orderCount-1) |
| 951 | 940 | { |
| 952 | − printThreeDecimalsBg(pixelBuffer, 128, 59+(y*6), posEdPosition+(y+1), | |
| 953 | − palette[PAL_QADSCP], palette[PAL_BACKGRD]); | |
| 954 | − | |
| 955 | − printTwoDecimalsBg(pixelBuffer, 160, 59+(y*6), modEntry->head.order[posEdPosition+(y+1)], | |
| 956 | − palette[PAL_QADSCP], palette[PAL_BACKGRD]); | |
| 941 | + printThreeDecimalsBg(128, 59+(y*6), posEdPosition+(y+1), video.palette[PAL_QADSCP], video.palette[PAL_BACKGRD]); | |
| 942 | + printTwoDecimalsBg(160, 59+(y*6), modEntry->head.order[posEdPosition+(y+1)], video.palette[PAL_QADSCP], video.palette[PAL_BACKGRD]); | |
| 957 | 943 | } |
| 958 | 944 | else |
| 959 | 945 | { |
| 960 | − dstPtr = &pixelBuffer[((59+(y*6)) * SCREEN_W) + 128]; | |
| 946 | + dstPtr = &video.frameBuffer[((59+(y*6)) * SCREEN_W) + 128]; | |
| 961 | 947 | for (y2 = 0; y2 < 5; y2++) |
| 962 | 948 | { |
| 963 | 949 | for (x = 0; x < FONT_CHAR_W*22; x++) |
| @@ -980,7 +966,7 @@ void renderPosEdScreen(void) · 16 unmodified lines | ||
| 980 | 966 | uint32_t *dstPtr; |
| 981 | 967 | |
| 982 | 968 | srcPtr = posEdBMP; |
| 983 | − dstPtr = &pixelBuffer[120]; | |
| 969 | + dstPtr = &video.frameBuffer[120]; | |
| 984 | 970 | |
| 985 | 971 | for (uint32_t y = 0; y < 99; y++) |
| 986 | 972 | { |
| @@ -999,7 +985,7 @@ void renderMuteButtons(void) · 12 unmodified lines | ||
| 999 | 985 | if (editor.ui.diskOpScreenShown || editor.ui.posEdScreenShown) |
| 1000 | 986 | return; |
| 1001 | 987 | |
| 1002 | − dstPtr = &pixelBuffer[(3 * SCREEN_W) + 310]; | |
| 988 | + dstPtr = &video.frameBuffer[(3 * SCREEN_W) + 310]; | |
| 1003 | 989 | for (uint32_t i = 0; i < AMIGA_VOICES; i++) |
| 1004 | 990 | { |
| 1005 | 991 | if (editor.muted[i]) |
| @@ -1035,7 +1021,7 @@ void renderClearScreen(void) · 29 unmodified lines | ||
| 1035 | 1021 | editor.ui.disableVisualizer = true; |
| 1036 | 1022 | |
| 1037 | 1023 | srcPtr = clearDialogBMP; |
| 1038 | − dstPtr = &pixelBuffer[(51 * SCREEN_W) + 160]; | |
| 1024 | + dstPtr = &video.frameBuffer[(51 * SCREEN_W) + 160]; | |
| 1039 | 1025 | |
| 1040 | 1026 | for (uint32_t y = 0; y < 39; y++) |
| 1041 | 1027 | { |
| @@ -1085,7 +1071,7 @@ void updatePatternData(void) · 43 unmodified lines | ||
| 1085 | 1071 | { |
| 1086 | 1072 | editor.ui.updatePatternData = false; |
| 1087 | 1073 | if (!editor.ui.samplerScreenShown) |
| 1088 | − redrawPattern(pixelBuffer); | |
| 1074 | + redrawPattern(); | |
| 1089 | 1075 | } |
| 1090 | 1076 | } |
| 1091 | 1077 | |
| @@ -1096,13 +1082,13 @@ void removeTextEditMarker(void) · 4 unmodified lines | ||
| 1096 | 1082 | if (!editor.ui.editTextFlag) |
| 1097 | 1083 | return; |
| 1098 | 1084 | |
| 1099 | − dstPtr = &pixelBuffer[((editor.ui.lineCurY - 1) * SCREEN_W) + (editor.ui.lineCurX - 4)]; | |
| 1085 | + dstPtr = &video.frameBuffer[((editor.ui.lineCurY - 1) * SCREEN_W) + (editor.ui.lineCurX - 4)]; | |
| 1100 | 1086 | |
| 1101 | 1087 | if (editor.ui.editObject == PTB_PE_PATT) |
| 1102 | 1088 | { |
| 1103 | 1089 | // position editor text editing |
| 1104 | 1090 | |
| 1105 | − pixel = palette[PAL_GENBKG2]; | |
| 1091 | + pixel = video.palette[PAL_GENBKG2]; | |
| 1106 | 1092 | for (uint32_t x = 0; x < 7; x++) |
| 1107 | 1093 | dstPtr[x] = pixel; |
| 1108 | 1094 | |
| @@ -1114,7 +1100,7 @@ void removeTextEditMarker(void) · 5 unmodified lines | ||
| 1114 | 1100 | { |
| 1115 | 1101 | // all others |
| 1116 | 1102 | |
| 1117 | − pixel = palette[PAL_GENBKG]; | |
| 1103 | + pixel = video.palette[PAL_GENBKG]; | |
| 1118 | 1104 | for (uint32_t y = 0; y < 2; y++) |
| 1119 | 1105 | { |
| 1120 | 1106 | for (uint32_t x = 0; x < 7; x++) |
| @@ -1132,8 +1118,8 @@ void renderTextEditMarker(void) · 11 unmodified lines | ||
| 1132 | 1118 | if (!editor.ui.editTextFlag) |
| 1133 | 1119 | return; |
| 1134 | 1120 | |
| 1135 | − dstPtr = &pixelBuffer[((editor.ui.lineCurY - 1) * SCREEN_W) + (editor.ui.lineCurX - 4)]; | |
| 1136 | − pixel = palette[PAL_TEXTMARK]; | |
| 1121 | + dstPtr = &video.frameBuffer[((editor.ui.lineCurY - 1) * SCREEN_W) + (editor.ui.lineCurX - 4)]; | |
| 1122 | + pixel = video.palette[PAL_TEXTMARK]; | |
| 1137 | 1123 | |
| 1138 | 1124 | for (uint32_t y = 0; y < 2; y++) |
| 1139 | 1125 | { |
| @@ -1144,12 +1130,60 @@ void renderTextEditMarker(void) · 4 unmodified lines | ||
| 1144 | 1130 | } |
| 1145 | 1131 | } |
| 1146 | 1132 | |
| 1147 | −void updateDragBars(void) | |
| 1133 | +static void sendMouseButtonUpEvent(uint8_t button) | |
| 1148 | 1134 | { |
| 1149 | − if (editor.ui.sampleMarkingPos >= 0) samplerSamplePressed(MOUSE_BUTTON_HELD); | |
| 1150 | − if (editor.ui.forceSampleDrag) samplerBarPressed(MOUSE_BUTTON_HELD); | |
| 1151 | − if (editor.ui.forceSampleEdit) samplerEditSample(MOUSE_BUTTON_HELD); | |
| 1152 | − if (editor.ui.forceVolDrag) volBoxBarPressed(MOUSE_BUTTON_HELD); | |
| 1135 | + SDL_Event event; | |
| 1136 | + | |
| 1137 | + memset(&event, 0, sizeof (event)); | |
| 1138 | + | |
| 1139 | + event.type = SDL_MOUSEBUTTONUP; | |
| 1140 | + event.button.button = button; | |
| 1141 | + | |
| 1142 | + SDL_PushEvent(&event); | |
| 1143 | +} | |
| 1144 | + | |
| 1145 | +void handleLastGUIObjectDown(void) | |
| 1146 | +{ | |
| 1147 | + bool testMouseButtonRelease = false; | |
| 1148 | + | |
| 1149 | + if (editor.ui.sampleMarkingPos >= 0) | |
| 1150 | + { | |
| 1151 | + samplerSamplePressed(MOUSE_BUTTON_HELD); | |
| 1152 | + testMouseButtonRelease = true; | |
| 1153 | + } | |
| 1154 | + | |
| 1155 | + if (editor.ui.forceSampleDrag) | |
| 1156 | + { | |
| 1157 | + samplerBarPressed(MOUSE_BUTTON_HELD); | |
| 1158 | + testMouseButtonRelease = true; | |
| 1159 | + } | |
| 1160 | + | |
| 1161 | + if (editor.ui.forceSampleEdit) | |
| 1162 | + { | |
| 1163 | + samplerEditSample(MOUSE_BUTTON_HELD); | |
| 1164 | + testMouseButtonRelease = true; | |
| 1165 | + } | |
| 1166 | + | |
| 1167 | + if (editor.ui.forceVolDrag) | |
| 1168 | + { | |
| 1169 | + volBoxBarPressed(MOUSE_BUTTON_HELD); | |
| 1170 | + testMouseButtonRelease = true; | |
| 1171 | + } | |
| 1172 | + | |
| 1173 | + /* Hack to send "mouse button up" events if we released the mouse button(s) | |
| 1174 | + ** outside of the window... | |
| 1175 | + */ | |
| 1176 | + if (testMouseButtonRelease) | |
| 1177 | + { | |
| 1178 | + if (mouse.x < 0 || mouse.x >= SCREEN_W || mouse.y < 0 || mouse.y >= SCREEN_H) | |
| 1179 | + { | |
| 1180 | + if (mouse.leftButtonPressed && !(mouse.buttonState & SDL_BUTTON_LMASK)) | |
| 1181 | + sendMouseButtonUpEvent(SDL_BUTTON_LEFT); | |
| 1182 | + | |
| 1183 | + if (mouse.rightButtonPressed && !(mouse.buttonState & SDL_BUTTON_RMASK)) | |
| 1184 | + sendMouseButtonUpEvent(SDL_BUTTON_RIGHT); | |
| 1185 | + } | |
| 1186 | + } | |
| 1153 | 1187 | } |
| 1154 | 1188 | |
| 1155 | 1189 | void updateVisualizer(void) |
| @@ -1170,11 +1204,11 @@ void updateVisualizer(void) · 14 unmodified lines | ||
| 1170 | 1204 | { |
| 1171 | 1205 | // spectrum analyzer |
| 1172 | 1206 | |
| 1173 | − dstPtr = &pixelBuffer[(59 * SCREEN_W) + 129]; | |
| 1207 | + dstPtr = &video.frameBuffer[(59 * SCREEN_W) + 129]; | |
| 1174 | 1208 | for (uint32_t i = 0; i < SPECTRUM_BAR_NUM; i++) |
| 1175 | 1209 | { |
| 1176 | 1210 | srcPtr = spectrumAnaBMP; |
| 1177 | − pixel = palette[PAL_GENBKG]; | |
| 1211 | + pixel = video.palette[PAL_GENBKG]; | |
| 1178 | 1212 | |
| 1179 | 1213 | tmpVol = editor.spectrumVolumes[i]; |
| 1180 | 1214 | if (tmpVol > SPECTRUM_BAR_HEIGHT) |
| @@ -1206,7 +1240,7 @@ void renderQuadrascopeBg(void) · 25 unmodified lines | ||
| 1206 | 1240 | uint32_t *dstPtr; |
| 1207 | 1241 | |
| 1208 | 1242 | srcPtr = &trackerFrameBMP[(44 * SCREEN_W) + 120]; |
| 1209 | − dstPtr = &pixelBuffer[(44 * SCREEN_W) + 120]; | |
| 1243 | + dstPtr = &video.frameBuffer[(44 * SCREEN_W) + 120]; | |
| 1210 | 1244 | |
| 1211 | 1245 | for (uint32_t y = 0; y < 55; y++) |
| 1212 | 1246 | { |
| @@ -1226,7 +1260,7 @@ void renderSpectrumAnalyzerBg(void) · 13 unmodified lines | ||
| 1226 | 1260 | uint32_t *dstPtr; |
| 1227 | 1261 | |
| 1228 | 1262 | srcPtr = spectrumVisualsBMP; |
| 1229 | − dstPtr = &pixelBuffer[(44 * SCREEN_W) + 120]; | |
| 1263 | + dstPtr = &video.frameBuffer[(44 * SCREEN_W) + 120]; | |
| 1230 | 1264 | |
| 1231 | 1265 | for (uint32_t y = 0; y < 55; y++) |
| 1232 | 1266 | { |
| @@ -1247,7 +1281,7 @@ void renderAboutScreen(void) · 14 unmodified lines | ||
| 1247 | 1281 | return; |
| 1248 | 1282 | |
| 1249 | 1283 | srcPtr = aboutScreenBMP; |
| 1250 | − dstPtr = &pixelBuffer[(44 * SCREEN_W) + 120]; | |
| 1284 | + dstPtr = &video.frameBuffer[(44 * SCREEN_W) + 120]; | |
| 1251 | 1285 | |
| 1252 | 1286 | for (uint32_t y = 0; y < 55; y++) |
| 1253 | 1287 | { |
| @@ -1261,7 +1295,7 @@ void renderAboutScreen(void) · 7 unmodified lines | ||
| 1261 | 1295 | |
| 1262 | 1296 | sprintf(verString, "v%s", PROG_VER_STR); |
| 1263 | 1297 | verStringX = 260 + (((63 - ((uint32_t)strlen(verString) * (FONT_CHAR_W - 1))) + 1) / 2); |
| 1264 | − textOutTight(pixelBuffer, verStringX, 67, verString, palette[PAL_GENBKG2]); | |
| 1298 | + textOutTight(verStringX, 67, verString, video.palette[PAL_GENBKG2]); | |
| 1265 | 1299 | } |
| 1266 | 1300 | |
| 1267 | 1301 | void renderEditOpMode(void) |
| @@ -1297,7 +1331,7 @@ void renderEditOpMode(void) · 29 unmodified lines | ||
| 1297 | 1331 | |
| 1298 | 1332 | // render it... |
| 1299 | 1333 | |
| 1300 | − dstPtr = &pixelBuffer[(47 * SCREEN_W) + 310]; | |
| 1334 | + dstPtr = &video.frameBuffer[(47 * SCREEN_W) + 310]; | |
| 1301 | 1335 | for (uint32_t y = 0; y < 6; y++) |
| 1302 | 1336 | { |
| 1303 | 1337 | for (uint32_t x = 0; x < 7; x++) |
| @@ -1324,7 +1358,7 @@ void renderEditOpScreen(void) · 20 unmodified lines | ||
| 1324 | 1358 | } |
| 1325 | 1359 | |
| 1326 | 1360 | // render background |
| 1327 | − dstPtr = &pixelBuffer[(44 * SCREEN_W) + 120]; | |
| 1361 | + dstPtr = &video.frameBuffer[(44 * SCREEN_W) + 120]; | |
| 1328 | 1362 | for (uint32_t y = 0; y < 55; y++) |
| 1329 | 1363 | { |
| 1330 | 1364 | memcpy(dstPtr, srcPtr, 200 * sizeof (int32_t)); |
| @@ -1338,11 +1372,11 @@ void renderEditOpScreen(void) · 7 unmodified lines | ||
| 1338 | 1372 | // render text and content |
| 1339 | 1373 | if (editor.ui.editOpScreen == 0) |
| 1340 | 1374 | { |
| 1341 | − textOut(pixelBuffer, 128, 47, " TRACK PATTERN ", palette[PAL_GENTXT]); | |
| 1375 | + textOut(128, 47, " TRACK PATTERN ", video.palette[PAL_GENTXT]); | |
| 1342 | 1376 | } |
| 1343 | 1377 | else if (editor.ui.editOpScreen == 1) |
| 1344 | 1378 | { |
| 1345 | − textOut(pixelBuffer, 128, 47, " RECORD SAMPLES ", palette[PAL_GENTXT]); | |
| 1379 | + textOut(128, 47, " RECORD SAMPLES ", video.palette[PAL_GENTXT]); | |
| 1346 | 1380 | |
| 1347 | 1381 | editor.ui.updateRecordText = true; |
| 1348 | 1382 | editor.ui.updateQuantizeText = true; |
| @@ -1354,8 +1388,8 @@ void renderEditOpScreen(void) · 5 unmodified lines | ||
| 1354 | 1388 | } |
| 1355 | 1389 | else if (editor.ui.editOpScreen == 2) |
| 1356 | 1390 | { |
| 1357 | − textOut(pixelBuffer, 128, 47, " SAMPLE EDITOR ", palette[PAL_GENTXT]); | |
| 1358 | − charOut(pixelBuffer, 272, 91, '%', palette[PAL_GENTXT]); // for Volume text | |
| 1391 | + textOut(128, 47, " SAMPLE EDITOR ", video.palette[PAL_GENTXT]); | |
| 1392 | + charOut(272, 91, '%', video.palette[PAL_GENTXT]); // for Volume text | |
| 1359 | 1393 | |
| 1360 | 1394 | editor.ui.updatePosText = true; |
| 1361 | 1395 | editor.ui.updateModText = true; |
| @@ -1363,7 +1397,7 @@ void renderEditOpScreen(void) · 1 unmodified line | ||
| 1363 | 1397 | } |
| 1364 | 1398 | else if (editor.ui.editOpScreen == 3) |
| 1365 | 1399 | { |
| 1366 | − textOut(pixelBuffer, 128, 47, " SAMPLE CHORD EDITOR ", palette[PAL_GENTXT]); | |
| 1400 | + textOut(128, 47, " SAMPLE CHORD EDITOR ", video.palette[PAL_GENTXT]); | |
| 1367 | 1401 | |
| 1368 | 1402 | editor.ui.updateLengthText = true; |
| 1369 | 1403 | editor.ui.updateNote1Text = true; |
| @@ -1379,7 +1413,7 @@ void renderMOD2WAVDialog(void) · 9 unmodified lines | ||
| 1379 | 1413 | uint32_t *dstPtr; |
| 1380 | 1414 | |
| 1381 | 1415 | srcPtr = mod2wavBMP; |
| 1382 | − dstPtr = &pixelBuffer[(27 * SCREEN_W) + 64]; | |
| 1416 | + dstPtr = &video.frameBuffer[(27 * SCREEN_W) + 64]; | |
| 1383 | 1417 | |
| 1384 | 1418 | for (uint32_t y = 0; y < 48; y++) |
| 1385 | 1419 | { |
| @@ -1431,9 +1465,9 @@ void updateMOD2WAVDialog(void) · 45 unmodified lines | ||
| 1431 | 1465 | percent = 100; |
| 1432 | 1466 | |
| 1433 | 1467 | barLength = ((percent * 180) + 50) / 100; |
| 1434 | − dstPtr = &pixelBuffer[(42 * SCREEN_W) + 70]; | |
| 1435 | − pixel = palette[PAL_GENBKG2]; | |
| 1436 | − bgPixel = palette[PAL_BORDER]; | |
| 1468 | + dstPtr = &video.frameBuffer[(42 * SCREEN_W) + 70]; | |
| 1469 | + pixel = video.palette[PAL_GENBKG2]; | |
| 1470 | + bgPixel = video.palette[PAL_BORDER]; | |
| 1437 | 1471 | |
| 1438 | 1472 | for (int32_t y = 0; y < 11; y++) |
| 1439 | 1473 | { |
| @@ -1450,13 +1484,13 @@ void updateMOD2WAVDialog(void) · 10 unmodified lines | ||
| 1450 | 1484 | } |
| 1451 | 1485 | |
| 1452 | 1486 | // render percentage |
| 1453 | − pixel = palette[PAL_GENTXT]; | |
| 1487 | + pixel = video.palette[PAL_GENTXT]; | |
| 1454 | 1488 | if (percent > 99) |
| 1455 | − printThreeDecimals(pixelBuffer, 144, 45, percent, pixel); | |
| 1489 | + printThreeDecimals(144, 45, percent, pixel); | |
| 1456 | 1490 | else |
| 1457 | − printTwoDecimals(pixelBuffer, 152, 45, percent, pixel); | |
| 1491 | + printTwoDecimals(152, 45, percent, pixel); | |
| 1458 | 1492 | |
| 1459 | − charOut(pixelBuffer, 168, 45, '%', pixel); | |
| 1493 | + charOut(168, 45, '%', pixel); | |
| 1460 | 1494 | } |
| 1461 | 1495 | } |
| 1462 | 1496 | } |
| @@ -1471,44 +1505,43 @@ void updateEditOp(void) · 8 unmodified lines | ||
| 1471 | 1505 | if (editor.ui.updateRecordText) |
| 1472 | 1506 | { |
| 1473 | 1507 | editor.ui.updateRecordText = false; |
| 1474 | − textOutBg(pixelBuffer, 176, 58, (editor.recordMode == RECORD_PATT) ? "PATT" : "SONG", | |
| 1475 | − palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1508 | + textOutBg(176, 58, (editor.recordMode == RECORD_PATT) ? "PATT" : "SONG", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1476 | 1509 | } |
| 1477 | 1510 | |
| 1478 | 1511 | if (editor.ui.updateQuantizeText) |
| 1479 | 1512 | { |
| 1480 | 1513 | editor.ui.updateQuantizeText = false; |
| 1481 | − printTwoDecimalsBg(pixelBuffer, 192, 69, *editor.quantizeValueDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1514 | + printTwoDecimalsBg(192, 69, *editor.quantizeValueDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1482 | 1515 | } |
| 1483 | 1516 | |
| 1484 | 1517 | if (editor.ui.updateMetro1Text) |
| 1485 | 1518 | { |
| 1486 | 1519 | editor.ui.updateMetro1Text = false; |
| 1487 | − printTwoDecimalsBg(pixelBuffer, 168, 80, *editor.metroSpeedDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1520 | + printTwoDecimalsBg(168, 80, *editor.metroSpeedDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1488 | 1521 | } |
| 1489 | 1522 | |
| 1490 | 1523 | if (editor.ui.updateMetro2Text) |
| 1491 | 1524 | { |
| 1492 | 1525 | editor.ui.updateMetro2Text = false; |
| 1493 | − printTwoDecimalsBg(pixelBuffer, 192, 80, *editor.metroChannelDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1526 | + printTwoDecimalsBg(192, 80, *editor.metroChannelDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1494 | 1527 | } |
| 1495 | 1528 | |
| 1496 | 1529 | if (editor.ui.updateFromText) |
| 1497 | 1530 | { |
| 1498 | 1531 | editor.ui.updateFromText = false; |
| 1499 | − printTwoHexBg(pixelBuffer, 264, 80, *editor.sampleFromDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1532 | + printTwoHexBg(264, 80, *editor.sampleFromDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1500 | 1533 | } |
| 1501 | 1534 | |
| 1502 | 1535 | if (editor.ui.updateKeysText) |
| 1503 | 1536 | { |
| 1504 | 1537 | editor.ui.updateKeysText = false; |
| 1505 | − textOutBg(pixelBuffer, 160, 91, editor.multiFlag ? "MULTI " : "SINGLE", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1538 | + textOutBg(160, 91, editor.multiFlag ? "MULTI " : "SINGLE", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1506 | 1539 | } |
| 1507 | 1540 | |
| 1508 | 1541 | if (editor.ui.updateToText) |
| 1509 | 1542 | { |
| 1510 | 1543 | editor.ui.updateToText = false; |
| 1511 | − printTwoHexBg(pixelBuffer, 264, 91, *editor.sampleToDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1544 | + printTwoHexBg(264, 91, *editor.sampleToDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1512 | 1545 | } |
| 1513 | 1546 | } |
| 1514 | 1547 | else if (editor.ui.editOpScreen == 2) |
| @@ -1518,38 +1551,38 @@ void updateEditOp(void) · 3 unmodified lines | ||
| 1518 | 1551 | editor.ui.updateMixText = false; |
| 1519 | 1552 | if (editor.mixFlag) |
| 1520 | 1553 | { |
| 1521 | − textOutBg(pixelBuffer, 128, 47, editor.mixText, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1522 | − textOutBg(pixelBuffer, 248, 47, " ", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1554 | + textOutBg(128, 47, editor.mixText, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1555 | + textOutBg(248, 47, " ", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1523 | 1556 | } |
| 1524 | 1557 | else |
| 1525 | 1558 | { |
| 1526 | − textOutBg(pixelBuffer, 128, 47, " SAMPLE EDITOR ", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1559 | + textOutBg(128, 47, " SAMPLE EDITOR ", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1527 | 1560 | } |
| 1528 | 1561 | } |
| 1529 | 1562 | |
| 1530 | 1563 | if (editor.ui.updatePosText) |
| 1531 | 1564 | { |
| 1532 | 1565 | editor.ui.updatePosText = false; |
| 1533 | − printFourHexBg(pixelBuffer, 248, 58, *editor.samplePosDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1566 | + printFourHexBg(248, 58, *editor.samplePosDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1534 | 1567 | } |
| 1535 | 1568 | |
| 1536 | 1569 | if (editor.ui.updateModText) |
| 1537 | 1570 | { |
| 1538 | 1571 | editor.ui.updateModText = false; |
| 1539 | − printThreeDecimalsBg(pixelBuffer, 256, 69, | |
| 1572 | + printThreeDecimalsBg(256, 69, | |
| 1540 | 1573 | (editor.modulateSpeed < 0) ? (0 - editor.modulateSpeed) : editor.modulateSpeed, |
| 1541 | − palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1574 | + video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1542 | 1575 | |
| 1543 | 1576 | if (editor.modulateSpeed < 0) |
| 1544 | − charOutBg(pixelBuffer, 248, 69, '-', palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1577 | + charOutBg(248, 69, '-', video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1545 | 1578 | else |
| 1546 | − charOutBg(pixelBuffer, 248, 69, ' ', palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1579 | + charOutBg(248, 69, ' ', video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1547 | 1580 | } |
| 1548 | 1581 | |
| 1549 | 1582 | if (editor.ui.updateVolText) |
| 1550 | 1583 | { |
| 1551 | 1584 | editor.ui.updateVolText = false; |
| 1552 | − printThreeDecimalsBg(pixelBuffer, 248, 91, *editor.sampleVolDisp, palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1585 | + printThreeDecimalsBg(248, 91, *editor.sampleVolDisp, video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1553 | 1586 | } |
| 1554 | 1587 | } |
| 1555 | 1588 | else if (editor.ui.editOpScreen == 3) |
| @@ -1559,17 +1592,17 @@ void updateEditOp(void) · 3 unmodified lines | ||
| 1559 | 1592 | editor.ui.updateLengthText = false; |
| 1560 | 1593 | |
| 1561 | 1594 | // clear background |
| 1562 | − textOutBg(pixelBuffer, 168, 91, " ", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1563 | − charOut(pixelBuffer, 198, 91, ':', palette[PAL_GENBKG]); | |
| 1595 | + textOutBg(168, 91, " ", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1596 | + charOut(198, 91, ':', video.palette[PAL_GENBKG]); | |
| 1564 | 1597 | |
| 1565 | 1598 | if (modEntry->samples[editor.currSample].loopLength > 2 || modEntry->samples[editor.currSample].loopStart >= 2) |
| 1566 | 1599 | { |
| 1567 | − textOut(pixelBuffer, 168, 91, "LOOP", palette[PAL_GENTXT]); | |
| 1600 | + textOut(168, 91, "LOOP", video.palette[PAL_GENTXT]); | |
| 1568 | 1601 | } |
| 1569 | 1602 | else |
| 1570 | 1603 | { |
| 1571 | − printFourHex(pixelBuffer, 168, 91, *editor.chordLengthDisp, palette[PAL_GENTXT]); // CHORD MAX LENGTH | |
| 1572 | − charOut(pixelBuffer, 198, 91, (editor.chordLengthMin) ? '.' : ':', palette[PAL_GENTXT]); // MIN/MAX FLAG | |
| 1604 | + printFourHex(168, 91, *editor.chordLengthDisp, video.palette[PAL_GENTXT]); // chord max length | |
| 1605 | + charOut(198, 91, (editor.chordLengthMin) ? '.' : ':', video.palette[PAL_GENTXT]); // min/max flag | |
| 1573 | 1606 | } |
| 1574 | 1607 | } |
| 1575 | 1608 | |
| @@ -1577,40 +1610,40 @@ void updateEditOp(void) · 1 unmodified line | ||
| 1577 | 1610 | { |
| 1578 | 1611 | editor.ui.updateNote1Text = false; |
| 1579 | 1612 | if (editor.note1 > 35) |
| 1580 | − textOutBg(pixelBuffer, 256, 58, "---", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1613 | + textOutBg(256, 58, "---", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1581 | 1614 | else |
| 1582 | − textOutBg(pixelBuffer, 256, 58, ptConfig.accidental ? noteNames2[editor.note1] : noteNames1[editor.note1], | |
| 1583 | − palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1615 | + textOutBg(256, 58, config.accidental ? noteNames2[editor.note1] : noteNames1[editor.note1], | |
| 1616 | + video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1584 | 1617 | } |
| 1585 | 1618 | |
| 1586 | 1619 | if (editor.ui.updateNote2Text) |
| 1587 | 1620 | { |
| 1588 | 1621 | editor.ui.updateNote2Text = false; |
| 1589 | 1622 | if (editor.note2 > 35) |
| 1590 | − textOutBg(pixelBuffer, 256, 69, "---", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1623 | + textOutBg(256, 69, "---", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1591 | 1624 | else |
| 1592 | − textOutBg(pixelBuffer, 256, 69, ptConfig.accidental ? noteNames2[editor.note2] : noteNames1[editor.note2], | |
| 1593 | − palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1625 | + textOutBg(256, 69, config.accidental ? noteNames2[editor.note2] : noteNames1[editor.note2], | |
| 1626 | + video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1594 | 1627 | } |
| 1595 | 1628 | |
| 1596 | 1629 | if (editor.ui.updateNote3Text) |
| 1597 | 1630 | { |
| 1598 | 1631 | editor.ui.updateNote3Text = false; |
| 1599 | 1632 | if (editor.note3 > 35) |
| 1600 | − textOutBg(pixelBuffer, 256, 80, "---", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1633 | + textOutBg(256, 80, "---", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1601 | 1634 | else |
| 1602 | − textOutBg(pixelBuffer, 256, 80, ptConfig.accidental ? noteNames2[editor.note3] : noteNames1[editor.note3], | |
| 1603 | − palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1635 | + textOutBg(256, 80, config.accidental ? noteNames2[editor.note3] : noteNames1[editor.note3], | |
| 1636 | + video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1604 | 1637 | } |
| 1605 | 1638 | |
| 1606 | 1639 | if (editor.ui.updateNote4Text) |
| 1607 | 1640 | { |
| 1608 | 1641 | editor.ui.updateNote4Text = false; |
| 1609 | 1642 | if (editor.note4 > 35) |
| 1610 | − textOutBg(pixelBuffer, 256, 91, "---", palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1643 | + textOutBg(256, 91, "---", video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1611 | 1644 | else |
| 1612 | − textOutBg(pixelBuffer, 256, 91, ptConfig.accidental ? noteNames2[editor.note4] : noteNames1[editor.note4], | |
| 1613 | − palette[PAL_GENTXT], palette[PAL_GENBKG]); | |
| 1645 | + textOutBg(256, 91, config.accidental ? noteNames2[editor.note4] : noteNames1[editor.note4], | |
| 1646 | + video.palette[PAL_GENTXT], video.palette[PAL_GENBKG]); | |
| 1614 | 1647 | } |
| 1615 | 1648 | } |
| 1616 | 1649 | } |
| @@ -1640,14 +1673,14 @@ void displayMainScreen(void) · 23 unmodified lines | ||
| 1640 | 1673 | if (editor.ui.samplerScreenShown) |
| 1641 | 1674 | { |
| 1642 | 1675 | if (!editor.ui.diskOpScreenShown) |
| 1643 | − memcpy(pixelBuffer, trackerFrameBMP, 320 * 121 * sizeof (int32_t)); | |
| 1676 | + memcpy(video.frameBuffer, trackerFrameBMP, 320 * 121 * sizeof (int32_t)); | |
| 1644 | 1677 | } |
| 1645 | 1678 | else |
| 1646 | 1679 | { |
| 1647 | 1680 | if (!editor.ui.diskOpScreenShown) |
| 1648 | − memcpy(pixelBuffer, trackerFrameBMP, 320 * 255 * sizeof (int32_t)); | |
| 1681 | + memcpy(video.frameBuffer, trackerFrameBMP, 320 * 255 * sizeof (int32_t)); | |
| 1649 | 1682 | else |
| 1650 | − memcpy(&pixelBuffer[121 * SCREEN_W], &trackerFrameBMP[121 * SCREEN_W], 320 * 134 * sizeof (int32_t)); | |
| 1683 | + memcpy(&video.frameBuffer[121 * SCREEN_W], &trackerFrameBMP[121 * SCREEN_W], 320 * 134 * sizeof (int32_t)); | |
| 1651 | 1684 | |
| 1652 | 1685 | editor.ui.updateSongBPM = true; |
| 1653 | 1686 | editor.ui.updateCurrPattText = true; |
| @@ -1665,14 +1698,14 @@ void displayMainScreen(void) · 11 unmodified lines | ||
| 1665 | 1698 | editor.ui.updateSongLength = true; |
| 1666 | 1699 | |
| 1667 | 1700 | // zeroes (can't integrate zeroes in the graphics, the palette entry is above the 2-bit range) |
| 1668 | − charOut(pixelBuffer, 64, 3, '0', palette[PAL_GENTXT]); | |
| 1669 | − textOut(pixelBuffer, 64, 14, "00", palette[PAL_GENTXT]); | |
| 1701 | + charOut(64, 3, '0', video.palette[PAL_GENTXT]); | |
| 1702 | + textOut(64, 14, "00", video.palette[PAL_GENTXT]); | |
| 1670 | 1703 | |
| 1671 | 1704 | if (!editor.isWAVRendering) |
| 1672 | 1705 | { |
| 1673 | − charOut(pixelBuffer, 64, 25, '0', palette[PAL_GENTXT]); | |
| 1674 | − textOut(pixelBuffer, 64, 47, "00", palette[PAL_GENTXT]); | |
| 1675 | − textOut(pixelBuffer, 64, 58, "00", palette[PAL_GENTXT]); | |
| 1706 | + charOut(64, 25, '0', video.palette[PAL_GENTXT]); | |
| 1707 | + textOut(64, 47, "00", video.palette[PAL_GENTXT]); | |
| 1708 | + textOut(64, 58, "00", video.palette[PAL_GENTXT]); | |
| 1676 | 1709 | } |
| 1677 | 1710 | |
| 1678 | 1711 | if (editor.ui.posEdScreenShown) |
| @@ -2167,7 +2200,7 @@ void createBitmaps(void) · 488 unmodified lines | ||
| 2167 | 2200 | uint16_t pixel12; |
| 2168 | 2201 | uint32_t i, j, x, y, pixel24; |
| 2169 | 2202 | |
| 2170 | − pixel24 = palette[PAL_PATCURSOR]; | |
| 2203 | + pixel24 = video.palette[PAL_PATCURSOR]; | |
| 2171 | 2204 | for (y = 0; y < 14; y++) |
| 2172 | 2205 | { |
| 2173 | 2206 | // top two rows have a lighter color |
| @@ -2202,7 +2235,7 @@ void createBitmaps(void) · 28 unmodified lines | ||
| 2202 | 2235 | patternCursorBMP[(y * 11) + 0] = pixel24; |
| 2203 | 2236 | |
| 2204 | 2237 | for (x = 1; x < 10; x++) |
| 2205 | − patternCursorBMP[(y * 11) + x] = palette[PAL_COLORKEY]; | |
| 2238 | + patternCursorBMP[(y * 11) + x] = video.palette[PAL_COLORKEY]; | |
| 2206 | 2239 | |
| 2207 | 2240 | patternCursorBMP[(y * 11) + 10] = pixel24; |
| 2208 | 2241 | } |
| @@ -2299,7 +2332,7 @@ void createBitmaps(void) · 90 unmodified lines | ||
| 2299 | 2332 | vuMeterBMP[(i * 10) + 9] = pixel24; |
| 2300 | 2333 | } |
| 2301 | 2334 | |
| 2302 | − for (i = 0; i < 30; i++) arrowBMP[i] = palette[arrowPaletteBMP[i]]; | |
| 2335 | + for (i = 0; i < 30; i++) arrowBMP[i] = video.palette[arrowPaletteBMP[i]]; | |
| 2303 | 2336 | for (i = 0; i < 64; i++) samplingPosBMP[i] = samplingPosBMP[i]; |
| 2304 | 2337 | for (i = 0; i < 512; i++) loopPinsBMP[i] = loopPinsBMP[i]; |
| 2305 | 2338 | } |
| @@ -2379,19 +2412,19 @@ uint32_t *unpackBMP(const uint8_t *src, uint32_t packedLen) · 73 unmodified lines | ||
| 2379 | 2412 | { |
| 2380 | 2413 | byteIn = (tmpBuffer[i] & 0xC0) >> 6; |
| 2381 | 2414 | assert(byteIn < PALETTE_NUM); |
| 2382 | − dst[(i * 4) + 0] = palette[byteIn]; | |
| 2415 | + dst[(i * 4) + 0] = video.palette[byteIn]; | |
| 2383 | 2416 | |
| 2384 | 2417 | byteIn = (tmpBuffer[i] & 0x30) >> 4; |
| 2385 | 2418 | assert(byteIn < PALETTE_NUM); |
| 2386 | − dst[(i * 4) + 1] = palette[byteIn]; | |
| 2419 | + dst[(i * 4) + 1] = video.palette[byteIn]; | |
| 2387 | 2420 | |
| 2388 | 2421 | byteIn = (tmpBuffer[i] & 0x0C) >> 2; |
| 2389 | 2422 | assert(byteIn < PALETTE_NUM); |
| 2390 | − dst[(i * 4) + 2] = palette[byteIn]; | |
| 2423 | + dst[(i * 4) + 2] = video.palette[byteIn]; | |
| 2391 | 2424 | |
| 2392 | 2425 | byteIn = (tmpBuffer[i] & 0x03) >> 0; |
| 2393 | 2426 | assert(byteIn < PALETTE_NUM); |
| 2394 | − dst[(i * 4) + 3] = palette[byteIn]; | |
| 2427 | + dst[(i * 4) + 3] = video.palette[byteIn]; | |
| 2395 | 2428 | } |
| 2396 | 2429 | |
| 2397 | 2430 | free(tmpBuffer); |
| @@ -2440,10 +2473,10 @@ bool unpackBMPs(void) · 42 unmodified lines | ||
| 2440 | 2473 | |
| 2441 | 2474 | void videoClose(void) |
| 2442 | 2475 | { |
| 2443 | − SDL_DestroyTexture(texture); | |
| 2444 | − SDL_DestroyRenderer(renderer); | |
| 2445 | − SDL_DestroyWindow(window); | |
| 2446 | − free(pixelBuffer); | |
| 2476 | + SDL_DestroyTexture(video.texture); | |
| 2477 | + SDL_DestroyRenderer(video.renderer); | |
| 2478 | + SDL_DestroyWindow(video.window); | |
| 2479 | + free(video.frameBufferUnaligned); | |
| 2447 | 2480 | } |
| 2448 | 2481 | |
| 2449 | 2482 | void setupSprites(void) |
| @@ -2459,28 +2492,28 @@ void setupSprites(void) · 9 unmodified lines | ||
| 2459 | 2492 | |
| 2460 | 2493 | sprites[SPRITE_PATTERN_CURSOR].data = patternCursorBMP; |
| 2461 | 2494 | sprites[SPRITE_PATTERN_CURSOR].pixelType = SPRITE_TYPE_RGB; |
| 2462 | − sprites[SPRITE_PATTERN_CURSOR].colorKey = palette[PAL_COLORKEY]; | |
| 2495 | + sprites[SPRITE_PATTERN_CURSOR].colorKey = video.palette[PAL_COLORKEY]; | |
| 2463 | 2496 | sprites[SPRITE_PATTERN_CURSOR].w = 11; |
| 2464 | 2497 | sprites[SPRITE_PATTERN_CURSOR].h = 14; |
| 2465 | 2498 | hideSprite(SPRITE_PATTERN_CURSOR); |
| 2466 | 2499 | |
| 2467 | 2500 | sprites[SPRITE_LOOP_PIN_LEFT].data = loopPinsBMP; |
| 2468 | 2501 | sprites[SPRITE_LOOP_PIN_LEFT].pixelType = SPRITE_TYPE_RGB; |
| 2469 | − sprites[SPRITE_LOOP_PIN_LEFT].colorKey = palette[PAL_COLORKEY]; | |
| 2502 | + sprites[SPRITE_LOOP_PIN_LEFT].colorKey = video.palette[PAL_COLORKEY]; | |
| 2470 | 2503 | sprites[SPRITE_LOOP_PIN_LEFT].w = 4; |
| 2471 | 2504 | sprites[SPRITE_LOOP_PIN_LEFT].h = 64; |
| 2472 | 2505 | hideSprite(SPRITE_LOOP_PIN_LEFT); |
| 2473 | 2506 | |
| 2474 | 2507 | sprites[SPRITE_LOOP_PIN_RIGHT].data = &loopPinsBMP[4 * 64]; |
| 2475 | 2508 | sprites[SPRITE_LOOP_PIN_RIGHT].pixelType = SPRITE_TYPE_RGB; |
| 2476 | − sprites[SPRITE_LOOP_PIN_RIGHT].colorKey = palette[PAL_COLORKEY]; | |
| 2509 | + sprites[SPRITE_LOOP_PIN_RIGHT].colorKey = video.palette[PAL_COLORKEY]; | |
| 2477 | 2510 | sprites[SPRITE_LOOP_PIN_RIGHT].w = 4; |
| 2478 | 2511 | sprites[SPRITE_LOOP_PIN_RIGHT].h = 64; |
| 2479 | 2512 | hideSprite(SPRITE_LOOP_PIN_RIGHT); |
| 2480 | 2513 | |
| 2481 | 2514 | sprites[SPRITE_SAMPLING_POS_LINE].data = samplingPosBMP; |
| 2482 | 2515 | sprites[SPRITE_SAMPLING_POS_LINE].pixelType = SPRITE_TYPE_RGB; |
| 2483 | − sprites[SPRITE_SAMPLING_POS_LINE].colorKey = palette[PAL_COLORKEY]; | |
| 2516 | + sprites[SPRITE_SAMPLING_POS_LINE].colorKey = video.palette[PAL_COLORKEY]; | |
| 2484 | 2517 | sprites[SPRITE_SAMPLING_POS_LINE].w = 1; |
| 2485 | 2518 | sprites[SPRITE_SAMPLING_POS_LINE].h = 64; |
| 2486 | 2519 | hideSprite(SPRITE_SAMPLING_POS_LINE); |
| @@ -2509,7 +2542,7 @@ void hideSprite(uint8_t sprite) · 22 unmodified lines | ||
| 2509 | 2542 | |
| 2510 | 2543 | void eraseSprites(void) |
| 2511 | 2544 | { |
| 2512 | − int32_t sw, sh, srcPitch, dstPitch; | |
| 2545 | + int32_t sx, sy, x, y, sw, sh, srcPitch, dstPitch; | |
| 2513 | 2546 | const uint32_t *src32; |
| 2514 | 2547 | uint32_t *dst32; |
| 2515 | 2548 | sprite_t *s; |
| @@ -2517,26 +2550,43 @@ void eraseSprites(void) · 1 unmodified line | ||
| 2517 | 2550 | for (int32_t i = SPRITE_NUM-1; i >= 0; i--) // erasing must be done in reverse order |
| 2518 | 2551 | { |
| 2519 | 2552 | s = &sprites[i]; |
| 2520 | − if (s->x >= SCREEN_W) // sprite is hidden, don't erase | |
| 2553 | + if (s->x >= SCREEN_W || s->y >= SCREEN_H) // sprite is hidden, don't draw nor fill clear buffer | |
| 2521 | 2554 | continue; |
| 2522 | 2555 | |
| 2523 | − assert(s->x >= 0 && s->y >= 0 && s->refreshBuffer != NULL); | |
| 2556 | + assert(s->refreshBuffer != NULL); | |
| 2524 | 2557 | |
| 2525 | 2558 | sw = s->w; |
| 2526 | 2559 | sh = s->h; |
| 2527 | − dst32 = &pixelBuffer[(s->y * SCREEN_W) + s->x]; | |
| 2560 | + sx = s->x; | |
| 2561 | + sy = s->y; | |
| 2562 | + | |
| 2563 | + // if x is negative, adjust variables | |
| 2564 | + if (sx < 0) | |
| 2565 | + { | |
| 2566 | + sw += sx; // subtraction | |
| 2567 | + sx = 0; | |
| 2568 | + } | |
| 2569 | + | |
| 2570 | + // if y is negative, adjust variables | |
| 2571 | + if (sy < 0) | |
| 2572 | + { | |
| 2573 | + sh += sy; // subtraction | |
| 2574 | + sy = 0; | |
| 2575 | + } | |
| 2576 | + | |
| 2577 | + dst32 = &video.frameBuffer[(sy * SCREEN_W) + sx]; | |
| 2528 | 2578 | src32 = s->refreshBuffer; |
| 2529 | 2579 | |
| 2530 | − // handle xy clipping | |
| 2531 | − if (s->y+sh >= SCREEN_H) sh = SCREEN_H - s->y; | |
| 2532 | − if (s->x+sw >= SCREEN_W) sw = SCREEN_W - s->x; | |
| 2580 | + // handle x/y clipping | |
| 2581 | + if (sx+sw >= SCREEN_W) sw = SCREEN_W - sx; | |
| 2582 | + if (sy+sh >= SCREEN_H) sh = SCREEN_H - sy; | |
| 2533 | 2583 | |
| 2534 | 2584 | srcPitch = s->w - sw; |
| 2535 | 2585 | dstPitch = SCREEN_W - sw; |
| 2536 | 2586 | |
| 2537 | − for (int32_t y = 0; y < sh; y++) | |
| 2587 | + for (y = 0; y < sh; y++) | |
| 2538 | 2588 | { |
| 2539 | − for (int32_t x = 0; x < sw; x++) | |
| 2589 | + for (x = 0; x < sw; x++) | |
| 2540 | 2590 | *dst32++ = *src32++; |
| 2541 | 2591 | |
| 2542 | 2592 | src32 += srcPitch; |
| @@ -2550,10 +2600,9 @@ void eraseSprites(void) · 7 unmodified lines | ||
| 2550 | 2600 | void renderSprites(void) |
| 2551 | 2601 | { |
| 2552 | 2602 | const uint8_t *src8; |
| 2553 | − int32_t x, y, sw, sh, srcPitch, dstPitch; | |
| 2603 | + int32_t sx, sy, x, y, srcPtrBias, sw, sh, srcPitch, dstPitch; | |
| 2554 | 2604 | const uint32_t *src32; |
| 2555 | − uint32_t *dst32, *clr32; | |
| 2556 | − register uint32_t colorKey; | |
| 2605 | + uint32_t *dst32, *clr32, colorKey; | |
| 2557 | 2606 | sprite_t *s; |
| 2558 | 2607 | |
| 2559 | 2608 | renderVuMeters(); // let's put it here even though it's not sprite-based |
| @@ -2566,19 +2615,39 @@ void renderSprites(void) · 6 unmodified lines | ||
| 2566 | 2615 | s->x = s->newX; |
| 2567 | 2616 | s->y = s->newY; |
| 2568 | 2617 | |
| 2569 | − if (s->x >= SCREEN_W) // sprite is hidden, don't draw nor fill clear buffer | |
| 2618 | + if (s->x >= SCREEN_W || s->y >= SCREEN_H) // sprite is hidden, don't draw nor fill clear buffer | |
| 2570 | 2619 | continue; |
| 2571 | 2620 | |
| 2572 | − assert(s->x >= 0 && s->y >= 0 && s->data != NULL && s->refreshBuffer != NULL); | |
| 2621 | + assert(s->data != NULL && s->refreshBuffer != NULL); | |
| 2573 | 2622 | |
| 2574 | 2623 | sw = s->w; |
| 2575 | 2624 | sh = s->h; |
| 2576 | − dst32 = &pixelBuffer[(s->y * SCREEN_W) + s->x]; | |
| 2625 | + sx = s->x; | |
| 2626 | + sy = s->y; | |
| 2627 | + srcPtrBias = 0; | |
| 2628 | + | |
| 2629 | + // if x is negative, adjust variables | |
| 2630 | + if (sx < 0) | |
| 2631 | + { | |
| 2632 | + sw += sx; // subtraction | |
| 2633 | + srcPtrBias += -sx; | |
| 2634 | + sx = 0; | |
| 2635 | + } | |
| 2636 | + | |
| 2637 | + // if y is negative, adjust variables | |
| 2638 | + if (sy < 0) | |
| 2639 | + { | |
| 2640 | + sh += sy; // subtraction | |
| 2641 | + srcPtrBias += (-sy * s->w); | |
| 2642 | + sy = 0; | |
| 2643 | + } | |
| 2644 | + | |
| 2645 | + dst32 = &video.frameBuffer[(sy * SCREEN_W) + sx]; | |
| 2577 | 2646 | clr32 = s->refreshBuffer; |
| 2578 | 2647 | |
| 2579 | − // handle xy clipping | |
| 2580 | − if (s->y+sh >= SCREEN_H) sh = SCREEN_H - s->y; | |
| 2581 | − if (s->x+sw >= SCREEN_W) sw = SCREEN_W - s->x; | |
| 2648 | + // handle x/y clipping | |
| 2649 | + if (sx+sw >= SCREEN_W) sw = SCREEN_W - sx; | |
| 2650 | + if (sy+sh >= SCREEN_H) sh = SCREEN_H - sy; | |
| 2582 | 2651 | |
| 2583 | 2652 | srcPitch = s->w - sw; |
| 2584 | 2653 | dstPitch = SCREEN_W - sw; |
| @@ -2587,7 +2656,7 @@ void renderSprites(void) · 2 unmodified lines | ||
| 2587 | 2656 | if (sprites[i].pixelType == SPRITE_TYPE_RGB) |
| 2588 | 2657 | { |
| 2589 | 2658 | // 24-bit RGB sprite |
| 2590 | − src32 = (uint32_t *)sprites[i].data; | |
| 2659 | + src32 = ((uint32_t *)sprites[i].data) + srcPtrBias; | |
| 2591 | 2660 | for (y = 0; y < sh; y++) |
| 2592 | 2661 | { |
| 2593 | 2662 | for (x = 0; x < sw; x++) |
| @@ -2608,7 +2677,7 @@ void renderSprites(void) · 14 unmodified lines | ||
| 2608 | 2677 | else |
| 2609 | 2678 | { |
| 2610 | 2679 | // 8-bit paletted sprite |
| 2611 | − src8 = (uint8_t *)sprites[i].data; | |
| 2680 | + src8 = ((uint8_t *)sprites[i].data) + srcPtrBias; | |
| 2612 | 2681 | for (y = 0; y < sh; y++) |
| 2613 | 2682 | { |
| 2614 | 2683 | for (x = 0; x < sw; x++) |
| @@ -2617,7 +2686,7 @@ void renderSprites(void) · 2 unmodified lines | ||
| 2617 | 2686 | if (*src8 != colorKey) |
| 2618 | 2687 | { |
| 2619 | 2688 | assert(*src8 < PALETTE_NUM); |
| 2620 | − *dst32 = palette[*src8]; | |
| 2689 | + *dst32 = video.palette[*src8]; | |
| 2621 | 2690 | } |
| 2622 | 2691 | |
| 2623 | 2692 | dst32++; |
| @@ -2634,21 +2703,21 @@ void renderSprites(void) · 10 unmodified lines | ||
| 2634 | 2703 | |
| 2635 | 2704 | void flipFrame(void) |
| 2636 | 2705 | { |
| 2637 | − uint32_t windowFlags = SDL_GetWindowFlags(window); | |
| 2638 | − | |
| 2639 | 2706 | renderSprites(); |
| 2640 | − SDL_UpdateTexture(texture, NULL, pixelBuffer, SCREEN_W * sizeof (int32_t)); | |
| 2641 | − SDL_RenderClear(renderer); | |
| 2642 | − SDL_RenderCopy(renderer, texture, NULL, NULL); | |
| 2643 | − SDL_RenderPresent(renderer); | |
| 2707 | + SDL_UpdateTexture(video.texture, NULL, video.frameBuffer, SCREEN_W * sizeof (int32_t)); | |
| 2708 | + SDL_RenderClear(video.renderer); | |
| 2709 | + SDL_RenderCopy(video.renderer, video.texture, NULL, NULL); | |
| 2710 | + SDL_RenderPresent(video.renderer); | |
| 2644 | 2711 | eraseSprites(); |
| 2645 | 2712 | |
| 2646 | − if (!editor.ui.vsync60HzPresent) | |
| 2713 | + if (!video.vsync60HzPresent) | |
| 2647 | 2714 | { |
| 2648 | 2715 | waitVBL(); // we have no VSync, do crude thread sleeping to sync to ~60Hz |
| 2649 | 2716 | } |
| 2650 | 2717 | else |
| 2651 | 2718 | { |
| 2719 | + uint32_t windowFlags = SDL_GetWindowFlags(video.window); | |
| 2720 | + | |
| 2652 | 2721 | /* We have VSync, but it can unexpectedly get inactive in certain scenarios. |
| 2653 | 2722 | ** We have to force thread sleeping (to ~60Hz) if so. |
| 2654 | 2723 | */ |
| @@ -2658,7 +2727,7 @@ void flipFrame(void) · 3 unmodified lines | ||
| 2658 | 2727 | waitVBL(); |
| 2659 | 2728 | #elif __unix__ |
| 2660 | 2729 | // *NIX: VSync gets disabled in fullscreen mode (at least on some distros/systems). Let's add a fix: |
| 2661 | − if ((windowFlags & SDL_WINDOW_MINIMIZED) || editor.fullscreen) | |
| 2730 | + if ((windowFlags & SDL_WINDOW_MINIMIZED) || video.fullscreen) | |
| 2662 | 2731 | waitVBL(); |
| 2663 | 2732 | #else |
| 2664 | 2733 | if (windowFlags & SDL_WINDOW_MINIMIZED) |
| @@ -2670,20 +2739,18 @@ void flipFrame(void) · 5 unmodified lines | ||
| 2670 | 2739 | void updateSpectrumAnalyzer(int8_t vol, int16_t period) |
| 2671 | 2740 | { |
| 2672 | 2741 | const uint8_t maxHeight = SPECTRUM_BAR_HEIGHT + 1; // +1 because of audio latency - allows full height to be seen |
| 2673 | − int16_t scaledVol; | |
| 2674 | − int32_t scaledNote; | |
| 2742 | + int32_t scaledVol, scaledNote; | |
| 2675 | 2743 | |
| 2676 | 2744 | if (editor.ui.visualizerMode != VISUAL_SPECTRUM || vol <= 0) |
| 2677 | 2745 | return; |
| 2678 | 2746 | |
| 2679 | − scaledVol = (vol * 256) / ((64 * 256) / (SPECTRUM_BAR_NUM+1)); // 64 = max sample vol | |
| 2747 | + scaledVol = (vol * 24600L) >> 16; // scaledVol = (vol << 8) / 682 | |
| 2680 | 2748 | |
| 2681 | 2749 | period = CLAMP(period, 113, 856); |
| 2682 | 2750 | |
| 2683 | − // 856 = C-1 period, 113 = B-3 period | |
| 2684 | − scaledNote = (856-113) - (period - 113); | |
| 2751 | + scaledNote = 856 - period; | |
| 2685 | 2752 | scaledNote *= scaledNote; |
| 2686 | − scaledNote /= ((856 - 113) * (856 - 113)) / (SPECTRUM_BAR_NUM-1); | |
| 2753 | + scaledNote = ((int64_t)scaledNote * 171162) >> 32; // scaledNote /= 25093 | |
| 2687 | 2754 | |
| 2688 | 2755 | // scaledNote now ranges 0..22, no need to clamp |
| 2689 | 2756 | |
| @@ -2711,24 +2778,27 @@ void updateSpectrumAnalyzer(int8_t vol, int16_t period) · 21 unmodified lines | ||
| 2711 | 2778 | |
| 2712 | 2779 | void sinkVisualizerBars(void) |
| 2713 | 2780 | { |
| 2781 | + int32_t i; | |
| 2782 | + | |
| 2714 | 2783 | // sink stuff @ 50Hz rate |
| 2715 | 2784 | |
| 2716 | − const uint64_t _50HzCounterDelta = ((uint64_t)AMIGA_PAL_VBLANK_HZ << 32) / VBLANK_HZ; | |
| 2785 | + static uint64_t counter50Hz; | |
| 2786 | + const uint64_t counter50HzDelta = ((uint64_t)AMIGA_PAL_VBLANK_HZ << 32) / VBLANK_HZ; | |
| 2717 | 2787 | |
| 2718 | − _50HzCounter += _50HzCounterDelta; // 32.32 fixed-point counter | |
| 2719 | − if (_50HzCounter > 0xFFFFFFFF) | |
| 2788 | + counter50Hz += counter50HzDelta; // 32.32 fixed-point counter | |
| 2789 | + if (counter50Hz > 0xFFFFFFFF) | |
| 2720 | 2790 | { |
| 2721 | − _50HzCounter &= 0xFFFFFFFF; | |
| 2791 | + counter50Hz &= 0xFFFFFFFF; | |
| 2722 | 2792 | |
| 2723 | 2793 | // sink VU-meters |
| 2724 | − for (uint32_t i = 0; i < AMIGA_VOICES; i++) | |
| 2794 | + for (i = 0; i < AMIGA_VOICES; i++) | |
| 2725 | 2795 | { |
| 2726 | 2796 | if (editor.vuMeterVolumes[i] > 0) |
| 2727 | 2797 | editor.vuMeterVolumes[i]--; |
| 2728 | 2798 | } |
| 2729 | 2799 | |
| 2730 | 2800 | // sink "spectrum analyzer" bars |
| 2731 | − for (uint32_t i = 0; i < SPECTRUM_BAR_NUM; i++) | |
| 2801 | + for (i = 0; i < SPECTRUM_BAR_NUM; i++) | |
| 2732 | 2802 | { |
| 2733 | 2803 | if (editor.spectrumVolumes[i] > 0) |
| 2734 | 2804 | editor.spectrumVolumes[i]--; |
| @@ -2746,57 +2816,57 @@ void updateRenderSizeVars(void) · 11 unmodified lines | ||
| 2746 | 2816 | float fXScale, fYScale; |
| 2747 | 2817 | SDL_DisplayMode dm; |
| 2748 | 2818 | |
| 2749 | − di = SDL_GetWindowDisplayIndex(window); | |
| 2819 | + di = SDL_GetWindowDisplayIndex(video.window); | |
| 2750 | 2820 | if (di < 0) |
| 2751 | 2821 | di = 0; /* return display index 0 (default) on error */ |
| 2752 | 2822 | |
| 2753 | 2823 | SDL_GetDesktopDisplayMode(di, &dm); |
| 2754 | − editor.ui.displayW = dm.w; | |
| 2755 | − editor.ui.displayH = dm.h; | |
| 2824 | + video.displayW = dm.w; | |
| 2825 | + video.displayH = dm.h; | |
| 2756 | 2826 | |
| 2757 | − if (editor.fullscreen) | |
| 2827 | + if (video.fullscreen) | |
| 2758 | 2828 | { |
| 2759 | − if (ptConfig.fullScreenStretch) | |
| 2829 | + if (config.fullScreenStretch) | |
| 2760 | 2830 | { |
| 2761 | − editor.ui.renderW = editor.ui.displayW; | |
| 2762 | − editor.ui.renderH = editor.ui.displayH; | |
| 2763 | − editor.ui.renderX = 0; | |
| 2764 | − editor.ui.renderY = 0; | |
| 2831 | + video.renderW = video.displayW; | |
| 2832 | + video.renderH = video.displayH; | |
| 2833 | + video.renderX = 0; | |
| 2834 | + video.renderY = 0; | |
| 2765 | 2835 | } |
| 2766 | 2836 | else |
| 2767 | 2837 | { |
| 2768 | − SDL_RenderGetScale(renderer, &fXScale, &fYScale); | |
| 2838 | + SDL_RenderGetScale(video.renderer, &fXScale, &fYScale); | |
| 2769 | 2839 | |
| 2770 | − editor.ui.renderW = (int32_t)(SCREEN_W * fXScale); | |
| 2771 | − editor.ui.renderH = (int32_t)(SCREEN_H * fYScale); | |
| 2840 | + video.renderW = (int32_t)(SCREEN_W * fXScale); | |
| 2841 | + video.renderH = (int32_t)(SCREEN_H * fYScale); | |
| 2772 | 2842 | |
| 2773 | 2843 | #ifdef __APPLE__ |
| 2774 | 2844 | // retina high-DPI hackery (SDL2 is bad at reporting actual rendering sizes on macOS w/ high-DPI) |
| 2775 | − SDL_GL_GetDrawableSize(window, &actualScreenW, &actualScreenH); | |
| 2845 | + SDL_GL_GetDrawableSize(video.window, &actualScreenW, &actualScreenH); | |
| 2776 | 2846 | SDL_GetDesktopDisplayMode(0, &dm); |
| 2777 | 2847 | |
| 2778 | − dXUpscale = ((double)actualScreenW / editor.ui.displayW); | |
| 2779 | − dYUpscale = ((double)actualScreenH / editor.ui.displayH); | |
| 2848 | + dXUpscale = ((double)actualScreenW / video.displayW); | |
| 2849 | + dYUpscale = ((double)actualScreenH / video.displayH); | |
| 2780 | 2850 | |
| 2781 | 2851 | // downscale back to correct sizes |
| 2782 | − if (dXUpscale != 0.0) editor.ui.renderW = (int32_t)(editor.ui.renderW / dXUpscale); | |
| 2783 | − if (dYUpscale != 0.0) editor.ui.renderH = (int32_t)(editor.ui.renderH / dYUpscale); | |
| 2852 | + if (dXUpscale != 0.0) video.renderW = (int32_t)(video.renderW / dXUpscale); | |
| 2853 | + if (dYUpscale != 0.0) video.renderH = (int32_t)(video.renderH / dYUpscale); | |
| 2784 | 2854 | #endif |
| 2785 | − editor.ui.renderX = (editor.ui.displayW - editor.ui.renderW) / 2; | |
| 2786 | − editor.ui.renderY = (editor.ui.displayH - editor.ui.renderH) / 2; | |
| 2855 | + video.renderX = (video.displayW - video.renderW) >> 1; | |
| 2856 | + video.renderY = (video.displayH - video.renderH) >> 1; | |
| 2787 | 2857 | } |
| 2788 | 2858 | } |
| 2789 | 2859 | else |
| 2790 | 2860 | { |
| 2791 | − SDL_GetWindowSize(window, &editor.ui.renderW, &editor.ui.renderH); | |
| 2861 | + SDL_GetWindowSize(video.window, &video.renderW, &video.renderH); | |
| 2792 | 2862 | |
| 2793 | − editor.ui.renderX = 0; | |
| 2794 | − editor.ui.renderY = 0; | |
| 2863 | + video.renderX = 0; | |
| 2864 | + video.renderY = 0; | |
| 2795 | 2865 | } |
| 2796 | 2866 | |
| 2797 | 2867 | // for mouse cursor creation |
| 2798 | − editor.ui.xScale = (int32_t)((editor.ui.renderW / (double)SCREEN_W) + 0.5); | |
| 2799 | − editor.ui.yScale = (int32_t)((editor.ui.renderH / (double)SCREEN_H) + 0.5); | |
| 2868 | + video.xScale = (int32_t)((video.renderW * (1.0 / SCREEN_W)) + 0.5); | |
| 2869 | + video.yScale = (int32_t)((video.renderH * (1.0 / SCREEN_H)) + 0.5); | |
| 2800 | 2870 | createMouseCursors(); |
| 2801 | 2871 | } |
| 2802 | 2872 | |
| @@ -2804,47 +2874,47 @@ void toggleFullScreen(void) · 1 unmodified line | ||
| 2804 | 2874 | { |
| 2805 | 2875 | SDL_DisplayMode dm; |
| 2806 | 2876 | |
| 2807 | − editor.fullscreen ^= 1; | |
| 2808 | − if (editor.fullscreen) | |
| 2877 | + video.fullscreen ^= 1; | |
| 2878 | + if (video.fullscreen) | |
| 2809 | 2879 | { |
| 2810 | − if (ptConfig.fullScreenStretch) | |
| 2880 | + if (config.fullScreenStretch) | |
| 2811 | 2881 | { |
| 2812 | 2882 | SDL_GetDesktopDisplayMode(0, &dm); |
| 2813 | − SDL_RenderSetLogicalSize(renderer, dm.w, dm.h); | |
| 2883 | + SDL_RenderSetLogicalSize(video.renderer, dm.w, dm.h); | |
| 2814 | 2884 | } |
| 2815 | 2885 | else |
| 2816 | 2886 | { |
| 2817 | − SDL_RenderSetLogicalSize(renderer, SCREEN_W, SCREEN_H); | |
| 2887 | + SDL_RenderSetLogicalSize(video.renderer, SCREEN_W, SCREEN_H); | |
| 2818 | 2888 | } |
| 2819 | 2889 | |
| 2820 | − SDL_SetWindowSize(window, SCREEN_W, SCREEN_H); | |
| 2821 | − SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP); | |
| 2822 | − SDL_SetWindowGrab(window, SDL_TRUE); | |
| 2890 | + SDL_SetWindowSize(video.window, SCREEN_W, SCREEN_H); | |
| 2891 | + SDL_SetWindowFullscreen(video.window, SDL_WINDOW_FULLSCREEN_DESKTOP); | |
| 2892 | + SDL_SetWindowGrab(video.window, SDL_TRUE); | |
| 2823 | 2893 | } |
| 2824 | 2894 | else |
| 2825 | 2895 | { |
| 2826 | − SDL_SetWindowFullscreen(window, 0); | |
| 2827 | − SDL_RenderSetLogicalSize(renderer, SCREEN_W, SCREEN_H); | |
| 2828 | − SDL_SetWindowSize(window, SCREEN_W * ptConfig.videoScaleFactor, SCREEN_H * ptConfig.videoScaleFactor); | |
| 2829 | − SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED); | |
| 2830 | − SDL_SetWindowGrab(window, SDL_FALSE); | |
| 2896 | + SDL_SetWindowFullscreen(video.window, 0); | |
| 2897 | + SDL_RenderSetLogicalSize(video.renderer, SCREEN_W, SCREEN_H); | |
| 2898 | + SDL_SetWindowSize(video.window, SCREEN_W * config.videoScaleFactor, SCREEN_H * config.videoScaleFactor); | |
| 2899 | + SDL_SetWindowPosition(video.window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED); | |
| 2900 | + SDL_SetWindowGrab(video.window, SDL_FALSE); | |
| 2831 | 2901 | } |
| 2832 | 2902 | |
| 2833 | 2903 | updateRenderSizeVars(); |
| 2834 | 2904 | updateMouseScaling(); |
| 2835 | 2905 | |
| 2836 | − if (editor.fullscreen) | |
| 2906 | + if (video.fullscreen) | |
| 2837 | 2907 | { |
| 2838 | − input.mouse.setPosX = editor.ui.displayW / 2; | |
| 2839 | − input.mouse.setPosY = editor.ui.displayH / 2; | |
| 2908 | + mouse.setPosX = video.displayW >> 1; | |
| 2909 | + mouse.setPosY = video.displayH >> 1; | |
| 2840 | 2910 | } |
| 2841 | 2911 | else |
| 2842 | 2912 | { |
| 2843 | − input.mouse.setPosX = editor.ui.renderW / 2; | |
| 2844 | − input.mouse.setPosY = editor.ui.renderH / 2; | |
| 2913 | + mouse.setPosX = video.renderW >> 1; | |
| 2914 | + mouse.setPosY = video.renderH >> 1; | |
| 2845 | 2915 | } |
| 2846 | 2916 | |
| 2847 | − input.mouse.setPosFlag = true; | |
| 2917 | + mouse.setPosFlag = true; | |
| 2848 | 2918 | } |
| 2849 | 2919 | |
| 2850 | 2920 | bool setupVideo(void) |
| @@ -2853,8 +2923,8 @@ bool setupVideo(void) · 2 unmodified lines | ||
| 2853 | 2923 | uint32_t rendererFlags; |
| 2854 | 2924 | SDL_DisplayMode dm; |
| 2855 | 2925 | |
| 2856 | − screenW = SCREEN_W * ptConfig.videoScaleFactor; | |
| 2857 | − screenH = SCREEN_H * ptConfig.videoScaleFactor; | |
| 2926 | + screenW = SCREEN_W * config.videoScaleFactor; | |
| 2927 | + screenH = SCREEN_H * config.videoScaleFactor; | |
| 2858 | 2928 | |
| 2859 | 2929 | rendererFlags = 0; |
| 2860 | 2930 | |
| @@ -2868,38 +2938,38 @@ bool setupVideo(void) · 7 unmodified lines | ||
| 2868 | 2938 | SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1"); |
| 2869 | 2939 | #endif |
| 2870 | 2940 | |
| 2871 | − editor.ui.vsync60HzPresent = false; | |
| 2872 | − if (!ptConfig.vsyncOff) | |
| 2941 | + video.vsync60HzPresent = false; | |
| 2942 | + if (!config.vsyncOff) | |
| 2873 | 2943 | { |
| 2874 | 2944 | SDL_GetDesktopDisplayMode(0, &dm); |
| 2875 | 2945 | if (dm.refresh_rate >= 59 && dm.refresh_rate <= 61) |
| 2876 | 2946 | { |
| 2877 | − editor.ui.vsync60HzPresent = true; | |
| 2947 | + video.vsync60HzPresent = true; | |
| 2878 | 2948 | rendererFlags |= SDL_RENDERER_PRESENTVSYNC; |
| 2879 | 2949 | } |
| 2880 | 2950 | } |
| 2881 | 2951 | |
| 2882 | − window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, | |
| 2952 | + video.window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, | |
| 2883 | 2953 | SDL_WINDOWPOS_CENTERED, screenW, screenH, |
| 2884 | 2954 | SDL_WINDOW_HIDDEN | SDL_WINDOW_ALLOW_HIGHDPI); |
| 2885 | 2955 | |
| 2886 | − if (window == NULL) | |
| 2956 | + if (video.window == NULL) | |
| 2887 | 2957 | { |
| 2888 | 2958 | showErrorMsgBox("Couldn't create SDL window:\n%s", SDL_GetError()); |
| 2889 | 2959 | return false; |
| 2890 | 2960 | } |
| 2891 | 2961 | |
| 2892 | − renderer = SDL_CreateRenderer(window, -1, rendererFlags); | |
| 2893 | − if (renderer == NULL) | |
| 2962 | + video.renderer = SDL_CreateRenderer(video.window, -1, rendererFlags); | |
| 2963 | + if (video.renderer == NULL) | |
| 2894 | 2964 | { |
| 2895 | − if (editor.ui.vsync60HzPresent) // try again without vsync flag | |
| 2965 | + if (video.vsync60HzPresent) // try again without vsync flag | |
| 2896 | 2966 | { |
| 2897 | − editor.ui.vsync60HzPresent = false; | |
| 2967 | + video.vsync60HzPresent = false; | |
| 2898 | 2968 | rendererFlags &= ~SDL_RENDERER_PRESENTVSYNC; |
| 2899 | − renderer = SDL_CreateRenderer(window, -1, rendererFlags); | |
| 2969 | + video.renderer = SDL_CreateRenderer(video.window, -1, rendererFlags); | |
| 2900 | 2970 | } |
| 2901 | 2971 | |
| 2902 | − if (renderer == NULL) | |
| 2972 | + if (video.renderer == NULL) | |
| 2903 | 2973 | { |
| 2904 | 2974 | showErrorMsgBox("Couldn't create SDL renderer:\n%s\n\n" \ |
| 2905 | 2975 | "Is your GPU (+ driver) too old?", SDL_GetError()); |
| @@ -2907,38 +2977,41 @@ bool setupVideo(void) · 1 unmodified line | ||
| 2907 | 2977 | } |
| 2908 | 2978 | } |
| 2909 | 2979 | |
| 2910 | − SDL_RenderSetLogicalSize(renderer, SCREEN_W, SCREEN_H); | |
| 2980 | + SDL_RenderSetLogicalSize(video.renderer, SCREEN_W, SCREEN_H); | |
| 2911 | 2981 | |
| 2912 | 2982 | #if SDL_PATCHLEVEL >= 5 |
| 2913 | − SDL_RenderSetIntegerScale(renderer, SDL_TRUE); | |
| 2983 | + SDL_RenderSetIntegerScale(video.renderer, SDL_TRUE); | |
| 2914 | 2984 | #endif |
| 2915 | 2985 | |
| 2916 | − SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE); | |
| 2986 | + SDL_SetRenderDrawBlendMode(video.renderer, SDL_BLENDMODE_NONE); | |
| 2917 | 2987 | |
| 2918 | 2988 | SDL_SetHint("SDL_RENDER_SCALE_QUALITY", "nearest"); |
| 2919 | 2989 | |
| 2920 | − texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, SCREEN_W, SCREEN_H); | |
| 2921 | − if (texture == NULL) | |
| 2990 | + video.texture = SDL_CreateTexture(video.renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, SCREEN_W, SCREEN_H); | |
| 2991 | + if (video.texture == NULL) | |
| 2922 | 2992 | { |
| 2923 | 2993 | showErrorMsgBox("Couldn't create %dx%d GPU texture:\n%s\n\n" \ |
| 2924 | 2994 | "Is your GPU (+ driver) too old?", SCREEN_W, SCREEN_H, SDL_GetError()); |
| 2925 | 2995 | return false; |
| 2926 | 2996 | } |
| 2927 | 2997 | |
| 2928 | − SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_NONE); | |
| 2998 | + SDL_SetTextureBlendMode(video.texture, SDL_BLENDMODE_NONE); | |
| 2929 | 2999 | |
| 2930 | 3000 | // frame buffer used by SDL (for texture) |
| 2931 | − pixelBuffer = (uint32_t *)malloc(SCREEN_W * SCREEN_H * sizeof (int32_t)); | |
| 2932 | − if (pixelBuffer == NULL) | |
| 3001 | + video.frameBufferUnaligned = (uint32_t *)MALLOC_PAD(SCREEN_W * SCREEN_H * sizeof (int32_t), 256); | |
| 3002 | + if (video.frameBufferUnaligned == NULL) | |
| 2933 | 3003 | { |
| 2934 | 3004 | showErrorMsgBox("Out of memory!"); |
| 2935 | 3005 | return false; |
| 2936 | 3006 | } |
| 2937 | 3007 | |
| 3008 | + // we want an aligned pointer | |
| 3009 | + video.frameBuffer = (uint32_t *)ALIGN_PTR(video.frameBufferUnaligned, 256); | |
| 3010 | + | |
| 2938 | 3011 | updateRenderSizeVars(); |
| 2939 | 3012 | updateMouseScaling(); |
| 2940 | 3013 | |
| 2941 | − if (ptConfig.hwMouse) | |
| 3014 | + if (config.hwMouse) | |
| 2942 | 3015 | SDL_ShowCursor(SDL_TRUE); |
| 2943 | 3016 | else |
| 2944 | 3017 | SDL_ShowCursor(SDL_FALSE); |
| @@ -68,7 +68,7 @@ void showVolToSlider(void); · 67 unmodified lines | ||
| 68 | 68 | void updateCurrSample(void); |
| 69 | 69 | void eraseSprites(void); |
| 70 | 70 | void renderSprites(void); |
| 71 | −void updateDragBars(void); | |
| 71 | +void handleLastGUIObjectDown(void); | |
| 72 | 72 | void invertRange(void); |
| 73 | 73 | void updateCursorPos(void); |
| 74 | 74 | void renderVuMeters(void); |
| @@ -206,6 +206,7 @@ · 205 unmodified lines | ||
| 206 | 206 | <OpenMPSupport>false</OpenMPSupport> |
| 207 | 207 | <LanguageStandard>stdcpplatest</LanguageStandard> |
| 208 | 208 | <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary> |
| 209 | + <Optimization>Disabled</Optimization> | |
| 209 | 210 | </ClCompile> |
| 210 | 211 | <Link> |
| 211 | 212 | <SubSystem>Windows</SubSystem> |
| @@ -247,6 +248,8 @@ · 35 unmodified lines | ||
| 247 | 248 | <OpenMPSupport>false</OpenMPSupport> |
| 248 | 249 | <LanguageStandard>stdcpplatest</LanguageStandard> |
| 249 | 250 | <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary> |
| 251 | + <Optimization>Disabled</Optimization> | |
| 252 | + <OmitFramePointers>false</OmitFramePointers> | |
| 250 | 253 | </ClCompile> |
| 251 | 254 | <Link> |
| 252 | 255 | <SubSystem>Windows</SubSystem> |