Quote:You cant interpret the game overnight, as somebody would have to be playing it, moving around, using all items, using all possible attacks in battle against every possible enemy (talking about ffx) and then saving the interpreted commands in lets say an sql table. The next time you would be playing the game instead of interpreting again, it would find the needed command in a table, but that may take more time then actually interpreting the command.
On the other hand, its hypothetically possible to make an emotion engine to intel assembler code converter (big speedup, but time and space consuming). Did anybody try to do this? I mean, if the interpreter is nearly finished, this should be a possibility.
Your right, but what I mean is instead of storing all the locations in a large database, rather you would make an x86 executable. If you went straight through the code line by line down to the bottom you would cover every single possibility within the game. The interpreter should be coded to optimize the code for execution on x86 processors, which would be instead of blending instructions basically which is what the EE core does, you would be separating them and running them parallel to each other in different threads. (It's supposedly improbable to be able to do this with the emulator because the core architecture performs on a 'combined thread' basis rather than a singlular-thread level like x86 does, and all you would have to do to optimize it is to designate the instructions to run independent of each other)
That is a limitation *only* with the PS2 Emotion Engine however, x86 CPUs have excellent speed when it comes to running a single thread.
And true, it is *very* possible to convert any code to any other code if you are able to recompile or interpret it [basically if it's *understood* by the converter then all your basically doing is decoding and encoding]. The interpreter for the IOP seems very effective, it only halves my framerate, but the interpreter for the VU1 or EE on FFX completely slow down my framerate.
I use the interpreter for the IOP because it's quicker than disabling speedhacks, then I can nail those tricky overdrives like Wakka's or Auron's.
Basically we're talking about recompiling or interpreting all the code of a PS2 game line-by-line (offline, not using emulation) to produce a working program for x86 processors. You would have to skip all of the game's resources and focus only on the executable code.. that'll speed up the process because what's the point of sorting through texture and sound files?
It's still difficult to figure what your going to do with all of the game's resources like the FMVs, sound and textures... if you create a separate x86 executable to 'read' those PS2-exclusive formats like you would using Windows Media Player to play music in the backround of a game which music volume you muted because you got bored of all the 'ding-ding-dings' and integrate them into the other's x86 execution or run independently of.
Still though, the fact your emulating shows it's possible! (Your just recompiling all the code in real time and having your PC 'pretend' to be a PS2)
Your creating a virtual machine... remove the need for a virtual machine by re-encoding the game executable and possibly resources for x86 and you literally translated all of it and have yourself a PC port if it's working. How will you change the resolution and everything? You'll have a separate executable like you do for some games which will change the execution parameters for the game.
How do companies usually port their games to different systems? It's that process which they use to port games from console to PC that we need to know about (know any games that were first on the PS2 and got ported eventually to PC? I do... Metal Gear Solid 2: Sons of Liberty [I have the PC and PS2 ports... it's like one of my fav games ever], plus you have all the options that you didn't in the original version)
Then if it were native, you would only need like a Pentium III to run the code. The PS2 'blends' instructions for computational efficiency but I believe if you just ran them separately you could do much better on PC architecture, while you would also be able to scale upwards in the amount of cores or threads run if needed.
The PCSX2 team is planning to add quad-core support, although you cannot have 'out-of-order execution' with the PS2 core.. so I would say you just isolate every unit (EE core 1, IOP core 2, VU0 core 3, VU1 core 4) and synchronize them the best that's possible. If you isolated them on a quad core @ 3-4 ghz you could get decent speeds [albeit maybe quarter or fifth realtime at best] just using all interpreters.
We need to find the method of console to PC porting for *most* instances in the past. Perhaps even the inverse of this operation holds some clues.
It is possible to make that converter, and it would consume only 5-15% more space for most games (considering were not inflating the size of the resources, just maybe the code). It would have to find the equivalents of instructions on the EE for x86 though, but that can't be too difficult... you could do almost anything with Assembly.
My guess is this site has some clues too:
http://www.goingware.com/tips/getting-started/
It's about the compiler.. That's really all we need is a compiler, but it's going to take someone who is familiar with the PS2-exclusive code to write one.