November 2001:
- Written an iostream wrapper for .zip file access. Look at the download section.
- 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, ...).
October 2001:
- 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 stuff again.
September 2001:
- Too busy working, so I had no time for an update.
August 2001:
- 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 done.
- Back from vacation which was great!
July 2001:
- 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.
June 2001:
- 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 a ratio.
- 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, but works.
- 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".
May 2001:
- 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 windows,...
- 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 localization.
- 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 yet).
- 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 culling.
- Started using unit tests.
April 2001:
- 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 :)
March 2001:
- Start!
- 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.
