Immanuel Scholz

	typedef Particle::Engine<FireParticle, 8192,
		Particle::LinearMovement,
		Particle::PhoenixLifeDecrease,

		Particle::AlphaCircle,
		Particle::Glowing,
		Particle::SetColor
	> Fire;
	Fire fire;

All particle are moving with a linear movement (LinearMovement) and will respawn immediately on the emitter (PhoenixLifeDecrease). A circle with decreasing alpha-value is used as particle image (AlphaCircle). Particles glow by blending on the destination alpha (Glowing) and all particles have a constant colour (SetColor).

	TitleImpl()
	{
		fire.particleColor = D3DCOLOR_COLORVALUE(0.1f,0.06f,0.03f,1.0f);
	}

struct FireParticle
{
	struct Vertex
	{
		float x,y,z;
		Vertex()
			: x(randf()*gGame->width()-70)
			, y(500)
			, z(0)
		{
		}
		static const int FVF = D3DFVF_XYZ;
	};

	float maxLife;
	float life;
	Vector velocity;

	FireParticle()
		: maxLife(randf()*5.0f)
		, life(maxLife)
		, velocity(randf()*70, randf()*randf()*60-70)
	{
	}
};

• There has to be an inner-struct "Vertex", which has a constant FVF. Vertex is copied into the vertex buffer using memcpy later, so it's memory structure has to match the FVF constant. (E.g. no virtual functions!)
• Required member variables of the particle and Vertex are depending on the choosen actions. Examples: "LinearMovement" requires a member "Vector velocity" in the particle and "PhoenixLifeDecrease" needs a "float life".
• All member variables have to be readily initialized by the default constructor (and there has to be a default constructor). Note: This restriction has proven unsustainable and will be removed soon.
• Particle and Vertex can be copied by value (copy constructor, assignment operator, no subclassing).

	// No-Op type. You may safely ignore this.
	template<class P> struct EmptyTemplate {};

	// Main Engine Template.
	template<class P, size_t MAX_SIZE,
		template<class> class U1,
		template<class> class U2 = EmptyTemplate,
		template<class> class U3 = EmptyTemplate,
		template<class> class U4 = EmptyTemplate,
		template<class> class U5 = EmptyTemplate,
		template<class> class U6 = EmptyTemplate,
		template<class> class U7 = EmptyTemplate,
		template<class> class U8 = EmptyTemplate,
		template<class> class U9 = EmptyTemplate,
		template<class> class U10 = EmptyTemplate,
		template<class> class U11 = EmptyTemplate,
		template<class> class U12 = EmptyTemplate,
		template<class> class U13 = EmptyTemplate,
		template<class> class U14 = EmptyTemplate,
		template<class> class U15 = EmptyTemplate>
	class Engine : public Sequence<P, U1, U2, U3, U4, U5, U6,
				U7, U8, U9, U10, U11, U12, U13, U14, U15>
	{
	public:
		size_t size;
		typedef P Particle;
		typedef typename Particle::Vertex Vertex;
		typedef Sequence<P, U1, U2, U3, U4, U5, U6,
				U7, U8, U9, U10, U11, U12, U13, U14, U15> BaseSequence;
		typedef Engine<Particle, MAX_SIZE, U1, U2, U3, U4, U5, U6,
				U7, U8, U9, U10, U11, U12, U13, U14, U15> EngineType;

		Particle particle[MAX_SIZE];
		Vertex vertex[MAX_SIZE];
		IDirect3DVertexBuffer9* vb;

		Engine()
			: size(MAX_SIZE)
		{
			deviceReset();
			lostConnection = gGame->deviceLost.connect(
				std::bind(&EngineType::deviceLost, this));
			resetConnection = gGame->deviceReset.connect(
				std::bind(&EngineType::deviceReset, this));
		}
		~Engine()
		{
			deviceLost();
			lostConnection.disconnect();
			resetConnection.disconnect();
		}

		void update(float elapsed)
		{
			Sequence::emitParticles(elapsed, particle, vertex, size, MAX_SIZE);
			for (size_t i = 0; i < size;)
			{
				if (Sequence::updateParticle(elapsed, particle[i], vertex[i]))
				{
					particle[i] = particle[--size];
					vertex[i] = vertex[size];
				}
				else
					++i;
			}
		}

		void paint()
		{
			if (!size)
				return;
			Sequence::prePaint();

			gDevice->SetRenderState(D3DRS_POINTSPRITEENABLE, true);
			gDevice->SetFVF(Vertex::FVF);
			gDevice->SetStreamSource(0, vb, 0, sizeof(Vertex));
			Vertex* vertexData;
			VERIFY(vb->Lock(0, sizeof(Vertex)*size,
				(void**)&vertexData, D3DLOCK_DISCARD));
			memcpy(vertexData, vertex, sizeof(Vertex)*size);
			VERIFY(vb->Unlock());
			VERIFY(gDevice->DrawPrimitive(D3DPT_POINTLIST, 0, size));

			Sequence::postPaint();
		}

		void deviceLost()
		{
			SAFE_RELEASE(vb);
		}

		void deviceReset()
		{
			VERIFY(gDevice->CreateVertexBuffer(
				sizeof(vertex),
				D3DUSAGE_DYNAMIC | D3DUSAGE_POINTS | D3DUSAGE_WRITEONLY,
				Vertex::FVF,
				D3DPOOL_DEFAULT,
				&vb,
				0));
		}

	private:
		boost::signals::connection resetConnection, lostConnection;
	};

	// Combines update actions to a sequence using this template
	// and call the appropiate member functions if present.
	template<class P, template<class> class U1,
		template<class> class U2, template<class> class U3,
		template<class> class U4, template<class> class U5,
		template<class> class U6, template<class> class U7,
		template<class> class U8, template<class> class U9,
		template<class> class U10, template<class> class U11,
		template<class> class U12, template<class> class U13,
		template<class> class U14, template<class> class U15>
	class Sequence : public U1<P>, public Sequence<P, U2, U3, U4,
			U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15, EmptyTemplate>
	{
		typedef Sequence<P, U2, U3, U4, U5, U6, U7, U8, U9, U10,
				U11, U12, U13, U14, U15, EmptyTemplate> Tail;
	public:
		void emitParticles(float elapsed, P* p, typename P::Vertex* v,
				size_t& size, size_t MAX_SIZE)
		{
			Call<Traits<U1<P>,P>::hasEmitParticles, U1<P>, P>::
				emitParticles(*this, elapsed, p, v, size, MAX_SIZE);
			Call<Traits<Tail,P>::hasEmitParticles, Tail, P>::
				emitParticles(*this, elapsed, p, v, size, MAX_SIZE);
		}

		// returns whether the particle should be killed.
		bool updateParticle(float elapsed, P& p, typename P::Vertex& v)
		{
			return Call<Traits<U1<P>,P>::hasBoolUpdateParticle, U1<P>, P>::
					boolUpdateParticle(*this, elapsed, p, v)
				|| (Call<Traits<U1<P>,P>::hasUpdateParticle, U1<P>, P>::
					updateParticle(*this, elapsed, p, v), false)
				|| Call<Traits<Tail,P>::hasBoolUpdateParticle, Tail, P>::
					boolUpdateParticle(*this, elapsed, p, v)
				|| (Call<Traits<Tail,P>::hasUpdateParticle, Tail, P>::
					updateParticle(*this, elapsed, p, v), false);
		}

		void prePaint()
		{
			Call<Traits<U1<P>,P>::hasPrePaint, U1<P>, P>::prePaint(*this);
			Call<Traits<Tail,P>::hasPrePaint, Tail, P>::prePaint(*this);
		}

		void postPaint()
		{
			Call<Traits<U1<P>,P>::hasPostPaint, U1<P>, P>::postPaint(*this);
			Call<Traits<Tail,P>::hasPostPaint, Tail, P>::postPaint(*this);
		}
	};
	template<class P> struct Sequence<P, EmptyTemplate, EmptyTemplate,
			EmptyTemplate, EmptyTemplate, EmptyTemplate, EmptyTemplate,
			EmptyTemplate, EmptyTemplate, EmptyTemplate, EmptyTemplate,
			EmptyTemplate, EmptyTemplate, EmptyTemplate, EmptyTemplate,
			EmptyTemplate> {};

