@thi.ng/webgl 6.6.11 → 6.6.12

package/shaders/lambert.js

@@ -1,4 +1,8 @@
-import { diffuseLighting, halfLambert, lambert, } from "@thi.ng/shader-ast-stdlib/light/lambert";
+import {
+  diffuseLighting,
+  halfLambert,
+  lambert
+} from "@thi.ng/shader-ast-stdlib/light/lambert";
 import { transformMVP } from "@thi.ng/shader-ast-stdlib/matrix/mvp";
 import { surfaceNormal } from "@thi.ng/shader-ast-stdlib/matrix/normal";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
@@ -11,51 +15,78 @@ import { texture } from "@thi.ng/shader-ast/builtin/texture";
 import { defMaterial } from "../material.js";
 import { autoNormalMatrix2 } from "../matrices.js";
 import { colorAttrib, positionAttrib } from "../utils.js";
-export const LAMBERT = (opts = {}) => ({
-    vs: (gl, unis, ins, outs) => [
-        defMain(() => [
-            opts.uv ? assign(outs.vuv, ins[opts.uv]) : null,
-            assign(outs.vcolor, colorAttrib(opts, ins, unis.diffuseCol)),
-            assign(outs.vnormal, surfaceNormal(ins.normal, unis.normalMat)),
-            assign(gl.gl_Position, transformMVP(positionAttrib(opts, ins), unis.model, unis.view, unis.proj)),
-        ]),
-    ],
-    fs: (_, unis, ins, outs) => [
-        defMain(() => [
-            assign(outs.fragColor, vec4(diffuseLighting((opts.bidir !== false ? halfLambert : lambert)(normalize(ins.vnormal), unis.lightDir), opts.uv
-                ? mul($(texture(unis.tex, ins.vuv), "xyz"), ins.vcolor)
-                : ins.vcolor, unis.lightCol, unis.ambientCol), 1)),
-        ]),
-    ],
-    // pre: ALIAS_TEXTURE,
-    attribs: {
-        position: "vec3",
-        normal: "vec3",
-        ...(opts.uv ? { [opts.uv]: "vec2" } : null),
-        ...(opts.color && !opts.instanceColor
-            ? { [opts.color]: "vec3" }
-            : null),
-        ...(opts.instancePos ? { [opts.instancePos]: "vec3" } : null),
-        ...(opts.instanceColor ? { [opts.instanceColor]: "vec3" } : null),
-    },
-    varying: {
-        vcolor: "vec3",
-        vnormal: "vec3",
-        ...(opts.uv ? { vuv: "vec2" } : null),
-    },
-    uniforms: {
-        model: "mat4",
-        view: "mat4",
-        proj: "mat4",
-        normalMat: ["mat4", autoNormalMatrix2()],
-        lightDir: ["vec3", [0, 1, 0]],
-        lightCol: ["vec3", [1, 1, 1]],
-        ...defMaterial({ diffuseCol: [1, 1, 1], ...opts.material }, { specularCol: false }),
-        ...(opts.uv ? { tex: "sampler2D" } : null),
-    },
-    state: {
-        depth: true,
-        cull: true,
-        ...opts.state,
-    },
+const LAMBERT = (opts = {}) => ({
+  vs: (gl, unis, ins, outs) => [
+    defMain(() => [
+      opts.uv ? assign(outs.vuv, ins[opts.uv]) : null,
+      assign(outs.vcolor, colorAttrib(opts, ins, unis.diffuseCol)),
+      assign(outs.vnormal, surfaceNormal(ins.normal, unis.normalMat)),
+      assign(
+        gl.gl_Position,
+        transformMVP(
+          positionAttrib(opts, ins),
+          unis.model,
+          unis.view,
+          unis.proj
+        )
+      )
+    ])
+  ],
+  fs: (_, unis, ins, outs) => [
+    defMain(() => [
+      assign(
+        outs.fragColor,
+        vec4(
+          diffuseLighting(
+            (opts.bidir !== false ? halfLambert : lambert)(
+              normalize(ins.vnormal),
+              unis.lightDir
+            ),
+            opts.uv ? mul(
+              $(texture(unis.tex, ins.vuv), "xyz"),
+              ins.vcolor
+            ) : ins.vcolor,
+            unis.lightCol,
+            unis.ambientCol
+          ),
+          1
+        )
+      )
+    ])
+  ],
+  // pre: ALIAS_TEXTURE,
+  attribs: {
+    position: "vec3",
+    normal: "vec3",
+    ...opts.uv ? { [opts.uv]: "vec2" } : null,
+    ...opts.color && !opts.instanceColor ? { [opts.color]: "vec3" } : null,
+    ...opts.instancePos ? { [opts.instancePos]: "vec3" } : null,
+    ...opts.instanceColor ? { [opts.instanceColor]: "vec3" } : null
+  },
+  varying: {
+    vcolor: "vec3",
+    vnormal: "vec3",
+    ...opts.uv ? { vuv: "vec2" } : null
+  },
+  uniforms: {
+    model: "mat4",
+    view: "mat4",
+    proj: "mat4",
+    normalMat: ["mat4", autoNormalMatrix2()],
+    lightDir: ["vec3", [0, 1, 0]],
+    lightCol: ["vec3", [1, 1, 1]],
+    ...defMaterial(
+      { diffuseCol: [1, 1, 1], ...opts.material },
+      { specularCol: false }
+    ),
+    ...opts.uv ? { tex: "sampler2D" } : null
+  },
+  state: {
+    depth: true,
+    cull: true,
+    ...opts.state
+  }
 });
+export {
+  LAMBERT
+};

package/shaders/phong.js

@@ -11,64 +11,96 @@ import { dot, max, normalize, pow } from "@thi.ng/shader-ast/builtin/math";
 import { defMaterial } from "../material.js";
 import { autoNormalMatrix1 } from "../matrices.js";
 import { colorAttrib, positionAttrib } from "../utils.js";
-export const PHONG = (opts = {}) => ({
-    vs: (gl, unis, ins, outs) => [
-        defMain(() => {
-            let worldPos;
-            return [
-                (worldPos = sym(mul(unis.model, vec4(positionAttrib(opts, ins), 1)))),
-                assign(outs.vnormal, surfaceNormal(ins.normal, unis.normalMat)),
-                assign(outs.vlight, sub(unis.lightPos, $(worldPos, "xyz"))),
-                assign(outs.veye, sub(unis.eyePos, $(worldPos, "xyz"))),
-                assign(outs.vcolor, colorAttrib(opts, ins, unis.diffuseCol)),
-                assign(gl.gl_Position, mul(mul(unis.proj, unis.view), worldPos)),
-            ];
-        }),
-    ],
-    fs: (_, unis, ins, outs) => [
-        defMain(() => {
-            let normal;
-            let light;
-            let directional;
-            let specular;
-            return [
-                (normal = sym(normalize(ins.vnormal))),
-                (light = sym(normalize(ins.vlight))),
-                (directional = sym(max(dot(normal, light), FLOAT0))),
-                (specular = sym(ternary(gt(directional, FLOAT0), pow(dot(normal, normalize(add(light, normalize(ins.veye)))), unis.shininess), FLOAT0))),
-                assign(outs.fragColor, vec4(add(diffuseLighting(directional, ins.vcolor, unis.lightCol, unis.ambientCol), mul(unis.specularCol, specular)), 1)),
-            ];
-        }),
-    ],
-    attribs: {
-        position: "vec3",
-        normal: "vec3",
-        ...(opts.color && !opts.instanceColor
-            ? { [opts.color]: "vec3" }
-            : null),
-        ...(opts.instancePos ? { [opts.instancePos]: "vec3" } : null),
-        ...(opts.instanceColor ? { [opts.instanceColor]: "vec3" } : null),
-    },
-    varying: {
-        vnormal: "vec3",
-        veye: "vec3",
-        vlight: "vec3",
-        vcolor: "vec3",
-    },
-    uniforms: {
-        model: "mat4",
-        normalMat: ["mat4", autoNormalMatrix1()],
-        view: "mat4",
-        proj: "mat4",
-        shininess: ["float", 32],
-        eyePos: "vec3",
-        lightPos: ["vec3", [0, 0, 2]],
-        lightCol: ["vec3", [1, 1, 1]],
-        ...defMaterial(opts.material),
-    },
-    state: {
-        depth: true,
-        cull: true,
-        ...opts.state,
-    },
+const PHONG = (opts = {}) => ({
+  vs: (gl, unis, ins, outs) => [
+    defMain(() => {
+      let worldPos;
+      return [
+        worldPos = sym(
+          mul(unis.model, vec4(positionAttrib(opts, ins), 1))
+        ),
+        assign(outs.vnormal, surfaceNormal(ins.normal, unis.normalMat)),
+        assign(outs.vlight, sub(unis.lightPos, $(worldPos, "xyz"))),
+        assign(outs.veye, sub(unis.eyePos, $(worldPos, "xyz"))),
+        assign(outs.vcolor, colorAttrib(opts, ins, unis.diffuseCol)),
+        assign(
+          gl.gl_Position,
+          mul(mul(unis.proj, unis.view), worldPos)
+        )
+      ];
+    })
+  ],
+  fs: (_, unis, ins, outs) => [
+    defMain(() => {
+      let normal;
+      let light;
+      let directional;
+      let specular;
+      return [
+        normal = sym(normalize(ins.vnormal)),
+        light = sym(normalize(ins.vlight)),
+        directional = sym(max(dot(normal, light), FLOAT0)),
+        specular = sym(
+          ternary(
+            gt(directional, FLOAT0),
+            pow(
+              dot(
+                normal,
+                normalize(add(light, normalize(ins.veye)))
+              ),
+              unis.shininess
+            ),
+            FLOAT0
+          )
+        ),
+        assign(
+          outs.fragColor,
+          vec4(
+            add(
+              diffuseLighting(
+                directional,
+                ins.vcolor,
+                unis.lightCol,
+                unis.ambientCol
+              ),
+              mul(unis.specularCol, specular)
+            ),
+            1
+          )
+        )
+      ];
+    })
+  ],
+  attribs: {
+    position: "vec3",
+    normal: "vec3",
+    ...opts.color && !opts.instanceColor ? { [opts.color]: "vec3" } : null,
+    ...opts.instancePos ? { [opts.instancePos]: "vec3" } : null,
+    ...opts.instanceColor ? { [opts.instanceColor]: "vec3" } : null
+  },
+  varying: {
+    vnormal: "vec3",
+    veye: "vec3",
+    vlight: "vec3",
+    vcolor: "vec3"
+  },
+  uniforms: {
+    model: "mat4",
+    normalMat: ["mat4", autoNormalMatrix1()],
+    view: "mat4",
+    proj: "mat4",
+    shininess: ["float", 32],
+    eyePos: "vec3",
+    lightPos: ["vec3", [0, 0, 2]],
+    lightCol: ["vec3", [1, 1, 1]],
+    ...defMaterial(opts.material)
+  },
+  state: {
+    depth: true,
+    cull: true,
+    ...opts.state
+  }
 });
+export {
+  PHONG
+};

package/shaders/pipeline.js

@@ -3,36 +3,44 @@ import { defMain } from "@thi.ng/shader-ast/ast/function";
 import { FLOAT0, FLOAT1, vec4 } from "@thi.ng/shader-ast/ast/lit";
 import { $xy } from "@thi.ng/shader-ast/ast/swizzle";
 import { texture } from "@thi.ng/shader-ast/builtin/texture";
-export const PASSTHROUGH_VS = (gl, _, ins) => [
-    defMain(() => [assign(gl.gl_Position, vec4(ins.position, FLOAT0, FLOAT1))]),
+const PASSTHROUGH_VS = (gl, _, ins) => [
+  defMain(() => [assign(gl.gl_Position, vec4(ins.position, FLOAT0, FLOAT1))])
 ];
-export const PASSTHROUGH_VS_UV = (gl, _, ins, outs) => [
-    defMain(() => [
-        assign(outs.v_uv, ins.uv),
-        assign(gl.gl_Position, vec4(ins.position, FLOAT0, FLOAT1)),
-    ]),
+const PASSTHROUGH_VS_UV = (gl, _, ins, outs) => [
+  defMain(() => [
+    assign(outs.v_uv, ins.uv),
+    assign(gl.gl_Position, vec4(ins.position, FLOAT0, FLOAT1))
+  ])
 ];
-export const PASSTHROUGH_FS = (gl, _, __, outs) => [
-    defMain(() => [assign(outs.fragColor, $xy(gl.gl_FragCoord))]),
+const PASSTHROUGH_FS = (gl, _, __, outs) => [
+  defMain(() => [assign(outs.fragColor, $xy(gl.gl_FragCoord))])
 ];
-export const PASSTHROUGH_FS_UV = (_, unis, ins, outs) => [
-    defMain(() => [assign(outs.fragColor, texture(unis.tex, ins.v_uv))]),
+const PASSTHROUGH_FS_UV = (_, unis, ins, outs) => [
+  defMain(() => [assign(outs.fragColor, texture(unis.tex, ins.v_uv))])
 ];
-export const FX_SHADER_SPEC = {
-    vs: PASSTHROUGH_VS,
-    fs: PASSTHROUGH_FS,
-    attribs: { position: "vec2" },
-    varying: {},
-    uniforms: {},
-    state: { depth: false },
-    ext: {},
+const FX_SHADER_SPEC = {
+  vs: PASSTHROUGH_VS,
+  fs: PASSTHROUGH_FS,
+  attribs: { position: "vec2" },
+  varying: {},
+  uniforms: {},
+  state: { depth: false },
+  ext: {}
 };
-export const FX_SHADER_SPEC_UV = {
-    vs: PASSTHROUGH_VS_UV,
-    fs: PASSTHROUGH_FS_UV,
-    attribs: { position: "vec2", uv: "vec2" },
-    varying: { v_uv: "vec2" },
-    uniforms: { tex: "sampler2D" },
-    state: { depth: false },
-    ext: {},
+const FX_SHADER_SPEC_UV = {
+  vs: PASSTHROUGH_VS_UV,
+  fs: PASSTHROUGH_FS_UV,
+  attribs: { position: "vec2", uv: "vec2" },
+  varying: { v_uv: "vec2" },
+  uniforms: { tex: "sampler2D" },
+  state: { depth: false },
+  ext: {}
+};
+export {
+  FX_SHADER_SPEC,
+  FX_SHADER_SPEC_UV,
+  PASSTHROUGH_FS,
+  PASSTHROUGH_FS_UV,
+  PASSTHROUGH_VS,
+  PASSTHROUGH_VS_UV
 };

package/syntax.js

@@ -1,91 +1,69 @@
 import { isArray } from "@thi.ng/checks/is-array";
 import { GLSLVersion } from "@thi.ng/shader-ast-glsl/api";
-export const PREFIXES = {
-    a: "a_",
-    v: "v_",
-    u: "u_",
-    o: "o_",
+const PREFIXES = {
+  a: "a_",
+  v: "v_",
+  u: "u_",
+  o: "o_"
 };
-export const NO_PREFIXES = {
-    a: "",
-    v: "",
-    u: "",
-    o: "",
+const NO_PREFIXES = {
+  a: "",
+  v: "",
+  u: "",
+  o: ""
 };
-/**
- * GLSL data declaration code generators.
- */
-export const SYNTAX = {
-    /**
-     * WebGL (GLSL ES 1.0)
-     */
-    [GLSLVersion.GLES_100]: {
-        number: 100,
-        attrib: (id, type, pre) => `attribute ${isArray(type) ? type[0] : type} ${pre.a}${id};`,
-        varying: {
-            vs: (id, type, pre) => arrayDecl("varying", type, pre.v + id),
-            fs: (id, type, pre) => arrayDecl("varying", type, pre.v + id),
-        },
-        uniform: (id, u, pre) => arrayDecl("uniform", u, pre.u + id),
-        output: (id, type, pre) => isArray(type)
-            ? `#define ${pre.o}${id} gl_FragData[${type[1]}]`
-            : "",
+const SYNTAX = {
+  /**
+   * WebGL (GLSL ES 1.0)
+   */
+  [GLSLVersion.GLES_100]: {
+    number: 100,
+    attrib: (id, type, pre) => `attribute ${isArray(type) ? type[0] : type} ${pre.a}${id};`,
+    varying: {
+      vs: (id, type, pre) => arrayDecl("varying", type, pre.v + id),
+      fs: (id, type, pre) => arrayDecl("varying", type, pre.v + id)
     },
-    /**
-     * WebGL 2 (GLSL ES 3)
-     */
-    [GLSLVersion.GLES_300]: {
-        number: 300,
-        attrib: (id, type, pre) => isArray(type)
-            ? `layout(location=${type[1]}) in ${type[0]} ${pre.a}${id};`
-            : `in ${type} ${pre.a}${id};`,
-        varying: {
-            vs: (id, type, pre) => arrayDecl("out", type, pre.v + id),
-            fs: (id, type, pre) => arrayDecl("in", type, pre.v + id),
-        },
-        uniform: (id, u, pre) => arrayDecl("uniform", u, pre.u + id),
-        output: (id, type, pre) => isArray(type)
-            ? `layout(location=${type[1]}) out ${type[0]} ${pre.o}${id};`
-            : `out ${type} ${pre.o}${id};`,
+    uniform: (id, u, pre) => arrayDecl("uniform", u, pre.u + id),
+    output: (id, type, pre) => isArray(type) ? `#define ${pre.o}${id} gl_FragData[${type[1]}]` : ""
+  },
+  /**
+   * WebGL 2 (GLSL ES 3)
+   */
+  [GLSLVersion.GLES_300]: {
+    number: 300,
+    attrib: (id, type, pre) => isArray(type) ? `layout(location=${type[1]}) in ${type[0]} ${pre.a}${id};` : `in ${type} ${pre.a}${id};`,
+    varying: {
+      vs: (id, type, pre) => arrayDecl("out", type, pre.v + id),
+      fs: (id, type, pre) => arrayDecl("in", type, pre.v + id)
     },
+    uniform: (id, u, pre) => arrayDecl("uniform", u, pre.u + id),
+    output: (id, type, pre) => isArray(type) ? `layout(location=${type[1]}) out ${type[0]} ${pre.o}${id};` : `out ${type} ${pre.o}${id};`
+  }
 };
 const arrayDecl = (qualifier, decl, id) => {
-    const type = isArray(decl) ? decl[0] : decl;
-    return type.indexOf("[]") > 0
-        ? `${qualifier} ${type.replace("[]", "")} ${id}[${decl[1]}];`
-        : `${qualifier} ${type} ${id};`;
+  const type = isArray(decl) ? decl[0] : decl;
+  return type.indexOf("[]") > 0 ? `${qualifier} ${type.replace("[]", "")} ${id}[${decl[1]}];` : `${qualifier} ${type} ${id};`;
 };
-/**
- * GLSL preprocessor macro for conditional execution based on `__VERSION__`.
- *
- * @param ver -
- * @param ok -
- * @param fail -
- */
-export const VERSION_CHECK = (ver, ok, fail = "") => {
-    let cmp = ">=";
-    if (!ok) {
-        ok = fail;
-        fail = null;
-        cmp = "<";
-    }
-    return `#if __VERSION__ ${cmp} ${ver}
-${ok}${fail ? `\n#else\n${fail}` : ""}
+const VERSION_CHECK = (ver, ok, fail = "") => {
+  let cmp = ">=";
+  if (!ok) {
+    ok = fail;
+    fail = null;
+    cmp = "<";
+  }
+  return `#if __VERSION__ ${cmp} ${ver}
+${ok}${fail ? `
+#else
+${fail}` : ""}
 #endif`;
 };
-export const ALIAS_TEXTURE = VERSION_CHECK(300, "", "#define texture texture2D");
-/**
- * GLSL version specific fragment shader output. If `__VERSION__ >= 300`
- * assigns `body` to `out`, else to `gl_FragColor`.
- *
- * @param body -
- * @param out -
- */
-export const EXPORT_FRAGCOL = (body = "col", out = "o_fragColor") => VERSION_CHECK(300, `${out}=${body};`, `gl_FragColor=${body};`);
-/**
- * Default GLSL prelude.
- */
-export const GLSL_HEADER = `#ifdef GL_FRAGMENT_PRECISION_HIGH
+const ALIAS_TEXTURE = VERSION_CHECK(
+  300,
+  "",
+  "#define texture texture2D"
+);
+const EXPORT_FRAGCOL = (body = "col", out = "o_fragColor") => VERSION_CHECK(300, `${out}=${body};`, `gl_FragColor=${body};`);
+const GLSL_HEADER = `#ifdef GL_FRAGMENT_PRECISION_HIGH
 precision highp int;
 precision highp float;
 #else
@@ -102,3 +80,12 @@ precision mediump float;
 #define HALF_PI 1.570796326794896
 #endif
 `;
+export {
+  ALIAS_TEXTURE,
+  EXPORT_FRAGCOL,
+  GLSL_HEADER,
+  NO_PREFIXES,
+  PREFIXES,
+  SYNTAX,
+  VERSION_CHECK
+};