iakov.dev

Archive

All 125 posts since 2009.

2021

2020

  • Glow engine videos from 2004 to 2020

    Old videos of my Glow engine by year, from an architectural walkthrough and stencil shadows to Intel contest demos, Iron Cube and voxel prototypes.

2019

  • Path tracing voxels, day 1

    Adding a path tracer to my voxel engine after Ray Tracing in One Weekend: voxel ray casting, importance-sampled sunlight and going from 0.4M to 5M rays per second.

  • Running Emscripten apps in fullscreen

    How I made my Emscripten game demo fill the browser window with soft fullscreen and an SDL2 resize callback, with the code.

  • Iron Cube in the browser with Emscripten

    I ported my Iron Cube demo to the web with Emscripten in a couple of days, and it runs in modern desktop and mobile browsers.

2017

  • glw_imgui 0.1, my immediate-mode GUI library

    First release of glw_imgui, the immediate-mode GUI library from my game engine, with themes, dockable toolbars and Linux, macOS and Windows builds.

  • A voxel adventure game prototype

    Video of an isometric, Zelda-like voxel adventure prototype on my Glow3D engine, with art by Sir carma, MagicaVoxel import and NVIDIA HBAO+.

  • New website and blog

    Why I rebuilt glow3d.com as a static Jekyll site hosted on GitHub after an unreliable WordPress blog on AWS.

  • Pied Piper, my first Ludum Dare game

    A short postmortem of Pied Piper, a silly game about dancing zombies and my first finished Ludum Dare entry, built with Fuse and Mixamo.

  • Voxel art by Sir carma in Glow3D

    A screenshot from a voxel game prototype I made with voxel artist Sir carma: his art rendered by my Glow3D engine.

2014

  • A DirectX 11 renderer for the Glow engine

    Adding a DirectX 11 renderer to the Glow engine took a couple of weeks, and the code came out half the size of the DirectX 9 version.

  • Ambient lighting with vertex colours

    I moved Iron Cube's ambient lighting into vertex colours. It looks the same as before but should render faster.

  • Iron Cube 0.31

    Iron Cube 0.31 for Windows and Android: smoother online play for two players, local tank simulation, 3D sound, faster startup and a new trailer.

2013

  • Automated tests for Iron Cube

    A bot that picks a random tank action every second ran Iron Cube for hours without a crash before the next Google Play update.

  • Debugging Iron Cube with recorded network traffic

    Recording server data on an Android phone and replaying it in the Windows editor helps me track down network bugs in Iron Cube.

  • Recording and replaying games in Iron Cube

    How I added movie recording and playback to Iron Cube by saving the server's network snapshots, which also gives slow motion for trailers.

  • Mercury in stage 2 of the Intel challenge

    An improved Mercury for stage 2 of the Intel Perceptual Computing Challenge: new gestures, an OpenGL renderer, saving and smoother brushes.

  • Iron Cube is out on Google Play

    Iron Cube, my voxel tank combat game, is ported to Android and free on Google Play, with three levels, two tanks, Wi-Fi multiplayer and a bot.

  • Iron Cube 0.15

    Iron Cube 0.15 adds AI bots, dynamic navigation meshes, flood-fill voxel lighting, an OpenGL renderer with water and a working level editor.

  • CPU voxel lighting in Iron Cube

    Iron Cube gets new CPU-calculated voxel lighting, split into sky and local light and baked in the editor to help mobile devices.

  • First prize in the Intel Perceptual Computing Challenge

    My Mercury prototype, a voxel sculpting tool controlled by hand gestures, won first prize in the Intel Perceptual Computing Challenge.

  • The Mercury prototype

    A cleaner video of Mercury, my hand-controlled voxel sculpting prototype, with more robust fingertip tracking from the Perceptual Computing SDK.

  • Why Android is better

    My Galaxy Note 2 running Launcher 8, a home screen that makes an Android phone look like Windows Phone.

  • Project Mercury

    Mercury, my entry for the Intel Perceptual Computing Challenge: a voxel sculpting prototype on the Glow engine controlled by hand gestures.

  • Rasterising 3D models into voxels

    The first version of my algorithm for rasterising polygonal 3D models into voxels. It still leaves cracks and holes.

  • Iron Cube on Android

    A video of Iron Cube running on a Galaxy Note 2. Movement, shooting and rendering work; sound and AI are still to do.

  • The Leap Motion controller has arrived

    My Leap Motion developer unit arrived today. First tests look responsive and precise, and I plan to integrate the Leap SDK into Glow.

  • Glow engine on Android

    I ported the Glow engine to Android over the last few weekends, building on its Native Client port. The Galaxy Note II loads my voxel scene fast.

  • Steam Big Picture on a TV

    I connected my Intel Ultrabook to a 46-inch TV, bought a wireless Xbox 360 controller and started playing my Steam library in Big Picture mode.

