@jscad/regl-renderer 2.6.7 → 3.0.0-alpha.0

package/src/geometry-utils-V1/csgToGeometries.js

@@ -1,220 +0,0 @@
-const vec3 = require('gl-vec3')
-
-const { toArray } = require('@jscad/array-utils')
-
-/**
- * convert a CSG from csg.js to an array of geometries with positions, normals, colors & indices
- * typically used for example to display the csg data in a webgl wiever
- * @param {Array} csgs single or an array of CSG object
- * @param {Object} options options hash
- * @param {Boolean} options.smoothLighting=false set to true if we want to use interpolated vertex normals
- * this creates nice round spheres but does not represent the shape of the actual model
- * @param {Float} options.normalThreshold=0.349066 threshold beyond which to split normals // 20 deg
- * @param {String} options.faceColor='#FF000' hex color
- * @returns {Object} {indices, positions, normals, colors}
- */
-const csgToGeometries = (csgs, options) => {
-  const defaults = {
-    smoothLighting: false, // set to true if we want to use interpolated vertex normals this creates nice round spheres but does not represent the shape of the actual model
-    normalThreshold: 0.349066, // 20 deg
-    faceColor: [1, 0.4, 0, 1]// default color
-  }
-  const { smoothLighting, normalThreshold, faceColor } = Object.assign({}, defaults, options)
-  const faceColorRgb = faceColor === undefined ? undefined : normalizedColor(faceColor) // TODO : detect if hex or rgba
-
-  const convert = (csg) => {
-    const geometries = []
-
-    const positions = []
-    const colors = []
-    const normals = []
-    const indices = []
-
-    // flag for transparency
-    let isTransparent = false
-
-    const polygons = csg.canonicalized().toPolygons()
-
-    /* let positions = new Float32Array(faces * 3 * 3)
-    let normals = new Float32Array(faces * 3 * 3) */
-
-    let normalPositionLookup = []
-    normalPositionLookup = {}
-    let tupplesIndex = 0
-
-    for (let i = 0; i < polygons.length; i++) {
-      const polygon = polygons[i]
-
-      const color = polygonColor(polygon, faceColorRgb)
-      const rawNormal = polygon.plane.normal
-      const normal = [rawNormal.x, rawNormal.y, rawNormal.z]
-
-      if (color[3] !== 1) {
-        isTransparent = true
-      }
-
-      const polygonIndices = []
-      // we need unique tupples of normal + position , that gives us a specific index (indices)
-      // if the angle between a given normal and another normal is less than X they are considered the same
-      for (let j = 0; j < polygon.vertices.length; j++) {
-        let index
-
-        const vertex = polygon.vertices[j]
-        const position = [vertex.pos.x, vertex.pos.y, vertex.pos.z]
-
-        if (smoothLighting) {
-          const candidateTupple = { normal, position }
-          const existingTupple = fuzyNormalAndPositionLookup(normalPositionLookup, candidateTupple, normalThreshold)
-          if (!existingTupple) {
-            const existingPositing = normalPositionLookup[candidateTupple.position]
-            const itemToAdd = [{ normal: candidateTupple.normal, index: tupplesIndex }]
-            if (!existingPositing) {
-              normalPositionLookup[candidateTupple.position] = itemToAdd
-            } else {
-              normalPositionLookup[candidateTupple.position] = normalPositionLookup[candidateTupple.position]
-                .concat(itemToAdd)
-            }
-            index = tupplesIndex
-            // normalPositionLookup.push(candidateTupple)
-            // index = normalPositionLookup.length - 1
-            if (faceColor !== undefined) {
-              colors.push(color)
-            }
-            normals.push(normal)
-            positions.push(position)
-            tupplesIndex += 1
-          } else {
-            index = existingTupple.index
-          }
-        } else {
-          if (faceColor !== undefined) {
-            colors.push(color)
-          }
-          normals.push(normal)
-          positions.push(position)
-          index = positions.length - 1
-        }
-
-        // let prevcolor = colors[index]
-        polygonIndices.push(index)
-      }
-
-      for (let j = 2; j < polygonIndices.length; j++) {
-        indices.push([polygonIndices[0], polygonIndices[j - 1], polygonIndices[j]])
-      }
-
-      // if too many vertices or we are at the end, start a new geometry
-      if (positions.length > 65000 || i === polygons.length - 1) {
-        // special case to deal with face color SPECICIALLY SET TO UNDEFINED
-        if (faceColor === undefined) {
-          geometries.push({
-            indices,
-            positions,
-            normals,
-            isTransparent
-          })
-        } else {
-          geometries.push({
-            indices,
-            positions,
-            normals,
-            colors,
-            isTransparent
-          })
-        }
-      }
-    }
-    return geometries
-  }
-
-  csgs = toArray(csgs)
-  const geometriesPerCsg = csgs.map(convert)
-
-  return geometriesPerCsg
-}
-
-/** determine if input is a hex (color) or not
- * @param  {Object} object a string, array, object , whatever
- * @returns {Boolean} wether the input is a hex string or not
- */
-const isHexColor = (object) => {
-  if (typeof sNum !== 'string') {
-    return false
-  }
-  return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(object)
-}
-
-// modified from https://stackoverflow.com/questions/21646738/convert-hex-to-rgba
-const hexToRgbNormalized = (hex, alpha) => {
-  hex = hex.replace('#', '')
-  const r = parseInt(hex.length === 3 ? hex.slice(0, 1).repeat(2) : hex.slice(0, 2), 16)
-  const g = parseInt(hex.length === 3 ? hex.slice(1, 2).repeat(2) : hex.slice(2, 4), 16)
-  const b = parseInt(hex.length === 3 ? hex.slice(2, 3).repeat(2) : hex.slice(4, 6), 16)
-  return (alpha ? [r, g, b, alpha] : [r, g, b, 255]).map((x) => x / 255)
-}
-
-/** outputs a normalized [0...1] range, 4 component array color
- * @param  {} input
- */
-const normalizedColor = (input) => {
-  if (isHexColor(input)) {
-    return hexToRgbNormalized(input)
-  } else if (Array.isArray(input) && input.length >= 3) {
-    input = input.length < 4 ? [input[0], input[1], input[2], 1] : input.slice(0, 4)
-    if (input[0] > 1 || input[1] > 1 || input[2] > 1) {
-      return input.map((x) => x / 255)
-    }
-    return input
-  }
-}
-
-/**
- * return the color information of a polygon
- * @param {Object} polygon a csg.js polygon
- * @param {Object} faceColor a hex color value to default to
- * @returns {Array}  `[r, g, b, a]`
- */
-const polygonColor = (polygon, faceColor) => {
-  let color = faceColor
-
-  if (polygon.shared && polygon.shared.color) {
-    color = polygon.shared.color
-  } else if (polygon.color) {
-    color = polygon.color
-  }
-  // opaque is default
-  if (color !== undefined && color.length < 4) {
-    color.push(1.0)
-  }
-  return color
-}
-
-/**
- * determine if the two given normals are 'similar' ie if the distance/angle between the
- * two is less than the given threshold
- * @param {Array} normal a 3 component array normal
- * @param {Array} otherNormal another 3 component array normal
- * @returns {Boolean} true if the two normals are similar
- */
-const areNormalsSimilar = (normal, otherNormal, threshold) => vec3.distance(normal, otherNormal) <= threshold
-// angle computation is too slow but actually precise
-// return vec3.angle(normal, otherNormal) <= threshold
-
-const fuzyNormalAndPositionLookup = (normalPositionLookup, toCompare, normalThreshold = 0.349066) => {
-  const normalsCandidates = normalPositionLookup[toCompare.position]
-  if (normalsCandidates) {
-    // normalPositionLookup[toCompare.position] = normalPositionLookup[toCompare.position].concat([toCompare.normal])
-    // get array of normals with same position
-    for (let i = 0; i < normalsCandidates.length; i++) {
-      const normal = normalsCandidates[i].normal
-      const similarNormal = areNormalsSimilar(normal, toCompare.normal, normalThreshold)
-      const similar = similarNormal
-      if (similar) {
-        return { tupple: { position: toCompare.position, normal }, index: normalsCandidates[i].index }
-      }
-    }
-  }
-  return undefined
-}
-
-module.exports = csgToGeometries

