Context Navigation

source: trunk/src/opengl/mesa/depth.c

Visit:

Last change on this file was 3598, checked in by jeroen, 25 years ago
* empty log message *
File size: 44.8 KB

Rev	Line
[3598]	1	/* $Id: depth.c,v 1.3 2000-05-23 20:40:30 jeroen Exp $ */
[2938]	2
	3	/*
	4	* Mesa 3-D graphics library
[3598]	5	* Version: 3.3
[2938]	6	*
	7	* Copyright (C) 1999 Brian Paul All Rights Reserved.
	8	*
	9	* Permission is hereby granted, free of charge, to any person obtaining a
	10	* copy of this software and associated documentation files (the "Software"),
	11	* to deal in the Software without restriction, including without limitation
	12	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	13	* and/or sell copies of the Software, and to permit persons to whom the
	14	* Software is furnished to do so, subject to the following conditions:
	15	*
	16	* The above copyright notice and this permission notice shall be included
	17	* in all copies or substantial portions of the Software.
	18	*
	19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	20	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	22	* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
	23	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	24	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	25	*/
	26
	27
	28	/* $XFree86: xc/lib/GL/mesa/src/depth.c,v 1.3 1999/04/04 00:20:22 dawes Exp $ */
	29
	30	/*
	31	* Depth buffer functions
	32	*/
	33
	34	#include <stdlib.h>
	35
	36	#ifdef PC_HEADER
	37	#include "all.h"
	38	#else
[3598]	39	#include "glheader.h"
[2962]	40	#include "types.h"
[2938]	41	#include "context.h"
	42	#include "enums.h"
	43	#include "depth.h"
[3598]	44	#include "mem.h"
	45	#include "pb.h"
[2938]	46	#include "macros.h"
	47	#endif
	48
	49
	50
	51	/**********************************************************************/
	52	/*** API Functions ***/
	53	/**********************************************************************/
	54
	55
	56
[3598]	57	void
	58	_mesa_ClearDepth( GLclampd depth )
[2938]	59	{
[3598]	60	GET_CURRENT_CONTEXT(ctx);
[2938]	61	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glClearDepth");
	62	ctx->Depth.Clear = (GLfloat) CLAMP( depth, 0.0, 1.0 );
	63	if (ctx->Driver.ClearDepth)
	64	(*ctx->Driver.ClearDepth)( ctx, ctx->Depth.Clear );
	65	}
	66
	67
	68
[3598]	69	void
	70	_mesa_DepthFunc( GLenum func )
[2938]	71	{
[3598]	72	GET_CURRENT_CONTEXT(ctx);
[2938]	73	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDepthFunc");
	74
	75	if (MESA_VERBOSE & (VERBOSE_API\|VERBOSE_TEXTURE))
	76	fprintf(stderr, "glDepthFunc %s\n", gl_lookup_enum_by_nr(func));
	77
	78	switch (func) {
	79	case GL_LESS: /* (default) pass if incoming z < stored z */
	80	case GL_GEQUAL:
	81	case GL_LEQUAL:
	82	case GL_GREATER:
	83	case GL_NOTEQUAL:
	84	case GL_EQUAL:
	85	case GL_ALWAYS:
[3598]	86	if (ctx->Depth.Func != func) {
	87	ctx->Depth.Func = func;
	88	ctx->NewState \|= NEW_RASTER_OPS;
	89	ctx->TriangleCaps &= ~DD_Z_NEVER;
	90	if (ctx->Driver.DepthFunc) {
	91	(*ctx->Driver.DepthFunc)( ctx, func );
	92	}
	93	}
[2938]	94	break;
	95	case GL_NEVER:
[3598]	96	if (ctx->Depth.Func != func) {
	97	ctx->Depth.Func = func;
	98	ctx->NewState \|= NEW_RASTER_OPS;
	99	ctx->TriangleCaps \|= DD_Z_NEVER;
	100	if (ctx->Driver.DepthFunc) {
	101	(*ctx->Driver.DepthFunc)( ctx, func );
	102	}
	103	}
[2938]	104	break;
	105	default:
	106	gl_error( ctx, GL_INVALID_ENUM, "glDepth.Func" );
	107	}
	108	}
	109
	110
	111
[3598]	112	void
	113	_mesa_DepthMask( GLboolean flag )
[2938]	114	{
[3598]	115	GET_CURRENT_CONTEXT(ctx);
[2938]	116	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glDepthMask");
	117
	118	if (MESA_VERBOSE & (VERBOSE_API\|VERBOSE_TEXTURE))
	119	fprintf(stderr, "glDepthMask %d\n", flag);
	120
	121	/*
	122	* GL_TRUE indicates depth buffer writing is enabled (default)
	123	* GL_FALSE indicates depth buffer writing is disabled
	124	*/
	125	if (ctx->Depth.Mask != flag) {
	126	ctx->Depth.Mask = flag;
	127	ctx->NewState \|= NEW_RASTER_OPS;
	128	if (ctx->Driver.DepthMask) {
[3598]	129	(*ctx->Driver.DepthMask)( ctx, flag );
[2938]	130	}
	131	}
	132	}
	133
	134
	135
	136	/**********************************************************************/
[3598]	137	/*** Misc ***/
[2938]	138	/**********************************************************************/
	139
	140	/*
[3598]	141	* Return address of depth buffer value for given window coord.
[2938]	142	*/
[3598]	143	GLvoid *
	144	_mesa_zbuffer_address(GLcontext *ctx, GLint x, GLint y)
	145	{
	146	if (ctx->Visual->DepthBits <= 16)
	147	return (GLushort ) ctx->DrawBuffer->DepthBuffer + ctx->DrawBuffer->Width y + x;
	148	else
	149	return (GLuint ) ctx->DrawBuffer->DepthBuffer + ctx->DrawBuffer->Width y + x;
	150	}
[2938]	151
	152
[3598]	153	#define Z_ADDRESS16( CTX, X, Y ) \
	154	( ((GLushort *) (CTX)->DrawBuffer->DepthBuffer) \
	155	+ (CTX)->DrawBuffer->Width * (Y) + (X) )
	156
	157	#define Z_ADDRESS32( CTX, X, Y ) \
	158	( ((GLuint *) (CTX)->DrawBuffer->DepthBuffer) \
	159	+ (CTX)->DrawBuffer->Width * (Y) + (X) )
	160
	161
	162
	163	/**********************************************************************/
	164	/*** Depth Testing Functions ***/
	165	/**********************************************************************/
	166
	167
