source/glsl/output.cpp

   1 #include <msp/core/raii.h>
   2 #include <msp/strings/format.h>
   3 #include "output.h"
   4
   5 using namespace std;
   6
   7 namespace Msp {
   8 namespace GL {
   9 namespace SL {
  10
  11 Formatter::Formatter():
  12         stage(0),
  13         source_index(0),
  14         source_line(1),
  15         indent(0),
  16         parameter_list(false),
  17         omit_builtin(false)
  18 { }
  19
  20 const string &Formatter::apply(Stage &s)
  21 {
  22         stage = &s;
  23         omit_builtin = true;
  24
  25         const Version &ver = s.required_features.glsl_version;
  26
  27         if(ver)
  28         {
  29                 append(format("#version %d%02d", ver.major, ver.minor));
  30                 if(s.required_features.gl_api==OPENGL_ES2 && ver>=Version(3, 0))
  31                         append(" es");
  32                 formatted += '\n';
  33         }
  34
  35         if(s.required_features.arb_explicit_attrib_location)
  36                 append("#extension arb_explicit_attrib_location: require\n");
  37         if(s.required_features.arb_gpu_shader5)
  38                 append("#extension arb_gpu_shader5: require\n");
  39         if(s.required_features.arb_uniform_buffer_object)
  40                 append("#extension arb_uniform_buffer_object: require\n");
  41         if(s.required_features.ext_gpu_shader4)
  42                 append("#extension ext_gpu_shader4: require\n");
  43         if(s.required_features.ext_texture_array)
  44                 append("#extension ext_texture_array: require\n");
  45         formatted += '\n';
  46
  47         s.content.visit(*this);
  48
  49         return formatted;
  50 }
  51
  52 void Formatter::append(const string &text)
  53 {
  54         formatted += text;
  55         for(string::const_iterator i=text.begin(); i!=text.end(); ++i)
  56                 if(*i=='\n')
  57                         ++source_line;
  58 }
  59
  60 void Formatter::append(char c)
  61 {
  62         formatted += c;
  63         if(c=='\n')
  64                 ++source_line;
  65 }
  66
  67 void Formatter::set_source(unsigned index, unsigned line)
  68 {
  69         if(index!=source_index || (index && line!=source_line))
  70         {
  71                 if(index==source_index && line==source_line+1)
  72                         formatted += '\n';
  73                 else
  74                 {
  75                         unsigned l = line;
  76                         if(stage && stage->required_features.glsl_version && stage->required_features.glsl_version<Version(3, 30))
  77                                 --l;
  78                         formatted += format("#line %d %d\n", l, index);
  79                 }
  80         }
  81         source_index = index;
  82         source_line = line;
  83 }
  84
  85 void Formatter::visit(Block &block)
  86 {
  87         unsigned brace_indent = indent;
  88         bool use_braces = (block.use_braces || (indent && block.body.size()!=1));
  89         if(use_braces)
  90                 append(format("%s{\n", string(brace_indent*2, ' ')));
  91
  92         SetForScope<unsigned> set(indent, indent+(indent>0 || use_braces));
  93         string spaces(indent*2, ' ');
  94         bool first = true;
  95         for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
  96         {
  97                 if(omit_builtin && (*i)->source<=BUILTIN_SOURCE)
  98                         continue;
  99                 if(!first)
 100                         append('\n');
 101                 first = false;
 102                 set_source((*i)->source, (*i)->line);
 103                 append(spaces);
 104                 (*i)->visit(*this);
 105         }
 106
 107         if(use_braces)
 108                 append(format("\n%s}", string(brace_indent*2, ' ')));
 109 }
 110
 111 void Formatter::visit(Literal &literal)
 112 {
 113         append(literal.token);
 114 }
 115
 116 void Formatter::visit(ParenthesizedExpression &parexpr)
 117 {
 118         append('(');
 119         parexpr.expression->visit(*this);
 120         append(')');
 121 }
 122
 123 void Formatter::visit(VariableReference &var)
 124 {
 125         append(var.name);
 126 }
 127
 128 void Formatter::visit(InterfaceBlockReference &iface)
 129 {
 130         append(iface.name);
 131 }
 132
 133 void Formatter::visit(MemberAccess &memacc)
 134 {
 135         memacc.left->visit(*this);
 136         append(format(".%s", memacc.member));
 137 }
 138
 139 void Formatter::visit(Swizzle &swizzle)
 140 {
 141         swizzle.left->visit(*this);
 142         append(format(".%s", swizzle.component_group));
 143 }
 144
 145 void Formatter::visit(UnaryExpression &unary)
 146 {
 147         if(unary.oper->type==Operator::PREFIX)
 148                 append(unary.oper->token);
 149         unary.expression->visit(*this);
 150         if(unary.oper->type==Operator::POSTFIX)
 151                 append(unary.oper->token);
 152 }
 153
 154 void Formatter::visit(BinaryExpression &binary)
 155 {
 156         binary.left->visit(*this);
 157         append(binary.oper->token);
 158         binary.right->visit(*this);
 159         if(binary.oper->token[0]=='[')
 160                 append(']');
 161 }
 162
 163 void Formatter::visit(Assignment &assign)
 164 {
 165         assign.left->visit(*this);
 166         append(format(" %s ", assign.oper->token));
 167         assign.right->visit(*this);
 168 }
 169
 170 void Formatter::visit(TernaryExpression &ternary)
 171 {
 172         ternary.condition->visit(*this);
 173         append(ternary.oper->token);
 174         ternary.true_expr->visit(*this);
 175         if(ternary.oper->token[0]=='?')
 176                 append(':');
 177         ternary.false_expr->visit(*this);
 178 }
 179
 180 void Formatter::visit(FunctionCall &call)
 181 {
 182         append(format("%s(", call.name));
 183         for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
 184         {
 185                 if(i!=call.arguments.begin())
 186                         append(", ");
 187                 (*i)->visit(*this);
 188         }
 189         append(')');
 190 }
 191
 192 void Formatter::visit(ExpressionStatement &expr)
 193 {
 194         expr.expression->visit(*this);
 195         append(';');
 196 }
 197
 198 void Formatter::visit(Import &import)
 199 {
 200         append(format("import %s;", import.module));
 201 }
 202
 203 void Formatter::visit(Precision &prec)
 204 {
 205         append(format("precision %s %s;", prec.precision, prec.type));
 206 }
 207
 208 void Formatter::visit(Layout &layout)
 209 {
 210         append("layout(");
 211         for(vector<Layout::Qualifier>::const_iterator i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); ++i)
 212         {
 213                 if(i!=layout.qualifiers.begin())
 214                         append(", ");
 215                 append(i->name);
 216                 if(i->has_value)
 217                         append(format("=%d", i->value));
 218         }
 219         append(')');
 220 }
 221
 222 void Formatter::visit(InterfaceLayout &layout)
 223 {
 224         layout.layout.visit(*this);
 225         append(format(" %s;", layout.interface));
 226 }
 227
 228 void Formatter::visit(StructDeclaration &strct)
 229 {
 230         append(format("struct %s\n", strct.name));
 231         strct.members.visit(*this);
 232         append(';');
 233 }
 234
 235 void Formatter::visit(VariableDeclaration &var)
 236 {
 237         if(var.layout)
 238         {
 239                 var.layout->visit(*this);
 240                 append(' ');
 241         }
 242         if(var.constant)
 243                 append("const ");
 244         if(!var.interpolation.empty())
 245                 append(format("%s ", var.interpolation));
 246         if(!var.sampling.empty())
 247                 append(format("%s ", var.sampling));
 248         if(!var.interface.empty())
 249         {
 250                 string interface = var.interface;
 251                 if(stage && stage->required_features.glsl_version && stage->required_features.glsl_version<Version(1, 30))
 252                 {
 253                         if(stage->type==Stage::VERTEX && var.interface=="in")
 254                                 interface = "attribute";
 255                         else if((stage->type==Stage::VERTEX && var.interface=="out") || (stage->type==Stage::FRAGMENT && var.interface=="in"))
 256                                 interface = "varying";
 257                 }
 258                 append(format("%s ", interface));
 259         }
 260         if(!var.precision.empty())
 261                 append(format("%s ", var.precision));
 262         string type_name = var.type_declaration->name;
 263         if(var.array)
 264                 type_name = type_name.substr(0, type_name.find('['));
 265         append(format("%s %s", type_name, var.name));
 266         if(var.array)
 267         {
 268                 append('[');
 269                 if(var.array_size)
 270                         var.array_size->visit(*this);
 271                 append(']');
 272         }
 273         if(var.init_expression)
 274         {
 275                 append(" = ");
 276                 var.init_expression->visit(*this);
 277         }
 278         if(!parameter_list)
 279                 append(';');
 280 }
 281
 282 void Formatter::visit(InterfaceBlock &iface)
 283 {
 284         append(format("%s %s\n", iface.interface, iface.name));
 285         if(iface.struct_declaration)
 286                 iface.struct_declaration->members.visit(*this);
 287         if(!iface.instance_name.empty())
 288         {
 289                 append(' ');
 290                 append(iface.instance_name);
 291                 if(iface.array)
 292                         append("[]");
 293         }
 294         append(';');
 295 }
 296
 297 void Formatter::visit(FunctionDeclaration &func)
 298 {
 299         append(format("%s %s(", func.return_type_declaration->name, func.name));
 300         for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
 301         {
 302                 if(i!=func.parameters.begin())
 303                         append(", ");
 304                 SetFlag set(parameter_list);
 305                 (*i)->visit(*this);
 306         }
 307         append(')');
 308         if(func.definition==&func)
 309         {
 310                 append('\n');
 311                 func.body.visit(*this);
 312         }
 313         else
 314                 append(';');
 315 }
 316
 317 void Formatter::visit(Conditional &cond)
 318 {
 319         append("if(");
 320         cond.condition->visit(*this);
 321         append(")\n");
 322
 323         cond.body.visit(*this);
 324         if(!cond.else_body.body.empty())
 325         {
 326                 Conditional *else_cond = dynamic_cast<Conditional *>(cond.else_body.body.front().get());
 327                 if(cond.else_body.body.size()==1 && else_cond)
 328                 {
 329                         append('\n');
 330                         set_source(else_cond->source, else_cond->line);
 331                         append(format("%selse ", string(indent*2, ' ')));
 332                         else_cond->visit(*this);
 333                 }
 334                 else
 335                 {
 336                         append(format("\n%selse\n", string(indent*2, ' ')));
 337                         cond.else_body.visit(*this);
 338                 }
 339         }
 340 }
 341
 342 void Formatter::visit(Iteration &iter)
 343 {
 344         if(!iter.init_statement && iter.condition && !iter.loop_expression)
 345         {
 346                 append("while(");
 347                 iter.condition->visit(*this);
 348                 append(')');
 349         }
 350         else
 351         {
 352                 append("for(");
 353                 if(iter.init_statement)
 354                         iter.init_statement->visit(*this);
 355                 else
 356                         append(';');
 357                 if(iter.condition)
 358                 {
 359                         append(' ');
 360                         iter.condition->visit(*this);
 361                 }
 362                 append(';');
 363                 if(iter.loop_expression)
 364                 {
 365                         append(' ');
 366                         iter.loop_expression->visit(*this);
 367                 }
 368                 append(')');
 369         }
 370
 371         if(iter.body.body.empty())
 372                 append(" { }");
 373         else
 374         {
 375                 append('\n');
 376                 iter.body.visit(*this);
 377         }
 378 }
 379
 380 void Formatter::visit(Passthrough &pass)
 381 {
 382         append("passthrough");
 383         if(pass.subscript)
 384         {
 385                 append('[');
 386                 pass.subscript->visit(*this);
 387                 append(']');
 388         }
 389         append(';');
 390 }
 391
 392 void Formatter::visit(Return &ret)
 393 {
 394         append("return");
 395         if(ret.expression)
 396         {
 397                 append(' ');
 398                 ret.expression->visit(*this);
 399         }
 400         append(';');
 401 }
 402
 403 void Formatter::visit(Jump &jump)
 404 {
 405         append(jump.keyword);
 406         append(';');
 407 }
 408
 409 } // namespace SL
 410 } // namespace GL
 411 } // namespace Msp