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++; }
static void SetTexture(GLMesh &mesh, unsigned i, bool isSrgb) { if (!mesh.textures[i]) mesh.textures[i] = getUnicolorTexture(video::SColor(255, 255, 255, 255)); compressTexture(mesh.textures[i], isSrgb); if (UserConfigParams::m_azdo) { if (!mesh.TextureHandles[i]) mesh.TextureHandles[i] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[i]), MeshShader::ObjectPass1Shader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[i])) glMakeTextureHandleResidentARB(mesh.TextureHandles[i]); } }
void STKMeshSceneNode::render() { irr::video::IVideoDriver* driver = irr_driver->getVideoDriver(); if (!Mesh || !driver) return; ++PassCount; updateNoGL(); updateGL(); bool isTransparent; for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (!mb) continue; video::E_MATERIAL_TYPE type = mb->getMaterial().MaterialType; video::IMaterialRenderer* rnd = driver->getMaterialRenderer(type); isTransparent = rnd->isTransparent(); break; } if ((irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS) && immediate_draw && !isTransparent) { core::matrix4 invmodel; AbsoluteTransformation.getInverse(invmodel); glDisable(GL_CULL_FACE); if (update_each_frame) updatevbo(); glUseProgram(MeshShader::ObjectPass1Shader::getInstance()->Program); // Only untextured for (unsigned i = 0; i < GLmeshes.size(); i++) { irr_driver->IncreaseObjectCount(); GLMesh &mesh = GLmeshes[i]; GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; compressTexture(mesh.textures[0], true); if (UserConfigParams::m_azdo) { if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::ObjectPass1Shader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0])); } else MeshShader::ObjectPass1Shader::getInstance()->SetTextureUnits(std::vector < GLuint > { getTextureGLuint(mesh.textures[0]) }); MeshShader::ObjectPass1Shader::getInstance()->setUniforms(AbsoluteTransformation, invmodel); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } glEnable(GL_CULL_FACE); return; } if (irr_driver->getPhase() == SOLID_LIT_PASS && immediate_draw && !isTransparent) { core::matrix4 invmodel; AbsoluteTransformation.getInverse(invmodel); glDisable(GL_CULL_FACE); if (update_each_frame && !UserConfigParams::m_dynamic_lights) updatevbo(); glUseProgram(MeshShader::ObjectPass2Shader::getInstance()->Program); // Only untextured for (unsigned i = 0; i < GLmeshes.size(); i++) { irr_driver->IncreaseObjectCount(); GLMesh &mesh = GLmeshes[i]; GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; if (UserConfigParams::m_azdo) { GLuint64 DiffuseHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_DIFFUSE), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(DiffuseHandle)) glMakeTextureHandleResidentARB(DiffuseHandle); GLuint64 SpecularHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_SPECULAR), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[1]); if (!glIsTextureHandleResidentARB(SpecularHandle)) glMakeTextureHandleResidentARB(SpecularHandle); GLuint64 SSAOHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_HALF1_R), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[2]); if (!glIsTextureHandleResidentARB(SSAOHandle)) glMakeTextureHandleResidentARB(SSAOHandle); if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::ObjectPass2Shader::getInstance()->SetTextureHandles(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, mesh.TextureHandles[0])); } else MeshShader::ObjectPass2Shader::getInstance()->SetTextureUnits(createVector<GLuint>( irr_driver->getRenderTargetTexture(RTT_DIFFUSE), irr_driver->getRenderTargetTexture(RTT_SPECULAR), irr_driver->getRenderTargetTexture(RTT_HALF1_R), getTextureGLuint(mesh.textures[0]))); MeshShader::ObjectPass2Shader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } glEnable(GL_CULL_FACE); return; } if (irr_driver->getPhase() == GLOW_PASS) { glUseProgram(MeshShader::ColorizeShader::getInstance()->Program); for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) { scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i); if (!mb) continue; if (irr_driver->hasARB_base_instance()) glBindVertexArray(VAOManager::getInstance()->getVAO(video::EVT_STANDARD)); else glBindVertexArray(GLmeshes[i].vao); drawGlow(GLmeshes[i]); } } if (irr_driver->getPhase() == TRANSPARENT_PASS && isTransparent) { ModelViewProjectionMatrix = computeMVP(AbsoluteTransformation); if (immediate_draw) { if (update_each_frame) updatevbo(); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); if (World::getWorld() && World::getWorld()->isFogEnabled()) { glUseProgram(MeshShader::TransparentFogShader::getInstance()->Program); for (unsigned i = 0; i < GLmeshes.size(); i++) { GLMesh &mesh = GLmeshes[i]; irr_driver->IncreaseObjectCount(); GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; const Track * const track = World::getWorld()->getTrack(); // This function is only called once per frame - thus no need for setters. const float fogmax = track->getFogMax(); const float startH = track->getFogStartHeight(); const float endH = track->getFogEndHeight(); const float start = track->getFogStart(); const float end = track->getFogEnd(); const video::SColor tmpcol = track->getFogColor(); video::SColorf col(tmpcol.getRed() / 255.0f, tmpcol.getGreen() / 255.0f, tmpcol.getBlue() / 255.0f); compressTexture(mesh.textures[0], true); if (UserConfigParams::m_azdo) { if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::TransparentFogShader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0])); } else MeshShader::TransparentFogShader::getInstance()->SetTextureUnits(std::vector<GLuint>{ getTextureGLuint(mesh.textures[0]) }); MeshShader::TransparentFogShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix, fogmax, startH, endH, start, end, col); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } } else { glUseProgram(MeshShader::TransparentShader::getInstance()->Program); for (unsigned i = 0; i < GLmeshes.size(); i++) { irr_driver->IncreaseObjectCount(); GLMesh &mesh = GLmeshes[i]; GLenum ptype = mesh.PrimitiveType; GLenum itype = mesh.IndexType; size_t count = mesh.IndexCount; compressTexture(mesh.textures[0], true); if (UserConfigParams::m_azdo) { if (!mesh.TextureHandles[0]) mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentShader::getInstance()->SamplersId[0]); if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0])) glMakeTextureHandleResidentARB(mesh.TextureHandles[0]); MeshShader::TransparentShader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0])); } else MeshShader::TransparentShader::getInstance()->SetTextureUnits(std::vector<GLuint>{ getTextureGLuint(mesh.textures[0]) }); MeshShader::TransparentShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix); assert(mesh.vao); glBindVertexArray(mesh.vao); glDrawElements(ptype, count, itype, 0); glBindVertexArray(0); } } return; } } }
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); } }
// -------------------------------------------------------------------------------------------------------------------- void TexturedQuadsGLBindlessMultiDraw::Render(const std::vector<Matrix>& _transforms) { // Program Vec3 dir = { 0, 0, 1 }; Vec3 at = { 0, 0, 0 }; Vec3 up = { 0, 1, 0 }; dir = normalize(dir); Vec3 eye = at - 250 * dir; Matrix view = matrix_look_at(eye, at, up); Matrix view_proj = mProj * view; glUseProgram(mProgram); glUniformMatrix4fv(0, 1, GL_TRUE, &view_proj.x.x); // Input Layout. First the IB glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer); // Then the VBs. glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, pos)); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, tex)); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); // Rasterizer State glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); glFrontFace(GL_CCW); glDisable(GL_SCISSOR_TEST); // Blend State glDisable(GL_BLEND); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); // Depth Stencil State glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); for (auto it = mTexHandles.begin(); it != mTexHandles.end(); ++it) { glMakeTextureHandleResidentARB(*it); } glBindBuffer(GL_SHADER_STORAGE_BUFFER, mTransformBuffer); BufferData(GL_SHADER_STORAGE_BUFFER, _transforms, GL_DYNAMIC_DRAW); size_t xformCount = _transforms.size(); assert(xformCount <= mObjectCount); for (size_t u = 0; u < xformCount; ++u) { DrawElementsIndirectCommand *cmd = &mCommands[u]; cmd->count = mIndexCount; cmd->instanceCount = 1; cmd->firstIndex = 0; cmd->baseVertex = 0; cmd->baseInstance = 0; } glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, &*mCommands.begin(), xformCount, 0); for (auto it = mTexHandles.begin(); it != mTexHandles.end(); ++it) { glMakeTextureHandleNonResidentARB(*it); } }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBBindlessTexture_nglMakeTextureHandleResidentARB(JNIEnv *env, jclass clazz, jlong handle, jlong function_pointer) { glMakeTextureHandleResidentARBPROC glMakeTextureHandleResidentARB = (glMakeTextureHandleResidentARBPROC)((intptr_t)function_pointer); glMakeTextureHandleResidentARB(handle); }
// -------------------------------------------------------------------------------------------------------------------- void TexturedQuadsGLBindless::Render(const std::vector<Matrix>& _transforms) { // Program Vec3 dir = { 0, 0, 1 }; Vec3 at = { 0, 0, 0 }; Vec3 up = { 0, 1, 0 }; dir = normalize(dir); Vec3 eye = at - 250 * dir; Matrix view = matrix_look_at(eye, at, up); Matrix view_proj = mProj * view; glUseProgram(mProgram); glUniformMatrix4fv(mUniformLocation.ViewProjection, 1, GL_TRUE, &view_proj.x.x); // Input Layout. First the IB glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer); // Then the VBs. glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, pos)); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, tex)); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); // Rasterizer State glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); glFrontFace(GL_CCW); glDisable(GL_SCISSOR_TEST); // Blend State glDisable(GL_BLEND); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); // Depth Stencil State glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); for (auto it = mTexHandles.begin(); it != mTexHandles.end(); ++it) { glMakeTextureHandleResidentARB(*it); } glBindBuffer(GL_SHADER_STORAGE_BUFFER, mTransformBuffer); BufferData(GL_SHADER_STORAGE_BUFFER, _transforms, GL_DYNAMIC_DRAW); size_t xformCount = _transforms.size(); assert(xformCount <= mObjectCount); // Code below assumes at least 1 texture. assert(mTexHandles.size() > 0); auto texIt = mTexHandles.begin(); for (size_t u = 0; u < xformCount; ++u) { // Update the Draw ID (since we cannot use multi_draw here glUniform1i(mUniformLocation.DrawID, u); if (texIt == mTexHandles.end()) { texIt = mTexHandles.begin(); } GLuint64 activeTex = *texIt; ++texIt; glUniformHandleui64ARB(mUniformLocation.gTex, activeTex); glDrawElements(GL_TRIANGLES, mIndexCount, GL_UNSIGNED_SHORT, 0); } for (auto it = mTexHandles.begin(); it != mTexHandles.end(); ++it) { glMakeTextureHandleNonResidentARB(*it); } }
inline void make_texture_handle_resident(uint64_t handle) { ARC_GL_CLEAR_ERRORS(); glMakeTextureHandleResidentARB(handle); ARC_GL_CHECK_FOR_ERRORS(); }
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(); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBBindlessTexture_glMakeTextureHandleResidentARB(JNIEnv *__env, jclass clazz, jlong handle) { glMakeTextureHandleResidentARBPROC glMakeTextureHandleResidentARB = (glMakeTextureHandleResidentARBPROC)tlsGetFunction(1077); UNUSED_PARAM(clazz) glMakeTextureHandleResidentARB(handle); }