C++ Context::Dir方法代码示例

		void 
			Tree<ElementContainer>::TraversePacket(Context<1,flags> &c,const Selector<1> &selector) const
		{
			int bitMask=selector[0];
			const Vec3q &dir=c.Dir(0);

			bool split=1;

			if(Selector<1>::full||bitMask==0x0f) {	
				if(!filterSigns||GetVecSign(c.Dir(0))!=8) {
					if(separateFirstElement) elements[0].Collide(c,0);
					TraversePacket0(c);
					split=0;
				}
			}

			if(split) {
				if(bitMask==0) return;
				for(int q=0;q<4;q++) {	
					if(!(bitMask&(1<<q))) continue;

					FContext<flags> fc(c,q);
					if(separateFirstElement) elements[0].Collide(fc,0);
					TraverseMono(fc);
				} 
			}
		}

		void Tree<ElementContainer>::TraversePacket(Context<size,flags> &c,const Selector<size> &selector) const
		{
			bool split=1;

			enum { reflected=!(flags&(isct::fPrimary|isct::fShadow)) };

			bool selectorsFiltered=size<=(reflected?4:isComplex?64:16);
			if(!Selector<size>::full)
				for(int n=0;n<size/4;n++)
					if(selector.Mask4(n)!=0x0f0f0f0f) {
						selectorsFiltered=0;
						break;
					}

			if((Selector<size>::full||selectorsFiltered)
					&& size <= (reflected?4 : isComplex? 64 : 16)) {
				const Vec3q &dir=c.Dir(0);
				bool signsFiltered=1;
				int msk=_mm_movemask_ps(_mm_shuffle_ps(_mm_shuffle_ps(dir.x.m,dir.y.m,0),dir.z.m,0+(2<<2)))&7;

				if(filterSigns) {					
					for(int n=0;n<size;n++) if(GetVecSign(c.Dir(n))!=msk) {
						signsFiltered=0;
						break;
					}
				}

				if(signsFiltered) {
					bool primary = (flags & (isct::fPrimary|isct::fShadow)) && gVals[1];

					if((flags & isct::fShadow) &&!isComplex) {
						floatq dot=1.0f;
						for(int q=1;q<size;q++) dot=Min(dot,c.Dir(0)|c.Dir(q));
						if(ForAny(dot<0.9998f)) primary=0;
					}
					if(separateFirstElement) elements[0].Collide(c,0);
					if(primary) TraversePrimary(c);
					else TraversePacket0(c);

				//	if(primary && (flags & isct::fShadow)) c.stats.Skip();
					split=0;
				}
			}

			if(split) {
				for(int q=0;q<4;q++) {
					Context<size/4,flags> subC(c.Split(q));
					if(flags & isct::fShadow) subC.shadowCache=c.shadowCache;
					TraversePacket(subC,selector.SubSelector(q));
					if(flags & isct::fShadow) c.shadowCache=subC.shadowCache;
				}
			}
		}

void DBVH::TraversePrimary0(Context<sharedOrigin, hasMask> &c, int firstNode) const {
	const int size = c.Size();

	StackElem stack[maxDepth + 2]; int stackPos = 0;
	stack[stackPos++] = StackElem(firstNode, 0, size - 1);
	TreeStats stats;

	int sign[3] = { c.Dir(0).x[0] < 0.0f, c.Dir(0).y[0] < 0.0f, c.Dir(0).z[0] < 0.0f };

	CornerRays crays(c.rays);
	RayInterval interval(c.rays);
	
	while(stackPos) {
		int nNode = stack[--stackPos].node;
		int firstActive = stack[stackPos].firstActive;
		int lastActive = stack[stackPos].lastActive;

	CONTINUE:
		stats.LoopIteration();

		if(nodes[nNode].IsLeaf()) {
			int count = nodes[nNode].count, first = nodes[nNode].first & 0x7fffffff;

			const BBox &box = nodes[nNode].bbox;
			if(!box.TestInterval(interval))
				continue;

			if(box.Test(c, firstActive, lastActive))
				for(int n = 0; n < count; n++) {
					const ObjectInstance &obj = elements[first + n];
					obj.CollidePrimary(c, first + n, firstActive, lastActive);
					stats.Intersection(lastActive - firstActive + 1);
				}

			continue;
		}
			
		int child = nodes[nNode].subNode;
#ifdef VECLIB_SSE_VER
		_mm_prefetch(&nodes[child + 0], _MM_HINT_T0);
		_mm_prefetch(&nodes[child + 1], _MM_HINT_T0);
#endif
			
		bool test = 1; {
			const BBox &box = nodes[nNode].bbox;
			if(!box.TestInterval(interval))
				continue;
			test = box.Test(c, firstActive, lastActive);
		}

		if(test) {
			int firstNode = nodes[nNode].firstNode ^ sign[nodes[nNode].axis];
			stack[stackPos++] = StackElem(child + (firstNode ^ 1), firstActive, lastActive);
			nNode = child + firstNode;
			goto CONTINUE;
		}
	}

	if(c.stats)
		(*c.stats) += stats;
}

void DBVH::TraversePrimary(Context<sharedOrigin, hasMask> &c) const {
	return TraversePrimary0(c);
	
	const int size = c.Size();
	bool split = 1;

	RaySelector selector(c.MaskPtr(), c.Size());
	bool selectorsFiltered = 1;
	if(hasMask) {
		const int size4 = size / 4; //TODO: ...
		bool any = 0;
		for(int n = 0; n < size4; n++) {
			int mask = selector.Mask4(n);
			selectorsFiltered &= mask == 0x0f0f0f0f;
			any |= mask;
		}
		if(!any)
			return;
	}

	if(!hasMask || selectorsFiltered) {
		//TODO distant origins
		floatq dot = 1.0f;
		for(int q = 1; q < size; q++)
			dot = Min(dot, c.Dir(0) | c.Dir(q));
		split = ForAny(dot < 0.99);

		if(!split)
			TraversePrimary0(c);
	}

	if(split) {
	//	if(gVals[0]) {
			char tempData[size + 4];
			RaySelector temp(tempData, size);
			for(int n = 0; n < temp.Size(); n++)
				temp[n] = c.Mask(n);
			int start = 0;
			while(true) {
				char buf[c.Size() + 4];
				RaySelector newSel(buf, c.Size());
				newSel.Clear();

				for(;start < size; start++)
					if(temp[start]) break;
				if(start == size)
					break;

				Vec3q lead;
				for(int i = 0; i < 4; i++)
					if(temp[start] & (1 << i)) {
						lead = (Vec3q)ExtractN(c.Dir(start), i);
						break;
					}
				for(int q = start; q < size; q++) {
					int mask = ForWhich((c.Dir(q) | lead) >= 0.9) & temp[q];
					temp[q] &= ~mask;
					newSel[q] = mask;
				}
				Context<sharedOrigin, 1> splitCtx(RayGroup<sharedOrigin, 1>(c.rays.OriginPtr(),
								c.rays.DirPtr(), c.rays.IDirPtr(), size, buf), c.distance, c.object, c.element, c.barycentric);
				TraversePrimary0(splitCtx);
			}
	//	}
	//	else {
			//TODO: split
		//	for(int q = 0; q < 4; q++) {
		//		Context<size/4,flags> subC(c.Split(q));
		//		TraversePrimary0(subC, selector.SubSelector(q));
		//	}
	//	}
		if(c.stats) c.stats->Skip();
	}
}