Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Mesa 3-D graphics library
  3.  *
  4.  * Copyright (C) 2010 LunarG Inc.
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a
  7.  * copy of this software and associated documentation files (the "Software"),
  8.  * to deal in the Software without restriction, including without limitation
  9.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10.  * and/or sell copies of the Software, and to permit persons to whom the
  11.  * Software is furnished to do so, subject to the following conditions:
  12.  *
  13.  * The above copyright notice and this permission notice shall be included
  14.  * in all copies or substantial portions of the Software.
  15.  *
  16.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21.  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22.  * DEALINGS IN THE SOFTWARE.
  23.  *
  24.  * Authors:
  25.  *    Chia-I Wu <olv@lunarg.com>
  26.  */
  27.  
  28. #include "xm_api.h"
  29. #include "xm_st.h"
  30.  
  31. #include "util/u_inlines.h"
  32. #include "util/u_atomic.h"
  33.  
  34. struct xmesa_st_framebuffer {
  35.    XMesaDisplay display;
  36.    XMesaBuffer buffer;
  37.    struct pipe_screen *screen;
  38.  
  39.    struct st_visual stvis;
  40.    enum pipe_texture_target target;
  41.  
  42.    unsigned texture_width, texture_height, texture_mask;
  43.    struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
  44.  
  45.    struct pipe_resource *display_resource;
  46. };
  47.  
  48.  
  49. static INLINE struct xmesa_st_framebuffer *
  50. xmesa_st_framebuffer(struct st_framebuffer_iface *stfbi)
  51. {
  52.    return (struct xmesa_st_framebuffer *) stfbi->st_manager_private;
  53. }
  54.  
  55.  
  56. /**
  57.  * Display (present) an attachment to the xlib_drawable of the framebuffer.
  58.  */
  59. static boolean
  60. xmesa_st_framebuffer_display(struct st_framebuffer_iface *stfbi,
  61.                              enum st_attachment_type statt)
  62. {
  63.    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  64.    struct pipe_resource *ptex = xstfb->textures[statt];
  65.    struct pipe_resource *pres;
  66.  
  67.    if (!ptex)
  68.       return TRUE;
  69.  
  70.    pres = xstfb->display_resource;
  71.    /* (re)allocate the surface for the texture to be displayed */
  72.    if (!pres || pres != ptex) {
  73.       pipe_resource_reference(&xstfb->display_resource, ptex);
  74.       pres = xstfb->display_resource;
  75.    }
  76.  
  77.    xstfb->screen->flush_frontbuffer(xstfb->screen, pres, 0, 0, &xstfb->buffer->ws, NULL);
  78.    return TRUE;
  79. }
  80.  
  81.  
  82. /**
  83.  * Copy the contents between the attachments.
  84.  */
  85. static void
  86. xmesa_st_framebuffer_copy_textures(struct st_framebuffer_iface *stfbi,
  87.                                    enum st_attachment_type src_statt,
  88.                                    enum st_attachment_type dst_statt,
  89.                                    unsigned x, unsigned y,
  90.                                    unsigned width, unsigned height)
  91. {
  92.    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  93.    struct pipe_resource *src_ptex = xstfb->textures[src_statt];
  94.    struct pipe_resource *dst_ptex = xstfb->textures[dst_statt];
  95.    struct pipe_box src_box;
  96.    struct pipe_context *pipe;
  97.  
  98.    if (!src_ptex || !dst_ptex)
  99.       return;
  100.  
  101.    pipe = xmesa_get_context(stfbi);
  102.  
  103.    u_box_2d(x, y, width, height, &src_box);
  104.  
  105.    if (src_ptex && dst_ptex)
  106.       pipe->resource_copy_region(pipe, dst_ptex, 0, x, y, 0,
  107.                                  src_ptex, 0, &src_box);
  108. }
  109.  
  110.  
  111. /**
  112.  * Remove outdated textures and create the requested ones.
  113.  * This is a helper used during framebuffer validation.
  114.  */
  115. boolean
  116. xmesa_st_framebuffer_validate_textures(struct st_framebuffer_iface *stfbi,
  117.                                        unsigned width, unsigned height,
  118.                                        unsigned mask)
  119. {
  120.    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  121.    struct pipe_resource templ;
  122.    enum st_attachment_type i;
  123.  
  124.    /* remove outdated textures */
  125.    if (xstfb->texture_width != width || xstfb->texture_height != height) {
  126.       for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
  127.          pipe_resource_reference(&xstfb->textures[i], NULL);
  128.    }
  129.  
  130.    memset(&templ, 0, sizeof(templ));
  131.    templ.target = xstfb->target;
  132.    templ.width0 = width;
  133.    templ.height0 = height;
  134.    templ.depth0 = 1;
  135.    templ.array_size = 1;
  136.    templ.last_level = 0;
  137.  
  138.    for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
  139.       enum pipe_format format;
  140.       unsigned bind;
  141.  
  142.       /* the texture already exists or not requested */
  143.       if (xstfb->textures[i] || !(mask & (1 << i))) {
  144.          /* remember the texture */
  145.          if (xstfb->textures[i])
  146.             mask |= (1 << i);
  147.          continue;
  148.       }
  149.  
  150.       switch (i) {
  151.       case ST_ATTACHMENT_FRONT_LEFT:
  152.       case ST_ATTACHMENT_BACK_LEFT:
  153.       case ST_ATTACHMENT_FRONT_RIGHT:
  154.       case ST_ATTACHMENT_BACK_RIGHT:
  155.          format = xstfb->stvis.color_format;
  156.          bind = PIPE_BIND_DISPLAY_TARGET |
  157.                      PIPE_BIND_RENDER_TARGET;
  158.          break;
  159.       case ST_ATTACHMENT_DEPTH_STENCIL:
  160.          format = xstfb->stvis.depth_stencil_format;
  161.          bind = PIPE_BIND_DEPTH_STENCIL;
  162.          break;
  163.       default:
  164.          format = PIPE_FORMAT_NONE;
  165.          break;
  166.       }
  167.  
  168.       if (format != PIPE_FORMAT_NONE) {
  169.          templ.format = format;
  170.          templ.bind = bind;
  171.  
  172.          xstfb->textures[i] =
  173.             xstfb->screen->resource_create(xstfb->screen, &templ);
  174.          if (!xstfb->textures[i])
  175.             return FALSE;
  176.       }
  177.    }
  178.  
  179.    xstfb->texture_width = width;
  180.    xstfb->texture_height = height;
  181.    xstfb->texture_mask = mask;
  182.  
  183.    return TRUE;
  184. }
  185.  
  186.  
  187. /**
  188.  * Check that a framebuffer's attachments match the window's size.
  189.  *
  190.  * Called via st_framebuffer_iface::validate()
  191.  *
  192.  * \param statts  array of framebuffer attachments
  193.  * \param count  number of framebuffer attachments in statts[]
  194.  * \param out  returns resources for each of the attachments
  195.  */
  196. static boolean
  197. xmesa_st_framebuffer_validate(struct st_context_iface *stctx,
  198.                               struct st_framebuffer_iface *stfbi,
  199.                               const enum st_attachment_type *statts,
  200.                               unsigned count,
  201.                               struct pipe_resource **out)
  202. {
  203.    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  204.    unsigned statt_mask, new_mask, i;
  205.    boolean resized;
  206.    boolean ret;
  207.  
  208.    /* build mask of ST_ATTACHMENT bits */
  209.    statt_mask = 0x0;
  210.    for (i = 0; i < count; i++)
  211.       statt_mask |= 1 << statts[i];
  212.  
  213.    /* record newly allocated textures */
  214.    new_mask = statt_mask & ~xstfb->texture_mask;
  215.  
  216.    /* If xmesa_strict_invalidate is not set, we will not yet have
  217.     * called XGetGeometry().  Do so here:
  218.     */
  219.    if (!xmesa_strict_invalidate)
  220.       xmesa_check_buffer_size(xstfb->buffer);
  221.  
  222.    resized = (xstfb->buffer->width != xstfb->texture_width ||
  223.               xstfb->buffer->height != xstfb->texture_height);
  224.  
  225.    /* revalidate textures */
  226.    if (resized || new_mask) {
  227.       ret = xmesa_st_framebuffer_validate_textures(stfbi,
  228.                   xstfb->buffer->width, xstfb->buffer->height, statt_mask);
  229.       if (!ret)
  230.          return ret;
  231.  
  232.       if (!resized) {
  233.          enum st_attachment_type back, front;
  234.  
  235.          back = ST_ATTACHMENT_BACK_LEFT;
  236.          front = ST_ATTACHMENT_FRONT_LEFT;
  237.          /* copy the contents if front is newly allocated and back is not */
  238.          if ((statt_mask & (1 << back)) &&
  239.              (new_mask & (1 << front)) &&
  240.              !(new_mask & (1 << back))) {
  241.             xmesa_st_framebuffer_copy_textures(stfbi, back, front,
  242.                   0, 0, xstfb->texture_width, xstfb->texture_height);
  243.          }
  244.       }
  245.    }
  246.  
  247.    for (i = 0; i < count; i++) {
  248.       out[i] = NULL;
  249.       pipe_resource_reference(&out[i], xstfb->textures[statts[i]]);
  250.    }
  251.  
  252.    return TRUE;
  253. }
  254.  
  255.  
  256. /**
  257.  * Called via st_framebuffer_iface::flush_front()
  258.  */
  259. static boolean
  260. xmesa_st_framebuffer_flush_front(struct st_context_iface *stctx,
  261.                                  struct st_framebuffer_iface *stfbi,
  262.                                  enum st_attachment_type statt)
  263. {
  264.    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  265.    boolean ret;
  266.  
  267.    ret = xmesa_st_framebuffer_display(stfbi, statt);
  268.  
  269.    if (ret && xmesa_strict_invalidate)
  270.       xmesa_check_buffer_size(xstfb->buffer);
  271.  
  272.    return ret;
  273. }
  274.  
  275.  
  276. struct st_framebuffer_iface *
  277. xmesa_create_st_framebuffer(XMesaDisplay xmdpy, XMesaBuffer b)
  278. {
  279.    struct st_framebuffer_iface *stfbi;
  280.    struct xmesa_st_framebuffer *xstfb;
  281.  
  282.    assert(xmdpy->display == b->xm_visual->display);
  283.  
  284.    stfbi = CALLOC_STRUCT(st_framebuffer_iface);
  285.    xstfb = CALLOC_STRUCT(xmesa_st_framebuffer);
  286.    if (!stfbi || !xstfb) {
  287.       free(stfbi);
  288.       free(xstfb);
  289.       return NULL;
  290.    }
  291.  
  292.    xstfb->display = xmdpy;
  293.    xstfb->buffer = b;
  294.    xstfb->screen = xmdpy->screen;
  295.    xstfb->stvis = b->xm_visual->stvis;
  296.    if (xstfb->screen->get_param(xstfb->screen, PIPE_CAP_NPOT_TEXTURES))
  297.       xstfb->target = PIPE_TEXTURE_2D;
  298.    else
  299.       xstfb->target = PIPE_TEXTURE_RECT;
  300.  
  301.    stfbi->visual = &xstfb->stvis;
  302.    stfbi->flush_front = xmesa_st_framebuffer_flush_front;
  303.    stfbi->validate = xmesa_st_framebuffer_validate;
  304.    p_atomic_set(&stfbi->stamp, 1);
  305.    stfbi->st_manager_private = (void *) xstfb;
  306.  
  307.    return stfbi;
  308. }
  309.  
  310.  
  311. void
  312. xmesa_destroy_st_framebuffer(struct st_framebuffer_iface *stfbi)
  313. {
  314.    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  315.    int i;
  316.  
  317.    pipe_resource_reference(&xstfb->display_resource, NULL);
  318.  
  319.    for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
  320.       pipe_resource_reference(&xstfb->textures[i], NULL);
  321.  
  322.    free(xstfb);
  323.    free(stfbi);
  324. }
  325.  
  326.  
  327. /**
  328.  * Return the pipe_surface which corresponds to the given
  329.  * framebuffer attachment.
  330.  */
  331. struct pipe_resource *
  332. xmesa_get_framebuffer_resource(struct st_framebuffer_iface *stfbi,
  333.                                enum st_attachment_type att)
  334. {
  335.    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  336.    return xstfb->textures[att];
  337. }
  338.  
  339.  
  340. void
  341. xmesa_swap_st_framebuffer(struct st_framebuffer_iface *stfbi)
  342. {
  343.    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  344.    boolean ret;
  345.  
  346.    ret = xmesa_st_framebuffer_display(stfbi, ST_ATTACHMENT_BACK_LEFT);
  347.    if (ret) {
  348.       struct pipe_resource **front, **back, *tmp;
  349.  
  350.       front = &xstfb->textures[ST_ATTACHMENT_FRONT_LEFT];
  351.       back = &xstfb->textures[ST_ATTACHMENT_BACK_LEFT];
  352.       /* swap textures only if the front texture has been allocated */
  353.       if (*front) {
  354.          tmp = *front;
  355.          *front = *back;
  356.          *back = tmp;
  357.  
  358.          /* the current context should validate the buffer after swapping */
  359.          if (!xmesa_strict_invalidate)
  360.             xmesa_notify_invalid_buffer(xstfb->buffer);
  361.       }
  362.  
  363.       if (xmesa_strict_invalidate)
  364.          xmesa_check_buffer_size(xstfb->buffer);
  365.    }
  366. }
  367.  
  368.  
  369. void
  370. xmesa_copy_st_framebuffer(struct st_framebuffer_iface *stfbi,
  371.                           enum st_attachment_type src,
  372.                           enum st_attachment_type dst,
  373.                           int x, int y, int w, int h)
  374. {
  375.    xmesa_st_framebuffer_copy_textures(stfbi, src, dst, x, y, w, h);
  376.    if (dst == ST_ATTACHMENT_FRONT_LEFT)
  377.       xmesa_st_framebuffer_display(stfbi, dst);
  378. }
  379.  
  380.  
  381. struct pipe_resource*
  382. xmesa_get_attachment(struct st_framebuffer_iface *stfbi,
  383.                      enum st_attachment_type st_attachment)
  384. {
  385.    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  386.    struct pipe_resource *res;
  387.  
  388.    res = xstfb->textures[st_attachment];
  389.    return res;
  390. }
  391.  
  392.  
  393. struct pipe_context*
  394. xmesa_get_context(struct st_framebuffer_iface *stfbi)
  395. {
  396.    struct pipe_context *pipe;
  397.    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  398.  
  399.    pipe = xstfb->display->pipe;
  400.    if (!pipe) {
  401.       pipe = xstfb->screen->context_create(xstfb->screen, NULL);
  402.       if (!pipe)
  403.          return NULL;
  404.       xstfb->display->pipe = pipe;
  405.    }
  406.    return pipe;
  407. }
  408.