/************************************************************************** * * Copyright 2007-2009 VMware, Inc. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * **************************************************************************/ #ifndef LP_SETUP_CONTEXT_H #define LP_SETUP_CONTEXT_H #include "lp_setup.h" #include "lp_rast.h" #include "lp_tile_soa.h" /* for TILE_SIZE */ /* We're limited to 2K by 2K for 32bit fixed point rasterization. * Will need a 64-bit version for larger framebuffers. */ #define MAXHEIGHT 2048 #define MAXWIDTH 2048 #define TILES_X (MAXWIDTH / TILE_SIZE) #define TILES_Y (MAXHEIGHT / TILE_SIZE) #define CMD_BLOCK_MAX 128 #define DATA_BLOCK_SIZE (16 * 1024 - sizeof(unsigned) - sizeof(void *)) #define LP_SETUP_NEW_FS 0x01 #define LP_SETUP_NEW_CONSTANTS 0x02 #define LP_SETUP_NEW_BLEND_COLOR 0x04 /* switch to a non-pointer value for this: */ typedef void (*lp_rast_cmd)( struct lp_rasterizer *, const union lp_rast_cmd_arg ); struct cmd_block { lp_rast_cmd cmd[CMD_BLOCK_MAX]; union lp_rast_cmd_arg arg[CMD_BLOCK_MAX]; unsigned count; struct cmd_block *next; }; struct data_block { ubyte data[DATA_BLOCK_SIZE]; unsigned used; struct data_block *next; }; struct cmd_block_list { struct cmd_block *head; struct cmd_block *tail; }; /** * For each screen tile we have one of these bins. */ struct cmd_bin { struct cmd_block_list commands; }; /** * This stores bulk data which is shared by all bins. * Examples include triangle data and state data. The commands in * the per-tile bins will point to chunks of data in this structure. */ struct data_block_list { struct data_block *head; struct data_block *tail; }; /** * Point/line/triangle setup context. * Note: "stored" below indicates data which is stored in the bins, * not arbitrary malloc'd memory. */ struct setup_context { struct lp_rasterizer *rast; /** * Per-bin data goes into the 'tile' bins. * Shared bin data goes into the 'data' buffer. * When there are multiple threads, will want to double-buffer the * bin arrays: */ struct cmd_bin tile[TILES_X][TILES_Y]; struct data_block_list data; /* size of framebuffer, in tiles */ unsigned tiles_x; unsigned tiles_y; boolean ccw_is_frontface; unsigned cullmode; struct { struct pipe_surface *cbuf; struct pipe_surface *zsbuf; unsigned width; unsigned height; } fb; struct { unsigned flags; union lp_rast_cmd_arg color; /**< lp_rast_clear_color() cmd */ union lp_rast_cmd_arg zstencil; /**< lp_rast_clear_zstencil() cmd */ } clear; enum { SETUP_FLUSHED, SETUP_CLEARED, SETUP_ACTIVE } state; struct { struct lp_shader_input input[PIPE_MAX_ATTRIBS]; unsigned nr_inputs; const struct lp_rast_state *stored; /**< what's in the bins */ struct lp_rast_state current; /**< currently set state */ } fs; /** fragment shader constants */ struct { struct pipe_buffer *current; unsigned stored_size; const void *stored_data; } constants; struct { struct pipe_blend_color current; uint8_t *stored; } blend_color; unsigned dirty; /**< bitmask of LP_SETUP_x bits */ void (*point)( struct setup_context *, const float (*v0)[4]); void (*line)( struct setup_context *, const float (*v0)[4], const float (*v1)[4]); void (*triangle)( struct setup_context *, const float (*v0)[4], const float (*v1)[4], const float (*v2)[4]); }; void lp_setup_choose_triangle( struct setup_context *setup ); void lp_setup_choose_line( struct setup_context *setup ); void lp_setup_choose_point( struct setup_context *setup ); void lp_setup_new_data_block( struct data_block_list *list ); void lp_setup_new_cmd_block( struct cmd_block_list *list ); /** * Allocate space for a command/data in the given block list. * Grow the block list if needed. */ static INLINE void *get_data( struct data_block_list *list, unsigned size) { if (list->tail->used + size > DATA_BLOCK_SIZE) { lp_setup_new_data_block( list ); } { struct data_block *tail = list->tail; ubyte *data = tail->data + tail->used; tail->used += size; return data; } } /* Put back data if we decide not to use it, eg. culled triangles. */ static INLINE void putback_data( struct data_block_list *list, unsigned size) { list->tail->used -= size; } static INLINE void *get_data_aligned( struct data_block_list *list, unsigned size, unsigned alignment ) { if (list->tail->used + size + alignment - 1 > DATA_BLOCK_SIZE) { lp_setup_new_data_block( list ); } { struct data_block *tail = list->tail; ubyte *data = tail->data + tail->used; unsigned offset = (((uintptr_t)data + alignment - 1) & ~(alignment - 1)) - (uintptr_t)data; tail->used += offset + size; return data + offset; } } /* Add a command to a given bin. */ static INLINE void bin_command( struct cmd_bin *bin, lp_rast_cmd cmd, union lp_rast_cmd_arg arg ) { struct cmd_block_list *list = &bin->commands; if (list->tail->count == CMD_BLOCK_MAX) { lp_setup_new_cmd_block( list ); } { struct cmd_block *tail = list->tail; unsigned i = tail->count; tail->cmd[i] = cmd; tail->arg[i] = arg; tail->count++; } } #endif