TGE VolumeLight Distance Fade

In stock TGE, VolumeLights do not handle fogging causing them to "pop" in and out of view. This resource causes VolumeLights to automatically alpha fade based on the distance from the camera. The fade occurs linearly between the fog start range and the camera's max visible distance (in other words, the fade effect doesn't begin until the VolumeLight is actually "in" the fog plane and ends with the VolumeLight being totally transparent at the max visible distance).

On to the changes!

Step 1: Open engine/lightingSystem/volumeLight.h. In the public section of the volumeLight class (just below the sgRenderY() declaration) add:

F32 getRenderFadeValue(){return mLastRenderFadeValue;}

In the protected section of the volumeLight class (just below S32 mLastRenderTime) add:

void calcRenderFadeValue(SceneState *state);
	F32 mLastRenderFadeValue;

Save and close volumeLight.h.

Step 2: Open engien/lightingSystem/volumeLight.cc. Find volumeLight::initPersistFields(). Just above this method, add:

void volumeLight::calcRenderFadeValue(SceneState *state)
{
	mLastRenderFadeValue = 1.0f;

	F32 fadeDistStart = state->getFogDistance();
	F32 fadeDistEnd = state->getVisibleDistance();
	F32 distToCam  = (state->getCameraPosition() - getRenderPosition()).len();

	mLastRenderFadeValue = 1.0f - ((distToCam - fadeDistStart) / (fadeDistEnd - fadeDistStart));
	mLastRenderFadeValue = mClampF(mLastRenderFadeValue, 0.0f, 1.0f);
}

Find volumeLight::renderObject(). Inside this method, find renderGL(state, image). Just above this line, add:

// Calc render fade value to simulate fogging
	calcRenderFadeValue(state);

Replace the volumeLight::sgRenderY() and volumeLight::sgRenderX() methods with the following:

void volumeLight::sgRenderY(const Point3F &near1, const Point3F &far1, const Point3F &far2,
						   const ColorF &nearcol, const ColorF &farcol, F32 offset)
{
	glBegin(GL_QUADS);
	glColor4f(nearcol.red, nearcol.green, nearcol.blue, nearcol.alpha * getRenderFadeValue());
	glTexCoord2f(offset, 0.0);
	glVertex3f(near1.x, -near1.y, 0.0f);

	glColor4f(nearcol.red, nearcol.green, nearcol.blue, nearcol.alpha * getRenderFadeValue());
	glTexCoord2f(offset, 0.5);
	glVertex3f(near1.x, 0.0f, 0.0f);

	glColor4f(farcol.red, farcol.green, farcol.blue, farcol.alpha * getRenderFadeValue());
	glTexCoord2f(offset, 0.5);
	glVertex3f(far1.x, 0.0, far1.z);

	glColor4f(farcol.red, farcol.green, farcol.blue, farcol.alpha * getRenderFadeValue());
	glTexCoord2f(offset, 0.0);
	glVertex3f(far1.x, far1.y, far1.z);
	glEnd();

	glBegin(GL_QUADS);
	glColor4f(farcol.red, farcol.green, farcol.blue, farcol.alpha * getRenderFadeValue());
	glTexCoord2f(offset, 0.5);
	glVertex3f(far1.x, 0.0, far1.z);

	glColor4f(nearcol.red, nearcol.green, nearcol.blue, nearcol.alpha * getRenderFadeValue());
	glTexCoord2f(offset, 0.5);
	glVertex3f(near1.x, 0.0f, 0.0f);

	glColor4f(nearcol.red, nearcol.green, nearcol.blue, nearcol.alpha * getRenderFadeValue());
	glTexCoord2f(offset, 1.0);
	glVertex3f(near1.x, near1.y, 0.0f);

	glColor4f(farcol.red, farcol.green, farcol.blue, farcol.alpha * getRenderFadeValue());
	glTexCoord2f(offset, 1.0);
	glVertex3f(far2.x, far2.y, far2.z);
	glEnd();
}

