Merge branch 'blender2.7'
[blender.git] / source / blender / gpu / intern / gpu_batch_presets.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  * The Original Code is Copyright (C) 2016 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Mike Erwin
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/gpu/intern/gpu_batch_presets.c
29  *  \ingroup gpu
30  */
31
32 #include "BLI_utildefines.h"
33 #include "BLI_math.h"
34 #include "BLI_threads.h"
35 #include "BLI_listbase.h"
36 #include "MEM_guardedalloc.h"
37
38 #include "UI_interface.h"
39
40 #include "GPU_batch.h"
41 #include "GPU_batch_utils.h"
42 #include "GPU_batch_presets.h"  /* own include */
43 #include "gpu_shader_private.h"
44
45 /* Struct to store 3D Batches and their format */
46 static struct {
47         struct {
48                 GPUBatch *sphere_high;
49                 GPUBatch *sphere_med;
50                 GPUBatch *sphere_low;
51                 GPUBatch *sphere_wire_low;
52                 GPUBatch *sphere_wire_med;
53         } batch;
54
55         GPUVertFormat format;
56
57         struct {
58                 uint pos, nor;
59         } attr_id;
60
61         ThreadMutex mutex;
62 } g_presets_3d = {{0}};
63
64 static ListBase presets_list = {NULL, NULL};
65
66
67 /* -------------------------------------------------------------------- */
68 /** \name 3D Primitives
69  * \{ */
70
71 static GPUVertFormat *preset_3d_format(void)
72 {
73         if (g_presets_3d.format.attr_len == 0) {
74                 GPUVertFormat *format = &g_presets_3d.format;
75                 g_presets_3d.attr_id.pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
76                 g_presets_3d.attr_id.nor = GPU_vertformat_attr_add(format, "nor", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
77         }
78         return &g_presets_3d.format;
79 }
80
81 static void batch_sphere_lat_lon_vert(
82         GPUVertBufRaw *pos_step, GPUVertBufRaw *nor_step,
83         float lat, float lon)
84 {
85         float pos[3];
86         pos[0] = sinf(lat) * cosf(lon);
87         pos[1] = cosf(lat);
88         pos[2] = sinf(lat) * sinf(lon);
89         copy_v3_v3(GPU_vertbuf_raw_step(pos_step), pos);
90         copy_v3_v3(GPU_vertbuf_raw_step(nor_step), pos);
91 }
92 GPUBatch *GPU_batch_preset_sphere(int lod)
93 {
94         BLI_assert(lod >= 0 && lod <= 2);
95         BLI_assert(BLI_thread_is_main());
96
97         if (lod == 0) {
98                 return g_presets_3d.batch.sphere_low;
99         }
100         else if (lod == 1) {
101                 return g_presets_3d.batch.sphere_med;
102         }
103         else {
104                 return g_presets_3d.batch.sphere_high;
105         }
106 }
107
108 GPUBatch *GPU_batch_preset_sphere_wire(int lod)
109 {
110         BLI_assert(lod >= 0 && lod <= 1);
111         BLI_assert(BLI_thread_is_main());
112
113         if (lod == 0) {
114                 return g_presets_3d.batch.sphere_wire_low;
115         }
116         else {
117                 return g_presets_3d.batch.sphere_wire_med;
118         }
119 }
120
121 /** \} */
122
123 /* -------------------------------------------------------------------- */
124 /** \name Create Sphere (3D)
125  * \{ */
126
127 /* Replacement for gluSphere */
128 GPUBatch *gpu_batch_sphere(int lat_res, int lon_res)
129 {
130         const float lon_inc = 2 * M_PI / lon_res;
131         const float lat_inc = M_PI / lat_res;
132         float lon, lat;
133
134         GPUVertBuf *vbo = GPU_vertbuf_create_with_format(preset_3d_format());
135         const uint vbo_len = (lat_res - 1) * lon_res * 6;
136         GPU_vertbuf_data_alloc(vbo, vbo_len);
137
138         GPUVertBufRaw pos_step, nor_step;
139         GPU_vertbuf_attr_get_raw_data(vbo, g_presets_3d.attr_id.pos, &pos_step);
140         GPU_vertbuf_attr_get_raw_data(vbo, g_presets_3d.attr_id.nor, &nor_step);
141
142         lon = 0.0f;
143         for (int i = 0; i < lon_res; i++, lon += lon_inc) {
144                 lat = 0.0f;
145                 for (int j = 0; j < lat_res; j++, lat += lat_inc) {
146                         if (j != lat_res - 1) { /* Pole */
147                                 batch_sphere_lat_lon_vert(&pos_step, &nor_step, lat + lat_inc, lon + lon_inc);
148                                 batch_sphere_lat_lon_vert(&pos_step, &nor_step, lat + lat_inc, lon);
149                                 batch_sphere_lat_lon_vert(&pos_step, &nor_step, lat,           lon);
150                         }
151
152                         if (j != 0) { /* Pole */
153                                 batch_sphere_lat_lon_vert(&pos_step, &nor_step, lat,           lon + lon_inc);
154                                 batch_sphere_lat_lon_vert(&pos_step, &nor_step, lat + lat_inc, lon + lon_inc);
155                                 batch_sphere_lat_lon_vert(&pos_step, &nor_step, lat,           lon);
156                         }
157                 }
158         }
159
160         BLI_assert(vbo_len == GPU_vertbuf_raw_used(&pos_step));
161         BLI_assert(vbo_len == GPU_vertbuf_raw_used(&nor_step));
162
163         return GPU_batch_create_ex(GPU_PRIM_TRIS, vbo, NULL, GPU_BATCH_OWNS_VBO);
164 }
165
166 static GPUBatch *batch_sphere_wire(int lat_res, int lon_res)
167 {
168         const float lon_inc = 2 * M_PI / lon_res;
169         const float lat_inc = M_PI / lat_res;
170         float lon, lat;
171
172         GPUVertBuf *vbo = GPU_vertbuf_create_with_format(preset_3d_format());
173         const uint vbo_len = (lat_res * lon_res * 2) + ((lat_res - 1) * lon_res * 2);
174         GPU_vertbuf_data_alloc(vbo, vbo_len);
175
176         GPUVertBufRaw pos_step, nor_step;
177         GPU_vertbuf_attr_get_raw_data(vbo, g_presets_3d.attr_id.pos, &pos_step);
178         GPU_vertbuf_attr_get_raw_data(vbo, g_presets_3d.attr_id.nor, &nor_step);
179
180         lon = 0.0f;
181         for (int i = 0; i < lon_res; i++, lon += lon_inc) {
182                 lat = 0.0f;
183                 for (int j = 0; j < lat_res; j++, lat += lat_inc) {
184                         batch_sphere_lat_lon_vert(&pos_step, &nor_step, lat + lat_inc, lon);
185                         batch_sphere_lat_lon_vert(&pos_step, &nor_step, lat,           lon);
186
187                         if (j != lat_res - 1) { /* Pole */
188                                 batch_sphere_lat_lon_vert(&pos_step, &nor_step, lat + lat_inc, lon + lon_inc);
189                                 batch_sphere_lat_lon_vert(&pos_step, &nor_step, lat + lat_inc, lon);
190                         }
191                 }
192         }
193
194         BLI_assert(vbo_len == GPU_vertbuf_raw_used(&pos_step));
195         BLI_assert(vbo_len == GPU_vertbuf_raw_used(&nor_step));
196
197         return GPU_batch_create_ex(GPU_PRIM_LINES, vbo, NULL, GPU_BATCH_OWNS_VBO);
198 }
199
200 /** \} */
201
202 void gpu_batch_presets_init(void)
203 {
204         BLI_mutex_init(&g_presets_3d.mutex);
205
206         /* Hard coded resolution */
207         g_presets_3d.batch.sphere_low = gpu_batch_sphere(8, 16);
208         gpu_batch_presets_register(g_presets_3d.batch.sphere_low);
209
210         g_presets_3d.batch.sphere_med = gpu_batch_sphere(16, 10);
211         gpu_batch_presets_register(g_presets_3d.batch.sphere_med);
212
213         g_presets_3d.batch.sphere_high = gpu_batch_sphere(32, 24);
214         gpu_batch_presets_register(g_presets_3d.batch.sphere_high);
215
216         g_presets_3d.batch.sphere_wire_low = batch_sphere_wire(6, 8);
217         gpu_batch_presets_register(g_presets_3d.batch.sphere_wire_low);
218
219         g_presets_3d.batch.sphere_wire_med = batch_sphere_wire(8, 16);
220         gpu_batch_presets_register(g_presets_3d.batch.sphere_wire_med);
221 }
222
223 void gpu_batch_presets_register(GPUBatch *preset_batch)
224 {
225         BLI_mutex_lock(&g_presets_3d.mutex);
226         BLI_addtail(&presets_list, BLI_genericNodeN(preset_batch));
227         BLI_mutex_unlock(&g_presets_3d.mutex);
228 }
229
230 bool gpu_batch_presets_unregister(GPUBatch *preset_batch)
231 {
232         BLI_mutex_lock(&g_presets_3d.mutex);
233         for (LinkData *link = presets_list.last; link; link = link->prev) {
234                 if (preset_batch == link->data) {
235                         BLI_remlink(&presets_list, link);
236                         BLI_mutex_unlock(&g_presets_3d.mutex);
237                         MEM_freeN(link);
238                         return true;
239                 }
240         }
241         BLI_mutex_unlock(&g_presets_3d.mutex);
242         return false;
243 }
244
245 void gpu_batch_presets_reset(void)
246 {
247         BLI_mutex_lock(&g_presets_3d.mutex);
248         /* Reset vao caches for these every time we switch opengl context.
249          * This way they will draw correctly for each window. */
250         for (LinkData *link = presets_list.first; link; link = link->next) {
251                 GPUBatch *preset = link->data;
252                 GPU_batch_vao_cache_clear(preset);
253         }
254         BLI_mutex_unlock(&g_presets_3d.mutex);
255 }
256
257 void gpu_batch_presets_exit(void)
258 {
259         LinkData *link;
260         while ((link = BLI_pophead(&presets_list))) {
261                 GPUBatch *preset = link->data;
262                 GPU_batch_discard(preset);
263                 MEM_freeN(link);
264         }
265
266         BLI_mutex_end(&g_presets_3d.mutex);
267 }