Home | History | Annotate | Download | only in state_tracker 
      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 Olk
     34  */
     35 
     36 
     37 #include "main/bufferobj.h"
     38 #include "main/context.h"
     39 #include "main/mfeatures.h"
     40 #include "main/transformfeedback.h"
     41 
     42 #include "st_cb_bufferobjects.h"
     43 #include "st_cb_xformfb.h"
     44 #include "st_context.h"
     45 
     46 #include "pipe/p_context.h"
     47 #include "util/u_draw.h"
     48 #include "util/u_inlines.h"
     49 #include "cso_cache/cso_context.h"
     50 
     51 #if FEATURE_EXT_transform_feedback
     52 
     53 struct st_transform_feedback_object {
     54    struct gl_transform_feedback_object base;
     55 
     56    unsigned num_targets;
     57    struct pipe_stream_output_target *targets[PIPE_MAX_SO_BUFFERS];
     58 
     59    /* This encapsulates the count that can be used as a source for draw_vbo.
     60     * It contains a stream output target from the last call of
     61     * EndTransformFeedback. */
     62    struct pipe_stream_output_target *draw_count;
     63 };
     64 
     65 static INLINE struct st_transform_feedback_object *
     66 st_transform_feedback_object(struct gl_transform_feedback_object *obj)
     67 {
     68    return (struct st_transform_feedback_object *) obj;
     69 }
     70 
     71 static struct gl_transform_feedback_object *
     72 st_new_transform_feedback(struct gl_context *ctx, GLuint name)
     73 {
     74    struct st_transform_feedback_object *obj;
     75 
     76    obj = CALLOC_STRUCT(st_transform_feedback_object);
     77    if (!obj)
     78       return NULL;
     79 
     80    obj->base.Name = name;
     81    obj->base.RefCount = 1;
     82    return &obj->base;
     83 }
     84 
     85 
     86 static void
     87 st_delete_transform_feedback(struct gl_context *ctx,
     88                              struct gl_transform_feedback_object *obj)
     89 {
     90    struct st_transform_feedback_object *sobj =
     91          st_transform_feedback_object(obj);
     92    unsigned i;
     93 
     94    pipe_so_target_reference(&sobj->draw_count, NULL);
     95 
     96    /* Unreference targets. */
     97    for (i = 0; i < sobj->num_targets; i++) {
     98       pipe_so_target_reference(&sobj->targets[i], NULL);
     99    }
    100 
    101    for (i = 0; i < Elements(sobj->base.Buffers); i++) {
    102       _mesa_reference_buffer_object(ctx, &sobj->base.Buffers[i], NULL);
    103    }
    104 
    105    free(obj);
    106 }
    107 
    108 
    109 /* XXX Do we really need the mode? */
    110 static void
    111 st_begin_transform_feedback(struct gl_context *ctx, GLenum mode,
    112                             struct gl_transform_feedback_object *obj)
    113 {
    114    struct st_context *st = st_context(ctx);
    115    struct pipe_context *pipe = st->pipe;
    116    struct st_transform_feedback_object *sobj =
    117          st_transform_feedback_object(obj);
    118    unsigned i, max_num_targets;
    119 
    120    max_num_targets = MIN2(Elements(sobj->base.Buffers),
    121                           Elements(sobj->targets));
    122 
    123    /* Convert the transform feedback state into the gallium representation. */
    124    for (i = 0; i < max_num_targets; i++) {
    125       struct st_buffer_object *bo = st_buffer_object(sobj->base.Buffers[i]);
    126 
    127       if (bo) {
    128          /* Check whether we need to recreate the target. */
    129          if (!sobj->targets[i] ||
    130              sobj->targets[i] == sobj->draw_count ||
    131              sobj->targets[i]->buffer != bo->buffer ||
    132              sobj->targets[i]->buffer_offset != sobj->base.Offset[i] ||
    133              sobj->targets[i]->buffer_size != sobj->base.Size[i]) {
    134             /* Create a new target. */
    135             struct pipe_stream_output_target *so_target =
    136                   pipe->create_stream_output_target(pipe, bo->buffer,
    137                                                     sobj->base.Offset[i],
    138                                                     sobj->base.Size[i]);
    139 
    140             pipe_so_target_reference(&sobj->targets[i], NULL);
    141             sobj->targets[i] = so_target;
    142          }
    143 
    144          sobj->num_targets = i+1;
    145       } else {
    146          pipe_so_target_reference(&sobj->targets[i], NULL);
    147       }
    148    }
    149 
    150    /* Start writing at the beginning of each target. */
    151    cso_set_stream_outputs(st->cso_context, sobj->num_targets, sobj->targets,
    152                           0);
    153 }
    154 
    155 
    156 static void
    157 st_pause_transform_feedback(struct gl_context *ctx,
    158                            struct gl_transform_feedback_object *obj)
    159 {
    160    struct st_context *st = st_context(ctx);
    161    cso_set_stream_outputs(st->cso_context, 0, NULL, 0);
    162 }
    163 
    164 
    165 static void
    166 st_resume_transform_feedback(struct gl_context *ctx,
    167                              struct gl_transform_feedback_object *obj)
    168 {
    169    struct st_context *st = st_context(ctx);
    170    struct st_transform_feedback_object *sobj =
    171          st_transform_feedback_object(obj);
    172 
    173    cso_set_stream_outputs(st->cso_context, sobj->num_targets, sobj->targets,
    174                           ~0);
    175 }
    176 
    177 
    178 static struct pipe_stream_output_target *
    179 st_transform_feedback_get_draw_target(struct gl_transform_feedback_object *obj)
    180 {
    181    struct st_transform_feedback_object *sobj =
    182          st_transform_feedback_object(obj);
    183    unsigned i;
    184 
    185    for (i = 0; i < Elements(sobj->targets); i++) {
    186       if (sobj->targets[i]) {
    187          return sobj->targets[i];
    188       }
    189    }
    190 
    191    assert(0);
    192    return NULL;
    193 }
    194 
    195 
    196 static void
    197 st_end_transform_feedback(struct gl_context *ctx,
    198                           struct gl_transform_feedback_object *obj)
    199 {
    200    struct st_context *st = st_context(ctx);
    201    struct st_transform_feedback_object *sobj =
    202          st_transform_feedback_object(obj);
    203 
    204    cso_set_stream_outputs(st->cso_context, 0, NULL, 0);
    205 
    206    pipe_so_target_reference(&sobj->draw_count,
    207                             st_transform_feedback_get_draw_target(obj));
    208 }
    209 
    210 
    211 void
    212 st_transform_feedback_draw_init(struct gl_transform_feedback_object *obj,
    213                                 struct pipe_draw_info *out)
    214 {
    215    struct st_transform_feedback_object *sobj =
    216          st_transform_feedback_object(obj);
    217 
    218    out->count_from_stream_output = sobj->draw_count;
    219 }
    220 
    221 
    222 void
    223 st_init_xformfb_functions(struct dd_function_table *functions)
    224 {
    225    functions->NewTransformFeedback = st_new_transform_feedback;
    226    functions->DeleteTransformFeedback = st_delete_transform_feedback;
    227    functions->BeginTransformFeedback = st_begin_transform_feedback;
    228    functions->EndTransformFeedback = st_end_transform_feedback;
    229    functions->PauseTransformFeedback = st_pause_transform_feedback;
    230    functions->ResumeTransformFeedback = st_resume_transform_feedback;
    231 }
    232 
    233 #endif /* FEATURE_EXT_transform_feedback */
    234