From a0c29e7dd67abb15c74c85f07741784877edfdcd Mon Sep 17 00:00:00 2001
From: Joe Ludwig <joe@valvesoftware.com>
Date: Mon, 2 Sep 2013 11:39:10 -0700
Subject: General: * Fixed a variety of server browser issues with mods based
 on this SDK * Fixed many warnings on various platforms * Added source code
 for fgdlib and raytrace * Updated many source files with the latest shared
 source from TF2.

OSX:
* Added support for Xcode 4.6
* Switched OSX builds to use Xcode instead of makefiles
* Moved libs from src/lib/osx32 to src/lib/public/osx32 or src/lib/common/osx32 to match windows better.

Linux:
* Moved libs from src/lib/linux32 to src/lib/public/linux32 or src/lib/common/linux32 to match windows better.
---
 mp/src/raytrace/raytrace.cpp | 901 +++++++++++++++++++++++++++++++++++++++++++
 mp/src/raytrace/raytrace.vpc |  26 ++
 mp/src/raytrace/trace2.cpp   | 376 ++++++++++++++++++
 mp/src/raytrace/trace3.cpp   | 127 ++++++
 4 files changed, 1430 insertions(+)
 create mode 100644 mp/src/raytrace/raytrace.cpp
 create mode 100644 mp/src/raytrace/raytrace.vpc
 create mode 100644 mp/src/raytrace/trace2.cpp
 create mode 100644 mp/src/raytrace/trace3.cpp

(limited to 'mp/src/raytrace')

