It's a very simple class, but I wrote what I'm calling a Timer, it has similar functionality to a stop watch. The Basic timer class relies on the Windows QueryPerformanceFrequency, so here's the function necessary for my Timer class:

Time.h

#ifndef w_Time
#define w_Time

#include "../Definitions.h"

#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <Windows.h>

namespace _Warp
{
	class Time
	{
	public:

		static Real64 HiResTime()
		{
			u64 ticks;
			u64 ticksPerSecond;
			Bool result = QueryPerformanceFrequency((LARGE_INTEGER*) &ticksPerSecond);
			if(result == 0)
			{
				return -1;
			}
			result = QueryPerformanceCounter((LARGE_INTEGER*) &ticks);
			if(result == 0)
			{
				return -1;
			}
			return (Real64) ticks / ticksPerSecond;
		}
	};
};

#endif

Timer.h

#ifndef w_Timer
#define w_Timer

#include "../Definitions.h"

namespace _Warp
{
	class Timer
	{
	protected:
		Real64 _start;

		Bool _running;

	public:
		Timer();

		void Start();
		void Stop();
		void Reset();

		Real64 Get_Microseconds() const;
		Real64 Get_Milliseconds() const;
		Real64 Get_Seconds() const;

		Bool IsRunning() const;
	};
};

#endif

Timer.cpp

#include "Timer.h"

#include "Time.h"

namespace _Warp
{
	Timer::Timer()
		: _start( 0 )
		, _running( FALSE )
	{
	}

	void Timer::Start()
	{
		// this allows the timer to continue from where it left off
		_start = Time::HiResTime() - _start;
		_running = TRUE;
	}

	void Timer::Stop()
	{
		if(_running == TRUE)
		{
			_start = Time::HiResTime() - _start;
			_running = FALSE;
		}
	}

	void Timer::Reset()
	{
		if(_running == TRUE)
		{
			_start = Time::HiResTime();
		}
		else
		{
			_start = 0;
		}
	}

	Real64 Timer::Get_Microseconds() const
	{
		if(_running == TRUE)
		{
			return (Time::HiResTime() - _start) * 1000000.0;
		}
		return _start * 1000000.0;
	}

	Real64 Timer::Get_Milliseconds() const
	{
		if(_running == TRUE)
		{
			return (Time::HiResTime() - _start) * 1000.0;
		}
		return _start * 1000.0;
	}

	Real64 Timer::Get_Seconds() const
	{
		if(_running == TRUE)
		{
			return Time::HiResTime() - _start;
		}
		return _start;
	}

	Bool Timer::IsRunning() const
	{
		return _running;
	}
};

Here is a sample of how to use my timer class:

Timer timer = Timer();
timer.Start();
/* do stuff here */
timer.Stop();
Real64 seconds = timer.Get_Seconds();
timer.Reset();//reset the timer so it's total count is back to zero seconds.

timer.Start();
/* time something else */
timer.Stop();
/* do something */
timer.Start();//continue the count from where the timer left off
/* time something again*/
timer.Stop();
seconds = timer.Get_Seconds();// this is the total count of seconds from the last two timing sessions since Reset wasn't called

You can find the blog on the Definition.h file here.

Or download all of the above files and Definition.h here: Timer project files.

This is a simple definitions file that I use in my game engine, though this version was dumbed down for a 2D game engine I'll be working on.

Definitions.h

#ifndef w_Definitions
#define w_Definitions

#ifndef NULL
#define NULL 0
#endif

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif

#define NUKE(object)	{ if(object)	{ delete (object);		(object) = nullptr; } }
#define NUKE_ARRAY(object) { if(object) { delete[] (object);	(object) = nullptr; } }
#define RELEASE(object) { if(object)	{ (object)->Release();	(object) = nullptr; } }

namespace _Warp
{
	typedef signed char s8;
	typedef unsigned char u8;
	typedef signed short s16;
	typedef unsigned short u16;
	typedef signed int s32;
	typedef unsigned int u32;
	typedef signed long long s64;
	typedef unsigned long long u64;

	typedef unsigned int Bool;
	typedef u8 Byte;

	typedef float Real32;
	typedef double Real64;
};
#endif

