How to use the gl-matrix.vec3.transformMat4 function in gl-matrix

private static transformVertices(transform: mat4,
        vertices: GlyphVertices | undefined, begin: number, end: number): void {
        if (vertices === undefined || mat4.equals(transform, mat4.create())) {
            return;
        }

        for (let index: number = begin; index < end; ++index) {
            const origin = vertices.origin(index);

            const ll: vec3 = v3(); // Lower Left
            vec3.transformMat4(ll, origin, transform);
            const lr: vec3 = v3(); // Lower Right
            vec3.transformMat4(lr, vec3.add(lr, origin, vertices.tangent(index)), transform);
            const ul: vec3 = v3(); // Upper Left
            vec3.transformMat4(ul, vec3.add(ul, origin, vertices.up(index)), transform);

            vec3.copy(vertices.origin(index), ll);
            vec3.sub(vertices.tangent(index), lr, ll);
            vec3.sub(vertices.up(index), ul, ll);
        }
    }

bounds[2 + (Math.floor(i / 2) % 2)],
        bounds[4 + Math.floor(i / 4)]
      );
      vec3.transformMat4(pos, pos, keyMats.wcvc);
      vec3.normalize(dir, pos);

      // now find the projection of this point onto a
      // nearZ distance plane. Since the camera is at 0,0,0
      // in VC the ray is just t*pos and
      // t is -nearZ/dir.z
      // intersection becomes pos.x/pos.z
      const t = -crange[0] / pos[2];
      vec3.scale(pos, dir, t);

      // now convert to DC
      vec3.transformMat4(pos, pos, keyMats.vcdc);

      dcxmin = Math.min(pos[0], dcxmin);
      dcxmax = Math.max(pos[0], dcxmax);
      dcymin = Math.min(pos[1], dcymin);
      dcymax = Math.max(pos[1], dcymax);
    }
    program.setUniformf('dcxmin', dcxmin);
    program.setUniformf('dcxmax', dcxmax);
    program.setUniformf('dcymin', dcymin);
    program.setUniformf('dcymax', dcymax);

    const ext = model.currentInput.getExtent();
    const spc = model.currentInput.getSpacing();
    const vsize = vec3.create();
    vec3.set(
      vsize,

setPosition: signalRaw(function ([entity, target, isGlobal]) {
      vec3.copy(entity.transform.position, target);
      if (isGlobal && entity.parent != null) {
        // Convert world space to model space of the parent
        let parentInv = this.systems.matrix.getParentInverse(entity);
        vec3.transformMat4(
          entity.transform.position, entity.transform.position, parentInv);
      }
    }),
    translate: function (entity, target, isGlobal) {

function transformPose(light, position, direction) {
    light.getWorldMatrix(c_tmpWorldMatrix);
    if (position) {
        vec3.transformMat4(position, position, c_tmpWorldMatrix);
    }
    if (direction) {
        XML3D.math.vec3.transformDirection(direction, direction, c_tmpWorldMatrix);
        vec3.normalize(direction, direction);
    }
}

use() {
    let position = vec3.create();
    vec3.transformMat4(position, position, this.globalMatrix);
    return {
      position,
      color: this.options.color,
      intensity: new Float32Array([
        this.options.ambient, this.options.diffuse, this.options.specular,
        this.options.attenuation
      ])
    };
  }
}

publicAPI.worldToIndex = (ain, aout) => {
    const vin = vec3.fromValues(ain[0], ain[1], ain[2]);
    const vout = vec3.create();
    vec3.transformMat4(vout, vin, model.worldToIndex);
    vec3.copy(aout, vout);
  };

function worldToIndex(ain) {
    const vin = vec3.fromValues(ain[0], ain[1], ain[2]);
    const vout = vec3.create();
    vec3.transformMat4(vout, vin, model.worldToIndex);
    return [vout[0], vout[1], vout[2]];
  }

const getRotatedTourches = () => {
  const torches = [[], [], [], [], [], []];
  const vec = vec3.create();
  const vecTmp = vec3.create();

  torches[0] = model.vertexPositions;
  torches[1] = model.vertexPositions;
  for (let i = 0; i < model.vertexPositions.length / 3; i += 1) {
    vec[0] = model.vertexPositions[i * 3] - 0.5;
    vec[1] = model.vertexPositions[i * 3 + 1] - 0.5;
    vec[2] = model.vertexPositions[i * 3 + 2] - 0.5;

    let rMatr = mat4.create();
    mat4.rotateZ(rMatr, rMatr, 1.570796327 / 3);
    vec3.transformMat4(vecTmp, vec, rMatr);
    vec3.add(vecTmp, vecTmp, vec3.fromValues(0.75, 0.7, 0.5));
    torches[2].push(vecTmp[0], vecTmp[1], vecTmp[2]);

    rMatr = mat4.create();
    mat4.rotateZ(rMatr, rMatr, -1.570796327 / 3);
    vec3.transformMat4(vecTmp, vec, rMatr);
    vec3.add(vecTmp, vecTmp, vec3.fromValues(0.25, 0.7, 0.5));
    torches[3].push(vecTmp[0], vecTmp[1], vecTmp[2]);

    rMatr = mat4.create();
    mat4.rotateX(rMatr, rMatr, -1.570796327 / 3);
    vec3.transformMat4(vecTmp, vec, rMatr);
    vec3.add(vecTmp, vecTmp, vec3.fromValues(0.5, 0.7, 0.75));
    torches[4].push(vecTmp[0], vecTmp[1], vecTmp[2]);

    rMatr = mat4.create();

function transformVec3(ain, transform) {
  const vin = vec3.fromValues(ain[0], ain[1], ain[2]);
  const vout = vec3.create();
  vec3.transformMat4(vout, vin, transform);
  return [vout[0], vout[1], vout[2]];
}

updateRay() {
    vec3.copy(this._ray, this._translate);
    vec3.transformMat4(this._ray, this._ray, this.world);
    vec3.transformMat4(this._ray, this._ray, this.viewProject);
  }