Remove vertex array support from GPUBuffers. Remove USER_DISABLE_VBO. All

GPUBuffer rendering is now done using vertex buffers.

Vertex arrays are completely removed from GL 3.2 core profile, so we'll
have to do this change at some point anyway.

This commit, though big, is not modifying blender in any way. Use should
be exactly as if the vetex buffer option is constantly on.

1 files changed, 92 insertions, 235 deletions

diff --git a/source/blender/gpu/intern/gpu_buffers.c b/source/blender/gpu/intern/gpu_buffers.c
index eeefa92dc78..69aca31e21a 100644
--- a/source/blender/gpu/intern/gpu_buffers.c
+++ b/source/blender/gpu/intern/gpu_buffers.c
@@ -209,10 +209,7 @@ static void gpu_buffer_pool_delete_last(GPUBufferPool *pool)
 		return;
 
 	/* delete the buffer's data */
-	if (last->use_vbo)
-		glDeleteBuffers(1, &last->id);
-	else
-		MEM_freeN(last->pointer);
+	glDeleteBuffers(1, &last->id);
 
 	/* delete the buffer and remove from pool */
 	MEM_freeN(last);
@@ -273,7 +270,7 @@ void GPU_global_buffer_pool_free_unused(void)
  *
  * Thread-unsafe version for internal usage only.
  */
