Design.txt

So I'd like to make a simple ray tracer with these features:

- CPU
- "Interactive"
- Controllable Camera
- Sphere & Triangle intersections
- Emissive Materials / Area Lights
- Shadows
- Can easily plug in different diffuse models
- Light scattering
- Anti-Aliasing
- Specular highlights
- Refraction
- Metal & NonMetal materials

(for the next ray tracer):
- Accelerated spacial structures
- GPU/CUDA/RTX
- Realtime

Renderer
	render()
	traceRay()
	checkRayIntersection()

Scene
	geometry[]

Geometry
	position	]
	scale		|	transform matrix to transform primitives to world space
	rotation	]
	primatives[]
	bounding box

Primitive
	material

	virtual getNormal()

Box : Primitive
	bottom corner
	top corner

Sphere : Primitive
	scale		]
	position	]	transform matrix to transform unit sphere to local space

Triangle : Primitive
	vertices[3]

Material
	color
	rougness			// controls solid angle of reflection andis used in brdf
	
	emissonColor
	emissionStrength

	abstract redirect(direction, normal) => Direction
	abstract reflectionCoeff() => vec3

Metal : Material

	base reflectivity	// for Schlick(rgb)
	
	redirect()
		reflect

	reflectionCoeff()
		return base reflectivity

Dielectric : Material
	
	opacity					// controls probability of ray being reflected vs refracted
	index of refraction		// uses Schlick(ior1, ior2) (ideally)

	redirect()
		if rng < opacity // use opacity as probability of light refracting
			refract
		else
			reflect

	reflectionCoeff()
		return Schlick(ior)	// actually dont know how to implement use of an ior2

Ray Intersection
	ray*
	t
	intersection position
	surface normal

Math
	raySphereIntersection(Ray, Sphere) => Ray Intersection
	rayIntersection(Ray, Sphere) => Ray Intersection
	
	Intersection
	ray intersection*
	material*
	bool transmissive		// rays that transmitted don't reflect light for us to see

Camera
	pos				]
	rotation		]	view matrix
	up-dir
	forward-dir
	fov

Window
	buffer

Image
	width
	height
	pixels[]


render(Camera, Scene, Image)	// renders scene to Image
	for pixels in Image
		for rays per pixel
			calculate ray position and direction
			send it out	// traceRay()
			average colors


// cast ray out into scene, see where it goes, and determin color off that
traceRay(Ray, Scene) => Color
	
	hits[]

	for maxNumBounces
		check for intersection	// checkRayIntersection

		if ray hit
			append hit to hits
			
			position ray at intersection
			redirect based off material	// reflect or refract
		else
			break

	return evaluateLightPath from hits


// evaluates a path that light that did (or didnt) make it to the eye
evaluateLightPath(hits[]) => Color

	incoming light = black (0)

	if reached environment // if ray bounced off a surface and never hit anything after
		incoming light += environment light
	
	// start from last hit (whether there is any light there or not)
	// forward trace light ray, computing how light reflects and accumulates
	// off it bounces off each surface until making its way to eye
	reverse iterating hits
		if hit wasn't refractive
			incoming light += emitted light + incoming light * BRDF * cos(theta)

	return incoming light

BRDF(view dir, light dir, normal, material) => Color
	
	R0 = get reflectivity from material
	Ks = SchlickApprox(R0)

	diffuse = Lambert()

	specular = CookTorrance()

	// normal distribution function = GGX/Trowbridge-Reitz
	// geometry shading function = Schlick-GGX (uses Smith model's G and Schlick-Beckmann G1)  

	return Kd * diffuse + Ks * specular


checkRayIntersection(Ray, Scene) => Ray Intersection
	
	intersection = null

	for objects in geometry
		for primitive in object
			transform primitive into world space
			
			if sphere
				test = do ray-sphere intersection test
			if triangle
				test = do ray-triangle intersection test

			if test result is valid and closer than intersection
				intersection = test