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