points-to-vertices/dist/pointsToVertices.js

:white_square_button: a points to vertices array convertor

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global.pointsToVertices = factory());
}(this, (function () { 'use strict';

var mapChannel = (function (channel) {
  return channel / 255;
});

var normalize$1 = (function (min, max, value) {
  if (value < min) return min;else if (value > max) return max;else return value;
});

var rgbToVec4 = (function (color) {

  var alpha = false;

  if (color.startsWith('rgba(')) alpha = true;else if (color.startsWith('rgb(')) alpha = false;

  var split = alpha ? 'rgba(' : 'rgb(';

  var channels = color.split(split)[1].split(')')[0].split(',');
  if (channels.length < 3 || channels.length > 4) {
    throw new Error(color + ' is not a valid rgb(a) color');
  }

  channels = channels.map(function (c) {
    return parseFloat(c);
  }).map(function (c) {
    return normalize$1(0, 255, c);
  });

  var _channels = channels,
      r = _channels[0],
      g = _channels[1],
      b = _channels[2],
      _channels$ = _channels[3],
      a = _channels$ === undefined ? 1 : _channels$;

  var aa = normalize$1(0, 1, a);

  var rgb = [r, g, b].map(mapChannel);

  return [].concat(rgb, [aa]);
});

var hexToRgb = (function (hex) {

  var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
  result = result.slice(1, 4);
  result = result.map(function (r) {
    return parseInt(r, 16);
  });

  var _result = result,
      r = _result[0],
      g = _result[1],
      b = _result[2];

  var a = 1;

  return { r: r, g: g, b: b, a: a };
});

var hexToVec4 = (function (color) {

  var isValid = /^#[0-9A-F]{6}$/i.test(color);

  if (!isValid) {
    throw new Error(color + ' is not a valid hex color');
  }

  var colorObj = hexToRgb(color);
  var r = colorObj.r,
      g = colorObj.g,
      b = colorObj.b;

  var colors = [r, g, b];

  return [].concat(colors.map(function (c) {
    return mapChannel(c);
  }), [1]);
});

var colorToVec4 = (function (color) {

  if (typeof color === 'string') {

    if (color.startsWith('rgba')) return rgbToVec4(color);else if (color.startsWith('rgb')) return rgbToVec4(color);else if (color.startsWith('#')) return hexToVec4(color);else throw new Error(color + ' is not a valid color, must be rgba, rgb, hex or vec4');
  } else if (Array.isArray(color)) {
    if (color.length !== 4) {
      throw new Error('[' + color + '] is not a valid vec4');
    }
    return color;
  } else {
    throw new Error(color + ' is not a valid color, must be rgba, rgb, hex or vec4');
  }
});

var normalize = function normalize(min, max, value) {
  if (value < min) return min;else if (value > max) return max;
  return value;
};

var pointToVertex = (function (point) {
  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      _ref$color = _ref.color,
      color = _ref$color === undefined ? true : _ref$color,
      _ref$dx = _ref.dx,
      dx = _ref$dx === undefined ? 0 : _ref$dx,
      _ref$dy = _ref.dy,
      dy = _ref$dy === undefined ? 0 : _ref$dy,
      _ref$dz = _ref.dz,
      dz = _ref$dz === undefined ? 0 : _ref$dz,
      _ref$dcolor = _ref.dcolor,
      dcolor = _ref$dcolor === undefined ? [0, 0, 0, 1] : _ref$dcolor;

  var _point$x = point.x,
      x = _point$x === undefined ? dx : _point$x,
      _point$y = point.y,
      y = _point$y === undefined ? dy : _point$y,
      _point$z = point.z,
      z = _point$z === undefined ? dz : _point$z;


  x = normalize(-1, 1, x);
  y = normalize(-1, 1, y);
  z = normalize(-1, 1, z);

  var _point$color = point.color,
      pColor = _point$color === undefined ? dcolor : _point$color;


  if (pColor && color) {
    var colorVec = colorToVec4(pColor);
    // [x, y, z, r, g, b, a]
    return [x, y, z].concat(colorVec);
  } else {
    // [x, y, z]
    return [x, y, z];
  }
});

var flatten = (function (arr) {
  return [].concat.apply([], arr);
});

var index = (function (points) {
  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      _ref$color = _ref.color,
      color = _ref$color === undefined ? true : _ref$color,
      _ref$dx = _ref.dx,
      dx = _ref$dx === undefined ? 0 : _ref$dx,
      _ref$dy = _ref.dy,
      dy = _ref$dy === undefined ? 0 : _ref$dy,
      _ref$dz = _ref.dz,
      dz = _ref$dz === undefined ? 0 : _ref$dz,
      _ref$dcolor = _ref.dcolor,
      dcolor = _ref$dcolor === undefined ? [0, 0, 0, 1] : _ref$dcolor,
      _ref$meta = _ref.meta,
      meta = _ref$meta === undefined ? false : _ref$meta;

  var options = {
    color: color, dx: dx, dy: dy, dz: dz, dcolor: dcolor, meta: meta
  };

  var vertices = flatten(points.map(function (p) {
    return pointToVertex(p, options);
  }));

  if (meta) {

    var _meta = {};
    _meta.vertexLength = color ? 7 : 3;
    _meta.amount = vertices.length / _meta.vertexLength;
    _meta.position = { start: 0, length: 3 };
    if (color) _meta.color = { start: 3, length: 4 };
    return { data: vertices, meta: _meta };
  } else {
    return vertices;
  }
});

return index;

})));