Esempio n. 1
0
        protected override Intersections LocalIntersect(Ray ray)
        {
            var i = new Intersections();

            if (Math.Abs(ray.Direction.y) < MathHelper.Epsilon)
            {
                return(i);
            }

            var t = -ray.Origin.y / ray.Direction.y;

            i.Add(new Intersection(t, this));

            return(i);
        }
Esempio n. 2
0
        protected override Intersections LocalIntersect(Ray ray)
        {
            var intersections = new Intersections();

            CheckAxis(ray.Origin.x, ray.Direction.x, out double xtmin, out double xtmax);
            CheckAxis(ray.Origin.y, ray.Direction.y, out double ytmin, out double ytmax);
            CheckAxis(ray.Origin.z, ray.Direction.z, out double ztmin, out double ztmax);

            var tmin = Math.Max(xtmin, Math.Max(ytmin, ztmin));
            var tmax = Math.Min(xtmax, Math.Min(ytmax, ztmax));

            if (tmin <= tmax)
            {
                intersections.Add(new Intersection(tmin, this));
                intersections.Add(new Intersection(tmax, this));
            }

            return(intersections);
        }
Esempio n. 3
0
        private void IntersectCaps(Ray ray, Intersections xs)
        {
            if (!Closed || ray.Direction.y.IsEqual(0))
            {
                return;
            }

            var t = (Minimum - ray.Origin.y) / ray.Direction.y;

            if (CheckCap(ray, t))
            {
                xs.Add(new Intersection(t, this));
            }

            t = (Maximum - ray.Origin.y) / ray.Direction.y;
            if (CheckCap(ray, t))
            {
                xs.Add(new Intersection(t, this));
            }
        }
Esempio n. 4
0
        protected override Intersections LocalIntersect(Ray ray)
        {
            var result       = new Intersections();
            var sphereToRay  = new Vector(ray.Origin - Point.Zero);
            var a            = ray.Direction.Dot(ray.Direction);
            var b            = 2.0 * ray.Direction.Dot(sphereToRay);
            var c            = sphereToRay.Dot(sphereToRay) - 1;
            var discriminant = b * b - 4 * a * c;

            if (discriminant < 0.0)
            {
                return(result);
            }
            else
            {
                result.Add(new Intersection((-b - Math.Sqrt(discriminant)) / (2 * a), this));
                result.Add(new Intersection((-b + Math.Sqrt(discriminant)) / (2 * a), this));
            }

            return(result);
        }
        public Computations PrepareComputations(Ray r, Intersections xs)
        {
            List <RTObject> containers = new List <RTObject>();
            var             p          = r.Position(t);
            var             eyev       = -r.Direction;
            var             normv      = Object.NormalAt(p, this);
            var             inside     = false;

            if (normv.Dot(eyev) < 0)
            {
                inside = true;
                normv  = -normv;
            }

            var reflv = r.Direction.Reflect(normv);
            var n1    = 1.0;
            var n2    = 1.0;

            foreach (var i in xs)
            {
                if (this == i)
                {
                    if (containers.Count == 0)
                    {
                        n1 = 1.0;
                    }
                    else
                    {
                        n1 = containers[containers.Count - 1].Material.RefractiveIndex;
                    }
                }

                if (containers.Contains(i.Object))
                {
                    containers.Remove(i.Object);
                }
                else
                {
                    containers.Add(i.Object);
                }

                if (this == i)
                {
                    if (containers.Count == 0)
                    {
                        n2 = 1.0;
                    }
                    else
                    {
                        n2 = containers[containers.Count - 1].Material.RefractiveIndex;
                    }

                    break;
                }
            }

            return(new Computations(t,
                                    Object,
                                    p,
                                    eyev,
                                    normv,
                                    reflv,
                                    n1,
                                    n2,
                                    inside));
        }