#define LP_SCENE_H
#include "os/os_thread.h"
-#include "lp_tile_soa.h"
#include "lp_rast.h"
+#include "lp_debug.h"
struct lp_scene_queue;
+struct lp_rast_state;
/* We're limited to 2K by 2K for 32bit fixed point rasterization.
* Will need a 64-bit version for larger framebuffers.
#define TILES_Y (LP_MAX_HEIGHT / TILE_SIZE)
-#define CMD_BLOCK_MAX 16
-#define DATA_BLOCK_SIZE (64 * 1024 - 2 * sizeof(void *))
+/* Commands per command block (ideally so sizeof(cmd_block) is a power of
+ * two in size.)
+ */
+#define CMD_BLOCK_MAX 29
+
+/* Bytes per data block.
+ */
+#define DATA_BLOCK_SIZE (64 * 1024)
/* Scene temporary storage is clamped to this size:
*/
-#define LP_SCENE_MAX_SIZE (1024*1024)
+#define LP_SCENE_MAX_SIZE (36*1024*1024)
/* The maximum amount of texture storage referenced by a scene is
- * clamped ot this size:
+ * clamped to this size:
*/
#define LP_SCENE_MAX_RESOURCE_SIZE (64*1024*1024)
struct cmd_block *next;
};
-struct cmd_block_list {
- struct cmd_block *head;
- struct cmd_block *tail;
-};
struct data_block {
ubyte data[DATA_BLOCK_SIZE];
* For each screen tile we have one of these bins.
*/
struct cmd_bin {
- ushort x;
- ushort y;
+ const struct lp_rast_state *last_state; /* most recent state set in bin */
struct cmd_block *head;
struct cmd_block *tail;
};
struct pipe_context *pipe;
struct lp_fence *fence;
+ /* The queries still active at end of scene */
+ struct llvmpipe_query *active_queries[LP_MAX_ACTIVE_BINNED_QUERIES];
+ unsigned num_active_queries;
+ /* If queries were either active or there were begin/end query commands */
+ boolean had_queries;
+
/* Framebuffer mappings - valid only between begin_rasterization()
* and end_rasterization().
*/
struct {
uint8_t *map;
unsigned stride;
- unsigned blocksize;
+ unsigned layer_stride;
+ unsigned format_bytes;
+ unsigned sample_stride;
+ unsigned nr_samples;
} zsbuf, cbufs[PIPE_MAX_COLOR_BUFS];
-
+
+ /* The amount of layers in the fb (minimum of all attachments) */
+ unsigned fb_max_layer;
+
+ /* fixed point sample positions. */
+ int32_t fixed_sample_pos[LP_MAX_SAMPLES][2];
+
+ /* max samples for bound framebuffer */
+ unsigned fb_max_samples;
+
/** the framebuffer to render the scene into */
struct pipe_framebuffer_state fb;
unsigned resource_reference_size;
boolean alloc_failed;
- boolean has_depthstencil_clear;
-
/**
* Number of active tiles in each dimension.
* This basically the framebuffer size divided by tile size
unsigned tiles_x, tiles_y;
int curr_x, curr_y; /**< for iterating over bins */
- pipe_mutex mutex;
+ mtx_t mutex;
struct cmd_bin tile[TILES_X][TILES_Y];
struct data_block_list data;
* Allocate space for a command/data in the bin's data buffer.
* Grow the block list if needed.
*/
-static INLINE void *
+static inline void *
lp_scene_alloc( struct lp_scene *scene, unsigned size)
{
struct data_block_list *list = &scene->data;
assert(size <= DATA_BLOCK_SIZE);
assert(block != NULL);
+ if (LP_DEBUG & DEBUG_MEM)
+ debug_printf("alloc %u block %u/%u tot %u/%u\n",
+ size, block->used, DATA_BLOCK_SIZE,
+ scene->scene_size, LP_SCENE_MAX_SIZE);
+
if (block->used + size > DATA_BLOCK_SIZE) {
block = lp_scene_new_data_block( scene );
if (!block) {
/**
* As above, but with specific alignment.
*/
-static INLINE void *
+static inline void *
lp_scene_alloc_aligned( struct lp_scene *scene, unsigned size,
unsigned alignment )
{
struct data_block *block = list->head;
assert(block != NULL);
+
+ if (LP_DEBUG & DEBUG_MEM)
+ debug_printf("alloc %u block %u/%u tot %u/%u\n",
+ size + alignment - 1,
+ block->used, DATA_BLOCK_SIZE,
+ scene->scene_size, LP_SCENE_MAX_SIZE);
if (block->used + size + alignment - 1 > DATA_BLOCK_SIZE) {
block = lp_scene_new_data_block( scene );
/* Put back data if we decide not to use it, eg. culled triangles.
*/
-static INLINE void
+static inline void
lp_scene_putback_data( struct lp_scene *scene, unsigned size)
{
struct data_block_list *list = &scene->data;
/** Return pointer to a particular tile's bin. */
-static INLINE struct cmd_bin *
+static inline struct cmd_bin *
lp_scene_get_bin(struct lp_scene *scene, unsigned x, unsigned y)
{
return &scene->tile[x][y];
/* Add a command to bin[x][y].
*/
-static INLINE boolean
+static inline boolean
lp_scene_bin_command( struct lp_scene *scene,
unsigned x, unsigned y,
unsigned cmd,
assert(x < scene->tiles_x);
assert(y < scene->tiles_y);
- assert(cmd <= LP_RAST_OP_END_QUERY);
+ assert(cmd < LP_RAST_OP_MAX);
if (tail == NULL || tail->count == CMD_BLOCK_MAX) {
tail = lp_scene_new_cmd_block( scene, bin );
}
+static inline boolean
+lp_scene_bin_cmd_with_state( struct lp_scene *scene,
+ unsigned x, unsigned y,
+ const struct lp_rast_state *state,
+ unsigned cmd,
+ union lp_rast_cmd_arg arg )
+{
+ struct cmd_bin *bin = lp_scene_get_bin(scene, x, y);
+
+ if (state != bin->last_state) {
+ bin->last_state = state;
+ if (!lp_scene_bin_command(scene, x, y,
+ LP_RAST_OP_SET_STATE,
+ lp_rast_arg_state(state)))
+ return FALSE;
+ }
+
+ if (!lp_scene_bin_command( scene, x, y, cmd, arg ))
+ return FALSE;
+
+ return TRUE;
+}
+
+
/* Add a command to all active bins.
*/
-static INLINE boolean
+static inline boolean
lp_scene_bin_everywhere( struct lp_scene *scene,
unsigned cmd,
const union lp_rast_cmd_arg arg )
}
-static INLINE unsigned
+static inline unsigned
lp_scene_get_num_bins( const struct lp_scene *scene )
{
return scene->tiles_x * scene->tiles_y;
lp_scene_bin_iter_begin( struct lp_scene *scene );
struct cmd_bin *
-lp_scene_bin_iter_next( struct lp_scene *scene );
+lp_scene_bin_iter_next( struct lp_scene *scene, int *x, int *y );
/* Begin/end binning of a scene
*/
void
-lp_scene_begin_binning( struct lp_scene *scene,
- struct pipe_framebuffer_state *fb );
+lp_scene_begin_binning(struct lp_scene *scene,
+ struct pipe_framebuffer_state *fb);
void
-lp_scene_end_binning( struct lp_scene *scene );
+lp_scene_end_binning(struct lp_scene *scene);
/* Begin/end rasterization of a scene
lp_scene_begin_rasterization(struct lp_scene *scene);
void
-lp_scene_end_rasterization(struct lp_scene *scene );
+lp_scene_end_rasterization(struct lp_scene *scene);
projects / mesa.git / blobdiff