source/glsl/generate.h

   1 #ifndef MSP_GL_SL_GENERATE_H_
   2 #define MSP_GL_SL_GENERATE_H_
   3
   4 #include <map>
   5 #include <set>
   6 #include <string>
   7 #include <vector>
   8 #include "visitor.h"
   9
  10 namespace Msp {
  11 namespace GL {
  12 namespace SL {
  13
  14 /** Assigns IDs to specialization constants with an automatic ID. */
  15 class ConstantIdAssigner: private TraversingVisitor
  16 {
  17 private:
  18         std::set<unsigned> used_ids;
  19         std::map<std::string, unsigned> existing_constants;
  20         std::vector<VariableDeclaration *> auto_constants;
  21
  22 public:
  23         void apply(Module &, const Features &);
  24
  25 private:
  26         virtual void visit(VariableDeclaration &);
  27 };
  28
  29 /** Materializes implicitly declared interfaces.
  30
  31 Out variable declarations inside functions are moved to the global scope.
  32
  33 Passthrough statements are processed, generating out variables to match in
  34 variables and copying values.
  35
  36 Unresolved variables are looked up in the previous stage's out variables. */
  37 class InterfaceGenerator: private TraversingVisitor
  38 {
  39 private:
  40         Stage *stage = 0;
  41         std::string in_prefix;
  42         std::string out_prefix;
  43         bool function_scope = false;
  44         bool copy_block = false;
  45         std::vector<VariableDeclaration *> declared_inputs;
  46         Block *iface_target_block = 0;
  47         NodeList<Statement>::iterator iface_insert_point;
  48         NodeList<Statement>::iterator assignment_insert_point;
  49         std::set<Node *> nodes_to_remove;
  50
  51 public:
  52         void apply(Stage &);
  53
  54 private:
  55         static std::string get_out_prefix(Stage::Type);
  56         std::string change_prefix(const std::string &, const std::string &) const;
  57         virtual void visit(Block &);
  58         VariableDeclaration *generate_interface(VariableDeclaration &, const std::string &, const std::string &);
  59         ExpressionStatement &insert_assignment(const std::string &, Expression *);
  60         virtual void visit(VariableReference &);
  61         virtual void visit(VariableDeclaration &);
  62         virtual void visit(FunctionDeclaration &);
  63         virtual void visit(Passthrough &);
  64 };
  65
  66 class LayoutDefaulter: private TraversingVisitor
  67 {
  68 private:
  69         InterfaceLayout *in_iface = 0;
  70         bool need_winding = true;
  71         bool need_spacing = true;
  72
  73 public:
  74         void apply(Stage &);
  75
  76 private:
  77         virtual void visit(InterfaceLayout &);
  78 };
  79
  80 /**
  81 Assigns sizes to arrays which don't have a size.  Geometry shader inputs are
  82 sized by topology.  Other arrays are sized by their use with literal indices.
  83 */
  84 class ArraySizer: private TraversingVisitor
  85 {
  86 private:
  87         std::map<VariableDeclaration *, int> max_indices;
  88         unsigned input_size = 0;
  89         VariableDeclaration *r_declaration;
  90
  91 public:
  92         void apply(Stage &);
  93
  94 private:
  95         virtual void visit(VariableReference &);
  96         virtual void visit(MemberAccess &);
  97         virtual void visit(Swizzle &);
  98         virtual void visit(UnaryExpression&);
  99         virtual void visit(BinaryExpression &);
 100         virtual void visit(TernaryExpression &);
 101         virtual void visit(FunctionCall &);
 102         virtual void visit(InterfaceLayout &);
 103         virtual void visit(VariableDeclaration &);
 104 };
 105
 106 } // namespace SL
 107 } // namespace GL
 108 } // namespace Msp
 109
 110 #endif