fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-01 03:48:06 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

gallium: Remove feedback interfaces from pipe driver.

Browse source 
Something similar will return when geometry shaders are added, but for now
this interface is not required.
This commit is contained in:
Keith Whitwell 2007-12-11 13:00:12 +00:00
parent 89afc929f4
commit 48731280d0
19 changed files with 21 additions and 515 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
src/mesa/pipe/draw/draw_context.c
View file

@ -55,7 +55,6 @@ struct draw_context *draw_create( void )
draw->pipeline.clip = draw_clip_stage( draw );
draw->pipeline.flatshade = draw_flatshade_stage( draw );
draw->pipeline.cull = draw_cull_stage( draw );
draw->pipeline.feedback = draw_feedback_stage( draw );
draw->pipeline.validate = draw_validate_stage( draw );
draw->pipeline.first = draw->pipeline.validate;
@ -100,7 +99,6 @@ void draw_destroy( struct draw_context *draw )
draw->pipeline.clip->destroy( draw->pipeline.clip );
draw->pipeline.flatshade->destroy( draw->pipeline.flatshade );
draw->pipeline.cull->destroy( draw->pipeline.cull );
draw->pipeline.feedback->destroy( draw->pipeline.feedback );
draw->pipeline.validate->destroy( draw->pipeline.validate );
if (draw->pipeline.rasterize)
draw->pipeline.rasterize->destroy( draw->pipeline.rasterize );
@ -117,13 +115,6 @@ void draw_flush( struct draw_context *draw )
}
void draw_set_feedback_state( struct draw_context *draw,
const struct pipe_feedback_state *feedback )
{
draw_flush( draw );
draw->feedback = *feedback;
}
/**
* Register new primitive rasterization/rendering state.
@ -223,18 +214,6 @@ draw_set_mapped_constant_buffer(struct draw_context *draw,
}
void
draw_set_mapped_feedback_buffer(struct draw_context *draw, uint index,
void *buffer, uint size)
{
draw_flush( draw );
assert(index < PIPE_MAX_FEEDBACK_ATTRIBS);
draw->user.feedback_buffer[index] = buffer;
draw->user.feedback_buffer_size[index] = size; /* in bytes */
}

6
src/mesa/pipe/draw/draw_context.h
View file

