Attachment 89409 Details for Bug 71741 – std140 array bug

std140 array bug

std140_bug.c (text/plain), 7.39 KB, created by Stanislav Vorobiov on 2013-11-18 14:31:45 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Stanislav Vorobiov

Created: 2013-11-18 14:31:45 UTC

Size: 7.39 KB

patch

obsolete

>#include <GL/glx.h>
>#include <stdio.h>
>#include <stdlib.h>
>#include <unistd.h>
>#include <math.h>
>#include <assert.h>
>
>static Display *dpy;
>static GLXWindow glx_window;
>
>static float rotations[10] = {
>    0.0f,
>    0.0f, /* rotations[1] from shader should refer to this */
>    0.0f,
>    0.0f,
>    85.0f, /* but instead it refers to this */
>    0.0f,
>    0.0f,
>    0.0f,
>    0.0f,
>    0.0f
>};
>
>static const GLfloat verts[3][2] = {
>    { -0.5, -0.5 },
>    {  0.5, -0.5 },
>    {  0,    0.5 }
>};
>
>static const GLfloat colors[3][3] = {
>    { 1, 0, 0 },
>    { 0, 1, 0 },
>    { 0, 0, 1 }
>};
>
>static const char *vert_shader_text =
>    "#version 300 es\n\n"
>    "const float pi = 3.14159265358979323846;\n"
>    "layout(std140) uniform my_block\n"
>    "{\n"
>    "  float rotations[10];\n"
>    "};\n"
>    "in vec4 pos;\n"
>    "in vec4 color;\n"
>    "out vec4 v_color;\n"
>    "void main() {\n"
>    "  float angle = rotations[1]; \n" /* This appears to be 85.0 when should be 0.0 */
>    "  mat4 rotation = mat4 (cos(pi * angle / 180.0), 0.0, sin(pi * angle / 180.0), 0.0,\n"
>    "                        0.0, 1.0, 0.0, 0.0,\n"
>    "                        -sin(pi * angle / 180.0), 0.0, cos(pi * angle / 180.0), 0.0,\n"
>    "                        0.0, 0.0, 0.0, 1.0);\n"
>    "  gl_Position = rotation * pos;\n"
>    "  v_color = color;\n"
>    "}\n";
>
>static const char *frag_shader_text =
>    "#version 300 es\n\n"
>    "in vec4 v_color;\n"
>    "out vec4 color;\n"
>    "void main() {\n"
>    "  color = v_color;\n"
>    "}\n";
>
>static GLuint buff[3];
>static GLuint frag, vert;
>static GLuint program;
>
>static GLuint create_shader(const char *source, GLenum shader_type)
>{
>    GLuint shader;
>    GLint status;
>
>    shader = glCreateShader(shader_type);
>    assert(shader != 0);
>
>    glShaderSource(shader, 1, (const char **)&source, NULL);
>    glCompileShader(shader);
>
>    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
>
>    if (!status) {
>        printf("Failed to compile shader\n");
>        exit(1);
>    }
>
>    return shader;
>}
>
>static void run()
>{
>    glViewport(0, 0, 640, 480);
>
>    glClearColor(0.0, 0.0, 0.0, 0.5);
>    glClear(GL_COLOR_BUFFER_BIT);
>
>    glBindBuffer(GL_ARRAY_BUFFER, buff[0]);
>    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
>    glBindBuffer(GL_ARRAY_BUFFER, buff[1]);
>    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL);
>    glEnableVertexAttribArray(0);
>    glEnableVertexAttribArray(1);
>
>    glDrawArrays(GL_TRIANGLES, 0, 3);
>
>    glDisableVertexAttribArray(0);
>    glDisableVertexAttribArray(1);
>
>    glXSwapBuffers(dpy, glx_window);
>}
>
>int main(int argc, char *argv[])
>{
>    int config_attribs[] =
>    {
>        GLX_DOUBLEBUFFER, True,
>        GLX_RED_SIZE, 8,
>        GLX_GREEN_SIZE, 8,
>        GLX_BLUE_SIZE, 8,
>        GLX_ALPHA_SIZE, 8,
>        GLX_BUFFER_SIZE, 32,
>        GLX_DEPTH_SIZE, 24,
>        GLX_STENCIL_SIZE, 8,
>        GLX_RENDER_TYPE, GLX_RGBA_BIT,
>        GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
>        None
>    };
>    static int ctx_attribs[] =
>    {
>        GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
>        GLX_CONTEXT_MINOR_VERSION_ARB, 1,
>        GLX_RENDER_TYPE, GLX_RGBA_TYPE,
>        GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
>        None
>    };
>    int n;
>    GLXFBConfig *configs;
>    int vID;
>    XVisualInfo *visual, template;
>    XSetWindowAttributes wa;
>    Colormap colormap;
>    Window window;
>    XSizeHints sh;
>    GLXContext ctx;
>    GLint status;
>    GLuint vao;
>    PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB;
>
>    dpy = XOpenDisplay(NULL);
>
>    if (!dpy) {
>        printf("Failed to open display\n");
>        exit(1);
>    }
>
>    configs = glXChooseFBConfig(dpy,
>                                DefaultScreen(dpy),
>                                config_attribs,
>                                &n);
>
>    if (n <= 0) {
>        printf("Failed to choose config\n");
>        exit(1);
>    }
>
>    if (glXGetFBConfigAttrib(dpy,
>                             configs[0],
>                             GLX_VISUAL_ID,
>                             &vID) != Success) {
>        printf("Failed to get config attrib\n");
>        exit(1);
>    }
>
>    template.visualid = vID;
>
>    if ((visual = XGetVisualInfo(dpy, VisualIDMask, &template, &n)) == NULL) {
>        printf("Failed in XGetVisualInfo\n");
>        exit(1);
>    }
>
>    colormap = XCreateColormap(dpy,
>                               RootWindow(dpy, DefaultScreen(dpy)),
>                               visual->visual,
>                               AllocNone);
>    wa.colormap = colormap;
>    wa.background_pixel = 0xFF95FF94;
>    wa.border_pixel = 0;
>    wa.event_mask = StructureNotifyMask | ExposureMask;
>
>    window = XCreateWindow(dpy,
>                           RootWindow(dpy, DefaultScreen(dpy)),
>                           0,
>                           0,
>                           640,
>                           480,
>                           0,
>                           visual->depth,
>                           InputOutput,
>                           visual->visual,
>                           CWBackPixel | CWBorderPixel | CWEventMask | CWColormap,
>                           &wa);
>
>    if (window == 0) {
>        printf("Couldn't create window\n");
>        exit(1);
>    }
>
>    sh.flags = USPosition;
>    sh.x = 0;
>    sh.y = 0;
>
>    XSetStandardProperties(dpy,
>                           window,
>                           "std140 bug",
>                           "std140 bug",
>                           None,
>                           0,
>                           0,
>                           &sh);
>
>    XMapWindow(dpy, window);
>    XSetWMColormapWindows(dpy, window, &window, 1);
>    XFlush(dpy);
>
>    glx_window = glXCreateWindow(dpy, configs[0], window, NULL);
>
>    if (!glx_window) {
>        printf("Failed to create GLX surface\n");
>        exit(1);
>    }
>
>    glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glXGetProcAddressARB("glXCreateContextAttribsARB");
>
>    ctx = glXCreateContextAttribsARB(dpy,
>                                     configs[0],
>                                     NULL,
>                                     True,
>                                     ctx_attribs);
>
>    if (!ctx) {
>        printf("Failed to create GLX context\n");
>        exit(1);
>    }
>
>    if (!glXMakeContextCurrent(dpy, glx_window, glx_window, ctx)) {
>        printf("Failed to make GLX context current\n");
>        exit(1);
>    }
>
>    glGenVertexArrays(1, &vao);
>    glBindVertexArray(vao);
>
>    glGenBuffers(3, buff);
>    glBindBuffer(GL_ARRAY_BUFFER, buff[0]);
>    glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
>    glBindBuffer(GL_ARRAY_BUFFER, buff[1]);
>    glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
>    glBindBuffer(GL_ARRAY_BUFFER, buff[2]);
>    glBufferData(GL_ARRAY_BUFFER, sizeof(rotations), rotations, GL_STATIC_DRAW);
>
>    frag = create_shader(frag_shader_text, GL_FRAGMENT_SHADER);
>    vert = create_shader(vert_shader_text, GL_VERTEX_SHADER);
>    program = glCreateProgram();
>
>    glAttachShader(program, frag);
>    glAttachShader(program, vert);
>    glLinkProgram(program);
>
>    glGetProgramiv(program, GL_LINK_STATUS, &status);
>
>    if (!status) {
>        printf("Failed to link program\n");
>        exit(1);
>    }
>
>    glUseProgram(program);
>    glBindAttribLocation(program, 0, "pos");
>    glBindAttribLocation(program, 1, "color");
>    glLinkProgram(program);
>
>    glUniformBlockBinding(program, 0, 0);
>    glBindBufferBase(GL_UNIFORM_BUFFER, 0, buff[2]);
>
>    while (1) {
>        run();
>    }
>
>    return 0;
>}

Actions: View

Attachments on bug 71741: 89409

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.