Rados Jovanovic

2025– ai exhilarating

Without a care for token price, riding along with the evolution of models.

2019– honing the craft

CM Labs, then 3dverse. Rendering systems as a lifestyle.

2016–2018 papers after hours

Graphics and voxels by day; graphics, computer vision, machine learning by night.

1. Sensor Fusion and State Estimation via a Kalman Filter

   (2018)

   

   I played with Computer Vision a bit more, and implemented a Kalman filter: a moving camera looks at a moving object, and the filter estimates where the object is, in camera space, from noisy sensors. The camera has a stereo sensor and an accelerometer, the object has an accelerometer as well, and everything they return is flooded with noise.

   It works excellently while the objects have constant acceleration. The closer I got to a real-world scenario, the worse it got, and it is very sensitive to the noise covariance matrices you supply it. That is expected from the regular filter; the Extended and the Unscented variants exist for exactly this.

   The code is on GitHub.

2. Anomaly Detection

   (2018)

   

   Using Python and a set of n-dimensional points, I made a little script which learns how the points are distributed and flags the ones which do not belong. Semi-supervised, with two models: Gaussian and Multivariate Gaussian. The Multivariate one can describe correlations between features; the regular one cannot, but it is cheaper.

   The code is on GitHub.

3. Kernel Density Estimation and Mean-Shift Clustering

   (2018)

   

   This little script clusters points using Mean-Shift, in Python. I compute a Kernel Density Estimate over the points (Gaussian, Uniform, or Epanechnikov kernel), then climb the density with a gradient ascent. Each peak is a cluster center. The only input is the kernel bandwidth, and Silverman's rule of thumb picks that, so there is nothing to tune.

   The code is on GitHub.

4. Maximizing Parallelism When Constructing Binary Radix Trees

   (2018)

   

   When I read the abstract of this paper I was so excited! You can construct a binary radix tree by just looking at a single node at a time, and therefore construct it in a completely parallel way! A GPU friendly algorithm.

   For a small dataset (50k points), four threads did not quarter the execution time; creating and destroying them took about 55% of it. Still a bit faster than serial, and a pool of threads which stay alive fixes it. The positions have to be converted to Morton codes and sorted first. CPU-only, in C++11. The code is on GitHub.

5. K-Means Clustering

   (2018)

   

   K-Means, as a header-only generic algorithm in C++11. Give it the points and the number of clusters, and it assigns each point to one. Nothing too crazy. Most of the labour was putting a renderer in.

   The code is on GitHub.

6. Moving Object Detection

   (2016)

   

   I wanted to play with computer vision a little, so I implemented the algorithm from the paper Detection of moving objects in non-stationary cameras in 5.8ms. The camera itself moves, so its motion has to be compensated first. Pretty cool!

7. Voxel Farm

   (2016)

   

   I got to play with voxels while working at VoxelFarm! I also built a physically based deferred renderer, with water, screen space reflections, light, shadows, stars, clouds, and sun, for a very volatile world.

   I got very fluent in finding spooky bugs arising from misplaced variable assignments in a knotted multi-threaded environment. And I got to work with Unity, Unreal, and web platforms as well.

2013–2015 thesis and Hela

A master's at York, and a game that got away.

1. Hela

   (2015)

   

   A fantastic and ambitious project: an educational game about cancer, where you take the role of the cancer. The intention was to show people that it is not some unknown monster, that it has weaknesses, and that you can fight it.

   It ran from the beginning of 2013 for just shy of three years, with Kevin Neibert (Ph.D., Pharmacology and Therapeutics) and Sebastian Alvarado (Ph.D., Molecular Biology). For it I created an engine with soft bodies and exposed all of it to Lua, down to the GLSL shaders, so the entire game could be designed in Lua. It ended before completion, and it is slumbering in the state it is in.

2. Database Driven Multi-Agent Behaviour Module

   (2013)

   

   For my master's thesis I designed a library for processing agent behaviours with a database at its core: game logic is mostly queries over the game state, and databases are very good at queries. (An agent is an autonomous entity which observes an environment and acts upon it.)

   I implemented it, attached it to a game engine, and made a small game prototype. The game logic system defines the game state, calls the proper behaviour function for each agent, supports events, and uses indexing to speed up the queries. The results are favourable, especially considering the sub-optimal implementation (it was a research project!). C and SQL on PostgreSQL, with the client in C++.

   You can grab my thesis here, or just the abstract.

