diff options
16 files changed, 444 insertions, 467 deletions
diff --git a/release/scripts/startup/bl_ui/space_view3d.py b/release/scripts/startup/bl_ui/space_view3d.py index 0b2ae6fe3b6..f9e8f2b7793 100644 --- a/release/scripts/startup/bl_ui/space_view3d.py +++ b/release/scripts/startup/bl_ui/space_view3d.py @@ -2301,7 +2301,7 @@ class VIEW3D_PT_view3d_cursor(Panel): @classmethod def poll(cls, context): view = context.space_data - return (view) + return (view is not None) def draw(self, context): layout = self.layout diff --git a/source/blender/blenkernel/intern/collision.c b/source/blender/blenkernel/intern/collision.c index 29b709ba439..a93653537c7 100644 --- a/source/blender/blenkernel/intern/collision.c +++ b/source/blender/blenkernel/intern/collision.c @@ -366,12 +366,12 @@ static int cloth_collision_response_static ( ClothModifierData *clmd, CollisionM } //Determines collisions on overlap, collisions are written to collpair[i] and collision+number_collision_found is returned -static CollPair* cloth_collision ( ModifierData *md1, ModifierData *md2, - BVHTreeOverlap *overlap, CollPair *collpair, float UNUSED(dt) ) +static CollPair* cloth_collision(ModifierData *md1, ModifierData *md2, + BVHTreeOverlap *overlap, CollPair *collpair, float UNUSED(dt)) { ClothModifierData *clmd = (ClothModifierData *)md1; CollisionModifierData *collmd = (CollisionModifierData *) md2; - Cloth *cloth = clmd->clothObject; + /* Cloth *cloth = clmd->clothObject; */ /* UNUSED */ MFace *face1=NULL, *face2 = NULL; #ifdef USE_BULLET ClothVertex *verts1 = clmd->clothObject->verts; diff --git a/source/blender/render/intern/raytrace/bvh.h b/source/blender/render/intern/raytrace/bvh.h index c2e18a9236e..fab0bb94618 100644 --- a/source/blender/render/intern/raytrace/bvh.h +++ b/source/blender/render/intern/raytrace/bvh.h @@ -59,12 +59,12 @@ inline int test_bb_group4(__m128 *bb_group, const Isect *isec) copy_v3_v3(start, isec->start); copy_v3_v3(idot_axis, isec->idot_axis); - const __m128 tmin1 = _mm_max_ps(tmin0, _mm_mul_ps( _mm_sub_ps( bb_group[isec->bv_index[0]], _mm_set_ps1(start[0]) ), _mm_set_ps1(idot_axis[0])) ); - const __m128 tmax1 = _mm_min_ps(tmax0, _mm_mul_ps( _mm_sub_ps( bb_group[isec->bv_index[1]], _mm_set_ps1(start[0]) ), _mm_set_ps1(idot_axis[0])) ); - const __m128 tmin2 = _mm_max_ps(tmin1, _mm_mul_ps( _mm_sub_ps( bb_group[isec->bv_index[2]], _mm_set_ps1(start[1]) ), _mm_set_ps1(idot_axis[1])) ); - const __m128 tmax2 = _mm_min_ps(tmax1, _mm_mul_ps( _mm_sub_ps( bb_group[isec->bv_index[3]], _mm_set_ps1(start[1]) ), _mm_set_ps1(idot_axis[1])) ); - const __m128 tmin3 = _mm_max_ps(tmin2, _mm_mul_ps( _mm_sub_ps( bb_group[isec->bv_index[4]], _mm_set_ps1(start[2]) ), _mm_set_ps1(idot_axis[2])) ); - const __m128 tmax3 = _mm_min_ps(tmax2, _mm_mul_ps( _mm_sub_ps( bb_group[isec->bv_index[5]], _mm_set_ps1(start[2]) ), _mm_set_ps1(idot_axis[2])) ); + const __m128 tmin1 = _mm_max_ps(tmin0, _mm_mul_ps(_mm_sub_ps(bb_group[isec->bv_index[0]], _mm_set_ps1(start[0]) ), _mm_set_ps1(idot_axis[0])) ); + const __m128 tmax1 = _mm_min_ps(tmax0, _mm_mul_ps(_mm_sub_ps(bb_group[isec->bv_index[1]], _mm_set_ps1(start[0]) ), _mm_set_ps1(idot_axis[0])) ); + const __m128 tmin2 = _mm_max_ps(tmin1, _mm_mul_ps(_mm_sub_ps(bb_group[isec->bv_index[2]], _mm_set_ps1(start[1]) ), _mm_set_ps1(idot_axis[1])) ); + const __m128 tmax2 = _mm_min_ps(tmax1, _mm_mul_ps(_mm_sub_ps(bb_group[isec->bv_index[3]], _mm_set_ps1(start[1]) ), _mm_set_ps1(idot_axis[1])) ); + const __m128 tmin3 = _mm_max_ps(tmin2, _mm_mul_ps(_mm_sub_ps(bb_group[isec->bv_index[4]], _mm_set_ps1(start[2]) ), _mm_set_ps1(idot_axis[2])) ); + const __m128 tmax3 = _mm_min_ps(tmax2, _mm_mul_ps(_mm_sub_ps(bb_group[isec->bv_index[5]], _mm_set_ps1(start[2]) ), _mm_set_ps1(idot_axis[2])) ); return _mm_movemask_ps(_mm_cmpge_ps(tmax3, tmin3)); } @@ -142,7 +142,7 @@ static float bvh_cost(Tree *obj) /* bvh tree nodes generics */ template<class Node> static inline int bvh_node_hit_test(Node *node, Isect *isec) { - return rayobject_bb_intersect_test(isec, (const float*)node->bb); + return rayobject_bb_intersect_test(isec, (const float *)node->bb); } @@ -185,7 +185,7 @@ static int bvh_node_stack_raycast(Node *root, Isect *isec) } } else { - hit |= RE_rayobject_intersect( (RayObject*)node, isec); + hit |= RE_rayobject_intersect( (RayObject *)node, isec); if (SHADOW && hit) return hit; } } @@ -211,84 +211,84 @@ static int bvh_node_stack_raycast_simd(Node *root, Isect *isec) if (!is_leaf(root->child)) bvh_node_push_childs(root, isec, stack, stack_pos); else - return RE_rayobject_intersect( (RayObject*)root->child, isec); + return RE_rayobject_intersect( (RayObject *)root->child, isec); } else - return RE_rayobject_intersect( (RayObject*)root, isec); + return RE_rayobject_intersect( (RayObject *)root, isec); } else { if (!is_leaf(root)) stack[stack_pos++] = root; else - return RE_rayobject_intersect( (RayObject*)root, isec); + return RE_rayobject_intersect( (RayObject *)root, isec); } while (true) { //Use SIMD 4 if (stack_pos >= 4) { __m128 t_bb[6]; - Node * t_node[4]; + Node *t_node[4]; stack_pos -= 4; /* prepare the 4BB for SIMD */ - t_node[0] = stack[stack_pos+0]->child; - t_node[1] = stack[stack_pos+1]->child; - t_node[2] = stack[stack_pos+2]->child; - t_node[3] = stack[stack_pos+3]->child; - - const float *bb0 = stack[stack_pos+0]->bb; - const float *bb1 = stack[stack_pos+1]->bb; - const float *bb2 = stack[stack_pos+2]->bb; - const float *bb3 = stack[stack_pos+3]->bb; - - const __m128 x0y0x1y1 = _mm_shuffle_ps( _mm_load_ps(bb0), _mm_load_ps(bb1), _MM_SHUFFLE(1, 0, 1, 0) ); - const __m128 x2y2x3y3 = _mm_shuffle_ps( _mm_load_ps(bb2), _mm_load_ps(bb3), _MM_SHUFFLE(1, 0, 1, 0) ); - t_bb[0] = _mm_shuffle_ps( x0y0x1y1, x2y2x3y3, _MM_SHUFFLE(2, 0, 2, 0) ); - t_bb[1] = _mm_shuffle_ps( x0y0x1y1, x2y2x3y3, _MM_SHUFFLE(3, 1, 3, 1) ); - - const __m128 z0X0z1X1 = _mm_shuffle_ps( _mm_load_ps(bb0), _mm_load_ps(bb1), _MM_SHUFFLE(3, 2, 3, 2) ); - const __m128 z2X2z3X3 = _mm_shuffle_ps( _mm_load_ps(bb2), _mm_load_ps(bb3), _MM_SHUFFLE(3, 2, 3, 2) ); - t_bb[2] = _mm_shuffle_ps( z0X0z1X1, z2X2z3X3, _MM_SHUFFLE(2, 0, 2, 0) ); - t_bb[3] = _mm_shuffle_ps( z0X0z1X1, z2X2z3X3, _MM_SHUFFLE(3, 1, 3, 1) ); - - const __m128 Y0Z0Y1Z1 = _mm_shuffle_ps( _mm_load_ps(bb0+4), _mm_load_ps(bb1+4), _MM_SHUFFLE(1, 0, 1, 0) ); - const __m128 Y2Z2Y3Z3 = _mm_shuffle_ps( _mm_load_ps(bb2+4), _mm_load_ps(bb3+4), _MM_SHUFFLE(1, 0, 1, 0) ); - t_bb[4] = _mm_shuffle_ps( Y0Z0Y1Z1, Y2Z2Y3Z3, _MM_SHUFFLE(2, 0, 2, 0) ); - t_bb[5] = _mm_shuffle_ps( Y0Z0Y1Z1, Y2Z2Y3Z3, _MM_SHUFFLE(3, 1, 3, 1) ); + t_node[0] = stack[stack_pos + 0]->child; + t_node[1] = stack[stack_pos + 1]->child; + t_node[2] = stack[stack_pos + 2]->child; + t_node[3] = stack[stack_pos + 3]->child; + + const float *bb0 = stack[stack_pos + 0]->bb; + const float *bb1 = stack[stack_pos + 1]->bb; + const float *bb2 = stack[stack_pos + 2]->bb; + const float *bb3 = stack[stack_pos + 3]->bb; + + const __m128 x0y0x1y1 = _mm_shuffle_ps(_mm_load_ps(bb0), _mm_load_ps(bb1), _MM_SHUFFLE(1, 0, 1, 0) ); + const __m128 x2y2x3y3 = _mm_shuffle_ps(_mm_load_ps(bb2), _mm_load_ps(bb3), _MM_SHUFFLE(1, 0, 1, 0) ); + t_bb[0] = _mm_shuffle_ps(x0y0x1y1, x2y2x3y3, _MM_SHUFFLE(2, 0, 2, 0) ); + t_bb[1] = _mm_shuffle_ps(x0y0x1y1, x2y2x3y3, _MM_SHUFFLE(3, 1, 3, 1) ); + + const __m128 z0X0z1X1 = _mm_shuffle_ps(_mm_load_ps(bb0), _mm_load_ps(bb1), _MM_SHUFFLE(3, 2, 3, 2) ); + const __m128 z2X2z3X3 = _mm_shuffle_ps(_mm_load_ps(bb2), _mm_load_ps(bb3), _MM_SHUFFLE(3, 2, 3, 2) ); + t_bb[2] = _mm_shuffle_ps(z0X0z1X1, z2X2z3X3, _MM_SHUFFLE(2, 0, 2, 0) ); + t_bb[3] = _mm_shuffle_ps(z0X0z1X1, z2X2z3X3, _MM_SHUFFLE(3, 1, 3, 1) ); + + const __m128 Y0Z0Y1Z1 = _mm_shuffle_ps(_mm_load_ps(bb0 + 4), _mm_load_ps(bb1 + 4), _MM_SHUFFLE(1, 0, 1, 0) ); + const __m128 Y2Z2Y3Z3 = _mm_shuffle_ps(_mm_load_ps(bb2 + 4), _mm_load_ps(bb3 + 4), _MM_SHUFFLE(1, 0, 1, 0) ); + t_bb[4] = _mm_shuffle_ps(Y0Z0Y1Z1, Y2Z2Y3Z3, _MM_SHUFFLE(2, 0, 2, 0) ); + t_bb[5] = _mm_shuffle_ps(Y0Z0Y1Z1, Y2Z2Y3Z3, _MM_SHUFFLE(3, 1, 3, 1) ); #if 0 - for(int i=0; i<4; i++) + for (int i = 0; i < 4; i++) { - Node *t = stack[stack_pos+i]; + Node *t = stack[stack_pos + i]; assert(!is_leaf(t)); - float *bb = ((float*)t_bb)+i; - bb[4*0] = t->bb[0]; - bb[4*1] = t->bb[1]; - bb[4*2] = t->bb[2]; - bb[4*3] = t->bb[3]; - bb[4*4] = t->bb[4]; - bb[4*5] = t->bb[5]; + float *bb = ((float *)t_bb) + i; + bb[4 * 0] = t->bb[0]; + bb[4 * 1] = t->bb[1]; + bb[4 * 2] = t->bb[2]; + bb[4 * 3] = t->bb[3]; + bb[4 * 4] = t->bb[4]; + bb[4 * 5] = t->bb[5]; t_node[i] = t->child; } #endif RE_RC_COUNT(isec->raycounter->simd_bb.test); - int res = test_bb_group4( t_bb, isec ); + int res = test_bb_group4(t_bb, isec); for (int i = 0; i < 4; i++) - if (res & (1 << i)) { - RE_RC_COUNT(isec->raycounter->simd_bb.hit); - if (!is_leaf(t_node[i])) { - for (Node *t = t_node[i]; t; t = t->sibling) { - assert(stack_pos < MAX_STACK_SIZE); - stack[stack_pos++] = t; + if (res & (1 << i)) { + RE_RC_COUNT(isec->raycounter->simd_bb.hit); + if (!is_leaf(t_node[i])) { + for (Node *t = t_node[i]; t; t = t->sibling) { + assert(stack_pos < MAX_STACK_SIZE); + stack[stack_pos++] = t; + } + } + else { + hit |= RE_rayobject_intersect( (RayObject *)t_node[i], isec); + if (hit && isec->mode == RE_RAY_SHADOW) return hit; } } - else { - hit |= RE_rayobject_intersect( (RayObject*)t_node[i], isec); - if (hit && isec->mode == RE_RAY_SHADOW) return hit; - } - } } else if (stack_pos > 0) { Node *node = stack[--stack_pos]; @@ -300,7 +300,7 @@ static int bvh_node_stack_raycast_simd(Node *root, Isect *isec) assert(stack_pos <= MAX_STACK_SIZE); } else { - hit |= RE_rayobject_intersect( (RayObject*)node->child, isec); + hit |= RE_rayobject_intersect( (RayObject *)node->child, isec); if (hit && isec->mode == RE_RAY_SHADOW) return hit; } } @@ -324,7 +324,7 @@ static int bvh_node_raycast(Node *node, Isect *isec) if (isec->idot_axis[node->split_axis] > 0.0f) { int i; - for(i=0; i<BVH_NCHILDS; i++) + for (i = 0; i < BVH_NCHILDS; i++) if (!is_leaf(node->child[i])) { if (node->child[i] == 0) break; @@ -332,16 +332,14 @@ static int bvh_node_raycast(Node *node, Isect *isec) hit |= bvh_node_raycast(node->child[i], isec); if (hit && isec->mode == RE_RAY_SHADOW) return hit; } - else - { - hit |= RE_rayobject_intersect( (RayObject*)node->child[i], isec); + else { + hit |= RE_rayobject_intersect( (RayObject *)node->child[i], isec); if (hit && isec->mode == RE_RAY_SHADOW) return hit; } } - else - { + else { int i; - for(i=BVH_NCHILDS-1; i>=0; i--) + for (i = BVH_NCHILDS - 1; i >= 0; i--) if (!is_leaf(node->child[i])) { if (node->child[i]) @@ -350,9 +348,8 @@ static int bvh_node_raycast(Node *node, Isect *isec) if (hit && isec->mode == RE_RAY_SHADOW) return hit; } } - else - { - hit |= RE_rayobject_intersect( (RayObject*)node->child[i], isec); + else { + hit |= RE_rayobject_intersect( (RayObject *)node->child[i], isec); if (hit && isec->mode == RE_RAY_SHADOW) return hit; } } @@ -367,44 +364,44 @@ void bvh_dfs_make_hint(Node *node, LCTSHint *hint, int reserve_space, HintObject assert(hint->size + reserve_space + 1 <= RE_RAY_LCTS_MAX_SIZE); if (is_leaf(node)) { - hint->stack[hint->size++] = (RayObject*)node; + hint->stack[hint->size++] = (RayObject *)node; } else { int childs = count_childs(node); if (hint->size + reserve_space + childs <= RE_RAY_LCTS_MAX_SIZE) { - int result = hint_test_bb(hintObject, node->bb, node->bb+3); + int result = hint_test_bb(hintObject, node->bb, node->bb + 3); if (result == HINT_RECURSE) { /* We are 100% sure the ray will be pass inside this node */ bvh_dfs_make_hint_push_siblings(node->child, hint, reserve_space, hintObject); } else if (result == HINT_ACCEPT) { - hint->stack[hint->size++] = (RayObject*)node; + hint->stack[hint->size++] = (RayObject *)node; } } else { - hint->stack[hint->size++] = (RayObject*)node; + hint->stack[hint->size++] = (RayObject *)node; } } } template<class Tree> -static RayObjectAPI* bvh_get_api(int maxstacksize); +static RayObjectAPI *bvh_get_api(int maxstacksize); template<class Tree, int DFS_STACK_SIZE> static inline RayObject *bvh_create_tree(int size) { - Tree *obj= (Tree*)MEM_callocN(sizeof(Tree), "BVHTree" ); + Tree *obj = (Tree *)MEM_callocN(sizeof(Tree), "BVHTree"); assert(RE_rayobject_isAligned(obj)); /* RayObject API assumes real data to be 4-byte aligned */ obj->rayobj.api = bvh_get_api<Tree>(DFS_STACK_SIZE); obj->root = NULL; obj->node_arena = NULL; - obj->builder = rtbuild_create( size ); + obj->builder = rtbuild_create(size); - return RE_rayobject_unalignRayAPI((RayObject*) obj); + return RE_rayobject_unalignRayAPI((RayObject *) obj); } #endif diff --git a/source/blender/render/intern/raytrace/rayobject.cpp b/source/blender/render/intern/raytrace/rayobject.cpp index ac29d9e78ee..ca74367dd37 100644 --- a/source/blender/render/intern/raytrace/rayobject.cpp +++ b/source/blender/render/intern/raytrace/rayobject.cpp @@ -50,7 +50,7 @@ * because function is too long. Since this is code that is called billions * of times we really do want to inline. */ -MALWAYS_INLINE RayObject* rayface_from_coords(RayFace *rayface, void *ob, void *face, +MALWAYS_INLINE RayObject *rayface_from_coords(RayFace *rayface, void *ob, void *face, float *v1, float *v2, float *v3, float *v4) { rayface->ob = ob; @@ -85,14 +85,14 @@ MALWAYS_INLINE void rayface_from_vlak(RayFace *rayface, ObjectInstanceRen *obi, } } -RayObject* RE_rayface_from_vlak(RayFace *rayface, ObjectInstanceRen *obi, VlakRen *vlr) +RayObject *RE_rayface_from_vlak(RayFace *rayface, ObjectInstanceRen *obi, VlakRen *vlr) { return rayface_from_coords(rayface, obi, vlr, vlr->v1->co, vlr->v2->co, vlr->v3->co, vlr->v4 ? vlr->v4->co : 0); } /* VlakPrimitive */ -RayObject* RE_vlakprimitive_from_vlak(VlakPrimitive *face, struct ObjectInstanceRen *obi, struct VlakRen *vlr) +RayObject *RE_vlakprimitive_from_vlak(VlakPrimitive *face, struct ObjectInstanceRen *obi, struct VlakRen *vlr) { face->ob = obi; face->face = vlr; @@ -110,13 +110,13 @@ MALWAYS_INLINE int vlr_check_intersect(Isect *is, ObjectInstanceRen *obi, VlakRe return 0; /* I know... cpu cycle waste, might do smarter once */ - if (is->mode==RE_RAY_MIRROR) + if (is->mode == RE_RAY_MIRROR) return !(vlr->mat->mode & MA_ONLYCAST); else return (is->lay & obi->lay); } -MALWAYS_INLINE int vlr_check_intersect_solid(Isect *UNUSED(is), ObjectInstanceRen* UNUSED(obi), VlakRen *vlr) +MALWAYS_INLINE int vlr_check_intersect_solid(Isect *UNUSED(is), ObjectInstanceRen *UNUSED(obi), VlakRen *vlr) { /* solid material types only */ if (vlr->mat->material_type == MA_TYPE_SURFACE) @@ -125,7 +125,7 @@ MALWAYS_INLINE int vlr_check_intersect_solid(Isect *UNUSED(is), ObjectInstanceRe return 0; } -MALWAYS_INLINE int vlr_check_bake(Isect *is, ObjectInstanceRen* obi, VlakRen *UNUSED(vlr)) +MALWAYS_INLINE int vlr_check_bake(Isect *is, ObjectInstanceRen *obi, VlakRen *UNUSED(vlr)) { return (obi->obr->ob != is->userdata) && (obi->obr->ob->flag & SELECT); } @@ -138,7 +138,7 @@ MALWAYS_INLINE int isec_tri_quad(float start[3], float dir[3], RayFace *face, fl float t0[3], t1[3], x[3], r[3], m[3], u, v, divdet, det1, l; int quad; - quad= RE_rayface_isQuad(face); + quad = RE_rayface_isQuad(face); copy_v3_v3(co1, face->v1); copy_v3_v3(co2, face->v2); @@ -151,29 +151,29 @@ MALWAYS_INLINE int isec_tri_quad(float start[3], float dir[3], RayFace *face, fl sub_v3_v3v3(t1, co3, co1); cross_v3_v3v3(x, r, t1); - divdet= dot_v3v3(t0, x); + divdet = dot_v3v3(t0, x); sub_v3_v3v3(m, start, co3); - det1= dot_v3v3(m, x); + det1 = dot_v3v3(m, x); if (divdet != 0.0f) { - divdet= 1.0f/divdet; - v= det1*divdet; + divdet = 1.0f / divdet; + v = det1 * divdet; - if (v < RE_RAYTRACE_EPSILON && v > -(1.0f+RE_RAYTRACE_EPSILON)) { + if (v < RE_RAYTRACE_EPSILON && v > -(1.0f + RE_RAYTRACE_EPSILON)) { float cros[3]; cross_v3_v3v3(cros, m, t0); - u= divdet*dot_v3v3(cros, r); + u = divdet * dot_v3v3(cros, r); - if (u < RE_RAYTRACE_EPSILON && (v + u) > -(1.0f+RE_RAYTRACE_EPSILON)) { - l= divdet*dot_v3v3(cros, t1); + if (u < RE_RAYTRACE_EPSILON && (v + u) > -(1.0f + RE_RAYTRACE_EPSILON)) { + l = divdet * dot_v3v3(cros, t1); /* check if intersection is within ray length */ if (l > -RE_RAYTRACE_EPSILON && l < *lambda) { - uv[0]= u; - uv[1]= v; - *lambda= l; + uv[0] = u; + uv[1] = v; + *lambda = l; return 1; } } @@ -184,25 +184,25 @@ MALWAYS_INLINE int isec_tri_quad(float start[3], float dir[3], RayFace *face, fl if (quad) { copy_v3_v3(co4, face->v4); sub_v3_v3v3(t0, co3, co4); - divdet= dot_v3v3(t0, x); + divdet = dot_v3v3(t0, x); if (divdet != 0.0f) { - divdet= 1.0f/divdet; - v = det1*divdet; + divdet = 1.0f / divdet; + v = det1 * divdet; - if (v < RE_RAYTRACE_EPSILON && v > -(1.0f+RE_RAYTRACE_EPSILON)) { + if (v < RE_RAYTRACE_EPSILON && v > -(1.0f + RE_RAYTRACE_EPSILON)) { float cros[3]; cross_v3_v3v3(cros, m, t0); - u= divdet*dot_v3v3(cros, r); + u = divdet * dot_v3v3(cros, r); - if (u < RE_RAYTRACE_EPSILON && (v + u) > -(1.0f+RE_RAYTRACE_EPSILON)) { - l= divdet*dot_v3v3(cros, t1); + if (u < RE_RAYTRACE_EPSILON && (v + u) > -(1.0f + RE_RAYTRACE_EPSILON)) { + l = divdet * dot_v3v3(cros, t1); - if (l >- RE_RAYTRACE_EPSILON && l < *lambda) { - uv[0]= u; - uv[1]= -(1.0f + v + u); - *lambda= l; + if (l > -RE_RAYTRACE_EPSILON && l < *lambda) { + uv[0] = u; + uv[1] = -(1.0f + v + u); + *lambda = l; return 2; } } @@ -221,7 +221,7 @@ MALWAYS_INLINE int isec_tri_quad_neighbour(float start[3], float dir[3], RayFace float t0[3], t1[3], x[3], r[3], m[3], u, v, divdet, det1; int quad; - quad= RE_rayface_isQuad(face); + quad = RE_rayface_isQuad(face); copy_v3_v3(co1, face->v1); copy_v3_v3(co2, face->v2); @@ -234,22 +234,22 @@ MALWAYS_INLINE int isec_tri_quad_neighbour(float start[3], float dir[3], RayFace sub_v3_v3v3(t1, co3, co1); cross_v3_v3v3(x, r, t1); - divdet= dot_v3v3(t0, x); + divdet = dot_v3v3(t0, x); sub_v3_v3v3(m, start, co3); - det1= dot_v3v3(m, x); + det1 = dot_v3v3(m, x); if (divdet != 0.0f) { - divdet= 1.0f/divdet; - v= det1*divdet; + divdet = 1.0f / divdet; + v = det1 * divdet; - if (v < RE_RAYTRACE_EPSILON && v > -(1.0f+RE_RAYTRACE_EPSILON)) { + if (v < RE_RAYTRACE_EPSILON && v > -(1.0f + RE_RAYTRACE_EPSILON)) { float cros[3]; cross_v3_v3v3(cros, m, t0); - u= divdet*dot_v3v3(cros, r); + u = divdet * dot_v3v3(cros, r); - if (u < RE_RAYTRACE_EPSILON && (v + u) > -(1.0f+RE_RAYTRACE_EPSILON)) + if (u < RE_RAYTRACE_EPSILON && (v + u) > -(1.0f + RE_RAYTRACE_EPSILON)) return 1; } } @@ -258,19 +258,19 @@ MALWAYS_INLINE int isec_tri_quad_neighbour(float start[3], float dir[3], RayFace if (quad) { copy_v3_v3(co4, face->v4); sub_v3_v3v3(t0, co3, co4); - divdet= dot_v3v3(t0, x); + divdet = dot_v3v3(t0, x); if (divdet != 0.0f) { - divdet= 1.0f/divdet; - v = det1*divdet; + divdet = 1.0f / divdet; + v = det1 * divdet; - if (v < RE_RAYTRACE_EPSILON && v > -(1.0f+RE_RAYTRACE_EPSILON)) { + if (v < RE_RAYTRACE_EPSILON && v > -(1.0f + RE_RAYTRACE_EPSILON)) { float cros[3]; cross_v3_v3v3(cros, m, t0); - u= divdet*dot_v3v3(cros, r); + u = divdet * dot_v3v3(cros, r); - if (u < RE_RAYTRACE_EPSILON && (v + u) > -(1.0f+RE_RAYTRACE_EPSILON)) + if (u < RE_RAYTRACE_EPSILON && (v + u) > -(1.0f + RE_RAYTRACE_EPSILON)) return 2; } } @@ -285,7 +285,7 @@ MALWAYS_INLINE int isec_tri_quad_neighbour(float start[3], float dir[3], RayFace MALWAYS_INLINE int intersect_rayface(RayObject *hit_obj, RayFace *face, Isect *is) { float dist, uv[2]; - int ok= 0; + int ok = 0; /* avoid self-intersection */ if (is->orig.ob == face->ob && is->orig.face == face->face) @@ -293,25 +293,25 @@ MALWAYS_INLINE int intersect_rayface(RayObject *hit_obj, RayFace *face, Isect *i /* check if we should intersect this face */ if (is->check == RE_CHECK_VLR_RENDER) { - if (vlr_check_intersect(is, (ObjectInstanceRen*)face->ob, (VlakRen*)face->face) == 0) + if (vlr_check_intersect(is, (ObjectInstanceRen *)face->ob, (VlakRen *)face->face) == 0) return 0; } else if (is->check == RE_CHECK_VLR_NON_SOLID_MATERIAL) { - if (vlr_check_intersect(is, (ObjectInstanceRen*)face->ob, (VlakRen*)face->face) == 0) + if (vlr_check_intersect(is, (ObjectInstanceRen *)face->ob, (VlakRen *)face->face) == 0) return 0; - if (vlr_check_intersect_solid(is, (ObjectInstanceRen*)face->ob, (VlakRen*)face->face) == 0) + if (vlr_check_intersect_solid(is, (ObjectInstanceRen *)face->ob, (VlakRen *)face->face) == 0) return 0; } else if (is->check == RE_CHECK_VLR_BAKE) { - if (vlr_check_bake(is, (ObjectInstanceRen*)face->ob, (VlakRen*)face->face) == 0) + if (vlr_check_bake(is, (ObjectInstanceRen *)face->ob, (VlakRen *)face->face) == 0) return 0; } /* ray counter */ RE_RC_COUNT(is->raycounter->faces.test); - dist= is->dist; - ok= isec_tri_quad(is->start, is->dir, face, uv, &dist); + dist = is->dist; + ok = isec_tri_quad(is->start, is->dir, face, uv, &dist); if (ok) { @@ -319,21 +319,21 @@ MALWAYS_INLINE int intersect_rayface(RayObject *hit_obj, RayFace *face, Isect *i * of it, causing intersection to be detected in its neighbor face */ if (is->skip & RE_SKIP_VLR_NEIGHBOUR) { if (dist < 0.1f && is->orig.ob == face->ob) { - VlakRen * a = (VlakRen*)is->orig.face; - VlakRen * b = (VlakRen*)face->face; + VlakRen *a = (VlakRen *)is->orig.face; + VlakRen *b = (VlakRen *)face->face; /* so there's a shared edge or vertex, let's intersect ray with * face itself, if that's true we can safely return 1, otherwise * we assume the intersection is invalid, 0 */ - if (a->v1==b->v1 || a->v2==b->v1 || a->v3==b->v1 || a->v4==b->v1 || - a->v1==b->v2 || a->v2==b->v2 || a->v3==b->v2 || a->v4==b->v2 || - a->v1==b->v3 || a->v2==b->v3 || a->v3==b->v3 || a->v4==b->v3 || - (b->v4 && (a->v1==b->v4 || a->v2==b->v4 || a->v3==b->v4 || a->v4==b->v4))) + if (a->v1 == b->v1 || a->v2 == b->v1 || a->v3 == b->v1 || a->v4 == b->v1 || + a->v1 == b->v2 || a->v2 == b->v2 || a->v3 == b->v2 || a->v4 == b->v2 || + a->v1 == b->v3 || a->v2 == b->v3 || a->v3 == b->v3 || a->v4 == b->v3 || + (b->v4 && (a->v1 == b->v4 || a->v2 == b->v4 || a->v3 == b->v4 || a->v4 == b->v4))) { /* create RayFace from original face, transformed if necessary */ RayFace origface; - ObjectInstanceRen *ob= (ObjectInstanceRen*)is->orig.ob; - rayface_from_vlak(&origface, ob, (VlakRen*)is->orig.face); + ObjectInstanceRen *ob = (ObjectInstanceRen *)is->orig.ob; + rayface_from_vlak(&origface, ob, (VlakRen *)is->orig.face); if (!isec_tri_quad_neighbour(is->start, is->dir, &origface)) { return 0; @@ -344,9 +344,9 @@ MALWAYS_INLINE int intersect_rayface(RayObject *hit_obj, RayFace *face, Isect *i RE_RC_COUNT(is->raycounter->faces.hit); - is->isect= ok; // which half of the quad - is->dist= dist; - is->u= uv[0]; is->v= uv[1]; + is->isect = ok; // which half of the quad + is->dist = dist; + is->u = uv[0]; is->v = uv[1]; is->hit.ob = face->ob; is->hit.face = face->face; @@ -368,19 +368,19 @@ int RE_rayobject_raycast(RayObject *r, Isect *isec) RE_RC_COUNT(isec->raycounter->raycast.test); /* setup vars used on raycast */ - for (i=0; i<3; i++) { - isec->idot_axis[i] = 1.0f / isec->dir[i]; + for (i = 0; i < 3; i++) { + isec->idot_axis[i] = 1.0f / isec->dir[i]; - isec->bv_index[2*i] = isec->idot_axis[i] < 0.0 ? 1 : 0; - isec->bv_index[2*i+1] = 1 - isec->bv_index[2*i]; + isec->bv_index[2 * i] = isec->idot_axis[i] < 0.0 ? 1 : 0; + isec->bv_index[2 * i + 1] = 1 - isec->bv_index[2 * i]; - isec->bv_index[2*i] = i+3*isec->bv_index[2*i]; - isec->bv_index[2*i+1] = i+3*isec->bv_index[2*i+1]; + isec->bv_index[2 * i] = i + 3 * isec->bv_index[2 * i]; + isec->bv_index[2 * i + 1] = i + 3 * isec->bv_index[2 * i + 1]; } #ifdef RT_USE_LAST_HIT /* last hit heuristic */ - if (isec->mode==RE_RAY_SHADOW && isec->last_hit) { + if (isec->mode == RE_RAY_SHADOW && isec->last_hit) { RE_RC_COUNT(isec->raycounter->rayshadow_last_hit.test); if (RE_rayobject_intersect(isec->last_hit, isec)) { @@ -410,11 +410,11 @@ int RE_rayobject_raycast(RayObject *r, Isect *isec) int RE_rayobject_intersect(RayObject *r, Isect *i) { if (RE_rayobject_isRayFace(r)) { - return intersect_rayface(r, (RayFace*) RE_rayobject_align(r), i); + return intersect_rayface(r, (RayFace *) RE_rayobject_align(r), i); } else if (RE_rayobject_isVlakPrimitive(r)) { //TODO optimize (useless copy to RayFace to avoid duplicate code) - VlakPrimitive *face = (VlakPrimitive*) RE_rayobject_align(r); + VlakPrimitive *face = (VlakPrimitive *) RE_rayobject_align(r); RayFace nface; rayface_from_vlak(&nface, face->ob, face->face); @@ -470,7 +470,7 @@ float RE_rayobject_cost(RayObject *r) void RE_rayobject_merge_bb(RayObject *r, float *min, float *max) { if (RE_rayobject_isRayFace(r)) { - RayFace *face = (RayFace*) RE_rayobject_align(r); + RayFace *face = (RayFace *) RE_rayobject_align(r); DO_MINMAX(face->v1, min, max); DO_MINMAX(face->v2, min, max); @@ -478,7 +478,7 @@ void RE_rayobject_merge_bb(RayObject *r, float *min, float *max) if (RE_rayface_isQuad(face)) DO_MINMAX(face->v4, min, max); } else if (RE_rayobject_isVlakPrimitive(r)) { - VlakPrimitive *face = (VlakPrimitive*) RE_rayobject_align(r); + VlakPrimitive *face = (VlakPrimitive *) RE_rayobject_align(r); RayFace nface; rayface_from_vlak(&nface, face->ob, face->face); diff --git a/source/blender/render/intern/raytrace/rayobject_blibvh.cpp b/source/blender/render/intern/raytrace/rayobject_blibvh.cpp index 79ca21270fa..2d642a0a0d8 100644 --- a/source/blender/render/intern/raytrace/rayobject_blibvh.cpp +++ b/source/blender/render/intern/raytrace/rayobject_blibvh.cpp @@ -44,7 +44,7 @@ static int RE_rayobject_blibvh_intersect(RayObject *o, Isect *isec); static void RE_rayobject_blibvh_add(RayObject *o, RayObject *ob); static void RE_rayobject_blibvh_done(RayObject *o); static void RE_rayobject_blibvh_free(RayObject *o); -static void RE_rayobject_blibvh_bb(RayObject *o, float min[3], float max[3]); +static void RE_rayobject_blibvh_bb(RayObject * o, float min[3], float max[3]); static float RE_rayobject_blibvh_cost(RayObject *UNUSED(o)) { @@ -69,8 +69,7 @@ static RayObjectAPI bvh_api = RE_rayobject_blibvh_hint_bb }; -typedef struct BVHObject -{ +typedef struct BVHObject { RayObject rayobj; RayObject **leafs, **next_leaf; BVHTree *bvh; @@ -79,26 +78,25 @@ typedef struct BVHObject RayObject *RE_rayobject_blibvh_create(int size) { - BVHObject *obj= (BVHObject*)MEM_callocN(sizeof(BVHObject), "BVHObject"); + BVHObject *obj = (BVHObject *)MEM_callocN(sizeof(BVHObject), "BVHObject"); assert(RE_rayobject_isAligned(obj)); /* RayObject API assumes real data to be 4-byte aligned */ obj->rayobj.api = &bvh_api; obj->bvh = BLI_bvhtree_new(size, 0.0, 4, 6); - obj->next_leaf = obj->leafs = (RayObject**)MEM_callocN(size*sizeof(RayObject*), "BVHObject leafs"); + obj->next_leaf = obj->leafs = (RayObject **)MEM_callocN(size * sizeof(RayObject *), "BVHObject leafs"); INIT_MINMAX(obj->bb[0], obj->bb[1]); - return RE_rayobject_unalignRayAPI((RayObject*) obj); + return RE_rayobject_unalignRayAPI((RayObject *) obj); } -struct BVHCallbackUserData -{ +struct BVHCallbackUserData { Isect *isec; RayObject **leafs; }; static void bvh_callback(void *userdata, int index, const BVHTreeRay *UNUSED(ray), BVHTreeRayHit *hit) { - struct BVHCallbackUserData *data = (struct BVHCallbackUserData*)userdata; + struct BVHCallbackUserData *data = (struct BVHCallbackUserData *)userdata; Isect *isec = data->isec; RayObject *face = data->leafs[index]; @@ -114,7 +112,7 @@ static void bvh_callback(void *userdata, int index, const BVHTreeRay *UNUSED(ray static int RE_rayobject_blibvh_intersect(RayObject *o, Isect *isec) { - BVHObject *obj = (BVHObject*)o; + BVHObject *obj = (BVHObject *)o; BVHTreeRayHit hit; float dir[3]; struct BVHCallbackUserData data; @@ -126,15 +124,15 @@ static int RE_rayobject_blibvh_intersect(RayObject *o, Isect *isec) hit.index = 0; hit.dist = isec->dist; - return BLI_bvhtree_ray_cast(obj->bvh, isec->start, dir, 0.0, &hit, bvh_callback, (void*)&data); + return BLI_bvhtree_ray_cast(obj->bvh, isec->start, dir, 0.0, &hit, bvh_callback, (void *)&data); } static void RE_rayobject_blibvh_add(RayObject *o, RayObject *ob) { - BVHObject *obj = (BVHObject*)o; + BVHObject *obj = (BVHObject *)o; float min_max[6]; - INIT_MINMAX(min_max, min_max+3); - RE_rayobject_merge_bb(ob, min_max, min_max+3); + INIT_MINMAX(min_max, min_max + 3); + RE_rayobject_merge_bb(ob, min_max, min_max + 3); DO_MIN(min_max, obj->bb[0]); DO_MAX(min_max + 3, obj->bb[1]); @@ -145,13 +143,13 @@ static void RE_rayobject_blibvh_add(RayObject *o, RayObject *ob) static void RE_rayobject_blibvh_done(RayObject *o) { - BVHObject *obj = (BVHObject*)o; + BVHObject *obj = (BVHObject *)o; BLI_bvhtree_balance(obj->bvh); } static void RE_rayobject_blibvh_free(RayObject *o) { - BVHObject *obj = (BVHObject*)o; + BVHObject *obj = (BVHObject *)o; if (obj->bvh) BLI_bvhtree_free(obj->bvh); @@ -164,7 +162,7 @@ static void RE_rayobject_blibvh_free(RayObject *o) static void RE_rayobject_blibvh_bb(RayObject *o, float min[3], float max[3]) { - BVHObject *obj = (BVHObject*)o; + BVHObject *obj = (BVHObject *)o; DO_MIN(obj->bb[0], min); DO_MAX(obj->bb[1], max); } diff --git a/source/blender/render/intern/raytrace/rayobject_hint.h b/source/blender/render/intern/raytrace/rayobject_hint.h index 37d9edb035d..6eb3c035935 100644 --- a/source/blender/render/intern/raytrace/rayobject_hint.h +++ b/source/blender/render/intern/raytrace/rayobject_hint.h @@ -33,25 +33,23 @@ #ifndef __RAYOBJECT_HINT_H__ #define __RAYOBJECT_HINT_H__ -#define HINT_RECURSE 1 -#define HINT_ACCEPT 0 -#define HINT_DISCARD -1 +#define HINT_RECURSE 1 +#define HINT_ACCEPT 0 +#define HINT_DISCARD -1 -struct HintBB -{ +struct HintBB { float bb[6]; }; inline int hint_test_bb(HintBB *obj, float *Nmin, float *Nmax) { - if (bb_fits_inside( Nmin, Nmax, obj->bb, obj->bb+3 ) ) + if (bb_fits_inside(Nmin, Nmax, obj->bb, obj->bb + 3) ) return HINT_RECURSE; else return HINT_ACCEPT; } #if 0 -struct HintFrustum -{ +struct HintFrustum { float co[3]; float no[4][3]; }; diff --git a/source/blender/render/intern/raytrace/rayobject_qbvh.cpp b/source/blender/render/intern/raytrace/rayobject_qbvh.cpp index bfcfbee536f..2e37782d047 100644 --- a/source/blender/render/intern/raytrace/rayobject_qbvh.cpp +++ b/source/blender/render/intern/raytrace/rayobject_qbvh.cpp @@ -40,10 +40,9 @@ #ifdef __SSE__ -#define DFS_STACK_SIZE 256 +#define DFS_STACK_SIZE 256 -struct QBVHTree -{ +struct QBVHTree { RayObject rayobj; SVBVHNode *root; @@ -61,11 +60,11 @@ void bvh_done<QBVHTree>(QBVHTree *obj) //TODO find a away to exactly calculate the needed memory MemArena *arena1 = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "qbvh arena"); - BLI_memarena_use_malloc(arena1); + BLI_memarena_use_malloc(arena1); MemArena *arena2 = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "qbvh arena 2"); - BLI_memarena_use_malloc(arena2); - BLI_memarena_use_align(arena2, 16); + BLI_memarena_use_malloc(arena2); + BLI_memarena_use_align(arena2, 16); //Build and optimize the tree //TODO do this in 1 pass (half memory usage during building) @@ -95,7 +94,7 @@ void bvh_done<QBVHTree>(QBVHTree *obj) } template<int StackSize> -int intersect(QBVHTree *obj, Isect* isec) +int intersect(QBVHTree *obj, Isect *isec) { //TODO renable hint support if (RE_rayobject_isAligned(obj->root)) { @@ -105,7 +104,7 @@ int intersect(QBVHTree *obj, Isect* isec) return svbvh_node_stack_raycast<StackSize, false>(obj->root, isec); } else - return RE_rayobject_intersect((RayObject*)obj->root, isec); + return RE_rayobject_intersect((RayObject *)obj->root, isec); } template<class Tree> @@ -114,7 +113,7 @@ void bvh_hint_bb(Tree *tree, LCTSHint *hint, float *UNUSED(min), float *UNUSED(m //TODO renable hint support { hint->size = 0; - hint->stack[hint->size++] = (RayObject*)tree->root; + hint->stack[hint->size++] = (RayObject *)tree->root; } } /* the cast to pointer function is needed to workarround gcc bug: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=11407 */ @@ -123,20 +122,20 @@ RayObjectAPI make_api() { static RayObjectAPI api = { - (RE_rayobject_raycast_callback) ((int(*)(Tree*, Isect*)) &intersect<STACK_SIZE>), - (RE_rayobject_add_callback) ((void(*)(Tree*, RayObject*)) &bvh_add<Tree>), - (RE_rayobject_done_callback) ((void(*)(Tree*)) &bvh_done<Tree>), - (RE_rayobject_free_callback) ((void(*)(Tree*)) &bvh_free<Tree>), - (RE_rayobject_merge_bb_callback)((void(*)(Tree*, float*, float*)) &bvh_bb<Tree>), - (RE_rayobject_cost_callback) ((float(*)(Tree*)) &bvh_cost<Tree>), - (RE_rayobject_hint_bb_callback) ((void(*)(Tree*, LCTSHint*, float*, float*)) &bvh_hint_bb<Tree>) + (RE_rayobject_raycast_callback) ((int (*)(Tree *, Isect *)) & intersect<STACK_SIZE>), + (RE_rayobject_add_callback) ((void (*)(Tree *, RayObject *)) & bvh_add<Tree>), + (RE_rayobject_done_callback) ((void (*)(Tree *)) & bvh_done<Tree>), + (RE_rayobject_free_callback) ((void (*)(Tree *)) & bvh_free<Tree>), + (RE_rayobject_merge_bb_callback)((void (*)(Tree *, float *, float *)) & bvh_bb<Tree>), + (RE_rayobject_cost_callback) ((float (*)(Tree *)) & bvh_cost<Tree>), + (RE_rayobject_hint_bb_callback) ((void (*)(Tree *, LCTSHint *, float *, float *)) & bvh_hint_bb<Tree>) }; return api; } template<class Tree> -RayObjectAPI* bvh_get_api(int maxstacksize) +RayObjectAPI *bvh_get_api(int maxstacksize) { static RayObjectAPI bvh_api256 = make_api<Tree, 1024>(); diff --git a/source/blender/render/intern/raytrace/rayobject_rtbuild.cpp b/source/blender/render/intern/raytrace/rayobject_rtbuild.cpp index eb3bdb37f9d..66af64be160 100644 --- a/source/blender/render/intern/raytrace/rayobject_rtbuild.cpp +++ b/source/blender/render/intern/raytrace/rayobject_rtbuild.cpp @@ -54,19 +54,19 @@ static void rtbuild_init(RTBuilder *b) b->primitives.end = 0; b->primitives.maxsize = 0; - for (int i=0; i<RTBUILD_MAX_CHILDS; i++) + for (int i = 0; i < RTBUILD_MAX_CHILDS; i++) b->child_offset[i] = 0; - for (int i=0; i<3; i++) + for (int i = 0; i < 3; i++) b->sorted_begin[i] = b->sorted_end[i] = 0; - INIT_MINMAX(b->bb, b->bb+3); + INIT_MINMAX(b->bb, b->bb + 3); } -RTBuilder* rtbuild_create(int size) +RTBuilder *rtbuild_create(int size) { - RTBuilder *builder = (RTBuilder*) MEM_mallocN( sizeof(RTBuilder), "RTBuilder" ); - RTBuilder::Object *memblock= (RTBuilder::Object*)MEM_mallocN( sizeof(RTBuilder::Object)*size, "RTBuilder.objects"); + RTBuilder *builder = (RTBuilder *) MEM_mallocN(sizeof(RTBuilder), "RTBuilder"); + RTBuilder::Object *memblock = (RTBuilder::Object *)MEM_mallocN(sizeof(RTBuilder::Object) * size, "RTBuilder.objects"); rtbuild_init(builder); @@ -74,8 +74,8 @@ RTBuilder* rtbuild_create(int size) builder->primitives.begin = builder->primitives.end = memblock; builder->primitives.maxsize = size; - for (int i=0; i<3; i++) { - builder->sorted_begin[i] = (RTBuilder::Object**)MEM_mallocN( sizeof(RTBuilder::Object*)*size, "RTBuilder.sorted_objects"); + for (int i = 0; i < 3; i++) { + builder->sorted_begin[i] = (RTBuilder::Object **)MEM_mallocN(sizeof(RTBuilder::Object *) * size, "RTBuilder.sorted_objects"); builder->sorted_end[i] = builder->sorted_begin[i]; } @@ -87,7 +87,7 @@ void rtbuild_free(RTBuilder *b) { if (b->primitives.begin) MEM_freeN(b->primitives.begin); - for (int i=0; i<3; i++) + for (int i = 0; i < 3; i++) if (b->sorted_begin[i]) MEM_freeN(b->sorted_begin[i]); @@ -98,10 +98,10 @@ void rtbuild_add(RTBuilder *b, RayObject *o) { float bb[6]; - assert( b->primitives.begin + b->primitives.maxsize != b->primitives.end ); + assert(b->primitives.begin + b->primitives.maxsize != b->primitives.end); - INIT_MINMAX(bb, bb+3); - RE_rayobject_merge_bb(o, bb, bb+3); + INIT_MINMAX(bb, bb + 3); + RE_rayobject_merge_bb(o, bb, bb + 3); /* skip objects with invalid bounding boxes, nan causes DO_MINMAX * to do nothing, so we get these invalid values. this shouldn't @@ -114,16 +114,16 @@ void rtbuild_add(RTBuilder *b, RayObject *o) if (!finite(bb[3]) || !finite(bb[4]) || !finite(bb[5])) return; /* skip objects with zero bounding box, they are of no use, and - * will give problems in rtbuild_heuristic_object_split later */ + * will give problems in rtbuild_heuristic_object_split later */ if (bb[0] == bb[3] && bb[1] == bb[4] && bb[2] == bb[5]) return; copy_v3_v3(b->primitives.end->bb, bb); - copy_v3_v3(b->primitives.end->bb+3, bb+3); + copy_v3_v3(b->primitives.end->bb + 3, bb + 3); b->primitives.end->obj = o; b->primitives.end->cost = RE_rayobject_cost(o); - for (int i=0; i<3; i++) { + for (int i = 0; i < 3; i++) { *(b->sorted_end[i]) = b->primitives.end; b->sorted_end[i]++; } @@ -153,32 +153,33 @@ static void object_sort(Item *begin, Item *end, int axis) assert(false); } -void rtbuild_done(RTBuilder *b, RayObjectControl* ctrl) +void rtbuild_done(RTBuilder *b, RayObjectControl *ctrl) { - for (int i=0; i<3; i++) - if (b->sorted_begin[i]) { - if (RE_rayobjectcontrol_test_break(ctrl)) break; - object_sort( b->sorted_begin[i], b->sorted_end[i], i ); + for (int i = 0; i < 3; i++) { + if (b->sorted_begin[i]) { + if (RE_rayobjectcontrol_test_break(ctrl)) break; + object_sort(b->sorted_begin[i], b->sorted_end[i], i); + } } } -RayObject* rtbuild_get_primitive(RTBuilder *b, int index) +RayObject *rtbuild_get_primitive(RTBuilder *b, int index) { return b->sorted_begin[0][index]->obj; } -RTBuilder* rtbuild_get_child(RTBuilder *b, int child, RTBuilder *tmp) +RTBuilder *rtbuild_get_child(RTBuilder *b, int child, RTBuilder *tmp) { - rtbuild_init( tmp ); + rtbuild_init(tmp); - for (int i=0; i<3; i++) + for (int i = 0; i < 3; i++) if (b->sorted_begin[i]) { - tmp->sorted_begin[i] = b->sorted_begin[i] + b->child_offset[child ]; - tmp->sorted_end [i] = b->sorted_begin[i] + b->child_offset[child+1]; + tmp->sorted_begin[i] = b->sorted_begin[i] + b->child_offset[child]; + tmp->sorted_end[i] = b->sorted_begin[i] + b->child_offset[child + 1]; } else { tmp->sorted_begin[i] = 0; - tmp->sorted_end [i] = 0; + tmp->sorted_end[i] = 0; } return tmp; @@ -188,7 +189,7 @@ void rtbuild_calc_bb(RTBuilder *b) { if (b->bb[0] == 1.0e30f) { for (RTBuilder::Object **index = b->sorted_begin[0]; index != b->sorted_end[0]; index++) - RE_rayobject_merge_bb( (*index)->obj, b->bb, b->bb+3); + RE_rayobject_merge_bb( (*index)->obj, b->bb, b->bb + 3); } } @@ -196,14 +197,14 @@ void rtbuild_merge_bb(RTBuilder *b, float *min, float *max) { rtbuild_calc_bb(b); DO_MIN(b->bb, min); - DO_MAX(b->bb+3, max); + DO_MAX(b->bb + 3, max); } #if 0 int rtbuild_get_largest_axis(RTBuilder *b) { rtbuild_calc_bb(b); - return bb_largest_axis(b->bb, b->bb+3); + return bb_largest_axis(b->bb, b->bb + 3); } //Left balanced tree @@ -219,26 +220,25 @@ int rtbuild_mean_split(RTBuilder *b, int nchilds, int axis) assert(nchilds <= RTBUILD_MAX_CHILDS); //TODO optimize calc of leafs_per_child - for (s=nchilds; s<tot_leafs; s*=nchilds); - Mleafs_per_child = s/nchilds; - mleafs_per_child = Mleafs_per_child/nchilds; + for (s = nchilds; s < tot_leafs; s *= nchilds) ; + Mleafs_per_child = s / nchilds; + mleafs_per_child = Mleafs_per_child / nchilds; //split min leafs per child b->child_offset[0] = 0; - for (i=1; i<=nchilds; i++) + for (i = 1; i <= nchilds; i++) b->child_offset[i] = mleafs_per_child; //split remaining leafs - missing_leafs = tot_leafs - mleafs_per_child*nchilds; - for (i=1; i<=nchilds; i++) + missing_leafs = tot_leafs - mleafs_per_child * nchilds; + for (i = 1; i <= nchilds; i++) { if (missing_leafs > Mleafs_per_child - mleafs_per_child) { b->child_offset[i] += Mleafs_per_child - mleafs_per_child; missing_leafs -= Mleafs_per_child - mleafs_per_child; } - else - { + else { b->child_offset[i] += missing_leafs; missing_leafs = 0; break; @@ -246,14 +246,14 @@ int rtbuild_mean_split(RTBuilder *b, int nchilds, int axis) } //adjust for accumulative offsets - for (i=1; i<=nchilds; i++) - b->child_offset[i] += b->child_offset[i-1]; + for (i = 1; i <= nchilds; i++) + b->child_offset[i] += b->child_offset[i - 1]; //Count created childs - for (i=nchilds; b->child_offset[i] == b->child_offset[i-1]; i--); + for (i = nchilds; b->child_offset[i] == b->child_offset[i - 1]; i--) ; split_leafs(b, b->child_offset, i, axis); - assert( b->child_offset[0] == 0 && b->child_offset[i] == tot_leafs ); + assert(b->child_offset[0] == 0 && b->child_offset[i] == tot_leafs); return i; } @@ -279,20 +279,19 @@ int rtbuild_median_split(RTBuilder *b, float *separators, int nchilds, int axis) { return rtbuild_mean_split(b, nchilds, axis); } - else - { + else { int i; b->split_axis = axis; //Calculate child offsets b->child_offset[0] = 0; - for (i=0; i<nchilds-1; i++) - b->child_offset[i+1] = split_leafs_by_plane(b, b->child_offset[i], size, separators[i]); + for (i = 0; i < nchilds - 1; i++) + b->child_offset[i + 1] = split_leafs_by_plane(b, b->child_offset[i], size, separators[i]); b->child_offset[nchilds] = size; - for (i=0; i<nchilds; i++) - if (b->child_offset[i+1] - b->child_offset[i] == size) + for (i = 0; i < nchilds; i++) + if (b->child_offset[i + 1] - b->child_offset[i] == size) return rtbuild_mean_split(b, nchilds, axis); return nchilds; @@ -306,9 +305,9 @@ int rtbuild_median_split_largest_axis(RTBuilder *b, int nchilds) rtbuild_calc_bb(b); - la = bb_largest_axis(b->bb, b->bb+3); - for (i=1; i<nchilds; i++) - separators[i-1] = (b->bb[la+3]-b->bb[la])*i / nchilds; + la = bb_largest_axis(b->bb, b->bb + 3); + for (i = 1; i < nchilds; i++) + separators[i - 1] = (b->bb[la + 3] - b->bb[la]) * i / nchilds; return rtbuild_median_split(b, separators, nchilds, la); } @@ -317,8 +316,7 @@ int rtbuild_median_split_largest_axis(RTBuilder *b, int nchilds) //Heuristics Object Splitter -struct SweepCost -{ +struct SweepCost { float bb[6]; float cost; }; @@ -333,30 +331,30 @@ int rtbuild_heuristic_object_split(RTBuilder *b, int nchilds) if (size > nchilds) { float bcost = FLT_MAX; - baxis = -1, boffset = size/2; + baxis = -1, boffset = size / 2; - SweepCost *sweep = (SweepCost*)MEM_mallocN( sizeof(SweepCost)*size, "RTBuilder.HeuristicSweep" ); + SweepCost *sweep = (SweepCost *)MEM_mallocN(sizeof(SweepCost) * size, "RTBuilder.HeuristicSweep"); - for (int axis=0; axis<3; axis++) { + for (int axis = 0; axis < 3; axis++) { SweepCost sweep_left; RTBuilder::Object **obj = b->sorted_begin[axis]; // float right_cost = 0; - for (int i=size-1; i>=0; i--) { - if (i == size-1) { + for (int i = size - 1; i >= 0; i--) { + if (i == size - 1) { copy_v3_v3(sweep[i].bb, obj[i]->bb); - copy_v3_v3(sweep[i].bb+3, obj[i]->bb+3); + copy_v3_v3(sweep[i].bb + 3, obj[i]->bb + 3); sweep[i].cost = obj[i]->cost; } else { - sweep[i].bb[0] = MIN2(obj[i]->bb[0], sweep[i+1].bb[0]); - sweep[i].bb[1] = MIN2(obj[i]->bb[1], sweep[i+1].bb[1]); - sweep[i].bb[2] = MIN2(obj[i]->bb[2], sweep[i+1].bb[2]); - sweep[i].bb[3] = MAX2(obj[i]->bb[3], sweep[i+1].bb[3]); - sweep[i].bb[4] = MAX2(obj[i]->bb[4], sweep[i+1].bb[4]); - sweep[i].bb[5] = MAX2(obj[i]->bb[5], sweep[i+1].bb[5]); - sweep[i].cost = obj[i]->cost + sweep[i+1].cost; + sweep[i].bb[0] = MIN2(obj[i]->bb[0], sweep[i + 1].bb[0]); + sweep[i].bb[1] = MIN2(obj[i]->bb[1], sweep[i + 1].bb[1]); + sweep[i].bb[2] = MIN2(obj[i]->bb[2], sweep[i + 1].bb[2]); + sweep[i].bb[3] = MAX2(obj[i]->bb[3], sweep[i + 1].bb[3]); + sweep[i].bb[4] = MAX2(obj[i]->bb[4], sweep[i + 1].bb[4]); + sweep[i].bb[5] = MAX2(obj[i]->bb[5], sweep[i + 1].bb[5]); + sweep[i].cost = obj[i]->cost + sweep[i + 1].cost; } // right_cost += obj[i]->cost; } @@ -371,7 +369,7 @@ int rtbuild_heuristic_object_split(RTBuilder *b, int nchilds) // right_cost -= obj[0]->cost; if (right_cost < 0) right_cost = 0; - for (int i=1; i<size; i++) { + for (int i = 1; i < size; i++) { //Worst case heuristic (cost of each child is linear) float hcost, left_side, right_side; @@ -379,24 +377,24 @@ int rtbuild_heuristic_object_split(RTBuilder *b, int nchilds) // makes tree construction quicker, left out for now to test (brecht) // left_side = bb_area(sweep_left.bb, sweep_left.bb+3)*(sweep_left.cost+logf((float)i)); // right_side= bb_area(sweep[i].bb, sweep[i].bb+3)*(sweep[i].cost+logf((float)size-i)); - left_side = bb_area(sweep_left.bb, sweep_left.bb+3)*(sweep_left.cost); - right_side= bb_area(sweep[i].bb, sweep[i].bb+3)*(sweep[i].cost); - hcost = left_side+right_side; + left_side = bb_area(sweep_left.bb, sweep_left.bb + 3) * (sweep_left.cost); + right_side = bb_area(sweep[i].bb, sweep[i].bb + 3) * (sweep[i].cost); + hcost = left_side + right_side; assert(left_side >= 0); assert(right_side >= 0); - if (left_side > bcost) break; //No way we can find a better heuristic in this axis + if (left_side > bcost) break; //No way we can find a better heuristic in this axis assert(hcost >= 0); // this makes sure the tree built is the same whatever is the order of the sorting axis - if ( hcost < bcost || (hcost == bcost && axis < baxis)) { + if (hcost < bcost || (hcost == bcost && axis < baxis)) { bcost = hcost; baxis = axis; boffset = i; } - DO_MIN( obj[i]->bb, sweep_left.bb ); - DO_MAX( obj[i]->bb+3, sweep_left.bb+3 ); + DO_MIN(obj[i]->bb, sweep_left.bb); + DO_MAX(obj[i]->bb + 3, sweep_left.bb + 3); sweep_left.cost += obj[i]->cost; // right_cost -= obj[i]->cost; if (right_cost < 0) right_cost = 0; @@ -426,10 +424,10 @@ int rtbuild_heuristic_object_split(RTBuilder *b, int nchilds) /* Adjust sorted arrays for childs */ - for (int i=0; i<boffset; i++) b->sorted_begin[baxis][i]->selected = true; - for (int i=boffset; i<size; i++) b->sorted_begin[baxis][i]->selected = false; - for (int i=0; i<3; i++) - std::stable_partition( b->sorted_begin[i], b->sorted_end[i], selected_node ); + for (int i = 0; i < boffset; i++) b->sorted_begin[baxis][i]->selected = true; + for (int i = boffset; i < size; i++) b->sorted_begin[baxis][i]->selected = false; + for (int i = 0; i < 3; i++) + std::stable_partition(b->sorted_begin[i], b->sorted_end[i], selected_node); return nchilds; } @@ -445,13 +443,13 @@ static void split_leafs(RTBuilder *b, int *nth, int partitions, int split_axis) int i; b->split_axis = split_axis; - for (i=0; i < partitions-1; i++) + for (i = 0; i < partitions - 1; i++) { - assert(nth[i] < nth[i+1] && nth[i+1] < nth[partitions]); + assert(nth[i] < nth[i + 1] && nth[i + 1] < nth[partitions]); - if (split_axis == 0) std::nth_element(b, nth[i], nth[i+1], nth[partitions], obj_bb_compare<RTBuilder::Object, 0>); - if (split_axis == 1) std::nth_element(b, nth[i], nth[i+1], nth[partitions], obj_bb_compare<RTBuilder::Object, 1>); - if (split_axis == 2) std::nth_element(b, nth[i], nth[i+1], nth[partitions], obj_bb_compare<RTBuilder::Object, 2>); + if (split_axis == 0) std::nth_element(b, nth[i], nth[i + 1], nth[partitions], obj_bb_compare<RTBuilder::Object, 0>); + if (split_axis == 1) std::nth_element(b, nth[i], nth[i + 1], nth[partitions], obj_bb_compare<RTBuilder::Object, 1>); + if (split_axis == 2) std::nth_element(b, nth[i], nth[i + 1], nth[partitions], obj_bb_compare<RTBuilder::Object, 2>); } } #endif @@ -461,20 +459,20 @@ static void split_leafs(RTBuilder *b, int *nth, int partitions, int split_axis) */ float bb_volume(float *min, float *max) { - return (max[0]-min[0])*(max[1]-min[1])*(max[2]-min[2]); + return (max[0] - min[0]) * (max[1] - min[1]) * (max[2] - min[2]); } float bb_area(float *min, float *max) { float sub[3], a; - sub[0] = max[0]-min[0]; - sub[1] = max[1]-min[1]; - sub[2] = max[2]-min[2]; - - a = (sub[0]*sub[1] + sub[0]*sub[2] + sub[1]*sub[2])*2; - /* used to have an assert() here on negative results - * however, in this case its likely some overflow or ffast math error. - * so just return 0.0f instead. */ + sub[0] = max[0] - min[0]; + sub[1] = max[1] - min[1]; + sub[2] = max[2] - min[2]; + + a = (sub[0] * sub[1] + sub[0] * sub[2] + sub[1] * sub[2]) * 2; + /* used to have an assert() here on negative results + * however, in this case its likely some overflow or ffast math error. + * so just return 0.0f instead. */ return a < 0.0f ? 0.0f : a; } @@ -482,9 +480,9 @@ int bb_largest_axis(float *min, float *max) { float sub[3]; - sub[0] = max[0]-min[0]; - sub[1] = max[1]-min[1]; - sub[2] = max[2]-min[2]; + sub[0] = max[0] - min[0]; + sub[1] = max[1] - min[1]; + sub[2] = max[2] - min[2]; if (sub[0] > sub[1]) { if (sub[0] > sub[2]) return 0; @@ -502,10 +500,10 @@ int bb_largest_axis(float *min, float *max) int bb_fits_inside(float *outer_min, float *outer_max, float *inner_min, float *inner_max) { int i; - for (i=0; i<3; i++) + for (i = 0; i < 3; i++) if (outer_min[i] > inner_min[i]) return 0; - for (i=0; i<3; i++) + for (i = 0; i < 3; i++) if (outer_max[i] < inner_max[i]) return 0; return 1; diff --git a/source/blender/render/intern/raytrace/rayobject_rtbuild.h b/source/blender/render/intern/raytrace/rayobject_rtbuild.h index f6e9aabf43d..22e3d009c07 100644 --- a/source/blender/render/intern/raytrace/rayobject_rtbuild.h +++ b/source/blender/render/intern/raytrace/rayobject_rtbuild.h @@ -52,10 +52,8 @@ extern "C" { #define RTBUILD_MAX_CHILDS 32 -typedef struct RTBuilder -{ - struct Object - { +typedef struct RTBuilder { + struct Object { RayObject *obj; float cost; float bb[6]; @@ -63,8 +61,7 @@ typedef struct RTBuilder }; /* list to all primitives added in this tree */ - struct - { + struct { Object *begin, *end; int maxsize; } primitives; @@ -76,7 +73,7 @@ typedef struct RTBuilder int split_axis; /* child partitions calculated during splitting */ - int child_offset[RTBUILD_MAX_CHILDS+1]; + int child_offset[RTBUILD_MAX_CHILDS + 1]; // int child_sorted_axis; /* -1 if not sorted */ @@ -85,17 +82,17 @@ typedef struct RTBuilder } RTBuilder; /* used during creation */ -RTBuilder* rtbuild_create(int size); +RTBuilder *rtbuild_create(int size); void rtbuild_free(RTBuilder *b); void rtbuild_add(RTBuilder *b, RayObject *o); void rtbuild_done(RTBuilder *b, RayObjectControl *c); void rtbuild_merge_bb(RTBuilder *b, float *min, float *max); int rtbuild_size(RTBuilder *b); -RayObject* rtbuild_get_primitive(RTBuilder *b, int offset); +RayObject *rtbuild_get_primitive(RTBuilder *b, int offset); /* used during tree reorganization */ -RTBuilder* rtbuild_get_child(RTBuilder *b, int child, RTBuilder *tmp); +RTBuilder *rtbuild_get_child(RTBuilder *b, int child, RTBuilder *tmp); /* Calculates child partitions and returns number of efectively needed partitions */ int rtbuild_get_largest_axis(RTBuilder *b); diff --git a/source/blender/render/intern/raytrace/rayobject_svbvh.cpp b/source/blender/render/intern/raytrace/rayobject_svbvh.cpp index 3cf2b4b5d5f..697ba9ad6e2 100644 --- a/source/blender/render/intern/raytrace/rayobject_svbvh.cpp +++ b/source/blender/render/intern/raytrace/rayobject_svbvh.cpp @@ -40,10 +40,9 @@ #ifdef __SSE__ -#define DFS_STACK_SIZE 256 +#define DFS_STACK_SIZE 256 -struct SVBVHTree -{ +struct SVBVHTree { RayObject rayobj; SVBVHNode *root; @@ -56,11 +55,10 @@ struct SVBVHTree /* * Cost to test N childs */ -struct PackCost -{ +struct PackCost { float operator()(int n) { - return (n / 4) + ((n % 4) > 2 ? 1 : n%4); + return (n / 4) + ((n % 4) > 2 ? 1 : n % 4); } }; @@ -72,11 +70,11 @@ void bvh_done<SVBVHTree>(SVBVHTree *obj) //TODO find a away to exactly calculate the needed memory MemArena *arena1 = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "svbvh arena"); - BLI_memarena_use_malloc(arena1); + BLI_memarena_use_malloc(arena1); MemArena *arena2 = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "svbvh arena2"); - BLI_memarena_use_malloc(arena2); - BLI_memarena_use_align(arena2, 16); + BLI_memarena_use_malloc(arena2); + BLI_memarena_use_align(arena2, 16); //Build and optimize the tree if (0) { @@ -123,12 +121,12 @@ void bvh_done<SVBVHTree>(SVBVHTree *obj) obj->node_arena = arena2; obj->cost = 1.0; - rtbuild_free( obj->builder ); + rtbuild_free(obj->builder); obj->builder = NULL; } template<int StackSize> -int intersect(SVBVHTree *obj, Isect* isec) +int intersect(SVBVHTree *obj, Isect *isec) { //TODO renable hint support if (RE_rayobject_isAligned(obj->root)) { @@ -138,7 +136,7 @@ int intersect(SVBVHTree *obj, Isect* isec) return svbvh_node_stack_raycast<StackSize, false>(obj->root, isec); } else - return RE_rayobject_intersect( (RayObject*) obj->root, isec ); + return RE_rayobject_intersect( (RayObject *) obj->root, isec); } template<class Tree> @@ -147,7 +145,7 @@ void bvh_hint_bb(Tree *tree, LCTSHint *hint, float *UNUSED(min), float *UNUSED(m //TODO renable hint support { hint->size = 0; - hint->stack[hint->size++] = (RayObject*)tree->root; + hint->stack[hint->size++] = (RayObject *)tree->root; } } /* the cast to pointer function is needed to workarround gcc bug: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=11407 */ @@ -156,20 +154,20 @@ RayObjectAPI make_api() { static RayObjectAPI api = { - (RE_rayobject_raycast_callback) ((int(*)(Tree*, Isect*)) &intersect<STACK_SIZE>), - (RE_rayobject_add_callback) ((void(*)(Tree*, RayObject*)) &bvh_add<Tree>), - (RE_rayobject_done_callback) ((void(*)(Tree*)) &bvh_done<Tree>), - (RE_rayobject_free_callback) ((void(*)(Tree*)) &bvh_free<Tree>), - (RE_rayobject_merge_bb_callback)((void(*)(Tree*, float*, float*)) &bvh_bb<Tree>), - (RE_rayobject_cost_callback) ((float(*)(Tree*)) &bvh_cost<Tree>), - (RE_rayobject_hint_bb_callback) ((void(*)(Tree*, LCTSHint*, float*, float*)) &bvh_hint_bb<Tree>) + (RE_rayobject_raycast_callback) ((int (*)(Tree *, Isect *)) & intersect<STACK_SIZE>), + (RE_rayobject_add_callback) ((void (*)(Tree *, RayObject *)) & bvh_add<Tree>), + (RE_rayobject_done_callback) ((void (*)(Tree *)) & bvh_done<Tree>), + (RE_rayobject_free_callback) ((void (*)(Tree *)) & bvh_free<Tree>), + (RE_rayobject_merge_bb_callback)((void (*)(Tree *, float *, float *)) & bvh_bb<Tree>), + (RE_rayobject_cost_callback) ((float (*)(Tree *)) & bvh_cost<Tree>), + (RE_rayobject_hint_bb_callback) ((void (*)(Tree *, LCTSHint *, float *, float *)) & bvh_hint_bb<Tree>) }; return api; } template<class Tree> -RayObjectAPI* bvh_get_api(int maxstacksize) +RayObjectAPI *bvh_get_api(int maxstacksize) { static RayObjectAPI bvh_api256 = make_api<Tree, 1024>(); diff --git a/source/blender/render/intern/raytrace/rayobject_vbvh.cpp b/source/blender/render/intern/raytrace/rayobject_vbvh.cpp index 47e78b8912e..9e7075438cb 100644 --- a/source/blender/render/intern/raytrace/rayobject_vbvh.cpp +++ b/source/blender/render/intern/raytrace/rayobject_vbvh.cpp @@ -55,10 +55,9 @@ int tot_hints = 0; #include <queue> #include <algorithm> -#define DFS_STACK_SIZE 256 +#define DFS_STACK_SIZE 256 -struct VBVHTree -{ +struct VBVHTree { RayObject rayobj; VBVHNode *root; MemArena *node_arena; @@ -69,8 +68,7 @@ struct VBVHTree /* * Cost to test N childs */ -struct PackCost -{ +struct PackCost { float operator()(int n) { return n; @@ -84,7 +82,7 @@ void bvh_done<VBVHTree>(VBVHTree *obj) //TODO find a away to exactly calculate the needed memory MemArena *arena1 = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "vbvh arena"); - BLI_memarena_use_malloc(arena1); + BLI_memarena_use_malloc(arena1); //Build and optimize the tree if (1) { @@ -107,10 +105,10 @@ void bvh_done<VBVHTree>(VBVHTree *obj) obj->root = NULL; } else { -/* - TODO + /* TODO */ +#if 0 MemArena *arena2 = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "vbvh arena2"); - BLI_memarena_use_malloc(arena2); + BLI_memarena_use_malloc(arena2); //Finds the optimal packing of this tree using a given cost model //TODO this uses quite a lot of memory, find ways to reduce memory usage during building @@ -119,11 +117,11 @@ void bvh_done<VBVHTree>(VBVHTree *obj) obj->root = Reorganize_VBVH<OVBVHNode>(arena1).transform(root); BLI_memarena_free(arena2); - */ +#endif } //Cleanup - rtbuild_free( obj->builder ); + rtbuild_free(obj->builder); obj->builder = NULL; obj->node_arena = arena1; @@ -131,17 +129,17 @@ void bvh_done<VBVHTree>(VBVHTree *obj) } template<int StackSize> -int intersect(VBVHTree *obj, Isect* isec) +int intersect(VBVHTree *obj, Isect *isec) { //TODO renable hint support if (RE_rayobject_isAligned(obj->root)) { if (isec->mode == RE_RAY_SHADOW) - return bvh_node_stack_raycast<VBVHNode, StackSize, false, true>( obj->root, isec); + return bvh_node_stack_raycast<VBVHNode, StackSize, false, true>(obj->root, isec); else - return bvh_node_stack_raycast<VBVHNode, StackSize, false, false>( obj->root, isec); + return bvh_node_stack_raycast<VBVHNode, StackSize, false, false>(obj->root, isec); } else - return RE_rayobject_intersect( (RayObject*) obj->root, isec ); + return RE_rayobject_intersect( (RayObject *) obj->root, isec); } template<class Tree> @@ -150,7 +148,7 @@ void bvh_hint_bb(Tree *tree, LCTSHint *hint, float *UNUSED(min), float *UNUSED(m //TODO renable hint support { hint->size = 0; - hint->stack[hint->size++] = (RayObject*)tree->root; + hint->stack[hint->size++] = (RayObject *)tree->root; } } @@ -178,20 +176,20 @@ RayObjectAPI make_api() { static RayObjectAPI api = { - (RE_rayobject_raycast_callback) ((int(*)(Tree*, Isect*)) &intersect<STACK_SIZE>), - (RE_rayobject_add_callback) ((void(*)(Tree*, RayObject*)) &bvh_add<Tree>), - (RE_rayobject_done_callback) ((void(*)(Tree*)) &bvh_done<Tree>), - (RE_rayobject_free_callback) ((void(*)(Tree*)) &bvh_free<Tree>), - (RE_rayobject_merge_bb_callback)((void(*)(Tree*, float*, float*)) &bvh_bb<Tree>), - (RE_rayobject_cost_callback) ((float(*)(Tree*)) &bvh_cost<Tree>), - (RE_rayobject_hint_bb_callback) ((void(*)(Tree*, LCTSHint*, float*, float*)) &bvh_hint_bb<Tree>) + (RE_rayobject_raycast_callback) ((int (*)(Tree *, Isect *)) & intersect<STACK_SIZE>), + (RE_rayobject_add_callback) ((void (*)(Tree *, RayObject *)) & bvh_add<Tree>), + (RE_rayobject_done_callback) ((void (*)(Tree *)) & bvh_done<Tree>), + (RE_rayobject_free_callback) ((void (*)(Tree *)) & bvh_free<Tree>), + (RE_rayobject_merge_bb_callback)((void (*)(Tree *, float *, float *)) & bvh_bb<Tree>), + (RE_rayobject_cost_callback) ((float (*)(Tree *)) & bvh_cost<Tree>), + (RE_rayobject_hint_bb_callback) ((void (*)(Tree *, LCTSHint *, float *, float *)) & bvh_hint_bb<Tree>) }; return api; } template<class Tree> -RayObjectAPI* bvh_get_api(int maxstacksize) +RayObjectAPI *bvh_get_api(int maxstacksize) { static RayObjectAPI bvh_api256 = make_api<Tree, 1024>(); diff --git a/source/blender/render/intern/raytrace/reorganize.h b/source/blender/render/intern/raytrace/reorganize.h index a47bd27d11b..1e9a0319b2f 100644 --- a/source/blender/render/intern/raytrace/reorganize.h +++ b/source/blender/render/intern/raytrace/reorganize.h @@ -57,13 +57,13 @@ extern int tot_pushdown; template<class Node> bool node_fits_inside(Node *a, Node *b) { - return bb_fits_inside(b->bb, b->bb+3, a->bb, a->bb+3); + return bb_fits_inside(b->bb, b->bb + 3, a->bb, a->bb + 3); } template<class Node> -void reorganize_find_fittest_parent(Node *tree, Node *node, std::pair<float, Node*> &cost) +void reorganize_find_fittest_parent(Node *tree, Node *node, std::pair<float, Node *> &cost) { - std::queue<Node*> q; + std::queue<Node *> q; q.push(tree); while (!q.empty()) { @@ -72,8 +72,8 @@ void reorganize_find_fittest_parent(Node *tree, Node *node, std::pair<float, Nod if (parent == node) continue; if (node_fits_inside(node, parent) && RE_rayobject_isAligned(parent->child) ) { - float pcost = bb_area(parent->bb, parent->bb+3); - cost = std::min( cost, std::make_pair(pcost, parent) ); + float pcost = bb_area(parent->bb, parent->bb + 3); + cost = std::min(cost, std::make_pair(pcost, parent) ); for (Node *child = parent->child; child; child = child->sibling) q.push(child); } @@ -84,11 +84,11 @@ static int tot_moves = 0; template<class Node> void reorganize(Node *root) { - std::queue<Node*> q; + std::queue<Node *> q; q.push(root); while (!q.empty()) { - Node * node = q.front(); + Node *node = q.front(); q.pop(); if (RE_rayobject_isAligned(node->child)) { @@ -96,7 +96,7 @@ void reorganize(Node *root) assert(RE_rayobject_isAligned(*prev)); q.push(*prev); - std::pair<float, Node*> best(FLT_MAX, root); + std::pair<float, Node *> best(FLT_MAX, root); reorganize_find_fittest_parent(root, *prev, best); if (best.second == node) { @@ -129,7 +129,7 @@ void reorganize(Node *root) template<class Node> void remove_useless(Node *node, Node **new_node) { - if ( RE_rayobject_isAligned(node->child) ) { + if (RE_rayobject_isAligned(node->child) ) { for (Node **prev = &node->child; *prev; ) { Node *next = (*prev)->sibling; @@ -160,12 +160,12 @@ void pushup(Node *parent) { if (is_leaf(parent)) return; - float p_area = bb_area(parent->bb, parent->bb+3); + float p_area = bb_area(parent->bb, parent->bb + 3); Node **prev = &parent->child; for (Node *child = parent->child; RE_rayobject_isAligned(child) && child; ) { const float c_area = bb_area(child->bb, child->bb + 3); const int nchilds = count_childs(child); - float original_cost = ((p_area != 0.0f)? (c_area / p_area)*nchilds: 1.0f) + 1; + float original_cost = ((p_area != 0.0f) ? (c_area / p_area) * nchilds : 1.0f) + 1; float flatten_cost = nchilds; if (flatten_cost < original_cost && nchilds >= 2) { append_sibling(child, child->child); @@ -201,7 +201,7 @@ void pushup_simd(Node *parent) Node **prev = &parent->child; for (Node *child = parent->child; RE_rayobject_isAligned(child) && child; ) { int cn = count_childs(child); - if (cn-1 <= (SSize - (n%SSize) ) % SSize && RE_rayobject_isAligned(child->child) ) { + if (cn - 1 <= (SSize - (n % SSize) ) % SSize && RE_rayobject_isAligned(child->child) ) { n += (cn - 1); append_sibling(child, child->child); child = child->sibling; @@ -227,7 +227,7 @@ template<class Node> void pushdown(Node *parent) { Node **s_child = &parent->child; - Node * child = parent->child; + Node *child = parent->child; while (child && RE_rayobject_isAligned(child)) { Node *next = child->sibling; @@ -236,18 +236,18 @@ void pushdown(Node *parent) //assert(bb_fits_inside(parent->bb, parent->bb+3, child->bb, child->bb+3)); for (Node *i = parent->child; RE_rayobject_isAligned(i) && i; i = i->sibling) - if (child != i && bb_fits_inside(i->bb, i->bb+3, child->bb, child->bb+3) && RE_rayobject_isAligned(i->child)) { + if (child != i && bb_fits_inside(i->bb, i->bb + 3, child->bb, child->bb + 3) && RE_rayobject_isAligned(i->child)) { // todo optimize (should the one with the smallest area?) // float ia = bb_area(i->bb, i->bb+3) // if (child->i) - *s_child = child->sibling; - child->sibling = i->child; - i->child = child; - next_s_child = s_child; + *s_child = child->sibling; + child->sibling = i->child; + i->child = child; + next_s_child = s_child; - tot_pushdown++; - break; - } + tot_pushdown++; + break; + } child = next; s_child = next_s_child; } @@ -273,13 +273,13 @@ float bvh_refit(Node *node) for (Node *child = node->child; child; child = child->sibling) total += bvh_refit(child); - float old_area = bb_area(node->bb, node->bb+3); - INIT_MINMAX(node->bb, node->bb+3); + float old_area = bb_area(node->bb, node->bb + 3); + INIT_MINMAX(node->bb, node->bb + 3); for (Node *child = node->child; child; child = child->sibling) { DO_MIN(child->bb, node->bb); - DO_MAX(child->bb+3, node->bb+3); + DO_MAX(child->bb + 3, node->bb + 3); } - total += old_area - bb_area(node->bb, node->bb+3); + total += old_area - bb_area(node->bb, node->bb + 3); return total; } @@ -289,12 +289,11 @@ float bvh_refit(Node *node) * with the purpose to reduce the expected cost (eg.: number of BB tests). */ #include <vector> -#define MAX_CUT_SIZE 4 /* svbvh assumes max 4 children! */ -#define MAX_OPTIMIZE_CHILDS MAX_CUT_SIZE +#define MAX_CUT_SIZE 4 /* svbvh assumes max 4 children! */ +#define MAX_OPTIMIZE_CHILDS MAX_CUT_SIZE -struct OVBVHNode -{ - float bb[6]; +struct OVBVHNode { + float bb[6]; OVBVHNode *child; OVBVHNode *sibling; @@ -306,7 +305,7 @@ struct OVBVHNode float cut_cost[MAX_CUT_SIZE]; float get_cost(int cutsize) { - return cut_cost[cutsize-1]; + return cut_cost[cutsize - 1]; } /* @@ -316,7 +315,7 @@ struct OVBVHNode int cut_size[MAX_CUT_SIZE]; int get_cut_size(int parent_cut_size) { - return cut_size[parent_cut_size-1]; + return cut_size[parent_cut_size - 1]; } /* @@ -327,19 +326,21 @@ struct OVBVHNode { if (cutsize == 1) { **cut = this; - *cut = &(**cut)->sibling; + *cut = &(**cut)->sibling; } else { if (cutsize > MAX_CUT_SIZE) { for (OVBVHNode *child = this->child; child && RE_rayobject_isAligned(child); child = child->sibling) { - child->set_cut( 1, cut ); + child->set_cut(1, cut); cutsize--; } assert(cutsize == 0); } - else - for (OVBVHNode *child = this->child; child && RE_rayobject_isAligned(child); child = child->sibling) - child->set_cut( child->get_cut_size( cutsize ), cut ); + else { + for (OVBVHNode *child = this->child; child && RE_rayobject_isAligned(child); child = child->sibling) { + child->set_cut(child->get_cut_size(cutsize), cut); + } + } } } @@ -365,8 +366,7 @@ struct OVBVHNode * */ template<class Node, class TestCost> -struct VBVH_optimalPackSIMD -{ +struct VBVH_optimalPackSIMD { TestCost testcost; VBVH_optimalPackSIMD(TestCost testcost) @@ -377,8 +377,7 @@ struct VBVH_optimalPackSIMD /* * calc best cut on a node */ - struct calc_best - { + struct calc_best { Node *child[MAX_OPTIMIZE_CHILDS]; float child_hit_prob[MAX_OPTIMIZE_CHILDS]; @@ -387,10 +386,10 @@ struct VBVH_optimalPackSIMD int nchilds = 0; //Fetch childs and needed data { - float parent_area = bb_area(node->bb, node->bb+3); + float parent_area = bb_area(node->bb, node->bb + 3); for (Node *child = node->child; child && RE_rayobject_isAligned(child); child = child->sibling) { this->child[nchilds] = child; - this->child_hit_prob[nchilds] = (parent_area != 0.0f)? bb_area(child->bb, child->bb+3) / parent_area: 1.0f; + this->child_hit_prob[nchilds] = (parent_area != 0.0f) ? bb_area(child->bb, child->bb + 3) / parent_area : 1.0f; nchilds++; } @@ -399,7 +398,7 @@ struct VBVH_optimalPackSIMD //Build DP table to find minimum cost to represent this node with a given cutsize - int bt [MAX_OPTIMIZE_CHILDS + 1][MAX_CUT_SIZE + 1]; //backtrace table + int bt[MAX_OPTIMIZE_CHILDS + 1][MAX_CUT_SIZE + 1]; //backtrace table float cost[MAX_OPTIMIZE_CHILDS + 1][MAX_CUT_SIZE + 1]; //cost table (can be reduced to float[2][MAX_CUT_COST]) for (int i = 0; i <= nchilds; i++) { @@ -410,13 +409,13 @@ struct VBVH_optimalPackSIMD cost[0][0] = 0; - for (int i = 1; i<=nchilds; i++) { - for (int size = i - 1; size/*+(nchilds-i)*/<=MAX_CUT_SIZE; size++) { - for (int cut = 1; cut+size/*+(nchilds-i)*/<=MAX_CUT_SIZE; cut++) { + for (int i = 1; i <= nchilds; i++) { + for (int size = i - 1; size /*+(nchilds-i)*/ <= MAX_CUT_SIZE; size++) { + for (int cut = 1; cut + size /*+(nchilds-i)*/ <= MAX_CUT_SIZE; cut++) { float new_cost = cost[i - 1][size] + child_hit_prob[i - 1] * child[i - 1]->get_cost(cut); - if (new_cost < cost[i][size+cut]) { - cost[i][size+cut] = new_cost; - bt[i][size+cut] = cut; + if (new_cost < cost[i][size + cut]) { + cost[i][size + cut] = new_cost; + bt[i][size + cut] = cut; } } } @@ -424,11 +423,11 @@ struct VBVH_optimalPackSIMD //Save the ways to archieve the minimum cost with a given cutsize for (int i = nchilds; i <= MAX_CUT_SIZE; i++) { - node->cut_cost[i-1] = cost[nchilds][i]; + node->cut_cost[i - 1] = cost[nchilds][i]; if (cost[nchilds][i] < INFINITY) { int current_size = i; - for (int j=nchilds; j>0; j--) { - child[j-1]->cut_size[i-1] = bt[j][current_size]; + for (int j = nchilds; j > 0; j--) { + child[j - 1]->cut_size[i - 1] = bt[j][current_size]; current_size -= bt[j][current_size]; } } @@ -439,23 +438,23 @@ struct VBVH_optimalPackSIMD void calc_costs(Node *node) { - if ( RE_rayobject_isAligned(node->child) ) { + if (RE_rayobject_isAligned(node->child) ) { int nchilds = 0; for (Node *child = node->child; child && RE_rayobject_isAligned(child); child = child->sibling) { calc_costs(child); nchilds++; } - for (int i=0; i<MAX_CUT_SIZE; i++) + for (int i = 0; i < MAX_CUT_SIZE; i++) node->cut_cost[i] = INFINITY; //We are not allowed to look on nodes with with so many childs if (nchilds > MAX_CUT_SIZE) { float cost = 0; - float parent_area = bb_area(node->bb, node->bb+3); + float parent_area = bb_area(node->bb, node->bb + 3); for (Node *child = node->child; child && RE_rayobject_isAligned(child); child = child->sibling) { - cost += ((parent_area != 0.0f)? ( bb_area(child->bb, child->bb+3) / parent_area ): 1.0f) * child->get_cost(1); + cost += ((parent_area != 0.0f) ? (bb_area(child->bb, child->bb + 3) / parent_area) : 1.0f) * child->get_cost(1); } cost += testcost(nchilds); @@ -466,7 +465,7 @@ struct VBVH_optimalPackSIMD calc_best calc(node); //calc expected cost if we optimaly pack this node - for (int cutsize=nchilds; cutsize<=MAX_CUT_SIZE; cutsize++) { + for (int cutsize = nchilds; cutsize <= MAX_CUT_SIZE; cutsize++) { float m = node->get_cost(cutsize) + testcost(cutsize); if (m < node->cut_cost[0]) { node->cut_cost[0] = m; @@ -491,7 +490,7 @@ struct VBVH_optimalPackSIMD if (num == 0) { num++; first = true; } calc_costs(node); - if ((G.debug & G_DEBUG) && first) printf("expected cost = %f (%d)\n", node->cut_cost[0], node->best_cutsize ); + if ((G.debug & G_DEBUG) && first) printf("expected cost = %f (%d)\n", node->cut_cost[0], node->best_cutsize); node->optimize(); } return node; diff --git a/source/blender/render/intern/raytrace/svbvh.h b/source/blender/render/intern/raytrace/svbvh.h index ff402446b9f..a58094e5021 100644 --- a/source/blender/render/intern/raytrace/svbvh.h +++ b/source/blender/render/intern/raytrace/svbvh.h @@ -41,8 +41,7 @@ #include <stdio.h> #include <algorithm> -struct SVBVHNode -{ +struct SVBVHNode { float child_bb[24]; SVBVHNode *child[4]; int nchilds; @@ -120,12 +119,12 @@ static int svbvh_node_stack_raycast(SVBVHNode *root, Isect *isec) node = stack[--stack_pos]; if (!svbvh_node_is_leaf(node)) { - int nchilds= node->nchilds; + int nchilds = node->nchilds; if (nchilds == 4) { - float *child_bb= node->child_bb; - int res = svbvh_bb_intersect_test_simd4(isec, ((__m128*) (child_bb))); - SVBVHNode **child= node->child; + float *child_bb = node->child_bb; + int res = svbvh_bb_intersect_test_simd4(isec, ((__m128 *) (child_bb))); + SVBVHNode **child = node->child; RE_RC_COUNT(isec->raycounter->simd_bb.test); @@ -135,8 +134,8 @@ static int svbvh_node_stack_raycast(SVBVHNode *root, Isect *isec) if (res & 8) { stack[stack_pos++] = child[3]; RE_RC_COUNT(isec->raycounter->simd_bb.hit); } } else { - float *child_bb= node->child_bb; - SVBVHNode **child= node->child; + float *child_bb = node->child_bb; + SVBVHNode **child = node->child; int i; for (i = 0; i < nchilds; i++) { @@ -147,7 +146,7 @@ static int svbvh_node_stack_raycast(SVBVHNode *root, Isect *isec) } } else { - hit |= RE_rayobject_intersect((RayObject*)node, isec); + hit |= RE_rayobject_intersect((RayObject *)node, isec); if (SHADOW && hit) break; } } @@ -160,7 +159,7 @@ template<> inline void bvh_node_merge_bb<SVBVHNode>(SVBVHNode *node, float min[3], float max[3]) { if (is_leaf(node)) { - RE_rayobject_merge_bb((RayObject*)node, min, max); + RE_rayobject_merge_bb((RayObject *)node, min, max); } else { int i; @@ -180,7 +179,7 @@ inline void bvh_node_merge_bb<SVBVHNode>(SVBVHNode *node, float min[3], float ma } } - for ( ; i < node->nchilds; i++) { + for (; i < node->nchilds; i++) { DO_MIN(node->child_bb + 6 * i, min); DO_MAX(node->child_bb + 3 + 6 * i, max); } @@ -193,8 +192,7 @@ inline void bvh_node_merge_bb<SVBVHNode>(SVBVHNode *node, float min[3], float ma * Builds a SVBVH tree form a VBVHTree */ template<class OldNode> -struct Reorganize_SVBVH -{ +struct Reorganize_SVBVH { MemArena *arena; float childs_per_node; @@ -220,14 +218,14 @@ struct Reorganize_SVBVH printf("%f childs per node\n", childs_per_node / nodes); printf("%d childs BB are useless\n", useless_bb); for (int i = 0; i < 16; i++) { - printf("%i childs per node: %d/%d = %f\n", i, nodes_with_childs[i], nodes, nodes_with_childs[i]/float(nodes)); + printf("%i childs per node: %d/%d = %f\n", i, nodes_with_childs[i], nodes, nodes_with_childs[i] / float(nodes)); } } } SVBVHNode *create_node(int nchilds) { - SVBVHNode *node = (SVBVHNode*)BLI_memarena_alloc(arena, sizeof(SVBVHNode)); + SVBVHNode *node = (SVBVHNode *)BLI_memarena_alloc(arena, sizeof(SVBVHNode)); node->nchilds = nchilds; return node; @@ -235,22 +233,22 @@ struct Reorganize_SVBVH void copy_bb(float *bb, const float *old_bb) { - std::copy(old_bb, old_bb+6, bb); + std::copy(old_bb, old_bb + 6, bb); } void prepare_for_simd(SVBVHNode *node) { - int i=0; + int i = 0; while (i + 4 <= node->nchilds) { - float vec_tmp[4*6]; - float *res = node->child_bb+6*i; - std::copy(res, res+6*4, vec_tmp); - - for (int j=0; j<6; j++) { - res[4*j+0] = vec_tmp[6*0+j]; - res[4*j+1] = vec_tmp[6*1+j]; - res[4*j+2] = vec_tmp[6*2+j]; - res[4*j+3] = vec_tmp[6*3+j]; + float vec_tmp[4 * 6]; + float *res = node->child_bb + 6 * i; + std::copy(res, res + 6 * 4, vec_tmp); + + for (int j = 0; j < 6; j++) { + res[4 * j + 0] = vec_tmp[6 * 0 + j]; + res[4 * j + 1] = vec_tmp[6 * 1 + j]; + res[4 * j + 2] = vec_tmp[6 * 2 + j]; + res[4 * j + 3] = vec_tmp[6 * 3 + j]; } i += 4; @@ -260,15 +258,15 @@ struct Reorganize_SVBVH /* amt must be power of two */ inline int padup(int num, int amt) { - return ((num+(amt-1))&~(amt-1)); + return ((num + (amt - 1)) & ~(amt - 1)); } SVBVHNode *transform(OldNode *old) { if (is_leaf(old)) - return (SVBVHNode*)old; + return (SVBVHNode *)old; if (is_leaf(old->child)) - return (SVBVHNode*)old->child; + return (SVBVHNode *)old->child; int nchilds = count_childs(old); int alloc_childs = nchilds; @@ -282,27 +280,27 @@ struct Reorganize_SVBVH if (nchilds < 16) nodes_with_childs[nchilds]++; - useless_bb += alloc_childs-nchilds; + useless_bb += alloc_childs - nchilds; while (alloc_childs > nchilds) { const static float def_bb[6] = { FLT_MAX, FLT_MAX, FLT_MAX, FLT_MIN, FLT_MIN, FLT_MIN }; alloc_childs--; node->child[alloc_childs] = NULL; - copy_bb(node->child_bb+alloc_childs*6, def_bb); + copy_bb(node->child_bb + alloc_childs * 6, def_bb); } - int i=nchilds; + int i = nchilds; for (OldNode *o_child = old->child; o_child; o_child = o_child->sibling) { i--; node->child[i] = transform(o_child); if (is_leaf(o_child)) { float bb[6]; - INIT_MINMAX(bb, bb+3); - RE_rayobject_merge_bb((RayObject*)o_child, bb, bb+3); - copy_bb(node->child_bb+i*6, bb); + INIT_MINMAX(bb, bb + 3); + RE_rayobject_merge_bb((RayObject *)o_child, bb, bb + 3); + copy_bb(node->child_bb + i * 6, bb); break; } else { - copy_bb(node->child_bb+i*6, o_child->bb); + copy_bb(node->child_bb + i * 6, o_child->bb); } } assert(i == 0); diff --git a/source/blender/render/intern/raytrace/vbvh.h b/source/blender/render/intern/raytrace/vbvh.h index d8ff9000a3f..ec671f95c76 100644 --- a/source/blender/render/intern/raytrace/vbvh.h +++ b/source/blender/render/intern/raytrace/vbvh.h @@ -40,9 +40,8 @@ /* * VBVHNode represents a BVHNode with support for a variable number of childrens */ -struct VBVHNode -{ - float bb[6]; +struct VBVHNode { + float bb[6]; VBVHNode *child; VBVHNode *sibling; @@ -107,8 +106,7 @@ void append_sibling(Node *node, Node *sibling) * Builds a binary VBVH from a rtbuild */ template<class Node> -struct BuildBinaryVBVH -{ +struct BuildBinaryVBVH { MemArena *arena; RayObjectControl *control; @@ -126,7 +124,7 @@ struct BuildBinaryVBVH Node *create_node() { - Node *node = (Node*)BLI_memarena_alloc( arena, sizeof(Node) ); + Node *node = (Node *)BLI_memarena_alloc(arena, sizeof(Node) ); assert(RE_rayobject_isAligned(node)); node->sibling = NULL; @@ -146,7 +144,7 @@ struct BuildBinaryVBVH { return _transform(builder); - } catch(...) + } catch (...) { } return NULL; @@ -161,8 +159,8 @@ struct BuildBinaryVBVH } else if (size == 1) { Node *node = create_node(); - INIT_MINMAX(node->bb, node->bb+3); - rtbuild_merge_bb(builder, node->bb, node->bb+3); + INIT_MINMAX(node->bb, node->bb + 3); + rtbuild_merge_bb(builder, node->bb, node->bb + 3); node->child = (Node *) rtbuild_get_primitive(builder, 0); return node; } @@ -174,7 +172,7 @@ struct BuildBinaryVBVH Node **child = &node->child; int nc = rtbuild_split(builder); - INIT_MINMAX(node->bb, node->bb+3); + INIT_MINMAX(node->bb, node->bb + 3); assert(nc == 2); for (int i = 0; i < nc; i++) { @@ -183,7 +181,7 @@ struct BuildBinaryVBVH *child = _transform(&tmp); DO_MIN((*child)->bb, node->bb); - DO_MAX((*child)->bb+3, node->bb+3); + DO_MAX((*child)->bb + 3, node->bb + 3); child = &((*child)->sibling); } @@ -194,9 +192,8 @@ struct BuildBinaryVBVH }; #if 0 -template<class Tree,class OldNode> -struct Reorganize_VBVH -{ +template<class Tree, class OldNode> +struct Reorganize_VBVH { Tree *tree; Reorganize_VBVH(Tree *t) @@ -206,27 +203,27 @@ struct Reorganize_VBVH VBVHNode *create_node() { - VBVHNode *node = (VBVHNode*)BLI_memarena_alloc(tree->node_arena, sizeof(VBVHNode)); + VBVHNode *node = (VBVHNode *)BLI_memarena_alloc(tree->node_arena, sizeof(VBVHNode)); return node; } void copy_bb(VBVHNode *node, OldNode *old) { - std::copy( old->bb, old->bb+6, node->bb ); + std::copy(old->bb, old->bb + 6, node->bb); } VBVHNode *transform(OldNode *old) { if (is_leaf(old)) - return (VBVHNode*)old; + return (VBVHNode *)old; VBVHNode *node = create_node(); VBVHNode **child_ptr = &node->child; node->sibling = 0; - copy_bb(node,old); + copy_bb(node, old); - for(OldNode *o_child = old->child; o_child; o_child = o_child->sibling) + for (OldNode *o_child = old->child; o_child; o_child = o_child->sibling) { VBVHNode *n_child = transform(o_child); *child_ptr = n_child; diff --git a/source/blender/render/intern/source/texture_ocean.c b/source/blender/render/intern/source/texture_ocean.c index c13347dc162..4ef88e4740a 100644 --- a/source/blender/render/intern/source/texture_ocean.c +++ b/source/blender/render/intern/source/texture_ocean.c @@ -56,7 +56,7 @@ extern struct Render R; /* ***** actual texture sampling ***** */ int ocean_texture(Tex *tex, float *texvec, TexResult *texres) { - OceanTex *ot= tex->ot; + OceanTex *ot = tex->ot; ModifierData *md; OceanModifierData *omd; @@ -64,8 +64,8 @@ int ocean_texture(Tex *tex, float *texvec, TexResult *texres) if ( !(ot) || !(ot->object) || - !(md = (ModifierData *)modifiers_findByType(ot->object, eModifierType_Ocean)) || - !(omd= (OceanModifierData *)md)->ocean) + !(md = (ModifierData *)modifiers_findByType(ot->object, eModifierType_Ocean)) || + !(omd = (OceanModifierData *)md)->ocean) { return 0; } @@ -75,10 +75,10 @@ int ocean_texture(Tex *tex, float *texvec, TexResult *texres) int retval = TEX_INT; OceanResult ocr; - const float u = 0.5f+0.5f*texvec[0]; - const float v = 0.5f+0.5f*texvec[1]; + const float u = 0.5f + 0.5f * texvec[0]; + const float v = 0.5f + 0.5f * texvec[1]; - if (omd->oceancache && omd->cached==TRUE) { + if (omd->oceancache && omd->cached == TRUE) { CLAMP(cfra, omd->bakestart, omd->bakeend); cfra -= omd->bakestart; // shift to 0 based diff --git a/source/blender/windowmanager/intern/wm_window.c b/source/blender/windowmanager/intern/wm_window.c index 5f6b15dee02..af3ba02ed4d 100644 --- a/source/blender/windowmanager/intern/wm_window.c +++ b/source/blender/windowmanager/intern/wm_window.c @@ -932,7 +932,7 @@ static int wm_window_timer(const bContext *C) wtnext = wt->next; /* in case timer gets removed */ win = wt->win; - if (wt->sleep== 0) { + if (wt->sleep == 0) { if (time > wt->ntime) { wt->delta = time - wt->ltime; wt->duration += wt->delta; |