Поддерживаются ли в OpenGL вертексные и индексные буфера?

#include <windows.h>
#include <GL\gl3.h>
#include <GL\glu.h>
#include <stdio.h>
 
 
PFNGLGENVERTEXARRAYSPROC    glGenVertexArrays           = NULL;
PFNGLBINDVERTEXARRAYPROC    glBindVertexArray           = NULL;
PFNGLGENBUFFERSPROC         glGenBuffers                = NULL;
PFNGLBINDBUFFERPROC         glBindBuffer                = NULL;
PFNGLBUFFERDATAPROC         glBufferData                = NULL;
PFNGLDELETEBUFFERSPROC      glDeleteBuffers             = NULL;
 
 
HWND        hwnd;
MSG         msg;
HGLRC       hRC;
HDC         hDC;
 
 
LRESULT CALLBACK WindowProc(HWND, UINT, WPARAM, LPARAM);
int Load_Object(int, char[]);
void Draw_Object(int);
int Load_BMP(int, char[]);
 
 
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
{
    WNDCLASSEX wcex;
    wcex.cbSize         = sizeof(WNDCLASSEX);
    wcex.style          = CS_OWNDC;
    wcex.hbrBackground  = (HBRUSH)(0);
    wcex.lpfnWndProc    = WindowProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.lpszMenuName   = NULL;
    wcex.lpszClassName  = "classname";
    wcex.hIconSm        = LoadIcon(NULL, IDI_APPLICATION);
    RegisterClassEx(&wcex);
    hwnd = CreateWindowEx( WS_EX_APPWINDOW, "classname", " ", WS_POPUPWINDOW, 0, 0, 800, 600, HWND_DESKTOP, NULL, hInstance, NULL );
 
    PIXELFORMATDESCRIPTOR pfd;
    int iFormat;
    hDC = GetDC (hwnd);
    ZeroMemory (&pfd, sizeof (pfd));
    pfd.nSize       = sizeof (pfd);
    pfd.nVersion    = 1;
    pfd.dwFlags     = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType  = PFD_TYPE_RGBA;
    pfd.cColorBits  = 24;
    pfd.cDepthBits  = 16;
    pfd.iLayerType  = PFD_MAIN_PLANE;
    iFormat         = ChoosePixelFormat (hDC, &pfd);
    SetPixelFormat (hDC, iFormat, &pfd);
 
    hRC = wglCreateContext(hDC);
    wglMakeCurrent(hDC, hRC);
 
    glGenVertexArrays   = (PFNGLGENVERTEXARRAYSPROC)wglGetProcAddress("glGenVertexArrays");
    glBindVertexArray   = (PFNGLBINDVERTEXARRAYPROC)wglGetProcAddress("glBindVertexArray");
    glGenBuffers        = (PFNGLGENBUFFERSPROC)     wglGetProcAddress("glGenBuffers");
    glBindBuffer        = (PFNGLBINDBUFFERPROC)     wglGetProcAddress("glBindBuffer");
    glBufferData        = (PFNGLBUFFERDATAPROC)     wglGetProcAddress("glBufferData");
    glDeleteBuffers     = (PFNGLDELETEBUFFERSPROC)  wglGetProcAddress("glDeleteBuffers");
 
    ShowWindow(hwnd, nCmdShow);
    ShowCursor(false);
 
 
    glViewport(0, 0, 800, 600);
    glMatrixMode(GL_PROJECTION);
 
    gluPerspective(45.0f, 800.0/600.0, 0.1f, 100.0f);
    glMatrixMode(GL_MODELVIEW);
 
    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
    glDepthFunc(GL_LEQUAL);
    glDepthRange(0.0, 1.0);
    glEnable(GL_DEPTH_TEST);
 
 
 
 
 
    int sphere  = Load_Object(0, "sphere.txt"); // ЗАГРУЖАЕМ МОДЕЛЬ
    int texture = Load_BMP(0, "texture.bmp");   // ЗАГРУЖАЕМ ТЕКСТУРУ
 
 
 
 
 
    while ( msg.message != WM_QUIT )
    {
        if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {
            glMatrixMode(GL_MODELVIEW);
            glLoadIdentity();
            gluLookAt( 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0 );
 
            glClearColor(0.6f, 0.8f, 1.0f, 0.0f);
            glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 
            glEnable(GL_BLEND);
            glEnable(GL_TEXTURE_2D);
            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
 
            glPushMatrix();
            glTranslatef( 0.0, 0.0, 5.0 );
            glRotatef( 0.0, 0.0, 0.0, 0.0 );
            glBindTexture(GL_TEXTURE_2D, texName[0]);
 
            Draw_Object(0);
 
            glPopMatrix();
 
            glDisable(GL_TEXTURE_2D);
            glDisable(GL_BLEND);
 
            glFlush();
            SwapBuffers (hDC);
        }
    }
    // УДАЛЕНИЕ БУФЕРОВ
    for (int i = 0; i < 256; i ++)
    {
        glDeleteBuffers(1, &VertexVBOID[i]);
        glDeleteBuffers(1, &IndexVBOID[i]);
    }
    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(hRC);
    ReleaseDC(hwnd, hDC);
    DestroyWindow(hwnd);
    return msg.wParam;
}

///======================================================================
/// Name: WindowProc
/// Desc:
///======================================================================
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_CLOSE:
            PostQuitMessage(0);
            break;
        case WM_KEYDOWN:
            switch (wParam)
            {
                case VK_ESCAPE:
                    PostQuitMessage(0);
                    break;
            }
            break;
        default:
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
    return 0;
}
 
 
 
 
#define BUFFER_OFFSET(i) ((void*)(i))
#define MAX_OBJECTS 512
 
