I'm under the impression that you can read back into the CPU memory the triangles that are emitted from a geometry shader. I just can't make it work.
The project is at https://github.com/sjhalayka/opengl_gs_transform_feedback
Any ideas on how to do this so-called transform feedback?
I found a comprehensive code that reads the out variables of a geometry shader. It's close, and I can make it work, but it's kind of a hack. I was hoping that I'd be able to read the triangles emitted.
https://open.gl/feedback
https://open.gl/content/code/c8_final.txt
…I was hoping that I'd be able to read the triangles emitted.
-lol- (respectfully) u sound like a diva now ?
have u not even inspected the code on that c8_final.txt?? that's exactly what it does!
… and it's not a hack;
come on, have another look ?
LOL
OK, there’s two outs in the geometry shader; one‘s the triangles and one’s the floating point variable. If I take out the floating point variable, is there still a way to read the triangles?
P.S. How can you say that it's what I want, when it only spits out 5x3 =15 floats, instead of 5 x 3 x 3 = 45 that are actually required to describe the 5 triangles? I was thinking of making 3 floating point variables.
?
For each value in this data field GLfloat data[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; the geometry shader is outputting a triangle.
//pseudo
- data[0] goes to vertex shader
- vertex shader computes geovalue[0] = sqrt of data[0] and passes it to geom shader
- geom shader receives geovalue and outputs 3 vertices:
- emit vertex : geovalue[0] + 0
- emit vertex : geovalue[0] + 1
- emit vertex : geovalue[0] + 2
- data[1] goes to vertex shader
- vertex shader computes geovalue[0] = sqrt of data[1] and passes it to geom shader
- geom shader receives geovalue and outputs 3 vertices:
- emit vertex : geovalue[0] + 0
- emit vertex : geovalue[0] + 1
- emit vertex : geovalue[0] + 2
- data[2] goes to the pub and asks for a beer
- vertex shader asks r u really here for a beer? see geom shader
- geom shader is already drunk and pukes 3 times:
- ...
...
i'm not even gonna tell u what happens to data[3] and data[4], the voting count had to stop without evidence :-) and
GLfloat feedback[15];
glGetBufferSubData(GL_TRANSFORM_FEEDBACK_BUFFER, 0, sizeof(feedback), feedback);
for (int i = 0; i < 15; i++)
printf("%f\n", feedback[i]);
feedback then captures all 15 emitted verts;
That's it … all the best ?
ROFL
There's not enough data to describe the triangles though. There's 15 floats, not 15 verts.
P.S. thanks for your time and patience!
OK, so I changed the code to use vec4s instead of floats, and it's working well. My question still stands… Do I absolutely have to use a vec4 out variable?
Major problem: as soon as I attempt to add in a second out variable, I get zero primitives generated.
#include <GL/glew.h>
#include <GL/glut.h>
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
#include <glm/gtc/matrix_transform.hpp>
using namespace glm;
#include <iostream>
#include <vector>
using namespace std;
// Automatically link in the GLUT and GLEW libraries if compiling on MSVC++
#ifdef _MSC_VER
#pragma comment(lib, "glew32")
#pragma comment(lib, "freeglut")
#endif
// Vertex shader
const GLchar* vertexShaderSrc = R"glsl(
#version 150 core
//in vec4 inValue;
out vec4 geoValue;
void main()
{
geoValue = vec4(1, 2, 3, 4);//inValue;
}
)glsl";
// Geometry shader
const GLchar* geoShaderSrc = R"glsl(
#version 150 core
layout(points) in;
layout(triangle_strip, max_vertices = 3) out;
in vec4[] geoValue;
out vec4 outValue;
out vec4 outvalue2;
void main()
{
for (int i = 0; i < 3; i++)
{
outValue = geoValue[0] + vec4(i, i, i, i);
EmitVertex();
}
EndPrimitive();
}
)glsl";
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(10, 10);
glutInitWindowPosition(0, 0);
GLint win_id = glutCreateWindow("GS Test");
if (GLEW_OK != glewInit())
{
cout << "GLEW initialization error" << endl;
return 0;
}
int GL_major_version = 0;
glGetIntegerv(GL_MAJOR_VERSION, &GL_major_version);
int GL_minor_version = 0;
glGetIntegerv(GL_MINOR_VERSION, &GL_minor_version);
if (GL_major_version < 4)
{
cout << "GPU does not support OpenGL 4.3 or higher" << endl;
return 0;
}
else if (GL_major_version == 4)
{
if (GL_minor_version < 3)
{
cout << "GPU does not support OpenGL 4.3 or higher" << endl;
return 0;
}
}
// Compile shaders
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSrc, nullptr);
glCompileShader(vertexShader);
GLuint geoShader = glCreateShader(GL_GEOMETRY_SHADER);
glShaderSource(geoShader, 1, &geoShaderSrc, nullptr);
glCompileShader(geoShader);
// Create program and specify transform feedback variables
GLuint program = glCreateProgram();
glAttachShader(program, vertexShader);
glAttachShader(program, geoShader);
const GLchar* feedbackVaryings[] = { "outValue", "outvalue2" };
glTransformFeedbackVaryings(program, 2, feedbackVaryings, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(program);
glUseProgram(program);
// Create VAO
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
size_t num_vertices = 1;
size_t num_vertices_per_triangle = 3;
size_t num_floats_per_vertex = 4;
// Create input VBO and vertex format
//vector<GLfloat> data = { 5.0f, 6.0f, 7.0f, 0.0f };
//GLuint vbo;
//glGenBuffers(1, &vbo);
//glBindBuffer(GL_ARRAY_BUFFER, vbo);
//glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat)*num_vertices*num_floats_per_vertex, &data[0], GL_STATIC_DRAW);
//GLint inputAttrib = glGetAttribLocation(program, "inValue");
//glEnableVertexAttribArray(inputAttrib);
//glVertexAttribPointer(inputAttrib, 1, GL_FLOAT, GL_FALSE, 0, 0);
// Create transform feedback buffer
GLuint tbo;
glGenBuffers(1, &tbo);
glBindBuffer(GL_ARRAY_BUFFER, tbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 2 * num_vertices * num_vertices_per_triangle * num_floats_per_vertex, nullptr, GL_STATIC_READ);
// Create query object to collect info
GLuint query;
glGenQueries(1, &query);
// Perform feedback transform
glEnable(GL_RASTERIZER_DISCARD);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tbo);
glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, query);
glBeginTransformFeedback(GL_TRIANGLES);
glDrawArrays(GL_POINTS, 0, 1);
glEndTransformFeedback();
glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
glDisable(GL_RASTERIZER_DISCARD);
glFlush();
// Fetch and print results
GLuint primitives;
glGetQueryObjectuiv(query, GL_QUERY_RESULT, &primitives);
vector<GLfloat> feedback(2 * num_vertices * num_vertices_per_triangle * num_floats_per_vertex);
glGetBufferSubData(GL_TRANSFORM_FEEDBACK_BUFFER, 0, sizeof(GLfloat)*feedback.size(), &feedback[0]);
printf("%u primitives written!\n\n", primitives);
for (int i = 0; i < 2 * num_vertices * num_vertices_per_triangle * num_floats_per_vertex; i++)
{
cout << feedback[i] << endl;
}
glDeleteQueries(1, &query);
glDeleteProgram(program);
glDeleteShader(geoShader);
glDeleteShader(vertexShader);
glDeleteBuffers(1, &tbo);
//glDeleteBuffers(1, &vbo);
glDeleteVertexArrays(1, &vao);
return 0;
}Holy cow, I figured it out. The shader will not link on my AMD Ryzen 3. It links fine on an Intel box. WTF?
