Cycles: Make all #include statements relative to cycles source directory
[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 "render/mesh.h"
20
21 #include "subd/subd_patch.h"
22
23 #include "util/util_math.h"
24 #include "util/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, float3 *N, 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         if(N) {
73                 *N = normalize(interp(interp(normals[0], normals[1], u), interp(normals[2], normals[3], u), v));
74         }
75 }
76
77 BoundBox LinearQuadPatch::bound()
78 {
79         BoundBox bbox = BoundBox::empty;
80
81         for(int i = 0; i < 4; i++)
82                 bbox.grow(hull[i]);
83         
84         return bbox;
85 }
86
87 /* Bicubic Patch */
88
89 void BicubicPatch::eval(float3 *P, float3 *dPdu, float3 *dPdv, float3 *N, float u, float v)
90 {
91         if(N) {
92                 float3 dPdu_, dPdv_;
93                 decasteljau_bicubic(P, &dPdu_, &dPdv_, hull, u, v);
94
95                 if(dPdu && dPdv) {
96                         *dPdu = dPdu_;
97                         *dPdv = dPdv_;
98                 }
99
100                 *N = normalize(cross(dPdu_, dPdv_));
101         }
102         else {
103                 decasteljau_bicubic(P, dPdu, dPdv, hull, u, v);
104         }
105 }
106
107 BoundBox BicubicPatch::bound()
108 {
109         BoundBox bbox = BoundBox::empty;
110
111         for(int i = 0; i < 16; i++)
112                 bbox.grow(hull[i]);
113         
114         return bbox;
115 }
116
117 CCL_NAMESPACE_END
118