So yeah. I was wandering in WikiTI's Experiments page, section 3D engine, and went trough different links to see which ones included source (you know, documentation and all). I had heard about qarnos's Aether3D but in some way I never got my hand on it or anything related to it.

Until I found an actual download. The zip doesn't contain the lib's source unfortunately, but the lib itself has been compiled into a flash app accessible via the same mecanism that I use with PageSwap (mapping the app to bank A and stuff). Taking a look at the readme (an amazing readme, you should see it), I realized how awesome it was, and how close to OpenGL it actually was (scaled down to z80 calcs of course).

So it has pretty much anything one could expect from a 3D engine : rotations, camera handling, matrices, quaternions, model-loading automagic, arbitrary polygon-filling (any number of points), proper 3D clipping, all that stuff.

So I'm not doing it right now since it's 2:15 am, but I'm pretty sure it would be worth it to dive into it a bit (the zip includes an example and some models to play with), but I guess it'll be hard since the latest (understand : 2008) source is non-available.

Just pointing out.

<Hayleia> post it post it post it
<Hayleia> (then I'll tell you I never asked you to post it )

Hayleia forced me to post that (now you can't deny it ).

I wanted to see if I could still make a triangle filler with Axe. It appeared that I could, so I remembered that old 90's 83 demo saying "the first filled vector on calculators". So heh, here's another one. I also wanted to make an "old video recorder" effect on the screen.

So this will probably be a part of a demo, maybe yes, maybe no, we'll see.



As always, 6 MHz, not using Full, blablablah.

Hey guys,

Graphically impressive (read : useless) programs had always been my thing, so when I figured out that I could do some intense LUT-based demoscenes-like programs (my first one was actually nSpeedX3D, it uses the same concept), I took the only programmable machine that was near me : my TI-83+. Could have been my PC, but I was at school.

So, in a mere 3 hours I wrote a small LUT generator that takes X, Y as input (the center of the screen being 0,0) and gives U, V as output. Basically, X and Y are screen coordinates, and U and V are texture coordinates, so I use those to draw things on the screen with a bit-per-bit basis - very slow in Axe, but w/e, it was meant only to look good, not to be fast. Actually, you can argue a bit about it looking good, but I couldn't really do any better with Axe's precision and the z80 calcs' LCD.

So yeah, basically, to perform a plane deformation, you don't need many things :

• A texture (I use a 8*8 one),
• Two 6144-bytes LUTs (yup, that's a lot), one byte for the X of each pixel, one byte for the Y,
• Two equations, one that gives U, one that gives V.

So first, you want to make sure everything works. So you just do U = X and V = Y. It gives this.



(Note how the LUT generation takes ages. We actually generate 12288 coordinates.)
Now that you're certain it works, you can start doing actually funny and interesting things

r = sqrt(x² + y²)
a = tan^-1(x,y)

u = x * 8 // abs(y)
v = 512 / abs(y)


u = x * cos(r * 2) - (y * sin(r * 2)) // 256
v = y * cos(r * 2) + (x * sin(r * 2)) // 256


u = 1.0 /* (r * 256 + 0.5 + (sin(a * 5) // 2))
v = a * 3 * 256 /* 3.142


u = r * cos(a + r) // 320
v = r * sin(a + r) // 320


u = a
v = 1.0 /* r


Also, the whole program includes those 5 scenes and is only 1354 bytes. So it can be done very lightly.

To use it, just put a number between 0 and 5 inclusive in Ans before running Asm(prgmPLDEFORM). You need at least 13800 bytes of free RAM though. No test is done to see if Ans is out of bounds, but that shouldn't do anything else than displaying random garbage. Binaries attached, source will come later (when cleaned).

I'm going to make everything more ergonomic and release it as a pure eye-candy program I guess (among with some additional equations).

Hey guys,

I want to make, like, the simplest interrupt ever : increment a variable if the second timer (0x900D0000) reaches zero.

About interrupts, I already know ... nothing. I'd need something like :

attachInterrupt(0x900D0000, incrementTimer);
...

void incrementTimer(void)
{
  timing++;
}
Can anyone help me with that ?

FOR LATEST UPDATES, SEE LAST PAGES !

Hey guys,

After IkarugaX, it's time for me and my team (we three together make the "RMV Pixel Engineers" team) to work on another project

This time we chose to port a game (again) that the three of us wanted to see on a TI-83+/84+ one day, but couldn't find any version that was complete, fast and playable while remaining good-looking : Worms, by the almighty Team 17 !

I know there were several attempts to an ASM Worms, including TI-ny Worms a decade ago and Kindermoumoute and Hayleia' Axe Worms one to two years ago, but they both died, so yeah.

We started the project three weeks ago, so we had time to get several things working. You can also follow us as we progress on the game by regularly checking our site, which is basically a single web page where we put articles.

Latest screenshot (10/05/2014) :



Share comments

IkarugaX z80 danmaku / shoot-them-up

Alright, time to upload IkarugaX to Omnimaga's archive. After all, the project is born here.

http://www.omnimaga.org/index.php?action=downloads;sa=view;down=873

Hey guys,

Seeing the challenge TheMachine02 shamelessly sent me (), I wanted to try and do some 3D, but this time without defining any vertex by advance. So this came out.

What it features :

• 3D graphing of any function that only involves integer maths (8.8 maths are coming, maybe) on the [-6,6] range (13*9 = 117 dots)
• Dynamic movement around the graphed function : translation, rotation around the Y axis and zooming in/out
• Dots and grid view
• Clipped line routine !
• Support for animated functions. More on that below
• All of that in less than 2400 bytes of pure Axe !

So yeah, it's not really useful, but I found that it would be cool to try and do such program.

Small precision : the graphed function doesn't give exact results. I mean, there's no such thing as units. The only point of that is making good-looking results on-screen, it's not a mathematics tool.

How to use it : by default, prgmDOTSURF (Noshell executable) will graph the 2x² function. You can move around the graphed function with the arrows, zoom in with + and out with -, rotate left with [Y=] and rotate right with [graph], switch between dots and grid view with [mode] and exit with [clear].

You can also define your own function for the program to graph. To do that, just edit prgmFUNC3D. While I'm speaking about a "function", this is actually Axe code that you'll have to compile. I want to make this into a more user-friendly way, but I still have to figure how. Here're instructions on how you can define your function :

• The graphed function is f(x,z) = y. X and Z of the current point are passed respectively in r₂ and r₃, from -6 to 6 and -4 to 4 respectively. You are free to use these, but they must remain the same value at the beginning and the end of your function. They are used for the drawing code. Also, store the resulting Y coordinate into r₆. Do not use Return.
• You cannot edit any of the following variables, meaning that they must have the same value before and after your function : r₂, r₃, r₄, A, B, C, D, E, F, H, V, Y, Z, ?. Also, you can't use any of the bytes from L₁ to L₁+702, nor the 256 first bytes of L₃.
• If you want to use trig, do not use Axe's sin/cos functions, but type Sin() and Cos() instead. Those are way faster, LUT-based routines that I made. Remember that this will destroy r₁, unless you call it with sub(Sin) or sub(Cos) and writing the value right before it. Those functions still returns the same output as Axe's ones. Also, Y holds the current Y rotation angle.
• You can write animated functions : the O variable is a timer that gets incremented by 16 every frame. You are free to use it.

Remember that grid mode will lag a lot at 6MHz, since the program has to draw a line between each of the 117 dots.

So, I think that's all. For those who don't know Axe but want to try anyway, I give you some functions that you can copy in prgmFUNC3D (that will also be an example for those who want to write their own ) :

The default 2x² :
r₂*r₂*2?r₆

One of my favourite functions (also, one that demonstrates well the clipped line routine), the good old x³ :
r₂*r₂*r₂?r₆

Some animated sinusoidal function :
Sin(r₂*16+O)//4?r₆

More animated sinusoidal function to demonstrate the use of both X and Z coordinates to generate Y :
Sin(r₂*16+O)+Cos(r₃*16+O)//4?r₆

Here's a little screenshot that describes the process of drawing 2x² and navigating around the graphed function (at 6MHz of course) :



Don't be horrified by the how-so non-user-friendly interface, I'm working on it

prgmFUNC3D is the program you have to edit to write your own function, prgmSINE3D is the source to compile, and prgmDOTSURF is the executable (here, it contains the 2x² default function).

Feel free to make functions, share them with others if you want, and don't hesitate to ask if you have questions

Hey guys,

With TheMachine02 we made a contest about who could write the fastest 3D cube, me vs GLib The rules are simple :

• XY rotation
• The cube must be made out of 8 dots that are always visible
• Each dot appears on-screen as a 2*2 square
• No ASM code, only pure Axe
• 6 MHz only

My program reaches 56 FPS (when not moving, and 54 FPS when moving) while respecting all these conditions. I'm pretty proud



And here's the source :

:.FASTCUBE
:#ExprOn
:FnOff
:Data(‾40r,40r,‾40r)→°Verts
:Data(40r,40r,‾40r)
:Data(40r,‾40r,‾40r)
:Data(‾40r,‾40r,‾40r)
:Data(‾40r,40r,40r)
:Data(40r,40r,40r)
:Data(40r,‾40r,40r)
:Data(‾40r,‾40r,40r)
:
:Buff(6)→°Back
:
:L₃→°CosLUT
:
:L₃+512→°CosX+2→°CosY+2→°SinX+2→°SinY+2→°CXCY+2→°CXSY+2→°SXCY+2→°SXSY
:
:‾1
:For(256)
:Select(+1,cos(→r₁)→{r₁*2+°CosLUT}r)
:End
:
:0→X→Y
:
:While 1
:Sin(X)→SinX
:Cos(Y)→CosY
:Sin(Y)→SinY
:*SinX//128→SXSY
:Cos(X)→CosX*CosY//128→CXCY
:‾CosX*SinY//128→CXSY
:CosY*SinX//128→SXCY
:
:°Verts-6
:For(8)
:{+6→r₂}r*CosY+(SinY*{r₂+4}r)//128→{°Back}r
:SXSY*{r₂}r+(CosX*{r₂+2}r)-(SXCY*{r₂+4}r)//128→{°Back+2}r
:CXSY*{r₂}r+(SinX*{r₂+2}r)+(CXCY*{r₂+4}r)//128+192→{°Back+4}r
:
:Rect({°Back}r*64//{°Back+4}r+48,{°Back+2}r*64//{°Back+4}r+32,2,)
:r₂
:End
:
:DispGraphClrDraw
:getKey(3)-getKey(2)*4+Y→Y
:getKey(4)-getKey(1)*4+X→X
:EndIf getKey(15)
:Return
:
:Lbl Sin
:-64
:Lbl Cos
:{^256*2+°CosLUT}r

Generated by the BBify'r (http://clrhome.org/bbify/)

If you want to try, please do