void GLState::glsGetStateData(const GLenum state_name, const GLType type,
void* data) {
switch (type) {
case GLTYPE_BOOL:
glGetBooleanv(state_name, (GLboolean*)data);
ERROR_CHECK;
break;
case GLTYPE_ENUM:
case GLTYPE_INT:
glGetIntegerv(state_name, (GLint*)data);
ERROR_CHECK;
break;
case GLTYPE_FLOAT:
glGetFloatv(state_name, (GLfloat*)data);
ERROR_CHECK;
break;
case GLTYPE_DOUBLE:
glGetDoublev(state_name, (GLdouble*)data);
ERROR_CHECK;
break;
case GLTYPE_INT64:
glGetInteger64v(state_name, (GLint64*)data);
ERROR_CHECK;
break;
}
}
GLsizei getSizei(lua_State *L, GLenum pname)
{
GLint64 len;
glGetInteger64v(pname, &len);
CheckError(L);
return (GLsizei)len;
}
static void
piglit_test_uint64(GLenum token, GLuint64 limit, bool max)
{
const char *name = piglit_get_gl_enum_name(token);
GLuint64 val = SENTINEL;
bool pass;
/* To obtain GLuint64 values, we must use glGetInteger64v.
* Justification is found in the GL_ARB_sync spec:
*
* 30) What is the type of the timeout interval?
*
* RESOLVED: GLuint64. [...] Consequently the type of <timeout>
* has been changed to 'GLuint64' and a corresponding
* 'GetInteger64v' query taking 'GLint64' added (by symmetry
* with GetInteger, where unsigned quantities are queries with
* a function taking a pointer to a signed integer - the pointer
* conversion is harmless).
*/
glGetInteger64v(token, (GLint64*) &val);
pass = piglit_check_gl_error(GL_NO_ERROR);
piglit_report_uint64(name, limit, val,
pass &&
val != SENTINEL &&
((max && val <= limit) ||
(!max && val >= limit)));
}
static GLint64
get_gpu_time_via_get(GLuint q)
{
GLint64 time;
glGetInteger64v(GL_TIMESTAMP, &time);
return time;
}
static int GetInt(lua_State *L, GLenum pname)
{
GLint64 data;
glGetInteger64v(pname, &data);
CheckError(L);
lua_pushinteger(L, data);
return 1;
}
static int GetInt2(lua_State *L, GLenum pname)
{
GLint64 data[2];
glGetInteger64v(pname, data);
CheckError(L);
lua_pushinteger(L, data[0]);
lua_pushinteger(L, data[1]);
return 2;
}
int64_t MetricBackend_opengl::getCurrentTime(void) {
if (supportsTimestamp && cpugpuSync) {
/* Get the current GL time without stalling */
GLint64 timestamp = 0;
glGetInteger64v(GL_TIMESTAMP, ×tamp);
return timestamp;
} else {
return os::getTime();
}
}
static inline int64_t
getCurrentTime(void) {
if (retrace::profilingGpuTimes && supportsTimestamp) {
/* Get the current GL time without stalling */
GLint64 timestamp = 0;
glGetInteger64v(GL_TIMESTAMP, ×tamp);
return timestamp;
} else {
return os::getTime();
}
}
static int GetIntN(lua_State *L, GLenum pname, GLenum numpname)
{
GLint64 *data;
GLsizei i, num = getSizei(L, numpname);
if(num==0) return 0;
data = (GLint64*)Malloc(L, num*sizeof(GLint64));
glGetInteger64v(pname, data);
CheckErrorFree(L, data);
for(i = 0; i<num; i++)
lua_pushinteger(L, data[i]);
Free(L, data);
return num;
}
static int GetIntOptIndex(lua_State *L, GLenum pname) /* index is optional */
{
GLint64 data;
GLuint index;
if(!lua_isnoneornil(L, 2))
{
index = luaL_checkinteger(L, 2);
glGetInteger64i_v(pname, index, &data);
}
else
glGetInteger64v(pname, &data);
CheckError(L);
lua_pushinteger(L, data);
return 1;
}
static void
piglit_test_int64(GLenum token, GLint64 limit, bool max)
{
const char *name = piglit_get_gl_enum_name(token);
GLint64 val = SENTINEL;
bool pass;
glGetInteger64v(token, &val);
pass = piglit_check_gl_error(GL_NO_ERROR);
piglit_report_int64(name, limit, val,
pass &&
val != SENTINEL &&
((max && val <= limit) ||
(!max && val >= limit)));
}
//==============================================================================
void GlBuffer::create(GLenum target, U32 sizeInBytes,
const void* dataPtr, GLbitfield flags)
{
ANKI_ASSERT(!isCreated());
if(target == GL_UNIFORM_BUFFER)
{
GLint64 maxBufferSize;
glGetInteger64v(GL_MAX_UNIFORM_BLOCK_SIZE, &maxBufferSize);
if(sizeInBytes > 16384)
{
ANKI_LOGW("The size (%u) of the uniform buffer is greater "
"than the spec's min", sizeInBytes);
}
else if(sizeInBytes > (PtrSize)maxBufferSize)
{
ANKI_LOGW("The size (%u) of the uniform buffer is greater "
"than the implementation's min (%u)", sizeInBytes,
maxBufferSize);
}
}
else if(target == GL_SHADER_STORAGE_BUFFER)
{
GLint64 maxBufferSize;
glGetInteger64v(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &maxBufferSize);
if(sizeInBytes > pow(2, 24))
{
ANKI_LOGW("The size (%u) of the uniform buffer is greater "
"than the spec's min", sizeInBytes);
}
else if(sizeInBytes > (PtrSize)maxBufferSize)
{
ANKI_LOGW("The size (%u) of the shader storage buffer is greater "
"than the implementation's min (%u)", sizeInBytes,
maxBufferSize);
}
}
m_target = target;
m_size = sizeInBytes;
ANKI_ASSERT(m_size > 0 && "Unacceptable size");
// Create
glGenBuffers(1, &m_glName);
glBindBuffer(m_target, m_glName);
glBufferStorage(m_target, m_size, dataPtr, flags);
// Map if needed
if((flags & GL_MAP_PERSISTENT_BIT) && (flags & GL_MAP_COHERENT_BIT))
{
const GLbitfield mapbits = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT
| GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT;
m_persistentMapping =
glMapBufferRange(m_target, 0, sizeInBytes, flags & mapbits);
ANKI_ASSERT(m_persistentMapping != nullptr);
}
}
/// <summary>
/// Execute http get request
/// </summary>
/// <param name="idstr">OpenGL enum as string</param>
/// <param name="id">OpenGL enum to query</param>
/// <param name="type">Internal OpenGL enum type (glint, glstring)</param>
/// <param name="dim">No of dimensions to query</param>
void capsGroup::addCapability(string idstr, GLenum id, string type, int dim)
{
string errorValue = "n/a";
// Flush OpenGL error state
glGetError();
if (type == "glint")
{
GLint* intVal;
intVal = new GLint[dim];
glGetIntegerv(id, intVal);
GLint glerr = glGetError();
if (dim == 1)
{
capabilities[idstr] = to_string(intVal[0]);
}
else
{
for (int i = 0; i < dim; i++)
capabilities[idstr + "[" + to_string(i) + "]"] = to_string(intVal[i]);
}
if (glerr != GL_NO_ERROR)
capabilities[idstr] = errorValue;
delete[] intVal;
}
if (type == "glint64")
{
GLint64* intVal;
intVal = new GLint64[dim];
glGetInteger64v(id, intVal);
string valString = "";
for (int i = 0; i < dim; i++) {
if (i > 0) {
valString += " ,";
}
valString += to_string(intVal[i]);
}
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = errorValue;
}
delete[] intVal;
}
if (type == "glintindex")
{
GLint *intVal;
intVal = new GLint[dim];
for (int i = 0; i < dim; i++)
glGetIntegeri_v(id, i, &intVal[i]);
GLint glerr = glGetError();
if (dim == 1)
{
capabilities[idstr] = to_string(intVal[0]);
}
else
{
for (int i = 0; i < dim; i++)
capabilities[idstr+"["+to_string(i)+"]"] = to_string(intVal[i]);
}
if (glerr != GL_NO_ERROR)
capabilities[idstr] = errorValue;
delete[] intVal;
}
if (type == "glintfragmentprogram")
{
GLint* intVal;
intVal = new GLint[dim];
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, id, intVal);
string valString = "";
for (int i = 0; i < dim; i++) {
if (i > 0) {
valString += " ,";
}
valString += to_string(intVal[i]);
}
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = errorValue;
}
delete[] intVal;
}
if (type == "glintvertexprogram")
{
GLint* intVal;
intVal = new GLint[dim];
glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, id, intVal);
string valString = "";
for (int i = 0; i < dim; i++) {
if (i > 0) {
valString += " ,";
}
valString += to_string(intVal[i]);
}
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = errorValue;
}
delete[] intVal;
}
if (type == "glfloat")
{
GLfloat* floatVal;
floatVal = new GLfloat[dim];
glGetFloatv(id, floatVal);
string valString = "";
for (int i = 0; i < dim; i++) {
if (i > 0) {
valString += " ,";
}
valString += to_string(floatVal[i]);
}
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = errorValue;
}
delete[] floatVal;
}
if (type == "glstring")
{
string valString = reinterpret_cast<const char*>(glGetString(id));
GLint glerr = glGetError();
capabilities[idstr] = valString;
if (glerr != GL_NO_ERROR) {
capabilities[idstr] = "";
}
}
}
void caps::initValues()
{
memset(&ValuesData, 0, sizeof(ValuesData));
if(check(2, 1))
{
glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &ValuesData.MAX_ELEMENTS_INDICES);
glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &ValuesData.MAX_ELEMENTS_VERTICES);
}
if(check(4, 3) || (ExtensionData.ARB_vertex_attrib_binding))
{
glGetIntegerv(GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET, &ValuesData.MAX_VERTEX_ATTRIB_RELATIVE_OFFSET);
glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &ValuesData.MAX_VERTEX_ATTRIB_BINDINGS);
}
if(check(4, 3) || (ExtensionData.ARB_ES3_compatibility))
glGetInteger64v(GL_MAX_ELEMENT_INDEX, &ValuesData.MAX_ELEMENT_INDEX);
if(VersionData.PROFILE == caps::COMPATIBILITY)
{
glGetFloatv(GL_POINT_SIZE_MIN, &ValuesData.POINT_SIZE_MIN);
glGetFloatv(GL_POINT_SIZE_MAX, &ValuesData.POINT_SIZE_MAX);
}
glGetFloatv(GL_POINT_SIZE_RANGE, &ValuesData.POINT_SIZE_RANGE[0]);
glGetFloatv(GL_POINT_SIZE_GRANULARITY, &ValuesData.POINT_SIZE_GRANULARITY);
glGetFloatv(GL_ALIASED_LINE_WIDTH_RANGE, &ValuesData.ALIASED_LINE_WIDTH_RANGE[0]);
glGetFloatv(GL_SMOOTH_LINE_WIDTH_RANGE, &ValuesData.SMOOTH_LINE_WIDTH_RANGE[0]);
glGetFloatv(GL_SMOOTH_LINE_WIDTH_GRANULARITY, &ValuesData.SMOOTH_LINE_WIDTH_GRANULARITY);
if(check(2, 1))
{
glGetIntegerv(GL_SUBPIXEL_BITS, &ValuesData.SUBPIXEL_BITS);
glGetFloatv(GL_MAX_VIEWPORT_DIMS, &ValuesData.MAX_VIEWPORT_DIMS);
}
if(check(3, 0))
{
glGetIntegerv(GL_MAX_CLIP_DISTANCES, &ValuesData.MAX_CLIP_DISTANCES);
}
if(check(4, 1) || (ExtensionData.ARB_viewport_array))
{
glGetIntegerv(GL_MAX_VIEWPORTS, &ValuesData.MAX_VIEWPORTS);
glGetIntegerv(GL_VIEWPORT_SUBPIXEL_BITS, &ValuesData.VIEWPORT_SUBPIXEL_BITS);
glGetFloatv(GL_VIEWPORT_BOUNDS_RANGE, &ValuesData.VIEWPORT_BOUNDS_RANGE[0]);
glGetIntegerv(GL_LAYER_PROVOKING_VERTEX, reinterpret_cast<GLint*>(&ValuesData.LAYER_PROVOKING_VERTEX));
glGetIntegerv(GL_VIEWPORT_INDEX_PROVOKING_VERTEX, reinterpret_cast<GLint*>(&ValuesData.VIEWPORT_INDEX_PROVOKING_VERTEX));
}
if(check(2, 1))
{
glGetIntegerv(GL_MAX_TEXTURE_LOD_BIAS, &ValuesData.MAX_TEXTURE_LOD_BIAS);
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &ValuesData.MAX_TEXTURE_SIZE);
glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, &ValuesData.MAX_3D_TEXTURE_SIZE);
glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &ValuesData.MAX_CUBE_MAP_TEXTURE_SIZE);
}
if(check(3, 0) || (ExtensionData.EXT_texture_array))
glGetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &ValuesData.MAX_ARRAY_TEXTURE_LAYERS);
if(check(4, 3) || (ExtensionData.ARB_texture_buffer_object))
glGetIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, &ValuesData.TEXTURE_BUFFER_OFFSET_ALIGNMENT);
}
u64 GLGSRender::timestamp() const
{
GLint64 result;
glGetInteger64v(GL_TIMESTAMP, &result);
return result;
}
void
piglit_init(int argc, char **argv)
{
/* If the value's type is listed as Z in a spec table, then consider
* its type to be a signed int (that is, GLint or GLint64). If the
* value's type is listed as Z^+, then consider its type to be
* unsigned (that is, GLuint or GLuint64).
*/
GLuint v_blocks;
GLuint v_uniforms;
GLuint f_blocks;
GLuint f_uniforms;
GLuint64 blocksize;
piglit_print_minmax_header();
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_BLOCKS, (GLint*) &v_blocks);
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, (GLint*) &v_uniforms);
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_BLOCKS, (GLint*) &f_blocks);
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, (GLint*) &f_uniforms);
glGetInteger64v(GL_MAX_UNIFORM_BLOCK_SIZE, (GLint64*) &blocksize);
/* Table 6.27 */
piglit_test_min_uint64(GL_MAX_ELEMENT_INDEX, (1 << 24) - 1);
piglit_test_min_uint(GL_SUBPIXEL_BITS, 4);
piglit_test_min_uint(GL_MAX_3D_TEXTURE_SIZE, 256);
piglit_test_min_uint(GL_MAX_TEXTURE_SIZE, 2048);
piglit_test_min_uint(GL_MAX_ARRAY_TEXTURE_LAYERS, 256);
piglit_test_min_float(GL_MAX_TEXTURE_LOD_BIAS, 2.0);
piglit_test_min_uint(GL_MAX_CUBE_MAP_TEXTURE_SIZE, 2048);
piglit_test_min_uint(GL_MAX_RENDERBUFFER_SIZE, 2048);
piglit_test_min_uint(GL_MAX_DRAW_BUFFERS, 4);
piglit_test_min_uint(GL_MAX_COLOR_ATTACHMENTS, 4);
piglit_test_min_viewport_dimensions();
piglit_test_range_float(GL_ALIASED_POINT_SIZE_RANGE, 1, 1);
piglit_test_range_float(GL_ALIASED_LINE_WIDTH_RANGE, 1, 1);
/* Table 6.28 */
piglit_test_min_uint(GL_NUM_COMPRESSED_TEXTURE_FORMATS, 10);
piglit_test_min_uint(GL_NUM_PROGRAM_BINARY_FORMATS, 0);
piglit_test_min_uint(GL_NUM_SHADER_BINARY_FORMATS, 0);
piglit_test_min_uint(GL_MAX_SERVER_WAIT_TIMEOUT, 0);
/* Table 6.29 */
piglit_test_min_int(GL_MAJOR_VERSION, 3);
/* Table 6.30 */
piglit_test_min_uint(GL_MAX_VERTEX_ATTRIBS, 16);
piglit_test_min_uint(GL_MAX_VERTEX_UNIFORM_COMPONENTS, 1024);
piglit_test_min_uint(GL_MAX_VERTEX_UNIFORM_VECTORS, 256);
piglit_test_min_uint(GL_MAX_VERTEX_UNIFORM_BLOCKS, 12);
piglit_test_min_uint(GL_MAX_VERTEX_UNIFORM_COMPONENTS, 64);
piglit_test_min_uint(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, 16);
/* Table 6.31 */
piglit_test_min_uint(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, 896);
piglit_test_min_uint(GL_MAX_FRAGMENT_UNIFORM_VECTORS, 224);
piglit_test_min_uint(GL_MAX_FRAGMENT_UNIFORM_BLOCKS, 12);
piglit_test_min_uint(GL_MAX_FRAGMENT_INPUT_COMPONENTS, 60);
piglit_test_min_uint(GL_MAX_TEXTURE_IMAGE_UNITS, 16);
piglit_test_max_int(GL_MIN_PROGRAM_TEXEL_OFFSET, -8);
piglit_test_min_int(GL_MAX_PROGRAM_TEXEL_OFFSET, 7);
/* Table 6.32 */
piglit_test_min_uint(GL_MAX_UNIFORM_BUFFER_BINDINGS, 24);
piglit_test_min_uint64(GL_MAX_UNIFORM_BLOCK_SIZE, 16384);
piglit_test_min_uint(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, 1);
piglit_test_min_uint(GL_MAX_COMBINED_UNIFORM_BLOCKS, 24);
piglit_test_min_uint64(GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS, v_blocks * blocksize / 4 + v_uniforms);
piglit_test_min_uint64(GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS, f_blocks * blocksize / 4 + f_uniforms);
piglit_test_min_uint64(GL_MAX_VARYING_COMPONENTS, 60);
piglit_test_min_uint64(GL_MAX_VARYING_VECTORS, 15);
piglit_test_min_uint64(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, 32);
/* Table 6.33 */
piglit_test_min_uint(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, 64);
piglit_test_min_uint(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, 4);
piglit_test_min_uint(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, 4);
/* Table 6.34 */
piglit_test_min_uint(GL_SAMPLE_BUFFERS, 0);
piglit_test_min_uint(GL_SAMPLES, 0);
piglit_test_min_uint(GL_MAX_SAMPLES, 4);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
piglit_report_result(piglit_minmax_pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
//! glGetInteger64v wrapper. May throw.
inline void getInteger64v(GLenum const pname, GLint64* data) {
glGetInteger64v(pname, data);
checkError("glGetInteger64v");
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL32_nglGetInteger64v(JNIEnv *env, jclass clazz, jint pname, jlong data, jlong function_pointer) {
GLint64 *data_address = (GLint64 *)(intptr_t)data;
glGetInteger64vPROC glGetInteger64v = (glGetInteger64vPROC)((intptr_t)function_pointer);
glGetInteger64v(pname, data_address);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL32C_nglGetInteger64v__IJ(JNIEnv *__env, jclass clazz, jint pname, jlong paramsAddress) {
glGetInteger64vPROC glGetInteger64v = (glGetInteger64vPROC)tlsGetFunction(663);
intptr_t params = (intptr_t)paramsAddress;
UNUSED_PARAM(clazz)
glGetInteger64v(pname, params);
}
//==============================================================================
void BufferImpl::init(
PtrSize size, BufferUsageBit usage, BufferAccessBit access)
{
ANKI_ASSERT(!isCreated());
m_usage = usage;
m_access = access;
///
// Check size
//
ANKI_ASSERT(size > 0 && "Unacceptable size");
// This is a guess, not very important since DSA doesn't care about it on
// creation
m_target = GL_ARRAY_BUFFER;
if((usage & BufferUsageBit::UNIFORM) != BufferUsageBit::NONE)
{
GLint64 maxBufferSize;
glGetInteger64v(GL_MAX_UNIFORM_BLOCK_SIZE, &maxBufferSize);
if(size > 16384)
{
ANKI_LOGW("The size (%u) of the uniform buffer is greater "
"than the spec's min",
size);
}
else if(size > PtrSize(maxBufferSize))
{
ANKI_LOGW("The size (%u) of the uniform buffer is greater "
"than the implementation's min (%u)",
size,
maxBufferSize);
}
m_target = GL_UNIFORM_BUFFER;
}
if((usage & BufferUsageBit::STORAGE) != BufferUsageBit::NONE)
{
GLint64 maxBufferSize;
glGetInteger64v(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &maxBufferSize);
if(size > pow(2, 24))
{
ANKI_LOGW("The size (%u) of the uniform buffer is greater "
"than the spec's min",
size);
}
else if(size > PtrSize(maxBufferSize))
{
ANKI_LOGW("The size (%u) of the shader storage buffer is greater "
"than the implementation's min (%u)",
size,
maxBufferSize);
}
m_target = GL_SHADER_STORAGE_BUFFER;
}
m_size = size;
//
// Determine the creation flags
//
GLbitfield flags = 0;
Bool shouldMap = false;
if((access & BufferAccessBit::CLIENT_WRITE) != BufferAccessBit::NONE)
{
flags |= GL_DYNAMIC_STORAGE_BIT;
}
if((access & BufferAccessBit::CLIENT_MAP_WRITE) != BufferAccessBit::NONE)
{
flags |= GL_MAP_WRITE_BIT;
flags |= GL_MAP_PERSISTENT_BIT;
flags |= GL_MAP_COHERENT_BIT;
shouldMap = true;
}
if((access & BufferAccessBit::CLIENT_MAP_READ) != BufferAccessBit::NONE)
{
flags |= GL_MAP_READ_BIT;
flags |= GL_MAP_PERSISTENT_BIT;
flags |= GL_MAP_COHERENT_BIT;
shouldMap = true;
}
//
// Create
//
glGenBuffers(1, &m_glName);
glBindBuffer(m_target, m_glName);
glBufferStorage(m_target, size, nullptr, flags);
//
// Map
//
if(shouldMap)
{
const GLbitfield MAP_BITS = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT
| GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT;
m_persistentMapping =
glMapBufferRange(m_target, 0, size, flags & MAP_BITS);
ANKI_ASSERT(m_persistentMapping != nullptr);
}
}
void Curvature::run(GLuint nbcells_reg, GLuint nbcells_tr, GLuint* nb_triangles_regular, GLuint* nb_triangles_transition, GLuint64* sync_time)
{
configureProgram();
if((int)Parameters::getInstance()->g_ground_truth == 2)
// glUseProgram(Parameters::getInstance()->g_programs[PROGRAM_GTCURV]);
//else if((int)Parameters::getInstance()->g_ground_truth == 2)
glUseProgram(Parameters::getInstance()->g_programs[PROGRAM_HIERARCHCURV]);
else if((int)Parameters::getInstance()->g_ground_truth == 1)
glUseProgram(Parameters::getInstance()->g_programs[PROGRAM_APPROXCURV]);
glBeginQuery(GL_PRIMITIVES_GENERATED, Parameters::getInstance()->g_query[QUERY_TRIANGLES]);
int res = (int)Parameters::getInstance()->g_tessel;
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, Parameters::getInstance()->g_buffers[BUFFER_INDIRECT_DRAWS]);
glBindVertexArray (Parameters::getInstance()->g_vertex_arrays[VERTEX_ARRAY_CURVATURE]);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, Parameters::getInstance()->g_feedbacks[FEEDBACK_TRIANGULATION]);
if (!Parameters::getInstance()->g_lightmode)
{
glBindBufferBase (
GL_TRANSFORM_FEEDBACK_BUFFER,
0u,
Parameters::getInstance()->g_buffers[BUFFER_EXPORT_TGL]
);
glBindBufferBase (
GL_TRANSFORM_FEEDBACK_BUFFER,
1u,
Parameters::getInstance()->g_buffers[BUFFER_EXPORT_DIRMIN]
);
glBindBufferBase (
GL_TRANSFORM_FEEDBACK_BUFFER,
2u,
Parameters::getInstance()->g_buffers[BUFFER_EXPORT_DIRMAX]
);
glBindBufferBase (
GL_TRANSFORM_FEEDBACK_BUFFER,
3u,
Parameters::getInstance()->g_buffers[BUFFER_EXPORT_NORMALES]
);
}
glBeginTransformFeedback(GL_TRIANGLES);
glMultiDrawElementsIndirect(
GL_TRIANGLES,
GL_UNSIGNED_INT,
NULL,
nbcells_reg*res*res*res,
0);
glEndQuery(GL_PRIMITIVES_GENERATED);
GLint64 start, stop;
glGetInteger64v(GL_TIMESTAMP, &start);
glGetQueryObjectuiv(Parameters::getInstance()->g_query[QUERY_TRIANGLES], GL_QUERY_RESULT, nb_triangles_regular);
glGetInteger64v(GL_TIMESTAMP, &stop);
//printf("After Curv %d\n", *nb_triangles_regular);
*sync_time = stop - start;
glBeginQuery(GL_PRIMITIVES_GENERATED, Parameters::getInstance()->g_query[QUERY_TRIANGLES]);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, Parameters::getInstance()->g_buffers[BUFFER_INDIRECT_DRAWS_TR]);
glBindVertexArray (Parameters::getInstance()->g_vertex_arrays[VERTEX_ARRAY_CURVATURE_TR]);
glMultiDrawElementsIndirect(
GL_TRIANGLES,
GL_UNSIGNED_INT,
NULL,
nbcells_tr*res*res,
0);
glEndQuery(GL_PRIMITIVES_GENERATED);
glGetInteger64v(GL_TIMESTAMP, &start);
glGetQueryObjectuiv(Parameters::getInstance()->g_query[QUERY_TRIANGLES], GL_QUERY_RESULT, nb_triangles_transition);
glGetInteger64v(GL_TIMESTAMP, &stop);
glEndTransformFeedback();
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glUseProgram(0);
*sync_time += (stop - start);
}
