VBO + glBufferData stürzt ab, wenn die Größe zu hoch ist

Question

Ich versuche, einen einfachen VBO zu bekommen. Aber wenn ich rufe

glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex)*vertexcount, vertices, GL_STATIC_DRAW); 

stürzt nur, aber nur, wenn vertexcount über 1531 ist Und ja, die „Ecken“ Array speichert, oder besser gesagt es gibt genug Platz zugewiesen, für mehr als 1531 Elemente. Das ist meine Vertex-Struktur:

typedef struct{ 
    float x, y, z; 
    float nx, ny, nz; 
    float u, v; 
}Vertex, vertex; 

So sollte es 32 Byte sein. 32 Bytes * 1531 = 48992 Bytes = 48 KB.

Aber 48kb scheint nicht zu hoch für einen normalen VBO? Ich verstehe nicht, was passiert.

Edit:

Windows Xp 32bit Service Pack 3

Nvidia GeForce 9800GT 1024MB

Edit2: Kurzfassung meines kompletten Code: (interessanter Teil an der Unterseite ist)

#include <windows.h> 
#include <glew.h> 
#include <wglew.h> 
#include <gl3.h> 
#include <gl/glu.h> 
#define BUFFER_OFFSET(i) ((char *)NULL + (i)) 

typedef struct{ 
    float x, y, z; 
float nx, ny, nz; 
float u, v; 
}Vertex, vertex; 

typedef struct{ 
    int first, second, third; 
}VertexIndex, vertexindex, vindex, Vindex; 

typedef struct{ 
    unsigned int vao; 
    unsigned int vertexcount, indexcount; 
}Mesh, mesh; 

typedef struct{ 
    HWND hwnd; 
    HDC hdc; 
    HGLRC hrc; 
}GLWindow, Window, window; 

void WindowShenanigans(Window *w, HINSTANCE *hinstance, WNDPROC WindowProc) 
{ 
    HWND tmp_hwnd; 
    WNDCLASS wndclass; 

    ZeroMemory(&wndclass, sizeof(WNDCLASS)); 
    wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC | CS_GLOBALCLASS; 
    wndclass.cbClsExtra = 0;  
    wndclass.cbWndExtra = 0; 
    wndclass.lpszMenuName = 0; 
    wndclass.hIcon = 0; 
    wndclass.hInstance = *hinstance; 
    wndclass.lpszClassName = "glclass"; 
    wndclass.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE); 
    wndclass.hCursor = LoadCursor(0, IDC_ARROW); 
    wndclass.lpfnWndProc = WindowProc; 

    if(RegisterClass(&wndclass) == 0) 
    { 
     return; 
    } 

    ShowCursor(TRUE); 

    tmp_hwnd = CreateWindowA ("glclass", 
          "bla", 
          WS_BORDER | WS_CAPTION | WS_SYSMENU, 
          0, 0, 
          600, 
          800, 
          HWND_DESKTOP, 
          NULL, 
          hinstance, 
          NULL); 

    w->hwnd = tmp_hwnd; 

    unsigned int PixelFormat; 
    PIXELFORMATDESCRIPTOR pfd; 

    pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); 
    pfd.nVersion = 1; 
    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; 
    pfd.iPixelType = PFD_TYPE_RGBA; 
    pfd.cColorBits = 32; 
    pfd.cDepthBits = 16; 
    pfd.cStencilBits = 32; 
    pfd.iLayerType = PFD_MAIN_PLANE; 

    w->hdc = GetDC(w->hwnd); 

    PixelFormat = ChoosePixelFormat(w->hdc, &pfd); 
    SetPixelFormat(w->hdc, PixelFormat, &pfd); 

    int attrib[] = 
    { 
      WGL_CONTEXT_MAJOR_VERSION_ARB, 3, 
      WGL_CONTEXT_MINOR_VERSION_ARB, 2, 
      WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, 
      0 
    }; //OpenGL Context 

    HGLRC tmphrc = wglCreateContext(w->hdc); 

    wglMakeCurrent (w->hdc, tmphrc); 

    PFNWGLCREATEBUFFERREGIONARBPROC wglCreateContextAttribsARB =  (PFNWGLCREATEBUFFERREGIONARBPROC)wglGetProcAddress("wglCreateContextAttribsARB"); 
    w->hrc = (HGLRC)wglCreateContextAttribsARB(w->hdc, 0, (UINT)attrib) ; 

    ShowWindow(w->hwnd, SW_SHOW); 
    UpdateWindow(w->hwnd); 
} 

LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) 
{ 
    switch(msg) 
    { 
     case WM_DESTROY: 
     { 
      PostQuitMessage(0); 
      return 0; 
     } 
     case WM_CLOSE: 
     { 
      PostQuitMessage(0); 
      return 0; 
     } 
     case WM_CREATE: 
     { 
     } 
     break; 
     case WM_SIZE: 
     { 
     } 
     break; 

     case WM_PAINT: 
     { 
     } 
     break; 
    } 
    return DefWindowProc(hwnd, msg, wparam, lparam); 
} 

BOOL ProcessMessage(MSG *msg) 
{ 
    if(GetMessage(msg, NULL, 0, 0) != 0) 
    { 
     TranslateMessage(msg); 
     DispatchMessage(msg); 
     return TRUE; 
    } 
    else 
    { 
     return FALSE; 
    } 
} 

/////////////////////////////////////////////////////////////////////////////////////////// 
void DataUpload(Mesh *m, Vindex *indices, Vertex *vertices) 
{ 
    unsigned int vbo, index_vbo; 

    glGenVertexArrays(1, &m->vao); 
    glBindVertexArray(m->vao); 

    glGenBuffers(1, &index_vbo); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_vbo); 
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int)*3500, indices, GL_STATIC_DRAW); 

    glGenBuffers(1, &vbo); 
    glBindBuffer(GL_ARRAY_BUFFER, vbo); 
    // MessageBox(HWND_DESKTOP, "3..2..1..", "", MB_OK); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex)*3500, vertices, GL_STATIC_DRAW); 
    // MessageBox(HWND_DESKTOP, "YEA", "", MB_OK); 

    glEnableVertexAttribArray(0); 
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), BUFFER_OFFSET(0)); 
    glEnableVertexAttribArray(1); 
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), BUFFER_OFFSET(sizeof(float)*3)); 
    glEnableVertexAttribArray(2); 
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), BUFFER_OFFSET(sizeof(float)*6)); 
    glBindVertexArray(0); 
} 

void MeshGenerate(Mesh *m, float x, float y, float z) 
{ 
     int i; 
     Vertex *vertices; 
     Vindex *indices; 
     m->vertexcount = 3500; 
     m->indexcount = 3500; 
     vertices = malloc(3500*sizeof(vertex)); 
     indices = malloc(3500*sizeof(vindex)); 

     for(i = 0; i<3500; i++) 
     { 
      vertices[i].x = 1.0f; 
      vertices[i].y = 1.0f; 
      vertices[i].z = 1.0f; 
      vertices[i].nx = 1.0f; 
      vertices[i].ny = 1.0f; 
      vertices[i].nz = 1.0f; 
      vertices[i].u = 1.0f; 
      vertices[i].v = 1.0f; 
     } 
     for(i = 0; i<3500; i++) 
     { 
      indices[i].first = 1; 
      indices[i].second = 1; 
      indices[i].third = 1; 
     } 
     DataUpload(m, vertices, indices); 
     return; 
} 

int WINAPI WinMain(HINSTANCE hinstance, HINSTANCE hprevinstance, LPSTR lpcmdline, int nshowcmd) 
{ 
    MSG msg; 
    BOOL isActive = 1; 
    window w; 
    WindowShenanigans(&w, &hinstance, WindowProc); 

    glewInit(); 

    Mesh m; 
    MeshGenerate(&m, 1.0f, 1.0f, 1.0f); 

    while(isActive == 1) 
    { 
     SwapBuffers(w.hdc); 
     isActive = ProcessMessage(&msg); 
    } 

    return msg.wParam; 
} 
//////////////////////////////////////////////////////////////////////////////// 

Answer 1

ogl.c: In function `MeshGenerate': 

ogl.c: 200: warning: übergeben arg 2 von DataUpload' from incompatible pointer type ogl.c:200: warning: passing arg 3 of DataUpload 'von inkompatiblen Zeigertyp

Ich habe nicht installiert installiert, so kann ich nicht die Probe richtig funktionieren. Aber das ist definitiv ein Problem.

DataUpload(m, vertices, indices); 

Es sollte

sein

DataUpload(m, indices, vertices);