src/mesa/pipe/softpipe/sp_quad_blend.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 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 /**
  29  * quad blending
  30  * \author Brian Paul
  31  */
  32
  33 #include "glheader.h"
  34 #include "imports.h"
  35 #include "macros.h"
  36 #include "pipe/p_defines.h"
  37 #include "sp_context.h"
  38 #include "sp_headers.h"
  39 #include "sp_surface.h"
  40 #include "sp_quad.h"
  41
  42
  43 #define VEC4_COPY(DST, SRC) \
  44 do { \
  45     DST[0] = SRC[0]; \
  46     DST[1] = SRC[1]; \
  47     DST[2] = SRC[2]; \
  48     DST[3] = SRC[3]; \
  49 } while(0)
  50
  51 #define VEC4_SCALAR(DST, SRC) \
  52 do { \
  53     DST[0] = SRC; \
  54     DST[1] = SRC; \
  55     DST[2] = SRC; \
  56     DST[3] = SRC; \
  57 } while(0)
  58
  59 #define VEC4_ADD(SUM, A, B) \
  60 do { \
  61    SUM[0] = A[0] + B[0]; \
  62    SUM[1] = A[1] + B[1]; \
  63    SUM[2] = A[2] + B[2]; \
  64    SUM[3] = A[3] + B[3]; \
  65 } while (0)
  66
  67 #define VEC4_SUB(SUM, A, B) \
  68 do { \
  69    SUM[0] = A[0] - B[0]; \
  70    SUM[1] = A[1] - B[1]; \
  71    SUM[2] = A[2] - B[2]; \
  72    SUM[3] = A[3] - B[3]; \
  73 } while (0)
  74
  75 #define VEC4_MUL(SUM, A, B) \
  76 do { \
  77    SUM[0] = A[0] * B[0]; \
  78    SUM[1] = A[1] * B[1]; \
  79    SUM[2] = A[2] * B[2]; \
  80    SUM[3] = A[3] * B[3]; \
  81 } while (0)
  82
  83 #define VEC4_MIN(SUM, A, B) \
  84 do { \
  85    SUM[0] = (A[0] < B[0]) ? A[0] : B[0]; \
  86    SUM[1] = (A[1] < B[1]) ? A[1] : B[1]; \
  87    SUM[2] = (A[2] < B[2]) ? A[2] : B[2]; \
  88    SUM[3] = (A[3] < B[3]) ? A[3] : B[3]; \
  89 } while (0)
  90
  91 #define VEC4_MAX(SUM, A, B) \
  92 do { \
  93    SUM[0] = (A[0] > B[0]) ? A[0] : B[0]; \
  94    SUM[1] = (A[1] > B[1]) ? A[1] : B[1]; \
  95    SUM[2] = (A[2] > B[2]) ? A[2] : B[2]; \
  96    SUM[3] = (A[3] > B[3]) ? A[3] : B[3]; \
  97 } while (0)
  98
  99
 100
 101 static void
 102 blend_quad(struct quad_stage *qs, struct quad_header *quad)
 103 {
 104    static const GLfloat zero[4] = { 0, 0, 0, 0 };
 105    static const GLfloat one[4] = { 1, 1, 1, 1 };
 106    struct softpipe_context *softpipe = qs->softpipe;
 107    struct softpipe_surface *sps = softpipe_surface(softpipe->cbuf);
 108    GLfloat source[4][QUAD_SIZE], dest[4][QUAD_SIZE];
 109
 110    /* get colors from framebuffer */
 111    sps->read_quad_f_swz(sps, quad->x0, quad->y0, dest);
 112
 113    /*
 114     * Compute src/first term RGB
 115     */
 116    switch (softpipe->blend.rgb_src_factor) {
 117    case PIPE_BLENDFACTOR_ONE:
 118       VEC4_COPY(source[0], quad->outputs.color[0]); /* R */
 119       VEC4_COPY(source[1], quad->outputs.color[1]); /* G */
 120       VEC4_COPY(source[2], quad->outputs.color[2]); /* B */
 121       break;
 122    case PIPE_BLENDFACTOR_SRC_COLOR:
 123       VEC4_MUL(source[0], quad->outputs.color[0], quad->outputs.color[0]); /* R */
 124       VEC4_MUL(source[1], quad->outputs.color[1], quad->outputs.color[1]); /* G */
 125       VEC4_MUL(source[2], quad->outputs.color[2], quad->outputs.color[2]); /* B */
 126       break;
 127    case PIPE_BLENDFACTOR_SRC_ALPHA:
 128       {
 129          const GLfloat *alpha = quad->outputs.color[3];
 130          VEC4_MUL(source[0], quad->outputs.color[0], alpha); /* R */
 131          VEC4_MUL(source[1], quad->outputs.color[1], alpha); /* G */
 132          VEC4_MUL(source[2], quad->outputs.color[2], alpha); /* B */
 133       }
 134       break;
 135    case PIPE_BLENDFACTOR_DST_COLOR:
 136       VEC4_MUL(source[0], quad->outputs.color[0], dest[0]); /* R */
 137       VEC4_MUL(source[1], quad->outputs.color[1], dest[1]); /* G */
 138       VEC4_MUL(source[2], quad->outputs.color[2], dest[2]); /* B */
 139       break;
 140    case PIPE_BLENDFACTOR_DST_ALPHA:
 141       {
 142          const GLfloat *alpha = dest[3];
 143          VEC4_MUL(source[0], quad->outputs.color[0], alpha); /* R */
 144          VEC4_MUL(source[1], quad->outputs.color[1], alpha); /* G */
 145          VEC4_MUL(source[2], quad->outputs.color[2], alpha); /* B */
 146       }
 147       break;
 148    case PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE:
 149       assert(0); /* to do */
 150       break;
 151    case PIPE_BLENDFACTOR_CONST_COLOR:
 152       {
 153          GLfloat comp[4];
 154          VEC4_SCALAR(comp, softpipe->blend_color.color[0]); /* R */
 155          VEC4_MUL(source[0], quad->outputs.color[0], comp); /* R */
 156          VEC4_SCALAR(comp, softpipe->blend_color.color[1]); /* G */
 157          VEC4_MUL(source[1], quad->outputs.color[1], comp); /* G */
 158          VEC4_SCALAR(comp, softpipe->blend_color.color[2]); /* B */
 159          VEC4_MUL(source[2], quad->outputs.color[2], comp); /* B */
 160       }
 161       break;
 162    case PIPE_BLENDFACTOR_CONST_ALPHA:
 163       {
 164          GLfloat alpha[4];
 165          VEC4_SCALAR(alpha, softpipe->blend_color.color[3]);
 166          VEC4_MUL(source[0], quad->outputs.color[0], alpha); /* R */
 167          VEC4_MUL(source[1], quad->outputs.color[1], alpha); /* G */
 168          VEC4_MUL(source[2], quad->outputs.color[2], alpha); /* B */
 169       }
 170       break;
 171    case PIPE_BLENDFACTOR_SRC1_COLOR:
 172       assert(0); /* to do */
 173       break;
 174    case PIPE_BLENDFACTOR_SRC1_ALPHA:
 175       assert(0); /* to do */
 176       break;
 177    case PIPE_BLENDFACTOR_ZERO:
 178       VEC4_COPY(source[0], zero); /* R */
 179       VEC4_COPY(source[1], zero); /* G */
 180       VEC4_COPY(source[2], zero); /* B */
 181       break;
 182    case PIPE_BLENDFACTOR_INV_SRC_COLOR:
 183       {
 184          GLfloat inv_comp[4];
 185          VEC4_SUB(inv_comp, one, quad->outputs.color[0]); /* R */
 186          VEC4_MUL(source[0], quad->outputs.color[0], inv_comp); /* R */
 187          VEC4_SUB(inv_comp, one, quad->outputs.color[1]); /* G */
 188          VEC4_MUL(source[1], quad->outputs.color[1], inv_comp); /* G */
 189          VEC4_SUB(inv_comp, one, quad->outputs.color[2]); /* B */
 190          VEC4_MUL(source[2], quad->outputs.color[2], inv_comp); /* B */
 191       }
 192       break;
 193    case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
 194       {
 195          GLfloat inv_alpha[4];
 196          VEC4_SUB(inv_alpha, one, quad->outputs.color[3]);
 197          VEC4_MUL(source[0], quad->outputs.color[0], inv_alpha); /* R */
 198          VEC4_MUL(source[1], quad->outputs.color[1], inv_alpha); /* G */
 199          VEC4_MUL(source[2], quad->outputs.color[2], inv_alpha); /* B */
 200       }
 201       break;
 202    case PIPE_BLENDFACTOR_INV_DST_ALPHA:
 203       {
 204          GLfloat inv_alpha[4];
 205          VEC4_SUB(inv_alpha, one, dest[3]);
 206          VEC4_MUL(source[0], quad->outputs.color[0], inv_alpha); /* R */
 207          VEC4_MUL(source[1], quad->outputs.color[1], inv_alpha); /* G */
 208          VEC4_MUL(source[2], quad->outputs.color[2], inv_alpha); /* B */
 209       }
 210       break;
 211    case PIPE_BLENDFACTOR_INV_DST_COLOR:
 212       {
 213          GLfloat inv_comp[4];
 214          VEC4_SUB(inv_comp, one, dest[0]); /* R */
 215          VEC4_MUL(source[0], quad->outputs.color[0], inv_comp); /* R */
 216          VEC4_SUB(inv_comp, one, dest[1]); /* G */
 217          VEC4_MUL(source[1], quad->outputs.color[1], inv_comp); /* G */
 218          VEC4_SUB(inv_comp, one, dest[2]); /* B */
 219          VEC4_MUL(source[2], quad->outputs.color[2], inv_comp); /* B */
 220       }
 221       break;
 222    case PIPE_BLENDFACTOR_INV_CONST_COLOR:
 223       {
 224          GLfloat inv_comp[4];
 225          /* R */
 226          VEC4_SCALAR(inv_comp, 1.0 - softpipe->blend_color.color[0]);
 227          VEC4_MUL(source[0], quad->outputs.color[0], inv_comp);
 228          /* G */
 229          VEC4_SCALAR(inv_comp, 1.0 - softpipe->blend_color.color[1]);
 230          VEC4_MUL(source[1], quad->outputs.color[1], inv_comp);
 231          /* B */
 232          VEC4_SCALAR(inv_comp, 1.0 - softpipe->blend_color.color[2]);
 233          VEC4_MUL(source[2], quad->outputs.color[2], inv_comp);
 234       }
 235       break;
 236    case PIPE_BLENDFACTOR_INV_CONST_ALPHA:
 237       {
 238          GLfloat alpha[4], inv_alpha[4];
 239          VEC4_SCALAR(alpha, 1.0 - softpipe->blend_color.color[3]);
 240          VEC4_MUL(source[0], quad->outputs.color[0], inv_alpha); /* R */
 241          VEC4_MUL(source[1], quad->outputs.color[1], inv_alpha); /* G */
 242          VEC4_MUL(source[2], quad->outputs.color[2], inv_alpha); /* B */
 243       }
 244       break;
 245    case PIPE_BLENDFACTOR_INV_SRC1_COLOR:
 246       assert(0); /* to do */
 247       break;
 248    case PIPE_BLENDFACTOR_INV_SRC1_ALPHA:
 249       assert(0); /* to do */
 250       break;
 251    default:
 252       abort();
 253    }
 254
 255    /*
 256     * Compute src/first term A
 257     */
 258    switch (softpipe->blend.alpha_src_factor) {
 259    case PIPE_BLENDFACTOR_ONE:
 260       VEC4_COPY(source[3], quad->outputs.color[3]); /* A */
 261       break;
 262    case PIPE_BLENDFACTOR_SRC_ALPHA:
 263       {
 264          const GLfloat *alpha = quad->outputs.color[3];
 265          VEC4_MUL(source[3], quad->outputs.color[3], alpha); /* A */
 266       }
 267       break;
 268    case PIPE_BLENDFACTOR_ZERO:
 269       VEC4_COPY(source[3], zero); /* A */
 270       break;
 271       /* XXX fill in remaining terms */
 272    default:
 273       abort();
 274    }
 275
 276
 277    /*
 278     * Compute dest/second term RGB
 279     */
 280    switch (softpipe->blend.rgb_dst_factor) {
 281    case PIPE_BLENDFACTOR_ONE:
 282       /* dest = dest * 1   NO-OP, leave dest as-is */
 283       break;
 284    case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
 285       {
 286          GLfloat one_minus_alpha[QUAD_SIZE];
 287          VEC4_SUB(one_minus_alpha, one, quad->outputs.color[3]);
 288          VEC4_MUL(dest[0], dest[0], one_minus_alpha); /* R */
 289          VEC4_MUL(dest[1], dest[1], one_minus_alpha); /* G */
 290          VEC4_MUL(dest[2], dest[2], one_minus_alpha); /* B */
 291       }
 292       break;
 293    case PIPE_BLENDFACTOR_ZERO:
 294       VEC4_COPY(dest[0], zero); /* R */
 295       VEC4_COPY(dest[1], zero); /* G */
 296       VEC4_COPY(dest[2], zero); /* B */
 297       break;
 298       /* XXX fill in remaining terms */
 299    default:
 300       abort();
 301    }
 302
 303    /*
 304     * Compute dest/second term A
 305     */
 306    switch (softpipe->blend.alpha_dst_factor) {
 307    case PIPE_BLENDFACTOR_ONE:
 308       /* dest = dest * 1   NO-OP, leave dest as-is */
 309       break;
 310    case PIPE_BLENDFACTOR_INV_SRC_ALPHA:
 311       {
 312          GLfloat one_minus_alpha[QUAD_SIZE];
 313          VEC4_SUB(one_minus_alpha, one, quad->outputs.color[3]);
 314          VEC4_MUL(dest[3], dest[3], one_minus_alpha); /* A */
 315       }
 316       break;
 317    case PIPE_BLENDFACTOR_ZERO:
 318       VEC4_COPY(dest[3], zero); /* A */
 319       break;
 320       /* XXX fill in remaining terms */
 321    default:
 322       abort();
 323    }
 324
 325    /*
 326     * Combine RGB terms
 327     */
 328    switch (softpipe->blend.rgb_func) {
 329    case PIPE_BLEND_ADD:
 330       VEC4_ADD(quad->outputs.color[0], source[0], dest[0]); /* R */
 331       VEC4_ADD(quad->outputs.color[1], source[1], dest[1]); /* G */
 332       VEC4_ADD(quad->outputs.color[2], source[2], dest[2]); /* B */
 333       break;
 334    case PIPE_BLEND_SUBTRACT:
 335       VEC4_SUB(quad->outputs.color[0], source[0], dest[0]); /* R */
 336       VEC4_SUB(quad->outputs.color[1], source[1], dest[1]); /* G */
 337       VEC4_SUB(quad->outputs.color[2], source[2], dest[2]); /* B */
 338       break;
 339    case PIPE_BLEND_REVERSE_SUBTRACT:
 340       VEC4_SUB(quad->outputs.color[0], dest[0], source[0]); /* R */
 341       VEC4_SUB(quad->outputs.color[1], dest[1], source[1]); /* G */
 342       VEC4_SUB(quad->outputs.color[2], dest[2], source[2]); /* B */
 343       break;
 344    case PIPE_BLEND_MIN:
 345       VEC4_MIN(quad->outputs.color[0], source[0], dest[0]); /* R */
 346       VEC4_MIN(quad->outputs.color[1], source[1], dest[1]); /* G */
 347       VEC4_MIN(quad->outputs.color[2], source[2], dest[2]); /* B */
 348       break;
 349    case PIPE_BLEND_MAX:
 350       VEC4_MAX(quad->outputs.color[0], source[0], dest[0]); /* R */
 351       VEC4_MAX(quad->outputs.color[1], source[1], dest[1]); /* G */
 352       VEC4_MAX(quad->outputs.color[2], source[2], dest[2]); /* B */
 353       break;
 354    default:
 355       abort();
 356    }
 357
 358    /*
 359     * Combine A terms
 360     */
 361    switch (softpipe->blend.alpha_func) {
 362    case PIPE_BLEND_ADD:
 363       VEC4_ADD(quad->outputs.color[3], source[3], dest[3]); /* A */
 364       break;
 365    case PIPE_BLEND_SUBTRACT:
 366       VEC4_SUB(quad->outputs.color[3], source[3], dest[3]); /* A */
 367       break;
 368    case PIPE_BLEND_REVERSE_SUBTRACT:
 369       VEC4_SUB(quad->outputs.color[3], dest[3], source[3]); /* A */
 370       break;
 371    case PIPE_BLEND_MIN:
 372       VEC4_MIN(quad->outputs.color[3], source[3], dest[3]); /* A */
 373       break;
 374    case PIPE_BLEND_MAX:
 375       VEC4_MAX(quad->outputs.color[3], source[3], dest[3]); /* A */
 376    default:
 377       abort();
 378    }
 379
 380    /* pass blended quad to next stage */
 381    qs->next->run(qs->next, quad);
 382 }
 383
 384
 385 static void blend_begin(struct quad_stage *qs)
 386 {
 387    if (qs->next)
 388       qs->next->begin(qs->next);
 389 }
 390
 391
 392 struct quad_stage *sp_quad_blend_stage( struct softpipe_context *softpipe )
 393 {
 394    struct quad_stage *stage = CALLOC_STRUCT(quad_stage);
 395
 396    stage->softpipe = softpipe;
 397    stage->begin = blend_begin;
 398    stage->run = blend_quad;
 399
 400    return stage;
 401 }