Humm and Strumm Project

Engine Requirement Document

2011-12-22T03:47:00.002-05:00

The Humm and Strumm Project has released the first version of its Engine Requirements Document. This document details the requirements analysis for the Humm and Strumm Game Engine in non-implementation-dependent terms, providing an overarching philosophy and requirements set by which the engine will be designed and implemented.

This document is the first version of the Engine Requirements Document, which may change due to unexpected requirements changes or requirements not realized during the initial project requirements analysis. Newer versions of this document will be available via the same link.

The document is available in PDF (A4 paper) format (direct link, 156 kB).

Social Media

2011-11-28T22:48:00.015-05:00

In addition to subscribing to the RSS feed for this blog or subscribing to the various mailing lists that we use, we are also introducing several new means of receiving updates from the Project.

If you are a DIASPORA* or Friendika user, you can add our new DIASPORA* profile as a contact. Simply type in our OAuth handle (hummstrumm@diasp.org) to the subscribe bar, just as you would to add any other contact. We'd like to thank David Morley for hosting this community-run, open pod.

If you are a Status.Net user, GNUSocial user, or a user of any social network that supports the open OStatus standard, you can subscribe to our new Status.Net profile. You'll need to enter our OAuth handle (hummstrumm@parlementum.net) in the remote subscribe box on your social network. We'd like to thank Charles Roth for hosting his Parlementum StatusNet server, on which we created our account.

These will have frequent updates on the status of the project, more frequent than those on this blog. If you are interested in knowing the latest updates, we think these two solutions will benefit you greatly.

RELEASE: Version 0.4

2011-11-28T17:48:00.000-05:00

The Humm and Strumm Game Engine, version 0.4 has been released. This release introduces Windows window system code and several stability fixes.

Like all 0.x releases, this release is a pure game engine release—this means no playable game yet. However, these releases are necessary, as they provide the backbone to the rest of the game.

The game is available in the gzip and zip formats from the Downloads page.

PRE-RELEASE: Version 0.4

2011-09-06T10:45:00.002-04:00

The 0.4 version of the Humm and Strumm game engine will be released this Thursday, September 8th.

As with all version 0.x releases, this is only a game engine release. There will be no playable game until version 1.0. This release is the first of our monthly releases, so there is less in it than in previous releases:

Win32 rendering: Having revamped our window system code, we now have support for both X11 and Windows rendering. For the user, this means that our rotating cube demo from the previous release now works on all platforms that the Humm and Strumm engine currently supports: GNU/Linux, *BSD, and Windows.
Stability fixes: We've introduced a few fixes that should better the stability and extensibility of the engine. Most of this work was done behind the API, so there isn't much that the user of the engine might see.

For more information, see the Downloads Page

Moved to Git Repository

2011-08-22T20:12:00.005-04:00

Along with work on the upcoming 0.4 release, this past month has seen an important infrastructure change in the Humm and Strumm Project. Our code is now being stored in a public Git repository (which you can clone using these instructions). This change should result in a more efficient workflow for developers and for contributors.

Some background: our code has been stored in a version control system called Subversion, where there is one central repository to which everyone commits. Having a version control system allows us to revert changes, track additions effectively, and collaborate with contributors and developers across the world. Until now, this has been quite fine in facilitating our development on Humm and Strumm

Enter Git, the distributed version control system. Instead of having only one repository to which everyone commits, everyone has at least one repository for themselves. All their work is done on their personal repository; the changes are then merged into the project's master repository.

The benefits of Git are twofold:

Easy merges: In Subversion, merges can be a nightmare. It was a lot of work to schedule merges of changes that both developers made. This was counterproductive—time that could have been spent developing and testing was instead spent fixing problems caused by merges. With Git, merges are (usually) brainless. We don't have to find time to schedule merges or to fix merge problems. They just work.
Easy contributing: Because of the decentralized nature of Git, anyone can make a clone of our repository. This includes both developers and potential contributors. Due to the increased ease of merging, it's far easier to for anyone to contribute to the project. For a detailed (updated) description of how to contribute, see our contribution policy.

For most users, this shouldn't have any direct effect. However, on the development end, we now have an even more efficient way to work on the game, hopefully resulting in quicker development.

RELEASE: Version 0.3

2011-08-03T00:44:00.003-04:00

Here is the first of our upcoming monthly releases!

This, like all 0.x releases, is a pure game engine release—this means no playable game yet. However, these releases are necessary, as they provide the backbone to the rest of the game.

We have a lot of functionality now: see the NEWS file for all the changes.

The game is available in the gzip and zip formats from the Downloads page.

