Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
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);
}