ShuriZma
/
bsnes
mirror of https://github.com/bsnes-emu/bsnes.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update to v103r09 release. 

byuu says:

Changelog:

  - gba/apu: fixed wave RAM nibble ordering (fixes audio in Castlevania,
    PocketNES)
  - emulator: restructured video information to just a single
    videoResolution() → VideoResolution function
      - returns "projected size" (between 160x144 and 320x240)
      - "internal buffer size" (up to 1280x480)
      - returns aspect correction multiplier that is to be applied to
        the width field
          - the value could be < 1.0 to handle systems with taller
            pixels; although higan doesn't emulate such a system
  - tomoko: all calculations for scaling and overscan masking are done
    by the GUI now
  - tomoko: aspect correction can be enabled in either windowed or
    fullscreen mode separately; moved to Video settings panel
  - tomoko: video scaling multipliers (against 320x240) can now me
    modified from the default (2,3,4) via the configuration file
      - use this as a really barebones way of supporting high DPI
        monitors; although the GUI elements won't scale nicely
      - if you set a value less than two, or greater than your
        resolution divided by 320x240, it's your own fault when things
        blow up. I'm not babysitting anyone with advanced config-file
        only options.
  - tomoko: added new adaptive windowed mode
      - when enabled, the window will shrink to eliminate any black
        borders when loading a game or changing video settings. The
        window will not reposition itself.
  - tomoko: added new adaptive fullscreen mode
      - when enabled, the integral scaling will be disabled for
        fullscreen mode, forcing the video to fill at least one
        direction of the video monitor completely.

I expect we will be bikeshedding for the next month on how to describe
the new video options, where they should appear in the GUI, changes
people want, etc ... but suffice to say, I'm happy with the
functionality, so I don't intend to make changes to -what- things do,
but I will entertain better ways to name things.
This commit is contained in:
Tim Allen 2017-07-06 18:29:12 +10:00
parent 191a71b291
commit 7af270aa59
26 changed files with 146 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
higan/emulator/emulator.hpp
View File

