/*
* Mesa 3-D graphics library
*
* Copyright (C) 2010 VMware, Inc. 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"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
/*
* Transform feedback support.
*
* Authors:
* Brian Paul
*/
#include "buffers.h"
#include "context.h"
#include "hash.h"
#include "macros.h"
#include "mtypes.h"
#include "transformfeedback.h"
#include "shaderapi.h"
#include "shaderobj.h"
#include "main/dispatch.h"
#include "program/prog_parameter.h"
struct using_program_tuple
{
struct gl_program *prog;
bool found;
};
static void
active_xfb_object_references_program(GLuint key, void *data, void *user_data)
{
struct using_program_tuple *callback_data = user_data;
struct gl_transform_feedback_object *obj = data;
if (obj->Active && obj->program == callback_data->prog)
callback_data->found = true;
}
/**
* Return true if any active transform feedback object is using a program.
*/
bool
_mesa_transform_feedback_is_using_program(struct gl_context *ctx,
struct gl_shader_program *shProg)
{
if (!shProg->last_vert_prog)
return false;
struct using_program_tuple callback_data;
callback_data.found = false;
callback_data.prog = shProg->last_vert_prog;
_mesa_HashWalkLocked(ctx->TransformFeedback.Objects,
active_xfb_object_references_program, &callback_data);
/* Also check DefaultObject, as it's not in the Objects hash table. */
active_xfb_object_references_program(0, ctx->TransformFeedback.DefaultObject,
&callback_data);
return callback_data.found;
}
/**
* Do reference counting of transform feedback buffers.
*/
static void
reference_transform_feedback_object(struct gl_transform_feedback_object **ptr,
struct gl_transform_feedback_object *obj)
{
if (*ptr == obj)
return;
if (*ptr) {
/* Unreference the old object */
struct gl_transform_feedback_object *oldObj = *ptr;
assert(oldObj->RefCount > 0);
oldObj->RefCount--;
if (oldObj->RefCount == 0) {
GET_CURRENT_CONTEXT(ctx);
if (ctx)
ctx->Driver.DeleteTransformFeedback(ctx, oldObj);
}
*ptr = NULL;
}
assert(!*ptr);
if (obj) {
assert(obj->RefCount > 0);
/* reference new object */
obj->RefCount++;
obj->EverBound = GL_TRUE;
*ptr = obj;
}
}
/**
* Per-context init for transform feedback.
*/
void
_mesa_init_transform_feedback(struct gl_context *ctx)
{
/* core mesa expects this, even a dummy one, to be available */
assert(ctx->Driver.NewTransformFeedback);
ctx->TransformFeedback.DefaultObject =
ctx->Driver.NewTransformFeedback(ctx, 0);
assert(ctx->TransformFeedback.DefaultObject->RefCount == 1);
reference_transform_feedback_object(&ctx->TransformFeedback.CurrentObject,
ctx->TransformFeedback.DefaultObject);
assert(ctx->TransformFeedback.DefaultObject->RefCount == 2);
ctx->TransformFeedback.Objects = _mesa_NewHashTable();
_mesa_reference_buffer_object(ctx,
&ctx->TransformFeedback.CurrentBuffer,
ctx->Shared->NullBufferObj);
}
/**
* Callback for _mesa_HashDeleteAll().
*/
static void
delete_cb(GLuint key, void *data, void *userData)
{
struct gl_context *ctx = (struct gl_context *) userData;
struct gl_transform_feedback_object *obj =
(struct gl_transform_feedback_object *) data;
ctx->Driver.DeleteTransformFeedback(ctx, obj);
}
/**
* Per-context free/clean-up for transform feedback.
*/
void
_mesa_free_transform_feedback(struct gl_context *ctx)
{
/* core mesa expects this, even a dummy one, to be available */
assert(ctx->Driver.NewTransformFeedback);
_mesa_reference_buffer_object(ctx,
&ctx->TransformFeedback.CurrentBuffer,
NULL);
/* Delete all feedback objects */
_mesa_HashDeleteAll(ctx->TransformFeedback.Objects, delete_cb, ctx);
_mesa_DeleteHashTable(ctx->TransformFeedback.Objects);
/* Delete the default feedback object */
assert(ctx->Driver.DeleteTransformFeedback);
ctx->Driver.DeleteTransformFeedback(ctx,
ctx->TransformFeedback.DefaultObject);
ctx->TransformFeedback.CurrentObject = NULL;
}
/** Initialize the fields of a gl_transform_feedback_object. */
void
_mesa_init_transform_feedback_object(struct gl_transform_feedback_object *obj,
GLuint name)
{
obj->Name = name;
obj->RefCount = 1;
obj->EverBound = GL_FALSE;
}
/** Default fallback for ctx->Driver.NewTransformFeedback() */
static struct gl_transform_feedback_object *
new_transform_feedback_fallback(struct gl_context *ctx, GLuint name)
{
struct gl_transform_feedback_object *obj;
obj = CALLOC_STRUCT(gl_transform_feedback_object);
if (!obj)
return NULL;
_mesa_init_transform_feedback_object(obj, name);
return obj;
}
/** Default fallback for ctx->Driver.DeleteTransformFeedback() */
static void
delete_transform_feedback_fallback(struct gl_context *ctx,
struct gl_transform_feedback_object *obj)
{
GLuint i;
for (i = 0; i < ARRAY_SIZE(obj->Buffers); i++) {
_mesa_reference_buffer_object(ctx, &obj->Buffers[i], NULL);
}
free(obj->Label);
free(obj);
}
/** Default fallback for ctx->Driver.BeginTransformFeedback() */
static void
begin_transform_feedback_fallback(struct gl_context *ctx, GLenum mode,
struct gl_transform_feedback_object *obj)
{
/* nop */
}
/** Default fallback for ctx->Driver.EndTransformFeedback() */
static void
end_transform_feedback_fallback(struct gl_context *ctx,
struct gl_transform_feedback_object *obj)
{
/* nop */
}
/** Default fallback for ctx->Driver.PauseTransformFeedback() */
static void
pause_transform_feedback_fallback(struct gl_context *ctx,
struct gl_transform_feedback_object *obj)
{
/* nop */
}
/** Default fallback for ctx->Driver.ResumeTransformFeedback() */
static void
resume_transform_feedback_fallback(struct gl_context *ctx,
struct gl_transform_feedback_object *obj)
{
/* nop */
}
/**
* Plug in default device driver functions for transform feedback.
* Most drivers will override some/all of these.
*/
void
_mesa_init_transform_feedback_functions(struct dd_function_table *driver)
{
driver->NewTransformFeedback = new_transform_feedback_fallback;
driver->DeleteTransformFeedback = delete_transform_feedback_fallback;
driver->BeginTransformFeedback = begin_transform_feedback_fallback;
driver->EndTransformFeedback = end_transform_feedback_fallback;
driver->PauseTransformFeedback = pause_transform_feedback_fallback;
driver->ResumeTransformFeedback = resume_transform_feedback_fallback;
}
/**
* Fill in the correct Size value for each buffer in \c obj.
*
* From the GL 4.3 spec, section 6.1.1 ("Binding Buffer Objects to Indexed
* Targets"):
*
* BindBufferBase binds the entire buffer, even when the size of the buffer
* is changed after the binding is established. It is equivalent to calling
* BindBufferRange with offset zero, while size is determined by the size of
* the bound buffer at the time the binding is used.
*
* Regardless of the size specified with BindBufferRange, or indirectly with
* BindBufferBase, the GL will never read or write beyond the end of a bound
* buffer. In some cases this constraint may result in visibly different
* behavior when a buffer overflow would otherwise result, such as described
* for transform feedback operations in section 13.2.2.
*/
static void
compute_transform_feedback_buffer_sizes(
struct gl_transform_feedback_object *obj)
{
unsigned i = 0;
for (i = 0; i < MAX_FEEDBACK_BUFFERS; ++i) {
GLintptr offset = obj->Offset[i];
GLsizeiptr buffer_size
= obj->Buffers[i] == NULL ? 0 : obj->Buffers[i]->Size;
GLsizeiptr available_space
= buffer_size <= offset ? 0 : buffer_size - offset;
GLsizeiptr computed_size;
if (obj->RequestedSize[i] == 0) {
/* No size was specified at the time the buffer was bound, so allow
* writing to all available space in the buffer.
*/
computed_size = available_space;
} else {
/* A size was specified at the time the buffer was bound, however
* it's possible that the buffer has shrunk since then. So only
* allow writing to the minimum of the specified size and the space
* available.
*/
computed_size = MIN2(available_space, obj->RequestedSize[i]);
}
/* Legal sizes must be multiples of four, so round down if necessary. */
obj->Size[i] = computed_size & ~0x3;
}
}
/**
* Compute the maximum number of vertices that can be written to the currently
* enabled transform feedback buffers without overflowing any of them.
*/
unsigned
_mesa_compute_max_transform_feedback_vertices(struct gl_context *ctx,
const struct gl_transform_feedback_object *obj,
const struct gl_transform_feedback_info *info)
{
unsigned max_index = 0xffffffff;
unsigned i;
for (i = 0; i < ctx->Const.MaxTransformFeedbackBuffers; i++) {
if ((info->ActiveBuffers >> i) & 1) {
unsigned stride = info->Buffers[i].Stride;
unsigned max_for_this_buffer;
/* Skip any inactive buffers, which have a stride of 0. */
if (stride == 0)
continue;
max_for_this_buffer = obj->Size[i] / (4 * stride);
max_index = MIN2(max_index, max_for_this_buffer);
}
}
return max_index;
}
/**
** Begin API functions
**/
/**
* Figure out which stage of the pipeline is the source of transform feedback
* data given the current context state, and return its gl_program.
*
* If no active program can generate transform feedback data (i.e. no vertex
* shader is active), returns NULL.
*/
static struct gl_program *
get_xfb_source(struct gl_context *ctx)
{
int i;
for (i = MESA_SHADER_GEOMETRY; i >= MESA_SHADER_VERTEX; i--) {
if (ctx->_Shader->CurrentProgram[i] != NULL)
return ctx->_Shader->CurrentProgram[i];
}
return NULL;
}
static ALWAYS_INLINE void
begin_transform_feedback(struct gl_context *ctx, GLenum mode, bool no_error)
{
struct gl_transform_feedback_object *obj;
struct gl_transform_feedback_info *info = NULL;
struct gl_program *source;
GLuint i;
unsigned vertices_per_prim;
obj = ctx->TransformFeedback.CurrentObject;
/* Figure out what pipeline stage is the source of data for transform
* feedback.
*/
source = get_xfb_source(ctx);
if (!no_error && source == NULL) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBeginTransformFeedback(no program active)");
return;
}
info = source->sh.LinkedTransformFeedback;
if (!no_error && info->NumOutputs == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBeginTransformFeedback(no varyings to record)");
return;
}
switch (mode) {
case GL_POINTS:
vertices_per_prim = 1;
break;
case GL_LINES:
vertices_per_prim = 2;
break;
case GL_TRIANGLES:
vertices_per_prim = 3;
break;
default:
if (!no_error) {
_mesa_error(ctx, GL_INVALID_ENUM, "glBeginTransformFeedback(mode)");
return;
} else {
/* Stop compiler warnings */
unreachable("Error in API use when using KHR_no_error");
}
}
if (!no_error) {
if (obj->Active) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBeginTransformFeedback(already active)");
return;
}
for (i = 0; i < ctx->Const.MaxTransformFeedbackBuffers; i++) {
if ((info->ActiveBuffers >> i) & 1) {
if (obj->BufferNames[i] == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBeginTransformFeedback(binding point %d does not "
"have a buffer object bound)", i);
return;
}
}
}
}
FLUSH_VERTICES(ctx, 0);
ctx->NewDriverState |= ctx->DriverFlags.NewTransformFeedback;
obj->Active = GL_TRUE;
ctx->TransformFeedback.Mode = mode;
compute_transform_feedback_buffer_sizes(obj);
if (_mesa_is_gles3(ctx)) {
/* In GLES3, we are required to track the usage of the transform
* feedback buffer and report INVALID_OPERATION if a draw call tries to
* exceed it. So compute the maximum number of vertices that we can
* write without overflowing any of the buffers currently being used for
* feedback.
*/
unsigned max_vertices
= _mesa_compute_max_transform_feedback_vertices(ctx, obj, info);
obj->GlesRemainingPrims = max_vertices / vertices_per_prim;
}
if (obj->program != source) {
ctx->NewDriverState |= ctx->DriverFlags.NewTransformFeedbackProg;
obj->program = source;
}
assert(ctx->Driver.BeginTransformFeedback);
ctx->Driver.BeginTransformFeedback(ctx, mode, obj);
}
void GLAPIENTRY
_mesa_BeginTransformFeedback_no_error(GLenum mode)
{
GET_CURRENT_CONTEXT(ctx);
begin_transform_feedback(ctx, mode, true);
}
void GLAPIENTRY
_mesa_BeginTransformFeedback(GLenum mode)
{
GET_CURRENT_CONTEXT(ctx);
begin_transform_feedback(ctx, mode, false);
}
static void
end_transform_feedback(struct gl_context *ctx,
struct gl_transform_feedback_object *obj)
{
FLUSH_VERTICES(ctx, 0);
ctx->NewDriverState |= ctx->DriverFlags.NewTransformFeedback;
assert(ctx->Driver.EndTransformFeedback);
ctx->Driver.EndTransformFeedback(ctx, obj);
ctx->TransformFeedback.CurrentObject->Active = GL_FALSE;
ctx->TransformFeedback.CurrentObject->Paused = GL_FALSE;
ctx->TransformFeedback.CurrentObject->EndedAnytime = GL_TRUE;
}
void GLAPIENTRY
_mesa_EndTransformFeedback_no_error(void)
{
GET_CURRENT_CONTEXT(ctx);
end_transform_feedback(ctx, ctx->TransformFeedback.CurrentObject);
}
void GLAPIENTRY
_mesa_EndTransformFeedback(void)
{
struct gl_transform_feedback_object *obj;
GET_CURRENT_CONTEXT(ctx);
obj = ctx->TransformFeedback.CurrentObject;
if (!obj->Active) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glEndTransformFeedback(not active)");
return;
}
end_transform_feedback(ctx, obj);
}
/**
* Helper used by BindBufferRange() and BindBufferBase().
*/
static void
bind_buffer_range(struct gl_context *ctx,
struct gl_transform_feedback_object *obj,
GLuint index,
struct gl_buffer_object *bufObj,
GLintptr offset, GLsizeiptr size,
bool dsa)
{
/* Note: no need to FLUSH_VERTICES or flag NewTransformFeedback, because
* transform feedback buffers can't be changed while transform feedback is
* active.
*/
if (!dsa) {
/* The general binding point */
_mesa_reference_buffer_object(ctx,
&ctx->TransformFeedback.CurrentBuffer,
bufObj);
}
/* The per-attribute binding point */
_mesa_set_transform_feedback_binding(ctx, obj, index, bufObj, offset, size);
}
/**
* Validate the buffer object to receive transform feedback results. Plus,
* validate the starting offset to place the results, and max size.
* Called from the glBindBufferRange() and glTransformFeedbackBufferRange
* functions.
*/
bool
_mesa_validate_buffer_range_xfb(struct gl_context *ctx,
struct gl_transform_feedback_object *obj,
GLuint index, struct gl_buffer_object *bufObj,
GLintptr offset, GLsizeiptr size, bool dsa)
{
const char *gl_methd_name;
if (dsa)
gl_methd_name = "glTransformFeedbackBufferRange";
else
gl_methd_name = "glBindBufferRange";
if (obj->Active) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(transform feedback active)",
gl_methd_name);
return false;
}
if (index >= ctx->Const.MaxTransformFeedbackBuffers) {
/* OpenGL 4.5 core profile, 6.1, pdf page 82: "An INVALID_VALUE error is
* generated if index is greater than or equal to the number of binding
* points for transform feedback, as described in section 6.7.1."
*/
_mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%d out of bounds)",
gl_methd_name, index);
return false;
}
if (size & 0x3) {
/* OpenGL 4.5 core profile, 6.7, pdf page 103: multiple of 4 */
_mesa_error(ctx, GL_INVALID_VALUE, "%s(size=%d must be a multiple of "
"four)", gl_methd_name, (int) size);
return false;
}
if (offset & 0x3) {
/* OpenGL 4.5 core profile, 6.7, pdf page 103: multiple of 4 */
_mesa_error(ctx, GL_INVALID_VALUE, "%s(offset=%d must be a multiple "
"of four)", gl_methd_name, (int) offset);
return false;
}
if (offset < 0) {
/* OpenGL 4.5 core profile, 6.1, pdf page 82: "An INVALID_VALUE error is
* generated by BindBufferRange if offset is negative."
*
* OpenGL 4.5 core profile, 13.2, pdf page 445: "An INVALID_VALUE error
* is generated by TransformFeedbackBufferRange if offset is negative."
*/
_mesa_error(ctx, GL_INVALID_VALUE, "%s(offset=%d must be >= 0)",
gl_methd_name,
(int) offset);
return false;
}
if (size <= 0 && (dsa || bufObj != ctx->Shared->NullBufferObj)) {
/* OpenGL 4.5 core profile, 6.1, pdf page 82: "An INVALID_VALUE error is
* generated by BindBufferRange if buffer is non-zero and size is less
* than or equal to zero."
*
* OpenGL 4.5 core profile, 13.2, pdf page 445: "An INVALID_VALUE error
* is generated by TransformFeedbackBufferRange if size is less than or
* equal to zero."
*/
_mesa_error(ctx, GL_INVALID_VALUE, "%s(size=%d must be > 0)",
gl_methd_name, (int) size);
return false;
}
return true;
}
/**
* Specify a buffer object to receive transform feedback results.
* As above, but start at offset = 0.
* Called from the glBindBufferBase() and glTransformFeedbackBufferBase()
* functions.
*/
void
_mesa_bind_buffer_base_transform_feedback(struct gl_context *ctx,
struct gl_transform_feedback_object *obj,
GLuint index,
struct gl_buffer_object *bufObj,
bool dsa)
{
if (obj->Active) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(transform feedback active)",
dsa ? "glTransformFeedbackBufferBase" : "glBindBufferBase");
return;
}
if (index >= ctx->Const.MaxTransformFeedbackBuffers) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%d out of bounds)",
dsa ? "glTransformFeedbackBufferBase" : "glBindBufferBase",
index);
return;
}
bind_buffer_range(ctx, obj, index, bufObj, 0, 0, dsa);
}
/**
* Wrapper around lookup_transform_feedback_object that throws
* GL_INVALID_OPERATION if id is not in the hash table. After calling
* _mesa_error, it returns NULL.
*/
static struct gl_transform_feedback_object *
lookup_transform_feedback_object_err(struct gl_context *ctx,
GLuint xfb, const char* func)
{
struct gl_transform_feedback_object *obj;
obj = _mesa_lookup_transform_feedback_object(ctx, xfb);
if (!obj) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"%s(xfb=%u: non-generated object name)", func, xfb);
}
return obj;
}
/**
* Wrapper around _mesa_lookup_bufferobj that throws GL_INVALID_VALUE if id
* is not in the hash table. Specialised version for the
* transform-feedback-related functions. After calling _mesa_error, it
* returns NULL.
*/
static struct gl_buffer_object *
lookup_transform_feedback_bufferobj_err(struct gl_context *ctx,
GLuint buffer, const char* func)
{
struct gl_buffer_object *bufObj;
/* OpenGL 4.5 core profile, 13.2, pdf page 444: buffer must be zero or the
* name of an existing buffer object.
*/
if (buffer == 0) {
bufObj = ctx->Shared->NullBufferObj;
} else {
bufObj = _mesa_lookup_bufferobj(ctx, buffer);
if (!bufObj) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(invalid buffer=%u)", func,
buffer);
}
}
return bufObj;
}
void GLAPIENTRY
_mesa_TransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_transform_feedback_object *obj;
struct gl_buffer_object *bufObj;
obj = lookup_transform_feedback_object_err(ctx, xfb,
"glTransformFeedbackBufferBase");
if (!obj) {
return;
}
bufObj = lookup_transform_feedback_bufferobj_err(ctx, buffer,
"glTransformFeedbackBufferBase");
if (!bufObj) {
return;
}
_mesa_bind_buffer_base_transform_feedback(ctx, obj, index, bufObj, true);
}
void GLAPIENTRY
_mesa_TransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer,
GLintptr offset, GLsizeiptr size)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_transform_feedback_object *obj;
struct gl_buffer_object *bufObj;
obj = lookup_transform_feedback_object_err(ctx, xfb,
"glTransformFeedbackBufferRange");
if (!obj) {
return;
}
bufObj = lookup_transform_feedback_bufferobj_err(ctx, buffer,
"glTransformFeedbackBufferRange");
if (!bufObj) {
return;
}
if (!_mesa_validate_buffer_range_xfb(ctx, obj, index, bufObj, offset,
size, true))
return;
/* The per-attribute binding point */
_mesa_set_transform_feedback_binding(ctx, obj, index, bufObj, offset,
size);
}
/**
* Specify a buffer object to receive transform feedback results, plus the
* offset in the buffer to start placing results.
* This function is part of GL_EXT_transform_feedback, but not GL3.
*/
static ALWAYS_INLINE void
bind_buffer_offset(struct gl_context *ctx,
struct gl_transform_feedback_object *obj, GLuint index,
GLuint buffer, GLintptr offset, bool no_error)
{
struct gl_buffer_object *bufObj;
if (buffer == 0) {
bufObj = ctx->Shared->NullBufferObj;
} else {
bufObj = _mesa_lookup_bufferobj(ctx, buffer);
if (!no_error && !bufObj) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBindBufferOffsetEXT(invalid buffer=%u)", buffer);
return;
}
}
_mesa_bind_buffer_range_xfb(ctx, obj, index, bufObj, offset, 0);
}
void GLAPIENTRY
_mesa_BindBufferOffsetEXT_no_error(GLenum target, GLuint index, GLuint buffer,
GLintptr offset)
{
GET_CURRENT_CONTEXT(ctx);
bind_buffer_offset(ctx, ctx->TransformFeedback.CurrentObject, index, buffer,
offset, true);
}
void GLAPIENTRY
_mesa_BindBufferOffsetEXT(GLenum target, GLuint index, GLuint buffer,
GLintptr offset)
{
struct gl_transform_feedback_object *obj;
GET_CURRENT_CONTEXT(ctx);
if (target != GL_TRANSFORM_FEEDBACK_BUFFER) {
_mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferOffsetEXT(target)");
return;
}
obj = ctx->TransformFeedback.CurrentObject;
if (obj->Active) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBindBufferOffsetEXT(transform feedback active)");
return;
}
if (index >= ctx->Const.MaxTransformFeedbackBuffers) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glBindBufferOffsetEXT(index=%d)", index);
return;
}
if (offset & 0x3) {
/* must be multiple of four */
_mesa_error(ctx, GL_INVALID_VALUE,
"glBindBufferOffsetEXT(offset=%d)", (int) offset);
return;
}
bind_buffer_offset(ctx, obj, index, buffer, offset, false);
}
/**
* This function specifies the transform feedback outputs to be written
* to the feedback buffer(s), and in what order.
*/
static ALWAYS_INLINE void
transform_feedback_varyings(struct gl_context *ctx,
struct gl_shader_program *shProg, GLsizei count,
const GLchar *const *varyings, GLenum bufferMode)
{
GLint i;
/* free existing varyings, if any */
for (i = 0; i < (GLint) shProg->TransformFeedback.NumVarying; i++) {
free(shProg->TransformFeedback.VaryingNames[i]);
}
free(shProg->TransformFeedback.VaryingNames);
/* allocate new memory for varying names */
shProg->TransformFeedback.VaryingNames =
malloc(count * sizeof(GLchar *));
if (!shProg->TransformFeedback.VaryingNames) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glTransformFeedbackVaryings()");
return;
}
/* Save the new names and the count */
for (i = 0; i < count; i++) {
shProg->TransformFeedback.VaryingNames[i] = strdup(varyings[i]);
}
shProg->TransformFeedback.NumVarying = count;
shProg->TransformFeedback.BufferMode = bufferMode;
/* No need to invoke FLUSH_VERTICES or flag NewTransformFeedback since
* the varyings won't be used until shader link time.
*/
}
void GLAPIENTRY
_mesa_TransformFeedbackVaryings_no_error(GLuint program, GLsizei count,
const GLchar *const *varyings,
GLenum bufferMode)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, program);
transform_feedback_varyings(ctx, shProg, count, varyings, bufferMode);
}
void GLAPIENTRY
_mesa_TransformFeedbackVaryings(GLuint program, GLsizei count,
const GLchar * const *varyings,
GLenum bufferMode)
{
struct gl_shader_program *shProg;
GLint i;
GET_CURRENT_CONTEXT(ctx);
/* From the ARB_transform_feedback2 specification:
* "The error INVALID_OPERATION is generated by TransformFeedbackVaryings
* if the current transform feedback object is active, even if paused."
*/
if (ctx->TransformFeedback.CurrentObject->Active) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glTransformFeedbackVaryings(current object is active)");
return;
}
switch (bufferMode) {
case GL_INTERLEAVED_ATTRIBS:
break;
case GL_SEPARATE_ATTRIBS:
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM,
"glTransformFeedbackVaryings(bufferMode)");
return;
}
if (count < 0 ||
(bufferMode == GL_SEPARATE_ATTRIBS &&
(GLuint) count > ctx->Const.MaxTransformFeedbackBuffers)) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glTransformFeedbackVaryings(count=%d)", count);
return;
}
shProg = _mesa_lookup_shader_program_err(ctx, program,
"glTransformFeedbackVaryings");
if (!shProg)
return;
if (ctx->Extensions.ARB_transform_feedback3) {
if (bufferMode == GL_INTERLEAVED_ATTRIBS) {
unsigned buffers = 1;
for (i = 0; i < count; i++) {
if (strcmp(varyings[i], "gl_NextBuffer") == 0)
buffers++;
}
if (buffers > ctx->Const.MaxTransformFeedbackBuffers) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glTransformFeedbackVaryings(too many gl_NextBuffer "
"occurrences)");
return;
}
} else {
for (i = 0; i < count; i++) {
if (strcmp(varyings[i], "gl_NextBuffer") == 0 ||
strcmp(varyings[i], "gl_SkipComponents1") == 0 ||
strcmp(varyings[i], "gl_SkipComponents2") == 0 ||
strcmp(varyings[i], "gl_SkipComponents3") == 0 ||
strcmp(varyings[i], "gl_SkipComponents4") == 0) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glTransformFeedbackVaryings(SEPARATE_ATTRIBS,"
"varying=%s)",
varyings[i]);
return;
}
}
}
}
transform_feedback_varyings(ctx, shProg, count, varyings, bufferMode);
}
/**
* Get info about the transform feedback outputs which are to be written
* to the feedback buffer(s).
*/
void GLAPIENTRY
_mesa_GetTransformFeedbackVarying(GLuint program, GLuint index,
GLsizei bufSize, GLsizei *length,
GLsizei *size, GLenum *type, GLchar *name)
{
const struct gl_shader_program *shProg;
struct gl_program_resource *res;
GET_CURRENT_CONTEXT(ctx);
shProg = _mesa_lookup_shader_program_err(ctx, program,
"glGetTransformFeedbackVarying");
if (!shProg)
return;
res = _mesa_program_resource_find_index((struct gl_shader_program *) shProg,
GL_TRANSFORM_FEEDBACK_VARYING,
index);
if (!res) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glGetTransformFeedbackVarying(index=%u)", index);
return;
}
/* return the varying's name and length */
_mesa_copy_string(name, bufSize, length, _mesa_program_resource_name(res));
/* return the datatype and value's size (in datatype units) */
if (type)
_mesa_program_resource_prop((struct gl_shader_program *) shProg,
res, index, GL_TYPE, (GLint*) type,
"glGetTransformFeedbackVarying");
if (size)
_mesa_program_resource_prop((struct gl_shader_program *) shProg,
res, index, GL_ARRAY_SIZE, (GLint*) size,
"glGetTransformFeedbackVarying");
}
struct gl_transform_feedback_object *
_mesa_lookup_transform_feedback_object(struct gl_context *ctx, GLuint name)
{
/* OpenGL 4.5 core profile, 13.2 pdf page 444: "xfb must be zero, indicating
* the default transform feedback object, or the name of an existing
* transform feedback object."
*/
if (name == 0) {
return ctx->TransformFeedback.DefaultObject;
}
else
return (struct gl_transform_feedback_object *)
_mesa_HashLookupLocked(ctx->TransformFeedback.Objects, name);
}
static void
create_transform_feedbacks(struct gl_context *ctx, GLsizei n, GLuint *ids,
bool dsa)
{
GLuint first;
const char* func;
if (dsa)
func = "glCreateTransformFeedbacks";
else
func = "glGenTransformFeedbacks";
if (n < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(n < 0)", func);
return;
}
if (!ids)
return;
/* we don't need contiguous IDs, but this might be faster */
first = _mesa_HashFindFreeKeyBlock(ctx->TransformFeedback.Objects, n);
if (first) {
GLsizei i;
for (i = 0; i < n; i++) {
struct gl_transform_feedback_object *obj
= ctx->Driver.NewTransformFeedback(ctx, first + i);
if (!obj) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", func);
return;
}
ids[i] = first + i;
_mesa_HashInsertLocked(ctx->TransformFeedback.Objects, first + i,
obj);
if (dsa) {
/* this is normally done at bind time in the non-dsa case */
obj->EverBound = GL_TRUE;
}
}
}
else {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", func);
}
}
/**
* Create new transform feedback objects. Transform feedback objects
* encapsulate the state related to transform feedback to allow quickly
* switching state (and drawing the results, below).
* Part of GL_ARB_transform_feedback2.
*/
void GLAPIENTRY
_mesa_GenTransformFeedbacks(GLsizei n, GLuint *names)
{
GET_CURRENT_CONTEXT(ctx);
/* GenTransformFeedbacks should just reserve the object names that a
* subsequent call to BindTransformFeedback should actively create. For
* the sake of simplicity, we reserve the names and create the objects
* straight away.
*/
create_transform_feedbacks(ctx, n, names, false);
}
/**
* Create new transform feedback objects. Transform feedback objects
* encapsulate the state related to transform feedback to allow quickly
* switching state (and drawing the results, below).
* Part of GL_ARB_direct_state_access.
*/
void GLAPIENTRY
_mesa_CreateTransformFeedbacks(GLsizei n, GLuint *names)
{
GET_CURRENT_CONTEXT(ctx);
create_transform_feedbacks(ctx, n, names, true);
}
/**
* Is the given ID a transform feedback object?
* Part of GL_ARB_transform_feedback2.
*/
GLboolean GLAPIENTRY
_mesa_IsTransformFeedback(GLuint name)
{
struct gl_transform_feedback_object *obj;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
if (name == 0)
return GL_FALSE;
obj = _mesa_lookup_transform_feedback_object(ctx, name);
if (obj == NULL)
return GL_FALSE;
return obj->EverBound;
}
/**
* Bind the given transform feedback object.
* Part of GL_ARB_transform_feedback2.
*/
static ALWAYS_INLINE void
bind_transform_feedback(struct gl_context *ctx, GLuint name, bool no_error)
{
struct gl_transform_feedback_object *obj;
obj = _mesa_lookup_transform_feedback_object(ctx, name);
if (!no_error && !obj) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBindTransformFeedback(name=%u)", name);
return;
}
reference_transform_feedback_object(&ctx->TransformFeedback.CurrentObject,
obj);
}
void GLAPIENTRY
_mesa_BindTransformFeedback_no_error(GLenum target, GLuint name)
{
GET_CURRENT_CONTEXT(ctx);
bind_transform_feedback(ctx, name, true);
}
void GLAPIENTRY
_mesa_BindTransformFeedback(GLenum target, GLuint name)
{
GET_CURRENT_CONTEXT(ctx);
if (target != GL_TRANSFORM_FEEDBACK) {
_mesa_error(ctx, GL_INVALID_ENUM, "glBindTransformFeedback(target)");
return;
}
if (_mesa_is_xfb_active_and_unpaused(ctx)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBindTransformFeedback(transform is active, or not paused)");
return;
}
bind_transform_feedback(ctx, name, false);
}
/**
* Delete the given transform feedback objects.
* Part of GL_ARB_transform_feedback2.
*/
void GLAPIENTRY
_mesa_DeleteTransformFeedbacks(GLsizei n, const GLuint *names)
{
GLint i;
GET_CURRENT_CONTEXT(ctx);
if (n < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glDeleteTransformFeedbacks(n < 0)");
return;
}
if (!names)
return;
for (i = 0; i < n; i++) {
if (names[i] > 0) {
struct gl_transform_feedback_object *obj
= _mesa_lookup_transform_feedback_object(ctx, names[i]);
if (obj) {
if (obj->Active) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glDeleteTransformFeedbacks(object %u is active)",
names[i]);
return;
}
_mesa_HashRemoveLocked(ctx->TransformFeedback.Objects, names[i]);
/* unref, but object may not be deleted until later */
if (obj == ctx->TransformFeedback.CurrentObject) {
reference_transform_feedback_object(
&ctx->TransformFeedback.CurrentObject,
ctx->TransformFeedback.DefaultObject);
}
reference_transform_feedback_object(&obj, NULL);
}
}
}
}
/**
* Pause transform feedback.
* Part of GL_ARB_transform_feedback2.
*/
static void
pause_transform_feedback(struct gl_context *ctx,
struct gl_transform_feedback_object *obj)
{
FLUSH_VERTICES(ctx, 0);
ctx->NewDriverState |= ctx->DriverFlags.NewTransformFeedback;
assert(ctx->Driver.PauseTransformFeedback);
ctx->Driver.PauseTransformFeedback(ctx, obj);
obj->Paused = GL_TRUE;
}
void GLAPIENTRY
_mesa_PauseTransformFeedback_no_error(void)
{
GET_CURRENT_CONTEXT(ctx);
pause_transform_feedback(ctx, ctx->TransformFeedback.CurrentObject);
}
void GLAPIENTRY
_mesa_PauseTransformFeedback(void)
{
struct gl_transform_feedback_object *obj;
GET_CURRENT_CONTEXT(ctx);
obj = ctx->TransformFeedback.CurrentObject;
if (!_mesa_is_xfb_active_and_unpaused(ctx)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glPauseTransformFeedback(feedback not active or already paused)");
return;
}
pause_transform_feedback(ctx, obj);
}
/**
* Resume transform feedback.
* Part of GL_ARB_transform_feedback2.
*/
static void
resume_transform_feedback(struct gl_context *ctx,
struct gl_transform_feedback_object *obj)
{
FLUSH_VERTICES(ctx, 0);
ctx->NewDriverState |= ctx->DriverFlags.NewTransformFeedback;
obj->Paused = GL_FALSE;
assert(ctx->Driver.ResumeTransformFeedback);
ctx->Driver.ResumeTransformFeedback(ctx, obj);
}
void GLAPIENTRY
_mesa_ResumeTransformFeedback_no_error(void)
{
GET_CURRENT_CONTEXT(ctx);
resume_transform_feedback(ctx, ctx->TransformFeedback.CurrentObject);
}
void GLAPIENTRY
_mesa_ResumeTransformFeedback(void)
{
struct gl_transform_feedback_object *obj;
GET_CURRENT_CONTEXT(ctx);
obj = ctx->TransformFeedback.CurrentObject;
if (!obj->Active || !obj->Paused) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glResumeTransformFeedback(feedback not active or not paused)");
return;
}
/* From the ARB_transform_feedback2 specification:
* "The error INVALID_OPERATION is generated by ResumeTransformFeedback if
* the program object being used by the current transform feedback object
* is not active."
*/
if (obj->program != get_xfb_source(ctx)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glResumeTransformFeedback(wrong program bound)");
return;
}
resume_transform_feedback(ctx, obj);
}
extern void GLAPIENTRY
_mesa_GetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param)
{
struct gl_transform_feedback_object *obj;
GET_CURRENT_CONTEXT(ctx);
obj = lookup_transform_feedback_object_err(ctx, xfb,
"glGetTransformFeedbackiv");
if (!obj) {
return;
}
switch(pname) {
case GL_TRANSFORM_FEEDBACK_PAUSED:
*param = obj->Paused;
break;
case GL_TRANSFORM_FEEDBACK_ACTIVE:
*param = obj->Active;
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM,
"glGetTransformFeedbackiv(pname=%i)", pname);
}
}
extern void GLAPIENTRY
_mesa_GetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index,
GLint *param)
{
struct gl_transform_feedback_object *obj;
GET_CURRENT_CONTEXT(ctx);
obj = lookup_transform_feedback_object_err(ctx, xfb,
"glGetTransformFeedbacki_v");
if (!obj) {
return;
}
if (index >= ctx->Const.MaxTransformFeedbackBuffers) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glGetTransformFeedbacki_v(index=%i)", index);
return;
}
switch(pname) {
case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
*param = obj->BufferNames[index];
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM,
"glGetTransformFeedbacki_v(pname=%i)", pname);
}
}
extern void GLAPIENTRY
_mesa_GetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index,
GLint64 *param)
{
struct gl_transform_feedback_object *obj;
GET_CURRENT_CONTEXT(ctx);
obj = lookup_transform_feedback_object_err(ctx, xfb,
"glGetTransformFeedbacki64_v");
if (!obj) {
return;
}
if (index >= ctx->Const.MaxTransformFeedbackBuffers) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glGetTransformFeedbacki64_v(index=%i)", index);
return;
}
/**
* This follows the same general rules used for BindBufferBase:
*
* "To query the starting offset or size of the range of a buffer
* object binding in an indexed array, call GetInteger64i_v with
* target set to respectively the starting offset or binding size
* name from table 6.5 for that array. Index must be in the range
* zero to the number of bind points supported minus one. If the
* starting offset or size was not specified when the buffer object
* was bound (e.g. if it was bound with BindBufferBase), or if no
* buffer object is bound to the target array at index, zero is
* returned."
*/
if (obj->RequestedSize[index] == 0 &&
(pname == GL_TRANSFORM_FEEDBACK_BUFFER_START ||
pname == GL_TRANSFORM_FEEDBACK_BUFFER_SIZE)) {
*param = 0;
return;
}
compute_transform_feedback_buffer_sizes(obj);
switch(pname) {
case GL_TRANSFORM_FEEDBACK_BUFFER_START:
assert(obj->RequestedSize[index] > 0);
*param = obj->Offset[index];
break;
case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
assert(obj->RequestedSize[index] > 0);
*param = obj->Size[index];
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM,
"glGetTransformFeedbacki64_v(pname=%i)", pname);
}
}