//#define USE_LOGGING //====================================================================== // This file is part of VCC (Virtual Color Computer). // Vcc is Copyright 2015 by Joseph Forgione // // VCC (Virtual Color Computer) is free software, you can redistribute // and/or modify it under the terms of the GNU General Public License // as published by the Free Software Foundation, either version 3 of // the License, or (at your option) any later version. // // VCC (Virtual Color Computer) is distributed in the hope that it will // be useful, but WITHOUT ANY WARRANTY; without even the implied // warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. // See the GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with VCC (Virtual Color Computer). If not, see // . //====================================================================== /*---------------------------------------------------------------------*/ //#define STRICT //#define WIN32_LEAN_AND_MEAN /*---------------------------------------------------------------------*/ // FIXME: This should be defined on the command line #define DIRECTINPUT_VERSION 0x0800 #ifdef _LEGACY_VCC #define _WIN32_WINNT 0x0500 #else #define _WIN32_WINNT 0x0601 // Windows 7 #endif #ifndef ABOVE_NORMAL_PRIORITY_CLASS //#define ABOVE_NORMAL_PRIORITY_CLASS 32768 #endif // FIXME: These defines need to be converted to a scoped enumeration #define TH_RUNNING 0 #define TH_REQWAIT 1 #define TH_WAITING 2 // To eliminate ShellExecute for displaying Wiki #include #include #pragma comment(lib, "runtimeobject.lib") #include "../../src/core/BuildConfig.h" #include #include #include #include #include #include #include #include #include #include "defines.h" #include "resource.h" #include "joystickinput.h" #include "Vcc.h" #include "../../src/core/tcc1014mmu.h" #include "../../src/core/tcc1014graphics.h" #include "../../src/core/tcc1014registers.h" #include "../../src/core/hd6309.h" #include "../../src/core/mc6809.h" #include "../../src/core/mc6821.h" #include "keyboard.h" #include "coco3.h" #include "pakinterface.h" #include "audio.h" #include "config.h" #include "quickload.h" #include "throttle.h" #include "DirectDrawInterface.h" #include "Cassette.h" #include "CommandLine.h" #include #include #include #include "memdump.h" #include "MemoryMap.h" #include "ProcessorState.h" #include "SourceDebug.h" #include "Disassembler.h" #include "MMUMonitor.h" #include "ExecutionTrace.h" #include #include #if USE_DEBUG_MOUSE #include "../../src/core/IDisplayDebug.h" #endif using namespace ::VCC; // namespace is everything VCC static HANDLE hout=nullptr; SystemState EmuState; static bool DialogOpen=false; static unsigned char AutoStart=1; static unsigned char Qflag=0; static unsigned char Pflag=0; static char CpuName[20]="CPUNAME"; #if USE_FPS #include "../../src/core/IDisplayDebug.h" #endif /***Forward declarations of functions included in this code module*****/ BOOL InitInstance (HINSTANCE, int); BOOL CALLBACK About(HWND, UINT, WPARAM, LPARAM); BOOL CALLBACK FunctionKeys(HWND, UINT, WPARAM, LPARAM); LRESULT CALLBACK WndProc( HWND, UINT, WPARAM, LPARAM); void SoftReset(); void LoadIniFile(); void SaveConfig(); unsigned __stdcall EmuLoop(HANDLE hEvent); unsigned __stdcall CartLoad(void *); void (*CPUInit)()=nullptr; int (*CPUExec)( int)=nullptr; void (*CPUReset)()=nullptr; void (*CPUSetBreakpoints)(const std::vector&) = nullptr; void (*CPUSetTraceTriggers)(const std::vector&) = nullptr; VCC::CPUState (*CPUGetState)() = nullptr; void (*CPUAssertInterupt)(InterruptSource, Interrupt)=nullptr; void (*CPUDeAssertInterupt)(InterruptSource, Interrupt)=nullptr; void (*CPUForcePC)(unsigned short)=nullptr; void FullScreenToggle(); void save_key_down(unsigned char kb_char, unsigned char OEMscan); void raise_saved_keys(); void FunctionHelpBox(HWND); void SetupClock(); HMENU GetConfMenu(); HMENU DrawCartMenu(HWND hWnd); // Globals static HANDLE hEMUThread ; static HANDLE hEMUQuit; // Function key overclocking flag //unsigned char OverclockFlag = 1; static char g_szAppName[MAX_LOADSTRING] = ""; bool BinaryRunning; static unsigned char FlagEmuStop=TH_RUNNING; const GUID* PowerGUID; bool IsShiftKeyDown(); using VCC::Bus::gVccCartMenu; static bool gHasFocus {}; #ifndef _LEGACY_VCC extern "C" NTSTATUS NTAPI RtlGetVersion(POSVERSIONINFOW); #pragma comment(lib, "ntdll") bool IsWin8_OrLater() { OSVERSIONINFOW osvi = { sizeof(osvi) }; RtlGetVersion(&osvi); return (osvi.dwMajorVersion > 6) || (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion >= 2); } #endif void RegisterDisplayNotification(HWND hWnd) { #ifndef _LEGACY_VCC if (IsWin8_OrLater()) PowerGUID = &GUID_CONSOLE_DISPLAY_STATE; // Win 8+ else PowerGUID = &GUID_MONITOR_POWER_ON; // Win 7 fallback RegisterPowerSettingNotification(hWnd, PowerGUID, DEVICE_NOTIFY_WINDOW_HANDLE); #endif } //--------------------------------------------------------------------------// // Main entry //--------------------------------------------------------------------------// int APIENTRY WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ int nCmdShow) { MSG Msg; EmuState.WindowInstance = hInstance; unsigned threadID; HANDLE hEvent, OleInitialize(nullptr); //Work around fixs app crashing in "Open file" system dialogs (related to Adobe acrobat 7+ LoadString(hInstance, IDS_APP_TITLE,g_szAppName, MAX_LOADSTRING); // Parse command line memset(&CmdArg,0,sizeof(CmdArg)); if (strlen(lpCmdLine)>0) GetCmdLineArgs(lpCmdLine); Cls(0,&EmuState); EmuState.Throttle = 1; EmuState.WindowSize.w=DefaultWidth; EmuState.WindowSize.h=DefaultHeight; EmuState.Exiting = false; // A reset will read settings from the config file. Must call // InitialLoadConfig and instantiate settings before a reset occurs. // Normally pakinterface will do a hard reset after loading a // cart but in case there is no cart to load force a reset here. InitialLoadConfig(&EmuState); EmuState.ResetPending=2; InitInstance(hInstance, nCmdShow); if ((CmdArg.NoOutput && !CreateNullWindow(&EmuState)) || (!CmdArg.NoOutput && !CreateDDWindow(&EmuState))) { MessageBox(nullptr,"Can't create primary Window","Error",0); exit(0); } RegisterDisplayNotification(EmuState.WindowHandle); InitSound(); LoadModule(); #if !USE_NEWTIMING SetClockSpeed(1); //Default clock speed .89 MHZ #endif BinaryRunning = true; EmuState.EmulationRunning=AutoStart; if (strlen(CmdArg.PasteText)!=0) { Pflag=255; } if (strlen(CmdArg.QLoadFile)!=0) { Qflag=255; EmuState.EmulationRunning=1; } hEvent = CreateEvent( nullptr, FALSE, FALSE, nullptr ) ; if (hEvent==nullptr) { MessageBox(nullptr,"Can't create Thread!!","Error",0); return 0; } hEMUQuit = CreateEvent(nullptr, FALSE, FALSE, nullptr); if (hEMUQuit == nullptr) { MessageBox(nullptr, "Can't create Thread Quit Event!!", "Error", 0); return 0; } hEMUThread = (HANDLE)_beginthreadex( nullptr, 0, &EmuLoop, hEvent, 0, &threadID ); if (hEMUThread==nullptr) { MessageBox(nullptr,"Can't Start main Emulation Thread!","Ok",0); return 0; } WaitForSingleObject( hEvent, INFINITE ); SetThreadPriority(hEMUThread,THREAD_PRIORITY_NORMAL); while (BinaryRunning) { //Need to stop the EMU thread for screen mode change //As it holds the Secondary screen buffer open while running if (FlagEmuStop==TH_WAITING) { FullScreenToggle(); FlagEmuStop=TH_RUNNING; } if (CmdArg.NoOutput) Sleep(1); else { // Seems if the main loop stops polling the child threads stall // not GetMessage as it blocks, continue loop when no messages if (PeekMessage(&Msg, nullptr, 0, 0, PM_REMOVE)) { TranslateMessage(&Msg); DispatchMessage(&Msg); } } } EmuState.Exiting = true; PostThreadMessage(threadID, WM_QUIT, 0, 0); SetEvent(hEMUQuit); // Signal emulation thread to finish up. // Wait for emulation thread to terminate while (WaitForSingleObject(hEMUThread, 10) == WAIT_TIMEOUT) { if (CmdArg.NoOutput) Sleep(1); else { // process messages while waiting, if any // not GetMessage as it blocks, continue loop when no messages if (PeekMessage(&Msg, nullptr, 0, 0, PM_REMOVE)) { TranslateMessage(&Msg); DispatchMessage(&Msg); } } } CloseHandle( hEvent ) ; CloseHandle( hEMUQuit ) ; CloseHandle( hEMUThread ) ; CloseScreen(); timeEndPeriod(1); UnloadDll(); return Msg.wParam; } void CloseApp() { WriteWindowSize(); // Saves size and position if checkbox is set BinaryRunning = false; SoundDeInit(); UnloadDll(); } //--------------------------------------------------------------------------// // VCC Main Window messaging loop //--------------------------------------------------------------------------// LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { int wmId, wmEvent; unsigned char kb_char; static unsigned char OEMscan=0; int Extended; kb_char = (unsigned char)wParam; switch (message) { #ifndef _LEGACY_VCC case WM_POWERBROADCAST: if (wParam == PBT_POWERSETTINGCHANGE) { auto p = reinterpret_cast(lParam); if (p->PowerSetting == *PowerGUID) { DWORD state = *reinterpret_cast(p->Data); // 0 = off, 1 = on, 2 = dimmed if (state == 1) OnMonitorRestored(); } } break; #endif // Fatal error notification // TODO: enum error code in wparam to give user more info case WM_VCC_FATAL: { MessageBox(nullptr, "A fatal error has occurred. VCC will close", "VCC Fatal Error", MB_ICONERROR | MB_OK); // TODO: This is brutal perhaps a cleaner shutdown? DWORD pid = GetCurrentProcessId(); HANDLE h = OpenProcess(PROCESS_TERMINATE,FALSE,pid); TerminateProcess(h,0); } // Hard reset VCC case WM_VCC_CPU_RESET: if (EmuState.EmulationRunning) EmuState.ResetPending=2; break; // Soft reset VCC case WM_VCC_SOFT_RESET: if (EmuState.EmulationRunning) EmuState.ResetPending=1; break; // Rebuild dynamic menus case WM_VCC_UPD_MENU: BuildCartMenu(); DrawCartMenu(hWnd); break; // Set startup slot from MPI case WM_VCC_SET_ACTIVE_SLOT: { uint32_t slot = static_cast(wParam); return SetActiveSlot(slot); } // Unload slot from MPI case WM_VCC_UNLOAD_SLOT: { uint32_t slot = static_cast(wParam); return UnloadSlot(slot); } // Load slot from MPI case WM_VCC_LOAD_SLOT: { uint32_t slot = static_cast(wParam); return LoadSlot(slot,reinterpret_cast(lParam)); } // Request name of cartridge in slot (1-4) case WM_VCC_GET_CART_NAME: { uint32_t slot = static_cast(wParam); auto* req = reinterpret_cast(lParam); return GetSlotCartName(slot,req); } // Request description of cartridge in slot (1-4) case WM_VCC_GET_CART_DESCRIPT: { uint32_t slot = static_cast(wParam); auto* req = reinterpret_cast(lParam); return GetSlotCartDescript(slot,req); } case WM_SYSCOMMAND: // Disable windows seeing Left ALT. (ALT-TAB can not be disabled) if(wParam==SC_KEYMENU) { if (GetKeyState(VK_LMENU) & 0x8000) return 0; // Left off } // falls through to WM_COMMAND case WM_COMMAND: // Force all keys up to prevent key repeats raise_saved_keys(); wmId = LOWORD(wParam); wmEvent = HIWORD(wParam); // Activate plugin menu if wmID is in plugin menu range if ( (wmId >= MID_CONTROL) && (wmId < MID_CONTROL + 250) ) { auto MenuID = wmId - MID_CONTROL; CartMenuActivated(MenuID); return 0; } switch (wmId) { case IDM_USER_WIKI: winrt::Windows::System::Launcher::LaunchUriAsync( winrt::Windows::Foundation::Uri( L"https://github.com/VCCE/VCC/wiki/UserGuide")); break; case IDM_HELP_ABOUT: DialogBox(EmuState.WindowInstance, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About); break; case IDM_HELP_FUNKEY: DialogBox(EmuState.WindowInstance, (LPCTSTR)IDD_FUNCTION_KEYS, hWnd, (DLGPROC)FunctionKeys); break; case ID_AUDIO_CONFIG: OpenAudioConfig(); break; case ID_CPU_CONFIG: OpenCpuConfig(); break; case ID_DISPLAY_CONFIG: OpenDisplayConfig(); break; case ID_KEYBOARD_CONFIG: OpenInputConfig(); break; case ID_JOYSTICKS_CONFIG: OpenJoyStickConfig(); break; case ID_TAPE_CONFIG: OpenTapeConfig(); break; case ID_BITBANGER_CONFIG: OpenBitBangerConfig(); break; case ID_FILE_EXIT: case IDOK: SendMessage (hWnd, WM_CLOSE, 0, 0); break; case ID_FILE_RESET: if (EmuState.EmulationRunning) EmuState.ResetPending=2; break; case ID_FILE_RUN: EmuState.EmulationRunning=TRUE; #if !USE_NEWTIMING gGimeGpu.InvalidateBoarder(); #endif break; case ID_FILE_RESET_SFT: if (EmuState.EmulationRunning) EmuState.ResetPending=1; break; case ID_FILE_LOAD: LoadIniFile(); break; case ID_SAVE_CONFIG: SaveConfig(); break; case ID_COPY_TEXT: CopyText(); break; case ID_PASTE_TEXT: PasteText(); break; case ID_PASTE_BASIC: PasteBASIC(); break; case ID_PASTE_BASIC_NEW: PasteBASICWithNew(); break; case ID_FLIP_ARTIFACTS: gGimeGpu.FlipArtifacts(); break; case ID_SWAP_JOYSTICKS: SwapJoySticks(); break; case ID_PAUSE_EMULATION: EmuState.Debugger.ToggleRun(); break; case ID_MEMORY_DISPLAY: VCC::Debugger::UI::OpenMemoryMapWindow(EmuState.WindowInstance, EmuState.WindowHandle); break; case ID_PROCESSOR_STATE: VCC::Debugger::UI::OpenProcessorStateWindow(EmuState.WindowInstance, EmuState.WindowHandle); break; case ID_BREAKPOINTS: VCC::Debugger::UI::OpenSourceDebugWindow(EmuState.WindowInstance, EmuState.WindowHandle); break; case ID_MMU_MONITOR: VCC::Debugger::UI::OpenMMUMonitorWindow(EmuState.WindowInstance, EmuState.WindowHandle); break; case ID_EXEC_TRACE: VCC::Debugger::UI::OpenExecutionTraceWindow(EmuState.WindowInstance, EmuState.WindowHandle); break; case ID_DISASSEMBLER: VCC::OpenDisassemblerWindow(EmuState.WindowInstance, EmuState.WindowHandle); break; default: return DefWindowProc(hWnd, message, wParam, lParam); } break; case WM_CREATE: // Create initial cartridge menu. If no carts are loaded at startup // build and draw here are needed to bootstrap the cartridge menu BuildCartMenu(); DrawCartMenu(hWnd); #ifdef _LEGACY_VCC { char title[80] = "Legacy "; strncat(title,g_szAppName,80); SetWindowTextA(hWnd,title); } #endif break; case WM_SETCURSOR: // Hide mouse cursor if ((EmuState.MousePointer != 1) && (LOWORD(lParam) == HTCLIENT)) { if (gHasFocus) SetCursor(nullptr); return TRUE; } break; case WM_SETFOCUS: gHasFocus = true; break; case WM_KILLFOCUS: // Force keys up if main widow keyboard focus is lost. Otherwise // down keys will cause issues with OS-9 on return raise_saved_keys(); gHasFocus = false; break; case WM_CLOSE: CloseApp(); break; case WM_CHAR: return 0; break; case WM_SYSCHAR: DefWindowProc(hWnd, message, wParam, lParam); return 0; break; case WM_KEYUP: case WM_SYSKEYUP: // send emulator key up event to the emulator // TODO: Key up checks whether the emulation is running, this does not OEMscan = (unsigned char) ((lParam >> 16) & 0xFF); Extended=(lParam >> 24) & 1; if (Extended && (OEMscan!=DIK_NUMLOCK)) OEMscan += 0x80; vccKeyboardHandleKey(OEMscan,kEventKeyUp); return 0; break; //---------------------------------------------------------------------------------------- // lParam bits // 0-15 The repeat count for the current message. The value is the number of times // the keystroke is autorepeated as a result of the user holding down the key. // If the keystroke is held long enough, multiple messages are sent. However, // the repeat count is not cumulative. // 16-23 The scan code. The value depends on the OEM. // 24 Indicates whether the key is an extended key, such as the right-hand ALT and // CTRL keys that appear on an enhanced 101- or 102-key keyboard. The value is // one if it is an extended key; otherwise, it is zero. // 25-28 Reserved; do not use. // 29 The context code. The value is always zero for a WM_KEYDOWN message. // 30 The previous key state. The value is one if the key is down before the // message is sent, or it is zero if the key is up. // 31 The transition state. The value is always zero for a WM_KEYDOWN message. //---------------------------------------------------------------------------------------- case WM_SYSKEYDOWN: // Ignore repeated system keys if (lParam>>30) return 0; case WM_KEYDOWN: // Let Windows handle right ALT key { bool isRightAlt = (wParam == VK_MENU && (lParam & (1 << 24))); if (isRightAlt) return DefWindowProc(hWnd, message, wParam, lParam); } // get key scan code for emulator control keys OEMscan = (unsigned char) ((lParam >> 16) & 0xFF); Extended=(lParam >> 24) & 1; if (Extended && (OEMscan!=DIK_NUMLOCK)) OEMscan += 0x80; // kb_char = Windows virtual key code switch ( OEMscan ) { case DIK_F3: DecreaseOverclockSpeed(); break; case DIK_F4: IncreaseOverclockSpeed(); break; case DIK_F5: if ( EmuState.EmulationRunning ) { EmuState.ResetPending = (IsShiftKeyDown()) ? 2 : 1; } break; case DIK_F6: if (IsShiftKeyDown()) gGimeGpu.FlipArtifacts(); else gGimeGpu.SetMonitorType(!gGimeGpu.SetMonitorType(QUERY)); break; case DIK_F7: if (IsShiftKeyDown()) SwapJoySticks(); else EmuState.Debugger.ToggleRun(); break; case DIK_F8: if (IsShiftKeyDown()) { SetOverclock(!EmuState.OverclockFlag); SetupClock(); } else { SetSpeedThrottle(!SetSpeedThrottle(QUERY)); } break; case DIK_F9: EmuState.EmulationRunning=!EmuState.EmulationRunning; if ( EmuState.EmulationRunning ) EmuState.ResetPending=2; else SetStatusBarText("",&EmuState); break; case DIK_F10: { HMENU hMenu = nullptr; if ( IsShiftKeyDown() ) { hMenu = GetConfMenu(); } else { hMenu = DrawCartMenu(hWnd); } if (hMenu && EmuState.FullScreen) { RECT r; GetClientRect(hWnd,&r); TrackPopupMenu(hMenu,TPM_CENTERALIGN|TPM_VCENTERALIGN, r.right/2,r.bottom/2,0,hWnd,nullptr); } } break; case DIK_F11: if (FlagEmuStop == TH_RUNNING) { if (IsShiftKeyDown()) { SetInfoBand(!SetInfoBand(QUERY)); #if !USE_NEWTIMING gGimeGpu.InvalidateBoarder(); #endif } else { FlagEmuStop = TH_REQWAIT; EmuState.FullScreen =!EmuState.FullScreen; } } break; case DIK_F12: if (IsShiftKeyDown()) DumpScreenshot(); else // If help dialog is modeless it prevents full screen FunctionHelpBox(hWnd); break; default: // send shift and other keystrokes to the emulator if it is active if ( EmuState.EmulationRunning ) { vccKeyboardHandleKey(OEMscan, kEventKeyDown); // Save key down in case focus is lost save_key_down(kb_char,OEMscan); } break; } return 0; break; // Don't send click that activates window to emulation case WM_MOUSEACTIVATE: return MA_ACTIVATEANDEAT; break; case WM_LBUTTONDOWN: //0 = Left 1=right SetButtonStatus(0,1); break; case WM_LBUTTONUP: SetButtonStatus(0,0); break; case WM_RBUTTONDOWN: SetButtonStatus(1,1); break; case WM_RBUTTONUP: SetButtonStatus(1,0); break; case WM_MOUSEMOVE: if (EmuState.EmulationRunning) { static const float MAX_AXIS_VALUE = 16384.0f; // Get the dimensions of the usable client area (i.e. sans status bar) RECT clientRect; GetClientRect(EmuState.WindowHandle, &clientRect); clientRect.bottom -= GetRenderWindowStatusBarHeight(); int mouseXPosition = GET_X_LPARAM(lParam); int mouseYPosition = GET_Y_LPARAM(lParam); int maxHorizontalPosition = clientRect.right; int maxVerticalPosition = clientRect.bottom; if (!EmuState.FullScreen) { const DisplayDetails displayDetails(GetDisplayDetails(clientRect.right, clientRect.bottom)); maxHorizontalPosition -= (displayDetails.leftBorderColumns + displayDetails.rightBorderColumns); maxVerticalPosition -= (displayDetails.topBorderRows + displayDetails.bottomBorderRows); mouseXPosition = std::min( std::max(0, mouseXPosition - displayDetails.leftBorderColumns), maxHorizontalPosition); mouseYPosition = std::min( std::max(0, mouseYPosition - displayDetails.topBorderRows), maxVerticalPosition); #if USE_DEBUG_MOUSE // render mouse content area DebugDrawBox(displayDetails.leftBorderColumns, displayDetails.topBorderRows, maxHorizontalPosition, maxVerticalPosition, VCC::ColorRed); // render mouse crosshair int mx = displayDetails.leftBorderColumns; int my = displayDetails.topBorderRows; DebugDrawLine(mouseXPosition + mx, mouseYPosition - 20 + my, mouseXPosition + mx, mouseYPosition + 20 + my, VCC::ColorRed); DebugDrawLine(mouseXPosition - 20 + mx, mouseYPosition + my, mouseXPosition + 20 + mx, mouseYPosition + my, VCC::ColorRed); #endif } // Convert coordinates to mouseXPosition,mouseYPosition values with range 0-3fff (0-16383). mouseXPosition = static_cast(mouseXPosition * (MAX_AXIS_VALUE / maxHorizontalPosition)); mouseYPosition = static_cast(mouseYPosition * (MAX_AXIS_VALUE / maxVerticalPosition)); joystick(mouseXPosition, mouseYPosition); } return 0; } return DefWindowProc(hWnd, message, wParam, lParam); } //-------------------------------------------------------------------------- // Refresh the cartridge menu from the menu item list //-------------------------------------------------------------------------- HMENU DrawCartMenu (HWND hWnd) { gVccCartMenu.log(); // window handle, zero based position on menu bar, name on bar. return gVccCartMenu.draw( hWnd, 3, "&Cartridge"); } //-------------------------------------------------------------------------- // When the main window is about to lose keyboard focus there are one // or two keys down in the emulation that must be raised. These routines // track the last two key down events so they can be raised when needed. //-------------------------------------------------------------------------- static unsigned char SC_save1 = 0; static unsigned char SC_save2 = 0; static unsigned char KB_save1 = 0; static unsigned char KB_save2 = 0; static int KeySaveToggle=0; // Save last two key down events void save_key_down(unsigned char kb_char, unsigned char OEMscan) { // Ignore zero scan code if (OEMscan == 0) return; // Remember it KeySaveToggle = !KeySaveToggle; if (KeySaveToggle) { KB_save1 = kb_char; SC_save1 = OEMscan; } else { KB_save2 = kb_char; SC_save2 = OEMscan; } return; } // Send key up events to keyboard handler for saved keys void raise_saved_keys() { if (SC_save1) vccKeyboardHandleKey(SC_save1,kEventKeyUp); if (SC_save2) vccKeyboardHandleKey(SC_save2,kEventKeyUp); SC_save1 = 0; SC_save2 = 0; return; } void SetCPUMultiplyerFlag (unsigned char double_speed) { EmuState.DoubleSpeedFlag=double_speed; SetupClock(); return; } void SetTurboMode(unsigned char data) { EmuState.TurboSpeedFlag=(data&1)+1; SetupClock(); return; } unsigned char SetCPUMultiplyer(unsigned char Multiplyer) { if (Multiplyer!=QUERY) { EmuState.DoubleSpeedMultiplyer=Multiplyer; SetCPUMultiplyerFlag (EmuState.DoubleSpeedFlag); } return(EmuState.DoubleSpeedMultiplyer); } void SetupClock() { int mult = EmuState.OverclockFlag ? EmuState.DoubleSpeedMultiplyer : 2; #if USE_NEWTIMING // clocks @ 14.31818mhz (NTSC) constexpr auto ClockFreq = 14318180; EmuState.CPUCurrentSpeed = ClockFreq / 16 / 1000000.0; int speed = 1; if (EmuState.DoubleSpeedFlag) { // -1 as double speed is set in clocks per cycle speed = EmuState.TurboSpeedFlag * (mult - 1); } VCC::gEvents.SetOverclock(speed); VCC::gEvents.SetClocksPerCycle(EmuState.DoubleSpeedFlag ? 8 : 16); #else SetClockSpeed(1); if (EmuState.DoubleSpeedFlag) SetClockSpeed(mult * EmuState.TurboSpeedFlag); EmuState.CPUCurrentSpeed = .894; #endif if (EmuState.DoubleSpeedFlag) EmuState.CPUCurrentSpeed*=(mult*EmuState.TurboSpeedFlag); return; } void DoHardReset(SystemState* const HRState) { HRState->RamBuffer=MmuInit(HRState->RamSize); //Alocate RAM/ROM & copy ROM Images from source HRState->WRamBuffer=(unsigned short *)HRState->RamBuffer; // Debugger - watch memory. // Only Processor Space (64K) is watched at the moment. HRState->Debugger.Reset(); // Debugger --------------------- // Remove all haltpoints VCC::KillHaltpoints(); if (HRState->RamBuffer == nullptr) { MessageBox(nullptr,"Can't allocate enough RAM, Out of memory","Error",0); exit(0); } if (HRState->CpuType == 1) { CPUInit = HD6309Init; CPUExec = HD6309Exec; CPUReset = HD6309Reset; CPUAssertInterupt = HD6309AssertInterupt; CPUDeAssertInterupt = HD6309DeAssertInterupt; CPUForcePC = HD6309ForcePC; CPUSetBreakpoints = HD6309SetBreakpoints; CPUGetState = HD6309GetState; CPUSetTraceTriggers = HD6309SetTraceTriggers; } else { CPUInit = MC6809Init; CPUExec = MC6809Exec; CPUReset = MC6809Reset; CPUAssertInterupt = MC6809AssertInterupt; CPUDeAssertInterupt = MC6809DeAssertInterupt; CPUForcePC = MC6809ForcePC; CPUSetBreakpoints = MC6809SetBreakpoints; CPUGetState = MC6809GetState; CPUSetTraceTriggers = MC6809SetTraceTriggers; } PiaReset(); mc6883_reset(); //Captures interal rom pointer for CPU Interupt Vectors CPUInit(); CPUReset(); // Zero all CPU Registers and sets the PC to VRESET EmuState.TurboSpeedFlag = 1; SetCPUMultiplyerFlag(0); gEvents.Reset(); gGimeGpu.GimeReset(); GimeRegistersReset(); MiscReset(); MmuReset(); UpdateBusPointer(); ResetBus(); return; } void SoftReset() { mc6883_reset(); PiaReset(); CPUReset(); EmuState.TurboSpeedFlag = 1; SetCPUMultiplyerFlag(0); gEvents.Reset(); gGimeGpu.GimeReset(); MiscReset(); MmuReset(); LoadRom(); ResetBus(); return; } // Message handler for the About box. BOOL CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM /*lParam*/) { switch (message) { case WM_INITDIALOG: SendDlgItemMessage(hDlg,IDC_TITLE,WM_SETTEXT,0,(LPARAM)(LPCSTR)g_szAppName); return TRUE; case WM_CLOSE: EndDialog(hDlg, LOWORD(wParam)); return TRUE; case WM_COMMAND: switch (LOWORD(wParam)) case IDOK: SendMessage (hDlg, WM_CLOSE, 0, 0); break; } return FALSE; } // Message handler for function key help. BOOL CALLBACK FunctionKeys(HWND hDlg, UINT message, WPARAM wParam, LPARAM /*lParam*/) { switch (message) { case WM_INITDIALOG: SendDlgItemMessage(hDlg,IDC_TITLE,WM_SETTEXT,0,(LPARAM)(LPCSTR)g_szAppName); return TRUE; case WM_CLOSE: case WM_COMMAND: EndDialog(hDlg, wParam); return TRUE; } return FALSE; } unsigned char SetRamSize(unsigned char Size) { if (Size!=QUERY) EmuState.RamSize=Size; return(EmuState.RamSize); } unsigned char SetSpeedThrottle(unsigned char throttle) { if (throttle != QUERY) { EmuState.Throttle = throttle; } return(EmuState.Throttle); } unsigned char SetFrameSkip(unsigned char Skip) { if (Skip!=QUERY) EmuState.FrameSkip=Skip; return(EmuState.FrameSkip); } unsigned char SetCpuType( unsigned char Tmp) { switch (Tmp) { case 0: EmuState.CpuType=0; strcpy(CpuName,"MC6809"); break; case 1: EmuState.CpuType=1; strcpy(CpuName,"HD6309"); break; } return(EmuState.CpuType); } void DoReboot() { EmuState.ResetPending=2; return; } unsigned char SetAutoStart(unsigned char Tmp) { if (Tmp != QUERY) AutoStart=Tmp; return AutoStart; } // LoadIniFile allows user to browse for an ini file and reloads the config from it. void LoadIniFile() { FlushSettings(); // Make sure all current settings are flused to store char curini[MAX_PATH]=""; GetIniFilePath(curini); FileDialog dlg; dlg.setFilter("INI\0*.ini\0\0"); dlg.setDefExt("ini"); dlg.setInitialDir(AppDirectory() ); dlg.setTitle(TEXT("Load Vcc Config File") ); dlg.setFlags(OFN_FILEMUSTEXIST); dlg.setpath(curini); if ( dlg.show() ) { SetIniFilePath(dlg.path()); // Set new settings path EmuState.ResetPending = 2; // Hard reset loads and updates settings } return; } // SaveConfig copies the current ini file to a choosen ini file. void SaveConfig() { FlushSettings(); char curini[MAX_PATH]=""; GetIniFilePath(curini); FileDialog dlg; dlg.setFilter("INI\0*.ini\0\0"); dlg.setDefExt("ini"); dlg.setInitialDir(AppDirectory() ); dlg.setTitle(TEXT("Save Vcc Config File") ); dlg.setFlags(OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT); // Send current ini file path to dialog dlg.setpath(curini); if ( dlg.show(1) ) { SetIniFilePath(dlg.path()); // Set new ini file path // If ini file has changed if (_stricmp(curini,dlg.path()) != 0) { // Copy current ini to new ini if (! CopyFile(curini,dlg.path(),false) ) MessageBox(nullptr,"Copy config failed","error",0); } } return; } #if USE_FPS const int FPSHistorySize = 120; struct FPS { float render; float frame; }; FPS gFPSHistory[FPSHistorySize]; #endif unsigned __stdcall EmuLoop(HANDLE hEvent) { _LARGE_INTEGER Now{}; #if USE_FPS _LARGE_INTEGER LastNow{}, OneMs{}, LastFrame{}; QueryPerformanceFrequency(&Now); OneMs.QuadPart = Now.QuadPart / 1000; #endif static float FPS; static unsigned int FrameCounter=0; CalibrateThrottle(); Sleep(30); SetEvent(hEvent) ; while (true) { // Main Thread wants us to end? if (WaitForSingleObject(hEMUQuit,0) == WAIT_OBJECT_0) { break; } if (FlagEmuStop==TH_REQWAIT) { FlagEmuStop = TH_WAITING; //Signal Main thread we are waiting while (FlagEmuStop == TH_WAITING) Sleep(1); } FPS=0; if ((Qflag==255) && (FrameCounter==32)) { Qflag=0; QuickLoad(CmdArg.QLoadFile); } if ((Pflag==255) && (FrameCounter==32)) { Pflag=0; QueueText(CmdArg.PasteText); } #if USE_FPS // do not include throttling just rendering time QueryPerformanceCounter(&LastNow); Now = LastNow; #endif StartRender(); for (uint8_t Frames = 1; Frames <= EmuState.FrameSkip; Frames++) { if (!EmuState.Debugger.IsHalted()) FrameCounter++; if (EmuState.ResetPending != 0) { switch (EmuState.ResetPending) { case 1: //Soft Reset SoftReset(); break; case 2: //Hard Reset ReadIniFile(); // FIXME ReadIniFile should apply changes UpdateConfig(); // Applies only video and Cpu changes DoCls(&EmuState); // Clear the screen DoHardReset(&EmuState); break; case 3: DoCls(&EmuState); break; case 4: UpdateConfig(); // Apply video and cpy changes DoCls(&EmuState); break; default: break; } EmuState.ResetPending = 0; } if (EmuState.EmulationRunning == 1) { FPS += RenderFrame(&EmuState,Now); } else { FPS += Static(&EmuState); } } EndRender(EmuState.FrameSkip); FPS/=EmuState.FrameSkip; GetModuleStatus(&EmuState); char tstatus[128]; char tspeed[32]; snprintf(tspeed,sizeof(tspeed),"%2.2fMhz",EmuState.CPUCurrentSpeed); // Append "+" to speed if overclocking is enabled if (EmuState.OverclockFlag && (EmuState.DoubleSpeedMultiplyer>2)) strncat (tspeed,"+",sizeof(tspeed)); if (EmuState.Debugger.IsHalted()) { snprintf(tstatus,sizeof(tstatus), " Paused - Hit F7 | %s @ %s | %s", CpuName,tspeed,EmuState.StatusLine); } else { snprintf(tstatus,sizeof(tstatus),"Skip:%2.2i | FPS:%3.0f | %s @ %s | %s", EmuState.FrameSkip,FPS,CpuName,tspeed,EmuState.StatusLine); } int len = strlen(tstatus); UpdateTapeStatus(tstatus + len, sizeof(tstatus) - len); SetStatusBarText(tstatus,&EmuState); if (CmdArg.MaxFrames > 0 && FrameCounter >= CmdArg.MaxFrames) { if (*CmdArg.Screenshot != 0) DumpScreenshot(CmdArg.Screenshot); CloseApp(); } #if USE_FPS auto intervalMS = (float)(Now.QuadPart - LastNow.QuadPart) / OneMs.QuadPart; QueryPerformanceCounter(&Now); auto frameIntervalMS = (float)(Now.QuadPart - LastFrame.QuadPart) / OneMs.QuadPart; LastFrame = Now; memcpy(&gFPSHistory[0], &gFPSHistory[1], sizeof(gFPSHistory) - sizeof(*gFPSHistory)); auto constexpr scale = 2.0f; auto constexpr height = 50.0f*scale; extern int gHsyncs; gFPSHistory[FPSHistorySize - 1].render = std::min(intervalMS*scale, height); gFPSHistory[FPSHistorySize - 1].frame = std::min(frameIntervalMS*scale, height); VCC::Pixel col1(VCC::ColorBlue); col1.a = 150; VCC::Pixel col(VCC::ColorYellow); col.a = 200; VCC::Pixel col2(VCC::ColorWhite); col2.a = 200; VCC::Pixel col3(VCC::ColorGreen); col3.a = 200; DebugDrawBox(10, 10, FPSHistorySize, (int)height, col1, true); DebugDrawBox(10, 10, FPSHistorySize, (int)height, col2, false); for (int i = 1; i < FPSHistorySize;++i) { auto& data = gFPSHistory[i]; float xp = 10 + (float)i; float yp = 10 + height; DebugDrawLine(xp, yp - gFPSHistory[i - 1].render, xp + 1, yp - gFPSHistory[i].render, col); DebugDrawLine(xp, yp - gFPSHistory[i - 1].frame, xp + 1, yp - gFPSHistory[i].frame, col2); } char ms[32]; sprintf(ms, "Frame :%.1fms", frameIntervalMS); DebugPrint(12, 22, 13, ms, VCC::ColorWhite); sprintf(ms, "Render:%.1fms", intervalMS); DebugPrint(12, 22+12, 13, ms, VCC::ColorYellow); #endif if (EmuState.Throttle) //Do nothing untill the frame is over returning unused time to OS FrameWait(); } //Still Emulating return 0; } void FullScreenToggle() { PauseAudio(true); if (!CreateDDWindow(&EmuState)) { MessageBox(nullptr,"Can't rebuild primary Window","Error",0); exit(0); } #if !USE_NEWTIMING gGimeGpu.InvalidateBoarder(); #endif EmuState.ConfigDialog=nullptr; PauseAudio(false); return; } void FunctionHelpBox(HWND hWnd) { DialogBox(EmuState.WindowInstance, MAKEINTRESOURCE(IDD_FUNCTION_KEYS),hWnd,FunctionKeys); } HMENU GetConfMenu() { static HMENU hMenu = nullptr; if (hMenu == nullptr) { hMenu = CreatePopupMenu(); AppendMenu(hMenu,MF_STRING,ID_AUDIO_CONFIG,"Audio"); AppendMenu(hMenu,MF_STRING,ID_CPU_CONFIG,"Cpu"); AppendMenu(hMenu,MF_STRING,ID_DISPLAY_CONFIG,"Display"); AppendMenu(hMenu,MF_STRING,ID_KEYBOARD_CONFIG,"Keyboard"); AppendMenu(hMenu,MF_STRING,ID_JOYSTICKS_CONFIG,"Joysticks"); AppendMenu(hMenu,MF_STRING,ID_TAPE_CONFIG,"Tape"); AppendMenu(hMenu,MF_STRING,ID_BITBANGER_CONFIG,"BitBanger"); } return hMenu; } bool IsShiftKeyDown() { return (GetKeyState(VK_SHIFT) & 0x8000) != 0; }