aefaf1a0f541aa5638e7beada9a116504dce9015
[blender-staging.git] / source / blender / gpu / GPU_buffers.h
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) 2005 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Brecht Van Lommel.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file GPU_buffers.h
29  *  \ingroup gpu
30  */
31
32 #ifndef __GPU_BUFFERS_H__
33 #define __GPU_BUFFERS_H__
34
35 #ifdef DEBUG
36 /*  #define DEBUG_VBO(X) printf(X)*/
37 #  define DEBUG_VBO(X)
38 #else
39 #  define DEBUG_VBO(X)
40 #endif
41
42 #include <stddef.h>
43
44 struct BMesh;
45 struct CCGElem;
46 struct CCGKey;
47 struct DMFlagMat;
48 struct DerivedMesh;
49 struct GSet;
50 struct GPUVertPointLink;
51 struct GPUDrawObject;
52 struct GridCommonGPUBuffer;
53 struct PBVH;
54 struct MVert;
55
56 typedef struct GPUBuffer {
57         size_t size;        /* in bytes */
58         unsigned int id; /* used with vertex buffer objects */
59 } GPUBuffer;
60
61 typedef struct GPUBufferMaterial {
62         /* range of points used for this material */
63         unsigned int start;
64         unsigned int totelements;
65         unsigned int totloops;
66         unsigned int *polys; /* array of polygons for this material */
67         unsigned int totpolys; /* total polygons in polys */
68         unsigned int totvisiblepolys; /* total visible polygons */
69
70         /* original material index */
71         short mat_nr;
72 } GPUBufferMaterial;
73
74 void GPU_buffer_material_finalize(struct GPUDrawObject *gdo, GPUBufferMaterial *matinfo, int totmat);
75
76 /* meshes are split up by material since changing materials requires
77  * GL state changes that can't occur in the middle of drawing an
78  * array.
79  *
80  * some simplifying assumptions are made:
81  * - all quads are treated as two triangles.
82  * - no vertex sharing is used; each triangle gets its own copy of the
83  *   vertices it uses (this makes it easy to deal with a vertex used
84  *   by faces with different properties, such as smooth/solid shading,
85  *   different MCols, etc.)
86  *
87  * to avoid confusion between the original MVert vertices and the
88  * arrays of OpenGL vertices, the latter are referred to here and in
89  * the source as `points'. similarly, the OpenGL triangles generated
90  * for MFaces are referred to as triangles rather than faces.
91  */
92 typedef struct GPUDrawObject {
93         GPUBuffer *points;
94         GPUBuffer *normals;
95         GPUBuffer *uv;
96         GPUBuffer *uv_tex;
97         GPUBuffer *colors;
98         GPUBuffer *edges;
99         GPUBuffer *uvedges;
100         GPUBuffer *triangles; /* triangle index buffer */
101
102         /* for each original vertex, the list of related points */
103         struct GPUVertPointLink *vert_points;
104
105         /* see: USE_GPU_POINT_LINK define */
106 #if 0
107         /* storage for the vert_points lists */
108         struct GPUVertPointLink *vert_points_mem;
109         int vert_points_usage;
110 #endif
111         
112         int colType;
113
114         GPUBufferMaterial *materials;
115         int totmaterial;
116         
117         unsigned int tot_triangle_point;
118         unsigned int tot_loose_point;
119         /* different than total loops since ngons get tesselated still */
120         unsigned int tot_loop_verts;
121         
122         /* caches of the original DerivedMesh values */
123         unsigned int totvert;
124         unsigned int totedge;
125
126         unsigned int loose_edge_offset;
127         unsigned int tot_loose_edge_drawn;
128         unsigned int tot_edge_drawn;
129
130         /* for subsurf, offset where drawing of interior edges starts */
131         unsigned int interior_offset;
132         unsigned int totinterior;
133 } GPUDrawObject;
134
135 /* currently unused */
136 // #define USE_GPU_POINT_LINK
137
138 typedef struct GPUVertPointLink {
139 #ifdef USE_GPU_POINT_LINK
140         struct GPUVertPointLink *next;
141 #endif
142         /* -1 means uninitialized */
143         int point_index;
144 } GPUVertPointLink;
145
146
147
148 /* used for GLSL materials */
149 typedef struct GPUAttrib {
150         int index;
151         int info_index;
152         int size;
153         int type;
154 } GPUAttrib;
155
156 void GPU_global_buffer_pool_free(void);
157 void GPU_global_buffer_pool_free_unused(void);
158
159 GPUBuffer *GPU_buffer_alloc(size_t size);
160 void GPU_buffer_free(GPUBuffer *buffer);
161
162 void GPU_drawobject_free(struct DerivedMesh *dm);
163
164 /* flag that controls data type to fill buffer with, a modifier will prepare. */
165 typedef enum {
166         GPU_BUFFER_VERTEX = 0,
167         GPU_BUFFER_NORMAL,
168         GPU_BUFFER_COLOR,
169         GPU_BUFFER_UV,
170         GPU_BUFFER_UV_TEXPAINT,
171         GPU_BUFFER_EDGE,
172         GPU_BUFFER_UVEDGE,
173         GPU_BUFFER_TRIANGLES
174 } GPUBufferType;
175
176 typedef enum {
177         GPU_BINDING_ARRAY = 0,
178         GPU_BINDING_INDEX = 1,
179 } GPUBindingType;
180
181 typedef enum {
182         GPU_ATTR_INFO_SRGB = (1 << 0),
183 } GPUAttrInfo;
184
185 /* called before drawing */
186 void GPU_vertex_setup(struct DerivedMesh *dm);
187 void GPU_normal_setup(struct DerivedMesh *dm);
188 void GPU_uv_setup(struct DerivedMesh *dm);
189 void GPU_texpaint_uv_setup(struct DerivedMesh *dm);
190 /* colType is the cddata MCol type to use! */
191 void GPU_color_setup(struct DerivedMesh *dm, int colType);
192 void GPU_buffer_bind_as_color(GPUBuffer *buffer);
193 void GPU_edge_setup(struct DerivedMesh *dm); /* does not mix with other data */
194 void GPU_uvedge_setup(struct DerivedMesh *dm);
195
196 void GPU_triangle_setup(struct DerivedMesh *dm);
197
198 int GPU_attrib_element_size(GPUAttrib data[], int numdata);
199 void GPU_interleaved_attrib_setup(GPUBuffer *buffer, GPUAttrib data[], int numdata, int element_size);
200
201 void GPU_buffer_bind(GPUBuffer *buffer, GPUBindingType binding);
202 void GPU_buffer_unbind(GPUBuffer *buffer, GPUBindingType binding);
203
204 /* can't lock more than one buffer at once */
205 void *GPU_buffer_lock(GPUBuffer *buffer, GPUBindingType binding);
206 void *GPU_buffer_lock_stream(GPUBuffer *buffer, GPUBindingType binding);
207 void GPU_buffer_unlock(GPUBuffer *buffer, GPUBindingType binding);
208
209 /* switch color rendering on=1/off=0 */
210 void GPU_color_switch(int mode);
211
212 /* used for drawing edges */
213 void GPU_buffer_draw_elements(GPUBuffer *elements, unsigned int mode, int start, int count);
214
215 /* called after drawing */
216 void GPU_buffers_unbind(void);
217
218 /* only unbind interleaved data */
219 void GPU_interleaved_attrib_unbind(void);
220
221 /* Buffers for non-DerivedMesh drawing */
222 typedef struct GPU_PBVH_Buffers GPU_PBVH_Buffers;
223
224 /* build */
225 GPU_PBVH_Buffers *GPU_build_mesh_pbvh_buffers(
226         const int (*face_vert_indices)[4],
227         const struct MPoly *mpoly, const struct MLoop *mloop, const struct MLoopTri *looptri,
228         const struct MVert *verts,
229         const int *face_indices,
230         const int  face_indices_len);
231
232 GPU_PBVH_Buffers *GPU_build_grid_pbvh_buffers(
233         int *grid_indices, int totgrid,unsigned int **grid_hidden, int gridsize, const struct CCGKey *key,
234         struct GridCommonGPUBuffer **grid_common_gpu_buffer);
235
236 GPU_PBVH_Buffers *GPU_build_bmesh_pbvh_buffers(bool smooth_shading);
237
238 /* update */
239
240 void GPU_update_mesh_pbvh_buffers(
241         GPU_PBVH_Buffers *buffers, const struct MVert *mvert,
242         const int *vert_indices, int totvert, const float *vmask,
243         const int (*face_vert_indices)[4], bool show_diffuse_color);
244
245 void GPU_update_bmesh_pbvh_buffers(GPU_PBVH_Buffers *buffers,
246                               struct BMesh *bm,
247                               struct GSet *bm_faces,
248                               struct GSet *bm_unique_verts,
249                               struct GSet *bm_other_verts,
250                               bool show_diffuse_color);
251
252 void GPU_update_grid_pbvh_buffers(GPU_PBVH_Buffers *buffers, struct CCGElem **grids,
253                              const struct DMFlagMat *grid_flag_mats,
254                              int *grid_indices, int totgrid, const struct CCGKey *key,
255                              bool show_diffuse_color);
256
257 /* draw */
258 void GPU_draw_pbvh_buffers(GPU_PBVH_Buffers *buffers, DMSetMaterial setMaterial,
259                            bool wireframe, bool fast);
260
261 /* debug PBVH draw*/
262 void GPU_draw_pbvh_BB(float min[3], float max[3], bool leaf);
263 void GPU_end_draw_pbvh_BB(void);
264 void GPU_init_draw_pbvh_BB(void);
265
266 bool GPU_pbvh_buffers_diffuse_changed(GPU_PBVH_Buffers *buffers, struct GSet *bm_faces, bool show_diffuse_color);
267
268 void GPU_free_pbvh_buffers(GPU_PBVH_Buffers *buffers);
269 void GPU_free_pbvh_buffer_multires(struct GridCommonGPUBuffer **grid_common_gpu_buffer);
270
271 #endif