        <!DOCTYPE html>
        <html>
        <head>
                <meta charset="utf-8">
        <title>VectorMath</title>
        <link rel="stylesheet" type="text/css"
            href="styles.css" />
        <link href="http://fonts.googleapis.com/css?family=Open+Sans:400,600,700,800" rel="stylesheet" type="text/css">
        <link rel="shortcut icon" href="favicon.ico" />
        <script src="client-static.js"></script>
        
        </head>
        <body data-library="VectorMath">
        <div class="page">
        <div class="header">
          <a href="index.html"><div class="logo"></div></a>
          <a href="index.html">Dart Documentation</a>
         &rsaquo; <a href="VectorMath.html">VectorMath</a></div>
        <div class="nav">
        
<h2><div class="icon-library"></div><a href="dart_core.html">dart:core</a></h2><h2><div class="icon-library"></div><a href="dart_coreimpl.html">dart:coreimpl</a></h2><h2><div class="icon-library"></div><strong>VectorMath</strong></h2><ul class="icon">
<li><a href="VectorMath/vec2.html"><div class="icon-class"></div>vec2</a></li>
<li><a href="VectorMath/vec3.html"><div class="icon-class"></div>vec3</a></li>
<li><a href="VectorMath/vec4.html"><div class="icon-class"></div>vec4</a></li>
<li><a href="VectorMath/mat2x2.html"><div class="icon-class"></div>mat2x2</a></li>
<li><a href="VectorMath/mat2x3.html"><div class="icon-class"></div>mat2x3</a></li>
<li><a href="VectorMath/mat2x4.html"><div class="icon-class"></div>mat2x4</a></li>
<li><a href="VectorMath/mat3x2.html"><div class="icon-class"></div>mat3x2</a></li>
<li><a href="VectorMath/mat3x3.html"><div class="icon-class"></div>mat3x3</a></li>
<li><a href="VectorMath/mat3x4.html"><div class="icon-class"></div>mat3x4</a></li>
<li><a href="VectorMath/mat4x2.html"><div class="icon-class"></div>mat4x2</a></li>
<li><a href="VectorMath/mat4x3.html"><div class="icon-class"></div>mat4x3</a></li>
<li><a href="VectorMath/mat4x4.html"><div class="icon-class"></div>mat4x4</a></li>
<li><a href="VectorMath/quat.html"><div class="icon-class"></div>quat</a></li>
</ul>
</div>
<div class="content">
<h2>Library <strong>VectorMath</strong></h2>
<div class="doc"></div>
<h3>Functions</h3>
<div class="method"><h4 id="relativeError">
<span class="show-code">Code</span>
<a href="dart_core/num.html">num</a> <strong>relativeError</strong>(calculated, correct) <a class="anchor-link" href="#relativeError"
              title="Permalink to null.relativeError">#</a></h4>
<div class="doc">
<p>Returns relative error between 
<span class="param">calculated</span> and 
<span class="param">correct</span>. The type of 
<span class="param">calculated</span> and 
<span class="param">correct</span> must match and can be any vector, matrix, or quaternion.</p>
<pre class="source">
num relativeError(Dynamic calculated, Dynamic correct) {
  if (calculated is num &amp;&amp; correct is num) {
    num diff = (calculated - correct).abs();
    return diff/correct;
  }
  return calculated.relativeError(correct);
}
</pre>
</div>
</div>
<div class="method"><h4 id="absoluteError">
<span class="show-code">Code</span>
<a href="dart_core/num.html">num</a> <strong>absoluteError</strong>(calculated, correct) <a class="anchor-link" href="#absoluteError"
              title="Permalink to null.absoluteError">#</a></h4>
<div class="doc">
<p>Returns absolute error between 
<span class="param">calculated</span> and 
<span class="param">correct</span>. The type of 
<span class="param">calculated</span> and 
<span class="param">correct</span> must match and can be any vector, matrix, or quaternion.</p>
<pre class="source">
num absoluteError(Dynamic calculated, Dynamic correct) {
  if (calculated is num &amp;&amp; correct is num) {
    num diff = (calculated - correct).abs();
    return diff;
  }
  return calculated.absoluteError(correct);
}
</pre>
</div>
</div>
<div class="method"><h4 id="dot">
<span class="show-code">Code</span>
<a href="dart_core/num.html">num</a> <strong>dot</strong>(x, y) <a class="anchor-link" href="#dot"
              title="Permalink to null.dot">#</a></h4>
<div class="doc">
<p>Returns the dot product between vectors 
<span class="param">x</span> and 
<span class="param">y</span>. The dimension of 
<span class="param">x</span> and 
<span class="param">y</span> must match.</p>
<pre class="source">
num dot(Dynamic x, Dynamic y) {
  return x.dot(y);
}
</pre>
</div>
</div>
<div class="method"><h4 id="length">
<span class="show-code">Code</span>
<a href="dart_core/num.html">num</a> <strong>length</strong>(x) <a class="anchor-link" href="#length"
              title="Permalink to null.length">#</a></h4>
<div class="doc">
<p>Returns the length of vector 
<span class="param">x</span></p>
<pre class="source">
num length(Dynamic x) {
  return x.length();
}
</pre>
</div>
</div>
<div class="method"><h4 id="distance">
<span class="show-code">Code</span>
<a href="dart_core/num.html">num</a> <strong>distance</strong>(x, y) <a class="anchor-link" href="#distance"
              title="Permalink to null.distance">#</a></h4>
