2014-12-15 15:21:41 +00:00
|
|
|
|
/*
|
2014-12-15 16:18:01 +00:00
|
|
|
|
* Copyright 2014, Blender Foundation.
|
2014-12-15 15:21:41 +00:00
|
|
|
|
*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
|
|
|
|
|
2015-04-01 16:08:12 +00:00
|
|
|
|
/* Triangle/Ray intersections.
|
2014-12-15 15:21:41 +00:00
|
|
|
|
*
|
2014-12-15 16:18:01 +00:00
|
|
|
|
* For BVH ray intersection we use a precomputed triangle storage to accelerate
|
|
|
|
|
* intersection at the cost of more memory usage.
|
|
|
|
|
*/
|
2014-12-15 15:21:41 +00:00
|
|
|
|
|
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
|
|
2014-12-25 01:42:06 +00:00
|
|
|
|
/* Workaround stupidness of CUDA/OpenCL which doesn't allow to access indexed
|
2014-12-15 16:18:01 +00:00
|
|
|
|
* component of float3 value.
|
|
|
|
|
*/
|
|
|
|
|
#ifndef __KERNEL_CPU__
|
|
|
|
|
# define IDX(vec, idx) \
|
|
|
|
|
((idx == 0) ? ((vec).x) : ( (idx == 1) ? ((vec).y) : ((vec).z) ))
|
|
|
|
|
#else
|
|
|
|
|
# define IDX(vec, idx) ((vec)[idx])
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-12-15 15:21:41 +00:00
|
|
|
|
/* Ray-Triangle intersection for BVH traversal
|
|
|
|
|
*
|
2014-12-15 16:18:01 +00:00
|
|
|
|
* Sven Woop
|
|
|
|
|
* Watertight Ray/Triangle Intersection
|
|
|
|
|
*
|
|
|
|
|
* http://jcgt.org/published/0002/01/05/paper.pdf
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* Precalculated data for the ray->tri intersection. */
|
|
|
|
|
typedef struct IsectPrecalc {
|
|
|
|
|
/* Maximal dimension kz, and orthogonal dimensions. */
|
|
|
|
|
int kx, ky, kz;
|
|
|
|
|
|
|
|
|
|
/* Shear constants. */
|
|
|
|
|
float Sx, Sy, Sz;
|
|
|
|
|
} IsectPrecalc;
|
|
|
|
|
|
2014-12-25 09:15:37 +00:00
|
|
|
|
/* Workaround for CUDA toolkit 6.5.16. */
|
2015-02-02 12:06:15 +00:00
|
|
|
|
#if defined(__KERNEL_CPU__) || !defined(__KERNEL_CUDA_EXPERIMENTAL__) || __CUDA_ARCH__ < 500
|
2015-02-09 11:11:58 +00:00
|
|
|
|
# if (defined(i386) || defined(_M_IX86))
|
2015-02-02 17:08:01 +00:00
|
|
|
|
ccl_device_noinline
|
|
|
|
|
# else
|
2014-12-25 09:15:37 +00:00
|
|
|
|
ccl_device_inline
|
2015-02-02 17:08:01 +00:00
|
|
|
|
# endif
|
2014-12-25 09:15:37 +00:00
|
|
|
|
#else
|
|
|
|
|
ccl_device_noinline
|
|
|
|
|
#endif
|
|
|
|
|
void triangle_intersect_precalc(float3 dir,
|
2015-04-07 17:41:08 +00:00
|
|
|
|
IsectPrecalc *isect_precalc)
|
2014-12-15 16:18:01 +00:00
|
|
|
|
{
|
2014-12-25 01:42:06 +00:00
|
|
|
|
/* Calculate dimension where the ray direction is maximal. */
|
2014-12-15 16:18:01 +00:00
|
|
|
|
int kz = util_max_axis(make_float3(fabsf(dir.x),
|
|
|
|
|
fabsf(dir.y),
|
|
|
|
|
fabsf(dir.z)));
|
|
|
|
|
int kx = kz + 1; if(kx == 3) kx = 0;
|
|
|
|
|
int ky = kx + 1; if(ky == 3) ky = 0;
|
|
|
|
|
|
|
|
|
|
/* Swap kx and ky dimensions to preserve winding direction of triangles. */
|
|
|
|
|
if(IDX(dir, kz) < 0.0f) {
|
2015-01-02 12:21:24 +00:00
|
|
|
|
int tmp = kx;
|
2015-01-02 09:58:01 +00:00
|
|
|
|
kx = ky;
|
2015-03-03 19:16:21 +00:00
|
|
|
|
ky = tmp;
|
2014-12-15 16:18:01 +00:00
|
|
|
|
}
|
2014-12-15 15:21:41 +00:00
|
|
|
|
|
2014-12-15 16:18:01 +00:00
|
|
|
|
/* Calculate the shear constants. */
|
2015-04-07 20:13:16 +00:00
|
|
|
|
float inv_dir_z = 1.0f / IDX(dir, kz);
|
|
|
|
|
isect_precalc->Sx = IDX(dir, kx) * inv_dir_z;
|
|
|
|
|
isect_precalc->Sy = IDX(dir, ky) * inv_dir_z;
|
|
|
|
|
isect_precalc->Sz = inv_dir_z;
|
2014-12-15 16:18:01 +00:00
|
|
|
|
|
|
|
|
|
/* Store the dimensions. */
|
|
|
|
|
isect_precalc->kx = kx;
|
|
|
|
|
isect_precalc->ky = ky;
|
|
|
|
|
isect_precalc->kz = kz;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* TODO(sergey): Make it general utility function. */
|
|
|
|
|
ccl_device_inline float xor_signmast(float x, int y)
|
|
|
|
|
{
|
|
|
|
|
return __int_as_float(__float_as_int(x) ^ y);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ccl_device_inline bool triangle_intersect(KernelGlobals *kg,
|
|
|
|
|
const IsectPrecalc *isect_precalc,
|
|
|
|
|
Intersection *isect,
|
|
|
|
|
float3 P,
|
|
|
|
|
uint visibility,
|
|
|
|
|
int object,
|
|
|
|
|
int triAddr)
|
2014-12-15 15:21:41 +00:00
|
|
|
|
{
|
2014-12-15 16:18:01 +00:00
|
|
|
|
const int kx = isect_precalc->kx;
|
|
|
|
|
const int ky = isect_precalc->ky;
|
|
|
|
|
const int kz = isect_precalc->kz;
|
|
|
|
|
const float Sx = isect_precalc->Sx;
|
|
|
|
|
const float Sy = isect_precalc->Sy;
|
|
|
|
|
const float Sz = isect_precalc->Sz;
|
|
|
|
|
|
|
|
|
|
/* Calculate vertices relative to ray origin. */
|
|
|
|
|
float3 tri[3];
|
|
|
|
|
tri[0] = float4_to_float3(kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+0));
|
|
|
|
|
tri[1] = float4_to_float3(kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+1));
|
|
|
|
|
tri[2] = float4_to_float3(kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+2));
|
|
|
|
|
|
|
|
|
|
const float3 A = tri[0] - P;
|
|
|
|
|
const float3 B = tri[1] - P;
|
|
|
|
|
const float3 C = tri[2] - P;
|
|
|
|
|
|
|
|
|
|
const float A_kx = IDX(A, kx), A_ky = IDX(A, ky), A_kz = IDX(A, kz);
|
|
|
|
|
const float B_kx = IDX(B, kx), B_ky = IDX(B, ky), B_kz = IDX(B, kz);
|
|
|
|
|
const float C_kx = IDX(C, kx), C_ky = IDX(C, ky), C_kz = IDX(C, kz);
|
|
|
|
|
|
|
|
|
|
/* Perform shear and scale of vertices. */
|
|
|
|
|
const float Ax = A_kx - Sx * A_kz;
|
|
|
|
|
const float Ay = A_ky - Sy * A_kz;
|
|
|
|
|
const float Bx = B_kx - Sx * B_kz;
|
|
|
|
|
const float By = B_ky - Sy * B_kz;
|
|
|
|
|
const float Cx = C_kx - Sx * C_kz;
|
|
|
|
|
const float Cy = C_ky - Sy * C_kz;
|
|
|
|
|
|
|
|
|
|
/* Calculate scaled barycentric coordinates. */
|
|
|
|
|
float U = Cx * By - Cy * Bx;
|
|
|
|
|
int sign_mask = (__float_as_int(U) & 0x80000000);
|
|
|
|
|
float V = Ax * Cy - Ay * Cx;
|
|
|
|
|
if(sign_mask != (__float_as_int(V) & 0x80000000)) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
float W = Bx * Ay - By * Ax;
|
|
|
|
|
if(sign_mask != (__float_as_int(W) & 0x80000000)) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Calculate determinant. */
|
|
|
|
|
float det = U + V + W;
|
|
|
|
|
if(UNLIKELY(det == 0.0f)) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Calculate scaled z−coordinates of vertices and use them to calculate
|
|
|
|
|
* the hit distance.
|
|
|
|
|
*/
|
2015-03-05 13:55:30 +00:00
|
|
|
|
const float T = (U * A_kz + V * B_kz + W * C_kz) * Sz;
|
2015-03-12 12:51:01 +00:00
|
|
|
|
const float sign_T = xor_signmast(T, sign_mask);
|
2015-03-27 19:15:15 +00:00
|
|
|
|
if((sign_T < 0.0f) ||
|
|
|
|
|
(sign_T > isect->t * xor_signmast(det, sign_mask)))
|
2015-03-12 12:51:01 +00:00
|
|
|
|
{
|
2014-12-15 16:18:01 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-15 15:21:41 +00:00
|
|
|
|
#ifdef __VISIBILITY_FLAG__
|
2014-12-15 16:18:01 +00:00
|
|
|
|
/* 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)
|
2014-12-15 15:21:41 +00:00
|
|
|
|
#endif
|
2014-12-15 16:18:01 +00:00
|
|
|
|
{
|
|
|
|
|
/* Normalize U, V, W, and T. */
|
|
|
|
|
const float inv_det = 1.0f / det;
|
|
|
|
|
isect->prim = triAddr;
|
|
|
|
|
isect->object = object;
|
|
|
|
|
isect->type = PRIMITIVE_TRIANGLE;
|
|
|
|
|
isect->u = U * inv_det;
|
|
|
|
|
isect->v = V * inv_det;
|
2015-03-12 12:51:01 +00:00
|
|
|
|
isect->t = T * inv_det;
|
2014-12-15 16:18:01 +00:00
|
|
|
|
return true;
|
2014-12-15 15:21:41 +00:00
|
|
|
|
}
|
|
|
|
|
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
|
2014-12-15 16:18:01 +00:00
|
|
|
|
* multiple hits we pick a single random primitive as the intersection point.
|
|
|
|
|
*/
|
2014-12-15 15:21:41 +00:00
|
|
|
|
|
|
|
|
|
#ifdef __SUBSURFACE__
|
2014-12-15 16:18:01 +00:00
|
|
|
|
ccl_device_inline void triangle_intersect_subsurface(
|
|
|
|
|
KernelGlobals *kg,
|
|
|
|
|
const IsectPrecalc *isect_precalc,
|
|
|
|
|
Intersection *isect_array,
|
|
|
|
|
float3 P,
|
|
|
|
|
int object,
|
|
|
|
|
int triAddr,
|
|
|
|
|
float tmax,
|
|
|
|
|
uint *num_hits,
|
|
|
|
|
uint *lcg_state,
|
|
|
|
|
int max_hits)
|
2014-12-15 15:21:41 +00:00
|
|
|
|
{
|
2014-12-15 16:18:01 +00:00
|
|
|
|
const int kx = isect_precalc->kx;
|
|
|
|
|
const int ky = isect_precalc->ky;
|
|
|
|
|
const int kz = isect_precalc->kz;
|
|
|
|
|
const float Sx = isect_precalc->Sx;
|
|
|
|
|
const float Sy = isect_precalc->Sy;
|
|
|
|
|
const float Sz = isect_precalc->Sz;
|
|
|
|
|
|
|
|
|
|
/* Calculate vertices relative to ray origin. */
|
|
|
|
|
float3 tri[3];
|
2015-02-04 09:49:19 +00:00
|
|
|
|
tri[0] = float4_to_float3(kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+0));
|
|
|
|
|
tri[1] = float4_to_float3(kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+1));
|
|
|
|
|
tri[2] = float4_to_float3(kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+2));
|
2014-12-15 16:18:01 +00:00
|
|
|
|
|
|
|
|
|
const float3 A = tri[0] - P;
|
|
|
|
|
const float3 B = tri[1] - P;
|
|
|
|
|
const float3 C = tri[2] - P;
|
|
|
|
|
|
|
|
|
|
const float A_kx = IDX(A, kx), A_ky = IDX(A, ky), A_kz = IDX(A, kz);
|
|
|
|
|
const float B_kx = IDX(B, kx), B_ky = IDX(B, ky), B_kz = IDX(B, kz);
|
|
|
|
|
const float C_kx = IDX(C, kx), C_ky = IDX(C, ky), C_kz = IDX(C, kz);
|
|
|
|
|
|
|
|
|
|
/* Perform shear and scale of vertices. */
|
|
|
|
|
const float Ax = A_kx - Sx * A_kz;
|
|
|
|
|
const float Ay = A_ky - Sy * A_kz;
|
|
|
|
|
const float Bx = B_kx - Sx * B_kz;
|
|
|
|
|
const float By = B_ky - Sy * B_kz;
|
|
|
|
|
const float Cx = C_kx - Sx * C_kz;
|
|
|
|
|
const float Cy = C_ky - Sy * C_kz;
|
|
|
|
|
|
|
|
|
|
/* Calculate scaled barycentric coordinates. */
|
|
|
|
|
float U = Cx * By - Cy * Bx;
|
|
|
|
|
int sign_mask = (__float_as_int(U) & 0x80000000);
|
|
|
|
|
float V = Ax * Cy - Ay * Cx;
|
|
|
|
|
if(sign_mask != (__float_as_int(V) & 0x80000000)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
float W = Bx * Ay - By * Ax;
|
|
|
|
|
if(sign_mask != (__float_as_int(W) & 0x80000000)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Calculate determinant. */
|
|
|
|
|
float det = U + V + W;
|
|
|
|
|
if(UNLIKELY(det == 0.0f)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Calculate scaled z−coordinates of vertices and use them to calculate
|
|
|
|
|
* the hit distance.
|
|
|
|
|
*/
|
2015-04-01 16:19:29 +00:00
|
|
|
|
const float T = (U * A_kz + V * B_kz + W * C_kz) * Sz;
|
|
|
|
|
const float sign_T = xor_signmast(T, sign_mask);
|
|
|
|
|
if((sign_T < 0.0f) ||
|
|
|
|
|
(sign_T > tmax * xor_signmast(det, sign_mask)))
|
2014-12-15 16:18:01 +00:00
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Normalize U, V, W, and T. */
|
|
|
|
|
const float inv_det = 1.0f / det;
|
|
|
|
|
|
|
|
|
|
(*num_hits)++;
|
|
|
|
|
int hit;
|
|
|
|
|
|
|
|
|
|
if(*num_hits <= max_hits) {
|
|
|
|
|
hit = *num_hits - 1;
|
2014-12-15 15:21:41 +00:00
|
|
|
|
}
|
2014-12-15 16:18:01 +00:00
|
|
|
|
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->prim = triAddr;
|
|
|
|
|
isect->object = object;
|
|
|
|
|
isect->type = PRIMITIVE_TRIANGLE;
|
|
|
|
|
isect->u = U * inv_det;
|
|
|
|
|
isect->v = V * inv_det;
|
|
|
|
|
isect->t = T * inv_det;
|
2014-12-15 15:21:41 +00:00
|
|
|
|
}
|
|
|
|
|
#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. */
|
|
|
|
|
|
2014-12-15 16:18:01 +00:00
|
|
|
|
/* Reintersections uses the paper:
|
|
|
|
|
*
|
|
|
|
|
* Tomas Moeller
|
|
|
|
|
* Fast, minimum storage ray/triangle intersection
|
|
|
|
|
* http://www.cs.virginia.edu/~gfx/Courses/2003/ImageSynthesis/papers/Acceleration/Fast%20MinimumStorage%20RayTriangle%20Intersection.pdf
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
ccl_device_inline float3 triangle_refine(KernelGlobals *kg,
|
|
|
|
|
ShaderData *sd,
|
|
|
|
|
const Intersection *isect,
|
|
|
|
|
const Ray *ray)
|
2014-12-15 15:21:41 +00:00
|
|
|
|
{
|
|
|
|
|
float3 P = ray->P;
|
|
|
|
|
float3 D = ray->D;
|
|
|
|
|
float t = isect->t;
|
|
|
|
|
|
|
|
|
|
#ifdef __INTERSECTION_REFINE__
|
|
|
|
|
if(isect->object != OBJECT_NONE) {
|
2015-02-10 14:07:55 +00:00
|
|
|
|
if(UNLIKELY(t == 0.0f)) {
|
|
|
|
|
return P;
|
|
|
|
|
}
|
2014-12-15 15:21:41 +00:00
|
|
|
|
#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;
|
|
|
|
|
|
2014-12-15 16:18:01 +00:00
|
|
|
|
float3 tri[3];
|
|
|
|
|
tri[0] = float4_to_float3(kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+0));
|
|
|
|
|
tri[1] = float4_to_float3(kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+1));
|
|
|
|
|
tri[2] = float4_to_float3(kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+2));
|
|
|
|
|
|
|
|
|
|
float3 edge1 = tri[0] - tri[2];
|
|
|
|
|
float3 edge2 = tri[1] - tri[2];
|
|
|
|
|
float3 tvec = P - tri[2];
|
|
|
|
|
float3 qvec = cross(tvec, edge1);
|
|
|
|
|
float3 pvec = cross(D, edge2);
|
|
|
|
|
float rt = dot(edge2, qvec) / dot(edge1, pvec);
|
2014-12-15 15:21:41 +00:00
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-15 16:18:01 +00:00
|
|
|
|
/* 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)
|
2014-12-15 15:21:41 +00:00
|
|
|
|
{
|
|
|
|
|
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
|
2014-12-15 16:18:01 +00:00
|
|
|
|
Transform tfm = object_fetch_transform(kg,
|
|
|
|
|
isect->object,
|
|
|
|
|
OBJECT_INVERSE_TRANSFORM);
|
2014-12-15 15:21:41 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
P = transform_point(&tfm, P);
|
|
|
|
|
D = transform_direction(&tfm, D);
|
|
|
|
|
D = normalize(D);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
P = P + D*t;
|
|
|
|
|
|
2014-12-15 16:18:01 +00:00
|
|
|
|
float3 tri[3];
|
2015-02-04 09:49:19 +00:00
|
|
|
|
tri[0] = float4_to_float3(kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+0));
|
|
|
|
|
tri[1] = float4_to_float3(kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+1));
|
|
|
|
|
tri[2] = float4_to_float3(kernel_tex_fetch(__tri_woop, isect->prim*TRI_NODE_SIZE+2));
|
2014-12-15 16:18:01 +00:00
|
|
|
|
|
|
|
|
|
float3 edge1 = tri[0] - tri[2];
|
|
|
|
|
float3 edge2 = tri[1] - tri[2];
|
|
|
|
|
float3 tvec = P - tri[2];
|
|
|
|
|
float3 qvec = cross(tvec, edge1);
|
|
|
|
|
float3 pvec = cross(D, edge2);
|
|
|
|
|
float rt = dot(edge2, qvec) / dot(edge1, pvec);
|
2014-12-15 15:21:41 +00:00
|
|
|
|
|
|
|
|
|
P = P + D*rt;
|
|
|
|
|
|
|
|
|
|
if(isect->object != OBJECT_NONE) {
|
|
|
|
|
#ifdef __OBJECT_MOTION__
|
|
|
|
|
Transform tfm = sd->ob_tfm;
|
|
|
|
|
#else
|
2014-12-15 16:18:01 +00:00
|
|
|
|
Transform tfm = object_fetch_transform(kg,
|
|
|
|
|
isect->object,
|
|
|
|
|
OBJECT_TRANSFORM);
|
2014-12-15 15:21:41 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
P = transform_point(&tfm, P);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return P;
|
|
|
|
|
#else
|
|
|
|
|
return P + D*t;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-15 16:18:01 +00:00
|
|
|
|
#undef IDX
|
|
|
|
|
|
2014-12-15 15:21:41 +00:00
|
|
|
|
CCL_NAMESPACE_END
|