1 files changed, 399 insertions, 136 deletions

diff --git a/indra/newview/llvopartgroup.cpp b/indra/newview/llvopartgroup.cpp
index 0b34bbb90f..1ba0868544 100644..100755
--- a/indra/newview/llvopartgroup.cpp
+++ b/indra/newview/llvopartgroup.cpp
@@ -44,28 +44,22 @@
 #include "pipeline.h"
 #include "llspatialpartition.h"
 
-const F32 MAX_PART_LIFETIME = 120.f;
-
-extern U64 gFrameTime;
+extern U64MicrosecondsImplicit gFrameTime;
 
 LLPointer<LLVertexBuffer> LLVOPartGroup::sVB = NULL;
-S32 LLVOPartGroup::sVBSlotFree[];
-S32* LLVOPartGroup::sVBSlotCursor = NULL;
+S32 LLVOPartGroup::sVBSlotCursor = 0;
 
 void LLVOPartGroup::initClass()
 {
-	for (S32 i = 0; i < LL_MAX_PARTICLE_COUNT; ++i)
-	{
-		sVBSlotFree[i] = i;
-	}
-
-	sVBSlotCursor = sVBSlotFree;
+	
 }
 
 //static
 void LLVOPartGroup::restoreGL()
 {
-	sVB = new LLVertexBuffer(VERTEX_DATA_MASK, GL_STREAM_DRAW_ARB);
+
+	//TODO: optimize out binormal mask here.  Specular and normal coords as well.
+	sVB = new LLVertexBuffer(VERTEX_DATA_MASK | LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2, GL_STREAM_DRAW_ARB);
 	U32 count = LL_MAX_PARTICLE_COUNT;
 	sVB->allocateBuffer(count*4, count*6, true);
 
@@ -122,36 +116,33 @@ void LLVOPartGroup::destroyGL()
 //static
 S32 LLVOPartGroup::findAvailableVBSlot()
 {
-	if (sVBSlotCursor >= sVBSlotFree+LL_MAX_PARTICLE_COUNT)
+	if (sVBSlotCursor >= LL_MAX_PARTICLE_COUNT)
 	{ //no more available slots
 		return -1;
 	}
 
-	S32 ret = *sVBSlotCursor;
-	sVBSlotCursor++;
-
-	return ret;
+	return sVBSlotCursor++;
 }
 
 bool ll_is_part_idx_allocated(S32 idx, S32* start, S32* end)
 {
-	while (start < end)
+	/*while (start < end)
 	{
 		if (*start == idx)
 		{ //not allocated (in free list)
 			return false;
 		}
 		++start;
-	}
+	}*/
 
 	//allocated (not in free list)
-	return true;
+	return false;
 }
 
 //static
 void LLVOPartGroup::freeVBSlot(S32 idx)
 {
-	llassert(idx < LL_MAX_PARTICLE_COUNT && idx >= 0);
+	/*llassert(idx < LL_MAX_PARTICLE_COUNT && idx >= 0);
 	//llassert(sVBSlotCursor > sVBSlotFree);
 	//llassert(ll_is_part_idx_allocated(idx, sVBSlotCursor, sVBSlotFree+LL_MAX_PARTICLE_COUNT));
 
@@ -159,7 +150,7 @@ void LLVOPartGroup::freeVBSlot(S32 idx)
 	{
 		sVBSlotCursor--;
 		*sVBSlotCursor = idx;
-	}
+	}*/
 }
 
 LLVOPartGroup::LLVOPartGroup(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
@@ -183,20 +174,31 @@ BOOL LLVOPartGroup::isActive() const
 
 F32 LLVOPartGroup::getBinRadius()
 { 
-	return mScale.mV[0]*2.f;
+	return mViewerPartGroupp->getBoxSide();
 }
 
 void LLVOPartGroup::updateSpatialExtents(LLVector4a& newMin, LLVector4a& newMax)
 {		
 	const LLVector3& pos_agent = getPositionAgent();
-	newMin.load3( (pos_agent - mScale).mV);
-	newMax.load3( (pos_agent + mScale).mV);
-	LLVector4a pos;
-	pos.load3(pos_agent.mV);
-	mDrawable->setPositionGroup(pos);
+
+	LLVector4a scale;
+	LLVector4a p;
+
+	p.load3(pos_agent.mV);
+
+	scale.splat(mScale.mV[0]+mViewerPartGroupp->getBoxSide()*0.5f);
+
+	newMin.setSub(p, scale);
+	newMax.setAdd(p,scale);
+
+	llassert(newMin.isFinite3());
+	llassert(newMax.isFinite3());
+
+	llassert(p.isFinite3());
+	mDrawable->setPositionGroup(p);
 }
 
-void LLVOPartGroup::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
+void LLVOPartGroup::idleUpdate(LLAgent &agent, const F64 &time)
 {
 }
 
@@ -232,6 +234,37 @@ LLDrawable* LLVOPartGroup::createDrawable(LLPipeline *pipeline)
 
  const F32 MAX_PARTICLE_AREA_SCALE = 0.02f; // some tuned constant, limits on how much particle area to draw
 
+ LLUUID LLVOPartGroup::getPartOwner(S32 idx)
+ {
+	 LLUUID ret = LLUUID::null;
+
+	 if (idx < (S32) mViewerPartGroupp->mParticles.size())
+	 {
+		 ret = mViewerPartGroupp->mParticles[idx]->mPartSourcep->getOwnerUUID();
+	 }
+
+	 return ret;
+ }
+
+ LLUUID LLVOPartGroup::getPartSource(S32 idx)
+ {
+	 LLUUID ret = LLUUID::null;
+
+	 if (idx < (S32) mViewerPartGroupp->mParticles.size())
+	 {
+		 LLViewerPart* part = mViewerPartGroupp->mParticles[idx];
+		 if (part && part->mPartSourcep.notNull() &&
+			 part->mPartSourcep->mSourceObjectp.notNull())
+		 {
+			 LLViewerObject* source = part->mPartSourcep->mSourceObjectp;
+			 ret = source->getID();
+		 }
+	 }
+
+	 return ret;
+ }
+
+
 F32 LLVOPartGroup::getPartSize(S32 idx)
 {
 	if (idx < (S32) mViewerPartGroupp->mParticles.size())
@@ -242,15 +275,25 @@ F32 LLVOPartGroup::getPartSize(S32 idx)
 	return 0.f;
 }
 
+void LLVOPartGroup::getBlendFunc(S32 idx, U32& src, U32& dst)
+{
+	if (idx < (S32) mViewerPartGroupp->mParticles.size())
+	{
+		LLViewerPart* part = mViewerPartGroupp->mParticles[idx];
+		src = part->mBlendFuncSource;
+		dst = part->mBlendFuncDest;
+	}
+}
+
 LLVector3 LLVOPartGroup::getCameraPosition() const
 {
 	return gAgentCamera.getCameraPositionAgent();
 }
 
-static LLFastTimer::DeclareTimer FTM_UPDATE_PARTICLES("Update Particles");
+static LLTrace::BlockTimerStatHandle FTM_UPDATE_PARTICLES("Update Particles");
 BOOL LLVOPartGroup::updateGeometry(LLDrawable *drawable)
 {
-	LLFastTimer ftm(FTM_UPDATE_PARTICLES);
+	LL_RECORD_BLOCK_TIME(FTM_UPDATE_PARTICLES);
 
 	dirtySpatialGroup();
 	
@@ -301,19 +344,52 @@ BOOL LLVOPartGroup::updateGeometry(LLDrawable *drawable)
 	mDepth = 0.f;
 	S32 i = 0 ;
 	LLVector3 camera_agent = getCameraPosition();
+	
+	F32 max_scale = 0.f;
+
+
 	for (i = 0 ; i < (S32)mViewerPartGroupp->mParticles.size(); i++)
 	{
 		const LLViewerPart *part = mViewerPartGroupp->mParticles[i];
 
+
+		//remember the largest particle
+		max_scale = llmax(max_scale, part->mScale.mV[0], part->mScale.mV[1]);
+
+		if (part->mFlags & LLPartData::LL_PART_RIBBON_MASK)
+		{ //include ribbon segment length in scale
+			const LLVector3* pos_agent = NULL;
+			if (part->mParent)
+			{
+				pos_agent = &(part->mParent->mPosAgent);
+			}
+			else if (part->mPartSourcep.notNull())
+			{
+				pos_agent = &(part->mPartSourcep->mPosAgent);
+			}
+
+			if (pos_agent)
+			{
+				F32 dist = (*pos_agent-part->mPosAgent).length();
+
+				max_scale = llmax(max_scale, dist);
+			}
+		}
+
 		LLVector3 part_pos_agent(part->mPosAgent);
 		LLVector3 at(part_pos_agent - camera_agent);
 
+		
 		F32 camera_dist_squared = at.lengthSquared();
 		F32 inv_camera_dist_squared;
 		if (camera_dist_squared > 1.f)
 			inv_camera_dist_squared = 1.f / camera_dist_squared;
 		else
 			inv_camera_dist_squared = 1.f;
+
+		llassert(llfinite(inv_camera_dist_squared));
+		llassert(!llisnan(inv_camera_dist_squared));
+
 		F32 area = part->mScale.mV[0] * part->mScale.mV[1] * inv_camera_dist_squared;
 		tot_area = llmax(tot_area, area);
  		
@@ -327,7 +403,7 @@ BOOL LLVOPartGroup::updateGeometry(LLDrawable *drawable)
 		facep = drawable->getFace(i);
 		if (!facep)
 		{
-			llwarns << "No face found for index " << i << "!" << llendl;
+			LL_WARNS() << "No face found for index " << i << "!" << LL_ENDL;
 			continue;
 		}
 
@@ -373,110 +449,265 @@ BOOL LLVOPartGroup::updateGeometry(LLDrawable *drawable)
 		LLFace* facep = drawable->getFace(i);
 		if (!facep)
 		{
-			llwarns << "No face found for index " << i << "!" << llendl;
+			LL_WARNS() << "No face found for index " << i << "!" << LL_ENDL;
 			continue;
 		}
 		facep->setTEOffset(i);
 		facep->setSize(0, 0);
 	}
 
+	//record max scale (used to stretch bounding box for visibility culling)
+	
+	mScale.set(max_scale, max_scale, max_scale);
+
 	mDrawable->movePartition();
 	LLPipeline::sCompiles++;
 	return TRUE;
 }
 
+
+BOOL LLVOPartGroup::lineSegmentIntersect(const LLVector4a& start, const LLVector4a& end,
+										  S32 face,
+										  BOOL pick_transparent,
+										  S32* face_hit,
+										  LLVector4a* intersection,
+										  LLVector2* tex_coord,
+										  LLVector4a* normal,
+										  LLVector4a* bi_normal)
+{
+	LLVector4a dir;
+	dir.setSub(end, start);
+
+	F32 closest_t = 2.f;
+	BOOL ret = FALSE;
+	
+	for (U32 idx = 0; idx < mViewerPartGroupp->mParticles.size(); ++idx)
+	{
+		const LLViewerPart &part = *((LLViewerPart*) (mViewerPartGroupp->mParticles[idx]));
+
+		LLVector4a v[4];
+		LLStrider<LLVector4a> verticesp;
+		verticesp = v;
+		
+		getGeometry(part, verticesp);
+
+		F32 a,b,t;
+		if (LLTriangleRayIntersect(v[0], v[1], v[2], start, dir, a,b,t) ||
+			LLTriangleRayIntersect(v[1], v[3], v[2], start, dir, a,b,t))
+		{
+			if (t >= 0.f &&
+				t <= 1.f &&
+				t < closest_t)
+			{
+				ret = TRUE;
+				closest_t = t;
+				if (face_hit)
+				{
+					*face_hit = idx;
+				}
+
+				if (intersection)
+				{
+					LLVector4a intersect = dir;
+					intersect.mul(closest_t);
+					intersection->setAdd(intersect, start);
+				}
+			}
+		}
+	}
+
+	return ret;
+}
+
+void LLVOPartGroup::getGeometry(const LLViewerPart& part,
+								LLStrider<LLVector4a>& verticesp)
+{
+	if (part.mFlags & LLPartData::LL_PART_RIBBON_MASK)
+	{
+		LLVector4a axis, pos, paxis, ppos;
+		F32 scale, pscale;
+
+		pos.load3(part.mPosAgent.mV);
+		axis.load3(part.mAxis.mV);
+		scale = part.mScale.mV[0];
+		
+		if (part.mParent)
+		{
+			ppos.load3(part.mParent->mPosAgent.mV);
+			paxis.load3(part.mParent->mAxis.mV);
+			pscale = part.mParent->mScale.mV[0];
+		}
+		else
+		{ //use source object as position
+			
+			if (part.mPartSourcep->mSourceObjectp.notNull())
+			{
+				LLVector3 v = LLVector3(0,0,1);
+				v *= part.mPartSourcep->mSourceObjectp->getRenderRotation();
+				paxis.load3(v.mV);
+				ppos.load3(part.mPartSourcep->mPosAgent.mV);
+				pscale = part.mStartScale.mV[0];
+			}
+			else
+			{ //no source object, no parent, nothing to draw
+				ppos = pos;
+				pscale = scale;
+				paxis = axis;
+			}
+		}
+
+		LLVector4a p0, p1, p2, p3;
+
+		scale *= 0.5f;
+		pscale *= 0.5f;
+
+		axis.mul(scale);
+		paxis.mul(pscale);
+
+		p0.setAdd(pos, axis);
+		p1.setSub(pos,axis);
+		p2.setAdd(ppos, paxis);
+		p3.setSub(ppos, paxis);
+
+		(*verticesp++) = p2;
+		(*verticesp++) = p3;
+		(*verticesp++) = p0;
+		(*verticesp++) = p1;
+	}
+	else
+	{
+		LLVector4a part_pos_agent;
+		part_pos_agent.load3(part.mPosAgent.mV);
+		LLVector4a camera_agent;
+		camera_agent.load3(getCameraPosition().mV); 
+		LLVector4a at;
+		at.setSub(part_pos_agent, camera_agent);
+		LLVector4a up(0, 0, 1);
+		LLVector4a right;
+
+		right.setCross3(at, up);
+		right.normalize3fast();
+
+		up.setCross3(right, at);
+		up.normalize3fast();
+
+		if (part.mFlags & LLPartData::LL_PART_FOLLOW_VELOCITY_MASK)
+		{
+			LLVector4a normvel;
+			normvel.load3(part.mVelocity.mV);
+			normvel.normalize3fast();
+			LLVector2 up_fracs;
+			up_fracs.mV[0] = normvel.dot3(right).getF32();
+			up_fracs.mV[1] = normvel.dot3(up).getF32();
+			up_fracs.normalize();
+			LLVector4a new_up;
+			LLVector4a new_right;
+
+			//new_up = up_fracs.mV[0] * right + up_fracs.mV[1]*up;
+			LLVector4a t = right;
+			t.mul(up_fracs.mV[0]);
+			new_up = up;
+			new_up.mul(up_fracs.mV[1]);
+			new_up.add(t);
+
+			//new_right = up_fracs.mV[1] * right - up_fracs.mV[0]*up;
+			t = right;
+			t.mul(up_fracs.mV[1]);
+			new_right = up;
+			new_right.mul(up_fracs.mV[0]);
+			t.sub(new_right);
+
+			up = new_up;
+			right = t;
+			up.normalize3fast();
+			right.normalize3fast();
+		}
+
+		right.mul(0.5f*part.mScale.mV[0]);
+		up.mul(0.5f*part.mScale.mV[1]);
+
+
+		//HACK -- the verticesp->mV[3] = 0.f here are to set the texture index to 0 (particles don't use texture batching, maybe they should)
+		// this works because there is actually a 4th float stored after the vertex position which is used as a texture index
+		// also, somebody please VECTORIZE THIS
+
+		LLVector4a ppapu;
+		LLVector4a ppamu;
+
+		ppapu.setAdd(part_pos_agent, up);
+		ppamu.setSub(part_pos_agent, up);
+
+		verticesp->setSub(ppapu, right);
+		(*verticesp++).getF32ptr()[3] = 0.f;
+		verticesp->setSub(ppamu, right);
+		(*verticesp++).getF32ptr()[3] = 0.f;
+		verticesp->setAdd(ppapu, right);
+		(*verticesp++).getF32ptr()[3] = 0.f;
+		verticesp->setAdd(ppamu, right);
+		(*verticesp++).getF32ptr()[3] = 0.f;
+	}
+}
+
+
+								
 void LLVOPartGroup::getGeometry(S32 idx,
 								LLStrider<LLVector4a>& verticesp,
 								LLStrider<LLVector3>& normalsp, 
 								LLStrider<LLVector2>& texcoordsp,
 								LLStrider<LLColor4U>& colorsp, 
+								LLStrider<LLColor4U>& emissivep,
 								LLStrider<U16>& indicesp)
 {
 	if (idx >= (S32) mViewerPartGroupp->mParticles.size())
 	{
 		return;
 	}
-
+	
 	const LLViewerPart &part = *((LLViewerPart*) (mViewerPartGroupp->mParticles[idx]));
 
-	LLVector4a part_pos_agent;
-	part_pos_agent.load3(part.mPosAgent.mV);
-	LLVector4a camera_agent;
-	camera_agent.load3(getCameraPosition().mV); 
-	LLVector4a at;
-	at.setSub(part_pos_agent, camera_agent);
-	LLVector4a up(0, 0, 1);
-	LLVector4a right;
-
-	right.setCross3(at, up);
-	right.normalize3fast();
-	up.setCross3(right, at);
-	up.normalize3fast();
-
-	if (part.mFlags & LLPartData::LL_PART_FOLLOW_VELOCITY_MASK)
-	{
-		LLVector4a normvel;
-		normvel.load3(part.mVelocity.mV);
-		normvel.normalize3fast();
-		LLVector2 up_fracs;
-		up_fracs.mV[0] = normvel.dot3(right).getF32();
-		up_fracs.mV[1] = normvel.dot3(up).getF32();
-		up_fracs.normalize();
-		LLVector4a new_up;
-		LLVector4a new_right;
-
-		//new_up = up_fracs.mV[0] * right + up_fracs.mV[1]*up;
-		LLVector4a t = right;
-		t.mul(up_fracs.mV[0]);
-		new_up = up;
-		new_up.mul(up_fracs.mV[1]);
-		new_up.add(t);
-
-		//new_right = up_fracs.mV[1] * right - up_fracs.mV[0]*up;
-		t = right;
-		t.mul(up_fracs.mV[1]);
-		new_right = up;
-		new_right.mul(up_fracs.mV[0]);
-		t.sub(new_right);
-
-		up = new_up;
-		right = t;
-		up.normalize3fast();
-		right.normalize3fast();
-	}
-
-	right.mul(0.5f*part.mScale.mV[0]);
-	up.mul(0.5f*part.mScale.mV[1]);
+	getGeometry(part, verticesp);
 
+	LLColor4U pcolor;
+	LLColor4U color = part.mColor;
 
-	LLVector3 normal = -LLViewerCamera::getInstance()->getXAxis();
+	LLColor4U pglow;
 
-	//HACK -- the verticesp->mV[3] = 0.f here are to set the texture index to 0 (particles don't use texture batching, maybe they should)
-	// this works because there is actually a 4th float stored after the vertex position which is used as a texture index
-	// also, somebody please VECTORIZE THIS
-
-	LLVector4a ppapu;
-	LLVector4a ppamu;
-
-	ppapu.setAdd(part_pos_agent, up);
-	ppamu.setSub(part_pos_agent, up);
+	if (part.mFlags & LLPartData::LL_PART_RIBBON_MASK)
+	{ //make sure color blends properly
+		if (part.mParent)
+		{
+			pglow = part.mParent->mGlow;
+			pcolor = part.mParent->mColor;
+		}
+		else 
+		{
+			pglow = LLColor4U(0, 0, 0, (U8) ll_round(255.f*part.mStartGlow));
+			pcolor = part.mStartColor;
+		}
+	}
+	else
+	{
+		pglow = part.mGlow;
+		pcolor = color;
+	}
 
-	verticesp->setSub(ppapu, right);
-	(*verticesp++).getF32ptr()[3] = 0.f;
-	verticesp->setSub(ppamu, right);
-	(*verticesp++).getF32ptr()[3] = 0.f;
-	verticesp->setAdd(ppapu, right);
-	(*verticesp++).getF32ptr()[3] = 0.f;
-	verticesp->setAdd(ppamu, right);
-	(*verticesp++).getF32ptr()[3] = 0.f;
+	*colorsp++ = pcolor;
+	*colorsp++ = pcolor;
+	*colorsp++ = color;
+	*colorsp++ = color;
+
+	//if (pglow.mV[3] || part.mGlow.mV[3])
+	{ //only write glow if it is not zero
+		*emissivep++ = pglow;
+		*emissivep++ = pglow;
+		*emissivep++ = part.mGlow;
+		*emissivep++ = part.mGlow;
+	}
 
-	*colorsp++ = part.mColor;
-	*colorsp++ = part.mColor;
-	*colorsp++ = part.mColor;
-	*colorsp++ = part.mColor;
 
 	if (!(part.mFlags & LLPartData::LL_PART_EMISSIVE_MASK))
 	{ //not fullbright, needs normal
+		LLVector3 normal = -LLViewerCamera::getInstance()->getXAxis();
 		*normalsp++   = normal;
 		*normalsp++   = normal;
 		*normalsp++   = normal;
@@ -489,8 +720,8 @@ U32 LLVOPartGroup::getPartitionType() const
 	return LLViewerRegion::PARTITION_PARTICLE; 
 }
 
-LLParticlePartition::LLParticlePartition()
-: LLSpatialPartition(LLDrawPoolAlpha::VERTEX_DATA_MASK | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, GL_STREAM_DRAW_ARB)
+LLParticlePartition::LLParticlePartition(LLViewerRegion* regionp)
+: LLSpatialPartition(LLDrawPoolAlpha::VERTEX_DATA_MASK | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, GL_STREAM_DRAW_ARB, regionp)
 {
 	mRenderPass = LLRenderPass::PASS_ALPHA;
 	mDrawableType = LLPipeline::RENDER_TYPE_PARTICLES;
@@ -499,18 +730,18 @@ LLParticlePartition::LLParticlePartition()
 	mLODPeriod = 1;
 }
 
-LLHUDParticlePartition::LLHUDParticlePartition() :
-	LLParticlePartition()
+LLHUDParticlePartition::LLHUDParticlePartition(LLViewerRegion* regionp) :
+	LLParticlePartition(regionp)
 {
 	mDrawableType = LLPipeline::RENDER_TYPE_HUD_PARTICLES;
 	mPartitionType = LLViewerRegion::PARTITION_HUD_PARTICLE;
 }
 
-static LLFastTimer::DeclareTimer FTM_REBUILD_PARTICLE_VBO("Particle VBO");
+static LLTrace::BlockTimerStatHandle FTM_REBUILD_PARTICLE_VBO("Particle VBO");
 
 void LLParticlePartition::rebuildGeom(LLSpatialGroup* group)
 {
-	if (group->isDead() || !group->isState(LLSpatialGroup::GEOM_DIRTY))
+	if (group->isDead() || !group->hasState(LLSpatialGroup::GEOM_DIRTY))
 	{
 		return;
 	}
@@ -521,7 +752,7 @@ void LLParticlePartition::rebuildGeom(LLSpatialGroup* group)
 		group->mLastUpdateViewAngle = group->mViewAngle;
 	}
 	
-	LLFastTimer ftm(FTM_REBUILD_PARTICLE_VBO);	
+	LL_RECORD_BLOCK_TIME(FTM_REBUILD_PARTICLE_VBO);	
 
 	group->clearDrawMap();
 	
@@ -558,9 +789,9 @@ void LLParticlePartition::addGeometryCount(LLSpatialGroup* group, U32& vertex_co
 	LLViewerCamera* camera = LLViewerCamera::getInstance();
 	for (LLSpatialGroup::element_iter i = group->getDataBegin(); i != group->getDataEnd(); ++i)
 	{
-		LLDrawable* drawablep = *i;
+		LLDrawable* drawablep = (LLDrawable*)(*i)->getDrawable();
 		
-		if (drawablep->isDead())
+		if (!drawablep || drawablep->isDead())
 		{
 			continue;
 		}
@@ -595,11 +826,11 @@ void LLParticlePartition::addGeometryCount(LLSpatialGroup* group, U32& vertex_co
 }
 
 
-static LLFastTimer::DeclareTimer FTM_REBUILD_PARTICLE_GEOM("Particle Geom");
+static LLTrace::BlockTimerStatHandle FTM_REBUILD_PARTICLE_GEOM("Particle Geom");
 
 void LLParticlePartition::getGeometry(LLSpatialGroup* group)
 {
-	LLFastTimer ftm(FTM_REBUILD_PARTICLE_GEOM);
+	LL_RECORD_BLOCK_TIME(FTM_REBUILD_PARTICLE_GEOM);
 
 	std::sort(mFaceList.begin(), mFaceList.end(), LLFace::CompareDistanceGreater());
 
@@ -615,10 +846,13 @@ void LLParticlePartition::getGeometry(LLSpatialGroup* group)
 	LLStrider<LLVector3> normalsp;
 	LLStrider<LLVector2> texcoordsp;
 	LLStrider<LLColor4U> colorsp;
+	LLStrider<LLColor4U> emissivep;
 
 	buffer->getVertexStrider(verticesp);
 	buffer->getNormalStrider(normalsp);
 	buffer->getColorStrider(colorsp);
+	buffer->getEmissiveStrider(emissivep);
+
 	
 	LLSpatialGroup::drawmap_elem_t& draw_vec = group->mDrawMap[mRenderPass];	
 
@@ -627,7 +861,7 @@ void LLParticlePartition::getGeometry(LLSpatialGroup* group)
 		LLFace* facep = *i;
 		LLAlphaObject* object = (LLAlphaObject*) facep->getViewerObject();
 
-		if (!facep->isState(LLFace::PARTICLE))
+		//if (!facep->isState(LLFace::PARTICLE))
 		{ //set the indices of this face
 			S32 idx = LLVOPartGroup::findAvailableVBSlot();
 			if (idx >= 0)
@@ -636,7 +870,7 @@ void LLParticlePartition::getGeometry(LLSpatialGroup* group)
 				facep->setIndicesIndex(idx*6);
 				facep->setVertexBuffer(LLVOPartGroup::sVB);
 				facep->setPoolType(LLDrawPool::POOL_ALPHA);
-				facep->setState(LLFace::PARTICLE);
+				//facep->setState(LLFace::PARTICLE);
 			}
 			else
 			{
@@ -651,9 +885,19 @@ void LLParticlePartition::getGeometry(LLSpatialGroup* group)
 		LLStrider<LLVector3> cur_norm = normalsp + geom_idx;
 		LLStrider<LLVector2> cur_tc = texcoordsp + geom_idx;
 		LLStrider<LLColor4U> cur_col = colorsp + geom_idx;
+		LLStrider<LLColor4U> cur_glow = emissivep + geom_idx;
 
-		object->getGeometry(facep->getTEOffset(), cur_vert, cur_norm, cur_tc, cur_col, cur_idx);
+		LLColor4U* start_glow = cur_glow.get();
+
+		object->getGeometry(facep->getTEOffset(), cur_vert, cur_norm, cur_tc, cur_col, cur_glow, cur_idx);
 		
+		BOOL has_glow = FALSE;
+
+		if (cur_glow.get() != start_glow)
+		{
+			has_glow = TRUE;
+		}
+
 		llassert(facep->getGeomCount() == 4);
 		llassert(facep->getIndicesCount() == 6);
 
@@ -668,24 +912,37 @@ void LLParticlePartition::getGeometry(LLSpatialGroup* group)
 
 		bool batched = false;
 	
-		if (idx >= 0 &&
-			draw_vec[idx]->mTexture == facep->getTexture() &&
-			draw_vec[idx]->mFullbright == fullbright)
+		U32 bf_src = LLRender::BF_SOURCE_ALPHA;
+		U32 bf_dst = LLRender::BF_ONE_MINUS_SOURCE_ALPHA;
+
+		object->getBlendFunc(facep->getTEOffset(), bf_src, bf_dst);
+
+		
+		if (idx >= 0)
 		{
-			if (draw_vec[idx]->mEnd == facep->getGeomIndex()-1)
-			{
-				batched = true;
-				draw_vec[idx]->mCount += facep->getIndicesCount();
-				draw_vec[idx]->mEnd += facep->getGeomCount();
-				draw_vec[idx]->mVSize = llmax(draw_vec[idx]->mVSize, vsize);
-			}
-			else if (draw_vec[idx]->mStart == facep->getGeomIndex()+facep->getGeomCount()+1)
+			LLDrawInfo* info = draw_vec[idx];
+
+			if (info->mTexture == facep->getTexture() &&
+				info->mHasGlow == has_glow &&
+				info->mFullbright == fullbright &&
+				info->mBlendFuncDst == bf_dst &&
+				info->mBlendFuncSrc == bf_src)
 			{
-				batched = true;
-				draw_vec[idx]->mCount += facep->getIndicesCount();
-				draw_vec[idx]->mStart -= facep->getGeomCount();
-				draw_vec[idx]->mOffset = facep->getIndicesStart();
-				draw_vec[idx]->mVSize = llmax(draw_vec[idx]->mVSize, vsize);
+				if (draw_vec[idx]->mEnd == facep->getGeomIndex()-1)
+				{
+					batched = true;
+					info->mCount += facep->getIndicesCount();
+					info->mEnd += facep->getGeomCount();
+					info->mVSize = llmax(draw_vec[idx]->mVSize, vsize);
+				}
+				else if (draw_vec[idx]->mStart == facep->getGeomIndex()+facep->getGeomCount()+1)
+				{
+					batched = true;
+					info->mCount += facep->getIndicesCount();
+					info->mStart -= facep->getGeomCount();
+					info->mOffset = facep->getIndicesStart();
+					info->mVSize = llmax(draw_vec[idx]->mVSize, vsize);
+				}
 			}
 		}
 
@@ -699,9 +956,15 @@ void LLParticlePartition::getGeometry(LLSpatialGroup* group)
 			LLDrawInfo* info = new LLDrawInfo(start,end,count,offset,facep->getTexture(), 
 				//facep->getTexture(),
 				buffer, fullbright); 
-			info->mExtents[0] = group->mObjectExtents[0];
-			info->mExtents[1] = group->mObjectExtents[1];
+
+			const LLVector4a* exts = group->getObjectExtents();
+			info->mExtents[0] = exts[0];
+			info->mExtents[1] = exts[1];
 			info->mVSize = vsize;
+			info->mBlendFuncDst = bf_dst;
+			info->mBlendFuncSrc = bf_src;
+			info->mHasGlow = has_glow;
+			info->mParticle = TRUE;
 			draw_vec.push_back(info);
 			//for alpha sorting
 			facep->setDrawInfo(info);