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