Attachment 34366 Details for Bug 27265 – source code - sample GLES app

source code - sample GLES app

main.c (text/x-csrc), 13.77 KB, created by Karthik Hariharakrishnan on 2010-03-23 07:33:37 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Karthik Hariharakrishnan

Created: 2010-03-23 07:33:37 UTC

Size: 13.77 KB

patch

obsolete

>/*
> * $Copyright:
> * ----------------------------------------------------------------
> * This confidential and proprietary software may be used only as
> * authorised by a licensing agreement from ARM Limited
> *   (C) COPYRIGHT 2008-2009 ARM Limited
> *       ALL RIGHTS RESERVED
> * The entire notice above must be reproduced on all authorised
> * copies and copies may only be made to the extent permitted
> * by a licensing agreement from ARM Limited.
> * $
> *
> * Spinning shaded cube example for a Linux desktop.
> */
>
>/* 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"
>#include "3d.h"
>
>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 = 480;
>    unsigned int uiWidth = 640;
>    Window win;
>    Display* display;
>    int major, minor;
>    Colormap colormap;
>    XVisualInfo *pVisual;
>    XEvent e;
>
>    /* GL specific variables */
>    GLint iLocPosition;
>    GLint iLocColour;
>    GLint result = 0;
>    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];
>    int i;
>
>    /* Open X display */
>    display = XOpenDisplay(NULL);
>    if (NULL == display)
>    {
>        /* Environment variable DISPLAY not set */
>        printf("Failed to open display.\n");
>        goto exit;
>    }
>
>    /* 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");
>        goto exit;
>    }
>
>    /* 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");
>        goto exit;
>    }
>
>    sEGLSurface = EGL_CHECK(eglCreateWindowSurface(
>        sEGLDisplay,
>        aEGLConfigs[0],
>        win,
>        NULL));
>    if (EGL_NO_SURFACE == sEGLSurface)
>    {
>        printf("Failed to create EGL surface.\n");
>        goto exit;
>    }
>
>    sEGLContext = EGL_CHECK(eglCreateContext(
>        sEGLDisplay,
>        aEGLConfigs[0],
>        EGL_NO_CONTEXT,
>        aEGLContextAttributes));
>    if (EGL_NO_CONTEXT == sEGLContext)
>    {
>        printf("Failed to create EGL context.\n");
>        goto exit;
>    }
>
>    EGL_CHECK(eglMakeCurrent(
>        sEGLDisplay,
>        sEGLSurface,
>        sEGLSurface,
>        sEGLContext));
>
>    /* 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));
>
>    glGetProgramiv(uiProgram,GL_LINK_STATUS,&result);
>    if(result == GL_FALSE)
>    {
>        printf("Link Program failed !!!!\n");
>        exit(0);
>    }
>
>    /* Get attribute locations of non-fixed attributes like colour and texture coordinates. */
>    iLocPosition = GL_CHECK(glGetAttribLocation(uiProgram, "av4position"));
>    iLocColour = GL_CHECK(glGetAttribLocation(uiProgram, "av3colour"));
>
>    DEBUG1("iLocPosition:\t%i\n", iLocPosition);
>    DEBUG1("iLocColour:\t%i\n", iLocColour);
>
>    /* Get uniform locations */
>    iLocMVP = GL_CHECK(glGetUniformLocation(uiProgram, "mvp"));
>
>    DEBUG1("iLocMVP:\t%i\n", iLocMVP);
>
>    GL_CHECK(glUseProgram(uiProgram));
>
>    /* Enable attributes for position, colour and texture coordinates etc. */
>    GL_CHECK(glEnableVertexAttribArray(iLocPosition));
>    GL_CHECK(glEnableVertexAttribArray(iLocColour));
>
>    /* Populate attributes for position, colour and texture coordinates etc. */
>    GL_CHECK(glVertexAttribPointer(
>        iLocPosition,
>        3,
>        GL_FLOAT,
>        GL_FALSE,
>        0,
>        aVertices));
>
>    GL_CHECK(glVertexAttribPointer(
>        iLocColour,
>        3,
>        GL_FLOAT,
>        GL_FALSE,
>        0,
>        aColours));
>
>    GL_CHECK(glEnable(GL_CULL_FACE));
>    GL_CHECK(glEnable(GL_DEPTH_TEST));
>    
>    XSelectInput(
>        display,
>        win,
>        KeyPressMask | ExposureMask | EnterWindowMask | LeaveWindowMask
>        | PointerMotionMask | VisibilityChangeMask | ButtonPressMask
>        | ButtonReleaseMask | StructureNotifyMask);
>
>    /* Main event loop */
>    while(!bDone)
>    {
>        while (XPending(display) > 0)
>        {
>            XNextEvent(display, &e);
>            if (e.type == ButtonPress)
>            {
>                bDone = 1;
>            }
>        }
>
>        /* Do some rotation with Euler angles. It is not a fixed axis as
>         * quaterions would be, but the effect is cool. */
>        rotateMatrix(iXangle, 1.0, 0.0, 0.0, aModelView);
>        rotateMatrix(iYangle, 0.0, 1.0, 0.0, aRotate);
>        multiplyMatrix(aRotate, aModelView, aModelView);
>        rotateMatrix(iZangle, 0.0, 1.0, 0.0, aRotate);
>        multiplyMatrix(aRotate, aModelView, aModelView);
>
>        /* Pull the camera back from the cube */
>        aModelView[14] -= 2.5;
>
>        perspectiveMatrix(
>            45.0,
>            (double)uiWidth/(double)uiHeight,
>            0.01,
>            100.0,
>            aPerspective);
>        multiplyMatrix(aPerspective, aModelView, aMVP);
>        GL_CHECK(glUniformMatrix4fv(iLocMVP, 1, GL_FALSE, aMVP));
>
>        iXangle += 3;
>        iYangle += 2;
>        iZangle += 1;
>        if(iXangle >= 360) iXangle -= 360;
>        if(iXangle < 0) iXangle += 360;
>        if(iYangle >= 360) iYangle -= 360;
>        if(iYangle < 0) iYangle += 360;
>        if(iZangle >= 360) iZangle -= 360;
>        if(iZangle < 0) iZangle += 360;
>
>        GL_CHECK(glClear(
>            GL_COLOR_BUFFER_BIT
>            | GL_DEPTH_BUFFER_BIT
>            | GL_STENCIL_BUFFER_BIT));
>        GL_CHECK(glDrawArrays(GL_TRIANGLES, 0, 36));
>
>        if (!eglSwapBuffers(sEGLDisplay, sEGLSurface))
>        {
>            printf("Failed to swap buffers.\n");
>        }
>
>        usleep(20000);
>
>        DEBUG0("Loop...\n");
>    }
>
>    /* Cleanup shaders */
>    GL_CHECK(glUseProgram(0));
>    GL_CHECK(glDeleteShader(uiVertShader));
>    GL_CHECK(glDeleteShader(uiFragShader));
>    GL_CHECK(glDeleteProgram(uiProgram));
>
>    /* EGL clean up */
>    EGL_CHECK(eglMakeCurrent(
>        sEGLDisplay,
>        EGL_NO_SURFACE,
>        EGL_NO_SURFACE,
>        EGL_NO_CONTEXT));
>    EGL_CHECK(eglDestroySurface(sEGLDisplay, sEGLSurface));
>    EGL_CHECK(eglDestroyContext(sEGLDisplay, sEGLContext));
>    EGL_CHECK(eglTerminate(sEGLDisplay));
>
>exit:
>    /* X windows clean up */
>    XDestroyWindow(display, win);
>    XFreeColormap(display, colormap);
>    XFree(pVisual);
>    XCloseDisplay(display);
>
>    printf("Cube example ends.\n");
>    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 27265: 34365 | 34366 | 34367 | 34368

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.