-/* $Id: depth.c,v 1.15 2000/03/19 01:10:11 brianp Exp $ */
+/* $Id: depth.c,v 1.17 2000/04/11 20:42:22 brianp Exp $ */
/*
* Mesa 3-D graphics library
}
break;
case GL_NEVER:
- MEMSET(mask, 0, n * sizeof(GLubyte));
+ BZERO(mask, n * sizeof(GLubyte));
break;
default:
gl_problem(ctx, "Bad depth func in depth_test_span16");
}
break;
case GL_NEVER:
- MEMSET(mask, 0, n * sizeof(GLubyte));
+ BZERO(mask, n * sizeof(GLubyte));
break;
default:
gl_problem(ctx, "Bad depth func in depth_test_span32");
break;
case GL_NEVER:
/* depth test never passes */
- MEMSET(mask, 0, n * sizeof(GLubyte));
+ BZERO(mask, n * sizeof(GLubyte));
break;
default:
gl_problem(ctx, "Bad depth func in software_depth_test_pixels");
break;
case GL_NEVER:
/* depth test never passes */
- MEMSET(mask, 0, n * sizeof(GLubyte));
+ BZERO(mask, n * sizeof(GLubyte));
break;
default:
gl_problem(ctx, "Bad depth func in software_depth_test_pixels");
break;
case GL_NEVER:
/* depth test never passes */
- MEMSET(mask, 0, n * sizeof(GLubyte));
+ BZERO(mask, n * sizeof(GLubyte));
break;
default:
gl_problem(ctx, "Bad depth func in hardware_depth_test_pixels");
/**********************************************************************/
+/*
+ * Read a span of depth values from the depth buffer.
+ * This function does clipping before calling the device driver function.
+ */
+void
+_mesa_read_depth_span( GLcontext *ctx,
+ GLint n, GLint x, GLint y, GLdepth depth[] )
+{
+ if (y < 0 || y >= ctx->DrawBuffer->Height ||
+ x + (GLint) n <= 0 || x >= ctx->DrawBuffer->Width) {
+ /* span is completely outside framebuffer */
+ GLint i;
+ for (i = 0; i < n; i++)
+ depth[i] = 0;
+ return;
+ }
+
+ if (x < 0) {
+ GLint dx = -x;
+ GLint i;
+ for (i = 0; i < dx; i++)
+ depth[i] = 0;
+ x = 0;
+ n -= dx;
+ depth += dx;
+ }
+ if (x + n > ctx->DrawBuffer->Width) {
+ GLint dx = x + n - ctx->DrawBuffer->Width;
+ GLint i;
+ for (i = 0; i < dx; i++)
+ depth[n - i - 1] = 0;
+ n -= dx;
+ }
+ if (n <= 0) {
+ return;
+ }
+
+ if (ctx->DrawBuffer->DepthBuffer) {
+ /* read from software depth buffer */
+ if (ctx->Visual->DepthBits <= 16) {
+ const GLushort *zptr = Z_ADDRESS16( ctx, x, y );
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ depth[i] = zptr[i];
+ }
+ }
+ else {
+ const GLuint *zptr = Z_ADDRESS32( ctx, x, y );
+ GLuint i;
+ for (i = 0; i < n; i++) {
+ depth[i] = zptr[i];
+ }
+ }
+ }
+ else if (ctx->Driver.ReadDepthSpan) {
+ /* read from hardware depth buffer */
+ (*ctx->Driver.ReadDepthSpan)( ctx, n, x, y, depth );
+ }
+ else {
+ /* no depth buffer */
+ BZERO(depth, n * sizeof(GLfloat));
+ }
+
+}
+
+
+
+
/*
* Return a span of depth values from the depth buffer as floats in [0,1].
* This is used for both hardware and software depth buffers.
* Output: depth - the array of depth values
*/
void
-_mesa_read_depth_span_float( GLcontext* ctx,
- GLuint n, GLint x, GLint y, GLfloat depth[] )
+_mesa_read_depth_span_float( GLcontext *ctx,
+ GLint n, GLint x, GLint y, GLfloat depth[] )
{
const GLfloat scale = 1.0F / ctx->Visual->DepthMaxF;
+ if (y < 0 || y >= ctx->DrawBuffer->Height ||
+ x + (GLint) n <= 0 || x >= ctx->DrawBuffer->Width) {
+ /* span is completely outside framebuffer */
+ GLint i;
+ for (i = 0; i < n; i++)
+ depth[i] = 0.0F;
+ return;
+ }
+
+ if (x < 0) {
+ GLint dx = -x;
+ GLint i;
+ for (i = 0; i < dx; i++)
+ depth[i] = 0.0F;
+ n -= dx;
+ x = 0;
+ }
+ if (x + n > ctx->DrawBuffer->Width) {
+ GLint dx = x + n - ctx->DrawBuffer->Width;
+ GLint i;
+ for (i = 0; i < dx; i++)
+ depth[n - i - 1] = 0.0F;
+ n -= dx;
+ }
+ if (n <= 0) {
+ return;
+ }
+
if (ctx->DrawBuffer->DepthBuffer) {
/* read from software depth buffer */
if (ctx->Visual->DepthBits <= 16) {
}
else {
/* no depth buffer */
- MEMSET(depth, 0, n * sizeof(GLfloat));
+ BZERO(depth, n * sizeof(GLfloat));
}
}
if (ctx->Visual->DepthBits <= 16) {
const GLushort clearValue = (GLushort) (ctx->Depth.Clear * ctx->Visual->DepthMax);
if ((clearValue & 0xff) == (clearValue >> 8)) {
- /* lower and upper bytes of clear_value are same, use MEMSET */
- MEMSET( ctx->DrawBuffer->DepthBuffer, clearValue & 0xff,
- 2 * ctx->DrawBuffer->Width * ctx->DrawBuffer->Height);
+ if (clearValue == 0) {
+ BZERO(ctx->DrawBuffer->DepthBuffer,
+ 2*ctx->DrawBuffer->Width*ctx->DrawBuffer->Height);
+ }
+ else {
+ /* lower and upper bytes of clear_value are same, use MEMSET */
+ MEMSET( ctx->DrawBuffer->DepthBuffer, clearValue & 0xff,
+ 2 * ctx->DrawBuffer->Width * ctx->DrawBuffer->Height);
+ }
}
else {
GLushort *d = (GLushort *) ctx->DrawBuffer->DepthBuffer;
}
else {
/* >16 bit depth buffer */
- GLuint *d = (GLuint *) ctx->DrawBuffer->DepthBuffer;
const GLuint clearValue = (GLuint) (ctx->Depth.Clear * ctx->Visual->DepthMax);
- GLint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
- while (n >= 16) {
- d[0] = clearValue; d[1] = clearValue;
- d[2] = clearValue; d[3] = clearValue;
- d[4] = clearValue; d[5] = clearValue;
- d[6] = clearValue; d[7] = clearValue;
- d[8] = clearValue; d[9] = clearValue;
- d[10] = clearValue; d[11] = clearValue;
- d[12] = clearValue; d[13] = clearValue;
- d[14] = clearValue; d[15] = clearValue;
- d += 16;
- n -= 16;
+ if (clearValue == 0) {
+ BZERO(ctx->DrawBuffer->DepthBuffer,
+ ctx->DrawBuffer->Width*ctx->DrawBuffer->Height*sizeof(GLuint));
}
- while (n > 0) {
- *d++ = clearValue;
- n--;
+ else {
+ GLint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
+ GLuint *d = (GLuint *) ctx->DrawBuffer->DepthBuffer;
+ while (n >= 16) {
+ d[0] = clearValue; d[1] = clearValue;
+ d[2] = clearValue; d[3] = clearValue;
+ d[4] = clearValue; d[5] = clearValue;
+ d[6] = clearValue; d[7] = clearValue;
+ d[8] = clearValue; d[9] = clearValue;
+ d[10] = clearValue; d[11] = clearValue;
+ d[12] = clearValue; d[13] = clearValue;
+ d[14] = clearValue; d[15] = clearValue;
+ d += 16;
+ n -= 16;
+ }
+ while (n > 0) {
+ *d++ = clearValue;
+ n--;
+ }
}
}
}