These are the base data types I use everywhere in my game. Instead of using the 1 byte bool, I use a custom defined Bool which is the size of an integer; when compiled for a 32 bit system will coincide with 4 byte alignment, and compiled for a 64bit platform will coincide with 8 byte alignment. For more information on byte alignment, check out this wikipedia article.

Some of the macros are also useful for memory management, specifically NUKE, NUKE_ARRAY, and RELEASE. RELEASE is used on things like DirectX objects: RELEASE(_d3dDevice); basically, if you can't tell, any object that has a function called Release can be used with this macro. It checks to see if the object is valid, releases it, and sets the pointer to NULL. NUKE works on object you create using the 'new' operator, and properly sets the pointer to NULL. For example, cleaning up a Vector3:

Vector3* pVect = new Vector3(0,1,0);
/* other code here */
NUKE(pVect); // pVect gets cleaned up and set to NULL, aka, it is now nuked. ;p

And NUKE_ARRAY is used similarly on an array that was dynamically allocated, using new.

Definitions.zip

Airlines were helllllllllllllllll. >.< I missed every connecting flight I had, and I ended up missing most of the event I was checking out in Washington state. Of course things could have been better prepared for the first flight, but my choices were still limited since Newark only had flights out to Washington that day all in an hour time-span. That weekend was also hell because I didn't get a lot of sleep, one night getting only 4, the next only 3.

But, luckily I got to catch up on my sleep this week a bit. And yes I realize there's, "no such thing as catching up on sleep," but then I'll tell you to go preach somewhere else because I'll tell you otherwise. :p I got at least 15 hours the night after that crazy weekend, and more than 8 for the rest of the week! ^.^

So, I invited Beck Macary over for thanksgiving, and we had a blast hanging out with my cousins! I was especially open that night, explored my sense of humor more than I get to, and had plenty of laughs and good times tonight. Nerf Wars, sparring, food fight, crazyy uno games, lotss of fun, couldn't have gone better!! :]  After thinking about it, many of my Rocester friends haven't got to see my crazy sarcastic sense of humor in full action, it was a lot of fun, I even had moments I was laughing at myself! Good times. :)

So, with all that was going on, and catching up on sleep, my one week for thanksgiving break felt waay too short! But at least it was an awesome one, and weekend airline hell aside, it couldn't have gone better!!

Concerning programming stuff, the draft for my new Vector2 post has been sitting in my inbox, waiting to be edited and finished before posting. I'll probably release the post and the source code in the next week, and will get onto making another post with a useful class for game development.  I have a busy quarter in for me though, this is basically what my schedule looks like, though it's been changed a little: schedule here.  I'll have two game projects I'm working on, though one of them should be semi-finished early in the quarter, and from then on I'll only have one to work on; though I will try to continue work on my Warp game engine, as I plan on using it to develop my own games in the future, besides by expanding it learning other game programming technologies.  Fun stufff. (:

The last two years of my life at RIT leaves something to be desired, as a result I've been itching to get out of here and go somewhere else that will help re-ignite my passion for learning and programming.

Nothing bad about RIT in particular, it's just how school systems are, requiring you to take a whole bunch of classes that have nothing to do with your major.  I'm paying money to go to this school, and I don't think it's fair that I'm forced to take classes I don't want to take.  I realize they're supposed to help make me more well-rounded, but why do I have to take so many of them??  I just know I could've gotten a better programming experience if I went to a different school, though that's what I'm hoping for by going to graduate school.

So, in trying to spark my passion for programming and making games, I'm thinking of going to Digipen in Washington state, or Southern Methodist University: Guildhall in Texas.  I'm also looking to get a job for the next 6 months.


Overall, I know I want to try to develop a really cool game in my free time, and try to market it myself as an indie developer to try to make some money, and to help myself get my name out there to make it easier to be hired from a company.  You know, good resume material.  I'm also doing it to learn more about game programming, so it's an educational pursuit as well.  I already have ideas in mind, though they're technically challenging and will take some time.  However, I have thought about making a 3d fan version of ZZT, I just don't know if I'd have any lawsuit kind of stuff to worry about; if I did do such a thing, I know I probably couldn't sell it, but I'd encourage people to donate money if they appreciate the work. Anyway, just a thought, as I would love to see ZZT become almost mmo like material, or at least have online content sharing similar to Little Big Planet or what have you.  One thing that would also psych me out, is if my game supported importing standard .zzt games; though as the engine is 3d, I've been considering taking it into the 3d realm, especially considering the popularity of Minecraft.  The other games I want to make are technically challenging because they require some 3d physics stuff, obviously a 3d battle system with somewhat realistic targeting and reactions, and from there it's necessary to have a sophisticated animation system with something like rag doll support.  I also reaally want to mess around with graphics and making things look cool and pretty!