2010–2012 contracts and Traps!

Work shipped for clients, and the most complete game made so far.

1. Product Of Italy

   (2012)

   

   It is the year 2013, and cooking will never be the same again! No more juggling ingredients and panicking about getting a 5-course dinner out on time. A little virtual brain constructs a schedule which minimizes your time in the kitchen, while keeping a bunch of kitchen-critical things in mind.

   That planner was my ingredient in this iPad cooking app: tasty food from all regions of Italy, with cooking episodes starring chef Massimo Bruno. Once you have tasted the food, you will want to overwhelm your kitchen with this deliciousness!

2. SPLIT BlackJack

   (2011)

   

   SPLIT BlackJack is a BlackBerry game where the cards are split in half and dealt like that, and you combine halves of the same number to create a whole card! Otherwise, regular BlackJack.

   I developed it for MagiLab with my partner Zhanna Brener.

3. We Will Remember Them

   (2010)

   

   An online extension of the documentary We Will Remember Them, and a tribute to Canadian soldiers fallen in battle. Relatives and friends tell us who the soldiers were, and their communities add to the stories. The stories are laid out on a map and on a timeline, for a clearer picture of the events and a more personal look into their lives.

   I created it for the Canadian Broadcasting Corporation while working at Orange Paperclip.

4. Traps! Game

   (2010)

   

   Traps! is a browser game where you defend your treasure from invading enemies using only your traps and your wit. Fast-paced, top-down, blood-boiling, trap-setting arcade.

   Three tile sets, two types of nasty monsters, six traps, three abilities, and, unfortunately, only three levels. Underneath: collision detection, particles, effects, AI, and pathfinding, stapled together by a few useful design patterns. I coded it in Java, and the level editor in C#, with my partner Zhanna.

2007–2009 classes and contracts

York's Intelligent Systems stream, a year in Germany, first paid work.

1. Autodesk 3DS Max PhysX Ragdoll Creation Tool

   (2009)

   

   A little tool for Autodesk 3DS Max which generates PhysX-compatible ragdolls for use in a simulation, based on the nVidia PhysX plugin. It follows the bone hierarchy of the mesh, makes a ragdoll for every bone, and links them together; after that, each ragdoll and joint can be fine-tuned to taste.

   I created it during my stay at the Fraunhofer Research Institute in Sankt Augustin, Germany.

2. The Tudors Season 2 and 3 Data Collector and Webpage for CBC

   (2008, 2009)

   

   An interactive data visualization web page for seasons 2 and 3 of The Tudors, for the Canadian Broadcasting Corporation. A server perpetually scans the internet for blog posts, news stories, and photos about the show, and a front-end displays them in a visually meaningful and pleasing way. The designer, Eva Riinitze, did a wonderful job of organizing that vast amount of information. I coded the server in C#, and the front-end in ActionScript 3.

3. Rotating and Translating Objects in CAD Systems with Collision Correction

   (2008)

   

   A new, or simply not widely used, way to control objects in 3D space with a 2D input device, aimed at CAD systems. Three assumptions: every object is touching a surface of another object, objects do not interpenetrate, and you are looking at the object you are manipulating. On those, a pixel-based collision detection and correction in GLSL lets you translate and rotate objects by dragging them directly. I also implemented the standard widget-based controls, for comparison.

   It is fun and easy to work with objects in this way, but since it reads the framebuffer, the entire object must be in view to guarantee correct results. I assume that huge restriction is why CAD systems do not do this. Maybe if we add cube mapping into the mix...

   A university project, so it does contain bugs, and it requires a decent video card (by 2008 standards).

4. AIEngine

   (2008)

   

   AIEngine is a library for giving virtual agents reactive or goal-based behaviours, based on first-order predicate calculus, with actions defined in a variation of STRIPS.

   Reactive behaviours are finite-state automata. For goal-based ones you give an agent a goal, a set of predicates which you wish to become true, and a planner figures out the steps which make it so. If a locked door is in the way, the plan is: go back, press the button which unlocks it, return, pass through.

   Special predicates ignore all rules of logic and execute custom code instead. That allowed for an A* pathfinding predicate, a cat-mouse-cheese game, and a Mars exploration mission.

   Worlds and scripts are text files, for faster prototyping (and debugging. I needed that.) A year-long university project.

