The Concept

Being a musician (drums, synths), one of my favorite programs is Renoise. After learning to program, I remembered that Renoise offers a Lua API to create extensions of the program! I decided to make a game within Renoise. Wanting something classic, I decided on Pong. The only other game made using the Renoise API is a port of Nibbles ("Nibbles" is a Snake clone included in FastTracker2).

Engineering a Display

The Renoise API doesn't really offer a way to directly control pixels. Instead, it offers elements like sliders, knobs, text boxes, etc. However, I found that I could control a grid of tiny bitmaps (loaded from the filesystem) to create a "virtual screen"! Each frame, I had to manually update bitmaps, rather than blanking the whole screen and redrawing everything as graphics engines typically do, because Renoise isn't very fast at updating large amounts of bitmaps (it can update ~100 bitmaps at 25 frames/second).

The Launch

After some development, the game had a rainbow that trailed behind the ball, an AI opponent, a 2-player mode, sound effects, and more! Within 24 hours of its release, it was featured on the front page of the Renoise website's "Tools" section (where it still remains today), and even received recognition from Renoise's lead programmer and CEO; Eduard Müller (aka "taktik").

Upgrading the Display

After the game's release, I discovered that Renoise provided another GUI element capable of creating a "virtual screen". Buttons can be scaled, and colored via a HEX color-code. This change offered a full 8-bit color display—capable of displaying 16,777,216 colors! To top it off, Renoise updates them 9x faster than bitmaps! I also implemented a double frame buffer system that only pushed updates to buttons that needed it. This allowed for more complex graphics, as I could now blank the screen each frame!

Utilizing the New Display

I had been studying some water simulation algorithms for use in my 3D graphics projects, and decided to implement a water simulation in my Pong game for some nice visuals! The update was released and received more positive feedback from the Renoise community!

Hopes

I sometimes worry that Renoise will cease development. Its keyboard–only tracker-style approach was common from the 1980's to the early 2000's, but most users today prefer a piano–roll interface. I hope that my Renoise tools will attract more like-minded users to the program, and keep its development alive for years to come.

The Purpose

During development on Reform, the need arose for the calculation and rasterization of various curves. My first solution was to use logarithmic functions. They worked, but implementing discrete mathematical functions for different curve shapes wasn't a very robust solution. I ended up going down a rabbit hole of math and 2D rasterization that yielded the desired result. This project was the testing ground where I isolated this task.

Infinite-Degree Bézier Curves

After a lot of digging, I found Bézier Curves. Compared to Linear, Quadratic, and Cubic Bézier curves, I wanted my curves to support an infinite number of control points. I found this recursive definition of a Bézier curve. After implementing this—along with the associated functions for Binomial Coefficients and Bernstein Basis Polynomials—my curves supported an infinite number of control points! A very proud moment indeed!

Tension

I wanted each control point to have a variable "weight" (or "tension") to control its influence on the curve. I found an amazing resource called A Primer on Bézier Curves by Mike Kamermans (aka "Pomax"), which contains a chapter on adding this "weight"! After implementing this new math, I now had infinite-degree, weighted, Bézier curves!

Rasterization

Bézier curves are rendered in a unique way. Rather than solving for X / Y coordinates per–pixel, you have to solve for t—which represents an interpolation between the curve's endpoints.

Naiveté

A naive approach is to just sample a high number of points, and fill the pixels where those points lie. The result of this approach is a curve that's too thick in high–tension segments, and breaking apart in low–tension segments. A better approach was clearly needed.

Pixel-Perfect

My solution was to sample a moderate amount of points, and connect them with line segments, which are easier to rasterize (which I later discovered is called "flattening" the curve). More robust solutions have been documented (such as in Chapter 4 of A Rasterizing Algorithm for Drawing Curves by Alois Zingl), but this solution would be sufficient, and quicker to implement. Wanting pixel–perfect, aliased lines, I found the Bresenham algorithm, which yielded a beautiful result!

Finished!

Being modular/loosely coupled, my finished code was easily implemented into Reform, with 2 curve types available now, and a custom curve editor to come in a future update. I will definitely be utilizing the knowledge from this project in other future projects as well! I can already imagine the possibilities of what can be created using these techniques!

The Concept

After the launch of Paddles, the need for a new Renoise tool became apparent; one that would make it quick and intuitive to powerfully fine–tune strums. The idea was inspired by FL Studio's "Strumizer" tool. It offers knobs and sliders to edit timings and velocities. You get realtime visual feedback of your changes to the notes. You can preview the audio by pressing the spacebar. Renoise, in comparison, lacks any such abilities, requiring users to edit notes one–by–one instead.

The Problem

Being a tracker, Renoise represents musical notes as text on a spreadsheet. By default, each cell on the spreadsheet corresponds to a 16th note. To have notes trigger in–between this 16th–note grid, you must type a hexadecimal value 0x00–0x80 into the "delay" column next to the note. This results in an inefficient process for creating strums that are not in sync with the grid's time division, requiring the user to manually type individual hexadecimal values for each note.

The Solution

A strum–editing tool for Renoise that would include: a playful UI, intuitive controls, realtime updates to notes, easy preview playback, strumming across pattern boundaries, and more. This would be quite a complex task to achieve in a tracker–based application.

Caching

To allow manipulated notes to overflow into other patterns, avoid colliding with other notes, and wrap from the end of the song to the beginning, it was necessary to know pattern lengths, song lengths, note positions, and more. The handing-over of all that data from Renoise's C++ runtime to its Lua API is slow, and Reform demands huge amounts of that data rapidly, hundreds of times per second. To improve performance, the data would be cached Lua–side after retrieving it from the Renoise runtime, and Renoise's Observer–style notifiers would be used to alert Reform when cached data was no longer valid. This resulted in a dramatic increase in performance (over 100x), and was architected in an easy-to-use, modular API.

Curving

The implementation of Beziér curves in Reform (developed via the Curves demo) allowed for selections of notes to have their timings "bent". Note timings are interpreted as being linearly distributed upon selection, and can then be redistributed along a Quadratic Beziér curve, or an S-shaped Cubic curve. More curve shapes could easily be added, and users could even be allowed to create custom curves via an editor, but for the majority of use–cases, these two curve types are robust.

The Result

The tool is accurate, performant, and fully–featured to a professional standard. This was achieved through long–term project organization, disciplined learning, patient problem–solving, and clever optimization. The tool has been provided for free, out of deep appreciation for the Renoise software.

Rendering

The game was first rendered using cout statements, but this didn't result in a framerate–capable runtime (although it did have a cool film–like effect). So I learned and refactored my code to write directly to the console buffer using the WriteConsoleOutputCharacter() function, which resulted in a stable image capable of faster framerates. It also allowed me to easily add some color to the game, using the WriteConsoleOutputAttribute() function.

Sound

As the project matured, I wanted to add sound to the game, and decided to learn FMOD Studio and the FMOD Studio API. From this endeavor I learned how to read API documentation, which assured me that I would be able to learn and use any libraries I want for future projects. I did successfully add sound effects, as well as music that is synced to the player's movement (each frame that the snake moves corresponds to an 8th note in the music). The music also reacts when the player eats a fruit exactly on a downbeat, gets a new high score, and more.