wip shaderc

engine/CMakeLists.txt

@@ -21,7 +21,7 @@ add_shader(shaders/depth_reduce.comp)
 add_shader(shaders/draw_cull.comp)
 add_shader(shaders/fst.vert)
 add_shader(shaders/light_cull.comp)
-add_shader(shaders/object.vsl)
+#add_shader(shaders/object.vsl)
 add_shader(shaders/shadow.vert)
 add_shader(shaders/skybox.frag)
 add_shader(shaders/skybox.vert)
@@ -40,7 +40,7 @@ function(vull_depend_builtin target)
         ${CMAKE_BINARY_DIR}/engine/shaders/draw_cull.comp.spv /shaders/draw_cull.comp
         ${CMAKE_BINARY_DIR}/engine/shaders/fst.vert.spv /shaders/fst.vert
         ${CMAKE_BINARY_DIR}/engine/shaders/light_cull.comp.spv /shaders/light_cull.comp
-        ${CMAKE_BINARY_DIR}/engine/shaders/object.vsl.spv /shaders/object
+        #${CMAKE_BINARY_DIR}/engine/shaders/object.vsl.spv /shaders/object
         ${CMAKE_BINARY_DIR}/engine/shaders/shadow.vert.spv /shaders/shadow.vert
         ${CMAKE_BINARY_DIR}/engine/shaders/skybox.frag.spv /shaders/skybox.frag
         ${CMAKE_BINARY_DIR}/engine/shaders/skybox.vert.spv /shaders/skybox.vert

engine/include/vull/core/main.hh

@@ -3,4 +3,12 @@
 #include <vull/container/vector.hh>
 #include <vull/support/string_view.hh>
 
+namespace vull {
+
+class ArgsParser;
+
+void add_engine_args(ArgsParser &args_parser);
+
+} // namespace vull
+
 void vull_main(vull::Vector<vull::StringView> &&args);

engine/include/vull/shaderc/ast.hh

