TypeScript mat4.identity方法代码示例

  public draw(camera: Camera | PerspectiveCamera | OrthographicCamera) {
    if (!this.visible) return;
    gl = GL.get();

    // Update modelMatrix
    this.updateMatrix(camera);

    // Update
    mat4.identity(projectionViewMatrix);
    mat4.identity(modelWorldMatrix);

    mat4.mul(
      projectionViewMatrix,
      camera.projectionMatrix,
      this.modelViewMatrix
    );

    let screenPosition;
    let vertex;
    this._labels.forEach((label, i) => {
      vertex = this._parentMesh.geometry.vertices[label.indice];
      screenPosition = from3DTo2D(vertex, projectionViewMatrix);
      label.element.style.left = `${screenPosition.x * window.innerWidth}px`;
      label.element.style.top = `${screenPosition.y * window.innerHeight}px`;
      label.element.innerHTML = `${label.indice}`;
    });

    this.material.program.bind();
    this.material.setUniforms(
      camera.projectionMatrix,
      this.modelViewMatrix,
      this.modelMatrix,
      camera
    );

    if (extensions.vertexArrayObject) {
      this.vao.bind();
    } else {
      this.bindAttributes();
      this.bindAttributesInstanced();
      this.bindIndexBuffer();
    }

    gl.drawArrays(
      gl.POINTS,
      0,
      this.geometry.attributes.aVertexPosition.numItems
    );

    if (extensions.vertexArrayObject) {
      this.vao.unbind();
    }
  }

 public updateMatrixWorld() {
   mat4.identity(this.worldInverseMatrix);
   mat4.lookAt(
     this.worldInverseMatrix,
     this.position.v,
     this.target.v,
     this.up.v
   );
 }

  public updateMatrix(camera: Camera | PerspectiveCamera | OrthographicCamera) {
    mat4.identity(this.modelViewMatrix);

    if (this.matrixAutoUpdate) {
      // Reset
      mat4.identity(this.localMatrix);
      mat4.identity(this.modelMatrix);
      quat.identity(this.quaternion);

      // If Object3D has a parent, copy the computed modelMatrix into localMatrix
      if (this.parent) {
        mat4.copy(this.localMatrix, this.parent.modelMatrix);
        mat4.multiply(this.modelMatrix, this.modelMatrix, this.localMatrix);
      }

      // Use lookAt quat as base
      // Note: this.rotation isn't updated if lookAt's used
      quat.copy(this.quaternion, this.quaternionLookAt);

      // Apply local transitions to modelMatrix
      mat4.translate(this.modelMatrix, this.modelMatrix, this.position.v);
      quat.rotateX(this.quaternion, this.quaternion, this.rotation.x);
      quat.rotateY(this.quaternion, this.quaternion, this.rotation.y);
      quat.rotateZ(this.quaternion, this.quaternion, this.rotation.z);
      axisAngle = quat.getAxisAngle(quaternionAxisAngle, this.quaternion);
      mat4.rotate(
        this.modelMatrix,
        this.modelMatrix,
        axisAngle,
        quaternionAxisAngle
      );
      mat4.scale(this.modelMatrix, this.modelMatrix, this.scale.v);
    }

    // Model View Matrix
    if (camera) {
      mat4.multiply(
        this.modelViewMatrix,
        camera.worldInverseMatrix,
        this.modelMatrix
      );
    }
  }

outVal = mat3.frob(mat3A);
outMat3 = mat3.add(outMat3, mat3A, mat3B);
outMat3 = mat3.subtract(outMat3, mat3A, mat3B);
outMat3 = mat3.sub(outMat3, mat3A, mat3B);
outMat3 = mat3.multiplyScalar (outMat3, mat3A, 2);
outMat3 = mat3.multiplyScalarAndAdd (outMat3, mat3A, mat3B, 2);
outBool = mat3.exactEquals(mat3A, mat3B);
outBool = mat3.equals(mat3A, mat3B);

