/**
* Get the radiance seen through a particular pixel
*
* @param istate intersection state for ray tracing
* @param rx pixel x coordinate
* @param ry pixel y coordinate
* @param lensU DOF sampling variable
* @param lensV DOF sampling variable
* @param time motion blur sampling variable
* @param instance QMC instance seed
* @return a shading state for the intersected primitive, or
* <code>null</code> if nothing is seen through the specifieFd
* point
*/
public ShadingState getRadiance(IntersectionState istate, float rx, float ry, double lensU, double lensV, double time, int instance)
{
if (bakingPrimitives == null)
{
Ray r = camera.getRay(rx, ry, imageWidth, imageHeight, lensU, lensV, time);
return(r != null?lightServer.getRadiance(rx, ry, instance, r, istate) : null);
}
else
{
Ray r = new Ray(rx / imageWidth, ry / imageHeight, -1, 0, 0, 1);
traceBake(r, istate);
if (!istate.hit())
{
return(null);
}
ShadingState state = ShadingState.createState(istate, rx, ry, r, instance, lightServer);
bakingPrimitives.prepareShadingState(state);
if (bakingViewDependent)
{
state.setRay(camera.getRay(state.getPoint()));
}
else
{
Point3 p = state.getPoint();
Vector3 n = state.getNormal();
// create a ray coming from directly above the point being
// shaded
Ray incoming = new Ray(p.x + n.x, p.y + n.y, p.z + n.z, -n.x, -n.y, -n.z);
incoming.setMax(1);
state.setRay(incoming);
}
lightServer.shadeBakeResult(state);
return(state);
}
}
public ShadingState traceFinalGather(ShadingState previous, Ray r, int i)
{
if (previous.getDiffuseDepth() >= maxDiffuseDepth)
{
return(null);
}
IntersectionState istate = previous.getIntersectionState();
scene.trace(r, istate);
return(istate.hit() ? ShadingState.createFinalGatherState(previous, r, i) : null);
}
public Color traceRefraction(ShadingState previous, Ray r, int i)
{
// limit path depth and disable caustic paths
if (previous.getRefractionDepth() >= maxRefractionDepth || previous.getDiffuseDepth() > 0)
{
return(Color.BLACK);
}
IntersectionState istate = previous.getIntersectionState();
scene.trace(r, istate);
return(istate.hit() ? shadeHit(ShadingState.createRefractionBounceState(previous, r, i)) : Color.BLACK);
}
public void Run()
{
ByteUtil.InitByteUtil();
IntersectionState istate = new IntersectionState();
for (int i = start; i < end; i++)
{
lock (lockObj)
{
UI.taskUpdate(server.photonCounter);
server.photonCounter++;
if (UI.taskCanceled())
{
return;
}
}
int qmcI = i + seed;
double rand = QMC.halton(0, qmcI) * histogram[histogram.Length - 1];
int j = 0;
while (rand >= histogram[j] && j < histogram.Length)
{
j++;
}
// make sure we didn't pick a zero-probability light
if (j == histogram.Length)
{
continue;
}
double randX1 = (j == 0) ? rand / histogram[0] : (rand - histogram[j]) / (histogram[j] - histogram[j - 1]);
double randY1 = QMC.halton(1, qmcI);
double randX2 = QMC.halton(2, qmcI);
double randY2 = QMC.halton(3, qmcI);
Point3 pt = new Point3();
Vector3 dir = new Vector3();
Color power = new Color();
server.lights[j].getPhoton(randX1, randY1, randX2, randY2, pt, dir, power);
power.mul(scale);
Ray r = new Ray(pt, dir);
server.scene.trace(r, istate);
if (istate.hit())
{
server.shadePhoton(ShadingState.createPhotonState(r, istate, qmcI, map, server), power);
}
}
}
public ShadingState getRadiance(float rx, float ry, int i, Ray r, IntersectionState istate)
{
lock (lockObj)
{
scene.trace(r, istate);
if (istate.hit())
{
ShadingState state = ShadingState.createState(istate, rx, ry, r, i, this);
state.getInstance().prepareShadingState(state);
IShader shader = getShader(state);
if (shader == null)
{
state.setResult(Color.BLACK);
return(state);
}
if (_shadingCache != null)
{
Color c = lookupShadingCache(state, shader);
if (c != null)
{
state.setResult(c);
return(state);
}
}
state.setResult(shader.getRadiance(state));
if (_shadingCache != null)
{
addShadingCache(state, shader, state.getResult());
}
return(state);
}
else
{
return(null);
}
}
}
public ShadingState getRadiance(float rx, float ry, float time, int i, int d, Ray r, IntersectionState istate, ShadingCache cache)
{
istate.time = time;
scene.trace(r, istate);
if (istate.hit())
{
ShadingState state = ShadingState.createState(istate, rx, ry, time, r, i, d, this);
state.getInstance().prepareShadingState(state);
IShader shader = getShader(state);
if (shader == null)
{
state.setResult(Color.BLACK);
return(state);
}
if (cache != null)
{
Color c = cache.lookup(state, shader);
if (c != null)
{
state.setResult(c);
return(state);
}
}
state.setResult(shader.GetRadiance(state));
if (cache != null)
{
cache.add(state, shader, state.getResult());
}
checkNanInf(state.getResult());
return(state);
}
else
{
return(null);
}
}
public void Run()
{
ByteUtil.InitByteUtil();
IntersectionState istate = new IntersectionState();
for (int i = start; i < end; i++)
{
lock (lockObj)
{
UI.taskUpdate(server.photonCounter);
server.photonCounter++;
if (UI.taskCanceled())
return;
}
int qmcI = i + seed;
double rand = QMC.halton(0, qmcI) * histogram[histogram.Length - 1];
int j = 0;
while (rand >= histogram[j] && j < histogram.Length)
j++;
// make sure we didn't pick a zero-probability light
if (j == histogram.Length)
continue;
double randX1 = (j == 0) ? rand / histogram[0] : (rand - histogram[j]) / (histogram[j] - histogram[j - 1]);
double randY1 = QMC.halton(1, qmcI);
double randX2 = QMC.halton(2, qmcI);
double randY2 = QMC.halton(3, qmcI);
Point3 pt = new Point3();
Vector3 dir = new Vector3();
Color power = new Color();
server.lights[j].getPhoton(randX1, randY1, randX2, randY2, pt, dir, power);
power.mul(scale);
Ray r = new Ray(pt, dir);
server.scene.trace(r, istate);
if (istate.hit())
server.shadePhoton(ShadingState.createPhotonState(r, istate, qmcI, map, server), power);
}
}
public ShadingState getRadiance(float rx, float ry, float time, int i, int d, Ray r, IntersectionState istate, ShadingCache cache)
{
istate.time = time;
scene.trace(r, istate);
if (istate.hit()) {
ShadingState state = ShadingState.createState(istate, rx, ry, time, r, i, d, this);
state.getInstance().prepareShadingState(state);
IShader shader = getShader(state);
if (shader == null) {
state.setResult(Color.BLACK);
return state;
}
if (cache != null) {
Color c = cache.lookup(state, shader);
if (c != null) {
state.setResult(c);
return state;
}
}
state.setResult(shader.GetRadiance(state));
if (cache != null)
cache.add(state, shader, state.getResult());
checkNanInf(state.getResult());
return state;
} else
return null;
}
public void intersect(Ray r, IntersectionState state)
{
float intervalMin = r.getMin();
float intervalMax = r.getMax();
float orgX = r.ox;
float dirX = r.dx, invDirX = 1 / dirX;
float t1, t2;
t1 = (bounds.getMinimum().x - orgX) * invDirX;
t2 = (bounds.getMaximum().x - orgX) * invDirX;
if (invDirX > 0)
{
if (t1 > intervalMin)
intervalMin = t1;
if (t2 < intervalMax)
intervalMax = t2;
}
else
{
if (t2 > intervalMin)
intervalMin = t2;
if (t1 < intervalMax)
intervalMax = t1;
}
if (intervalMin > intervalMax)
return;
float orgY = r.oy;
float dirY = r.dy, invDirY = 1 / dirY;
t1 = (bounds.getMinimum().y - orgY) * invDirY;
t2 = (bounds.getMaximum().y - orgY) * invDirY;
if (invDirY > 0)
{
if (t1 > intervalMin)
intervalMin = t1;
if (t2 < intervalMax)
intervalMax = t2;
}
else
{
if (t2 > intervalMin)
intervalMin = t2;
if (t1 < intervalMax)
intervalMax = t1;
}
if (intervalMin > intervalMax)
return;
float orgZ = r.oz;
float dirZ = r.dz, invDirZ = 1 / dirZ;
t1 = (bounds.getMinimum().z - orgZ) * invDirZ;
t2 = (bounds.getMaximum().z - orgZ) * invDirZ;
if (invDirZ > 0)
{
if (t1 > intervalMin)
intervalMin = t1;
if (t2 < intervalMax)
intervalMax = t2;
}
else
{
if (t2 > intervalMin)
intervalMin = t2;
if (t1 < intervalMax)
intervalMax = t1;
}
if (intervalMin > intervalMax)
return;
// box is hit at [intervalMin, intervalMax]
orgX += intervalMin * dirX;
orgY += intervalMin * dirY;
orgZ += intervalMin * dirZ;
// locate starting point inside the grid
// and set up 3D-DDA vars
int indxX, indxY, indxZ;
int stepX, stepY, stepZ;
int stopX, stopY, stopZ;
float deltaX, deltaY, deltaZ;
float tnextX, tnextY, tnextZ;
// stepping factors along X
indxX = (int)((orgX - bounds.getMinimum().x) * invVoxelwx);
if (indxX < 0)
indxX = 0;
else if (indxX >= nx)
indxX = nx - 1;
if (Math.Abs(dirX) < 1e-6f)
{
stepX = 0;
stopX = indxX;
deltaX = 0;
tnextX = float.PositiveInfinity;
}
else if (dirX > 0)
{
stepX = 1;
stopX = nx;
deltaX = voxelwx * invDirX;
tnextX = intervalMin + ((indxX + 1) * voxelwx + bounds.getMinimum().x - orgX) * invDirX;
}
else
{
stepX = -1;
stopX = -1;
deltaX = -voxelwx * invDirX;
tnextX = intervalMin + (indxX * voxelwx + bounds.getMinimum().x - orgX) * invDirX;
}
// stepping factors along Y
indxY = (int)((orgY - bounds.getMinimum().y) * invVoxelwy);
if (indxY < 0)
indxY = 0;
else if (indxY >= ny)
indxY = ny - 1;
if (Math.Abs(dirY) < 1e-6f)
{
stepY = 0;
stopY = indxY;
deltaY = 0;
tnextY = float.PositiveInfinity;
}
else if (dirY > 0)
{
stepY = 1;
stopY = ny;
deltaY = voxelwy * invDirY;
tnextY = intervalMin + ((indxY + 1) * voxelwy + bounds.getMinimum().y - orgY) * invDirY;
}
else
{
stepY = -1;
stopY = -1;
deltaY = -voxelwy * invDirY;
tnextY = intervalMin + (indxY * voxelwy + bounds.getMinimum().y - orgY) * invDirY;
}
// stepping factors along Z
indxZ = (int)((orgZ - bounds.getMinimum().z) * invVoxelwz);
if (indxZ < 0)
indxZ = 0;
else if (indxZ >= nz)
indxZ = nz - 1;
if (Math.Abs(dirZ) < 1e-6f)
{
stepZ = 0;
stopZ = indxZ;
deltaZ = 0;
tnextZ = float.PositiveInfinity;
}
else if (dirZ > 0)
{
stepZ = 1;
stopZ = nz;
deltaZ = voxelwz * invDirZ;
tnextZ = intervalMin + ((indxZ + 1) * voxelwz + bounds.getMinimum().z - orgZ) * invDirZ;
}
else
{
stepZ = -1;
stopZ = -1;
deltaZ = -voxelwz * invDirZ;
tnextZ = intervalMin + (indxZ * voxelwz + bounds.getMinimum().z - orgZ) * invDirZ;
}
int cellstepX = stepX;
int cellstepY = stepY * nx;
int cellstepZ = stepZ * ny * nx;
int cell = indxX + indxY * nx + indxZ * ny * nx;
// trace through the grid
for (; ; )
{
if (tnextX < tnextY && tnextX < tnextZ)
{
if (cells[cell] != null)
{
foreach (int i in cells[cell])
primitives.intersectPrimitive(r, i, state);
if (state.hit() && (r.getMax() < tnextX && r.getMax() < intervalMax))
return;
}
intervalMin = tnextX;
if (intervalMin > intervalMax)
return;
indxX += stepX;
if (indxX == stopX)
return;
tnextX += deltaX;
cell += cellstepX;
}
else if (tnextY < tnextZ)
{
if (cells[cell] != null)
{
foreach (int i in cells[cell])
primitives.intersectPrimitive(r, i, state);
if (state.hit() && (r.getMax() < tnextY && r.getMax() < intervalMax))
return;
}
intervalMin = tnextY;
if (intervalMin > intervalMax)
return;
indxY += stepY;
if (indxY == stopY)
return;
tnextY += deltaY;
cell += cellstepY;
}
else
{
if (cells[cell] != null)
{
foreach (int i in cells[cell])
primitives.intersectPrimitive(r, i, state);
if (state.hit() && (r.getMax() < tnextZ && r.getMax() < intervalMax))
return;
}
intervalMin = tnextZ;
if (intervalMin > intervalMax)
return;
indxZ += stepZ;
if (indxZ == stopZ)
return;
tnextZ += deltaZ;
cell += cellstepZ;
}
}
}
public ShadingState getRadiance(float rx, float ry, int i, Ray r, IntersectionState istate)
{
lock (lockObj)
{
scene.trace(r, istate);
if (istate.hit())
{
ShadingState state = ShadingState.createState(istate, rx, ry, r, i, this);
state.getInstance().prepareShadingState(state);
IShader shader = getShader(state);
if (shader == null)
{
state.setResult(Color.BLACK);
return state;
}
if (_shadingCache != null)
{
Color c = lookupShadingCache(state, shader);
if (c != null)
{
state.setResult(c);
return state;
}
}
state.setResult(shader.getRadiance(state));
if (_shadingCache != null)
addShadingCache(state, shader, state.getResult());
return state;
}
else
return null;
}
}
public Color traceShadow(Ray r, IntersectionState state)
{
trace(r, state);
return state.hit() ? Color.WHITE : Color.BLACK;
}
/**
* Get the radiance seen through a particular pixel
*
* @param istate intersection state for ray tracing
* @param rx pixel x coordinate
* @param ry pixel y coordinate
* @param lensU DOF sampling variable
* @param lensV DOF sampling variable
* @param time motion blur sampling variable
* @param instance QMC instance seed
* @return a shading state for the intersected primitive, or
* <code>null</code> if nothing is seen through the specifieFd
* point
*/
public ShadingState getRadiance(IntersectionState istate, float rx, float ry, double lensU, double lensV, double time, int instance)
{
if (bakingPrimitives == null)
{
Ray r = camera.getRay(rx, ry, imageWidth, imageHeight, lensU, lensV, time);
return r != null ? lightServer.getRadiance(rx, ry, instance, r, istate) : null;
}
else
{
Ray r = new Ray(rx / imageWidth, ry / imageHeight, -1, 0, 0, 1);
traceBake(r, istate);
if (!istate.hit())
return null;
ShadingState state = ShadingState.createState(istate, rx, ry, r, instance, lightServer);
bakingPrimitives.prepareShadingState(state);
if (bakingViewDependent)
state.setRay(camera.getRay(state.getPoint()));
else
{
Point3 p = state.getPoint();
Vector3 n = state.getNormal();
// create a ray coming from directly above the point being
// shaded
Ray incoming = new Ray(p.x + n.x, p.y + n.y, p.z + n.z, -n.x, -n.y, -n.z);
incoming.setMax(1);
state.setRay(incoming);
}
lightServer.shadeBakeResult(state);
return state;
}
}
public Color traceShadow(Ray r, IntersectionState state)
{
state.numShadowRays++;
trace(r, state);
return(state.hit() ? Color.WHITE : Color.BLACK);
}
