← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to src/gallium/drivers/r300/r300_render_translate.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
        enum pipe_format output_format = ve->hw_format[i];
 
53
        unsigned output_format_size = ve->hw_format_size[i];
 
54
 
 
55
        /* Check for support. */
 
56
        if (ve->velem[i].src_format == ve->hw_format[i] &&
 
57
            (vb->buffer_offset + ve->velem[i].src_offset) % 4 == 0 &&
 
58
            vb->stride % 4 == 0) {
 
59
            continue;
 
60
        }
 
61
 
 
62
        /* Workaround for translate: output floats instead of halfs. */
 
63
        switch (output_format) {
 
64
            case PIPE_FORMAT_R16_FLOAT:
 
65
                output_format = PIPE_FORMAT_R32_FLOAT;
 
66
                output_format_size = 4;
 
67
                break;
 
68
            case PIPE_FORMAT_R16G16_FLOAT:
 
69
                output_format = PIPE_FORMAT_R32G32_FLOAT;
 
70
                output_format_size = 8;
 
71
                break;
 
72
            case PIPE_FORMAT_R16G16B16_FLOAT:
 
73
                output_format = PIPE_FORMAT_R32G32B32_FLOAT;
 
74
                output_format_size = 12;
 
75
                break;
 
76
            case PIPE_FORMAT_R16G16B16A16_FLOAT:
 
77
                output_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
 
78
                output_format_size = 16;
 
79
                break;
 
80
            default:;
 
81
        }
 
82
 
 
83
        /* Add this vertex element. */
 
84
        te = &key.element[key.nr_elements];
 
85
        /*te->type;
 
86
        te->instance_divisor;*/
 
87
        te->input_buffer = ve->velem[i].vertex_buffer_index;
 
88
        te->input_format = ve->velem[i].src_format;
 
89
        te->input_offset = vb->buffer_offset + ve->velem[i].src_offset;
 
90
        te->output_format = output_format;
 
91
        te->output_offset = key.output_stride;
 
92
 
 
93
        key.output_stride += output_format_size;
 
94
        vb_translated[ve->velem[i].vertex_buffer_index] = TRUE;
 
95
        tr_elem_index[i] = key.nr_elements;
 
96
        key.nr_elements++;
 
97
    }
 
98
 
 
99
    /* Get a translate object. */
 
100
    tr = translate_cache_find(r300->tran.translate_cache, &key);
 
101
 
 
102
    /* Map buffers we want to translate. */
 
103
    for (i = 0; i < r300->vertex_buffer_count; i++) {
 
104
        if (vb_translated[i]) {
 
105
            struct pipe_vertex_buffer *vb = &r300->vertex_buffer[i];
 
106
 
 
107
            vb_map[i] = pipe_buffer_map(pipe, vb->buffer,
 
108
                                        PIPE_TRANSFER_READ, &vb_transfer[i]);
 
109
 
 
110
            tr->set_buffer(tr, i, vb_map[i], vb->stride, vb->max_index);
 
111
        }
 
112
    }
 
113
 
 
114
    /* Create and map the output buffer. */
 
115
    num_verts = r300->vertex_buffer_max_index + 1;
 
116
 
 
117
    out_buffer = pipe_buffer_create(&r300->screen->screen,
 
118
                                    PIPE_BIND_VERTEX_BUFFER,
 
119
                                    key.output_stride * num_verts);
 
120
 
 
121
    out_map = pipe_buffer_map(pipe, out_buffer, PIPE_TRANSFER_WRITE,
 
122
                              &out_transfer);
 
123
 
 
124
    /* Translate. */
 
125
    tr->run(tr, 0, num_verts, 0, out_map);
 
126
 
 
127
    /* Unmap all buffers. */
 
128
    for (i = 0; i < r300->vertex_buffer_count; i++) {
 
129
        if (vb_translated[i]) {
 
130
            pipe_buffer_unmap(pipe, r300->vertex_buffer[i].buffer,
 
131
                              vb_transfer[i]);
 
132
        }
 
133
    }
 
134
 
 
135
    pipe_buffer_unmap(pipe, out_buffer, out_transfer);
 
