gl-react/lib/Shaders.js

Universal React library, write and compose WebGL shaders, implement complex effects using a descriptive paradigm

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
exports.ensureShaderDefinition = ensureShaderDefinition;
exports.isShaderIdentifier = isShaderIdentifier;
exports.shaderDefinitionToShaderInfo = shaderDefinitionToShaderInfo;
exports.shaderInfoEquals = shaderInfoEquals;

var _invariant = _interopRequireDefault(require("invariant"));

var _GLSL = _interopRequireDefault(require("./GLSL"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const ShaderID = "ShaderID";
/**
 * An object that contains a `frag` GLSLCode.
 * @example
 *  {
 *    frag: GLSL`...`
 *  }
 */

const shaderDefinitions = {};
const shaderNames = {};
const shaderResults = {};

const genShaderId = (i => () => (++i).toString())(0);

const staticVerts = {
  "100": (0, _GLSL.default)`
attribute vec2 _p;
varying vec2 uv;
void main() {
gl_Position = vec4(_p,0.0,1.0);
uv = vec2(0.5, 0.5) * (_p+vec2(1.0, 1.0));
}`,
  "300 es": (0, _GLSL.default)`#version 300 es
in vec2 _p;
out vec2 uv;
void main() {
gl_Position = vec4(_p,0.0,1.0);
uv = vec2(0.5, 0.5) * (_p+vec2(1.0, 1.0));
}`
};

function isShaderIdentifier(shaderIdentifier) {
  return typeof shaderIdentifier === "object" && !!shaderIdentifier && shaderIdentifier.type === ShaderID && typeof shaderIdentifier.id === "string";
}

function ensureShaderDefinition(definition, ctx = "") {
  (0, _invariant.default)(definition && typeof definition.frag === "string", "A `frag` GLSL code (string) is required" + ctx);
  return definition;
}

const versionDef = "#version";

function inferGLSLVersion(glsl) {
  const i = glsl.indexOf("\n");
  const line1 = i > -1 ? glsl.slice(0, i) : glsl;

  if (line1.startsWith(versionDef)) {
    return line1.slice(versionDef.length + 1);
  }

  return "100";
}

const addGLSLName = (glsl, name) => !name ? glsl : glsl + "\n#define SHADER_NAME " + name + "\n";

function shaderDefinitionToShaderInfo({
  frag,
  vert
}, name) {
  frag = frag.trim();
  const version = inferGLSLVersion(frag);

  if (vert) {
    vert = vert.trim();
    const vertVersion = inferGLSLVersion(vert);

    if (version !== vertVersion) {
      throw new Error("GLSL shader vert and frag version must match");
    }
  } else {
    vert = staticVerts[version];

    if (!vert) {
      throw new Error("gl-react: could not find static vertex shader for GLSL version '" + version + "'");
    }
  }

  frag = addGLSLName(frag, name);
  vert = addGLSLName(vert, name);
  return {
    frag,
    vert
  };
}

function shaderInfoEquals(s1, s2) {
  return s1.frag === s2.frag && s1.vert === s2.vert;
}
/**
 * Define shaders statically.
 * @namespace
 */


const Shaders = global.__glReactShaders = global.__glReactShaders || {
  /**
   * @memberof Shaders
   * @param {ShadersDefinition} shadersDef - an object that statically define all shaders.
   * @returns {ShadersSheet}, an object map that returns a ShaderIdentifier for each shader key defined in the shaders definition.
   * @example
   *  const shaders = Shaders.create({
   *    helloGL: {
   *      frag: GLSL`...`
   *    }
   *  });
   *  ...
   *  <Node shader={shaders.helloGL} />
   */
  create(shadersDef) {
    const sheet = {};
    Object.keys(shadersDef).forEach(k => {
      const definition = ensureShaderDefinition(shadersDef[k], " in Shaders.create({ " + k + ": ... })");
      const id = genShaderId();
      const shaderId = Object.freeze({
        type: ShaderID,
        id
      });
      shaderDefinitions[id] = definition;
      shaderNames[id] = k;
      sheet[k] = shaderId;
      const result = shaderDefinitionToShaderInfo(definition, k);
      shaderResults[id] = result;
    });
    return sheet;
  },

  getName(shaderIdentifier) {
    return (shaderNames[shaderIdentifier.id] || "???") + `#${String(shaderIdentifier.id)}`;
  },

  getShortName(shaderIdentifier) {
    return shaderNames[shaderIdentifier.id] || "???";
  },

  get(shaderIdentifier) {
    (0, _invariant.default)(shaderIdentifier.id in shaderDefinitions, "Shader %s does not exist. Make sure you don't have gl-react dup issue: `npm ls gl-react`", shaderIdentifier.id);
    return shaderResults[shaderIdentifier.id];
  }

};
var _default = Shaders;
exports.default = _default;
//# sourceMappingURL=Shaders.js.map