llvmpipe: (trivial) drop "unswizzled" from some function names
authorRoland Scheidegger <sroland@vmware.com>
Thu, 29 May 2014 22:53:36 +0000 (00:53 +0200)
committerRoland Scheidegger <sroland@vmware.com>
Sat, 31 May 2014 20:05:14 +0000 (22:05 +0200)
This made sense when swizzled storage layout was used for rendering to tiles.
But nowadays the name just adds confusion (and makes for long lines).

Reviewed-by: Jose Fonseca <jfonseca@vmware.com>
src/gallium/drivers/llvmpipe/lp_rast.c
src/gallium/drivers/llvmpipe/lp_rast_priv.h

index f7c5b03b8d1e7f2bf62ca4ebb7c21c815b6475ea..a3420a21fbf373876bc432a413d64293aecf789c 100644 (file)
@@ -185,7 +185,7 @@ lp_rast_clear_zstencil(struct lp_rasterizer_task *task,
 
    if (scene->fb.zsbuf) {
       unsigned layer;
-      uint8_t *dst_layer = lp_rast_get_unswizzled_depth_tile_pointer(task, LP_TEX_USAGE_READ_WRITE);
+      uint8_t *dst_layer = lp_rast_get_depth_tile_pointer(task, LP_TEX_USAGE_READ_WRITE);
       block_size = util_format_get_blocksize(scene->fb.zsbuf->format);
 
       clear_value &= clear_mask;
@@ -314,8 +314,8 @@ lp_rast_shade_tile(struct lp_rasterizer_task *task,
          for (i = 0; i < scene->fb.nr_cbufs; i++){
             if (scene->fb.cbufs[i]) {
                stride[i] = scene->cbufs[i].stride;
-               color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, tile_x + x,
-                                                                     tile_y + y, inputs->layer);
+               color[i] = lp_rast_get_color_block_pointer(task, i, tile_x + x,
+                                                          tile_y + y, inputs->layer);
             }
             else {
                stride[i] = 0;
@@ -325,8 +325,8 @@ lp_rast_shade_tile(struct lp_rasterizer_task *task,
 
          /* depth buffer */
          if (scene->zsbuf.map) {
-            depth = lp_rast_get_unswizzled_depth_block_pointer(task, tile_x + x,
-                                                               tile_y + y, inputs->layer);
+            depth = lp_rast_get_depth_block_pointer(task, tile_x + x,
+                                                    tile_y + y, inputs->layer);
             depth_stride = scene->zsbuf.stride;
          }
 
@@ -409,8 +409,8 @@ lp_rast_shade_quads_mask(struct lp_rasterizer_task *task,
    for (i = 0; i < scene->fb.nr_cbufs; i++) {
       if (scene->fb.cbufs[i]) {
          stride[i] = scene->cbufs[i].stride;
-         color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, x, y,
-                                                               inputs->layer);
+         color[i] = lp_rast_get_color_block_pointer(task, i, x, y,
+                                                    inputs->layer);
       }
       else {
          stride[i] = 0;
@@ -421,7 +421,7 @@ lp_rast_shade_quads_mask(struct lp_rasterizer_task *task,
    /* depth buffer */
    if (scene->zsbuf.map) {
       depth_stride = scene->zsbuf.stride;
-      depth = lp_rast_get_unswizzled_depth_block_pointer(task, x, y, inputs->layer);
+      depth = lp_rast_get_depth_block_pointer(task, x, y, inputs->layer);
    }
 
    assert(lp_check_alignment(state->jit_context.u8_blend_color, 16));
index 063a70e9a344c15a9e108b04012f02a99db2e18a..d92230db68d0eea1ec06f9717c84aff0487a676a 100644 (file)
@@ -143,11 +143,11 @@ lp_rast_shade_quads_mask(struct lp_rasterizer_task *task,
 
 
 /**
- * Get pointer to the unswizzled color tile
+ * Get pointer to the color tile
  */
 static INLINE uint8_t *
-lp_rast_get_unswizzled_color_tile_pointer(struct lp_rasterizer_task *task,
-                                          unsigned buf, enum lp_texture_usage usage)
+lp_rast_get_color_tile_pointer(struct lp_rasterizer_task *task,
+                               unsigned buf, enum lp_texture_usage usage)
 {
    const struct lp_scene *scene = task->scene;
    unsigned format_bytes;
@@ -163,7 +163,8 @@ lp_rast_get_unswizzled_color_tile_pointer(struct lp_rasterizer_task *task,
       assert(cbuf);
 
       format_bytes = util_format_get_blocksize(cbuf->format);
-      task->color_tiles[buf] = scene->cbufs[buf].map + scene->cbufs[buf].stride * task->y + format_bytes * task->x;
+      task->color_tiles[buf] = scene->cbufs[buf].map + scene->cbufs[buf].stride * task->y +
+                               format_bytes * task->x;
    }
 
    return task->color_tiles[buf];
@@ -171,11 +172,11 @@ lp_rast_get_unswizzled_color_tile_pointer(struct lp_rasterizer_task *task,
 
 
 /**
- * Get pointer to the unswizzled depth tile
+ * Get pointer to the depth tile
  */
 static INLINE uint8_t *
-lp_rast_get_unswizzled_depth_tile_pointer(struct lp_rasterizer_task *task,
-                                          enum lp_texture_usage usage)
+lp_rast_get_depth_tile_pointer(struct lp_rasterizer_task *task,
+                               enum lp_texture_usage usage)
 {
    const struct lp_scene *scene = task->scene;
    unsigned format_bytes;
@@ -190,7 +191,8 @@ lp_rast_get_unswizzled_depth_tile_pointer(struct lp_rasterizer_task *task,
       assert(dbuf);
 
       format_bytes = util_format_get_blocksize(dbuf->format);
-      task->depth_tile = scene->zsbuf.map + scene->zsbuf.stride * task->y + format_bytes * task->x;
+      task->depth_tile = scene->zsbuf.map + scene->zsbuf.stride * task->y +
+                         format_bytes * task->x;
    }
 
    return task->depth_tile;
@@ -198,13 +200,13 @@ lp_rast_get_unswizzled_depth_tile_pointer(struct lp_rasterizer_task *task,
 
 
 /**
- * Get the pointer to an unswizzled 4x4 color block (within an unswizzled 64x64 tile).
+ * Get the pointer to a 4x4 color block (within a 64x64 tile).
  * \param x, y location of 4x4 block in window coords
  */
 static INLINE uint8_t *
-lp_rast_get_unswizzled_color_block_pointer(struct lp_rasterizer_task *task,
-                                           unsigned buf, unsigned x, unsigned y,
-                                           unsigned layer)
+lp_rast_get_color_block_pointer(struct lp_rasterizer_task *task,
+                                unsigned buf, unsigned x, unsigned y,
+                                unsigned layer)
 {
    unsigned px, py, pixel_offset, format_bytes;
    uint8_t *color;
@@ -217,7 +219,7 @@ lp_rast_get_unswizzled_color_block_pointer(struct lp_rasterizer_task *task,
 
    format_bytes = util_format_get_blocksize(task->scene->fb.cbufs[buf]->format);
 
-   color = lp_rast_get_unswizzled_color_tile_pointer(task, buf, LP_TEX_USAGE_READ_WRITE);
+   color = lp_rast_get_color_tile_pointer(task, buf, LP_TEX_USAGE_READ_WRITE);
    assert(color);
 
    px = x % TILE_SIZE;
@@ -236,12 +238,12 @@ lp_rast_get_unswizzled_color_block_pointer(struct lp_rasterizer_task *task,
 
 
 /**
- * Get the pointer to an unswizzled 4x4 depth block (within an unswizzled 64x64 tile).
+ * Get the pointer to a 4x4 depth block (within a 64x64 tile).
  * \param x, y location of 4x4 block in window coords
  */
 static INLINE uint8_t *
-lp_rast_get_unswizzled_depth_block_pointer(struct lp_rasterizer_task *task,
-                                           unsigned x, unsigned y, unsigned layer)
+lp_rast_get_depth_block_pointer(struct lp_rasterizer_task *task,
+                                unsigned x, unsigned y, unsigned layer)
 {
    unsigned px, py, pixel_offset, format_bytes;
    uint8_t *depth;
@@ -253,7 +255,7 @@ lp_rast_get_unswizzled_depth_block_pointer(struct lp_rasterizer_task *task,
 
    format_bytes = util_format_get_blocksize(task->scene->fb.zsbuf->format);
 
-   depth = lp_rast_get_unswizzled_depth_tile_pointer(task, LP_TEX_USAGE_READ_WRITE);
+   depth = lp_rast_get_depth_tile_pointer(task, LP_TEX_USAGE_READ_WRITE);
    assert(depth);
 
    px = x % TILE_SIZE;
@@ -295,8 +297,8 @@ lp_rast_shade_quads_all( struct lp_rasterizer_task *task,
    for (i = 0; i < scene->fb.nr_cbufs; i++) {
       if (scene->fb.cbufs[i]) {
          stride[i] = scene->cbufs[i].stride;
-         color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, x, y,
-                                                               inputs->layer);
+         color[i] = lp_rast_get_color_block_pointer(task, i, x, y,
+                                                    inputs->layer);
       }
       else {
          stride[i] = 0;
@@ -305,7 +307,7 @@ lp_rast_shade_quads_all( struct lp_rasterizer_task *task,
    }
 
    if (scene->zsbuf.map) {
-      depth = lp_rast_get_unswizzled_depth_block_pointer(task, x, y, inputs->layer);
+      depth = lp_rast_get_depth_block_pointer(task, x, y, inputs->layer);
       depth_stride = scene->zsbuf.stride;
    }