Attachment 138904 Details for Bug 106123 – source code of example

source code of example

srgb.c (text/x-csrc), 11.79 KB, created by xinghua on 2018-04-18 09:22:31 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: xinghua

Created: 2018-04-18 09:22:31 UTC

Size: 11.79 KB

patch

obsolete

>// -- Written in C -- //
>#include<stdio.h>
>#include<stdlib.h>
>#include<epoxy/gl.h>
>#include<epoxy/glx.h>
>#include<X11/X.h>
>#include<X11/Xlib.h>
>/*#include<GL/gl.h>
>#include<GL/glx.h>*/
>
>Display                 *dpy;
>Window                  root;
>GLint                   att[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None };
>XVisualInfo             *vi;
>Colormap                cmap;
>XSetWindowAttributes    swa;
>Window                  win, win1;
>GLXContext              glc;
>XWindowAttributes       gwa;
>XEvent                  xev;
>
>int main(int argc, char *argv[]) {
>  dpy = XOpenDisplay(NULL);
>  if(dpy == NULL) {
>     printf("\n\tcannot connect to X server\n\n");
>     exit(0);
>  }
>
>  root = DefaultRootWindow(dpy);
>  vi = glXChooseVisual(dpy, 0, att);
>  if(vi == NULL) {
>     printf("\n\tno appropriate visual found\n\n");
>     exit(0);
>  }
>  else {
>     printf("\n\tvisual %p selected\n", (void *)vi->visualid); /* %p creates hexadecimal output like in glxinfo */
>  }
>
>  cmap = XCreateColormap(dpy, root, vi->visual, AllocNone);
>  swa.colormap = cmap;
>  swa.event_mask = ExposureMask | KeyPressMask;
>  win = XCreateWindow(dpy, root, 0, 0, 128, 128, 0, vi->depth, InputOutput, vi->visual, CWColormap | CWEventMask, &swa);
>  XMapWindow(dpy, win);
>  XStoreName(dpy, win, "VERY SIMPLE APPLICATION");
>  glc = glXCreateContext(dpy, vi, NULL, GL_TRUE);
>  glXMakeCurrent(dpy, win, glc);
>  glEnable(GL_DEPTH_TEST);
>  win1 = XCreateWindow(dpy, root, 0, 0, 128, 128, 0, vi->depth, InputOutput, vi->visual, CWColormap | CWEventMask, &swa);
>  glXMakeCurrent(dpy, win1, glc);
>
>  const char *vs_1 =
>            "#version 300 es\n"
>            "in highp vec4 a_position;\n"
>            "in highp vec4 a_coord;\n"
>            "out highp vec4 v_coord;\n"
>            "void main (void)\n"
>            "{\n"
>            "    gl_Position = a_position;\n"
>            "    v_coord = a_coord;\n"
>            "}\n";
>
>  const char *fs_1 =
>            "#version 300 es\n"
>            "in highp vec4 v_coord;\n"
>            "uniform highp vec4 u_gradientMin;\n"
>            "uniform highp vec4 u_gradientMax;\n"
>            "layout(location = 0) out highp vec4 o_color;\n"
>            "void main (void)\n"
>            "{\n"
>            "    highp float x = v_coord.x;\n"
>            "    highp float y = v_coord.y;\n"
>            "    highp float f0 = (x + y) * 0.5;\n"
>            "    highp float f1 = 0.5 + (x - y) * 0.5;\n"
>            "    highp vec4 fv = vec4(f0, f1, 1.0f-f0, 1.0f-f1);\n"
>            "    o_color = vec4(u_gradientMin + (u_gradientMax-u_gradientMin)*fv);\n"
>            "}\n";
>
>const char *vs_2 =
>            "#version 300 es\n"
>            "in highp vec4 a_position;\n"
>            "in highp vec2 a_coord;\n"
>            "out highp vec2 v_coord;\n"
>            "void main(void)\n"
>            "{\n"
>            "    gl_Position = a_position;\n"
>            "    v_coord = a_coord;\n"
>            "}\n";
>
>  const char *fs_2 =
>            "#version 300 es\n"
>            "layout(location = 0) out highp vec4 o_color0;\n"
>            "in highp vec2 v_coord;\n"
>            "uniform highp sampler2D u_sampler0;\n"
>            "uniform highp vec4 u_texScale0;\n"
>            "uniform highp vec4 u_texBias0;\n"
>            "uniform highp vec4 u_outScale0;\n"
>            "uniform highp vec4 u_outBias0;\n"
>            "void main (void)\n"
>            "{\n"
>            "    highp vec4 out0 = vec4(0.0);\n"
>            "    out0 += vec4(texture(u_sampler0, v_coord)) * u_texScale0 + u_texBias0;\n"
>            "    o_color0 = vec4(out0 * u_outScale0 + u_outBias0);\n"
>            "}\n";
>
>  GLuint mProgram_1 = glCreateProgram();
>  GLuint vsShader_1 = glCreateShader(GL_VERTEX_SHADER);
>  GLuint fsShader_1 = glCreateShader(GL_FRAGMENT_SHADER);
>
>  glShaderSource(vsShader_1, 1, &vs_1, NULL);
>  glCompileShader(vsShader_1);
>  GLint vsCompileStatus_1;
>  glGetShaderiv(vsShader_1, GL_COMPILE_STATUS, &vsCompileStatus_1);
>  if (vsCompileStatus_1 == 0)
>  {
>      printf("VS Compile failed 1.\n");
>      exit(0);
>  }
>  else
>  {
>      printf("VS Compile success 1.\n");
>  }
>  glShaderSource(fsShader_1, 1, &fs_1, NULL);
>  glCompileShader(fsShader_1);
>  GLint fsCompileStatus_1;
>  glGetShaderiv(fsShader_1, GL_COMPILE_STATUS, &fsCompileStatus_1);
>  if (fsCompileStatus_1 == 0)
>  {
>      printf("FS Compile failed 1.\n");
>      exit(0);
>  }
>  else
>  {
>      printf("FS Compile success 1.\n");
>  }
>
>  glAttachShader(mProgram_1, vsShader_1);
>  glAttachShader(mProgram_1, fsShader_1);
>  glLinkProgram(mProgram_1);
>  GLint linkStatus_1;
>  glGetProgramiv(mProgram_1, GL_LINK_STATUS, &linkStatus_1);
>  if (linkStatus_1 == 0)
>  {
>     printf("Link failed 1.\n");
>     exit(0);
>  }
>  else
>  {
>     printf("Link success 1.\n");
>  }
>
>  GLuint mProgram_2 = glCreateProgram();
>  GLuint vsShader_2 = glCreateShader(GL_VERTEX_SHADER);
>  GLuint fsShader_2 = glCreateShader(GL_FRAGMENT_SHADER);
>
>  glShaderSource(vsShader_2, 1, &vs_2, NULL);
>  glCompileShader(vsShader_2);
>  GLint vsCompileStatus_2;
>  glGetShaderiv(vsShader_2, GL_COMPILE_STATUS, &vsCompileStatus_2);
>  if (vsCompileStatus_2 == 0)
>  {
>      printf("VS Compile failed 2.\n");
>      exit(0);
>  }
>  else
>  {
>      printf("VS Compile success 2.\n");
>  }
>  glShaderSource(fsShader_2, 1, &fs_2, NULL);
>  glCompileShader(fsShader_2);
>  GLint fsCompileStatus_2;
>  glGetShaderiv(fsShader_2, GL_COMPILE_STATUS, &fsCompileStatus_2);
>  if (fsCompileStatus_2 == 0)
>  {
>      printf("FS Compile failed 2.\n");
>      exit(0);
>  }
>  else
>  {
>      printf("FS Compile success 2.\n");
>  }
>
>  glAttachShader(mProgram_2, vsShader_2);
>  glAttachShader(mProgram_2, fsShader_2);
>  glLinkProgram(mProgram_2);
>  GLint linkStatus_2;
>  glGetProgramiv(mProgram_2, GL_LINK_STATUS, &linkStatus_2);
>  if (linkStatus_2 == 0)
>  {
>     printf("Link failed 2.\n");
>     exit(0);
>  }
>  else
>  {
>     printf("Link success 2.\n");
>  }
>
>  GLuint fbo       = 0;
>  GLuint tex       = 0;
>  const GLint texW = 128;
>  const GLint texH = 128;
>
>  static const GLfloat gradientMin[] = {0.0f, 0.0f, 0.0f, 0.0f};
>  static const GLfloat gradientMax[] = {1.0f, 1.0f, 1.0f, 1.0f};
>  static const GLfloat scale[]       = {1.0f, 1.0f, 1.0f, 1.0f};
>  static const GLfloat bias[]        = {0.0f, 0.0f, 0.0f, 0.0f};
>
>  glUseProgram(mProgram_1);
>  glUniform4fv(glGetUniformLocation(mProgram_1, "u_gradientMin"), 1, gradientMin);
>  glUniform4fv(glGetUniformLocation(mProgram_1, "u_gradientMax"), 1, gradientMax);
>
>  glUseProgram(mProgram_2);
>  glUniform1i(glGetUniformLocation(mProgram_2, "u_sampler0"), 0);
>  glUniform4fv(glGetUniformLocation(mProgram_2, "u_texScale0"), 1, scale);
>  glUniform4fv(glGetUniformLocation(mProgram_2, "u_texBias0"), 1, bias);
>  glUniform4fv(glGetUniformLocation(mProgram_2, "u_outScale0"), 1, scale);
>  glUniform4fv(glGetUniformLocation(mProgram_2, "u_outBias0"), 1, bias);
>
>  //glBindFramebuffer(GL_FRAMEBUFFER, 0);
>
>  glUseProgram(0);
>  glGenFramebuffers(1, &fbo);
>  glGenTextures(1, &tex);
>  glBindTexture(GL_TEXTURE_2D, tex);
>  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
>  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
>  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
>  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
>  //GLuint data[128 * 128] = {0x58ab, 0x4398, 0x9843, 0x8430, 0x7839, 0x8923, 0x8923, 0x8450, 0x4739, 0x9203};
>  glTexImage2D(GL_TEXTURE_2D, 0, GL_SRGB8_ALPHA8, texW, texH, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
>
>  glBindFramebuffer(GL_FRAMEBUFFER, fbo);
>  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
>  glCheckFramebufferStatus(GL_FRAMEBUFFER);
>
>  glBindFramebuffer(GL_FRAMEBUFFER, 0);
>
>  GLfloat position_1[]       = {-1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f,
>                                1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f};
>  const GLfloat coord_1[]    = {0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f};
>  const GLushort indices_1[] = {0, 1, 2, 2, 1, 3};
>
>  GLint posLoc_1   = glGetAttribLocation(mProgram_1, "a_position");
>  GLint coordLoc_1 = glGetAttribLocation(mProgram_1, "a_coord");
>  GLuint vaoID_1;
>  GLuint bufIDs_1[2];
>
>
>  glGenVertexArrays(1, &vaoID_1);
>  glBindVertexArray(vaoID_1);
>
>  glGenBuffers(2, &bufIDs_1[0]);
>  glUseProgram(mProgram_1);
>  glBindBuffer(GL_ARRAY_BUFFER, bufIDs_1[0]);
>  glBufferData(GL_ARRAY_BUFFER, 16 * sizeof(GLfloat), &position_1[0], GL_STATIC_DRAW);
>  glEnableVertexAttribArray(posLoc_1);
>  glVertexAttribPointer(posLoc_1, 4, GL_FLOAT, GL_FALSE, 0, 0);
>  glBindBuffer(GL_ARRAY_BUFFER, 0);
>
>  glBindBuffer(GL_ARRAY_BUFFER, bufIDs_1[1]);
>  glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), &coord_1[0], GL_STATIC_DRAW);
>  glEnableVertexAttribArray(coordLoc_1);
>  glVertexAttribPointer(coordLoc_1, 2, GL_FLOAT, GL_FALSE, 0, 0);
>  glBindBuffer(GL_ARRAY_BUFFER, 0);
>
>  GLuint ndxID_1;
>  glGenBuffers(1, &ndxID_1);
>  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ndxID_1);
>  glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(GLushort), &indices_1[0], GL_STATIC_DRAW);
>  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
>
>  GLubyte pixels_1[128 * 128 * 4];
>  glReadPixels(0, 0, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, &pixels_1[0]);
>  FILE *outputFile_1 = fopen("result_1.rgba", "a");
>  fprintf(outputFile_1, "%s\n", (char *)(pixels_1));
>  fclose(outputFile_1);
>
>  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
>  glDeleteBuffers(1, &ndxID_1);
>  glDeleteBuffers(2, &bufIDs_1[0]);
>  glDeleteVertexArrays(1, &vaoID_1);
>
>  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
>  glBlitFramebuffer(0, 0, 128, 128, 0, 0, texW, texH,
>                      GL_COLOR_BUFFER_BIT, GL_LINEAR);
>
>  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
>
>  GLubyte pixels_2[128 * 128 * 4];
>  glReadPixels(0, 0, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, &pixels_2[0]);
>  FILE *outputFile_2 = fopen("result_2.rgba", "a");
>  fprintf(outputFile_2, "%s\n", (char *)(pixels_2));
>  fclose(outputFile_2);
>
>  static const GLfloat clearColor[] = {1.0f, 0.0f, 0.0f, 1.0f};
>  glClearBufferfv(GL_COLOR, 0, clearColor);
>
>  GLubyte pixels_3[128 * 128 * 4];
>  glReadPixels(0, 0, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, &pixels_3[0]);
>  FILE *outputFile_3 = fopen("result_3.rgba", "a");
>  fprintf(outputFile_3, "%s\n", (char *)(pixels_3));
>  fclose(outputFile_3);
>
>
>
>  GLint posLoc_2   = glGetAttribLocation(mProgram_2, "a_position");
>  GLint coordLoc_2 = glGetAttribLocation(mProgram_2, "a_coord");
>
>  //glBindFramebuffer(GL_FRAMEBUFFER, 0);
>
>  GLfloat position_2[]       = {-1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f,
>                            1.0f,  -1.0f, 0.0f, 1.0f, 1.0f,  1.0f, 0.0f, 1.0f};
>  const GLfloat coord_2[]    = {0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f};
>  const GLushort indices_2[] = {0, 1, 2, 2, 1, 3};
>
>  GLuint vaoID_2;
>  GLuint bufIDs_2[2];
>  glGenVertexArrays(1, &vaoID_2);
>  glBindVertexArray(vaoID_2);
>
>  glBindTexture(GL_TEXTURE_2D, tex);
>  glActiveTexture(GL_TEXTURE0);
>
>  glGenBuffers(2, &bufIDs_2[0]);
>  glBindBuffer(GL_ARRAY_BUFFER, bufIDs_2[0]);
>  glBufferData(GL_ARRAY_BUFFER, 16 * sizeof(GLfloat), &position_2[0], GL_STATIC_DRAW);
>  glEnableVertexAttribArray(posLoc_2);
>  glVertexAttribPointer(posLoc_2, 4, GL_FLOAT, GL_FALSE, 0, 0);
>  glBindBuffer(GL_ARRAY_BUFFER, 0);
>
>  glBindBuffer(GL_ARRAY_BUFFER, bufIDs_2[1]);
>  glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLfloat), &coord_2[0], GL_STATIC_DRAW);
>  glEnableVertexAttribArray(coordLoc_2);
>  glVertexAttribPointer(coordLoc_2, 2, GL_FLOAT, GL_FALSE, 0, 0);
>  glBindBuffer(GL_ARRAY_BUFFER, 0);
>
>  GLuint ndxID_2;
>  glGenBuffers(1, &ndxID_2);
>  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ndxID_2);
>  glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(GLushort), &indices_2[0], GL_STATIC_DRAW);
>  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
>
>  GLubyte pixels_4[128 * 128 * 4];
>  glReadPixels(0, 0, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE, &pixels_4[0]);
>  FILE *outputFile_4 = fopen("result_4.rgba", "a");
>  fprintf(outputFile_4, "%s\n", (char *)(pixels_4));
>  fclose(outputFile_4);
>
>  glXMakeCurrent(dpy, None, NULL);
>  glXDestroyContext(dpy, glc);
>  XDestroyWindow(dpy, win);
>  XCloseDisplay(dpy);
>  exit(0);
>}

Actions: View

Attachments on bug 106123: 138904

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.