WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/Mesa/src/gallium/drivers/softpipe/sp_quad_depth_test.c

Rev	Author	Line No.	Line
4358	Serge	1	/**************************************************************************
		2	*
		3	* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
		4	* Copyright 2010 VMware, Inc.
		5	* All Rights Reserved.
		6	*
		7	* Permission is hereby granted, free of charge, to any person obtaining a
		8	* copy of this software and associated documentation files (the
		9	* "Software"), to deal in the Software without restriction, including
		10	* without limitation the rights to use, copy, modify, merge, publish,
		11	* distribute, sub license, and/or sell copies of the Software, and to
		12	* permit persons to whom the Software is furnished to do so, subject to
		13	* the following conditions:
		14	*
		15	* The above copyright notice and this permission notice (including the
		16	* next paragraph) shall be included in all copies or substantial portions
		17	* 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
		21	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
		22	* IN NO EVENT SHALL THE AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR
		23	* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
		24	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
		25	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		26	*
		27	**************************************************************************/
		28
		29	/**
		30	* \brief Quad depth / stencil testing
		31	*/
		32
		33	#include "pipe/p_defines.h"
		34	#include "util/u_format.h"
		35	#include "util/u_math.h"
		36	#include "util/u_memory.h"
		37	#include "tgsi/tgsi_scan.h"
		38	#include "sp_context.h"
		39	#include "sp_quad.h"
		40	#include "sp_quad_pipe.h"
		41	#include "sp_tile_cache.h"
		42	#include "sp_state.h" /* for sp_fragment_shader */
		43
		44
		45	struct depth_data {
		46	struct pipe_surface *ps;
		47	enum pipe_format format;
		48	unsigned bzzzz[TGSI_QUAD_SIZE]; /*< Z values fetched from depth buffer /
		49	unsigned qzzzz[TGSI_QUAD_SIZE]; /*< Z values from the quad /
		50	ubyte stencilVals[TGSI_QUAD_SIZE];
		51	boolean use_shader_stencil_refs;
		52	ubyte shader_stencil_refs[TGSI_QUAD_SIZE];
		53	struct softpipe_cached_tile *tile;
		54	};
		55
		56
		57
		58	static void
		59	get_depth_stencil_values( struct depth_data *data,
		60	const struct quad_header *quad )
		61	{
		62	unsigned j;
		63	const struct softpipe_cached_tile *tile = data->tile;
		64
		65	switch (data->format) {
		66	case PIPE_FORMAT_Z16_UNORM:
		67	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		68	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		69	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		70	data->bzzzz[j] = tile->data.depth16[y][x];
		71	}
		72	break;
		73	case PIPE_FORMAT_Z32_UNORM:
		74	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		75	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		76	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		77	data->bzzzz[j] = tile->data.depth32[y][x];
		78	}
		79	break;
		80	case PIPE_FORMAT_Z24X8_UNORM:
		81	case PIPE_FORMAT_Z24_UNORM_S8_UINT:
		82	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		83	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		84	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		85	data->bzzzz[j] = tile->data.depth32[y][x] & 0xffffff;
		86	data->stencilVals[j] = tile->data.depth32[y][x] >> 24;
		87	}
		88	break;
		89	case PIPE_FORMAT_X8Z24_UNORM:
		90	case PIPE_FORMAT_S8_UINT_Z24_UNORM:
		91	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		92	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		93	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		94	data->bzzzz[j] = tile->data.depth32[y][x] >> 8;
		95	data->stencilVals[j] = tile->data.depth32[y][x] & 0xff;
		96	}
		97	break;
		98	case PIPE_FORMAT_S8_UINT:
		99	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		100	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		101	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		102	data->bzzzz[j] = 0;
		103	data->stencilVals[j] = tile->data.stencil8[y][x];
		104	}
		105	break;
		106	case PIPE_FORMAT_Z32_FLOAT:
		107	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		108	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		109	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		110	data->bzzzz[j] = tile->data.depth32[y][x];
		111	}
		112	break;
		113	case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
		114	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		115	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		116	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		117	data->bzzzz[j] = tile->data.depth64[y][x] & 0xffffffff;
		118	data->stencilVals[j] = (tile->data.depth64[y][x] >> 32) & 0xff;
		119	}
		120	break;
		121	default:
		122	assert(0);
		123	}
		124	}
		125
		126
		127	/**
		128	* If the shader has not been run, interpolate the depth values
		129	* ourselves.
		130	*/
		131	static void
		132	interpolate_quad_depth( struct quad_header *quad )
		133	{
		134	const float fx = (float) quad->input.x0;
		135	const float fy = (float) quad->input.y0;
		136	const float dzdx = quad->posCoef->dadx[2];
		137	const float dzdy = quad->posCoef->dady[2];
		138	const float z0 = quad->posCoef->a0[2] + dzdx * fx + dzdy * fy;
		139
		140	quad->output.depth[0] = z0;
		141	quad->output.depth[1] = z0 + dzdx;
		142	quad->output.depth[2] = z0 + dzdy;
		143	quad->output.depth[3] = z0 + dzdx + dzdy;
		144	}
		145
		146
		147	/**
		148	* Compute the depth_data::qzzzz[] values from the float fragment Z values.
		149	*/
		150	static void
		151	convert_quad_depth( struct depth_data *data,
		152	const struct quad_header *quad )
		153	{
		154	unsigned j;
		155
		156	/* Convert quad's float depth values to int depth values (qzzzz).
		157	* If the Z buffer stores integer values, we _have_ to do the depth
		158	* compares with integers (not floats). Otherwise, the float->int->float
		159	* conversion of Z values (which isn't an identity function) will cause
		160	* Z-fighting errors.
		161	*/
		162	switch (data->format) {
		163	case PIPE_FORMAT_Z16_UNORM:
		164	{
		165	float scale = 65535.0;
		166
		167	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		168	data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
		169	}
		170	}
		171	break;
		172	case PIPE_FORMAT_Z32_UNORM:
		173	{
		174	double scale = (double) (uint) ~0UL;
		175
		176	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		177	data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
		178	}
		179	}
		180	break;
		181	case PIPE_FORMAT_Z24X8_UNORM:
		182	case PIPE_FORMAT_Z24_UNORM_S8_UINT:
		183	{
		184	float scale = (float) ((1 << 24) - 1);
		185
		186	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		187	data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
		188	}
		189	}
		190	break;
		191	case PIPE_FORMAT_X8Z24_UNORM:
		192	case PIPE_FORMAT_S8_UINT_Z24_UNORM:
		193	{
		194	float scale = (float) ((1 << 24) - 1);
		195
		196	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		197	data->qzzzz[j] = (unsigned) (quad->output.depth[j] * scale);
		198	}
		199	}
		200	break;
		201	case PIPE_FORMAT_Z32_FLOAT:
		202	case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
		203	{
		204	union fi fui;
		205
		206	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		207	fui.f = quad->output.depth[j];
		208	data->qzzzz[j] = fui.ui;
		209	}
		210	}
		211	break;
		212	default:
		213	assert(0);
		214	}
		215	}
		216
		217
		218	/**
		219	* Compute the depth_data::shader_stencil_refs[] values from the float
		220	* fragment stencil values.
		221	*/
		222	static void
		223	convert_quad_stencil( struct depth_data *data,
		224	const struct quad_header *quad )
		225	{
		226	unsigned j;
		227
		228	data->use_shader_stencil_refs = TRUE;
		229	/* Copy quads stencil values
		230	*/
		231	switch (data->format) {
		232	case PIPE_FORMAT_Z24X8_UNORM:
		233	case PIPE_FORMAT_Z24_UNORM_S8_UINT:
		234	case PIPE_FORMAT_X8Z24_UNORM:
		235	case PIPE_FORMAT_S8_UINT_Z24_UNORM:
		236	case PIPE_FORMAT_S8_UINT:
		237	case PIPE_FORMAT_Z32_FLOAT:
		238	case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
		239	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		240	data->shader_stencil_refs[j] = ((unsigned)(quad->output.stencil[j]));
		241	}
		242	break;
		243	default:
		244	assert(0);
		245	}
		246	}
		247
		248
		249	/**
		250	* Write data->bzzzz[] values and data->stencilVals into the Z/stencil buffer.
		251	*/
		252	static void
		253	write_depth_stencil_values( struct depth_data *data,
		254	struct quad_header *quad )
		255	{
		256	struct softpipe_cached_tile *tile = data->tile;
		257	unsigned j;
		258
		259	/* put updated Z values back into cached tile */
		260	switch (data->format) {
		261	case PIPE_FORMAT_Z16_UNORM:
		262	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		263	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		264	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		265	tile->data.depth16[y][x] = (ushort) data->bzzzz[j];
		266	}
		267	break;
		268	case PIPE_FORMAT_Z24X8_UNORM:
		269	case PIPE_FORMAT_Z32_UNORM:
		270	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		271	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		272	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		273	tile->data.depth32[y][x] = data->bzzzz[j];
		274	}
		275	break;
		276	case PIPE_FORMAT_Z24_UNORM_S8_UINT:
		277	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		278	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		279	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		280	tile->data.depth32[y][x] = (data->stencilVals[j] << 24) \| data->bzzzz[j];
		281	}
		282	break;
		283	case PIPE_FORMAT_S8_UINT_Z24_UNORM:
		284	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		285	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		286	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		287	tile->data.depth32[y][x] = (data->bzzzz[j] << 8) \| data->stencilVals[j];
		288	}
		289	break;
		290	case PIPE_FORMAT_X8Z24_UNORM:
		291	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		292	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		293	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		294	tile->data.depth32[y][x] = data->bzzzz[j] << 8;
		295	}
		296	break;
		297	case PIPE_FORMAT_S8_UINT:
		298	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		299	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		300	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		301	tile->data.stencil8[y][x] = data->stencilVals[j];
		302	}
		303	break;
		304	case PIPE_FORMAT_Z32_FLOAT:
		305	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		306	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		307	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		308	tile->data.depth32[y][x] = data->bzzzz[j];
		309	}
		310	break;
		311	case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
		312	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		313	int x = quad->input.x0 % TILE_SIZE + (j & 1);
		314	int y = quad->input.y0 % TILE_SIZE + (j >> 1);
		315	tile->data.depth64[y][x] = (uint64_t)data->bzzzz[j] \| ((uint64_t)data->stencilVals[j] << 32);
		316	}
		317	break;
		318	default:
		319	assert(0);
		320	}
		321	}
		322
		323
		324
		325	/** Only 8-bit stencil supported */
		326	#define STENCIL_MAX 0xff
		327
		328
		329	/**
		330	* Do the basic stencil test (compare stencil buffer values against the
		331	* reference value.
		332	*
		333	* \param data->stencilVals the stencil values from the stencil buffer
		334	* \param func the stencil func (PIPE_FUNC_x)
		335	* \param ref the stencil reference value
		336	* \param valMask the stencil value mask indicating which bits of the stencil
		337	* values and ref value are to be used.
		338	* \return mask indicating which pixels passed the stencil test
		339	*/
		340	static unsigned
		341	do_stencil_test(struct depth_data *data,
		342	unsigned func,
		343	unsigned ref, unsigned valMask)
		344	{
		345	unsigned passMask = 0x0;
		346	unsigned j;
		347	ubyte refs[TGSI_QUAD_SIZE];
		348
		349	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		350	if (data->use_shader_stencil_refs)
		351	refs[j] = data->shader_stencil_refs[j] & valMask;
		352	else
		353	refs[j] = ref & valMask;
		354	}
		355
		356	switch (func) {
		357	case PIPE_FUNC_NEVER:
		358	/* passMask = 0x0 */
		359	break;
		360	case PIPE_FUNC_LESS:
		361	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		362	if (refs[j] < (data->stencilVals[j] & valMask)) {
		363	passMask \|= (1 << j);
		364	}
		365	}
		366	break;
		367	case PIPE_FUNC_EQUAL:
		368	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		369	if (refs[j] == (data->stencilVals[j] & valMask)) {
		370	passMask \|= (1 << j);
		371	}
		372	}
		373	break;
		374	case PIPE_FUNC_LEQUAL:
		375	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		376	if (refs[j] <= (data->stencilVals[j] & valMask)) {
		377	passMask \|= (1 << j);
		378	}
		379	}
		380	break;
		381	case PIPE_FUNC_GREATER:
		382	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		383	if (refs[j] > (data->stencilVals[j] & valMask)) {
		384	passMask \|= (1 << j);
		385	}
		386	}
		387	break;
		388	case PIPE_FUNC_NOTEQUAL:
		389	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		390	if (refs[j] != (data->stencilVals[j] & valMask)) {
		391	passMask \|= (1 << j);
		392	}
		393	}
		394	break;
		395	case PIPE_FUNC_GEQUAL:
		396	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		397	if (refs[j] >= (data->stencilVals[j] & valMask)) {
		398	passMask \|= (1 << j);
		399	}
		400	}
		401	break;
		402	case PIPE_FUNC_ALWAYS:
		403	passMask = MASK_ALL;
		404	break;
		405	default:
		406	assert(0);
		407	}
		408
		409	return passMask;
		410	}
		411
		412
		413	/**
		414	* Apply the stencil operator to stencil values.
		415	*
		416	* \param data->stencilVals the stencil buffer values (read and written)
		417	* \param mask indicates which pixels to update
		418	* \param op the stencil operator (PIPE_STENCIL_OP_x)
		419	* \param ref the stencil reference value
		420	* \param wrtMask writemask controlling which bits are changed in the
		421	* stencil values
		422	*/
		423	static void
		424	apply_stencil_op(struct depth_data *data,
		425	unsigned mask, unsigned op, ubyte ref, ubyte wrtMask)
		426	{
		427	unsigned j;
		428	ubyte newstencil[TGSI_QUAD_SIZE];
		429	ubyte refs[TGSI_QUAD_SIZE];
		430
		431	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		432	newstencil[j] = data->stencilVals[j];
		433	if (data->use_shader_stencil_refs)
		434	refs[j] = data->shader_stencil_refs[j];
		435	else
		436	refs[j] = ref;
		437	}
		438
		439	switch (op) {
		440	case PIPE_STENCIL_OP_KEEP:
		441	/* no-op */
		442	break;
		443	case PIPE_STENCIL_OP_ZERO:
		444	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		445	if (mask & (1 << j)) {
		446	newstencil[j] = 0;
		447	}
		448	}
		449	break;
		450	case PIPE_STENCIL_OP_REPLACE:
		451	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		452	if (mask & (1 << j)) {
		453	newstencil[j] = refs[j];
		454	}
		455	}
		456	break;
		457	case PIPE_STENCIL_OP_INCR:
		458	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		459	if (mask & (1 << j)) {
		460	if (data->stencilVals[j] < STENCIL_MAX) {
		461	newstencil[j] = data->stencilVals[j] + 1;
		462	}
		463	}
		464	}
		465	break;
		466	case PIPE_STENCIL_OP_DECR:
		467	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		468	if (mask & (1 << j)) {
		469	if (data->stencilVals[j] > 0) {
		470	newstencil[j] = data->stencilVals[j] - 1;
		471	}
		472	}
		473	}
		474	break;
		475	case PIPE_STENCIL_OP_INCR_WRAP:
		476	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		477	if (mask & (1 << j)) {
		478	newstencil[j] = data->stencilVals[j] + 1;
		479	}
		480	}
		481	break;
		482	case PIPE_STENCIL_OP_DECR_WRAP:
		483	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		484	if (mask & (1 << j)) {
		485	newstencil[j] = data->stencilVals[j] - 1;
		486	}
		487	}
		488	break;
		489	case PIPE_STENCIL_OP_INVERT:
		490	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		491	if (mask & (1 << j)) {
		492	newstencil[j] = ~data->stencilVals[j];
		493	}
		494	}
		495	break;
		496	default:
		497	assert(0);
		498	}
		499
		500	/*
		501	* update the stencil values
		502	*/
		503	if (wrtMask != STENCIL_MAX) {
		504	/* apply bit-wise stencil buffer writemask */
		505	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		506	data->stencilVals[j] = (wrtMask & newstencil[j]) \| (~wrtMask & data->stencilVals[j]);
		507	}
		508	}
		509	else {
		510	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		511	data->stencilVals[j] = newstencil[j];
		512	}
		513	}
		514	}
		515
		516
		517
		518	/**
		519	* To increase efficiency, we should probably have multiple versions
		520	* of this function that are specifically for Z16, Z32 and FP Z buffers.
		521	* Try to effectively do that with codegen...
		522	*/
		523	static boolean
		524	depth_test_quad(struct quad_stage *qs,
		525	struct depth_data *data,
		526	struct quad_header *quad)
		527	{
		528	struct softpipe_context *softpipe = qs->softpipe;
		529	unsigned zmask = 0;
		530	unsigned j;
		531
		532	switch (softpipe->depth_stencil->depth.func) {
		533	case PIPE_FUNC_NEVER:
		534	/* zmask = 0 */
		535	break;
		536	case PIPE_FUNC_LESS:
		537	/* Note this is pretty much a single sse or cell instruction.
		538	* Like this: quad->mask &= (quad->outputs.depth < zzzz);
		539	*/
		540	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		541	if (data->qzzzz[j] < data->bzzzz[j])
		542	zmask \|= 1 << j;
		543	}
		544	break;
		545	case PIPE_FUNC_EQUAL:
		546	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		547	if (data->qzzzz[j] == data->bzzzz[j])
		548	zmask \|= 1 << j;
		549	}
		550	break;
		551	case PIPE_FUNC_LEQUAL:
		552	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		553	if (data->qzzzz[j] <= data->bzzzz[j])
		554	zmask \|= (1 << j);
		555	}
		556	break;
		557	case PIPE_FUNC_GREATER:
		558	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		559	if (data->qzzzz[j] > data->bzzzz[j])
		560	zmask \|= (1 << j);
		561	}
		562	break;
		563	case PIPE_FUNC_NOTEQUAL:
		564	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		565	if (data->qzzzz[j] != data->bzzzz[j])
		566	zmask \|= (1 << j);
		567	}
		568	break;
		569	case PIPE_FUNC_GEQUAL:
		570	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		571	if (data->qzzzz[j] >= data->bzzzz[j])
		572	zmask \|= (1 << j);
		573	}
		574	break;
		575	case PIPE_FUNC_ALWAYS:
		576	zmask = MASK_ALL;
		577	break;
		578	default:
		579	assert(0);
		580	}
		581
		582	quad->inout.mask &= zmask;
		583	if (quad->inout.mask == 0)
		584	return FALSE;
		585
		586	/* Update our internal copy only if writemask set. Even if
		587	* depth.writemask is FALSE, may still need to write out buffer
		588	* data due to stencil changes.
		589	*/
		590	if (softpipe->depth_stencil->depth.writemask) {
		591	for (j = 0; j < TGSI_QUAD_SIZE; j++) {
		592	if (quad->inout.mask & (1 << j)) {
		593	data->bzzzz[j] = data->qzzzz[j];
		594	}
		595	}
		596	}
		597
		598	return TRUE;
		599	}
		600
		601
		602
		603	/**
		604	* Do stencil (and depth) testing. Stenciling depends on the outcome of
		605	* depth testing.
		606	*/
		607	static void
		608	depth_stencil_test_quad(struct quad_stage *qs,
		609	struct depth_data *data,
		610	struct quad_header *quad)
		611	{
		612	struct softpipe_context *softpipe = qs->softpipe;
		613	unsigned func, zFailOp, zPassOp, failOp;
		614	ubyte ref, wrtMask, valMask;
		615	uint face = quad->input.facing;
		616
		617	if (!softpipe->depth_stencil->stencil[1].enabled) {
		618	/* single-sided stencil test, use front (face=0) state */
		619	face = 0;
		620	}
		621
		622	/* 0 = front-face, 1 = back-face */
		623	assert(face == 0 \|\| face == 1);
		624
		625	/* choose front or back face function, operator, etc */
		626	/* XXX we could do these initializations once per primitive */
		627	func = softpipe->depth_stencil->stencil[face].func;
		628	failOp = softpipe->depth_stencil->stencil[face].fail_op;
		629	zFailOp = softpipe->depth_stencil->stencil[face].zfail_op;
		630	zPassOp = softpipe->depth_stencil->stencil[face].zpass_op;
		631	ref = softpipe->stencil_ref.ref_value[face];
		632	wrtMask = softpipe->depth_stencil->stencil[face].writemask;
		633	valMask = softpipe->depth_stencil->stencil[face].valuemask;
		634
		635	/* do the stencil test first */
		636	{
		637	unsigned passMask, failMask;
		638	passMask = do_stencil_test(data, func, ref, valMask);
		639	failMask = quad->inout.mask & ~passMask;
		640	quad->inout.mask &= passMask;
		641
		642	if (failOp != PIPE_STENCIL_OP_KEEP) {
		643	apply_stencil_op(data, failMask, failOp, ref, wrtMask);
		644	}
		645	}
		646
		647	if (quad->inout.mask) {
		648	/* now the pixels that passed the stencil test are depth tested */
		649	if (softpipe->depth_stencil->depth.enabled) {
		650	const unsigned origMask = quad->inout.mask;
		651
		652	depth_test_quad(qs, data, quad); /* quad->mask is updated */
		653
		654	/* update stencil buffer values according to z pass/fail result */
		655	if (zFailOp != PIPE_STENCIL_OP_KEEP) {
		656	const unsigned zFailMask = origMask & ~quad->inout.mask;
		657	apply_stencil_op(data, zFailMask, zFailOp, ref, wrtMask);
		658	}
		659
		660	if (zPassOp != PIPE_STENCIL_OP_KEEP) {
		661	const unsigned zPassMask = origMask & quad->inout.mask;
		662	apply_stencil_op(data, zPassMask, zPassOp, ref, wrtMask);
		663	}
		664	}
		665	else {
		666	/* no depth test, apply Zpass operator to stencil buffer values */
		667	apply_stencil_op(data, quad->inout.mask, zPassOp, ref, wrtMask);
		668	}
		669	}
		670	}
		671
		672
		673	#define ALPHATEST( FUNC, COMP ) \
		674	static unsigned \
		675	alpha_test_quads_##FUNC( struct quad_stage *qs, \
		676	struct quad_header *quads[], \
		677	unsigned nr ) \
		678	{ \
		679	const float ref = qs->softpipe->depth_stencil->alpha.ref_value; \
		680	const uint cbuf = 0; /* only output[0].alpha is tested */ \
		681	unsigned pass_nr = 0; \
		682	unsigned i; \
		683	\
		684	for (i = 0; i < nr; i++) { \
		685	const float *aaaa = quads[i]->output.color[cbuf][3]; \
		686	unsigned passMask = 0; \
		687	\
		688	if (aaaa[0] COMP ref) passMask \|= (1 << 0); \
		689	if (aaaa[1] COMP ref) passMask \|= (1 << 1); \
		690	if (aaaa[2] COMP ref) passMask \|= (1 << 2); \
		691	if (aaaa[3] COMP ref) passMask \|= (1 << 3); \
		692	\
		693	quads[i]->inout.mask &= passMask; \
		694	\
		695	if (quads[i]->inout.mask) \
		696	quads[pass_nr++] = quads[i]; \
		697	} \
		698	\
		699	return pass_nr; \
		700	}
		701
		702
		703	ALPHATEST( LESS, < )
		704	ALPHATEST( EQUAL, == )
		705	ALPHATEST( LEQUAL, <= )
		706	ALPHATEST( GREATER, > )
		707	ALPHATEST( NOTEQUAL, != )
		708	ALPHATEST( GEQUAL, >= )
		709
		710
		711	/* XXX: Incorporate into shader using KILL_IF.
		712	*/
		713	static unsigned
		714	alpha_test_quads(struct quad_stage *qs,
		715	struct quad_header *quads[],
		716	unsigned nr)
		717	{
		718	switch (qs->softpipe->depth_stencil->alpha.func) {
		719	case PIPE_FUNC_LESS:
		720	return alpha_test_quads_LESS( qs, quads, nr );
		721	case PIPE_FUNC_EQUAL:
		722	return alpha_test_quads_EQUAL( qs, quads, nr );
		723	case PIPE_FUNC_LEQUAL:
		724	return alpha_test_quads_LEQUAL( qs, quads, nr );
		725	case PIPE_FUNC_GREATER:
		726	return alpha_test_quads_GREATER( qs, quads, nr );
		727	case PIPE_FUNC_NOTEQUAL:
		728	return alpha_test_quads_NOTEQUAL( qs, quads, nr );
		729	case PIPE_FUNC_GEQUAL:
		730	return alpha_test_quads_GEQUAL( qs, quads, nr );
		731	case PIPE_FUNC_ALWAYS:
		732	return nr;
		733	case PIPE_FUNC_NEVER:
		734	default:
		735	return 0;
		736	}
		737	}
		738
		739
		740	static unsigned mask_count[16] =
		741	{
		742	0, /* 0x0 */
		743	1, /* 0x1 */
		744	1, /* 0x2 */
		745	2, /* 0x3 */
		746	1, /* 0x4 */
		747	2, /* 0x5 */
		748	2, /* 0x6 */
		749	3, /* 0x7 */
		750	1, /* 0x8 */
		751	2, /* 0x9 */
		752	2, /* 0xa */
		753	3, /* 0xb */
		754	2, /* 0xc */
		755	3, /* 0xd */
		756	3, /* 0xe */
		757	4, /* 0xf */
		758	};
		759
		760
		761
		762	/**
		763	* General depth/stencil test function. Used when there's no fast-path.
		764	*/
		765	static void
		766	depth_test_quads_fallback(struct quad_stage *qs,
		767	struct quad_header *quads[],
		768	unsigned nr)
		769	{
		770	unsigned i, pass = 0;
		771	const struct tgsi_shader_info *fsInfo = &qs->softpipe->fs_variant->info;
		772	boolean interp_depth = !fsInfo->writes_z;
		773	boolean shader_stencil_ref = fsInfo->writes_stencil;
		774	struct depth_data data;
		775
		776	data.use_shader_stencil_refs = FALSE;
		777
		778	if (qs->softpipe->depth_stencil->alpha.enabled) {
		779	nr = alpha_test_quads(qs, quads, nr);
		780	}
		781
		782	if (qs->softpipe->framebuffer.zsbuf &&
		783	(qs->softpipe->depth_stencil->depth.enabled \|\|
		784	qs->softpipe->depth_stencil->stencil[0].enabled)) {
		785
		786	data.ps = qs->softpipe->framebuffer.zsbuf;
		787	data.format = data.ps->format;
		788	data.tile = sp_get_cached_tile(qs->softpipe->zsbuf_cache,
		789	quads[0]->input.x0,
		790	quads[0]->input.y0);
		791
		792	for (i = 0; i < nr; i++) {
		793	get_depth_stencil_values(&data, quads[i]);
		794
		795	if (qs->softpipe->depth_stencil->depth.enabled) {
		796	if (interp_depth)
		797	interpolate_quad_depth(quads[i]);
		798
		799	convert_quad_depth(&data, quads[i]);
		800	}
		801
		802	if (qs->softpipe->depth_stencil->stencil[0].enabled) {
		803	if (shader_stencil_ref)
		804	convert_quad_stencil(&data, quads[i]);
		805
		806	depth_stencil_test_quad(qs, &data, quads[i]);
		807	write_depth_stencil_values(&data, quads[i]);
		808	}
		809	else {
		810	if (!depth_test_quad(qs, &data, quads[i]))
		811	continue;
		812
		813	if (qs->softpipe->depth_stencil->depth.writemask)
		814	write_depth_stencil_values(&data, quads[i]);
		815	}
		816
		817	quads[pass++] = quads[i];
		818	}
		819
		820	nr = pass;
		821	}
		822
		823	if (qs->softpipe->active_query_count) {
		824	for (i = 0; i < nr; i++)
		825	qs->softpipe->occlusion_count += mask_count[quads[i]->inout.mask];
		826	}
		827
		828	if (nr)
		829	qs->next->run(qs->next, quads, nr);
		830	}
		831
		832
		833	/**
		834	* Special-case Z testing for 16-bit Zbuffer and Z buffer writes enabled.
		835	*/
		836
		837	#define NAME depth_interp_z16_less_write
		838	#define OPERATOR <
		839	#include "sp_quad_depth_test_tmp.h"
		840
		841	#define NAME depth_interp_z16_equal_write
		842	#define OPERATOR ==
		843	#include "sp_quad_depth_test_tmp.h"
		844
		845	#define NAME depth_interp_z16_lequal_write
		846	#define OPERATOR <=
		847	#include "sp_quad_depth_test_tmp.h"
		848
		849	#define NAME depth_interp_z16_greater_write
		850	#define OPERATOR >
		851	#include "sp_quad_depth_test_tmp.h"
		852
		853	#define NAME depth_interp_z16_notequal_write
		854	#define OPERATOR !=
		855	#include "sp_quad_depth_test_tmp.h"
		856
		857	#define NAME depth_interp_z16_gequal_write
		858	#define OPERATOR >=
		859	#include "sp_quad_depth_test_tmp.h"
		860
		861	#define NAME depth_interp_z16_always_write
		862	#define ALWAYS 1
		863	#include "sp_quad_depth_test_tmp.h"
		864
		865
		866
		867	static void
		868	depth_noop(struct quad_stage *qs,
		869	struct quad_header *quads[],
		870	unsigned nr)
		871	{
		872	qs->next->run(qs->next, quads, nr);
		873	}
		874
		875
		876
		877	static void
		878	choose_depth_test(struct quad_stage *qs,
		879	struct quad_header *quads[],
		880	unsigned nr)
		881	{
		882	const struct tgsi_shader_info *fsInfo = &qs->softpipe->fs_variant->info;
		883
		884	boolean interp_depth = !fsInfo->writes_z;
		885
		886	boolean alpha = qs->softpipe->depth_stencil->alpha.enabled;
		887
		888	boolean depth = qs->softpipe->depth_stencil->depth.enabled;
		889
		890	unsigned depthfunc = qs->softpipe->depth_stencil->depth.func;
		891
		892	boolean stencil = qs->softpipe->depth_stencil->stencil[0].enabled;
		893
		894	boolean depthwrite = qs->softpipe->depth_stencil->depth.writemask;
		895
		896	boolean occlusion = qs->softpipe->active_query_count;
		897
		898	if(!qs->softpipe->framebuffer.zsbuf)
		899	depth = depthwrite = stencil = FALSE;
		900
		901	/* default */
		902	qs->run = depth_test_quads_fallback;
		903
		904	/* look for special cases */
		905	if (!alpha &&
		906	!depth &&
		907	!occlusion &&
		908	!stencil) {
		909	qs->run = depth_noop;
		910	}
		911	else if (!alpha &&
		912	interp_depth &&
		913	depth &&
		914	depthwrite &&
		915	!occlusion &&
		916	!stencil)
		917	{
		918	if (qs->softpipe->framebuffer.zsbuf->format == PIPE_FORMAT_Z16_UNORM) {
		919	switch (depthfunc) {
		920	case PIPE_FUNC_NEVER:
		921	qs->run = depth_test_quads_fallback;
		922	break;
		923	case PIPE_FUNC_LESS:
		924	qs->run = depth_interp_z16_less_write;
		925	break;
		926	case PIPE_FUNC_EQUAL:
		927	qs->run = depth_interp_z16_equal_write;
		928	break;
		929	case PIPE_FUNC_LEQUAL:
		930	qs->run = depth_interp_z16_lequal_write;
		931	break;
		932	case PIPE_FUNC_GREATER:
		933	qs->run = depth_interp_z16_greater_write;
		934	break;
		935	case PIPE_FUNC_NOTEQUAL:
		936	qs->run = depth_interp_z16_notequal_write;
		937	break;
		938	case PIPE_FUNC_GEQUAL:
		939	qs->run = depth_interp_z16_gequal_write;
		940	break;
		941	case PIPE_FUNC_ALWAYS:
		942	qs->run = depth_interp_z16_always_write;
		943	break;
		944	default:
		945	qs->run = depth_test_quads_fallback;
		946	break;
		947	}
		948	}
		949	}
		950
		951	/* next quad/fragment stage */
		952	qs->run( qs, quads, nr );
		953	}
		954
		955
		956
		957	static void
		958	depth_test_begin(struct quad_stage *qs)
		959	{
		960	qs->run = choose_depth_test;
		961	qs->next->begin(qs->next);
		962	}
		963
		964
		965	static void
		966	depth_test_destroy(struct quad_stage *qs)
		967	{
		968	FREE( qs );
		969	}
		970
		971
		972	struct quad_stage *
		973	sp_quad_depth_test_stage(struct softpipe_context *softpipe)
		974	{
		975	struct quad_stage *stage = CALLOC_STRUCT(quad_stage);
		976
		977	stage->softpipe = softpipe;
		978	stage->begin = depth_test_begin;
		979	stage->run = choose_depth_test;
		980	stage->destroy = depth_test_destroy;
		981
		982	return stage;
		983	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/src/gallium/drivers/softpipe/sp_quad_depth_test.c – Rev 4826