Hello,

i spent the last 24h finding out why my code is not working (image is just black).

I am especially confused by the way of generating rays from the camera into the scene because there are a lot of ways how it can be done (at least it looks like that for me) and i don't know which way is right for me.

So my ray generation looks like this:

double imageAspectRatio = cast(double)width / cast(double)height;
double Px = (2.0*((cast(double)x+0.5) / cast(double)width) - 1) * tan(45.0 / 2.0 * PI / 180.0) * imageAspectRatio;
double Py = (1.0 - 2.0 * ((cast(double)y + 0.5) / cast(double)height) * tan(45.0 / 2.0 * PI / 180.0));
Vector3D direction = new Vector3D(Px,Py,-1).normalize();
Ray r = new Ray(this.camera, direction);

I debugged my program and no ray hits a sphere in my scene ever! So i think the problem has to be correlated with the ray generation code (i am pretty sure my sphere intersection code is correct).

What's the range that `x` and `y` sweep?

x and y sweep both between 0 and 250 (size of the image)

On the formula i read online the '0.5' would be the 'u' and 'v' coordinates but i don't know how to calculate them...

Thank you very much for your help, i really appreciate it!

So i changed my Ray-generation code accordingly:

double fov = PI*0.25;
double aspect = cast(double)width / cast(double)height;
double fovFactor = tan(fov*0.5);
double rayX = (2.0*(cast(double)x+0.5)/cast(double)width) - 1.0;
double rayY = (2.0*(cast(double)y+0.5)/cast(double)height) - 1.0;
rayX *= fovFactor*aspect;
rayY *= fovFactor;
Vector3D direction = new Vector3D(rayX, rayY, -1).normalize();
Ray r = new Ray(this.camera, direction);

transform the ray into scene space, before you cast it!

How is this done?

The problem is that i don't have any raytracing source material because either i don't understand it (weird math signs) or it doesn't cover all aspects of the topic or it just doesn't work. Currently my camera is just the "world origin", so (0,0,0).

if the Ray constructor takes an origin position and a direction vector (as opposed to an origin position and a "towards" position)

I don't understand what the differences between those two are. But:

and it'll look really wierd

makes me assume that i should at least get an image if the ray-creation-code is correct? But it's still black and i don't get to the point where a ray intersects with a sphere. But what else could be wrong besides the part of ray-creation? I mean, this is my code for the sphere-intersection and it should be correct:

		Vector3D v = ray.origin.sub(this.center);
		double a = ray.direction.dot(ray.direction);
		double b = 2.0 * ray.direction.dot(v);
		double c = v.dot(v) - (this.radius * this.radius);
		double discriminant = (b*b) - (4.0*a*c);
		if(discriminant > 0.0){
			double x1 = (-b - sqrt(discriminant)) / (2.0*a);
			double x2 = (-b + sqrt(discriminant)) / (2.0*a);
			if((x1 >= 0.0) && (x2 >= 0.0)){
				return x1;
			}
			if((x1 < 0.0) && (x2 >= 0.0)){
				return x2;
			}
			return -1.0;
		} else{
			return -1.0;
		}

Also, stop using all those pointless mid-expression conversions.

Okay. I just want to make sure it is not rounded up.

If you fire a ray directly at the sphere (0,0,-1), can you make it work then?

Yes but obviously the whole image is one single color, here is my sphere:

Sphere(new Color(20,255,125), true, new Vector3D(0,0,-2), .5),

The Vector is the center and the '.5' is the radius.

Ray:

Ray r = new Ray(this.camera, new Vector3D(0,0,-1));

where 'this.camera' is the Vector(0,0,0)