TypeScript vec3.clone方法代码示例

    moveAlong(elapsedTime: number, speed: number): Vec3 {
        // If there is no further waypoint, we've arrived at the end and we
        // always return the current position.
        if (this.done) {
            return vec3.clone(this.currentPosition);
        }

        // The vector from the current position to the next waypoint.
        var vector        = vec3.subtract(vec3.create(), this.waypoints[0], this.currentPosition)
          , vectorLength  = vec3.length(vector)
          , distanceMoved = speed * elapsedTime;

        if (vectorLength < distanceMoved) {
            // The remaining distance in the current segment is less than what
            // we moved, jump to the next waypoint and move along the next path
            // segment from there.

            vec3.copy(this.currentPosition, this.waypoints.shift());
            this.currentHeading = normalizeHeading(Math.atan2(vector[1], vector[0]));

            return this.moveAlong(elapsedTime - vectorLength / speed, speed);
        }

        // We have not yet reached the next waypoint. Move along the vector
        // towards it and update the heading.
        vec3.add(this.currentPosition, this.currentPosition, vec3.scale(vec3.create(), vec3.normalize(vec3.create(), vector), distanceMoved));
        this.currentHeading = normalizeHeading(Math.atan2(vector[1], vector[0]));

        return vec3.clone(this.currentPosition);
    }

    constructor
      ( public terrain    : Terrain
        // ^ MUST be the terrain where 'start_pos' is located in.

      , public from       : HalfEdgeFace
      , public to         : HalfEdgeFace
      , public start_pos  : TerrainPosition
      , public target_pos : TerrainPosition
      ) {
        this._open_list   = {};
        this._closed_list = {};
        this._path_length = {};
        this._cost_map    = {};

        this._current_pos = vec3.clone(getWorldCoordinates(this.terrain, this.start_pos));
    }

outVec2 = vec2.lerp(outVec2, vec2A, vec2B, 0.5);
outVec2 = vec2.random(outVec2);
outVec2 = vec2.random(outVec2, 5.0);
outVec2 = vec2.transformMat2(outVec2, vec2A, mat2A);
outVec2 = vec2.transformMat2d(outVec2, vec2A, mat2dA);
outVec2 = vec2.transformMat3(outVec2, vec2A, mat3A);
outVec2 = vec2.transformMat4(outVec2, vec2A, mat4A);
vecArray = vec2.forEach(vecArray, 0, 0, 0, vec2.normalize);
outStr = vec2.str(vec2A);
outBool = vec2.exactEquals(vec2A, vec2B);
outBool = vec2.equals(vec2A, vec2B);
outVec2 = vec2.add(outVec2, [0, 1], [2, 3]); // test one method with number array input

