Everything now goes through the draw_vbuf handler, the same as regular drivers.tags/mesa_7_7_rc1
@@ -11,7 +11,6 @@ C_SOURCES = \ | |||
sp_query.c \ | |||
sp_context.c \ | |||
sp_draw_arrays.c \ | |||
sp_prim_setup.c \ | |||
sp_prim_vbuf.c \ | |||
sp_quad_pipe.c \ | |||
sp_quad_stipple.c \ |
@@ -12,7 +12,6 @@ softpipe = env.ConvenienceLibrary( | |||
'sp_context.c', | |||
'sp_draw_arrays.c', | |||
'sp_flush.c', | |||
'sp_prim_setup.c', | |||
'sp_prim_vbuf.c', | |||
'sp_setup.c', | |||
'sp_quad_alpha_test.c', |
@@ -31,13 +31,13 @@ | |||
*/ | |||
#include "draw/draw_context.h" | |||
#include "draw/draw_vbuf.h" | |||
#include "pipe/p_defines.h" | |||
#include "util/u_math.h" | |||
#include "util/u_memory.h" | |||
#include "sp_clear.h" | |||
#include "sp_context.h" | |||
#include "sp_flush.h" | |||
#include "sp_prim_setup.h" | |||
#include "sp_prim_vbuf.h" | |||
#include "sp_state.h" | |||
#include "sp_surface.h" | |||
@@ -242,21 +242,21 @@ softpipe_create( struct pipe_screen *screen ) | |||
(struct tgsi_sampler **) | |||
softpipe->tgsi.vert_samplers_list); | |||
softpipe->setup = sp_draw_render_stage(softpipe); | |||
if (!softpipe->setup) | |||
goto fail; | |||
if (debug_get_bool_option( "SP_NO_RAST", FALSE )) | |||
softpipe->no_rast = TRUE; | |||
if (debug_get_bool_option( "SP_NO_VBUF", FALSE )) { | |||
/* Deprecated path -- vbuf is the intended interface to the draw module: | |||
*/ | |||
draw_set_rasterize_stage(softpipe->draw, softpipe->setup); | |||
} | |||
else { | |||
sp_init_vbuf(softpipe); | |||
} | |||
softpipe->vbuf_backend = sp_create_vbuf_backend(softpipe); | |||
if (!softpipe->vbuf_backend) | |||
goto fail; | |||
softpipe->vbuf = draw_vbuf_stage(softpipe->draw, softpipe->vbuf_backend); | |||
if (!softpipe->vbuf) | |||
goto fail; | |||
draw_set_rasterize_stage(softpipe->draw, softpipe->vbuf); | |||
draw_set_render(softpipe->draw, softpipe->vbuf_backend); | |||
/* plug in AA line/point stages */ | |||
draw_install_aaline_stage(softpipe->draw, &softpipe->pipe); |
@@ -129,9 +129,10 @@ struct softpipe_context { | |||
/** The primitive drawing context */ | |||
struct draw_context *draw; | |||
struct draw_stage *setup; | |||
/** Draw module backend */ | |||
struct vbuf_render *vbuf_backend; | |||
struct draw_stage *vbuf; | |||
struct softpipe_vbuf_render *vbuf_render; | |||
boolean dirty_render_cache; | |||
@@ -1,190 +0,0 @@ | |||
/************************************************************************** | |||
* | |||
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. | |||
* 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 TUNGSTEN GRAPHICS 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. | |||
* | |||
**************************************************************************/ | |||
/** | |||
* \brief A draw stage that drives our triangle setup routines from | |||
* within the draw pipeline. One of two ways to drive setup, the | |||
* other being in sp_prim_vbuf.c. | |||
* | |||
* \author Keith Whitwell <keith@tungstengraphics.com> | |||
* \author Brian Paul | |||
*/ | |||
#include "sp_context.h" | |||
#include "sp_setup.h" | |||
#include "sp_state.h" | |||
#include "sp_prim_setup.h" | |||
#include "draw/draw_pipe.h" | |||
#include "draw/draw_vertex.h" | |||
#include "util/u_memory.h" | |||
/** | |||
* Triangle setup info (derived from draw_stage). | |||
* Also used for line drawing (taking some liberties). | |||
*/ | |||
struct setup_stage { | |||
struct draw_stage stage; /**< This must be first (base class) */ | |||
struct setup_context *setup; | |||
}; | |||
/** | |||
* Basically a cast wrapper. | |||
*/ | |||
static INLINE struct setup_stage *setup_stage( struct draw_stage *stage ) | |||
{ | |||
return (struct setup_stage *)stage; | |||
} | |||
typedef const float (*cptrf4)[4]; | |||
static void | |||
do_tri(struct draw_stage *stage, struct prim_header *prim) | |||
{ | |||
struct setup_stage *setup = setup_stage( stage ); | |||
setup_tri( setup->setup, | |||
(cptrf4)prim->v[0]->data, | |||
(cptrf4)prim->v[1]->data, | |||
(cptrf4)prim->v[2]->data ); | |||
} | |||
static void | |||
do_line(struct draw_stage *stage, struct prim_header *prim) | |||
{ | |||
struct setup_stage *setup = setup_stage( stage ); | |||
setup_line( setup->setup, | |||
(cptrf4)prim->v[0]->data, | |||
(cptrf4)prim->v[1]->data ); | |||
} | |||
static void | |||
do_point(struct draw_stage *stage, struct prim_header *prim) | |||
{ | |||
struct setup_stage *setup = setup_stage( stage ); | |||
setup_point( setup->setup, | |||
(cptrf4)prim->v[0]->data ); | |||
} | |||
static void setup_begin( struct draw_stage *stage ) | |||
{ | |||
struct setup_stage *setup = setup_stage(stage); | |||
setup_prepare( setup->setup ); | |||
stage->point = do_point; | |||
stage->line = do_line; | |||
stage->tri = do_tri; | |||
} | |||
static void setup_first_point( struct draw_stage *stage, | |||
struct prim_header *header ) | |||
{ | |||
setup_begin(stage); | |||
stage->point( stage, header ); | |||
} | |||
static void setup_first_line( struct draw_stage *stage, | |||
struct prim_header *header ) | |||
{ | |||
setup_begin(stage); | |||
stage->line( stage, header ); | |||
} | |||
static void setup_first_tri( struct draw_stage *stage, | |||
struct prim_header *header ) | |||
{ | |||
setup_begin(stage); | |||
stage->tri( stage, header ); | |||
} | |||
static void setup_flush( struct draw_stage *stage, | |||
unsigned flags ) | |||
{ | |||
stage->point = setup_first_point; | |||
stage->line = setup_first_line; | |||
stage->tri = setup_first_tri; | |||
} | |||
static void reset_stipple_counter( struct draw_stage *stage ) | |||
{ | |||
} | |||
static void render_destroy( struct draw_stage *stage ) | |||
{ | |||
struct setup_stage *ssetup = setup_stage(stage); | |||
setup_destroy_context(ssetup->setup); | |||
FREE( stage ); | |||
} | |||
/** | |||
* Create a new primitive setup/render stage. | |||
*/ | |||
struct draw_stage *sp_draw_render_stage( struct softpipe_context *softpipe ) | |||
{ | |||
struct setup_stage *sstage = CALLOC_STRUCT(setup_stage); | |||
sstage->setup = setup_create_context(softpipe); | |||
sstage->stage.draw = softpipe->draw; | |||
sstage->stage.point = setup_first_point; | |||
sstage->stage.line = setup_first_line; | |||
sstage->stage.tri = setup_first_tri; | |||
sstage->stage.flush = setup_flush; | |||
sstage->stage.reset_stipple_counter = reset_stipple_counter; | |||
sstage->stage.destroy = render_destroy; | |||
return (struct draw_stage *)sstage; | |||
} | |||
struct setup_context * | |||
sp_draw_setup_context( struct draw_stage *stage ) | |||
{ | |||
struct setup_stage *ssetup = setup_stage(stage); | |||
return ssetup->setup; | |||
} | |||
void | |||
sp_draw_flush( struct draw_stage *stage ) | |||
{ | |||
stage->flush( stage, 0 ); | |||
} |
@@ -1,85 +0,0 @@ | |||
/************************************************************************** | |||
* | |||
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. | |||
* 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 TUNGSTEN GRAPHICS 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 SP_PRIM_SETUP_H | |||
#define SP_PRIM_SETUP_H | |||
/** | |||
* vbuf is a special stage to gather the stream of triangles, lines, points | |||
* together and reconstruct vertex buffers for hardware upload. | |||
* | |||
* First attempt, work in progress. | |||
* | |||
* TODO: | |||
* - separate out vertex buffer building and primitive emit, ie >1 draw per vb. | |||
* - tell vbuf stage how to build hw vertices directly | |||
* - pass vbuf stage a buffer pointer for direct emit to agp/vram. | |||
* | |||
* | |||
* | |||
* Vertices are just an array of floats, with all the attributes | |||
* packed. We currently assume a layout like: | |||
* | |||
* attr[0][0..3] - window position | |||
* attr[1..n][0..3] - remaining attributes. | |||
* | |||
* Attributes are assumed to be 4 floats wide but are packed so that | |||
* all the enabled attributes run contiguously. | |||
*/ | |||
struct draw_stage; | |||
struct softpipe_context; | |||
typedef void (*vbuf_draw_func)( struct pipe_context *pipe, | |||
unsigned prim, | |||
const ushort *elements, | |||
unsigned nr_elements, | |||
const void *vertex_buffer, | |||
unsigned nr_vertices ); | |||
extern struct draw_stage * | |||
sp_draw_render_stage( struct softpipe_context *softpipe ); | |||
extern struct setup_context * | |||
sp_draw_setup_context( struct draw_stage * ); | |||
extern void | |||
sp_draw_flush( struct draw_stage * ); | |||
extern struct draw_stage * | |||
sp_draw_vbuf_stage( struct draw_context *draw_context, | |||
struct pipe_context *pipe, | |||
vbuf_draw_func draw ); | |||
#endif /* SP_PRIM_SETUP_H */ |
@@ -37,10 +37,9 @@ | |||
#include "sp_context.h" | |||
#include "sp_setup.h" | |||
#include "sp_state.h" | |||
#include "sp_prim_vbuf.h" | |||
#include "sp_prim_setup.h" | |||
#include "sp_setup.h" | |||
#include "draw/draw_context.h" | |||
#include "draw/draw_vbuf.h" | |||
#include "util/u_memory.h" | |||
@@ -59,6 +58,8 @@ struct softpipe_vbuf_render | |||
{ | |||
struct vbuf_render base; | |||
struct softpipe_context *softpipe; | |||
struct setup_context *setup; | |||
uint prim; | |||
uint vertex_size; | |||
uint nr_vertices; | |||
@@ -75,6 +76,11 @@ softpipe_vbuf_render(struct vbuf_render *vbr) | |||
} | |||
static const struct vertex_info * | |||
sp_vbuf_get_vertex_info(struct vbuf_render *vbr) | |||
{ | |||
@@ -105,36 +111,6 @@ sp_vbuf_allocate_vertices(struct vbuf_render *vbr, | |||
static void | |||
sp_vbuf_release_vertices(struct vbuf_render *vbr) | |||
{ | |||
#if 0 | |||
{ | |||
struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr); | |||
const struct vertex_info *info = | |||
softpipe_get_vbuf_vertex_info(cvbr->softpipe); | |||
const float *vtx = (const float *) cvbr->vertex_buffer; | |||
uint i, j; | |||
debug_printf("%s (vtx_size = %u, vtx_used = %u)\n", | |||
__FUNCTION__, cvbr->vertex_size, cvbr->nr_vertices); | |||
for (i = 0; i < cvbr->nr_vertices; i++) { | |||
for (j = 0; j < info->num_attribs; j++) { | |||
uint k; | |||
switch (info->attrib[j].emit) { | |||
case EMIT_4F: k = 4; break; | |||
case EMIT_3F: k = 3; break; | |||
case EMIT_2F: k = 2; break; | |||
case EMIT_1F: k = 1; break; | |||
default: assert(0); | |||
} | |||
debug_printf("Vert %u attr %u: ", i, j); | |||
while (k-- > 0) { | |||
debug_printf("%g ", vtx[0]); | |||
vtx++; | |||
} | |||
debug_printf("\n"); | |||
} | |||
} | |||
} | |||
#endif | |||
/* keep the old allocation for next time */ | |||
} | |||
@@ -160,11 +136,7 @@ static boolean | |||
sp_vbuf_set_primitive(struct vbuf_render *vbr, unsigned prim) | |||
{ | |||
struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr); | |||
/* XXX: break this dependency - make setup_context live under | |||
* softpipe, rename the old "setup" draw stage to something else. | |||
*/ | |||
struct setup_context *setup_ctx = sp_draw_setup_context(cvbr->softpipe->setup); | |||
struct setup_context *setup_ctx = cvbr->setup; | |||
setup_prepare( setup_ctx ); | |||
@@ -193,14 +165,9 @@ sp_vbuf_draw(struct vbuf_render *vbr, const ushort *indices, uint nr) | |||
struct softpipe_context *softpipe = cvbr->softpipe; | |||
const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float); | |||
const void *vertex_buffer = cvbr->vertex_buffer; | |||
struct setup_context *setup_ctx = cvbr->setup; | |||
unsigned i; | |||
/* XXX: break this dependency - make setup_context live under | |||
* softpipe, rename the old "setup" draw stage to something else. | |||
*/ | |||
struct draw_stage *setup = softpipe->setup; | |||
struct setup_context *setup_ctx = sp_draw_setup_context(setup); | |||
switch (cvbr->prim) { | |||
case PIPE_PRIM_POINTS: | |||
for (i = 0; i < nr; i++) { | |||
@@ -367,11 +334,6 @@ sp_vbuf_draw(struct vbuf_render *vbr, const ushort *indices, uint nr) | |||
default: | |||
assert(0); | |||
} | |||
/* XXX: why are we calling this??? If we had to call something, it | |||
* would be a function in sp_setup.c: | |||
*/ | |||
sp_draw_flush( setup ); | |||
} | |||
@@ -384,17 +346,12 @@ sp_vbuf_draw_arrays(struct vbuf_render *vbr, uint start, uint nr) | |||
{ | |||
struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr); | |||
struct softpipe_context *softpipe = cvbr->softpipe; | |||
struct setup_context *setup_ctx = cvbr->setup; | |||
const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float); | |||
const void *vertex_buffer = | |||
(void *) get_vert(cvbr->vertex_buffer, start, stride); | |||
unsigned i; | |||
/* XXX: break this dependency - make setup_context live under | |||
* softpipe, rename the old "setup" draw stage to something else. | |||
*/ | |||
struct draw_stage *setup = softpipe->setup; | |||
struct setup_context *setup_ctx = sp_draw_setup_context(setup); | |||
switch (cvbr->prim) { | |||
case PIPE_PRIM_POINTS: | |||
for (i = 0; i < nr; i++) { | |||
@@ -568,40 +525,38 @@ static void | |||
sp_vbuf_destroy(struct vbuf_render *vbr) | |||
{ | |||
struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr); | |||
cvbr->softpipe->vbuf_render = NULL; | |||
setup_destroy_context(cvbr->setup); | |||
FREE(cvbr); | |||
} | |||
/** | |||
* Initialize the post-transform vertex buffer information for the given | |||
* context. | |||
* Create the post-transform vertex handler for the given context. | |||
*/ | |||
void | |||
sp_init_vbuf(struct softpipe_context *sp) | |||
struct vbuf_render * | |||
sp_create_vbuf_backend(struct softpipe_context *sp) | |||
{ | |||
assert(sp->draw); | |||
struct softpipe_vbuf_render *cvbr = CALLOC_STRUCT(softpipe_vbuf_render); | |||
sp->vbuf_render = CALLOC_STRUCT(softpipe_vbuf_render); | |||
assert(sp->draw); | |||
sp->vbuf_render->base.max_indices = SP_MAX_VBUF_INDEXES; | |||
sp->vbuf_render->base.max_vertex_buffer_bytes = SP_MAX_VBUF_SIZE; | |||
sp->vbuf_render->base.get_vertex_info = sp_vbuf_get_vertex_info; | |||
sp->vbuf_render->base.allocate_vertices = sp_vbuf_allocate_vertices; | |||
sp->vbuf_render->base.map_vertices = sp_vbuf_map_vertices; | |||
sp->vbuf_render->base.unmap_vertices = sp_vbuf_unmap_vertices; | |||
sp->vbuf_render->base.set_primitive = sp_vbuf_set_primitive; | |||
sp->vbuf_render->base.draw = sp_vbuf_draw; | |||
sp->vbuf_render->base.draw_arrays = sp_vbuf_draw_arrays; | |||
sp->vbuf_render->base.release_vertices = sp_vbuf_release_vertices; | |||
sp->vbuf_render->base.destroy = sp_vbuf_destroy; | |||
cvbr->base.max_indices = SP_MAX_VBUF_INDEXES; | |||
cvbr->base.max_vertex_buffer_bytes = SP_MAX_VBUF_SIZE; | |||
sp->vbuf_render->softpipe = sp; | |||
cvbr->base.get_vertex_info = sp_vbuf_get_vertex_info; | |||
cvbr->base.allocate_vertices = sp_vbuf_allocate_vertices; | |||
cvbr->base.map_vertices = sp_vbuf_map_vertices; | |||
cvbr->base.unmap_vertices = sp_vbuf_unmap_vertices; | |||
cvbr->base.set_primitive = sp_vbuf_set_primitive; | |||
cvbr->base.draw = sp_vbuf_draw; | |||
cvbr->base.draw_arrays = sp_vbuf_draw_arrays; | |||
cvbr->base.release_vertices = sp_vbuf_release_vertices; | |||
cvbr->base.destroy = sp_vbuf_destroy; | |||
sp->vbuf = draw_vbuf_stage(sp->draw, &sp->vbuf_render->base); | |||
cvbr->softpipe = sp; | |||
draw_set_rasterize_stage(sp->draw, sp->vbuf); | |||
cvbr->setup = setup_create_context(cvbr->softpipe); | |||
draw_set_render(sp->draw, &sp->vbuf_render->base); | |||
return &cvbr->base; | |||
} |
@@ -31,8 +31,8 @@ | |||
struct softpipe_context; | |||
extern void | |||
sp_init_vbuf(struct softpipe_context *softpipe); | |||
extern struct vbuf_render * | |||
sp_create_vbuf_backend(struct softpipe_context *softpipe); | |||
#endif /* SP_VBUF_H */ |
@@ -33,7 +33,6 @@ | |||
*/ | |||
#include "sp_context.h" | |||
#include "sp_prim_setup.h" | |||
#include "sp_quad.h" | |||
#include "sp_quad_pipe.h" | |||
#include "sp_setup.h" |
@@ -68,24 +68,19 @@ softpipe_get_vertex_info(struct softpipe_context *softpipe) | |||
const struct sp_fragment_shader *spfs = softpipe->fs; | |||
const enum interp_mode colorInterp | |||
= softpipe->rasterizer->flatshade ? INTERP_CONSTANT : INTERP_LINEAR; | |||
struct vertex_info *vinfo_vbuf = &softpipe->vertex_info_vbuf; | |||
const uint num = draw_num_vs_outputs(softpipe->draw); | |||
uint i; | |||
if (softpipe->vbuf) { | |||
/* if using the post-transform vertex buffer, tell draw_vbuf to | |||
* simply emit the whole post-xform vertex as-is: | |||
*/ | |||
struct vertex_info *vinfo_vbuf = &softpipe->vertex_info_vbuf; | |||
const uint num = draw_num_vs_outputs(softpipe->draw); | |||
uint i; | |||
/* No longer any need to try and emit draw vertex_header info. | |||
*/ | |||
vinfo_vbuf->num_attribs = 0; | |||
for (i = 0; i < num; i++) { | |||
draw_emit_vertex_attr(vinfo_vbuf, EMIT_4F, INTERP_PERSPECTIVE, i); | |||
} | |||
draw_compute_vertex_size(vinfo_vbuf); | |||
/* Tell draw_vbuf to simply emit the whole post-xform vertex | |||
* as-is. No longer any need to try and emit draw vertex_header | |||
* info. | |||
*/ | |||
vinfo_vbuf->num_attribs = 0; | |||
for (i = 0; i < num; i++) { | |||
draw_emit_vertex_attr(vinfo_vbuf, EMIT_4F, INTERP_PERSPECTIVE, i); | |||
} | |||
draw_compute_vertex_size(vinfo_vbuf); | |||
/* | |||
* Loop over fragment shader inputs, searching for the matching output |