src/gallium/auxiliary/tgsi/tgsi_aa_point.c

   1 /*
   2  * Copyright 2014 VMware, Inc.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * 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, sub license, 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 portions
  15  * of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  20  * IN NO EVENT SHALL THE AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR
  21  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26
  27 /**
  28  * This utility transforms the fragment shader to support anti-aliasing points.
  29  */
  30
  31 #include "util/u_debug.h"
  32 #include "util/u_math.h"
  33 #include "tgsi_info.h"
  34 #include "tgsi_aa_point.h"
  35 #include "tgsi_transform.h"
  36
  37 #define INVALID_INDEX 9999
  38
  39 struct aa_transform_context
  40 {
  41    struct tgsi_transform_context base;
  42
  43    unsigned tmp;           // temp register
  44    unsigned color_out;     // frag color out register
  45    unsigned color_tmp;     // frag color temp register
  46    unsigned num_tmp;       // number of temp registers
  47    unsigned num_imm;       // number of immediates
  48    unsigned num_input;     // number of inputs
  49    unsigned aa_point_coord_index;
  50 };
  51
  52 static inline struct aa_transform_context *
  53 aa_transform_context(struct tgsi_transform_context *ctx)
  54 {
  55    return (struct aa_transform_context *) ctx;
  56 }
  57
  58 /**
  59  * TGSI declaration transform callback.
  60  */
  61 static void
  62 aa_decl(struct tgsi_transform_context *ctx,
  63               struct tgsi_full_declaration *decl)
  64 {
  65    struct aa_transform_context *ts = aa_transform_context(ctx);
  66
  67    if (decl->Declaration.File == TGSI_FILE_OUTPUT &&
  68        decl->Semantic.Name == TGSI_SEMANTIC_COLOR &&
  69        decl->Semantic.Index == 0) {
  70          ts->color_out = decl->Range.First;
  71    }
  72    else if (decl->Declaration.File == TGSI_FILE_INPUT) {
  73       ts->num_input++;
  74    }
  75    else if (decl->Declaration.File == TGSI_FILE_TEMPORARY) {
  76       ts->num_tmp = MAX2(ts->num_tmp, (unsigned)(decl->Range.Last + 1));
  77    }
  78
  79    ctx->emit_declaration(ctx, decl);
  80 }
  81
  82 /**
  83  * TGSI immediate declaration transform callback.
  84  */
  85 static void
  86 aa_immediate(struct tgsi_transform_context *ctx,
  87                   struct tgsi_full_immediate *imm)
  88 {
  89    struct aa_transform_context *ts = aa_transform_context(ctx);
  90
  91    ctx->emit_immediate(ctx, imm);
  92    ts->num_imm++;
  93 }
  94
  95 /**
  96  * TGSI transform prolog callback.
  97  */
  98 static void
  99 aa_prolog(struct tgsi_transform_context *ctx)
 100 {
 101    struct aa_transform_context *ts = aa_transform_context(ctx);
 102    unsigned tmp0;
 103    unsigned texIn;
 104    unsigned imm;
 105
 106    /* Declare two temporary registers, one for temporary and
 107     * one for color.
 108     */
 109    ts->tmp = ts->num_tmp++;
 110    ts->color_tmp = ts->num_tmp++;
 111
 112    tgsi_transform_temps_decl(ctx, ts->tmp, ts->color_tmp);
 113
 114    /* Declare new generic input/texcoord */
 115    texIn = ts->num_input++;
 116    tgsi_transform_input_decl(ctx, texIn, TGSI_SEMANTIC_GENERIC,
 117                              ts->aa_point_coord_index, TGSI_INTERPOLATE_LINEAR);
 118
 119    /* Declare extra immediates */
 120    imm = ts->num_imm++;
 121    tgsi_transform_immediate_decl(ctx, 0.5, 0.5, 0.45, 1.0);
 122
 123    /*
 124     * Emit code to compute fragment coverage.
 125     * The point always has radius 0.5.  The threshold value will be a
 126     * value less than, but close to 0.5, such as 0.45.
 127     * We compute a coverage factor from the distance and threshold.
 128     * If the coverage is negative, the fragment is outside the circle and
 129     * it's discarded.
 130     * If the coverage is >= 1, the fragment is fully inside the threshold
 131     * distance.  We limit/clamp the coverage to 1.
 132     * Otherwise, the fragment is between the threshold value and 0.5 and we
 133     * compute a coverage value in [0,1].
 134     *
 135     * Input reg (texIn) usage:
 136     *  texIn.x = x point coord in [0,1]
 137     *  texIn.y = y point coord in [0,1]
 138     *  texIn.z = "k" the smoothing threshold distance
 139     *  texIn.w = unused
 140     *
 141     * Temp reg (t0) usage:
 142     *  t0.x = distance of fragment from center point
 143     *  t0.y = boolean, is t0.x > 0.5, also misc temp usage
 144     *  t0.z = temporary for computing 1/(0.5-k) value
 145     *  t0.w = final coverage value
 146     */
 147
 148    tmp0 = ts->tmp;
 149
 150    /* SUB t0.xy, texIn, (0.5, 0,5) */
 151    tgsi_transform_op2_inst(ctx, TGSI_OPCODE_ADD,
 152                            TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_XY,
 153                            TGSI_FILE_INPUT, texIn,
 154                            TGSI_FILE_IMMEDIATE, imm, true);
 155
 156    /* DP2 t0.x, t0.xy, t0.xy;  # t0.x = x^2 + y^2 */
 157    tgsi_transform_op2_inst(ctx, TGSI_OPCODE_DP2,
 158                            TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_X,
 159                            TGSI_FILE_TEMPORARY, tmp0,
 160                            TGSI_FILE_TEMPORARY, tmp0, false);
 161
 162    /* SQRT t0.x, t0.x */
 163    tgsi_transform_op1_inst(ctx, TGSI_OPCODE_SQRT,
 164                            TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_X,
 165                            TGSI_FILE_TEMPORARY, tmp0);
 166
 167    /* compute coverage factor = (0.5-d)/(0.5-k) */
 168
 169    /* SUB t0.w, 0.5, texIn.z;  # t0.w = 0.5-k */
 170    tgsi_transform_op2_swz_inst(ctx, TGSI_OPCODE_ADD,
 171                                TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_W,
 172                                TGSI_FILE_IMMEDIATE, imm, TGSI_SWIZZLE_X,
 173                                TGSI_FILE_INPUT, texIn, TGSI_SWIZZLE_Z, true);
 174
 175    /* SUB t0.y, 0.5, t0.x;  # t0.y = 0.5-d */
 176    tgsi_transform_op2_swz_inst(ctx, TGSI_OPCODE_ADD,
 177                                TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_Y,
 178                                TGSI_FILE_IMMEDIATE, imm, TGSI_SWIZZLE_X,
 179                                TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_X, true);
 180
 181    /* DIV t0.w, t0.y, t0.w;  # coverage = (0.5-d)/(0.5-k) */
 182    tgsi_transform_op2_swz_inst(ctx, TGSI_OPCODE_DIV,
 183                                TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_W,
 184                                TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_Y,
 185                                TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_W, false);
 186
 187    /* If the coverage value is negative, it means the fragment is outside
 188     * the point's circular boundary.  Kill it.
 189     */
 190    /* KILL_IF tmp0.w;  # if tmp0.w < 0 KILL */
 191    tgsi_transform_kill_inst(ctx, TGSI_FILE_TEMPORARY, tmp0,
 192                             TGSI_SWIZZLE_W, FALSE);
 193
 194    /* If the distance is less than the threshold, the coverage/alpha value
 195     * will be greater than one.  Clamp to one here.
 196     */
 197    /* MIN tmp0.w, tmp0.w, 1.0 */
 198    tgsi_transform_op2_swz_inst(ctx, TGSI_OPCODE_MIN,
 199                                TGSI_FILE_TEMPORARY, tmp0, TGSI_WRITEMASK_W,
 200                                TGSI_FILE_TEMPORARY, tmp0, TGSI_SWIZZLE_W,
 201                                TGSI_FILE_IMMEDIATE, imm, TGSI_SWIZZLE_W, false);
 202 }
 203
 204 /**
 205  * TGSI instruction transform callback.
 206  */
 207 static void
 208 aa_inst(struct tgsi_transform_context *ctx,
 209         struct tgsi_full_instruction *inst)
 210 {
 211    struct aa_transform_context *ts = aa_transform_context(ctx);
 212    unsigned i;
 213
 214    /* Look for writes to color output reg and replace it with
 215     * color temp reg.
 216     */
 217    for (i = 0; i < inst->Instruction.NumDstRegs; i++) {
 218       struct tgsi_full_dst_register *dst = &inst->Dst[i];
 219       if (dst->Register.File == TGSI_FILE_OUTPUT &&
 220           dst->Register.Index == (int)ts->color_out) {
 221          dst->Register.File = TGSI_FILE_TEMPORARY;
 222          dst->Register.Index = ts->color_tmp;
 223       }
 224    }
 225
 226    ctx->emit_instruction(ctx, inst);
 227 }
 228
 229 /**
 230  * TGSI transform epilog callback.
 231  */
 232 static void
 233 aa_epilog(struct tgsi_transform_context *ctx)
 234 {
 235    struct aa_transform_context *ts = aa_transform_context(ctx);
 236
 237    /* add alpha modulation code at tail of program */
 238    assert(ts->color_out != INVALID_INDEX);
 239    assert(ts->color_tmp != INVALID_INDEX);
 240
 241    /* MOV output.color.xyz colorTmp */
 242    tgsi_transform_op1_inst(ctx, TGSI_OPCODE_MOV,
 243                            TGSI_FILE_OUTPUT, ts->color_out,
 244                            TGSI_WRITEMASK_XYZ,
 245                            TGSI_FILE_TEMPORARY, ts->color_tmp);
 246
 247    /* MUL output.color.w colorTmp.w tmp0.w */
 248    tgsi_transform_op2_inst(ctx, TGSI_OPCODE_MUL,
 249                            TGSI_FILE_OUTPUT, ts->color_out,
 250                            TGSI_WRITEMASK_W,
 251                            TGSI_FILE_TEMPORARY, ts->color_tmp,
 252                            TGSI_FILE_TEMPORARY, ts->tmp, false);
 253 }
 254
 255 /**
 256  * TGSI utility to transform a fragment shader to support antialiasing point.
 257  *
 258  * This utility accepts two inputs:
 259  *\param tokens_in  -- the original token string of the shader
 260  *\param aa_point_coord_index -- the semantic index of the generic register
 261  *                            that contains the point sprite texture coord
 262  *
 263  * For each fragment in the point, we compute the distance of the fragment
 264  * from the point center using the point sprite texture coordinates.
 265  * If the distance is greater than 0.5, we'll discard the fragment.
 266  * Otherwise, we'll compute a coverage value which approximates how much
 267  * of the fragment is inside the bounding circle of the point. If the distance
 268  * is less than 'k', the coverage is 1. Else, the coverage is between 0 and 1.
 269  * The final fragment color's alpha channel is then modulated by the coverage
 270  * value.
 271  */
 272 struct tgsi_token *
 273 tgsi_add_aa_point(const struct tgsi_token *tokens_in,
 274                   const int aa_point_coord_index)
 275 {
 276    struct aa_transform_context transform;
 277    const uint num_new_tokens = 200; /* should be enough */
 278    const uint new_len = tgsi_num_tokens(tokens_in) + num_new_tokens;
 279    struct tgsi_token *new_tokens;
 280
 281    /* allocate new tokens buffer */
 282    new_tokens = tgsi_alloc_tokens(new_len);
 283    if (!new_tokens)
 284       return NULL;
 285
 286    /* setup transformation context */
 287    memset(&transform, 0, sizeof(transform));
 288    transform.base.transform_declaration = aa_decl;
 289    transform.base.transform_instruction = aa_inst;
 290    transform.base.transform_immediate = aa_immediate;
 291    transform.base.prolog = aa_prolog;
 292    transform.base.epilog = aa_epilog;
 293
 294    transform.tmp = INVALID_INDEX;
 295    transform.color_out = INVALID_INDEX;
 296    transform.color_tmp = INVALID_INDEX;
 297
 298    assert(aa_point_coord_index != -1);
 299    transform.aa_point_coord_index = (unsigned)aa_point_coord_index;
 300
 301    transform.num_tmp = 0;
 302    transform.num_imm = 0;
 303    transform.num_input = 0;
 304
 305    /* transform the shader */
 306    tgsi_transform_shader(tokens_in, new_tokens, new_len, &transform.base);
 307
 308    return new_tokens;
 309 }