/*
* Mesa 3-D graphics library
- * Version: 5.1
+ * Version: 6.3
*
- * Copyright (C) 1999-2003 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
#include "glheader.h"
#include "hash.h"
#include "imports.h"
+#include "image.h"
#include "context.h"
#include "bufferobj.h"
case GL_ELEMENT_ARRAY_BUFFER_ARB:
bufObj = ctx->Array.ElementArrayBufferObj;
break;
+ case GL_PIXEL_PACK_BUFFER_EXT:
+ bufObj = ctx->Pack.BufferObj;
+ break;
+ case GL_PIXEL_UNPACK_BUFFER_EXT:
+ bufObj = ctx->Unpack.BufferObj;
+ break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "gl%s(target)", str);
return NULL;
}
bufObj = buffer_object_get_target( ctx, target, str );
- if ( bufObj == NULL ) {
+ if (!bufObj || bufObj->Name == 0) {
return NULL;
}
- if ( (GLuint)(offset + size) > bufObj->Size ) {
+ if ((GLuint) (offset + size) > bufObj->Size) {
_mesa_error(ctx, GL_INVALID_VALUE,
"%s(size + offset > buffer size)", str);
return NULL;
}
- if ( bufObj->Pointer != NULL ) {
+ if (bufObj->Pointer) {
+ /* Buffer is currently mapped */
_mesa_error(ctx, GL_INVALID_OPERATION, "%s", str);
return NULL;
}
_mesa_new_buffer_object( GLcontext *ctx, GLuint name, GLenum target )
{
struct gl_buffer_object *obj;
+
+ (void) ctx;
+
obj = MALLOC_STRUCT(gl_buffer_object);
_mesa_initialize_buffer_object(obj, name, target);
return obj;
* Delete a buffer object.
*
* This function is intended to be called via
- * \c dd_function_table::DeleteBufferObject.
+ * \c dd_function_table::DeleteBuffer.
*/
void
_mesa_delete_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj )
{
+ (void) ctx;
+
if (bufObj->Data)
_mesa_free(bufObj->Data);
_mesa_free(bufObj);
_mesa_initialize_buffer_object( struct gl_buffer_object *obj,
GLuint name, GLenum target )
{
+ (void) target;
+
_mesa_bzero(obj, sizeof(struct gl_buffer_object));
obj->RefCount = 1;
obj->Name = name;
+ obj->Usage = GL_STATIC_DRAW_ARB;
+ obj->Access = GL_READ_WRITE_ARB;
}
{
void * new_data;
- (void) target;
+ (void) ctx; (void) target;
new_data = _mesa_realloc( bufObj->Data, bufObj->Size, size );
- if ( new_data != NULL ) {
+ if (new_data) {
bufObj->Data = (GLubyte *) new_data;
bufObj->Size = size;
bufObj->Usage = usage;
- if ( data != NULL ) {
+ if (data) {
_mesa_memcpy( bufObj->Data, data, size );
}
}
GLsizeiptrARB size, const GLvoid * data,
struct gl_buffer_object * bufObj )
{
- if ( (bufObj->Data != NULL)
- && ((GLuint)(size + offset) <= bufObj->Size) ) {
+ (void) ctx; (void) target;
+
+ if (bufObj->Data && ((GLuint) (size + offset) <= bufObj->Size)) {
_mesa_memcpy( (GLubyte *) bufObj->Data + offset, data, size );
}
}
GLsizeiptrARB size, GLvoid * data,
struct gl_buffer_object * bufObj )
{
- if ( (bufObj->Data != NULL)
- && ((GLuint)(size + offset) <= bufObj->Size) ) {
+ (void) ctx; (void) target;
+
+ if (bufObj->Data && ((GLsizeiptrARB) (size + offset) <= bufObj->Size)) {
_mesa_memcpy( data, (GLubyte *) bufObj->Data + offset, size );
}
}
/**
- * Maps the private data buffer into the processor's address space.
+ * Fallback function called via ctx->Driver.MapBuffer().
+ * Hardware drivers that really implement buffer objects should never use
+ * function.
*
- * This function is intended to be called by \c dd_function_table::MapBuffer.
- * This function need not set GL error codes. The input parameters will have
- * been tested before calling.
+ * The input parameters will have been already tested for errors.
*
* \param ctx GL context.
* \param target Buffer object target on which to operate.
* \param access Information about how the buffer will be accessed.
- * \param bufObj Object to be used.
+ * \param bufObj Object to be mapped.
* \return A pointer to the object's internal data store that can be accessed
* by the processor
*
*/
void *
_mesa_buffer_map( GLcontext *ctx, GLenum target, GLenum access,
- struct gl_buffer_object * bufObj )
+ struct gl_buffer_object *bufObj )
+{
+ (void) ctx;
+ (void) target;
+ (void) access;
+ ASSERT(!bufObj->OnCard);
+ /* Just return a direct pointer to the data */
+ if (bufObj->Pointer) {
+ /* already mapped! */
+ return NULL;
+ }
+ bufObj->Pointer = bufObj->Data;
+ return bufObj->Pointer;
+}
+
+
+/**
+ * Fallback function called via ctx->Driver.MapBuffer().
+ * Hardware drivers that really implement buffer objects should never use
+ * function.
+ *
+ * The input parameters will have been already tested for errors.
+ *
+ * \sa glUnmapBufferARB, dd_function_table::UnmapBuffer
+ */
+GLboolean
+_mesa_buffer_unmap( GLcontext *ctx, GLenum target,
+ struct gl_buffer_object *bufObj )
{
- return bufObj->Data;
+ (void) ctx;
+ (void) target;
+ ASSERT(!bufObj->OnCard);
+ /* XXX we might assert here that bufObj->Pointer is non-null */
+ bufObj->Pointer = NULL;
+ return GL_TRUE;
}
}
+/**
+ * When we're about to read pixel data out of a PBO (via glDrawPixels,
+ * glTexImage, etc) or write data into a PBO (via glReadPixels,
+ * glGetTexImage, etc) we call this function to check that we're not
+ * going to read out of bounds.
+ *
+ * XXX This would also be a convenient time to check that the PBO isn't
+ * currently mapped. Whoever calls this function should check for that.
+ * Remember, we can't use a PBO when it's mapped!
+ *
+ * \param width width of image to read/write
+ * \param height height of image to read/write
+ * \param depth depth of image to read/write
+ * \param format format of image to read/write
+ * \param type datatype of image to read/write
+ * \param ptr the user-provided pointer/offset
+ * \return GL_TRUE if the PBO access is OK, GL_FALSE if the access would
+ * go out of bounds.
+ */
+GLboolean
+_mesa_validate_pbo_access(GLuint dimensions,
+ const struct gl_pixelstore_attrib *pack,
+ GLsizei width, GLsizei height, GLsizei depth,
+ GLenum format, GLenum type, const GLvoid *ptr)
+{
+ GLvoid *start, *end;
+
+ ASSERT(pack->BufferObj->Name != 0);
+
+ if (pack->BufferObj->Size == 0)
+ /* no buffer! */
+ return GL_FALSE;
+
+ /* get address of first pixel we'll read */
+ start = _mesa_image_address(dimensions, pack, ptr, width, height,
+ format, type, 0, 0, 0);
+
+ /* get address just past the last pixel we'll read */
+ end = _mesa_image_address(dimensions, pack, ptr, width, height,
+ format, type, depth-1, height-1, width);
+
+
+ if ((const GLubyte *) start > (const GLubyte *) pack->BufferObj->Size) {
+ /* This will catch negative values / wrap-around */
+ return GL_FALSE;
+ }
+ if ((const GLubyte *) end > (const GLubyte *) pack->BufferObj->Size) {
+ /* Image read goes beyond end of buffer */
+ return GL_FALSE;
+ }
+
+ /* OK! */
+ return GL_TRUE;
+}
+
+
+
/**********************************************************************/
/* API Functions */
{
GET_CURRENT_CONTEXT(ctx);
struct gl_buffer_object *oldBufObj;
- struct gl_buffer_object *newBufObj = 0;
+ struct gl_buffer_object *newBufObj = NULL;
ASSERT_OUTSIDE_BEGIN_END(ctx);
oldBufObj = buffer_object_get_target( ctx, target, "BindBufferARB" );
- if ( (oldBufObj != NULL) && (oldBufObj->Name == buffer) )
+ if (oldBufObj && oldBufObj->Name == buffer)
return; /* rebinding the same buffer object- no change */
/*
* Get pointer to new buffer object (newBufObj)
*/
- if ( buffer == 0 ) {
+ if (buffer == 0) {
/* The spec says there's not a buffer object named 0, but we use
* one internally because it simplifies things.
*/
case GL_ELEMENT_ARRAY_BUFFER_ARB:
ctx->Array.ElementArrayBufferObj = newBufObj;
break;
+ case GL_PIXEL_PACK_BUFFER_EXT:
+ ctx->Pack.BufferObj = newBufObj;
+ break;
+ case GL_PIXEL_UNPACK_BUFFER_EXT:
+ ctx->Unpack.BufferObj = newBufObj;
+ break;
+ default:
+ _mesa_problem(ctx, "Bad target in _mesa_BindBufferARB");
+ return;
}
/* Pass BindBuffer call to device driver */
- if ( (ctx->Driver.BindBuffer != NULL) && (newBufObj != NULL) )
+ if (ctx->Driver.BindBuffer && newBufObj)
(*ctx->Driver.BindBuffer)( ctx, target, newBufObj );
- if ( oldBufObj != NULL ) {
+ if (oldBufObj) {
oldBufObj->RefCount--;
assert(oldBufObj->RefCount >= 0);
if (oldBufObj->RefCount == 0) {
assert(oldBufObj->Name != 0);
- _mesa_remove_buffer_object(ctx, oldBufObj);
ASSERT(ctx->Driver.DeleteBuffer);
- (*ctx->Driver.DeleteBuffer)( ctx, oldBufObj );
+ ctx->Driver.DeleteBuffer( ctx, oldBufObj );
}
}
}
* Delete a set of buffer objects.
*
* \param n Number of buffer objects to delete.
- * \param buffer Array of \c n buffer object IDs.
+ * \param ids Array of \c n buffer object IDs.
*/
void GLAPIENTRY
_mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids)
/* unbind any vertex pointers bound to this buffer */
GLuint j;
- ASSERT(bufObj->Name != 0);
+ ASSERT(bufObj->Name == ids[i]);
- if (ctx->Array.Vertex.BufferObj == bufObj)
+ if (ctx->Array.Vertex.BufferObj == bufObj) {
+ bufObj->RefCount--;
ctx->Array.Vertex.BufferObj = ctx->Array.NullBufferObj;
- if (ctx->Array.Normal.BufferObj == bufObj)
+ ctx->Array.NullBufferObj->RefCount++;
+ }
+ if (ctx->Array.Normal.BufferObj == bufObj) {
+ bufObj->RefCount--;
ctx->Array.Normal.BufferObj = ctx->Array.NullBufferObj;
- if (ctx->Array.Color.BufferObj == bufObj)
+ ctx->Array.NullBufferObj->RefCount++;
+ }
+ if (ctx->Array.Color.BufferObj == bufObj) {
+ bufObj->RefCount--;
ctx->Array.Color.BufferObj = ctx->Array.NullBufferObj;
- if (ctx->Array.SecondaryColor.BufferObj == bufObj)
+ ctx->Array.NullBufferObj->RefCount++;
+ }
+ if (ctx->Array.SecondaryColor.BufferObj == bufObj) {
+ bufObj->RefCount--;
ctx->Array.SecondaryColor.BufferObj = ctx->Array.NullBufferObj;
- if (ctx->Array.FogCoord.BufferObj == bufObj)
+ ctx->Array.NullBufferObj->RefCount++;
+ }
+ if (ctx->Array.FogCoord.BufferObj == bufObj) {
+ bufObj->RefCount--;
ctx->Array.FogCoord.BufferObj = ctx->Array.NullBufferObj;
- if (ctx->Array.Index.BufferObj == bufObj)
+ ctx->Array.NullBufferObj->RefCount++;
+ }
+ if (ctx->Array.Index.BufferObj == bufObj) {
+ bufObj->RefCount--;
ctx->Array.Index.BufferObj = ctx->Array.NullBufferObj;
- if (ctx->Array.EdgeFlag.BufferObj == bufObj)
+ ctx->Array.NullBufferObj->RefCount++;
+ }
+ if (ctx->Array.EdgeFlag.BufferObj == bufObj) {
+ bufObj->RefCount--;
ctx->Array.EdgeFlag.BufferObj = ctx->Array.NullBufferObj;
+ ctx->Array.NullBufferObj->RefCount++;
+ }
for (j = 0; j < MAX_TEXTURE_UNITS; j++) {
- if (ctx->Array.TexCoord[j].BufferObj == bufObj)
+ if (ctx->Array.TexCoord[j].BufferObj == bufObj) {
+ bufObj->RefCount--;
ctx->Array.TexCoord[j].BufferObj = ctx->Array.NullBufferObj;
+ ctx->Array.NullBufferObj->RefCount++;
+ }
}
for (j = 0; j < VERT_ATTRIB_MAX; j++) {
- if (ctx->Array.VertexAttrib[j].BufferObj == bufObj)
+ if (ctx->Array.VertexAttrib[j].BufferObj == bufObj) {
+ bufObj->RefCount--;
ctx->Array.VertexAttrib[j].BufferObj = ctx->Array.NullBufferObj;
+ ctx->Array.NullBufferObj->RefCount++;
+ }
}
- /* if deleting bound buffers, rebind to zero */
if (ctx->Array.ArrayBufferObj == bufObj) {
- _mesa_BindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
+ _mesa_BindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
}
if (ctx->Array.ElementArrayBufferObj == bufObj) {
- _mesa_BindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );
+ _mesa_BindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );
}
+ if (ctx->Pack.BufferObj == bufObj) {
+ _mesa_BindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 );
+ }
+ if (ctx->Unpack.BufferObj == bufObj) {
+ _mesa_BindBufferARB( GL_PIXEL_UNPACK_BUFFER_EXT, 0 );
+ }
+
+ /* The ID is immediately freed for re-use */
+ _mesa_remove_buffer_object(ctx, bufObj);
bufObj->RefCount--;
if (bufObj->RefCount <= 0) {
- _mesa_remove_buffer_object(ctx, bufObj);
+ ASSERT(ctx->Array.ArrayBufferObj != bufObj);
+ ASSERT(ctx->Array.ElementArrayBufferObj != bufObj);
+ ASSERT(ctx->Array.Vertex.BufferObj != bufObj);
ASSERT(ctx->Driver.DeleteBuffer);
- (*ctx->Driver.DeleteBuffer)(ctx, bufObj);
+ ctx->Driver.DeleteBuffer(ctx, bufObj);
}
}
}
return;
}
- if ( buffer == NULL ) {
+ if (!buffer) {
return;
}
GLenum target = 0;
bufObj = (*ctx->Driver.NewBufferObject)( ctx, name, target );
if (!bufObj) {
+ _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenBuffersARB");
return;
}
bufObj = (struct gl_buffer_object *) _mesa_HashLookup(ctx->Shared->BufferObjects, id);
_glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
- return (bufObj != NULL);
+ return bufObj ? GL_TRUE : GL_FALSE;
}
}
bufObj = buffer_object_get_target( ctx, target, "BufferDataARB" );
- if ( bufObj == NULL ) {
+ if (!bufObj || bufObj->Name ==0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB" );
return;
}
bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,
"BufferSubDataARB" );
if (!bufObj) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferSubDataARB" );
+ /* error already recorded */
return;
}
- if (bufObj->Pointer) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferSubDataARB(buffer is mapped)" );
- return;
- }
-
ASSERT(ctx->Driver.BufferSubData);
(*ctx->Driver.BufferSubData)( ctx, target, offset, size, data, bufObj );
}
bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,
"GetBufferSubDataARB" );
if (!bufObj) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferSubDataARB" );
+ /* error already recorded */
return;
}
- if (bufObj->Pointer) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferSubDataARB(buffer is mapped)" );
- return;
- }
-
ASSERT(ctx->Driver.GetBufferSubData);
(*ctx->Driver.GetBufferSubData)( ctx, target, offset, size, data, bufObj );
}
}
bufObj = buffer_object_get_target( ctx, target, "MapBufferARB" );
- if ( bufObj == NULL ) {
+ if (!bufObj || bufObj->Name == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB" );
return NULL;
}
- if ( bufObj->Pointer != NULL ) {
+ if (bufObj->Pointer) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(already mapped)");
return NULL;
}
ASSERT(ctx->Driver.MapBuffer);
bufObj->Pointer = (*ctx->Driver.MapBuffer)( ctx, target, access, bufObj );
- if ( bufObj->Pointer == NULL ) {
+ if (!bufObj->Pointer) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(access)");
}
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
bufObj = buffer_object_get_target( ctx, target, "UnmapBufferARB" );
- if ( bufObj == NULL ) {
+ if (!bufObj || bufObj->Name == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB" );
return GL_FALSE;
}
- if ( bufObj->Pointer == NULL ) {
+ if (!bufObj->Pointer) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB");
return GL_FALSE;
}
- if ( ctx->Driver.UnmapBuffer != NULL ) {
+ if (ctx->Driver.UnmapBuffer) {
status = (*ctx->Driver.UnmapBuffer)( ctx, target, bufObj );
}
ASSERT_OUTSIDE_BEGIN_END(ctx);
bufObj = buffer_object_get_target( ctx, target, "GetBufferParameterivARB" );
- if (!bufObj) {
+ if (!bufObj || bufObj->Name == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "GetBufferParameterivARB" );
return;
}
}
bufObj = buffer_object_get_target( ctx, target, "GetBufferPointervARB" );
- if ( bufObj == NULL ) {
+ if (!bufObj || bufObj->Name == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferPointervARB" );
return;
}
projects / mesa.git / blobdiff