We do work that calls two-stage shaders. In bidirenctional path tracing, in the first stage, the light vertices should be calculated and data can be retrived to c++ program from the compute shader. In the second stage in c++ program, a series of data such as bvh and vertex information of the light vertices should be established and sent back to the shader.
However in our second stage there was a problem when transferring data: The problem is we can get the correct data in the c++ program, but we can’t pass it back to the shader through the texture. I don’t have a deep understanding of opengl, here are some of my key codes (in order)
// Here I use a compute shader to calculate the light path node informations
sc_computeShader->Use();
glDispatchCompute((lpnum + 31) / 32, (scPreLightSize + 31) / 32, 1);
// Here I fetch lightnode informations from output texture of the compute shader
glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT);
GLfloat *img = new GLfloat[lpnum * scPreLightSize * 4 * 7];
glBindTexture(GL_TEXTURE_2D, lightOutTex);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, img);
// stop using a compute shader
sc_computeShader->StopUsing();
// here I store all the informations into my structure lightPathInfos
for (int i = 0; i < lpnum; i++)
{
for (int j = 0; j < scPreLightSize; j++)
{
lightPathInfos[i][j].position =
Vec3(
img[i * 4 + j * 4 * lpnum + 0],
img[i * 4 + j * 4 * lpnum + 1],
img[i * 4 + j * 4 * lpnum + 2]);
lightPathInfos[i][j].radiance =
Vec3(
img[i * 4 + (j + 3) * 4 * lpnum + 0],
img[i * 4 + (j + 3) * 4 * lpnum + 1],
img[i * 4 + (j + 3) * 4 * lpnum + 2]);
......
}
}
// here I fetch the point locations from lightPathInfos and starting constrcting a bvh tree
std::vector<Point3f> pts;
for (int i = 0; i < lpnum; i++)
{
for (int j = 0; j < scPreLightSize; j++)
{
pts.push_back(Point3f(lightPathInfos[i][j].position.x,
lightPathInfos[i][j].position.y,
lightPathInfos[i][j].position.z));
}
}
auto beforeTime = std::chrono::steady_clock::now();
BVH_ACC1 bvh_lightpath(pts, 0.03, 0.07);
auto afterTime = std::chrono::steady_clock::now();
double duration_millsecond = std::chrono::duration<double, std::milli>(afterTime - beforeTime).count();
printf("bvh construction time: %f ms\n", duration_millsecond);
// here I start to store the informations of light path and bvh infomations into shader
glBindBuffer(GL_TEXTURE_BUFFER, lightPathBuffer);
glBufferData(GL_TEXTURE_BUFFER, sizeof(LightInfo) * lpnum * scPreLightSize, &lightPathInfos[0][0], GL_STATIC_DRAW);
glBindTexture(GL_TEXTURE_BUFFER, lightPathTex);
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGB32F, lightPathBuffer);
glBindBuffer(GL_TEXTURE_BUFFER, lightPathBVHBuffer);
glBufferData(GL_TEXTURE_BUFFER, sizeof(LinearBVHNode) * bvh_lightpath.totalNodes, &bvh_lightpath.nodes[0], GL_STATIC_DRAW);
glBindTexture(GL_TEXTURE_BUFFER, lightPathBVHTex);
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGB32F, lightPathBVHBuffer);
glBindBuffer(GL_TEXTURE_BUFFER, lightPathBVHIndexBuffer);
glBufferData(GL_TEXTURE_BUFFER, sizeof(int) * bvh_lightpath.totalNodes, &bvh_lightpath.orderdata[0], GL_STATIC_DRAW);
glBindTexture(GL_TEXTURE_BUFFER, lightPathBVHIndexTex);
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGB32I, lightPathBVHIndexBuffer);
Before this segment I wrote some other code in preparation of data transport(in order):
// initialzation
lightInTex = 0;
lightOutTex = 0;
lightPathTex = 0;
lightPathBVHTex = 0;
lightPathBVHIndexTex = 0;
...
// generating tex and buffer for tex
glGenTextures(1, &lightPathTex);
glGenTextures(1, &lightPathBVHTex);
glGenTextures(1, &lightPathBVHIndexTex);
glGenBuffers(1, &lightPathBuffer);
glGenBuffers(1, &lightPathBVHBuffer);
glGenBuffers(1, &lightPathBVHIndexBuffer);
...
// bind texture to glsl texture
glActiveTexture(GL_TEXTURE13);
glBindTexture(GL_TEXTURE_BUFFER, lightPathTex);
glActiveTexture(GL_TEXTURE14);
glBindTexture(GL_TEXTURE_BUFFER, lightPathBVHTex);
glActiveTexture(GL_TEXTURE15);
glBindTexture(GL_TEXTURE_BUFFER, lightPathBVHIndexTex);
// transform texture number so we can use in pathtrace shader
pathTraceShader->Use();
shaderObject = pathTraceShader->getObject();
glUniform1i(glGetUniformLocation(shaderObject, "lightPathTex"), 13);
glUniform1i(glGetUniformLocation(shaderObject, "lightPathBVHTex"), 14);
glUniform1i(glGetUniformLocation(shaderObject, "lightPathBVHIndexTex"), 15);
pathTraceShader->StopUsing();