Adds support for basic structs

src/assignment.ts

@@ -1,8 +1,8 @@
 import Expression from './expression';
-import Variable from './variable';
-import Type from './type';
+import Interface from './interface';
 import Reference from './reference';
 import Set from './util/set';
+import Type from './type';
 
 export default class Assignment implements Expression {
     private lhs: Reference;
@@ -14,7 +14,7 @@ export default class Assignment implements Expression {
         this.rhs = rhs;
     }
 
-    public dependencies(): Set<Variable> {
+    public dependencies(): Set<Interface> {
         return this.rhs.dependencies().union(this.lhs.dependencies());
     }
 

src/block.ts

@@ -1,8 +1,8 @@
-import Variable from './variable';
 import Expression from './expression';
+import Interface from './interface';
+import Set from './util/set';
 import Statement from './statement';
 import Type from './type';
-import Set from './util/set';
 
 export default class Block implements Expression {
     private statements: Statement[];
@@ -20,11 +20,11 @@ export default class Block implements Expression {
         return Type.Void;
     }
 
-    public dependencies(): Set<Variable> {
+    public dependencies(): Set<Interface> {
         return this.statements.reduce((union, statement) => (
                 union.addAll(statement.dependencies())
             ),
-            new Set<Variable>()
+            new Set<Interface>()
         );
     }
 

src/calder.ts

@@ -33,8 +33,10 @@ export { default as Shader } from './shader';
 export { default as Qualifier } from './qualifier';
 export { default as Type } from './type';
 export { default as If } from './if'
+export { default as Interface } from './interface';
 export { default as Block } from './block'
 export { default as While } from './while'
 export { default as DoWhile } from './dowhile'
+export { default as Struct } from './struct'
 export { default as ShaderPipelineBuilder } from './shaderpipelinebuilder';
 export { default as ShaderPipeline } from './shaderpipeline';

src/function.ts

@@ -1,7 +1,7 @@
-import Variable from './variable';
-import SyntaxNode from './syntaxnode';
-import Statement from './statement';
+import Interface from './interface';
 import Set from './util/set';
+import Statement from './statement';
+import SyntaxNode from './syntaxnode';
 
 export default class Function implements SyntaxNode {
     public readonly name: string;
@@ -12,11 +12,11 @@ export default class Function implements SyntaxNode {
         this.statements = statements;
     }
 
-    public dependencies(): Set<Variable> {
+    public dependencies(): Set<Interface> {
         return this.statements.reduce((union, statement) => (
                 union.addAll(statement.dependencies())
             ),
-            new Set<Variable>()
+            new Set<Interface>()
         );
     }
 

src/if.ts

@@ -1,8 +1,8 @@
-import Variable from './variable';
-import Expression from './expression';
 import Block from './block';
-import Type from './type';
+import Expression from './expression';
+import Interface from './interface';
 import Set from './util/set';
+import Type from './type';
 
 export default class If implements Expression {
     private condition: Expression;
@@ -19,7 +19,7 @@ export default class If implements Expression {
         return Type.Void;
     }
 
-    public dependencies(): Set<Variable> {
+    public dependencies(): Set<Interface> {
         return this.condition.dependencies()
             .union(this.thenBlock.dependencies())
             .union(this.elseBlock.dependencies());

src/interface.ts

@@ -0,0 +1,27 @@
+import Hashable from './util/hashable';
+import Qualifier from './qualifier';
+import Type from './type';
+import Variable from './variable';
+
+export default class Interface implements Hashable {
+    public readonly name: string;
+    public readonly qualifier: Qualifier;
+    public readonly kind: Type;
+    private variable: Variable;
+
+    // TODO: typecheck kind
+    constructor(qualifier: Qualifier, variable: Variable) {
+        this.qualifier = qualifier;
+        this.name = variable.name;
+        this.kind = variable.kind;
+        this.variable = variable;
+    }
+
+    public declaration(): string {
+        return `${this.qualifier} ${this.variable.declaration()}`;
+    }
+
+    public hashCode(): string {
+        return this.declaration();
+    }
+}

src/reference.ts

@@ -1,16 +1,16 @@
-import Variable from './variable';
-import Type from './type';
 import Expression from './expression';
+import Interface from './interface';
 import Set from './util/set';
+import Type from './type';
 
 export default class Reference implements Expression {
-    private variable: Variable;
+    private variable: Interface;
 
-    constructor(variable: Variable) {
+    constructor(variable: Interface) {
         this.variable = variable;
     }
 
-    public dependencies(): Set<Variable> {
+    public dependencies(): Set<Interface> {
         return new Set([this.variable]);
     }
 

src/shader.ts

@@ -1,5 +1,5 @@
-import Variable from './variable';
 import Function from './function';
+import Interface from './interface';
 import Qualifier from './qualifier';
 import Type from './type';
 
@@ -8,7 +8,7 @@ export default class Shader {
 
     constructor(main: Function = new Function('main')) {
         this.main = main;
-    } 
+    }
 
     public source(): string {
         return `${this.header()}\n${this.main.source()}`;

src/statement.ts

@@ -1,6 +1,6 @@
-import SyntaxNode from './syntaxnode';
-import Variable from './variable';
+import Interface from './interface';
 import Set from './util/set';
+import SyntaxNode from './syntaxnode';
 
 export default class Statement implements SyntaxNode {
     private node: SyntaxNode;
@@ -9,7 +9,7 @@ export default class Statement implements SyntaxNode {
         this.node = node;
     }
 
-    public dependencies(): Set<Variable> {
+    public dependencies(): Set<Interface> {
         return this.node.dependencies();
     }
 

src/struct.ts

@@ -0,0 +1,34 @@
+import Interface from './interface';
+import Qualifier from './qualifier';
+import Set from './util/set';
+import SyntaxNode from './syntaxnode';
+import Variable from './variable';
+
+/**
+ * struct type-name {
+ *   members
+ * } struct-name;
+ */
+export default class Struct implements SyntaxNode {
+    public readonly name: string;
+    public readonly qualifier: Qualifier;
+    private members: Variable[];
+
+    constructor(qualifier: Qualifier, name: string, members: Variable[]) {
+        this.qualifier = qualifier
+        this.name = name;
+        this.members = members;
+    }
+
+    public dependencies(): Set<Interface> {
+        return new Set<Interface>();
+    }
+
+    public source(): string {
+        return `${this.qualifier} struct ${this.name} {` +
+            this.members
+                .map(member => member.declaration())
+                .join('\n') +
+            '};';
+    }
+}

src/syntaxnode.ts

@@ -1,7 +1,7 @@
-import Variable from './variable';
+import Interface from './interface';
 import Set from './util/set';
 
 export default interface SyntaxNode {
-    dependencies(): Set<Variable>;
+    dependencies(): Set<Interface>;
     source(): string;
 }

src/type.ts

@@ -1,4 +1,4 @@
-// TODO: Deal with structs and arrays
+// TODO: Deal with arrays
 enum Type {
     Void = 'void',
     Bool = 'bool',
@@ -17,7 +17,8 @@ enum Type {
     Mat3 = 'mat3',
     Mat4 = 'mat4',
     Sampler2D = 'sampler2D',
-    SamplerCube = 'samplerCube'
+    SamplerCube = 'samplerCube',
+    Struct = 'struct'
 }
 
 export default Type;

src/variable.ts

@@ -1,24 +1,15 @@
-import Qualifier from './qualifier';
 import Type from './type';
-import Hashable from './util/hashable';
 
-export default class Variable implements Hashable {
+export default class Variable {
     public readonly name: string;
-    public readonly qualifier: Qualifier;
     public readonly kind: Type;
 
-    // TODO: typecheck kind
-    constructor(qualifier: Qualifier, kind: Type, name: string) {
+    constructor(kind: Type, name: string) {
         this.kind = kind;
-        this.qualifier = qualifier;
         this.name = name;
     }
 
     public declaration(): string {
-        return `${this.qualifier} ${this.kind} ${this.name};`;
-    }
-
-    public hashCode(): string {
-        return this.declaration();
+        return `${this.kind} ${this.name};`;
     }
 }

src/while.ts

@@ -1,8 +1,8 @@
-import Variable from './variable';
-import Expression from './expression';
 import Block from './block';
-import Type from './type';
+import Expression from './expression';
+import Interface from './interface';
 import Set from './util/set';
+import Type from './type';
 
 export default class While implements Expression {
     protected condition: Expression;
@@ -17,7 +17,7 @@ export default class While implements Expression {
         return Type.Void;
     }
 
-    public dependencies(): Set<Variable> {
+    public dependencies(): Set<Interface> {
         return this.condition.dependencies().union(this.loopBlock.dependencies());
     }
 

test/assignment.spec.js

@@ -6,10 +6,10 @@ describe('Assignment', () => {
         it('references both the left and right hand sides', () => {
             const assignment = new cgl.Assignment(
                 new cgl.Reference(
-                    new cgl.Variable(cgl.Qualifier.In, cgl.Type.Vec4, 'lhs')
+                    new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Vec4, 'lhs'))
                 ),
                 new cgl.Reference(
-                    new cgl.Variable(cgl.Qualifier.In, cgl.Type.Vec4, 'rhs')
+                    new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Vec4, 'rhs'))
                 )
             );
 

test/block.spec.js

@@ -6,10 +6,10 @@ describe('Block', () => {
         it('references all included statements', () => {
             const block = new cgl.Block([
                 new cgl.Reference(
-                    new cgl.Variable(cgl.Qualifier.In, cgl.Type.Vec4, 'a')
+                    new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Vec4, 'a'))
                 ),
                 new cgl.Reference(
-                    new cgl.Variable(cgl.Qualifier.In, cgl.Type.Vec4, 'b')
+                    new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Vec4, 'b'))
                 )
             ]);
 
@@ -32,12 +32,12 @@ describe('Block', () => {
             const block = new cgl.Block([
                 new cgl.Statement(
                     new cgl.Reference(
-                        new cgl.Variable(cgl.Qualifier.In, cgl.Type.Vec4, 'a')
+                        new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Vec4, 'a'))
                     )
                 ),
                 new cgl.Statement(
                     new cgl.Reference(
-                        new cgl.Variable(cgl.Qualifier.In, cgl.Type.Vec4, 'b')
+                        new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Vec4, 'b'))
                     )
                 )
             ]);
@@ -57,12 +57,12 @@ describe('Block', () => {
             const block = new cgl.Block([
                 new cgl.Statement(
                     new cgl.Reference(
-                        new cgl.Variable(cgl.Qualifier.In, cgl.Type.Vec4, 'a')
+                        new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Vec4, 'a'))
                     )
                 ),
                 new cgl.Statement(
                     new cgl.Reference(
-                        new cgl.Variable(cgl.Qualifier.In, cgl.Type.Vec4, 'b')
+                        new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Vec4, 'b'))
                     )
                 )
             ]);

test/dowhile.spec.js

@@ -4,28 +4,28 @@ import * as cgl from '../src/calder';
 describe('DoWhile', () => {
     describe('dependencies', () => {
         it('includes both the then and else blocks', () => {
-            const conditionVariable = new cgl.Variable(cgl.Qualifier.In, cgl.Type.Bool, 'condition');
-            const someVariable1 = new cgl.Variable(cgl.Qualifier.In, cgl.Type.Bool, 'someVariable1');
+            const conditionInterface = new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Bool, 'condition'));
+            const someInterface1 = new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Bool, 'someInterface1'));
             const doWhileStmt = new cgl.DoWhile(
-                new cgl.Reference(conditionVariable),
+                new cgl.Reference(conditionInterface),
                 new cgl.Block([
                     new cgl.Statement(
-                        new cgl.Assignment(new cgl.Reference(conditionVariable), new cgl.Reference(someVariable1))
+                        new cgl.Assignment(new cgl.Reference(conditionInterface), new cgl.Reference(someInterface1))
                     )
                 ])
             );
 
             const dependencyNames = [...doWhileStmt.dependencies()]
                 .map(dependency => dependency.name)
                 .sort();
-            expect(dependencyNames).to.eql(['condition', 'someVariable1']);
+            expect(dependencyNames).to.eql(['condition', 'someInterface1']);
         });
     });
 
     describe('source', () => {
         it('is well formed', () => {
-            const a = new cgl.Variable(cgl.Qualifier.In, cgl.Type.Bool, 'a');
-            const b = new cgl.Variable(cgl.Qualifier.In, cgl.Type.Bool, 'b');
+            const a = new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Bool, 'a'));
+            const b = new cgl.Interface(cgl.Qualifier.In, new cgl.Variable(cgl.Type.Bool, 'b'));
             const doWhileStmt = new cgl.DoWhile(
                 new cgl.Reference(a),
                 new cgl.Block([
@@ -37,5 +37,5 @@ describe('DoWhile', () => {
 
             expect(doWhileStmt.source()).to.equalIgnoreSpaces('do { a=b; } while (a)');
         });
-    })
+    });
 });