-static GPUBuffer *gpu_buffer_alloc_intern(size_t size, bool use_VBO)
+static GPUBuffer *gpu_buffer_alloc_intern(size_t size)
 {
 	GPUBufferPool *pool;
 	GPUBuffer *buf;
@@ -298,11 +295,6 @@ static GPUBuffer *gpu_buffer_alloc_intern(size_t size, bool use_VBO)
 	 * twice as big */
 	for (i = 0; i < pool->totbuf; i++) {
 		bufsize = pool->buffers[i]->size;
-
-		/* only return a buffer that matches the VBO preference */
-		if (pool->buffers[i]->use_vbo != use_VBO) {
-			 continue;
-		}
 		
 		/* check for an exact size match */
 		if (bufsize == size) {
@@ -332,45 +324,19 @@ static GPUBuffer *gpu_buffer_alloc_intern(size_t size, bool use_VBO)
 	/* no acceptable buffer found in the pool, create a new one */
 	buf = MEM_callocN(sizeof(GPUBuffer), "GPUBuffer");
 	buf->size = size;
-	buf->use_vbo = use_VBO;
-
-	if (use_VBO) {
-		/* create a new VBO and initialize it to the requested
-		 * size */
-		glGenBuffers(1, &buf->id);
-		glBindBuffer(GL_ARRAY_BUFFER, buf->id);
-		glBufferData(GL_ARRAY_BUFFER, size, NULL, GL_STATIC_DRAW);
-		glBindBuffer(GL_ARRAY_BUFFER, 0);
-	}
-	else {
-		static int time = 0;
-
-		buf->pointer = MEM_mallocN(size, "GPUBuffer.pointer");
 
-		time++;
-		/* purpose of this seems to be dealing with
-		 * out-of-memory errors? looks a bit iffy to me
-		 * though, at least on Linux I expect malloc() would
-		 * just overcommit. --nicholas */
-		while (!buf->pointer && pool->totbuf > 0) {
-			gpu_buffer_pool_delete_last(pool);
-			buf->pointer = MEM_mallocN(size, "GPUBuffer.pointer");
-		}
-		if (!buf->pointer) {
-			MEM_freeN(buf);
-			return NULL;
-		}
-	}
+	glGenBuffers(1, &buf->id);
+	glBindBuffer(GL_ARRAY_BUFFER, buf->id);
+	glBufferData(GL_ARRAY_BUFFER, size, NULL, GL_STATIC_DRAW);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
 
 	return buf;
 }
 
 /* Same as above, but safe for threading. */
-GPUBuffer *GPU_buffer_alloc(size_t size, bool force_vertex_arrays)
+GPUBuffer *GPU_buffer_alloc(size_t size)
 {
 	GPUBuffer *buffer;
-	bool use_VBOs = !(U.gameflags & USER_DISABLE_VBO) && !force_vertex_arrays;
-	/* TODO: remove USER_DISABLE_VBO from user prefs */
 
 	if (size == 0) {
 		/* Early out, no lock needed in this case. */
@@ -378,7 +344,7 @@ GPUBuffer *GPU_buffer_alloc(size_t size, bool force_vertex_arrays)
 	}
 
 	BLI_mutex_lock(&buffer_mutex);
-	buffer = gpu_buffer_alloc_intern(size, use_VBOs);
+	buffer = gpu_buffer_alloc_intern(size);
 	BLI_mutex_unlock(&buffer_mutex);
 
 	return buffer;
@@ -453,8 +419,6 @@ void GPU_buffer_multires_free(bool force)
 		if (mres_glob_buffer) {
 			if (mres_glob_buffer->id)
 				glDeleteBuffers(1, &mres_glob_buffer->id);
-			else if (mres_glob_buffer->pointer)
-				MEM_freeN(mres_glob_buffer->pointer);
 			MEM_freeN(mres_glob_buffer);
 		}
 	}
@@ -503,7 +467,7 @@ void GPU_drawobject_free(DerivedMesh *dm)
 	dm->drawObject = NULL;
 }
 
-static GPUBuffer *gpu_try_realloc(GPUBufferPool *pool, GPUBuffer *buffer, size_t size, bool use_VBOs)
+static GPUBuffer *gpu_try_realloc(GPUBufferPool *pool, GPUBuffer *buffer, size_t size)
 {
 	/* try freeing an entry from the pool
 	 * and reallocating the buffer */
@@ -513,7 +477,7 @@ static GPUBuffer *gpu_try_realloc(GPUBufferPool *pool, GPUBuffer *buffer, size_t
 
 	while (pool->totbuf && !buffer) {
 		gpu_buffer_pool_delete_last(pool);
-		buffer = gpu_buffer_alloc_intern(size, use_VBOs);
+		buffer = gpu_buffer_alloc_intern(size);
 	}
 
 	return buffer;
@@ -530,8 +494,6 @@ static GPUBuffer *gpu_buffer_setup(DerivedMesh *dm, GPUDrawObject *object,
 	const GPUBufferTypeSettings *ts = &gpu_buffer_type_settings[type];
 	GLenum target = ts->gl_buffer_type;
 	size_t size = gpu_buffer_size_from_type(dm, type);
-	bool use_VBOs = !(U.gameflags & USER_DISABLE_VBO);
-	/* TODO: remove USER_DISABLE_VBO from user prefs */
 	GLboolean uploaded;
 
 	pool = gpu_get_global_buffer_pool();
@@ -539,7 +501,7 @@ static GPUBuffer *gpu_buffer_setup(DerivedMesh *dm, GPUDrawObject *object,
 	BLI_mutex_lock(&buffer_mutex);
 
 	/* alloc a GPUBuffer; fall back to legacy mode on failure */
-	if (!(buffer = gpu_buffer_alloc_intern(size, use_VBOs))) {
+	if (!(buffer = gpu_buffer_alloc_intern(size))) {
 		BLI_mutex_unlock(&buffer_mutex);
 		return NULL;
 	}
@@ -552,56 +514,34 @@ static GPUBuffer *gpu_buffer_setup(DerivedMesh *dm, GPUDrawObject *object,
 		mat_orig_to_new[object->materials[i].mat_nr] = i;
 	}
 
-	if (use_VBOs) {
-		bool success = false;
+	/* bind the buffer and discard previous data,
+	 * avoids stalling gpu */
+	glBindBuffer(target, buffer->id);
+	glBufferData(target, buffer->size, NULL, GL_STATIC_DRAW);
 
-		while (!success) {
-			/* bind the buffer and discard previous data,
-			 * avoids stalling gpu */
-			glBindBuffer(target, buffer->id);
-			glBufferData(target, buffer->size, NULL, GL_STATIC_DRAW);
+	/* attempt to map the buffer */
+	if (!(varray = glMapBuffer(target, GL_WRITE_ONLY))) {
+		buffer = gpu_try_realloc(pool, buffer, size);
 
-			/* attempt to map the buffer */
-			if (!(varray = glMapBuffer(target, GL_WRITE_ONLY))) {
-				buffer = gpu_try_realloc(pool, buffer, size, true);
-
-				/* allocation still failed; fall back
-				 * to legacy mode */
-				if (!(buffer && (varray = glMapBuffer(target, GL_WRITE_ONLY)))) {
-					use_VBOs = false;
-					success = true;
-				}
-			}
-			else {
-				success = true;
-			}
-		}
-
-		/* check legacy fallback didn't happen */
-		if (use_VBOs) {
-			uploaded = GL_FALSE;
-			/* attempt to upload the data to the VBO */
-			while (uploaded == GL_FALSE) {
-				dm->copy_gpu_data(dm, type, varray, mat_orig_to_new, user);
-				/* glUnmapBuffer returns GL_FALSE if
-				 * the data store is corrupted; retry
-				 * in that case */
-				uploaded = glUnmapBuffer(target);
-			}
+		/* allocation still failed; unfortunately we need to exit */
+		if (!(buffer && (varray = glMapBuffer(target, GL_WRITE_ONLY)))) {
+			if (buffer)
+				gpu_buffer_free_intern(buffer);
+			return NULL;
 		}
-		glBindBuffer(target, 0);
 	}
-	if (!use_VBOs) {
-		/* VBO not supported, use vertex array fallback */
-		if (!buffer || !buffer->pointer) {
-			buffer = gpu_try_realloc(pool, buffer, size, false);
-		}
-		
-		if (buffer) {
-			varray = buffer->pointer;
-			dm->copy_gpu_data(dm, type, varray, mat_orig_to_new, user);
-		}
+
+	uploaded = GL_FALSE;
+
+	/* attempt to upload the data to the VBO */
+	while (uploaded == GL_FALSE) {
+		dm->copy_gpu_data(dm, type, varray, mat_orig_to_new, user);
+		/* glUnmapBuffer returns GL_FALSE if
+		 * the data store is corrupted; retry
+		 * in that case */
+		uploaded = glUnmapBuffer(target);
 	}
+	glBindBuffer(target, 0);
 
 	MEM_freeN(mat_orig_to_new);
 
@@ -703,13 +643,8 @@ void GPU_vertex_setup(DerivedMesh *dm)
 		return;
 
 	glEnableClientState(GL_VERTEX_ARRAY);
-	if (dm->drawObject->points->use_vbo) {
-		glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->points->id);
-		glVertexPointer(3, GL_FLOAT, 0, 0);
-	}
-	else {
-		glVertexPointer(3, GL_FLOAT, 0, dm->drawObject->points->pointer);
-	}
+	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->points->id);
+	glVertexPointer(3, GL_FLOAT, 0, 0);
 	
 	GLStates |= GPU_BUFFER_VERTEX_STATE;
 }
@@ -720,13 +655,8 @@ void GPU_normal_setup(DerivedMesh *dm)
 		return;
 
 	glEnableClientState(GL_NORMAL_ARRAY);
-	if (dm->drawObject->normals->use_vbo) {
-		glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->normals->id);
-		glNormalPointer(GL_SHORT, 4 * sizeof(short), 0);
-	}
-	else {
-		glNormalPointer(GL_SHORT, 4 * sizeof(short), dm->drawObject->normals->pointer);
-	}
+	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->normals->id);
+	glNormalPointer(GL_SHORT, 4 * sizeof(short), 0);
 
 	GLStates |= GPU_BUFFER_NORMAL_STATE;
 }
@@ -737,13 +667,8 @@ void GPU_uv_setup(DerivedMesh *dm)
 		return;
 
 	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-	if (dm->drawObject->uv->use_vbo) {
-		glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->uv->id);
-		glTexCoordPointer(2, GL_FLOAT, 0, 0);
-	}
-	else {
-		glTexCoordPointer(2, GL_FLOAT, 0, dm->drawObject->uv->pointer);
-	}
+	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->uv->id);
+	glTexCoordPointer(2, GL_FLOAT, 0, 0);
 
 	GLStates |= GPU_BUFFER_TEXCOORD_UNIT_0_STATE;
 }
