Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2010 VMware, Inc.
  4.  * All Rights Reserved.
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a
  7.  * copy of this software and associated documentation files (the
  8.  * "Software"), to deal in the Software without restriction, including
  9.  * without limitation the rights to use, copy, modify, merge, publish,
  10.  * distribute, sub license, and/or sell copies of the Software, and to
  11.  * permit persons to whom the Software is furnished to do so, subject to
  12.  * the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice (including the
  15.  * next paragraph) shall be included in all copies or substantial portions
  16.  * of the Software.
  17.  *
  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21.  * IN NO EVENT SHALL THE AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22.  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23.  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24.  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  *
  26.  **************************************************************************/
  27.  
  28.  
  29. /**
  30.  * Transform feedback functions.
  31.  *
  32.  * \author Brian Paul
  33.  *         Marek Olšák
  34.  */
  35.  
  36.  
  37. #include "main/bufferobj.h"
  38. #include "main/context.h"
  39. #include "main/transformfeedback.h"
  40.  
  41. #include "st_cb_bufferobjects.h"
  42. #include "st_cb_xformfb.h"
  43. #include "st_context.h"
  44.  
  45. #include "pipe/p_context.h"
  46. #include "util/u_draw.h"
  47. #include "util/u_inlines.h"
  48. #include "cso_cache/cso_context.h"
  49.  
  50. struct st_transform_feedback_object {
  51.    struct gl_transform_feedback_object base;
  52.  
  53.    unsigned num_targets;
  54.    struct pipe_stream_output_target *targets[PIPE_MAX_SO_BUFFERS];
  55.  
  56.    /* This encapsulates the count that can be used as a source for draw_vbo.
  57.     * It contains a stream output target from the last call of
  58.     * EndTransformFeedback. */
  59.    struct pipe_stream_output_target *draw_count;
  60. };
  61.  
  62. static inline struct st_transform_feedback_object *
  63. st_transform_feedback_object(struct gl_transform_feedback_object *obj)
  64. {
  65.    return (struct st_transform_feedback_object *) obj;
  66. }
  67.  
  68. static struct gl_transform_feedback_object *
  69. st_new_transform_feedback(struct gl_context *ctx, GLuint name)
  70. {
  71.    struct st_transform_feedback_object *obj;
  72.  
  73.    obj = CALLOC_STRUCT(st_transform_feedback_object);
  74.    if (!obj)
  75.       return NULL;
  76.  
  77.    _mesa_init_transform_feedback_object(&obj->base, name);
  78.  
  79.    return &obj->base;
  80. }
  81.  
  82.  
  83. static void
  84. st_delete_transform_feedback(struct gl_context *ctx,
  85.                              struct gl_transform_feedback_object *obj)
  86. {
  87.    struct st_transform_feedback_object *sobj =
  88.          st_transform_feedback_object(obj);
  89.    unsigned i;
  90.  
  91.    pipe_so_target_reference(&sobj->draw_count, NULL);
  92.  
  93.    /* Unreference targets. */
  94.    for (i = 0; i < sobj->num_targets; i++) {
  95.       pipe_so_target_reference(&sobj->targets[i], NULL);
  96.    }
  97.  
  98.    for (i = 0; i < ARRAY_SIZE(sobj->base.Buffers); i++) {
  99.       _mesa_reference_buffer_object(ctx, &sobj->base.Buffers[i], NULL);
  100.    }
  101.  
  102.    free(obj);
  103. }
  104.  
  105.  
  106. /* XXX Do we really need the mode? */
  107. static void
  108. st_begin_transform_feedback(struct gl_context *ctx, GLenum mode,
  109.                             struct gl_transform_feedback_object *obj)
  110. {
  111.    struct st_context *st = st_context(ctx);
  112.    struct pipe_context *pipe = st->pipe;
  113.    struct st_transform_feedback_object *sobj =
  114.          st_transform_feedback_object(obj);
  115.    unsigned i, max_num_targets;
  116.    unsigned offsets[PIPE_MAX_SO_BUFFERS] = {0};
  117.  
  118.    max_num_targets = MIN2(ARRAY_SIZE(sobj->base.Buffers),
  119.                           ARRAY_SIZE(sobj->targets));
  120.  
  121.    /* Convert the transform feedback state into the gallium representation. */
  122.    for (i = 0; i < max_num_targets; i++) {
  123.       struct st_buffer_object *bo = st_buffer_object(sobj->base.Buffers[i]);
  124.  
  125.       if (bo && bo->buffer) {
  126.          /* Check whether we need to recreate the target. */
  127.          if (!sobj->targets[i] ||
  128.              sobj->targets[i] == sobj->draw_count ||
  129.              sobj->targets[i]->buffer != bo->buffer ||
  130.              sobj->targets[i]->buffer_offset != sobj->base.Offset[i] ||
  131.              sobj->targets[i]->buffer_size != sobj->base.Size[i]) {
  132.             /* Create a new target. */
  133.             struct pipe_stream_output_target *so_target =
  134.                   pipe->create_stream_output_target(pipe, bo->buffer,
  135.                                                     sobj->base.Offset[i],
  136.                                                     sobj->base.Size[i]);
  137.  
  138.             pipe_so_target_reference(&sobj->targets[i], NULL);
  139.             sobj->targets[i] = so_target;
  140.          }
  141.  
  142.          sobj->num_targets = i+1;
  143.       } else {
  144.          pipe_so_target_reference(&sobj->targets[i], NULL);
  145.       }
  146.    }
  147.  
  148.    /* Start writing at the beginning of each target. */
  149.    cso_set_stream_outputs(st->cso_context, sobj->num_targets,
  150.                           sobj->targets, offsets);
  151. }
  152.  
  153.  
  154. static void
  155. st_pause_transform_feedback(struct gl_context *ctx,
  156.                            struct gl_transform_feedback_object *obj)
  157. {
  158.    struct st_context *st = st_context(ctx);
  159.    cso_set_stream_outputs(st->cso_context, 0, NULL, NULL);
  160. }
  161.  
  162.  
  163. static void
  164. st_resume_transform_feedback(struct gl_context *ctx,
  165.                              struct gl_transform_feedback_object *obj)
  166. {
  167.    struct st_context *st = st_context(ctx);
  168.    struct st_transform_feedback_object *sobj =
  169.       st_transform_feedback_object(obj);
  170.    unsigned offsets[PIPE_MAX_SO_BUFFERS];
  171.    unsigned i;
  172.  
  173.    for (i = 0; i < PIPE_MAX_SO_BUFFERS; i++)
  174.       offsets[i] = (unsigned)-1;
  175.  
  176.    cso_set_stream_outputs(st->cso_context, sobj->num_targets,
  177.                           sobj->targets, offsets);
  178. }
  179.  
  180.  
  181. static struct pipe_stream_output_target *
  182. st_transform_feedback_get_draw_target(struct gl_transform_feedback_object *obj)
  183. {
  184.    struct st_transform_feedback_object *sobj =
  185.          st_transform_feedback_object(obj);
  186.    unsigned i;
  187.  
  188.    for (i = 0; i < ARRAY_SIZE(sobj->targets); i++) {
  189.       if (sobj->targets[i]) {
  190.          return sobj->targets[i];
  191.       }
  192.    }
  193.  
  194.    assert(0);
  195.    return NULL;
  196. }
  197.  
  198.  
  199. static void
  200. st_end_transform_feedback(struct gl_context *ctx,
  201.                           struct gl_transform_feedback_object *obj)
  202. {
  203.    struct st_context *st = st_context(ctx);
  204.    struct st_transform_feedback_object *sobj =
  205.          st_transform_feedback_object(obj);
  206.  
  207.    cso_set_stream_outputs(st->cso_context, 0, NULL, NULL);
  208.  
  209.    pipe_so_target_reference(&sobj->draw_count,
  210.                             st_transform_feedback_get_draw_target(obj));
  211. }
  212.  
  213.  
  214. void
  215. st_transform_feedback_draw_init(struct gl_transform_feedback_object *obj,
  216.                                 struct pipe_draw_info *out)
  217. {
  218.    struct st_transform_feedback_object *sobj =
  219.          st_transform_feedback_object(obj);
  220.  
  221.    out->count_from_stream_output = sobj->draw_count;
  222. }
  223.  
  224.  
  225. void
  226. st_init_xformfb_functions(struct dd_function_table *functions)
  227. {
  228.    functions->NewTransformFeedback = st_new_transform_feedback;
  229.    functions->DeleteTransformFeedback = st_delete_transform_feedback;
  230.    functions->BeginTransformFeedback = st_begin_transform_feedback;
  231.    functions->EndTransformFeedback = st_end_transform_feedback;
  232.    functions->PauseTransformFeedback = st_pause_transform_feedback;
  233.    functions->ResumeTransformFeedback = st_resume_transform_feedback;
  234. }
  235.