• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2009-2010 Francisco Jerez.
3  * All Rights Reserved.
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining
6  * a copy of this software and associated documentation files (the
7  * "Software"), to deal in the Software without restriction, including
8  * without limitation the rights to use, copy, modify, merge, publish,
9  * distribute, sublicense, and/or sell copies of the Software, and to
10  * permit persons to whom the Software is furnished to do so, subject to
11  * the following conditions:
12  *
13  * The above copyright notice and this permission notice (including the
14  * next paragraph) shall be included in all copies or substantial
15  * portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24  *
25  */
26 
27 #include "nouveau_driver.h"
28 #include "nouveau_context.h"
29 #include "nouveau_gldefs.h"
30 #include "nv10_3d.xml.h"
31 #include "nouveau_util.h"
32 #include "nv10_driver.h"
33 #include "nv20_driver.h"
34 
35 #define RC_IN_SHIFT_A	24
36 #define RC_IN_SHIFT_B	16
37 #define RC_IN_SHIFT_C	8
38 #define RC_IN_SHIFT_D	0
39 #define RC_IN_SHIFT_E	56
40 #define RC_IN_SHIFT_F	48
41 #define RC_IN_SHIFT_G	40
42 
43 #define RC_IN_SOURCE(source)				\
44 	((uint64_t)NV10_3D_RC_IN_RGB_D_INPUT_##source)
45 #define RC_IN_USAGE(usage)					\
46 	((uint64_t)NV10_3D_RC_IN_RGB_D_COMPONENT_USAGE_##usage)
47 #define RC_IN_MAPPING(mapping)					\
48 	((uint64_t)NV10_3D_RC_IN_RGB_D_MAPPING_##mapping)
49 
50 #define RC_OUT_BIAS	NV10_3D_RC_OUT_RGB_BIAS_BIAS_BY_NEGATIVE_ONE_HALF
51 #define RC_OUT_SCALE_1	NV10_3D_RC_OUT_RGB_SCALE_NONE
52 #define RC_OUT_SCALE_2	NV10_3D_RC_OUT_RGB_SCALE_SCALE_BY_TWO
53 #define RC_OUT_SCALE_4	NV10_3D_RC_OUT_RGB_SCALE_SCALE_BY_FOUR
54 
55 /* Make the combiner do: spare0_i = A_i * B_i */
56 #define RC_OUT_AB	NV10_3D_RC_OUT_RGB_AB_OUTPUT_SPARE0
57 /* spare0_i = dot3(A, B) */
58 #define RC_OUT_DOT_AB	(NV10_3D_RC_OUT_RGB_AB_OUTPUT_SPARE0 |	\
59 			 NV10_3D_RC_OUT_RGB_AB_DOT_PRODUCT)
60 /* spare0_i = A_i * B_i + C_i * D_i */
61 #define RC_OUT_SUM	NV10_3D_RC_OUT_RGB_SUM_OUTPUT_SPARE0
62 
63 struct combiner_state {
64 	struct gl_context *ctx;
65 	int unit;
66 	GLboolean premodulate;
67 
68 	/* GL state */
69 	GLenum mode;
70 	GLenum *source;
71 	GLenum *operand;
72 	GLuint logscale;
73 
74 	/* Derived HW state */
75 	uint64_t in;
76 	uint32_t out;
77 };
78 
79 /* Initialize a combiner_state struct from the texture unit
80  * context. */
81 #define INIT_COMBINER(chan, ctx, rc, i) do {			\
82 		struct gl_tex_env_combine_state *c =		\
83 			ctx->Texture.Unit[i]._CurrentCombine;	\
84 		(rc)->ctx = ctx;				\
85 		(rc)->unit = i;					\
86 		(rc)->premodulate = c->_NumArgs##chan == 4;	\
87 		(rc)->mode = c->Mode##chan;			\
88 		(rc)->source = c->Source##chan;			\
89 		(rc)->operand = c->Operand##chan;		\
90 		(rc)->logscale = c->ScaleShift##chan;		\
91 		(rc)->in = (rc)->out = 0;			\
92 	} while (0)
93 
94 /* Get the RC input source for the specified EXT_texture_env_combine
95  * source. */
96 static uint32_t
get_input_source(struct combiner_state * rc,int source)97 get_input_source(struct combiner_state *rc, int source)
98 {
99 	switch (source) {
100 	case GL_ZERO:
101 		return RC_IN_SOURCE(ZERO);
102 
103 	case GL_TEXTURE:
104 		return RC_IN_SOURCE(TEXTURE0) + rc->unit;
105 
106 	case GL_TEXTURE0:
107 		return RC_IN_SOURCE(TEXTURE0);
108 
109 	case GL_TEXTURE1:
110 		return RC_IN_SOURCE(TEXTURE1);
111 
112 	case GL_TEXTURE2:
113 		return RC_IN_SOURCE(TEXTURE2);
114 
115 	case GL_TEXTURE3:
116 		return RC_IN_SOURCE(TEXTURE3);
117 
118 	case GL_CONSTANT:
119 		return context_chipset(rc->ctx) >= 0x20 ?
120 			RC_IN_SOURCE(CONSTANT_COLOR0) :
121 			RC_IN_SOURCE(CONSTANT_COLOR0) + rc->unit;
122 
123 	case GL_PRIMARY_COLOR:
124 		return RC_IN_SOURCE(PRIMARY_COLOR);
125 
126 	case GL_PREVIOUS:
127 		return rc->unit ? RC_IN_SOURCE(SPARE0)
128 			: RC_IN_SOURCE(PRIMARY_COLOR);
129 
130 	default:
131 		assert(0);
132 	}
133 }
134 
135 /* Get the RC input mapping for the specified texture_env_combine
136  * operand, possibly inverted or biased. */
137 #define INVERT 0x1
138 #define NORMALIZE 0x2
139 
140 static uint32_t
get_input_mapping(struct combiner_state * rc,int operand,int flags)141 get_input_mapping(struct combiner_state *rc, int operand, int flags)
142 {
143 	int map = 0;
144 
145 	if (is_color_operand(operand))
146 		map |= RC_IN_USAGE(RGB);
147 	else
148 		map |= RC_IN_USAGE(ALPHA);
149 
150 	if (is_negative_operand(operand) == !(flags & INVERT))
151 		map |= flags & NORMALIZE ?
152 			RC_IN_MAPPING(EXPAND_NEGATE) :
153 			RC_IN_MAPPING(UNSIGNED_INVERT);
154 	else
155 		map |= flags & NORMALIZE ?
156 			RC_IN_MAPPING(EXPAND_NORMAL) :
157 			RC_IN_MAPPING(UNSIGNED_IDENTITY);
158 
159 	return map;
160 }
161 
162 static uint32_t
get_input_arg(struct combiner_state * rc,int arg,int flags)163 get_input_arg(struct combiner_state *rc, int arg, int flags)
164 {
165 	int source = rc->source[arg];
166 	int operand = rc->operand[arg];
167 
168 	/* Fake several unsupported texture formats. */
169 	if (is_texture_source(source)) {
170 		int i = (source == GL_TEXTURE ?
171 			 rc->unit : source - GL_TEXTURE0);
172 		struct gl_texture_object *t = rc->ctx->Texture.Unit[i]._Current;
173 		mesa_format format = t->Image[0][t->BaseLevel]->TexFormat;
174 
175 		if (format == MESA_FORMAT_A_UNORM8) {
176 			/* Emulated using I8. */
177 			if (is_color_operand(operand))
178 				return RC_IN_SOURCE(ZERO) |
179 					get_input_mapping(rc, operand, flags);
180 
181 		} else if (format == MESA_FORMAT_L_UNORM8) {
182 			/* Sometimes emulated using I8. */
183 			if (!is_color_operand(operand))
184 				return RC_IN_SOURCE(ZERO) |
185 					get_input_mapping(rc, operand,
186 							  flags ^ INVERT);
187 
188 		} else if (format == MESA_FORMAT_B8G8R8X8_UNORM) {
189 			/* Sometimes emulated using ARGB8888. */
190 			if (!is_color_operand(operand))
191 				return RC_IN_SOURCE(ZERO) |
192 					get_input_mapping(rc, operand,
193 							  flags ^ INVERT);
194 		}
195 	}
196 
197 	return get_input_source(rc, source) |
198 		get_input_mapping(rc, operand, flags);
199 }
200 
201 /* Bind the RC input variable <var> to the EXT_texture_env_combine
202  * argument <arg>, possibly inverted or biased. */
203 #define INPUT_ARG(rc, var, arg, flags)					\
204 	(rc)->in |= get_input_arg(rc, arg, flags) << RC_IN_SHIFT_##var
205 
206 /* Bind the RC input variable <var> to the RC source <src>. */
207 #define INPUT_SRC(rc, var, src, chan)					\
208 	(rc)->in |= (RC_IN_SOURCE(src) |				\
209 		     RC_IN_USAGE(chan)) << RC_IN_SHIFT_##var
210 
211 /* Bind the RC input variable <var> to a constant +/-1 */
212 #define INPUT_ONE(rc, var, flags)					\
213 	(rc)->in |= (RC_IN_SOURCE(ZERO) |				\
214 		     (flags & INVERT ? RC_IN_MAPPING(EXPAND_NORMAL) :	\
215 		      RC_IN_MAPPING(UNSIGNED_INVERT))) << RC_IN_SHIFT_##var
216 
217 static void
setup_combiner(struct combiner_state * rc)218 setup_combiner(struct combiner_state *rc)
219 {
220 	switch (rc->mode) {
221 	case GL_REPLACE:
222 		INPUT_ARG(rc, A, 0, 0);
223 		INPUT_ONE(rc, B, 0);
224 
225 		rc->out = RC_OUT_AB;
226 		break;
227 
228 	case GL_MODULATE:
229 		INPUT_ARG(rc, A, 0, 0);
230 		INPUT_ARG(rc, B, 1, 0);
231 
232 		rc->out = RC_OUT_AB;
233 		break;
234 
235 	case GL_ADD:
236 	case GL_ADD_SIGNED:
237 		if (rc->premodulate) {
238 			INPUT_ARG(rc, A, 0, 0);
239 			INPUT_ARG(rc, B, 1, 0);
240 			INPUT_ARG(rc, C, 2, 0);
241 			INPUT_ARG(rc, D, 3, 0);
242 		} else {
243 			INPUT_ARG(rc, A, 0, 0);
244 			INPUT_ONE(rc, B, 0);
245 			INPUT_ARG(rc, C, 1, 0);
246 			INPUT_ONE(rc, D, 0);
247 		}
248 
249 		rc->out = RC_OUT_SUM |
250 			(rc->mode == GL_ADD_SIGNED ? RC_OUT_BIAS : 0);
251 		break;
252 
253 	case GL_INTERPOLATE:
254 		INPUT_ARG(rc, A, 0, 0);
255 		INPUT_ARG(rc, B, 2, 0);
256 		INPUT_ARG(rc, C, 1, 0);
257 		INPUT_ARG(rc, D, 2, INVERT);
258 
259 		rc->out = RC_OUT_SUM;
260 		break;
261 
262 	case GL_SUBTRACT:
263 		INPUT_ARG(rc, A, 0, 0);
264 		INPUT_ONE(rc, B, 0);
265 		INPUT_ARG(rc, C, 1, 0);
266 		INPUT_ONE(rc, D, INVERT);
267 
268 		rc->out = RC_OUT_SUM;
269 		break;
270 
271 	case GL_DOT3_RGB:
272 	case GL_DOT3_RGBA:
273 		INPUT_ARG(rc, A, 0, NORMALIZE);
274 		INPUT_ARG(rc, B, 1, NORMALIZE);
275 
276 		rc->out = RC_OUT_DOT_AB;
277 		break;
278 
279 	case GL_DOT3_RGB_EXT:
280 	case GL_DOT3_RGBA_EXT:
281 		INPUT_ARG(rc, A, 0, NORMALIZE);
282 		INPUT_ARG(rc, B, 1, NORMALIZE);
283 
284 		rc->out = RC_OUT_DOT_AB;
285 
286 		/* The EXT version of the DOT3 extension does not support the
287 		 * scale factor, but the ARB version (and the version in
288 		 * OpenGL 1.3) does.
289 		 */
290 		rc->logscale = 0;
291 		break;
292 
293 	default:
294 		assert(0);
295 	}
296 
297 	switch (rc->logscale) {
298 	case 0:
299 		rc->out |= RC_OUT_SCALE_1;
300 		break;
301 	case 1:
302 		rc->out |= RC_OUT_SCALE_2;
303 		break;
304 	case 2:
305 		rc->out |= RC_OUT_SCALE_4;
306 		break;
307 	default:
308 		assert(0);
309 	}
310 }
311 
312 void
nv10_get_general_combiner(struct gl_context * ctx,int i,uint32_t * a_in,uint32_t * a_out,uint32_t * c_in,uint32_t * c_out,uint32_t * k)313 nv10_get_general_combiner(struct gl_context *ctx, int i,
314 			  uint32_t *a_in, uint32_t *a_out,
315 			  uint32_t *c_in, uint32_t *c_out, uint32_t *k)
316 {
317 	struct combiner_state rc_a, rc_c;
318 
319 	if (ctx->Texture.Unit[i]._Current) {
320 		INIT_COMBINER(RGB, ctx, &rc_c, i);
321 
322 		if (rc_c.mode == GL_DOT3_RGBA || rc_c.mode == GL_DOT3_RGBA_EXT)
323 			rc_a = rc_c;
324 		else
325 			INIT_COMBINER(A, ctx, &rc_a, i);
326 
327 		setup_combiner(&rc_c);
328 		setup_combiner(&rc_a);
329 
330 	} else {
331 		rc_a.in = rc_a.out = rc_c.in = rc_c.out = 0;
332 	}
333 
334 	*k = pack_rgba_f(MESA_FORMAT_B8G8R8A8_UNORM,
335 			 ctx->Texture.Unit[i].EnvColor);
336 	*a_in = rc_a.in;
337 	*a_out = rc_a.out;
338 	*c_in = rc_c.in;
339 	*c_out = rc_c.out;
340 }
341 
342 void
nv10_get_final_combiner(struct gl_context * ctx,uint64_t * in,int * n)343 nv10_get_final_combiner(struct gl_context *ctx, uint64_t *in, int *n)
344 {
345 	struct combiner_state rc = {};
346 
347 	/*
348 	 * The final fragment value equation is something like:
349 	 *	x_i = A_i * B_i + (1 - A_i) * C_i + D_i
350 	 *	x_alpha = G_alpha
351 	 * where D_i = E_i * F_i, i one of {red, green, blue}.
352 	 */
353 	if (ctx->Fog.ColorSumEnabled || ctx->Light.Enabled) {
354 		INPUT_SRC(&rc, D, E_TIMES_F, RGB);
355 		INPUT_SRC(&rc, F, SECONDARY_COLOR, RGB);
356 	}
357 
358 	if (ctx->Fog.Enabled) {
359 		INPUT_SRC(&rc, A, FOG, ALPHA);
360 		INPUT_SRC(&rc, C, FOG, RGB);
361 		INPUT_SRC(&rc, E, FOG, ALPHA);
362 	} else {
363 		INPUT_ONE(&rc, A, 0);
364 		INPUT_ONE(&rc, C, 0);
365 		INPUT_ONE(&rc, E, 0);
366 	}
367 
368 	if (ctx->Texture._MaxEnabledTexImageUnit != -1) {
369 		INPUT_SRC(&rc, B, SPARE0, RGB);
370 		INPUT_SRC(&rc, G, SPARE0, ALPHA);
371 	} else {
372 		INPUT_SRC(&rc, B, PRIMARY_COLOR, RGB);
373 		INPUT_SRC(&rc, G, PRIMARY_COLOR, ALPHA);
374 	}
375 
376 	*in = rc.in;
377 	*n = ctx->Texture._MaxEnabledTexImageUnit + 1;
378 }
379 
380 void
nv10_emit_tex_env(struct gl_context * ctx,int emit)381 nv10_emit_tex_env(struct gl_context *ctx, int emit)
382 {
383 	const int i = emit - NOUVEAU_STATE_TEX_ENV0;
384 	struct nouveau_pushbuf *push = context_push(ctx);
385 	uint32_t a_in, a_out, c_in, c_out, k;
386 
387 	nv10_get_general_combiner(ctx, i, &a_in, &a_out, &c_in, &c_out, &k);
388 
389 	/* Enable the combiners we're going to need. */
390 	if (i == 1) {
391 		if (c_out || a_out)
392 			c_out |= 0x5 << 27;
393 		else
394 			c_out |= 0x3 << 27;
395 	}
396 
397 	BEGIN_NV04(push, NV10_3D(RC_IN_ALPHA(i)), 1);
398 	PUSH_DATA (push, a_in);
399 	BEGIN_NV04(push, NV10_3D(RC_IN_RGB(i)), 1);
400 	PUSH_DATA (push, c_in);
401 	BEGIN_NV04(push, NV10_3D(RC_COLOR(i)), 1);
402 	PUSH_DATA (push, k);
403 	BEGIN_NV04(push, NV10_3D(RC_OUT_ALPHA(i)), 1);
404 	PUSH_DATA (push, a_out);
405 	BEGIN_NV04(push, NV10_3D(RC_OUT_RGB(i)), 1);
406 	PUSH_DATA (push, c_out);
407 
408 	context_dirty(ctx, FRAG);
409 }
410 
411 void
nv10_emit_frag(struct gl_context * ctx,int emit)412 nv10_emit_frag(struct gl_context *ctx, int emit)
413 {
414 	struct nouveau_pushbuf *push = context_push(ctx);
415 	uint64_t in;
416 	int n;
417 
418 	nv10_get_final_combiner(ctx, &in, &n);
419 
420 	BEGIN_NV04(push, NV10_3D(RC_FINAL0), 2);
421 	PUSH_DATA (push, in);
422 	PUSH_DATA (push, in >> 32);
423 }
424