EXTERN_C_ENTER
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL42_nglGetActiveAtomicCounterBufferiv__IIIJ(JNIEnv *__env, jclass clazz, jint program, jint bufferIndex, jint pname, jlong paramsAddress) {
glGetActiveAtomicCounterBufferivPROC glGetActiveAtomicCounterBufferiv = (glGetActiveAtomicCounterBufferivPROC)tlsGetFunction(858);
intptr_t params = (intptr_t)paramsAddress;
UNUSED_PARAM(clazz)
glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL42_nglGetActiveAtomicCounterBufferiv(JNIEnv *env, jclass clazz, jint program, jint bufferIndex, jint pname, jlong params, jlong function_pointer) {
GLint *params_address = (GLint *)(intptr_t)params;
glGetActiveAtomicCounterBufferivPROC glGetActiveAtomicCounterBufferiv = (glGetActiveAtomicCounterBufferivPROC)((intptr_t)function_pointer);
glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params_address);
}
void
piglit_init(int argc, char **argv)
{
struct atomic_counters_limits ls = atomic_counters_get_limits();
bool visited_buffers[8] = { false };
bool visited_counters[8] = { false };
GLuint prog = glCreateProgram();
int i, j, n, ret;
piglit_require_gl_version(31);
piglit_require_extension("GL_ARB_shader_atomic_counters");
if (ls.fragment_counters < 9) {
fprintf(stderr, "Insufficient number of supported atomic "
"counters.\n");
piglit_report_result(PIGLIT_SKIP);
}
if (ls.fragment_buffers < 4) {
fprintf(stderr, "Insufficient number of supported atomic "
"counter buffers.\n");
piglit_report_result(PIGLIT_SKIP);
}
if (!atomic_counters_compile(prog, GL_FRAGMENT_SHADER, fs_source)) {
fprintf(stderr, "Program failed to compile.\n");
piglit_report_result(PIGLIT_FAIL);
}
if (!atomic_counters_link(prog)) {
fprintf(stderr, "Program failed to link.\n");
piglit_report_result(PIGLIT_FAIL);
}
glGetProgramiv(prog, GL_ACTIVE_ATOMIC_COUNTER_BUFFERS, &n);
if (n != 4) {
fprintf(stderr, "Unexpected number of active counter "
"buffers.\n");
piglit_report_result(PIGLIT_FAIL);
}
ret = 0xdeadbeef;
glGetActiveAtomicCounterBufferiv(
prog, n, GL_ATOMIC_COUNTER_BUFFER_BINDING, &ret);
if (!piglit_check_gl_error(GL_INVALID_VALUE)) {
fprintf(stderr, "glGetActiveAtomicCounterBufferiv should have "
"failed when trying to query a non-existent buffer.\n");
piglit_report_result(PIGLIT_FAIL);
}
if (ret != 0xdeadbeef) {
fprintf(stderr, "Failed call to glGetActiveAtomicCounterBufferiv"
"didn't preserve the output parameter contents.\n");
piglit_report_result(PIGLIT_FAIL);
}
for (i = 0; i < n; ++i) {
const struct buffer_info *binfo;
int binding, data_size, num_counters, ref;
GLuint counters[4];
glGetActiveAtomicCounterBufferiv(
prog, i, GL_ATOMIC_COUNTER_BUFFER_BINDING, &binding);
if (!piglit_check_gl_error(GL_NO_ERROR)) {
fprintf(stderr, "Couldn't obtain counter buffer binding"
" point.\n");
piglit_report_result(PIGLIT_FAIL);
}
binfo = expected_buffer_info(binding);
if (!binfo) {
fprintf(stderr, "Got unexpected buffer binding "
"point.\n");
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveAtomicCounterBufferiv(
prog, i, GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE,
&data_size);
if (!piglit_check_gl_error(GL_NO_ERROR) ||
data_size < binfo->min_reasonable_size) {
fprintf(stderr, "Invalid buffer data size: %d,"
" expected at least: %d.\n", data_size,
binfo->min_reasonable_size);
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveAtomicCounterBufferiv(
prog, i, GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS,
&num_counters);
if (!piglit_check_gl_error(GL_NO_ERROR) ||
num_counters != binfo->num_counters) {
fprintf(stderr, "Invalid number of atomic counters: %d,"
" expected: %d.\n", num_counters,
binfo->num_counters);
piglit_report_result(PIGLIT_FAIL);
}
if (visited_buffers[i]) {
fprintf(stderr, "Buffer at binding point %d seen twice."
"\n", binding);
piglit_report_result(PIGLIT_FAIL);
}
visited_buffers[i] = true;
glGetActiveAtomicCounterBufferiv(prog, i,
GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER,
&ref);
if (!piglit_check_gl_error(GL_NO_ERROR) || ref) {
fprintf(stderr, "Buffer incorrectly reported to be "
"referenced by vertex shader.\n");
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveAtomicCounterBufferiv(prog, i,
GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER,
&ref);
if (!piglit_check_gl_error(GL_NO_ERROR) || ref) {
fprintf(stderr, "Buffer incorrectly reported to be "
"referenced by tessellation control shader.\n");
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveAtomicCounterBufferiv(prog, i,
GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER,
&ref);
if (!piglit_check_gl_error(GL_NO_ERROR) || ref) {
fprintf(stderr, "Buffer incorrectly reported to be "
"referenced by tessellation evaluation shader."
"\n");
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveAtomicCounterBufferiv(prog, i,
GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER,
&ref);
if (!piglit_check_gl_error(GL_NO_ERROR) || ref) {
fprintf(stderr, "Buffer incorrectly reported to be "
"referenced by geometry shader.\n");
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveAtomicCounterBufferiv(prog, i,
GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER,
&ref);
if (!piglit_check_gl_error(GL_NO_ERROR) || !ref) {
fprintf(stderr, "Buffer incorrectly reported as "
"unreferenced from the fragment shader.\n");
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveAtomicCounterBufferiv(prog, i,
GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES,
(GLint *)counters);
if (!piglit_check_gl_error(GL_NO_ERROR)) {
fprintf(stderr, "Couldn't obtain list of active atomic "
"counters for buffer at binding point %d.\n",
binding);
piglit_report_result(PIGLIT_FAIL);
}
for (j = 0; j < num_counters; ++j) {
const struct counter_info *cinfo;
int unif_type, unif_size, unif_name_len,
unif_block_idx, unif_offset, unif_stride,
unif_buffer_idx;
char unif_name[8];
glGetActiveUniformName(prog, counters[j],
sizeof(unif_name), NULL,
unif_name);
cinfo = expected_counter_info(unif_name);
if (!piglit_check_gl_error(GL_NO_ERROR) || !cinfo) {
fprintf(stderr, "Unknown atomic counter \"%s\"."
"\n", unif_name);
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveUniformsiv(prog, 1, &counters[j],
GL_UNIFORM_TYPE, &unif_type);
if (!piglit_check_gl_error(GL_NO_ERROR) ||
unif_type != GL_UNSIGNED_INT_ATOMIC_COUNTER) {
fprintf(stderr, "Atomic counter \"%s\" has "
"invalid type 0x%x, expected 0x%x.\n",
unif_name, unif_type,
GL_UNSIGNED_INT_ATOMIC_COUNTER);
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveUniformsiv(prog, 1, &counters[j],
GL_UNIFORM_SIZE, &unif_size);
if (!piglit_check_gl_error(GL_NO_ERROR) ||
unif_size != cinfo->size) {
fprintf(stderr, "Atomic counter \"%s\" has "
"invalid size %d, expected: %d.\n",
unif_name, unif_size, cinfo->size);
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveUniformsiv(prog, 1, &counters[j],
GL_UNIFORM_NAME_LENGTH, &unif_name_len);
if (!piglit_check_gl_error(GL_NO_ERROR) ||
unif_name_len != strlen(unif_name) + 1) {
fprintf(stderr, "Atomic counter \"%s\" has "
"invalid name length %d, expected: %d."
"\n", unif_name, unif_name_len,
(int)strlen(unif_name) + 1);
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveUniformsiv(prog, 1, &counters[j],
GL_UNIFORM_BLOCK_INDEX, &unif_block_idx);
if (!piglit_check_gl_error(GL_NO_ERROR) ||
unif_block_idx != -1) {
fprintf(stderr, "Atomic counter \"%s\" has "
"invalid block index %d, expected: -1."
"\n", unif_name, unif_block_idx);
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveUniformsiv(prog, 1, &counters[j],
GL_UNIFORM_OFFSET, &unif_offset);
if (!piglit_check_gl_error(GL_NO_ERROR) ||
unif_offset != cinfo->offset) {
fprintf(stderr, "Atomic counter \"%s\" has "
"invalid offset %d, expected: %d.\n",
unif_name, unif_offset, cinfo->offset);
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveUniformsiv(prog, 1, &counters[j],
GL_UNIFORM_ARRAY_STRIDE, &unif_stride);
if (!piglit_check_gl_error(GL_NO_ERROR) ||
(cinfo->size > 1 && unif_stride < 4) ||
(cinfo->size == 1 && unif_stride != 0)) {
fprintf(stderr, "Atomic counter \"%s\" has "
"invalid array stride %d.\n",
unif_name, unif_stride);
piglit_report_result(PIGLIT_FAIL);
}
glGetActiveUniformsiv(prog, 1, &counters[j],
GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX,
&unif_buffer_idx);
if (!piglit_check_gl_error(GL_NO_ERROR) ||
unif_buffer_idx != i) {
fprintf(stderr, "Atomic counter \"%s\" has "
"invalid buffer index %d, expected %d."
"\n", unif_name, unif_buffer_idx, i);
piglit_report_result(PIGLIT_FAIL);
}
if (cinfo->binding != binding) {
fprintf(stderr, "Atomic counter \"%s\" belongs "
"to the wrong binding point %d.\n",
unif_name, binding);
piglit_report_result(PIGLIT_FAIL);
}
if (visited_counters[counters[j]]) {
fprintf(stderr, "Atomic counter \"%s\" seen "
"twice.\n", unif_name);
piglit_report_result(PIGLIT_FAIL);
}
visited_counters[counters[j]] = true;
}
}
glDeleteProgram(prog);
piglit_report_result(PIGLIT_PASS);
}
void kore::ShaderProgram::constructShaderInputInfo(const GLenum activeType,
std::vector<kore::ShaderInput>& rInputVector) {
GLint iNumActiveElements = 0;
/*
/* OpenGL 4.3 or arb_program_interface_query needed
/*
glGetProgramInterfaceiv(_programHandle, activeType, GL_ACTIVE_RESOURCES,
&iNumActiveElements);
const GLenum properties[3] = {GL_TYPE, GL_NAME_LENGTH, GL_LOCATION};
*/
glGetProgramiv(_programHandle,
activeType,
&iNumActiveElements);
for (int i = 0; i < iNumActiveElements; ++i) {
GLchar szNameBuf[BUFSIZE];
GLsizei iActualNameLength = 0;
GLint iElementSize = 1;
GLenum eElementType;
GLint iElementLoc = -1;
/*
/* OpenGL 4.3 or arb_program_interface_query needed
/*
GLint values[3];
glGetProgramResourceiv(_programHandle, activeType, i, 3, properties,
BUFSIZE, NULL, values);
eElementType = values[0];
iActualNameLength = values[1];
iElementLoc = values[2];
glGetProgramResourceName(_programHandle, activeType, i, BUFSIZE,
&iActualNameLength, szNameBuf);
*/
if (activeType == GL_ACTIVE_ATTRIBUTES) {
glGetActiveAttrib(_programHandle, i, BUFSIZE, &iActualNameLength,
&iElementSize, &eElementType, szNameBuf);
iElementLoc = glGetAttribLocation(_programHandle, szNameBuf);
}
if (activeType == GL_ACTIVE_UNIFORMS){
glGetActiveUniform(_programHandle, i, BUFSIZE, &iActualNameLength,
&iElementSize, &eElementType, szNameBuf);
iElementLoc = glGetUniformLocation(_programHandle, szNameBuf);
}
std::string szName = std::string(szNameBuf);
ShaderInput element;
element.name = szName;
element.type = eElementType;
element.input_type = activeType;
element.size = iElementSize;
element.location = iElementLoc;
element.programHandle = _programHandle;
element.shader = this;
rInputVector.push_back(element);
}
/*
/* OpenGL 4.3 or arb_program_interface_query needed
/*
// For Uniform texture-types: add the textureUnit-field
if (activeType == GL_UNIFORM) {
GLuint texUnit = 0;
for (uint i = 0; i < rInputVector.size(); ++i) {
if (isSamplerType(rInputVector[i].type)) {
rInputVector[i].texUnit = texUnit;
++texUnit;
}
}
}
*/
// For Uniform texture-types: add the textureUnit-field
if (activeType == GL_ACTIVE_UNIFORMS) {
ResourceManager* resourceManager = ResourceManager::getInstance();
GLuint texUnit = 0;
GLuint imgUnit = 0;
GLuint atomicCounterIndex = 0; // e.g. for atomic counters.
for (uint i = 0; i < rInputVector.size(); ++i) {
if (rInputVector[i].isSamplerType()) {
rInputVector[i].texUnit = texUnit;
TexSamplerProperties samplerProperties;
samplerProperties.type = rInputVector[i].type;
const TextureSampler* sampler =
resourceManager->requestTextureSampler(samplerProperties);
_vSamplers.push_back(sampler);
++texUnit;
}
// For Image-types: add the imgUnit-field,
// but don't create a sampler.
else if (rInputVector[i].isImageType()) {
rInputVector[i].imgUnit = imgUnit;
++imgUnit;
_imgAccessParams.push_back(GL_READ_WRITE);
}
else if(rInputVector[i].isAtomicCounterType()) {
// Get the bindingPoint (set with layout(binding = x)
GLint bindingPoint;
glGetActiveAtomicCounterBufferiv(_programHandle,
atomicCounterIndex,
GL_ATOMIC_COUNTER_BUFFER_BINDING,
&bindingPoint);
++atomicCounterIndex;
rInputVector[i].atomicCounterBindingPoint = bindingPoint;
}
}
}
}