// vec3
outVec3 = vec3.create();
outVec3 = vec3.clone(vec3A);
outVec3 = vec3.fromValues(1, 2, 3);
outVec3 = vec3.copy(outVec3, vec3A);
outVec3 = vec3.set(outVec3, 1, 2, 3);
outVec3 = vec3.add(outVec3, vec3A, vec3B);
outVec3 = vec3.subtract(outVec3, vec3A, vec3B);
outVec3 = vec3.sub(outVec3, vec3A, vec3B);
outVec3 = vec3.multiply(outVec3, vec3A, vec3B);
outVec3 = vec3.mul(outVec3, vec3A, vec3B);
outVec3 = vec3.divide(outVec3, vec3A, vec3B);
outVec3 = vec3.div(outVec3, vec3A, vec3B);
outVec3 = vec3.ceil(outVec3, vec3A);
outVec3 = vec3.floor(outVec3, vec3A);
outVec3 = vec3.min(outVec3, vec3A, vec3B);
outVec3 = vec3.max(outVec3, vec3A, vec3B);
outVec3 = vec3.round(outVec3, vec3A);

 // The final position of the path. The last waypoint or current position if
 // we've reached the end.
 get finalPosition(): Vec3 {
     return vec3.clone(this.waypoints[this.waypoints.length - 1] || this.currentPosition);
 }

 constructor(waypoints: Vec3[], initialHeading: number) {
     this.currentPosition = vec3.clone(waypoints.shift());
     this.currentHeading  = normalizeHeading(initialHeading);
     this.waypoints       = waypoints;
 }

    // Reconstructs the path and returns waypoints connecting start and
    // target position with corners.
    private nextCornerPathReconstruction(current: HalfEdgeFace,
            path: HalfEdgeFace[]): Vec3[] {

        var nav_mesh_path  = this.reconstructPath(current, path)
        , reset          = true
        , best_left      = null
        , best_right     = null
        , best_right_dir = vec3.create()
        , best_left_dir  = vec3.create()
        , corner_path    = [];

        corner_path.push(this._current_pos);

        //while we have a next nav mesh face on the path we:
        //  - compute new line of sight, left & right corner and direction
        //  - check if we still "see" the new left & right corners
        //  - update best values or add corner "blocking" the line of sight
        //    to waypoint list
        while (nav_mesh_path.length > 1) {
            var current_face = nav_mesh_path.shift()
              , sharing_edge = this.getSharingEdge(current_face, nav_mesh_path[0])
              , right        = vec3.clone(sharing_edge.begin.pos)
              , left         = vec3.clone(sharing_edge.end.pos)
              , right_dir    = vec3.create()
              , left_dir     = vec3.create();

            vec3.subtract(right_dir, right, this._current_pos);
            vec3.subtract(left_dir, left, this._current_pos);

            if (reset === true) {
                best_left      = left;
                best_right     = right;
                best_left_dir  = left_dir;
                best_right_dir = right_dir;
                reset          = false;
                continue;
            }

            // The new corners are acceptable if the corridor gets narrower
            // or stays the same. In order to choose the correct corner
            // later (in case 3) we need to keep track which was updated.
            //FIXME: the narrowing should only be done if we hit a wall!
            var right_changed = false
              , left_changed  = false;

            if (this._isLeftEq(best_right_dir, right_dir)) {
                right_changed  = !vec3equal(best_right, right);
                best_right     = right;
                best_right_dir = right_dir;
            }

            if (this._isRightEq(best_left_dir, left_dir)) {
                left_changed  = !vec3equal(best_left, left);
                best_left     = left;
                best_left_dir = left_dir;
            }

            // Case 1: the new right direction is right of the best right
            // direction. This means the right corner blocks our view to
            // the next nav mesh face on the path.
            if (this._isRight(best_right_dir, right_dir)) {
                reset = true;
                this._current_pos = toNavmeshCoordinates(this.terrain, best_right);
                corner_path.push(this._current_pos);
            } else if (this._isLeft(best_left_dir, left_dir)) {
                // Case 2: same as case 1 for left direction.
                reset = true;
                this._current_pos = toNavmeshCoordinates(this.terrain, best_left);
                corner_path.push(this._current_pos);
            } else if (this._isRightEq(best_right_dir, best_left_dir)) {
                // Case 3: the best left direction is now right of the
                // best right direction (same as best left is left of best
                // right). To find the proper corner blocking the line of
                // sight we need to know which corner was updated in this
                // step.
                reset = true;

                var pos;
                if (right_changed) {
                    pos = toNavmeshCoordinates(this.terrain, best_left);
                } else {
                    pos = toNavmeshCoordinates(this.terrain, best_right);
                }

                this._current_pos = pos;
                corner_path.push(this._current_pos);
            }
        }

        // handle last nav face mesh (can be around the corner)
        if (!reset) {
            var target_dir = vec3.create();
            vec3.subtract(target_dir,
                    getWorldCoordinates(this.terrain, this.target_pos),
                    this._current_pos);
            if (this._isLeft(best_left_dir, target_dir)) {
                pos = toNavmeshCoordinates(this.terrain, best_left);
                corner_path.push(pos);
//.........这里部分代码省略.........