add sdlgl shader example

recipes-example/example/example_0.1.bb

@@ -5,18 +5,22 @@ LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda
 
 DEPENDS += "libsdl2"
 FILESEXTRAPATHS:prepend := "${THISDIR}/files:"
-SRC_URI = "file://sdl_test.cpp file://sdlgl.c "
+SRC_URI = "file://sdl_test.cpp file://sdlgl.c file://sdlglshader.c"
 TARGET_CC_ARCH += "${LDFLAGS}"
 
 do_compile() {
     ${CXX} ${WORKDIR}/sdl_test.cpp `pkg-config --cflags --libs sdl2` -o ${WORKDIR}/sdl_test
     ${CC} ${WORKDIR}/sdlgl.c `pkg-config --cflags --libs sdl2` -lGL -o ${WORKDIR}/sdlgl
+    ${CC} ${WORKDIR}/sdlglshader.c `pkg-config --cflags --libs sdl2` -lGL -o ${WORKDIR}/sdlglshader
 }
 
 do_install() {
     install -d ${D}/usr/bin
     install  -m 0755 ${WORKDIR}/sdl_test ${D}/usr/bin
     install  -m 0755 ${WORKDIR}/sdlgl ${D}/usr/bin
+    install  -m 0755 ${WORKDIR}/sdlglshader ${D}/usr/bin
+    # for manual copy test applications on target from tmp dir
     install  -m 0755 ${WORKDIR}/sdl_test /tmp
     install  -m 0755 ${WORKDIR}/sdlgl /tmp
+    install  -m 0755 ${WORKDIR}/sdlglshader /tmp
 }

recipes-example/example/files/sdlglshader.c

