projects / mesa.git / blob
? search:


20424b1da4348a995f5b69d4195a13b84e45b77c
[mesa.git] / src / mesa / drivers / dri / i915 / i915_fragprog.c
1 /**************************************************************************
2 *
3 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 #include "glheader.h"
29 #include "macros.h"
30 #include "enums.h"
31
32 #include "tnl/t_context.h"
33 #include "intel_batchbuffer.h"
34
35 #include "i915_reg.h"
36 #include "i915_context.h"
37 #include "i915_program.h"
38
39 #include "program_instruction.h"
40 #include "program.h"
41 #include "arbfragparse.h"
42
43
44
45 #undef PI
46 #define PI 3.141592
47
48
49 /* 1, -1/3!, 1/5!, -1/7! */
50 static const GLfloat sin_constants[4] = { 1.0,
51 -1.0/(3*2*1),
52 1.0/(5*4*3*2*1),
53 -1.0/(7*6*5*4*3*2*1) };
54
55 /* 1, -1/2!, 1/4!, -1/6! */
56 static const GLfloat cos_constants[4] = { 1.0,
57 -1.0/(2*1),
58 1.0/(4*3*2*1),
59 -1.0/(6*5*4*3*2*1) };
60
61 /**
62 * Retrieve a ureg for the given source register. Will emit
63 * constants, apply swizzling and negation as needed.
64 */
65 static GLuint src_vector( struct i915_fragment_program *p,
66 const struct prog_src_register *source,
67 const struct fragment_program *program )
68 {
69 GLuint src;
70
71 switch (source->File) {
72
73 /* Registers:
74 */
75 case PROGRAM_TEMPORARY:
76 if (source->Index >= I915_MAX_TEMPORARY) {
77 i915_program_error( p, "Exceeded max temporary reg" );
78 return 0;
79 }
80 src = UREG( REG_TYPE_R, source->Index );
81 break;
82 case PROGRAM_INPUT:
83 switch (source->Index) {
84 case FRAG_ATTRIB_WPOS:
85 src = i915_emit_decl( p, REG_TYPE_T, p->wpos_tex, D0_CHANNEL_ALL );
86 break;
87 case FRAG_ATTRIB_COL0:
88 src = i915_emit_decl( p, REG_TYPE_T, T_DIFFUSE, D0_CHANNEL_ALL );
89 break;
90 case FRAG_ATTRIB_COL1:
91 src = i915_emit_decl( p, REG_TYPE_T, T_SPECULAR, D0_CHANNEL_XYZ );
92 src = swizzle( src, X, Y, Z, ONE );
93 break;
94 case FRAG_ATTRIB_FOGC:
95 src = i915_emit_decl( p, REG_TYPE_T, T_FOG_W, D0_CHANNEL_W );
96 src = swizzle( src, W, W, W, W );
97 break;
98 case FRAG_ATTRIB_TEX0:
99 case FRAG_ATTRIB_TEX1:
100 case FRAG_ATTRIB_TEX2:
101 case FRAG_ATTRIB_TEX3:
102 case FRAG_ATTRIB_TEX4:
103 case FRAG_ATTRIB_TEX5:
104 case FRAG_ATTRIB_TEX6:
105 case FRAG_ATTRIB_TEX7:
106 src = i915_emit_decl( p, REG_TYPE_T,
107 T_TEX0 + (source->Index - FRAG_ATTRIB_TEX0),
108 D0_CHANNEL_ALL );
109 break;
110
111 default:
112 i915_program_error( p, "Bad source->Index" );
113 return 0;
114 }
115 break;
116
117 /* Various paramters and env values. All emitted to
118 * hardware as program constants.
119 */
120 case PROGRAM_LOCAL_PARAM:
121 src = i915_emit_param4fv(
122 p, program->Base.LocalParams[source->Index]);
123 break;
124
125 case PROGRAM_ENV_PARAM:
126 src = i915_emit_param4fv(
127 p, p->ctx->FragmentProgram.Parameters[source->Index]);
128 break;
129
130 case PROGRAM_STATE_VAR:
131 case PROGRAM_NAMED_PARAM:
132 src = i915_emit_param4fv(
133 p, program->Parameters->ParameterValues[source->Index] );
134 break;
135
136 default:
137 i915_program_error( p, "Bad source->File" );
138 return 0;
139 }
140
141 src = swizzle(src,
142 GET_SWZ(source->Swizzle, 0),
143 GET_SWZ(source->Swizzle, 1),
144 GET_SWZ(source->Swizzle, 2),
145 GET_SWZ(source->Swizzle, 3));
146
147 if (source->NegateBase)
148 src = negate( src,
149 GET_BIT(source->NegateBase, 0),
150 GET_BIT(source->NegateBase, 1),
151 GET_BIT(source->NegateBase, 2),
152 GET_BIT(source->NegateBase, 3));
153
154 return src;
155 }
156
157
158 static GLuint get_result_vector( struct i915_fragment_program *p,
159 const struct prog_instruction *inst )
160 {
161 switch (inst->DstReg.File) {
162 case PROGRAM_OUTPUT:
163 switch (inst->DstReg.Index) {
164 case 0:
165 return UREG(REG_TYPE_OC, 0);
166 case 1:
167 p->depth_written = 1;
168 return UREG(REG_TYPE_OD, 0);
169 default:
170 i915_program_error( p, "Bad inst->DstReg.Index" );
171 return 0;
172 }
173 case PROGRAM_TEMPORARY:
174 return UREG(REG_TYPE_R, inst->DstReg.Index);
175 default:
176 i915_program_error( p, "Bad inst->DstReg.File" );
177 return 0;
178 }
179 }
180
181 static GLuint get_result_flags( const struct prog_instruction *inst )
182 {
183 GLuint flags = 0;
184
185 if (inst->Saturate) flags |= A0_DEST_SATURATE;
186 if (inst->DstReg.WriteMask & WRITEMASK_X) flags |= A0_DEST_CHANNEL_X;
187 if (inst->DstReg.WriteMask & WRITEMASK_Y) flags |= A0_DEST_CHANNEL_Y;
188 if (inst->DstReg.WriteMask & WRITEMASK_Z) flags |= A0_DEST_CHANNEL_Z;
189 if (inst->DstReg.WriteMask & WRITEMASK_W) flags |= A0_DEST_CHANNEL_W;
190
191 return flags;
192 }
193
194 static GLuint translate_tex_src_target( struct i915_fragment_program *p,
195 GLubyte bit )
196 {
197 switch (bit) {
198 case TEXTURE_1D_INDEX: return D0_SAMPLE_TYPE_2D;
199 case TEXTURE_2D_INDEX: return D0_SAMPLE_TYPE_2D;
200 case TEXTURE_RECT_INDEX: return D0_SAMPLE_TYPE_2D;
201 case TEXTURE_3D_INDEX: return D0_SAMPLE_TYPE_VOLUME;
202 case TEXTURE_CUBE_INDEX: return D0_SAMPLE_TYPE_CUBE;
203 default: i915_program_error(p, "TexSrcBit"); return 0;
204 }
205 }
206
207 #define EMIT_TEX( OP ) \
208 do { \
209 GLuint dim = translate_tex_src_target( p, inst->TexSrcTarget ); \
210 GLuint sampler = i915_emit_decl(p, REG_TYPE_S, \
211 inst->TexSrcUnit, dim); \
212 GLuint coord = src_vector( p, &inst->SrcReg[0], program); \
213 /* Texel lookup */ \
214 \
215 i915_emit_texld( p, \
216 get_result_vector( p, inst ), \
217 get_result_flags( inst ), \
218 sampler, \
219 coord, \
220 OP); \
221 } while (0)
222
223 #define EMIT_ARITH( OP, N ) \
224 do { \
225 i915_emit_arith( p, \
226 OP, \
227 get_result_vector( p, inst ), \
228 get_result_flags( inst ), 0, \
229 (N<1)?0:src_vector( p, &inst->SrcReg[0], program), \
230 (N<2)?0:src_vector( p, &inst->SrcReg[1], program), \
231 (N<3)?0:src_vector( p, &inst->SrcReg[2], program)); \
232 } while (0)
233
234 #define EMIT_1ARG_ARITH( OP ) EMIT_ARITH( OP, 1 )
235 #define EMIT_2ARG_ARITH( OP ) EMIT_ARITH( OP, 2 )
236 #define EMIT_3ARG_ARITH( OP ) EMIT_ARITH( OP, 3 )
237
238
239 /* Possible concerns:
240 *
241 * SIN, COS -- could use another taylor step?
242 * LIT -- results seem a little different to sw mesa
243 * LOG -- different to mesa on negative numbers, but this is conformant.
244 *
245 * Parse failures -- Mesa doesn't currently give a good indication
246 * internally whether a particular program string parsed or not. This
247 * can lead to confusion -- hopefully we cope with it ok now.
248 *
249 */
250 static void upload_program( struct i915_fragment_program *p )
251 {
252 const struct fragment_program *program = p->ctx->FragmentProgram._Current;
253 const struct prog_instruction *inst = program->Instructions;
254
255 /* _mesa_debug_fp_inst(program->Base.NumInstructions, inst); */
256
257 /* Is this a parse-failed program? Ensure a valid program is
258 * loaded, as the flagging of an error isn't sufficient to stop
259 * this being uploaded to hardware.
260 */
261 if (inst[0].Opcode == OPCODE_END) {
262 GLuint tmp = i915_get_utemp( p );
263 i915_emit_arith( p,
264 A0_MOV,
265 UREG(REG_TYPE_OC, 0),
266 A0_DEST_CHANNEL_ALL, 0,
267 swizzle(tmp,ONE,ZERO,ONE,ONE), 0, 0);
268 return;
269 }
270
271 while (1) {
272 GLuint src0, src1, src2, flags;
273 GLuint tmp = 0;
274
275 switch (inst->Opcode) {
276 case OPCODE_ABS:
277 src0 = src_vector( p, &inst->SrcReg[0], program);
278 i915_emit_arith( p,
279 A0_MAX,
280 get_result_vector( p, inst ),
281 get_result_flags( inst ), 0,
282 src0, negate(src0, 1,1,1,1), 0);
283 break;
284
285 case OPCODE_ADD:
286 EMIT_2ARG_ARITH( A0_ADD );
287 break;
288
289 case OPCODE_CMP:
290 src0 = src_vector( p, &inst->SrcReg[0], program);
291 src1 = src_vector( p, &inst->SrcReg[1], program);
292 src2 = src_vector( p, &inst->SrcReg[2], program);
293 i915_emit_arith( p,
294 A0_CMP,
295 get_result_vector( p, inst ),
296 get_result_flags( inst ), 0,
297 src0, src2, src1); /* NOTE: order of src2, src1 */
298 break;
299
300 case OPCODE_COS:
301 src0 = src_vector( p, &inst->SrcReg[0], program);
302 tmp = i915_get_utemp( p );
303
304 i915_emit_arith( p,
305 A0_MUL,
306 tmp, A0_DEST_CHANNEL_X, 0,
307 src0,
308 i915_emit_const1f(p, 1.0/(PI * 2)),
309 0);
310
311 i915_emit_arith( p,
312 A0_MOD,
313 tmp, A0_DEST_CHANNEL_X, 0,
314 tmp,
315 0, 0 );
316
317 /* By choosing different taylor constants, could get rid of this mul:
318 */
319 i915_emit_arith( p,
320 A0_MUL,
321 tmp, A0_DEST_CHANNEL_X, 0,
322 tmp,
323 i915_emit_const1f(p, (PI * 2)),
324 0);
325
326 /*
327 * t0.xy = MUL x.xx11, x.x1111 ; x^2, x, 1, 1
328 * t0 = MUL t0.xyxy t0.xx11 ; x^4, x^3, x^2, 1
329 * t0 = MUL t0.xxz1 t0.z111 ; x^6 x^4 x^2 1
330 * result = DP4 t0, cos_constants
331 */
332 i915_emit_arith( p,
333 A0_MUL,
334 tmp, A0_DEST_CHANNEL_XY, 0,
335 swizzle(tmp, X,X,ONE,ONE),
336 swizzle(tmp, X,ONE,ONE,ONE), 0);
337
338 i915_emit_arith( p,
339 A0_MUL,
340 tmp, A0_DEST_CHANNEL_XYZ, 0,
341 swizzle(tmp, X,Y,X,ONE),
342 swizzle(tmp, X,X,ONE,ONE), 0);
343
344 i915_emit_arith( p,
345 A0_MUL,
346 tmp, A0_DEST_CHANNEL_XYZ, 0,
347 swizzle(tmp, X,X,Z,ONE),
348 swizzle(tmp, Z,ONE,ONE,ONE), 0);
349
350 i915_emit_arith( p,
351 A0_DP4,
352 get_result_vector( p, inst ),
353 get_result_flags( inst ), 0,
354 swizzle(tmp, ONE,Z,Y,X),
355 i915_emit_const4fv( p, cos_constants ), 0);
356
357 break;
358
359 case OPCODE_DP3:
360 EMIT_2ARG_ARITH( A0_DP3 );
361 break;
362
363 case OPCODE_DP4:
364 EMIT_2ARG_ARITH( A0_DP4 );
365 break;
366
367 case OPCODE_DPH:
368 src0 = src_vector( p, &inst->SrcReg[0], program);
369 src1 = src_vector( p, &inst->SrcReg[1], program);
370
371 i915_emit_arith( p,
372 A0_DP4,
373 get_result_vector( p, inst ),
374 get_result_flags( inst ), 0,
375 swizzle(src0, X,Y,Z,ONE), src1, 0);
376 break;
377
378 case OPCODE_DST:
379 src0 = src_vector( p, &inst->SrcReg[0], program);
380 src1 = src_vector( p, &inst->SrcReg[1], program);
381
382 /* result[0] = 1 * 1;
383 * result[1] = a[1] * b[1];
384 * result[2] = a[2] * 1;
385 * result[3] = 1 * b[3];
386 */
387 i915_emit_arith( p,
388 A0_MUL,
389 get_result_vector( p, inst ),
390 get_result_flags( inst ), 0,
391 swizzle(src0, ONE, Y, Z, ONE),
392 swizzle(src1, ONE, Y, ONE, W ),
393 0);
394 break;
395
396 case OPCODE_EX2:
397 src0 = src_vector( p, &inst->SrcReg[0], program);
398
399 i915_emit_arith( p,
400 A0_EXP,
401 get_result_vector( p, inst ),
402 get_result_flags( inst ), 0,
403 swizzle(src0,X,X,X,X), 0, 0);
404 break;
405
406 case OPCODE_FLR:
407 EMIT_1ARG_ARITH( A0_FLR );
408 break;
409
410 case OPCODE_FRC:
411 EMIT_1ARG_ARITH( A0_FRC );
412 break;
413
414 case OPCODE_KIL:
415 src0 = src_vector( p, &inst->SrcReg[0], program);
416 tmp = i915_get_utemp( p );
417
418 i915_emit_texld( p,
419 tmp, A0_DEST_CHANNEL_ALL, /* use a dummy dest reg */
420 0,
421 src0,
422 T0_TEXKILL );
423 break;
424
425 case OPCODE_LG2:
426 src0 = src_vector( p, &inst->SrcReg[0], program);
427
428 i915_emit_arith( p,
429 A0_LOG,
430 get_result_vector( p, inst ),
431 get_result_flags( inst ), 0,
432 swizzle(src0,X,X,X,X), 0, 0);
433 break;
434
435 case OPCODE_LIT:
436 src0 = src_vector( p, &inst->SrcReg[0], program);
437 tmp = i915_get_utemp( p );
438
439 /* tmp = max( a.xyzw, a.00zw )
440 * XXX: Clamp tmp.w to -128..128
441 * tmp.y = log(tmp.y)
442 * tmp.y = tmp.w * tmp.y
443 * tmp.y = exp(tmp.y)
444 * result = cmp (a.11-x1, a.1x01, a.1xy1 )
445 */
446 i915_emit_arith( p, A0_MAX, tmp, A0_DEST_CHANNEL_ALL, 0,
447 src0, swizzle(src0, ZERO, ZERO, Z, W), 0 );
448
449 i915_emit_arith( p, A0_LOG, tmp, A0_DEST_CHANNEL_Y, 0,
450 swizzle(tmp, Y, Y, Y, Y), 0, 0 );
451
452 i915_emit_arith( p, A0_MUL, tmp, A0_DEST_CHANNEL_Y, 0,
453 swizzle(tmp, ZERO, Y, ZERO, ZERO),
454 swizzle(tmp, ZERO, W, ZERO, ZERO), 0 );
455
456 i915_emit_arith( p, A0_EXP, tmp, A0_DEST_CHANNEL_Y, 0,
457 swizzle(tmp, Y, Y, Y, Y), 0, 0 );
458
459 i915_emit_arith( p, A0_CMP,
460 get_result_vector( p, inst ),
461 get_result_flags( inst ), 0,
462 negate(swizzle(tmp, ONE, ONE, X, ONE),0,0,1,0),
463 swizzle(tmp, ONE, X, ZERO, ONE),
464 swizzle(tmp, ONE, X, Y, ONE));
465
466 break;
467
468 case OPCODE_LRP:
469 src0 = src_vector( p, &inst->SrcReg[0], program);
470 src1 = src_vector( p, &inst->SrcReg[1], program);
471 src2 = src_vector( p, &inst->SrcReg[2], program);
472 flags = get_result_flags( inst );
473 tmp = i915_get_utemp( p );
474
475 /* b*a + c*(1-a)
476 *
477 * b*a + c - ca
478 *
479 * tmp = b*a + c,
480 * result = (-c)*a + tmp
481 */
482 i915_emit_arith( p, A0_MAD, tmp,
483 flags & A0_DEST_CHANNEL_ALL, 0,
484 src1, src0, src2 );
485
486 i915_emit_arith( p, A0_MAD,
487 get_result_vector( p, inst ),
488 flags, 0,
489 negate(src2, 1,1,1,1), src0, tmp );
490 break;
491
492 case OPCODE_MAD:
493 EMIT_3ARG_ARITH( A0_MAD );
494 break;
495
496 case OPCODE_MAX:
497 EMIT_2ARG_ARITH( A0_MAX );
498 break;
499
500 case OPCODE_MIN:
501 src0 = src_vector( p, &inst->SrcReg[0], program);
502 src1 = src_vector( p, &inst->SrcReg[1], program);
503 tmp = i915_get_utemp( p );
504 flags = get_result_flags( inst );
505
506 i915_emit_arith( p,
507 A0_MAX,
508 tmp, flags & A0_DEST_CHANNEL_ALL, 0,
509 negate(src0,1,1,1,1),
510 negate(src1,1,1,1,1), 0);
511
512 i915_emit_arith( p,
513 A0_MOV,
514 get_result_vector( p, inst ),
515 flags, 0,
516 negate(tmp, 1,1,1,1), 0, 0);
517 break;
518
519 case OPCODE_MOV:
520 EMIT_1ARG_ARITH( A0_MOV );
521 break;
522
523 case OPCODE_MUL:
524 EMIT_2ARG_ARITH( A0_MUL );
525 break;
526
527 case OPCODE_POW:
528 src0 = src_vector( p, &inst->SrcReg[0], program);
529 src1 = src_vector( p, &inst->SrcReg[1], program);
530 tmp = i915_get_utemp( p );
531 flags = get_result_flags( inst );
532
533 /* XXX: masking on intermediate values, here and elsewhere.
534 */
535 i915_emit_arith( p,
536 A0_LOG,
537 tmp, A0_DEST_CHANNEL_X, 0,
538 swizzle(src0,X,X,X,X), 0, 0);
539
540 i915_emit_arith( p,
541 A0_MUL,
542 tmp, A0_DEST_CHANNEL_X, 0,
543 tmp, src1, 0);
544
545
546 i915_emit_arith( p,
547 A0_EXP,
548 get_result_vector( p, inst ),
549 flags, 0,
550 swizzle(tmp,X,X,X,X), 0, 0);
551
552 break;
553
554 case OPCODE_RCP:
555 src0 = src_vector( p, &inst->SrcReg[0], program);
556
557 i915_emit_arith( p,
558 A0_RCP,
559 get_result_vector( p, inst ),
560 get_result_flags( inst ), 0,
561 swizzle(src0,X,X,X,X), 0, 0);
562 break;
563
564 case OPCODE_RSQ:
565
566 src0 = src_vector( p, &inst->SrcReg[0], program);
567
568 i915_emit_arith( p,
569 A0_RSQ,
570 get_result_vector( p, inst ),
571 get_result_flags( inst ), 0,
572 swizzle(src0,X,X,X,X), 0, 0);
573 break;
574
575 case OPCODE_SCS:
576 src0 = src_vector( p, &inst->SrcReg[0], program);
577 tmp = i915_get_utemp( p );
578
579 /*
580 * t0.xy = MUL x.xx11, x.x1111 ; x^2, x, 1, 1
581 * t0 = MUL t0.xyxy t0.xx11 ; x^4, x^3, x^2, x
582 * t1 = MUL t0.xyyw t0.yz11 ; x^7 x^5 x^3 x
583 * scs.x = DP4 t1, sin_constants
584 * t1 = MUL t0.xxz1 t0.z111 ; x^6 x^4 x^2 1
585 * scs.y = DP4 t1, cos_constants
586 */
587 i915_emit_arith( p,
588 A0_MUL,
589 tmp, A0_DEST_CHANNEL_XY, 0,
590 swizzle(src0, X,X,ONE,ONE),
591 swizzle(src0, X,ONE,ONE,ONE), 0);
592
593 i915_emit_arith( p,
594 A0_MUL,
595 tmp, A0_DEST_CHANNEL_ALL, 0,
596 swizzle(tmp, X,Y,X,Y),
597 swizzle(tmp, X,X,ONE,ONE), 0);
598
599 if (inst->DstReg.WriteMask & WRITEMASK_Y) {
600 GLuint tmp1;
601
602 if (inst->DstReg.WriteMask & WRITEMASK_X)
603 tmp1 = i915_get_utemp( p );
604 else
605 tmp1 = tmp;
606
607 i915_emit_arith( p,
608 A0_MUL,
609 tmp1, A0_DEST_CHANNEL_ALL, 0,
610 swizzle(tmp, X,Y,Y,W),
611 swizzle(tmp, X,Z,ONE,ONE), 0);
612
613 i915_emit_arith( p,
614 A0_DP4,
615 get_result_vector( p, inst ),
616 A0_DEST_CHANNEL_Y, 0,
617 swizzle(tmp1, W,Z,Y,X),
618 i915_emit_const4fv( p, sin_constants ), 0);
619 }
620
621 if (inst->DstReg.WriteMask & WRITEMASK_X) {
622 i915_emit_arith( p,
623 A0_MUL,
624 tmp, A0_DEST_CHANNEL_XYZ, 0,
625 swizzle(tmp, X,X,Z,ONE),
626 swizzle(tmp, Z,ONE,ONE,ONE), 0);
627
628 i915_emit_arith( p,
629 A0_DP4,
630 get_result_vector( p, inst ),
631 A0_DEST_CHANNEL_X, 0,
632 swizzle(tmp, ONE,Z,Y,X),
633 i915_emit_const4fv( p, cos_constants ), 0);
634 }
635 break;
636
637 case OPCODE_SGE:
638 EMIT_2ARG_ARITH( A0_SGE );
639 break;
640
641 case OPCODE_SIN:
642 src0 = src_vector( p, &inst->SrcReg[0], program);
643 tmp = i915_get_utemp( p );
644
645 i915_emit_arith( p,
646 A0_MUL,
647 tmp, A0_DEST_CHANNEL_X, 0,
648 src0,
649 i915_emit_const1f(p, 1.0/(PI * 2)),
650 0);
651
652 i915_emit_arith( p,
653 A0_MOD,
654 tmp, A0_DEST_CHANNEL_X, 0,
655 tmp,
656 0, 0 );
657
658 /* By choosing different taylor constants, could get rid of this mul:
659 */
660 i915_emit_arith( p,
661 A0_MUL,
662 tmp, A0_DEST_CHANNEL_X, 0,
663 tmp,
664 i915_emit_const1f(p, (PI * 2)),
665 0);
666
667 /*
668 * t0.xy = MUL x.xx11, x.x1111 ; x^2, x, 1, 1
669 * t0 = MUL t0.xyxy t0.xx11 ; x^4, x^3, x^2, x
670 * t1 = MUL t0.xyyw t0.yz11 ; x^7 x^5 x^3 x
671 * result = DP4 t1.wzyx, sin_constants
672 */
673 i915_emit_arith( p,
674 A0_MUL,
675 tmp, A0_DEST_CHANNEL_XY, 0,
676 swizzle(tmp, X,X,ONE,ONE),
677 swizzle(tmp, X,ONE,ONE,ONE), 0);
678
679 i915_emit_arith( p,
680 A0_MUL,
681 tmp, A0_DEST_CHANNEL_ALL, 0,
682 swizzle(tmp, X,Y,X,Y),
683 swizzle(tmp, X,X,ONE,ONE), 0);
684
685 i915_emit_arith( p,
686 A0_MUL,
687 tmp, A0_DEST_CHANNEL_ALL, 0,
688 swizzle(tmp, X,Y,Y,W),
689 swizzle(tmp, X,Z,ONE,ONE), 0);
690
691 i915_emit_arith( p,
692 A0_DP4,
693 get_result_vector( p, inst ),
694 get_result_flags( inst ), 0,
695 swizzle(tmp, W, Z, Y, X ),
696 i915_emit_const4fv( p, sin_constants ), 0);
697 break;
698
699 case OPCODE_SLT:
700 EMIT_2ARG_ARITH( A0_SLT );
701 break;
702
703 case OPCODE_SUB:
704 src0 = src_vector( p, &inst->SrcReg[0], program);
705 src1 = src_vector( p, &inst->SrcReg[1], program);
706
707 i915_emit_arith( p,
708 A0_ADD,
709 get_result_vector( p, inst ),
710 get_result_flags( inst ), 0,
711 src0, negate(src1, 1,1,1,1), 0);
712 break;
713
714 case OPCODE_SWZ:
715 EMIT_1ARG_ARITH( A0_MOV ); /* extended swizzle handled natively */
716 break;
717
718 case OPCODE_TEX:
719 EMIT_TEX( T0_TEXLD );
720 break;
721
722 case OPCODE_TXB:
723 EMIT_TEX( T0_TEXLDB );
724 break;
725
726 case OPCODE_TXP:
727 EMIT_TEX( T0_TEXLDP );
728 break;
729
730 case OPCODE_XPD:
731 /* Cross product:
732 * result.x = src0.y * src1.z - src0.z * src1.y;
733 * result.y = src0.z * src1.x - src0.x * src1.z;
734 * result.z = src0.x * src1.y - src0.y * src1.x;
735 * result.w = undef;
736 */
737 src0 = src_vector( p, &inst->SrcReg[0], program);
738 src1 = src_vector( p, &inst->SrcReg[1], program);
739 tmp = i915_get_utemp( p );
740
741 i915_emit_arith( p,
742 A0_MUL,
743 tmp, A0_DEST_CHANNEL_ALL, 0,
744 swizzle(src0,Z,X,Y,ONE),
745 swizzle(src1,Y,Z,X,ONE), 0);
746
747 i915_emit_arith( p,
748 A0_MAD,
749 get_result_vector( p, inst ),
750 get_result_flags( inst ), 0,
751 swizzle(src0,Y,Z,X,ONE),
752 swizzle(src1,Z,X,Y,ONE),
753 negate(tmp,1,1,1,0));
754 break;
755
756 case OPCODE_END:
757 return;
758
759 default:
760 i915_program_error( p, "bad opcode" );
761 return;
762 }
763
764 inst++;
765 i915_release_utemps( p );
766 }
767 }
768
769 /* Rather than trying to intercept and jiggle depth writes during
770 * emit, just move the value into its correct position at the end of
771 * the program:
772 */
773 static void fixup_depth_write( struct i915_fragment_program *p )
774 {
775 if (p->depth_written) {
776 GLuint depth = UREG(REG_TYPE_OD, 0);
777
778 i915_emit_arith( p,
779 A0_MOV,
780 depth, A0_DEST_CHANNEL_W, 0,
781 swizzle(depth,X,Y,Z,Z),
782 0, 0);
783 }
784 }
785
786
787 #define FRAG_BIT_TEX(n) (FRAG_BIT_TEX0 << (n))
788
789
790 static void check_wpos( struct i915_fragment_program *p )
791 {
792 GLuint inputs = p->FragProg.InputsRead;
793 GLint i;
794
795 p->wpos_tex = -1;
796
797 for (i = 0; i < p->ctx->Const.MaxTextureCoordUnits; i++) {
798 if (inputs & FRAG_BIT_TEX(i))
799 continue;
800 else if (inputs & FRAG_BIT_WPOS) {
801 p->wpos_tex = i;
802 inputs &= ~FRAG_BIT_WPOS;
803 }
804 }
805
806 if (inputs & FRAG_BIT_WPOS) {
807 i915_program_error(p, "No free texcoord for wpos value");
808 }
809 }
810
811
812 static void translate_program( struct i915_fragment_program *p )
813 {
814 i915ContextPtr i915 = I915_CONTEXT(p->ctx);
815
816 i915_init_program( i915, p );
817 check_wpos( p );
818 upload_program( p );
819 fixup_depth_write( p );
820 i915_fini_program( p );
821
822 p->translated = 1;
823 }
824
825
826 static void track_params( struct i915_fragment_program *p )
827 {
828 GLint i;
829
830 if (p->nr_params)
831 _mesa_load_state_parameters(p->ctx, p->FragProg.Parameters);
832
833 for (i = 0; i < p->nr_params; i++) {
834 GLint reg = p->param[i].reg;
835 COPY_4V( p->constant[reg], p->param[i].values );
836 }
837
838 p->params_uptodate = 1;
839 p->on_hardware = 0; /* overkill */
840 }
841
842
843 static void i915BindProgram( GLcontext *ctx,
844 GLenum target,
845 struct program *prog )
846 {
847 if (target == GL_FRAGMENT_PROGRAM_ARB) {
848 i915ContextPtr i915 = I915_CONTEXT(ctx);
849 struct i915_fragment_program *p = (struct i915_fragment_program *)prog;
850
851 if (i915->current_program == p)
852 return;
853
854 if (i915->current_program) {
855 i915->current_program->on_hardware = 0;
856 i915->current_program->params_uptodate = 0;
857 }
858
859 i915->current_program = p;
860
861 assert(p->on_hardware == 0);
862 assert(p->params_uptodate == 0);
863
864 /* Hack: make sure fog is correctly enabled according to this
865 * fragment program's fog options.
866 */
867 ctx->Driver.Enable( ctx, GL_FRAGMENT_PROGRAM_ARB,
868 ctx->FragmentProgram.Enabled );
869 }
870 }
871
872 static struct program *i915NewProgram( GLcontext *ctx,
873 GLenum target,
874 GLuint id )
875 {
876 switch (target) {
877 case GL_VERTEX_PROGRAM_ARB:
878 return _mesa_init_vertex_program( ctx, CALLOC_STRUCT(vertex_program),
879 target, id );
880
881 case GL_FRAGMENT_PROGRAM_ARB: {
882 struct i915_fragment_program *prog = CALLOC_STRUCT(i915_fragment_program);
883 if (prog) {
884 i915_init_program( I915_CONTEXT(ctx), prog );
885
886 return _mesa_init_fragment_program( ctx, &prog->FragProg,
887 target, id );
888 }
889 else
890 return NULL;
891 }
892
893 default:
894 /* Just fallback:
895 */
896 return _mesa_new_program( ctx, target, id );
897 }
898 }
899
900 static void i915DeleteProgram( GLcontext *ctx,
901 struct program *prog )
902 {
903 if (prog->Target == GL_FRAGMENT_PROGRAM_ARB) {
904 i915ContextPtr i915 = I915_CONTEXT(ctx);
905 struct i915_fragment_program *p = (struct i915_fragment_program *)prog;
906
907 if (i915->current_program == p)
908 i915->current_program = 0;
909 }
910
911 _mesa_delete_program( ctx, prog );
912 }
913
914
915 static GLboolean i915IsProgramNative( GLcontext *ctx,
916 GLenum target,
917 struct program *prog )
918 {
919 if (target == GL_FRAGMENT_PROGRAM_ARB) {
920 struct i915_fragment_program *p = (struct i915_fragment_program *)prog;
921
922 if (!p->translated)
923 translate_program( p );
924
925 return !p->error;
926 }
927 else
928 return GL_TRUE;
929 }
930
931 static void i915ProgramStringNotify( GLcontext *ctx,
932 GLenum target,
933 struct program *prog )
934 {
935 if (target == GL_FRAGMENT_PROGRAM_ARB) {
936 struct i915_fragment_program *p = (struct i915_fragment_program *)prog;
937 p->translated = 0;
938
939 /* Hack: make sure fog is correctly enabled according to this
940 * fragment program's fog options.
941 */
942 ctx->Driver.Enable( ctx, GL_FRAGMENT_PROGRAM_ARB,
943 ctx->FragmentProgram.Enabled );
944 }
945 }
946
947
948 void i915ValidateFragmentProgram( i915ContextPtr i915 )
949 {
950 GLcontext *ctx = &i915->intel.ctx;
951 intelContextPtr intel = INTEL_CONTEXT(ctx);
952 TNLcontext *tnl = TNL_CONTEXT(ctx);
953 struct vertex_buffer *VB = &tnl->vb;
954
955 struct i915_fragment_program *p =
956 (struct i915_fragment_program *)ctx->FragmentProgram._Current;
957
958 GLuint inputsRead = p->FragProg.InputsRead;
959 GLuint s4 = i915->state.Ctx[I915_CTXREG_LIS4] & ~S4_VFMT_MASK;
960 GLuint s2 = S2_TEXCOORD_NONE;
961 int i, offset = 0;
962
963 /* Important:
964 */
965 VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
966
967 if (!p->translated)
968 translate_program( p );
969
970 intel->vertex_attr_count = 0;
971 intel->wpos_offset = 0;
972 intel->wpos_size = 0;
973 intel->coloroffset = 0;
974 intel->specoffset = 0;
975
976 if (inputsRead & FRAG_BITS_TEX_ANY) {
977 EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, S4_VFMT_XYZW, 16 );
978 }
979 else {
980 EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT, S4_VFMT_XYZ, 12 );
981 }
982
983 if (inputsRead & FRAG_BIT_COL0) {
984 intel->coloroffset = offset / 4;
985 EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_BGRA, S4_VFMT_COLOR, 4 );
986 }
987
988 if ((inputsRead & (FRAG_BIT_COL1|FRAG_BIT_FOGC)) ||
989 i915->vertex_fog != I915_FOG_NONE) {
990
991 if (inputsRead & FRAG_BIT_COL1) {
992 intel->specoffset = offset / 4;
993 EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, S4_VFMT_SPEC_FOG, 3 );
994 }
995 else
996 EMIT_PAD(3);
997
998 if ((inputsRead & FRAG_BIT_FOGC) || i915->vertex_fog != I915_FOG_NONE)
999 EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, S4_VFMT_SPEC_FOG, 1 );
1000 else
1001 EMIT_PAD( 1 );
1002 }
1003
1004 #if 0
1005 if ((inputsRead & FRAG_BIT_FOGC) || i915->vertex_fog != I915_FOG_NONE) {
1006 EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1F, S4_VFMT_FOG_PARAM, 4 );
1007 }
1008 #endif
1009
1010 for (i = 0; i < p->ctx->Const.MaxTextureCoordUnits; i++) {
1011 if (inputsRead & FRAG_BIT_TEX(i)) {
1012 int sz = VB->TexCoordPtr[i]->size;
1013
1014 s2 &= ~S2_TEXCOORD_FMT(i, S2_TEXCOORD_FMT0_MASK);
1015 s2 |= S2_TEXCOORD_FMT(i, SZ_TO_HW(sz));
1016
1017 EMIT_ATTR( _TNL_ATTRIB_TEX0+i, EMIT_SZ(sz), 0, sz * 4 );
1018 }
1019 else if (i == p->wpos_tex) {
1020
1021 /* If WPOS is required, duplicate the XYZ position data in an
1022 * unused texture coordinate:
1023 */
1024 s2 &= ~S2_TEXCOORD_FMT(i, S2_TEXCOORD_FMT0_MASK);
1025 s2 |= S2_TEXCOORD_FMT(i, SZ_TO_HW(3));
1026
1027 intel->wpos_offset = offset;
1028 intel->wpos_size = 3 * sizeof(GLuint);
1029
1030 EMIT_PAD( intel->wpos_size );
1031 }
1032 }
1033
1034 if (s2 != i915->state.Ctx[I915_CTXREG_LIS2] ||
1035 s4 != i915->state.Ctx[I915_CTXREG_LIS4]) {
1036
1037 I915_STATECHANGE( i915, I915_UPLOAD_CTX );
1038
1039 /* Must do this *after* statechange, so as not to affect
1040 * buffered vertices reliant on the old state:
1041 */
1042 intel->vertex_size = _tnl_install_attrs( &intel->ctx,
1043 intel->vertex_attrs,
1044 intel->vertex_attr_count,
1045 intel->ViewportMatrix.m, 0 );
1046
1047 intel->vertex_size >>= 2;
1048
1049 i915->state.Ctx[I915_CTXREG_LIS2] = s2;
1050 i915->state.Ctx[I915_CTXREG_LIS4] = s4;
1051
1052 assert(intel->vtbl.check_vertex_size( intel, intel->vertex_size ));
1053 }
1054
1055 if (!p->params_uptodate)
1056 track_params( p );
1057
1058 if (!p->on_hardware)
1059 i915_upload_program( i915, p );
1060 }
1061
1062 void i915InitFragProgFuncs( struct dd_function_table *functions )
1063 {
1064 functions->BindProgram = i915BindProgram;
1065 functions->NewProgram = i915NewProgram;
1066 functions->DeleteProgram = i915DeleteProgram;
1067 functions->IsProgramNative = i915IsProgramNative;
1068 functions->ProgramStringNotify = i915ProgramStringNotify;
1069 }