5. Procedural Brick Shader

   (2008)

   

   A university project: a procedural brick shader in GLSL (the bricks are computed per pixel, not read from an image), with per-pixel lighting, normal mapping, parallax mapping, and texture mapping.

6. Immune System Educational Game

   (2007)

   

   The world outside of your body is ending. New strains of pathogens are evolving at a rapid rate. Your body is under attack!

   You are in control of your immune system. First you must identify the enemy, and since not all white blood cells have eyes (well, none do, but some can bind to pathogens), you need different types of cells for different purposes. You directly control one cell at a time, the AI runs the rest, and the pathogens attack multiple parts of your body at once. You can construct more white blood cells, but choose wisely which type you need next.

   A real-time action strategy game, made for my Game Development class at Hochschule Bonn-Rhein-Sieg in Germany.

7. Autonomous Discovery and Navigation with a Mobile Robot

   (2007)

   

   This was my little friend with whom I played for my Robotics class at Hochschule Bonn-Rhein-Sieg in Germany. And I got to take it home as well! I created two algorithms for it: one to discover the obstacles in an environment, and one to navigate to a point in it.

   It maps its surroundings with five distance sensors: placed on the ground, it drives around an area of predetermined size, and once it is done every cell of a grid is marked as blocked or free. It is guaranteed to reach every accessible cell. With that map, a modified A* finds a path to any accessible point. All of it had to fit in the very limited memory of a MIPS microprocessor.

   It was very fun to work with this creature, even when a wheel or two would randomly fall off at the most unwanted moments.

2001–2006 building and classes

From 2D sprites to ray tracing, and engines built with confidence.

1. Simple Raytracer

   (2006)

   

   I developed this ray tracer for a university class. I was given a simple C++ framework with ray-sphere and ray-cube intersections and a function for writing the image buffer to a file, and the task was to fill that buffer. I implemented lights, shadows, reflections, refraction, and opaque, transparent, and "imperfect transparent" surfaces.

   Screenshots here and here.

2. Top Down Shooter

   (2006)

   

   I like the idea of procedurally generated levels: infinite variations, and some work off the shoulders of artists and designers as well.

   So: a top-down shooter with procedurally generated rooms and the most advanced physics I had created to date (actors have a hitbox for each limb!). Every room gets an entrance on the bottom wall and one on the top, and everything else about it is random. You can shoot and make enemies vanish (they can do the same to you), walk from room to room, and move objects around. And there is a table. The physics is done by the ODE library.

3. Image Processing on GPU: Sobel Filter

   (2005)

   

   One of my first GLSL applications: a GPU-powered Sobel filter. It finds the edges in an image.

4. VOID Engine

   (2005)

   

   As soon as I felt like I finally knew what I was doing, I started to work on a 3D graphics engine. And then I found out I did not really know what I was doing. But that mattered not. Making the VOID Engine was a fantastic learning experience, since most of what I implemented I had not played around with before:

   • An OpenGL 1.x renderer.
   • Octrees, pre-calculated or generated on-the-fly.
   • A material system with 6 kinds of materials, set inside 3DS Max and exported in the 3ds file.
   • Multiple rendering pipelines for older video cards: ARB fragment/vertex programs, nVidia register combiners, and a simple native path.
   • A particle system with sorting for proper blending.
   • A post-processing glow effect.
   • Shadow mapping.
   • A converter of 3ds files to my own mesh format, which sorts polygons by material for faster rendering.
   • Tokamak physics. (Not really a graphics engine feature, but I needed falling boxes.)

5. Domination

   (2001)

   

   Domination is a turn-based RPG strategy set in a fantasy world, for up to 3 players, human or AI. You create your hero, a warrior, a rogue, a wizard, or a priest, adjust their statistics, and the game starts. Along the way you summon units to fight alongside the hero: 9 different units, 8 wizard spells and 3 priest spells, and walls to build.

   I created it with my partner Milos Stojanovic for a national high-school student showcase. It was our very first complete non-space-invaders game. Both the game and its level editor are coded in Delphi.

–2000 first steps

When the greatest QBasic games and apps were proudly made.