This is a simple brute force raytracer based on the excellent book "Ray Tracing in One Weekend" It will take approximately 2 hours to render the image in the preview! The slowness is mostly caused by there being no form of object hierarchy so every single sphere is being test for every single ray generated. There's a lot of sphere's so that's a lot of calculations.
The ray tracer produced by following Ray Tracing in One Weekend is really simple and straightfoward, as a result I think this is a great cart to look at if you want to get a handle on Ray Tracing. You probably don't want to run the cart as is but nick the code and play around with a scene yourself.
If you look at the end of the code it should be pretty clear how the scene is described (simply adding sphere's to the things table). There is also the "fast" option. If you set that to TRUE then the pico8 will switch to 64x64 mode and only do 1 sample per pixel. It's a great way of making sure you have setup a scene correctly before doing a longer render.
Finally I have also implemented checkerboard material as well called CHECK which does black and vec(r,g,b) colour of your choice squares.
I aim to improve this cart somewhat before moving into the next book (Ray Tracing the Next Week): the main thing is to improve the colour mapping. At the moment I simply map to the closest Pico8 colour from the default palette in RGB space. I'd quite like to pick a best possible monochrome (or at least two 8-colour monochrome palettes) to produce smoother images as some of the colour transitions are quite jarring at the moment
Started noodling with a sports game, probably going to be rugby.
My dream has alwasy been to produce a rugby game as good as the mid ninties Jonah Lomu Rugby, never been bettered
What I've got here is two 7 a side teams randomly distributed over the pitch with a physics engine to resolve collisions.
From small acorns things grow and such like
So this is mostly for those of you who are thinking about ChessJam and wondering if the Pico8 is tough enough for the job.
The answer is clearly "Yes!" (1). Here is my implementation of a Sid Sackson classic board game Lines of Action. OF interest is that I'm using Negamax, bit boards and the 0x4300 user memory for the storing thereof.
There is unfortunately some kind of bug hiding in my (horrible, horrible) code that means the smart AI occasionally glitches the game state. I did mostly write this late at night during a period I wasn't sleeping well. I am very hapy with the code about the menus though.
(1) People have managed to fit (most of chess) into a ZX81 (that's a whole 1K of ram they were working with). http://users.ox.ac.uk/~uzdm0006/scans/1kchess/
So I went a little crazy after doing my contribution for the invent a title screen thread. I thought it would be nice if the two Gs drew at the same time and I came to the conclusion (in a huge leap) that the best way of doing it would be to some kind of co-operative multitasking co-routine system.
It doubled the token count from 200ish to 400ish but I'me pretty happy with it and I think it works well as a demonstration of the power of closures and co-routines.
EDIT: So the library is based around additive drawing - there is no clearing of screen state between each frame so everything builds up. My next plan is to build a "display list" system when you can attach co-routines to properties of each display item to animate them - more flexible than this current system.
While working on my 3d engine I've written a function that I think would be generally useful and I haven't seen it done before. It draws horizontal dithered lines such that odd and even rows have an alternating checkerboard pattern. Code is obviously in the cart but I post below as well.
The code runs just as fast the native LINE function but with the bonus of optional dithered-e-ness
function dither(sx,ex,y,draw_colour,shade_colour) if (sx<0 and ex<0) or (sx>127 and ex>127) then return end sx = max(0,min(sx,127)) ex = max(0,min(ex,127)) if ex < sx then sx,ex = ex,sx end local sos = sx % 2 local eos = ex % 2 local yind = y*64+0x6000 local ctu = -1 if y%2 == 0 then ctu = draw_colour else ctu = shade_colour end if sos == 1 then sx -= 1 poke(yind+sx/2, bor(band(peek(yind+sx/2),0x0f), band(0xf0,ctu))) sx += 2 end if eos == 0 then poke(yind+flr(ex/2), bor(band(peek(yind+ex/2),0xf0),band(0x0f, ctu))) ex -= 1 end memset(yind +sx/2,ctu, (ex/2-sx/2)+1) end
The tricky bit being to deal with the start and end of the line when they do no perfectly align with the byte boundaries.
I've finally managed to get a clean, 3d wireframe engine up and running. It does backface culling but otherwise is as plain as it comes.
Working through the maths and pulling together from various sources was a pain as writing a software renderer is a bit of a lost art form with D3d/OpenGl doing all the maths for you these days.
So I thought people might appreciate a simple example to start from.
THis doesn't do any camera transforms - the camera is at 0,0 starting down the z-axis.
Another memory game to go along with my earlier "Simon Says" game.
I really loved the low-to-high game from Brain Training so thought I would implement it here. If I take this any further the I think I'd double the size of the tiles and make my own font as I have difficulty 'scanning' the numbers with Pico's default font.
My personal high score on this Pico version is 9 numbers cleared (I was way better at the DS version!)
A rough and ready "Simon Says" game I hacked together in a few hours. Use the arrow key to play the appropriate triangles and follow the sequence. What high score can you get?
I am inordinately proud of the code that draws the triangles as I got it right first time.