How to get texture size limit in a program on Opengl?

I have a qt program, which use several VBOs,and two framebuffer objects in QOpenglWidget like this:

class PatternWidget: public QOpenGLWidget,protected QOpenGLFunctions_4_3_Core {...}

Here I don't initialize some resources like Points/Tangents/tbo_depth/tbo_norm because these data will be reset outside the widget class,so I choose to allocate or reallocate these resources in paintGL() function.

void PatternWidget::initializeGL(){
...
glGenBuffers(1, &Points);
glBindBuffer(GL_ARRAY_BUFFER,Points);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(0);

glGenBuffers(1, &Tangents);
glBindBuffer(GL_ARRAY_BUFFER,Tangents);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(1);

glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &tbo_radiance);
glBindTexture(GL_TEXTURE_2D_ARRAY, tbo_radiance);
glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_R32F, 100, 100, 32);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glActiveTexture(GL_TEXTURE1);
glGenTextures(1, &tbo_density);
glBindTexture(GL_TEXTURE_2D_ARRAY, tbo_density);
glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_R32F, 100, 100, 32);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glActiveTexture(GL_TEXTURE2);
glGenTextures(1, &tbo_depth);
glBindTexture(GL_TEXTURE_2D, tbo_depth);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);

glActiveTexture(GL_TEXTURE3);
glGenTextures(1, &tbo_norm);
glBindTexture(GL_TEXTURE_2D, tbo_norm);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

glGenFramebuffers(1, &depthFrame);
glBindFramebuffer(GL_FRAMEBUFFER, depthFrame);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, tbo_depth, 0);
glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tbo_norm, 0);
glDrawBuffer(GL_COLOR_ATTACHMENT0);

glGenRenderbuffers(1, &rb_colorPattern);
glBindRenderbuffer(GL_RENDERBUFFER, rb_colorPattern);

glGenRenderbuffers(1, &rb_depthPattern);
glBindRenderbuffer(GL_RENDERBUFFER, rb_depthPattern);

glGenFramebuffers(1, &patternFrame);
glBindFramebuffer(GL_FRAMEBUFFER, patternFrame);
glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_RENDERBUFFER, rb_colorPattern);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rb_depthPattern);
glDrawBuffer(GL_COLOR_ATTACHMENT0);
}

In paintGL,I use several bool value to make sure when some resources not allocated in initialGL() will be set here only once,and when be reset outside this class,will also be reset only once.

void PatternWidget::paintGL(){
    if(!frameObjectUpdated){//frameObjectUpdated bool value,to make sure reset framebuffer only once
        resetFBO();
    }
    if(!bufferObjectUpdated){//bufferObjectUpdated same as frameObjectUpdated
        resetBO();
    }
    if(!crossTextureUpdated){//crossTextureUpdatedsame as frameObjectUpdated
        resetCrossData();
    }
    //render depth texture for shadow map   
    glUseProgram(shadowProgram);
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, depthFrame);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    ...//some basic matrix set
    glDrawArrays(GL_POINTS, 0, renderSize);
    //render pattern in framebuffer 
    glUseProgram(renderProgram);
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, patternFrame);
    ...//some basic matrix set
    glBindVertexArray(vao_render);
    glDrawArrays(GL_POINTS, 0, renderSize);
    //copy framebuffer to default framebuffer
    glBindFramebuffer(GL_READ_FRAMEBUFFER, patternFrame);
    glReadBuffer(GL_COLOR_ATTACHMENT0);
    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, defaultFramebufferObject());
    glBlitFramebuffer(0,0,winWid, winHei,0,0, winWid, winHei,GL_COLOR_BUFFER_BIT,GL_NEAREST);
}

Here are my reset functions,setFrameSizeaccept window width and height outside the class,then call resetFBO to reset framebuffer size, same way to call resetRenderData and resetBO to reset vbo.

void PatternWidget::setFrameSize(int w,int h){
    winWid = w;
    winHei = h;
    resetFBO();
}
void PatternWidget::resetFBO(){
    if(openGLInitialized){
        glBindTexture(GL_TEXTURE_2D, tbo_depth);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, 1024, 1024, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);

        glBindTexture(GL_TEXTURE_2D, tbo_norm);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 1024, 1024, 0, GL_RGBA, GL_FLOAT, NULL);

        glBindRenderbuffer(GL_RENDERBUFFER, rb_colorPattern);
        glRenderbufferStorage(GL_RENDERBUFFER,GL_RGBA,winWid, winHei);

        glBindRenderbuffer(GL_RENDERBUFFER, rb_depthPattern);
        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT32F, winWid, winHei);

        frameObjectUpdated = true;
    }
}

void PatternWidget::resetRenderData(QVector<vec4> *pnts, QVector<vec3> *t){
    points = pnts;
    tangents = t;
    resetBO();
}

void PatternWidget::resetBO(){
    if(openGLInitialized){
        renderSize = points->size();
        int nBytes = renderSize * sizeof(vec4);
        glBindBuffer(GL_ARRAY_BUFFER,bo_renderPoints);
        glBufferData(GL_ARRAY_BUFFER,nBytes,&(*points)[0].x,GL_DYNAMIC_DRAW);

        nBytes = renderSize * sizeof(vec3);
        glBindBuffer(GL_ARRAY_BUFFER,bo_renderTangents);
        glBufferData(GL_ARRAY_BUFFER,nBytes,&(*tangents)[0].x,GL_DYNAMIC_DRAW);

        nBytes = renderSize * sizeof(float);
        glBindBuffer(GL_ARRAY_BUFFER,bo_renderRotations);
        glBufferData(GL_ARRAY_BUFFER,nBytes,&(*rotations)[0],GL_DYNAMIC_DRAW);
        bufferObjectUpdated = true;
    }
}

I find that if Points and Tangents are 75M big, then the size of tbo_depth and tbo_norm should be smaller than 1024 * 1024,because if the size is bigger than 1024,shadow map won't work. I also copy tbo_norm to default framebuffer by glBlitFramebuffer,there wont be anything if size bigger than 1024.If Points and Tangents are half size then tbo_depth and tbo_norm size can be 2048 * 2048. Is there any way that I can get the actual max size of texture on different condition?

After creating your context, you can check the max texture size like this:

int value;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
std::cout << "Max texture: " << value << " x " << value << std::endl;

but be aware that this is specific to your driver (maybe your GPU as well).

EDIT:

Other things to check, even though you might already know:

• You don't seem to be setting resetFBO(w,h) in

:

PatternWidget::setFrameSize(int w,int h){
    winWid = w;
    winHei = h;
    resetFBO();
}

for example:

void PatternWidget::resetFBO(int w, int h){
    if(openGLInitialized){
        glBindTexture(GL_TEXTURE_2D, tbo_depth);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, w, h,...)
...

Which might be important, since drawing to the shadow map requires changing the viewport size:

glViewport(0, 0, shadowMapResolution, shadowMapResolution);

• bo_renderRotations looks uninitialized, but maybe you didn't include in the original snippet for brevity.

• You could check if 1024 is hard coded somewhere else, like in the shader.

Because, even though it looks like, its pretty unlikely that the size of the VBO is influencing the resolution of the shadow map texture.