Halogenica

Adding Underglow to DZ65RGB and QMK

michael.robert.romero@gmail.com (Michael Romero) — Thu, 03 Oct 2019 00:00:00 +0000

I recently built a DZ65RGB keyboard to replace my TADA68 and I’ve been thrilled with it, but it is lacking one major feature: it has no underglow support. So I undertook a challenge to add high quality LEDs to the underside of my favorite TADA68 case, powered through the DZ65RGB PCB, and controlled by the keyboard microcontroller (an STM32 ARM Cortex) running the QMK firmware. While underglow is a configuration setting in QMK for many AVR microcontrollers, it is not supported out of the box for the STM32 ARM microcontroller, and it conflicts with the individually addressable RGB LEDs. This is a detailed tutorial on the hardware and software required to enable additional dimmable lights to any STM32 keyboard with full production-quality integration.

Custom Keyboard - DZ65RGB

michael.robert.romero@gmail.com (Michael Romero) — Fri, 28 Jun 2019 00:00:00 +0000

My previous TADA68 build mysteriously bit the dust, so I decided to build a new keyboard and reuse my TADA68 aluminum case. Thankfully I found a fantastic (nearly) drop-in replacement PCB: the DZ65RGB. It is another 65% keyboard like the TADA68, and has my most desired improvements over the TADA68: individually addressable RGB LEDs, USB-C, hot-swappable switches, and a lovely purple and gold color scheme!

Custom Keyboard - TADA68

michael.robert.romero@gmail.com (Michael Romero) — Thu, 08 Feb 2018 00:00:00 +0000

As I learned more about the world of mechanical keyboards, I wanted to experiment with new switches, play with new keycaps, and most importantly try my hand at building my own.

Fez Viewer

michael.robert.romero@gmail.com (Michael Romero) — Wed, 14 Jan 2015 00:00:00 +0000

Fez Viewer is a tool that can load the models and levels from Fez, and allow you to freely inspect and fly through them. It currently supports loading individual art objects, animation sets, and even entire levels.

Cull Shot

michael.robert.romero@gmail.com (Michael Romero) — Mon, 28 Apr 2014 00:00:00 +0000

Cull Shot is a single player time attack shooter. It was created for Ludum Dare 29, with the theme “Beneath the Surface”. The player holds a button to charge up a “cull shot”; the longer you hold the button the further the shot is fired. The shot reveals red cubes underneath a diagonal landscape. Pressing another button will capture these cubes, each cube extending the time limit. The objective is simply to last as long as possible.

Sharing Resources Between DirectX and OpenGL

michael.robert.romero@gmail.com (Michael Romero) — Thu, 13 Mar 2014 00:00:00 +0000

I’ve recently had a need to simultaneously render using both DirectX and OpenGL. With this technique it is possible to efficiently perform some rendering operations within one API for part of an image, and switch to the other API for another part of the image. It can also be used to perform all rendering in a specific API, while presenting that final render target using another API. Providing direct access to graphics memory between APIs allows efficient and optimal sharing.

Monitor Overclock

michael.robert.romero@gmail.com (Michael Romero) — Sat, 08 Mar 2014 00:00:00 +0000

In late 2012 I decided to try out an imported Korean Yamakasi 27”; 2560x1440 IPS display. These have become particularly popular because of the high quality panels (the same as the Dell and Apple high-end monitors) at less than half the price, with some early models capable of overclocking to 120Hz. I decided the benefits outweighed the risks of spending so much money on a monitor with essentially no warranty. The panel was excellent, with no backlight bleed, excellent color, no dead pixels, and good response time. Unfortunately after 1 year the DVI board fried, and I ended up with similar problems to the one below:

Aggrogate

michael.robert.romero@gmail.com (Michael Romero) — Mon, 16 Dec 2013 00:00:00 +0000

Aggrogate is a 2 player action puzzle game. Each player controls light and dark cubes (light/dark purple or light/dark green). They must match 4 cubes of the same color to clear those cubes. The first play to clear all of their colored cubes wins. The trick is, each player is playing on the same collection of cubes, and shooting it causes it to spin, for both players!

Zero Zen

michael.robert.romero@gmail.com (Michael Romero) — Mon, 29 Apr 2013 00:00:00 +0000

Zero Zen is a 2-4 player game, most easily described as “sumo wrestling with airplanes”. Each player controls a plane with left/right rotation, a thruster to move forward, and a “shoot” button which fires a shotgun blast with tremendous kickback. The flying physics works similar to Asteroids, where your ship will continue coasting after accelerating. The bullets don’t do any damage, they just push players around. The objective is to knock all opponents into the outer walls to be the last person standing.

