First off, let me apologize if this is the wrong forum or such a thread already exists.
Switching between emulators can be very annoying, especially if you're working with multiple emulators simultaneously. Each emulator has its own little quirks and differences, and setting up each and every emulator can take up quite a bit of time. So my idea is to use a standard GUI for emulators that can be modified and expanded to fit its console's needs.
Things such as display options (resolution, filters, etc.) or (hot)key mappings could be identical, saving quite a bit of trouble finding your way around other emulators.
This could also make it possible to re-use config files through emulators with only console-specific changes.
While this would obviously be a lot of effort, this may be an idea giving a thought about
Joined: 5/1/2004
Posts: 4096
Location: Rio, Brazil
I guess this is a very good idea, it could encourage tasing on different systems. Only problem is when certain features exist only on some emulators. In this case perhaps the best option is to make the feature dimmed when it's not available.
From what I see, it seems the main concern isn't the feature set itself, but how you access them.
The idea is mainly to have menu arrangement in the same order, and hotkeys giving the same command for each system.
Though I admit it would be cool if there was an all in one emulator frontend that just called the individual systems as dlls.
For console emulators, making one emulator capable of running them all could be feasible. But then there are computer emulators, which tend to be really different from console emulators, making merging almost impossible. But still, merging console emulators could be possible.
The emulator core would have to export lots of functional parameters to generic part (the controller axis and button maps, how many controllers are possible, memory sizes, byte orders, etc...) the generic part would then offer UI based on these parameters (restricting input ranges and disabling options where needed).
Ideally, Lua support would be part of generic part. Some Lua functions probably won't make sense on all systems but many do.
Then there's the problem that 2D consoles (the generations of NES and SNES) should use 2D rendering to screen and 3D consoles (later generations) should use 3D rendering to screen. There's still fair amount of machines that can't properly handle 3D rendering.
The emulator core would have to export lots of functional parameters to generic part (the controller axis and button maps, how many controllers are possible, memory sizes, byte orders, etc...) the generic part would then offer UI based on these parameters (restricting input ranges and disabling options where needed).
Ideally, Lua support would be part of generic part. Some Lua functions probably won't make sense on all systems but many do.
Then there's the problem that 2D consoles (the generations of NES and SNES) should use 2D rendering to screen and 3D consoles (later generations) should use 3D rendering to screen. There's still fair amount of machines that can't properly handle 3D rendering.
If I understood you correctly, you're pointing out that making emulator cores work on several different platforms is difficult, right? I think what scrimpeh was after is that there's a single GUI front-end that calls for different emulator cores when asked, so there won't be just a single core that has to manage with all of the emulation.
I actually think this is a great idea, but I'm a little pessimistic about it becoming reality in near future.
If I understood you correctly, you're pointing out that making emulator cores work on several different platforms is difficult, right? I think what scrimpeh was after is that there's a single GUI front-end that calls for different emulator cores when asked, so there won't be just a single core that has to manage with all of the emulation.
Well, what I'm talking about is single GUI (and perhaps some other common parts, possibly Lua VM, possibly movie code, etc..) calling number of emulator cores (one for each system or system group) for different systems (like NES core, SNES core, GBx core, Genesis core, etc...)
The almost impossible part refers to systems that are pretty much totally different from common consoles, like PC(DOS) and MSX. These things also have really diverse configurations, where console configurations are quite limited.
Brushy wrote:
I actually think this is a great idea, but I'm a little pessimistic about it becoming reality in near future.
I'm pessimistic too. It is loads of work after all...
I think a better (though longer) solution is to standardize the featureset of all the emulators.
I agree with this. Each emulator for each console might require its own special user interface, especially if the console is somehow special (eg. some consoles may have analog sticks or touchscreens), and it can be both technically difficult and from an usability point of view quite awkward to try to cram everything into one single common GUI. It would also mean that a new emulator for a new console may find itself limited by the current GUI.
If, instead, the emulators are independent programs, they can add whatever is needed to emulate the console and add console-specific options and tools. But if common features and settings (including configuration files) are standardized and common to them all, and all the different emulators try to obey this standard as well as possible, it makes using them easier.
