Cuda use streams and async to avoid busywaiting
[blender.git] / intern / cycles / subd / subd_patch.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 /* Parts adapted from code in the public domain in NVidia Mesh Tools. */
18
19 #include "mesh.h"
20
21 #include "subd_patch.h"
22
23 #include "util_math.h"
24 #include "util_types.h"
25
26 CCL_NAMESPACE_BEGIN
27
28 /* De Casteljau Evaluation */
29
30 static void decasteljau_cubic(float3 *P, float3 *dt, float t, const float3 cp[4])
31 {
32         float3 d0 = cp[0] + t*(cp[1] - cp[0]);
33         float3 d1 = cp[1] + t*(cp[2] - cp[1]);
34         float3 d2 = cp[2] + t*(cp[3] - cp[2]);
35
36         d0 += t*(d1 - d0);
37         d1 += t*(d2 - d1);
38
39         *P = d0 + t*(d1 - d0);
40         if(dt) *dt = d1 - d0;
41 }
42
43 static void decasteljau_bicubic(float3 *P, float3 *du, float3 *dv, const float3 cp[16], float u, float v)
44 {
45         float3 ucp[4], utn[4];
46
47         /* interpolate over u */
48         decasteljau_cubic(ucp+0, utn+0, u, cp);
49         decasteljau_cubic(ucp+1, utn+1, u, cp+4);
50         decasteljau_cubic(ucp+2, utn+2, u, cp+8);
51         decasteljau_cubic(ucp+3, utn+3, u, cp+12);
52
53         /* interpolate over v */
54         decasteljau_cubic(P, dv, v, ucp);
55         if(du) decasteljau_cubic(du, NULL, v, utn);
56 }
57
58 /* Linear Quad Patch */
59
60 void LinearQuadPatch::eval(float3 *P, float3 *dPdu, float3 *dPdv, float u, float v)
61 {
62         float3 d0 = interp(hull[0], hull[1], u);
63         float3 d1 = interp(hull[2], hull[3], u);
64
65         *P = interp(d0, d1, v);
66
67         if(dPdu && dPdv) {
68                 *dPdu = interp(hull[1] - hull[0], hull[3] - hull[2], v);
69                 *dPdv = interp(hull[2] - hull[0], hull[3] - hull[1], u);
70         }
71 }
72
73 BoundBox LinearQuadPatch::bound()
74 {
75         BoundBox bbox = BoundBox::empty;
76
77         for(int i = 0; i < 4; i++)
78                 bbox.grow(hull[i]);
79         
80         return bbox;
81 }
82
83 /* Linear Triangle Patch */
84
85 void LinearTrianglePatch::eval(float3 *P, float3 *dPdu, float3 *dPdv, float u, float v)
86 {
87         *P = u*hull[0] + v*hull[1] + (1.0f - u - v)*hull[2];
88
89         if(dPdu && dPdv) {
90                 *dPdu = hull[0] - hull[2];
91                 *dPdv = hull[1] - hull[2];
92         }
93 }
94
95 BoundBox LinearTrianglePatch::bound()
96 {
97         BoundBox bbox = BoundBox::empty;
98
99         for(int i = 0; i < 3; i++)
100                 bbox.grow(hull[i]);
101         
102         return bbox;
103 }
104
105 /* Bicubic Patch */
106
107 void BicubicPatch::eval(float3 *P, float3 *dPdu, float3 *dPdv, float u, float v)
108 {
109         decasteljau_bicubic(P, dPdu, dPdv, hull, u, v);
110 }
111
112 BoundBox BicubicPatch::bound()
113 {
114         BoundBox bbox = BoundBox::empty;
115
116         for(int i = 0; i < 16; i++)
117                 bbox.grow(hull[i]);
118         
119         return bbox;
120 }
121
122 CCL_NAMESPACE_END
123