459 lines
14 KiB
C++
459 lines
14 KiB
C++
#include <stdbool.h>
|
|
|
|
#include <guisan.hpp>
|
|
#include <SDL_ttf.h>
|
|
#include <guisan/sdl.hpp>
|
|
#include <guisan/sdl/sdltruetypefont.hpp>
|
|
#include "SelectorEntry.hpp"
|
|
#include "UaeRadioButton.hpp"
|
|
#include "UaeCheckBox.hpp"
|
|
|
|
#include "sysdeps.h"
|
|
#include "options.h"
|
|
#include "memory.h"
|
|
#include "newcpu.h"
|
|
#include "gui_handling.h"
|
|
|
|
static gcn::Window* grpCPU;
|
|
static gcn::UaeRadioButton* optCPU68000;
|
|
static gcn::UaeRadioButton* optCPU68010;
|
|
static gcn::UaeRadioButton* optCPU68020;
|
|
static gcn::UaeRadioButton* optCPU68030;
|
|
static gcn::UaeRadioButton* optCPU68040;
|
|
static gcn::UaeCheckBox* chk24Bit;
|
|
static gcn::UaeCheckBox* chkCPUCompatible;
|
|
static gcn::UaeCheckBox* chkJIT;
|
|
static gcn::Window* grpFPU;
|
|
static gcn::UaeRadioButton* optFPUnone;
|
|
static gcn::UaeRadioButton* optFPU68881;
|
|
static gcn::UaeRadioButton* optFPU68882;
|
|
static gcn::UaeRadioButton* optFPUinternal;
|
|
static gcn::UaeCheckBox* chkFPUstrict;
|
|
static gcn::UaeCheckBox* chkFPUJIT;
|
|
static gcn::Window* grpCPUSpeed;
|
|
static gcn::UaeRadioButton* opt7Mhz;
|
|
static gcn::UaeRadioButton* opt14Mhz;
|
|
static gcn::UaeRadioButton* opt28Mhz;
|
|
static gcn::UaeRadioButton* optFastest;
|
|
static gcn::UaeRadioButton* optTurbo;
|
|
|
|
class CPUButtonActionListener : public gcn::ActionListener
|
|
{
|
|
public:
|
|
void action(const gcn::ActionEvent& actionEvent) override
|
|
{
|
|
if (actionEvent.getSource() == optCPU68000)
|
|
{
|
|
changed_prefs.cpu_model = 68000;
|
|
changed_prefs.fpu_model = 0;
|
|
changed_prefs.address_space_24 = true;
|
|
changed_prefs.z3fastmem[0].size = 0;
|
|
changed_prefs.rtgboards[0].rtgmem_size = 0;
|
|
changed_prefs.cachesize = 0;
|
|
changed_prefs.compfpu = false;
|
|
}
|
|
else if (actionEvent.getSource() == optCPU68010)
|
|
{
|
|
changed_prefs.cpu_model = 68010;
|
|
changed_prefs.fpu_model = 0;
|
|
changed_prefs.address_space_24 = true;
|
|
changed_prefs.z3fastmem[0].size = 0;
|
|
changed_prefs.rtgboards[0].rtgmem_size = 0;
|
|
changed_prefs.cachesize = 0;
|
|
changed_prefs.compfpu = false;
|
|
}
|
|
else if (actionEvent.getSource() == optCPU68020)
|
|
{
|
|
changed_prefs.cpu_model = 68020;
|
|
if (changed_prefs.fpu_model == 68040)
|
|
changed_prefs.fpu_model = 68881;
|
|
changed_prefs.cpu_compatible = false;
|
|
}
|
|
else if (actionEvent.getSource() == optCPU68030)
|
|
{
|
|
changed_prefs.cpu_model = 68030;
|
|
if (changed_prefs.fpu_model == 68040)
|
|
changed_prefs.fpu_model = 68881;
|
|
changed_prefs.address_space_24 = false;
|
|
changed_prefs.cpu_compatible = false;
|
|
}
|
|
else if (actionEvent.getSource() == optCPU68040)
|
|
{
|
|
changed_prefs.cpu_model = 68040;
|
|
changed_prefs.fpu_model = 68040;
|
|
changed_prefs.address_space_24 = false;
|
|
changed_prefs.cpu_compatible = false;
|
|
}
|
|
RefreshPanelCPU();
|
|
RefreshPanelRAM();
|
|
}
|
|
};
|
|
|
|
static CPUButtonActionListener* cpuButtonActionListener;
|
|
|
|
class FPUButtonActionListener : public gcn::ActionListener
|
|
{
|
|
public:
|
|
void action(const gcn::ActionEvent& actionEvent) override
|
|
{
|
|
if (actionEvent.getSource() == optFPUnone)
|
|
{
|
|
changed_prefs.fpu_model = 0;
|
|
}
|
|
else if (actionEvent.getSource() == optFPU68881)
|
|
{
|
|
changed_prefs.fpu_model = 68881;
|
|
}
|
|
else if (actionEvent.getSource() == optFPU68882)
|
|
{
|
|
changed_prefs.fpu_model = 68882;
|
|
}
|
|
else if (actionEvent.getSource() == optFPUinternal)
|
|
{
|
|
changed_prefs.fpu_model = 68040;
|
|
}
|
|
RefreshPanelCPU();
|
|
RefreshPanelRAM();
|
|
}
|
|
};
|
|
|
|
static FPUButtonActionListener* fpuButtonActionListener;
|
|
|
|
|
|
class CPUSpeedButtonActionListener : public gcn::ActionListener
|
|
{
|
|
public:
|
|
void action(const gcn::ActionEvent& actionEvent) override
|
|
{
|
|
if (actionEvent.getSource() == opt7Mhz)
|
|
changed_prefs.m68k_speed = M68K_SPEED_7MHZ_CYCLES;
|
|
else if (actionEvent.getSource() == opt14Mhz)
|
|
changed_prefs.m68k_speed = M68K_SPEED_14MHZ_CYCLES;
|
|
else if (actionEvent.getSource() == opt28Mhz)
|
|
changed_prefs.m68k_speed = M68K_SPEED_25MHZ_CYCLES;
|
|
else if (actionEvent.getSource() == optFastest)
|
|
changed_prefs.m68k_speed = -1;
|
|
else if (actionEvent.getSource() == optTurbo)
|
|
changed_prefs.m68k_speed = -30;
|
|
}
|
|
};
|
|
|
|
static CPUSpeedButtonActionListener* cpuSpeedButtonActionListener;
|
|
|
|
|
|
class CPU24BitActionListener : public gcn::ActionListener
|
|
{
|
|
public:
|
|
void action(const gcn::ActionEvent& actionEvent) override
|
|
{
|
|
changed_prefs.address_space_24 = chk24Bit->isSelected();
|
|
RefreshPanelCPU();
|
|
}
|
|
};
|
|
|
|
static CPU24BitActionListener* cpu24BitActionListener;
|
|
|
|
class CPUCompActionListener : public gcn::ActionListener
|
|
{
|
|
public:
|
|
void action(const gcn::ActionEvent& actionEvent) override
|
|
{
|
|
if (chkCPUCompatible->isSelected())
|
|
{
|
|
changed_prefs.cpu_compatible = true;
|
|
changed_prefs.cachesize = 0;
|
|
}
|
|
else
|
|
{
|
|
changed_prefs.cpu_compatible = false;
|
|
}
|
|
RefreshPanelCPU();
|
|
}
|
|
};
|
|
|
|
static CPUCompActionListener* cpuCompActionListener;
|
|
|
|
|
|
class JITActionListener : public gcn::ActionListener
|
|
{
|
|
public:
|
|
void action(const gcn::ActionEvent& actionEvent) override
|
|
{
|
|
if (actionEvent.getSource() == chkJIT)
|
|
{
|
|
if (chkJIT->isSelected())
|
|
{
|
|
changed_prefs.cpu_compatible = false;
|
|
changed_prefs.cachesize = MAX_JIT_CACHE;
|
|
changed_prefs.compfpu = true;
|
|
}
|
|
else
|
|
{
|
|
changed_prefs.cachesize = 0;
|
|
changed_prefs.compfpu = false;
|
|
}
|
|
}
|
|
else if (actionEvent.getSource() == chkFPUJIT)
|
|
{
|
|
changed_prefs.compfpu = chkFPUJIT->isSelected();
|
|
}
|
|
RefreshPanelCPU();
|
|
}
|
|
};
|
|
|
|
static JITActionListener* jitActionListener;
|
|
|
|
class FPUActionListener : public gcn::ActionListener
|
|
{
|
|
public:
|
|
void action(const gcn::ActionEvent& actionEvent) override
|
|
{
|
|
if (actionEvent.getSource() == chkFPUstrict)
|
|
{
|
|
changed_prefs.fpu_strict = chkFPUstrict->isSelected();
|
|
}
|
|
RefreshPanelCPU();
|
|
}
|
|
};
|
|
|
|
static FPUActionListener* fpuActionListener;
|
|
|
|
void InitPanelCPU(const struct _ConfigCategory& category)
|
|
{
|
|
cpuButtonActionListener = new CPUButtonActionListener();
|
|
cpu24BitActionListener = new CPU24BitActionListener();
|
|
cpuCompActionListener = new CPUCompActionListener();
|
|
jitActionListener = new JITActionListener();
|
|
fpuActionListener = new FPUActionListener();
|
|
|
|
optCPU68000 = new gcn::UaeRadioButton("68000", "radiocpugroup");
|
|
optCPU68000->addActionListener(cpuButtonActionListener);
|
|
optCPU68010 = new gcn::UaeRadioButton("68010", "radiocpugroup");
|
|
optCPU68010->addActionListener(cpuButtonActionListener);
|
|
optCPU68020 = new gcn::UaeRadioButton("68020", "radiocpugroup");
|
|
optCPU68020->addActionListener(cpuButtonActionListener);
|
|
optCPU68030 = new gcn::UaeRadioButton("68030", "radiocpugroup");
|
|
optCPU68030->addActionListener(cpuButtonActionListener);
|
|
optCPU68040 = new gcn::UaeRadioButton("68040", "radiocpugroup");
|
|
optCPU68040->addActionListener(cpuButtonActionListener);
|
|
|
|
chk24Bit = new gcn::UaeCheckBox("24-bit addressing", true);
|
|
chk24Bit->setId("CPU24Bit");
|
|
chk24Bit->addActionListener(cpu24BitActionListener);
|
|
|
|
chkCPUCompatible = new gcn::UaeCheckBox("More compatible", true);
|
|
chkCPUCompatible->setId("CPUComp");
|
|
chkCPUCompatible->addActionListener(cpuCompActionListener);
|
|
|
|
chkJIT = new gcn::UaeCheckBox("JIT", true);
|
|
chkJIT->setId("JIT");
|
|
chkJIT->addActionListener(jitActionListener);
|
|
|
|
grpCPU = new gcn::Window("CPU");
|
|
grpCPU->setPosition(DISTANCE_BORDER, DISTANCE_BORDER);
|
|
grpCPU->add(optCPU68000, 5, 10);
|
|
grpCPU->add(optCPU68010, 5, 40);
|
|
grpCPU->add(optCPU68020, 5, 70);
|
|
grpCPU->add(optCPU68030, 5, 100);
|
|
grpCPU->add(optCPU68040, 5, 130);
|
|
grpCPU->add(chk24Bit, 5, 170);
|
|
grpCPU->add(chkCPUCompatible, 5, 200);
|
|
grpCPU->add(chkJIT, 5, 230);
|
|
grpCPU->setMovable(false);
|
|
grpCPU->setSize(175, 275);
|
|
grpCPU->setBaseColor(gui_baseCol);
|
|
|
|
category.panel->add(grpCPU);
|
|
|
|
fpuButtonActionListener = new FPUButtonActionListener();
|
|
|
|
optFPUnone = new gcn::UaeRadioButton("None", "radiofpugroup");
|
|
optFPUnone->setId("FPUnone");
|
|
optFPUnone->addActionListener(fpuButtonActionListener);
|
|
|
|
optFPU68881 = new gcn::UaeRadioButton("68881", "radiofpugroup");
|
|
optFPU68881->addActionListener(fpuButtonActionListener);
|
|
|
|
optFPU68882 = new gcn::UaeRadioButton("68882", "radiofpugroup");
|
|
optFPU68882->addActionListener(fpuButtonActionListener);
|
|
|
|
optFPUinternal = new gcn::UaeRadioButton("CPU internal", "radiofpugroup");
|
|
optFPUinternal->addActionListener(fpuButtonActionListener);
|
|
|
|
chkFPUstrict = new gcn::UaeCheckBox("More compatible", true);
|
|
chkFPUstrict->setId("FPUstrict");
|
|
chkFPUstrict->addActionListener(fpuActionListener);
|
|
|
|
chkFPUJIT = new gcn::UaeCheckBox("FPU JIT", true);
|
|
chkFPUJIT->setId("FPUJIT");
|
|
chkFPUJIT->addActionListener(jitActionListener);
|
|
|
|
grpFPU = new gcn::Window("FPU");
|
|
grpFPU->setPosition(DISTANCE_BORDER + grpCPU->getWidth() + DISTANCE_NEXT_X, DISTANCE_BORDER);
|
|
grpFPU->add(optFPUnone, 5, 10);
|
|
grpFPU->add(optFPU68881, 5, 40);
|
|
grpFPU->add(optFPU68882, 5, 70);
|
|
grpFPU->add(optFPUinternal, 5, 100);
|
|
grpFPU->add(chkFPUstrict, 5, 140);
|
|
grpFPU->add(chkFPUJIT, 5, 170);
|
|
grpFPU->setMovable(false);
|
|
grpFPU->setSize(185, 215);
|
|
grpFPU->setBaseColor(gui_baseCol);
|
|
|
|
category.panel->add(grpFPU);
|
|
|
|
cpuSpeedButtonActionListener = new CPUSpeedButtonActionListener();
|
|
|
|
opt7Mhz = new gcn::UaeRadioButton("7 Mhz", "radiocpuspeedgroup");
|
|
opt7Mhz->addActionListener(cpuSpeedButtonActionListener);
|
|
|
|
opt14Mhz = new gcn::UaeRadioButton("14 Mhz", "radiocpuspeedgroup");
|
|
opt14Mhz->addActionListener(cpuSpeedButtonActionListener);
|
|
|
|
opt28Mhz = new gcn::UaeRadioButton("25 Mhz", "radiocpuspeedgroup");
|
|
opt28Mhz->addActionListener(cpuSpeedButtonActionListener);
|
|
|
|
optFastest = new gcn::UaeRadioButton("Fastest", "radiocpuspeedgroup");
|
|
optFastest->addActionListener(cpuSpeedButtonActionListener);
|
|
|
|
optTurbo = new gcn::UaeRadioButton("Turbo", "radiocpuspeedgroup");
|
|
optTurbo->addActionListener(cpuSpeedButtonActionListener);
|
|
|
|
grpCPUSpeed = new gcn::Window("CPU Speed");
|
|
grpCPUSpeed->setPosition(grpFPU->getX() + grpFPU->getWidth() + DISTANCE_NEXT_X, DISTANCE_BORDER);
|
|
grpCPUSpeed->add(opt7Mhz, 5, 10);
|
|
grpCPUSpeed->add(opt14Mhz, 5, 40);
|
|
grpCPUSpeed->add(opt28Mhz, 5, 70);
|
|
grpCPUSpeed->add(optFastest, 5, 100);
|
|
grpCPUSpeed->add(optTurbo, 5, 130);
|
|
grpCPUSpeed->setMovable(false);
|
|
grpCPUSpeed->setSize(95, 200);
|
|
grpCPUSpeed->setBaseColor(gui_baseCol);
|
|
|
|
category.panel->add(grpCPUSpeed);
|
|
|
|
RefreshPanelCPU();
|
|
}
|
|
|
|
|
|
void ExitPanelCPU()
|
|
{
|
|
delete optCPU68000;
|
|
delete optCPU68010;
|
|
delete optCPU68020;
|
|
delete optCPU68030;
|
|
delete optCPU68040;
|
|
delete chk24Bit;
|
|
delete chkCPUCompatible;
|
|
delete chkJIT;
|
|
delete grpCPU;
|
|
delete cpuButtonActionListener;
|
|
delete cpu24BitActionListener;
|
|
delete cpuCompActionListener;
|
|
delete jitActionListener;
|
|
|
|
delete optFPUnone;
|
|
delete optFPU68881;
|
|
delete optFPU68882;
|
|
delete optFPUinternal;
|
|
delete chkFPUstrict;
|
|
delete chkFPUJIT;
|
|
delete grpFPU;
|
|
delete fpuButtonActionListener;
|
|
delete fpuActionListener;
|
|
|
|
delete opt7Mhz;
|
|
delete opt14Mhz;
|
|
delete opt28Mhz;
|
|
delete optFastest;
|
|
delete optTurbo;
|
|
delete grpCPUSpeed;
|
|
delete cpuSpeedButtonActionListener;
|
|
}
|
|
|
|
|
|
void RefreshPanelCPU()
|
|
{
|
|
if (changed_prefs.cpu_model == 68000)
|
|
optCPU68000->setSelected(true);
|
|
else if (changed_prefs.cpu_model == 68010)
|
|
optCPU68010->setSelected(true);
|
|
else if (changed_prefs.cpu_model == 68020)
|
|
optCPU68020->setSelected(true);
|
|
else if (changed_prefs.cpu_model == 68030)
|
|
optCPU68030->setSelected(true);
|
|
else if (changed_prefs.cpu_model == 68040)
|
|
optCPU68040->setSelected(true);
|
|
|
|
chk24Bit->setSelected(changed_prefs.address_space_24);
|
|
chk24Bit->setEnabled(changed_prefs.cpu_model == 68020);
|
|
chkCPUCompatible->setSelected(changed_prefs.cpu_compatible > 0);
|
|
chkCPUCompatible->setEnabled(changed_prefs.cpu_model <= 68010);
|
|
chkJIT->setEnabled(changed_prefs.cpu_model > 68010);
|
|
chkJIT->setSelected(changed_prefs.cachesize > 0);
|
|
|
|
switch (changed_prefs.fpu_model)
|
|
{
|
|
case 68881:
|
|
optFPU68881->setSelected(true);
|
|
break;
|
|
case 68882:
|
|
optFPU68882->setSelected(true);
|
|
break;
|
|
case 68040:
|
|
optFPUinternal->setSelected(true);
|
|
break;
|
|
default:
|
|
optFPUnone->setSelected(true);
|
|
break;
|
|
}
|
|
optFPU68881->setEnabled(changed_prefs.cpu_model >= 68020 && changed_prefs.cpu_model < 68040);
|
|
optFPU68882->setEnabled(changed_prefs.cpu_model >= 68020 && changed_prefs.cpu_model < 68040);
|
|
optFPUinternal->setEnabled(changed_prefs.cpu_model == 68040);
|
|
|
|
chkFPUstrict->setSelected(changed_prefs.fpu_strict);
|
|
|
|
#ifdef USE_JIT_FPU
|
|
chkFPUJIT->setEnabled(changed_prefs.cachesize > 0);
|
|
chkFPUJIT->setSelected(changed_prefs.compfpu);
|
|
#else
|
|
chkFPUJIT->setSelected(false);
|
|
chkFPUJIT->setEnabled(false);
|
|
#endif
|
|
|
|
if (changed_prefs.m68k_speed == M68K_SPEED_7MHZ_CYCLES)
|
|
opt7Mhz->setSelected(true);
|
|
else if (changed_prefs.m68k_speed == M68K_SPEED_14MHZ_CYCLES)
|
|
opt14Mhz->setSelected(true);
|
|
else if (changed_prefs.m68k_speed == M68K_SPEED_25MHZ_CYCLES)
|
|
opt28Mhz->setSelected(true);
|
|
else if (changed_prefs.m68k_speed == -1)
|
|
optFastest->setSelected(true);
|
|
else if (changed_prefs.m68k_speed == -30)
|
|
optTurbo->setSelected(true);
|
|
}
|
|
|
|
bool HelpPanelCPU(std::vector<std::string>& helptext)
|
|
{
|
|
helptext.clear();
|
|
helptext.emplace_back("Select the required Amiga CPU (68000 - 68040).");
|
|
helptext.emplace_back("If you select 68020, you can choose between 24-bit addressing (68EC020) or 32-bit");
|
|
helptext.emplace_back("addressing (68020). The option \"More compatible\" is only available if 68000 or 68010");
|
|
helptext.emplace_back("is selected and emulates simple prefetch of the 68000. This may improve compatibility");
|
|
helptext.emplace_back("in few situations but is not required for most games and demos.");
|
|
helptext.emplace_back(" ");
|
|
helptext.emplace_back("JIT enables the Just-in-time compiler. This may break compatibility in some games.");
|
|
helptext.emplace_back("");
|
|
helptext.emplace_back("The available FPU models depending on the selected CPU.");
|
|
helptext.emplace_back("The option \"More compatible\" activates more accurate rounding and compare of two floats.");
|
|
helptext.emplace_back(" ");
|
|
helptext.emplace_back("With \"CPU Speed\" you can choose the clock rate of the Amiga.");
|
|
helptext.emplace_back("Use 7MHz for A500 games or 14MHz for A1200 ones. Fastest uses more emulation time");
|
|
helptext.emplace_back("for the CPU, and Turbo will give only the minimum time to the chipset, using as");
|
|
helptext.emplace_back("much as possible for the CPU, usually resulting in dropping frames also.");
|
|
helptext.emplace_back(" ");
|
|
helptext.emplace_back("In current version, you will not see a difference in the performance for 68020,");
|
|
helptext.emplace_back("68030 and 68040 CPUs. The CPU cycles for the opcodes are based on 68020. The different");
|
|
helptext.emplace_back("cycles for 68030 and 68040 may come in a later version.");
|
|
return true;
|
|
}
|