@@ -0,0 +1,209 @@
+// To compile with gcc:  (tested on Ubuntu 14.04 64bit):
+//	 g++ sdl2_opengl.cpp -lSDL2 -lGL
+// To compile with msvc: (tested on Windows 7 64bit)
+//   cl sdl2_opengl.cpp /I C:\sdl2path\include /link C:\path\SDL2.lib C:\path\SDL2main.lib /SUBSYSTEM:CONSOLE /NODEFAULTLIB:libcmtd.lib opengl32.lib
+
+#include <stdio.h>
+#include <stdint.h>
+#include <assert.h>
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_opengl.h>
+#include <GL/gl.h>
+
+typedef int32_t i32;
+typedef uint32_t u32;
+typedef int32_t b32;
+
+#define WinWidth 480
+#define WinHeight 640
+#define VERTEX_SHADER "\
+void main() \
+{ \
+	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; \
+} \
+"
+
+#define FRAG_SHADER "\
+void main() \
+{ \
+	gl_FragColor = vec4(1.0,0.0,0.0,1.0); \
+} \
+"
+
+GLuint load_shader(c)
+{
+
+    // Create the shaders
+    GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
+    GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
+
+    GLint Result = GL_FALSE;
+    int InfoLogLength;
+    char *source;
+    char buff[2048];
+    // Compile Vertex Shader
+    source = VERTEX_SHADER;
+    printf("Compiling vertex shader \n");
+    glShaderSource(VertexShaderID, 1, &source, NULL);
+    glCompileShader(VertexShaderID);
+
+    memset(buff, 0, sizeof(buff));
+    // Check Vertex Shader
+    glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
+    glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
+    if (InfoLogLength > 0)
+    {
+        glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &buff);
+        printf("%s\n", buff);
+    }
+
+    // Compile Fragment Shader
+    source = FRAG_SHADER;
+    printf("Compiling frag shader \n");
+    glShaderSource(FragmentShaderID, 1, &source, NULL);
+    glCompileShader(FragmentShaderID);
+
+    // Check Fragment Shader
+    memset(buff, 0, sizeof(buff));
+    glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
+    glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
+    if (InfoLogLength > 0)
+    {
+        glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, buff);
+        printf("%s\n", buff);
+    }
+
+    // Link the program
+    printf("Linking program\n");
+    GLuint ProgramID = glCreateProgram();
+    glAttachShader(ProgramID, VertexShaderID);
+    glAttachShader(ProgramID, FragmentShaderID);
+    glLinkProgram(ProgramID);
+
+    // Check the program
+    memset(buff, 0, sizeof(buff));
+    glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
+    glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
+    if (InfoLogLength > 0)
+    {
+        glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, buff);
+        printf("Linking: %s\n", buff);
+    }
+
+    glDetachShader(ProgramID, VertexShaderID);
+    glDetachShader(ProgramID, FragmentShaderID);
+
+    glDeleteShader(VertexShaderID);
+    glDeleteShader(FragmentShaderID);
+
+    return ProgramID;
+}
+
+int main(int ArgCount, char **Args)
+{
+
+    u32 WindowFlags = SDL_WINDOW_OPENGL;
+    
+    SDL_Window *Window = SDL_CreateWindow("OpenGL Test", 0, 0, 0, 0, WindowFlags);
+    assert(Window);
+    SDL_GLContext Context = SDL_GL_CreateContext(Window);
+    SDL_SetWindowFullscreen(Window, SDL_WINDOW_FULLSCREEN);
+    SDL_DisplayMode DM;
+    SDL_GetCurrentDisplayMode(0, &DM);
+    printf("Display size %dx%d\n", DM.w, DM.h);
+    int Running = 1;
+
+    // openGL part
+    GLuint VertexArrayID;
+    glGenVertexArrays(1, &VertexArrayID);
+    glBindVertexArray(VertexArrayID);
+    printf("Vertex Array ID %d\n", VertexArrayID);
+    // Create and compile our GLSL program from the shaders
+    GLuint programID = load_shader();
+    GLfloat tmp_buffer[9]; 
+    static const GLfloat g_vertex_buffer_data[] = {
+        -1.0f,
+        -1.0f,
+        0.0f,
+        1.0f,
+        -1.0f,
+        0.0f,
+        0.0f,
+        1.0f,
+        0.0f,
+    };
+
+    GLuint vertexbuffer;
+    GLint currid = -1;
+    glGenBuffers(1, &vertexbuffer);
+    glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
+    printf("Buffer ID %d of size: %d\n", vertexbuffer, sizeof(tmp_buffer));
+    // read back buffer data
+    memset(tmp_buffer, 0, sizeof(tmp_buffer));
+    glGetBufferSubData(GL_ARRAY_BUFFER, 0,sizeof(tmp_buffer), tmp_buffer );
+    printf("Read back buffer data: \n");
+
+    for(int i=0; i< 9; i++)
+    {
+        printf("%d: %.2f\n", i, tmp_buffer[i]);
+    }
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &currid);
+    printf("current id: %d\n",currid);
+    while (Running)
+    {
+        SDL_Event Event;
+        while (SDL_PollEvent(&Event))
+        {
+            if (Event.type == SDL_KEYDOWN)
+            {
+                switch (Event.key.keysym.sym)
+                {
+                case SDLK_ESCAPE:
+                    Running = 0;
+                    break;
+                default:
+                    break;
+                }
+            }
+            else if (Event.type == SDL_QUIT)
+            {
+                Running = 0;
+            }
+        }
+
+        glViewport(0, 0, DM.w, DM.h);
+        glClearColor(1.f, 0.f, 1.f, 0.f);
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        
+        // Use our shader
+        glUseProgram(programID);
+
+        // 1rst attribute buffer : vertices
+        glEnableVertexAttribArray(0);
+        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
+        glVertexAttribPointer(
+            0,        // attribute 0. No particular reason for 0, but must match the layout in the shader.
+            3,        // size
+            GL_FLOAT, // type
+            GL_FALSE, // normalized?
+            0,        // stride
+            (void *)0 // array buffer offset
+        );
+
+        // Draw the triangle !
+        glDrawArrays(GL_TRIANGLES, 0, 3); // 3 indices starting at 0 -> 1 triangle
+
+        glDisableVertexAttribArray(0);
+        /* Send our triangle data to the pipeline. */
+        SDL_GL_SwapWindow(Window);
+    }
+
+
+    // Cleanup VBO
+	glDeleteBuffers(1, &vertexbuffer);
+	glDeleteVertexArrays(1, &VertexArrayID);
+	glDeleteProgram(programID);
+    return 0;
+}