for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
const GLuint attr = FRAG_ATTRIB_TEX0 + i;
const GLfloat *tc = ctx->Current.RasterTexCoords[i];
- if (ctx->FragmentProgram._Current || ctx->ATIFragmentShader._Enabled) {
+ if (_swrast_use_fragment_program(ctx) ||
+ ctx->ATIFragmentShader._Enabled) {
COPY_4V(span->attrStart[attr], tc);
}
else if (tc[3] > 0.0F) {
swrast_texture_image_const(img);
needLambda = (obj->Sampler.MinFilter != obj->Sampler.MagFilter)
- || ctx->FragmentProgram._Current;
+ || _swrast_use_fragment_program(ctx);
/* LOD is calculated directly in the ansiotropic filter, we can
* skip the normal lambda function as the result is ignored.
*/
if (needLambda) {
GLuint i;
- if (ctx->FragmentProgram._Current
+ if (_swrast_use_fragment_program(ctx)
|| ctx->ATIFragmentShader._Enabled) {
/* do perspective correction but don't divide s, t, r by q */
const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];
}
else {
GLuint i;
- if (ctx->FragmentProgram._Current ||
+ if (_swrast_use_fragment_program(ctx) ||
ctx->ATIFragmentShader._Enabled) {
/* do perspective correction but don't divide s, t, r by q */
const GLfloat dwdx = span->attrStepX[FRAG_ATTRIB_WPOS][3];
GLfloat (*col1)[4] = span->array->attribs[FRAG_ATTRIB_COL1];
GLuint i;
- ASSERT(!ctx->FragmentProgram._Current);
+ ASSERT(!_swrast_use_fragment_program(ctx));
ASSERT(span->arrayMask & SPAN_RGBA);
ASSERT(swrast->_ActiveAttribMask & FRAG_BIT_COL1);
(void) swrast; /* silence warning */
static inline void
shade_texture_span(struct gl_context *ctx, SWspan *span)
{
- /* This is a hack to work around drivers such as i965 that:
- *
- * - Set _MaintainTexEnvProgram to generate GLSL IR for
- * fixed-function fragment processing.
- * - Don't call _mesa_ir_link_shader to generate Mesa IR from
- * the GLSL IR.
- * - May use swrast to handle glDrawPixels.
- *
- * Since _mesa_ir_link_shader is never called, there is no Mesa IR
- * to execute. Instead do regular fixed-function processing.
- *
- * It is also worth noting that the software fixed-function path is
- * much faster than the software shader path.
- */
- const bool use_fragment_program =
- ctx->FragmentProgram._Current
- && ctx->FragmentProgram._Current != ctx->FragmentProgram._TexEnvProgram;
-
- if (use_fragment_program ||
+ if (_swrast_use_fragment_program(ctx) ||
ctx->ATIFragmentShader._Enabled) {
/* programmable shading */
if (span->primitive == GL_BITMAP && span->array->ChanType != GL_FLOAT) {
interpolate_wpos(ctx, span);
/* Run fragment program/shader now */
- if (use_fragment_program) {
+ if (_swrast_use_fragment_program(ctx)) {
_swrast_exec_fragment_program(ctx, span);
}
else {
/** Put colors at x/y locations into a renderbuffer */
static void
put_values(struct gl_context *ctx, struct gl_renderbuffer *rb,
+ GLenum datatype,
GLuint count, const GLint x[], const GLint y[],
const void *values, const GLubyte *mask)
{
+ gl_pack_ubyte_rgba_func pack_ubyte = NULL;
+ gl_pack_float_rgba_func pack_float = NULL;
GLuint i;
+ if (datatype == GL_UNSIGNED_BYTE)
+ pack_ubyte = _mesa_get_pack_ubyte_rgba_function(rb->Format);
+ else
+ pack_float = _mesa_get_pack_float_rgba_function(rb->Format);
+
for (i = 0; i < count; i++) {
if (mask[i]) {
GLubyte *dst = _swrast_pixel_address(rb, x[i], y[i]);
- if (rb->DataType == GL_UNSIGNED_BYTE) {
- _mesa_pack_ubyte_rgba_row(rb->Format, 1,
- (const GLubyte (*)[4]) values + i, dst);
+ if (datatype == GL_UNSIGNED_BYTE) {
+ pack_ubyte((const GLubyte *) values + 4 * i, dst);
}
else {
- assert(rb->DataType == GL_FLOAT);
- _mesa_pack_float_rgba_row(rb->Format, count,
- (const GLfloat (*)[4]) values + i, dst);
+ assert(datatype == GL_FLOAT);
+ pack_float((const GLfloat *) values + 4 * i, dst);
}
}
}
/** Put row of colors into renderbuffer */
void
_swrast_put_row(struct gl_context *ctx, struct gl_renderbuffer *rb,
+ GLenum datatype,
GLuint count, GLint x, GLint y,
const void *values, const GLubyte *mask)
{
GLubyte *dst = _swrast_pixel_address(rb, x, y);
if (!mask) {
- if (rb->DataType == GL_UNSIGNED_BYTE) {
+ if (datatype == GL_UNSIGNED_BYTE) {
_mesa_pack_ubyte_rgba_row(rb->Format, count,
(const GLubyte (*)[4]) values, dst);
}
else {
- assert(rb->DataType == GL_FLOAT);
+ assert(datatype == GL_FLOAT);
_mesa_pack_float_rgba_row(rb->Format, count,
(const GLfloat (*)[4]) values, dst);
}
/* We can't pass a 'mask' array to the _mesa_pack_rgba_row() functions
* so look for runs where mask=1...
*/
- runLen = 0;
+ runLen = runStart = 0;
for (i = 0; i < count; i++) {
if (mask[i]) {
if (runLen == 0)
if (!mask[i] || i == count - 1) {
/* might be the end of a run of pixels */
if (runLen > 0) {
- if (rb->DataType == GL_UNSIGNED_BYTE) {
+ if (datatype == GL_UNSIGNED_BYTE) {
_mesa_pack_ubyte_rgba_row(rb->Format, runLen,
(const GLubyte (*)[4]) values + runStart,
dst + runStart * bpp);
}
else {
- assert(rb->DataType == GL_FLOAT);
+ assert(datatype == GL_FLOAT);
_mesa_pack_float_rgba_row(rb->Format, runLen,
(const GLfloat (*)[4]) values + runStart,
dst + runStart * bpp);
const GLbitfield64 origArrayAttribs = span->arrayAttribs;
const GLenum origChanType = span->array->ChanType;
void * const origRgba = span->array->rgba;
- const GLboolean shader = (ctx->FragmentProgram._Current
+ const GLboolean shader = (_swrast_use_fragment_program(ctx)
|| ctx->ATIFragmentShader._Enabled);
const GLboolean shaderOrTexture = shader || ctx->Texture._EnabledCoordUnits;
struct gl_framebuffer *fb = ctx->DrawBuffer;
return;
}
- ASSERT(span->end <= MAX_WIDTH);
+ ASSERT(span->end <= SWRAST_MAX_WIDTH);
/* Depth bounds test */
if (ctx->Depth.BoundsTest && fb->Visual.depthBits > 0) {
const GLuint numBuffers = fb->_NumColorDrawBuffers;
const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;
const GLboolean multiFragOutputs =
- (fp && fp->Base.OutputsWritten >= (1 << FRAG_RESULT_DATA0));
+ _swrast_use_fragment_program(ctx)
+ && fp->Base.OutputsWritten >= (1 << FRAG_RESULT_DATA0);
GLuint buf;
for (buf = 0; buf < numBuffers; buf++) {
/* color[fragOutput] will be written to buffer[buf] */
if (rb) {
- GLchan rgbaSave[MAX_WIDTH][4];
- const GLuint fragOutput = multiFragOutputs ? buf : 0;
+ /* re-use one of the attribute array buffers for rgbaSave */
+ GLchan (*rgbaSave)[4] = (GLchan (*)[4]) span->array->attribs[0];
+ struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
+ GLenum colorType = srb->ColorType;
- /* set span->array->rgba to colors for render buffer's datatype */
- if (rb->DataType != span->array->ChanType || fragOutput > 0) {
- convert_color_type(span, rb->DataType, fragOutput);
+ assert(colorType == GL_UNSIGNED_BYTE ||
+ colorType == GL_FLOAT);
+
+ /* set span->array->rgba to colors for renderbuffer's datatype */
+ if (span->array->ChanType != colorType) {
+ convert_color_type(span, colorType, 0);
}
else {
- if (rb->DataType == GL_UNSIGNED_BYTE) {
+ if (span->array->ChanType == GL_UNSIGNED_BYTE) {
span->array->rgba = span->array->rgba8;
}
- else if (rb->DataType == GL_UNSIGNED_SHORT) {
- span->array->rgba = (void *) span->array->rgba16;
- }
else {
span->array->rgba = (void *)
span->array->attribs[FRAG_ATTRIB_COL0];
if (span->arrayMask & SPAN_XY) {
/* array of pixel coords */
- put_values(ctx, rb, span->end,
+ put_values(ctx, rb,
+ span->array->ChanType, span->end,
span->array->x, span->array->y,
span->array->rgba, span->array->mask);
}
else {
/* horizontal run of pixels */
- _swrast_put_row(ctx, rb, span->end, span->x, span->y,
+ _swrast_put_row(ctx, rb,
+ span->array->ChanType,
+ span->end, span->x, span->y,
span->array->rgba,
span->writeAll ? NULL: span->array->mask);
}
GLuint n, GLint x, GLint y,
GLvoid *rgba)
{
+ struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
GLenum dstType = GL_FLOAT;
const GLint bufWidth = (GLint) rb->Width;
const GLint bufHeight = (GLint) rb->Height;
rb->_BaseFormat == GL_LUMINANCE_ALPHA ||
rb->_BaseFormat == GL_ALPHA);
- assert(rb->Map);
+ assert(srb->Map);
src = _swrast_pixel_address(rb, x + skip, y);
projects / mesa.git / blobdiff