@ -82,9 +82,6 @@ void draw_set_viewport_state( struct draw_context *draw,
void draw_set_clip_state( struct draw_context *pipe,
const struct pipe_clip_state *clip );
void draw_set_feedback_state( struct draw_context *draw,
const struct pipe_feedback_state * );
void draw_set_rasterizer_state( struct draw_context *draw,
const struct pipe_rasterizer_state *raster );
@ -120,9 +117,6 @@ void draw_set_mapped_vertex_buffer(struct draw_context *draw,
void draw_set_mapped_constant_buffer(struct draw_context *draw,
const void *buffer);
void
draw_set_mapped_feedback_buffer(struct draw_context *draw, uint index,
void *buffer, uint size);
/***********************************************************************

253
src/mesa/pipe/draw/draw_feedback.c
View file

@ -1,253 +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.
*
**************************************************************************/
/**
* Primitive/vertex feedback (and/or discard) stage.
* Used to implement transformation feedback/streaming and other things
* which require a post-transformed vertex position (such as rasterpos,
* selection and feedback modes).
*
* Authors:
* Brian Paul
*/
#include "pipe/p_util.h"
#include "draw_private.h"
struct feedback_stage {
struct draw_stage stage; /**< base class */
uint num_prim_generated; /**< number of primitives received */
uint num_prim_emitted; /**< number of primitives fed back */
uint num_vert_emitted; /**< number of vertices fed back */
uint max_vert_emit; /**< max number of verts we can emit */
float *dest[PIPE_MAX_FEEDBACK_ATTRIBS]; /**< dests for vertex attribs */
};
/**
* Check if there's space to store 'numVerts' in the feedback buffer(s).
*/
static boolean
check_space(const struct draw_stage *stage, uint numVerts)
{
const struct feedback_stage *fs = (struct feedback_stage *) stage;
return fs->num_vert_emitted + numVerts <= fs->max_vert_emit;
}
/**
* Record the given vertex's attributes into the feedback buffer(s).
*/
static void
feedback_vertex(struct draw_stage *stage, const struct vertex_header *vertex)
{
struct feedback_stage *fs = (struct feedback_stage *) stage;
const struct pipe_feedback_state *feedback = &stage->draw->feedback;
const uint select = feedback->interleaved ? 0 : 1;
uint i;
/*
* Note: 'select' is either 0 or 1. By multiplying 'i' by 'select'
* we can either address output buffer 0 (for interleaving) or
* output buffer i (for non-interleaved).
*/
for (i = 0; i < feedback->num_attribs; i++) {
const uint slot = feedback->attrib[i];
const float *src = slot ? vertex->data[slot] : vertex->clip;
const uint size = feedback->size[i];
float *dest = fs->dest[i * select];
switch (size) {
case 4:
dest[3] = src[3];
/* fall-through */
case 3:
dest[2] = src[2];
/* fall-through */
case 2:
dest[1] = src[1];
/* fall-through */
case 1:
dest[0] = src[0];
/* fall-through */
default:
;
}
fs->dest[i * select] += size;
}
fs->num_vert_emitted++;
}
static void feedback_begin( struct draw_stage *stage )
{
struct feedback_stage *fs = (struct feedback_stage *) stage;
const struct pipe_feedback_state *feedback = &stage->draw->feedback;
fs->num_prim_generated = 0;
fs->num_prim_emitted = 0;
fs->num_vert_emitted = 0;
assert(feedback->enabled);
/* Compute max_vert_emit, the max number of vertices we can emit.
* And, setup dest[] pointers.
*/
if (stage->draw->feedback.interleaved) {
uint i, vertex_size = 0;
/* compute size of each interleaved vertex, in floats */
for (i = 0; i < feedback->num_attribs; i++) {
vertex_size += feedback->size[i];
}
/* compute max number of vertices we can feedback */
fs->max_vert_emit = stage->draw->user.feedback_buffer_size[0]
/ sizeof(float) / vertex_size;
fs->dest[0] = (float *) stage->draw->user.feedback_buffer[0];
}
else {
uint i;
uint max = ~0;
for (i = 0; i < feedback->num_attribs; i++) {
uint n = stage->draw->user.feedback_buffer_size[i]
/ sizeof(float) / feedback->size[i];
if (n < max)
max = n;
fs->dest[i] = (float *) stage->draw->user.feedback_buffer[i];
}
fs->max_vert_emit = max;
}
if (!feedback->discard)
stage->next->begin( stage->next );
}
static void feedback_tri( struct draw_stage *stage,
struct prim_header *header )
{
struct feedback_stage *fs = (struct feedback_stage *) stage;
fs->num_prim_generated++;
if (stage->draw->feedback.enabled && check_space(stage, 3)) {
feedback_vertex(stage, header->v[0]);
feedback_vertex(stage, header->v[1]);
feedback_vertex(stage, header->v[2]);
fs->num_prim_emitted++;
}
if (!stage->draw->feedback.discard)
stage->next->tri( stage->next, header );
}
static void feedback_line( struct draw_stage *stage,
struct prim_header *header )
{
struct feedback_stage *fs = (struct feedback_stage *) stage;
fs->num_prim_generated++;
if (stage->draw->feedback.enabled && check_space(stage, 2)) {
feedback_vertex(stage, header->v[0]);
feedback_vertex(stage, header->v[1]);
fs->num_prim_emitted++;
}
if (!stage->draw->feedback.discard)
stage->next->line( stage->next, header );
}
static void feedback_point( struct draw_stage *stage,
struct prim_header *header )
{
struct feedback_stage *fs = (struct feedback_stage *) stage;
fs->num_prim_generated++;
if (stage->draw->feedback.enabled && check_space(stage, 1)) {
feedback_vertex(stage, header->v[0]);
fs->num_prim_emitted++;
}
if (!stage->draw->feedback.discard)
stage->next->point( stage->next, header );
}
static void feedback_end( struct draw_stage *stage )
{
/* XXX Unmap the vertex feedback buffers so we can write to them */
if (!stage->draw->feedback.discard)
stage->next->end( stage->next );
}
static void feedback_reset_stipple_counter( struct draw_stage *stage )
{
if (!stage->draw->feedback.discard)
stage->next->reset_stipple_counter( stage->next );
}
static void feedback_destroy( struct draw_stage *stage )
{
FREE( stage );
}
/**
* Create feedback drawing stage.
*/
struct draw_stage *draw_feedback_stage( struct draw_context *draw )
{
struct feedback_stage *feedback = CALLOC_STRUCT(feedback_stage);
feedback->stage.draw = draw;
feedback->stage.next = NULL;
feedback->stage.begin = feedback_begin;
feedback->stage.point = feedback_point;
feedback->stage.line = feedback_line;
feedback->stage.tri = feedback_tri;
feedback->stage.end = feedback_end;
feedback->stage.reset_stipple_counter = feedback_reset_stipple_counter;
feedback->stage.destroy = feedback_destroy;
return &feedback->stage;
}

9
src/mesa/pipe/draw/draw_private.h
View file

@ -159,7 +159,6 @@ struct draw_context
struct draw_stage *validate;
/* stages (in logical order) */
struct draw_stage *feedback;
struct draw_stage *flatshade;
struct draw_stage *clip;
struct draw_stage *cull;
@ -172,13 +171,10 @@ struct draw_context
/* pipe state that we need: */
const struct pipe_rasterizer_state *rasterizer;
struct pipe_feedback_state feedback;
struct pipe_viewport_state viewport;
struct pipe_vertex_buffer vertex_buffer[PIPE_ATTRIB_MAX];
struct pipe_vertex_element vertex_element[PIPE_ATTRIB_MAX];
const struct draw_vertex_shader *vertex_shader;
struct pipe_vertex_buffer feedback_buffer[PIPE_ATTRIB_MAX];
struct pipe_vertex_element feedback_element[PIPE_ATTRIB_MAX];
/* user-space vertex data, buffers */
struct {
@ -192,10 +188,6 @@ struct draw_context
/** constant buffer (for vertex shader) */
const void *constants;
/** The vertex feedback buffer */
void *feedback_buffer[PIPE_MAX_FEEDBACK_ATTRIBS];
uint feedback_buffer_size[PIPE_MAX_FEEDBACK_ATTRIBS]; /* in bytes */
} user;
/* Clip derived state:
@ -257,7 +249,6 @@ struct draw_context
extern struct draw_stage *draw_feedback_stage( struct draw_context *context );
extern struct draw_stage *draw_unfilled_stage( struct draw_context *context );
extern struct draw_stage *draw_twoside_stage( struct draw_context *context );
extern struct draw_stage *draw_offset_stage( struct draw_context *context );

5
src/mesa/pipe/draw/draw_validate.c
View file

@ -100,11 +100,6 @@ static void validate_begin( struct draw_stage *stage )
next = draw->pipeline.flatshade;
}
if (draw->feedback.enabled || draw->feedback.discard) {
draw->pipeline.feedback->next = next;
next = draw->pipeline.feedback;
}
draw->pipeline.first = next;
draw->pipeline.first->begin( draw->pipeline.first );
}

22
src/mesa/pipe/i915simple/i915_context.c
View file

@ -223,18 +223,6 @@ i915_draw_elements( struct pipe_context *pipe,
draw_set_mapped_element_buffer(draw, 0, NULL);
}
/* Map feedback buffers if enabled */
if (i915->feedback.enabled) {
const uint n = i915->feedback.interleaved ? 1 : i915->feedback.num_attribs;
for (i = 0; i < n; i++) {
void *ptr = pipe->winsys->buffer_map(pipe->winsys,
i915->feedback_buffer[i].buffer,
PIPE_BUFFER_FLAG_WRITE);
draw_set_mapped_feedback_buffer(draw, i, ptr,
i915->feedback_buffer[i].size);
}
}
draw_set_mapped_constant_buffer(draw,
i915->current.constants[PIPE_SHADER_VERTEX]);
@ -256,16 +244,6 @@ i915_draw_elements( struct pipe_context *pipe,
draw_set_mapped_element_buffer(draw, 0, NULL);
}
/* Unmap feedback buffers if enabled */
if (i915->feedback.enabled) {
const uint n = i915->feedback.interleaved ? 1 : i915->feedback.num_attribs;
for (i = 0; i < n; i++) {
pipe->winsys->buffer_unmap(pipe->winsys,
i915->feedback_buffer[i].buffer);
draw_set_mapped_feedback_buffer(draw, i, NULL, 0);
}
}
return TRUE;
}

4
src/mesa/pipe/i915simple/i915_context.h
View file

@ -197,7 +197,6 @@ struct i915_context
struct pipe_clear_color_state clear_color;
struct pipe_clip_state clip;
struct pipe_constant_buffer constants[PIPE_SHADER_TYPES];
struct pipe_feedback_state feedback;
struct pipe_framebuffer_state framebuffer;
struct pipe_poly_stipple poly_stipple;
struct pipe_scissor_state scissor;
@ -206,9 +205,6 @@ struct i915_context
struct pipe_viewport_state viewport;
struct pipe_vertex_buffer vertex_buffer[PIPE_ATTRIB_MAX];
/** Feedback buffers */
struct pipe_feedback_buffer feedback_buffer[PIPE_MAX_FEEDBACK_ATTRIBS];
unsigned dirty;
unsigned *batch_start;

30
src/mesa/pipe/i915simple/i915_state.c
View file

@ -547,34 +547,6 @@ static void i915_set_framebuffer_state(struct pipe_context *pipe,
}
static void
i915_set_feedback_state(struct pipe_context *pipe,
const struct pipe_feedback_state *feedback)
{
struct i915_context *i915 = i915_context(pipe);
i915->feedback = *feedback;
draw_set_feedback_state(i915->draw, feedback);
}
static void
i915_set_feedback_buffer(struct pipe_context *pipe,
unsigned index,
const struct pipe_feedback_buffer *feedback)
{
struct i915_context *i915 = i915_context(pipe);
assert(index < PIPE_MAX_FEEDBACK_ATTRIBS);
/* Need to be careful with referencing */
pipe->winsys->buffer_reference(pipe->winsys,
&i915->feedback_buffer[index].buffer,
feedback->buffer);
i915->feedback_buffer[index].size = feedback->size;
i915->feedback_buffer[index].start_offset = feedback->start_offset;
}
static void i915_set_clear_color_state(struct pipe_context *pipe,
const struct pipe_clear_color_state *clear)
@ -751,8 +723,6 @@ i915_init_state_functions( struct i915_context *i915 )
i915->pipe.set_clear_color_state = i915_set_clear_color_state;
i915->pipe.set_constant_buffer = i915_set_constant_buffer;
i915->pipe.set_framebuffer_state = i915_set_framebuffer_state;
i915->pipe.set_feedback_state = i915_set_feedback_state;
i915->pipe.set_feedback_buffer = i915_set_feedback_buffer;
i915->pipe.set_polygon_stipple = i915_set_polygon_stipple;
i915->pipe.set_sampler_units = i915_set_sampler_units;

9
src/mesa/pipe/p_context.h
View file

@ -139,9 +139,6 @@ struct pipe_context {
uint shader, uint index,
const struct pipe_constant_buffer *buf );
void (*set_feedback_state)( struct pipe_context *,
const struct pipe_feedback_state *);
void (*set_framebuffer_state)( struct pipe_context *,
const struct pipe_framebuffer_state * );
@ -172,12 +169,6 @@ struct pipe_context {
unsigned index,
const struct pipe_vertex_element * );
/*
* Vertex feedback
*/
void (*set_feedback_buffer)(struct pipe_context *,
unsigned index,
const struct pipe_feedback_buffer *);
/** Get a surface which is a "view" into a texture */
struct pipe_surface *(*get_tex_surface)(struct pipe_context *pipe,

22
src/mesa/pipe/p_state.h
View file

@ -103,19 +103,6 @@ struct pipe_rasterizer_state
};
/**
* Post-transform vertex feeback
*/
struct pipe_feedback_state {
uint enabled:1; /**< enable feedback? */
uint discard:1; /**< discard primitives? */
uint interleaved:1; /**< interleaved output? */
uint num_attribs;
uint attrib[PIPE_MAX_FEEDBACK_ATTRIBS];
uint size[PIPE_MAX_FEEDBACK_ATTRIBS];
};
struct pipe_poly_stipple {
unsigned stipple[32];
};
@ -336,15 +323,6 @@ struct pipe_vertex_element
};
/**
* Vertex feedback buffer
*/
struct pipe_feedback_buffer {
struct pipe_buffer_handle *buffer;
unsigned size;
unsigned start_offset;
};
/**
* Hardware queries (occlusion, transform feedback, timing, etc)

1
src/mesa/pipe/softpipe/Makefile
View file

@ -27,7 +27,6 @@ DRIVER_SOURCES = \
sp_state_blend.c \
sp_state_clip.c \
sp_state_derived.c \
sp_state_feedback.c \
sp_state_fs.c \
sp_state_sampler.c \
sp_state_rasterizer.c \

2
src/mesa/pipe/softpipe/sp_context.c
View file

@ -306,7 +306,6 @@ struct pipe_context *softpipe_create( struct pipe_winsys *pipe_winsys,
softpipe->pipe.set_clip_state = softpipe_set_clip_state;
softpipe->pipe.set_clear_color_state = softpipe_set_clear_color_state;
softpipe->pipe.set_constant_buffer = softpipe_set_constant_buffer;
softpipe->pipe.set_feedback_state = softpipe_set_feedback_state;
softpipe->pipe.set_framebuffer_state = softpipe_set_framebuffer_state;
softpipe->pipe.set_polygon_stipple = softpipe_set_polygon_stipple;
softpipe->pipe.set_sampler_units = softpipe_set_sampler_units;
@ -316,7 +315,6 @@ struct pipe_context *softpipe_create( struct pipe_winsys *pipe_winsys,
softpipe->pipe.set_vertex_buffer = softpipe_set_vertex_buffer;
softpipe->pipe.set_vertex_element = softpipe_set_vertex_element;
softpipe->pipe.set_feedback_buffer = softpipe_set_feedback_buffer;
softpipe->pipe.draw_arrays = softpipe_draw_arrays;
softpipe->pipe.draw_elements = softpipe_draw_elements;

4
src/mesa/pipe/softpipe/sp_context.h
View file

@ -85,7 +85,6 @@ struct softpipe_context {
struct pipe_clear_color_state clear_color;
struct pipe_clip_state clip;
struct pipe_constant_buffer constants[2];
struct pipe_feedback_state feedback;
struct pipe_framebuffer_state framebuffer;
struct pipe_poly_stipple poly_stipple;
struct pipe_scissor_state scissor;
@ -117,9 +116,6 @@ struct softpipe_context {
boolean need_w; /**< produce quad/fragment W values? */
int psize_slot;
/** Feedback buffers */
struct pipe_feedback_buffer feedback_buffer[PIPE_MAX_FEEDBACK_ATTRIBS];
#if 0
/* Stipple derived state:
*/

