I've been thinking, instead of trying to emulate the Gamecube hardware (either really slow, or near to impossible) why not have Dolphin extract the audio and textures and mechanics and such and convert it into a more windows/linux friendly format? Then Dolphin would run the game using those files rather than the ISO. That way, Dolphin does not have to try emulating all off that hardware, so it can run the games faster.
Sounds near impossible to me, but it doesn't hurt to mention it, does it?
Well, if you have any idea how to do it, Dolphin is up to you! You may add some changes to source on your PC and then contact devs
This is what emulation is all about : reverse engineering.
Try to understand and emulate hardware by trying to make software usable.
What you're mentionning is like making a DVD working with a piece of stone instead of a laser ^^
why not have Dolphin extract the audio and textures and mechanics and such and convert it into a more windows/linux friendly format?
You, my friend, got everything wrong. You're talking about audio/textures, which is really beside the point, what matters are the commands the games sends to the hardware (PowerPC language or so I heard). These commands are what Dolphin converts to C/C++ language understood by computers. Dolphin also needs to redirect the commands, which of course refers to Wii hardware, to similar features in OpenGL/DX9/DSP etc., these can finally display the video and sound. Because of all these convertions processes , things are slowed.
The other option would be, I'm sorry but your suggestion didn't make much sense, would be to patch the isos of the games, converting the commands inside of the games themselves into C/C++, saving time compared to converting them on the fly. Of course This hasn't been done, there would be tons of difficulties for each game and much harder than making Dolphin, I'm not a dev so of course I have no clue if there's even a chance of this to ever work. Note everything I just explained is just how I understood it, a dev could probably tell me I'm wrong somewhere
It's a useless suggestion anyway. Just like RuFo stated, the whole point of emulating is to reverse engeneer the system and make it run as close to the original console as possible. They're not going to cheat and modify it just to make it run better or faster. Otherwise it's not emulation anymore. It's just a hack to try to get the games to play on the PC. But, just like nosound97 said. If you want it done that way, good luck when you do it yourself.
What you are suggesting is pretty much what Dolphin is doing. We're translating PowerPC code to x86, we're converting textures from GC to PC format, etc etc. It can't be done in any other way unless you want to manually rewrite every game.
Ah I see; KHRZ seems to have explained what i was thinking better than how I did; converting the GC commands to C++ is what I meant to say I guess.
As for ector, manually rewriting the game is basically what I was mentioning before; but I guess it doesn't make too much sense if it is impossible to have one generic method of converting the code for every game.
Sounds like you guys don't agree with my line of thinking, but like I said, it was just a thought.
The games are designed to run ON the gamecube, therefore they are coded in a specific manner that will only respond to commands and responses given and received BY the gamecube. What you're suggesting is to rip all the content from the discs, and then basically create an EXE for each game to run it on the computer. This would be pointless to do because you would have to do it differently for EVERY single game. It would not only be hard to do, it would be so much time invested into getting one game working... and then do it for them all? It's much less time consuming to just do what they are doing. and Emulate the hardware.
As I understand it, they basically *are* rewriting each game, or at least the code for the game. That's what a dynamic recompiler does. Given PowerPC code, Dolphin can translate that directly into x86 code before it runs it. This makes the resulting code (although not terribly optimized) much faster, and then Dolphin just has to hook the reads/writes to the system hardware or calls to the system firmware and emulate those. So really, when you think about it, Dolphin is already doing this manual conversion beforehand.
"On the fly" would be running Dolphin in interpreter mode, which is where instead of doing a run on the code beforehand, it literally emulates the instructions one at a time. It's much more accurate and much less prone to errors, but it's also slow as hell as can be seen by running it yourself.