PRE-RELEASE: Version 0.3 and New Release Cycle

2011-07-21T09:31:00.006-04:00

After a short delay, the Humm and Strumm engine version 0.3 will be released on Monday, July 25th.

As with all version 0.x releases, this is only a game engine release. There will be no playable game until version 1.0. What's new in this release?

X11 rendering: We now have a window that appears on X11 enabled systems displaying a rotating cube. Windows native windowing system support will come with the next release.
Port to *BSD: Humm and Strumm now supports *BSD systems out of the box. This support has been tested with FreeBSD x64. (Be sure you have an up-to-date version of GCC when compiling).
Geometry Mathematics classes: Geometry mathematics classes such as AABBs and ellipsoids have been added. They support collision checking and detection.
SSE: Streaming SIMD Extensions support, which speeds up the processing of vector mathematics (on which game engines are built), is now included in the engine.

CPPUnit for Windows: We have a version of CPPUnit bundled with the game engine now for Windows, because it is extremely hard to compile and download for modern versions of Windows.
System Detection: Various attributes about the system, including clock frequency, memory usage, and processor flags, can now be detected at runtime.
Build System Refactoring: The build system has been refactored internally, which makes maintaining it much easier. For users, this is most apparent in the robustness in case of failure: if a package isn't installed, the build system will alert them.

For more information, see the Downloads Page

Additionally, the Humm and Strumm Project is adopting an aggressive release cycle of once per month releases. These releases will be smaller, but much more frequent. Hopefully, this will allow us to better pace our releases and follow the adage of "Release Early, Release Often". To see upcoming releases, see our release calendar.

Mailing Lists

2011-02-06T22:03:00.000-05:00

Did you know that Humm and Strumm's mailing lists are open for all to subscribe to? They are a great way to communicate with us, to keep up with recent features, and to join the community!

We have four mailing lists that we use for interaction:

hummstrumm-user: For release announcements and general communication with the users. At the moment, this mailing list is very low volume, but we would love to have more discussion on it. If you have a question, a problem, or just want to talk to us, please post here.
hummstrumm-contrib: For interaction with contributors and posting of patches. Anyone who has a patch to contribute, but doesn't want to become a full-fledged member of the team can request to subscribe to this list and post here.
hummstrumm-dev: For interaction between developers. This is a pretty high volume, as it is the main way developers communicate in the project. Anyone can subscribe, but only we can post. Subscribing is a great way to keep up-to-date with development news and discussions.
hummstrumm-updates: For automatic updates concerning bug reports, commits, and wiki edits. This is very high volume, but anyone who wants to keep up with the development of Humm and Strumm should subscribe.

How do I subscribe to these mailing lists? For each one except hummstrumm-contrib, send an email to listname+subscribe@googlegroups.com, where listname is the name of the mailing list as given above. For hummstrumm-contrib, first send an email to hummstrumm-user to request to join. Be sure to tell us what patch you have or plan on developing. We'll certainly add you.

Consider subscribing; we'd love you to join the community.

New log, new platform, and some old fixes

2010-11-28T23:32:00.000-05:00

Some miscellaneous news on Humm and Strumm:

Experimental *BSD support: We now have BSD specific code in the engine. This code is highly experimental...so experimental that it hasn't even yet been compiled on a BSD system. If you would like to test it out, join our User Group and download our latest source code, from the branch PatrickNiedzielski.
XML-based Log: Our logging class now logs to a pure XML file. You can convert it to HTML or plain text by means of XSL stylesheets. The new log also contains lots of useful information, like filenames, line numbers, function names, and system attributes (soon to have timestamps).
CPPUnit for Windows: Since we are using an old version of CPPUnit (not the latest, experimental version 2), we needed to port it to new versions of Windows. This version is fully integrated with our build system.

Reference Counting Fix: The fundamental means of reference counting in our engine has been flawed; it would fail for elements of arrays on the heap, and members of other Objects on the heap. We've fixed this with something called AllocationTable, which tracks the allocations from the heap until when they are constructed and then setting the initial Object reference count accordingly. This solution is by no means final. We are still investigating other methods.
Custom Allocators: For the sake of both speed and robustness, we are currently looking at various allocators to replace our custom one. They will be more robust, better tested, and more optimized. This will cut down on inexplicable errors we have sometimes gotten, especially in SSE.
Wiki Revamp: Our wiki has been revamped to make it easier to get the information you want. There will be a few more minor modifications in the future, too, to ease the navigation. Our wiki is a good place to get information about our project for both users and developers alike.

Development Continues...

2010-08-31T11:32:00.001-04:00