package/src/geometry-utils-V1/entitiesFromSolids.js

@@ -1,75 +0,0 @@
-const mat4 = require('gl-mat4')
-const { flatten, toArray } = require('@jscad/array-utils')
-const csgToGeometries = require('./csgToGeometries')
-const cagToGeometries = require('./cagToGeometries')
-const computeBounds = require('../bound-utils/computeBounds')
-
-const entitiesFromSolids = (params, solids) => {
-  const defaults = {
-    meshColor: [0, 0.6, 1, 1],
-    smoothNormals: true
-  }
-  const { meshColor, smoothNormals } = defaults
-  // const defaultColor = params.rendering.meshColor
-  solids = toArray(solids)
-  // warning !!! fixTJunctions alters the csg and can result in visual issues ??
-  // .fixTJunctions()
-  // cachedSolids = solids
-  // const start = performance.now()
-  const entities = solids.map((solid) => {
-    let geometry
-    let type
-    if ('sides' in solid) {
-      type = '2d'
-      geometry = cagToGeometries(solid, { color: meshColor })
-    } else if ('polygons' in solid) {
-      type = '3d'
-      geometry = csgToGeometries(solid, {
-        smoothLighting: smoothNormals,
-        normalThreshold: 0.3,
-        faceColor: meshColor
-      })//, normalThreshold: 0})
-    }
-    // geometry = flatten(geometries)// FXIME : ACTUALLY deal with arrays since a single csg can
-    // generate multiple geometries if positions count is >65535
-    geometry = flatten(geometry)[0]
-
-    // bounds
-    const bounds = computeBounds({ geometry })// FXIME : ACTUALLY deal with arrays as inputs see above
-
-    // transforms: for now not used, since all transformed are stored in the geometry
-    // FIXME : for V2 we will be able to use the transfors provided by the solids directly
-    const matrix = mat4.identity([])
-
-    const transforms = {
-      matrix
-      /* const modelViewMatrix = mat4.multiply(mat4.create(), model, props.camera.view)
-      const normalMatrix = mat4.create()
-      mat4.invert(normalMatrix, modelViewMatrix)
-      mat4.transpose(normalMatrix, normalMatrix)
-      return normalMatrix */
-    }
-
-    const visuals = {
-      drawCmd: 'drawMesh',
-      show: true,
-      color: meshColor,
-      transparent: geometry.isTransparent, // not sure
-      useVertexColors: true
-    }
-
-    const entity = {
-      type,
-      geometry,
-      transforms,
-      bounds,
-      visuals,
-      isTransparent: geometry.isTransparent
-    }
-    return entity
-  })
-  // }
-  return entities
-}
-
-module.exports = entitiesFromSolids

