~ubuntu-branches/ubuntu/utopic/blender/utopic-proposed

 */

 

/* bottom-most stack entry, indicating the end of traversal */

#define ENTRYPOINT_SENTINEL 0x76543210

/* 64 object BVH + 64 mesh BVH + 64 object node splitting */

#define BVH_STACK_SIZE 192

#define BVH_NODE_SIZE 4

        float3 P, float3 idir, uint visibility, int object, int curveAddr, int segment, uint *lcg_state, float difl, float extmax)

{

        float epsilon = 0.0f;

 

        

        float3 curve_coef[4];

        {

                Transform htfm;

                float d = sqrtf(dir.x * dir.x + dir.z * dir.z);

                htfm = make_transform(

        if((flags & CURVE_KN_RIBBONS) || !(flags & CURVE_KN_BACKFACING))

                epsilon = 2 * r_curr;

 

 

        float zextrem[4];

        curvebounds(&lower, &upper, &zextrem[0], &zextrem[1], &zextrem[2], &zextrem[3], curve_coef[0].z, curve_coef[1].z, curve_coef[2].z, curve_coef[3].z);

        if(lower - r_curr > isect->t || upper + r_curr < epsilon)

                return false;

 

        float mw_extension = min(difl * fabsf(upper), extmax);

        float r_ext = mw_extension + r_curr;

 

        if(lower > r_ext || upper < -r_ext)

                return false;

 

        int level = 1 << depth;

        int tree = 0;

        float resol = 1.0f / (float)level;

        bool hit = false;

 

        while(!(tree >> (depth))) {

                float i_st = tree * resol;

                float i_en = i_st + (level * resol);

                float coverage = 1.0f;

 

                if (bminz - r_curr > isect->t || bmaxz + r_curr < epsilon || bminx > r_ext|| bmaxx < -r_ext|| bminy > r_ext|| bmaxy < -r_ext) {

                        tree += level;

                        level = tree & -tree;

                }

                                w = -(p_st.x * tg.x + p_st.y * tg.y) / w;

                                w = clamp((float)w, 0.0f, 1.0f);

 

                                u = i_st * (1 - w) + i_en * w;

                                r_curr = r_st + (r_en - r_st) * u;

                                float3 p_curr = ((curve_coef[3] * u + curve_coef[2]) * u + curve_coef[1]) * u + curve_coef[0];

 

                                float3 dp_st = (3 * curve_coef[3] * i_st + 2 * curve_coef[2]) * i_st + curve_coef[1];

                                        level = tree & -tree;

                                        continue;

                                }

                                if (isect->t < p_curr.z) {

                                        tree++;

                                        level = tree & -tree;

                        }

                        else {

                                float l = len(p_en - p_st);

                                float or1 = r1;

                                float or2 = r2;

                                if(difl != 0.0f) {

                                float tb = 2*(tdif.z - tg.z*(tdifz + gd*(tdifz*gd + or1)));

                                float tc = dot(tdif,tdif) - tdifz * tdifz * (1 + gd*gd) - or1*or1 - 2*or1*tdifz*gd;

                                float td = tb*tb - 4*cyla*tc;

                                        tree++;

                                        level = tree & -tree;

                                        continue;

                                }

 

                                w = clamp((float)w, 0.0f, 1.0f);

                                u = i_st * (1 - w) + i_en * w;

                                r_curr = r1 + (r2 - r1) * w;

                                r_ext = or1 + (or2 - or1) * w;

                                coverage = r_curr/r_ext;

 

                        }

 

                        if(lcg_state && coverage != 1.0f) {

                                        return hit;

                        }

 

        float3 P, float3 idir, uint visibility, int object, int curveAddr, int segment, uint *lcg_state, float difl, float extmax)

{

        /* curve Intersection check */

 

        int prim = kernel_tex_fetch(__prim_index, curveAddr);

        float4 v00 = kernel_tex_fetch(__curves, prim);

        float3 p1 = float4_to_float3(P1);

        float3 p2 = float4_to_float3(P2);

 

        float r1 = or1;

        float r2 = or2;

        if(difl != 0.0f) {

        if(sdisc < 0.0f)

                return false;

 

        float3 tg = (p2 - p1) / l;

        float gd = (r2 - r1) / l;

        float dirz = dot(dir,tg);

        if((zcentre < 0 || zcentre > l) && !(flags & CURVE_KN_ACCURATE) && !(flags & CURVE_KN_INTERSECTCORRECTION))

                return false;

 

        float3 cprod = cross(tg, dir);

        float3 cprod2 = cross(tg, dif);

        float cprodsq = len_squared(cprod);

        if(distscaled > mr*mr)

                return false;

 

        float3 tdif = P - p1 + tcentre * dir;

        float tdifz = dot(tdif,tg);

        float tb = 2*(dot(dir,tdif) - dirz*(tdifz + gd*(tdifz*gd + r1)));

                        z = zcentre + (dirz * correction);

                }

 

                float adjradius = or1 + z * (or2 - or1) / l;

                adjradius = adjradius / (r1 + z * gd);

                if(lcg_state && adjradius != 1.0f) {

                                return false;

                }

                /* --- */

 

                        if (flags & CURVE_KN_ENCLOSEFILTER) {

 

                                if((dot(P - p1, tg) > -r1 * enc_ratio) && (dot(P - p2, tg) < r2 * enc_ratio)) {

                                        float a2 = 1.0f - (dirz*dirz*(1 + gd*gd*enc_ratio*enc_ratio));

                                        float c2 = dot(dif,dif) - difz * difz * (1 + gd*gd*enc_ratio*enc_ratio) - r1*r1*enc_ratio*enc_ratio - 2*r1*difz*gd*enc_ratio;

 * 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. */

 

{

        /* compute and check intersection t-value */

        float4 v00 = kernel_tex_fetch(__tri_woop, triAddr*TRI_NODE_SIZE+0);

                        if(v >= 0.0f && u + v <= 1.0f) {

                                (*num_hits)++;

 

                        }

                }

        }

}

#endif

 

#define BVH_MOTION                              2

#define BVH_HAIR                                4

#define BVH_HAIR_MINIMUM_WIDTH  8

 

#define BVH_FUNCTION_NAME bvh_intersect

#define BVH_FUNCTION_FEATURES 0

 

#if defined(__SUBSURFACE__)

#define BVH_FUNCTION_NAME bvh_intersect_subsurface

#endif