PathTracer.java

/* Copyright (c) 2013 Jesper Öqvist <jesper@llbit.se>
 *
 * This file is part of Chunky.
 *
 * Chunky is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Chunky is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with Chunky.  If not, see <http://www.gnu.org/licenses/>.
 */
package se.llbit.chunky.renderer.scene;

import java.util.Random;

import org.apache.commons.math3.util.FastMath;

import se.llbit.chunky.model.WaterModel;
import se.llbit.chunky.renderer.WorkerState;
import se.llbit.chunky.world.Block;
import se.llbit.math.QuickMath;
import se.llbit.math.Ray;
import se.llbit.math.Vector3d;
import se.llbit.math.Vector4d;

/**
 * Static methods for path tracing
 *
 * @author Jesper Öqvist <jesper@llbit.se>
 */
public class PathTracer {

	/**
	 * Path trace the ray
	 * @param scene
	 * @param state
	 */
	public static final void pathTrace(Scene scene, WorkerState state) {
		pathTrace(scene, state.ray, state, 1, true);
	}

	/**
	 * Path trace the ray in this scene
	 * @param scene
	 * @param state
	 * @param addEmitted
	 * @param first
	 */
	public static final void pathTrace(Scene scene, Ray ray, WorkerState state,
			int addEmitted, boolean first) {

		Random random = state.random;
		Ray reflected = state.rayPool.get();
		Ray transmitted = state.rayPool.get();
		Ray refracted = state.rayPool.get();
		Vector3d ox = state.vectorPool.get(ray.x);
		Vector3d od = state.vectorPool.get(ray.d);
		double s = 0;

		while (true) {

			if (!RayTracer.nextIntersection(scene, ray, state)) {
				if (ray.depth == 0) {
					// direct sky hit
					scene.sky.getSkyColorInterpolated(ray, scene.waterHeight > 0);

				} else if (ray.specular) {
					// sky color
					scene.sky.getSkySpecularColor(ray, scene.waterHeight > 0);
				} else {
					scene.sky.getSkyColor(ray, scene.waterHeight > 0);
				}
				break;
			}

			double pSpecular = 0;

			Block currentBlock = ray.getCurrentBlock();
			Block prevBlock = ray.getPrevBlock();

			if (!scene.stillWater && ray.n.y != 0 &&
					((currentBlock == Block.WATER && prevBlock == Block.AIR) ||
					(currentBlock == Block.AIR && prevBlock == Block.WATER))) {

				WaterModel.doWaterDisplacement(ray);

				if (currentBlock == Block.AIR) {
					ray.n.y = -ray.n.y;
				}
			}

			if (currentBlock.isShiny) {
				if (currentBlock == Block.WATER) {
					pSpecular = Scene.WATER_SPECULAR;
				} else {
					pSpecular = Scene.SPECULAR_COEFF;
				}
			}

			double pDiffuse = ray.color.w;

			float n1 = prevBlock.ior;
			float n2 = currentBlock.ior;

			if (pDiffuse + pSpecular < Ray.EPSILON && n1 == n2)
				continue;

			if (first) {
				s = ray.distance;
				first = false;
			}

			if (currentBlock.isShiny &&
					random.nextDouble() < pSpecular) {

				reflected.specularReflection(ray);

				if (!scene.kill(reflected, random)) {
					pathTrace(scene, reflected, state, 1, false);
					if (reflected.hit) {
						ray.color.x *= reflected.color.x;
						ray.color.y *= reflected.color.y;
						ray.color.z *= reflected.color.z;
						ray.hit = true;
					}
				}

			} else {

				if (random.nextDouble() < pDiffuse) {

					reflected.set(ray);
					if (!scene.kill(reflected, random)) {

						double emittance = 0;

						if (scene.emittersEnabled && currentBlock.isEmitter) {

							emittance = addEmitted;
							ray.emittance.x = ray.color.x * ray.color.x *
									currentBlock.emittance * scene.emitterIntensity;
							ray.emittance.y = ray.color.y * ray.color.y *
									currentBlock.emittance * scene.emitterIntensity;
							ray.emittance.z = ray.color.z * ray.color.z *
									currentBlock.emittance * scene.emitterIntensity;
							ray.hit = true;
						}

						if (scene.sunEnabled) {
							scene.sun.getRandomSunDirection(reflected, random, state.vectorPool);

							double directLightR = 0;
							double directLightG = 0;
							double directLightB = 0;

							boolean frontLight = reflected.d.dot(ray.n) > 0;

							if (frontLight || (currentBlock.subSurfaceScattering &&
									random.nextDouble() < Scene.fSubSurface)) {

								if (!frontLight) {
									reflected.x.scaleAdd(-Ray.OFFSET, ray.n, reflected.x);
								}

								reflected.currentMaterial = ray.prevMaterial;

								getDirectLightAttenuation(scene, reflected, state);

								Vector4d attenuation = state.attenuation;
								if (attenuation.w > 0) {
									double mult = QuickMath.abs(reflected.d.dot(ray.n));
									directLightR = attenuation.x*attenuation.w * mult;
									directLightG = attenuation.y*attenuation.w * mult;
									directLightB = attenuation.z*attenuation.w * mult;
									ray.hit = true;
								}
							}

							reflected.diffuseReflection(ray, random);
							pathTrace(scene, reflected, state, 0, false);
							ray.hit = ray.hit || reflected.hit;
							if (ray.hit) {
								ray.color.x = ray.color.x
									* (emittance + directLightR * scene.sun.emittance.x
										+ (reflected.color.x + reflected.emittance.x));
								ray.color.y = ray.color.y
									* (emittance + directLightG * scene.sun.emittance.y
										+ (reflected.color.y + reflected.emittance.y));
								ray.color.z = ray.color.z
									* (emittance + directLightB * scene.sun.emittance.z
										+ (reflected.color.z + reflected.emittance.z));
							}

						} else {
							reflected.diffuseReflection(ray, random);

							pathTrace(scene, reflected, state, 0, false);
							ray.hit = ray.hit || reflected.hit;
							if (ray.hit) {
								ray.color.x = ray.color.x
									* (emittance + (reflected.color.x + reflected.emittance.x));
								ray.color.y = ray.color.y
									* (emittance + (reflected.color.y + reflected.emittance.y));
								ray.color.z = ray.color.z
									* (emittance + (reflected.color.z + reflected.emittance.z));
							}
						}
					}
				} else if (n1 != n2) {

					boolean doRefraction =
							currentBlock == Block.WATER ||
							prevBlock == Block.WATER ||
							currentBlock == Block.ICE ||
							prevBlock == Block.ICE;

					// refraction
					float n1n2 = n1 / n2;
					double cosTheta = - ray.n.dot(ray.d);
					double radicand = 1 - n1n2*n1n2 * (1 - cosTheta*cosTheta);
					if (doRefraction && radicand < Ray.EPSILON) {
						// total internal reflection
						reflected.specularReflection(ray);
						if (!scene.kill(reflected, random)) {
							pathTrace(scene, reflected, state, 1, false);
							if (reflected.hit) {

								ray.color.x = reflected.color.x;
								ray.color.y = reflected.color.y;
								ray.color.z = reflected.color.z;
								ray.hit = true;
							}
						}
					} else {
						refracted.set(ray);
						if (!scene.kill(refracted, random)) {

							// Calculate angle-dependent reflectance using
							// Fresnel equation approximation
							// R(theta) = R0 + (1 - R0) * (1 - cos(theta))^5
							float a = (n1n2 - 1);
							float b = (n1n2 + 1);
							double R0 = a*a/(b*b);
							double c = 1 - cosTheta;
							double Rtheta = R0 + (1-R0) * c*c*c*c*c;

							if (random.nextDouble() < Rtheta) {
								reflected.specularReflection(ray);
								pathTrace(scene, reflected, state, 1, false);
								if (reflected.hit) {
									ray.color.x = reflected.color.x;
									ray.color.y = reflected.color.y;
									ray.color.z = reflected.color.z;
									ray.hit = true;
								}
							} else {
								if (doRefraction) {

									double t2 = FastMath.sqrt(radicand);
									if (cosTheta > 0) {
										refracted.d.x = n1n2*ray.d.x + (n1n2*cosTheta - t2)*ray.n.x;
										refracted.d.y = n1n2*ray.d.y + (n1n2*cosTheta - t2)*ray.n.y;
										refracted.d.z = n1n2*ray.d.z + (n1n2*cosTheta - t2)*ray.n.z;
									} else {
										refracted.d.x = n1n2*ray.d.x - (-n1n2*cosTheta - t2)*ray.n.x;
										refracted.d.y = n1n2*ray.d.y - (-n1n2*cosTheta - t2)*ray.n.y;
										refracted.d.z = n1n2*ray.d.z - (-n1n2*cosTheta - t2)*ray.n.z;
									}

									refracted.d.normalize();

									refracted.x.scaleAdd(Ray.OFFSET,
											refracted.d, refracted.x);
								}

								pathTrace(scene, refracted, state, 1, false);
								if (refracted.hit) {
									ray.color.x = ray.color.x * pDiffuse + (1-pDiffuse);
									ray.color.y = ray.color.y * pDiffuse + (1-pDiffuse);
									ray.color.z = ray.color.z * pDiffuse + (1-pDiffuse);
									ray.color.x *= refracted.color.x;
									ray.color.y *= refracted.color.y;
									ray.color.z *= refracted.color.z;
									ray.hit = true;
								}
							}
						}
					}

				} else {

					transmitted.set(ray);
					transmitted.x.scaleAdd(Ray.OFFSET, transmitted.d,
							transmitted.x);

					pathTrace(scene, transmitted, state, 1, false);
					if (transmitted.hit) {
						ray.color.x = ray.color.x * pDiffuse + (1-pDiffuse);
						ray.color.y = ray.color.y * pDiffuse + (1-pDiffuse);
						ray.color.z = ray.color.z * pDiffuse + (1-pDiffuse);
						ray.color.x *= transmitted.color.x;
						ray.color.y *= transmitted.color.y;
						ray.color.z *= transmitted.color.z;
						ray.hit = true;
					}
				}
			}

			// do water fog
			if (!scene.clearWater && prevBlock == Block.WATER) {
				double a = ray.distance / scene.waterVisibility;
				double attenuation = 1 - QuickMath.min(1, a*a);
				ray.color.scale(attenuation);
				/*ray.color.x *= attenuation;
				ray.color.y *= attenuation;
				ray.color.z *= attenuation;
				float[] wc = Texture.water.getAvgColorLinear();
				ray.color.x += (1-attenuation) * wc[0];
				ray.color.y += (1-attenuation) * wc[1];
				ray.color.z += (1-attenuation) * wc[2];
				ray.color.w = attenuation;*/
				ray.hit = true;
			}

			break;
		}
		if (!ray.hit) {
			ray.color.set(0, 0, 0, 1);
			if (first)
				s = ray.distance;
		}

		if (s > 0) {

			if (scene.atmosphereEnabled) {
				double Fex = scene.sun.extinction(s);
				ray.color.x *= Fex;
				ray.color.y *= Fex;
				ray.color.z *= Fex;

				if (!scene.volumetricFogEnabled) {
					double Fin = scene.sun.inscatter(Fex, scene.sun.theta(ray.d));

					ray.color.x += Fin * scene.sun.emittance.x * scene.sun.getIntensity();
					ray.color.y += Fin * scene.sun.emittance.y * scene.sun.getIntensity();
					ray.color.z += Fin * scene.sun.emittance.z * scene.sun.getIntensity();
				}
			}

			if (scene.volumetricFogEnabled) {
				s = (s - Ray.OFFSET) * random.nextDouble();

				reflected.x.scaleAdd(s, od, ox);
				scene.sun.getRandomSunDirection(reflected, random, state.vectorPool);
				reflected.currentMaterial = 0;

				getDirectLightAttenuation(scene, reflected, state);
				Vector4d attenuation = state.attenuation;

				double Fex = scene.sun.extinction(s);
				double Fin = scene.sun.inscatter(Fex, scene.sun.theta(ray.d));

				ray.color.x += 50 * attenuation.x*attenuation.w * Fin * scene.sun.emittance.x * scene.sun.getIntensity();
				ray.color.y += 50 * attenuation.y*attenuation.w * Fin * scene.sun.emittance.y * scene.sun.getIntensity();
				ray.color.z += 50 * attenuation.z*attenuation.w * Fin * scene.sun.emittance.z * scene.sun.getIntensity();
			}
		}

		state.rayPool.dispose(reflected);
		state.rayPool.dispose(transmitted);
		state.rayPool.dispose(refracted);
		state.vectorPool.dispose(ox);
		state.vectorPool.dispose(od);
	}

	/**
	 * Calculate direct lighting attenuation
	 * @param scene
	 * @param ray
	 * @param state
	 */
	public static final void getDirectLightAttenuation(Scene scene, Ray ray,
			WorkerState state) {

		Vector4d attenuation = state.attenuation;
		attenuation.x = 1;
		attenuation.y = 1;
		attenuation.z = 1;
		attenuation.w = 1;
		boolean b = false;
		while (attenuation.w > 0) {
			ray.x.scaleAdd(Ray.OFFSET,
					ray.d, ray.x);
			if (!RayTracer.nextIntersection(scene, ray, state))
				break;
			double mult = 1 - ray.color.w;
			attenuation.x *= ray.color.x * ray.color.w + mult;
			attenuation.y *= ray.color.y * ray.color.w + mult;
			attenuation.z *= ray.color.z * ray.color.w + mult;
			attenuation.w *= mult;
			if (!scene.clearWater && ray.getPrevBlock() == Block.WATER) {
				double a = ray.distance / scene.waterVisibility;
				attenuation.w *= 1 - QuickMath.min(1, a*a);
			}
		}
	}

}