22
src/mesa/pipe/softpipe/sp_draw_arrays.c
View file

@ -138,18 +138,6 @@ softpipe_draw_elements(struct pipe_context *pipe,
draw_set_mapped_element_buffer(draw, 0, NULL);
}
/* Map feedback buffers if enabled */
if (sp->feedback.enabled) {
const uint n = sp->feedback.interleaved ? 1 : sp->feedback.num_attribs;
for (i = 0; i < n; i++) {
void *ptr = pipe->winsys->buffer_map(pipe->winsys,
sp->feedback_buffer[i].buffer,
PIPE_BUFFER_FLAG_WRITE);
draw_set_mapped_feedback_buffer(draw, i, ptr,
sp->feedback_buffer[i].size);
}
}
/* draw! */
draw_arrays(draw, mode, start, count);
@ -171,16 +159,6 @@ softpipe_draw_elements(struct pipe_context *pipe,
draw_set_mapped_element_buffer(draw, 0, NULL);
}
/* Unmap feedback buffers if enabled */
if (sp->feedback.enabled) {
const uint n = sp->feedback.interleaved ? 1 : sp->feedback.num_attribs;
for (i = 0; i < n; i++) {
pipe->winsys->buffer_unmap(pipe->winsys,
sp->feedback_buffer[i].buffer);
draw_set_mapped_feedback_buffer(draw, i, NULL, 0);
}
}
/* Note: leave drawing surfaces mapped */
softpipe_unmap_constant_buffers(sp);

