GHOST: Fix uninitialized var
[blender.git] / source / blender / render / intern / raytrace / rayobject_svbvh.cpp
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2009 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): AndrĂ© Pinto.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/render/intern/raytrace/rayobject_svbvh.cpp
29  *  \ingroup render
30  */
31
32
33 #include "MEM_guardedalloc.h"
34
35 #include "BLI_utildefines.h"
36
37 #include "vbvh.h"
38 #include "svbvh.h"
39 #include "reorganize.h"
40
41 #ifdef __SSE__
42
43 #define DFS_STACK_SIZE  256
44
45 struct SVBVHTree {
46         RayObject rayobj;
47
48         SVBVHNode *root;
49         MemArena *node_arena;
50
51         float cost;
52         RTBuilder *builder;
53 };
54
55 /*
56  * Cost to test N childs
57  */
58 struct PackCost {
59         float operator()(int n)
60         {
61                 return (n / 4) + ((n % 4) > 2 ? 1 : n % 4);
62         }
63 };
64
65
66 template<>
67 void bvh_done<SVBVHTree>(SVBVHTree *obj)
68 {
69         rtbuild_done(obj->builder, &obj->rayobj.control);
70
71         //TODO find a away to exactly calculate the needed memory
72         MemArena *arena1 = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "svbvh arena");
73         BLI_memarena_use_malloc(arena1);
74
75         MemArena *arena2 = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, "svbvh arena2");
76         BLI_memarena_use_malloc(arena2);
77         BLI_memarena_use_align(arena2, 16);
78
79         //Build and optimize the tree
80         if (0) {
81                 VBVHNode *root = BuildBinaryVBVH<VBVHNode>(arena1, &obj->rayobj.control).transform(obj->builder);
82
83                 if (RE_rayobjectcontrol_test_break(&obj->rayobj.control)) {
84                         BLI_memarena_free(arena1);
85                         BLI_memarena_free(arena2);
86                         return;
87                 }
88
89                 reorganize(root);
90                 remove_useless(root, &root);
91                 bvh_refit(root);
92
93                 pushup(root);
94                 pushdown(root);
95                 pushup_simd<VBVHNode, 4>(root);
96
97                 obj->root = Reorganize_SVBVH<VBVHNode>(arena2).transform(root);
98         }
99         else {
100                 //Finds the optimal packing of this tree using a given cost model
101                 //TODO this uses quite a lot of memory, find ways to reduce memory usage during building
102                 OVBVHNode *root = BuildBinaryVBVH<OVBVHNode>(arena1, &obj->rayobj.control).transform(obj->builder);
103
104                 if (RE_rayobjectcontrol_test_break(&obj->rayobj.control)) {
105                         BLI_memarena_free(arena1);
106                         BLI_memarena_free(arena2);
107                         return;
108                 }
109
110                 if (root) {
111                         VBVH_optimalPackSIMD<OVBVHNode, PackCost>(PackCost()).transform(root);
112                         obj->root = Reorganize_SVBVH<OVBVHNode>(arena2).transform(root);
113                 }
114                 else
115                         obj->root = NULL;
116         }
117
118         //Free data
119         BLI_memarena_free(arena1);
120
121         obj->node_arena = arena2;
122         obj->cost = 1.0;
123
124         rtbuild_free(obj->builder);
125         obj->builder = NULL;
126 }
127
128 template<int StackSize>
129 static int intersect(SVBVHTree *obj, Isect *isec)
130 {
131         //TODO renable hint support
132         if (RE_rayobject_isAligned(obj->root)) {
133                 if (isec->mode == RE_RAY_SHADOW)
134                         return svbvh_node_stack_raycast<StackSize, true>(obj->root, isec);
135                 else
136                         return svbvh_node_stack_raycast<StackSize, false>(obj->root, isec);
137         }
138         else
139                 return RE_rayobject_intersect( (RayObject *) obj->root, isec);
140 }
141
142 template<class Tree>
143 static void bvh_hint_bb(Tree *tree, LCTSHint *hint, float *UNUSED(min), float *UNUSED(max))
144 {
145         //TODO renable hint support
146         {
147                 hint->size = 0;
148                 hint->stack[hint->size++] = (RayObject *)tree->root;
149         }
150 }
151 /* the cast to pointer function is needed to workarround gcc bug: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=11407 */
152 template<class Tree, int STACK_SIZE>
153 static RayObjectAPI make_api()
154 {
155         static RayObjectAPI api =
156         {
157                 (RE_rayobject_raycast_callback) ((int   (*)(Tree *, Isect *)) & intersect<STACK_SIZE>),
158                 (RE_rayobject_add_callback)     ((void  (*)(Tree *, RayObject *)) & bvh_add<Tree>),
159                 (RE_rayobject_done_callback)    ((void  (*)(Tree *))       & bvh_done<Tree>),
160                 (RE_rayobject_free_callback)    ((void  (*)(Tree *))       & bvh_free<Tree>),
161                 (RE_rayobject_merge_bb_callback)((void  (*)(Tree *, float *, float *)) & bvh_bb<Tree>),
162                 (RE_rayobject_cost_callback)    ((float (*)(Tree *))      & bvh_cost<Tree>),
163                 (RE_rayobject_hint_bb_callback) ((void  (*)(Tree *, LCTSHint *, float *, float *)) & bvh_hint_bb<Tree>)
164         };
165
166         return api;
167 }
168
169 template<class Tree>
170 static RayObjectAPI *bvh_get_api(int maxstacksize)
171 {
172         static RayObjectAPI bvh_api256 = make_api<Tree, 1024>();
173
174         if (maxstacksize <= 1024) return &bvh_api256;
175         assert(maxstacksize <= 256);
176         return NULL;
177 }
178
179 RayObject *RE_rayobject_svbvh_create(int size)
180 {
181         return bvh_create_tree<SVBVHTree, DFS_STACK_SIZE>(size);
182 }
183
184 #else
185
186 RayObject *RE_rayobject_svbvh_create(int UNUSED(size))
187 {
188         puts("WARNING: SSE disabled at compile time\n");
189         return NULL;
190 }
191
192 #endif