Cycles: Remove unneeded include statements
[blender-staging.git] / intern / cycles / subd / subd_split.cpp
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include "render/camera.h"
18 #include "render/mesh.h"
19
20 #include "subd/subd_dice.h"
21 #include "subd/subd_patch.h"
22 #include "subd/subd_split.h"
23
24 #include "util/util_math.h"
25 #include "util/util_types.h"
26
27 CCL_NAMESPACE_BEGIN
28
29 /* DiagSplit */
30
31 DiagSplit::DiagSplit(const SubdParams& params_)
32 : params(params_)
33 {
34 }
35
36 void DiagSplit::dispatch(QuadDice::SubPatch& sub, QuadDice::EdgeFactors& ef)
37 {
38         subpatches_quad.push_back(sub);
39         edgefactors_quad.push_back(ef);
40 }
41
42 float3 DiagSplit::to_world(Patch *patch, float2 uv)
43 {
44         float3 P;
45
46         patch->eval(&P, NULL, NULL, NULL, uv.x, uv.y);
47         if(params.camera)
48                 P = transform_point(&params.objecttoworld, P);
49
50         return P;
51 }
52
53 int DiagSplit::T(Patch *patch, float2 Pstart, float2 Pend)
54 {
55         float3 Plast = make_float3(0.0f, 0.0f, 0.0f);
56         float Lsum = 0.0f;
57         float Lmax = 0.0f;
58
59         for(int i = 0; i < params.test_steps; i++) {
60                 float t = i/(float)(params.test_steps-1);
61
62                 float3 P = to_world(patch, Pstart + t*(Pend - Pstart));
63
64                 if(i > 0) {
65                         float L;
66
67                         if(!params.camera) {
68                                 L = len(P - Plast);
69                         }
70                         else {
71                                 Camera* cam = params.camera;
72
73                                 float pixel_width = cam->world_to_raster_size((P + Plast) * 0.5f);
74                                 L = len(P - Plast) / pixel_width;
75                         }
76
77                         Lsum += L;
78                         Lmax = max(L, Lmax);
79                 }
80
81                 Plast = P;
82         }
83
84         int tmin = (int)ceil(Lsum/params.dicing_rate);
85         int tmax = (int)ceil((params.test_steps-1)*Lmax/params.dicing_rate); // XXX paper says N instead of N-1, seems wrong?
86
87         if(tmax - tmin > params.split_threshold)
88                 return DSPLIT_NON_UNIFORM;
89         
90         return tmax;
91 }
92
93 void DiagSplit::partition_edge(Patch *patch, float2 *P, int *t0, int *t1, float2 Pstart, float2 Pend, int t)
94 {
95         if(t == DSPLIT_NON_UNIFORM) {
96                 *P = (Pstart + Pend)*0.5f;
97                 *t0 = T(patch, Pstart, *P);
98                 *t1 = T(patch, *P, Pend);
99         }
100         else {
101                 int I = (int)floor((float)t*0.5f);
102                 *P = interp(Pstart, Pend, (t == 0)? 0: I/(float)t); /* XXX is t faces or verts */
103                 *t0 = I;
104                 *t1 = t - I;
105         }
106 }
107
108 static void limit_edge_factors(const QuadDice::SubPatch& sub, QuadDice::EdgeFactors& ef, int max_t)
109 {
110         float2 P00 = sub.P00;
111         float2 P01 = sub.P01;
112         float2 P10 = sub.P10;
113         float2 P11 = sub.P11;
114
115         int tu0 = int(max_t * len(P10 - P00));
116         int tu1 = int(max_t * len(P11 - P01));
117         int tv0 = int(max_t * len(P01 - P00));
118         int tv1 = int(max_t * len(P11 - P10));
119
120         ef.tu0 = tu0 <= 1 ? 1 : min(ef.tu0, tu0);
121         ef.tu1 = tu1 <= 1 ? 1 : min(ef.tu1, tu1);
122         ef.tv0 = tv0 <= 1 ? 1 : min(ef.tv0, tv0);
123         ef.tv1 = tv1 <= 1 ? 1 : min(ef.tv1, tv1);
124 }
125
126 void DiagSplit::split(QuadDice::SubPatch& sub, QuadDice::EdgeFactors& ef, int depth)
127 {
128         if(depth > 32) {
129                 /* We should never get here, but just in case end recursion safely. */
130                 ef.tu0 = 1;
131                 ef.tu1 = 1;
132                 ef.tv0 = 1;
133                 ef.tv1 = 1;
134
135                 dispatch(sub, ef);
136                 return;
137         }
138
139         bool split_u = (ef.tu0 == DSPLIT_NON_UNIFORM || ef.tu1 == DSPLIT_NON_UNIFORM);
140         bool split_v = (ef.tv0 == DSPLIT_NON_UNIFORM || ef.tv1 == DSPLIT_NON_UNIFORM);
141
142         /* Split subpatches such that the ratio of T for opposite edges doesn't
143      * exceed 1.5, this reduces over tessellation for some patches
144          */
145         bool tmp_split_v = split_v;
146         if(!split_u && min(ef.tu0, ef.tu1) > 8 && min(ef.tu0, ef.tu1)*1.5f < max(ef.tu0, ef.tu1))
147                 split_v = true;
148         if(!tmp_split_v && min(ef.tu0, ef.tu1) > 8 && min(ef.tv0, ef.tv1)*1.5f < max(ef.tv0, ef.tv1))
149                 split_u = true;
150
151         /* alternate axis */
152         if(split_u && split_v) {
153                 split_u = depth % 2;
154         }
155
156         if(split_u) {
157                 /* partition edges */
158                 QuadDice::EdgeFactors ef0, ef1;
159                 float2 Pu0, Pu1;
160
161                 partition_edge(sub.patch,
162                         &Pu0, &ef0.tu0, &ef1.tu0, sub.P00, sub.P10, ef.tu0);
163                 partition_edge(sub.patch,
164                         &Pu1, &ef0.tu1, &ef1.tu1, sub.P01, sub.P11, ef.tu1);
165
166                 /* split */
167                 int tsplit = T(sub.patch, Pu0, Pu1);
168                 ef0.tv0 = ef.tv0;
169                 ef0.tv1 = tsplit;
170
171                 ef1.tv0 = tsplit;
172                 ef1.tv1 = ef.tv1;
173
174                 /* create subpatches */
175                 QuadDice::SubPatch sub0 = {sub.patch, sub.P00, Pu0, sub.P01, Pu1};
176                 QuadDice::SubPatch sub1 = {sub.patch, Pu0, sub.P10, Pu1, sub.P11};
177
178                 limit_edge_factors(sub0, ef0, 1 << params.max_level);
179                 limit_edge_factors(sub1, ef1, 1 << params.max_level);
180
181                 split(sub0, ef0, depth+1);
182                 split(sub1, ef1, depth+1);
183         }
184         else if(split_v) {
185                 /* partition edges */
186                 QuadDice::EdgeFactors ef0, ef1;
187                 float2 Pv0, Pv1;
188
189                 partition_edge(sub.patch,
190                         &Pv0, &ef0.tv0, &ef1.tv0, sub.P00, sub.P01, ef.tv0);
191                 partition_edge(sub.patch,
192                         &Pv1, &ef0.tv1, &ef1.tv1, sub.P10, sub.P11, ef.tv1);
193
194                 /* split */
195                 int tsplit = T(sub.patch, Pv0, Pv1);
196                 ef0.tu0 = ef.tu0;
197                 ef0.tu1 = tsplit;
198
199                 ef1.tu0 = tsplit;
200                 ef1.tu1 = ef.tu1;
201
202                 /* create subpatches */
203                 QuadDice::SubPatch sub0 = {sub.patch, sub.P00, sub.P10, Pv0, Pv1};
204                 QuadDice::SubPatch sub1 = {sub.patch, Pv0, Pv1, sub.P01, sub.P11};
205
206                 limit_edge_factors(sub0, ef0, 1 << params.max_level);
207                 limit_edge_factors(sub1, ef1, 1 << params.max_level);
208
209                 split(sub0, ef0, depth+1);
210                 split(sub1, ef1, depth+1);
211         }
212         else {
213                 dispatch(sub, ef);
214         }
215 }
216
217 void DiagSplit::split_quad(Patch *patch, QuadDice::SubPatch *subpatch)
218 {
219         QuadDice::SubPatch sub_split;
220         QuadDice::EdgeFactors ef_split;
221
222         if(subpatch) {
223                 sub_split = *subpatch;
224         }
225         else {
226                 sub_split.patch = patch;
227                 sub_split.P00 = make_float2(0.0f, 0.0f);
228                 sub_split.P10 = make_float2(1.0f, 0.0f);
229                 sub_split.P01 = make_float2(0.0f, 1.0f);
230                 sub_split.P11 = make_float2(1.0f, 1.0f);
231         }
232
233         ef_split.tu0 = T(patch, sub_split.P00, sub_split.P10);
234         ef_split.tu1 = T(patch, sub_split.P01, sub_split.P11);
235         ef_split.tv0 = T(patch, sub_split.P00, sub_split.P01);
236         ef_split.tv1 = T(patch, sub_split.P10, sub_split.P11);
237
238         limit_edge_factors(sub_split, ef_split, 1 << params.max_level);
239
240         split(sub_split, ef_split);
241
242         QuadDice dice(params);
243
244         for(size_t i = 0; i < subpatches_quad.size(); i++) {
245                 QuadDice::SubPatch& sub = subpatches_quad[i];
246                 QuadDice::EdgeFactors& ef = edgefactors_quad[i];
247
248                 ef.tu0 = max(ef.tu0, 1);
249                 ef.tu1 = max(ef.tu1, 1);
250                 ef.tv0 = max(ef.tv0, 1);
251                 ef.tv1 = max(ef.tv1, 1);
252
253                 dice.dice(sub, ef);
254         }
255
256         subpatches_quad.clear();
257         edgefactors_quad.clear();
258 }
259
260 CCL_NAMESPACE_END
261