// СТРУКТУРА ВЕРШИНЫ
struct MyVertex
{
    float x, y, z;      // КООРДИТАТЫ ВЕРШИНЫ
    float nx, ny, nz;   // НОРМАЛИ
    float s0, t0;       // ТЕКСТУРНЫЕ КООРДИНАТЫ
};
 
int v_count[MAX_OBJECTS] = {0};     // кол-во вершин
int i_count[MAX_OBJECTS] = {0};     // кол-во индексов
 
GLuint VertexVBOID[MAX_OBJECTS];    // буфер вершин
GLuint IndexVBOID[MAX_OBJECTS];     // буфер индексов
 
MyVertex pvertex[MAX_OBJECTS][64000];           // массив вершин
unsigned short pindices[MAX_OBJECTS][64000];    // массив индексов
 
 
///======================================================================
/// Name: Load_Object
/// Desc:
///======================================================================
int Load_Object(int id, char name[])
{
    FILE *file;
    int i = 0;
 
    file = fopen(name, "rt");
 
    fscanf(file, "%d", &v_count[id]);
    fscanf(file, "%d", &i_count[id]);
 
    for (i = 0; i < v_count[id]; i ++)
    {
        fscanf(file, "%f", &pvertex[id][i].x);
        fscanf(file, "%f", &pvertex[id][i].y);
        fscanf(file, "%f", &pvertex[id][i].z);
        fscanf(file, "%f", &pvertex[id][i].nx);
        fscanf(file, "%f", &pvertex[id][i].ny);
        fscanf(file, "%f", &pvertex[id][i].nz);
        fscanf(file, "%f", &pvertex[id][i].s0);
        fscanf(file, "%f", &pvertex[id][i].t0);
    }
 
    for (i = 0; i < 3*i_count[id]; i ++)
    {
        fscanf(file, "%u", &pindices[id][i]);
        pindices[id][i] -= 1; // ВЫЧИТАЕМ ЕДИНИЦУ ПОТОМУ ЧТО 3D MAX И ТП ХРАНЯТ ИНДЕКСЫ В МАССИВАХ НАЧИНАЮЩИХСЯ НЕ С НУЛЯ, А С ЕДИНИЦЫ
    }
    fclose(file);
 
 
    glGenBuffers(1, &VertexVBOID[id]);
    glBindBuffer(GL_ARRAY_BUFFER, VertexVBOID[id]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(MyVertex)*v_count[id], &pvertex[id][0].x, GL_STATIC_DRAW);
 
    glGenBuffers(1, &IndexVBOID[id]);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexVBOID[id]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned short)*3*i_count[id], pindices[id], GL_STATIC_DRAW);
 
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    return 1;
}
 
 
 
 
///======================================================================
/// Name: Draw_Object
/// Desc:
///======================================================================
void Draw_Object(int id)
{
    glPushClientAttrib  ( GL_CLIENT_VERTEX_ARRAY_BIT );
 
    glBindBuffer(GL_ARRAY_BUFFER, VertexVBOID[id]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(MyVertex)*v_count[id], &pvertex[id][0].x, GL_STATIC_DRAW);
 
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(3, GL_FLOAT, sizeof(MyVertex), BUFFER_OFFSET(0));
 
    glEnableClientState(GL_NORMAL_ARRAY);
    glNormalPointer(GL_FLOAT, sizeof(MyVertex), BUFFER_OFFSET(12));
 
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glTexCoordPointer(2, GL_FLOAT, sizeof(MyVertex), BUFFER_OFFSET(24));
 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexVBOID[id]);
    glDrawElements(GL_TRIANGLES, 3*i_count[id], GL_UNSIGNED_SHORT, BUFFER_OFFSET(0));
 
    glPopClientAttrib();
}
 
 
 
 
GLuint texName[MAX_OBJECTS] = {0};
 
///=============================================================================================
/// Name: Load_BMP
/// Desc:
///=============================================================================================
int Load_BMP(int id, char filename[])
{
    BITMAPFILEHEADER    headfirst;
    BITMAPINFOHEADER    headsecond;
    FILE *fin;
 
    fin = fopen(filename, "rb");
 
    fread( &headfirst, sizeof(BITMAPFILEHEADER), 1, fin );
    fread( &headsecond, sizeof(BITMAPINFOHEADER), 1, fin );
 
    unsigned int imgWidth = headsecond.biWidth;
    unsigned int imgHeight = headsecond.biHeight;
 
    RGBQUAD pixel[imgWidth*imgHeight];
 
    for ( int j = 0; j < imgWidth*imgHeight; j+=1 )
    {
        fread( &pixel[j].rgbRed, 1, 1, fin );
        fread( &pixel[j].rgbGreen, 1, 1, fin );
        fread( &pixel[j].rgbBlue, 1, 1, fin );
        pixel[j].rgbReserved = 255;
    }
 
    fclose(fin);
 
    glGenTextures(1, &texName[id]);
    glBindTexture(GL_TEXTURE_2D, texName[id]);
 
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    
    // МИП-МАППИНГ ТЕКСТУР
    gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, imgWidth, imgHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixel);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    return 1;
}

if (Load_Object(0, "name.file")!=1)
{
    fprinrf(out_file, "ошибка загрузки!");
}