[2938]	168	/*
[3598]	169	* Do depth test for an array of fragments. This is used both for
	170	* software and hardware Z buffers.
	171	* Input: zbuffer - array of z values in the zbuffer
	172	* z - array of fragment z values
	173	* Return: number of fragments which pass the test.
[2938]	174	*/
[3598]	175	static GLuint
	176	depth_test_span16( GLcontext *ctx, GLuint n, GLint x, GLint y,
	177	GLushort zbuffer[], const GLdepth z[], GLubyte mask[] )
[2938]	178	{
	179	GLuint passed = 0;
	180
	181	/* switch cases ordered from most frequent to less frequent */
	182	switch (ctx->Depth.Func) {
	183	case GL_LESS:
	184	if (ctx->Depth.Mask) {
[3598]	185	/* Update Z buffer */
	186	GLuint i;
	187	for (i=0; i<n; i++) {
	188	if (mask[i]) {
	189	if (z[i] < zbuffer[i]) {
	190	/* pass */
	191	zbuffer[i] = z[i];
	192	passed++;
	193	}
	194	else {
	195	/* fail */
	196	mask[i] = 0;
	197	}
	198	}
	199	}
	200	}
	201	else {
	202	/* Don't update Z buffer */
	203	GLuint i;
	204	for (i=0; i<n; i++) {
	205	if (mask[i]) {
	206	if (z[i] < zbuffer[i]) {
	207	/* pass */
	208	passed++;
	209	}
	210	else {
	211	mask[i] = 0;
	212	}
	213	}
	214	}
	215	}
	216	break;
[2938]	217	case GL_LEQUAL:
[3598]	218	if (ctx->Depth.Mask) {
	219	/* Update Z buffer */
	220	GLuint i;
	221	for (i=0;i<n;i++) {
	222	if (mask[i]) {
	223	if (z[i] <= zbuffer[i]) {
	224	zbuffer[i] = z[i];
	225	passed++;
	226	}
	227	else {
	228	mask[i] = 0;
	229	}
	230	}
	231	}
	232	}
	233	else {
	234	/* Don't update Z buffer */
	235	GLuint i;
	236	for (i=0;i<n;i++) {
	237	if (mask[i]) {
	238	if (z[i] <= zbuffer[i]) {
	239	/* pass */
	240	passed++;
	241	}
	242	else {
	243	mask[i] = 0;
	244	}
	245	}
	246	}
	247	}
	248	break;
[2938]	249	case GL_GEQUAL:
[3598]	250	if (ctx->Depth.Mask) {
	251	/* Update Z buffer */
	252	GLuint i;
	253	for (i=0;i<n;i++) {
	254	if (mask[i]) {
	255	if (z[i] >= zbuffer[i]) {
	256	zbuffer[i] = z[i];
	257	passed++;
	258	}
	259	else {
	260	mask[i] = 0;
	261	}
	262	}
	263	}
	264	}
	265	else {
	266	/* Don't update Z buffer */
	267	GLuint i;
	268	for (i=0;i<n;i++) {
	269	if (mask[i]) {
	270	if (z[i] >= zbuffer[i]) {
	271	/* pass */
	272	passed++;
	273	}
	274	else {
	275	mask[i] = 0;
	276	}
	277	}
	278	}
	279	}
	280	break;
[2938]	281	case GL_GREATER:
[3598]	282	if (ctx->Depth.Mask) {
	283	/* Update Z buffer */
	284	GLuint i;
	285	for (i=0;i<n;i++) {
	286	if (mask[i]) {
	287	if (z[i] > zbuffer[i]) {
	288	zbuffer[i] = z[i];
	289	passed++;
	290	}
	291	else {
	292	mask[i] = 0;
	293	}
	294	}
	295	}
	296	}
	297	else {
	298	/* Don't update Z buffer */
	299	GLuint i;
	300	for (i=0;i<n;i++) {
	301	if (mask[i]) {
	302	if (z[i] > zbuffer[i]) {
	303	/* pass */
	304	passed++;
	305	}
	306	else {
	307	mask[i] = 0;
	308	}
	309	}
	310	}
	311	}
	312	break;
[2938]	313	case GL_NOTEQUAL:
[3598]	314	if (ctx->Depth.Mask) {
	315	/* Update Z buffer */
	316	GLuint i;
	317	for (i=0;i<n;i++) {
	318	if (mask[i]) {
	319	if (z[i] != zbuffer[i]) {
	320	zbuffer[i] = z[i];
	321	passed++;
	322	}
	323	else {
	324	mask[i] = 0;
	325	}
	326	}
	327	}
	328	}
	329	else {
	330	/* Don't update Z buffer */
	331	GLuint i;
	332	for (i=0;i<n;i++) {
	333	if (mask[i]) {
	334	if (z[i] != zbuffer[i]) {
	335	/* pass */
	336	passed++;
	337	}
	338	else {
	339	mask[i] = 0;
	340	}
	341	}
	342	}
	343	}
	344	break;
[2938]	345	case GL_EQUAL:
[3598]	346	if (ctx->Depth.Mask) {
	347	/* Update Z buffer */
	348	GLuint i;
	349	for (i=0;i<n;i++) {
	350	if (mask[i]) {
	351	if (z[i] == zbuffer[i]) {
	352	zbuffer[i] = z[i];
	353	passed++;
	354	}
	355	else {
	356	mask[i] = 0;
	357	}
	358	}
	359	}
	360	}
	361	else {
	362	/* Don't update Z buffer */
	363	GLuint i;
	364	for (i=0;i<n;i++) {
	365	if (mask[i]) {
	366	if (z[i] == zbuffer[i]) {
	367	/* pass */
	368	passed++;
	369	}
	370	else {
	371	mask[i] = 0;
	372	}
	373	}
	374	}
	375	}
	376	break;
[2938]	377	case GL_ALWAYS:
[3598]	378	if (ctx->Depth.Mask) {
	379	/* Update Z buffer */
	380	GLuint i;
	381	for (i=0;i<n;i++) {
	382	if (mask[i]) {
	383	zbuffer[i] = z[i];
	384	passed++;
	385	}
	386	}
	387	}
	388	else {
	389	/* Don't update Z buffer or mask */
	390	passed = n;
	391	}
	392	break;
[2938]	393	case GL_NEVER:
[3598]	394	MEMSET(mask, 0, n * sizeof(GLubyte));
	395	break;
[2938]	396	default:
[3598]	397	gl_problem(ctx, "Bad depth func in depth_test_span16");
	398	}
[2938]	399
	400	return passed;
	401	}
	402
	403