Gameboy Backlight

michael.robert.romero@gmail.com (Michael Romero) — Sun, 17 Feb 2013 00:00:00 +0000

“Chiptune” is a term used to describe music created using specifically limited hardware, usually for classic computer equipment like the Gameboy, the C64, etc. I’ve always found chiptune music interesting, and wanted to try my hand at making some with an original gameboy and LSDJ. Since I wanted to play around with it before bed, I decided to install a backlight in my gameboy, from KitschBent.

MIDI Controller

michael.robert.romero@gmail.com (Michael Romero) — Wed, 16 Jan 2013 00:00:00 +0000

I’ve been interested in making some nice electronic music and sound effects for my games. I tend to find the UI of different VSTs frustrating, so I was interested in getting a MIDI controller that could help speed things up. I’m also interested in the possibilities of rigging the MIDI knobs to variables in the code so I could tweak different parameters in real time. Like any good (over-)engineer, I researched what it might take to put one together myself. For whatever reason I find this sort of controller hardware fascinating.

Signed Distance Fields – Part 1

michael.robert.romero@gmail.com (Michael Romero) — Fri, 16 Nov 2012 00:00:00 +0000

Signed Distance Fields, when used in computer graphics, is a way of mathematically defining a scene, which can be both greatly compressed, and scale to any resolution. There’s a truly excellent presentation by iq of rgba (Iñigo Quilez) posted on his website http://www.iquilezles.org which he presented at nvscene back in 2008 called “Rendering Worlds with Two Triangles”. Other powerful examples were presented by smash of fairlight (Matt Swaboda) at GDC earlier this year http://directtovideo.wordpress.com. This is my first expermientation with this rendering technique.

Serendipity with Cubes

michael.robert.romero@gmail.com (Michael Romero) — Mon, 23 Apr 2012 00:00:00 +0000

Serendipity with Cubes is a relaxing, solitary puzzle game. The objective is to create a “path” of same-colored cubes to connect the two pulsing cubes. Click on one cube to select it and any adjacent cube to swap their colors. Once a path is created between the pulsing cubes, all cubes in that path are cleared from the puzzle. Win the game by clearing all cubes from the puzzle. If there is no way to connect enough cubes to complete a path, it’s game over.

Ray Casting and Picking Using Bullet Physics

michael.robert.romero@gmail.com (Michael Romero) — Mon, 13 Feb 2012 00:00:00 +0000

I just recently got picking working using the Bullet Physics Engine. Picking is a way to “pick” an object via a primitive (triangle) using a cursor from the camera’s perspective. Hovering your mouse cursor over an object and clicking on it is obviously a very intuitive way to interact with a scene. However, it’s not as intuitive to program, because the location selected is in 2D screen coordinates, and not 3D world coordinates. The difficulty in picking really lies in somehow determining the 3D coordinate space of the object to select. First, lets see what I’m talking about.

Scriptable Asset Loading

michael.robert.romero@gmail.com (Michael Romero) — Mon, 11 Jul 2011 00:00:00 +0000

In the last few months, I’ve been spending a considerable amount of time fleshing out some tedious but necessary parts of my game. I realized that since I’m a one-man army, I need the ability to very quickly get all of my ideas out and into a playable form without a lot of process and layers of tools. Unfortunately, the only way to achieve a very seamless workflow is by specializing your tools, which means rolling my own level editor and game formats. These things are nice to have anyway, but I believe that the time I invest in these tools will pay off in even the very first game I make with them. I decided I needed a quick and easy way to import models and other game assets, a scripting language (I chose Lua) for data definition and eventually scripted events and possibly game rules, and a level editor that allows rapid building and playtesting of open 3D worlds.

From an “is-a” to a “has-a” Object Model

michael.robert.romero@gmail.com (Michael Romero) — Fri, 22 Apr 2011 00:00:00 +0000

When evolving my rough particle system into a (very targeted) game engine, I started to learn why object oriented design has gone out of favor for many game engines. From a design standpoint, the particle system was a learning project where I tried to leverage C++ inheritance as much as I could. For the game engine, I attempted to model my game objects using an inheritance structure as well. I felt that in the real world, nearly everything falls into some sort of classification, often with distinct parent-child relationships. However, as I began adding game specific objects to my engine, I realized that not only is it prohibitively difficult to try to model the real world (the way I felt it should be modeled) due to the sheer volume and complexity, but game objects are simply an approximation of real world occurrences, and as such they tend to “cheat” to achieve a certain effect. Objects in a game can choose to be invisible, or defy the laws of physics. This basically breaks whatever elegant classification structure I had planned. Luckily, this can be addressed by converting from an “is-a” model (where an Object “is a” physics-based object) to a “has-a” model, (where an object “has a” physics component). In this model, objects will contain pointers to optional collections of data and functionality.

