My name is Takaaki Ichijo, I’m a core member of asobu, and helps to introduce our activities and community to local indie game creators in Japan.
I’m also a solo-game developer, and I’m currently working on a giant robot battle game called “Demolition Robots K.K.” for Nintendo Switch and PC. This project was planned to be showcased at GDC 2020 exhibit floor…but with the event being cancelled, I was looking for other opportunities to show it online.
In this article, I won’t be talking about it, instead i would like to share about the development of my previous game: Back in 1995.
I made that game based on the hypothesis that “the dawn of polygon visuals generalized by the PlayStation might have equal value to pixel art” .
A first concept video was revealed in 2015 and the game was released on Steam in April 2016.
I’m running a 50% off sale to celebrate the 5th anniversary of the project announcement.
I feel like various “PS1-like” styles are finally catching on among indie game developers around the world, so I’m going to talk about what makes a “well-made” PS1-like games from my point of view.
There’s no obligation to stick to all of the techniques I’m going to talk about, to make a PS1-like game. With so many different ways to represent that style, it should be up to the developer to decide which one to adopt.
Here, i’ll introduce you to three levels.
Level 1: Reproducing the limit of hardware performance
The minimum you need to do is to check the hardware specs of the PS1.
Sony PlayStation Specifications
- CPU: R3000A 33Mz
- GPU: GPU for 2D processing + Geometric Transfer Engine (GTE)
- RAM: EDO DRAM 2MB
- VRAM: SGRAM 1MB
- Sound LSI: Sound Processing Unit (SPU)
- Media: Double-speed CD-ROM drive
The PS1 has a polygon processing capacity of 360,000 polygons per second. That means 12,000 polygons per frame in a 30FPS game. Since there is a lot of other things processing, the total number of polygons in one screen has to be 10,000 polygons.
Also, the screen resolution that the GPU could send out was from 256 x 224 to 640 x 224 (interlaced mode). For Back in 1995, I set to 320 x 224 because of the look of the screen and the amount of information.
Depending on the game development environment, it may be difficult to scale screen with keeping low-resolution screens. In Unity engine, you can use Render Texture function, a feature that pastes the drawing results into textures.
The low resolution also affects the font. Fonts that read well at low resolutions, preferably 12pt to 14pt. Since “Back in 1995” also includes Japanese language, “Shinonome font” is used.
In addition, reproducing the wait time for loading from the CD-ROM when a stage changes, is an effective way. Modern PCs and consoles, don’t even need a few frames to read few MBs of data.
However, loading screen can be a source of stress for players, so be careful when adding them. On Back in 1995, there’s a four-second fake loading screen.
To sum it up level 1:
- Set the screen resolution from 256 x 224 to 640 x 224
- Make character data in 500 to 1000 poly.
- Set the total amount of polygon within 10,000 poly per screen.
- Change the font to a low-resolution bitmap font
- Insert a fake loading screen. Preferably looking like a CD-ROM!
Level 2: Reproducing hardware quirks
Of all the PS1’s hardware, the one that has the most distinctive visual impact is the GTE, an LSI dedicated to vector operations. It was characterized by the fixed-point arithmetic of vectors, which allowed for the processing of large numbers of polygons (for the time) in exchange for less computational accuracy.
This creates the “polygon wobble” that is unique to PS1.
It is also important to note that GTE does not have a texture perspective collection feature. Perspective Collection is. When you apply a texture to a polygon, this function expands the texture by taking the distance from the viewpoint into account, and since this function was omitted from PS1, the texture was distorted.
The shortest way to integrate these two GTE characteristics, is to use PS1-like shader assets. If you’re using a game engine, there are PS1-themed shaders published or for sale for Unity and UE4.
The widely used shader for Unity is “Retro 3D” provided by Keijiro Takahashi of Unity Technologies Japan, who taught me about those shaders at Unite 2015 Tokyo when we discussed the PS1-like graphics.
Later he put them together in a package.
Retro 3D
https://github.com/keijiro/Retro3D
You can see a demo using this shader at the following URL. You can grab the orange with the mouse and move it. (This is a parody of the legendary PS1 title, do you figure out?)
http://takaakiichijo.github.io/90sPoly/Mikan.html
A PS1-like shader that can be used in Unity’s new Universal Render Pipeline (URP) has also been released very recently.
https://github.com/Kodrin/URP-PSX
For Unreal Engine 4, an asset called “Oldskooler” is available for sale.
https://4loup.itch.io/oldskooler
Implementing these plugins can be a huge improvement(Deterioration?) to the way you look.
An even more challenging graphics expression is “Z-sort reproduction”. I’m wondering if there aren’t any PS1-like games doing this yet.
In the current game development environment, there is the depth buffer function that allows pixels to be drawn with information about depth and overlapping pixels to be drawn only in the front.
However, the PS1 didn’t have this function, so a method called “Z-sort” was used to determine the relationship between the front and back in polygons. This is because the intersecting polygons cannot be drawn correctly, and many faces that should be drawn at the back are often drawn at the front.
This was considered difficult to integrate in “Back in 1995” because it could not be accomplished without huge modifications on game engine’s drawing process, so I decided to not use this technique.
The next step of 3D reproducing is 2D images.
The capacity of CD-ROM (black disk) which was the data media of PS1 was 700MB, In the case of games that require a large number of images, we had to work on keeping the file size down. For this reason, many games were recorded in 15-bit color (32768 colors) instead of full color.
However, when color is reduced, the mach bands phenomenon occurs where the border between colors becomes a pattern and stands out. At the time, a technique called dithering was used to suppress this mach band (in fact, this technique is widely used in modern mobile games to reduce the transfer data amount).
Dithering, which means “intentionally added noise,” is a process that expresses the color in the middle by adding fine point noise at the point where the mach band occurs and makes it appear smooth to the human eye.
In addition, the translucent processing that the PS1 features is “additive” and “alpha-blend (fixed alpha value)”. If you use additive translucency for translucency, the picture will looks nice.
Finally, let’s focus on audio.
- Sound source: 16bit ADPCM
- Memory: 512KB
- Sampling frequency: 44.1kHz
- Number of simultaneous sounds: stereo, 24 channel
From this, it can be concluded that there should be no more than 24 simultaneous audio. Also, setting the compressed audio to 16-bit ADPCM is effective. However, the PS1 was able to play CD-DA quality music when streaming from CD-ROM, so you can set the backstory to “Background music streaming from CD”.
As for sound, there is a method of extract the built-in sound source of the SPU from the actual PS1 hardware, but it will be legally infringement. If you do this, please use that for reference only. Use the final sound data made with legitimate sound source units.
To sum it up level 2
- use shaders for PS1-like shader assets.
- Use additive semi-transparency.
- Set the texture color to 15-bit color 32768 and do the dithering process.
- Setting the quality of the sound effect to 16-bit ADPCM
- Reduce the number of sounds that can be played simultaneously to 24 or less.
Level 3: Sticking to the limits
There are a lot of PS1-like indie games out there these days, but there’s one part of the game that hasn’t been challenged yet, the Motion JPEG movie. PS1 can playback Motion JPEG movies at 30 frames per second at 320x240 dots and 15 frames per second at 640x240 dots.
The following shaders are available to create images that look as if they were degraded by Jpeg compression, but it is unclear how they can be used in a game development environment.
DCT quantization shader
https://github.com/FMS-Cat/dct-shader
This is something that probably no one else has done yet. The in-game movie itself would be best if it had a CG quality that reflected the times of the 1995–2000s.
There is an approach that not only reproduces the game hardware side of the game, but also expresses “what kind of environment it was played in. First of all, it’s a reproduction of a CRT monitor. There are various CRT monitor effects for Unity, but the ones used in “Back in 1995” are as follows.
[Unity3D]ブラウン管風シェーダーを作った http://wordpress.notargs.com/blog/blog/2016/01/09/unity3d%e3%83%96%e3%83%a9%e3%82%a6%e3%83%b3%e7%ae%a1%e9%a2%a8%e3%82%b7%e3%82%a7%e3%83%bc%e3%83%80%e3%83%bc%e3%82%92%e4%bd%9c%e3%81%a3%e3%81%9f/
The New Nintendo 3DS version of “Back in 1995” uses the bottom screen to add the experience of playing a game on a malfunctioning cartridge-type game console.
The top screen resembles a TV monitor, and sometimes, when the game stops, it is necessary to plug and unplug the RGB plug or reset the fake game hardware in bottom screen.
In a similar vein, there was a VR game called “Pixel Ripped 1989,” which was based on the concept of “playing a handheld game console at school without the teacher finding out.
By creating a device that reflects not only the in-game expression but also the historical background of the PS1 hardware, it may be possible to awaken the child who has fallen asleep in the player’s head.
To sum it up level 3
- Trying to reproduce Motion JPEG movie
- Using the CRT monitor representation shader
- Recreating the environment of playing game in 90’s
Conclusion: Reverse Memory Correction
Now, I’ve explained the process of creating a PS1-like game based on the features of the PS1, but there are not always the best way. For Back in 1995, I’ve set a much lower FPS (18~22 FPS) than the PS1 game to make a laggy screen…
This is inherently overkill. However, we introduced it as a device to evoke a sense of “this is what the old games used to be like”. I named it reverse memory correction.
There’s no limit to the PS1-like style games. For example, it would be nice to have a game with crumbling polygonal characters roaming the ultra-high-res low-poly world.
Like pixel art styles, I’d be happy if PS1-like style could be established as a new genre of expression that’s not just nostalgic.I’m looking forward to play games made by the creators who have seen this guide.
Back in 1995 official website
https://backin1995.com/
