mirror of
https://github.com/bsnes-emu/bsnes.git
synced 2025-02-23 14:42:33 +01:00
4d7bb510f2
byuu says:
Don't let the point release fool you, there are many significant changes in this
release. I will be keeping bsnes releases using a point system until the new
higan release is ready.
Changelog:
- GUI: added high DPI support
- GUI: fixed the state manager image preview
- Windows: added a new waveOut driver with support for dynamic rate control
- Windows: corrected the XAudio 2.1 dynamic rate control support [BearOso]
- Windows: corrected the Direct3D 9.0 fullscreen exclusive window centering
- Windows: fixed XInput controller support on Windows 10
- SFC: added high-level emulation for the DSP1, DSP2, DSP4, ST010, and Cx4
coprocessors
- SFC: fixed a slight rendering glitch in the intro to Megalomania
If the coprocessor firmware is missing, bsnes will fallback on HLE where it is
supported, which is everything other than SD Gundam GX and the two Hayazashi
Nidan Morita Shougi games.
The Windows dynamic rate control works best with Direct3D in fullscreen
exclusive mode. I recommend the waveOut driver over the XAudio 2.1 driver, as it
is not possible to target a single XAudio2 version on all Windows OS releases.
The waveOut driver should work everywhere out of the box.
Note that with DRC, the synchronization source is your monitor, so you will
want to be running at 60hz (NTSC) or 50hz (PAL). If you have an adaptive sync
monitor, you should instead use the WASAPI (exclusive) or ASIO audio driver.
90 lines
3.7 KiB
C++
90 lines
3.7 KiB
C++
#if defined(Hiro_Object)
|
|
struct mObject {
|
|
Declare(Object)
|
|
|
|
mObject();
|
|
virtual ~mObject();
|
|
mObject(const mObject&) = delete;
|
|
mObject& operator=(const mObject&) = delete;
|
|
|
|
explicit operator bool() const;
|
|
|
|
auto abstract() const -> bool;
|
|
auto adjustOffset(int displacement) -> type&;
|
|
auto enabled(bool recursive = false) const -> bool;
|
|
virtual auto focused() const -> bool;
|
|
auto font(bool recursive = false) const -> Font;
|
|
virtual auto group() const -> Group;
|
|
auto offset() const -> int;
|
|
auto parent() const -> mObject*;
|
|
auto parentComboButton(bool recursive = false) const -> mComboButton*;
|
|
auto parentComboEdit(bool recursive = false) const -> mComboEdit*;
|
|
auto parentFrame(bool recursive = false) const -> mFrame*;
|
|
auto parentIconView(bool recursive = false) const -> mIconView*;
|
|
auto parentMenu(bool recursive = false) const -> mMenu*;
|
|
auto parentMenuBar(bool recursive = false) const -> mMenuBar*;
|
|
auto parentPopupMenu(bool recursive = false) const -> mPopupMenu*;
|
|
auto parentSizable(bool recursive = false) const -> mSizable*;
|
|
auto parentTabFrame(bool recursive = false) const -> mTabFrame*;
|
|
auto parentTabFrameItem(bool recursive = false) const -> mTabFrameItem*;
|
|
auto parentTableView(bool recursive = false) const -> mTableView*;
|
|
auto parentTableViewItem(bool recursive = false) const -> mTableViewItem*;
|
|
auto parentTreeView(bool recursive = false) const -> mTreeView*;
|
|
auto parentTreeViewItem(bool recursive = false) const -> mTreeViewItem*;
|
|
auto parentWidget(bool recursive = false) const -> mWidget*;
|
|
auto parentWindow(bool recursive = false) const -> mWindow*;
|
|
virtual auto remove() -> type&;
|
|
virtual auto reset() -> type&;
|
|
virtual auto setEnabled(bool enabled = true) -> type&;
|
|
virtual auto setFocused() -> type&;
|
|
virtual auto setFont(const Font& font = {}) -> type&;
|
|
virtual auto setGroup(sGroup group = {}) -> type&;
|
|
virtual auto setParent(mObject* parent = nullptr, int offset = -1) -> type&;
|
|
virtual auto setVisible(bool visible = true) -> type&;
|
|
auto visible(bool recursive = false) const -> bool;
|
|
|
|
template<typename T = string> auto property(const string& name) const -> T {
|
|
if(auto property = state.properties.find(name)) {
|
|
if(property->value().is<T>()) return property->value().get<T>();
|
|
}
|
|
return {};
|
|
}
|
|
|
|
//this template basically disables implicit template type deduction:
|
|
//if setProperty(name, value) is called without a type, the type will be a string, so property(name) will just work.
|
|
//if setProperty<T>(name, value) is called, the type will be T. as such, U must be cast to T on assignment.
|
|
//when T = string, value must be convertible to a string.
|
|
//U defaults to a string, so that setProperty(name, {values, ...}) will deduce U as a string.
|
|
template<typename T = string, typename U = string> auto setProperty(const string& name, const U& value) -> type& {
|
|
if constexpr(std::is_same_v<T, string> && !std::is_same_v<U, string>) {
|
|
return setProperty(name, string{value});
|
|
}
|
|
if(auto property = state.properties.find(name)) {
|
|
if((const T&)value) property->setValue((const T&)value);
|
|
else state.properties.remove(*property);
|
|
} else {
|
|
if((const T&)value) state.properties.insert({name, (const T&)value});
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
//private:
|
|
//sizeof(mObject) == 88
|
|
struct State {
|
|
Font font; //32
|
|
set<Property> properties; //16
|
|
mObject* parent = nullptr; // 8
|
|
int offset = -1; // 4
|
|
char enabled = true; // 1+
|
|
char visible = true; // 1=4
|
|
} state;
|
|
|
|
wObject instance; // 8
|
|
pObject* delegate = nullptr; // 8
|
|
//vtable // 8
|
|
|
|
virtual auto construct() -> void;
|
|
virtual auto destruct() -> void;
|
|
};
|
|
#endif
|