boolean svga_init_swtnl( struct svga_context *svga )
{
struct svga_screen *screen = svga_screen(svga->pipe.screen);
svga->swtnl.backend = svga_vbuf_render_create(svga);
if(!svga->swtnl.backend)
goto fail;
/*
* Create drawing context and plug our rendering stage into it.
*/
svga->swtnl.draw = draw_create(&svga->pipe);
if (svga->swtnl.draw == NULL)
goto fail;
draw_set_rasterize_stage(svga->swtnl.draw,
draw_vbuf_stage( svga->swtnl.draw, svga->swtnl.backend ));
draw_set_render(svga->swtnl.draw, svga->swtnl.backend);
svga->blitter = util_blitter_create(&svga->pipe);
if (!svga->blitter)
goto fail;
/* must be done before installing Draw stages */
util_blitter_cache_all_shaders(svga->blitter);
if (!screen->haveLineSmooth)
draw_install_aaline_stage(svga->swtnl.draw, &svga->pipe);
/* enable/disable line stipple stage depending on device caps */
draw_enable_line_stipple(svga->swtnl.draw, !screen->haveLineStipple);
/* always install AA point stage */
draw_install_aapoint_stage(svga->swtnl.draw, &svga->pipe);
/* Set wide line threshold above device limit (so we'll never really use it)
*/
draw_wide_line_threshold(svga->swtnl.draw,
MAX2(screen->maxLineWidth,
screen->maxLineWidthAA));
if (debug_get_bool_option("SVGA_SWTNL_FSE", FALSE))
draw_set_driver_clipping(svga->swtnl.draw, TRUE, TRUE, TRUE, FALSE);
return TRUE;
fail:
if (svga->blitter)
util_blitter_destroy(svga->blitter);
if (svga->swtnl.backend)
svga->swtnl.backend->destroy( svga->swtnl.backend );
if (svga->swtnl.draw)
draw_destroy( svga->swtnl.draw );
return FALSE;
}
void
nv30_draw_init(struct pipe_context *pipe)
{
struct nv30_context *nv30 = nv30_context(pipe);
struct vbuf_render *render;
struct draw_context *draw;
struct draw_stage *stage;
draw = draw_create(pipe);
if (!draw)
return;
render = nv30_render_create(nv30);
if (!render) {
draw_destroy(draw);
return;
}
stage = draw_vbuf_stage(draw, render);
if (!stage) {
render->destroy(render);
draw_destroy(draw);
return;
}
draw_set_render(draw, render);
draw_set_rasterize_stage(draw, stage);
draw_wide_line_threshold(draw, 10000000.f);
draw_wide_point_threshold(draw, 10000000.f);
draw_wide_point_sprites(draw, TRUE);
nv30->draw = draw;
}
static struct st_context *
st_create_context_priv( GLcontext *ctx, struct pipe_context *pipe )
{
uint i;
struct st_context *st = CALLOC_STRUCT( st_context );
ctx->st = st;
st->ctx = ctx;
st->pipe = pipe;
/* state tracker needs the VBO module */
_vbo_CreateContext(ctx);
#if FEATURE_feedback || FEATURE_drawpix
st->draw = draw_create(); /* for selection/feedback */
/* Disable draw options that might convert points/lines to tris, etc.
* as that would foul-up feedback/selection mode.
*/
draw_wide_line_threshold(st->draw, 1000.0f);
draw_wide_point_threshold(st->draw, 1000.0f);
draw_enable_line_stipple(st->draw, FALSE);
draw_enable_point_sprites(st->draw, FALSE);
#endif
st->dirty.mesa = ~0;
st->dirty.st = ~0;
st->cso_context = cso_create_context(pipe);
st_init_atoms( st );
st_init_bitmap(st);
st_init_clear(st);
st_init_draw( st );
st_init_generate_mipmap(st);
st_init_blit(st);
for (i = 0; i < PIPE_MAX_SAMPLERS; i++)
st->state.sampler_list[i] = &st->state.samplers[i];
/* we want all vertex data to be placed in buffer objects */
vbo_use_buffer_objects(ctx);
/* Need these flags:
*/
st->ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
st->ctx->FragmentProgram._UseTexEnvProgram = GL_TRUE;
st->ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
st->pixel_xfer.cache = _mesa_new_program_cache();
/* GL limits and extensions */
st_init_limits(st);
st_init_extensions(st);
return st;
}
void
st_init_draw(struct st_context *st)
{
struct gl_context *ctx = st->ctx;
vbo_set_draw_func(ctx, st_draw_vbo);
st->draw = draw_create(st->pipe); /* for selection/feedback */
/* Disable draw options that might convert points/lines to tris, etc.
* as that would foul-up feedback/selection mode.
*/
draw_wide_line_threshold(st->draw, 1000.0f);
draw_wide_point_threshold(st->draw, 1000.0f);
draw_enable_line_stipple(st->draw, FALSE);
draw_enable_point_sprites(st->draw, FALSE);
}
struct pipe_context *
nv30_create(struct pipe_screen *pscreen, void *priv)
{
struct nv30_screen *screen = nv30_screen(pscreen);
struct pipe_winsys *ws = pscreen->winsys;
struct nv30_context *nv30;
struct nouveau_winsys *nvws = screen->nvws;
nv30 = CALLOC(1, sizeof(struct nv30_context));
if (!nv30)
return NULL;
nv30->screen = screen;
nv30->nvws = nvws;
nv30->pipe.winsys = ws;
nv30->pipe.screen = pscreen;
nv30->pipe.priv = priv;
nv30->pipe.destroy = nv30_destroy;
nv30->pipe.draw_arrays = nv30_draw_arrays;
nv30->pipe.draw_elements = nv30_draw_elements;
nv30->pipe.clear = nv30_clear;
nv30->pipe.flush = nv30_flush;
nv30->pipe.is_texture_referenced = nouveau_is_texture_referenced;
nv30->pipe.is_buffer_referenced = nouveau_is_buffer_referenced;
screen->base.channel->user_private = nv30;
screen->base.channel->flush_notify = nv30_state_flush_notify;
nv30_init_query_functions(nv30);
nv30_init_surface_functions(nv30);
nv30_init_state_functions(nv30);
/* Create, configure, and install fallback swtnl path */
nv30->draw = draw_create(&nv30->pipe);
draw_wide_point_threshold(nv30->draw, 9999999.0);
draw_wide_line_threshold(nv30->draw, 9999999.0);
draw_enable_line_stipple(nv30->draw, FALSE);
draw_enable_point_sprites(nv30->draw, FALSE);
draw_set_rasterize_stage(nv30->draw, nv30_draw_render_stage(nv30));
return &nv30->pipe;
}
struct pipe_context *
nv04_create(struct pipe_screen *pscreen, unsigned pctx_id)
{
struct nv04_screen *screen = nv04_screen(pscreen);
struct pipe_winsys *ws = pscreen->winsys;
struct nv04_context *nv04;
struct nouveau_winsys *nvws = screen->nvws;
nv04 = CALLOC(1, sizeof(struct nv04_context));
if (!nv04)
return NULL;
nv04->screen = screen;
nv04->pctx_id = pctx_id;
nv04->nvws = nvws;
nv04->pipe.winsys = ws;
nv04->pipe.screen = pscreen;
nv04->pipe.destroy = nv04_destroy;
nv04->pipe.set_edgeflags = nv04_set_edgeflags;
nv04->pipe.draw_arrays = nv04_draw_arrays;
nv04->pipe.draw_elements = nv04_draw_elements;
nv04->pipe.clear = nv04_clear;
nv04->pipe.flush = nv04_flush;
nv04->pipe.is_texture_referenced = nouveau_is_texture_referenced;
nv04->pipe.is_buffer_referenced = nouveau_is_buffer_referenced;
nv04_init_surface_functions(nv04);
nv04_init_state_functions(nv04);
nv04->draw = draw_create();
assert(nv04->draw);
draw_wide_point_threshold(nv04->draw, 0.0);
draw_wide_line_threshold(nv04->draw, 0.0);
draw_enable_line_stipple(nv04->draw, FALSE);
draw_enable_point_sprites(nv04->draw, FALSE);
draw_set_rasterize_stage(nv04->draw, nv04_draw_vbuf_stage(nv04));
nv04_init_hwctx(nv04);
return &nv04->pipe;
}
/**
* Getter for the draw_context, so that initialization of it can happen only
* when needed (the TGSI exec machines take up quite a bit of memory).
*/
struct draw_context *
st_get_draw_context(struct st_context *st)
{
if (!st->draw) {
st->draw = draw_create(st->pipe);
if (!st->draw) {
_mesa_error(st->ctx, GL_OUT_OF_MEMORY, "feedback fallback allocation");
return NULL;
}
}
/* Disable draw options that might convert points/lines to tris, etc.
* as that would foul-up feedback/selection mode.
*/
draw_wide_line_threshold(st->draw, 1000.0f);
draw_wide_point_threshold(st->draw, 1000.0f);
draw_enable_line_stipple(st->draw, FALSE);
draw_enable_point_sprites(st->draw, FALSE);
return st->draw;
}
struct pipe_context* r300_create_context(struct pipe_screen* screen,
void *priv)
{
struct r300_context* r300 = CALLOC_STRUCT(r300_context);
struct r300_screen* r300screen = r300_screen(screen);
struct radeon_winsys *rws = r300screen->rws;
if (!r300)
return NULL;
r300->rws = rws;
r300->screen = r300screen;
r300->context.screen = screen;
r300->context.priv = priv;
r300->context.destroy = r300_destroy_context;
util_slab_create(&r300->pool_transfers,
sizeof(struct pipe_transfer), 64,
UTIL_SLAB_SINGLETHREADED);
r300->cs = rws->cs_create(rws, RING_GFX, r300_flush_callback, r300, NULL);
if (r300->cs == NULL)
goto fail;
if (!r300screen->caps.has_tcl) {
/* Create a Draw. This is used for SW TCL. */
r300->draw = draw_create(&r300->context);
if (r300->draw == NULL)
goto fail;
/* Enable our renderer. */
draw_set_rasterize_stage(r300->draw, r300_draw_stage(r300));
/* Disable converting points/lines to triangles. */
draw_wide_line_threshold(r300->draw, 10000000.f);
draw_wide_point_threshold(r300->draw, 10000000.f);
draw_wide_point_sprites(r300->draw, FALSE);
draw_enable_line_stipple(r300->draw, TRUE);
draw_enable_point_sprites(r300->draw, FALSE);
}
if (!r300_setup_atoms(r300))
goto fail;
r300_init_blit_functions(r300);
r300_init_flush_functions(r300);
r300_init_query_functions(r300);
r300_init_state_functions(r300);
r300_init_resource_functions(r300);
r300_init_render_functions(r300);
r300_init_states(&r300->context);
r300->context.create_video_codec = vl_create_decoder;
r300->context.create_video_buffer = vl_video_buffer_create;
r300->uploader = u_upload_create(&r300->context, 256 * 1024, 4,
PIPE_BIND_CUSTOM);
r300->blitter = util_blitter_create(&r300->context);
if (r300->blitter == NULL)
goto fail;
r300->blitter->draw_rectangle = r300_blitter_draw_rectangle;
/* The KIL opcode needs the first texture unit to be enabled
* on r3xx-r4xx. In order to calm down the CS checker, we bind this
* dummy texture there. */
if (!r300->screen->caps.is_r500) {
struct pipe_resource *tex;
struct pipe_resource rtempl = {{0}};
struct pipe_sampler_view vtempl = {{0}};
rtempl.target = PIPE_TEXTURE_2D;
rtempl.format = PIPE_FORMAT_I8_UNORM;
rtempl.usage = PIPE_USAGE_IMMUTABLE;
rtempl.width0 = 1;
rtempl.height0 = 1;
rtempl.depth0 = 1;
tex = screen->resource_create(screen, &rtempl);
u_sampler_view_default_template(&vtempl, tex, tex->format);
r300->texkill_sampler = (struct r300_sampler_view*)
r300->context.create_sampler_view(&r300->context, tex, &vtempl);
pipe_resource_reference(&tex, NULL);
}
if (r300screen->caps.has_tcl) {
struct pipe_resource vb;
memset(&vb, 0, sizeof(vb));
vb.target = PIPE_BUFFER;
vb.format = PIPE_FORMAT_R8_UNORM;
vb.usage = PIPE_USAGE_DEFAULT;
vb.width0 = sizeof(float) * 16;
vb.height0 = 1;
vb.depth0 = 1;
r300->dummy_vb.buffer = screen->resource_create(screen, &vb);
r300->context.set_vertex_buffers(&r300->context, 0, 1, &r300->dummy_vb);
}
{
struct pipe_depth_stencil_alpha_state dsa;
memset(&dsa, 0, sizeof(dsa));
dsa.depth.writemask = 1;
r300->dsa_decompress_zmask =
r300->context.create_depth_stencil_alpha_state(&r300->context,
&dsa);
}
r300->hyperz_time_of_last_flush = os_time_get();
/* Register allocator state */
rc_init_regalloc_state(&r300->fs_regalloc_state);
/* Print driver info. */
#ifdef DEBUG
{
#else
if (DBG_ON(r300, DBG_INFO)) {
#endif
fprintf(stderr,
"r300: DRM version: %d.%d.%d, Name: %s, ID: 0x%04x, GB: %d, Z: %d\n"
"r300: GART size: %"PRIu64" MB, VRAM size: %"PRIu64" MB\n"
"r300: AA compression RAM: %s, Z compression RAM: %s, HiZ RAM: %s\n",
r300->screen->info.drm_major,
r300->screen->info.drm_minor,
r300->screen->info.drm_patchlevel,
screen->get_name(screen),
r300->screen->info.pci_id,
r300->screen->info.r300_num_gb_pipes,
r300->screen->info.r300_num_z_pipes,
r300->screen->info.gart_size >> 20,
r300->screen->info.vram_size >> 20,
"YES", /* XXX really? */
r300->screen->caps.zmask_ram ? "YES" : "NO",
r300->screen->caps.hiz_ram ? "YES" : "NO");
}
return &r300->context;
fail:
r300_destroy_context(&r300->context);
return NULL;
}
struct pipe_context *
cell_create_context(struct pipe_screen *screen,
void *priv )
{
struct cell_context *cell;
uint i;
/* some fields need to be 16-byte aligned, so align the whole object */
cell = (struct cell_context*) align_malloc(sizeof(struct cell_context), 16);
if (!cell)
return NULL;
memset(cell, 0, sizeof(*cell));
cell->winsys = NULL; /* XXX: fixme - get this from screen? */
cell->pipe.winsys = NULL;
cell->pipe.screen = screen;
cell->pipe.priv = priv;
cell->pipe.destroy = cell_destroy_context;
cell->pipe.clear = cell_clear;
cell->pipe.flush = cell_flush;
#if 0
cell->pipe.begin_query = cell_begin_query;
cell->pipe.end_query = cell_end_query;
cell->pipe.wait_query = cell_wait_query;
#endif
cell_init_draw_functions(cell);
cell_init_state_functions(cell);
cell_init_shader_functions(cell);
cell_init_surface_functions(cell);
cell_init_vertex_functions(cell);
cell_init_texture_transfer_funcs(cell);
cell->draw = cell_draw_create(cell);
/* Create cache of fragment ops generated code */
cell->fragment_ops_cache =
util_new_keymap(sizeof(struct cell_fragment_ops_key), ~0, NULL);
cell_init_vbuf(cell);
draw_set_rasterize_stage(cell->draw, cell->vbuf);
/* convert all points/lines to tris for the time being */
draw_wide_point_threshold(cell->draw, 0.0);
draw_wide_line_threshold(cell->draw, 0.0);
/* get env vars or read config file to get debug flags */
cell->debug_flags = debug_get_flags_option("CELL_DEBUG",
cell_debug_flags,
0 );
for (i = 0; i < CELL_NUM_BUFFERS; i++)
cell_fence_init(&cell->fenced_buffers[i].fence);
/*
* SPU stuff
*/
/* This call only works with SDK 3.0. Anyone still using 2.1??? */
cell->num_cells = spe_cpu_info_get(SPE_COUNT_PHYSICAL_CPU_NODES, -1);
cell->num_spus = spe_cpu_info_get(SPE_COUNT_USABLE_SPES, -1);
if (cell->debug_flags) {
printf("Cell: found %d Cell(s) with %u SPUs\n",
cell->num_cells, cell->num_spus);
}
if (getenv("CELL_NUM_SPUS")) {
cell->num_spus = atoi(getenv("CELL_NUM_SPUS"));
assert(cell->num_spus > 0);
}
cell_start_spus(cell);
cell_init_batch_buffers(cell);
/* make sure SPU initializations are done before proceeding */
cell_flush_int(cell, CELL_FLUSH_WAIT);
return &cell->pipe;
}
struct pipe_context *
llvmpipe_create_context( struct pipe_screen *screen, void *priv )
{
struct llvmpipe_context *llvmpipe;
llvmpipe = align_malloc(sizeof(struct llvmpipe_context), 16);
if (!llvmpipe)
return NULL;
util_init_math();
memset(llvmpipe, 0, sizeof *llvmpipe);
make_empty_list(&llvmpipe->fs_variants_list);
make_empty_list(&llvmpipe->setup_variants_list);
llvmpipe->pipe.screen = screen;
llvmpipe->pipe.priv = priv;
/* Init the pipe context methods */
llvmpipe->pipe.destroy = llvmpipe_destroy;
llvmpipe->pipe.set_framebuffer_state = llvmpipe_set_framebuffer_state;
llvmpipe->pipe.clear = llvmpipe_clear;
llvmpipe->pipe.flush = do_flush;
llvmpipe->pipe.render_condition = llvmpipe_render_condition;
llvmpipe_init_blend_funcs(llvmpipe);
llvmpipe_init_clip_funcs(llvmpipe);
llvmpipe_init_draw_funcs(llvmpipe);
llvmpipe_init_sampler_funcs(llvmpipe);
llvmpipe_init_query_funcs( llvmpipe );
llvmpipe_init_vertex_funcs(llvmpipe);
llvmpipe_init_so_funcs(llvmpipe);
llvmpipe_init_fs_funcs(llvmpipe);
llvmpipe_init_vs_funcs(llvmpipe);
llvmpipe_init_gs_funcs(llvmpipe);
llvmpipe_init_rasterizer_funcs(llvmpipe);
llvmpipe_init_context_resource_funcs( &llvmpipe->pipe );
llvmpipe_init_surface_functions(llvmpipe);
/*
* Create drawing context and plug our rendering stage into it.
*/
llvmpipe->draw = draw_create(&llvmpipe->pipe);
if (!llvmpipe->draw)
goto fail;
/* FIXME: devise alternative to draw_texture_samplers */
llvmpipe->setup = lp_setup_create( &llvmpipe->pipe,
llvmpipe->draw );
if (!llvmpipe->setup)
goto fail;
/* plug in AA line/point stages */
draw_install_aaline_stage(llvmpipe->draw, &llvmpipe->pipe);
draw_install_aapoint_stage(llvmpipe->draw, &llvmpipe->pipe);
draw_install_pstipple_stage(llvmpipe->draw, &llvmpipe->pipe);
/* convert points and lines into triangles:
* (otherwise, draw points and lines natively)
*/
draw_wide_point_sprites(llvmpipe->draw, FALSE);
draw_enable_point_sprites(llvmpipe->draw, FALSE);
draw_wide_point_threshold(llvmpipe->draw, 10000.0);
draw_wide_line_threshold(llvmpipe->draw, 10000.0);
lp_reset_counters();
return &llvmpipe->pipe;
fail:
llvmpipe_destroy(&llvmpipe->pipe);
return NULL;
}