@@ -754,21 +679,12 @@ void GPU_texpaint_uv_setup(DerivedMesh *dm)
 		return;
 
 	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-	if (dm->drawObject->uv_tex->use_vbo) {
-		glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->uv_tex->id);
-		glTexCoordPointer(2, GL_FLOAT, 4 * sizeof(float), 0);
-		glClientActiveTexture(GL_TEXTURE2);
-		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-		glTexCoordPointer(2, GL_FLOAT, 4 * sizeof(float), BUFFER_OFFSET(2 * sizeof(float)));
-		glClientActiveTexture(GL_TEXTURE0);
-	}
-	else {
-		glTexCoordPointer(2, GL_FLOAT, 4 * sizeof(float), dm->drawObject->uv_tex->pointer);
-		glClientActiveTexture(GL_TEXTURE2);
-		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-		glTexCoordPointer(2, GL_FLOAT, 4 * sizeof(float), (char *)dm->drawObject->uv_tex->pointer + 2 * sizeof(float));
-		glClientActiveTexture(GL_TEXTURE0);
-	}
+	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->uv_tex->id);
+	glTexCoordPointer(2, GL_FLOAT, 4 * sizeof(float), 0);
+	glClientActiveTexture(GL_TEXTURE2);
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	glTexCoordPointer(2, GL_FLOAT, 4 * sizeof(float), BUFFER_OFFSET(2 * sizeof(float)));
+	glClientActiveTexture(GL_TEXTURE0);
 
 	GLStates |= GPU_BUFFER_TEXCOORD_UNIT_0_STATE | GPU_BUFFER_TEXCOORD_UNIT_2_STATE;
 }