2012

  • CEGUI vs IMGUI

    Creating one button in CEGUI takes five lines of setup code. An immediate-mode GUI does the same job in a single if statement.

  • A Leap Motion controller is on its way

    I applied for a Leap Motion developer unit some time ago and forgot about it, and now it looks like one is coming to me.

  • Iron Cube vs reality

    A photo of an avenue of box-clipped trees that look just like the cubic trees in my voxel game Iron Cube.

  • 6000 animated entities in the Glow engine

    A Glow engine performance test with 6000 animated entities in one frame and no special optimisation such as instancing.

  • Iron Cube on Mod DB

    Iron Cube, my multiplayer game in a destructible voxel world, now has a page on Mod DB with an alpha version to download.

  • Random screenshot

    A screenshot of the tank next to a single voxel tree on a floating block of terrain, one day before release.

  • My tank game for the Ultrabook contest is nearly done

    My tank game for the Intel Ultrabook contest is close to finished, but I still don't have a Symantec certificate to sign the code.

  • Greedy meshing with baked ambient lighting

    My greedy voxel mesh generator now supports ambient lighting prerendered into a texture, and the same mesh goes to Bullet physics.

  • An Ultrabook from Intel

    Intel sent me a pre-release Ivy Bridge Ultrabook running Windows 8 after I reached Round 2 of the Ultrabook app contest on CodeProject.

  • Automatic voxelisation of a 3D model

    I voxelised a tank model into a 50x50x50 voxel field by rasterising it polygon by polygon, much like a 2D scanline algorithm.

  • Flight over a voxel landscape

    A video of the camera flying over the voxel landscape of my new tank game.

  • A tank model for my new game

    A free tank model loaded into my editor for a new game, though I'm not sure it will suit a voxel world.

  • Google Native Client build of the Glow engine

    Glow is now cross-platform, and its first platform after Windows is Google Native Client, which runs native C/C++ code in a browser.

  • A template static member that GCC won't link

    GCC won't link a declared explicit specialisation of a template's static data member until it has an initialiser, and the standard agrees.

  • Geometry optimisation for voxel meshes

    A new voxel mesh generator cuts vertex data by a factor of three to four, at the cost of slightly slower generation.

  • Moving the site to Amazon EC2

    I moved the blog and site from Hostgator to a free t1.micro instance on Amazon EC2 and set up the whole server by hand.

  • First iteration of grass

    A first pass at grass in the Tarta voxel world. The grass texture needs to become more cubic to match the blocks.

  • Art for Tarta

    Tarta has outgrown my own art skills, so I'm looking for an artist. Also: a possible multiplayer character and a grass test.

  • Bigger explosions

    A short video of grenades in Tarta after I increased the explosion radius in the voxel world.

  • Voxel field updates over the network

    Tarta now edits the voxel field on the server and sends changed chunks to clients over UDP, compressed with RLE.

  • Flocking fish

    Simple steering for fish, using the OpenSteer library's Boids behaviour for the first tests.

  • Another day/night cycle video

    Another video of the day/night cycle in Tarta, the voxel game prototype.

  • First video of Tarta on OpenGL

    A first video of the Tarta voxel prototype running on the Glow engine's new OpenGL renderer.

  • First OpenGL screenshot

    The first screenshot of Tarta on the Glow engine's new OpenGL renderer, after a quick port to GCC and Linux.

  • New game prototype: Tarta

    Tarta is a new voxel game prototype built in three weeks: an infinite random voxel world, terrain editing, a day/night cycle and PhysX.