<div class="doc">
<p>Returns the distance between vectors 
<span class="param">x</span> and 
<span class="param">y</span>. The dimension of 
<span class="param">x</span> and 
<span class="param">y</span> must match.</p>
<pre class="source">
num distance(Dynamic x, Dynamic y) {
  return length(x-y);
}
</pre>
</div>
</div>
<div class="method"><h4 id="cross">
<span class="show-code">Code</span>
<a href="VectorMath/vec3.html">vec3</a> <strong>cross</strong>(<a href="VectorMath/vec3.html">vec3</a> x, <a href="VectorMath/vec3.html">vec3</a> y) <a class="anchor-link" href="#cross"
              title="Permalink to null.cross">#</a></h4>
<div class="doc">
<p>Returns the cross product between 
<span class="param">x</span> and 
<span class="param">y</span>. Both 
<span class="param">x</span> and 
<span class="param">y</span> must be 3D vectors (<a class="crossref" href="VectorMath/vec3.html">vec3</a>)</p>
<pre class="source">
vec3 cross(vec3 x, vec3 y) {
  return x.cross(y);
}
</pre>
</div>
</div>
<div class="method"><h4 id="normalize">
<span class="show-code">Code</span>
<strong>normalize</strong>(x) <a class="anchor-link" href="#normalize"
              title="Permalink to null.normalize">#</a></h4>
<div class="doc">
<p>Returns 
<span class="param">x</span> normalized. Supports <code>num</code>, <a class="crossref" href="VectorMath/vec2.html">vec2</a>, <a class="crossref" href="VectorMath/vec3.html">vec3</a>, and <a class="crossref" href="VectorMath/vec4.html">vec4</a> input types. The return type will match the type of 
<span class="param">x</span></p>
<pre class="source">
Dynamic normalize(Dynamic x) {
  if (x is num) {
    return 1.0 * sign(x);
  }
  Dynamic r;
  if (x is vec2) {
    r = new vec2(x);
    r.normalize();
  }
  if (x is vec3) {
    r = new vec3(x);
    r.normalize();
  }
  if (x is vec4) {
    r = new vec4(x);
    r.normalize();
  }
  return r;
}
</pre>
</div>
</div>
<div class="method"><h4 id="sin">
<span class="show-code">Code</span>
<strong>sin</strong>(arg) <a class="anchor-link" href="#sin"
              title="Permalink to null.sin">#</a></h4>