[3598]	404	static GLuint
	405	depth_test_span32( GLcontext *ctx, GLuint n, GLint x, GLint y,
	406	GLuint zbuffer[], const GLdepth z[], GLubyte mask[] )
[2938]	407	{
	408	GLuint passed = 0;
	409
[3598]	410	/* switch cases ordered from most frequent to less frequent */
	411	switch (ctx->Depth.Func) {
	412	case GL_LESS:
	413	if (ctx->Depth.Mask) {
	414	/* Update Z buffer */
	415	GLuint i;
	416	for (i=0; i<n; i++) {
	417	if (mask[i]) {
	418	if (z[i] < zbuffer[i]) {
	419	/* pass */
	420	zbuffer[i] = z[i];
	421	passed++;
	422	}
	423	else {
	424	/* fail */
	425	mask[i] = 0;
	426	}
	427	}
	428	}
[2938]	429	}
	430	else {
[3598]	431	/* Don't update Z buffer */
	432	GLuint i;
	433	for (i=0; i<n; i++) {
	434	if (mask[i]) {
	435	if (z[i] < zbuffer[i]) {
	436	/* pass */
	437	passed++;
	438	}
	439	else {
	440	mask[i] = 0;
	441	}
	442	}
	443	}
[2938]	444	}
[3598]	445	break;
	446	case GL_LEQUAL:
	447	if (ctx->Depth.Mask) {
	448	/* Update Z buffer */
	449	GLuint i;
	450	for (i=0;i<n;i++) {
	451	if (mask[i]) {
	452	if (z[i] <= zbuffer[i]) {
	453	zbuffer[i] = z[i];
	454	passed++;
	455	}
	456	else {
	457	mask[i] = 0;
	458	}
	459	}
	460	}
	461	}
	462	else {
	463	/* Don't update Z buffer */
	464	GLuint i;
	465	for (i=0;i<n;i++) {
	466	if (mask[i]) {
	467	if (z[i] <= zbuffer[i]) {
	468	/* pass */
	469	passed++;
	470	}
	471	else {
	472	mask[i] = 0;
	473	}
	474	}
	475	}
	476	}
	477	break;
	478	case GL_GEQUAL:
	479	if (ctx->Depth.Mask) {
	480	/* Update Z buffer */
	481	GLuint i;
	482	for (i=0;i<n;i++) {
	483	if (mask[i]) {
	484	if (z[i] >= zbuffer[i]) {
	485	zbuffer[i] = z[i];
	486	passed++;
	487	}
	488	else {
	489	mask[i] = 0;
	490	}
	491	}
	492	}
	493	}
	494	else {
	495	/* Don't update Z buffer */
	496	GLuint i;
	497	for (i=0;i<n;i++) {
	498	if (mask[i]) {
	499	if (z[i] >= zbuffer[i]) {
	500	/* pass */
	501	passed++;
	502	}
	503	else {
	504	mask[i] = 0;
	505	}
	506	}
	507	}
	508	}
	509	break;
	510	case GL_GREATER:
	511	if (ctx->Depth.Mask) {
	512	/* Update Z buffer */
	513	GLuint i;
	514	for (i=0;i<n;i++) {
	515	if (mask[i]) {
	516	if (z[i] > zbuffer[i]) {
	517	zbuffer[i] = z[i];
	518	passed++;
	519	}
	520	else {
	521	mask[i] = 0;
	522	}
	523	}
	524	}
	525	}
	526	else {
	527	/* Don't update Z buffer */
	528	GLuint i;
	529	for (i=0;i<n;i++) {
	530	if (mask[i]) {
	531	if (z[i] > zbuffer[i]) {
	532	/* pass */
	533	passed++;
	534	}
	535	else {
	536	mask[i] = 0;
	537	}
	538	}
	539	}
	540	}
	541	break;
	542	case GL_NOTEQUAL:
	543	if (ctx->Depth.Mask) {
	544	/* Update Z buffer */
	545	GLuint i;
	546	for (i=0;i<n;i++) {
	547	if (mask[i]) {
	548	if (z[i] != zbuffer[i]) {
	549	zbuffer[i] = z[i];
	550	passed++;
	551	}
	552	else {
	553	mask[i] = 0;
	554	}
	555	}
	556	}
	557	}
	558	else {
	559	/* Don't update Z buffer */
	560	GLuint i;
	561	for (i=0;i<n;i++) {
	562	if (mask[i]) {
	563	if (z[i] != zbuffer[i]) {
	564	/* pass */
	565	passed++;
	566	}
	567	else {
	568	mask[i] = 0;
	569	}
	570	}
	571	}
	572	}
	573	break;
	574	case GL_EQUAL:
	575	if (ctx->Depth.Mask) {
	576	/* Update Z buffer */
	577	GLuint i;
	578	for (i=0;i<n;i++) {
	579	if (mask[i]) {
	580	if (z[i] == zbuffer[i]) {
	581	zbuffer[i] = z[i];
	582	passed++;
	583	}
	584	else {
	585	mask[i] = 0;
	586	}
	587	}
	588	}
	589	}
	590	else {
	591	/* Don't update Z buffer */
	592	GLuint i;
	593	for (i=0;i<n;i++) {
	594	if (mask[i]) {
	595	if (z[i] == zbuffer[i]) {
	596	/* pass */
	597	passed++;
	598	}
	599	else {
	600	mask[i] = 0;
	601	}
	602	}
	603	}
	604	}
	605	break;
	606	case GL_ALWAYS:
	607	if (ctx->Depth.Mask) {
	608	/* Update Z buffer */
	609	GLuint i;
	610	for (i=0;i<n;i++) {
	611	if (mask[i]) {
	612	zbuffer[i] = z[i];
	613	passed++;
	614	}
	615	}
	616	}
	617	else {
	618	/* Don't update Z buffer or mask */
	619	passed = n;
	620	}
	621	break;
	622	case GL_NEVER:
	623	MEMSET(mask, 0, n * sizeof(GLubyte));
	624	break;
	625	default:
	626	gl_problem(ctx, "Bad depth func in depth_test_span32");
[2938]	627	}
[3598]	628
[2938]	629	return passed;
	630	}
	631
	632
