@defold-typescript/types 0.53.0 → 0.54.0

package/fixtures/defold-1.12.4/vmath_doc.json

@@ -0,0 +1,1814 @@
+{
+  "elements": [
+    {
+      "type": "FUNCTION",
+      "name": "vmath.vector",
+      "brief": "create a new vector from a table of values",
+      "description": "Creates a vector of arbitrary size. The vector is initialized\nwith numeric values from a table.\n<span class=\"icon-attention\"></span> The table values are converted to floating point\nvalues. If a value cannot be converted, a 0 is stored in that\nvalue position in the vector.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "new vector",
+          "types": ["vector"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "t",
+          "doc": "table of numbers",
+          "types": ["table"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "How to create a vector with custom data to be used for animation easing:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">values</span> <span class=\"o\">=</span> <span class=\"p\">{</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mf\">0.5</span><span class=\"p\">,</span> <span class=\"mi\">0</span> <span class=\"p\">}</span>\n<span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector</span><span class=\"p\">(</span><span class=\"n\">values</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector (size: 3)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">[</span><span class=\"mi\">2</span><span class=\"p\">])</span> <span class=\"c1\">--&gt; 0.5</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.vector3",
+      "brief": "creates a new zero vector",
+      "description": "Creates a new zero vector with all components set to 0.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "new zero vector",
+          "types": ["vector3"]
+        }
+      ],
+      "parameters": [],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">()</span>\n<span class=\"n\">pprint</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector3(0, 0, 0)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">.</span><span class=\"n\">x</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; 0</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.vector3",
+      "brief": "creates a new vector from scalar value",
+      "description": "Creates a new vector with all components set to the\nsupplied scalar value.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "new vector",
+          "types": ["vector3"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "n",
+          "doc": "scalar value to splat",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mf\">1.0</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector3(1, 1, 1)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">.</span><span class=\"n\">x</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; 1</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.vector3",
+      "brief": "creates a new vector from another existing vector",
+      "description": "Creates a new vector with all components set to the\ncorresponding values from the supplied vector. I.e.\nThis function creates a copy of the given vector.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "new vector",
+          "types": ["vector3"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v1",
+          "doc": "existing vector",
+          "types": ["vector3"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec1</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mf\">1.0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">vec2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"n\">vec1</span><span class=\"p\">)</span>\n<span class=\"kr\">if</span> <span class=\"n\">vec1</span> <span class=\"o\">==</span> <span class=\"n\">vec2</span> <span class=\"kr\">then</span>\n    <span class=\"c1\">-- yes, they are equal</span>\n    <span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec2</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector3(1, 1, 1)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.vector3",
+      "brief": "creates a new vector from its coordinates",
+      "description": "Creates a new vector with the components set to the\nsupplied values.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "new vector",
+          "types": ["vector3"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "x",
+          "doc": "x coordinate",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "y",
+          "doc": "y coordinate",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "z",
+          "doc": "z coordinate",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mf\">1.0</span><span class=\"p\">,</span> <span class=\"mf\">2.0</span><span class=\"p\">,</span> <span class=\"mf\">3.0</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector3(1, 2, 3)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"o\">-</span><span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector3(-1, -2, -3)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span> <span class=\"o\">*</span> <span class=\"mi\">2</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector3(2, 4, 6)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span> <span class=\"o\">+</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mf\">2.0</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector3(3, 4, 5)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span> <span class=\"o\">-</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mf\">2.0</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector3(-1, 0, 1)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.vector4",
+      "brief": "creates a new zero vector",
+      "description": "Creates a new zero vector with all components set to 0.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "new zero vector",
+          "types": ["vector4"]
+        }
+      ],
+      "parameters": [],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">()</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector4(0, 0, 0, 0)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">.</span><span class=\"n\">w</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; 0</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.vector4",
+      "brief": "creates a new vector from scalar value",
+      "description": "Creates a new vector with all components set to the\nsupplied scalar value.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "new vector",
+          "types": ["vector4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "n",
+          "doc": "scalar value to splat",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mf\">1.0</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector4(1, 1, 1, 1)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">.</span><span class=\"n\">w</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; 1</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.vector4",
+      "brief": "creates a new vector from another existing vector",
+      "description": "Creates a new vector with all components set to the\ncorresponding values from the supplied vector. I.e.\nThis function creates a copy of the given vector.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "new vector",
+          "types": ["vector4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v1",
+          "doc": "existing vector",
+          "types": ["vector4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vect1</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mf\">1.0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">vect2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"n\">vec1</span><span class=\"p\">)</span>\n<span class=\"kr\">if</span> <span class=\"n\">vec1</span> <span class=\"o\">==</span> <span class=\"n\">vec2</span> <span class=\"kr\">then</span>\n    <span class=\"c1\">-- yes, they are equal</span>\n    <span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec2</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector4(1, 1, 1, 1)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.vector4",
+      "brief": "creates a new vector from its coordinates",
+      "description": "Creates a new vector with the components set to the\nsupplied values.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "new vector",
+          "types": ["vector4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "x",
+          "doc": "x coordinate",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "y",
+          "doc": "y coordinate",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "z",
+          "doc": "z coordinate",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "w",
+          "doc": "w coordinate",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mf\">1.0</span><span class=\"p\">,</span> <span class=\"mf\">2.0</span><span class=\"p\">,</span> <span class=\"mf\">3.0</span><span class=\"p\">,</span> <span class=\"mf\">4.0</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector4(1, 2, 3, 4)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"o\">-</span><span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector4(-1, -2, -3, -4)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span> <span class=\"o\">*</span> <span class=\"mi\">2</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector4(2, 4, 6, 8)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span> <span class=\"o\">+</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mf\">2.0</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector4(3, 4, 5, 6)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vec</span> <span class=\"o\">-</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mf\">2.0</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector4(-1, 0, 1, 2)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.quat",
+      "brief": "creates a new identity quaternion",
+      "description": "Creates a new identity quaternion. The identity\nquaternion is equal to:\n<code>vmath.quat(0, 0, 0, 1)</code>",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "new identity quaternion",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">quat</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat</span><span class=\"p\">()</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">quat</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.quat(0, 0, 0, 1)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">quat</span><span class=\"p\">.</span><span class=\"n\">w</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; 1</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.quat",
+      "brief": "creates a new quaternion from another existing quaternion",
+      "description": "Creates a new quaternion with all components set to the\ncorresponding values from the supplied quaternion. I.e.\nThis function creates a copy of the given quaternion.",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "new quaternion",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "q1",
+          "doc": "existing quaternion",
+          "types": ["quaternion"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">quat1</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">quat2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat</span><span class=\"p\">(</span><span class=\"n\">quat1</span><span class=\"p\">)</span>\n<span class=\"kr\">if</span> <span class=\"n\">quat1</span> <span class=\"o\">==</span> <span class=\"n\">quat2</span> <span class=\"kr\">then</span>\n    <span class=\"c1\">-- yes, they are equal</span>\n    <span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">quat2</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.quat(1, 2, 3, 4)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.quat",
+      "brief": "creates a new quaternion from its coordinates",
+      "description": "Creates a new quaternion with the components set\naccording to the supplied parameter values.",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "new quaternion",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "x",
+          "doc": "x coordinate",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "y",
+          "doc": "y coordinate",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "z",
+          "doc": "z coordinate",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "w",
+          "doc": "w coordinate",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">quat</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">quat</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.quat(1, 2, 3, 4)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.quat_from_to",
+      "brief": "creates a quaternion to rotate between two unit vectors",
+      "description": "The resulting quaternion describes the rotation that,\nif applied to the first vector, would rotate the first\nvector to the second. The two vectors must be unit\nvectors (of length 1).\n<span class=\"icon-attention\"></span> The result is undefined if the two vectors point in opposite directions",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "quaternion representing the rotation from first to second vector",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v1",
+          "doc": "first unit vector, before rotation",
+          "types": ["vector3"],
+          "is_optional": "False"
+        },
+        {
+          "name": "v2",
+          "doc": "second unit vector, after rotation",
+          "types": ["vector3"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">v1</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">v2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">rot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_from_to</span><span class=\"p\">(</span><span class=\"n\">v1</span><span class=\"p\">,</span> <span class=\"n\">v2</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">rotate</span><span class=\"p\">(</span><span class=\"n\">rot</span><span class=\"p\">,</span> <span class=\"n\">v1</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector3(0, 0.99999994039536, 0)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.quat_axis_angle",
+      "brief": "creates a quaternion to rotate around a unit vector",
+      "description": "The resulting quaternion describes a rotation of <code>angle</code>\nradians around the axis described by the unit vector <code>v</code>.",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "quaternion representing the axis-angle rotation",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v",
+          "doc": "axis",
+          "types": ["vector3"],
+          "is_optional": "False"
+        },
+        {
+          "name": "angle",
+          "doc": "angle",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">axis</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">rot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_axis_angle</span><span class=\"p\">(</span><span class=\"n\">axis</span><span class=\"p\">,</span> <span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">rotate</span><span class=\"p\">(</span><span class=\"n\">rot</span><span class=\"p\">,</span> <span class=\"n\">vec</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector3(1, -1, -8.7422776573476e-08)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.quat_basis",
+      "brief": "creates a quaternion from three base unit vectors",
+      "description": "The resulting quaternion describes the rotation from the\nidentity quaternion (no rotation) to the coordinate system\nas described by the given x, y and z base unit vectors.",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "quaternion representing the rotation of the specified base vectors",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "x",
+          "doc": "x base vector",
+          "types": ["vector3"],
+          "is_optional": "False"
+        },
+        {
+          "name": "y",
+          "doc": "y base vector",
+          "types": ["vector3"],
+          "is_optional": "False"
+        },
+        {
+          "name": "z",
+          "doc": "z base vector",
+          "types": ["vector3"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- Axis rotated 90 degrees around z.</span>\n<span class=\"kd\">local</span> <span class=\"n\">rot_x</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">rot_y</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">z</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">rot1</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_basis</span><span class=\"p\">(</span><span class=\"n\">rot_x</span><span class=\"p\">,</span> <span class=\"n\">rot_y</span><span class=\"p\">,</span> <span class=\"n\">z</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">rot2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_from_to</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">),</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">))</span>\n<span class=\"kr\">if</span> <span class=\"n\">rot1</span> <span class=\"o\">==</span> <span class=\"n\">rot2</span> <span class=\"kr\">then</span>\n    <span class=\"c1\">-- These quaternions are equal!</span>\n    <span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">rot2</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.quat(0, 0, -0.70710676908493, 0.70710676908493)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.quat_rotation_x",
+      "brief": "creates a quaternion from rotation around x-axis",
+      "description": "The resulting quaternion describes a rotation of <code>angle</code>\nradians around the x-axis.",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "quaternion representing the rotation around the x-axis",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "angle",
+          "doc": "angle in radians around x-axis",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">rot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_x</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">rotate</span><span class=\"p\">(</span><span class=\"n\">rot</span><span class=\"p\">,</span> <span class=\"n\">vec</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector3(1, -1, -8.7422776573476e-08)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.quat_rotation_y",
+      "brief": "creates a quaternion from rotation around y-axis",
+      "description": "The resulting quaternion describes a rotation of <code>angle</code>\nradians around the y-axis.",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "quaternion representing the rotation around the y-axis",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "angle",
+          "doc": "angle in radians around y-axis",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">rot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_y</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">rotate</span><span class=\"p\">(</span><span class=\"n\">rot</span><span class=\"p\">,</span> <span class=\"n\">vec</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector3(-1, 1, 8.7422776573476e-08)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.quat_rotation_z",
+      "brief": "creates a quaternion from rotation around z-axis",
+      "description": "The resulting quaternion describes a rotation of <code>angle</code>\nradians around the z-axis.",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "quaternion representing the rotation around the z-axis",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "angle",
+          "doc": "angle in radians around z-axis",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">rot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_z</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">rotate</span><span class=\"p\">(</span><span class=\"n\">rot</span><span class=\"p\">,</span> <span class=\"n\">vec</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector3(-0.99999988079071, -1, 0)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4",
+      "brief": "creates a new identity matrix",
+      "description": "The resulting identity matrix describes a transform with\nno translation or rotation.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "identity matrix",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">mat</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4</span><span class=\"p\">()</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">mat</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.matrix4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)</span>\n<span class=\"c1\">-- get column 0:</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">mat</span><span class=\"p\">.</span><span class=\"n\">c0</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector4(1, 0, 0, 0)</span>\n<span class=\"c1\">-- get the value in row 3 and column 2:</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">mat</span><span class=\"p\">.</span><span class=\"n\">m32</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; 0</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4",
+      "brief": "creates a new matrix from another existing matrix",
+      "description": "Creates a new matrix with all components set to the\ncorresponding values from the supplied matrix. I.e.\nthe function creates a copy of the given matrix.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "matrix which is a copy of the specified matrix",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "m1",
+          "doc": "existing matrix",
+          "types": ["matrix4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">mat1</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_rotation_x</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">mat2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4</span><span class=\"p\">(</span><span class=\"n\">mat1</span><span class=\"p\">)</span>\n<span class=\"kr\">if</span> <span class=\"n\">mat1</span> <span class=\"o\">==</span> <span class=\"n\">mat2</span> <span class=\"kr\">then</span>\n    <span class=\"c1\">-- yes, they are equal</span>\n    <span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">mat2</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.matrix4(1, 0, 0, 0, 0, -1, 8.7422776573476e-08, 0, 0, -8.7422776573476e-08, -1, 0, 0, 0, 0, 1)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_frustum",
+      "brief": "creates a frustum matrix",
+      "description": "Constructs a frustum matrix from the given values. The left, right,\ntop and bottom coordinates of the view cone are expressed as distances\nfrom the center of the near clipping plane. The near and far coordinates\nare expressed as distances from the tip of the view frustum cone.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "matrix representing the frustum",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "left",
+          "doc": "coordinate for left clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "right",
+          "doc": "coordinate for right clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "bottom",
+          "doc": "coordinate for bottom clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "top",
+          "doc": "coordinate for top clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "near",
+          "doc": "coordinate for near clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "far",
+          "doc": "coordinate for far clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- Construct a projection frustum with a vertical and horizontal</span>\n<span class=\"c1\">-- FOV of 45 degrees. Useful for rendering a square view.</span>\n<span class=\"kd\">local</span> <span class=\"n\">proj</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_frustum</span><span class=\"p\">(</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1000</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_projection</span><span class=\"p\">(</span><span class=\"n\">proj</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_look_at",
+      "brief": "creates a look-at view matrix",
+      "description": "The resulting matrix is created from the supplied look-at parameters.\nThis is useful for constructing a view matrix for a camera or\nrendering in general.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "look-at matrix",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "eye",
+          "doc": "eye position",
+          "types": ["vector3"],
+          "is_optional": "False"
+        },
+        {
+          "name": "look_at",
+          "doc": "look-at position",
+          "types": ["vector3"],
+          "is_optional": "False"
+        },
+        {
+          "name": "up",
+          "doc": "up vector",
+          "types": ["vector3"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- Set up a perspective camera at z 100 with 45 degrees (pi/2) FOV</span>\n<span class=\"c1\">-- Aspect ratio 4:3</span>\n<span class=\"kd\">local</span> <span class=\"n\">eye</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">100</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">look_at</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">up</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">view</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_look_at</span><span class=\"p\">(</span><span class=\"n\">eye</span><span class=\"p\">,</span> <span class=\"n\">look_at</span><span class=\"p\">,</span> <span class=\"n\">up</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_view</span><span class=\"p\">(</span><span class=\"n\">view</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">proj</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_perspective</span><span class=\"p\">(</span><span class=\"mf\">3.141592</span><span class=\"o\">/</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"o\">/</span><span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1000</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_projection</span><span class=\"p\">(</span><span class=\"n\">proj</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_orthographic",
+      "brief": "creates an orthographic projection matrix",
+      "description": "Creates an orthographic projection matrix.\nThis is useful to construct a projection matrix for a camera or rendering in general.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "orthographic projection matrix",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "left",
+          "doc": "coordinate for left clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "right",
+          "doc": "coordinate for right clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "bottom",
+          "doc": "coordinate for bottom clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "top",
+          "doc": "coordinate for top clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "near",
+          "doc": "coordinate for near clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "far",
+          "doc": "coordinate for far clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- Set up an orthographic projection based on the width and height</span>\n<span class=\"c1\">-- of the game window.</span>\n<span class=\"kd\">local</span> <span class=\"n\">w</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_width</span><span class=\"p\">()</span>\n<span class=\"kd\">local</span> <span class=\"n\">h</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_height</span><span class=\"p\">()</span>\n<span class=\"kd\">local</span> <span class=\"n\">proj</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_orthographic</span><span class=\"p\">(</span><span class=\"o\">-</span> <span class=\"n\">w</span> <span class=\"o\">/</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"n\">w</span> <span class=\"o\">/</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"n\">h</span> <span class=\"o\">/</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"n\">h</span> <span class=\"o\">/</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">1000</span><span class=\"p\">,</span> <span class=\"mi\">1000</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_projection</span><span class=\"p\">(</span><span class=\"n\">proj</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_perspective",
+      "brief": "creates a perspective projection matrix",
+      "description": "Creates a perspective projection matrix.\nThis is useful to construct a projection matrix for a camera or rendering in general.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "perspective projection matrix",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "fov",
+          "doc": "angle of the full vertical field of view in radians",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "aspect",
+          "doc": "aspect ratio",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "near",
+          "doc": "coordinate for near clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "far",
+          "doc": "coordinate for far clipping plane",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- Set up a perspective camera at z 100 with 45 degrees (pi/2) FOV</span>\n<span class=\"c1\">-- Aspect ratio 4:3</span>\n<span class=\"kd\">local</span> <span class=\"n\">eye</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">100</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">look_at</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">up</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">view</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_look_at</span><span class=\"p\">(</span><span class=\"n\">eye</span><span class=\"p\">,</span> <span class=\"n\">look_at</span><span class=\"p\">,</span> <span class=\"n\">up</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_view</span><span class=\"p\">(</span><span class=\"n\">view</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">proj</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_perspective</span><span class=\"p\">(</span><span class=\"mf\">3.141592</span><span class=\"o\">/</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"o\">/</span><span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1000</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_projection</span><span class=\"p\">(</span><span class=\"n\">proj</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_quat",
+      "brief": "creates a matrix from a quaternion",
+      "description": "The resulting matrix describes the same rotation as the quaternion, but does not have any translation (also like the quaternion).",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "matrix represented by quaternion",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "q",
+          "doc": "quaternion to create matrix from",
+          "types": ["quaternion"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">quat</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_z</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">mat</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_quat</span><span class=\"p\">(</span><span class=\"n\">quat</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">mat</span> <span class=\"o\">*</span> <span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.matrix4_frustum(-1, 1, -1, 1, 1, 1000)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_axis_angle",
+      "brief": "creates a matrix from an axis and an angle",
+      "description": "The resulting matrix describes a rotation around the axis by the specified angle.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "matrix represented by axis and angle",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v",
+          "doc": "axis",
+          "types": ["vector3"],
+          "is_optional": "False"
+        },
+        {
+          "name": "angle",
+          "doc": "angle in radians",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">axis</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span> <span class=\"c1\">-- z-axis</span>\n<span class=\"kd\">local</span> <span class=\"n\">mat</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_axis_angle</span><span class=\"p\">(</span><span class=\"n\">axis</span><span class=\"p\">,</span> <span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">mat</span> <span class=\"o\">*</span> <span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector4(-0.99999994039536, -1.0000001192093, 0, 0)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_rotation_x",
+      "brief": "creates a matrix from rotation around x-axis",
+      "description": "The resulting matrix describes a rotation around the x-axis\nby the specified angle.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "matrix from rotation around x-axis",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "angle",
+          "doc": "angle in radians around x-axis",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">mat</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_rotation_x</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">mat</span> <span class=\"o\">*</span> <span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector4(1, -1, -8.7422776573476e-08, 0)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_rotation_y",
+      "brief": "creates a matrix from rotation around y-axis",
+      "description": "The resulting matrix describes a rotation around the y-axis\nby the specified angle.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "matrix from rotation around y-axis",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "angle",
+          "doc": "angle in radians around y-axis",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">mat</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_rotation_y</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">mat</span> <span class=\"o\">*</span> <span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector4(-1, 1, 8.7422776573476e-08, 0)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_rotation_z",
+      "brief": "creates a matrix from rotation around z-axis",
+      "description": "The resulting matrix describes a rotation around the z-axis\nby the specified angle.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "matrix from rotation around z-axis",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "angle",
+          "doc": "angle in radians around z-axis",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">mat</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_rotation_z</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">mat</span> <span class=\"o\">*</span> <span class=\"n\">vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector4(-0.99999994039536, -1.0000001192093, 0, 0)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_translation",
+      "brief": "creates a translation matrix from a position vector",
+      "description": "The resulting matrix describes a translation of a point\nin euclidean space.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "matrix from the supplied position vector",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "position",
+          "doc": "position vector to create matrix from",
+          "types": ["vector3", "vector4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- Set camera view from custom view and translation matrices</span>\n<span class=\"kd\">local</span> <span class=\"n\">mat_trans</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_translation</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">10</span><span class=\"p\">,</span> <span class=\"mi\">100</span><span class=\"p\">))</span>\n<span class=\"kd\">local</span> <span class=\"n\">mat_view</span>  <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_rotation_y</span><span class=\"p\">(</span><span class=\"o\">-</span><span class=\"mf\">3.141592</span><span class=\"o\">/</span><span class=\"mi\">4</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_view</span><span class=\"p\">(</span><span class=\"n\">mat_view</span> <span class=\"o\">*</span> <span class=\"n\">mat_trans</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.inv",
+      "brief": "calculates the inverse matrix.",
+      "description": "The resulting matrix is the inverse of the supplied matrix.\n<span class=\"icon-attention\"></span> For ortho-normal matrices, e.g. regular object transformation,\nuse <code>vmath.ortho_inv()</code> instead.\nThe specialized inverse for ortho-normalized matrices is much faster\nthan the general inverse.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "inverse of the supplied matrix",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "m1",
+          "doc": "matrix to invert",
+          "types": ["matrix4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">mat1</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_rotation_z</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">mat2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">inv</span><span class=\"p\">(</span><span class=\"n\">mat1</span><span class=\"p\">)</span>\n<span class=\"c1\">-- M * inv(M) = identity matrix</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">mat1</span> <span class=\"o\">*</span> <span class=\"n\">mat2</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.matrix4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.ortho_inv",
+      "brief": "calculates the inverse of an ortho-normal matrix.",
+      "description": "The resulting matrix is the inverse of the supplied matrix.\nThe supplied matrix has to be an ortho-normal matrix, e.g.\ndescribe a regular object transformation.\n<span class=\"icon-attention\"></span> For matrices that are not ortho-normal\nuse the general inverse <code>vmath.inv()</code> instead.",
+      "returnvalues": [
+        {
+          "name": "m",
+          "doc": "inverse of the supplied matrix",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "m1",
+          "doc": "ortho-normalized matrix to invert",
+          "types": ["matrix4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">mat1</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_rotation_z</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">mat2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">ortho_inv</span><span class=\"p\">(</span><span class=\"n\">mat1</span><span class=\"p\">)</span>\n<span class=\"c1\">-- M * inv(M) = identity matrix</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">mat1</span> <span class=\"o\">*</span> <span class=\"n\">mat2</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.matrix4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.dot",
+      "brief": "calculates the dot-product of two vectors",
+      "description": "The returned value is a scalar defined as:\n<code>P &#x22C5; Q = |P| |Q| cos &#x03B8;</code>\nwhere &#x03B8; is the angle between the vectors P and Q.\n<ul>\n<li>If the dot product is positive then the angle between the vectors is below 90 degrees.</li>\n<li>If the dot product is zero the vectors are perpendicular (at right-angles to each other).</li>\n<li>If the dot product is negative then the angle between the vectors is more than 90 degrees.</li>\n</ul>",
+      "returnvalues": [
+        {
+          "name": "n",
+          "doc": "dot product",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v1",
+          "doc": "first vector",
+          "types": ["vector3", "vector4"],
+          "is_optional": "False"
+        },
+        {
+          "name": "v2",
+          "doc": "second vector",
+          "types": ["vector3", "vector4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kr\">if</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">dot</span><span class=\"p\">(</span><span class=\"n\">vector1</span><span class=\"p\">,</span> <span class=\"n\">vector2</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"mi\">0</span> <span class=\"kr\">then</span>\n    <span class=\"c1\">-- The two vectors are perpendicular (at right-angles to each other)</span>\n    <span class=\"p\">...</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.length_sqr",
+      "brief": "calculates the squared length of a vector or quaternion",
+      "description": "Returns the squared length of the supplied vector or quaternion.",
+      "returnvalues": [
+        {
+          "name": "n",
+          "doc": "squared length",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v",
+          "doc": "value of which to calculate the squared length",
+          "types": ["vector3", "vector4", "quaternion"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kr\">if</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">length_sqr</span><span class=\"p\">(</span><span class=\"n\">vector1</span><span class=\"p\">)</span> <span class=\"o\">&lt;</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">length_sqr</span><span class=\"p\">(</span><span class=\"n\">vector2</span><span class=\"p\">)</span> <span class=\"kr\">then</span>\n    <span class=\"c1\">-- Vector 1 has less magnitude than vector 2</span>\n    <span class=\"p\">...</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.length",
+      "brief": "calculates the length of a vector or quaternion",
+      "description": "Returns the length of the supplied vector or quaternion.\nIf you are comparing the lengths of vectors or quaternions, you should compare\nthe length squared instead as it is slightly more efficient to calculate\n(it eliminates a square root calculation).",
+      "returnvalues": [
+        {
+          "name": "n",
+          "doc": "length",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v",
+          "doc": "value of which to calculate the length",
+          "types": ["vector3", "vector4", "quaternion"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kr\">if</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">length</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">velocity</span><span class=\"p\">)</span> <span class=\"o\">&lt;</span> <span class=\"n\">max_velocity</span> <span class=\"kr\">then</span>\n    <span class=\"c1\">-- The speed (velocity vector) is below max.</span>\n\n    <span class=\"c1\">-- TODO: max_velocity can be expressed as squared</span>\n    <span class=\"c1\">-- so we can compare with length_sqr() instead.</span>\n    <span class=\"p\">...</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.normalize",
+      "brief": "normalizes a vector",
+      "description": "Normalizes a vector, i.e. returns a new vector with the same\ndirection as the input vector, but with length 1.\n<span class=\"icon-attention\"></span> The length of the vector must be above 0, otherwise a\ndivision-by-zero will occur.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "new normalized vector",
+          "types": ["vector3", "vector4", "quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v1",
+          "doc": "vector to normalize",
+          "types": ["vector3", "vector4", "quaternion"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">norm_vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">normalize</span><span class=\"p\">(</span><span class=\"n\">vec</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">norm_vec</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector3(0.26726123690605, 0.5345224738121, 0.80178368091583)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">length</span><span class=\"p\">(</span><span class=\"n\">norm_vec</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; 0.99999994039536</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.cross",
+      "brief": "calculates the cross-product of two vectors",
+      "description": "Given two linearly independent vectors P and Q, the cross product,\nP &#x00D7; Q, is a vector that is perpendicular to both P and Q and\ntherefore normal to the plane containing them.\nIf the two vectors have the same direction (or have the exact\nopposite direction from one another, i.e. are not linearly independent)\nor if either one has zero length, then their cross product is zero.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "a new vector representing the cross product",
+          "types": ["vector3"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v1",
+          "doc": "first vector",
+          "types": ["vector3"],
+          "is_optional": "False"
+        },
+        {
+          "name": "v2",
+          "doc": "second vector",
+          "types": ["vector3"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec1</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">vec2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">cross</span><span class=\"p\">(</span><span class=\"n\">vec1</span><span class=\"p\">,</span> <span class=\"n\">vec2</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector3(0, 0, 1)</span>\n<span class=\"kd\">local</span> <span class=\"n\">vec3</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">cross</span><span class=\"p\">(</span><span class=\"n\">vec1</span><span class=\"p\">,</span> <span class=\"n\">vec3</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector3(0, -0, 0)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.lerp",
+      "brief": "lerps between two vectors",
+      "description": "Linearly interpolate between two vectors. The function\ntreats the vectors as positions and interpolates between\nthe positions in a straight line. Lerp is useful to describe\ntransitions from one place to another over time.\n<span class=\"icon-attention\"></span> The function does not clamp t between 0 and 1.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "the lerped vector",
+          "types": ["vector3", "vector4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "t",
+          "doc": "interpolation parameter, 0-1",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "v1",
+          "doc": "vector to lerp from",
+          "types": ["vector3", "vector4"],
+          "is_optional": "False"
+        },
+        {
+          "name": "v2",
+          "doc": "vector to lerp to",
+          "types": ["vector3", "vector4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kr\">function</span> <span class=\"nf\">init</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">)</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n<span class=\"kr\">end</span>\n\n<span class=\"kr\">function</span> <span class=\"nf\">update</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">,</span> <span class=\"n\">dt</span><span class=\"p\">)</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">+</span> <span class=\"n\">dt</span>\n    <span class=\"kr\">if</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">&lt;=</span> <span class=\"mi\">1</span> <span class=\"kr\">then</span>\n        <span class=\"kd\">local</span> <span class=\"n\">startpos</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">600</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n        <span class=\"kd\">local</span> <span class=\"n\">endpos</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">600</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n        <span class=\"kd\">local</span> <span class=\"n\">pos</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">lerp</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span><span class=\"p\">,</span> <span class=\"n\">startpos</span><span class=\"p\">,</span> <span class=\"n\">endpos</span><span class=\"p\">)</span>\n        <span class=\"n\">go</span><span class=\"p\">.</span><span class=\"n\">set_position</span><span class=\"p\">(</span><span class=\"n\">pos</span><span class=\"p\">,</span> <span class=\"s2\">&quot;go&quot;</span><span class=\"p\">)</span>\n    <span class=\"kr\">end</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.lerp",
+      "brief": "lerps between two quaternions",
+      "description": "Linearly interpolate between two quaternions. Linear\ninterpolation of rotations are only useful for small\nrotations. For interpolations of arbitrary rotations,\n<a href=\"/ref/vmath#vmath.slerp\">vmath.slerp</a> yields much better results.\n<span class=\"icon-attention\"></span> The function does not clamp t between 0 and 1.",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "the lerped quaternion",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "t",
+          "doc": "interpolation parameter, 0-1",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "q1",
+          "doc": "quaternion to lerp from",
+          "types": ["quaternion"],
+          "is_optional": "False"
+        },
+        {
+          "name": "q2",
+          "doc": "quaternion to lerp to",
+          "types": ["quaternion"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kr\">function</span> <span class=\"nf\">init</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">)</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n<span class=\"kr\">end</span>\n\n<span class=\"kr\">function</span> <span class=\"nf\">update</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">,</span> <span class=\"n\">dt</span><span class=\"p\">)</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">+</span> <span class=\"n\">dt</span>\n    <span class=\"kr\">if</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">&lt;=</span> <span class=\"mi\">1</span> <span class=\"kr\">then</span>\n        <span class=\"kd\">local</span> <span class=\"n\">startrot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_z</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">)</span>\n        <span class=\"kd\">local</span> <span class=\"n\">endrot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_z</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n        <span class=\"kd\">local</span> <span class=\"n\">rot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">lerp</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span><span class=\"p\">,</span> <span class=\"n\">startrot</span><span class=\"p\">,</span> <span class=\"n\">endrot</span><span class=\"p\">)</span>\n        <span class=\"n\">go</span><span class=\"p\">.</span><span class=\"n\">set_rotation</span><span class=\"p\">(</span><span class=\"n\">rot</span><span class=\"p\">,</span> <span class=\"s2\">&quot;go&quot;</span><span class=\"p\">)</span>\n    <span class=\"kr\">end</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.lerp",
+      "brief": "lerps between two numbers",
+      "description": "Linearly interpolate between two values. Lerp is useful\nto describe transitions from one value to another over time.\n<span class=\"icon-attention\"></span> The function does not clamp t between 0 and 1.",
+      "returnvalues": [
+        {
+          "name": "n",
+          "doc": "the lerped number",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "t",
+          "doc": "interpolation parameter, 0-1",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "n1",
+          "doc": "number to lerp from",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "n2",
+          "doc": "number to lerp to",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kr\">function</span> <span class=\"nf\">init</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">)</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n<span class=\"kr\">end</span>\n\n<span class=\"kr\">function</span> <span class=\"nf\">update</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">,</span> <span class=\"n\">dt</span><span class=\"p\">)</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">+</span> <span class=\"n\">dt</span>\n    <span class=\"kr\">if</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">&lt;=</span> <span class=\"mi\">1</span> <span class=\"kr\">then</span>\n        <span class=\"kd\">local</span> <span class=\"n\">startx</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n        <span class=\"kd\">local</span> <span class=\"n\">endx</span> <span class=\"o\">=</span> <span class=\"mi\">600</span>\n        <span class=\"kd\">local</span> <span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">lerp</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span><span class=\"p\">,</span> <span class=\"n\">startx</span><span class=\"p\">,</span> <span class=\"n\">endx</span><span class=\"p\">)</span>\n        <span class=\"n\">go</span><span class=\"p\">.</span><span class=\"n\">set_position</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"mi\">100</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">),</span> <span class=\"s2\">&quot;go&quot;</span><span class=\"p\">)</span>\n    <span class=\"kr\">end</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.slerp",
+      "brief": "slerps between two vectors",
+      "description": "Spherically interpolates between two vectors. The difference to\nlerp is that slerp treats the vectors as directions instead of\npositions in space.\nThe direction of the returned vector is interpolated by the angle\nand the magnitude is interpolated between the magnitudes of the\nfrom and to vectors.\n<span class=\"icon-attention\"></span> Slerp is computationally more expensive than lerp.\nThe function does not clamp t between 0 and 1.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "the slerped vector",
+          "types": ["vector3", "vector4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "t",
+          "doc": "interpolation parameter, 0-1",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "v1",
+          "doc": "vector to slerp from",
+          "types": ["vector3", "vector4"],
+          "is_optional": "False"
+        },
+        {
+          "name": "v2",
+          "doc": "vector to slerp to",
+          "types": ["vector3", "vector4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kr\">function</span> <span class=\"nf\">init</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">)</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n<span class=\"kr\">end</span>\n\n<span class=\"kr\">function</span> <span class=\"nf\">update</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">,</span> <span class=\"n\">dt</span><span class=\"p\">)</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">+</span> <span class=\"n\">dt</span>\n    <span class=\"kr\">if</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">&lt;=</span> <span class=\"mi\">1</span> <span class=\"kr\">then</span>\n        <span class=\"kd\">local</span> <span class=\"n\">startpos</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">600</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n        <span class=\"kd\">local</span> <span class=\"n\">endpos</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">600</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n        <span class=\"kd\">local</span> <span class=\"n\">pos</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">slerp</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span><span class=\"p\">,</span> <span class=\"n\">startpos</span><span class=\"p\">,</span> <span class=\"n\">endpos</span><span class=\"p\">)</span>\n        <span class=\"n\">go</span><span class=\"p\">.</span><span class=\"n\">set_position</span><span class=\"p\">(</span><span class=\"n\">pos</span><span class=\"p\">,</span> <span class=\"s2\">&quot;go&quot;</span><span class=\"p\">)</span>\n    <span class=\"kr\">end</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.slerp",
+      "brief": "slerps between two quaternions",
+      "description": "Slerp travels the torque-minimal path maintaining constant\nvelocity, which means it travels along the straightest path along\nthe rounded surface of a sphere. Slerp is useful for interpolation\nof rotations.\nSlerp travels the torque-minimal path, which means it travels\nalong the straightest path the rounded surface of a sphere.\n<span class=\"icon-attention\"></span> The function does not clamp t between 0 and 1.",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "the slerped quaternion",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "t",
+          "doc": "interpolation parameter, 0-1",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "q1",
+          "doc": "quaternion to slerp from",
+          "types": ["quaternion"],
+          "is_optional": "False"
+        },
+        {
+          "name": "q2",
+          "doc": "quaternion to slerp to",
+          "types": ["quaternion"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kr\">function</span> <span class=\"nf\">init</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">)</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n<span class=\"kr\">end</span>\n\n<span class=\"kr\">function</span> <span class=\"nf\">update</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">,</span> <span class=\"n\">dt</span><span class=\"p\">)</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">+</span> <span class=\"n\">dt</span>\n    <span class=\"kr\">if</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span> <span class=\"o\">&lt;=</span> <span class=\"mi\">1</span> <span class=\"kr\">then</span>\n        <span class=\"kd\">local</span> <span class=\"n\">startrot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_z</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">)</span>\n        <span class=\"kd\">local</span> <span class=\"n\">endrot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_z</span><span class=\"p\">(</span><span class=\"mf\">3.141592653</span><span class=\"p\">)</span>\n        <span class=\"kd\">local</span> <span class=\"n\">rot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">slerp</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">t</span><span class=\"p\">,</span> <span class=\"n\">startrot</span><span class=\"p\">,</span> <span class=\"n\">endrot</span><span class=\"p\">)</span>\n        <span class=\"n\">go</span><span class=\"p\">.</span><span class=\"n\">set_rotation</span><span class=\"p\">(</span><span class=\"n\">rot</span><span class=\"p\">,</span> <span class=\"s2\">&quot;go&quot;</span><span class=\"p\">)</span>\n    <span class=\"kr\">end</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.conj",
+      "brief": "calculates the conjugate of a quaternion",
+      "description": "Calculates the conjugate of a quaternion. The result is a\nquaternion with the same magnitudes but with the sign of\nthe imaginary (vector) parts changed:\n<code>q<super>*</super> = [w, -v]</code>",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "the conjugate",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "q1",
+          "doc": "quaternion of which to calculate the conjugate",
+          "types": ["quaternion"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">quat</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">conj</span><span class=\"p\">(</span><span class=\"n\">quat</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.quat(-1, -2, -3, 4)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.rotate",
+      "brief": "rotates a vector by a quaternion",
+      "description": "Returns a new vector from the supplied vector that is\nrotated by the rotation described by the supplied\nquaternion.",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "the rotated vector",
+          "types": ["vector3"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "q",
+          "doc": "quaternion",
+          "types": ["quaternion"],
+          "is_optional": "False"
+        },
+        {
+          "name": "v1",
+          "doc": "vector to rotate",
+          "types": ["vector3"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">vec</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">rot</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_z</span><span class=\"p\">(</span><span class=\"mf\">3.141592563</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">rotate</span><span class=\"p\">(</span><span class=\"n\">rot</span><span class=\"p\">,</span> <span class=\"n\">vec</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.vector3(-1.0000002384186, -0.99999988079071, 0)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.project",
+      "brief": "projects a vector onto another vector",
+      "description": "Calculates the extent the projection of the first vector onto the second.\nThe returned value is a scalar p defined as:\n<code>p = |P| cos &#x03B8; / |Q|</code>\nwhere &#x03B8; is the angle between the vectors P and Q.",
+      "returnvalues": [
+        {
+          "name": "n",
+          "doc": "the projected extent of the first vector onto the second",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v1",
+          "doc": "vector to be projected on the second",
+          "types": ["vector3"],
+          "is_optional": "False"
+        },
+        {
+          "name": "v2",
+          "doc": "vector onto which the first will be projected, must not have zero length",
+          "types": ["vector3"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">v1</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">v2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">project</span><span class=\"p\">(</span><span class=\"n\">v1</span><span class=\"p\">,</span> <span class=\"n\">v2</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; 0.5</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.mul_per_elem",
+      "brief": "performs an element wise multiplication of two vectors",
+      "description": "Performs an element wise multiplication between two vectors of the same type\nThe returned value is a vector defined as (e.g. for a vector3):\n<code>v = vmath.mul_per_elem(a, b) = vmath.vector3(a.x * b.x, a.y * b.y, a.z * b.z)</code>",
+      "returnvalues": [
+        {
+          "name": "v",
+          "doc": "multiplied vector",
+          "types": ["vector3", "vector4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "v1",
+          "doc": "first vector",
+          "types": ["vector3", "vector4"],
+          "is_optional": "False"
+        },
+        {
+          "name": "v2",
+          "doc": "second vector",
+          "types": ["vector3", "vector4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">blend_color</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">mul_per_elem</span><span class=\"p\">(</span><span class=\"n\">color1</span><span class=\"p\">,</span> <span class=\"n\">color2</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.quat_matrix4",
+      "brief": "creates a new quaternion from matrix4",
+      "description": "Creates a new quaternion with the components set\naccording to the supplied parameter values.",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "new quaternion",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "matrix",
+          "doc": "source matrix4",
+          "types": ["matrix4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_compose",
+      "brief": "creates a new matrix4 from translation, rotation and scale",
+      "description": "Creates a new matrix constructed from separate\ntranslation vector, roation quaternion and scale vector",
+      "returnvalues": [
+        {
+          "name": "matrix",
+          "doc": "new matrix4",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "translation",
+          "doc": "translation",
+          "types": ["vector3", "vector4"],
+          "is_optional": "False"
+        },
+        {
+          "name": "rotation",
+          "doc": "rotation",
+          "types": ["quaternion"],
+          "is_optional": "False"
+        },
+        {
+          "name": "scale",
+          "doc": "scale",
+          "types": ["vector3"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">translation</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">103</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">95</span><span class=\"p\">,</span> <span class=\"mi\">14</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">quat</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">scale</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mf\">0.5</span><span class=\"p\">,</span> <span class=\"mf\">0.5</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_compose</span><span class=\"p\">(</span><span class=\"n\">translation</span><span class=\"p\">,</span> <span class=\"n\">quat</span><span class=\"p\">,</span> <span class=\"n\">scale</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">result</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.matrix4(-25, -10, 11, 103, 28, -9.5, 2, -95, -10, 10, -4.5, 14, 0, 0, 0, 1)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_scale",
+      "brief": "creates a new matrix4 from scale vector",
+      "description": "Creates a new matrix constructed from scale vector",
+      "returnvalues": [
+        {
+          "name": "matrix",
+          "doc": "new matrix4",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "scale",
+          "doc": "scale",
+          "types": ["vector3"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">scale</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mf\">0.5</span><span class=\"p\">,</span> <span class=\"mf\">0.5</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_scale</span><span class=\"p\">(</span><span class=\"n\">scale</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">result</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.matrix4(1, 0, 0, 0, 0, 0.5, 0, 0, 0, 0, 0.5, 0, 0, 0, 0, 1)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_scale",
+      "brief": "creates a new matrix4 from uniform scale",
+      "description": "creates a new matrix4 from uniform scale",
+      "returnvalues": [
+        {
+          "name": "matrix",
+          "doc": "new matrix4",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "scale",
+          "doc": "scale",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_scale</span><span class=\"p\">(</span><span class=\"mf\">0.5</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">result</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.matrix4(0.5, 0, 0, 0, 0, 0.5, 0, 0, 0, 0, 0.5, 0, 0, 0, 0, 1)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.matrix4_scale",
+      "brief": "creates a new matrix4 from three scale components",
+      "description": "Creates a new matrix4 from three scale components",
+      "returnvalues": [
+        {
+          "name": "matrix",
+          "doc": "new matrix4",
+          "types": ["matrix4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "scale_x",
+          "doc": "scale along X axis",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "scale_y",
+          "doc": "sclae along Y axis",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "scale_z",
+          "doc": "scale along Z asis",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_scale</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mf\">0.5</span><span class=\"p\">,</span> <span class=\"mf\">0.5</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">result</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.matrix4(1, 0, 0, 0, 0, 0.5, 0, 0, 0, 0, 0.5, 0, 0, 0, 0, 1)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.clamp",
+      "brief": "clamp input value in range [min, max] and return clamped value",
+      "description": "Clamp input value to be in range of [min, max]. In case if input value has vector3|vector4 type\nreturn new vector3|vector4 with clamped value at every vector's element.\nMin/max arguments can be vector3|vector4. In that case clamp excuted per every vector's element",
+      "returnvalues": [
+        {
+          "name": "clamped_value",
+          "doc": "Clamped value or vector",
+          "types": ["number", "vector3", "vector4"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "value",
+          "doc": "Input value or vector of values",
+          "types": ["number", "vector3", "vector4"],
+          "is_optional": "False"
+        },
+        {
+          "name": "min",
+          "doc": "Min value(s) border",
+          "types": ["number", "vector3", "vector4"],
+          "is_optional": "False"
+        },
+        {
+          "name": "max",
+          "doc": "Max value(s) border",
+          "types": ["number", "vector3", "vector4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">value1</span> <span class=\"o\">=</span> <span class=\"mi\">56</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">clamp</span><span class=\"p\">(</span><span class=\"n\">value1</span><span class=\"p\">,</span> <span class=\"mi\">89</span><span class=\"p\">,</span> <span class=\"mi\">134</span><span class=\"p\">))</span> <span class=\"o\">-&gt;</span> <span class=\"mi\">89</span>\n<span class=\"kd\">local</span> <span class=\"n\">v2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">190</span><span class=\"p\">,</span> <span class=\"mi\">190</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">10</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">clamp</span><span class=\"p\">(</span><span class=\"n\">v2</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">50</span><span class=\"p\">,</span> <span class=\"mi\">150</span><span class=\"p\">))</span> <span class=\"o\">-&gt;</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">150</span><span class=\"p\">,</span> <span class=\"mi\">150</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">10</span><span class=\"p\">)</span>\n<span class=\"kd\">local</span> <span class=\"n\">v3</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mi\">30</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">30</span><span class=\"p\">,</span> <span class=\"mi\">45</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">clamp</span><span class=\"p\">(</span><span class=\"n\">v3</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">20</span><span class=\"p\">))</span> <span class=\"o\">-&gt;</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mi\">20</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">20</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n\n<span class=\"kd\">local</span> <span class=\"n\">min_v</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">10</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">10</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">clamp</span><span class=\"p\">(</span><span class=\"n\">v3</span><span class=\"p\">,</span> <span class=\"n\">min_v</span><span class=\"p\">,</span> <span class=\"mi\">20</span><span class=\"p\">))</span> <span class=\"o\">-&gt;</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector4</span><span class=\"p\">(</span><span class=\"mi\">20</span><span class=\"p\">,</span> <span class=\"o\">-</span><span class=\"mi\">10</span><span class=\"p\">,</span> <span class=\"mi\">20</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.quat_to_euler",
+      "brief": "converts a quaternion into euler angles",
+      "description": "Converts a quaternion into euler angles (r0, r1, r2), based on YZX rotation order.\nTo handle gimbal lock (singularity at r1 ~ +/- 90 degrees), the cut off is at r0 = +/- 88.85 degrees, which snaps to +/- 90.\nThe provided quaternion is expected to be normalized.\nThe error is guaranteed to be less than +/- 0.02 degrees",
+      "returnvalues": [
+        {
+          "name": "x",
+          "doc": "euler angle x in degrees",
+          "types": ["number"]
+        },
+        {
+          "name": "y",
+          "doc": "euler angle y in degrees",
+          "types": ["number"]
+        },
+        {
+          "name": "z",
+          "doc": "euler angle z in degrees",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "q",
+          "doc": "source quaternion",
+          "types": ["quaternion"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">q</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_z</span><span class=\"p\">(</span><span class=\"nb\">math.rad</span><span class=\"p\">(</span><span class=\"mi\">90</span><span class=\"p\">))</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_to_euler</span><span class=\"p\">(</span><span class=\"n\">q</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; 0 0 90</span>\n\n<span class=\"kd\">local</span> <span class=\"n\">q2</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_y</span><span class=\"p\">(</span><span class=\"nb\">math.rad</span><span class=\"p\">(</span><span class=\"mi\">45</span><span class=\"p\">))</span> <span class=\"o\">*</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_rotation_z</span><span class=\"p\">(</span><span class=\"nb\">math.rad</span><span class=\"p\">(</span><span class=\"mi\">90</span><span class=\"p\">))</span>\n<span class=\"kd\">local</span> <span class=\"n\">v</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">quat_to_euler</span><span class=\"p\">(</span><span class=\"n\">q2</span><span class=\"p\">))</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">v</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.vector3(0, 45, 90)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "vmath.euler_to_quat",
+      "brief": "converts euler angles into a quaternion",
+      "description": "Converts euler angles (x, y, z) in degrees into a quaternion\nThe error is guaranteed to be less than 0.001.\nIf the first argument is vector3, its values are used as x, y, z angles.",
+      "returnvalues": [
+        {
+          "name": "q",
+          "doc": "quaternion describing an equivalent rotation (231 (YZX) rotation sequence)",
+          "types": ["quaternion"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "x",
+          "doc": "rotation around x-axis in degrees or vector3 with euler angles in degrees",
+          "types": ["number", "vector3"],
+          "is_optional": "False"
+        },
+        {
+          "name": "y",
+          "doc": "rotation around y-axis in degrees",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "z",
+          "doc": "rotation around z-axis in degrees",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">q</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">euler_to_quat</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">45</span><span class=\"p\">,</span> <span class=\"mi\">90</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">q</span><span class=\"p\">)</span> <span class=\"c1\">--&gt; vmath.quat(0.27059805393219, 0.27059805393219, 0.65328145027161, 0.65328145027161)</span>\n\n<span class=\"kd\">local</span> <span class=\"n\">v</span> <span class=\"o\">=</span> <span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">vector3</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">90</span><span class=\"p\">)</span>\n<span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">euler_to_quat</span><span class=\"p\">(</span><span class=\"n\">v</span><span class=\"p\">))</span> <span class=\"c1\">--&gt; vmath.quat(0, 0, 0.70710676908493, 0.70710676908493)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    }
+  ],
+  "info": {
+    "namespace": "vmath",
+    "name": "Vector math",
+    "brief": "Vector math API documentation",
+    "description": "Functions for mathematical operations on vectors, matrices and quaternions.\n\n- The vector types (`vmath.vector3` and `vmath.vector4`) supports addition and subtraction\n  with vectors of the same type. Vectors can be negated and multiplied (scaled) or divided by numbers.\n- The quaternion type (`vmath.quat`) supports multiplication with other quaternions.\n- The matrix type (`vmath.matrix4`) can be multiplied with numbers, other matrices\n  and `vmath.vector4` values.\n- All types performs equality comparison by each component value.\n\nThe following components are available for the various types:\n\nvector3\n: `x`, `y` and `z`. Example: `v.y`\n\nvector4\n: `x`, `y`, `z`, and `w`. Example: `v.w`\n\nquaternion\n: `x`, `y`, `z`, and `w`. Example: `q.w`\n\nmatrix4\n: `m00` to `m33` where the first number is the row (starting from 0) and the second\nnumber is the column. Columns can be accessed with `c0` to `c3`, returning a `vector4`.\nExample: `m.m21` which is equal to `m.c1.z`\n\nvector\n: indexed by number 1 to the vector length. Example: `v[3]`",
+    "path": "engine/script/src/script_vmath.cpp",
+    "file": "",
+    "notes": [],
+    "language": "Lua"
+  }
+}