DaveC-- you've got a few things mixed up here.
First off, the bit about OpenGL slowing things. Right now, you have an API between the main program (let's use for an example, SquidgeSNES) and the video hardware; here, a blitter and a framebuffer it writes into, which then forms the image on the screen in the end. SDL is that layer, which feeds into a video driver in the kernel and in turn, into the blitter, framebuffer and screen. There are software layers with the blitter in the MMSP2 *or* the OpenGL-based GPU in the VRENDER-3D. OpenGL would most likely just be implemented through SDL as is quite common-- you can utilize OpenGL contexts within it quite neatly. Or the process could be automated like Paeryn's 'HW-SDL', kept hidden from the user but behind the scenes, accelerating graphics operations. If developers want to get closer to the metal, they can write instructions directly for the GPU through their own lighter API much akin to how Minimal Lib works.
Full hardware-based OpenGL support on a GPU such as that in the VR-3D would allow not only such fun gimmicks as hardware scaling and rotation, but also hardware-rendered alpha effects and transparency (of enormous obvious benefit to SNES emulation, and down the line, GBA emulation), and would also likely accelerate the drawing process of many 2D sprites (e.g. tiles in an emulator, or larger graphics in a homebrew game like Stargazer) to raise framerate during intense drawing operations. Decreased CPU utilization in draw operations may also be a benefit, freeing cycles for use in CPU core emulation. On top of that are the benefits of hardware 3D rendering.
As for the bit comparing the GP2X's available hardware next to your average PC's and comparable tolerance for bloatware-- it's important to remember that while software has become more bloated over time this has been on much a different side of the ballpark, DirectX, not OpenGL-- the former also being a much more recent development. Even then, DirectX is not that big a burden in efficiently accessing graphics hardware. It's also important to remember that while a 200 MHz ARM9 processor may not seem powerful compared to something running at 4000 MHz like a slightly-overclocked P4, note how a CPU clocked closer to 2 GHz like an Athlon 64 or Core 2-series chip outperforms a 4 GHz P4 unit! Clockrates can't be compared like apples and apples or treated as the sole determination of performance. Nor, as we've discussed before, can the capability of the GP2X when programmed for directly be compared to the sorts of games it can run in emulation-- the capabilities of the GP2X blow away those of any of the systems it can emulate hundreds of times over.
Linux preventing access to the screen and getting in the way of full speed is no major issue. I would not even doubt that direct access to the display could be achieved. Regardless, performance gains from removing Linux from the equation are minimal-- nearly nothing on the OS side of things is using many CPU cycles at all. The Linux OS uses a good chunk of RAM, but nowhere near enough to impede on the '2x's impressive 64MB capacity-- remarkable compared to any other portable available today, and the vast majority of it remains free even with Linux running. As for OpenGL, use of this API would have a negligable impact on RAM. No one complains that SDL uses too much RAM-- and OpenGL would use far less. As it stands, as a developer you have around 50MB to play with, with Linux running!
Now, what's this about Squidge's MMU hack being a taste of performance without an OS or APIs in the way? That's not what it's accelerating at all. Normally, the ARM920T can access the upper 32 MB of RAM in the GP2X but it is not cacheable, so access is fairly slow. The MMU hack allows the upper 32MB to be cacheable as well so it will be able to perform as well as the lower 32MB, providing a dramatic performance boost for programs like GNGeo that store huge ROM binaries in upper memory, including graphics data, or programs that make heavy use of the framebuffer residing in the 32MB upper memory area. The simple fact of the matter is that most of the gains of programming with no OS or API for the machine can be had through the use of ARM9 ASM, the MMU hack and just plain efficient code, and it comes with the benefit of enticing developers who don't want to go through the huge hassle of programming 'on the metal'. Were it not for Linux and SDL on the GP2X we'd have nowhere near the developer base we do today.
DaveC said:
That is fine if you want to display some "sprites", rotate them etc. But if you want to do something out of the feature set then what? What if you need to render some 2D screens per scanline or per pixel, read some screen locations directly and do some raster interrupts for effects in emus? You know everything is not primitive or polygon based. Yeah that stuff makes my computer render quickly *IN 3D* not everything can be broken down into 3D polygons and primitives though. It will be nice for 3D games but more limited in emus. Again why all of this *need* for 3D? we don't have enough that now that every mainstream console and handheld is 3D? Jezzus enough already.
You're really confused about this whole topic, aren't you? .. A GPU is just a microprocessor that's good at handling polygons, but is excellent for MANY graphical operations, 2D or 3D. Or just floating point and vector calculations. There's nothing that makes it a polygon engine alone. Why "sprites" in quotes? You don't HAVE to render sprites on polygons, you know. You can just as easily draw them in 2D space with a GPU. That's just one manner in which some 3D consoles like the PSX or Saturn pulled off accelerated 2D with a polygon engine.
There is nothing to keep you from doing more direct drawing operations; just as no one is MAKING you use the blitter in the GP2X. You don't have to use OpenGL if you don't wish to; if you want, write to the framebuffer directly, pixel by pixel, line by line, however you wish. At any rate, the implementation of a GPU won't add any limitations the GP2X doesn't have. If anything, though, a 3D GPU would be able to achieve levels of performance the '2x's blitter likely won't ever achieve.