Particle System

michael.robert.romero@gmail.com (Michael Romero) — Wed, 22 Dec 2010 00:00:00 +0000

I saw a video online recently of several cubes flying into the scene and stacking up to form a larger cube. I thought it was a pretty simple yet powerful effect. The effect was achieved using Particle Flow, so the movement of the particles are entirely animated and not in real time. After seeing this, I immediately wanted to try it, but with a more general solution. So, off I went to write a physics system for my particle engine.

CUDA Design Rule Checking

michael.robert.romero@gmail.com (Michael Romero) — Wed, 15 Dec 2010 00:00:00 +0000

Design Rule Checking (DRC) of semiconductor layouts is a massively independently parallel problem, and well suited for CUDA. As part of an Independent Study, my friend Jeremy Espenshade and I implemented DRC algorithms using CUDA and achieved approximately 25-30x speedup of the checking algorithm on a Tesla card from 2009.

Mini Server

michael.robert.romero@gmail.com (Michael Romero) — Wed, 15 Dec 2010 00:00:00 +0000

This is an old server build when mini desktops were pretty rare (Shuttle was the most popular solution at the time). I wanted to build a small, efficient, always-on server. The system could be used as a home theater PC, act as a backup server, host public and sandbox websites, code repositories and many other things. With the price of storage dropping and some impressive mini-itx motherboard options out there, the perfect storm of hardware pushed me to build a mini-server.

Remote Controlled Turret

michael.robert.romero@gmail.com (Michael Romero) — Wed, 15 Dec 2010 00:00:00 +0000

A pneumatic nerf turret, controllable via a flash interface over the internet. It holds six shots, has a webcam for aiming, LEDs for use in the dark, an approximate range of 20 feet, with hundreds of shots between tank refills.

Volume Rendering using GPGPU

michael.robert.romero@gmail.com (Michael Romero) — Mon, 15 Jun 2009 00:00:00 +0000

Traditional 3D computer graphics focus on rendering the exterior of objects. Volume rendering is a technique used to visualize information corresponding to the interior of an object, commonly used in medical imaging and other fields. Visualization of such data may be accomplished by ray casting; similar to ray tracing. Rendering each pixel can be done in parallel, so massively parallel architectures like GPGPU can dramatically speed up rendering.

Volume Rendering on the PSP

michael.robert.romero@gmail.com (Michael Romero) — Sun, 15 Feb 2009 00:00:00 +0000

I’ve long been active in PSP development and decided to have some fun with graphics on the PSP. I asked my university to order two PSP dev systems and I got to work porting my ray tracer to the PSP. As a team effort with three other graphics enthusiasts, we decided to accelerate hypertexturing on the PSP using the VFPU. We ended up with a ray tracer, hypertexturer, and volume ray caster working on the PSP capable of displaying a 64x64x64 voxel volume.

Hypertexturing

michael.robert.romero@gmail.com (Michael Romero) — Mon, 19 Jan 2009 00:00:00 +0000

This code is branched from the Ray Tracer code, with the perlin noise function added and the hit function and normal calculations for the volume of noise/density.

Ray Tracer

michael.robert.romero@gmail.com (Michael Romero) — Mon, 15 Dec 2008 00:00:00 +0000

This was my first ray tracer, implemented on the CPU using OpenGL and GLUT to present to the screen, and coded in Dev-C++. It is largely inspired by the ray tracer used in the book Ray Tracing from the Ground Up, an excellent and highly recommended book on ray tracing by Kevin Suffern.

First Graphics Project

michael.robert.romero@gmail.com (Michael Romero) — Fri, 14 Dec 2007 00:00:00 +0000

My very first graphics project. It’s written in C, and uses old fixed-function OpenGL and GLUT. The code is pretty sloppy as most first attempts go. There are a few interactive elements to this project, with the box spreading apart and interesting use of blending. As the transparent surfaces occlude other geometry, the geometry “disappears” and shapes are revealed inside the formerly opaque geometry.

About

michael.robert.romero@gmail.com (Michael Romero) — Mon, 01 Jan 0001 00:00:00 +0000

Hello and welcome! I use this site to catalog my projects and share my discoveries with friends. I work in video games and computer graphics, with a background in both hardware and software. I also have a ton of hobbies including making gadgets, creative programming, and creating collectible figures/miniatures. I’m very particular about design and interested in how things work, so I tend to build a lot of things from scratch.