#include "lp_scene.h"
#include "lp_state.h"
#include "lp_texture.h"
-#include "lp_tile_soa.h"
+#include "lp_tile_image.h"
#include "lp_limits.h"
*/
#ifdef DEBUG
+struct lp_rasterizer_task;
extern int jit_line;
extern const struct lp_rast_state *jit_state;
+extern const struct lp_rasterizer_task *jit_task;
-#define BEGIN_JIT_CALL(state) \
+#define BEGIN_JIT_CALL(state, task) \
do { \
jit_line = __LINE__; \
jit_state = state; \
+ jit_task = task; \
} while (0)
#define END_JIT_CALL() \
#else
-#define BEGIN_JIT_CALL(X)
+#define BEGIN_JIT_CALL(X, Y)
#define END_JIT_CALL()
#endif
/** "my" index */
unsigned thread_index;
- /* occlude counter for visiable pixels */
- uint32_t vis_counter;
- struct llvmpipe_query *query;
+ /* occlude counter for visible pixels */
+ struct lp_jit_thread_data thread_data;
+ uint64_t query_start;
+ struct llvmpipe_query *query[PIPE_QUERY_TYPES];
pipe_semaphore work_ready;
pipe_semaphore work_done;
struct lp_rasterizer
{
boolean exit_flag;
+ boolean no_rast; /**< For debugging/profiling */
/** The incoming queue of scenes ready to rasterize */
struct lp_scene_queue *full_scenes;
const struct lp_scene *scene = task->scene;
void *depth;
+ assert(x < scene->tiles_x * TILE_SIZE);
+ assert(y < scene->tiles_y * TILE_SIZE);
assert((x % TILE_VECTOR_WIDTH) == 0);
assert((y % TILE_VECTOR_HEIGHT) == 0);
/**
- * Get pointer to the swizzled color tile
+ * Get pointer to the unswizzled color tile
*/
static INLINE uint8_t *
-lp_rast_get_color_tile_pointer(struct lp_rasterizer_task *task,
- unsigned buf, enum lp_texture_usage usage)
+lp_rast_get_unswizzled_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;
+ assert(task->x < scene->tiles_x * TILE_SIZE);
+ assert(task->y < scene->tiles_y * TILE_SIZE);
assert(task->x % TILE_SIZE == 0);
assert(task->y % TILE_SIZE == 0);
assert(buf < scene->fb.nr_cbufs);
if (!task->color_tiles[buf]) {
struct pipe_surface *cbuf = scene->fb.cbufs[buf];
- struct llvmpipe_resource *lpt;
assert(cbuf);
- lpt = llvmpipe_resource(cbuf->texture);
- task->color_tiles[buf] = lp_swizzled_cbuf[task->thread_index][buf];
-
- if (usage != LP_TEX_USAGE_WRITE_ALL) {
- llvmpipe_swizzle_cbuf_tile(lpt,
- cbuf->face + cbuf->zslice,
- cbuf->level,
- task->x, task->y,
- task->color_tiles[buf]);
- }
+
+ format_bytes = util_format_description(cbuf->format)->block.bits / 8;
+ task->color_tiles[buf] = scene->cbufs[buf].map + scene->cbufs[buf].stride * task->y + format_bytes * task->x;
}
return task->color_tiles[buf];
/**
- * Get the pointer to a 4x4 color block (within a 64x64 tile).
- * We'll map the color buffer on demand here.
- * Note that this may be called even when there's no color buffers - return
- * NULL in that case.
+ * Get the pointer to an unswizzled 4x4 color block (within an unswizzled 64x64 tile).
* \param x, y location of 4x4 block in window coords
*/
static INLINE uint8_t *
-lp_rast_get_color_block_pointer(struct lp_rasterizer_task *task,
- unsigned buf, unsigned x, unsigned y)
+lp_rast_get_unswizzled_color_block_pointer(struct lp_rasterizer_task *task,
+ unsigned buf, unsigned x, unsigned y)
{
- unsigned px, py, pixel_offset;
+ unsigned px, py, pixel_offset, format_bytes;
uint8_t *color;
+ assert(x < task->scene->tiles_x * TILE_SIZE);
+ assert(y < task->scene->tiles_y * TILE_SIZE);
assert((x % TILE_VECTOR_WIDTH) == 0);
assert((y % TILE_VECTOR_HEIGHT) == 0);
+ assert(buf < task->scene->fb.nr_cbufs);
+
+ format_bytes = util_format_description(task->scene->fb.cbufs[buf]->format)->block.bits / 8;
- color = lp_rast_get_color_tile_pointer(task, buf, LP_TEX_USAGE_READ_WRITE);
+ color = lp_rast_get_unswizzled_color_tile_pointer(task, buf, LP_TEX_USAGE_READ_WRITE);
assert(color);
px = x % TILE_SIZE;
py = y % TILE_SIZE;
- pixel_offset = tile_pixel_offset(px, py, 0);
+ pixel_offset = px * format_bytes + py * task->scene->cbufs[buf].stride;
color = color + pixel_offset;
- assert(lp_check_alignment(color, 16));
+ assert(lp_check_alignment(color, llvmpipe_get_format_alignment(task->scene->fb.cbufs[buf]->format)));
return color;
}
const struct lp_rast_state *state = task->state;
struct lp_fragment_shader_variant *variant = state->variant;
uint8_t *color[PIPE_MAX_COLOR_BUFS];
+ unsigned stride[PIPE_MAX_COLOR_BUFS];
void *depth;
unsigned i;
/* color buffer */
- for (i = 0; i < scene->fb.nr_cbufs; i++)
- color[i] = lp_rast_get_color_block_pointer(task, i, x, y);
+ for (i = 0; i < scene->fb.nr_cbufs; i++) {
+ stride[i] = scene->cbufs[i].stride;
+
+ color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, x, y);
+ }
depth = lp_rast_get_depth_block_pointer(task, x, y);
/* run shader on 4x4 block */
- BEGIN_JIT_CALL(state);
+ BEGIN_JIT_CALL(state, task);
variant->jit_function[RAST_WHOLE]( &state->jit_context,
x, y,
inputs->frontfacing,
color,
depth,
0xffff,
- &task->vis_counter );
+ &task->thread_data,
+ stride );
END_JIT_CALL();
}
projects / mesa.git / blobdiff