As you can see I’ve added doorways now, and well as roofs (although some are still not quite complete roofs yet). There is a new terrain being work on, that will hopefully be better for area Totus village is in (between two mountain ranges, with a forest to the south and plains to the north).

I’m currently decided what to do with the walls, its hard to tell from the original SNES graphics what they were trying to do with the walls. On the one hand they appear to be supported by beams, on the other those shadows on the beams could just the be the wall on the upper half. I’ve began working on a tool that takes the COLLADA file and converts it to my geometry format, as well as some geometry optimisations through Tootle.

One of my housemates, Johnny, made me a great loading screen and title screen. The loading screen, would have been better if the candle flickered, but I didn’t have time to multithread it.

More research is needed to know if Ogre3D can be multithreaded safely.

The title screen is just as basic as the loading screen, after I created a Lua script to control it. It has only two options, “Start New Game” and “Exit”.

I wish, as with the loading screen I had time to improve it, maybe some ambient music for the background, and the ability to save and load.

However there is a downside, the black outline edge is current done by drawing backfaces in wireframe with line thickness, the lower the anti-aliasing, the worse it appears. I’m thinking that if I use the depth buffer I can generate my own outlines based on depth change per pixel.

I have also modified the texture splat ARGB map to be smoother and use more toon like textures rather than realistic to go more with the overall theme of the game.

The contrast before was noticable, however the lack of shadows does give the impression now that the character is hovering above the ground, so I added basic shadows to solve this.

To finish off the post process effects, I added a Bloom shader.

Not only did I do that, but I finally got around to putting the finishing touches to my event system, now it now the type of variable that is being set, and I also finally found a use for template functions (thats right, functions, not classes, didn’t know they existed til last month).

What use you say? Quick function overloading, not really much point, but it saves the hassle of type casts. I’m currently using a 32bit unsigned integer for storing the variable type, which gives me 32 potential arguments for my events, I only use 5 at the moment, and I think I can remove one of them.

template
void SetArgumentAsNumber( const unsigned int inIndex, const T inValue )
{
 Arg[inIndex].d = (double)inValue;
 m_type &= ~( 1 << inIndex );
}

void SetArgumentAsString( const unsigned int inIndex, const char *string )
{
 Arg[inIndex].text = string;
 m_type |= ( 1 << inIndex );
}

bool IsArgumentAString( const unsigned int inIndex ) const
{
 return ( m_type & ( 1 << inIndex ) ) ? true : false;
}

So I’ve changed the skybox for my AGT project to be of a night sky with stars.

I’ve also reduced the fog near and far distance to be closer, and then darkened the colour. These worked together quite well, and the night effect was achieved.

I think with a bit of Bloom, the snow would look great like this.

The snowflakes are additive and alpha blended, and so give a glow, and stop at ground level, this is ruining slightly with the river since it is just slightly less than ground level.

Also the fact that a vertex shader is being for the water to make it look like it is moving, the snow shouldn’t settle on it, but it does.

Unfortunately that is not much I can do about it, at some point I may go through and setup multiple emitters that bypass the areas that the snow has a problem with, or adjust it so that it stops at a different ground level.

So here is some basic code for getting audio playing using FMOD, as well as a few additional functions. I’ve only allocated blocks for playing 10 sounds (if more than 10 sounds are attempted to be loaded, LoadSoundByFile() returns -1).

Here is the header for my sound manager.

#ifndef SOUNDMANAGER_H_INCLUDED
#define SOUNDMANAGER_H_INCLUDED

// --- [ libraries ] ------------------------------------------
#pragma comment(lib, "fmodex_vc.lib")

// --- [ includes ] -------------------------------------------
#include <fmod.hpp>

// --- [ definitions ] ----------------------------------------
#define SOUND_LOOP_INFINITE -1
#define MAX_NUM_SOUNDS 10

// --- [ class ] ----------------------------------------------
class SoundManager
{
// Attributes
private
FMOD::System * m_pSystem;
FMOD::Sound * m_pSound[MAX_NUM_SOUNDS];

// Functions
public:
// Constructor
SoundManager();

// Destructor
~SoundManager();

// Load Sound from File
int LoadSoundFromFile( const char * inFilename );

// Free Sound
void FreeSound( const int inSoundId );

// Play Sound
void PlaySound( const int inSoundId );

// Set Position
void SetSoundPosition( const int inSoundId, const int inPositionInMilliseconds );

// Set Loop Count
void SetSoundLoopCount( const int inSoundId, const int inCount );

// Set Loop Points
void SetSoundLoopPoints( const int inSoundId, const int inStartInMilliseconds, const int inEndInMilliseconds );
};

#endif

For background music, I’ve also included code so that the sound can be looped forever, and since not all sounds will be looping from the beginning, I’ve added a function to set where the loop repeats from and begins again. When a sound is not being used anymore, FreeSound() should be called for the id returned by LoadSoundFromFile().

And finally the source file for my sound manager.

// --- [ includes ] -------------------------------------------
#include "SoundManager.h"