As the hot summertime in the northern hemisphere draws to a close, we are hard at work on the Humm and Strumm game engine. Yes, sorry about the lack of posting recently. Perhaps we should be doing posts every week as opposed to every few months.

Development News:

Unicode Support: Our Character and String classes have almost been fully implemented with Unicode support. This includes UTF-8, UTF-16, and UTF-32 formats, with rigorous error checking on input characters. Characters outside the BMP (Basic Multilingual Plane) can be stored (in case you, for some reason, need to store a Mahjong tile in a string?). You can find more about our Internationalization requirements on our wiki.

Windows Unit Testing: The Humm and Strumm Engine finally compiles on Windows (or it will, with the next check-in on my branch). We had to port our unit testing system, CPPUnit, to Windows; now, however, we should be able to run unit testing out of the box. There does seem to be one error, though.
X11 Window: We have code for the X11 system, to make a window appear (which is a thrill to have!) This code will be ported to Windows with the next release.
SSE Math: After doing extensive testing, we have found that writing custom SSE code does offer a benefit over that generated by GCC. The same is probably true with MSVC. We are using compiler intrinsics functions to keep things cross-platform if possible, and because Win64 doesn't support inline assembly code(!)
List Class: We have decided not to offer a true array or vector (in the computer science sense of the word) class, in which all elements are contiguous in memory. Instead, we offer a specially optimized linked list, which facilitates random access more quickly than a standard linked list. We call this technique a Service Centre Linked List, which you can read about on our wiki, at the Ideas Sandbox page.

Hopefully, we can get a release in by mid-September. Hopefully. This should also have some nice concept art for you all to see.

Looking ahead to the 0.4 release, we will have the biggest subsystem implemented yet: the Event System, which ties in with the Threading System. The multithreading design for Humm and Strumm is designed to take advantage of all the cores on the system, while keeping some processes in serial, allowing easy updates and message passing between entities in the game world and subsystems in the engine.

Oh, and this is the new and final website design. It finally looks acceptable.

First Design Session

2010-06-01T00:24:00.000-04:00

Our first design decisions conference will be this weekend, via a private chat between me and Ricardo. Future design sessions may be hosted some other way, but for now, with the two of us working on it, this works well.

I hope to discuss the following points:

Multithreading
A messaging system
Scene management

Further points may be addressed as needed.

For those interested, I will be putting a document up online either on our Project Documentation Site or our Wiki space. I hope to make the process as transparent as possible for anyone to see, so all ideas and debate relating to the game will be recorded. Feel free to post your comments on the design session either directly on the website (both the documentation site and the wiki allow this) or send them to our hummstrumm-user group.

RELEASE: Version 0.2

2010-05-15T18:28:00.000-04:00

We've another release under our belts now, and get ready for many more to come.

This, like all 0.x releases, is a pure game engine release—this means no playable game yet. However, these releases are necessary, as they provide the backbone to the rest of the game.

This release adds on to the core functionality by introducing debugging helpers, type wrappers, and some system functions. It also has the basis of the rendering engine--the Vector Algebra mathematics classes. Both of these developments will directly lead us to the higher level engine systems.

Furthermore, we have started to migrate to CppUnit for our test cases. To compile, you will need this.

The game is available in the gzip and zip formats from the Downloads page.

PRE-RELEASE: Version 0.2

2010-05-08T13:36:00.000-04:00

Another release is coming up next weekend, and we are coming to a fuller basis for the game.

As with all version 0.x releases, this is only a game engine release. There will be no playable game until version 1.0. Here's what we've done in this release:

Vector Math: The Math System provides normal linear algebraic operations on vectors, matrices, and quaternions. This work forms the start of the Graphics and Scene Management Systems.
Debugging System: The Debugging System allows for easy compile-time and run-time debugging. We've provided a class for profiling execution of a block of code, a class for logging information to the disk, and magic macros that will help in debugging the engine and the game.
Types: The Types System provides wrapper classes for the standard C++ built-in types. In doing this, we can add additional functionality to the types, and more importantly, we can integrate an ECMAScript-compatible language in with existing C++ code.

We have also added some test programs for each module, using the CppUnit test framework. If you want to help write or improve these test cases, you can send us patches or files via our hummstrumm-contrib Google Group. We accept all contributions.

For more information, see the Downloads Page.

Subversion Repository Layout

2010-03-25T01:18:00.001-04:00

This is a quick update: So until now, we've been polluting our trunk with changes to the codebase. Not a good thing! Ricardo suggested that we instead have separate sandbox branches for each developer in our repository on which to play around. I have just implemented this in our repo. In addition, there is an unstable branch, in which code is committed for a series of tests before going into the stable trunk. I think it will fit in nicely with code reviews, which could be done before we merge our personal branch in with the unstable branch. For any new team members, we will create a new branch based on the Google Code user name of the contributor. This will help organisationally and logistically.