[3598]	633
[2938]	634	/*
[3598]	635	* Apply depth test to span of fragments. Hardware or software z buffer.
[2938]	636	*/
[3598]	637	GLuint
	638	_mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
	639	const GLdepth z[], GLubyte mask[] )
[2938]	640	{
[3598]	641	if (ctx->Driver.ReadDepthSpan) {
	642	/* hardware-based depth buffer */
	643	GLdepth zbuffer[MAX_WIDTH];
	644	GLuint passed;
	645	(*ctx->Driver.ReadDepthSpan)(ctx, n, x, y, zbuffer);
	646	passed = depth_test_span32(ctx, n, x, y, zbuffer, z, mask);
	647	ASSERT(ctx->Driver.WriteDepthSpan);
	648	(*ctx->Driver.WriteDepthSpan)(ctx, n, x, y, zbuffer, mask);
	649	return passed;
	650	}
	651	else {
	652	/* software depth buffer */
	653	if (ctx->Visual->DepthBits <= 16) {
	654	GLushort zptr = (GLushort ) Z_ADDRESS16(ctx, x, y);
	655	GLuint passed = depth_test_span16(ctx, n, x, y, zptr, z, mask);
	656	return passed;
[2938]	657	}
[3598]	658	else {
	659	GLuint zptr = (GLuint ) Z_ADDRESS32(ctx, x, y);
	660	GLuint passed = depth_test_span32(ctx, n, x, y, zptr, z, mask);
	661	return passed;
	662	}
[2938]	663	}
	664	}
	665
	666
	667
	668
	669	/*
[3598]	670	* Do depth testing for an array of fragments using software Z buffer.
[2938]	671	*/
[3598]	672	static void
	673	software_depth_test_pixels16( GLcontext *ctx, GLuint n,
	674	const GLint x[], const GLint y[],
	675	const GLdepth z[], GLubyte mask[] )
[2938]	676	{
	677	/* switch cases ordered from most frequent to less frequent */
	678	switch (ctx->Depth.Func) {
	679	case GL_LESS:
	680	if (ctx->Depth.Mask) {
[3598]	681	/* Update Z buffer */
	682	GLuint i;
	683	for (i=0; i<n; i++) {
	684	if (mask[i]) {
	685	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	686	if (z[i] < *zptr) {
	687	/* pass */
	688	*zptr = z[i];
	689	}
	690	else {
	691	/* fail */
	692	mask[i] = 0;
	693	}
	694	}
	695	}
	696	}
	697	else {
	698	/* Don't update Z buffer */
	699	GLuint i;
	700	for (i=0; i<n; i++) {
	701	if (mask[i]) {
	702	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	703	if (z[i] < *zptr) {
	704	/* pass */
	705	}
	706	else {
	707	/* fail */
	708	mask[i] = 0;
	709	}
	710	}
	711	}
	712	}
	713	break;
[2938]	714	case GL_LEQUAL:
	715	if (ctx->Depth.Mask) {
[3598]	716	/* Update Z buffer */
	717	GLuint i;
	718	for (i=0; i<n; i++) {
	719	if (mask[i]) {
	720	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	721	if (z[i] <= *zptr) {
	722	/* pass */
	723	*zptr = z[i];
	724	}
	725	else {
	726	/* fail */
	727	mask[i] = 0;
	728	}
	729	}
	730	}
	731	}
	732	else {
	733	/* Don't update Z buffer */
	734	GLuint i;
	735	for (i=0; i<n; i++) {
	736	if (mask[i]) {
	737	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	738	if (z[i] <= *zptr) {
	739	/* pass */
	740	}
	741	else {
	742	/* fail */
	743	mask[i] = 0;
	744	}
	745	}
	746	}
	747	}
	748	break;
[2938]	749	case GL_GEQUAL:
	750	if (ctx->Depth.Mask) {
[3598]	751	/* Update Z buffer */
	752	GLuint i;
	753	for (i=0; i<n; i++) {
	754	if (mask[i]) {
	755	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	756	if (z[i] >= *zptr) {
	757	/* pass */
	758	*zptr = z[i];
	759	}
	760	else {
	761	/* fail */
	762	mask[i] = 0;
	763	}
	764	}
	765	}
	766	}
	767	else {
	768	/* Don't update Z buffer */
	769	GLuint i;
	770	for (i=0; i<n; i++) {
	771	if (mask[i]) {
	772	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	773	if (z[i] >= *zptr) {
	774	/* pass */
	775	}
	776	else {
	777	/* fail */
	778	mask[i] = 0;
	779	}
	780	}
	781	}
	782	}
	783	break;
[2938]	784	case GL_GREATER:
	785	if (ctx->Depth.Mask) {
[3598]	786	/* Update Z buffer */
	787	GLuint i;
	788	for (i=0; i<n; i++) {
	789	if (mask[i]) {
	790	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	791	if (z[i] > *zptr) {
	792	/* pass */
	793	*zptr = z[i];
	794	}
	795	else {
	796	/* fail */
	797	mask[i] = 0;
	798	}
	799	}
	800	}
	801	}
	802	else {
	803	/* Don't update Z buffer */
	804	GLuint i;
	805	for (i=0; i<n; i++) {
	806	if (mask[i]) {
	807	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	808	if (z[i] > *zptr) {
	809	/* pass */
	810	}
	811	else {
	812	/* fail */
	813	mask[i] = 0;
	814	}
	815	}
	816	}
	817	}
	818	break;
[2938]	819	case GL_NOTEQUAL:
	820	if (ctx->Depth.Mask) {
[3598]	821	/* Update Z buffer */
	822	GLuint i;
	823	for (i=0; i<n; i++) {
	824	if (mask[i]) {
	825	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	826	if (z[i] != *zptr) {
	827	/* pass */
	828	*zptr = z[i];
	829	}
	830	else {
	831	/* fail */
	832	mask[i] = 0;
	833	}
	834	}
	835	}
	836	}
	837	else {
	838	/* Don't update Z buffer */
	839	GLuint i;
	840	for (i=0; i<n; i++) {
	841	if (mask[i]) {
	842	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	843	if (z[i] != *zptr) {
	844	/* pass */
	845	}
	846	else {
	847	/* fail */
	848	mask[i] = 0;
	849	}
	850	}
	851	}
	852	}
	853	break;
[2938]	854	case GL_EQUAL:
	855	if (ctx->Depth.Mask) {
[3598]	856	/* Update Z buffer */
	857	GLuint i;
	858	for (i=0; i<n; i++) {
	859	if (mask[i]) {
	860	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	861	if (z[i] == *zptr) {
	862	/* pass */
	863	*zptr = z[i];
	864	}
	865	else {
	866	/* fail */
	867	mask[i] = 0;
	868	}
	869	}
	870	}
	871	}
	872	else {
	873	/* Don't update Z buffer */
	874	GLuint i;
	875	for (i=0; i<n; i++) {
	876	if (mask[i]) {
	877	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	878	if (z[i] == *zptr) {
	879	/* pass */
	880	}
	881	else {
	882	/* fail */
	883	mask[i] = 0;
	884	}
	885	}
	886	}
	887	}
	888	break;
[2938]	889	case GL_ALWAYS:
[3598]	890	if (ctx->Depth.Mask) {
	891	/* Update Z buffer */
	892	GLuint i;
	893	for (i=0; i<n; i++) {
	894	if (mask[i]) {
	895	GLushort *zptr = Z_ADDRESS16(ctx,x[i],y[i]);
	896	*zptr = z[i];
	897	}
	898	}
	899	}
	900	else {
	901	/* Don't update Z buffer or mask */
	902	}
	903	break;
[2938]	904	case GL_NEVER:
[3598]	905	/* depth test never passes */
	906	MEMSET(mask, 0, n * sizeof(GLubyte));
	907	break;
[2938]	908	default:
[3598]	909	gl_problem(ctx, "Bad depth func in software_depth_test_pixels");
	910	}
[2938]	911	}
	912
	913
	914
	915	/*
[3598]	916	* Do depth testing for an array of fragments using software Z buffer.
[2938]	917	*/
[3598]	918	static void
	919	software_depth_test_pixels32( GLcontext *ctx, GLuint n,
	920	const GLint x[], const GLint y[],
	921	const GLdepth z[], GLubyte mask[] )
