C# Ray.GetDirection方法代码示例

	/**
	 * Intersect
	 *
	 * @param ray
	 * @param pt
	 * @return boolean
	 */
	public override bool Intersect(Ray ray, IntersectPt pt)
	{
		Vector OC = new Vector();
		double l2OC, tCA, t2HC;

		OC.Sub(Origin, ray.GetOrigin());
		l2OC = OC.SquaredLength();
		tCA = OC.Dot(ray.GetDirection());
		if(l2OC >= RadiusSquare && tCA <= 0)
		{
			return (false);
		}
		t2HC = RadiusSquare - l2OC + tCA * tCA;
		if(t2HC < 0)
		{
			return (false);
		}
		if(l2OC <= RadiusSquare)
		{
			pt.SetT(tCA + (double)System.Math.Sqrt(t2HC));
			if(pt.GetT() < pt.GetThreshold())
			{
				return (false);
			}
			pt.SetEnter(false);
			pt.GetIntersection().Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, pt.GetT());
		}
		else
		{
			pt.SetT(tCA - (double)System.Math.Sqrt(t2HC));
			pt.SetEnter(true);
			if(pt.GetT() < pt.GetThreshold())
			{
				pt.SetT(tCA + (double)System.Math.Sqrt(t2HC));
				pt.SetEnter(false);
			}
			pt.GetIntersection().Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, pt.GetT());
		}
		pt.SetIntersectObj(this);
		GetCachePt().Set(ray.GetID(), pt);
		return (true);
	}

	/**
	 * Intersect
	 *
	 * @param ray
	 * @param pt
	 * @return boolean
	 */
	public override bool Intersect(Ray ray, IntersectPt pt)
	{
		double vd = Normal.Dot(ray.GetDirection());
		double vo, t;
		Vector origVec = new Vector(ray.GetOrigin().GetX(), ray.GetOrigin().GetY(), ray.GetOrigin().GetZ());

		if(vd == 0.0f)
		{
			return (false);
		}
		vo = -Normal.Dot(origVec) - D;
		t = vo / vd;
		if(t < pt.GetThreshold())
		{
			return (false);
		}
		pt.GetIntersection().Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, t);
		if(!Check(ray, pt))
		{
			return (false);
		}
		pt.SetT(t);
		pt.SetIntersectObj(this);
		if(GetObjID() == pt.GetOriginal())
		{
			pt.SetEnter(false);
		}
		else
		{
			pt.SetEnter(true);
		}
		GetCachePt().Set(ray.GetID(), pt);
		return (true);
	}

	/**
	 * FindNearestIsect
	 *
	 * @param octree
	 * @param ray
	 * @param originID
	 * @param level
	 * @param isectnode
	 * @return boolean
	 */
	public bool FindNearestIsect(OctNode octree, Ray ray, int originID, int level, OctNode isectnode)
	{
		Point testpt = new Point(ray.GetOrigin());
		OctNode current;
		ObjNode currentnode;
		CacheIntersectPt isectptr;
		IntersectPt test = new IntersectPt();

		if(level == 0)
		{
			testpt.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, Threshold);
		}

		current = octree.FindTreeNode(testpt);
		IntersectObj = null;
		while(current != null)
		{
			currentnode = current.GetList();
			while(currentnode != null)
			{
				bool found = false;
				if(currentnode.GetObj().GetCachePt().GetID() == ray.GetID())
				{
					isectptr = currentnode.GetObj().GetCachePt();
					if(current == current.FindTreeNode(isectptr.GetIntersection()))
					{
						if(IntersectObj == null)
						{
							SetIsectPt(isectptr);
							isectnode.Copy(current);
						}
						else
						{
							if(isectptr.GetT() < t)
							{
								SetIsectPt(isectptr);
								isectnode.Copy(current);
							}
						}
						found = true;
					}
				}
				if(!found)
				{
					test.SetOrigID(originID);
					if(currentnode.GetObj().Intersect(ray, test))
					{
						if(current == current.FindTreeNode(test.GetIntersection()))
						{
							if(IntersectObj == null)
							{
								SetIsectPt(test);
								isectnode.Copy(current);
							}
							else
							{
								if(test.GetT() < t)
								{
									SetIsectPt(test);
									isectnode.Copy(current);
								}
							}
						}
					}
				}
				currentnode = currentnode.Next();
			}
			if(IntersectObj == null)
			{
				OctNode adjacent = current.Intersect(ray, testpt, Threshold);
				if(adjacent == null)
				{
					current = null;
				}
				else
				{
					current = adjacent.FindTreeNode(testpt);
				}
			}
			else
			{
				current = null;
			}
		}
		if(IntersectObj == null)
		{
			return (false);
		}
		else
		{
//.........这里部分代码省略.........

	/**
	 * Intersect
	 *
	 * @param ray
	 * @param intersect
	 * @param Threshold
	 * @return OctNode
	 */
	public OctNode Intersect(Ray ray, Point intersect, double Threshold)
	{
		Vector delta = new Vector(0.0f, 0.0f, 0.0f);
		double current = 0.0f;
		double t;
		int[] facehits = new int[3];
		facehits[0] = -1;
		facehits[1] = -1;
		facehits[2] = -1;
		OctNode adjacent = null;

		Face[] OFaces = this.OctFaces;
		Face MAXXF = OFaces[MAXX];
		Face MAXYF = OFaces[MAXY];
		Face MAXZF = OFaces[MAXZ];
		Face MINXF = OFaces[MINX];
		Face MINYF = OFaces[MINY];
		Face MINZF = OFaces[MINZ];

		if(ray.GetDirection().GetX() != 0.0)
		{
			t = -(ray.GetOrigin().GetX() - OctFaces[MAXX].GetVert(0).GetX()) / ray.GetDirection().GetX();
			if(t > Threshold && t > current)
			{
				intersect.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, t);
				if((intersect.GetY() <= MAXYF.GetVert(0).GetY()) && (intersect.GetY() >= MINYF.GetVert(0).GetY()) &&
					(intersect.GetZ() <= MAXZF.GetVert(0).GetZ()) && (intersect.GetZ() >= MINZF.GetVert(0).GetZ()))
				{
					current = t;
					facehits[0] = MAXX;
					delta.SetX(Threshold);
				}
			}
			t = -(ray.GetOrigin().GetX() - OctFaces[MINX].GetVert(0).GetX()) / ray.GetDirection().GetX();
			if(t > Threshold && t > current)
			{
				intersect.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, t);
				if((intersect.GetY() <= MAXYF.GetVert(0).GetY()) && (intersect.GetY() >= MINYF.GetVert(0).GetY()) &&
					(intersect.GetZ() <= MAXZF.GetVert(0).GetZ()) && (intersect.GetZ() >= MINZF.GetVert(0).GetZ()))
				{
					current = t;
					facehits[0] = MINX;
					delta.SetX(-Threshold);
				}
			}
		}
		if(ray.GetDirection().GetY() != 0.0)
		{
			t = -(ray.GetOrigin().GetY() - OctFaces[MAXY].GetVert(0).GetY()) / ray.GetDirection().GetY();
			if(t > Threshold)
			{
				if(t > current)
				{
					intersect.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, t);
					if((intersect.GetX() <= MAXXF.GetVert(0).GetX()) && (intersect.GetX() >= MINXF.GetVert(0).GetX()) &&
						(intersect.GetZ() <= MAXZF.GetVert(0).GetZ()) && (intersect.GetZ() >= MINZF.GetVert(0).GetZ()))
					{
						current = t;
						facehits[0] = MAXY;
						delta.Set(0.0f, Threshold, 0.0f);
					}
				}
				else if(t == current)
				{
					facehits[1] = MAXY;
					delta.SetY(Threshold);
				}
			}
			t = -(ray.GetOrigin().GetY() - OctFaces[MINY].GetVert(0).GetY()) / ray.GetDirection().GetY();
			if(t > Threshold)
			{
				if(t > current)
				{
					intersect.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, t);
					if((intersect.GetX() <= MAXXF.GetVert(0).GetX()) && (intersect.GetX() >= MINXF.GetVert(0).GetX()) &&
						(intersect.GetZ() <= MAXZF.GetVert(0).GetZ()) && (intersect.GetZ() >= MINZF.GetVert(0).GetZ()))
					{
						current = t;
						facehits[0] = MINY;
						delta.Set(0.0f, -Threshold, 0.0f);
					}
				}
				else if(t == current)
				{
					facehits[1] = MINY;
					delta.SetY(-Threshold);
				}
			}
		}
		if(ray.GetDirection().GetZ() != 0.0)
		{
			t = -(ray.GetOrigin().GetZ() - OctFaces[MAXZ].GetVert(0).GetZ()) / ray.GetDirection().GetZ();
//.........这里部分代码省略.........

	/**
	 * RenderScene
	 */
	public void RenderScene(Canvas canvas, int width, int section, int nsections)
	{
		Vector view = camera.GetViewDir();
		Vector up = camera.GetOrthoUp();
		Vector plane = new Vector();
		Vector horIncr = new Vector();
		Vector vertIncr = new Vector();
		double ylen = camera.GetFocalDist() * (double)Math.Tan(0.5f * camera.GetFOV());
		double xlen = ylen * canvas.GetWidth() / canvas.GetHeight();
		Point upleft = new Point();
		Point upright = new Point();
		Point lowleft = new Point();
		Point basepoint = new Point();
		Point current;
		Ray eyeRay = new Ray();
		int ypixel, xpixel;

		RayID = 1;
		plane.Cross(view, up);
		view.Scale(camera.GetFocalDist());
		up.Scale(ylen);
		plane.Scale(-xlen);
		upleft.FindCorner(view, up, plane, camera.GetPosition());
		plane.Negate();
		upright.FindCorner(view, up, plane, camera.GetPosition());
		up.Negate();
		plane.Negate();
		lowleft.FindCorner(view, up, plane, camera.GetPosition());
		horIncr.Sub(upright, upleft);
		horIncr.Scale(horIncr.Length() / ((double)canvas.GetWidth()));
		vertIncr.Sub(lowleft, upleft);
		vertIncr.Scale(vertIncr.Length() / ((double)canvas.GetHeight()));
		basepoint.Set(upleft.GetX() + 0.5f * (horIncr.GetX() + vertIncr.GetX()), upleft.GetY() + 0.5f * (horIncr.GetY() + vertIncr.GetY()),
			upleft.GetZ() + 0.5f * (horIncr.GetZ() + vertIncr.GetZ()));
		eyeRay.SetOrigin(camera.GetPosition());

		int xstart = section * width / nsections;
		int xend = xstart + width / nsections;

		Console.WriteLine("+" + xstart + " to " + (xend - 1) + " by " + canvas.GetHeight());

		for(ypixel = 0; ypixel < canvas.GetHeight(); ypixel++)
		{
			current = new Point(basepoint);
			for(xpixel = 0; xpixel < canvas.GetWidth(); xpixel++)
			{
				if(xpixel >= xstart && xpixel < xend)
				{
					Color color = new Color(0.0f, 0.0f, 0.0f);
					eyeRay.GetDirection().Sub(current, eyeRay.GetOrigin());
					eyeRay.GetDirection().Normalize();
					eyeRay.SetID(RayID);
					this.RayID = this.RayID + 1;
					Shade(octree, eyeRay, color, 1.0f, 0, 0);
					canvas.Write(Brightness, xpixel, ypixel, color);
				}
				current.Add(horIncr);
			}
			basepoint.Add(vertIncr);
		}
		Console.WriteLine("-" + xstart + " to " + (xend - 1) + " by " + canvas.GetHeight());
	}

	/**
	 * GetLightColor
	 *
	 * @param tree
	 * @param point
	 * @param normal
	 * @param currentObj
	 * @param color
	 */
	private void GetLightColor(OctNode tree, Point point, Vector normal, ObjectType currentObj, Color color)
	{
		Ray shadow = new Ray();
		LightNode current = lights;
		double maxt;

		while(current != null)
		{
			shadow.SetOrigin(point);
			shadow.GetDirection().Sub(current.GetLight().GetPosition(), point);
			maxt = shadow.GetDirection().Length();
			shadow.GetDirection().Normalize();
			shadow.SetID(RayID);
			this.RayID = this.RayID + 1;
			if(!FindLightBlock(tree, shadow, maxt))
			{
				double factor = Math.Max(0.0f, normal.Dot(shadow.GetDirection()));
				if(factor != 0.0)
				{
					color.Mix(factor, current.GetLight().GetColor(), currentObj.GetMaterial().GetDiffColor());
				}
			}
			current = current.Next();
		}
	}

	/**
	 * Shade
	 *
	 * @param tree
	 * @param eyeRay
	 * @param color
	 * @param factor
	 * @param level
	 * @param originID
	 */
	private void Shade(OctNode tree, Ray eyeRay, Color color, double factor, int level, int originID)
	{
		Color lightColor = new Color(0.0f, 0.0f, 0.0f);
		Color reflectColor = new Color(0.0f, 0.0f, 0.0f);
		Color refractColor = new Color(0.0f, 0.0f, 0.0f);
		IntersectPt intersect = new IntersectPt();
		OctNode baseoctn = new OctNode();
		Vector normal = new Vector();
		Ray reflect = new Ray();
		Ray refract = new Ray();
		double mu;
		int current;

		if(intersect.FindNearestIsect(tree, eyeRay, originID, level, baseoctn))
		{
			intersect.GetIntersectObj().FindNormal(intersect.GetIntersection(), normal);
			GetLightColor(baseoctn, intersect.GetIntersection(), normal, intersect.GetIntersectObj(), lightColor);
			if(level < MaxLevel)
			{
				double check = factor * (1.0f - intersect.GetIntersectObj().GetMaterial().GetKTran()) * intersect.GetIntersectObj().GetMaterial().GetShininess();
				if(check > MinFactor)
				{
					reflect.SetOrigin(intersect.GetIntersection());
					reflect.GetDirection().Combine(eyeRay.GetDirection(), normal, 1.0f, -2.0f * normal.Dot(eyeRay.GetDirection()));
					reflect.SetID(RayID);
					this.RayID = this.RayID + 1;
					Shade(baseoctn, reflect, reflectColor, check, level + 1, originID);
					reflectColor.Scale((1.0f - intersect.GetIntersectObj().GetMaterial().GetKTran()) * intersect.GetIntersectObj().GetMaterial().GetShininess(),
						intersect.GetIntersectObj().GetMaterial().GetSpecColor());
				}
				check = factor * intersect.GetIntersectObj().GetMaterial().GetKTran();
				if(check > MinFactor)
				{
					if(intersect.GetEnter())
					{
						mu = 1.0f / intersect.GetIntersectObj().GetMaterial().GetRefIndex();
						current = intersect.GetIntersectObj().GetObjID();
					}
					else
					{
						mu = intersect.GetIntersectObj().GetMaterial().GetRefIndex();
						normal.Negate();
						current = 0;
					}
					double IdotN = normal.Dot(eyeRay.GetDirection());
					double TotIntReflect = 1.0f - mu * mu * (1.0f - IdotN * IdotN);
					if(TotIntReflect >= 0.0)
					{
						double gamma = -mu * IdotN - (double)Math.Sqrt(TotIntReflect);
						refract.SetOrigin(intersect.GetIntersection());
						refract.GetDirection().Combine(eyeRay.GetDirection(), normal, mu, gamma);
						refract.SetID(RayID);
						this.RayID = RayID + 1;
						Shade(baseoctn, refract, refractColor, check, level + 1, current);
						refractColor.Scale(intersect.GetIntersectObj().GetMaterial().GetKTran(), intersect.GetIntersectObj().GetMaterial().GetSpecColor());
					}
				}
			}
			color.Combine(intersect.GetIntersectObj().GetMaterial().GetEmissColor(), intersect.GetIntersectObj().GetMaterial().GetAmbColor(),
				AmbLightIntensity, lightColor, reflectColor, refractColor);
		}
	}