136
 
 
137
    /* Setup the new vertex buffer in the first free slot. */
 
138
    for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
 
139
        struct pipe_vertex_buffer *vb = &r300->vertex_buffer[i];
 
140
 
 
141
        if (!vb->buffer) {
 
142
            pipe_resource_reference(&vb->buffer, out_buffer);
 
143
            vb->buffer_offset = 0;
 
144
            vb->max_index = num_verts - 1;
 
145
            vb->stride = key.output_stride;
 
146
            r300->tran.vb_slot = i;
 
147
            break;
 
148
        }
 
149
    }
 
150
 
 
151
    /* Save and replace vertex elements. */
 
152
    {
 
153
        struct pipe_vertex_element new_velems[PIPE_MAX_ATTRIBS];
 
154
 
 
155
        r300->tran.saved_velems = r300->velems;
 
156
 
 
157
        for (i = 0; i < ve->count; i++) {
 
158
            if (vb_translated[ve->velem[i].vertex_buffer_index]) {
 
159
                te = &key.element[tr_elem_index[i]];
 
160
                new_velems[i].instance_divisor = ve->velem[i].instance_divisor;
 
161
                new_velems[i].src_format = te->output_format;
 
162
                new_velems[i].src_offset = te->output_offset;
 
163
                new_velems[i].vertex_buffer_index = r300->tran.vb_slot;
 
164
            } else {
 
165
                memcpy(&new_velems[i], &ve->velem[i],
 
166
                       sizeof(struct pipe_vertex_element));
 
167
            }
 
168
        }
 
169
 
 
170
        r300->tran.new_velems =
 
171
            pipe->create_vertex_elements_state(pipe, ve->count, new_velems);
 
172
        pipe->bind_vertex_elements_state(pipe, r300->tran.new_velems);
 
173
    }
 
174
 
 
175
    pipe_resource_reference(&out_buffer, NULL);
 
176
}
 
177
 
 
178
void r300_end_vertex_translate(struct r300_context *r300)
 
179
{
 
180
    struct pipe_context *pipe = &r300->context;
 
181
 
 
182
    /* Restore vertex elements. */
 
183
    pipe->bind_vertex_elements_state(pipe, r300->tran.saved_velems);
 
184
    pipe->delete_vertex_elements_state(pipe, r300->tran.new_velems);
 
185
 
 
186
    /* Delete the now-unused VBO. */
 
187
    pipe_resource_reference(&r300->vertex_buffer[r300->tran.vb_slot].buffer,
 
188
                            NULL);
 
189
}
 
190
 
 
191
static void r300_shorten_ubyte_elts(struct r300_context* r300,
 
192
                                    struct pipe_resource** elts,
 
193
                                    int index_bias,
 
194
                                    unsigned start,
 
195
                                    unsigned count)
 
196
{
 
197
    struct pipe_context* context = &r300->context;
 
198
    struct pipe_screen* screen = r300->context.screen;
 
199
    struct pipe_resource* new_elts;
 
200
    unsigned char *in_map;
 
201
    unsigned short *out_map;
 
202
    struct pipe_transfer *src_transfer, *dst_transfer;
 
203
    unsigned i;
 
204
 
 
205
    new_elts = pipe_buffer_create(screen,
 
206
                                  PIPE_BIND_INDEX_BUFFER,
 
207
                                  2 * count);
 
208
 
 
209
    in_map = pipe_buffer_map(context, *elts, PIPE_TRANSFER_READ, &src_transfer);
 
210
    out_map = pipe_buffer_map(context, new_elts, PIPE_TRANSFER_WRITE, &dst_transfer);
 
211
 
 
212
    in_map += start;
 
213
 
 
214
    for (i = 0; i < count; i++) {
 
215
        *out_map = (unsigned short)(*in_map + index_bias);
 
216
        in_map++;
 
217
        out_map++;
 
218
    }
 
219
 
 
220
    pipe_buffer_unmap(context, *elts, src_transfer);
 
221
    pipe_buffer_unmap(context, new_elts, dst_transfer);
 
222
 
 
223
    *elts = new_elts;
 
224
}
 