<div class="doc">
<p>Returns sine of 
<span class="param">arg</span>. Return type matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic sin(Dynamic arg) {
  if (arg is num) {
    return Math.sin(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.sin(arg.x), Math.sin(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.sin(arg.x), Math.sin(arg.y), Math.sin(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.sin(arg.x), Math.sin(arg.y), Math.sin(arg.z), Math.sin(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="cos">
<span class="show-code">Code</span>
<strong>cos</strong>(arg) <a class="anchor-link" href="#cos"
              title="Permalink to null.cos">#</a></h4>
<div class="doc">
<p>Returns cosine of 
<span class="param">arg</span>. Return type matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic cos(Dynamic arg) {
  if (arg is num) {
    return Math.cos(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.cos(arg.x), Math.cos(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.cos(arg.x), Math.cos(arg.y), Math.cos(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.cos(arg.x), Math.cos(arg.y), Math.cos(arg.z), Math.cos(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="tan">
<span class="show-code">Code</span>
<strong>tan</strong>(arg) <a class="anchor-link" href="#tan"
              title="Permalink to null.tan">#</a></h4>
<div class="doc">
<p>Returns tangent of 
<span class="param">arg</span>. Return type matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic tan(Dynamic arg) {
  if (arg is num) {
    return Math.tan(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.tan(arg.x), Math.tan(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.tan(arg.x), Math.tan(arg.y), Math.tan(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.tan(arg.x), Math.tan(arg.y), Math.tan(arg.z), Math.tan(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="asin">
<span class="show-code">Code</span>
<strong>asin</strong>(arg) <a class="anchor-link" href="#asin"
              title="Permalink to null.asin">#</a></h4>
<div class="doc">
<p>Returns arc sine of 
<span class="param">arg</span>. Return type matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic asin(Dynamic arg) {
  if (arg is num) {
    return Math.asin(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.asin(arg.x), Math.asin(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.asin(arg.x), Math.asin(arg.y), Math.asin(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.asin(arg.x), Math.asin(arg.y), Math.asin(arg.z), Math.asin(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="acos">
<span class="show-code">Code</span>
<strong>acos</strong>(arg) <a class="anchor-link" href="#acos"
              title="Permalink to null.acos">#</a></h4>
<div class="doc">
<p>Returns arc cosine of 
<span class="param">arg</span>. Return type matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic acos(Dynamic arg) {
  if (arg is num) {
    return Math.acos(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.acos(arg.x), Math.acos(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.acos(arg.x), Math.acos(arg.y), Math.acos(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.acos(arg.x), Math.acos(arg.y), Math.acos(arg.z), Math.acos(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="sinh">
<span class="show-code">Code</span>
<strong>sinh</strong>(arg) <a class="anchor-link" href="#sinh"
              title="Permalink to null.sinh">#</a></h4>
<div class="doc">
<p>Returns hyperbolic sine of 
<span class="param">arg</span>. Return type matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic sinh(Dynamic arg) {
  if (arg is num) {
    return Math.sinh(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.sinh(arg.x), Math.sinh(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.sinh(arg.x), Math.sinh(arg.y), Math.sinh(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.sinh(arg.x), Math.sinh(arg.y), Math.sinh(arg.z), Math.sinh(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="cosh">
<span class="show-code">Code</span>
<strong>cosh</strong>(arg) <a class="anchor-link" href="#cosh"
              title="Permalink to null.cosh">#</a></h4>
<div class="doc">
<p>Returns hyperbolic cosine of 
<span class="param">arg</span>. Return type matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic cosh(Dynamic arg) {
  if (arg is num) {
    return Math.cosh(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.cosh(arg.x), Math.cosh(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.cosh(arg.x), Math.cosh(arg.y), Math.cosh(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.cosh(arg.x), Math.cosh(arg.y), Math.cosh(arg.z), Math.cosh(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="tanh">
<span class="show-code">Code</span>
<strong>tanh</strong>(arg) <a class="anchor-link" href="#tanh"
              title="Permalink to null.tanh">#</a></h4>
<div class="doc">
<p>Returns hyperbolic tangent of 
<span class="param">arg</span>. Return type matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic tanh(Dynamic arg) {
  if (arg is num) {
    return Math.tanh(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.tanh(arg.x), Math.tanh(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.tanh(arg.x), Math.tanh(arg.y), Math.tanh(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.tanh(arg.x), Math.tanh(arg.y), Math.tanh(arg.z), Math.tanh(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="asinh">
<span class="show-code">Code</span>
<strong>asinh</strong>(arg) <a class="anchor-link" href="#asinh"
              title="Permalink to null.asinh">#</a></h4>
<div class="doc">
<p>Returns arc hyperbolic sine of 
<span class="param">arg</span>. Return type matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic asinh(Dynamic arg) {
  if (arg is num) {
    return Math.asinh(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.asinh(arg.x), Math.asinh(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.asinh(arg.x), Math.asinh(arg.y), Math.asinh(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.asinh(arg.x), Math.asinh(arg.y), Math.asinh(arg.z), Math.asinh(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="acosh">
<span class="show-code">Code</span>
<strong>acosh</strong>(arg) <a class="anchor-link" href="#acosh"
              title="Permalink to null.acosh">#</a></h4>
<div class="doc">
<p>Returns arc hyperbolic cosine of 
<span class="param">arg</span>. Return type matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic acosh(Dynamic arg) {
  if (arg is num) {
    return Math.acosh(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.acosh(arg.x), Math.acosh(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.acosh(arg.x), Math.acosh(arg.y), Math.acosh(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.acosh(arg.x), Math.acosh(arg.y), Math.acosh(arg.z), Math.acosh(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="atanh">
<span class="show-code">Code</span>
<strong>atanh</strong>(arg) <a class="anchor-link" href="#atanh"
              title="Permalink to null.atanh">#</a></h4>
<div class="doc">
<p>Returns arc hyperbolic tangent of 
<span class="param">arg</span>. Return type matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic atanh(Dynamic arg) {
  if (arg is num) {
    return Math.atanh(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.atanh(arg.x), Math.atanh(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.atanh(arg.x), Math.atanh(arg.y), Math.atanh(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.atanh(arg.x), Math.atanh(arg.y), Math.atanh(arg.z), Math.atanh(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="radians">
<span class="show-code">Code</span>
<strong>radians</strong>(arg) <a class="anchor-link" href="#radians"
              title="Permalink to null.radians">#</a></h4>
<div class="doc">
<p>Returns 
<span class="param">arg</span> converted from degrees to radians. Return types matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic radians(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.radians(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.radians(arg.x), _ScalerHelpers.radians(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.radians(arg.x), _ScalerHelpers.radians(arg.y), _ScalerHelpers.radians(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.radians(arg.x), _ScalerHelpers.radians(arg.y), _ScalerHelpers.radians(arg.z), _ScalerHelpers.radians(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="degrees">
<span class="show-code">Code</span>
<strong>degrees</strong>(arg) <a class="anchor-link" href="#degrees"
              title="Permalink to null.degrees">#</a></h4>
<div class="doc">
<p>Returns 
<span class="param">arg</span> converted from radians to degrees. Return types matches the type of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic degrees(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.degrees(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.degrees(arg.x), _ScalerHelpers.degrees(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.degrees(arg.x), _ScalerHelpers.degrees(arg.y), _ScalerHelpers.degrees(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.degrees(arg.x), _ScalerHelpers.degrees(arg.y), _ScalerHelpers.degrees(arg.z), _ScalerHelpers.degrees(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="pow">
<span class="show-code">Code</span>
<strong>pow</strong>(x, y) <a class="anchor-link" href="#pow"
              title="Permalink to null.pow">#</a></h4>
<div class="doc">
<p>Returns 
<span class="param">x</span> raised to the exponent 
<span class="param">y</span>. Supports vectors and numbers.</p>
<pre class="source">
Dynamic pow(Dynamic x, Dynamic y) {
  if (x is num) {
    return Math.pow(x, y);
  }
  if (x is vec2) {
    return new vec2(Math.pow(x.x, y.x), Math.pow(x.y, y.y));
  }
  if (x is vec3) {
    return new vec3(Math.pow(x.x, y.x), Math.pow(x.y, y.y), Math.pow(x.z, y.z));
  }
  if (x is vec4) {
    return new vec4(Math.pow(x.x, y.x), Math.pow(x.y, y.y), Math.pow(x.z, y.z), Math.pow(x.w, y.w));
  }
  throw new IllegalArgumentException(x);
}
</pre>
</div>
</div>
<div class="method"><h4 id="exp">
<span class="show-code">Code</span>
<strong>exp</strong>(arg) <a class="anchor-link" href="#exp"
              title="Permalink to null.exp">#</a></h4>
<div class="doc">
<p>Returns <em>e</em> raised to the exponent 
<span class="param">arg</span>. Supports vectors and numbers.</p>
<pre class="source">
Dynamic exp(Dynamic arg) {
  if (arg is num) {
    return Math.exp(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.exp(arg.x), Math.exp(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.exp(arg.x), Math.exp(arg.y), Math.exp(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.exp(arg.x), Math.exp(arg.y), Math.exp(arg.z), Math.exp(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="log">
<span class="show-code">Code</span>
<strong>log</strong>(arg) <a class="anchor-link" href="#log"
              title="Permalink to null.log">#</a></h4>
<div class="doc">
<p>Returns the logarithm of 
<span class="param">arg</span> base <em>e</em>. Supports vectors and numbers.</p>
<pre class="source">
Dynamic log(Dynamic arg) {
  if (arg is num) {
    return Math.log(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.log(arg.x), Math.log(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.log(arg.x), Math.log(arg.y), Math.log(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.log(arg.x), Math.log(arg.y), Math.log(arg.z), Math.log(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="exp2">
<span class="show-code">Code</span>
<strong>exp2</strong>(arg) <a class="anchor-link" href="#exp2"
              title="Permalink to null.exp2">#</a></h4>
<div class="doc">
<p>Returns <em>2</em> raised to the exponent 
<span class="param">arg</span>. Supports vectors and numbers.</p>
<pre class="source">
Dynamic exp2(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.exp2(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.exp2(arg.x), _ScalerHelpers.exp2(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.exp2(arg.x), _ScalerHelpers.exp2(arg.y), _ScalerHelpers.exp2(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.exp2(arg.x), _ScalerHelpers.exp2(arg.y), _ScalerHelpers.exp2(arg.z), _ScalerHelpers.exp2(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="log2">
<span class="show-code">Code</span>
<strong>log2</strong>(arg) <a class="anchor-link" href="#log2"
              title="Permalink to null.log2">#</a></h4>
<div class="doc">
<p>Returns the logarithm of 
<span class="param">arg</span> base <em>2</em>. Supports vectors and numbers.</p>
<pre class="source">
Dynamic log2(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.log2(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.log2(arg.x), _ScalerHelpers.log2(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.log2(arg.x), _ScalerHelpers.log2(arg.y), _ScalerHelpers.log2(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.log2(arg.x), _ScalerHelpers.log2(arg.y), _ScalerHelpers.log2(arg.z), _ScalerHelpers.log2(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="sqrt">
<span class="show-code">Code</span>
<strong>sqrt</strong>(arg) <a class="anchor-link" href="#sqrt"
              title="Permalink to null.sqrt">#</a></h4>
<div class="doc">
<p>Returns the square root of 
<span class="param">arg</span>.</p>
<pre class="source">
Dynamic sqrt(Dynamic arg) {
  if (arg is num) {
    return Math.sqrt(arg);
  }
  if (arg is vec2) {
    return new vec2(Math.sqrt(arg.x), Math.sqrt(arg.y));
  }
  if (arg is vec3) {
    return new vec3(Math.sqrt(arg.x), Math.sqrt(arg.y), Math.sqrt(arg.z));
  }
  if (arg is vec4) {
    return new vec4(Math.sqrt(arg.x), Math.sqrt(arg.y), Math.sqrt(arg.z), Math.sqrt(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="inversesqrt">
<span class="show-code">Code</span>
<strong>inversesqrt</strong>(arg) <a class="anchor-link" href="#inversesqrt"
              title="Permalink to null.inversesqrt">#</a></h4>
<div class="doc">
<p>Returns the inverse square root of 
<span class="param">arg</span>. Supports vectors and numbers.</p>
<pre class="source">
Dynamic inversesqrt(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.inversesqrt(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.inversesqrt(arg.x), _ScalerHelpers.inversesqrt(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.inversesqrt(arg.x), _ScalerHelpers.inversesqrt(arg.y), _ScalerHelpers.inversesqrt(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.inversesqrt(arg.x), _ScalerHelpers.inversesqrt(arg.y), _ScalerHelpers.inversesqrt(arg.z), _ScalerHelpers.inversesqrt(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="abs">
<span class="show-code">Code</span>
<strong>abs</strong>(arg) <a class="anchor-link" href="#abs"
              title="Permalink to null.abs">#</a></h4>
<div class="doc">
<p>Returns absolute value of 
<span class="param">arg</span>.</p>
<pre class="source">
Dynamic abs(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.abs(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.abs(arg.x), _ScalerHelpers.abs(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.abs(arg.x), _ScalerHelpers.abs(arg.y), _ScalerHelpers.abs(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.abs(arg.x), _ScalerHelpers.abs(arg.y), _ScalerHelpers.abs(arg.z), _ScalerHelpers.abs(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="sign">
<span class="show-code">Code</span>
<strong>sign</strong>(arg) <a class="anchor-link" href="#sign"
              title="Permalink to null.sign">#</a></h4>
<div class="doc">
<p>Returns 1.0 or 0.0 or -1.0 depending on sign of 
<span class="param">arg</span>.</p>
<pre class="source">
Dynamic sign(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.sign(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.sign(arg.x), _ScalerHelpers.sign(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.sign(arg.x), _ScalerHelpers.sign(arg.y), _ScalerHelpers.sign(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.sign(arg.x), _ScalerHelpers.sign(arg.y), _ScalerHelpers.sign(arg.z), _ScalerHelpers.sign(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="floor">
<span class="show-code">Code</span>
<strong>floor</strong>(arg) <a class="anchor-link" href="#floor"
              title="Permalink to null.floor">#</a></h4>
<div class="doc">
<p>Returns floor value of 
<span class="param">arg</span>.</p>
<pre class="source">
Dynamic floor(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.floor(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.floor(arg.x), _ScalerHelpers.floor(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.floor(arg.x), _ScalerHelpers.floor(arg.y), _ScalerHelpers.floor(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.floor(arg.x), _ScalerHelpers.floor(arg.y), _ScalerHelpers.floor(arg.z), _ScalerHelpers.floor(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="trunc">
<span class="show-code">Code</span>
<strong>trunc</strong>(arg) <a class="anchor-link" href="#trunc"
              title="Permalink to null.trunc">#</a></h4>
<div class="doc">
<p>Returns 
<span class="param">arg</span> truncated.</p>
<pre class="source">
Dynamic trunc(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.truncate(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.truncate(arg.x), _ScalerHelpers.truncate(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.truncate(arg.x), _ScalerHelpers.truncate(arg.y), _ScalerHelpers.truncate(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.truncate(arg.x), _ScalerHelpers.truncate(arg.y), _ScalerHelpers.truncate(arg.z), _ScalerHelpers.truncate(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="round">
<span class="show-code">Code</span>
<strong>round</strong>(arg) <a class="anchor-link" href="#round"
              title="Permalink to null.round">#</a></h4>
<div class="doc">
<p>Returns 
<span class="param">arg</span> rounded to nearest integer.</p>
<pre class="source">
Dynamic round(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.round(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.round(arg.x), _ScalerHelpers.round(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.round(arg.x), _ScalerHelpers.round(arg.y), _ScalerHelpers.round(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.round(arg.x), _ScalerHelpers.round(arg.y), _ScalerHelpers.round(arg.z), _ScalerHelpers.round(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="roundEven">
<span class="show-code">Code</span>
<strong>roundEven</strong>(arg) <a class="anchor-link" href="#roundEven"
              title="Permalink to null.roundEven">#</a></h4>
<div class="doc">
<p>Returns 
<span class="param">arg</span> rounded to nearest even integer.</p>
<pre class="source">
Dynamic roundEven(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.roundEven(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.roundEven(arg.x), _ScalerHelpers.roundEven(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.roundEven(arg.x), _ScalerHelpers.roundEven(arg.y), _ScalerHelpers.roundEven(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.roundEven(arg.x), _ScalerHelpers.roundEven(arg.y), _ScalerHelpers.roundEven(arg.z), _ScalerHelpers.roundEven(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="ceil">
<span class="show-code">Code</span>
<strong>ceil</strong>(arg) <a class="anchor-link" href="#ceil"
              title="Permalink to null.ceil">#</a></h4>
<div class="doc">
<p>Returns ceiling of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic ceil(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.ceil(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.ceil(arg.x), _ScalerHelpers.ceil(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.ceil(arg.x), _ScalerHelpers.ceil(arg.y), _ScalerHelpers.ceil(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.ceil(arg.x), _ScalerHelpers.ceil(arg.y), _ScalerHelpers.ceil(arg.z), _ScalerHelpers.ceil(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="fract">
<span class="show-code">Code</span>
<strong>fract</strong>(arg) <a class="anchor-link" href="#fract"
              title="Permalink to null.fract">#</a></h4>
<div class="doc">
<p>Returns fraction of 
<span class="param">arg</span></p>
<pre class="source">
Dynamic fract(Dynamic arg) {
  if (arg is num) {
    return _ScalerHelpers.fract(arg);
  }
  if (arg is vec2) {
    return new vec2(_ScalerHelpers.fract(arg.x), _ScalerHelpers.fract(arg.y));
  }
  if (arg is vec3) {
    return new vec3(_ScalerHelpers.fract(arg.x), _ScalerHelpers.fract(arg.y), _ScalerHelpers.fract(arg.z));
  }
  if (arg is vec4) {
    return new vec4(_ScalerHelpers.fract(arg.x), _ScalerHelpers.fract(arg.y), _ScalerHelpers.fract(arg.z), _ScalerHelpers.fract(arg.w));
  }
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="mod">
<span class="show-code">Code</span>
<strong>mod</strong>(x, y) <a class="anchor-link" href="#mod"
              title="Permalink to null.mod">#</a></h4>
<div class="doc">
<p>Returns 
<span class="param">x</span> mod 
<span class="param">y</span></p>
<pre class="source">
Dynamic mod(Dynamic x, Dynamic y) {
  if (x is num) {
    return _ScalerHelpers.mod(x, y);
  }
  if (x is vec2) {
    return new vec2(_ScalerHelpers.mod(x.x, y.x), _ScalerHelpers.mod(x.y, y.y));
  }
  if (x is vec3) {
    return new vec3(_ScalerHelpers.mod(x.x, y.x), _ScalerHelpers.mod(x.y, y.y), _ScalerHelpers.mod(x.z, y.z));
  }
  if (x is vec4) {
    return new vec4(_ScalerHelpers.mod(x.x, y.x), _ScalerHelpers.mod(x.y, y.y), _ScalerHelpers.mod(x.z, y.z), _ScalerHelpers.mod(x.w, y.w));
  }
  throw new IllegalArgumentException(x);
}
</pre>
</div>
</div>
<div class="method"><h4 id="min">
<span class="show-code">Code</span>
<strong>min</strong>(x, y) <a class="anchor-link" href="#min"
              title="Permalink to null.min">#</a></h4>
<div class="doc">
<p>Returns component wise minimum of 
<span class="param">x</span> and 
<span class="param">y</span></p>
<pre class="source">
Dynamic min(Dynamic x, Dynamic y) {
  if (x is num) {
    return Math.min(x, y);
  }
  if (x is vec2) {
    return new vec2(Math.min(x.x, y.x), Math.min(x.y, y.y));
  }
  if (x is vec3) {
    return new vec3(Math.min(x.x, y.x), Math.min(x.y, y.y), Math.min(x.z, y.z));
  }
  if (x is vec4) {
    return new vec4(Math.min(x.x, y.x), Math.min(x.y, y.y), Math.min(x.z, y.z), Math.min(x.w, y.w));
  }
  throw new IllegalArgumentException(x);
}
</pre>
</div>
</div>
<div class="method"><h4 id="max">
<span class="show-code">Code</span>
<strong>max</strong>(x, y) <a class="anchor-link" href="#max"
              title="Permalink to null.max">#</a></h4>
<div class="doc">
<p>Returns component wise maximum of 
<span class="param">x</span> and 
<span class="param">y</span></p>
<pre class="source">
Dynamic max(Dynamic x, Dynamic y) {
  if (x is num) {
    return Math.max(x, y);
  }
  if (x is vec2) {
    return new vec2(Math.max(x.x, y.x), Math.max(x.y, y.y));
  }
  if (x is vec3) {
    return new vec3(Math.max(x.x, y.x), Math.max(x.y, y.y), Math.max(x.z, y.z));
  }
  if (x is vec4) {
    return new vec4(Math.max(x.x, y.x), Math.max(x.y, y.y), Math.max(x.z, y.z), Math.max(x.w, y.w));
  }
  throw new IllegalArgumentException(x);
}
</pre>
</div>
</div>
<div class="method"><h4 id="clamp">
<span class="show-code">Code</span>
<strong>clamp</strong>(x, min_, max_) <a class="anchor-link" href="#clamp"
              title="Permalink to null.clamp">#</a></h4>
<div class="doc">
<p>Component wise clamp of 
<span class="param">x</span> between 
<span class="param">min_</span> and 
<span class="param">max_</span></p>
<pre class="source">
Dynamic clamp(Dynamic x, Dynamic min_, Dynamic max_) {
  if (x is num) {
    return _ScalerHelpers.clamp(x, min_, max_);
  }
  if (x is vec2) {
    return new vec2(_ScalerHelpers.clamp(x.x, min_.x, max_.x), _ScalerHelpers.clamp(x.y, min_.y, max_.y));
  }
  if (x is vec3) {
    return new vec3(_ScalerHelpers.clamp(x.x, min_.x, max_.x), _ScalerHelpers.clamp(x.y, min_.y, max_.y), _ScalerHelpers.clamp(x.z, min_.z, max_.z));
  }
  if (x is vec4) {
    return new vec4(_ScalerHelpers.clamp(x.x, min_.x, max_.x), _ScalerHelpers.clamp(x.y, min_.y, max_.y), _ScalerHelpers.clamp(x.z, min_.z, max_.z), _ScalerHelpers.clamp(x.w, min_.w, max_.w));
  }
  throw new IllegalArgumentException(x);
}
</pre>
</div>
</div>
<div class="method"><h4 id="mix">
<span class="show-code">Code</span>
<strong>mix</strong>(x, y, t) <a class="anchor-link" href="#mix"
              title="Permalink to null.mix">#</a></h4>
<div class="doc">
<p>Linear interpolation between 
<span class="param">x</span> and 
<span class="param">y</span> with 
<span class="param">t</span>. 
<span class="param">t</span> must be between 0.0 and 1.0.</p>
<pre class="source">
Dynamic mix(Dynamic x, Dynamic y, Dynamic t) {
  if (x is num) {
    return _ScalerHelpers.mix(x, y, t);
  }
  if (x is vec2) {
    return new vec2(_ScalerHelpers.mix(x.x, y.x, t.x), _ScalerHelpers.mix(x.y, y.y, t.y));
  }
  if (x is vec3) {
    return new vec3(_ScalerHelpers.mix(x.x, y.x, t.x), _ScalerHelpers.mix(x.y, y.y, t.y), _ScalerHelpers.mix(x.z, y.z, t.z));
  }
  if (x is vec4) {
    return new vec4(_ScalerHelpers.mix(x.x, y.x, t.x), _ScalerHelpers.mix(x.y, y.y, t.y), _ScalerHelpers.mix(x.z, y.z, t.z), _ScalerHelpers.mix(x.w, y.w, t.w));
  }
  throw new IllegalArgumentException(x);
}
</pre>
</div>
</div>
<div class="method"><h4 id="step">
<span class="show-code">Code</span>
<strong>step</strong>(x, y) <a class="anchor-link" href="#step"
              title="Permalink to null.step">#</a></h4>
<div class="doc">
<p>Returns 0.0 if x &lt; 
<span class="param">y</span> and 1.0 otherwise.</p>
<pre class="source">
Dynamic step(Dynamic x, Dynamic y) {
  if (x is num) {
    return _ScalerHelpers.step(x, y);
  }
  if (x is vec2) {
    return new vec2(_ScalerHelpers.step(x.x, y.x), _ScalerHelpers.step(x.y, y.y));
  }
  if (x is vec3) {
    return new vec3(_ScalerHelpers.step(x.x, y.x), _ScalerHelpers.step(x.y, y.y), _ScalerHelpers.step(x.z, y.z));
  }
  if (x is vec4) {
    return new vec4(_ScalerHelpers.step(x.x, y.x), _ScalerHelpers.step(x.y, y.y), _ScalerHelpers.step(x.z, y.z), _ScalerHelpers.step(x.w, y.w));
  }
  throw new IllegalArgumentException(x);
}
</pre>
</div>
</div>
<div class="method"><h4 id="smoothstep">
<span class="show-code">Code</span>
<strong>smoothstep</strong>(edge0, edge1, x) <a class="anchor-link" href="#smoothstep"
              title="Permalink to null.smoothstep">#</a></h4>
<div class="doc">
<p>Hermite intpolation between 
<span class="param">edge0</span> and 
<span class="param">edge1</span>. 
<span class="param">edge0</span> &lt; 
<span class="param">x</span> &lt; 
<span class="param">edge1</span>.</p>
<pre class="source">
Dynamic smoothstep(Dynamic edge0, Dynamic edge1, Dynamic x) {
  if (x is num) {
    return _ScalerHelpers.smoothstep(edge0, edge1, x);
  }
  if (x is vec2) {
    return new vec2(_ScalerHelpers.smoothstep(edge0.x, edge1.x, x.x), _ScalerHelpers.smoothstep(edge0.y, edge1.y, x.y));
  }
  if (x is vec3) {
    return new vec3(_ScalerHelpers.smoothstep(edge0.x, edge1.x, x.x), _ScalerHelpers.smoothstep(edge0.y, edge1.y, x.y), _ScalerHelpers.smoothstep(edge0.z, edge1.z, x.z));
  }
  if (x is vec4) {
    return new vec4(_ScalerHelpers.smoothstep(edge0.x, edge1.x, x.x), _ScalerHelpers.smoothstep(edge0.y, edge1.y, x.y), _ScalerHelpers.smoothstep(edge0.z, edge1.z, x.z), _ScalerHelpers.smoothstep(edge0.w, edge1.w, x.w));
  }
  throw new IllegalArgumentException(x);
}
</pre>
</div>
</div>
<div class="method"><h4 id="atan">
<span class="show-code">Code</span>
<strong>atan</strong>(arg, [arg2]) <a class="anchor-link" href="#atan"
              title="Permalink to null.atan">#</a></h4>
<div class="doc">
<p>Returns atan(
<span class="param">arg</span>) or atan(
<span class="param">arg</span>/
<span class="param">arg2</span>)</p>
<p>Arguments can be of type <code>num</code>, <a class="crossref" href="VectorMath/vec2.html">vec2</a>, <a class="crossref" href="VectorMath/vec3.html">vec3</a> or <a class="crossref" href="VectorMath/vec4.html">vec4</a>
Return type matches input argument type</p>
<pre class="source">
Dynamic atan(Dynamic arg, [Dynamic arg2]) {
  if (arg2 == null) {
    if (arg is num) {
      return Math.atan(arg);
    }
    if (arg is vec2) {
      return new vec2(Math.atan(arg.x), Math.atan(arg.y));
    }
    if (arg is vec3) {
      return new vec3(Math.atan(arg.x), Math.atan(arg.y), Math.atan(arg.z));
    }
    if (arg is vec4) {
      return new vec4(Math.atan(arg.x), Math.atan(arg.y), Math.atan(arg.z), Math.atan(arg.w));
    }  
  } else {
    if (arg is num) {
      return Math.atan2(arg, arg2);
    }
    if (arg is vec2) {
      return new vec2(Math.atan2(arg.x, arg2.x), Math.atan2(arg.y, arg2.y));
    }
    if (arg is vec3) {
      return new vec3(Math.atan2(arg.x, arg2.x), Math.atan2(arg.y, arg2.y), Math.atan2(arg.z, arg2.z));
    }
    if (arg is vec4) {
      return new vec4(Math.atan2(arg.x, arg2.x), Math.atan2(arg.y, arg2.y), Math.atan2(arg.z, arg2.z), Math.atan2(arg.w, arg2.w));
    }
  }
  
  throw new IllegalArgumentException(arg);
}
</pre>
</div>
</div>
<div class="method"><h4 id="makeLookAt">
<span class="show-code">Code</span>
<a href="VectorMath/mat4x4.html">mat4x4</a> <strong>makeLookAt</strong>(<a href="VectorMath/vec3.html">vec3</a> eyePosition, <a href="VectorMath/vec3.html">vec3</a> lookAtPosition, <a href="VectorMath/vec3.html">vec3</a> upDirection) <a class="anchor-link" href="#makeLookAt"
              title="Permalink to null.makeLookAt">#</a></h4>
<div class="doc">
<p>Returns an OpenGL LookAt matrix</p>
<pre class="source">
mat4x4 makeLookAt(vec3 eyePosition, vec3 lookAtPosition, vec3 upDirection) {
  vec3 z = lookAtPosition - eyePosition;
  z.normalize();
  vec3 x = upDirection.cross(z);
  x.normalize();
  vec3 y = z.cross(x);
  y.normalize();
  mat4x4 r = new mat4x4();
  r[0].xyz = x;
  r[1].xyz = y;
  r[2].xyz = z;
  r[3].w = 1.0;
  vec3 rotatedEye = r * eyePosition;
  r[3].xyz = rotatedEye;
  return r;
}
</pre>
</div>
</div>
<div class="method"><h4 id="makePerspective">
<span class="show-code">Code</span>
<a href="VectorMath/mat4x4.html">mat4x4</a> <strong>makePerspective</strong>(<a href="dart_core/num.html">num</a> fov_y_radians, <a href="dart_core/num.html">num</a> aspect_ratio, <a href="dart_core/num.html">num</a> znear, <a href="dart_core/num.html">num</a> zfar) <a class="anchor-link" href="#makePerspective"
              title="Permalink to null.makePerspective">#</a></h4>
<div class="doc">
<p>Returns an OpenGL perspective camera projection matrix</p>
<pre class="source">
mat4x4 makePerspective(num fov_y_radians, num aspect_ratio, num znear, num zfar) {
  num tan_fov = tan(fov_y_radians * 0.5);
  num height = 1.0/tan_fov;
  num width = height / aspect_ratio;
  num zf_sub_zn = zfar - znear;
  
  mat4x4 r = new mat4x4();
  r[0].x = width;
  r[1].y = height;
  r[2].z = zfar/zf_sub_zn;
  r[3].z = 1.0;
  r[3].w = 0.0;
  return r;
}
</pre>
</div>
</div>
<div class="method"><h4 id="makeOrthographic">
<span class="show-code">Code</span>
<a href="VectorMath/mat4x4.html">mat4x4</a> <strong>makeOrthographic</strong>(<a href="dart_core/num.html">num</a> left, <a href="dart_core/num.html">num</a> right, <a href="dart_core/num.html">num</a> bottom, <a href="dart_core/num.html">num</a> top, <a href="dart_core/num.html">num</a> znear, <a href="dart_core/num.html">num</a> zfar) <a class="anchor-link" href="#makeOrthographic"
              title="Permalink to null.makeOrthographic">#</a></h4>
<div class="doc">
<p>Returns an OpenGL orthographic camera projection matrix</p>
<pre class="source">
mat4x4 makeOrthographic(num left, num right, num bottom, num top, num znear, num zfar) {
  num rml = right - left;
  num rpl = right + left;
  num tmb = top - bottom;
  num tpb = top + bottom;
  num fmn = zfar - znear;
  num fpn = zfar + znear;
  
  mat4x4 r = new mat4x4();
  r[0].x = 2.0/rml;
  r[1].y = 2.0/tmb;
  r[2].z = 2.0/fmn;
  r[3].x = rpl/rml;
  r[3].y = tpb/tmb;
  r[3].z = fpn/fmn;
  r[3].w = 1.0;
  
  return r;
}
</pre>
</div>
</div>
<div class="method"><h4 id="makePlaneProjection">
<span class="show-code">Code</span>
<a href="VectorMath/mat4x4.html">mat4x4</a> <strong>makePlaneProjection</strong>(<a href="VectorMath/vec3.html">vec3</a> planeNormal, <a href="VectorMath/vec3.html">vec3</a> planePoint) <a class="anchor-link" href="#makePlaneProjection"
              title="Permalink to null.makePlaneProjection">#</a></h4>
<div class="doc">
<p>Returns a transformation matrix that transforms points onto the plane specified with 
<span class="param">planeNormal</span> and 
<span class="param">planePoint</span></p>
<pre class="source">
mat4x4 makePlaneProjection(vec3 planeNormal, vec3 planePoint) {
  vec4 v = new vec4(planeNormal, 0.0);
  mat4x4 outer = new mat4x4.outer(v, v);
  mat4x4 r = new mat4x4();
  r = r - outer;
  vec3 scaledNormal = (planeNormal * dot(planePoint, planeNormal));
  vec4 T = new vec4(scaledNormal, 1.0);
  r.col3 = T;
  return r;
}
</pre>
</div>
</div>
<div class="method"><h4 id="makePlaneReflection">
<span class="show-code">Code</span>
<a href="VectorMath/mat4x4.html">mat4x4</a> <strong>makePlaneReflection</strong>(<a href="VectorMath/vec3.html">vec3</a> planeNormal, <a href="VectorMath/vec3.html">vec3</a> planePoint) <a class="anchor-link" href="#makePlaneReflection"
              title="Permalink to null.makePlaneReflection">#</a></h4>
<div class="doc">
<p>Returns a transformation matrix that transforms points by reflecting them in the plane specified with 
<span class="param">planeNormal</span> and 
<span class="param">planePoint</span></p>
<pre class="source">
mat4x4 makePlaneReflection(vec3 planeNormal, vec3 planePoint) {
  vec4 v = new vec4(planeNormal, 0.0);
  mat4x4 outer = new mat4x4.outer(v,v);
  outer = outer * 2.0;
  mat4x4 r = new mat4x4();
  r = r - outer;
  vec3 scaledNormal = (planeNormal * 2.0 * dot(planePoint, planeNormal));
  vec4 T = new vec4(scaledNormal, 1.0);
  r.col3 = T;
  return r;
}
</pre>
</div>
</div>
<h3>Classes</h3>
          <div class="type">
          <h4>
            <a href="VectorMath/vec2.html"><strong>vec2</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/vec3.html"><strong>vec3</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/vec4.html"><strong>vec4</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/mat2x2.html"><strong>mat2x2</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/mat2x3.html"><strong>mat2x3</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/mat2x4.html"><strong>mat2x4</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/mat3x2.html"><strong>mat3x2</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/mat3x3.html"><strong>mat3x3</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/mat3x4.html"><strong>mat3x4</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/mat4x2.html"><strong>mat4x2</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/mat4x3.html"><strong>mat4x3</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/mat4x4.html"><strong>mat4x4</strong></a>
          </h4>
          </div>
          
          <div class="type">
          <h4>
            <a href="VectorMath/quat.html"><strong>quat</strong></a>
          </h4>
          </div>
          
        </div>
        <div class="clear"></div>
        </div>
        <div class="footer"></div>
        </body></html>