Attachment 34494 Details for Bug 27312 – Source code for reproducing the problem.

Source code for reproducing the problem.

copytex.c (text/plain), 12.74 KB, created by Karthik Hariharakrishnan on 2010-03-26 10:44:37 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Karthik Hariharakrishnan

Created: 2010-03-26 10:44:37 UTC

Size: 12.74 KB

patch

obsolete

>
>/* Includes */
>#include <EGL/egl.h>
>#include <GLES2/gl2.h>
>#include <stdio.h>
>#include <unistd.h>
>#include <stdlib.h>
>#include <math.h>
>#include <X11/Xlib.h>
>
>#include "main.h"
>static GLint vertices_loc, txtSampler, txtCoord_loc, colors_loc;
>GLubyte *buf;
>GLuint projMat_loc;
>int     j;
>
>void computeMatrix(GLfloat *mat4, GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
>{
>        GLfloat inv_width = 1.0f / (r - l);
>        GLfloat inv_height = 1.0f / (t - b);
>        GLfloat inv_depth = 1.0f / (f - n);
>
>        memset(mat4, 0, sizeof(GLfloat) * 16);
>
>        /*                                      
>                0       4       8       12
>                1       5       9       13
>                2       6       10      14
>                3       7       11      15
>                                                */
>
>        mat4[0] = 2.0f * inv_width;
>        mat4[5] = 2.0f * inv_height;
>        mat4[10] = 2.0f * inv_depth;
>
>        mat4[12] = -(r + l) * inv_width;
>        mat4[13] = -(t + b) * inv_height;
>        mat4[14] = -(f + n) * inv_depth;
>        mat4[15] = 1.0f;
>}
>static long int random_value = 1;
>static char colorBufferFormatName[40];
>
>int main(int cArgs, char **aArgs)
>{
>    /* EGL variables */
>    EGLDisplay sEGLDisplay;
>    EGLContext sEGLContext;
>    EGLSurface sEGLSurface;
>    /* EGL_RENDERABLE_TYPE must be set to EGL_OPENGL_ES2_BIT. Otherwise, no
>     * configurations will be returned. */
>    EGLint aEGLAttributes[] =
>    {
>        EGL_RED_SIZE, 8,
>        EGL_GREEN_SIZE, 8,
>        EGL_BLUE_SIZE, 8,
>        EGL_DEPTH_SIZE, 16,
>        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
>        EGL_NONE
>    };
>    EGLConfig aEGLConfigs[1];
>    EGLint cEGLConfigs;
>    /* The default version is 1. 2 must be passed else eglCreateContext will
>     * fail. */
>    EGLint aEGLContextAttributes[] =
>    {
>        EGL_CONTEXT_CLIENT_VERSION, 2,
>        EGL_NONE
>    };
>
>    /* Platform-specific variables */
>    XSetWindowAttributes win_attrs;
>    int attrs[64], idx = 0, num_config = 0;
>    unsigned int uiHeight = 64;
>    unsigned int uiWidth = 64;
>    Window win;
>    Display* display;
>    int major, minor;
>    Colormap colormap;
>    XVisualInfo *pVisual;
>    XEvent e;
>
>    /* GL specific variables */
>    GLint iLocPosition;
>    GLint iLocColour;
>    GLint iLocMVP;
>    GLuint uiProgram;
>    GLuint uiFragShader;
>    GLuint uiVertShader;
>
>    /* Misc variables */
>    int bDone = 0;
>    int iXangle = 0 * 3;
>    int iYangle = 0 * 2;
>    int iZangle = 0 * 1;
>    float aRotate[16];
>    float aModelView[16], aPerspective[16], aMVP[16];
>    
>    GLenum colorBufferFormat, targetFormats[5];
>    GLsizei numTargetFormats;
>    GLfloat ref[4], exp[4], buf[4];
>    GLsizei textureBits[4];
>    GLfloat eps[4];
>    GLfloat matProjection[16];
>    long i, ii, max;
>
>	GLfloat texCoords0[2] = { 0.0f, 0.0f };
>    GLfloat texCoords1[2] = { 1.0f, 1.0f};
>    GLfloat vertex[2];
>    GLfloat texCol[4];
>	GLubyte *tmpBuf;
>
>	GLfloat col[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
>
>    /* Open X display */
>    display = XOpenDisplay(NULL);
>    if (NULL == display)
>    {
>        /* Environment variable DISPLAY not set */
>        printf("Failed to open display.\n");
>    }
>
>    /* Initialize EGL */
>    sEGLDisplay = EGL_CHECK(eglGetDisplay(display));
>    EGL_CHECK(eglInitialize(sEGLDisplay, NULL, NULL));
>    EGL_CHECK(eglChooseConfig(
>        sEGLDisplay,
>        aEGLAttributes,
>        aEGLConfigs,
>        1,
>        &cEGLConfigs));
>    if (cEGLConfigs == 0)
>    {
>        printf("No EGL configurations were returned.\n");
>    }
>
>    /* Create X window */
>    win = CreateXWindow(
>        "OpenGL ES 2.0 Example on a Linux Desktop",
>        uiWidth,
>        uiHeight,
>        display,
>        sEGLDisplay,
>        aEGLConfigs[0],
>        &colormap,
>        &pVisual);
>    if (!win)
>    {
>        /* Failed to create X window */
>        printf("Failed to create X window.\n");
>    }
>
>    sEGLSurface = EGL_CHECK(eglCreateWindowSurface(
>        sEGLDisplay,
>        aEGLConfigs[0],
>        win,
>        NULL));
>    if (EGL_NO_SURFACE == sEGLSurface)
>    {
>        printf("Failed to create EGL surface.\n");
>    }
>
>    sEGLContext = EGL_CHECK(eglCreateContext(
>        sEGLDisplay,
>        aEGLConfigs[0],
>        EGL_NO_CONTEXT,
>        aEGLContextAttributes));
>    if (EGL_NO_CONTEXT == sEGLContext)
>    {
>        printf("Failed to create EGL context.\n");
>    }
>
>    EGL_CHECK(eglMakeCurrent(
>        sEGLDisplay,
>        sEGLSurface,
>        sEGLSurface,
>        sEGLContext));
>
>    
>    computeMatrix(matProjection, 0.0f, (GLfloat)uiWidth, 0.0f, (GLfloat)uiHeight, 1.0f, -1.0f);
>    glDisable(GL_DITHER);
>
>	
>    /* Initialize shaders */
>    processShader(&uiVertShader, VERT_FILE, GL_VERTEX_SHADER);
>    processShader(&uiFragShader, FRAG_FILE, GL_FRAGMENT_SHADER);
>
>    /* Create uiProgram (ready to attach shaders) */
>    uiProgram = GL_CHECK(glCreateProgram());
>
>    /* Attach shaders and link uiProgram */
>    GL_CHECK(glAttachShader(uiProgram, uiVertShader));
>    GL_CHECK(glAttachShader(uiProgram, uiFragShader));
>    GL_CHECK(glLinkProgram(uiProgram));
>
>    GL_CHECK(glUseProgram(uiProgram));
>
>    projMat_loc = glGetUniformLocation(uiProgram, "mvpMatrix_uni");
>    glUniformMatrix4fv(projMat_loc, 1, 0, matProjection);
>
>    vertices_loc = glGetAttribLocation(uiProgram, "vertex_att");
>    colors_loc = glGetAttribLocation(uiProgram, "color_att");
>    txtCoord_loc = glGetAttribLocation(uiProgram, "multiTexCoord_att");
>    txtSampler = glGetUniformLocation(uiProgram, "texture0");
>
>    glEnableVertexAttribArray(vertices_loc);
>    glEnableVertexAttribArray(colors_loc);
>    glEnableVertexAttribArray(txtCoord_loc);
>
>    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
>
>	texCol[0] = 0.56;
>    texCol[1] = 0.56;
>    texCol[2] = 0.56;
>    texCol[3] = 0.56;
>
>    glClear(GL_COLOR_BUFFER_BIT);
>
>    glVertexAttribPointer(txtCoord_loc, 2, GL_FLOAT, GL_FALSE, 0, texCoords1);
>
>    vertex[0] = 4.5;
>    vertex[1] = 4.5;
>
>    glVertexAttribPointer(vertices_loc, 2, GL_FLOAT, GL_FALSE, 0, &vertex[0]);
>    glVertexAttribPointer(colors_loc, 4, GL_FLOAT, GL_FALSE, 0, texCol);
>
>    glDrawArrays(GL_POINTS, 0, 1);
>
>    glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 4, 4, 1, 1, 0); 
>
>    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (GLfloat)GL_NEAREST);
>    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (GLfloat)GL_NEAREST);
>    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, (GLfloat)GL_CLAMP_TO_EDGE);
>    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, (GLfloat)GL_CLAMP_TO_EDGE);
>
>    glActiveTexture(GL_TEXTURE0);
>
>    glUniform1i(txtSampler, 0); 
>    glVertexAttribPointer(txtCoord_loc, 2, GL_FLOAT, GL_FALSE, 0, texCoords0);
>
>    vertex[0] = 12.5;
>    vertex[1] = 12.5;
> 
>    col[0] = col[1] = col[2] = col[3] = 1; 
>
>    glVertexAttribPointer(vertices_loc, 2, GL_FLOAT, GL_FALSE, 0, &vertex[0]);
>    glVertexAttribPointer(colors_loc, 4, GL_FLOAT, GL_FALSE, 0, col);
>
>    glDrawArrays(GL_POINTS, 0, 1);
>
>
>    tmpBuf = (GLubyte *)malloc(4*sizeof(GLubyte));
>    glReadPixels(12, 12, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, tmpBuf);    
>
>    
>     return 0;
>}
>
>/* Simulates desktop's glRotatef. The matrix is returned in
> * column-major order. */
>void rotateMatrix(
>    double angle,
>    double x,
>    double y,
>    double z,
>    float *R)
>{
>    double radians, c, s, c1, u[3], length;
>    int i, j;
>
>    radians = (angle * M_PI)/180.0;
>    c = cos(radians);
>    s = sin(radians);
>    c1 = 1.0 - cos(radians);
>    length = sqrt(x * x + y * y + z * z);
>    u[0] = x/length;
>    u[1] = y/length;
>    u[2] = z/length;
>
>    for (i = 0; i < 16; i++)
>    {
>        R[i] = 0.0;
>    }
>    R[15] = 1.0;
>
>    for (i = 0; i < 3; i++)
>    {
>        R[i * 4 + (i + 1) % 3] = u[(i + 2) % 3] * s;
>        R[i * 4 + (i + 2) % 3] = -u[(i + 1) % 3] * s;
>    }
>
>    for (i = 0; i < 3; i++)
>    {
>        for (j = 0; j < 3; j++)
>        {
>            R[i * 4 + j] += c1 * u[i] * u[j] + (i == j ? c : 0.0);
>        }
>    }
>}
>
>/* Simulates gluPerspectiveMatrix */
>void perspectiveMatrix(
>    double fovy,
>    double aspect,
>    double znear,
>    double zfar,
>    float *P)
>{
>    int i;
>    double f;
>
>    f = 1.0/tan(fovy * 0.5);
>
>    for (i = 0; i < 16; i++)
>    {
>        P[i] = 0.0;
>    }
>
>    P[0] = f/aspect;
>    P[5] = f;
>    P[10] = (znear + zfar)/(znear - zfar);
>    P[11] = -1.0;
>    P[14] = (2.0 * znear * zfar)/(znear - zfar);
>    P[15] = 0.0;
>}
>
>/* Multiplies A by B and writes out to C. All matrices are 4x4 and column
> * major. In-place multiplication is supported. */
>void multiplyMatrix(float *A, float *B, float *C)
>{
>    int i, j, k;
>    float aTmp[16];
>
>    for (i = 0; i < 4; i++)
>    {
>        for (j = 0; j < 4; j++)
>        {
>            aTmp[j * 4 + i] = 0.0;
>            for (k = 0; k < 4; k++)
>            {
>                aTmp[j * 4 + i] += A[k * 4 + i] * B[j * 4 + k];
>            }
>        }
>    }
>
>    for (i = 0; i < 16; i++)
>    {
>        C[i] = aTmp[i];
>    }
>}
>
>/* Creates a shader, loads in source, compiles, dumps debug as necessary.
> * pShader: Pointer to return created shader ID.
> * sFilename: Passed-in filename from which to load shader source.
> * iShaderType: Passed to GL e.g. GL_VERTEX_SHADER. */
>void processShader(GLuint *pShader, char *sFilename, GLint iShaderType)
>{
>    GLint iStatus;
>    const char *aStrings[1] = { NULL };
>
>    /* Create shader and load into GL */
>    *pShader = GL_CHECK(glCreateShader(iShaderType));
>    aStrings[0] = loadShader(sFilename);
>    GL_CHECK(glShaderSource(*pShader, 1, aStrings, NULL));
>
>    /* Clean up shader source */
>    free((void *)(aStrings[0]));
>    aStrings[0] = NULL;
>
>    /* Try compiling the shader */
>    GL_CHECK(glCompileShader(*pShader));
>    GL_CHECK(glGetShaderiv(*pShader, GL_COMPILE_STATUS, &iStatus));
>
>    /* Dump debug info (source and log) if compilation failed */
>    if(iStatus != GL_TRUE)
>    {
>        GLint iLen;
>        char *sDebugSource = NULL;
>        char *sErrorLog = NULL;
>
>        /* Get shader source */
>        GL_CHECK(glGetShaderiv(*pShader, GL_SHADER_SOURCE_LENGTH, &iLen));
>        sDebugSource = malloc(iLen);
>        GL_CHECK(glGetShaderSource(*pShader, iLen, NULL, sDebugSource));
>        printf("Debug source START:\n%s\nDebug source END\n\n", sDebugSource);
>        free(sDebugSource);
>
>        /* Now get the info log */
>        GL_CHECK(glGetShaderiv(*pShader, GL_INFO_LOG_LENGTH, &iLen));
>        sErrorLog = malloc(iLen);
>        GL_CHECK(glGetShaderInfoLog(*pShader, iLen, NULL, sErrorLog));
>        printf("Log START:\n%s\nLog END\n\n", sErrorLog);
>        free(sErrorLog);
>
>        printf("Compilation FAILED!\n\n");
>        exit(1);
>    }
>}
>
>/* Loads the shader source into memory.
> * sFilename: String holding filename to load */
>char* loadShader(char *sFilename)
>{
>    char *pResult = NULL;
>    FILE *pFile = NULL;
>    long iLen = 0;
>
>    pFile = fopen(sFilename, "r");
>    if(pFile == NULL)
>    {
>        fprintf(stderr, "Error: Cannot read file '%s'\n", sFilename);
>        exit(1);
>    }
>
>    fseek(pFile, 0, SEEK_END); /* Seek end of file */
>    iLen = ftell(pFile);
>    fseek(pFile, 0, SEEK_SET); /* Seek start of file again */
>    pResult = calloc(iLen+1, sizeof(char));
>    fread(pResult, sizeof(char), iLen, pFile);
>    pResult[iLen] = '\0';
>    fclose(pFile);
>
>    return pResult;
>}
>
>/* Waits for map notification */
>Bool WaitForMap(Display *d, XEvent *e, char *win_ptr)
>{
>    if (e->type == MapNotify && e->xmap.window == (*((Window*)win_ptr)))
>    {
>        return True;
>    }
>    return False;
>}
>
>/* Creates an X window */
>Window CreateXWindow(
>    const char *title,
>    int width,
>    int height,
>    Display* display,
>    EGLDisplay sEGLDisplay,
>    EGLConfig FBConfig,
>    Colormap *pColormap,
>    XVisualInfo **ppVisual)
>{
>    XSetWindowAttributes wa;
>    XSizeHints sh;
>    XEvent e;
>    unsigned long mask;
>    long screen;
>    XVisualInfo *visual, template;
>    Colormap colormap;
>    int vID, n;
>    Window window;
>
>    screen = DefaultScreen(display);
>    eglGetConfigAttrib(sEGLDisplay, FBConfig, EGL_NATIVE_VISUAL_ID, &vID);
>    template.visualid = vID;
>    visual = XGetVisualInfo(display, VisualIDMask, &template, &n);
>    colormap = XCreateColormap(
>        display,
>        RootWindow(display, screen),
>        visual->visual,
>        AllocNone);
>    wa.colormap = colormap;
>    wa.background_pixel = 0xFFFFFFFF;
>    wa.border_pixel = 0;
>    wa.event_mask = StructureNotifyMask | ExposureMask;
>
>    mask = CWBackPixel | CWBorderPixel | CWEventMask | CWColormap;
>
>    window = XCreateWindow(
>       display,
>       RootWindow(display, screen),
>       0,
>       0,
>       width,
>       height,
>       0,
>       visual->depth,
>       InputOutput,
>       visual->visual,
>       mask,
>       &wa);
>
>    sh.flags = USPosition;
>    sh.x = 10;
>    sh.y = 10;
>    XSetStandardProperties(display, window, title, title, None, 0, 0, &sh);
>    XMapWindow(display, window);
>    XIfEvent(display, &e, WaitForMap, (char*)&window);
>    XSetWMColormapWindows(display, window, &window, 1);
>    XFlush(display);
>
>    *pColormap = colormap;
>    *ppVisual = visual;
>
>    return window;
>}

Actions: View

Attachments on bug 27312: 34438 | 34439 | 34494 | 34495 | 34496

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.