X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fi915%2Fi915_state.c;h=d8a5edfebf40b23810358ce01c2d3326655dce47;hb=76f9eae7bb2b503e46ebe2847619bba1cec393b6;hp=cd963e4df75f5fb64f801f51966f7cb4ef2f68b5;hpb=0bd1cbcd0d28dbadfb0c3e1f8b048a18b56bc72c;p=mesa.git diff --git a/src/gallium/drivers/i915/i915_state.c b/src/gallium/drivers/i915/i915_state.c index cd963e4df75..d8a5edfebf4 100644 --- a/src/gallium/drivers/i915/i915_state.c +++ b/src/gallium/drivers/i915/i915_state.c @@ -1,6 +1,6 @@ /************************************************************************** * - * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * Copyright 2007 VMware, Inc. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a @@ -18,21 +18,23 @@ * 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 TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * 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. * **************************************************************************/ -/* Authors: Keith Whitwell +/* Authors: Keith Whitwell */ #include "draw/draw_context.h" +#include "util/u_helpers.h" #include "util/u_inlines.h" #include "util/u_math.h" #include "util/u_memory.h" +#include "util/u_transfer.h" #include "tgsi/tgsi_parse.h" #include "i915_context.h" @@ -40,6 +42,7 @@ #include "i915_state_inlines.h" #include "i915_fpc.h" #include "i915_resource.h" +#include "i915_state.h" /* The i915 (and related graphics cores) do not support GL_CLAMP. The * Intel drivers for "other operating systems" implement GL_CLAMP as @@ -57,10 +60,8 @@ translate_wrap_mode(unsigned wrap) return TEXCOORDMODE_CLAMP_EDGE; case PIPE_TEX_WRAP_CLAMP_TO_BORDER: return TEXCOORDMODE_CLAMP_BORDER; - /* - case PIPE_TEX_WRAP_MIRRORED_REPEAT: + case PIPE_TEX_WRAP_MIRROR_REPEAT: return TEXCOORDMODE_MIRROR; - */ default: return TEXCOORDMODE_WRAP; } @@ -94,7 +95,6 @@ static unsigned translate_mip_filter( unsigned filter ) } } - /* None of this state is actually used for anything yet. */ static void * @@ -113,14 +113,14 @@ i915_create_blend_state(struct pipe_context *pipe, unsigned dstA = blend->rt[0].alpha_dst_factor; /* Special handling for MIN/MAX filter modes handled at - * state_tracker level. + * frontend level. */ if (srcA != srcRGB || - dstA != dstRGB || - eqA != eqRGB) { + dstA != dstRGB || + eqA != eqRGB) { - cso_data->iab = (_3DSTATE_INDEPENDENT_ALPHA_BLEND_CMD | + cso_data->iab = (_3DSTATE_INDEPENDENT_ALPHA_BLEND_CMD | IAB_MODIFY_ENABLE | IAB_ENABLE | IAB_MODIFY_FUNC | @@ -131,7 +131,7 @@ i915_create_blend_state(struct pipe_context *pipe, (i915_translate_blend_func(eqA) << IAB_FUNC_SHIFT)); } else { - cso_data->iab = (_3DSTATE_INDEPENDENT_ALPHA_BLEND_CMD | + cso_data->iab = (_3DSTATE_INDEPENDENT_ALPHA_BLEND_CMD | IAB_MODIFY_ENABLE | 0); } @@ -147,6 +147,7 @@ i915_create_blend_state(struct pipe_context *pipe, if (blend->dither) cso_data->LIS5 |= S5_COLOR_DITHER_ENABLE; + /* We potentially do some fixup at emission for non-BGRA targets */ if ((blend->rt[0].colormask & PIPE_MASK_R) == 0) cso_data->LIS5 |= S5_WRITEDISABLE_RED; @@ -177,7 +178,9 @@ static void i915_bind_blend_state(struct pipe_context *pipe, void *blend) { struct i915_context *i915 = i915_context(pipe); - draw_flush(i915->draw); + + if (i915->blend == blend) + return; i915->blend = (struct i915_blend_state*)blend; @@ -194,7 +197,9 @@ static void i915_set_blend_color( struct pipe_context *pipe, const struct pipe_blend_color *blend_color ) { struct i915_context *i915 = i915_context(pipe); - draw_flush(i915->draw); + + if (!blend_color) + return; i915->blend_color = *blend_color; @@ -205,7 +210,6 @@ static void i915_set_stencil_ref( struct pipe_context *pipe, const struct pipe_stencil_ref *stencil_ref ) { struct i915_context *i915 = i915_context(pipe); - draw_flush(i915->draw); i915->stencil_ref = *stencil_ref; @@ -223,12 +227,12 @@ i915_create_sampler_state(struct pipe_context *pipe, unsigned minFilt, magFilt; unsigned mipFilt; - cso->templ = sampler; + cso->templ = *sampler; mipFilt = translate_mip_filter(sampler->min_mip_filter); minFilt = translate_img_filter( sampler->min_img_filter ); magFilt = translate_img_filter( sampler->mag_img_filter ); - + if (sampler->max_anisotropy > 1) minFilt = magFilt = FILTER_ANISOTROPIC; @@ -244,10 +248,10 @@ i915_create_sampler_state(struct pipe_context *pipe, /* Shadow: */ - if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) + if (sampler->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) { cso->state[0] |= (SS2_SHADOW_ENABLE | - i915_translate_compare_func(sampler->compare_func)); + i915_translate_shadow_compare_func(sampler->compare_func)); minFilt = FILTER_4X4_FLAT; magFilt = FILTER_4X4_FLAT; @@ -272,47 +276,106 @@ i915_create_sampler_state(struct pipe_context *pipe, maxlod = CLAMP(maxlod, 0, 16 * 11); if (minlod > maxlod) - maxlod = minlod; + maxlod = minlod; cso->minlod = minlod; cso->maxlod = maxlod; } { - ubyte r = float_to_ubyte(sampler->border_color[0]); - ubyte g = float_to_ubyte(sampler->border_color[1]); - ubyte b = float_to_ubyte(sampler->border_color[2]); - ubyte a = float_to_ubyte(sampler->border_color[3]); + ubyte r = float_to_ubyte(sampler->border_color.f[0]); + ubyte g = float_to_ubyte(sampler->border_color.f[1]); + ubyte b = float_to_ubyte(sampler->border_color.f[2]); + ubyte a = float_to_ubyte(sampler->border_color.f[3]); cso->state[2] = I915PACKCOLOR8888(r, g, b, a); } return cso; } -static void i915_bind_sampler_states(struct pipe_context *pipe, - unsigned num, void **sampler) +static void +i915_bind_vertex_sampler_states(struct pipe_context *pipe, + unsigned start, + unsigned num, + void **samplers) { struct i915_context *i915 = i915_context(pipe); unsigned i; - assert(num <= PIPE_MAX_SAMPLERS); + assert(start + num <= ARRAY_SIZE(i915->vertex_samplers)); /* Check for no-op */ - if (num == i915->num_samplers && - !memcmp(i915->sampler, sampler, num * sizeof(void *))) + if (num == i915->num_vertex_samplers && + !memcmp(i915->vertex_samplers + start, samplers, + num * sizeof(void *))) return; - draw_flush(i915->draw); + for (i = 0; i < num; ++i) + i915->vertex_samplers[i + start] = samplers[i]; + + /* find highest non-null samplers[] entry */ + { + unsigned j = MAX2(i915->num_vertex_samplers, start + num); + while (j > 0 && i915->vertex_samplers[j - 1] == NULL) + j--; + i915->num_vertex_samplers = j; + } + + draw_set_samplers(i915->draw, + PIPE_SHADER_VERTEX, + i915->vertex_samplers, + i915->num_vertex_samplers); +} + + + +static void i915_bind_fragment_sampler_states(struct pipe_context *pipe, + unsigned start, + unsigned num, + void **samplers) +{ + struct i915_context *i915 = i915_context(pipe); + unsigned i; + + /* Check for no-op */ + if (num == i915->num_samplers && + !memcmp(i915->fragment_sampler + start, samplers, + num * sizeof(void *))) + return; for (i = 0; i < num; ++i) - i915->sampler[i] = sampler[i]; - for (i = num; i < PIPE_MAX_SAMPLERS; ++i) - i915->sampler[i] = NULL; + i915->fragment_sampler[i + start] = samplers[i]; - i915->num_samplers = num; + /* find highest non-null samplers[] entry */ + { + unsigned j = MAX2(i915->num_samplers, start + num); + while (j > 0 && i915->fragment_sampler[j - 1] == NULL) + j--; + i915->num_samplers = j; + } i915->dirty |= I915_NEW_SAMPLER; } + +static void +i915_bind_sampler_states(struct pipe_context *pipe, + enum pipe_shader_type shader, + unsigned start, unsigned num_samplers, + void **samplers) +{ + switch (shader) { + case PIPE_SHADER_VERTEX: + i915_bind_vertex_sampler_states(pipe, start, num_samplers, samplers); + break; + case PIPE_SHADER_FRAGMENT: + i915_bind_fragment_sampler_states(pipe, start, num_samplers, samplers); + break; + default: + ; + } +} + + static void i915_delete_sampler_state(struct pipe_context *pipe, void *sampler) { @@ -320,6 +383,77 @@ static void i915_delete_sampler_state(struct pipe_context *pipe, } +/** + * Called before drawing VBO to map vertex samplers and hand them to draw + */ +void +i915_prepare_vertex_sampling(struct i915_context *i915) +{ + struct i915_winsys *iws = i915->iws; + unsigned i,j; + uint32_t row_stride[PIPE_MAX_TEXTURE_LEVELS]; + uint32_t img_stride[PIPE_MAX_TEXTURE_LEVELS]; + uint32_t mip_offsets[PIPE_MAX_TEXTURE_LEVELS]; + unsigned num = i915->num_vertex_sampler_views; + struct pipe_sampler_view **views = i915->vertex_sampler_views; + + assert(num <= PIPE_MAX_SAMPLERS); + if (!num) + return; + + for (i = 0; i < PIPE_MAX_SAMPLERS; i++) { + struct pipe_sampler_view *view = i < num ? views[i] : NULL; + + if (view) { + struct pipe_resource *tex = view->texture; + struct i915_texture *i915_tex = i915_texture(tex); + ubyte *addr; + + /* We're referencing the texture's internal data, so save a + * reference to it. + */ + pipe_resource_reference(&i915->mapped_vs_tex[i], tex); + + i915->mapped_vs_tex_buffer[i] = i915_tex->buffer; + addr = iws->buffer_map(iws, + i915_tex->buffer, + FALSE /* read only */); + + /* Setup array of mipmap level pointers */ + /* FIXME: handle 3D textures? */ + for (j = view->u.tex.first_level; j <= tex->last_level; j++) { + mip_offsets[j] = i915_texture_offset(i915_tex, j , 0 /* FIXME depth */); + row_stride[j] = i915_tex->stride; + img_stride[j] = 0; /* FIXME */ + } + + draw_set_mapped_texture(i915->draw, + PIPE_SHADER_VERTEX, + i, + tex->width0, tex->height0, tex->depth0, + view->u.tex.first_level, tex->last_level, + 0, 0, addr, + row_stride, img_stride, mip_offsets); + } else + i915->mapped_vs_tex[i] = NULL; + } +} + +void +i915_cleanup_vertex_sampling(struct i915_context *i915) +{ + struct i915_winsys *iws = i915->iws; + unsigned i; + for (i = 0; i < ARRAY_SIZE(i915->mapped_vs_tex); i++) { + if (i915->mapped_vs_tex_buffer[i]) { + iws->buffer_unmap(iws, i915->mapped_vs_tex_buffer[i]); + pipe_resource_reference(&i915->mapped_vs_tex[i], NULL); + } + } +} + + + /** XXX move someday? Or consolidate all these simple state setters * into one file. */ @@ -398,7 +532,7 @@ i915_create_depth_stencil_state(struct pipe_context *pipe, (func << S6_DEPTH_TEST_FUNC_SHIFT)); if (depth_stencil->depth.writemask) - cso->depth_LIS6 |= S6_DEPTH_WRITE_ENABLE; + cso->depth_LIS6 |= S6_DEPTH_WRITE_ENABLE; } if (depth_stencil->alpha.enabled) { @@ -417,7 +551,9 @@ static void i915_bind_depth_stencil_state(struct pipe_context *pipe, void *depth_stencil) { struct i915_context *i915 = i915_context(pipe); - draw_flush(i915->draw); + + if (i915->depth_stencil == depth_stencil) + return; i915->depth_stencil = (const struct i915_depth_stencil_state *)depth_stencil; @@ -431,11 +567,12 @@ static void i915_delete_depth_stencil_state(struct pipe_context *pipe, } -static void i915_set_scissor_state( struct pipe_context *pipe, +static void i915_set_scissor_states( struct pipe_context *pipe, + unsigned start_slot, + unsigned num_scissors, const struct pipe_scissor_state *scissor ) { struct i915_context *i915 = i915_context(pipe); - draw_flush(i915->draw); memcpy( &i915->scissor, scissor, sizeof(*scissor) ); i915->dirty |= I915_NEW_SCISSOR; @@ -458,6 +595,7 @@ i915_create_fs_state(struct pipe_context *pipe, if (!ifs) return NULL; + ifs->draw_data = draw_create_fragment_shader(i915->draw, templ); ifs->state.tokens = tgsi_dup_tokens(templ->tokens); tgsi_scan_shader(templ->tokens, &ifs->info); @@ -472,10 +610,14 @@ static void i915_bind_fs_state(struct pipe_context *pipe, void *shader) { struct i915_context *i915 = i915_context(pipe); - draw_flush(i915->draw); + + if (i915->fs == shader) + return; i915->fs = (struct i915_fragment_shader*) shader; + draw_bind_fragment_shader(i915->draw, (i915->fs ? i915->fs->draw_data : NULL)); + i915->dirty |= I915_NEW_FS; } @@ -484,11 +626,16 @@ void i915_delete_fs_state(struct pipe_context *pipe, void *shader) { struct i915_fragment_shader *ifs = (struct i915_fragment_shader *) shader; - if (ifs->program) - FREE(ifs->program); - ifs->program_len = 0; + FREE(ifs->decl); + ifs->decl = NULL; + FREE(ifs->program); + ifs->program = NULL; FREE((struct tgsi_token *)ifs->state.tokens); + ifs->state.tokens = NULL; + + ifs->program_len = 0; + ifs->decl_len = 0; FREE(ifs); } @@ -508,6 +655,11 @@ static void i915_bind_vs_state(struct pipe_context *pipe, void *shader) { struct i915_context *i915 = i915_context(pipe); + if (i915->vs == shader) + return; + + i915->vs = shader; + /* just pass-through to draw module */ draw_bind_vertex_shader(i915->draw, (struct draw_vertex_shader *) shader); @@ -523,36 +675,58 @@ static void i915_delete_vs_state(struct pipe_context *pipe, void *shader) } static void i915_set_constant_buffer(struct pipe_context *pipe, - uint shader, uint index, - struct pipe_resource *buf) + enum pipe_shader_type shader, uint index, + const struct pipe_constant_buffer *cb) { struct i915_context *i915 = i915_context(pipe); - draw_flush(i915->draw); - - assert(shader < PIPE_SHADER_TYPES); - assert(index == 0); - - /* Make a copy of shader constants. - * During fragment program translation we may add additional - * constants to the array. - * - * We want to consider the situation where some user constants - * (ex: a material color) may change frequently but the shader program - * stays the same. In that case we should only be updating the first - * N constants, leaving any extras from shader translation alone. - */ - if (buf) { - struct i915_buffer *ir = i915_buffer(buf); - memcpy(i915->current.constants[shader], ir->data, ir->b.b.width0); - i915->current.num_user_constants[shader] = (ir->b.b.width0 / - 4 * sizeof(float)); + struct pipe_resource *buf = cb ? cb->buffer : NULL; + unsigned new_num = 0; + boolean diff = TRUE; + + /* XXX don't support geom shaders now */ + if (shader == PIPE_SHADER_GEOMETRY) + return; + + if (cb && cb->user_buffer) { + buf = i915_user_buffer_create(pipe->screen, (void *) cb->user_buffer, + cb->buffer_size, + PIPE_BIND_CONSTANT_BUFFER); } - else { - i915->current.num_user_constants[shader] = 0; + + /* if we have a new buffer compare it with the old one */ + if (buf) { + struct i915_buffer *ibuf = i915_buffer(buf); + struct pipe_resource *old_buf = i915->constants[shader]; + struct i915_buffer *old = old_buf ? i915_buffer(old_buf) : NULL; + unsigned old_num = i915->current.num_user_constants[shader]; + + new_num = ibuf->b.b.width0 / 4 * sizeof(float); + + if (old_num == new_num) { + if (old_num == 0) + diff = FALSE; +#if 0 + /* XXX no point in running this code since st/mesa only uses user buffers */ + /* Can't compare the buffer data since they are userbuffers */ + else if (old && old->free_on_destroy) + diff = memcmp(old->data, ibuf->data, ibuf->b.b.width0); +#else + (void)old; +#endif + } + } else { + diff = i915->current.num_user_constants[shader] != 0; } + pipe_resource_reference(&i915->constants[shader], buf); + i915->current.num_user_constants[shader] = new_num; - i915->dirty |= I915_NEW_CONSTANTS; + if (diff) + i915->dirty |= shader == PIPE_SHADER_VERTEX ? I915_NEW_VS_CONSTANTS : I915_NEW_FS_CONSTANTS; + + if (cb && cb->user_buffer) { + pipe_resource_reference(&buf, NULL); + } } @@ -570,22 +744,87 @@ static void i915_set_fragment_sampler_views(struct pipe_context *pipe, !memcmp(i915->fragment_sampler_views, views, num * sizeof(struct pipe_sampler_view *))) return; - /* Fixes wrong texture in texobj with VBUF */ - draw_flush(i915->draw); - - for (i = 0; i < num; i++) - pipe_sampler_view_reference(&i915->fragment_sampler_views[i], - views[i]); + for (i = 0; i < num; i++) { + pipe_sampler_view_reference(&i915->fragment_sampler_views[i], views[i]); + } for (i = num; i < i915->num_fragment_sampler_views; i++) - pipe_sampler_view_reference(&i915->fragment_sampler_views[i], - NULL); + pipe_sampler_view_reference(&i915->fragment_sampler_views[i], NULL); i915->num_fragment_sampler_views = num; i915->dirty |= I915_NEW_SAMPLER_VIEW; } +static void +i915_set_vertex_sampler_views(struct pipe_context *pipe, + unsigned num, + struct pipe_sampler_view **views) +{ + struct i915_context *i915 = i915_context(pipe); + uint i; + + assert(num <= ARRAY_SIZE(i915->vertex_sampler_views)); + + /* Check for no-op */ + if (num == i915->num_vertex_sampler_views && + !memcmp(i915->vertex_sampler_views, views, num * sizeof(struct pipe_sampler_view *))) { + return; + } + + for (i = 0; i < ARRAY_SIZE(i915->vertex_sampler_views); i++) { + struct pipe_sampler_view *view = i < num ? views[i] : NULL; + + pipe_sampler_view_reference(&i915->vertex_sampler_views[i], view); + } + + i915->num_vertex_sampler_views = num; + + draw_set_sampler_views(i915->draw, + PIPE_SHADER_VERTEX, + i915->vertex_sampler_views, + i915->num_vertex_sampler_views); +} + + +static void +i915_set_sampler_views(struct pipe_context *pipe, enum pipe_shader_type shader, + unsigned start, unsigned num, + struct pipe_sampler_view **views) +{ + assert(start == 0); + switch (shader) { + case PIPE_SHADER_FRAGMENT: + i915_set_fragment_sampler_views(pipe, num, views); + break; + case PIPE_SHADER_VERTEX: + i915_set_vertex_sampler_views(pipe, num, views); + break; + default: + ; + } +} + + +struct pipe_sampler_view * +i915_create_sampler_view_custom(struct pipe_context *pipe, + struct pipe_resource *texture, + const struct pipe_sampler_view *templ, + unsigned width0, + unsigned height0) +{ + struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view); + + if (view) { + *view = *templ; + view->reference.count = 1; + view->texture = NULL; + pipe_resource_reference(&view->texture, texture); + view->context = pipe; + } + + return view; +} static struct pipe_sampler_view * i915_create_sampler_view(struct pipe_context *pipe, @@ -621,13 +860,12 @@ static void i915_set_framebuffer_state(struct pipe_context *pipe, struct i915_context *i915 = i915_context(pipe); int i; - draw_flush(i915->draw); - i915->framebuffer.width = fb->width; i915->framebuffer.height = fb->height; i915->framebuffer.nr_cbufs = fb->nr_cbufs; for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) { - pipe_surface_reference(&i915->framebuffer.cbufs[i], fb->cbufs[i]); + pipe_surface_reference(&i915->framebuffer.cbufs[i], + i < fb->nr_cbufs ? fb->cbufs[i] : NULL); } pipe_surface_reference(&i915->framebuffer.zsbuf, fb->zsbuf); @@ -640,7 +878,8 @@ static void i915_set_clip_state( struct pipe_context *pipe, const struct pipe_clip_state *clip ) { struct i915_context *i915 = i915_context(pipe); - draw_flush(i915->draw); + + i915->clip = *clip; draw_set_clip_state(i915->draw, clip); @@ -649,10 +888,12 @@ static void i915_set_clip_state( struct pipe_context *pipe, -/* Called when driver state tracker notices changes to the viewport +/* Called when gallium frontends notice changes to the viewport * matrix: */ -static void i915_set_viewport_state( struct pipe_context *pipe, +static void i915_set_viewport_states( struct pipe_context *pipe, + unsigned start_slot, + unsigned num_viewports, const struct pipe_viewport_state *viewport ) { struct i915_context *i915 = i915_context(pipe); @@ -660,7 +901,8 @@ static void i915_set_viewport_state( struct pipe_context *pipe, i915->viewport = *viewport; /* struct copy */ /* pass the viewport info to the draw module */ - draw_set_viewport_state(i915->draw, &i915->viewport); + draw_set_viewport_states(i915->draw, start_slot, num_viewports, + &i915->viewport); i915->dirty |= I915_NEW_VIEWPORT; } @@ -672,8 +914,7 @@ i915_create_rasterizer_state(struct pipe_context *pipe, { struct i915_rasterizer_state *cso = CALLOC_STRUCT( i915_rasterizer_state ); - cso->templ = rasterizer; - cso->color_interp = rasterizer->flatshade ? INTERP_CONSTANT : INTERP_LINEAR; + cso->templ = *rasterizer; cso->light_twoside = rasterizer->light_twoside; cso->ds[0].u = _3DSTATE_DEPTH_OFFSET_SCALE; cso->ds[1].f = rasterizer->offset_scale; @@ -739,11 +980,14 @@ static void i915_bind_rasterizer_state( struct pipe_context *pipe, { struct i915_context *i915 = i915_context(pipe); + if (i915->rasterizer == raster) + return; + i915->rasterizer = (struct i915_rasterizer_state *)raster; /* pass-through to draw module */ draw_set_rasterizer_state(i915->draw, - (i915->rasterizer ? i915->rasterizer->templ : NULL), + (i915->rasterizer ? &(i915->rasterizer->templ) : NULL), raster); i915->dirty |= I915_NEW_RASTERIZER; @@ -756,20 +1000,18 @@ static void i915_delete_rasterizer_state(struct pipe_context *pipe, } static void i915_set_vertex_buffers(struct pipe_context *pipe, - unsigned count, + unsigned start_slot, unsigned count, const struct pipe_vertex_buffer *buffers) { struct i915_context *i915 = i915_context(pipe); - /* Because we change state before the draw_set_vertex_buffers call - * we need a flush here, just to be sure. - */ - draw_flush(i915->draw); + struct draw_context *draw = i915->draw; - memcpy(i915->vertex_buffer, buffers, count * sizeof(buffers[0])); - i915->num_vertex_buffers = count; + util_set_vertex_buffers_count(i915->vertex_buffers, + &i915->nr_vertex_buffers, + buffers, start_slot, count); /* pass-through to draw module */ - draw_set_vertex_buffers(i915->draw, count, buffers); + draw_set_vertex_buffers(draw, start_slot, count, buffers); } static void * @@ -794,10 +1036,10 @@ i915_bind_vertex_elements_state(struct pipe_context *pipe, struct i915_context *i915 = i915_context(pipe); struct i915_velems_state *i915_velems = (struct i915_velems_state *) velems; - /* Because we change state before the draw_set_vertex_buffers call - * we need a flush here, just to be sure. - */ - draw_flush(i915->draw); + if (i915->velems == velems) + return; + + i915->velems = velems; /* pass-through to draw module */ if (i915_velems) { @@ -812,6 +1054,12 @@ i915_delete_vertex_elements_state(struct pipe_context *pipe, void *velems) FREE( velems ); } +static void +i915_set_sample_mask(struct pipe_context *pipe, + unsigned sample_mask) +{ +} + void i915_init_state_functions( struct i915_context *i915 ) { @@ -820,7 +1068,7 @@ i915_init_state_functions( struct i915_context *i915 ) i915->base.delete_blend_state = i915_delete_blend_state; i915->base.create_sampler_state = i915_create_sampler_state; - i915->base.bind_fragment_sampler_states = i915_bind_sampler_states; + i915->base.bind_sampler_states = i915_bind_sampler_states; i915->base.delete_sampler_state = i915_delete_sampler_state; i915->base.create_depth_stencil_alpha_state = i915_create_depth_stencil_state; @@ -843,14 +1091,15 @@ i915_init_state_functions( struct i915_context *i915 ) i915->base.set_blend_color = i915_set_blend_color; i915->base.set_stencil_ref = i915_set_stencil_ref; i915->base.set_clip_state = i915_set_clip_state; + i915->base.set_sample_mask = i915_set_sample_mask; i915->base.set_constant_buffer = i915_set_constant_buffer; i915->base.set_framebuffer_state = i915_set_framebuffer_state; i915->base.set_polygon_stipple = i915_set_polygon_stipple; - i915->base.set_scissor_state = i915_set_scissor_state; - i915->base.set_fragment_sampler_views = i915_set_fragment_sampler_views; + i915->base.set_scissor_states = i915_set_scissor_states; + i915->base.set_sampler_views = i915_set_sampler_views; i915->base.create_sampler_view = i915_create_sampler_view; i915->base.sampler_view_destroy = i915_sampler_view_destroy; - i915->base.set_viewport_state = i915_set_viewport_state; + i915->base.set_viewport_states = i915_set_viewport_states; i915->base.set_vertex_buffers = i915_set_vertex_buffers; }