your graphics card may not support these extensions try on a different computer, or you dont have that functions described properly

in c++ is something like this:

header

PFNGLTEXIMAGE3DPROC glTexImage3D;

source

glTexImage3D = (PFNGLTEXIMAGE3DPROC) wglGetProcAddress("glTexImage3D");

i dont know but i could be in glew.h

BUT

your problem seems to be simple but quite hard to solve look for your code for bad drawing calls

maybe you dont disable some statements on frame end.

Really try with blank project and try to do that you want to make, then compare it to your code.

can you show your drawing code?

maybe you dont have properly closed last face? (2 or 1 vertex instead of 3)

VAO? i use VAO too but i dont have something like glgenbuffers etc

i have just simple array that is drawn like:

void __fastcall TachoGLModel::DrawModelVBO(t3dpoint punkt)
{
if (ModelCanBeUsed == false) return;

glVertexPointer(3, GL_FLOAT, sizeof(t3dpoint), &VBO_V[0]);
glNormalPointer(GL_FLOAT, sizeof(t3dpoint),&VBO_N[0]);
glTexCoordPointer(2, GL_FLOAT, sizeof(textpoint),&VBO_T[0]);
if (USE_COLOR_MAP == true) {

glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_FLOAT, 0, &VBO_C[0]);

}

int i,j;


if (Textures.Length == 0) {
for (i = 0; i < Matrixarr.Length; i++)
glDrawArrays(matrixtogl(Matrixarr[i]), VBO_BE[i].INDEX_START , VBO_BE[i].length);
// FCyfra->ProjectTextures

if (USE_COLOR_MAP == true) glDisableClientState(GL_COLOR_ARRAY);
return;
}
//if( Textures.Length == 0) ShowMessage("NO");

for (i = 0; i < Matrixarr.Length; i++) {
//if (classifyapointagainstaplane(punkt,VBO_N[VBO_BE[i].INDEX_START],FACE_DISTANCE[i]) == isFront) {
if (EditMode == false)
if (Textures[Textureindex[i]].ID != 2)
if (Textures[Textureindex[i]].ID != 1) {
//


if ( Textures.Length > 0 )
glBindTexture(GL_TEXTURE_2D, Textures[ Textureindex[i] ].pointer);

glDrawArrays(matrixtogl(Matrixarr[i]), VBO_BE[i].INDEX_START , VBO_BE[i].length);


}


if (EditMode == true) glDrawArrays(matrixtogl(Matrixarr[i]), VBO_BE[i].INDEX_START , VBO_BE[i].length);
}


glEnable(GL_BLEND);
glDepthMask(GL_FALSE);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
if (EditMode == true)
for (i = 0; i < Matrixarr.Length; i++)
if (Textures[Textureindex[i]].ID == 1) {
if(Textures.Length > 0)
glBindTexture(GL_TEXTURE_2D,Textures[Textureindex[i]].pointer);
glDrawArrays(matrixtogl(Matrixarr[i]), VBO_BE[i].INDEX_START , VBO_BE[i].length);




}
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);


if (USE_COLOR_MAP == true) glDisableClientState(GL_COLOR_ARRAY);

}

show your vertex array and drawing routine with initialization of the VAO too

Are you unbinding the VAO before calling SFML's stuff? Would also help a lot if you could make a minimal example to show the problem.

This works at least for me.

// g++ sfml_vao.cpp -lsfml-graphics -lsfml-window -lsfml-system -lGL -lGLEW 

#include <SFML/Graphics.hpp>
#include <GL/glew.h>
#include <cstdio>

unsigned int vbo, ibo, vao;

const char *vs = "#version 150\n in vec3 vs_Position; void main() { gl_Position = vec4(vs_Position, 1); }";
const char *fs = "#version 150\n out vec4 o; void main() { o = vec4(1,0,0,1); }";

void init() {
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    glGenBuffers(1, &vbo);
    glGenBuffers(1, &ibo);

    float vertices[] = {
        -0.5f, -0.5f, 0.1f,
         0.5f, -0.5f, 0.1f,
         0.5f,  0.5f, 0.1f,
        -0.5f,  0.5f, 0.1f,
    };

    unsigned int indices[] = {
        0, 1, 2,
        0, 2, 3
    };

    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 3, 0);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

void draw() {
    glBindVertexArray(vao);
    glDrawElementsBaseVertex(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0, 0);
    glBindVertexArray(0);
}

void check() {
    GLenum err = glGetError();
    if(err) {
        printf("fuu! %d\n", err);
    }
}

int main() {
    sf::RenderWindow window(sf::VideoMode(200, 200), "SFML works!");

    sf::CircleShape shape(100.f);
    shape.setFillColor(sf::Color::Green);

    glewInit();

    sf::Shader shader;
    shader.loadFromMemory(vs, fs);

    init();

    while(window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                window.close();
                return 0;
            }
        }

        window.clear();

        sf::Shader::bind(0);
        window.draw(shape);
        check();

        sf::Shader::bind(&shader);
        draw();
        check();

        window.display();
    }

    return 0;
}