source/core/blend.cpp

   1 #include <msp/gl/extensions/ext_blend_minmax.h>
   2 #include <msp/gl/extensions/ext_blend_subtract.h>
   3 #include <msp/strings/format.h>
   4 #include "blend.h"
   5
   6 using namespace std;
   7
   8 namespace Msp {
   9 namespace GL {
  10
  11 Blend::Blend():
  12         enabled(false),
  13         equation(ADD),
  14         src_factor(ONE),
  15         dst_factor(ZERO),
  16         constant(0.0f, 0.0f, 0.0f, 0.0f)
  17 { }
  18
  19 Blend::Blend(BlendFactor sf, BlendFactor df):
  20         enabled(true),
  21         equation(ADD),
  22         src_factor(sf),
  23         dst_factor(df),
  24         constant(0.0f, 0.0f, 0.0f, 0.0f)
  25 { }
  26
  27 Blend::Blend(BlendEquation e, BlendFactor sf, BlendFactor df):
  28         enabled(true),
  29         equation(e),
  30         src_factor(sf),
  31         dst_factor(df),
  32         constant(0.0f, 0.0f, 0.0f, 0.0f)
  33 { }
  34
  35
  36 Blend::Loader::Loader(Blend &b):
  37         ObjectLoader<Blend>(b)
  38 {
  39         add("equation", &Loader::equation);
  40         add("factors", &Loader::factors);
  41         add("constant", &Loader::constant);
  42 }
  43
  44 void Blend::Loader::constant(float r, float g, float b, float a)
  45 {
  46         obj.constant = Color(r, g, b, a);
  47 }
  48
  49 void Blend::Loader::equation(BlendEquation eq)
  50 {
  51         obj.enabled = true;
  52         obj.equation = eq;
  53 }
  54
  55 void Blend::Loader::factors(BlendFactor sf, BlendFactor df)
  56 {
  57         obj.enabled = true;
  58         obj.src_factor = sf;
  59         obj.dst_factor = df;
  60 }
  61
  62
  63 GLenum get_gl_blend_equation(BlendEquation eq)
  64 {
  65         switch(eq)
  66         {
  67         case ADD: return GL_FUNC_ADD;
  68         case SUBTRACT: return GL_FUNC_SUBTRACT;
  69         case REVERSE_SUBTRACT: return GL_FUNC_REVERSE_SUBTRACT;
  70         case MIN: return GL_MIN;
  71         case MAX: return GL_MAX;
  72         default: throw invalid_argument("get_gl_blend_equation");
  73         }
  74 }
  75
  76 GLenum get_gl_blend_factor(BlendFactor factor)
  77 {
  78         switch(factor)
  79         {
  80         case ZERO: return GL_ZERO;
  81         case ONE: return GL_ONE;
  82         case SRC_COLOR: return GL_SRC_COLOR;
  83         case ONE_MINUS_SRC_COLOR: return GL_ONE_MINUS_SRC_COLOR;
  84         case SRC_ALPHA: return GL_SRC_ALPHA;
  85         case ONE_MINUS_SRC_ALPHA: return GL_ONE_MINUS_SRC_ALPHA;
  86         case DST_COLOR: return GL_DST_COLOR;
  87         case ONE_MINUS_DST_COLOR: return GL_ONE_MINUS_DST_COLOR;
  88         case DST_ALPHA: return GL_DST_ALPHA;
  89         case ONE_MINUS_DST_ALPHA: return GL_ONE_MINUS_DST_ALPHA;
  90         case CONSTANT_COLOR: return GL_CONSTANT_COLOR;
  91         case ONE_MINUS_CONSTANT_COLOR: return GL_ONE_MINUS_CONSTANT_COLOR;
  92         case CONSTANT_ALPHA: return GL_CONSTANT_ALPHA;
  93         case ONE_MINUS_CONSTANT_ALPHA: return GL_ONE_MINUS_CONSTANT_ALPHA;
  94         default: throw invalid_argument("get_gl_blend_factor");
  95         }
  96 }
  97
  98 void operator>>(const LexicalConverter &conv, BlendEquation &eq)
  99 {
 100         const string &str = conv.get();
 101         if(str=="ADD")
 102                 eq = ADD;
 103         else if(str=="SUBTRACT")
 104                 eq = SUBTRACT;
 105         else if(str=="REVERSE_SUBTRACT")
 106                 eq = REVERSE_SUBTRACT;
 107         else if(str=="MIN")
 108                 eq = MIN;
 109         else if(str=="MAX")
 110                 eq = MAX;
 111         else
 112                 throw lexical_error(format("conversion of '%s' to BlendEquation", str));
 113 }
 114
 115 void operator<<(LexicalConverter &conv, BlendEquation eq)
 116 {
 117         switch(eq)
 118         {
 119         case ADD: conv.result("ADD"); break;
 120         case SUBTRACT: conv.result("SUBTRACT"); break;
 121         case REVERSE_SUBTRACT: conv.result("REVERSE_SUBTRACT"); break;
 122         case MIN: conv.result("MIN"); break;
 123         case MAX: conv.result("MAX"); break;
 124         default: conv.result(format("BlendEquation(%#x)", static_cast<int>(eq)));
 125         }
 126 }
 127
 128 void operator>>(const LexicalConverter &conv, BlendFactor &factor)
 129 {
 130         const string &str = conv.get();
 131         if(str=="ZERO")
 132                 factor = ZERO;
 133         else if(str=="ONE")
 134                 factor = ONE;
 135         else if(str=="SRC_COLOR")
 136                 factor = SRC_COLOR;
 137         else if(str=="ONE_MINUS_SRC_COLOR")
 138                 factor = ONE_MINUS_SRC_COLOR;
 139         else if(str=="SRC_ALPHA")
 140                 factor = SRC_ALPHA;
 141         else if(str=="ONE_MINUS_SRC_ALPHA")
 142                 factor = ONE_MINUS_SRC_ALPHA;
 143         else if(str=="DST_COLOR")
 144                 factor = DST_COLOR;
 145         else if(str=="ONE_MINUS_DST_COLOR")
 146                 factor = ONE_MINUS_DST_COLOR;
 147         else if(str=="DST_ALPHA")
 148                 factor = DST_ALPHA;
 149         else if(str=="ONE_MINUS_DST_ALPHA")
 150                 factor = ONE_MINUS_DST_ALPHA;
 151         else if(str=="CONSTANT_COLOR")
 152                 factor = CONSTANT_COLOR;
 153         else if(str=="ONE_MINUS_CONSTANT_COLOR")
 154                 factor = ONE_MINUS_CONSTANT_COLOR;
 155         else if(str=="CONSTANT_ALPHA")
 156                 factor = CONSTANT_ALPHA;
 157         else if(str=="ONE_MINUS_CONSTANT_ALPHA")
 158                 factor = ONE_MINUS_CONSTANT_ALPHA;
 159         else
 160                 throw lexical_error(format("conversion of '%s' to BlendFactor", str));
 161 }
 162
 163 void operator<<(LexicalConverter &conv, BlendFactor factor)
 164 {
 165         switch(factor)
 166         {
 167         case ZERO: conv.result("ZERO"); break;
 168         case ONE: conv.result("ONE"); break;
 169         case SRC_COLOR: conv.result("SRC_COLOR"); break;
 170         case ONE_MINUS_SRC_COLOR: conv.result("ONE_MINUS_SRC_COLOR"); break;
 171         case SRC_ALPHA: conv.result("SRC_ALPHA"); break;
 172         case ONE_MINUS_SRC_ALPHA: conv.result("ONE_MINUS_SRC_ALPHA"); break;
 173         case DST_COLOR: conv.result("DST_COLOR"); break;
 174         case ONE_MINUS_DST_COLOR: conv.result("ONE_MINUS_DST_COLOR"); break;
 175         case DST_ALPHA: conv.result("DST_ALPHA"); break;
 176         case ONE_MINUS_DST_ALPHA: conv.result("ONE_MINUS_DST_ALPHA"); break;
 177         case CONSTANT_COLOR: conv.result("CONSTANT_COLOR"); break;
 178         case ONE_MINUS_CONSTANT_COLOR: conv.result("ONE_MINUS_CONSTANT_COLOR"); break;
 179         case CONSTANT_ALPHA: conv.result("CONSTANT_ALPHA"); break;
 180         case ONE_MINUS_CONSTANT_ALPHA: conv.result("ONE_MINUS_CONSTANT_ALPHA"); break;
 181         default: conv.result(format("BlendFactor(%#x)", static_cast<int>(factor)));
 182         }
 183 }
 184
 185 } // namespace GL
 186 } // namespace Msp