8
src/mesa/pipe/softpipe/sp_state.h
View file

@ -102,9 +102,6 @@ void softpipe_set_constant_buffer(struct pipe_context *,
uint shader, uint index,
const struct pipe_constant_buffer *buf);
void softpipe_set_feedback_state( struct pipe_context *,
const struct pipe_feedback_state * );
void *softpipe_create_fs_state(struct pipe_context *,
const struct pipe_shader_state *);
void softpipe_bind_fs_state(struct pipe_context *, void *);
@ -138,11 +135,6 @@ void softpipe_set_vertex_buffer(struct pipe_context *,
unsigned index,
const struct pipe_vertex_buffer *);
void softpipe_set_feedback_buffer(struct pipe_context *,
uint index,
const struct pipe_feedback_buffer *);
void softpipe_update_derived( struct softpipe_context *softpipe );

72
src/mesa/pipe/softpipe/sp_state_feedback.c
View file

@ -1,72 +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.
*
**************************************************************************/
/**
* Authors:
* Brian Paul
*/
#include "sp_context.h"
#include "sp_state.h"
#include "sp_surface.h"
#include "pipe/p_winsys.h"
#include "pipe/draw/draw_context.h"
void
softpipe_set_feedback_state(struct pipe_context *pipe,
const struct pipe_feedback_state *feedback)
{
struct softpipe_context *softpipe = softpipe_context(pipe);
softpipe->feedback = *feedback; /* struct copy */
/*
softpipe->dirty |= SP_NEW_FEEDBACK;
*/
draw_set_feedback_state(softpipe->draw, feedback);
}
void
softpipe_set_feedback_buffer(struct pipe_context *pipe,
unsigned index,
const struct pipe_feedback_buffer *feedback)
{
struct softpipe_context *softpipe = softpipe_context(pipe);
assert(index < PIPE_MAX_FEEDBACK_ATTRIBS);
/* Need to be careful with referencing */
pipe->winsys->buffer_reference(pipe->winsys,
&softpipe->feedback_buffer[index].buffer,
feedback->buffer);
softpipe->feedback_buffer[index].size = feedback->size;
softpipe->feedback_buffer[index].start_offset = feedback->start_offset;
}

