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;
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 );
}
-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.
}
-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 */
-}
-
-
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 );
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);
/***********************************************************************
+++ /dev/null
-/**************************************************************************
- *
- * 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;
-}
-
-
struct draw_stage *validate;
/* stages (in logical order) */
- struct draw_stage *feedback;
struct draw_stage *flatshade;
struct draw_stage *clip;
struct draw_stage *cull;
/* 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 {
/** 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:
-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 );
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 );
}
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]);
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;
}
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;
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;
}
-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)
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;
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 * );
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,
};
-/**
- * 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];
};
};
-/**
- * Vertex feedback buffer
- */
-struct pipe_feedback_buffer {
- struct pipe_buffer_handle *buffer;
- unsigned size;
- unsigned start_offset;
-};
-
/**
* Hardware queries (occlusion, transform feedback, timing, etc)
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 \
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;
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;
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;
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:
*/
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);
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);
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 *);
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 );
+++ /dev/null
-/**************************************************************************
- *
- * 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;
-}
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 \
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;
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;
}
}
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 */
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;
projects / platform / upstream / mesa.git / commitdiff