Cycles: Use explicit qualifier for single-argument constructors
[blender.git] / intern / cycles / subd / subd_dice.h
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 #ifndef __SUBD_DICE_H__
18 #define __SUBD_DICE_H__
19
20 /* DX11 like EdgeDice implementation, with different tessellation factors for
21  * each edge for watertight tessellation, with subpatch remapping to work with
22  * DiagSplit. For more algorithm details, see the DiagSplit paper or the
23  * ARB_tessellation_shader OpenGL extension, Section 2.X.2. */
24
25 #include "util_types.h"
26 #include "util_vector.h"
27
28 CCL_NAMESPACE_BEGIN
29
30 class Camera;
31 class Mesh;
32 class Patch;
33
34 struct SubdParams {
35         Mesh *mesh;
36         int shader;
37         bool smooth;
38         bool ptex;
39
40         int test_steps;
41         int split_threshold;
42         float dicing_rate;
43         int max_level;
44         Camera *camera;
45         Transform objecttoworld;
46
47         SubdParams(Mesh *mesh_, int shader_, bool smooth_ = true, bool ptex_ = false)
48         {
49                 mesh = mesh_;
50                 shader = shader_;
51                 smooth = smooth_;
52                 ptex = ptex_;
53
54                 test_steps = 3;
55                 split_threshold = 1;
56                 dicing_rate = 0.1f;
57                 max_level = 12;
58                 camera = NULL;
59         }
60
61 };
62
63 /* EdgeDice Base */
64
65 class EdgeDice {
66 public:
67         SubdParams params;
68         float3 *mesh_P;
69         float3 *mesh_N;
70         size_t vert_offset;
71         size_t tri_offset;
72
73         explicit EdgeDice(const SubdParams& params);
74
75         void reserve(int num_verts, int num_tris);
76
77         int add_vert(Patch *patch, float2 uv);
78         void add_triangle(Patch *patch, int v0, int v1, int v2);
79
80         void stitch_triangles(Patch *patch, vector<int>& outer, vector<int>& inner);
81 };
82
83 /* Quad EdgeDice
84  *
85  * Edge tessellation factors and subpatch coordinates are as follows:
86  *
87  *            tu1
88  *     P01 --------- P11 
89  *     |               |
90  * tv0 |               | tv1
91  *     |               |
92  *     P00 --------- P10
93  *            tu0
94  */
95
96 class QuadDice : public EdgeDice {
97 public:
98         struct SubPatch {
99                 Patch *patch;
100
101                 float2 P00;
102                 float2 P10;
103                 float2 P01;
104                 float2 P11;
105         };
106
107         struct EdgeFactors {
108                 int tu0;
109                 int tu1;
110                 int tv0;
111                 int tv1;
112         };
113
114         explicit QuadDice(const SubdParams& params);
115
116         void reserve(EdgeFactors& ef, int Mu, int Mv);
117         float3 eval_projected(SubPatch& sub, float u, float v);
118
119         float2 map_uv(SubPatch& sub, float u, float v);
120         int add_vert(SubPatch& sub, float u, float v);
121
122         void add_corners(SubPatch& sub);
123         void add_grid(SubPatch& sub, int Mu, int Mv, int offset);
124
125         void add_side_u(SubPatch& sub,
126                 vector<int>& outer, vector<int>& inner,
127                 int Mu, int Mv, int tu, int side, int offset);
128
129         void add_side_v(SubPatch& sub,
130                 vector<int>& outer, vector<int>& inner,
131                 int Mu, int Mv, int tv, int side, int offset);
132
133         float quad_area(const float3& a, const float3& b, const float3& c, const float3& d);
134         float scale_factor(SubPatch& sub, EdgeFactors& ef, int Mu, int Mv);
135
136         void dice(SubPatch& sub, EdgeFactors& ef);
137 };
138
139 /* Triangle EdgeDice
140  *
141  * Edge tessellation factors and subpatch coordinates are as follows:
142  *
143  *        Pw
144  *        /\
145  *    tv /  \ tu
146  *      /    \
147  *     /      \
148  *  Pu -------- Pv
149  *        tw     
150  */
151
152 class TriangleDice : public EdgeDice {
153 public:
154         struct SubPatch {
155                 Patch *patch;
156
157                 float2 Pu;
158                 float2 Pv;
159                 float2 Pw;
160         };
161
162         struct EdgeFactors {
163                 int tu;
164                 int tv;
165                 int tw;
166         };
167
168         explicit TriangleDice(const SubdParams& params);
169
170         void reserve(EdgeFactors& ef, int M);
171
172         float2 map_uv(SubPatch& sub, float2 uv);
173         int add_vert(SubPatch& sub, float2 uv);
174
175         void add_grid(SubPatch& sub, EdgeFactors& ef, int M);
176         void dice(SubPatch& sub, EdgeFactors& ef);
177 };
178
179 CCL_NAMESPACE_END
180
181 #endif /* __SUBD_DICE_H__ */
182