- Written an iostream wrapper for .zip file access. Look at the download
- Did some research into the standard C++ iostream framework.
- Written a small Python script to "clean" a project automatically
(i.e. get rid of Debug/Release directories, source safe files, ...).
- Small change: Replaced occurences of strstream by stringstream because
strstream is deprecated.
- Did some research into CRC checksums for interest. As a result I've
added a template CRC class to the engine that is configurable so you
can calculate all popular CRC standards. I don't really need that now,
but it might come in handy one day.
- Hooray! We've finished our project, so I can continue with my private
- Too busy working, so I had no time for an update.
- Alas I'm very busy now at work since we're crunching to get the next
game out in time, so I don't have time to work on the engine until we're
- Back from vacation which was great!
- We'll go to China for 3 weeks on vacation, so don't expect any updates
for that period :)
- Finally added depth sorting of models with alpha transparency. The
algortihm I use is not really optimal, but at least it works.
- Added flipping of texture UV coordinates, since UV coordinates exported
by Maya are reversed to DirectX's coordinates on the V axis.
- I tried FreeImage instead of OpenIL but I think I'll stay with OpenIL
since it is easier to use and more mature (had linking problems with
FreeImage and some crashes).
- Texture files are not limited to .bmp anymore. All formats that OpenIL
can read are now usable. Restrictions: OpenIL seems to have problems
with some .jpg files which are loaded "blocky". Further the
alpha channel of .tif files is not loaded -> use .tga for alpha textures
instead (I have reported that to the OpenIL developer).
- Enhanced OpenIL wrapper functionality (including copying the pixel
data to an array with a certain byte pitch, e.g. needed for Direct3d
textures or Windows compatible bitmaps, which have to be DWORD aligned).
- Researched per pixel lighting. Put up a screenshot of a small test
program. The setup for the lighting is done in a vertex shader. You
can also download the executable.
- Did some experiments with DirectX 8 vertex shaders. Look at the results
in Screenshots. The source code is not
incorporated into the engine yet.
- Added a screenshots section to the site.
- Written a small Python script to fix .obj files which don't reference
a material lib (e.g. exported by Maya).
- Modified GameTime so that you can slow down and accelerate it using
- Added a function in AudioVisual that let's you print out a sub tree
of the scene tree to an std::ostream. This proved very helpful for debugging.
- Fixed a bug in the Lightwave importer. The object hierarchy was built
up in wrong order.
- Models are loaded through a ModelPool now similar to the TexturePool.
Thus a model, will be loaded only once in the engine. Every further
request for loading the model will clone the original model. (Cloning
shares the geometry data, only stuff like transformations and render
states will be duplicated). Model loading now has to go through the
ModelPool because I made the .x and .obj importer constructors private.
- Importing Lightwave .lws files is possible now. Some restrictions
have to be applied (keys can not be separated into components, since
e.g. a position key is a Vector3 internally, so for example no x-axis
only translation keys should be used).
- Implemented hierarchical keyframe animation. The design is preliminary,
- Changed file structure (don't separate files into Include/Source folders
anymore). Further external library #include statements don't us any
paths anymore, so it doesn't matter, where DirectX, OpenIL,... are installed.
- Programmed a 3d model viewer to test engine usage (see Download section).
- Textures were introduced as render states
- Materials were originally part of a mesh and are now render states.
- Meshes were organized into sub meshes before (like subsets of DirectX
meshes) where each sub mesh belonged to one material. This idea was
abandoned, since it didn't allow sorting by texture/material. Now a
mesh doesn't know about materials, since they've become render states.
During importing of .x-files the mesh is split up to fit my internal
format. This change was a major restructuring of the engine.
- View frustum culling implementation was finished. After trying out
several algorithms for sphere/frustum culling I use the algorithm presented
in the book "Realtime rendering" by Möller and Haines.
- Started this site and using this diary. All older entries are only
extracted from memory and as such is quite incomplete.
- Implemented an .obj file loader
- TexturePool was introduced that makes checking whether a texture was
already loaded somewhere easier. (Textures can only be loaded through
TexturePools now). If a texture is requested to be loaded more than
once, the texture is shared via a smart pointer.
- Added class TagLine that facilitates loading of files with lines of
tags separated by spaces like "v 0.123 0.456 0.789".
- Introduced .set files, where game settings are read from. Lines from
the .set file are used to construct CommandLine objects that are used
to execute commands (through an abstract Command class interface).
- Added an input system that understands single hardware keystrokes
(through DirectInput), hardware keys mapped to virtual keys, multiple
virtual keys mapped to multikeys and key sequences mapped to combo keys
all through the same abstract key interface. Key mappings can be read
from the settings file. Keys can also be mapped to commands, so a keypress
automatically issues the assigned action. Further a set of mapped commands
can be grouped into an input context that checks keypresses automatically.
Different input contexts can thus be used for e.g. menus, in game, popup
- Strings used in a game are read through a .str file where each string
is identified through a label. This can be used in the future for facilitating
- Added some really basic physics, but stopped that, since there is
no use for that yet.
- Having render states accessible through renderer switches proved to
be clumsy, so render states are now classes that can be attached to
nodes in the scene tree. An attached render state influences all nodes
below it (examples are: lighting, specular lighting, fill mode, alpha
state,...). Handling render states requires switching on the render
state type, which I consider bad design, but I couldn't get rid of it.
Maybe I'll manage later.
- Directly rendering a scene when traversing it proved to be a bad idea,
when alpha transparency was introduced as a render state, since transparent
nodes must be drawn after the opaque ones. So I added a Sorter class
where all nodes to be drawn are first accumulated where they can be
sorted e.g. by texture, by alpha state or later by vertex shader. The
renderer then gets a list of objects to render by the sorter. For your
own sorting algorithm just inherit from the sorter and implement your
own behavior.The current DefaultSorter just sorts alpha objects to be
drawn after opaque ones. (The transparent objects are not sorted correctly
- Billboards are implemented for stuff like lense flares. Actually billboards
are nodes that rotate the subtree below them towards the camera, so
you're not limited to texture mapped quads.
- Spheres, planes and half spaces added as preparation for view frustum
- Started using unit tests.
- Added file path handling, scene graph management (nodes, transforms,
geometry data, abstract renderer class, DirectX renderer, render caches,
materials, lights), camera, interface to OpenIL, interface to XAudio
lib for MP3 playback, .x-file importer, display statistics (frame, vertex
and triangle counter).
- A lot of ideas for organizing the scene graph came from Dave Eberly's
book "3D Game Engine Design".
- Render caches were introduced, because refilling vertex buffers every
frame was quite a bad idea :)
- Added game time, smart pointers, object base class, mouse input, basic
linear algebra (matrices and vectors) and math tool functions, logging.
- Smart pointers are realized via an object base class and not through
adding a memory header and overriding global new.