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 loadParticles()
{
glGenVertexArrays(2, pvao);
glGenBuffers(2, posBuf);
GLfloat pos[MAX_PARTICLES * 3] = {0};
GLfloat step = 5.0f / MAX_PARTICLES;
for (GLuint x = 0; x < MAX_PARTICLES; ++x)
pos[x*3+1] = x * -step;
glBindVertexArray(pvao[0]);
glBindBuffer(GL_ARRAY_BUFFER, posBuf[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(pos), pos, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindVertexArray(pvao[1]);
glBindBuffer(GL_ARRAY_BUFFER, posBuf[1]);
glBufferData(GL_ARRAY_BUFFER, sizeof(pos), pos, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glGenTransformFeedbacks(2, feedback);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedback[0]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, posBuf[0]);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedback[1]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, posBuf[1]);
}
void piglit_init(int argc, char **argv)
{
GLuint id;
bool pass = true;
piglit_require_transform_feedback();
piglit_require_extension("GL_ARB_transform_feedback2");
glGenTransformFeedbacks(1, &id);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
pass = piglit_check_gl_error(0) && pass;
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, id + 1);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, id);
pass = piglit_check_gl_error(0) && pass;
glDeleteTransformFeedbacks(1, &id);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, id);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
unsigned int OpenglES3Device::attachVboToTransformFeedback(unsigned int feedbackHandle, unsigned int vboHandle, unsigned int attachIndex){
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedbackHandle);
this->evaluateErrorsAndLog("attachVboToTransformFeedback(1)");
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, attachIndex, vboHandle);
this->evaluateErrorsAndLog("attachVboToTransformFeedback(2)");
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
return feedbackHandle;
}
bool initFeedback()
{
glGenTransformFeedbacks(1, &FeedbackName);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, BufferName[buffer::FEEDBACK]);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
return this->checkError("initFeedback");
}
bool initFeedback()
{
// Generate a buffer object
glGenTransformFeedbacks(1, &FeedbackName);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, FeedbackArrayBufferName);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
return glf::checkError("initFeedback");
}
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 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();
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
// Compute the MVP (Model View Projection matrix)
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = reinterpret_cast<glm::mat4*>(glMapBufferRange(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT));
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
// Set the display viewport
glViewport(0, 0, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y));
// Clear color buffer
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
// First draw, capture the attributes
// Disable rasterisation, vertices processing only!
glEnable(GL_RASTERIZER_DISCARD);
glUseProgram(TransformProgramName);
glBindVertexArray(TransformVertexArrayName);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName);
glBeginTransformFeedback(GL_TRIANGLES);
glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1);
glEndTransformFeedback();
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glDisable(GL_RASTERIZER_DISCARD);
// Second draw, reuse the captured attributes
glUseProgram(FeedbackProgramName);
glBindVertexArray(FeedbackVertexArrayName);
glDrawTransformFeedback(GL_TRIANGLES, FeedbackName);
return true;
}
void
piglit_init(int argc, char **argv)
{
GLuint id;
piglit_require_gl_version(15);
piglit_require_GLSL();
piglit_require_extension("GL_EXT_transform_feedback");
piglit_require_extension("GL_ARB_transform_feedback2");
glGenTransformFeedbacks(1, &id);
if (glIsTransformFeedback(id)) {
fprintf(stderr, "id recognized incorrectly as a transform feedback object.\n");
piglit_report_result(PIGLIT_FAIL);
}
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, id);
if (!glIsTransformFeedback(id)) {
fprintf(stderr, "id not recognized correctly as a transform feedback object.\n");
piglit_report_result(PIGLIT_FAIL);
}
piglit_report_result(PIGLIT_PASS);
}
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);
bool ParticleSystem::InitParticleSystem(const glm::vec3& pos){
Particle particles[MAX_PARTICLES];
memset(&particles[0], 0.0f, sizeof(particles));
particles[0].type = PARTICLE_TYPE_LAUNCHER;
particles[0].pos = pos;
particles[0].vel = glm::vec3(0.0f,0.0f,0.0f);
particles[0].lifetimeMillisecs = 0.0f;
if (!mParticleShader.CreateParticleShader()){
return false;
}
if (!mSpriteShader.CreatePointSpriteShader()){
return false;
}
glGenTransformFeedbacks(2, mTransformFeedback);
glGenBuffers(2, mParticleBuffer);
for (int buff = 0; buff < 2; buff++){
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, mTransformFeedback[buff]);
glBindBuffer(GL_ARRAY_BUFFER,mParticleBuffer[buff]);
glBufferData(GL_ARRAY_BUFFER,sizeof(particles),particles,GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0,mParticleBuffer[buff]);
}
return true;
}
void FireWorkEffect::init()
{
FireWorkParticle particles[MAX_PARTICLES];
memset(particles, 0, sizeof(particles));
// we set the first particle as a Laucher
particles[0].type = PARTICLE_TYPE_LAUNCHER;
particles[0].position = glm::vec3(0.0f, 0.0f, 0.0f);
particles[0].velocity = glm::vec3(0.0f, 0.0f, 0.0f);
particles[0].lifetimeMillis = 0.0f;
// making two transform feedback
// we create two transformfeedback objects by calling glGenTransformFeedbacks
glGenTransformFeedbacks(2, m_transformFeedback);
// we create two buffers objects, one for each transform feedback objects
glGenBuffers(2, m_particleBuffer);
for (unsigned int i = 0; i < 2; i++)
{
// we start by binding GL_Transform_Feedback target to the transformfeedback object
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[i]);
// Next we bind the the corresponding buffer object to the GL_ARRAY_BUFFER
// that makes it a regular vertex buffer and load the contents of the particle array into it.
glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[i]);
glBufferData(GL_ARRAY_BUFFER, sizeof(particles), particles, GL_DYNAMIC_DRAW);
// This makes this buffer a transform feedback buffer and places it as index zero
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_particleBuffer[i]);
}
initRandomTexture(1000);
}
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);
}
bool init()
{
sys::info << "ogl::CParticleSystem::init()" << sys::endl;
mFirst = true;
mInit = true;
mActiveVBO = 0;
mActiveTBO = 1;
mTime = 0;
mPosition = math::vec3(0.0f, 0.0f, 0.0f);
_ZEROMEM(mVBOs);
_ZEROMEM(mTBOs);
_ZEROMEM(mVAOs);
CParticle particles[mNumParticles];
_ZEROMEM(particles);
particles[0].mType = CParticle::LAUNCHER;
particles[0].mPosition = mPosition;
particles[0].mVelocity = math::vec3(0.0f, 0.0001f, 0.0f);
particles[0].mLifetime = 0.0f;
glGenTransformFeedbacks(2, mTBOs);
glGenBuffers(2, mVBOs);
for(short i = 0; i < 2; i++)
{
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, mTBOs[i]);
glBindBuffer(GL_ARRAY_BUFFER, mVBOs[i]);
glBufferData(GL_ARRAY_BUFFER, sizeof(particles), particles, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, mVBOs[i]);
}
mUpdateProgram->enable();
mUpdateProgram->setUniform("u_fLauncherLifetime", 100.0f);
mUpdateProgram->setUniform("u_fPrimaryLifetime", 1000.0f);
mUpdateProgram->setUniform("u_fSecondaryLifetime", 2500.0f);
mUpdateProgram->setUniform("u_fTertiaryLifetime", 1500.0f);
mRenderProgram->enable();
mRenderProgram->setUniform("u_fBillboardSize", 0.1f);
glGenVertexArrays(2, mVAOs);
glBindVertexArray(mVAOs[0]);
glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, sizeof(CParticle), (const GLvoid*)((0) * sizeof(GLfloat))); // type
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(CParticle), (const GLvoid*)((0 + 1) * sizeof(GLfloat))); // position
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(CParticle), (const GLvoid*)((0 + 1 + 3) * sizeof(GLfloat))); // velocity
glEnableVertexAttribArray(2);
glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, sizeof(CParticle), (const GLvoid*)((0 + 1 + 3 + 3) * sizeof(GLfloat))); // lifetime
glEnableVertexAttribArray(3);
glBindVertexArray(mVAOs[1]);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(CParticle), (const GLvoid*)((0 + 1) * sizeof(GLfloat))); // position
glEnableVertexAttribArray(0);
return glCheckError();
void SmokeEffect::init()
{
SmokeParticle particles[MAX_PARTICLES];
memset(particles, 0, sizeof(particles));
// we set the first few particles as Lauchers
for (int i = 0; i < m_startingParticleCount; i++)
{
particles[i].type = PARTICLE_TYPE_LAUNCHER;
// particles[i].position = glm::vec3(0.0f, 0.0f, 0.0f);
// particles[i].velocity = glm::vec3(0.0f, 0.0f, 0.0f);
float x = utl::randFloat(-1.0f, 1.0f);
float y = 0.0;
float z = utl::randFloat(-1.0f, 1.0f);
float scale = 10.0f;
float vx = utl::randFloat(-scale, scale);
float vy = utl::randFloat(0.0, scale);
float vz = utl::randFloat(-scale, scale);
particles[i].position = glm::vec3(x, y, z);
particles[i].velocity = glm::vec3(vx, vy, vz);
particles[i].lifetimeMillis = 0.0f;
}
// making two transform feedback
// we create two transformfeedback objects by calling glGenTransformFeedbacks
glGenTransformFeedbacks(2, m_transformFeedback);
// we create two buffers objects, one for each transform feedback objects
glGenBuffers(2, m_particleBuffer);
for (unsigned int i = 0; i < 2; i++)
{
// we start by binding GL_Transform_Feedback target to the transformfeedback object
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[i]);
// Next we bind the the corresponding buffer object to the GL_ARRAY_BUFFER
// that makes it a regular vertex buffer and load the contents of the particle array into it.
glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[i]);
glBufferData(GL_ARRAY_BUFFER, sizeof(particles), particles, GL_DYNAMIC_DRAW);
// This makes this buffer a transform feedback buffer and places it as index zero
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_particleBuffer[i]);
}
initRandomTexture(1000);
m_textureId = utl::loadTexture("Assets/Images/smoke_sprite2.png");
}
/** * @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 (PointCloud& mesh, const Tucano::Camera& camera, const Tucano::Camera& lightTrackball)
{
Eigen::Vector4f viewport = camera.getViewport();
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
particletf_shader.bind();
glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, 0);
// Transform feedback 0
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedback[0]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0,mesh.getAttribute("in_Position")->getBufferID());
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,1,mesh.getAttribute("in_Velocity")->getBufferID());
// posBuf[0] -> mesh.getAttribute("in_Position")->getBufferID()
// Transform feedback 1
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedback[1]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0,mesh.getAttribute("in_Position")->getBufferID());
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,1,mesh.getAttribute("in_Velocity")->getBufferID());
// glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,1,velBuf[1]);
// glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,2,startTime[1]);
// sets all uniform variables for the phong shader
particletf_shader.setUniform("projectionMatrix", camera.getProjectionMatrix());
particletf_shader.setUniform("modelMatrix", mesh.getModelMatrix());
particletf_shader.setUniform("viewMatrix", camera.getViewMatrix());
particletf_shader.setUniform("lightViewMatrix", lightTrackball.getViewMatrix());
particletf_shader.setUniform("has_color", mesh.hasAttribute("in_Color"));
particletf_shader.setUniform("default_color", default_color);
// Disable rendering
glEnable(GL_RASTERIZER_DISCARD);
int drawBuf = 0;
// Bind the feedback object for the buffers to be drawn next
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedback[drawBuf]);
mesh.setAttributeLocation(particletf_shader);
glEnable(GL_DEPTH_TEST);
mesh.render();
particletf_shader.unbind();
// glEndTransformFeedback();
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 MVP = Projection * this->view() * Model;
*UniformPointer = MVP;
}
// Set the display viewport
glViewportIndexedf(0, 0.0f, 0.0f, WindowSize.x, WindowSize.y);
// Clear color buffer
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
// First draw, capture the attributes
// Disable rasterisation, vertices processing only!
glEnable(GL_RASTERIZER_DISCARD);
glBindProgramPipeline(PipelineName[program::TRANSFORM]);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindVertexArray(VertexArrayName[program::TRANSFORM]);
glBindVertexBuffer(semantic::buffer::STATIC, BufferName[buffer::VERTEX], 0, sizeof(glm::vec4));
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName);
glBeginTransformFeedback(GL_TRIANGLES);
glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1);
glEndTransformFeedback();
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glDisable(GL_RASTERIZER_DISCARD);
// Second draw, reuse the captured attributes
glBindProgramPipeline(PipelineName[program::FEEDBACK]);
glBindVertexArray(VertexArrayName[program::FEEDBACK]);
glBindVertexBuffer(semantic::buffer::STATIC, BufferName[buffer::FEEDBACK], 0, sizeof(glf::vertex_v4fc4f));
glDrawTransformFeedback(GL_TRIANGLES, FeedbackName);
return true;
}
bool ParticleSystem::InitParticleSystem(const Vector3f& Pos)
{
Particle Particles[MAX_PARTICLES];
ZERO_MEM(Particles);
Particles[0].Type = PARTICLE_TYPE_LAUNCHER;
Particles[0].Pos = Pos;
Particles[0].Vel = Vector3f(0.0f, 0.0001f, 0.0f);
Particles[0].LifetimeMillis = 0.0f;
glGenTransformFeedbacks(2, m_transformFeedback);
glGenBuffers(2, m_particleBuffer);
for (unsigned int i = 0; i < 2 ; i++) {
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[i]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_particleBuffer[i]);
glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[i]);
glBufferData(GL_ARRAY_BUFFER, sizeof(Particles), Particles, GL_DYNAMIC_DRAW);
}
if (!m_updateTechnique.Init()) {
return false;
}
m_updateTechnique.Enable();
m_updateTechnique.SetRandomTextureUnit(RANDOM_TEXTURE_UNIT_INDEX);
m_updateTechnique.SetLauncherLifetime(100.0f);
m_updateTechnique.SetShellLifetime(10000.0f);
m_updateTechnique.SetSecondaryShellLifetime(2500.0f);
if (!m_randomTexture.InitRandomTexture(1000)) {
return false;
}
m_randomTexture.Bind(RANDOM_TEXTURE_UNIT);
if (!m_billboardTechnique.Init()) {
return false;
}
m_billboardTechnique.Enable();
m_billboardTechnique.SetColorTextureUnit(COLOR_TEXTURE_UNIT_INDEX);
m_billboardTechnique.SetBillboardSize(0.01f);
m_pTexture = new Texture(GL_TEXTURE_2D, "../Content/fireworks_red.jpg");
if (!m_pTexture->Load()) {
return false;
}
return GLCheckError();
}
void TransformFeedback::bindInternal() {
GLuint& bound = Context::current()->state().transformFeedback->binding;
/* Already bound, nothing to do */
if(bound == _id) return;
/* Bind the transform feedback otherwise, which will also finally create it */
bound = _id;
_created = true;
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, _id);
}
void display()
{
// Compute the MVP (Model View Projection matrix)
glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
// Set the display viewport
glViewport(0, 0, Window.Size.x, Window.Size.y);
// Clear color buffer
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
// First draw, capture the attributes
// Disable rasterisation, vertices processing only!
glEnable(GL_RASTERIZER_DISCARD);
glUseProgram(TransformProgramName);
glUniformMatrix4fv(TransformUniformMVP, 1, GL_FALSE, &MVP[0][0]);
glBindVertexArray(TransformVertexArrayName);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName);
glBeginTransformFeedback(GL_TRIANGLES);
glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1);
glEndTransformFeedback();
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glDisable(GL_RASTERIZER_DISCARD);
// Second draw, reuse the captured attributes
glUseProgram(FeedbackProgramName);
glBindVertexArray(FeedbackVertexArrayName);
glDrawTransformFeedback(GL_TRIANGLES, FeedbackName);
glf::swapBuffers();
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
// Compute the MVP (Model View Projection matrix)
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 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, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y));
// Clear color buffer
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
// First draw, capture the attributes
// Disable rasterisation, vertices processing only!
glEnable(GL_RASTERIZER_DISCARD);
glUseProgram(TransformProgramName);
glUniformMatrix4fv(TransformUniformMVP, 1, GL_FALSE, &MVP[0][0]);
glBindVertexArray(TransformVertexArrayName);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName);
glBeginTransformFeedback(GL_TRIANGLES);
glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1);
glEndTransformFeedback();
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glDisable(GL_RASTERIZER_DISCARD);
// Second draw, reuse the captured attributes
glUseProgram(FeedbackProgramName);
glBindVertexArray(FeedbackVertexArrayName);
glDrawTransformFeedback(GL_TRIANGLES, FeedbackName);
return true;
}
bool do_query_gl(void)
{
if(!does_have_ARB_transform_feedback2())
{
return false;
}
GLuint x = 0;
glGenTransformFeedbacks(1, &x);
if(glGetError() != GL_NO_ERROR)
{
return false;
}
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, x);
if(glGetError() != GL_NO_ERROR)
{
return false;
}
if(glIsTransformFeedback(x) != GL_TRUE)
{
return false;
}
if(glGetError() != GL_NO_ERROR)
{
return false;
}
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
if(glGetError() != GL_NO_ERROR)
{
return false;
}
glDeleteTransformFeedbacks(1, &x);
if(glGetError() != GL_NO_ERROR)
{
return false;
}
return true;
}
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();
}
void ParticleSystem::UpdateParticles(int DeltaTimeMillis)
{
m_updateTechnique.Enable();
m_updateTechnique.SetTime(m_time);
m_updateTechnique.SetDeltaTimeMillis(DeltaTimeMillis);
m_updateTechnique.SetRandomColor();
m_randomTexture.Bind(GL_TEXTURE3);
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);
glEnableVertexAttribArray(4);
glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, sizeof(Particle), 0); // type
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)4); // position
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)16); // velocity
glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)28); // lifetime
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)40); // color
glBeginTransformFeedback(GL_POINTS);
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);
glDisableVertexAttribArray(4);
}
void
transform_feedback::unbind(render_context& in_context) const
{
assert(state().ok());
if (SCM_GL_CORE_OPENGL_CORE_VERSION >= SCM_GL_CORE_OPENGL_CORE_VERSION_400) {
assert(object_id() != 0);
const opengl::gl_core& glapi = in_context.opengl_api();
glapi.glBindTransformFeedback(object_target(), 0);
gl_assert(glapi, transform_feedback::unbind() after glBindTransformFeedback());
}
else {
unbind_stream_out_buffers(in_context);
}
gl_assert(in_context.opengl_api(), leaving transform_feedback:unbind());
}
void ParticleSystem::updateParticles(float dt)
{
glBindVertexArray(vao);
update_prog->bind();
update_prog->set("time", time);
update_prog->set("dt", dt * 1000.0f);
random_texture->bind(RANDOM_TEXTURE_UNIT);
glEnable(GL_RASTERIZER_DISCARD);
glBindBuffer(GL_ARRAY_BUFFER, particleBuffer[currVB]);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback[currTFB]);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glEnableVertexAttribArray(3);
glVertexAttribPointer(0,1,GL_FLOAT,GL_FALSE,sizeof(Particle),(void*) 0); // type
glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,sizeof(Particle),(void*) 4); // position
glVertexAttribPointer(2,3,GL_FLOAT,GL_FALSE,sizeof(Particle),(void*) 16); // velocity
glVertexAttribPointer(3,1,GL_FLOAT,GL_FALSE,sizeof(Particle),(void*) 28); // lifetime
glBeginTransformFeedback(GL_POINTS);
if (isFirst) {
glDrawArrays(GL_POINTS, 0, 1);
isFirst = false;
}
else {
glDrawTransformFeedback(GL_POINTS, transformFeedback[currVB]);
}
glEndTransformFeedback();
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glDisableVertexAttribArray(2);
glDisableVertexAttribArray(3);
}
void ParticleSystem::initWithPos(const glm::vec3& pos)
{
Particle particles[MAX_PARTICLES];
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
particles[0].type = PARTICLE_TYPE_LAUNCHER;
particles[0].pos = pos;
particles[0].vel = glm::vec3(0.0f,0.0001f,0.0f);
particles[0].lifetime = 0.0f;
glGenTransformFeedbacks(2,transformFeedback);
glGenBuffers(2, particleBuffer);
for(int i = 0; i < 2; i++) {
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback[i]);
glBindBuffer(GL_ARRAY_BUFFER, particleBuffer[i]);
glBufferData(GL_ARRAY_BUFFER, sizeof(particles), particles, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, particleBuffer[i]);
}
texture = new Texture("../assets/fireworks_red.jpg", GL_TEXTURE_2D);
random_texture = new RandomTexture(MAX_PARTICLES, GL_TEXTURE_1D);
update_prog->bind();
update_prog->set("random_texture", RANDOM_TEXTURE_UNIT_INDEX);
update_prog->set("launcher_lifetime", 250.0f);
update_prog->set("shell_lifetime", 1500.0f);
update_prog->set("secondary_shell_lifetime", 2500.0f);
render_prog->bind();
render_prog->set("color_map", COLOR_TEXTURE_UNIT_INDEX);
render_prog->set("billboard_size", 2.0f);
glBindVertexArray(0);
}
void GLSLShader::createVertexTFAttribute(GLuint location, const char *name, std::vector<Eigen::Vector4f> &data)
{
// GLuint feedback[1];
// glGenTransformFeedbacks(1, feedback);
// glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedback[0]);
// glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, posBuf);
// int size = data.size() * 4;
// GLuint buffer;
// glGenBuffers(1, &buffer);
// glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buffer);
// glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, size * sizeof(float), NULL, GL_DYNAMIC_COPY);
size = data.size() * 4;
float *dataB = new float[size];
int temp =0;
for(int i =0; i < size; i+=4)
{
dataB[i] = data[temp][0];
dataB[i+1] = data[temp][1];
dataB[i+2] = data[temp][2];
dataB[i+3] = data[temp][3];
temp++;
}
glGenTransformFeedbacks(2, m_transformFeedback);
glGenBuffers(2, m_particleBuffer);
for (unsigned int i = 0; i < 2 ; i++) {
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[i]);
glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[i]);
glBufferData(GL_ARRAY_BUFFER, size, dataB, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_particleBuffer[i]);
}
}