// --- [ constructor / destructor ] ---------------------------
SoundManager::SoundManager()
{
for( unsigned int i = 0; i < MAX_NUM_EFFECTS; ++i )
{
m_pSound[i] = 0;
}

// Create FMOD SoundSystem
FMOD::System_Create( &m_pSystem );

// Check FMOD Version
unsigned int fmodVersion;
m_pSystem->getVersion( &fmodVersion );
assert( fmodVersion >= FMOD_VERSION )

// Initialize FMOD SoundSystem
m_pSystem->init(32, FMOD_INIT_NORMAL, 0);
}

SoundManager::~SoundManager()
{
// Free FMOD Sounds
for( unsigned int i = 0; i < MAX_NUM_SOUNDS; ++i )
{
if( m_pSound[i] )
{
m_pSound[i]->release();
}
}

// Free FMOD SoundSystem
if( m_pSystem )
{
m_pSystem->close();
m_pSystem->release();
m_pSystem = 0;
}
}

// --- [ functions ] ------------------------------------------
int SoundManager::LoadSoundFromFile( const char * inFilename )
{
for( int i = 0; i < MAX_NUM_SOUNDS; ++i )
{
if( !m_pSound[i] )
{
m_pSystem->createSound( inFilename, FMOD_SOFTWARE, 0, &m_pSound[i] );
return i;
}
}

return -1;
}

void SoundManager::FreeSound( const int inSoundId )
{
assert( inSoundId >= 0 && inSoundId < MAX_NUM_SOUNDS );

if( m_pSound[inSoundId] )
{
m_pSound[inSoundId]->release();
m_pSound[inSoundId] = 0;
}
}

void SoundManager::PlaySound( const int inSoundId )
{
assert( inSoundId >= 0 && inSoundId < MAX_NUM_SOUNDS );

if( m_pSound[inSoundId] )
{
FMOD::Channel * channel;
m_pSystem->playSound( FMOD_CHANNEL_FREE, m_pSound[inSoundId], false, &channel );
}
}

void SetSoundPosition( const int inSoundId, const int inPositionInMilliseconds )
{
assert( inSoundId >= 0 && inSoundId < MAX_NUM_SOUNDS );

if( m_pSound[inSoundId] )
{
m_pSound[inSoundId]->setPosition( inPositionInMilliseconds, FMOD_TIMEUNIT_MS );
}
}

void SoundManager::SetSoundLoopCount( const int inSoundId, const int inCount )
{
assert( inSoundId >= 0 && inSoundId < MAX_NUM_SOUNDS );

if( m_pSound[inSoundId] )
{
m_pSound[inSoundId]->setLoopCount( inCount );
}
}

void SoundManager::SetSoundLoopPoints( const int inSoundId, const int inStartInMilliseconds, const int inEndInMilliseconds )
{
assert( inSoundId >= 0 && inSoundId < MAX_NUM_SOUNDS );

if( m_pSound[inSoundId] )
{
m_pSound[inSoundId]->setLoopPoints( inStartInMilliseconds, FMOD_TIMEUNIT_MS, inEndInMilliseconds, FMOD_TIMEUNIT_MS );
}
}

All timing in my code is in milliseconds, but it can be changed to another supported FMOD time unit.

I’ve also added a smoke particle effect, though I’m currently “borrowing” the smoke from Wind Waker.

At some point I’ll be creating a campfire model to place below the smoke, and a small particle effect for fire. One thing I’d like to add to the map eventually would be some street lamps.

One thing last thing I’m happy about getting into the game is fog, though it wasn’t needed it showed me how to do something I’ve been trying to figure out.

I was playing around with the values and different fog equations when I got distant objects to flatten to silhouettes like the landscape does in World of Warcraft.

Before setting up a “.overlay” file for the GUI, I decided to manually enter the information into Ogre3D, and despite the texture coordinates being messed up, everything was fine.

Using C.E.G.U.I (Crazy Eddie’s Graphical User Interface), I setup an overlay file for the message box that would be displayed when talking to NPCs.

I brought in the edges slightly after a recommendation from one of my housemates, and then move the faceset image up slightly.

Over time I’ll be upgrading the models and effects to be better designed as more of the engine becomes active. At the moment I’m using a large texture (4096×4096 pixels) for the ground texture.

This ground texture is used to composite other smaller textures using a method known as “texture splatting“, which gives soft transitions between different textures depending on the mixture of colours.

I’ve used this method for transitioning between grass, sand, and rock.

The water has been upgraded from its original appearance to be more cartoon like, originally it was a semi transparent water texture.

Now the water texture is an opaque Toon shaded graphic that I found in a Ocean based game on the internet. At some point I’ll hopefully get around to making my own.

The town model is the most impressive part of the first town so far, being 52618 faces, 40000 of which are the tree (almost as bad as that 30000 face fish I had at one point).

But it is slowly being optimized, removing and merging polygons, and then afterwards, it will be split up and loaded as separate models, before being compiled into static geometry.

I’ve modified my shaders to give rings of brightness depending on the closeness to the player, this gives a more toon like effect, however I think the dark values are too strong at the moment, and need to be more subtle.