extern "C" void GLAPIENTRY
_mesa_GetActiveUniformsiv(GLuint program,
GLsizei uniformCount,
const GLuint *uniformIndices,
GLenum pname,
GLint *params)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_shader_program *shProg;
struct gl_program_resource *res;
GLenum res_prop;
if (uniformCount < 0) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glGetActiveUniformsiv(uniformCount < 0)");
return;
}
shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");
if (!shProg)
return;
res_prop = resource_prop_from_uniform_prop(pname);
/* We need to first verify that each entry exists as active uniform. If
* not, generate error and do not cause any other side effects.
*
* In the case of and error condition, Page 16 (section 2.3.1 Errors)
* of the OpenGL 4.5 spec says:
*
* "If the generating command modifies values through a pointer argu-
* ment, no change is made to these values."
*/
for (int i = 0; i < uniformCount; i++) {
if (!_mesa_program_resource_find_index(shProg, GL_UNIFORM,
uniformIndices[i])) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniformsiv(index)");
return;
}
}
for (int i = 0; i < uniformCount; i++) {
res = _mesa_program_resource_find_index(shProg, GL_UNIFORM,
uniformIndices[i]);
if (!_mesa_program_resource_prop(shProg, res, uniformIndices[i],
res_prop, ¶ms[i],
"glGetActiveUniformsiv"))
break;
}
}
void GLAPIENTRY
_mesa_GetActiveAttrib(GLuint program, GLuint desired_index,
GLsizei maxLength, GLsizei * length, GLint * size,
GLenum * type, GLchar * name)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_shader_program *shProg;
if (maxLength < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(maxLength < 0)");
return;
}
shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");
if (!shProg)
return;
if (!shProg->LinkStatus) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glGetActiveAttrib(program not linked)");
return;
}
if (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(no vertex shader)");
return;
}
struct gl_program_resource *res =
_mesa_program_resource_find_index(shProg, GL_PROGRAM_INPUT,
desired_index);
/* User asked for index that does not exist. */
if (!res) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
return;
}
const gl_shader_variable *const var = RESOURCE_VAR(res);
const char *var_name = var->name;
_mesa_copy_string(name, maxLength, length, var_name);
if (size)
_mesa_program_resource_prop(shProg, res, desired_index, GL_ARRAY_SIZE,
size, "glGetActiveAttrib");
if (type)
_mesa_program_resource_prop(shProg, res, desired_index, GL_TYPE,
(GLint *) type, "glGetActiveAttrib");
}
/* Get full name of a program resource.
*/
bool
_mesa_get_program_resource_name(struct gl_shader_program *shProg,
GLenum programInterface, GLuint index,
GLsizei bufSize, GLsizei *length,
GLchar *name, const char *caller)
{
GET_CURRENT_CONTEXT(ctx);
/* Find resource with given interface and index. */
struct gl_program_resource *res =
_mesa_program_resource_find_index(shProg, programInterface, index);
/* The error INVALID_VALUE is generated if <index> is greater than
* or equal to the number of entries in the active resource list for
* <programInterface>.
*/
if (!res) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(index %u)", caller, index);
return false;
}
if (bufSize < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(bufSize %d)", caller, bufSize);
return false;
}
GLsizei localLength;
if (length == NULL)
length = &localLength;
_mesa_copy_string(name, bufSize, length, _mesa_program_resource_name(res));
if (_mesa_program_resource_array_size(res) && add_index_to_name(res)) {
int i;
/* The comparison is strange because *length does *NOT* include the
* terminating NUL, but maxLength does.
*/
for (i = 0; i < 3 && (*length + i + 1) < bufSize; i++)
name[*length + i] = "[0]"[i];
name[*length + i] = '\0';
*length += i;
}
return true;
}
extern void
_mesa_get_program_resourceiv(struct gl_shader_program *shProg,
GLenum programInterface, GLuint index, GLsizei propCount,
const GLenum *props, GLsizei bufSize,
GLsizei *length, GLint *params)
{
GET_CURRENT_CONTEXT(ctx);
GLint *val = (GLint *) params;
const GLenum *prop = props;
GLsizei amount = 0;
struct gl_program_resource *res =
_mesa_program_resource_find_index(shProg, programInterface, index);
/* No such resource found or bufSize negative. */
if (!res || bufSize < 0) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glGetProgramResourceiv(%s index %d bufSize %d)",
_mesa_enum_to_string(programInterface), index, bufSize);
return;
}
/* Write propCount values until error occurs or bufSize reached. */
for (int i = 0; i < propCount && i < bufSize; i++, val++, prop++) {
int props_written =
_mesa_program_resource_prop(shProg, res, index, *prop, val,
"glGetProgramResourceiv");
/* Error happened. */
if (props_written == 0)
return;
amount += props_written;
}
/* If <length> is not NULL, the actual number of integer values
* written to <params> will be written to <length>.
*/
if (length)
*length = amount;
}
extern "C" void GLAPIENTRY
_mesa_GetActiveUniform(GLuint program, GLuint index,
GLsizei maxLength, GLsizei *length, GLint *size,
GLenum *type, GLcharARB *nameOut)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_shader_program *shProg;
struct gl_program_resource *res;
if (maxLength < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(maxLength < 0)");
return;
}
shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");
if (!shProg)
return;
res = _mesa_program_resource_find_index((struct gl_shader_program *) shProg,
GL_UNIFORM, index);
if (!res) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
return;
}
if (nameOut)
_mesa_get_program_resource_name(shProg, GL_UNIFORM, index, maxLength,
length, nameOut, "glGetActiveUniform");
if (type)
_mesa_program_resource_prop((struct gl_shader_program *) shProg,
res, index, GL_TYPE, (GLint*) type,
"glGetActiveUniform");
if (size)
_mesa_program_resource_prop((struct gl_shader_program *) shProg,
res, index, GL_ARRAY_SIZE, (GLint*) size,
"glGetActiveUniform");
}
/**
* 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(ctx, program);
if (!shProg) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glGetTransformFeedbackVarying(program=%u)", program);
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");
}
static unsigned
get_buffer_property(struct gl_shader_program *shProg,
struct gl_program_resource *res, const GLenum prop,
GLint *val, const char *caller)
{
GET_CURRENT_CONTEXT(ctx);
if (res->Type != GL_UNIFORM_BLOCK &&
res->Type != GL_ATOMIC_COUNTER_BUFFER &&
res->Type != GL_SHADER_STORAGE_BLOCK &&
res->Type != GL_TRANSFORM_FEEDBACK_BUFFER)
goto invalid_operation;
if (res->Type == GL_UNIFORM_BLOCK) {
switch (prop) {
case GL_BUFFER_BINDING:
*val = RESOURCE_UBO(res)->Binding;
return 1;
case GL_BUFFER_DATA_SIZE:
*val = RESOURCE_UBO(res)->UniformBufferSize;
return 1;
case GL_NUM_ACTIVE_VARIABLES:
*val = 0;
for (unsigned i = 0; i < RESOURCE_UBO(res)->NumUniforms; i++) {
const char *iname = RESOURCE_UBO(res)->Uniforms[i].IndexName;
struct gl_program_resource *uni =
_mesa_program_resource_find_name(shProg, GL_UNIFORM, iname,
NULL);
if (!uni)
continue;
(*val)++;
}
return 1;
case GL_ACTIVE_VARIABLES: {
unsigned num_values = 0;
for (unsigned i = 0; i < RESOURCE_UBO(res)->NumUniforms; i++) {
const char *iname = RESOURCE_UBO(res)->Uniforms[i].IndexName;
struct gl_program_resource *uni =
_mesa_program_resource_find_name(shProg, GL_UNIFORM, iname,
NULL);
if (!uni)
continue;
*val++ =
_mesa_program_resource_index(shProg, uni);
num_values++;
}
return num_values;
}
}
} else if (res->Type == GL_SHADER_STORAGE_BLOCK) {
switch (prop) {
case GL_BUFFER_BINDING:
*val = RESOURCE_UBO(res)->Binding;
return 1;
case GL_BUFFER_DATA_SIZE:
*val = RESOURCE_UBO(res)->UniformBufferSize;
return 1;
case GL_NUM_ACTIVE_VARIABLES:
*val = 0;
for (unsigned i = 0; i < RESOURCE_UBO(res)->NumUniforms; i++) {
const char *iname = RESOURCE_UBO(res)->Uniforms[i].IndexName;
struct gl_program_resource *uni =
_mesa_program_resource_find_name(shProg, GL_BUFFER_VARIABLE,
iname, NULL);
if (!uni)
continue;
(*val)++;
}
return 1;
case GL_ACTIVE_VARIABLES: {
unsigned num_values = 0;
for (unsigned i = 0; i < RESOURCE_UBO(res)->NumUniforms; i++) {
const char *iname = RESOURCE_UBO(res)->Uniforms[i].IndexName;
struct gl_program_resource *uni =
_mesa_program_resource_find_name(shProg, GL_BUFFER_VARIABLE,
iname, NULL);
if (!uni)
continue;
*val++ =
_mesa_program_resource_index(shProg, uni);
num_values++;
}
return num_values;
}
}
} else if (res->Type == GL_ATOMIC_COUNTER_BUFFER) {
switch (prop) {
case GL_BUFFER_BINDING:
*val = RESOURCE_ATC(res)->Binding;
return 1;
case GL_BUFFER_DATA_SIZE:
*val = RESOURCE_ATC(res)->MinimumSize;
return 1;
case GL_NUM_ACTIVE_VARIABLES:
*val = RESOURCE_ATC(res)->NumUniforms;
return 1;
case GL_ACTIVE_VARIABLES:
for (unsigned i = 0; i < RESOURCE_ATC(res)->NumUniforms; i++) {
/* Active atomic buffer contains index to UniformStorage. Find
* out gl_program_resource via data pointer and then calculate
* index of that uniform.
*/
unsigned idx = RESOURCE_ATC(res)->Uniforms[i];
struct gl_program_resource *uni =
program_resource_find_data(shProg,
&shProg->UniformStorage[idx]);
assert(uni);
*val++ = _mesa_program_resource_index(shProg, uni);
}
return RESOURCE_ATC(res)->NumUniforms;
}
} else if (res->Type == GL_TRANSFORM_FEEDBACK_BUFFER) {
switch (prop) {
case GL_BUFFER_BINDING:
*val = RESOURCE_XFB(res)->Binding;
return 1;
case GL_NUM_ACTIVE_VARIABLES:
*val = RESOURCE_XFB(res)->NumVaryings;
return 1;
case GL_ACTIVE_VARIABLES:
int i = 0;
for ( ; i < shProg->LinkedTransformFeedback.NumVarying; i++) {
unsigned index =
shProg->LinkedTransformFeedback.Varyings[i].BufferIndex;
struct gl_program_resource *buf_res =
_mesa_program_resource_find_index(shProg,
GL_TRANSFORM_FEEDBACK_BUFFER,
index);
assert(buf_res);
if (res == buf_res) {
*val++ = i;
}
}
return RESOURCE_XFB(res)->NumVaryings;
}
}
assert(!"support for property type not implemented");
invalid_operation:
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(%s prop %s)", caller,
_mesa_enum_to_string(res->Type),
_mesa_enum_to_string(prop));
return 0;
}
void GLAPIENTRY
_mesa_GetActiveAttrib(GLhandleARB program, GLuint desired_index,
GLsizei maxLength, GLsizei * length, GLint * size,
GLenum * type, GLcharARB * name)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_shader_program *shProg;
if (maxLength < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(maxLength < 0)");
return;
}
shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");
if (!shProg)
return;
if (!shProg->LinkStatus) {
_mesa_error(ctx, GL_INVALID_VALUE,
"glGetActiveAttrib(program not linked)");
return;
}
if (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(no vertex shader)");
return;
}
struct gl_program_resource *res =
_mesa_program_resource_find_index(shProg, GL_PROGRAM_INPUT,
desired_index);
/* User asked for index that does not exist. */
if (!res) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
return;
}
const ir_variable *const var = RESOURCE_VAR(res);
if (!is_active_attrib(var))
return;
const char *var_name = var->name;
/* Since gl_VertexID may be lowered to gl_VertexIDMESA, we need to
* consider gl_VertexIDMESA as gl_VertexID for purposes of checking
* active attributes.
*/
if (var->data.mode == ir_var_system_value &&
var->data.location == SYSTEM_VALUE_VERTEX_ID_ZERO_BASE) {
var_name = "gl_VertexID";
}
_mesa_copy_string(name, maxLength, length, var_name);
if (size)
_mesa_program_resource_prop(shProg, res, desired_index, GL_ARRAY_SIZE,
size, "glGetActiveAttrib");
if (type)
_mesa_program_resource_prop(shProg, res, desired_index, GL_TYPE,
(GLint *) type, "glGetActiveAttrib");
}
/* Get full name of a program resource.
*/
bool
_mesa_get_program_resource_name(struct gl_shader_program *shProg,
GLenum programInterface, GLuint index,
GLsizei bufSize, GLsizei *length,
GLchar *name, const char *caller)
{
GET_CURRENT_CONTEXT(ctx);
/* Find resource with given interface and index. */
struct gl_program_resource *res =
_mesa_program_resource_find_index(shProg, programInterface, index);
/* The error INVALID_VALUE is generated if <index> is greater than
* or equal to the number of entries in the active resource list for
* <programInterface>.
*/
if (!res) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(index %u)", caller, index);
return false;
}
if (bufSize < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(bufSize %d)", caller, bufSize);
return false;
}
GLsizei localLength;
if (length == NULL)
length = &localLength;
_mesa_copy_string(name, bufSize, length, _mesa_program_resource_name(res));
/* Page 61 (page 73 of the PDF) in section 2.11 of the OpenGL ES 3.0
* spec says:
*
* "If the active uniform is an array, the uniform name returned in
* name will always be the name of the uniform array appended with
* "[0]"."
*
* The same text also appears in the OpenGL 4.2 spec. It does not,
* however, appear in any previous spec. Previous specifications are
* ambiguous in this regard. However, either name can later be passed
* to glGetUniformLocation (and related APIs), so there shouldn't be any
* harm in always appending "[0]" to uniform array names.
*
* Geometry shader stage has different naming convention where the 'normal'
* condition is an array, therefore for variables referenced in geometry
* stage we do not add '[0]'.
*
* Note, that TCS outputs and TES inputs should not have index appended
* either.
*/
bool add_index = !(((programInterface == GL_PROGRAM_INPUT) &&
res->StageReferences & (1 << MESA_SHADER_GEOMETRY)));
if (add_index && _mesa_program_resource_array_size(res)) {
int i;
/* The comparison is strange because *length does *NOT* include the
* terminating NUL, but maxLength does.
*/
for (i = 0; i < 3 && (*length + i + 1) < bufSize; i++)
name[*length + i] = "[0]"[i];
name[*length + i] = '\0';
*length += i;
}
return true;
}
