By YazwhoEdit: I am not currently developing this project. I'll leave this here as it might be interesting to someone!
Happy New Year all! Given the site is a bit slow, I thought I'd show off the latest version of my player.
The biggest change in the latest version is that the commands now have 2 bytes of variable space to store their state, hopefully leading to some more interesting effects. You can hear an example with the 'warbling' on the track included. It's not vibrato by any stretch, but adds a little something. Hopefully you can hear the difference to the previous version here and agree its an improvement! (I am by no means a musician, so your mileage on that may vary!)
The 'tracker', BitPlayer, that I'm using and developing is still relatively basic in terms of its UI, but is slowly but surely maturing. This uploaded .prg file is what is produced when the X16 emulator is launched from the tracker. It's all hosted on Gitlab here. The .json file attached is the 'mod'.
There are of course a fair few things to do, the list is something like this:
PCM support Change the output to my own new templating engine instead of ca65 YM2151 support (X8 depending) Change the sound engine to use a common engine with the emulator that better represents the X16 - Probably by embedding a emulator directly into the application The new templating engine removes all the typical restrictions that 'macro assemblers' can have. It's written in c# and is currently based on the Razor engine. As such it's easy to embed within an application like BitPlayer to produce 65c02 asm. The engine and the compiler have a little way to go, but if you're interested there is more information here.
The track was originally by Archyx and can be found here.
By YazwhoHope you enjoy this little intro! Best viewed on a local emulator. The web one doesn't seem to handle the audio too well.
More on the audio player:
Original mod by Archyx. See their other mods here: https://modarchive.org/index.php?request=view_artist_modules&query=69244
Thanks for looking.
R39+: Doesn't work (has bank switching)
By YazwhoA new little intro, featuring full frame rate vectors!
Original music by cerror. See their other music here: https://modarchive.org/index.php?request=view_profile&query=85822
By rjeThis is a pale imitation of the DMS-250 SOS command line.
It's based on a Perl script I wrote many years ago. It has a little bit of training value -- you can set the boot files for a switch and then do a restart. That's something you couldn't "practice" in the olden days without booking time on a switch. There's also a rudimentary TTP layer, if you know how to get to that.
It's fairly ridiculous, except for nostalgia value.
It does very little, and requires that you know DMS-250 SOS already.
* you can enter DISKUTIL
* from DISKUTIL, you can LV 0, LF on the images, and do elementary CBF and SBF commands.
* you can do a restart reload, restart cold, and restart warm (that's how you log out)
* you can go to TTP and post a trunk. You can then bsy, offl, or rts it.
By rjeA demonstration of the use of C, sprites, and banks to create a tiled map.
Everything is quite primitive right now. The scrolling is terrible.
The map is 256 x 256 and stored in banks 10-17 (it's 64k). My plan is of course to make it larger.
Use the cursor keys to move about the map.
By SlithyMattGot a day to kill with your X16? Run this BASIC program and generate this 256-color fractal plot. It's zoomed into a deep part of the Mandelbrot Set that is particularly pretty. This plot does up to 355 iterations and is within an area where all points require at least 100 iterations, so the whole 256-color palette is able to be represented, from white for 100 iterations to black for 355 iterations or more.
For fastest results, run in "warp" mode with your emulator:
x16emu -warp -bas x16-mandelbrot-vga-fancy.bas
At 8Mhz, this will take literally all day, but if you have a beefy enough host for your emulator, it can be cranked out in a couple hours.
By YazwhoThe BitMagic example.
It decompresses (inflates) a 320x240 256 colour image, from the 32k .prg file.
By JimmyDansboSlideshow showing some of the progress of the Commander X16 project.
By desertfishThis is a multi-format image viewer program. It supports IFF, PCX, BMP and Koala (c64). It supports full-screen 320x240x256 color bitmap mode and IFF Color Cycling !
Due to emulator restrictions (it seems) It only works when running from an sd-card file, so I've provided a zipped one that contains the program and a few sample images.
The source code is here https://github.com/irmen/cx16imageviewer
The video below shows the program in action!
By SlithyMattHere is the 2021 version of my X16 Christmas Demo, including new graphics and my own YM2151 arrangement of "The Carol of the Bells".
The Commodore Labyrinth demo written entirely in BASIC from the early 80s. I've updated it a little bit and I'm trying to understand and untangle some of the spaghetti code.
By kliepatschA simple 8-bar loop song bringing you dance floor vibes.
To reduce jitter and audio dropouts, run the demo locally.
It uses all 16 PSG voices and a couple of FM voices.
Would you like to code some graphics to be accommodated by this song? Send me a PM 🙂
This is my first "proper" program written for the Commander X16, and it is written entirely in BASIC. I wrote it mostly so that I could get a feel for how logic and moving between sections of code works, as well as to help with understanding how to draw pixels to the screen using the PSET command. At the moment, I know there are ways I could optimize my code, but at the same time I'm not sure quite how much faster I could get the program to really run. If I make any real, tangible changes to the code, I'll update the file on here with what I changed.
Currently, the program offers four possible modes of drawing color to the screen:
MODE 1 - 2-COLOR (draws a random black-and-white static pattern to the screen)
MODE 2 - 4-COLOR (draws a random 4-color "3d goggles" static pattern to the screen)
MODE 3 - 16-COLOR (draws a random 16-color static pattern to the screen)
MODE 4 - 256-COLOR (draws the default 256-color pallete to the screen)
I know this really isn't much and there are far better demos for the Commander X16 out there at the moment, but I still feel proud of what I wrote, considering how inexperienced I am at writing for the system.
I've been investigating the feasibility of using fantasy console development environments to develop new fantasy-console-style video games for the Commander X16 and also to potentially port existing fantasy console video games to the Commander X16. I've primarily been investigating the PICO-8 and TIC-80 fantasy consoles (see https://www.lexaloffle.com/pico-8.php and https://tic80.com/ ), but there are a variety of fantasy consoles/computers (see https://github.com/paladin-t/fantasy ).This Commander X16 demo repetitively cycles through sequential display of the PICO-8 color palette, sprite sheet, and 16 screens of the map that I imported from the PICO-8 CELESTE video game by Matt Thorson and Noel Berry which was the initial basis for their computer/console version (see https://en.wikipedia.org/wiki/Celeste_(video_game) ).
A simple demo creating a random road and the player moves the car sprite around.
By ZeroByteThis demo is made from original game assets and translating the VGM tune into YM2151 + VERA PSG.
I made this demo because I think too many people forget just how great the graphics can be on the X16. I also think the FM music is vital to the 16-bit era of gaming, so this demo shows how the Commander X16 can deliver the goods if you like a 4th-gen experience.
By desertfishI needed a test program for the graphics routines in Prog8 that now also work in highres 4 color screen mode.
I thought it would be fun to replicate a classic Amiga Workbench desktop screen, using just the graphics drawing commands.
Note that the text font is actually the built-in iso charset. It is fairly similar to the Amiga's topaz font, so I just went with it and didn't bother to replicate the font pixel-perfect.
Also I didn't bother to make a nice white/red sprite mouse cursor, maybe I'll try to add this in a later version.
Here is a screenshot of a real Amiga Workbench 3.1 in action:
By desertfishEarly Amiga-demoscene inspired raster bars with color gradients.
The color gradients are randomly generated.
Written in Prog8 with a bit of inline assembly. Source code is available here https://github.com/irmen/prog8/blob/master/examples/cx16/colorbars.p8
By rjeA simple file that graphically shows the values of several registers in the X16 which change regularly -- for example, the top of the accumulator stack, and some of the I/O registers.
It's an attempt to replicate the "blinking lights" of systems that used to use big ol' LEDs to represent register contents, alarm bars, and whatnot.
The C source is here: https://github.com/bobbyjim/x16-blinkenlights
By YazwhoAs has been pointed out recently there is tooling for the X16, especially in terms of trackers.
There have been a few great examples of music on the forums, either playing a Amiga\C64 mod, or via a X16 tracker. And these are great.
That said, I did think maybe the community was missing a trick. If the goal is to make music for the X16 do we need to be able to run the tracker on it? Doesn't that make writing everything harder? If you have a modern machine, it would be easier and quicker to create a tracker on that. UIs are easy. MIDI keyboard integration is a mere nuget package away. Can hand edit json files if you want. IO is trivial. That's not to say writing a tracker for the X16 is wrong, it's just a different goal.
So that's what I did. Apart from the emulation of the X16's PSG which took a while to get going, it wasn't so bad to do -- WPF aside. I've ended up with an application which lets me produce X16 music. It can export an .asm file which can be imported into ca65, making integration into a project really easy with just two calls. It only uses single digit worth of cpu lines and 32 bytes in the ZP, so is pretty lean. That said, it does not yet support PCM audio not commands.
The music from file attached is sourced from part of a demo file that comes with FamiTracker. What did occur to me while doing this, is that VRC6 ( https://en.wikipedia.org/wiki/Memory_management_controller#VRC6 ) music is pretty damn good. In fact I'm sure a player for .ftm files could be written. (Given how long it took to get just the first 3rd of a demo file working, I might write a pattern importer myself..!)
For me, the audio quality demonstrates that Vera's PSG and some form of PCM is all that's needed for audio on the X8/16. (Sharpen your pitchforks!) It just needs to be a bit louder!
What next? Like all projects that have gone from 'Proof of Concept' to 'Production' in one step, has resulted in some of the code being a bit crap. Especially on the WPF side! If anyone is interested, I'll try to shore the code up and will post with an explanation of how it works soon.
For now the display shows the four counters. Counters for Frame, Line, Pattern, and the Next Line. Source is the VRAM address (I use VERA to stream out the data for the patterns, as it makes life much easier. I can't understate how useful this feature is.)
The bottom table is:
VERA registers Address of the instrument data Instrument Position Command Note Number Instrument Repeat Command 2bytes Parameters
I just started assembly programming last week and this is my first project after about three days of work. I hope you enjoy it!
The effect isn't quite complete yet but for now its all I'm able to get working.
This is a single program listing that contains three different versions of the Proteus Demo from my thread in HOWTOs on converting and optimizing BASIC programs.
Version .02 was from very early in the conversion/optimization process from that thread and, consequently, is quite slow. Its also got the original author's bad scaling coefficients, which make the output look a little gnarly.
Version 1.0 was originally what I thought would be the 'fully optimized' version, with all sorts of things (documented in the thread) done to squeeze out better performance. And of course the scaling is fixed so the output looks better. This was supposed to be the end of the thread, except that...
Version 2.0 takes advantage of something I noticed about the calculations, which led to the idea to have the program start off by precomputing a table that allows us to avoid having BASIC redundantly performing a bunch of the most expensive operations in the program. Even considering (and counting) the over minute-and-a-half it takes to initially compute the lookup table, the trick resulted in nearly halving the time to complete plotting the output compared to what was the previous fastest version. (Of course, I now wonder if some of the better math and coding gurus have been rolling their eyes all along, just wondering when, if ever, I might figure this part out...).
Just RUN it and pick A, B or C from the menu. When its done plotting and puts up the elapsed time (its in HHMMSS format) you can press any key, and it will 'LIST' the program lines that correspond to the version that just completed plotting.
I hope folks find it helpful having the three versions (and the howto thread) in terms of seeing how the thing evolved. You will notice that the more tweaking you do for speed, the more opaque and confusing the program becomes in terms of ever expecting someone with fresh eyes to try and see what the heck is going on. That 'early' version is included, in part, because its much easier to follow than the others.
More info at the thread here:
This weekend, I decided to play with X16 BASIC using the emulator and wound up making an X16 adaptation/extension of a short program for the Plus/4 that appeared in 'The Transactor' journal decades ago. The program uses three parameters: "S" (squiggles/spokes/segments), "W" (wave factor), and "A" (amplitude). Using X16 BASIC's extensions in terms of bitmap drawing commands, it outputs a neat design with lots of color and a surprising amount of visual variety.
The original Plus/4 program just plotted in black and white and had some built in limitations (and at least two bugs), but I decided to extend the program, add a menu, and upload it after I added color and decided these were fairly cool looking results from such a short simple BASIC routine.
It strikes me as a cool demo because with just three core parameters, you can get an astonishing range of outputs. Of course, like many graphics demos based on stacking transcendental functions, there are combos of inputs where the functions will sort of fall apart and produce something akin to a kiddo scribbling with crayons , but there are also weird "islands" in the domain of possible parameter combinations where order re-asserts itself, both in terms of what gets drawn and (because colors are picked by an AND mask over one of the function variables) how the colors play out. Note that I included a sample screen shot about some weirdness you can get with very high numbers. Mostly that is the result of my simple use of .01745 to convert between degrees and radians, and is caused by amplifying that really simplified rounding of PI/180.
There are 4 'modes' of operation you can pick from the menu. You can specify inputs for S, W and A manually; the program can run a sequence with fixed S and A while incrementing W; there is a mode that tries to picks random parameters within several domains where the program produces nice outputs; and there's one that just reads the inputs from some "presets" in DATA statements. (You can of course add your own 'best of' examples by adding data statements between lines 432 and 499).
I always considered myself a passable BASIC programmer, but this weekend showed me I'm really sort of rusty so please go easy on me if I did something inefficiently or especially 'dumb' in my implementation. The main output routine is extremely crunched (sorry, not sorry) and I did some further things to optimize from the original program for purposes of getting a bit more performance out of the main routine. Although it absolutely crawled on the Plus4, I think its fairly impressive on the X16 especially if you look at the sheer amount of sines, cosines, multiplications, and variable fetches /updates that occur during an entire cycle through the primary output drawing loops.
The X16's 40 column mode (SCREEN $00) was used to key this in and format it, so its probably best if listed/ displayed/reviewed in that mode, Tested on emulator r.38, and I don't see anything in the pending updates for the next emulator release that would break anything here.
If there are questions about why/how I did something I'll be happy to answer. In fact, if there's any interest in a more detailed write-up of this short and fairly simple program (e.g., section by section, and line-by-line), I would be happy to give it a shot, especially if there are folks new to Commodore BASIC that might find it useful. It seems to me there are many highly advanced programmers for the X16 posting on this site who are using assembly, C, and even languages they are developing themselves. Its amazing! However, its surely the case that part of the mission of the X16 is to get some newbies involved, and from where I sit, that really does mean getting some more content up here written in BASIC. Keeping that in mind, I'll probably be diving back into more old issues of The Transactor to do more conversions for the X16 and will continue to upload as long as I'm still having fun with BASIC. Cheers.
By CursorKeysX16 Forum
This is my third "Double PETSCII" demo.
But this time around, the colors are gone. It is only black and white.
This is a converted PETSCII picture,
the trick was to see if with no colors still some nice effects could be done.
Besides PETSCII, there are also a few effects.
The demo is written in KickC, and the PETSCII editor is once more the
alfa version of HyperPetscii.
The link to this can be found here: https://hyperpyxel.com/?p=229
Note: It is still pretty unstable and does not work well on a browser in the MAC for some reason.
If you cannot run it on an emulator, you can see it on youtube here: https://youtu.be/3x7OieGqQCg
Keep cool, and keep it (DOUBLE) PETSCII.
By a9mThis demo features 3D rendering to a 256x240@8bpp surface with full transformation calculation, texture mapping and per-pixel depth buffering. The model is a decimated Spot test model with 512 vertices, 1020 triangles and a 256x64 texture.
So, I wrote this just to get familiar with this system and figure out how to write and optimize a 3D math for it. Also, it would makes a nice reason for me to get up and do some coding streams, as shown here:
Only runs on r39 since I can't find documents for older versions. There's still bunch of incorrect pixels due to depth buffer precision problems.
A/D - Move camera left/right W/S - Move camera up/down Q/E - Move camera backward/forward (Z value should be an unsigned number but the UI only displays signed numbers) J/L - Rotate left/right (yaw) I/K - Rotate up/down (pitch) U/O - Tilt left/right (roll)