1
src/mesa/sources
View file

@ -162,7 +162,6 @@ DRAW_SOURCES = \
pipe/draw/draw_context.c\
pipe/draw/draw_cull.c \
pipe/draw/draw_debug.c \
pipe/draw/draw_feedback.c \
pipe/draw/draw_flatshade.c \
pipe/draw/draw_offset.c \
pipe/draw/draw_prim.c \

44
src/mesa/state_tracker/st_cb_rasterpos.c
View file

@ -173,6 +173,7 @@ static struct rastpos_stage *
new_draw_rastpos_stage(GLcontext *ctx, struct draw_context *draw)
{
struct rastpos_stage *rs = CALLOC_STRUCT(rastpos_stage);
GLuint i;
rs->stage.draw = draw;
rs->stage.next = NULL;
@ -184,6 +185,26 @@ new_draw_rastpos_stage(GLcontext *ctx, struct draw_context *draw)
rs->stage.reset_stipple_counter = rastpos_reset_stipple_counter;
rs->ctx = ctx;
for (i = 0; i < VERT_ATTRIB_MAX; i++) {
rs->array[i].Size = 4;
rs->array[i].Type = GL_FLOAT;
rs->array[i].Stride = 0;
rs->array[i].StrideB = 0;
rs->array[i].Ptr = (GLubyte *) ctx->Current.Attrib[i];
rs->array[i].Enabled = GL_TRUE;
rs->array[i].Normalized = GL_TRUE;
rs->array[i].BufferObj = NULL;
rs->arrays[i] = &rs->array[i];
}
rs->prim.mode = GL_POINTS;
rs->prim.indexed = 0;
rs->prim.begin = 1;
rs->prim.end = 1;
rs->prim.weak = 0;
rs->prim.start = 0;
rs->prim.count = 1;
return rs;
}
@ -201,31 +222,8 @@ st_RasterPos(GLcontext *ctx, const GLfloat v[4])
}
else {
/* create rastpos draw stage */
GLuint i;
rs = new_draw_rastpos_stage(ctx, draw);
st->rastpos_stage = &rs->stage;
/* one-time init */
for (i = 0; i < VERT_ATTRIB_MAX; i++) {
rs->array[i].Size = 4;
rs->array[i].Type = GL_FLOAT;
rs->array[i].Stride = 0;
rs->array[i].StrideB = 0;
rs->array[i].Ptr = (GLubyte *) ctx->Current.Attrib[i];
rs->array[i].Enabled = GL_TRUE;
rs->array[i].Normalized = GL_TRUE;
rs->array[i].BufferObj = NULL;
rs->arrays[i] = &rs->array[i];
}
rs->prim.mode = GL_POINTS;
rs->prim.indexed = 0;
rs->prim.begin = 1;
rs->prim.end = 1;
rs->prim.weak = 0;
rs->prim.start = 0;
rs->prim.count = 1;
}
/* plug our rastpos stage into the draw module */

1
src/mesa/state_tracker/st_context.h
View file

@ -106,7 +106,6 @@ struct st_context
struct pipe_clear_color_state clear_color;
struct pipe_clip_state clip;
struct pipe_constant_buffer constants[2];
struct pipe_feedback_state feedback;
struct pipe_framebuffer_state framebuffer;
struct pipe_texture *texture[PIPE_MAX_SAMPLERS];
struct pipe_poly_stipple poly_stipple;