[2938]	922	{
[3598]	923	/* switch cases ordered from most frequent to less frequent */
	924	switch (ctx->Depth.Func) {
	925	case GL_LESS:
	926	if (ctx->Depth.Mask) {
	927	/* Update Z buffer */
	928	GLuint i;
	929	for (i=0; i<n; i++) {
	930	if (mask[i]) {
	931	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	932	if (z[i] < *zptr) {
	933	/* pass */
	934	*zptr = z[i];
	935	}
	936	else {
	937	/* fail */
	938	mask[i] = 0;
	939	}
	940	}
	941	}
[2938]	942	}
	943	else {
[3598]	944	/* Don't update Z buffer */
	945	GLuint i;
	946	for (i=0; i<n; i++) {
	947	if (mask[i]) {
	948	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	949	if (z[i] < *zptr) {
	950	/* pass */
	951	}
	952	else {
	953	/* fail */
	954	mask[i] = 0;
	955	}
	956	}
	957	}
[2938]	958	}
[3598]	959	break;
	960	case GL_LEQUAL:
	961	if (ctx->Depth.Mask) {
	962	/* Update Z buffer */
	963	GLuint i;
	964	for (i=0; i<n; i++) {
	965	if (mask[i]) {
	966	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	967	if (z[i] <= *zptr) {
	968	/* pass */
	969	*zptr = z[i];
	970	}
	971	else {
	972	/* fail */
	973	mask[i] = 0;
	974	}
	975	}
	976	}
	977	}
	978	else {
	979	/* Don't update Z buffer */
	980	GLuint i;
	981	for (i=0; i<n; i++) {
	982	if (mask[i]) {
	983	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	984	if (z[i] <= *zptr) {
	985	/* pass */
	986	}
	987	else {
	988	/* fail */
	989	mask[i] = 0;
	990	}
	991	}
	992	}
	993	}
	994	break;
	995	case GL_GEQUAL:
	996	if (ctx->Depth.Mask) {
	997	/* Update Z buffer */
	998	GLuint i;
	999	for (i=0; i<n; i++) {
	1000	if (mask[i]) {
	1001	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	1002	if (z[i] >= *zptr) {
	1003	/* pass */
	1004	*zptr = z[i];
	1005	}
	1006	else {
	1007	/* fail */
	1008	mask[i] = 0;
	1009	}
	1010	}
	1011	}
	1012	}
	1013	else {
	1014	/* Don't update Z buffer */
	1015	GLuint i;
	1016	for (i=0; i<n; i++) {
	1017	if (mask[i]) {
	1018	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	1019	if (z[i] >= *zptr) {
	1020	/* pass */
	1021	}
	1022	else {
	1023	/* fail */
	1024	mask[i] = 0;
	1025	}
	1026	}
	1027	}
	1028	}
	1029	break;
	1030	case GL_GREATER:
	1031	if (ctx->Depth.Mask) {
	1032	/* Update Z buffer */
	1033	GLuint i;
	1034	for (i=0; i<n; i++) {
	1035	if (mask[i]) {
	1036	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	1037	if (z[i] > *zptr) {
	1038	/* pass */
	1039	*zptr = z[i];
	1040	}
	1041	else {
	1042	/* fail */
	1043	mask[i] = 0;
	1044	}
	1045	}
	1046	}
	1047	}
	1048	else {
	1049	/* Don't update Z buffer */
	1050	GLuint i;
	1051	for (i=0; i<n; i++) {
	1052	if (mask[i]) {
	1053	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	1054	if (z[i] > *zptr) {
	1055	/* pass */
	1056	}
	1057	else {
	1058	/* fail */
	1059	mask[i] = 0;
	1060	}
	1061	}
	1062	}
	1063	}
	1064	break;
	1065	case GL_NOTEQUAL:
	1066	if (ctx->Depth.Mask) {
	1067	/* Update Z buffer */
	1068	GLuint i;
	1069	for (i=0; i<n; i++) {
	1070	if (mask[i]) {
	1071	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	1072	if (z[i] != *zptr) {
	1073	/* pass */
	1074	*zptr = z[i];
	1075	}
	1076	else {
	1077	/* fail */
	1078	mask[i] = 0;
	1079	}
	1080	}
	1081	}
	1082	}
	1083	else {
	1084	/* Don't update Z buffer */
	1085	GLuint i;
	1086	for (i=0; i<n; i++) {
	1087	if (mask[i]) {
	1088	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	1089	if (z[i] != *zptr) {
	1090	/* pass */
	1091	}
	1092	else {
	1093	/* fail */
	1094	mask[i] = 0;
	1095	}
	1096	}
	1097	}
	1098	}
	1099	break;
	1100	case GL_EQUAL:
	1101	if (ctx->Depth.Mask) {
	1102	/* Update Z buffer */
	1103	GLuint i;
	1104	for (i=0; i<n; i++) {
	1105	if (mask[i]) {
	1106	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	1107	if (z[i] == *zptr) {
	1108	/* pass */
	1109	*zptr = z[i];
	1110	}
	1111	else {
	1112	/* fail */
	1113	mask[i] = 0;
	1114	}
	1115	}
	1116	}
	1117	}
	1118	else {
	1119	/* Don't update Z buffer */
	1120	GLuint i;
	1121	for (i=0; i<n; i++) {
	1122	if (mask[i]) {
	1123	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	1124	if (z[i] == *zptr) {
	1125	/* pass */
	1126	}
	1127	else {
	1128	/* fail */
	1129	mask[i] = 0;
	1130	}
	1131	}
	1132	}
	1133	}
	1134	break;
	1135	case GL_ALWAYS:
	1136	if (ctx->Depth.Mask) {
	1137	/* Update Z buffer */
	1138	GLuint i;
	1139	for (i=0; i<n; i++) {
	1140	if (mask[i]) {
	1141	GLuint *zptr = Z_ADDRESS32(ctx,x[i],y[i]);
	1142	*zptr = z[i];
	1143	}
	1144	}
	1145	}
	1146	else {
	1147	/* Don't update Z buffer or mask */
	1148	}
	1149	break;
	1150	case GL_NEVER:
	1151	/* depth test never passes */
	1152	MEMSET(mask, 0, n * sizeof(GLubyte));
	1153	break;
	1154	default:
	1155	gl_problem(ctx, "Bad depth func in software_depth_test_pixels");
[2938]	1156	}
	1157	}
	1158
	1159