diff --git a/mp/src/raytrace/raytrace.cpp b/mp/src/raytrace/raytrace.cpp
new file mode 100644
index 00000000..142220e2
--- /dev/null
+++ b/mp/src/raytrace/raytrace.cpp
@@ -0,0 +1,901 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+// $Id$
+
+#include "raytrace.h"
+#include <filesystem_tools.h>
+#include <cmdlib.h>
+#include <stdio.h>
+
+static bool SameSign(float a, float b)
+{
+	int32 aa=*((int *) &a);
+	int32 bb=*((int *) &b);
+	return ((aa^bb)&0x80000000)==0;
+}
+
+int FourRays::CalculateDirectionSignMask(void) const
+{
+	// this code treats the floats as integers since all it cares about is the sign bit and
+	// floating point compares suck.
+
+	int ret;
+	int ormask;
+	int andmask;
+	int32 const *treat_as_int=((int32 const *) (&direction));
+
+	ormask=andmask=*(treat_as_int++);
+	ormask|=*treat_as_int;
+	andmask&=*(treat_as_int++);
+	ormask|=*(treat_as_int);
+	andmask&=*(treat_as_int++);
+	ormask|=*(treat_as_int);
+	andmask&=*(treat_as_int++);
+	if (ormask>=0)
+		ret=0;
+	else
+	{
+		if (andmask<0)
+			ret=1;
+		else return -1;
+	}
+	ormask=andmask=*(treat_as_int++);
+	ormask|=*treat_as_int;
+	andmask&=*(treat_as_int++);
+	ormask|=*(treat_as_int);
+	andmask&=*(treat_as_int++);
+	ormask|=*(treat_as_int);
+	andmask&=*(treat_as_int++);
+	if (ormask<0)
+	{
+		if (andmask<0)
+			ret|=2;
+		else return -1;
+	}
+	ormask=andmask=*(treat_as_int++);
+	ormask|=*treat_as_int;
+	andmask&=*(treat_as_int++);
+	ormask|=*(treat_as_int);
+	andmask&=*(treat_as_int++);
+	ormask|=*(treat_as_int);
+	andmask&=*(treat_as_int++);
+	if (ormask<0)
+	{
+		if (andmask<0)
+			ret|=4;
+		else return -1;
+	}
+	return ret;
+}
+
+
+
+
+void RayTracingEnvironment::MakeRoomForTriangles( int ntris )
+{
+	//OptimizedTriangleList.EnsureCapacity( ntris );
+	if (! (Flags & RTE_FLAGS_DONT_STORE_TRIANGLE_COLORS))
+		TriangleColors.EnsureCapacity( ntris );
+}
+
+
+void RayTracingEnvironment::AddTriangle(int32 id, const Vector &v1,
+										const Vector &v2, const Vector &v3,
+										const Vector &color)
+{
+	AddTriangle( id, v1, v2, v3, color, 0, 0 );
+}
+
+void RayTracingEnvironment::AddTriangle(int32 id, const Vector &v1,
+										const Vector &v2, const Vector &v3,
+										const Vector &color, uint16 flags, int32 materialIndex)
+{
+	CacheOptimizedTriangle tmptri;
+	tmptri.m_Data.m_GeometryData.m_nTriangleID = id;
+	tmptri.Vertex( 0 ) = v1;
+	tmptri.Vertex( 1 ) = v2;
+	tmptri.Vertex( 2 ) = v3;
+	tmptri.m_Data.m_GeometryData.m_nFlags = flags;
+	OptimizedTriangleList.AddToTail(tmptri);
+	if (! ( Flags & RTE_FLAGS_DONT_STORE_TRIANGLE_COLORS) )
+		TriangleColors.AddToTail(color);
+	if ( !( Flags & RTE_FLAGS_DONT_STORE_TRIANGLE_MATERIALS) )
+		TriangleMaterials.AddToTail(materialIndex);
+// 	printf("add triange from (%f %f %f),(%f %f %f),(%f %f %f) id %d\n",
+// 		   XYZ(v1),XYZ(v2),XYZ(v3),id);
+}
+
+void RayTracingEnvironment::AddQuad(
+	int32 id, const Vector &v1, const Vector &v2, const Vector &v3,
+	const Vector &v4,							// specify vertices in cw or ccw order
+	const Vector &color)
+{
+	AddTriangle(id,v1,v2,v3,color);
+	AddTriangle(id+1,v1,v3,v4,color);
+}
+
+
+void RayTracingEnvironment::AddAxisAlignedRectangularSolid(int id,Vector minc, Vector maxc,
+														   const Vector &color)
+{
+
+	// "far" face
+	AddQuad(id,
+			Vector(minc.x,maxc.y,maxc.z),
+			Vector(maxc.x,maxc.y,maxc.z),Vector(maxc.x,minc.y,maxc.z),
+			Vector(minc.x,minc.y,maxc.z),color);
+	// "near" face
+	AddQuad(id,
+			Vector(minc.x,maxc.y,minc.z),
+			Vector(maxc.x,maxc.y,minc.z),Vector(maxc.x,minc.y,minc.z),
+			Vector(minc.x,minc.y,minc.z),color);
+
+	// "left" face
+	AddQuad(id,
+			Vector(minc.x,maxc.y,maxc.z),
+			Vector(minc.x,maxc.y,minc.z),
+			Vector(minc.x,minc.y,minc.z),
+			Vector(minc.x,minc.y,maxc.z),color);
+	// "right" face
+	AddQuad(id,
+			Vector(maxc.x,maxc.y,maxc.z),
+			Vector(maxc.x,maxc.y,minc.z),
+			Vector(maxc.x,minc.y,minc.z),
+			Vector(maxc.x,minc.y,maxc.z),color);
+	
+	// "top" face
+	AddQuad(id,
+			Vector(minc.x,maxc.y,maxc.z),
+			Vector(maxc.x,maxc.y,maxc.z),
+			Vector(maxc.x,maxc.y,minc.z),
+			Vector(minc.x,maxc.y,minc.z),color);
+	// "bot" face
+	AddQuad(id,
+			Vector(minc.x,minc.y,maxc.z),
+			Vector(maxc.x,minc.y,maxc.z),
+			Vector(maxc.x,minc.y,minc.z),
+			Vector(minc.x,minc.y,minc.z),color);
+}
+
+
+
+static Vector GetEdgeEquation(Vector p1, Vector p2, int c1, int c2, Vector InsidePoint)
+{
+	float nx=p1[c2]-p2[c2];
+	float ny=p2[c1]-p1[c1];
+	float d=-(nx*p1[c1]+ny*p1[c2]);
+// 	assert(fabs(nx*p1[c1]+ny*p1[c2]+d)<0.01);
+// 	assert(fabs(nx*p2[c1]+ny*p2[c2]+d)<0.01);
+
+	// use the convention that negative is "outside"
+	float trial_dist=InsidePoint[c1]*nx+InsidePoint[c2]*ny+d;
+	if (trial_dist<0)
+	{
+		nx = -nx;
+		ny = -ny;
+		d = -d;
+		trial_dist = -trial_dist;
+	}
+	nx /= trial_dist;										// scale so that it will be =1.0 at the oppositve vertex
+	ny /= trial_dist;
+	d /= trial_dist;
+
+	return Vector(nx,ny,d);
+}
+
+void CacheOptimizedTriangle::ChangeIntoIntersectionFormat(void)
+{
+	// lose the vertices and use edge equations instead
+
+	// grab the whole original triangle to we don't overwrite it
+	TriGeometryData_t srcTri = m_Data.m_GeometryData;
+
+	m_Data.m_IntersectData.m_nFlags = srcTri.m_nFlags;
+	m_Data.m_IntersectData.m_nTriangleID = srcTri.m_nTriangleID;
+
+	Vector p1 = srcTri.Vertex( 0 );
+	Vector p2 = srcTri.Vertex( 1 );
+	Vector p3 = srcTri.Vertex( 2 );
+
+	Vector e1 = p2 - p1;
+	Vector e2 = p3 - p1;
+
+	Vector N = e1.Cross( e2 );
+	N.NormalizeInPlace();
+	// now, determine which axis to drop
+	int drop_axis = 0;
+	for(int c=1 ; c<3 ; c++)
+		if ( fabs(N[c]) > fabs( N[drop_axis] ) )
+			drop_axis = c;
+
+	m_Data.m_IntersectData.m_flD = N.Dot( p1 );
+	m_Data.m_IntersectData.m_flNx = N.x;
+	m_Data.m_IntersectData.m_flNy = N.y;
+	m_Data.m_IntersectData.m_flNz = N.z;
+
+	// decide which axes to keep
+	int nCoordSelect0 = ( drop_axis + 1 ) % 3;
+	int nCoordSelect1 = ( drop_axis + 2 ) % 3;
+
+	m_Data.m_IntersectData.m_nCoordSelect0 = nCoordSelect0;
+	m_Data.m_IntersectData.m_nCoordSelect1 = nCoordSelect1;
+
+
+	Vector edge1 = GetEdgeEquation( p1, p2, nCoordSelect0, nCoordSelect1, p3 );
+	m_Data.m_IntersectData.m_ProjectedEdgeEquations[0] = edge1.x;
+	m_Data.m_IntersectData.m_ProjectedEdgeEquations[1] = edge1.y;
+	m_Data.m_IntersectData.m_ProjectedEdgeEquations[2] = edge1.z;
+
+	Vector edge2 = GetEdgeEquation( p2, p3, nCoordSelect0, nCoordSelect1, p1 );
+	m_Data.m_IntersectData.m_ProjectedEdgeEquations[3] = edge2.x;
+	m_Data.m_IntersectData.m_ProjectedEdgeEquations[4] = edge2.y;
+	m_Data.m_IntersectData.m_ProjectedEdgeEquations[5] = edge2.z;
+
+
+}
+
+int n_intersection_calculations=0;
+
+int CacheOptimizedTriangle::ClassifyAgainstAxisSplit(int split_plane, float split_value)
+{
+	// classify a triangle against an axis-aligned plane
+	float minc=Vertex(0)[split_plane];
+	float maxc=minc;
+	for(int v=1;v<3;v++)
+	{
+		minc=min(minc,Vertex(v)[split_plane]);
+		maxc=max(maxc,Vertex(v)[split_plane]);
+	}
+
+	if (minc>=split_value)
+		return PLANECHECK_POSITIVE;
+	if (maxc<=split_value)
+		return PLANECHECK_NEGATIVE;
+	if (minc==maxc)
+		return PLANECHECK_POSITIVE;
+	return PLANECHECK_STRADDLING;
+}
+
+#define MAILBOX_HASH_SIZE 256
+#define MAX_TREE_DEPTH 21
+#define MAX_NODE_STACK_LEN (40*MAX_TREE_DEPTH)
+
+struct NodeToVisit {
+	CacheOptimizedKDNode const *node;
+	fltx4 TMin;
+	fltx4 TMax;
+};
+
+
+static fltx4 FourEpsilons={1.0e-10,1.0e-10,1.0e-10,1.0e-10};
+static fltx4 FourZeros={1.0e-10,1.0e-10,1.0e-10,1.0e-10};
+static fltx4 FourNegativeEpsilons={-1.0e-10,-1.0e-10,-1.0e-10,-1.0e-10};
+
+static float BoxSurfaceArea(Vector const &boxmin, Vector const &boxmax)
+{
+	Vector boxdim=boxmax-boxmin;
+	return 2.0*((boxdim[0]*boxdim[2])+(boxdim[0]*boxdim[1])+(boxdim[1]*boxdim[2]));
+}
+
+void RayTracingEnvironment::Trace4Rays(const FourRays &rays, fltx4 TMin, fltx4 TMax,
+									   RayTracingResult *rslt_out,
+									   int32 skip_id, ITransparentTriangleCallback *pCallback)
+{
+	int msk=rays.CalculateDirectionSignMask();
+	if (msk!=-1)
+		Trace4Rays(rays,TMin,TMax,msk,rslt_out,skip_id, pCallback);
+	else
+	{
+		// sucky case - can't trace 4 rays at once. in the worst case, need to trace all 4
+		// separately, but usually we will still get 2x, Since our tracer only does 4 at a
+		// time, we will have to cover up the undesired rays with the desired ray
+
+		//!! speed!! there is room for some sse-ization here
+		FourRays tmprays;
+		tmprays.origin=rays.origin;
+
+		uint8 need_trace[4]={1,1,1,1};
+		for(int try_trace=0;try_trace<4;try_trace++)
+		{
+			if (need_trace[try_trace])
+			{
+				need_trace[try_trace]=2;			// going to trace it
+				// replicate the ray being traced into all 4 rays
+				tmprays.direction.x=ReplicateX4(rays.direction.X(try_trace));
+				tmprays.direction.y=ReplicateX4(rays.direction.Y(try_trace));
+				tmprays.direction.z=ReplicateX4(rays.direction.Z(try_trace));
+				// now, see if any of the other remaining rays can be handled at the same time.
+				for(int try2=try_trace+1;try2<4;try2++)
+					if (need_trace[try2])
+					{
+						if (
+							SameSign(rays.direction.X(try2),
+									 rays.direction.X(try_trace)) &&
+							SameSign(rays.direction.Y(try2),
+									 rays.direction.Y(try_trace)) &&
+							SameSign(rays.direction.Z(try2),
+									 rays.direction.Z(try_trace)))
+						{
+							need_trace[try2]=2;
+							tmprays.direction.X(try2) = rays.direction.X(try2);
+							tmprays.direction.Y(try2) = rays.direction.Y(try2);
+							tmprays.direction.Z(try2) = rays.direction.Z(try2);
+						}
+					}
+				// ok, now trace between 1 and 3 rays, and output the results
+				RayTracingResult tmpresults;
+				msk=tmprays.CalculateDirectionSignMask();
+				assert(msk!=-1);
+				Trace4Rays(tmprays,TMin,TMax,msk,&tmpresults,skip_id, pCallback);
+				// now, move results to proper place
+				for(int i=0;i<4;i++)
+					if (need_trace[i]==2)
+					{
+						need_trace[i]=0;
+						rslt_out->HitIds[i]=tmpresults.HitIds[i];
+						SubFloat(rslt_out->HitDistance, i) = SubFloat(tmpresults.HitDistance, i);
+						rslt_out->surface_normal.X(i) = tmpresults.surface_normal.X(i);
+						rslt_out->surface_normal.Y(i) = tmpresults.surface_normal.Y(i);
+						rslt_out->surface_normal.Z(i) = tmpresults.surface_normal.Z(i);
+					}
+				
+			}
+		}
+	}
+}
+
+
+void RayTracingEnvironment::Trace4Rays(const FourRays &rays, fltx4 TMin, fltx4 TMax,
+									   int DirectionSignMask, RayTracingResult *rslt_out,
+									   int32 skip_id, ITransparentTriangleCallback *pCallback)
+{
+	rays.Check();
+
+	memset(rslt_out->HitIds,0xff,sizeof(rslt_out->HitIds));
+
+	rslt_out->HitDistance=ReplicateX4(1.0e23);
+
+	rslt_out->surface_normal.DuplicateVector(Vector(0.,0.,0.));
+	FourVectors OneOverRayDir=rays.direction;
+	OneOverRayDir.MakeReciprocalSaturate();
+	
+	// now, clip rays against bounding box
+	for(int c=0;c<3;c++)
+	{
+		fltx4 isect_min_t=
+			MulSIMD(SubSIMD(ReplicateX4(m_MinBound[c]),rays.origin[c]),OneOverRayDir[c]);
+		fltx4 isect_max_t=
+			MulSIMD(SubSIMD(ReplicateX4(m_MaxBound[c]),rays.origin[c]),OneOverRayDir[c]);
+		TMin=MaxSIMD(TMin,MinSIMD(isect_min_t,isect_max_t));
+		TMax=MinSIMD(TMax,MaxSIMD(isect_min_t,isect_max_t));
+	}
+	fltx4 active=CmpLeSIMD(TMin,TMax);					// mask of which rays are active
+	if (! IsAnyNegative(active) )
+		return;												// missed bounding box
+
+	int32 mailboxids[MAILBOX_HASH_SIZE];					// used to avoid redundant triangle tests
+	memset(mailboxids,0xff,sizeof(mailboxids));				// !!speed!! keep around?
+
+	int front_idx[3],back_idx[3];							// based on ray direction, whether to
+															// visit left or right node first
+
+	if (DirectionSignMask & 1)
+	{
+		back_idx[0]=0;
+		front_idx[0]=1;
+	}
+		else
+	{
+		back_idx[0]=1;
+		front_idx[0]=0;
+	}
+	if (DirectionSignMask & 2)
+	{
+		back_idx[1]=0;
+		front_idx[1]=1;
+	}
+	else
+	{
+		back_idx[1]=1;
+		front_idx[1]=0;
+	}
+	if (DirectionSignMask & 4)
+	{
+		back_idx[2]=0;
+		front_idx[2]=1;
+	}
+	else
+	{
+		back_idx[2]=1;
+		front_idx[2]=0;
+	}
+		
+	NodeToVisit NodeQueue[MAX_NODE_STACK_LEN];
+	CacheOptimizedKDNode const *CurNode=&(OptimizedKDTree[0]);
+	NodeToVisit *stack_ptr=&NodeQueue[MAX_NODE_STACK_LEN];
+	while(1)
+	{
+		while (CurNode->NodeType() != KDNODE_STATE_LEAF)		// traverse until next leaf
+		{	   
+			int split_plane_number=CurNode->NodeType();
+			CacheOptimizedKDNode const *FrontChild=&(OptimizedKDTree[CurNode->LeftChild()]);
+			
+			fltx4 dist_to_sep_plane=						// dist=(split-org)/dir
+				MulSIMD(
+					SubSIMD(ReplicateX4(CurNode->SplittingPlaneValue),
+							   rays.origin[split_plane_number]),OneOverRayDir[split_plane_number]);
+			fltx4 active=CmpLeSIMD(TMin,TMax);			// mask of which rays are active
+
+			// now, decide how to traverse children. can either do front,back, or do front and push
+			// back.
+			fltx4 hits_front=AndSIMD(active,CmpGeSIMD(dist_to_sep_plane,TMin));
+			if (! IsAnyNegative(hits_front))
+			{
+				// missed the front. only traverse back
+				//printf("only visit back %d\n",CurNode->LeftChild()+back_idx[split_plane_number]);
+				CurNode=FrontChild+back_idx[split_plane_number];
+				TMin=MaxSIMD(TMin, dist_to_sep_plane);
+
+			}
+			else
+			{
+				fltx4 hits_back=AndSIMD(active,CmpLeSIMD(dist_to_sep_plane,TMax));
+				if (! IsAnyNegative(hits_back) )
+				{
+					// missed the back - only need to traverse front node
+					//printf("only visit front %d\n",CurNode->LeftChild()+front_idx[split_plane_number]);
+					CurNode=FrontChild+front_idx[split_plane_number];
+					TMax=MinSIMD(TMax, dist_to_sep_plane);
+				}
+				else
+				{
+					// at least some rays hit both nodes.
+					// must push far, traverse near
+ 					//printf("visit %d,%d\n",CurNode->LeftChild()+front_idx[split_plane_number],
+ 					//	   CurNode->LeftChild()+back_idx[split_plane_number]);
+					assert(stack_ptr>NodeQueue);
+					--stack_ptr;
+					stack_ptr->node=FrontChild+back_idx[split_plane_number];
+					stack_ptr->TMin=MaxSIMD(TMin,dist_to_sep_plane);
+					stack_ptr->TMax=TMax;
+					CurNode=FrontChild+front_idx[split_plane_number];
+					TMax=MinSIMD(TMax,dist_to_sep_plane);
+				}
+			}
+		}
+		// hit a leaf! must do intersection check
+		int ntris=CurNode->NumberOfTrianglesInLeaf();
+		if (ntris)
+		{
+			int32 const *tlist=&(TriangleIndexList[CurNode->TriangleIndexStart()]);
+			do
+			{
+				int tnum=*(tlist++);
+				//printf("try tri %d\n",tnum);
+				// check mailbox
+				int mbox_slot=tnum & (MAILBOX_HASH_SIZE-1);
+				TriIntersectData_t const *tri = &( OptimizedTriangleList[tnum].m_Data.m_IntersectData );
+				if ( ( mailboxids[mbox_slot] != tnum ) && ( tri->m_nTriangleID != skip_id ) )
+				{
+					n_intersection_calculations++;
+					mailboxids[mbox_slot] = tnum;
+					// compute plane intersection
+
+
+					FourVectors N;
+					N.x = ReplicateX4( tri->m_flNx );
+					N.y = ReplicateX4( tri->m_flNy );
+					N.z = ReplicateX4( tri->m_flNz );
+
+					fltx4 DDotN = rays.direction * N;
+					// mask off zero or near zero (ray parallel to surface)
+					fltx4 did_hit = OrSIMD( CmpGtSIMD( DDotN,FourEpsilons ),
+											CmpLtSIMD( DDotN, FourNegativeEpsilons ) );
+
+					fltx4 numerator=SubSIMD( ReplicateX4( tri->m_flD ), rays.origin * N );
+
+					fltx4 isect_t=DivSIMD( numerator,DDotN );
+					// now, we have the distance to the plane. lets update our mask
+					did_hit = AndSIMD( did_hit, CmpGtSIMD( isect_t, FourZeros ) );
+					//did_hit=AndSIMD(did_hit,CmpLtSIMD(isect_t,TMax));
+					did_hit = AndSIMD( did_hit, CmpLtSIMD( isect_t, rslt_out->HitDistance ) );
+
+					if ( ! IsAnyNegative( did_hit ) )
+						continue;
+
+					// now, check 3 edges
+					fltx4 hitc1 = AddSIMD( rays.origin[tri->m_nCoordSelect0],
+										MulSIMD( isect_t, rays.direction[ tri->m_nCoordSelect0] ) );
+					fltx4 hitc2 = AddSIMD( rays.origin[tri->m_nCoordSelect1],
+										   MulSIMD( isect_t, rays.direction[tri->m_nCoordSelect1] ) );
+					
+					// do barycentric coordinate check
+					fltx4 B0 = MulSIMD( ReplicateX4( tri->m_ProjectedEdgeEquations[0] ), hitc1 );
+
+					B0 = AddSIMD(
+						B0,
+						MulSIMD( ReplicateX4( tri->m_ProjectedEdgeEquations[1] ), hitc2 ) );
+					B0 = AddSIMD(
+						B0, ReplicateX4( tri->m_ProjectedEdgeEquations[2] ) );
+
+					did_hit = AndSIMD( did_hit, CmpGeSIMD( B0, FourZeros ) );
+
+					fltx4 B1 = MulSIMD( ReplicateX4( tri->m_ProjectedEdgeEquations[3] ), hitc1 );
+					B1 = AddSIMD(
+						B1,
+						MulSIMD( ReplicateX4( tri->m_ProjectedEdgeEquations[4]), hitc2 ) );
+
+					B1 = AddSIMD(
+						B1, ReplicateX4( tri->m_ProjectedEdgeEquations[5] ) );
+					
+					did_hit = AndSIMD( did_hit, CmpGeSIMD( B1, FourZeros ) );
+
+					fltx4 B2 = AddSIMD( B1, B0 );
+					did_hit = AndSIMD( did_hit, CmpLeSIMD( B2, Four_Ones ) );
+
+					if ( ! IsAnyNegative( did_hit ) )
+						continue;
+
+					// if the triangle is transparent
+					if ( tri->m_nFlags & FCACHETRI_TRANSPARENT )
+					{
+						if ( pCallback )
+						{
+							// assuming a triangle indexed as v0, v1, v2
+							// the projected edge equations are set up such that the vert opposite the first
+							// equation is v2, and the vert opposite the second equation is v0
+							// Therefore we pass them back in 1, 2, 0 order
+							// Also B2 is currently B1 + B0 and needs to be 1 - (B1+B0) in order to be a real
+							// barycentric coordinate.  Compute that now and pass it to the callback
+							fltx4 b2 = SubSIMD( Four_Ones, B2 );
+							if ( pCallback->VisitTriangle_ShouldContinue( *tri, rays, &did_hit, &B1, &b2, &B0, tnum ) )
+							{
+								did_hit = Four_Zeros;
+							}
+						}
+					}
+					// now, set the hit_id and closest_hit fields for any enabled rays
+					fltx4 replicated_n = ReplicateIX4(tnum);
+					StoreAlignedSIMD((float *) rslt_out->HitIds,
+								 OrSIMD(AndSIMD(replicated_n,did_hit),
+										   AndNotSIMD(did_hit,LoadAlignedSIMD(
+															 (float *) rslt_out->HitIds))));
+					rslt_out->HitDistance=OrSIMD(AndSIMD(isect_t,did_hit),
+									 AndNotSIMD(did_hit,rslt_out->HitDistance));
+
+					rslt_out->surface_normal.x=OrSIMD(
+						AndSIMD(N.x,did_hit),
+						AndNotSIMD(did_hit,rslt_out->surface_normal.x));
+					rslt_out->surface_normal.y=OrSIMD(
+						AndSIMD(N.y,did_hit),
+						AndNotSIMD(did_hit,rslt_out->surface_normal.y));
+					rslt_out->surface_normal.z=OrSIMD(
+						AndSIMD(N.z,did_hit),
+						AndNotSIMD(did_hit,rslt_out->surface_normal.z));
+					
+				}
+			} while (--ntris);
+			// now, check if all rays have terminated
+			fltx4 raydone=CmpLeSIMD(TMax,rslt_out->HitDistance);
+			if (! IsAnyNegative(raydone))
+			{
+				return;
+			}
+		}
+		
+ 		if (stack_ptr==&NodeQueue[MAX_NODE_STACK_LEN])
+		{
+			return;
+		}
+		// pop stack!
+		CurNode=stack_ptr->node;
+		TMin=stack_ptr->TMin;
+		TMax=stack_ptr->TMax;
+		stack_ptr++;
+	}
+}
+
+
+int RayTracingEnvironment::MakeLeafNode(int first_tri, int last_tri)
+{
+	CacheOptimizedKDNode ret;
+	ret.Children=KDNODE_STATE_LEAF+(TriangleIndexList.Count()<<2);
+	ret.SetNumberOfTrianglesInLeafNode(1+(last_tri-first_tri));
+	for(int tnum=first_tri;tnum<=last_tri;tnum++)
+		TriangleIndexList.AddToTail(tnum);
+	OptimizedKDTree.AddToTail(ret);
+	return OptimizedKDTree.Count()-1;
+}
+
+
+void RayTracingEnvironment::CalculateTriangleListBounds(int32 const *tris,int ntris,
+														Vector &minout, Vector &maxout)
+{
+	minout = Vector( 1.0e23, 1.0e23, 1.0e23);
+	maxout = Vector( -1.0e23, -1.0e23, -1.0e23);
+	for(int i=0; i<ntris; i++)
+	{
+		CacheOptimizedTriangle const &tri=OptimizedTriangleList[tris[i]];
+		for(int v=0; v<3; v++)
+			for(int c=0; c<3; c++)
+			{
+				minout[c]=min(minout[c],tri.Vertex(v)[c]);
+							  maxout[c]=max(maxout[c],tri.Vertex(v)[c]);
+			}
+	}
+}
+
+
+// Both the "quick" and regular kd tree building algorithms here use the "surface area heuristic":
+// the relative probability of hitting the "left" subvolume (Vl) from a split is equal to that
+// subvolume's surface area divided by its parent's surface area (Vp) : P(Vl | V)=SA(Vl)/SA(Vp).
+// The same holds for the right subvolume, Vp. Nl is the number of triangles in the left volume,
+// and Nr in the right volume. if Ct is the cost of traversing one tree node, and Ci is the cost of
+// intersection with the primitive, than the cost of splitting is estimated as:
+//
+//    Ct+Ci*((SA(Vl)/SA(V))*Nl+(SA(Vr)/SA(V)*Nr)).
+// and the cost of not splitting is
+//    Ci*N
+//
+//  This both provides a metric to minimize when computing how and where to split, and also a
+//  termination criterion.
+//
+// the "quick" method just splits down the middle, while the slow method splits at the best
+// discontinuity of the cost formula. The quick method splits along the longest axis ; the 
+// regular algorithm tries all 3 to find which one results in the minimum cost
+// 
+// both methods use the additional optimization of "growing" empty nodes - if the split results in
+// one side being devoid of triangles, the empty side is "grown" as much as possible.
+//
+
+#define COST_OF_TRAVERSAL 75								// approximate #operations
+#define COST_OF_INTERSECTION 167							// approximate #operations
+
+
+float RayTracingEnvironment::CalculateCostsOfSplit(
+	int split_plane,int32 const *tri_list,int ntris,
+	Vector MinBound,Vector MaxBound, float &split_value,
+	int &nleft, int &nright, int &nboth)
+{
+	// determine the costs of splitting on a given axis, and label triangles with respect to
+	// that axis by storing the value in coordselect0. It will also return the number of
+	// tris in the left, right, and nboth groups, in order to facilitate memory
+	nleft=nboth=nright=0;
+	
+	// now, label each triangle. Since we have not converted the triangles into
+	// intersection fromat yet, we can use the CoordSelect0 field of each as a temp.
+	nleft=0;
+	nright=0;
+	nboth=0;
+	float min_coord=1.0e23,max_coord=-1.0e23;
+
+	for(int t=0;t<ntris;t++)
+	{
+		CacheOptimizedTriangle &tri=OptimizedTriangleList[tri_list[t]];
+		// determine max and min coordinate values for later optimization
+		for(int v=0;v<3;v++)
+		{
+			min_coord = min( min_coord, tri.Vertex(v)[split_plane] );
+			max_coord = max( max_coord, tri.Vertex(v)[split_plane] );
+		}
+		switch(tri.ClassifyAgainstAxisSplit(split_plane,split_value))
+		{
+			case PLANECHECK_NEGATIVE:
+				nleft++;
+				tri.m_Data.m_GeometryData.m_nTmpData0 = PLANECHECK_NEGATIVE;
+				break;
+
+			case PLANECHECK_POSITIVE:
+				nright++;
+				tri.m_Data.m_GeometryData.m_nTmpData0 = PLANECHECK_POSITIVE;
+				break;
+
+			case PLANECHECK_STRADDLING:
+				nboth++;
+				tri.m_Data.m_GeometryData.m_nTmpData0 = PLANECHECK_STRADDLING;
+				break;
+		}
+	}
+	// now, if the split resulted in one half being empty, "grow" the empty half
+	if (nleft && (nboth==0) && (nright==0))
+		split_value=max_coord;
+	if (nright && (nboth==0) && (nleft==0))
+		split_value=min_coord;
+
+	// now, perform surface area/cost check to determine whether this split was worth it
+	Vector LeftMins=MinBound;
+	Vector LeftMaxes=MaxBound;
+	Vector RightMins=MinBound;
+	Vector RightMaxes=MaxBound;
+	LeftMaxes[split_plane]=split_value;
+	RightMins[split_plane]=split_value;
+	float SA_L=BoxSurfaceArea(LeftMins,LeftMaxes);
+	float SA_R=BoxSurfaceArea(RightMins,RightMaxes);
+	float ISA=1.0/BoxSurfaceArea(MinBound,MaxBound);
+	float cost_of_split=COST_OF_TRAVERSAL+COST_OF_INTERSECTION*(nboth+
+		(SA_L*ISA*(nleft))+(SA_R*ISA*(nright)));
+	return cost_of_split;
+}
+
+
+#define NEVER_SPLIT 0
+
+void RayTracingEnvironment::RefineNode(int node_number,int32 const *tri_list,int ntris,
+									   Vector MinBound,Vector MaxBound, int depth)
+{
+	if (ntris<3)											// never split empty lists
+	{
+		// no point in continuing
+		OptimizedKDTree[node_number].Children=KDNODE_STATE_LEAF+(TriangleIndexList.Count()<<2);
+		OptimizedKDTree[node_number].SetNumberOfTrianglesInLeafNode(ntris);
+
+#ifdef DEBUG_RAYTRACE
+		OptimizedKDTree[node_number].vecMins = MinBound;
+		OptimizedKDTree[node_number].vecMaxs = MaxBound;
+#endif
+
+		for(int t=0;t<ntris;t++)
+			TriangleIndexList.AddToTail(tri_list[t]);
+		return;
+	}
+
+	float best_cost=1.0e23;
+	int best_nleft=0,best_nright=0,best_nboth=0;
+	float best_splitvalue=0;
+	int split_plane=0;
+
+	int tri_skip=1+(ntris/10);								// don't try all trinagles as split
+															// points when there are a lot of them
+	for(int axis=0;axis<3;axis++)
+	{
+		for(int ts=-1;ts<ntris;ts+=tri_skip)
+		{
+			for(int tv=0;tv<3;tv++)
+			{
+				int trial_nleft,trial_nright,trial_nboth;
+				float trial_splitvalue;
+				if (ts==-1)
+					trial_splitvalue=0.5*(MinBound[axis]+MaxBound[axis]);
+				else
+				{
+					// else, split at the triangle vertex if possible
+					CacheOptimizedTriangle &tri=OptimizedTriangleList[tri_list[ts]];
+					trial_splitvalue = tri.Vertex(tv)[axis];
+					if ((trial_splitvalue>MaxBound[axis]) || (trial_splitvalue<MinBound[axis]))
+						continue;							// don't try this vertex - not inside
+					
+				}
+//				printf("ts=%d tv=%d tp=%f\n",ts,tv,trial_splitvalue);
+				float trial_cost=
+					CalculateCostsOfSplit(axis,tri_list,ntris,MinBound,MaxBound,trial_splitvalue,
+										  trial_nleft,trial_nright, trial_nboth);
+// 				printf("try %d cost=%f nl=%d nr=%d nb=%d sp=%f\n",axis,trial_cost,trial_nleft,trial_nright, trial_nboth,
+// 					   trial_splitvalue);
+				if (trial_cost<best_cost)
+				{
+					split_plane=axis;
+					best_cost=trial_cost;
+					best_nleft=trial_nleft;
+					best_nright=trial_nright;
+					best_nboth=trial_nboth;
+					best_splitvalue=trial_splitvalue;
+					// save away the axis classification of each triangle
+					for(int t=0 ; t < ntris; t++)
+					{
+						CacheOptimizedTriangle &tri=OptimizedTriangleList[tri_list[t]];
+						tri.m_Data.m_GeometryData.m_nTmpData1 = tri.m_Data.m_GeometryData.m_nTmpData0;
+					}
+				}
+				if (ts==-1)
+					break;
+			}
+		}
+
+	}
+	float cost_of_no_split=COST_OF_INTERSECTION*ntris;
+	if ( (cost_of_no_split<=best_cost) || NEVER_SPLIT || (depth>MAX_TREE_DEPTH))
+	{
+		// no benefit to splitting. just make this a leaf node
+		OptimizedKDTree[node_number].Children=KDNODE_STATE_LEAF+(TriangleIndexList.Count()<<2);
+		OptimizedKDTree[node_number].SetNumberOfTrianglesInLeafNode(ntris);
+#ifdef DEBUG_RAYTRACE
+		OptimizedKDTree[node_number].vecMins = MinBound;
+		OptimizedKDTree[node_number].vecMaxs = MaxBound;
+#endif
+		for(int t=0;t<ntris;t++)
+			TriangleIndexList.AddToTail(tri_list[t]);
+	}
+	else
+	{
+// 		printf("best split was %d at %f (mid=%f,n=%d, sk=%d)\n",split_plane,best_splitvalue,
+// 			   0.5*(MinBound[split_plane]+MaxBound[split_plane]),ntris,tri_skip);
+		// its worth splitting!
+		// we will achieve the splitting without sorting by using a selection algorithm.
+		int32 *new_triangle_list;
+		new_triangle_list=new int32[ntris];
+
+		// now, perform surface area/cost check to determine whether this split was worth it
+		Vector LeftMins=MinBound;
+		Vector LeftMaxes=MaxBound;
+		Vector RightMins=MinBound;
+		Vector RightMaxes=MaxBound;
+		LeftMaxes[split_plane]=best_splitvalue;
+		RightMins[split_plane]=best_splitvalue;
+		
+		int n_left_output=0;
+		int n_both_output=0;
+		int n_right_output=0;
+		for(int t=0;t<ntris;t++)
+		{
+			CacheOptimizedTriangle &tri=OptimizedTriangleList[tri_list[t]];
+			switch( tri.m_Data.m_GeometryData.m_nTmpData1 )
+			{
+				case PLANECHECK_NEGATIVE:
+//					printf("%d goes left\n",t);
+					new_triangle_list[n_left_output++]=tri_list[t];
+					break;
+				case PLANECHECK_POSITIVE:
+					n_right_output++;
+//					printf("%d goes right\n",t);
+					new_triangle_list[ntris-n_right_output]=tri_list[t];
+					break;
+				case PLANECHECK_STRADDLING:
+//					printf("%d goes both\n",t);
+					new_triangle_list[best_nleft+n_both_output]=tri_list[t];
+					n_both_output++;
+					break;
+
+					
+			}
+		}
+		int left_child=OptimizedKDTree.Count();
+		int right_child=left_child+1;
+// 		printf("node %d split on axis %d at %f, nl=%d nr=%d nb=%d lc=%d rc=%d\n",node_number,
+// 			   split_plane,best_splitvalue,best_nleft,best_nright,best_nboth,
+// 			   left_child,right_child);
+		OptimizedKDTree[node_number].Children=split_plane+(left_child<<2);
+		OptimizedKDTree[node_number].SplittingPlaneValue=best_splitvalue;
+#ifdef DEBUG_RAYTRACE
+		OptimizedKDTree[node_number].vecMins = MinBound;
+		OptimizedKDTree[node_number].vecMaxs = MaxBound;
+#endif
+		CacheOptimizedKDNode newnode;
+		OptimizedKDTree.AddToTail(newnode);
+		OptimizedKDTree.AddToTail(newnode);
+		// now, recurse!
+		if ( (ntris<20) && ((best_nleft==0) || (best_nright==0)) )
+			depth+=100;
+		RefineNode(left_child,new_triangle_list,best_nleft+best_nboth,LeftMins,LeftMaxes,depth+1);
+		RefineNode(right_child,new_triangle_list+best_nleft,best_nright+best_nboth,
+				   RightMins,RightMaxes,depth+1);
+		delete[] new_triangle_list;
+	}	
+}
+
+
+void RayTracingEnvironment::SetupAccelerationStructure(void)
+{
+	CacheOptimizedKDNode root;
+	OptimizedKDTree.AddToTail(root);
+	int32 *root_triangle_list=new int32[OptimizedTriangleList.Count()];
+	for(int t=0;t<OptimizedTriangleList.Count();t++)
+		root_triangle_list[t]=t;
+	CalculateTriangleListBounds(root_triangle_list,OptimizedTriangleList.Count(),m_MinBound,
+								m_MaxBound);
+	RefineNode(0,root_triangle_list,OptimizedTriangleList.Count(),m_MinBound,m_MaxBound,0);
+	delete[] root_triangle_list;
+
+	// now, convert all triangles to "intersection format"
+	for(int i=0;i<OptimizedTriangleList.Count();i++)
+		OptimizedTriangleList[i].ChangeIntoIntersectionFormat();
+}
+
+
+
+void RayTracingEnvironment::AddInfinitePointLight(Vector position, Vector intensity)
+{
+	LightDesc_t mylight(position,intensity);
+	LightList.AddToTail(mylight);
+	
+}
+
+
diff --git a/mp/src/raytrace/raytrace.vpc b/mp/src/raytrace/raytrace.vpc
new file mode 100644
index 00000000..d8504ec4
--- /dev/null
+++ b/mp/src/raytrace/raytrace.vpc
@@ -0,0 +1,26 @@
+//-----------------------------------------------------------------------------
+//	RAYTRACE.VPC
+//
+//	Project Script
+//-----------------------------------------------------------------------------
+
+$Macro SRCDIR		".."
+$Include "$SRCDIR\vpc_scripts\source_lib_base.vpc"
+
+$Configuration
+{
+	$Compiler
+	{
+		$AdditionalIncludeDirectories		"$BASE,$SRCDIR\utils\common"
+	}
+}
+
+$Project "Raytrace"
+{
+	$Folder	"Source Files"
+	{
+		$File	"raytrace.cpp"
+		$File	"trace2.cpp"
+		$File	"trace3.cpp"
+	}
+}
diff --git a/mp/src/raytrace/trace2.cpp b/mp/src/raytrace/trace2.cpp
new file mode 100644
index 00000000..f7f4ed7e
--- /dev/null
+++ b/mp/src/raytrace/trace2.cpp
@@ -0,0 +1,376 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+// $Id$
+#include "raytrace.h"
+#include <mathlib/halton.h>
+
+static uint32 MapDistanceToPixel(float t)
+{
+	if (t<0) return 0xffff0000;
+	if (t>100) return 0xff000000;
+	int a=t*1000; a&=0xff;
+	int b=t*10; b &=0xff;
+	int c=t*.01; c &=0xff;
+	return 0xff000000+(a<<16)+(b<<8)+c;
+}
+
+#define IGAMMA (1.0/2.2)
+
+#define MAGIC_NUMBER (1<<23)
+
+static fltx4 Four_MagicNumbers={ MAGIC_NUMBER, MAGIC_NUMBER, MAGIC_NUMBER, MAGIC_NUMBER };
+static ALIGN16 int32 Four_255s[4]= {0xff,0xff,0xff,0xff};
+#define PIXMASK ( * ( reinterpret_cast< fltx4 *>( &Four_255s ) ) )
+
+void MapLinearIntensities(FourVectors const &intens,uint32 *p1, uint32 *p2, uint32 *p3, uint32 *p4)
+{
+	// convert four pixels worth of sse-style rgb into argb lwords
+	// NOTE the _mm_empty macro is voodoo. do not mess with this routine casually - simply throwing
+	// anything that ends up generating a fpu stack references in here would be bad news.
+	static fltx4 pixscale={255.0,255.0,255.0,255.0};
+	fltx4 r,g,b;
+	r=MinSIMD(pixscale,MulSIMD(pixscale,PowSIMD(intens.x,IGAMMA)));
+	g=MinSIMD(pixscale,MulSIMD(pixscale,PowSIMD(intens.y,IGAMMA)));
+	b=MinSIMD(pixscale,MulSIMD(pixscale,PowSIMD(intens.z,IGAMMA)));
+	// now, convert to integer
+	r=AndSIMD( AddSIMD( r, Four_MagicNumbers ), PIXMASK );
+	g=AndSIMD( AddSIMD( g, Four_MagicNumbers ), PIXMASK );
+	b=AndSIMD( AddSIMD( b, Four_MagicNumbers ), PIXMASK );
+
+	*(p1)=(SubInt(r, 0))|(SubInt(g, 0)<<8)|(SubInt(b, 0)<<16);
+	*(p2)=(SubInt(r, 1))|(SubInt(g, 1)<<8)|(SubInt(b, 1)<<16);
+	*(p3)=(SubInt(r, 2))|(SubInt(g, 2)<<8)|(SubInt(b, 2)<<16);
+	*(p4)=(SubInt(r, 3))|(SubInt(g, 3)<<8)|(SubInt(b, 3)<<16);
+}
+
+static ALIGN16 int32 signmask[4]={0x80000000,0x80000000,0x80000000,0x80000000};
+static ALIGN16 int32 all_ones[4]={-1,-1,-1,-1};
+static fltx4 all_zeros={0,0,0,0};
+static fltx4 TraceLimit={1.0e20,1.0e20,1.0e20,1.0e20};
+
+void RayTracingEnvironment::RenderScene(
+	int width, int height,								   // width and height of desired rendering
+	int stride,											 // actual width in pixels of target buffer
+	uint32 *output_buffer,									// pointer to destination 
+	Vector CameraOrigin,									// eye position
+	Vector ULCorner,										// word space coordinates of upper left
+															// monitor corner
+	Vector URCorner,										// top right corner
+	Vector LLCorner,										// lower left
+	Vector LRCorner,										// lower right
+	RayTraceLightingMode_t lmode)
+{
+	// first, compute deltas
+	Vector dxvector=URCorner;
+	dxvector-=ULCorner;
+	dxvector*=(1.0/width);
+	Vector dxvectortimes2=dxvector;
+	dxvectortimes2+=dxvector;
+
+	Vector dyvector=LLCorner;
+	dyvector-=ULCorner;
+	dyvector*=(1.0/height);
+
+
+	// block_offsets-relative offsets for eahc of the 4 pixels in the block, in sse format
+	FourVectors block_offsets;
+	block_offsets.LoadAndSwizzle(Vector(0,0,0),dxvector,dyvector,dxvector+dyvector);
+	
+	FourRays myrays;
+	myrays.origin.DuplicateVector(CameraOrigin);
+	
+	// tmprays is used fo rthe case when we cannot trace 4 rays at once.
+	FourRays tmprays;
+	tmprays.origin.DuplicateVector(CameraOrigin);
+
+	// now, we will ray trace pixels. we will do the rays in a 2x2 pattern
+	for(int y=0;y<height;y+=2)
+	{
+		Vector SLoc=dyvector;
+		SLoc*=((float) y);
+		SLoc+=ULCorner;
+		uint32 *dest=output_buffer+y*stride;
+		for(int x=0;x<width;x+=2)
+		{
+			myrays.direction.DuplicateVector(SLoc);
+			myrays.direction+=block_offsets;
+			myrays.direction.VectorNormalize();
+			
+			RayTracingResult rslt;
+			Trace4Rays(myrays,all_zeros,TraceLimit, &rslt);
+			if ((rslt.HitIds[0]==-1) && (rslt.HitIds[1]==-1) && 
+				(rslt.HitIds[2]==-1) && (rslt.HitIds[3]==-1))
+				MapLinearIntensities(BackgroundColor,dest,dest+1,dest+stride,dest+stride+1);
+			else
+			{
+				// make sure normal points back towards ray origin
+				fltx4 ndoti=rslt.surface_normal*myrays.direction;
+				fltx4 bad_dirs=AndSIMD(CmpGtSIMD(ndoti,Four_Zeros),
+										   LoadAlignedSIMD((float *) signmask));
+
+				// flip signs of all "wrong" normals
+				rslt.surface_normal.x=XorSIMD(bad_dirs,rslt.surface_normal.x);
+				rslt.surface_normal.y=XorSIMD(bad_dirs,rslt.surface_normal.y);
+				rslt.surface_normal.z=XorSIMD(bad_dirs,rslt.surface_normal.z);
+
+				FourVectors intens;
+				intens.DuplicateVector(Vector(0,0,0));
+				// set up colors
+				FourVectors surf_colors;
+				surf_colors.DuplicateVector(Vector(0,0,0));
+				for(int i=0;i<4;i++)
+				{
+					if (rslt.HitIds[i]>=0)
+					{
+						surf_colors.X(i)=TriangleColors[rslt.HitIds[i]].x;
+						surf_colors.Y(i)=TriangleColors[rslt.HitIds[i]].y;
+						surf_colors.Z(i)=TriangleColors[rslt.HitIds[i]].z;
+					}
+
+				}
+				FourVectors surface_pos=myrays.direction;
+				surface_pos*=rslt.HitDistance;
+				surface_pos+=myrays.origin;
+				
+				switch(lmode)
+				{
+					case DIRECT_LIGHTING:
+					{
+						// light all points
+						for(int l=0;l<LightList.Count();l++)
+						{
+							LightList[l].ComputeLightAtPoints(surface_pos,rslt.surface_normal,
+															  intens);
+						}
+					}
+					break;
+
+					case DIRECT_LIGHTING_WITH_SHADOWS:
+					{
+						// light all points
+						for(int l=0;l<LightList.Count();l++)
+						{
+							FourVectors ldir;
+							ldir.DuplicateVector(LightList[l].m_Position);
+							ldir-=surface_pos;
+							fltx4 MaxT=ldir.length();
+							ldir.VectorNormalizeFast();
+							// now, compute shadow flag
+							FourRays myrays;
+							myrays.origin=surface_pos;
+							FourVectors epsilon=ldir;
+							epsilon*=0.01;
+							myrays.origin+=epsilon;
+							myrays.direction=ldir;
+							RayTracingResult shadowtest;
+							Trace4Rays(myrays,Four_Zeros,MaxT, &shadowtest);
+							fltx4 unshadowed=CmpGtSIMD(shadowtest.HitDistance,MaxT);
+							if (! (IsAllZeros(unshadowed)))
+							{
+								FourVectors tmp;
+								tmp.DuplicateVector(Vector(0,0,0));
+								LightList[l].ComputeLightAtPoints(surface_pos,rslt.surface_normal,
+																  tmp);
+								intens.x=AddSIMD(intens.x,AndSIMD(tmp.x,unshadowed));
+								intens.y=AddSIMD(intens.y,AndSIMD(tmp.y,unshadowed));
+								intens.z=AddSIMD(intens.z,AndSIMD(tmp.z,unshadowed));
+							}
+						}
+					}
+					break;
+				}
+				// now, mask off non-hitting pixels
+				intens.VProduct(surf_colors);
+				fltx4 no_hit_mask=CmpGtSIMD(rslt.HitDistance,TraceLimit);
+				
+				intens.x=OrSIMD(AndSIMD(BackgroundColor.x,no_hit_mask),
+								   AndNotSIMD(no_hit_mask,intens.x));
+				intens.y=OrSIMD(AndSIMD(BackgroundColor.y,no_hit_mask),
+								   AndNotSIMD(no_hit_mask,intens.y));
+				intens.z=OrSIMD(AndSIMD(BackgroundColor.y,no_hit_mask),
+								   AndNotSIMD(no_hit_mask,intens.z));
+
+				MapLinearIntensities(intens,dest,dest+1,dest+stride,dest+stride+1);
+			}
+			dest+=2;
+			SLoc+=dxvectortimes2;
+		}
+	}
+}
+
+
+
+
+#define SQ(x) ((x)*(x))
+
+void RayTracingEnvironment::ComputeVirtualLightSources(void)
+{
+	int start_pos=0;
+	for(int b=0;b<3;b++)
+	{
+		int nl=LightList.Count();
+		int where_to_start=start_pos;
+		start_pos=nl;
+		for(int l=where_to_start;l<nl;l++)
+		{
+			DirectionalSampler_t sample_generator;
+			int n_desired=1*LightList[l].m_Color.Length();
+			if (LightList[l].m_Type==MATERIAL_LIGHT_SPOT)
+				n_desired*=LightList[l].m_Phi/2;
+			for(int try1=0;try1<n_desired;try1++)
+			{
+				LightDesc_t const &li=LightList[l];
+				FourRays myrays;
+				myrays.origin.DuplicateVector(li.m_Position);
+				RayTracingResult rslt;
+				Vector trial_dir=sample_generator.NextValue();
+				if (li.IsDirectionWithinLightCone(trial_dir))
+				{
+					myrays.direction.DuplicateVector(trial_dir);
+					Trace4Rays(myrays,all_zeros,ReplicateX4(1000.0), &rslt);
+					if ((rslt.HitIds[0]!=-1))
+					{
+						// make sure normal points back towards ray origin
+						fltx4 ndoti=rslt.surface_normal*myrays.direction;
+						fltx4 bad_dirs=AndSIMD(CmpGtSIMD(ndoti,Four_Zeros),
+												   LoadAlignedSIMD((float *) signmask));
+						
+						// flip signs of all "wrong" normals
+						rslt.surface_normal.x=XorSIMD(bad_dirs,rslt.surface_normal.x);
+						rslt.surface_normal.y=XorSIMD(bad_dirs,rslt.surface_normal.y);
+						rslt.surface_normal.z=XorSIMD(bad_dirs,rslt.surface_normal.z);
+
+						// a hit! let's make a virtual light source
+
+						// treat the virtual light as a disk with its center at the hit position
+						// and its radius scaled by the amount of the solid angle this probe
+						// represents.
+						float area_of_virtual_light=
+							4.0*M_PI*SQ( SubFloat( rslt.HitDistance, 0 ) )*(1.0/n_desired);
+
+						FourVectors intens;
+						intens.DuplicateVector(Vector(0,0,0));
+
+						FourVectors surface_pos=myrays.direction;
+						surface_pos*=rslt.HitDistance;
+						surface_pos+=myrays.origin;
+						FourVectors delta=rslt.surface_normal;
+						delta*=0.1;
+						surface_pos+=delta;
+						LightList[l].ComputeLightAtPoints(surface_pos,rslt.surface_normal,
+														  intens);
+						FourVectors surf_colors;
+						surf_colors.DuplicateVector(TriangleColors[rslt.HitIds[0]]);
+						intens*=surf_colors;
+						// see if significant
+						LightDesc_t l1;
+						l1.m_Type=MATERIAL_LIGHT_SPOT;
+						l1.m_Position=Vector(surface_pos.X(0),surface_pos.Y(0),surface_pos.Z(0));
+						l1.m_Direction=Vector(rslt.surface_normal.X(0),rslt.surface_normal.Y(0),
+											  rslt.surface_normal.Z(0));
+						l1.m_Color=Vector(intens.X(0),intens.Y(0),intens.Z(0));
+						if (l1.m_Color.Length()>0)
+						{
+							l1.m_Color*=area_of_virtual_light/M_PI;
+							l1.m_Range=0.0;
+							l1.m_Falloff=1.0;
+							l1.m_Attenuation0=1.0;
+							l1.m_Attenuation1=0.0;
+							l1.m_Attenuation2=1.0;			// intens falls off as 1/r^2
+							l1.m_Theta=0;
+							l1.m_Phi=M_PI;
+							l1.RecalculateDerivedValues();
+							LightList.AddToTail(l1);
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+
+static unsigned int GetSignMask(Vector const &v)
+{
+	unsigned int ret=0;
+	if (v.x<0.0)
+		ret++;
+	if (v.y<0)
+		ret+=2;
+	if (v.z<0)
+		ret+=4;
+	return ret;
+}
+
+
+inline void RayTracingEnvironment::FlushStreamEntry(RayStream &s,int msk)
+{
+	assert(msk>=0);
+	assert(msk<8);
+	fltx4 tmax=s.PendingRays[msk].direction.length();
+	fltx4 scl=ReciprocalSaturateSIMD(tmax);
+	s.PendingRays[msk].direction*=scl;					// normalize
+	RayTracingResult tmpresult;
+	Trace4Rays(s.PendingRays[msk],Four_Zeros,tmax,msk,&tmpresult);
+	// now, write out results
+	for(int r=0;r<4;r++)
+	{
+		RayTracingSingleResult *out=s.PendingStreamOutputs[msk][r];
+		out->ray_length=SubFloat( tmax, r );
+		out->surface_normal.x=tmpresult.surface_normal.X(r);
+		out->surface_normal.y=tmpresult.surface_normal.Y(r);
+		out->surface_normal.z=tmpresult.surface_normal.Z(r);
+		out->HitID=tmpresult.HitIds[r];
+		out->HitDistance=SubFloat( tmpresult.HitDistance, r );
+	}
+	s.n_in_stream[msk]=0;
+}
+
+void RayTracingEnvironment::AddToRayStream(RayStream &s,
+										   Vector const &start,Vector const &end,
+										   RayTracingSingleResult *rslt_out)
+{
+	Vector delta=end;
+	delta-=start;
+	int msk=GetSignMask(delta);
+	assert(msk>=0);
+	assert(msk<8);
+	int pos=s.n_in_stream[msk];
+	assert(pos<4);
+	s.PendingRays[msk].origin.X(pos)=start.x;
+	s.PendingRays[msk].origin.Y(pos)=start.y;
+	s.PendingRays[msk].origin.Z(pos)=start.z;
+	s.PendingRays[msk].direction.X(pos)=delta.x;
+	s.PendingRays[msk].direction.Y(pos)=delta.y;
+	s.PendingRays[msk].direction.Z(pos)=delta.z;
+	s.PendingStreamOutputs[msk][pos]=rslt_out;
+	if (pos==3)
+	{
+		FlushStreamEntry(s,msk);
+	}
+	else
+		s.n_in_stream[msk]++;
+}
+
+void RayTracingEnvironment::FinishRayStream(RayStream &s)
+{
+	for(int msk=0;msk<8;msk++)
+	{
+		int cnt=s.n_in_stream[msk];
+		if (cnt)
+		{
+			// fill in unfilled entries with dups of first
+			for(int c=cnt;c<4;c++)
+			{
+				s.PendingRays[msk].origin.X(c) = s.PendingRays[msk].origin.X(0);
+				s.PendingRays[msk].origin.Y(c) = s.PendingRays[msk].origin.Y(0);
+				s.PendingRays[msk].origin.Z(c) = s.PendingRays[msk].origin.Z(0);
+				s.PendingRays[msk].direction.X(c) = s.PendingRays[msk].direction.X(0);
+				s.PendingRays[msk].direction.Y(c) = s.PendingRays[msk].direction.Y(0);
+				s.PendingRays[msk].direction.Z(c) = s.PendingRays[msk].direction.Z(0);
+				s.PendingStreamOutputs[msk][c]=s.PendingStreamOutputs[msk][0];
+			}
+			FlushStreamEntry(s,msk);
+		}
+	}
+}
diff --git a/mp/src/raytrace/trace3.cpp b/mp/src/raytrace/trace3.cpp
new file mode 100644
index 00000000..d8000c3d
--- /dev/null
+++ b/mp/src/raytrace/trace3.cpp
@@ -0,0 +1,127 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "raytrace.h"
+#include <bspfile.h>
+#include "bsplib.h"
+
+static Vector VertCoord(dface_t const &f, int vnum)
+{
+	int eIndex = dsurfedges[f.firstedge+vnum];
+	int point;
+	if( eIndex < 0 )
+	{
+		point = dedges[-eIndex].v[1];
+	}
+	else
+	{
+		point = dedges[eIndex].v[0];
+	}
+	dvertex_t *v=dvertexes+point;
+	return Vector(v->point[0],v->point[1],v->point[2]);
+
+}
+
+Vector colors[]={
+	Vector(0.5,0.5,1),
+	Vector(0.5,1,0.5),
+	Vector(0.5,1,1),
+	Vector(1,0.5,0.5),
+	Vector(1,0.5,1),
+	Vector(1,1,1)};
+
+void RayTracingEnvironment::AddBSPFace(int id,dface_t const &face)
+{
+	if (face.dispinfo!=-1)									// displacements must be dealt with elsewhere
+		return;
+	texinfo_t *tx =(face.texinfo>=0)?&(texinfo[face.texinfo]):0;
+// 	if (tx && (tx->flags & (SURF_SKY|SURF_NODRAW)))
+// 		return;
+	if (tx)
+	{
+		printf("id %d flags=%x\n",id,tx->flags);
+	}
+	printf("side: ");
+	for(int v=0;v<face.numedges;v++)
+	{
+		printf("(%f %f %f) ",XYZ(VertCoord(face,v)));
+	}
+	printf("\n");
+	int ntris=face.numedges-2;
+	for(int tri=0;tri<ntris;tri++)
+	{
+		
+		AddTriangle(id,VertCoord(face,0),VertCoord(face,(tri+1)%face.numedges),
+					VertCoord(face,(tri+2)%face.numedges),Vector(1,1,1)); //colors[id % NELEMS(colors)]);
+	}
+}
+
+void RayTracingEnvironment::InitializeFromLoadedBSP(void)
+{
+// 	CUtlVector<uint8> PlanesToSkip;
+// 	SidesToSkip.EnsureCapacity(numplanes);
+// 	for(int s=0;s<numplanes;s++)
+// 		SidesToSkip.AddToTail(0);
+// 	for(int b=0;b<numbrushes;b++)
+// 		if ((dbrushes[b].contents & MASK_OPAQUE)==0)
+// 		{
+// 			// transparent brush - mark all its sides as "do not process"
+// 			for(int s=0;s<dbrushes[b].numsides;s++)
+// 			{
+// 				PlanesToSkip[s+dbrushes[b].firstside]=1;
+// 			}
+
+// 		}
+// 	// now, add all origfaces, omitting those whose sides are the ones we marked previously
+// 	for(int c=0;c<numorigfaces;c++)
+// 	{
+// 		dface_t const &f=dorigfaces[c];
+// 		if (SidesToSkip[f.AddBSPFace(c,dorigfaces[c]);
+// 	}
+	
+
+
+// 	// ugly - I want to traverse all the faces. but there is no way to get from a face back to it's
+// 	// original brush, and I need to get back to the face to the contents field of the brush.  So I
+// 	// will create a temporary mapping from a "side" to its brush. I can get from the face to it
+// 	// side, which can get me back to its brush.
+	
+// 	CUtlVector<uint8> OrigFaceVisited;
+// 	OrigFaceVisited.EnsureCapacity(numorigfaces);
+// 	int n_added=0;
+
+// 	for(int i=0;i<numorigfaces;i++)
+// 		OrigFaceVisited.AddToTail(0);
+
+// 	for(int l=0;l<numleafs;l++)
+// 	{
+// 		dleaf_t const &lf=dleafs[l];
+// //		if (lf.contents & MASK_OPAQUE)
+// 		{
+// 			for(int f=0;f<lf.numleaffaces;f++);
+// 			{
+// 				dface_t const &face=dfaces[f+lf.firstleafface];
+// 				if (OrigFaceVisited[face.origFace]==0)
+// 				{
+// 					dface_t const &oface=dorigfaces[face.origFace];
+// 					OrigFaceVisited[face.origFace]=1;
+// 					n_added++;
+// 					AddBSPFace(face.origFace,oface);
+// 				}
+// 			}
+// 		}
+// 	}
+// 	printf("added %d of %d\n",n_added,numorigfaces);
+// 	for(int c=0;c<numorigfaces;c++)
+// 	{
+// 		dface_t const &f=dorigfaces[c];
+// 		AddBSPFace(c,dorigfaces[c]);
+// 	}
+	for(int c=0;c<numfaces;c++)
+	{
+//		dface_t const &f=dfaces[c];
+		AddBSPFace(c,dorigfaces[c]);
+	}
+
+//	AddTriangle(1234,Vector(51,145,-700),Vector(71,165,-700),Vector(51,165,-700),colors[5]);
+}
+
-- 
cgit v1.2.3