Пример #1
0
Файл: RectXY.cs Проект: rje/ray
        public bool Hit(Ray r, double tMin, double tMax, out HitRecord hr)
        {
            var t = (K - r.Origin.z) / r.Dir.z;

            if (t < tMin || t > tMax)
            {
                hr = default(HitRecord);
                return(false);
            }

            var x = r.Origin.x + t * r.Dir.x;
            var y = r.Origin.y + t * r.Dir.y;

            if (x < X0 || x > X1 || y < Y0 || y > Y1)
            {
                hr = default;
                return(false);
            }

            var u             = (x - X0) / (X1 - X0);
            var v             = (y - Y0) / (Y1 - Y0);
            var outwardNormal = new Vec3(0, 0, 1);

            hr = new HitRecord
            {
                T        = t,
                Point    = r.At(t),
                Material = Mp,
                U        = u,
                V        = v
            };
            hr.SetFaceNormal(r, outwardNormal);
            return(true);
        }
Пример #2
0
        public bool Hit(Ray r, double tMin, double tMax, out HitRecord hr)
        {
            var origin = r.Origin;
            var dir    = r.Dir;

            origin[0] = CosTheta * r.Origin[0] - SinTheta * r.Origin[2];
            origin[2] = SinTheta * r.Origin[0] + CosTheta * r.Origin[2];

            dir[0] = CosTheta * r.Dir[0] - SinTheta * r.Dir[2];
            dir[2] = SinTheta * r.Dir[0] + CosTheta * r.Dir[2];

            var rotatedRay = new Ray(origin, dir, r.Time);

            if (!Child.Hit(rotatedRay, tMin, tMax, out hr))
            {
                return(false);
            }

            var p      = hr.Point;
            var normal = hr.Normal;

            p[0] = CosTheta * hr.Point[0] + SinTheta * hr.Point[2];
            p[2] = -SinTheta * hr.Point[0] + CosTheta * hr.Point[2];

            normal[0] = CosTheta * hr.Normal[0] + SinTheta * hr.Normal[2];
            normal[2] = -SinTheta * hr.Normal[0] + CosTheta * hr.Normal[2];

            hr.Point = p;
            hr.SetFaceNormal(rotatedRay, normal);

            return(true);
        }
Пример #3
0
        public bool Hit(Ray r, double tMin, double tMax, out HitRecord hr)
        {
            var movedRay = new Ray(r.Origin - Offset, r.Dir, r.Time);

            if (!Child.Hit(movedRay, tMin, tMax, out hr))
            {
                return(false);
            }

            hr.Point += Offset;
            hr.SetFaceNormal(movedRay, hr.Normal);

            return(true);
        }
Пример #4
0
        public bool Hit(Ray r, double tMin, double tMax, out HitRecord hitRec)
        {
            var center = CenterForTime(r.Time);
            var oc     = r.Origin - center;
            var a      = r.Dir.LengthSquared;
            var halfB  = Vec3.Dot(oc, r.Dir);
            var c      = oc.LengthSquared - Radius * Radius;

            var disc = halfB * halfB - a * c;

            if (disc < 0)
            {
                hitRec = default(HitRecord);
                return(false);
            }

            var sqrtd = Math.Sqrt(disc);

            var root = (-halfB - sqrtd) / a;

            if (root < tMin || tMax < root)
            {
                root = (-halfB + sqrtd) / a;
                if (root < tMin || tMax < root)
                {
                    hitRec = default(HitRecord);
                    return(false);
                }
            }

            var t             = root;
            var point         = r.At(t);
            var outwardNormal = (point - center) / Radius;

            Sphere.GetSphereUV(outwardNormal, out var u, out var v);
            hitRec = new HitRecord
            {
                T        = t,
                Point    = point,
                Material = Material,
                U        = u,
                V        = v
            };
            hitRec.SetFaceNormal(r, outwardNormal);
            return(true);
        }