Blog Redesign

2010-03-09T16:28:00.000-05:00

As you have probably noticed, I have been redesigning the development blog. It is definitely much more user-friendly than before. Now, as opposed to the old standard Blogger template, we have a custom designed web site.

My hope is that this can become our main homepage for the Humm and Strumm project, as opposed to the current (ugly) Google Code page. The Blogger blog affords us much more flexibility, and will perhaps create a more positive and professional image of our project to those first finding it. Making this our home on the web will also allow people to easily see development news—it is a blog, after all! All information will be available on the blog site, and links to the Wiki, Downloads Page, and Issue Tracker will give easy access to these services from Google Code.

Team member introduction

2010-03-03T08:27:00.005-05:00

Hi all, I'm Ricardo Tiago, I just joined the team and I will work for now on the graphics subsystem. Its a pleasure to be part of this project!

RELEASE: Version 0.1

2010-02-06T19:48:00.000-05:00

Yes, the first release of Humm and Strumm is here!

This, like all 0.x releases, is a pure game engine release—this means no playable game yet. However, these releases are necessary, as they provide the backbone to the rest of the game.

This release is the basis of the game engine, providing a framework from which all other classes are derived: the Object/Type System. This system gives the programmer specific abilities with all classes. In addition, a memory heap manager is provided to increase allocation speed. More information can be found on the wiki and in the accompanying documentation.

The game is available in the gzip and zip formats from the Downloads page.

PRE-RELEASE: Version 0.1

2010-01-30T17:57:00.001-05:00

The first release of Humm and Strumm is due in one week!

All version 0.x releases are game engine releases, with no playable game yet. Version 0.1 specifically has the following features:

Object/Type System: The Object/Type System forms the basis of almost all of the classes in the Humm and Strumm game. With this system, classes have runtime type information, dynamic creation from Type objects, and reference counting for smart pointers. Classes are said to "implement the Object/Type System" when they derive from Object and use the tools provided by the Object/Type System.
Memory Management System: The Memory Management System provides a memory heap implementation from which all memory in the game engine is allocated. The memory heap uses fewer calls to the system memory heap, so it is more efficient. A Pointer class is also provided, which updates the reference count of an Object.
Standard Error Classes: Standard Error Classes are used for communication through C++ exceptions of errors in the game engine. Currently, only error::Error and error::OutOfMemory are provided.

This version is fully documented with Doxygen comment documentation. Right now, tests have not been created; this will come in a later version.

The game engine download will be in a gzipped archive file, available at the Downloads Page.

External Project Documentation Site

2009-12-21T22:26:00.000-05:00

Instead of putting all the documentation in single wiki pages, we have decided to move it to an external site. At the moment, the documentation is more than a little spotty. This site will be updated daily, though, until it becomes more complete.

I also have two possible thread systems, which I will outline in a future post.

Unfortunately, that is all for updates, but the please check the documentation for many updates. I need to transfer the existing documentation there.

Meanwhile, Merry Christmas.

Implementation and Contribution

2009-11-27T19:48:00.001-05:00

After a rather long break from Humm and Strumm, I have almost finished implementing the four classes mentioned previously. Next month, I shall post more documentation about both the game and implementation, which in my opinion is seriously lacking. More API documentation will be on its way soon, and the policies are almost complete.

As a side note, if anyone would like to help, read up on the project policies (including the coding standards, which should be finalized in the near future) and find a feature to implement. Subscribe to the Humm and Strumm Contributors Group by sending us a request. You can find out more about this process at out Contribution Policy. We welcome any and all help.

API Interface for Core System

2009-10-11T19:50:00.003-04:00

At the moment, we have the API for the Core System of the engine documented. The next step is to implement these four classes. Note: the engine does not have thread support yet; see our release roadmap for more details. For now, we will use typedefs of C++ types for the Basic Type System. After we create the Debug System, we will add the basic type classes.

Upcoming TODOs:

Implement Core System
Write tests for Core System
Define Interface for Debug System

Humm and Strumm Blog

2009-08-11T15:29:00.005-04:00

Welcome to the Humm and Strumm blog! On this site, you will find news related to the development of the game, and other interesting things related to the game.

You can find the game at this location: http://code.google.com/p/hummstrumm/. This website has everything you need to know about the game, and and downloads. If you find any bugs, you can report them here.

Check back every once in a while, or better yet, subscribe!