src/gallium/drivers/cell/spu/spu_util.c

   1
   2 #include "cell/common.h"
   3 #include "pipe/p_shader_tokens.h"
   4 #include "pipe/p_debug.h"
   5 #include "tgsi/tgsi_parse.h"
   6 //#include "tgsi_build.h"
   7 #include "tgsi/tgsi_util.h"
   8
   9 unsigned
  10 tgsi_util_get_src_register_swizzle(
  11    const struct tgsi_src_register *reg,
  12    unsigned component )
  13 {
  14    switch( component ) {
  15    case 0:
  16       return reg->SwizzleX;
  17    case 1:
  18       return reg->SwizzleY;
  19    case 2:
  20       return reg->SwizzleZ;
  21    case 3:
  22       return reg->SwizzleW;
  23    default:
  24       ASSERT( 0 );
  25    }
  26    return 0;
  27 }
  28
  29 unsigned
  30 tgsi_util_get_src_register_extswizzle(
  31    const struct tgsi_src_register_ext_swz *reg,
  32    unsigned component )
  33 {
  34    switch( component ) {
  35    case 0:
  36       return reg->ExtSwizzleX;
  37    case 1:
  38       return reg->ExtSwizzleY;
  39    case 2:
  40       return reg->ExtSwizzleZ;
  41    case 3:
  42       return reg->ExtSwizzleW;
  43    default:
  44       ASSERT( 0 );
  45    }
  46    return 0;
  47 }
  48
  49 unsigned
  50 tgsi_util_get_full_src_register_extswizzle(
  51    const struct tgsi_full_src_register  *reg,
  52    unsigned component )
  53 {
  54    unsigned swizzle;
  55
  56    /*
  57     * First, calculate  the   extended swizzle for a given channel. This will give
  58     * us either a channel index into the simple swizzle or  a constant 1 or   0.
  59     */
  60    swizzle = tgsi_util_get_src_register_extswizzle(
  61       &reg->SrcRegisterExtSwz,
  62       component );
  63
  64    ASSERT (TGSI_SWIZZLE_X == TGSI_EXTSWIZZLE_X);
  65    ASSERT (TGSI_SWIZZLE_Y == TGSI_EXTSWIZZLE_Y);
  66    ASSERT (TGSI_SWIZZLE_Z == TGSI_EXTSWIZZLE_Z);
  67    ASSERT (TGSI_SWIZZLE_W == TGSI_EXTSWIZZLE_W);
  68    ASSERT (TGSI_EXTSWIZZLE_ZERO > TGSI_SWIZZLE_W);
  69    ASSERT (TGSI_EXTSWIZZLE_ONE > TGSI_SWIZZLE_W);
  70
  71    /*
  72     * Second, calculate the simple  swizzle  for   the   unswizzled channel index.
  73     * Leave the constants intact, they are   not   affected by the   simple swizzle.
  74     */
  75    if( swizzle <= TGSI_SWIZZLE_W ) {
  76       swizzle = tgsi_util_get_src_register_swizzle(
  77          &reg->SrcRegister,
  78          component );
  79    }
  80
  81    return swizzle;
  82 }
  83
  84 unsigned
  85 tgsi_util_get_src_register_extnegate(
  86    const  struct tgsi_src_register_ext_swz *reg,
  87    unsigned component )
  88 {
  89    switch( component ) {
  90    case 0:
  91       return reg->NegateX;
  92    case 1:
  93       return reg->NegateY;
  94    case 2:
  95       return reg->NegateZ;
  96    case 3:
  97       return reg->NegateW;
  98    default:
  99       ASSERT( 0 );
 100    }
 101    return 0;
 102 }
 103
 104 void
 105 tgsi_util_set_src_register_extnegate(
 106    struct tgsi_src_register_ext_swz *reg,
 107    unsigned negate,
 108    unsigned component )
 109 {
 110    switch( component ) {
 111    case 0:
 112       reg->NegateX = negate;
 113       break;
 114    case 1:
 115       reg->NegateY = negate;
 116       break;
 117    case 2:
 118       reg->NegateZ = negate;
 119       break;
 120    case 3:
 121       reg->NegateW = negate;
 122       break;
 123    default:
 124       ASSERT( 0 );
 125    }
 126 }
 127
 128 unsigned
 129 tgsi_util_get_full_src_register_sign_mode(
 130    const struct  tgsi_full_src_register *reg,
 131    unsigned component )
 132 {
 133    unsigned sign_mode;
 134
 135    if( reg->SrcRegisterExtMod.Absolute ) {
 136       /* Consider only the post-abs negation. */
 137
 138       if( reg->SrcRegisterExtMod.Negate ) {
 139          sign_mode = TGSI_UTIL_SIGN_SET;
 140       }
 141       else {
 142          sign_mode = TGSI_UTIL_SIGN_CLEAR;
 143       }
 144    }
 145    else {
 146       /* Accumulate the three negations. */
 147
 148       unsigned negate;
 149
 150       negate = reg->SrcRegister.Negate;
 151       if( tgsi_util_get_src_register_extnegate( &reg->SrcRegisterExtSwz, component ) ) {
 152          negate = !negate;
 153       }
 154       if( reg->SrcRegisterExtMod.Negate ) {
 155          negate = !negate;
 156       }
 157
 158       if( negate ) {
 159          sign_mode = TGSI_UTIL_SIGN_TOGGLE;
 160       }
 161       else {
 162          sign_mode = TGSI_UTIL_SIGN_KEEP;
 163       }
 164    }
 165
 166    return sign_mode;
 167 }