Other than that, Sequence just consists of 4 functions, which forward calls to 5 other functions.

One main aspect is, that these classes should be as easy to create and maintain as possible. That is because these are the classes a user of the framework has to know and understand. This is also the point where the user extends the framework with new functionality.

Users of these actions can (but does not have to) implement five different functions. If he provides an implementation, this will be called while the engine runs.

This description would be typical for a base class with only pure virtual functions ("interface" in other languages). With one exception: The function "updateParticle" can be implemented either as returning a bool or not returning anything (void). This kind overloading is not allowed for normal C++ classes.

// pseudo code. Not part of Nightwatch. (not even legal C++)
template<class P> // Partikel-struct
struct PossibleBaseClassOfActions
{
	// called before rendering (and before locking the vertex buffer)
	void prePaint();
	// at the end of rendering (after unlocking the buffer)
	void postPaint();
	// called every tick to update the particle state
	void updateParticle(float elapsed, P& p, typename P::Vertex& v);
	// like above, but if it returns true, the particle will be destroyed
	bool updateParticle(float elapsed, P& p, typename P::Vertex& v);
	// called to create particles
	void emitParticles(float elapsed, P* p, typename P::Vertex* v,
			size_t& size, size_t MAX_SIZE);
};

	/*
	Linear movement with a particle-specific velocity.
	The particle struct must have a member called "velocity".

	Requires: Vector velocity
	*/
	template<class P>
	struct LinearMovement
	{
		void updateParticle(float elapsed, P& p, typename P::Vertex& v)
		{
			v.x += p.velocity.x()*elapsed;
			v.y += p.velocity.y()*elapsed;
		}
	};

	/*
	Acceleration towards a fixed constant vector.

	Requires: Vector velocity
	*/
	template<class P>
	struct Gravity
	{
		Vector gravity;
		Gravity() : gravity(0,80) {}
		void updateParticle(float elapsed, P& p, typename P::Vertex& v)
		{
			p.velocity = p.velocity + elapsed * gravity;
		}
	};

	/*
	Decrease the lifetime and kills the particle, if it reaches zero life.

	Requires: float life;
	*/
	template<class P>
	struct LifeDecrease
	{
		bool updateParticle(float elapsed, P& p, typename P::Vertex& v)
		{
			p.life -= elapsed;
			return p.life < 0;
		}
	};

Finally an example for an action used in the "CursorSparkle" (the animated cursor). The action moves a particle only, if it is not near the current mouse position.

template<class P>
struct IfNotUnderMouse : Particle::LinearMovement<P>
{
	void updateParticle(float elapsed, P& p, typename P::Vertex& v)
	{
		if ((Gui::state.mouse - Vector(v.x-25, v.y-25)).length2() > 10)
			Particle::LinearMovement<P>::updateParticle(elapsed, p, v);
	}
};

Some places where the framework could be simplified without sacrificing performance:

1. updateParticle always returns a bool. Problem: Most actions would have to write a dummy "return false;" at their end.
2. Providing a class for all actions which non-virtual-implements all functions with an empty body. This class will be base class for all actions. The template "Call" and all SFINAE-code could be removed. Problem: User would have to override non-virtual functions and this is against all common programming recommendations. Alternatively, they would have to always implement all functions (empty, if necessary).

Beside: A template based system is basically unusable by artists and designer. Or at least it makes any visual editor a lot harder to write. And it unnecessarily lengthen compile times, which are usually already quite a problem for bigger games.

But I definetely achieved my goal: I feel quite comfortable with templates and meta programming again. ;-)