@ -12,7 +12,7 @@ using namespace nall;
namespace Emulator {
static const string Name = "higan";
static const string Version = "103.08";
static const string Version = "103.09";
static const string Author = "byuu";
static const string License = "GPLv3";
static const string Website = "http://byuu.org/";

12
higan/emulator/interface.hpp
View File

@ -43,10 +43,14 @@ struct Interface {
virtual auto title() -> string = 0;
//video information
struct VideoSize { uint width, height; };
virtual auto videoResolution() -> VideoSize = 0;
virtual auto videoSize(uint width, uint height, bool aspectCorrection, uint cropWidth = 0, uint cropHeight = 0) -> VideoSize = 0;
virtual auto videoCrop(const uint32*& data, uint& width, uint& height, uint cropWidth, uint cropHeight) -> void {}
struct VideoResolution {
uint width;
uint height;
uint internalWidth;
uint internalHeight;
double aspectCorrection;
};
virtual auto videoResolution() -> VideoResolution = 0;
virtual auto videoColors() -> uint32 = 0;
virtual auto videoColor(uint32 color) -> uint64 = 0;

17
higan/fc/interface/interface.cpp
View File

@ -44,21 +44,8 @@ auto Interface::title() -> string {
return cartridge.title();
}
auto Interface::videoResolution() -> VideoSize {
return {256, 240};
}
auto Interface::videoSize(uint width, uint height, bool aspectCorrection, uint cropHorizontal, uint cropVertical) -> VideoSize {
double widthDivider = (256 - cropHorizontal * 2) * (aspectCorrection ? 8.0 / 7.0 : 1.0);
double heightDivider = (240 - cropVertical * 2);
uint multiplier = min(width / widthDivider, height / heightDivider);
return {uint(widthDivider * multiplier), uint(heightDivider * multiplier)};
}
auto Interface::videoCrop(const uint32*& data, uint& width, uint& height, uint cropHorizontal, uint cropVertical) -> void {
data += cropVertical * 256 + cropHorizontal;
width -= cropHorizontal * 2;
height -= cropVertical * 2;
auto Interface::videoResolution() -> VideoResolution {
return {256, 240, 256, 240, 8.0 / 7.0};
}
auto Interface::videoColors() -> uint32 {

4
higan/fc/interface/interface.hpp
View File

@ -26,9 +26,7 @@ struct Interface : Emulator::Interface {
auto manifest() -> string override;
auto title() -> string override;
auto videoResolution() -> VideoSize override;
auto videoSize(uint width, uint height, bool aspectCorrection, uint cropHorizontal, uint cropVertical) -> VideoSize override;
auto videoCrop(const uint32*& data, uint& width, uint& height, uint cropHorizontal, uint cropVertical) -> void override;
auto videoResolution() -> VideoResolution override;
auto videoColors() -> uint32 override;
auto videoColor(uint32 color) -> uint64 override;

11
higan/gb/interface/interface.cpp
View File

@ -33,15 +33,8 @@ auto Interface::title() -> string {
return cartridge.title();
}
auto Interface::videoResolution() -> VideoSize {
return {160, 144};
}
auto Interface::videoSize(uint width, uint height, bool, uint, uint) -> VideoSize {
double widthDivider = 160;
double heightDivider = 144;
uint multiplier = min(width / widthDivider, height / heightDivider);
return {uint(widthDivider * multiplier), uint(heightDivider * multiplier)};
auto Interface::videoResolution() -> VideoResolution {
return {160, 144, 160, 144, 1.0};
}
auto Interface::loaded() -> bool {

3
higan/gb/interface/interface.hpp
View File

@ -23,8 +23,7 @@ struct Interface : Emulator::Interface {
auto manifest() -> string override;
auto title() -> string override;
auto videoResolution() -> VideoSize override;
auto videoSize(uint width, uint height, bool, uint, uint) -> VideoSize override;
auto videoResolution() -> VideoResolution override;
auto loaded() -> bool override;
auto sha256() -> string override;

8
higan/gba/apu/wave.cpp
View File

@ -66,14 +66,14 @@ auto APU::Wave::write(uint addr, uint8 byte) -> void {
auto APU::Wave::readram(uint addr) const -> uint8 {
uint8 byte = 0;
byte |= pattern[!bank << 5 | addr << 1 | 0] << 0;
byte |= pattern[!bank << 5 | addr << 1 | 1] << 4;
byte |= pattern[!bank << 5 | addr << 1 | 0] << 4;
byte |= pattern[!bank << 5 | addr << 1 | 1] << 0;
return byte;
}
auto APU::Wave::writeram(uint addr, uint8 byte) -> void {
pattern[!bank << 5 | addr << 1 | 0] = byte >> 0;
pattern[!bank << 5 | addr << 1 | 1] = byte >> 4;
pattern[!bank << 5 | addr << 1 | 0] = byte >> 4;
pattern[!bank << 5 | addr << 1 | 1] = byte >> 0;
}
auto APU::Wave::power() -> void {

13
higan/gba/interface/interface.cpp
View File

@ -39,21 +39,14 @@ auto Interface::title() -> string {
return cartridge.title();
}
auto Interface::videoResolution() -> VideoSize {
auto Interface::videoResolution() -> VideoResolution {
if(!settings.rotateLeft) {
return {240, 160};
return {240, 160, 240, 160, 1.0};
} else {
return {160, 240};
return {160, 240, 160, 240, 1.0};
}
}
auto Interface::videoSize(uint width, uint height, bool, uint, uint) -> VideoSize {
double widthDivider = videoResolution().width;
double heightDivider = videoResolution().height;
uint multiplier = min(width / widthDivider, height / heightDivider);
return {uint(widthDivider * multiplier), uint(heightDivider * multiplier)};
}
auto Interface::videoColors() -> uint32 {
return 1 << 15;
}

3
higan/gba/interface/interface.hpp
View File

@ -23,8 +23,7 @@ struct Interface : Emulator::Interface {
auto manifest() -> string override;
auto title() -> string override;
auto videoResolution() -> VideoSize override;
auto videoSize(uint width, uint height, bool, uint, uint) -> VideoSize override;
auto videoResolution() -> VideoResolution override;
auto videoColors() -> uint32 override;
auto videoColor(uint32 color) -> uint64 override;

19
higan/md/interface/interface.cpp
View File

@ -52,23 +52,8 @@ auto Interface::title() -> string {
return cartridge.title();
}
auto Interface::videoResolution() -> VideoSize {
return {1280, 480};
}
auto Interface::videoSize(uint width, uint height, bool aspectCorrection, uint cropHorizontal, uint cropVertical) -> VideoSize {
double widthDivider = (320 - cropHorizontal * 2);
double heightDivider = (240 - cropVertical * 2);
uint multiplier = min(width / widthDivider, height / heightDivider);
return {uint(widthDivider * multiplier), uint(heightDivider * multiplier)};
}
auto Interface::videoCrop(const uint32*& data, uint& width, uint& height, uint cropHorizontal, uint cropVertical) -> void {
cropHorizontal *= 4;
cropVertical *= 2;
data += cropVertical * 1280 + cropHorizontal;
width -= cropHorizontal * 2;
height -= cropVertical * 2;
auto Interface::videoResolution() -> VideoResolution {
return {320, 240, 1280, 480, 1.0};
}
auto Interface::videoColors() -> uint32 {

4
higan/md/interface/interface.hpp
View File

@ -26,9 +26,7 @@ struct Interface : Emulator::Interface {
auto manifest() -> string override;
auto title() -> string override;
auto videoResolution() -> VideoSize override;
auto videoSize(uint width, uint height, bool aspectCorrection, uint cropHorizontal, uint cropVertical) -> VideoSize override;
auto videoCrop(const uint32*& data, uint& width, uint& height, uint cropHorizontal, uint cropVertical) -> void override;
auto videoResolution() -> VideoResolution override;
auto videoColors() -> uint32 override;
auto videoColor(uint32 color) -> uint64 override;

11
higan/ms/interface/game-gear.cpp
View File

@ -21,15 +21,8 @@ GameGearInterface::GameGearInterface() {
ports.append(move(hardware));
}
auto GameGearInterface::videoResolution() -> VideoSize {
return {160, 144};
}
auto GameGearInterface::videoSize(uint width, uint height, bool, uint, uint) -> VideoSize {
double widthDivider = 160;
double heightDivider = 144;
uint multiplier = min(width / widthDivider, height / heightDivider);
return {uint(widthDivider * multiplier), uint(heightDivider * multiplier)};
auto GameGearInterface::videoResolution() -> VideoResolution {
return {160, 144, 160, 144, 1.0};
}
auto GameGearInterface::videoColors() -> uint32 {

7
higan/ms/interface/interface.hpp
View File

@ -50,9 +50,7 @@ struct MasterSystemInterface : Interface {
MasterSystemInterface();
auto videoResolution() -> VideoSize override;
auto videoSize(uint width, uint height, bool aspectCorrection, uint cropWidth, uint cropHeight) -> VideoSize override;
auto videoCrop(const uint32*& data, uint& width, uint& height, uint cropWidth, uint cropHeight) -> void override;
auto videoResolution() -> VideoResolution override;
auto videoColors() -> uint32 override;
auto videoColor(uint32 color) -> uint64 override;
@ -66,8 +64,7 @@ struct GameGearInterface : Interface {
GameGearInterface();
auto videoResolution() -> VideoSize override;
auto videoSize(uint width, uint height, bool, uint, uint) -> VideoSize override;
auto videoResolution() -> VideoResolution override;
auto videoColors() -> uint32 override;
auto videoColor(uint32 color) -> uint64 override;

17
higan/ms/interface/master-system.cpp
View File

@ -36,21 +36,8 @@ MasterSystemInterface::MasterSystemInterface() {
ports.append(move(controllerPort2));
}
auto MasterSystemInterface::videoResolution() -> VideoSize {
return {256, 240};
}
auto MasterSystemInterface::videoSize(uint width, uint height, bool aspectCorrection, uint cropHorizontal, uint cropVertical) -> VideoSize {
double widthDivider = (256 - cropHorizontal * 2) * (aspectCorrection ? 8.0 / 7.0 : 1.0);
double heightDivider = (240 - cropVertical * 2);
uint multiplier = min(width / widthDivider, height / heightDivider);
return {uint(widthDivider * multiplier), uint(heightDivider * multiplier)};
}
auto MasterSystemInterface::videoCrop(const uint32*& data, uint& width, uint& height, uint cropHorizontal, uint cropVertical) -> void {
data += cropVertical * 256 + cropHorizontal;
width -= cropHorizontal * 2;
height -= cropVertical * 2;
auto MasterSystemInterface::videoResolution() -> VideoResolution {
return {256, 240, 256, 240, 8.0 / 7.0};
}
auto MasterSystemInterface::videoColors() -> uint32 {

18
higan/pce/interface/interface.cpp
View File

@ -39,22 +39,8 @@ auto Interface::title() -> string {
return cartridge.title();
}
auto Interface::videoResolution() -> VideoSize {
return {1120, 240};
}
auto Interface::videoSize(uint width, uint height, bool aspectCorrection, uint cropHorizontal, uint cropVertical) -> VideoSize {
double widthDivider = (280 - cropHorizontal * 2) * (aspectCorrection ? 8.0 / 7.0 : 1.0);
double heightDivider = (240 - cropVertical * 2);
uint multiplier = min(width / widthDivider, height / heightDivider);
return {uint(widthDivider * multiplier), uint(heightDivider * multiplier)};
}
auto Interface::videoCrop(const uint32*& data, uint& width, uint& height, uint cropHorizontal, uint cropVertical) -> void {
cropHorizontal *= 4;
data += cropVertical * 1120 + cropHorizontal;
width -= cropHorizontal * 2;
height -= cropVertical * 2;
auto Interface::videoResolution() -> VideoResolution {
return {280, 240, 1120, 240, 8.0 / 7.0};
}
auto Interface::videoColors() -> uint32 {

4
higan/pce/interface/interface.hpp
View File

@ -23,9 +23,7 @@ struct Interface : Emulator::Interface {
auto manifest() -> string override;
auto title() -> string override;
auto videoResolution() -> VideoSize override;
auto videoSize(uint width, uint height, bool aspectCorrection, uint cropHorizontal, uint cropVertical) -> VideoSize override;
auto videoCrop(const uint32*& data, uint& width, uint& height, uint cropHorizontal, uint cropVertical) -> void override;
auto videoResolution() -> VideoResolution override;
auto videoColors() -> uint32 override;
auto videoColor(uint32 color) -> uint64 override;

19
higan/sfc/interface/interface.cpp
View File

@ -118,23 +118,8 @@ auto Interface::title() -> string {
return cartridge.title();
}
auto Interface::videoResolution() -> VideoSize {
return {512, 480};
}
auto Interface::videoSize(uint width, uint height, bool aspectCorrection, uint cropHorizontal, uint cropVertical) -> VideoSize {
double widthDivider = (256 - cropHorizontal * 2) * (aspectCorrection ? 8.0 / 7.0 : 1.0);
double heightDivider = (240 - cropVertical * 2);
uint multiplier = min(width / widthDivider, height / heightDivider);
return {uint(widthDivider * multiplier), uint(heightDivider * multiplier)};
}
auto Interface::videoCrop(const uint32*& data, uint& width, uint& height, uint cropHorizontal, uint cropVertical) -> void {
cropHorizontal *= 2;
cropVertical *= 2;
data += cropVertical * 512 + cropHorizontal;
width -= cropHorizontal * 2;
height -= cropVertical * 2;
auto Interface::videoResolution() -> VideoResolution {
return {256, 240, 512, 480, 8.0 / 7.0};
}
auto Interface::videoColors() -> uint32 {

4
higan/sfc/interface/interface.hpp
View File

@ -38,9 +38,7 @@ struct Interface : Emulator::Interface {
auto manifest() -> string override;
auto title() -> string override;
auto videoResolution() -> VideoSize override;
auto videoSize(uint width, uint height, bool aspectCorrection, uint cropWidth, uint cropHeight) -> VideoSize override;
auto videoCrop(const uint32*& data, uint& width, uint& height, uint cropWidth, uint cropHeight) -> void override;
auto videoResolution() -> VideoResolution override;
auto videoColors() -> uint32 override;
auto videoColor(uint32 color) -> uint64 override;

12
higan/target-tomoko/configuration/configuration.cpp
View File

@ -16,8 +16,6 @@ Settings::Settings() {
set("Video/Driver", ruby::Video::optimalDriver());
set("Video/Synchronize", false);
set("Video/Scale", "Small");
set("Video/AspectCorrection", true);
set("Video/Shader", "Blur");
set("Video/BlurEmulation", true);
set("Video/ColorEmulation", true);
@ -31,6 +29,16 @@ Settings::Settings() {
set("Video/Overscan/Horizontal", 8);
set("Video/Overscan/Vertical", 8);
set("Video/Windowed/AspectCorrection", true);
set("Video/Windowed/Adaptive", false);
set("Video/Windowed/Multiplier", "Small");
set("Video/Windowed/Multiplier/Small", 2);
set("Video/Windowed/Multiplier/Medium", 3);
set("Video/Windowed/Multiplier/Large", 4);
set("Video/Fullscreen/AspectCorrection", true);
set("Video/Fullscreen/Adaptive", false);
set("Audio/Driver", ruby::Audio::optimalDriver());
set("Audio/Device", "");
set("Audio/Exclusive", false);

92
higan/target-tomoko/presentation/presentation.cpp
View File

@ -47,23 +47,19 @@ Presentation::Presentation() {
settingsMenu.setText("Settings");
videoScaleMenu.setText("Video Scale");
if(settings["Video/Scale"].text() == "Small") videoScaleSmall.setChecked();
if(settings["Video/Scale"].text() == "Medium") videoScaleMedium.setChecked();
if(settings["Video/Scale"].text() == "Large") videoScaleLarge.setChecked();
if(settings["Video/Windowed/Multiplier"].text() == "Small") videoScaleSmall.setChecked();
if(settings["Video/Windowed/Multiplier"].text() == "Medium") videoScaleMedium.setChecked();
if(settings["Video/Windowed/Multiplier"].text() == "Large") videoScaleLarge.setChecked();
videoScaleSmall.setText("Small").onActivate([&] {
settings["Video/Scale"].setValue("Small");
settings["Video/Windowed/Multiplier"].setValue("Small");
resizeViewport();
});
videoScaleMedium.setText("Medium").onActivate([&] {
settings["Video/Scale"].setValue("Medium");
settings["Video/Windowed/Multiplier"].setValue("Medium");
resizeViewport();
});
videoScaleLarge.setText("Large").onActivate([&] {
settings["Video/Scale"].setValue("Large");
resizeViewport();
});
aspectCorrection.setText("Aspect Correction").setChecked(settings["Video/AspectCorrection"].boolean()).onToggle([&] {
settings["Video/AspectCorrection"].setValue(aspectCorrection.checked());
settings["Video/Windowed/Multiplier"].setValue("Large");
resizeViewport();
});
videoEmulationMenu.setText("Video Emulation");
@ -243,35 +239,59 @@ auto Presentation::resizeViewport() -> void {
//clear video area before resizing to avoid seeing distorted video momentarily
clearViewport();
uint scale = 2;
if(settings["Video/Scale"].text() == "Small" ) scale = 2;
if(settings["Video/Scale"].text() == "Medium") scale = 3;
if(settings["Video/Scale"].text() == "Large" ) scale = 4;
uint windowWidth = 0, windowHeight = 0;
bool aspectCorrection = true;
if(!fullScreen()) {
windowWidth = 320 * scale;
windowHeight = 240 * scale;
aspectCorrection = settings["Video/AspectCorrection"].boolean();
} else {
windowWidth = geometry().width();
windowHeight = geometry().height();
}
if(!fullScreen()) setSize({windowWidth, windowHeight});
if(!emulator) {
viewport.setGeometry({0, 0, windowWidth, windowHeight});
} else {
uint overscanWidth = 0, overscanHeight = 0;
double emulatorWidth = 320;
double emulatorHeight = 240;
double aspectCorrection = 1.0;
if(emulator) {
auto resolution = emulator->videoResolution();
emulatorWidth = resolution.width;
emulatorHeight = resolution.height;
aspectCorrection = resolution.aspectCorrection;
if(emulator->information.overscan && settings["Video/Overscan/Mask"].boolean()) {
overscanWidth = settings["Video/Overscan/Horizontal"].natural();
overscanHeight = settings["Video/Overscan/Vertical" ].natural();
uint overscanHorizontal = settings["Video/Overscan/Horizontal"].natural();
uint overscanVertical = settings["Video/Overscan/Vertical"].natural();
emulatorWidth -= overscanHorizontal * 2;
emulatorHeight -= overscanVertical * 2;
}
}
if(!fullScreen()) {
if(settings["Video/Windowed/AspectCorrection"].boolean()) emulatorWidth *= aspectCorrection;
uint viewportMultiplier = 2;
if(settings["Video/Windowed/Multiplier"].text() == "Small") viewportMultiplier = settings["Video/Windowed/Multiplier/Small"].natural();
if(settings["Video/Windowed/Multiplier"].text() == "Medium") viewportMultiplier = settings["Video/Windowed/Multiplier/Medium"].natural();
if(settings["Video/Windowed/Multiplier"].text() == "Large") viewportMultiplier = settings["Video/Windowed/Multiplier/Large"].natural();
uint viewportWidth = 320 * viewportMultiplier;
uint viewportHeight = 240 * viewportMultiplier;
uint multiplier = min(viewportWidth / emulatorWidth, viewportHeight / emulatorHeight);
if(!settings["Video/Windowed/Adaptive"].boolean()) {
emulatorWidth *= multiplier;
emulatorHeight *= multiplier;
setSize({viewportWidth, viewportHeight});
viewport.setGeometry({
(viewportWidth - emulatorWidth) / 2, (viewportHeight - emulatorHeight) / 2,
emulatorWidth, emulatorHeight
});
} else {
setSize({emulatorWidth * multiplier, emulatorHeight * multiplier});
viewport.setGeometry({0, 0, emulatorWidth * multiplier, emulatorHeight * multiplier});
}
} else {
if(settings["Video/Fullscreen/AspectCorrection"].boolean()) emulatorWidth *= aspectCorrection;
uint viewportWidth = geometry().width();
uint viewportHeight = geometry().height();
if(!settings["Video/Fullscreen/Adaptive"].boolean()) {
uint multiplier = min(viewportWidth / emulatorWidth, viewportHeight / emulatorHeight);
emulatorWidth *= multiplier;
emulatorHeight *= multiplier;
} else {
double multiplier = min(viewportWidth / emulatorWidth, viewportHeight / emulatorHeight);
emulatorWidth *= multiplier;
emulatorHeight *= multiplier;
}
auto videoSize = emulator->videoSize(windowWidth, windowHeight, aspectCorrection, overscanWidth, overscanHeight);
viewport.setGeometry({
(windowWidth - videoSize.width) / 2, (windowHeight - videoSize.height) / 2,
videoSize.width, videoSize.height
(viewportWidth - emulatorWidth) / 2, (viewportHeight - emulatorHeight) / 2,
emulatorWidth, emulatorHeight
});
}

2
higan/target-tomoko/presentation/presentation.hpp
View File

@ -31,8 +31,6 @@ struct Presentation : Window {
MenuRadioItem videoScaleMedium{&videoScaleMenu};
MenuRadioItem videoScaleLarge{&videoScaleMenu};
Group videoScales{&videoScaleSmall, &videoScaleMedium, &videoScaleLarge};
MenuSeparator videoScaleSeparator{&videoScaleMenu};
MenuCheckItem aspectCorrection{&videoScaleMenu};
Menu videoEmulationMenu{&settingsMenu};
MenuCheckItem blurEmulation{&videoEmulationMenu};
MenuCheckItem colorEmulation{&videoEmulationMenu};

11
higan/target-tomoko/program/interface.cpp
View File

@ -56,9 +56,14 @@ auto Program::videoRefresh(const uint32* data, uint pitch, uint width, uint heig
pitch >>= 2;
if(emulator->information.overscan && settings["Video/Overscan/Mask"].boolean()) {
uint horizontal = settings["Video/Overscan/Horizontal"].natural();
uint vertical = settings["Video/Overscan/Vertical"].natural();
emulator->videoCrop(data, width, height, horizontal, vertical);
uint overscanHorizontal = settings["Video/Overscan/Horizontal"].natural();
uint overscanVertical = settings["Video/Overscan/Vertical"].natural();
auto resolution = emulator->videoResolution();
overscanHorizontal *= resolution.internalWidth / resolution.width;
overscanVertical *= resolution.internalHeight / resolution.height;
data += overscanVertical * pitch + overscanHorizontal;
width -= overscanHorizontal * 2;
height -= overscanVertical * 2;
}
if(video->lock(output, length, width, height)) {

17
higan/target-tomoko/settings/settings.hpp
View File

@ -2,7 +2,7 @@ struct VideoSettings : TabFrameItem {
VideoSettings(TabFrame*);
VerticalLayout layout{this};
Label colorAdjustmentLabel{&layout, Size{~0, 0}};
Label colorAdjustmentLabel{&layout, Size{~0, 0}, 2};
HorizontalLayout saturationLayout{&layout, Size{~0, 0}};
Label saturationLabel{&saturationLayout, Size{80, 0}};
Label saturationValue{&saturationLayout, Size{50, 0}};
@ -15,7 +15,7 @@ struct VideoSettings : TabFrameItem {
Label luminanceLabel{&luminanceLayout, Size{80, 0}};
Label luminanceValue{&luminanceLayout, Size{50, 0}};
HorizontalSlider luminanceSlider{&luminanceLayout, Size{~0, 0}};
Label overscanMaskLabel{&layout, Size{~0, 0}};
Label overscanMaskLabel{&layout, Size{~0, 0}, 2};
HorizontalLayout horizontalMaskLayout{&layout, Size{~0, 0}};
Label horizontalMaskLabel{&horizontalMaskLayout, Size{80, 0}};
Label horizontalMaskValue{&horizontalMaskLayout, Size{50, 0}};
@ -24,16 +24,25 @@ struct VideoSettings : TabFrameItem {
Label verticalMaskLabel{&verticalMaskLayout, Size{80, 0}};
Label verticalMaskValue{&verticalMaskLayout, Size{50, 0}};
HorizontalSlider verticalMaskSlider{&verticalMaskLayout, Size{~0, 0}};
Label windowedModeLabel{&layout, Size{~0, 0}, 2};
HorizontalLayout windowedModeLayout{&layout, Size{~0, 0}};
CheckLabel windowedModeAspectCorrection{&windowedModeLayout, Size{0, 0}};
CheckLabel windowedModeAdaptive{&windowedModeLayout, Size{0, 0}};
Label fullscreenModeLabel{&layout, Size{~0, 0}, 2};
HorizontalLayout fullscreenModeLayout{&layout, Size{~0, 0}};
CheckLabel fullscreenModeAspectCorrection{&fullscreenModeLayout, Size{0, 0}};
CheckLabel fullscreenModeAdaptive{&fullscreenModeLayout, Size{0, 0}};
auto updateColor() -> void;
auto updateOverscan() -> void;
auto updateViewport() -> void;
};
struct AudioSettings : TabFrameItem {
AudioSettings(TabFrame*);
VerticalLayout layout{this};
Label driverLabel{&layout, Size{~0, 0}};
Label driverLabel{&layout, Size{~0, 0}, 2};
HorizontalLayout controlLayout{&layout, Size{~0, 0}};
Label latencyLabel{&controlLayout, Size{0, 0}};
ComboButton latencyCombo{&controlLayout, Size{~0, 0}};
@ -42,7 +51,7 @@ struct AudioSettings : TabFrameItem {
Label resamplerLabel{&controlLayout, Size{0, 0}};
ComboButton resamplerCombo{&controlLayout, Size{~0, 0}};
CheckLabel exclusiveMode{&layout, Size{~0, 0}};
Label effectsLabel{&layout, Size{~0, 0}};
Label effectsLabel{&layout, Size{~0, 0}, 2};
HorizontalLayout volumeLayout{&layout, Size{~0, 0}};
Label volumeLabel{&volumeLayout, Size{80, 0}};
Label volumeValue{&volumeLayout, Size{50, 0}};

17
higan/target-tomoko/settings/video.cpp
View File

@ -23,8 +23,17 @@ VideoSettings::VideoSettings(TabFrame* parent) : TabFrameItem(parent) {
verticalMaskValue.setAlignment(0.5);
verticalMaskSlider.setLength(25).setPosition(settings["Video/Overscan/Vertical"].natural()).onChange([&] { updateOverscan(); });
windowedModeLabel.setFont(Font().setBold()).setText("Windowed Mode");
windowedModeAspectCorrection.setText("Correct aspect ratio").setChecked(settings["Video/Windowed/AspectCorrection"].boolean()).onToggle([&] { updateViewport(); });
windowedModeAdaptive.setText("Resize window to viewport").setChecked(settings["Video/Windowed/Adaptive"].boolean()).onToggle([&] { updateViewport(); });
fullscreenModeLabel.setFont(Font().setBold()).setText("Fullscreen Mode");
fullscreenModeAspectCorrection.setText("Correct aspect ratio").setChecked(settings["Video/Fullscreen/AspectCorrection"].boolean()).onToggle([&] { updateViewport(); });
fullscreenModeAdaptive.setText("Resize viewport to window").setChecked(settings["Video/Fullscreen/Adaptive"].boolean()).onToggle([&] { updateViewport(); });
updateColor();
updateOverscan();
updateViewport();
}
auto VideoSettings::updateColor() -> void {
@ -44,3 +53,11 @@ auto VideoSettings::updateOverscan() -> void {
verticalMaskValue.setText({verticalMaskSlider.position()});
presentation->resizeViewport();
}
auto VideoSettings::updateViewport() -> void {
settings["Video/Windowed/AspectCorrection"].setValue(windowedModeAspectCorrection.checked());
settings["Video/Windowed/Adaptive"].setValue(windowedModeAdaptive.checked());
settings["Video/Fullscreen/AspectCorrection"].setValue(fullscreenModeAspectCorrection.checked());
settings["Video/Fullscreen/Adaptive"].setValue(fullscreenModeAdaptive.checked());
presentation->resizeViewport();
}

13
higan/ws/interface/interface.cpp
View File

@ -35,21 +35,14 @@ auto Interface::title() -> string {
return cartridge.information.title;
}
auto Interface::videoResolution() -> VideoSize {
auto Interface::videoResolution() -> VideoResolution {
if(!settings.rotateLeft) {
return {224, 144};
return {224, 144, 224, 144, 1.0};
} else {
return {144, 224};
return {144, 224, 144, 224, 1.0};
}
}
auto Interface::videoSize(uint width, uint height, bool, uint, uint) -> VideoSize {
double widthDivider = videoResolution().width;
double heightDivider = videoResolution().height;
uint multiplier = min(width / widthDivider, height / heightDivider);
return {uint(widthDivider * multiplier), uint(heightDivider * multiplier)};
}
auto Interface::loaded() -> bool {
return system.loaded();
}

3
higan/ws/interface/interface.hpp
View File

@ -22,8 +22,7 @@ struct Interface : Emulator::Interface {
auto manifest() -> string override;
auto title() -> string override;
auto videoResolution() -> VideoSize override;
auto videoSize(uint width, uint height, bool, uint, uint) -> VideoSize override;
auto videoResolution() -> VideoResolution override;
auto loaded() -> bool override;
auto sha256() -> string override;