| // Copyright 2013 The Closure Library Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS-IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| |
| ////////////////////////// NOTE ABOUT EDITING THIS FILE /////////////////////// |
| // // |
| // Any edits to this file must be applied to vec2d.js by running: // |
| // swap_type.sh vec2f.js > vec2d.js // |
| // // |
| ////////////////////////// NOTE ABOUT EDITING THIS FILE /////////////////////// |
| |
| |
| /** |
| * @fileoverview Provides functions for operating on 2 element float (32bit) |
| * vectors. |
| * |
| * The last parameter will typically be the output object and an object |
| * can be both an input and output parameter to all methods except where |
| * noted. |
| * |
| * See the README for notes about the design and structure of the API |
| * (especially related to performance). |
| * |
| */ |
| |
| goog.provide('goog.vec.vec2f'); |
| goog.provide('goog.vec.vec2f.Type'); |
| |
| /** @suppress {extraRequire} */ |
| goog.require('goog.vec'); |
| |
| |
| /** @typedef {goog.vec.Float32} */ goog.vec.vec2f.Type; |
| |
| |
| /** |
| * Creates a vec2f with all elements initialized to zero. |
| * |
| * @return {!goog.vec.vec2f.Type} The new vec2f. |
| */ |
| goog.vec.vec2f.create = function() { |
| return new Float32Array(2); |
| }; |
| |
| |
| /** |
| * Initializes the vector with the given values. |
| * |
| * @param {goog.vec.vec2f.Type} vec The vector to receive the values. |
| * @param {number} v0 The value for element at index 0. |
| * @param {number} v1 The value for element at index 1. |
| * @return {!goog.vec.vec2f.Type} Return vec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.setFromValues = function(vec, v0, v1) { |
| vec[0] = v0; |
| vec[1] = v1; |
| return vec; |
| }; |
| |
| |
| /** |
| * Initializes vec2f vec from vec2f src. |
| * |
| * @param {goog.vec.vec2f.Type} vec The destination vector. |
| * @param {goog.vec.vec2f.Type} src The source vector. |
| * @return {!goog.vec.vec2f.Type} Return vec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.setFromVec2f = function(vec, src) { |
| vec[0] = src[0]; |
| vec[1] = src[1]; |
| return vec; |
| }; |
| |
| |
| /** |
| * Initializes vec2f vec from vec2d src (typed as a Float64Array to |
| * avoid circular goog.requires). |
| * |
| * @param {goog.vec.vec2f.Type} vec The destination vector. |
| * @param {Float64Array} src The source vector. |
| * @return {!goog.vec.vec2f.Type} Return vec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.setFromVec2d = function(vec, src) { |
| vec[0] = src[0]; |
| vec[1] = src[1]; |
| return vec; |
| }; |
| |
| |
| /** |
| * Initializes vec2f vec from Array src. |
| * |
| * @param {goog.vec.vec2f.Type} vec The destination vector. |
| * @param {Array<number>} src The source vector. |
| * @return {!goog.vec.vec2f.Type} Return vec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.setFromArray = function(vec, src) { |
| vec[0] = src[0]; |
| vec[1] = src[1]; |
| return vec; |
| }; |
| |
| |
| /** |
| * Performs a component-wise addition of vec0 and vec1 together storing the |
| * result into resultVec. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The first addend. |
| * @param {goog.vec.vec2f.Type} vec1 The second addend. |
| * @param {goog.vec.vec2f.Type} resultVec The vector to |
| * receive the result. May be vec0 or vec1. |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.add = function(vec0, vec1, resultVec) { |
| resultVec[0] = vec0[0] + vec1[0]; |
| resultVec[1] = vec0[1] + vec1[1]; |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Performs a component-wise subtraction of vec1 from vec0 storing the |
| * result into resultVec. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The minuend. |
| * @param {goog.vec.vec2f.Type} vec1 The subtrahend. |
| * @param {goog.vec.vec2f.Type} resultVec The vector to |
| * receive the result. May be vec0 or vec1. |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.subtract = function(vec0, vec1, resultVec) { |
| resultVec[0] = vec0[0] - vec1[0]; |
| resultVec[1] = vec0[1] - vec1[1]; |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Multiplies each component of vec0 with the matching element of vec0 |
| * storing the products into resultVec. |
| * |
| * @param {!goog.vec.vec2f.Type} vec0 The first vector. |
| * @param {!goog.vec.vec2f.Type} vec1 The second vector. |
| * @param {!goog.vec.vec2f.Type} resultVec The vector to |
| * receive the result. May be vec0. |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.componentMultiply = function(vec0, vec1, resultVec) { |
| resultVec[0] = vec0[0] * vec1[0]; |
| resultVec[1] = vec0[1] * vec1[1]; |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Divides each component of vec0 with the matching element of vec0 |
| * storing the divisor into resultVec. |
| * |
| * @param {!goog.vec.vec2f.Type} vec0 The first vector. |
| * @param {!goog.vec.vec2f.Type} vec1 The second vector. |
| * @param {!goog.vec.vec2f.Type} resultVec The vector to |
| * receive the result. May be vec0. |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.componentDivide = function(vec0, vec1, resultVec) { |
| resultVec[0] = vec0[0] / vec1[0]; |
| resultVec[1] = vec0[1] / vec1[1]; |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Negates vec0, storing the result into resultVec. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The vector to negate. |
| * @param {goog.vec.vec2f.Type} resultVec The vector to |
| * receive the result. May be vec0. |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.negate = function(vec0, resultVec) { |
| resultVec[0] = -vec0[0]; |
| resultVec[1] = -vec0[1]; |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Takes the absolute value of each component of vec0 storing the result in |
| * resultVec. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The source vector. |
| * @param {goog.vec.vec2f.Type} resultVec The vector to receive the result. |
| * May be vec0. |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.abs = function(vec0, resultVec) { |
| resultVec[0] = Math.abs(vec0[0]); |
| resultVec[1] = Math.abs(vec0[1]); |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Multiplies each component of vec0 with scalar storing the product into |
| * resultVec. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The source vector. |
| * @param {number} scalar The value to multiply with each component of vec0. |
| * @param {goog.vec.vec2f.Type} resultVec The vector to |
| * receive the result. May be vec0. |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.scale = function(vec0, scalar, resultVec) { |
| resultVec[0] = vec0[0] * scalar; |
| resultVec[1] = vec0[1] * scalar; |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Returns the magnitudeSquared of the given vector. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The vector. |
| * @return {number} The magnitude of the vector. |
| */ |
| goog.vec.vec2f.magnitudeSquared = function(vec0) { |
| var x = vec0[0], y = vec0[1]; |
| return x * x + y * y; |
| }; |
| |
| |
| /** |
| * Returns the magnitude of the given vector. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The vector. |
| * @return {number} The magnitude of the vector. |
| */ |
| goog.vec.vec2f.magnitude = function(vec0) { |
| var x = vec0[0], y = vec0[1]; |
| return Math.sqrt(x * x + y * y); |
| }; |
| |
| |
| /** |
| * Normalizes the given vector storing the result into resultVec. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The vector to normalize. |
| * @param {goog.vec.vec2f.Type} resultVec The vector to |
| * receive the result. May be vec0. |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.normalize = function(vec0, resultVec) { |
| var x = vec0[0], y = vec0[1]; |
| var ilen = 1 / Math.sqrt(x * x + y * y); |
| resultVec[0] = x * ilen; |
| resultVec[1] = y * ilen; |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Returns the scalar product of vectors vec0 and vec1. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The first vector. |
| * @param {goog.vec.vec2f.Type} vec1 The second vector. |
| * @return {number} The scalar product. |
| */ |
| goog.vec.vec2f.dot = function(vec0, vec1) { |
| return vec0[0] * vec1[0] + vec0[1] * vec1[1]; |
| }; |
| |
| |
| /** |
| * Returns the squared distance between two points. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 First point. |
| * @param {goog.vec.vec2f.Type} vec1 Second point. |
| * @return {number} The squared distance between the points. |
| */ |
| goog.vec.vec2f.distanceSquared = function(vec0, vec1) { |
| var x = vec0[0] - vec1[0]; |
| var y = vec0[1] - vec1[1]; |
| return x * x + y * y; |
| }; |
| |
| |
| /** |
| * Returns the distance between two points. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 First point. |
| * @param {goog.vec.vec2f.Type} vec1 Second point. |
| * @return {number} The distance between the points. |
| */ |
| goog.vec.vec2f.distance = function(vec0, vec1) { |
| return Math.sqrt(goog.vec.vec2f.distanceSquared(vec0, vec1)); |
| }; |
| |
| |
| /** |
| * Returns a unit vector pointing from one point to another. |
| * If the input points are equal then the result will be all zeros. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 Origin point. |
| * @param {goog.vec.vec2f.Type} vec1 Target point. |
| * @param {goog.vec.vec2f.Type} resultVec The vector to receive the |
| * results (may be vec0 or vec1). |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.direction = function(vec0, vec1, resultVec) { |
| var x = vec1[0] - vec0[0]; |
| var y = vec1[1] - vec0[1]; |
| var d = Math.sqrt(x * x + y * y); |
| if (d) { |
| d = 1 / d; |
| resultVec[0] = x * d; |
| resultVec[1] = y * d; |
| } else { |
| resultVec[0] = resultVec[1] = 0; |
| } |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Linearly interpolate from vec0 to vec1 according to f. The value of f should |
| * be in the range [0..1] otherwise the results are undefined. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The first vector. |
| * @param {goog.vec.vec2f.Type} vec1 The second vector. |
| * @param {number} f The interpolation factor. |
| * @param {goog.vec.vec2f.Type} resultVec The vector to receive the |
| * results (may be vec0 or vec1). |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.lerp = function(vec0, vec1, f, resultVec) { |
| var x = vec0[0], y = vec0[1]; |
| resultVec[0] = (vec1[0] - x) * f + x; |
| resultVec[1] = (vec1[1] - y) * f + y; |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Compares the components of vec0 with the components of another vector or |
| * scalar, storing the larger values in resultVec. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The source vector. |
| * @param {goog.vec.vec2f.Type|number} limit The limit vector or scalar. |
| * @param {goog.vec.vec2f.Type} resultVec The vector to receive the |
| * results (may be vec0 or limit). |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.max = function(vec0, limit, resultVec) { |
| if (goog.isNumber(limit)) { |
| resultVec[0] = Math.max(vec0[0], limit); |
| resultVec[1] = Math.max(vec0[1], limit); |
| } else { |
| resultVec[0] = Math.max(vec0[0], limit[0]); |
| resultVec[1] = Math.max(vec0[1], limit[1]); |
| } |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Compares the components of vec0 with the components of another vector or |
| * scalar, storing the smaller values in resultVec. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The source vector. |
| * @param {goog.vec.vec2f.Type|number} limit The limit vector or scalar. |
| * @param {goog.vec.vec2f.Type} resultVec The vector to receive the |
| * results (may be vec0 or limit). |
| * @return {!goog.vec.vec2f.Type} Return resultVec so that operations can be |
| * chained together. |
| */ |
| goog.vec.vec2f.min = function(vec0, limit, resultVec) { |
| if (goog.isNumber(limit)) { |
| resultVec[0] = Math.min(vec0[0], limit); |
| resultVec[1] = Math.min(vec0[1], limit); |
| } else { |
| resultVec[0] = Math.min(vec0[0], limit[0]); |
| resultVec[1] = Math.min(vec0[1], limit[1]); |
| } |
| return resultVec; |
| }; |
| |
| |
| /** |
| * Returns true if the components of vec0 are equal to the components of vec1. |
| * |
| * @param {goog.vec.vec2f.Type} vec0 The first vector. |
| * @param {goog.vec.vec2f.Type} vec1 The second vector. |
| * @return {boolean} True if the vectors are equal, false otherwise. |
| */ |
| goog.vec.vec2f.equals = function(vec0, vec1) { |
| return vec0.length == vec1.length && |
| vec0[0] == vec1[0] && vec0[1] == vec1[1]; |
| }; |