public void intersectPrimitive(Ray r, int primID, IntersectionState state)
{
float uv00 = 0, uv01 = 0, uv10 = 0, uv11 = 0, uv20 = 0, uv21 = 0;
switch (triangleMesh.uvs.interp)
{
case ParameterList.InterpolationType.NONE:
case ParameterList.InterpolationType.FACE:
default:
return;
case ParameterList.InterpolationType.VERTEX:
{
int tri = 3 * primID;
int index0 = triangleMesh.triangles[tri + 0];
int index1 = triangleMesh.triangles[tri + 1];
int index2 = triangleMesh.triangles[tri + 2];
int i20 = 2 * index0;
int i21 = 2 * index1;
int i22 = 2 * index2;
float[] uvs = triangleMesh.uvs.data;
uv00 = uvs[i20 + 0];
uv01 = uvs[i20 + 1];
uv10 = uvs[i21 + 0];
uv11 = uvs[i21 + 1];
uv20 = uvs[i22 + 0];
uv21 = uvs[i22 + 1];
break;
}
case ParameterList.InterpolationType.FACEVARYING:
{
int idx = (3 * primID) << 1;
float[] uvs = triangleMesh.uvs.data;
uv00 = uvs[idx + 0];
uv01 = uvs[idx + 1];
uv10 = uvs[idx + 2];
uv11 = uvs[idx + 3];
uv20 = uvs[idx + 4];
uv21 = uvs[idx + 5];
break;
}
}
double edge1x = uv10 - uv00;
double edge1y = uv11 - uv01;
double edge2x = uv20 - uv00;
double edge2y = uv21 - uv01;
double pvecx = r.dy * 0 - r.dz * edge2y;
double pvecy = r.dz * edge2x - r.dx * 0;
double pvecz = r.dx * edge2y - r.dy * edge2x;
double qvecx, qvecy, qvecz;
double u, v;
double det = edge1x * pvecx + edge1y * pvecy + 0 * pvecz;
if (det > 0)
{
double tvecx = r.ox - uv00;
double tvecy = r.oy - uv01;
double tvecz = r.oz;
u = (tvecx * pvecx + tvecy * pvecy + tvecz * pvecz);
if (u < 0.0 || u > det)
return;
qvecx = tvecy * 0 - tvecz * edge1y;
qvecy = tvecz * edge1x - tvecx * 0;
qvecz = tvecx * edge1y - tvecy * edge1x;
v = (r.dx * qvecx + r.dy * qvecy + r.dz * qvecz);
if (v < 0.0 || u + v > det)
return;
}
else if (det < 0)
{
double tvecx = r.ox - uv00;
double tvecy = r.oy - uv01;
double tvecz = r.oz;
u = (tvecx * pvecx + tvecy * pvecy + tvecz * pvecz);
if (u > 0.0 || u < det)
return;
qvecx = tvecy * 0 - tvecz * edge1y;
qvecy = tvecz * edge1x - tvecx * 0;
qvecz = tvecx * edge1y - tvecy * edge1x;
v = (r.dx * qvecx + r.dy * qvecy + r.dz * qvecz);
if (v > 0.0 || u + v < det)
return;
}
else
return;
double inv_det = 1.0 / det;
float t = (float)((edge2x * qvecx + edge2y * qvecy + 0 * qvecz) * inv_det);
if (r.isInside(t))
{
r.setMax(t);
state.setIntersection(primID, (float)(u * inv_det), (float)(v * inv_det));
}
}
public void intersectPrimitive(Ray r, int primID, IntersectionState state)
{
float intervalMin = float.NegativeInfinity;
float intervalMax = float.PositiveInfinity;
float orgX = r.ox;
float invDirX = 1 / r.dx;
float t1, t2;
t1 = (minX - orgX) * invDirX;
t2 = (maxX - orgX) * invDirX;
int sideIn = -1, sideOut = -1;
if (invDirX > 0)
{
if (t1 > intervalMin)
{
intervalMin = t1;
sideIn = 0;
}
if (t2 < intervalMax)
{
intervalMax = t2;
sideOut = 1;
}
}
else
{
if (t2 > intervalMin)
{
intervalMin = t2;
sideIn = 1;
}
if (t1 < intervalMax)
{
intervalMax = t1;
sideOut = 0;
}
}
if (intervalMin > intervalMax)
return;
float orgY = r.oy;
float invDirY = 1 / r.dy;
t1 = (minY - orgY) * invDirY;
t2 = (maxY - orgY) * invDirY;
if (invDirY > 0)
{
if (t1 > intervalMin)
{
intervalMin = t1;
sideIn = 2;
}
if (t2 < intervalMax)
{
intervalMax = t2;
sideOut = 3;
}
}
else
{
if (t2 > intervalMin)
{
intervalMin = t2;
sideIn = 3;
}
if (t1 < intervalMax)
{
intervalMax = t1;
sideOut = 2;
}
}
if (intervalMin > intervalMax)
return;
float orgZ = r.oz;
float invDirZ = 1 / r.dz;
t1 = (minZ - orgZ) * invDirZ; // no front wall
t2 = (maxZ - orgZ) * invDirZ;
if (invDirZ > 0)
{
if (t1 > intervalMin)
{
intervalMin = t1;
sideIn = 4;
}
if (t2 < intervalMax)
{
intervalMax = t2;
sideOut = 5;
}
}
else
{
if (t2 > intervalMin)
{
intervalMin = t2;
sideIn = 5;
}
if (t1 < intervalMax)
{
intervalMax = t1;
sideOut = 4;
}
}
if (intervalMin > intervalMax)
return;
if (r.isInside(intervalMin))
{
r.setMax(intervalMin);
state.setIntersection(sideIn, 0, 0);
}
else if (r.isInside(intervalMax))
{
r.setMax(intervalMax);
state.setIntersection(sideOut, 0, 0);
}
}
private void intersectTriangleKensler(Ray r, int primID, IntersectionState state)
{
int tri = 3 * primID;
int a = 3 * triangles[tri + 0];
int b = 3 * triangles[tri + 1];
int c = 3 * triangles[tri + 2];
float edge0x = points[b + 0] - points[a + 0];
float edge0y = points[b + 1] - points[a + 1];
float edge0z = points[b + 2] - points[a + 2];
float edge1x = points[a + 0] - points[c + 0];
float edge1y = points[a + 1] - points[c + 1];
float edge1z = points[a + 2] - points[c + 2];
float nx = edge0y * edge1z - edge0z * edge1y;
float ny = edge0z * edge1x - edge0x * edge1z;
float nz = edge0x * edge1y - edge0y * edge1x;
float v = r.dot(nx, ny, nz);
float iv = 1 / v;
float edge2x = points[a + 0] - r.ox;
float edge2y = points[a + 1] - r.oy;
float edge2z = points[a + 2] - r.oz;
float va = nx * edge2x + ny * edge2y + nz * edge2z;
float t = iv * va;
if (!r.isInside(t))
return;
float ix = edge2y * r.dz - edge2z * r.dy;
float iy = edge2z * r.dx - edge2x * r.dz;
float iz = edge2x * r.dy - edge2y * r.dx;
float v1 = ix * edge1x + iy * edge1y + iz * edge1z;
float beta = iv * v1;
if (beta < 0)
return;
float v2 = ix * edge0x + iy * edge0y + iz * edge0z;
if ((v1 + v2) * v > v * v)
return;
float gamma = iv * v2;
if (gamma < 0)
return;
r.setMax(t);
state.setIntersection(primID, beta, gamma);
}
public void intersect(Ray r, int primID, IntersectionState state)
{
switch (k)
{
case 0:
{
float det = 1.0f / (r.dx + nu * r.dy + nv * r.dz);
float t = (nd - r.ox - nu * r.oy - nv * r.oz) * det;
if (!r.isInside(t))
return;
float hu = r.oy + t * r.dy;
float hv = r.oz + t * r.dz;
float u = hu * bnu + hv * bnv + bnd;
if (u < 0.0f)
return;
float v = hu * cnu + hv * cnv + cnd;
if (v < 0.0f)
return;
if (u + v > 1.0f)
return;
r.setMax(t);
state.setIntersection(primID, u, v);
return;
}
case 1:
{
float det = 1.0f / (r.dy + nu * r.dz + nv * r.dx);
float t = (nd - r.oy - nu * r.oz - nv * r.ox) * det;
if (!r.isInside(t))
return;
float hu = r.oz + t * r.dz;
float hv = r.ox + t * r.dx;
float u = hu * bnu + hv * bnv + bnd;
if (u < 0.0f)
return;
float v = hu * cnu + hv * cnv + cnd;
if (v < 0.0f)
return;
if (u + v > 1.0f)
return;
r.setMax(t);
state.setIntersection(primID, u, v);
return;
}
case 2:
{
float det = 1.0f / (r.dz + nu * r.dx + nv * r.dy);
float t = (nd - r.oz - nu * r.ox - nv * r.oy) * det;
if (!r.isInside(t))
return;
float hu = r.ox + t * r.dx;
float hv = r.oy + t * r.dy;
float u = hu * bnu + hv * bnv + bnd;
if (u < 0.0f)
return;
float v = hu * cnu + hv * cnv + cnd;
if (v < 0.0f)
return;
if (u + v > 1.0f)
return;
r.setMax(t);
state.setIntersection(primID, u, v);
return;
}
}
}
public void intersectPrimitive(Ray r, int primID, IntersectionState state)
{
// intersect with bounding sphere
float qc = ((r.ox * r.ox) + (r.oy * r.oy) + (r.oz * r.oz)) - BOUNDING_RADIUS2;
float qt = r.getMin();
if (qc > 0)
{
// we are starting outside the sphere, find intersection on the
// sphere
float qa = r.dx * r.dx + r.dy * r.dy + r.dz * r.dz;
float qb = 2 * ((r.dx * r.ox) + (r.dy * r.oy) + (r.dz * r.oz));
double[] t = Solvers.solveQuadric(qa, qb, qc);
// early rejection
if (t == null || t[0] >= r.getMax() || t[1] <= r.getMin())
return;
qt = (float)t[0];
}
float dist = float.PositiveInfinity;
float rox = r.ox + qt * r.dx;
float roy = r.oy + qt * r.dy;
float roz = r.oz + qt * r.dz;
float invRayLength = (float)(1 / Math.Sqrt(r.dx * r.dx + r.dy * r.dy + r.dz * r.dz));
// now we can start intersection
while (true)
{
float zw = rox;
float zx = roy;
float zy = roz;
float zz = 0;
float zpw = 1;
float zpx = 0;
float zpy = 0;
float zpz = 0;
// run several iterations
float dotz = 0;
for (int i = 0; i < maxIterations; i++)
{
{
// zp = 2 * (z * zp)
float nw = zw * zpw - zx * zpx - zy * zpy - zz * zpz;
float nx = zw * zpx + zx * zpw + zy * zpz - zz * zpy;
float ny = zw * zpy + zy * zpw + zz * zpx - zx * zpz;
zpz = 2 * (zw * zpz + zz * zpw + zx * zpy - zy * zpx);
zpw = 2 * nw;
zpx = 2 * nx;
zpy = 2 * ny;
}
{
// z = z*z + c
float nw = zw * zw - zx * zx - zy * zy - zz * zz + cw;
zx = 2 * zw * zx + cx;
zy = 2 * zw * zy + cy;
zz = 2 * zw * zz + cz;
zw = nw;
}
dotz = zw * zw + zx * zx + zy * zy + zz * zz;
if (dotz > ESCAPE_THRESHOLD)
break;
}
float normZ = (float)Math.Sqrt(dotz);
dist = 0.5f * normZ * (float)Math.Log(normZ) / Length(zpw, zpx, zpy, zpz);
rox += dist * r.dx;
roy += dist * r.dy;
roz += dist * r.dz;
qt += dist;
if (dist * invRayLength < epsilon)
break;
if (rox * rox + roy * roy + roz * roz > BOUNDING_RADIUS2)
return;
}
// now test t value again
if (!r.isInside(qt))
return;
if (dist * invRayLength < epsilon)
{
// valid hit
r.setMax(qt);
state.setIntersection(0, 0, 0);
}
}
public void intersectPrimitive(Ray r, int primID, IntersectionState state)
{
int hair = primID / numSegments;
int line = primID % numSegments;
int vRoot = hair * 3 * (numSegments + 1);
int v0 = vRoot + line * 3;
int v1 = v0 + 3;
float vx = points[v1 + 0] - points[v0 + 0];
float vy = points[v1 + 1] - points[v0 + 1];
float vz = points[v1 + 2] - points[v0 + 2];
float ux = r.dy * vz - r.dz * vy;
float uy = r.dz * vx - r.dx * vz;
float uz = r.dx * vy - r.dy * vx;
float nx = uy * vz - uz * vy;
float ny = uz * vx - ux * vz;
float nz = ux * vy - uy * vx;
float tden = 1 / (nx * r.dx + ny * r.dy + nz * r.dz);
float tnum = nx * (points[v0 + 0] - r.ox) + ny * (points[v0 + 1] - r.oy) + nz * (points[v0 + 2] - r.oz);
float t = tnum * tden;
if (r.isInside(t))
{
int vn = hair * (numSegments + 1) + line;
float px = r.ox + t * r.dx;
float py = r.oy + t * r.dy;
float pz = r.oz + t * r.dz;
float qx = px - points[v0 + 0];
float qy = py - points[v0 + 1];
float qz = pz - points[v0 + 2];
float q = (vx * qx + vy * qy + vz * qz) / (vx * vx + vy * vy + vz * vz);
if (q <= 0)
{
// don't included rounded tip at root
if (line == 0)
return;
float dx = points[v0 + 0] - px;
float dy = points[v0 + 1] - py;
float dz = points[v0 + 2] - pz;
float d2 = dx * dx + dy * dy + dz * dz;
float width = getWidth(vn);
if (d2 < (width * width * 0.25f))
{
r.setMax(t);
state.setIntersection(primID, 0, 0);
}
}
else if (q >= 1)
{
float dx = points[v1 + 0] - px;
float dy = points[v1 + 1] - py;
float dz = points[v1 + 2] - pz;
float d2 = dx * dx + dy * dy + dz * dz;
float width = getWidth(vn + 1);
if (d2 < (width * width * 0.25f))
{
r.setMax(t);
state.setIntersection(primID, 0, 1);
}
}
else
{
float dx = points[v0 + 0] + q * vx - px;
float dy = points[v0 + 1] + q * vy - py;
float dz = points[v0 + 2] + q * vz - pz;
float d2 = dx * dx + dy * dy + dz * dz;
float width = (1 - q) * getWidth(vn) + q * getWidth(vn + 1);
if (d2 < (width * width * 0.25f))
{
r.setMax(t);
state.setIntersection(primID, 0, q);
}
}
}
}
public void intersectPrimitive(Ray r, int primID, IntersectionState state)
{
// ray/bilinear patch intersection adapted from "Production Rendering:
// Design and Implementation" by Ian Stephenson (Ed.)
int quad = 4 * primID;
int p0 = 3 * quads[quad + 0];
int p1 = 3 * quads[quad + 1];
int p2 = 3 * quads[quad + 2];
int p3 = 3 * quads[quad + 3];
// transform patch into Hilbert space
float[] A = {
points[p2 + 0] - points[p3 + 0] - points[p1 + 0] + points[p0 + 0],
points[p2 + 1] - points[p3 + 1] - points[p1 + 1] + points[p0 + 1],
points[p2 + 2] - points[p3 + 2] - points[p1 + 2] + points[p0 + 2] };
float[] B = { points[p1 + 0] - points[p0 + 0],
points[p1 + 1] - points[p0 + 1],
points[p1 + 2] - points[p0 + 2] };
float[] C = { points[p3 + 0] - points[p0 + 0],
points[p3 + 1] - points[p0 + 1],
points[p3 + 2] - points[p0 + 2] };
float[] R = { r.ox - points[p0 + 0], r.oy - points[p0 + 1],
r.oz - points[p0 + 2] };
float[] Q = { r.dx, r.dy, r.dz };
// pick major direction
float absqx = Math.Abs(r.dx);
float absqy = Math.Abs(r.dy);
float absqz = Math.Abs(r.dz);
int X = 0, Y = 1, Z = 2;
if (absqx > absqy && absqx > absqz)
{
// X = 0, Y = 1, Z = 2
}
else if (absqy > absqz)
{
// X = 1, Y = 0, Z = 2
X = 1;
Y = 0;
}
else
{
// X = 2, Y = 1, Z = 0
X = 2;
Z = 0;
}
float Cxz = C[X] * Q[Z] - C[Z] * Q[X];
float Cyx = C[Y] * Q[X] - C[X] * Q[Y];
float Czy = C[Z] * Q[Y] - C[Y] * Q[Z];
float Rxz = R[X] * Q[Z] - R[Z] * Q[X];
float Ryx = R[Y] * Q[X] - R[X] * Q[Y];
float Rzy = R[Z] * Q[Y] - R[Y] * Q[Z];
float Bxy = B[X] * Q[Y] - B[Y] * Q[X];
float Byz = B[Y] * Q[Z] - B[Z] * Q[Y];
float Bzx = B[Z] * Q[X] - B[X] * Q[Z];
float a = A[X] * Byz + A[Y] * Bzx + A[Z] * Bxy;
if (a == 0)
{
// setup for linear equation
float b = B[X] * Czy + B[Y] * Cxz + B[Z] * Cyx;
float c = C[X] * Rzy + C[Y] * Rxz + C[Z] * Ryx;
float u = -c / b;
if (u >= 0 && u <= 1)
{
float v = (u * Bxy + Ryx) / Cyx;
if (v >= 0 && v <= 1)
{
float t = (B[X] * u + C[X] * v - R[X]) / Q[X];
if (r.isInside(t))
{
r.setMax(t);
state.setIntersection(primID, u, v);
}
}
}
}
else
{
// setup for quadratic equation
float b = A[X] * Rzy + A[Y] * Rxz + A[Z] * Ryx + B[X] * Czy + B[Y] * Cxz + B[Z] * Cyx;
float c = C[X] * Rzy + C[Y] * Rxz + C[Z] * Ryx;
float discrim = b * b - 4 * a * c;
// reject trivial cases
if (c * (a + b + c) > 0 && (discrim < 0 || a * c < 0 || b / a > 0 || b / a < -2))
return;
// solve quadratic
float q = b > 0 ? -0.5f * (b + (float)Math.Sqrt(discrim)) : -0.5f * (b - (float)Math.Sqrt(discrim));
// check first solution
float Axy = A[X] * Q[Y] - A[Y] * Q[X];
float u = q / a;
if (u >= 0 && u <= 1)
{
float d = u * Axy - Cyx;
float v = -(u * Bxy + Ryx) / d;
if (v >= 0 && v <= 1)
{
float t = (A[X] * u * v + B[X] * u + C[X] * v - R[X]) / Q[X];
if (r.isInside(t))
{
r.setMax(t);
state.setIntersection(primID, u, v);
}
}
}
u = c / q;
if (u >= 0 && u <= 1)
{
float d = u * Axy - Cyx;
float v = -(u * Bxy + Ryx) / d;
if (v >= 0 && v <= 1)
{
float t = (A[X] * u * v + B[X] * u + C[X] * v - R[X]) / Q[X];
if (r.isInside(t))
{
r.setMax(t);
state.setIntersection(primID, u, v);
}
}
}
}
}