frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

glamor: Change to use official APIs rather than ARB version function. 

Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
This commit is contained in:
Zhigang Gong 2011-08-02 15:51:46 +08:00
parent 0ef1698be2
commit 98f8ef5f99
8 changed files with 132 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
glamor/glamor.c
View File

@ -74,10 +74,10 @@ glamor_set_pixmap_texture(PixmapPtr pixmap, int w, int h, unsigned int tex)
*/ */
pixmap_priv->gl_fbo = 1; pixmap_priv->gl_fbo = 1;
pixmap_priv->gl_tex = 1; pixmap_priv->gl_tex = 1;
glGenFramebuffersEXT(1, &pixmap_priv->fb); glGenFramebuffers(1, &pixmap_priv->fb);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, pixmap_priv->fb); glBindFramebuffer(GL_FRAMEBUFFER, pixmap_priv->fb);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, GL_TEXTURE_2D,
pixmap_priv->tex, pixmap_priv->tex,
0); 0);
@ -217,11 +217,11 @@ glamor_destroy_pixmap(PixmapPtr pixmap)
if (pixmap->refcnt == 1) { if (pixmap->refcnt == 1) {
glamor_pixmap_private *pixmap_priv = glamor_get_pixmap_private(pixmap); glamor_pixmap_private *pixmap_priv = glamor_get_pixmap_private(pixmap);
if (pixmap_priv->fb) if (pixmap_priv->fb)
glDeleteFramebuffersEXT(1, &pixmap_priv->fb); glDeleteFramebuffers(1, &pixmap_priv->fb);
if (pixmap_priv->tex) if (pixmap_priv->tex)
glDeleteTextures(1, &pixmap_priv->tex); glDeleteTextures(1, &pixmap_priv->tex);
if (pixmap_priv->pbo) if (pixmap_priv->pbo)
glDeleteBuffersARB(1, &pixmap_priv->pbo); glDeleteBuffers(1, &pixmap_priv->pbo);
dixFreePrivates(pixmap->devPrivates, PRIVATE_PIXMAP); dixFreePrivates(pixmap->devPrivates, PRIVATE_PIXMAP);
} }
@ -293,6 +293,7 @@ glamor_init(ScreenPtr screen, unsigned int flags)
glewInit(); glewInit();
#ifndef GLAMOR_GLES2
if (!GLEW_EXT_framebuffer_object) { if (!GLEW_EXT_framebuffer_object) {
ErrorF("GL_EXT_framebuffer_object required\n"); ErrorF("GL_EXT_framebuffer_object required\n");
goto fail; goto fail;
@ -305,14 +306,17 @@ glamor_init(ScreenPtr screen, unsigned int flags)
ErrorF("GL_ARB_vertex_shader required\n"); ErrorF("GL_ARB_vertex_shader required\n");
goto fail; goto fail;
} }
if (!GLEW_ARB_pixel_buffer_object) {
ErrorF("GL_ARB_pixel_buffer_object required\n");
goto fail;
}
if (!GLEW_EXT_bgra) { if (!GLEW_EXT_bgra) {
ErrorF("GL_EXT_bgra required\n"); ErrorF("GL_EXT_bgra required\n");
goto fail; goto fail;
} }
#endif
if (!GLEW_ARB_pixel_buffer_object) {
ErrorF("GL_ARB_pixel_buffer_object required\n");
goto fail;
}
if (!RegisterBlockAndWakeupHandlers(glamor_block_handler, if (!RegisterBlockAndWakeupHandlers(glamor_block_handler,
glamor_wakeup_handler, glamor_wakeup_handler,
NULL)) { NULL)) {

4
glamor/glamor_copyarea.c
View File

@ -196,7 +196,7 @@ glamor_copy_n_to_n_textured(DrawablePtr src,
glClientActiveTexture(GL_TEXTURE0); glClientActiveTexture(GL_TEXTURE0);
glTexCoordPointer(2, GL_FLOAT, sizeof(float) * 2, texcoords); glTexCoordPointer(2, GL_FLOAT, sizeof(float) * 2, texcoords);
glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glUseProgramObjectARB(glamor_priv->finish_access_prog[0]); glUseProgram(glamor_priv->finish_access_prog[0]);
} }
else { else {
GLAMOR_CHECK_PENDING_FILL(glamor_priv, src_pixmap_priv); GLAMOR_CHECK_PENDING_FILL(glamor_priv, src_pixmap_priv);
@ -222,7 +222,7 @@ glamor_copy_n_to_n_textured(DrawablePtr src,
glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
} }
glUseProgramObjectARB(0); glUseProgram(0);
glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_VERTEX_ARRAY);
if (GLAMOR_PIXMAP_PRIV_NO_PENDING(src_pixmap_priv)) { if (GLAMOR_PIXMAP_PRIV_NO_PENDING(src_pixmap_priv)) {

68
glamor/glamor_core.c
View File

@ -59,10 +59,10 @@ void
glamor_get_transform_uniform_locations(GLint prog, glamor_get_transform_uniform_locations(GLint prog,
glamor_transform_uniforms *uniform_locations) glamor_transform_uniforms *uniform_locations)
{ {
uniform_locations->x_bias = glGetUniformLocationARB(prog, "x_bias"); uniform_locations->x_bias = glGetUniformLocation(prog, "x_bias");
uniform_locations->x_scale = glGetUniformLocationARB(prog, "x_scale"); uniform_locations->x_scale = glGetUniformLocation(prog, "x_scale");
uniform_locations->y_bias = glGetUniformLocationARB(prog, "y_bias"); uniform_locations->y_bias = glGetUniformLocation(prog, "y_bias");
uniform_locations->y_scale = glGetUniformLocationARB(prog, "y_scale"); uniform_locations->y_scale = glGetUniformLocation(prog, "y_scale");
} }
/* We don't use a full matrix for our transformations because it's /* We don't use a full matrix for our transformations because it's
@ -73,10 +73,10 @@ void
glamor_set_transform_for_pixmap(PixmapPtr pixmap, glamor_set_transform_for_pixmap(PixmapPtr pixmap,
glamor_transform_uniforms *uniform_locations) glamor_transform_uniforms *uniform_locations)
{ {
glUniform1fARB(uniform_locations->x_bias, -pixmap->drawable.width / 2.0f); glUniform1f(uniform_locations->x_bias, -pixmap->drawable.width / 2.0f);
glUniform1fARB(uniform_locations->x_scale, 2.0f / pixmap->drawable.width); glUniform1f(uniform_locations->x_scale, 2.0f / pixmap->drawable.width);
glUniform1fARB(uniform_locations->y_bias, -pixmap->drawable.height / 2.0f); glUniform1f(uniform_locations->y_bias, -pixmap->drawable.height / 2.0f);
glUniform1fARB(uniform_locations->y_scale, -2.0f / pixmap->drawable.height); glUniform1f(uniform_locations->y_scale, -2.0f / pixmap->drawable.height);
} }
GLint GLint
@ -85,9 +85,9 @@ glamor_compile_glsl_prog(GLenum type, const char *source)
GLint ok; GLint ok;
GLint prog; GLint prog;
prog = glCreateShaderObjectARB(type); prog = glCreateShader(type);
glShaderSourceARB(prog, 1, (const GLchar **)&source, NULL); glShaderSource(prog, 1, (const GLchar **)&source, NULL);
glCompileShaderARB(prog); glCompileShader(prog);
glGetObjectParameterivARB(prog, GL_OBJECT_COMPILE_STATUS_ARB, &ok); glGetObjectParameterivARB(prog, GL_OBJECT_COMPILE_STATUS_ARB, &ok);
if (!ok) { if (!ok) {
GLchar *info; GLchar *info;
@ -165,22 +165,22 @@ glamor_init_finish_access_shaders(ScreenPtr screen)
GLint fs_prog, vs_prog, avs_prog, aswizzle_prog; GLint fs_prog, vs_prog, avs_prog, aswizzle_prog;
glamor_priv->finish_access_prog[0] = glCreateProgramObjectARB(); glamor_priv->finish_access_prog[0] = glCreateProgram();
glamor_priv->finish_access_prog[1] = glCreateProgramObjectARB(); glamor_priv->finish_access_prog[1] = glCreateProgram();
if (GLEW_ARB_fragment_shader) { if (GLEW_ARB_fragment_shader) {
vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER_ARB, vs_source); vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER, vs_source);
fs_prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER_ARB, fs_source); fs_prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER, fs_source);
glAttachObjectARB(glamor_priv->finish_access_prog[0], vs_prog); glAttachShader(glamor_priv->finish_access_prog[0], vs_prog);
glAttachObjectARB(glamor_priv->finish_access_prog[0], fs_prog); glAttachShader(glamor_priv->finish_access_prog[0], fs_prog);
avs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER_ARB, vs_source); avs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER, vs_source);
aswizzle_prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER_ARB, aswizzle_source); aswizzle_prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER, aswizzle_source);
glAttachObjectARB(glamor_priv->finish_access_prog[1], avs_prog); glAttachShader(glamor_priv->finish_access_prog[1], avs_prog);
glAttachObjectARB(glamor_priv->finish_access_prog[1], aswizzle_prog); glAttachShader(glamor_priv->finish_access_prog[1], aswizzle_prog);
} else { } else {
vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER_ARB, vs_source); vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER, vs_source);
glAttachObjectARB(glamor_priv->finish_access_prog[0], vs_prog); glAttachShader(glamor_priv->finish_access_prog[0], vs_prog);
ErrorF("Lack of framgment shader support.\n"); ErrorF("Lack of framgment shader support.\n");
} }
@ -191,16 +191,16 @@ glamor_init_finish_access_shaders(ScreenPtr screen)
GLint sampler_uniform_location; GLint sampler_uniform_location;
sampler_uniform_location = sampler_uniform_location =
glGetUniformLocationARB(glamor_priv->finish_access_prog[0], "sampler"); glGetUniformLocation(glamor_priv->finish_access_prog[0], "sampler");
glUseProgramObjectARB(glamor_priv->finish_access_prog[0]); glUseProgram(glamor_priv->finish_access_prog[0]);
glUniform1iARB(sampler_uniform_location, 0); glUniform1i(sampler_uniform_location, 0);
glUseProgramObjectARB(0); glUseProgram(0);
sampler_uniform_location = sampler_uniform_location =
glGetUniformLocationARB(glamor_priv->finish_access_prog[1], "sampler"); glGetUniformLocation(glamor_priv->finish_access_prog[1], "sampler");
glUseProgramObjectARB(glamor_priv->finish_access_prog[1]); glUseProgram(glamor_priv->finish_access_prog[1]);
glUniform1iARB(sampler_uniform_location, 0); glUniform1i(sampler_uniform_location, 0);
glUseProgramObjectARB(0); glUseProgram(0);
} }
} }
@ -218,10 +218,10 @@ glamor_finish_access(DrawablePtr drawable)
} }
if (pixmap_priv->pbo != 0 && pixmap_priv->pbo_valid) { if (pixmap_priv->pbo != 0 && pixmap_priv->pbo_valid) {
glBindBufferARB (GL_PIXEL_PACK_BUFFER_EXT, 0); glBindBuffer (GL_PIXEL_PACK_BUFFER_EXT, 0);
glBindBufferARB (GL_PIXEL_UNPACK_BUFFER_EXT, 0); glBindBuffer (GL_PIXEL_UNPACK_BUFFER_EXT, 0);
pixmap_priv->pbo_valid = FALSE; pixmap_priv->pbo_valid = FALSE;
glDeleteBuffersARB(1, &pixmap_priv->pbo); glDeleteBuffers(1, &pixmap_priv->pbo);
pixmap_priv->pbo = 0; pixmap_priv->pbo = 0;
} else } else
free(pixmap->devPrivate.ptr); free(pixmap->devPrivate.ptr);

22
glamor/glamor_fill.c
View File

@ -122,20 +122,20 @@ glamor_init_solid_shader(ScreenPtr screen)
"}\n"; "}\n";
GLint fs_prog, vs_prog; GLint fs_prog, vs_prog;
glamor_priv->solid_prog = glCreateProgramObjectARB(); glamor_priv->solid_prog = glCreateProgram();
if (GLEW_ARB_fragment_shader) { if (GLEW_ARB_fragment_shader) {
vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER_ARB, solid_vs); vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER, solid_vs);
fs_prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER_ARB, solid_fs); fs_prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER, solid_fs);
glAttachObjectARB(glamor_priv->solid_prog, vs_prog); glAttachShader(glamor_priv->solid_prog, vs_prog);
glAttachObjectARB(glamor_priv->solid_prog, fs_prog); glAttachShader(glamor_priv->solid_prog, fs_prog);
} else { } else {
vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER_ARB, solid_vs_only); vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER, solid_vs_only);
glAttachObjectARB(glamor_priv->solid_prog, vs_prog); glAttachShader(glamor_priv->solid_prog, vs_prog);
} }
glamor_link_glsl_prog(glamor_priv->solid_prog); glamor_link_glsl_prog(glamor_priv->solid_prog);
glamor_priv->solid_color_uniform_location = glamor_priv->solid_color_uniform_location =
glGetUniformLocationARB(glamor_priv->solid_prog, "color"); glGetUniformLocation(glamor_priv->solid_prog, "color");
} }
Bool Bool
@ -184,9 +184,9 @@ glamor_solid(PixmapPtr pixmap, int x, int y, int width, int height,
glamor_set_destination_pixmap_priv_nc(pixmap_priv); glamor_set_destination_pixmap_priv_nc(pixmap_priv);
glamor_validate_pixmap(pixmap); glamor_validate_pixmap(pixmap);
glUseProgramObjectARB(glamor_priv->solid_prog); glUseProgram(glamor_priv->solid_prog);
glUniform4fvARB(glamor_priv->solid_color_uniform_location, 1, color); glUniform4fv(glamor_priv->solid_color_uniform_location, 1, color);
glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, vertices); glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, vertices);
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
@ -199,7 +199,7 @@ glamor_solid(PixmapPtr pixmap, int x, int y, int width, int height,
glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_VERTEX_ARRAY);
glUseProgramObjectARB(0); glUseProgram(0);
return TRUE; return TRUE;
fail: fail:
glamor_set_alu(GXcopy); glamor_set_alu(GXcopy);

48
glamor/glamor_pixmap.c
View File

@ -35,8 +35,8 @@ _glamor_pixmap_validate_filling(glamor_screen_private *glamor_priv,
// glamor_set_destination_pixmap_priv_nc(pixmap_priv); // glamor_set_destination_pixmap_priv_nc(pixmap_priv);
glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, vertices); glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, vertices);
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
glUseProgramObjectARB(glamor_priv->solid_prog); glUseProgram(glamor_priv->solid_prog);
glUniform4fvARB(glamor_priv->solid_color_uniform_location, glUniform4fv(glamor_priv->solid_color_uniform_location,
1, pixmap_priv->pending_op.fill.color4fv); 1, pixmap_priv->pending_op.fill.color4fv);
vertices[0] = -1; vertices[0] = -1;
vertices[1] = -1; vertices[1] = -1;
@ -48,7 +48,7 @@ _glamor_pixmap_validate_filling(glamor_screen_private *glamor_priv,
vertices[7] = 1; vertices[7] = 1;
glDrawArrays(GL_QUADS, 0, 4); glDrawArrays(GL_QUADS, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_VERTEX_ARRAY);
glUseProgramObjectARB(0); glUseProgram(0);
pixmap_priv->pending_op.type = GLAMOR_PENDING_NONE; pixmap_priv->pending_op.type = GLAMOR_PENDING_NONE;
} }
@ -223,7 +223,7 @@ __glamor_upload_pixmap_to_texture(PixmapPtr pixmap, GLenum format, GLenum type,
if (pixmap_priv->pbo && pixmap_priv->pbo_valid) { if (pixmap_priv->pbo && pixmap_priv->pbo_valid) {
texels = NULL; texels = NULL;
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_EXT, pixmap_priv->pbo); glBindBuffer(GL_PIXEL_UNPACK_BUFFER_EXT, pixmap_priv->pbo);
} }
else else
texels = pixmap->devPrivate.ptr; texels = pixmap->devPrivate.ptr;
@ -300,12 +300,12 @@ _glamor_upload_pixmap_to_texture(PixmapPtr pixmap, GLenum format, GLenum type, i
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glUseProgramObjectARB(glamor_priv->finish_access_prog[ax]); glUseProgram(glamor_priv->finish_access_prog[ax]);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_2D);
glUseProgramObjectARB(0); glUseProgram(0);
glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDeleteTextures(1, &tex); glDeleteTextures(1, &tex);
@ -472,16 +472,16 @@ glamor_download_pixmap_to_cpu(PixmapPtr pixmap, glamor_access_t access)
glamor_validate_pixmap(pixmap); glamor_validate_pixmap(pixmap);
switch (access) { switch (access) {
case GLAMOR_ACCESS_RO: case GLAMOR_ACCESS_RO:
gl_access = GL_READ_ONLY_ARB; gl_access = GL_READ_ONLY;
gl_usage = GL_STREAM_READ_ARB; gl_usage = GL_STREAM_READ;
break; break;
case GLAMOR_ACCESS_WO: case GLAMOR_ACCESS_WO:
data = malloc(stride * pixmap->drawable.height); data = malloc(stride * pixmap->drawable.height);
goto done; goto done;
break; break;
case GLAMOR_ACCESS_RW: case GLAMOR_ACCESS_RW:
gl_access = GL_READ_WRITE_ARB; gl_access = GL_READ_WRITE;
gl_usage = GL_DYNAMIC_DRAW_ARB; gl_usage = GL_DYNAMIC_DRAW;
break; break;
default: default:
ErrorF("Glamor: Invalid access code. %d\n", access); ErrorF("Glamor: Invalid access code. %d\n", access);
@ -497,41 +497,41 @@ glamor_download_pixmap_to_cpu(PixmapPtr pixmap, glamor_access_t access)
if (!glamor_priv->yInverted) if (!glamor_priv->yInverted)
glPixelStorei(GL_PACK_INVERT_MESA, 1); glPixelStorei(GL_PACK_INVERT_MESA, 1);
if (pixmap_priv->pbo == 0) if (pixmap_priv->pbo == 0)
glGenBuffersARB (1, &pixmap_priv->pbo); glGenBuffers (1, &pixmap_priv->pbo);
glBindBufferARB (GL_PIXEL_PACK_BUFFER_EXT, pixmap_priv->pbo); glBindBuffer (GL_PIXEL_PACK_BUFFER_EXT, pixmap_priv->pbo);
glBufferDataARB (GL_PIXEL_PACK_BUFFER_EXT, glBufferData (GL_PIXEL_PACK_BUFFER_EXT,
stride * pixmap->drawable.height, stride * pixmap->drawable.height,
NULL, gl_usage); NULL, gl_usage);
glReadPixels (0, 0, glReadPixels (0, 0,
row_length, pixmap->drawable.height, row_length, pixmap->drawable.height,
format, type, 0); format, type, 0);
data = glMapBufferARB (GL_PIXEL_PACK_BUFFER_EXT, gl_access); data = glMapBuffer (GL_PIXEL_PACK_BUFFER_EXT, gl_access);
pixmap_priv->pbo_valid = TRUE; pixmap_priv->pbo_valid = TRUE;
if (!glamor_priv->yInverted) if (!glamor_priv->yInverted)
glPixelStorei(GL_PACK_INVERT_MESA, 0); glPixelStorei(GL_PACK_INVERT_MESA, 0);
glBindBufferARB (GL_PIXEL_PACK_BUFFER_EXT, 0); glBindBuffer (GL_PIXEL_PACK_BUFFER_EXT, 0);
} else { } else {
data = malloc(stride * pixmap->drawable.height); data = malloc(stride * pixmap->drawable.height);
assert(data); assert(data);
if (access != GLAMOR_ACCESS_WO) { if (access != GLAMOR_ACCESS_WO) {
if (pixmap_priv->pbo == 0) if (pixmap_priv->pbo == 0)
glGenBuffersARB(1, &pixmap_priv->pbo); glGenBuffers(1, &pixmap_priv->pbo);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, pixmap_priv->pbo); glBindBuffer(GL_PIXEL_PACK_BUFFER_EXT, pixmap_priv->pbo);
glBufferDataARB(GL_PIXEL_PACK_BUFFER_EXT, glBufferData(GL_PIXEL_PACK_BUFFER_EXT,
stride * pixmap->drawable.height, stride * pixmap->drawable.height,
NULL, GL_STREAM_READ_ARB); NULL, GL_STREAM_READ);
glReadPixels (0, 0, row_length, pixmap->drawable.height, glReadPixels (0, 0, row_length, pixmap->drawable.height,
format, type, 0); format, type, 0);
read = glMapBufferARB(GL_PIXEL_PACK_BUFFER_EXT, GL_READ_ONLY_ARB); read = glMapBuffer(GL_PIXEL_PACK_BUFFER_EXT, GL_READ_ONLY);
for (y = 0; y < pixmap->drawable.height; y++) for (y = 0; y < pixmap->drawable.height; y++)
memcpy(data + y * stride, memcpy(data + y * stride,
read + (pixmap->drawable.height - y - 1) * stride, stride); read + (pixmap->drawable.height - y - 1) * stride, stride);
glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_EXT); glUnmapBuffer(GL_PIXEL_PACK_BUFFER_EXT);
glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, 0); glBindBuffer(GL_PIXEL_PACK_BUFFER_EXT, 0);
pixmap_priv->pbo_valid = FALSE; pixmap_priv->pbo_valid = FALSE;
glDeleteBuffersARB(1, &pixmap_priv->pbo); glDeleteBuffers(1, &pixmap_priv->pbo);
pixmap_priv->pbo = 0; pixmap_priv->pbo = 0;
} }
} }
@ -555,7 +555,7 @@ _glamor_destroy_upload_pixmap(PixmapPtr pixmap)
if (pixmap_priv->tex) if (pixmap_priv->tex)
glDeleteTextures(1, &pixmap_priv->tex); glDeleteTextures(1, &pixmap_priv->tex);
if (pixmap_priv->pbo) if (pixmap_priv->pbo)
glDeleteBuffersARB(1, &pixmap_priv->pbo); glDeleteBuffers(1, &pixmap_priv->pbo);
pixmap_priv->fb = pixmap_priv->tex = pixmap_priv->pbo = 0; pixmap_priv->fb = pixmap_priv->tex = pixmap_priv->pbo = 0;
} }

32
glamor/glamor_putimage.c
View File

@ -66,25 +66,25 @@ glamor_init_putimage_shaders(ScreenPtr screen)
if (!GLEW_ARB_fragment_shader) if (!GLEW_ARB_fragment_shader)
return; return;
prog = glCreateProgramObjectARB(); prog = glCreateProgram();
vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER_ARB, xybitmap_vs); vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER, xybitmap_vs);
fs_prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER_ARB, xybitmap_fs); fs_prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER, xybitmap_fs);
glAttachObjectARB(prog, vs_prog); glAttachShader(prog, vs_prog);
glAttachObjectARB(prog, fs_prog); glAttachShader(prog, fs_prog);
glamor_link_glsl_prog(prog); glamor_link_glsl_prog(prog);
glUseProgramObjectARB(prog); glUseProgram(prog);
sampler_uniform_location = glGetUniformLocationARB(prog, "bitmap_sampler"); sampler_uniform_location = glGetUniformLocation(prog, "bitmap_sampler");
glUniform1iARB(sampler_uniform_location, 0); glUniform1i(sampler_uniform_location, 0);
glamor_priv->put_image_xybitmap_fg_uniform_location = glamor_priv->put_image_xybitmap_fg_uniform_location =
glGetUniformLocationARB(prog, "fg"); glGetUniformLocation(prog, "fg");
glamor_priv->put_image_xybitmap_bg_uniform_location = glamor_priv->put_image_xybitmap_bg_uniform_location =
glGetUniformLocationARB(prog, "bg"); glGetUniformLocation(prog, "bg");
glamor_get_transform_uniform_locations(prog, glamor_get_transform_uniform_locations(prog,
&glamor_priv->put_image_xybitmap_transform); &glamor_priv->put_image_xybitmap_transform);
glamor_priv->put_image_xybitmap_prog = prog; glamor_priv->put_image_xybitmap_prog = prog;
glUseProgramObjectARB(0); glUseProgram(0);
} }
@ -160,13 +160,13 @@ glamor_put_image_xybitmap(DrawablePtr drawable, GCPtr gc,
if (!glamor_set_planemask(pixmap, gc->planemask)) if (!glamor_set_planemask(pixmap, gc->planemask))
goto fail; goto fail;
glUseProgramObjectARB(glamor_priv->put_image_xybitmap_prog); glUseProgram(glamor_priv->put_image_xybitmap_prog);
glamor_get_color_4f_from_pixel(pixmap, gc->fgPixel, fg); glamor_get_color_4f_from_pixel(pixmap, gc->fgPixel, fg);
glUniform4fvARB(glamor_priv->put_image_xybitmap_fg_uniform_location, glUniform4fv(glamor_priv->put_image_xybitmap_fg_uniform_location,
1, fg); 1, fg);
glamor_get_color_4f_from_pixel(pixmap, gc->bgPixel, bg); glamor_get_color_4f_from_pixel(pixmap, gc->bgPixel, bg);
glUniform4fvARB(glamor_priv->put_image_xybitmap_bg_uniform_location, glUniform4fv(glamor_priv->put_image_xybitmap_bg_uniform_location,
1, bg); 1, bg);
glGenTextures(1, &tex); glGenTextures(1, &tex);
@ -322,7 +322,7 @@ glamor_put_image(DrawablePtr drawable, GCPtr gc, int depth, int x, int y,
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
assert(GLEW_ARB_fragment_shader); assert(GLEW_ARB_fragment_shader);
glUseProgramObjectARB(glamor_priv->finish_access_prog[ax]); glUseProgram(glamor_priv->finish_access_prog[ax]);
x += drawable->x; x += drawable->x;
y += drawable->y; y += drawable->y;
@ -371,7 +371,7 @@ glamor_put_image(DrawablePtr drawable, GCPtr gc, int depth, int x, int y,
} }
glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_2D);
glUseProgramObjectARB(0); glUseProgram(0);
glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDeleteTextures(1, &tex); glDeleteTextures(1, &tex);

40
glamor/glamor_render.c
View File

@ -186,7 +186,7 @@ glamor_create_composite_fs(struct shader_key *key)
in); in);
prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER_ARB, source); prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER, source);
free(source); free(source);
return prog; return prog;
@ -223,7 +223,7 @@ glamor_create_composite_vs(struct shader_key *key)
mask_coords_setup, mask_coords_setup,
main_closing); main_closing);
prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER_ARB, source); prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER, source);
free(source); free(source);
return prog; return prog;
@ -243,30 +243,30 @@ glamor_create_composite_shader(ScreenPtr screen, struct shader_key *key,
if (fs == 0) if (fs == 0)
return; return;
prog = glCreateProgramObjectARB(); prog = glCreateProgram();
glAttachObjectARB(prog, vs); glAttachShader(prog, vs);
glAttachObjectARB(prog, fs); glAttachShader(prog, fs);
glamor_link_glsl_prog(prog); glamor_link_glsl_prog(prog);
shader->prog = prog; shader->prog = prog;
glUseProgramObjectARB(prog); glUseProgram(prog);
if (key->source == SHADER_SOURCE_SOLID) { if (key->source == SHADER_SOURCE_SOLID) {
shader->source_uniform_location = glGetUniformLocationARB(prog, shader->source_uniform_location = glGetUniformLocation(prog,
"source"); "source");
} else { } else {
source_sampler_uniform_location = glGetUniformLocationARB(prog, source_sampler_uniform_location = glGetUniformLocation(prog,
"source_sampler"); "source_sampler");
glUniform1i(source_sampler_uniform_location, 0); glUniform1i(source_sampler_uniform_location, 0);
} }
if (key->mask != SHADER_MASK_NONE) { if (key->mask != SHADER_MASK_NONE) {
if (key->mask == SHADER_MASK_SOLID) { if (key->mask == SHADER_MASK_SOLID) {
shader->mask_uniform_location = glGetUniformLocationARB(prog, shader->mask_uniform_location = glGetUniformLocation(prog,
"mask"); "mask");
} else { } else {
mask_sampler_uniform_location = glGetUniformLocationARB(prog, mask_sampler_uniform_location = glGetUniformLocation(prog,
"mask_sampler"); "mask_sampler");
glUniform1i(mask_sampler_uniform_location, 1); glUniform1i(mask_sampler_uniform_location, 1);
} }
@ -397,7 +397,7 @@ glamor_set_composite_texture(ScreenPtr screen, int unit, PicturePtr picture,
static void static void
glamor_set_composite_solid(float *color, GLint uniform_location) glamor_set_composite_solid(float *color, GLint uniform_location)
{ {
glUniform4fvARB(uniform_location, 1, color); glUniform4fv(uniform_location, 1, color);
} }
static int static int
@ -504,7 +504,7 @@ glamor_setup_composite_vbo(ScreenPtr screen)
if (glamor_priv->has_mask_coords) if (glamor_priv->has_mask_coords)
glamor_priv->vb_stride += 2 * sizeof(float); glamor_priv->vb_stride += 2 * sizeof(float);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, glamor_priv->vbo); glBindBuffer(GL_ARRAY_BUFFER, glamor_priv->vbo);
glVertexPointer(2, GL_FLOAT, glamor_priv->vb_stride, glVertexPointer(2, GL_FLOAT, glamor_priv->vb_stride,
(void *)((long)glamor_priv->vbo_offset)); (void *)((long)glamor_priv->vbo_offset));
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
@ -559,8 +559,8 @@ glamor_flush_composite_rects(ScreenPtr screen)
if (!glamor_priv->render_nr_verts) if (!glamor_priv->render_nr_verts)
return; return;
glBufferDataARB(GL_ARRAY_BUFFER_ARB, glamor_priv->vbo_offset, glamor_priv->vb, glBufferData(GL_ARRAY_BUFFER, glamor_priv->vbo_offset, glamor_priv->vb,
GL_STREAM_DRAW_ARB); GL_STREAM_DRAW);
glDrawArrays(GL_QUADS, 0, glamor_priv->render_nr_verts); glDrawArrays(GL_QUADS, 0, glamor_priv->render_nr_verts);
glamor_reset_composite_vbo(screen); glamor_reset_composite_vbo(screen);
@ -582,7 +582,7 @@ glamor_emit_composite_rect(ScreenPtr screen,
if (glamor_priv->vbo_offset == 0) { if (glamor_priv->vbo_offset == 0) {
if (glamor_priv->vbo == 0) if (glamor_priv->vbo == 0)
glGenBuffersARB(1, &glamor_priv->vbo); glGenBuffers(1, &glamor_priv->vbo);
glamor_setup_composite_vbo(screen); glamor_setup_composite_vbo(screen);
} }
@ -882,7 +882,7 @@ glamor_composite_with_shader(CARD8 op,
goto fail; goto fail;
} }
glUseProgramObjectARB(shader->prog); glUseProgram(shader->prog);
if (key.source == SHADER_SOURCE_SOLID) { if (key.source == SHADER_SOURCE_SOLID) {
glamor_set_composite_solid(source_solid_color, shader->source_uniform_location); glamor_set_composite_solid(source_solid_color, shader->source_uniform_location);
} else { } else {
@ -1008,7 +1008,7 @@ glamor_composite_with_shader(CARD8 op,
} }
glamor_flush_composite_rects(screen); glamor_flush_composite_rects(screen);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); glBindBuffer(GL_ARRAY_BUFFER, 0);
glClientActiveTexture(GL_TEXTURE0); glClientActiveTexture(GL_TEXTURE0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE1); glClientActiveTexture(GL_TEXTURE1);
@ -1021,7 +1021,7 @@ glamor_composite_with_shader(CARD8 op,
glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE1); glActiveTexture(GL_TEXTURE1);
glDisable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_2D);
glUseProgramObjectARB(0); glUseProgram(0);
if (saved_source_format) if (saved_source_format)
source->format = saved_source_format; source->format = saved_source_format;
return TRUE; return TRUE;
@ -1031,7 +1031,7 @@ glamor_composite_with_shader(CARD8 op,
source->format = saved_source_format; source->format = saved_source_format;
glDisable(GL_BLEND); glDisable(GL_BLEND);
glUseProgramObjectARB(0); glUseProgram(0);
return FALSE; return FALSE;
} }
@ -1223,7 +1223,7 @@ fail:
dest->pDrawable->height, dest->pDrawable->height,
glamor_get_picture_location(dest)); glamor_get_picture_location(dest));
glUseProgramObjectARB(0); glUseProgram(0);
glDisable(GL_BLEND); glDisable(GL_BLEND);
if (glamor_prepare_access_picture(dest, GLAMOR_ACCESS_RW)) { if (glamor_prepare_access_picture(dest, GLAMOR_ACCESS_RW)) {
if (glamor_prepare_access_picture(source, GLAMOR_ACCESS_RO)) if (glamor_prepare_access_picture(source, GLAMOR_ACCESS_RO))

22
glamor/glamor_tile.c
View File

@ -58,18 +58,18 @@ glamor_init_tile_shader(ScreenPtr screen)
if (!GLEW_ARB_fragment_shader) if (!GLEW_ARB_fragment_shader)
return; return;
glamor_priv->tile_prog = glCreateProgramObjectARB(); glamor_priv->tile_prog = glCreateProgram();
vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER_ARB, tile_vs); vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER, tile_vs);
fs_prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER_ARB, tile_fs); fs_prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER, tile_fs);
glAttachObjectARB(glamor_priv->tile_prog, vs_prog); glAttachShader(glamor_priv->tile_prog, vs_prog);
glAttachObjectARB(glamor_priv->tile_prog, fs_prog); glAttachShader(glamor_priv->tile_prog, fs_prog);
glamor_link_glsl_prog(glamor_priv->tile_prog); glamor_link_glsl_prog(glamor_priv->tile_prog);
sampler_uniform_location = sampler_uniform_location =
glGetUniformLocationARB(glamor_priv->tile_prog, "sampler"); glGetUniformLocation(glamor_priv->tile_prog, "sampler");
glUseProgramObjectARB(glamor_priv->tile_prog); glUseProgram(glamor_priv->tile_prog);
glUniform1iARB(sampler_uniform_location, 0); glUniform1i(sampler_uniform_location, 0);
glUseProgramObjectARB(0); glUseProgram(0);
} }
Bool Bool
@ -130,7 +130,7 @@ glamor_tile(PixmapPtr pixmap, PixmapPtr tile,
if (GLAMOR_PIXMAP_PRIV_NO_PENDING(src_pixmap_priv)) { if (GLAMOR_PIXMAP_PRIV_NO_PENDING(src_pixmap_priv)) {
pixmap_priv_get_scale(src_pixmap_priv, &src_xscale, &src_yscale); pixmap_priv_get_scale(src_pixmap_priv, &src_xscale, &src_yscale);
glUseProgramObjectARB(glamor_priv->tile_prog); glUseProgram(glamor_priv->tile_prog);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, src_pixmap_priv->tex); glBindTexture(GL_TEXTURE_2D, src_pixmap_priv->tex);
@ -169,7 +169,7 @@ glamor_tile(PixmapPtr pixmap, PixmapPtr tile,
} }
glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_VERTEX_ARRAY);
glUseProgramObjectARB(0); glUseProgram(0);
glamor_set_alu(GXcopy); glamor_set_alu(GXcopy);
glamor_set_planemask(pixmap, ~0); glamor_set_planemask(pixmap, ~0);
return TRUE; return TRUE;