[3598]	1160
[2938]	1161	/*
[3598]	1162	* Do depth testing for an array of pixels using hardware Z buffer.
	1163	* Input/output: zbuffer - array of depth values from Z buffer
	1164	* Input: z - array of fragment z values.
[2938]	1165	*/
[3598]	1166	static void
	1167	hardware_depth_test_pixels( GLcontext *ctx, GLuint n, GLdepth zbuffer[],
	1168	const GLdepth z[], GLubyte mask[] )
[2938]	1169	{
[3598]	1170	/* switch cases ordered from most frequent to less frequent */
	1171	switch (ctx->Depth.Func) {
	1172	case GL_LESS:
	1173	if (ctx->Depth.Mask) {
	1174	/* Update Z buffer */
	1175	GLuint i;
	1176	for (i=0; i<n; i++) {
	1177	if (mask[i]) {
	1178	if (z[i] < zbuffer[i]) {
	1179	/* pass */
	1180	zbuffer[i] = z[i];
	1181	}
	1182	else {
	1183	/* fail */
	1184	mask[i] = 0;
	1185	}
	1186	}
	1187	}
[2938]	1188	}
	1189	else {
[3598]	1190	/* Don't update Z buffer */
	1191	GLuint i;
	1192	for (i=0; i<n; i++) {
	1193	if (mask[i]) {
	1194	if (z[i] < zbuffer[i]) {
	1195	/* pass */
	1196	}
	1197	else {
	1198	/* fail */
	1199	mask[i] = 0;
	1200	}
	1201	}
	1202	}
[2938]	1203	}
[3598]	1204	break;
	1205	case GL_LEQUAL:
	1206	if (ctx->Depth.Mask) {
	1207	/* Update Z buffer */
	1208	GLuint i;
	1209	for (i=0; i<n; i++) {
	1210	if (mask[i]) {
	1211	if (z[i] <= zbuffer[i]) {
	1212	/* pass */
	1213	zbuffer[i] = z[i];
	1214	}
	1215	else {
	1216	/* fail */
	1217	mask[i] = 0;
	1218	}
	1219	}
	1220	}
	1221	}
	1222	else {
	1223	/* Don't update Z buffer */
	1224	GLuint i;
	1225	for (i=0; i<n; i++) {
	1226	if (mask[i]) {
	1227	if (z[i] <= zbuffer[i]) {
	1228	/* pass */
	1229	}
	1230	else {
	1231	/* fail */
	1232	mask[i] = 0;
	1233	}
	1234	}
	1235	}
	1236	}
	1237	break;
	1238	case GL_GEQUAL:
	1239	if (ctx->Depth.Mask) {
	1240	/* Update Z buffer */
	1241	GLuint i;
	1242	for (i=0; i<n; i++) {
	1243	if (mask[i]) {
	1244	if (z[i] >= zbuffer[i]) {
	1245	/* pass */
	1246	zbuffer[i] = z[i];
	1247	}
	1248	else {
	1249	/* fail */
	1250	mask[i] = 0;
	1251	}
	1252	}
	1253	}
	1254	}
	1255	else {
	1256	/* Don't update Z buffer */
	1257	GLuint i;
	1258	for (i=0; i<n; i++) {
	1259	if (mask[i]) {
	1260	if (z[i] >= zbuffer[i]) {
	1261	/* pass */
	1262	}
	1263	else {
	1264	/* fail */
	1265	mask[i] = 0;
	1266	}
	1267	}
	1268	}
	1269	}
	1270	break;
	1271	case GL_GREATER:
	1272	if (ctx->Depth.Mask) {
	1273	/* Update Z buffer */
	1274	GLuint i;
	1275	for (i=0; i<n; i++) {
	1276	if (mask[i]) {
	1277	if (z[i] > zbuffer[i]) {
	1278	/* pass */
	1279	zbuffer[i] = z[i];
	1280	}
	1281	else {
	1282	/* fail */
	1283	mask[i] = 0;
	1284	}
	1285	}
	1286	}
	1287	}
	1288	else {
	1289	/* Don't update Z buffer */
	1290	GLuint i;
	1291	for (i=0; i<n; i++) {
	1292	if (mask[i]) {
	1293	if (z[i] > zbuffer[i]) {
	1294	/* pass */
	1295	}
	1296	else {
	1297	/* fail */
	1298	mask[i] = 0;
	1299	}
	1300	}
	1301	}
	1302	}
	1303	break;
	1304	case GL_NOTEQUAL:
	1305	if (ctx->Depth.Mask) {
	1306	/* Update Z buffer */
	1307	GLuint i;
	1308	for (i=0; i<n; i++) {
	1309	if (mask[i]) {
	1310	if (z[i] != zbuffer[i]) {
	1311	/* pass */
	1312	zbuffer[i] = z[i];
	1313	}
	1314	else {
	1315	/* fail */
	1316	mask[i] = 0;
	1317	}
	1318	}
	1319	}
	1320	}
	1321	else {
	1322	/* Don't update Z buffer */
	1323	GLuint i;
	1324	for (i=0; i<n; i++) {
	1325	if (mask[i]) {
	1326	if (z[i] != zbuffer[i]) {
	1327	/* pass */
	1328	}
	1329	else {
	1330	/* fail */
	1331	mask[i] = 0;
	1332	}
	1333	}
	1334	}
	1335	}
	1336	break;
	1337	case GL_EQUAL:
	1338	if (ctx->Depth.Mask) {
	1339	/* Update Z buffer */
	1340	GLuint i;
	1341	for (i=0; i<n; i++) {
	1342	if (mask[i]) {
	1343	if (z[i] == zbuffer[i]) {
	1344	/* pass */
	1345	zbuffer[i] = z[i];
	1346	}
	1347	else {
	1348	/* fail */
	1349	mask[i] = 0;
	1350	}
	1351	}
	1352	}
	1353	}
	1354	else {
	1355	/* Don't update Z buffer */
	1356	GLuint i;
	1357	for (i=0; i<n; i++) {
	1358	if (mask[i]) {
	1359	if (z[i] == zbuffer[i]) {
	1360	/* pass */
	1361	}
	1362	else {
	1363	/* fail */
	1364	mask[i] = 0;
	1365	}
	1366	}
	1367	}
	1368	}
	1369	break;
	1370	case GL_ALWAYS:
	1371	if (ctx->Depth.Mask) {
	1372	/* Update Z buffer */
	1373	GLuint i;
	1374	for (i=0; i<n; i++) {
	1375	if (mask[i]) {
	1376	zbuffer[i] = z[i];
	1377	}
	1378	}
	1379	}
	1380	else {
	1381	/* Don't update Z buffer or mask */
	1382	}
	1383	break;
	1384	case GL_NEVER:
	1385	/* depth test never passes */
	1386	MEMSET(mask, 0, n * sizeof(GLubyte));
	1387	break;
	1388	default:
	1389	gl_problem(ctx, "Bad depth func in hardware_depth_test_pixels");
[2938]	1390	}
	1391	}
	1392
	1393
	1394