void volumeLight::sgRenderX(const Point3F &near1, const Point3F &far1, const Point3F &far2,
						   const ColorF &nearcol, const ColorF &farcol, F32 offset)
{
	glBegin(GL_QUADS);
	glColor4f(nearcol.red, nearcol.green, nearcol.blue, nearcol.alpha * getRenderFadeValue());
	glTexCoord2f(0.0, offset);
	glVertex3f(-near1.x, near1.y, 0.0f);

	glColor4f(nearcol.red, nearcol.green, nearcol.blue, nearcol.alpha * getRenderFadeValue());
	glTexCoord2f(0.5, offset);
	glVertex3f(0.0f, near1.y, 0.0f);

	glColor4f(farcol.red, farcol.green, farcol.blue, farcol.alpha * getRenderFadeValue());
	glTexCoord2f(0.5, offset);
	glVertex3f(0.0, far1.y, far1.z);

	glColor4f(farcol.red, farcol.green, farcol.blue, farcol.alpha * getRenderFadeValue());
	glTexCoord2f(0.0, offset);
	glVertex3f(far1.x, far1.y, far1.z);
	glEnd();

	glBegin(GL_QUADS);
	glColor4f(farcol.red, farcol.green, farcol.blue, farcol.alpha * getRenderFadeValue());
	glTexCoord2f(0.5, offset);
	glVertex3f(0.0, far1.y, far1.z);

	glColor4f(nearcol.red, nearcol.green, nearcol.blue, nearcol.alpha * getRenderFadeValue());
	glTexCoord2f(0.5, offset);
	glVertex3f(0.0f, near1.y, 0.0f);

	glColor4f(nearcol.red, nearcol.green, nearcol.blue, nearcol.alpha * getRenderFadeValue());
	glTexCoord2f(1.0, offset);
	glVertex3f(near1.x, near1.y, 0.0f);

	glColor4f(farcol.red, farcol.green, farcol.blue, farcol.alpha * getRenderFadeValue());
	glTexCoord2f(1.0, offset);
	glVertex3f(far2.x, far2.y, far2.z);
	glEnd();
}

Replace the volumeLight::renderGL() method with the following:

void volumeLight::renderGL(SceneState *state, SceneRenderImage *image)
{
	glEnable(GL_TEXTURE_2D);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glEnable(GL_BLEND);
	glDepthMask(GL_FALSE);

	glBlendFunc(GL_SRC_ALPHA, GL_ONE);

	glBindTexture(GL_TEXTURE_2D, mLightHandle.getGLName());

	Point3F lightpoint;

	// This is where the hypothetical point source of the spot will be
	// The volume slices are projected along the lines from
	lightpoint.x = lightpoint.y = 0.0f;
	lightpoint.z = -mlpDistance;

	F32 ax = mXextent / 2;
	F32 ay = mYextent / 2;

	glEnable(GL_DEPTH_TEST);
	glDepthMask(GL_TRUE);

	// Draw the bottom foot...  this is basically the glowing region.
	glBegin(GL_QUADS);
		glColor4f(mfootColour.red, mfootColour.green, mfootColour.blue, getRenderFadeValue());
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f(-ax, -ay, 0.0f);

		glColor4f(mfootColour.red, mfootColour.green, mfootColour.blue, getRenderFadeValue());
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f(ax, -ay, 0.0f);

		glColor4f(mfootColour.red, mfootColour.green, mfootColour.blue, getRenderFadeValue());
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f(ax, ay, 0.0f);

		glColor4f(mfootColour.red, mfootColour.green, mfootColour.blue, getRenderFadeValue());
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f(-ax, ay, 0.0f);
	glEnd();

	S32 i;

	glDepthMask(GL_FALSE);

	// Slices in X/U space
	for(i = mSubdivideU; i >= 0; i--)
	{
		F32 k = ((F32)i) / mSubdivideU;				// use for the texture coord
		F32 bx = i * mXextent / mSubdivideU - ax;	// use for point positions

		// These are the two endpoints for a slice at the foot
		Point3F end1(bx, -ay, 0.0f);
		Point3F end2(bx, ay, 0.0f);

		end1 -= lightpoint;		// get a vector from point to lightsource
		end1.normalize();		// normalize vector
		end1 *= mShootDistance;	// multiply it out by shootlength

		end1.x += bx;			// Add the original point location to the vector
		end1.y -= ay;

		// Do it again for the other point.
		end2 -= lightpoint;
		end2.normalize();
		end2 *= mShootDistance;

		end2.x += bx;
		end2.y += ay;

		sgRenderY(Point3F(bx, ay, 0.0f), end1, end2, mfootColour, mtailColour, k);
	}

	// Slices in Y/V space
	for(i = 0; i <= mSubdivideV; i++)
	{
		F32 k = ((F32)i) / mSubdivideV;				// use for the texture coord
		F32 by = i * mXextent / mSubdivideV - ay;	// use for point positions

		// These are the two endpoints for a slice at the foot
		Point3F end1(-ax, by, 0.0f);
		Point3F end2(ax, by, 0.0f);

		end1 -= lightpoint;		// get a vector from point to lightsource
		end1.normalize();		// normalize vector
		end1 *= mShootDistance;	// extend it out by shootlength

		end1.x -= ax;			// Add the original point location to the vector
		end1.y += by;


		// Do it again for the other point.
		end2 -= lightpoint;
		end2.normalize();
		end2 *= mShootDistance;

		end2.x += ax;
		end2.y += by;

		sgRenderX(Point3F(ax, by, 0.0f), end1, end2, mfootColour, mtailColour, k);
	}

	glDepthMask(GL_TRUE);
}

Save volumeLight.cc. Recompile. :]