sandey/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

Cycles: Cleanup, code style and comments

Browse Source
This commit is contained in:
Sergey Sharybin 2017-03-23 12:53:45 +01:00
parent 1c5cceb7af
commit aa0602130b
1 changed files with 76 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
intern/cycles/util/util_math_intersect.h
View File

@ -26,30 +26,29 @@ ccl_device bool ray_sphere_intersect(
float3 sphere_P, float sphere_radius,
float3 *isect_P, float *isect_t)
{
float3 d = sphere_P - ray_P;
float radiussq = sphere_radius*sphere_radius;
float tsq = dot(d, d);
const float3 d = sphere_P - ray_P;
const float radiussq = sphere_radius*sphere_radius;
const float tsq = dot(d, d);
if(tsq > radiussq) { /* ray origin outside sphere */
float tp = dot(d, ray_D);
if(tp < 0.0f) /* dir points away from sphere */
if(tsq > radiussq) {
/* Ray origin outside sphere. */
const float tp = dot(d, ray_D);
if(tp < 0.0f) {
/* Ray points away from sphere. */
return false;
float dsq = tsq - tp*tp; /* pythagoras */
if(dsq > radiussq) /* closest point on ray outside sphere */
}
const float dsq = tsq - tp*tp; /* pythagoras */
if(dsq > radiussq) {
/* Closest point on ray outside sphere. */
return false;
float t = tp - sqrtf(radiussq - dsq); /* pythagoras */
}
const float t = tp - sqrtf(radiussq - dsq); /* pythagoras */
if(t < ray_t) {
*isect_t = t;
*isect_P = ray_P + ray_D*t;
return true;
}
}
return false;
}
@ -58,27 +57,25 @@ ccl_device bool ray_aligned_disk_intersect(
float3 disk_P, float disk_radius,
float3 *isect_P, float *isect_t)
{
/* aligned disk normal */
/* Aligned disk normal. */
float disk_t;
float3 disk_N = normalize_len(ray_P - disk_P, &disk_t);
float div = dot(ray_D, disk_N);
if(UNLIKELY(div == 0.0f))
const float3 disk_N = normalize_len(ray_P - disk_P, &disk_t);
const float div = dot(ray_D, disk_N);
if(UNLIKELY(div == 0.0f)) {
return false;
/* compute t to intersection point */
float t = -disk_t/div;
if(t < 0.0f || t > ray_t)
}
/* Compute t to intersection point. */
const float t = -disk_t/div;
if(t < 0.0f || t > ray_t) {
return false;
/* test if within radius */
}
/* Test if within radius. */
float3 P = ray_P + ray_D*t;
if(len_squared(P - disk_P) > disk_radius*disk_radius)
if(len_squared(P - disk_P) > disk_radius*disk_radius) {
return false;
}
*isect_P = P;
*isect_t = t;
return true;
}
@ -87,69 +84,72 @@ ccl_device_inline bool ray_triangle_intersect_uv(
float3 v0, float3 v1, float3 v2,
float *isect_u, float *isect_v, float *isect_t)
{
/* Calculate intersection */
float3 e1 = v1 - v0;
float3 e2 = v2 - v0;
float3 s1 = cross(ray_D, e2);
/* Calculate intersection. */
const float3 e1 = v1 - v0;
const float3 e2 = v2 - v0;
const float3 s1 = cross(ray_D, e2);
const float divisor = dot(s1, e1);
if(UNLIKELY(divisor == 0.0f))
if(UNLIKELY(divisor == 0.0f)) {
return false;
}
const float inv_divisor = 1.0f/divisor;
const float invdivisor = 1.0f/divisor;
/* compute first barycentric coordinate */
/* Compute first barycentric coordinate. */
const float3 d = ray_P - v0;
const float u = dot(d, s1)*invdivisor;
if(u < 0.0f)
const float u = dot(d, s1)*inv_divisor;
if(u < 0.0f) {
return false;
/* Compute second barycentric coordinate */
}
/* Compute second barycentric coordinate. */
const float3 s2 = cross(d, e1);
const float v = dot(ray_D, s2)*invdivisor;
if(v < 0.0f)
const float v = dot(ray_D, s2)*inv_divisor;
if(v < 0.0f) {
return false;
}
const float b0 = 1.0f - u - v;
if(b0 < 0.0f)
if(b0 < 0.0f) {
return false;
/* compute t to intersection point */
const float t = dot(e2, s2)*invdivisor;
if(t < 0.0f || t > ray_t)
}
/* Compute distance to intersection point. */
const float t = dot(e2, s2)*inv_divisor;
if(t < 0.0f || t > ray_t) {
return false;
}
*isect_u = u;
*isect_v = v;
*isect_t = t;
return true;
}
ccl_device bool ray_quad_intersect(float3 ray_P, float3 ray_D, float ray_mint, float ray_maxt,
float3 quad_P, float3 quad_u, float3 quad_v, float3 quad_n,
float3 *isect_P, float *isect_t, float *isect_u, float *isect_v)
ccl_device bool ray_quad_intersect(float3 ray_P, float3 ray_D,
float ray_mint, float ray_maxt,
float3 quad_P,
float3 quad_u, float3 quad_v, float3 quad_n,
float3 *isect_P, float *isect_t,
float *isect_u, float *isect_v)
{
/* Perform intersection test. */
float t = -(dot(ray_P, quad_n) - dot(quad_P, quad_n)) / dot(ray_D, quad_n);
if(t < ray_mint || t > ray_maxt)
if(t < ray_mint || t > ray_maxt) {
return false;
float3 hit = ray_P + t*ray_D;
float3 inplane = hit - quad_P;
float u = dot(inplane, quad_u) / dot(quad_u, quad_u) + 0.5f;
if(u < 0.0f || u > 1.0f)
}
const float3 hit = ray_P + t*ray_D;
const float3 inplane = hit - quad_P;
const float u = dot(inplane, quad_u) / dot(quad_u, quad_u) + 0.5f;
if(u < 0.0f || u > 1.0f) {
return false;
float v = dot(inplane, quad_v) / dot(quad_v, quad_v) + 0.5f;
if(v < 0.0f || v > 1.0f)
}
const float v = dot(inplane, quad_v) / dot(quad_v, quad_v) + 0.5f;
if(v < 0.0f || v > 1.0f) {
return false;
if(isect_P) *isect_P = hit;
if(isect_t) *isect_t = t;
if(isect_u) *isect_u = u;
if(isect_v) *isect_v = v;
}
/* Store the result. */
/* TODO(sergey): Check whether we can avoid some checks here. */
if(isect_P != NULL) *isect_P = hit;
if(isect_t != NULL) *isect_t = t;
if(isect_u != NULL) *isect_u = u;
if(isect_v != NULL) *isect_v = v;
return true;
}