[3598]	1395	void
	1396	_mesa_depth_test_pixels( GLcontext *ctx,
	1397	GLuint n, const GLint x[], const GLint y[],
	1398	const GLdepth z[], GLubyte mask[] )
	1399	{
	1400	if (ctx->Driver.ReadDepthPixels) {
	1401	/* read depth values from hardware Z buffer */
	1402	GLdepth zbuffer[PB_SIZE];
	1403	(*ctx->Driver.ReadDepthPixels)(ctx, n, x, y, zbuffer);
[2938]	1404
[3598]	1405	hardware_depth_test_pixels( ctx, n, zbuffer, z, mask );
	1406
	1407	/* update hardware Z buffer with new values */
	1408	ASSERT(ctx->Driver.WriteDepthPixels);
	1409	(*ctx->Driver.WriteDepthPixels)(ctx, n, x, y, zbuffer, mask );
	1410	}
	1411	else {
	1412	/* software depth testing */
	1413	if (ctx->Visual->DepthBits <= 16)
	1414	software_depth_test_pixels16(ctx, n, x, y, z, mask);
	1415	else
	1416	software_depth_test_pixels32(ctx, n, x, y, z, mask);
	1417	}
	1418	}
	1419
	1420
	1421
	1422
	1423
[2938]	1424	/**********************************************************************/
	1425	/*** Read Depth Buffer ***/
	1426	/**********************************************************************/
	1427
	1428
	1429	/*
	1430	* Return a span of depth values from the depth buffer as floats in [0,1].
[3598]	1431	* This is used for both hardware and software depth buffers.
[2938]	1432	* Input: n - how many pixels
	1433	* x,y - location of first pixel
	1434	* Output: depth - the array of depth values
	1435	*/
[3598]	1436	void
	1437	_mesa_read_depth_span_float( GLcontext* ctx,
	1438	GLuint n, GLint x, GLint y, GLfloat depth[] )
[2938]	1439	{
[3598]	1440	const GLfloat scale = 1.0F / ctx->Visual->DepthMaxF;
[2938]	1441
[3598]	1442	if (ctx->DrawBuffer->DepthBuffer) {
	1443	/* read from software depth buffer */
	1444	if (ctx->Visual->DepthBits <= 16) {
	1445	const GLushort *zptr = Z_ADDRESS16( ctx, x, y );
	1446	GLuint i;
	1447	for (i = 0; i < n; i++) {
	1448	depth[i] = (GLfloat) zptr[i] * scale;
	1449	}
[2938]	1450	}
[3598]	1451	else {
	1452	const GLuint *zptr = Z_ADDRESS32( ctx, x, y );
	1453	GLuint i;
	1454	for (i = 0; i < n; i++) {
	1455	depth[i] = (GLfloat) zptr[i] * scale;
	1456	}
[2938]	1457	}
	1458	}
[3598]	1459	else if (ctx->Driver.ReadDepthSpan) {
	1460	/* read from hardware depth buffer */
	1461	GLdepth d[MAX_WIDTH];
[2938]	1462	GLuint i;
[3598]	1463	ASSERT(n <= MAX_WIDTH);
	1464	(*ctx->Driver.ReadDepthSpan)( ctx, n, x, y, d );
	1465	for (i = 0; i < n; i++) {
	1466	depth[i] = d[i] * scale;
[2938]	1467	}
	1468	}
[3598]	1469	else {
	1470	/* no depth buffer */
	1471	MEMSET(depth, 0, n * sizeof(GLfloat));
	1472	}
[2938]	1473	}
	1474
	1475
	1476
	1477	/**********************************************************************/
	1478	/*** Allocate and Clear Depth Buffer ***/
	1479	/**********************************************************************/
	1480
	1481
	1482
	1483	/*
	1484	* Allocate a new depth buffer. If there's already a depth buffer allocated
	1485	* it will be free()'d. The new depth buffer will be uniniitalized.
	1486	* This function is only called through Driver.alloc_depth_buffer.
	1487	*/
