src/gallium/drivers/r300/r300_render.c

   1 /*
   2  * Copyright 2009 Corbin Simpson <MostAwesomeDude@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 #include "draw/draw_context.h"
  24 #include "draw/draw_vbuf.h"
  25
  26 #include "pipe/p_inlines.h"
  27
  28 #include "util/u_memory.h"
  29 #include "util/u_prim.h"
  30
  31 #include "r300_cs.h"
  32 #include "r300_context.h"
  33 #include "r300_emit.h"
  34 #include "r300_reg.h"
  35 #include "r300_render.h"
  36 #include "r300_state_derived.h"
  37
  38 /* r300_render: Vertex and index buffer primitive emission. */
  39 #define R300_MAX_VBO_SIZE  (1024 * 1024)
  40
  41 static uint32_t r300_translate_primitive(unsigned prim)
  42 {
  43     switch (prim) {
  44         case PIPE_PRIM_POINTS:
  45             return R300_VAP_VF_CNTL__PRIM_POINTS;
  46         case PIPE_PRIM_LINES:
  47             return R300_VAP_VF_CNTL__PRIM_LINES;
  48         case PIPE_PRIM_LINE_LOOP:
  49             return R300_VAP_VF_CNTL__PRIM_LINE_LOOP;
  50         case PIPE_PRIM_LINE_STRIP:
  51             return R300_VAP_VF_CNTL__PRIM_LINE_STRIP;
  52         case PIPE_PRIM_TRIANGLES:
  53             return R300_VAP_VF_CNTL__PRIM_TRIANGLES;
  54         case PIPE_PRIM_TRIANGLE_STRIP:
  55             return R300_VAP_VF_CNTL__PRIM_TRIANGLE_STRIP;
  56         case PIPE_PRIM_TRIANGLE_FAN:
  57             return R300_VAP_VF_CNTL__PRIM_TRIANGLE_FAN;
  58         case PIPE_PRIM_QUADS:
  59             return R300_VAP_VF_CNTL__PRIM_QUADS;
  60         case PIPE_PRIM_QUAD_STRIP:
  61             return R300_VAP_VF_CNTL__PRIM_QUAD_STRIP;
  62         case PIPE_PRIM_POLYGON:
  63             return R300_VAP_VF_CNTL__PRIM_POLYGON;
  64         default:
  65             return 0;
  66     }
  67 }
  68
  69 /* This is the fast-path drawing & emission for HW TCL. */
  70 boolean r300_draw_range_elements(struct pipe_context* pipe,
  71                                  struct pipe_buffer* indexBuffer,
  72                                  unsigned indexSize,
  73                                  unsigned minIndex,
  74                                  unsigned maxIndex,
  75                                  unsigned mode,
  76                                  unsigned start,
  77                                  unsigned count)
  78 {
  79     struct r300_context* r300 = r300_context(pipe);
  80     uint32_t prim = r300_translate_primitive(mode);
  81     struct pipe_vertex_buffer* aos = r300->vertex_buffers;
  82     unsigned aos_count = r300->vertex_buffer_count;
  83     short* indices;
  84     unsigned packet_size;
  85     unsigned i;
  86     bool invalid = FALSE;
  87
  88     CS_LOCALS(r300);
  89
  90     if (!u_trim_pipe_prim(mode, &count)) {
  91         return FALSE;
  92     }
  93
  94 validate:
  95     for (i = 0; i < aos_count; i++) {
  96         if (!r300->winsys->add_buffer(r300->winsys, aos[i].buffer,
  97                     RADEON_GEM_DOMAIN_GTT, 0)) {
  98             pipe->flush(pipe, 0, NULL);
  99             goto validate;
 100         }
 101     }
 102     if (!r300->winsys->validate(r300->winsys)) {
 103         pipe->flush(pipe, 0, NULL);
 104         if (invalid) {
 105             /* Well, hell. */
 106             debug_printf("r300: Stuck in validation loop, gonna quit now.");
 107             exit(1);
 108         }
 109         invalid = TRUE;
 110         goto validate;
 111     }
 112
 113     r300_emit_dirty_state(r300);
 114
 115     packet_size = (aos_count >> 1) * 3 + (aos_count & 1) * 2;
 116
 117     BEGIN_CS(3 + packet_size + (aos_count * 2));
 118     OUT_CS_PKT3(R300_PACKET3_3D_LOAD_VBPNTR, packet_size);
 119     OUT_CS(aos_count);
 120     for (i = 0; i < aos_count - 1; i += 2) {
 121         OUT_CS(aos[i].stride |
 122             (aos[i].stride << 8) |
 123             (aos[i + 1].stride << 16) |
 124             (aos[i + 1].stride << 24));
 125         OUT_CS(aos[i].buffer_offset + start * 4 * aos[i].stride);
 126         OUT_CS(aos[i + 1].buffer_offset + start * 4 * aos[i + 1].stride);
 127     }
 128     if (aos_count & 1) {
 129         OUT_CS(aos[i].stride | (aos[i].stride << 8));
 130         OUT_CS(aos[i].buffer_offset + start * 4 * aos[i].stride);
 131     }
 132     for (i = 0; i < aos_count; i++) {
 133         OUT_CS_RELOC(aos[i].buffer, 0, RADEON_GEM_DOMAIN_GTT, 0, 0);
 134     }
 135     END_CS;
 136
 137     if (indexBuffer) {
 138         indices = (short*)pipe_buffer_map(pipe->screen, indexBuffer,
 139                                           PIPE_BUFFER_USAGE_CPU_READ);
 140
 141         /* Set the starting point. */
 142         indices += start;
 143
 144         BEGIN_CS(2 + (count+1)/2);
 145         OUT_CS_PKT3(R300_PACKET3_3D_DRAW_INDX_2, (count + 1)/2);
 146         OUT_CS(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (count << 16) | prim);
 147         for (i = 0; i < count - 1; i += 2) {
 148             OUT_CS(indices[i + 1] << 16 | indices[i]);
 149         }
 150         if (count % 2) {
 151             OUT_CS(indices[count - 1]);
 152         }
 153         END_CS;
 154     } else {
 155         BEGIN_CS(2);
 156         OUT_CS_PKT3(R300_PACKET3_3D_DRAW_VBUF_2, 0);
 157         OUT_CS(R300_VAP_VF_CNTL__PRIM_WALK_VERTEX_LIST | (count << 16) |
 158                prim);
 159         END_CS;
 160     }
 161
 162     return TRUE;
 163 }
 164
 165 /* Simple helpers for context setup. Should probably be moved to util. */
 166 boolean r300_draw_elements(struct pipe_context* pipe,
 167                            struct pipe_buffer* indexBuffer,
 168                            unsigned indexSize, unsigned mode,
 169                            unsigned start, unsigned count)
 170 {
 171     return pipe->draw_range_elements(pipe, indexBuffer, indexSize, 0, ~0,
 172                                      mode, start, count);
 173 }
 174
 175 boolean r300_draw_arrays(struct pipe_context* pipe, unsigned mode,
 176                          unsigned start, unsigned count)
 177 {
 178     return pipe->draw_elements(pipe, NULL, 0, mode, start, count);
 179 }
 180
 181 /****************************************************************************
 182  * The rest of this file is for SW TCL rendering only. Please be polite and *
 183  * keep these functions separated so that they are easier to locate. ~C.    *
 184  ***************************************************************************/
 185
 186 /* Draw-based drawing for SW TCL chipsets. */
 187 boolean r300_swtcl_draw_range_elements(struct pipe_context* pipe,
 188                                        struct pipe_buffer* indexBuffer,
 189                                        unsigned indexSize,
 190                                        unsigned minIndex,
 191                                        unsigned maxIndex,
 192                                        unsigned mode,
 193                                        unsigned start,
 194                                        unsigned count)
 195 {
 196     struct r300_context* r300 = r300_context(pipe);
 197     int i;
 198
 199     if (!u_trim_pipe_prim(mode, &count)) {
 200         return FALSE;
 201     }
 202
 203     for (i = 0; i < r300->vertex_buffer_count; i++) {
 204         void* buf = pipe_buffer_map(pipe->screen,
 205                                     r300->vertex_buffers[i].buffer,
 206                                     PIPE_BUFFER_USAGE_CPU_READ);
 207         draw_set_mapped_vertex_buffer(r300->draw, i, buf);
 208     }
 209
 210     if (indexBuffer) {
 211         void* indices = pipe_buffer_map(pipe->screen, indexBuffer,
 212                                         PIPE_BUFFER_USAGE_CPU_READ);
 213         draw_set_mapped_element_buffer_range(r300->draw, indexSize,
 214                                              minIndex, maxIndex, indices);
 215     } else {
 216         draw_set_mapped_element_buffer(r300->draw, 0, NULL);
 217     }
 218
 219     draw_set_mapped_constant_buffer(r300->draw,
 220             r300->shader_constants[PIPE_SHADER_VERTEX].constants,
 221             r300->shader_constants[PIPE_SHADER_VERTEX].count *
 222                 (sizeof(float) * 4));
 223
 224     draw_arrays(r300->draw, mode, start, count);
 225
 226     for (i = 0; i < r300->vertex_buffer_count; i++) {
 227         pipe_buffer_unmap(pipe->screen, r300->vertex_buffers[i].buffer);
 228         draw_set_mapped_vertex_buffer(r300->draw, i, NULL);
 229     }
 230
 231     if (indexBuffer) {
 232         pipe_buffer_unmap(pipe->screen, indexBuffer);
 233         draw_set_mapped_element_buffer_range(r300->draw, 0, start,
 234                                              start + count - 1, NULL);
 235     }
 236
 237     return TRUE;
 238 }
 239
 240 /* Object for rendering using Draw. */
 241 struct r300_render {
 242     /* Parent class */
 243     struct vbuf_render base;
 244
 245     /* Pipe context */
 246     struct r300_context* r300;
 247
 248     /* Vertex information */
 249     size_t vertex_size;
 250     unsigned prim;
 251     unsigned hwprim;
 252
 253     /* VBO */
 254     struct pipe_buffer* vbo;
 255     size_t vbo_size;
 256     size_t vbo_offset;
 257     size_t vbo_max_used;
 258     void * vbo_ptr;
 259 };
 260
 261 static INLINE struct r300_render*
 262 r300_render(struct vbuf_render* render)
 263 {
 264     return (struct r300_render*)render;
 265 }
 266
 267 static const struct vertex_info*
 268 r300_render_get_vertex_info(struct vbuf_render* render)
 269 {
 270     struct r300_render* r300render = r300_render(render);
 271     struct r300_context* r300 = r300render->r300;
 272
 273     r300_update_derived_state(r300);
 274
 275     return &r300->vertex_info->vinfo;
 276 }
 277
 278 static boolean r300_render_allocate_vertices(struct vbuf_render* render,
 279                                                    ushort vertex_size,
 280                                                    ushort count)
 281 {
 282     struct r300_render* r300render = r300_render(render);
 283     struct r300_context* r300 = r300render->r300;
 284     struct pipe_screen* screen = r300->context.screen;
 285     size_t size = (size_t)vertex_size * (size_t)count;
 286
 287     if (size + r300render->vbo_offset > r300render->vbo_size)
 288     {
 289         pipe_buffer_reference(&r300->vbo, NULL);
 290         r300render->vbo = pipe_buffer_create(screen,
 291                                              64,
 292                                              PIPE_BUFFER_USAGE_VERTEX,
 293                                              R300_MAX_VBO_SIZE);
 294         r300render->vbo_offset = 0;
 295         r300render->vbo_size = R300_MAX_VBO_SIZE;
 296     }
 297
 298     r300render->vertex_size = vertex_size;
 299     r300->vbo = r300render->vbo;
 300     r300->vbo_offset = r300render->vbo_offset;
 301
 302     return (r300render->vbo) ? TRUE : FALSE;
 303 }
 304
 305 static void* r300_render_map_vertices(struct vbuf_render* render)
 306 {
 307     struct r300_render* r300render = r300_render(render);
 308     struct pipe_screen* screen = r300render->r300->context.screen;
 309
 310     r300render->vbo_ptr = pipe_buffer_map(screen, r300render->vbo,
 311                                           PIPE_BUFFER_USAGE_CPU_WRITE);
 312
 313     return (r300render->vbo_ptr + r300render->vbo_offset);
 314 }
 315
 316 static void r300_render_unmap_vertices(struct vbuf_render* render,
 317                                              ushort min,
 318                                              ushort max)
 319 {
 320     struct r300_render* r300render = r300_render(render);
 321     struct pipe_screen* screen = r300render->r300->context.screen;
 322     CS_LOCALS(r300render->r300);
 323     BEGIN_CS(2);
 324     OUT_CS_REG(R300_VAP_VF_MAX_VTX_INDX, max);
 325     END_CS;
 326
 327     r300render->vbo_max_used = MAX2(r300render->vbo_max_used,
 328                                     r300render->vertex_size * (max + 1));
 329     pipe_buffer_unmap(screen, r300render->vbo);
 330 }
 331
 332 static void r300_render_release_vertices(struct vbuf_render* render)
 333 {
 334     struct r300_render* r300render = r300_render(render);
 335
 336     r300render->vbo_offset += r300render->vbo_max_used;
 337     r300render->vbo_max_used = 0;
 338 }
 339
 340 static boolean r300_render_set_primitive(struct vbuf_render* render,
 341                                                unsigned prim)
 342 {
 343     struct r300_render* r300render = r300_render(render);
 344
 345     r300render->prim = prim;
 346     r300render->hwprim = r300_translate_primitive(prim);
 347
 348     return TRUE;
 349 }
 350
 351 static void r300_render_draw_arrays(struct vbuf_render* render,
 352                                           unsigned start,
 353                                           unsigned count)
 354 {
 355     struct r300_render* r300render = r300_render(render);
 356     struct r300_context* r300 = r300render->r300;
 357
 358     CS_LOCALS(r300);
 359
 360     r300_emit_dirty_state(r300);
 361
 362     DBG(r300, DBG_DRAW, "r300: Doing vbuf render, count %d\n", count);
 363
 364     BEGIN_CS(2);
 365     OUT_CS_PKT3(R300_PACKET3_3D_DRAW_VBUF_2, 0);
 366     OUT_CS(R300_VAP_VF_CNTL__PRIM_WALK_VERTEX_LIST | (count << 16) |
 367            r300render->hwprim);
 368     END_CS;
 369 }
 370
 371 static void r300_render_draw(struct vbuf_render* render,
 372                                    const ushort* indices,
 373                                    uint count)
 374 {
 375     struct r300_render* r300render = r300_render(render);
 376     struct r300_context* r300 = r300render->r300;
 377     int i;
 378
 379     CS_LOCALS(r300);
 380
 381     r300_emit_dirty_state(r300);
 382
 383     BEGIN_CS(2 + (count+1)/2);
 384     OUT_CS_PKT3(R300_PACKET3_3D_DRAW_INDX_2, (count+1)/2);
 385     OUT_CS(R300_VAP_VF_CNTL__PRIM_WALK_INDICES | (count << 16) |
 386            r300render->hwprim);
 387     for (i = 0; i < count-1; i += 2) {
 388         OUT_CS(indices[i+1] << 16 | indices[i]);
 389     }
 390     if (count % 2) {
 391         OUT_CS(indices[count-1]);
 392     }
 393     END_CS;
 394 }
 395
 396 static void r300_render_destroy(struct vbuf_render* render)
 397 {
 398     FREE(render);
 399 }
 400
 401 static struct vbuf_render* r300_render_create(struct r300_context* r300)
 402 {
 403     struct r300_render* r300render = CALLOC_STRUCT(r300_render);
 404
 405     r300render->r300 = r300;
 406
 407     /* XXX find real numbers plz */
 408     r300render->base.max_vertex_buffer_bytes = 128 * 1024;
 409     r300render->base.max_indices = 16 * 1024;
 410
 411     r300render->base.get_vertex_info = r300_render_get_vertex_info;
 412     r300render->base.allocate_vertices = r300_render_allocate_vertices;
 413     r300render->base.map_vertices = r300_render_map_vertices;
 414     r300render->base.unmap_vertices = r300_render_unmap_vertices;
 415     r300render->base.set_primitive = r300_render_set_primitive;
 416     r300render->base.draw = r300_render_draw;
 417     r300render->base.draw_arrays = r300_render_draw_arrays;
 418     r300render->base.release_vertices = r300_render_release_vertices;
 419     r300render->base.destroy = r300_render_destroy;
 420
 421     r300render->vbo = NULL;
 422     r300render->vbo_size = 0;
 423     r300render->vbo_offset = 0;
 424
 425     return &r300render->base;
 426 }
 427
 428 struct draw_stage* r300_draw_stage(struct r300_context* r300)
 429 {
 430     struct vbuf_render* render;
 431     struct draw_stage* stage;
 432
 433     render = r300_render_create(r300);
 434
 435     if (!render) {
 436         return NULL;
 437     }
 438
 439     stage = draw_vbuf_stage(r300->draw, render);
 440
 441     if (!stage) {
 442         render->destroy(render);
 443         return NULL;
 444     }
 445
 446     draw_set_render(r300->draw, render);
 447
 448     return stage;
 449 }