src/mesa/drivers/dri/nouveau/nv10_state_frag.c

   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
  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 HALF_BIAS 0x2
 139
 140 static uint32_t
 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 & HALF_BIAS ?
 152                         RC_IN_MAPPING(HALF_BIAS_NEGATE) :
 153                         RC_IN_MAPPING(UNSIGNED_INVERT);
 154         else
 155                 map |= flags & HALF_BIAS ?
 156                         RC_IN_MAPPING(HALF_BIAS_NORMAL) :
 157                         RC_IN_MAPPING(UNSIGNED_IDENTITY);
 158
 159         return map;
 160 }
 161
 162 static uint32_t
 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                 gl_format format = t->Image[0][t->BaseLevel]->TexFormat;
 174
 175                 if (format == MESA_FORMAT_A8) {
 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_L8) {
 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_XRGB8888) {
 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
 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, HALF_BIAS);
 274                 INPUT_ARG(rc, B, 1, HALF_BIAS);
 275
 276                 rc->out = RC_OUT_DOT_AB | RC_OUT_SCALE_4;
 277
 278                 assert(!rc->logscale);
 279                 break;
 280
 281         default:
 282                 assert(0);
 283         }
 284
 285         switch (rc->logscale) {
 286         case 0:
 287                 rc->out |= RC_OUT_SCALE_1;
 288                 break;
 289         case 1:
 290                 rc->out |= RC_OUT_SCALE_2;
 291                 break;
 292         case 2:
 293                 rc->out |= RC_OUT_SCALE_4;
 294                 break;
 295         default:
 296                 assert(0);
 297         }
 298 }
 299
 300 void
 301 nv10_get_general_combiner(struct gl_context *ctx, int i,
 302                           uint32_t *a_in, uint32_t *a_out,
 303                           uint32_t *c_in, uint32_t *c_out, uint32_t *k)
 304 {
 305         struct combiner_state rc_a, rc_c;
 306
 307         if (ctx->Texture.Unit[i]._ReallyEnabled) {
 308                 INIT_COMBINER(RGB, ctx, &rc_c, i);
 309
 310                 if (rc_c.mode == GL_DOT3_RGBA)
 311                         rc_a = rc_c;
 312                 else
 313                         INIT_COMBINER(A, ctx, &rc_a, i);
 314
 315                 setup_combiner(&rc_c);
 316                 setup_combiner(&rc_a);
 317
 318         } else {
 319                 rc_a.in = rc_a.out = rc_c.in = rc_c.out = 0;
 320         }
 321
 322         *k = pack_rgba_f(MESA_FORMAT_ARGB8888,
 323                          ctx->Texture.Unit[i].EnvColor);
 324         *a_in = rc_a.in;
 325         *a_out = rc_a.out;
 326         *c_in = rc_c.in;
 327         *c_out = rc_c.out;
 328 }
 329
 330 void
 331 nv10_get_final_combiner(struct gl_context *ctx, uint64_t *in, int *n)
 332 {
 333         struct combiner_state rc = {};
 334
 335         /*
 336          * The final fragment value equation is something like:
 337          *      x_i = A_i * B_i + (1 - A_i) * C_i + D_i
 338          *      x_alpha = G_alpha
 339          * where D_i = E_i * F_i, i one of {red, green, blue}.
 340          */
 341         if (ctx->Fog.ColorSumEnabled || ctx->Light.Enabled) {
 342                 INPUT_SRC(&rc, D, E_TIMES_F, RGB);
 343                 INPUT_SRC(&rc, F, SECONDARY_COLOR, RGB);
 344         }
 345
 346         if (ctx->Fog.Enabled) {
 347                 INPUT_SRC(&rc, A, FOG, ALPHA);
 348                 INPUT_SRC(&rc, C, FOG, RGB);
 349                 INPUT_SRC(&rc, E, FOG, ALPHA);
 350         } else {
 351                 INPUT_ONE(&rc, A, 0);
 352                 INPUT_ONE(&rc, C, 0);
 353                 INPUT_ONE(&rc, E, 0);
 354         }
 355
 356         if (ctx->Texture._EnabledUnits) {
 357                 INPUT_SRC(&rc, B, SPARE0, RGB);
 358                 INPUT_SRC(&rc, G, SPARE0, ALPHA);
 359         } else {
 360                 INPUT_SRC(&rc, B, PRIMARY_COLOR, RGB);
 361                 INPUT_SRC(&rc, G, PRIMARY_COLOR, ALPHA);
 362         }
 363
 364         *in = rc.in;
 365         *n = log2i(ctx->Texture._EnabledUnits) + 1;
 366 }
 367
 368 void
 369 nv10_emit_tex_env(struct gl_context *ctx, int emit)
 370 {
 371         const int i = emit - NOUVEAU_STATE_TEX_ENV0;
 372         struct nouveau_channel *chan = context_chan(ctx);
 373         struct nouveau_grobj *celsius = context_eng3d(ctx);
 374         uint32_t a_in, a_out, c_in, c_out, k;
 375
 376         nv10_get_general_combiner(ctx, i, &a_in, &a_out, &c_in, &c_out, &k);
 377
 378         /* Enable the combiners we're going to need. */
 379         if (i == 1) {
 380                 if (c_out || a_out)
 381                         c_out |= 0x5 << 27;
 382                 else
 383                         c_out |= 0x3 << 27;
 384         }
 385
 386         BEGIN_RING(chan, celsius, NV10_3D_RC_IN_ALPHA(i), 1);
 387         OUT_RING(chan, a_in);
 388         BEGIN_RING(chan, celsius, NV10_3D_RC_IN_RGB(i), 1);
 389         OUT_RING(chan, c_in);
 390         BEGIN_RING(chan, celsius, NV10_3D_RC_COLOR(i), 1);
 391         OUT_RING(chan, k);
 392         BEGIN_RING(chan, celsius, NV10_3D_RC_OUT_ALPHA(i), 1);
 393         OUT_RING(chan, a_out);
 394         BEGIN_RING(chan, celsius, NV10_3D_RC_OUT_RGB(i), 1);
 395         OUT_RING(chan, c_out);
 396
 397         context_dirty(ctx, FRAG);
 398 }
 399
 400 void
 401 nv10_emit_frag(struct gl_context *ctx, int emit)
 402 {
 403         struct nouveau_channel *chan = context_chan(ctx);
 404         struct nouveau_grobj *celsius = context_eng3d(ctx);
 405         uint64_t in;
 406         int n;
 407
 408         nv10_get_final_combiner(ctx, &in, &n);
 409
 410         BEGIN_RING(chan, celsius, NV10_3D_RC_FINAL0, 2);
 411         OUT_RING(chan, in);
 412         OUT_RING(chan, in >> 32);
 413 }