OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

swrast: Remove _swrast_write_index_span and associated code

Browse Source 
After all the recent color-index rendering removal,
_swrast_write_index_span is no longer used anywhere.

Signed-off-by: Ian Romanick <ian.d.romanick@intel.com>
This commit is contained in:
Ian Romanick
2010-02-24 16:05:20 -08:00
parent 2b7911d37d
commit c00282102a
2 changed files with 0 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

275
src/mesa/swrast/s_span.c
View File

@@ -367,38 +367,6 @@ interpolate_float_colors(SWspan *span)
/* Fill in the span.color.index array from the interpolation values */
static INLINE void
interpolate_indexes(GLcontext *ctx, SWspan *span)
{
GLfixed index = span->index;
const GLint indexStep = span->indexStep;
const GLuint n = span->end;
GLuint *indexes = span->array->index;
GLuint i;
(void) ctx;
ASSERT(!(span->arrayMask & SPAN_INDEX));
if ((span->interpMask & SPAN_FLAT) || (indexStep == 0)) {
/* constant color */
index = FixedToInt(index);
for (i = 0; i < n; i++) {
indexes[i] = index;
}
}
else {
/* interpolate */
for (i = 0; i < n; i++) {
indexes[i] = FixedToInt(index);
index += indexStep;
}
}
span->arrayMask |= SPAN_INDEX;
span->interpMask &= ~SPAN_INDEX;
}
/**
* Fill in the span.zArray array from the span->z, zStep values.
*/
@@ -834,249 +802,6 @@ clip_span( GLcontext *ctx, SWspan *span )
}
/**
* Apply all the per-fragment opertions to a span of color index fragments
* and write them to the enabled color drawbuffers.
* The 'span' parameter can be considered to be const. Note that
* span->interpMask and span->arrayMask may be changed but will be restored
* to their original values before returning.
*/
void
_swrast_write_index_span( GLcontext *ctx, SWspan *span)
{
const SWcontext *swrast = SWRAST_CONTEXT(ctx);
const GLbitfield origInterpMask = span->interpMask;
const GLbitfield origArrayMask = span->arrayMask;
struct gl_framebuffer *fb = ctx->DrawBuffer;
ASSERT(span->end <= MAX_WIDTH);
ASSERT(span->primitive == GL_POINT || span->primitive == GL_LINE ||
span->primitive == GL_POLYGON || span->primitive == GL_BITMAP);
ASSERT((span->interpMask | span->arrayMask) & SPAN_INDEX);
/*
ASSERT((span->interpMask & span->arrayMask) == 0);
*/
if (span->arrayMask & SPAN_MASK) {
/* mask was initialized by caller, probably glBitmap */
span->writeAll = GL_FALSE;
}
else {
memset(span->array->mask, 1, span->end);
span->writeAll = GL_TRUE;
}
/* Clipping */
if ((swrast->_RasterMask & CLIP_BIT) || (span->primitive != GL_POLYGON)) {
if (!clip_span(ctx, span)) {
return;
}
}
if (!(span->arrayMask & SPAN_MASK)) {
/* post-clip sanity check */
assert(span->x >= 0);
assert(span->y >= 0);
}
/* Depth bounds test */
if (ctx->Depth.BoundsTest && fb->Visual.depthBits > 0) {
if (!_swrast_depth_bounds_test(ctx, span)) {
return;
}
}
#ifdef DEBUG
/* Make sure all fragments are within window bounds */
if (span->arrayMask & SPAN_XY) {
GLuint i;
for (i = 0; i < span->end; i++) {
if (span->array->mask[i]) {
assert(span->array->x[i] >= fb->_Xmin);
assert(span->array->x[i] < fb->_Xmax);
assert(span->array->y[i] >= fb->_Ymin);
assert(span->array->y[i] < fb->_Ymax);
}
}
}
#endif
/* Polygon Stippling */
if (ctx->Polygon.StippleFlag && span->primitive == GL_POLYGON) {
stipple_polygon_span(ctx, span);
}
/* Stencil and Z testing */
if (ctx->Stencil._Enabled || ctx->Depth.Test) {
if (!(span->arrayMask & SPAN_Z))
_swrast_span_interpolate_z(ctx, span);
if (ctx->Transform.DepthClamp)
_swrast_depth_clamp_span(ctx, span);
if (ctx->Stencil._Enabled) {
if (!_swrast_stencil_and_ztest_span(ctx, span)) {
span->arrayMask = origArrayMask;
return;
}
}
else {
ASSERT(ctx->Depth.Test);
if (!_swrast_depth_test_span(ctx, span)) {
span->interpMask = origInterpMask;
span->arrayMask = origArrayMask;
return;
}
}
}
if (ctx->Query.CurrentOcclusionObject) {
/* update count of 'passed' fragments */
struct gl_query_object *q = ctx->Query.CurrentOcclusionObject;
GLuint i;
for (i = 0; i < span->end; i++)
q->Result += span->array->mask[i];
}
/* we have to wait until after occlusion to do this test */
if (ctx->Color.IndexMask == 0) {
/* write no pixels */
span->arrayMask = origArrayMask;
return;
}
/* Interpolate the color indexes if needed */
if (swrast->_FogEnabled ||
ctx->Color.IndexLogicOpEnabled ||
ctx->Color.IndexMask != 0xffffffff ||
(span->arrayMask & SPAN_COVERAGE)) {
if (!(span->arrayMask & SPAN_INDEX) /*span->interpMask & SPAN_INDEX*/) {
interpolate_indexes(ctx, span);
}
}
/* Fog */
if (swrast->_FogEnabled) {
_swrast_fog_ci_span(ctx, span);
}
/* Antialias coverage application */
if (span->arrayMask & SPAN_COVERAGE) {
const GLfloat *coverage = span->array->coverage;
GLuint *index = span->array->index;
GLuint i;
for (i = 0; i < span->end; i++) {
ASSERT(coverage[i] < 16);
index[i] = (index[i] & ~0xf) | ((GLuint) coverage[i]);
}
}
/*
* Write to renderbuffers
*/
{
const GLuint numBuffers = fb->_NumColorDrawBuffers;
GLuint buf;
for (buf = 0; buf < numBuffers; buf++) {
struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];
GLuint indexSave[MAX_WIDTH];
ASSERT(rb->_BaseFormat == GL_COLOR_INDEX);
if (numBuffers > 1) {
/* save indexes for second, third renderbuffer writes */
memcpy(indexSave, span->array->index,
span->end * sizeof(indexSave[0]));
}
if (ctx->Color.IndexLogicOpEnabled) {
_swrast_logicop_ci_span(ctx, rb, span);
}
if (ctx->Color.IndexMask != 0xffffffff) {
_swrast_mask_ci_span(ctx, rb, span);
}
if (!(span->arrayMask & SPAN_INDEX) && span->indexStep == 0) {
/* all fragments have same color index */
GLubyte index8;
GLushort index16;
GLuint index32;
void *value;
if (rb->DataType == GL_UNSIGNED_BYTE) {
index8 = FixedToInt(span->index);
value = &index8;
}
else if (rb->DataType == GL_UNSIGNED_SHORT) {
index16 = FixedToInt(span->index);
value = &index16;
}
else {
ASSERT(rb->DataType == GL_UNSIGNED_INT);
index32 = FixedToInt(span->index);
value = &index32;
}
if (span->arrayMask & SPAN_XY) {
rb->PutMonoValues(ctx, rb, span->end, span->array->x,
span->array->y, value, span->array->mask);
}
else {
rb->PutMonoRow(ctx, rb, span->end, span->x, span->y,
value, span->array->mask);
}
}
else {
/* each fragment is a different color */
GLubyte index8[MAX_WIDTH];
GLushort index16[MAX_WIDTH];
void *values;
if (rb->DataType == GL_UNSIGNED_BYTE) {
GLuint k;
for (k = 0; k < span->end; k++) {
index8[k] = (GLubyte) span->array->index[k];
}
values = index8;
}
else if (rb->DataType == GL_UNSIGNED_SHORT) {
GLuint k;
for (k = 0; k < span->end; k++) {
index16[k] = (GLushort) span->array->index[k];
}
values = index16;
}
else {
ASSERT(rb->DataType == GL_UNSIGNED_INT);
values = span->array->index;
}
if (span->arrayMask & SPAN_XY) {
rb->PutValues(ctx, rb, span->end,
span->array->x, span->array->y,
values, span->array->mask);
}
else {
rb->PutRow(ctx, rb, span->end, span->x, span->y,
values, span->array->mask);
}
}
if (buf + 1 < numBuffers) {
/* restore original span values */
memcpy(span->array->index, indexSave,
span->end * sizeof(indexSave[0]));
}
} /* for buf */
}
span->interpMask = origInterpMask;
span->arrayMask = origArrayMask;
}
/**
* Add specular colors to primary colors.
* Only called during fixed-function operation.

3
src/mesa/swrast/s_span.h
View File

@@ -187,9 +187,6 @@ _swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy,
GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH,
GLfloat s, GLfloat t, GLfloat q, GLfloat invQ);
extern void
_swrast_write_index_span( GLcontext *ctx, SWspan *span);
extern void
_swrast_write_rgba_span( GLcontext *ctx, SWspan *span);