feat(glsl): support for const declaration

Author: MrTelanie

.eslintrc

@@ -27,6 +27,7 @@
     "no-tabs": "off",
     "no-underscore-dangle": "off",
     "prefer-spread": "off",
-    "no-shadow": "off"
+    "no-shadow": "off",
+    "no-unused-vars": "warn"
   }
 }

README.md

@@ -40,17 +40,18 @@ this can be archived with typescript, but not at runtime.
 - [ ] type inference
 - [ ] jstoGLSL transpiler great for performance
   - [x] generate valid glsl code
-  - [ ] glsl polyfills
+  - [ ] js transformations to glsl
     - [x] modulo as arithmetic operator
     - [x] pow as arithmetic operator
-    - [ ] symbols and enums
+    - [ ] variable index expression for vectors
     - [ ] destruct
+    - [ ] symbols and enums
     - [ ] functional structs
     - [ ] inline functions for map, reduce, filter
 - [x] jstoGLSL simulator great for testing
-  - [x] painting slowly to image buffer
+  - [x] painting (slowly) to image buffer
   - [x] vector arithmetic (component wise) operator support
-  - [ ] matrix algebraic operator support
+  - [x] partly matrix algebraic operator support
   - [ ] multithreading
   - [ ] typesafety
 

src/glsl/index.js

@@ -256,8 +256,8 @@ function calExp(node) {
   return `${name}(${args.map(handleNode).join(', ')})`;
 }
 
-function varDec({ declarations }) {
-  return declarations.map(handleAssign).join('; ');
+function varDec({ declarations, kind }) {
+  return declarations.map((declaration) => handleAssign(declaration, kind)).join('; ');
 }
 
 function throwError(msg, node) {
@@ -266,7 +266,7 @@ function throwError(msg, node) {
   throw error;
 }
 
-function handleAssign(node) {
+function handleAssign(node, kind) {
   const { init, id } = node;
   let { name, typeAnnotation, qualifier: q } = id;
 
@@ -295,12 +295,22 @@ function handleAssign(node) {
       allocation = handleAlloc(init, typeAnnotation, name);
     }
   }
+  if (!typeAnnotation) {
+    throwError(`
+      handleAssign() 2 no type defined for ${id.name} allocation ${allocation}
+      ${JSON.stringify(node, null, '\t')}
+    `, id);
+  }
 
   let qualifier = '';
   if (q) {
     qualifier = `${q} `;
   }
-  return `${qualifier}${typeAnnotation} ${name}${allocation}`;
+  let k = '';
+  if (kind === 'const') {
+    k = 'const ';
+  }
+  return `${k}${qualifier}${typeAnnotation} ${name}${allocation}`;
 }
 
 function handleAlloc(init, typeAnnotation, name) {

test/glsl/index.js

@@ -257,4 +257,32 @@ vec2 bar(vec2 x, float y) {
     assert.equal(glsl.trim(), expected.trim());
   });
 
+
+  it('throw an error when type is forgotten.', () => {
+    assert.throws(() => {
+      buildGLSL(() => {
+        let bar = vec2((x = vec2()) => {
+          let y = normalize(x) * 10.0;
+          return vec2(x.x, y);
+        });
+      });
+    });
+  });
+
+  it('const handling works.', () => {
+    const { glsl, ast } = buildGLSL(() => {
+      const foo = uniform(vec2(0.0));
+      const bar = vec2(0.0);
+      let baz = vec2(0.0);
+    });
+
+    console.log('ast', ast.body[0].expression.body.body);
+
+    const expected = `
+const uniform vec2 foo = vec2(0.0);
+const vec2 bar = vec2(0.0);
+vec2 baz = vec2(0.0);
+  `;
+    assert.equal(glsl.trim(), expected.trim());
+  });
 });

test/glsl/sim.js

@@ -202,6 +202,24 @@ float action(vec2 one, vec2 two) {
     assert.equal(result.w, 1);
   });
 
+  it('works fine with glsl flexible vector factories with singlee argument', () => {
+    const shader = ({ vec4, vec2 }) => {
+      let bar = vec4((x = vec2()) => {
+        return vec4(vec4(x, 1.0, 1.0));
+      });
+      return { bar };
+    };
+    const { js } = buildGLSL(shader, { js: true, glsl: false });
+
+    const { bar } = js;
+
+    const result = bar(new Vec2(3, 2));
+    assert.equal(result.x, 3);
+    assert.equal(result.y, 2);
+    assert.equal(result.z, 1);
+    assert.equal(result.w, 1);
+  });
+
   it('works fine with glsl asin multiple types.', () => {
     const shader = ({ asin, vec2 }) => {
       let bar = vec2((x = vec2()) => {
@@ -252,6 +270,22 @@ float action(vec2 one, vec2 two) {
     assert.equal(result.w, 1);
   });
 
+  it('works when using mix.', () => {
+    const shader = ({ mix, vec2 }) => {
+      let bar = vec2(() => {
+        return mix(vec2(1.0, 0.0), vec2(3.0, 6.0), 0.5);
+      });
+      return { bar };
+    };
+    const { js } = buildGLSL(shader, { js: true, glsl: false });
+
+    const { bar } = js;
+
+    const result = bar();
+    assert.equal(result.x, 2);
+    assert.equal(result.y, 3);
+  });
+
   it('works fine with sampler2D from array buffer.', () => {
 
     const buffer = new Uint8ClampedArray(2 * 1 * 4);