2011

  • Random landscape generator

    A first version of a random landscape generator in the Glow engine editor, built on the open-source libnoise library.

  • Cinematic editor

    The Glow engine editor can now animate the camera like any other entity, with keyframes set from the frame slider.

  • Deferred reflections

    How the Glow engine does planar reflections with deferred lighting, using the deferred reflections idea from Metro 2033.

  • New features

    Exponential shadow maps, soft particles, a cinematic editor and UI improvements have landed in the Glow engine.

  • First steps with SSAO

    Screen-space ambient occlusion in the Glow engine, plus a video of the new water.

  • Water, finally

    The first stage of water in the Glow engine, with reflection and refraction, alongside HDR, antialiasing and linear rendering.

  • A new day, a new picture with houses

    Testing atmospheric scattering, light intensity, a dynamic sun and time of day on a row of small houses in the Glow engine.

  • Atmospheric scattering

    Dynamic atmospheric scattering is back in the Glow engine, with new Time of Day and Length of Day scene properties.

  • HDR, finally

    After four months without updates, HDR rendering in the Glow engine works, using 64-bit float render targets and bloom.

  • HDR and the editor so far

    A screenshot of the Glow engine editor in its current state, a few tasks away from the alpha version.

  • Colour transformations as a post-process

    The Glow engine gets a single-pass colour transformation post-process for contrast, brightness, black and white and RGB shifts.

  • Antialiasing in the Glow engine

    The Glow engine gets antialiasing through Directionally Localized Antialiasing, the post-process method used in The Force Unleashed 2.

  • An NPC lit by several lights

    A soldier NPC in the Glow engine, lit by several lights at once against a cloudy sky over the sea.

  • More screenshots of the Sponza model

    Two more views of the Sponza atrium in the Glow engine editor, from the upper gallery and from the ground floor.

  • The Sponza lion in the Glow engine

    A close-up of the lion head relief from the Sponza model, lit by small coloured lights in the Glow engine editor.

  • A screenshot from the Deadly Light demo

    A screenshot from the Deadly Light demo after a round of engine work on concurrency, memory debugging and reference counting.

  • Debug views in the Glow engine

    The Glow engine editor gets debug modes for wireframe, normals, depth, lights, physics, AI triggers and navigation meshes.

  • Updated glow3d.com

    glow3d.com now matches the current state of the Glow engine after the recent concurrency work.

  • Intel TBB is in the engine

    Intel Threading Building Blocks is integrated, and work starts on a concurrent, templated scene graph that several threads can read at once.

  • Moving to Intel Threading Building Blocks

    Why the Glow engine's task system is switching from the experimental boost::thread_pool to Intel Threading Building Blocks.

  • Concurrent scene graph

    Three ways to give physics, audio and rendering concurrent access to the Glow engine's scene graph, and the trade-offs of each.

  • HDR rendering with eye adaptation

    The Glow engine gets HDR lighting with eye adaptation, gamma-correct rendering and the start of colour transformations.

  • Memory management in the Glow engine

    The Glow engine's new memory manager: per-module heaps with small-object pools, STL allocators, a message heap and a memory debugger UI.

2010

  • Replacing std::vector with a stack array

    Removing dynamic allocation from the Glow engine's update loop with a container that mixes boost::array and std::vector.

  • SIGGRAPH Asia 2010

    Notes from SIGGRAPH Asia 2010: tessellation in the DirectX 11 and OpenGL 4.0 courses, real-time ray tracing and stereoscopic rendering.

  • Post-processing pipeline started

    A post-processing pipeline for the Glow engine, starting with camera motion blur built from the geometry buffer.

  • Notes on the Metro 2033 tech interview

    Reading the Digital Foundry interview on Metro 2033's tech: deferred reflections, and a plan to try exponential shadow maps.

  • November editor plan done

    Over 30 editor tasks finished in November: editable scaling, asset previews, simple skyboxes and new gizmos.

  • Normal texture trick

    A normal map trick that lets the same shaders read DXT1 and DXT5 bump textures, so the editor can skip DXT5 compression.

  • Auto-reloading resources

    The Glow editor now reloads scripts, textures, models and shaders automatically when you switch back from Photoshop or 3ds Max.

  • Big face on the landscape

    A random photo used as landscape texture while testing the Glow editor, plus FBX import, heightmap tracing and drag-and-drop assignment.

  • Weekly editor screenshot

    Deferred shading, shadow maps, clipmap landscapes and axis-constrained mouse editing in the Glow editor, plus a two-month plan.

  • Editor status

    The Glow editor now has window layout management, object type editing, asset management and project save and load.

  • Editor progress with projects, assets and property editing

    The Glow editor can now load and save projects, list assets and entities, and edit properties, all in its in-game 3D UI.

  • Back from vacation

    Back after three weeks away, five countries and eleven flights, and starting on project management for the editor.

  • First week of the level editor

    A week into the Glow level editor: drag-and-drop meshes, a background asset manager, undo/redo and objects snapped to the landscape.

  • A short way to build a quaternion from a direction

    Replacing a long asin/acos quaternion function with four lines that rotate (0,0,1) onto any unit vector.

  • Immediate-mode UI for the editor, scripted in Lua

    The Glow editor UI is built on the immediate-mode GUI from the Recast library and scripted in Lua through luabind.

  • A website for the Glow engine

    I built glow3d.com, a website for the Glow engine, in three days of HTML, CSS and Photoshop.

  • Glow engine feature presentation

    A slide presentation listing the features of the Glow engine, published on Google Docs.

  • A month of refactoring

    I split the Glow engine into separate DLL modules behind abstract interfaces and added a thread pool for jobs.

  • Streaming data from the internet

    The Glow engine now streams data from local files, zip archives and HTTP or FTP, which the web player needs.

  • Starting the web player

    First day of work on a browser web player for the Glow engine, built as an ATL ActiveX control.

  • First tests with water

    First water rendering tests in my engine, using reflection and refraction maps as described in GPU Gems 2.

  • Feedback from the IGF judges

    What the IGF judges said about my zombie game: they liked the intro and criticised the level design, lighting and audio.

  • Planning the gameplay before building it

    After a brainstorm that produced about 80 gameplay ideas, my five-step plan for designing a game before implementing it.

2009