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 #include "util/u_index_modify.h"
  33
  34 void r300_begin_vertex_translate(struct r300_context *r300)
  35 {
  36     struct pipe_context *pipe = &r300->context;
  37     struct translate_key key = {0};
  38     struct translate_element *te;
  39     unsigned tr_elem_index[PIPE_MAX_ATTRIBS] = {0};
  40     struct translate *tr;
  41     struct r300_vertex_element_state *ve = r300->velems;
  42     boolean vb_translated[PIPE_MAX_ATTRIBS] = {0};
  43     void *vb_map[PIPE_MAX_ATTRIBS] = {0}, *out_map;
  44     struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS] = {0}, *out_transfer;
  45     struct pipe_resource *out_buffer;
  46     unsigned i, num_verts;
  47
  48     /* Initialize the translate key, i.e. the recipe how vertices should be
  49      * translated. */
  50     for (i = 0; i < ve->count; i++) {
  51         struct pipe_vertex_buffer *vb =
  52                 &r300->vertex_buffer[ve->velem[i].vertex_buffer_index];
  53         enum pipe_format output_format = ve->hw_format[i];
  54         unsigned output_format_size = ve->hw_format_size[i];
  55
  56         /* Check for support. */
  57         if (ve->velem[i].src_format == ve->hw_format[i] &&
  58             (vb->buffer_offset + ve->velem[i].src_offset) % 4 == 0 &&
  59             vb->stride % 4 == 0) {
  60             continue;
  61         }
  62
  63         /* Workaround for translate: output floats instead of halfs. */
  64         switch (output_format) {
  65             case PIPE_FORMAT_R16_FLOAT:
  66                 output_format = PIPE_FORMAT_R32_FLOAT;
  67                 output_format_size = 4;
  68                 break;
  69             case PIPE_FORMAT_R16G16_FLOAT:
  70                 output_format = PIPE_FORMAT_R32G32_FLOAT;
  71                 output_format_size = 8;
  72                 break;
  73             case PIPE_FORMAT_R16G16B16_FLOAT:
  74                 output_format = PIPE_FORMAT_R32G32B32_FLOAT;
  75                 output_format_size = 12;
  76                 break;
  77             case PIPE_FORMAT_R16G16B16A16_FLOAT:
  78                 output_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
  79                 output_format_size = 16;
  80                 break;
  81             default:;
  82         }
  83
  84         /* Add this vertex element. */
  85         te = &key.element[key.nr_elements];
  86         /*te->type;
  87         te->instance_divisor;*/
  88         te->input_buffer = ve->velem[i].vertex_buffer_index;
  89         te->input_format = ve->velem[i].src_format;
  90         te->input_offset = vb->buffer_offset + ve->velem[i].src_offset;
  91         te->output_format = output_format;
  92         te->output_offset = key.output_stride;
  93
  94         key.output_stride += output_format_size;
  95         vb_translated[ve->velem[i].vertex_buffer_index] = TRUE;
  96         tr_elem_index[i] = key.nr_elements;
  97         key.nr_elements++;
  98     }
  99
 100     /* Get a translate object. */
 101     tr = translate_cache_find(r300->tran.translate_cache, &key);
 102
 103     /* Map buffers we want to translate. */
 104     for (i = 0; i < r300->vertex_buffer_count; i++) {
 105         if (vb_translated[i]) {
 106             struct pipe_vertex_buffer *vb = &r300->vertex_buffer[i];
 107
 108             vb_map[i] = pipe_buffer_map(pipe, vb->buffer,
 109                                         PIPE_TRANSFER_READ, &vb_transfer[i]);
 110
 111             tr->set_buffer(tr, i, vb_map[i], vb->stride, vb->max_index);
 112         }
 113     }
 114
 115     /* Create and map the output buffer. */
 116     num_verts = r300->vertex_buffer_max_index + 1;
 117
 118     out_buffer = pipe_buffer_create(&r300->screen->screen,
 119                                     PIPE_BIND_VERTEX_BUFFER,
 120                                     key.output_stride * num_verts);
 121
 122     out_map = pipe_buffer_map(pipe, out_buffer, PIPE_TRANSFER_WRITE,
 123                               &out_transfer);
 124
 125     /* Translate. */
 126     tr->run(tr, 0, num_verts, 0, out_map);
 127
 128     /* Unmap all buffers. */
 129     for (i = 0; i < r300->vertex_buffer_count; i++) {
 130         if (vb_translated[i]) {
 131             pipe_buffer_unmap(pipe, r300->vertex_buffer[i].buffer,
 132                               vb_transfer[i]);
 133         }
 134     }
 135
 136     pipe_buffer_unmap(pipe, out_buffer, out_transfer);
 137
 138     /* Setup the new vertex buffer in the first free slot. */
 139     for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
 140         struct pipe_vertex_buffer *vb = &r300->vertex_buffer[i];
 141
 142         if (!vb->buffer) {
 143             pipe_resource_reference(&vb->buffer, out_buffer);
 144             vb->buffer_offset = 0;
 145             vb->max_index = num_verts - 1;
 146             vb->stride = key.output_stride;
 147             r300->tran.vb_slot = i;
 148             r300->validate_buffers = TRUE;
 149             break;
 150         }
 151     }
 152
 153     /* Save and replace vertex elements. */
 154     {
 155         struct pipe_vertex_element new_velems[PIPE_MAX_ATTRIBS];
 156
 157         r300->tran.saved_velems = r300->velems;
 158
 159         for (i = 0; i < ve->count; i++) {
 160             if (vb_translated[ve->velem[i].vertex_buffer_index]) {
 161                 te = &key.element[tr_elem_index[i]];
 162                 new_velems[i].instance_divisor = ve->velem[i].instance_divisor;
 163                 new_velems[i].src_format = te->output_format;
 164                 new_velems[i].src_offset = te->output_offset;
 165                 new_velems[i].vertex_buffer_index = r300->tran.vb_slot;
 166             } else {
 167                 memcpy(&new_velems[i], &ve->velem[i],
 168                        sizeof(struct pipe_vertex_element));
 169             }
 170         }
 171
 172         r300->tran.new_velems =
 173             pipe->create_vertex_elements_state(pipe, ve->count, new_velems);
 174         pipe->bind_vertex_elements_state(pipe, r300->tran.new_velems);
 175     }
 176
 177     pipe_resource_reference(&out_buffer, NULL);
 178 }
 179
 180 void r300_end_vertex_translate(struct r300_context *r300)
 181 {
 182     struct pipe_context *pipe = &r300->context;
 183
 184     /* Restore vertex elements. */
 185     pipe->bind_vertex_elements_state(pipe, r300->tran.saved_velems);
 186     pipe->delete_vertex_elements_state(pipe, r300->tran.new_velems);
 187
 188     /* Delete the now-unused VBO. */
 189     pipe_resource_reference(&r300->vertex_buffer[r300->tran.vb_slot].buffer,
 190                             NULL);
 191 }
 192
 193 void r300_translate_index_buffer(struct r300_context *r300,
 194                                  struct pipe_resource **index_buffer,
 195                                  unsigned *index_size, unsigned index_offset,
 196                                  unsigned *start, unsigned count)
 197 {
 198     switch (*index_size) {
 199         case 1:
 200             util_shorten_ubyte_elts(&r300->context, index_buffer, index_offset, *start, count);
 201             *index_size = 2;
 202             *start = 0;
 203             r300->validate_buffers = TRUE;
 204             break;
 205
 206         case 2:
 207             if (*start % 2 != 0 || index_offset) {
 208                 util_rebuild_ushort_elts(&r300->context, index_buffer, index_offset, *start, count);
 209                 *start = 0;
 210                 r300->validate_buffers = TRUE;
 211             }
 212             break;
 213
 214         case 4:
 215             if (index_offset) {
 216                 util_rebuild_uint_elts(&r300->context, index_buffer, index_offset, *start, count);
 217                 *start = 0;
 218                 r300->validate_buffers = TRUE;
 219             }
 220             break;
 221     }
 222 }