src/gallium/drivers/r300/r300_render_translate.c

   1 /*
   2  * Copyright 2010 Marek Olšák <maraeo@gmail.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  22
  23 /**
  24  * The functions below translate vertex and index buffers to the layout
  25  * compatible with the hardware, so that all vertex and index fetches are
  26  * DWORD-aligned and all used vertex and index formats are supported.
  27  * For indices, an optional index offset is added to each index.
  28  */
  29
  30 #include "r300_context.h"
  31 #include "translate/translate.h"
  32
  33 void r300_begin_vertex_translate(struct r300_context *r300)
  34 {
  35     struct pipe_context *pipe = &r300->context;
  36     struct translate_key key = {0};
  37     struct translate_element *te;
  38     unsigned tr_elem_index[PIPE_MAX_ATTRIBS] = {0};
  39     struct translate *tr;
  40     struct r300_vertex_element_state *ve = r300->velems;
  41     boolean vb_translated[PIPE_MAX_ATTRIBS] = {0};
  42     void *vb_map[PIPE_MAX_ATTRIBS] = {0}, *out_map;
  43     struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS] = {0}, *out_transfer;
  44     struct pipe_resource *out_buffer;
  45     unsigned i, num_verts;
  46
  47     /* Initialize the translate key, i.e. the recipe how vertices should be
  48      * translated. */
  49     for (i = 0; i < ve->count; i++) {
  50         struct pipe_vertex_buffer *vb =
  51                 &r300->vertex_buffer[ve->velem[i].vertex_buffer_index];
  52
  53         /* Check for support. */
  54         if (ve->velem[i].src_format == ve->hw_format[i] &&
  55             (vb->buffer_offset + ve->velem[i].src_offset) % 4 == 0 &&
  56             vb->stride % 4 == 0) {
  57             continue;
  58         }
  59
  60         /* Add this vertex element. */
  61         te = &key.element[key.nr_elements];
  62         /*te->type;
  63         te->instance_divisor;*/
  64         te->input_buffer = ve->velem[i].vertex_buffer_index;
  65         te->input_format = ve->velem[i].src_format;
  66         te->input_offset = vb->buffer_offset + ve->velem[i].src_offset;
  67         te->output_format = ve->hw_format[i];
  68         te->output_offset = key.output_stride;
  69
  70         key.output_stride += ve->hw_format_size[i];
  71         vb_translated[ve->velem[i].vertex_buffer_index] = TRUE;
  72         tr_elem_index[i] = key.nr_elements;
  73         key.nr_elements++;
  74     }
  75
  76     /* Get a translate object. */
  77     tr = translate_cache_find(r300->tran.translate_cache, &key);
  78
  79     /* Map buffers we want to translate. */
  80     for (i = 0; i < r300->vertex_buffer_count; i++) {
  81         if (vb_translated[i]) {
  82             struct pipe_vertex_buffer *vb = &r300->vertex_buffer[i];
  83
  84             vb_map[i] = pipe_buffer_map(pipe, vb->buffer,
  85                                         PIPE_TRANSFER_READ, &vb_transfer[i]);
  86
  87             tr->set_buffer(tr, i, vb_map[i], vb->stride, vb->max_index);
  88         }
  89     }
  90
  91     /* Create and map the output buffer. */
  92     num_verts = r300->vertex_buffer_max_index + 1;
  93
  94     out_buffer = pipe_buffer_create(&r300->screen->screen,
  95                                     PIPE_BIND_VERTEX_BUFFER,
  96                                     key.output_stride * num_verts);
  97
  98     out_map = pipe_buffer_map(pipe, out_buffer, PIPE_TRANSFER_WRITE,
  99                               &out_transfer);
 100
 101     /* Translate. */
 102     tr->run(tr, 0, num_verts, 0, out_map);
 103
 104     /* Unmap all buffers. */
 105     for (i = 0; i < r300->vertex_buffer_count; i++) {
 106         if (vb_translated[i]) {
 107             pipe_buffer_unmap(pipe, r300->vertex_buffer[i].buffer,
 108                               vb_transfer[i]);
 109         }
 110     }
 111
 112     pipe_buffer_unmap(pipe, out_buffer, out_transfer);
 113
 114     /* Setup the new vertex buffer in the first free slot. */
 115     for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
 116         struct pipe_vertex_buffer *vb = &r300->vertex_buffer[i];
 117
 118         if (!vb->buffer) {
 119             pipe_resource_reference(&vb->buffer, out_buffer);
 120             vb->buffer_offset = 0;
 121             vb->max_index = num_verts - 1;
 122             vb->stride = key.output_stride;
 123             r300->tran.vb_slot = i;
 124             break;
 125         }
 126     }
 127
 128     /* Save and replace vertex elements. */
 129     {
 130         struct pipe_vertex_element new_velems[PIPE_MAX_ATTRIBS];
 131
 132         r300->tran.saved_velems = r300->velems;
 133
 134         for (i = 0; i < ve->count; i++) {
 135             if (vb_translated[ve->velem[i].vertex_buffer_index]) {
 136                 te = &key.element[tr_elem_index[i]];
 137                 new_velems[i].instance_divisor = ve->velem[i].instance_divisor;
 138                 new_velems[i].src_format = te->output_format;
 139                 new_velems[i].src_offset = te->output_offset;
 140                 new_velems[i].vertex_buffer_index = r300->tran.vb_slot;
 141             } else {
 142                 memcpy(&new_velems[i], &ve->velem[i],
 143                        sizeof(struct pipe_vertex_element));
 144             }
 145         }
 146
 147         r300->tran.new_velems =
 148             pipe->create_vertex_elements_state(pipe, ve->count, new_velems);
 149         pipe->bind_vertex_elements_state(pipe, r300->tran.new_velems);
 150     }
 151
 152     pipe_resource_reference(&out_buffer, NULL);
 153 }
 154
 155 void r300_end_vertex_translate(struct r300_context *r300)
 156 {
 157     struct pipe_context *pipe = &r300->context;
 158
 159     /* Restore vertex elements. */
 160     pipe->bind_vertex_elements_state(pipe, r300->tran.saved_velems);
 161     pipe->delete_vertex_elements_state(pipe, r300->tran.new_velems);
 162
 163     /* Delete the now-unused VBO. */
 164     pipe_resource_reference(&r300->vertex_buffer[r300->tran.vb_slot].buffer,
 165                             NULL);
 166 }
 167
 168 static void r300_shorten_ubyte_elts(struct r300_context* r300,
 169                                     struct pipe_resource** elts,
 170                                     int index_bias,
 171                                     unsigned start,
 172                                     unsigned count)
 173 {
 174     struct pipe_context* context = &r300->context;
 175     struct pipe_screen* screen = r300->context.screen;
 176     struct pipe_resource* new_elts;
 177     unsigned char *in_map;
 178     unsigned short *out_map;
 179     struct pipe_transfer *src_transfer, *dst_transfer;
 180     unsigned i;
 181
 182     new_elts = pipe_buffer_create(screen,
 183                                   PIPE_BIND_INDEX_BUFFER,
 184                                   2 * count);
 185
 186     in_map = pipe_buffer_map(context, *elts, PIPE_TRANSFER_READ, &src_transfer);
 187     out_map = pipe_buffer_map(context, new_elts, PIPE_TRANSFER_WRITE, &dst_transfer);
 188
 189     in_map += start;
 190
 191     for (i = 0; i < count; i++) {
 192         *out_map = (unsigned short)(*in_map + index_bias);
 193         in_map++;
 194         out_map++;
 195     }
 196
 197     pipe_buffer_unmap(context, *elts, src_transfer);
 198     pipe_buffer_unmap(context, new_elts, dst_transfer);
 199
 200     *elts = new_elts;
 201 }
 202
 203 static void r300_rebuild_ushort_elts(struct r300_context *r300,
 204                                      struct pipe_resource **elts,
 205                                      int index_bias,
 206                                      unsigned start, unsigned count)
 207 {
 208     struct pipe_context *context = &r300->context;
 209     struct pipe_transfer *in_transfer = NULL;
 210     struct pipe_transfer *out_transfer = NULL;
 211     struct pipe_resource *new_elts;
 212     unsigned short *in_map;
 213     unsigned short *out_map;
 214     unsigned i;
 215
 216     new_elts = pipe_buffer_create(context->screen,
 217                                   PIPE_BIND_INDEX_BUFFER,
 218                                   2 * count);
 219
 220     in_map = pipe_buffer_map(context, *elts,
 221                              PIPE_TRANSFER_READ, &in_transfer);
 222     out_map = pipe_buffer_map(context, new_elts,
 223                               PIPE_TRANSFER_WRITE, &out_transfer);
 224
 225     in_map += start;
 226     for (i = 0; i < count; i++) {
 227         *out_map = (unsigned short)(*in_map + index_bias);
 228         in_map++;
 229         out_map++;
 230     }
 231
 232     pipe_buffer_unmap(context, *elts, in_transfer);
 233     pipe_buffer_unmap(context, new_elts, out_transfer);
 234
 235     *elts = new_elts;
 236 }
 237
 238 static void r300_rebuild_uint_elts(struct r300_context *r300,
 239                                    struct pipe_resource **elts,
 240                                    int index_bias,
 241                                    unsigned start, unsigned count)
 242 {
 243     struct pipe_context *context = &r300->context;
 244     struct pipe_transfer *in_transfer = NULL;
 245     struct pipe_transfer *out_transfer = NULL;
 246     struct pipe_resource *new_elts;
 247     unsigned int *in_map;
 248     unsigned int *out_map;
 249     unsigned i;
 250
 251     new_elts = pipe_buffer_create(context->screen,
 252                                   PIPE_BIND_INDEX_BUFFER,
 253                                   2 * count);
 254
 255     in_map = pipe_buffer_map(context, *elts,
 256                              PIPE_TRANSFER_READ, &in_transfer);
 257     out_map = pipe_buffer_map(context, new_elts,
 258                               PIPE_TRANSFER_WRITE, &out_transfer);
 259
 260     in_map += start;
 261     for (i = 0; i < count; i++) {
 262         *out_map = (unsigned int)(*in_map + index_bias);
 263         in_map++;
 264         out_map++;
 265     }
 266
 267     pipe_buffer_unmap(context, *elts, in_transfer);
 268     pipe_buffer_unmap(context, new_elts, out_transfer);
 269
 270     *elts = new_elts;
 271 }
 272
 273 void r300_translate_index_buffer(struct r300_context *r300,
 274                                  struct pipe_resource **index_buffer,
 275                                  unsigned *index_size, unsigned index_offset,
 276                                  unsigned *start, unsigned count)
 277 {
 278     switch (*index_size) {
 279         case 1:
 280             r300_shorten_ubyte_elts(r300, index_buffer, index_offset, *start, count);
 281             *index_size = 2;
 282             *start = 0;
 283             break;
 284
 285         case 2:
 286             if (*start % 2 != 0 || index_offset) {
 287                 r300_rebuild_ushort_elts(r300, index_buffer, index_offset, *start, count);
 288                 *start = 0;
 289             }
 290             break;
 291
 292         case 4:
 293             if (index_offset) {
 294                 r300_rebuild_uint_elts(r300, index_buffer, index_offset, *start, count);
 295                 *start = 0;
 296             }
 297             break;
 298     }
 299 }