package/src/geometry-utils-V2/geom2ToGeometries.js

@@ -1,66 +0,0 @@
-const mat4 = require('gl-mat4')
-
-const maxIndex = Math.floor(65535 / 2) // two vertices per segment
-
-/*
- * Convert the given solid into one or more geometries for rendering.
- * @param {Object} options - options for conversion
- * @param {Array} options.color - RGBA of solid
- * @param {geom2} solid - the solid to convert
- * @return {Array} list of new geometries
- */
-const geom2ToGeometries = (options, solid) => {
-  let { color } = options
-
-  const sides = solid.sides
-  if (sides.length === 0) return []
-
-  if ('color' in solid) color = solid.color
-  const isTransparent = (color[3] < 1.0)
-  const colors = []
-  const numgeometries = Math.floor(sides.length / (maxIndex)) + 1
-
-  const addColor = (startColor, endColor) => {
-    // each line needs 2 colors: startColor and endColor
-    // endColor is optional
-    colors.push(startColor, endColor || startColor)
-  }
-
-  const geometries = []
-  for (let g = 0; g < numgeometries; g++) {
-    const offset = g * maxIndex
-    const endset = Math.min(offset + maxIndex, sides.length)
-    const positions = []
-
-    for (let i = offset; i < endset; i++) {
-      const side = sides[i]
-      if (side.color) {
-        // backfill colors, so colors array is not used unless at least one side has color defined
-        if (colors.length === 0 && positions.length > 0) {
-          const toFill = positions.length
-          for (let j = 0; j < toFill; j++) {
-            colors.push(color) // push default color
-          }
-        }
-        // shader actually allows for gradient on the lines by design
-        addColor(side.color, side.endColor)
-      } else if (colors.length) {
-        addColor(color)
-      }
-      positions.push([side[0][0], side[0][1], 0])
-      positions.push([side[1][0], side[1][1], 0])
-    }
-    // assemble the geometry
-    const normals = positions.map((x) => [0, 0, -1])
-    const indices = positions.map((x, i) => i)
-    const transforms = solid.transforms ? mat4.clone(solid.transforms) : mat4.create()
-
-    // FIXME positions should be Float32Array buffers to eliminate another conversion
-    // FIXME normals should be Float32Array buffers to eliminate another conversion
-    // FIXME indices should be Uint16Array buffers to eliminate another conversion
-    geometries.push({ type: '2d', positions, normals, indices, transforms, color, colors, isTransparent })
-  }
-  return geometries
-}
-
-module.exports = geom2ToGeometries