1 files changed, 371 insertions, 0 deletions
diff --git a/indra/newview/llhudeffectbeam.cpp b/indra/newview/llhudeffectbeam.cpp
new file mode 100644
index 0000000000..069986eb77
--- /dev/null
+++ b/indra/newview/llhudeffectbeam.cpp
@@ -0,0 +1,371 @@
+/** 
+ * @file llhudeffectbeam.cpp
+ * @brief LLHUDEffectBeam class implementation
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llhudeffectbeam.h"
+#include "message.h"
+
+#include "llviewerobjectlist.h"
+
+#include "llagent.h"
+#include "lldrawable.h"
+#include "llfontgl.h"
+#include "llgl.h"
+#include "llglheaders.h"
+#include "llhudrender.h"
+#include "llimagegl.h"
+#include "llsphere.h"
+#include "llviewercamera.h"
+#include "llvoavatar.h"
+#include "llviewercontrol.h"
+
+const F32 BEAM_SPACING = 0.075f;
+
+LLHUDEffectBeam::LLHUDEffectBeam(const U8 type) : LLHUDEffect(type)
+{
+	mKillTime = mDuration;
+
+	// Initialize all of these to defaults
+	S32 i;
+	for (i = 0; i < NUM_POINTS; i++)
+	{
+		mInterp[i].setStartTime(BEAM_SPACING*i);
+		mInterp[i].setEndTime(BEAM_SPACING*NUM_POINTS + BEAM_SPACING*i);
+		mInterp[i].start();
+		mInterpFade[i].setStartTime(BEAM_SPACING*NUM_POINTS + BEAM_SPACING*i - 0.5f*NUM_POINTS*BEAM_SPACING);
+		mInterpFade[i].setEndTime(BEAM_SPACING*NUM_POINTS + BEAM_SPACING*i);
+		mInterpFade[i].setStartVal(1.f);
+		mInterpFade[i].setEndVal(0.f);
+	}
+
+	// Setup default timeouts and fade animations.
+	F32 fade_length;
+	fade_length = llmin(0.5f, mDuration);
+	mFadeInterp.setStartTime(mKillTime - fade_length);
+	mFadeInterp.setEndTime(mKillTime);
+	mFadeInterp.setStartVal(1.f);
+	mFadeInterp.setEndVal(0.f);
+}
+
+LLHUDEffectBeam::~LLHUDEffectBeam()
+{
+}
+
+void LLHUDEffectBeam::packData(LLMessageSystem *mesgsys)
+{
+	if (!mSourceObject)
+	{
+		llwarns << "Missing source object!" << llendl;
+	}
+
+	// Pack the default data
+	LLHUDEffect::packData(mesgsys);
+
+	// Pack the type-specific data.  Uses a fun packed binary format.  Whee!
+	// 16 + 24 + 1 = 41
+	U8 packed_data[41];
+	memset(packed_data, 0, 41);
+	if (mSourceObject)
+	{
+		htonmemcpy(packed_data, mSourceObject->mID.mData, MVT_LLUUID, 16);
+	}
+
+	if (mTargetObject)
+	{
+		packed_data[16] = 1;
+	}
+	else
+	{
+		packed_data[16] = 0;
+	}
+
+	if (mTargetObject)
+	{
+		htonmemcpy(&(packed_data[17]), mTargetObject->mID.mData, MVT_LLUUID, 16);
+	}
+	else
+	{
+		htonmemcpy(&(packed_data[17]), mTargetPos.mdV, MVT_LLVector3d, 24);
+	}
+	mesgsys->addBinaryDataFast(_PREHASH_TypeData, packed_data, 41);
+}
+
+void LLHUDEffectBeam::unpackData(LLMessageSystem *mesgsys, S32 blocknum)
+{
+	llerrs << "Got beam!" << llendl;
+	BOOL use_target_object;
+	LLVector3d new_target;
+	U8 packed_data[41];
+
+	LLHUDEffect::unpackData(mesgsys, blocknum);
+	LLUUID source_id;
+	LLUUID target_id;
+	S32 size = mesgsys->getSizeFast(_PREHASH_Effect, blocknum, _PREHASH_TypeData);
+	if (size != 41)
+	{
+		llwarns << "Beam effect with bad size " << size << llendl;
+		return;
+	}
+	mesgsys->getBinaryDataFast(_PREHASH_Effect, _PREHASH_TypeData, packed_data, 41, blocknum);
+	
+	htonmemcpy(source_id.mData, packed_data, MVT_LLUUID, 16);
+
+	LLViewerObject *objp = gObjectList.findObject(source_id);
+	if (objp)
+	{
+		setSourceObject(objp);
+	}
+
+	use_target_object = packed_data[16];
+
+	if (use_target_object)
+	{
+		htonmemcpy(target_id.mData, &packed_data[17], MVT_LLUUID, 16);
+
+		LLViewerObject *objp = gObjectList.findObject(target_id);
+		if (objp)
+		{
+			setTargetObject(objp);
+		}
+	}
+	else
+	{
+		htonmemcpy(new_target.mdV, &(packed_data[17]), MVT_LLVector3d, 24);
+		setTargetPos(new_target);
+	}
+
+	// We've received an update for the effect, update the various timeouts
+	// and fade animations.
+	mKillTime = mTimer.getElapsedTimeF32() + mDuration;
+	F32 fade_length;
+	fade_length = llmin(0.5f, mDuration);
+	mFadeInterp.setStartTime(mKillTime - fade_length);
+	mFadeInterp.setEndTime(mKillTime);
+	mFadeInterp.setStartVal(1.f);
+	mFadeInterp.setEndVal(0.f);
+}
+
+void LLHUDEffectBeam::setSourceObject(LLViewerObject *objp)
+{
+	if (objp->isDead())
+	{
+		llwarns << "HUDEffectBeam: Source object is dead!" << llendl;
+		mSourceObject = NULL;
+		return;
+	}
+
+	if (mSourceObject == objp)
+	{
+		return;
+	}
+
+	mSourceObject = objp;
+	if (mSourceObject)
+	{
+		S32 i;
+		for (i = 0; i < NUM_POINTS; i++)
+		{
+			if (mSourceObject->isAvatar())
+			{
+				LLViewerObject *objp = mSourceObject;
+				LLVOAvatar *avatarp = (LLVOAvatar *)objp;
+				LLVector3d hand_pos_global = gAgent.getPosGlobalFromAgent(avatarp->mWristLeftp->getWorldPosition());
+				mInterp[i].setStartVal(hand_pos_global);
+				mInterp[i].start();
+			}
+			else
+			{
+				mInterp[i].setStartVal(mSourceObject->getPositionGlobal());
+				mInterp[i].start();
+			}
+		}
+	}
+}
+
+
+void LLHUDEffectBeam::setTargetObject(LLViewerObject *objp)
+{
+	if (mTargetObject->isDead())
+	{
+		llwarns << "HUDEffectBeam: Target object is dead!" << llendl;
+	}
+
+	mTargetObject = objp;
+}
+
+void LLHUDEffectBeam::setTargetPos(const LLVector3d &pos_global)
+{
+	mTargetPos = pos_global;
+	mTargetObject = NULL;
+}
+
+void LLHUDEffectBeam::render()
+{
+	if (!mSourceObject)
+	{
+		markDead();
+		return;
+	}
+	if (mSourceObject->isDead())
+	{
+		markDead();
+		return;
+	}
+
+	F32 time = mTimer.getElapsedTimeF32();
+
+	// Kill us if our time is over...
+	if (mKillTime < time)
+	{
+		markDead();
+		return;
+	}
+
+	LLGLSPipelineAlpha gls_pipeline_alpha;
+	LLImageGL::unbindTexture(0, GL_TEXTURE_2D);
+
+
+	// Interpolate the global fade alpha
+	mFadeInterp.update(time);
+
+	if (mTargetObject.notNull() && mTargetObject->mDrawable.notNull())
+	{
+		// use viewer object position on freshly created objects
+		if (mTargetObject->mDrawable->getGeneration() == -1)
+		{
+			mTargetPos = mTargetObject->getPositionGlobal();
+		}
+		// otherwise use drawable
+		else
+		{
+			mTargetPos = gAgent.getPosGlobalFromAgent(mTargetObject->mDrawable->getPositionAgent());
+		}
+	}
+
+
+	// Init the color of the particles
+	LLColor4U coloru = mColor;
+
+	/*
+	// This is disabled for now - DJS
+
+	// Fade the alpha
+	coloru.mV[3] = mFadeInterp.getCurVal()*mColor.mV[3];
+
+	// Draw a regular "beam" that connects the source and target
+
+	// First, figure out start and end positions relative to the camera
+	LLVector3 start_pos_agent;
+	if (mSourceObject->getPCode() == LL_PCODE_LEGACY_AVATAR)
+	{
+		LLViewerObject *objp = mSourceObject;
+		LLVOAvatar *avatarp = (LLVOAvatar *)objp;
+		LLVector3d hand_pos_global = gAgent.getPosGlobalFromAgent(avatarp->mWristLeftp->getWorldPosition());
+		start_pos_agent = gAgent.getPosAgentFromGlobal(hand_pos_global);
+	}
+	else
+	{
+		start_pos_agent = mSourceObject->getPositionAgent();
+	}
+	LLVector3 start_pos_camera = (start_pos_agent - gAgent.getCameraPositionAgent());
+	LLVector3 target_pos_agent = gAgent.getPosAgentFromGlobal(mTargetPos);
+	LLVector3 target_pos_camera = target_pos_agent - gAgent.getCameraPositionAgent();
+
+	// Generate the right "up" vector which is perpendicular to the beam, make it 1/10 meter wide, going to a point.
+	LLVector3 camera_up = gCamera->getUpAxis();
+	LLVector3 camera_at = gCamera->getAtAxis();
+	LLVector3 up = target_pos_camera % start_pos_camera;
+	up.normVec();
+	up *= 0.1f;
+
+	// Draw the triangle for the beam.
+	LLVector3 vertex;
+	glColor4ubv(coloru.mV);
+	glBegin(GL_TRIANGLE_STRIP);
+	vertex = start_pos_agent + up;
+	glVertex3fv(vertex.mV);
+	vertex = start_pos_agent - up;
+	glVertex3fv(vertex.mV);
+	vertex = target_pos_agent;
+	glVertex3fv(vertex.mV);
+	glEnd();
+	*/
+	
+	// Draw the particles
+	S32 i;
+	for (i = 0; i < NUM_POINTS; i++)
+	{
+		mInterp[i].update(time);
+		if (!mInterp[i].isActive())
+		{
+			continue;
+		}
+		mInterpFade[i].update(time);
+
+		if (mInterp[i].isDone())
+		{
+			// Reinitialize the particle when the particle has finished its animation.
+			setupParticle(i);
+		}
+
+		F32 frac = mInterp[i].getCurFrac();
+		F32 scale = 0.025f + fabs(0.05f*sin(2.f*F_PI*(frac - time)));
+		scale *= mInterpFade[i].getCurVal();
+
+		LLVector3 pos_agent = gAgent.getPosAgentFromGlobal(mInterp[i].getCurVal());
+
+		F32 alpha = mFadeInterp.getCurVal()*mColor.mV[3];
+		alpha *= mInterpFade[i].getCurVal();
+		coloru.mV[3] = (U8)alpha;
+		glColor4ubv(coloru.mV);
+
+		glPushMatrix();
+		glTranslatef(pos_agent.mV[0], pos_agent.mV[1], pos_agent.mV[2]);
+		glScalef(scale, scale, scale);
+		gSphere.render(0);
+		glPopMatrix();
+	}
+}
+
+void LLHUDEffectBeam::setupParticle(const S32 i)
+{
+	LLVector3d start_pos_global;
+	if (mSourceObject->getPCode() == LL_PCODE_LEGACY_AVATAR)
+	{
+		LLViewerObject *objp = mSourceObject;
+		LLVOAvatar *avatarp = (LLVOAvatar *)objp;
+		start_pos_global = gAgent.getPosGlobalFromAgent(avatarp->mWristLeftp->getWorldPosition());
+	}
+	else
+	{
+		start_pos_global = mSourceObject->getPositionGlobal();
+	}
+
+	// Generate a random offset for the target point.
+	const F32 SCALE = 0.5f;
+	F32 x, y, z;
+	x = frand(SCALE) - 0.5f*SCALE;
+	y = frand(SCALE) - 0.5f*SCALE;
+	z = frand(SCALE) - 0.5f*SCALE;
+
+	LLVector3d target_pos_global(mTargetPos);
+	target_pos_global += LLVector3d(x, y, z);
+
+	mInterp[i].setStartTime(mInterp[i].getEndTime());
+	mInterp[i].setEndTime(mInterp[i].getStartTime() + BEAM_SPACING*NUM_POINTS);
+	mInterp[i].setStartVal(start_pos_global);
+	mInterp[i].setEndVal(target_pos_global);
+	mInterp[i].start();
+
+
+	// Setup the interpolator that fades out the alpha.
+	mInterpFade[i].setStartTime(mInterp[i].getStartTime() + BEAM_SPACING*NUM_POINTS - 0.5f*NUM_POINTS*BEAM_SPACING);
+	mInterpFade[i].setEndTime(mInterp[i].getStartTime() + BEAM_SPACING*NUM_POINTS - 0.05f);
+	mInterpFade[i].start();
+}