1/**********************************************************
2 * Copyright 2008-2009 VMware, Inc.  All rights reserved.
3 *
4 * Permission is hereby granted, free of charge, to any person
5 * obtaining a copy of this software and associated documentation
6 * files (the "Software"), to deal in the Software without
7 * restriction, including without limitation the rights to use, copy,
8 * modify, merge, publish, distribute, sublicense, and/or sell copies
9 * of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 *
24 **********************************************************/
25
26
27#include "pipe/p_shader_tokens.h"
28#include "tgsi/tgsi_parse.h"
29#include "util/u_memory.h"
30
31#include "svga_tgsi_emit.h"
32
33
34/**
35 * Translate TGSI semantic info into SVGA3d semantic info.
36 * This is called for VS outputs and PS inputs only.
37 */
38static boolean
39translate_vs_ps_semantic(struct svga_shader_emitter *emit,
40                         struct tgsi_declaration_semantic semantic,
41                         unsigned *usage,
42                         unsigned *idx)
43{
44   switch (semantic.Name) {
45   case TGSI_SEMANTIC_POSITION:
46      *idx = semantic.Index;
47      *usage = SVGA3D_DECLUSAGE_POSITION;
48      break;
49   case TGSI_SEMANTIC_COLOR:
50      *idx = semantic.Index;
51      *usage = SVGA3D_DECLUSAGE_COLOR;
52      break;
53   case TGSI_SEMANTIC_BCOLOR:
54      *idx = semantic.Index + 2; /* sharing with COLOR */
55      *usage = SVGA3D_DECLUSAGE_COLOR;
56      break;
57   case TGSI_SEMANTIC_FOG:
58      *idx = 0;
59      assert(semantic.Index == 0);
60      *usage = SVGA3D_DECLUSAGE_TEXCOORD;
61      break;
62   case TGSI_SEMANTIC_PSIZE:
63      *idx = semantic.Index;
64      *usage = SVGA3D_DECLUSAGE_PSIZE;
65      break;
66   case TGSI_SEMANTIC_GENERIC:
67      *idx = svga_remap_generic_index(emit->key.generic_remap_table,
68                                      semantic.Index);
69      *usage = SVGA3D_DECLUSAGE_TEXCOORD;
70      break;
71   case TGSI_SEMANTIC_NORMAL:
72      *idx = semantic.Index;
73      *usage = SVGA3D_DECLUSAGE_NORMAL;
74      break;
75   case TGSI_SEMANTIC_CLIPDIST:
76   case TGSI_SEMANTIC_CLIPVERTEX:
77      /* XXX at this time we don't support clip distance or clip vertices */
78      debug_warn_once("unsupported clip distance/vertex attribute\n");
79      *usage = SVGA3D_DECLUSAGE_TEXCOORD;
80      *idx = 0;
81      return TRUE;
82   default:
83      assert(0);
84      *usage = SVGA3D_DECLUSAGE_TEXCOORD;
85      *idx = 0;
86      return FALSE;
87   }
88
89   return TRUE;
90}
91
92
93/**
94 * Emit a PS input (or VS depth/fog output) register declaration.
95 * For example, if usage = SVGA3D_DECLUSAGE_TEXCOORD, reg.num = 1, and
96 * index = 3, we'll emit "dcl_texcoord3 v1".
97 */
98static boolean
99emit_decl(struct svga_shader_emitter *emit,
100          SVGA3dShaderDestToken reg,
101          unsigned usage,
102          unsigned index)
103{
104   SVGA3DOpDclArgs dcl;
105   SVGA3dShaderInstToken opcode;
106
107   /* check values against bitfield sizes */
108   assert(index < 16);
109   assert(usage <= SVGA3D_DECLUSAGE_MAX);
110
111   opcode = inst_token( SVGA3DOP_DCL );
112   dcl.values[0] = 0;
113   dcl.values[1] = 0;
114
115   dcl.dst = reg;
116   dcl.usage = usage;
117   dcl.index = index;
118   dcl.values[0] |= 1<<31;
119
120   return (emit_instruction(emit, opcode) &&
121           svga_shader_emit_dwords( emit, dcl.values, ARRAY_SIZE(dcl.values)));
122}
123
124
125/**
126 * Emit declaration for PS front/back-face input register.
127 */
128static boolean
129emit_vface_decl(struct svga_shader_emitter *emit)
130{
131   if (!emit->emitted_vface) {
132      SVGA3dShaderDestToken reg =
133         dst_register(SVGA3DREG_MISCTYPE, SVGA3DMISCREG_FACE);
134
135      if (!emit_decl( emit, reg, 0, 0 ))
136         return FALSE;
137
138      emit->emitted_vface = TRUE;
139   }
140   return TRUE;
141}
142
143
144/**
145 * Emit PS input register to pass depth/fog coordinates.
146 * Note that this always goes into texcoord[0].
147 */
148static boolean
149ps30_input_emit_depth_fog( struct svga_shader_emitter *emit,
150                           struct src_register *out )
151{
152   struct src_register reg;
153
154   if (emit->emitted_depth_fog) {
155      *out = emit->ps_depth_fog;
156      return TRUE;
157   }
158
159   if (emit->ps30_input_count >= SVGA3D_INPUTREG_MAX)
160      return FALSE;
161
162   reg = src_register( SVGA3DREG_INPUT,
163                       emit->ps30_input_count++ );
164
165   *out = emit->ps_depth_fog = reg;
166
167   emit->emitted_depth_fog = TRUE;
168
169   return emit_decl( emit, dst( reg ), SVGA3D_DECLUSAGE_TEXCOORD, 0 );
170}
171
172
173/**
174 * Process a PS input declaration.
175 * We'll emit a declaration like "dcl_texcoord1 v2"
176 */
177static boolean
178ps30_input(struct svga_shader_emitter *emit,
179           struct tgsi_declaration_semantic semantic,
180           unsigned idx)
181{
182   unsigned usage, index;
183   SVGA3dShaderDestToken reg;
184
185   if (semantic.Name == TGSI_SEMANTIC_POSITION) {
186
187      emit->ps_true_pos = src_register( SVGA3DREG_MISCTYPE,
188                                        SVGA3DMISCREG_POSITION );
189      emit->ps_true_pos.base.swizzle = TRANSLATE_SWIZZLE( TGSI_SWIZZLE_X,
190                                                          TGSI_SWIZZLE_Y,
191                                                          TGSI_SWIZZLE_Y,
192                                                          TGSI_SWIZZLE_Y );
193      reg = writemask( dst(emit->ps_true_pos),
194                       TGSI_WRITEMASK_XY );
195      emit->ps_reads_pos = TRUE;
196
197      if (emit->info.reads_z) {
198         emit->ps_temp_pos = dst_register( SVGA3DREG_TEMP,
199                                           emit->nr_hw_temp );
200
201         emit->input_map[idx] = src_register( SVGA3DREG_TEMP,
202                                              emit->nr_hw_temp );
203         emit->nr_hw_temp++;
204
205         if (!ps30_input_emit_depth_fog( emit, &emit->ps_depth_pos ))
206            return FALSE;
207
208         emit->ps_depth_pos.base.swizzle = TRANSLATE_SWIZZLE( TGSI_SWIZZLE_Z,
209                                                              TGSI_SWIZZLE_Z,
210                                                              TGSI_SWIZZLE_Z,
211                                                              TGSI_SWIZZLE_W );
212      }
213      else {
214         emit->input_map[idx] = emit->ps_true_pos;
215      }
216
217      return emit_decl( emit, reg, 0, 0 );
218   }
219   else if (emit->key.fs.light_twoside &&
220            (semantic.Name == TGSI_SEMANTIC_COLOR)) {
221
222      if (!translate_vs_ps_semantic( emit, semantic, &usage, &index ))
223         return FALSE;
224
225      emit->internal_color_idx[emit->internal_color_count] = idx;
226      emit->input_map[idx] = src_register( SVGA3DREG_INPUT, emit->ps30_input_count );
227      emit->ps30_input_count++;
228      emit->internal_color_count++;
229
230      reg = dst( emit->input_map[idx] );
231
232      if (!emit_decl( emit, reg, usage, index ))
233         return FALSE;
234
235      semantic.Name = TGSI_SEMANTIC_BCOLOR;
236      if (!translate_vs_ps_semantic( emit, semantic, &usage, &index ))
237         return FALSE;
238
239      if (emit->ps30_input_count >= SVGA3D_INPUTREG_MAX)
240         return FALSE;
241
242      reg = dst_register( SVGA3DREG_INPUT, emit->ps30_input_count++ );
243
244      if (!emit_decl( emit, reg, usage, index ))
245         return FALSE;
246
247      if (!emit_vface_decl( emit ))
248         return FALSE;
249
250      return TRUE;
251   }
252   else if (semantic.Name == TGSI_SEMANTIC_FACE) {
253      if (!emit_vface_decl( emit ))
254         return FALSE;
255      emit->emit_frontface = TRUE;
256      emit->internal_frontface_idx = idx;
257      return TRUE;
258   }
259   else if (semantic.Name == TGSI_SEMANTIC_FOG) {
260
261      assert(semantic.Index == 0);
262
263      if (!ps30_input_emit_depth_fog( emit, &emit->input_map[idx] ))
264         return FALSE;
265
266      emit->input_map[idx].base.swizzle = TRANSLATE_SWIZZLE( TGSI_SWIZZLE_X,
267                                                             TGSI_SWIZZLE_X,
268                                                             TGSI_SWIZZLE_X,
269                                                             TGSI_SWIZZLE_X );
270
271      return TRUE;
272   }
273   else {
274
275      if (!translate_vs_ps_semantic( emit, semantic, &usage, &index ))
276         return FALSE;
277
278      if (emit->ps30_input_count >= SVGA3D_INPUTREG_MAX)
279         return FALSE;
280
281      emit->input_map[idx] = src_register( SVGA3DREG_INPUT, emit->ps30_input_count++ );
282      reg = dst( emit->input_map[idx] );
283
284      if (!emit_decl( emit, reg, usage, index ))
285         return FALSE;
286
287      if (semantic.Name == TGSI_SEMANTIC_GENERIC &&
288          emit->key.sprite_origin_lower_left &&
289          index >= 1 &&
290          emit->key.tex[index - 1].sprite_texgen) {
291         /* This is a sprite texture coord with lower-left origin.
292          * We need to invert the texture T coordinate since the SVGA3D
293          * device only supports an upper-left origin.
294          */
295         unsigned unit = index - 1;
296
297         emit->inverted_texcoords |= (1 << unit);
298
299         /* save original texcoord reg */
300         emit->ps_true_texcoord[unit] = emit->input_map[idx];
301
302         /* this temp register will be the results of the MAD instruction */
303         emit->ps_inverted_texcoord[unit] =
304            src_register(SVGA3DREG_TEMP, emit->nr_hw_temp);
305         emit->nr_hw_temp++;
306
307         emit->ps_inverted_texcoord_input[unit] = idx;
308
309         /* replace input_map entry with the temp register */
310         emit->input_map[idx] = emit->ps_inverted_texcoord[unit];
311      }
312
313      return TRUE;
314   }
315
316}
317
318
319/**
320 * Process a PS output declaration.
321 * Note that we don't actually emit a SVGA3DOpDcl for PS outputs.
322 * \idx  register index, such as OUT[2] (not semantic index)
323 */
324static boolean
325ps30_output(struct svga_shader_emitter *emit,
326            struct tgsi_declaration_semantic semantic,
327            unsigned idx)
328{
329   switch (semantic.Name) {
330   case TGSI_SEMANTIC_COLOR:
331      if (emit->unit == PIPE_SHADER_FRAGMENT) {
332         if (emit->key.fs.white_fragments) {
333            /* Used for XOR logicop mode */
334            emit->output_map[idx] = dst_register( SVGA3DREG_TEMP,
335                                                  emit->nr_hw_temp++ );
336            emit->temp_color_output[idx] = emit->output_map[idx];
337            emit->true_color_output[idx] = dst_register(SVGA3DREG_COLOROUT,
338                                                        semantic.Index);
339         }
340         else if (emit->key.fs.write_color0_to_n_cbufs) {
341            /* We'll write color output [0] to all render targets.
342             * Prepare all the output registers here, but only when the
343             * semantic.Index == 0 so we don't do this more than once.
344             */
345            if (semantic.Index == 0) {
346               unsigned i;
347               for (i = 0; i < emit->key.fs.write_color0_to_n_cbufs; i++) {
348                  emit->output_map[idx+i] = dst_register(SVGA3DREG_TEMP,
349                                                     emit->nr_hw_temp++);
350                  emit->temp_color_output[i] = emit->output_map[idx+i];
351                  emit->true_color_output[i] = dst_register(SVGA3DREG_COLOROUT,
352                                                            i);
353               }
354            }
355         }
356         else {
357            emit->output_map[idx] =
358               dst_register(SVGA3DREG_COLOROUT, semantic.Index);
359         }
360      }
361      else {
362         emit->output_map[idx] = dst_register( SVGA3DREG_COLOROUT,
363                                               semantic.Index );
364      }
365      break;
366   case TGSI_SEMANTIC_POSITION:
367      emit->output_map[idx] = dst_register( SVGA3DREG_TEMP,
368                                            emit->nr_hw_temp++ );
369      emit->temp_pos = emit->output_map[idx];
370      emit->true_pos = dst_register( SVGA3DREG_DEPTHOUT,
371                                     semantic.Index );
372      break;
373   default:
374      assert(0);
375      /* A wild stab in the dark. */
376      emit->output_map[idx] = dst_register( SVGA3DREG_COLOROUT, 0 );
377      break;
378   }
379
380   return TRUE;
381}
382
383
384/**
385 * Declare a VS input register.
386 * We still make up the input semantics the same as in 2.0
387 */
388static boolean
389vs30_input(struct svga_shader_emitter *emit,
390           struct tgsi_declaration_semantic semantic,
391           unsigned idx)
392{
393   SVGA3DOpDclArgs dcl;
394   SVGA3dShaderInstToken opcode;
395   unsigned usage, index;
396
397   opcode = inst_token( SVGA3DOP_DCL );
398   dcl.values[0] = 0;
399   dcl.values[1] = 0;
400
401   emit->input_map[idx] = src_register( SVGA3DREG_INPUT, idx );
402   dcl.dst = dst_register( SVGA3DREG_INPUT, idx );
403
404   assert(dcl.dst.reserved0);
405
406   svga_generate_vdecl_semantics( idx, &usage, &index );
407
408   dcl.usage = usage;
409   dcl.index = index;
410   dcl.values[0] |= 1<<31;
411
412   return (emit_instruction(emit, opcode) &&
413           svga_shader_emit_dwords( emit, dcl.values, ARRAY_SIZE(dcl.values)));
414}
415
416
417/**
418 * Declare VS output for holding depth/fog.
419 */
420static boolean
421vs30_output_emit_depth_fog(struct svga_shader_emitter *emit,
422                           SVGA3dShaderDestToken *out)
423{
424   SVGA3dShaderDestToken reg;
425
426   if (emit->emitted_depth_fog) {
427      *out = emit->vs_depth_fog;
428      return TRUE;
429   }
430
431   reg = dst_register( SVGA3DREG_OUTPUT, emit->vs30_output_count++ );
432
433   *out = emit->vs_depth_fog = reg;
434
435   emit->emitted_depth_fog = TRUE;
436
437   return emit_decl( emit, reg, SVGA3D_DECLUSAGE_TEXCOORD, 0 );
438}
439
440
441/**
442 * Declare a VS output.
443 * VS3.0 outputs have proper declarations and semantic info for
444 * matching against PS inputs.
445 */
446static boolean
447vs30_output(struct svga_shader_emitter *emit,
448            struct tgsi_declaration_semantic semantic,
449            unsigned idx)
450{
451   SVGA3DOpDclArgs dcl;
452   SVGA3dShaderInstToken opcode;
453   unsigned usage, index;
454
455   opcode = inst_token( SVGA3DOP_DCL );
456   dcl.values[0] = 0;
457   dcl.values[1] = 0;
458
459   if (!translate_vs_ps_semantic( emit, semantic, &usage, &index ))
460      return FALSE;
461
462   if (emit->vs30_output_count >= SVGA3D_OUTPUTREG_MAX)
463      return FALSE;
464
465   dcl.dst = dst_register( SVGA3DREG_OUTPUT, emit->vs30_output_count++ );
466   dcl.usage = usage;
467   dcl.index = index;
468   dcl.values[0] |= 1<<31;
469
470   if (semantic.Name == TGSI_SEMANTIC_POSITION) {
471      assert(idx == 0);
472      emit->output_map[idx] = dst_register( SVGA3DREG_TEMP,
473                                            emit->nr_hw_temp++ );
474      emit->temp_pos = emit->output_map[idx];
475      emit->true_pos = dcl.dst;
476
477      /* Grab an extra output for the depth output */
478      if (!vs30_output_emit_depth_fog( emit, &emit->depth_pos ))
479         return FALSE;
480
481   }
482   else if (semantic.Name == TGSI_SEMANTIC_PSIZE) {
483      emit->output_map[idx] = dst_register( SVGA3DREG_TEMP,
484                                            emit->nr_hw_temp++ );
485      emit->temp_psiz = emit->output_map[idx];
486
487      /* This has the effect of not declaring psiz (below) and not
488       * emitting the final MOV to true_psiz in the postamble.
489       */
490      if (!emit->key.vs.allow_psiz)
491         return TRUE;
492
493      emit->true_psiz = dcl.dst;
494   }
495   else if (semantic.Name == TGSI_SEMANTIC_FOG) {
496      /*
497       * Fog is shared with depth.
498       * So we need to decrement out_count since emit_depth_fog will increment it.
499       */
500      emit->vs30_output_count--;
501
502      if (!vs30_output_emit_depth_fog( emit, &emit->output_map[idx] ))
503         return FALSE;
504
505      return TRUE;
506   }
507   else {
508      emit->output_map[idx] = dcl.dst;
509   }
510
511   return (emit_instruction(emit, opcode) &&
512           svga_shader_emit_dwords( emit, dcl.values, ARRAY_SIZE(dcl.values)));
513}
514
515
516/** Translate PIPE_TEXTURE_x to SVGA3DSAMP_x */
517static ubyte
518svga_tgsi_sampler_type(const struct svga_shader_emitter *emit, int idx)
519{
520   switch (emit->sampler_target[idx]) {
521   case TGSI_TEXTURE_1D:
522      return SVGA3DSAMP_2D;
523   case TGSI_TEXTURE_2D:
524   case TGSI_TEXTURE_RECT:
525      return SVGA3DSAMP_2D;
526   case TGSI_TEXTURE_3D:
527      return SVGA3DSAMP_VOLUME;
528   case TGSI_TEXTURE_CUBE:
529      return SVGA3DSAMP_CUBE;
530   }
531
532   return SVGA3DSAMP_UNKNOWN;
533}
534
535
536static boolean
537ps30_sampler( struct svga_shader_emitter *emit,
538              unsigned idx )
539{
540   SVGA3DOpDclArgs dcl;
541   SVGA3dShaderInstToken opcode;
542
543   opcode = inst_token( SVGA3DOP_DCL );
544   dcl.values[0] = 0;
545   dcl.values[1] = 0;
546
547   dcl.dst = dst_register( SVGA3DREG_SAMPLER, idx );
548   dcl.type = svga_tgsi_sampler_type( emit, idx );
549   dcl.values[0] |= 1<<31;
550
551   return (emit_instruction(emit, opcode) &&
552           svga_shader_emit_dwords( emit, dcl.values, ARRAY_SIZE(dcl.values)));
553}
554
555boolean
556svga_shader_emit_samplers_decl( struct svga_shader_emitter *emit )
557{
558   unsigned i;
559
560   for (i = 0; i < emit->num_samplers; i++) {
561      if (!ps30_sampler(emit, i))
562         return FALSE;
563   }
564   return TRUE;
565}
566
567boolean
568svga_translate_decl_sm30( struct svga_shader_emitter *emit,
569                          const struct tgsi_full_declaration *decl )
570{
571   unsigned first = decl->Range.First;
572   unsigned last = decl->Range.Last;
573   unsigned idx;
574
575   for( idx = first; idx <= last; idx++ ) {
576      boolean ok = TRUE;
577
578      switch (decl->Declaration.File) {
579      case TGSI_FILE_SAMPLER:
580         assert (emit->unit == PIPE_SHADER_FRAGMENT);
581         /* just keep track of the number of samplers here.
582          * Will emit the declaration in the helpers function.
583          */
584         emit->num_samplers = MAX2(emit->num_samplers, decl->Range.Last + 1);
585         break;
586
587      case TGSI_FILE_INPUT:
588         if (emit->unit == PIPE_SHADER_VERTEX)
589            ok = vs30_input( emit, decl->Semantic, idx );
590         else
591            ok = ps30_input( emit, decl->Semantic, idx );
592         break;
593
594      case TGSI_FILE_OUTPUT:
595         if (emit->unit == PIPE_SHADER_VERTEX)
596            ok = vs30_output( emit, decl->Semantic, idx );
597         else
598            ok = ps30_output( emit, decl->Semantic, idx );
599         break;
600
601      case TGSI_FILE_SAMPLER_VIEW:
602         {
603            unsigned unit = decl->Range.First;
604            assert(decl->Range.First == decl->Range.Last);
605            emit->sampler_target[unit] = decl->SamplerView.Resource;
606         }
607         break;
608
609      default:
610         /* don't need to declare other vars */
611         ok = TRUE;
612      }
613
614      if (!ok)
615         return FALSE;
616   }
617
618   return TRUE;
619}
620