Indirect/bounce lighting issues

[semagnum]

I'm currently working on a Java implementation using Maven. I'm surprised how I've been able to get away without using references - it's a pain to write sometimes, but it still works quite well. Lombok and abstraction keeps the classes clean. I plan to post it here when I finish all three courses.
I'm going through the Next Week course, but the lighting doesn't seem to catch enough indirect lighting. This was what I have at the end of the "Turning Objects into Lights" section:

It's almost like there's a flipped normal or ray somewhere, so it's only getting blown-out values at strange angles but nothing else. I haven't committed the lighting portion, but I've rewritten that section a few times and still get the same result. Here's the repo: https://github.com/semagnum/JavaRaytracing. It's committed up until the "Rectangles and Lights" section.

Any ideas on how to troubleshoot this issue?

[semagnum]

I made a branch and commit with my current lighting changes to get the picture above, for your convenience.

[trevordblack]

That's a new one...
I've not seen that in memory.

Uhhhh. Can you show us what it looks like at the end of Image Texture Mapping?

[semagnum]

Yeah, sure. Here's the textured Earth - matches the book pretty well, from what I can tell.

[semagnum]

Update: I tried adding the lighting to my commit of the "Ray Tracing in One Weekend" and still had the issue, so either I'm writing the light code badly every single time, or I have something wrong setup from the first book. Here's my final image from the first book, for reference:

[semagnum]

My theory is that something's wrong with my diffuse scattering - I changed the randomUnitVector() to randomInHemisphere() and seemed to get a little more bounce light on the main sphere.

@Getter
@AllArgsConstructor
public class DiffuseMaterial extends Material {
    private final Texture albedo;

    public DiffuseMaterial(Color color) {
        albedo = new SolidTexture(color);
    }

    public ScatterRecord scatter(Ray rIn, HitRecord hitRecord) {
//        Vector3 scatter_direction = hitRecord.getNormal().add(RandomUtil.randomUnitVector());
        Vector3 scatter_direction = hitRecord.getNormal().add(RandomUtil.randomInHemisphere(hitRecord.getNormal()));

        // Catch degenerate scatter direction
        if (scatter_direction.nearZero())
            scatter_direction = hitRecord.getNormal();

        Color attenuation = albedo.value(hitRecord.getUv().getU(), hitRecord.getUv().getV(), hitRecord.getP());

        Ray scattered = new Ray(hitRecord.getP(), scatter_direction, rIn.getTime());

        return new ScatterRecord(true, attenuation, scattered);
    }
}

...

private static Color rayColor(Ray r, Color background, Hittable world, int depth) {
        // If we've exceeded the ray bounce limit, no more light is gathered.
        if (depth <= 0)
            return new Color();

        // If the ray hits nothing, return the background color.
        HitRecord hitRecord = world.hit(r, 0.001, 100.0);
        if (hitRecord == null)
            return background;

        ScatterRecord scatterRecord = hitRecord.getMaterial().scatter(r, hitRecord);
        Ray scattered = scatterRecord.getScatterRay();
        Color attenuation = scatterRecord.getAttenuation();
        Color emitted = hitRecord.getMaterial().emitted(
                hitRecord.getUv().getU(), hitRecord.getUv().getV(), hitRecord.getP());

        if (!scatterRecord.isScattered())
            return emitted;

        return new Color (rayColor(scattered, background, world, depth-1).multiply(attenuation).add(emitted));
    }

[TKristof09]

Have you managed to find the issue? I'm having the same problem and can't seem to find the error in my code even after comparing it multiple times to the code in this git repo.

This is the image i'm getting, same weird area that gets lit up by the emissive rectangle as you have.

[semagnum]

Sadly, I never did get this figured out. Now that I think about it, I'm wondering if it has to do with the front/back face part of the collection, but otherwise I'm not sure. No one looked into this with me.

[TKristof09]

I thought about it being a problem with the direction the normals are facing on one of the meshes, but everything seems consistent with the normals facing outward, and then making them face opposite of the direction of the ray in the hit_record struct's function. I also tried switching the rectangle's normal's direction which didn't affect the resulting image (it seems weird to me though that it didn't affect anything, so there might actually be a problem with normals).
I will keep trying to figure it out, but I'm really running out of ideas on what it could be