Anyway, I'll be posting more code stuff soon, like a modified Vector2 class after the early somewhat naive version being critiqued by the Leander Hasty, lead programmer at 1st Playable Productions.  I plan on putting up a Matrix_4x4 implementation, in which I first learned and started using the c++ "union" feature, allowing me to store and access data in a way that works with DirectX and OpenGL, or however I wanted; though I have to make tweaks to it based off of the recommendations of Leander, and rename a few things here and there.  I also plan on writing a basic tutorial explaining rotation matrices and what they actually represent, as classes and books I have read had failed to explain them in an easy coherent way.

Oh, as a side note, I had a lot of fun the other night working on a threaded server to setup a basic protocol for a simulated game environment; I hadn't worked with threads before in C++, so I'm eager to add support for them in my 3D engine, Warp.  Also on that note, I'll be adding a lot more on this engine, and making a project page for it with helper classes for you to feel free to use in your own projects.  I'll also mention all the various books I've been reading, as well as the open source game engines I've looked at, to try to inspire my design to create a cross-platform 3d game engine.  So the basic idea for my Warp Engine: it's a game engine that abstracts the hardware and software API's so you can write a game that works across multiple platforms without having to change much; the way to do this is through the use of interfaces and components implemented by a platform by platform basis.  Oh, and another thing I would like to look into is adding support for processors with SIMD instructions so my Vector3 and Matrix4x4 class can be more efficient.  Basically, there are too many things I want to do and to learn!! (:

I could ramble on for almost forever, so feel free to leave any thoughts if you might have them!

[Edit: Checkout the improved Vector2 class here: improved Vector2 blog post.]

Hey, it's been a while since I've posted anything, and I've been wanting to share this Vector2 class that I have written. It started being developed less than a year ago, and has undergone some minor changes since then to try to improve efficiency and add functionality. I haven't touched it in a while since then, as I'm now working on a 3D game engine, but here is what I've got.

/*  __      __   ___     _____    ____
 *  \ \    / /  / _ \   |  __ \  |    |
 *   \ \/\/ /  / / \ \  | | / /  |  __|
 *    \_/\_/  /_/   \_\ |_| \_\  |_|
 *      Take it to the next Level
 *
 *  Copyright (c) 2009 Brian Ernst.
 */

#ifndef w_Vector2
#define w_Vector2

#include <math.h>

namespace _Warp
{
	typedef float Scalar;
	typedef int Bool;

	class Vector2
	{
	public:
		Scalar X;
		Scalar Y;

		Vector2(const Scalar x = 0,const Scalar y = 0);
		~Vector2();

		Vector2 operator+(const Vector2& pVector) const;
		Vector2 operator-(const Vector2& pVector) const;
		Vector2 operator*(const Scalar& num) const;
		Vector2 operator/(const Scalar& num) const;
		Vector2 operator*(const Vector2& vector) const;
		Vector2 operator/(const Vector2& vector) const;
		void operator+=(const Vector2& pVector);
		void operator-=(const Vector2& pVector);
		void operator*=(const Scalar& num);
		void operator/=(const Scalar& num);
		void operator=(const Vector2& pVector);
		Bool operator==(const Vector2& vector) const;
		Bool operator!=(const Vector2& vector) const;

		void Clamp(const Scalar& value);
		void Normalize(const Scalar& value = 1.0f);
		void Invert();

		Scalar Length() const;

		Vector2 Copy() const;

		static Vector2 Cartesian(const Scalar& x,const Scalar& y);
		static Vector2 Polar(const Scalar& radius,const Scalar& angle);
		static Scalar Dot(const Vector2& pVec1,const Vector2& pVec2);
		static Vector2 Rotate(const Vector2& pVec,const Scalar& angle);
		static const Vector2 Zero;
	};

	inline Vector2 Vector2::Copy() const
	{
		return Vector2(X,Y);
	}

	inline Bool Vector2::operator==(const Vector2& vector) const
	{
		return X == vector.X && Y == vector.Y;
	}

	inline Bool Vector2::operator!=(const Vector2& vector) const
	{
		return X != vector.X || Y != vector.Y;
	}

	inline Vector2 Vector2::operator+(const Vector2& pVector) const
	{
		return Vector2(X + pVector.X,Y + pVector.Y);
	}

	inline Vector2 Vector2::operator-(const Vector2& pVector) const
	{
		return Vector2(X - pVector.X,Y - pVector.Y);
	}

	inline Vector2 Vector2::operator*(const Scalar& num) const
	{
		return Vector2(X * num,Y * num);
	}

	inline Vector2 Vector2::operator/(const Scalar& num) const
	{
		return Vector2(X / num,Y / num);
	}

	inline Vector2 Vector2::operator*(const Vector2& vector) const
	{
		return Vector2(X * vector.X,Y * vector.Y);
	}

	inline Vector2 Vector2::operator/(const Vector2& vector) const
	{
		return Vector2(X / vector.X,Y / vector.Y);
	}
}

#endif

And yes, I realize I need to comment this class, and I will. I might include the source files, but you can just as easily click on the "Source" button on the top right corner of the code box. And here's the cpp definitions file for the Vector2 functions:

#include "Vector2.h"

namespace _Warp
{
	const Vector2 Vector2::Zero = Vector2();

	Vector2::Vector2(const Scalar x,const Scalar y)
	{
		X = x;
		Y = y;
	}

	Vector2::~Vector2()
	{
	}

	void Vector2::operator+=(const Vector2& pVector)
	{
		X += pVector.X;
		Y += pVector.Y;
	}

	void Vector2::operator-=(const Vector2& pVector)
	{
		X -= pVector.X;
		Y -= pVector.Y;
	}

	void Vector2::operator*=(const Scalar& num)
	{
		X *= num;
		Y *= num;
	}

	void Vector2::operator/=(const Scalar& num)
	{
		X /= num;
		Y /= num;
	}

	void Vector2::operator=(const Vector2& pVector)
	{
		X = pVector.X;
		Y = pVector.Y;
	}

	Scalar Vector2::Length() const
	{
		return sqrt(pow(X,2.0f) + pow(Y,2.0f));
	}

	void Vector2::Clamp(const Scalar& value)
	{
		if(Length() <= value)
			return;
		Normalize();
		*this *= value;
	}

	void Vector2::Normalize(const Scalar& value)
	{
		Scalar vecLength = Length();

		if(vecLength == 0)
			return;

		X = X/vecLength * value;
		Y = Y/vecLength * value;
	}

	void Vector2::Invert()
	{
		X *= -1;
		Y *= -1;
	}

	Vector2 Vector2::Polar(const Scalar& x,const Scalar& y)
	{
		Vector2 pVector = Vector2();
		pVector.X = atan2(y,x);
		pVector.Y = sqrt(x * x + y * y);
		return pVector;
	}

	Vector2 Vector2::Cartesian(const Scalar& radius,const Scalar& angle)
	{
		Vector2 pVector = Vector2();
		pVector.X = radius * cos(angle);
		pVector.Y = radius * sin(angle);
		return pVector;
	}

	Scalar Vector2::Dot(const Vector2& pVec1,const Vector2& pVec2)
	{
		return pVec1.X * pVec2.X + pVec1.Y * pVec2.Y;
	}

	Vector2 Vector2::Rotate(const Vector2& pVec,const Scalar& angle)
	{
		Scalar cosResult = cos(angle);
		Scalar sinResult = sin(angle);

		//Essentially, apply a 2x2 rotation matrix to the vector
		Scalar newX = pVec.X * cosResult - pVec.Y * sinResult;
		Scalar newY = pVec.X * sinResult + pVec.Y * cosResult;

		return Vector2(newX,newY);
	}
}

It's pretty simple, but quite useful and powerful I think. I put it up here for other people to use for quick reference; let me know what you think or just drop me a line telling me you're using it for something, that'd make my day. (:

So here's a zip file you can download: Vector2

Archive