| 0,0 → 1,852 |
|---|
| /* |
| * Copyright (c) 2013 Brian Paul All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included |
| * in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| * OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| |
| |
| /* |
| * Off-Screen rendering into client memory. |
| * State tracker for gallium (for softpipe and llvmpipe) |
| * |
| * Notes: |
| * |
| * If Gallium is built with LLVM support we use the llvmpipe driver. |
| * Otherwise we use softpipe. The GALLIUM_DRIVER environment variable |
| * may be set to "softpipe" or "llvmpipe" to override. |
| * |
| * With softpipe we could render directly into the user's buffer by using a |
| * display target resource. However, softpipe doesn't suport "upside-down" |
| * rendering which would be needed for the OSMESA_Y_UP=TRUE case. |
| * |
| * With llvmpipe we could only render directly into the user's buffer when its |
| * width and height is a multiple of the tile size (64 pixels). |
| * |
| * Because of these constraints we always render into ordinary resources then |
| * copy the results to the user's buffer in the flush_front() function which |
| * is called when the app calls glFlush/Finish. |
| * |
| * In general, the OSMesa interface is pretty ugly and not a good match |
| * for Gallium. But we're interested in doing the best we can to preserve |
| * application portability. With a little work we could come up with a |
| * much nicer, new off-screen Gallium interface... |
| */ |
| |
| |
| #include "GL/osmesa.h" |
| |
| #include "glapi/glapi.h" /* for OSMesaGetProcAddress below */ |
| |
| #include "pipe/p_context.h" |
| #include "pipe/p_screen.h" |
| #include "pipe/p_state.h" |
| |
| #include "util/u_atomic.h" |
| #include "util/u_box.h" |
| #include "util/u_format.h" |
| #include "util/u_memory.h" |
| |
| #include "state_tracker/st_api.h" |
| #include "state_tracker/st_gl_api.h" |
| |
| |
| |
| extern struct pipe_screen * |
| osmesa_create_screen(void); |
| |
| |
| |
| struct osmesa_buffer |
| { |
| struct st_framebuffer_iface *stfb; |
| struct st_visual visual; |
| unsigned width, height; |
| |
| struct pipe_resource *textures[ST_ATTACHMENT_COUNT]; |
| |
| void *map; |
| |
| struct osmesa_buffer *next; /**< next in linked list */ |
| }; |
| |
| |
| struct osmesa_context |
| { |
| struct st_context_iface *stctx; |
| |
| struct osmesa_buffer *current_buffer; |
| |
| enum pipe_format depth_stencil_format, accum_format; |
| |
| GLenum format; /*< User-specified context format */ |
| GLenum type; /*< Buffer's data type */ |
| GLint user_row_length; /*< user-specified number of pixels per row */ |
| GLboolean y_up; /*< TRUE -> Y increases upward */ |
| /*< FALSE -> Y increases downward */ |
| }; |
| |
| |
| /** |
| * Linked list of all osmesa_buffers. |
| * We can re-use an osmesa_buffer from one OSMesaMakeCurrent() call to |
| * the next unless the color/depth/stencil/accum formats change. |
| * We have to do this to be compatible with the original OSMesa implementation |
| * because some apps call OSMesaMakeCurrent() several times during rendering |
| * a frame. |
| */ |
| static struct osmesa_buffer *BufferList = NULL; |
| |
| |
| /** |
| * Called from the ST manager. |
| */ |
| static int |
| osmesa_st_get_param(struct st_manager *smapi, enum st_manager_param param) |
| { |
| /* no-op */ |
| return 0; |
| } |
| |
| |
| /** |
| * Create/return singleton st_api object. |
| */ |
| static struct st_api * |
| get_st_api(void) |
| { |
| static struct st_api *stapi = NULL; |
| if (!stapi) { |
| stapi = st_gl_api_create(); |
| } |
| return stapi; |
| } |
| |
| |
| /** |
| * Create/return a singleton st_manager object. |
| */ |
| static struct st_manager * |
| get_st_manager(void) |
| { |
| static struct st_manager *stmgr = NULL; |
| if (!stmgr) { |
| stmgr = CALLOC_STRUCT(st_manager); |
| if (stmgr) { |
| stmgr->screen = osmesa_create_screen(); |
| stmgr->get_param = osmesa_st_get_param; |
| stmgr->get_egl_image = NULL; |
| } |
| } |
| return stmgr; |
| } |
| |
| |
| static INLINE boolean |
| little_endian(void) |
| { |
| const unsigned ui = 1; |
| return *((const char *) &ui); |
| } |
| |
| |
| /** |
| * Given an OSMESA_x format and a GL_y type, return the best |
| * matching PIPE_FORMAT_z. |
| * Note that we can't exactly match all user format/type combinations |
| * with gallium formats. If we find this to be a problem, we can |
| * implement more elaborate format/type conversion in the flush_front() |
| * function. |
| */ |
| static enum pipe_format |
| osmesa_choose_format(GLenum format, GLenum type) |
| { |
| switch (format) { |
| case OSMESA_RGBA: |
| if (type == GL_UNSIGNED_BYTE) { |
| if (little_endian()) |
| return PIPE_FORMAT_R8G8B8A8_UNORM; |
| else |
| return PIPE_FORMAT_A8B8G8R8_UNORM; |
| } |
| else if (type == GL_UNSIGNED_SHORT) { |
| return PIPE_FORMAT_R16G16B16A16_UNORM; |
| } |
| else if (type == GL_FLOAT) { |
| return PIPE_FORMAT_R32G32B32A32_FLOAT; |
| } |
| else { |
| return PIPE_FORMAT_NONE; |
| } |
| break; |
| case OSMESA_BGRA: |
| if (type == GL_UNSIGNED_BYTE) { |
| if (little_endian()) |
| return PIPE_FORMAT_B8G8R8A8_UNORM; |
| else |
| return PIPE_FORMAT_A8R8G8B8_UNORM; |
| } |
| else if (type == GL_UNSIGNED_SHORT) { |
| return PIPE_FORMAT_R16G16B16A16_UNORM; |
| } |
| else if (type == GL_FLOAT) { |
| return PIPE_FORMAT_R32G32B32A32_FLOAT; |
| } |
| else { |
| return PIPE_FORMAT_NONE; |
| } |
| break; |
| case OSMESA_ARGB: |
| if (type == GL_UNSIGNED_BYTE) { |
| if (little_endian()) |
| return PIPE_FORMAT_A8R8G8B8_UNORM; |
| else |
| return PIPE_FORMAT_B8G8R8A8_UNORM; |
| } |
| else if (type == GL_UNSIGNED_SHORT) { |
| return PIPE_FORMAT_R16G16B16A16_UNORM; |
| } |
| else if (type == GL_FLOAT) { |
| return PIPE_FORMAT_R32G32B32A32_FLOAT; |
| } |
| else { |
| return PIPE_FORMAT_NONE; |
| } |
| break; |
| case OSMESA_RGB: |
| if (type == GL_UNSIGNED_BYTE) { |
| return PIPE_FORMAT_R8G8B8_UNORM; |
| } |
| else if (type == GL_UNSIGNED_SHORT) { |
| return PIPE_FORMAT_R16G16B16_UNORM; |
| } |
| else if (type == GL_FLOAT) { |
| return PIPE_FORMAT_R32G32B32_FLOAT; |
| } |
| else { |
| return PIPE_FORMAT_NONE; |
| } |
| break; |
| case OSMESA_BGR: |
| /* No gallium format for this one */ |
| return PIPE_FORMAT_NONE; |
| case OSMESA_RGB_565: |
| return PIPE_FORMAT_B5G6R5_UNORM; |
| default: |
| ; /* fall-through */ |
| } |
| return PIPE_FORMAT_NONE; |
| } |
| |
| |
| /** |
| * Initialize an st_visual object. |
| */ |
| static void |
| osmesa_init_st_visual(struct st_visual *vis, |
| enum pipe_format color_format, |
| enum pipe_format ds_format, |
| enum pipe_format accum_format) |
| { |
| vis->buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK; |
| vis->color_format = color_format; |
| vis->depth_stencil_format = ds_format; |
| vis->accum_format = accum_format; |
| vis->samples = 1; |
| vis->render_buffer = ST_ATTACHMENT_FRONT_LEFT; |
| } |
| |
| |
| /** |
| * Return the osmesa_buffer that corresponds to an st_framebuffer_iface. |
| */ |
| static INLINE struct osmesa_buffer * |
| stfbi_to_osbuffer(struct st_framebuffer_iface *stfbi) |
| { |
| return (struct osmesa_buffer *) stfbi->st_manager_private; |
| } |
| |
| |
| /** |
| * Called via glFlush/glFinish. This is where we copy the contents |
| * of the driver's color buffer into the user-specified buffer. |
| */ |
| static boolean |
| osmesa_st_framebuffer_flush_front(struct st_context_iface *stctx, |
| struct st_framebuffer_iface *stfbi, |
| enum st_attachment_type statt) |
| { |
| OSMesaContext osmesa = OSMesaGetCurrentContext(); |
| struct osmesa_buffer *osbuffer = stfbi_to_osbuffer(stfbi); |
| struct pipe_context *pipe = stctx->pipe; |
| struct pipe_resource *res = osbuffer->textures[statt]; |
| struct pipe_transfer *transfer = NULL; |
| struct pipe_box box; |
| void *map; |
| ubyte *src, *dst; |
| unsigned y, bytes, bpp; |
| int dst_stride; |
| |
| u_box_2d(0, 0, res->width0, res->height0, &box); |
| |
| map = pipe->transfer_map(pipe, res, 0, PIPE_TRANSFER_READ, &box, |
| &transfer); |
| |
| /* |
| * Copy the color buffer from the resource to the user's buffer. |
| */ |
| bpp = util_format_get_blocksize(osbuffer->visual.color_format); |
| src = map; |
| dst = osbuffer->map; |
| if (osmesa->user_row_length) |
| dst_stride = bpp * osmesa->user_row_length; |
| else |
| dst_stride = bpp * osbuffer->width; |
| bytes = bpp * res->width0; |
| |
| if (osmesa->y_up) { |
| /* need to flip image upside down */ |
| dst = dst + (res->height0 - 1) * dst_stride; |
| dst_stride = -dst_stride; |
| } |
| |
| for (y = 0; y < res->height0; y++) { |
| memcpy(dst, src, bytes); |
| dst += dst_stride; |
| src += transfer->stride; |
| } |
| |
| pipe->transfer_unmap(pipe, transfer); |
| |
| return TRUE; |
| } |
| |
| |
| /** |
| * Called by the st manager to validate the framebuffer (allocate |
| * its resources). |
| */ |
| static boolean |
| osmesa_st_framebuffer_validate(struct st_context_iface *stctx, |
| struct st_framebuffer_iface *stfbi, |
| const enum st_attachment_type *statts, |
| unsigned count, |
| struct pipe_resource **out) |
| { |
| struct pipe_screen *screen = get_st_manager()->screen; |
| enum st_attachment_type i; |
| struct osmesa_buffer *osbuffer = stfbi_to_osbuffer(stfbi); |
| struct pipe_resource templat; |
| |
| memset(&templat, 0, sizeof(templat)); |
| templat.target = PIPE_TEXTURE_RECT; |
| templat.format = 0; /* setup below */ |
| templat.last_level = 0; |
| templat.width0 = osbuffer->width; |
| templat.height0 = osbuffer->height; |
| templat.depth0 = 1; |
| templat.array_size = 1; |
| templat.usage = PIPE_USAGE_DEFAULT; |
| templat.bind = 0; /* setup below */ |
| templat.flags = 0; |
| |
| for (i = 0; i < count; i++) { |
| enum pipe_format format = PIPE_FORMAT_NONE; |
| unsigned bind = 0; |
| |
| /* |
| * At this time, we really only need to handle the front-left color |
| * attachment, since that's all we specified for the visual in |
| * osmesa_init_st_visual(). |
| */ |
| if (statts[i] == ST_ATTACHMENT_FRONT_LEFT) { |
| format = osbuffer->visual.color_format; |
| bind = PIPE_BIND_RENDER_TARGET; |
| } |
| else if (statts[i] == ST_ATTACHMENT_DEPTH_STENCIL) { |
| format = osbuffer->visual.depth_stencil_format; |
| bind = PIPE_BIND_DEPTH_STENCIL; |
| } |
| else if (statts[i] == ST_ATTACHMENT_ACCUM) { |
| format = osbuffer->visual.accum_format; |
| bind = PIPE_BIND_RENDER_TARGET; |
| } |
| else { |
| debug_warning("Unexpected attachment type in " |
| "osmesa_st_framebuffer_validate()"); |
| } |
| |
| templat.format = format; |
| templat.bind = bind; |
| out[i] = osbuffer->textures[i] = |
| screen->resource_create(screen, &templat); |
| } |
| |
| return TRUE; |
| } |
| |
| |
| static struct st_framebuffer_iface * |
| osmesa_create_st_framebuffer(void) |
| { |
| struct st_framebuffer_iface *stfbi = CALLOC_STRUCT(st_framebuffer_iface); |
| if (stfbi) { |
| stfbi->flush_front = osmesa_st_framebuffer_flush_front; |
| stfbi->validate = osmesa_st_framebuffer_validate; |
| p_atomic_set(&stfbi->stamp, 1); |
| } |
| return stfbi; |
| } |
| |
| |
| /** |
| * Create new buffer and add to linked list. |
| */ |
| static struct osmesa_buffer * |
| osmesa_create_buffer(enum pipe_format color_format, |
| enum pipe_format ds_format, |
| enum pipe_format accum_format) |
| { |
| struct osmesa_buffer *osbuffer = CALLOC_STRUCT(osmesa_buffer); |
| if (osbuffer) { |
| osbuffer->stfb = osmesa_create_st_framebuffer(); |
| |
| osbuffer->stfb->st_manager_private = osbuffer; |
| osbuffer->stfb->visual = &osbuffer->visual; |
| |
| osmesa_init_st_visual(&osbuffer->visual, color_format, |
| ds_format, accum_format); |
| |
| /* insert into linked list */ |
| osbuffer->next = BufferList; |
| BufferList = osbuffer; |
| } |
| |
| return osbuffer; |
| } |
| |
| |
| /** |
| * Search linked list for a buffer with matching pixel formats. |
| */ |
| static struct osmesa_buffer * |
| osmesa_find_buffer(enum pipe_format color_format, |
| enum pipe_format ds_format, |
| enum pipe_format accum_format) |
| { |
| struct osmesa_buffer *b; |
| |
| /* Check if we already have a suitable buffer for the given formats */ |
| for (b = BufferList; b; b = b->next) { |
| if (b->visual.color_format == color_format && |
| b->visual.depth_stencil_format == ds_format && |
| b->visual.accum_format == accum_format) { |
| return b; |
| } |
| } |
| return NULL; |
| } |
| |
| |
| static void |
| osmesa_destroy_buffer(struct osmesa_buffer *osbuffer) |
| { |
| FREE(osbuffer->stfb); |
| FREE(osbuffer); |
| } |
| |
| |
| |
| /**********************************************************************/ |
| /***** Public Functions *****/ |
| /**********************************************************************/ |
| |
| |
| /** |
| * Create an Off-Screen Mesa rendering context. The only attribute needed is |
| * an RGBA vs Color-Index mode flag. |
| * |
| * Input: format - Must be GL_RGBA |
| * sharelist - specifies another OSMesaContext with which to share |
| * display lists. NULL indicates no sharing. |
| * Return: an OSMesaContext or 0 if error |
| */ |
| GLAPI OSMesaContext GLAPIENTRY |
| OSMesaCreateContext(GLenum format, OSMesaContext sharelist) |
| { |
| return OSMesaCreateContextExt(format, 24, 8, 0, sharelist); |
| } |
| |
| |
| /** |
| * New in Mesa 3.5 |
| * |
| * Create context and specify size of ancillary buffers. |
| */ |
| GLAPI OSMesaContext GLAPIENTRY |
| OSMesaCreateContextExt(GLenum format, GLint depthBits, GLint stencilBits, |
| GLint accumBits, OSMesaContext sharelist) |
| { |
| OSMesaContext osmesa; |
| struct st_context_iface *st_shared; |
| enum st_context_error st_error = 0; |
| struct st_context_attribs attribs; |
| struct st_api *stapi = get_st_api(); |
| |
| if (sharelist) { |
| st_shared = sharelist->stctx; |
| } |
| else { |
| st_shared = NULL; |
| } |
| |
| osmesa = (OSMesaContext) CALLOC_STRUCT(osmesa_context); |
| if (!osmesa) |
| return NULL; |
| |
| /* Choose depth/stencil/accum buffer formats */ |
| if (accumBits > 0) { |
| osmesa->accum_format = PIPE_FORMAT_R16G16B16A16_SNORM; |
| } |
| if (depthBits > 0 && stencilBits > 0) { |
| osmesa->depth_stencil_format = PIPE_FORMAT_Z24_UNORM_S8_UINT; |
| } |
| else if (stencilBits > 0) { |
| osmesa->depth_stencil_format = PIPE_FORMAT_S8_UINT; |
| } |
| else if (depthBits >= 24) { |
| osmesa->depth_stencil_format = PIPE_FORMAT_Z24X8_UNORM; |
| } |
| else if (depthBits >= 16) { |
| osmesa->depth_stencil_format = PIPE_FORMAT_Z16_UNORM; |
| } |
| |
| /* |
| * Create the rendering context |
| */ |
| attribs.profile = ST_PROFILE_DEFAULT; |
| attribs.major = 2; |
| attribs.minor = 1; |
| attribs.flags = 0; /* ST_CONTEXT_FLAG_x */ |
| attribs.options.force_glsl_extensions_warn = FALSE; |
| attribs.options.disable_blend_func_extended = FALSE; |
| attribs.options.disable_glsl_line_continuations = FALSE; |
| attribs.options.disable_shader_bit_encoding = FALSE; |
| attribs.options.force_s3tc_enable = FALSE; |
| attribs.options.force_glsl_version = 0; |
| |
| osmesa_init_st_visual(&attribs.visual, |
| PIPE_FORMAT_R8G8B8A8_UNORM, |
| osmesa->depth_stencil_format, |
| osmesa->accum_format); |
| |
| osmesa->stctx = stapi->create_context(stapi, get_st_manager(), |
| &attribs, &st_error, st_shared); |
| if (!osmesa->stctx) { |
| FREE(osmesa); |
| return NULL; |
| } |
| |
| osmesa->stctx->st_manager_private = osmesa; |
| |
| osmesa->format = format; |
| osmesa->user_row_length = 0; |
| osmesa->y_up = GL_TRUE; |
| |
| return osmesa; |
| } |
| |
| |
| /** |
| * Destroy an Off-Screen Mesa rendering context. |
| * |
| * \param osmesa the context to destroy |
| */ |
| GLAPI void GLAPIENTRY |
| OSMesaDestroyContext(OSMesaContext osmesa) |
| { |
| if (osmesa) { |
| osmesa->stctx->destroy(osmesa->stctx); |
| FREE(osmesa); |
| } |
| } |
| |
| |
| /** |
| * Bind an OSMesaContext to an image buffer. The image buffer is just a |
| * block of memory which the client provides. Its size must be at least |
| * as large as width*height*pixelSize. Its address should be a multiple |
| * of 4 if using RGBA mode. |
| * |
| * By default, image data is stored in the order of glDrawPixels: row-major |
| * order with the lower-left image pixel stored in the first array position |
| * (ie. bottom-to-top). |
| * |
| * If the context's viewport hasn't been initialized yet, it will now be |
| * initialized to (0,0,width,height). |
| * |
| * Input: osmesa - the rendering context |
| * buffer - the image buffer memory |
| * type - data type for pixel components |
| * GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT |
| * or GL_FLOAT. |
| * width, height - size of image buffer in pixels, at least 1 |
| * Return: GL_TRUE if success, GL_FALSE if error because of invalid osmesa, |
| * invalid type, invalid size, etc. |
| */ |
| GLAPI GLboolean GLAPIENTRY |
| OSMesaMakeCurrent(OSMesaContext osmesa, void *buffer, GLenum type, |
| GLsizei width, GLsizei height) |
| { |
| struct st_api *stapi = get_st_api(); |
| struct osmesa_buffer *osbuffer; |
| enum pipe_format color_format; |
| |
| if (!osmesa || !buffer || width < 1 || height < 1) { |
| return GL_FALSE; |
| } |
| |
| if (osmesa->format == OSMESA_RGB_565 && type != GL_UNSIGNED_SHORT_5_6_5) { |
| return GL_FALSE; |
| } |
| |
| color_format = osmesa_choose_format(osmesa->format, type); |
| if (color_format == PIPE_FORMAT_NONE) { |
| fprintf(stderr, "OSMesaMakeCurrent(unsupported format/type)\n"); |
| return GL_FALSE; |
| } |
| |
| /* See if we already have a buffer that uses these pixel formats */ |
| osbuffer = osmesa_find_buffer(color_format, |
| osmesa->depth_stencil_format, |
| osmesa->accum_format); |
| if (!osbuffer) { |
| /* Existing buffer found, create new buffer */ |
| osbuffer = osmesa_create_buffer(color_format, |
| osmesa->depth_stencil_format, |
| osmesa->accum_format); |
| } |
| |
| osbuffer->width = width; |
| osbuffer->height = height; |
| osbuffer->map = buffer; |
| |
| /* XXX unused for now */ |
| (void) osmesa_destroy_buffer; |
| |
| osmesa->current_buffer = osbuffer; |
| osmesa->type = type; |
| |
| stapi->make_current(stapi, osmesa->stctx, osbuffer->stfb, osbuffer->stfb); |
| |
| return GL_TRUE; |
| } |
| |
| |
| |
| GLAPI OSMesaContext GLAPIENTRY |
| OSMesaGetCurrentContext(void) |
| { |
| struct st_api *stapi = get_st_api(); |
| struct st_context_iface *st = stapi->get_current(stapi); |
| return st ? (OSMesaContext) st->st_manager_private : NULL; |
| } |
| |
| |
| |
| GLAPI void GLAPIENTRY |
| OSMesaPixelStore(GLint pname, GLint value) |
| { |
| OSMesaContext osmesa = OSMesaGetCurrentContext(); |
| |
| switch (pname) { |
| case OSMESA_ROW_LENGTH: |
| osmesa->user_row_length = value; |
| break; |
| case OSMESA_Y_UP: |
| osmesa->y_up = value ? GL_TRUE : GL_FALSE; |
| break; |
| default: |
| fprintf(stderr, "Invalid pname in OSMesaPixelStore()\n"); |
| return; |
| } |
| } |
| |
| |
| GLAPI void GLAPIENTRY |
| OSMesaGetIntegerv(GLint pname, GLint *value) |
| { |
| OSMesaContext osmesa = OSMesaGetCurrentContext(); |
| struct osmesa_buffer *osbuffer = osmesa ? osmesa->current_buffer : NULL; |
| |
| switch (pname) { |
| case OSMESA_WIDTH: |
| *value = osbuffer ? osbuffer->width : 0; |
| return; |
| case OSMESA_HEIGHT: |
| *value = osbuffer ? osbuffer->height : 0; |
| return; |
| case OSMESA_FORMAT: |
| *value = osmesa->format; |
| return; |
| case OSMESA_TYPE: |
| /* current color buffer's data type */ |
| *value = osmesa->type; |
| return; |
| case OSMESA_ROW_LENGTH: |
| *value = osmesa->user_row_length; |
| return; |
| case OSMESA_Y_UP: |
| *value = osmesa->y_up; |
| return; |
| case OSMESA_MAX_WIDTH: |
| /* fall-through */ |
| case OSMESA_MAX_HEIGHT: |
| { |
| struct pipe_screen *screen = get_st_manager()->screen; |
| int maxLevels = screen->get_param(screen, |
| PIPE_CAP_MAX_TEXTURE_2D_LEVELS); |
| *value = 1 << (maxLevels - 1); |
| *value = 8 * 1024; |
| } |
| return; |
| default: |
| fprintf(stderr, "Invalid pname in OSMesaGetIntegerv()\n"); |
| return; |
| } |
| } |
| |
| |
| /** |
| * Return information about the depth buffer associated with an OSMesa context. |
| * Input: c - the OSMesa context |
| * Output: width, height - size of buffer in pixels |
| * bytesPerValue - bytes per depth value (2 or 4) |
| * buffer - pointer to depth buffer values |
| * Return: GL_TRUE or GL_FALSE to indicate success or failure. |
| */ |
| GLAPI GLboolean GLAPIENTRY |
| OSMesaGetDepthBuffer(OSMesaContext c, GLint *width, GLint *height, |
| GLint *bytesPerValue, void **buffer) |
| { |
| struct osmesa_buffer *osbuffer = c->current_buffer; |
| struct pipe_context *pipe = c->stctx->pipe; |
| struct pipe_resource *res = osbuffer->textures[ST_ATTACHMENT_DEPTH_STENCIL]; |
| struct pipe_transfer *transfer = NULL; |
| struct pipe_box box; |
| |
| /* |
| * Note: we can't really implement this function with gallium as |
| * we did for swrast. We can't just map the resource and leave it |
| * mapped (and there's no OSMesaUnmapDepthBuffer() function) so |
| * we unmap the buffer here and return a 'stale' pointer. This should |
| * actually be OK in most cases where the caller of this function |
| * immediately uses the pointer. |
| */ |
| |
| u_box_2d(0, 0, res->width0, res->height0, &box); |
| |
| *buffer = pipe->transfer_map(pipe, res, 0, PIPE_TRANSFER_READ, &box, |
| &transfer); |
| if (!*buffer) { |
| return GL_FALSE; |
| } |
| |
| *width = res->width0; |
| *height = res->height0; |
| *bytesPerValue = util_format_get_blocksize(res->format); |
| |
| pipe->transfer_unmap(pipe, transfer); |
| |
| return GL_TRUE; |
| } |
| |
| |
| /** |
| * Return the color buffer associated with an OSMesa context. |
| * Input: c - the OSMesa context |
| * Output: width, height - size of buffer in pixels |
| * format - the pixel format (OSMESA_FORMAT) |
| * buffer - pointer to color buffer values |
| * Return: GL_TRUE or GL_FALSE to indicate success or failure. |
| */ |
| GLAPI GLboolean GLAPIENTRY |
| OSMesaGetColorBuffer(OSMesaContext osmesa, GLint *width, |
| GLint *height, GLint *format, void **buffer) |
| { |
| struct osmesa_buffer *osbuffer = osmesa->current_buffer; |
| |
| if (osbuffer) { |
| *width = osbuffer->width; |
| *height = osbuffer->height; |
| *format = osmesa->format; |
| *buffer = osbuffer->map; |
| return GL_TRUE; |
| } |
| else { |
| *width = 0; |
| *height = 0; |
| *format = 0; |
| *buffer = 0; |
| return GL_FALSE; |
| } |
| } |
| |
| |
| struct name_function |
| { |
| const char *Name; |
| OSMESAproc Function; |
| }; |
| |
| static struct name_function functions[] = { |
| { "OSMesaCreateContext", (OSMESAproc) OSMesaCreateContext }, |
| { "OSMesaCreateContextExt", (OSMESAproc) OSMesaCreateContextExt }, |
| { "OSMesaDestroyContext", (OSMESAproc) OSMesaDestroyContext }, |
| { "OSMesaMakeCurrent", (OSMESAproc) OSMesaMakeCurrent }, |
| { "OSMesaGetCurrentContext", (OSMESAproc) OSMesaGetCurrentContext }, |
| { "OSMesaPixelsStore", (OSMESAproc) OSMesaPixelStore }, |
| { "OSMesaGetIntegerv", (OSMESAproc) OSMesaGetIntegerv }, |
| { "OSMesaGetDepthBuffer", (OSMESAproc) OSMesaGetDepthBuffer }, |
| { "OSMesaGetColorBuffer", (OSMESAproc) OSMesaGetColorBuffer }, |
| { "OSMesaGetProcAddress", (OSMESAproc) OSMesaGetProcAddress }, |
| { "OSMesaColorClamp", (OSMESAproc) OSMesaColorClamp }, |
| { NULL, NULL } |
| }; |
| |
| |
| GLAPI OSMESAproc GLAPIENTRY |
| OSMesaGetProcAddress(const char *funcName) |
| { |
| int i; |
| for (i = 0; functions[i].Name; i++) { |
| if (strcmp(functions[i].Name, funcName) == 0) |
| return functions[i].Function; |
| } |
| return _glapi_get_proc_address(funcName); |
| } |
| |
| |
| GLAPI void GLAPIENTRY |
| OSMesaColorClamp(GLboolean enable) |
| { |
| extern void GLAPIENTRY _mesa_ClampColor(GLenum target, GLenum clamp); |
| |
| _mesa_ClampColor(GL_CLAMP_FRAGMENT_COLOR_ARB, |
| enable ? GL_TRUE : GL_FIXED_ONLY_ARB); |
| } |