> Each new release was decidedly worse than the previous one. Compare the original PSX version (video) to the DOS release (video): The vertex lighting on the track is gone, everything looks flat, there is no transparency and the speedometer was redrawn by a programmer. The ATI Rage Edition (video) carried this mess forward, introduced visible seams in the geometry everywhere, somehow corrupted the software z-sorting and then screwed up the text rendering with ghastly letter spacing.
I played a lot of Wipeout XL on the Playstation in my late teens/early 20s. I mean a LOT. The only thing I really wished for (other than less frustrating maps and smarter AI) was a higher resolution and farther draw distance. At some point, I found the Windows version in a bargain bin at some store and snatched it up. 640x480 Wipeout XL would be glorious!
Unfortunately whoever ported it was brand-new to programming or something because they pinned the game speed to the CPU speed, or screen refresh rate or similar. Net result was that it ran way too fast even on a modest computer at the time. It's like nobody even bothered to test it. There was a patch floating around to fix the speed at one point, but there are so many other problems with it that's just far easier to run the PSX version in an emulator and call it a day.
Just a reminder that BallisticNG is an equally addictive Wipeout clone and available on all Steam platforms. A Nintendo Switch port was also announced.
WOW! Just a `git clone`, download and unpack the .zip with the assets (end of the blog post), type `make` and it compiles on Linux without warnings into `wipegame`, run it and it works first time!
You need a joypad/joystick, I was surprised that I could plug it in after the game had started and it picked it up, insted of having to restart the game as I remember being the case with other games on Linux years ago.
I loved everything about Wipeout, except the racing. The controls where impossible and the difficulty ridiculous.
But the music, the art style, the concept and attitude of that game was awesome. I spent many hours playing it on PSX as an early teenager.
Source repo: https://github.com/phoboslab/wipeout-rewrite
The web version is WASM, from C/SDL sources.
This is great.
Sidenote, there should be some amazing games capable of running browser now. Is there any list or any recommendation ?
I've lately been playing Redout (Redout: Enhanced Edition) on the Steam Deck, and it is a quite fun game in the spirit of the old Wipeout game. Consider giving it a go if you are into that sort of speed-over-everything-else racing games!
<3 Designers Republic <3
Link to the original soundtrack https://archive.org/details/wipeout_psx_soundtrack
This is so cool! My first entry in this series was WipEout Pure on PSP; such a great experience and remastered twice with HD and Omega Collection. Impressive how the PS1 original can run at 60 fps in a browser.
The writeup is pretty impressive
https://phoboslab.org/log/2023/08/rewriting-wipeout
As a sign of what you're getting yourself into, though (you knew this was coming though, didn't you?): "The leaked source has a few hundred global variables scattered all over. Many of these are brought in to different source files (using `extern int something;`) and there was little logic to where they were defined."
I was wondering how he didn't get shutdown immediately and read his post about it linked in the top right. https://phoboslab.org/log/2023/08/rewriting-wipeout
This part is great: > If anyone at Sony is reading this, please consider that you have (in my opinion) two equally good options: either let it be, or shut this thing down and get a real remaster going.
> I'd love to help!
A perfect thing to release on "Zero Cool Day"
Its always so fascinating to see source code from console games of the 5th generation when most started using C vs assembly. The ratio of lines of code to "game" for something like this or Mario 64 just seems so incredibly high.
I would love to see an analysis of the original source without the attempt to try and critique and âimproveâ it
programmers who don't understand seasoned game developers' views on manual memory management (and aversion to garbage collection) might want to take a look at the "Rewriting the memory management" sectionâlook at how simple that is, both to implement and maintain!
Looks really cool and props for fixing a huge amount of spaghetti code. Now, I wonder if I can make a 3d rasterizer on a FPGA and run the CPU side on a RISC-V... If anyone else is intrigued by this let me know.
It's funny there aren't any texture packs for the original WipeOut yet.
It would be good if this code would could would work with whatever the standard format for texture packs on PS1 emulators is.
Brings back happy memories of playing this on the demo unit in the shop across the road from my house every day after school because I couldnât afford to buy the console.
What are the keys? I can't figure out how to accelerate.
Yep, just as hard as I remember it being - fun though
The Amiga might finally get a port! IIRC related one of more of the hardware designers of the Amiga went on to do the Playstation 1 hardware.
to me wipeout 3 was the pinnacle of the genre. never matched after.
Impressive. Really smooth. Brings back memories!
The code is a pleasure to read.
Yesterdayâs submission: https://news.ycombinator.com/item?id=37075916
Itâs strange how some HN submissions fail to get noticed, and a duplicate submission after a few hours (or even next day) gets upvoted and is more visible.
> The PSX devkits came with a library called LIBGPU, which handled the rendering. Since the PSX GPU didn't have a z-buffer, all primitives you wanted to draw (triangles, quads and sprites) needed to be submitted into an âordering tableâ or OT for short. This table had (typically) 8192 slots allowing for 8192 different z-levels. The GPU would then rasterize the list back to front. The result would not be perfect (in some situations neither of two polygons will have all pixels in front of the other one), but close enough.
This is actually implemented in a slightly funky way on the PS1. The DMA unit responsible for sending commands to the GPU allows for a display list to be built in memory as a linked list of variable-length packets, each of which can hold zero or more commands. What Sony's libraries do is essentially generating the ordering table as an array of 8192 empty packets linked to each other, then allowing actual command packets to be allocated elsewhere (typically using a simple bump allocator) and "spliced" into the link from one empty packet to the next one. The PS1's vertex transformation coprocessor, the GTE, also keeps track of the Z coordinates of the last 4 vertices processed and has an instruction to quickly average them out so that the resulting value can be used as an index into the ordering table.
I wrote a few SDK-less bare metal C examples showing how to build an ordering table [1] and leverage it for 3D polygon sorting [2], should anybody want to check those out.
[1] https://github.com/spicyjpeg/ps1-bare-metal/blob/main/src/07...
[2] https://github.com/spicyjpeg/ps1-bare-metal/blob/main/src/08...