| /* |
| * Mesa 3-D graphics library |
| * |
| * Copyright (C) 1999-2007 Brian Paul 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, sublicense, |
| * 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 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 NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS 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. |
| */ |
| |
| |
| #include "main/glheader.h" |
| #include "main/context.h" |
| #include "main/imports.h" |
| #include "main/format_pack.h" |
| #include "main/format_unpack.h" |
| #include "main/stencil.h" |
| |
| #include "s_context.h" |
| #include "s_depth.h" |
| #include "s_stencil.h" |
| #include "s_span.h" |
| |
| |
| |
| /* Stencil Logic: |
| |
| IF stencil test fails THEN |
| Apply fail-op to stencil value |
| Don't write the pixel (RGBA,Z) |
| ELSE |
| IF doing depth test && depth test fails THEN |
| Apply zfail-op to stencil value |
| Write RGBA and Z to appropriate buffers |
| ELSE |
| Apply zpass-op to stencil value |
| ENDIF |
| |
| */ |
| |
| |
| |
| /** |
| * Compute/return the offset of the stencil value in a pixel. |
| * For example, if the format is Z24+S8, the position of the stencil bits |
| * within the 4-byte pixel will be either 0 or 3. |
| */ |
| static GLint |
| get_stencil_offset(mesa_format format) |
| { |
| const GLubyte one = 1; |
| GLubyte pixel[MAX_PIXEL_BYTES]; |
| GLint bpp = _mesa_get_format_bytes(format); |
| GLint i; |
| |
| assert(_mesa_get_format_bits(format, GL_STENCIL_BITS) == 8); |
| memset(pixel, 0, sizeof(pixel)); |
| _mesa_pack_ubyte_stencil_row(format, 1, &one, pixel); |
| |
| for (i = 0; i < bpp; i++) { |
| if (pixel[i]) |
| return i; |
| } |
| |
| _mesa_problem(NULL, "get_stencil_offset() failed\n"); |
| return 0; |
| } |
| |
| |
| /** Clamp the stencil value to [0, 255] */ |
| static inline GLubyte |
| clamp(GLint val) |
| { |
| if (val < 0) |
| return 0; |
| else if (val > 255) |
| return 255; |
| else |
| return val; |
| } |
| |
| |
| #define STENCIL_OP(NEW_VAL) \ |
| if (invmask == 0) { \ |
| for (i = j = 0; i < n; i++, j += stride) { \ |
| if (mask[i]) { \ |
| GLubyte s = stencil[j]; \ |
| (void) s; \ |
| stencil[j] = (GLubyte) (NEW_VAL); \ |
| } \ |
| } \ |
| } \ |
| else { \ |
| for (i = j = 0; i < n; i++, j += stride) { \ |
| if (mask[i]) { \ |
| GLubyte s = stencil[j]; \ |
| stencil[j] = (GLubyte) ((invmask & s) | (wrtmask & (NEW_VAL))); \ |
| } \ |
| } \ |
| } |
| |
| |
| /** |
| * Apply the given stencil operator to the array of stencil values. |
| * Don't touch stencil[i] if mask[i] is zero. |
| * @param n number of stencil values |
| * @param oper the stencil buffer operator |
| * @param face 0 or 1 for front or back face operation |
| * @param stencil array of stencil values (in/out) |
| * @param mask array [n] of flag: 1=apply operator, 0=don't apply operator |
| * @param stride stride between stencil values |
| */ |
| static void |
| apply_stencil_op(const struct gl_context *ctx, GLenum oper, GLuint face, |
| GLuint n, GLubyte stencil[], const GLubyte mask[], |
| GLint stride) |
| { |
| const GLubyte ref = _mesa_get_stencil_ref(ctx, face); |
| const GLubyte wrtmask = ctx->Stencil.WriteMask[face]; |
| const GLubyte invmask = (GLubyte) (~wrtmask); |
| GLuint i, j; |
| |
| switch (oper) { |
| case GL_KEEP: |
| /* do nothing */ |
| break; |
| case GL_ZERO: |
| /* replace stencil buf values with zero */ |
| STENCIL_OP(0); |
| break; |
| case GL_REPLACE: |
| /* replace stencil buf values with ref value */ |
| STENCIL_OP(ref); |
| break; |
| case GL_INCR: |
| /* increment stencil buf values, with clamping */ |
| STENCIL_OP(clamp(s + 1)); |
| break; |
| case GL_DECR: |
| /* increment stencil buf values, with clamping */ |
| STENCIL_OP(clamp(s - 1)); |
| break; |
| case GL_INCR_WRAP_EXT: |
| /* increment stencil buf values, without clamping */ |
| STENCIL_OP(s + 1); |
| break; |
| case GL_DECR_WRAP_EXT: |
| /* increment stencil buf values, without clamping */ |
| STENCIL_OP(s - 1); |
| break; |
| case GL_INVERT: |
| /* replace stencil buf values with inverted value */ |
| STENCIL_OP(~s); |
| break; |
| default: |
| _mesa_problem(ctx, "Bad stencil op in apply_stencil_op"); |
| } |
| } |
| |
| |
| |
| #define STENCIL_TEST(FUNC) \ |
| for (i = j = 0; i < n; i++, j += stride) { \ |
| if (mask[i]) { \ |
| s = (GLubyte) (stencil[j] & valueMask); \ |
| if (FUNC) { \ |
| /* stencil pass */ \ |
| fail[i] = 0; \ |
| } \ |
| else { \ |
| /* stencil fail */ \ |
| fail[i] = 1; \ |
| mask[i] = 0; \ |
| } \ |
| } \ |
| else { \ |
| fail[i] = 0; \ |
| } \ |
| } |
| |
| |
| |
| /** |
| * Apply stencil test to an array of stencil values (before depth buffering). |
| * For the values that fail, we'll apply the GL_STENCIL_FAIL operator to |
| * the stencil values. |
| * |
| * @param face 0 or 1 for front or back-face polygons |
| * @param n number of pixels in the array |
| * @param stencil array of [n] stencil values (in/out) |
| * @param mask array [n] of flag: 0=skip the pixel, 1=stencil the pixel, |
| * values are set to zero where the stencil test fails. |
| * @param stride stride between stencil values |
| * @return GL_FALSE = all pixels failed, GL_TRUE = zero or more pixels passed. |
| */ |
| static GLboolean |
| do_stencil_test(struct gl_context *ctx, GLuint face, GLuint n, |
| GLubyte stencil[], GLubyte mask[], GLint stride) |
| { |
| SWcontext *swrast = SWRAST_CONTEXT(ctx); |
| GLubyte *fail = swrast->stencil_temp.buf2; |
| GLboolean allfail = GL_FALSE; |
| GLuint i, j; |
| const GLuint valueMask = ctx->Stencil.ValueMask[face]; |
| const GLubyte ref = (GLubyte) (_mesa_get_stencil_ref(ctx, face) & valueMask); |
| GLubyte s; |
| |
| /* |
| * Perform stencil test. The results of this operation are stored |
| * in the fail[] array: |
| * IF fail[i] is non-zero THEN |
| * the stencil fail operator is to be applied |
| * ELSE |
| * the stencil fail operator is not to be applied |
| * ENDIF |
| */ |
| switch (ctx->Stencil.Function[face]) { |
| case GL_NEVER: |
| STENCIL_TEST(0); |
| allfail = GL_TRUE; |
| break; |
| case GL_LESS: |
| STENCIL_TEST(ref < s); |
| break; |
| case GL_LEQUAL: |
| STENCIL_TEST(ref <= s); |
| break; |
| case GL_GREATER: |
| STENCIL_TEST(ref > s); |
| break; |
| case GL_GEQUAL: |
| STENCIL_TEST(ref >= s); |
| break; |
| case GL_EQUAL: |
| STENCIL_TEST(ref == s); |
| break; |
| case GL_NOTEQUAL: |
| STENCIL_TEST(ref != s); |
| break; |
| case GL_ALWAYS: |
| STENCIL_TEST(1); |
| break; |
| default: |
| _mesa_problem(ctx, "Bad stencil func in gl_stencil_span"); |
| return 0; |
| } |
| |
| if (ctx->Stencil.FailFunc[face] != GL_KEEP) { |
| apply_stencil_op(ctx, ctx->Stencil.FailFunc[face], face, n, stencil, |
| fail, stride); |
| } |
| |
| return !allfail; |
| } |
| |
| |
| /** |
| * Compute the zpass/zfail masks by comparing the pre- and post-depth test |
| * masks. |
| */ |
| static inline void |
| compute_pass_fail_masks(GLuint n, const GLubyte origMask[], |
| const GLubyte newMask[], |
| GLubyte passMask[], GLubyte failMask[]) |
| { |
| GLuint i; |
| for (i = 0; i < n; i++) { |
| assert(newMask[i] == 0 || newMask[i] == 1); |
| passMask[i] = origMask[i] & newMask[i]; |
| failMask[i] = origMask[i] & (newMask[i] ^ 1); |
| } |
| } |
| |
| |
| /** |
| * Get 8-bit stencil values from random locations in the stencil buffer. |
| */ |
| static void |
| get_s8_values(struct gl_context *ctx, struct gl_renderbuffer *rb, |
| GLuint count, const GLint x[], const GLint y[], |
| GLubyte stencil[]) |
| { |
| struct swrast_renderbuffer *srb = swrast_renderbuffer(rb); |
| const GLint w = rb->Width, h = rb->Height; |
| const GLubyte *map = _swrast_pixel_address(rb, 0, 0); |
| GLuint i; |
| |
| if (rb->Format == MESA_FORMAT_S_UINT8) { |
| const GLint rowStride = srb->RowStride; |
| for (i = 0; i < count; i++) { |
| if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) { |
| stencil[i] = *(map + y[i] * rowStride + x[i]); |
| } |
| } |
| } |
| else { |
| const GLint bpp = _mesa_get_format_bytes(rb->Format); |
| const GLint rowStride = srb->RowStride; |
| for (i = 0; i < count; i++) { |
| if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) { |
| const GLubyte *src = map + y[i] * rowStride + x[i] * bpp; |
| _mesa_unpack_ubyte_stencil_row(rb->Format, 1, src, &stencil[i]); |
| } |
| } |
| } |
| } |
| |
| |
| /** |
| * Put 8-bit stencil values at random locations into the stencil buffer. |
| */ |
| static void |
| put_s8_values(struct gl_context *ctx, struct gl_renderbuffer *rb, |
| GLuint count, const GLint x[], const GLint y[], |
| const GLubyte stencil[]) |
| { |
| const GLint w = rb->Width, h = rb->Height; |
| gl_pack_ubyte_stencil_func pack_stencil = |
| _mesa_get_pack_ubyte_stencil_func(rb->Format); |
| GLuint i; |
| |
| for (i = 0; i < count; i++) { |
| if (x[i] >= 0 && y[i] >= 0 && x[i] < w && y[i] < h) { |
| GLubyte *dst = _swrast_pixel_address(rb, x[i], y[i]); |
| pack_stencil(&stencil[i], dst); |
| } |
| } |
| } |
| |
| |
| /** |
| * /return GL_TRUE = one or more fragments passed, |
| * GL_FALSE = all fragments failed. |
| */ |
| GLboolean |
| _swrast_stencil_and_ztest_span(struct gl_context *ctx, SWspan *span) |
| { |
| SWcontext *swrast = SWRAST_CONTEXT(ctx); |
| struct gl_framebuffer *fb = ctx->DrawBuffer; |
| struct gl_renderbuffer *rb = fb->Attachment[BUFFER_STENCIL].Renderbuffer; |
| const GLint stencilOffset = get_stencil_offset(rb->Format); |
| const GLint stencilStride = _mesa_get_format_bytes(rb->Format); |
| const GLuint face = (span->facing == 0) ? 0 : ctx->Stencil._BackFace; |
| const GLuint count = span->end; |
| GLubyte *mask = span->array->mask; |
| GLubyte *stencilTemp = swrast->stencil_temp.buf1; |
| GLubyte *stencilBuf; |
| |
| if (span->arrayMask & SPAN_XY) { |
| /* read stencil values from random locations */ |
| get_s8_values(ctx, rb, count, span->array->x, span->array->y, |
| stencilTemp); |
| stencilBuf = stencilTemp; |
| } |
| else { |
| /* Processing a horizontal run of pixels. Since stencil is always |
| * 8 bits for all MESA_FORMATs, we just need to use the right offset |
| * and stride to access them. |
| */ |
| stencilBuf = _swrast_pixel_address(rb, span->x, span->y) + stencilOffset; |
| } |
| |
| /* |
| * Apply the stencil test to the fragments. |
| * failMask[i] is 1 if the stencil test failed. |
| */ |
| if (!do_stencil_test(ctx, face, count, stencilBuf, mask, stencilStride)) { |
| /* all fragments failed the stencil test, we're done. */ |
| span->writeAll = GL_FALSE; |
| if (span->arrayMask & SPAN_XY) { |
| /* need to write the updated stencil values back to the buffer */ |
| put_s8_values(ctx, rb, count, span->array->x, span->array->y, |
| stencilTemp); |
| } |
| return GL_FALSE; |
| } |
| |
| /* |
| * Some fragments passed the stencil test, apply depth test to them |
| * and apply Zpass and Zfail stencil ops. |
| */ |
| if (ctx->Depth.Test == GL_FALSE || |
| ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer == NULL) { |
| /* |
| * No depth buffer, just apply zpass stencil function to active pixels. |
| */ |
| apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face, count, |
| stencilBuf, mask, stencilStride); |
| } |
| else { |
| /* |
| * Perform depth buffering, then apply zpass or zfail stencil function. |
| */ |
| SWcontext *swrast = SWRAST_CONTEXT(ctx); |
| GLubyte *passMask = swrast->stencil_temp.buf2; |
| GLubyte *failMask = swrast->stencil_temp.buf3; |
| GLubyte *origMask = swrast->stencil_temp.buf4; |
| |
| /* save the current mask bits */ |
| memcpy(origMask, mask, count * sizeof(GLubyte)); |
| |
| /* apply the depth test */ |
| _swrast_depth_test_span(ctx, span); |
| |
| compute_pass_fail_masks(count, origMask, mask, passMask, failMask); |
| |
| /* apply the pass and fail operations */ |
| if (ctx->Stencil.ZFailFunc[face] != GL_KEEP) { |
| apply_stencil_op(ctx, ctx->Stencil.ZFailFunc[face], face, |
| count, stencilBuf, failMask, stencilStride); |
| } |
| if (ctx->Stencil.ZPassFunc[face] != GL_KEEP) { |
| apply_stencil_op(ctx, ctx->Stencil.ZPassFunc[face], face, |
| count, stencilBuf, passMask, stencilStride); |
| } |
| } |
| |
| /* Write updated stencil values back into hardware stencil buffer */ |
| if (span->arrayMask & SPAN_XY) { |
| put_s8_values(ctx, rb, count, span->array->x, span->array->y, |
| stencilBuf); |
| } |
| |
| span->writeAll = GL_FALSE; |
| |
| return GL_TRUE; /* one or more fragments passed both tests */ |
| } |
| |
| |
| |
| |
| /** |
| * Return a span of stencil values from the stencil buffer. |
| * Used for glRead/CopyPixels |
| * Input: n - how many pixels |
| * x,y - location of first pixel |
| * Output: stencil - the array of stencil values |
| */ |
| void |
| _swrast_read_stencil_span(struct gl_context *ctx, struct gl_renderbuffer *rb, |
| GLint n, GLint x, GLint y, GLubyte stencil[]) |
| { |
| GLubyte *src; |
| |
| if (y < 0 || y >= (GLint) rb->Height || |
| x + n <= 0 || x >= (GLint) rb->Width) { |
| /* span is completely outside framebuffer */ |
| return; /* undefined values OK */ |
| } |
| |
| if (x < 0) { |
| GLint dx = -x; |
| x = 0; |
| n -= dx; |
| stencil += dx; |
| } |
| if (x + n > (GLint) rb->Width) { |
| GLint dx = x + n - rb->Width; |
| n -= dx; |
| } |
| if (n <= 0) { |
| return; |
| } |
| |
| src = _swrast_pixel_address(rb, x, y); |
| _mesa_unpack_ubyte_stencil_row(rb->Format, n, src, stencil); |
| } |
| |
| |
| |
| /** |
| * Write a span of stencil values to the stencil buffer. This function |
| * applies the stencil write mask when needed. |
| * Used for glDraw/CopyPixels |
| * Input: n - how many pixels |
| * x, y - location of first pixel |
| * stencil - the array of stencil values |
| */ |
| void |
| _swrast_write_stencil_span(struct gl_context *ctx, GLint n, GLint x, GLint y, |
| const GLubyte stencil[] ) |
| { |
| SWcontext *swrast = SWRAST_CONTEXT(ctx); |
| struct gl_framebuffer *fb = ctx->DrawBuffer; |
| struct gl_renderbuffer *rb = fb->Attachment[BUFFER_STENCIL].Renderbuffer; |
| const GLuint stencilMax = (1 << fb->Visual.stencilBits) - 1; |
| const GLuint stencilMask = ctx->Stencil.WriteMask[0]; |
| GLubyte *stencilBuf; |
| |
| if (y < 0 || y >= (GLint) rb->Height || |
| x + n <= 0 || x >= (GLint) rb->Width) { |
| /* span is completely outside framebuffer */ |
| return; /* undefined values OK */ |
| } |
| if (x < 0) { |
| GLint dx = -x; |
| x = 0; |
| n -= dx; |
| stencil += dx; |
| } |
| if (x + n > (GLint) rb->Width) { |
| GLint dx = x + n - rb->Width; |
| n -= dx; |
| } |
| if (n <= 0) { |
| return; |
| } |
| |
| stencilBuf = _swrast_pixel_address(rb, x, y); |
| |
| if ((stencilMask & stencilMax) != stencilMax) { |
| /* need to apply writemask */ |
| GLubyte *destVals = swrast->stencil_temp.buf1; |
| GLubyte *newVals = swrast->stencil_temp.buf2; |
| GLint i; |
| |
| _mesa_unpack_ubyte_stencil_row(rb->Format, n, stencilBuf, destVals); |
| for (i = 0; i < n; i++) { |
| newVals[i] |
| = (stencil[i] & stencilMask) | (destVals[i] & ~stencilMask); |
| } |
| _mesa_pack_ubyte_stencil_row(rb->Format, n, newVals, stencilBuf); |
| } |
| else { |
| _mesa_pack_ubyte_stencil_row(rb->Format, n, stencil, stencilBuf); |
| } |
| } |
| |
| |
| |
| /** |
| * Clear the stencil buffer. If the buffer is a combined |
| * depth+stencil buffer, only the stencil bits will be touched. |
| */ |
| void |
| _swrast_clear_stencil_buffer(struct gl_context *ctx) |
| { |
| struct gl_renderbuffer *rb = |
| ctx->DrawBuffer->Attachment[BUFFER_STENCIL].Renderbuffer; |
| const GLubyte stencilBits = ctx->DrawBuffer->Visual.stencilBits; |
| const GLuint writeMask = ctx->Stencil.WriteMask[0]; |
| const GLuint stencilMax = (1 << stencilBits) - 1; |
| GLint x, y, width, height; |
| GLubyte *map; |
| GLint rowStride, i, j; |
| GLbitfield mapMode; |
| |
| if (!rb || writeMask == 0) |
| return; |
| |
| /* compute region to clear */ |
| x = ctx->DrawBuffer->_Xmin; |
| y = ctx->DrawBuffer->_Ymin; |
| width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin; |
| height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin; |
| |
| mapMode = GL_MAP_WRITE_BIT; |
| if ((writeMask & stencilMax) != stencilMax) { |
| /* need to mask stencil values */ |
| mapMode |= GL_MAP_READ_BIT; |
| } |
| else if (_mesa_get_format_bits(rb->Format, GL_DEPTH_BITS) > 0) { |
| /* combined depth+stencil, need to mask Z values */ |
| mapMode |= GL_MAP_READ_BIT; |
| } |
| |
| ctx->Driver.MapRenderbuffer(ctx, rb, x, y, width, height, |
| mapMode, &map, &rowStride, |
| ctx->DrawBuffer->FlipY); |
| if (!map) { |
| _mesa_error(ctx, GL_OUT_OF_MEMORY, "glClear(stencil)"); |
| return; |
| } |
| |
| switch (rb->Format) { |
| case MESA_FORMAT_S_UINT8: |
| { |
| GLubyte clear = ctx->Stencil.Clear & writeMask & 0xff; |
| GLubyte mask = (~writeMask) & 0xff; |
| if (mask != 0) { |
| /* masked clear */ |
| for (i = 0; i < height; i++) { |
| GLubyte *row = map; |
| for (j = 0; j < width; j++) { |
| row[j] = (row[j] & mask) | clear; |
| } |
| map += rowStride; |
| } |
| } |
| else if (rowStride == width) { |
| /* clear whole buffer */ |
| memset(map, clear, width * height); |
| } |
| else { |
| /* clear scissored */ |
| for (i = 0; i < height; i++) { |
| memset(map, clear, width); |
| map += rowStride; |
| } |
| } |
| } |
| break; |
| case MESA_FORMAT_Z24_UNORM_S8_UINT: |
| { |
| GLuint clear = (ctx->Stencil.Clear & writeMask & 0xff) << 24; |
| GLuint mask = (((~writeMask) & 0xff) << 24) | 0xffffff; |
| for (i = 0; i < height; i++) { |
| GLuint *row = (GLuint *) map; |
| for (j = 0; j < width; j++) { |
| row[j] = (row[j] & mask) | clear; |
| } |
| map += rowStride; |
| } |
| } |
| break; |
| case MESA_FORMAT_S8_UINT_Z24_UNORM: |
| { |
| GLuint clear = ctx->Stencil.Clear & writeMask & 0xff; |
| GLuint mask = 0xffffff00 | ((~writeMask) & 0xff); |
| for (i = 0; i < height; i++) { |
| GLuint *row = (GLuint *) map; |
| for (j = 0; j < width; j++) { |
| row[j] = (row[j] & mask) | clear; |
| } |
| map += rowStride; |
| } |
| } |
| break; |
| default: |
| _mesa_problem(ctx, "Unexpected stencil buffer format %s" |
| " in _swrast_clear_stencil_buffer()", |
| _mesa_get_format_name(rb->Format)); |
| } |
| |
| ctx->Driver.UnmapRenderbuffer(ctx, rb); |
| } |
