Issues with transparency and the other side of objects

I'm not sure, but I'm guessing this is a side effect of taking only the nearest non-zero intersection for the hit. For the transparent objects I imagine you'd have to take all positive hits, or something to that effect. Again, this is just a guess.

Hello,

Thanks for the replies. I went back over my code and I did find an error where I hadn't updated World.ColorAt to pass in the intersection list into comps.prepare. I checked ColorAt, ShadeHit, GetReflectedColor, GetRefractedColor but didn't find any further errors.

Oddly, fixing this bug has made things worse.

This screenshot is without refraction, just a single transparent cube. Except you can only see 3 faces, and I assume you should be able to see the other 3 through the "glass".



This second screenshot is with a refraction value, but still a single cube. As you can see it has gone pretty wrong!



This third screenshot is the original scene with refraction and the nested cubes - and it looks even more awful.



I tested some other scenes and they look just as bad.

I checked my intersection function and it is returning items ordered by t. I'm completely stumped by this.

I don't have my code published online yet, if the screenshots above give a clue as to the problem area I can post that code? I have posted some of the colour code below, given that refraction definitely breaks it and reflection isn't so hot either

Any help gratefully appreciated!


   public double Schlick
   {
     get
     {
       double result;
       double cos;

       // find the cosine of the angle between the eye and normal vectors
       cos = Tuple.Dot(_eyev, _normalv);

       // total internal reflection can only occur if n 1> n2
       if (_n1 > _n2)
       {
         double n;
         double sin2t;

         n = _n1 / _n2;
         sin2t = Math.Pow(n, 2) * (1 - Math.Pow(cos, 2));

         if (sin2t > 1)
         {
           result = 1;
         }
         else
         {
           cos = Math.Sqrt(1 - sin2t);

           result = 0;
         }
       }
       else
       {
         result = 0;
       }

       if (result != 1)
       {
         double r0;

         r0 = Math.Pow((_n1 - _n2) / (_n1 + _n2), 2);

         result = r0 + (1 - r0) * Math.Pow(1 - cos, 5);
       }

       return result;
     }
   }

   public static Computation Prepare(Intersection hit, Ray ray, Intersection[] xs)
   {
     double t;
     Tuple point;
     Tuple eyev;
     Tuple normalv;
     Shape shape;
     bool inside;
     Tuple overpoint;
     Tuple reflectv;
     double n1;
     double n2;
     Tuple underPoint;

     t = hit.T;
     point = ray.Position(t);
     eyev = -ray.Direction;
     shape = hit.Object;
     normalv = shape.NormalAt(hit, point);

     if (Tuple.Dot(normalv, eyev) < 0)
     {
       inside = true;
       normalv = -normalv;
     }
     else
     {
       inside = false;
     }

     overpoint = point + normalv * Extensions.Epsilon;
     underPoint = point - normalv * Extensions.Epsilon;
     reflectv = Tuple.Reflect(ray.Direction, normalv);

     n1 = 1;
     n2 = 1;

     if (xs.Length != 0)
     {
       Computation.CalculateN(hit, xs, ref n1, ref n2);
     }

     return new Computation(t, shape, point, eyev, normalv, inside, overpoint, reflectv, n1, n2, underPoint);
   }

   public Color ColorAt(Ray ray, int remaining)
   {
     Color result;
     Intersection[] xs;
     Intersection hit;

     xs = this.Intersects(ray);
     hit = Intersection.Hit(xs);

     if (!hit.IsEmpty)
     {
       Computation comps;

       comps = Computation.Prepare(hit, ray, xs);

       result = this.ShadeHit(comps, remaining);
     }
     else
     {
       result = Color.Black;
     }

     return result;
   }

   public Color GetReflectedColor(Computation comps, int remaining)
   {
     Color result;

     if (remaining != 0)
     {
       double reflective;

       reflective = comps.Object.GetMaterial().Reflective;

       if (reflective == 0)
       {
         result = Color.Black;
       }
       else
       {
         Ray reflect;

         reflect = Ray.Create(comps.OverPoint, comps.Reflectv);

         result = this.ColorAt(reflect, remaining - 1) * reflective;
       }
     }
     else
     {
       result = Color.Black;
       ;
     }

     return result;
   }

   public Color GetRefractedColor(Computation comps, int remaining)
   {
     Color result;

     if (comps.Object.GetMaterial().Transparency == 0 || remaining == 0)
     {
       result = Color.Black;
     }
     else
     {
       double nRatio;
       double cosi;
       double sin2t;

       // find the ratio of the first index of refraction to the second
       // (this is inverted from the definition of Snell's Law)
       nRatio = comps.N1 / comps.N2;

       // cos(theta_i) is the same as the dot product of the two vectors
       cosi = Tuple.Dot(comps.Eyev, comps.Normalv);

       // find sin(theta_t)^2 via trigonometric identity
       sin2t = Math.Pow(nRatio, 2) * (1 - Math.Pow(cosi, 2));

       if (sin2t <= 1)
       {
         double cost;
         Tuple direction;
         Ray refractRay;

         // fnid the cos(theta_t) via trigonometric identity
         cost = Math.Sqrt(1 - sin2t);

         // compute the direction of the refracted ray
         direction = comps.Normalv * (nRatio * cosi - cost) - comps.Eyev * nRatio;
         refractRay = Ray.Create(comps.UnderPoint, direction);

         // find the color of the refacted ray, making sure to multiply
         // by the transparency value to account for any opacity
         result = this.ColorAt(refractRay, remaining - 1) * comps.Object.GetMaterial().Transparency;
       }
       else
       {
         result = Color.Black;
       }
     }

     return result;
   }


Regards;
Richard Moss

Oh, I just realized: in your first screenshot, you have "reflective" set to 0. I assume this is true for the other screenshots as well? If so, try setting "reflective" to the same value as "transparency". That is to say, if you have "transparency" set to 0.9, trying setting "reflective" to 0.9 as well. This will enable your Schlick function to do what it does best: blend the reflected and refracted rays into a single, beautiful color.

Richard,

I think those look pretty good, actually! They look a little washed out, which might be from the ambient term. Try setting ambient to 0 when rendering glass (or any highly reflective or transparent media).

I'll see about putting together a YAML definition for that scene you mentioned.

- Jamis

Hello,

I thought I'd add a final update on this transparency / reflection issue. I'd previously grabbed all the YAML definitions I can find on the forums, and tonight I added a loader for them. With the exception of the Christmas and Group scenes I can render them all, which is really neat.

I rendered reflect-refract.yml and it looks very close to the reference image. The upper left section of the foreground green sphere is a bit washed out compared to the reference, but there's also jpg artefacts in that area on the reference so I can't get a feel of why it's like this. Need to do some more digging just in case, but it does look like everything is working nicely... my sample scenes just suck in comparison to other peoples



I also noticed I had strange single pixel artefacts periodically on the ends of open shapes in the cylinders.yml scene. Given that I also have an issue with cones rendering with artefacts, and I derived that shape from the cylinder I must have mucked something up there so I'll do some more poking here to, hopefully I'll find and resolve the error without having to write another post.

My crap imagination for creating decent sample scenes aside, this book has probably been the most fun technical book to "read" I've ever had. While there's likely no way under the sun I could have done this without the copious pseudo code, the test driven nature meant I learned more than I would have had I just read it. I had doubted that I would get the point where I could render Appendix I (maths is hard!) but tonight I proved myself wrong. I hope you do other similar books in future

Regards;
Richard Moss