@@ -70,13 +70,6 @@ enum class BinaryOp {
     SubAssign,
     MulAssign,
     DivAssign,
-
-    // Parsed-generated Muls can be turned into these by the legaliser.
-    VectorTimesScalar,
-    MatrixTimesScalar,
-    VectorTimesMatrix,
-    MatrixTimesVector,
-    MatrixTimesMatrix,
 };
 
 class BinaryExpr final : public TypedNode {
@@ -220,9 +213,9 @@ public:
     Root &operator=(const Root &) = delete;
     Root &operator=(Root &&) = delete;
 
-    template <typename U, typename... Args>
-    U *allocate(Args &&...args) {
-        return m_arena.allocate<U>(vull::forward<Args>(args)...);
+    template <typename T, typename... Args>
+    T *allocate(Args &&...args) {
+        return m_arena.allocate<T>(vull::forward<Args>(args)...);
     }
 
     void append_top_level(Node *node);

engine/include/vull/shaderc/hir.hh

@@ -0,0 +1,165 @@
+#pragma once
+
+#include <vull/container/vector.hh>
+#include <vull/shaderc/arena.hh>
+#include <vull/shaderc/type.hh>
+#include <vull/support/variant.hh>
+
+#include <stdint.h>
+
+namespace vull::shaderc::hir {
+
+enum class NodeKind {
+    FunctionDecl,
+
+    ReturnStmt,
+
+    BinaryExpr,
+    BuiltinExpr,
+    Constant,
+    UnaryExpr,
+
+    LocalVar,
+    PipelineVar,
+};
+
+class Node {
+    const NodeKind m_kind;
+
+public:
+    explicit Node(NodeKind kind) : m_kind(kind) {}
+
+    NodeKind kind() const { return m_kind; }
+};
+
+class Aggregate : public Node {
+    Vector<Node *> m_nodes;
+
+public:
+    explicit Aggregate(NodeKind kind) : Node(kind) {}
+
+    void append_node(Node *node) { m_nodes.push(node); }
+};
+
+class Expr : public Node {
+    Type m_type;
+
+public:
+    explicit Expr(NodeKind kind) : Node(kind) {}
+
+    void set_type(Type type) { m_type = type; }
+    Type type() const { return m_type; }
+};
+
+enum class SpecialFunction {
+    None,
+    VertexEntry,
+    FragmentEntry,
+};
+
+class FunctionDecl : public Node {
+    Type m_return_type;
+    Vector<Type> m_parameter_types;
+    SpecialFunction m_special_function;
+
+public:
+    SpecialFunction special_function() const { return m_special_function; }
+};
+
+class ReturnStmt : public Node {
+    Expr *m_expr;
+
+public:
+    Expr *expr() const { return m_expr; }
+};
+
+enum class BinaryOp {
+    Assign,
+    Add,
+    Sub,
+    Div,
+    Mod,
+    ScalarTimesScalar,
+    VectorTimesScalar,
+    MatrixTimesScalar,
+    VectorTimesMatrix,
+    MatrixTimesVector,
+    MatrixTimesMatrix,
+};
+
+class BinaryExpr : public Expr {
+    Expr *m_lhs;
+    Expr *m_rhs;
+    BinaryOp m_op;
+    bool m_is_assign{false};
+
+public:
+    BinaryExpr(Expr *lhs, Expr *rhs) : Expr(NodeKind::BinaryExpr), m_lhs(lhs), m_rhs(rhs) {}
+
+    void set_op(BinaryOp op) { m_op = op; }
+
+    BinaryOp op() const { return m_op; }
+    Expr *lhs() const { return m_lhs; }
+    Expr *rhs() const { return m_rhs; }
+    bool is_assign() const { return m_is_assign; }
+};
+
+enum class BuiltinFunction {
+    Dot,
+    Max,
+};
+
+class BuiltinExpr : public Expr {
+    BuiltinFunction m_function;
+
+public:
+    BuiltinExpr(BuiltinFunction function) : Expr(NodeKind::BuiltinExpr), m_function(function) {}
+
+    BuiltinFunction function() const { return m_function; }
+};
+
+class Constant : public Expr {
+    union {
+        float decimal;
+        size_t integer;
+    } m_literal;
+
+public:
+    explicit Constant(float decimal) : Expr(NodeKind::Constant), m_literal({.decimal = decimal}) {}
+    explicit Constant(size_t integer) : Expr(NodeKind::Constant), m_literal({.integer = integer}) {}
+
+    float decimal() const { return m_literal.decimal; }
+    size_t integer() const { return m_literal.integer; }
+};
+
+enum class UnaryOp {
+    Negate,
+};
+
+class UnaryExpr : public Expr {
+    Expr *m_expr;
+    UnaryOp m_op;
+
+public:
+    UnaryOp op() const { return m_op; }
+    Expr *expr() const { return m_expr; }
+};
+
+class Root {
+    Arena m_arena;
+    Vector<Node *> m_top_level_nodes;
+
+public:
+    template <typename T, typename... Args>
+    T *allocate(Args &&...args) {
+        return m_arena.allocate<T>(vull::forward<Args>(args)...);
+    }
+
+    void append_top_level(Node *node) {
+        m_top_level_nodes.push(node);
+    }
+
+    const Vector<Node *> &top_level_nodes() const { return m_top_level_nodes; }
+};
+
+} // namespace vull::shaderc::hir

engine/include/vull/shaderc/legaliser.hh

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <vull/container/hash_map.hh>
+#include <vull/shaderc/ast.hh>
+#include <vull/shaderc/hir.hh>
+#include <vull/support/result.hh>
+#include <vull/support/tuple.hh>
+#include <vull/support/unique_ptr.hh>
+
+namespace vull::shaderc {
+
+enum class LegaliseError {
+
+};
+
+class Legaliser {
+    class Scope;
+
+private:
+    hir::Root m_root;
+    Scope *m_scope{nullptr};
+    UniquePtr<Scope> m_root_scope;
+    HashMap<StringView, Tuple<hir::BuiltinFunction, Type>> m_builtin_functions;
+
+    Result<hir::Expr *, LegaliseError> lower_binary_expr(const ast::BinaryExpr &);
+    Result<hir::Expr *, LegaliseError> lower_call_expr(const ast::CallExpr &);
+    Result<hir::Expr *, LegaliseError> lower_symbol(const ast::Symbol &);
+    Result<hir::Expr *, LegaliseError> lower_expr(const ast::Node &);
+
+    Result<hir::Node *, LegaliseError> lower_function_decl(const ast::FunctionDecl &);
+    Result<hir::Node *, LegaliseError> lower_pipeline_decl(const ast::PipelineDecl &);
+    Result<hir::Node *, LegaliseError> lower_top_level(const ast::Node &);
+
+public:
+    Legaliser();
+    Legaliser(const Legaliser &) = delete;
+    Legaliser(Legaliser &&) = delete;
+    ~Legaliser();
+
+    Legaliser &operator=(const Legaliser &) = delete;
+    Legaliser &operator=(Legaliser &&) = delete;
+
+    Result<hir::Root, LegaliseError> legalise(const ast::Root &);
+};
+
+} // namespace vull::shaderc

engine/include/vull/shaderc/spv_backend.hh

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace vull::shaderc::hir {
+
+class Root;
+
+} // namespace vull::shaderc::hir
+
+namespace vull::shaderc::spv {
+
+class Builder;
+
+void build_spv(Builder &builder, const hir::Root &root);
+
+} // namespace vull::shaderc::spv

engine/include/vull/shaderc/spv_builder.hh

@@ -67,6 +67,19 @@ public:
     bool is_terminated() const;
 };
 
+class Function {
+    Builder &m_builder;
+    Instruction m_definition_inst;
+    Vector<UniquePtr<Block>> m_blocks;
+    Vector<UniquePtr<Instruction>> m_variables;
+
+public:
+    Function(Builder &builder, Id return_type, Id function_type);
+
+    Block &append_block();
+    Instruction &append_variable(Id type);
+};
+
 class Builder {
     Vector<Instruction> m_extension_imports;
     Vector<Instruction> m_decorations;

engine/sources/CMakeLists.txt

@@ -57,8 +57,10 @@ target_sources(vull-script PRIVATE
 
 target_sources(vull-shaderc PRIVATE
     shaderc/ast.cc
+    shaderc/legaliser.cc
     shaderc/lexer.cc
     shaderc/parser.cc
+    shaderc/spv_backend.cc
     shaderc/spv_builder.cc)
 
 target_sources(vull-ui PRIVATE