forked from bartvdbraak/blender
Cycles: Move triangle intersection functions into own file
This way extending intersection routines with some pre-calculation step wouldn't explode the single file size, hopefully keeping them all in a nice maintainable state.
This commit is contained in:
Sergey Sharybin
parent
43421e9c53
commit
f4df3ec05a
@ -124,6 +124,7 @@ set(SRC_GEOM_HEADERS
|
||||
geom/geom_object.h
|
||||
geom/geom_primitive.h
|
||||
geom/geom_triangle.h
|
||||
geom/geom_triangle_intersect.h
|
||||
geom/geom_volume.h
|
||||
)
|
||||
|
||||
|
||||
@ -35,6 +35,7 @@
|
||||
#include "geom_attribute.h"
|
||||
#include "geom_object.h"
|
||||
#include "geom_triangle.h"
|
||||
#include "geom_triangle_intersect.h"
|
||||
#include "geom_motion_triangle.h"
|
||||
#include "geom_motion_curve.h"
|
||||
#include "geom_curve.h"
|
||||
|
||||
@ -17,105 +17,10 @@
|
||||
|
||||
/* Triangle Primitive
|
||||
*
|
||||
* Basic triangle with 3 vertices is used to represent mesh surfaces. For BVH
|
||||
* ray intersection we use a precomputed triangle storage to accelerate
|
||||
* intersection at the cost of more memory usage */
|
||||
* Basic triangle with 3 vertices is used to represent mesh surfaces. */
|
||||
|
||||
CCL_NAMESPACE_BEGIN
|
||||
|
||||
/* Refine triangle intersection to more precise hit point. For rays that travel
|
||||
* far the precision is often not so good, this reintersects the primitive from
|
||||
* a closer distance. */
|
||||
|
||||
ccl_device_inline float3 triangle_refine(KernelGlobals *kg, ShaderData *sd, const Intersection *isect, const Ray *ray)
|
||||
{
|
||||
float3 P = ray->P;
|
||||
float3 D = ray->D;
|
||||
float t = isect->t;
|
||||
|
||||
#ifdef __INTERSECTION_REFINE__
|
||||
if(isect->object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform tfm = sd->ob_itfm;
|
||||
#else
|
||||
Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_INVERSE_TRANSFORM);
|
||||
#endif
|
||||
|
||||
P = transform_point(&tfm, P);
|
||||
D = transform_direction(&tfm, D*t);
|
||||
D = normalize_len(D, &t);
|
||||
}
|
||||
|
||||
P = P + D*t;
|
||||
|
||||
float4 v00 = kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+0);
|
||||
float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z;
|
||||
float invDz = 1.0f/(D.x*v00.x + D.y*v00.y + D.z*v00.z);
|
||||
float rt = Oz * invDz;
|
||||
|
||||
P = P + D*rt;
|
||||
|
||||
if(isect->object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform tfm = sd->ob_tfm;
|
||||
#else
|
||||
Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_TRANSFORM);
|
||||
#endif
|
||||
|
||||
P = transform_point(&tfm, P);
|
||||
}
|
||||
|
||||
return P;
|
||||
#else
|
||||
return P + D*t;
|
||||
#endif
|
||||
}
|
||||
|
||||
/* same as above, except that isect->t is assumed to be in object space for instancing */
|
||||
ccl_device_inline float3 triangle_refine_subsurface(KernelGlobals *kg, ShaderData *sd, const Intersection *isect, const Ray *ray)
|
||||
{
|
||||
float3 P = ray->P;
|
||||
float3 D = ray->D;
|
||||
float t = isect->t;
|
||||
|
||||
#ifdef __INTERSECTION_REFINE__
|
||||
if(isect->object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform tfm = sd->ob_itfm;
|
||||
#else
|
||||
Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_INVERSE_TRANSFORM);
|
||||
#endif
|
||||
|
||||
P = transform_point(&tfm, P);
|
||||
D = transform_direction(&tfm, D);
|
||||
D = normalize(D);
|
||||
}
|
||||
|
||||
P = P + D*t;
|
||||
|
||||
float4 v00 = kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+0);
|
||||
float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z;
|
||||
float invDz = 1.0f/(D.x*v00.x + D.y*v00.y + D.z*v00.z);
|
||||
float rt = Oz * invDz;
|
||||
|
||||
P = P + D*rt;
|
||||
|
||||
if(isect->object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform tfm = sd->ob_tfm;
|
||||
#else
|
||||
Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_TRANSFORM);
|
||||
#endif
|
||||
|
||||
P = transform_point(&tfm, P);
|
||||
}
|
||||
|
||||
return P;
|
||||
#else
|
||||
return P + D*t;
|
||||
#endif
|
||||
}
|
||||
|
||||
/* normal on triangle */
|
||||
ccl_device_inline float3 triangle_normal(KernelGlobals *kg, ShaderData *sd)
|
||||
{
|
||||
@ -298,116 +203,4 @@ ccl_device float3 triangle_attribute_float3(KernelGlobals *kg, const ShaderData
|
||||
}
|
||||
}
|
||||
|
||||
/* Ray-Triangle intersection for BVH traversal
|
||||
*
|
||||
* Based on Sven Woop's algorithm with precomputed triangle storage */
|
||||
|
||||
ccl_device_inline bool triangle_intersect(KernelGlobals *kg, Intersection *isect,
|
||||
float3 P, float3 dir, uint visibility, int object, int triAddr)
|
||||
{
|
||||
/* compute and check intersection t-value */
|
||||
float4 v00 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+0);
|
||||
float4 v11 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+1);
|
||||
|
||||
float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z;
|
||||
float invDz = 1.0f/(dir.x*v00.x + dir.y*v00.y + dir.z*v00.z);
|
||||
float t = Oz * invDz;
|
||||
|
||||
if(t > 0.0f && t < isect->t) {
|
||||
/* compute and check barycentric u */
|
||||
float Ox = v11.w + P.x*v11.x + P.y*v11.y + P.z*v11.z;
|
||||
float Dx = dir.x*v11.x + dir.y*v11.y + dir.z*v11.z;
|
||||
float u = Ox + t*Dx;
|
||||
|
||||
if(u >= 0.0f) {
|
||||
/* compute and check barycentric v */
|
||||
float4 v22 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+2);
|
||||
float Oy = v22.w + P.x*v22.x + P.y*v22.y + P.z*v22.z;
|
||||
float Dy = dir.x*v22.x + dir.y*v22.y + dir.z*v22.z;
|
||||
float v = Oy + t*Dy;
|
||||
|
||||
if(v >= 0.0f && u + v <= 1.0f) {
|
||||
#ifdef __VISIBILITY_FLAG__
|
||||
/* visibility flag test. we do it here under the assumption
|
||||
* that most triangles are culled by node flags */
|
||||
if(kernel_tex_fetch(__prim_visibility, triAddr) & visibility)
|
||||
#endif
|
||||
{
|
||||
/* record intersection */
|
||||
isect->t = t;
|
||||
isect->u = u;
|
||||
isect->v = v;
|
||||
isect->prim = triAddr;
|
||||
isect->object = object;
|
||||
isect->type = PRIMITIVE_TRIANGLE;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Special ray intersection routines for subsurface scattering. In that case we
|
||||
* only want to intersect with primitives in the same object, and if case of
|
||||
* multiple hits we pick a single random primitive as the intersection point. */
|
||||
|
||||
#ifdef __SUBSURFACE__
|
||||
ccl_device_inline void triangle_intersect_subsurface(KernelGlobals *kg, Intersection *isect_array,
|
||||
float3 P, float3 dir, int object, int triAddr, float tmax, uint *num_hits, uint *lcg_state, int max_hits)
|
||||
{
|
||||
/* compute and check intersection t-value */
|
||||
float4 v00 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+0);
|
||||
float4 v11 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+1);
|
||||
|
||||
float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z;
|
||||
float invDz = 1.0f/(dir.x*v00.x + dir.y*v00.y + dir.z*v00.z);
|
||||
float t = Oz * invDz;
|
||||
|
||||
if(t > 0.0f && t < tmax) {
|
||||
/* compute and check barycentric u */
|
||||
float Ox = v11.w + P.x*v11.x + P.y*v11.y + P.z*v11.z;
|
||||
float Dx = dir.x*v11.x + dir.y*v11.y + dir.z*v11.z;
|
||||
float u = Ox + t*Dx;
|
||||
|
||||
if(u >= 0.0f) {
|
||||
/* compute and check barycentric v */
|
||||
float4 v22 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+2);
|
||||
float Oy = v22.w + P.x*v22.x + P.y*v22.y + P.z*v22.z;
|
||||
float Dy = dir.x*v22.x + dir.y*v22.y + dir.z*v22.z;
|
||||
float v = Oy + t*Dy;
|
||||
|
||||
if(v >= 0.0f && u + v <= 1.0f) {
|
||||
(*num_hits)++;
|
||||
|
||||
int hit;
|
||||
|
||||
if(*num_hits <= max_hits) {
|
||||
hit = *num_hits - 1;
|
||||
}
|
||||
else {
|
||||
/* reservoir sampling: if we are at the maximum number of
|
||||
* hits, randomly replace element or skip it */
|
||||
hit = lcg_step_uint(lcg_state) % *num_hits;
|
||||
|
||||
if(hit >= max_hits)
|
||||
return;
|
||||
}
|
||||
|
||||
/* record intersection */
|
||||
Intersection *isect = &isect_array[hit];
|
||||
isect->t = t;
|
||||
isect->u = u;
|
||||
isect->v = v;
|
||||
isect->prim = triAddr;
|
||||
isect->object = object;
|
||||
isect->type = PRIMITIVE_TRIANGLE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
CCL_NAMESPACE_END
|
||||
|
||||
|
||||
230
intern/cycles/kernel/geom/geom_triangle_intersect.h
Normal file
230
intern/cycles/kernel/geom/geom_triangle_intersect.h
Normal file
@ -0,0 +1,230 @@
|
||||
/*
|
||||
* Adapted from code Copyright 2009-2010 NVIDIA Corporation
|
||||
* Modifications Copyright 2011, Blender Foundation.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
/* Triangle/Ray intersections
|
||||
*
|
||||
* Basic triangle with 3 vertices is used to represent mesh surfaces. For BVH
|
||||
* ray intersection we use a precomputed triangle storage to accelerate
|
||||
* intersection at the cost of more memory usage */
|
||||
|
||||
CCL_NAMESPACE_BEGIN
|
||||
|
||||
/* Ray-Triangle intersection for BVH traversal
|
||||
*
|
||||
* Based on Sven Woop's algorithm with precomputed triangle storage */
|
||||
|
||||
ccl_device_inline bool triangle_intersect(KernelGlobals *kg, Intersection *isect,
|
||||
float3 P, float3 dir, uint visibility, int object, int triAddr)
|
||||
{
|
||||
/* compute and check intersection t-value */
|
||||
float4 v00 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+0);
|
||||
float4 v11 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+1);
|
||||
|
||||
float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z;
|
||||
float invDz = 1.0f/(dir.x*v00.x + dir.y*v00.y + dir.z*v00.z);
|
||||
float t = Oz * invDz;
|
||||
|
||||
if(t > 0.0f && t < isect->t) {
|
||||
/* compute and check barycentric u */
|
||||
float Ox = v11.w + P.x*v11.x + P.y*v11.y + P.z*v11.z;
|
||||
float Dx = dir.x*v11.x + dir.y*v11.y + dir.z*v11.z;
|
||||
float u = Ox + t*Dx;
|
||||
|
||||
if(u >= 0.0f) {
|
||||
/* compute and check barycentric v */
|
||||
float4 v22 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+2);
|
||||
float Oy = v22.w + P.x*v22.x + P.y*v22.y + P.z*v22.z;
|
||||
float Dy = dir.x*v22.x + dir.y*v22.y + dir.z*v22.z;
|
||||
float v = Oy + t*Dy;
|
||||
|
||||
if(v >= 0.0f && u + v <= 1.0f) {
|
||||
#ifdef __VISIBILITY_FLAG__
|
||||
/* visibility flag test. we do it here under the assumption
|
||||
* that most triangles are culled by node flags */
|
||||
if(kernel_tex_fetch(__prim_visibility, triAddr) & visibility)
|
||||
#endif
|
||||
{
|
||||
/* record intersection */
|
||||
isect->t = t;
|
||||
isect->u = u;
|
||||
isect->v = v;
|
||||
isect->prim = triAddr;
|
||||
isect->object = object;
|
||||
isect->type = PRIMITIVE_TRIANGLE;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Special ray intersection routines for subsurface scattering. In that case we
|
||||
* only want to intersect with primitives in the same object, and if case of
|
||||
* multiple hits we pick a single random primitive as the intersection point. */
|
||||
|
||||
#ifdef __SUBSURFACE__
|
||||
ccl_device_inline void triangle_intersect_subsurface(KernelGlobals *kg, Intersection *isect_array,
|
||||
float3 P, float3 dir, int object, int triAddr, float tmax, uint *num_hits, uint *lcg_state, int max_hits)
|
||||
{
|
||||
/* compute and check intersection t-value */
|
||||
float4 v00 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+0);
|
||||
float4 v11 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+1);
|
||||
|
||||
float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z;
|
||||
float invDz = 1.0f/(dir.x*v00.x + dir.y*v00.y + dir.z*v00.z);
|
||||
float t = Oz * invDz;
|
||||
|
||||
if(t > 0.0f && t < tmax) {
|
||||
/* compute and check barycentric u */
|
||||
float Ox = v11.w + P.x*v11.x + P.y*v11.y + P.z*v11.z;
|
||||
float Dx = dir.x*v11.x + dir.y*v11.y + dir.z*v11.z;
|
||||
float u = Ox + t*Dx;
|
||||
|
||||
if(u >= 0.0f) {
|
||||
/* compute and check barycentric v */
|
||||
float4 v22 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+2);
|
||||
float Oy = v22.w + P.x*v22.x + P.y*v22.y + P.z*v22.z;
|
||||
float Dy = dir.x*v22.x + dir.y*v22.y + dir.z*v22.z;
|
||||
float v = Oy + t*Dy;
|
||||
|
||||
if(v >= 0.0f && u + v <= 1.0f) {
|
||||
(*num_hits)++;
|
||||
|
||||
int hit;
|
||||
|
||||
if(*num_hits <= max_hits) {
|
||||
hit = *num_hits - 1;
|
||||
}
|
||||
else {
|
||||
/* reservoir sampling: if we are at the maximum number of
|
||||
* hits, randomly replace element or skip it */
|
||||
hit = lcg_step_uint(lcg_state) % *num_hits;
|
||||
|
||||
if(hit >= max_hits)
|
||||
return;
|
||||
}
|
||||
|
||||
/* record intersection */
|
||||
Intersection *isect = &isect_array[hit];
|
||||
isect->t = t;
|
||||
isect->u = u;
|
||||
isect->v = v;
|
||||
isect->prim = triAddr;
|
||||
isect->object = object;
|
||||
isect->type = PRIMITIVE_TRIANGLE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Refine triangle intersection to more precise hit point. For rays that travel
|
||||
* far the precision is often not so good, this reintersects the primitive from
|
||||
* a closer distance. */
|
||||
|
||||
ccl_device_inline float3 triangle_refine(KernelGlobals *kg, ShaderData *sd, const Intersection *isect, const Ray *ray)
|
||||
{
|
||||
float3 P = ray->P;
|
||||
float3 D = ray->D;
|
||||
float t = isect->t;
|
||||
|
||||
#ifdef __INTERSECTION_REFINE__
|
||||
if(isect->object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform tfm = sd->ob_itfm;
|
||||
#else
|
||||
Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_INVERSE_TRANSFORM);
|
||||
#endif
|
||||
|
||||
P = transform_point(&tfm, P);
|
||||
D = transform_direction(&tfm, D*t);
|
||||
D = normalize_len(D, &t);
|
||||
}
|
||||
|
||||
P = P + D*t;
|
||||
|
||||
float4 v00 = kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+0);
|
||||
float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z;
|
||||
float invDz = 1.0f/(D.x*v00.x + D.y*v00.y + D.z*v00.z);
|
||||
float rt = Oz * invDz;
|
||||
|
||||
P = P + D*rt;
|
||||
|
||||
if(isect->object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform tfm = sd->ob_tfm;
|
||||
#else
|
||||
Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_TRANSFORM);
|
||||
#endif
|
||||
|
||||
P = transform_point(&tfm, P);
|
||||
}
|
||||
|
||||
return P;
|
||||
#else
|
||||
return P + D*t;
|
||||
#endif
|
||||
}
|
||||
|
||||
/* same as above, except that isect->t is assumed to be in object space for instancing */
|
||||
ccl_device_inline float3 triangle_refine_subsurface(KernelGlobals *kg, ShaderData *sd, const Intersection *isect, const Ray *ray)
|
||||
{
|
||||
float3 P = ray->P;
|
||||
float3 D = ray->D;
|
||||
float t = isect->t;
|
||||
|
||||
#ifdef __INTERSECTION_REFINE__
|
||||
if(isect->object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform tfm = sd->ob_itfm;
|
||||
#else
|
||||
Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_INVERSE_TRANSFORM);
|
||||
#endif
|
||||
|
||||
P = transform_point(&tfm, P);
|
||||
D = transform_direction(&tfm, D);
|
||||
D = normalize(D);
|
||||
}
|
||||
|
||||
P = P + D*t;
|
||||
|
||||
float4 v00 = kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+0);
|
||||
float Oz = v00.w - P.x*v00.x - P.y*v00.y - P.z*v00.z;
|
||||
float invDz = 1.0f/(D.x*v00.x + D.y*v00.y + D.z*v00.z);
|
||||
float rt = Oz * invDz;
|
||||
|
||||
P = P + D*rt;
|
||||
|
||||
if(isect->object != OBJECT_NONE) {
|
||||
#ifdef __OBJECT_MOTION__
|
||||
Transform tfm = sd->ob_tfm;
|
||||
#else
|
||||
Transform tfm = object_fetch_transform(kg, isect->object, OBJECT_TRANSFORM);
|
||||
#endif
|
||||
|
||||
P = transform_point(&tfm, P);
|
||||
}
|
||||
|
||||
return P;
|
||||
#else
|
||||
return P + D*t;
|
||||
#endif
|
||||
}
|
||||
|
||||
CCL_NAMESPACE_END
|
||||
Loading…
Reference in New Issue
Block a user