I was 21 or so when I discovered this paper and re-implemented Phong shading for a combination of a an early i386 (1986 iirc), combined with a co-processor board that had a DSP32 on it, which - amazingly - would do some pretty impressive float calculations. It was a tricky combo to program for, the bus was a limiting factor but when it worked it was quite fast. I later also ported the vector math section of a small ray tracer to that DSP32. The main application the designers of the board had in mind was real time filtering of telephone voice data streams (the board had two RJ11 jacks) so it wasn't an ideal match for graphics work but it worked quite well in spite of that.
Given the resolution limitations of the display hardware I had access to at the time computing the images was actually easier than displaying them, in the end I resorted to all kinds of very fancy dithering schemes and palette hacks to output the images, some so faint that you had to view them in a darkened room (but they looked pretty good, they were faint because I used interlocking RGR/BGB groups of pixels (6 pixels to display two true color pixels) so you'd lose a lot of light output. Fun times!
Aaah, it brings so many fantastic memories. I still remember the excitement and awe when watching the new stuff released on Assembly. The pure fan admiration for guys from Orange, CNCD, Nooon, Complex, Halcyon and many others.
I wonder if it's still as exciting today? Nowadays, when there's abundance of productions, effects, impressive games, wonderful animations, powerful hardware to run all this stuff, I think it's harder to impress people. Especially when they can instantly find 10 tutorials and 5 code examples helping to achieve something similar and as the result everyone immediately depreciate other people's work.
I quite enjoyed that. It really does amaze me how far computer graphics software/hardware has come since those days. I'd love to know what the guys who worked on that bit of kit went on to do.
Thanks, that brings back soooo many good memories!
I wish there would still an easy way for kids to do similar graphics programming on modern PCs. Back then it was very easy to bring pixels to the screen, you just needed a few lines of code to switch to the correct mode. But nowadays with Direct X / Open GL you have layers and layers of abstractions between you and the pixels. And "setting up"Turbo pascal is still way easier than a modern Visual Studio.
I wish there would be some sort of modern Turbo Pascal which lets you do similar programming by faking / emulating the whole VESA stuff.
The demo scene was so formative. Like many others of a certain age in the 3D industry, I was first a demo scene coder, because what else was one to do if you were good at math and computer science but still stuck in high school?
My 1997-era renderer did reflections, bump, color textures, etc all in 16 bit using x86 assembler rasterizers, no floating point, with 256 color palette - source can be found from this link: https://twitter.com/benhouston3d/status/1260346800176877571
Nearly 30 years later I am still doing 3D graphics, contributing to Threejs (which is run by mrdoob, another demo scene coder), glTF, VFX software, https://web3dsurvey.com and have run a computer-graphics company for the last ~20 years: https://threekit.com
I remember staying up all night waiting for my first renders to complete on my brand new amazingly fast 80286 with 80287 math coprocessor. It was amazing.
Between this and Fravia I probably learned more about how computers worked than any other course or article. I remember running through most of these to build up my own personal GFX library. Silly things like "draw random lines" versus "draw random lines REALLY FAST" kept me interested long beyond any reasonable attention span. Thanks @tdicola for the link to the texts!
I'm only sad that I've forgotten so much, and that it's getting harder and harder to make cool stuff like this - there are still ways to get a 1:1 array:pixel mapping and have at, but they're all more complicated than MOV AX, 13h; INT 10h; and $A000.
Hilarious. I wouldn't have expected that ever to happen.
So much talent in the Finish scene and they were so good at advertizing their accomplishments in a way that was energizing to fellow nerds.
It was the biggest reason I ended up getting so deep into computer graphics -- I wanted to be as "cool" as they were. How else could you be "cool" by sitting at your computer BBS chatting all night doing math and algorithms? Such an awesome time.
I know that mrdoob of three.js also got into coding via the demoscene.
My roommate in 1992 would run this on his 386DX with the 387 math coprocessor. It would take literally days to run to create a small 640x480 image.
This was in the days of DOS where you could only run one program at a time. It would run all night and then in the morning he would stop it so he could use the computer for other things. But he had some kind of Targa .tga file utility to merge the files together.
Then he compiled povray for our Sun workstations and he would split up the rendering so that each machine would render 50 lines of the image and he could merge them together with that utility.
I remember how happy he was that he could render stuff 20 times faster.
I ended up working on software rendering (ray tracing) for film production for many years. Now I'm working for a hardware vendor, so I get to have fun with the machine way below the DirectX level.
It's hard for me to capture the level of nostalgia I have for those 4px graphical elements that you could use for graphics. They allowed you to control graphics with the conditional logic of Basic. I had so much fun making animations with different scenes.
Thanks, that is nice to hear. Lots of custom 16 bit blitters made that happen. I made one that blended between (I think) 16 bit patterns to interpolate between two images, plus some RGB blending if I remember right. PowerPC had some wonderful functions for all of that but in the switch to Intel, computers were fast enough that I used a regular loop since it was waiting around for ram anyway. We got pretty far on an OpenGL port but ran into issues with needing to draw the scene in a handful of passes instead of piece by piece. My partner had the vision for artwork and special FX and I just made it happen on the back end.
I implemented real-time Phong rendering on 486SX (no FPU) with a chrome-like effect (see https://github.com/thbar/demomaking#obez-1995) and this still gives me chills.
I met great people back then, and had a ton of fun.
My only regret is that source code is lost, and decompiling properly is not easy!
reply