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);
}
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);
}
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 TransformFeedback::create(){
WT_ASSERT(!mCreated, "Object alraedy created");
glGenTransformFeedbacks(1, &mHandle);
mCreated = true;
}
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]);
}
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;
}
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");
}
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");
}
/**
* @brief Load and initialize shaders
*/
virtual void initialize (void)
{
// searches in default shader directory (/shaders) for shader files phongShader.(vert,frag,geom,comp)
loadShader(particletf_shader, "particleTF") ;
const char * outputNames[] = { "Position", "Velocity" };
particletf_shader.initializeTF(2, outputNames);
glGenTransformFeedbacks(2, feedback);
}
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();
}
bool ParticleSystem::init() {
const char* sVaryings[NUM_PARTICLE_ATTRIBUTES] = {
"vPositionOut",
"vVelocityOut",
"vColorOut",
"fLifeTimeOut",
"fSizeOut",
"iTypeOut",
};
//Updating program shader
for(int i = 0; i < NUM_PARTICLE_ATTRIBUTES; i++) {
glTransformFeedbackVaryings(updateShader->getProgramID(), 6, sVaryings, GL_INTERLEAVED_ATTRIBS);
}
//updateShader->link();
//Rendering program shader
//add shaders to the program
//link program
glGenTransformFeedbacks(1, &transformFeedbackBuffer);
glGenQueries(1, &query);
glGenBuffers(2, particleBuffer);
glGenVertexArrays(2, particleVAO);
Particle partInit;
partInit.type = PARTICLE_TYPE_GENERATOR;
for(int i = 0; i < 2; i++) {
glBindVertexArray(particleVAO[i]);
glBindBuffer(GL_ARRAY_BUFFER, particleBuffer[i]);
glBufferData(GL_ARRAY_BUFFER, sizeof(Particle) * MAX_PARTICLES_ON_SCENE, NULL, GL_DYNAMIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Particle), &partInit);
for(int i = 0; i < NUM_PARTICLE_ATTRIBUTES; i++) {
glEnableVertexAttribArray(i);
}
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)0); // Position
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)12); // Velocity
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)24); // Color
glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)36); // Lifetime
glVertexAttribPointer(4, 1, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)40); // Size
glVertexAttribPointer(5, 1, GL_INT, GL_FALSE, sizeof(Particle), (const GLvoid*)44); // Type
}
currentReadBuffer = 0;
numParticles = 1;
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 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]);
}
}
bool ParticleSystem::InitParticleSystem(const glm::vec3 Pos)
{
Particle Particles[MAX_PARTICLES];
ZERO_MEM(Particles);
Particles[0].Type = PARTICLE_TYPE_LAUNCHER;
Particles[0].Pos = Pos;
Particles[0].Vel = glm::vec3(0.0f, 0.00000010f, 0.0f);
Particles[0].LifetimeMillis = 0.0f;
Particles[0].Color = glm::vec3(0.0f, 0.0f, 1.0f);
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, sizeof(Particles), Particles, GL_DYNAMIC_DRAW);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_particleBuffer[i]);
}
if (!m_updateTechnique.Initilize())
{
printf("Error Loading Update\n");
return false;
}
m_updateTechnique.Enable();
m_updateTechnique.SetRandomTextureUnit(3);
m_updateTechnique.SetLauncherLifetime(250.0f);
m_updateTechnique.SetShellLifetime(10000.0f);
m_updateTechnique.SetSecondaryShellLifetime(2500.0f);
if (!m_randomTexture.InitRandomTexture(1000))
{
printf("Error Loading Random\n");
return false;
}
m_randomTexture.Bind(GL_TEXTURE3);
if (!m_billboardTechnique.Initilize("billboard_fireworks"))
{
printf("Error Loading Billboard\n");
return false;
}
m_billboardTechnique.Enable();
m_billboardTechnique.SetColorTextureUnit(0);
m_billboardTechnique.SetBillboardSize(1.0f);
m_pTexture = new Texture(GL_TEXTURE_2D, "../content/fireworks_red.jpg");
if (!m_pTexture->Load()) {
return false;
}
return GLCheckError();
}
GlTransformFeedback GlTransformFeedback::create()
{
GlTransformFeedback r(Ptr(new GlTransformFeedbackImpl));
glGenTransformFeedbacks(1, &r->id);
return r;
}
void piglit_init(int argc, char **argv)
{
static const char *varyings[] = {"x"};
GLuint buffers[3];
GLuint vao;
GLuint prog;
GLuint queries[4];
GLuint xfb[2];
bool pass = true;
#ifdef PIGLIT_USE_OPENGL
piglit_require_transform_feedback();
piglit_require_GLSL_version(130);
piglit_require_extension("GL_ARB_vertex_array_object");
piglit_require_extension("GL_ARB_transform_feedback2");
#endif
/* This is all just the boot-strap work for the test.
*/
glGenTransformFeedbacks(ARRAY_SIZE(xfb), xfb);
glGenBuffers(ARRAY_SIZE(buffers), buffers);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buffers[0]);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 1024, NULL, GL_STREAM_READ);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buffers[1]);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 1024, NULL, GL_STREAM_READ);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, 0);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, buffers[2]);
glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 1 * sizeof(GLfloat), 0);
glEnableVertexAttribArray(0);
glGenQueries(ARRAY_SIZE(queries), queries);
prog = piglit_build_simple_program_unlinked(vstext, fstext);
glTransformFeedbackVaryings(prog, 1, varyings, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(prog);
if (!piglit_link_check_status(prog)) {
pass = false;
goto done;
}
glUseProgram(prog);
glEnable(GL_RASTERIZER_DISCARD);
/* Here's the actual test.
*/
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, xfb[0]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buffers[0]);
glBeginTransformFeedback(GL_POINTS);
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, queries[0]);
glDrawArrays(GL_POINTS, 0, 4);
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
glPauseTransformFeedback();
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, xfb[1]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buffers[1]);
glBeginTransformFeedback(GL_POINTS);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, queries[1]);
glDrawArrays(GL_POINTS, 4, 2);
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
glPauseTransformFeedback();
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, xfb[0]);
glResumeTransformFeedback();
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, queries[2]);
glDrawArrays(GL_POINTS, 6, 4);
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
glEndTransformFeedback();
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, xfb[1]);
glResumeTransformFeedback();
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, queries[3]);
glDrawArrays(GL_POINTS, 10, 2);
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
glEndTransformFeedback();
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glBindVertexArray(0);
/* The first XFB should have 8 primitives generated, and the buffer
* object should contain the values {1.0, 2.0, 3.0, 4.0, 7.0, 8.0,
* 9.0, 10.0}.
*/
{
static const float expected_xfb_data[] = {
1.0, 2.0, 3.0, 4.0, 7.0, 8.0, 9.0, 10.0
};
glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
pass = check_results(1, ARRAY_SIZE(expected_xfb_data),
expected_xfb_data,
queries[0], queries[2])
&& pass;
}
/* The second XFB should have 4 primitives generated, and the buffer
* object should contain the values {5.0, 6.0, 11.0, 12.0}.
*/
{
static const float expected_xfb_data[] = {
5.0, 6.0, 11.0, 12.0
};
glBindBuffer(GL_ARRAY_BUFFER, buffers[1]);
pass = check_results(2, ARRAY_SIZE(expected_xfb_data),
expected_xfb_data,
queries[1], queries[3])
&& pass;
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
done:
glBindVertexArray(0);
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(ARRAY_SIZE(buffers), buffers);
glDeleteQueries(ARRAY_SIZE(queries), queries);
glDeleteTransformFeedbacks(ARRAY_SIZE(xfb), xfb);
glUseProgram(0);
glDeleteProgram(prog);
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
TransformFeedbackObjImplHardware::TransformFeedbackObjImplHardware()
{
glGenTransformFeedbacks( 1, &mId );
}
static void genObjects(GLsizei n, GLuint* objects) {
glGenTransformFeedbacks(n, objects);
}
// initialize OpenGL buffers for this particle fountain
bool ParticleEmitter::initGL() {
if (Utils::GLReturnedError("ParticleEmitter::initGL - on entry")) return false;
// generate handles for whole bundle
glGenVertexArrays(2, particleArray);
// generate two buffers for each attribute (to be used with transform feedback)
glGenBuffers(2, posBuf);
glGenBuffers(2, velBuf);
glGenBuffers(2, startBuf);
glGenBuffers(1, &initVelBuf);
// set up bundles 0 and 1
for (int i = 0; i < 2; i++) {
// bind bundle
glBindVertexArray(particleArray[i]);
// set up position buffer
glBindBuffer(GL_ARRAY_BUFFER, posBuf[i]);
glBufferData(GL_ARRAY_BUFFER, positions.size() * sizeof(vec3), &positions[0], GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(vec3), 0);
// set up velocity buffer
glBindBuffer(GL_ARRAY_BUFFER, velBuf[i]);
glBufferData(GL_ARRAY_BUFFER, velocities.size() * sizeof(vec3), &velocities[0], GL_STATIC_DRAW);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(vec3), 0);
// set up initial velocity buffer
// set up start time buffer
glBindBuffer(GL_ARRAY_BUFFER, startBuf[i]);
glBufferData(GL_ARRAY_BUFFER, startTimes.size() * sizeof(GLfloat), &startTimes[0], GL_STATIC_DRAW);
glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, sizeof(float), 0);
// set up initial velocity buffer
glBindBuffer(GL_ARRAY_BUFFER, initVelBuf);
glBufferData(GL_ARRAY_BUFFER, velocities.size() * sizeof(vec3), &velocities[0], GL_STATIC_DRAW);
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(vec3), 0);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glEnableVertexAttribArray(3);
}
// unbind handles
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
// set up transform feedback objects
glGenTransformFeedbacks(2, feedback);
// transform feedback 0 and 1
for (int i = 0; i < 2; i++) {
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedback[i]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, posBuf[i]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 1, velBuf[i]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 2, startBuf[i]);
}
/*
glGenVertexArrays(1, &vertexArrayHandle);
glBindVertexArray(vertexArrayHandle);
glGenBuffers(1, &vertexBufferHandle);
glBindBuffer(GL_ARRAY_BUFFER, vertexBufferHandle);
glBufferData(GL_ARRAY_BUFFER, particles.size() * sizeof(ParticleData), &particles[0], GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), 0);
glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (void*) sizeof(vec3));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
*/
if (Utils::GLReturnedError("ParticleEmitter::initGL - on exit")) return false;
return true;
}
TransformFeedback::TransformFeedback(GLsizei howMany) :
GLObject(howMany), mTarget(GL_TRANSFORM_FEEDBACK) {
glGenTransformFeedbacks(mHowMany, mHandles);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL40_nglGenTransformFeedbacks(JNIEnv *__env, jclass clazz, jint n, jlong idsAddress, jlong __functionAddress) {
GLuint *ids = (GLuint *)(intptr_t)idsAddress;
glGenTransformFeedbacksPROC glGenTransformFeedbacks = (glGenTransformFeedbacksPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glGenTransformFeedbacks(n, ids);
}
void ViewportArrayApplication::Initialize(const char * title)
{
int i;
base::Initialize(title);
glGenTransformFeedbacks(1, &xfb);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, xfb);
sort_prog = glCreateProgram();
static const char sort_vs_source[] =
"#version 410\n"
"\n"
"uniform mat4 model_matrix;\n"
"\n"
"layout (location = 0) in vec4 position;\n"
"layout (location = 1) in vec3 normal;\n"
"\n"
"out vec3 vs_normal;\n"
"\n"
"void main(void)\n"
"{\n"
" vs_normal = (model_matrix * vec4(normal, 0.0)).xyz;\n"
" gl_Position = model_matrix * position;\n"
"}\n";
static const char sort_gs_source[] =
"#version 410\n"
"\n"
"layout (triangles) in;\n"
"layout (points, max_vertices = 3) out;\n"
"\n"
"uniform mat4 projection_matrix;\n"
"\n"
"in vec3 vs_normal[];\n"
"\n"
"layout (stream = 0) out vec4 rf_position;\n"
"layout (stream = 0) out vec3 rf_normal;\n"
"\n"
"layout (stream = 1) out vec4 lf_position;\n"
"layout (stream = 1) out vec3 lf_normal;\n"
"\n"
"void main(void)\n"
"{\n"
" vec4 A = gl_in[0].gl_Position;\n"
" vec4 B = gl_in[1].gl_Position;\n"
" vec4 C = gl_in[2].gl_Position;\n"
" vec3 AB = (B - A).xyz;\n"
" vec3 AC = (C - A).xyz;\n"
" vec3 face_normal = cross(AB, AC);\n"
" int i;\n"
"\n"
" if (face_normal.x < 0.0)\n"
" {\n"
" for (i = 0; i < gl_in.length(); i++)\n"
" {\n"
" rf_position = projection_matrix * (gl_in[i].gl_Position - vec4(30.0, 0.0, 0.0, 0.0));\n"
" rf_normal = vs_normal[i];\n"
" EmitStreamVertex(0);\n"
" }\n"
" EndStreamPrimitive(0);\n"
" }\n"
" else\n"
" {\n"
" for (i = 0; i < gl_in.length(); i++)\n"
" {\n"
" lf_position = projection_matrix * (gl_in[i].gl_Position + vec4(30.0, 0.0, 0.0, 0.0));\n"
" lf_normal = vs_normal[i];\n"
" EmitStreamVertex(1);\n"
" }\n"
" EndStreamPrimitive(1);\n"
" }\n"
"}\n";
vglAttachShaderSource(sort_prog, GL_VERTEX_SHADER, sort_vs_source);
vglAttachShaderSource(sort_prog, GL_GEOMETRY_SHADER, sort_gs_source);
static const char * varyings[] =
{
"rf_position", "rf_normal",
"gl_NextBuffer",
"lf_position", "lf_normal"
};
glTransformFeedbackVaryings(sort_prog, 5, varyings, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(sort_prog);
glUseProgram(sort_prog);
model_matrix_pos = glGetUniformLocation(sort_prog, "model_matrix");
projection_matrix_pos = glGetUniformLocation(sort_prog, "projection_matrix");
glGenVertexArrays(2, vao);
glGenBuffers(2, vbo);
for (i = 0; i < 2; i++)
{
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, vbo[i]);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 1024 * 1024 * sizeof(GLfloat), NULL, GL_DYNAMIC_COPY);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, i, vbo[i]);
glBindVertexArray(vao[i]);
glBindBuffer(GL_ARRAY_BUFFER, vbo[i]);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(vmath::vec4) + sizeof(vmath::vec3), NULL);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(vmath::vec4) + sizeof(vmath::vec3), (GLvoid *)(sizeof(vmath::vec4)));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
}
render_prog = glCreateProgram();
static const char render_vs_source[] =
"#version 410\n"
"\n"
"layout (location = 0) in vec4 position;\n"
"layout (location = 1) in vec3 normal;\n"
"\n"
"out vec3 vs_normal;\n"
"\n"
"void main(void)\n"
"{\n"
" vs_normal = normal;\n"
" gl_Position = position;\n"
"}\n";
static const char render_fs_source[] =
"#version 410\n"
"\n"
"layout (location = 0) out vec4 color;\n"
"\n"
"uniform vec4 pass_color;\n"
"\n"
"in vec3 vs_normal;\n"
"\n"
"void main(void)\n"
"{\n"
" color = pass_color * (0.2 + pow(abs(vs_normal.z), 4.0)) + vec4(1.0, 1.0, 1.0, 0.0) * pow(abs(vs_normal.z), 37.0);\n"
"}\n";
vglAttachShaderSource(render_prog, GL_VERTEX_SHADER, render_vs_source);
vglAttachShaderSource(render_prog, GL_FRAGMENT_SHADER, render_fs_source);
glLinkProgram(render_prog);
object.LoadFromVBM("D:/svn/Vermilion-Book/trunk/Code/media/ninja.vbm", 0, 1, 2);
}
Particles::Particles(shared_ptr<ShaderGroup> m_updateShader, shared_ptr<ShaderGroup> m_renderShader) {
this->m_updateShader = m_updateShader;
this->m_renderShader = m_renderShader;
m_currVB = 0;
m_currTFB = 1;
m_isFirst = true;
float g_radiusRange = 150;
float g_heightRange = 35;
vector<particle_t> particles;
for (int i = 0; i < NUM_RAIN; i++)
{
particle_t pt;
particles.push_back(pt);
float SeedX;
float SeedY = random()*g_heightRange;
float SeedZ;
bool pointIsInside = false;
while (!pointIsInside)
{
SeedX = random() - 0.5f;
SeedZ = random() - 0.5f;
if (sqrt(SeedX*SeedX + SeedZ*SeedZ) <= 0.5f)
pointIsInside = true;
}
//save these random locations for reinitializing rain particles that have fallen out of bounds
SeedX *= g_radiusRange;
SeedZ *= g_radiusRange;
particles[i].seed = glm::vec3(SeedX, SeedY, SeedZ);
float SpeedX = 40.0f*(random() / 10.0f);
float SpeedZ = 40.0f*(random() / -10.0f);
float SpeedY = -40.0f*(random() / 10.0f);
particles[i].speed = glm::vec3(SpeedX, SpeedY, SpeedZ);
particles[i].pos = glm::vec3(SeedX, SeedY, SeedZ);
particles[i].type = floor(random() * 6 + 1);
particles[i].random = 0.5f + random()*0.5f;
}
glGenVertexArrays(2, m_vao);
glGenTransformFeedbacks(2, m_transformFeedback);
glGenBuffers(2, m_particleBuffer);
GL_CHECK_ERRORS();
for (unsigned int i = 0; i < 2; i++) {
//init buffers
glBindVertexArray(m_vao[i]);
glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[i]);
glBufferData(GL_ARRAY_BUFFER, sizeof(particle_t) * particles.size(), particles.data(), GL_DYNAMIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(particle_t), 0); // vec3 pos
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(particle_t), (const GLvoid*)(3 * sizeof GLfloat)); // vec3 seed
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(particle_t), (const GLvoid*)(6 * sizeof GLfloat)); // vec3 speed
glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, sizeof(particle_t), (const GLvoid*)(9 * sizeof GLfloat)); // float random
glVertexAttribPointer(4, 1, GL_FLOAT, GL_FALSE, sizeof(particle_t), (const GLvoid*)(10 * sizeof GLfloat)); // int type
glBindBuffer(GL_ARRAY_BUFFER, 0);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
glEnableVertexAttribArray(3);
glEnableVertexAttribArray(4);
glBindVertexArray(0);
//bind feedback buffers
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[i]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_particleBuffer[i]);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
}
GL_CHECK_ERRORS();
}
void TransformFeedback::createImplementationDefault() {
glGenTransformFeedbacks(1, &_id);
_created = false;
}
GlobalModel::GlobalModel()
: target(0),
renderSource(1),
bufferSize(MAX_VERTICES * Vertex::SIZE),
count(0),
initProgram(loadProgramFromFile("init_unstable.vert")),
drawProgram(loadProgramFromFile("draw_feedback.vert", "draw_feedback.frag")),
drawSurfelProgram(loadProgramFromFile("draw_global_surface.vert", "draw_global_surface.frag", "draw_global_surface.geom")),
dataProgram(loadProgramFromFile("data.vert", "data.frag", "data.geom")),
updateProgram(loadProgramFromFile("update.vert")),
unstableProgram(loadProgramGeomFromFile("copy_unstable.vert", "copy_unstable.geom")),
renderBuffer(TEXTURE_DIMENSION, TEXTURE_DIMENSION),
updateMapVertsConfs(TEXTURE_DIMENSION, TEXTURE_DIMENSION, GL_RGBA32F, GL_LUMINANCE, GL_FLOAT),
updateMapColorsTime(TEXTURE_DIMENSION, TEXTURE_DIMENSION, GL_RGBA32F, GL_LUMINANCE, GL_FLOAT),
updateMapNormsRadii(TEXTURE_DIMENSION, TEXTURE_DIMENSION, GL_RGBA32F, GL_LUMINANCE, GL_FLOAT),
deformationNodes(NODE_TEXTURE_DIMENSION, 1, GL_LUMINANCE32F_ARB, GL_LUMINANCE, GL_FLOAT)
{
vbos = new std::pair<GLuint, GLuint>[2];
float * vertices = new float[bufferSize];
memset(&vertices[0], 0, bufferSize);
glGenTransformFeedbacks(1, &vbos[0].second);
glGenBuffers(1, &vbos[0].first);
glBindBuffer(GL_ARRAY_BUFFER, vbos[0].first);
glBufferData(GL_ARRAY_BUFFER, bufferSize, &vertices[0], GL_STREAM_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenTransformFeedbacks(1, &vbos[1].second);
glGenBuffers(1, &vbos[1].first);
glBindBuffer(GL_ARRAY_BUFFER, vbos[1].first);
glBufferData(GL_ARRAY_BUFFER, bufferSize, &vertices[0], GL_STREAM_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
delete [] vertices;
vertices = new float[Resolution::getInstance().numPixels() * Vertex::SIZE];
memset(&vertices[0], 0, Resolution::getInstance().numPixels() * Vertex::SIZE);
glGenTransformFeedbacks(1, &newUnstableFid);
glGenBuffers(1, &newUnstableVbo);
glBindBuffer(GL_ARRAY_BUFFER, newUnstableVbo);
glBufferData(GL_ARRAY_BUFFER, Resolution::getInstance().numPixels() * Vertex::SIZE, &vertices[0], GL_STREAM_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
delete [] vertices;
std::vector<Eigen::Vector2f> uv;
for(int i = 0; i < Resolution::getInstance().width(); i++)
{
for(int j = 0; j < Resolution::getInstance().height(); j++)
{
uv.push_back(Eigen::Vector2f(((float)i / (float)Resolution::getInstance().width()) + 1.0 / (2 * (float)Resolution::getInstance().width()),
((float)j / (float)Resolution::getInstance().height()) + 1.0 / (2 * (float)Resolution::getInstance().height())));
}
}
uvSize = uv.size();
glGenBuffers(1, &uvo);
glBindBuffer(GL_ARRAY_BUFFER, uvo);
glBufferData(GL_ARRAY_BUFFER, uvSize * sizeof(Eigen::Vector2f), &uv[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
frameBuffer.AttachColour(*updateMapVertsConfs.texture);
frameBuffer.AttachColour(*updateMapColorsTime.texture);
frameBuffer.AttachColour(*updateMapNormsRadii.texture);
frameBuffer.AttachDepth(renderBuffer);
updateProgram->Bind();
int locUpdate[3] =
{
glGetVaryingLocationNV(updateProgram->programId(), "vPosition0"),
glGetVaryingLocationNV(updateProgram->programId(), "vColor0"),
glGetVaryingLocationNV(updateProgram->programId(), "vNormRad0"),
};
glTransformFeedbackVaryingsNV(updateProgram->programId(), 3, locUpdate, GL_INTERLEAVED_ATTRIBS);
updateProgram->Unbind();
dataProgram->Bind();
int dataUpdate[3] =
{
glGetVaryingLocationNV(dataProgram->programId(), "vPosition0"),
glGetVaryingLocationNV(dataProgram->programId(), "vColor0"),
glGetVaryingLocationNV(dataProgram->programId(), "vNormRad0"),
};
glTransformFeedbackVaryingsNV(dataProgram->programId(), 3, dataUpdate, GL_INTERLEAVED_ATTRIBS);
dataProgram->Unbind();
unstableProgram->Bind();
int unstableUpdate[3] =
{
glGetVaryingLocationNV(unstableProgram->programId(), "vPosition0"),
glGetVaryingLocationNV(unstableProgram->programId(), "vColor0"),
glGetVaryingLocationNV(unstableProgram->programId(), "vNormRad0"),
};
glTransformFeedbackVaryingsNV(unstableProgram->programId(), 3, unstableUpdate, GL_INTERLEAVED_ATTRIBS);
unstableProgram->Unbind();
initProgram->Bind();
int locInit[3] =
{
glGetVaryingLocationNV(initProgram->programId(), "vPosition0"),
glGetVaryingLocationNV(initProgram->programId(), "vColor0"),
glGetVaryingLocationNV(initProgram->programId(), "vNormRad0"),
};
glTransformFeedbackVaryingsNV(initProgram->programId(), 3, locInit, GL_INTERLEAVED_ATTRIBS);
glGenQueries(1, &countQuery);
//Empty both transform feedbacks
glEnable(GL_RASTERIZER_DISCARD);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, vbos[0].second);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbos[0].first);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, 0);
glEndTransformFeedback();
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, vbos[1].second);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbos[1].first);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, 0);
glEndTransformFeedback();
glDisable(GL_RASTERIZER_DISCARD);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
initProgram->Unbind();
}
/* trivial tests to get/set labels on all the different types of objects */
static bool
test_object_label_types()
{
#define numObjects 12
GLsizei length[numObjects]; /* create a fresh variable for each object to test */
GLchar label[numObjects][TestLabelLen + 1];
bool pass = true;
enum test_object_indices {
BUFFER_IDX, SHADER_IDX, PROGRAM_IDX, VERTEX_ARRAY_IDX, RENDERBUFFER_IDX,
FRAMEBUFFER_IDX, QUERY_IDX, PROGRAM_PIPELINE_IDX, TRANSFORM_FEEDBACK_IDX,
SAMPLER_IDX, TEXTURE_IDX, DISPLAY_LIST_IDX
};
GLuint buffer;
GLuint shader;
GLuint program;
GLuint vertexArray;
GLuint query;
#ifdef PIGLIT_USE_OPENGL
GLuint programPipeline;
#endif
GLuint transformFeedback;
GLuint sampler;
GLuint texture;
GLuint renderbuffer;
GLuint framebuffer;
#ifdef PIGLIT_USE_OPENGL
GLuint displayList;
#endif
/* Test BUFFER */
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
ObjectLabel(GL_BUFFER, buffer, -1, TestLabel);
GetObjectLabel(GL_BUFFER, buffer, TestLabelLen + 1, &length[BUFFER_IDX], label[BUFFER_IDX]);
check_label_and_length(label[BUFFER_IDX], length[BUFFER_IDX], "GL_BUFFER");
glDeleteBuffers(1, &buffer);
if (piglit_get_gl_version() >= 20) {
/* Test SHADER */
shader = glCreateShader(GL_FRAGMENT_SHADER);
ObjectLabel(GL_SHADER, shader, -1, TestLabel);
GetObjectLabel(GL_SHADER, shader, TestLabelLen + 1,
&length[SHADER_IDX], label[SHADER_IDX]);
check_label_and_length(label[SHADER_IDX], length[SHADER_IDX], "GL_SHADER");
glDeleteShader(shader);
/* Test PROGRAM */
program = glCreateProgram();
ObjectLabel(GL_PROGRAM, program, -1, TestLabel);
GetObjectLabel(GL_PROGRAM, program, TestLabelLen + 1,
&length[PROGRAM_IDX], label[PROGRAM_IDX]);
check_label_and_length(label[PROGRAM_IDX], length[PROGRAM_IDX], "GL_PROGRAM");
glDeleteProgram(program);
}
/* GL or GLES >= 3.0 supports vertex arrays*/
if (piglit_get_gl_version() >= 30) {
/* Test VERTEX_ARRAY */
glGenVertexArrays(1, &vertexArray);
glBindVertexArray(vertexArray);
ObjectLabel(GL_VERTEX_ARRAY, vertexArray, -1, TestLabel);
GetObjectLabel(GL_VERTEX_ARRAY, vertexArray, TestLabelLen + 1,
&length[VERTEX_ARRAY_IDX], label[VERTEX_ARRAY_IDX]);
check_label_and_length(label[VERTEX_ARRAY_IDX], length[VERTEX_ARRAY_IDX], "GL_VERTEX_ARRAY");
glDeleteVertexArrays(1, &vertexArray);
}
/* GLES supports render buffer and frame buffer since 2.0 */
if (piglit_is_gles() || piglit_get_gl_version() >= 30) {
/* Test RENDERBUFFER */
glGenRenderbuffers(1, &renderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
ObjectLabel(GL_RENDERBUFFER, renderbuffer, -1, TestLabel);
GetObjectLabel(GL_RENDERBUFFER, renderbuffer, TestLabelLen + 1,
&length[RENDERBUFFER_IDX], label[RENDERBUFFER_IDX]);
check_label_and_length(label[RENDERBUFFER_IDX], length[RENDERBUFFER_IDX], "GL_RENDERBUFFER");
glDeleteRenderbuffers(1, &renderbuffer);
/* Test FRAMEBUFFER */
glGenFramebuffers(1, &framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
ObjectLabel(GL_FRAMEBUFFER, framebuffer, -1, TestLabel);
GetObjectLabel(GL_FRAMEBUFFER, framebuffer, TestLabelLen + 1,
&length[FRAMEBUFFER_IDX], label[FRAMEBUFFER_IDX]);
check_label_and_length(label[FRAMEBUFFER_IDX], length[FRAMEBUFFER_IDX], "GL_FRAMEBUFFER");
glDeleteFramebuffers(1, &framebuffer);
}
/* GLES >= 3.0 or GL compat */
if (!piglit_is_gles() || piglit_get_gl_version() >= 30) {
/* Test QUERY */
glGenQueries(1, &query);
glBeginQuery(GL_TIME_ELAPSED, query);
glEndQuery(GL_TIME_ELAPSED);
ObjectLabel(GL_QUERY, query, -1, TestLabel);
GetObjectLabel(GL_QUERY, query, TestLabelLen + 1, &length[QUERY_IDX], label[QUERY_IDX]);
check_label_and_length(label[QUERY_IDX], length[QUERY_IDX], "GL_TEST_QUERY");
glDeleteQueries(1, &query);
}
#ifdef PIGLIT_USE_OPENGL
/* Test PROGRAM_PIPELINE */
if (piglit_is_extension_supported("GL_ARB_separate_shader_objects")) {
glGenProgramPipelines(1, &programPipeline);
glBindProgramPipeline(programPipeline);
ObjectLabel(GL_PROGRAM_PIPELINE, programPipeline, -1, TestLabel);
GetObjectLabel(GL_PROGRAM_PIPELINE, programPipeline, TestLabelLen + 1,
&length[PROGRAM_PIPELINE_IDX], label[PROGRAM_PIPELINE_IDX]);
check_label_and_length(label[PROGRAM_PIPELINE_IDX], length[PROGRAM_PIPELINE_IDX], "GL_PROGRAM_PIPELINE");
glDeleteProgramPipelines(1, &programPipeline);
}
#endif /* PIGLIT_USE_OPENGL */
/* Test TRANSFORM_FEEDBACK */
if ((piglit_is_gles() && piglit_get_gl_version() >= 30) ||
piglit_is_extension_supported("GL_ARB_transform_feedback2")) {
glGenTransformFeedbacks(1, &transformFeedback);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback);
ObjectLabel(GL_TRANSFORM_FEEDBACK, transformFeedback, -1, TestLabel);
GetObjectLabel(GL_TRANSFORM_FEEDBACK, transformFeedback, TestLabelLen + 1,
&length[TRANSFORM_FEEDBACK_IDX], label[TRANSFORM_FEEDBACK_IDX]);
check_label_and_length(label[TRANSFORM_FEEDBACK_IDX], length[TRANSFORM_FEEDBACK_IDX], "GL_TRANSFORM_FEEDBACK");
glDeleteTransformFeedbacks(1, &transformFeedback);
}
/* Test SAMPLER */
if ((piglit_is_gles() && piglit_get_gl_version() >= 30) ||
piglit_is_extension_supported("GL_ARB_sampler_objects")) {
glGenSamplers(1, &sampler);
glBindSampler(0, sampler);
ObjectLabel(GL_SAMPLER, sampler, -1, TestLabel);
GetObjectLabel(GL_SAMPLER, sampler, TestLabelLen + 1, &length[SAMPLER_IDX], label[SAMPLER_IDX]);
check_label_and_length(label[SAMPLER_IDX], length[SAMPLER_IDX], "GL_SAMPLER");
glDeleteSamplers(1, &sampler);
}
/* Test TEXTURE */
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
ObjectLabel(GL_TEXTURE, texture, -1, TestLabel);
GetObjectLabel(GL_TEXTURE, texture, TestLabelLen + 1, &length[TEXTURE_IDX], label[TEXTURE_IDX]);
check_label_and_length(label[TEXTURE_IDX], length[TEXTURE_IDX], "GL_TEXTURE");
glDeleteTextures(1, &texture);
#ifdef PIGLIT_USE_OPENGL
/* Test DISPLAY_LIST - Compatibility Profile */
displayList = glGenLists(1);
glNewList(displayList, GL_COMPILE_AND_EXECUTE);
glEndList();
ObjectLabel(GL_DISPLAY_LIST, displayList, -1, TestLabel);
GetObjectLabel(GL_DISPLAY_LIST, displayList, TestLabelLen + 1, &length[DISPLAY_LIST_IDX], label[DISPLAY_LIST_IDX]);
check_label_and_length(label[DISPLAY_LIST_IDX], length[DISPLAY_LIST_IDX], "GL_DISPLAY_LIST");
glDeleteLists(displayList, 1);
#endif /* PIGLIT_USE_OPENGL */
return pass;
}
unsigned int OpenglES3Device::generateTransformFeedback(){
unsigned int handle;
glGenTransformFeedbacks(1, &handle);
this->evaluateErrorsAndLog("generateTransformFeedback(1)");
return handle;
}