//mat4
outMat4 = mat4.create();
outMat4 = mat4.clone(mat4A);
outMat4 = mat4.copy(outMat4, mat4A);
outMat4 = mat4.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
outMat4 = mat4.set(outMat4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
outMat4 = mat4.identity(outMat4);
outMat4 = mat4.transpose(outMat4, mat4A);
outMat4Null = mat4.invert(outMat4, mat4A);
outMat4 = mat4.adjoint(outMat4, mat4A);
outVal = mat4.determinant(mat4A);
outMat4 = mat4.multiply(outMat4, mat4A, mat4B);
outMat4 = mat4.mul(outMat4, mat4A, mat4B);
outMat4 = mat4.translate(outMat4, mat4A, vec3A);
outMat4 = mat4.scale(outMat4, mat4A, vec3A);
outMat4Null = mat4.rotate(outMat4, mat4A, Math.PI, vec3A);
outMat4 = mat4.rotateX(outMat4, mat4A, Math.PI);
outMat4 = mat4.rotateY(outMat4, mat4A, Math.PI);
outMat4 = mat4.rotateZ(outMat4, mat4A, Math.PI);
outMat4 = mat4.fromTranslation(outMat4, vec3A);
outMat4Null = mat4.fromRotation(outMat4, Math.PI, vec3A);
outMat4 = mat4.fromScaling(outMat4, vec3A);

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

export {vec2, vec3, vec4, mat3, mat4, quat} from 'gl-matrix';
import {vec3, vec4, mat4} from 'gl-matrix';

export type Vec2 = Float32Array;
export type Vec3 = Float32Array;
export type Vec4 = Float32Array;
export type Mat3 = Float32Array;
export type Mat4 = Float32Array;
export type Quat = Float32Array;

export const identityMat4 = mat4.create();
mat4.identity(identityMat4);

export const AXES_NAMES = ['x', 'y', 'z'];

export class BoundingBox {
  constructor(public lower: Vec3, public upper: Vec3) {}
};

export const kAxes = [
  vec4.fromValues(1, 0, 0, 0), vec4.fromValues(0, 1, 0, 0),
  vec4.fromValues(0, 0, 1, 0)
];
export const kZeroVec = vec3.fromValues(0, 0, 0);

export function prod3(x: ArrayLike<number>) {
  return x[0] * x[1] * x[2];

//.........这里部分代码省略.........
            uniform.value[1],
            uniform.value[2]
          );
          break;
        }
        case '4f': {
          gl.uniform4f(
            uniform.location,
            uniform.value[0],
            uniform.value[1],
            uniform.value[2],
            uniform.value[3]
          );
          break;
        }
        case '1iv': {
          gl.uniform1iv(uniform.location, uniform.value);
          break;
        }
        case '2iv': {
          gl.uniform2iv(uniform.location, uniform.value);
          break;
        }
        case '1fv': {
          gl.uniform1fv(uniform.location, uniform.value);
          break;
        }
        case '2fv': {
          gl.uniform2fv(uniform.location, uniform.value);
          break;
        }
        case '3fv': {
          gl.uniform3fv(uniform.location, uniform.value);
          break;
        }
        case '4fv': {
          gl.uniform4fv(uniform.location, uniform.value);
          break;
        }
        case 'Matrix3fv': {
          gl.uniformMatrix3fv(uniform.location, false, uniform.value);
          break;
        }
        case 'Matrix4fv': {
          gl.uniformMatrix4fv(uniform.location, false, uniform.value);
          break;
        }
        default:
      }
    });

    if (!GL.webgl2) {
      gl.uniformMatrix4fv(
        this.uniforms.uProjectionMatrix.location,
        false,
        projectionMatrix
      );
    }

    gl.uniformMatrix4fv(
      this.uniforms.uModelViewMatrix.location,
      false,
      modelViewMatrix
    );
    gl.uniformMatrix4fv(
      this.uniforms.uModelMatrix.location,
      false,
      modelMatrix
    );

    mat4.identity(inversedModelViewMatrix);
    mat4.invert(inversedModelViewMatrix, modelMatrix);

    mat3.identity(normalMatrix);
    mat3.fromMat4(normalMatrix, inversedModelViewMatrix);
    mat3.transpose(normalMatrix, normalMatrix);
    gl.uniformMatrix3fv(
      this.uniforms.uNormalMatrix.location,
      false,
      normalMatrix
    );

    // uDiffuse
    gl.uniform3f(
      this.uniforms.uDiffuse.location,
      this.uniforms.uDiffuse.value[0],
      this.uniforms.uDiffuse.value[1],
      this.uniforms.uDiffuse.value[2]
    );

    // Camera
    if (camera && this.uniforms.uCameraPosition) {
      gl.uniform3f(
        this.uniforms.uCameraPosition.location,
        camera.position.v[0],
        camera.position.v[1],
        camera.position.v[2]
      );
    }
  }