Merge branch 'blender2.7'
[blender.git] / source / blender / gpu / intern / gpu_batch_utils.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
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  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 /** \file blender/gpu/intern/gpu_batch_utils.c
22  *  \ingroup gpu
23  */
24
25 #include "MEM_guardedalloc.h"
26
27 #include "BLI_utildefines.h"
28 #include "BLI_rect.h"
29 #include "BLI_math.h"
30 #include "BLI_polyfill_2d.h"
31 #include "BLI_sort_utils.h"
32
33 #include "GPU_batch.h"
34 #include "GPU_batch_utils.h"  /* own include */
35 #include "gpu_shader_private.h"
36
37 /* -------------------------------------------------------------------- */
38 /** \name Polygon Creation (2D)
39  * \{ */
40
41 /**
42  * Creates triangles from a byte-array of polygons.
43  *
44  * See 'make_shape_2d_from_blend.py' utility to create data to pass to this function.
45  *
46  * \param polys_flat: Pairs of X, Y coordinates (repeating to signify closing the polygon).
47  * \param polys_flat_len: Length of the array (must be an even number).
48  * \param rect: Optional region to map the byte 0..255 coords to. When not set use -1..1.
49  */
50 GPUBatch *GPU_batch_tris_from_poly_2d_encoded(
51         const uchar *polys_flat, uint polys_flat_len, const rctf *rect)
52 {
53         const uchar (*polys)[2] = (const void *)polys_flat;
54         const uint polys_len = polys_flat_len / 2;
55         BLI_assert(polys_flat_len == polys_len * 2);
56
57         /* Over alloc in both cases */
58         float (*verts)[2] = MEM_mallocN(sizeof(*verts) * polys_len, __func__);
59         float (*verts_step)[2] = verts;
60         uint (*tris)[3] = MEM_mallocN(sizeof(*tris) * polys_len, __func__);
61         uint (*tris_step)[3] = tris;
62
63         const float range_uchar[2] = {
64                 (rect ? (rect->xmax - rect->xmin) : 2.0f) / 255.0f,
65                 (rect ? (rect->ymax - rect->ymin) : 2.0f) / 255.0f,
66         };
67         const float min_uchar[2] = {
68                 (rect ? rect->xmin : -1.0f),
69                 (rect ? rect->ymin : -1.0f),
70         };
71
72         uint i_poly = 0;
73         uint i_vert = 0;
74         while (i_poly != polys_len) {
75                 for (uint j = 0; j < 2; j++) {
76                         verts[i_vert][j] = min_uchar[j] + ((float)polys[i_poly][j] * range_uchar[j]);
77                 }
78                 i_vert++;
79                 i_poly++;
80                 if (polys[i_poly - 1][0] == polys[i_poly][0] &&
81                     polys[i_poly - 1][1] == polys[i_poly][1])
82                 {
83                         const uint verts_step_len = (&verts[i_vert]) - verts_step;
84                         BLI_assert(verts_step_len >= 3);
85                         const uint tris_len = (verts_step_len - 2);
86                         BLI_polyfill_calc(verts_step, verts_step_len, -1, tris_step);
87                         /* offset indices */
88                         if (verts_step != verts) {
89                                 uint *t = tris_step[0];
90                                 const uint offset = (verts_step - verts);
91                                 uint tot = tris_len * 3;
92                                 while (tot--) {
93                                         *t += offset;
94                                         t++;
95                                 }
96                                 BLI_assert(t == tris_step[tris_len]);
97                         }
98                         verts_step += verts_step_len;
99                         tris_step += tris_len;
100                         i_poly++;
101                         /* ignore the duplicate point */
102                 }
103         }
104
105         /* We have vertices and tris, make a batch from this. */
106         static GPUVertFormat format = {0};
107         static struct { uint pos; } attr_id;
108         if (format.attr_len == 0) {
109                 attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
110         }
111
112         const uint verts_len = (verts_step - verts);
113         const uint tris_len = (tris_step - tris);
114         GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
115         GPU_vertbuf_data_alloc(vbo, verts_len);
116
117         GPUVertBufRaw pos_step;
118         GPU_vertbuf_attr_get_raw_data(vbo, attr_id.pos, &pos_step);
119
120         for (uint i = 0; i < verts_len; i++) {
121                 copy_v2_v2(GPU_vertbuf_raw_step(&pos_step), verts[i]);
122         }
123
124         GPUIndexBufBuilder elb;
125         GPU_indexbuf_init(&elb, GPU_PRIM_TRIS, tris_len, verts_len);
126         for (uint i = 0; i < tris_len; i++) {
127                 GPU_indexbuf_add_tri_verts(&elb, UNPACK3(tris[i]));
128         }
129         GPUIndexBuf *indexbuf = GPU_indexbuf_build(&elb);
130
131         MEM_freeN(tris);
132         MEM_freeN(verts);
133
134         return GPU_batch_create_ex(
135                 GPU_PRIM_TRIS, vbo,
136                 indexbuf,
137                 GPU_BATCH_OWNS_VBO | GPU_BATCH_OWNS_INDEX);
138 }
139
140 GPUBatch *GPU_batch_wire_from_poly_2d_encoded(
141         const uchar *polys_flat, uint polys_flat_len, const rctf *rect)
142 {
143         const uchar (*polys)[2] = (const void *)polys_flat;
144         const uint polys_len = polys_flat_len / 2;
145         BLI_assert(polys_flat_len == polys_len * 2);
146
147         /* Over alloc */
148         /* Lines are pairs of (x, y) byte locations packed into an int32_t. */
149         int32_t *lines = MEM_mallocN(sizeof(*lines) * polys_len, __func__);
150         int32_t *lines_step = lines;
151
152         const float range_uchar[2] = {
153                 (rect ? (rect->xmax - rect->xmin) : 2.0f) / 255.0f,
154                 (rect ? (rect->ymax - rect->ymin) : 2.0f) / 255.0f,
155         };
156         const float min_uchar[2] = {
157                 (rect ? rect->xmin : -1.0f),
158                 (rect ? rect->ymin : -1.0f),
159         };
160
161         uint i_poly_prev = 0;
162         uint i_poly = 0;
163         while (i_poly != polys_len) {
164                 i_poly++;
165                 if (polys[i_poly - 1][0] == polys[i_poly][0] &&
166                     polys[i_poly - 1][1] == polys[i_poly][1])
167                 {
168                         const uchar (*polys_step)[2] = polys + i_poly_prev;
169                         const uint polys_step_len = i_poly - i_poly_prev;
170                         BLI_assert(polys_step_len >= 2);
171                         for (uint i_prev = polys_step_len - 1, i = 0; i < polys_step_len; i_prev = i++) {
172                                 union {
173                                         uint8_t  as_u8[4];
174                                         uint16_t as_u16[2];
175                                         uint32_t as_u32;
176                                 } data;
177                                 data.as_u16[0] = *((const uint16_t *)polys_step[i_prev]);
178                                 data.as_u16[1] = *((const uint16_t *)polys_step[i]);
179                                 if (data.as_u16[0] > data.as_u16[1]) {
180                                         SWAP(uint16_t, data.as_u16[0], data.as_u16[1]);
181                                 }
182                                 *lines_step = data.as_u32;
183                                 lines_step++;
184                         }
185                         i_poly++;
186                         i_poly_prev = i_poly;
187                         /* ignore the duplicate point */
188                 }
189         }
190
191         uint lines_len = lines_step - lines;
192
193         /* Hide Lines (we could make optional) */
194         {
195                 qsort(lines, lines_len, sizeof(int32_t), BLI_sortutil_cmp_int);
196                 lines_step = lines;
197                 for (uint i_prev = 0, i = 1; i < lines_len; i_prev = i++) {
198                         if (lines[i] != lines[i_prev]) {
199                                 *lines_step++ = lines[i_prev];
200                         }
201                         else {
202                                 i++;
203                         }
204                 }
205                 *lines_step++ = lines[lines_len - 1];
206                 lines_len = lines_step - lines;
207         }
208
209         /* We have vertices and tris, make a batch from this. */
210         static GPUVertFormat format = {0};
211         static struct { uint pos; } attr_id;
212         if (format.attr_len == 0) {
213                 attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
214         }
215
216         GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
217         const uint vbo_len_capacity = lines_len * 2;
218         GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
219
220         GPUVertBufRaw pos_step;
221         GPU_vertbuf_attr_get_raw_data(vbo, attr_id.pos, &pos_step);
222
223         for (uint i = 0; i < lines_len; i++) {
224                 union {
225                         uint8_t  as_u8_pair[2][2];
226                         uint32_t as_u32;
227                 } data;
228                 data.as_u32 = lines[i];
229                 for (uint k = 0; k < 2; k++) {
230                         float *pos_v2 = GPU_vertbuf_raw_step(&pos_step);
231                         for (uint j = 0; j < 2; j++) {
232                                 pos_v2[j] = min_uchar[j] + ((float)data.as_u8_pair[k][j] * range_uchar[j]);
233                         }
234                 }
235         }
236         BLI_assert(vbo_len_capacity == GPU_vertbuf_raw_used(&pos_step));
237         MEM_freeN(lines);
238         return GPU_batch_create_ex(
239                 GPU_PRIM_LINES, vbo,
240                 NULL,
241                 GPU_BATCH_OWNS_VBO);
242 }
243
244 /** \} */