@@ -800,13 +716,8 @@ void GPU_color_setup(DerivedMesh *dm, int colType)
 		return;
 
 	glEnableClientState(GL_COLOR_ARRAY);
-	if (dm->drawObject->colors->use_vbo) {
-		glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->colors->id);
-		glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0);
-	}
-	else {
-		glColorPointer(3, GL_UNSIGNED_BYTE, 0, dm->drawObject->colors->pointer);
-	}
+	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->colors->id);
+	glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0);
 
 	GLStates |= GPU_BUFFER_COLOR_STATE;
 }
@@ -814,13 +725,8 @@ void GPU_color_setup(DerivedMesh *dm, int colType)
 void GPU_buffer_bind_as_color(GPUBuffer *buffer)
 {
 	glEnableClientState(GL_COLOR_ARRAY);
-	if (buffer->use_vbo) {
-		glBindBuffer(GL_ARRAY_BUFFER, buffer->id);
-		glColorPointer(4, GL_UNSIGNED_BYTE, 0, 0);
-	}
-	else {
-		glColorPointer(4, GL_UNSIGNED_BYTE, 0, buffer->pointer);
-	}
+	glBindBuffer(GL_ARRAY_BUFFER, buffer->id);
+	glColorPointer(4, GL_UNSIGNED_BYTE, 0, 0);
 
 	GLStates |= GPU_BUFFER_COLOR_STATE;
 }
@@ -835,20 +741,12 @@ void GPU_edge_setup(DerivedMesh *dm)
 		return;
 
 	glEnableClientState(GL_VERTEX_ARRAY);
-	if (dm->drawObject->points->use_vbo) {
-		glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->points->id);
-		glVertexPointer(3, GL_FLOAT, 0, 0);
-	}
-	else {
-		glVertexPointer(3, GL_FLOAT, 0, dm->drawObject->points->pointer);
-	}
+	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->points->id);
+	glVertexPointer(3, GL_FLOAT, 0, 0);
 	
-	GLStates |= GPU_BUFFER_VERTEX_STATE;
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dm->drawObject->edges->id);
 
-	if (dm->drawObject->edges->use_vbo)
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dm->drawObject->edges->id);
-
-	GLStates |= GPU_BUFFER_ELEMENT_STATE;
+	GLStates |= (GPU_BUFFER_VERTEX_STATE | GPU_BUFFER_ELEMENT_STATE);
 }
 
 void GPU_uvedge_setup(DerivedMesh *dm)
@@ -857,13 +755,8 @@ void GPU_uvedge_setup(DerivedMesh *dm)
 		return;
 
 	glEnableClientState(GL_VERTEX_ARRAY);
