void TopazSample::initFramebuffers(int32_t width, int32_t height)
{
if (textures.sceneColor && GLEW_ARB_bindless_texture)
{
glMakeTextureHandleNonResidentARB(texturesAddress64.sceneColor);
glMakeTextureHandleNonResidentARB(texturesAddress64.sceneDepth);
}
if (textures.sceneColor)
{
glDeleteTextures(1, &textures.sceneColor);
}
glGenTextures(1, &textures.sceneColor);
glBindTexture(GL_TEXTURE_RECTANGLE, textures.sceneColor);
glTexStorage2D(GL_TEXTURE_RECTANGLE, 1, GL_RGBA16F, width, height);
glBindTexture(GL_TEXTURE_RECTANGLE, 0);
if (textures.sceneDepth)
{
glDeleteTextures(1, &textures.sceneDepth);
}
glGenTextures(1, &textures.sceneDepth);
glBindTexture(GL_TEXTURE_RECTANGLE, textures.sceneDepth);
glTexStorage2D(GL_TEXTURE_RECTANGLE, 1, GL_DEPTH_COMPONENT24, width, height);
glBindTexture(GL_TEXTURE_RECTANGLE, 0);
if (fbos.scene)
{
glDeleteFramebuffers(1, &fbos.scene);
}
glGenFramebuffers(1, &fbos.scene);
glBindFramebuffer(GL_FRAMEBUFFER, fbos.scene);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, textures.sceneColor, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_RECTANGLE, textures.sceneDepth, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
if (GLEW_ARB_bindless_texture)
{
texturesAddress64.sceneColor = glGetTextureHandleARB(textures.sceneColor);
texturesAddress64.sceneDepth = glGetTextureHandleARB(textures.sceneDepth);
glMakeTextureHandleResidentARB(texturesAddress64.sceneColor);
glMakeTextureHandleResidentARB(texturesAddress64.sceneDepth);
}
cmdlist.state.fboIncarnation++;
}
// --------------------------------------------------------------------------------------------------------------------
bool TexturedQuadsGLBindless::Init(const std::vector<TexturedQuadsProblem::Vertex>& _vertices,
const std::vector<TexturedQuadsProblem::Index>& _indices,
const std::vector<TextureDetails*>& _textures,
size_t _objectCount)
{
if (!TexturedQuadsSolution::Init(_vertices, _indices, _textures, _objectCount)) {
return false;
}
// Prerequisites
if (glGetTextureHandleARB == nullptr) {
console::warn("Unable to initialize solution '%s', requires support for bindless textures (not present).", GetName().c_str());
return false;
}
// Program
const char* kUniformNames[] = { "ViewProjection", "DrawID", "gTex", nullptr };
mProgram = CreateProgramT("textures_gl_bindless_vs.glsl",
"textures_gl_bindless_fs.glsl",
kUniformNames, &mUniformLocation);
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
// Textures
for (auto it = _textures.begin(); it != _textures.end(); ++it) {
GLuint tex = NewTex2DFromDetails(*(*it));
if (!tex) {
console::warn("Unable to initialize solution '%s', texture creation failed.", GetName().c_str());
return false;
}
// Needs to be freed later.
mTextures.push_back(tex);
GLuint64 texHandle = glGetTextureHandleARB(tex);
if (texHandle == 0) {
console::warn("Unable to initialize solution '%s', couldn't get texture handle.", GetName().c_str());
}
mTexHandles.push_back(texHandle);
}
// Buffers
glGenVertexArrays(1, &mVertexArray);
glBindVertexArray(mVertexArray);
mVertexBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW);
mIndexBuffer = NewBufferFromVector(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW);
glGenBuffers(1, &mTransformBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, mTransformBuffer);
glGenVertexArrays(1, &mVAO);
glBindVertexArray(mVAO);
return glGetError() == GL_NO_ERROR;
}
static enum piglit_result
call_CopyTexSubImage_when_texture_is_referenced(void *data)
{
GLuint tex;
tex = piglit_rgbw_texture(GL_RGBA8, 16, 16, GL_FALSE, GL_FALSE,
GL_UNSIGNED_BYTE);
glGetTextureHandleARB(tex);
if (!piglit_check_gl_error(GL_NO_ERROR))
return PIGLIT_FAIL;
/* The ARB_bindless_texture spec says:
*
* "The contents of the images in a texture object may still be
* updated via commands such as TexSubImage*, CopyTexSubImage*, and
* CompressedTexSubImage*, and by rendering to a framebuffer object,
* even if the texture object is referenced by one or more texture
* handles."
*/
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 16, 16);
if (!piglit_check_gl_error(GL_NO_ERROR))
return PIGLIT_FAIL;
return PIGLIT_PASS;
}
PIGLIT_GL_TEST_CONFIG_END
static enum piglit_result
call_TexSubImage_when_texture_is_referenced(void *data)
{
int *img = malloc(16 * 16 * 4 * sizeof(unsigned));
GLuint tex;
tex = piglit_integer_texture(GL_RGBA32I, 16, 16, 0, 0);
glGetTextureHandleARB(tex);
if (!piglit_check_gl_error(GL_NO_ERROR)) {
free(img);
return PIGLIT_FAIL;
}
/* The ARB_bindless_texture spec says:
*
* "The contents of the images in a texture object may still be
* updated via commands such as TexSubImage*, CopyTexSubImage*, and
* CompressedTexSubImage*, and by rendering to a framebuffer object,
* even if the texture object is referenced by one or more texture
* handles."
*/
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 16, 16, GL_RGBA_INTEGER,
GL_INT, img);
free(img);
if (!piglit_check_gl_error(GL_NO_ERROR))
return PIGLIT_FAIL;
return PIGLIT_PASS;
}
static enum piglit_result
call_MapBuffer_when_texture_is_referenced(void *data)
{
static const float red[4] = {1, 0, 0, 0};
GLuint tex, tbo;
glGenBuffers(1, &tbo);
glBindBuffer(GL_TEXTURE_BUFFER, tbo);
glBufferData(GL_TEXTURE_BUFFER, sizeof(red), red, GL_STATIC_DRAW);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_BUFFER, tex);
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, tbo);
glGetTextureHandleARB(tex);
if (!piglit_check_gl_error(GL_NO_ERROR))
return PIGLIT_FAIL;
/* The ARB_bindless_texture spec says:
*
* "The contents of the buffer object may still be updated via buffer
* update commands such as BufferSubData and MapBuffer*, or via the
* texture update commands, even if the buffer is bound to a texture
* while that buffer texture object is referenced by one or more
* texture handles."
*/
glMapBuffer(GL_TEXTURE_BUFFER, GL_READ_ONLY);
if (!piglit_check_gl_error(GL_NO_ERROR))
return PIGLIT_FAIL;
glUnmapBuffer(GL_TEXTURE_BUFFER);
return PIGLIT_PASS;
}
inline uint64_t get_texture_handle(uint32_t tex_id)
{
ARC_GL_CLEAR_ERRORS();
uint64_t result = glGetTextureHandleARB(tex_id);
ARC_GL_CHECK_FOR_ERRORS();
return result;
}
EXTERN_C_ENTER
JNIEXPORT jlong JNICALL Java_org_lwjgl_opengl_ARBBindlessTexture_glGetTextureHandleARB(JNIEnv *__env, jclass clazz, jint texture) {
glGetTextureHandleARBPROC glGetTextureHandleARB = (glGetTextureHandleARBPROC)tlsGetFunction(1075);
UNUSED_PARAM(clazz)
return (jlong)glGetTextureHandleARB(texture);
}
GLuint64EXT HdSimpleTextureResource::GetLayoutTextureHandle()
{
if (!TF_VERIFY(_isPtex)) {
return 0;
}
if (!TF_VERIFY(glGetTextureHandleARB)) {
return 0;
}
GLuint textureId = GetLayoutTextureId();
return textureId ? glGetTextureHandleARB(textureId) : 0;
}
GLuint64EXT HdSimpleTextureResource::GetTexelsTextureHandle()
{
GLuint textureId = GetTexelsTextureId();
GLuint samplerId = GetTexelsSamplerId();
if (!TF_VERIFY(glGetTextureHandleARB) ||
!TF_VERIFY(glGetTextureSamplerHandleARB)) {
return 0;
}
if (_isPtex) {
return textureId ? glGetTextureHandleARB(textureId) : 0;
}
return textureId ? glGetTextureSamplerHandleARB(textureId, samplerId) : 0;
}
static enum piglit_result
call_CompressedTexSubImage_when_texture_is_referenced(void *data)
{
void *compressed;
GLuint tex;
GLint size;
tex = piglit_rgbw_texture(GL_COMPRESSED_RGBA_BPTC_UNORM, 16, 16,
GL_FALSE, GL_FALSE, GL_UNSIGNED_NORMALIZED);
glGetTextureHandleARB(tex);
if (!piglit_check_gl_error(GL_NO_ERROR))
return PIGLIT_FAIL;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &size);
compressed = malloc(size);
glGetCompressedTexImage(GL_TEXTURE_2D, 0, compressed);
/* The ARB_bindless_texture spec says:
*
* "The contents of the images in a texture object may still be
* updated via commands such as TexSubImage*, CopyTexSubImage*, and
* CompressedTexSubImage*, and by rendering to a framebuffer object,
* even if the texture object is referenced by one or more texture
* handles."
*/
glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 16, 16,
GL_COMPRESSED_RGBA_BPTC_UNORM, size,
compressed);
free(compressed);
if (!piglit_check_gl_error(GL_NO_ERROR))
return PIGLIT_FAIL;
return PIGLIT_PASS;
}
void ImageViewerPanel::initializeGL()
{
//glewInit();
glGetIntegerv(GL_MAJOR_VERSION, &ogl_ver_major);
glGetIntegerv(GL_MINOR_VERSION, &ogl_ver_minor);
shaderP = make_unique<GLSLProgram>(
"resources/shaders/img_vs.glsl",
"resources/shaders/img_fs.glsl");
if (ogl_ver_major == 4 && ogl_ver_minor >= 5)
{
// DSA
// Create VAO
glCreateBuffers(1, &vbo);
glNamedBufferData(vbo, sizeof(frame), frame, GL_STATIC_DRAW);
// IBO
GLuint indices[] = { 0,1,2,2,3,0 };
glCreateBuffers(1, &ibo);
glNamedBufferData(ibo, sizeof(indices), indices, GL_STATIC_DRAW);
// VAO
glCreateVertexArrays(1, &vao);
glEnableVertexArrayAttrib(vao, 0);
// Setup the formats
glVertexArrayAttribFormat(vao, 0, 2, GL_FLOAT, GL_FALSE, 0);
glVertexArrayVertexBuffer(vao, 0, vbo, 0, sizeof(float) * 2);
glVertexArrayAttribBinding(vao, 0, 0);
glVertexArrayElementBuffer(vao, ibo);
// Setup textures
int texSize = 4;
glCreateTextures(GL_TEXTURE_2D, 1, &tex);
glTextureParameteri(tex, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTextureParameteri(tex, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTextureParameteri(tex, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTextureParameteri(tex, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTextureStorage2D(tex, 1, GL_RGB32F, imgsize[0], imgsize[1]);
if (texLen > 0)
{
glTextureSubImage2D(tex, 0, 0, 0, imgsize[0], imgsize[1], GL_RGB, GL_FLOAT, textures);
}
texHandle = glGetTextureHandleARB(tex);
glMakeTextureHandleResidentARB(texHandle);
}
else
{
// Non-DSA
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
// Bind UV values
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(frame), frame, GL_STATIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
}
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
Texture2DContainer::Texture2DContainer(bool sparse, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei slices)
: mHandle(0)
, mWidth(width)
, mHeight(height)
, mLevels(levels)
, mSlices(slices)
, mXTileSize(0)
, mYTileSize(0)
{
glGenTextures(1, &mTexId);
glBindTexture(GL_TEXTURE_2D_ARRAY, mTexId);
if (sparse) {
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_SPARSE_ARB, GL_TRUE);
// TODO: This could be done once per internal format. For now, just do it every time.
GLint indexCount = 0,
xSize = 0,
ySize = 0,
zSize = 0;
GLint bestIndex = -1,
bestXSize = 0,
bestYSize = 0;
glGetInternalformativ(GL_TEXTURE_2D_ARRAY, internalformat, GL_NUM_VIRTUAL_PAGE_SIZES_ARB, 1, &indexCount);
for (GLint i = 0; i < indexCount; ++i) {
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_VIRTUAL_PAGE_SIZE_INDEX_ARB, i);
glGetInternalformativ(GL_TEXTURE_2D_ARRAY, internalformat, GL_VIRTUAL_PAGE_SIZE_X_ARB, 1, &xSize);
glGetInternalformativ(GL_TEXTURE_2D_ARRAY, internalformat, GL_VIRTUAL_PAGE_SIZE_Y_ARB, 1, &ySize);
glGetInternalformativ(GL_TEXTURE_2D_ARRAY, internalformat, GL_VIRTUAL_PAGE_SIZE_Z_ARB, 1, &zSize);
// For our purposes, the "best" format is the one that winds up with Z=1 and the largest x and y sizes.
if (zSize == 1) {
if (xSize >= bestXSize && ySize >= bestYSize) {
bestIndex = i;
bestXSize = xSize;
bestYSize = ySize;
}
}
}
// This would mean the implementation has no valid sizes for us, or that this format doesn't actually support sparse
// texture allocation. Need to implement the fallback. TODO: Implement that.
assert(bestIndex != -1);
mXTileSize = bestXSize;
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_VIRTUAL_PAGE_SIZE_INDEX_ARB, bestIndex);
}
// We've set all the necessary parameters, now it's time to create the sparse texture.
glTexStorage3D(GL_TEXTURE_2D_ARRAY, levels, internalformat, width, height, mSlices);
for (GLsizei i = 0; i < mSlices; ++i) {
mFreeList.push(i);
}
if (sparse) {
mHandle = glGetTextureHandleARB(mTexId);
assert(mHandle != 0);
glMakeTextureHandleResidentARB(mHandle);
}
}
// --------------------------------------------------------------------------------------------------------------------
bool TexturedQuadsGLBindlessMultiDraw::Init(const std::vector<TexturedQuadsProblem::Vertex>& _vertices,
const std::vector<TexturedQuadsProblem::Index>& _indices,
const std::vector<TextureDetails*>& _textures,
size_t _objectCount)
{
if (!TexturedQuadsSolution::Init(_vertices, _indices, _textures, _objectCount)) {
return false;
}
// Prerequisites
if (glGetTextureHandleARB == nullptr) {
console::warn("Unable to initialize solution '%s', requires support for bindless textures (not present).", GetName().c_str());
return false;
}
// Programs
mProgram = CreateProgram("textures_gl_bindless_multidraw_vs.glsl",
"textures_gl_bindless_multidraw_fs.glsl");
if (mProgram == 0) {
console::warn("Unable to initialize solution '%s', shader compilation/linking failed.", GetName().c_str());
return false;
}
// Textures
for (auto it = _textures.begin(); it != _textures.end(); ++it) {
GLuint tex = NewTex2DFromDetails(*(*it));
if (!tex) {
console::warn("Unable to initialize solution '%s', texture creation failed.", GetName().c_str());
return false;
}
// Needs to be freed later.
mTextures.push_back(tex);
GLuint64 texHandle = glGetTextureHandleARB(tex);
if (texHandle == 0) {
console::warn("Unable to initialize solution '%s', couldn't get texture handle.", GetName().c_str());
}
mTexHandles.push_back(texHandle);
}
// Buffers
mVertexBuffer = NewBufferFromVector(GL_ARRAY_BUFFER, _vertices, GL_STATIC_DRAW);
mIndexBuffer = NewBufferFromVector(GL_ELEMENT_ARRAY_BUFFER, _indices, GL_STATIC_DRAW);
glGenBuffers(1, &mTransformBuffer);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, mTransformBuffer);
auto srcIt = mTexHandles.cbegin();
std::vector<GLuint64> texAddressContents(_objectCount);
for (auto dstIt = texAddressContents.begin(); dstIt != texAddressContents.end(); ++dstIt) {
if (srcIt == mTexHandles.cend()) {
srcIt = mTexHandles.cbegin();
}
(*dstIt) = *srcIt;
++srcIt;
}
mTexAddressBuffer = NewBufferFromVector(GL_SHADER_STORAGE_BUFFER, texAddressContents, GL_STATIC_DRAW);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, mTexAddressBuffer);
mCommands.resize(_objectCount);
return GLRenderer::GetApiError() == GL_NO_ERROR;
}
JNIEXPORT jlong JNICALL Java_org_lwjgl_opengl_ARBBindlessTexture_nglGetTextureHandleARB(JNIEnv *env, jclass clazz, jint texture, jlong function_pointer) {
glGetTextureHandleARBPROC glGetTextureHandleARB = (glGetTextureHandleARBPROC)((intptr_t)function_pointer);
GLuint64 __result = glGetTextureHandleARB(texture);
return __result;
}
void TopazSample::initScene()
{
// initializate skybox
{
glBindTexture(GL_TEXTURE_CUBE_MAP, textures.skybox);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
texturesAddress64.skybox = glGetTextureHandleARB(textures.skybox);
glMakeTextureHandleResidentARB(texturesAddress64.skybox);
}
// init fullscreen quad
{
const float position[] =
{
-1.0f, -1.0f, 0.0,
1.0f, -1.0f, 0.0,
-1.0f, 1.0f, 0.0,
1.0f, 1.0f, 0.0
};
initBuffer(GL_ARRAY_BUFFER, fullScreenRectangle.vboFullScreen, fullScreenRectangle.vboFullScreen64,
12 * sizeof(float),
position);
}
// initializate scene & weightBlended ubo
{
initBuffer(GL_UNIFORM_BUFFER, ubos.sceneUbo, ubos.sceneUbo64,
sizeof(SceneData),
nullptr,
true); // mutable buffer
initBuffer(GL_UNIFORM_BUFFER, ubos.identityUbo, ubos.identityUbo64,
sizeof(IdentityData),
identityData.identity._array,
true); // mutable buffer
WeightBlendedData weightBlendedData;
weightBlendedData.background = texturesAddress64.sceneColor;
weightBlendedData.colorTex0 = oit->getAccumulationTextureId64(0);
weightBlendedData.colorTex1 = oit->getAccumulationTextureId64(1);
initBuffer(GL_UNIFORM_BUFFER, ubos.weightBlendedUbo, ubos.weightBlendedUbo64,
sizeof(WeightBlendedData),
&weightBlendedData,
true); // mutable buffer
}
brushStyle->brushPattern8to32(QtStyles::Dense1Pattern);
objectData.objectID = nv::vec4f(0.0);
objectData.objectColor = nv::vec4f(1.0f, 1.0f, 1.0f, oit->getOpacity());
objectData.skybox = texturesAddress64.skybox;
objectData.pattern = brushStyle->getTextureId64();
for (auto & model : models)
{
model->getModel()->compileModel(NvModelPrimType::TRIANGLES);
/* ibo */
initBuffer(GL_ELEMENT_ARRAY_BUFFER, model->getBufferID("ibo"), model->getBufferID64("ibo"),
model->getModel()->getCompiledIndexCount(NvModelPrimType::TRIANGLES) * sizeof(uint32_t),
model->getModel()->getCompiledIndices(NvModelPrimType::TRIANGLES));
/* vbo */
initBuffer(GL_ARRAY_BUFFER, model->getBufferID("vbo"), model->getBufferID64("vbo"),
model->getModel()->getCompiledVertexCount() * model->getModel()->getCompiledVertexSize() * sizeof(float),
model->getModel()->getCompiledVertices());
if (model->cornerPointsExists())
{
/* ibo corner */
initBuffer(GL_ELEMENT_ARRAY_BUFFER, model->getCornerBufferID("ibo"), model->getCornerBufferID64("ibo"),
model->getCornerIndices().size() * sizeof(uint32_t),
model->getCornerIndices().data());
/* vbo corner */
initBuffer(GL_ARRAY_BUFFER, model->getCornerBufferID("vbo"), model->getCornerBufferID64("vbo"),
model->getCorners().size() * sizeof(nv::vec3f),
model->getCorners().data());
/* ubo corner */
ObjectData curObjectData;
curObjectData.objectID = nv::vec4f(1.0f);
curObjectData.objectColor = nv::vec4f(1.0f, 0.0f, 0.0f, oit->getOpacity());
curObjectData.pattern = brushStyle->getTextureId64();
initBuffer(GL_UNIFORM_BUFFER, model->getCornerBufferID("ubo"), model->getCornerBufferID64("ubo"),
sizeof(ObjectData),
&curObjectData,
true); // mutable buffer
}
/* ubo */
initBuffer(GL_UNIFORM_BUFFER, model->getBufferID("ubo"), model->getBufferID64("ubo"),
sizeof(ObjectData),
&objectData,
true); // mutable buffer
objectData.objectID = nv::vec4f(1.0);
}
}
void WeightedBlendedOIT::InitAccumulationRenderTargets(int32_t width, int32_t height)
{
this->imageWidth = width;
this->imageHeight = height;
glGenTextures(1, &this->sceneOpaqueId);
/* scene non transparent */
glBindTexture(GL_TEXTURE_RECTANGLE, this->sceneOpaqueId);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE, 0, GL_RGBA16F, this->imageWidth, this->imageHeight, 0, GL_RGBA, GL_FLOAT, nullptr);
glGenTextures(2, this->accumulationTextureId);
/* rgba texture */
glBindTexture(GL_TEXTURE_RECTANGLE, this->accumulationTextureId[0]);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE, 0, GL_RGBA16F, this->imageWidth, this->imageHeight, 0, GL_RGBA, GL_FLOAT, nullptr);
/* alpha texture */
glBindTexture(GL_TEXTURE_RECTANGLE, this->accumulationTextureId[1]);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_RECTANGLE, 0, GL_R8, this->imageWidth, this->imageHeight, 0, GL_RED, GL_FLOAT, nullptr);
glGenFramebuffers(1, &this->accumulationFramebufferId);
glBindFramebuffer(GL_FRAMEBUFFER, this->accumulationFramebufferId);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE, this->accumulationTextureId[0], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_RECTANGLE, this->accumulationTextureId[1], 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_RECTANGLE, this->sceneOpaqueId, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
if (GLEW_ARB_bindless_texture)
{
this->accumulationTextureId64[0] = glGetTextureHandleARB(this->accumulationTextureId[0]);
this->accumulationTextureId64[1] = glGetTextureHandleARB(this->accumulationTextureId[1]);
this->sceneOpaqueId64 = glGetTextureHandleARB(this->sceneOpaqueId);
glMakeTextureHandleResidentARB(this->accumulationTextureId64[0]);
glMakeTextureHandleResidentARB(this->accumulationTextureId64[1]);
glMakeTextureHandleResidentARB(this->sceneOpaqueId64);
}
CHECK_GL_ERROR();
}