225
 
 
226
static void r300_rebuild_ushort_elts(struct r300_context *r300,
 
227
                                     struct pipe_resource **elts,
 
228
                                     int index_bias,
 
229
                                     unsigned start, unsigned count)
 
230
{
 
231
    struct pipe_context *context = &r300->context;
 
232
    struct pipe_transfer *in_transfer = NULL;
 
233
    struct pipe_transfer *out_transfer = NULL;
 
234
    struct pipe_resource *new_elts;
 
235
    unsigned short *in_map;
 
236
    unsigned short *out_map;
 
237
    unsigned i;
 
238
 
 
239
    new_elts = pipe_buffer_create(context->screen,
 
240
                                  PIPE_BIND_INDEX_BUFFER,
 
241
                                  2 * count);
 
242
 
 
243
    in_map = pipe_buffer_map(context, *elts,
 
244
                             PIPE_TRANSFER_READ, &in_transfer);
 
245
    out_map = pipe_buffer_map(context, new_elts,
 
246
                              PIPE_TRANSFER_WRITE, &out_transfer);
 
247
 
 
248
    in_map += start;
 
249
    for (i = 0; i < count; i++) {
 
250
        *out_map = (unsigned short)(*in_map + index_bias);
 
251
        in_map++;
 
252
        out_map++;
 
253
    }
 
254
 
 
255
    pipe_buffer_unmap(context, *elts, in_transfer);
 
256
    pipe_buffer_unmap(context, new_elts, out_transfer);
 
257
 
 
258
    *elts = new_elts;
 
259
}
 
260
 
 
261
static void r300_rebuild_uint_elts(struct r300_context *r300,
 
262
                                   struct pipe_resource **elts,
 
263
                                   int index_bias,
 
264
                                   unsigned start, unsigned count)
 
265
{
 
266
    struct pipe_context *context = &r300->context;
 
267
    struct pipe_transfer *in_transfer = NULL;
 
268
    struct pipe_transfer *out_transfer = NULL;
 
269
    struct pipe_resource *new_elts;
 
270
    unsigned int *in_map;
 
271
    unsigned int *out_map;
 
272
    unsigned i;
 
273
 
 
274
    new_elts = pipe_buffer_create(context->screen,
 
275
                                  PIPE_BIND_INDEX_BUFFER,
 
276
                                  2 * count);
 
277
 
 
278
    in_map = pipe_buffer_map(context, *elts,
 
279
                             PIPE_TRANSFER_READ, &in_transfer);
 
280
    out_map = pipe_buffer_map(context, new_elts,
 
281
                              PIPE_TRANSFER_WRITE, &out_transfer);
 
282
 
 
283
    in_map += start;
 
284
    for (i = 0; i < count; i++) {
 
285
        *out_map = (unsigned int)(*in_map + index_bias);
 
286
        in_map++;
 
287
        out_map++;
 
288
    }
 
289
 
 
290
    pipe_buffer_unmap(context, *elts, in_transfer);
 
291
    pipe_buffer_unmap(context, new_elts, out_transfer);
 
292
 
 
293
    *elts = new_elts;
 
294
}
 
295
 
 
296
void r300_translate_index_buffer(struct r300_context *r300,
 
297
                                 struct pipe_resource **index_buffer,
 
298
                                 unsigned *index_size, unsigned index_offset,
 
299
                                 unsigned *start, unsigned count)
 
300
{
 
301
    switch (*index_size) {
 
302
        case 1:
 
303
            r300_shorten_ubyte_elts(r300, index_buffer, index_offset, *start, count);
 
304
            *index_size = 2;
 
305
            *start = 0;
 
306
            break;
 
307
 
 
308
        case 2:
 
309
            if (*start % 2 != 0 || index_offset) {
 
310
                r300_rebuild_ushort_elts(r300, index_buffer, index_offset, *start, count);
 
311
                *start = 0;
 
312
            }
 
313
            break;
 
314
 
 
315
        case 4:
 
316
            if (index_offset) {
 
317
                r300_rebuild_uint_elts(r300, index_buffer, index_offset, *start, count);
 
318
                *start = 0;
 
319
            }
 
320
            break;
 
321
    }
 
322
}