-	if (dm->drawObject->uvedges->use_vbo) {
-		glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->uvedges->id);
-		glVertexPointer(2, GL_FLOAT, 0, 0);
-	}
-	else {
-		glVertexPointer(2, GL_FLOAT, 0, dm->drawObject->uvedges->pointer);
-	}
+	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->uvedges->id);
+	glVertexPointer(2, GL_FLOAT, 0, 0);
 	
 	GLStates |= GPU_BUFFER_VERTEX_STATE;
 }
@@ -873,10 +766,7 @@ void GPU_triangle_setup(struct DerivedMesh *dm)
 	if (!gpu_buffer_setup_common(dm, GPU_BUFFER_TRIANGLES))
 		return;
 
-	if (dm->drawObject->triangles->use_vbo) {
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dm->drawObject->triangles->id);
-	}
-
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dm->drawObject->triangles->id);
 	GLStates |= GPU_BUFFER_ELEMENT_STATE;
 }
 
@@ -914,8 +804,7 @@ void GPU_interleaved_attrib_setup(GPUBuffer *buffer, GPUAttrib data[], int numda
 {
 	int i;
 	int elementsize;
-	intptr_t offset = 0;
-	char *basep;
+	size_t offset = 0;
 
 	for (i = 0; i < MAX_GPU_ATTRIB_DATA; i++) {
 		if (attribData[i].index != -1) {
@@ -929,18 +818,12 @@ void GPU_interleaved_attrib_setup(GPUBuffer *buffer, GPUAttrib data[], int numda
 	else
 		elementsize = element_size;
 
-	if (buffer->use_vbo) {
-		glBindBuffer(GL_ARRAY_BUFFER, buffer->id);
-		basep = NULL;
-	}
-	else {
-		basep = buffer->pointer;
-	}
+	glBindBuffer(GL_ARRAY_BUFFER, buffer->id);
 	
 	for (i = 0; i < numdata; i++) {
 		glEnableVertexAttribArray(data[i].index);
 		glVertexAttribPointer(data[i].index, data[i].size, data[i].type,
-		                         GL_FALSE, elementsize, (void *)(basep + offset));
+		                         GL_FALSE, elementsize, BUFFER_OFFSET(offset));
 		offset += data[i].size * GPU_typesize(data[i].type);
 		
 		attribData[i].index = data[i].index;
@@ -1025,75 +908,58 @@ static int gpu_binding_type_gl[] =
 void *GPU_buffer_lock(GPUBuffer *buffer, GPUBindingType binding)
 {
 	float *varray;
+	int bindtypegl;
 
 	if (!buffer)
 		return 0;
 
-	if (buffer->use_vbo) {
-		int bindtypegl = gpu_binding_type_gl[binding];
-		glBindBuffer(bindtypegl, buffer->id);
-		varray = glMapBuffer(bindtypegl, GL_WRITE_ONLY);
-		return varray;
-	}
-	else {
-		return buffer->pointer;
-	}
+	bindtypegl = gpu_binding_type_gl[binding];
+	glBindBuffer(bindtypegl, buffer->id);
+	varray = glMapBuffer(bindtypegl, GL_WRITE_ONLY);
+	return varray;
 }
 
 void *GPU_buffer_lock_stream(GPUBuffer *buffer, GPUBindingType binding)
 {
 	float *varray;
+	int bindtypegl;
 
 	if (!buffer)
 		return 0;
 
-	if (buffer->use_vbo) {
-		int bindtypegl = gpu_binding_type_gl[binding];
-		glBindBuffer(bindtypegl, buffer->id);
-		/* discard previous data, avoid stalling gpu */
-		glBufferData(bindtypegl, buffer->size, 0, GL_STREAM_DRAW);
-		varray = glMapBuffer(bindtypegl, GL_WRITE_ONLY);
-		return varray;
-	}
-	else {
-		return buffer->pointer;
-	}
+	bindtypegl = gpu_binding_type_gl[binding];
+	glBindBuffer(bindtypegl, buffer->id);
+	/* discard previous data, avoid stalling gpu */
+	glBufferData(bindtypegl, buffer->size, 0, GL_STREAM_DRAW);
+	varray = glMapBuffer(bindtypegl, GL_WRITE_ONLY);
+	return varray;
 }
 
-void GPU_buffer_unlock(GPUBuffer *buffer, GPUBindingType binding)
+void GPU_buffer_unlock(GPUBuffer *UNUSED(buffer), GPUBindingType binding)
 {
-	if (buffer->use_vbo) {
-		int bindtypegl = gpu_binding_type_gl[binding];
-		/* note: this operation can fail, could return
+	int bindtypegl = gpu_binding_type_gl[binding];
+	/* note: this operation can fail, could return
 		 * an error code from this function? */
-		glUnmapBuffer(bindtypegl);
-		glBindBuffer(bindtypegl, 0);
-	}
+	glUnmapBuffer(bindtypegl);
+	glBindBuffer(bindtypegl, 0);
 }
 
 void GPU_buffer_bind(GPUBuffer *buffer, GPUBindingType binding)
 {
-	if (buffer->use_vbo) {
-		int bindtypegl = gpu_binding_type_gl[binding];
-		glBindBuffer(bindtypegl, buffer->id);
-	}
+	int bindtypegl = gpu_binding_type_gl[binding];
+	glBindBuffer(bindtypegl, buffer->id);
 }
 
-void GPU_buffer_unbind(GPUBuffer *buffer, GPUBindingType binding)
+void GPU_buffer_unbind(GPUBuffer *UNUSED(buffer), GPUBindingType binding)
 {
-	if (buffer->use_vbo) {
-		int bindtypegl = gpu_binding_type_gl[binding];
-		glBindBuffer(bindtypegl, 0);
-	}
+	int bindtypegl = gpu_binding_type_gl[binding];
+	glBindBuffer(bindtypegl, 0);
 }
 
 /* used for drawing edges */
-void GPU_buffer_draw_elements(GPUBuffer *elements, unsigned int mode, int start, int count)
+void GPU_buffer_draw_elements(GPUBuffer *UNUSED(elements), unsigned int mode, int start, int count)
 {
-	glDrawElements(mode, count, GL_UNSIGNED_INT,
-	               (elements->use_vbo ?
-	                (void *)(start * sizeof(unsigned int)) :
-	                ((int *)elements->pointer) + start));
+	glDrawElements(mode, count, GL_UNSIGNED_INT, BUFFER_OFFSET(start * sizeof(unsigned int)));
 }
 
 
@@ -1236,7 +1102,7 @@ void GPU_update_mesh_pbvh_buffers(
 		/* Build VBO */
 		if (buffers->vert_buf)
 			GPU_buffer_free(buffers->vert_buf);
-		buffers->vert_buf = GPU_buffer_alloc(sizeof(VertexBufferFormat) * totelem, false);
+		buffers->vert_buf = GPU_buffer_alloc(sizeof(VertexBufferFormat) * totelem);
 		vert_data = GPU_buffer_lock(buffers->vert_buf, GPU_BINDING_ARRAY);
 
 		if (vert_data) {
@@ -1377,7 +1243,7 @@ GPU_PBVH_Buffers *GPU_build_mesh_pbvh_buffers(
 	 * shading requires separate vertex normals so an index buffer is
 	 * can't be used there. */
 	if (buffers->smooth)
-		buffers->index_buf = GPU_buffer_alloc(sizeof(unsigned short) * tottri * 3, false);
+		buffers->index_buf = GPU_buffer_alloc(sizeof(unsigned short) * tottri * 3);
 
 	if (buffers->index_buf) {
 		/* Fill the triangle buffer */
@@ -1529,8 +1395,7 @@ void GPU_update_grid_pbvh_buffers(GPU_PBVH_Buffers *buffers, CCGElem **grids,
         type_ *tri_data;                                                \
         int offset = 0;                                                 \
         int i, j, k;                                                    \
-        buffer_ = GPU_buffer_alloc(sizeof(type_) * (tot_quad_) * 6,     \
-                                  false);                               \
+        buffer_ = GPU_buffer_alloc(sizeof(type_) * (tot_quad_) * 6);    \
                                                                         \
         /* Fill the buffer */                                           \
         tri_data = GPU_buffer_lock(buffer_, GPU_BINDING_INDEX);         \
@@ -1608,7 +1473,7 @@ static GPUBuffer *gpu_get_grid_buffer(int gridsize, GLenum *index_type, unsigned
 #define FILL_FAST_BUFFER(type_) \
 { \
 	type_ *buffer; \
-	buffers->index_buf_fast = GPU_buffer_alloc(sizeof(type_) * 6 * totgrid, false); \
+	buffers->index_buf_fast = GPU_buffer_alloc(sizeof(type_) * 6 * totgrid); \
 	buffer = GPU_buffer_lock(buffers->index_buf_fast, GPU_BINDING_INDEX); \
 	if (buffer) { \
 		int i; \
@@ -1679,7 +1544,7 @@ GPU_PBVH_Buffers *GPU_build_grid_pbvh_buffers(int *grid_indices, int totgrid,
 
 	/* Build coord/normal VBO */
 	if (buffers->index_buf)
-		buffers->vert_buf = GPU_buffer_alloc(sizeof(VertexBufferFormat) * totgrid * key->grid_area, false);
+		buffers->vert_buf = GPU_buffer_alloc(sizeof(VertexBufferFormat) * totgrid * key->grid_area);
 
 	if (GLEW_ARB_draw_elements_base_vertex /* 3.2 */) {
 		int i;
@@ -1688,8 +1553,7 @@ GPU_PBVH_Buffers *GPU_build_grid_pbvh_buffers(int *grid_indices, int totgrid,
 		for (i = 0; i < totgrid; i++) {
 			buffers->baseelemarray[i] = buffers->tot_quad * 6;
 			buffers->baseelemarray[i + totgrid] = i * key->grid_area;
-			buffers->baseindex[i] = buffers->index_buf && !buffers->index_buf->use_vbo ?
-			                                      buffers->index_buf->pointer : NULL;
+			buffers->baseindex[i] = NULL;
 		}
 	}
 
@@ -1821,7 +1685,7 @@ void GPU_update_bmesh_pbvh_buffers(GPU_PBVH_Buffers *buffers,
 	/* Initialize vertex buffer */
 	if (buffers->vert_buf)
 		GPU_buffer_free(buffers->vert_buf);
-	buffers->vert_buf = GPU_buffer_alloc(sizeof(VertexBufferFormat) * totvert, false);
+	buffers->vert_buf = GPU_buffer_alloc(sizeof(VertexBufferFormat) * totvert);
 
 	/* Fill vertex buffer */
 	vert_data = GPU_buffer_lock(buffers->vert_buf, GPU_BINDING_ARRAY);
@@ -1904,7 +1768,7 @@ void GPU_update_bmesh_pbvh_buffers(GPU_PBVH_Buffers *buffers,
 			GPU_buffer_free(buffers->index_buf);
 		buffers->index_buf = GPU_buffer_alloc((use_short ?
 		                                      sizeof(unsigned short) :
-		                                      sizeof(unsigned int)) * 3 * tottri, false);
+		                                      sizeof(unsigned int)) * 3 * tottri);
 
 		/* Fill triangle index buffer */
 		tri_data = GPU_buffer_lock(buffers->index_buf, GPU_BINDING_INDEX);
@@ -2005,18 +1869,11 @@ void GPU_draw_pbvh_buffers(GPU_PBVH_Buffers *buffers, DMSetMaterial setMaterial,
 
 		GPU_buffer_bind(buffers->vert_buf, GPU_BINDING_ARRAY);
 
-		if (!buffers->vert_buf->use_vbo)
-			base = (char *)buffers->vert_buf->pointer;
-
 		if (do_fast) {
 			GPU_buffer_bind(buffers->index_buf_fast, GPU_BINDING_INDEX);
-			if (!buffers->index_buf_fast->use_vbo)
-				index_base = buffers->index_buf_fast->pointer;
 		}
 		else if (buffers->index_buf) {
 			GPU_buffer_bind(buffers->index_buf, GPU_BINDING_INDEX);
-			if (!buffers->index_buf->use_vbo)
-				index_base = buffers->index_buf->pointer;
 		}
 
 		if (wireframe)