void recursion( float startX,
float startY,
float startZ,
float startW)
{
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0,streamoutBufffer[0]);
glBeginTransformFeedback(GL_POINTS);
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, outputQuery);
glPointSize(1);
glBegin(GL_POINTS);
glVertex4f(startX, startY, startZ, startW);
glEnd();
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
glEndTransformFeedback();
GLint outPointCount = 0;
GLint succ = 0;
while(!succ)
glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT_AVAILABLE, &succ);
glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT, &outPointCount);
//std::cout << "points written: " << outPointCount << std::endl;
succ = 0;
glEnableClientState(GL_VERTEX_ARRAY);
int bb = 0;
while(outPointCount > 0)
{
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0,streamoutBufffer[(bb+1)%2]);
glBeginTransformFeedback(GL_POINTS);
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, outputQuery);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, streamoutBufffer[bb]);
glVertexPointer(4,GL_FLOAT,0,NULL);
glDrawArrays(GL_POINTS, 0, outPointCount);
glEndTransformFeedback();
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
while(!succ)
glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT_AVAILABLE, &succ);
glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT, &outPointCount);
succ = 0;
bb = (bb + 1) % 2;
}
glDisableClientState(GL_VERTEX_ARRAY);
}
enum piglit_result
piglit_display(void)
{
check_invalid_queries();
glClear(GL_COLOR_BUFFER_BIT);
glBeginTransformFeedback(GL_POINTS);
ctx.active = true;
check_active_paused_state("TransformFeedback started");
glPauseTransformFeedback();
ctx.paused = true;
check_active_paused_state("TransformFeedback paused");
glResumeTransformFeedback();
ctx.paused = false;
check_active_paused_state("TransformFeedback resumed");
glEndTransformFeedback();
ctx.active = false;
check_active_paused_state("TransformFeedback ended");
/* clean-up everything */
glDeleteBuffers(3, xfb_buf);
glDeleteBuffers(1, &input_buf);
glDeleteVertexArrays(1, &vao);
glDeleteProgram(prog);
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
protected:
void update(int dt)
{
mUpdateProgram->enable();
mUpdateProgram->setUniform("u_fTime", (float)mTime);
mUpdateProgram->setUniform("u_fDeltaTime", (float)dt);
mRandomTexture->bind(OGL_TEXTURE_GENERIC);
glEnable(GL_RASTERIZER_DISCARD);
glBindBuffer(GL_ARRAY_BUFFER, mVBOs[mActiveVBO]);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, mTBOs[mActiveTBO]);
glBindVertexArray(mVAOs[0]);
glBeginTransformFeedback(GL_POINTS); ///////////////////////////////////////////////////////////////////////////
if(mFirst)
{
glDrawArrays(GL_POINTS, 0, 1);
mFirst = false;
}
else
{
glDrawTransformFeedback(GL_POINTS, mTBOs[mActiveVBO]);
}
glEndTransformFeedback(); //////////////////////////////////////////////////////////////////////////////////////
// glExitIfError();
glBindVertexArray(0);
glDisable(GL_RASTERIZER_DISCARD);
void ParticleSystem::UpdateParticles(int deltaTimeMillis){
glBindTexture(GL_TEXTURE_2D, mTexture);
glEnable(GL_RASTERIZER_DISCARD);
glBindBuffer(GL_ARRAY_BUFFER, mParticleBuffer[mCurrVB]);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, mTransformFeedback[mCurrTFB]);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glEnableVertexAttribArray(3);
glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, sizeof(Particle), 0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)4);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)16);
glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)28);
glBeginTransformFeedback(GL_POINTS);
if (mIsFirst){
glDrawArrays(GL_POINTS, 0, 1);
mIsFirst = false;
}
else{
glDrawTransformFeedback(GL_POINTS, mTransformFeedback[mCurrVB]);
}
glEndTransformFeedback();
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(3);
}
void FeedbackTransformPass::DoRun()
{
glDisable(GL_DEPTH_TEST);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf->vbo);
{
Use shader(program);
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, query);
glBeginTransformFeedback(objtype);
glEnable(GL_RASTERIZER_DISCARD);
out->Draw(program);
glDisable(GL_RASTERIZER_DISCARD);
glEndTransformFeedback();
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
// performance loss of 15ms order
TODO_W("Move this query to the *start* of the transform, use the old objects in the drawing phase.");
glGetQueryObjectuiv(query, GL_QUERY_RESULT, &buf->count);
}
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
swap(*buf, *out);
}
void Tessellator::endTessellation()
{
glEndTransformFeedback();
glDisable(GL_RASTERIZER_DISCARD);
program->unbind();
glFlush();
}
void ParticleSystemProxy::simulateNoHeightmap()
{
int timediff = int(GUIEngine::getLatestDt() * 1000.f);
int active_count = getEmitter()->getMaxLifeTime() * getEmitter()->getMaxParticlesPerSecond() / 1000;
core::matrix4 matrix = getAbsoluteTransformation();
glUseProgram(ParticleShader::SimpleSimulationShader::Program);
glEnable(GL_RASTERIZER_DISCARD);
glUniform1i(ParticleShader::SimpleSimulationShader::uniform_dt, timediff);
glUniform1i(ParticleShader::SimpleSimulationShader::uniform_level, active_count);
glUniformMatrix4fv(ParticleShader::SimpleSimulationShader::uniform_sourcematrix, 1, GL_FALSE, matrix.pointer());
glUniform1f(ParticleShader::SimpleSimulationShader::uniform_size_increase_factor, size_increase_factor);
glBindVertexArray(current_simulation_vao);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfb_buffers[1]);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, count);
glEndTransformFeedback();
glBindVertexArray(0);
glDisable(GL_RASTERIZER_DISCARD);
std::swap(tfb_buffers[0], tfb_buffers[1]);
std::swap(current_rendering_vao, non_current_rendering_vao);
std::swap(current_simulation_vao, non_current_simulation_vao);
}
void FireParticleSystem::Process(float delta_t)
{
UpdateParameters(delta_t);
glUseProgram(m_animateProgram.program); CHECK_GL_ERRORS;
setUniform(m_animateProgram.program, "delta_t", delta_t);
setUniform(m_animateProgram.program, "wind", m_wind);
//setUniform(m_animateProgram.program, "epicenter", float3(0,1,0));
glBindBuffer(GL_TEXTURE_BUFFER, m_posAndSizeBuffers[1-m_currPinPongId]); CHECK_GL_ERRORS;
bindTextureBuffer(m_animateProgram.program, 1, "vertPosBuffer", m_vertexPosTBO); CHECK_GL_ERRORS;
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_vertexPosTBO); CHECK_GL_ERRORS;
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_posAndSizeBuffers[m_currPinPongId]); CHECK_GL_ERRORS;
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1, m_velAndHPBuffers[m_currPinPongId]); CHECK_GL_ERRORS;
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 2, m_randBuffers[m_currPinPongId]); CHECK_GL_ERRORS;
glEnable(GL_RASTERIZER_DISCARD);
glBeginTransformFeedback(GL_POINTS); CHECK_GL_ERRORS;
glBindVertexArray(m_animVAOs[1-m_currPinPongId]); CHECK_GL_ERRORS;
glDrawArrays(GL_POINTS, 0, m_particlesNum); CHECK_GL_ERRORS;
glBindVertexArray(0);
glEndTransformFeedback(); CHECK_GL_ERRORS;
glDisable(GL_RASTERIZER_DISCARD);
glBindBuffer(GL_TEXTURE_BUFFER, 0);
glBindTexture(GL_TEXTURE_BUFFER, 0);
m_currPinPongId = 1 - m_currPinPongId;
m_lastDeltaTime = delta_t;
}
void ParticleEmitter::Draw(Camera* camera)
{
GLuint otherBuffer = (activeBuffer + 1) % 2;
updateShader.setFloat("time", glfwGetTime());
updateShader.setFloat("deltatime", Time::deltaTime());
updateShader.setVec3("emitterPosition", vec3(5 * sin(glfwGetTime()), 3, 5 * cos(glfwGetTime())));
//updateShader.setVec3("emitterPosition", position);
//updateShader.setVec3("emitterPosition", camera->getPosition() + vec3(glm::normalize(-camera->getWorldTransform()[2]) * 10.f));
updateShader.useProgram();
glEnable(GL_RASTERIZER_DISCARD);
glBindVertexArray(vao[activeBuffer]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbo[otherBuffer]);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, maxParticles);
glEndTransformFeedback();
glDisable(GL_RASTERIZER_DISCARD);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
drawShader.setMat4("projectionView", camera->getProjectionViewTransform());
drawShader.setVec3("cameraPos", camera->getPosition());
drawShader.useProgram();
glBindVertexArray(vao[otherBuffer]);
glDrawArrays(GL_POINTS, 0, maxParticles);
activeBuffer = otherBuffer;
}
void GPUParticle::shaderUpdate(float time, float delta){
glUseProgram(uiUpdateShader);
// bind time information
unsigned int location = glGetUniformLocation(uiUpdateShader,"time");
if (time == 0.0f){time = Utility::getTotalTime();}
glUniform1f(location, time);
location = glGetUniformLocation(uiUpdateShader,"deltaTime");
if (delta == 0.0f){delta = Utility::getDeltaTime();}
glUniform1f(location, delta);
// disable rasterisation
glEnable(GL_RASTERIZER_DISCARD);
// bind the buffer we will update
glBindVertexArray(uivao[uiActiveBuffer]);
// work out the "other" buffer
uiOtherBuffer = (uiActiveBuffer + 1) % 2;
// bind the buffer we will update into as points and begin transform feedback
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, uivbo[ uiOtherBuffer ]);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, uiMaxParticles);
// disable transform feedback and enable rasterisation again
glEndTransformFeedback();
glDisable(GL_RASTERIZER_DISCARD);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
}
void updateTF (Tucano::Mesh& mesh, const Tucano::Camera& camera, const Tucano::Camera& lightTrackball)
{
qDebug() << "UPDATING TF2";
tf.bind();
//mesh.setAttributeLocation(tf);
glEnable(GL_RASTERIZER_DISCARD);
mesh.bindBuffers();
Tucano::Misc::errorCheckFunc(__FILE__, __LINE__);
//VertexAttribute* va = mesh.getAttribute("nPos");
write_va->disable();
//glDisableVertexAttribArray(mesh.getAttributeLocation("nPos"));
read_va->enable(tf.getAttributeLocation("inPos"));
Tucano::Misc::errorCheckFunc(__FILE__, __LINE__);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, write_va->getBufferID());
glBeginTransformFeedback(GL_POINTS);
glEnable(GL_DEPTH_TEST);
mesh.renderPoints();
glEndTransformFeedback();
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
mesh.unbindBuffers();
glDisable(GL_RASTERIZER_DISCARD);
tf.unbind();
}
void Particles::update()
{
glEnable(GL_RASTERIZER_DISCARD);
glBindVertexArray(m_vao[m_currVB]);
GL_CHECK_ERRORS_MSG("Particles update 1");
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[m_currTFB]);
GL_CHECK_ERRORS_MSG("Particles update 2");
glBeginTransformFeedback(GL_POINTS);
if (m_isFirst) {
m_isFirst = false;
glDrawArrays(GL_POINTS, 0, NUM_RAIN);
GL_CHECK_ERRORS_MSG("Particles update 6");
}
else {
glDrawTransformFeedback(GL_POINTS, m_transformFeedback[m_currVB]);
GL_CHECK_ERRORS_MSG("Particles update 7");
}
glEndTransformFeedback();
GL_CHECK_ERRORS_MSG("Particles update 8");
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glBindVertexArray(0);
glDisable(GL_RASTERIZER_DISCARD);
}
void TransformFeedback::calculate(std::shared_ptr<GLBuffer> outBuffer, int vertexCount, GLenum primitiveType)
{
SCOPED_BIND(mProgramData);
glEnable(GL_RASTERIZER_DISCARD);
CHECK_GL_ERROR();
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, outBuffer->getId());
CHECK_GL_ERROR();
GLenum transformPrimitiveType = primitiveType;
switch (primitiveType)
{
case GL_POINTS:
transformPrimitiveType = GL_POINTS; break;
case GL_LINES:
case GL_LINE_LOOP:
case GL_LINE_STRIP:
transformPrimitiveType = GL_LINES; break;
case GL_TRIANGLES:
case GL_TRIANGLE_STRIP:
case GL_TRIANGLE_FAN:
transformPrimitiveType = GL_TRIANGLES; break;
}
glBeginTransformFeedback(transformPrimitiveType);
CHECK_GL_ERROR();
glDrawArrays(primitiveType, 0, vertexCount);
CHECK_GL_ERROR();
glEndTransformFeedback();
CHECK_GL_ERROR();
glDisable(GL_RASTERIZER_DISCARD);
CHECK_GL_ERROR();
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
GLfloat *v;
int i;
GLuint q, num_prims;
glClear(GL_COLOR_BUFFER_BIT);
glGenQueries(1, &q);
glBeginQuery(GL_PRIMITIVES_GENERATED_EXT, q);
glBeginTransformFeedback(GL_POINTS);
glBindBuffer(GL_ARRAY_BUFFER, vert_buf);
glVertexPointer(3, GL_FLOAT, 0, 0);
glEnable(GL_VERTEX_ARRAY);
glDrawArrays(GL_POINTS, 0, 3);
glEndTransformFeedback();
glEndQuery(GL_PRIMITIVES_GENERATED);
glGetQueryObjectuiv(q, GL_QUERY_RESULT, &num_prims);
glDeleteQueries(1, &q);
printf("%u primitives generated:\n", num_prims);
if (num_prims != NUM_VERTS) {
printf("Incorrect number of prims generated.\n");
printf("Found %u, expected %u\n", num_prims, NUM_VERTS);
pass = false;
}
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, xfb_buf);
v = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, GL_READ_ONLY);
for (i = 0; i < num_prims; i++) {
printf("vertex %2d: pos %5.2g, %5.2g, %5.2g, %5.2g "
"color %5.2g, %5.2g, %5.2g, %5.2g\n", i,
v[i*8+0], v[i*8+1], v[i*8+2], v[i*8+3],
v[i*8+4], v[i*8+5], v[i*8+6], v[i*8+7]);
/* spot-check results */
if (!equal(v[i*8+1], 0.1)) {
printf("Incorrect Y coord for point %d: %f\n",
i, v[i*8+1]);
pass = false;
}
if (!equal(v[i*8+4], 0.9)) {
printf("Incorrect red value for point %d: %f\n",
i, v[i*8+4]);
pass = false;
}
}
glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void BotanySystem::Construct(QuadNode* p_node)
{
glEnable(GL_RASTERIZER_DISCARD);
for(auto entity = p_node->m_indices.begin(); entity != p_node->m_indices.end(); ++entity)
{
// Reset mesh counter to resuse old meshes.
if(m_meshCount >= BOTANY_MESHES_SIZE)
{
m_meshCount = 0;
}
RootForce::Renderable* renderable = m_world->GetEntityManager()->GetComponent<RootForce::Renderable>(m_quadTree.m_entities[(*entity)]);
renderable->m_material->m_textures[Render::TextureSemantic::TEXTUREMAP]->Bind(6);
renderable->m_model->m_meshes[0]->Bind();
// Fetch an empty mesh to output data into.
Render::MeshInterface* mesh = m_meshes[m_meshCount];
// If a cell already uses this mesh, remove it.
if(m_cells[m_cellDirectory[m_meshCount]].m_meshSize != 0)
{
for(int i = 0; i < m_cells[m_cellDirectory[m_meshCount]].m_meshSize; i++)
{
m_cells[m_cellDirectory[m_meshCount]].m_meshIndices[i] = -1;
}
m_cells[m_cellDirectory[m_meshCount]].m_meshSize = 0;
}
// Store which cell this mesh belong to.
m_cellDirectory[m_meshCount] = p_node->m_id;
mesh->BindTransformFeedback();
int flipped = 0;
if(renderable->m_material->m_flipped)
flipped = 1;
// Apply update program.
m_effect->GetTechniques()[flipped]->GetPrograms()[0]->Apply();
renderable->m_model->m_meshes[0]->SetPrimitiveType(GL_PATCHES);
glBeginTransformFeedback(GL_POINTS);
renderable->m_model->m_meshes[0]->Draw();
glEndTransformFeedback();
//AMD fix
// glFlush();
renderable->m_model->m_meshes[0]->SetPrimitiveType(GL_TRIANGLES);
renderable->m_model->m_meshes[0]->Unbind();
m_cells[p_node->m_id].m_meshIndices[m_cells[p_node->m_id].m_meshSize] = m_meshCount;
m_cells[p_node->m_id].m_meshSize++;
m_meshCount++;
}
glDisable(GL_RASTERIZER_DISCARD);
}
static bool
do_test_vector(const struct test_set *test, const struct test_vector *vector)
{
GLuint primitives_generated;
int i;
const GLint *readback;
unsigned expected_output_points;
unsigned actual_output_points;
bool pass = true;
printf("Testing %s(%d vertices)\n",
piglit_get_prim_name(tests->prim_type),
vector->num_input_vertices);
/* Run vertices through the pipeline */
glBeginQuery(GL_PRIMITIVES_GENERATED, generated_query);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(test->prim_type, 0, vector->num_input_vertices);
glEndTransformFeedback();
glEndQuery(GL_PRIMITIVES_GENERATED);
/* Check that the GS got invoked the right number of times */
glGetQueryObjectuiv(generated_query, GL_QUERY_RESULT,
&primitives_generated);
if (primitives_generated != vector->expected_gs_invocations) {
printf(" Expected %d GS invocations, got %d\n",
vector->expected_gs_invocations, primitives_generated);
pass = false;
}
expected_output_points =
vector->expected_gs_invocations * test->vertices_per_prim;
actual_output_points = primitives_generated * test->vertices_per_prim;
/* Check the data output by the GS */
readback = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
if (memcmp(readback, vector->expected_results,
expected_output_points * sizeof(GLint)) != 0) {
pass = false;
}
/* Output details if the result was wrong */
if (!pass) {
printf(" Expected vertex IDs:");
for (i = 0; i < expected_output_points; i++)
printf(" %d", vector->expected_results[i]);
printf("\n");
printf(" Actual vertex IDs: ");
for (i = 0; i < actual_output_points; i++)
printf(" %d", readback[i]);
printf("\n");
}
glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
return pass;
}
/** * @brief Render the mesh given a camera and light, using a Phong shader
* @param mesh Given mesh
* @param camera Given camera
* @param lightTrackball Given light camera
*/
void render (Tucano::Mesh& mesh, const Tucano::Camera& camera, const Tucano::Camera& lightTrackball)
{
Eigen::Vector4f viewport = camera.getViewport();
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
tftest_shader.bind();
// sets all uniform variables for the phong shader
tftest_shader.setUniform("projectionMatrix", camera.getProjectionMatrix());
tftest_shader.setUniform("modelMatrix", mesh.getModelMatrix());
tftest_shader.setUniform("viewMatrix", camera.getViewMatrix());
tftest_shader.setUniform("lightViewMatrix", lightTrackball.getViewMatrix());
tftest_shader.setUniform("has_color", mesh.hasAttribute("in_Color"));
tftest_shader.setUniform("default_color", default_color);
tftest_shader.setUniform("tf", 1.0);
cout << "set attrib TF\n";
mesh.setAttributeLocation(tftest_shader);
glEnable(GL_RASTERIZER_DISCARD);
mesh.bindBuffers();
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, mesh.getAttribute("nPos")->getBufferID());
glBeginTransformFeedback(GL_POINTS);
glEnable(GL_DEPTH_TEST);
mesh.renderPoints();
glEndTransformFeedback();
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
mesh.unbindBuffers();
glDisable(GL_RASTERIZER_DISCARD);
tftest_shader.unbind();
printActiveAttribs(tftest_shader.getShaderProgram(), "TF");
printActiveAttribs(tfrender.getShaderProgram(), "RENDER");
// RENDERING
tfrender.bind();
// sets all uniform variables for the phong shader
tfrender.setUniform("projectionMatrix", camera.getProjectionMatrix());
tfrender.setUniform("modelMatrix", mesh.getModelMatrix());
tfrender.setUniform("viewMatrix", camera.getViewMatrix());
tfrender.setUniform("lightViewMatrix", lightTrackball.getViewMatrix());
tfrender.setUniform("has_color", mesh.hasAttribute("in_Color"));
tfrender.setUniform("default_color", default_color);
// tfrender.setUniform("tf", 1.0);
cout << "set attrib RENDER\n";
mesh.setAttributeLocation(tfrender);
mesh.bindBuffers();
mesh.renderElements();
mesh.unbindBuffers();
tfrender.unbind();
}
void OpenglES3Device::transformUsingFeedback(VertexArrayObject* vao, unsigned int vertexCount, TransformFeedbackObject* tfo){
// TODO: Chicos, no hagan esto en casa, es un asco, refactor urgente
glEnable(GL_RASTERIZER_DISCARD);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfo->getHandler());
this->evaluateErrorsAndLogOnlyInDebugMode("transformMeshUsingFeedback(1)");
glBeginTransformFeedback(GL_TRIANGLES);
glBindVertexArray( vao->getHandler());
glDrawArrays( GL_TRIANGLES, 0, vertexCount);
glEndTransformFeedback();
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glDisable(GL_RASTERIZER_DISCARD);
}
void ParticleSystemProxy::simulateHeightmap()
{
int timediff = int(GUIEngine::getLatestDt() * 1000.f);
int active_count = getEmitter()->getMaxLifeTime() * getEmitter()->getMaxParticlesPerSecond() / 1000;
core::matrix4 matrix = getAbsoluteTransformation();
glUseProgram(HeightmapSimulationShader::Program);
glEnable(GL_RASTERIZER_DISCARD);
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_position);
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_lifetime);
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_velocity);
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_size);
glBindBuffer(GL_ARRAY_BUFFER, tfb_buffers[0]);
glVertexAttribPointer(HeightmapSimulationShader::attrib_position, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)0);
glVertexAttribPointer(HeightmapSimulationShader::attrib_lifetime, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(3 * sizeof(float)));
glVertexAttribPointer(HeightmapSimulationShader::attrib_velocity, 4, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(4 * sizeof(float)));
glVertexAttribPointer(HeightmapSimulationShader::attrib_size, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(7 * sizeof(float)));
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_initial_position);
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_initial_lifetime);
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_initial_velocity);
glEnableVertexAttribArray(HeightmapSimulationShader::attrib_initial_size);
glBindBuffer(GL_ARRAY_BUFFER, initial_values_buffer);
glVertexAttribPointer(HeightmapSimulationShader::attrib_initial_position, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)0);
glVertexAttribPointer(HeightmapSimulationShader::attrib_initial_lifetime, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(3 * sizeof(float)));
glVertexAttribPointer(HeightmapSimulationShader::attrib_initial_velocity, 4, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(4 * sizeof(float)));
glVertexAttribPointer(HeightmapSimulationShader::attrib_initial_size, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid*)(7 * sizeof(float)));
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfb_buffers[1]);
glUniform1i(HeightmapSimulationShader::uniform_dt, timediff);
glUniform1i(HeightmapSimulationShader::uniform_level, active_count);
glUniformMatrix4fv(HeightmapSimulationShader::uniform_sourcematrix, 1, GL_FALSE, matrix.pointer());
glUniform1f(HeightmapSimulationShader::uniform_size_increase_factor, size_increase_factor);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_BUFFER, heightmaptexture);
glUniform1i(HeightmapSimulationShader::uniform_heightmap, 2);
glUniform1f(HeightmapSimulationShader::uniform_track_x, track_x);
glUniform1f(HeightmapSimulationShader::uniform_track_z, track_z);
glUniform1f(HeightmapSimulationShader::uniform_track_x_len, track_x_len);
glUniform1f(HeightmapSimulationShader::uniform_track_z_len, track_z_len);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, count);
glEndTransformFeedback();
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_position);
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_lifetime);
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_velocity);
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_size);
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_initial_position);
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_initial_lifetime);
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_initial_velocity);
glDisableVertexAttribArray(HeightmapSimulationShader::attrib_initial_size);
glDisable(GL_RASTERIZER_DISCARD);
std::swap(tfb_buffers[0], tfb_buffers[1]);
}
enum piglit_result piglit_display(void)
{
GLint input_index = glGetAttribLocation(prog, "input_uint");
GLuint *readback;
GLuint buffer[BUFFER_SIZE];
GLuint expected[BUFFER_SIZE];
unsigned int i;
GLboolean pass = GL_TRUE;
glUseProgram(prog);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glVertexAttribIPointer(input_index, 1, GL_UNSIGNED_INT,
sizeof(GLuint), &verts);
glEnableVertexAttribArray(input_index);
pass = piglit_check_gl_error(0) && pass;
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_buf);
memset(buffer, 0xffffffff, sizeof(buffer));
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, sizeof(buffer), buffer,
GL_STREAM_READ);
glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb_buf,
additional_offset,
sizeof(buffer) - additional_offset);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, 4);
glEndTransformFeedback();
pass = piglit_check_gl_error(0) && pass;
readback = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
pass = piglit_check_gl_error(0) && pass;
/* Figure out expected output */
memset(expected, 0xffffffff, sizeof(expected));
for (i = 0; i < EXPECTED_NUM_OUTPUTS; ++i) {
expected[i + additional_offset / 4] =
0x00010203u + 0x04040404u * i;
}
/* Check output */
for (i = 0; i < BUFFER_SIZE; ++i) {
if (expected[i] != readback[i]) {
printf("readback[%u]: %u, expected: %u\n", i,
readback[i], expected[i]);
pass = GL_FALSE;
}
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
const GLint *readback;
GLuint buf;
void *initial_data;
int i;
GLuint prog = piglit_build_simple_program_unlinked(vs_text, NULL);
glTransformFeedbackVaryings(prog, ARRAY_SIZE(varyings), varyings,
GL_INTERLEAVED_ATTRIBS);
glLinkProgram(prog);
if (!piglit_link_check_status(prog) ||
!piglit_check_gl_error(GL_NO_ERROR)) {
piglit_report_result(PIGLIT_FAIL);
}
glUseProgram(prog);
/* Create transform feedback buffer and pre-load it with
* garbage.
*/
glGenBuffers(1, &buf);
initial_data = malloc(sizeof(expected_xfb_result));
memset(initial_data, 0xcc, sizeof(expected_xfb_result));
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, sizeof(expected_xfb_result),
initial_data, GL_STREAM_READ);
free(initial_data);
/* Run the test */
glEnable(GL_RASTERIZER_DISCARD);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, 1);
glEndTransformFeedback();
/* Check output */
readback = glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0,
sizeof(expected_xfb_result),
GL_MAP_READ_BIT);
for (i = 0; i < ARRAY_SIZE(expected_xfb_result); i++) {
if (readback[i] != expected_xfb_result[i]) {
printf("XFB[%i] == %i, expected %i\n", i, readback[i],
expected_xfb_result[i]);
pass = false;
}
}
glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
static GLboolean
draw(GLuint vs, GLuint fs, int num_xfb_varyings,
int max_varyings, const char **xfb_varyings)
{
GLboolean pass = GL_TRUE;
int offset;
for (offset = 0; offset + num_xfb_varyings <= max_varyings; ++offset) {
GLuint prog;
float initial_buffer[MAX_VARYING * 6][4];
prog = glCreateProgram();
glAttachShader(prog, vs);
glAttachShader(prog, fs);
glTransformFeedbackVaryings(prog, num_xfb_varyings,
xfb_varyings + offset,
GL_INTERLEAVED_ATTRIBS);
glLinkProgram(prog);
if (!piglit_link_check_status(prog))
piglit_report_result(PIGLIT_FAIL);
glUseProgram(prog);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_buf);
memset(initial_buffer, 0, sizeof(initial_buffer));
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER,
sizeof(initial_buffer), initial_buffer,
GL_STREAM_READ);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb_buf);
glBeginTransformFeedback(GL_TRIANGLES);
piglit_draw_rect(coord_from_index(offset),
coord_from_index(num_xfb_varyings - 1),
10,
10);
glEndTransformFeedback();
pass = check_xfb_output(max_varyings, num_xfb_varyings,
offset, xfb_varyings);
glDeleteProgram(prog);
if (!pass) {
break;
}
}
return pass;
}
void FireWorkEffect::update(Pipeline& p, Renderer* r)
{
// m_randomTexture.Bind(RANDOM_TEXTURE_UNIT);
p.pushMatrix();
r->setUniLocs(p);
// We have another draw call later on that does that.
// Calling glEnable() with the GL_RASTERIZER_DISCARD flag
// tells the pipeline to discard all primitives before
// they reach the rasterizer (but after the optional transform feedback stage).
glEnable(GL_RASTERIZER_DISCARD);
glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[m_currVB]);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[m_currTFB]);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glEnableVertexAttribArray(3);
glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, sizeof(FireWorkParticle), 0); // type
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(FireWorkParticle), (const GLvoid*)4); // position
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(FireWorkParticle), (const GLvoid*)16); // velocity
glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, sizeof(FireWorkParticle), (const GLvoid*)28); // lifetime
glBeginTransformFeedback(GL_POINTS);
// first drawing function, since we know we're drawing one point
if (m_isFirst)
{
glDrawArrays(GL_POINTS, 0, 1);
m_isFirst = false;
}
else
{
glDrawTransformFeedback(GL_POINTS, m_transformFeedback[m_currVB]);
}
glEndTransformFeedback();
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(3);
glDisable(GL_RASTERIZER_DISCARD);
p.popMatrix();
}
__forceinline void render()
{
const float pos = sound::get_position();
glUseProgram(dynamics_prog_obj);
glUniform1f(dynamics_prog_sample_count_uniform_loc, pos);
const size_t crnt_pos_vbo_id = (vbo_switch+0)%3;
const size_t new_pos_vbo_id = (vbo_switch+1)%3;
const size_t prev_pos_vbo_id = (vbo_switch+2)%3;
glEnable(GL_RASTERIZER_DISCARD);
glBindBuffer(GL_ARRAY_BUFFER, vbo[prev_pos_vbo_id]);
glEnableVertexAttribArray(0);
glVertexAttribDivisor(0, 0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (float*)(0));
glBindBuffer(GL_ARRAY_BUFFER, vbo[crnt_pos_vbo_id]);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (float*)(0));
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbo[new_pos_vbo_id]);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, NUM_LINES);
glEndTransformFeedback();
#if 0
//for debugging.
float result[NUM_VERTICES_PER_LINE*3];
glGetBufferSubData(GL_TRANSFORM_FEEDBACK_BUFFER, 0, sizeof(result), &result);
#endif
glUseProgram(particle_prog_obj);
glUniform1f(particle_prog_sample_count_uniform_loc, pos);
glDisable(GL_RASTERIZER_DISCARD);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, vbo[new_pos_vbo_id]);
glVertexAttribDivisor(0, 1);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (float*)(0));
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0);
// glDrawArrays(GL_TRIANGLES, 0, num_particles*3);
glDrawArraysInstanced(GL_TRIANGLE_STRIP/*GL_LINE_STRIP*/, 0, 4, NUM_LINES);
++vbo_switch;
}
bool render()
{
glm::ivec2 WindowSize(this->getWindowSize());
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * this->view() * Model;
// Set the display viewport
glViewport(0, 0, WindowSize.x, WindowSize.y);
// Clear color buffer with black
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// First draw, capture the attributes
{
// Disable rasterisation, vertices processing only!
glEnable(GL_RASTERIZER_DISCARD);
glUseProgram(ProgramName[program::TRANSFORM]);
glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, BufferName[buffer::POSITION]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1, BufferName[buffer::COLOR]);
glBindVertexArray(VertexArrayName[program::TRANSFORM]);
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, QueryName);
glBeginTransformFeedback(GL_TRIANGLES);
glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1);
glEndTransformFeedback();
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
glDisable(GL_RASTERIZER_DISCARD);
}
// Second draw, reuse the captured attributes
{
glUseProgram(ProgramName[program::FEEDBACK]);
GLuint PrimitivesWritten = 0;
glGetQueryObjectuiv(QueryName, GL_QUERY_RESULT, &PrimitivesWritten);
glBindVertexArray(VertexArrayName[program::FEEDBACK]);
glDrawArraysInstanced(GL_TRIANGLES, 0, PrimitivesWritten * 3, 1);
}
return true;
}
void renderParticles()
{
glPointSize(10);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedback[drawBuf]);
glBeginTransformFeedback(GL_POINTS);
glBindVertexArray(pvao[1-drawBuf]);
glDrawArrays(GL_POINTS, 0, MAX_PARTICLES);
glEndTransformFeedback();
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
drawBuf = 1 - drawBuf;
}
void GlobalModel::initialise(const FeedbackBuffer & rawFeedback,
const FeedbackBuffer & filteredFeedback)
{
initProgram->Bind();
glBindBuffer(GL_ARRAY_BUFFER, rawFeedback.vbo);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, 0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f)));
glBindBuffer(GL_ARRAY_BUFFER, filteredFeedback.vbo);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f) * 2));
glEnable(GL_RASTERIZER_DISCARD);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, vbos[target].second);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbos[target].first);
glBeginTransformFeedback(GL_POINTS);
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, countQuery);
//It's ok to use either fid because both raw and filtered have the same amount of vertices
glDrawTransformFeedback(GL_POINTS, rawFeedback.fid);
glEndTransformFeedback();
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
glGetQueryObjectuiv(countQuery, GL_QUERY_RESULT, &count);
glDisable(GL_RASTERIZER_DISCARD);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
initProgram->Unbind();
glFinish();
}
void GLRenderer::render(float dt) {
const float FPS_CLAMP = 1.0f / 15.0f;
if (dt > FPS_CLAMP)
dt = FPS_CLAMP;
mElapsedTime += dt;
freeGLBindings();
glm::mat4 mvp = mProjectionMatrix * mViewMatrix;
glm::vec4 right = mViewMatrix[0];
glm::vec4 up = mViewMatrix[1];
mFeedbackShader->enable();
glUniform1f(mFeedbackShader->mDeltaTimeHandle, dt);
glUniform1f(mFeedbackShader->mBirthRateHandle, BIRTH_RATE);
glUniform3f(mFeedbackShader->mMousePositionHandle, mMousePosition.x, mMousePosition.y, mMousePosition.z);
glUniform1f(mFeedbackShader->mElapsedTimeHandle, mElapsedTime);
glUniform1f(mFeedbackShader->mSizeHandle, BILLBOARD_SIZE);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mVelocityTexture);
glBindVertexArray(mVAO[(mCurrentBuffer+1)%BUFFER_COUNT]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, mVBO[mCurrentBuffer]);
glEnable(GL_RASTERIZER_DISCARD);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, MAX_PARTICLES);
glEndTransformFeedback();
glDisable(GL_RASTERIZER_DISCARD);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
mBillboardShader->enable();
glUniformMatrix4fv(mBillboardShader->mModelViewProjectionHandle, 1, GL_FALSE, glm::value_ptr(mvp));
glUniform3f(mBillboardShader->mRightHandle, right.x, right.y, right.z);
glUniform3f(mBillboardShader->mUpHandle, up.x, up.y, up.z);
glUniform1f(mBillboardShader->mBillboardSizeHandle, BILLBOARD_SIZE);
glBindVertexArray(mVAO[mCurrentBuffer]);
glDrawArrays(GL_POINTS, 0, MAX_PARTICLES);
// mTestShader->enable();
// glUniformMatrix4fv(mTestShader->mMVP, 1, GL_FALSE, glm::value_ptr(mvp));
// glUniform1f(mTestShader->mElapsedTimeHandle, mElapsedTime);
// glActiveTexture(GL_TEXTURE0);
// glBindTexture(GL_TEXTURE_2D, mVelocityTexture);
// mScreenQuadModel->drawArrays();
// mTestShader->disable();
mCurrentBuffer = (mCurrentBuffer + 1) % BUFFER_COUNT;
}
void Clouds::moveClouds()
{
glBindVertexArray(vao_cloudParticleBuffer_Read);
glEnable(GL_RASTERIZER_DISCARD);
moveShader->useProgram();
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbo_cloudParticleBuffer_Write[0]); // specify targets
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1, vbo_cloudParticleBuffer_Write[1]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 2, vbo_cloudParticleBuffer_Write[2]);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, maxNumCloudParticles);
glEndTransformFeedback();
glDisable(GL_RASTERIZER_DISCARD);
}
void VertexBuffer::DrawToFeedbackBuffer(VertexBuffer* target, ShaderProgram* shader_program, bool keep_fragments)
{
GLDEBUG();
if(!keep_fragments)
glEnable(GL_RASTERIZER_DISCARD);
ShaderProgram::SetActiveProgram(shader_program);
GLchar const* strings[] = { "gl_Position" };
// glTransformFeedbackVaryings(shader_program->program_id, 1, strings, GL_SEPARATE_ATTRIBS);
// we must re-link the program to force some things to update (i think?)
glLinkProgram(shader_program->program_id);
GLuint query;
glGenQueries(1, &query);
GLuint out_buf;
glGenBuffers(1, &out_buf);
glBindBuffer(GL_ARRAY_BUFFER, out_buf);
glBufferData(GL_ARRAY_BUFFER, 4 * num_verts * sizeof(float), NULL, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, out_buf);
// glBindVertexArray(transform vertex array name);
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, query);
glBeginTransformFeedback((GLenum)storage_mode);
glDrawArrays((GLenum)storage_mode, 0, num_verts);
glEndTransformFeedback();
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
glDisable(GL_RASTERIZER_DISCARD);
GLuint primitives_written = 0;
glGetQueryObjectuiv(query, GL_QUERY_RESULT, &primitives_written);
glDeleteQueries(1, &query);
/*
TODO: put results into target
*/
GLDEBUG();
}