[3598]	1488	void
	1489	_mesa_alloc_depth_buffer( GLcontext *ctx )
[2938]	1490	{
	1491	/* deallocate current depth buffer if present */
[3598]	1492	if (ctx->DrawBuffer->UseSoftwareDepthBuffer) {
	1493	GLint bytesPerValue;
[2938]	1494
[3598]	1495	if (ctx->DrawBuffer->DepthBuffer) {
	1496	FREE(ctx->DrawBuffer->DepthBuffer);
	1497	ctx->DrawBuffer->DepthBuffer = NULL;
	1498	}
	1499
	1500	/* allocate new depth buffer, but don't initialize it */
	1501	if (ctx->Visual->DepthBits <= 16)
	1502	bytesPerValue = sizeof(GLushort);
	1503	else
	1504	bytesPerValue = sizeof(GLuint);
	1505
	1506	ctx->DrawBuffer->DepthBuffer = MALLOC( ctx->DrawBuffer->Width
	1507	* ctx->DrawBuffer->Height
	1508	* bytesPerValue );
	1509
	1510	if (!ctx->DrawBuffer->DepthBuffer) {
	1511	/* out of memory */
	1512	ctx->Depth.Test = GL_FALSE;
	1513	ctx->NewState \|= NEW_RASTER_OPS;
	1514	gl_error( ctx, GL_OUT_OF_MEMORY, "Couldn't allocate depth buffer" );
	1515	}
[2938]	1516	}
	1517	}
	1518
	1519
	1520
	1521
	1522	/*
	1523	* Clear the depth buffer. If the depth buffer doesn't exist yet we'll
	1524	* allocate it now.
	1525	* This function is only called through Driver.clear_depth_buffer.
	1526	*/
[3598]	1527	void
	1528	_mesa_clear_depth_buffer( GLcontext *ctx )
[2938]	1529	{
[3598]	1530	if (ctx->Visual->DepthBits == 0
	1531	\|\| !ctx->DrawBuffer->DepthBuffer
	1532	\|\| !ctx->Depth.Mask) {
[2938]	1533	/* no depth buffer, or writing to it is disabled */
	1534	return;
	1535	}
	1536
	1537	/* The loops in this function have been written so the IRIX 5.3
	1538	* C compiler can unroll them. Hopefully other compilers can too!
	1539	*/
	1540
	1541	if (ctx->Scissor.Enabled) {
	1542	/* only clear scissor region */
[3598]	1543	if (ctx->Visual->DepthBits <= 16) {
	1544	const GLushort clearValue = (GLushort) (ctx->Depth.Clear * ctx->Visual->DepthMax);
	1545	const GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
	1546	const GLint width = ctx->DrawBuffer->Width;
	1547	GLushort dRow = (GLushort ) ctx->DrawBuffer->DepthBuffer
	1548	+ ctx->DrawBuffer->Ymin * width + ctx->DrawBuffer->Xmin;
	1549	GLint i, j;
	1550	for (i = 0; i < rows; i++) {
	1551	for (j = 0; j < width; j++) {
	1552	dRow[j] = clearValue;
	1553	}
	1554	dRow += width;
	1555	}
[2938]	1556	}
[3598]	1557	else {
	1558	const GLuint clearValue = (GLuint) (ctx->Depth.Clear * ctx->Visual->DepthMax);
	1559	const GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
	1560	const GLint width = ctx->DrawBuffer->Width;
	1561	GLuint dRow = (GLuint ) ctx->DrawBuffer->DepthBuffer
	1562	+ ctx->DrawBuffer->Ymin * width + ctx->DrawBuffer->Xmin;
	1563	GLint i, j;
	1564	for (i = 0; i < rows; i++) {
	1565	for (j = 0; j < width; j++) {
	1566	dRow[j] = clearValue;
	1567	}
	1568	dRow += width;
	1569	}
	1570	}
[2938]	1571	}
	1572	else {
	1573	/* clear whole buffer */
[3598]	1574	if (ctx->Visual->DepthBits <= 16) {
	1575	const GLushort clearValue = (GLushort) (ctx->Depth.Clear * ctx->Visual->DepthMax);
	1576	if ((clearValue & 0xff) == (clearValue >> 8)) {
	1577	/* lower and upper bytes of clear_value are same, use MEMSET */
	1578	MEMSET( ctx->DrawBuffer->DepthBuffer, clearValue & 0xff,
	1579	2 * ctx->DrawBuffer->Width * ctx->DrawBuffer->Height);
	1580	}
	1581	else {
	1582	GLushort d = (GLushort ) ctx->DrawBuffer->DepthBuffer;
	1583	GLint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
	1584	while (n >= 16) {
	1585	d[0] = clearValue; d[1] = clearValue;
	1586	d[2] = clearValue; d[3] = clearValue;
	1587	d[4] = clearValue; d[5] = clearValue;
	1588	d[6] = clearValue; d[7] = clearValue;
	1589	d[8] = clearValue; d[9] = clearValue;
	1590	d[10] = clearValue; d[11] = clearValue;
	1591	d[12] = clearValue; d[13] = clearValue;
	1592	d[14] = clearValue; d[15] = clearValue;
	1593	d += 16;
	1594	n -= 16;
	1595	}
	1596	while (n > 0) {
	1597	*d++ = clearValue;
	1598	n--;
	1599	}
	1600	}
[2938]	1601	}
	1602	else {
[3598]	1603	/* >16 bit depth buffer */
	1604	GLuint d = (GLuint ) ctx->DrawBuffer->DepthBuffer;
	1605	const GLuint clearValue = (GLuint) (ctx->Depth.Clear * ctx->Visual->DepthMax);
	1606	GLint n = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
	1607	while (n >= 16) {
	1608	d[0] = clearValue; d[1] = clearValue;
	1609	d[2] = clearValue; d[3] = clearValue;
	1610	d[4] = clearValue; d[5] = clearValue;
	1611	d[6] = clearValue; d[7] = clearValue;
	1612	d[8] = clearValue; d[9] = clearValue;
	1613	d[10] = clearValue; d[11] = clearValue;
	1614	d[12] = clearValue; d[13] = clearValue;
	1615	d[14] = clearValue; d[15] = clearValue;
[2938]	1616	d += 16;
	1617	n -= 16;
	1618	}
[3598]	1619	while (n > 0) {
	1620	*d++ = clearValue;
[2938]	1621	n--;
	1622	}
	1623	}
	1624	}
	1625	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: