#include "pipe/p_defines.h"
#include "pipe/p_inlines.h"
-#include "util/u_math.h"
#include "util/u_memory.h"
#include "util/u_pack_color.h"
-#include "lp_state.h"
+#include "util/u_surface.h"
+#include "lp_scene.h"
+#include "lp_scene_queue.h"
#include "lp_buffer.h"
#include "lp_texture.h"
+#include "lp_debug.h"
+#include "lp_fence.h"
+#include "lp_rast.h"
#include "lp_setup_context.h"
-#define SETUP_DEBUG debug_printf
+#include "draw/draw_context.h"
+#include "draw/draw_vbuf.h"
-static void set_state( struct setup_context *, unsigned );
-void lp_setup_new_cmd_block( struct cmd_block_list *list )
-{
- struct cmd_block *block = MALLOC_STRUCT(cmd_block);
- list->tail->next = block;
- list->tail = block;
- block->next = NULL;
- block->count = 0;
-}
+static void set_scene_state( struct setup_context *, unsigned );
+
-void lp_setup_new_data_block( struct data_block_list *list )
+struct lp_scene *
+lp_setup_get_current_scene(struct setup_context *setup)
{
- struct data_block *block = MALLOC_STRUCT(data_block);
- list->tail->next = block;
- list->tail = block;
- block->next = NULL;
- block->used = 0;
+ if (!setup->scene) {
+
+ /* wait for a free/empty scene
+ */
+ setup->scene = lp_scene_dequeue(setup->empty_scenes, TRUE);
+
+ if(0)lp_scene_reset( setup->scene ); /* XXX temporary? */
+
+ lp_scene_set_framebuffer_size(setup->scene,
+ setup->fb.width,
+ setup->fb.height);
+ }
+ return setup->scene;
}
const float (*v1)[4],
const float (*v2)[4])
{
- set_state( setup, SETUP_ACTIVE );
+ set_scene_state( setup, SETUP_ACTIVE );
lp_setup_choose_triangle( setup );
setup->triangle( setup, v0, v1, v2 );
}
const float (*v0)[4],
const float (*v1)[4])
{
- set_state( setup, SETUP_ACTIVE );
+ set_scene_state( setup, SETUP_ACTIVE );
lp_setup_choose_line( setup );
setup->line( setup, v0, v1 );
}
first_point( struct setup_context *setup,
const float (*v0)[4])
{
- set_state( setup, SETUP_ACTIVE );
+ set_scene_state( setup, SETUP_ACTIVE );
lp_setup_choose_point( setup );
setup->point( setup, v0 );
}
static void reset_context( struct setup_context *setup )
{
- unsigned i, j;
-
- SETUP_DEBUG("%s\n", __FUNCTION__);
+ LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
/* Reset derived state */
setup->constants.stored_size = 0;
setup->fs.stored = NULL;
setup->dirty = ~0;
- /* Free all but last binner command lists:
- */
- for (i = 0; i < setup->tiles_x; i++) {
- for (j = 0; j < setup->tiles_y; j++) {
- struct cmd_block_list *list = &setup->tile[i][j];
- struct cmd_block *block;
- struct cmd_block *tmp;
-
- for (block = list->head; block != list->tail; block = tmp) {
- tmp = block->next;
- FREE(block);
- }
-
- assert(list->tail->next == NULL);
- list->head = list->tail;
- list->head->count = 0;
- }
- }
-
- /* Free all but last binned data block:
- */
- {
- struct data_block_list *list = &setup->data;
- struct data_block *block, *tmp;
-
- for (block = list->head; block != list->tail; block = tmp) {
- tmp = block->next;
- FREE(block);
- }
-
- assert(list->tail->next == NULL);
- list->head = list->tail;
- list->head->used = 0;
- }
+ /* no current bin */
+ setup->scene = NULL;
/* Reset some state:
*/
}
-
-
-/* Add a command to all active bins.
- */
-static void bin_everywhere( struct setup_context *setup,
- lp_rast_cmd cmd,
- const union lp_rast_cmd_arg arg )
-{
- unsigned i, j;
- for (i = 0; i < setup->tiles_x; i++)
- for (j = 0; j < setup->tiles_y; j++)
- bin_command( &setup->tile[i][j], cmd, arg );
-}
-
-
-/** Rasterize commands for a single bin */
+/** Rasterize all scene's bins */
static void
-rasterize_bin( struct lp_rasterizer *rast,
- struct cmd_block_list *commands,
- int x, int y)
+lp_setup_rasterize_scene( struct setup_context *setup,
+ boolean write_depth )
{
- struct cmd_block *block;
- unsigned k;
-
- lp_rast_start_tile( rast, x, y );
-
- /* simply execute each of the commands in the block list */
- for (block = commands->head; block; block = block->next) {
- for (k = 0; k < block->count; k++) {
- block->cmd[k]( rast, block->arg[k] );
- }
- }
-
- lp_rast_end_tile( rast );
-}
-
+ struct lp_scene *scene = lp_setup_get_current_scene(setup);
-/** Rasterize all tile's bins */
-static void
-rasterize_bins( struct setup_context *setup,
- boolean write_depth )
-{
- struct lp_rasterizer *rast = setup->rast;
- unsigned i, j;
-
- SETUP_DEBUG("%s\n", __FUNCTION__);
-
- lp_rast_begin( rast,
- setup->fb.cbuf,
- setup->fb.zsbuf,
- setup->fb.cbuf != NULL,
- setup->fb.zsbuf != NULL && write_depth,
- setup->fb.width,
- setup->fb.height );
-
- /* loop over tile bins, rasterize each */
- for (i = 0; i < setup->tiles_x; i++) {
- for (j = 0; j < setup->tiles_y; j++) {
- rasterize_bin( rast, &setup->tile[i][j],
- i * TILE_SIZE,
- j * TILE_SIZE );
- }
- }
-
- lp_rast_end( rast );
+ lp_rasterize_scene(setup->rast,
+ scene,
+ &setup->fb,
+ write_depth);
reset_context( setup );
- SETUP_DEBUG("%s done \n", __FUNCTION__);
+ LP_DBG(DEBUG_SETUP, "%s done \n", __FUNCTION__);
}
static void
begin_binning( struct setup_context *setup )
{
- SETUP_DEBUG("%s\n", __FUNCTION__);
+ struct lp_scene *scene = lp_setup_get_current_scene(setup);
- if (!setup->fb.cbuf && !setup->fb.zsbuf) {
- setup->fb.width = 0;
- setup->fb.height = 0;
- }
- else if (!setup->fb.zsbuf) {
- setup->fb.width = setup->fb.cbuf->width;
- setup->fb.height = setup->fb.cbuf->height;
- }
- else if (!setup->fb.cbuf) {
- setup->fb.width = setup->fb.zsbuf->width;
- setup->fb.height = setup->fb.zsbuf->height;
- }
- else {
- /* XXX: not sure what we're really supposed to do for
- * mis-matched color & depth buffer sizes.
- */
- setup->fb.width = MIN2(setup->fb.cbuf->width,
- setup->fb.zsbuf->width);
- setup->fb.height = MIN2(setup->fb.cbuf->height,
- setup->fb.zsbuf->height);
- }
+ LP_DBG(DEBUG_SETUP, "%s color: %s depth: %s\n", __FUNCTION__,
+ (setup->clear.flags & PIPE_CLEAR_COLOR) ? "clear": "load",
+ (setup->clear.flags & PIPE_CLEAR_DEPTHSTENCIL) ? "clear": "load");
- setup->tiles_x = align(setup->fb.width, TILE_SIZE) / TILE_SIZE;
- setup->tiles_y = align(setup->fb.height, TILE_SIZE) / TILE_SIZE;
-
- if (setup->fb.cbuf) {
+ if (setup->fb.nr_cbufs) {
if (setup->clear.flags & PIPE_CLEAR_COLOR)
- bin_everywhere( setup,
- lp_rast_clear_color,
- setup->clear.color );
+ lp_scene_bin_everywhere( scene,
+ lp_rast_clear_color,
+ setup->clear.color );
else
- bin_everywhere( setup, lp_rast_load_color, lp_rast_arg_null() );
+ lp_scene_bin_everywhere( scene,
+ lp_rast_load_color,
+ lp_rast_arg_null() );
}
if (setup->fb.zsbuf) {
if (setup->clear.flags & PIPE_CLEAR_DEPTHSTENCIL)
- bin_everywhere( setup,
- lp_rast_clear_zstencil,
- setup->clear.zstencil );
+ lp_scene_bin_everywhere( scene,
+ lp_rast_clear_zstencil,
+ setup->clear.zstencil );
else
- bin_everywhere( setup, lp_rast_load_zstencil, lp_rast_arg_null() );
+ lp_scene_bin_everywhere( scene,
+ lp_rast_load_zstencil,
+ lp_rast_arg_null() );
}
- SETUP_DEBUG("%s done\n", __FUNCTION__);
+ LP_DBG(DEBUG_SETUP, "%s done\n", __FUNCTION__);
}
static void
execute_clears( struct setup_context *setup )
{
- SETUP_DEBUG("%s\n", __FUNCTION__);
+ LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
begin_binning( setup );
- rasterize_bins( setup, TRUE );
+ lp_setup_rasterize_scene( setup, TRUE );
}
static void
-set_state( struct setup_context *setup,
+set_scene_state( struct setup_context *setup,
unsigned new_state )
{
unsigned old_state = setup->state;
if (old_state == new_state)
return;
- SETUP_DEBUG("%s old %d new %d\n", __FUNCTION__, old_state, new_state);
+ LP_DBG(DEBUG_SETUP, "%s old %d new %d\n", __FUNCTION__, old_state, new_state);
switch (new_state) {
case SETUP_ACTIVE:
if (old_state == SETUP_CLEARED)
execute_clears( setup );
else
- rasterize_bins( setup, TRUE );
+ lp_setup_rasterize_scene( setup, TRUE );
break;
}
lp_setup_flush( struct setup_context *setup,
unsigned flags )
{
- SETUP_DEBUG("%s\n", __FUNCTION__);
+ LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
- set_state( setup, SETUP_FLUSHED );
+ set_scene_state( setup, SETUP_FLUSHED );
}
void
lp_setup_bind_framebuffer( struct setup_context *setup,
- struct pipe_surface *color,
- struct pipe_surface *zstencil )
+ const struct pipe_framebuffer_state *fb )
{
- SETUP_DEBUG("%s\n", __FUNCTION__);
+ struct lp_scene *scene = lp_setup_get_current_scene(setup);
+
+ LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
- set_state( setup, SETUP_FLUSHED );
+ set_scene_state( setup, SETUP_FLUSHED );
- pipe_surface_reference( &setup->fb.cbuf, color );
- pipe_surface_reference( &setup->fb.zsbuf, zstencil );
+ /* re-get scene pointer, may have a new scene after flushing */
+ scene = lp_setup_get_current_scene(setup);
+
+ util_copy_framebuffer_state(&setup->fb, fb);
+
+ lp_scene_set_framebuffer_size(scene, setup->fb.width, setup->fb.height);
}
+
void
lp_setup_clear( struct setup_context *setup,
const float *color,
unsigned stencil,
unsigned flags )
{
+ struct lp_scene *scene = lp_setup_get_current_scene(setup);
unsigned i;
- SETUP_DEBUG("%s state %d\n", __FUNCTION__, setup->state);
+ LP_DBG(DEBUG_SETUP, "%s state %d\n", __FUNCTION__, setup->state);
if (flags & PIPE_CLEAR_COLOR) {
}
if (setup->state == SETUP_ACTIVE) {
- /* Add the clear to existing bins. In the unusual case where
- * both color and depth-stencilare being cleared, we could
- * discard the currently binned scene and start again, but I
- * don't see that as being a common usage.
+ /* Add the clear to existing scene. In the unusual case where
+ * both color and depth-stencil are being cleared when there's
+ * already been some rendering, we could discard the currently
+ * binned scene and start again, but I don't see that as being
+ * a common usage.
*/
if (flags & PIPE_CLEAR_COLOR)
- bin_everywhere( setup,
- lp_rast_clear_color,
- setup->clear.color );
+ lp_scene_bin_everywhere( scene,
+ lp_rast_clear_color,
+ setup->clear.color );
if (setup->clear.flags & PIPE_CLEAR_DEPTHSTENCIL)
- bin_everywhere( setup,
- lp_rast_clear_zstencil,
- setup->clear.zstencil );
+ lp_scene_bin_everywhere( scene,
+ lp_rast_clear_zstencil,
+ setup->clear.zstencil );
}
else {
/* Put ourselves into the 'pre-clear' state, specifically to try
* buffers which the app or state-tracker might issue
* separately.
*/
- set_state( setup, SETUP_CLEARED );
+ set_scene_state( setup, SETUP_CLEARED );
setup->clear.flags |= flags;
}
}
+/**
+ * Emit a fence.
+ */
+struct pipe_fence_handle *
+lp_setup_fence( struct setup_context *setup )
+{
+ struct lp_scene *scene = lp_setup_get_current_scene(setup);
+ const unsigned rank = lp_scene_get_num_bins( scene ); /* xxx */
+ struct lp_fence *fence = lp_fence_create(rank);
+
+ LP_DBG(DEBUG_SETUP, "%s rank %u\n", __FUNCTION__, rank);
+
+ set_scene_state( setup, SETUP_ACTIVE );
+
+ /* insert the fence into all command bins */
+ lp_scene_bin_everywhere( scene,
+ lp_rast_fence,
+ lp_rast_arg_fence(fence) );
+
+ return (struct pipe_fence_handle *) fence;
+}
+
void
lp_setup_set_triangle_state( struct setup_context *setup,
unsigned cull_mode,
- boolean ccw_is_frontface)
+ boolean ccw_is_frontface,
+ boolean scissor )
{
- SETUP_DEBUG("%s\n", __FUNCTION__);
+ LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
setup->ccw_is_frontface = ccw_is_frontface;
setup->cullmode = cull_mode;
setup->triangle = first_triangle;
+ setup->scissor_test = scissor;
}
const struct lp_shader_input *input,
unsigned nr )
{
- SETUP_DEBUG("%s %p %u\n", __FUNCTION__, (void *) input, nr);
+ LP_DBG(DEBUG_SETUP, "%s %p %u\n", __FUNCTION__, (void *) input, nr);
memcpy( setup->fs.input, input, nr * sizeof input[0] );
setup->fs.nr_inputs = nr;
}
void
-lp_setup_set_fs( struct setup_context *setup,
- struct lp_fragment_shader *fs )
+lp_setup_set_fs_functions( struct setup_context *setup,
+ lp_jit_frag_func jit_function0,
+ lp_jit_frag_func jit_function1,
+ boolean opaque )
{
- SETUP_DEBUG("%s %p\n", __FUNCTION__, (void *) fs);
+ LP_DBG(DEBUG_SETUP, "%s %p\n", __FUNCTION__, (void *) jit_function0);
/* FIXME: reference count */
- setup->fs.current.jit_function = fs ? fs->current->jit_function : NULL;
+ setup->fs.current.jit_function[0] = jit_function0;
+ setup->fs.current.jit_function[1] = jit_function1;
+ setup->fs.current.opaque = opaque;
+ setup->dirty |= LP_SETUP_NEW_FS;
}
void
lp_setup_set_fs_constants(struct setup_context *setup,
struct pipe_buffer *buffer)
{
- SETUP_DEBUG("%s %p\n", __FUNCTION__, (void *) buffer);
+ LP_DBG(DEBUG_SETUP, "%s %p\n", __FUNCTION__, (void *) buffer);
pipe_buffer_reference(&setup->constants.current, buffer);
lp_setup_set_alpha_ref_value( struct setup_context *setup,
float alpha_ref_value )
{
- SETUP_DEBUG("%s %f\n", __FUNCTION__, alpha_ref_value);
+ LP_DBG(DEBUG_SETUP, "%s %f\n", __FUNCTION__, alpha_ref_value);
if(setup->fs.current.jit_context.alpha_ref_value != alpha_ref_value) {
setup->fs.current.jit_context.alpha_ref_value = alpha_ref_value;
lp_setup_set_blend_color( struct setup_context *setup,
const struct pipe_blend_color *blend_color )
{
- SETUP_DEBUG("%s\n", __FUNCTION__);
+ LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
assert(blend_color);
}
}
+
+void
+lp_setup_set_scissor( struct setup_context *setup,
+ const struct pipe_scissor_state *scissor )
+{
+ LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
+
+ assert(scissor);
+
+ if (memcmp(&setup->scissor.current, scissor, sizeof(*scissor)) != 0) {
+ setup->scissor.current = *scissor; /* struct copy */
+ setup->dirty |= LP_SETUP_NEW_SCISSOR;
+ }
+}
+
+
+void
+lp_setup_set_flatshade_first( struct setup_context *setup,
+ boolean flatshade_first )
+{
+ setup->flatshade_first = flatshade_first;
+}
+
+
+void
+lp_setup_set_vertex_info( struct setup_context *setup,
+ struct vertex_info *vertex_info )
+{
+ /* XXX: just silently holding onto the pointer:
+ */
+ setup->vertex_info = vertex_info;
+}
+
+
+/**
+ * Called during state validation when LP_NEW_TEXTURE is set.
+ */
void
lp_setup_set_sampler_textures( struct setup_context *setup,
unsigned num, struct pipe_texture **texture)
{
- struct pipe_texture *dummy;
unsigned i;
- SETUP_DEBUG("%s\n", __FUNCTION__);
-
+ LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
assert(num <= PIPE_MAX_SAMPLERS);
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
struct pipe_texture *tex = i < num ? texture[i] : NULL;
- /* FIXME: hold on to the reference */
- dummy = NULL;
- pipe_texture_reference(&dummy, tex);
-
if(tex) {
struct llvmpipe_texture *lp_tex = llvmpipe_texture(tex);
struct lp_jit_texture *jit_tex;
jit_tex = &setup->fs.current.jit_context.textures[i];
- jit_tex->width = tex->width[0];
- jit_tex->height = tex->height[0];
+ jit_tex->width = tex->width0;
+ jit_tex->height = tex->height0;
jit_tex->stride = lp_tex->stride[0];
if(!lp_tex->dt)
jit_tex->data = lp_tex->data;
else
/* FIXME: map the rendertarget */
assert(0);
+
+ /* the scene references this texture */
+ {
+ struct lp_scene *scene = lp_setup_get_current_scene(setup);
+ lp_scene_texture_reference(scene, tex);
+ }
}
}
setup->dirty |= LP_SETUP_NEW_FS;
}
+
+/**
+ * Is the given texture referenced by any scene?
+ * Note: we have to check all scenes including any scenes currently
+ * being rendered and the current scene being built.
+ */
boolean
-lp_setup_is_texture_referenced( struct setup_context *setup,
+lp_setup_is_texture_referenced( const struct setup_context *setup,
const struct pipe_texture *texture )
{
- /* FIXME */
+ unsigned i;
+
+ /* check the render targets */
+ for (i = 0; i < setup->fb.nr_cbufs; i++) {
+ if (setup->fb.cbufs[i]->texture == texture)
+ return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
+ }
+ if (setup->fb.zsbuf && setup->fb.zsbuf->texture == texture) {
+ return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
+ }
+
+ /* check textures referenced by the scene */
+ for (i = 0; i < Elements(setup->scenes); i++) {
+ if (lp_scene_is_textured_referenced(setup->scenes[i], texture)) {
+ return PIPE_REFERENCED_FOR_READ;
+ }
+ }
+
return PIPE_UNREFERENCED;
}
-static INLINE void
-lp_setup_update_shader_state( struct setup_context *setup )
+/**
+ * Called by vbuf code when we're about to draw something.
+ */
+void
+lp_setup_update_state( struct setup_context *setup )
{
- SETUP_DEBUG("%s\n", __FUNCTION__);
+ struct lp_scene *scene = lp_setup_get_current_scene(setup);
+
+ LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
assert(setup->fs.current.jit_function);
uint8_t *stored;
unsigned i, j;
- stored = get_data_aligned(&setup->data, 4 * 16, 16);
+ stored = lp_scene_alloc_aligned(scene, 4 * 16, 16);
+ /* smear each blend color component across 16 ubyte elements */
for (i = 0; i < 4; ++i) {
uint8_t c = float_to_ubyte(setup->blend_color.current.color[i]);
for (j = 0; j < 16; ++j)
- stored[i*4 + j] = c;
+ stored[i*16 + j] = c;
}
setup->blend_color.stored = stored;
setup->dirty |= LP_SETUP_NEW_FS;
}
+ if (setup->dirty & LP_SETUP_NEW_SCISSOR) {
+ float *stored;
+
+ stored = lp_scene_alloc_aligned(scene, 4 * sizeof(int32_t), 16);
+
+ stored[0] = (float) setup->scissor.current.minx;
+ stored[1] = (float) setup->scissor.current.miny;
+ stored[2] = (float) setup->scissor.current.maxx;
+ stored[3] = (float) setup->scissor.current.maxy;
+
+ setup->scissor.stored = stored;
+
+ setup->fs.current.jit_context.scissor_xmin = stored[0];
+ setup->fs.current.jit_context.scissor_ymin = stored[1];
+ setup->fs.current.jit_context.scissor_xmax = stored[2];
+ setup->fs.current.jit_context.scissor_ymax = stored[3];
+
+ setup->dirty |= LP_SETUP_NEW_FS;
+ }
if(setup->dirty & LP_SETUP_NEW_CONSTANTS) {
struct pipe_buffer *buffer = setup->constants.current;
current_size) != 0) {
void *stored;
- stored = get_data(&setup->data, current_size);
+ stored = lp_scene_alloc(scene, current_size);
if(stored) {
memcpy(stored,
current_data,
memcmp(setup->fs.stored,
&setup->fs.current,
sizeof setup->fs.current) != 0) {
- struct lp_rast_state *stored;
-
- stored = get_data(&setup->data, sizeof *stored);
+ /* The fs state that's been stored in the scene is different from
+ * the new, current state. So allocate a new lp_rast_state object
+ * and append it to the bin's setup data buffer.
+ */
+ struct lp_rast_state *stored =
+ (struct lp_rast_state *) lp_scene_alloc(scene, sizeof *stored);
if(stored) {
memcpy(stored,
&setup->fs.current,
sizeof setup->fs.current);
setup->fs.stored = stored;
+
+ /* put the state-set command into all bins */
+ lp_scene_bin_state_command( scene,
+ lp_rast_set_state,
+ lp_rast_arg_state(setup->fs.stored) );
}
}
}
}
-/* Stubs for lines & points for now:
- */
-void
-lp_setup_point(struct setup_context *setup,
- const float (*v0)[4])
-{
- lp_setup_update_shader_state(setup);
- setup->point( setup, v0 );
-}
-
-void
-lp_setup_line(struct setup_context *setup,
- const float (*v0)[4],
- const float (*v1)[4])
-{
- lp_setup_update_shader_state(setup);
- setup->line( setup, v0, v1 );
-}
-
-void
-lp_setup_tri(struct setup_context *setup,
- const float (*v0)[4],
- const float (*v1)[4],
- const float (*v2)[4])
-{
- SETUP_DEBUG("%s\n", __FUNCTION__);
-
- lp_setup_update_shader_state(setup);
- setup->triangle( setup, v0, v1, v2 );
-}
-
+/* Only caller is lp_setup_vbuf_destroy()
+ */
void
lp_setup_destroy( struct setup_context *setup )
{
- unsigned i, j;
-
reset_context( setup );
pipe_buffer_reference(&setup->constants.current, NULL);
- for (i = 0; i < TILES_X; i++)
- for (j = 0; j < TILES_Y; j++)
- FREE(setup->tile[i][j].head);
-
- FREE(setup->data.head);
+ /* free the scenes in the 'empty' queue */
+ while (1) {
+ struct lp_scene *scene = lp_scene_dequeue(setup->empty_scenes, FALSE);
+ if (!scene)
+ break;
+ lp_scene_destroy(scene);
+ }
lp_rast_destroy( setup->rast );
+
FREE( setup );
}
/**
- * Create a new primitive tiling engine. Currently also creates a
- * rasterizer to use with it.
+ * Create a new primitive tiling engine. Plug it into the backend of
+ * the draw module. Currently also creates a rasterizer to use with
+ * it.
*/
struct setup_context *
-lp_setup_create( struct pipe_screen *screen )
+lp_setup_create( struct pipe_screen *screen,
+ struct draw_context *draw )
{
+ unsigned i;
struct setup_context *setup = CALLOC_STRUCT(setup_context);
- unsigned i, j;
- setup->rast = lp_rast_create( screen );
+ if (!setup)
+ return NULL;
+
+ lp_setup_init_vbuf(setup);
+
+ setup->empty_scenes = lp_scene_queue_create();
+ if (!setup->empty_scenes)
+ goto fail;
+
+ setup->rast = lp_rast_create( screen, setup->empty_scenes );
if (!setup->rast)
goto fail;
- for (i = 0; i < TILES_X; i++)
- for (j = 0; j < TILES_Y; j++)
- setup->tile[i][j].head =
- setup->tile[i][j].tail = CALLOC_STRUCT(cmd_block);
+ setup->vbuf = draw_vbuf_stage(draw, &setup->base);
+ if (!setup->vbuf)
+ goto fail;
+
+ draw_set_rasterize_stage(draw, setup->vbuf);
+ draw_set_render(draw, &setup->base);
- setup->data.head =
- setup->data.tail = CALLOC_STRUCT(data_block);
+ /* create some empty scenes */
+ for (i = 0; i < MAX_SCENES; i++) {
+ setup->scenes[i] = lp_scene_create();
+ lp_scene_enqueue(setup->empty_scenes, setup->scenes[i]);
+ }
setup->triangle = first_triangle;
setup->line = first_line;
return setup;
fail:
+ if (setup->rast)
+ lp_rast_destroy( setup->rast );
+
+ if (setup->vbuf)
+ ;
+
+ if (setup->empty_scenes)
+ lp_scene_queue_destroy(setup->empty_scenes);
+
FREE(setup);
return NULL;
}