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 struct CCGElem;
  43 struct CCGKey;
  44 struct CustomData;
  45 struct DMFlagMat;
  46 struct DerivedMesh;
  47 struct GPUVertPointLink;
  48
  49 typedef struct GPUBuffer {
  50         int size;       /* in bytes */
  51         void *pointer;  /* used with vertex arrays */
  52         unsigned int id;        /* used with vertex buffer objects */
  53 } GPUBuffer;
  54
  55 typedef struct GPUBufferMaterial {
  56         /* range of points used for this material */
  57         int start;
  58         int totpoint;
  59
  60         /* original material index */
  61         short mat_nr;
  62 } GPUBufferMaterial;
  63
  64 /* meshes are split up by material since changing materials requires
  65  * GL state changes that can't occur in the middle of drawing an
  66  * array.
  67  *
  68  * some simplifying assumptions are made:
  69  * - all quads are treated as two triangles.
  70  * - no vertex sharing is used; each triangle gets its own copy of the
  71  *   vertices it uses (this makes it easy to deal with a vertex used
  72  *   by faces with different properties, such as smooth/solid shading,
  73  *   different MCols, etc.)
  74  *
  75  * to avoid confusion between the original MVert vertices and the
  76  * arrays of OpenGL vertices, the latter are referred to here and in
  77  * the source as `points'. similarly, the OpenGL triangles generated
  78  * for MFaces are referred to as triangles rather than faces.
  79  */
  80 typedef struct GPUDrawObject {
  81         GPUBuffer *points;
  82         GPUBuffer *normals;
  83         GPUBuffer *uv;
  84         GPUBuffer *colors;
  85         GPUBuffer *edges;
  86         GPUBuffer *uvedges;
  87
  88         /* for each triangle, the original MFace index */
  89         int *triangle_to_mface;
  90
  91         /* for each original vertex, the list of related points */
  92         struct GPUVertPointLink *vert_points;
  93         /* storage for the vert_points lists */
  94         struct GPUVertPointLink *vert_points_mem;
  95         int vert_points_usage;
  96
  97         int colType;
  98
  99         GPUBufferMaterial *materials;
 100         int totmaterial;
 101
 102         int tot_triangle_point;
 103         int tot_loose_point;
 104
 105         /* caches of the original DerivedMesh values */
 106         int totvert;
 107         int totedge;
 108
 109         /* if there was a failure allocating some buffer, use old
 110          * rendering code */
 111         int legacy;
 112 } GPUDrawObject;
 113
 114 /* used for GLSL materials */
 115 typedef struct GPUAttrib {
 116         int index;
 117         int size;
 118         int type;
 119 } GPUAttrib;
 120
 121 void GPU_global_buffer_pool_free(void);
 122
 123 GPUBuffer *GPU_buffer_alloc(int size);
 124 void GPU_buffer_free(GPUBuffer *buffer);
 125
 126 GPUDrawObject *GPU_drawobject_new(struct DerivedMesh *dm );
 127 void GPU_drawobject_free(struct DerivedMesh *dm );
 128
 129 /* called before drawing */
 130 void GPU_vertex_setup(struct DerivedMesh *dm );
 131 void GPU_normal_setup(struct DerivedMesh *dm );
 132 void GPU_uv_setup(struct DerivedMesh *dm );
 133 void GPU_color_setup(struct DerivedMesh *dm );
 134 void GPU_edge_setup(struct DerivedMesh *dm );   /* does not mix with other data */
 135 void GPU_uvedge_setup(struct DerivedMesh *dm );
 136 int GPU_attrib_element_size( GPUAttrib data[], int numdata );
 137 void GPU_interleaved_attrib_setup( GPUBuffer *buffer, GPUAttrib data[], int numdata );
 138
 139 /* can't lock more than one buffer at once */
 140 void *GPU_buffer_lock( GPUBuffer *buffer );
 141 void *GPU_buffer_lock_stream( GPUBuffer *buffer );
 142 void GPU_buffer_unlock( GPUBuffer *buffer );
 143
 144 /* upload three unsigned chars, representing RGB colors, for each vertex. Resets dm->drawObject->colType to -1 */
 145 void GPU_color3_upload(struct DerivedMesh *dm, unsigned char *data );
 146 /* switch color rendering on=1/off=0 */
 147 void GPU_color_switch( int mode );
 148
 149 /* used for drawing edges */
 150 void GPU_buffer_draw_elements( GPUBuffer *elements, unsigned int mode, int start, int count );
 151
 152 /* called after drawing */
 153 void GPU_buffer_unbind(void);
 154
 155 /* used to check whether to use the old (without buffers) code */
 156 int GPU_buffer_legacy(struct DerivedMesh *dm );
 157
 158 /* Buffers for non-DerivedMesh drawing */
 159 typedef struct GPU_Buffers GPU_Buffers;
 160
 161 GPU_Buffers *GPU_build_mesh_buffers(int (*face_vert_indices)[4],
 162                         struct MFace *mface, struct MVert *mvert,
 163             int *face_indices, int totface);
 164
 165 void GPU_update_mesh_buffers(GPU_Buffers *buffers, struct MVert *mvert,
 166                         int *vert_indices, int totvert, const float *vmask);
 167
 168 GPU_Buffers *GPU_build_grid_buffers(int *grid_indices, int totgrid,
 169                                                                         unsigned int **grid_hidden, int gridsize);
 170
 171 void GPU_update_grid_buffers(GPU_Buffers *buffers, struct CCGElem **grids,
 172                                                          const struct DMFlagMat *grid_flag_mats,
 173                                                          int *grid_indices, int totgrid, const struct CCGKey *key);
 174
 175 void GPU_draw_buffers(GPU_Buffers *buffers, DMSetMaterial setMaterial);
 176
 177 void GPU_free_buffers(GPU_Buffers *buffers);
 178
 179 #endif