Esempio n. 1
0
        public override Color Sample(int x, int y, World world)
        {
            Color color = Color.Black;

            var ray = this.RayForPixel(x, y);

            Interlocked.Increment(ref Stats.PrimaryRays);
            color += world.ColorAt(ray);

            return(color);
        }
Esempio n. 2
0
        public override Color Sample(int x, int y, World world)
        {
            Color color = Color.Black;

            foreach (var ray in this.RaysForPixel(x, y))
            {
                Interlocked.Increment(ref Stats.PrimaryRays);
                color += world.ColorAt(ray);
            }
            return(color /= NumSamples);
        }
Esempio n. 3
0
        public override Color Sample(int x, int y, World world)
        {
            Color color = Color.Black;

            Ray   ray        = this.RayForPixel(x, y);
            Point focalPoint = ray.Position(this.focalLength);

            for (int i = 0; i < this.numSamples; i++)
            {
                Vector apertureOffset = RandomInUnitDisk() * this.aperture;

                Point  newOrigin    = ray.Origin + apertureOffset;
                Vector direction    = (focalPoint - newOrigin).Normalize();
                Ray    secondaryRay = new Ray(newOrigin, direction, RayType.Primary);

                Interlocked.Increment(ref Stats.PrimaryRays);
                color += world.ColorAt(secondaryRay);
            }

            return(color / (double)numSamples);
        }
Esempio n. 4
0
        public override Color Sample(int x, int y, World world)
        {
            Color color            = Color.Black;
            int   n                = (int)Math.Sqrt((double)this.numSamples);
            int   numActualSamples = 0;

            for (int jitterX = 0; jitterX < n; jitterX++)
            {
                for (int jitterY = 0; jitterY < n; jitterY++)
                {
                    double xoffset = this.Camera.PixelSize * ((x + 0.5) + ((jitterX + 0.5) / numSamples));
                    double yoffset = this.Camera.PixelSize * ((y + 0.5) + ((jitterY + 0.5) / numSamples));

                    double world_x = this.Camera.HalfWidth - xoffset;
                    double world_y = this.Camera.HalfHeight - yoffset;

                    Point  pixel     = this.Camera.TransformInverse * new Point(world_x, world_y, -1);
                    Point  origin    = this.Camera.TransformInverse * new Point(0, 0, 0);
                    Vector direction = (pixel - origin).Normalize();
                    var    ray       = new Ray(origin, direction, RayType.Primary);

                    Interlocked.Increment(ref Stats.PrimaryRays);
                    Color currColor = world.ColorAt(ray);

                    if (currColor - color < colorEpsilon)
                    {
                        return(color /= numActualSamples);
                    }

                    color += currColor;
                    numActualSamples++;
                }
            }

            return(color /= numActualSamples);
        }