mirror/bsnes
1
0
Fork 0
mirror of https://github.com/bsnes-emu/bsnes.git synced 2025-08-31 20:12:12 +02:00
Code Issues Projects Releases Wiki Activity

Update to bsnes v107.1 release.

Browse Source 
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.
This commit is contained in:
Tim Allen
2019-04-09 11:16:30 +10:00
parent 7786206a4f
commit 4d7bb510f2
223 changed files with 9895 additions and 3116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
nall/string/markup/find.hpp
View File

@@ -5,7 +5,7 @@ namespace nall::Markup {
auto ManagedNode::_evaluate(string query) const -> bool {
if(!query) return true;
for(auto& rule : query.replace(" ", "").split(",")) {
for(auto& rule : query.split(",")) {
enum class Comparator : uint { ID, EQ, NE, LT, LE, GT, GE };
auto comparator = Comparator::ID;
if(rule.match("*!=*")) comparator = Comparator::NE;

32
nall/string/markup/node.hpp
View File

@@ -46,31 +46,39 @@ protected:
struct Node {
Node() : shared(new ManagedNode) {}
Node(const SharedNode& source) : shared(source ? source : new ManagedNode) {}
Node(const string& name) : shared(new ManagedNode(name)) {}
Node(const string& name, const string& value) : shared(new ManagedNode(name, value)) {}
Node(const nall::string& name) : shared(new ManagedNode(name)) {}
Node(const nall::string& name, const nall::string& value) : shared(new ManagedNode(name, value)) {}
auto unique() const -> bool { return shared.unique(); }
auto clone() const -> Node { return shared->clone(); }
auto copy(Node source) -> void { return shared->copy(source.shared); }
explicit operator bool() const { return shared->_name || shared->_children; }
auto name() const -> string { return shared->_name; }
auto value() const -> string { return shared->_value; }
auto name() const -> nall::string { return shared->_name; }
auto value() const -> nall::string { return shared->_value; }
auto text() const -> string { return value().strip(); }
auto value(nall::string& target) const -> bool { if(shared) target = string(); return (bool)shared; }
auto value(bool& target) const -> bool { if(shared) target = boolean(); return (bool)shared; }
auto value(int& target) const -> bool { if(shared) target = integer(); return (bool)shared; }
auto value(uint& target) const -> bool { if(shared) target = natural(); return (bool)shared; }
auto value(double& target) const -> bool { if(shared) target = real(); return (bool)shared; }
auto text() const -> nall::string { return value().strip(); }
auto string() const -> nall::string { return value().strip(); }
auto boolean() const -> bool { return text() == "true"; }
auto integer() const -> intmax { return text().integer(); }
auto natural() const -> uintmax { return text().natural(); }
auto real() const -> double { return text().real(); }
auto text(const string& fallback) const -> string { return bool(*this) ? text() : fallback; }
auto text(const nall::string& fallback) const -> nall::string { return bool(*this) ? text() : fallback; }
auto string(const nall::string& fallback) const -> nall::string { return bool(*this) ? string() : fallback; }
auto boolean(bool fallback) const -> bool { return bool(*this) ? boolean() : fallback; }
auto integer(intmax fallback) const -> intmax { return bool(*this) ? integer() : fallback; }
auto natural(uintmax fallback) const -> uintmax { return bool(*this) ? natural() : fallback; }
auto real(double fallback) const -> double { return bool(*this) ? real() : fallback; }
auto setName(const string& name = "") -> Node& { shared->_name = name; return *this; }
auto setValue(const string& value = "") -> Node& { shared->_value = value; return *this; }
auto setName(const nall::string& name = "") -> Node& { shared->_name = name; return *this; }
auto setValue(const nall::string& value = "") -> Node& { shared->_value = value; return *this; }
auto reset() -> void { shared->_children.reset(); }
auto size() const -> uint { return shared->_children.size(); }
@@ -102,7 +110,7 @@ struct Node {
}
auto sort(function<bool (Node, Node)> comparator = [](auto x, auto y) {
return string::compare(x.shared->_name, y.shared->_name) < 0;
return nall::string::compare(x.shared->_name, y.shared->_name) < 0;
}) -> void {
nall::sort(shared->_children.data(), shared->_children.size(), [&](auto x, auto y) {
return comparator(x, y); //this call converts SharedNode objects to Node objects
@@ -114,9 +122,9 @@ struct Node {
return shared->_children[position];
}
auto operator[](const string& path) const -> Node { return shared->_lookup(path); }
auto operator()(const string& path) -> Node { return shared->_create(path); }
auto find(const string& query) const -> vector<Node> { return shared->_find(query); }
auto operator[](const nall::string& path) const -> Node { return shared->_lookup(path); }
auto operator()(const nall::string& path) -> Node { return shared->_create(path); }
auto find(const nall::string& query) const -> vector<Node> { return shared->_find(query); }
struct iterator {
auto operator*() -> Node { return {source.shared->_children[position]}; }